anonymous_namespace{TableFunctionExecutionContext.cpp} Namespace Reference

Enumerations
enum	{   MANAGER, ERROR_BUFFER, COL_BUFFERS, COL_SIZES,   INPUT_STR_DICT_PROXIES, OUTPUT_BUFFERS, OUTPUT_STR_DICT_PROXIES, OUTPUT_ROW_COUNT,   KERNEL_PARAM_COUNT }

Functions
template<typename T >
const int8_t *	create_literal_buffer (const T literal, const ExecutorDeviceType device_type, std::vector< std::unique_ptr< char[]>> &literals_owner, CudaAllocator *gpu_allocator)
template<>
const int8_t *	create_literal_buffer (std::string *const literal, const ExecutorDeviceType device_type, std::vector< std::unique_ptr< char[]>> &literals_owner, CudaAllocator *gpu_allocator)
size_t	get_output_row_count (const TableFunctionExecutionUnit &exe_unit, size_t input_element_count)

Enumeration Type Documentation

anonymous enum

Enumerator
MANAGER
ERROR_BUFFER
COL_BUFFERS
COL_SIZES
INPUT_STR_DICT_PROXIES
OUTPUT_BUFFERS
OUTPUT_STR_DICT_PROXIES
OUTPUT_ROW_COUNT
KERNEL_PARAM_COUNT

Definition at line 633 of file TableFunctionExecutionContext.cpp.

     {
  MANAGER,
  ERROR_BUFFER,
  COL_BUFFERS,
  COL_SIZES,
  INPUT_STR_DICT_PROXIES,
  OUTPUT_BUFFERS,
  OUTPUT_STR_DICT_PROXIES,
  OUTPUT_ROW_COUNT,
  KERNEL_PARAM_COUNT,
};

Function Documentation

template<typename T >

const int8_t* anonymous_namespace{TableFunctionExecutionContext.cpp}::create_literal_buffer	(	const T	literal,
		const ExecutorDeviceType	device_type,
		std::vector< std::unique_ptr< char[]>> &	literals_owner,
		CudaAllocator *	gpu_allocator
	)

Definition at line 32 of file TableFunctionExecutionContext.cpp.

References CudaAllocator::alloc(), CHECK, CHECK_LE, CudaAllocator::copyToDevice(), CPU, GPU, heavydb.dtypes::T, and UNREACHABLE.

Referenced by TableFunctionExecutionContext::execute().

                                                                  {
  CHECK_LE(sizeof(T), sizeof(int64_t));  // pad to 8 bytes
  switch (device_type) {
    case ExecutorDeviceType::CPU: {
      literals_owner.emplace_back(std::make_unique<char[]>(sizeof(int64_t)));
      std::memcpy(literals_owner.back().get(), &literal, sizeof(T));
      return reinterpret_cast<const int8_t*>(literals_owner.back().get());
    }
    case ExecutorDeviceType::GPU: {
      CHECK(gpu_allocator);
      const auto gpu_literal_buf_ptr = gpu_allocator->alloc(sizeof(int64_t));
      gpu_allocator->copyToDevice(
          gpu_literal_buf_ptr, reinterpret_cast<const int8_t*>(&literal), sizeof(T));
      return gpu_literal_buf_ptr;
    }
  }
  UNREACHABLE();
  return nullptr;
}

Here is the call graph for this function:

Here is the caller graph for this function:

template<>

const int8_t* anonymous_namespace{TableFunctionExecutionContext.cpp}::create_literal_buffer	(	std::string *const	literal,
		const ExecutorDeviceType	device_type,
		std::vector< std::unique_ptr< char[]>> &	literals_owner,
		CudaAllocator *	gpu_allocator
	)

Definition at line 59 of file TableFunctionExecutionContext.cpp.

References CudaAllocator::alloc(), CHECK, CudaAllocator::copyToDevice(), CPU, GPU, and UNREACHABLE.

                                                                  {
  const int64_t string_size = literal->size();
  const int64_t padded_string_size =
      (string_size + 7) / 8 * 8;  // round up to the next multiple of 8
  switch (device_type) {
    case ExecutorDeviceType::CPU: {
      literals_owner.emplace_back(
          std::make_unique<char[]>(sizeof(int64_t) + padded_string_size));
      std::memcpy(literals_owner.back().get(), &string_size, sizeof(int64_t));
      std::memcpy(
          literals_owner.back().get() + sizeof(int64_t), literal->data(), string_size);
      return reinterpret_cast<const int8_t*>(literals_owner.back().get());
    }
    case ExecutorDeviceType::GPU: {
      CHECK(gpu_allocator);
      const auto gpu_literal_buf_ptr =
          gpu_allocator->alloc(sizeof(int64_t) + padded_string_size);
      gpu_allocator->copyToDevice(gpu_literal_buf_ptr,
                                  reinterpret_cast<const int8_t*>(&string_size),
                                  sizeof(int64_t));
      gpu_allocator->copyToDevice(gpu_literal_buf_ptr + sizeof(int64_t),
                                  reinterpret_cast<const int8_t*>(literal->data()),
                                  string_size);
      return gpu_literal_buf_ptr;
    }
  }
  UNREACHABLE();
  return nullptr;
}

Here is the call graph for this function:

size_t anonymous_namespace{TableFunctionExecutionContext.cpp}::get_output_row_count	(	const TableFunctionExecutionUnit &	exe_unit,
		size_t	input_element_count
	)

Definition at line 92 of file TableFunctionExecutionContext.cpp.

References table_functions::TableFunction::getOutputRowSizeType(), table_functions::kConstant, table_functions::kPreFlightParameter, table_functions::kTableFunctionSpecifiedParameter, table_functions::kUserSpecifiedConstantParameter, table_functions::kUserSpecifiedRowMultiplier, TableFunctionExecutionUnit::output_buffer_size_param, TableFunctionExecutionUnit::table_func, and UNREACHABLE.

Referenced by TableFunctionExecutionContext::launchCpuCode(), and TableFunctionExecutionContext::launchGpuCode().

                                                        {
  size_t allocated_output_row_count = 0;
  switch (exe_unit.table_func.getOutputRowSizeType()) {
    case table_functions::OutputBufferSizeType::kConstant:
    case table_functions::OutputBufferSizeType::kUserSpecifiedConstantParameter:
    case table_functions::OutputBufferSizeType::kPreFlightParameter: {
      allocated_output_row_count = exe_unit.output_buffer_size_param;
      break;
    }
    case table_functions::OutputBufferSizeType::kUserSpecifiedRowMultiplier: {
      allocated_output_row_count =
          exe_unit.output_buffer_size_param * input_element_count;
      break;
    }
    case table_functions::OutputBufferSizeType::kTableFunctionSpecifiedParameter: {
      allocated_output_row_count = input_element_count;
      break;
    }
    default: {
      UNREACHABLE();
    }
  }
  return allocated_output_row_count;
}

Here is the call graph for this function:

Here is the caller graph for this function: