// Generate a scan over all tile groups.
//
// @code
// column_layouts := alloca<peloton::ColumnLayoutInfo>(
// table.GetSchema().GetColumnCount())
//
// oid_t tile_group_idx := 0
// num_tile_groups = GetTileGroupCount(table_ptr)
//
// for (; tile_group_idx < num_tile_groups; ++tile_group_idx) {
// tile_group_ptr := GetTileGroup(table_ptr, tile_group_idx)
// consumer.TileGroupStart(tile_group_ptr);
// tile_group.TidScan(tile_group_ptr, column_layouts, vector_size, consumer);
// consumer.TileGroupEnd(tile_group_ptr);
// }
//
// @endcode
void Table::GenerateScan(CodeGen &codegen, llvm::Value *table_ptr,
uint32_t batch_size, ScanCallback &consumer) const {
// First get the columns from the table the consumer needs. For every column,
// we'll need to have a ColumnInfoLayout struct
const uint32_t num_columns =
static_cast<uint32_t>(table_.GetSchema()->GetColumnCount());
llvm::Value *column_layouts = codegen->CreateAlloca(
RuntimeFunctionsProxy::_ColumnLayoutInfo::GetType(codegen),
codegen.Const32(num_columns));
// Get the number of tile groups in the given table
llvm::Value *tile_group_idx = codegen.Const64(0);
llvm::Value *num_tile_groups = GetTileGroupCount(codegen, table_ptr);
// Iterate over all tile groups in the table
lang::Loop loop{codegen,
codegen->CreateICmpULT(tile_group_idx, num_tile_groups),
{{"tileGroupIdx", tile_group_idx}}};
{
// Get the tile group with the given tile group ID
tile_group_idx = loop.GetLoopVar(0);
llvm::Value *tile_group_ptr =
GetTileGroup(codegen, table_ptr, tile_group_idx);
llvm::Value *tile_group_id =
tile_group_.GetTileGroupId(codegen, tile_group_ptr);
// Invoke the consumer to let her know that we're starting to iterate over
// the tile group now
consumer.TileGroupStart(codegen, tile_group_id, tile_group_ptr);
// Generate the scan cover over the given tile group
tile_group_.GenerateTidScan(codegen, tile_group_ptr, column_layouts,
batch_size, consumer);
// Invoke the consumer to let her know that we're done with this tile group
consumer.TileGroupFinish(codegen, tile_group_ptr);
// Move to next tile group in the table
tile_group_idx = codegen->CreateAdd(tile_group_idx, codegen.Const64(1));
loop.LoopEnd(codegen->CreateICmpULT(tile_group_idx, num_tile_groups),
{tile_group_idx});
}
}
// Iterate over all valid rows in this batch
void RowBatch::Iterate(CodeGen &codegen, RowBatch::IterateCallback &cb) {
// The starting position in the batch
llvm::Value *start = codegen.Const32(0);
// The ending position in the batch
llvm::Value *end = GetNumValidRows(codegen);
// Generating the loop
std::vector<lang::Loop::LoopVariable> loop_vars = {
{"readIdx", start}, {"writeIdx", codegen.Const32(0)}};
llvm::Value *loop_cond = codegen->CreateICmpULT(start, end);
lang::Loop batch_loop{codegen, loop_cond, loop_vars};
{
// Pull out loop vars for convenience
auto *batch_pos = batch_loop.GetLoopVar(0);
auto *write_pos = batch_loop.GetLoopVar(1);
// Create an output tracker to track the final position of the row
OutputTracker tracker{GetSelectionVector(), write_pos};
// Get the current row
RowBatch::Row row = GetRowAt(batch_pos, &tracker);
// Invoke callback
cb.ProcessRow(row);
// The next read position is one next
auto *next_read_pos = codegen->CreateAdd(batch_pos, codegen.Const32(1));
// The write position from the output track
auto *next_write_pos = tracker.GetFinalOutputPos();
// Close up loop
llvm::Value *loop_cond = codegen->CreateICmpULT(next_read_pos, end);
batch_loop.LoopEnd(loop_cond, {next_read_pos, next_write_pos});
}
// After the batch loop, we need to reset the size of the selection vector
std::vector<llvm::Value *> final_vals;
batch_loop.CollectFinalLoopVariables(final_vals);
// Mark the last position in the batch
UpdateWritePosition(final_vals[1]);
}
void ProcessEntries(CodeGen &codegen, llvm::Value *start_index,
llvm::Value *end_index, SorterAccess &access) const {
lang::Loop loop(codegen,
codegen->CreateICmpULT(start_index, end_index),
{{"start", start_index}});
{
llvm::Value *curr_index = loop.GetLoopVar(0);
// Parse the row
std::vector<codegen::Value> vals;
auto &row = access.GetRow(curr_index);
for (uint32_t i = 0; i < storage.GetNumElements(); i++) {
vals.emplace_back(row.LoadColumn(codegen, i));
}
// Call the actual callback
callback.ProcessEntry(codegen, vals);
curr_index = codegen->CreateAdd(curr_index, codegen.Const32(1));
loop.LoopEnd(codegen->CreateICmpULT(curr_index, end_index),
{curr_index});
}
}
void RowBatch::OutputTracker::AppendRowToOutput(CodeGen &codegen,
RowBatch::Row &row,
llvm::Value *delta) {
output_.SetValue(codegen, target_pos_, row.GetTID(codegen));
final_pos_ = codegen->CreateAdd(target_pos_, delta);
}
