added tensorframe prototype

twhuang-utah · twhuang-utah · commit cd62b6feec2a · 2020-08-31T10:32:22.000-06:00
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -6,7 +6,7 @@ MESSAGE(STATUS "CMAKE_ROOT: " ${CMAKE_ROOT})
 set(CMAKE_VERBOSE_MAKEFILE ON)
 
 # Project name
-project(Taskflow VERSION 2.6.0 LANGUAGES CXX)
+project(Taskflow VERSION 2.7.0 LANGUAGES CXX)
 
 # build options
 option(TF_BUILD_BENCHMARKS "Enables build of benchmarks" OFF)
@@ -222,6 +222,14 @@ target_include_directories(${PROJECT_NAME} INTERFACE
   $<INSTALL_INTERFACE:include/> 
 )
 
+add_library(TensorFrame INTERFACE)
+target_compile_features(TensorFrame INTERFACE cxx_std_17)
+target_link_libraries(TensorFrame INTERFACE Threads::Threads)
+target_include_directories(TensorFrame INTERFACE
+  $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
+  $<INSTALL_INTERFACE:include/> 
+)
+
 # -----------------------------------------------------------------------------
 # Example program 
 # -----------------------------------------------------------------------------
@@ -305,6 +313,13 @@ target_link_libraries(
 )
 endif(CMAKE_CUDA_COMPILER AND TF_BUILD_CUDA)
 
+#### TensorFrame
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${TF_EXAMPLE_DIR}/tensorframe)
+add_executable(add ${TF_EXAMPLE_DIR}/tensorframe/add.cpp)
+target_link_libraries(
+  add TensorFrame Threads::Threads tf::default_settings
+)
+
 endif(TF_BUILD_EXAMPLES)
 
 # -----------------------------------------------------------------------------
diff --git a/doxygen/Doxyfile b/doxygen/Doxyfile
@@ -38,7 +38,7 @@ PROJECT_NAME           = "Taskflow"
 # could be handy for archiving the generated documentation or if some version
 # control system is used.
 
-PROJECT_NUMBER         = 2.6.0
+PROJECT_NUMBER         = 2.7.0 (master branch)
 
 # Using the PROJECT_BRIEF tag one can provide an optional one line description
 # for a project that appears at the top of each page and should give viewer a
diff --git a/examples/tensorframe/add.cpp b/examples/tensorframe/add.cpp
@@ -0,0 +1,16 @@
+#include <taskflow/tensorframe.hpp>
+
+int main(){
+
+  tf::Tensor<float> tensor({2, 3, 3, 4}, 10);
+
+  tensor.dump(std::cout);
+  
+  std::cout << tensor.flat_chunk_index(1, 2, 2, 3) << '\n';
+  std::cout << tensor.flat_index(1, 2, 2, 3) << '\n';
+  std::cout << tensor.chunk_size() << '\n';
+
+
+  return 0;
+}
+
diff --git a/taskflow/algorithm/for_each.hpp b/taskflow/algorithm/for_each.hpp
@@ -114,7 +114,7 @@ Task FlowBuilder::for_each_guided(B&& beg, E&& end, C&& c, H&& chunk_size){
               q = chunk_size;
             }
             size_t e0 = (q <= r) ? s0 + q : N;
-            if(next.compare_exchange_strong(s0, e0, std::memory_order_release,
+            if(next.compare_exchange_strong(s0, e0, std::memory_order_relaxed,
                                                     std::memory_order_relaxed)) {
               std::advance(beg, s0-z);
               for(size_t x = s0; x< e0; x++) {
@@ -212,7 +212,7 @@ Task FlowBuilder::for_each_index_guided(
               q = chunk_size;
             }
             size_t e0 = (q <= r) ? s0 + q : N;
-            if(next.compare_exchange_strong(s0, e0, std::memory_order_release,
+            if(next.compare_exchange_strong(s0, e0, std::memory_order_relaxed,
                                                     std::memory_order_relaxed)) {
               auto s = static_cast<I>(s0) * inc + beg;
               for(size_t x=s0; x<e0; x++, s+= inc) {
diff --git a/taskflow/algorithm/reduce.hpp b/taskflow/algorithm/reduce.hpp
@@ -128,7 +128,7 @@ Task FlowBuilder::reduce_guided(
               q = C;
             }
             size_t e0 = (q <= r) ? s0 + q : N;
-            if(next.compare_exchange_strong(s0, e0, std::memory_order_release,
+            if(next.compare_exchange_strong(s0, e0, std::memory_order_relaxed,
                                                     std::memory_order_relaxed)) {
               std::advance(beg, s0-z);
               for(size_t x = s0; x<e0; x++, beg++) {
@@ -549,7 +549,7 @@ Task FlowBuilder::transform_reduce_guided(
               q = C;
             }
             size_t e0 = (q <= r) ? s0 + q : N;
-            if(next.compare_exchange_strong(s0, e0, std::memory_order_release,
+            if(next.compare_exchange_strong(s0, e0, std::memory_order_relaxed,
                                                     std::memory_order_relaxed)) {
               std::advance(beg, s0-z);
               for(size_t x = s0; x<e0; x++, beg++) {
diff --git a/taskflow/taskflow.hpp b/taskflow/taskflow.hpp
@@ -8,8 +8,8 @@
 // TF_VERSION / 100 % 1000 is the minor version
 // TF_VERSION / 100000 is the major version
 
-// current version: 2.6.0
-#define TF_VERSION 200600
+// current version: 2.7.0
+#define TF_VERSION 200700
 
 #define TF_MAJOR_VERSION TF_VERSION/100000
 #define TF_MINOR_VERSION TF_VERSION/100%1000
@@ -21,7 +21,7 @@ namespace tf {
 @brief queries the version information in string
 */
 constexpr const char* version() {
-  return "2.6.0";
+  return "2.7.0";
 }
 
 
diff --git a/taskflow/tensorframe/tensor.hpp b/taskflow/tensorframe/tensor.hpp
@@ -0,0 +1,261 @@
+#pragma once
+
+#include "../taskflow.hpp"
+
+#include <variant>
+#include <filesystem>
+
+namespace tf {
+
+/** 
+
+@class Tensor
+
+@brief a tensor contains arithmetic data in N dimensions
+
+*/
+template <typename T>
+class Tensor {
+  
+  friend class TensorNode;
+  friend class TensorExpr;
+  friend class TensorFrame;
+
+  struct Chunk {
+    std::vector<T> data;
+    std::string location;
+  };
+
+  public:
+
+    Tensor(const Tensor& tensor) = delete;
+    Tensor(Tensor&& tensor) = delete;
+
+    Tensor(std::vector<size_t> shape);
+    Tensor(std::vector<size_t> shape, size_t max_elements);
+
+    const std::vector<size_t>& shape() const;
+    const std::vector<size_t>& chunk_shape() const;
+
+    size_t size() const;
+    size_t rank() const;
+    size_t max_elements() const;
+    size_t chunk_size() const;
+    size_t num_chunks() const;
+
+    void dump(std::ostream& ostream) const;
+    
+    template <typename... Is>
+    size_t flat_chunk_index(Is... indices) const;
+
+    template <typename... Is>
+    size_t flat_index(Is... indices) const;
+
+  private:
+    
+    size_t _max_elements {65536*1024};  // 65MB
+
+    std::vector<size_t> _shape;
+    std::vector<size_t> _chunk_shape;
+    std::vector<size_t> _chunk_grid;
+    std::vector<Chunk> _chunks;
+
+    void _make_chunks();
+    
+    size_t _flat_chunk_index(size_t&, size_t) const;
+
+    template <typename... Is>
+    size_t _flat_chunk_index(size_t&, size_t, Is...) const;
+    
+    size_t _flat_index(size_t&, size_t) const;
+
+    template <typename... Is>
+    size_t _flat_index(size_t&, size_t, Is...) const;
+};
+
+template <typename T>
+Tensor<T>::Tensor(std::vector<size_t> shape) : 
+  _shape {std::move(shape)},
+  _chunk_shape (_shape.size()),
+  _chunk_grid (_shape.size()) {
+
+  _make_chunks();
+}
+
+template <typename T>
+Tensor<T>::Tensor(std::vector<size_t> shape, size_t max_elements) :
+  _max_elements {std::max(1ul, max_elements)},
+  _shape {std::move(shape)},
+  _chunk_shape (_shape.size()),
+  _chunk_grid (_shape.size()) {
+
+  _make_chunks();
+}
+
+template <typename T>
+size_t Tensor<T>::size() const {
+  return std::accumulate(
+    _shape.begin(), _shape.end(), 1, std::multiplies<size_t>()
+  );
+}
+
+template <typename T>
+size_t Tensor<T>::num_chunks() const {
+  return _chunks.size();
+}
+
+template <typename T>
+size_t Tensor<T>::chunk_size() const {
+  return _chunks[0].data.size();
+}
+
+template <typename T>
+size_t Tensor<T>::rank() const {
+  return _shape.size();
+}
+
+template <typename T>
+size_t Tensor<T>::max_elements() const {
+  return _max_elements;
+}
+
+template <typename T>
+const std::vector<size_t>& Tensor<T>::shape() const {
+  return _shape;
+}
+
+template <typename T>
+const std::vector<size_t>& Tensor<T>::chunk_shape() const {
+  return _chunk_shape;
+}
+
+template <typename T>
+template <typename... Is>
+size_t Tensor<T>::flat_chunk_index(Is... rest) const {
+
+  if(sizeof...(Is) != rank()) {
+    TF_THROW("index rank dose not match tensor rank");
+  }
+
+  size_t offset;
+  return _flat_chunk_index(offset, rest...);
+}
+
+template <typename T>
+size_t Tensor<T>::_flat_chunk_index(size_t& offset, size_t id) const {
+  offset = 1;
+  return id/_chunk_shape.back();
+}
+
+template <typename T>
+template <typename... Is>
+size_t Tensor<T>::_flat_chunk_index(
+  size_t& offset, size_t id, Is... rest
+) const {
+  auto i = _flat_chunk_index(offset, rest...);
+  offset *= _chunk_grid[_chunk_shape.size() - (sizeof...(Is))];
+  return (id/_chunk_shape[_chunk_shape.size() - sizeof...(Is) - 1])*offset + i;
+}
+
+template <typename T>
+template <typename... Is>
+size_t Tensor<T>::flat_index(Is... rest) const {
+
+  if(sizeof...(Is) != rank()) {
+    TF_THROW("index rank dose not match tensor rank");
+  }
+
+  size_t offset;
+  return _flat_index(offset, rest...);
+}
+
+template <typename T>
+size_t Tensor<T>::_flat_index(size_t& offset, size_t id) const {
+  offset = 1;
+  return id;
+}
+
+template <typename T>
+template <typename... Is>
+size_t Tensor<T>::_flat_index(size_t& offset, size_t id, Is... rest) const {
+  auto i = _flat_index(offset, rest...);
+  offset *= _shape[_shape.size() - (sizeof...(Is))];
+  return id*offset + i;
+}
+
+template <typename T>
+void Tensor<T>::dump(std::ostream& os) const {
+
+  os << "Tensor<" << typeid(T).name() << "> {\n"
+     << "  shape=[";
+
+  for(size_t i=0; i<_shape.size(); ++i) {
+    if(i) os << 'x';
+    os << _shape[i];
+  }
+
+  os << "], chunk=[";
+
+  for(size_t i=0; i<_chunk_shape.size(); ++i) {
+    if(i) os << 'x';
+    os << _chunk_shape[i];
+  }
+
+  os << "], pgrid=[";
+
+  for(size_t i=0; i<_chunk_grid.size(); ++i) {
+    if(i) os << 'x';
+    os << _chunk_grid[i];
+  }
+
+  os << "]\n}\n";
+}
+
+template <typename T>
+void Tensor<T>::_make_chunks() {  
+
+  size_t M = _max_elements;
+  size_t P = 1;
+  size_t N = 1;
+
+  for(int i=_shape.size()-1; i>=0; i--) {
+    if(M >= _shape[i]) {
+      _chunk_shape[i] = _shape[i];
+      _chunk_grid[i] = 1;
+      N *= _chunk_shape[i];
+      M /= _shape[i];
+    }
+    else {
+      _chunk_shape[i] = M;
+      _chunk_grid[i] = (_shape[i] + _chunk_shape[i] - 1) / _chunk_shape[i];
+      P *= _chunk_grid[i];
+      N *= _chunk_shape[i];
+      for(i--; i>=0; i--) {
+        _chunk_shape[i] = 1;
+        _chunk_grid[i] = _shape[i];
+        P *= _chunk_grid[i];
+      }
+      break;
+    }
+  }
+
+  _chunks.resize(P);
+
+  // we allocate the first data in memory
+  _chunks[0].data.resize(N);
+
+  // TODO: the rest sits in the disk
+  for(size_t i=1; i<_chunks.size(); ++i) {
+  }
+}
+    
+}  // end of namespace tf -----------------------------------------------------
+
+
+
+
+
+
+
+
+
diff --git a/taskflow/tensorframe/tensor_expr.hpp b/taskflow/tensorframe/tensor_expr.hpp
diff --git a/taskflow/tensorframe/tensor_graph.hpp b/taskflow/tensorframe/tensor_graph.hpp
diff --git a/taskflow/tensorframe/tensorframe.hpp b/taskflow/tensorframe/tensorframe.hpp
