/** * pay attention to the work of different block buffer according to the * comments near it */ bool ExchangeSenderPipeline::Open(SegmentExecStatus* const exec_status, const PartitionOffset&) { RETURN_IF_CANCELLED(exec_status); state_.child_->Open(exec_status, state_.partition_offset_); RETURN_IF_CANCELLED(exec_status); upper_num_ = state_.upper_id_list_.size(); partition_function_ = PartitionFunctionFactory::createBoostHashFunction(upper_num_); socket_fd_upper_list_ = new int[upper_num_]; /** * initialize the block that is used to accumulate the block obtained * by calling child iterator's next() */ block_for_asking_ = BlockStreamBase::createBlock(state_.schema_, state_.block_size_); /** * partitioned_data_buffer_ stores the tuples received from child iterator. * Note the tuples are partitioned and stored. */ partitioned_data_buffer_ = new PartitionedBlockBuffer( upper_num_, block_for_asking_->getSerializedBlockSize()); /** * the temporary block that is used to transfer a block from partitioned data * buffer into sending_buffer. */ block_for_sending_buffer_ = new BlockContainer(block_for_asking_->getSerializedBlockSize()); /** * Initialize the buffer that is used to hold the blocks being sent. There are * upper_num blocks, each corresponding to a merger. */ sending_buffer_ = new PartitionedBlockContainer( upper_num_, block_for_asking_->getSerializedBlockSize()); // Initialized the temporary block to hold the serialized block. block_for_serialization_ = new Block(block_for_asking_->getSerializedBlockSize()); /** * Initialize the blocks that are used to accumulate the tuples from child so * that the insertion to the buffer * can be conducted at the granularity of blocks rather than tuples. */ partitioned_block_stream_ = new BlockStreamBase* [upper_num_]; for (unsigned i = 0; i < upper_num_; ++i) { partitioned_block_stream_[i] = BlockStreamBase::createBlock(state_.schema_, state_.block_size_); } RETURN_IF_CANCELLED(exec_status); /** connect to all the mergers **/ for (unsigned upper_offset = 0; upper_offset < state_.upper_id_list_.size(); ++upper_offset) { RETURN_IF_CANCELLED(exec_status); LOG(INFO) << "(exchane_id= " << state_.exchange_id_ << " partition_offset= " << state_.partition_offset_ << " ) try to connect to upper( " << upper_offset << " , " << state_.upper_id_list_[upper_offset] << " ) "; if (ConnectToUpper(ExchangeID(state_.exchange_id_, upper_offset), state_.upper_id_list_[upper_offset], socket_fd_upper_list_[upper_offset]) != true) { LOG(INFO) << "unsuccessfully !" << std::endl; return false; } } LOG(INFO) << "connect to all mereger successfully !" << std::endl; RETURN_IF_CANCELLED(exec_status); /** create the Sender thread **/ int error = pthread_create(&sender_thread_id_, NULL, Sender, this); if (error != 0) { LOG(ERROR) << "(exchane_id= " << state_.exchange_id_ << " partition_offset= " << state_.partition_offset_ << " ) Failed to create the sender thread>>>>>>>>>>" << std::endl; return false; } return true; }
bool ExpandableBlockStreamExchangeLowerEfficient::open(const PartitionOffset&) { logging_->log("[%lld] Exchange lower is created!", state_.exchange_id_); debug_connected_uppers = 0; debug_connected_uppers_in = 0; state_.child_->open(state_.partition_offset_); nuppers_ = state_.upper_id_list_.size(); partition_function_ = PartitionFunctionFactory::createBoostHashFunction( nuppers_); socket_fd_upper_list = new int[nuppers_]; /** initialize the block stream that is used to accumulate the block obtained by calling child iterator's next() **/ block_stream_for_asking_ = BlockStreamBase::createBlock(state_.schema_, state_.block_size_); /** buffer stores the tuples received from child iterator. Note the tuples are partitioned and stored. **/ partitioned_data_buffer_ = new PartitionedBlockBuffer( nuppers_, block_stream_for_asking_->getSerializedBlockSize()); /** the temporary block that is used to transfer a block from partitioned data buffer into sending buffer.**/ block_for_buffer_ = new BlockContainer( block_stream_for_asking_->getSerializedBlockSize()); /** Initialize the buffer that is used to hold the blocks being sent. There are nuppers block, each corresponding * to a merger. **/ sending_buffer_ = new PartitionedBlockContainer( nuppers_, block_stream_for_asking_->getSerializedBlockSize()); /** Initialized the temporary block to hold the serialized block stream. **/ block_for_serialization_ = new Block( block_stream_for_asking_->getSerializedBlockSize()); /** Initialize the blocks that are used to accumulate the tuples from child so that the insertion to the buffer * can be conducted at the granularity of blocks rather than tuples. */ partitioned_block_stream_ = new BlockStreamBase*[nuppers_]; for (unsigned i = 0; i < nuppers_; i++) { partitioned_block_stream_[i] = BlockStreamBase::createBlock( state_.schema_, state_.block_size_); } /** connect to all the mergers **/ for (unsigned upper_offset = 0; upper_offset < state_.upper_id_list_.size(); upper_offset++) { logging_->log("[%ld,%d] try to connect to upper (%d) %s\n", state_.exchange_id_, state_.partition_offset_, upper_offset, state_.upper_id_list_[upper_offset]); if (ConnectToUpper(ExchangeID(state_.exchange_id_, upper_offset), state_.upper_id_list_[upper_offset], socket_fd_upper_list[upper_offset], logging_) != true) return false; printf("[%ld,%d] connected to upper [%d,%d] on Node %d\n", state_.exchange_id_, state_.partition_offset_, state_.exchange_id_, upper_offset, state_.upper_id_list_[upper_offset]); } /** create the sender thread **/ // if (true == g_thread_pool_used) { // Environment::getInstance()->getThreadPool()->add_task(sender, this); // } // else { int error; error = pthread_create(&sender_tid, NULL, sender, this); if (error != 0) { logging_->elog( "Failed to create the sender thread>>>>>>>>>>>>>>>>>>>>>>>>>>>>@@#@#\n\n."); return false; } // } // pthread_create(&debug_tid,NULL,debug,this); /*debug*/ return true; }