excuter:并行处理cpu,cuda

Author: miaobyte

doc/excuter/op-mem-ompsimd/list.md

@@ -4,7 +4,6 @@
 
 | 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) |
 | print |  none  | print(tensor<any> tensor1, var<string> format)->() | print(T1) | print(tensor<any> tensor1, var<string> format)->() |
 | print |  none  | print(tensor<any> tensor1)->() | print(T1) | print(tensor<any> tensor1)->() |
 | newtensor |  none  | newtensor(vector<int32> shape)->(tensor<any> tensor1) | T1 = zeros(shape) | newtensor(vector<int32> shape)->(tensor<any> tensor1) |

excuter/cpp-common/src/deepx/tensorfunc/init.hpp

@@ -33,13 +33,13 @@ namespace deepx::tensorfunc
     template <typename Author, typename T>
     struct uniformDispatcher
     {
-        static void uniform(Tensor<T> &tensor, const T low  , const T high  ) = delete;
+        static void uniform(Tensor<T> &tensor, const T low  , const T high  , const unsigned int seed) = delete;
     }; 
 
     template <typename Author, typename T>
-    void uniform(Tensor<T> &tensor, const T low  , const T high = T(1))
+    void uniform(Tensor<T> &tensor, const T low = T(0), const T high = T(1), const unsigned int seed = 0)
     {
-        uniformDispatcher<Author, T>::uniform(tensor, low, high);
+        uniformDispatcher<Author, T>::uniform(tensor, low, high, seed);
     }
 }
 

excuter/cpp-common/src/deepx/tf/tf.cpp

@@ -19,7 +19,7 @@ namespace deepx::tf
         size_t arrow_pos = body.find("->");
         if (arrow_pos == string::npos)
         {
-            throw runtime_error("Invalid IR format: missing arrow");
+                throw runtime_error("Invalid IR format: missing arrow");
         }
 
         // 获取输入和输出部分的原始字符串

excuter/cpp-common/src/deepx/tf/tffactory.cpp

@@ -0,0 +1,99 @@
+#include <iostream>
+#include <memory>
+#include <vector>
+#include <string>
+#include <sstream>
+
+#include "deepx/tf/tffactory.hpp"
+#include "deepx/dtype.hpp"
+
+namespace deepx::tf
+{   
+    using namespace std;
+
+    shared_ptr<TF> TfFactory::get_tf(const TF &other) const
+    {
+        // 检查操作名是否存在
+        auto family_it = tf_families.find(other.name);
+        if (family_it == tf_families.end())
+        {
+            cerr << "<op> " << other.name << " not found" << endl;
+            return nullptr;
+        }
+
+        // 检查作者是否存在
+        auto author_it = family_it->second->tf_authors.find(other.author);
+        if (author_it == family_it->second->tf_authors.end())
+        {
+            cerr << "<op> " << other.name << " author:" << other.author << " not found" << endl;
+            return nullptr;
+        }
+
+        // 提取参数和返回值类型
+        vector<TypeDef> arg_types;
+        for (const auto &arg : other.args)
+        {
+            arg_types.push_back(arg.dtype);
+        }
+
+        vector<TypeDef> return_types;
+        for (const auto &ret : other.returns)
+        {
+            return_types.push_back(ret.dtype);
+        }
+
+        // 尝试找到匹配的实现
+        auto tf = author_it->second->get_matching_tf(arg_types, return_types);
+        if (!tf)
+        {
+            cerr << "<op> " << other.name << " " << other.to_string(false, false) << " not found" << endl;
+            cerr << "supported dtypes: " << endl;
+            // 遍历所有已注册的实现
+            for (const auto &registered_tf : author_it->second->tfs)
+            {
+                cerr << "(";
+                for (size_t i = 0; i < registered_tf->args.size(); i++)
+                {
+                    if (i > 0)
+                        cerr << ", ";
+                    cerr << dtype_str(registered_tf->args[i].dtype);
+                }
+                cerr << ")->(";
+                for (size_t i = 0; i < registered_tf->returns.size(); i++)
+                {
+                    if (i > 0)
+                        cerr << ", ";
+                    cerr << dtype_str(registered_tf->returns[i].dtype);
+                }
+                cerr << ")" << endl;
+            }
+            return nullptr;
+        }
+        return tf;
+    }
+    string TfFactory::print_markdown() const
+    {
+        std::stringstream ss;
+        ss << "## excuter/op-mem-ompsimd 支持算子列表 \n\n";
+        ss << "本页面由 `excuter/op-mem-ompsimd/src/deepx/tf/tffactory.hpp` 生成，请勿手动修改 \n\n";
+        ss << "| Operation | Author | Func Def | Math Formula | IR Instruction |\n";
+        ss << "|-----------|--------|------------|--------------|----------------|\n";
+
+        // 输出每个操作及其信息
+        for (const auto &[name, tf_family] : tf_families)
+        {
+            for (const auto &[author, tf_author] : tf_family->tf_authors)
+            {
+                for (const auto &tf : tf_author->tfs)
+                {
+                    ss << "| " << name << " | ";
+                    ss << (author.empty() ? " none " : author) << " | ";
+                    ss << tf->to_string(false, true) << " | ";
+                    ss << tf->math_formula() << " | ";
+                    ss << tf->to_string(false, true) << " |\n";
+                }
+            }
+        }
+        return ss.str();
+    }
+}

…p-mem-ompsimd/src/deepx/tf/tffactory.hpp …er/cpp-common/src/deepx/tf/tffactory.hppexcuter/op-mem-ompsimd/src/deepx/tf/tffactory.hpp renamed to excuter/cpp-common/src/deepx/tf/tffactory.hpp excuter/op-mem-ompsimd/src/deepx/tf/tffactory.hpp renamed to excuter/cpp-common/src/deepx/tf/tffactory.hpp

@@ -1,37 +1,38 @@
 #ifndef DEEPX_TF_TFFACTORY_HPP
 #define DEEPX_TF_TFFACTORY_HPP
 
-#include <unordered_map>
-#include <string>
-#include <memory>
-#include <vector>
-#include <algorithm>
-
 #include "deepx/tf/tf.hpp"
 
 namespace deepx::tf
 {
+
     struct TypeSignature
     {
         vector<TypeDef> args;
         vector<TypeDef> returns;
 
-        bool is_compatible(const TypeSignature& other) const {
-            return is_compatible_types(args, other.args) && 
+        bool is_compatible(const TypeSignature &other) const
+        {
+            return is_compatible_types(args, other.args) &&
                    is_compatible_types(returns, other.returns);
         }
 
     private:
-        static bool is_compatible_types(const vector<TypeDef>& a, const vector<TypeDef>& b) {
-            if (a.size() != b.size()) return false;
-            for (size_t i = 0; i < a.size(); i++) {
-                if ((static_cast<uint8_t>(a[i].parts.category) & 
-                     static_cast<uint8_t>(b[i].parts.category)) == 0) {
+        static bool is_compatible_types(const vector<TypeDef> &a, const vector<TypeDef> &b)
+        {
+            if (a.size() != b.size())
+                return false;
+            for (size_t i = 0; i < a.size(); i++)
+            {
+                if ((static_cast<uint8_t>(a[i].parts.category) &
+                     static_cast<uint8_t>(b[i].parts.category)) == 0)
+                {
                     return false;
                 }
-                if (a[i].parts.precision != Precision::Any && 
-                    b[i].parts.precision != Precision::Any && 
-                    a[i].parts.precision != b[i].parts.precision) {
+                if (a[i].parts.precision != Precision::Any &&
+                    b[i].parts.precision != Precision::Any &&
+                    a[i].parts.precision != b[i].parts.precision)
+                {
                     return false;
                 }
             }
@@ -44,23 +45,28 @@ namespace deepx::tf
         vector<std::shared_ptr<TF>> tfs;
 
         // 获取匹配的TF实现
-        std::shared_ptr<TF> get_matching_tf(const vector<TypeDef>& arg_types,
-                                           const vector<TypeDef>& return_types) const {
+        std::shared_ptr<TF> get_matching_tf(const vector<TypeDef> &arg_types,
+                                            const vector<TypeDef> &return_types) const
+        {
             TypeSignature target{arg_types, return_types};
-            
-            for (const auto& tf : tfs) {
+
+            for (const auto &tf : tfs)
+            {
                 vector<TypeDef> tf_arg_types;
-                for (const auto& arg : tf->args) {
+                for (const auto &arg : tf->args)
+                {
                     tf_arg_types.push_back(arg.dtype);
                 }
-                
+
                 vector<TypeDef> tf_return_types;
-                for (const auto& ret : tf->returns) {
+                for (const auto &ret : tf->returns)
+                {
                     tf_return_types.push_back(ret.dtype);
                 }
-                
+
                 TypeSignature current{tf_arg_types, tf_return_types};
-                if (target.is_compatible(current)) {
+                if (target.is_compatible(current))
+                {
                     return tf;
                 }
             }
@@ -101,9 +107,6 @@ namespace deepx::tf
         // 输出为markdown表格格式
         string print_markdown() const;
     };
-
-    int register_all(TfFactory &tfactory);
 }
- 
 
 #endif

excuter/op-mem-cuda/CMakeLists.txt

@@ -58,6 +58,7 @@ add_executable(${PROJECT_NAME} ${CLIENT_SOURCES})
 target_link_libraries(${PROJECT_NAME}
     PRIVATE
     deepx
+    CUDA::cudart
 )
 # 测试
 add_subdirectory(test/tensorfunc)

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

@@ -5,6 +5,7 @@
 #include <deepx/tensorfunc/init.hpp>
 #include "deepx/tf/tf.hpp"
 #include "deepx/tf/tffactory.hpp"
+#include "client/tfs.hpp"
 #include "deepx/mem/mem.hpp"
 #include "client/udpserver.hpp"
 
@@ -23,7 +24,7 @@ int main()
     Mem mem;
     std::mutex memmutex;
 
-    client::udpserver server(8080);
+    client::udpserver server(9090);
     deepx::tf::TfFactory tf_factory;
     register_all(tf_factory);
 

…r/op-mem-cuda/src/deepx/tf/tffactory.cpp excuter/op-mem-cuda/src/client/tfs.cppexcuter/op-mem-cuda/src/deepx/tf/tffactory.cpp renamed to excuter/op-mem-cuda/src/client/tfs.cpp excuter/op-mem-cuda/src/deepx/tf/tffactory.cpp renamed to excuter/op-mem-cuda/src/client/tfs.cpp

@@ -7,80 +7,7 @@
 
 namespace deepx::tf
 {
-    shared_ptr<TF> TfFactory::get_tf(const TF &other) const
-    {
-        // 检查操作名是否存在
-        auto family_it = tf_families.find(other.name);
-        if (family_it == tf_families.end())
-        {
-            cerr << "<op> " << other.name << " not found" << endl;
-            return nullptr;
-        }
-
-        // 检查作者是否存在
-        auto author_it = family_it->second->tf_authors.find(other.author);
-        if (author_it == family_it->second->tf_authors.end())
-        {
-            cerr << "<op> " << other.name << " author:" << other.author << " not found" << endl;
-            return nullptr;
-        }
-
-        // 提取参数和返回值类型
-        vector<TypeDef> arg_types;
-        for (const auto& arg : other.args) {
-            arg_types.push_back(arg.dtype);
-        }
-
-        vector<TypeDef> return_types;
-        for (const auto& ret : other.returns) {
-            return_types.push_back(ret.dtype);
-        }
-
-        // 尝试找到匹配的实现
-        auto tf = author_it->second->get_matching_tf(arg_types, return_types);
-        if (!tf) {
-            cerr << "<op> " << other.name << " " << other.to_string(false, false) << " not found" << endl;
-            cerr << "supported dtypes: " << endl;
-            // 遍历所有已注册的实现
-            for (const auto& registered_tf : author_it->second->tfs) {
-                cerr << "(";
-                for (size_t i = 0; i < registered_tf->args.size(); i++) {
-                    if (i > 0) cerr << ", ";
-                    cerr << dtype_str(registered_tf->args[i].dtype);
-                }
-                cerr << ")->(";
-                for (size_t i = 0; i < registered_tf->returns.size(); i++) {
-                    if (i > 0) cerr << ", ";
-                    cerr << dtype_str(registered_tf->returns[i].dtype);
-                }
-                cerr << ")" << endl;
-            }
-            return nullptr;
-        }
-        return tf;
-    }
-    string TfFactory::print_markdown() const
-    {
-        std::stringstream ss;
-        ss << "## excuter/op-mem-cuda 支持算子列表 \n\n";
-        ss << "本页面由 `excuter/op-mem-cuda/src/deepx/tf/tffactory.hpp` 生成，请勿手动修改 \n\n";
-        ss << "| Operation | Author | Func Def | Math Formula | IR Instruction |\n";
-        ss << "|-----------|--------|------------|--------------|----------------|\n";
-
-        // 输出每个操作及其信息
-        for (const auto& [name, tf_family] : tf_families) {
-            for (const auto& [author, tf_author] : tf_family->tf_authors) {
-                for (const auto& tf : tf_author->tfs) {
-                    ss << "| " << name << " | ";
-                    ss << (author.empty() ? " none " : author) << " | ";
-                    ss << tf->to_string(false, true) << " | ";
-                    ss << tf->math_formula() << " | ";
-                    ss << tf->to_string(false, true) << " |\n";
-                }
-            }
-        }
-        return ss.str();
-    }
+  
     // tensor
     void register_lifecycle(TfFactory &tffactory)
     {
@@ -107,6 +34,7 @@ namespace deepx::tf
     void register_util(TfFactory &opfactory)
     {
         opfactory.add_tf(std::make_shared<Print>());
+        opfactory.add_tf(std::make_shared<Print>(1));
     }
 
     // // elementwise

excuter/op-mem-cuda/src/client/tfs.hpp

@@ -0,0 +1,10 @@
+#ifndef CLIENT_TFS_HPP
+#define CLIENT_TFS_HPP
+ 
+#include "deepx/tf/tffactory.hpp"
+namespace deepx::tf{
+
+    int register_all(TfFactory &tfactory);
+}
+
+#endif