urcu-mb/signal/membarrier: batch concurrent synchronize_rcu()
A message that is not in the archive (sent off-list or not yet received): 20121126032220.GA19034@Krystal
Quoted 88 lines · * Mathieu Desnoyers ([email protected]) wrote:
Here are benchmarks on batching of
synchronize_rcu(), and it leads to very interesting scalability improvement and speedups, e.g., on a 24-core AMD, with a write-heavy scenario (4 readers threads, 20 updater threads, each updater usingsynchronize_rcu()):* Serialized grace periods:
./test_urcu 4 20 20
SUMMARY ./test_urcu testdur 20nr_readers4
rdur 0 wdur 0nr_writers20 wdelay 0nr_reads714598368nr_writes5032889nr_ops719631257* Batched grace periods:
./test_urcu 4 20 20
SUMMARY ./test_urcu testdur 20nr_readers4
rdur 0 wdur 0nr_writers20 wdelay 0nr_reads611848168nr_writes9877965nr_ops621726133For a 9877965/5032889 = 1.96 speedup for 20 updaters.
Of course, we can see that readers have slowed down, probably due to increased update traffic, given there is no change to the read-side code whatsoever.
Now let's see the penality of managing the stack for single-updater. With 4 readers, single updater:
* Serialized grace periods :
./test_urcu 4 1 20
SUMMARY ./test_urcu testdur 20nr_readers4
rdur 0 wdur 0nr_writers1 wdelay 0nr_reads241959144nr_writes11146189nr_ops253105333
SUMMARY ./test_urcu testdur 20nr_readers4
rdur 0 wdur 0nr_writers1 wdelay 0nr_reads257131080nr_writes12310537nr_ops269441617
SUMMARY ./test_urcu testdur 20nr_readers4
rdur 0 wdur 0nr_writers1 wdelay 0nr_reads259973359nr_writes12203025nr_ops272176384* Batched grace periods :
SUMMARY ./test_urcu testdur 20
nr_readers4
rdur 0 wdur 0nr_writers1 wdelay 0nr_reads298926555nr_writes14018748nr_ops312945303
SUMMARY ./test_urcu testdur 20nr_readers4
rdur 0 wdur 0nr_writers1 wdelay 0nr_reads272411290nr_writes12832166nr_ops285243456
SUMMARY ./test_urcu testdur 20nr_readers4
rdur 0 wdur 0nr_writers1 wdelay 0nr_reads267511858nr_writes12822026nr_ops280333884Serialized vs batched seems to similar, batched possibly even slightly faster, but this is probably caused by NUMA affinity.
CC Paul E. McKenney <[email protected]>CC Lai Jiangshan <[email protected]>CC Alan Stern <[email protected]>Signed-off-by Mathieu Desnoyers <[email protected]>---
urcu.c +7
-0@@ -43,6 +43,7 @@#include "urcu/tls-compat.h" #include "urcu-die.h" +#include "urcu-wait.h" /* Do not #define _LGPL_SOURCE to ensure we can emit the wrapper symbols */ #undef _LGPL_SOURCE@@ -106,6 +107,12 @@ DEFINE_URCU_TLS(unsigned int, rcu_rand_yield);static CDS_LIST_HEAD (registry); +/* +* Queue keeping threads awaiting to wait for a grace period. Contains +* struct gp_waiters_thread objects. +*/ +static DEFINE_URCU_WAIT_QUEUE (gp_waiters); +static void mutex_lock (pthread_mutex_t *mutex) {int ret;@@ -306,9 +313,31 @@ void synchronize_rcu(void) {CDS_LIST_HEAD (cur_snap_readers);
urcu.c void synchronize_rcu(void) · line 324
Quoted 10 lines
urcu.c +9
-0CDS_LIST_HEAD (qsreaders); +DEFINE_URCU_WAIT_NODE (wait,URCU_WAIT_WAITING ); +struct urcu_waiters waiters; + +/* +* Add ourself to gp_waiters queue of threads awaiting to wait +* for a grace period. Proceed to perform the grace period only +* if we are the first thread added into the queue. +*/ +if (urcu_wait_add (&gp_waiters, &wait) !=0 ) {
Actually, we're missing a memory barrier right here. Here is what I'm adding right away:
+ /* Order previous memory accesses before grace period. */
+ cmm_smp_mb();
Thanks,
Mathieu
Quoted 44 lines
urcu.c +20
-0+/* Not first in queue: will be awakened by another thread. */ +urcu_adaptative_busy_wait (&wait); +/* Order following memory accesses after grace period. */ +cmm_smp_mb (); +return ; + } +/* We won't need to wake ourself up */ +urcu_wait_set_state (&wait,URCU_WAIT_RUNNING );mutex_lock (&rcu_gp_lock); +/* +* Move all waiters into our local queue. +*/ +urcu_move_waiters (&waiters, &gp_waiters); +if (cds_list_empty (®istry)) goto out;@@ -374,6 +403,13 @@ void synchronize_rcu(void)smp_mb_master (RCU_MB_GROUP ); out:mutex_unlock (&rcu_gp_lock); + +/* +* Wakeup waiters only after we have completed the grace period +* and have ensured the memory barriers at the end of the grace +* period have been issued. +*/ +urcu_wake_all_waiters (&waiters); }/* Signature · 10 lines
-- Mathieu Desnoyers Operating System Efficiency R&D Consultant EfficiOS Inc. http://www.efficios.com _______________________________________________ lttng-dev mailing list [email protected] http://lists.lttng.org/cgi-bin/mailman/listinfo/lttng-dev
Signature · 4 lines
Mathieu Desnoyers Operating System Efficiency R&D Consultant EfficiOS Inc. http://www.efficios.com
I'm also interesting in the result of:
./test_urcu 12 12 20
./test_urcu 16 8 20
./test_urcu 20 4 20
Quoted 132 lines · Mathieu Desnoyers
Here are benchmarks on batching of
synchronize_rcu(), and it leads to very interesting scalability improvement and speedups, e.g., on a 24-core AMD, with a write-heavy scenario (4 readers threads, 20 updater threads, each updater usingsynchronize_rcu()):* Serialized grace periods:
./test_urcu 4 20 20
SUMMARY ./test_urcu testdur 20nr_readers4
rdur 0 wdur 0nr_writers20 wdelay 0nr_reads714598368nr_writes5032889nr_ops719631257* Batched grace periods:
./test_urcu 4 20 20
SUMMARY ./test_urcu testdur 20nr_readers4
rdur 0 wdur 0nr_writers20 wdelay 0nr_reads611848168nr_writes9877965nr_ops621726133For a 9877965/5032889 = 1.96 speedup for 20 updaters.
Of course, we can see that readers have slowed down, probably due to increased update traffic, given there is no change to the read-side code whatsoever.
Now let's see the penality of managing the stack for single-updater. With 4 readers, single updater:
* Serialized grace periods :
./test_urcu 4 1 20
SUMMARY ./test_urcu testdur 20nr_readers4
rdur 0 wdur 0nr_writers1 wdelay 0nr_reads241959144nr_writes11146189nr_ops253105333
SUMMARY ./test_urcu testdur 20nr_readers4
rdur 0 wdur 0nr_writers1 wdelay 0nr_reads257131080nr_writes12310537nr_ops269441617
SUMMARY ./test_urcu testdur 20nr_readers4
rdur 0 wdur 0nr_writers1 wdelay 0nr_reads259973359nr_writes12203025nr_ops272176384* Batched grace periods :
SUMMARY ./test_urcu testdur 20
nr_readers4
rdur 0 wdur 0nr_writers1 wdelay 0nr_reads298926555nr_writes14018748nr_ops312945303
SUMMARY ./test_urcu testdur 20nr_readers4
rdur 0 wdur 0nr_writers1 wdelay 0nr_reads272411290nr_writes12832166nr_ops285243456
SUMMARY ./test_urcu testdur 20nr_readers4
rdur 0 wdur 0nr_writers1 wdelay 0nr_reads267511858nr_writes12822026nr_ops280333884Serialized vs batched seems to similar, batched possibly even slightly faster, but this is probably caused by NUMA affinity.
CC Paul E. McKenney <[email protected]>CC Lai Jiangshan <[email protected]>CC Alan Stern <[email protected]>Signed-off-by Mathieu Desnoyers <[email protected]>---
urcu.c +36
-0@@ -43,6 +43,7 @@#include "urcu/tls-compat.h" #include "urcu-die.h" +#include "urcu-wait.h" /* Do not #define _LGPL_SOURCE to ensure we can emit the wrapper symbols */ #undef _LGPL_SOURCE@@ -106,6 +107,12 @@ DEFINE_URCU_TLS(unsigned int, rcu_rand_yield);static CDS_LIST_HEAD (registry); +/* +* Queue keeping threads awaiting to wait for a grace period. Contains +* struct gp_waiters_thread objects. +*/ +static DEFINE_URCU_WAIT_QUEUE (gp_waiters); +static void mutex_lock (pthread_mutex_t *mutex) {int ret;@@ -306,9 +313,31 @@ void synchronize_rcu(void) {CDS_LIST_HEAD (cur_snap_readers);CDS_LIST_HEAD (qsreaders); +DEFINE_URCU_WAIT_NODE (wait,URCU_WAIT_WAITING ); +struct urcu_waiters waiters; + +/* +* Add ourself to gp_waiters queue of threads awaiting to wait +* for a grace period. Proceed to perform the grace period only +* if we are the first thread added into the queue. +*/ +if (urcu_wait_add (&gp_waiters, &wait) !=0 ) { +/* Not first in queue: will be awakened by another thread. */ +urcu_adaptative_busy_wait (&wait); +/* Order following memory accesses after grace period. */ +cmm_smp_mb (); +return ; + } +/* We won't need to wake ourself up */ +urcu_wait_set_state (&wait,URCU_WAIT_RUNNING );mutex_lock (&rcu_gp_lock); +/* +* Move all waiters into our local queue. +*/ +urcu_move_waiters (&waiters, &gp_waiters); +if (cds_list_empty (®istry)) goto out;@@ -374,6 +403,13 @@ void synchronize_rcu(void)smp_mb_master (RCU_MB_GROUP ); out:mutex_unlock (&rcu_gp_lock); + +/* +* Wakeup waiters only after we have completed the grace period +* and have ensured the memory barriers at the end of the grace +* period have been issued. +*/ +urcu_wake_all_waiters (&waiters); }/*
Quoted 11 lines · Mathieu Desnoyers
Here are benchmarks on batching of
synchronize_rcu(), and it leads to very interesting scalability improvement and speedups, e.g., on a 24-core AMD, with a write-heavy scenario (4 readers threads, 20 updater threads, each updater usingsynchronize_rcu()):* Serialized grace periods:
./test_urcu 4 20 20
SUMMARY ./test_urcu testdur 20nr_readers4
rdur 0 wdur 0nr_writers20 wdelay 0nr_reads714598368nr_writes5032889nr_ops719631257
Quoted 8 lines
* Batched grace periods:
./test_urcu 4 20 20
SUMMARY ./test_urcu testdur 20nr_readers4
rdur 0 wdur 0nr_writers20 wdelay 0nr_reads611848168nr_writes9877965nr_ops621726133For a 9877965/5032889 = 1.96 speedup for 20 updaters.
I guess it is the result of RCU_MB,
(if it does, could you test RCU_SIGNAL, it may speedup more)
Quoted 113 lines
Of course, we can see that readers have slowed down, probably due to increased update traffic, given there is no change to the read-side code whatsoever.
Now let's see the penality of managing the stack for single-updater. With 4 readers, single updater:
* Serialized grace periods :
./test_urcu 4 1 20
SUMMARY ./test_urcu testdur 20nr_readers4
rdur 0 wdur 0nr_writers1 wdelay 0nr_reads241959144nr_writes11146189nr_ops253105333
SUMMARY ./test_urcu testdur 20nr_readers4
rdur 0 wdur 0nr_writers1 wdelay 0nr_reads257131080nr_writes12310537nr_ops269441617
SUMMARY ./test_urcu testdur 20nr_readers4
rdur 0 wdur 0nr_writers1 wdelay 0nr_reads259973359nr_writes12203025nr_ops272176384* Batched grace periods :
SUMMARY ./test_urcu testdur 20
nr_readers4
rdur 0 wdur 0nr_writers1 wdelay 0nr_reads298926555nr_writes14018748nr_ops312945303
SUMMARY ./test_urcu testdur 20nr_readers4
rdur 0 wdur 0nr_writers1 wdelay 0nr_reads272411290nr_writes12832166nr_ops285243456
SUMMARY ./test_urcu testdur 20nr_readers4
rdur 0 wdur 0nr_writers1 wdelay 0nr_reads267511858nr_writes12822026nr_ops280333884Serialized vs batched seems to similar, batched possibly even slightly faster, but this is probably caused by NUMA affinity.
CC Paul E. McKenney <[email protected]>CC Lai Jiangshan <[email protected]>CC Alan Stern <[email protected]>Signed-off-by Mathieu Desnoyers <[email protected]>---
urcu.c +36
-0@@ -43,6 +43,7 @@#include "urcu/tls-compat.h" #include "urcu-die.h" +#include "urcu-wait.h" /* Do not #define _LGPL_SOURCE to ensure we can emit the wrapper symbols */ #undef _LGPL_SOURCE@@ -106,6 +107,12 @@ DEFINE_URCU_TLS(unsigned int, rcu_rand_yield);static CDS_LIST_HEAD (registry); +/* +* Queue keeping threads awaiting to wait for a grace period. Contains +* struct gp_waiters_thread objects. +*/ +static DEFINE_URCU_WAIT_QUEUE (gp_waiters); +static void mutex_lock (pthread_mutex_t *mutex) {int ret;@@ -306,9 +313,31 @@ void synchronize_rcu(void) {CDS_LIST_HEAD (cur_snap_readers);CDS_LIST_HEAD (qsreaders); +DEFINE_URCU_WAIT_NODE (wait,URCU_WAIT_WAITING ); +struct urcu_waiters waiters; + +/* +* Add ourself to gp_waiters queue of threads awaiting to wait +* for a grace period. Proceed to perform the grace period only +* if we are the first thread added into the queue. +*/ +if (urcu_wait_add (&gp_waiters, &wait) !=0 ) { +/* Not first in queue: will be awakened by another thread. */ +urcu_adaptative_busy_wait (&wait); +/* Order following memory accesses after grace period. */ +cmm_smp_mb (); +return ; + } +/* We won't need to wake ourself up */ +urcu_wait_set_state (&wait,URCU_WAIT_RUNNING );mutex_lock (&rcu_gp_lock); +/* +* Move all waiters into our local queue. +*/ +urcu_move_waiters (&waiters, &gp_waiters); +if (cds_list_empty (®istry)) goto out;@@ -374,6 +403,13 @@ void synchronize_rcu(void)smp_mb_master (RCU_MB_GROUP ); out:mutex_unlock (&rcu_gp_lock); + +/* +* Wakeup waiters only after we have completed the grace period +* and have ensured the memory barriers at the end of the grace +* period have been issued. +*/ +urcu_wake_all_waiters (&waiters); }/*
A message that is not in the archive (sent off-list or not yet received): 20121126033217.GA19396@Krystal
Quoted 103 lines · * Mathieu Desnoyers ([email protected]) wrote:
Quoted 88 lines · * Mathieu Desnoyers ([email protected]) wrote:
Here are benchmarks on batching of
synchronize_rcu(), and it leads to very interesting scalability improvement and speedups, e.g., on a 24-core AMD, with a write-heavy scenario (4 readers threads, 20 updater threads, each updater usingsynchronize_rcu()):* Serialized grace periods:
./test_urcu 4 20 20
SUMMARY ./test_urcu testdur 20nr_readers4
rdur 0 wdur 0nr_writers20 wdelay 0nr_reads714598368nr_writes5032889nr_ops719631257* Batched grace periods:
./test_urcu 4 20 20
SUMMARY ./test_urcu testdur 20nr_readers4
rdur 0 wdur 0nr_writers20 wdelay 0nr_reads611848168nr_writes9877965nr_ops621726133For a 9877965/5032889 = 1.96 speedup for 20 updaters.
Of course, we can see that readers have slowed down, probably due to increased update traffic, given there is no change to the read-side code whatsoever.
Now let's see the penality of managing the stack for single-updater. With 4 readers, single updater:
* Serialized grace periods :
./test_urcu 4 1 20
SUMMARY ./test_urcu testdur 20nr_readers4
rdur 0 wdur 0nr_writers1 wdelay 0nr_reads241959144nr_writes11146189nr_ops253105333
SUMMARY ./test_urcu testdur 20nr_readers4
rdur 0 wdur 0nr_writers1 wdelay 0nr_reads257131080nr_writes12310537nr_ops269441617
SUMMARY ./test_urcu testdur 20nr_readers4
rdur 0 wdur 0nr_writers1 wdelay 0nr_reads259973359nr_writes12203025nr_ops272176384* Batched grace periods :
SUMMARY ./test_urcu testdur 20
nr_readers4
rdur 0 wdur 0nr_writers1 wdelay 0nr_reads298926555nr_writes14018748nr_ops312945303
SUMMARY ./test_urcu testdur 20nr_readers4
rdur 0 wdur 0nr_writers1 wdelay 0nr_reads272411290nr_writes12832166nr_ops285243456
SUMMARY ./test_urcu testdur 20nr_readers4
rdur 0 wdur 0nr_writers1 wdelay 0nr_reads267511858nr_writes12822026nr_ops280333884Serialized vs batched seems to similar, batched possibly even slightly faster, but this is probably caused by NUMA affinity.
CC Paul E. McKenney <[email protected]>CC Lai Jiangshan <[email protected]>CC Alan Stern <[email protected]>Signed-off-by Mathieu Desnoyers <[email protected]>---
urcu.c +7
-0@@ -43,6 +43,7 @@#include "urcu/tls-compat.h" #include "urcu-die.h" +#include "urcu-wait.h" /* Do not #define _LGPL_SOURCE to ensure we can emit the wrapper symbols */ #undef _LGPL_SOURCE@@ -106,6 +107,12 @@ DEFINE_URCU_TLS(unsigned int, rcu_rand_yield);static CDS_LIST_HEAD (registry); +/* +* Queue keeping threads awaiting to wait for a grace period. Contains +* struct gp_waiters_thread objects. +*/ +static DEFINE_URCU_WAIT_QUEUE (gp_waiters); +static void mutex_lock (pthread_mutex_t *mutex) {int ret;@@ -306,9 +313,31 @@ void synchronize_rcu(void) {CDS_LIST_HEAD (cur_snap_readers);urcu.c void synchronize_rcu(void) · line 324
Quoted 10 lines
urcu.c +9
-0CDS_LIST_HEAD (qsreaders); +DEFINE_URCU_WAIT_NODE (wait,URCU_WAIT_WAITING ); +struct urcu_waiters waiters; + +/* +* Add ourself to gp_waiters queue of threads awaiting to wait +* for a grace period. Proceed to perform the grace period only +* if we are the first thread added into the queue. +*/ +if (urcu_wait_add (&gp_waiters, &wait) !=0 ) {Actually, we're missing a memory barrier right here. Here is what I'm adding right away:
Review
Quoted 2 lines
(quoted diff) +2
-0+ /* Order previous memory accesses before grace period. */ + cmm_smp_mb();
Now that I come to think of it, the barrier is needed before urcu_wait_add() rather than after. It's the action on the wait queue (move operation) that order us before the start of the grace period. So instead of adding this barrier, I'm going to document that there is an implicit memory barrier before urcu_wait_add(), and document this barrier in the urcu_wait_add API.
I will also document an implicit memory barrier after urcu_move_waiters, which orders the queue moving memory access prior to the beginning of the grace period.
Thanks,
Mathieu
Quoted 56 lines
Thanks,
Mathieu
Quoted 44 lines
urcu.c +20
-0+/* Not first in queue: will be awakened by another thread. */ +urcu_adaptative_busy_wait (&wait); +/* Order following memory accesses after grace period. */ +cmm_smp_mb (); +return ; + } +/* We won't need to wake ourself up */ +urcu_wait_set_state (&wait,URCU_WAIT_RUNNING );mutex_lock (&rcu_gp_lock); +/* +* Move all waiters into our local queue. +*/ +urcu_move_waiters (&waiters, &gp_waiters); +if (cds_list_empty (®istry)) goto out;@@ -374,6 +403,13 @@ void synchronize_rcu(void)smp_mb_master (RCU_MB_GROUP ); out:mutex_unlock (&rcu_gp_lock); + +/* +* Wakeup waiters only after we have completed the grace period +* and have ensured the memory barriers at the end of the grace +* period have been issued. +*/ +urcu_wake_all_waiters (&waiters); }/* Signature · 10 lines
-- Mathieu Desnoyers Operating System Efficiency R&D Consultant EfficiOS Inc. http://www.efficios.com _______________________________________________ lttng-dev mailing list [email protected] http://lists.lttng.org/cgi-bin/mailman/listinfo/lttng-devSignature · 4 lines
Mathieu Desnoyers Operating System Efficiency R&D Consultant EfficiOS Inc. http://www.efficios.com
Signature · 4 lines
Mathieu Desnoyers Operating System Efficiency R&D Consultant EfficiOS Inc. http://www.efficios.com
A message that is not in the archive (sent off-list or not yet received): [email protected]
Hi Lai,
Here are the raw results you asked for. I only did a single run for each, and did not specify any CPU affinity, so please keep in mind that results can vary due to NUMA access effects. But the trend is clear:
when we have 3 or more updaters, batching is quite effective. With 1-2 updaters, the results vary between a small speedup for batching (for 1 updater) to a small slowdown for batching (2 updaters). I don't have good explanation for the 1-updater speedups, except maybe that accessing a mutex cache-line with a xchg() first might speed things up, but this is really just a guess.
Thoughts ?
* Serialized synchronize_rcu() -- test_urcu (mb)
./test_urcu 4 1 20
SUMMARY ./test_urcu testdur 20 nr_readers 4 rdur 0 wdur 0 nr_writers 1 wdelay 0 nr_reads 222512859 nr_writes 10723654 nr_ops 233236513
./test_urcu 4 20 20
SUMMARY ./test_urcu testdur 20 nr_readers 4 rdur 0 wdur 0 nr_writers 20 wdelay 0 nr_reads 722096653 nr_writes 5012429 nr_ops 727109082
./test_urcu 12 12 20
SUMMARY ./test_urcu testdur 20 nr_readers 12 rdur 0 wdur 0 nr_writers 12 wdelay 0 nr_reads 1822868768 nr_writes 2300787 nr_ops 1825169555
./test_urcu 16 8 20
SUMMARY ./test_urcu testdur 20 nr_readers 16 rdur 0 wdur 0 nr_writers 8 wdelay 0 nr_reads 2355908375 nr_writes 1604850 nr_ops 2357513225
./test_urcu 20 4 20
SUMMARY ./test_urcu testdur 20 nr_readers 20 rdur 0 wdur 0 nr_writers 4 wdelay 0 nr_reads 3003457459 nr_writes 1074828 nr_ops 3004532287
./test_urcu 20 3 20
SUMMARY ./test_urcu testdur 20 nr_readers 20 rdur 0 wdur 0 nr_writers 3 wdelay 0 nr_reads 2956972543 nr_writes 1036556 nr_ops 2958009099
./test_urcu 20 2 20
SUMMARY ./test_urcu testdur 20 nr_readers 20 rdur 0 wdur 0 nr_writers 2 wdelay 0 nr_reads 2890178860 nr_writes 1030095 nr_ops 2891208955
./test_urcu 20 1 20
SUMMARY ./test_urcu testdur 20 nr_readers 20 rdur 0 wdur 0 nr_writers 1 wdelay 0 nr_reads 3017482290 nr_writes 783420 nr_ops 3018265710
* Batched synchronize_rcu() -- test_urcu (mb)
./test_urcu 4 1 20
SUMMARY ./test_urcu testdur 20 nr_readers 4 rdur 0 wdur 0 nr_writers 1 wdelay 0 nr_reads 271476751 nr_writes 12858885 nr_ops 284335636
./test_urcu 4 20 20
SUMMARY ./test_urcu testdur 20 nr_readers 4 rdur 0 wdur 0 nr_writers 20 wdelay 0 nr_reads 608488583 nr_writes 10080610 nr_ops 618569193
./test_urcu 12 12 20
SUMMARY ./test_urcu testdur 20 nr_readers 12 rdur 0 wdur 0 nr_writers 12 wdelay 0 nr_reads 1260044362 nr_writes 7957711 nr_ops 1268002073
./test_urcu 16 8 20
SUMMARY ./test_urcu testdur 20 nr_readers 16 rdur 0 wdur 0 nr_writers 8 wdelay 0 nr_reads 2048890674 nr_writes 5440985 nr_ops 2054331659
./test_urcu 20 4 20
SUMMARY ./test_urcu testdur 20 nr_readers 20 rdur 0 wdur 0 nr_writers 4 wdelay 0 nr_reads 2819267217 nr_writes 3093008 nr_ops 2822360225
./test_urcu 20 3 20
SUMMARY ./test_urcu testdur 20 nr_readers 20 rdur 0 wdur 0 nr_writers 3 wdelay 0 nr_reads 3067795320 nr_writes 2817760 nr_ops 3070613080
./test_urcu 20 2 20
SUMMARY ./test_urcu testdur 20 nr_readers 20 rdur 0 wdur 0 nr_writers 2 wdelay 0 nr_reads 3116770603 nr_writes 2404242 nr_ops 3119174845
./test_urcu 20 1 20
SUMMARY ./test_urcu testdur 20 nr_readers 20 rdur 0 wdur 0 nr_writers 1 wdelay 0 nr_reads 2238534130 nr_writes 3737588 nr_ops 2242271718
* Serialized synchronize_rcu() -- test_urcu_signal
./test_urcu_signal 4 1 20
SUMMARY ./test_urcu_signal testdur 20 nr_readers 4 rdur 0 wdur 0 nr_writers 1 wdelay 0 nr_reads 16063309841 nr_writes 9217 nr_ops 16063319058
./test_urcu_signal 4 20 20
SUMMARY ./test_urcu_signal testdur 20 nr_readers 4 rdur 0 wdur 0 nr_writers 20 wdelay 0 nr_reads 16065183739 nr_writes 9182 nr_ops 16065192921
./test_urcu_signal 12 12 20
SUMMARY ./test_urcu_signal testdur 20 nr_readers 12 rdur 0 wdur 0 nr_writers 12 wdelay 0 nr_reads 48028512672 nr_writes 8890 nr_ops 48028521562
./test_urcu_signal 16 8 20
SUMMARY ./test_urcu_signal testdur 20 nr_readers 16 rdur 0 wdur 0 nr_writers 8 wdelay 0 nr_reads 64001589198 nr_writes 8756 nr_ops 64001597954
./test_urcu_signal 20 4 20
SUMMARY ./test_urcu_signal testdur 20 nr_readers 20 rdur 0 wdur 0 nr_writers 4 wdelay 0 nr_reads 79907434070 nr_writes 9068 nr_ops 79907443138
./test_urcu_signal 20 3 20
SUMMARY ./test_urcu_signal testdur 20 nr_readers 20 rdur 0 wdur 0 nr_writers 3 wdelay 0 nr_reads 79987250839 nr_writes 8589 nr_ops 79987259428
./test_urcu_signal 20 2 20
SUMMARY ./test_urcu_signal testdur 20 nr_readers 20 rdur 0 wdur 0 nr_writers 2 wdelay 0 nr_reads 79749947176 nr_writes 8596 nr_ops 79749955772
./test_urcu_signal 20 1 20
SUMMARY ./test_urcu_signal testdur 20 nr_readers 20 rdur 0 wdur 0 nr_writers 1 wdelay 0 nr_reads 79751023090 nr_writes 8624 nr_ops 79751031714
* Batched synchronize_rcu() -- test_urcu_signal
./test_urcu_signal 4 1 20
SUMMARY ./test_urcu_signal testdur 20 nr_readers 4 rdur 0 wdur 0 nr_writers 1 wdelay 0 nr_reads 15739087241 nr_writes 9218 nr_ops 15739096459
./test_urcu_signal 4 20 20
SUMMARY ./test_urcu_signal testdur 20 nr_readers 4 rdur 0 wdur 0 nr_writers 20 wdelay 0 nr_reads 15662135806 nr_writes 94833 nr_ops 15662230639
./test_urcu_signal 12 12 20
SUMMARY ./test_urcu_signal testdur 20 nr_readers 12 rdur 0 wdur 0 nr_writers 12 wdelay 0 nr_reads 46634363289 nr_writes 56903 nr_ops 46634420192
./test_urcu_signal 16 8 20
SUMMARY ./test_urcu_signal testdur 20 nr_readers 16 rdur 0 wdur 0 nr_writers 8 wdelay 0 nr_reads 62263951759 nr_writes 39058 nr_ops 62263990817
./test_urcu_signal 20 4 20
SUMMARY ./test_urcu_signal testdur 20 nr_readers 20 rdur 0 wdur 0 nr_writers 4 wdelay 0 nr_reads 77799768623 nr_writes 21065 nr_ops 77799789688
./test_urcu_signal 20 3 20
SUMMARY ./test_urcu_signal testdur 20 nr_readers 20 rdur 0 wdur 0 nr_writers 3 wdelay 0 nr_reads 76408008440 nr_writes 17026 nr_ops 76408025466
./test_urcu_signal 20 2 20
SUMMARY ./test_urcu_signal testdur 20 nr_readers 20 rdur 0 wdur 0 nr_writers 2 wdelay 0 nr_reads 77868927424 nr_writes 12630 nr_ops 77868940054
./test_urcu_signal 20 1 20
SUMMARY ./test_urcu_signal testdur 20 nr_readers 20 rdur 0 wdur 0 nr_writers 1 wdelay 0 nr_reads 77293186844 nr_writes 8680 nr_ops 77293195524
* Serialized synchronize_rcu() -- test_urcu_qsbr
./test_urcu_qsbr 4 1 20
SUMMARY ./test_urcu_qsbr testdur 20 nr_readers 4 rdur 0 wdur 0 nr_writers 1 wdelay 0 nr_reads 18841016559 nr_writes 1857130 nr_ops 18842873689
./test_urcu_qsbr 4 20 20
SUMMARY ./test_urcu_qsbr testdur 20 nr_readers 4 rdur 0 wdur 0 nr_writers 20 wdelay 0 nr_reads 20272811733 nr_writes 1837027 nr_ops 20274648760
./test_urcu_qsbr 12 12 20
SUMMARY ./test_urcu_qsbr testdur 20 nr_readers 12 rdur 0 wdur 0 nr_writers 12 wdelay 0 nr_reads 60343516643 nr_writes 2353685 nr_ops 60345870328
./test_urcu_qsbr 16 8 20
SUMMARY ./test_urcu_qsbr testdur 20 nr_readers 16 rdur 0 wdur 0 nr_writers 8 wdelay 0 nr_reads 78202711840 nr_writes 2326331 nr_ops 78205038171
./test_urcu_qsbr 20 4 20
SUMMARY ./test_urcu_qsbr testdur 20 nr_readers 20 rdur 0 wdur 0 nr_writers 4 wdelay 0 nr_reads 94553396003 nr_writes 2238396 nr_ops 94555634399
./test_urcu_qsbr 20 3 20
SUMMARY ./test_urcu_qsbr testdur 20 nr_readers 20 rdur 0 wdur 0 nr_writers 3 wdelay 0 nr_reads 95004708661 nr_writes 2165966 nr_ops 95006874627
./test_urcu_qsbr 20 2 20
SUMMARY ./test_urcu_qsbr testdur 20 nr_readers 20 rdur 0 wdur 0 nr_writers 2 wdelay 0 nr_reads 95386506198 nr_writes 2194352 nr_ops 95388700550
./test_urcu_qsbr 20 1 20
SUMMARY ./test_urcu_qsbr testdur 20 nr_readers 20 rdur 0 wdur 0 nr_writers 1 wdelay 0 nr_reads 84705972017 nr_writes 2609595 nr_ops 84708581612
* Batched synchronize_rcu() -- test_urcu_qsbr
./test_urcu_qsbr 4 1 20
SUMMARY ./test_urcu_qsbr testdur 20 nr_readers 4 rdur 0 wdur 0 nr_writers 1 wdelay 0 nr_reads 19154850714 nr_writes 2238834 nr_ops 19157089548
./test_urcu_qsbr 4 20 20
SUMMARY ./test_urcu_qsbr testdur 20 nr_readers 4 rdur 0 wdur 0 nr_writers 20 wdelay 0 nr_reads 15114131760 nr_writes 9370255 nr_ops 15123502015
./test_urcu_qsbr 12 12 20
SUMMARY ./test_urcu_qsbr testdur 20 nr_readers 12 rdur 0 wdur 0 nr_writers 12 wdelay 0 nr_reads 45541854970 nr_writes 5786496 nr_ops 45547641466
./test_urcu_qsbr 16 8 20
SUMMARY ./test_urcu_qsbr testdur 20 nr_readers 16 rdur 0 wdur 0 nr_writers 8 wdelay 0 nr_reads 66217337547 nr_writes 4257427 nr_ops 66221594974
./test_urcu_qsbr 20 4 20
SUMMARY ./test_urcu_qsbr testdur 20 nr_readers 20 rdur 0 wdur 0 nr_writers 4 wdelay 0 nr_reads 95048642908 nr_writes 2416266 nr_ops 95051059174
./test_urcu_qsbr 20 3 20
SUMMARY ./test_urcu_qsbr testdur 20 nr_readers 20 rdur 0 wdur 0 nr_writers 3 wdelay 0 nr_reads 96679609928 nr_writes 2211168 nr_ops 96681821096
./test_urcu_qsbr 20 2 20
SUMMARY ./test_urcu_qsbr testdur 20 nr_readers 20 rdur 0 wdur 0 nr_writers 2 wdelay 0 nr_reads 92166219811 nr_writes 1968725 nr_ops 92168188536
./test_urcu_qsbr 20 1 20
SUMMARY ./test_urcu_qsbr testdur 20 nr_readers 20 rdur 0 wdur 0 nr_writers 1 wdelay 0 nr_reads 87986181951 nr_writes 3278737 nr_ops 87989460688
Signature · 4 lines
Mathieu Desnoyers Operating System Efficiency R&D Consultant EfficiOS Inc. http://www.efficios.com