bool ExpandableBlockStreamExchange::open(const PartitionOffset& partition_off){
if(sem_open_.try_wait()){
nexhausted_lowers=0;
nlowers=state.lower_ip_list.size();
for(unsigned i=0;i<nlowers;i++){
received_block[i]=0;
}
socket_fd_lower_list=new int[nlowers];
// lower_ip_array=new std::string[nlowers];
buffer=new BlockStreamBuffer(state.block_size,nlowers*10,state.schema);
received_block_stream_=BlockStreamBase::createBlock(state.schema,state.block_size);
block_for_socket_=new BlockReadableFix(received_block_stream_->getSerializedBlockSize(),state.schema);
if(PrepareTheSocket()==false)
return false;
if(RegisterExchange()==false){
Logging_ExchangeIteratorEager("Register Exchange with ID=%l fails!",state.exchange_id);
}
if(isMaster()){
Logging_ExchangeIteratorEager("This exchange is the master one, serialize the iterator subtree to the children...");
if(SerializeAndSendToMulti()==false)
return false;
}
if(WaitForConnectionFromLowerExchanges()==false){
return false;
}
if(CreateReceiverThread()==false){
return false;
}
open_finished_=true;
return true;
}
else{
while(!open_finished_){
usleep(1);
}
return true;
}
}
bool ExpandableBlockStreamExchangeMaterialized::open(const PartitionOffset& part_off){
if(sem_open_.try_wait()){
nexhausted_lowers_=0;
received_block_stream_=BlockStreamBase::createBlock(state_.schema_,state_.block_size_);
block_for_socket_=new BlockReadableFix(received_block_stream_->getSerializedBlockSize(),state_.schema_);
buffer=new BlockStreamBuffer(state_.block_size_,nlowers_*10,state_.schema_);
if(PrepareTheSocket()==false)
return false;
if(RegisterExchange(ExchangeID(state_.exchange_id_,0))==false){
Logging_ExpandableBlockStreamExchangeMaterialized("Register Exchange with ID=%l fails!",state_.exchange_id_);
}
if(isMaster()){
Logging_ExpandableBlockStreamExchangeMaterialized("This exchange is the master one, serialize the iterator subtree to the children...");
if(SerializeAndSendToMulti()==false)
return false;
}
if(WaitForConnectionFromLowerExchanges()==false){
return false;
}
if(pthread_create(&receiver_tid,NULL,receiver,this)!=0){
Logging_ExpandableBlockStreamExchangeMaterialized("Failed to create receiver thread.");
return false;
}
open_finished_=true;
return true;
}
else{
while(!open_finished_){
usleep(1);
}
return true;
}
}
bool ExpandableBlockStreamExchangeEpoll::open(const PartitionOffset& partition_offset)
{
unsigned long long int start = curtick();
RegisterExpandedThreadToAllBarriers();
if (tryEntryIntoSerializedSection())
{
debug_winner_thread++;
nexhausted_lowers=0;
this->partition_offset=partition_offset;
nlowers=state.lower_id_list_.size();
for (unsigned i = 0; i < nlowers; i++)
{
debug_received_block[i] = 0;
}
socket_fd_lower_list = new int[nlowers];
//init -1 ---Yu
for (int i = 0; i < nlowers; ++i) {
socket_fd_lower_list[i] = -1;
}
buffer=new BlockStreamBuffer(state.block_size_,BUFFER_SIZE_IN_EXCHANGE,state.schema_);
ExpanderTracker::getInstance()->addNewStageEndpoint(pthread_self(),LocalStageEndPoint(stage_src,"Exchange",buffer));
received_block_stream_=BlockStreamBase::createBlock(state.schema_,state.block_size_);
block_for_socket_ = new BlockContainer*[nlowers];
for (unsigned i = 0; i < nlowers; i++)
{
block_for_socket_[i] = new BlockContainer(received_block_stream_->getSerializedBlockSize());
}
if (PrepareTheSocket() == false)
return false;
if (SetSocketNonBlocking(sock_fd) == false)
{
return false;
}
logging_->log("[%ld,%d] Open: nexhausted lowers=%d, nlower=%d", state.exchange_id_, partition_offset, nexhausted_lowers, nlowers);
if (RegisterExchange() == false)
{
logging_->elog("Register Exchange with ID=%d fails!", state.exchange_id_);
}
if(isMaster()){
/* According to a bug reported by dsc, the master exchangeupper should check whether other
* uppers have registered to exchangeTracker. Otherwise, the lower may fail to connect to the
* exchangeTracker of some uppers when the lower nodes receive the exchagnelower, as some uppers
* have not register the exchange_id to the exchangeTracker.
*/
logging_->log("[%ld,%d] Synchronizing....", state.exchange_id_, partition_offset);
checkOtherUpperRegistered();
logging_->log("[%ld,%d] Synchronized!", state.exchange_id_, partition_offset);
logging_->log("[%ld,%d] This exchange is the master one, serialize the iterator subtree to the children...", state.exchange_id_, partition_offset);
if (SerializeAndSendToMulti() == false)
return false;
}
if (CreateReceiverThread() == false)
{
return false;
}
createPerformanceInfo();
}
/* A synchronization barrier, in case of multiple expanded threads*/
barrierArrive();
return true;
}
/**
* note the serialized block's size is different from others, it has tail info.
* exchange merger is at the end of one segment of plan, so it's the "stage_src"
* for this stage
*/
bool ExchangeMerger::Open(const PartitionOffset& partition_offset) {
unsigned long long int start = curtick();
RegisterExpandedThreadToAllBarriers();
if (TryEntryIntoSerializedSection()) { // first arrived thread dose
exhausted_lowers = 0;
this->partition_offset_ = partition_offset;
lower_num_ = state_.lower_id_list_.size();
socket_fd_lower_list_ = new int[lower_num_];
for (int i = 0; i < lower_num_; ++i) {
socket_fd_lower_list_[i] = -1;
}
// buffer all deserialized blocks come from every socket
all_merged_block_buffer_ = new BlockStreamBuffer(
state_.block_size_, BUFFER_SIZE_IN_EXCHANGE, state_.schema_);
ExpanderTracker::getInstance()->addNewStageEndpoint(
pthread_self(),
LocalStageEndPoint(stage_src, "Exchange", all_merged_block_buffer_));
// if one of block_for_socket is full, it will be deserialized into
// block_for_deserialization and sended to all_merged_data_buffer
block_for_deserialization =
BlockStreamBase::createBlock(state_.schema_, state_.block_size_);
// store block for each socket and the received block is serialized.
block_for_socket_ = new BlockContainer* [lower_num_];
for (unsigned i = 0; i < lower_num_; ++i) {
block_for_socket_[i] = new BlockContainer(
block_for_deserialization->getSerializedBlockSize());
}
if (PrepareSocket() == false) return false;
if (SetSocketNonBlocking(sock_fd_) == false) {
return false;
}
LOG(INFO) << "exchange_id = " << state_.exchange_id_
<< " partition_offset = " << partition_offset
<< " Open: exhausted lower senders num = " << exhausted_lowers
<< " lower sender num = " << lower_num_ << std::endl;
if (RegisterExchange() == false) {
LOG(ERROR) << "Register Exchange with ID = " << state_.exchange_id_
<< " fails!" << std::endl;
}
if (IsMaster()) {
/* According to a bug reported by dsc, the master exchange upper should
* check whether other uppers have registered to exchangeTracker.
* Otherwise, the lower may fail to connect to the exchangeTracker of some
* uppers when the lower nodes receive the exchange lower, as some uppers
* have not register the exchange_id to the exchangeTracker.
*/
LOG(INFO) << " exchange_id = " << state_.exchange_id_
<< " partition_offset = " << partition_offset
<< "Synchronizing...." << std::endl;
IsOtherMergersRegistered();
LOG(INFO) << " exchange_id = " << state_.exchange_id_
<< " partition_offset = " << partition_offset
<< " Synchronized! Then serialize and send its next segment "
"plan to all its lower senders" << std::endl;
if (SerializeAndSendPlan() == false) return false;
}
if (CreateReceiverThread() == false) {
return false;
}
CreatePerformanceInfo();
}
/// A synchronization barrier, in case of multiple expanded threads
BarrierArrive();
return true;
}
