bool InOperator::Open(const PartitionOffset& partition_offset) {
state_.child_set_->Open(partition_offset);
state_.child_in_->Open(partition_offset);
AtomicPushFreeHtBlockStream(BlockStreamBase::createBlock(
state_.schema_child_set_, state_.block_size_));
AtomicPushFreeBlockStream(BlockStreamBase::createBlock(
state_.schema_child_in_, state_.block_size_));
if (sema_open_.try_wait()) {
// initialize hash table, use the child_set to build hash table
hash_func_ =
PartitionFunctionFactory::createBoostHashFunction(state_.ht_nbuckets_);
vector<unsigned> ht_index;
ht_index.push_back(state_.index_child_set_);
hash_table_ = new BasicHashTable(
state_.ht_nbuckets_, state_.ht_bucket_size_,
(state_.schema_child_set_->getSubSchema(ht_index))->getTupleMaxSize());
ht_index.clear();
open_finished_ = true;
} else {
while (!open_finished_) usleep(1);
}
void* cur_tuple = NULL;
void* tuple_in_hashtable = NULL;
unsigned bn = 0;
BlockStreamBase* bsb = AtomicPopFreeHtBlockStream();
while (state_.child_set_->Next(bsb)) {
BlockStreamBase::BlockStreamTraverseIterator* bsti = bsb->createIterator();
bsti->reset();
while (cur_tuple = bsti->nextTuple()) {
bn = state_.schema_child_set_->getcolumn(state_.index_child_set_)
.operate->GetPartitionValue(
state_.schema_child_set_->getColumnAddess(
state_.index_child_set_, cur_tuple),
state_.ht_nbuckets_);
tuple_in_hashtable = hash_table_->atomicAllocate(bn);
state_.schema_child_set_->getcolumn(state_.index_child_set_)
.operate->Assign(state_.schema_child_set_->getColumnAddess(
state_.index_child_set_, cur_tuple),
tuple_in_hashtable);
}
bsb->setEmpty();
}
barrier_->Arrive();
printf("-----------In Iterator Open Successful!-----------\n");
return true;
}
bool BlockStreamJoinIterator::open(const PartitionOffset& partition_offset){
#ifdef TIME
startTimer(&timer);
#endif
state_.child_left->open(partition_offset);
AtomicPushFreeHtBlockStream(BlockStreamBase::createBlock(state_.input_schema_left,state_.block_size_));
AtomicPushFreeBlockStream(BlockStreamBase::createBlock(state_.input_schema_right,state_.block_size_));
cout<<"AtomicPushFreeBlockStream\n\n"<<endl;
cout<<"join open begin"<<endl;
if(sema_open_.try_wait()){
unsigned output_index=0;
for(unsigned i=0;i<state_.joinIndex_left.size();i++){
joinIndex_left_to_output[i]=output_index;
output_index++;
}
for(unsigned i=0;i<state_.payload_left.size();i++){
payload_left_to_output[i]=output_index;
output_index++;
}
for(unsigned i=0;i<state_.payload_right.size();i++){
payload_right_to_output[i]=output_index;
output_index++;
}
/* Currently, the block is 4096, and the table in build phase is left one*/
hash=PartitionFunctionFactory::createBoostHashFunction(state_.ht_nbuckets);
hashtable=new BasicHashTable(state_.ht_nbuckets,state_.ht_bucketsize,state_.input_schema_left->getTupleMaxSize());
cout<<"in the open master "<<endl;
open_finished_=true;
}else{
while (!open_finished_) {
usleep(1);
}
}
//hashtable createIterator的好处就是创建的都是可读的对象，不需要加锁
// lock_.acquire();
BasicHashTable::Iterator tmp_it=hashtable->CreateIterator();
// lock_.release();
void *cur;
void *tuple_in_hashtable;
unsigned bn;
void *key_in_input;
void *key_in_hashtable;
void *value_in_input;
void *value_in_hashtable;
BlockStreamBase *bsb=AtomicPopFreeHtBlockStream();
PartitionFunction* hash_test=PartitionFunctionFactory::createBoostHashFunction(4);
cout<<"in the hashtable build stage!"<<endl;
// consumed_tuples_from_left=0;
while(state_.child_left->next(bsb)){
BlockStreamBase::BlockStreamTraverseIterator *bsti=bsb->createIterator();
bsti->reset();
while(cur=bsti->nextTuple()){
consumed_tuples_from_left++;
//
// if(state_.ht_schema->getncolumns()>20)
// state_.ht_schema->displayTuple(cur,"|B|"); ///for debug
/* Currently, the join index is [0]-th column, so the hash table is based on the hash value of [0]-th column*/
// bn=hash->get_partition_value(*(unsigned long*)(state_.input_schema_left->getColumnAddess(state_.joinIndex_left[0],cur)));
// bn=state_.input_schema_left->getcolumn(0).operate->getPartitionValue(state_.input_schema_left->getColumnAddess(state_.joinIndex_left[0],cur),hash);
bn=state_.input_schema_left->getcolumn(state_.joinIndex_left[0]).operate->getPartitionValue(state_.input_schema_left->getColumnAddess(state_.joinIndex_left[0],cur),hash);
// const unsigned test_bn=state_.input_schema_left->getcolumn(state_.joinIndex_left[0]).operate->getPartitionValue(state_.input_schema_left->getColumnAddess(state_.joinIndex_left[0],cur),hash_test);
// if(rand()%10000<3){
// printf("key:%d\n",test_bn);
// }
// hashtable->placeIterator(tmp_it,bn);
// lock_.acquire();
tuple_in_hashtable=hashtable->atomicAllocate(bn);
/* copy join index columns*/
// for(unsigned i=0;i<state_.joinIndex_left.size();i++){
// key_in_input=state_.input_schema_left->getColumnAddess(state_.joinIndex_left[i],cur);
// key_in_hashtable=state_.ht_schema->getColumnAddess(joinIndex_left_to_output[i],tuple_in_hashtable);
// state_.input_schema_left->getcolumn(state_.joinIndex_left[i]).operate->assignment(key_in_input,key_in_hashtable);
//
// }
// /* copy left payload columns*/
// for(unsigned i=0;i<state_.payload_left.size();i++){
// value_in_input=state_.input_schema_left->getColumnAddess(state_.payload_left[i],cur);
// value_in_hashtable=state_.ht_schema->getColumnAddess(payload_left_to_output[i],tuple_in_hashtable);
// state_.input_schema_left->getcolumn(state_.payload_left[i]).operate->assignment(value_in_input,value_in_hashtable);
// }
state_.input_schema_left->copyTuple(cur,tuple_in_hashtable);
// lock_.release();
}
bsb->setEmpty();
}
// printf("<<<<<<<<<<<<<<<<Join Open consumes %d tuples\n",consumed_tuples_from_left);
BasicHashTable::Iterator it=hashtable->CreateIterator();
unsigned tmp=0;
tuples_in_hashtable=0;
// PartitionFunction* hash_tmp=PartitionFunctionFactory::createGeneralModuloFunction(4);
// while(hashtable->placeIterator(it,tmp++)){
// void* tuple;
// while(tuple=it.readCurrent()){
//// printf("join key:%s\n",(state_.input_schema_left->getcolumn(state_.joinIndex_left[0]).operate->toString(state_.input_schema_left->getColumnAddess(state_.joinIndex_left[0],tuple)).c_str()));
// tuples_in_hashtable++;
// unsigned bn=state_.input_schema_left->getcolumn(state_.joinIndex_left[0]).operate->getPartitionValue(state_.input_schema_left->getColumnAddess(state_.joinIndex_left[0],tuple),hash_tmp);
// if(rand()%1000<3)
// printf("partition key of left tuple:%d\n",bn);
// it.increase_cur_();
// }
// }
// cout<<"join open end"<<endl;
produced_tuples=0;
consumed_tuples_from_right=0;
// water_mark=0;
barrier_->Arrive();
cout<<"pass the arrive of barrier!!!"<<endl;
state_.child_right->open(partition_offset);
// cout<<"PartitionOffset:"<<partition_offset<<endl;
// sleep(1);
return true;
}
