client:指令格式调试

Author: miaobyte

excuter/op-mem-ompsimd/src/client/main.cpp

@@ -30,10 +30,20 @@ int main()
         deepx::op::Op op;
         op.load(buffer);
 
-        shared_ptr<deepx::op::Op> opsrc = opfactory.get_op(op);
+
+        if (opfactory.ops.find(op.name)==opfactory.ops.end()){
+            cout<<"<op> "<<op.name<<" not found"<<endl;
+            return;
+        }
+        auto &type_map = opfactory.ops.find(op.name)->second;
+        if (type_map.find(op.dtype)==type_map.end()){
+            cout<<"<op>"<<op.name<<" "<<op.dtype<<" not found"<<endl;
+            return;
+        }
+        auto src = type_map.find(op.dtype)->second;
 
-        (*opsrc).init(op.name, op.dtype, op.args, op.returns, op.require_grad, op.args_grad, op.returns_grad);
-        (*opsrc).forward(mem);
+        (*src).init(op.name, op.dtype, op.args, op.returns, op.require_grad, op.args_grad, op.returns_grad);
+        (*src).forward(mem);
     };
     server.start();
     return 0;

excuter/op-mem-ompsimd/src/client/udpserver.cpp

@@ -44,7 +44,7 @@ namespace client
                          0, (struct sockaddr *)&cliaddr,
                          &len);
             buffer[n] = '\0';
-            std::cout << "Recv "<<n<<"bytes:" << buffer << std::endl;
+            std::cout << ">>"<< buffer << std::endl;
             func(buffer);
         }
 

excuter/op-mem-ompsimd/src/deepx/mem/mem.hpp

@@ -117,19 +117,20 @@ namespace deepx::mem
             tempidx++;
             return cloned;
         }
-        template <typename T>
+ 
         bool existstensor(const string &name) const
         {
             return mem.find(name) != mem.end();
         }   
 
-        template <typename T>
+        template <typename T> 
         shared_ptr<Tensor<T>> gettensor(const string &name) const
         {
             auto  ptr = mem.at(name);
             return std::static_pointer_cast<Tensor<T>>(ptr);
         }
- 
+
+
         // 获取多个张量
         template <typename T>
         vector<Tensor<T> *> gettensors(const vector<string> &names) const

excuter/op-mem-ompsimd/src/deepx/op/init.hpp

@@ -18,8 +18,8 @@ namespace deepx::op{
         }
         void forward(mem::Mem &mem) override{
             auto output = mem.gettensor<T>(this->returns[0]).get();
-            T low = mem.getarg<T>(this->args[1]);
-            T high = mem.getarg<T>(this->args[2]);
+            T low = mem.getarg<T>(this->args[0]);
+            T high = mem.getarg<T>(this->args[1]);
             tensorfunc::uniform(*output,low,high);
         } 
         void backward(mem::Mem &mem) override{

excuter/op-mem-ompsimd/src/deepx/op/new.hpp

@@ -18,8 +18,8 @@ namespace deepx::op{
             this->init("newtensor",dtype<T>::name(), args, {}, false, {}, {});
         }
         void forward(mem::Mem &mem) override{
-            string name= this->args[0];
-            vector<int> shape=mem.getvector<int>(this->args[1]);
+            string name= this->returns[0];
+            vector<int> shape=mem.getvector<int32_t>(this->args[0]);
             Tensor<T> t=tensorfunc::New<T>(shape);
             mem.addtensor(name,t);
         }   

excuter/op-mem-ompsimd/src/deepx/op/op.hpp

@@ -6,7 +6,8 @@
 #include <memory>
 #include <string>
 #include <iostream>
-#include <yaml-cpp/yaml.h>
+#include <sstream>
+
 #include "deepx/tensor.hpp"
 #include "deepx/mem/mem.hpp"
 #include "deepx/dtype.hpp"
@@ -50,26 +51,62 @@ namespace deepx::op
             throw std::runtime_error("backward not implemented");
         }
 
-        void load(const char *yml)
-        {
-            YAML::Node config = YAML::Load(yml);
-            name = config["name"].as<std::string>();
-            dtype = config["dtype"].as<std::string>();
-            if (config["args"])
-            {
-                args = config["args"].as<std::vector<std::string>>();
-            }
-            if (config["returns"])
-            {
-                returns = config["returns"].as<std::vector<std::string>>();
+        void load(const char* str) {
+            // 格式: opname dtype args returns require_grad args_grad returns_grad
+            // 例子: "add float32 a,b c 1 a.grad,b.grad c.grad"
+            // 或者: "add float32 a,b c 0"
+            // 或者: "print a"
+            
+            stringstream ss(str);
+            string token;
+            
+            // 读取操作名
+            ss >> name;
+            
+            // 读取数据类型
+            ss >> dtype;
+            
+            // 读取参数列表 (逗号分隔)
+            ss >> token;
+            args.clear();
+            stringstream args_ss(token);
+            string arg;
+            while (getline(args_ss, arg, ',')) {
+                args.push_back(arg);
             }
-            if (config["args_grad"])
-            {
-                args_grad = config["args_grad"].as<std::vector<std::string>>();
+            
+            // 读取返回值列表
+            ss >> token;
+            returns.clear();
+            stringstream returns_ss(token);
+            string ret;
+            while (getline(returns_ss, ret, ',')) {
+                returns.push_back(ret);
             }
-            if (config["returns_grad"])
-            {
-                returns_grad = config["returns_grad"].as<std::vector<std::string>>();
+            
+            // 读取是否需要梯度
+            ss >> token;
+            require_grad = (token == "1");
+            
+            // 如果需要梯度，继续读取梯度变量名
+            if (require_grad && ss >> token) {
+                // 读取参数梯度列表
+                args_grad.clear();
+                stringstream args_grad_ss(token);
+                string arg_grad;
+                while (getline(args_grad_ss, arg_grad, ',')) {
+                    args_grad.push_back(arg_grad);
+                }
+                
+                // 读取返回值梯度列表
+                if (ss >> token) {
+                    returns_grad.clear();
+                    stringstream returns_grad_ss(token);
+                    string ret_grad;
+                    while (getline(returns_grad_ss, ret_grad, ',')) {
+                        returns_grad.push_back(ret_grad);
+                    }
+                }
             }
         }
         void init(const string &opname,

excuter/op-mem-ompsimd/src/deepx/op/opfactory.cpp

@@ -5,6 +5,7 @@
 #include "deepx/op/init.hpp"
 #include "deepx/op/new.hpp"
 #include "deepx/op/arg.hpp"
+#include "deepx/op/print.hpp"
 namespace deepx::op
 {   
     //new
@@ -38,6 +39,10 @@ namespace deepx::op
         register_constant(opfactory);
         register_arange(opfactory);
     }
+    //print
+    void register_print(OpFactory &opfactory){
+        opfactory.add_op(Print<float>());
+    }
     //elementwise
      void register_add(OpFactory &opfactory){
         opfactory.add_op(Add<float>());
@@ -110,6 +115,7 @@ namespace deepx::op
     int register_all(OpFactory &opfactory){
         register_new(opfactory);
         register_init(opfactory);
+        register_print(opfactory);
         register_elementwise_op(opfactory);
         register_concat(opfactory);
         register_matmul(opfactory);

excuter/op-mem-ompsimd/src/deepx/op/opfactory.hpp

@@ -14,28 +14,14 @@ namespace deepx::op
 
     class OpFactory
     {
-    private:
-        std::unordered_map<std::string, Op_dtype> ops;
-
     public:
-    
+        std::unordered_map<std::string, Op_dtype> ops;
         template <typename T>
         void add_op(const T &op)
         {
             ops[op.name][op.dtype] = std::make_shared<T>(op);
         }
-
-        std::shared_ptr<Op> get_op(const Op &op)
-        {
-            auto &type_map = ops[op.name];
-            auto it = type_map.find(op.dtype);
-            if (it != type_map.end())
-            {
-                auto src = it->second;
-                return src;
-            }
-            return nullptr;
-        }
+ 
 
         void print(){
             cout<<"support op:"<<endl;

excuter/op-mem-ompsimd/src/deepx/op/print.hpp

@@ -2,21 +2,22 @@
 #define DEEPX_OP_PRINT_HPP
 
 #include "deepx/op/op.hpp"
+#include "deepx/tensorfunc/print.hpp"
 
 namespace deepx::op{
- 
+    template <typename T>
     class Print : public Op{
         public:
         Print(){
-            this->init("print","", {}, {}, false, {}, {});
+            this->init("print","any", {}, {}, false, {}, {});
         }
         void forward(mem::Mem &mem) override{
             string name=this->returns[0];
-            if (mem.existtensor(name)){
+            if (mem.existstensor(name)){
                 auto t=mem.gettensor<T>(name);
-                cout<<t<<endl;
+                tensorfunc::print<T>(*t);
             }else{
-                throw std::runtime_error("Print op does not support backward");
+                cout<<"<print> "<<name<<" not found"<<endl;
             }
         }   
         void backward(mem::Mem &mem) override{