double noise::operator () (double &t) const
{
while (t >= t_rand) { // time to get a new random sample
i_old = i_rand;
q_old = q_rand;
if (n == 0) {
double x, y, r;
do {
x = (double) rnd_uint32() / 2147483648U - 1;
y = (double) rnd_uint32() / 2147483648U - 1;
r = x * x + y * y;
} while (r > 1 || r == 0);
r = sqrt(-variance * log(r) / r);
i_rand = filter1(x * r);
q_rand = filter2(y * r);
} else {
i_rand = filter1(0);
q_rand = filter2(0);
}
if (!(++n % 4)) n = 0;
t_rand += period;
// This uses a filter to do a 4x oversampling, and then a linear interpolation.
}
double tau = (t_rand - t) / period;
double i = i_old * tau + i_rand * (1 - tau);
double q = q_old * tau + q_rand * (1 - tau);
double y = i * sin(omega * t) + q * cos(omega * t);
t += t_sine;
return y;
}
void test_cute_filter_runner_ArgvFilter() {
char const *argv[] = { "dummy", "testsuite1", "testsuite2#test1",
"testsuite2#test3", 0 };
std::vector<std::string> args;
std::copy(argv + 1, argv + sizeof(argv) / sizeof(*argv) - 1,
std::back_inserter(args));
cute::runner_aux::ArgvTestFilter filter1("", args);
ASSERT(filter1.shouldRun("any"));
cute::runner_aux::ArgvTestFilter filter2("testsuite1", args);
ASSERT(filter2.shouldrunsuite);
ASSERT(filter2.shouldRun("test"));
ASSERT(filter2.shouldRun("test1"));
ASSERT(filter2.shouldRun("test2"));
ASSERT(filter2.shouldRun("test3"));
ASSERT(filter2.shouldRun("test4"));
cute::runner_aux::ArgvTestFilter filter3("dummy", args);
ASSERT(!filter3.shouldrunsuite);
cute::runner_aux::ArgvTestFilter filter4("testsuite2", args);
ASSERT(filter4.shouldrunsuite);
ASSERT(!filter4.shouldRun("test"));
ASSERT(filter4.shouldRun("test1"));
ASSERT(!filter4.shouldRun("test2"));
ASSERT(filter4.shouldRun("test3"));
ASSERT(!filter4.shouldRun("test4"));
}
static rc_t print_fastq_1_read( join_stats * stats,
struct join_results * results,
const fastq_rec * rec,
const join_options * jo,
uint32_t dst_id,
uint32_t read_id )
{
rc_t rc = 0;
if ( rec -> read . len != rec -> quality . len )
{
ErrMsg( "row #%ld : READ.len(%u) != QUALITY.len(%u)\n", rec -> row_id, rec -> read . len, rec -> quality . len );
stats -> reads_invalid++;
if ( jo -> terminate_on_invalid )
return SILENT_RC( rcApp, rcNoTarg, rcReading, rcItem, rcInvalid );
}
if ( filter1( stats, rec, jo ) )
{
if ( join_results_match( results, &( rec -> read ) ) )
{
rc = join_results_print_fastq_v1( results,
rec -> row_id,
dst_id,
read_id,
jo -> rowid_as_name ? NULL : &( rec -> name ),
&( rec -> read ),
&( rec -> quality ) );
if ( rc == 0 )
stats -> reads_written++;
}
}
return rc;
}
std_msgs::PointCloudFloat32* runFilters(const std_msgs::PointCloudFloat32 &cloud)
{
std_msgs::PointCloudFloat32 *cloudF = filter0(cloud, m_retainPointcloudFraction);
if (cloudF)
{
std_msgs::PointCloudFloat32 *temp = filter1(*cloudF);
delete cloudF;
cloudF = temp;
}
return cloudF;
}
int main()
{
X = 0;
INIT1 = TRUE;
INIT2 = TRUE;
while (TRUE) {
X = 0.98*X + 85.;
if (X >= -400. && X <= 400.) {
filter1();
X = X + 100.;
INIT1 = FALSE;
}
else if (X >= -800. && X <= 800.) {
filter2();
X = X - 50.;
INIT2 = FALSE;
}
__VERIFIER_assert(X >= -1155. && X <= 4251.);
}
return 0;
}
void run_function() {
ASSERT(!filter_node_count, NULL);
const size_t number_of_filters = 3;
input_filter<type1> i_filter;
middle_filter<type1, type2> m_filter;
output_filter<type2> o_filter;
unsigned limit = 1;
// Test pipeline that contains number_of_filters filters
for( unsigned i=0; i<number_of_filters; ++i)
limit *= number_of_filter_types;
// Iterate over possible filter sequences
for( unsigned numeral=0; numeral<limit; ++numeral ) {
unsigned temp = numeral;
tbb::filter::mode filter_type[number_of_filter_types];
for( unsigned i=0; i<number_of_filters; ++i, temp/=number_of_filter_types )
filter_type[i] = filter_table[temp%number_of_filter_types];
tbb::filter_t<void, type1> filter1( filter_type[0], i_filter );
tbb::filter_t<type1, type2> filter2( filter_type[1], m_filter );
tbb::filter_t<type2, void> filter3( filter_type[2], o_filter );
ASSERT(filter_node_count==3, "some filter nodes left after previous iteration?");
// Create filters sequence when parallel_pipeline() is being run
tbb::parallel_pipeline( n_tokens, filter1 & filter2 & filter3 );
check_and_reset();
// Create filters sequence partially outside parallel_pipeline() and also when parallel_pipeline() is being run
tbb::filter_t<void, type2> filter12;
filter12 = filter1 & filter2;
tbb::parallel_pipeline( n_tokens, filter12 & filter3 );
check_and_reset();
tbb::filter_t<void, void> filter123 = filter12 & filter3;
// Run pipeline twice with the same filter sequence
for( unsigned i = 0; i<2; i++ ) {
tbb::parallel_pipeline( n_tokens, filter123 );
check_and_reset();
}
// Now copy-construct another filter_t instance, and use it to run pipeline
{
tbb::filter_t<void, void> copy123( filter123 );
tbb::parallel_pipeline( n_tokens, copy123 );
check_and_reset();
}
// Construct filters and create the sequence when parallel_pipeline() is being run
tbb::parallel_pipeline( n_tokens,
tbb::make_filter<void, type1>(filter_type[0], i_filter) &
tbb::make_filter<type1, type2>(filter_type[1], m_filter) &
tbb::make_filter<type2, void>(filter_type[2], o_filter) );
check_and_reset();
// Construct filters, make a copy, destroy the original filters, and run with the copy
int cnt = filter_node_count;
{
tbb::filter_t<void, void>* p123 = new tbb::filter_t<void,void> (
tbb::make_filter<void, type1>(filter_type[0], i_filter) &
tbb::make_filter<type1, type2>(filter_type[1], m_filter) &
tbb::make_filter<type2, void>(filter_type[2], o_filter) );
ASSERT(filter_node_count==cnt+5, "filter node accounting error?");
tbb::filter_t<void, void> copy123( *p123 );
delete p123;
ASSERT(filter_node_count==cnt+5, "filter nodes deleted prematurely?");
tbb::parallel_pipeline( n_tokens, copy123 );
check_and_reset();
}
ASSERT(filter_node_count==cnt, "scope ended but filter nodes not deleted?");
#if __TBB_LAMBDAS_PRESENT
tbb::atomic<int> counter;
counter = max_counter;
// Construct filters using lambda-syntax and create the sequence when parallel_pipeline() is being run;
tbb::parallel_pipeline( n_tokens,
tbb::make_filter<void, type1>(filter_type[0], [&counter]( tbb::flow_control& control ) -> type1 {
if( --counter < 0 )
control.stop();
return type1(); }
) &
tbb::make_filter<type1, type2>(filter_type[1], []( type1 /*my_storage*/ ) -> type2 {
return type2(); }
) &
tbb::make_filter<type2, void>(filter_type[2], [] ( type2 ) -> void {
tmp_counter++; }
)
);
check_and_reset();
#endif
}
ASSERT(!filter_node_count, "filter_node objects leaked");
}
int main_asdfasdf(){
Environment::getInstance(true);
ResourceManagerMaster *rmms=Environment::getInstance()->getResourceManagerMaster();
Catalog* catalog=Environment::getInstance()->getCatalog();
// rmms->RegisterNewSlave("192.168.1.1");
// rmms->RegisterNewSlave("192.168.1.2");
// rmms->RegisterNewSlave("192.168.1.3");
// rmms->RegisterNewSlave("192.168.1.4");
// rmms->RegisterNewSlave("192.168.1.5");
// rmms->RegisterDiskBuget(0,10000);
// rmms->RegisterDiskBuget(1,10000);
// rmms->RegisterDiskBuget(2,10000);
// rmms->RegisterDiskBuget(3,10000);
// rmms->RegisterDiskBuget(4,10000);
/////////////////////////////////////Create table left/////////////////////
TableDescriptor* table_1=new TableDescriptor("Left",Environment::getInstance()->getCatalog()->allocate_unique_table_id());
table_1->addAttribute("Name",data_type(t_string),3);
table_1->addAttribute("Age",data_type(t_int));
table_1->addAttribute("Gender",data_type(t_int));
table_1->addAttribute("Score",data_type(t_int));
vector<ColumnOffset> index_1;
index_1.push_back(0);
index_1.push_back(1);
index_1.push_back(3);
const int partition_key_index_1=3;
table_1->createHashPartitionedProjection(index_1,partition_key_index_1,3);
catalog->add_table(table_1);
////////////////////////////////////Create table right//////////////////////////
TableDescriptor* table_2=new TableDescriptor("right",Environment::getInstance()->getCatalog()->allocate_unique_table_id());
table_2->addAttribute("Name",data_type(t_string),10);
table_2->addAttribute("Age",data_type(t_int));
table_2->addAttribute("Gender",data_type(t_int));
table_2->addAttribute("Score",data_type(t_int));
vector<ColumnOffset> index_2;
index_2.push_back(0);
index_2.push_back(1);
index_2.push_back(3);
const int partition_key_index_2=3;
table_2->createHashPartitionedProjection(index_2,partition_key_index_2,3);
catalog->add_table(table_2);
///////////////////////////////////////////////////////////
///////////////////////////////////////
////////////////////////////////////////
/* the following codes should be triggered by Load module*/
for(unsigned i=0;i<table_1->getProjectoin(0)->getPartitioner()->getNumberOfPartitions();i++){
catalog->getTable(0)->getProjectoin(0)->getPartitioner()->RegisterPartition(i,5);
}
for(unsigned i=0;i<table_2->getProjectoin(0)->getPartitioner()->getNumberOfPartitions();i++){
catalog->getTable(1)->getProjectoin(0)->getPartitioner()->RegisterPartition(i,4);
}
////////////////////////////////////////
ProjectionBinding *pb=new ProjectionBinding();
pb->BindingEntireProjection(catalog->getTable(0)->getProjectoin(0)->getPartitioner());
pb->BindingEntireProjection(catalog->getTable(1)->getProjectoin(0)->getPartitioner());
////scan////////
std::vector<unsigned> index_list_1;
index_list_1.push_back(0);
index_list_1.push_back(1);
index_list_1.push_back(3);
LogicalOperator* scan_1=new LogicalScan(table_1->getAttributes(index_list_1));
////////filter////////
int f=0;
FilterIterator::AttributeComparator filter1(column_type(t_int),Comparator::EQ,2,&f);
std::vector<FilterIterator::AttributeComparator> ComparatorList;
ComparatorList.push_back(filter1);
LogicalOperator* filter=new Filter(ComparatorList,scan_1);
////scan/////////
std::vector<unsigned> index_list_2;
index_list_2.push_back(0);
index_list_2.push_back(1);
index_list_2.push_back(3);
LogicalOperator* scan_2=new LogicalScan(table_2->getAttributes(index_list_2));
//////////////////
////Join////////
EqualJoin::JoinPair joinpair(table_1->getAttribute(3),table_2->getAttribute(3));
std::vector<EqualJoin::JoinPair> pair_list;
pair_list.push_back(joinpair);
LogicalOperator* join=new EqualJoin(pair_list,filter,scan_2);
Dataflow final_dataflow=join->getDataflow();
printf("Total communication cost: %d\n",final_dataflow.property_.commnication_cost);
printf("Waiting~\n");
while(true){
sleep(1);
}
}
int main(void) {
loggerInit();
PortAudioClass pa;
SignalBlock sb;
FilterBlock fb;
fb.initialize();
// Global setup
int num_inputs = 2;
int num_outputs = 2;
EXEC_MODE mode = SWEEP;
int num_taps = 4800;
std::vector<float> filter1(num_taps,0.f);
filter1.at(0) = 1.f;
std::vector<float> filter2(num_taps,0.f);
filter2.at(0) = 1.f;
fb.setFilterLen(num_taps);
fb.setNumInAndOutputs(num_inputs,num_outputs);
//readFile("responseL.txt", filter1);
//readFile("responseR.txt", filter2);
for(int i = 0; i < num_taps; i++)
std::cout<<filter1.at(i)<<std::endl;
fb.setFilterTaps(0,0, filter1);
fb.setFilterTaps(0,1, filter2);
//fb.setFilterTaps(1,1, filter2);
//fb.setFilterTaps(1,0, filter2);
fb.setFrameLen(256);
fb.setMode(mode);
fb.initialize();
pa.setFramesPerBuffer(256);
pa.initialize();
//for(int i = 0; i < pa.getNumberOfDevices(); i++)
// pa.printDeviceInfo(i);
// Currently fastrack is at index 3
// Soundflower 16 is index 5
// port audio setup
pa.setCurrentDevice(3);
pa.setNumInputChannels(num_inputs);
pa.setNumOutputChannels(num_outputs);
pa.setFs(48e3);
// sweep parameters
if(mode == SWEEP) {
// this is for the sweep, one pair at a time
pa.setCurrentOutputChannel(0);
pa.setCurrentInputChannel(0);
sb.setFs(48e3);
sb.setFBegin(1);
sb.setFEnd(20000);
sb.setLength(6);
pa.output_data_ = sb.getSweep();
CallbackStruct sweep = pa.setupSweepCallbackBlock();
pa.setCallbackData((void*)&sweep);
pa.setCallback(playRecCallback);
}
if(mode < SWEEP) {
log_msg<LOG_INFO>(L"main - Convoltuion processing: %s")%mode_texts[(int)mode];
pa.setCallbackData((void*)(&fb));
pa.setCallback(convolutionCallback);
}
pa.openStream();
pa.startStream();
sleep(sb.getLength());
pa.closeStream();
pa.terminate();
if(mode == SWEEP) {
std::vector<float> ir = sb.getRawIr(pa.getOutputData(),
pa.getInputBuffer());
writeFile("response1.txt", pa.getOutputData(), pa.getInputBuffer(), ir);
}
return 0;
}
void run_filter_set(
input_filter<t1>& i_filter,
middle_filter<t1,t2>& m_filter,
output_filter<t2>& o_filter,
mode_array *filter_type,
final_assert_type my_t) {
tbb::filter_t<void, t1> filter1( filter_type[0], i_filter );
tbb::filter_t<t1, t2> filter2( filter_type[1], m_filter );
tbb::filter_t<t2, void> filter3( filter_type[2], o_filter );
ASSERT(filter_node_count==3, "some filter nodes left after previous iteration?");
resetCounters();
// Create filters sequence when parallel_pipeline() is being run
tbb::parallel_pipeline( n_tokens, filter1 & filter2 & filter3 );
checkCounters(my_t);
// Create filters sequence partially outside parallel_pipeline() and also when parallel_pipeline() is being run
tbb::filter_t<void, t2> filter12;
filter12 = filter1 & filter2;
resetCounters();
tbb::parallel_pipeline( n_tokens, filter12 & filter3 );
checkCounters(my_t);
tbb::filter_t<void, void> filter123 = filter12 & filter3;
// Run pipeline twice with the same filter sequence
for( unsigned i = 0; i<2; i++ ) {
resetCounters();
tbb::parallel_pipeline( n_tokens, filter123 );
checkCounters(my_t);
}
// Now copy-construct another filter_t instance, and use it to run pipeline
{
tbb::filter_t<void, void> copy123( filter123 );
resetCounters();
tbb::parallel_pipeline( n_tokens, copy123 );
checkCounters(my_t);
}
// Construct filters and create the sequence when parallel_pipeline() is being run
resetCounters();
tbb::parallel_pipeline( n_tokens,
tbb::make_filter<void, t1>(filter_type[0], i_filter) &
tbb::make_filter<t1, t2>(filter_type[1], m_filter) &
tbb::make_filter<t2, void>(filter_type[2], o_filter) );
checkCounters(my_t);
// Construct filters, make a copy, destroy the original filters, and run with the copy
int cnt = filter_node_count;
{
tbb::filter_t<void, void>* p123 = new tbb::filter_t<void,void> (
tbb::make_filter<void, t1>(filter_type[0], i_filter) &
tbb::make_filter<t1, t2>(filter_type[1], m_filter) &
tbb::make_filter<t2, void>(filter_type[2], o_filter) );
ASSERT(filter_node_count==cnt+5, "filter node accounting error?");
tbb::filter_t<void, void> copy123( *p123 );
delete p123;
ASSERT(filter_node_count==cnt+5, "filter nodes deleted prematurely?");
resetCounters();
tbb::parallel_pipeline( n_tokens, copy123 );
checkCounters(my_t);
}
// construct a filter with temporaries
{
tbb::filter_t<void, void> my_filter;
fill_chain<t1,t2>( my_filter, filter_type, i_filter, m_filter, o_filter );
resetCounters();
tbb::parallel_pipeline( n_tokens, my_filter );
checkCounters(my_t);
}
ASSERT(filter_node_count==cnt, "scope ended but filter nodes not deleted?");
}
/*
* the test is like root iterator is PrintIterator, the left child and right child is FilterIterator,
* between the PrintIterator and FilterIterator is the ExchangeIterator, and the child of FilterIterator
* is ScanIterator, and Between is the ExchangeIterator.
* */
int mainasf3234(int argc,char* argv[])
{
int choice=0;
int block_size=2048+2*sizeof(unsigned);
printf("Master(0) or Slave(1) ?\n");
choice=0;
scanf("%d",&choice);
if(choice==0)
{
std::cout<<"Environment initializing!"<<std::endl;
Environment::getInstance(true);
std::vector<std::string> upper_ip_list;
std::vector<std::string> lower_ip_list;
///////////////////////////////////////////Scan////////////////////////////////////////|
std::vector<column_type> column_list;
column_list.push_back(column_type(t_int));
Schema* input=new SchemaFix(column_list);
Schema* output=new SchemaFix(column_list);
//SingleColumnScanIterator::State SCstate1("/home/imdb/temp/1_0.column_copy",input, output);
SingleColumnScanIterator::State SCstate1("/home/imdb/temp/1_0.column.400k",input,output);
// SingleColumnScanIterator::State SCstate1("/home/imdb/temp/Uniform_0_99.column",input,output);
Iterator* scs1=new SingleColumnScanIterator(SCstate1);
///////////////////////////////////////////Exchange////////////////////////////////////|
upper_ip_list.push_back("10.11.1.204");
upper_ip_list.push_back("10.11.1.205");
lower_ip_list.push_back("10.11.1.206");
lower_ip_list.push_back("10.11.1.207");
const unsigned long long int exchange_id_1=1;
ExchangeIteratorEager::State EIstate(input,scs1,block_size,lower_ip_list,upper_ip_list,exchange_id_1);
Iterator* ei=new ExchangeIteratorEager(EIstate);
///////////////////////////////////////Filter//////////////////////////////////////////|
FilterIterator::State FIstate;
FIstate.child=ei;
FIstate.input=output;
FIstate.output=output;
int f=0;
FilterIterator::AttributeComparator filter1(column_type(t_int),Comparator::GEQ,0,&f);
FIstate.ComparatorList.push_back(filter1);
Iterator* fi=new FilterIterator(FIstate);
///////////////////////////////////////////Exchange////////////////////////////////////|
upper_ip_list.clear();
lower_ip_list.clear();
upper_ip_list.push_back("10.11.1.208");
lower_ip_list.push_back("10.11.1.204");
lower_ip_list.push_back("10.11.1.205");
const unsigned long long int exchange_id_0=0;
// ExchangeIteratorEager::State EIstate_(output,fi,block_size,lower_ip_list,upper_ip_list,exchange_id_0);
ExchangeIteratorEager::State EIstate_(output,scs1,block_size,lower_ip_list,upper_ip_list,exchange_id_0);
Iterator* ei_=new ExchangeIteratorEager(EIstate_);
///////////////////////////////////////Print///////////////////////////////////////////|
PrintIterator::State PIstate(output,ei_);
Iterator *pi=new PrintIterator(PIstate);
//-------------------------------------------------------------------------------------|
//IteratorExecutorMaster IEM;
int d;
printf("Enter 1 to continue, other number to stop.\n");
scanf("%d",&d);
int printcount=0;
while(d==1)
{
cout<<"in the Exchange test"<<endl;
pi->open();
cout<<"in the Exchange test and already pass the open func"<<endl;
while(pi->next(0))
printcount++;
cout<<"total number:"<<printcount<<endl;
pi->close();
getchar();
scanf("%d",&d);
}
}
else
{
Environment::getInstance(false);
//IteratorExecutorSlave IES;
}
printf("Go to sleep while!\n");
while(1)
{
sleep(1);
}
return 1;
}
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);
}
}
