Rebase fix

Author: pmenon

src/codegen/codegen.cpp

@@ -284,7 +284,7 @@ uint64_t CodeGen::SizeOf(llvm::Type *type) const {
 }
 
 uint64_t CodeGen::ElementOffset(llvm::Type *type, uint32_t element_idx) const {
-  PL_ASSERT(llvm::isa<llvm::StructType>(type));
+  PELOTON_ASSERT(llvm::isa<llvm::StructType>(type));
   auto &data_layout = code_context_.GetDataLayout();
 
   auto *struct_layout =

src/codegen/pipeline.cpp

@@ -78,12 +78,13 @@ PipelineContext::PipelineContext(Pipeline &pipeline)
 
 PipelineContext::Id PipelineContext::RegisterState(std::string name,
                                                    llvm::Type *type) {
-  PL_ASSERT(thread_state_type_ == nullptr);
+  PELOTON_ASSERT(thread_state_type_ == nullptr);
   if (thread_state_type_ != nullptr) {
     throw Exception{"Cannot register thread state after finalization"};
   }
 
-  PL_ASSERT(state_components_.size() < std::numeric_limits<uint8_t>::max());
+  PELOTON_ASSERT(state_components_.size() <
+                 std::numeric_limits<uint8_t>::max());
   auto slot = static_cast<uint8_t>(state_components_.size());
   state_components_.emplace_back(name, type);
   return slot;
@@ -111,7 +112,7 @@ void PipelineContext::FinalizeState(CodeGen &codegen) {
 
 llvm::Value *PipelineContext::AccessThreadState(
     UNUSED_ATTRIBUTE CodeGen &codegen) const {
-  PL_ASSERT(thread_state_ != nullptr);
+  PELOTON_ASSERT(thread_state_ != nullptr);
   return thread_state_;
 }
 
@@ -120,8 +121,8 @@ llvm::Value *PipelineContext::LoadFlag(CodeGen &codegen) const {
 }
 
 void PipelineContext::StoreFlag(CodeGen &codegen, llvm::Value *flag) const {
-  PL_ASSERT(flag->getType()->isIntegerTy(1) &&
-            flag->getType() == codegen.BoolType());
+  PELOTON_ASSERT(flag->getType()->isIntegerTy(1) &&
+                 flag->getType() == codegen.BoolType());
   auto *flag_ptr = LoadStatePtr(codegen, init_flag_id_);
   codegen->CreateStore(flag, flag_ptr);
 }
@@ -183,7 +184,7 @@ void Pipeline::Add(OperatorTranslator *translator, Parallelism parallelism) {
 
 void Pipeline::MarkSource(OperatorTranslator *translator,
                           Pipeline::Parallelism parallelism) {
-  PL_ASSERT(translator == pipeline_.back());
+  PELOTON_ASSERT(translator == pipeline_.back());
 
   // Check parallel execution settings
   bool parallel_exec_disabled = !settings::SettingsManager::GetBool(
@@ -240,7 +241,7 @@ const OperatorTranslator *Pipeline::NextStep() {
 void Pipeline::InstallStageBoundary(
     UNUSED_ATTRIBUTE const OperatorTranslator *translator) {
   // Validate the assumption
-  PL_ASSERT(pipeline_[pipeline_index_] == translator);
+  PELOTON_ASSERT(pipeline_[pipeline_index_] == translator);
   stage_boundaries_.push_back(pipeline_index_ + 1);
 }
 
@@ -409,7 +410,7 @@ void Pipeline::RunParallel(
     const std::vector<llvm::Type *> &pipeline_args_types,
     const std::function<void(ConsumerContext &,
                              const std::vector<llvm::Value *> &)> &body) {
-  PL_ASSERT(IsParallel());
+  PELOTON_ASSERT(IsParallel());
   Run(dispatch_func, dispatch_args, pipeline_args_types, body);
 }
 

src/codegen/util/buffer.cpp

@@ -68,7 +68,7 @@ void Buffer::MakeRoomForBytes(uint64_t num_bytes) {
   uint64_t curr_used_size = UsedSpace();
 
   // Ensure the current size is a power of two
-  PL_ASSERT(curr_alloc_size % 2 == 0);
+  PELOTON_ASSERT(curr_alloc_size % 2 == 0);
 
   // Allocate double the buffer room
   uint64_t next_alloc_size = curr_alloc_size;
@@ -83,7 +83,7 @@ void Buffer::MakeRoomForBytes(uint64_t num_bytes) {
       backend_manager.Allocate(BackendType::MM, next_alloc_size));
 
   // Now copy the previous buffer into the new area
-  PL_MEMCPY(new_buffer, buffer_start_, curr_used_size);
+  PELOTON_MEMCPY(new_buffer, buffer_start_, curr_used_size);
 
   // Set pointers
   char *old_buffer_start = buffer_start_;

src/executor/executor_context.cpp

@@ -72,19 +72,19 @@ void ExecutorContext::ThreadStates::Reset(const uint32_t state_size) {
 }
 
 void ExecutorContext::ThreadStates::Allocate(const uint32_t num_threads) {
-  PL_ASSERT(state_size_ > 0);
-  PL_ASSERT(states_ == nullptr);
+  PELOTON_ASSERT(state_size_ > 0);
+  PELOTON_ASSERT(states_ == nullptr);
   num_threads_ = num_threads;
   uint32_t alloc_size = num_threads_ * state_size_;
   states_ = reinterpret_cast<char *>(pool_.Allocate(alloc_size));
-  PL_MEMSET(states_, 0, alloc_size);
+  PELOTON_MEMSET(states_, 0, alloc_size);
 }
 
 char *ExecutorContext::ThreadStates::AccessThreadState(
     const uint32_t thread_id) const {
-  PL_ASSERT(state_size_ > 0);
-  PL_ASSERT(states_ != nullptr);
-  PL_ASSERT(thread_id < num_threads_);
+  PELOTON_ASSERT(state_size_ > 0);
+  PELOTON_ASSERT(states_ != nullptr);
+  PELOTON_ASSERT(thread_id < num_threads_);
   return states_ + (thread_id * state_size_);
 }
 

src/include/threadpool/mono_queue_pool.h

@@ -90,8 +90,8 @@ inline MonoQueuePool &MonoQueuePool::GetInstance() {
   int32_t worker_pool_size = settings::SettingsManager::GetInt(
       settings::SettingId::monoqueue_worker_pool_size);
 
-  PL_ASSERT(task_queue_size > 0);
-  PL_ASSERT(worker_pool_size > 0);
+  PELOTON_ASSERT(task_queue_size > 0);
+  PELOTON_ASSERT(worker_pool_size > 0);
 
   std::string name = "main-pool";
 
@@ -107,8 +107,8 @@ inline MonoQueuePool &MonoQueuePool::GetBrainInstance() {
   int32_t worker_pool_size = settings::SettingsManager::GetInt(
       settings::SettingId::brain_worker_pool_size);
 
-  PL_ASSERT(task_queue_size > 0);
-  PL_ASSERT(worker_pool_size > 0);
+  PELOTON_ASSERT(task_queue_size > 0);
+  PELOTON_ASSERT(worker_pool_size > 0);
 
   std::string name = "brain-pool";
 
@@ -124,8 +124,8 @@ inline MonoQueuePool &MonoQueuePool::GetExecutionInstance(){
   int32_t worker_pool_size = settings::SettingsManager::GetInt(
       settings::SettingId::monoqueue_worker_pool_size);
 
-  PL_ASSERT(task_queue_size > 0);
-  PL_ASSERT(worker_pool_size > 0);
+  PELOTON_ASSERT(task_queue_size > 0);
+  PELOTON_ASSERT(worker_pool_size > 0);
 
   std::string name = "executor-pool";