pd.if.org Git - liblfds/blob - liblfds/liblfds7.1.0/test_and_benchmark/libbenchmark/src/libbenchmark_benchmarks_btree_au_readn_writen/libbenchmark_benchmarks_btree_au_liblfds700_lockfree_readn_writen.c

   1 /***** includes *****/
   2 #include "libbenchmark_benchmarks_btree_au_internal.h"
   3
   4 /***** structs *****/
   5 struct libbenchmark_benchmark_btree_au_liblfds700_lockfree_readn_writen_benchmark_element
   6 {
   7   lfds710_pal_uint_t
   8     datum;
   9
  10   struct lfds700_btree_au_element
  11     be;
  12 };
  13
  14 struct libbenchmark_benchmark_btree_au_liblfds700_lockfree_readn_writen_per_thread_benchmark_state
  15 {
  16   lfds710_pal_uint_t
  17     operation_count,
  18     per_thread_prng_seed;
  19 };
  20
  21 struct libbenchmark_benchmark_btree_au_liblfds700_lockfree_readn_writen_per_numa_benchmark_state
  22 {
  23   lfds710_pal_uint_t
  24     *element_key_array,
  25     number_element_keys;
  26
  27   struct libbenchmark_benchmark_btree_au_liblfds700_lockfree_readn_writen_benchmark_element
  28     *bme;
  29
  30   struct lfds700_btree_au_state
  31     *bs;
  32 };
  33
  34 struct libbenchmark_benchmark_btree_au_liblfds700_lockfree_readn_writen_overall_benchmark_state
  35 {
  36   enum libbenchmark_topology_numa_mode
  37     numa_mode;
  38
  39   lfds710_pal_uint_t
  40     *element_key_array,
  41     number_element_keys;
  42
  43   struct libbenchmark_benchmark_btree_au_liblfds700_lockfree_readn_writen_benchmark_element
  44     *bme;
  45
  46   struct lfds700_btree_au_state
  47     *bs;
  48 };
  49
  50 /***** private prototypes *****/
  51 static int key_compare_function( void const *new_key, void const *existing_key );
  52
  53
  54
  55
  56
  57 /****************************************************************************/
  58 void libbenchmark_benchmark_btree_au_liblfds700_lockfree_readn_writen_init( struct libbenchmark_topology_state *ts,
  59                                                                             struct lfds710_list_aso_state *logical_processor_set,
  60                                                                             struct libshared_memory_state *ms,
  61                                                                             enum libbenchmark_topology_numa_mode numa_mode,
  62                                                                             struct libbenchmark_threadset_state *tsets )
  63 {
  64   enum lfds700_btree_au_insert_result
  65     ir;
  66
  67   struct lfds700_misc_prng_state
  68     lfds700_ps;
  69
  70   lfds710_pal_uint_t
  71     index = 0,
  72     loop,
  73     number_logical_processors,
  74     number_benchmark_elements,
  75     number_logical_processors_in_numa_node,
  76     largest_number_logical_processors_in_numa_node = 0,
  77     total_number_benchmark_elements;
  78
  79   struct lfds710_list_asu_element
  80     *lasue = NULL,
  81     *lasue_lp;
  82
  83   struct libbenchmark_benchmark_btree_au_liblfds700_lockfree_readn_writen_overall_benchmark_state
  84     *obs;
  85
  86   struct libbenchmark_benchmark_btree_au_liblfds700_lockfree_readn_writen_per_numa_benchmark_state
  87     *ptns;
  88
  89   struct libbenchmark_benchmark_btree_au_liblfds700_lockfree_readn_writen_per_thread_benchmark_state
  90     *ptbs;
  91
  92   struct lfds700_btree_au_state
  93     *bs = NULL;
  94
  95   struct libbenchmark_prng_state
  96     ps;
  97
  98   struct libbenchmark_threadset_per_numa_state
  99     *pns,
 100     *largest_pns = NULL;
 101
 102   struct libbenchmark_threadset_per_thread_state
 103     *pts;
 104
 105   struct libbenchmark_topology_node_state
 106     *numa_node_for_lp;
 107
 108   LFDS710_PAL_ASSERT( ts != NULL );
 109   LFDS710_PAL_ASSERT( logical_processor_set != NULL );
 110   LFDS710_PAL_ASSERT( ms != NULL );
 111   // TRD : numa_mode can be any value in its range
 112   LFDS710_PAL_ASSERT( tsets != NULL );
 113
 114   lfds700_misc_prng_init( &lfds700_ps );
 115
 116   lfds710_list_aso_query( logical_processor_set, LFDS710_LIST_ASO_QUERY_GET_POTENTIALLY_INACCURATE_COUNT, NULL, (void *) &number_logical_processors );
 117
 118   libbenchmark_threadset_init( tsets, ts, logical_processor_set, ms, libbenchmark_benchmark_btree_au_liblfds700_lockfree_readn_writen_thread, NULL );
 119
 120   total_number_benchmark_elements = number_logical_processors * 1024;
 121
 122   obs = libshared_memory_alloc_from_most_free_space_node( ms, sizeof(struct libbenchmark_benchmark_btree_au_liblfds700_lockfree_readn_writen_overall_benchmark_state), LFDS710_PAL_ATOMIC_ISOLATION_IN_BYTES );
 123
 124   LIBBENCHMARK_PRNG_INIT( ps, LFDS710_PRNG_SEED );
 125
 126   switch( numa_mode )
 127   {
 128     case LIBBENCHMARK_TOPOLOGY_NUMA_MODE_SMP:
 129       bs = libshared_memory_alloc_from_most_free_space_node( ms, sizeof(struct lfds700_btree_au_state), LFDS700_PAL_ATOMIC_ISOLATION_IN_BYTES );
 130       lfds700_btree_au_init_valid_on_current_logical_core( bs, key_compare_function, LIBBENCHMARK_DATASTRUCTURE_BTREE_AU_GCC_SPINLOCK_ATOMIC_EXISTING_KEY_FAIL, NULL );
 131
 132       obs->bme = libshared_memory_alloc_from_most_free_space_node( ms, sizeof(struct libbenchmark_benchmark_btree_au_liblfds700_lockfree_readn_writen_benchmark_element) * total_number_benchmark_elements, LFDS700_PAL_ATOMIC_ISOLATION_IN_BYTES );
 133       obs->element_key_array = libshared_memory_alloc_from_most_free_space_node( ms, sizeof(lfds710_pal_uint_t) * total_number_benchmark_elements, sizeof(lfds710_pal_uint_t) );
 134
 135       for( loop = 0 ; loop < total_number_benchmark_elements ; loop++ )
 136         do
 137         {
 138           LIBBENCHMARK_PRNG_GENERATE( ps, obs->bme[loop].datum );
 139           obs->element_key_array[loop] = obs->bme[loop].datum;
 140
 141           LFDS700_BTREE_AU_SET_KEY_IN_ELEMENT( obs->bme[loop].be, &obs->bme[loop] );
 142           LFDS700_BTREE_AU_SET_VALUE_IN_ELEMENT( obs->bme[loop].be, &obs->bme[loop] );
 143           ir = lfds700_btree_au_insert( bs, &obs->bme[loop].be, NULL, &lfds700_ps );
 144         }
 145         while( ir == LFDS700_BTREE_AU_INSERT_RESULT_FAILURE_EXISTING_KEY );
 146
 147       lasue = NULL;
 148
 149       while( LFDS710_LIST_ASU_GET_START_AND_THEN_NEXT(tsets->list_of_per_thread_states,lasue) )
 150       {
 151         pts = LFDS710_LIST_ASU_GET_VALUE_FROM_ELEMENT( *lasue );
 152         ptbs = libshared_memory_alloc_from_most_free_space_node( ms, sizeof(struct libbenchmark_benchmark_btree_au_liblfds700_lockfree_readn_writen_per_thread_benchmark_state), LFDS710_PAL_ATOMIC_ISOLATION_IN_BYTES );
 153         LIBBENCHMARK_PRNG_GENERATE( ps, ptbs->per_thread_prng_seed );
 154         pts->users_per_thread_state = ptbs;
 155       }
 156     break;
 157
 158     case LIBBENCHMARK_TOPOLOGY_NUMA_MODE_NUMA:
 159       while( LFDS710_LIST_ASU_GET_START_AND_THEN_NEXT(tsets->list_of_per_numa_states,lasue) )
 160       {
 161         pns = LFDS710_LIST_ASU_GET_VALUE_FROM_ELEMENT( *lasue );
 162
 163         lasue_lp = NULL;
 164         number_logical_processors_in_numa_node = 0;
 165
 166         while( LFDS710_LIST_ASU_GET_START_AND_THEN_NEXT(tsets->list_of_per_thread_states,lasue_lp) )
 167         {
 168           pts = LFDS710_LIST_ASU_GET_VALUE_FROM_ELEMENT( *lasue_lp );
 169
 170           libbenchmark_topology_query( ts, LIBBENCHMARK_TOPOLOGY_QUERY_GET_NUMA_NODE_FOR_LOGICAL_PROCESSOR, pts->tns_lp, &numa_node_for_lp );
 171
 172           if( LIBBENCHMARK_TOPOLOGY_NODE_GET_NUMA_ID(*numa_node_for_lp) == pns->numa_node_id )
 173             number_logical_processors_in_numa_node++;
 174         }
 175
 176         if( number_logical_processors_in_numa_node > largest_number_logical_processors_in_numa_node )
 177           largest_pns = pns;
 178       }
 179
 180       bs = libshared_memory_alloc_from_specific_node( ms, largest_pns->numa_node_id, sizeof(struct lfds700_btree_au_state), LFDS700_PAL_ATOMIC_ISOLATION_IN_BYTES );
 181       lfds700_btree_au_init_valid_on_current_logical_core( bs, key_compare_function, LFDS700_BTREE_AU_EXISTING_KEY_FAIL, NULL );
 182
 183       obs->element_key_array = libshared_memory_alloc_from_most_free_space_node( ms, sizeof(lfds710_pal_uint_t) * total_number_benchmark_elements, sizeof(lfds710_pal_uint_t) );
 184
 185       lasue = NULL;
 186
 187       while( LFDS710_LIST_ASU_GET_START_AND_THEN_NEXT(tsets->list_of_per_numa_states,lasue) )
 188       {
 189         pns = LFDS710_LIST_ASU_GET_VALUE_FROM_ELEMENT( *lasue );
 190
 191         /* TRD : for each NUMA node, figure out how many LPs in the current set are in that NUMA node
 192                  and allocate then the correct number of elements from this NUMA node (1024 per LP)
 193         */
 194
 195         lasue_lp = NULL;
 196         number_logical_processors_in_numa_node = 0;
 197
 198         while( LFDS710_LIST_ASU_GET_START_AND_THEN_NEXT(tsets->list_of_per_thread_states,lasue_lp) )
 199         {
 200           pts = LFDS710_LIST_ASU_GET_VALUE_FROM_ELEMENT( *lasue_lp );
 201
 202           libbenchmark_topology_query( ts, LIBBENCHMARK_TOPOLOGY_QUERY_GET_NUMA_NODE_FOR_LOGICAL_PROCESSOR, pts->tns_lp, &numa_node_for_lp );
 203
 204           if( LIBBENCHMARK_TOPOLOGY_NODE_GET_NUMA_ID(*numa_node_for_lp) == pns->numa_node_id )
 205             number_logical_processors_in_numa_node++;
 206         }
 207
 208         number_benchmark_elements = number_logical_processors_in_numa_node * 1024;
 209
 210         ptns = libshared_memory_alloc_from_specific_node( ms, pns->numa_node_id, sizeof(struct libbenchmark_benchmark_btree_au_liblfds700_lockfree_readn_writen_per_numa_benchmark_state), LFDS710_PAL_ATOMIC_ISOLATION_IN_BYTES );
 211         ptns->element_key_array = libshared_memory_alloc_from_specific_node( ms, pns->numa_node_id, sizeof(lfds710_pal_uint_t) * total_number_benchmark_elements, sizeof(lfds710_pal_uint_t) );
 212         ptns->number_element_keys = total_number_benchmark_elements;
 213
 214         ptns->bme = libshared_memory_alloc_from_specific_node( ms, pns->numa_node_id, sizeof(struct libbenchmark_benchmark_btree_au_liblfds700_lockfree_readn_writen_benchmark_element) * number_benchmark_elements, LFDS700_PAL_ATOMIC_ISOLATION_IN_BYTES );
 215
 216         for( loop = 0 ; loop < number_benchmark_elements ; loop++, index++ )
 217           do
 218           {
 219             LIBBENCHMARK_PRNG_GENERATE( ps, ptns->bme[loop].datum );
 220             obs->element_key_array[index] = ptns->bme[loop].datum;
 221
 222             LFDS700_BTREE_AU_SET_KEY_IN_ELEMENT( ptns->bme[loop].be, &ptns->bme[loop] );
 223             LFDS700_BTREE_AU_SET_VALUE_IN_ELEMENT( ptns->bme[loop].be, &ptns->bme[loop] );
 224             ir = lfds700_btree_au_insert( bs, &ptns->bme[loop].be, NULL, &lfds700_ps );
 225           }
 226           while( ir == LFDS700_BTREE_AU_INSERT_RESULT_FAILURE_EXISTING_KEY );
 227
 228         pns->users_per_numa_state = ptns;
 229       }
 230
 231       // TRD : now copy over into each NUMA node state the element_key_array
 232       lasue = NULL;
 233
 234       while( LFDS710_LIST_ASU_GET_START_AND_THEN_NEXT(tsets->list_of_per_numa_states,lasue) )
 235       {
 236         pns = LFDS710_LIST_ASU_GET_VALUE_FROM_ELEMENT( *lasue );
 237         ptns = pns->users_per_numa_state;
 238
 239         for( loop = 0 ; loop < total_number_benchmark_elements ; loop++ )
 240           ptns->element_key_array[loop] = obs->element_key_array[loop];
 241       }
 242
 243       lasue = NULL;
 244
 245       while( LFDS710_LIST_ASU_GET_START_AND_THEN_NEXT(tsets->list_of_per_thread_states,lasue) )
 246       {
 247         pts = LFDS710_LIST_ASU_GET_VALUE_FROM_ELEMENT( *lasue );
 248         ptbs = libshared_memory_alloc_from_most_free_space_node( ms, sizeof(struct libbenchmark_benchmark_btree_au_liblfds700_lockfree_readn_writen_per_thread_benchmark_state), LFDS710_PAL_ATOMIC_ISOLATION_IN_BYTES );
 249         LIBBENCHMARK_PRNG_GENERATE( ps, ptbs->per_thread_prng_seed );
 250         LIBBENCHMARK_PRNG_MURMURHASH3_MIXING_FUNCTION( ptbs->per_thread_prng_seed );
 251         pts->users_per_thread_state = ptbs;
 252       }
 253     break;
 254
 255     case LIBBENCHMARK_TOPOLOGY_NUMA_MODE_NUMA_BUT_NOT_USED:
 256       while( LFDS710_LIST_ASU_GET_START_AND_THEN_NEXT(tsets->list_of_per_numa_states,lasue) )
 257       {
 258         pns = LFDS710_LIST_ASU_GET_VALUE_FROM_ELEMENT( *lasue );
 259
 260         lasue_lp = NULL;
 261         number_logical_processors_in_numa_node = 0;
 262
 263         while( LFDS710_LIST_ASU_GET_START_AND_THEN_NEXT(tsets->list_of_per_thread_states,lasue_lp) )
 264         {
 265           pts = LFDS710_LIST_ASU_GET_VALUE_FROM_ELEMENT( *lasue_lp );
 266
 267           libbenchmark_topology_query( ts, LIBBENCHMARK_TOPOLOGY_QUERY_GET_NUMA_NODE_FOR_LOGICAL_PROCESSOR, pts->tns_lp, &numa_node_for_lp );
 268
 269           if( LIBBENCHMARK_TOPOLOGY_NODE_GET_NUMA_ID(*numa_node_for_lp) == pns->numa_node_id )
 270             number_logical_processors_in_numa_node++;
 271         }
 272
 273         if( number_logical_processors_in_numa_node > largest_number_logical_processors_in_numa_node )
 274           largest_pns = pns;
 275       }
 276
 277       bs = libshared_memory_alloc_from_specific_node( ms, largest_pns->numa_node_id, sizeof(struct lfds700_btree_au_state), LFDS700_PAL_ATOMIC_ISOLATION_IN_BYTES );
 278       lfds700_btree_au_init_valid_on_current_logical_core( bs, key_compare_function, LFDS700_BTREE_AU_EXISTING_KEY_FAIL, NULL );
 279
 280       obs->element_key_array = libshared_memory_alloc_from_most_free_space_node( ms, sizeof(lfds710_pal_uint_t) * total_number_benchmark_elements, sizeof(lfds710_pal_uint_t) );
 281
 282       lasue = NULL;
 283
 284       while( LFDS710_LIST_ASU_GET_START_AND_THEN_NEXT(tsets->list_of_per_numa_states,lasue) )
 285       {
 286         pns = LFDS710_LIST_ASU_GET_VALUE_FROM_ELEMENT( *lasue );
 287
 288         /* TRD : for each NUMA node, figure out how many LPs in the current set are in that NUMA node
 289                  and allocate then the correct number of elements from this NUMA node (1024 per LP)
 290         */
 291
 292         lasue_lp = NULL;
 293         number_logical_processors_in_numa_node = 0;
 294
 295         while( LFDS710_LIST_ASU_GET_START_AND_THEN_NEXT(tsets->list_of_per_thread_states,lasue_lp) )
 296         {
 297           pts = LFDS710_LIST_ASU_GET_VALUE_FROM_ELEMENT( *lasue_lp );
 298
 299           libbenchmark_topology_query( ts, LIBBENCHMARK_TOPOLOGY_QUERY_GET_NUMA_NODE_FOR_LOGICAL_PROCESSOR, pts->tns_lp, &numa_node_for_lp );
 300
 301           if( LIBBENCHMARK_TOPOLOGY_NODE_GET_NUMA_ID(*numa_node_for_lp) == pns->numa_node_id )
 302             number_logical_processors_in_numa_node++;
 303         }
 304
 305         number_benchmark_elements = number_logical_processors_in_numa_node * 1024;
 306
 307         ptns = libshared_memory_alloc_from_specific_node( ms, pns->numa_node_id, sizeof(struct libbenchmark_benchmark_btree_au_liblfds700_lockfree_readn_writen_per_numa_benchmark_state), LFDS710_PAL_ATOMIC_ISOLATION_IN_BYTES );
 308         ptns->element_key_array = libshared_memory_alloc_from_specific_node( ms, pns->numa_node_id, sizeof(lfds710_pal_uint_t) * total_number_benchmark_elements, sizeof(lfds710_pal_uint_t) );
 309         ptns->number_element_keys = total_number_benchmark_elements;
 310
 311         // TRD : everyone stores their elements in the same NUMA node
 312         ptns->bme = libshared_memory_alloc_from_specific_node( ms, largest_pns->numa_node_id, sizeof(struct libbenchmark_benchmark_btree_au_liblfds700_lockfree_readn_writen_benchmark_element) * number_benchmark_elements, LFDS700_PAL_ATOMIC_ISOLATION_IN_BYTES );
 313
 314         for( loop = 0 ; loop < number_benchmark_elements ; loop++, index++ )
 315           do
 316           {
 317             LIBBENCHMARK_PRNG_GENERATE( ps, ptns->bme[loop].datum );
 318             obs->element_key_array[index] = ptns->bme[loop].datum;
 319
 320             LFDS700_BTREE_AU_SET_KEY_IN_ELEMENT( ptns->bme[loop].be, &ptns->bme[loop] );
 321             LFDS700_BTREE_AU_SET_VALUE_IN_ELEMENT( ptns->bme[loop].be, &ptns->bme[loop] );
 322             ir = lfds700_btree_au_insert( bs, &ptns->bme[loop].be, NULL, &lfds700_ps );
 323           }
 324           while( ir == LFDS700_BTREE_AU_INSERT_RESULT_FAILURE_EXISTING_KEY );
 325
 326         pns->users_per_numa_state = ptns;
 327       }
 328
 329       // TRD : now copy over into each NUMA node state the element_key_array
 330       lasue = NULL;
 331
 332       while( LFDS710_LIST_ASU_GET_START_AND_THEN_NEXT(tsets->list_of_per_numa_states,lasue) )
 333       {
 334         pns = LFDS710_LIST_ASU_GET_VALUE_FROM_ELEMENT( *lasue );
 335         ptns = pns->users_per_numa_state;
 336
 337         for( loop = 0 ; loop < total_number_benchmark_elements ; loop++ )
 338           ptns->element_key_array[loop] = obs->element_key_array[loop];
 339       }
 340
 341       lasue = NULL;
 342
 343       while( LFDS710_LIST_ASU_GET_START_AND_THEN_NEXT(tsets->list_of_per_thread_states,lasue) )
 344       {
 345         pts = LFDS710_LIST_ASU_GET_VALUE_FROM_ELEMENT( *lasue );
 346         ptbs = libshared_memory_alloc_from_most_free_space_node( ms, sizeof(struct libbenchmark_benchmark_btree_au_liblfds700_lockfree_readn_writen_per_thread_benchmark_state), LFDS710_PAL_ATOMIC_ISOLATION_IN_BYTES );
 347         LIBBENCHMARK_PRNG_GENERATE( ps, ptbs->per_thread_prng_seed );
 348         LIBBENCHMARK_PRNG_MURMURHASH3_MIXING_FUNCTION( ptbs->per_thread_prng_seed );
 349         pts->users_per_thread_state = ptbs;
 350       }
 351     break;
 352   }
 353
 354   obs->number_element_keys = total_number_benchmark_elements;
 355   obs->bs = bs;
 356   obs->numa_mode = numa_mode;
 357
 358   tsets->users_threadset_state = obs;
 359
 360   return;
 361 }
 362
 363
 364
 365
 366
 367 /****************************************************************************/
 368 libshared_pal_thread_return_t LIBSHARED_PAL_THREAD_CALLING_CONVENTION libbenchmark_benchmark_btree_au_liblfds700_lockfree_readn_writen_thread( void *libbenchmark_threadset_per_thread_state )
 369 {
 370   int long long unsigned
 371     current_time = 0,
 372     end_time,
 373     time_units_per_second;
 374
 375   lfds710_pal_uint_t
 376     *element_key_array = NULL,
 377     index,
 378     number_element_keys = 0,
 379     operation_count = 0,
 380     random_value,
 381     time_loop = 0;
 382
 383   struct libbenchmark_prng_state
 384     ps;
 385
 386   struct lfds700_btree_au_element
 387     *existing_be;
 388
 389   struct lfds700_btree_au_state
 390     *bs;
 391
 392   struct libbenchmark_benchmark_btree_au_liblfds700_lockfree_readn_writen_per_thread_benchmark_state
 393     *ptbs;
 394
 395   struct libbenchmark_benchmark_btree_au_liblfds700_lockfree_readn_writen_per_numa_benchmark_state
 396     *pnbs = NULL;
 397
 398   struct libbenchmark_benchmark_btree_au_liblfds700_lockfree_readn_writen_overall_benchmark_state
 399     *obs;
 400
 401   struct libbenchmark_threadset_per_thread_state
 402     *pts;
 403
 404   LFDS710_MISC_BARRIER_LOAD;
 405
 406   LFDS710_PAL_ASSERT( libbenchmark_threadset_per_thread_state != NULL );
 407
 408   pts = (struct libbenchmark_threadset_per_thread_state *) libbenchmark_threadset_per_thread_state;
 409
 410   ptbs = LIBBENCHMARK_THREADSET_PER_THREAD_STATE_GET_USERS_PER_THREAD_STATE( *pts );
 411   obs = LIBBENCHMARK_THREADSET_PER_THREAD_STATE_GET_USERS_OVERALL_STATE( *pts );
 412   if( obs->numa_mode == LIBBENCHMARK_TOPOLOGY_NUMA_MODE_NUMA or obs->numa_mode == LIBBENCHMARK_TOPOLOGY_NUMA_MODE_NUMA_BUT_NOT_USED )
 413     pnbs = LIBBENCHMARK_THREADSET_PER_THREAD_STATE_GET_USERS_PER_NUMA_STATE( *pts );
 414   bs = obs->bs;
 415
 416   LIBBENCHMARK_PRNG_INIT( ps, ptbs->per_thread_prng_seed );
 417
 418   LIBBENCHMARK_PAL_TIME_UNITS_PER_SECOND( &time_units_per_second );
 419
 420   switch( obs->numa_mode )
 421   {
 422     case LIBBENCHMARK_TOPOLOGY_NUMA_MODE_SMP:
 423       element_key_array = obs->element_key_array;
 424       number_element_keys = obs->number_element_keys;
 425     break;
 426
 427     case LIBBENCHMARK_TOPOLOGY_NUMA_MODE_NUMA:
 428       element_key_array = pnbs->element_key_array;
 429       number_element_keys = pnbs->number_element_keys;
 430     break;
 431
 432     case LIBBENCHMARK_TOPOLOGY_NUMA_MODE_NUMA_BUT_NOT_USED:
 433       element_key_array = pnbs->element_key_array;
 434       number_element_keys = pnbs->number_element_keys;
 435     break;
 436   }
 437
 438   libbenchmark_threadset_thread_ready_and_wait( pts );
 439
 440   LIBBENCHMARK_PAL_GET_HIGHRES_TIME( &current_time );
 441
 442   end_time = current_time + time_units_per_second * libbenchmark_globals_benchmark_duration_in_seconds;
 443
 444   while( current_time < end_time )
 445   {
 446     LIBBENCHMARK_PRNG_GENERATE( ps, random_value );
 447     index = random_value % number_element_keys;
 448
 449     // TRD : read
 450     lfds700_btree_au_get_by_key( bs, &element_key_array[index], &existing_be );
 451     // LFDS700_BTREE_AU_GET_VALUE_FROM_ELEMENT( benchmark_state->bs, *existing_be, datum );
 452
 453     LIBBENCHMARK_PRNG_GENERATE( ps, random_value );
 454     index = random_value % number_element_keys;
 455
 456     // TRD : write
 457     lfds700_btree_au_get_by_key( bs, &element_key_array[index], &existing_be );
 458     // LFDS700_BTREE_AU_SET_VALUE_IN_ELEMENT( benchmark_state->bs, *existing_be, benchmark_state->benchmark_element_array[index].datum );
 459
 460     operation_count++;
 461
 462     if( time_loop++ == TIME_LOOP_COUNT )
 463     {
 464       time_loop = 0;
 465       LIBBENCHMARK_PAL_GET_HIGHRES_TIME( &current_time );
 466     }
 467   }
 468
 469   ptbs->operation_count = operation_count;
 470
 471   LFDS710_MISC_BARRIER_STORE;
 472
 473   lfds710_misc_force_store();
 474
 475   return LIBSHARED_PAL_THREAD_RETURN_CAST(RETURN_SUCCESS);
 476 }
 477
 478
 479
 480
 481
 482 /****************************************************************************/
 483 void libbenchmark_benchmark_btree_au_liblfds700_lockfree_readn_writen_cleanup( struct lfds710_list_aso_state *logical_processor_set,
 484                                                                             enum libbenchmark_topology_numa_mode numa_mode,
 485                                                                             struct libbenchmark_results_state *rs,
 486                                                                             struct libbenchmark_threadset_state *tsets )
 487 {
 488   struct lfds710_list_asu_element
 489     *lasue = NULL;
 490
 491   struct libbenchmark_benchmark_btree_au_liblfds700_lockfree_readn_writen_overall_benchmark_state
 492     *obs;
 493
 494   struct libbenchmark_benchmark_btree_au_liblfds700_lockfree_readn_writen_per_thread_benchmark_state
 495     *ptbs;
 496
 497   struct libbenchmark_threadset_per_thread_state
 498     *pts;
 499
 500   LFDS710_PAL_ASSERT( logical_processor_set != NULL );
 501   // TRD : numa_mode can be any value in its range
 502   LFDS710_PAL_ASSERT( rs != NULL );
 503   LFDS710_PAL_ASSERT( tsets != NULL );
 504
 505   while( LFDS710_LIST_ASU_GET_START_AND_THEN_NEXT(tsets->list_of_per_thread_states,lasue) )
 506   {
 507     pts = LFDS710_LIST_ASU_GET_VALUE_FROM_ELEMENT( *lasue );
 508
 509     ptbs = LIBBENCHMARK_THREADSET_PER_THREAD_STATE_GET_USERS_PER_THREAD_STATE( *pts );
 510
 511     libbenchmark_results_put_result( rs,
 512                                      LIBBENCHMARK_DATASTRUCTURE_ID_BTREE_AU,
 513                                      LIBBENCHMARK_BENCHMARK_ID_READN_THEN_WRITEN,
 514                                      LIBBENCHMARK_LOCK_ID_LIBLFDS700_LOCKFREE,
 515                                      numa_mode,
 516                                      logical_processor_set,
 517                                      LIBBENCHMARK_TOPOLOGY_NODE_GET_LOGICAL_PROCESSOR_NUMBER( *pts->tns_lp ),
 518                                      LIBBENCHMARK_TOPOLOGY_NODE_GET_WINDOWS_GROUP_NUMBER( *pts->tns_lp ),
 519                                      ptbs->operation_count );
 520   }
 521
 522   obs = tsets->users_threadset_state;;
 523
 524   lfds700_btree_au_cleanup( obs->bs, NULL );
 525
 526   return;
 527 }
 528
 529
 530
 531
 532
 533 /****************************************************************************/
 534 static int key_compare_function( void const *new_key, void const *existing_key )
 535 {
 536   struct libbenchmark_benchmark_btree_au_liblfds700_lockfree_readn_writen_benchmark_element
 537     *new_benchmark_element,
 538     *existing_benchmark_element;
 539
 540   LFDS710_PAL_ASSERT( new_key != NULL );
 541   LFDS710_PAL_ASSERT( existing_key != NULL );
 542
 543   new_benchmark_element = (struct libbenchmark_benchmark_btree_au_liblfds700_lockfree_readn_writen_benchmark_element *) new_key;
 544   existing_benchmark_element = (struct libbenchmark_benchmark_btree_au_liblfds700_lockfree_readn_writen_benchmark_element *) existing_key;
 545
 546   if( new_benchmark_element->datum < existing_benchmark_element->datum )
 547     return -1;
 548
 549   if( new_benchmark_element->datum > existing_benchmark_element->datum )
 550     return 1;
 551
 552   return 0;
 553 }
 554