Functions
bool	use_multithreaded_reduction (const size_t entry_count)

size_t	get_row_qw_count (const QueryMemoryDescriptor &query_mem_desc)

std::vector< int64_t >	make_key (const int64_t *buff, const size_t entry_count, const size_t key_count)

void	fill_slots (int64_t dst_entry, const size_t dst_entry_count, const int64_t src_buff, const size_t src_entry_idx, const size_t src_entry_count, const QueryMemoryDescriptor &query_mem_desc)

ALWAYS_INLINE void	fill_empty_key_32 (int32_t *key_ptr_i32, const size_t key_count)

ALWAYS_INLINE void	fill_empty_key_64 (int64_t *key_ptr_i64, const size_t key_count)

int64_t	get_component (const int8_t *group_by_buffer, const size_t comp_sz, const size_t index=0)

void	run_reduction_code (const size_t executor_id, const ReductionCode &reduction_code, int8_t this_buff, const int8_t that_buff, const int32_t start_entry_index, const int32_t end_entry_index, const int32_t that_entry_count, const void this_qmd, const void that_qmd, const void *serialized_varlen_buffer)

ALWAYS_INLINE void	check_watchdog ()

ALWAYS_INLINE void	check_watchdog_with_seed (const size_t sample_seed)

GroupValueInfo	get_matching_group_value_columnar_reduction (int64_t groups_buffer, const uint32_t h, const int64_t key, const uint32_t key_qw_count, const size_t entry_count)

GroupValueInfo	get_group_value_columnar_reduction (int64_t groups_buffer, const uint32_t groups_buffer_entry_count, const int64_t key, const uint32_t key_qw_count)

template<typename T = int64_t>
GroupValueInfo	get_matching_group_value_reduction (int64_t groups_buffer, const uint32_t h, const T key, const uint32_t key_count, const QueryMemoryDescriptor &query_mem_desc, const int64_t *that_buff_i64, const size_t that_entry_idx, const size_t that_entry_count, const uint32_t row_size_quad)

GroupValueInfo	get_matching_group_value_reduction (int64_t groups_buffer, const uint32_t h, const int64_t key, const uint32_t key_count, const size_t key_width, const QueryMemoryDescriptor &query_mem_desc, const int64_t *that_buff_i64, const size_t that_entry_idx, const size_t that_entry_count, const uint32_t row_size_quad)

Function Documentation

ALWAYS_INLINE void anonymous_namespace{ResultSetReduction.cpp}::check_watchdog ( )

Definition at line 386 of file ResultSetReduction.cpp.

References dynamic_watchdog(), and UNLIKELY.

Referenced by ResultSetStorage::reduceEntriesNoCollisionsColWise().

                                     {
   if (UNLIKELY(dynamic_watchdog())) {
     // TODO(alex): distinguish between the deadline and interrupt
     throw std::runtime_error(
         "Query execution has exceeded the time limit or was interrupted during result "
         "set reduction");
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

ALWAYS_INLINE void anonymous_namespace{ResultSetReduction.cpp}::check_watchdog_with_seed ( const size_t sample_seed )

Definition at line 395 of file ResultSetReduction.cpp.

References dynamic_watchdog(), and UNLIKELY.

Referenced by ResultSetStorage::reduceOneEntryBaseline().

                                                                       {
   if (UNLIKELY((sample_seed & 0x3F) == 0 && dynamic_watchdog())) {
     // TODO(alex): distinguish between the deadline and interrupt
     throw std::runtime_error(
         "Query execution has exceeded the time limit or was interrupted during result "
         "set reduction");
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

ALWAYS_INLINE void anonymous_namespace{ResultSetReduction.cpp}::fill_empty_key_32	(	int32_t *	key_ptr_i32,
		const size_t	key_count
	)

Definition at line 89 of file ResultSetReduction.cpp.

References EMPTY_KEY_32.

Referenced by result_set::fill_empty_key(), and ResultSetStorage::initializeRowWise().

                                                                      {
   for (size_t i = 0; i < key_count; ++i) {
     key_ptr_i32[i] = EMPTY_KEY_32;
   }
 }

Here is the caller graph for this function:

ALWAYS_INLINE void anonymous_namespace{ResultSetReduction.cpp}::fill_empty_key_64	(	int64_t *	key_ptr_i64,
		const size_t	key_count
	)

Definition at line 96 of file ResultSetReduction.cpp.

References EMPTY_KEY_64.

Referenced by result_set::fill_empty_key(), and ResultSetStorage::initializeRowWise().

                                                                      {
   for (size_t i = 0; i < key_count; ++i) {
     key_ptr_i64[i] = EMPTY_KEY_64;
   }
 }

Here is the caller graph for this function:

void anonymous_namespace{ResultSetReduction.cpp}::fill_slots	(	int64_t *	dst_entry,
		const size_t	dst_entry_count,
		const int64_t *	src_buff,
		const size_t	src_entry_idx,
		const size_t	src_entry_count,
		const QueryMemoryDescriptor &	query_mem_desc
	)

Definition at line 65 of file ResultSetReduction.cpp.

References QueryMemoryDescriptor::didOutputColumnar(), get_row_qw_count(), get_slot_off_quad(), QueryMemoryDescriptor::getBufferColSlotCount(), QueryMemoryDescriptor::getGroupbyColCount(), and slot_offset_colwise().

Referenced by get_matching_group_value_reduction(), ResultSetStorage::moveOneEntryToBuffer(), and ResultSetStorage::reduceOneEntryBaseline().

                                                              {
   const auto slot_count = query_mem_desc.getBufferColSlotCount();
   const auto key_count = query_mem_desc.getGroupbyColCount();
   if (query_mem_desc.didOutputColumnar()) {
     for (size_t i = 0, dst_slot_off = 0; i < slot_count;
          ++i, dst_slot_off += dst_entry_count) {
       dst_entry[dst_slot_off] =
           src_buff[slot_offset_colwise(src_entry_idx, i, key_count, src_entry_count)];
     }
   } else {
     const auto row_ptr = src_buff + get_row_qw_count(query_mem_desc) * src_entry_idx;
     const auto slot_off_quad = get_slot_off_quad(query_mem_desc);
     for (size_t i = 0; i < slot_count; ++i) {
       dst_entry[i] = row_ptr[slot_off_quad + i];
     }
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

int64_t anonymous_namespace{ResultSetReduction.cpp}::get_component	(	const int8_t *	group_by_buffer,
		const size_t	comp_sz,
		const size_t	index = `0`
	)

inline

Definition at line 102 of file ResultSetReduction.cpp.

References CHECK.

Referenced by ResultSetStorage::reduceSingleRow().

                                                      {
   int64_t ret = std::numeric_limits<int64_t>::min();
   switch (comp_sz) {
     case 1: {
       ret = group_by_buffer[index];
       break;
     }
     case 2: {
       const int16_t* buffer_ptr = reinterpret_cast<const int16_t*>(group_by_buffer);
       ret = buffer_ptr[index];
       break;
     }
     case 4: {
       const int32_t* buffer_ptr = reinterpret_cast<const int32_t*>(group_by_buffer);
       ret = buffer_ptr[index];
       break;
     }
     case 8: {
       const int64_t* buffer_ptr = reinterpret_cast<const int64_t*>(group_by_buffer);
       ret = buffer_ptr[index];
       break;
     }
     default:
       CHECK(false);
   }
   return ret;
 }

Here is the caller graph for this function:

GroupValueInfo anonymous_namespace{ResultSetReduction.cpp}::get_group_value_columnar_reduction	(	int64_t *	groups_buffer,
		const uint32_t	groups_buffer_entry_count,
		const int64_t *	key,
		const uint32_t	key_qw_count
	)

Definition at line 655 of file ResultSetReduction.cpp.

References get_matching_group_value_columnar_reduction(), and key_hash().

Referenced by ResultSetStorage::reduceOneEntryBaseline().

                                  {
   uint32_t h = key_hash(key, key_qw_count, sizeof(int64_t)) % groups_buffer_entry_count;
   auto matching_gvi = get_matching_group_value_columnar_reduction(
       groups_buffer, h, key, key_qw_count, groups_buffer_entry_count);
   if (matching_gvi.first) {
     return matching_gvi;
   }
   uint32_t h_probe = (h + 1) % groups_buffer_entry_count;
   while (h_probe != h) {
     matching_gvi = get_matching_group_value_columnar_reduction(
         groups_buffer, h_probe, key, key_qw_count, groups_buffer_entry_count);
     if (matching_gvi.first) {
       return matching_gvi;
     }
     h_probe = (h_probe + 1) % groups_buffer_entry_count;
   }
   return {nullptr, true};
 }

Here is the call graph for this function:

Here is the caller graph for this function:

GroupValueInfo anonymous_namespace{ResultSetReduction.cpp}::get_matching_group_value_columnar_reduction	(	int64_t *	groups_buffer,
		const uint32_t	h,
		const int64_t *	key,
		const uint32_t	key_qw_count,
		const size_t	entry_count
	)

Definition at line 628 of file ResultSetReduction.cpp.

References EMPTY_KEY_64, and mapd_cas.

Referenced by get_group_value_columnar_reduction().

                                                                                      {
   auto off = h;
   const auto old_key = mapd_cas(&groups_buffer[off], EMPTY_KEY_64, *key);
   if (old_key == EMPTY_KEY_64) {
     for (size_t i = 0; i < key_qw_count; ++i) {
       groups_buffer[off] = key[i];
       off += entry_count;
     }
     return {&groups_buffer[off], true};
   }
   off = h;
   for (size_t i = 0; i < key_qw_count; ++i) {
     if (groups_buffer[off] != key[i]) {
       return {nullptr, true};
     }
     off += entry_count;
   }
   return {&groups_buffer[off], false};
 }

Here is the caller graph for this function:

template<typename T = int64_t>

GroupValueInfo anonymous_namespace{ResultSetReduction.cpp}::get_matching_group_value_reduction	(	int64_t *	groups_buffer,
		const uint32_t	h,
		const T *	key,
		const uint32_t	key_count,
		const QueryMemoryDescriptor &	query_mem_desc,
		const int64_t *	that_buff_i64,
		const size_t	that_entry_idx,
		const size_t	that_entry_count,
		const uint32_t	row_size_quad
	)

Definition at line 697 of file ResultSetReduction.cpp.

References cas_cst, fill_slots(), get_slot_off_quad(), QueryMemoryDescriptor::getEntryCount(), load_cst, query_mem_desc, store_cst, and heavydb.dtypes::T.

Referenced by result_set::get_group_value_reduction(), and get_matching_group_value_reduction().

                                   {
   auto off = h * row_size_quad;
   T empty_key = get_empty_key<T>();
   T write_pending = get_empty_key<T>() - 1;
   auto row_ptr = reinterpret_cast<T*>(groups_buffer + off);
   const auto slot_off_quad = get_slot_off_quad(query_mem_desc);
   const bool success = cas_cst(row_ptr, &empty_key, write_pending);
   if (success) {
     fill_slots(groups_buffer + off + slot_off_quad,
                query_mem_desc.getEntryCount(),
                that_buff_i64,
                that_entry_idx,
                that_entry_count,
                query_mem_desc);
     if (key_count > 1) {
       memcpy(row_ptr + 1, key + 1, (key_count - 1) * sizeof(T));
     }
     store_cst(row_ptr, *key);
     return {groups_buffer + off + slot_off_quad, true};
   }
   while (load_cst(row_ptr) == write_pending) {
     // spin until the winning thread has finished writing the entire key and the init
     // value
   }
   for (size_t i = 0; i < key_count; ++i) {
     if (load_cst(row_ptr + i) != key[i]) {
       return {nullptr, true};
     }
   }
   return {groups_buffer + off + slot_off_quad, false};
 }

Here is the call graph for this function:

Here is the caller graph for this function:

GroupValueInfo anonymous_namespace{ResultSetReduction.cpp}::get_matching_group_value_reduction	(	int64_t *	groups_buffer,
		const uint32_t	h,
		const int64_t *	key,
		const uint32_t	key_count,
		const size_t	key_width,
		const QueryMemoryDescriptor &	query_mem_desc,
		const int64_t *	that_buff_i64,
		const size_t	that_entry_idx,
		const size_t	that_entry_count,
		const uint32_t	row_size_quad
	)

inline

Definition at line 742 of file ResultSetReduction.cpp.

References CHECK, and get_matching_group_value_reduction().

                                   {
   switch (key_width) {
     case 4:
       return get_matching_group_value_reduction(groups_buffer,
                                                 h,
                                                 reinterpret_cast<const int32_t*>(key),
                                                 key_count,
                                                 query_mem_desc,
                                                 that_buff_i64,
                                                 that_entry_idx,
                                                 that_entry_count,
                                                 row_size_quad);
     case 8:
       return get_matching_group_value_reduction(groups_buffer,
                                                 h,
                                                 key,
                                                 key_count,
                                                 query_mem_desc,
                                                 that_buff_i64,
                                                 that_entry_idx,
                                                 that_entry_count,
                                                 row_size_quad);
     default:
       CHECK(false);
       return {nullptr, true};
   }
 }

Here is the call graph for this function:

size_t anonymous_namespace{ResultSetReduction.cpp}::get_row_qw_count ( const QueryMemoryDescriptor & query_mem_desc )

Definition at line 47 of file ResultSetReduction.cpp.

References CHECK_EQ, and get_row_bytes().

Referenced by fill_slots(), and ResultSetStorage::moveEntriesToBuffer().

                                                                      {
   const auto row_bytes = get_row_bytes(query_mem_desc);
   CHECK_EQ(size_t(0), row_bytes % 8);
   return row_bytes / 8;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector<int64_t> anonymous_namespace{ResultSetReduction.cpp}::make_key	(	const int64_t *	buff,
		const size_t	entry_count,
		const size_t	key_count
	)

Definition at line 53 of file ResultSetReduction.cpp.

Referenced by ResultSetStorage::moveOneEntryToBuffer(), and ResultSetStorage::reduceOneEntryBaseline().

                                                       {
   std::vector<int64_t> key;
   size_t off = 0;
   for (size_t i = 0; i < key_count; ++i) {
     key.push_back(buff[off]);
     off += entry_count;
   }
   return key;
 }

Here is the caller graph for this function:

void anonymous_namespace{ResultSetReduction.cpp}::run_reduction_code	(	const size_t	executor_id,
		const ReductionCode &	reduction_code,
		int8_t *	this_buff,
		const int8_t *	that_buff,
		const int32_t	start_entry_index,
		const int32_t	end_entry_index,
		const int32_t	that_entry_count,
		const void *	this_qmd,
		const void *	that_qmd,
		const void *	serialized_varlen_buffer
	)

Definition at line 132 of file ResultSetReduction.cpp.

References ReductionCode::func_ptr, ReductionInterpreter::EvalValue::int_val, ReductionCode::ir_reduce_loop, ReductionInterpreter::MakeEvalValue(), and ReductionInterpreter::run().

Referenced by ResultSetStorage::reduce().

                                                               {
   int err = 0;
   if (reduction_code.func_ptr) {
     err = reduction_code.func_ptr(this_buff,
                                   that_buff,
                                   start_entry_index,
                                   end_entry_index,
                                   that_entry_count,
                                   this_qmd,
                                   that_qmd,
                                   serialized_varlen_buffer);
   } else {
     auto ret = ReductionInterpreter::run(
         executor_id,
         reduction_code.ir_reduce_loop.get(),
         {ReductionInterpreter::MakeEvalValue(this_buff),
          ReductionInterpreter::MakeEvalValue(that_buff),
          ReductionInterpreter::MakeEvalValue(start_entry_index),
          ReductionInterpreter::MakeEvalValue(end_entry_index),
          ReductionInterpreter::MakeEvalValue(that_entry_count),
          ReductionInterpreter::MakeEvalValue(this_qmd),
          ReductionInterpreter::MakeEvalValue(that_qmd),
          ReductionInterpreter::MakeEvalValue(serialized_varlen_buffer)});
     err = ret.int_val;
   }
   if (err) {
     if (err == int32_t(heavyai::ErrorCode::SINGLE_VALUE_FOUND_MULTIPLE_VALUES)) {
       throw std::runtime_error("Multiple distinct values encountered");
     } else if (err == int32_t(heavyai::ErrorCode::INTERRUPTED)) {
       throw std::runtime_error(
           "Query execution has interrupted during result set reduction");
     }
     throw std::runtime_error(
         "Query execution has exceeded the time limit or was interrupted during result "
         "set reduction");
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool anonymous_namespace{ResultSetReduction.cpp}::use_multithreaded_reduction ( const size_t entry_count )

Definition at line 43 of file ResultSetReduction.cpp.

Referenced by ResultSetStorage::moveEntriesToBuffer(), and ResultSetStorage::reduce().

                                                            {
   return entry_count > 100000;
 }

Here is the caller graph for this function:

Functions

Function Documentation