excuter(cpu/cuda):constant int8,cuda

miaobyte · miaobyte · commit ef5123365561 · 2025-03-19T13:25:37.000+08:00
diff --git a/doc/excuter/op-mem-ompsimd/list.md b/doc/excuter/op-mem-ompsimd/list.md
@@ -4,7 +4,7 @@
 
 | Operation | Author | Func Def | Math Formula | IR Instruction |
 |-----------|--------|------------|--------------|----------------|
-| concat |  none  | concat(listtensor<any> tensors, var<int32> axis)->(tensor<any> Tresult) | Tresult = concat([T1, T2...], axis=3) | concat(listtensor<any> tensors, var<int32> axis)->(tensor<any> Tresult) |
+| concat |  none  | concat()->() | Tresult = concat([T1, T2...], axis=3) | concat()->() |
 | constant | miaobyte | constant(tensor<any> t, var<any> value)->() | print(T1) | constant(tensor<any> t, var<any> value)->() |
 | print | miaobyte | print(tensor<any> )->() | print(T1) | print(tensor<any> )->() |
 | print | miaobyte | print(tensor<any> , var<string> )->() | print(T1) | print(tensor<any> , var<string> )->() |
diff --git a/excuter/cpp-common/src/deepx/mem/mem.hpp b/excuter/cpp-common/src/deepx/mem/mem.hpp
@@ -173,12 +173,31 @@ namespace deepx::mem
                     result->data = ptr_tensor->data;
                     break;
                 }
+                case Precision::Int64:
+                {
+                    auto ptr_tensor = std::static_pointer_cast<Tensor<int64_t>>(ptr);
+                    result->data = ptr_tensor->data;
+                    break;
+                }
                 case Precision::Int32:
                 {
                     auto ptr_tensor = std::static_pointer_cast<Tensor<int32_t>>(ptr);
                     result->data = ptr_tensor->data;
                     break;
                 }
+                case Precision::Int16:
+                {
+                    auto ptr_tensor = std::static_pointer_cast<Tensor<int16_t>>(ptr);
+                    result->data = ptr_tensor->data;
+                    break;
+                }   
+                case Precision::Int8:
+                {
+                    auto ptr_tensor = std::static_pointer_cast<Tensor<int8_t>>(ptr);
+                    result->data = ptr_tensor->data;
+                    break;
+                }
+                
                 default:
                     throw std::runtime_error("Unsupported dtype: " + precision_str(ptr->shape.dtype));
             }
diff --git a/excuter/cpp-common/src/deepx/tf/tf.cpp b/excuter/cpp-common/src/deepx/tf/tf.cpp
@@ -446,10 +446,6 @@ namespace deepx::tf
         return true;
     }
 
-    void TF::funcdef(int polymorphism)
-    {
-        // 基类的默认实现为空
-        // 派生类需要重写这个函数来定义具体的函数签名
-    }
+
  
 }
diff --git a/excuter/cpp-common/src/deepx/tf/tf.hpp b/excuter/cpp-common/src/deepx/tf/tf.hpp
@@ -53,8 +53,7 @@ namespace deepx::tf
             throw NotImplementError(name);
         }
         virtual string math_formula() const;
-        virtual void funcdef(int polymorphism=0);
-        
+
         void parse(const string &str);
         std::string to_string(bool show_extra=false, bool show_name=true) const;
         void init(const string &opname,
diff --git a/excuter/op-mem-cuda/src/client/tfs.cpp b/excuter/op-mem-cuda/src/client/tfs.cpp
@@ -20,7 +20,7 @@ namespace deepx::tf
                                                       {
                                                           Param("name", DataCategory::Var, Precision::Any),
                                                       })));
-         tffactory.add_tf(std::make_shared<VecSet>(
+        tffactory.add_tf(std::make_shared<VecSet>(
             vector<Param>(
                 {
                     Param("value", DataCategory::Vector, Precision::Any),
@@ -29,8 +29,22 @@ namespace deepx::tf
                 {
                     Param("name", DataCategory::Vector, Precision::Any),
                 })));
-        tffactory.add_tf(std::make_shared<NewTensor>(0));
-        tffactory.add_tf(std::make_shared<NewTensor>(1));
+        tffactory.add_tf(std::make_shared<NewTensor>(vector<Param>(
+                                                         {
+                                                             Param("shape", DataCategory::Vector, Precision::Int32),
+                                                         }),
+                                                     vector<Param>(
+                                                         {
+                                                             Param("tensor1", DataCategory::Tensor, Precision::Any),
+                                                         })));
+        tffactory.add_tf(std::make_shared<NewTensor>(vector<Param>(
+                                                         {
+                                                             Param("shape", DataCategory::Var, Precision::String),
+                                                         }),
+                                                     vector<Param>(
+                                                         {
+                                                             Param("tensor1", DataCategory::Tensor, Precision::Any),
+                                                         })));
         // opfactory.add_op(DelTensor<float>());
     }
 
@@ -41,11 +55,11 @@ namespace deepx::tf
         //     opfactory.add_op(Uniform<double>());
 
         tffactory.add_tf(std::make_shared<Constant<miaobyte>>(vector<Param>(
-                                                        {
-                                                            Param("t", DataCategory::Tensor, Precision::Any),
-                                                            Param("value", DataCategory::Var, Precision::Any),
-                                                        }),
-                                                    vector<Param>()));
+                                                                  {
+                                                                      Param("t", DataCategory::Tensor, Precision::Any),
+                                                                      Param("value", DataCategory::Var, Precision::Any),
+                                                                  }),
+                                                              vector<Param>()));
 
         //     opfactory.add_op(Arange<float>());
         //     opfactory.add_op(Arange<double>());
diff --git a/excuter/op-mem-cuda/src/deepx/tf/arg.hpp b/excuter/op-mem-cuda/src/deepx/tf/arg.hpp
@@ -27,11 +27,7 @@ namespace deepx::tf
                 throw std::runtime_error("Invalid name: " + this->name);
             }
         }
-        void funcdef(int polymorphism = 0) override
-        {
-            this->args.push_back(Param("value", DataCategory::Var, Precision::Any));
-            this->returns.push_back(Param("name", DataCategory::Var, Precision::Any));
-        }
+
         string math_formula() const override
         {
             return "var argname = argvalue";
@@ -96,11 +92,7 @@ namespace deepx::tf
                 throw std::runtime_error("Invalid name: " + this->name);
             }
         }
-        void funcdef(int polymorphism = 0) override
-        {
-            this->args.push_back(Param("shape", DataCategory::Vector, Precision::Any));
-            this->returns.push_back(Param("name", DataCategory::Vector, Precision::Any));
-        }
+
         string math_formula() const override
         {
             return "shape = [3  4  5]";
diff --git a/excuter/op-mem-cuda/src/deepx/tf/new.hpp b/excuter/op-mem-cuda/src/deepx/tf/new.hpp
@@ -14,18 +14,14 @@ namespace deepx::tf
     class NewTensor : public TF
     {
     public:
-        NewTensor()
+        NewTensor(vector<Param> args, vector<Param> returns)
         {
             this->name = "newtensor";
-            this->funcdef();
+            this->args = args;
+            this->returns = returns;
         }
-        // support polymorphism=0 or 1
-        NewTensor(int polymorphism = 0)
-        {
-            this->name = "newtensor";
-            this->funcdef(polymorphism);
-        }
-        NewTensor(string text, bool call = false)
+ 
+        NewTensor(string text)
         {
             this->parse(text);
             if (this->name != "newtensor")
@@ -146,22 +142,6 @@ namespace deepx::tf
             return 0;
         };
 
-        void funcdef(int polymorphism = 0) override
-        {
-            switch (polymorphism)
-            {
-
-            case 1:
-                this->args.push_back(Param("shape", DataCategory::Var, Precision::String));
-                break;
-            case 0:
-            default:
-                this->args.push_back(Param("shape", DataCategory::Vector, Precision::Int32));
-                break;
-            }
-            this->returns.push_back(Param("tensor1", DataCategory::Tensor, Precision::Any));
-        };
-
         string math_formula() const override
         {
             return "T1 = zeros(shape)";
@@ -174,7 +154,7 @@ namespace deepx::tf
         CopyTensor()
         {
             this->name = "copytensor";
-            this->funcdef();
+
         }
         CopyTensor(string text)
         {
@@ -192,11 +172,7 @@ namespace deepx::tf
             //  tensorfunc::copytensor(*src,*dst);
             return 0;
         }
-        void funcdef(int polymorphism = 0) override
-        {
-            this->args.push_back(Param("src", DataCategory::Tensor, Precision::Any));
-            this->args.push_back(Param("dst", DataCategory::Tensor, Precision::Any));
-        }
+
         string math_formula() const override
         {
             return "T2.data = T1.data";
@@ -209,7 +185,7 @@ namespace deepx::tf
         CloneTensor()
         {
             this->name = "clonetensor";
-            this->funcdef();
+
         }
         int run(mem::Mem &mem, string &error) override
         {
@@ -220,11 +196,7 @@ namespace deepx::tf
             return 0;
         }
 
-        void funcdef(int polymorphism = 0) override
-        {
-            this->args.push_back(Param("src", DataCategory::Tensor, Precision::Any));
-            this->args.push_back(Param("dst", DataCategory::Var, Precision::String));
-        }
+
         string math_formula() const override
         {
             return "T2 = T1.clone()";
@@ -237,7 +209,7 @@ namespace deepx::tf
         DelTensor()
         {
             this->name = "deltensor";
-            this->funcdef();
+
         }
         DelTensor(string text)
         {
@@ -253,10 +225,7 @@ namespace deepx::tf
             mem.delete_tensor(name);
             return 0;
         }
-        void funcdef(int polymorphism=0) override
-        {
-            this->args.push_back(Param("tensor1", DataCategory::Tensor, Precision::Any));
-        }
+
         string math_formula() const override
         {
             return "del T1";
diff --git a/excuter/op-mem-cuda/src/deepx/tf/print.hpp b/excuter/op-mem-cuda/src/deepx/tf/print.hpp
@@ -51,14 +51,7 @@ namespace deepx::tf
             }
             return 0;
         }
-        void funcdef(int polymorphism = 0) override
-        {
-            this->args.push_back(Param("tensor1", DataCategory::Tensor, Precision::Any));
-            if (polymorphism == 0)
-            {
-                this->args.push_back(Param("format", DataCategory::Var, Precision::String));
-            }
-        }
+
         string math_formula() const override
         {
             return "print(T1)";
diff --git a/excuter/op-mem-ompsimd/src/client/tfs.cpp b/excuter/op-mem-ompsimd/src/client/tfs.cpp
@@ -33,8 +33,22 @@ namespace deepx::tf
                 {
                     Param("name", DataCategory::Vector, Precision::Any),
                 })));
-        tffactory.add_tf(std::make_shared<NewTensor>(0));
-        tffactory.add_tf(std::make_shared<NewTensor>(1));
+        tffactory.add_tf(std::make_shared<NewTensor>(vector<Param>(
+            {
+                Param("shape", DataCategory::Vector, Precision::Int32),
+            }),
+            vector<Param>(
+                {
+                    Param("tensor1", DataCategory::Tensor, Precision::Any),
+                })));
+         tffactory.add_tf(std::make_shared<NewTensor>(vector<Param>(
+            {
+                Param("shape", DataCategory::Var, Precision::String),
+            }),
+            vector<Param>(
+                {
+                    Param("tensor1", DataCategory::Tensor, Precision::Any),
+                })));
         // opfactory.add_op(DelTensor<float>());
     }
 
diff --git a/excuter/op-mem-ompsimd/src/deepx/tf/arg.hpp b/excuter/op-mem-ompsimd/src/deepx/tf/arg.hpp
@@ -28,11 +28,7 @@ namespace deepx::tf
                 throw std::runtime_error("Invalid name: " + this->name);
             }
         }
-        void funcdef(int polymorphism = 0) override
-        {
-            this->args.push_back(Param("value", DataCategory::Var, Precision::Any));
-            this->returns.push_back(Param("name", DataCategory::Var, Precision::Any));
-        }
+
         string math_formula() const override
         {
             return "var argname = argvalue";
@@ -97,11 +93,7 @@ namespace deepx::tf
                 throw std::runtime_error("Invalid name: " + this->name);
             }
         }
-        void funcdef(int polymorphism = 0) override
-        {
-            this->args.push_back(Param("shape", DataCategory::Vector, Precision::Any));
-            this->returns.push_back(Param("name", DataCategory::Vector, Precision::Any));
-        }
+
         string math_formula() const override
         {
             return "shape = [3  4  5]";
diff --git a/excuter/op-mem-ompsimd/src/deepx/tf/changeshape.hpp b/excuter/op-mem-ompsimd/src/deepx/tf/changeshape.hpp
@@ -15,7 +15,7 @@ namespace deepx::tf
         Concat()
         {
             this->name=_name;
-            this->funcdef();
+
         }
         Concat(string text)
         {
@@ -24,12 +24,7 @@ namespace deepx::tf
                 throw std::runtime_error("Invalid name: "+this->name);
             }
         }
-        void funcdef(int polymorphism=0) override
-        {
-            this->args.push_back(Param("tensors", DataCategory::ListTensor, Precision::Any));
-            this->args.push_back(Param("axis", DataCategory::Var, Precision::Int32));
-            this->returns.push_back(Param("Tresult", DataCategory::Tensor, Precision::Any));
-        }
+
         string math_formula() const override
         {
             return "Tresult = concat([T1, T2...], axis=3)";
diff --git a/excuter/op-mem-ompsimd/src/deepx/tf/new.hpp b/excuter/op-mem-ompsimd/src/deepx/tf/new.hpp
diff --git a/excuter/op-mem-ompsimd/src/deepx/tf/print.hpp b/excuter/op-mem-ompsimd/src/deepx/tf/print.hpp

Original file line number	Diff line number	Diff line change
`@@ -446,10 +446,6 @@ namespace deepx::tf`
`446`	`446`	`return true;`
`447`	`447`	`}`
`448`	`448`
`449`		`- void TF::funcdef(int polymorphism)`
`450`		`- {`
`451`		`- // 基类的默认实现为空`
`452`		`- // 派生类需要重写这个函数来定义具体的函数签名`
`453`		`- }`
	`449`	`+`
`454`	`450`
`455`	`451`	`}`
Original file line number	Diff line number	Diff line change
`@@ -27,11 +27,7 @@ namespace deepx::tf`
`27`	`27`	`throw std::runtime_error("Invalid name: " + this->name);`
`28`	`28`	`}`
`29`	`29`	`}`
`30`		`- void funcdef(int polymorphism = 0) override`
`31`		`- {`
`32`		`- this->args.push_back(Param("value", DataCategory::Var, Precision::Any));`
`33`		`- this->returns.push_back(Param("name", DataCategory::Var, Precision::Any));`
`34`		`- }`
	`30`	`+`
`35`	`31`	`string math_formula() const override`
`36`	`32`	`{`
`37`	`33`	`return "var argname = argvalue";`
`@@ -96,11 +92,7 @@ namespace deepx::tf`
`96`	`92`	`throw std::runtime_error("Invalid name: " + this->name);`
`97`	`93`	`}`
`98`	`94`	`}`
`99`		`- void funcdef(int polymorphism = 0) override`
`100`		`- {`
`101`		`- this->args.push_back(Param("shape", DataCategory::Vector, Precision::Any));`
`102`		`- this->returns.push_back(Param("name", DataCategory::Vector, Precision::Any));`
`103`		`- }`
	`95`	`+`
`104`	`96`	`string math_formula() const override`
`105`	`97`	`{`
`106`	`98`	`return "shape = [3 4 5]";`
Original file line number	Diff line number	Diff line change
`@@ -14,18 +14,14 @@ namespace deepx::tf`
`14`	`14`	`class NewTensor : public TF`
`15`	`15`	`{`
`16`	`16`	`public:`
`17`		`- NewTensor()`
	`17`	`+ NewTensor(vector<Param> args, vector<Param> returns)`
`18`	`18`	`{`
`19`	`19`	`this->name = "newtensor";`
`20`		`- this->funcdef();`
	`20`	`+ this->args = args;`
	`21`	`+ this->returns = returns;`
`21`	`22`	`}`
`22`		`- // support polymorphism=0 or 1`
`23`		`- NewTensor(int polymorphism = 0)`
`24`		`- {`
`25`		`- this->name = "newtensor";`
`26`		`- this->funcdef(polymorphism);`
`27`		`- }`
`28`		`- NewTensor(string text, bool call = false)`
	`23`	`+`
	`24`	`+ NewTensor(string text)`
`29`	`25`	`{`
`30`	`26`	`this->parse(text);`
`31`	`27`	`if (this->name != "newtensor")`
`@@ -146,22 +142,6 @@ namespace deepx::tf`
`146`	`142`	`return 0;`
`147`	`143`	`};`
`148`	`144`
`149`		`- void funcdef(int polymorphism = 0) override`
`150`		`- {`
`151`		`- switch (polymorphism)`
`152`		`- {`
`153`		`-`
`154`		`- case 1:`
`155`		`- this->args.push_back(Param("shape", DataCategory::Var, Precision::String));`
`156`		`- break;`
`157`		`- case 0:`
`158`		`- default:`
`159`		`- this->args.push_back(Param("shape", DataCategory::Vector, Precision::Int32));`
`160`		`- break;`
`161`		`- }`
`162`		`- this->returns.push_back(Param("tensor1", DataCategory::Tensor, Precision::Any));`
`163`		`- };`
`164`		`-`
`165`	`145`	`string math_formula() const override`
`166`	`146`	`{`
`167`	`147`	`return "T1 = zeros(shape)";`
`@@ -174,7 +154,7 @@ namespace deepx::tf`
`174`	`154`	`CopyTensor()`
`175`	`155`	`{`
`176`	`156`	`this->name = "copytensor";`
`177`		`- this->funcdef();`
	`157`	`+`
`178`	`158`	`}`
`179`	`159`	`CopyTensor(string text)`
`180`	`160`	`{`
`@@ -192,11 +172,7 @@ namespace deepx::tf`
`192`	`172`	`// tensorfunc::copytensor(src,dst);`
`193`	`173`	`return 0;`
`194`	`174`	`}`
`195`		`- void funcdef(int polymorphism = 0) override`
`196`		`- {`
`197`		`- this->args.push_back(Param("src", DataCategory::Tensor, Precision::Any));`
`198`		`- this->args.push_back(Param("dst", DataCategory::Tensor, Precision::Any));`
`199`		`- }`
	`175`	`+`
`200`	`176`	`string math_formula() const override`
`201`	`177`	`{`
`202`	`178`	`return "T2.data = T1.data";`
`@@ -209,7 +185,7 @@ namespace deepx::tf`
`209`	`185`	`CloneTensor()`
`210`	`186`	`{`
`211`	`187`	`this->name = "clonetensor";`
`212`		`- this->funcdef();`
	`188`	`+`
`213`	`189`	`}`
`214`	`190`	`int run(mem::Mem &mem, string &error) override`
`215`	`191`	`{`
`@@ -220,11 +196,7 @@ namespace deepx::tf`
`220`	`196`	`return 0;`
`221`	`197`	`}`
`222`	`198`
`223`		`- void funcdef(int polymorphism = 0) override`
`224`		`- {`
`225`		`- this->args.push_back(Param("src", DataCategory::Tensor, Precision::Any));`
`226`		`- this->args.push_back(Param("dst", DataCategory::Var, Precision::String));`
`227`		`- }`
	`199`	`+`
`228`	`200`	`string math_formula() const override`
`229`	`201`	`{`
`230`	`202`	`return "T2 = T1.clone()";`
`@@ -237,7 +209,7 @@ namespace deepx::tf`
`237`	`209`	`DelTensor()`
`238`	`210`	`{`
`239`	`211`	`this->name = "deltensor";`
`240`		`- this->funcdef();`
	`212`	`+`
`241`	`213`	`}`
`242`	`214`	`DelTensor(string text)`
`243`	`215`	`{`
`@@ -253,10 +225,7 @@ namespace deepx::tf`
`253`	`225`	`mem.delete_tensor(name);`
`254`	`226`	`return 0;`
`255`	`227`	`}`
`256`		`- void funcdef(int polymorphism=0) override`
`257`		`- {`
`258`		`- this->args.push_back(Param("tensor1", DataCategory::Tensor, Precision::Any));`
`259`		`- }`
	`228`	`+`
`260`	`229`	`string math_formula() const override`
`261`	`230`	`{`
`262`	`231`	`return "del T1";`
Original file line number	Diff line number	Diff line change
`@@ -51,14 +51,7 @@ namespace deepx::tf`
`51`	`51`	`}`
`52`	`52`	`return 0;`
`53`	`53`	`}`
`54`		`- void funcdef(int polymorphism = 0) override`
`55`		`- {`
`56`		`- this->args.push_back(Param("tensor1", DataCategory::Tensor, Precision::Any));`
`57`		`- if (polymorphism == 0)`
`58`		`- {`
`59`		`- this->args.push_back(Param("format", DataCategory::Var, Precision::String));`
`60`		`- }`
`61`		`- }`
	`54`	`+`
`62`	`55`	`string math_formula() const override`
`63`	`56`	`{`
`64`	`57`	`return "print(T1)";`
Original file line number	Diff line number	Diff line change
`@@ -28,11 +28,7 @@ namespace deepx::tf`
`28`	`28`	`throw std::runtime_error("Invalid name: " + this->name);`
`29`	`29`	`}`
`30`	`30`	`}`
`31`		`- void funcdef(int polymorphism = 0) override`
`32`		`- {`
`33`		`- this->args.push_back(Param("value", DataCategory::Var, Precision::Any));`
`34`		`- this->returns.push_back(Param("name", DataCategory::Var, Precision::Any));`
`35`		`- }`
	`31`	`+`
`36`	`32`	`string math_formula() const override`
`37`	`33`	`{`
`38`	`34`	`return "var argname = argvalue";`
`@@ -97,11 +93,7 @@ namespace deepx::tf`
`97`	`93`	`throw std::runtime_error("Invalid name: " + this->name);`
`98`	`94`	`}`
`99`	`95`	`}`
`100`		`- void funcdef(int polymorphism = 0) override`
`101`		`- {`
`102`		`- this->args.push_back(Param("shape", DataCategory::Vector, Precision::Any));`
`103`		`- this->returns.push_back(Param("name", DataCategory::Vector, Precision::Any));`
`104`		`- }`
	`96`	`+`
`105`	`97`	`string math_formula() const override`
`106`	`98`	`{`
`107`	`99`	`return "shape = [3 4 5]";`