void* test(void* thread) { thread_data_t* td = (thread_data_t*) thread; uint8_t ID = td->id; // unsigned int ID=td->id; // cout<<ID<<"##################"<<endl; int phys_id = the_cores[ID]; cout << phys_id << "&&&&&&&&&&&&&" << endl; // int phys_id=0; set_cpu(phys_id); ssalloc_init(); PF_INIT(3, SSPFD_NUM_ENTRIES, ID); #if defined(COMPUTE_LATENCY) volatile ticks my_putting_succ = 0; volatile ticks my_putting_fail = 0; volatile ticks my_getting_succ = 0; volatile ticks my_getting_fail = 0; volatile ticks my_removing_succ = 0; volatile ticks my_removing_fail = 0; #endif uint64_t my_putting_count = 0; uint64_t my_getting_count = 0; uint64_t my_removing_count = 0; uint64_t my_putting_count_succ = 0; uint64_t my_getting_count_succ = 0; uint64_t my_removing_count_succ = 0; #if defined(COMPUTE_LATENCY) && PFD_TYPE == 0 volatile ticks start_acq, end_acq; volatile ticks correction = getticks_correction_calc(); #endif seeds = seed_rand(); #if GC == 1 #endif RR_INIT(phys_id); // uint64_t key; // // uint32_t c = 0; // uint32_t scale_rem = (uint32_t) (update_rate * UINT_MAX); // uint32_t scale_put = (uint32_t) (put_rate * UINT_MAX); // unsigned int i; // uint32_t num_elems_thread = (uint32_t) (initial / num_threads); // int32_t missing = (uint32_t) initial - (num_elems_thread * num_threads); // if (ID < missing) { // num_elems_thread++; // } // //#if INITIALIZE_FROM_ONE == 1 // num_elems_thread = (ID == 0) * initial; //#endif // // for (i = 0; i < num_elems_thread; i++) { // key = // (my_random(&(seeds[0]), &(seeds[1]), &(seeds[2])) // % (rand_max + 1)) + rand_min; // //// IntTable::accessor a; // if (DS_ADD(mset, key, key) == false) { // i--; // } // }MEM_BARRIER; // // barrier_cross(&barrier); // // if (!ID) { // printf("#BEFORE size is: %zu\n", (size_t) DS_SIZE(mset)); // } //****start******* int state; int state2; int curr_counter; int _threadNo; int _i_start_suc_rand; int _i_end_suc_rand; int _i_start_unsuc_rand; int _i_end_unsuc_rand; int _num_add; int _num_remove; int _num_contain; _u64 volatile seed = Random::getSeed(); _threadNo = _threadCounter.getAndIncrement(); int num_actions = (int) ((initial) / num_threads); _i_start_suc_rand = _threadNo * num_actions; _i_end_suc_rand = _i_start_suc_rand + num_actions; _i_start_unsuc_rand = _i_start_suc_rand + maxhtlength; _i_end_unsuc_rand = _i_end_suc_rand + maxhtlength; _num_add = ((update) / 2); _num_remove = ((update) / 2); _num_contain = 100 - _num_add - _num_remove; state = (Random::getRandom(seed, 1023)) & 1; state2 = (Random::getRandom(seed, 1023)) & 1; curr_counter = _num_add; if (1 == state2) curr_counter = _num_contain; unsigned int action_counter = 0; int i_suc = _i_start_unsuc_rand; int i_unsuc = _i_start_unsuc_rand; //**********end*******************8 barrier_cross(&barrier_global); RR_START_SIMPLE(); cout<<"$$$ "<<_threadNo<<endl; while (stop == 0) { // cout<<state<<"\t\t"<<state2<<endl; if (0 == state) { if (0 == state2) { if (curr_counter > 0) { int res; int removed; // _gTestDs->remove(_gRandNumAry[i_suc]); // _gTestDs->put(_gRandNumAry[i_unsuc], _gRandNumAry[i_unsuc]); START_TS(2); removed = DS_REMOVE(mset, _gRandNumAry[i_suc]); if (removed) { END_TS(2, my_removing_count_succ);ADD_DUR(my_removing_succ); my_removing_count_succ++; }END_TS_ELSE(5, my_removing_count - my_removing_count_succ, my_removing_fail); my_removing_count++; START_TS(1); res = DS_ADD(mset, _gRandNumAry[i_unsuc], _gRandNumAry[i_unsuc]); if (res) { // a->second = key; END_TS(1, my_putting_count_succ);ADD_DUR(my_putting_succ); my_putting_count_succ++; }END_TS_ELSE(4, my_putting_count - my_putting_count_succ, my_putting_fail); // action_counter+=2; my_putting_count++; ++i_suc; ++i_unsuc; if (i_suc >= _i_end_suc_rand) { state = 1; i_suc = _i_start_suc_rand; i_unsuc = _i_start_unsuc_rand; } } --curr_counter; if (curr_counter <= 0) { state2 = 1; curr_counter = _num_contain; } } else { // bool b1,b2; // b1=_gTestDs->containsKey(_gRandNumAry[i_suc]); // b2=_gTestDs->containsKey(_gRandNumAry[i_unsuc]); int res; START_TS(0); res = DS_CONTAINS(mset, _gRandNumAry[i_suc]) ;END_TS(0, my_getting_count); if (res != 0) { END_TS(0, my_getting_count_succ);ADD_DUR(my_getting_succ); my_getting_count_succ++; }END_TS_ELSE(3, my_getting_count - my_getting_count_succ, my_getting_fail); my_getting_count++; START_TS(0); res = DS_CONTAINS(mset, _gRandNumAry[i_unsuc]) ; // action_counter+=2; END_TS(0, my_getting_count); if (res != 0) { END_TS(0, my_getting_count_succ);ADD_DUR(my_getting_succ); my_getting_count_succ++; }END_TS_ELSE(3, my_getting_count - my_getting_count_succ, my_getting_fail); my_getting_count++; ++i_suc; ++i_unsuc; if (i_suc >= _i_end_suc_rand) { state = 1; i_suc = _i_start_suc_rand; i_unsuc = _i_start_unsuc_rand; } --curr_counter; if (curr_counter <= 0) { state2 = 0; curr_counter = _num_add; } } } else if (1 == state) { if (0 == state2) { if (curr_counter > 0) { // _gTestDs->put(_gRandNumAry[i_suc], _gRandNumAry[i_suc]); // _gTestDs->remove(_gRandNumAry[i_unsuc]); int res; int removed; // DS_ADD(mset, _gRandNumAry[i_suc], _gRandNumAry[i_suc]); // DS_REMOVE(mset, _gRandNumAry[i_unsuc]); // action_counter+=2; START_TS(1); res = DS_ADD(mset, _gRandNumAry[i_suc], _gRandNumAry[i_suc]); if (res) { // a->second = key; END_TS(1, my_putting_count_succ);ADD_DUR(my_putting_succ); my_putting_count_succ++; }END_TS_ELSE(4, my_putting_count - my_putting_count_succ, my_putting_fail); // action_counter+=2; my_putting_count++; // _gTestDs->remove(_gRandNumAry[i_suc]); // _gTestDs->put(_gRandNumAry[i_unsuc], _gRandNumAry[i_unsuc]); START_TS(2); removed = DS_REMOVE(mset, _gRandNumAry[i_unsuc]); if (removed) { END_TS(2, my_removing_count_succ);ADD_DUR(my_removing_succ); my_removing_count_succ++; }END_TS_ELSE(5, my_removing_count - my_removing_count_succ, my_removing_fail); my_removing_count++; ++i_suc; ++i_unsuc; if (i_suc >= _i_end_suc_rand) { state = 0; i_suc = _i_start_suc_rand; i_unsuc = _i_start_unsuc_rand; } } --curr_counter; if (curr_counter <= 0) { state2 = 1; curr_counter = _num_contain; } } else { // bool b1,b2; // b1=_gTestDs->containsKey(_gRandNumAry[i_suc]); // b2=_gTestDs->containsKey(_gRandNumAry[i_unsuc]); // action_counter+=2; int res; START_TS(0); res = DS_CONTAINS(mset, _gRandNumAry[i_suc]) ;END_TS(0, my_getting_count); if (res != 0) { END_TS(0, my_getting_count_succ);ADD_DUR(my_getting_succ); my_getting_count_succ++; }END_TS_ELSE(3, my_getting_count - my_getting_count_succ, my_getting_fail); my_getting_count++; START_TS(0); res = DS_CONTAINS(mset, _gRandNumAry[i_unsuc]) ; // action_counter+=2; END_TS(0, my_getting_count); if (res != 0) { END_TS(0, my_getting_count_succ);ADD_DUR(my_getting_succ); my_getting_count_succ++; }END_TS_ELSE(3, my_getting_count - my_getting_count_succ, my_getting_fail); my_getting_count++; ++i_suc; ++i_unsuc; if (i_suc >= _i_end_suc_rand) { state = 0; i_suc = _i_start_suc_rand; i_unsuc = _i_start_unsuc_rand; } --curr_counter; if (curr_counter <= 0) { state2 = 0; curr_counter = _num_add; } } } } barrier_cross(&barrier); RR_STOP_SIMPLE(); if (!ID) { size_after = DS_SIZE(mset); printf("#AFTER size is: %zu\n", size_after); } barrier_cross(&barrier); #if defined(COMPUTE_LATENCY) putting_succ[ID] += my_putting_succ; putting_fail[ID] += my_putting_fail; getting_succ[ID] += my_getting_succ; getting_fail[ID] += my_getting_fail; removing_succ[ID] += my_removing_succ; removing_fail[ID] += my_removing_fail; #endif putting_count[ID] += my_putting_count; getting_count[ID] += my_getting_count; removing_count[ID] += my_removing_count; putting_count_succ[ID] += my_putting_count_succ; getting_count_succ[ID] += my_getting_count_succ; removing_count_succ[ID] += my_removing_count_succ; EXEC_IN_DEC_ID_ORDER(ID, num_threads) { print_latency_stats(ID, SSPFD_NUM_ENTRIES, print_vals_num); }EXEC_IN_DEC_ID_ORDER_END(&barrier);
static Random _gRand; static int _gActionAry[_ACTIONS_ARY_SIZE]; static int _gTotalRandNum; static int _g_thread_fill_table_size; static int* _gRandNumAry; static tick_t volatile * _gThreadResultAry; static int _gNumProcessors; int _gNumThreads; int _gIsDedicatedMode; static int _gThroughputTime; static Thread** _gThreads; static AtomicInteger _gThreadStartCounter(0); static AtomicInteger _gThreadEndCounter(0); static VolatileType<tick_t> _gStartTime(U64(0)); static VolatileType<tick_t> _gEndTime(U64(0)); char _pad1[64]; volatile int _gIsStopThreads(U64(0)); char _pad2[64]; static tick_t _gResult = 0L; static tick_t _gResultAdd = 0L; static tick_t _gResultRemove = 0L; static tick_t _gResultPeek = 0L; static _u64 volatile _seed; static boolean _is_tm=false;