int mainasdf(int argc, const char** argv){
int master;
printf("Master(0) or Slave(others)?\n");
scanf("%d",&master);
if(master==0){
Environment::getInstance(true);
const unsigned block_size=atoi(argv[1]);
const unsigned thread_count=atoi(argv[2]);
int f=atoi(argv[3]);
const unsigned expander_buffer=atoi(argv[4]);
const unsigned lowers_1=atoi(argv[5]);
const unsigned lowers_2=atoi(argv[6]);
std::vector<std::string> upper_ip_list;
upper_ip_list.push_back("10.11.1.211");
std::vector<std::string> lower_ip_list;
lower_ip_list.push_back("10.11.1.201");
lower_ip_list.push_back("10.11.1.202");
lower_ip_list.push_back("10.11.1.203");
lower_ip_list.push_back("10.11.1.204");
lower_ip_list.push_back("10.11.1.209");
// lower_ip_list.push_back("10.11.1.210");
// lower_ip_list.push_back("10.11.1.201");
lower_ip_list.push_back("10.11.1.214");
lower_ip_list.push_back("10.11.1.207");
lower_ip_list.push_back("10.11.1.208");
lower_ip_list.push_back("10.11.1.205");
lower_ip_list.push_back("10.11.1.206");
std::vector<std::string> used_lowers_1;
for(unsigned i=0;i<lowers_1;i++){
used_lowers_1.push_back(lower_ip_list[i]);
}
//
std::vector<std::string> used_lowers_2;
for(unsigned i=lower_ip_list.size()-1;i>=lower_ip_list.size()-lowers_2;i--){
used_lowers_2.push_back(lower_ip_list[i]);
}
std::vector<column_type> column_list,column_list_;
column_list.push_back(column_type(t_int));
Schema* schema=new SchemaFix(column_list);
/*ColumnScan*/
ExpandableBlockStreamSingleColumnScan::State ebssc_state("/home/imdb/temp/Uniform_0_999.column",schema,block_size);
BlockStreamIteratorBase* ebssc=new ExpandableBlockStreamSingleColumnScan(ebssc_state);
//
// FilterIterator::AttributeComparator filter1(column_type(t_int),Comparator::L,0,&f);
// std::vector<FilterIterator::AttributeComparator> ComparatorList;
// ComparatorList.push_back(filter1);
// ExpandableBlockStreamFilter::State ebsf_state(schema,ebssc,ComparatorList,block_size);
// BlockStreamIteratorBase* bbsf=new ExpandableBlockStreamFilter(ebsf_state);
/*Expander*/
BlockStreamExpander::State bse_state_1(schema,ebssc,thread_count,block_size,expander_buffer);
BlockStreamIteratorBase* bse_1=new BlockStreamExpander(bse_state_1);
/* Exchange */
const int exchange_id_1=1;
ExpandableBlockStreamExchangeEpoll::State ebse_state_1(schema,bse_1,block_size,used_lowers_2,used_lowers_1,exchange_id_1);
BlockStreamIteratorBase* ebse_1=new ExpandableBlockStreamExchangeEpoll(ebse_state_1);
/*Filter*/
FilterIterator::AttributeComparator filter1(column_type(t_int),Comparator::L,0,&f);
std::vector<FilterIterator::AttributeComparator> ComparatorList;
ComparatorList.push_back(filter1);
ExpandableBlockStreamFilter::State ebsf_state(schema,ebse_1,ComparatorList,block_size);
BlockStreamIteratorBase* bbsf=new ExpandableBlockStreamFilter(ebsf_state);
/*Expander*/
BlockStreamExpander::State bse_state(schema,bbsf,thread_count,block_size,expander_buffer);
BlockStreamIteratorBase* bse=new BlockStreamExpander(bse_state);
/* Exchange */
const int exchange_id=0;
ExpandableBlockStreamExchangeEpoll::State ebse_state(schema,bse,block_size,used_lowers_1,upper_ip_list,exchange_id);
BlockStreamIteratorBase* ebse=new ExpandableBlockStreamExchangeEpoll(ebse_state);
/* Performance Monitor*/
BlockStreamPerformanceMonitorTop::State bspfm_state(schema,ebse,block_size,1000);
BlockStreamIteratorBase* bspfm=new BlockStreamPerformanceMonitorTop(bspfm_state);
// BlockStreamBase *block=new BlockStreamFix(block_size,4);
volatile int choice;
printf("Continue(1) or Not(0) ?\n");
scanf("%d",&choice);
unsigned tuple_count=0;
while(choice==1){
// bsf->open();
bspfm->open();
// unsigned long long int start=curtick();
// tuple_count=0;
while(bspfm->next(0)){
// BlockStreamBase::BlockStreamTraverseIterator *it=block->createIterator();
// void* tuple;
// while(tuple=it->nextTuple()){
//// printf("tuple:%d \n",*(int*)tuple);
// tuple_count++;
// }
// block->setEmpty();
}
// printf("Total tupls:%d\n",tuple_count);
// printf("Time=%f Throughput=%f.\n",getSecond(start),1024/getSecond(start));
bspfm->close();
printf("Continue(0) or Not(1) ?\n");
// getchar();
scanf("%d",&choice);
printf("you input %d\n",choice);
}
}
else{
Environment::getInstance(false);
}
printf("Waiting~~~~~....\n");
while(true){
sleep(1);
}
}
static int in_iterator_test ()
{
cout << "test in\n";
std::vector<column_type> column_list;
column_list.push_back(column_type(t_u_long));
column_list.push_back(column_type(t_int));
column_list.push_back(column_type(t_u_long));
column_list.push_back(column_type(t_int));
column_list.push_back(column_type(t_int));
column_list.push_back(column_type(t_int));
Schema* input=new SchemaFix(column_list);
Schema* output=new SchemaFix(column_list);
unsigned block_size = 64*1024-sizeof(unsigned);
ExpandableBlockStreamSingleColumnScan::State ebsscs1_state("/home/claims/data/wangli/T0G0P0",input, block_size);
BlockStreamIteratorBase* ebssc1=new ExpandableBlockStreamSingleColumnScan(ebsscs1_state);
unsigned long f = 20000;
AttributeComparator fA(column_type(t_u_long),Comparator::L,0,&f);
std::vector<AttributeComparator> ComparatorList;
ComparatorList.push_back(fA);
ExpandableBlockStreamFilter::State ebsf_state(input, ebssc1, ComparatorList, block_size);
BlockStreamIteratorBase* ebfs = new ExpandableBlockStreamFilter(ebsf_state);
ExpandableBlockStreamSingleColumnScan::State ebsscs2_state("/home/claims/data/wangli/T0G0P0",input, block_size);
BlockStreamIteratorBase* ebssc2=new ExpandableBlockStreamSingleColumnScan(ebsscs1_state);
BlockStreamInIterator::State bsii_state(ebfs, ebssc2, input, input, 0, 0, block_size);
BlockStreamIteratorBase* bsii = new BlockStreamInIterator(bsii_state);
std::vector<string> attr_name;
attr_name.push_back("rowid");
attr_name.push_back("Trade_Date");
attr_name.push_back("Order_No");
attr_name.push_back("Sec_Code");
attr_name.push_back("Trade_Dir");
attr_name.push_back("Order_Type");
BlockStreamPrint::State bsp1_state(input, ebfs, block_size, attr_name, "\t");
BlockStreamIteratorBase* bsp1 = new BlockStreamPrint(bsp1_state);
bsp1->print();
bsp1->open(0);
BlockStreamBase* block = BlockStreamBase::createBlock(input, block_size);
while(bsp1->next(block));
{
}
bsp1->close();
BlockStreamPrint::State bsp_state(input, bsii, block_size, attr_name, "\t");
BlockStreamIteratorBase* bsp = new BlockStreamPrint(bsp_state);
bsp->open(0);
// BlockStreamBase* block = BlockStreamBase::createBlock(input, block_size);
while(bsp->next(block));
{
}
bsp->close();
PhysicalQueryPlan IM(bsp);
Message4K M4K = PhysicalQueryPlan::serialize4K(IM);
PhysicalQueryPlan tmp = PhysicalQueryPlan::deserialize4K(M4K);
tmp.run();
return 0;
}
