fixing gpu multiplication

Author: jolatechno

src/arithmetic.inl

@@ -28,8 +28,8 @@ Matrix Matrix::T() const {
   uint64_t *this_blocks = blocks;
   uint64_t *res_blocks = res.blocks;
 
-  uint16_t _width = width;
-  uint16_t _height = height;
+  int _width = width;
+  int _height = height;
 
   int16_t i, j;
   #if defined(_OPENMP) && defined(TARGET)
@@ -67,7 +67,7 @@ Matrix Matrix::operator~() const {
   uint64_t *this_blocks = blocks;
   uint64_t *res_blocks = res.blocks;
 
-  uint16_t _size = width * height;
+  int _size = width * height;
 
   int16_t n;
   #if defined(_OPENMP) && defined(TARGET)
@@ -97,7 +97,7 @@ Vector Vector::operator~() const {
   uint8_t *this_blocks = blocks;
   uint8_t *res_blocks = res.blocks;
 
-  uint16_t _height = height;
+  int _height = height;
 
   int16_t i;
   #if defined(_OPENMP) && defined(TARGET)

src/binary_arithmetic.cpp

@@ -25,7 +25,7 @@ constructors
 */
 
 
-Matrix::Matrix(uint16_t _height, uint16_t _width) : height(_height), width(_width) {
+Matrix::Matrix(int _height, int _width) : height(_height), width(_width) {
   blocks = (uint64_t *) calloc(height * width, sizeof(uint64_t));
   if (blocks == NULL) throw std::bad_alloc();
   #ifdef MPIENABLED
@@ -38,7 +38,7 @@ Matrix::Matrix(uint16_t _height, uint16_t _width) : height(_height), width(_widt
   #endif
 }
 
-Matrix::Matrix(uint16_t _size) : height(_size), width(_size) {
+Matrix::Matrix(int _size) : height(_size), width(_size) {
   blocks = (uint64_t *) calloc(_size * _size, sizeof(uint64_t));
   if (blocks == NULL) throw std::bad_alloc();
   #ifdef MPIENABLED
@@ -51,7 +51,7 @@ Matrix::Matrix(uint16_t _size) : height(_size), width(_size) {
   #endif
 }
 
-Vector::Vector(uint16_t _size): height(_size) {
+Vector::Vector(int _size): height(_size) {
   blocks = (uint8_t *) calloc(height, sizeof(uint64_t));
   if (blocks == NULL) throw std::bad_alloc();
   #ifdef MPIENABLED
@@ -81,7 +81,7 @@ Matrix::Matrix(Matrix const& other) : height(other.height), width(other.width) {
   memcpy(blocks, other.blocks, height * width * sizeof(uint64_t)); //copy blocks
 
   #if defined(_OPENMP) && defined(TARGET)
-    uint16_t _size = height * width;
+    int _size = height * width;
     uint64_t *this_blocks = blocks;
     #pragma omp target enter data map(to:this_blocks[:_size])
   #endif
@@ -98,7 +98,7 @@ Vector::Vector(Vector const& other) : height(other.height) {
   memcpy(blocks, other.blocks, height * sizeof(uint8_t)); //copy blocks
 
   #if defined(_OPENMP) && defined(TARGET)
-    uint16_t _height = height;
+    int _height = height;
     uint8_t *this_blocks = blocks;
     #pragma omp target enter data map(to:this_blocks[:_height])
   #endif
@@ -112,7 +112,7 @@ destructors
 
 Matrix::~Matrix(){
   #if defined(_OPENMP) && defined(TARGET)
-    uint16_t _size = height * width;
+    int _size = height * width;
     uint64_t *this_blocks = blocks;
     #pragma omp target exit data map(delete:this_blocks[:_size])
   #endif
@@ -121,7 +121,7 @@ Matrix::~Matrix(){
 
 Vector::~Vector(){
   #if defined(_OPENMP) && defined(TARGET)
-    uint16_t _height = height;
+    int _height = height;
     uint8_t *this_blocks = blocks;
     #pragma omp target exit data map(delete:this_blocks[:_height])
   #endif

src/binary_arithmetic.hpp

@@ -17,10 +17,10 @@ slice struct
 
 struct vector_slice {
   Vector *vect;
-  uint16_t start, length;
+  int start, length;
 
   //constructor
-  vector_slice(uint16_t _start, uint16_t _length, Vector *_vect) : start(_start), length(_length), vect(_vect) {}
+  vector_slice(int _start, int _length, Vector *_vect) : start(_start), length(_length), vect(_vect) {}
 
   operator Vector() const; //implicite comvertion
   vector_slice& operator=(Vector const& other); //assignment operators
@@ -29,10 +29,10 @@ struct vector_slice {
 
 struct matrix_slice {
   Matrix *mat;
-  uint16_t start_i, start_j, length_i, length_j;
+  int start_i, start_j, length_i, length_j;
 
   //constructor
-  matrix_slice(uint16_t _start_i, uint16_t _start_j, uint16_t _length_i, uint16_t _length_j, Matrix *_mat) : start_i(_start_i), start_j(_start_j), length_i(_length_i), length_j(_length_j), mat(_mat) {}
+  matrix_slice(int _start_i, int _start_j, int _length_i, int _length_j, Matrix *_mat) : start_i(_start_i), start_j(_start_j), length_i(_length_i), length_j(_length_j), mat(_mat) {}
 
   operator Matrix() const; //implicite comvertion
   matrix_slice& operator=(Matrix const& other); //assignment operators
@@ -47,13 +47,13 @@ assignment struct
 
 struct bool_from_byte {
   uint8_t *byte;
-  uint16_t i;
+  int i;
 
   //util operations
   Utils* utils;
 
   //constructor
-  bool_from_byte(int16_t _i, uint8_t *_byte) : i(_i), byte(_byte) {}
+  bool_from_byte(int _i, uint8_t *_byte) : i(_i), byte(_byte) {}
 
   operator bool() const; //implicite comvertion
   bool_from_byte& operator=(bool value); //assignment operators
@@ -65,13 +65,13 @@ struct bool_from_byte {
 
 struct bool_from_word {
   uint64_t *word;
-  uint16_t i, j;
+  int i, j;
 
   //util operations
   Utils* utils;
 
   //constructor
-  bool_from_word(int16_t _i, int16_t _j, uint64_t *_word) : i(_i), j(_j), word(_word) {}
+  bool_from_word(int _i, int _j, uint64_t *_word) : i(_i), j(_j), word(_word) {}
 
   operator bool() const; //implicite comvertion
   bool_from_word& operator=(bool value); //assignment operators
@@ -121,15 +121,15 @@ class Matrix {
     uint64_t *blocks;
 
     //Stupid way of accessing Matrix elements, only for testing or debugging !
-    bool_from_word operator()(uint16_t i, uint16_t j) const;
+    bool_from_word operator()(int i, int j) const;
 
     //size
-    const uint16_t height;
-    const uint16_t width;
+    const int height;
+    const int width;
 
     //constructors
-    Matrix(uint16_t mat_height, uint16_t mat_width);
-    Matrix(uint16_t size);
+    Matrix(int mat_height, int mat_width);
+    Matrix(int size);
 
     //destructor
     ~Matrix();
@@ -234,13 +234,13 @@ class Vector {
     uint8_t *blocks;
 
     //Stupid way of accessing vector elements, only for testing or debugging !
-    bool_from_byte operator[](uint16_t i) const;
+    bool_from_byte operator[](int i) const;
 
     //size
-    const uint16_t height;
+    const int height;
 
     //constructor
-    Vector(uint16_t size);
+    Vector(int size);
 
     //destructor
     ~Vector();

src/comparisons.inl

@@ -26,7 +26,7 @@ bool Matrix::operator==(Matrix const& other) const {
 
     bool equal_ = true;
 
-    int16_t n;
+    int n;
     _OPENMP_PRAGMA("omp parralel shared(this_blocks, other_blocks, _equal)")
     _OPENMP_PRAGMA("omp for")
     for (n = 0; n < _height * _width; n++) {
@@ -58,7 +58,7 @@ bool Vector::operator==(Vector const& other) const {
 
     bool equal_ = true;
 
-    int16_t i;
+    int i;
     _OPENMP_PRAGMA("omp parralel shared(this_blocks, other_blocks, _equal)")
     _OPENMP_PRAGMA("omp for")
     for (i = 0; i < _height; i++) {
@@ -96,7 +96,7 @@ bool Matrix::operator==(const bool bit) const {
   auto *this_blocks = blocks;
   auto _size = height * width;
 
-  int16_t n;
+  int n;
   _OPENMP_PRAGMA("omp parralel shared(this_blocks, _equal)")
   _OPENMP_PRAGMA("omp for")
   for (n = 0; n < _size; n++) {
@@ -123,7 +123,7 @@ bool Vector::operator==(const bool bit) const {
   auto *this_blocks = blocks;
   auto _height = height;
 
-  int16_t i;
+  int i;
   _OPENMP_PRAGMA("omp parralel shared(this_blocks, _equal)")
   _OPENMP_PRAGMA("omp for")
   for (i = 0; i < _height; i++) {
@@ -156,7 +156,7 @@ int Matrix::difference(Matrix const& other) const {
 
     int diff = 0;
 
-    int16_t n;
+    int n;
     #if defined(_OPENMP) && defined(TARGET)
       if(_size > GPU_LIMIT) {
         #pragma omp target teams distribute parallel for reduction(+ : diff) map(tofrom:diff)
@@ -186,7 +186,7 @@ int Vector::difference(Vector const& other) const {
 
     int diff = 0;
 
-    int16_t i;
+    int i;
     #if defined(_OPENMP) && defined(TARGET)
       if(_height > GPU_LIMIT) {
         #pragma omp target teams distribute parallel for reduction(+ : diff) map(tofrom:diff)

src/initializers.inl

@@ -19,9 +19,9 @@ void Matrix::randomize() {
   #endif
   uint8_t *block_8 = (uint8_t *)blocks;
 
-  uint16_t _size = height * width * 8;
+  int _size = height * width * 8;
 
-  int16_t i;
+  int i;
   _OPENMP_PRAGMA("omp parallel for shared(block_8)")
   for (i = 0; i < _size; i++)
     block_8[i] = rand();
@@ -45,7 +45,7 @@ void Vector::randomize() {
   #endif
   INITIALIZER_VECTOR_HEADER;
 
-  int16_t i;
+  int i;
   _OPENMP_PRAGMA("omp parallel for shared(this_blocks)")
   for (i = 0; i < _height; i++)
     this_blocks[i] = rand();
@@ -104,7 +104,7 @@ diagonal initializers
 void Matrix::diag() {
   INITIALIZER_SQUARE_MATRIX_HEADER;
 
-  int16_t i, j;
+  int i, j;
   _OPENMP_PRAGMA("omp parallel for collapse(2) shared(this_blocks)")
   for (i = 0; i < _height; i++)
     for (j = 0; j < _width; j++)
@@ -122,15 +122,15 @@ void Matrix::diag() {
 void Matrix::diag(Vector const& diagonal) {
   INITIALIZER_SQUARE_MATRIX_HEADER;
 
-  int16_t i, j;
+  int i, j;
   _OPENMP_PRAGMA("omp parallel for collapse(2) shared(this_blocks)")
   for (i = 0; i < _height; i++)
     for (j = 0; j < _width; j++)
       if(i == j) {
         uint8_t block = diagonal.blocks[i];
         uint64_t res = 0;
 
-        for (int16_t k = 7; k >= 0; k--)
+        for (int k = 7; k >= 0; k--)
           res = (res << 9) | ((block >> k) & 0x01);
 
           blocks[i + j*_height] = res;

src/member/read_write.inl

@@ -46,15 +46,15 @@ read operators
 */
 
 
-bool_from_word Matrix::operator()(uint16_t i, uint16_t j) const { //changed to acomodate the switch in block indices, check the readme
+bool_from_word Matrix::operator()(int i, int j) const { //changed to acomodate the switch in block indices, check the readme
   assert(i < height * 8);  //check if indices are in range
   assert(j < width * 8);
 
   uint64_t *block = &blocks[j/8 + (i/8)*width];
   return bool_from_word(i%8, j%8, block);
 }
 
-bool_from_byte Vector::operator[](uint16_t i) const {
+bool_from_byte Vector::operator[](int i) const {
   assert(i < height * 8);  //check if indices are in range
 
   return bool_from_byte(i%8, &blocks[i/8]);

src/member/slice.inl

@@ -20,7 +20,7 @@ slice cast operator
 matrix_slice::operator Matrix() const {
   Matrix res(length_i, length_j);
 
-  for (int16_t i = 0; i < length_i; i++)
+  for (int i = 0; i < length_i; i++)
     memcpy(&res.blocks[i*length_j], &mat->blocks[start_j + (i + start_i)*mat->width], length_j * sizeof(uint64_t)); //copy blocks
 
   #if defined(_OPENMP) && defined(TARGET)
@@ -52,7 +52,7 @@ matrix_slice& matrix_slice::operator=(Matrix const& other) {
   assert(length_i == other.height);
   assert(length_j == other.width);
 
-  for (int16_t i = 0; i < length_i; i++) {
+  for (int i = 0; i < length_i; i++) {
     memcpy(&mat->blocks[start_j + (i + start_i)*mat->width], &other.blocks[i*length_j], length_j * sizeof(uint64_t)); //copy blocks
 
     #if defined(_OPENMP) && defined(TARGET)
@@ -79,7 +79,7 @@ matrix_slice& matrix_slice::operator=(matrix_slice const& other) {
   assert(length_i == other.length_i);
   assert(length_j == other.length_j);
 
-  for (int16_t i = 0; i < length_i; i++) {
+  for (int i = 0; i < length_i; i++) {
     memcpy(&mat->blocks[start_j + (i + start_i)*mat->width], &other.mat->blocks[other.start_j + (i + other.start_i)*other.mat->width], length_j * sizeof(uint64_t)); //copy blocks
 
     #if defined(_OPENMP) && defined(TARGET)

src/openmp.inl

@@ -1,13 +1,13 @@
 //gpu operations
 #if defined(_OPENMP) && defined(TARGET)
   void Matrix::to() {
-    uint16_t _size = height * width;
+    int _size = height * width;
     uint64_t *this_blocks = blocks;
     #pragma omp target update to(this_blocks[:_size])
   }
 
   void Vector::to() {
-    uint16_t _height = height;
+    int _height = height;
     uint8_t *this_blocks = blocks;
     #pragma omp target update to(this_blocks[:_height])
   }
@@ -23,13 +23,13 @@
   }
 
   void Matrix::from() {
-    uint16_t _size = height * width;
+    int _size = height * width;
     uint64_t *this_blocks = blocks;
     #pragma omp target update from(this_blocks[:_size])
   }
 
   void Vector::from() {
-    uint16_t _height = height;
+    int _height = height;
     uint8_t *this_blocks = blocks;
     #pragma omp target update from(this_blocks[:_height])
   }