finally finished gpu support git add .!

Author: jolatechno

README.md

@@ -20,9 +20,9 @@ To compile it with __Openmp__ and enable Offlowding to GPUs, you will need to us
 
 All arithmetic operations, self-operators, and comparisons excluding `==, !=` (for performance reasons) are now supported on GPUs.
 
-Operation requiring xor reduction on single bytes (currently only __multiplication between a `Matrix` and a `Vector`__) have a performance disadvantage on GPUs because atomic xor for type `uint8_t` is not supported by Openmp on GPU (see [issue #1](https://github.com/jolatechno/binary_algebra/issues/1)), and so the use of `omp critical` was required which is a huge performance hit compared to `omp atomic`.
+Atomic operations for type `uint8_t` are not supported by __Openmp__ on GPU (see [issue #1](https://github.com/jolatechno/binary_algebra/issues/1)). I finally found a work around for every operation, either by converting types, or by grouping operations together to only apply atomic operations on `long unsigned int`.
 
-I will implement threshold for which will redirect operation to the CPU without Opnemp, the CPU with Openmp, or GPUs; according to the size of the `Matrix` or `Vector`.
+I will implement threshold for which will redirect operation to the CPU without __Openmp__, the CPU with __Openmp__, or GPUs; according to the size of the `Matrix` or `Vector`.
 
 ## What is "binary algebra" ?
 

src/arithmetic.inl

@@ -232,7 +232,7 @@ Matrix Matrix::operator*(Matrix const& other) const {
   for (j = 0; j < _size; j++)
     for (k = 0; k < _width; k++)
       for (i = 0; i < _height; i++) {
-        #pragma omp atomic
+        _OPENMP_PRAGMA("omp atomic")
         res_blocks[i + j*_height] ^= multiply_block_block(this_blocks[k + j*_width], other_blocks[i + k*_size]);
       }
 
@@ -244,17 +244,27 @@ Vector Matrix::operator*(Vector const& other) const {
 
   Vector res(height);
 
-  int16_t _width = width;
-  int16_t _height = height;
+  auto _width = width;
+  auto _height = height;
 
-  ARITHMETIC_VARIABLE_HEADER;
+  long unsigned int *res_blocks = (long unsigned int*)res.blocks;
+  uint8_t *other_blocks = other.blocks;
+  uint64_t *this_blocks = blocks;
 
   int16_t i, k;
   _OPENMP_GPU_PRAGMA("omp parallel for collapse(2) schedule(static) shared(other_blocks, res_blocks, this_blocks)", \
     "omp target teams distribute parallel for collapse(2) map(to:this_blocks[:_width * _height], other_blocks[:_width]) map(from:res_blocks[:_height])")
   for (k = 0; k < _width; k++)
-    for (i = 0; i < _height; i++)
-      utils->_atomic_xor_fetch_8(res_blocks[i], multiply_block_byte(this_blocks[k + i*_width], other_blocks[k]));
+    for (i = 0; i < _height/8; i++) {
+      _OPENMP_PRAGMA("omp atomic")
+      res_blocks[i] ^= multiply_block_word(this_blocks[k + 8*i*_width], this_blocks[k + (8*i + 1)*_width], this_blocks[k + (8*i + 2)*_width], this_blocks[k + (8*i + 3)*_width], \
+        this_blocks[k + (8*i + 4)*_width], this_blocks[k + (8*i + 5)*_width], this_blocks[k + (8*i + 6)*_width], this_blocks[k + (8*i + 7)*_width], \
+        other_blocks[k]);
+    }
+
+  for (k = 0; k < _width; k++)
+    for (i = _height - _height%8; i < _height; i++)
+      res.blocks[i] ^= multiply_block_byte(this_blocks[k + i*_width], other_blocks[k]);
 
   return res;
 }

src/binary_arithmetic.hpp

@@ -22,15 +22,14 @@ class Matrix {
     Utils* utils;
 
     //block operations
-    #if defined(_OPENMP) &&  defined(TARGET)
-      #pragma omp declare target
-    #endif
+    _OPENMP_GPU("omp declare target")
     inline uint64_t transpose_block(uint64_t block) const;
     inline uint8_t multiply_block_byte(uint64_t block, uint8_t vect) const;
+    inline uint64_t multiply_block_word(uint64_t block0, uint64_t block1, uint64_t block2, uint64_t block3, \
+      uint64_t block4, uint64_t block5, uint64_t block6, uint64_t block7, \
+      uint8_t vect) const;
     inline uint64_t multiply_block_block(uint64_t block_left, uint64_t block_right) const;
-    #if defined(_OPENMP) &&  defined(TARGET)
-      #pragma omp end declare target
-    #endif
+    _OPENMP_GPU("omp end declare target")
 
     //for comparaisons
     int difference(Matrix const& mat) const;
@@ -117,13 +116,9 @@ class Vector {
     Utils* utils;
 
     //block operations
-    #if defined(_OPENMP) &&  defined(TARGET)
-      #pragma omp declare target
-    #endif
+    _OPENMP_GPU("omp declare target")
     inline uint64_t multiply_byte_byte(uint8_t vect_left, uint8_t vect_right) const;
-    #if defined(_OPENMP) &&  defined(TARGET)
-      #pragma omp end declare target
-    #endif
+    _OPENMP_GPU("omp end declare target")
 
     //for comparaisons
     int difference(Vector const& vect) const;

src/openmp.hpp

@@ -15,4 +15,12 @@
     #define _OPENMP_GPU_PRAGMA(cpu, gpu)
 
   #endif
+
+  #if defined(_OPENMP) && defined(TARGET)
+    #define _OPENMP_GPU(gpu) _Pragma(gpu)
+
+  #else
+    #define _OPENMP_GPU(gpu)
+    
+  #endif
 #endif

src/utils/block_arithmetic.inl

@@ -39,6 +39,20 @@ inline  uint8_t Matrix::multiply_block_byte(uint64_t block, uint8_t vect) const
   return sum;
 }
 
+inline uint64_t Matrix::multiply_block_word(uint64_t block0, uint64_t block1, uint64_t block2, uint64_t block3, \
+  uint64_t block4, uint64_t block5, uint64_t block6, uint64_t block7, \
+  uint8_t vect) const {
+  uint64_t res = multiply_block_byte(block7, vect);
+  res = (res << 8) | multiply_block_byte(block6, vect);
+  res = (res << 8) | multiply_block_byte(block5, vect);
+  res = (res << 8) | multiply_block_byte(block4, vect);
+  res = (res << 8) | multiply_block_byte(block3, vect);
+  res = (res << 8) | multiply_block_byte(block2, vect);
+  res = (res << 8) | multiply_block_byte(block1, vect);
+
+  return (res << 8) | multiply_block_byte(block0, vect);
+}
+
 inline  uint64_t Matrix::multiply_block_block(uint64_t block_left, uint64_t block_right) const { //changed to acomodate the switch in block indices, check the readme
   uint64_t res = 0;
   //uint64_t block_right_t = transpose_block(block_right);
@@ -49,6 +63,7 @@ inline  uint64_t Matrix::multiply_block_block(uint64_t block_left, uint64_t bloc
   return res;
 }
 
+
 inline  uint64_t Vector::multiply_byte_byte(uint8_t vect_left, uint8_t vect_right) const { //changed to acomodate the switch in block indices, check the readme
   uint64_t res = 0;
 

src/utils/utils.hpp

@@ -12,18 +12,12 @@ class Utils {
   friend class Matrix;
 
   private:
-    #if defined(_OPENMP) &&  defined(TARGET)
-      #pragma omp declare target
-    #endif
+    _OPENMP_GPU("omp declare target")
     static inline bool bit_out_of_byte_reversed(uint8_t byte, uint8_t bit);
     static inline uint8_t byte_out_of_word_reversed(uint64_t word, uint8_t byte);
     static inline int count_ones_8(uint8_t byte);
     static inline int count_ones_64(uint64_t word);
-
-    static inline void _atomic_xor_fetch_8(uint8_t &x1, uint8_t x2); //because openmp dosen't implement it on GPUs
-    #if defined(_OPENMP) &&  defined(TARGET)
-      #pragma omp end declare target
-    #endif
+    _OPENMP_GPU("omp end declare target")
 };
 
 inline bool Utils::bit_out_of_byte_reversed(uint8_t byte, uint8_t bit) {
@@ -51,8 +45,3 @@ inline int Utils::count_ones_64(uint64_t word) {
 
   return sum;
 }
-
-inline void Utils::_atomic_xor_fetch_8(uint8_t &x1, uint8_t x2) {
-  _OPENMP_GPU_PRAGMA("omp atomic", "omp critical")
-  x1 ^= x2;
-}