anonymous_namespace{OverlapsJoinHashTable.cpp} Namespace Reference

Classes
struct	BucketSizeTuner

Functions
void	compute_bucket_sizes (std::vector< double > &bucket_sizes_for_dimension, const double bucket_threshold, const Data_Namespace::MemoryLevel effective_memory_level, const JoinColumn &join_column, const JoinColumnTypeInfo &join_column_type, const std::vector< InnerOuter > &inner_outer_pairs, const Executor *executor)
std::ostream &	operator<< (std::ostream &os, const BucketSizeTuner &tuner)

Function Documentation

void anonymous_namespace{OverlapsJoinHashTable.cpp}::compute_bucket_sizes	(	std::vector< double > &	bucket_sizes_for_dimension,
		const double	bucket_threshold,
		const Data_Namespace::MemoryLevel	effective_memory_level,
		const JoinColumn &	join_column,
		const JoinColumnTypeInfo &	join_column_type,
		const std::vector< InnerOuter > &	inner_outer_pairs,
		const Executor *	executor
	)

Definition at line 127 of file OverlapsJoinHashTable.cpp.

References CHECK, CHECK_EQ, compute_bucket_sizes_on_cpu(), compute_bucket_sizes_on_device(), CudaAllocator::copyFromDevice(), Data_Namespace::CPU_LEVEL, cpu_threads(), to_string(), transfer_flat_object_to_gpu(), transfer_vector_of_flat_objects_to_gpu(), and VLOG.

Referenced by anonymous_namespace{OverlapsJoinHashTable.cpp}::BucketSizeTuner::computeBucketSizes().

                                                    {
  // No coalesced keys for overlaps joins yet
  CHECK_EQ(inner_outer_pairs.size(), 1u);

  const auto col = inner_outer_pairs[0].first;
  CHECK(col);
  const auto col_ti = col->get_type_info();
  CHECK(col_ti.is_array());

  // TODO: Compute the number of dimensions for this overlaps key
  const int num_dims = 2;
  std::vector<double> local_bucket_sizes(num_dims, std::numeric_limits<double>::max());

  VLOG(1)
      << "Computing x and y bucket sizes for overlaps hash join with minimum bucket size "
      << std::to_string(bucket_threshold);

  if (effective_memory_level == Data_Namespace::MemoryLevel::CPU_LEVEL) {
    const int thread_count = cpu_threads();
    compute_bucket_sizes_on_cpu(local_bucket_sizes,
                                join_column,
                                join_column_type,
                                bucket_threshold,
                                thread_count);
  }
#ifdef HAVE_CUDA
  else {
    // Note that we compute the bucket sizes using only a single GPU
    const int device_id = 0;
    auto& data_mgr = executor->getCatalog()->getDataMgr();
    CudaAllocator allocator(&data_mgr, device_id);
    auto device_bucket_sizes_gpu =
        transfer_vector_of_flat_objects_to_gpu(local_bucket_sizes, allocator);
    auto join_column_gpu = transfer_flat_object_to_gpu(join_column, allocator);
    auto join_column_type_gpu = transfer_flat_object_to_gpu(join_column_type, allocator);

    compute_bucket_sizes_on_device(
        device_bucket_sizes_gpu, join_column_gpu, join_column_type_gpu, bucket_threshold);
    allocator.copyFromDevice(reinterpret_cast<int8_t*>(local_bucket_sizes.data()),
                             reinterpret_cast<int8_t*>(device_bucket_sizes_gpu),
                             local_bucket_sizes.size() * sizeof(double));
  }
#endif

  size_t ctr = 0;
  for (auto& bucket_sz : local_bucket_sizes) {
    VLOG(1) << "Computed bucket size for dim[" << ctr++ << "]: " << bucket_sz;
    bucket_sizes_for_dimension.push_back(1.0 / bucket_sz);
  }

  return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::ostream& anonymous_namespace{OverlapsJoinHashTable.cpp}::operator<<	(	std::ostream &	os,
		const BucketSizeTuner &	tuner
	)

Definition at line 237 of file OverlapsJoinHashTable.cpp.

References anonymous_namespace{OverlapsJoinHashTable.cpp}::BucketSizeTuner::bucket_threshold, anonymous_namespace{OverlapsJoinHashTable.cpp}::BucketSizeTuner::min_threshold, anonymous_namespace{OverlapsJoinHashTable.cpp}::BucketSizeTuner::num_steps, and anonymous_namespace{OverlapsJoinHashTable.cpp}::BucketSizeTuner::step.

                                                                     {
  os << "Step Num: " << tuner.num_steps << ", Threshold: " << std::fixed
     << tuner.bucket_threshold << ", Step Size: " << std::fixed << tuner.step
     << ", Min: " << std::fixed << tuner.min_threshold;
  return os;
}