anonymous_namespace{OverlapsJoinHashTable.cpp} Namespace Reference

Classes
struct	HashTableProps
struct	TuningState
class	BucketSizeTuner

Functions
std::vector< double >	correct_uninitialized_bucket_sizes_to_thresholds (const std::vector< double > &bucket_sizes, const std::vector< double > &bucket_thresholds, const double initial_value)
std::vector< double >	compute_bucket_sizes (const std::vector< double > &bucket_thresholds, 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 HashTableProps &props)
std::ostream &	operator<< (std::ostream &os, const BucketSizeTuner &tuner)

Function Documentation

std::vector<double> anonymous_namespace{OverlapsJoinHashTable.cpp}::compute_bucket_sizes	(	const std::vector< double > &	bucket_thresholds,
		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 162 of file OverlapsJoinHashTable.cpp.

References CHECK, CHECK_EQ, compute_bucket_sizes_on_cpu(), compute_bucket_sizes_on_device(), CudaAllocator::copyFromDevice(), correct_uninitialized_bucket_sizes_to_thresholds(), Data_Namespace::CPU_LEVEL, cpu_threads(), getQueryEngineCudaStreamForDevice(), 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 size_t num_dims{2};
  const double initial_bin_value{0.0};
  std::vector<double> bucket_sizes(num_dims, initial_bin_value);
  CHECK_EQ(bucket_thresholds.size(), num_dims);

  VLOG(1)
      << "Computing x and y bucket sizes for overlaps hash join with maximum bucket size "
      << std::to_string(bucket_thresholds[0]) << ", "
      << std::to_string(bucket_thresholds[1]);

  if (effective_memory_level == Data_Namespace::MemoryLevel::CPU_LEVEL) {
    const int thread_count = cpu_threads();
    compute_bucket_sizes_on_cpu(
        bucket_sizes, join_column, join_column_type, bucket_thresholds, 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->getDataMgr();
    CudaAllocator allocator(
        data_mgr, device_id, getQueryEngineCudaStreamForDevice(device_id));
    auto device_bucket_sizes_gpu =
        transfer_vector_of_flat_objects_to_gpu(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);
    auto device_bucket_thresholds_gpu =
        transfer_vector_of_flat_objects_to_gpu(bucket_thresholds, allocator);

    compute_bucket_sizes_on_device(device_bucket_sizes_gpu,
                                   join_column_gpu,
                                   join_column_type_gpu,
                                   device_bucket_thresholds_gpu);
    allocator.copyFromDevice(reinterpret_cast<int8_t*>(bucket_sizes.data()),
                             reinterpret_cast<int8_t*>(device_bucket_sizes_gpu),
                             bucket_sizes.size() * sizeof(double));
  }
#endif
  const auto corrected_bucket_sizes = correct_uninitialized_bucket_sizes_to_thresholds(
      bucket_sizes, bucket_thresholds, initial_bin_value);

  VLOG(1) << "Computed x and y bucket sizes for overlaps hash join: ("
          << corrected_bucket_sizes[0] << ", " << corrected_bucket_sizes[1] << ")";

  return corrected_bucket_sizes;
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector<double> anonymous_namespace{OverlapsJoinHashTable.cpp}::correct_uninitialized_bucket_sizes_to_thresholds	(	const std::vector< double > &	bucket_sizes,
		const std::vector< double > &	bucket_thresholds,
		const double	initial_value
	)

Definition at line 149 of file OverlapsJoinHashTable.cpp.

Referenced by compute_bucket_sizes().

                                {
  std::vector<double> corrected_bucket_sizes(bucket_sizes);
  for (size_t i = 0; i != bucket_sizes.size(); ++i) {
    if (bucket_sizes[i] == initial_value) {
      corrected_bucket_sizes[i] = bucket_thresholds[i];
    }
  }
  return corrected_bucket_sizes;
}

Here is the caller graph for this function:

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

Definition at line 246 of file OverlapsJoinHashTable.cpp.

References anonymous_namespace{OverlapsJoinHashTable.cpp}::HashTableProps::emitted_keys_count, anonymous_namespace{OverlapsJoinHashTable.cpp}::HashTableProps::entry_count, anonymous_namespace{OverlapsJoinHashTable.cpp}::HashTableProps::hash_table_size, and anonymous_namespace{OverlapsJoinHashTable.cpp}::HashTableProps::keys_per_bin.

                                                                    {
  os << " entry_count: " << props.entry_count << ", emitted_keys "
     << props.emitted_keys_count << ", hash table size " << props.hash_table_size
     << ", keys per bin " << props.keys_per_bin;
  return os;
}

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

Definition at line 524 of file OverlapsJoinHashTable.cpp.

References anonymous_namespace{OverlapsJoinHashTable.cpp}::BucketSizeTuner::bucket_thresholds_, 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_thresholds_[0] << ", " << tuner.bucket_thresholds_[1] << ")"
     << ", Step Size: " << std::fixed << tuner.step_ << ", Min: " << std::fixed
     << tuner.min_threshold_;
  return os;
}