TableFunctionManager Struct Reference

#include <heavydbTypes.h>

Collaboration diagram for TableFunctionManager:

Public Member Functions
void	set_output_row_size (int64_t num_rows)
int32_t	error_message (const char *message)
	TableFunctionManager (const TableFunctionExecutionUnit &exe_unit, Executor *executor, std::vector< const int8_t * > &col_buf_ptrs, std::shared_ptr< RowSetMemoryOwner > row_set_mem_owner, bool is_singleton)
size_t	get_ncols () const
size_t	get_nrows () const
void	check_thread_id () const
void	set_output_column (int32_t index, int8_t *ptr)
void	allocate_output_buffers (int64_t output_num_rows)
const char *	get_error_message () const
void	set_error_message (const char *msg)
bool	isSingleton () const
	~TableFunctionManager ()

Static Public Member Functions
static TableFunctionManager *	get_singleton ()
static TableFunctionManager *&	get_singleton ()

Public Attributes
std::unique_ptr < QueryMemoryInitializer >	query_buffers

Private Member Functions
void	lock ()
void	unlock ()

Static Private Member Functions
static void	set_singleton (TableFunctionManager *instance)

Private Attributes
const TableFunctionExecutionUnit &	exe_unit_
Executor *	executor_
std::vector< const int8_t * > &	col_buf_ptrs_
std::shared_ptr < RowSetMemoryOwner >	row_set_mem_owner_
std::vector< int64_t * >	output_col_buf_ptrs
size_t	output_num_rows_
std::vector< int8_t * >	output_column_ptrs
bool	is_singleton_
std::thread::id	thread_id_
std::string	error_message_

Detailed Description

Definition at line 650 of file heavydbTypes.h.

Constructor & Destructor Documentation

TableFunctionManager::TableFunctionManager ( const TableFunctionExecutionUnit &  exe_unit, Executor *  executor, std::vector< const int8_t * > &  col_buf_ptrs, std::shared_ptr< RowSetMemoryOwner >  row_set_mem_owner, bool  is_singleton  )

inline

Definition at line 57 of file TableFunctionManager.h.

References get_ncols(), isSingleton(), output_col_buf_ptrs, output_column_ptrs, and set_singleton().

      : exe_unit_(exe_unit)
      , executor_(executor)
      , col_buf_ptrs_(col_buf_ptrs)
      , row_set_mem_owner_(row_set_mem_owner)
      , output_num_rows_(-1)
      , is_singleton_(is_singleton)
      , thread_id_(std::this_thread::get_id()) {
    if (isSingleton()) {
      set_singleton(this);  // start of singleton life
    }
    auto num_out_columns = get_ncols();
    output_col_buf_ptrs.reserve(num_out_columns);
    output_column_ptrs.reserve(num_out_columns);
    for (size_t i = 0; i < num_out_columns; i++) {
      output_col_buf_ptrs.emplace_back(nullptr);
      output_column_ptrs.emplace_back(nullptr);
    }
  }

Here is the call graph for this function:

TableFunctionManager::~TableFunctionManager ( )

inline

Definition at line 176 of file TableFunctionManager.h.

References isSingleton(), and set_singleton().

                          {
    if (isSingleton()) {
      set_singleton(nullptr);  // end of singleton life
    }
  }

Here is the call graph for this function:

Member Function Documentation

void TableFunctionManager::allocate_output_buffers ( int64_t  output_num_rows )

inline

Definition at line 102 of file TableFunctionManager.h.

References QueryMemoryDescriptor::addColSlotInfo(), align_to_int64(), CHECK, CHECK_EQ, check_thread_id(), col_buf_ptrs_, CPU, exe_unit_, executor_, get_ncols(), output_col_buf_ptrs, output_column_ptrs, output_num_rows_, query_buffers, query_mem_desc, row_set_mem_owner_, QueryMemoryDescriptor::setOutputColumnar(), Column< T >::size(), TableFunction, TableFunctionExecutionUnit::target_exprs, and toString().

                                                        {
    check_thread_id();
    CHECK_EQ(output_num_rows_,
             size_t(-1));  // re-allocation of output buffers is not supported
    output_num_rows_ = output_num_rows;
    auto num_out_columns = get_ncols();
    QueryMemoryDescriptor query_mem_desc(executor_,
                                         output_num_rows,  // divide by row multiplier???
                                         QueryDescriptionType::TableFunction,
                                         /*is_table_function=*/true);
    query_mem_desc.setOutputColumnar(true);

    for (size_t i = 0; i < num_out_columns; i++) {
      // All outputs have padded width set to logical column width
      const size_t col_width = exe_unit_.target_exprs[i]->get_type_info().get_size();
      query_mem_desc.addColSlotInfo({std::make_tuple(col_width, col_width)});
    }

    // The members layout of Column must match with Column defined in
    // heavydbTypes.h
    struct Column {
      int8_t* ptr;
      int64_t size;
      // just for debugging:
      std::string toString() const {
        return "Column{" + ::toString(ptr) + ", " + ::toString(size) + "}";
      }
    };
    // We do not init output buffers for CPU currently, so CPU
    // table functions are expected to handle their own initialization
    query_buffers = std::make_unique<QueryMemoryInitializer>(
        exe_unit_,
        query_mem_desc,
        /*device_id=*/0,
        ExecutorDeviceType::CPU,
        (output_num_rows_ == 0 ? 1 : output_num_rows_),
        std::vector<std::vector<const int8_t*>>{col_buf_ptrs_},
        std::vector<std::vector<uint64_t>>{{0}},  // frag offsets
        row_set_mem_owner_,
        nullptr,
        executor_);
    if (output_num_rows_ != 0) {
      auto group_by_buffers_ptr = query_buffers->getGroupByBuffersPtr();
      CHECK(group_by_buffers_ptr);
      auto output_buffers_ptr = reinterpret_cast<int8_t*>(group_by_buffers_ptr[0]);
      for (size_t i = 0; i < num_out_columns; i++) {
        Column* col = reinterpret_cast<Column*>(output_column_ptrs[i]);
        CHECK(col);
        // set the members of output Column instances:
        output_col_buf_ptrs[i] = reinterpret_cast<int64_t*>(output_buffers_ptr);
        col->ptr = output_buffers_ptr;
        col->size = output_num_rows_;

        const size_t col_width = exe_unit_.target_exprs[i]->get_type_info().get_size();
        output_buffers_ptr =
            align_to_int64(output_buffers_ptr + col_width * output_num_rows_);
      }
    }
  }

Here is the call graph for this function:

void TableFunctionManager::check_thread_id ( ) const

inline

Definition at line 87 of file TableFunctionManager.h.

References thread_id_.

Referenced by allocate_output_buffers(), get_error_message(), set_error_message(), and set_output_column().

                               {
    if (std::this_thread::get_id() != thread_id_) {
      throw std::runtime_error(
          "TableFunctionManager instance accessed from an alien thread!");
    }
  }

Here is the caller graph for this function:

int32_t TableFunctionManager::error_message ( const char *  message )

inline

Definition at line 659 of file heavydbTypes.h.

References TableFunctionManager_error_message().

                                             {
    return TableFunctionManager_error_message(reinterpret_cast<int8_t*>(this), message);
  }

Here is the call graph for this function:

const char* TableFunctionManager::get_error_message ( ) const

inline

Definition at line 162 of file TableFunctionManager.h.

References check_thread_id(), and error_message_.

                                        {
    check_thread_id();
    return error_message_.c_str();
  }

Here is the call graph for this function:

size_t TableFunctionManager::get_ncols ( ) const

inline

Definition at line 82 of file TableFunctionManager.h.

References exe_unit_, and TableFunctionExecutionUnit::target_exprs.

Referenced by allocate_output_buffers(), set_output_column(), and TableFunctionManager().

{ return exe_unit_.target_exprs.size(); }

Here is the caller graph for this function:

size_t TableFunctionManager::get_nrows ( ) const

inline

Definition at line 85 of file TableFunctionManager.h.

References output_num_rows_.

{ return output_num_rows_; }

static TableFunctionManager*& TableFunctionManager::get_singleton ( )

inlinestatic

Definition at line 182 of file TableFunctionManager.h.

                                                {
    static TableFunctionManager* instance = nullptr;
    return instance;
  }

static TableFunctionManager* TableFunctionManager::get_singleton ( )

inlinestatic

Definition at line 651 of file heavydbTypes.h.

References TableFunctionManager_get_singleton().

Referenced by ct_sleep1__cpu_(), ct_sleep2(), and set_singleton().

                                               {
    return reinterpret_cast<TableFunctionManager*>(TableFunctionManager_get_singleton());
  }

Here is the call graph for this function:

Here is the caller graph for this function:

bool TableFunctionManager::isSingleton ( ) const

inline

Definition at line 174 of file TableFunctionManager.h.

References is_singleton_.

Referenced by TableFunctionManager(), and ~TableFunctionManager().

{ return is_singleton_; }

Here is the caller graph for this function:

void TableFunctionManager::lock ( )

inlineprivate

Definition at line 188 of file TableFunctionManager.h.

References TableFunctionManager_singleton_mutex.

Referenced by set_singleton().

{ TableFunctionManager_singleton_mutex.lock(); }

Here is the caller graph for this function:

void TableFunctionManager::set_error_message ( const char *  msg )

inline

Definition at line 167 of file TableFunctionManager.h.

References check_thread_id(), and error_message_.

                                          {
    check_thread_id();
    error_message_ = std::string(msg);
  }

Here is the call graph for this function:

void TableFunctionManager::set_output_column ( int32_t  index, int8_t *  ptr  )

inline

Definition at line 95 of file TableFunctionManager.h.

References CHECK, check_thread_id(), get_ncols(), and output_column_ptrs.

                                                     {
    check_thread_id();
    CHECK(index >= 0 && index < static_cast<int32_t>(get_ncols()));
    CHECK(ptr);
    output_column_ptrs[index] = ptr;
  }

Here is the call graph for this function:

void TableFunctionManager::set_output_row_size ( int64_t  num_rows )

inline

Definition at line 655 of file heavydbTypes.h.

References TableFunctionManager_set_output_row_size().

Referenced by ct_add_size_and_mul_alpha(), ct_copy_and_add_size(), ct_cursor_named_args__cpu_(), ct_pushdown_projection__cpu_template(), ct_pushdown_stats__cpu_template(), ct_scalar_named_args__cpu_(), ct_sleep2(), ct_sparse_add(), ct_string_concat__cpu_(), ct_substr__cpu_(), ct_synthesize_new_dict__cpu_(), ct_test_preflight_multicursor_qe227__cpu_(), ct_test_preflight_singlecursor_qe227__cpu_(), ct_throw_if_gt_100__cpu_template(), ct_timestamp_add_offset(), ct_timestamp_column_list_input(), ct_timestamp_extract(), ct_timestamp_truncate(), ct_union_pushdown_projection__cpu_template(), ct_union_pushdown_stats__cpu_template(), generate_random_strings__cpu_(), generate_series__cpu_1(), Mandelbrot::mandelbrot_cpu_template(), and GeoRaster< T, Z >::outputDenseColumns().

                                             {
    TableFunctionManager_set_output_row_size(reinterpret_cast<int8_t*>(this), num_rows);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

static void TableFunctionManager::set_singleton ( TableFunctionManager *  instance )

inlinestaticprivate

Definition at line 191 of file TableFunctionManager.h.

References CHECK, get_singleton(), and lock().

Referenced by TableFunctionManager(), and ~TableFunctionManager().

                                                            {
    auto& instance_ = get_singleton();
    // ensure being singleton and lock/unlock
    if (instance) {
      instance->lock();
      CHECK(instance_ == nullptr);
    } else {
      CHECK(instance_ != nullptr);
      instance_->unlock();
    }
    instance_ = instance;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

void TableFunctionManager::unlock ( )

inlineprivate

Definition at line 189 of file TableFunctionManager.h.

References TableFunctionManager_singleton_mutex.

{ TableFunctionManager_singleton_mutex.unlock(); }

Member Data Documentation

std::vector<const int8_t*>& TableFunctionManager::col_buf_ptrs_

private

Definition at line 207 of file TableFunctionManager.h.

Referenced by allocate_output_buffers().

std::string TableFunctionManager::error_message_

private

Definition at line 221 of file TableFunctionManager.h.

Referenced by get_error_message(), and set_error_message().

const TableFunctionExecutionUnit& TableFunctionManager::exe_unit_

private

Definition at line 204 of file TableFunctionManager.h.

Referenced by allocate_output_buffers(), and get_ncols().

Executor* TableFunctionManager::executor_

private

Definition at line 205 of file TableFunctionManager.h.

Referenced by allocate_output_buffers().

bool TableFunctionManager::is_singleton_

private

Definition at line 217 of file TableFunctionManager.h.

Referenced by isSingleton().

std::vector<int64_t*> TableFunctionManager::output_col_buf_ptrs

private

Definition at line 211 of file TableFunctionManager.h.

Referenced by allocate_output_buffers(), and TableFunctionManager().

std::vector<int8_t*> TableFunctionManager::output_column_ptrs

private

Definition at line 215 of file TableFunctionManager.h.

Referenced by allocate_output_buffers(), set_output_column(), and TableFunctionManager().

size_t TableFunctionManager::output_num_rows_

private

Definition at line 213 of file TableFunctionManager.h.

Referenced by allocate_output_buffers(), and get_nrows().

std::unique_ptr<QueryMemoryInitializer> TableFunctionManager::query_buffers

Definition at line 55 of file TableFunctionManager.h.

Referenced by allocate_output_buffers().

std::shared_ptr<RowSetMemoryOwner> TableFunctionManager::row_set_mem_owner_

private

Definition at line 209 of file TableFunctionManager.h.

Referenced by allocate_output_buffers().

std::thread::id TableFunctionManager::thread_id_

private

Definition at line 219 of file TableFunctionManager.h.

Referenced by check_thread_id().

---

The documentation for this struct was generated from the following files:

• /home/jenkins-slave/workspace/core-os-doxygen/QueryEngine/heavydbTypes.h
• /home/jenkins-slave/workspace/core-os-doxygen/QueryEngine/TableFunctions/TableFunctionManager.h