From 7eec247c356826abbf51f53b41e6307d577a446d Mon Sep 17 00:00:00 2001 From: Sebastian Huber Date: Mon, 31 Oct 2016 10:50:54 +0100 Subject: smptests/smplock01: Use test support Convert output to XML. --- testsuites/smptests/smplock01/init.c | 622 ++++---- testsuites/smptests/smplock01/smplock01.py | 32 + testsuites/smptests/smplock01/smplock01.scn | 2068 +++++++++++++++++++++++---- 3 files changed, 2189 insertions(+), 533 deletions(-) create mode 100644 testsuites/smptests/smplock01/smplock01.py (limited to 'testsuites/smptests') diff --git a/testsuites/smptests/smplock01/init.c b/testsuites/smptests/smplock01/init.c index 62397a3b27..046fce6493 100644 --- a/testsuites/smptests/smplock01/init.c +++ b/testsuites/smptests/smplock01/init.c @@ -19,10 +19,10 @@ #include #include #include -#include -#include +#include #include +#define TESTS_USE_PRINTK #include "tmacros.h" const char rtems_test_name[] = "SMPLOCK 1"; @@ -33,34 +33,21 @@ const char rtems_test_name[] = "SMPLOCK 1"; #define TEST_COUNT 11 -typedef enum { - INITIAL, - START_TEST, - STOP_TEST -} states; - typedef struct { - Atomic_Uint state; - SMP_barrier_Control barrier; - rtems_id timer_id; - rtems_interval timeout; + rtems_test_parallel_context base; unsigned long counter[TEST_COUNT]; - unsigned long test_counter[TEST_COUNT][CPU_COUNT]; + unsigned long local_counter[CPU_COUNT][TEST_COUNT][CPU_COUNT]; SMP_lock_Control lock; #if defined(RTEMS_PROFILING) SMP_lock_Stats mcs_stats; #endif SMP_MCS_lock_Control mcs_lock; SMP_sequence_lock_Control seq_lock; - char unused_space_for_cache_line_separation_0[128]; - int a; - char unused_space_for_cache_line_separation_1[128]; - int b; -} global_context; - -static global_context context = { - .state = ATOMIC_INITIALIZER_UINT(INITIAL), - .barrier = SMP_BARRIER_CONTROL_INITIALIZER, + int a RTEMS_ALIGNED(CPU_CACHE_LINE_BYTES); + int b RTEMS_ALIGNED(CPU_CACHE_LINE_BYTES); +} test_context RTEMS_ALIGNED(CPU_CACHE_LINE_BYTES); + +static test_context test_instance = { .lock = SMP_LOCK_INITIALIZER("global ticket"), #if defined(RTEMS_PROFILING) .mcs_stats = SMP_LOCK_STATS_INITIALIZER("global MCS"), @@ -69,146 +56,222 @@ static global_context context = { .seq_lock = SMP_SEQUENCE_LOCK_INITIALIZER }; -static const char * const test_names[TEST_COUNT] = { - "global ticket lock with local counter", - "global MCS lock with local counter", - "global ticket lock with global counter", - "global MCS lock with global counter", - "local ticket lock with local counter", - "local MCS lock with local counter", - "local ticket lock with global counter", - "local MCS lock with global counter", - "global ticket lock with busy section", - "global MCS lock with busy section", - "sequence lock" -}; - -static void stop_test_timer(rtems_id timer_id, void *arg) +static rtems_interval test_duration(void) { - global_context *ctx = arg; - - _Atomic_Store_uint(&ctx->state, STOP_TEST, ATOMIC_ORDER_RELEASE); + return rtems_clock_get_ticks_per_second(); } -static void wait_for_state(global_context *ctx, int desired_state) +static rtems_interval test_init( + rtems_test_parallel_context *base, + void *arg, + size_t active_workers +) { - while ( - _Atomic_Load_uint(&ctx->state, ATOMIC_ORDER_ACQUIRE) != desired_state - ) { - /* Wait */ - } + return test_duration(); } -static bool assert_state(global_context *ctx, int desired_state) +static void test_fini( + test_context *ctx, + const char *name, + size_t test, + size_t active_workers +) { - return _Atomic_Load_uint(&ctx->state, ATOMIC_ORDER_RELAXED) == desired_state; -} + unsigned long sum = 0; + unsigned long n = active_workers; + unsigned long i; + + printf(" <%s activeWorker=\"%lu\">\n", name, n); + + for (i = 0; i < n; ++i) { + unsigned long local_counter = + ctx->local_counter[active_workers - 1][test][i]; -typedef void (*test_body)( - int test, - global_context *ctx, - SMP_barrier_State *bs, - unsigned int cpu_count, - unsigned int cpu_self -); + sum += local_counter; + + printf( + " %lu\n", + i, + local_counter + ); + } + + printf( + " %lu\n" + " %lu\n" + " \n", + ctx->counter[test], + sum, + name + ); +} static void test_0_body( - int test, - global_context *ctx, - SMP_barrier_State *bs, - unsigned int cpu_count, - unsigned int cpu_self + rtems_test_parallel_context *base, + void *arg, + size_t active_workers, + size_t worker_index ) { + test_context *ctx = (test_context *) base; + size_t test = 0; unsigned long counter = 0; SMP_lock_Context lock_context; - while (assert_state(ctx, START_TEST)) { + while (!rtems_test_parallel_stop_job(&ctx->base)) { _SMP_lock_Acquire(&ctx->lock, &lock_context); _SMP_lock_Release(&ctx->lock, &lock_context); ++counter; } - ctx->test_counter[test][cpu_self] = counter; + ctx->local_counter[active_workers - 1][test][worker_index] = counter; +} + +static void test_0_fini( + rtems_test_parallel_context *base, + void *arg, + size_t active_workers +) +{ + test_context *ctx = (test_context *) base; + + test_fini( + ctx, + "GlobalTicketLockWithLocalCounter", + 0, + active_workers + ); } static void test_1_body( - int test, - global_context *ctx, - SMP_barrier_State *bs, - unsigned int cpu_count, - unsigned int cpu_self + rtems_test_parallel_context *base, + void *arg, + size_t active_workers, + size_t worker_index ) { + test_context *ctx = (test_context *) base; + size_t test = 1; unsigned long counter = 0; SMP_MCS_lock_Context lock_context; - while (assert_state(ctx, START_TEST)) { + while (!rtems_test_parallel_stop_job(&ctx->base)) { _SMP_MCS_lock_Acquire(&ctx->mcs_lock, &lock_context, &ctx->mcs_stats); _SMP_MCS_lock_Release(&ctx->mcs_lock, &lock_context); ++counter; } - ctx->test_counter[test][cpu_self] = counter; + ctx->local_counter[active_workers - 1][test][worker_index] = counter; +} + +static void test_1_fini( + rtems_test_parallel_context *base, + void *arg, + size_t active_workers +) +{ + test_context *ctx = (test_context *) base; + + test_fini( + ctx, + "GlobalMCSLockWithLocalCounter", + 1, + active_workers + ); } static void test_2_body( - int test, - global_context *ctx, - SMP_barrier_State *bs, - unsigned int cpu_count, - unsigned int cpu_self + rtems_test_parallel_context *base, + void *arg, + size_t active_workers, + size_t worker_index ) { + test_context *ctx = (test_context *) base; + size_t test = 2; unsigned long counter = 0; SMP_lock_Context lock_context; - while (assert_state(ctx, START_TEST)) { + while (!rtems_test_parallel_stop_job(&ctx->base)) { _SMP_lock_Acquire(&ctx->lock, &lock_context); ++ctx->counter[test]; _SMP_lock_Release(&ctx->lock, &lock_context); ++counter; } - ctx->test_counter[test][cpu_self] = counter; + ctx->local_counter[active_workers - 1][test][worker_index] = counter; +} + +static void test_2_fini( + rtems_test_parallel_context *base, + void *arg, + size_t active_workers +) +{ + test_context *ctx = (test_context *) base; + + test_fini( + ctx, + "GlobalTicketLockWithGlobalCounter", + 2, + active_workers + ); } static void test_3_body( - int test, - global_context *ctx, - SMP_barrier_State *bs, - unsigned int cpu_count, - unsigned int cpu_self + rtems_test_parallel_context *base, + void *arg, + size_t active_workers, + size_t worker_index ) { + test_context *ctx = (test_context *) base; + size_t test = 3; unsigned long counter = 0; SMP_MCS_lock_Context lock_context; - while (assert_state(ctx, START_TEST)) { + while (!rtems_test_parallel_stop_job(&ctx->base)) { _SMP_MCS_lock_Acquire(&ctx->mcs_lock, &lock_context, &ctx->mcs_stats); ++ctx->counter[test]; _SMP_MCS_lock_Release(&ctx->mcs_lock, &lock_context); ++counter; } - ctx->test_counter[test][cpu_self] = counter; + ctx->local_counter[active_workers - 1][test][worker_index] = counter; +} + +static void test_3_fini( + rtems_test_parallel_context *base, + void *arg, + size_t active_workers +) +{ + test_context *ctx = (test_context *) base; + + test_fini( + ctx, + "GlobalMCSLockWithGlobalCounter", + 3, + active_workers + ); } static void test_4_body( - int test, - global_context *ctx, - SMP_barrier_State *bs, - unsigned int cpu_count, - unsigned int cpu_self + rtems_test_parallel_context *base, + void *arg, + size_t active_workers, + size_t worker_index ) { + test_context *ctx = (test_context *) base; + size_t test = 4; unsigned long counter = 0; SMP_lock_Control lock; SMP_lock_Context lock_context; _SMP_lock_Initialize(&lock, "local"); - while (assert_state(ctx, START_TEST)) { + while (!rtems_test_parallel_stop_job(&ctx->base)) { _SMP_lock_Acquire(&lock, &lock_context); _SMP_lock_Release(&lock, &lock_context); ++counter; @@ -216,17 +279,34 @@ static void test_4_body( _SMP_lock_Destroy(&lock); - ctx->test_counter[test][cpu_self] = counter; + ctx->local_counter[active_workers - 1][test][worker_index] = counter; +} + +static void test_4_fini( + rtems_test_parallel_context *base, + void *arg, + size_t active_workers +) +{ + test_context *ctx = (test_context *) base; + + test_fini( + ctx, + "LocalTicketLockWithLocalCounter", + 4, + active_workers + ); } static void test_5_body( - int test, - global_context *ctx, - SMP_barrier_State *bs, - unsigned int cpu_count, - unsigned int cpu_self + rtems_test_parallel_context *base, + void *arg, + size_t active_workers, + size_t worker_index ) { + test_context *ctx = (test_context *) base; + size_t test = 5; unsigned long counter = 0; #if defined(RTEMS_PROFILING) SMP_lock_Stats stats; @@ -237,7 +317,7 @@ static void test_5_body( _SMP_lock_Stats_initialize(&stats, "local"); _SMP_MCS_lock_Initialize(&lock); - while (assert_state(ctx, START_TEST)) { + while (!rtems_test_parallel_stop_job(&ctx->base)) { _SMP_MCS_lock_Acquire(&lock, &lock_context, &stats); _SMP_MCS_lock_Release(&lock, &lock_context); ++counter; @@ -246,24 +326,41 @@ static void test_5_body( _SMP_MCS_lock_Destroy(&lock); _SMP_lock_Stats_destroy(&stats); - ctx->test_counter[test][cpu_self] = counter; + ctx->local_counter[active_workers - 1][test][worker_index] = counter; +} + +static void test_5_fini( + rtems_test_parallel_context *base, + void *arg, + size_t active_workers +) +{ + test_context *ctx = (test_context *) base; + + test_fini( + ctx, + "LocalMCSLockWithLocalCounter", + 5, + active_workers + ); } static void test_6_body( - int test, - global_context *ctx, - SMP_barrier_State *bs, - unsigned int cpu_count, - unsigned int cpu_self + rtems_test_parallel_context *base, + void *arg, + size_t active_workers, + size_t worker_index ) { + test_context *ctx = (test_context *) base; + size_t test = 6; unsigned long counter = 0; SMP_lock_Control lock; SMP_lock_Context lock_context; _SMP_lock_Initialize(&lock, "local"); - while (assert_state(ctx, START_TEST)) { + while (!rtems_test_parallel_stop_job(&ctx->base)) { _SMP_lock_Acquire(&lock, &lock_context); /* The counter value is not interesting, only the access to it */ @@ -275,17 +372,34 @@ static void test_6_body( _SMP_lock_Destroy(&lock); - ctx->test_counter[test][cpu_self] = counter; + ctx->local_counter[active_workers - 1][test][worker_index] = counter; +} + +static void test_6_fini( + rtems_test_parallel_context *base, + void *arg, + size_t active_workers +) +{ + test_context *ctx = (test_context *) base; + + test_fini( + ctx, + "LocalTicketLockWithGlobalCounter", + 6, + active_workers + ); } static void test_7_body( - int test, - global_context *ctx, - SMP_barrier_State *bs, - unsigned int cpu_count, - unsigned int cpu_self + rtems_test_parallel_context *base, + void *arg, + size_t active_workers, + size_t worker_index ) { + test_context *ctx = (test_context *) base; + size_t test = 7; unsigned long counter = 0; #if defined(RTEMS_PROFILING) SMP_lock_Stats stats; @@ -296,7 +410,7 @@ static void test_7_body( _SMP_lock_Stats_initialize(&stats, "local"); _SMP_MCS_lock_Initialize(&lock); - while (assert_state(ctx, START_TEST)) { + while (!rtems_test_parallel_stop_job(&ctx->base)) { _SMP_MCS_lock_Acquire(&lock, &lock_context, &stats); /* The counter value is not interesting, only the access to it */ @@ -309,7 +423,23 @@ static void test_7_body( _SMP_MCS_lock_Destroy(&lock); _SMP_lock_Stats_destroy(&stats); - ctx->test_counter[test][cpu_self] = counter; + ctx->local_counter[active_workers - 1][test][worker_index] = counter; +} + +static void test_7_fini( + rtems_test_parallel_context *base, + void *arg, + size_t active_workers +) +{ + test_context *ctx = (test_context *) base; + + test_fini( + ctx, + "LocalMCSLockWithGlobalCounter", + 7, + active_workers + ); } static void busy_section(void) @@ -322,60 +452,95 @@ static void busy_section(void) } static void test_8_body( - int test, - global_context *ctx, - SMP_barrier_State *bs, - unsigned int cpu_count, - unsigned int cpu_self + rtems_test_parallel_context *base, + void *arg, + size_t active_workers, + size_t worker_index ) { + test_context *ctx = (test_context *) base; + size_t test = 8; unsigned long counter = 0; SMP_lock_Context lock_context; - while (assert_state(ctx, START_TEST)) { + while (!rtems_test_parallel_stop_job(&ctx->base)) { _SMP_lock_Acquire(&ctx->lock, &lock_context); busy_section(); _SMP_lock_Release(&ctx->lock, &lock_context); ++counter; } - ctx->test_counter[test][cpu_self] = counter; + ctx->local_counter[active_workers - 1][test][worker_index] = counter; +} + +static void test_8_fini( + rtems_test_parallel_context *base, + void *arg, + size_t active_workers +) +{ + test_context *ctx = (test_context *) base; + + test_fini( + ctx, + "GlobalTicketLockWithBusySection", + 8, + active_workers + ); } static void test_9_body( - int test, - global_context *ctx, - SMP_barrier_State *bs, - unsigned int cpu_count, - unsigned int cpu_self + rtems_test_parallel_context *base, + void *arg, + size_t active_workers, + size_t worker_index ) { + test_context *ctx = (test_context *) base; + size_t test = 9; unsigned long counter = 0; SMP_MCS_lock_Context lock_context; - while (assert_state(ctx, START_TEST)) { + while (!rtems_test_parallel_stop_job(&ctx->base)) { _SMP_MCS_lock_Acquire(&ctx->mcs_lock, &lock_context, &ctx->mcs_stats); busy_section(); _SMP_MCS_lock_Release(&ctx->mcs_lock, &lock_context); ++counter; } - ctx->test_counter[test][cpu_self] = counter; + ctx->local_counter[active_workers - 1][test][worker_index] = counter; +} + +static void test_9_fini( + rtems_test_parallel_context *base, + void *arg, + size_t active_workers +) +{ + test_context *ctx = (test_context *) base; + + test_fini( + ctx, + "GlobalMCSLockWithBusySection", + 9, + active_workers + ); } static void test_10_body( - int test, - global_context *ctx, - SMP_barrier_State *bs, - unsigned int cpu_count, - unsigned int cpu_self + rtems_test_parallel_context *base, + void *arg, + size_t active_workers, + size_t worker_index ) { + test_context *ctx = (test_context *) base; + size_t test = 10; unsigned long counter = 0; unsigned long seq; - if (cpu_self == 0) { - while (assert_state(ctx, START_TEST)) { + if (rtems_test_parallel_is_master_worker(worker_index)) { + while (!rtems_test_parallel_stop_job(&ctx->base)) { seq = _SMP_sequence_lock_Write_begin(&ctx->seq_lock); ctx->a = counter; @@ -386,7 +551,7 @@ static void test_10_body( ++counter; } } else { - while (assert_state(ctx, START_TEST)) { + while (!rtems_test_parallel_stop_job(&ctx->base)) { unsigned long a; unsigned long b; @@ -403,129 +568,92 @@ static void test_10_body( } } - ctx->test_counter[test][cpu_self] = counter; + ctx->local_counter[active_workers - 1][test][worker_index] = counter; } -static const test_body test_bodies[TEST_COUNT] = { - test_0_body, - test_1_body, - test_2_body, - test_3_body, - test_4_body, - test_5_body, - test_6_body, - test_7_body, - test_8_body, - test_9_body, - test_10_body -}; - -static void run_tests( - global_context *ctx, - SMP_barrier_State *bs, - unsigned int cpu_count, - unsigned int cpu_self, - bool master +static void test_10_fini( + rtems_test_parallel_context *base, + void *arg, + size_t active_workers ) { - int test; - - for (test = 0; test < TEST_COUNT; ++test) { - _SMP_barrier_Wait(&ctx->barrier, bs, cpu_count); - - if (master) { - rtems_status_code sc = rtems_timer_fire_after( - ctx->timer_id, - ctx->timeout, - stop_test_timer, - ctx - ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); - - _Atomic_Store_uint(&ctx->state, START_TEST, ATOMIC_ORDER_RELEASE); - } - - wait_for_state(ctx, START_TEST); - - (*test_bodies[test])(test, ctx, bs, cpu_count, cpu_self); - } - - _SMP_barrier_Wait(&ctx->barrier, bs, cpu_count); + test_context *ctx = (test_context *) base; + + test_fini( + ctx, + "SequenceLock", + 10, + active_workers + ); } -static void task(rtems_task_argument arg) -{ - global_context *ctx = (global_context *) arg; - uint32_t cpu_count = rtems_get_processor_count(); - uint32_t cpu_self = rtems_get_current_processor(); - rtems_status_code sc; - SMP_barrier_State bs = SMP_BARRIER_STATE_INITIALIZER; - - run_tests(ctx, &bs, cpu_count, cpu_self, false); - - sc = rtems_task_suspend(RTEMS_SELF); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); -} +static const rtems_test_parallel_job test_jobs[TEST_COUNT] = { + { + .init = test_init, + .body = test_0_body, + .fini = test_0_fini, + .cascade = true + }, { + .init = test_init, + .body = test_1_body, + .fini = test_1_fini, + .cascade = true + }, { + .init = test_init, + .body = test_2_body, + .fini = test_2_fini, + .cascade = false + }, { + .init = test_init, + .body = test_3_body, + .fini = test_3_fini, + .cascade = false + }, { + .init = test_init, + .body = test_4_body, + .fini = test_4_fini, + .cascade = true + }, { + .init = test_init, + .body = test_5_body, + .fini = test_5_fini, + .cascade = true + }, { + .init = test_init, + .body = test_6_body, + .fini = test_6_fini, + .cascade = false + }, { + .init = test_init, + .body = test_7_body, + .fini = test_7_fini, + .cascade = false + }, { + .init = test_init, + .body = test_8_body, + .fini = test_8_fini, + .cascade = false + }, { + .init = test_init, + .body = test_9_body, + .fini = test_9_fini, + .cascade = false + }, { + .init = test_init, + .body = test_10_body, + .fini = test_10_fini, + .cascade = false + } +}; static void test(void) { - global_context *ctx = &context; - uint32_t cpu_count = rtems_get_processor_count(); - uint32_t cpu_self = rtems_get_current_processor(); - uint32_t cpu; - int test; - rtems_status_code sc; - SMP_barrier_State bs = SMP_BARRIER_STATE_INITIALIZER; - - for (cpu = 0; cpu < cpu_count; ++cpu) { - if (cpu != cpu_self) { - rtems_id task_id; - - sc = rtems_task_create( - rtems_build_name('T', 'A', 'S', 'K'), - TASK_PRIORITY, - RTEMS_MINIMUM_STACK_SIZE, - RTEMS_DEFAULT_MODES, - RTEMS_DEFAULT_ATTRIBUTES, - &task_id - ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); - - sc = rtems_task_start(task_id, task, (rtems_task_argument) ctx); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); - } - } - - ctx->timeout = 5 * rtems_clock_get_ticks_per_second(); - - sc = rtems_timer_create(rtems_build_name('T', 'I', 'M', 'R'), &ctx->timer_id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + test_context *ctx = &test_instance; + const char *test = "SMPLock01"; - run_tests(ctx, &bs, cpu_count, cpu_self, true); - - for (test = 0; test < TEST_COUNT; ++test) { - unsigned long sum = 0; - - printf("%s\n", test_names[test]); - - for (cpu = 0; cpu < cpu_count; ++cpu) { - unsigned long local_counter = ctx->test_counter[test][cpu]; - - sum += local_counter; - - printf( - "\tprocessor %" PRIu32 ", local counter %lu\n", - cpu, - local_counter - ); - } - - printf( - "\tglobal counter %lu, sum of local counter %lu\n", - ctx->counter[test], - sum - ); - } + printf("<%s>\n", test); + rtems_test_parallel(&ctx->base, NULL, &test_jobs[0], TEST_COUNT); + printf("\n", test); } static void Init(rtems_task_argument arg) diff --git a/testsuites/smptests/smplock01/smplock01.py b/testsuites/smptests/smplock01/smplock01.py new file mode 100644 index 0000000000..f8189f32ff --- /dev/null +++ b/testsuites/smptests/smplock01/smplock01.py @@ -0,0 +1,32 @@ +#!/usr/bin/env python + +# +# Copyright (c) 2016 embedded brains GmbH. All rights reserved. +# +# The license and distribution terms for this file may be +# found in the file LICENSE in this distribution or at +# http://www.rtems.org/license/LICENSE. +# + +import re +import libxml2 +from libxml2 import xmlNode +import matplotlib.pyplot as plt +data = open('smplock01.scn').read() +data = re.sub(r'\*\*\*.*\*\*\*', '', data) +doc = libxml2.parseDoc(data) +ctx = doc.xpathNewContext() + +plt.title('SMP Lock Performance') +plt.xlabel('Active Workers') +plt.ylabel('Operation Count') + +y = map(xmlNode.getContent, ctx.xpathEval('/SMPLock01/GlobalTicketLockWithLocalCounter/SumOfLocalCounter')) +x = range(1, len(y) + 1) +plt.plot(x, y, label = 'Global Ticket Lock') + +y = map(xmlNode.getContent, ctx.xpathEval('/SMPLock01/GlobalMCSLockWithLocalCounter/SumOfLocalCounter')) +plt.plot(x, y, label = 'Global MCS Lock') + +plt.legend(loc = 'best') +plt.show() diff --git a/testsuites/smptests/smplock01/smplock01.scn b/testsuites/smptests/smplock01/smplock01.scn index b13bab0e45..03b2af32af 100644 --- a/testsuites/smptests/smplock01/smplock01.scn +++ b/testsuites/smptests/smplock01/smplock01.scn @@ -1,288 +1,1784 @@ *** BEGIN OF TEST SMPLOCK 1 *** -global ticket lock with local counter - processor 0, local counter 830091 - processor 1, local counter 830090 - processor 2, local counter 830091 - processor 3, local counter 830091 - processor 4, local counter 830091 - processor 5, local counter 830091 - processor 6, local counter 830091 - processor 7, local counter 830091 - processor 8, local counter 830089 - processor 9, local counter 830088 - processor 10, local counter 830090 - processor 11, local counter 830090 - processor 12, local counter 830090 - processor 13, local counter 830092 - processor 14, local counter 830093 - processor 15, local counter 830092 - processor 16, local counter 830092 - processor 17, local counter 830092 - processor 18, local counter 830089 - processor 19, local counter 830092 - processor 20, local counter 830090 - processor 21, local counter 830090 - processor 22, local counter 830090 - processor 23, local counter 830092 - global counter 0, sum of local counter 19922178 -global MCS lock with local counter - processor 0, local counter 1579723 - processor 1, local counter 1580054 - processor 2, local counter 1579890 - processor 3, local counter 1579777 - processor 4, local counter 1579884 - processor 5, local counter 1580005 - processor 6, local counter 1578632 - processor 7, local counter 1578637 - processor 8, local counter 1578774 - processor 9, local counter 1578759 - processor 10, local counter 1580282 - processor 11, local counter 1579885 - processor 12, local counter 1580378 - processor 13, local counter 1580043 - processor 14, local counter 1580115 - processor 15, local counter 1580113 - processor 16, local counter 1579911 - processor 17, local counter 1579993 - processor 18, local counter 1580032 - processor 19, local counter 1579588 - processor 20, local counter 1580049 - processor 21, local counter 1580048 - processor 22, local counter 1578484 - processor 23, local counter 1580013 - global counter 0, sum of local counter 37913069 -global ticket lock with global counter - processor 0, local counter 784729 - processor 1, local counter 784730 - processor 2, local counter 784730 - processor 3, local counter 784730 - processor 4, local counter 784731 - processor 5, local counter 784730 - processor 6, local counter 784731 - processor 7, local counter 784730 - processor 8, local counter 784731 - processor 9, local counter 784729 - processor 10, local counter 784729 - processor 11, local counter 784730 - processor 12, local counter 784731 - processor 13, local counter 784729 - processor 14, local counter 784728 - processor 15, local counter 784730 - processor 16, local counter 784729 - processor 17, local counter 784730 - processor 18, local counter 784730 - processor 19, local counter 784729 - processor 20, local counter 784729 - processor 21, local counter 784729 - processor 22, local counter 784729 - processor 23, local counter 784731 - global counter 18833514, sum of local counter 18833514 -global MCS lock with global counter - processor 0, local counter 947856 - processor 1, local counter 947857 - processor 2, local counter 947857 - processor 3, local counter 947855 - processor 4, local counter 947858 - processor 5, local counter 947857 - processor 6, local counter 947856 - processor 7, local counter 947856 - processor 8, local counter 947856 - processor 9, local counter 947856 - processor 10, local counter 947857 - processor 11, local counter 947856 - processor 12, local counter 947855 - processor 13, local counter 947857 - processor 14, local counter 947857 - processor 15, local counter 947855 - processor 16, local counter 947856 - processor 17, local counter 947855 - processor 18, local counter 947858 - processor 19, local counter 947857 - processor 20, local counter 947858 - processor 21, local counter 947857 - processor 22, local counter 947857 - processor 23, local counter 947857 - global counter 22748556, sum of local counter 22748556 -local ticket lock with local counter - processor 0, local counter 77155869 - processor 1, local counter 77158831 - processor 2, local counter 77081105 - processor 3, local counter 77082737 - processor 4, local counter 77075777 - processor 5, local counter 77076154 - processor 6, local counter 77065268 - processor 7, local counter 77066500 - processor 8, local counter 77106686 - processor 9, local counter 77107321 - processor 10, local counter 77060207 - processor 11, local counter 77062079 - processor 12, local counter 77059638 - processor 13, local counter 77059931 - processor 14, local counter 77056750 - processor 15, local counter 77057813 - processor 16, local counter 76659137 - processor 17, local counter 76659205 - processor 18, local counter 76669140 - processor 19, local counter 76670415 - processor 20, local counter 76674221 - processor 21, local counter 76674630 - processor 22, local counter 76434805 - processor 23, local counter 76434361 - global counter 0, sum of local counter 1846208580 -local MCS lock with local counter - processor 0, local counter 44963740 - processor 1, local counter 45045357 - processor 2, local counter 45023035 - processor 3, local counter 45021994 - processor 4, local counter 44912701 - processor 5, local counter 44951749 - processor 6, local counter 45090697 - processor 7, local counter 45089463 - processor 8, local counter 45015619 - processor 9, local counter 45088716 - processor 10, local counter 45064955 - processor 11, local counter 45063568 - processor 12, local counter 44966963 - processor 13, local counter 45002743 - processor 14, local counter 45127830 - processor 15, local counter 45126512 - processor 16, local counter 44947194 - processor 17, local counter 44992882 - processor 18, local counter 45006760 - processor 19, local counter 45005553 - processor 20, local counter 44880447 - processor 21, local counter 44889042 - processor 22, local counter 45036454 - processor 23, local counter 45036288 - global counter 0, sum of local counter 1080350262 -local ticket lock with global counter - processor 0, local counter 3962116 - processor 1, local counter 3963441 - processor 2, local counter 3963482 - processor 3, local counter 3963367 - processor 4, local counter 3962978 - processor 5, local counter 3963102 - processor 6, local counter 3962979 - processor 7, local counter 3962911 - processor 8, local counter 3962974 - processor 9, local counter 3963125 - processor 10, local counter 3963056 - processor 11, local counter 3963093 - processor 12, local counter 3962996 - processor 13, local counter 3963100 - processor 14, local counter 3963096 - processor 15, local counter 3963028 - processor 16, local counter 3967076 - processor 17, local counter 3967251 - processor 18, local counter 3967222 - processor 19, local counter 3967093 - processor 20, local counter 3972862 - processor 21, local counter 3972917 - processor 22, local counter 3967217 - processor 23, local counter 3967220 - global counter 7095791, sum of local counter 95157702 -local MCS lock with global counter - processor 0, local counter 3849478 - processor 1, local counter 3860113 - processor 2, local counter 3966891 - processor 3, local counter 3966750 - processor 4, local counter 3973618 - processor 5, local counter 4014013 - processor 6, local counter 3914674 - processor 7, local counter 3914601 - processor 8, local counter 3910536 - processor 9, local counter 3924908 - processor 10, local counter 3995362 - processor 11, local counter 3995130 - processor 12, local counter 3909912 - processor 13, local counter 3923977 - processor 14, local counter 3995941 - processor 15, local counter 3995667 - processor 16, local counter 3842753 - processor 17, local counter 3852728 - processor 18, local counter 3956029 - processor 19, local counter 3955977 - processor 20, local counter 3961870 - processor 21, local counter 4001067 - processor 22, local counter 3911767 - processor 23, local counter 3911724 - global counter 8503087, sum of local counter 94505486 -global ticket lock with busy section - processor 0, local counter 614377 - processor 1, local counter 614376 - processor 2, local counter 614377 - processor 3, local counter 614377 - processor 4, local counter 614377 - processor 5, local counter 614378 - processor 6, local counter 614377 - processor 7, local counter 614377 - processor 8, local counter 614377 - processor 9, local counter 614376 - processor 10, local counter 614378 - processor 11, local counter 614377 - processor 12, local counter 614377 - processor 13, local counter 614377 - processor 14, local counter 614377 - processor 15, local counter 614376 - processor 16, local counter 614377 - processor 17, local counter 614377 - processor 18, local counter 614377 - processor 19, local counter 614378 - processor 20, local counter 614378 - processor 21, local counter 614377 - processor 22, local counter 614377 - processor 23, local counter 614377 - global counter 0, sum of local counter 14745049 -global MCS lock with busy section - processor 0, local counter 552660 - processor 1, local counter 552661 - processor 2, local counter 552659 - processor 3, local counter 552659 - processor 4, local counter 552660 - processor 5, local counter 552659 - processor 6, local counter 552659 - processor 7, local counter 552660 - processor 8, local counter 552660 - processor 9, local counter 552660 - processor 10, local counter 552660 - processor 11, local counter 552659 - processor 12, local counter 552660 - processor 13, local counter 552659 - processor 14, local counter 552660 - processor 15, local counter 552661 - processor 16, local counter 552660 - processor 17, local counter 552659 - processor 18, local counter 552660 - processor 19, local counter 552661 - processor 20, local counter 552660 - processor 21, local counter 552661 - processor 22, local counter 552660 - processor 23, local counter 552661 - global counter 0, sum of local counter 13263838 -sequence lock - processor 0, local counter 12138641 - processor 1, local counter 8 - processor 2, local counter 64 - processor 3, local counter 89 - processor 4, local counter 208 - processor 5, local counter 227 - processor 6, local counter 69 - processor 7, local counter 82 - processor 8, local counter 2019 - processor 9, local counter 2017 - processor 10, local counter 1914 - processor 11, local counter 2008 - processor 12, local counter 1890 - processor 13, local counter 1902 - processor 14, local counter 1734 - processor 15, local counter 1701 - processor 16, local counter 2198 - processor 17, local counter 2176 - processor 18, local counter 2011 - processor 19, local counter 2047 - processor 20, local counter 2072 - processor 21, local counter 2084 - processor 22, local counter 1866 - processor 23, local counter 1849 - global counter 0, sum of local counter 12170876 + + + 18398214 + 0 + 18398214 + + + 3818444 + 3818595 + 0 + 7637039 + + + 1919976 + 1919985 + 1919953 + 0 + 5759914 + + + 1487437 + 1487431 + 1487432 + 1487421 + 0 + 5949721 + + + 1148919 + 1148898 + 1148900 + 1148852 + 1148909 + 0 + 5744478 + + + 930242 + 930202 + 930199 + 930184 + 930181 + 930230 + 0 + 5581238 + + + 779079 + 778991 + 778995 + 778990 + 778981 + 778985 + 778987 + 0 + 5453008 + + + 654604 + 651632 + 651569 + 651546 + 651563 + 651567 + 651596 + 653615 + 0 + 5217692 + + + 534418 + 534312 + 534314 + 534304 + 534309 + 534304 + 534311 + 534303 + 534309 + 0 + 4808884 + + + 472000 + 470376 + 470345 + 470334 + 470373 + 470401 + 470374 + 470391 + 470370 + 472016 + 0 + 4706980 + + + 429615 + 428935 + 428953 + 428926 + 428906 + 428880 + 428914 + 428898 + 428907 + 429584 + 429584 + 0 + 4720102 + + + 386115 + 385629 + 385643 + 385644 + 385621 + 385630 + 385638 + 385615 + 385627 + 386087 + 386088 + 386095 + 0 + 4629432 + + + 352696 + 352413 + 352429 + 352421 + 352419 + 352411 + 352423 + 352409 + 352415 + 352661 + 352666 + 352666 + 352660 + 0 + 4582689 + + + 324515 + 324378 + 324389 + 324381 + 324382 + 324372 + 324380 + 324380 + 324370 + 324483 + 324482 + 324482 + 324479 + 324509 + 0 + 4541982 + + + 301306 + 301217 + 301212 + 301217 + 301219 + 301218 + 301213 + 301212 + 301215 + 301273 + 301271 + 301274 + 301273 + 301270 + 301270 + 0 + 4518660 + + + 282744 + 282629 + 282622 + 282627 + 282620 + 282617 + 282616 + 282618 + 282624 + 282662 + 282664 + 282663 + 282662 + 282658 + 282662 + 282693 + 0 + 4522381 + + + 259579 + 259524 + 259529 + 259530 + 259529 + 259532 + 259530 + 259536 + 259529 + 259533 + 259527 + 259529 + 259533 + 259527 + 259528 + 259524 + 259536 + 0 + 4412055 + + + 239835 + 239813 + 239814 + 239810 + 239811 + 239817 + 239813 + 239814 + 239815 + 239816 + 239815 + 239813 + 239813 + 239817 + 239813 + 239812 + 239811 + 239834 + 0 + 4316686 + + + 223254 + 223225 + 223227 + 223222 + 223224 + 223223 + 223220 + 223216 + 223217 + 223222 + 223219 + 223221 + 223223 + 223225 + 223219 + 223222 + 223223 + 223249 + 223251 + 0 + 4241302 + + + 213739 + 213709 + 213708 + 213708 + 213707 + 213710 + 213708 + 213710 + 213708 + 213710 + 213710 + 213710 + 213711 + 213714 + 213714 + 213708 + 213710 + 213732 + 213734 + 213735 + 0 + 4274295 + + + 198998 + 198980 + 198986 + 198983 + 198981 + 198983 + 198983 + 198981 + 198981 + 198983 + 198982 + 198981 + 198982 + 198983 + 198984 + 198984 + 198982 + 198992 + 198994 + 198993 + 198995 + 0 + 4178691 + + + 192361 + 192346 + 192349 + 192348 + 192348 + 192350 + 192346 + 192349 + 192348 + 192346 + 192346 + 192345 + 192346 + 192348 + 192346 + 192347 + 192350 + 192356 + 192355 + 192357 + 192356 + 192358 + 0 + 4231701 + + + 176769 + 176761 + 176760 + 176759 + 176760 + 176757 + 176759 + 176758 + 176759 + 176759 + 176759 + 176760 + 176758 + 176758 + 176760 + 176759 + 176757 + 176761 + 176763 + 176760 + 176762 + 176763 + 176762 + 0 + 4065483 + + + 164847 + 164844 + 164845 + 164845 + 164846 + 164844 + 164846 + 164845 + 164845 + 164845 + 164846 + 164844 + 164846 + 164846 + 164846 + 164845 + 164846 + 164846 + 164847 + 164845 + 164845 + 164845 + 164846 + 164846 + 0 + 3956291 + + + 13057243 + 0 + 13057243 + + + 1266595 + 1266587 + 0 + 2533182 + + + 1806557 + 1806541 + 1806556 + 0 + 5419654 + + + 1799359 + 1799355 + 1799361 + 1799358 + 0 + 7197433 + + + 1809548 + 1809543 + 1809545 + 1809547 + 1809545 + 0 + 9047728 + + + 1572945 + 1572938 + 1572941 + 1572942 + 1572941 + 1572939 + 0 + 9437646 + + + 1488244 + 1488238 + 1488242 + 1488243 + 1488241 + 1488240 + 1488242 + 0 + 10417690 + + + 1326735 + 1326731 + 1326732 + 1326732 + 1326730 + 1326731 + 1326733 + 1326732 + 0 + 10613856 + + + 1227563 + 1227561 + 1227561 + 1227562 + 1227558 + 1227561 + 1227561 + 1227562 + 1227559 + 0 + 11048048 + + + 894577 + 894574 + 894575 + 894576 + 894575 + 894575 + 894576 + 894575 + 894575 + 894575 + 0 + 8945753 + + + 791584 + 791584 + 791583 + 791582 + 791584 + 791582 + 791584 + 791582 + 791583 + 791583 + 791584 + 0 + 8707415 + + + 700121 + 700119 + 700118 + 700118 + 700117 + 700117 + 700119 + 700119 + 700118 + 700118 + 700119 + 700118 + 0 + 8401421 + + + 612928 + 612926 + 612925 + 612927 + 612925 + 612925 + 612925 + 612925 + 612924 + 612925 + 612926 + 612926 + 612925 + 0 + 7968032 + + + 615640 + 615637 + 615638 + 615638 + 615637 + 615636 + 615637 + 615636 + 615633 + 615638 + 615638 + 615637 + 615637 + 615635 + 0 + 8618917 + + + 494010 + 494005 + 494007 + 494003 + 494006 + 494003 + 494003 + 494003 + 494005 + 494002 + 494006 + 494005 + 494004 + 494002 + 494003 + 0 + 7410067 + + + 452311 + 452308 + 452307 + 452304 + 452306 + 452306 + 452306 + 452305 + 452306 + 452305 + 452308 + 452302 + 452304 + 452307 + 452305 + 452307 + 0 + 7236897 + + + 411836 + 411832 + 411832 + 411831 + 411830 + 411830 + 411835 + 411833 + 411830 + 411832 + 411833 + 411829 + 411833 + 411833 + 411831 + 411833 + 411828 + 0 + 7001141 + + + 467016 + 466996 + 467001 + 466994 + 466989 + 466986 + 466991 + 466994 + 466973 + 466976 + 466993 + 466996 + 467008 + 467005 + 466998 + 467002 + 466990 + 467009 + 0 + 8405917 + + + 370400 + 370402 + 370401 + 370408 + 370401 + 370404 + 370404 + 370410 + 370410 + 370403 + 370399 + 370408 + 370401 + 370399 + 370401 + 370398 + 370401 + 370396 + 370396 + 0 + 7037642 + + + 391059 + 392308 + 392294 + 392312 + 392291 + 392348 + 392321 + 392268 + 392312 + 392486 + 392486 + 392471 + 392499 + 392452 + 392467 + 392478 + 392436 + 390882 + 390899 + 390972 + 0 + 7842041 + + + 318394 + 332823 + 332655 + 332725 + 332890 + 333114 + 332973 + 332994 + 332878 + 334457 + 334487 + 334425 + 334507 + 334550 + 334514 + 334366 + 334029 + 317461 + 317374 + 317671 + 318126 + 0 + 6927413 + + + 331955 + 341916 + 341888 + 342280 + 343635 + 343767 + 343948 + 343914 + 343375 + 343501 + 343454 + 343316 + 343271 + 343456 + 343351 + 343245 + 341111 + 329097 + 329162 + 329303 + 331236 + 332000 + 0 + 7472181 + + + 308389 + 309721 + 309624 + 309655 + 310504 + 310414 + 310534 + 310443 + 310415 + 310215 + 310278 + 310266 + 310079 + 310083 + 309887 + 310072 + 309153 + 307219 + 307158 + 307167 + 307747 + 307966 + 307630 + 0 + 7114619 + + + 294282 + 294274 + 294265 + 294275 + 294278 + 294265 + 294278 + 294277 + 294265 + 294270 + 294267 + 294273 + 294257 + 294271 + 294274 + 294277 + 294270 + 294269 + 294271 + 294268 + 294267 + 294276 + 294276 + 294269 + 0 + 7062514 + + + 149135 + 149134 + 149134 + 149134 + 149135 + 149134 + 149134 + 149135 + 149134 + 149134 + 149134 + 149135 + 149134 + 149135 + 149135 + 149134 + 149134 + 149136 + 149135 + 149134 + 149135 + 149134 + 149134 + 149134 + 3579226 + 3579226 + + + 172181 + 172178 + 172178 + 172178 + 172180 + 172180 + 172179 + 172179 + 172180 + 172179 + 172179 + 172180 + 172180 + 172178 + 172179 + 172179 + 172179 + 172178 + 172179 + 172180 + 172178 + 172180 + 172179 + 172178 + 4132298 + 4132298 + + + 18652007 + 0 + 18652007 + + + 18740564 + 18739964 + 0 + 37480528 + + + 18653030 + 18122134 + 18122915 + 0 + 54898079 + + + 18565582 + 17190377 + 17191117 + 17190756 + 0 + 70137832 + + + 18665586 + 16212891 + 16213673 + 16081746 + 16081213 + 0 + 83255109 + + + 18578108 + 16296115 + 16296806 + 15747768 + 15747301 + 16956328 + 0 + 99622426 + + + 18678200 + 15992304 + 15993081 + 15841718 + 15841348 + 15959344 + 15960072 + 0 + 114266067 + + + 18589106 + 15875999 + 15876649 + 15818065 + 15815412 + 15846763 + 15847293 + 15916120 + 0 + 129585407 + + + 18689087 + 15546911 + 15547569 + 15455961 + 15455418 + 15496903 + 15497497 + 15447033 + 15446640 + 0 + 142583019 + + + 18601625 + 15394303 + 15394892 + 15291311 + 15290941 + 15381054 + 15381638 + 15323738 + 15323464 + 18600921 + 0 + 159983887 + + + 18700020 + 15533741 + 15534221 + 15404627 + 15404204 + 15487953 + 15488572 + 15400441 + 15399985 + 18154320 + 18155089 + 0 + 178663173 + + + 18610943 + 15473224 + 15473800 + 15368894 + 15368360 + 15480650 + 15481411 + 15336787 + 15336385 + 17196268 + 17197013 + 17196671 + 0 + 193520406 + + + 18709295 + 15557477 + 15558120 + 15469686 + 15469124 + 15504119 + 15504781 + 15472427 + 15472039 + 16307092 + 16307904 + 16131731 + 16131316 + 0 + 207595111 + + + 18620298 + 15450048 + 15450641 + 15348671 + 15348185 + 15447477 + 15448127 + 15373177 + 15372740 + 16256377 + 16257208 + 15596231 + 15595801 + 17067834 + 0 + 222632815 + + + 18718604 + 15566735 + 15567272 + 15480329 + 15479757 + 15546455 + 15547082 + 15465925 + 15465579 + 16056473 + 16057260 + 15873190 + 15872808 + 16031509 + 16032179 + 0 + 238761157 + + + 18629493 + 15433606 + 15434095 + 15364110 + 15363692 + 15423461 + 15424149 + 15354320 + 15353874 + 15878044 + 15878765 + 15833258 + 15832744 + 15862126 + 15862781 + 15931680 + 0 + 252860198 + + + 18727849 + 15496672 + 15497263 + 15410632 + 15410094 + 15474278 + 15474890 + 15414881 + 15414414 + 15540994 + 15541641 + 15473973 + 15473463 + 15532322 + 15532896 + 15445168 + 15444816 + 0 + 266306246 + + + 17928143 + 15385654 + 15386165 + 15317188 + 15316670 + 15362234 + 15362933 + 15274058 + 15273688 + 15520890 + 15521466 + 15415491 + 15414935 + 15485859 + 15486443 + 15398657 + 15398314 + 17927656 + 0 + 282176444 + + + 17613429 + 15606024 + 15606469 + 15506465 + 15505964 + 15570703 + 15571382 + 15514428 + 15514060 + 15578430 + 15578956 + 15476117 + 15475709 + 15518932 + 15519675 + 15469292 + 15468941 + 17612809 + 17613528 + 0 + 301321313 + + + 17132843 + 15467671 + 15468243 + 15355941 + 15355528 + 15430531 + 15431151 + 15388106 + 15387790 + 15532317 + 15532901 + 15419252 + 15418798 + 15488804 + 15489381 + 15448508 + 15448083 + 17110297 + 17110974 + 17132347 + 0 + 315549466 + + + 16916206 + 15348829 + 15349378 + 15301237 + 15300660 + 15352077 + 15352792 + 15295586 + 15295234 + 15406432 + 15407215 + 15288387 + 15287834 + 15387376 + 15388065 + 15288287 + 15287963 + 16326915 + 16327566 + 16106693 + 16106335 + 0 + 327121067 + + + 16836742 + 15449539 + 15450118 + 15316318 + 15315967 + 15414143 + 15414873 + 15315456 + 15315048 + 15419186 + 15419737 + 15374010 + 15373492 + 15396609 + 15397385 + 15336581 + 15336218 + 16132164 + 16132817 + 15836470 + 15835949 + 16836521 + 0 + 343655343 + + + 16291232 + 15428041 + 15428655 + 15361817 + 15361312 + 15423987 + 15424704 + 15320451 + 15320015 + 15335989 + 15336602 + 15238353 + 15237888 + 15288964 + 15289713 + 15247179 + 15246800 + 15845200 + 15845834 + 15532883 + 15532415 + 15837390 + 15838022 + 0 + 356013446 + + + 15397914 + 15566890 + 15567438 + 15477547 + 15477033 + 15534538 + 15535180 + 15491695 + 15491372 + 15542761 + 15543394 + 15406366 + 15405826 + 15490798 + 15491494 + 15357829 + 15357479 + 15492383 + 15493044 + 15370471 + 15369857 + 15493139 + 15493629 + 15396639 + 0 + 371244716 + + + 12082959 + 0 + 12082959 + + + 12073288 + 12072981 + 0 + 24146269 + + + 12138406 + 11387467 + 11387966 + 0 + 34913839 + + + 12081451 + 10664115 + 10664607 + 12243261 + 0 + 45653434 + + + 12146609 + 10837665 + 10838107 + 11075941 + 10837795 + 0 + 55736117 + + + 12089675 + 10559924 + 10560425 + 10776034 + 10525391 + 10774845 + 0 + 65286294 + + + 12154687 + 10116784 + 10117227 + 10572633 + 10106234 + 10107965 + 10108427 + 0 + 73283957 + + + 12097857 + 9685901 + 9686270 + 10157156 + 9521302 + 9656650 + 9657039 + 11582770 + 0 + 82044945 + + + 12168151 + 9531826 + 9532173 + 9548152 + 9528324 + 9524184 + 9524626 + 9552042 + 9531793 + 0 + 88441271 + + + 12114395 + 9496439 + 9496720 + 9518493 + 9502427 + 9494644 + 9495062 + 9519993 + 9499030 + 12114111 + 0 + 100251314 + + + 12177360 + 9564657 + 9564923 + 9581460 + 9566647 + 9562022 + 9562428 + 9582352 + 9568441 + 11402504 + 11402957 + 0 + 111535751 + + + 12119476 + 9491442 + 9491786 + 9531107 + 9493390 + 9489365 + 9489758 + 9534422 + 9499933 + 10732309 + 10732783 + 12318345 + 0 + 121924116 + + + 12183361 + 9565165 + 9565455 + 9582604 + 9568538 + 9567760 + 9568161 + 9591184 + 9569765 + 10815689 + 10816130 + 11127405 + 10815691 + 0 + 132336908 + + + 12125462 + 9524915 + 9525201 + 9553382 + 9529788 + 9528364 + 9528814 + 9565861 + 9534294 + 10579374 + 10579805 + 10804186 + 10559267 + 10803938 + 0 + 141742651 + + + 12189465 + 9573943 + 9574374 + 9587321 + 9575449 + 9574838 + 9575216 + 9592097 + 9576771 + 10155658 + 10156093 + 10485978 + 10147342 + 10152197 + 10152655 + 0 + 150069397 + + + 12131505 + 9528313 + 9528627 + 9555655 + 9533873 + 9528420 + 9528806 + 9562116 + 9535204 + 9703506 + 9703941 + 10182457 + 9558198 + 9675351 + 9675784 + 11641089 + 0 + 158572845 + + + 12078841 + 9483353 + 9483735 + 9515396 + 9490017 + 9484411 + 9484807 + 9529365 + 9491485 + 9450709 + 9451029 + 9486607 + 9462696 + 9452474 + 9452839 + 9492193 + 9462094 + 0 + 163752051 + + + 11636388 + 9519555 + 9519856 + 9543401 + 9522497 + 9518968 + 9519332 + 9549730 + 9523584 + 9486041 + 9486390 + 9516448 + 9489905 + 9486483 + 9486864 + 9521185 + 9495104 + 11636084 + 0 + 175457815 + + + 11238520 + 9474877 + 9475285 + 9490895 + 9476567 + 9473480 + 9473849 + 9492630 + 9477676 + 9473855 + 9474244 + 9495034 + 9474186 + 9467731 + 9468228 + 9497539 + 9479597 + 11238069 + 11238469 + 0 + 185380731 + + + 11107013 + 9521584 + 9521960 + 9564977 + 9532128 + 9522954 + 9523296 + 9575090 + 9536475 + 9516989 + 9517312 + 9561659 + 9523097 + 9520017 + 9520401 + 9572744 + 9526636 + 10512248 + 10512713 + 12209345 + 0 + 196898638 + + + 10752935 + 9493202 + 9493496 + 9530851 + 9496285 + 9492053 + 9492366 + 9540724 + 9502382 + 9500543 + 9500935 + 9530543 + 9499016 + 9491779 + 9492142 + 9534216 + 9503606 + 10658376 + 10658781 + 10767856 + 10647666 + 0 + 205579753 + + + 10562721 + 9513544 + 9513904 + 9546975 + 9519487 + 9513233 + 9513599 + 9552592 + 9521671 + 9521235 + 9521661 + 9586145 + 9516100 + 9497783 + 9498107 + 9600924 + 9524532 + 10418128 + 10418533 + 10557157 + 10398032 + 10562124 + 0 + 215378187 + + + 10020531 + 9499389 + 9499749 + 9539918 + 9501002 + 9499387 + 9499718 + 9549295 + 9505903 + 9469095 + 9469462 + 9526032 + 9488043 + 9482123 + 9482578 + 9551048 + 9492329 + 9974833 + 9975234 + 10011108 + 9968749 + 9967105 + 9967536 + 0 + 221940167 + + + 9565647 + 9559731 + 9560104 + 9570849 + 9561554 + 9558504 + 9558927 + 9572162 + 9562182 + 9552179 + 9552550 + 9564991 + 9553751 + 9550482 + 9550928 + 9570603 + 9554636 + 9557198 + 9557558 + 9582834 + 9559094 + 9550291 + 9550671 + 9584758 + 0 + 229462184 + + + 919628 + 915976 + 916014 + 915977 + 915974 + 915968 + 916000 + 915967 + 915980 + 919377 + 919362 + 919368 + 919387 + 919349 + 919362 + 919383 + 919360 + 919503 + 919547 + 919538 + 919531 + 919522 + 919527 + 919283 + 2095665 + 22038883 + + + 862472 + 883424 + 883458 + 963897 + 862708 + 883272 + 883301 + 963959 + 862582 + 892427 + 892442 + 967350 + 865089 + 886256 + 886273 + 970013 + 867177 + 883852 + 883865 + 963960 + 862399 + 883581 + 883619 + 963271 + 1751273 + 21600647 + + + 122982 + 122980 + 122980 + 122981 + 122980 + 122981 + 122980 + 122981 + 122982 + 122980 + 122981 + 122980 + 122980 + 122980 + 122980 + 122981 + 122980 + 122980 + 122980 + 122981 + 122980 + 122980 + 122980 + 122980 + 0 + 2951530 + + + 111505 + 111504 + 111504 + 111504 + 111504 + 111504 + 111505 + 111504 + 111505 + 111503 + 111505 + 111504 + 111505 + 111504 + 111505 + 111504 + 111504 + 111505 + 111505 + 111504 + 111504 + 111504 + 111504 + 111505 + 0 + 2676104 + + + 2440262 + 707 + 735 + 740 + 792 + 772 + 772 + 800 + 752 + 692 + 684 + 678 + 695 + 690 + 692 + 750 + 734 + 38 + 12 + 3 + 12 + 21 + 4 + 1 + 0 + 2452038 + + *** END OF TEST SMPLOCK 1 *** -- cgit v1.2.3