                                    const size_type num_partitions,
                                    const partitioner_type the_partitioner,
                                    size_type * row_partition_numbers,
-                                   size_type * partition_sizes)
+                                   size_type * block_partition_sizes,
+                                   size_type * global_partition_sizes)
 {
   // Accumulate histogram of the size of each partition in shared memory
   extern __shared__ size_type shared_partition_sizes[];

  {
    return GDF_SUCCESS;
  }

  // check that the columns data are not null, have matching types,
  // and the same number of rows


  const size_type num_rows = table_to_hash.get_column_length();

  constexpr int rows_per_block = BLOCK_SIZE * ROWS_PER_THREAD;
  const size_type grid_size = (num_rows + rows_per_block - 1) / rows_per_block;

  // Allocate array to hold which partition each row belongs to
  size_type * row_partition_numbers{nullptr};
  CUDA_TRY( cudaMalloc(&row_partition_numbers, num_rows * sizeof(hash_value_type)) );

  // Array to hold the size of each partition computed by each block
  size_type * block_partition_sizes{nullptr};
  CUDA_TRY(cudaMalloc(&block_partition_sizes, (grid_size * num_partitions) * sizeof(size_type)));

  // Holds the total size of each partition
  size_type * partition_sizes{nullptr};
  CUDA_TRY( cudaMalloc(&partition_sizes, num_partitions * sizeof(size_type)) );
  CUDA_TRY( cudaMemsetAsync(partition_sizes, 0, num_partitions * sizeof(size_type)) );

  // If the number of partitions is a power of two, we can compute the partition 
  // number of each row more efficiently with bitwise operations
