large tensor

Author: linuxb

.gitignore

@@ -4,3 +4,5 @@ build
 
 /target
 **/*.rs.bk
+Makefile
+.idea

.idea/codeStyles/Project.xml

@@ -1,9 +1,10 @@
 cmake_minimum_required(VERSION 3.9)
 project(keigen)
 
+#set(LLVM_DIR /usr/local/opt/llvm/share/cmake/modules)
 set(CMAKE_CXX_STANDARD 11)
 find_package(LLVM REQUIRED CONFIG)
-
+#
 message(STATUS "Found LLVM ${LLVM_PACKAGE_VERSION}")
 message(STATUS "Using LLVMConfig.cmake in: ${LLVM_DIR}")
 
@@ -16,7 +17,7 @@ include_directories(${LLVM_INCLUDE_DIRS})
 add_definitions(${LLVM_DEFINITIONS})
 
 #find_package (Eigen3 3.3 REQUIRED NO_MODULE)
-include_directories(.)
+include_directories(Eigen)
 
 add_executable(r_traits traits.cpp)
 add_executable(r_boost boost.cpp)
@@ -31,4 +32,4 @@ llvm_map_components_to_libnames(llvm_libs core)
 # Link against LLVM libraries
 target_link_libraries(r_kvm ${llvm_libs})
 #target_link_libraries(r_kvm Eigen3::Eigen)
-#target_link_libraries(r_kq Eigen3::Eigen)
+#target_link_libraries(r_kq Eigen3::Eigen)s

.idea/keigen.iml

@@ -324,7 +324,7 @@ struct Assignment<DstXprType, Inverse<XprType>, internal::assign_op<typename Dst
   * \note This matrix must be invertible, otherwise the result is undefined. If you need an
   * invertibility check, do the following:
   * \li for fixed sizes up to 4x4, use computeInverseAndDetWithCheck().
-  * \li for the general case, use class FullPivLU.
+  * \li for the general case, use class x.
   *
   * Example: \include MatrixBase_inverse.cpp
   * Output: \verbinclude MatrixBase_inverse.out

.idea/misc.xml

@@ -1,5 +1,4 @@
 # keigen
-![](http://eigen.tuxfamily.org/images/Eigen_Silly_Professor_135x135.png)
-
 
+![](img/logo.png)
 Some toys for high performance computation includes computation graph KVM compiler etc.

.idea/modules.xml

@@ -2,35 +2,37 @@
 // Created by nuxeslin on 2018/11/7.
 //
 #include <iostream>
-#include <Eigen/Core>
+#include <Core>
 #include <stdlib.h>
 
 using namespace std;
 using namespace Eigen;
 
-template <int M, int N>
+template<int M, int N>
 void InitMat(float mat[M][N], int row_num, int col_num) {
 //    for (int i = 0; i < row_num; i++) {
 //        for (int j = 0; j < col_num; j++) {
 //            mat[i * col_num + j] = 1;
 //        }
 //    }
     for (int k = 0; k < row_num * col_num; k++) {
-        *((float*)mat + k) = 1;
+        *((float *) mat + k) = 1;
     }
 }
 
-template <size_t N>
+template<size_t N>
 struct MyAllocator {
     char buf[N];
     void *ptr;
     size_t sz;
+
     MyAllocator() : ptr(buf), sz(N) {}
-    template <typename T>
-    T* aligned_malloc(size_t a = alignof(T)) {
+
+    template<typename T>
+    T *aligned_malloc(size_t a = alignof(T)) {
         if (std::align(a, sizeof(T), ptr, sz)) {
-            auto res = reinterpret_cast<T*>(ptr);
-            ptr = (char*)res + sizeof(T);
+            auto res = reinterpret_cast<T *>(ptr);
+            ptr = (char *) res + sizeof(T);
             sz -= sizeof(T);
             return res;
         }
@@ -42,7 +44,7 @@ struct MyAllocator {
 struct KMatrix {
     int width;
     int height;
-    float* data;
+    float *data;
 };
 
 // set memory alignment
@@ -59,40 +61,41 @@ struct Area {
     double x3;
 };
 
-void Run() {
-    int size = 3;
-    Eigen::VectorXf v(size), u(size), w(size);
-    u = v + w;
-    std::cout << u << std::endl;
-}
-
 // at runtime
 void KL_bad_allocate() {
     auto huge = static_cast<size_t>(-1);
     ::operator new(huge);
 }
 
 void KL_compute_op() {
-    Eigen::Matrix2d mat;
-    KL_bad_allocate();
+    Eigen::MatrixXf mat(2, 2);
+    mat << 2, 4,
+           3, 9;
+    mat.inverse();
+//    KL_bad_allocate();
 //    std::bad_alloc();
 }
 
+void Run() {
+    KL_compute_op();
+}
+
+
 void AlignedAllocate() {
     char n = 'x';
     float q = 2.0;
-    printf("y1: 0x%lx\n", (size_t)&n);
+    printf("y1: 0x%lx\n", (size_t) &n);
     // without customized alignment
     // alignment equal to min(sizeof(float), 16) = 4 bytes
     // so there will be 3 bytes padding subsequently
     // - (4 + 3 = 7) bytes
-    printf("y2: 0x%lx\n", (size_t)&q);
+    printf("y2: 0x%lx\n", (size_t) &q);
     // alignment at heap
     printf("at heap:\n");
 //    auto pool = (Area*)malloc(sizeof(Area) * 3);
     Area *pool;
     // guarantee the address of `pool` multiple of 32(bytes), while `malloc` will not
-    if (posix_memalign(reinterpret_cast<void**>(&pool), 32, 64 * 3)) {
+    if (posix_memalign(reinterpret_cast<void **>(&pool), 32, 64 * 3)) {
         perror("error while allocate aligned memory\n");
     }
 //    pool = (Area*)malloc(24 * 3);
@@ -108,11 +111,11 @@ void AlignedAllocate() {
     pool[1] = {'o', 4};
     // it works
 //    pool[1000] = {'e', 7, 2};
-    printf("r0: %ld\n", ((size_t)&pool[0]) % 32);
-    printf("p1: 0x%lx\n", (size_t)&pool[1]);
+    printf("r0: %ld\n", ((size_t) &pool[0]) % 32);
+    printf("p1: 0x%lx\n", (size_t) &pool[1]);
     // + 48 bytes
-    printf("p2: 0x%lx\n", (size_t)&pool[2]);
-    printf("offset: %lu\n", ((char*)&pool[1] - (char*)&pool[0]));
+    printf("p2: 0x%lx\n", (size_t) &pool[2]);
+    printf("offset: %lu\n", ((char *) &pool[1] - (char *) &pool[0]));
 //    printf("%c\n", pool[1].x1);
 }
 
@@ -125,13 +128,13 @@ void Zmalloc() {
     // so we can access an element by *(buffer + i), let the pointer move up
     char buffer[6] = "kkkkk";
     // initialize to 0 when allocated at heap
-    auto ptr = (float*)malloc(4);
+    auto ptr = (float *) malloc(4);
     // non-successive at heap
     // arithmetic on a pointer to void is invalid
-    auto other = (float*)malloc(4);
+    auto other = (float *) malloc(4);
 //    posix_memalign((void**)&ptr, 16, 4);
-    cout << "ptr: " << (void*)ptr << endl;
-    printf("other: 0x%lx\n", (size_t)other);
+    cout << "ptr: " << (void *) ptr << endl;
+    printf("other: 0x%lx\n", (size_t) other);
     // only pointers to compatible type can be subtracted
     printf("ptr offset: %lu\n", (other - ptr));
     printf("alignof T: %lu\n", alignof(char));
@@ -140,12 +143,12 @@ void Zmalloc() {
     cout << "ptr0: " << allocator.ptr << endl;
     auto ptr1 = allocator.aligned_malloc<char>();
     *ptr1 = 'x';
-    cout << "ptr1: " << (void*)ptr1 << endl;
+    cout << "ptr1: " << (void *) ptr1 << endl;
     // internal pointer of allocator will be adjusted when std::align has been invoked
     // aligned at runtime
     auto ptr2 = allocator.aligned_malloc<int>(8);
     *ptr2 = 7;
-    cout << "ptr2: " << (void*)ptr2 << endl;
+    cout << "ptr2: " << (void *) ptr2 << endl;
     // size is 48 bytes when alignment is 16 bytes, and 32 bytes when 8 bytes, 28 bytes when 4 bytes
     printf("size of area: %lu\n", sizeof(Area));
     Area ka = {'x', 5};
@@ -175,11 +178,6 @@ int main() {
     char my_key[] = "lollipop";
     memset(my_key, 'k', 6);
     printf("%s\n", my_key);
-    InitMat<6, 6>(mat, 6, 6);
-    ::KMatrix cmat = {6, 5};
-    cmat.data = (float*)malloc(cmat.width * cmat.height * sizeof(float));
-    cmat.data[3] = 1;
-    printf("%.1f\n", cmat.data[3]);
     Run();
     Zmalloc();
 //    printf("size is %ld\n", sizeof(st));