Compiler Explorer

Source code

#include <cuco/static_map.cuh>

#include <thrust/device_vector.h>
#include <thrust/equal.h>
#include <thrust/iterator/zip_iterator.h>
#include <thrust/sequence.h>
#include <thrust/transform.h>

#include <cmath>
#include <cstddef>
#include <iostream>
#include <limits>

/**
 * @file host_bulk_example.cu
 * @brief Demonstrates usage of the static_map "bulk" host APIs.
 *
 * The bulk APIs are only invocable from the host and are used for doing operations like insert or
 * find on a set of keys.
 *
 */

int main(void)
{
  using Key   = int;
  using Value = int;

// Empty slots are represented by reserved "sentinel" values. These values should be selected such
  // that they never occur in your input data.
  Key constexpr empty_key_sentinel     = -1;
  Value constexpr empty_value_sentinel = -1;

// Number of key/value pairs to be inserted
  std::size_t constexpr num_keys = 50;

// Compute capacity based on a 50% load factor
  auto constexpr load_factor = 0.5;
  std::size_t const capacity = std::ceil(num_keys / load_factor);

// Constructs a map with "capacity" slots using -1 and -1 as the empty key/value sentinels.
  cuco::static_map<Key, Value> map{
    capacity, cuco::empty_key{empty_key_sentinel}, cuco::empty_value{empty_value_sentinel}};

// Create a sequence of keys and values {{0,0}, {1,1}, ... {i,i}}
  thrust::device_vector<Key> insert_keys(num_keys);
  thrust::sequence(insert_keys.begin(), insert_keys.end(), 0);
  thrust::device_vector<Value> insert_values(num_keys);
  thrust::sequence(insert_values.begin(), insert_values.end(), 0);
  auto zipped =
    thrust::make_zip_iterator(thrust::make_tuple(insert_keys.begin(), insert_values.begin()));

// Inserts all pairs into the map
  map.insert(zipped, zipped + insert_keys.size());

// fetch the number of stored key/value pairs stored in the map
  auto const size = map.get_size();

// reserve memory for the result
  thrust::device_vector<Key> all_keys(size);
  thrust::device_vector<Value> all_values(size);
  
  // fetch all the key/value paires stored in the map
  map.retrieve_all(all_keys.begin(), all_values.begin());

// print pairs (uses a simple index-based for loop for simplicity)
  for (size_t i = 0; i < size; ++i) {
    std::cout << "Key: " << all_keys[i] << ", Value: " << all_values[i] << std::endl;
  }

return 0;
}