op&mem:验证

Author: miaobyte

excuter/common/src/deepx/shape_concat.hpp

@@ -6,7 +6,9 @@
 
 namespace deepx
 {
+
     Shape concatShape(const std::vector<Shape> &shapes,const int axis);
+
     template<typename T>
     Shape concatShape(const std::vector<Tensor<T>*> &tensors,const int axis){
         std::vector<Shape> shapes;

excuter/common/src/deepx/tensor.hpp

@@ -7,36 +7,36 @@
 
 #include "deepx/shape.hpp"
 #include "deepx/dtype.hpp"
+#include "deepx/tensorbase.hpp"
+
 namespace deepx
 {
-
-
-    enum DeviceType
-    {
-        CPU = 0,
-        CUDA = 1,
-    };
-
+    using namespace std;
+    
     template <typename T>
-    struct Tensor
+    struct Tensor : public TensorBase
     {
-        Shape shape;
         T *data;
-        DeviceType device;
-        
- 
-        using NewFn = T* (*)(int);
+
+        using NewFn = T *(*)(int);
         NewFn newer; //  申请内存
- 
+
         using DeleteFn = void (*)(T *);
         DeleteFn deleter; // 释放内存
 
-        using CopyFn = void (*)(T *,T *,int);
+        using CopyFn = void (*)(T *, T *, int);
         CopyFn copyer; // 拷贝内存
 
-        Tensor( )=default;
-        Tensor(const Shape &s):shape(s){
-            shape.dtype=dtype<T>::name();
+        Tensor() = default;
+        Tensor(const vector<int> &s)  
+        {
+            shape = Shape(s);
+            shape.dtype = dtype<T>::name();
+        }
+        Tensor(const Shape &s)  
+        {
+            shape = s;
+            shape.dtype = dtype<T>::name();
         }
 
         ~Tensor()
@@ -52,95 +52,99 @@ namespace deepx
          * 该构造函数用于创建一个新的Tensor对象，并将现有Tensor对象的内容复制到新对象中。
          * 它会分配新的内存并使用copyer函数将数据从源Tensor复制到新Tensor。
          */
-        Tensor(const Tensor<T> &tensor){
-            shape=tensor.shape;
-            shape.dtype=dtype<T>::name();
-            device=tensor.device;
-            newer=tensor.newer;
-            deleter=tensor.deleter;
-            copyer=tensor.copyer;
-            
-            data=newer(shape.size);
-            copyer(tensor.data,data,tensor.shape.size);
+        Tensor(const Tensor<T> &tensor)
+        {
+            shape = tensor.shape;
+            shape.dtype = dtype<T>::name();
+            device = tensor.device;
+            newer = tensor.newer;
+            deleter = tensor.deleter;
+            copyer = tensor.copyer;
+
+            data = newer(shape.size);
+            copyer(tensor.data, data, tensor.shape.size);
         }
-         
+
         /**
          * 移动构造
          * 该构造函数用于通过转移资源来创建一个新的Tensor对象。
          * 它会将源Tensor的资源（如数据指针）转移到新对象中，并将源Tensor的数据指针置为nullptr。
          * 这样可以避免不必要的内存分配，提高性能。
          */
-        
- 
-        Tensor(Tensor<T> &&other) noexcept {
-            shape=std::move(other.shape);
-            device=other.device;
 
-            deleter=other.deleter;
-            copyer=other.copyer;
-            newer=other.newer;
+        Tensor(Tensor<T> &&other) noexcept
+        {
+            shape = std::move(other.shape);
+            device = other.device;
+
+            deleter = other.deleter;
+            copyer = other.copyer;
+            newer = other.newer;
 
-            data=other.data;
+            data = other.data;
 
-            other.data=nullptr;
+            other.data = nullptr;
 
-            other.deleter=nullptr;
-            other.copyer=nullptr;
-            other.newer=nullptr;
+            other.deleter = nullptr;
+            other.copyer = nullptr;
+            other.newer = nullptr;
         }
-       
+
         /**
          * 拷贝赋值运算符
          * 该运算符用于将一个Tensor对象的内容赋值给另一个Tensor对象。
          * 它会先检查自赋值的情况，然后使用copyer函数将数据从源Tensor复制到目标Tensor。
          * 需要注意的是，目标Tensor的原有数据会被释放。
          */
 
-        Tensor<T>& operator=(const Tensor<T> &tensor) {
-            if(this==&tensor) 
-            return *this;
-
-            shape=tensor.shape;
-            shape.dtype=dtype<T>::name();
-            device=tensor.device;
-            deleter=tensor.deleter;
-            copyer=tensor.copyer;
-            newer=tensor.newer;
-
-            data=newer(shape.size);
-            if (data!=nullptr){
+        Tensor<T> &operator=(const Tensor<T> &tensor)
+        {
+            if (this == &tensor)
+                return *this;
+
+            shape = tensor.shape;
+            shape.dtype = dtype<T>::name();
+            device = tensor.device;
+            deleter = tensor.deleter;
+            copyer = tensor.copyer;
+            newer = tensor.newer;
+
+            data = newer(shape.size);
+            if (data != nullptr)
+            {
                 deleter(data);
             }
-            copyer(tensor.data,data,tensor.shape.size);
+            copyer(tensor.data, data, tensor.shape.size);
             return *this;
         }
- 
+
         /**
          * 移动赋值运算符
          * 该运算符用于将一个Tensor对象的资源转移到另一个Tensor对象。
          * 它会先检查自赋值的情况，然后将源Tensor的资源转移到目标Tensor，并将源Tensor的数据指针置为nullptr。
          * 这样可以避免不必要的内存分配，提高性能。
          */
-        Tensor<T>& operator=( Tensor<T> &&tensor) noexcept{
-            if(this==&tensor) return *this;
-            shape=tensor.shape;
-            shape.dtype=dtype<T>::name();
-            device=tensor.device;
-            newer=tensor.newer;
-            deleter=tensor.deleter;
-            copyer=tensor.copyer;
-            if (data!=nullptr){
+        Tensor<T> &operator=(Tensor<T> &&tensor) noexcept
+        {
+            if (this == &tensor)
+                return *this;
+            shape = tensor.shape;
+            shape.dtype = dtype<T>::name();
+            device = tensor.device;
+            newer = tensor.newer;
+            deleter = tensor.deleter;
+            copyer = tensor.copyer;
+            if (data != nullptr)
+            {
                 deleter(data);
             }
-            data=tensor.data;
-            tensor.data=nullptr;
-            tensor.deleter=nullptr;
-            tensor.copyer=nullptr;
-            tensor.newer=nullptr;
+            data = tensor.data;
+            tensor.data = nullptr;
+            tensor.deleter = nullptr;
+            tensor.copyer = nullptr;
+            tensor.newer = nullptr;
             return *this;
         }
-
-      
     };
 
     // template <typename T>

excuter/common/src/deepx/tensorbase.hpp

@@ -0,0 +1,57 @@
+#ifndef DEEPX_TENSORBASE_HPP
+#define DEEPX_TENSORBASE_HPP
+
+#include "deepx/shape.hpp"
+
+namespace deepx
+{
+    enum DeviceType
+    {
+        CPU = 0,
+        CUDA = 1,
+    };
+
+    struct TensorBase
+    {
+        Shape shape;
+        DeviceType device;
+        TensorBase() = default;
+        // 拷贝构造函数
+        TensorBase(const TensorBase &other)
+        {
+            shape = other.shape;
+            device = other.device;
+        }
+
+        // 移动构造函数
+        TensorBase(TensorBase &&other) noexcept
+        {
+            shape = std::move(other.shape);
+            device = other.device;
+        }
+
+        // 拷贝赋值运算符
+        TensorBase &operator=(const TensorBase &other)
+        {
+            if (this != &other)
+            {
+                shape = other.shape;
+                device = other.device;
+            }
+            return *this;
+        }
+
+        // 移动赋值运算符
+        TensorBase &operator=(TensorBase &&other) noexcept
+        {
+            if (this != &other)
+            {
+                shape = std::move(other.shape);
+                device = other.device;
+            }
+            return *this;
+        }
+    };
+
+}
+#endif

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

@@ -1,17 +1,8 @@
-#include <iostream>
-#include <string.h>
-#include <arpa/inet.h>
-#include <unistd.h>
-
-#include <stdutil/vector.hpp>
- 
 #include <deepx/tensorfunc/init.hpp>
 #include <deepx/tensorfunc/new.hpp>
 #include <deepx/tensorfunc/print.hpp>
 
 #include "deepx/op/op.hpp"
-#include "deepx/op/elementwise.hpp"
-#include "deepx/op/reduce.hpp"
 #include "deepx/op/opfactory.hpp"
 #include "deepx/mem/mem.hpp"
 #include "client/udpserver.hpp"
@@ -24,26 +15,25 @@ int main()
     Mem  mem;   
     deepx::Tensor<float> tensor =  New<float>({1, 2, 3});
     uniform(tensor,-1.0f,1.0f);
-    mem.add("tensor", std::make_shared<deepx::Tensor<float>>(tensor));
+    mem.addtensor("tensor", tensor);
 
     deepx::Tensor<float> result = New<float>({1, 2, 3});
 
-    mem.add("result", std::make_shared<deepx::Tensor<float>>(result));
-
+    mem.addtensor("result", result);
+    print(tensor);
     client::udpserver server(8080);
     deepx::op::OpFactory opfactory;
     deepx::op::register_all(opfactory);
-    server.func = [&mem, &opfactory](char *buffer)
+    opfactory.print();
+    server.func = [&mem, &opfactory](const char *buffer)
     {
         deepx::op::Op op;
         op.load(buffer);
-        op.forward(mem);
- 
+
         shared_ptr<deepx::op::Op> opsrc = opfactory.get_op(op);
 
         (*opsrc).init(op.name, op.dtype, op.args, op.returns, op.require_grad, op.args_grad, op.returns_grad);
         (*opsrc).forward(mem);
-        print(*mem.gettensor<float>("result"));
     };
     server.start();
     return 0;

excuter/op-mem-ompsimd/src/client/send.py

@@ -0,0 +1,25 @@
+import socket
+
+def send_udp_message(ip, port, message):
+    sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+    sock.sendto(message.encode(), (ip, port))
+
+argset_str = """
+name: argset
+dtype: int32
+args:
+    - 2
+    - 3
+    - 4
+returns:
+    - shape1
+"""
+send_udp_message("localhost", 8080, argset_str) 
+new_str = """
+name: newtensor
+dtype: float32
+args:
+    - tensor
+    - shape1
+"""
+send_udp_message("localhost", 8080, new_str)

excuter/op-mem-ompsimd/src/client/udpsend.py

@@ -41,10 +41,10 @@ namespace client
             len = sizeof(cliaddr); // len is value/result
             // 接收消息
             n = recvfrom(sockfd, (char *)buffer, 1024,
-                         MSG_WAITALL, (struct sockaddr *)&cliaddr,
+                         0, (struct sockaddr *)&cliaddr,
                          &len);
             buffer[n] = '\0';
-            std::cout << "Received message: " << buffer << std::endl;
+            std::cout << "Recv "<<n<<"bytes:" << buffer << std::endl;
             func(buffer);
         }