client:解决了并行问题

Author: miaobyte

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

@@ -1,3 +1,5 @@
+#include <mutex>
+
 #include <deepx/tensorfunc/init.hpp>
 #include <deepx/tensorfunc/new.hpp>
 #include <deepx/tensorfunc/print.hpp>
@@ -12,7 +14,8 @@ using namespace deepx::mem;
 
 int main()
 {
-    Mem  mem;   
+    Mem  mem;
+    std::mutex memmutex;
     deepx::Tensor<float> tensor =  New<float>({1, 2, 3});
     uniform(tensor,-1.0f,1.0f);
     mem.addtensor("tensor", tensor);
@@ -25,12 +28,10 @@ int main()
     deepx::op::OpFactory opfactory;
     deepx::op::register_all(opfactory);
     opfactory.print();
-    server.func = [&mem, &opfactory](const char *buffer)
+    server.func = [&mem, &opfactory, &memmutex](const char *buffer)
     {
         deepx::op::Op op;
         op.load(buffer);
-
-
         if (opfactory.ops.find(op.name)==opfactory.ops.end()){
             cout<<"<op> "<<op.name<<" not found"<<endl;
             return;
@@ -43,7 +44,9 @@ int main()
         auto src = type_map.find(op.dtype)->second;
 
         (*src).init(op.name, op.dtype, op.args, op.returns, op.require_grad, op.args_grad, op.returns_grad);
+        memmutex.lock();
         (*src).forward(mem);
+        memmutex.unlock();
     };
     server.start();
     return 0;

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

@@ -1,7 +1,10 @@
+#include <sstream>
+ 
 #include "udpserver.hpp"
 
 namespace client
 {
+    using namespace std;
     udpserver::udpserver(int port)
     {
         this->port = port;
@@ -38,16 +41,21 @@ namespace client
         }
         while (true)
         {
-            len = sizeof(cliaddr); // len is value/result
-            // 接收消息
-            n = recvfrom(sockfd, (char *)buffer, 1024,
-                         0, (struct sockaddr *)&cliaddr,
-                         &len);
+            len = sizeof(cliaddr);
+            n = recvfrom(sockfd, (char *)buffer, 1024, 0, (struct sockaddr *)&cliaddr, &len);
             buffer[n] = '\0';
-            std::cout << "~"<< buffer;
-            func(buffer);
+            
+            // 新增换行拆分逻辑
+            stringstream ss(buffer);
+            string line;
+            while (getline(ss, line)) {
+                if (!line.empty()) {
+                    cout << "~" << line << endl;
+                    char *IR = const_cast<char *>(line.c_str());
+                    func(IR);
+                }
+            }
         }
-
         close(sockfd);
     }
 }

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

@@ -18,7 +18,7 @@ namespace deepx::mem
         unordered_map<string, std::any> args;
 
         std::unordered_map<std::string, std::shared_ptr<TensorBase>> mem;
-        int tempidx=0;
+        int tempidx = 0;
 
         // template <typename T>
         // static std::shared_ptr<void> type_erase(const std::shared_ptr<Tensor<T>> &ptr)
@@ -60,37 +60,56 @@ namespace deepx::mem
         template <typename T>
         void addarg(const string &name, const T value)
         {
+            if (args.find(name) != args.end())
+            {
+                cerr << "Argument already exists: " << name << endl;
+            }
             args[name] = value;
         }
 
         template <typename T>
         T getarg(const string &name) const
         {
+            if (args.find(name) == args.end())
+            {
+                cerr << "Argument not found: " << name << endl;
+                return T();
+            }
             return any_cast<T>(args.at(name));
         }
 
         template <typename T>
         void addvector(const string &name, const vector<T> &value)
         {
+            if (args.find(name) != args.end())
+            {
+                cerr << "Vector already exists: " << name << endl;
+                return;
+            }
             args[name] = value;
         }
 
         template <typename T>
         vector<T> getvector(const string &name) const
         {
+            if (args.find(name) == args.end())
+            {
+                cerr << "Vector not found: " << name << endl;
+                return vector<T>();
+            }
             auto v = any_cast<vector<T>>(args.at(name));
             return v;
         }
 
+        // tensor
 
-        //tensor
-        
         template <typename T>
         void addtensor(const string &name, Tensor<T> &&tensor)
         {
             if (mem.find(name) != mem.end())
             {
-                throw std::runtime_error("Tensor already exists: " + name);
+                cerr << "Tensor already exists: " << name << endl;
+                return;
             }
             auto ptr = std::make_shared<Tensor<T>>(std::move(tensor));
             mem[name] = ptr;
@@ -101,7 +120,8 @@ namespace deepx::mem
         {
             if (mem.find(name) != mem.end())
             {
-                throw std::runtime_error("Tensor already exists: " + name);
+                cerr << "Tensor already exists: " << name << endl;
+                return;
             }
             auto ptr = std::make_shared<Tensor<T>>(tensor);
             mem[name] = ptr;
@@ -111,43 +131,42 @@ namespace deepx::mem
         shared_ptr<Tensor<T>> temptensor(vector<int> shape)
         {
             // 直接构造到shared_ptr避免移动
-            auto temp = tensorfunc::New<T>(shape);  // 临时对象
-            auto cloned = make_shared<Tensor<T>>(std::move(temp));  
-            mem["temp"+to_string(tempidx)]=cloned;
+            auto temp = tensorfunc::New<T>(shape); // 临时对象
+            auto cloned = make_shared<Tensor<T>>(std::move(temp));
+            mem["temp" + to_string(tempidx)] = cloned;
             tempidx++;
             return cloned;
         }
- 
+
         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);
+            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
         {
             std::vector<Tensor<T> *> tensors;
-            try
+
+            for (const auto &name : names)
             {
-                for (const auto &name : names)
+                if (mem.find(name) == mem.end())
                 {
-                    auto ptr = mem.at(name);
-                    tensors.push_back(std::static_pointer_cast<Tensor<T>>(ptr).get());
+                    cerr << "Tensor not found: " << name << endl;
+                    continue;
                 }
+                auto ptr = mem.at(name);
+                tensors.push_back(std::static_pointer_cast<Tensor<T>>(ptr).get());
             }
-            catch (const std::out_of_range &)
-            {
-                throw std::runtime_error("Type mismatch or tensor not found");
-            }
+
             return tensors;
         }