#include <StorageIOFacility.h>

Inheritance diagram for StorageIOFacility:

Collaboration diagram for StorageIOFacility:

Classes
struct	DeleteTransactionParameters

class	TransactionParameters

class	UpdateTransactionParameters

Public Types
using	UpdateCallback = UpdateLogForFragment::Callback

using	TableDescriptorType = TableDescriptor

using	DeleteVictimOffsetList = std::vector< uint64_t >

using	UpdateTargetOffsetList = std::vector< uint64_t >

using	UpdateTargetTypeList = std::vector< TargetMetaInfo >

using	UpdateTargetColumnNamesList = std::vector< std::string >

using	TransactionLog = Fragmenter_Namespace::InsertOrderFragmenter::ModifyTransactionTracker

using	TransactionLogPtr = std::unique_ptr< TransactionLog >

using	ColumnValidationFunction = std::function< bool(std::string const &)>

Public Member Functions
	StorageIOFacility (Executor *executor)

StorageIOFacility::UpdateCallback	yieldUpdateCallback (UpdateTransactionParameters &update_parameters)

StorageIOFacility::UpdateCallback	yieldDeleteCallback (DeleteTransactionParameters &delete_parameters)

Private Member Functions
int	normalized_cpu_threads () const

Static Private Member Functions
static std::unique_ptr< int8_t[]>	getRsBufferNoPadding (const ResultSet *rs, size_t col_idx, const SQLTypeInfo &column_type, size_t row_count)

Private Attributes
Executor *	executor_

Detailed Description

Definition at line 106 of file StorageIOFacility.h.

Member Typedef Documentation

using StorageIOFacility::ColumnValidationFunction = std::function<bool(std::string const&)>

Definition at line 119 of file StorageIOFacility.h.

using StorageIOFacility::DeleteVictimOffsetList = std::vector<uint64_t>

Definition at line 111 of file StorageIOFacility.h.

using StorageIOFacility::TableDescriptorType = TableDescriptor

Definition at line 110 of file StorageIOFacility.h.

using StorageIOFacility::TransactionLog = Fragmenter_Namespace::InsertOrderFragmenter::ModifyTransactionTracker

Definition at line 117 of file StorageIOFacility.h.

using StorageIOFacility::TransactionLogPtr = std::unique_ptr<TransactionLog>

Definition at line 118 of file StorageIOFacility.h.

using StorageIOFacility::UpdateCallback = UpdateLogForFragment::Callback

Definition at line 108 of file StorageIOFacility.h.

using StorageIOFacility::UpdateTargetColumnNamesList = std::vector<std::string>

Definition at line 114 of file StorageIOFacility.h.

using StorageIOFacility::UpdateTargetOffsetList = std::vector<uint64_t>

Definition at line 112 of file StorageIOFacility.h.

using StorageIOFacility::UpdateTargetTypeList = std::vector<TargetMetaInfo>

Definition at line 113 of file StorageIOFacility.h.

Constructor & Destructor Documentation

StorageIOFacility::StorageIOFacility ( Executor * executor )

inline

Definition at line 204 of file StorageIOFacility.h.

204 : executor_(executor) {}

StorageIOFacility::executor_

Executor * executor_

Definition: StorageIOFacility.h:692

Member Function Documentation

static std::unique_ptr<int8_t[]> StorageIOFacility::getRsBufferNoPadding	(	const ResultSet *	rs,
		size_t	col_idx,
		const SQLTypeInfo &	column_type,
		size_t	row_count
	)

inlinestaticprivate

Definition at line 651 of file StorageIOFacility.h.

References CHECK, SQLTypeInfo::get_logical_size(), SQLTypeInfo::get_size(), SQLTypeInfo::get_type(), SQLTypeInfo::is_dict_encoded_string(), SQLTypeInfo::is_fp(), and kFLOAT.

Referenced by yieldDeleteCallback(), and yieldUpdateCallback().

                                                                           {
     const auto padded_size = rs->getPaddedSlotWidthBytes(col_idx);
     const auto type_size = column_type.is_dict_encoded_string()
                                ? column_type.get_size()
                                : column_type.get_logical_size();
 
     auto rs_buffer_size = padded_size * row_count;
     auto rs_buffer = std::make_unique<int8_t[]>(rs_buffer_size);
     rs->copyColumnIntoBuffer(col_idx, rs_buffer.get(), rs_buffer_size);
 
     if (type_size < padded_size) {
       // else we're going to remove padding and we do it inplace in the same buffer
       // we can do updates inplace in the same buffer because type_size < padded_size
       // for some types, like kFLOAT, simple memcpy is not enough
       auto src_ptr = rs_buffer.get();
       auto dst_ptr = rs_buffer.get();
       if (column_type.is_fp()) {
         CHECK(column_type.get_type() == kFLOAT);
         CHECK(padded_size == sizeof(double));
         for (size_t i = 0; i < row_count; i++) {
           const auto old_val = *reinterpret_cast<double*>(may_alias_ptr(src_ptr));
           auto new_val = static_cast<float>(old_val);
           std::memcpy(dst_ptr, &new_val, type_size);
           dst_ptr += type_size;
           src_ptr += padded_size;
         }
       } else {
         // otherwise just take first type_size bytes from the padded value
         for (size_t i = 0; i < row_count; i++) {
           std::memcpy(dst_ptr, src_ptr, type_size);
           dst_ptr += type_size;
           src_ptr += padded_size;
         }
       }
     }
     return rs_buffer;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

int StorageIOFacility::normalized_cpu_threads ( ) const

inlineprivate

Definition at line 649 of file StorageIOFacility.h.

References cpu_threads().

Referenced by yieldDeleteCallback(), and yieldUpdateCallback().

649 { return cpu_threads() / 2; }

cpu_threads

int cpu_threads()

Definition: thread_count.h:25

Here is the call graph for this function:

Here is the caller graph for this function:

StorageIOFacility::UpdateCallback StorageIOFacility::yieldDeleteCallback ( DeleteTransactionParameters & delete_parameters )

inline

Definition at line 468 of file StorageIOFacility.h.

References threading_serial::async(), CHECK, CHECK_EQ, Data_Namespace::CPU_LEVEL, StorageIOFacility::TransactionParameters::getCatalog(), Chunk_NS::Chunk::getChunk(), UpdateLogForFragment::getColumnType(), UpdateLogForFragment::getEntryAt(), UpdateLogForFragment::getEntryCount(), UpdateLogForFragment::getFragmentId(), Catalog_Namespace::Catalog::getMetadataForTable(), UpdateLogForFragment::getPhysicalTableId(), UpdateLogForFragment::getRowCount(), getRsBufferNoPadding(), StorageIOFacility::TransactionParameters::getTableDescriptor(), StorageIOFacility::TransactionParameters::getTransactionTracker(), lockmgr::TableLockMgrImpl< TableDataLockMgr >::getWriteLockForTable(), Data_Namespace::GPU_LEVEL, kBOOLEAN, normalized_cpu_threads(), table_is_temporary(), StorageIOFacility::TransactionParameters::tableIsTemporary(), and UNLIKELY.

Referenced by RelAlgExecutor::executeDelete().

                                                       {
     using RowProcessingFuturesVector = std::vector<std::future<uint64_t>>;
 
     if (delete_parameters.tableIsTemporary()) {
       auto logical_table_id = delete_parameters.getTableDescriptor()->tableId;
       const auto& catalog = delete_parameters.getCatalog();
       auto callback = [logical_table_id, &catalog](UpdateLogForFragment const& update_log,
                                                    TableUpdateMetadata&) -> void {
         auto rs = update_log.getResultSet();
         CHECK(rs->didOutputColumnar());
         CHECK(rs->isDirectColumnarConversionPossible());
         CHECK_EQ(rs->colCount(), size_t(1));
 
         // Temporary table updates require the full projected column
         CHECK_EQ(rs->rowCount(), update_log.getRowCount());
 
         const ChunkKey lock_chunk_key{catalog.getCurrentDB().dbId, logical_table_id};
         const auto table_lock =
             lockmgr::TableDataLockMgr::getWriteLockForTable(lock_chunk_key);
 
         auto& fragment_info = update_log.getFragmentInfo();
         const auto td = catalog.getMetadataForTable(update_log.getPhysicalTableId());
         CHECK(td);
         const auto cd = catalog.getDeletedColumn(td);
         CHECK(cd);
         CHECK(cd->columnType.get_type() == kBOOLEAN);
         auto chunk_metadata =
             fragment_info.getChunkMetadataMapPhysical().find(cd->columnId);
         CHECK(chunk_metadata != fragment_info.getChunkMetadataMapPhysical().end());
         ChunkKey chunk_key{catalog.getCurrentDB().dbId,
                            td->tableId,
                            cd->columnId,
                            fragment_info.fragmentId};
         auto chunk = Chunk_NS::Chunk::getChunk(cd,
                                                &catalog.getDataMgr(),
                                                chunk_key,
                                                Data_Namespace::MemoryLevel::CPU_LEVEL,
                                                0,
                                                chunk_metadata->second->numBytes,
                                                chunk_metadata->second->numElements);
         CHECK(chunk);
         auto chunk_buffer = chunk->getBuffer();
         CHECK(chunk_buffer);
 
         auto encoder = chunk_buffer->getEncoder();
         CHECK(encoder);
 
         auto owned_buffer = StorageIOFacility::getRsBufferNoPadding(
             rs.get(), 0, cd->columnType, rs->rowCount());
         auto buffer = reinterpret_cast<int8_t*>(owned_buffer.get());
 
         const auto new_chunk_metadata =
             encoder->appendData(buffer, rs->rowCount(), cd->columnType, false, 0);
 
         auto fragmenter = td->fragmenter.get();
         CHECK(fragmenter);
 
         // The fragmenter copy of the fragment info differs from the copy used by the
         // query engine. Update metadata in the fragmenter directly.
         auto fragment = fragmenter->getFragmentInfo(fragment_info.fragmentId);
         // TODO: we may want to put this directly in the fragmenter so we are under the
         // fragmenter lock. But, concurrent queries on the same fragmenter should not be
         // allowed in this path.
 
         fragment->setChunkMetadata(cd->columnId, new_chunk_metadata);
         fragment->shadowChunkMetadataMap =
             fragment->getChunkMetadataMapPhysicalCopy();  // TODO(adb): needed?
 
         auto& data_mgr = catalog.getDataMgr();
         if (data_mgr.gpusPresent()) {
           // flush any GPU copies of the updated chunk
           data_mgr.deleteChunksWithPrefix(chunk_key,
                                           Data_Namespace::MemoryLevel::GPU_LEVEL);
         }
       };
       return callback;
     } else {
       auto callback = [this, &delete_parameters](
                           UpdateLogForFragment const& update_log,
                           TableUpdateMetadata& table_update_metadata) -> void {
         auto entries_per_column = update_log.getEntryCount();
         auto rows_per_column = update_log.getRowCount();
         if (rows_per_column == 0) {
           return;
         }
         DeleteVictimOffsetList victim_offsets(rows_per_column);
 
         auto complete_row_block_size = entries_per_column / normalized_cpu_threads();
         auto partial_row_block_size = entries_per_column % normalized_cpu_threads();
         auto usable_threads = normalized_cpu_threads();
 
         if (UNLIKELY(rows_per_column < (unsigned)normalized_cpu_threads())) {
           complete_row_block_size = rows_per_column;
           partial_row_block_size = 0;
           usable_threads = 1;
         }
 
         std::atomic<size_t> row_idx{0};
 
         auto process_rows = [&update_log, &victim_offsets, &row_idx](
                                 uint64_t entry_start, uint64_t entry_count) -> uint64_t {
           uint64_t entries_processed = 0;
 
           for (uint64_t entry_index = entry_start;
                entry_index < (entry_start + entry_count);
                entry_index++) {
             auto const row(update_log.getEntryAt(entry_index));
 
             if (row.empty()) {
               continue;
             }
 
             entries_processed++;
             size_t row_index = row_idx.fetch_add(1);
 
             auto terminal_column_iter = std::prev(row.end());
             const auto scalar_tv = boost::get<ScalarTargetValue>(&*terminal_column_iter);
             CHECK(scalar_tv);
 
             uint64_t fragment_offset =
                 static_cast<uint64_t>(*(boost::get<int64_t>(scalar_tv)));
             victim_offsets[row_index] = fragment_offset;
           }
           return entries_processed;
         };
 
         auto get_row_index =
             [complete_row_block_size](uint64_t thread_index) -> uint64_t {
           return thread_index * complete_row_block_size;
         };
 
         RowProcessingFuturesVector row_processing_futures;
         row_processing_futures.reserve(usable_threads);
 
         for (unsigned i = 0; i < (unsigned)usable_threads; i++) {
           row_processing_futures.emplace_back(
               std::async(std::launch::async,
                          std::forward<decltype(process_rows)>(process_rows),
                          get_row_index(i),
                          complete_row_block_size));
         }
         if (partial_row_block_size) {
           row_processing_futures.emplace_back(
               std::async(std::launch::async,
                          std::forward<decltype(process_rows)>(process_rows),
                          get_row_index(usable_threads),
                          partial_row_block_size));
         }
 
         for (auto& t : row_processing_futures) {
           t.wait();
         }
 
         const auto& catalog = delete_parameters.getCatalog();
         auto const* table_descriptor =
             catalog.getMetadataForTable(update_log.getPhysicalTableId());
         CHECK(table_descriptor);
         CHECK(!table_is_temporary(table_descriptor));
         auto* fragmenter = table_descriptor->fragmenter.get();
         CHECK(fragmenter);
 
         auto const* deleted_column_desc = catalog.getDeletedColumn(table_descriptor);
         CHECK(deleted_column_desc);
         fragmenter->updateColumn(&catalog,
                                  table_descriptor,
                                  deleted_column_desc,
                                  update_log.getFragmentId(),
                                  victim_offsets,
                                  ScalarTargetValue(int64_t(1L)),
                                  update_log.getColumnType(0),
                                  Data_Namespace::MemoryLevel::CPU_LEVEL,
                                  delete_parameters.getTransactionTracker());
         table_update_metadata.fragments_with_deleted_rows[table_descriptor->tableId]
             .emplace(update_log.getFragmentId());
       };
       return callback;
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

StorageIOFacility::UpdateCallback StorageIOFacility::yieldUpdateCallback ( UpdateTransactionParameters & update_parameters )

inline

Definition at line 206 of file StorageIOFacility.h.

Referenced by RelAlgExecutor::executeUpdate().

                                                       {
     using OffsetVector = std::vector<uint64_t>;
     using ScalarTargetValueVector = std::vector<ScalarTargetValue>;
     using RowProcessingFuturesVector = std::vector<std::future<uint64_t>>;
 
     if (update_parameters.isVarlenUpdateRequired()) {
       auto callback = [this, &update_parameters](
                           UpdateLogForFragment const& update_log,
                           TableUpdateMetadata& table_update_metadata) -> void {
         std::vector<const ColumnDescriptor*> columnDescriptors;
         std::vector<TargetMetaInfo> sourceMetaInfos;
 
         const auto& catalog = update_parameters.getCatalog();
         for (size_t idx = 0; idx < update_parameters.getUpdateColumnNames().size();
              idx++) {
           auto& column_name = update_parameters.getUpdateColumnNames()[idx];
           auto target_column =
               catalog.getMetadataForColumn(update_log.getPhysicalTableId(), column_name);
           columnDescriptors.push_back(target_column);
           sourceMetaInfos.push_back(update_parameters.getTargetsMetaInfo()[idx]);
         }
 
         auto td = catalog.getMetadataForTable(update_log.getPhysicalTableId());
         auto* fragmenter = td->fragmenter.get();
         CHECK(fragmenter);
 
         fragmenter->updateColumns(
             &catalog,
             td,
             update_log.getFragmentId(),
             sourceMetaInfos,
             columnDescriptors,
             update_log,
             update_parameters.getUpdateColumnCount(),  // last column of result set
             Data_Namespace::MemoryLevel::CPU_LEVEL,
             update_parameters.getTransactionTracker(),
             executor_);
         table_update_metadata.fragments_with_deleted_rows[td->tableId].emplace(
             update_log.getFragmentId());
       };
       return callback;
     } else if (update_parameters.tableIsTemporary()) {
       auto callback = [&update_parameters](UpdateLogForFragment const& update_log,
                                            TableUpdateMetadata&) -> void {
         auto rs = update_log.getResultSet();
         CHECK(rs->didOutputColumnar());
         CHECK(rs->isDirectColumnarConversionPossible());
         CHECK_EQ(update_parameters.getUpdateColumnCount(), size_t(1));
         CHECK_EQ(rs->colCount(), size_t(1));
 
         // Temporary table updates require the full projected column
         CHECK_EQ(rs->rowCount(), update_log.getRowCount());
 
         const auto& catalog = update_parameters.getCatalog();
         ChunkKey chunk_key_prefix{catalog.getCurrentDB().dbId,
                                   update_parameters.getTableDescriptor()->tableId};
         const auto table_lock =
             lockmgr::TableDataLockMgr::getWriteLockForTable(chunk_key_prefix);
 
         auto& fragment_info = update_log.getFragmentInfo();
         const auto td = catalog.getMetadataForTable(update_log.getPhysicalTableId());
         CHECK(td);
         const auto cd = catalog.getMetadataForColumn(
             td->tableId, update_parameters.getUpdateColumnNames().front());
         CHECK(cd);
         auto chunk_metadata =
             fragment_info.getChunkMetadataMapPhysical().find(cd->columnId);
         CHECK(chunk_metadata != fragment_info.getChunkMetadataMapPhysical().end());
         ChunkKey chunk_key{catalog.getCurrentDB().dbId,
                            td->tableId,
                            cd->columnId,
                            fragment_info.fragmentId};
         auto chunk = Chunk_NS::Chunk::getChunk(cd,
                                                &catalog.getDataMgr(),
                                                chunk_key,
                                                Data_Namespace::MemoryLevel::CPU_LEVEL,
                                                0,
                                                chunk_metadata->second->numBytes,
                                                chunk_metadata->second->numElements);
         CHECK(chunk);
         auto chunk_buffer = chunk->getBuffer();
         CHECK(chunk_buffer);
 
         auto encoder = chunk_buffer->getEncoder();
         CHECK(encoder);
 
         auto owned_buffer = StorageIOFacility::getRsBufferNoPadding(
             rs.get(), 0, cd->columnType, rs->rowCount());
         auto buffer = reinterpret_cast<int8_t*>(owned_buffer.get());
 
         const auto new_chunk_metadata =
             encoder->appendData(buffer, rs->rowCount(), cd->columnType, false, 0);
         CHECK(new_chunk_metadata);
 
         auto fragmenter = td->fragmenter.get();
         CHECK(fragmenter);
 
         // The fragmenter copy of the fragment info differs from the copy used by the
         // query engine. Update metadata in the fragmenter directly.
         auto fragment = fragmenter->getFragmentInfo(fragment_info.fragmentId);
         // TODO: we may want to put this directly in the fragmenter so we are under the
         // fragmenter lock. But, concurrent queries on the same fragmenter should not be
         // allowed in this path.
 
         fragment->setChunkMetadata(cd->columnId, new_chunk_metadata);
         fragment->shadowChunkMetadataMap =
             fragment->getChunkMetadataMapPhysicalCopy();  // TODO(adb): needed?
 
         auto& data_mgr = catalog.getDataMgr();
         if (data_mgr.gpusPresent()) {
           // flush any GPU copies of the updated chunk
           data_mgr.deleteChunksWithPrefix(chunk_key,
                                           Data_Namespace::MemoryLevel::GPU_LEVEL);
         }
       };
       return callback;
     } else {
       auto callback = [this, &update_parameters](
                           UpdateLogForFragment const& update_log,
                           TableUpdateMetadata& table_update_metadata) -> void {
         auto entries_per_column = update_log.getEntryCount();
         auto rows_per_column = update_log.getRowCount();
         if (rows_per_column == 0) {
           return;
         }
 
         OffsetVector column_offsets(rows_per_column);
         ScalarTargetValueVector scalar_target_values(rows_per_column);
 
         auto complete_entry_block_size = entries_per_column / normalized_cpu_threads();
         auto partial_row_block_size = entries_per_column % normalized_cpu_threads();
         auto usable_threads = normalized_cpu_threads();
         if (UNLIKELY(rows_per_column < (unsigned)normalized_cpu_threads())) {
           complete_entry_block_size = entries_per_column;
           partial_row_block_size = 0;
           usable_threads = 1;
         }
 
         std::atomic<size_t> row_idx{0};
 
         auto process_rows =
             [&update_parameters, &column_offsets, &scalar_target_values, &row_idx](
                 auto get_entry_at_func,
                 uint64_t column_index,
                 uint64_t entry_start,
                 uint64_t entry_count) -> uint64_t {
           uint64_t entries_processed = 0;
           for (uint64_t entry_index = entry_start;
                entry_index < (entry_start + entry_count);
                entry_index++) {
             const auto& row = get_entry_at_func(entry_index);
             if (row.empty()) {
               continue;
             }
 
             entries_processed++;
             size_t row_index = row_idx.fetch_add(1);
 
             CHECK(row.size() == update_parameters.getUpdateColumnCount() + 1);
 
             auto terminal_column_iter = std::prev(row.end());
             const auto frag_offset_scalar_tv =
                 boost::get<ScalarTargetValue>(&*terminal_column_iter);
             CHECK(frag_offset_scalar_tv);
 
             column_offsets[row_index] =
                 static_cast<uint64_t>(*(boost::get<int64_t>(frag_offset_scalar_tv)));
             scalar_target_values[row_index] =
                 boost::get<ScalarTargetValue>(row[column_index]);
           }
           return entries_processed;
         };
 
         auto get_row_index =
             [complete_entry_block_size](uint64_t thread_index) -> uint64_t {
           return (thread_index * complete_entry_block_size);
         };
 
         const auto& catalog = update_parameters.getCatalog();
         auto const* table_descriptor =
             catalog.getMetadataForTable(update_log.getPhysicalTableId());
         auto fragment_id = update_log.getFragmentId();
         auto table_id = update_log.getPhysicalTableId();
         if (!table_descriptor) {
           const auto* input_source_node = update_parameters.getInputSourceNode();
           if (auto proj_node = dynamic_cast<const RelProject*>(input_source_node)) {
             if (proj_node->hasPushedDownWindowExpr() ||
                 proj_node->hasWindowFunctionExpr()) {
               table_id = proj_node->getModifiedTableDescriptor()->tableId;
               table_descriptor = catalog.getMetadataForTable(table_id);
             }
           }
         }
         CHECK(table_descriptor);
 
         // Iterate over each column
         for (decltype(update_parameters.getUpdateColumnCount()) column_index = 0;
              column_index < update_parameters.getUpdateColumnCount();
              column_index++) {
           row_idx = 0;
           RowProcessingFuturesVector entry_processing_futures;
           entry_processing_futures.reserve(usable_threads);
 
           auto get_entry_at_func = [&update_log,
                                     &column_index](const size_t entry_index) {
             if (UNLIKELY(update_log.getColumnType(column_index).is_string())) {
               return update_log.getTranslatedEntryAt(entry_index);
             } else {
               return update_log.getEntryAt(entry_index);
             }
           };
 
           for (unsigned i = 0; i < static_cast<unsigned>(usable_threads); i++) {
             entry_processing_futures.emplace_back(
                 std::async(std::launch::async,
                            std::forward<decltype(process_rows)>(process_rows),
                            get_entry_at_func,
                            column_index,
                            get_row_index(i),
                            complete_entry_block_size));
           }
           if (partial_row_block_size) {
             entry_processing_futures.emplace_back(
                 std::async(std::launch::async,
                            std::forward<decltype(process_rows)>(process_rows),
                            get_entry_at_func,
                            column_index,
                            get_row_index(usable_threads),
                            partial_row_block_size));
           }
 
           for (auto& t : entry_processing_futures) {
             t.wait();
           }
 
           CHECK(row_idx == rows_per_column);
           const auto fragmenter = table_descriptor->fragmenter;
           CHECK(fragmenter);
           auto const* target_column = catalog.getMetadataForColumn(
               table_id, update_parameters.getUpdateColumnNames()[column_index]);
           CHECK(target_column);
           auto update_stats =
               fragmenter->updateColumn(&catalog,
                                        table_descriptor,
                                        target_column,
                                        fragment_id,
                                        column_offsets,
                                        scalar_target_values,
                                        update_log.getColumnType(column_index),
                                        Data_Namespace::MemoryLevel::CPU_LEVEL,
                                        update_parameters.getTransactionTracker());
           if (should_recompute_metadata(update_stats)) {
             table_update_metadata.columns_for_metadata_update[target_column].emplace(
                 fragment_id);
           }
         }
       };
       return callback;
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

Executor* StorageIOFacility::executor_

private

Definition at line 692 of file StorageIOFacility.h.

Referenced by yieldUpdateCallback().

The documentation for this class was generated from the following file:

/home/jenkins-slave/workspace/core-os-doxygen/QueryEngine/StorageIOFacility.h

Classes

Public Types

Public Member Functions

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation