Better allocator support

README.md

@@ -153,6 +153,45 @@ int main()
 	hmap.insert(src.data(),src.size());
 }
 ```
+### Hashinator and SplitVector can also be used with external allocators   
+
+```c++
+#include "splitvec.h"
+//main.cu
+using vector = split::SplitVector<int,std::allocator<int>>;
+
+
+int main()
+{
+	vector* vec = new vector{1,2,3,4,5};
+	vec->reserve(128);
+	std::cout<<vec[3]<<std::endl;
+	delete vec;
+}
+```
+
+```c++
+//main.cpp
+#include "hashinator.h"
+
+int main()
+{
+
+   Hashmap<uint32_t,uint32_t,std::allocator<uint32_t>> hmap;
+
+   //Write
+   for (uint32_t i=0 ; i<64; ++i){
+      hmap[i]=rand()%10000;
+   }
+
+   //Read
+   for (const auto& i:hmap){
+      std::cout<<"["<<i.first<<" "<<i.second<<"] ";
+   }
+   std::cout<<std::endl;
+}
+```
+
 `nvcc   main.cu  -std=c++17  --expt-relaxed-constexpr --expt-extended-lambda -gencode arch=compute_80,code=sm_80 -o example`
 
 You can have a look in the Doxygen for a more feature-rich explanation of the methods and tools included!   

include/common.h

@@ -76,6 +76,7 @@ inline bool isDeviceAccessible(void* ptr){
     }
     return true;
 #endif
+  return false;
 }
 
 /**

include/hashinator/hashinator.h

@@ -51,7 +51,7 @@ using DefaultAllocator = split::split_unified_allocator<T>;
                    defaults::elementsPerWarp>
 #else
 template <typename T>
-using DefaultAllocator = split::split_host_allocator<T>;
+using DefaultAllocator = std::allocator<T>;
 #define DefaultHasher void
 #endif
 
@@ -116,7 +116,7 @@ class Hashmap {
    inline void set_status(status code) noexcept { _mapInfo->err = code; }
 
 public:
-   //By default we allocate enough space for 1<<5 elements
+   //By default we allocate enough space for 1<<5 (32) elements
    Hashmap():_allocator(Allocator{}) {
       preallocate_device_handles();
       _mapInfo = reinterpret_cast<MapInfo*>(_allocator.allocate(get_number_of_Ts_for_Map_Info()));
@@ -323,9 +323,12 @@ class Hashmap {
 
       size_t priorFill = _mapInfo->fill;
       // Extract all valid elements
-      hash_pair<KEY_TYPE, VAL_TYPE>* validElements;
-      SPLIT_CHECK_ERR(split_gpuMallocAsync((void**)&validElements,
-                                           (_mapInfo->fill + 1) * sizeof(hash_pair<KEY_TYPE, VAL_TYPE>), s));
+      hash_pair<KEY_TYPE, VAL_TYPE>* validElements=nullptr;
+      const std::size_t alloc_size=_mapInfo->fill+1;
+      validElements=_allocator.allocate(alloc_size);
+      if (!validElements){
+         throw std::runtime_error("ERORR: Failed to allocate temporary buffer in device rehash");
+      }
       if constexpr (prefetches) {
          optimizeGPU(s);
          SPLIT_CHECK_ERR(split_gpuStreamSynchronize(s));
@@ -347,7 +350,7 @@ class Hashmap {
       if (newSizePower == _mapInfo->sizePower && nValidElements == 0) {
          clear<prefetches>(targets::device, s, 1 << newSizePower);
          set_status((priorFill == _mapInfo->fill) ? status::success : status::fail);
-         split_gpuFreeAsync(validElements, s);
+         _allocator.deallocate(validElements,alloc_size); 
          return;
       }
       if (newSizePower == _mapInfo->sizePower) {
@@ -365,7 +368,7 @@ class Hashmap {
       // Insert valid elements to now larger buckets
       insert(validElements, nValidElements, 1, s);
       set_status((priorFill == _mapInfo->fill) ? status::success : status::fail);
-      split_gpuFreeAsync(validElements, s);
+      _allocator.deallocate(validElements,alloc_size); 
       return;
    }
 #endif
@@ -1336,10 +1339,12 @@ class Hashmap {
       // Allocate memory for overflown elements. So far this is the same size as our buckets but we can be better than
       // this
 
-      hash_pair<KEY_TYPE, VAL_TYPE>* overflownElements;
-      SPLIT_CHECK_ERR(split_gpuMallocAsync((void**)&overflownElements,
-                                           (1 << _mapInfo->sizePower) * sizeof(hash_pair<KEY_TYPE, VAL_TYPE>), s));
-
+      hash_pair<KEY_TYPE, VAL_TYPE>* overflownElements=nullptr;
+      const std::size_t alloc_size=_mapInfo->fill+1;
+      overflownElements=_allocator.allocate(alloc_size);
+      if (!overflownElements){
+         throw std::runtime_error("ERORR: Failed to allocate temporary buffer in tombstone cleaning");
+      }
       if constexpr (prefetches) {
          optimizeGPU(s);
       }
@@ -1367,7 +1372,7 @@ class Hashmap {
       _mapInfo->currentMaxBucketOverflow = defaults::BUCKET_OVERFLOW;
 
       if (nOverflownElements == 0) {
-         SPLIT_CHECK_ERR(split_gpuFreeAsync(overflownElements, s));
+         _allocator.deallocate(overflownElements,alloc_size);
          return;
       }
       // If we do have overflown elements we put them back in the buckets
@@ -1376,7 +1381,7 @@ class Hashmap {
 
       DeviceHasher::insert(overflownElements, buckets.data(), _mapInfo, nOverflownElements, s);
 
-      SPLIT_CHECK_ERR(split_gpuFreeAsync(overflownElements, s));
+      _allocator.deallocate(overflownElements,alloc_size);
       return;
    }
 
@@ -1484,9 +1489,9 @@ class Hashmap {
       if constexpr (prefetches) {
          optimizeGPU(stream);
       }
-      // device_buckets = (split::SplitVector<hash_pair<KEY_TYPE, VAL_TYPE>>*)((char*)device_map + offsetof(Hashmap,
-      // buckets)); SPLIT_CHECK_ERR(split_gpuMemcpyAsync(device_map, this, sizeof(Hashmap), split_gpuMemcpyHostToDevice,
-      // stream));
+      device_buckets = (split::SplitVector<hash_pair<KEY_TYPE, VAL_TYPE>, Allocator>*)((char*)device_map +
+                                                                                       offsetof(Hashmap, buckets));
+      SPLIT_CHECK_ERR(split_gpuMemcpyAsync(device_map, this, sizeof(Hashmap), split_gpuMemcpyHostToDevice, stream));
       return device_map;
    }
 
@@ -1813,27 +1818,22 @@ class Hashmap {
    }
 
    HASHINATOR_DEVICEONLY
-   const VAL_TYPE& read_element(const KEY_TYPE& key) const {
-      int bitMask = (1 << _mapInfo->sizePower) - 1; // For efficient modulo of the array size
-      auto hashIndex = hash(key);
-
-      // Try to find the matching bucket.
-      const size_t bsize = buckets.size();
-      for (size_t i = 0; i < bsize; i++) {
-         uint32_t vecindex = (hashIndex + i) & bitMask;
-         const hash_pair<KEY_TYPE, VAL_TYPE>& candidate = buckets[vecindex];
-         if (candidate.first == key) {
-            // Found a match, return that
-            return candidate.second;
-         }
-         if (candidate.first == EMPTYBUCKET) {
-            // Found an empty bucket, so error.
-            assert(false && "Key does not exist");
-         }
-      }
-      assert(false && "Key does not exist");
-   }
-
+   std::optional<std::reference_wrapper<const VAL_TYPE>> read_element(const KEY_TYPE& key) const {
+   int bitMask = (1 << _mapInfo->sizePower) - 1;
+   auto hashIndex = hash(key);
+   const size_t bsize = buckets.size();
+   for (size_t i = 0; i < bsize; i++) {
+       uint32_t vecindex = (hashIndex + i) & bitMask;
+       const hash_pair<KEY_TYPE, VAL_TYPE>& candidate = buckets[vecindex];
+       if (candidate.first == key) {
+           return candidate.second; 
+       }
+       if (candidate.first == EMPTYBUCKET) {
+           return std::nullopt; 
+       }
+   }
+   return std::nullopt;
+}
 #else
 
    // Uses Hasher's insert_kernel to insert all elements

include/splitvector/splitvec.h

@@ -289,11 +289,9 @@ class SplitVector {
    HOSTONLY SplitVector(SplitVector<T, Allocator>&& other) noexcept {
       _allocator=other._allocator;
       _data = other._data;
-      _info->size = other.size();
-      _info->capacity = other.capacity();
-      _info->capacity = 0;
-      _info->size = 0;
+      _info = other._info;
       other._data = nullptr;
+      other._info = nullptr;
       _location = other._location;
       d_vec = nullptr;
    }
@@ -417,6 +415,7 @@ class SplitVector {
 
    /**
     * @brief Move assignment operator to move from another SplitVector.
+    * Supported only for vectors of same Allocator type
     *
     * @param other The SplitVector to move from.
     * @return Reference to the moved SplitVector.
@@ -427,12 +426,11 @@ class SplitVector {
       }
 
       _deallocate_and_destroy(capacity(), _data);
+      _allocator.deallocate(reinterpret_cast<T*>(_info),get_number_of_Ts_for_Split_Info());
       _data = other._data;
-      _info->size = other.size();
-      _info->capacity= other.capacity();
-      other._info->capacity = 0;
-      other._info->size = 0;
+      _info = other._info;
       other._data = nullptr;
+      other._info = nullptr;
       _location = other._location;
       d_vec = nullptr;
       return *this;
@@ -608,9 +606,6 @@ class SplitVector {
     * are invalidated after swap is called.
     */
    void swap(SplitVector<T, Allocator>& other) noexcept {
-      if (*this == other) { // no need to do any work
-         return;
-      }
       split::swap(_data, other._data);
       split::swap(_info, other._info);
       split::swap(_allocator, other._allocator);
@@ -737,7 +732,7 @@ class SplitVector {
       }
       // Nope.
       if (requested_space <= current_space) {
-         if constexpr (!std::is_trivial<T>::value) {
+         if constexpr (!std::is_trivially_copy_constructible_v<T>) {
             for (size_t i = size(); i < requested_space; ++i) {
                _allocator.construct(&_data[i], T());
             }
@@ -970,7 +965,7 @@ class SplitVector {
    HOSTDEVICE
    void remove_from_back(size_t n) noexcept {
       const size_t end = size() - n;
-      if constexpr (!std::is_trivial<T>::value) {
+      if constexpr (!std::is_trivially_copy_constructible_v<T>) {
          for (auto i = size(); i > end;) {
             (_data + --i)->~T();
          }
@@ -983,7 +978,7 @@ class SplitVector {
     */
    HOSTDEVICE
    void clear() noexcept {
-      if constexpr (!std::is_trivial<T>::value) {
+      if constexpr (!std::is_trivially_copy_constructible_v<T>) {
          for (size_t i = 0; i < size(); i++) {
             _data[i].~T();
          }
@@ -1066,14 +1061,6 @@ class SplitVector {
     */
    HOSTONLY
    void push_back(const T&& val) {
-
-      // If we have no allocated memory because the default ctor was used then
-      // allocate one element, set it and return
-      // if (_data == nullptr) {
-      //    _allocate(1);
-      //    _data[size() - 1] = val;
-      //    return;
-      // }
       resize(size() + 1);
       _data[size() - 1] = std::move(val);
       return;
@@ -1491,7 +1478,7 @@ class SplitVector {
    HOSTDEVICE
    iterator erase(iterator it) noexcept {
       const int64_t index = it.data() - begin().data();
-      if constexpr (!std::is_trivial<T>::value) {
+      if constexpr (!std::is_trivially_copy_constructible_v<T>) {
          _data[index].~T();
          for (size_t i = index; i < size() - 1; i++) {
             new (&_data[i]) T(_data[i + 1]);
@@ -1521,7 +1508,7 @@ class SplitVector {
       const int64_t range = end - start;
 
       const size_t sz = size();
-      if constexpr (!std::is_trivial<T>::value) {
+      if constexpr (!std::is_trivially_copy_constructible_v<T>) {
          for (int64_t i = start; i < end; i++) {
             _data[i].~T();
          }
@@ -1559,7 +1546,7 @@ class SplitVector {
       resize(size() + 1);
       iterator it = &_data[index];
       std::move(it.data(), end().data(), it.data() + 1);
-      if constexpr (!std::is_trivial<T>::value) {
+      if constexpr (!std::is_trivially_copy_constructible_v<T>) {
          _allocator.destroy(it.data());
          _allocator.construct(it.data(), args...);
       }else{

meson.build

@@ -1,4 +1,4 @@
-project('Hashinator', 'cpp', 'cuda' ,default_options : ['cpp_std=c++20','warning_level=2','werror=true','buildtype=debugoptimized'])
+project('Hashinator', 'cpp', 'cuda' ,default_options : ['cpp_std=c++20','warning_level=2','werror=false','buildtype=debugoptimized'])
 
 #Config
 add_global_arguments('-DHASHMAPDEBUG', language : 'cpp')

unit_tests/gtest_vec_device/memtest.h

@@ -0,0 +1,45 @@
+#include <iostream>
+#include <stdlib.h>
+//#include <chrono>
+#include "../../include/splitvector/splitvec.h"
+#include "../../include/splitvector/split_tools.h"
+#include <gtest/gtest.h>
+
+#define CHK_ERR(err) (cuda_error(err, __FILE__, __LINE__))
+
+typedef split::SplitVector<int,split::split_unified_allocator<int>> vec ;
+
+
+struct testStructure {
+   testStructure(const size_t initSize=100) {
+      std::cerr<<"a"<<std::endl;
+      testContent = vec(initSize);
+      std::cerr<<"b"<<std::endl;
+   };
+   size_t capacity() const {
+      return testContent.capacity();
+   };
+   size_t size() const {
+      return testContent.size();
+   };
+   void shrink_to_fit() {
+      testContent.shrink_to_fit();
+   };
+   void shrink_to_fit_2() {
+      vec testContent_new(size());
+      testContent_new.overwrite(testContent);
+      testContent.swap(testContent_new);
+   };
+   void recapacitate(size_t newCapacity) {
+      testContent.reserve(newCapacity,true);
+   }; 
+   void resize(size_t newSize) {
+      testContent.resize(newSize);
+   }; 
+   size_t capacityInBytes() const {
+      return testContent.capacity() * sizeof(uint);
+   };
+
+   vec testContent;
+};
+