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;
