From f2b3a82d7569463cc9b28bdd0943f06984197b6a Mon Sep 17 00:00:00 2001 From: Mathieu Desnoyers Date: Wed, 3 Jun 2009 10:15:45 -0400 Subject: [PATCH] Add Intel ipi urcu model run results Signed-off-by: Mathieu Desnoyers --- .../.input.spin | 1249 ++++++++++++ .../urcu-controldataflow-ipi-intel/DEFINES | 18 + .../urcu-controldataflow-ipi-intel/Makefile | 170 ++ .../asserts.log | 473 +++++ .../asserts.spin.input | 1249 ++++++++++++ .../references.txt | 13 + .../urcu-controldataflow-ipi-intel/urcu.sh | 29 + .../urcu-controldataflow-ipi-intel/urcu.spin | 1231 ++++++++++++ .../urcu_free.log | 484 +++++ .../urcu_free.ltl | 1 + .../urcu_free.spin.input | 1249 ++++++++++++ .../urcu_free_nested.define | 1 + .../urcu_free_no_mb.define | 1 + .../urcu_free_no_mb.log | 624 ++++++ .../urcu_free_no_mb.spin.input | 1250 ++++++++++++ .../urcu_free_no_mb.spin.input.trail | 1304 +++++++++++++ .../urcu_free_no_rmb.define | 1 + .../urcu_free_no_rmb.log | 491 +++++ .../urcu_free_no_rmb.spin.input | 1250 ++++++++++++ .../urcu_free_no_wmb.define | 1 + .../urcu_free_no_wmb.log | 511 +++++ .../urcu_free_no_wmb.spin.input | 1250 ++++++++++++ .../urcu_free_no_wmb.spin.input.trail | 1390 ++++++++++++++ .../urcu_free_single_flip.define | 1 + .../urcu_free_single_flip.log | 678 +++++++ .../urcu_free_single_flip.spin.input | 1250 ++++++++++++ .../urcu_free_single_flip.spin.input.trail | 1257 ++++++++++++ .../urcu_progress.ltl | 1 + .../urcu_progress_reader.define | 1 + .../urcu_progress_reader.log | 535 ++++++ .../urcu_progress_reader.spin.input | 1250 ++++++++++++ .../urcu_progress_writer.define | 1 + .../urcu_progress_writer.log | 519 +++++ .../urcu_progress_writer.spin.input | 1250 ++++++++++++ .../urcu_progress_writer_error.define | 2 + .../urcu_progress_writer_error.log | 498 +++++ .../urcu_progress_writer_error.spin.input | 1251 ++++++++++++ ...rcu_progress_writer_error.spin.input.trail | 1700 +++++++++++++++++ 38 files changed, 24434 insertions(+) create mode 100644 formal-model/results/urcu-controldataflow-ipi-intel/.input.spin create mode 100644 formal-model/results/urcu-controldataflow-ipi-intel/DEFINES create mode 100644 formal-model/results/urcu-controldataflow-ipi-intel/Makefile create mode 100644 formal-model/results/urcu-controldataflow-ipi-intel/asserts.log create mode 100644 formal-model/results/urcu-controldataflow-ipi-intel/asserts.spin.input create mode 100644 formal-model/results/urcu-controldataflow-ipi-intel/references.txt create mode 100644 formal-model/results/urcu-controldataflow-ipi-intel/urcu.sh create mode 100644 formal-model/results/urcu-controldataflow-ipi-intel/urcu.spin create mode 100644 formal-model/results/urcu-controldataflow-ipi-intel/urcu_free.log create mode 100644 formal-model/results/urcu-controldataflow-ipi-intel/urcu_free.ltl create mode 100644 formal-model/results/urcu-controldataflow-ipi-intel/urcu_free.spin.input create mode 100644 formal-model/results/urcu-controldataflow-ipi-intel/urcu_free_nested.define create mode 100644 formal-model/results/urcu-controldataflow-ipi-intel/urcu_free_no_mb.define create mode 100644 formal-model/results/urcu-controldataflow-ipi-intel/urcu_free_no_mb.log create mode 100644 formal-model/results/urcu-controldataflow-ipi-intel/urcu_free_no_mb.spin.input create mode 100644 formal-model/results/urcu-controldataflow-ipi-intel/urcu_free_no_mb.spin.input.trail create mode 100644 formal-model/results/urcu-controldataflow-ipi-intel/urcu_free_no_rmb.define create mode 100644 formal-model/results/urcu-controldataflow-ipi-intel/urcu_free_no_rmb.log create mode 100644 formal-model/results/urcu-controldataflow-ipi-intel/urcu_free_no_rmb.spin.input create mode 100644 formal-model/results/urcu-controldataflow-ipi-intel/urcu_free_no_wmb.define create mode 100644 formal-model/results/urcu-controldataflow-ipi-intel/urcu_free_no_wmb.log create mode 100644 formal-model/results/urcu-controldataflow-ipi-intel/urcu_free_no_wmb.spin.input create mode 100644 formal-model/results/urcu-controldataflow-ipi-intel/urcu_free_no_wmb.spin.input.trail create mode 100644 formal-model/results/urcu-controldataflow-ipi-intel/urcu_free_single_flip.define create mode 100644 formal-model/results/urcu-controldataflow-ipi-intel/urcu_free_single_flip.log create mode 100644 formal-model/results/urcu-controldataflow-ipi-intel/urcu_free_single_flip.spin.input create mode 100644 formal-model/results/urcu-controldataflow-ipi-intel/urcu_free_single_flip.spin.input.trail create mode 100644 formal-model/results/urcu-controldataflow-ipi-intel/urcu_progress.ltl create mode 100644 formal-model/results/urcu-controldataflow-ipi-intel/urcu_progress_reader.define create mode 100644 formal-model/results/urcu-controldataflow-ipi-intel/urcu_progress_reader.log create mode 100644 formal-model/results/urcu-controldataflow-ipi-intel/urcu_progress_reader.spin.input create mode 100644 formal-model/results/urcu-controldataflow-ipi-intel/urcu_progress_writer.define create mode 100644 formal-model/results/urcu-controldataflow-ipi-intel/urcu_progress_writer.log create mode 100644 formal-model/results/urcu-controldataflow-ipi-intel/urcu_progress_writer.spin.input create mode 100644 formal-model/results/urcu-controldataflow-ipi-intel/urcu_progress_writer_error.define create mode 100644 formal-model/results/urcu-controldataflow-ipi-intel/urcu_progress_writer_error.log create mode 100644 formal-model/results/urcu-controldataflow-ipi-intel/urcu_progress_writer_error.spin.input create mode 100644 formal-model/results/urcu-controldataflow-ipi-intel/urcu_progress_writer_error.spin.input.trail diff --git a/formal-model/results/urcu-controldataflow-ipi-intel/.input.spin b/formal-model/results/urcu-controldataflow-ipi-intel/.input.spin new file mode 100644 index 0000000..8afab6a --- /dev/null +++ b/formal-model/results/urcu-controldataflow-ipi-intel/.input.spin @@ -0,0 +1,1249 @@ + +// Poison value for freed memory +#define POISON 1 +// Memory with correct data +#define WINE 0 +#define SLAB_SIZE 2 + +#define read_poison (data_read_first[0] == POISON || data_read_second[0] == POISON) + +#define RCU_GP_CTR_BIT (1 << 7) +#define RCU_GP_CTR_NEST_MASK (RCU_GP_CTR_BIT - 1) + +//disabled +#define REMOTE_BARRIERS + +//#define ARCH_ALPHA +#define ARCH_INTEL +//#define ARCH_POWERPC +/* + * mem.spin: Promela code to validate memory barriers with OOO memory + * and out-of-order instruction scheduling. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * Copyright (c) 2009 Mathieu Desnoyers + */ + +/* Promela validation variables. */ + +/* specific defines "included" here */ +/* DEFINES file "included" here */ + +#define NR_READERS 1 +#define NR_WRITERS 1 + +#define NR_PROCS 2 + +#define get_pid() (_pid) + +#define get_readerid() (get_pid()) + +/* + * Produced process control and data flow. Updated after each instruction to + * show which variables are ready. Using one-hot bit encoding per variable to + * save state space. Used as triggers to execute the instructions having those + * variables as input. Leaving bits active to inhibit instruction execution. + * Scheme used to make instruction disabling and automatic dependency fall-back + * automatic. + */ + +#define CONSUME_TOKENS(state, bits, notbits) \ + ((!(state & (notbits))) && (state & (bits)) == (bits)) + +#define PRODUCE_TOKENS(state, bits) \ + state = state | (bits); + +#define CLEAR_TOKENS(state, bits) \ + state = state & ~(bits) + +/* + * Types of dependency : + * + * Data dependency + * + * - True dependency, Read-after-Write (RAW) + * + * This type of dependency happens when a statement depends on the result of a + * previous statement. This applies to any statement which needs to read a + * variable written by a preceding statement. + * + * - False dependency, Write-after-Read (WAR) + * + * Typically, variable renaming can ensure that this dependency goes away. + * However, if the statements must read and then write from/to the same variable + * in the OOO memory model, renaming may be impossible, and therefore this + * causes a WAR dependency. + * + * - Output dependency, Write-after-Write (WAW) + * + * Two writes to the same variable in subsequent statements. Variable renaming + * can ensure this is not needed, but can be required when writing multiple + * times to the same OOO mem model variable. + * + * Control dependency + * + * Execution of a given instruction depends on a previous instruction evaluating + * in a way that allows its execution. E.g. : branches. + * + * Useful considerations for joining dependencies after branch + * + * - Pre-dominance + * + * "We say box i dominates box j if every path (leading from input to output + * through the diagram) which passes through box j must also pass through box + * i. Thus box i dominates box j if box j is subordinate to box i in the + * program." + * + * http://www.hipersoft.rice.edu/grads/publications/dom14.pdf + * Other classic algorithm to calculate dominance : Lengauer-Tarjan (in gcc) + * + * - Post-dominance + * + * Just as pre-dominance, but with arcs of the data flow inverted, and input vs + * output exchanged. Therefore, i post-dominating j ensures that every path + * passing by j will pass by i before reaching the output. + * + * Other considerations + * + * Note about "volatile" keyword dependency : The compiler will order volatile + * accesses so they appear in the right order on a given CPU. They can be + * reordered by the CPU instruction scheduling. This therefore cannot be + * considered as a depencency. + * + * References : + * + * Cooper, Keith D.; & Torczon, Linda. (2005). Engineering a Compiler. Morgan + * Kaufmann. ISBN 1-55860-698-X. + * Kennedy, Ken; & Allen, Randy. (2001). Optimizing Compilers for Modern + * Architectures: A Dependence-based Approach. Morgan Kaufmann. ISBN + * 1-55860-286-0. + * Muchnick, Steven S. (1997). Advanced Compiler Design and Implementation. + * Morgan Kaufmann. ISBN 1-55860-320-4. + */ + +/* + * Note about loops and nested calls + * + * To keep this model simple, loops expressed in the framework will behave as if + * there was a core synchronizing instruction between loops. To see the effect + * of loop unrolling, manually unrolling loops is required. Note that if loops + * end or start with a core synchronizing instruction, the model is appropriate. + * Nested calls are not supported. + */ + +/* + * Only Alpha has out-of-order cache bank loads. Other architectures (intel, + * powerpc, arm) ensure that dependent reads won't be reordered. c.f. + * http://www.linuxjournal.com/article/8212) +#ifdef ARCH_ALPHA +#define HAVE_OOO_CACHE_READ +#endif + +/* + * Each process have its own data in cache. Caches are randomly updated. + * smp_wmb and smp_rmb forces cache updates (write and read), smp_mb forces + * both. + */ + +typedef per_proc_byte { + byte val[NR_PROCS]; +}; + +typedef per_proc_bit { + bit val[NR_PROCS]; +}; + +/* Bitfield has a maximum of 8 procs */ +typedef per_proc_bitfield { + byte bitfield; +}; + +#define DECLARE_CACHED_VAR(type, x) \ + type mem_##x; \ + per_proc_##type cached_##x; \ + per_proc_bitfield cache_dirty_##x; + +#define INIT_CACHED_VAR(x, v, j) \ + mem_##x = v; \ + cache_dirty_##x.bitfield = 0; \ + j = 0; \ + do \ + :: j < NR_PROCS -> \ + cached_##x.val[j] = v; \ + j++ \ + :: j >= NR_PROCS -> break \ + od; + +#define IS_CACHE_DIRTY(x, id) (cache_dirty_##x.bitfield & (1 << id)) + +#define READ_CACHED_VAR(x) (cached_##x.val[get_pid()]) + +#define WRITE_CACHED_VAR(x, v) \ + atomic { \ + cached_##x.val[get_pid()] = v; \ + cache_dirty_##x.bitfield = \ + cache_dirty_##x.bitfield | (1 << get_pid()); \ + } + +#define CACHE_WRITE_TO_MEM(x, id) \ + if \ + :: IS_CACHE_DIRTY(x, id) -> \ + mem_##x = cached_##x.val[id]; \ + cache_dirty_##x.bitfield = \ + cache_dirty_##x.bitfield & (~(1 << id)); \ + :: else -> \ + skip \ + fi; + +#define CACHE_READ_FROM_MEM(x, id) \ + if \ + :: !IS_CACHE_DIRTY(x, id) -> \ + cached_##x.val[id] = mem_##x;\ + :: else -> \ + skip \ + fi; + +/* + * May update other caches if cache is dirty, or not. + */ +#define RANDOM_CACHE_WRITE_TO_MEM(x, id)\ + if \ + :: 1 -> CACHE_WRITE_TO_MEM(x, id); \ + :: 1 -> skip \ + fi; + +#define RANDOM_CACHE_READ_FROM_MEM(x, id)\ + if \ + :: 1 -> CACHE_READ_FROM_MEM(x, id); \ + :: 1 -> skip \ + fi; + +/* Must consume all prior read tokens. All subsequent reads depend on it. */ +inline smp_rmb(i) +{ + atomic { + CACHE_READ_FROM_MEM(urcu_gp_ctr, get_pid()); + i = 0; + do + :: i < NR_READERS -> + CACHE_READ_FROM_MEM(urcu_active_readers[i], get_pid()); + i++ + :: i >= NR_READERS -> break + od; + CACHE_READ_FROM_MEM(rcu_ptr, get_pid()); + i = 0; + do + :: i < SLAB_SIZE -> + CACHE_READ_FROM_MEM(rcu_data[i], get_pid()); + i++ + :: i >= SLAB_SIZE -> break + od; + } +} + +/* Must consume all prior write tokens. All subsequent writes depend on it. */ +inline smp_wmb(i) +{ + atomic { + CACHE_WRITE_TO_MEM(urcu_gp_ctr, get_pid()); + i = 0; + do + :: i < NR_READERS -> + CACHE_WRITE_TO_MEM(urcu_active_readers[i], get_pid()); + i++ + :: i >= NR_READERS -> break + od; + CACHE_WRITE_TO_MEM(rcu_ptr, get_pid()); + i = 0; + do + :: i < SLAB_SIZE -> + CACHE_WRITE_TO_MEM(rcu_data[i], get_pid()); + i++ + :: i >= SLAB_SIZE -> break + od; + } +} + +/* Synchronization point. Must consume all prior read and write tokens. All + * subsequent reads and writes depend on it. */ +inline smp_mb(i) +{ + atomic { + smp_wmb(i); + smp_rmb(i); + } +} + +#ifdef REMOTE_BARRIERS + +bit reader_barrier[NR_READERS]; + +/* + * We cannot leave the barriers dependencies in place in REMOTE_BARRIERS mode + * because they would add unexisting core synchronization and would therefore + * create an incomplete model. + * Therefore, we model the read-side memory barriers by completely disabling the + * memory barriers and their dependencies from the read-side. One at a time + * (different verification runs), we make a different instruction listen for + * signals. + */ + +#define smp_mb_reader(i, j) + +/* + * Service 0, 1 or many barrier requests. + */ +inline smp_mb_recv(i, j) +{ + do + :: (reader_barrier[get_readerid()] == 1) -> + /* + * We choose to ignore cycles caused by writer busy-looping, + * waiting for the reader, sending barrier requests, and the + * reader always services them without continuing execution. + */ +progress_ignoring_mb1: + smp_mb(i); + reader_barrier[get_readerid()] = 0; + :: 1 -> + /* + * We choose to ignore writer's non-progress caused by the + * reader ignoring the writer's mb() requests. + */ +progress_ignoring_mb2: + break; + od; +} + +#define PROGRESS_LABEL(progressid) progress_writer_progid_##progressid: + +#define smp_mb_send(i, j, progressid) \ +{ \ + smp_mb(i); \ + i = 0; \ + do \ + :: i < NR_READERS -> \ + reader_barrier[i] = 1; \ + /* \ + * Busy-looping waiting for reader barrier handling is of little\ + * interest, given the reader has the ability to totally ignore \ + * barrier requests. \ + */ \ + do \ + :: (reader_barrier[i] == 1) -> \ +PROGRESS_LABEL(progressid) \ + skip; \ + :: (reader_barrier[i] == 0) -> break; \ + od; \ + i++; \ + :: i >= NR_READERS -> \ + break \ + od; \ + smp_mb(i); \ +} + +#else + +#define smp_mb_send(i, j, progressid) smp_mb(i) +#define smp_mb_reader smp_mb(i) +#define smp_mb_recv(i, j) + +#endif + +/* Keep in sync manually with smp_rmb, smp_wmb, ooo_mem and init() */ +DECLARE_CACHED_VAR(byte, urcu_gp_ctr); +/* Note ! currently only one reader */ +DECLARE_CACHED_VAR(byte, urcu_active_readers[NR_READERS]); +/* RCU data */ +DECLARE_CACHED_VAR(bit, rcu_data[SLAB_SIZE]); + +/* RCU pointer */ +#if (SLAB_SIZE == 2) +DECLARE_CACHED_VAR(bit, rcu_ptr); +bit ptr_read_first[NR_READERS]; +bit ptr_read_second[NR_READERS]; +#else +DECLARE_CACHED_VAR(byte, rcu_ptr); +byte ptr_read_first[NR_READERS]; +byte ptr_read_second[NR_READERS]; +#endif + +bit data_read_first[NR_READERS]; +bit data_read_second[NR_READERS]; + +bit init_done = 0; + +inline wait_init_done() +{ + do + :: init_done == 0 -> skip; + :: else -> break; + od; +} + +inline ooo_mem(i) +{ + atomic { + RANDOM_CACHE_WRITE_TO_MEM(urcu_gp_ctr, get_pid()); + i = 0; + do + :: i < NR_READERS -> + RANDOM_CACHE_WRITE_TO_MEM(urcu_active_readers[i], + get_pid()); + i++ + :: i >= NR_READERS -> break + od; + RANDOM_CACHE_WRITE_TO_MEM(rcu_ptr, get_pid()); + i = 0; + do + :: i < SLAB_SIZE -> + RANDOM_CACHE_WRITE_TO_MEM(rcu_data[i], get_pid()); + i++ + :: i >= SLAB_SIZE -> break + od; +#ifdef HAVE_OOO_CACHE_READ + RANDOM_CACHE_READ_FROM_MEM(urcu_gp_ctr, get_pid()); + i = 0; + do + :: i < NR_READERS -> + RANDOM_CACHE_READ_FROM_MEM(urcu_active_readers[i], + get_pid()); + i++ + :: i >= NR_READERS -> break + od; + RANDOM_CACHE_READ_FROM_MEM(rcu_ptr, get_pid()); + i = 0; + do + :: i < SLAB_SIZE -> + RANDOM_CACHE_READ_FROM_MEM(rcu_data[i], get_pid()); + i++ + :: i >= SLAB_SIZE -> break + od; +#else + smp_rmb(i); +#endif /* HAVE_OOO_CACHE_READ */ + } +} + +/* + * Bit encoding, urcu_reader : + */ + +int _proc_urcu_reader; +#define proc_urcu_reader _proc_urcu_reader + +/* Body of PROCEDURE_READ_LOCK */ +#define READ_PROD_A_READ (1 << 0) +#define READ_PROD_B_IF_TRUE (1 << 1) +#define READ_PROD_B_IF_FALSE (1 << 2) +#define READ_PROD_C_IF_TRUE_READ (1 << 3) + +#define PROCEDURE_READ_LOCK(base, consumetoken, producetoken) \ + :: CONSUME_TOKENS(proc_urcu_reader, consumetoken, READ_PROD_A_READ << base) -> \ + ooo_mem(i); \ + tmp = READ_CACHED_VAR(urcu_active_readers[get_readerid()]); \ + PRODUCE_TOKENS(proc_urcu_reader, READ_PROD_A_READ << base); \ + :: CONSUME_TOKENS(proc_urcu_reader, \ + READ_PROD_A_READ << base, /* RAW, pre-dominant */ \ + (READ_PROD_B_IF_TRUE | READ_PROD_B_IF_FALSE) << base) -> \ + if \ + :: (!(tmp & RCU_GP_CTR_NEST_MASK)) -> \ + PRODUCE_TOKENS(proc_urcu_reader, READ_PROD_B_IF_TRUE << base); \ + :: else -> \ + PRODUCE_TOKENS(proc_urcu_reader, READ_PROD_B_IF_FALSE << base); \ + fi; \ + /* IF TRUE */ \ + :: CONSUME_TOKENS(proc_urcu_reader, READ_PROD_B_IF_TRUE << base, \ + READ_PROD_C_IF_TRUE_READ << base) -> \ + ooo_mem(i); \ + tmp2 = READ_CACHED_VAR(urcu_gp_ctr); \ + PRODUCE_TOKENS(proc_urcu_reader, READ_PROD_C_IF_TRUE_READ << base); \ + :: CONSUME_TOKENS(proc_urcu_reader, \ + (READ_PROD_C_IF_TRUE_READ /* pre-dominant */ \ + | READ_PROD_A_READ) << base, /* WAR */ \ + producetoken) -> \ + ooo_mem(i); \ + WRITE_CACHED_VAR(urcu_active_readers[get_readerid()], tmp2); \ + PRODUCE_TOKENS(proc_urcu_reader, producetoken); \ + /* IF_MERGE implies \ + * post-dominance */ \ + /* ELSE */ \ + :: CONSUME_TOKENS(proc_urcu_reader, \ + (READ_PROD_B_IF_FALSE /* pre-dominant */ \ + | READ_PROD_A_READ) << base, /* WAR */ \ + producetoken) -> \ + ooo_mem(i); \ + WRITE_CACHED_VAR(urcu_active_readers[get_readerid()], \ + tmp + 1); \ + PRODUCE_TOKENS(proc_urcu_reader, producetoken); \ + /* IF_MERGE implies \ + * post-dominance */ \ + /* ENDIF */ \ + skip + +/* Body of PROCEDURE_READ_LOCK */ +#define READ_PROC_READ_UNLOCK (1 << 0) + +#define PROCEDURE_READ_UNLOCK(base, consumetoken, producetoken) \ + :: CONSUME_TOKENS(proc_urcu_reader, \ + consumetoken, \ + READ_PROC_READ_UNLOCK << base) -> \ + ooo_mem(i); \ + tmp2 = READ_CACHED_VAR(urcu_active_readers[get_readerid()]); \ + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_READ_UNLOCK << base); \ + :: CONSUME_TOKENS(proc_urcu_reader, \ + consumetoken \ + | (READ_PROC_READ_UNLOCK << base), /* WAR */ \ + producetoken) -> \ + ooo_mem(i); \ + WRITE_CACHED_VAR(urcu_active_readers[get_readerid()], tmp2 - 1); \ + PRODUCE_TOKENS(proc_urcu_reader, producetoken); \ + skip + + +#define READ_PROD_NONE (1 << 0) + +/* PROCEDURE_READ_LOCK base = << 1 : 1 to 5 */ +#define READ_LOCK_BASE 1 +#define READ_LOCK_OUT (1 << 5) + +#define READ_PROC_FIRST_MB (1 << 6) + +/* PROCEDURE_READ_LOCK (NESTED) base : << 7 : 7 to 11 */ +#define READ_LOCK_NESTED_BASE 7 +#define READ_LOCK_NESTED_OUT (1 << 11) + +#define READ_PROC_READ_GEN (1 << 12) +#define READ_PROC_ACCESS_GEN (1 << 13) + +/* PROCEDURE_READ_UNLOCK (NESTED) base = << 14 : 14 to 15 */ +#define READ_UNLOCK_NESTED_BASE 14 +#define READ_UNLOCK_NESTED_OUT (1 << 15) + +#define READ_PROC_SECOND_MB (1 << 16) + +/* PROCEDURE_READ_UNLOCK base = << 17 : 17 to 18 */ +#define READ_UNLOCK_BASE 17 +#define READ_UNLOCK_OUT (1 << 18) + +/* PROCEDURE_READ_LOCK_UNROLL base = << 19 : 19 to 23 */ +#define READ_LOCK_UNROLL_BASE 19 +#define READ_LOCK_OUT_UNROLL (1 << 23) + +#define READ_PROC_THIRD_MB (1 << 24) + +#define READ_PROC_READ_GEN_UNROLL (1 << 25) +#define READ_PROC_ACCESS_GEN_UNROLL (1 << 26) + +#define READ_PROC_FOURTH_MB (1 << 27) + +/* PROCEDURE_READ_UNLOCK_UNROLL base = << 28 : 28 to 29 */ +#define READ_UNLOCK_UNROLL_BASE 28 +#define READ_UNLOCK_OUT_UNROLL (1 << 29) + + +/* Should not include branches */ +#define READ_PROC_ALL_TOKENS (READ_PROD_NONE \ + | READ_LOCK_OUT \ + | READ_PROC_FIRST_MB \ + | READ_LOCK_NESTED_OUT \ + | READ_PROC_READ_GEN \ + | READ_PROC_ACCESS_GEN \ + | READ_UNLOCK_NESTED_OUT \ + | READ_PROC_SECOND_MB \ + | READ_UNLOCK_OUT \ + | READ_LOCK_OUT_UNROLL \ + | READ_PROC_THIRD_MB \ + | READ_PROC_READ_GEN_UNROLL \ + | READ_PROC_ACCESS_GEN_UNROLL \ + | READ_PROC_FOURTH_MB \ + | READ_UNLOCK_OUT_UNROLL) + +/* Must clear all tokens, including branches */ +#define READ_PROC_ALL_TOKENS_CLEAR ((1 << 30) - 1) + +inline urcu_one_read(i, j, nest_i, tmp, tmp2) +{ + PRODUCE_TOKENS(proc_urcu_reader, READ_PROD_NONE); + +#ifdef NO_MB + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_FIRST_MB); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_SECOND_MB); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_THIRD_MB); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_FOURTH_MB); +#endif + +#ifdef REMOTE_BARRIERS + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_FIRST_MB); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_SECOND_MB); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_THIRD_MB); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_FOURTH_MB); +#endif + + do + :: 1 -> + +#ifdef REMOTE_BARRIERS + /* + * Signal-based memory barrier will only execute when the + * execution order appears in program order. + */ + if + :: 1 -> + atomic { + if + :: CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE, + READ_LOCK_OUT | READ_LOCK_NESTED_OUT + | READ_PROC_READ_GEN | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT + | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT, + READ_LOCK_NESTED_OUT + | READ_PROC_READ_GEN | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT + | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT | READ_LOCK_NESTED_OUT, + READ_PROC_READ_GEN | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT + | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN, + READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT + | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN | READ_PROC_ACCESS_GEN, + READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT + | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN + | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT, + READ_UNLOCK_OUT + | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN + | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT, + READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN + | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT | READ_LOCK_OUT_UNROLL, + READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN + | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL, + READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN + | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL, + READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL, + 0) -> + goto non_atomic3; +non_atomic3_end: + skip; + fi; + } + fi; + + goto non_atomic3_skip; +non_atomic3: + smp_mb_recv(i, j); + goto non_atomic3_end; +non_atomic3_skip: + +#endif /* REMOTE_BARRIERS */ + + atomic { + if + PROCEDURE_READ_LOCK(READ_LOCK_BASE, READ_PROD_NONE, READ_LOCK_OUT); + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_LOCK_OUT, /* post-dominant */ + READ_PROC_FIRST_MB) -> + smp_mb_reader(i, j); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_FIRST_MB); + + PROCEDURE_READ_LOCK(READ_LOCK_NESTED_BASE, READ_PROC_FIRST_MB | READ_LOCK_OUT, + READ_LOCK_NESTED_OUT); + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_PROC_FIRST_MB, /* mb() orders reads */ + READ_PROC_READ_GEN) -> + ooo_mem(i); + ptr_read_first[get_readerid()] = READ_CACHED_VAR(rcu_ptr); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_READ_GEN); + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_PROC_FIRST_MB /* mb() orders reads */ + | READ_PROC_READ_GEN, + READ_PROC_ACCESS_GEN) -> + /* smp_read_barrier_depends */ + goto rmb1; +rmb1_end: + data_read_first[get_readerid()] = + READ_CACHED_VAR(rcu_data[ptr_read_first[get_readerid()]]); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_ACCESS_GEN); + + + /* Note : we remove the nested memory barrier from the read unlock + * model, given it is not usually needed. The implementation has the barrier + * because the performance impact added by a branch in the common case does not + * justify it. + */ + + PROCEDURE_READ_UNLOCK(READ_UNLOCK_NESTED_BASE, + READ_PROC_FIRST_MB + | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT, + READ_UNLOCK_NESTED_OUT); + + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_PROC_ACCESS_GEN /* mb() orders reads */ + | READ_PROC_READ_GEN /* mb() orders reads */ + | READ_PROC_FIRST_MB /* mb() ordered */ + | READ_LOCK_OUT /* post-dominant */ + | READ_LOCK_NESTED_OUT /* post-dominant */ + | READ_UNLOCK_NESTED_OUT, + READ_PROC_SECOND_MB) -> + smp_mb_reader(i, j); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_SECOND_MB); + + PROCEDURE_READ_UNLOCK(READ_UNLOCK_BASE, + READ_PROC_SECOND_MB /* mb() orders reads */ + | READ_PROC_FIRST_MB /* mb() orders reads */ + | READ_LOCK_NESTED_OUT /* RAW */ + | READ_LOCK_OUT /* RAW */ + | READ_UNLOCK_NESTED_OUT, /* RAW */ + READ_UNLOCK_OUT); + + /* Unrolling loop : second consecutive lock */ + /* reading urcu_active_readers, which have been written by + * READ_UNLOCK_OUT : RAW */ + PROCEDURE_READ_LOCK(READ_LOCK_UNROLL_BASE, + READ_UNLOCK_OUT /* RAW */ + | READ_PROC_SECOND_MB /* mb() orders reads */ + | READ_PROC_FIRST_MB /* mb() orders reads */ + | READ_LOCK_NESTED_OUT /* RAW */ + | READ_LOCK_OUT /* RAW */ + | READ_UNLOCK_NESTED_OUT, /* RAW */ + READ_LOCK_OUT_UNROLL); + + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_PROC_FIRST_MB /* mb() ordered */ + | READ_PROC_SECOND_MB /* mb() ordered */ + | READ_LOCK_OUT_UNROLL /* post-dominant */ + | READ_LOCK_NESTED_OUT + | READ_LOCK_OUT + | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT, + READ_PROC_THIRD_MB) -> + smp_mb_reader(i, j); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_THIRD_MB); + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_PROC_FIRST_MB /* mb() orders reads */ + | READ_PROC_SECOND_MB /* mb() orders reads */ + | READ_PROC_THIRD_MB, /* mb() orders reads */ + READ_PROC_READ_GEN_UNROLL) -> + ooo_mem(i); + ptr_read_second[get_readerid()] = READ_CACHED_VAR(rcu_ptr); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_READ_GEN_UNROLL); + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_PROC_READ_GEN_UNROLL + | READ_PROC_FIRST_MB /* mb() orders reads */ + | READ_PROC_SECOND_MB /* mb() orders reads */ + | READ_PROC_THIRD_MB, /* mb() orders reads */ + READ_PROC_ACCESS_GEN_UNROLL) -> + /* smp_read_barrier_depends */ + goto rmb2; +rmb2_end: + data_read_second[get_readerid()] = + READ_CACHED_VAR(rcu_data[ptr_read_second[get_readerid()]]); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_ACCESS_GEN_UNROLL); + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_PROC_READ_GEN_UNROLL /* mb() orders reads */ + | READ_PROC_ACCESS_GEN_UNROLL /* mb() orders reads */ + | READ_PROC_FIRST_MB /* mb() ordered */ + | READ_PROC_SECOND_MB /* mb() ordered */ + | READ_PROC_THIRD_MB /* mb() ordered */ + | READ_LOCK_OUT_UNROLL /* post-dominant */ + | READ_LOCK_NESTED_OUT + | READ_LOCK_OUT + | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT, + READ_PROC_FOURTH_MB) -> + smp_mb_reader(i, j); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_FOURTH_MB); + + PROCEDURE_READ_UNLOCK(READ_UNLOCK_UNROLL_BASE, + READ_PROC_FOURTH_MB /* mb() orders reads */ + | READ_PROC_THIRD_MB /* mb() orders reads */ + | READ_LOCK_OUT_UNROLL /* RAW */ + | READ_PROC_SECOND_MB /* mb() orders reads */ + | READ_PROC_FIRST_MB /* mb() orders reads */ + | READ_LOCK_NESTED_OUT /* RAW */ + | READ_LOCK_OUT /* RAW */ + | READ_UNLOCK_NESTED_OUT, /* RAW */ + READ_UNLOCK_OUT_UNROLL); + :: CONSUME_TOKENS(proc_urcu_reader, READ_PROC_ALL_TOKENS, 0) -> + CLEAR_TOKENS(proc_urcu_reader, READ_PROC_ALL_TOKENS_CLEAR); + break; + fi; + } + od; + /* + * Dependency between consecutive loops : + * RAW dependency on + * WRITE_CACHED_VAR(urcu_active_readers[get_readerid()], tmp2 - 1) + * tmp = READ_CACHED_VAR(urcu_active_readers[get_readerid()]); + * between loops. + * _WHEN THE MB()s are in place_, they add full ordering of the + * generation pointer read wrt active reader count read, which ensures + * execution will not spill across loop execution. + * However, in the event mb()s are removed (execution using signal + * handler to promote barrier()() -> smp_mb()), nothing prevents one loop + * to spill its execution on other loop's execution. + */ + goto end; +rmb1: +#ifndef NO_RMB + smp_rmb(i); +#else + ooo_mem(i); +#endif + goto rmb1_end; +rmb2: +#ifndef NO_RMB + smp_rmb(i); +#else + ooo_mem(i); +#endif + goto rmb2_end; +end: + skip; +} + + + +active proctype urcu_reader() +{ + byte i, j, nest_i; + byte tmp, tmp2; + + wait_init_done(); + + assert(get_pid() < NR_PROCS); + +end_reader: + do + :: 1 -> + /* + * We do not test reader's progress here, because we are mainly + * interested in writer's progress. The reader never blocks + * anyway. We have to test for reader/writer's progress + * separately, otherwise we could think the writer is doing + * progress when it's blocked by an always progressing reader. + */ +#ifdef READER_PROGRESS +progress_reader: +#endif + urcu_one_read(i, j, nest_i, tmp, tmp2); + od; +} + +/* no name clash please */ +#undef proc_urcu_reader + + +/* Model the RCU update process. */ + +/* + * Bit encoding, urcu_writer : + * Currently only supports one reader. + */ + +int _proc_urcu_writer; +#define proc_urcu_writer _proc_urcu_writer + +#define WRITE_PROD_NONE (1 << 0) + +#define WRITE_DATA (1 << 1) +#define WRITE_PROC_WMB (1 << 2) +#define WRITE_XCHG_PTR (1 << 3) + +#define WRITE_PROC_FIRST_MB (1 << 4) + +/* first flip */ +#define WRITE_PROC_FIRST_READ_GP (1 << 5) +#define WRITE_PROC_FIRST_WRITE_GP (1 << 6) +#define WRITE_PROC_FIRST_WAIT (1 << 7) +#define WRITE_PROC_FIRST_WAIT_LOOP (1 << 8) + +/* second flip */ +#define WRITE_PROC_SECOND_READ_GP (1 << 9) +#define WRITE_PROC_SECOND_WRITE_GP (1 << 10) +#define WRITE_PROC_SECOND_WAIT (1 << 11) +#define WRITE_PROC_SECOND_WAIT_LOOP (1 << 12) + +#define WRITE_PROC_SECOND_MB (1 << 13) + +#define WRITE_FREE (1 << 14) + +#define WRITE_PROC_ALL_TOKENS (WRITE_PROD_NONE \ + | WRITE_DATA \ + | WRITE_PROC_WMB \ + | WRITE_XCHG_PTR \ + | WRITE_PROC_FIRST_MB \ + | WRITE_PROC_FIRST_READ_GP \ + | WRITE_PROC_FIRST_WRITE_GP \ + | WRITE_PROC_FIRST_WAIT \ + | WRITE_PROC_SECOND_READ_GP \ + | WRITE_PROC_SECOND_WRITE_GP \ + | WRITE_PROC_SECOND_WAIT \ + | WRITE_PROC_SECOND_MB \ + | WRITE_FREE) + +#define WRITE_PROC_ALL_TOKENS_CLEAR ((1 << 15) - 1) + +/* + * Mutexes are implied around writer execution. A single writer at a time. + */ +active proctype urcu_writer() +{ + byte i, j; + byte tmp, tmp2, tmpa; + byte cur_data = 0, old_data, loop_nr = 0; + byte cur_gp_val = 0; /* + * Keep a local trace of the current parity so + * we don't add non-existing dependencies on the global + * GP update. Needed to test single flip case. + */ + + wait_init_done(); + + assert(get_pid() < NR_PROCS); + + do + :: (loop_nr < 3) -> +#ifdef WRITER_PROGRESS +progress_writer1: +#endif + loop_nr = loop_nr + 1; + + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROD_NONE); + +#ifdef NO_WMB + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_WMB); +#endif + +#ifdef NO_MB + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_FIRST_MB); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_MB); +#endif + +#ifdef SINGLE_FLIP + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_READ_GP); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_WRITE_GP); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_WAIT); + /* For single flip, we need to know the current parity */ + cur_gp_val = cur_gp_val ^ RCU_GP_CTR_BIT; +#endif + + do :: 1 -> + atomic { + if + + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_PROD_NONE, + WRITE_DATA) -> + ooo_mem(i); + cur_data = (cur_data + 1) % SLAB_SIZE; + WRITE_CACHED_VAR(rcu_data[cur_data], WINE); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_DATA); + + + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_DATA, + WRITE_PROC_WMB) -> + smp_wmb(i); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_WMB); + + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_PROC_WMB, + WRITE_XCHG_PTR) -> + /* rcu_xchg_pointer() */ + atomic { + old_data = READ_CACHED_VAR(rcu_ptr); + WRITE_CACHED_VAR(rcu_ptr, cur_data); + } + PRODUCE_TOKENS(proc_urcu_writer, WRITE_XCHG_PTR); + + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_DATA | WRITE_PROC_WMB | WRITE_XCHG_PTR, + WRITE_PROC_FIRST_MB) -> + goto smp_mb_send1; +smp_mb_send1_end: + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_FIRST_MB); + + /* first flip */ + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_PROC_FIRST_MB, + WRITE_PROC_FIRST_READ_GP) -> + tmpa = READ_CACHED_VAR(urcu_gp_ctr); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_FIRST_READ_GP); + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_PROC_FIRST_MB | WRITE_PROC_WMB + | WRITE_PROC_FIRST_READ_GP, + WRITE_PROC_FIRST_WRITE_GP) -> + ooo_mem(i); + WRITE_CACHED_VAR(urcu_gp_ctr, tmpa ^ RCU_GP_CTR_BIT); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_FIRST_WRITE_GP); + + :: CONSUME_TOKENS(proc_urcu_writer, + //WRITE_PROC_FIRST_WRITE_GP /* TEST ADDING SYNC CORE */ + WRITE_PROC_FIRST_MB, /* can be reordered before/after flips */ + WRITE_PROC_FIRST_WAIT | WRITE_PROC_FIRST_WAIT_LOOP) -> + ooo_mem(i); + /* ONLY WAITING FOR READER 0 */ + tmp2 = READ_CACHED_VAR(urcu_active_readers[0]); +#ifndef SINGLE_FLIP + /* In normal execution, we are always starting by + * waiting for the even parity. + */ + cur_gp_val = RCU_GP_CTR_BIT; +#endif + if + :: (tmp2 & RCU_GP_CTR_NEST_MASK) + && ((tmp2 ^ cur_gp_val) & RCU_GP_CTR_BIT) -> + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_FIRST_WAIT_LOOP); + :: else -> + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_FIRST_WAIT); + fi; + + :: CONSUME_TOKENS(proc_urcu_writer, + //WRITE_PROC_FIRST_WRITE_GP /* TEST ADDING SYNC CORE */ + WRITE_PROC_FIRST_WRITE_GP + | WRITE_PROC_FIRST_READ_GP + | WRITE_PROC_FIRST_WAIT_LOOP + | WRITE_DATA | WRITE_PROC_WMB | WRITE_XCHG_PTR + | WRITE_PROC_FIRST_MB, /* can be reordered before/after flips */ + 0) -> +#ifndef GEN_ERROR_WRITER_PROGRESS + goto smp_mb_send2; +smp_mb_send2_end: +#else + ooo_mem(i); +#endif + /* This instruction loops to WRITE_PROC_FIRST_WAIT */ + CLEAR_TOKENS(proc_urcu_writer, WRITE_PROC_FIRST_WAIT_LOOP | WRITE_PROC_FIRST_WAIT); + + /* second flip */ + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_PROC_FIRST_WAIT /* Control dependency : need to branch out of + * the loop to execute the next flip (CHECK) */ + | WRITE_PROC_FIRST_WRITE_GP + | WRITE_PROC_FIRST_READ_GP + | WRITE_PROC_FIRST_MB, + WRITE_PROC_SECOND_READ_GP) -> + ooo_mem(i); + tmpa = READ_CACHED_VAR(urcu_gp_ctr); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_READ_GP); + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_PROC_FIRST_MB + | WRITE_PROC_WMB + | WRITE_PROC_FIRST_READ_GP + | WRITE_PROC_FIRST_WRITE_GP + | WRITE_PROC_SECOND_READ_GP, + WRITE_PROC_SECOND_WRITE_GP) -> + ooo_mem(i); + WRITE_CACHED_VAR(urcu_gp_ctr, tmpa ^ RCU_GP_CTR_BIT); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_WRITE_GP); + + :: CONSUME_TOKENS(proc_urcu_writer, + //WRITE_PROC_FIRST_WRITE_GP /* TEST ADDING SYNC CORE */ + WRITE_PROC_FIRST_WAIT + | WRITE_PROC_FIRST_MB, /* can be reordered before/after flips */ + WRITE_PROC_SECOND_WAIT | WRITE_PROC_SECOND_WAIT_LOOP) -> + ooo_mem(i); + /* ONLY WAITING FOR READER 0 */ + tmp2 = READ_CACHED_VAR(urcu_active_readers[0]); + if + :: (tmp2 & RCU_GP_CTR_NEST_MASK) + && ((tmp2 ^ 0) & RCU_GP_CTR_BIT) -> + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_WAIT_LOOP); + :: else -> + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_WAIT); + fi; + + :: CONSUME_TOKENS(proc_urcu_writer, + //WRITE_PROC_FIRST_WRITE_GP /* TEST ADDING SYNC CORE */ + WRITE_PROC_SECOND_WRITE_GP + | WRITE_PROC_FIRST_WRITE_GP + | WRITE_PROC_SECOND_READ_GP + | WRITE_PROC_FIRST_READ_GP + | WRITE_PROC_SECOND_WAIT_LOOP + | WRITE_DATA | WRITE_PROC_WMB | WRITE_XCHG_PTR + | WRITE_PROC_FIRST_MB, /* can be reordered before/after flips */ + 0) -> +#ifndef GEN_ERROR_WRITER_PROGRESS + goto smp_mb_send3; +smp_mb_send3_end: +#else + ooo_mem(i); +#endif + /* This instruction loops to WRITE_PROC_SECOND_WAIT */ + CLEAR_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_WAIT_LOOP | WRITE_PROC_SECOND_WAIT); + + + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_PROC_FIRST_WAIT + | WRITE_PROC_SECOND_WAIT + | WRITE_PROC_FIRST_READ_GP + | WRITE_PROC_SECOND_READ_GP + | WRITE_PROC_FIRST_WRITE_GP + | WRITE_PROC_SECOND_WRITE_GP + | WRITE_DATA | WRITE_PROC_WMB | WRITE_XCHG_PTR + | WRITE_PROC_FIRST_MB, + WRITE_PROC_SECOND_MB) -> + goto smp_mb_send4; +smp_mb_send4_end: + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_MB); + + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_XCHG_PTR + | WRITE_PROC_FIRST_WAIT + | WRITE_PROC_SECOND_WAIT + | WRITE_PROC_WMB /* No dependency on + * WRITE_DATA because we + * write to a + * different location. */ + | WRITE_PROC_SECOND_MB + | WRITE_PROC_FIRST_MB, + WRITE_FREE) -> + WRITE_CACHED_VAR(rcu_data[old_data], POISON); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_FREE); + + :: CONSUME_TOKENS(proc_urcu_writer, WRITE_PROC_ALL_TOKENS, 0) -> + CLEAR_TOKENS(proc_urcu_writer, WRITE_PROC_ALL_TOKENS_CLEAR); + break; + fi; + } + od; + /* + * Note : Promela model adds implicit serialization of the + * WRITE_FREE instruction. Normally, it would be permitted to + * spill on the next loop execution. Given the validation we do + * checks for the data entry read to be poisoned, it's ok if + * we do not check "late arriving" memory poisoning. + */ + :: else -> break; + od; + /* + * Given the reader loops infinitely, let the writer also busy-loop + * with progress here so, with weak fairness, we can test the + * writer's progress. + */ +end_writer: + do + :: 1 -> +#ifdef WRITER_PROGRESS +progress_writer2: +#endif +#ifdef READER_PROGRESS + /* + * Make sure we don't block the reader's progress. + */ + smp_mb_send(i, j, 5); +#endif + skip; + od; + + /* Non-atomic parts of the loop */ + goto end; +smp_mb_send1: + smp_mb_send(i, j, 1); + goto smp_mb_send1_end; +#ifndef GEN_ERROR_WRITER_PROGRESS +smp_mb_send2: + smp_mb_send(i, j, 2); + goto smp_mb_send2_end; +smp_mb_send3: + smp_mb_send(i, j, 3); + goto smp_mb_send3_end; +#endif +smp_mb_send4: + smp_mb_send(i, j, 4); + goto smp_mb_send4_end; +end: + skip; +} + +/* no name clash please */ +#undef proc_urcu_writer + + +/* Leave after the readers and writers so the pid count is ok. */ +init { + byte i, j; + + atomic { + INIT_CACHED_VAR(urcu_gp_ctr, 1, j); + INIT_CACHED_VAR(rcu_ptr, 0, j); + + i = 0; + do + :: i < NR_READERS -> + INIT_CACHED_VAR(urcu_active_readers[i], 0, j); + ptr_read_first[i] = 1; + ptr_read_second[i] = 1; + data_read_first[i] = WINE; + data_read_second[i] = WINE; + i++; + :: i >= NR_READERS -> break + od; + INIT_CACHED_VAR(rcu_data[0], WINE, j); + i = 1; + do + :: i < SLAB_SIZE -> + INIT_CACHED_VAR(rcu_data[i], POISON, j); + i++ + :: i >= SLAB_SIZE -> break + od; + + init_done = 1; + } +} diff --git a/formal-model/results/urcu-controldataflow-ipi-intel/DEFINES b/formal-model/results/urcu-controldataflow-ipi-intel/DEFINES new file mode 100644 index 0000000..abea5ff --- /dev/null +++ b/formal-model/results/urcu-controldataflow-ipi-intel/DEFINES @@ -0,0 +1,18 @@ + +// Poison value for freed memory +#define POISON 1 +// Memory with correct data +#define WINE 0 +#define SLAB_SIZE 2 + +#define read_poison (data_read_first[0] == POISON || data_read_second[0] == POISON) + +#define RCU_GP_CTR_BIT (1 << 7) +#define RCU_GP_CTR_NEST_MASK (RCU_GP_CTR_BIT - 1) + +//disabled +#define REMOTE_BARRIERS + +//#define ARCH_ALPHA +#define ARCH_INTEL +//#define ARCH_POWERPC diff --git a/formal-model/results/urcu-controldataflow-ipi-intel/Makefile b/formal-model/results/urcu-controldataflow-ipi-intel/Makefile new file mode 100644 index 0000000..de47dff --- /dev/null +++ b/formal-model/results/urcu-controldataflow-ipi-intel/Makefile @@ -0,0 +1,170 @@ +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +# +# Copyright (C) Mathieu Desnoyers, 2009 +# +# Authors: Mathieu Desnoyers + +#CFLAGS=-DSAFETY +#for multi-core verif, 15.5GB shared mem, use files if full +#CFLAGS=-DHASH64 -DMEMLIM=15500 -DNCORE=2 +#CFLAGS=-DHASH64 -DCOLLAPSE -DMA=88 -DMEMLIM=15500 -DNCORE=8 + +#liveness +#CFLAGS=-DHASH64 -DCOLLAPSE -DMA=88 +CFLAGS=-DHASH64 + +SPINFILE=urcu.spin + +default: + make urcu_free | tee urcu_free.log + make urcu_free_no_mb | tee urcu_free_no_mb.log + make urcu_free_no_rmb | tee urcu_free_no_rmb.log + make urcu_free_no_wmb | tee urcu_free_no_wmb.log + make urcu_free_single_flip | tee urcu_free_single_flip.log + make urcu_progress_writer | tee urcu_progress_writer.log + make urcu_progress_reader | tee urcu_progress_reader.log + make urcu_progress_writer_error | tee urcu_progress_writer_error.log + make asserts | tee asserts.log + make summary + +#show trail : spin -v -t -N pan.ltl input.spin +# after each individual make. + +summary: + @echo + @echo "Verification summary" + @grep errors: *.log + +asserts: clean + cat DEFINES > .input.spin + cat ${SPINFILE} >> .input.spin + rm -f .input.spin.trail + spin -a -X .input.spin + gcc -O2 -w ${CFLAGS} -DSAFETY -o pan pan.c + ./pan -v -c1 -X -m10000000 -w20 + cp .input.spin $@.spin.input + -cp .input.spin.trail $@.spin.input.trail + +urcu_free: clean urcu_free_ltl run + cp .input.spin $@.spin.input + -cp .input.spin.trail $@.spin.input.trail + +urcu_free_nested: clean urcu_free_ltl urcu_free_nested_define run + cp .input.spin $@.spin.input + -cp .input.spin.trail $@.spin.input.trail + +urcu_free_nested_define: + cp urcu_free_nested.define .input.define + +urcu_free_no_rmb: clean urcu_free_ltl urcu_free_no_rmb_define run + cp .input.spin $@.spin.input + -cp .input.spin.trail $@.spin.input.trail + +urcu_free_no_rmb_define: + cp urcu_free_no_rmb.define .input.define + +urcu_free_no_wmb: clean urcu_free_ltl urcu_free_no_wmb_define run + cp .input.spin $@.spin.input + -cp .input.spin.trail $@.spin.input.trail + +urcu_free_no_wmb_define: + cp urcu_free_no_wmb.define .input.define + +urcu_free_no_mb: clean urcu_free_ltl urcu_free_no_mb_define run + cp .input.spin $@.spin.input + -cp .input.spin.trail $@.spin.input.trail + +urcu_free_no_mb_define: + cp urcu_free_no_mb.define .input.define + +urcu_free_single_flip: clean urcu_free_ltl urcu_free_single_flip_define run + cp .input.spin $@.spin.input + -cp .input.spin.trail $@.spin.input.trail + +urcu_free_single_flip_define: + cp urcu_free_single_flip.define .input.define + +urcu_free_ltl: + touch .input.define + cat .input.define >> pan.ltl + cat DEFINES >> pan.ltl + spin -f "!(`cat urcu_free.ltl | grep -v ^//`)" >> pan.ltl + +# Progress checks + +urcu_progress_writer: clean urcu_progress_writer_ltl \ + urcu_progress_writer_define run_weak_fair + cp .input.spin $@.spin.input + -cp .input.spin.trail $@.spin.input.trail + +urcu_progress_writer_define: + cp urcu_progress_writer.define .input.define + +urcu_progress_writer_ltl: + touch .input.define + cat .input.define > pan.ltl + cat DEFINES >> pan.ltl + spin -f "!(`cat urcu_progress.ltl | grep -v ^//`)" >> pan.ltl + +urcu_progress_reader: clean urcu_progress_reader_ltl \ + urcu_progress_reader_define run_weak_fair + cp .input.spin $@.spin.input + -cp .input.spin.trail $@.spin.input.trail + +urcu_progress_reader_define: + cp urcu_progress_reader.define .input.define + +urcu_progress_reader_ltl: + touch .input.define + cat .input.define > pan.ltl + cat DEFINES >> pan.ltl + spin -f "!(`cat urcu_progress.ltl | grep -v ^//`)" >> pan.ltl + +urcu_progress_writer_error: clean urcu_progress_writer_error_ltl \ + urcu_progress_writer_error_define run_weak_fair + cp .input.spin $@.spin.input + -cp .input.spin.trail $@.spin.input.trail + +urcu_progress_writer_error_define: + cp urcu_progress_writer_error.define .input.define + +urcu_progress_writer_error_ltl: + touch .input.define + cat .input.define > pan.ltl + cat DEFINES >> pan.ltl + spin -f "!(`cat urcu_progress.ltl | grep -v ^//`)" >> pan.ltl + + +run_weak_fair: pan + ./pan -a -f -v -c1 -X -m10000000 -w20 + +run: pan + ./pan -a -v -c1 -X -m10000000 -w20 + +pan: pan.c + gcc -O2 -w ${CFLAGS} -o pan pan.c + +pan.c: pan.ltl ${SPINFILE} + cat .input.define > .input.spin + cat DEFINES >> .input.spin + cat ${SPINFILE} >> .input.spin + rm -f .input.spin.trail + spin -a -X -N pan.ltl .input.spin + +.PHONY: clean default distclean summary +clean: + rm -f pan* trail.out .input.spin* *.spin.trail .input.define +distclean: + rm -f *.trail *.input *.log diff --git a/formal-model/results/urcu-controldataflow-ipi-intel/asserts.log b/formal-model/results/urcu-controldataflow-ipi-intel/asserts.log new file mode 100644 index 0000000..ddccacb --- /dev/null +++ b/formal-model/results/urcu-controldataflow-ipi-intel/asserts.log @@ -0,0 +1,473 @@ +make[1]: Entering directory `/home/compudj/doc/userspace-rcu/formal-model/urcu-controldataflow' +rm -f pan* trail.out .input.spin* *.spin.trail .input.define +cat DEFINES > .input.spin +cat urcu.spin >> .input.spin +rm -f .input.spin.trail +spin -a -X .input.spin +Exit-Status 0 +gcc -O2 -w -DHASH64 -DSAFETY -o pan pan.c +./pan -v -c1 -X -m10000000 -w20 +Depth= 5407 States= 1e+06 Transitions= 5.87e+06 Memory= 542.717 t= 11.7 R= 9e+04 +Depth= 5407 States= 2e+06 Transitions= 1.64e+07 Memory= 618.986 t= 35.3 R= 6e+04 +Depth= 5407 States= 3e+06 Transitions= 3.29e+07 Memory= 695.256 t= 74.2 R= 4e+04 +pan: resizing hashtable to -w22.. done +Depth= 5407 States= 4e+06 Transitions= 4.33e+07 Memory= 802.647 t= 97.9 R= 4e+04 +Depth= 5407 States= 5e+06 Transitions= 5.2e+07 Memory= 878.916 t= 117 R= 4e+04 +Depth= 5407 States= 6e+06 Transitions= 5.99e+07 Memory= 955.186 t= 134 R= 4e+04 +Depth= 5407 States= 7e+06 Transitions= 7.13e+07 Memory= 1031.455 t= 160 R= 4e+04 +Depth= 5407 States= 8e+06 Transitions= 8.71e+07 Memory= 1107.822 t= 198 R= 4e+04 +Depth= 5407 States= 9e+06 Transitions= 9.81e+07 Memory= 1184.092 t= 223 R= 4e+04 +pan: resizing hashtable to -w24.. done +Depth= 5407 States= 1e+07 Transitions= 1.07e+08 Memory= 1384.455 t= 244 R= 4e+04 +Depth= 5407 States= 1.1e+07 Transitions= 1.14e+08 Memory= 1460.725 t= 260 R= 4e+04 +Depth= 5407 States= 1.2e+07 Transitions= 1.27e+08 Memory= 1536.994 t= 288 R= 4e+04 + +(Spin Version 5.1.7 -- 23 December 2008) + + Partial Order Reduction + +Full statespace search for: + never claim - (none specified) + assertion violations + + cycle checks - (disabled by -DSAFETY) + invalid end states + + +State-vector 72 byte, depth reached 5407, errors: 0 + 12141896 states, stored +1.1623987e+08 states, matched +1.2838176e+08 transitions (= stored+matched) +1.9407117e+09 atomic steps +hash conflicts: 98957892 (resolved) + +Stats on memory usage (in Megabytes): + 1157.941 equivalent memory usage for states (stored*(State-vector + overhead)) + 962.219 actual memory usage for states (compression: 83.10%) + state-vector as stored = 55 byte + 28 byte overhead + 128.000 memory used for hash table (-w24) + 457.764 memory used for DFS stack (-m10000000) + 1547.834 total actual memory usage + +unreached in proctype urcu_reader + line 261, ".input.spin", state 30, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 269, ".input.spin", state 52, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 273, ".input.spin", state 61, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 238, ".input.spin", state 77, "(1)" + line 242, ".input.spin", state 85, "(1)" + line 246, ".input.spin", state 97, "(1)" + line 250, ".input.spin", state 105, "(1)" + line 400, ".input.spin", state 131, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 409, ".input.spin", state 163, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 413, ".input.spin", state 177, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 238, ".input.spin", state 195, "(1)" + line 246, ".input.spin", state 215, "(1)" + line 250, ".input.spin", state 223, "(1)" + line 679, ".input.spin", state 242, "_proc_urcu_reader = (_proc_urcu_reader|((1<<2)<<1))" + line 400, ".input.spin", state 249, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 409, ".input.spin", state 281, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 413, ".input.spin", state 295, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 238, ".input.spin", state 313, "(1)" + line 246, ".input.spin", state 333, "(1)" + line 250, ".input.spin", state 341, "(1)" + line 400, ".input.spin", state 360, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 409, ".input.spin", state 392, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 413, ".input.spin", state 406, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 238, ".input.spin", state 424, "(1)" + line 246, ".input.spin", state 444, "(1)" + line 250, ".input.spin", state 452, "(1)" + line 400, ".input.spin", state 473, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 400, ".input.spin", state 475, "(1)" + line 400, ".input.spin", state 476, "((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid)))" + line 400, ".input.spin", state 476, "else" + line 400, ".input.spin", state 479, "(1)" + line 404, ".input.spin", state 487, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 404, ".input.spin", state 489, "(1)" + line 404, ".input.spin", state 490, "((cache_dirty_urcu_active_readers.bitfield&(1<<_pid)))" + line 404, ".input.spin", state 490, "else" + line 404, ".input.spin", state 493, "(1)" + line 404, ".input.spin", state 494, "(1)" + line 404, ".input.spin", state 494, "(1)" + line 402, ".input.spin", state 499, "((i<1))" + line 402, ".input.spin", state 499, "((i>=1))" + line 409, ".input.spin", state 505, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 409, ".input.spin", state 507, "(1)" + line 409, ".input.spin", state 508, "((cache_dirty_rcu_ptr.bitfield&(1<<_pid)))" + line 409, ".input.spin", state 508, "else" + line 409, ".input.spin", state 511, "(1)" + line 409, ".input.spin", state 512, "(1)" + line 409, ".input.spin", state 512, "(1)" + line 413, ".input.spin", state 519, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 413, ".input.spin", state 521, "(1)" + line 413, ".input.spin", state 522, "((cache_dirty_rcu_data[i].bitfield&(1<<_pid)))" + line 413, ".input.spin", state 522, "else" + line 413, ".input.spin", state 525, "(1)" + line 413, ".input.spin", state 526, "(1)" + line 413, ".input.spin", state 526, "(1)" + line 411, ".input.spin", state 531, "((i<2))" + line 411, ".input.spin", state 531, "((i>=2))" + line 238, ".input.spin", state 537, "(1)" + line 242, ".input.spin", state 545, "(1)" + line 242, ".input.spin", state 546, "(!((cache_dirty_urcu_active_readers.bitfield&(1<<_pid))))" + line 242, ".input.spin", state 546, "else" + line 240, ".input.spin", state 551, "((i<1))" + line 240, ".input.spin", state 551, "((i>=1))" + line 246, ".input.spin", state 557, "(1)" + line 246, ".input.spin", state 558, "(!((cache_dirty_rcu_ptr.bitfield&(1<<_pid))))" + line 246, ".input.spin", state 558, "else" + line 250, ".input.spin", state 565, "(1)" + line 250, ".input.spin", state 566, "(!((cache_dirty_rcu_data[i].bitfield&(1<<_pid))))" + line 250, ".input.spin", state 566, "else" + line 248, ".input.spin", state 571, "((i<2))" + line 248, ".input.spin", state 571, "((i>=2))" + line 255, ".input.spin", state 575, "(!((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid))))" + line 255, ".input.spin", state 575, "else" + line 420, ".input.spin", state 577, "(1)" + line 420, ".input.spin", state 577, "(1)" + line 679, ".input.spin", state 580, "cached_urcu_active_readers.val[_pid] = (tmp+1)" + line 679, ".input.spin", state 581, "_proc_urcu_reader = (_proc_urcu_reader|(1<<5))" + line 679, ".input.spin", state 582, "(1)" + line 400, ".input.spin", state 589, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 409, ".input.spin", state 621, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 413, ".input.spin", state 635, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 238, ".input.spin", state 653, "(1)" + line 246, ".input.spin", state 673, "(1)" + line 250, ".input.spin", state 681, "(1)" + line 400, ".input.spin", state 707, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 400, ".input.spin", state 709, "(1)" + line 400, ".input.spin", state 710, "((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid)))" + line 400, ".input.spin", state 710, "else" + line 400, ".input.spin", state 713, "(1)" + line 404, ".input.spin", state 721, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 404, ".input.spin", state 723, "(1)" + line 404, ".input.spin", state 724, "((cache_dirty_urcu_active_readers.bitfield&(1<<_pid)))" + line 404, ".input.spin", state 724, "else" + line 404, ".input.spin", state 727, "(1)" + line 404, ".input.spin", state 728, "(1)" + line 404, ".input.spin", state 728, "(1)" + line 402, ".input.spin", state 733, "((i<1))" + line 402, ".input.spin", state 733, "((i>=1))" + line 409, ".input.spin", state 739, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 409, ".input.spin", state 741, "(1)" + line 409, ".input.spin", state 742, "((cache_dirty_rcu_ptr.bitfield&(1<<_pid)))" + line 409, ".input.spin", state 742, "else" + line 409, ".input.spin", state 745, "(1)" + line 409, ".input.spin", state 746, "(1)" + line 409, ".input.spin", state 746, "(1)" + line 413, ".input.spin", state 753, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 413, ".input.spin", state 755, "(1)" + line 413, ".input.spin", state 756, "((cache_dirty_rcu_data[i].bitfield&(1<<_pid)))" + line 413, ".input.spin", state 756, "else" + line 413, ".input.spin", state 759, "(1)" + line 413, ".input.spin", state 760, "(1)" + line 413, ".input.spin", state 760, "(1)" + line 411, ".input.spin", state 765, "((i<2))" + line 411, ".input.spin", state 765, "((i>=2))" + line 238, ".input.spin", state 771, "(1)" + line 242, ".input.spin", state 779, "(1)" + line 242, ".input.spin", state 780, "(!((cache_dirty_urcu_active_readers.bitfield&(1<<_pid))))" + line 242, ".input.spin", state 780, "else" + line 240, ".input.spin", state 785, "((i<1))" + line 240, ".input.spin", state 785, "((i>=1))" + line 246, ".input.spin", state 791, "(1)" + line 246, ".input.spin", state 792, "(!((cache_dirty_rcu_ptr.bitfield&(1<<_pid))))" + line 246, ".input.spin", state 792, "else" + line 250, ".input.spin", state 799, "(1)" + line 250, ".input.spin", state 800, "(!((cache_dirty_rcu_data[i].bitfield&(1<<_pid))))" + line 250, ".input.spin", state 800, "else" + line 255, ".input.spin", state 809, "(!((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid))))" + line 255, ".input.spin", state 809, "else" + line 420, ".input.spin", state 811, "(1)" + line 420, ".input.spin", state 811, "(1)" + line 400, ".input.spin", state 818, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 400, ".input.spin", state 820, "(1)" + line 400, ".input.spin", state 821, "((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid)))" + line 400, ".input.spin", state 821, "else" + line 400, ".input.spin", state 824, "(1)" + line 404, ".input.spin", state 832, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 404, ".input.spin", state 834, "(1)" + line 404, ".input.spin", state 835, "((cache_dirty_urcu_active_readers.bitfield&(1<<_pid)))" + line 404, ".input.spin", state 835, "else" + line 404, ".input.spin", state 838, "(1)" + line 404, ".input.spin", state 839, "(1)" + line 404, ".input.spin", state 839, "(1)" + line 402, ".input.spin", state 844, "((i<1))" + line 402, ".input.spin", state 844, "((i>=1))" + line 409, ".input.spin", state 850, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 409, ".input.spin", state 852, "(1)" + line 409, ".input.spin", state 853, "((cache_dirty_rcu_ptr.bitfield&(1<<_pid)))" + line 409, ".input.spin", state 853, "else" + line 409, ".input.spin", state 856, "(1)" + line 409, ".input.spin", state 857, "(1)" + line 409, ".input.spin", state 857, "(1)" + line 413, ".input.spin", state 864, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 413, ".input.spin", state 866, "(1)" + line 413, ".input.spin", state 867, "((cache_dirty_rcu_data[i].bitfield&(1<<_pid)))" + line 413, ".input.spin", state 867, "else" + line 413, ".input.spin", state 870, "(1)" + line 413, ".input.spin", state 871, "(1)" + line 413, ".input.spin", state 871, "(1)" + line 411, ".input.spin", state 876, "((i<2))" + line 411, ".input.spin", state 876, "((i>=2))" + line 238, ".input.spin", state 882, "(1)" + line 242, ".input.spin", state 890, "(1)" + line 242, ".input.spin", state 891, "(!((cache_dirty_urcu_active_readers.bitfield&(1<<_pid))))" + line 242, ".input.spin", state 891, "else" + line 240, ".input.spin", state 896, "((i<1))" + line 240, ".input.spin", state 896, "((i>=1))" + line 246, ".input.spin", state 902, "(1)" + line 246, ".input.spin", state 903, "(!((cache_dirty_rcu_ptr.bitfield&(1<<_pid))))" + line 246, ".input.spin", state 903, "else" + line 250, ".input.spin", state 910, "(1)" + line 250, ".input.spin", state 911, "(!((cache_dirty_rcu_data[i].bitfield&(1<<_pid))))" + line 250, ".input.spin", state 911, "else" + line 248, ".input.spin", state 916, "((i<2))" + line 248, ".input.spin", state 916, "((i>=2))" + line 255, ".input.spin", state 920, "(!((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid))))" + line 255, ".input.spin", state 920, "else" + line 420, ".input.spin", state 922, "(1)" + line 420, ".input.spin", state 922, "(1)" + line 687, ".input.spin", state 926, "_proc_urcu_reader = (_proc_urcu_reader|(1<<11))" + line 400, ".input.spin", state 931, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 409, ".input.spin", state 963, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 413, ".input.spin", state 977, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 238, ".input.spin", state 995, "(1)" + line 246, ".input.spin", state 1015, "(1)" + line 250, ".input.spin", state 1023, "(1)" + line 400, ".input.spin", state 1045, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 409, ".input.spin", state 1077, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 413, ".input.spin", state 1091, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 238, ".input.spin", state 1109, "(1)" + line 246, ".input.spin", state 1129, "(1)" + line 250, ".input.spin", state 1137, "(1)" + line 400, ".input.spin", state 1160, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 409, ".input.spin", state 1192, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 413, ".input.spin", state 1206, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 238, ".input.spin", state 1224, "(1)" + line 246, ".input.spin", state 1244, "(1)" + line 250, ".input.spin", state 1252, "(1)" + line 400, ".input.spin", state 1271, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 409, ".input.spin", state 1303, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 413, ".input.spin", state 1317, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 238, ".input.spin", state 1335, "(1)" + line 246, ".input.spin", state 1355, "(1)" + line 250, ".input.spin", state 1363, "(1)" + line 400, ".input.spin", state 1387, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 409, ".input.spin", state 1419, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 413, ".input.spin", state 1433, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 238, ".input.spin", state 1451, "(1)" + line 246, ".input.spin", state 1471, "(1)" + line 250, ".input.spin", state 1479, "(1)" + line 400, ".input.spin", state 1498, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 409, ".input.spin", state 1530, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 413, ".input.spin", state 1544, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 238, ".input.spin", state 1562, "(1)" + line 246, ".input.spin", state 1582, "(1)" + line 250, ".input.spin", state 1590, "(1)" + line 400, ".input.spin", state 1612, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 409, ".input.spin", state 1644, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 413, ".input.spin", state 1658, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 238, ".input.spin", state 1676, "(1)" + line 246, ".input.spin", state 1696, "(1)" + line 250, ".input.spin", state 1704, "(1)" + line 726, ".input.spin", state 1723, "_proc_urcu_reader = (_proc_urcu_reader|((1<<2)<<19))" + line 400, ".input.spin", state 1730, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 409, ".input.spin", state 1762, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 413, ".input.spin", state 1776, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 238, ".input.spin", state 1794, "(1)" + line 246, ".input.spin", state 1814, "(1)" + line 250, ".input.spin", state 1822, "(1)" + line 400, ".input.spin", state 1841, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 409, ".input.spin", state 1873, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 413, ".input.spin", state 1887, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 238, ".input.spin", state 1905, "(1)" + line 246, ".input.spin", state 1925, "(1)" + line 250, ".input.spin", state 1933, "(1)" + line 400, ".input.spin", state 1954, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 400, ".input.spin", state 1956, "(1)" + line 400, ".input.spin", state 1957, "((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid)))" + line 400, ".input.spin", state 1957, "else" + line 400, ".input.spin", state 1960, "(1)" + line 404, ".input.spin", state 1968, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 404, ".input.spin", state 1970, "(1)" + line 404, ".input.spin", state 1971, "((cache_dirty_urcu_active_readers.bitfield&(1<<_pid)))" + line 404, ".input.spin", state 1971, "else" + line 404, ".input.spin", state 1974, "(1)" + line 404, ".input.spin", state 1975, "(1)" + line 404, ".input.spin", state 1975, "(1)" + line 402, ".input.spin", state 1980, "((i<1))" + line 402, ".input.spin", state 1980, "((i>=1))" + line 409, ".input.spin", state 1986, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 409, ".input.spin", state 1988, "(1)" + line 409, ".input.spin", state 1989, "((cache_dirty_rcu_ptr.bitfield&(1<<_pid)))" + line 409, ".input.spin", state 1989, "else" + line 409, ".input.spin", state 1992, "(1)" + line 409, ".input.spin", state 1993, "(1)" + line 409, ".input.spin", state 1993, "(1)" + line 413, ".input.spin", state 2000, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 413, ".input.spin", state 2002, "(1)" + line 413, ".input.spin", state 2003, "((cache_dirty_rcu_data[i].bitfield&(1<<_pid)))" + line 413, ".input.spin", state 2003, "else" + line 413, ".input.spin", state 2006, "(1)" + line 413, ".input.spin", state 2007, "(1)" + line 413, ".input.spin", state 2007, "(1)" + line 411, ".input.spin", state 2012, "((i<2))" + line 411, ".input.spin", state 2012, "((i>=2))" + line 238, ".input.spin", state 2018, "(1)" + line 242, ".input.spin", state 2026, "(1)" + line 242, ".input.spin", state 2027, "(!((cache_dirty_urcu_active_readers.bitfield&(1<<_pid))))" + line 242, ".input.spin", state 2027, "else" + line 240, ".input.spin", state 2032, "((i<1))" + line 240, ".input.spin", state 2032, "((i>=1))" + line 246, ".input.spin", state 2038, "(1)" + line 246, ".input.spin", state 2039, "(!((cache_dirty_rcu_ptr.bitfield&(1<<_pid))))" + line 246, ".input.spin", state 2039, "else" + line 250, ".input.spin", state 2046, "(1)" + line 250, ".input.spin", state 2047, "(!((cache_dirty_rcu_data[i].bitfield&(1<<_pid))))" + line 250, ".input.spin", state 2047, "else" + line 248, ".input.spin", state 2052, "((i<2))" + line 248, ".input.spin", state 2052, "((i>=2))" + line 255, ".input.spin", state 2056, "(!((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid))))" + line 255, ".input.spin", state 2056, "else" + line 420, ".input.spin", state 2058, "(1)" + line 420, ".input.spin", state 2058, "(1)" + line 726, ".input.spin", state 2061, "cached_urcu_active_readers.val[_pid] = (tmp+1)" + line 726, ".input.spin", state 2062, "_proc_urcu_reader = (_proc_urcu_reader|(1<<23))" + line 726, ".input.spin", state 2063, "(1)" + line 400, ".input.spin", state 2070, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 409, ".input.spin", state 2102, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 413, ".input.spin", state 2116, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 238, ".input.spin", state 2134, "(1)" + line 246, ".input.spin", state 2154, "(1)" + line 250, ".input.spin", state 2162, "(1)" + line 400, ".input.spin", state 2187, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 409, ".input.spin", state 2219, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 413, ".input.spin", state 2233, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 238, ".input.spin", state 2251, "(1)" + line 246, ".input.spin", state 2271, "(1)" + line 250, ".input.spin", state 2279, "(1)" + line 400, ".input.spin", state 2298, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 409, ".input.spin", state 2330, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 413, ".input.spin", state 2344, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 238, ".input.spin", state 2362, "(1)" + line 246, ".input.spin", state 2382, "(1)" + line 250, ".input.spin", state 2390, "(1)" + line 238, ".input.spin", state 2421, "(1)" + line 246, ".input.spin", state 2441, "(1)" + line 250, ".input.spin", state 2449, "(1)" + line 238, ".input.spin", state 2464, "(1)" + line 246, ".input.spin", state 2484, "(1)" + line 250, ".input.spin", state 2492, "(1)" + line 886, ".input.spin", state 2509, "-end-" + (246 of 2509 states) +unreached in proctype urcu_writer + line 400, ".input.spin", state 18, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 404, ".input.spin", state 32, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 409, ".input.spin", state 50, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 238, ".input.spin", state 82, "(1)" + line 242, ".input.spin", state 90, "(1)" + line 246, ".input.spin", state 102, "(1)" + line 261, ".input.spin", state 131, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 265, ".input.spin", state 140, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 269, ".input.spin", state 153, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 400, ".input.spin", state 193, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 404, ".input.spin", state 207, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 409, ".input.spin", state 225, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 413, ".input.spin", state 239, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 238, ".input.spin", state 257, "(1)" + line 242, ".input.spin", state 265, "(1)" + line 246, ".input.spin", state 277, "(1)" + line 250, ".input.spin", state 285, "(1)" + line 404, ".input.spin", state 320, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 409, ".input.spin", state 338, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 413, ".input.spin", state 352, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 242, ".input.spin", state 378, "(1)" + line 246, ".input.spin", state 390, "(1)" + line 250, ".input.spin", state 398, "(1)" + line 404, ".input.spin", state 440, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 409, ".input.spin", state 458, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 413, ".input.spin", state 472, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 242, ".input.spin", state 498, "(1)" + line 246, ".input.spin", state 510, "(1)" + line 250, ".input.spin", state 518, "(1)" + line 404, ".input.spin", state 551, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 409, ".input.spin", state 569, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 413, ".input.spin", state 583, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 242, ".input.spin", state 609, "(1)" + line 246, ".input.spin", state 621, "(1)" + line 250, ".input.spin", state 629, "(1)" + line 404, ".input.spin", state 664, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 409, ".input.spin", state 682, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 413, ".input.spin", state 696, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 242, ".input.spin", state 722, "(1)" + line 246, ".input.spin", state 734, "(1)" + line 250, ".input.spin", state 742, "(1)" + line 261, ".input.spin", state 795, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 265, ".input.spin", state 804, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 269, ".input.spin", state 819, "(1)" + line 273, ".input.spin", state 826, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 238, ".input.spin", state 842, "(1)" + line 242, ".input.spin", state 850, "(1)" + line 246, ".input.spin", state 862, "(1)" + line 250, ".input.spin", state 870, "(1)" + line 261, ".input.spin", state 901, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 265, ".input.spin", state 910, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 269, ".input.spin", state 923, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 273, ".input.spin", state 932, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 238, ".input.spin", state 948, "(1)" + line 242, ".input.spin", state 956, "(1)" + line 246, ".input.spin", state 968, "(1)" + line 250, ".input.spin", state 976, "(1)" + line 265, ".input.spin", state 1002, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 269, ".input.spin", state 1015, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 273, ".input.spin", state 1024, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 238, ".input.spin", state 1040, "(1)" + line 242, ".input.spin", state 1048, "(1)" + line 246, ".input.spin", state 1060, "(1)" + line 250, ".input.spin", state 1068, "(1)" + line 261, ".input.spin", state 1099, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 265, ".input.spin", state 1108, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 269, ".input.spin", state 1121, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 273, ".input.spin", state 1130, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 238, ".input.spin", state 1146, "(1)" + line 242, ".input.spin", state 1154, "(1)" + line 246, ".input.spin", state 1166, "(1)" + line 250, ".input.spin", state 1174, "(1)" + line 265, ".input.spin", state 1200, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 269, ".input.spin", state 1213, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 273, ".input.spin", state 1222, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 238, ".input.spin", state 1238, "(1)" + line 242, ".input.spin", state 1246, "(1)" + line 246, ".input.spin", state 1258, "(1)" + line 250, ".input.spin", state 1266, "(1)" + line 261, ".input.spin", state 1297, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 265, ".input.spin", state 1306, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 269, ".input.spin", state 1319, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 273, ".input.spin", state 1328, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 238, ".input.spin", state 1344, "(1)" + line 242, ".input.spin", state 1352, "(1)" + line 246, ".input.spin", state 1364, "(1)" + line 250, ".input.spin", state 1372, "(1)" + line 265, ".input.spin", state 1398, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 269, ".input.spin", state 1411, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 273, ".input.spin", state 1420, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 238, ".input.spin", state 1436, "(1)" + line 242, ".input.spin", state 1444, "(1)" + line 246, ".input.spin", state 1456, "(1)" + line 250, ".input.spin", state 1464, "(1)" + line 261, ".input.spin", state 1495, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 265, ".input.spin", state 1504, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 269, ".input.spin", state 1517, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 273, ".input.spin", state 1526, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 238, ".input.spin", state 1542, "(1)" + line 242, ".input.spin", state 1550, "(1)" + line 246, ".input.spin", state 1562, "(1)" + line 250, ".input.spin", state 1570, "(1)" + line 1213, ".input.spin", state 1586, "-end-" + (103 of 1586 states) +unreached in proctype :init: + (0 of 78 states) + +pan: elapsed time 291 seconds +pan: rate 41688.913 states/second +pan: avg transition delay 2.2686e-06 usec +cp .input.spin asserts.spin.input +cp .input.spin.trail asserts.spin.input.trail +make[1]: Leaving directory `/home/compudj/doc/userspace-rcu/formal-model/urcu-controldataflow' diff --git a/formal-model/results/urcu-controldataflow-ipi-intel/asserts.spin.input b/formal-model/results/urcu-controldataflow-ipi-intel/asserts.spin.input new file mode 100644 index 0000000..8afab6a --- /dev/null +++ b/formal-model/results/urcu-controldataflow-ipi-intel/asserts.spin.input @@ -0,0 +1,1249 @@ + +// Poison value for freed memory +#define POISON 1 +// Memory with correct data +#define WINE 0 +#define SLAB_SIZE 2 + +#define read_poison (data_read_first[0] == POISON || data_read_second[0] == POISON) + +#define RCU_GP_CTR_BIT (1 << 7) +#define RCU_GP_CTR_NEST_MASK (RCU_GP_CTR_BIT - 1) + +//disabled +#define REMOTE_BARRIERS + +//#define ARCH_ALPHA +#define ARCH_INTEL +//#define ARCH_POWERPC +/* + * mem.spin: Promela code to validate memory barriers with OOO memory + * and out-of-order instruction scheduling. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * Copyright (c) 2009 Mathieu Desnoyers + */ + +/* Promela validation variables. */ + +/* specific defines "included" here */ +/* DEFINES file "included" here */ + +#define NR_READERS 1 +#define NR_WRITERS 1 + +#define NR_PROCS 2 + +#define get_pid() (_pid) + +#define get_readerid() (get_pid()) + +/* + * Produced process control and data flow. Updated after each instruction to + * show which variables are ready. Using one-hot bit encoding per variable to + * save state space. Used as triggers to execute the instructions having those + * variables as input. Leaving bits active to inhibit instruction execution. + * Scheme used to make instruction disabling and automatic dependency fall-back + * automatic. + */ + +#define CONSUME_TOKENS(state, bits, notbits) \ + ((!(state & (notbits))) && (state & (bits)) == (bits)) + +#define PRODUCE_TOKENS(state, bits) \ + state = state | (bits); + +#define CLEAR_TOKENS(state, bits) \ + state = state & ~(bits) + +/* + * Types of dependency : + * + * Data dependency + * + * - True dependency, Read-after-Write (RAW) + * + * This type of dependency happens when a statement depends on the result of a + * previous statement. This applies to any statement which needs to read a + * variable written by a preceding statement. + * + * - False dependency, Write-after-Read (WAR) + * + * Typically, variable renaming can ensure that this dependency goes away. + * However, if the statements must read and then write from/to the same variable + * in the OOO memory model, renaming may be impossible, and therefore this + * causes a WAR dependency. + * + * - Output dependency, Write-after-Write (WAW) + * + * Two writes to the same variable in subsequent statements. Variable renaming + * can ensure this is not needed, but can be required when writing multiple + * times to the same OOO mem model variable. + * + * Control dependency + * + * Execution of a given instruction depends on a previous instruction evaluating + * in a way that allows its execution. E.g. : branches. + * + * Useful considerations for joining dependencies after branch + * + * - Pre-dominance + * + * "We say box i dominates box j if every path (leading from input to output + * through the diagram) which passes through box j must also pass through box + * i. Thus box i dominates box j if box j is subordinate to box i in the + * program." + * + * http://www.hipersoft.rice.edu/grads/publications/dom14.pdf + * Other classic algorithm to calculate dominance : Lengauer-Tarjan (in gcc) + * + * - Post-dominance + * + * Just as pre-dominance, but with arcs of the data flow inverted, and input vs + * output exchanged. Therefore, i post-dominating j ensures that every path + * passing by j will pass by i before reaching the output. + * + * Other considerations + * + * Note about "volatile" keyword dependency : The compiler will order volatile + * accesses so they appear in the right order on a given CPU. They can be + * reordered by the CPU instruction scheduling. This therefore cannot be + * considered as a depencency. + * + * References : + * + * Cooper, Keith D.; & Torczon, Linda. (2005). Engineering a Compiler. Morgan + * Kaufmann. ISBN 1-55860-698-X. + * Kennedy, Ken; & Allen, Randy. (2001). Optimizing Compilers for Modern + * Architectures: A Dependence-based Approach. Morgan Kaufmann. ISBN + * 1-55860-286-0. + * Muchnick, Steven S. (1997). Advanced Compiler Design and Implementation. + * Morgan Kaufmann. ISBN 1-55860-320-4. + */ + +/* + * Note about loops and nested calls + * + * To keep this model simple, loops expressed in the framework will behave as if + * there was a core synchronizing instruction between loops. To see the effect + * of loop unrolling, manually unrolling loops is required. Note that if loops + * end or start with a core synchronizing instruction, the model is appropriate. + * Nested calls are not supported. + */ + +/* + * Only Alpha has out-of-order cache bank loads. Other architectures (intel, + * powerpc, arm) ensure that dependent reads won't be reordered. c.f. + * http://www.linuxjournal.com/article/8212) +#ifdef ARCH_ALPHA +#define HAVE_OOO_CACHE_READ +#endif + +/* + * Each process have its own data in cache. Caches are randomly updated. + * smp_wmb and smp_rmb forces cache updates (write and read), smp_mb forces + * both. + */ + +typedef per_proc_byte { + byte val[NR_PROCS]; +}; + +typedef per_proc_bit { + bit val[NR_PROCS]; +}; + +/* Bitfield has a maximum of 8 procs */ +typedef per_proc_bitfield { + byte bitfield; +}; + +#define DECLARE_CACHED_VAR(type, x) \ + type mem_##x; \ + per_proc_##type cached_##x; \ + per_proc_bitfield cache_dirty_##x; + +#define INIT_CACHED_VAR(x, v, j) \ + mem_##x = v; \ + cache_dirty_##x.bitfield = 0; \ + j = 0; \ + do \ + :: j < NR_PROCS -> \ + cached_##x.val[j] = v; \ + j++ \ + :: j >= NR_PROCS -> break \ + od; + +#define IS_CACHE_DIRTY(x, id) (cache_dirty_##x.bitfield & (1 << id)) + +#define READ_CACHED_VAR(x) (cached_##x.val[get_pid()]) + +#define WRITE_CACHED_VAR(x, v) \ + atomic { \ + cached_##x.val[get_pid()] = v; \ + cache_dirty_##x.bitfield = \ + cache_dirty_##x.bitfield | (1 << get_pid()); \ + } + +#define CACHE_WRITE_TO_MEM(x, id) \ + if \ + :: IS_CACHE_DIRTY(x, id) -> \ + mem_##x = cached_##x.val[id]; \ + cache_dirty_##x.bitfield = \ + cache_dirty_##x.bitfield & (~(1 << id)); \ + :: else -> \ + skip \ + fi; + +#define CACHE_READ_FROM_MEM(x, id) \ + if \ + :: !IS_CACHE_DIRTY(x, id) -> \ + cached_##x.val[id] = mem_##x;\ + :: else -> \ + skip \ + fi; + +/* + * May update other caches if cache is dirty, or not. + */ +#define RANDOM_CACHE_WRITE_TO_MEM(x, id)\ + if \ + :: 1 -> CACHE_WRITE_TO_MEM(x, id); \ + :: 1 -> skip \ + fi; + +#define RANDOM_CACHE_READ_FROM_MEM(x, id)\ + if \ + :: 1 -> CACHE_READ_FROM_MEM(x, id); \ + :: 1 -> skip \ + fi; + +/* Must consume all prior read tokens. All subsequent reads depend on it. */ +inline smp_rmb(i) +{ + atomic { + CACHE_READ_FROM_MEM(urcu_gp_ctr, get_pid()); + i = 0; + do + :: i < NR_READERS -> + CACHE_READ_FROM_MEM(urcu_active_readers[i], get_pid()); + i++ + :: i >= NR_READERS -> break + od; + CACHE_READ_FROM_MEM(rcu_ptr, get_pid()); + i = 0; + do + :: i < SLAB_SIZE -> + CACHE_READ_FROM_MEM(rcu_data[i], get_pid()); + i++ + :: i >= SLAB_SIZE -> break + od; + } +} + +/* Must consume all prior write tokens. All subsequent writes depend on it. */ +inline smp_wmb(i) +{ + atomic { + CACHE_WRITE_TO_MEM(urcu_gp_ctr, get_pid()); + i = 0; + do + :: i < NR_READERS -> + CACHE_WRITE_TO_MEM(urcu_active_readers[i], get_pid()); + i++ + :: i >= NR_READERS -> break + od; + CACHE_WRITE_TO_MEM(rcu_ptr, get_pid()); + i = 0; + do + :: i < SLAB_SIZE -> + CACHE_WRITE_TO_MEM(rcu_data[i], get_pid()); + i++ + :: i >= SLAB_SIZE -> break + od; + } +} + +/* Synchronization point. Must consume all prior read and write tokens. All + * subsequent reads and writes depend on it. */ +inline smp_mb(i) +{ + atomic { + smp_wmb(i); + smp_rmb(i); + } +} + +#ifdef REMOTE_BARRIERS + +bit reader_barrier[NR_READERS]; + +/* + * We cannot leave the barriers dependencies in place in REMOTE_BARRIERS mode + * because they would add unexisting core synchronization and would therefore + * create an incomplete model. + * Therefore, we model the read-side memory barriers by completely disabling the + * memory barriers and their dependencies from the read-side. One at a time + * (different verification runs), we make a different instruction listen for + * signals. + */ + +#define smp_mb_reader(i, j) + +/* + * Service 0, 1 or many barrier requests. + */ +inline smp_mb_recv(i, j) +{ + do + :: (reader_barrier[get_readerid()] == 1) -> + /* + * We choose to ignore cycles caused by writer busy-looping, + * waiting for the reader, sending barrier requests, and the + * reader always services them without continuing execution. + */ +progress_ignoring_mb1: + smp_mb(i); + reader_barrier[get_readerid()] = 0; + :: 1 -> + /* + * We choose to ignore writer's non-progress caused by the + * reader ignoring the writer's mb() requests. + */ +progress_ignoring_mb2: + break; + od; +} + +#define PROGRESS_LABEL(progressid) progress_writer_progid_##progressid: + +#define smp_mb_send(i, j, progressid) \ +{ \ + smp_mb(i); \ + i = 0; \ + do \ + :: i < NR_READERS -> \ + reader_barrier[i] = 1; \ + /* \ + * Busy-looping waiting for reader barrier handling is of little\ + * interest, given the reader has the ability to totally ignore \ + * barrier requests. \ + */ \ + do \ + :: (reader_barrier[i] == 1) -> \ +PROGRESS_LABEL(progressid) \ + skip; \ + :: (reader_barrier[i] == 0) -> break; \ + od; \ + i++; \ + :: i >= NR_READERS -> \ + break \ + od; \ + smp_mb(i); \ +} + +#else + +#define smp_mb_send(i, j, progressid) smp_mb(i) +#define smp_mb_reader smp_mb(i) +#define smp_mb_recv(i, j) + +#endif + +/* Keep in sync manually with smp_rmb, smp_wmb, ooo_mem and init() */ +DECLARE_CACHED_VAR(byte, urcu_gp_ctr); +/* Note ! currently only one reader */ +DECLARE_CACHED_VAR(byte, urcu_active_readers[NR_READERS]); +/* RCU data */ +DECLARE_CACHED_VAR(bit, rcu_data[SLAB_SIZE]); + +/* RCU pointer */ +#if (SLAB_SIZE == 2) +DECLARE_CACHED_VAR(bit, rcu_ptr); +bit ptr_read_first[NR_READERS]; +bit ptr_read_second[NR_READERS]; +#else +DECLARE_CACHED_VAR(byte, rcu_ptr); +byte ptr_read_first[NR_READERS]; +byte ptr_read_second[NR_READERS]; +#endif + +bit data_read_first[NR_READERS]; +bit data_read_second[NR_READERS]; + +bit init_done = 0; + +inline wait_init_done() +{ + do + :: init_done == 0 -> skip; + :: else -> break; + od; +} + +inline ooo_mem(i) +{ + atomic { + RANDOM_CACHE_WRITE_TO_MEM(urcu_gp_ctr, get_pid()); + i = 0; + do + :: i < NR_READERS -> + RANDOM_CACHE_WRITE_TO_MEM(urcu_active_readers[i], + get_pid()); + i++ + :: i >= NR_READERS -> break + od; + RANDOM_CACHE_WRITE_TO_MEM(rcu_ptr, get_pid()); + i = 0; + do + :: i < SLAB_SIZE -> + RANDOM_CACHE_WRITE_TO_MEM(rcu_data[i], get_pid()); + i++ + :: i >= SLAB_SIZE -> break + od; +#ifdef HAVE_OOO_CACHE_READ + RANDOM_CACHE_READ_FROM_MEM(urcu_gp_ctr, get_pid()); + i = 0; + do + :: i < NR_READERS -> + RANDOM_CACHE_READ_FROM_MEM(urcu_active_readers[i], + get_pid()); + i++ + :: i >= NR_READERS -> break + od; + RANDOM_CACHE_READ_FROM_MEM(rcu_ptr, get_pid()); + i = 0; + do + :: i < SLAB_SIZE -> + RANDOM_CACHE_READ_FROM_MEM(rcu_data[i], get_pid()); + i++ + :: i >= SLAB_SIZE -> break + od; +#else + smp_rmb(i); +#endif /* HAVE_OOO_CACHE_READ */ + } +} + +/* + * Bit encoding, urcu_reader : + */ + +int _proc_urcu_reader; +#define proc_urcu_reader _proc_urcu_reader + +/* Body of PROCEDURE_READ_LOCK */ +#define READ_PROD_A_READ (1 << 0) +#define READ_PROD_B_IF_TRUE (1 << 1) +#define READ_PROD_B_IF_FALSE (1 << 2) +#define READ_PROD_C_IF_TRUE_READ (1 << 3) + +#define PROCEDURE_READ_LOCK(base, consumetoken, producetoken) \ + :: CONSUME_TOKENS(proc_urcu_reader, consumetoken, READ_PROD_A_READ << base) -> \ + ooo_mem(i); \ + tmp = READ_CACHED_VAR(urcu_active_readers[get_readerid()]); \ + PRODUCE_TOKENS(proc_urcu_reader, READ_PROD_A_READ << base); \ + :: CONSUME_TOKENS(proc_urcu_reader, \ + READ_PROD_A_READ << base, /* RAW, pre-dominant */ \ + (READ_PROD_B_IF_TRUE | READ_PROD_B_IF_FALSE) << base) -> \ + if \ + :: (!(tmp & RCU_GP_CTR_NEST_MASK)) -> \ + PRODUCE_TOKENS(proc_urcu_reader, READ_PROD_B_IF_TRUE << base); \ + :: else -> \ + PRODUCE_TOKENS(proc_urcu_reader, READ_PROD_B_IF_FALSE << base); \ + fi; \ + /* IF TRUE */ \ + :: CONSUME_TOKENS(proc_urcu_reader, READ_PROD_B_IF_TRUE << base, \ + READ_PROD_C_IF_TRUE_READ << base) -> \ + ooo_mem(i); \ + tmp2 = READ_CACHED_VAR(urcu_gp_ctr); \ + PRODUCE_TOKENS(proc_urcu_reader, READ_PROD_C_IF_TRUE_READ << base); \ + :: CONSUME_TOKENS(proc_urcu_reader, \ + (READ_PROD_C_IF_TRUE_READ /* pre-dominant */ \ + | READ_PROD_A_READ) << base, /* WAR */ \ + producetoken) -> \ + ooo_mem(i); \ + WRITE_CACHED_VAR(urcu_active_readers[get_readerid()], tmp2); \ + PRODUCE_TOKENS(proc_urcu_reader, producetoken); \ + /* IF_MERGE implies \ + * post-dominance */ \ + /* ELSE */ \ + :: CONSUME_TOKENS(proc_urcu_reader, \ + (READ_PROD_B_IF_FALSE /* pre-dominant */ \ + | READ_PROD_A_READ) << base, /* WAR */ \ + producetoken) -> \ + ooo_mem(i); \ + WRITE_CACHED_VAR(urcu_active_readers[get_readerid()], \ + tmp + 1); \ + PRODUCE_TOKENS(proc_urcu_reader, producetoken); \ + /* IF_MERGE implies \ + * post-dominance */ \ + /* ENDIF */ \ + skip + +/* Body of PROCEDURE_READ_LOCK */ +#define READ_PROC_READ_UNLOCK (1 << 0) + +#define PROCEDURE_READ_UNLOCK(base, consumetoken, producetoken) \ + :: CONSUME_TOKENS(proc_urcu_reader, \ + consumetoken, \ + READ_PROC_READ_UNLOCK << base) -> \ + ooo_mem(i); \ + tmp2 = READ_CACHED_VAR(urcu_active_readers[get_readerid()]); \ + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_READ_UNLOCK << base); \ + :: CONSUME_TOKENS(proc_urcu_reader, \ + consumetoken \ + | (READ_PROC_READ_UNLOCK << base), /* WAR */ \ + producetoken) -> \ + ooo_mem(i); \ + WRITE_CACHED_VAR(urcu_active_readers[get_readerid()], tmp2 - 1); \ + PRODUCE_TOKENS(proc_urcu_reader, producetoken); \ + skip + + +#define READ_PROD_NONE (1 << 0) + +/* PROCEDURE_READ_LOCK base = << 1 : 1 to 5 */ +#define READ_LOCK_BASE 1 +#define READ_LOCK_OUT (1 << 5) + +#define READ_PROC_FIRST_MB (1 << 6) + +/* PROCEDURE_READ_LOCK (NESTED) base : << 7 : 7 to 11 */ +#define READ_LOCK_NESTED_BASE 7 +#define READ_LOCK_NESTED_OUT (1 << 11) + +#define READ_PROC_READ_GEN (1 << 12) +#define READ_PROC_ACCESS_GEN (1 << 13) + +/* PROCEDURE_READ_UNLOCK (NESTED) base = << 14 : 14 to 15 */ +#define READ_UNLOCK_NESTED_BASE 14 +#define READ_UNLOCK_NESTED_OUT (1 << 15) + +#define READ_PROC_SECOND_MB (1 << 16) + +/* PROCEDURE_READ_UNLOCK base = << 17 : 17 to 18 */ +#define READ_UNLOCK_BASE 17 +#define READ_UNLOCK_OUT (1 << 18) + +/* PROCEDURE_READ_LOCK_UNROLL base = << 19 : 19 to 23 */ +#define READ_LOCK_UNROLL_BASE 19 +#define READ_LOCK_OUT_UNROLL (1 << 23) + +#define READ_PROC_THIRD_MB (1 << 24) + +#define READ_PROC_READ_GEN_UNROLL (1 << 25) +#define READ_PROC_ACCESS_GEN_UNROLL (1 << 26) + +#define READ_PROC_FOURTH_MB (1 << 27) + +/* PROCEDURE_READ_UNLOCK_UNROLL base = << 28 : 28 to 29 */ +#define READ_UNLOCK_UNROLL_BASE 28 +#define READ_UNLOCK_OUT_UNROLL (1 << 29) + + +/* Should not include branches */ +#define READ_PROC_ALL_TOKENS (READ_PROD_NONE \ + | READ_LOCK_OUT \ + | READ_PROC_FIRST_MB \ + | READ_LOCK_NESTED_OUT \ + | READ_PROC_READ_GEN \ + | READ_PROC_ACCESS_GEN \ + | READ_UNLOCK_NESTED_OUT \ + | READ_PROC_SECOND_MB \ + | READ_UNLOCK_OUT \ + | READ_LOCK_OUT_UNROLL \ + | READ_PROC_THIRD_MB \ + | READ_PROC_READ_GEN_UNROLL \ + | READ_PROC_ACCESS_GEN_UNROLL \ + | READ_PROC_FOURTH_MB \ + | READ_UNLOCK_OUT_UNROLL) + +/* Must clear all tokens, including branches */ +#define READ_PROC_ALL_TOKENS_CLEAR ((1 << 30) - 1) + +inline urcu_one_read(i, j, nest_i, tmp, tmp2) +{ + PRODUCE_TOKENS(proc_urcu_reader, READ_PROD_NONE); + +#ifdef NO_MB + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_FIRST_MB); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_SECOND_MB); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_THIRD_MB); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_FOURTH_MB); +#endif + +#ifdef REMOTE_BARRIERS + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_FIRST_MB); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_SECOND_MB); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_THIRD_MB); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_FOURTH_MB); +#endif + + do + :: 1 -> + +#ifdef REMOTE_BARRIERS + /* + * Signal-based memory barrier will only execute when the + * execution order appears in program order. + */ + if + :: 1 -> + atomic { + if + :: CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE, + READ_LOCK_OUT | READ_LOCK_NESTED_OUT + | READ_PROC_READ_GEN | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT + | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT, + READ_LOCK_NESTED_OUT + | READ_PROC_READ_GEN | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT + | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT | READ_LOCK_NESTED_OUT, + READ_PROC_READ_GEN | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT + | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN, + READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT + | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN | READ_PROC_ACCESS_GEN, + READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT + | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN + | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT, + READ_UNLOCK_OUT + | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN + | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT, + READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN + | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT | READ_LOCK_OUT_UNROLL, + READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN + | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL, + READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN + | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL, + READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL, + 0) -> + goto non_atomic3; +non_atomic3_end: + skip; + fi; + } + fi; + + goto non_atomic3_skip; +non_atomic3: + smp_mb_recv(i, j); + goto non_atomic3_end; +non_atomic3_skip: + +#endif /* REMOTE_BARRIERS */ + + atomic { + if + PROCEDURE_READ_LOCK(READ_LOCK_BASE, READ_PROD_NONE, READ_LOCK_OUT); + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_LOCK_OUT, /* post-dominant */ + READ_PROC_FIRST_MB) -> + smp_mb_reader(i, j); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_FIRST_MB); + + PROCEDURE_READ_LOCK(READ_LOCK_NESTED_BASE, READ_PROC_FIRST_MB | READ_LOCK_OUT, + READ_LOCK_NESTED_OUT); + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_PROC_FIRST_MB, /* mb() orders reads */ + READ_PROC_READ_GEN) -> + ooo_mem(i); + ptr_read_first[get_readerid()] = READ_CACHED_VAR(rcu_ptr); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_READ_GEN); + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_PROC_FIRST_MB /* mb() orders reads */ + | READ_PROC_READ_GEN, + READ_PROC_ACCESS_GEN) -> + /* smp_read_barrier_depends */ + goto rmb1; +rmb1_end: + data_read_first[get_readerid()] = + READ_CACHED_VAR(rcu_data[ptr_read_first[get_readerid()]]); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_ACCESS_GEN); + + + /* Note : we remove the nested memory barrier from the read unlock + * model, given it is not usually needed. The implementation has the barrier + * because the performance impact added by a branch in the common case does not + * justify it. + */ + + PROCEDURE_READ_UNLOCK(READ_UNLOCK_NESTED_BASE, + READ_PROC_FIRST_MB + | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT, + READ_UNLOCK_NESTED_OUT); + + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_PROC_ACCESS_GEN /* mb() orders reads */ + | READ_PROC_READ_GEN /* mb() orders reads */ + | READ_PROC_FIRST_MB /* mb() ordered */ + | READ_LOCK_OUT /* post-dominant */ + | READ_LOCK_NESTED_OUT /* post-dominant */ + | READ_UNLOCK_NESTED_OUT, + READ_PROC_SECOND_MB) -> + smp_mb_reader(i, j); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_SECOND_MB); + + PROCEDURE_READ_UNLOCK(READ_UNLOCK_BASE, + READ_PROC_SECOND_MB /* mb() orders reads */ + | READ_PROC_FIRST_MB /* mb() orders reads */ + | READ_LOCK_NESTED_OUT /* RAW */ + | READ_LOCK_OUT /* RAW */ + | READ_UNLOCK_NESTED_OUT, /* RAW */ + READ_UNLOCK_OUT); + + /* Unrolling loop : second consecutive lock */ + /* reading urcu_active_readers, which have been written by + * READ_UNLOCK_OUT : RAW */ + PROCEDURE_READ_LOCK(READ_LOCK_UNROLL_BASE, + READ_UNLOCK_OUT /* RAW */ + | READ_PROC_SECOND_MB /* mb() orders reads */ + | READ_PROC_FIRST_MB /* mb() orders reads */ + | READ_LOCK_NESTED_OUT /* RAW */ + | READ_LOCK_OUT /* RAW */ + | READ_UNLOCK_NESTED_OUT, /* RAW */ + READ_LOCK_OUT_UNROLL); + + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_PROC_FIRST_MB /* mb() ordered */ + | READ_PROC_SECOND_MB /* mb() ordered */ + | READ_LOCK_OUT_UNROLL /* post-dominant */ + | READ_LOCK_NESTED_OUT + | READ_LOCK_OUT + | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT, + READ_PROC_THIRD_MB) -> + smp_mb_reader(i, j); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_THIRD_MB); + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_PROC_FIRST_MB /* mb() orders reads */ + | READ_PROC_SECOND_MB /* mb() orders reads */ + | READ_PROC_THIRD_MB, /* mb() orders reads */ + READ_PROC_READ_GEN_UNROLL) -> + ooo_mem(i); + ptr_read_second[get_readerid()] = READ_CACHED_VAR(rcu_ptr); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_READ_GEN_UNROLL); + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_PROC_READ_GEN_UNROLL + | READ_PROC_FIRST_MB /* mb() orders reads */ + | READ_PROC_SECOND_MB /* mb() orders reads */ + | READ_PROC_THIRD_MB, /* mb() orders reads */ + READ_PROC_ACCESS_GEN_UNROLL) -> + /* smp_read_barrier_depends */ + goto rmb2; +rmb2_end: + data_read_second[get_readerid()] = + READ_CACHED_VAR(rcu_data[ptr_read_second[get_readerid()]]); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_ACCESS_GEN_UNROLL); + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_PROC_READ_GEN_UNROLL /* mb() orders reads */ + | READ_PROC_ACCESS_GEN_UNROLL /* mb() orders reads */ + | READ_PROC_FIRST_MB /* mb() ordered */ + | READ_PROC_SECOND_MB /* mb() ordered */ + | READ_PROC_THIRD_MB /* mb() ordered */ + | READ_LOCK_OUT_UNROLL /* post-dominant */ + | READ_LOCK_NESTED_OUT + | READ_LOCK_OUT + | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT, + READ_PROC_FOURTH_MB) -> + smp_mb_reader(i, j); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_FOURTH_MB); + + PROCEDURE_READ_UNLOCK(READ_UNLOCK_UNROLL_BASE, + READ_PROC_FOURTH_MB /* mb() orders reads */ + | READ_PROC_THIRD_MB /* mb() orders reads */ + | READ_LOCK_OUT_UNROLL /* RAW */ + | READ_PROC_SECOND_MB /* mb() orders reads */ + | READ_PROC_FIRST_MB /* mb() orders reads */ + | READ_LOCK_NESTED_OUT /* RAW */ + | READ_LOCK_OUT /* RAW */ + | READ_UNLOCK_NESTED_OUT, /* RAW */ + READ_UNLOCK_OUT_UNROLL); + :: CONSUME_TOKENS(proc_urcu_reader, READ_PROC_ALL_TOKENS, 0) -> + CLEAR_TOKENS(proc_urcu_reader, READ_PROC_ALL_TOKENS_CLEAR); + break; + fi; + } + od; + /* + * Dependency between consecutive loops : + * RAW dependency on + * WRITE_CACHED_VAR(urcu_active_readers[get_readerid()], tmp2 - 1) + * tmp = READ_CACHED_VAR(urcu_active_readers[get_readerid()]); + * between loops. + * _WHEN THE MB()s are in place_, they add full ordering of the + * generation pointer read wrt active reader count read, which ensures + * execution will not spill across loop execution. + * However, in the event mb()s are removed (execution using signal + * handler to promote barrier()() -> smp_mb()), nothing prevents one loop + * to spill its execution on other loop's execution. + */ + goto end; +rmb1: +#ifndef NO_RMB + smp_rmb(i); +#else + ooo_mem(i); +#endif + goto rmb1_end; +rmb2: +#ifndef NO_RMB + smp_rmb(i); +#else + ooo_mem(i); +#endif + goto rmb2_end; +end: + skip; +} + + + +active proctype urcu_reader() +{ + byte i, j, nest_i; + byte tmp, tmp2; + + wait_init_done(); + + assert(get_pid() < NR_PROCS); + +end_reader: + do + :: 1 -> + /* + * We do not test reader's progress here, because we are mainly + * interested in writer's progress. The reader never blocks + * anyway. We have to test for reader/writer's progress + * separately, otherwise we could think the writer is doing + * progress when it's blocked by an always progressing reader. + */ +#ifdef READER_PROGRESS +progress_reader: +#endif + urcu_one_read(i, j, nest_i, tmp, tmp2); + od; +} + +/* no name clash please */ +#undef proc_urcu_reader + + +/* Model the RCU update process. */ + +/* + * Bit encoding, urcu_writer : + * Currently only supports one reader. + */ + +int _proc_urcu_writer; +#define proc_urcu_writer _proc_urcu_writer + +#define WRITE_PROD_NONE (1 << 0) + +#define WRITE_DATA (1 << 1) +#define WRITE_PROC_WMB (1 << 2) +#define WRITE_XCHG_PTR (1 << 3) + +#define WRITE_PROC_FIRST_MB (1 << 4) + +/* first flip */ +#define WRITE_PROC_FIRST_READ_GP (1 << 5) +#define WRITE_PROC_FIRST_WRITE_GP (1 << 6) +#define WRITE_PROC_FIRST_WAIT (1 << 7) +#define WRITE_PROC_FIRST_WAIT_LOOP (1 << 8) + +/* second flip */ +#define WRITE_PROC_SECOND_READ_GP (1 << 9) +#define WRITE_PROC_SECOND_WRITE_GP (1 << 10) +#define WRITE_PROC_SECOND_WAIT (1 << 11) +#define WRITE_PROC_SECOND_WAIT_LOOP (1 << 12) + +#define WRITE_PROC_SECOND_MB (1 << 13) + +#define WRITE_FREE (1 << 14) + +#define WRITE_PROC_ALL_TOKENS (WRITE_PROD_NONE \ + | WRITE_DATA \ + | WRITE_PROC_WMB \ + | WRITE_XCHG_PTR \ + | WRITE_PROC_FIRST_MB \ + | WRITE_PROC_FIRST_READ_GP \ + | WRITE_PROC_FIRST_WRITE_GP \ + | WRITE_PROC_FIRST_WAIT \ + | WRITE_PROC_SECOND_READ_GP \ + | WRITE_PROC_SECOND_WRITE_GP \ + | WRITE_PROC_SECOND_WAIT \ + | WRITE_PROC_SECOND_MB \ + | WRITE_FREE) + +#define WRITE_PROC_ALL_TOKENS_CLEAR ((1 << 15) - 1) + +/* + * Mutexes are implied around writer execution. A single writer at a time. + */ +active proctype urcu_writer() +{ + byte i, j; + byte tmp, tmp2, tmpa; + byte cur_data = 0, old_data, loop_nr = 0; + byte cur_gp_val = 0; /* + * Keep a local trace of the current parity so + * we don't add non-existing dependencies on the global + * GP update. Needed to test single flip case. + */ + + wait_init_done(); + + assert(get_pid() < NR_PROCS); + + do + :: (loop_nr < 3) -> +#ifdef WRITER_PROGRESS +progress_writer1: +#endif + loop_nr = loop_nr + 1; + + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROD_NONE); + +#ifdef NO_WMB + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_WMB); +#endif + +#ifdef NO_MB + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_FIRST_MB); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_MB); +#endif + +#ifdef SINGLE_FLIP + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_READ_GP); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_WRITE_GP); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_WAIT); + /* For single flip, we need to know the current parity */ + cur_gp_val = cur_gp_val ^ RCU_GP_CTR_BIT; +#endif + + do :: 1 -> + atomic { + if + + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_PROD_NONE, + WRITE_DATA) -> + ooo_mem(i); + cur_data = (cur_data + 1) % SLAB_SIZE; + WRITE_CACHED_VAR(rcu_data[cur_data], WINE); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_DATA); + + + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_DATA, + WRITE_PROC_WMB) -> + smp_wmb(i); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_WMB); + + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_PROC_WMB, + WRITE_XCHG_PTR) -> + /* rcu_xchg_pointer() */ + atomic { + old_data = READ_CACHED_VAR(rcu_ptr); + WRITE_CACHED_VAR(rcu_ptr, cur_data); + } + PRODUCE_TOKENS(proc_urcu_writer, WRITE_XCHG_PTR); + + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_DATA | WRITE_PROC_WMB | WRITE_XCHG_PTR, + WRITE_PROC_FIRST_MB) -> + goto smp_mb_send1; +smp_mb_send1_end: + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_FIRST_MB); + + /* first flip */ + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_PROC_FIRST_MB, + WRITE_PROC_FIRST_READ_GP) -> + tmpa = READ_CACHED_VAR(urcu_gp_ctr); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_FIRST_READ_GP); + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_PROC_FIRST_MB | WRITE_PROC_WMB + | WRITE_PROC_FIRST_READ_GP, + WRITE_PROC_FIRST_WRITE_GP) -> + ooo_mem(i); + WRITE_CACHED_VAR(urcu_gp_ctr, tmpa ^ RCU_GP_CTR_BIT); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_FIRST_WRITE_GP); + + :: CONSUME_TOKENS(proc_urcu_writer, + //WRITE_PROC_FIRST_WRITE_GP /* TEST ADDING SYNC CORE */ + WRITE_PROC_FIRST_MB, /* can be reordered before/after flips */ + WRITE_PROC_FIRST_WAIT | WRITE_PROC_FIRST_WAIT_LOOP) -> + ooo_mem(i); + /* ONLY WAITING FOR READER 0 */ + tmp2 = READ_CACHED_VAR(urcu_active_readers[0]); +#ifndef SINGLE_FLIP + /* In normal execution, we are always starting by + * waiting for the even parity. + */ + cur_gp_val = RCU_GP_CTR_BIT; +#endif + if + :: (tmp2 & RCU_GP_CTR_NEST_MASK) + && ((tmp2 ^ cur_gp_val) & RCU_GP_CTR_BIT) -> + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_FIRST_WAIT_LOOP); + :: else -> + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_FIRST_WAIT); + fi; + + :: CONSUME_TOKENS(proc_urcu_writer, + //WRITE_PROC_FIRST_WRITE_GP /* TEST ADDING SYNC CORE */ + WRITE_PROC_FIRST_WRITE_GP + | WRITE_PROC_FIRST_READ_GP + | WRITE_PROC_FIRST_WAIT_LOOP + | WRITE_DATA | WRITE_PROC_WMB | WRITE_XCHG_PTR + | WRITE_PROC_FIRST_MB, /* can be reordered before/after flips */ + 0) -> +#ifndef GEN_ERROR_WRITER_PROGRESS + goto smp_mb_send2; +smp_mb_send2_end: +#else + ooo_mem(i); +#endif + /* This instruction loops to WRITE_PROC_FIRST_WAIT */ + CLEAR_TOKENS(proc_urcu_writer, WRITE_PROC_FIRST_WAIT_LOOP | WRITE_PROC_FIRST_WAIT); + + /* second flip */ + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_PROC_FIRST_WAIT /* Control dependency : need to branch out of + * the loop to execute the next flip (CHECK) */ + | WRITE_PROC_FIRST_WRITE_GP + | WRITE_PROC_FIRST_READ_GP + | WRITE_PROC_FIRST_MB, + WRITE_PROC_SECOND_READ_GP) -> + ooo_mem(i); + tmpa = READ_CACHED_VAR(urcu_gp_ctr); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_READ_GP); + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_PROC_FIRST_MB + | WRITE_PROC_WMB + | WRITE_PROC_FIRST_READ_GP + | WRITE_PROC_FIRST_WRITE_GP + | WRITE_PROC_SECOND_READ_GP, + WRITE_PROC_SECOND_WRITE_GP) -> + ooo_mem(i); + WRITE_CACHED_VAR(urcu_gp_ctr, tmpa ^ RCU_GP_CTR_BIT); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_WRITE_GP); + + :: CONSUME_TOKENS(proc_urcu_writer, + //WRITE_PROC_FIRST_WRITE_GP /* TEST ADDING SYNC CORE */ + WRITE_PROC_FIRST_WAIT + | WRITE_PROC_FIRST_MB, /* can be reordered before/after flips */ + WRITE_PROC_SECOND_WAIT | WRITE_PROC_SECOND_WAIT_LOOP) -> + ooo_mem(i); + /* ONLY WAITING FOR READER 0 */ + tmp2 = READ_CACHED_VAR(urcu_active_readers[0]); + if + :: (tmp2 & RCU_GP_CTR_NEST_MASK) + && ((tmp2 ^ 0) & RCU_GP_CTR_BIT) -> + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_WAIT_LOOP); + :: else -> + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_WAIT); + fi; + + :: CONSUME_TOKENS(proc_urcu_writer, + //WRITE_PROC_FIRST_WRITE_GP /* TEST ADDING SYNC CORE */ + WRITE_PROC_SECOND_WRITE_GP + | WRITE_PROC_FIRST_WRITE_GP + | WRITE_PROC_SECOND_READ_GP + | WRITE_PROC_FIRST_READ_GP + | WRITE_PROC_SECOND_WAIT_LOOP + | WRITE_DATA | WRITE_PROC_WMB | WRITE_XCHG_PTR + | WRITE_PROC_FIRST_MB, /* can be reordered before/after flips */ + 0) -> +#ifndef GEN_ERROR_WRITER_PROGRESS + goto smp_mb_send3; +smp_mb_send3_end: +#else + ooo_mem(i); +#endif + /* This instruction loops to WRITE_PROC_SECOND_WAIT */ + CLEAR_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_WAIT_LOOP | WRITE_PROC_SECOND_WAIT); + + + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_PROC_FIRST_WAIT + | WRITE_PROC_SECOND_WAIT + | WRITE_PROC_FIRST_READ_GP + | WRITE_PROC_SECOND_READ_GP + | WRITE_PROC_FIRST_WRITE_GP + | WRITE_PROC_SECOND_WRITE_GP + | WRITE_DATA | WRITE_PROC_WMB | WRITE_XCHG_PTR + | WRITE_PROC_FIRST_MB, + WRITE_PROC_SECOND_MB) -> + goto smp_mb_send4; +smp_mb_send4_end: + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_MB); + + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_XCHG_PTR + | WRITE_PROC_FIRST_WAIT + | WRITE_PROC_SECOND_WAIT + | WRITE_PROC_WMB /* No dependency on + * WRITE_DATA because we + * write to a + * different location. */ + | WRITE_PROC_SECOND_MB + | WRITE_PROC_FIRST_MB, + WRITE_FREE) -> + WRITE_CACHED_VAR(rcu_data[old_data], POISON); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_FREE); + + :: CONSUME_TOKENS(proc_urcu_writer, WRITE_PROC_ALL_TOKENS, 0) -> + CLEAR_TOKENS(proc_urcu_writer, WRITE_PROC_ALL_TOKENS_CLEAR); + break; + fi; + } + od; + /* + * Note : Promela model adds implicit serialization of the + * WRITE_FREE instruction. Normally, it would be permitted to + * spill on the next loop execution. Given the validation we do + * checks for the data entry read to be poisoned, it's ok if + * we do not check "late arriving" memory poisoning. + */ + :: else -> break; + od; + /* + * Given the reader loops infinitely, let the writer also busy-loop + * with progress here so, with weak fairness, we can test the + * writer's progress. + */ +end_writer: + do + :: 1 -> +#ifdef WRITER_PROGRESS +progress_writer2: +#endif +#ifdef READER_PROGRESS + /* + * Make sure we don't block the reader's progress. + */ + smp_mb_send(i, j, 5); +#endif + skip; + od; + + /* Non-atomic parts of the loop */ + goto end; +smp_mb_send1: + smp_mb_send(i, j, 1); + goto smp_mb_send1_end; +#ifndef GEN_ERROR_WRITER_PROGRESS +smp_mb_send2: + smp_mb_send(i, j, 2); + goto smp_mb_send2_end; +smp_mb_send3: + smp_mb_send(i, j, 3); + goto smp_mb_send3_end; +#endif +smp_mb_send4: + smp_mb_send(i, j, 4); + goto smp_mb_send4_end; +end: + skip; +} + +/* no name clash please */ +#undef proc_urcu_writer + + +/* Leave after the readers and writers so the pid count is ok. */ +init { + byte i, j; + + atomic { + INIT_CACHED_VAR(urcu_gp_ctr, 1, j); + INIT_CACHED_VAR(rcu_ptr, 0, j); + + i = 0; + do + :: i < NR_READERS -> + INIT_CACHED_VAR(urcu_active_readers[i], 0, j); + ptr_read_first[i] = 1; + ptr_read_second[i] = 1; + data_read_first[i] = WINE; + data_read_second[i] = WINE; + i++; + :: i >= NR_READERS -> break + od; + INIT_CACHED_VAR(rcu_data[0], WINE, j); + i = 1; + do + :: i < SLAB_SIZE -> + INIT_CACHED_VAR(rcu_data[i], POISON, j); + i++ + :: i >= SLAB_SIZE -> break + od; + + init_done = 1; + } +} diff --git a/formal-model/results/urcu-controldataflow-ipi-intel/references.txt b/formal-model/results/urcu-controldataflow-ipi-intel/references.txt new file mode 100644 index 0000000..72c67a2 --- /dev/null +++ b/formal-model/results/urcu-controldataflow-ipi-intel/references.txt @@ -0,0 +1,13 @@ +http://spinroot.com/spin/Man/ltl.html +http://en.wikipedia.org/wiki/Linear_temporal_logic +http://www.dcs.gla.ac.uk/~muffy/MRS4-2002/lect11.ppt + +http://www.lsv.ens-cachan.fr/~gastin/ltl2ba/index.php +http://spinroot.com/spin/Man/index.html +http://spinroot.com/spin/Man/promela.html + +LTL vs CTL : + +http://spinroot.com/spin/Doc/course/lecture12.pdf p. 9, p. 15, p. 18 +http://www-i2.informatik.rwth-aachen.de/i2/fileadmin/user_upload/documents/Introduction_to_Model_Checking/mc_lec18.pdf + (downloaded) diff --git a/formal-model/results/urcu-controldataflow-ipi-intel/urcu.sh b/formal-model/results/urcu-controldataflow-ipi-intel/urcu.sh new file mode 100644 index 0000000..65ff517 --- /dev/null +++ b/formal-model/results/urcu-controldataflow-ipi-intel/urcu.sh @@ -0,0 +1,29 @@ +#!/bin/sh +# +# Compiles and runs the urcu.spin Promela model. +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +# +# Copyright (C) IBM Corporation, 2009 +# Mathieu Desnoyers, 2009 +# +# Authors: Paul E. McKenney +# Mathieu Desnoyers + +# Basic execution, without LTL clauses. See Makefile. + +spin -a urcu.spin +cc -DSAFETY -o pan pan.c +./pan -v -c1 -X -m10000000 -w21 diff --git a/formal-model/results/urcu-controldataflow-ipi-intel/urcu.spin b/formal-model/results/urcu-controldataflow-ipi-intel/urcu.spin new file mode 100644 index 0000000..dd5d17d --- /dev/null +++ b/formal-model/results/urcu-controldataflow-ipi-intel/urcu.spin @@ -0,0 +1,1231 @@ +/* + * mem.spin: Promela code to validate memory barriers with OOO memory + * and out-of-order instruction scheduling. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * Copyright (c) 2009 Mathieu Desnoyers + */ + +/* Promela validation variables. */ + +/* specific defines "included" here */ +/* DEFINES file "included" here */ + +#define NR_READERS 1 +#define NR_WRITERS 1 + +#define NR_PROCS 2 + +#define get_pid() (_pid) + +#define get_readerid() (get_pid()) + +/* + * Produced process control and data flow. Updated after each instruction to + * show which variables are ready. Using one-hot bit encoding per variable to + * save state space. Used as triggers to execute the instructions having those + * variables as input. Leaving bits active to inhibit instruction execution. + * Scheme used to make instruction disabling and automatic dependency fall-back + * automatic. + */ + +#define CONSUME_TOKENS(state, bits, notbits) \ + ((!(state & (notbits))) && (state & (bits)) == (bits)) + +#define PRODUCE_TOKENS(state, bits) \ + state = state | (bits); + +#define CLEAR_TOKENS(state, bits) \ + state = state & ~(bits) + +/* + * Types of dependency : + * + * Data dependency + * + * - True dependency, Read-after-Write (RAW) + * + * This type of dependency happens when a statement depends on the result of a + * previous statement. This applies to any statement which needs to read a + * variable written by a preceding statement. + * + * - False dependency, Write-after-Read (WAR) + * + * Typically, variable renaming can ensure that this dependency goes away. + * However, if the statements must read and then write from/to the same variable + * in the OOO memory model, renaming may be impossible, and therefore this + * causes a WAR dependency. + * + * - Output dependency, Write-after-Write (WAW) + * + * Two writes to the same variable in subsequent statements. Variable renaming + * can ensure this is not needed, but can be required when writing multiple + * times to the same OOO mem model variable. + * + * Control dependency + * + * Execution of a given instruction depends on a previous instruction evaluating + * in a way that allows its execution. E.g. : branches. + * + * Useful considerations for joining dependencies after branch + * + * - Pre-dominance + * + * "We say box i dominates box j if every path (leading from input to output + * through the diagram) which passes through box j must also pass through box + * i. Thus box i dominates box j if box j is subordinate to box i in the + * program." + * + * http://www.hipersoft.rice.edu/grads/publications/dom14.pdf + * Other classic algorithm to calculate dominance : Lengauer-Tarjan (in gcc) + * + * - Post-dominance + * + * Just as pre-dominance, but with arcs of the data flow inverted, and input vs + * output exchanged. Therefore, i post-dominating j ensures that every path + * passing by j will pass by i before reaching the output. + * + * Other considerations + * + * Note about "volatile" keyword dependency : The compiler will order volatile + * accesses so they appear in the right order on a given CPU. They can be + * reordered by the CPU instruction scheduling. This therefore cannot be + * considered as a depencency. + * + * References : + * + * Cooper, Keith D.; & Torczon, Linda. (2005). Engineering a Compiler. Morgan + * Kaufmann. ISBN 1-55860-698-X. + * Kennedy, Ken; & Allen, Randy. (2001). Optimizing Compilers for Modern + * Architectures: A Dependence-based Approach. Morgan Kaufmann. ISBN + * 1-55860-286-0. + * Muchnick, Steven S. (1997). Advanced Compiler Design and Implementation. + * Morgan Kaufmann. ISBN 1-55860-320-4. + */ + +/* + * Note about loops and nested calls + * + * To keep this model simple, loops expressed in the framework will behave as if + * there was a core synchronizing instruction between loops. To see the effect + * of loop unrolling, manually unrolling loops is required. Note that if loops + * end or start with a core synchronizing instruction, the model is appropriate. + * Nested calls are not supported. + */ + +/* + * Only Alpha has out-of-order cache bank loads. Other architectures (intel, + * powerpc, arm) ensure that dependent reads won't be reordered. c.f. + * http://www.linuxjournal.com/article/8212) +#ifdef ARCH_ALPHA +#define HAVE_OOO_CACHE_READ +#endif + +/* + * Each process have its own data in cache. Caches are randomly updated. + * smp_wmb and smp_rmb forces cache updates (write and read), smp_mb forces + * both. + */ + +typedef per_proc_byte { + byte val[NR_PROCS]; +}; + +typedef per_proc_bit { + bit val[NR_PROCS]; +}; + +/* Bitfield has a maximum of 8 procs */ +typedef per_proc_bitfield { + byte bitfield; +}; + +#define DECLARE_CACHED_VAR(type, x) \ + type mem_##x; \ + per_proc_##type cached_##x; \ + per_proc_bitfield cache_dirty_##x; + +#define INIT_CACHED_VAR(x, v, j) \ + mem_##x = v; \ + cache_dirty_##x.bitfield = 0; \ + j = 0; \ + do \ + :: j < NR_PROCS -> \ + cached_##x.val[j] = v; \ + j++ \ + :: j >= NR_PROCS -> break \ + od; + +#define IS_CACHE_DIRTY(x, id) (cache_dirty_##x.bitfield & (1 << id)) + +#define READ_CACHED_VAR(x) (cached_##x.val[get_pid()]) + +#define WRITE_CACHED_VAR(x, v) \ + atomic { \ + cached_##x.val[get_pid()] = v; \ + cache_dirty_##x.bitfield = \ + cache_dirty_##x.bitfield | (1 << get_pid()); \ + } + +#define CACHE_WRITE_TO_MEM(x, id) \ + if \ + :: IS_CACHE_DIRTY(x, id) -> \ + mem_##x = cached_##x.val[id]; \ + cache_dirty_##x.bitfield = \ + cache_dirty_##x.bitfield & (~(1 << id)); \ + :: else -> \ + skip \ + fi; + +#define CACHE_READ_FROM_MEM(x, id) \ + if \ + :: !IS_CACHE_DIRTY(x, id) -> \ + cached_##x.val[id] = mem_##x;\ + :: else -> \ + skip \ + fi; + +/* + * May update other caches if cache is dirty, or not. + */ +#define RANDOM_CACHE_WRITE_TO_MEM(x, id)\ + if \ + :: 1 -> CACHE_WRITE_TO_MEM(x, id); \ + :: 1 -> skip \ + fi; + +#define RANDOM_CACHE_READ_FROM_MEM(x, id)\ + if \ + :: 1 -> CACHE_READ_FROM_MEM(x, id); \ + :: 1 -> skip \ + fi; + +/* Must consume all prior read tokens. All subsequent reads depend on it. */ +inline smp_rmb(i) +{ + atomic { + CACHE_READ_FROM_MEM(urcu_gp_ctr, get_pid()); + i = 0; + do + :: i < NR_READERS -> + CACHE_READ_FROM_MEM(urcu_active_readers[i], get_pid()); + i++ + :: i >= NR_READERS -> break + od; + CACHE_READ_FROM_MEM(rcu_ptr, get_pid()); + i = 0; + do + :: i < SLAB_SIZE -> + CACHE_READ_FROM_MEM(rcu_data[i], get_pid()); + i++ + :: i >= SLAB_SIZE -> break + od; + } +} + +/* Must consume all prior write tokens. All subsequent writes depend on it. */ +inline smp_wmb(i) +{ + atomic { + CACHE_WRITE_TO_MEM(urcu_gp_ctr, get_pid()); + i = 0; + do + :: i < NR_READERS -> + CACHE_WRITE_TO_MEM(urcu_active_readers[i], get_pid()); + i++ + :: i >= NR_READERS -> break + od; + CACHE_WRITE_TO_MEM(rcu_ptr, get_pid()); + i = 0; + do + :: i < SLAB_SIZE -> + CACHE_WRITE_TO_MEM(rcu_data[i], get_pid()); + i++ + :: i >= SLAB_SIZE -> break + od; + } +} + +/* Synchronization point. Must consume all prior read and write tokens. All + * subsequent reads and writes depend on it. */ +inline smp_mb(i) +{ + atomic { + smp_wmb(i); + smp_rmb(i); + } +} + +#ifdef REMOTE_BARRIERS + +bit reader_barrier[NR_READERS]; + +/* + * We cannot leave the barriers dependencies in place in REMOTE_BARRIERS mode + * because they would add unexisting core synchronization and would therefore + * create an incomplete model. + * Therefore, we model the read-side memory barriers by completely disabling the + * memory barriers and their dependencies from the read-side. One at a time + * (different verification runs), we make a different instruction listen for + * signals. + */ + +#define smp_mb_reader(i, j) + +/* + * Service 0, 1 or many barrier requests. + */ +inline smp_mb_recv(i, j) +{ + do + :: (reader_barrier[get_readerid()] == 1) -> + /* + * We choose to ignore cycles caused by writer busy-looping, + * waiting for the reader, sending barrier requests, and the + * reader always services them without continuing execution. + */ +progress_ignoring_mb1: + smp_mb(i); + reader_barrier[get_readerid()] = 0; + :: 1 -> + /* + * We choose to ignore writer's non-progress caused by the + * reader ignoring the writer's mb() requests. + */ +progress_ignoring_mb2: + break; + od; +} + +#define PROGRESS_LABEL(progressid) progress_writer_progid_##progressid: + +#define smp_mb_send(i, j, progressid) \ +{ \ + smp_mb(i); \ + i = 0; \ + do \ + :: i < NR_READERS -> \ + reader_barrier[i] = 1; \ + /* \ + * Busy-looping waiting for reader barrier handling is of little\ + * interest, given the reader has the ability to totally ignore \ + * barrier requests. \ + */ \ + do \ + :: (reader_barrier[i] == 1) -> \ +PROGRESS_LABEL(progressid) \ + skip; \ + :: (reader_barrier[i] == 0) -> break; \ + od; \ + i++; \ + :: i >= NR_READERS -> \ + break \ + od; \ + smp_mb(i); \ +} + +#else + +#define smp_mb_send(i, j, progressid) smp_mb(i) +#define smp_mb_reader smp_mb(i) +#define smp_mb_recv(i, j) + +#endif + +/* Keep in sync manually with smp_rmb, smp_wmb, ooo_mem and init() */ +DECLARE_CACHED_VAR(byte, urcu_gp_ctr); +/* Note ! currently only one reader */ +DECLARE_CACHED_VAR(byte, urcu_active_readers[NR_READERS]); +/* RCU data */ +DECLARE_CACHED_VAR(bit, rcu_data[SLAB_SIZE]); + +/* RCU pointer */ +#if (SLAB_SIZE == 2) +DECLARE_CACHED_VAR(bit, rcu_ptr); +bit ptr_read_first[NR_READERS]; +bit ptr_read_second[NR_READERS]; +#else +DECLARE_CACHED_VAR(byte, rcu_ptr); +byte ptr_read_first[NR_READERS]; +byte ptr_read_second[NR_READERS]; +#endif + +bit data_read_first[NR_READERS]; +bit data_read_second[NR_READERS]; + +bit init_done = 0; + +inline wait_init_done() +{ + do + :: init_done == 0 -> skip; + :: else -> break; + od; +} + +inline ooo_mem(i) +{ + atomic { + RANDOM_CACHE_WRITE_TO_MEM(urcu_gp_ctr, get_pid()); + i = 0; + do + :: i < NR_READERS -> + RANDOM_CACHE_WRITE_TO_MEM(urcu_active_readers[i], + get_pid()); + i++ + :: i >= NR_READERS -> break + od; + RANDOM_CACHE_WRITE_TO_MEM(rcu_ptr, get_pid()); + i = 0; + do + :: i < SLAB_SIZE -> + RANDOM_CACHE_WRITE_TO_MEM(rcu_data[i], get_pid()); + i++ + :: i >= SLAB_SIZE -> break + od; +#ifdef HAVE_OOO_CACHE_READ + RANDOM_CACHE_READ_FROM_MEM(urcu_gp_ctr, get_pid()); + i = 0; + do + :: i < NR_READERS -> + RANDOM_CACHE_READ_FROM_MEM(urcu_active_readers[i], + get_pid()); + i++ + :: i >= NR_READERS -> break + od; + RANDOM_CACHE_READ_FROM_MEM(rcu_ptr, get_pid()); + i = 0; + do + :: i < SLAB_SIZE -> + RANDOM_CACHE_READ_FROM_MEM(rcu_data[i], get_pid()); + i++ + :: i >= SLAB_SIZE -> break + od; +#else + smp_rmb(i); +#endif /* HAVE_OOO_CACHE_READ */ + } +} + +/* + * Bit encoding, urcu_reader : + */ + +int _proc_urcu_reader; +#define proc_urcu_reader _proc_urcu_reader + +/* Body of PROCEDURE_READ_LOCK */ +#define READ_PROD_A_READ (1 << 0) +#define READ_PROD_B_IF_TRUE (1 << 1) +#define READ_PROD_B_IF_FALSE (1 << 2) +#define READ_PROD_C_IF_TRUE_READ (1 << 3) + +#define PROCEDURE_READ_LOCK(base, consumetoken, producetoken) \ + :: CONSUME_TOKENS(proc_urcu_reader, consumetoken, READ_PROD_A_READ << base) -> \ + ooo_mem(i); \ + tmp = READ_CACHED_VAR(urcu_active_readers[get_readerid()]); \ + PRODUCE_TOKENS(proc_urcu_reader, READ_PROD_A_READ << base); \ + :: CONSUME_TOKENS(proc_urcu_reader, \ + READ_PROD_A_READ << base, /* RAW, pre-dominant */ \ + (READ_PROD_B_IF_TRUE | READ_PROD_B_IF_FALSE) << base) -> \ + if \ + :: (!(tmp & RCU_GP_CTR_NEST_MASK)) -> \ + PRODUCE_TOKENS(proc_urcu_reader, READ_PROD_B_IF_TRUE << base); \ + :: else -> \ + PRODUCE_TOKENS(proc_urcu_reader, READ_PROD_B_IF_FALSE << base); \ + fi; \ + /* IF TRUE */ \ + :: CONSUME_TOKENS(proc_urcu_reader, READ_PROD_B_IF_TRUE << base, \ + READ_PROD_C_IF_TRUE_READ << base) -> \ + ooo_mem(i); \ + tmp2 = READ_CACHED_VAR(urcu_gp_ctr); \ + PRODUCE_TOKENS(proc_urcu_reader, READ_PROD_C_IF_TRUE_READ << base); \ + :: CONSUME_TOKENS(proc_urcu_reader, \ + (READ_PROD_C_IF_TRUE_READ /* pre-dominant */ \ + | READ_PROD_A_READ) << base, /* WAR */ \ + producetoken) -> \ + ooo_mem(i); \ + WRITE_CACHED_VAR(urcu_active_readers[get_readerid()], tmp2); \ + PRODUCE_TOKENS(proc_urcu_reader, producetoken); \ + /* IF_MERGE implies \ + * post-dominance */ \ + /* ELSE */ \ + :: CONSUME_TOKENS(proc_urcu_reader, \ + (READ_PROD_B_IF_FALSE /* pre-dominant */ \ + | READ_PROD_A_READ) << base, /* WAR */ \ + producetoken) -> \ + ooo_mem(i); \ + WRITE_CACHED_VAR(urcu_active_readers[get_readerid()], \ + tmp + 1); \ + PRODUCE_TOKENS(proc_urcu_reader, producetoken); \ + /* IF_MERGE implies \ + * post-dominance */ \ + /* ENDIF */ \ + skip + +/* Body of PROCEDURE_READ_LOCK */ +#define READ_PROC_READ_UNLOCK (1 << 0) + +#define PROCEDURE_READ_UNLOCK(base, consumetoken, producetoken) \ + :: CONSUME_TOKENS(proc_urcu_reader, \ + consumetoken, \ + READ_PROC_READ_UNLOCK << base) -> \ + ooo_mem(i); \ + tmp2 = READ_CACHED_VAR(urcu_active_readers[get_readerid()]); \ + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_READ_UNLOCK << base); \ + :: CONSUME_TOKENS(proc_urcu_reader, \ + consumetoken \ + | (READ_PROC_READ_UNLOCK << base), /* WAR */ \ + producetoken) -> \ + ooo_mem(i); \ + WRITE_CACHED_VAR(urcu_active_readers[get_readerid()], tmp2 - 1); \ + PRODUCE_TOKENS(proc_urcu_reader, producetoken); \ + skip + + +#define READ_PROD_NONE (1 << 0) + +/* PROCEDURE_READ_LOCK base = << 1 : 1 to 5 */ +#define READ_LOCK_BASE 1 +#define READ_LOCK_OUT (1 << 5) + +#define READ_PROC_FIRST_MB (1 << 6) + +/* PROCEDURE_READ_LOCK (NESTED) base : << 7 : 7 to 11 */ +#define READ_LOCK_NESTED_BASE 7 +#define READ_LOCK_NESTED_OUT (1 << 11) + +#define READ_PROC_READ_GEN (1 << 12) +#define READ_PROC_ACCESS_GEN (1 << 13) + +/* PROCEDURE_READ_UNLOCK (NESTED) base = << 14 : 14 to 15 */ +#define READ_UNLOCK_NESTED_BASE 14 +#define READ_UNLOCK_NESTED_OUT (1 << 15) + +#define READ_PROC_SECOND_MB (1 << 16) + +/* PROCEDURE_READ_UNLOCK base = << 17 : 17 to 18 */ +#define READ_UNLOCK_BASE 17 +#define READ_UNLOCK_OUT (1 << 18) + +/* PROCEDURE_READ_LOCK_UNROLL base = << 19 : 19 to 23 */ +#define READ_LOCK_UNROLL_BASE 19 +#define READ_LOCK_OUT_UNROLL (1 << 23) + +#define READ_PROC_THIRD_MB (1 << 24) + +#define READ_PROC_READ_GEN_UNROLL (1 << 25) +#define READ_PROC_ACCESS_GEN_UNROLL (1 << 26) + +#define READ_PROC_FOURTH_MB (1 << 27) + +/* PROCEDURE_READ_UNLOCK_UNROLL base = << 28 : 28 to 29 */ +#define READ_UNLOCK_UNROLL_BASE 28 +#define READ_UNLOCK_OUT_UNROLL (1 << 29) + + +/* Should not include branches */ +#define READ_PROC_ALL_TOKENS (READ_PROD_NONE \ + | READ_LOCK_OUT \ + | READ_PROC_FIRST_MB \ + | READ_LOCK_NESTED_OUT \ + | READ_PROC_READ_GEN \ + | READ_PROC_ACCESS_GEN \ + | READ_UNLOCK_NESTED_OUT \ + | READ_PROC_SECOND_MB \ + | READ_UNLOCK_OUT \ + | READ_LOCK_OUT_UNROLL \ + | READ_PROC_THIRD_MB \ + | READ_PROC_READ_GEN_UNROLL \ + | READ_PROC_ACCESS_GEN_UNROLL \ + | READ_PROC_FOURTH_MB \ + | READ_UNLOCK_OUT_UNROLL) + +/* Must clear all tokens, including branches */ +#define READ_PROC_ALL_TOKENS_CLEAR ((1 << 30) - 1) + +inline urcu_one_read(i, j, nest_i, tmp, tmp2) +{ + PRODUCE_TOKENS(proc_urcu_reader, READ_PROD_NONE); + +#ifdef NO_MB + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_FIRST_MB); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_SECOND_MB); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_THIRD_MB); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_FOURTH_MB); +#endif + +#ifdef REMOTE_BARRIERS + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_FIRST_MB); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_SECOND_MB); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_THIRD_MB); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_FOURTH_MB); +#endif + + do + :: 1 -> + +#ifdef REMOTE_BARRIERS + /* + * Signal-based memory barrier will only execute when the + * execution order appears in program order. + */ + if + :: 1 -> + atomic { + if + :: CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE, + READ_LOCK_OUT | READ_LOCK_NESTED_OUT + | READ_PROC_READ_GEN | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT + | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT, + READ_LOCK_NESTED_OUT + | READ_PROC_READ_GEN | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT + | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT | READ_LOCK_NESTED_OUT, + READ_PROC_READ_GEN | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT + | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN, + READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT + | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN | READ_PROC_ACCESS_GEN, + READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT + | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN + | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT, + READ_UNLOCK_OUT + | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN + | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT, + READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN + | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT | READ_LOCK_OUT_UNROLL, + READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN + | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL, + READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN + | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL, + READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL, + 0) -> + goto non_atomic3; +non_atomic3_end: + skip; + fi; + } + fi; + + goto non_atomic3_skip; +non_atomic3: + smp_mb_recv(i, j); + goto non_atomic3_end; +non_atomic3_skip: + +#endif /* REMOTE_BARRIERS */ + + atomic { + if + PROCEDURE_READ_LOCK(READ_LOCK_BASE, READ_PROD_NONE, READ_LOCK_OUT); + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_LOCK_OUT, /* post-dominant */ + READ_PROC_FIRST_MB) -> + smp_mb_reader(i, j); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_FIRST_MB); + + PROCEDURE_READ_LOCK(READ_LOCK_NESTED_BASE, READ_PROC_FIRST_MB | READ_LOCK_OUT, + READ_LOCK_NESTED_OUT); + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_PROC_FIRST_MB, /* mb() orders reads */ + READ_PROC_READ_GEN) -> + ooo_mem(i); + ptr_read_first[get_readerid()] = READ_CACHED_VAR(rcu_ptr); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_READ_GEN); + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_PROC_FIRST_MB /* mb() orders reads */ + | READ_PROC_READ_GEN, + READ_PROC_ACCESS_GEN) -> + /* smp_read_barrier_depends */ + goto rmb1; +rmb1_end: + data_read_first[get_readerid()] = + READ_CACHED_VAR(rcu_data[ptr_read_first[get_readerid()]]); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_ACCESS_GEN); + + + /* Note : we remove the nested memory barrier from the read unlock + * model, given it is not usually needed. The implementation has the barrier + * because the performance impact added by a branch in the common case does not + * justify it. + */ + + PROCEDURE_READ_UNLOCK(READ_UNLOCK_NESTED_BASE, + READ_PROC_FIRST_MB + | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT, + READ_UNLOCK_NESTED_OUT); + + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_PROC_ACCESS_GEN /* mb() orders reads */ + | READ_PROC_READ_GEN /* mb() orders reads */ + | READ_PROC_FIRST_MB /* mb() ordered */ + | READ_LOCK_OUT /* post-dominant */ + | READ_LOCK_NESTED_OUT /* post-dominant */ + | READ_UNLOCK_NESTED_OUT, + READ_PROC_SECOND_MB) -> + smp_mb_reader(i, j); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_SECOND_MB); + + PROCEDURE_READ_UNLOCK(READ_UNLOCK_BASE, + READ_PROC_SECOND_MB /* mb() orders reads */ + | READ_PROC_FIRST_MB /* mb() orders reads */ + | READ_LOCK_NESTED_OUT /* RAW */ + | READ_LOCK_OUT /* RAW */ + | READ_UNLOCK_NESTED_OUT, /* RAW */ + READ_UNLOCK_OUT); + + /* Unrolling loop : second consecutive lock */ + /* reading urcu_active_readers, which have been written by + * READ_UNLOCK_OUT : RAW */ + PROCEDURE_READ_LOCK(READ_LOCK_UNROLL_BASE, + READ_UNLOCK_OUT /* RAW */ + | READ_PROC_SECOND_MB /* mb() orders reads */ + | READ_PROC_FIRST_MB /* mb() orders reads */ + | READ_LOCK_NESTED_OUT /* RAW */ + | READ_LOCK_OUT /* RAW */ + | READ_UNLOCK_NESTED_OUT, /* RAW */ + READ_LOCK_OUT_UNROLL); + + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_PROC_FIRST_MB /* mb() ordered */ + | READ_PROC_SECOND_MB /* mb() ordered */ + | READ_LOCK_OUT_UNROLL /* post-dominant */ + | READ_LOCK_NESTED_OUT + | READ_LOCK_OUT + | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT, + READ_PROC_THIRD_MB) -> + smp_mb_reader(i, j); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_THIRD_MB); + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_PROC_FIRST_MB /* mb() orders reads */ + | READ_PROC_SECOND_MB /* mb() orders reads */ + | READ_PROC_THIRD_MB, /* mb() orders reads */ + READ_PROC_READ_GEN_UNROLL) -> + ooo_mem(i); + ptr_read_second[get_readerid()] = READ_CACHED_VAR(rcu_ptr); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_READ_GEN_UNROLL); + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_PROC_READ_GEN_UNROLL + | READ_PROC_FIRST_MB /* mb() orders reads */ + | READ_PROC_SECOND_MB /* mb() orders reads */ + | READ_PROC_THIRD_MB, /* mb() orders reads */ + READ_PROC_ACCESS_GEN_UNROLL) -> + /* smp_read_barrier_depends */ + goto rmb2; +rmb2_end: + data_read_second[get_readerid()] = + READ_CACHED_VAR(rcu_data[ptr_read_second[get_readerid()]]); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_ACCESS_GEN_UNROLL); + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_PROC_READ_GEN_UNROLL /* mb() orders reads */ + | READ_PROC_ACCESS_GEN_UNROLL /* mb() orders reads */ + | READ_PROC_FIRST_MB /* mb() ordered */ + | READ_PROC_SECOND_MB /* mb() ordered */ + | READ_PROC_THIRD_MB /* mb() ordered */ + | READ_LOCK_OUT_UNROLL /* post-dominant */ + | READ_LOCK_NESTED_OUT + | READ_LOCK_OUT + | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT, + READ_PROC_FOURTH_MB) -> + smp_mb_reader(i, j); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_FOURTH_MB); + + PROCEDURE_READ_UNLOCK(READ_UNLOCK_UNROLL_BASE, + READ_PROC_FOURTH_MB /* mb() orders reads */ + | READ_PROC_THIRD_MB /* mb() orders reads */ + | READ_LOCK_OUT_UNROLL /* RAW */ + | READ_PROC_SECOND_MB /* mb() orders reads */ + | READ_PROC_FIRST_MB /* mb() orders reads */ + | READ_LOCK_NESTED_OUT /* RAW */ + | READ_LOCK_OUT /* RAW */ + | READ_UNLOCK_NESTED_OUT, /* RAW */ + READ_UNLOCK_OUT_UNROLL); + :: CONSUME_TOKENS(proc_urcu_reader, READ_PROC_ALL_TOKENS, 0) -> + CLEAR_TOKENS(proc_urcu_reader, READ_PROC_ALL_TOKENS_CLEAR); + break; + fi; + } + od; + /* + * Dependency between consecutive loops : + * RAW dependency on + * WRITE_CACHED_VAR(urcu_active_readers[get_readerid()], tmp2 - 1) + * tmp = READ_CACHED_VAR(urcu_active_readers[get_readerid()]); + * between loops. + * _WHEN THE MB()s are in place_, they add full ordering of the + * generation pointer read wrt active reader count read, which ensures + * execution will not spill across loop execution. + * However, in the event mb()s are removed (execution using signal + * handler to promote barrier()() -> smp_mb()), nothing prevents one loop + * to spill its execution on other loop's execution. + */ + goto end; +rmb1: +#ifndef NO_RMB + smp_rmb(i); +#else + ooo_mem(i); +#endif + goto rmb1_end; +rmb2: +#ifndef NO_RMB + smp_rmb(i); +#else + ooo_mem(i); +#endif + goto rmb2_end; +end: + skip; +} + + + +active proctype urcu_reader() +{ + byte i, j, nest_i; + byte tmp, tmp2; + + wait_init_done(); + + assert(get_pid() < NR_PROCS); + +end_reader: + do + :: 1 -> + /* + * We do not test reader's progress here, because we are mainly + * interested in writer's progress. The reader never blocks + * anyway. We have to test for reader/writer's progress + * separately, otherwise we could think the writer is doing + * progress when it's blocked by an always progressing reader. + */ +#ifdef READER_PROGRESS +progress_reader: +#endif + urcu_one_read(i, j, nest_i, tmp, tmp2); + od; +} + +/* no name clash please */ +#undef proc_urcu_reader + + +/* Model the RCU update process. */ + +/* + * Bit encoding, urcu_writer : + * Currently only supports one reader. + */ + +int _proc_urcu_writer; +#define proc_urcu_writer _proc_urcu_writer + +#define WRITE_PROD_NONE (1 << 0) + +#define WRITE_DATA (1 << 1) +#define WRITE_PROC_WMB (1 << 2) +#define WRITE_XCHG_PTR (1 << 3) + +#define WRITE_PROC_FIRST_MB (1 << 4) + +/* first flip */ +#define WRITE_PROC_FIRST_READ_GP (1 << 5) +#define WRITE_PROC_FIRST_WRITE_GP (1 << 6) +#define WRITE_PROC_FIRST_WAIT (1 << 7) +#define WRITE_PROC_FIRST_WAIT_LOOP (1 << 8) + +/* second flip */ +#define WRITE_PROC_SECOND_READ_GP (1 << 9) +#define WRITE_PROC_SECOND_WRITE_GP (1 << 10) +#define WRITE_PROC_SECOND_WAIT (1 << 11) +#define WRITE_PROC_SECOND_WAIT_LOOP (1 << 12) + +#define WRITE_PROC_SECOND_MB (1 << 13) + +#define WRITE_FREE (1 << 14) + +#define WRITE_PROC_ALL_TOKENS (WRITE_PROD_NONE \ + | WRITE_DATA \ + | WRITE_PROC_WMB \ + | WRITE_XCHG_PTR \ + | WRITE_PROC_FIRST_MB \ + | WRITE_PROC_FIRST_READ_GP \ + | WRITE_PROC_FIRST_WRITE_GP \ + | WRITE_PROC_FIRST_WAIT \ + | WRITE_PROC_SECOND_READ_GP \ + | WRITE_PROC_SECOND_WRITE_GP \ + | WRITE_PROC_SECOND_WAIT \ + | WRITE_PROC_SECOND_MB \ + | WRITE_FREE) + +#define WRITE_PROC_ALL_TOKENS_CLEAR ((1 << 15) - 1) + +/* + * Mutexes are implied around writer execution. A single writer at a time. + */ +active proctype urcu_writer() +{ + byte i, j; + byte tmp, tmp2, tmpa; + byte cur_data = 0, old_data, loop_nr = 0; + byte cur_gp_val = 0; /* + * Keep a local trace of the current parity so + * we don't add non-existing dependencies on the global + * GP update. Needed to test single flip case. + */ + + wait_init_done(); + + assert(get_pid() < NR_PROCS); + + do + :: (loop_nr < 3) -> +#ifdef WRITER_PROGRESS +progress_writer1: +#endif + loop_nr = loop_nr + 1; + + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROD_NONE); + +#ifdef NO_WMB + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_WMB); +#endif + +#ifdef NO_MB + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_FIRST_MB); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_MB); +#endif + +#ifdef SINGLE_FLIP + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_READ_GP); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_WRITE_GP); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_WAIT); + /* For single flip, we need to know the current parity */ + cur_gp_val = cur_gp_val ^ RCU_GP_CTR_BIT; +#endif + + do :: 1 -> + atomic { + if + + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_PROD_NONE, + WRITE_DATA) -> + ooo_mem(i); + cur_data = (cur_data + 1) % SLAB_SIZE; + WRITE_CACHED_VAR(rcu_data[cur_data], WINE); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_DATA); + + + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_DATA, + WRITE_PROC_WMB) -> + smp_wmb(i); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_WMB); + + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_PROC_WMB, + WRITE_XCHG_PTR) -> + /* rcu_xchg_pointer() */ + atomic { + old_data = READ_CACHED_VAR(rcu_ptr); + WRITE_CACHED_VAR(rcu_ptr, cur_data); + } + PRODUCE_TOKENS(proc_urcu_writer, WRITE_XCHG_PTR); + + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_DATA | WRITE_PROC_WMB | WRITE_XCHG_PTR, + WRITE_PROC_FIRST_MB) -> + goto smp_mb_send1; +smp_mb_send1_end: + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_FIRST_MB); + + /* first flip */ + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_PROC_FIRST_MB, + WRITE_PROC_FIRST_READ_GP) -> + tmpa = READ_CACHED_VAR(urcu_gp_ctr); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_FIRST_READ_GP); + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_PROC_FIRST_MB | WRITE_PROC_WMB + | WRITE_PROC_FIRST_READ_GP, + WRITE_PROC_FIRST_WRITE_GP) -> + ooo_mem(i); + WRITE_CACHED_VAR(urcu_gp_ctr, tmpa ^ RCU_GP_CTR_BIT); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_FIRST_WRITE_GP); + + :: CONSUME_TOKENS(proc_urcu_writer, + //WRITE_PROC_FIRST_WRITE_GP /* TEST ADDING SYNC CORE */ + WRITE_PROC_FIRST_MB, /* can be reordered before/after flips */ + WRITE_PROC_FIRST_WAIT | WRITE_PROC_FIRST_WAIT_LOOP) -> + ooo_mem(i); + /* ONLY WAITING FOR READER 0 */ + tmp2 = READ_CACHED_VAR(urcu_active_readers[0]); +#ifndef SINGLE_FLIP + /* In normal execution, we are always starting by + * waiting for the even parity. + */ + cur_gp_val = RCU_GP_CTR_BIT; +#endif + if + :: (tmp2 & RCU_GP_CTR_NEST_MASK) + && ((tmp2 ^ cur_gp_val) & RCU_GP_CTR_BIT) -> + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_FIRST_WAIT_LOOP); + :: else -> + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_FIRST_WAIT); + fi; + + :: CONSUME_TOKENS(proc_urcu_writer, + //WRITE_PROC_FIRST_WRITE_GP /* TEST ADDING SYNC CORE */ + WRITE_PROC_FIRST_WRITE_GP + | WRITE_PROC_FIRST_READ_GP + | WRITE_PROC_FIRST_WAIT_LOOP + | WRITE_DATA | WRITE_PROC_WMB | WRITE_XCHG_PTR + | WRITE_PROC_FIRST_MB, /* can be reordered before/after flips */ + 0) -> +#ifndef GEN_ERROR_WRITER_PROGRESS + goto smp_mb_send2; +smp_mb_send2_end: +#else + ooo_mem(i); +#endif + /* This instruction loops to WRITE_PROC_FIRST_WAIT */ + CLEAR_TOKENS(proc_urcu_writer, WRITE_PROC_FIRST_WAIT_LOOP | WRITE_PROC_FIRST_WAIT); + + /* second flip */ + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_PROC_FIRST_WAIT /* Control dependency : need to branch out of + * the loop to execute the next flip (CHECK) */ + | WRITE_PROC_FIRST_WRITE_GP + | WRITE_PROC_FIRST_READ_GP + | WRITE_PROC_FIRST_MB, + WRITE_PROC_SECOND_READ_GP) -> + ooo_mem(i); + tmpa = READ_CACHED_VAR(urcu_gp_ctr); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_READ_GP); + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_PROC_FIRST_MB + | WRITE_PROC_WMB + | WRITE_PROC_FIRST_READ_GP + | WRITE_PROC_FIRST_WRITE_GP + | WRITE_PROC_SECOND_READ_GP, + WRITE_PROC_SECOND_WRITE_GP) -> + ooo_mem(i); + WRITE_CACHED_VAR(urcu_gp_ctr, tmpa ^ RCU_GP_CTR_BIT); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_WRITE_GP); + + :: CONSUME_TOKENS(proc_urcu_writer, + //WRITE_PROC_FIRST_WRITE_GP /* TEST ADDING SYNC CORE */ + WRITE_PROC_FIRST_WAIT + | WRITE_PROC_FIRST_MB, /* can be reordered before/after flips */ + WRITE_PROC_SECOND_WAIT | WRITE_PROC_SECOND_WAIT_LOOP) -> + ooo_mem(i); + /* ONLY WAITING FOR READER 0 */ + tmp2 = READ_CACHED_VAR(urcu_active_readers[0]); + if + :: (tmp2 & RCU_GP_CTR_NEST_MASK) + && ((tmp2 ^ 0) & RCU_GP_CTR_BIT) -> + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_WAIT_LOOP); + :: else -> + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_WAIT); + fi; + + :: CONSUME_TOKENS(proc_urcu_writer, + //WRITE_PROC_FIRST_WRITE_GP /* TEST ADDING SYNC CORE */ + WRITE_PROC_SECOND_WRITE_GP + | WRITE_PROC_FIRST_WRITE_GP + | WRITE_PROC_SECOND_READ_GP + | WRITE_PROC_FIRST_READ_GP + | WRITE_PROC_SECOND_WAIT_LOOP + | WRITE_DATA | WRITE_PROC_WMB | WRITE_XCHG_PTR + | WRITE_PROC_FIRST_MB, /* can be reordered before/after flips */ + 0) -> +#ifndef GEN_ERROR_WRITER_PROGRESS + goto smp_mb_send3; +smp_mb_send3_end: +#else + ooo_mem(i); +#endif + /* This instruction loops to WRITE_PROC_SECOND_WAIT */ + CLEAR_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_WAIT_LOOP | WRITE_PROC_SECOND_WAIT); + + + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_PROC_FIRST_WAIT + | WRITE_PROC_SECOND_WAIT + | WRITE_PROC_FIRST_READ_GP + | WRITE_PROC_SECOND_READ_GP + | WRITE_PROC_FIRST_WRITE_GP + | WRITE_PROC_SECOND_WRITE_GP + | WRITE_DATA | WRITE_PROC_WMB | WRITE_XCHG_PTR + | WRITE_PROC_FIRST_MB, + WRITE_PROC_SECOND_MB) -> + goto smp_mb_send4; +smp_mb_send4_end: + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_MB); + + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_XCHG_PTR + | WRITE_PROC_FIRST_WAIT + | WRITE_PROC_SECOND_WAIT + | WRITE_PROC_WMB /* No dependency on + * WRITE_DATA because we + * write to a + * different location. */ + | WRITE_PROC_SECOND_MB + | WRITE_PROC_FIRST_MB, + WRITE_FREE) -> + WRITE_CACHED_VAR(rcu_data[old_data], POISON); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_FREE); + + :: CONSUME_TOKENS(proc_urcu_writer, WRITE_PROC_ALL_TOKENS, 0) -> + CLEAR_TOKENS(proc_urcu_writer, WRITE_PROC_ALL_TOKENS_CLEAR); + break; + fi; + } + od; + /* + * Note : Promela model adds implicit serialization of the + * WRITE_FREE instruction. Normally, it would be permitted to + * spill on the next loop execution. Given the validation we do + * checks for the data entry read to be poisoned, it's ok if + * we do not check "late arriving" memory poisoning. + */ + :: else -> break; + od; + /* + * Given the reader loops infinitely, let the writer also busy-loop + * with progress here so, with weak fairness, we can test the + * writer's progress. + */ +end_writer: + do + :: 1 -> +#ifdef WRITER_PROGRESS +progress_writer2: +#endif +#ifdef READER_PROGRESS + /* + * Make sure we don't block the reader's progress. + */ + smp_mb_send(i, j, 5); +#endif + skip; + od; + + /* Non-atomic parts of the loop */ + goto end; +smp_mb_send1: + smp_mb_send(i, j, 1); + goto smp_mb_send1_end; +#ifndef GEN_ERROR_WRITER_PROGRESS +smp_mb_send2: + smp_mb_send(i, j, 2); + goto smp_mb_send2_end; +smp_mb_send3: + smp_mb_send(i, j, 3); + goto smp_mb_send3_end; +#endif +smp_mb_send4: + smp_mb_send(i, j, 4); + goto smp_mb_send4_end; +end: + skip; +} + +/* no name clash please */ +#undef proc_urcu_writer + + +/* Leave after the readers and writers so the pid count is ok. */ +init { + byte i, j; + + atomic { + INIT_CACHED_VAR(urcu_gp_ctr, 1, j); + INIT_CACHED_VAR(rcu_ptr, 0, j); + + i = 0; + do + :: i < NR_READERS -> + INIT_CACHED_VAR(urcu_active_readers[i], 0, j); + ptr_read_first[i] = 1; + ptr_read_second[i] = 1; + data_read_first[i] = WINE; + data_read_second[i] = WINE; + i++; + :: i >= NR_READERS -> break + od; + INIT_CACHED_VAR(rcu_data[0], WINE, j); + i = 1; + do + :: i < SLAB_SIZE -> + INIT_CACHED_VAR(rcu_data[i], POISON, j); + i++ + :: i >= SLAB_SIZE -> break + od; + + init_done = 1; + } +} diff --git a/formal-model/results/urcu-controldataflow-ipi-intel/urcu_free.log b/formal-model/results/urcu-controldataflow-ipi-intel/urcu_free.log new file mode 100644 index 0000000..357c5a6 --- /dev/null +++ b/formal-model/results/urcu-controldataflow-ipi-intel/urcu_free.log @@ -0,0 +1,484 @@ +make[1]: Entering directory `/home/compudj/doc/userspace-rcu/formal-model/urcu-controldataflow' +rm -f pan* trail.out .input.spin* *.spin.trail .input.define +touch .input.define +cat .input.define >> pan.ltl +cat DEFINES >> pan.ltl +spin -f "!(`cat urcu_free.ltl | grep -v ^//`)" >> pan.ltl +cat .input.define > .input.spin +cat DEFINES >> .input.spin +cat urcu.spin >> .input.spin +rm -f .input.spin.trail +spin -a -X -N pan.ltl .input.spin +Exit-Status 0 +gcc -O2 -w -DHASH64 -o pan pan.c +./pan -a -v -c1 -X -m10000000 -w20 +warning: for p.o. reduction to be valid the never claim must be stutter-invariant +(never claims generated from LTL formulae are stutter-invariant) +depth 0: Claim reached state 5 (line 1271) +Depth= 6767 States= 1e+06 Transitions= 5.89e+06 Memory= 550.432 t= 14.3 R= 7e+04 +Depth= 6767 States= 2e+06 Transitions= 1.64e+07 Memory= 634.318 t= 43 R= 5e+04 +Depth= 6767 States= 3e+06 Transitions= 3.29e+07 Memory= 718.303 t= 90 R= 3e+04 +pan: resizing hashtable to -w22.. done +Depth= 6767 States= 4e+06 Transitions= 4.33e+07 Memory= 833.311 t= 119 R= 3e+04 +Depth= 6767 States= 5e+06 Transitions= 5.21e+07 Memory= 917.295 t= 142 R= 4e+04 +Depth= 6767 States= 6e+06 Transitions= 5.99e+07 Memory= 1001.279 t= 163 R= 4e+04 +Depth= 6767 States= 7e+06 Transitions= 7.13e+07 Memory= 1085.264 t= 195 R= 4e+04 +Depth= 6767 States= 8e+06 Transitions= 8.71e+07 Memory= 1169.151 t= 240 R= 3e+04 +Depth= 6767 States= 9e+06 Transitions= 9.81e+07 Memory= 1253.135 t= 270 R= 3e+04 +pan: resizing hashtable to -w24.. done +Depth= 6767 States= 1e+07 Transitions= 1.07e+08 Memory= 1461.115 t= 296 R= 3e+04 +Depth= 6767 States= 1.1e+07 Transitions= 1.15e+08 Memory= 1545.100 t= 315 R= 3e+04 +Depth= 6767 States= 1.2e+07 Transitions= 1.27e+08 Memory= 1629.084 t= 349 R= 3e+04 + +(Spin Version 5.1.7 -- 23 December 2008) + + Partial Order Reduction + +Full statespace search for: + never claim + + assertion violations + (if within scope of claim) + acceptance cycles + (fairness disabled) + invalid end states - (disabled by never claim) + +State-vector 88 byte, depth reached 6767, errors: 0 + 12141896 states, stored +1.1627209e+08 states, matched +1.2841399e+08 transitions (= stored+matched) +1.9407117e+09 atomic steps +hash conflicts: 98962276 (resolved) + +Stats on memory usage (in Megabytes): + 1343.212 equivalent memory usage for states (stored*(State-vector + overhead)) + 1055.903 actual memory usage for states (compression: 78.61%) + state-vector as stored = 63 byte + 28 byte overhead + 128.000 memory used for hash table (-w24) + 457.764 memory used for DFS stack (-m10000000) + 1640.998 total actual memory usage + +unreached in proctype urcu_reader + line 261, "pan.___", state 30, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 269, "pan.___", state 52, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 273, "pan.___", state 61, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 238, "pan.___", state 77, "(1)" + line 242, "pan.___", state 85, "(1)" + line 246, "pan.___", state 97, "(1)" + line 250, "pan.___", state 105, "(1)" + line 400, "pan.___", state 131, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 409, "pan.___", state 163, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 413, "pan.___", state 177, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 238, "pan.___", state 195, "(1)" + line 246, "pan.___", state 215, "(1)" + line 250, "pan.___", state 223, "(1)" + line 679, "pan.___", state 242, "_proc_urcu_reader = (_proc_urcu_reader|((1<<2)<<1))" + line 400, "pan.___", state 249, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 409, "pan.___", state 281, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 413, "pan.___", state 295, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 238, "pan.___", state 313, "(1)" + line 246, "pan.___", state 333, "(1)" + line 250, "pan.___", state 341, "(1)" + line 400, "pan.___", state 360, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 409, "pan.___", state 392, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 413, "pan.___", state 406, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 238, "pan.___", state 424, "(1)" + line 246, "pan.___", state 444, "(1)" + line 250, "pan.___", state 452, "(1)" + line 400, "pan.___", state 473, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 400, "pan.___", state 475, "(1)" + line 400, "pan.___", state 476, "((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid)))" + line 400, "pan.___", state 476, "else" + line 400, "pan.___", state 479, "(1)" + line 404, "pan.___", state 487, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 404, "pan.___", state 489, "(1)" + line 404, "pan.___", state 490, "((cache_dirty_urcu_active_readers.bitfield&(1<<_pid)))" + line 404, "pan.___", state 490, "else" + line 404, "pan.___", state 493, "(1)" + line 404, "pan.___", state 494, "(1)" + line 404, "pan.___", state 494, "(1)" + line 402, "pan.___", state 499, "((i<1))" + line 402, "pan.___", state 499, "((i>=1))" + line 409, "pan.___", state 505, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 409, "pan.___", state 507, "(1)" + line 409, "pan.___", state 508, "((cache_dirty_rcu_ptr.bitfield&(1<<_pid)))" + line 409, "pan.___", state 508, "else" + line 409, "pan.___", state 511, "(1)" + line 409, "pan.___", state 512, "(1)" + line 409, "pan.___", state 512, "(1)" + line 413, "pan.___", state 519, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 413, "pan.___", state 521, "(1)" + line 413, "pan.___", state 522, "((cache_dirty_rcu_data[i].bitfield&(1<<_pid)))" + line 413, "pan.___", state 522, "else" + line 413, "pan.___", state 525, "(1)" + line 413, "pan.___", state 526, "(1)" + line 413, "pan.___", state 526, "(1)" + line 411, "pan.___", state 531, "((i<2))" + line 411, "pan.___", state 531, "((i>=2))" + line 238, "pan.___", state 537, "(1)" + line 242, "pan.___", state 545, "(1)" + line 242, "pan.___", state 546, "(!((cache_dirty_urcu_active_readers.bitfield&(1<<_pid))))" + line 242, "pan.___", state 546, "else" + line 240, "pan.___", state 551, "((i<1))" + line 240, "pan.___", state 551, "((i>=1))" + line 246, "pan.___", state 557, "(1)" + line 246, "pan.___", state 558, "(!((cache_dirty_rcu_ptr.bitfield&(1<<_pid))))" + line 246, "pan.___", state 558, "else" + line 250, "pan.___", state 565, "(1)" + line 250, "pan.___", state 566, "(!((cache_dirty_rcu_data[i].bitfield&(1<<_pid))))" + line 250, "pan.___", state 566, "else" + line 248, "pan.___", state 571, "((i<2))" + line 248, "pan.___", state 571, "((i>=2))" + line 255, "pan.___", state 575, "(!((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid))))" + line 255, "pan.___", state 575, "else" + line 420, "pan.___", state 577, "(1)" + line 420, "pan.___", state 577, "(1)" + line 679, "pan.___", state 580, "cached_urcu_active_readers.val[_pid] = (tmp+1)" + line 679, "pan.___", state 581, "_proc_urcu_reader = (_proc_urcu_reader|(1<<5))" + line 679, "pan.___", state 582, "(1)" + line 400, "pan.___", state 589, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 409, "pan.___", state 621, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 413, "pan.___", state 635, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 238, "pan.___", state 653, "(1)" + line 246, "pan.___", state 673, "(1)" + line 250, "pan.___", state 681, "(1)" + line 400, "pan.___", state 707, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 400, "pan.___", state 709, "(1)" + line 400, "pan.___", state 710, "((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid)))" + line 400, "pan.___", state 710, "else" + line 400, "pan.___", state 713, "(1)" + line 404, "pan.___", state 721, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 404, "pan.___", state 723, "(1)" + line 404, "pan.___", state 724, "((cache_dirty_urcu_active_readers.bitfield&(1<<_pid)))" + line 404, "pan.___", state 724, "else" + line 404, "pan.___", state 727, "(1)" + line 404, "pan.___", state 728, "(1)" + line 404, "pan.___", state 728, "(1)" + line 402, "pan.___", state 733, "((i<1))" + line 402, "pan.___", state 733, "((i>=1))" + line 409, "pan.___", state 739, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 409, "pan.___", state 741, "(1)" + line 409, "pan.___", state 742, "((cache_dirty_rcu_ptr.bitfield&(1<<_pid)))" + line 409, "pan.___", state 742, "else" + line 409, "pan.___", state 745, "(1)" + line 409, "pan.___", state 746, "(1)" + line 409, "pan.___", state 746, "(1)" + line 413, "pan.___", state 753, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 413, "pan.___", state 755, "(1)" + line 413, "pan.___", state 756, "((cache_dirty_rcu_data[i].bitfield&(1<<_pid)))" + line 413, "pan.___", state 756, "else" + line 413, "pan.___", state 759, "(1)" + line 413, "pan.___", state 760, "(1)" + line 413, "pan.___", state 760, "(1)" + line 411, "pan.___", state 765, "((i<2))" + line 411, "pan.___", state 765, "((i>=2))" + line 238, "pan.___", state 771, "(1)" + line 242, "pan.___", state 779, "(1)" + line 242, "pan.___", state 780, "(!((cache_dirty_urcu_active_readers.bitfield&(1<<_pid))))" + line 242, "pan.___", state 780, "else" + line 240, "pan.___", state 785, "((i<1))" + line 240, "pan.___", state 785, "((i>=1))" + line 246, "pan.___", state 791, "(1)" + line 246, "pan.___", state 792, "(!((cache_dirty_rcu_ptr.bitfield&(1<<_pid))))" + line 246, "pan.___", state 792, "else" + line 250, "pan.___", state 799, "(1)" + line 250, "pan.___", state 800, "(!((cache_dirty_rcu_data[i].bitfield&(1<<_pid))))" + line 250, "pan.___", state 800, "else" + line 255, "pan.___", state 809, "(!((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid))))" + line 255, "pan.___", state 809, "else" + line 420, "pan.___", state 811, "(1)" + line 420, "pan.___", state 811, "(1)" + line 400, "pan.___", state 818, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 400, "pan.___", state 820, "(1)" + line 400, "pan.___", state 821, "((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid)))" + line 400, "pan.___", state 821, "else" + line 400, "pan.___", state 824, "(1)" + line 404, "pan.___", state 832, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 404, "pan.___", state 834, "(1)" + line 404, "pan.___", state 835, "((cache_dirty_urcu_active_readers.bitfield&(1<<_pid)))" + line 404, "pan.___", state 835, "else" + line 404, "pan.___", state 838, "(1)" + line 404, "pan.___", state 839, "(1)" + line 404, "pan.___", state 839, "(1)" + line 402, "pan.___", state 844, "((i<1))" + line 402, "pan.___", state 844, "((i>=1))" + line 409, "pan.___", state 850, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 409, "pan.___", state 852, "(1)" + line 409, "pan.___", state 853, "((cache_dirty_rcu_ptr.bitfield&(1<<_pid)))" + line 409, "pan.___", state 853, "else" + line 409, "pan.___", state 856, "(1)" + line 409, "pan.___", state 857, "(1)" + line 409, "pan.___", state 857, "(1)" + line 413, "pan.___", state 864, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 413, "pan.___", state 866, "(1)" + line 413, "pan.___", state 867, "((cache_dirty_rcu_data[i].bitfield&(1<<_pid)))" + line 413, "pan.___", state 867, "else" + line 413, "pan.___", state 870, "(1)" + line 413, "pan.___", state 871, "(1)" + line 413, "pan.___", state 871, "(1)" + line 411, "pan.___", state 876, "((i<2))" + line 411, "pan.___", state 876, "((i>=2))" + line 238, "pan.___", state 882, "(1)" + line 242, "pan.___", state 890, "(1)" + line 242, "pan.___", state 891, "(!((cache_dirty_urcu_active_readers.bitfield&(1<<_pid))))" + line 242, "pan.___", state 891, "else" + line 240, "pan.___", state 896, "((i<1))" + line 240, "pan.___", state 896, "((i>=1))" + line 246, "pan.___", state 902, "(1)" + line 246, "pan.___", state 903, "(!((cache_dirty_rcu_ptr.bitfield&(1<<_pid))))" + line 246, "pan.___", state 903, "else" + line 250, "pan.___", state 910, "(1)" + line 250, "pan.___", state 911, "(!((cache_dirty_rcu_data[i].bitfield&(1<<_pid))))" + line 250, "pan.___", state 911, "else" + line 248, "pan.___", state 916, "((i<2))" + line 248, "pan.___", state 916, "((i>=2))" + line 255, "pan.___", state 920, "(!((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid))))" + line 255, "pan.___", state 920, "else" + line 420, "pan.___", state 922, "(1)" + line 420, "pan.___", state 922, "(1)" + line 687, "pan.___", state 926, "_proc_urcu_reader = (_proc_urcu_reader|(1<<11))" + line 400, "pan.___", state 931, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 409, "pan.___", state 963, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 413, "pan.___", state 977, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 238, "pan.___", state 995, "(1)" + line 246, "pan.___", state 1015, "(1)" + line 250, "pan.___", state 1023, "(1)" + line 400, "pan.___", state 1045, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 409, "pan.___", state 1077, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 413, "pan.___", state 1091, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 238, "pan.___", state 1109, "(1)" + line 246, "pan.___", state 1129, "(1)" + line 250, "pan.___", state 1137, "(1)" + line 400, "pan.___", state 1160, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 409, "pan.___", state 1192, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 413, "pan.___", state 1206, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 238, "pan.___", state 1224, "(1)" + line 246, "pan.___", state 1244, "(1)" + line 250, "pan.___", state 1252, "(1)" + line 400, "pan.___", state 1271, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 409, "pan.___", state 1303, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 413, "pan.___", state 1317, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 238, "pan.___", state 1335, "(1)" + line 246, "pan.___", state 1355, "(1)" + line 250, "pan.___", state 1363, "(1)" + line 400, "pan.___", state 1387, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 409, "pan.___", state 1419, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 413, "pan.___", state 1433, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 238, "pan.___", state 1451, "(1)" + line 246, "pan.___", state 1471, "(1)" + line 250, "pan.___", state 1479, "(1)" + line 400, "pan.___", state 1498, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 409, "pan.___", state 1530, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 413, "pan.___", state 1544, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 238, "pan.___", state 1562, "(1)" + line 246, "pan.___", state 1582, "(1)" + line 250, "pan.___", state 1590, "(1)" + line 400, "pan.___", state 1612, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 409, "pan.___", state 1644, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 413, "pan.___", state 1658, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 238, "pan.___", state 1676, "(1)" + line 246, "pan.___", state 1696, "(1)" + line 250, "pan.___", state 1704, "(1)" + line 726, "pan.___", state 1723, "_proc_urcu_reader = (_proc_urcu_reader|((1<<2)<<19))" + line 400, "pan.___", state 1730, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 409, "pan.___", state 1762, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 413, "pan.___", state 1776, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 238, "pan.___", state 1794, "(1)" + line 246, "pan.___", state 1814, "(1)" + line 250, "pan.___", state 1822, "(1)" + line 400, "pan.___", state 1841, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 409, "pan.___", state 1873, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 413, "pan.___", state 1887, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 238, "pan.___", state 1905, "(1)" + line 246, "pan.___", state 1925, "(1)" + line 250, "pan.___", state 1933, "(1)" + line 400, "pan.___", state 1954, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 400, "pan.___", state 1956, "(1)" + line 400, "pan.___", state 1957, "((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid)))" + line 400, "pan.___", state 1957, "else" + line 400, "pan.___", state 1960, "(1)" + line 404, "pan.___", state 1968, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 404, "pan.___", state 1970, "(1)" + line 404, "pan.___", state 1971, "((cache_dirty_urcu_active_readers.bitfield&(1<<_pid)))" + line 404, "pan.___", state 1971, "else" + line 404, "pan.___", state 1974, "(1)" + line 404, "pan.___", state 1975, "(1)" + line 404, "pan.___", state 1975, "(1)" + line 402, "pan.___", state 1980, "((i<1))" + line 402, "pan.___", state 1980, "((i>=1))" + line 409, "pan.___", state 1986, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 409, "pan.___", state 1988, "(1)" + line 409, "pan.___", state 1989, "((cache_dirty_rcu_ptr.bitfield&(1<<_pid)))" + line 409, "pan.___", state 1989, "else" + line 409, "pan.___", state 1992, "(1)" + line 409, "pan.___", state 1993, "(1)" + line 409, "pan.___", state 1993, "(1)" + line 413, "pan.___", state 2000, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 413, "pan.___", state 2002, "(1)" + line 413, "pan.___", state 2003, "((cache_dirty_rcu_data[i].bitfield&(1<<_pid)))" + line 413, "pan.___", state 2003, "else" + line 413, "pan.___", state 2006, "(1)" + line 413, "pan.___", state 2007, "(1)" + line 413, "pan.___", state 2007, "(1)" + line 411, "pan.___", state 2012, "((i<2))" + line 411, "pan.___", state 2012, "((i>=2))" + line 238, "pan.___", state 2018, "(1)" + line 242, "pan.___", state 2026, "(1)" + line 242, "pan.___", state 2027, "(!((cache_dirty_urcu_active_readers.bitfield&(1<<_pid))))" + line 242, "pan.___", state 2027, "else" + line 240, "pan.___", state 2032, "((i<1))" + line 240, "pan.___", state 2032, "((i>=1))" + line 246, "pan.___", state 2038, "(1)" + line 246, "pan.___", state 2039, "(!((cache_dirty_rcu_ptr.bitfield&(1<<_pid))))" + line 246, "pan.___", state 2039, "else" + line 250, "pan.___", state 2046, "(1)" + line 250, "pan.___", state 2047, "(!((cache_dirty_rcu_data[i].bitfield&(1<<_pid))))" + line 250, "pan.___", state 2047, "else" + line 248, "pan.___", state 2052, "((i<2))" + line 248, "pan.___", state 2052, "((i>=2))" + line 255, "pan.___", state 2056, "(!((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid))))" + line 255, "pan.___", state 2056, "else" + line 420, "pan.___", state 2058, "(1)" + line 420, "pan.___", state 2058, "(1)" + line 726, "pan.___", state 2061, "cached_urcu_active_readers.val[_pid] = (tmp+1)" + line 726, "pan.___", state 2062, "_proc_urcu_reader = (_proc_urcu_reader|(1<<23))" + line 726, "pan.___", state 2063, "(1)" + line 400, "pan.___", state 2070, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 409, "pan.___", state 2102, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 413, "pan.___", state 2116, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 238, "pan.___", state 2134, "(1)" + line 246, "pan.___", state 2154, "(1)" + line 250, "pan.___", state 2162, "(1)" + line 400, "pan.___", state 2187, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 409, "pan.___", state 2219, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 413, "pan.___", state 2233, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 238, "pan.___", state 2251, "(1)" + line 246, "pan.___", state 2271, "(1)" + line 250, "pan.___", state 2279, "(1)" + line 400, "pan.___", state 2298, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 409, "pan.___", state 2330, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 413, "pan.___", state 2344, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 238, "pan.___", state 2362, "(1)" + line 246, "pan.___", state 2382, "(1)" + line 250, "pan.___", state 2390, "(1)" + line 238, "pan.___", state 2421, "(1)" + line 246, "pan.___", state 2441, "(1)" + line 250, "pan.___", state 2449, "(1)" + line 238, "pan.___", state 2464, "(1)" + line 246, "pan.___", state 2484, "(1)" + line 250, "pan.___", state 2492, "(1)" + line 886, "pan.___", state 2509, "-end-" + (246 of 2509 states) +unreached in proctype urcu_writer + line 400, "pan.___", state 18, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 404, "pan.___", state 32, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 409, "pan.___", state 50, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 238, "pan.___", state 82, "(1)" + line 242, "pan.___", state 90, "(1)" + line 246, "pan.___", state 102, "(1)" + line 261, "pan.___", state 131, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 265, "pan.___", state 140, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 269, "pan.___", state 153, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 400, "pan.___", state 193, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 404, "pan.___", state 207, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 409, "pan.___", state 225, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 413, "pan.___", state 239, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 238, "pan.___", state 257, "(1)" + line 242, "pan.___", state 265, "(1)" + line 246, "pan.___", state 277, "(1)" + line 250, "pan.___", state 285, "(1)" + line 404, "pan.___", state 320, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 409, "pan.___", state 338, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 413, "pan.___", state 352, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 242, "pan.___", state 378, "(1)" + line 246, "pan.___", state 390, "(1)" + line 250, "pan.___", state 398, "(1)" + line 404, "pan.___", state 440, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 409, "pan.___", state 458, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 413, "pan.___", state 472, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 242, "pan.___", state 498, "(1)" + line 246, "pan.___", state 510, "(1)" + line 250, "pan.___", state 518, "(1)" + line 404, "pan.___", state 551, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 409, "pan.___", state 569, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 413, "pan.___", state 583, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 242, "pan.___", state 609, "(1)" + line 246, "pan.___", state 621, "(1)" + line 250, "pan.___", state 629, "(1)" + line 404, "pan.___", state 664, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 409, "pan.___", state 682, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 413, "pan.___", state 696, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 242, "pan.___", state 722, "(1)" + line 246, "pan.___", state 734, "(1)" + line 250, "pan.___", state 742, "(1)" + line 261, "pan.___", state 795, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 265, "pan.___", state 804, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 269, "pan.___", state 819, "(1)" + line 273, "pan.___", state 826, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 238, "pan.___", state 842, "(1)" + line 242, "pan.___", state 850, "(1)" + line 246, "pan.___", state 862, "(1)" + line 250, "pan.___", state 870, "(1)" + line 261, "pan.___", state 901, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 265, "pan.___", state 910, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 269, "pan.___", state 923, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 273, "pan.___", state 932, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 238, "pan.___", state 948, "(1)" + line 242, "pan.___", state 956, "(1)" + line 246, "pan.___", state 968, "(1)" + line 250, "pan.___", state 976, "(1)" + line 265, "pan.___", state 1002, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 269, "pan.___", state 1015, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 273, "pan.___", state 1024, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 238, "pan.___", state 1040, "(1)" + line 242, "pan.___", state 1048, "(1)" + line 246, "pan.___", state 1060, "(1)" + line 250, "pan.___", state 1068, "(1)" + line 261, "pan.___", state 1099, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 265, "pan.___", state 1108, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 269, "pan.___", state 1121, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 273, "pan.___", state 1130, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 238, "pan.___", state 1146, "(1)" + line 242, "pan.___", state 1154, "(1)" + line 246, "pan.___", state 1166, "(1)" + line 250, "pan.___", state 1174, "(1)" + line 265, "pan.___", state 1200, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 269, "pan.___", state 1213, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 273, "pan.___", state 1222, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 238, "pan.___", state 1238, "(1)" + line 242, "pan.___", state 1246, "(1)" + line 246, "pan.___", state 1258, "(1)" + line 250, "pan.___", state 1266, "(1)" + line 261, "pan.___", state 1297, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 265, "pan.___", state 1306, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 269, "pan.___", state 1319, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 273, "pan.___", state 1328, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 238, "pan.___", state 1344, "(1)" + line 242, "pan.___", state 1352, "(1)" + line 246, "pan.___", state 1364, "(1)" + line 250, "pan.___", state 1372, "(1)" + line 265, "pan.___", state 1398, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 269, "pan.___", state 1411, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 273, "pan.___", state 1420, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 238, "pan.___", state 1436, "(1)" + line 242, "pan.___", state 1444, "(1)" + line 246, "pan.___", state 1456, "(1)" + line 250, "pan.___", state 1464, "(1)" + line 261, "pan.___", state 1495, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 265, "pan.___", state 1504, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 269, "pan.___", state 1517, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 273, "pan.___", state 1526, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 238, "pan.___", state 1542, "(1)" + line 242, "pan.___", state 1550, "(1)" + line 246, "pan.___", state 1562, "(1)" + line 250, "pan.___", state 1570, "(1)" + line 1213, "pan.___", state 1586, "-end-" + (103 of 1586 states) +unreached in proctype :init: + (0 of 78 states) +unreached in proctype :never: + line 1276, "pan.___", state 8, "-end-" + (1 of 8 states) + +pan: elapsed time 353 seconds +pan: rate 34395.332 states/second +pan: avg transition delay 2.749e-06 usec +cp .input.spin urcu_free.spin.input +cp .input.spin.trail urcu_free.spin.input.trail +make[1]: Leaving directory `/home/compudj/doc/userspace-rcu/formal-model/urcu-controldataflow' diff --git a/formal-model/results/urcu-controldataflow-ipi-intel/urcu_free.ltl b/formal-model/results/urcu-controldataflow-ipi-intel/urcu_free.ltl new file mode 100644 index 0000000..6be1be9 --- /dev/null +++ b/formal-model/results/urcu-controldataflow-ipi-intel/urcu_free.ltl @@ -0,0 +1 @@ +[] (!read_poison) diff --git a/formal-model/results/urcu-controldataflow-ipi-intel/urcu_free.spin.input b/formal-model/results/urcu-controldataflow-ipi-intel/urcu_free.spin.input new file mode 100644 index 0000000..8afab6a --- /dev/null +++ b/formal-model/results/urcu-controldataflow-ipi-intel/urcu_free.spin.input @@ -0,0 +1,1249 @@ + +// Poison value for freed memory +#define POISON 1 +// Memory with correct data +#define WINE 0 +#define SLAB_SIZE 2 + +#define read_poison (data_read_first[0] == POISON || data_read_second[0] == POISON) + +#define RCU_GP_CTR_BIT (1 << 7) +#define RCU_GP_CTR_NEST_MASK (RCU_GP_CTR_BIT - 1) + +//disabled +#define REMOTE_BARRIERS + +//#define ARCH_ALPHA +#define ARCH_INTEL +//#define ARCH_POWERPC +/* + * mem.spin: Promela code to validate memory barriers with OOO memory + * and out-of-order instruction scheduling. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * Copyright (c) 2009 Mathieu Desnoyers + */ + +/* Promela validation variables. */ + +/* specific defines "included" here */ +/* DEFINES file "included" here */ + +#define NR_READERS 1 +#define NR_WRITERS 1 + +#define NR_PROCS 2 + +#define get_pid() (_pid) + +#define get_readerid() (get_pid()) + +/* + * Produced process control and data flow. Updated after each instruction to + * show which variables are ready. Using one-hot bit encoding per variable to + * save state space. Used as triggers to execute the instructions having those + * variables as input. Leaving bits active to inhibit instruction execution. + * Scheme used to make instruction disabling and automatic dependency fall-back + * automatic. + */ + +#define CONSUME_TOKENS(state, bits, notbits) \ + ((!(state & (notbits))) && (state & (bits)) == (bits)) + +#define PRODUCE_TOKENS(state, bits) \ + state = state | (bits); + +#define CLEAR_TOKENS(state, bits) \ + state = state & ~(bits) + +/* + * Types of dependency : + * + * Data dependency + * + * - True dependency, Read-after-Write (RAW) + * + * This type of dependency happens when a statement depends on the result of a + * previous statement. This applies to any statement which needs to read a + * variable written by a preceding statement. + * + * - False dependency, Write-after-Read (WAR) + * + * Typically, variable renaming can ensure that this dependency goes away. + * However, if the statements must read and then write from/to the same variable + * in the OOO memory model, renaming may be impossible, and therefore this + * causes a WAR dependency. + * + * - Output dependency, Write-after-Write (WAW) + * + * Two writes to the same variable in subsequent statements. Variable renaming + * can ensure this is not needed, but can be required when writing multiple + * times to the same OOO mem model variable. + * + * Control dependency + * + * Execution of a given instruction depends on a previous instruction evaluating + * in a way that allows its execution. E.g. : branches. + * + * Useful considerations for joining dependencies after branch + * + * - Pre-dominance + * + * "We say box i dominates box j if every path (leading from input to output + * through the diagram) which passes through box j must also pass through box + * i. Thus box i dominates box j if box j is subordinate to box i in the + * program." + * + * http://www.hipersoft.rice.edu/grads/publications/dom14.pdf + * Other classic algorithm to calculate dominance : Lengauer-Tarjan (in gcc) + * + * - Post-dominance + * + * Just as pre-dominance, but with arcs of the data flow inverted, and input vs + * output exchanged. Therefore, i post-dominating j ensures that every path + * passing by j will pass by i before reaching the output. + * + * Other considerations + * + * Note about "volatile" keyword dependency : The compiler will order volatile + * accesses so they appear in the right order on a given CPU. They can be + * reordered by the CPU instruction scheduling. This therefore cannot be + * considered as a depencency. + * + * References : + * + * Cooper, Keith D.; & Torczon, Linda. (2005). Engineering a Compiler. Morgan + * Kaufmann. ISBN 1-55860-698-X. + * Kennedy, Ken; & Allen, Randy. (2001). Optimizing Compilers for Modern + * Architectures: A Dependence-based Approach. Morgan Kaufmann. ISBN + * 1-55860-286-0. + * Muchnick, Steven S. (1997). Advanced Compiler Design and Implementation. + * Morgan Kaufmann. ISBN 1-55860-320-4. + */ + +/* + * Note about loops and nested calls + * + * To keep this model simple, loops expressed in the framework will behave as if + * there was a core synchronizing instruction between loops. To see the effect + * of loop unrolling, manually unrolling loops is required. Note that if loops + * end or start with a core synchronizing instruction, the model is appropriate. + * Nested calls are not supported. + */ + +/* + * Only Alpha has out-of-order cache bank loads. Other architectures (intel, + * powerpc, arm) ensure that dependent reads won't be reordered. c.f. + * http://www.linuxjournal.com/article/8212) +#ifdef ARCH_ALPHA +#define HAVE_OOO_CACHE_READ +#endif + +/* + * Each process have its own data in cache. Caches are randomly updated. + * smp_wmb and smp_rmb forces cache updates (write and read), smp_mb forces + * both. + */ + +typedef per_proc_byte { + byte val[NR_PROCS]; +}; + +typedef per_proc_bit { + bit val[NR_PROCS]; +}; + +/* Bitfield has a maximum of 8 procs */ +typedef per_proc_bitfield { + byte bitfield; +}; + +#define DECLARE_CACHED_VAR(type, x) \ + type mem_##x; \ + per_proc_##type cached_##x; \ + per_proc_bitfield cache_dirty_##x; + +#define INIT_CACHED_VAR(x, v, j) \ + mem_##x = v; \ + cache_dirty_##x.bitfield = 0; \ + j = 0; \ + do \ + :: j < NR_PROCS -> \ + cached_##x.val[j] = v; \ + j++ \ + :: j >= NR_PROCS -> break \ + od; + +#define IS_CACHE_DIRTY(x, id) (cache_dirty_##x.bitfield & (1 << id)) + +#define READ_CACHED_VAR(x) (cached_##x.val[get_pid()]) + +#define WRITE_CACHED_VAR(x, v) \ + atomic { \ + cached_##x.val[get_pid()] = v; \ + cache_dirty_##x.bitfield = \ + cache_dirty_##x.bitfield | (1 << get_pid()); \ + } + +#define CACHE_WRITE_TO_MEM(x, id) \ + if \ + :: IS_CACHE_DIRTY(x, id) -> \ + mem_##x = cached_##x.val[id]; \ + cache_dirty_##x.bitfield = \ + cache_dirty_##x.bitfield & (~(1 << id)); \ + :: else -> \ + skip \ + fi; + +#define CACHE_READ_FROM_MEM(x, id) \ + if \ + :: !IS_CACHE_DIRTY(x, id) -> \ + cached_##x.val[id] = mem_##x;\ + :: else -> \ + skip \ + fi; + +/* + * May update other caches if cache is dirty, or not. + */ +#define RANDOM_CACHE_WRITE_TO_MEM(x, id)\ + if \ + :: 1 -> CACHE_WRITE_TO_MEM(x, id); \ + :: 1 -> skip \ + fi; + +#define RANDOM_CACHE_READ_FROM_MEM(x, id)\ + if \ + :: 1 -> CACHE_READ_FROM_MEM(x, id); \ + :: 1 -> skip \ + fi; + +/* Must consume all prior read tokens. All subsequent reads depend on it. */ +inline smp_rmb(i) +{ + atomic { + CACHE_READ_FROM_MEM(urcu_gp_ctr, get_pid()); + i = 0; + do + :: i < NR_READERS -> + CACHE_READ_FROM_MEM(urcu_active_readers[i], get_pid()); + i++ + :: i >= NR_READERS -> break + od; + CACHE_READ_FROM_MEM(rcu_ptr, get_pid()); + i = 0; + do + :: i < SLAB_SIZE -> + CACHE_READ_FROM_MEM(rcu_data[i], get_pid()); + i++ + :: i >= SLAB_SIZE -> break + od; + } +} + +/* Must consume all prior write tokens. All subsequent writes depend on it. */ +inline smp_wmb(i) +{ + atomic { + CACHE_WRITE_TO_MEM(urcu_gp_ctr, get_pid()); + i = 0; + do + :: i < NR_READERS -> + CACHE_WRITE_TO_MEM(urcu_active_readers[i], get_pid()); + i++ + :: i >= NR_READERS -> break + od; + CACHE_WRITE_TO_MEM(rcu_ptr, get_pid()); + i = 0; + do + :: i < SLAB_SIZE -> + CACHE_WRITE_TO_MEM(rcu_data[i], get_pid()); + i++ + :: i >= SLAB_SIZE -> break + od; + } +} + +/* Synchronization point. Must consume all prior read and write tokens. All + * subsequent reads and writes depend on it. */ +inline smp_mb(i) +{ + atomic { + smp_wmb(i); + smp_rmb(i); + } +} + +#ifdef REMOTE_BARRIERS + +bit reader_barrier[NR_READERS]; + +/* + * We cannot leave the barriers dependencies in place in REMOTE_BARRIERS mode + * because they would add unexisting core synchronization and would therefore + * create an incomplete model. + * Therefore, we model the read-side memory barriers by completely disabling the + * memory barriers and their dependencies from the read-side. One at a time + * (different verification runs), we make a different instruction listen for + * signals. + */ + +#define smp_mb_reader(i, j) + +/* + * Service 0, 1 or many barrier requests. + */ +inline smp_mb_recv(i, j) +{ + do + :: (reader_barrier[get_readerid()] == 1) -> + /* + * We choose to ignore cycles caused by writer busy-looping, + * waiting for the reader, sending barrier requests, and the + * reader always services them without continuing execution. + */ +progress_ignoring_mb1: + smp_mb(i); + reader_barrier[get_readerid()] = 0; + :: 1 -> + /* + * We choose to ignore writer's non-progress caused by the + * reader ignoring the writer's mb() requests. + */ +progress_ignoring_mb2: + break; + od; +} + +#define PROGRESS_LABEL(progressid) progress_writer_progid_##progressid: + +#define smp_mb_send(i, j, progressid) \ +{ \ + smp_mb(i); \ + i = 0; \ + do \ + :: i < NR_READERS -> \ + reader_barrier[i] = 1; \ + /* \ + * Busy-looping waiting for reader barrier handling is of little\ + * interest, given the reader has the ability to totally ignore \ + * barrier requests. \ + */ \ + do \ + :: (reader_barrier[i] == 1) -> \ +PROGRESS_LABEL(progressid) \ + skip; \ + :: (reader_barrier[i] == 0) -> break; \ + od; \ + i++; \ + :: i >= NR_READERS -> \ + break \ + od; \ + smp_mb(i); \ +} + +#else + +#define smp_mb_send(i, j, progressid) smp_mb(i) +#define smp_mb_reader smp_mb(i) +#define smp_mb_recv(i, j) + +#endif + +/* Keep in sync manually with smp_rmb, smp_wmb, ooo_mem and init() */ +DECLARE_CACHED_VAR(byte, urcu_gp_ctr); +/* Note ! currently only one reader */ +DECLARE_CACHED_VAR(byte, urcu_active_readers[NR_READERS]); +/* RCU data */ +DECLARE_CACHED_VAR(bit, rcu_data[SLAB_SIZE]); + +/* RCU pointer */ +#if (SLAB_SIZE == 2) +DECLARE_CACHED_VAR(bit, rcu_ptr); +bit ptr_read_first[NR_READERS]; +bit ptr_read_second[NR_READERS]; +#else +DECLARE_CACHED_VAR(byte, rcu_ptr); +byte ptr_read_first[NR_READERS]; +byte ptr_read_second[NR_READERS]; +#endif + +bit data_read_first[NR_READERS]; +bit data_read_second[NR_READERS]; + +bit init_done = 0; + +inline wait_init_done() +{ + do + :: init_done == 0 -> skip; + :: else -> break; + od; +} + +inline ooo_mem(i) +{ + atomic { + RANDOM_CACHE_WRITE_TO_MEM(urcu_gp_ctr, get_pid()); + i = 0; + do + :: i < NR_READERS -> + RANDOM_CACHE_WRITE_TO_MEM(urcu_active_readers[i], + get_pid()); + i++ + :: i >= NR_READERS -> break + od; + RANDOM_CACHE_WRITE_TO_MEM(rcu_ptr, get_pid()); + i = 0; + do + :: i < SLAB_SIZE -> + RANDOM_CACHE_WRITE_TO_MEM(rcu_data[i], get_pid()); + i++ + :: i >= SLAB_SIZE -> break + od; +#ifdef HAVE_OOO_CACHE_READ + RANDOM_CACHE_READ_FROM_MEM(urcu_gp_ctr, get_pid()); + i = 0; + do + :: i < NR_READERS -> + RANDOM_CACHE_READ_FROM_MEM(urcu_active_readers[i], + get_pid()); + i++ + :: i >= NR_READERS -> break + od; + RANDOM_CACHE_READ_FROM_MEM(rcu_ptr, get_pid()); + i = 0; + do + :: i < SLAB_SIZE -> + RANDOM_CACHE_READ_FROM_MEM(rcu_data[i], get_pid()); + i++ + :: i >= SLAB_SIZE -> break + od; +#else + smp_rmb(i); +#endif /* HAVE_OOO_CACHE_READ */ + } +} + +/* + * Bit encoding, urcu_reader : + */ + +int _proc_urcu_reader; +#define proc_urcu_reader _proc_urcu_reader + +/* Body of PROCEDURE_READ_LOCK */ +#define READ_PROD_A_READ (1 << 0) +#define READ_PROD_B_IF_TRUE (1 << 1) +#define READ_PROD_B_IF_FALSE (1 << 2) +#define READ_PROD_C_IF_TRUE_READ (1 << 3) + +#define PROCEDURE_READ_LOCK(base, consumetoken, producetoken) \ + :: CONSUME_TOKENS(proc_urcu_reader, consumetoken, READ_PROD_A_READ << base) -> \ + ooo_mem(i); \ + tmp = READ_CACHED_VAR(urcu_active_readers[get_readerid()]); \ + PRODUCE_TOKENS(proc_urcu_reader, READ_PROD_A_READ << base); \ + :: CONSUME_TOKENS(proc_urcu_reader, \ + READ_PROD_A_READ << base, /* RAW, pre-dominant */ \ + (READ_PROD_B_IF_TRUE | READ_PROD_B_IF_FALSE) << base) -> \ + if \ + :: (!(tmp & RCU_GP_CTR_NEST_MASK)) -> \ + PRODUCE_TOKENS(proc_urcu_reader, READ_PROD_B_IF_TRUE << base); \ + :: else -> \ + PRODUCE_TOKENS(proc_urcu_reader, READ_PROD_B_IF_FALSE << base); \ + fi; \ + /* IF TRUE */ \ + :: CONSUME_TOKENS(proc_urcu_reader, READ_PROD_B_IF_TRUE << base, \ + READ_PROD_C_IF_TRUE_READ << base) -> \ + ooo_mem(i); \ + tmp2 = READ_CACHED_VAR(urcu_gp_ctr); \ + PRODUCE_TOKENS(proc_urcu_reader, READ_PROD_C_IF_TRUE_READ << base); \ + :: CONSUME_TOKENS(proc_urcu_reader, \ + (READ_PROD_C_IF_TRUE_READ /* pre-dominant */ \ + | READ_PROD_A_READ) << base, /* WAR */ \ + producetoken) -> \ + ooo_mem(i); \ + WRITE_CACHED_VAR(urcu_active_readers[get_readerid()], tmp2); \ + PRODUCE_TOKENS(proc_urcu_reader, producetoken); \ + /* IF_MERGE implies \ + * post-dominance */ \ + /* ELSE */ \ + :: CONSUME_TOKENS(proc_urcu_reader, \ + (READ_PROD_B_IF_FALSE /* pre-dominant */ \ + | READ_PROD_A_READ) << base, /* WAR */ \ + producetoken) -> \ + ooo_mem(i); \ + WRITE_CACHED_VAR(urcu_active_readers[get_readerid()], \ + tmp + 1); \ + PRODUCE_TOKENS(proc_urcu_reader, producetoken); \ + /* IF_MERGE implies \ + * post-dominance */ \ + /* ENDIF */ \ + skip + +/* Body of PROCEDURE_READ_LOCK */ +#define READ_PROC_READ_UNLOCK (1 << 0) + +#define PROCEDURE_READ_UNLOCK(base, consumetoken, producetoken) \ + :: CONSUME_TOKENS(proc_urcu_reader, \ + consumetoken, \ + READ_PROC_READ_UNLOCK << base) -> \ + ooo_mem(i); \ + tmp2 = READ_CACHED_VAR(urcu_active_readers[get_readerid()]); \ + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_READ_UNLOCK << base); \ + :: CONSUME_TOKENS(proc_urcu_reader, \ + consumetoken \ + | (READ_PROC_READ_UNLOCK << base), /* WAR */ \ + producetoken) -> \ + ooo_mem(i); \ + WRITE_CACHED_VAR(urcu_active_readers[get_readerid()], tmp2 - 1); \ + PRODUCE_TOKENS(proc_urcu_reader, producetoken); \ + skip + + +#define READ_PROD_NONE (1 << 0) + +/* PROCEDURE_READ_LOCK base = << 1 : 1 to 5 */ +#define READ_LOCK_BASE 1 +#define READ_LOCK_OUT (1 << 5) + +#define READ_PROC_FIRST_MB (1 << 6) + +/* PROCEDURE_READ_LOCK (NESTED) base : << 7 : 7 to 11 */ +#define READ_LOCK_NESTED_BASE 7 +#define READ_LOCK_NESTED_OUT (1 << 11) + +#define READ_PROC_READ_GEN (1 << 12) +#define READ_PROC_ACCESS_GEN (1 << 13) + +/* PROCEDURE_READ_UNLOCK (NESTED) base = << 14 : 14 to 15 */ +#define READ_UNLOCK_NESTED_BASE 14 +#define READ_UNLOCK_NESTED_OUT (1 << 15) + +#define READ_PROC_SECOND_MB (1 << 16) + +/* PROCEDURE_READ_UNLOCK base = << 17 : 17 to 18 */ +#define READ_UNLOCK_BASE 17 +#define READ_UNLOCK_OUT (1 << 18) + +/* PROCEDURE_READ_LOCK_UNROLL base = << 19 : 19 to 23 */ +#define READ_LOCK_UNROLL_BASE 19 +#define READ_LOCK_OUT_UNROLL (1 << 23) + +#define READ_PROC_THIRD_MB (1 << 24) + +#define READ_PROC_READ_GEN_UNROLL (1 << 25) +#define READ_PROC_ACCESS_GEN_UNROLL (1 << 26) + +#define READ_PROC_FOURTH_MB (1 << 27) + +/* PROCEDURE_READ_UNLOCK_UNROLL base = << 28 : 28 to 29 */ +#define READ_UNLOCK_UNROLL_BASE 28 +#define READ_UNLOCK_OUT_UNROLL (1 << 29) + + +/* Should not include branches */ +#define READ_PROC_ALL_TOKENS (READ_PROD_NONE \ + | READ_LOCK_OUT \ + | READ_PROC_FIRST_MB \ + | READ_LOCK_NESTED_OUT \ + | READ_PROC_READ_GEN \ + | READ_PROC_ACCESS_GEN \ + | READ_UNLOCK_NESTED_OUT \ + | READ_PROC_SECOND_MB \ + | READ_UNLOCK_OUT \ + | READ_LOCK_OUT_UNROLL \ + | READ_PROC_THIRD_MB \ + | READ_PROC_READ_GEN_UNROLL \ + | READ_PROC_ACCESS_GEN_UNROLL \ + | READ_PROC_FOURTH_MB \ + | READ_UNLOCK_OUT_UNROLL) + +/* Must clear all tokens, including branches */ +#define READ_PROC_ALL_TOKENS_CLEAR ((1 << 30) - 1) + +inline urcu_one_read(i, j, nest_i, tmp, tmp2) +{ + PRODUCE_TOKENS(proc_urcu_reader, READ_PROD_NONE); + +#ifdef NO_MB + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_FIRST_MB); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_SECOND_MB); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_THIRD_MB); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_FOURTH_MB); +#endif + +#ifdef REMOTE_BARRIERS + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_FIRST_MB); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_SECOND_MB); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_THIRD_MB); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_FOURTH_MB); +#endif + + do + :: 1 -> + +#ifdef REMOTE_BARRIERS + /* + * Signal-based memory barrier will only execute when the + * execution order appears in program order. + */ + if + :: 1 -> + atomic { + if + :: CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE, + READ_LOCK_OUT | READ_LOCK_NESTED_OUT + | READ_PROC_READ_GEN | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT + | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT, + READ_LOCK_NESTED_OUT + | READ_PROC_READ_GEN | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT + | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT | READ_LOCK_NESTED_OUT, + READ_PROC_READ_GEN | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT + | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN, + READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT + | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN | READ_PROC_ACCESS_GEN, + READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT + | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN + | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT, + READ_UNLOCK_OUT + | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN + | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT, + READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN + | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT | READ_LOCK_OUT_UNROLL, + READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN + | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL, + READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN + | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL, + READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL, + 0) -> + goto non_atomic3; +non_atomic3_end: + skip; + fi; + } + fi; + + goto non_atomic3_skip; +non_atomic3: + smp_mb_recv(i, j); + goto non_atomic3_end; +non_atomic3_skip: + +#endif /* REMOTE_BARRIERS */ + + atomic { + if + PROCEDURE_READ_LOCK(READ_LOCK_BASE, READ_PROD_NONE, READ_LOCK_OUT); + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_LOCK_OUT, /* post-dominant */ + READ_PROC_FIRST_MB) -> + smp_mb_reader(i, j); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_FIRST_MB); + + PROCEDURE_READ_LOCK(READ_LOCK_NESTED_BASE, READ_PROC_FIRST_MB | READ_LOCK_OUT, + READ_LOCK_NESTED_OUT); + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_PROC_FIRST_MB, /* mb() orders reads */ + READ_PROC_READ_GEN) -> + ooo_mem(i); + ptr_read_first[get_readerid()] = READ_CACHED_VAR(rcu_ptr); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_READ_GEN); + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_PROC_FIRST_MB /* mb() orders reads */ + | READ_PROC_READ_GEN, + READ_PROC_ACCESS_GEN) -> + /* smp_read_barrier_depends */ + goto rmb1; +rmb1_end: + data_read_first[get_readerid()] = + READ_CACHED_VAR(rcu_data[ptr_read_first[get_readerid()]]); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_ACCESS_GEN); + + + /* Note : we remove the nested memory barrier from the read unlock + * model, given it is not usually needed. The implementation has the barrier + * because the performance impact added by a branch in the common case does not + * justify it. + */ + + PROCEDURE_READ_UNLOCK(READ_UNLOCK_NESTED_BASE, + READ_PROC_FIRST_MB + | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT, + READ_UNLOCK_NESTED_OUT); + + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_PROC_ACCESS_GEN /* mb() orders reads */ + | READ_PROC_READ_GEN /* mb() orders reads */ + | READ_PROC_FIRST_MB /* mb() ordered */ + | READ_LOCK_OUT /* post-dominant */ + | READ_LOCK_NESTED_OUT /* post-dominant */ + | READ_UNLOCK_NESTED_OUT, + READ_PROC_SECOND_MB) -> + smp_mb_reader(i, j); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_SECOND_MB); + + PROCEDURE_READ_UNLOCK(READ_UNLOCK_BASE, + READ_PROC_SECOND_MB /* mb() orders reads */ + | READ_PROC_FIRST_MB /* mb() orders reads */ + | READ_LOCK_NESTED_OUT /* RAW */ + | READ_LOCK_OUT /* RAW */ + | READ_UNLOCK_NESTED_OUT, /* RAW */ + READ_UNLOCK_OUT); + + /* Unrolling loop : second consecutive lock */ + /* reading urcu_active_readers, which have been written by + * READ_UNLOCK_OUT : RAW */ + PROCEDURE_READ_LOCK(READ_LOCK_UNROLL_BASE, + READ_UNLOCK_OUT /* RAW */ + | READ_PROC_SECOND_MB /* mb() orders reads */ + | READ_PROC_FIRST_MB /* mb() orders reads */ + | READ_LOCK_NESTED_OUT /* RAW */ + | READ_LOCK_OUT /* RAW */ + | READ_UNLOCK_NESTED_OUT, /* RAW */ + READ_LOCK_OUT_UNROLL); + + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_PROC_FIRST_MB /* mb() ordered */ + | READ_PROC_SECOND_MB /* mb() ordered */ + | READ_LOCK_OUT_UNROLL /* post-dominant */ + | READ_LOCK_NESTED_OUT + | READ_LOCK_OUT + | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT, + READ_PROC_THIRD_MB) -> + smp_mb_reader(i, j); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_THIRD_MB); + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_PROC_FIRST_MB /* mb() orders reads */ + | READ_PROC_SECOND_MB /* mb() orders reads */ + | READ_PROC_THIRD_MB, /* mb() orders reads */ + READ_PROC_READ_GEN_UNROLL) -> + ooo_mem(i); + ptr_read_second[get_readerid()] = READ_CACHED_VAR(rcu_ptr); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_READ_GEN_UNROLL); + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_PROC_READ_GEN_UNROLL + | READ_PROC_FIRST_MB /* mb() orders reads */ + | READ_PROC_SECOND_MB /* mb() orders reads */ + | READ_PROC_THIRD_MB, /* mb() orders reads */ + READ_PROC_ACCESS_GEN_UNROLL) -> + /* smp_read_barrier_depends */ + goto rmb2; +rmb2_end: + data_read_second[get_readerid()] = + READ_CACHED_VAR(rcu_data[ptr_read_second[get_readerid()]]); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_ACCESS_GEN_UNROLL); + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_PROC_READ_GEN_UNROLL /* mb() orders reads */ + | READ_PROC_ACCESS_GEN_UNROLL /* mb() orders reads */ + | READ_PROC_FIRST_MB /* mb() ordered */ + | READ_PROC_SECOND_MB /* mb() ordered */ + | READ_PROC_THIRD_MB /* mb() ordered */ + | READ_LOCK_OUT_UNROLL /* post-dominant */ + | READ_LOCK_NESTED_OUT + | READ_LOCK_OUT + | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT, + READ_PROC_FOURTH_MB) -> + smp_mb_reader(i, j); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_FOURTH_MB); + + PROCEDURE_READ_UNLOCK(READ_UNLOCK_UNROLL_BASE, + READ_PROC_FOURTH_MB /* mb() orders reads */ + | READ_PROC_THIRD_MB /* mb() orders reads */ + | READ_LOCK_OUT_UNROLL /* RAW */ + | READ_PROC_SECOND_MB /* mb() orders reads */ + | READ_PROC_FIRST_MB /* mb() orders reads */ + | READ_LOCK_NESTED_OUT /* RAW */ + | READ_LOCK_OUT /* RAW */ + | READ_UNLOCK_NESTED_OUT, /* RAW */ + READ_UNLOCK_OUT_UNROLL); + :: CONSUME_TOKENS(proc_urcu_reader, READ_PROC_ALL_TOKENS, 0) -> + CLEAR_TOKENS(proc_urcu_reader, READ_PROC_ALL_TOKENS_CLEAR); + break; + fi; + } + od; + /* + * Dependency between consecutive loops : + * RAW dependency on + * WRITE_CACHED_VAR(urcu_active_readers[get_readerid()], tmp2 - 1) + * tmp = READ_CACHED_VAR(urcu_active_readers[get_readerid()]); + * between loops. + * _WHEN THE MB()s are in place_, they add full ordering of the + * generation pointer read wrt active reader count read, which ensures + * execution will not spill across loop execution. + * However, in the event mb()s are removed (execution using signal + * handler to promote barrier()() -> smp_mb()), nothing prevents one loop + * to spill its execution on other loop's execution. + */ + goto end; +rmb1: +#ifndef NO_RMB + smp_rmb(i); +#else + ooo_mem(i); +#endif + goto rmb1_end; +rmb2: +#ifndef NO_RMB + smp_rmb(i); +#else + ooo_mem(i); +#endif + goto rmb2_end; +end: + skip; +} + + + +active proctype urcu_reader() +{ + byte i, j, nest_i; + byte tmp, tmp2; + + wait_init_done(); + + assert(get_pid() < NR_PROCS); + +end_reader: + do + :: 1 -> + /* + * We do not test reader's progress here, because we are mainly + * interested in writer's progress. The reader never blocks + * anyway. We have to test for reader/writer's progress + * separately, otherwise we could think the writer is doing + * progress when it's blocked by an always progressing reader. + */ +#ifdef READER_PROGRESS +progress_reader: +#endif + urcu_one_read(i, j, nest_i, tmp, tmp2); + od; +} + +/* no name clash please */ +#undef proc_urcu_reader + + +/* Model the RCU update process. */ + +/* + * Bit encoding, urcu_writer : + * Currently only supports one reader. + */ + +int _proc_urcu_writer; +#define proc_urcu_writer _proc_urcu_writer + +#define WRITE_PROD_NONE (1 << 0) + +#define WRITE_DATA (1 << 1) +#define WRITE_PROC_WMB (1 << 2) +#define WRITE_XCHG_PTR (1 << 3) + +#define WRITE_PROC_FIRST_MB (1 << 4) + +/* first flip */ +#define WRITE_PROC_FIRST_READ_GP (1 << 5) +#define WRITE_PROC_FIRST_WRITE_GP (1 << 6) +#define WRITE_PROC_FIRST_WAIT (1 << 7) +#define WRITE_PROC_FIRST_WAIT_LOOP (1 << 8) + +/* second flip */ +#define WRITE_PROC_SECOND_READ_GP (1 << 9) +#define WRITE_PROC_SECOND_WRITE_GP (1 << 10) +#define WRITE_PROC_SECOND_WAIT (1 << 11) +#define WRITE_PROC_SECOND_WAIT_LOOP (1 << 12) + +#define WRITE_PROC_SECOND_MB (1 << 13) + +#define WRITE_FREE (1 << 14) + +#define WRITE_PROC_ALL_TOKENS (WRITE_PROD_NONE \ + | WRITE_DATA \ + | WRITE_PROC_WMB \ + | WRITE_XCHG_PTR \ + | WRITE_PROC_FIRST_MB \ + | WRITE_PROC_FIRST_READ_GP \ + | WRITE_PROC_FIRST_WRITE_GP \ + | WRITE_PROC_FIRST_WAIT \ + | WRITE_PROC_SECOND_READ_GP \ + | WRITE_PROC_SECOND_WRITE_GP \ + | WRITE_PROC_SECOND_WAIT \ + | WRITE_PROC_SECOND_MB \ + | WRITE_FREE) + +#define WRITE_PROC_ALL_TOKENS_CLEAR ((1 << 15) - 1) + +/* + * Mutexes are implied around writer execution. A single writer at a time. + */ +active proctype urcu_writer() +{ + byte i, j; + byte tmp, tmp2, tmpa; + byte cur_data = 0, old_data, loop_nr = 0; + byte cur_gp_val = 0; /* + * Keep a local trace of the current parity so + * we don't add non-existing dependencies on the global + * GP update. Needed to test single flip case. + */ + + wait_init_done(); + + assert(get_pid() < NR_PROCS); + + do + :: (loop_nr < 3) -> +#ifdef WRITER_PROGRESS +progress_writer1: +#endif + loop_nr = loop_nr + 1; + + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROD_NONE); + +#ifdef NO_WMB + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_WMB); +#endif + +#ifdef NO_MB + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_FIRST_MB); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_MB); +#endif + +#ifdef SINGLE_FLIP + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_READ_GP); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_WRITE_GP); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_WAIT); + /* For single flip, we need to know the current parity */ + cur_gp_val = cur_gp_val ^ RCU_GP_CTR_BIT; +#endif + + do :: 1 -> + atomic { + if + + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_PROD_NONE, + WRITE_DATA) -> + ooo_mem(i); + cur_data = (cur_data + 1) % SLAB_SIZE; + WRITE_CACHED_VAR(rcu_data[cur_data], WINE); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_DATA); + + + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_DATA, + WRITE_PROC_WMB) -> + smp_wmb(i); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_WMB); + + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_PROC_WMB, + WRITE_XCHG_PTR) -> + /* rcu_xchg_pointer() */ + atomic { + old_data = READ_CACHED_VAR(rcu_ptr); + WRITE_CACHED_VAR(rcu_ptr, cur_data); + } + PRODUCE_TOKENS(proc_urcu_writer, WRITE_XCHG_PTR); + + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_DATA | WRITE_PROC_WMB | WRITE_XCHG_PTR, + WRITE_PROC_FIRST_MB) -> + goto smp_mb_send1; +smp_mb_send1_end: + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_FIRST_MB); + + /* first flip */ + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_PROC_FIRST_MB, + WRITE_PROC_FIRST_READ_GP) -> + tmpa = READ_CACHED_VAR(urcu_gp_ctr); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_FIRST_READ_GP); + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_PROC_FIRST_MB | WRITE_PROC_WMB + | WRITE_PROC_FIRST_READ_GP, + WRITE_PROC_FIRST_WRITE_GP) -> + ooo_mem(i); + WRITE_CACHED_VAR(urcu_gp_ctr, tmpa ^ RCU_GP_CTR_BIT); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_FIRST_WRITE_GP); + + :: CONSUME_TOKENS(proc_urcu_writer, + //WRITE_PROC_FIRST_WRITE_GP /* TEST ADDING SYNC CORE */ + WRITE_PROC_FIRST_MB, /* can be reordered before/after flips */ + WRITE_PROC_FIRST_WAIT | WRITE_PROC_FIRST_WAIT_LOOP) -> + ooo_mem(i); + /* ONLY WAITING FOR READER 0 */ + tmp2 = READ_CACHED_VAR(urcu_active_readers[0]); +#ifndef SINGLE_FLIP + /* In normal execution, we are always starting by + * waiting for the even parity. + */ + cur_gp_val = RCU_GP_CTR_BIT; +#endif + if + :: (tmp2 & RCU_GP_CTR_NEST_MASK) + && ((tmp2 ^ cur_gp_val) & RCU_GP_CTR_BIT) -> + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_FIRST_WAIT_LOOP); + :: else -> + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_FIRST_WAIT); + fi; + + :: CONSUME_TOKENS(proc_urcu_writer, + //WRITE_PROC_FIRST_WRITE_GP /* TEST ADDING SYNC CORE */ + WRITE_PROC_FIRST_WRITE_GP + | WRITE_PROC_FIRST_READ_GP + | WRITE_PROC_FIRST_WAIT_LOOP + | WRITE_DATA | WRITE_PROC_WMB | WRITE_XCHG_PTR + | WRITE_PROC_FIRST_MB, /* can be reordered before/after flips */ + 0) -> +#ifndef GEN_ERROR_WRITER_PROGRESS + goto smp_mb_send2; +smp_mb_send2_end: +#else + ooo_mem(i); +#endif + /* This instruction loops to WRITE_PROC_FIRST_WAIT */ + CLEAR_TOKENS(proc_urcu_writer, WRITE_PROC_FIRST_WAIT_LOOP | WRITE_PROC_FIRST_WAIT); + + /* second flip */ + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_PROC_FIRST_WAIT /* Control dependency : need to branch out of + * the loop to execute the next flip (CHECK) */ + | WRITE_PROC_FIRST_WRITE_GP + | WRITE_PROC_FIRST_READ_GP + | WRITE_PROC_FIRST_MB, + WRITE_PROC_SECOND_READ_GP) -> + ooo_mem(i); + tmpa = READ_CACHED_VAR(urcu_gp_ctr); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_READ_GP); + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_PROC_FIRST_MB + | WRITE_PROC_WMB + | WRITE_PROC_FIRST_READ_GP + | WRITE_PROC_FIRST_WRITE_GP + | WRITE_PROC_SECOND_READ_GP, + WRITE_PROC_SECOND_WRITE_GP) -> + ooo_mem(i); + WRITE_CACHED_VAR(urcu_gp_ctr, tmpa ^ RCU_GP_CTR_BIT); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_WRITE_GP); + + :: CONSUME_TOKENS(proc_urcu_writer, + //WRITE_PROC_FIRST_WRITE_GP /* TEST ADDING SYNC CORE */ + WRITE_PROC_FIRST_WAIT + | WRITE_PROC_FIRST_MB, /* can be reordered before/after flips */ + WRITE_PROC_SECOND_WAIT | WRITE_PROC_SECOND_WAIT_LOOP) -> + ooo_mem(i); + /* ONLY WAITING FOR READER 0 */ + tmp2 = READ_CACHED_VAR(urcu_active_readers[0]); + if + :: (tmp2 & RCU_GP_CTR_NEST_MASK) + && ((tmp2 ^ 0) & RCU_GP_CTR_BIT) -> + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_WAIT_LOOP); + :: else -> + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_WAIT); + fi; + + :: CONSUME_TOKENS(proc_urcu_writer, + //WRITE_PROC_FIRST_WRITE_GP /* TEST ADDING SYNC CORE */ + WRITE_PROC_SECOND_WRITE_GP + | WRITE_PROC_FIRST_WRITE_GP + | WRITE_PROC_SECOND_READ_GP + | WRITE_PROC_FIRST_READ_GP + | WRITE_PROC_SECOND_WAIT_LOOP + | WRITE_DATA | WRITE_PROC_WMB | WRITE_XCHG_PTR + | WRITE_PROC_FIRST_MB, /* can be reordered before/after flips */ + 0) -> +#ifndef GEN_ERROR_WRITER_PROGRESS + goto smp_mb_send3; +smp_mb_send3_end: +#else + ooo_mem(i); +#endif + /* This instruction loops to WRITE_PROC_SECOND_WAIT */ + CLEAR_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_WAIT_LOOP | WRITE_PROC_SECOND_WAIT); + + + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_PROC_FIRST_WAIT + | WRITE_PROC_SECOND_WAIT + | WRITE_PROC_FIRST_READ_GP + | WRITE_PROC_SECOND_READ_GP + | WRITE_PROC_FIRST_WRITE_GP + | WRITE_PROC_SECOND_WRITE_GP + | WRITE_DATA | WRITE_PROC_WMB | WRITE_XCHG_PTR + | WRITE_PROC_FIRST_MB, + WRITE_PROC_SECOND_MB) -> + goto smp_mb_send4; +smp_mb_send4_end: + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_MB); + + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_XCHG_PTR + | WRITE_PROC_FIRST_WAIT + | WRITE_PROC_SECOND_WAIT + | WRITE_PROC_WMB /* No dependency on + * WRITE_DATA because we + * write to a + * different location. */ + | WRITE_PROC_SECOND_MB + | WRITE_PROC_FIRST_MB, + WRITE_FREE) -> + WRITE_CACHED_VAR(rcu_data[old_data], POISON); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_FREE); + + :: CONSUME_TOKENS(proc_urcu_writer, WRITE_PROC_ALL_TOKENS, 0) -> + CLEAR_TOKENS(proc_urcu_writer, WRITE_PROC_ALL_TOKENS_CLEAR); + break; + fi; + } + od; + /* + * Note : Promela model adds implicit serialization of the + * WRITE_FREE instruction. Normally, it would be permitted to + * spill on the next loop execution. Given the validation we do + * checks for the data entry read to be poisoned, it's ok if + * we do not check "late arriving" memory poisoning. + */ + :: else -> break; + od; + /* + * Given the reader loops infinitely, let the writer also busy-loop + * with progress here so, with weak fairness, we can test the + * writer's progress. + */ +end_writer: + do + :: 1 -> +#ifdef WRITER_PROGRESS +progress_writer2: +#endif +#ifdef READER_PROGRESS + /* + * Make sure we don't block the reader's progress. + */ + smp_mb_send(i, j, 5); +#endif + skip; + od; + + /* Non-atomic parts of the loop */ + goto end; +smp_mb_send1: + smp_mb_send(i, j, 1); + goto smp_mb_send1_end; +#ifndef GEN_ERROR_WRITER_PROGRESS +smp_mb_send2: + smp_mb_send(i, j, 2); + goto smp_mb_send2_end; +smp_mb_send3: + smp_mb_send(i, j, 3); + goto smp_mb_send3_end; +#endif +smp_mb_send4: + smp_mb_send(i, j, 4); + goto smp_mb_send4_end; +end: + skip; +} + +/* no name clash please */ +#undef proc_urcu_writer + + +/* Leave after the readers and writers so the pid count is ok. */ +init { + byte i, j; + + atomic { + INIT_CACHED_VAR(urcu_gp_ctr, 1, j); + INIT_CACHED_VAR(rcu_ptr, 0, j); + + i = 0; + do + :: i < NR_READERS -> + INIT_CACHED_VAR(urcu_active_readers[i], 0, j); + ptr_read_first[i] = 1; + ptr_read_second[i] = 1; + data_read_first[i] = WINE; + data_read_second[i] = WINE; + i++; + :: i >= NR_READERS -> break + od; + INIT_CACHED_VAR(rcu_data[0], WINE, j); + i = 1; + do + :: i < SLAB_SIZE -> + INIT_CACHED_VAR(rcu_data[i], POISON, j); + i++ + :: i >= SLAB_SIZE -> break + od; + + init_done = 1; + } +} diff --git a/formal-model/results/urcu-controldataflow-ipi-intel/urcu_free_nested.define b/formal-model/results/urcu-controldataflow-ipi-intel/urcu_free_nested.define new file mode 100644 index 0000000..0fb59bd --- /dev/null +++ b/formal-model/results/urcu-controldataflow-ipi-intel/urcu_free_nested.define @@ -0,0 +1 @@ +#define READER_NEST_LEVEL 2 diff --git a/formal-model/results/urcu-controldataflow-ipi-intel/urcu_free_no_mb.define b/formal-model/results/urcu-controldataflow-ipi-intel/urcu_free_no_mb.define new file mode 100644 index 0000000..d99d793 --- /dev/null +++ b/formal-model/results/urcu-controldataflow-ipi-intel/urcu_free_no_mb.define @@ -0,0 +1 @@ +#define NO_MB diff --git a/formal-model/results/urcu-controldataflow-ipi-intel/urcu_free_no_mb.log b/formal-model/results/urcu-controldataflow-ipi-intel/urcu_free_no_mb.log new file mode 100644 index 0000000..15f7bc2 --- /dev/null +++ b/formal-model/results/urcu-controldataflow-ipi-intel/urcu_free_no_mb.log @@ -0,0 +1,624 @@ +make[1]: Entering directory `/home/compudj/doc/userspace-rcu/formal-model/urcu-controldataflow' +rm -f pan* trail.out .input.spin* *.spin.trail .input.define +touch .input.define +cat .input.define >> pan.ltl +cat DEFINES >> pan.ltl +spin -f "!(`cat urcu_free.ltl | grep -v ^//`)" >> pan.ltl +cp urcu_free_no_mb.define .input.define +cat .input.define > .input.spin +cat DEFINES >> .input.spin +cat urcu.spin >> .input.spin +rm -f .input.spin.trail +spin -a -X -N pan.ltl .input.spin +Exit-Status 0 +gcc -O2 -w -DHASH64 -o pan pan.c +./pan -a -v -c1 -X -m10000000 -w20 +warning: for p.o. reduction to be valid the never claim must be stutter-invariant +(never claims generated from LTL formulae are stutter-invariant) +depth 0: Claim reached state 5 (line 1272) +Depth= 5327 States= 1e+06 Transitions= 7.34e+06 Memory= 550.432 t= 18.2 R= 6e+04 +pan: claim violated! (at depth 1301) +pan: wrote .input.spin.trail + +(Spin Version 5.1.7 -- 23 December 2008) +Warning: Search not completed + + Partial Order Reduction + +Full statespace search for: + never claim + + assertion violations + (if within scope of claim) + acceptance cycles + (fairness disabled) + invalid end states - (disabled by never claim) + +State-vector 88 byte, depth reached 5456, errors: 1 + 1674433 states, stored + 12624035 states, matched + 14298468 transitions (= stored+matched) +2.0423758e+08 atomic steps +hash conflicts: 6074438 (resolved) + +Stats on memory usage (in Megabytes): + 185.236 equivalent memory usage for states (stored*(State-vector + overhead)) + 141.360 actual memory usage for states (compression: 76.31%) + state-vector as stored = 61 byte + 28 byte overhead + 8.000 memory used for hash table (-w20) + 457.764 memory used for DFS stack (-m10000000) + 606.975 total actual memory usage + +unreached in proctype urcu_reader + line 262, "pan.___", state 34, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 270, "pan.___", state 56, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 274, "pan.___", state 65, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 81, "(1)" + line 243, "pan.___", state 89, "(1)" + line 247, "pan.___", state 101, "(1)" + line 251, "pan.___", state 109, "(1)" + line 401, "pan.___", state 135, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 167, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 181, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 199, "(1)" + line 247, "pan.___", state 219, "(1)" + line 251, "pan.___", state 227, "(1)" + line 689, "pan.___", state 246, "_proc_urcu_reader = (_proc_urcu_reader|((1<<2)<<1))" + line 401, "pan.___", state 253, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 285, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 299, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 317, "(1)" + line 247, "pan.___", state 337, "(1)" + line 251, "pan.___", state 345, "(1)" + line 401, "pan.___", state 364, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 396, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 410, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 428, "(1)" + line 247, "pan.___", state 448, "(1)" + line 251, "pan.___", state 456, "(1)" + line 401, "pan.___", state 477, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 401, "pan.___", state 479, "(1)" + line 401, "pan.___", state 480, "((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid)))" + line 401, "pan.___", state 480, "else" + line 401, "pan.___", state 483, "(1)" + line 405, "pan.___", state 491, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 405, "pan.___", state 493, "(1)" + line 405, "pan.___", state 494, "((cache_dirty_urcu_active_readers.bitfield&(1<<_pid)))" + line 405, "pan.___", state 494, "else" + line 405, "pan.___", state 497, "(1)" + line 405, "pan.___", state 498, "(1)" + line 405, "pan.___", state 498, "(1)" + line 403, "pan.___", state 503, "((i<1))" + line 403, "pan.___", state 503, "((i>=1))" + line 410, "pan.___", state 509, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 511, "(1)" + line 410, "pan.___", state 512, "((cache_dirty_rcu_ptr.bitfield&(1<<_pid)))" + line 410, "pan.___", state 512, "else" + line 410, "pan.___", state 515, "(1)" + line 410, "pan.___", state 516, "(1)" + line 410, "pan.___", state 516, "(1)" + line 414, "pan.___", state 523, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 414, "pan.___", state 525, "(1)" + line 414, "pan.___", state 526, "((cache_dirty_rcu_data[i].bitfield&(1<<_pid)))" + line 414, "pan.___", state 526, "else" + line 414, "pan.___", state 529, "(1)" + line 414, "pan.___", state 530, "(1)" + line 414, "pan.___", state 530, "(1)" + line 412, "pan.___", state 535, "((i<2))" + line 412, "pan.___", state 535, "((i>=2))" + line 239, "pan.___", state 541, "(1)" + line 243, "pan.___", state 549, "(1)" + line 243, "pan.___", state 550, "(!((cache_dirty_urcu_active_readers.bitfield&(1<<_pid))))" + line 243, "pan.___", state 550, "else" + line 241, "pan.___", state 555, "((i<1))" + line 241, "pan.___", state 555, "((i>=1))" + line 247, "pan.___", state 561, "(1)" + line 247, "pan.___", state 562, "(!((cache_dirty_rcu_ptr.bitfield&(1<<_pid))))" + line 247, "pan.___", state 562, "else" + line 251, "pan.___", state 569, "(1)" + line 251, "pan.___", state 570, "(!((cache_dirty_rcu_data[i].bitfield&(1<<_pid))))" + line 251, "pan.___", state 570, "else" + line 249, "pan.___", state 575, "((i<2))" + line 249, "pan.___", state 575, "((i>=2))" + line 256, "pan.___", state 579, "(!((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid))))" + line 256, "pan.___", state 579, "else" + line 421, "pan.___", state 581, "(1)" + line 421, "pan.___", state 581, "(1)" + line 689, "pan.___", state 584, "cached_urcu_active_readers.val[_pid] = (tmp+1)" + line 689, "pan.___", state 585, "_proc_urcu_reader = (_proc_urcu_reader|(1<<5))" + line 689, "pan.___", state 586, "(1)" + line 401, "pan.___", state 593, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 625, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 639, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 657, "(1)" + line 247, "pan.___", state 677, "(1)" + line 251, "pan.___", state 685, "(1)" + line 401, "pan.___", state 711, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 401, "pan.___", state 713, "(1)" + line 401, "pan.___", state 714, "((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid)))" + line 401, "pan.___", state 714, "else" + line 401, "pan.___", state 717, "(1)" + line 405, "pan.___", state 725, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 405, "pan.___", state 727, "(1)" + line 405, "pan.___", state 728, "((cache_dirty_urcu_active_readers.bitfield&(1<<_pid)))" + line 405, "pan.___", state 728, "else" + line 405, "pan.___", state 731, "(1)" + line 405, "pan.___", state 732, "(1)" + line 405, "pan.___", state 732, "(1)" + line 403, "pan.___", state 737, "((i<1))" + line 403, "pan.___", state 737, "((i>=1))" + line 410, "pan.___", state 743, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 745, "(1)" + line 410, "pan.___", state 746, "((cache_dirty_rcu_ptr.bitfield&(1<<_pid)))" + line 410, "pan.___", state 746, "else" + line 410, "pan.___", state 749, "(1)" + line 410, "pan.___", state 750, "(1)" + line 410, "pan.___", state 750, "(1)" + line 414, "pan.___", state 757, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 414, "pan.___", state 759, "(1)" + line 414, "pan.___", state 760, "((cache_dirty_rcu_data[i].bitfield&(1<<_pid)))" + line 414, "pan.___", state 760, "else" + line 414, "pan.___", state 763, "(1)" + line 414, "pan.___", state 764, "(1)" + line 414, "pan.___", state 764, "(1)" + line 412, "pan.___", state 769, "((i<2))" + line 412, "pan.___", state 769, "((i>=2))" + line 239, "pan.___", state 775, "(1)" + line 243, "pan.___", state 783, "(1)" + line 243, "pan.___", state 784, "(!((cache_dirty_urcu_active_readers.bitfield&(1<<_pid))))" + line 243, "pan.___", state 784, "else" + line 241, "pan.___", state 789, "((i<1))" + line 241, "pan.___", state 789, "((i>=1))" + line 247, "pan.___", state 795, "(1)" + line 247, "pan.___", state 796, "(!((cache_dirty_rcu_ptr.bitfield&(1<<_pid))))" + line 247, "pan.___", state 796, "else" + line 251, "pan.___", state 803, "(1)" + line 251, "pan.___", state 804, "(!((cache_dirty_rcu_data[i].bitfield&(1<<_pid))))" + line 251, "pan.___", state 804, "else" + line 256, "pan.___", state 813, "(!((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid))))" + line 256, "pan.___", state 813, "else" + line 421, "pan.___", state 815, "(1)" + line 421, "pan.___", state 815, "(1)" + line 401, "pan.___", state 822, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 401, "pan.___", state 824, "(1)" + line 401, "pan.___", state 825, "((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid)))" + line 401, "pan.___", state 825, "else" + line 401, "pan.___", state 828, "(1)" + line 405, "pan.___", state 836, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 405, "pan.___", state 838, "(1)" + line 405, "pan.___", state 839, "((cache_dirty_urcu_active_readers.bitfield&(1<<_pid)))" + line 405, "pan.___", state 839, "else" + line 405, "pan.___", state 842, "(1)" + line 405, "pan.___", state 843, "(1)" + line 405, "pan.___", state 843, "(1)" + line 403, "pan.___", state 848, "((i<1))" + line 403, "pan.___", state 848, "((i>=1))" + line 410, "pan.___", state 854, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 856, "(1)" + line 410, "pan.___", state 857, "((cache_dirty_rcu_ptr.bitfield&(1<<_pid)))" + line 410, "pan.___", state 857, "else" + line 410, "pan.___", state 860, "(1)" + line 410, "pan.___", state 861, "(1)" + line 410, "pan.___", state 861, "(1)" + line 414, "pan.___", state 868, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 414, "pan.___", state 870, "(1)" + line 414, "pan.___", state 871, "((cache_dirty_rcu_data[i].bitfield&(1<<_pid)))" + line 414, "pan.___", state 871, "else" + line 414, "pan.___", state 874, "(1)" + line 414, "pan.___", state 875, "(1)" + line 414, "pan.___", state 875, "(1)" + line 412, "pan.___", state 880, "((i<2))" + line 412, "pan.___", state 880, "((i>=2))" + line 239, "pan.___", state 886, "(1)" + line 243, "pan.___", state 894, "(1)" + line 243, "pan.___", state 895, "(!((cache_dirty_urcu_active_readers.bitfield&(1<<_pid))))" + line 243, "pan.___", state 895, "else" + line 241, "pan.___", state 900, "((i<1))" + line 241, "pan.___", state 900, "((i>=1))" + line 247, "pan.___", state 906, "(1)" + line 247, "pan.___", state 907, "(!((cache_dirty_rcu_ptr.bitfield&(1<<_pid))))" + line 247, "pan.___", state 907, "else" + line 251, "pan.___", state 914, "(1)" + line 251, "pan.___", state 915, "(!((cache_dirty_rcu_data[i].bitfield&(1<<_pid))))" + line 251, "pan.___", state 915, "else" + line 249, "pan.___", state 920, "((i<2))" + line 249, "pan.___", state 920, "((i>=2))" + line 256, "pan.___", state 924, "(!((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid))))" + line 256, "pan.___", state 924, "else" + line 421, "pan.___", state 926, "(1)" + line 421, "pan.___", state 926, "(1)" + line 697, "pan.___", state 930, "_proc_urcu_reader = (_proc_urcu_reader|(1<<11))" + line 401, "pan.___", state 935, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 967, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 981, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 999, "(1)" + line 247, "pan.___", state 1019, "(1)" + line 251, "pan.___", state 1027, "(1)" + line 401, "pan.___", state 1049, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 1081, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 1095, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 1113, "(1)" + line 247, "pan.___", state 1133, "(1)" + line 251, "pan.___", state 1141, "(1)" + line 401, "pan.___", state 1164, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 1196, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 1210, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 1228, "(1)" + line 247, "pan.___", state 1248, "(1)" + line 251, "pan.___", state 1256, "(1)" + line 401, "pan.___", state 1275, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 1307, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 1321, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 1339, "(1)" + line 247, "pan.___", state 1359, "(1)" + line 251, "pan.___", state 1367, "(1)" + line 401, "pan.___", state 1391, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 1423, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 1437, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 1455, "(1)" + line 247, "pan.___", state 1475, "(1)" + line 251, "pan.___", state 1483, "(1)" + line 401, "pan.___", state 1502, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 1534, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 1548, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 1566, "(1)" + line 247, "pan.___", state 1586, "(1)" + line 251, "pan.___", state 1594, "(1)" + line 401, "pan.___", state 1616, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 1648, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 1662, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 1680, "(1)" + line 247, "pan.___", state 1700, "(1)" + line 251, "pan.___", state 1708, "(1)" + line 736, "pan.___", state 1727, "_proc_urcu_reader = (_proc_urcu_reader|((1<<2)<<19))" + line 401, "pan.___", state 1734, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 1766, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 1780, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 1798, "(1)" + line 247, "pan.___", state 1818, "(1)" + line 251, "pan.___", state 1826, "(1)" + line 401, "pan.___", state 1845, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 1877, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 1891, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 1909, "(1)" + line 247, "pan.___", state 1929, "(1)" + line 251, "pan.___", state 1937, "(1)" + line 401, "pan.___", state 1958, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 401, "pan.___", state 1960, "(1)" + line 401, "pan.___", state 1961, "((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid)))" + line 401, "pan.___", state 1961, "else" + line 401, "pan.___", state 1964, "(1)" + line 405, "pan.___", state 1972, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 405, "pan.___", state 1974, "(1)" + line 405, "pan.___", state 1975, "((cache_dirty_urcu_active_readers.bitfield&(1<<_pid)))" + line 405, "pan.___", state 1975, "else" + line 405, "pan.___", state 1978, "(1)" + line 405, "pan.___", state 1979, "(1)" + line 405, "pan.___", state 1979, "(1)" + line 403, "pan.___", state 1984, "((i<1))" + line 403, "pan.___", state 1984, "((i>=1))" + line 410, "pan.___", state 1990, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 1992, "(1)" + line 410, "pan.___", state 1993, "((cache_dirty_rcu_ptr.bitfield&(1<<_pid)))" + line 410, "pan.___", state 1993, "else" + line 410, "pan.___", state 1996, "(1)" + line 410, "pan.___", state 1997, "(1)" + line 410, "pan.___", state 1997, "(1)" + line 414, "pan.___", state 2004, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 414, "pan.___", state 2006, "(1)" + line 414, "pan.___", state 2007, "((cache_dirty_rcu_data[i].bitfield&(1<<_pid)))" + line 414, "pan.___", state 2007, "else" + line 414, "pan.___", state 2010, "(1)" + line 414, "pan.___", state 2011, "(1)" + line 414, "pan.___", state 2011, "(1)" + line 412, "pan.___", state 2016, "((i<2))" + line 412, "pan.___", state 2016, "((i>=2))" + line 239, "pan.___", state 2022, "(1)" + line 243, "pan.___", state 2030, "(1)" + line 243, "pan.___", state 2031, "(!((cache_dirty_urcu_active_readers.bitfield&(1<<_pid))))" + line 243, "pan.___", state 2031, "else" + line 241, "pan.___", state 2036, "((i<1))" + line 241, "pan.___", state 2036, "((i>=1))" + line 247, "pan.___", state 2042, "(1)" + line 247, "pan.___", state 2043, "(!((cache_dirty_rcu_ptr.bitfield&(1<<_pid))))" + line 247, "pan.___", state 2043, "else" + line 251, "pan.___", state 2050, "(1)" + line 251, "pan.___", state 2051, "(!((cache_dirty_rcu_data[i].bitfield&(1<<_pid))))" + line 251, "pan.___", state 2051, "else" + line 249, "pan.___", state 2056, "((i<2))" + line 249, "pan.___", state 2056, "((i>=2))" + line 256, "pan.___", state 2060, "(!((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid))))" + line 256, "pan.___", state 2060, "else" + line 421, "pan.___", state 2062, "(1)" + line 421, "pan.___", state 2062, "(1)" + line 736, "pan.___", state 2065, "cached_urcu_active_readers.val[_pid] = (tmp+1)" + line 736, "pan.___", state 2066, "_proc_urcu_reader = (_proc_urcu_reader|(1<<23))" + line 736, "pan.___", state 2067, "(1)" + line 401, "pan.___", state 2074, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 2106, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 2120, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 2138, "(1)" + line 247, "pan.___", state 2158, "(1)" + line 251, "pan.___", state 2166, "(1)" + line 401, "pan.___", state 2191, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 2223, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 2237, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 2255, "(1)" + line 247, "pan.___", state 2275, "(1)" + line 251, "pan.___", state 2283, "(1)" + line 401, "pan.___", state 2302, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 2334, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 2348, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 2366, "(1)" + line 247, "pan.___", state 2386, "(1)" + line 251, "pan.___", state 2394, "(1)" + line 239, "pan.___", state 2425, "(1)" + line 247, "pan.___", state 2445, "(1)" + line 251, "pan.___", state 2453, "(1)" + line 239, "pan.___", state 2468, "(1)" + line 247, "pan.___", state 2488, "(1)" + line 251, "pan.___", state 2496, "(1)" + line 887, "pan.___", state 2513, "-end-" + (246 of 2513 states) +unreached in proctype urcu_writer + line 401, "pan.___", state 20, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 401, "pan.___", state 26, "(1)" + line 405, "pan.___", state 34, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 405, "pan.___", state 40, "(1)" + line 405, "pan.___", state 41, "(1)" + line 405, "pan.___", state 41, "(1)" + line 403, "pan.___", state 46, "((i<1))" + line 403, "pan.___", state 46, "((i>=1))" + line 410, "pan.___", state 52, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 58, "(1)" + line 410, "pan.___", state 59, "(1)" + line 410, "pan.___", state 59, "(1)" + line 414, "pan.___", state 72, "(1)" + line 414, "pan.___", state 73, "(1)" + line 414, "pan.___", state 73, "(1)" + line 412, "pan.___", state 78, "((i<2))" + line 412, "pan.___", state 78, "((i>=2))" + line 239, "pan.___", state 84, "(1)" + line 243, "pan.___", state 92, "(1)" + line 243, "pan.___", state 93, "(!((cache_dirty_urcu_active_readers.bitfield&(1<<_pid))))" + line 243, "pan.___", state 93, "else" + line 241, "pan.___", state 98, "((i<1))" + line 241, "pan.___", state 98, "((i>=1))" + line 247, "pan.___", state 104, "(1)" + line 247, "pan.___", state 105, "(!((cache_dirty_rcu_ptr.bitfield&(1<<_pid))))" + line 247, "pan.___", state 105, "else" + line 251, "pan.___", state 112, "(1)" + line 251, "pan.___", state 113, "(!((cache_dirty_rcu_data[i].bitfield&(1<<_pid))))" + line 251, "pan.___", state 113, "else" + line 249, "pan.___", state 118, "((i<2))" + line 249, "pan.___", state 118, "((i>=2))" + line 256, "pan.___", state 122, "(!((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid))))" + line 256, "pan.___", state 122, "else" + line 421, "pan.___", state 124, "(1)" + line 421, "pan.___", state 124, "(1)" + line 262, "pan.___", state 133, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 266, "pan.___", state 142, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 264, "pan.___", state 150, "((i<1))" + line 264, "pan.___", state 150, "((i>=1))" + line 270, "pan.___", state 155, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 1010, "pan.___", state 183, "old_data = cached_rcu_ptr.val[_pid]" + line 1021, "pan.___", state 187, "_proc_urcu_writer = (_proc_urcu_writer|(1<<4))" + line 401, "pan.___", state 195, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 401, "pan.___", state 201, "(1)" + line 405, "pan.___", state 209, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 405, "pan.___", state 215, "(1)" + line 405, "pan.___", state 216, "(1)" + line 405, "pan.___", state 216, "(1)" + line 410, "pan.___", state 229, "(1)" + line 414, "pan.___", state 241, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 259, "(1)" + line 243, "pan.___", state 267, "(1)" + line 251, "pan.___", state 287, "(1)" + line 421, "pan.___", state 299, "(1)" + line 421, "pan.___", state 299, "(1)" + line 405, "pan.___", state 322, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 354, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 243, "pan.___", state 380, "(1)" + line 251, "pan.___", state 400, "(1)" + line 405, "pan.___", state 442, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 243, "pan.___", state 500, "(1)" + line 405, "pan.___", state 553, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 243, "pan.___", state 611, "(1)" + line 405, "pan.___", state 666, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 698, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 243, "pan.___", state 724, "(1)" + line 251, "pan.___", state 744, "(1)" + line 1145, "pan.___", state 769, "_proc_urcu_writer = (_proc_urcu_writer|(1<<13))" + line 262, "pan.___", state 797, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 262, "pan.___", state 799, "(1)" + line 266, "pan.___", state 806, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 266, "pan.___", state 808, "(1)" + line 266, "pan.___", state 809, "((cache_dirty_urcu_active_readers.bitfield&(1<<_pid)))" + line 266, "pan.___", state 809, "else" + line 264, "pan.___", state 814, "((i<1))" + line 264, "pan.___", state 814, "((i>=1))" + line 270, "pan.___", state 819, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 270, "pan.___", state 821, "(1)" + line 270, "pan.___", state 822, "((cache_dirty_rcu_ptr.bitfield&(1<<_pid)))" + line 270, "pan.___", state 822, "else" + line 274, "pan.___", state 828, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 274, "pan.___", state 830, "(1)" + line 274, "pan.___", state 831, "((cache_dirty_rcu_data[i].bitfield&(1<<_pid)))" + line 274, "pan.___", state 831, "else" + line 272, "pan.___", state 836, "((i<2))" + line 272, "pan.___", state 836, "((i>=2))" + line 239, "pan.___", state 844, "(1)" + line 243, "pan.___", state 852, "(1)" + line 243, "pan.___", state 853, "(!((cache_dirty_urcu_active_readers.bitfield&(1<<_pid))))" + line 243, "pan.___", state 853, "else" + line 241, "pan.___", state 858, "((i<1))" + line 241, "pan.___", state 858, "((i>=1))" + line 247, "pan.___", state 864, "(1)" + line 247, "pan.___", state 865, "(!((cache_dirty_rcu_ptr.bitfield&(1<<_pid))))" + line 247, "pan.___", state 865, "else" + line 251, "pan.___", state 872, "(1)" + line 251, "pan.___", state 873, "(!((cache_dirty_rcu_data[i].bitfield&(1<<_pid))))" + line 251, "pan.___", state 873, "else" + line 256, "pan.___", state 882, "(!((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid))))" + line 256, "pan.___", state 882, "else" + line 1199, "pan.___", state 898, "((i<1))" + line 1199, "pan.___", state 898, "((i>=1))" + line 262, "pan.___", state 903, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 262, "pan.___", state 905, "(1)" + line 266, "pan.___", state 912, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 266, "pan.___", state 914, "(1)" + line 266, "pan.___", state 915, "((cache_dirty_urcu_active_readers.bitfield&(1<<_pid)))" + line 266, "pan.___", state 915, "else" + line 264, "pan.___", state 920, "((i<1))" + line 264, "pan.___", state 920, "((i>=1))" + line 270, "pan.___", state 925, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 270, "pan.___", state 927, "(1)" + line 270, "pan.___", state 928, "((cache_dirty_rcu_ptr.bitfield&(1<<_pid)))" + line 270, "pan.___", state 928, "else" + line 274, "pan.___", state 934, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 274, "pan.___", state 936, "(1)" + line 274, "pan.___", state 937, "((cache_dirty_rcu_data[i].bitfield&(1<<_pid)))" + line 274, "pan.___", state 937, "else" + line 272, "pan.___", state 942, "((i<2))" + line 272, "pan.___", state 942, "((i>=2))" + line 239, "pan.___", state 950, "(1)" + line 243, "pan.___", state 958, "(1)" + line 243, "pan.___", state 959, "(!((cache_dirty_urcu_active_readers.bitfield&(1<<_pid))))" + line 243, "pan.___", state 959, "else" + line 241, "pan.___", state 964, "((i<1))" + line 241, "pan.___", state 964, "((i>=1))" + line 247, "pan.___", state 970, "(1)" + line 247, "pan.___", state 971, "(!((cache_dirty_rcu_ptr.bitfield&(1<<_pid))))" + line 247, "pan.___", state 971, "else" + line 251, "pan.___", state 978, "(1)" + line 251, "pan.___", state 979, "(!((cache_dirty_rcu_data[i].bitfield&(1<<_pid))))" + line 251, "pan.___", state 979, "else" + line 256, "pan.___", state 988, "(!((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid))))" + line 256, "pan.___", state 988, "else" + line 289, "pan.___", state 990, "((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid)))" + line 289, "pan.___", state 990, "else" + line 1199, "pan.___", state 991, "((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid)))" + line 1199, "pan.___", state 991, "else" + line 266, "pan.___", state 1004, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 270, "pan.___", state 1017, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 274, "pan.___", state 1026, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 1042, "(1)" + line 243, "pan.___", state 1050, "(1)" + line 247, "pan.___", state 1062, "(1)" + line 251, "pan.___", state 1070, "(1)" + line 262, "pan.___", state 1101, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 266, "pan.___", state 1110, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 270, "pan.___", state 1123, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 274, "pan.___", state 1132, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 1148, "(1)" + line 243, "pan.___", state 1156, "(1)" + line 247, "pan.___", state 1168, "(1)" + line 251, "pan.___", state 1176, "(1)" + line 266, "pan.___", state 1202, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 274, "pan.___", state 1224, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 1240, "(1)" + line 243, "pan.___", state 1248, "(1)" + line 247, "pan.___", state 1260, "(1)" + line 251, "pan.___", state 1268, "(1)" + line 262, "pan.___", state 1299, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 266, "pan.___", state 1308, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 270, "pan.___", state 1321, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 274, "pan.___", state 1330, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 1346, "(1)" + line 243, "pan.___", state 1354, "(1)" + line 247, "pan.___", state 1366, "(1)" + line 251, "pan.___", state 1374, "(1)" + line 262, "pan.___", state 1391, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 262, "pan.___", state 1393, "(1)" + line 266, "pan.___", state 1400, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 266, "pan.___", state 1402, "(1)" + line 266, "pan.___", state 1403, "((cache_dirty_urcu_active_readers.bitfield&(1<<_pid)))" + line 266, "pan.___", state 1403, "else" + line 264, "pan.___", state 1408, "((i<1))" + line 264, "pan.___", state 1408, "((i>=1))" + line 270, "pan.___", state 1413, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 270, "pan.___", state 1415, "(1)" + line 270, "pan.___", state 1416, "((cache_dirty_rcu_ptr.bitfield&(1<<_pid)))" + line 270, "pan.___", state 1416, "else" + line 274, "pan.___", state 1422, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 274, "pan.___", state 1424, "(1)" + line 274, "pan.___", state 1425, "((cache_dirty_rcu_data[i].bitfield&(1<<_pid)))" + line 274, "pan.___", state 1425, "else" + line 272, "pan.___", state 1430, "((i<2))" + line 272, "pan.___", state 1430, "((i>=2))" + line 239, "pan.___", state 1438, "(1)" + line 243, "pan.___", state 1446, "(1)" + line 243, "pan.___", state 1447, "(!((cache_dirty_urcu_active_readers.bitfield&(1<<_pid))))" + line 243, "pan.___", state 1447, "else" + line 241, "pan.___", state 1452, "((i<1))" + line 241, "pan.___", state 1452, "((i>=1))" + line 247, "pan.___", state 1458, "(1)" + line 247, "pan.___", state 1459, "(!((cache_dirty_rcu_ptr.bitfield&(1<<_pid))))" + line 247, "pan.___", state 1459, "else" + line 251, "pan.___", state 1466, "(1)" + line 251, "pan.___", state 1467, "(!((cache_dirty_rcu_data[i].bitfield&(1<<_pid))))" + line 251, "pan.___", state 1467, "else" + line 256, "pan.___", state 1476, "(!((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid))))" + line 256, "pan.___", state 1476, "else" + line 1210, "pan.___", state 1479, "i = 0" + line 1210, "pan.___", state 1481, "reader_barrier = 1" + line 1210, "pan.___", state 1492, "((i<1))" + line 1210, "pan.___", state 1492, "((i>=1))" + line 262, "pan.___", state 1497, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 262, "pan.___", state 1499, "(1)" + line 266, "pan.___", state 1506, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 266, "pan.___", state 1508, "(1)" + line 266, "pan.___", state 1509, "((cache_dirty_urcu_active_readers.bitfield&(1<<_pid)))" + line 266, "pan.___", state 1509, "else" + line 264, "pan.___", state 1514, "((i<1))" + line 264, "pan.___", state 1514, "((i>=1))" + line 270, "pan.___", state 1519, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 270, "pan.___", state 1521, "(1)" + line 270, "pan.___", state 1522, "((cache_dirty_rcu_ptr.bitfield&(1<<_pid)))" + line 270, "pan.___", state 1522, "else" + line 274, "pan.___", state 1528, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 274, "pan.___", state 1530, "(1)" + line 274, "pan.___", state 1531, "((cache_dirty_rcu_data[i].bitfield&(1<<_pid)))" + line 274, "pan.___", state 1531, "else" + line 272, "pan.___", state 1536, "((i<2))" + line 272, "pan.___", state 1536, "((i>=2))" + line 239, "pan.___", state 1544, "(1)" + line 243, "pan.___", state 1552, "(1)" + line 243, "pan.___", state 1553, "(!((cache_dirty_urcu_active_readers.bitfield&(1<<_pid))))" + line 243, "pan.___", state 1553, "else" + line 241, "pan.___", state 1558, "((i<1))" + line 241, "pan.___", state 1558, "((i>=1))" + line 247, "pan.___", state 1564, "(1)" + line 247, "pan.___", state 1565, "(!((cache_dirty_rcu_ptr.bitfield&(1<<_pid))))" + line 247, "pan.___", state 1565, "else" + line 251, "pan.___", state 1572, "(1)" + line 251, "pan.___", state 1573, "(!((cache_dirty_rcu_data[i].bitfield&(1<<_pid))))" + line 251, "pan.___", state 1573, "else" + line 256, "pan.___", state 1582, "(!((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid))))" + line 256, "pan.___", state 1582, "else" + line 289, "pan.___", state 1584, "((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid)))" + line 289, "pan.___", state 1584, "else" + line 1210, "pan.___", state 1585, "((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid)))" + line 1210, "pan.___", state 1585, "else" + line 1214, "pan.___", state 1588, "-end-" + (179 of 1588 states) +unreached in proctype :init: + line 1225, "pan.___", state 9, "((j<2))" + line 1225, "pan.___", state 9, "((j>=2))" + line 1226, "pan.___", state 20, "((j<2))" + line 1226, "pan.___", state 20, "((j>=2))" + line 1231, "pan.___", state 33, "((j<2))" + line 1231, "pan.___", state 33, "((j>=2))" + line 1229, "pan.___", state 43, "((i<1))" + line 1229, "pan.___", state 43, "((i>=1))" + line 1239, "pan.___", state 54, "((j<2))" + line 1239, "pan.___", state 54, "((j>=2))" + line 1243, "pan.___", state 67, "((j<2))" + line 1243, "pan.___", state 67, "((j>=2))" + (6 of 78 states) +unreached in proctype :never: + line 1277, "pan.___", state 8, "-end-" + (1 of 8 states) + +pan: elapsed time 36.6 seconds +pan: rate 45762.039 states/second +pan: avg transition delay 2.559e-06 usec +cp .input.spin urcu_free_no_mb.spin.input +cp .input.spin.trail urcu_free_no_mb.spin.input.trail +make[1]: Leaving directory `/home/compudj/doc/userspace-rcu/formal-model/urcu-controldataflow' diff --git a/formal-model/results/urcu-controldataflow-ipi-intel/urcu_free_no_mb.spin.input b/formal-model/results/urcu-controldataflow-ipi-intel/urcu_free_no_mb.spin.input new file mode 100644 index 0000000..739f3ef --- /dev/null +++ b/formal-model/results/urcu-controldataflow-ipi-intel/urcu_free_no_mb.spin.input @@ -0,0 +1,1250 @@ +#define NO_MB + +// Poison value for freed memory +#define POISON 1 +// Memory with correct data +#define WINE 0 +#define SLAB_SIZE 2 + +#define read_poison (data_read_first[0] == POISON || data_read_second[0] == POISON) + +#define RCU_GP_CTR_BIT (1 << 7) +#define RCU_GP_CTR_NEST_MASK (RCU_GP_CTR_BIT - 1) + +//disabled +#define REMOTE_BARRIERS + +//#define ARCH_ALPHA +#define ARCH_INTEL +//#define ARCH_POWERPC +/* + * mem.spin: Promela code to validate memory barriers with OOO memory + * and out-of-order instruction scheduling. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * Copyright (c) 2009 Mathieu Desnoyers + */ + +/* Promela validation variables. */ + +/* specific defines "included" here */ +/* DEFINES file "included" here */ + +#define NR_READERS 1 +#define NR_WRITERS 1 + +#define NR_PROCS 2 + +#define get_pid() (_pid) + +#define get_readerid() (get_pid()) + +/* + * Produced process control and data flow. Updated after each instruction to + * show which variables are ready. Using one-hot bit encoding per variable to + * save state space. Used as triggers to execute the instructions having those + * variables as input. Leaving bits active to inhibit instruction execution. + * Scheme used to make instruction disabling and automatic dependency fall-back + * automatic. + */ + +#define CONSUME_TOKENS(state, bits, notbits) \ + ((!(state & (notbits))) && (state & (bits)) == (bits)) + +#define PRODUCE_TOKENS(state, bits) \ + state = state | (bits); + +#define CLEAR_TOKENS(state, bits) \ + state = state & ~(bits) + +/* + * Types of dependency : + * + * Data dependency + * + * - True dependency, Read-after-Write (RAW) + * + * This type of dependency happens when a statement depends on the result of a + * previous statement. This applies to any statement which needs to read a + * variable written by a preceding statement. + * + * - False dependency, Write-after-Read (WAR) + * + * Typically, variable renaming can ensure that this dependency goes away. + * However, if the statements must read and then write from/to the same variable + * in the OOO memory model, renaming may be impossible, and therefore this + * causes a WAR dependency. + * + * - Output dependency, Write-after-Write (WAW) + * + * Two writes to the same variable in subsequent statements. Variable renaming + * can ensure this is not needed, but can be required when writing multiple + * times to the same OOO mem model variable. + * + * Control dependency + * + * Execution of a given instruction depends on a previous instruction evaluating + * in a way that allows its execution. E.g. : branches. + * + * Useful considerations for joining dependencies after branch + * + * - Pre-dominance + * + * "We say box i dominates box j if every path (leading from input to output + * through the diagram) which passes through box j must also pass through box + * i. Thus box i dominates box j if box j is subordinate to box i in the + * program." + * + * http://www.hipersoft.rice.edu/grads/publications/dom14.pdf + * Other classic algorithm to calculate dominance : Lengauer-Tarjan (in gcc) + * + * - Post-dominance + * + * Just as pre-dominance, but with arcs of the data flow inverted, and input vs + * output exchanged. Therefore, i post-dominating j ensures that every path + * passing by j will pass by i before reaching the output. + * + * Other considerations + * + * Note about "volatile" keyword dependency : The compiler will order volatile + * accesses so they appear in the right order on a given CPU. They can be + * reordered by the CPU instruction scheduling. This therefore cannot be + * considered as a depencency. + * + * References : + * + * Cooper, Keith D.; & Torczon, Linda. (2005). Engineering a Compiler. Morgan + * Kaufmann. ISBN 1-55860-698-X. + * Kennedy, Ken; & Allen, Randy. (2001). Optimizing Compilers for Modern + * Architectures: A Dependence-based Approach. Morgan Kaufmann. ISBN + * 1-55860-286-0. + * Muchnick, Steven S. (1997). Advanced Compiler Design and Implementation. + * Morgan Kaufmann. ISBN 1-55860-320-4. + */ + +/* + * Note about loops and nested calls + * + * To keep this model simple, loops expressed in the framework will behave as if + * there was a core synchronizing instruction between loops. To see the effect + * of loop unrolling, manually unrolling loops is required. Note that if loops + * end or start with a core synchronizing instruction, the model is appropriate. + * Nested calls are not supported. + */ + +/* + * Only Alpha has out-of-order cache bank loads. Other architectures (intel, + * powerpc, arm) ensure that dependent reads won't be reordered. c.f. + * http://www.linuxjournal.com/article/8212) +#ifdef ARCH_ALPHA +#define HAVE_OOO_CACHE_READ +#endif + +/* + * Each process have its own data in cache. Caches are randomly updated. + * smp_wmb and smp_rmb forces cache updates (write and read), smp_mb forces + * both. + */ + +typedef per_proc_byte { + byte val[NR_PROCS]; +}; + +typedef per_proc_bit { + bit val[NR_PROCS]; +}; + +/* Bitfield has a maximum of 8 procs */ +typedef per_proc_bitfield { + byte bitfield; +}; + +#define DECLARE_CACHED_VAR(type, x) \ + type mem_##x; \ + per_proc_##type cached_##x; \ + per_proc_bitfield cache_dirty_##x; + +#define INIT_CACHED_VAR(x, v, j) \ + mem_##x = v; \ + cache_dirty_##x.bitfield = 0; \ + j = 0; \ + do \ + :: j < NR_PROCS -> \ + cached_##x.val[j] = v; \ + j++ \ + :: j >= NR_PROCS -> break \ + od; + +#define IS_CACHE_DIRTY(x, id) (cache_dirty_##x.bitfield & (1 << id)) + +#define READ_CACHED_VAR(x) (cached_##x.val[get_pid()]) + +#define WRITE_CACHED_VAR(x, v) \ + atomic { \ + cached_##x.val[get_pid()] = v; \ + cache_dirty_##x.bitfield = \ + cache_dirty_##x.bitfield | (1 << get_pid()); \ + } + +#define CACHE_WRITE_TO_MEM(x, id) \ + if \ + :: IS_CACHE_DIRTY(x, id) -> \ + mem_##x = cached_##x.val[id]; \ + cache_dirty_##x.bitfield = \ + cache_dirty_##x.bitfield & (~(1 << id)); \ + :: else -> \ + skip \ + fi; + +#define CACHE_READ_FROM_MEM(x, id) \ + if \ + :: !IS_CACHE_DIRTY(x, id) -> \ + cached_##x.val[id] = mem_##x;\ + :: else -> \ + skip \ + fi; + +/* + * May update other caches if cache is dirty, or not. + */ +#define RANDOM_CACHE_WRITE_TO_MEM(x, id)\ + if \ + :: 1 -> CACHE_WRITE_TO_MEM(x, id); \ + :: 1 -> skip \ + fi; + +#define RANDOM_CACHE_READ_FROM_MEM(x, id)\ + if \ + :: 1 -> CACHE_READ_FROM_MEM(x, id); \ + :: 1 -> skip \ + fi; + +/* Must consume all prior read tokens. All subsequent reads depend on it. */ +inline smp_rmb(i) +{ + atomic { + CACHE_READ_FROM_MEM(urcu_gp_ctr, get_pid()); + i = 0; + do + :: i < NR_READERS -> + CACHE_READ_FROM_MEM(urcu_active_readers[i], get_pid()); + i++ + :: i >= NR_READERS -> break + od; + CACHE_READ_FROM_MEM(rcu_ptr, get_pid()); + i = 0; + do + :: i < SLAB_SIZE -> + CACHE_READ_FROM_MEM(rcu_data[i], get_pid()); + i++ + :: i >= SLAB_SIZE -> break + od; + } +} + +/* Must consume all prior write tokens. All subsequent writes depend on it. */ +inline smp_wmb(i) +{ + atomic { + CACHE_WRITE_TO_MEM(urcu_gp_ctr, get_pid()); + i = 0; + do + :: i < NR_READERS -> + CACHE_WRITE_TO_MEM(urcu_active_readers[i], get_pid()); + i++ + :: i >= NR_READERS -> break + od; + CACHE_WRITE_TO_MEM(rcu_ptr, get_pid()); + i = 0; + do + :: i < SLAB_SIZE -> + CACHE_WRITE_TO_MEM(rcu_data[i], get_pid()); + i++ + :: i >= SLAB_SIZE -> break + od; + } +} + +/* Synchronization point. Must consume all prior read and write tokens. All + * subsequent reads and writes depend on it. */ +inline smp_mb(i) +{ + atomic { + smp_wmb(i); + smp_rmb(i); + } +} + +#ifdef REMOTE_BARRIERS + +bit reader_barrier[NR_READERS]; + +/* + * We cannot leave the barriers dependencies in place in REMOTE_BARRIERS mode + * because they would add unexisting core synchronization and would therefore + * create an incomplete model. + * Therefore, we model the read-side memory barriers by completely disabling the + * memory barriers and their dependencies from the read-side. One at a time + * (different verification runs), we make a different instruction listen for + * signals. + */ + +#define smp_mb_reader(i, j) + +/* + * Service 0, 1 or many barrier requests. + */ +inline smp_mb_recv(i, j) +{ + do + :: (reader_barrier[get_readerid()] == 1) -> + /* + * We choose to ignore cycles caused by writer busy-looping, + * waiting for the reader, sending barrier requests, and the + * reader always services them without continuing execution. + */ +progress_ignoring_mb1: + smp_mb(i); + reader_barrier[get_readerid()] = 0; + :: 1 -> + /* + * We choose to ignore writer's non-progress caused by the + * reader ignoring the writer's mb() requests. + */ +progress_ignoring_mb2: + break; + od; +} + +#define PROGRESS_LABEL(progressid) progress_writer_progid_##progressid: + +#define smp_mb_send(i, j, progressid) \ +{ \ + smp_mb(i); \ + i = 0; \ + do \ + :: i < NR_READERS -> \ + reader_barrier[i] = 1; \ + /* \ + * Busy-looping waiting for reader barrier handling is of little\ + * interest, given the reader has the ability to totally ignore \ + * barrier requests. \ + */ \ + do \ + :: (reader_barrier[i] == 1) -> \ +PROGRESS_LABEL(progressid) \ + skip; \ + :: (reader_barrier[i] == 0) -> break; \ + od; \ + i++; \ + :: i >= NR_READERS -> \ + break \ + od; \ + smp_mb(i); \ +} + +#else + +#define smp_mb_send(i, j, progressid) smp_mb(i) +#define smp_mb_reader smp_mb(i) +#define smp_mb_recv(i, j) + +#endif + +/* Keep in sync manually with smp_rmb, smp_wmb, ooo_mem and init() */ +DECLARE_CACHED_VAR(byte, urcu_gp_ctr); +/* Note ! currently only one reader */ +DECLARE_CACHED_VAR(byte, urcu_active_readers[NR_READERS]); +/* RCU data */ +DECLARE_CACHED_VAR(bit, rcu_data[SLAB_SIZE]); + +/* RCU pointer */ +#if (SLAB_SIZE == 2) +DECLARE_CACHED_VAR(bit, rcu_ptr); +bit ptr_read_first[NR_READERS]; +bit ptr_read_second[NR_READERS]; +#else +DECLARE_CACHED_VAR(byte, rcu_ptr); +byte ptr_read_first[NR_READERS]; +byte ptr_read_second[NR_READERS]; +#endif + +bit data_read_first[NR_READERS]; +bit data_read_second[NR_READERS]; + +bit init_done = 0; + +inline wait_init_done() +{ + do + :: init_done == 0 -> skip; + :: else -> break; + od; +} + +inline ooo_mem(i) +{ + atomic { + RANDOM_CACHE_WRITE_TO_MEM(urcu_gp_ctr, get_pid()); + i = 0; + do + :: i < NR_READERS -> + RANDOM_CACHE_WRITE_TO_MEM(urcu_active_readers[i], + get_pid()); + i++ + :: i >= NR_READERS -> break + od; + RANDOM_CACHE_WRITE_TO_MEM(rcu_ptr, get_pid()); + i = 0; + do + :: i < SLAB_SIZE -> + RANDOM_CACHE_WRITE_TO_MEM(rcu_data[i], get_pid()); + i++ + :: i >= SLAB_SIZE -> break + od; +#ifdef HAVE_OOO_CACHE_READ + RANDOM_CACHE_READ_FROM_MEM(urcu_gp_ctr, get_pid()); + i = 0; + do + :: i < NR_READERS -> + RANDOM_CACHE_READ_FROM_MEM(urcu_active_readers[i], + get_pid()); + i++ + :: i >= NR_READERS -> break + od; + RANDOM_CACHE_READ_FROM_MEM(rcu_ptr, get_pid()); + i = 0; + do + :: i < SLAB_SIZE -> + RANDOM_CACHE_READ_FROM_MEM(rcu_data[i], get_pid()); + i++ + :: i >= SLAB_SIZE -> break + od; +#else + smp_rmb(i); +#endif /* HAVE_OOO_CACHE_READ */ + } +} + +/* + * Bit encoding, urcu_reader : + */ + +int _proc_urcu_reader; +#define proc_urcu_reader _proc_urcu_reader + +/* Body of PROCEDURE_READ_LOCK */ +#define READ_PROD_A_READ (1 << 0) +#define READ_PROD_B_IF_TRUE (1 << 1) +#define READ_PROD_B_IF_FALSE (1 << 2) +#define READ_PROD_C_IF_TRUE_READ (1 << 3) + +#define PROCEDURE_READ_LOCK(base, consumetoken, producetoken) \ + :: CONSUME_TOKENS(proc_urcu_reader, consumetoken, READ_PROD_A_READ << base) -> \ + ooo_mem(i); \ + tmp = READ_CACHED_VAR(urcu_active_readers[get_readerid()]); \ + PRODUCE_TOKENS(proc_urcu_reader, READ_PROD_A_READ << base); \ + :: CONSUME_TOKENS(proc_urcu_reader, \ + READ_PROD_A_READ << base, /* RAW, pre-dominant */ \ + (READ_PROD_B_IF_TRUE | READ_PROD_B_IF_FALSE) << base) -> \ + if \ + :: (!(tmp & RCU_GP_CTR_NEST_MASK)) -> \ + PRODUCE_TOKENS(proc_urcu_reader, READ_PROD_B_IF_TRUE << base); \ + :: else -> \ + PRODUCE_TOKENS(proc_urcu_reader, READ_PROD_B_IF_FALSE << base); \ + fi; \ + /* IF TRUE */ \ + :: CONSUME_TOKENS(proc_urcu_reader, READ_PROD_B_IF_TRUE << base, \ + READ_PROD_C_IF_TRUE_READ << base) -> \ + ooo_mem(i); \ + tmp2 = READ_CACHED_VAR(urcu_gp_ctr); \ + PRODUCE_TOKENS(proc_urcu_reader, READ_PROD_C_IF_TRUE_READ << base); \ + :: CONSUME_TOKENS(proc_urcu_reader, \ + (READ_PROD_C_IF_TRUE_READ /* pre-dominant */ \ + | READ_PROD_A_READ) << base, /* WAR */ \ + producetoken) -> \ + ooo_mem(i); \ + WRITE_CACHED_VAR(urcu_active_readers[get_readerid()], tmp2); \ + PRODUCE_TOKENS(proc_urcu_reader, producetoken); \ + /* IF_MERGE implies \ + * post-dominance */ \ + /* ELSE */ \ + :: CONSUME_TOKENS(proc_urcu_reader, \ + (READ_PROD_B_IF_FALSE /* pre-dominant */ \ + | READ_PROD_A_READ) << base, /* WAR */ \ + producetoken) -> \ + ooo_mem(i); \ + WRITE_CACHED_VAR(urcu_active_readers[get_readerid()], \ + tmp + 1); \ + PRODUCE_TOKENS(proc_urcu_reader, producetoken); \ + /* IF_MERGE implies \ + * post-dominance */ \ + /* ENDIF */ \ + skip + +/* Body of PROCEDURE_READ_LOCK */ +#define READ_PROC_READ_UNLOCK (1 << 0) + +#define PROCEDURE_READ_UNLOCK(base, consumetoken, producetoken) \ + :: CONSUME_TOKENS(proc_urcu_reader, \ + consumetoken, \ + READ_PROC_READ_UNLOCK << base) -> \ + ooo_mem(i); \ + tmp2 = READ_CACHED_VAR(urcu_active_readers[get_readerid()]); \ + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_READ_UNLOCK << base); \ + :: CONSUME_TOKENS(proc_urcu_reader, \ + consumetoken \ + | (READ_PROC_READ_UNLOCK << base), /* WAR */ \ + producetoken) -> \ + ooo_mem(i); \ + WRITE_CACHED_VAR(urcu_active_readers[get_readerid()], tmp2 - 1); \ + PRODUCE_TOKENS(proc_urcu_reader, producetoken); \ + skip + + +#define READ_PROD_NONE (1 << 0) + +/* PROCEDURE_READ_LOCK base = << 1 : 1 to 5 */ +#define READ_LOCK_BASE 1 +#define READ_LOCK_OUT (1 << 5) + +#define READ_PROC_FIRST_MB (1 << 6) + +/* PROCEDURE_READ_LOCK (NESTED) base : << 7 : 7 to 11 */ +#define READ_LOCK_NESTED_BASE 7 +#define READ_LOCK_NESTED_OUT (1 << 11) + +#define READ_PROC_READ_GEN (1 << 12) +#define READ_PROC_ACCESS_GEN (1 << 13) + +/* PROCEDURE_READ_UNLOCK (NESTED) base = << 14 : 14 to 15 */ +#define READ_UNLOCK_NESTED_BASE 14 +#define READ_UNLOCK_NESTED_OUT (1 << 15) + +#define READ_PROC_SECOND_MB (1 << 16) + +/* PROCEDURE_READ_UNLOCK base = << 17 : 17 to 18 */ +#define READ_UNLOCK_BASE 17 +#define READ_UNLOCK_OUT (1 << 18) + +/* PROCEDURE_READ_LOCK_UNROLL base = << 19 : 19 to 23 */ +#define READ_LOCK_UNROLL_BASE 19 +#define READ_LOCK_OUT_UNROLL (1 << 23) + +#define READ_PROC_THIRD_MB (1 << 24) + +#define READ_PROC_READ_GEN_UNROLL (1 << 25) +#define READ_PROC_ACCESS_GEN_UNROLL (1 << 26) + +#define READ_PROC_FOURTH_MB (1 << 27) + +/* PROCEDURE_READ_UNLOCK_UNROLL base = << 28 : 28 to 29 */ +#define READ_UNLOCK_UNROLL_BASE 28 +#define READ_UNLOCK_OUT_UNROLL (1 << 29) + + +/* Should not include branches */ +#define READ_PROC_ALL_TOKENS (READ_PROD_NONE \ + | READ_LOCK_OUT \ + | READ_PROC_FIRST_MB \ + | READ_LOCK_NESTED_OUT \ + | READ_PROC_READ_GEN \ + | READ_PROC_ACCESS_GEN \ + | READ_UNLOCK_NESTED_OUT \ + | READ_PROC_SECOND_MB \ + | READ_UNLOCK_OUT \ + | READ_LOCK_OUT_UNROLL \ + | READ_PROC_THIRD_MB \ + | READ_PROC_READ_GEN_UNROLL \ + | READ_PROC_ACCESS_GEN_UNROLL \ + | READ_PROC_FOURTH_MB \ + | READ_UNLOCK_OUT_UNROLL) + +/* Must clear all tokens, including branches */ +#define READ_PROC_ALL_TOKENS_CLEAR ((1 << 30) - 1) + +inline urcu_one_read(i, j, nest_i, tmp, tmp2) +{ + PRODUCE_TOKENS(proc_urcu_reader, READ_PROD_NONE); + +#ifdef NO_MB + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_FIRST_MB); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_SECOND_MB); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_THIRD_MB); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_FOURTH_MB); +#endif + +#ifdef REMOTE_BARRIERS + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_FIRST_MB); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_SECOND_MB); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_THIRD_MB); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_FOURTH_MB); +#endif + + do + :: 1 -> + +#ifdef REMOTE_BARRIERS + /* + * Signal-based memory barrier will only execute when the + * execution order appears in program order. + */ + if + :: 1 -> + atomic { + if + :: CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE, + READ_LOCK_OUT | READ_LOCK_NESTED_OUT + | READ_PROC_READ_GEN | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT + | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT, + READ_LOCK_NESTED_OUT + | READ_PROC_READ_GEN | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT + | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT | READ_LOCK_NESTED_OUT, + READ_PROC_READ_GEN | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT + | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN, + READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT + | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN | READ_PROC_ACCESS_GEN, + READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT + | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN + | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT, + READ_UNLOCK_OUT + | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN + | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT, + READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN + | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT | READ_LOCK_OUT_UNROLL, + READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN + | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL, + READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN + | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL, + READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL, + 0) -> + goto non_atomic3; +non_atomic3_end: + skip; + fi; + } + fi; + + goto non_atomic3_skip; +non_atomic3: + smp_mb_recv(i, j); + goto non_atomic3_end; +non_atomic3_skip: + +#endif /* REMOTE_BARRIERS */ + + atomic { + if + PROCEDURE_READ_LOCK(READ_LOCK_BASE, READ_PROD_NONE, READ_LOCK_OUT); + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_LOCK_OUT, /* post-dominant */ + READ_PROC_FIRST_MB) -> + smp_mb_reader(i, j); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_FIRST_MB); + + PROCEDURE_READ_LOCK(READ_LOCK_NESTED_BASE, READ_PROC_FIRST_MB | READ_LOCK_OUT, + READ_LOCK_NESTED_OUT); + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_PROC_FIRST_MB, /* mb() orders reads */ + READ_PROC_READ_GEN) -> + ooo_mem(i); + ptr_read_first[get_readerid()] = READ_CACHED_VAR(rcu_ptr); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_READ_GEN); + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_PROC_FIRST_MB /* mb() orders reads */ + | READ_PROC_READ_GEN, + READ_PROC_ACCESS_GEN) -> + /* smp_read_barrier_depends */ + goto rmb1; +rmb1_end: + data_read_first[get_readerid()] = + READ_CACHED_VAR(rcu_data[ptr_read_first[get_readerid()]]); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_ACCESS_GEN); + + + /* Note : we remove the nested memory barrier from the read unlock + * model, given it is not usually needed. The implementation has the barrier + * because the performance impact added by a branch in the common case does not + * justify it. + */ + + PROCEDURE_READ_UNLOCK(READ_UNLOCK_NESTED_BASE, + READ_PROC_FIRST_MB + | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT, + READ_UNLOCK_NESTED_OUT); + + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_PROC_ACCESS_GEN /* mb() orders reads */ + | READ_PROC_READ_GEN /* mb() orders reads */ + | READ_PROC_FIRST_MB /* mb() ordered */ + | READ_LOCK_OUT /* post-dominant */ + | READ_LOCK_NESTED_OUT /* post-dominant */ + | READ_UNLOCK_NESTED_OUT, + READ_PROC_SECOND_MB) -> + smp_mb_reader(i, j); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_SECOND_MB); + + PROCEDURE_READ_UNLOCK(READ_UNLOCK_BASE, + READ_PROC_SECOND_MB /* mb() orders reads */ + | READ_PROC_FIRST_MB /* mb() orders reads */ + | READ_LOCK_NESTED_OUT /* RAW */ + | READ_LOCK_OUT /* RAW */ + | READ_UNLOCK_NESTED_OUT, /* RAW */ + READ_UNLOCK_OUT); + + /* Unrolling loop : second consecutive lock */ + /* reading urcu_active_readers, which have been written by + * READ_UNLOCK_OUT : RAW */ + PROCEDURE_READ_LOCK(READ_LOCK_UNROLL_BASE, + READ_UNLOCK_OUT /* RAW */ + | READ_PROC_SECOND_MB /* mb() orders reads */ + | READ_PROC_FIRST_MB /* mb() orders reads */ + | READ_LOCK_NESTED_OUT /* RAW */ + | READ_LOCK_OUT /* RAW */ + | READ_UNLOCK_NESTED_OUT, /* RAW */ + READ_LOCK_OUT_UNROLL); + + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_PROC_FIRST_MB /* mb() ordered */ + | READ_PROC_SECOND_MB /* mb() ordered */ + | READ_LOCK_OUT_UNROLL /* post-dominant */ + | READ_LOCK_NESTED_OUT + | READ_LOCK_OUT + | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT, + READ_PROC_THIRD_MB) -> + smp_mb_reader(i, j); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_THIRD_MB); + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_PROC_FIRST_MB /* mb() orders reads */ + | READ_PROC_SECOND_MB /* mb() orders reads */ + | READ_PROC_THIRD_MB, /* mb() orders reads */ + READ_PROC_READ_GEN_UNROLL) -> + ooo_mem(i); + ptr_read_second[get_readerid()] = READ_CACHED_VAR(rcu_ptr); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_READ_GEN_UNROLL); + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_PROC_READ_GEN_UNROLL + | READ_PROC_FIRST_MB /* mb() orders reads */ + | READ_PROC_SECOND_MB /* mb() orders reads */ + | READ_PROC_THIRD_MB, /* mb() orders reads */ + READ_PROC_ACCESS_GEN_UNROLL) -> + /* smp_read_barrier_depends */ + goto rmb2; +rmb2_end: + data_read_second[get_readerid()] = + READ_CACHED_VAR(rcu_data[ptr_read_second[get_readerid()]]); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_ACCESS_GEN_UNROLL); + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_PROC_READ_GEN_UNROLL /* mb() orders reads */ + | READ_PROC_ACCESS_GEN_UNROLL /* mb() orders reads */ + | READ_PROC_FIRST_MB /* mb() ordered */ + | READ_PROC_SECOND_MB /* mb() ordered */ + | READ_PROC_THIRD_MB /* mb() ordered */ + | READ_LOCK_OUT_UNROLL /* post-dominant */ + | READ_LOCK_NESTED_OUT + | READ_LOCK_OUT + | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT, + READ_PROC_FOURTH_MB) -> + smp_mb_reader(i, j); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_FOURTH_MB); + + PROCEDURE_READ_UNLOCK(READ_UNLOCK_UNROLL_BASE, + READ_PROC_FOURTH_MB /* mb() orders reads */ + | READ_PROC_THIRD_MB /* mb() orders reads */ + | READ_LOCK_OUT_UNROLL /* RAW */ + | READ_PROC_SECOND_MB /* mb() orders reads */ + | READ_PROC_FIRST_MB /* mb() orders reads */ + | READ_LOCK_NESTED_OUT /* RAW */ + | READ_LOCK_OUT /* RAW */ + | READ_UNLOCK_NESTED_OUT, /* RAW */ + READ_UNLOCK_OUT_UNROLL); + :: CONSUME_TOKENS(proc_urcu_reader, READ_PROC_ALL_TOKENS, 0) -> + CLEAR_TOKENS(proc_urcu_reader, READ_PROC_ALL_TOKENS_CLEAR); + break; + fi; + } + od; + /* + * Dependency between consecutive loops : + * RAW dependency on + * WRITE_CACHED_VAR(urcu_active_readers[get_readerid()], tmp2 - 1) + * tmp = READ_CACHED_VAR(urcu_active_readers[get_readerid()]); + * between loops. + * _WHEN THE MB()s are in place_, they add full ordering of the + * generation pointer read wrt active reader count read, which ensures + * execution will not spill across loop execution. + * However, in the event mb()s are removed (execution using signal + * handler to promote barrier()() -> smp_mb()), nothing prevents one loop + * to spill its execution on other loop's execution. + */ + goto end; +rmb1: +#ifndef NO_RMB + smp_rmb(i); +#else + ooo_mem(i); +#endif + goto rmb1_end; +rmb2: +#ifndef NO_RMB + smp_rmb(i); +#else + ooo_mem(i); +#endif + goto rmb2_end; +end: + skip; +} + + + +active proctype urcu_reader() +{ + byte i, j, nest_i; + byte tmp, tmp2; + + wait_init_done(); + + assert(get_pid() < NR_PROCS); + +end_reader: + do + :: 1 -> + /* + * We do not test reader's progress here, because we are mainly + * interested in writer's progress. The reader never blocks + * anyway. We have to test for reader/writer's progress + * separately, otherwise we could think the writer is doing + * progress when it's blocked by an always progressing reader. + */ +#ifdef READER_PROGRESS +progress_reader: +#endif + urcu_one_read(i, j, nest_i, tmp, tmp2); + od; +} + +/* no name clash please */ +#undef proc_urcu_reader + + +/* Model the RCU update process. */ + +/* + * Bit encoding, urcu_writer : + * Currently only supports one reader. + */ + +int _proc_urcu_writer; +#define proc_urcu_writer _proc_urcu_writer + +#define WRITE_PROD_NONE (1 << 0) + +#define WRITE_DATA (1 << 1) +#define WRITE_PROC_WMB (1 << 2) +#define WRITE_XCHG_PTR (1 << 3) + +#define WRITE_PROC_FIRST_MB (1 << 4) + +/* first flip */ +#define WRITE_PROC_FIRST_READ_GP (1 << 5) +#define WRITE_PROC_FIRST_WRITE_GP (1 << 6) +#define WRITE_PROC_FIRST_WAIT (1 << 7) +#define WRITE_PROC_FIRST_WAIT_LOOP (1 << 8) + +/* second flip */ +#define WRITE_PROC_SECOND_READ_GP (1 << 9) +#define WRITE_PROC_SECOND_WRITE_GP (1 << 10) +#define WRITE_PROC_SECOND_WAIT (1 << 11) +#define WRITE_PROC_SECOND_WAIT_LOOP (1 << 12) + +#define WRITE_PROC_SECOND_MB (1 << 13) + +#define WRITE_FREE (1 << 14) + +#define WRITE_PROC_ALL_TOKENS (WRITE_PROD_NONE \ + | WRITE_DATA \ + | WRITE_PROC_WMB \ + | WRITE_XCHG_PTR \ + | WRITE_PROC_FIRST_MB \ + | WRITE_PROC_FIRST_READ_GP \ + | WRITE_PROC_FIRST_WRITE_GP \ + | WRITE_PROC_FIRST_WAIT \ + | WRITE_PROC_SECOND_READ_GP \ + | WRITE_PROC_SECOND_WRITE_GP \ + | WRITE_PROC_SECOND_WAIT \ + | WRITE_PROC_SECOND_MB \ + | WRITE_FREE) + +#define WRITE_PROC_ALL_TOKENS_CLEAR ((1 << 15) - 1) + +/* + * Mutexes are implied around writer execution. A single writer at a time. + */ +active proctype urcu_writer() +{ + byte i, j; + byte tmp, tmp2, tmpa; + byte cur_data = 0, old_data, loop_nr = 0; + byte cur_gp_val = 0; /* + * Keep a local trace of the current parity so + * we don't add non-existing dependencies on the global + * GP update. Needed to test single flip case. + */ + + wait_init_done(); + + assert(get_pid() < NR_PROCS); + + do + :: (loop_nr < 3) -> +#ifdef WRITER_PROGRESS +progress_writer1: +#endif + loop_nr = loop_nr + 1; + + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROD_NONE); + +#ifdef NO_WMB + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_WMB); +#endif + +#ifdef NO_MB + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_FIRST_MB); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_MB); +#endif + +#ifdef SINGLE_FLIP + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_READ_GP); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_WRITE_GP); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_WAIT); + /* For single flip, we need to know the current parity */ + cur_gp_val = cur_gp_val ^ RCU_GP_CTR_BIT; +#endif + + do :: 1 -> + atomic { + if + + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_PROD_NONE, + WRITE_DATA) -> + ooo_mem(i); + cur_data = (cur_data + 1) % SLAB_SIZE; + WRITE_CACHED_VAR(rcu_data[cur_data], WINE); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_DATA); + + + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_DATA, + WRITE_PROC_WMB) -> + smp_wmb(i); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_WMB); + + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_PROC_WMB, + WRITE_XCHG_PTR) -> + /* rcu_xchg_pointer() */ + atomic { + old_data = READ_CACHED_VAR(rcu_ptr); + WRITE_CACHED_VAR(rcu_ptr, cur_data); + } + PRODUCE_TOKENS(proc_urcu_writer, WRITE_XCHG_PTR); + + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_DATA | WRITE_PROC_WMB | WRITE_XCHG_PTR, + WRITE_PROC_FIRST_MB) -> + goto smp_mb_send1; +smp_mb_send1_end: + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_FIRST_MB); + + /* first flip */ + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_PROC_FIRST_MB, + WRITE_PROC_FIRST_READ_GP) -> + tmpa = READ_CACHED_VAR(urcu_gp_ctr); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_FIRST_READ_GP); + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_PROC_FIRST_MB | WRITE_PROC_WMB + | WRITE_PROC_FIRST_READ_GP, + WRITE_PROC_FIRST_WRITE_GP) -> + ooo_mem(i); + WRITE_CACHED_VAR(urcu_gp_ctr, tmpa ^ RCU_GP_CTR_BIT); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_FIRST_WRITE_GP); + + :: CONSUME_TOKENS(proc_urcu_writer, + //WRITE_PROC_FIRST_WRITE_GP /* TEST ADDING SYNC CORE */ + WRITE_PROC_FIRST_MB, /* can be reordered before/after flips */ + WRITE_PROC_FIRST_WAIT | WRITE_PROC_FIRST_WAIT_LOOP) -> + ooo_mem(i); + /* ONLY WAITING FOR READER 0 */ + tmp2 = READ_CACHED_VAR(urcu_active_readers[0]); +#ifndef SINGLE_FLIP + /* In normal execution, we are always starting by + * waiting for the even parity. + */ + cur_gp_val = RCU_GP_CTR_BIT; +#endif + if + :: (tmp2 & RCU_GP_CTR_NEST_MASK) + && ((tmp2 ^ cur_gp_val) & RCU_GP_CTR_BIT) -> + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_FIRST_WAIT_LOOP); + :: else -> + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_FIRST_WAIT); + fi; + + :: CONSUME_TOKENS(proc_urcu_writer, + //WRITE_PROC_FIRST_WRITE_GP /* TEST ADDING SYNC CORE */ + WRITE_PROC_FIRST_WRITE_GP + | WRITE_PROC_FIRST_READ_GP + | WRITE_PROC_FIRST_WAIT_LOOP + | WRITE_DATA | WRITE_PROC_WMB | WRITE_XCHG_PTR + | WRITE_PROC_FIRST_MB, /* can be reordered before/after flips */ + 0) -> +#ifndef GEN_ERROR_WRITER_PROGRESS + goto smp_mb_send2; +smp_mb_send2_end: +#else + ooo_mem(i); +#endif + /* This instruction loops to WRITE_PROC_FIRST_WAIT */ + CLEAR_TOKENS(proc_urcu_writer, WRITE_PROC_FIRST_WAIT_LOOP | WRITE_PROC_FIRST_WAIT); + + /* second flip */ + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_PROC_FIRST_WAIT /* Control dependency : need to branch out of + * the loop to execute the next flip (CHECK) */ + | WRITE_PROC_FIRST_WRITE_GP + | WRITE_PROC_FIRST_READ_GP + | WRITE_PROC_FIRST_MB, + WRITE_PROC_SECOND_READ_GP) -> + ooo_mem(i); + tmpa = READ_CACHED_VAR(urcu_gp_ctr); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_READ_GP); + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_PROC_FIRST_MB + | WRITE_PROC_WMB + | WRITE_PROC_FIRST_READ_GP + | WRITE_PROC_FIRST_WRITE_GP + | WRITE_PROC_SECOND_READ_GP, + WRITE_PROC_SECOND_WRITE_GP) -> + ooo_mem(i); + WRITE_CACHED_VAR(urcu_gp_ctr, tmpa ^ RCU_GP_CTR_BIT); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_WRITE_GP); + + :: CONSUME_TOKENS(proc_urcu_writer, + //WRITE_PROC_FIRST_WRITE_GP /* TEST ADDING SYNC CORE */ + WRITE_PROC_FIRST_WAIT + | WRITE_PROC_FIRST_MB, /* can be reordered before/after flips */ + WRITE_PROC_SECOND_WAIT | WRITE_PROC_SECOND_WAIT_LOOP) -> + ooo_mem(i); + /* ONLY WAITING FOR READER 0 */ + tmp2 = READ_CACHED_VAR(urcu_active_readers[0]); + if + :: (tmp2 & RCU_GP_CTR_NEST_MASK) + && ((tmp2 ^ 0) & RCU_GP_CTR_BIT) -> + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_WAIT_LOOP); + :: else -> + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_WAIT); + fi; + + :: CONSUME_TOKENS(proc_urcu_writer, + //WRITE_PROC_FIRST_WRITE_GP /* TEST ADDING SYNC CORE */ + WRITE_PROC_SECOND_WRITE_GP + | WRITE_PROC_FIRST_WRITE_GP + | WRITE_PROC_SECOND_READ_GP + | WRITE_PROC_FIRST_READ_GP + | WRITE_PROC_SECOND_WAIT_LOOP + | WRITE_DATA | WRITE_PROC_WMB | WRITE_XCHG_PTR + | WRITE_PROC_FIRST_MB, /* can be reordered before/after flips */ + 0) -> +#ifndef GEN_ERROR_WRITER_PROGRESS + goto smp_mb_send3; +smp_mb_send3_end: +#else + ooo_mem(i); +#endif + /* This instruction loops to WRITE_PROC_SECOND_WAIT */ + CLEAR_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_WAIT_LOOP | WRITE_PROC_SECOND_WAIT); + + + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_PROC_FIRST_WAIT + | WRITE_PROC_SECOND_WAIT + | WRITE_PROC_FIRST_READ_GP + | WRITE_PROC_SECOND_READ_GP + | WRITE_PROC_FIRST_WRITE_GP + | WRITE_PROC_SECOND_WRITE_GP + | WRITE_DATA | WRITE_PROC_WMB | WRITE_XCHG_PTR + | WRITE_PROC_FIRST_MB, + WRITE_PROC_SECOND_MB) -> + goto smp_mb_send4; +smp_mb_send4_end: + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_MB); + + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_XCHG_PTR + | WRITE_PROC_FIRST_WAIT + | WRITE_PROC_SECOND_WAIT + | WRITE_PROC_WMB /* No dependency on + * WRITE_DATA because we + * write to a + * different location. */ + | WRITE_PROC_SECOND_MB + | WRITE_PROC_FIRST_MB, + WRITE_FREE) -> + WRITE_CACHED_VAR(rcu_data[old_data], POISON); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_FREE); + + :: CONSUME_TOKENS(proc_urcu_writer, WRITE_PROC_ALL_TOKENS, 0) -> + CLEAR_TOKENS(proc_urcu_writer, WRITE_PROC_ALL_TOKENS_CLEAR); + break; + fi; + } + od; + /* + * Note : Promela model adds implicit serialization of the + * WRITE_FREE instruction. Normally, it would be permitted to + * spill on the next loop execution. Given the validation we do + * checks for the data entry read to be poisoned, it's ok if + * we do not check "late arriving" memory poisoning. + */ + :: else -> break; + od; + /* + * Given the reader loops infinitely, let the writer also busy-loop + * with progress here so, with weak fairness, we can test the + * writer's progress. + */ +end_writer: + do + :: 1 -> +#ifdef WRITER_PROGRESS +progress_writer2: +#endif +#ifdef READER_PROGRESS + /* + * Make sure we don't block the reader's progress. + */ + smp_mb_send(i, j, 5); +#endif + skip; + od; + + /* Non-atomic parts of the loop */ + goto end; +smp_mb_send1: + smp_mb_send(i, j, 1); + goto smp_mb_send1_end; +#ifndef GEN_ERROR_WRITER_PROGRESS +smp_mb_send2: + smp_mb_send(i, j, 2); + goto smp_mb_send2_end; +smp_mb_send3: + smp_mb_send(i, j, 3); + goto smp_mb_send3_end; +#endif +smp_mb_send4: + smp_mb_send(i, j, 4); + goto smp_mb_send4_end; +end: + skip; +} + +/* no name clash please */ +#undef proc_urcu_writer + + +/* Leave after the readers and writers so the pid count is ok. */ +init { + byte i, j; + + atomic { + INIT_CACHED_VAR(urcu_gp_ctr, 1, j); + INIT_CACHED_VAR(rcu_ptr, 0, j); + + i = 0; + do + :: i < NR_READERS -> + INIT_CACHED_VAR(urcu_active_readers[i], 0, j); + ptr_read_first[i] = 1; + ptr_read_second[i] = 1; + data_read_first[i] = WINE; + data_read_second[i] = WINE; + i++; + :: i >= NR_READERS -> break + od; + INIT_CACHED_VAR(rcu_data[0], WINE, j); + i = 1; + do + :: i < SLAB_SIZE -> + INIT_CACHED_VAR(rcu_data[i], POISON, j); + i++ + :: i >= SLAB_SIZE -> break + od; + + init_done = 1; + } +} diff --git a/formal-model/results/urcu-controldataflow-ipi-intel/urcu_free_no_mb.spin.input.trail b/formal-model/results/urcu-controldataflow-ipi-intel/urcu_free_no_mb.spin.input.trail new file mode 100644 index 0000000..bf64078 --- /dev/null +++ b/formal-model/results/urcu-controldataflow-ipi-intel/urcu_free_no_mb.spin.input.trail @@ -0,0 +1,1304 @@ +-2:3:-2 +-4:-4:-4 +1:0:4181 +2:3:4101 +3:3:4104 +4:3:4104 +5:3:4107 +6:3:4115 +7:3:4115 +8:3:4118 +9:3:4124 +10:3:4128 +11:3:4128 +12:3:4131 +13:3:4141 +14:3:4149 +15:3:4149 +16:3:4152 +17:3:4158 +18:3:4162 +19:3:4162 +20:3:4165 +21:3:4171 +22:3:4175 +23:3:4176 +24:0:4181 +25:3:4178 +26:0:4181 +27:2:2515 +28:0:4181 +29:2:2521 +30:0:4181 +31:2:2522 +32:0:4181 +33:2:2524 +34:0:4181 +35:2:2525 +36:0:4181 +37:2:2526 +38:0:4181 +39:2:2527 +40:0:4181 +41:2:2528 +42:2:2529 +43:2:2533 +44:2:2534 +45:2:2542 +46:2:2543 +47:2:2547 +48:2:2548 +49:2:2556 +50:2:2561 +51:2:2565 +52:2:2566 +53:2:2574 +54:2:2575 +55:2:2579 +56:2:2580 +57:2:2574 +58:2:2575 +59:2:2579 +60:2:2580 +61:2:2588 +62:2:2593 +63:2:2600 +64:2:2601 +65:2:2608 +66:2:2613 +67:2:2620 +68:2:2621 +69:2:2620 +70:2:2621 +71:2:2628 +72:2:2638 +73:0:4181 +74:2:2527 +75:0:4181 +76:2:2642 +77:2:2646 +78:2:2647 +79:2:2651 +80:2:2655 +81:2:2656 +82:2:2660 +83:2:2668 +84:2:2669 +85:2:2673 +86:2:2677 +87:2:2678 +88:2:2673 +89:2:2674 +90:2:2682 +91:0:4181 +92:2:2527 +93:0:4181 +94:2:2690 +95:2:2691 +96:2:2692 +97:0:4181 +98:2:2527 +99:0:4181 +100:2:2700 +101:0:4181 +102:2:2527 +103:0:4181 +104:2:2703 +105:2:2704 +106:2:2708 +107:2:2709 +108:2:2717 +109:2:2718 +110:2:2722 +111:2:2723 +112:2:2731 +113:2:2736 +114:2:2737 +115:2:2749 +116:2:2750 +117:2:2754 +118:2:2755 +119:2:2749 +120:2:2750 +121:2:2754 +122:2:2755 +123:2:2763 +124:2:2768 +125:2:2775 +126:2:2776 +127:2:2783 +128:2:2788 +129:2:2795 +130:2:2796 +131:2:2795 +132:2:2796 +133:2:2803 +134:2:2812 +135:0:4181 +136:2:2527 +137:0:4181 +138:2:2816 +139:2:2817 +140:2:2818 +141:2:2830 +142:2:2831 +143:2:2835 +144:2:2836 +145:2:2844 +146:2:2849 +147:2:2853 +148:2:2854 +149:2:2862 +150:2:2863 +151:2:2867 +152:2:2868 +153:2:2862 +154:2:2863 +155:2:2867 +156:2:2868 +157:2:2876 +158:2:2881 +159:2:2888 +160:2:2889 +161:2:2896 +162:2:2901 +163:2:2908 +164:2:2909 +165:2:2908 +166:2:2909 +167:2:2916 +168:2:2929 +169:2:2930 +170:0:4181 +171:2:2527 +172:0:4181 +173:2:2936 +174:2:2937 +175:2:2941 +176:2:2942 +177:2:2950 +178:2:2951 +179:2:2955 +180:2:2956 +181:2:2964 +182:2:2969 +183:2:2973 +184:2:2974 +185:2:2982 +186:2:2983 +187:2:2987 +188:2:2988 +189:2:2982 +190:2:2983 +191:2:2987 +192:2:2988 +193:2:2996 +194:2:3001 +195:2:3008 +196:2:3009 +197:2:3016 +198:2:3021 +199:2:3028 +200:2:3029 +201:2:3028 +202:2:3029 +203:2:3036 +204:0:4181 +205:2:2527 +206:0:4181 +207:2:3047 +208:2:3048 +209:2:3052 +210:2:3053 +211:2:3061 +212:2:3062 +213:2:3066 +214:2:3067 +215:2:3075 +216:2:3080 +217:2:3084 +218:2:3085 +219:2:3093 +220:2:3094 +221:2:3098 +222:2:3099 +223:2:3093 +224:2:3094 +225:2:3098 +226:2:3099 +227:2:3107 +228:2:3112 +229:2:3119 +230:2:3120 +231:2:3127 +232:2:3132 +233:2:3139 +234:2:3140 +235:2:3139 +236:2:3140 +237:2:3147 +238:2:3156 +239:0:4181 +240:2:2527 +241:0:4181 +242:2:3160 +243:2:3161 +244:2:3162 +245:2:3174 +246:2:3175 +247:2:3179 +248:2:3180 +249:2:3188 +250:2:3193 +251:2:3197 +252:2:3198 +253:2:3206 +254:2:3207 +255:2:3211 +256:2:3212 +257:2:3206 +258:2:3207 +259:2:3211 +260:2:3212 +261:2:3220 +262:2:3225 +263:2:3232 +264:2:3233 +265:2:3240 +266:2:3245 +267:2:3252 +268:2:3253 +269:2:3252 +270:2:3253 +271:2:3260 +272:2:3272 +273:2:3273 +274:0:4181 +275:2:2527 +276:0:4181 +277:2:3282 +278:2:3283 +279:0:4181 +280:2:2527 +281:0:4181 +282:2:3287 +283:0:4181 +284:2:3295 +285:0:4181 +286:2:2522 +287:0:4181 +288:2:2524 +289:0:4181 +290:2:2525 +291:0:4181 +292:2:2526 +293:0:4181 +294:2:2527 +295:0:4181 +296:2:2528 +297:2:2529 +298:2:2533 +299:2:2534 +300:2:2542 +301:2:2543 +302:2:2547 +303:2:2548 +304:2:2556 +305:2:2561 +306:2:2565 +307:2:2566 +308:2:2574 +309:2:2575 +310:2:2576 +311:2:2574 +312:2:2575 +313:2:2579 +314:2:2580 +315:2:2588 +316:2:2593 +317:2:2600 +318:2:2601 +319:2:2608 +320:2:2613 +321:2:2620 +322:2:2621 +323:2:2620 +324:2:2621 +325:2:2628 +326:2:2638 +327:0:4181 +328:2:2527 +329:0:4181 +330:2:2642 +331:2:2646 +332:2:2647 +333:2:2651 +334:2:2655 +335:2:2656 +336:2:2660 +337:2:2668 +338:2:2669 +339:2:2673 +340:2:2674 +341:2:2673 +342:2:2677 +343:2:2678 +344:2:2682 +345:0:4181 +346:2:2527 +347:0:4181 +348:2:2690 +349:2:2691 +350:2:2692 +351:0:4181 +352:2:2527 +353:0:4181 +354:2:2700 +355:0:4181 +356:2:2527 +357:0:4181 +358:2:2703 +359:2:2704 +360:2:2708 +361:2:2709 +362:2:2717 +363:2:2718 +364:2:2722 +365:2:2723 +366:2:2731 +367:2:2736 +368:2:2737 +369:2:2749 +370:2:2750 +371:2:2754 +372:2:2755 +373:2:2749 +374:2:2750 +375:2:2754 +376:2:2755 +377:2:2763 +378:2:2768 +379:2:2775 +380:2:2776 +381:2:2783 +382:2:2788 +383:2:2795 +384:2:2796 +385:2:2795 +386:2:2796 +387:2:2803 +388:2:2812 +389:0:4181 +390:2:2527 +391:0:4181 +392:2:2816 +393:2:2817 +394:2:2818 +395:2:2830 +396:2:2831 +397:2:2835 +398:2:2836 +399:2:2844 +400:2:2849 +401:2:2853 +402:2:2854 +403:2:2862 +404:2:2863 +405:2:2867 +406:2:2868 +407:2:2862 +408:2:2863 +409:2:2867 +410:2:2868 +411:2:2876 +412:2:2881 +413:2:2888 +414:2:2889 +415:2:2896 +416:2:2901 +417:2:2908 +418:2:2909 +419:2:2908 +420:2:2909 +421:2:2916 +422:2:2929 +423:2:2930 +424:0:4181 +425:2:2527 +426:0:4181 +427:2:2936 +428:2:2937 +429:2:2941 +430:2:2942 +431:2:2950 +432:2:2951 +433:2:2955 +434:2:2956 +435:2:2964 +436:2:2969 +437:2:2973 +438:2:2974 +439:2:2982 +440:2:2983 +441:2:2987 +442:2:2988 +443:2:2982 +444:2:2983 +445:2:2987 +446:2:2988 +447:2:2996 +448:2:3001 +449:2:3008 +450:2:3009 +451:2:3016 +452:2:3021 +453:2:3028 +454:2:3029 +455:2:3028 +456:2:3029 +457:2:3036 +458:0:4181 +459:2:2527 +460:0:4181 +461:2:3047 +462:2:3048 +463:2:3052 +464:2:3053 +465:2:3061 +466:2:3062 +467:2:3066 +468:2:3067 +469:2:3075 +470:2:3080 +471:2:3084 +472:2:3085 +473:2:3093 +474:2:3094 +475:2:3098 +476:2:3099 +477:2:3093 +478:2:3094 +479:2:3098 +480:2:3099 +481:2:3107 +482:2:3112 +483:2:3119 +484:2:3120 +485:2:3127 +486:2:3132 +487:2:3139 +488:2:3140 +489:2:3139 +490:2:3140 +491:2:3147 +492:2:3156 +493:0:4181 +494:2:2527 +495:0:4181 +496:2:3160 +497:2:3161 +498:2:3162 +499:2:3174 +500:2:3175 +501:2:3179 +502:2:3180 +503:2:3188 +504:2:3193 +505:2:3197 +506:2:3198 +507:2:3206 +508:2:3207 +509:2:3211 +510:2:3212 +511:2:3206 +512:2:3207 +513:2:3211 +514:2:3212 +515:2:3220 +516:2:3225 +517:2:3232 +518:2:3233 +519:2:3240 +520:2:3245 +521:2:3252 +522:2:3253 +523:2:3252 +524:2:3253 +525:2:3260 +526:2:3272 +527:2:3273 +528:0:4181 +529:2:2527 +530:0:4181 +531:2:3282 +532:2:3283 +533:0:4181 +534:2:2527 +535:0:4181 +536:2:3287 +537:0:4181 +538:2:3295 +539:0:4181 +540:2:2522 +541:0:4181 +542:2:2524 +543:0:4181 +544:2:2525 +545:0:4181 +546:2:2526 +547:0:4181 +548:2:2527 +549:0:4181 +550:2:2528 +551:2:2529 +552:2:2533 +553:2:2534 +554:2:2542 +555:2:2543 +556:2:2547 +557:2:2548 +558:2:2556 +559:2:2561 +560:2:2565 +561:2:2566 +562:2:2574 +563:2:2575 +564:2:2579 +565:2:2580 +566:2:2574 +567:2:2575 +568:2:2576 +569:2:2588 +570:2:2593 +571:2:2600 +572:2:2601 +573:2:2608 +574:2:2613 +575:2:2620 +576:2:2621 +577:2:2620 +578:2:2621 +579:2:2628 +580:2:2638 +581:0:4181 +582:2:2527 +583:0:4181 +584:2:2642 +585:2:2646 +586:2:2647 +587:2:2651 +588:2:2655 +589:2:2656 +590:2:2660 +591:2:2668 +592:2:2669 +593:2:2673 +594:2:2677 +595:2:2678 +596:2:2673 +597:2:2674 +598:2:2682 +599:0:4181 +600:2:2527 +601:0:4181 +602:2:2690 +603:2:2691 +604:2:2692 +605:0:4181 +606:2:2527 +607:0:4181 +608:2:2700 +609:0:4181 +610:2:2527 +611:0:4181 +612:2:2703 +613:2:2704 +614:2:2708 +615:2:2709 +616:2:2717 +617:2:2718 +618:2:2722 +619:2:2723 +620:2:2731 +621:2:2744 +622:2:2745 +623:2:2749 +624:2:2750 +625:2:2754 +626:2:2755 +627:2:2749 +628:2:2750 +629:2:2754 +630:2:2755 +631:2:2763 +632:2:2768 +633:2:2775 +634:2:2776 +635:2:2783 +636:2:2790 +637:2:2791 +638:2:2795 +639:2:2796 +640:2:2795 +641:2:2796 +642:2:2803 +643:2:2812 +644:0:4181 +645:2:2527 +646:0:4181 +647:2:2816 +648:2:2817 +649:2:2818 +650:2:2830 +651:2:2831 +652:2:2835 +653:2:2836 +654:2:2844 +655:2:2857 +656:2:2858 +657:2:2862 +658:2:2863 +659:2:2867 +660:2:2868 +661:2:2862 +662:2:2863 +663:2:2867 +664:2:2868 +665:2:2876 +666:2:2881 +667:2:2888 +668:2:2889 +669:2:2896 +670:2:2903 +671:2:2904 +672:2:2908 +673:2:2909 +674:2:2908 +675:2:2909 +676:2:2916 +677:2:2929 +678:2:2930 +679:0:4181 +680:2:2527 +681:0:4181 +682:2:2936 +683:2:2937 +684:2:2941 +685:2:2942 +686:2:2950 +687:2:2951 +688:2:2955 +689:2:2956 +690:2:2964 +691:2:2977 +692:2:2978 +693:2:2982 +694:2:2983 +695:2:2987 +696:2:2988 +697:2:2982 +698:2:2983 +699:2:2987 +700:2:2988 +701:2:2996 +702:2:3001 +703:2:3008 +704:2:3009 +705:2:3016 +706:2:3023 +707:2:3024 +708:2:3028 +709:2:3029 +710:2:3028 +711:2:3029 +712:2:3036 +713:0:4181 +714:2:2527 +715:0:4181 +716:2:3160 +717:2:3161 +718:2:3165 +719:2:3166 +720:2:3174 +721:2:3175 +722:2:3179 +723:2:3180 +724:2:3188 +725:2:3201 +726:2:3202 +727:2:3206 +728:2:3207 +729:2:3211 +730:2:3212 +731:2:3206 +732:2:3207 +733:2:3211 +734:2:3212 +735:2:3220 +736:2:3225 +737:2:3232 +738:2:3233 +739:2:3240 +740:2:3247 +741:2:3248 +742:2:3252 +743:2:3253 +744:2:3252 +745:2:3253 +746:2:3260 +747:2:3272 +748:2:3273 +749:0:4181 +750:2:2527 +751:0:4181 +752:2:3282 +753:2:3283 +754:0:4181 +755:2:2527 +756:0:4181 +757:2:3047 +758:2:3048 +759:2:3052 +760:2:3053 +761:2:3061 +762:2:3062 +763:2:3066 +764:2:3067 +765:2:3075 +766:2:3088 +767:2:3089 +768:2:3093 +769:2:3094 +770:2:3095 +771:2:3093 +772:2:3094 +773:2:3098 +774:2:3099 +775:2:3107 +776:2:3112 +777:2:3119 +778:2:3120 +779:2:3127 +780:2:3134 +781:2:3135 +782:2:3139 +783:2:3140 +784:2:3139 +785:2:3140 +786:2:3147 +787:2:3156 +788:0:4181 +789:2:2527 +790:0:4181 +791:2:3287 +792:0:4181 +793:2:3295 +794:0:4181 +795:2:3296 +796:0:4181 +797:2:3301 +798:0:4181 +799:1:2 +800:0:4181 +801:2:3302 +802:0:4181 +803:1:8 +804:0:4181 +805:2:3301 +806:0:4181 +807:1:9 +808:0:4181 +809:2:3302 +810:0:4181 +811:1:10 +812:0:4181 +813:2:3301 +814:0:4181 +815:1:11 +816:0:4181 +817:2:3302 +818:0:4181 +819:1:12 +820:0:4181 +821:2:3301 +822:0:4181 +823:1:13 +824:0:4181 +825:2:3302 +826:0:4181 +827:1:14 +828:0:4181 +829:2:3301 +830:0:4181 +831:1:15 +832:0:4181 +833:2:3302 +834:0:4181 +835:1:16 +836:0:4181 +837:2:3301 +838:0:4181 +839:1:17 +840:0:4181 +841:2:3302 +842:0:4181 +843:1:18 +844:0:4181 +845:2:3301 +846:0:4181 +847:1:19 +848:0:4181 +849:2:3302 +850:0:4181 +851:1:20 +852:0:4181 +853:2:3301 +854:0:4181 +855:1:21 +856:0:4181 +857:2:3302 +858:0:4181 +859:1:122 +860:0:4181 +861:2:3301 +862:0:4181 +863:1:124 +864:0:4181 +865:2:3302 +866:0:4181 +867:1:23 +868:0:4181 +869:2:3301 +870:0:4181 +871:1:130 +872:1:131 +873:1:135 +874:1:136 +875:1:144 +876:1:145 +877:1:149 +878:1:150 +879:1:158 +880:1:163 +881:1:167 +882:1:168 +883:1:176 +884:1:177 +885:1:181 +886:1:182 +887:1:176 +888:1:177 +889:1:181 +890:1:182 +891:1:190 +892:1:195 +893:1:202 +894:1:203 +895:1:210 +896:1:215 +897:1:222 +898:1:223 +899:1:222 +900:1:223 +901:1:230 +902:0:4181 +903:2:3302 +904:0:4181 +905:1:19 +906:0:4181 +907:2:3301 +908:0:4181 +909:1:20 +910:0:4181 +911:2:3302 +912:0:4181 +913:1:21 +914:0:4181 +915:2:3301 +916:0:4181 +917:1:122 +918:0:4181 +919:2:3302 +920:0:4181 +921:1:124 +922:0:4181 +923:2:3301 +924:0:4181 +925:1:23 +926:0:4181 +927:2:3302 +928:0:4181 +929:1:241 +930:1:242 +931:0:4181 +932:2:3301 +933:0:4181 +934:1:19 +935:0:4181 +936:2:3302 +937:0:4181 +938:1:20 +939:0:4181 +940:2:3301 +941:0:4181 +942:1:21 +943:0:4181 +944:2:3302 +945:0:4181 +946:1:122 +947:0:4181 +948:2:3301 +949:0:4181 +950:1:124 +951:0:4181 +952:2:3302 +953:0:4181 +954:1:23 +955:0:4181 +956:2:3301 +957:0:4181 +958:1:248 +959:1:249 +960:1:253 +961:1:254 +962:1:262 +963:1:263 +964:1:267 +965:1:268 +966:1:276 +967:1:281 +968:1:285 +969:1:286 +970:1:294 +971:1:295 +972:1:299 +973:1:300 +974:1:294 +975:1:295 +976:1:299 +977:1:300 +978:1:308 +979:1:313 +980:1:320 +981:1:321 +982:1:328 +983:1:333 +984:1:340 +985:1:341 +986:1:340 +987:1:341 +988:1:348 +989:0:4181 +990:2:3302 +991:0:4181 +992:1:19 +993:0:4181 +994:2:3301 +995:0:4181 +996:1:20 +997:0:4181 +998:2:3302 +999:0:4181 +1000:1:21 +1001:0:4181 +1002:2:3301 +1003:0:4181 +1004:1:122 +1005:0:4181 +1006:2:3302 +1007:0:4181 +1008:1:124 +1009:0:4181 +1010:2:3301 +1011:0:4181 +1012:1:23 +1013:0:4181 +1014:2:3302 +1015:0:4181 +1016:1:359 +1017:1:360 +1018:1:364 +1019:1:365 +1020:1:373 +1021:1:374 +1022:1:378 +1023:1:379 +1024:1:387 +1025:1:392 +1026:1:396 +1027:1:397 +1028:1:405 +1029:1:406 +1030:1:410 +1031:1:411 +1032:1:405 +1033:1:406 +1034:1:410 +1035:1:411 +1036:1:419 +1037:1:424 +1038:1:431 +1039:1:432 +1040:1:439 +1041:1:444 +1042:1:451 +1043:1:452 +1044:1:451 +1045:1:452 +1046:1:459 +1047:1:468 +1048:0:4181 +1049:2:3301 +1050:0:4181 +1051:1:19 +1052:0:4181 +1053:2:3302 +1054:0:4181 +1055:1:20 +1056:0:4181 +1057:2:3301 +1058:0:4181 +1059:1:21 +1060:0:4181 +1061:2:3302 +1062:0:4181 +1063:1:122 +1064:0:4181 +1065:2:3301 +1066:0:4181 +1067:1:124 +1068:0:4181 +1069:2:3302 +1070:0:4181 +1071:1:23 +1072:0:4181 +1073:2:3301 +1074:0:4181 +1075:1:588 +1076:1:589 +1077:1:593 +1078:1:594 +1079:1:602 +1080:1:603 +1081:1:604 +1082:1:616 +1083:1:621 +1084:1:625 +1085:1:626 +1086:1:634 +1087:1:635 +1088:1:639 +1089:1:640 +1090:1:634 +1091:1:635 +1092:1:639 +1093:1:640 +1094:1:648 +1095:1:653 +1096:1:660 +1097:1:661 +1098:1:668 +1099:1:673 +1100:1:680 +1101:1:681 +1102:1:680 +1103:1:681 +1104:1:688 +1105:0:4181 +1106:2:3302 +1107:0:4181 +1108:1:19 +1109:0:4181 +1110:2:3301 +1111:0:4181 +1112:1:20 +1113:0:4181 +1114:2:3302 +1115:0:4181 +1116:1:21 +1117:0:4181 +1118:2:3301 +1119:0:4181 +1120:1:122 +1121:0:4181 +1122:2:3302 +1123:0:4181 +1124:1:124 +1125:0:4181 +1126:2:3301 +1127:0:4181 +1128:1:23 +1129:0:4181 +1130:2:3302 +1131:0:4181 +1132:1:699 +1133:1:702 +1134:1:703 +1135:0:4181 +1136:2:3301 +1137:0:4181 +1138:1:19 +1139:0:4181 +1140:2:3302 +1141:0:4181 +1142:1:20 +1143:0:4181 +1144:2:3301 +1145:0:4181 +1146:1:21 +1147:0:4181 +1148:2:3302 +1149:0:4181 +1150:1:122 +1151:0:4181 +1152:2:3301 +1153:0:4181 +1154:1:124 +1155:0:4181 +1156:2:3302 +1157:0:4181 +1158:1:23 +1159:0:4181 +1160:2:3301 +1161:0:4181 +1162:1:930 +1163:1:931 +1164:1:935 +1165:1:936 +1166:1:944 +1167:1:945 +1168:1:949 +1169:1:950 +1170:1:958 +1171:1:963 +1172:1:967 +1173:1:968 +1174:1:976 +1175:1:977 +1176:1:981 +1177:1:982 +1178:1:976 +1179:1:977 +1180:1:981 +1181:1:982 +1182:1:990 +1183:1:995 +1184:1:1002 +1185:1:1003 +1186:1:1010 +1187:1:1015 +1188:1:1022 +1189:1:1023 +1190:1:1022 +1191:1:1023 +1192:1:1030 +1193:1:1039 +1194:1:1043 +1195:0:4181 +1196:2:3302 +1197:0:4181 +1198:1:19 +1199:0:4181 +1200:2:3301 +1201:0:4181 +1202:1:20 +1203:0:4181 +1204:2:3302 +1205:0:4181 +1206:1:21 +1207:0:4181 +1208:2:3301 +1209:0:4181 +1210:1:122 +1211:0:4181 +1212:2:3302 +1213:0:4181 +1214:1:124 +1215:0:4181 +1216:2:3301 +1217:0:4181 +1218:1:23 +1219:0:4181 +1220:2:3302 +1221:0:4181 +1222:1:1044 +1223:1:1045 +1224:1:1049 +1225:1:1050 +1226:1:1058 +1227:1:1059 +1228:1:1060 +1229:1:1072 +1230:1:1077 +1231:1:1081 +1232:1:1082 +1233:1:1090 +1234:1:1091 +1235:1:1095 +1236:1:1096 +1237:1:1090 +1238:1:1091 +1239:1:1095 +1240:1:1096 +1241:1:1104 +1242:1:1109 +1243:1:1116 +1244:1:1117 +1245:1:1124 +1246:1:1129 +1247:1:1136 +1248:1:1137 +1249:1:1136 +1250:1:1137 +1251:1:1144 +1252:0:4181 +1253:2:3301 +1254:0:4181 +1255:1:19 +1256:0:4181 +1257:2:3302 +1258:0:4181 +1259:1:20 +1260:0:4181 +1261:2:3301 +1262:0:4181 +1263:1:21 +1264:0:4181 +1265:2:3302 +1266:0:4181 +1267:1:122 +1268:0:4181 +1269:2:3301 +1270:0:4181 +1271:1:124 +1272:0:4181 +1273:2:3302 +1274:0:4181 +1275:1:23 +1276:0:4181 +1277:2:3301 +1278:0:4181 +1279:1:1155 +1280:0:4181 +1281:2:3302 +1282:0:4181 +1283:1:2421 +1284:1:2428 +1285:1:2429 +1286:1:2436 +1287:1:2441 +1288:1:2448 +1289:1:2449 +1290:1:2448 +1291:1:2449 +1292:1:2456 +1293:1:2460 +1294:0:4181 +1295:2:3301 +1296:0:4181 +1297:1:1157 +1298:1:1158 +1299:0:4179 +1300:2:3302 +1301:0:4185 +1302:1:2110 diff --git a/formal-model/results/urcu-controldataflow-ipi-intel/urcu_free_no_rmb.define b/formal-model/results/urcu-controldataflow-ipi-intel/urcu_free_no_rmb.define new file mode 100644 index 0000000..73e61a4 --- /dev/null +++ b/formal-model/results/urcu-controldataflow-ipi-intel/urcu_free_no_rmb.define @@ -0,0 +1 @@ +#define NO_RMB diff --git a/formal-model/results/urcu-controldataflow-ipi-intel/urcu_free_no_rmb.log b/formal-model/results/urcu-controldataflow-ipi-intel/urcu_free_no_rmb.log new file mode 100644 index 0000000..5bfb772 --- /dev/null +++ b/formal-model/results/urcu-controldataflow-ipi-intel/urcu_free_no_rmb.log @@ -0,0 +1,491 @@ +make[1]: Entering directory `/home/compudj/doc/userspace-rcu/formal-model/urcu-controldataflow' +rm -f pan* trail.out .input.spin* *.spin.trail .input.define +touch .input.define +cat .input.define >> pan.ltl +cat DEFINES >> pan.ltl +spin -f "!(`cat urcu_free.ltl | grep -v ^//`)" >> pan.ltl +cp urcu_free_no_rmb.define .input.define +cat .input.define > .input.spin +cat DEFINES >> .input.spin +cat urcu.spin >> .input.spin +rm -f .input.spin.trail +spin -a -X -N pan.ltl .input.spin +Exit-Status 0 +gcc -O2 -w -DHASH64 -o pan pan.c +./pan -a -v -c1 -X -m10000000 -w20 +warning: for p.o. reduction to be valid the never claim must be stutter-invariant +(never claims generated from LTL formulae are stutter-invariant) +depth 0: Claim reached state 5 (line 1272) +Depth= 6905 States= 1e+06 Transitions= 6.24e+06 Memory= 550.432 t= 16.2 R= 6e+04 +Depth= 6905 States= 2e+06 Transitions= 1.71e+07 Memory= 634.318 t= 47.8 R= 4e+04 +Depth= 6905 States= 3e+06 Transitions= 3.39e+07 Memory= 718.303 t= 99.2 R= 3e+04 +pan: resizing hashtable to -w22.. done +Depth= 6905 States= 4e+06 Transitions= 4.47e+07 Memory= 833.311 t= 131 R= 3e+04 +Depth= 6905 States= 5e+06 Transitions= 5.38e+07 Memory= 917.295 t= 157 R= 3e+04 +Depth= 6905 States= 6e+06 Transitions= 6.2e+07 Memory= 1001.279 t= 180 R= 3e+04 +Depth= 6905 States= 7e+06 Transitions= 7.38e+07 Memory= 1085.264 t= 214 R= 3e+04 +Depth= 6905 States= 8e+06 Transitions= 8.99e+07 Memory= 1169.151 t= 264 R= 3e+04 +Depth= 6905 States= 9e+06 Transitions= 1.01e+08 Memory= 1253.135 t= 297 R= 3e+04 +pan: resizing hashtable to -w24.. done +Depth= 6905 States= 1e+07 Transitions= 1.11e+08 Memory= 1461.115 t= 325 R= 3e+04 +Depth= 6905 States= 1.1e+07 Transitions= 1.18e+08 Memory= 1545.100 t= 347 R= 3e+04 +Depth= 6905 States= 1.2e+07 Transitions= 1.31e+08 Memory= 1629.084 t= 383 R= 3e+04 + +(Spin Version 5.1.7 -- 23 December 2008) + + Partial Order Reduction + +Full statespace search for: + never claim + + assertion violations + (if within scope of claim) + acceptance cycles + (fairness disabled) + invalid end states - (disabled by never claim) + +State-vector 88 byte, depth reached 6905, errors: 0 + 12145921 states, stored +1.2049274e+08 states, matched +1.3263866e+08 transitions (= stored+matched) +2.0136766e+09 atomic steps +hash conflicts: 1.0176788e+08 (resolved) + +Stats on memory usage (in Megabytes): + 1343.657 equivalent memory usage for states (stored*(State-vector + overhead)) + 1056.279 actual memory usage for states (compression: 78.61%) + state-vector as stored = 63 byte + 28 byte overhead + 128.000 memory used for hash table (-w24) + 457.764 memory used for DFS stack (-m10000000) + 1641.389 total actual memory usage + +unreached in proctype urcu_reader + line 262, "pan.___", state 30, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 270, "pan.___", state 52, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 274, "pan.___", state 61, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 77, "(1)" + line 243, "pan.___", state 85, "(1)" + line 247, "pan.___", state 97, "(1)" + line 251, "pan.___", state 105, "(1)" + line 401, "pan.___", state 131, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 163, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 177, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 195, "(1)" + line 247, "pan.___", state 215, "(1)" + line 251, "pan.___", state 223, "(1)" + line 680, "pan.___", state 242, "_proc_urcu_reader = (_proc_urcu_reader|((1<<2)<<1))" + line 401, "pan.___", state 249, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 281, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 295, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 313, "(1)" + line 247, "pan.___", state 333, "(1)" + line 251, "pan.___", state 341, "(1)" + line 401, "pan.___", state 360, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 392, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 406, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 424, "(1)" + line 247, "pan.___", state 444, "(1)" + line 251, "pan.___", state 452, "(1)" + line 401, "pan.___", state 473, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 401, "pan.___", state 475, "(1)" + line 401, "pan.___", state 476, "((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid)))" + line 401, "pan.___", state 476, "else" + line 401, "pan.___", state 479, "(1)" + line 405, "pan.___", state 487, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 405, "pan.___", state 489, "(1)" + line 405, "pan.___", state 490, "((cache_dirty_urcu_active_readers.bitfield&(1<<_pid)))" + line 405, "pan.___", state 490, "else" + line 405, "pan.___", state 493, "(1)" + line 405, "pan.___", state 494, "(1)" + line 405, "pan.___", state 494, "(1)" + line 403, "pan.___", state 499, "((i<1))" + line 403, "pan.___", state 499, "((i>=1))" + line 410, "pan.___", state 505, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 507, "(1)" + line 410, "pan.___", state 508, "((cache_dirty_rcu_ptr.bitfield&(1<<_pid)))" + line 410, "pan.___", state 508, "else" + line 410, "pan.___", state 511, "(1)" + line 410, "pan.___", state 512, "(1)" + line 410, "pan.___", state 512, "(1)" + line 414, "pan.___", state 519, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 414, "pan.___", state 521, "(1)" + line 414, "pan.___", state 522, "((cache_dirty_rcu_data[i].bitfield&(1<<_pid)))" + line 414, "pan.___", state 522, "else" + line 414, "pan.___", state 525, "(1)" + line 414, "pan.___", state 526, "(1)" + line 414, "pan.___", state 526, "(1)" + line 412, "pan.___", state 531, "((i<2))" + line 412, "pan.___", state 531, "((i>=2))" + line 239, "pan.___", state 537, "(1)" + line 243, "pan.___", state 545, "(1)" + line 243, "pan.___", state 546, "(!((cache_dirty_urcu_active_readers.bitfield&(1<<_pid))))" + line 243, "pan.___", state 546, "else" + line 241, "pan.___", state 551, "((i<1))" + line 241, "pan.___", state 551, "((i>=1))" + line 247, "pan.___", state 557, "(1)" + line 247, "pan.___", state 558, "(!((cache_dirty_rcu_ptr.bitfield&(1<<_pid))))" + line 247, "pan.___", state 558, "else" + line 251, "pan.___", state 565, "(1)" + line 251, "pan.___", state 566, "(!((cache_dirty_rcu_data[i].bitfield&(1<<_pid))))" + line 251, "pan.___", state 566, "else" + line 249, "pan.___", state 571, "((i<2))" + line 249, "pan.___", state 571, "((i>=2))" + line 256, "pan.___", state 575, "(!((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid))))" + line 256, "pan.___", state 575, "else" + line 421, "pan.___", state 577, "(1)" + line 421, "pan.___", state 577, "(1)" + line 680, "pan.___", state 580, "cached_urcu_active_readers.val[_pid] = (tmp+1)" + line 680, "pan.___", state 581, "_proc_urcu_reader = (_proc_urcu_reader|(1<<5))" + line 680, "pan.___", state 582, "(1)" + line 401, "pan.___", state 589, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 621, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 635, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 653, "(1)" + line 247, "pan.___", state 673, "(1)" + line 251, "pan.___", state 681, "(1)" + line 401, "pan.___", state 707, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 401, "pan.___", state 709, "(1)" + line 401, "pan.___", state 710, "((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid)))" + line 401, "pan.___", state 710, "else" + line 401, "pan.___", state 713, "(1)" + line 405, "pan.___", state 721, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 405, "pan.___", state 723, "(1)" + line 405, "pan.___", state 724, "((cache_dirty_urcu_active_readers.bitfield&(1<<_pid)))" + line 405, "pan.___", state 724, "else" + line 405, "pan.___", state 727, "(1)" + line 405, "pan.___", state 728, "(1)" + line 405, "pan.___", state 728, "(1)" + line 403, "pan.___", state 733, "((i<1))" + line 403, "pan.___", state 733, "((i>=1))" + line 410, "pan.___", state 739, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 741, "(1)" + line 410, "pan.___", state 742, "((cache_dirty_rcu_ptr.bitfield&(1<<_pid)))" + line 410, "pan.___", state 742, "else" + line 410, "pan.___", state 745, "(1)" + line 410, "pan.___", state 746, "(1)" + line 410, "pan.___", state 746, "(1)" + line 414, "pan.___", state 753, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 414, "pan.___", state 755, "(1)" + line 414, "pan.___", state 756, "((cache_dirty_rcu_data[i].bitfield&(1<<_pid)))" + line 414, "pan.___", state 756, "else" + line 414, "pan.___", state 759, "(1)" + line 414, "pan.___", state 760, "(1)" + line 414, "pan.___", state 760, "(1)" + line 412, "pan.___", state 765, "((i<2))" + line 412, "pan.___", state 765, "((i>=2))" + line 239, "pan.___", state 771, "(1)" + line 243, "pan.___", state 779, "(1)" + line 243, "pan.___", state 780, "(!((cache_dirty_urcu_active_readers.bitfield&(1<<_pid))))" + line 243, "pan.___", state 780, "else" + line 241, "pan.___", state 785, "((i<1))" + line 241, "pan.___", state 785, "((i>=1))" + line 247, "pan.___", state 791, "(1)" + line 247, "pan.___", state 792, "(!((cache_dirty_rcu_ptr.bitfield&(1<<_pid))))" + line 247, "pan.___", state 792, "else" + line 251, "pan.___", state 799, "(1)" + line 251, "pan.___", state 800, "(!((cache_dirty_rcu_data[i].bitfield&(1<<_pid))))" + line 251, "pan.___", state 800, "else" + line 256, "pan.___", state 809, "(!((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid))))" + line 256, "pan.___", state 809, "else" + line 421, "pan.___", state 811, "(1)" + line 421, "pan.___", state 811, "(1)" + line 401, "pan.___", state 818, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 401, "pan.___", state 820, "(1)" + line 401, "pan.___", state 821, "((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid)))" + line 401, "pan.___", state 821, "else" + line 401, "pan.___", state 824, "(1)" + line 405, "pan.___", state 832, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 405, "pan.___", state 834, "(1)" + line 405, "pan.___", state 835, "((cache_dirty_urcu_active_readers.bitfield&(1<<_pid)))" + line 405, "pan.___", state 835, "else" + line 405, "pan.___", state 838, "(1)" + line 405, "pan.___", state 839, "(1)" + line 405, "pan.___", state 839, "(1)" + line 403, "pan.___", state 844, "((i<1))" + line 403, "pan.___", state 844, "((i>=1))" + line 410, "pan.___", state 850, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 852, "(1)" + line 410, "pan.___", state 853, "((cache_dirty_rcu_ptr.bitfield&(1<<_pid)))" + line 410, "pan.___", state 853, "else" + line 410, "pan.___", state 856, "(1)" + line 410, "pan.___", state 857, "(1)" + line 410, "pan.___", state 857, "(1)" + line 414, "pan.___", state 864, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 414, "pan.___", state 866, "(1)" + line 414, "pan.___", state 867, "((cache_dirty_rcu_data[i].bitfield&(1<<_pid)))" + line 414, "pan.___", state 867, "else" + line 414, "pan.___", state 870, "(1)" + line 414, "pan.___", state 871, "(1)" + line 414, "pan.___", state 871, "(1)" + line 412, "pan.___", state 876, "((i<2))" + line 412, "pan.___", state 876, "((i>=2))" + line 239, "pan.___", state 882, "(1)" + line 243, "pan.___", state 890, "(1)" + line 243, "pan.___", state 891, "(!((cache_dirty_urcu_active_readers.bitfield&(1<<_pid))))" + line 243, "pan.___", state 891, "else" + line 241, "pan.___", state 896, "((i<1))" + line 241, "pan.___", state 896, "((i>=1))" + line 247, "pan.___", state 902, "(1)" + line 247, "pan.___", state 903, "(!((cache_dirty_rcu_ptr.bitfield&(1<<_pid))))" + line 247, "pan.___", state 903, "else" + line 251, "pan.___", state 910, "(1)" + line 251, "pan.___", state 911, "(!((cache_dirty_rcu_data[i].bitfield&(1<<_pid))))" + line 251, "pan.___", state 911, "else" + line 249, "pan.___", state 916, "((i<2))" + line 249, "pan.___", state 916, "((i>=2))" + line 256, "pan.___", state 920, "(!((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid))))" + line 256, "pan.___", state 920, "else" + line 421, "pan.___", state 922, "(1)" + line 421, "pan.___", state 922, "(1)" + line 688, "pan.___", state 926, "_proc_urcu_reader = (_proc_urcu_reader|(1<<11))" + line 401, "pan.___", state 931, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 963, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 977, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 995, "(1)" + line 247, "pan.___", state 1015, "(1)" + line 251, "pan.___", state 1023, "(1)" + line 401, "pan.___", state 1045, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 1077, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 1091, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 1109, "(1)" + line 247, "pan.___", state 1129, "(1)" + line 251, "pan.___", state 1137, "(1)" + line 401, "pan.___", state 1160, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 1192, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 1206, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 1224, "(1)" + line 247, "pan.___", state 1244, "(1)" + line 251, "pan.___", state 1252, "(1)" + line 401, "pan.___", state 1271, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 1303, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 1317, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 1335, "(1)" + line 247, "pan.___", state 1355, "(1)" + line 251, "pan.___", state 1363, "(1)" + line 401, "pan.___", state 1387, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 1419, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 1433, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 1451, "(1)" + line 247, "pan.___", state 1471, "(1)" + line 251, "pan.___", state 1479, "(1)" + line 401, "pan.___", state 1498, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 1530, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 1544, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 1562, "(1)" + line 247, "pan.___", state 1582, "(1)" + line 251, "pan.___", state 1590, "(1)" + line 401, "pan.___", state 1612, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 1644, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 1658, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 1676, "(1)" + line 247, "pan.___", state 1696, "(1)" + line 251, "pan.___", state 1704, "(1)" + line 727, "pan.___", state 1723, "_proc_urcu_reader = (_proc_urcu_reader|((1<<2)<<19))" + line 401, "pan.___", state 1730, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 1762, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 1776, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 1794, "(1)" + line 247, "pan.___", state 1814, "(1)" + line 251, "pan.___", state 1822, "(1)" + line 401, "pan.___", state 1841, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 1873, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 1887, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 1905, "(1)" + line 247, "pan.___", state 1925, "(1)" + line 251, "pan.___", state 1933, "(1)" + line 401, "pan.___", state 1954, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 401, "pan.___", state 1956, "(1)" + line 401, "pan.___", state 1957, "((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid)))" + line 401, "pan.___", state 1957, "else" + line 401, "pan.___", state 1960, "(1)" + line 405, "pan.___", state 1968, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 405, "pan.___", state 1970, "(1)" + line 405, "pan.___", state 1971, "((cache_dirty_urcu_active_readers.bitfield&(1<<_pid)))" + line 405, "pan.___", state 1971, "else" + line 405, "pan.___", state 1974, "(1)" + line 405, "pan.___", state 1975, "(1)" + line 405, "pan.___", state 1975, "(1)" + line 403, "pan.___", state 1980, "((i<1))" + line 403, "pan.___", state 1980, "((i>=1))" + line 410, "pan.___", state 1986, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 1988, "(1)" + line 410, "pan.___", state 1989, "((cache_dirty_rcu_ptr.bitfield&(1<<_pid)))" + line 410, "pan.___", state 1989, "else" + line 410, "pan.___", state 1992, "(1)" + line 410, "pan.___", state 1993, "(1)" + line 410, "pan.___", state 1993, "(1)" + line 414, "pan.___", state 2000, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 414, "pan.___", state 2002, "(1)" + line 414, "pan.___", state 2003, "((cache_dirty_rcu_data[i].bitfield&(1<<_pid)))" + line 414, "pan.___", state 2003, "else" + line 414, "pan.___", state 2006, "(1)" + line 414, "pan.___", state 2007, "(1)" + line 414, "pan.___", state 2007, "(1)" + line 412, "pan.___", state 2012, "((i<2))" + line 412, "pan.___", state 2012, "((i>=2))" + line 239, "pan.___", state 2018, "(1)" + line 243, "pan.___", state 2026, "(1)" + line 243, "pan.___", state 2027, "(!((cache_dirty_urcu_active_readers.bitfield&(1<<_pid))))" + line 243, "pan.___", state 2027, "else" + line 241, "pan.___", state 2032, "((i<1))" + line 241, "pan.___", state 2032, "((i>=1))" + line 247, "pan.___", state 2038, "(1)" + line 247, "pan.___", state 2039, "(!((cache_dirty_rcu_ptr.bitfield&(1<<_pid))))" + line 247, "pan.___", state 2039, "else" + line 251, "pan.___", state 2046, "(1)" + line 251, "pan.___", state 2047, "(!((cache_dirty_rcu_data[i].bitfield&(1<<_pid))))" + line 251, "pan.___", state 2047, "else" + line 249, "pan.___", state 2052, "((i<2))" + line 249, "pan.___", state 2052, "((i>=2))" + line 256, "pan.___", state 2056, "(!((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid))))" + line 256, "pan.___", state 2056, "else" + line 421, "pan.___", state 2058, "(1)" + line 421, "pan.___", state 2058, "(1)" + line 727, "pan.___", state 2061, "cached_urcu_active_readers.val[_pid] = (tmp+1)" + line 727, "pan.___", state 2062, "_proc_urcu_reader = (_proc_urcu_reader|(1<<23))" + line 727, "pan.___", state 2063, "(1)" + line 401, "pan.___", state 2070, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 2102, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 2116, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 2134, "(1)" + line 247, "pan.___", state 2154, "(1)" + line 251, "pan.___", state 2162, "(1)" + line 401, "pan.___", state 2187, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 2219, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 2233, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 2251, "(1)" + line 247, "pan.___", state 2271, "(1)" + line 251, "pan.___", state 2279, "(1)" + line 401, "pan.___", state 2298, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 2330, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 2344, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 2362, "(1)" + line 247, "pan.___", state 2382, "(1)" + line 251, "pan.___", state 2390, "(1)" + line 401, "pan.___", state 2421, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 2453, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 2467, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 2485, "(1)" + line 247, "pan.___", state 2505, "(1)" + line 251, "pan.___", state 2513, "(1)" + line 401, "pan.___", state 2530, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 2562, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 2576, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 2594, "(1)" + line 247, "pan.___", state 2614, "(1)" + line 251, "pan.___", state 2622, "(1)" + line 887, "pan.___", state 2641, "-end-" + (252 of 2641 states) +unreached in proctype urcu_writer + line 401, "pan.___", state 18, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 405, "pan.___", state 32, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 50, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 239, "pan.___", state 82, "(1)" + line 243, "pan.___", state 90, "(1)" + line 247, "pan.___", state 102, "(1)" + line 262, "pan.___", state 131, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 266, "pan.___", state 140, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 270, "pan.___", state 153, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 401, "pan.___", state 193, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 405, "pan.___", state 207, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 225, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 239, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 257, "(1)" + line 243, "pan.___", state 265, "(1)" + line 247, "pan.___", state 277, "(1)" + line 251, "pan.___", state 285, "(1)" + line 405, "pan.___", state 320, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 338, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 352, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 243, "pan.___", state 378, "(1)" + line 247, "pan.___", state 390, "(1)" + line 251, "pan.___", state 398, "(1)" + line 405, "pan.___", state 440, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 458, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 472, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 243, "pan.___", state 498, "(1)" + line 247, "pan.___", state 510, "(1)" + line 251, "pan.___", state 518, "(1)" + line 405, "pan.___", state 551, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 569, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 583, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 243, "pan.___", state 609, "(1)" + line 247, "pan.___", state 621, "(1)" + line 251, "pan.___", state 629, "(1)" + line 405, "pan.___", state 664, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 682, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 696, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 243, "pan.___", state 722, "(1)" + line 247, "pan.___", state 734, "(1)" + line 251, "pan.___", state 742, "(1)" + line 262, "pan.___", state 795, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 266, "pan.___", state 804, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 270, "pan.___", state 819, "(1)" + line 274, "pan.___", state 826, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 842, "(1)" + line 243, "pan.___", state 850, "(1)" + line 247, "pan.___", state 862, "(1)" + line 251, "pan.___", state 870, "(1)" + line 262, "pan.___", state 901, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 266, "pan.___", state 910, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 270, "pan.___", state 923, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 274, "pan.___", state 932, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 948, "(1)" + line 243, "pan.___", state 956, "(1)" + line 247, "pan.___", state 968, "(1)" + line 251, "pan.___", state 976, "(1)" + line 266, "pan.___", state 1002, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 270, "pan.___", state 1015, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 274, "pan.___", state 1024, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 1040, "(1)" + line 243, "pan.___", state 1048, "(1)" + line 247, "pan.___", state 1060, "(1)" + line 251, "pan.___", state 1068, "(1)" + line 262, "pan.___", state 1099, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 266, "pan.___", state 1108, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 270, "pan.___", state 1121, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 274, "pan.___", state 1130, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 1146, "(1)" + line 243, "pan.___", state 1154, "(1)" + line 247, "pan.___", state 1166, "(1)" + line 251, "pan.___", state 1174, "(1)" + line 266, "pan.___", state 1200, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 270, "pan.___", state 1213, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 274, "pan.___", state 1222, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 1238, "(1)" + line 243, "pan.___", state 1246, "(1)" + line 247, "pan.___", state 1258, "(1)" + line 251, "pan.___", state 1266, "(1)" + line 262, "pan.___", state 1297, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 266, "pan.___", state 1306, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 270, "pan.___", state 1319, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 274, "pan.___", state 1328, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 1344, "(1)" + line 243, "pan.___", state 1352, "(1)" + line 247, "pan.___", state 1364, "(1)" + line 251, "pan.___", state 1372, "(1)" + line 266, "pan.___", state 1398, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 270, "pan.___", state 1411, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 274, "pan.___", state 1420, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 1436, "(1)" + line 243, "pan.___", state 1444, "(1)" + line 247, "pan.___", state 1456, "(1)" + line 251, "pan.___", state 1464, "(1)" + line 262, "pan.___", state 1495, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 266, "pan.___", state 1504, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 270, "pan.___", state 1517, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 274, "pan.___", state 1526, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 1542, "(1)" + line 243, "pan.___", state 1550, "(1)" + line 247, "pan.___", state 1562, "(1)" + line 251, "pan.___", state 1570, "(1)" + line 1214, "pan.___", state 1586, "-end-" + (103 of 1586 states) +unreached in proctype :init: + (0 of 78 states) +unreached in proctype :never: + line 1277, "pan.___", state 8, "-end-" + (1 of 8 states) + +pan: elapsed time 388 seconds +pan: rate 31299.887 states/second +pan: avg transition delay 2.9256e-06 usec +cp .input.spin urcu_free_no_rmb.spin.input +cp .input.spin.trail urcu_free_no_rmb.spin.input.trail +make[1]: Leaving directory `/home/compudj/doc/userspace-rcu/formal-model/urcu-controldataflow' diff --git a/formal-model/results/urcu-controldataflow-ipi-intel/urcu_free_no_rmb.spin.input b/formal-model/results/urcu-controldataflow-ipi-intel/urcu_free_no_rmb.spin.input new file mode 100644 index 0000000..b54b6b4 --- /dev/null +++ b/formal-model/results/urcu-controldataflow-ipi-intel/urcu_free_no_rmb.spin.input @@ -0,0 +1,1250 @@ +#define NO_RMB + +// Poison value for freed memory +#define POISON 1 +// Memory with correct data +#define WINE 0 +#define SLAB_SIZE 2 + +#define read_poison (data_read_first[0] == POISON || data_read_second[0] == POISON) + +#define RCU_GP_CTR_BIT (1 << 7) +#define RCU_GP_CTR_NEST_MASK (RCU_GP_CTR_BIT - 1) + +//disabled +#define REMOTE_BARRIERS + +//#define ARCH_ALPHA +#define ARCH_INTEL +//#define ARCH_POWERPC +/* + * mem.spin: Promela code to validate memory barriers with OOO memory + * and out-of-order instruction scheduling. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * Copyright (c) 2009 Mathieu Desnoyers + */ + +/* Promela validation variables. */ + +/* specific defines "included" here */ +/* DEFINES file "included" here */ + +#define NR_READERS 1 +#define NR_WRITERS 1 + +#define NR_PROCS 2 + +#define get_pid() (_pid) + +#define get_readerid() (get_pid()) + +/* + * Produced process control and data flow. Updated after each instruction to + * show which variables are ready. Using one-hot bit encoding per variable to + * save state space. Used as triggers to execute the instructions having those + * variables as input. Leaving bits active to inhibit instruction execution. + * Scheme used to make instruction disabling and automatic dependency fall-back + * automatic. + */ + +#define CONSUME_TOKENS(state, bits, notbits) \ + ((!(state & (notbits))) && (state & (bits)) == (bits)) + +#define PRODUCE_TOKENS(state, bits) \ + state = state | (bits); + +#define CLEAR_TOKENS(state, bits) \ + state = state & ~(bits) + +/* + * Types of dependency : + * + * Data dependency + * + * - True dependency, Read-after-Write (RAW) + * + * This type of dependency happens when a statement depends on the result of a + * previous statement. This applies to any statement which needs to read a + * variable written by a preceding statement. + * + * - False dependency, Write-after-Read (WAR) + * + * Typically, variable renaming can ensure that this dependency goes away. + * However, if the statements must read and then write from/to the same variable + * in the OOO memory model, renaming may be impossible, and therefore this + * causes a WAR dependency. + * + * - Output dependency, Write-after-Write (WAW) + * + * Two writes to the same variable in subsequent statements. Variable renaming + * can ensure this is not needed, but can be required when writing multiple + * times to the same OOO mem model variable. + * + * Control dependency + * + * Execution of a given instruction depends on a previous instruction evaluating + * in a way that allows its execution. E.g. : branches. + * + * Useful considerations for joining dependencies after branch + * + * - Pre-dominance + * + * "We say box i dominates box j if every path (leading from input to output + * through the diagram) which passes through box j must also pass through box + * i. Thus box i dominates box j if box j is subordinate to box i in the + * program." + * + * http://www.hipersoft.rice.edu/grads/publications/dom14.pdf + * Other classic algorithm to calculate dominance : Lengauer-Tarjan (in gcc) + * + * - Post-dominance + * + * Just as pre-dominance, but with arcs of the data flow inverted, and input vs + * output exchanged. Therefore, i post-dominating j ensures that every path + * passing by j will pass by i before reaching the output. + * + * Other considerations + * + * Note about "volatile" keyword dependency : The compiler will order volatile + * accesses so they appear in the right order on a given CPU. They can be + * reordered by the CPU instruction scheduling. This therefore cannot be + * considered as a depencency. + * + * References : + * + * Cooper, Keith D.; & Torczon, Linda. (2005). Engineering a Compiler. Morgan + * Kaufmann. ISBN 1-55860-698-X. + * Kennedy, Ken; & Allen, Randy. (2001). Optimizing Compilers for Modern + * Architectures: A Dependence-based Approach. Morgan Kaufmann. ISBN + * 1-55860-286-0. + * Muchnick, Steven S. (1997). Advanced Compiler Design and Implementation. + * Morgan Kaufmann. ISBN 1-55860-320-4. + */ + +/* + * Note about loops and nested calls + * + * To keep this model simple, loops expressed in the framework will behave as if + * there was a core synchronizing instruction between loops. To see the effect + * of loop unrolling, manually unrolling loops is required. Note that if loops + * end or start with a core synchronizing instruction, the model is appropriate. + * Nested calls are not supported. + */ + +/* + * Only Alpha has out-of-order cache bank loads. Other architectures (intel, + * powerpc, arm) ensure that dependent reads won't be reordered. c.f. + * http://www.linuxjournal.com/article/8212) +#ifdef ARCH_ALPHA +#define HAVE_OOO_CACHE_READ +#endif + +/* + * Each process have its own data in cache. Caches are randomly updated. + * smp_wmb and smp_rmb forces cache updates (write and read), smp_mb forces + * both. + */ + +typedef per_proc_byte { + byte val[NR_PROCS]; +}; + +typedef per_proc_bit { + bit val[NR_PROCS]; +}; + +/* Bitfield has a maximum of 8 procs */ +typedef per_proc_bitfield { + byte bitfield; +}; + +#define DECLARE_CACHED_VAR(type, x) \ + type mem_##x; \ + per_proc_##type cached_##x; \ + per_proc_bitfield cache_dirty_##x; + +#define INIT_CACHED_VAR(x, v, j) \ + mem_##x = v; \ + cache_dirty_##x.bitfield = 0; \ + j = 0; \ + do \ + :: j < NR_PROCS -> \ + cached_##x.val[j] = v; \ + j++ \ + :: j >= NR_PROCS -> break \ + od; + +#define IS_CACHE_DIRTY(x, id) (cache_dirty_##x.bitfield & (1 << id)) + +#define READ_CACHED_VAR(x) (cached_##x.val[get_pid()]) + +#define WRITE_CACHED_VAR(x, v) \ + atomic { \ + cached_##x.val[get_pid()] = v; \ + cache_dirty_##x.bitfield = \ + cache_dirty_##x.bitfield | (1 << get_pid()); \ + } + +#define CACHE_WRITE_TO_MEM(x, id) \ + if \ + :: IS_CACHE_DIRTY(x, id) -> \ + mem_##x = cached_##x.val[id]; \ + cache_dirty_##x.bitfield = \ + cache_dirty_##x.bitfield & (~(1 << id)); \ + :: else -> \ + skip \ + fi; + +#define CACHE_READ_FROM_MEM(x, id) \ + if \ + :: !IS_CACHE_DIRTY(x, id) -> \ + cached_##x.val[id] = mem_##x;\ + :: else -> \ + skip \ + fi; + +/* + * May update other caches if cache is dirty, or not. + */ +#define RANDOM_CACHE_WRITE_TO_MEM(x, id)\ + if \ + :: 1 -> CACHE_WRITE_TO_MEM(x, id); \ + :: 1 -> skip \ + fi; + +#define RANDOM_CACHE_READ_FROM_MEM(x, id)\ + if \ + :: 1 -> CACHE_READ_FROM_MEM(x, id); \ + :: 1 -> skip \ + fi; + +/* Must consume all prior read tokens. All subsequent reads depend on it. */ +inline smp_rmb(i) +{ + atomic { + CACHE_READ_FROM_MEM(urcu_gp_ctr, get_pid()); + i = 0; + do + :: i < NR_READERS -> + CACHE_READ_FROM_MEM(urcu_active_readers[i], get_pid()); + i++ + :: i >= NR_READERS -> break + od; + CACHE_READ_FROM_MEM(rcu_ptr, get_pid()); + i = 0; + do + :: i < SLAB_SIZE -> + CACHE_READ_FROM_MEM(rcu_data[i], get_pid()); + i++ + :: i >= SLAB_SIZE -> break + od; + } +} + +/* Must consume all prior write tokens. All subsequent writes depend on it. */ +inline smp_wmb(i) +{ + atomic { + CACHE_WRITE_TO_MEM(urcu_gp_ctr, get_pid()); + i = 0; + do + :: i < NR_READERS -> + CACHE_WRITE_TO_MEM(urcu_active_readers[i], get_pid()); + i++ + :: i >= NR_READERS -> break + od; + CACHE_WRITE_TO_MEM(rcu_ptr, get_pid()); + i = 0; + do + :: i < SLAB_SIZE -> + CACHE_WRITE_TO_MEM(rcu_data[i], get_pid()); + i++ + :: i >= SLAB_SIZE -> break + od; + } +} + +/* Synchronization point. Must consume all prior read and write tokens. All + * subsequent reads and writes depend on it. */ +inline smp_mb(i) +{ + atomic { + smp_wmb(i); + smp_rmb(i); + } +} + +#ifdef REMOTE_BARRIERS + +bit reader_barrier[NR_READERS]; + +/* + * We cannot leave the barriers dependencies in place in REMOTE_BARRIERS mode + * because they would add unexisting core synchronization and would therefore + * create an incomplete model. + * Therefore, we model the read-side memory barriers by completely disabling the + * memory barriers and their dependencies from the read-side. One at a time + * (different verification runs), we make a different instruction listen for + * signals. + */ + +#define smp_mb_reader(i, j) + +/* + * Service 0, 1 or many barrier requests. + */ +inline smp_mb_recv(i, j) +{ + do + :: (reader_barrier[get_readerid()] == 1) -> + /* + * We choose to ignore cycles caused by writer busy-looping, + * waiting for the reader, sending barrier requests, and the + * reader always services them without continuing execution. + */ +progress_ignoring_mb1: + smp_mb(i); + reader_barrier[get_readerid()] = 0; + :: 1 -> + /* + * We choose to ignore writer's non-progress caused by the + * reader ignoring the writer's mb() requests. + */ +progress_ignoring_mb2: + break; + od; +} + +#define PROGRESS_LABEL(progressid) progress_writer_progid_##progressid: + +#define smp_mb_send(i, j, progressid) \ +{ \ + smp_mb(i); \ + i = 0; \ + do \ + :: i < NR_READERS -> \ + reader_barrier[i] = 1; \ + /* \ + * Busy-looping waiting for reader barrier handling is of little\ + * interest, given the reader has the ability to totally ignore \ + * barrier requests. \ + */ \ + do \ + :: (reader_barrier[i] == 1) -> \ +PROGRESS_LABEL(progressid) \ + skip; \ + :: (reader_barrier[i] == 0) -> break; \ + od; \ + i++; \ + :: i >= NR_READERS -> \ + break \ + od; \ + smp_mb(i); \ +} + +#else + +#define smp_mb_send(i, j, progressid) smp_mb(i) +#define smp_mb_reader smp_mb(i) +#define smp_mb_recv(i, j) + +#endif + +/* Keep in sync manually with smp_rmb, smp_wmb, ooo_mem and init() */ +DECLARE_CACHED_VAR(byte, urcu_gp_ctr); +/* Note ! currently only one reader */ +DECLARE_CACHED_VAR(byte, urcu_active_readers[NR_READERS]); +/* RCU data */ +DECLARE_CACHED_VAR(bit, rcu_data[SLAB_SIZE]); + +/* RCU pointer */ +#if (SLAB_SIZE == 2) +DECLARE_CACHED_VAR(bit, rcu_ptr); +bit ptr_read_first[NR_READERS]; +bit ptr_read_second[NR_READERS]; +#else +DECLARE_CACHED_VAR(byte, rcu_ptr); +byte ptr_read_first[NR_READERS]; +byte ptr_read_second[NR_READERS]; +#endif + +bit data_read_first[NR_READERS]; +bit data_read_second[NR_READERS]; + +bit init_done = 0; + +inline wait_init_done() +{ + do + :: init_done == 0 -> skip; + :: else -> break; + od; +} + +inline ooo_mem(i) +{ + atomic { + RANDOM_CACHE_WRITE_TO_MEM(urcu_gp_ctr, get_pid()); + i = 0; + do + :: i < NR_READERS -> + RANDOM_CACHE_WRITE_TO_MEM(urcu_active_readers[i], + get_pid()); + i++ + :: i >= NR_READERS -> break + od; + RANDOM_CACHE_WRITE_TO_MEM(rcu_ptr, get_pid()); + i = 0; + do + :: i < SLAB_SIZE -> + RANDOM_CACHE_WRITE_TO_MEM(rcu_data[i], get_pid()); + i++ + :: i >= SLAB_SIZE -> break + od; +#ifdef HAVE_OOO_CACHE_READ + RANDOM_CACHE_READ_FROM_MEM(urcu_gp_ctr, get_pid()); + i = 0; + do + :: i < NR_READERS -> + RANDOM_CACHE_READ_FROM_MEM(urcu_active_readers[i], + get_pid()); + i++ + :: i >= NR_READERS -> break + od; + RANDOM_CACHE_READ_FROM_MEM(rcu_ptr, get_pid()); + i = 0; + do + :: i < SLAB_SIZE -> + RANDOM_CACHE_READ_FROM_MEM(rcu_data[i], get_pid()); + i++ + :: i >= SLAB_SIZE -> break + od; +#else + smp_rmb(i); +#endif /* HAVE_OOO_CACHE_READ */ + } +} + +/* + * Bit encoding, urcu_reader : + */ + +int _proc_urcu_reader; +#define proc_urcu_reader _proc_urcu_reader + +/* Body of PROCEDURE_READ_LOCK */ +#define READ_PROD_A_READ (1 << 0) +#define READ_PROD_B_IF_TRUE (1 << 1) +#define READ_PROD_B_IF_FALSE (1 << 2) +#define READ_PROD_C_IF_TRUE_READ (1 << 3) + +#define PROCEDURE_READ_LOCK(base, consumetoken, producetoken) \ + :: CONSUME_TOKENS(proc_urcu_reader, consumetoken, READ_PROD_A_READ << base) -> \ + ooo_mem(i); \ + tmp = READ_CACHED_VAR(urcu_active_readers[get_readerid()]); \ + PRODUCE_TOKENS(proc_urcu_reader, READ_PROD_A_READ << base); \ + :: CONSUME_TOKENS(proc_urcu_reader, \ + READ_PROD_A_READ << base, /* RAW, pre-dominant */ \ + (READ_PROD_B_IF_TRUE | READ_PROD_B_IF_FALSE) << base) -> \ + if \ + :: (!(tmp & RCU_GP_CTR_NEST_MASK)) -> \ + PRODUCE_TOKENS(proc_urcu_reader, READ_PROD_B_IF_TRUE << base); \ + :: else -> \ + PRODUCE_TOKENS(proc_urcu_reader, READ_PROD_B_IF_FALSE << base); \ + fi; \ + /* IF TRUE */ \ + :: CONSUME_TOKENS(proc_urcu_reader, READ_PROD_B_IF_TRUE << base, \ + READ_PROD_C_IF_TRUE_READ << base) -> \ + ooo_mem(i); \ + tmp2 = READ_CACHED_VAR(urcu_gp_ctr); \ + PRODUCE_TOKENS(proc_urcu_reader, READ_PROD_C_IF_TRUE_READ << base); \ + :: CONSUME_TOKENS(proc_urcu_reader, \ + (READ_PROD_C_IF_TRUE_READ /* pre-dominant */ \ + | READ_PROD_A_READ) << base, /* WAR */ \ + producetoken) -> \ + ooo_mem(i); \ + WRITE_CACHED_VAR(urcu_active_readers[get_readerid()], tmp2); \ + PRODUCE_TOKENS(proc_urcu_reader, producetoken); \ + /* IF_MERGE implies \ + * post-dominance */ \ + /* ELSE */ \ + :: CONSUME_TOKENS(proc_urcu_reader, \ + (READ_PROD_B_IF_FALSE /* pre-dominant */ \ + | READ_PROD_A_READ) << base, /* WAR */ \ + producetoken) -> \ + ooo_mem(i); \ + WRITE_CACHED_VAR(urcu_active_readers[get_readerid()], \ + tmp + 1); \ + PRODUCE_TOKENS(proc_urcu_reader, producetoken); \ + /* IF_MERGE implies \ + * post-dominance */ \ + /* ENDIF */ \ + skip + +/* Body of PROCEDURE_READ_LOCK */ +#define READ_PROC_READ_UNLOCK (1 << 0) + +#define PROCEDURE_READ_UNLOCK(base, consumetoken, producetoken) \ + :: CONSUME_TOKENS(proc_urcu_reader, \ + consumetoken, \ + READ_PROC_READ_UNLOCK << base) -> \ + ooo_mem(i); \ + tmp2 = READ_CACHED_VAR(urcu_active_readers[get_readerid()]); \ + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_READ_UNLOCK << base); \ + :: CONSUME_TOKENS(proc_urcu_reader, \ + consumetoken \ + | (READ_PROC_READ_UNLOCK << base), /* WAR */ \ + producetoken) -> \ + ooo_mem(i); \ + WRITE_CACHED_VAR(urcu_active_readers[get_readerid()], tmp2 - 1); \ + PRODUCE_TOKENS(proc_urcu_reader, producetoken); \ + skip + + +#define READ_PROD_NONE (1 << 0) + +/* PROCEDURE_READ_LOCK base = << 1 : 1 to 5 */ +#define READ_LOCK_BASE 1 +#define READ_LOCK_OUT (1 << 5) + +#define READ_PROC_FIRST_MB (1 << 6) + +/* PROCEDURE_READ_LOCK (NESTED) base : << 7 : 7 to 11 */ +#define READ_LOCK_NESTED_BASE 7 +#define READ_LOCK_NESTED_OUT (1 << 11) + +#define READ_PROC_READ_GEN (1 << 12) +#define READ_PROC_ACCESS_GEN (1 << 13) + +/* PROCEDURE_READ_UNLOCK (NESTED) base = << 14 : 14 to 15 */ +#define READ_UNLOCK_NESTED_BASE 14 +#define READ_UNLOCK_NESTED_OUT (1 << 15) + +#define READ_PROC_SECOND_MB (1 << 16) + +/* PROCEDURE_READ_UNLOCK base = << 17 : 17 to 18 */ +#define READ_UNLOCK_BASE 17 +#define READ_UNLOCK_OUT (1 << 18) + +/* PROCEDURE_READ_LOCK_UNROLL base = << 19 : 19 to 23 */ +#define READ_LOCK_UNROLL_BASE 19 +#define READ_LOCK_OUT_UNROLL (1 << 23) + +#define READ_PROC_THIRD_MB (1 << 24) + +#define READ_PROC_READ_GEN_UNROLL (1 << 25) +#define READ_PROC_ACCESS_GEN_UNROLL (1 << 26) + +#define READ_PROC_FOURTH_MB (1 << 27) + +/* PROCEDURE_READ_UNLOCK_UNROLL base = << 28 : 28 to 29 */ +#define READ_UNLOCK_UNROLL_BASE 28 +#define READ_UNLOCK_OUT_UNROLL (1 << 29) + + +/* Should not include branches */ +#define READ_PROC_ALL_TOKENS (READ_PROD_NONE \ + | READ_LOCK_OUT \ + | READ_PROC_FIRST_MB \ + | READ_LOCK_NESTED_OUT \ + | READ_PROC_READ_GEN \ + | READ_PROC_ACCESS_GEN \ + | READ_UNLOCK_NESTED_OUT \ + | READ_PROC_SECOND_MB \ + | READ_UNLOCK_OUT \ + | READ_LOCK_OUT_UNROLL \ + | READ_PROC_THIRD_MB \ + | READ_PROC_READ_GEN_UNROLL \ + | READ_PROC_ACCESS_GEN_UNROLL \ + | READ_PROC_FOURTH_MB \ + | READ_UNLOCK_OUT_UNROLL) + +/* Must clear all tokens, including branches */ +#define READ_PROC_ALL_TOKENS_CLEAR ((1 << 30) - 1) + +inline urcu_one_read(i, j, nest_i, tmp, tmp2) +{ + PRODUCE_TOKENS(proc_urcu_reader, READ_PROD_NONE); + +#ifdef NO_MB + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_FIRST_MB); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_SECOND_MB); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_THIRD_MB); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_FOURTH_MB); +#endif + +#ifdef REMOTE_BARRIERS + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_FIRST_MB); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_SECOND_MB); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_THIRD_MB); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_FOURTH_MB); +#endif + + do + :: 1 -> + +#ifdef REMOTE_BARRIERS + /* + * Signal-based memory barrier will only execute when the + * execution order appears in program order. + */ + if + :: 1 -> + atomic { + if + :: CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE, + READ_LOCK_OUT | READ_LOCK_NESTED_OUT + | READ_PROC_READ_GEN | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT + | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT, + READ_LOCK_NESTED_OUT + | READ_PROC_READ_GEN | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT + | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT | READ_LOCK_NESTED_OUT, + READ_PROC_READ_GEN | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT + | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN, + READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT + | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN | READ_PROC_ACCESS_GEN, + READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT + | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN + | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT, + READ_UNLOCK_OUT + | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN + | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT, + READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN + | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT | READ_LOCK_OUT_UNROLL, + READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN + | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL, + READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN + | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL, + READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL, + 0) -> + goto non_atomic3; +non_atomic3_end: + skip; + fi; + } + fi; + + goto non_atomic3_skip; +non_atomic3: + smp_mb_recv(i, j); + goto non_atomic3_end; +non_atomic3_skip: + +#endif /* REMOTE_BARRIERS */ + + atomic { + if + PROCEDURE_READ_LOCK(READ_LOCK_BASE, READ_PROD_NONE, READ_LOCK_OUT); + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_LOCK_OUT, /* post-dominant */ + READ_PROC_FIRST_MB) -> + smp_mb_reader(i, j); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_FIRST_MB); + + PROCEDURE_READ_LOCK(READ_LOCK_NESTED_BASE, READ_PROC_FIRST_MB | READ_LOCK_OUT, + READ_LOCK_NESTED_OUT); + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_PROC_FIRST_MB, /* mb() orders reads */ + READ_PROC_READ_GEN) -> + ooo_mem(i); + ptr_read_first[get_readerid()] = READ_CACHED_VAR(rcu_ptr); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_READ_GEN); + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_PROC_FIRST_MB /* mb() orders reads */ + | READ_PROC_READ_GEN, + READ_PROC_ACCESS_GEN) -> + /* smp_read_barrier_depends */ + goto rmb1; +rmb1_end: + data_read_first[get_readerid()] = + READ_CACHED_VAR(rcu_data[ptr_read_first[get_readerid()]]); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_ACCESS_GEN); + + + /* Note : we remove the nested memory barrier from the read unlock + * model, given it is not usually needed. The implementation has the barrier + * because the performance impact added by a branch in the common case does not + * justify it. + */ + + PROCEDURE_READ_UNLOCK(READ_UNLOCK_NESTED_BASE, + READ_PROC_FIRST_MB + | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT, + READ_UNLOCK_NESTED_OUT); + + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_PROC_ACCESS_GEN /* mb() orders reads */ + | READ_PROC_READ_GEN /* mb() orders reads */ + | READ_PROC_FIRST_MB /* mb() ordered */ + | READ_LOCK_OUT /* post-dominant */ + | READ_LOCK_NESTED_OUT /* post-dominant */ + | READ_UNLOCK_NESTED_OUT, + READ_PROC_SECOND_MB) -> + smp_mb_reader(i, j); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_SECOND_MB); + + PROCEDURE_READ_UNLOCK(READ_UNLOCK_BASE, + READ_PROC_SECOND_MB /* mb() orders reads */ + | READ_PROC_FIRST_MB /* mb() orders reads */ + | READ_LOCK_NESTED_OUT /* RAW */ + | READ_LOCK_OUT /* RAW */ + | READ_UNLOCK_NESTED_OUT, /* RAW */ + READ_UNLOCK_OUT); + + /* Unrolling loop : second consecutive lock */ + /* reading urcu_active_readers, which have been written by + * READ_UNLOCK_OUT : RAW */ + PROCEDURE_READ_LOCK(READ_LOCK_UNROLL_BASE, + READ_UNLOCK_OUT /* RAW */ + | READ_PROC_SECOND_MB /* mb() orders reads */ + | READ_PROC_FIRST_MB /* mb() orders reads */ + | READ_LOCK_NESTED_OUT /* RAW */ + | READ_LOCK_OUT /* RAW */ + | READ_UNLOCK_NESTED_OUT, /* RAW */ + READ_LOCK_OUT_UNROLL); + + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_PROC_FIRST_MB /* mb() ordered */ + | READ_PROC_SECOND_MB /* mb() ordered */ + | READ_LOCK_OUT_UNROLL /* post-dominant */ + | READ_LOCK_NESTED_OUT + | READ_LOCK_OUT + | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT, + READ_PROC_THIRD_MB) -> + smp_mb_reader(i, j); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_THIRD_MB); + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_PROC_FIRST_MB /* mb() orders reads */ + | READ_PROC_SECOND_MB /* mb() orders reads */ + | READ_PROC_THIRD_MB, /* mb() orders reads */ + READ_PROC_READ_GEN_UNROLL) -> + ooo_mem(i); + ptr_read_second[get_readerid()] = READ_CACHED_VAR(rcu_ptr); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_READ_GEN_UNROLL); + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_PROC_READ_GEN_UNROLL + | READ_PROC_FIRST_MB /* mb() orders reads */ + | READ_PROC_SECOND_MB /* mb() orders reads */ + | READ_PROC_THIRD_MB, /* mb() orders reads */ + READ_PROC_ACCESS_GEN_UNROLL) -> + /* smp_read_barrier_depends */ + goto rmb2; +rmb2_end: + data_read_second[get_readerid()] = + READ_CACHED_VAR(rcu_data[ptr_read_second[get_readerid()]]); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_ACCESS_GEN_UNROLL); + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_PROC_READ_GEN_UNROLL /* mb() orders reads */ + | READ_PROC_ACCESS_GEN_UNROLL /* mb() orders reads */ + | READ_PROC_FIRST_MB /* mb() ordered */ + | READ_PROC_SECOND_MB /* mb() ordered */ + | READ_PROC_THIRD_MB /* mb() ordered */ + | READ_LOCK_OUT_UNROLL /* post-dominant */ + | READ_LOCK_NESTED_OUT + | READ_LOCK_OUT + | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT, + READ_PROC_FOURTH_MB) -> + smp_mb_reader(i, j); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_FOURTH_MB); + + PROCEDURE_READ_UNLOCK(READ_UNLOCK_UNROLL_BASE, + READ_PROC_FOURTH_MB /* mb() orders reads */ + | READ_PROC_THIRD_MB /* mb() orders reads */ + | READ_LOCK_OUT_UNROLL /* RAW */ + | READ_PROC_SECOND_MB /* mb() orders reads */ + | READ_PROC_FIRST_MB /* mb() orders reads */ + | READ_LOCK_NESTED_OUT /* RAW */ + | READ_LOCK_OUT /* RAW */ + | READ_UNLOCK_NESTED_OUT, /* RAW */ + READ_UNLOCK_OUT_UNROLL); + :: CONSUME_TOKENS(proc_urcu_reader, READ_PROC_ALL_TOKENS, 0) -> + CLEAR_TOKENS(proc_urcu_reader, READ_PROC_ALL_TOKENS_CLEAR); + break; + fi; + } + od; + /* + * Dependency between consecutive loops : + * RAW dependency on + * WRITE_CACHED_VAR(urcu_active_readers[get_readerid()], tmp2 - 1) + * tmp = READ_CACHED_VAR(urcu_active_readers[get_readerid()]); + * between loops. + * _WHEN THE MB()s are in place_, they add full ordering of the + * generation pointer read wrt active reader count read, which ensures + * execution will not spill across loop execution. + * However, in the event mb()s are removed (execution using signal + * handler to promote barrier()() -> smp_mb()), nothing prevents one loop + * to spill its execution on other loop's execution. + */ + goto end; +rmb1: +#ifndef NO_RMB + smp_rmb(i); +#else + ooo_mem(i); +#endif + goto rmb1_end; +rmb2: +#ifndef NO_RMB + smp_rmb(i); +#else + ooo_mem(i); +#endif + goto rmb2_end; +end: + skip; +} + + + +active proctype urcu_reader() +{ + byte i, j, nest_i; + byte tmp, tmp2; + + wait_init_done(); + + assert(get_pid() < NR_PROCS); + +end_reader: + do + :: 1 -> + /* + * We do not test reader's progress here, because we are mainly + * interested in writer's progress. The reader never blocks + * anyway. We have to test for reader/writer's progress + * separately, otherwise we could think the writer is doing + * progress when it's blocked by an always progressing reader. + */ +#ifdef READER_PROGRESS +progress_reader: +#endif + urcu_one_read(i, j, nest_i, tmp, tmp2); + od; +} + +/* no name clash please */ +#undef proc_urcu_reader + + +/* Model the RCU update process. */ + +/* + * Bit encoding, urcu_writer : + * Currently only supports one reader. + */ + +int _proc_urcu_writer; +#define proc_urcu_writer _proc_urcu_writer + +#define WRITE_PROD_NONE (1 << 0) + +#define WRITE_DATA (1 << 1) +#define WRITE_PROC_WMB (1 << 2) +#define WRITE_XCHG_PTR (1 << 3) + +#define WRITE_PROC_FIRST_MB (1 << 4) + +/* first flip */ +#define WRITE_PROC_FIRST_READ_GP (1 << 5) +#define WRITE_PROC_FIRST_WRITE_GP (1 << 6) +#define WRITE_PROC_FIRST_WAIT (1 << 7) +#define WRITE_PROC_FIRST_WAIT_LOOP (1 << 8) + +/* second flip */ +#define WRITE_PROC_SECOND_READ_GP (1 << 9) +#define WRITE_PROC_SECOND_WRITE_GP (1 << 10) +#define WRITE_PROC_SECOND_WAIT (1 << 11) +#define WRITE_PROC_SECOND_WAIT_LOOP (1 << 12) + +#define WRITE_PROC_SECOND_MB (1 << 13) + +#define WRITE_FREE (1 << 14) + +#define WRITE_PROC_ALL_TOKENS (WRITE_PROD_NONE \ + | WRITE_DATA \ + | WRITE_PROC_WMB \ + | WRITE_XCHG_PTR \ + | WRITE_PROC_FIRST_MB \ + | WRITE_PROC_FIRST_READ_GP \ + | WRITE_PROC_FIRST_WRITE_GP \ + | WRITE_PROC_FIRST_WAIT \ + | WRITE_PROC_SECOND_READ_GP \ + | WRITE_PROC_SECOND_WRITE_GP \ + | WRITE_PROC_SECOND_WAIT \ + | WRITE_PROC_SECOND_MB \ + | WRITE_FREE) + +#define WRITE_PROC_ALL_TOKENS_CLEAR ((1 << 15) - 1) + +/* + * Mutexes are implied around writer execution. A single writer at a time. + */ +active proctype urcu_writer() +{ + byte i, j; + byte tmp, tmp2, tmpa; + byte cur_data = 0, old_data, loop_nr = 0; + byte cur_gp_val = 0; /* + * Keep a local trace of the current parity so + * we don't add non-existing dependencies on the global + * GP update. Needed to test single flip case. + */ + + wait_init_done(); + + assert(get_pid() < NR_PROCS); + + do + :: (loop_nr < 3) -> +#ifdef WRITER_PROGRESS +progress_writer1: +#endif + loop_nr = loop_nr + 1; + + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROD_NONE); + +#ifdef NO_WMB + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_WMB); +#endif + +#ifdef NO_MB + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_FIRST_MB); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_MB); +#endif + +#ifdef SINGLE_FLIP + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_READ_GP); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_WRITE_GP); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_WAIT); + /* For single flip, we need to know the current parity */ + cur_gp_val = cur_gp_val ^ RCU_GP_CTR_BIT; +#endif + + do :: 1 -> + atomic { + if + + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_PROD_NONE, + WRITE_DATA) -> + ooo_mem(i); + cur_data = (cur_data + 1) % SLAB_SIZE; + WRITE_CACHED_VAR(rcu_data[cur_data], WINE); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_DATA); + + + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_DATA, + WRITE_PROC_WMB) -> + smp_wmb(i); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_WMB); + + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_PROC_WMB, + WRITE_XCHG_PTR) -> + /* rcu_xchg_pointer() */ + atomic { + old_data = READ_CACHED_VAR(rcu_ptr); + WRITE_CACHED_VAR(rcu_ptr, cur_data); + } + PRODUCE_TOKENS(proc_urcu_writer, WRITE_XCHG_PTR); + + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_DATA | WRITE_PROC_WMB | WRITE_XCHG_PTR, + WRITE_PROC_FIRST_MB) -> + goto smp_mb_send1; +smp_mb_send1_end: + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_FIRST_MB); + + /* first flip */ + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_PROC_FIRST_MB, + WRITE_PROC_FIRST_READ_GP) -> + tmpa = READ_CACHED_VAR(urcu_gp_ctr); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_FIRST_READ_GP); + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_PROC_FIRST_MB | WRITE_PROC_WMB + | WRITE_PROC_FIRST_READ_GP, + WRITE_PROC_FIRST_WRITE_GP) -> + ooo_mem(i); + WRITE_CACHED_VAR(urcu_gp_ctr, tmpa ^ RCU_GP_CTR_BIT); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_FIRST_WRITE_GP); + + :: CONSUME_TOKENS(proc_urcu_writer, + //WRITE_PROC_FIRST_WRITE_GP /* TEST ADDING SYNC CORE */ + WRITE_PROC_FIRST_MB, /* can be reordered before/after flips */ + WRITE_PROC_FIRST_WAIT | WRITE_PROC_FIRST_WAIT_LOOP) -> + ooo_mem(i); + /* ONLY WAITING FOR READER 0 */ + tmp2 = READ_CACHED_VAR(urcu_active_readers[0]); +#ifndef SINGLE_FLIP + /* In normal execution, we are always starting by + * waiting for the even parity. + */ + cur_gp_val = RCU_GP_CTR_BIT; +#endif + if + :: (tmp2 & RCU_GP_CTR_NEST_MASK) + && ((tmp2 ^ cur_gp_val) & RCU_GP_CTR_BIT) -> + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_FIRST_WAIT_LOOP); + :: else -> + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_FIRST_WAIT); + fi; + + :: CONSUME_TOKENS(proc_urcu_writer, + //WRITE_PROC_FIRST_WRITE_GP /* TEST ADDING SYNC CORE */ + WRITE_PROC_FIRST_WRITE_GP + | WRITE_PROC_FIRST_READ_GP + | WRITE_PROC_FIRST_WAIT_LOOP + | WRITE_DATA | WRITE_PROC_WMB | WRITE_XCHG_PTR + | WRITE_PROC_FIRST_MB, /* can be reordered before/after flips */ + 0) -> +#ifndef GEN_ERROR_WRITER_PROGRESS + goto smp_mb_send2; +smp_mb_send2_end: +#else + ooo_mem(i); +#endif + /* This instruction loops to WRITE_PROC_FIRST_WAIT */ + CLEAR_TOKENS(proc_urcu_writer, WRITE_PROC_FIRST_WAIT_LOOP | WRITE_PROC_FIRST_WAIT); + + /* second flip */ + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_PROC_FIRST_WAIT /* Control dependency : need to branch out of + * the loop to execute the next flip (CHECK) */ + | WRITE_PROC_FIRST_WRITE_GP + | WRITE_PROC_FIRST_READ_GP + | WRITE_PROC_FIRST_MB, + WRITE_PROC_SECOND_READ_GP) -> + ooo_mem(i); + tmpa = READ_CACHED_VAR(urcu_gp_ctr); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_READ_GP); + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_PROC_FIRST_MB + | WRITE_PROC_WMB + | WRITE_PROC_FIRST_READ_GP + | WRITE_PROC_FIRST_WRITE_GP + | WRITE_PROC_SECOND_READ_GP, + WRITE_PROC_SECOND_WRITE_GP) -> + ooo_mem(i); + WRITE_CACHED_VAR(urcu_gp_ctr, tmpa ^ RCU_GP_CTR_BIT); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_WRITE_GP); + + :: CONSUME_TOKENS(proc_urcu_writer, + //WRITE_PROC_FIRST_WRITE_GP /* TEST ADDING SYNC CORE */ + WRITE_PROC_FIRST_WAIT + | WRITE_PROC_FIRST_MB, /* can be reordered before/after flips */ + WRITE_PROC_SECOND_WAIT | WRITE_PROC_SECOND_WAIT_LOOP) -> + ooo_mem(i); + /* ONLY WAITING FOR READER 0 */ + tmp2 = READ_CACHED_VAR(urcu_active_readers[0]); + if + :: (tmp2 & RCU_GP_CTR_NEST_MASK) + && ((tmp2 ^ 0) & RCU_GP_CTR_BIT) -> + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_WAIT_LOOP); + :: else -> + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_WAIT); + fi; + + :: CONSUME_TOKENS(proc_urcu_writer, + //WRITE_PROC_FIRST_WRITE_GP /* TEST ADDING SYNC CORE */ + WRITE_PROC_SECOND_WRITE_GP + | WRITE_PROC_FIRST_WRITE_GP + | WRITE_PROC_SECOND_READ_GP + | WRITE_PROC_FIRST_READ_GP + | WRITE_PROC_SECOND_WAIT_LOOP + | WRITE_DATA | WRITE_PROC_WMB | WRITE_XCHG_PTR + | WRITE_PROC_FIRST_MB, /* can be reordered before/after flips */ + 0) -> +#ifndef GEN_ERROR_WRITER_PROGRESS + goto smp_mb_send3; +smp_mb_send3_end: +#else + ooo_mem(i); +#endif + /* This instruction loops to WRITE_PROC_SECOND_WAIT */ + CLEAR_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_WAIT_LOOP | WRITE_PROC_SECOND_WAIT); + + + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_PROC_FIRST_WAIT + | WRITE_PROC_SECOND_WAIT + | WRITE_PROC_FIRST_READ_GP + | WRITE_PROC_SECOND_READ_GP + | WRITE_PROC_FIRST_WRITE_GP + | WRITE_PROC_SECOND_WRITE_GP + | WRITE_DATA | WRITE_PROC_WMB | WRITE_XCHG_PTR + | WRITE_PROC_FIRST_MB, + WRITE_PROC_SECOND_MB) -> + goto smp_mb_send4; +smp_mb_send4_end: + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_MB); + + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_XCHG_PTR + | WRITE_PROC_FIRST_WAIT + | WRITE_PROC_SECOND_WAIT + | WRITE_PROC_WMB /* No dependency on + * WRITE_DATA because we + * write to a + * different location. */ + | WRITE_PROC_SECOND_MB + | WRITE_PROC_FIRST_MB, + WRITE_FREE) -> + WRITE_CACHED_VAR(rcu_data[old_data], POISON); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_FREE); + + :: CONSUME_TOKENS(proc_urcu_writer, WRITE_PROC_ALL_TOKENS, 0) -> + CLEAR_TOKENS(proc_urcu_writer, WRITE_PROC_ALL_TOKENS_CLEAR); + break; + fi; + } + od; + /* + * Note : Promela model adds implicit serialization of the + * WRITE_FREE instruction. Normally, it would be permitted to + * spill on the next loop execution. Given the validation we do + * checks for the data entry read to be poisoned, it's ok if + * we do not check "late arriving" memory poisoning. + */ + :: else -> break; + od; + /* + * Given the reader loops infinitely, let the writer also busy-loop + * with progress here so, with weak fairness, we can test the + * writer's progress. + */ +end_writer: + do + :: 1 -> +#ifdef WRITER_PROGRESS +progress_writer2: +#endif +#ifdef READER_PROGRESS + /* + * Make sure we don't block the reader's progress. + */ + smp_mb_send(i, j, 5); +#endif + skip; + od; + + /* Non-atomic parts of the loop */ + goto end; +smp_mb_send1: + smp_mb_send(i, j, 1); + goto smp_mb_send1_end; +#ifndef GEN_ERROR_WRITER_PROGRESS +smp_mb_send2: + smp_mb_send(i, j, 2); + goto smp_mb_send2_end; +smp_mb_send3: + smp_mb_send(i, j, 3); + goto smp_mb_send3_end; +#endif +smp_mb_send4: + smp_mb_send(i, j, 4); + goto smp_mb_send4_end; +end: + skip; +} + +/* no name clash please */ +#undef proc_urcu_writer + + +/* Leave after the readers and writers so the pid count is ok. */ +init { + byte i, j; + + atomic { + INIT_CACHED_VAR(urcu_gp_ctr, 1, j); + INIT_CACHED_VAR(rcu_ptr, 0, j); + + i = 0; + do + :: i < NR_READERS -> + INIT_CACHED_VAR(urcu_active_readers[i], 0, j); + ptr_read_first[i] = 1; + ptr_read_second[i] = 1; + data_read_first[i] = WINE; + data_read_second[i] = WINE; + i++; + :: i >= NR_READERS -> break + od; + INIT_CACHED_VAR(rcu_data[0], WINE, j); + i = 1; + do + :: i < SLAB_SIZE -> + INIT_CACHED_VAR(rcu_data[i], POISON, j); + i++ + :: i >= SLAB_SIZE -> break + od; + + init_done = 1; + } +} diff --git a/formal-model/results/urcu-controldataflow-ipi-intel/urcu_free_no_wmb.define b/formal-model/results/urcu-controldataflow-ipi-intel/urcu_free_no_wmb.define new file mode 100644 index 0000000..710f29d --- /dev/null +++ b/formal-model/results/urcu-controldataflow-ipi-intel/urcu_free_no_wmb.define @@ -0,0 +1 @@ +#define NO_WMB diff --git a/formal-model/results/urcu-controldataflow-ipi-intel/urcu_free_no_wmb.log b/formal-model/results/urcu-controldataflow-ipi-intel/urcu_free_no_wmb.log new file mode 100644 index 0000000..9422810 --- /dev/null +++ b/formal-model/results/urcu-controldataflow-ipi-intel/urcu_free_no_wmb.log @@ -0,0 +1,511 @@ +make[1]: Entering directory `/home/compudj/doc/userspace-rcu/formal-model/urcu-controldataflow' +rm -f pan* trail.out .input.spin* *.spin.trail .input.define +touch .input.define +cat .input.define >> pan.ltl +cat DEFINES >> pan.ltl +spin -f "!(`cat urcu_free.ltl | grep -v ^//`)" >> pan.ltl +cp urcu_free_no_wmb.define .input.define +cat .input.define > .input.spin +cat DEFINES >> .input.spin +cat urcu.spin >> .input.spin +rm -f .input.spin.trail +spin -a -X -N pan.ltl .input.spin +Exit-Status 0 +gcc -O2 -w -DHASH64 -o pan pan.c +./pan -a -v -c1 -X -m10000000 -w20 +warning: for p.o. reduction to be valid the never claim must be stutter-invariant +(never claims generated from LTL formulae are stutter-invariant) +depth 0: Claim reached state 5 (line 1272) +Depth= 6716 States= 1e+06 Transitions= 5.89e+06 Memory= 550.432 t= 14.4 R= 7e+04 +Depth= 6716 States= 2e+06 Transitions= 1.63e+07 Memory= 634.318 t= 42.7 R= 5e+04 +Depth= 6716 States= 3e+06 Transitions= 2.25e+07 Memory= 718.303 t= 58.7 R= 5e+04 +pan: resizing hashtable to -w22.. done +Depth= 6716 States= 4e+06 Transitions= 3.22e+07 Memory= 833.311 t= 85.5 R= 5e+04 +Depth= 6716 States= 5e+06 Transitions= 4.86e+07 Memory= 917.295 t= 132 R= 4e+04 +Depth= 6716 States= 6e+06 Transitions= 6.42e+07 Memory= 1001.279 t= 176 R= 3e+04 +Depth= 6716 States= 7e+06 Transitions= 7.63e+07 Memory= 1085.264 t= 209 R= 3e+04 +Depth= 6716 States= 8e+06 Transitions= 8.46e+07 Memory= 1169.151 t= 232 R= 3e+04 +Depth= 6716 States= 9e+06 Transitions= 9.43e+07 Memory= 1253.135 t= 259 R= 3e+04 +pan: resizing hashtable to -w24.. done +Depth= 6716 States= 1e+07 Transitions= 1.03e+08 Memory= 1461.115 t= 283 R= 4e+04 +Depth= 6716 States= 1.1e+07 Transitions= 1.15e+08 Memory= 1545.100 t= 316 R= 3e+04 +Depth= 6716 States= 1.2e+07 Transitions= 1.21e+08 Memory= 1629.084 t= 331 R= 4e+04 +pan: claim violated! (at depth 1387) +pan: wrote .input.spin.trail + +(Spin Version 5.1.7 -- 23 December 2008) +Warning: Search not completed + + Partial Order Reduction + +Full statespace search for: + never claim + + assertion violations + (if within scope of claim) + acceptance cycles + (fairness disabled) + invalid end states - (disabled by never claim) + +State-vector 88 byte, depth reached 6716, errors: 1 + 12467262 states, stored +1.1402162e+08 states, matched +1.2648888e+08 transitions (= stored+matched) +1.8978936e+09 atomic steps +hash conflicts: 82801757 (resolved) + +Stats on memory usage (in Megabytes): + 1379.206 equivalent memory usage for states (stored*(State-vector + overhead)) + 1083.262 actual memory usage for states (compression: 78.54%) + state-vector as stored = 63 byte + 28 byte overhead + 128.000 memory used for hash table (-w24) + 457.764 memory used for DFS stack (-m10000000) + 1668.342 total actual memory usage + +unreached in proctype urcu_reader + line 262, "pan.___", state 30, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 270, "pan.___", state 52, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 274, "pan.___", state 61, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 77, "(1)" + line 243, "pan.___", state 85, "(1)" + line 247, "pan.___", state 97, "(1)" + line 251, "pan.___", state 105, "(1)" + line 401, "pan.___", state 131, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 163, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 177, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 195, "(1)" + line 247, "pan.___", state 215, "(1)" + line 251, "pan.___", state 223, "(1)" + line 680, "pan.___", state 242, "_proc_urcu_reader = (_proc_urcu_reader|((1<<2)<<1))" + line 401, "pan.___", state 249, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 281, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 295, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 313, "(1)" + line 247, "pan.___", state 333, "(1)" + line 251, "pan.___", state 341, "(1)" + line 401, "pan.___", state 360, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 392, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 406, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 424, "(1)" + line 247, "pan.___", state 444, "(1)" + line 251, "pan.___", state 452, "(1)" + line 401, "pan.___", state 473, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 401, "pan.___", state 475, "(1)" + line 401, "pan.___", state 476, "((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid)))" + line 401, "pan.___", state 476, "else" + line 401, "pan.___", state 479, "(1)" + line 405, "pan.___", state 487, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 405, "pan.___", state 489, "(1)" + line 405, "pan.___", state 490, "((cache_dirty_urcu_active_readers.bitfield&(1<<_pid)))" + line 405, "pan.___", state 490, "else" + line 405, "pan.___", state 493, "(1)" + line 405, "pan.___", state 494, "(1)" + line 405, "pan.___", state 494, "(1)" + line 403, "pan.___", state 499, "((i<1))" + line 403, "pan.___", state 499, "((i>=1))" + line 410, "pan.___", state 505, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 507, "(1)" + line 410, "pan.___", state 508, "((cache_dirty_rcu_ptr.bitfield&(1<<_pid)))" + line 410, "pan.___", state 508, "else" + line 410, "pan.___", state 511, "(1)" + line 410, "pan.___", state 512, "(1)" + line 410, "pan.___", state 512, "(1)" + line 414, "pan.___", state 519, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 414, "pan.___", state 521, "(1)" + line 414, "pan.___", state 522, "((cache_dirty_rcu_data[i].bitfield&(1<<_pid)))" + line 414, "pan.___", state 522, "else" + line 414, "pan.___", state 525, "(1)" + line 414, "pan.___", state 526, "(1)" + line 414, "pan.___", state 526, "(1)" + line 412, "pan.___", state 531, "((i<2))" + line 412, "pan.___", state 531, "((i>=2))" + line 239, "pan.___", state 537, "(1)" + line 243, "pan.___", state 545, "(1)" + line 243, "pan.___", state 546, "(!((cache_dirty_urcu_active_readers.bitfield&(1<<_pid))))" + line 243, "pan.___", state 546, "else" + line 241, "pan.___", state 551, "((i<1))" + line 241, "pan.___", state 551, "((i>=1))" + line 247, "pan.___", state 557, "(1)" + line 247, "pan.___", state 558, "(!((cache_dirty_rcu_ptr.bitfield&(1<<_pid))))" + line 247, "pan.___", state 558, "else" + line 251, "pan.___", state 565, "(1)" + line 251, "pan.___", state 566, "(!((cache_dirty_rcu_data[i].bitfield&(1<<_pid))))" + line 251, "pan.___", state 566, "else" + line 249, "pan.___", state 571, "((i<2))" + line 249, "pan.___", state 571, "((i>=2))" + line 256, "pan.___", state 575, "(!((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid))))" + line 256, "pan.___", state 575, "else" + line 421, "pan.___", state 577, "(1)" + line 421, "pan.___", state 577, "(1)" + line 680, "pan.___", state 580, "cached_urcu_active_readers.val[_pid] = (tmp+1)" + line 680, "pan.___", state 581, "_proc_urcu_reader = (_proc_urcu_reader|(1<<5))" + line 680, "pan.___", state 582, "(1)" + line 401, "pan.___", state 589, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 621, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 635, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 653, "(1)" + line 247, "pan.___", state 673, "(1)" + line 251, "pan.___", state 681, "(1)" + line 401, "pan.___", state 707, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 401, "pan.___", state 709, "(1)" + line 401, "pan.___", state 710, "((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid)))" + line 401, "pan.___", state 710, "else" + line 401, "pan.___", state 713, "(1)" + line 405, "pan.___", state 721, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 405, "pan.___", state 723, "(1)" + line 405, "pan.___", state 724, "((cache_dirty_urcu_active_readers.bitfield&(1<<_pid)))" + line 405, "pan.___", state 724, "else" + line 405, "pan.___", state 727, "(1)" + line 405, "pan.___", state 728, "(1)" + line 405, "pan.___", state 728, "(1)" + line 403, "pan.___", state 733, "((i<1))" + line 403, "pan.___", state 733, "((i>=1))" + line 410, "pan.___", state 739, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 741, "(1)" + line 410, "pan.___", state 742, "((cache_dirty_rcu_ptr.bitfield&(1<<_pid)))" + line 410, "pan.___", state 742, "else" + line 410, "pan.___", state 745, "(1)" + line 410, "pan.___", state 746, "(1)" + line 410, "pan.___", state 746, "(1)" + line 414, "pan.___", state 753, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 414, "pan.___", state 755, "(1)" + line 414, "pan.___", state 756, "((cache_dirty_rcu_data[i].bitfield&(1<<_pid)))" + line 414, "pan.___", state 756, "else" + line 414, "pan.___", state 759, "(1)" + line 414, "pan.___", state 760, "(1)" + line 414, "pan.___", state 760, "(1)" + line 412, "pan.___", state 765, "((i<2))" + line 412, "pan.___", state 765, "((i>=2))" + line 239, "pan.___", state 771, "(1)" + line 243, "pan.___", state 779, "(1)" + line 243, "pan.___", state 780, "(!((cache_dirty_urcu_active_readers.bitfield&(1<<_pid))))" + line 243, "pan.___", state 780, "else" + line 241, "pan.___", state 785, "((i<1))" + line 241, "pan.___", state 785, "((i>=1))" + line 247, "pan.___", state 791, "(1)" + line 247, "pan.___", state 792, "(!((cache_dirty_rcu_ptr.bitfield&(1<<_pid))))" + line 247, "pan.___", state 792, "else" + line 251, "pan.___", state 799, "(1)" + line 251, "pan.___", state 800, "(!((cache_dirty_rcu_data[i].bitfield&(1<<_pid))))" + line 251, "pan.___", state 800, "else" + line 256, "pan.___", state 809, "(!((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid))))" + line 256, "pan.___", state 809, "else" + line 421, "pan.___", state 811, "(1)" + line 421, "pan.___", state 811, "(1)" + line 401, "pan.___", state 818, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 401, "pan.___", state 820, "(1)" + line 401, "pan.___", state 821, "((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid)))" + line 401, "pan.___", state 821, "else" + line 401, "pan.___", state 824, "(1)" + line 405, "pan.___", state 832, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 405, "pan.___", state 834, "(1)" + line 405, "pan.___", state 835, "((cache_dirty_urcu_active_readers.bitfield&(1<<_pid)))" + line 405, "pan.___", state 835, "else" + line 405, "pan.___", state 838, "(1)" + line 405, "pan.___", state 839, "(1)" + line 405, "pan.___", state 839, "(1)" + line 403, "pan.___", state 844, "((i<1))" + line 403, "pan.___", state 844, "((i>=1))" + line 410, "pan.___", state 850, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 852, "(1)" + line 410, "pan.___", state 853, "((cache_dirty_rcu_ptr.bitfield&(1<<_pid)))" + line 410, "pan.___", state 853, "else" + line 410, "pan.___", state 856, "(1)" + line 410, "pan.___", state 857, "(1)" + line 410, "pan.___", state 857, "(1)" + line 414, "pan.___", state 864, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 414, "pan.___", state 866, "(1)" + line 414, "pan.___", state 867, "((cache_dirty_rcu_data[i].bitfield&(1<<_pid)))" + line 414, "pan.___", state 867, "else" + line 414, "pan.___", state 870, "(1)" + line 414, "pan.___", state 871, "(1)" + line 414, "pan.___", state 871, "(1)" + line 412, "pan.___", state 876, "((i<2))" + line 412, "pan.___", state 876, "((i>=2))" + line 239, "pan.___", state 882, "(1)" + line 243, "pan.___", state 890, "(1)" + line 243, "pan.___", state 891, "(!((cache_dirty_urcu_active_readers.bitfield&(1<<_pid))))" + line 243, "pan.___", state 891, "else" + line 241, "pan.___", state 896, "((i<1))" + line 241, "pan.___", state 896, "((i>=1))" + line 247, "pan.___", state 902, "(1)" + line 247, "pan.___", state 903, "(!((cache_dirty_rcu_ptr.bitfield&(1<<_pid))))" + line 247, "pan.___", state 903, "else" + line 251, "pan.___", state 910, "(1)" + line 251, "pan.___", state 911, "(!((cache_dirty_rcu_data[i].bitfield&(1<<_pid))))" + line 251, "pan.___", state 911, "else" + line 249, "pan.___", state 916, "((i<2))" + line 249, "pan.___", state 916, "((i>=2))" + line 256, "pan.___", state 920, "(!((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid))))" + line 256, "pan.___", state 920, "else" + line 421, "pan.___", state 922, "(1)" + line 421, "pan.___", state 922, "(1)" + line 688, "pan.___", state 926, "_proc_urcu_reader = (_proc_urcu_reader|(1<<11))" + line 401, "pan.___", state 931, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 963, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 977, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 995, "(1)" + line 247, "pan.___", state 1015, "(1)" + line 251, "pan.___", state 1023, "(1)" + line 401, "pan.___", state 1045, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 1077, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 1091, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 1109, "(1)" + line 247, "pan.___", state 1129, "(1)" + line 251, "pan.___", state 1137, "(1)" + line 401, "pan.___", state 1160, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 1192, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 1206, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 1224, "(1)" + line 247, "pan.___", state 1244, "(1)" + line 251, "pan.___", state 1252, "(1)" + line 401, "pan.___", state 1271, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 1303, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 1317, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 1335, "(1)" + line 247, "pan.___", state 1355, "(1)" + line 251, "pan.___", state 1363, "(1)" + line 401, "pan.___", state 1387, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 1419, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 1433, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 1451, "(1)" + line 247, "pan.___", state 1471, "(1)" + line 251, "pan.___", state 1479, "(1)" + line 401, "pan.___", state 1498, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 1530, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 1544, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 1562, "(1)" + line 247, "pan.___", state 1582, "(1)" + line 251, "pan.___", state 1590, "(1)" + line 401, "pan.___", state 1612, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 1644, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 1658, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 1676, "(1)" + line 247, "pan.___", state 1696, "(1)" + line 251, "pan.___", state 1704, "(1)" + line 727, "pan.___", state 1723, "_proc_urcu_reader = (_proc_urcu_reader|((1<<2)<<19))" + line 401, "pan.___", state 1730, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 1762, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 1776, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 1794, "(1)" + line 247, "pan.___", state 1814, "(1)" + line 251, "pan.___", state 1822, "(1)" + line 401, "pan.___", state 1841, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 1873, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 1887, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 1905, "(1)" + line 247, "pan.___", state 1925, "(1)" + line 251, "pan.___", state 1933, "(1)" + line 401, "pan.___", state 1954, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 401, "pan.___", state 1956, "(1)" + line 401, "pan.___", state 1957, "((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid)))" + line 401, "pan.___", state 1957, "else" + line 401, "pan.___", state 1960, "(1)" + line 405, "pan.___", state 1968, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 405, "pan.___", state 1970, "(1)" + line 405, "pan.___", state 1971, "((cache_dirty_urcu_active_readers.bitfield&(1<<_pid)))" + line 405, "pan.___", state 1971, "else" + line 405, "pan.___", state 1974, "(1)" + line 405, "pan.___", state 1975, "(1)" + line 405, "pan.___", state 1975, "(1)" + line 403, "pan.___", state 1980, "((i<1))" + line 403, "pan.___", state 1980, "((i>=1))" + line 410, "pan.___", state 1986, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 1988, "(1)" + line 410, "pan.___", state 1989, "((cache_dirty_rcu_ptr.bitfield&(1<<_pid)))" + line 410, "pan.___", state 1989, "else" + line 410, "pan.___", state 1992, "(1)" + line 410, "pan.___", state 1993, "(1)" + line 410, "pan.___", state 1993, "(1)" + line 414, "pan.___", state 2000, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 414, "pan.___", state 2002, "(1)" + line 414, "pan.___", state 2003, "((cache_dirty_rcu_data[i].bitfield&(1<<_pid)))" + line 414, "pan.___", state 2003, "else" + line 414, "pan.___", state 2006, "(1)" + line 414, "pan.___", state 2007, "(1)" + line 414, "pan.___", state 2007, "(1)" + line 412, "pan.___", state 2012, "((i<2))" + line 412, "pan.___", state 2012, "((i>=2))" + line 239, "pan.___", state 2018, "(1)" + line 243, "pan.___", state 2026, "(1)" + line 243, "pan.___", state 2027, "(!((cache_dirty_urcu_active_readers.bitfield&(1<<_pid))))" + line 243, "pan.___", state 2027, "else" + line 241, "pan.___", state 2032, "((i<1))" + line 241, "pan.___", state 2032, "((i>=1))" + line 247, "pan.___", state 2038, "(1)" + line 247, "pan.___", state 2039, "(!((cache_dirty_rcu_ptr.bitfield&(1<<_pid))))" + line 247, "pan.___", state 2039, "else" + line 251, "pan.___", state 2046, "(1)" + line 251, "pan.___", state 2047, "(!((cache_dirty_rcu_data[i].bitfield&(1<<_pid))))" + line 251, "pan.___", state 2047, "else" + line 249, "pan.___", state 2052, "((i<2))" + line 249, "pan.___", state 2052, "((i>=2))" + line 256, "pan.___", state 2056, "(!((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid))))" + line 256, "pan.___", state 2056, "else" + line 421, "pan.___", state 2058, "(1)" + line 421, "pan.___", state 2058, "(1)" + line 727, "pan.___", state 2061, "cached_urcu_active_readers.val[_pid] = (tmp+1)" + line 727, "pan.___", state 2062, "_proc_urcu_reader = (_proc_urcu_reader|(1<<23))" + line 727, "pan.___", state 2063, "(1)" + line 401, "pan.___", state 2070, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 2102, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 2116, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 2134, "(1)" + line 247, "pan.___", state 2154, "(1)" + line 251, "pan.___", state 2162, "(1)" + line 401, "pan.___", state 2187, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 2219, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 2233, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 2251, "(1)" + line 247, "pan.___", state 2271, "(1)" + line 251, "pan.___", state 2279, "(1)" + line 401, "pan.___", state 2298, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 2330, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 2344, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 2362, "(1)" + line 247, "pan.___", state 2382, "(1)" + line 251, "pan.___", state 2390, "(1)" + line 239, "pan.___", state 2421, "(1)" + line 247, "pan.___", state 2441, "(1)" + line 251, "pan.___", state 2449, "(1)" + line 239, "pan.___", state 2464, "(1)" + line 247, "pan.___", state 2484, "(1)" + line 251, "pan.___", state 2492, "(1)" + line 887, "pan.___", state 2509, "-end-" + (246 of 2509 states) +unreached in proctype urcu_writer + line 401, "pan.___", state 19, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 405, "pan.___", state 33, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 239, "pan.___", state 83, "(1)" + line 243, "pan.___", state 91, "(1)" + line 262, "pan.___", state 132, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 262, "pan.___", state 134, "(1)" + line 266, "pan.___", state 141, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 266, "pan.___", state 143, "(1)" + line 266, "pan.___", state 144, "((cache_dirty_urcu_active_readers.bitfield&(1<<_pid)))" + line 266, "pan.___", state 144, "else" + line 264, "pan.___", state 149, "((i<1))" + line 264, "pan.___", state 149, "((i>=1))" + line 270, "pan.___", state 154, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 270, "pan.___", state 156, "(1)" + line 270, "pan.___", state 157, "((cache_dirty_rcu_ptr.bitfield&(1<<_pid)))" + line 270, "pan.___", state 157, "else" + line 274, "pan.___", state 163, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 274, "pan.___", state 165, "(1)" + line 274, "pan.___", state 166, "((cache_dirty_rcu_data[i].bitfield&(1<<_pid)))" + line 274, "pan.___", state 166, "else" + line 279, "pan.___", state 175, "((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid)))" + line 279, "pan.___", state 175, "else" + line 401, "pan.___", state 194, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 405, "pan.___", state 208, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 226, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 240, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 258, "(1)" + line 243, "pan.___", state 266, "(1)" + line 247, "pan.___", state 278, "(1)" + line 251, "pan.___", state 286, "(1)" + line 405, "pan.___", state 321, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 339, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 353, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 243, "pan.___", state 379, "(1)" + line 247, "pan.___", state 391, "(1)" + line 251, "pan.___", state 399, "(1)" + line 405, "pan.___", state 441, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 459, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 473, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 243, "pan.___", state 499, "(1)" + line 247, "pan.___", state 511, "(1)" + line 251, "pan.___", state 519, "(1)" + line 405, "pan.___", state 552, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 570, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 584, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 243, "pan.___", state 610, "(1)" + line 247, "pan.___", state 622, "(1)" + line 251, "pan.___", state 630, "(1)" + line 405, "pan.___", state 665, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 683, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 697, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 243, "pan.___", state 723, "(1)" + line 247, "pan.___", state 735, "(1)" + line 251, "pan.___", state 743, "(1)" + line 262, "pan.___", state 796, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 266, "pan.___", state 805, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 239, "pan.___", state 843, "(1)" + line 243, "pan.___", state 851, "(1)" + line 247, "pan.___", state 863, "(1)" + line 251, "pan.___", state 871, "(1)" + line 262, "pan.___", state 902, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 266, "pan.___", state 911, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 270, "pan.___", state 924, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 274, "pan.___", state 933, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 949, "(1)" + line 243, "pan.___", state 957, "(1)" + line 247, "pan.___", state 969, "(1)" + line 251, "pan.___", state 977, "(1)" + line 266, "pan.___", state 1003, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 270, "pan.___", state 1016, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 274, "pan.___", state 1025, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 1041, "(1)" + line 243, "pan.___", state 1049, "(1)" + line 247, "pan.___", state 1061, "(1)" + line 251, "pan.___", state 1069, "(1)" + line 262, "pan.___", state 1100, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 266, "pan.___", state 1109, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 270, "pan.___", state 1122, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 274, "pan.___", state 1131, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 1147, "(1)" + line 243, "pan.___", state 1155, "(1)" + line 247, "pan.___", state 1167, "(1)" + line 251, "pan.___", state 1175, "(1)" + line 266, "pan.___", state 1201, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 270, "pan.___", state 1214, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 274, "pan.___", state 1223, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 1239, "(1)" + line 243, "pan.___", state 1247, "(1)" + line 247, "pan.___", state 1259, "(1)" + line 251, "pan.___", state 1267, "(1)" + line 262, "pan.___", state 1298, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 266, "pan.___", state 1307, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 270, "pan.___", state 1320, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 274, "pan.___", state 1329, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 1345, "(1)" + line 243, "pan.___", state 1353, "(1)" + line 247, "pan.___", state 1365, "(1)" + line 251, "pan.___", state 1373, "(1)" + line 266, "pan.___", state 1399, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 270, "pan.___", state 1412, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 274, "pan.___", state 1421, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 1437, "(1)" + line 243, "pan.___", state 1445, "(1)" + line 247, "pan.___", state 1457, "(1)" + line 251, "pan.___", state 1465, "(1)" + line 262, "pan.___", state 1496, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 266, "pan.___", state 1505, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 270, "pan.___", state 1518, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 274, "pan.___", state 1527, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 1543, "(1)" + line 243, "pan.___", state 1551, "(1)" + line 247, "pan.___", state 1563, "(1)" + line 251, "pan.___", state 1571, "(1)" + line 1214, "pan.___", state 1587, "-end-" + (109 of 1587 states) +unreached in proctype :init: + line 1225, "pan.___", state 9, "((j<2))" + line 1225, "pan.___", state 9, "((j>=2))" + line 1226, "pan.___", state 20, "((j<2))" + line 1226, "pan.___", state 20, "((j>=2))" + line 1231, "pan.___", state 33, "((j<2))" + line 1231, "pan.___", state 33, "((j>=2))" + line 1229, "pan.___", state 43, "((i<1))" + line 1229, "pan.___", state 43, "((i>=1))" + line 1239, "pan.___", state 54, "((j<2))" + line 1239, "pan.___", state 54, "((j>=2))" + line 1243, "pan.___", state 67, "((j<2))" + line 1243, "pan.___", state 67, "((j>=2))" + (6 of 78 states) +unreached in proctype :never: + line 1277, "pan.___", state 8, "-end-" + (1 of 8 states) + +pan: elapsed time 346 seconds +pan: rate 36012.773 states/second +pan: avg transition delay 2.7369e-06 usec +cp .input.spin urcu_free_no_wmb.spin.input +cp .input.spin.trail urcu_free_no_wmb.spin.input.trail +make[1]: Leaving directory `/home/compudj/doc/userspace-rcu/formal-model/urcu-controldataflow' diff --git a/formal-model/results/urcu-controldataflow-ipi-intel/urcu_free_no_wmb.spin.input b/formal-model/results/urcu-controldataflow-ipi-intel/urcu_free_no_wmb.spin.input new file mode 100644 index 0000000..07b3110 --- /dev/null +++ b/formal-model/results/urcu-controldataflow-ipi-intel/urcu_free_no_wmb.spin.input @@ -0,0 +1,1250 @@ +#define NO_WMB + +// Poison value for freed memory +#define POISON 1 +// Memory with correct data +#define WINE 0 +#define SLAB_SIZE 2 + +#define read_poison (data_read_first[0] == POISON || data_read_second[0] == POISON) + +#define RCU_GP_CTR_BIT (1 << 7) +#define RCU_GP_CTR_NEST_MASK (RCU_GP_CTR_BIT - 1) + +//disabled +#define REMOTE_BARRIERS + +//#define ARCH_ALPHA +#define ARCH_INTEL +//#define ARCH_POWERPC +/* + * mem.spin: Promela code to validate memory barriers with OOO memory + * and out-of-order instruction scheduling. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * Copyright (c) 2009 Mathieu Desnoyers + */ + +/* Promela validation variables. */ + +/* specific defines "included" here */ +/* DEFINES file "included" here */ + +#define NR_READERS 1 +#define NR_WRITERS 1 + +#define NR_PROCS 2 + +#define get_pid() (_pid) + +#define get_readerid() (get_pid()) + +/* + * Produced process control and data flow. Updated after each instruction to + * show which variables are ready. Using one-hot bit encoding per variable to + * save state space. Used as triggers to execute the instructions having those + * variables as input. Leaving bits active to inhibit instruction execution. + * Scheme used to make instruction disabling and automatic dependency fall-back + * automatic. + */ + +#define CONSUME_TOKENS(state, bits, notbits) \ + ((!(state & (notbits))) && (state & (bits)) == (bits)) + +#define PRODUCE_TOKENS(state, bits) \ + state = state | (bits); + +#define CLEAR_TOKENS(state, bits) \ + state = state & ~(bits) + +/* + * Types of dependency : + * + * Data dependency + * + * - True dependency, Read-after-Write (RAW) + * + * This type of dependency happens when a statement depends on the result of a + * previous statement. This applies to any statement which needs to read a + * variable written by a preceding statement. + * + * - False dependency, Write-after-Read (WAR) + * + * Typically, variable renaming can ensure that this dependency goes away. + * However, if the statements must read and then write from/to the same variable + * in the OOO memory model, renaming may be impossible, and therefore this + * causes a WAR dependency. + * + * - Output dependency, Write-after-Write (WAW) + * + * Two writes to the same variable in subsequent statements. Variable renaming + * can ensure this is not needed, but can be required when writing multiple + * times to the same OOO mem model variable. + * + * Control dependency + * + * Execution of a given instruction depends on a previous instruction evaluating + * in a way that allows its execution. E.g. : branches. + * + * Useful considerations for joining dependencies after branch + * + * - Pre-dominance + * + * "We say box i dominates box j if every path (leading from input to output + * through the diagram) which passes through box j must also pass through box + * i. Thus box i dominates box j if box j is subordinate to box i in the + * program." + * + * http://www.hipersoft.rice.edu/grads/publications/dom14.pdf + * Other classic algorithm to calculate dominance : Lengauer-Tarjan (in gcc) + * + * - Post-dominance + * + * Just as pre-dominance, but with arcs of the data flow inverted, and input vs + * output exchanged. Therefore, i post-dominating j ensures that every path + * passing by j will pass by i before reaching the output. + * + * Other considerations + * + * Note about "volatile" keyword dependency : The compiler will order volatile + * accesses so they appear in the right order on a given CPU. They can be + * reordered by the CPU instruction scheduling. This therefore cannot be + * considered as a depencency. + * + * References : + * + * Cooper, Keith D.; & Torczon, Linda. (2005). Engineering a Compiler. Morgan + * Kaufmann. ISBN 1-55860-698-X. + * Kennedy, Ken; & Allen, Randy. (2001). Optimizing Compilers for Modern + * Architectures: A Dependence-based Approach. Morgan Kaufmann. ISBN + * 1-55860-286-0. + * Muchnick, Steven S. (1997). Advanced Compiler Design and Implementation. + * Morgan Kaufmann. ISBN 1-55860-320-4. + */ + +/* + * Note about loops and nested calls + * + * To keep this model simple, loops expressed in the framework will behave as if + * there was a core synchronizing instruction between loops. To see the effect + * of loop unrolling, manually unrolling loops is required. Note that if loops + * end or start with a core synchronizing instruction, the model is appropriate. + * Nested calls are not supported. + */ + +/* + * Only Alpha has out-of-order cache bank loads. Other architectures (intel, + * powerpc, arm) ensure that dependent reads won't be reordered. c.f. + * http://www.linuxjournal.com/article/8212) +#ifdef ARCH_ALPHA +#define HAVE_OOO_CACHE_READ +#endif + +/* + * Each process have its own data in cache. Caches are randomly updated. + * smp_wmb and smp_rmb forces cache updates (write and read), smp_mb forces + * both. + */ + +typedef per_proc_byte { + byte val[NR_PROCS]; +}; + +typedef per_proc_bit { + bit val[NR_PROCS]; +}; + +/* Bitfield has a maximum of 8 procs */ +typedef per_proc_bitfield { + byte bitfield; +}; + +#define DECLARE_CACHED_VAR(type, x) \ + type mem_##x; \ + per_proc_##type cached_##x; \ + per_proc_bitfield cache_dirty_##x; + +#define INIT_CACHED_VAR(x, v, j) \ + mem_##x = v; \ + cache_dirty_##x.bitfield = 0; \ + j = 0; \ + do \ + :: j < NR_PROCS -> \ + cached_##x.val[j] = v; \ + j++ \ + :: j >= NR_PROCS -> break \ + od; + +#define IS_CACHE_DIRTY(x, id) (cache_dirty_##x.bitfield & (1 << id)) + +#define READ_CACHED_VAR(x) (cached_##x.val[get_pid()]) + +#define WRITE_CACHED_VAR(x, v) \ + atomic { \ + cached_##x.val[get_pid()] = v; \ + cache_dirty_##x.bitfield = \ + cache_dirty_##x.bitfield | (1 << get_pid()); \ + } + +#define CACHE_WRITE_TO_MEM(x, id) \ + if \ + :: IS_CACHE_DIRTY(x, id) -> \ + mem_##x = cached_##x.val[id]; \ + cache_dirty_##x.bitfield = \ + cache_dirty_##x.bitfield & (~(1 << id)); \ + :: else -> \ + skip \ + fi; + +#define CACHE_READ_FROM_MEM(x, id) \ + if \ + :: !IS_CACHE_DIRTY(x, id) -> \ + cached_##x.val[id] = mem_##x;\ + :: else -> \ + skip \ + fi; + +/* + * May update other caches if cache is dirty, or not. + */ +#define RANDOM_CACHE_WRITE_TO_MEM(x, id)\ + if \ + :: 1 -> CACHE_WRITE_TO_MEM(x, id); \ + :: 1 -> skip \ + fi; + +#define RANDOM_CACHE_READ_FROM_MEM(x, id)\ + if \ + :: 1 -> CACHE_READ_FROM_MEM(x, id); \ + :: 1 -> skip \ + fi; + +/* Must consume all prior read tokens. All subsequent reads depend on it. */ +inline smp_rmb(i) +{ + atomic { + CACHE_READ_FROM_MEM(urcu_gp_ctr, get_pid()); + i = 0; + do + :: i < NR_READERS -> + CACHE_READ_FROM_MEM(urcu_active_readers[i], get_pid()); + i++ + :: i >= NR_READERS -> break + od; + CACHE_READ_FROM_MEM(rcu_ptr, get_pid()); + i = 0; + do + :: i < SLAB_SIZE -> + CACHE_READ_FROM_MEM(rcu_data[i], get_pid()); + i++ + :: i >= SLAB_SIZE -> break + od; + } +} + +/* Must consume all prior write tokens. All subsequent writes depend on it. */ +inline smp_wmb(i) +{ + atomic { + CACHE_WRITE_TO_MEM(urcu_gp_ctr, get_pid()); + i = 0; + do + :: i < NR_READERS -> + CACHE_WRITE_TO_MEM(urcu_active_readers[i], get_pid()); + i++ + :: i >= NR_READERS -> break + od; + CACHE_WRITE_TO_MEM(rcu_ptr, get_pid()); + i = 0; + do + :: i < SLAB_SIZE -> + CACHE_WRITE_TO_MEM(rcu_data[i], get_pid()); + i++ + :: i >= SLAB_SIZE -> break + od; + } +} + +/* Synchronization point. Must consume all prior read and write tokens. All + * subsequent reads and writes depend on it. */ +inline smp_mb(i) +{ + atomic { + smp_wmb(i); + smp_rmb(i); + } +} + +#ifdef REMOTE_BARRIERS + +bit reader_barrier[NR_READERS]; + +/* + * We cannot leave the barriers dependencies in place in REMOTE_BARRIERS mode + * because they would add unexisting core synchronization and would therefore + * create an incomplete model. + * Therefore, we model the read-side memory barriers by completely disabling the + * memory barriers and their dependencies from the read-side. One at a time + * (different verification runs), we make a different instruction listen for + * signals. + */ + +#define smp_mb_reader(i, j) + +/* + * Service 0, 1 or many barrier requests. + */ +inline smp_mb_recv(i, j) +{ + do + :: (reader_barrier[get_readerid()] == 1) -> + /* + * We choose to ignore cycles caused by writer busy-looping, + * waiting for the reader, sending barrier requests, and the + * reader always services them without continuing execution. + */ +progress_ignoring_mb1: + smp_mb(i); + reader_barrier[get_readerid()] = 0; + :: 1 -> + /* + * We choose to ignore writer's non-progress caused by the + * reader ignoring the writer's mb() requests. + */ +progress_ignoring_mb2: + break; + od; +} + +#define PROGRESS_LABEL(progressid) progress_writer_progid_##progressid: + +#define smp_mb_send(i, j, progressid) \ +{ \ + smp_mb(i); \ + i = 0; \ + do \ + :: i < NR_READERS -> \ + reader_barrier[i] = 1; \ + /* \ + * Busy-looping waiting for reader barrier handling is of little\ + * interest, given the reader has the ability to totally ignore \ + * barrier requests. \ + */ \ + do \ + :: (reader_barrier[i] == 1) -> \ +PROGRESS_LABEL(progressid) \ + skip; \ + :: (reader_barrier[i] == 0) -> break; \ + od; \ + i++; \ + :: i >= NR_READERS -> \ + break \ + od; \ + smp_mb(i); \ +} + +#else + +#define smp_mb_send(i, j, progressid) smp_mb(i) +#define smp_mb_reader smp_mb(i) +#define smp_mb_recv(i, j) + +#endif + +/* Keep in sync manually with smp_rmb, smp_wmb, ooo_mem and init() */ +DECLARE_CACHED_VAR(byte, urcu_gp_ctr); +/* Note ! currently only one reader */ +DECLARE_CACHED_VAR(byte, urcu_active_readers[NR_READERS]); +/* RCU data */ +DECLARE_CACHED_VAR(bit, rcu_data[SLAB_SIZE]); + +/* RCU pointer */ +#if (SLAB_SIZE == 2) +DECLARE_CACHED_VAR(bit, rcu_ptr); +bit ptr_read_first[NR_READERS]; +bit ptr_read_second[NR_READERS]; +#else +DECLARE_CACHED_VAR(byte, rcu_ptr); +byte ptr_read_first[NR_READERS]; +byte ptr_read_second[NR_READERS]; +#endif + +bit data_read_first[NR_READERS]; +bit data_read_second[NR_READERS]; + +bit init_done = 0; + +inline wait_init_done() +{ + do + :: init_done == 0 -> skip; + :: else -> break; + od; +} + +inline ooo_mem(i) +{ + atomic { + RANDOM_CACHE_WRITE_TO_MEM(urcu_gp_ctr, get_pid()); + i = 0; + do + :: i < NR_READERS -> + RANDOM_CACHE_WRITE_TO_MEM(urcu_active_readers[i], + get_pid()); + i++ + :: i >= NR_READERS -> break + od; + RANDOM_CACHE_WRITE_TO_MEM(rcu_ptr, get_pid()); + i = 0; + do + :: i < SLAB_SIZE -> + RANDOM_CACHE_WRITE_TO_MEM(rcu_data[i], get_pid()); + i++ + :: i >= SLAB_SIZE -> break + od; +#ifdef HAVE_OOO_CACHE_READ + RANDOM_CACHE_READ_FROM_MEM(urcu_gp_ctr, get_pid()); + i = 0; + do + :: i < NR_READERS -> + RANDOM_CACHE_READ_FROM_MEM(urcu_active_readers[i], + get_pid()); + i++ + :: i >= NR_READERS -> break + od; + RANDOM_CACHE_READ_FROM_MEM(rcu_ptr, get_pid()); + i = 0; + do + :: i < SLAB_SIZE -> + RANDOM_CACHE_READ_FROM_MEM(rcu_data[i], get_pid()); + i++ + :: i >= SLAB_SIZE -> break + od; +#else + smp_rmb(i); +#endif /* HAVE_OOO_CACHE_READ */ + } +} + +/* + * Bit encoding, urcu_reader : + */ + +int _proc_urcu_reader; +#define proc_urcu_reader _proc_urcu_reader + +/* Body of PROCEDURE_READ_LOCK */ +#define READ_PROD_A_READ (1 << 0) +#define READ_PROD_B_IF_TRUE (1 << 1) +#define READ_PROD_B_IF_FALSE (1 << 2) +#define READ_PROD_C_IF_TRUE_READ (1 << 3) + +#define PROCEDURE_READ_LOCK(base, consumetoken, producetoken) \ + :: CONSUME_TOKENS(proc_urcu_reader, consumetoken, READ_PROD_A_READ << base) -> \ + ooo_mem(i); \ + tmp = READ_CACHED_VAR(urcu_active_readers[get_readerid()]); \ + PRODUCE_TOKENS(proc_urcu_reader, READ_PROD_A_READ << base); \ + :: CONSUME_TOKENS(proc_urcu_reader, \ + READ_PROD_A_READ << base, /* RAW, pre-dominant */ \ + (READ_PROD_B_IF_TRUE | READ_PROD_B_IF_FALSE) << base) -> \ + if \ + :: (!(tmp & RCU_GP_CTR_NEST_MASK)) -> \ + PRODUCE_TOKENS(proc_urcu_reader, READ_PROD_B_IF_TRUE << base); \ + :: else -> \ + PRODUCE_TOKENS(proc_urcu_reader, READ_PROD_B_IF_FALSE << base); \ + fi; \ + /* IF TRUE */ \ + :: CONSUME_TOKENS(proc_urcu_reader, READ_PROD_B_IF_TRUE << base, \ + READ_PROD_C_IF_TRUE_READ << base) -> \ + ooo_mem(i); \ + tmp2 = READ_CACHED_VAR(urcu_gp_ctr); \ + PRODUCE_TOKENS(proc_urcu_reader, READ_PROD_C_IF_TRUE_READ << base); \ + :: CONSUME_TOKENS(proc_urcu_reader, \ + (READ_PROD_C_IF_TRUE_READ /* pre-dominant */ \ + | READ_PROD_A_READ) << base, /* WAR */ \ + producetoken) -> \ + ooo_mem(i); \ + WRITE_CACHED_VAR(urcu_active_readers[get_readerid()], tmp2); \ + PRODUCE_TOKENS(proc_urcu_reader, producetoken); \ + /* IF_MERGE implies \ + * post-dominance */ \ + /* ELSE */ \ + :: CONSUME_TOKENS(proc_urcu_reader, \ + (READ_PROD_B_IF_FALSE /* pre-dominant */ \ + | READ_PROD_A_READ) << base, /* WAR */ \ + producetoken) -> \ + ooo_mem(i); \ + WRITE_CACHED_VAR(urcu_active_readers[get_readerid()], \ + tmp + 1); \ + PRODUCE_TOKENS(proc_urcu_reader, producetoken); \ + /* IF_MERGE implies \ + * post-dominance */ \ + /* ENDIF */ \ + skip + +/* Body of PROCEDURE_READ_LOCK */ +#define READ_PROC_READ_UNLOCK (1 << 0) + +#define PROCEDURE_READ_UNLOCK(base, consumetoken, producetoken) \ + :: CONSUME_TOKENS(proc_urcu_reader, \ + consumetoken, \ + READ_PROC_READ_UNLOCK << base) -> \ + ooo_mem(i); \ + tmp2 = READ_CACHED_VAR(urcu_active_readers[get_readerid()]); \ + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_READ_UNLOCK << base); \ + :: CONSUME_TOKENS(proc_urcu_reader, \ + consumetoken \ + | (READ_PROC_READ_UNLOCK << base), /* WAR */ \ + producetoken) -> \ + ooo_mem(i); \ + WRITE_CACHED_VAR(urcu_active_readers[get_readerid()], tmp2 - 1); \ + PRODUCE_TOKENS(proc_urcu_reader, producetoken); \ + skip + + +#define READ_PROD_NONE (1 << 0) + +/* PROCEDURE_READ_LOCK base = << 1 : 1 to 5 */ +#define READ_LOCK_BASE 1 +#define READ_LOCK_OUT (1 << 5) + +#define READ_PROC_FIRST_MB (1 << 6) + +/* PROCEDURE_READ_LOCK (NESTED) base : << 7 : 7 to 11 */ +#define READ_LOCK_NESTED_BASE 7 +#define READ_LOCK_NESTED_OUT (1 << 11) + +#define READ_PROC_READ_GEN (1 << 12) +#define READ_PROC_ACCESS_GEN (1 << 13) + +/* PROCEDURE_READ_UNLOCK (NESTED) base = << 14 : 14 to 15 */ +#define READ_UNLOCK_NESTED_BASE 14 +#define READ_UNLOCK_NESTED_OUT (1 << 15) + +#define READ_PROC_SECOND_MB (1 << 16) + +/* PROCEDURE_READ_UNLOCK base = << 17 : 17 to 18 */ +#define READ_UNLOCK_BASE 17 +#define READ_UNLOCK_OUT (1 << 18) + +/* PROCEDURE_READ_LOCK_UNROLL base = << 19 : 19 to 23 */ +#define READ_LOCK_UNROLL_BASE 19 +#define READ_LOCK_OUT_UNROLL (1 << 23) + +#define READ_PROC_THIRD_MB (1 << 24) + +#define READ_PROC_READ_GEN_UNROLL (1 << 25) +#define READ_PROC_ACCESS_GEN_UNROLL (1 << 26) + +#define READ_PROC_FOURTH_MB (1 << 27) + +/* PROCEDURE_READ_UNLOCK_UNROLL base = << 28 : 28 to 29 */ +#define READ_UNLOCK_UNROLL_BASE 28 +#define READ_UNLOCK_OUT_UNROLL (1 << 29) + + +/* Should not include branches */ +#define READ_PROC_ALL_TOKENS (READ_PROD_NONE \ + | READ_LOCK_OUT \ + | READ_PROC_FIRST_MB \ + | READ_LOCK_NESTED_OUT \ + | READ_PROC_READ_GEN \ + | READ_PROC_ACCESS_GEN \ + | READ_UNLOCK_NESTED_OUT \ + | READ_PROC_SECOND_MB \ + | READ_UNLOCK_OUT \ + | READ_LOCK_OUT_UNROLL \ + | READ_PROC_THIRD_MB \ + | READ_PROC_READ_GEN_UNROLL \ + | READ_PROC_ACCESS_GEN_UNROLL \ + | READ_PROC_FOURTH_MB \ + | READ_UNLOCK_OUT_UNROLL) + +/* Must clear all tokens, including branches */ +#define READ_PROC_ALL_TOKENS_CLEAR ((1 << 30) - 1) + +inline urcu_one_read(i, j, nest_i, tmp, tmp2) +{ + PRODUCE_TOKENS(proc_urcu_reader, READ_PROD_NONE); + +#ifdef NO_MB + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_FIRST_MB); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_SECOND_MB); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_THIRD_MB); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_FOURTH_MB); +#endif + +#ifdef REMOTE_BARRIERS + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_FIRST_MB); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_SECOND_MB); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_THIRD_MB); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_FOURTH_MB); +#endif + + do + :: 1 -> + +#ifdef REMOTE_BARRIERS + /* + * Signal-based memory barrier will only execute when the + * execution order appears in program order. + */ + if + :: 1 -> + atomic { + if + :: CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE, + READ_LOCK_OUT | READ_LOCK_NESTED_OUT + | READ_PROC_READ_GEN | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT + | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT, + READ_LOCK_NESTED_OUT + | READ_PROC_READ_GEN | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT + | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT | READ_LOCK_NESTED_OUT, + READ_PROC_READ_GEN | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT + | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN, + READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT + | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN | READ_PROC_ACCESS_GEN, + READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT + | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN + | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT, + READ_UNLOCK_OUT + | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN + | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT, + READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN + | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT | READ_LOCK_OUT_UNROLL, + READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN + | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL, + READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN + | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL, + READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL, + 0) -> + goto non_atomic3; +non_atomic3_end: + skip; + fi; + } + fi; + + goto non_atomic3_skip; +non_atomic3: + smp_mb_recv(i, j); + goto non_atomic3_end; +non_atomic3_skip: + +#endif /* REMOTE_BARRIERS */ + + atomic { + if + PROCEDURE_READ_LOCK(READ_LOCK_BASE, READ_PROD_NONE, READ_LOCK_OUT); + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_LOCK_OUT, /* post-dominant */ + READ_PROC_FIRST_MB) -> + smp_mb_reader(i, j); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_FIRST_MB); + + PROCEDURE_READ_LOCK(READ_LOCK_NESTED_BASE, READ_PROC_FIRST_MB | READ_LOCK_OUT, + READ_LOCK_NESTED_OUT); + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_PROC_FIRST_MB, /* mb() orders reads */ + READ_PROC_READ_GEN) -> + ooo_mem(i); + ptr_read_first[get_readerid()] = READ_CACHED_VAR(rcu_ptr); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_READ_GEN); + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_PROC_FIRST_MB /* mb() orders reads */ + | READ_PROC_READ_GEN, + READ_PROC_ACCESS_GEN) -> + /* smp_read_barrier_depends */ + goto rmb1; +rmb1_end: + data_read_first[get_readerid()] = + READ_CACHED_VAR(rcu_data[ptr_read_first[get_readerid()]]); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_ACCESS_GEN); + + + /* Note : we remove the nested memory barrier from the read unlock + * model, given it is not usually needed. The implementation has the barrier + * because the performance impact added by a branch in the common case does not + * justify it. + */ + + PROCEDURE_READ_UNLOCK(READ_UNLOCK_NESTED_BASE, + READ_PROC_FIRST_MB + | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT, + READ_UNLOCK_NESTED_OUT); + + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_PROC_ACCESS_GEN /* mb() orders reads */ + | READ_PROC_READ_GEN /* mb() orders reads */ + | READ_PROC_FIRST_MB /* mb() ordered */ + | READ_LOCK_OUT /* post-dominant */ + | READ_LOCK_NESTED_OUT /* post-dominant */ + | READ_UNLOCK_NESTED_OUT, + READ_PROC_SECOND_MB) -> + smp_mb_reader(i, j); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_SECOND_MB); + + PROCEDURE_READ_UNLOCK(READ_UNLOCK_BASE, + READ_PROC_SECOND_MB /* mb() orders reads */ + | READ_PROC_FIRST_MB /* mb() orders reads */ + | READ_LOCK_NESTED_OUT /* RAW */ + | READ_LOCK_OUT /* RAW */ + | READ_UNLOCK_NESTED_OUT, /* RAW */ + READ_UNLOCK_OUT); + + /* Unrolling loop : second consecutive lock */ + /* reading urcu_active_readers, which have been written by + * READ_UNLOCK_OUT : RAW */ + PROCEDURE_READ_LOCK(READ_LOCK_UNROLL_BASE, + READ_UNLOCK_OUT /* RAW */ + | READ_PROC_SECOND_MB /* mb() orders reads */ + | READ_PROC_FIRST_MB /* mb() orders reads */ + | READ_LOCK_NESTED_OUT /* RAW */ + | READ_LOCK_OUT /* RAW */ + | READ_UNLOCK_NESTED_OUT, /* RAW */ + READ_LOCK_OUT_UNROLL); + + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_PROC_FIRST_MB /* mb() ordered */ + | READ_PROC_SECOND_MB /* mb() ordered */ + | READ_LOCK_OUT_UNROLL /* post-dominant */ + | READ_LOCK_NESTED_OUT + | READ_LOCK_OUT + | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT, + READ_PROC_THIRD_MB) -> + smp_mb_reader(i, j); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_THIRD_MB); + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_PROC_FIRST_MB /* mb() orders reads */ + | READ_PROC_SECOND_MB /* mb() orders reads */ + | READ_PROC_THIRD_MB, /* mb() orders reads */ + READ_PROC_READ_GEN_UNROLL) -> + ooo_mem(i); + ptr_read_second[get_readerid()] = READ_CACHED_VAR(rcu_ptr); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_READ_GEN_UNROLL); + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_PROC_READ_GEN_UNROLL + | READ_PROC_FIRST_MB /* mb() orders reads */ + | READ_PROC_SECOND_MB /* mb() orders reads */ + | READ_PROC_THIRD_MB, /* mb() orders reads */ + READ_PROC_ACCESS_GEN_UNROLL) -> + /* smp_read_barrier_depends */ + goto rmb2; +rmb2_end: + data_read_second[get_readerid()] = + READ_CACHED_VAR(rcu_data[ptr_read_second[get_readerid()]]); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_ACCESS_GEN_UNROLL); + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_PROC_READ_GEN_UNROLL /* mb() orders reads */ + | READ_PROC_ACCESS_GEN_UNROLL /* mb() orders reads */ + | READ_PROC_FIRST_MB /* mb() ordered */ + | READ_PROC_SECOND_MB /* mb() ordered */ + | READ_PROC_THIRD_MB /* mb() ordered */ + | READ_LOCK_OUT_UNROLL /* post-dominant */ + | READ_LOCK_NESTED_OUT + | READ_LOCK_OUT + | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT, + READ_PROC_FOURTH_MB) -> + smp_mb_reader(i, j); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_FOURTH_MB); + + PROCEDURE_READ_UNLOCK(READ_UNLOCK_UNROLL_BASE, + READ_PROC_FOURTH_MB /* mb() orders reads */ + | READ_PROC_THIRD_MB /* mb() orders reads */ + | READ_LOCK_OUT_UNROLL /* RAW */ + | READ_PROC_SECOND_MB /* mb() orders reads */ + | READ_PROC_FIRST_MB /* mb() orders reads */ + | READ_LOCK_NESTED_OUT /* RAW */ + | READ_LOCK_OUT /* RAW */ + | READ_UNLOCK_NESTED_OUT, /* RAW */ + READ_UNLOCK_OUT_UNROLL); + :: CONSUME_TOKENS(proc_urcu_reader, READ_PROC_ALL_TOKENS, 0) -> + CLEAR_TOKENS(proc_urcu_reader, READ_PROC_ALL_TOKENS_CLEAR); + break; + fi; + } + od; + /* + * Dependency between consecutive loops : + * RAW dependency on + * WRITE_CACHED_VAR(urcu_active_readers[get_readerid()], tmp2 - 1) + * tmp = READ_CACHED_VAR(urcu_active_readers[get_readerid()]); + * between loops. + * _WHEN THE MB()s are in place_, they add full ordering of the + * generation pointer read wrt active reader count read, which ensures + * execution will not spill across loop execution. + * However, in the event mb()s are removed (execution using signal + * handler to promote barrier()() -> smp_mb()), nothing prevents one loop + * to spill its execution on other loop's execution. + */ + goto end; +rmb1: +#ifndef NO_RMB + smp_rmb(i); +#else + ooo_mem(i); +#endif + goto rmb1_end; +rmb2: +#ifndef NO_RMB + smp_rmb(i); +#else + ooo_mem(i); +#endif + goto rmb2_end; +end: + skip; +} + + + +active proctype urcu_reader() +{ + byte i, j, nest_i; + byte tmp, tmp2; + + wait_init_done(); + + assert(get_pid() < NR_PROCS); + +end_reader: + do + :: 1 -> + /* + * We do not test reader's progress here, because we are mainly + * interested in writer's progress. The reader never blocks + * anyway. We have to test for reader/writer's progress + * separately, otherwise we could think the writer is doing + * progress when it's blocked by an always progressing reader. + */ +#ifdef READER_PROGRESS +progress_reader: +#endif + urcu_one_read(i, j, nest_i, tmp, tmp2); + od; +} + +/* no name clash please */ +#undef proc_urcu_reader + + +/* Model the RCU update process. */ + +/* + * Bit encoding, urcu_writer : + * Currently only supports one reader. + */ + +int _proc_urcu_writer; +#define proc_urcu_writer _proc_urcu_writer + +#define WRITE_PROD_NONE (1 << 0) + +#define WRITE_DATA (1 << 1) +#define WRITE_PROC_WMB (1 << 2) +#define WRITE_XCHG_PTR (1 << 3) + +#define WRITE_PROC_FIRST_MB (1 << 4) + +/* first flip */ +#define WRITE_PROC_FIRST_READ_GP (1 << 5) +#define WRITE_PROC_FIRST_WRITE_GP (1 << 6) +#define WRITE_PROC_FIRST_WAIT (1 << 7) +#define WRITE_PROC_FIRST_WAIT_LOOP (1 << 8) + +/* second flip */ +#define WRITE_PROC_SECOND_READ_GP (1 << 9) +#define WRITE_PROC_SECOND_WRITE_GP (1 << 10) +#define WRITE_PROC_SECOND_WAIT (1 << 11) +#define WRITE_PROC_SECOND_WAIT_LOOP (1 << 12) + +#define WRITE_PROC_SECOND_MB (1 << 13) + +#define WRITE_FREE (1 << 14) + +#define WRITE_PROC_ALL_TOKENS (WRITE_PROD_NONE \ + | WRITE_DATA \ + | WRITE_PROC_WMB \ + | WRITE_XCHG_PTR \ + | WRITE_PROC_FIRST_MB \ + | WRITE_PROC_FIRST_READ_GP \ + | WRITE_PROC_FIRST_WRITE_GP \ + | WRITE_PROC_FIRST_WAIT \ + | WRITE_PROC_SECOND_READ_GP \ + | WRITE_PROC_SECOND_WRITE_GP \ + | WRITE_PROC_SECOND_WAIT \ + | WRITE_PROC_SECOND_MB \ + | WRITE_FREE) + +#define WRITE_PROC_ALL_TOKENS_CLEAR ((1 << 15) - 1) + +/* + * Mutexes are implied around writer execution. A single writer at a time. + */ +active proctype urcu_writer() +{ + byte i, j; + byte tmp, tmp2, tmpa; + byte cur_data = 0, old_data, loop_nr = 0; + byte cur_gp_val = 0; /* + * Keep a local trace of the current parity so + * we don't add non-existing dependencies on the global + * GP update. Needed to test single flip case. + */ + + wait_init_done(); + + assert(get_pid() < NR_PROCS); + + do + :: (loop_nr < 3) -> +#ifdef WRITER_PROGRESS +progress_writer1: +#endif + loop_nr = loop_nr + 1; + + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROD_NONE); + +#ifdef NO_WMB + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_WMB); +#endif + +#ifdef NO_MB + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_FIRST_MB); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_MB); +#endif + +#ifdef SINGLE_FLIP + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_READ_GP); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_WRITE_GP); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_WAIT); + /* For single flip, we need to know the current parity */ + cur_gp_val = cur_gp_val ^ RCU_GP_CTR_BIT; +#endif + + do :: 1 -> + atomic { + if + + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_PROD_NONE, + WRITE_DATA) -> + ooo_mem(i); + cur_data = (cur_data + 1) % SLAB_SIZE; + WRITE_CACHED_VAR(rcu_data[cur_data], WINE); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_DATA); + + + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_DATA, + WRITE_PROC_WMB) -> + smp_wmb(i); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_WMB); + + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_PROC_WMB, + WRITE_XCHG_PTR) -> + /* rcu_xchg_pointer() */ + atomic { + old_data = READ_CACHED_VAR(rcu_ptr); + WRITE_CACHED_VAR(rcu_ptr, cur_data); + } + PRODUCE_TOKENS(proc_urcu_writer, WRITE_XCHG_PTR); + + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_DATA | WRITE_PROC_WMB | WRITE_XCHG_PTR, + WRITE_PROC_FIRST_MB) -> + goto smp_mb_send1; +smp_mb_send1_end: + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_FIRST_MB); + + /* first flip */ + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_PROC_FIRST_MB, + WRITE_PROC_FIRST_READ_GP) -> + tmpa = READ_CACHED_VAR(urcu_gp_ctr); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_FIRST_READ_GP); + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_PROC_FIRST_MB | WRITE_PROC_WMB + | WRITE_PROC_FIRST_READ_GP, + WRITE_PROC_FIRST_WRITE_GP) -> + ooo_mem(i); + WRITE_CACHED_VAR(urcu_gp_ctr, tmpa ^ RCU_GP_CTR_BIT); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_FIRST_WRITE_GP); + + :: CONSUME_TOKENS(proc_urcu_writer, + //WRITE_PROC_FIRST_WRITE_GP /* TEST ADDING SYNC CORE */ + WRITE_PROC_FIRST_MB, /* can be reordered before/after flips */ + WRITE_PROC_FIRST_WAIT | WRITE_PROC_FIRST_WAIT_LOOP) -> + ooo_mem(i); + /* ONLY WAITING FOR READER 0 */ + tmp2 = READ_CACHED_VAR(urcu_active_readers[0]); +#ifndef SINGLE_FLIP + /* In normal execution, we are always starting by + * waiting for the even parity. + */ + cur_gp_val = RCU_GP_CTR_BIT; +#endif + if + :: (tmp2 & RCU_GP_CTR_NEST_MASK) + && ((tmp2 ^ cur_gp_val) & RCU_GP_CTR_BIT) -> + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_FIRST_WAIT_LOOP); + :: else -> + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_FIRST_WAIT); + fi; + + :: CONSUME_TOKENS(proc_urcu_writer, + //WRITE_PROC_FIRST_WRITE_GP /* TEST ADDING SYNC CORE */ + WRITE_PROC_FIRST_WRITE_GP + | WRITE_PROC_FIRST_READ_GP + | WRITE_PROC_FIRST_WAIT_LOOP + | WRITE_DATA | WRITE_PROC_WMB | WRITE_XCHG_PTR + | WRITE_PROC_FIRST_MB, /* can be reordered before/after flips */ + 0) -> +#ifndef GEN_ERROR_WRITER_PROGRESS + goto smp_mb_send2; +smp_mb_send2_end: +#else + ooo_mem(i); +#endif + /* This instruction loops to WRITE_PROC_FIRST_WAIT */ + CLEAR_TOKENS(proc_urcu_writer, WRITE_PROC_FIRST_WAIT_LOOP | WRITE_PROC_FIRST_WAIT); + + /* second flip */ + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_PROC_FIRST_WAIT /* Control dependency : need to branch out of + * the loop to execute the next flip (CHECK) */ + | WRITE_PROC_FIRST_WRITE_GP + | WRITE_PROC_FIRST_READ_GP + | WRITE_PROC_FIRST_MB, + WRITE_PROC_SECOND_READ_GP) -> + ooo_mem(i); + tmpa = READ_CACHED_VAR(urcu_gp_ctr); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_READ_GP); + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_PROC_FIRST_MB + | WRITE_PROC_WMB + | WRITE_PROC_FIRST_READ_GP + | WRITE_PROC_FIRST_WRITE_GP + | WRITE_PROC_SECOND_READ_GP, + WRITE_PROC_SECOND_WRITE_GP) -> + ooo_mem(i); + WRITE_CACHED_VAR(urcu_gp_ctr, tmpa ^ RCU_GP_CTR_BIT); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_WRITE_GP); + + :: CONSUME_TOKENS(proc_urcu_writer, + //WRITE_PROC_FIRST_WRITE_GP /* TEST ADDING SYNC CORE */ + WRITE_PROC_FIRST_WAIT + | WRITE_PROC_FIRST_MB, /* can be reordered before/after flips */ + WRITE_PROC_SECOND_WAIT | WRITE_PROC_SECOND_WAIT_LOOP) -> + ooo_mem(i); + /* ONLY WAITING FOR READER 0 */ + tmp2 = READ_CACHED_VAR(urcu_active_readers[0]); + if + :: (tmp2 & RCU_GP_CTR_NEST_MASK) + && ((tmp2 ^ 0) & RCU_GP_CTR_BIT) -> + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_WAIT_LOOP); + :: else -> + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_WAIT); + fi; + + :: CONSUME_TOKENS(proc_urcu_writer, + //WRITE_PROC_FIRST_WRITE_GP /* TEST ADDING SYNC CORE */ + WRITE_PROC_SECOND_WRITE_GP + | WRITE_PROC_FIRST_WRITE_GP + | WRITE_PROC_SECOND_READ_GP + | WRITE_PROC_FIRST_READ_GP + | WRITE_PROC_SECOND_WAIT_LOOP + | WRITE_DATA | WRITE_PROC_WMB | WRITE_XCHG_PTR + | WRITE_PROC_FIRST_MB, /* can be reordered before/after flips */ + 0) -> +#ifndef GEN_ERROR_WRITER_PROGRESS + goto smp_mb_send3; +smp_mb_send3_end: +#else + ooo_mem(i); +#endif + /* This instruction loops to WRITE_PROC_SECOND_WAIT */ + CLEAR_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_WAIT_LOOP | WRITE_PROC_SECOND_WAIT); + + + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_PROC_FIRST_WAIT + | WRITE_PROC_SECOND_WAIT + | WRITE_PROC_FIRST_READ_GP + | WRITE_PROC_SECOND_READ_GP + | WRITE_PROC_FIRST_WRITE_GP + | WRITE_PROC_SECOND_WRITE_GP + | WRITE_DATA | WRITE_PROC_WMB | WRITE_XCHG_PTR + | WRITE_PROC_FIRST_MB, + WRITE_PROC_SECOND_MB) -> + goto smp_mb_send4; +smp_mb_send4_end: + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_MB); + + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_XCHG_PTR + | WRITE_PROC_FIRST_WAIT + | WRITE_PROC_SECOND_WAIT + | WRITE_PROC_WMB /* No dependency on + * WRITE_DATA because we + * write to a + * different location. */ + | WRITE_PROC_SECOND_MB + | WRITE_PROC_FIRST_MB, + WRITE_FREE) -> + WRITE_CACHED_VAR(rcu_data[old_data], POISON); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_FREE); + + :: CONSUME_TOKENS(proc_urcu_writer, WRITE_PROC_ALL_TOKENS, 0) -> + CLEAR_TOKENS(proc_urcu_writer, WRITE_PROC_ALL_TOKENS_CLEAR); + break; + fi; + } + od; + /* + * Note : Promela model adds implicit serialization of the + * WRITE_FREE instruction. Normally, it would be permitted to + * spill on the next loop execution. Given the validation we do + * checks for the data entry read to be poisoned, it's ok if + * we do not check "late arriving" memory poisoning. + */ + :: else -> break; + od; + /* + * Given the reader loops infinitely, let the writer also busy-loop + * with progress here so, with weak fairness, we can test the + * writer's progress. + */ +end_writer: + do + :: 1 -> +#ifdef WRITER_PROGRESS +progress_writer2: +#endif +#ifdef READER_PROGRESS + /* + * Make sure we don't block the reader's progress. + */ + smp_mb_send(i, j, 5); +#endif + skip; + od; + + /* Non-atomic parts of the loop */ + goto end; +smp_mb_send1: + smp_mb_send(i, j, 1); + goto smp_mb_send1_end; +#ifndef GEN_ERROR_WRITER_PROGRESS +smp_mb_send2: + smp_mb_send(i, j, 2); + goto smp_mb_send2_end; +smp_mb_send3: + smp_mb_send(i, j, 3); + goto smp_mb_send3_end; +#endif +smp_mb_send4: + smp_mb_send(i, j, 4); + goto smp_mb_send4_end; +end: + skip; +} + +/* no name clash please */ +#undef proc_urcu_writer + + +/* Leave after the readers and writers so the pid count is ok. */ +init { + byte i, j; + + atomic { + INIT_CACHED_VAR(urcu_gp_ctr, 1, j); + INIT_CACHED_VAR(rcu_ptr, 0, j); + + i = 0; + do + :: i < NR_READERS -> + INIT_CACHED_VAR(urcu_active_readers[i], 0, j); + ptr_read_first[i] = 1; + ptr_read_second[i] = 1; + data_read_first[i] = WINE; + data_read_second[i] = WINE; + i++; + :: i >= NR_READERS -> break + od; + INIT_CACHED_VAR(rcu_data[0], WINE, j); + i = 1; + do + :: i < SLAB_SIZE -> + INIT_CACHED_VAR(rcu_data[i], POISON, j); + i++ + :: i >= SLAB_SIZE -> break + od; + + init_done = 1; + } +} diff --git a/formal-model/results/urcu-controldataflow-ipi-intel/urcu_free_no_wmb.spin.input.trail b/formal-model/results/urcu-controldataflow-ipi-intel/urcu_free_no_wmb.spin.input.trail new file mode 100644 index 0000000..8c8735f --- /dev/null +++ b/formal-model/results/urcu-controldataflow-ipi-intel/urcu_free_no_wmb.spin.input.trail @@ -0,0 +1,1390 @@ +-2:3:-2 +-4:-4:-4 +1:0:4176 +2:3:4096 +3:3:4099 +4:3:4099 +5:3:4102 +6:3:4110 +7:3:4110 +8:3:4113 +9:3:4119 +10:3:4123 +11:3:4123 +12:3:4126 +13:3:4136 +14:3:4144 +15:3:4144 +16:3:4147 +17:3:4153 +18:3:4157 +19:3:4157 +20:3:4160 +21:3:4166 +22:3:4170 +23:3:4171 +24:0:4176 +25:3:4173 +26:0:4176 +27:2:2511 +28:0:4176 +29:2:2517 +30:0:4176 +31:2:2518 +32:0:4176 +33:2:2520 +34:0:4176 +35:2:2521 +36:0:4176 +37:2:2522 +38:0:4176 +39:2:2523 +40:2:2524 +41:2:2528 +42:2:2529 +43:2:2537 +44:2:2538 +45:2:2542 +46:2:2543 +47:2:2551 +48:2:2556 +49:2:2560 +50:2:2561 +51:2:2569 +52:2:2570 +53:2:2574 +54:2:2575 +55:2:2569 +56:2:2570 +57:2:2574 +58:2:2575 +59:2:2583 +60:2:2588 +61:2:2595 +62:2:2596 +63:2:2603 +64:2:2608 +65:2:2615 +66:2:2616 +67:2:2615 +68:2:2616 +69:2:2623 +70:2:2633 +71:0:4176 +72:2:2522 +73:0:4176 +74:2:2685 +75:2:2686 +76:2:2687 +77:0:4176 +78:2:2522 +79:0:4176 +80:2:2692 +81:0:4176 +82:2:3305 +83:2:3306 +84:2:3310 +85:2:3314 +86:2:3315 +87:2:3319 +88:2:3324 +89:2:3332 +90:2:3336 +91:2:3337 +92:2:3332 +93:2:3333 +94:2:3341 +95:2:3348 +96:2:3355 +97:2:3356 +98:2:3363 +99:2:3368 +100:2:3375 +101:2:3376 +102:2:3375 +103:2:3376 +104:2:3383 +105:2:3387 +106:0:4176 +107:2:3392 +108:0:4176 +109:2:3393 +110:0:4176 +111:2:3394 +112:0:4176 +113:2:3395 +114:0:4176 +115:1:2 +116:0:4176 +117:2:3396 +118:0:4176 +119:1:8 +120:0:4176 +121:1:9 +122:0:4176 +123:2:3395 +124:0:4176 +125:1:10 +126:0:4176 +127:2:3396 +128:0:4176 +129:1:11 +130:0:4176 +131:2:3395 +132:0:4176 +133:1:12 +134:0:4176 +135:2:3396 +136:0:4176 +137:1:13 +138:0:4176 +139:2:3395 +140:0:4176 +141:1:14 +142:0:4176 +143:2:3396 +144:0:4176 +145:1:15 +146:0:4176 +147:1:16 +148:0:4176 +149:2:3395 +150:0:4176 +151:1:17 +152:0:4176 +153:2:3396 +154:0:4176 +155:1:26 +156:0:4176 +157:2:3395 +158:0:4176 +159:1:30 +160:1:31 +161:1:35 +162:1:39 +163:1:40 +164:1:44 +165:1:52 +166:1:53 +167:1:57 +168:1:61 +169:1:62 +170:1:57 +171:1:61 +172:1:62 +173:1:66 +174:1:73 +175:1:80 +176:1:81 +177:1:88 +178:1:93 +179:1:100 +180:1:101 +181:1:100 +182:1:101 +183:1:108 +184:1:112 +185:0:4176 +186:2:3396 +187:0:4176 +188:1:117 +189:0:4176 +190:2:3397 +191:0:4176 +192:2:3402 +193:0:4176 +194:2:3403 +195:0:4176 +196:2:3411 +197:2:3412 +198:2:3416 +199:2:3420 +200:2:3421 +201:2:3425 +202:2:3433 +203:2:3434 +204:2:3438 +205:2:3442 +206:2:3443 +207:2:3438 +208:2:3442 +209:2:3443 +210:2:3447 +211:2:3454 +212:2:3461 +213:2:3462 +214:2:3469 +215:2:3474 +216:2:3481 +217:2:3482 +218:2:3481 +219:2:3482 +220:2:3489 +221:2:3493 +222:0:4176 +223:2:2694 +224:2:3286 +225:0:4176 +226:2:2522 +227:0:4176 +228:2:2695 +229:0:4176 +230:2:2522 +231:0:4176 +232:2:2698 +233:2:2699 +234:2:2703 +235:2:2704 +236:2:2712 +237:2:2713 +238:2:2717 +239:2:2718 +240:2:2726 +241:2:2731 +242:2:2735 +243:2:2736 +244:2:2744 +245:2:2745 +246:2:2749 +247:2:2750 +248:2:2744 +249:2:2745 +250:2:2749 +251:2:2750 +252:2:2758 +253:2:2763 +254:2:2770 +255:2:2771 +256:2:2778 +257:2:2783 +258:2:2790 +259:2:2791 +260:2:2790 +261:2:2791 +262:2:2798 +263:2:2807 +264:0:4176 +265:2:2522 +266:0:4176 +267:2:2811 +268:2:2812 +269:2:2813 +270:2:2825 +271:2:2826 +272:2:2830 +273:2:2831 +274:2:2839 +275:2:2844 +276:2:2848 +277:2:2849 +278:2:2857 +279:2:2858 +280:2:2862 +281:2:2863 +282:2:2857 +283:2:2858 +284:2:2862 +285:2:2863 +286:2:2871 +287:2:2876 +288:2:2883 +289:2:2884 +290:2:2891 +291:2:2896 +292:2:2903 +293:2:2904 +294:2:2903 +295:2:2904 +296:2:2911 +297:2:2924 +298:2:2925 +299:0:4176 +300:2:2522 +301:0:4176 +302:2:2931 +303:2:2932 +304:2:2936 +305:2:2937 +306:2:2945 +307:2:2946 +308:2:2950 +309:2:2951 +310:2:2959 +311:2:2964 +312:2:2968 +313:2:2969 +314:2:2977 +315:2:2978 +316:2:2982 +317:2:2983 +318:2:2977 +319:2:2978 +320:2:2982 +321:2:2983 +322:2:2991 +323:2:2996 +324:2:3003 +325:2:3004 +326:2:3011 +327:2:3016 +328:2:3023 +329:2:3024 +330:2:3023 +331:2:3024 +332:2:3031 +333:0:4176 +334:2:2522 +335:0:4176 +336:2:3042 +337:2:3043 +338:2:3047 +339:2:3048 +340:2:3056 +341:2:3057 +342:2:3061 +343:2:3062 +344:2:3070 +345:2:3075 +346:2:3079 +347:2:3080 +348:2:3088 +349:2:3089 +350:2:3093 +351:2:3094 +352:2:3088 +353:2:3089 +354:2:3093 +355:2:3094 +356:2:3102 +357:2:3107 +358:2:3114 +359:2:3115 +360:2:3122 +361:2:3127 +362:2:3134 +363:2:3135 +364:2:3134 +365:2:3135 +366:2:3142 +367:2:3151 +368:0:4176 +369:2:2522 +370:0:4176 +371:2:3155 +372:2:3156 +373:2:3157 +374:2:3169 +375:2:3170 +376:2:3174 +377:2:3175 +378:2:3183 +379:2:3188 +380:2:3192 +381:2:3193 +382:2:3201 +383:2:3202 +384:2:3206 +385:2:3207 +386:2:3201 +387:2:3202 +388:2:3206 +389:2:3207 +390:2:3215 +391:2:3220 +392:2:3227 +393:2:3228 +394:2:3235 +395:2:3240 +396:2:3247 +397:2:3248 +398:2:3247 +399:2:3248 +400:2:3255 +401:2:3267 +402:2:3268 +403:0:4176 +404:2:2522 +405:0:4176 +406:2:3274 +407:0:4176 +408:2:3899 +409:2:3900 +410:2:3904 +411:2:3908 +412:2:3909 +413:2:3913 +414:2:3921 +415:2:3922 +416:2:3926 +417:2:3930 +418:2:3931 +419:2:3926 +420:2:3930 +421:2:3931 +422:2:3935 +423:2:3942 +424:2:3949 +425:2:3950 +426:2:3957 +427:2:3962 +428:2:3969 +429:2:3970 +430:2:3969 +431:2:3970 +432:2:3977 +433:2:3981 +434:0:4176 +435:2:3986 +436:0:4176 +437:2:3987 +438:0:4176 +439:2:3988 +440:0:4176 +441:2:3989 +442:0:4176 +443:1:26 +444:0:4176 +445:2:3990 +446:0:4176 +447:1:30 +448:1:31 +449:1:35 +450:1:39 +451:1:40 +452:1:44 +453:1:52 +454:1:53 +455:1:57 +456:1:61 +457:1:62 +458:1:57 +459:1:61 +460:1:62 +461:1:66 +462:1:73 +463:1:80 +464:1:81 +465:1:88 +466:1:93 +467:1:100 +468:1:101 +469:1:100 +470:1:101 +471:1:108 +472:1:112 +473:0:4176 +474:2:3989 +475:0:4176 +476:1:117 +477:0:4176 +478:2:3990 +479:0:4176 +480:2:3991 +481:0:4176 +482:2:3996 +483:0:4176 +484:2:3997 +485:0:4176 +486:2:4005 +487:2:4006 +488:2:4010 +489:2:4014 +490:2:4015 +491:2:4019 +492:2:4027 +493:2:4028 +494:2:4032 +495:2:4036 +496:2:4037 +497:2:4032 +498:2:4036 +499:2:4037 +500:2:4041 +501:2:4048 +502:2:4055 +503:2:4056 +504:2:4063 +505:2:4068 +506:2:4075 +507:2:4076 +508:2:4075 +509:2:4076 +510:2:4083 +511:2:4087 +512:0:4176 +513:2:3276 +514:2:3286 +515:0:4176 +516:2:2522 +517:0:4176 +518:2:3277 +519:2:3278 +520:0:4176 +521:2:2522 +522:0:4176 +523:2:3282 +524:0:4176 +525:2:3290 +526:0:4176 +527:2:2518 +528:0:4176 +529:2:2520 +530:0:4176 +531:2:2521 +532:0:4176 +533:2:2522 +534:0:4176 +535:2:2685 +536:2:2686 +537:2:2687 +538:0:4176 +539:2:2522 +540:0:4176 +541:2:2523 +542:2:2524 +543:2:2528 +544:2:2529 +545:2:2537 +546:2:2538 +547:2:2542 +548:2:2543 +549:2:2551 +550:2:2556 +551:2:2557 +552:2:2569 +553:2:2570 +554:2:2571 +555:2:2569 +556:2:2570 +557:2:2574 +558:2:2575 +559:2:2583 +560:2:2588 +561:2:2595 +562:2:2596 +563:2:2603 +564:2:2608 +565:2:2615 +566:2:2616 +567:2:2615 +568:2:2616 +569:2:2623 +570:2:2633 +571:0:4176 +572:2:2522 +573:0:4176 +574:2:2692 +575:0:4176 +576:2:3305 +577:2:3306 +578:2:3310 +579:2:3314 +580:2:3315 +581:2:3319 +582:2:3327 +583:2:3328 +584:2:3332 +585:2:3333 +586:2:3332 +587:2:3336 +588:2:3337 +589:2:3341 +590:2:3348 +591:2:3355 +592:2:3356 +593:2:3363 +594:2:3368 +595:2:3375 +596:2:3376 +597:2:3375 +598:2:3376 +599:2:3383 +600:2:3387 +601:0:4176 +602:2:3392 +603:0:4176 +604:2:3393 +605:0:4176 +606:2:3394 +607:0:4176 +608:2:3395 +609:0:4176 +610:1:26 +611:0:4176 +612:2:3396 +613:0:4176 +614:1:30 +615:1:31 +616:1:35 +617:1:39 +618:1:40 +619:1:44 +620:1:52 +621:1:53 +622:1:57 +623:1:61 +624:1:62 +625:1:57 +626:1:61 +627:1:62 +628:1:66 +629:1:73 +630:1:80 +631:1:81 +632:1:88 +633:1:93 +634:1:100 +635:1:101 +636:1:100 +637:1:101 +638:1:108 +639:1:112 +640:0:4176 +641:2:3395 +642:0:4176 +643:1:117 +644:0:4176 +645:2:3396 +646:0:4176 +647:2:3397 +648:0:4176 +649:2:3402 +650:0:4176 +651:2:3403 +652:0:4176 +653:2:3411 +654:2:3412 +655:2:3416 +656:2:3420 +657:2:3421 +658:2:3425 +659:2:3433 +660:2:3434 +661:2:3438 +662:2:3442 +663:2:3443 +664:2:3438 +665:2:3442 +666:2:3443 +667:2:3447 +668:2:3454 +669:2:3461 +670:2:3462 +671:2:3469 +672:2:3474 +673:2:3481 +674:2:3482 +675:2:3481 +676:2:3482 +677:2:3489 +678:2:3493 +679:0:4176 +680:2:2694 +681:2:3286 +682:0:4176 +683:2:2522 +684:0:4176 +685:2:2695 +686:0:4176 +687:2:2522 +688:0:4176 +689:2:2698 +690:2:2699 +691:2:2703 +692:2:2704 +693:2:2712 +694:2:2713 +695:2:2717 +696:2:2718 +697:2:2726 +698:2:2731 +699:2:2735 +700:2:2736 +701:2:2744 +702:2:2745 +703:2:2749 +704:2:2750 +705:2:2744 +706:2:2745 +707:2:2749 +708:2:2750 +709:2:2758 +710:2:2763 +711:2:2770 +712:2:2771 +713:2:2778 +714:2:2783 +715:2:2790 +716:2:2791 +717:2:2790 +718:2:2791 +719:2:2798 +720:2:2807 +721:0:4176 +722:2:2522 +723:0:4176 +724:2:2811 +725:2:2812 +726:2:2813 +727:2:2825 +728:2:2826 +729:2:2830 +730:2:2831 +731:2:2839 +732:2:2844 +733:2:2848 +734:2:2849 +735:2:2857 +736:2:2858 +737:2:2862 +738:2:2863 +739:2:2857 +740:2:2858 +741:2:2862 +742:2:2863 +743:2:2871 +744:2:2876 +745:2:2883 +746:2:2884 +747:2:2891 +748:2:2896 +749:2:2903 +750:2:2904 +751:2:2903 +752:2:2904 +753:2:2911 +754:2:2924 +755:2:2925 +756:0:4176 +757:2:2522 +758:0:4176 +759:2:2931 +760:2:2932 +761:2:2936 +762:2:2937 +763:2:2945 +764:2:2946 +765:2:2950 +766:2:2951 +767:2:2959 +768:2:2964 +769:2:2968 +770:2:2969 +771:2:2977 +772:2:2978 +773:2:2982 +774:2:2983 +775:2:2977 +776:2:2978 +777:2:2982 +778:2:2983 +779:2:2991 +780:2:2996 +781:2:3003 +782:2:3004 +783:2:3011 +784:2:3016 +785:2:3023 +786:2:3024 +787:2:3023 +788:2:3024 +789:2:3031 +790:0:4176 +791:2:2522 +792:0:4176 +793:2:3042 +794:2:3043 +795:2:3047 +796:2:3048 +797:2:3056 +798:2:3057 +799:2:3061 +800:2:3062 +801:2:3070 +802:2:3075 +803:2:3079 +804:2:3080 +805:2:3088 +806:2:3089 +807:2:3093 +808:2:3094 +809:2:3088 +810:2:3089 +811:2:3093 +812:2:3094 +813:2:3102 +814:2:3107 +815:2:3114 +816:2:3115 +817:2:3122 +818:2:3127 +819:2:3134 +820:2:3135 +821:2:3134 +822:2:3135 +823:2:3142 +824:2:3151 +825:0:4176 +826:2:2522 +827:0:4176 +828:2:3155 +829:2:3156 +830:2:3157 +831:2:3169 +832:2:3170 +833:2:3174 +834:2:3175 +835:2:3183 +836:2:3188 +837:2:3192 +838:2:3193 +839:2:3201 +840:2:3202 +841:2:3206 +842:2:3207 +843:2:3201 +844:2:3202 +845:2:3206 +846:2:3207 +847:2:3215 +848:2:3220 +849:2:3227 +850:2:3228 +851:2:3235 +852:2:3240 +853:2:3247 +854:2:3248 +855:2:3247 +856:2:3248 +857:2:3255 +858:2:3267 +859:2:3268 +860:0:4176 +861:2:2522 +862:0:4176 +863:2:3274 +864:0:4176 +865:2:3899 +866:2:3900 +867:2:3904 +868:2:3908 +869:2:3909 +870:2:3913 +871:2:3921 +872:2:3922 +873:2:3926 +874:2:3930 +875:2:3931 +876:2:3926 +877:2:3930 +878:2:3931 +879:2:3935 +880:2:3942 +881:2:3949 +882:2:3950 +883:2:3957 +884:2:3962 +885:2:3969 +886:2:3970 +887:2:3969 +888:2:3970 +889:2:3977 +890:2:3981 +891:0:4176 +892:2:3986 +893:0:4176 +894:2:3987 +895:0:4176 +896:2:3988 +897:0:4176 +898:2:3989 +899:0:4176 +900:1:26 +901:0:4176 +902:2:3990 +903:0:4176 +904:1:30 +905:1:31 +906:1:35 +907:1:39 +908:1:40 +909:1:44 +910:1:52 +911:1:53 +912:1:57 +913:1:61 +914:1:62 +915:1:57 +916:1:61 +917:1:62 +918:1:66 +919:1:73 +920:1:80 +921:1:81 +922:1:88 +923:1:93 +924:1:100 +925:1:101 +926:1:100 +927:1:101 +928:1:108 +929:1:112 +930:0:4176 +931:2:3989 +932:0:4176 +933:1:117 +934:0:4176 +935:2:3990 +936:0:4176 +937:2:3991 +938:0:4176 +939:2:3996 +940:0:4176 +941:2:3997 +942:0:4176 +943:2:4005 +944:2:4006 +945:2:4010 +946:2:4014 +947:2:4015 +948:2:4019 +949:2:4027 +950:2:4028 +951:2:4032 +952:2:4036 +953:2:4037 +954:2:4032 +955:2:4036 +956:2:4037 +957:2:4041 +958:2:4048 +959:2:4055 +960:2:4056 +961:2:4063 +962:2:4068 +963:2:4075 +964:2:4076 +965:2:4075 +966:2:4076 +967:2:4083 +968:2:4087 +969:0:4176 +970:2:3276 +971:2:3286 +972:0:4176 +973:2:2522 +974:0:4176 +975:2:3277 +976:2:3278 +977:0:4176 +978:2:2522 +979:0:4176 +980:2:3282 +981:0:4176 +982:2:3290 +983:0:4176 +984:2:2518 +985:0:4176 +986:2:2520 +987:0:4176 +988:2:2521 +989:0:4176 +990:2:2522 +991:0:4176 +992:2:2523 +993:2:2524 +994:2:2528 +995:2:2529 +996:2:2537 +997:2:2538 +998:2:2542 +999:2:2543 +1000:2:2551 +1001:2:2556 +1002:2:2560 +1003:2:2561 +1004:2:2569 +1005:2:2570 +1006:2:2574 +1007:2:2575 +1008:2:2569 +1009:2:2570 +1010:2:2571 +1011:2:2583 +1012:2:2588 +1013:2:2595 +1014:2:2596 +1015:2:2603 +1016:2:2608 +1017:2:2615 +1018:2:2616 +1019:2:2615 +1020:2:2616 +1021:2:2623 +1022:2:2633 +1023:0:4176 +1024:2:2522 +1025:0:4176 +1026:2:2685 +1027:2:2686 +1028:2:2687 +1029:0:4176 +1030:2:2522 +1031:0:4176 +1032:2:2692 +1033:0:4176 +1034:1:118 +1035:0:4176 +1036:1:120 +1037:0:4176 +1038:1:19 +1039:0:4176 +1040:1:126 +1041:1:127 +1042:1:131 +1043:1:132 +1044:1:140 +1045:1:141 +1046:1:145 +1047:1:146 +1048:1:154 +1049:1:159 +1050:1:163 +1051:1:164 +1052:1:172 +1053:1:173 +1054:1:177 +1055:1:178 +1056:1:172 +1057:1:173 +1058:1:177 +1059:1:178 +1060:1:186 +1061:1:191 +1062:1:198 +1063:1:199 +1064:1:206 +1065:1:211 +1066:1:218 +1067:1:219 +1068:1:218 +1069:1:219 +1070:1:226 +1071:0:4176 +1072:1:15 +1073:0:4176 +1074:1:16 +1075:0:4176 +1076:1:17 +1077:0:4176 +1078:1:118 +1079:0:4176 +1080:1:120 +1081:0:4176 +1082:1:19 +1083:0:4176 +1084:1:237 +1085:1:238 +1086:0:4176 +1087:1:15 +1088:0:4176 +1089:1:16 +1090:0:4176 +1091:1:17 +1092:0:4176 +1093:1:118 +1094:0:4176 +1095:1:120 +1096:0:4176 +1097:1:19 +1098:0:4176 +1099:1:244 +1100:1:245 +1101:1:249 +1102:1:250 +1103:1:258 +1104:1:259 +1105:1:263 +1106:1:264 +1107:1:272 +1108:1:277 +1109:1:281 +1110:1:282 +1111:1:290 +1112:1:291 +1113:1:295 +1114:1:296 +1115:1:290 +1116:1:291 +1117:1:295 +1118:1:296 +1119:1:304 +1120:1:309 +1121:1:316 +1122:1:317 +1123:1:324 +1124:1:329 +1125:1:336 +1126:1:337 +1127:1:336 +1128:1:337 +1129:1:344 +1130:0:4176 +1131:1:15 +1132:0:4176 +1133:1:16 +1134:0:4176 +1135:1:17 +1136:0:4176 +1137:1:118 +1138:0:4176 +1139:1:120 +1140:0:4176 +1141:1:19 +1142:0:4176 +1143:1:355 +1144:1:356 +1145:1:360 +1146:1:361 +1147:1:369 +1148:1:370 +1149:1:374 +1150:1:375 +1151:1:383 +1152:1:388 +1153:1:392 +1154:1:393 +1155:1:401 +1156:1:402 +1157:1:406 +1158:1:407 +1159:1:401 +1160:1:402 +1161:1:406 +1162:1:407 +1163:1:415 +1164:1:420 +1165:1:427 +1166:1:428 +1167:1:435 +1168:1:440 +1169:1:447 +1170:1:448 +1171:1:447 +1172:1:448 +1173:1:455 +1174:1:464 +1175:0:4176 +1176:1:15 +1177:0:4176 +1178:1:16 +1179:0:4176 +1180:1:17 +1181:0:4176 +1182:1:118 +1183:0:4176 +1184:1:120 +1185:0:4176 +1186:1:19 +1187:0:4176 +1188:1:584 +1189:1:585 +1190:1:589 +1191:1:590 +1192:1:598 +1193:1:599 +1194:1:600 +1195:1:612 +1196:1:617 +1197:1:621 +1198:1:622 +1199:1:630 +1200:1:631 +1201:1:635 +1202:1:636 +1203:1:630 +1204:1:631 +1205:1:635 +1206:1:636 +1207:1:644 +1208:1:649 +1209:1:656 +1210:1:657 +1211:1:664 +1212:1:669 +1213:1:676 +1214:1:677 +1215:1:676 +1216:1:677 +1217:1:684 +1218:0:4176 +1219:1:15 +1220:0:4176 +1221:1:16 +1222:0:4176 +1223:1:17 +1224:0:4176 +1225:1:118 +1226:0:4176 +1227:1:120 +1228:0:4176 +1229:1:19 +1230:0:4176 +1231:1:695 +1232:1:698 +1233:1:699 +1234:0:4176 +1235:1:15 +1236:0:4176 +1237:1:16 +1238:0:4176 +1239:1:17 +1240:0:4176 +1241:1:118 +1242:0:4176 +1243:1:120 +1244:0:4176 +1245:1:19 +1246:0:4176 +1247:1:926 +1248:1:927 +1249:1:931 +1250:1:932 +1251:1:940 +1252:1:941 +1253:1:945 +1254:1:946 +1255:1:954 +1256:1:959 +1257:1:963 +1258:1:964 +1259:1:972 +1260:1:973 +1261:1:977 +1262:1:978 +1263:1:972 +1264:1:973 +1265:1:977 +1266:1:978 +1267:1:986 +1268:1:991 +1269:1:998 +1270:1:999 +1271:1:1006 +1272:1:1011 +1273:1:1018 +1274:1:1019 +1275:1:1018 +1276:1:1019 +1277:1:1026 +1278:1:1035 +1279:1:1039 +1280:0:4176 +1281:1:15 +1282:0:4176 +1283:1:16 +1284:0:4176 +1285:1:17 +1286:0:4176 +1287:1:118 +1288:0:4176 +1289:1:120 +1290:0:4176 +1291:1:19 +1292:0:4176 +1293:1:1040 +1294:1:1041 +1295:1:1045 +1296:1:1046 +1297:1:1054 +1298:1:1055 +1299:1:1056 +1300:1:1068 +1301:1:1073 +1302:1:1077 +1303:1:1078 +1304:1:1086 +1305:1:1087 +1306:1:1091 +1307:1:1092 +1308:1:1086 +1309:1:1087 +1310:1:1091 +1311:1:1092 +1312:1:1100 +1313:1:1105 +1314:1:1112 +1315:1:1113 +1316:1:1120 +1317:1:1125 +1318:1:1132 +1319:1:1133 +1320:1:1132 +1321:1:1133 +1322:1:1140 +1323:0:4176 +1324:1:15 +1325:0:4176 +1326:1:16 +1327:0:4176 +1328:1:17 +1329:0:4176 +1330:1:118 +1331:0:4176 +1332:1:120 +1333:0:4176 +1334:1:19 +1335:0:4176 +1336:1:1151 +1337:0:4176 +1338:1:2417 +1339:1:2424 +1340:1:2425 +1341:1:2432 +1342:1:2437 +1343:1:2444 +1344:1:2445 +1345:1:2444 +1346:1:2445 +1347:1:2452 +1348:1:2456 +1349:0:4176 +1350:2:3305 +1351:2:3306 +1352:2:3310 +1353:2:3314 +1354:2:3315 +1355:2:3319 +1356:2:3324 +1357:2:3332 +1358:2:3336 +1359:2:3337 +1360:2:3332 +1361:2:3333 +1362:2:3341 +1363:2:3348 +1364:2:3355 +1365:2:3356 +1366:2:3363 +1367:2:3368 +1368:2:3375 +1369:2:3376 +1370:2:3375 +1371:2:3376 +1372:2:3383 +1373:2:3387 +1374:0:4176 +1375:2:3392 +1376:0:4176 +1377:2:3393 +1378:0:4176 +1379:2:3394 +1380:0:4176 +1381:2:3395 +1382:0:4176 +1383:1:1153 +1384:1:1154 +1385:0:4174 +1386:2:3396 +1387:0:4180 +1388:1:2165 diff --git a/formal-model/results/urcu-controldataflow-ipi-intel/urcu_free_single_flip.define b/formal-model/results/urcu-controldataflow-ipi-intel/urcu_free_single_flip.define new file mode 100644 index 0000000..5e642ef --- /dev/null +++ b/formal-model/results/urcu-controldataflow-ipi-intel/urcu_free_single_flip.define @@ -0,0 +1 @@ +#define SINGLE_FLIP diff --git a/formal-model/results/urcu-controldataflow-ipi-intel/urcu_free_single_flip.log b/formal-model/results/urcu-controldataflow-ipi-intel/urcu_free_single_flip.log new file mode 100644 index 0000000..96aeb49 --- /dev/null +++ b/formal-model/results/urcu-controldataflow-ipi-intel/urcu_free_single_flip.log @@ -0,0 +1,678 @@ +make[1]: Entering directory `/home/compudj/doc/userspace-rcu/formal-model/urcu-controldataflow' +rm -f pan* trail.out .input.spin* *.spin.trail .input.define +touch .input.define +cat .input.define >> pan.ltl +cat DEFINES >> pan.ltl +spin -f "!(`cat urcu_free.ltl | grep -v ^//`)" >> pan.ltl +cp urcu_free_single_flip.define .input.define +cat .input.define > .input.spin +cat DEFINES >> .input.spin +cat urcu.spin >> .input.spin +rm -f .input.spin.trail +spin -a -X -N pan.ltl .input.spin +Exit-Status 0 +gcc -O2 -w -DHASH64 -o pan pan.c +./pan -a -v -c1 -X -m10000000 -w20 +warning: for p.o. reduction to be valid the never claim must be stutter-invariant +(never claims generated from LTL formulae are stutter-invariant) +depth 0: Claim reached state 5 (line 1272) +Depth= 6479 States= 1e+06 Transitions= 6.49e+06 Memory= 550.432 t= 16 R= 6e+04 +Depth= 6479 States= 2e+06 Transitions= 1.29e+07 Memory= 634.318 t= 32.2 R= 6e+04 +Depth= 6479 States= 3e+06 Transitions= 2.07e+07 Memory= 718.303 t= 53 R= 6e+04 +pan: resizing hashtable to -w22.. done +Depth= 6479 States= 4e+06 Transitions= 2.91e+07 Memory= 833.311 t= 75.3 R= 5e+04 +Depth= 6479 States= 5e+06 Transitions= 3.67e+07 Memory= 917.295 t= 95.1 R= 5e+04 +pan: claim violated! (at depth 1254) +pan: wrote .input.spin.trail + +(Spin Version 5.1.7 -- 23 December 2008) +Warning: Search not completed + + Partial Order Reduction + +Full statespace search for: + never claim + + assertion violations + (if within scope of claim) + acceptance cycles + (fairness disabled) + invalid end states - (disabled by never claim) + +State-vector 88 byte, depth reached 6479, errors: 1 + 5383072 states, stored + 34108932 states, matched + 39492004 transitions (= stored+matched) +5.5430124e+08 atomic steps +hash conflicts: 29860557 (resolved) + +Stats on memory usage (in Megabytes): + 595.509 equivalent memory usage for states (stored*(State-vector + overhead)) + 460.005 actual memory usage for states (compression: 77.25%) + state-vector as stored = 62 byte + 28 byte overhead + 32.000 memory used for hash table (-w22) + 457.764 memory used for DFS stack (-m10000000) + 949.424 total actual memory usage + +unreached in proctype urcu_reader + line 262, "pan.___", state 30, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 270, "pan.___", state 52, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 274, "pan.___", state 61, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 77, "(1)" + line 243, "pan.___", state 85, "(1)" + line 247, "pan.___", state 97, "(1)" + line 251, "pan.___", state 105, "(1)" + line 401, "pan.___", state 131, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 163, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 177, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 195, "(1)" + line 247, "pan.___", state 215, "(1)" + line 251, "pan.___", state 223, "(1)" + line 680, "pan.___", state 242, "_proc_urcu_reader = (_proc_urcu_reader|((1<<2)<<1))" + line 401, "pan.___", state 249, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 281, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 295, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 313, "(1)" + line 247, "pan.___", state 333, "(1)" + line 251, "pan.___", state 341, "(1)" + line 401, "pan.___", state 360, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 392, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 406, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 424, "(1)" + line 247, "pan.___", state 444, "(1)" + line 251, "pan.___", state 452, "(1)" + line 401, "pan.___", state 473, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 401, "pan.___", state 475, "(1)" + line 401, "pan.___", state 476, "((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid)))" + line 401, "pan.___", state 476, "else" + line 401, "pan.___", state 479, "(1)" + line 405, "pan.___", state 487, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 405, "pan.___", state 489, "(1)" + line 405, "pan.___", state 490, "((cache_dirty_urcu_active_readers.bitfield&(1<<_pid)))" + line 405, "pan.___", state 490, "else" + line 405, "pan.___", state 493, "(1)" + line 405, "pan.___", state 494, "(1)" + line 405, "pan.___", state 494, "(1)" + line 403, "pan.___", state 499, "((i<1))" + line 403, "pan.___", state 499, "((i>=1))" + line 410, "pan.___", state 505, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 507, "(1)" + line 410, "pan.___", state 508, "((cache_dirty_rcu_ptr.bitfield&(1<<_pid)))" + line 410, "pan.___", state 508, "else" + line 410, "pan.___", state 511, "(1)" + line 410, "pan.___", state 512, "(1)" + line 410, "pan.___", state 512, "(1)" + line 414, "pan.___", state 519, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 414, "pan.___", state 521, "(1)" + line 414, "pan.___", state 522, "((cache_dirty_rcu_data[i].bitfield&(1<<_pid)))" + line 414, "pan.___", state 522, "else" + line 414, "pan.___", state 525, "(1)" + line 414, "pan.___", state 526, "(1)" + line 414, "pan.___", state 526, "(1)" + line 412, "pan.___", state 531, "((i<2))" + line 412, "pan.___", state 531, "((i>=2))" + line 239, "pan.___", state 537, "(1)" + line 243, "pan.___", state 545, "(1)" + line 243, "pan.___", state 546, "(!((cache_dirty_urcu_active_readers.bitfield&(1<<_pid))))" + line 243, "pan.___", state 546, "else" + line 241, "pan.___", state 551, "((i<1))" + line 241, "pan.___", state 551, "((i>=1))" + line 247, "pan.___", state 557, "(1)" + line 247, "pan.___", state 558, "(!((cache_dirty_rcu_ptr.bitfield&(1<<_pid))))" + line 247, "pan.___", state 558, "else" + line 251, "pan.___", state 565, "(1)" + line 251, "pan.___", state 566, "(!((cache_dirty_rcu_data[i].bitfield&(1<<_pid))))" + line 251, "pan.___", state 566, "else" + line 249, "pan.___", state 571, "((i<2))" + line 249, "pan.___", state 571, "((i>=2))" + line 256, "pan.___", state 575, "(!((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid))))" + line 256, "pan.___", state 575, "else" + line 421, "pan.___", state 577, "(1)" + line 421, "pan.___", state 577, "(1)" + line 680, "pan.___", state 580, "cached_urcu_active_readers.val[_pid] = (tmp+1)" + line 680, "pan.___", state 581, "_proc_urcu_reader = (_proc_urcu_reader|(1<<5))" + line 680, "pan.___", state 582, "(1)" + line 401, "pan.___", state 589, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 621, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 635, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 653, "(1)" + line 247, "pan.___", state 673, "(1)" + line 251, "pan.___", state 681, "(1)" + line 401, "pan.___", state 707, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 401, "pan.___", state 709, "(1)" + line 401, "pan.___", state 710, "((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid)))" + line 401, "pan.___", state 710, "else" + line 401, "pan.___", state 713, "(1)" + line 405, "pan.___", state 721, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 405, "pan.___", state 723, "(1)" + line 405, "pan.___", state 724, "((cache_dirty_urcu_active_readers.bitfield&(1<<_pid)))" + line 405, "pan.___", state 724, "else" + line 405, "pan.___", state 727, "(1)" + line 405, "pan.___", state 728, "(1)" + line 405, "pan.___", state 728, "(1)" + line 403, "pan.___", state 733, "((i<1))" + line 403, "pan.___", state 733, "((i>=1))" + line 410, "pan.___", state 739, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 741, "(1)" + line 410, "pan.___", state 742, "((cache_dirty_rcu_ptr.bitfield&(1<<_pid)))" + line 410, "pan.___", state 742, "else" + line 410, "pan.___", state 745, "(1)" + line 410, "pan.___", state 746, "(1)" + line 410, "pan.___", state 746, "(1)" + line 414, "pan.___", state 753, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 414, "pan.___", state 755, "(1)" + line 414, "pan.___", state 756, "((cache_dirty_rcu_data[i].bitfield&(1<<_pid)))" + line 414, "pan.___", state 756, "else" + line 414, "pan.___", state 759, "(1)" + line 414, "pan.___", state 760, "(1)" + line 414, "pan.___", state 760, "(1)" + line 412, "pan.___", state 765, "((i<2))" + line 412, "pan.___", state 765, "((i>=2))" + line 239, "pan.___", state 771, "(1)" + line 243, "pan.___", state 779, "(1)" + line 243, "pan.___", state 780, "(!((cache_dirty_urcu_active_readers.bitfield&(1<<_pid))))" + line 243, "pan.___", state 780, "else" + line 241, "pan.___", state 785, "((i<1))" + line 241, "pan.___", state 785, "((i>=1))" + line 247, "pan.___", state 791, "(1)" + line 247, "pan.___", state 792, "(!((cache_dirty_rcu_ptr.bitfield&(1<<_pid))))" + line 247, "pan.___", state 792, "else" + line 251, "pan.___", state 799, "(1)" + line 251, "pan.___", state 800, "(!((cache_dirty_rcu_data[i].bitfield&(1<<_pid))))" + line 251, "pan.___", state 800, "else" + line 256, "pan.___", state 809, "(!((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid))))" + line 256, "pan.___", state 809, "else" + line 421, "pan.___", state 811, "(1)" + line 421, "pan.___", state 811, "(1)" + line 401, "pan.___", state 818, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 401, "pan.___", state 820, "(1)" + line 401, "pan.___", state 821, "((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid)))" + line 401, "pan.___", state 821, "else" + line 401, "pan.___", state 824, "(1)" + line 405, "pan.___", state 832, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 405, "pan.___", state 834, "(1)" + line 405, "pan.___", state 835, "((cache_dirty_urcu_active_readers.bitfield&(1<<_pid)))" + line 405, "pan.___", state 835, "else" + line 405, "pan.___", state 838, "(1)" + line 405, "pan.___", state 839, "(1)" + line 405, "pan.___", state 839, "(1)" + line 403, "pan.___", state 844, "((i<1))" + line 403, "pan.___", state 844, "((i>=1))" + line 410, "pan.___", state 850, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 852, "(1)" + line 410, "pan.___", state 853, "((cache_dirty_rcu_ptr.bitfield&(1<<_pid)))" + line 410, "pan.___", state 853, "else" + line 410, "pan.___", state 856, "(1)" + line 410, "pan.___", state 857, "(1)" + line 410, "pan.___", state 857, "(1)" + line 414, "pan.___", state 864, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 414, "pan.___", state 866, "(1)" + line 414, "pan.___", state 867, "((cache_dirty_rcu_data[i].bitfield&(1<<_pid)))" + line 414, "pan.___", state 867, "else" + line 414, "pan.___", state 870, "(1)" + line 414, "pan.___", state 871, "(1)" + line 414, "pan.___", state 871, "(1)" + line 412, "pan.___", state 876, "((i<2))" + line 412, "pan.___", state 876, "((i>=2))" + line 239, "pan.___", state 882, "(1)" + line 243, "pan.___", state 890, "(1)" + line 243, "pan.___", state 891, "(!((cache_dirty_urcu_active_readers.bitfield&(1<<_pid))))" + line 243, "pan.___", state 891, "else" + line 241, "pan.___", state 896, "((i<1))" + line 241, "pan.___", state 896, "((i>=1))" + line 247, "pan.___", state 902, "(1)" + line 247, "pan.___", state 903, "(!((cache_dirty_rcu_ptr.bitfield&(1<<_pid))))" + line 247, "pan.___", state 903, "else" + line 251, "pan.___", state 910, "(1)" + line 251, "pan.___", state 911, "(!((cache_dirty_rcu_data[i].bitfield&(1<<_pid))))" + line 251, "pan.___", state 911, "else" + line 249, "pan.___", state 916, "((i<2))" + line 249, "pan.___", state 916, "((i>=2))" + line 256, "pan.___", state 920, "(!((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid))))" + line 256, "pan.___", state 920, "else" + line 421, "pan.___", state 922, "(1)" + line 421, "pan.___", state 922, "(1)" + line 688, "pan.___", state 926, "_proc_urcu_reader = (_proc_urcu_reader|(1<<11))" + line 401, "pan.___", state 931, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 963, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 977, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 995, "(1)" + line 247, "pan.___", state 1015, "(1)" + line 251, "pan.___", state 1023, "(1)" + line 401, "pan.___", state 1045, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 1077, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 1091, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 1109, "(1)" + line 247, "pan.___", state 1129, "(1)" + line 251, "pan.___", state 1137, "(1)" + line 401, "pan.___", state 1160, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 1192, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 1206, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 1224, "(1)" + line 247, "pan.___", state 1244, "(1)" + line 251, "pan.___", state 1252, "(1)" + line 401, "pan.___", state 1271, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 1303, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 1317, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 1335, "(1)" + line 247, "pan.___", state 1355, "(1)" + line 251, "pan.___", state 1363, "(1)" + line 401, "pan.___", state 1387, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 1419, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 1433, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 1451, "(1)" + line 247, "pan.___", state 1471, "(1)" + line 251, "pan.___", state 1479, "(1)" + line 401, "pan.___", state 1498, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 1530, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 1544, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 1562, "(1)" + line 247, "pan.___", state 1582, "(1)" + line 251, "pan.___", state 1590, "(1)" + line 401, "pan.___", state 1612, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 1644, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 1658, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 1676, "(1)" + line 247, "pan.___", state 1696, "(1)" + line 251, "pan.___", state 1704, "(1)" + line 727, "pan.___", state 1723, "_proc_urcu_reader = (_proc_urcu_reader|((1<<2)<<19))" + line 401, "pan.___", state 1730, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 1762, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 1776, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 1794, "(1)" + line 247, "pan.___", state 1814, "(1)" + line 251, "pan.___", state 1822, "(1)" + line 401, "pan.___", state 1841, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 1873, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 1887, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 1905, "(1)" + line 247, "pan.___", state 1925, "(1)" + line 251, "pan.___", state 1933, "(1)" + line 401, "pan.___", state 1954, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 401, "pan.___", state 1956, "(1)" + line 401, "pan.___", state 1957, "((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid)))" + line 401, "pan.___", state 1957, "else" + line 401, "pan.___", state 1960, "(1)" + line 405, "pan.___", state 1968, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 405, "pan.___", state 1970, "(1)" + line 405, "pan.___", state 1971, "((cache_dirty_urcu_active_readers.bitfield&(1<<_pid)))" + line 405, "pan.___", state 1971, "else" + line 405, "pan.___", state 1974, "(1)" + line 405, "pan.___", state 1975, "(1)" + line 405, "pan.___", state 1975, "(1)" + line 403, "pan.___", state 1980, "((i<1))" + line 403, "pan.___", state 1980, "((i>=1))" + line 410, "pan.___", state 1986, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 1988, "(1)" + line 410, "pan.___", state 1989, "((cache_dirty_rcu_ptr.bitfield&(1<<_pid)))" + line 410, "pan.___", state 1989, "else" + line 410, "pan.___", state 1992, "(1)" + line 410, "pan.___", state 1993, "(1)" + line 410, "pan.___", state 1993, "(1)" + line 414, "pan.___", state 2000, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 414, "pan.___", state 2002, "(1)" + line 414, "pan.___", state 2003, "((cache_dirty_rcu_data[i].bitfield&(1<<_pid)))" + line 414, "pan.___", state 2003, "else" + line 414, "pan.___", state 2006, "(1)" + line 414, "pan.___", state 2007, "(1)" + line 414, "pan.___", state 2007, "(1)" + line 412, "pan.___", state 2012, "((i<2))" + line 412, "pan.___", state 2012, "((i>=2))" + line 239, "pan.___", state 2018, "(1)" + line 243, "pan.___", state 2026, "(1)" + line 243, "pan.___", state 2027, "(!((cache_dirty_urcu_active_readers.bitfield&(1<<_pid))))" + line 243, "pan.___", state 2027, "else" + line 241, "pan.___", state 2032, "((i<1))" + line 241, "pan.___", state 2032, "((i>=1))" + line 247, "pan.___", state 2038, "(1)" + line 247, "pan.___", state 2039, "(!((cache_dirty_rcu_ptr.bitfield&(1<<_pid))))" + line 247, "pan.___", state 2039, "else" + line 251, "pan.___", state 2046, "(1)" + line 251, "pan.___", state 2047, "(!((cache_dirty_rcu_data[i].bitfield&(1<<_pid))))" + line 251, "pan.___", state 2047, "else" + line 249, "pan.___", state 2052, "((i<2))" + line 249, "pan.___", state 2052, "((i>=2))" + line 256, "pan.___", state 2056, "(!((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid))))" + line 256, "pan.___", state 2056, "else" + line 421, "pan.___", state 2058, "(1)" + line 421, "pan.___", state 2058, "(1)" + line 727, "pan.___", state 2061, "cached_urcu_active_readers.val[_pid] = (tmp+1)" + line 727, "pan.___", state 2062, "_proc_urcu_reader = (_proc_urcu_reader|(1<<23))" + line 727, "pan.___", state 2063, "(1)" + line 401, "pan.___", state 2070, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 2102, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 2116, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 2134, "(1)" + line 247, "pan.___", state 2154, "(1)" + line 251, "pan.___", state 2162, "(1)" + line 401, "pan.___", state 2187, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 2219, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 2233, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 2251, "(1)" + line 247, "pan.___", state 2271, "(1)" + line 251, "pan.___", state 2279, "(1)" + line 401, "pan.___", state 2298, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 2330, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 2344, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 2362, "(1)" + line 247, "pan.___", state 2382, "(1)" + line 251, "pan.___", state 2390, "(1)" + line 239, "pan.___", state 2421, "(1)" + line 247, "pan.___", state 2441, "(1)" + line 251, "pan.___", state 2449, "(1)" + line 239, "pan.___", state 2464, "(1)" + line 247, "pan.___", state 2484, "(1)" + line 251, "pan.___", state 2492, "(1)" + line 887, "pan.___", state 2509, "-end-" + (246 of 2509 states) +unreached in proctype urcu_writer + line 401, "pan.___", state 22, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 405, "pan.___", state 36, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 54, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 239, "pan.___", state 86, "(1)" + line 243, "pan.___", state 94, "(1)" + line 247, "pan.___", state 106, "(1)" + line 262, "pan.___", state 135, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 266, "pan.___", state 144, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 270, "pan.___", state 157, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 401, "pan.___", state 197, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 405, "pan.___", state 211, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 229, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 243, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 261, "(1)" + line 243, "pan.___", state 269, "(1)" + line 247, "pan.___", state 281, "(1)" + line 251, "pan.___", state 289, "(1)" + line 405, "pan.___", state 324, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 342, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 356, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 243, "pan.___", state 382, "(1)" + line 247, "pan.___", state 394, "(1)" + line 251, "pan.___", state 402, "(1)" + line 401, "pan.___", state 429, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 401, "pan.___", state 431, "(1)" + line 401, "pan.___", state 432, "((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid)))" + line 401, "pan.___", state 432, "else" + line 401, "pan.___", state 435, "(1)" + line 405, "pan.___", state 443, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 405, "pan.___", state 445, "(1)" + line 405, "pan.___", state 446, "((cache_dirty_urcu_active_readers.bitfield&(1<<_pid)))" + line 405, "pan.___", state 446, "else" + line 405, "pan.___", state 449, "(1)" + line 405, "pan.___", state 450, "(1)" + line 405, "pan.___", state 450, "(1)" + line 403, "pan.___", state 455, "((i<1))" + line 403, "pan.___", state 455, "((i>=1))" + line 410, "pan.___", state 461, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 463, "(1)" + line 410, "pan.___", state 464, "((cache_dirty_rcu_ptr.bitfield&(1<<_pid)))" + line 410, "pan.___", state 464, "else" + line 410, "pan.___", state 467, "(1)" + line 410, "pan.___", state 468, "(1)" + line 410, "pan.___", state 468, "(1)" + line 414, "pan.___", state 475, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 414, "pan.___", state 477, "(1)" + line 414, "pan.___", state 478, "((cache_dirty_rcu_data[i].bitfield&(1<<_pid)))" + line 414, "pan.___", state 478, "else" + line 414, "pan.___", state 481, "(1)" + line 414, "pan.___", state 482, "(1)" + line 414, "pan.___", state 482, "(1)" + line 412, "pan.___", state 487, "((i<2))" + line 412, "pan.___", state 487, "((i>=2))" + line 239, "pan.___", state 493, "(1)" + line 243, "pan.___", state 501, "(1)" + line 243, "pan.___", state 502, "(!((cache_dirty_urcu_active_readers.bitfield&(1<<_pid))))" + line 243, "pan.___", state 502, "else" + line 241, "pan.___", state 507, "((i<1))" + line 241, "pan.___", state 507, "((i>=1))" + line 247, "pan.___", state 513, "(1)" + line 247, "pan.___", state 514, "(!((cache_dirty_rcu_ptr.bitfield&(1<<_pid))))" + line 247, "pan.___", state 514, "else" + line 251, "pan.___", state 521, "(1)" + line 251, "pan.___", state 522, "(!((cache_dirty_rcu_data[i].bitfield&(1<<_pid))))" + line 251, "pan.___", state 522, "else" + line 256, "pan.___", state 531, "(!((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid))))" + line 256, "pan.___", state 531, "else" + line 421, "pan.___", state 533, "(1)" + line 421, "pan.___", state 533, "(1)" + line 401, "pan.___", state 540, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 401, "pan.___", state 542, "(1)" + line 401, "pan.___", state 543, "((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid)))" + line 401, "pan.___", state 543, "else" + line 401, "pan.___", state 546, "(1)" + line 405, "pan.___", state 554, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 405, "pan.___", state 556, "(1)" + line 405, "pan.___", state 557, "((cache_dirty_urcu_active_readers.bitfield&(1<<_pid)))" + line 405, "pan.___", state 557, "else" + line 405, "pan.___", state 560, "(1)" + line 405, "pan.___", state 561, "(1)" + line 405, "pan.___", state 561, "(1)" + line 403, "pan.___", state 566, "((i<1))" + line 403, "pan.___", state 566, "((i>=1))" + line 410, "pan.___", state 572, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 574, "(1)" + line 410, "pan.___", state 575, "((cache_dirty_rcu_ptr.bitfield&(1<<_pid)))" + line 410, "pan.___", state 575, "else" + line 410, "pan.___", state 578, "(1)" + line 410, "pan.___", state 579, "(1)" + line 410, "pan.___", state 579, "(1)" + line 414, "pan.___", state 586, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 414, "pan.___", state 588, "(1)" + line 414, "pan.___", state 589, "((cache_dirty_rcu_data[i].bitfield&(1<<_pid)))" + line 414, "pan.___", state 589, "else" + line 414, "pan.___", state 592, "(1)" + line 414, "pan.___", state 593, "(1)" + line 414, "pan.___", state 593, "(1)" + line 412, "pan.___", state 598, "((i<2))" + line 412, "pan.___", state 598, "((i>=2))" + line 239, "pan.___", state 604, "(1)" + line 243, "pan.___", state 612, "(1)" + line 243, "pan.___", state 613, "(!((cache_dirty_urcu_active_readers.bitfield&(1<<_pid))))" + line 243, "pan.___", state 613, "else" + line 241, "pan.___", state 618, "((i<1))" + line 241, "pan.___", state 618, "((i>=1))" + line 247, "pan.___", state 624, "(1)" + line 247, "pan.___", state 625, "(!((cache_dirty_rcu_ptr.bitfield&(1<<_pid))))" + line 247, "pan.___", state 625, "else" + line 251, "pan.___", state 632, "(1)" + line 251, "pan.___", state 633, "(!((cache_dirty_rcu_data[i].bitfield&(1<<_pid))))" + line 251, "pan.___", state 633, "else" + line 249, "pan.___", state 638, "((i<2))" + line 249, "pan.___", state 638, "((i>=2))" + line 256, "pan.___", state 642, "(!((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid))))" + line 256, "pan.___", state 642, "else" + line 421, "pan.___", state 644, "(1)" + line 421, "pan.___", state 644, "(1)" + line 1095, "pan.___", state 648, "_proc_urcu_writer = (_proc_urcu_writer|(1<<10))" + line 401, "pan.___", state 653, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 401, "pan.___", state 655, "(1)" + line 401, "pan.___", state 656, "((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid)))" + line 401, "pan.___", state 656, "else" + line 401, "pan.___", state 659, "(1)" + line 405, "pan.___", state 667, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 405, "pan.___", state 669, "(1)" + line 405, "pan.___", state 670, "((cache_dirty_urcu_active_readers.bitfield&(1<<_pid)))" + line 405, "pan.___", state 670, "else" + line 405, "pan.___", state 673, "(1)" + line 405, "pan.___", state 674, "(1)" + line 405, "pan.___", state 674, "(1)" + line 403, "pan.___", state 679, "((i<1))" + line 403, "pan.___", state 679, "((i>=1))" + line 410, "pan.___", state 685, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 687, "(1)" + line 410, "pan.___", state 688, "((cache_dirty_rcu_ptr.bitfield&(1<<_pid)))" + line 410, "pan.___", state 688, "else" + line 410, "pan.___", state 691, "(1)" + line 410, "pan.___", state 692, "(1)" + line 410, "pan.___", state 692, "(1)" + line 414, "pan.___", state 699, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 414, "pan.___", state 701, "(1)" + line 414, "pan.___", state 702, "((cache_dirty_rcu_data[i].bitfield&(1<<_pid)))" + line 414, "pan.___", state 702, "else" + line 414, "pan.___", state 705, "(1)" + line 414, "pan.___", state 706, "(1)" + line 414, "pan.___", state 706, "(1)" + line 412, "pan.___", state 711, "((i<2))" + line 412, "pan.___", state 711, "((i>=2))" + line 239, "pan.___", state 717, "(1)" + line 243, "pan.___", state 725, "(1)" + line 243, "pan.___", state 726, "(!((cache_dirty_urcu_active_readers.bitfield&(1<<_pid))))" + line 243, "pan.___", state 726, "else" + line 241, "pan.___", state 731, "((i<1))" + line 241, "pan.___", state 731, "((i>=1))" + line 247, "pan.___", state 737, "(1)" + line 247, "pan.___", state 738, "(!((cache_dirty_rcu_ptr.bitfield&(1<<_pid))))" + line 247, "pan.___", state 738, "else" + line 251, "pan.___", state 745, "(1)" + line 251, "pan.___", state 746, "(!((cache_dirty_rcu_data[i].bitfield&(1<<_pid))))" + line 251, "pan.___", state 746, "else" + line 249, "pan.___", state 751, "((i<2))" + line 249, "pan.___", state 751, "((i>=2))" + line 256, "pan.___", state 755, "(!((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid))))" + line 256, "pan.___", state 755, "else" + line 421, "pan.___", state 757, "(1)" + line 421, "pan.___", state 757, "(1)" + line 1110, "pan.___", state 762, "_proc_urcu_writer = (_proc_urcu_writer|(1<<11))" + line 1105, "pan.___", state 763, "(((tmp2&((1<<7)-1))&&((tmp2^0)&(1<<7))))" + line 1105, "pan.___", state 763, "else" + line 1130, "pan.___", state 767, "_proc_urcu_writer = (_proc_urcu_writer&~(((1<<12)|(1<<11))))" + line 262, "pan.___", state 798, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 266, "pan.___", state 807, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 270, "pan.___", state 822, "(1)" + line 274, "pan.___", state 829, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 845, "(1)" + line 243, "pan.___", state 853, "(1)" + line 247, "pan.___", state 865, "(1)" + line 251, "pan.___", state 873, "(1)" + line 262, "pan.___", state 904, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 266, "pan.___", state 913, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 270, "pan.___", state 926, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 274, "pan.___", state 935, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 951, "(1)" + line 243, "pan.___", state 959, "(1)" + line 247, "pan.___", state 971, "(1)" + line 251, "pan.___", state 979, "(1)" + line 266, "pan.___", state 1005, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 270, "pan.___", state 1018, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 274, "pan.___", state 1027, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 1043, "(1)" + line 243, "pan.___", state 1051, "(1)" + line 247, "pan.___", state 1063, "(1)" + line 251, "pan.___", state 1071, "(1)" + line 262, "pan.___", state 1102, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 266, "pan.___", state 1111, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 270, "pan.___", state 1124, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 274, "pan.___", state 1133, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 1149, "(1)" + line 243, "pan.___", state 1157, "(1)" + line 247, "pan.___", state 1169, "(1)" + line 251, "pan.___", state 1177, "(1)" + line 262, "pan.___", state 1194, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 262, "pan.___", state 1196, "(1)" + line 266, "pan.___", state 1203, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 266, "pan.___", state 1205, "(1)" + line 266, "pan.___", state 1206, "((cache_dirty_urcu_active_readers.bitfield&(1<<_pid)))" + line 266, "pan.___", state 1206, "else" + line 264, "pan.___", state 1211, "((i<1))" + line 264, "pan.___", state 1211, "((i>=1))" + line 270, "pan.___", state 1216, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 270, "pan.___", state 1218, "(1)" + line 270, "pan.___", state 1219, "((cache_dirty_rcu_ptr.bitfield&(1<<_pid)))" + line 270, "pan.___", state 1219, "else" + line 274, "pan.___", state 1225, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 274, "pan.___", state 1227, "(1)" + line 274, "pan.___", state 1228, "((cache_dirty_rcu_data[i].bitfield&(1<<_pid)))" + line 274, "pan.___", state 1228, "else" + line 272, "pan.___", state 1233, "((i<2))" + line 272, "pan.___", state 1233, "((i>=2))" + line 239, "pan.___", state 1241, "(1)" + line 243, "pan.___", state 1249, "(1)" + line 243, "pan.___", state 1250, "(!((cache_dirty_urcu_active_readers.bitfield&(1<<_pid))))" + line 243, "pan.___", state 1250, "else" + line 241, "pan.___", state 1255, "((i<1))" + line 241, "pan.___", state 1255, "((i>=1))" + line 247, "pan.___", state 1261, "(1)" + line 247, "pan.___", state 1262, "(!((cache_dirty_rcu_ptr.bitfield&(1<<_pid))))" + line 247, "pan.___", state 1262, "else" + line 251, "pan.___", state 1269, "(1)" + line 251, "pan.___", state 1270, "(!((cache_dirty_rcu_data[i].bitfield&(1<<_pid))))" + line 251, "pan.___", state 1270, "else" + line 256, "pan.___", state 1279, "(!((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid))))" + line 256, "pan.___", state 1279, "else" + line 1206, "pan.___", state 1282, "i = 0" + line 1206, "pan.___", state 1284, "reader_barrier = 1" + line 1206, "pan.___", state 1295, "((i<1))" + line 1206, "pan.___", state 1295, "((i>=1))" + line 262, "pan.___", state 1300, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 262, "pan.___", state 1302, "(1)" + line 266, "pan.___", state 1309, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 266, "pan.___", state 1311, "(1)" + line 266, "pan.___", state 1312, "((cache_dirty_urcu_active_readers.bitfield&(1<<_pid)))" + line 266, "pan.___", state 1312, "else" + line 264, "pan.___", state 1317, "((i<1))" + line 264, "pan.___", state 1317, "((i>=1))" + line 270, "pan.___", state 1322, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 270, "pan.___", state 1324, "(1)" + line 270, "pan.___", state 1325, "((cache_dirty_rcu_ptr.bitfield&(1<<_pid)))" + line 270, "pan.___", state 1325, "else" + line 274, "pan.___", state 1331, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 274, "pan.___", state 1333, "(1)" + line 274, "pan.___", state 1334, "((cache_dirty_rcu_data[i].bitfield&(1<<_pid)))" + line 274, "pan.___", state 1334, "else" + line 272, "pan.___", state 1339, "((i<2))" + line 272, "pan.___", state 1339, "((i>=2))" + line 239, "pan.___", state 1347, "(1)" + line 243, "pan.___", state 1355, "(1)" + line 243, "pan.___", state 1356, "(!((cache_dirty_urcu_active_readers.bitfield&(1<<_pid))))" + line 243, "pan.___", state 1356, "else" + line 241, "pan.___", state 1361, "((i<1))" + line 241, "pan.___", state 1361, "((i>=1))" + line 247, "pan.___", state 1367, "(1)" + line 247, "pan.___", state 1368, "(!((cache_dirty_rcu_ptr.bitfield&(1<<_pid))))" + line 247, "pan.___", state 1368, "else" + line 251, "pan.___", state 1375, "(1)" + line 251, "pan.___", state 1376, "(!((cache_dirty_rcu_data[i].bitfield&(1<<_pid))))" + line 251, "pan.___", state 1376, "else" + line 256, "pan.___", state 1385, "(!((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid))))" + line 256, "pan.___", state 1385, "else" + line 289, "pan.___", state 1387, "((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid)))" + line 289, "pan.___", state 1387, "else" + line 1206, "pan.___", state 1388, "((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid)))" + line 1206, "pan.___", state 1388, "else" + line 266, "pan.___", state 1401, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 270, "pan.___", state 1414, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 274, "pan.___", state 1423, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 1439, "(1)" + line 243, "pan.___", state 1447, "(1)" + line 247, "pan.___", state 1459, "(1)" + line 251, "pan.___", state 1467, "(1)" + line 262, "pan.___", state 1498, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 266, "pan.___", state 1507, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 270, "pan.___", state 1520, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 274, "pan.___", state 1529, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 1545, "(1)" + line 243, "pan.___", state 1553, "(1)" + line 247, "pan.___", state 1565, "(1)" + line 251, "pan.___", state 1573, "(1)" + line 1214, "pan.___", state 1589, "-end-" + (218 of 1589 states) +unreached in proctype :init: + line 1225, "pan.___", state 9, "((j<2))" + line 1225, "pan.___", state 9, "((j>=2))" + line 1226, "pan.___", state 20, "((j<2))" + line 1226, "pan.___", state 20, "((j>=2))" + line 1231, "pan.___", state 33, "((j<2))" + line 1231, "pan.___", state 33, "((j>=2))" + line 1229, "pan.___", state 43, "((i<1))" + line 1229, "pan.___", state 43, "((i>=1))" + line 1239, "pan.___", state 54, "((j<2))" + line 1239, "pan.___", state 54, "((j>=2))" + line 1243, "pan.___", state 67, "((j<2))" + line 1243, "pan.___", state 67, "((j>=2))" + (6 of 78 states) +unreached in proctype :never: + line 1277, "pan.___", state 8, "-end-" + (1 of 8 states) + +pan: elapsed time 102 seconds +pan: rate 52558.797 states/second +pan: avg transition delay 2.5934e-06 usec +cp .input.spin urcu_free_single_flip.spin.input +cp .input.spin.trail urcu_free_single_flip.spin.input.trail +make[1]: Leaving directory `/home/compudj/doc/userspace-rcu/formal-model/urcu-controldataflow' diff --git a/formal-model/results/urcu-controldataflow-ipi-intel/urcu_free_single_flip.spin.input b/formal-model/results/urcu-controldataflow-ipi-intel/urcu_free_single_flip.spin.input new file mode 100644 index 0000000..240a2fd --- /dev/null +++ b/formal-model/results/urcu-controldataflow-ipi-intel/urcu_free_single_flip.spin.input @@ -0,0 +1,1250 @@ +#define SINGLE_FLIP + +// Poison value for freed memory +#define POISON 1 +// Memory with correct data +#define WINE 0 +#define SLAB_SIZE 2 + +#define read_poison (data_read_first[0] == POISON || data_read_second[0] == POISON) + +#define RCU_GP_CTR_BIT (1 << 7) +#define RCU_GP_CTR_NEST_MASK (RCU_GP_CTR_BIT - 1) + +//disabled +#define REMOTE_BARRIERS + +//#define ARCH_ALPHA +#define ARCH_INTEL +//#define ARCH_POWERPC +/* + * mem.spin: Promela code to validate memory barriers with OOO memory + * and out-of-order instruction scheduling. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * Copyright (c) 2009 Mathieu Desnoyers + */ + +/* Promela validation variables. */ + +/* specific defines "included" here */ +/* DEFINES file "included" here */ + +#define NR_READERS 1 +#define NR_WRITERS 1 + +#define NR_PROCS 2 + +#define get_pid() (_pid) + +#define get_readerid() (get_pid()) + +/* + * Produced process control and data flow. Updated after each instruction to + * show which variables are ready. Using one-hot bit encoding per variable to + * save state space. Used as triggers to execute the instructions having those + * variables as input. Leaving bits active to inhibit instruction execution. + * Scheme used to make instruction disabling and automatic dependency fall-back + * automatic. + */ + +#define CONSUME_TOKENS(state, bits, notbits) \ + ((!(state & (notbits))) && (state & (bits)) == (bits)) + +#define PRODUCE_TOKENS(state, bits) \ + state = state | (bits); + +#define CLEAR_TOKENS(state, bits) \ + state = state & ~(bits) + +/* + * Types of dependency : + * + * Data dependency + * + * - True dependency, Read-after-Write (RAW) + * + * This type of dependency happens when a statement depends on the result of a + * previous statement. This applies to any statement which needs to read a + * variable written by a preceding statement. + * + * - False dependency, Write-after-Read (WAR) + * + * Typically, variable renaming can ensure that this dependency goes away. + * However, if the statements must read and then write from/to the same variable + * in the OOO memory model, renaming may be impossible, and therefore this + * causes a WAR dependency. + * + * - Output dependency, Write-after-Write (WAW) + * + * Two writes to the same variable in subsequent statements. Variable renaming + * can ensure this is not needed, but can be required when writing multiple + * times to the same OOO mem model variable. + * + * Control dependency + * + * Execution of a given instruction depends on a previous instruction evaluating + * in a way that allows its execution. E.g. : branches. + * + * Useful considerations for joining dependencies after branch + * + * - Pre-dominance + * + * "We say box i dominates box j if every path (leading from input to output + * through the diagram) which passes through box j must also pass through box + * i. Thus box i dominates box j if box j is subordinate to box i in the + * program." + * + * http://www.hipersoft.rice.edu/grads/publications/dom14.pdf + * Other classic algorithm to calculate dominance : Lengauer-Tarjan (in gcc) + * + * - Post-dominance + * + * Just as pre-dominance, but with arcs of the data flow inverted, and input vs + * output exchanged. Therefore, i post-dominating j ensures that every path + * passing by j will pass by i before reaching the output. + * + * Other considerations + * + * Note about "volatile" keyword dependency : The compiler will order volatile + * accesses so they appear in the right order on a given CPU. They can be + * reordered by the CPU instruction scheduling. This therefore cannot be + * considered as a depencency. + * + * References : + * + * Cooper, Keith D.; & Torczon, Linda. (2005). Engineering a Compiler. Morgan + * Kaufmann. ISBN 1-55860-698-X. + * Kennedy, Ken; & Allen, Randy. (2001). Optimizing Compilers for Modern + * Architectures: A Dependence-based Approach. Morgan Kaufmann. ISBN + * 1-55860-286-0. + * Muchnick, Steven S. (1997). Advanced Compiler Design and Implementation. + * Morgan Kaufmann. ISBN 1-55860-320-4. + */ + +/* + * Note about loops and nested calls + * + * To keep this model simple, loops expressed in the framework will behave as if + * there was a core synchronizing instruction between loops. To see the effect + * of loop unrolling, manually unrolling loops is required. Note that if loops + * end or start with a core synchronizing instruction, the model is appropriate. + * Nested calls are not supported. + */ + +/* + * Only Alpha has out-of-order cache bank loads. Other architectures (intel, + * powerpc, arm) ensure that dependent reads won't be reordered. c.f. + * http://www.linuxjournal.com/article/8212) +#ifdef ARCH_ALPHA +#define HAVE_OOO_CACHE_READ +#endif + +/* + * Each process have its own data in cache. Caches are randomly updated. + * smp_wmb and smp_rmb forces cache updates (write and read), smp_mb forces + * both. + */ + +typedef per_proc_byte { + byte val[NR_PROCS]; +}; + +typedef per_proc_bit { + bit val[NR_PROCS]; +}; + +/* Bitfield has a maximum of 8 procs */ +typedef per_proc_bitfield { + byte bitfield; +}; + +#define DECLARE_CACHED_VAR(type, x) \ + type mem_##x; \ + per_proc_##type cached_##x; \ + per_proc_bitfield cache_dirty_##x; + +#define INIT_CACHED_VAR(x, v, j) \ + mem_##x = v; \ + cache_dirty_##x.bitfield = 0; \ + j = 0; \ + do \ + :: j < NR_PROCS -> \ + cached_##x.val[j] = v; \ + j++ \ + :: j >= NR_PROCS -> break \ + od; + +#define IS_CACHE_DIRTY(x, id) (cache_dirty_##x.bitfield & (1 << id)) + +#define READ_CACHED_VAR(x) (cached_##x.val[get_pid()]) + +#define WRITE_CACHED_VAR(x, v) \ + atomic { \ + cached_##x.val[get_pid()] = v; \ + cache_dirty_##x.bitfield = \ + cache_dirty_##x.bitfield | (1 << get_pid()); \ + } + +#define CACHE_WRITE_TO_MEM(x, id) \ + if \ + :: IS_CACHE_DIRTY(x, id) -> \ + mem_##x = cached_##x.val[id]; \ + cache_dirty_##x.bitfield = \ + cache_dirty_##x.bitfield & (~(1 << id)); \ + :: else -> \ + skip \ + fi; + +#define CACHE_READ_FROM_MEM(x, id) \ + if \ + :: !IS_CACHE_DIRTY(x, id) -> \ + cached_##x.val[id] = mem_##x;\ + :: else -> \ + skip \ + fi; + +/* + * May update other caches if cache is dirty, or not. + */ +#define RANDOM_CACHE_WRITE_TO_MEM(x, id)\ + if \ + :: 1 -> CACHE_WRITE_TO_MEM(x, id); \ + :: 1 -> skip \ + fi; + +#define RANDOM_CACHE_READ_FROM_MEM(x, id)\ + if \ + :: 1 -> CACHE_READ_FROM_MEM(x, id); \ + :: 1 -> skip \ + fi; + +/* Must consume all prior read tokens. All subsequent reads depend on it. */ +inline smp_rmb(i) +{ + atomic { + CACHE_READ_FROM_MEM(urcu_gp_ctr, get_pid()); + i = 0; + do + :: i < NR_READERS -> + CACHE_READ_FROM_MEM(urcu_active_readers[i], get_pid()); + i++ + :: i >= NR_READERS -> break + od; + CACHE_READ_FROM_MEM(rcu_ptr, get_pid()); + i = 0; + do + :: i < SLAB_SIZE -> + CACHE_READ_FROM_MEM(rcu_data[i], get_pid()); + i++ + :: i >= SLAB_SIZE -> break + od; + } +} + +/* Must consume all prior write tokens. All subsequent writes depend on it. */ +inline smp_wmb(i) +{ + atomic { + CACHE_WRITE_TO_MEM(urcu_gp_ctr, get_pid()); + i = 0; + do + :: i < NR_READERS -> + CACHE_WRITE_TO_MEM(urcu_active_readers[i], get_pid()); + i++ + :: i >= NR_READERS -> break + od; + CACHE_WRITE_TO_MEM(rcu_ptr, get_pid()); + i = 0; + do + :: i < SLAB_SIZE -> + CACHE_WRITE_TO_MEM(rcu_data[i], get_pid()); + i++ + :: i >= SLAB_SIZE -> break + od; + } +} + +/* Synchronization point. Must consume all prior read and write tokens. All + * subsequent reads and writes depend on it. */ +inline smp_mb(i) +{ + atomic { + smp_wmb(i); + smp_rmb(i); + } +} + +#ifdef REMOTE_BARRIERS + +bit reader_barrier[NR_READERS]; + +/* + * We cannot leave the barriers dependencies in place in REMOTE_BARRIERS mode + * because they would add unexisting core synchronization and would therefore + * create an incomplete model. + * Therefore, we model the read-side memory barriers by completely disabling the + * memory barriers and their dependencies from the read-side. One at a time + * (different verification runs), we make a different instruction listen for + * signals. + */ + +#define smp_mb_reader(i, j) + +/* + * Service 0, 1 or many barrier requests. + */ +inline smp_mb_recv(i, j) +{ + do + :: (reader_barrier[get_readerid()] == 1) -> + /* + * We choose to ignore cycles caused by writer busy-looping, + * waiting for the reader, sending barrier requests, and the + * reader always services them without continuing execution. + */ +progress_ignoring_mb1: + smp_mb(i); + reader_barrier[get_readerid()] = 0; + :: 1 -> + /* + * We choose to ignore writer's non-progress caused by the + * reader ignoring the writer's mb() requests. + */ +progress_ignoring_mb2: + break; + od; +} + +#define PROGRESS_LABEL(progressid) progress_writer_progid_##progressid: + +#define smp_mb_send(i, j, progressid) \ +{ \ + smp_mb(i); \ + i = 0; \ + do \ + :: i < NR_READERS -> \ + reader_barrier[i] = 1; \ + /* \ + * Busy-looping waiting for reader barrier handling is of little\ + * interest, given the reader has the ability to totally ignore \ + * barrier requests. \ + */ \ + do \ + :: (reader_barrier[i] == 1) -> \ +PROGRESS_LABEL(progressid) \ + skip; \ + :: (reader_barrier[i] == 0) -> break; \ + od; \ + i++; \ + :: i >= NR_READERS -> \ + break \ + od; \ + smp_mb(i); \ +} + +#else + +#define smp_mb_send(i, j, progressid) smp_mb(i) +#define smp_mb_reader smp_mb(i) +#define smp_mb_recv(i, j) + +#endif + +/* Keep in sync manually with smp_rmb, smp_wmb, ooo_mem and init() */ +DECLARE_CACHED_VAR(byte, urcu_gp_ctr); +/* Note ! currently only one reader */ +DECLARE_CACHED_VAR(byte, urcu_active_readers[NR_READERS]); +/* RCU data */ +DECLARE_CACHED_VAR(bit, rcu_data[SLAB_SIZE]); + +/* RCU pointer */ +#if (SLAB_SIZE == 2) +DECLARE_CACHED_VAR(bit, rcu_ptr); +bit ptr_read_first[NR_READERS]; +bit ptr_read_second[NR_READERS]; +#else +DECLARE_CACHED_VAR(byte, rcu_ptr); +byte ptr_read_first[NR_READERS]; +byte ptr_read_second[NR_READERS]; +#endif + +bit data_read_first[NR_READERS]; +bit data_read_second[NR_READERS]; + +bit init_done = 0; + +inline wait_init_done() +{ + do + :: init_done == 0 -> skip; + :: else -> break; + od; +} + +inline ooo_mem(i) +{ + atomic { + RANDOM_CACHE_WRITE_TO_MEM(urcu_gp_ctr, get_pid()); + i = 0; + do + :: i < NR_READERS -> + RANDOM_CACHE_WRITE_TO_MEM(urcu_active_readers[i], + get_pid()); + i++ + :: i >= NR_READERS -> break + od; + RANDOM_CACHE_WRITE_TO_MEM(rcu_ptr, get_pid()); + i = 0; + do + :: i < SLAB_SIZE -> + RANDOM_CACHE_WRITE_TO_MEM(rcu_data[i], get_pid()); + i++ + :: i >= SLAB_SIZE -> break + od; +#ifdef HAVE_OOO_CACHE_READ + RANDOM_CACHE_READ_FROM_MEM(urcu_gp_ctr, get_pid()); + i = 0; + do + :: i < NR_READERS -> + RANDOM_CACHE_READ_FROM_MEM(urcu_active_readers[i], + get_pid()); + i++ + :: i >= NR_READERS -> break + od; + RANDOM_CACHE_READ_FROM_MEM(rcu_ptr, get_pid()); + i = 0; + do + :: i < SLAB_SIZE -> + RANDOM_CACHE_READ_FROM_MEM(rcu_data[i], get_pid()); + i++ + :: i >= SLAB_SIZE -> break + od; +#else + smp_rmb(i); +#endif /* HAVE_OOO_CACHE_READ */ + } +} + +/* + * Bit encoding, urcu_reader : + */ + +int _proc_urcu_reader; +#define proc_urcu_reader _proc_urcu_reader + +/* Body of PROCEDURE_READ_LOCK */ +#define READ_PROD_A_READ (1 << 0) +#define READ_PROD_B_IF_TRUE (1 << 1) +#define READ_PROD_B_IF_FALSE (1 << 2) +#define READ_PROD_C_IF_TRUE_READ (1 << 3) + +#define PROCEDURE_READ_LOCK(base, consumetoken, producetoken) \ + :: CONSUME_TOKENS(proc_urcu_reader, consumetoken, READ_PROD_A_READ << base) -> \ + ooo_mem(i); \ + tmp = READ_CACHED_VAR(urcu_active_readers[get_readerid()]); \ + PRODUCE_TOKENS(proc_urcu_reader, READ_PROD_A_READ << base); \ + :: CONSUME_TOKENS(proc_urcu_reader, \ + READ_PROD_A_READ << base, /* RAW, pre-dominant */ \ + (READ_PROD_B_IF_TRUE | READ_PROD_B_IF_FALSE) << base) -> \ + if \ + :: (!(tmp & RCU_GP_CTR_NEST_MASK)) -> \ + PRODUCE_TOKENS(proc_urcu_reader, READ_PROD_B_IF_TRUE << base); \ + :: else -> \ + PRODUCE_TOKENS(proc_urcu_reader, READ_PROD_B_IF_FALSE << base); \ + fi; \ + /* IF TRUE */ \ + :: CONSUME_TOKENS(proc_urcu_reader, READ_PROD_B_IF_TRUE << base, \ + READ_PROD_C_IF_TRUE_READ << base) -> \ + ooo_mem(i); \ + tmp2 = READ_CACHED_VAR(urcu_gp_ctr); \ + PRODUCE_TOKENS(proc_urcu_reader, READ_PROD_C_IF_TRUE_READ << base); \ + :: CONSUME_TOKENS(proc_urcu_reader, \ + (READ_PROD_C_IF_TRUE_READ /* pre-dominant */ \ + | READ_PROD_A_READ) << base, /* WAR */ \ + producetoken) -> \ + ooo_mem(i); \ + WRITE_CACHED_VAR(urcu_active_readers[get_readerid()], tmp2); \ + PRODUCE_TOKENS(proc_urcu_reader, producetoken); \ + /* IF_MERGE implies \ + * post-dominance */ \ + /* ELSE */ \ + :: CONSUME_TOKENS(proc_urcu_reader, \ + (READ_PROD_B_IF_FALSE /* pre-dominant */ \ + | READ_PROD_A_READ) << base, /* WAR */ \ + producetoken) -> \ + ooo_mem(i); \ + WRITE_CACHED_VAR(urcu_active_readers[get_readerid()], \ + tmp + 1); \ + PRODUCE_TOKENS(proc_urcu_reader, producetoken); \ + /* IF_MERGE implies \ + * post-dominance */ \ + /* ENDIF */ \ + skip + +/* Body of PROCEDURE_READ_LOCK */ +#define READ_PROC_READ_UNLOCK (1 << 0) + +#define PROCEDURE_READ_UNLOCK(base, consumetoken, producetoken) \ + :: CONSUME_TOKENS(proc_urcu_reader, \ + consumetoken, \ + READ_PROC_READ_UNLOCK << base) -> \ + ooo_mem(i); \ + tmp2 = READ_CACHED_VAR(urcu_active_readers[get_readerid()]); \ + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_READ_UNLOCK << base); \ + :: CONSUME_TOKENS(proc_urcu_reader, \ + consumetoken \ + | (READ_PROC_READ_UNLOCK << base), /* WAR */ \ + producetoken) -> \ + ooo_mem(i); \ + WRITE_CACHED_VAR(urcu_active_readers[get_readerid()], tmp2 - 1); \ + PRODUCE_TOKENS(proc_urcu_reader, producetoken); \ + skip + + +#define READ_PROD_NONE (1 << 0) + +/* PROCEDURE_READ_LOCK base = << 1 : 1 to 5 */ +#define READ_LOCK_BASE 1 +#define READ_LOCK_OUT (1 << 5) + +#define READ_PROC_FIRST_MB (1 << 6) + +/* PROCEDURE_READ_LOCK (NESTED) base : << 7 : 7 to 11 */ +#define READ_LOCK_NESTED_BASE 7 +#define READ_LOCK_NESTED_OUT (1 << 11) + +#define READ_PROC_READ_GEN (1 << 12) +#define READ_PROC_ACCESS_GEN (1 << 13) + +/* PROCEDURE_READ_UNLOCK (NESTED) base = << 14 : 14 to 15 */ +#define READ_UNLOCK_NESTED_BASE 14 +#define READ_UNLOCK_NESTED_OUT (1 << 15) + +#define READ_PROC_SECOND_MB (1 << 16) + +/* PROCEDURE_READ_UNLOCK base = << 17 : 17 to 18 */ +#define READ_UNLOCK_BASE 17 +#define READ_UNLOCK_OUT (1 << 18) + +/* PROCEDURE_READ_LOCK_UNROLL base = << 19 : 19 to 23 */ +#define READ_LOCK_UNROLL_BASE 19 +#define READ_LOCK_OUT_UNROLL (1 << 23) + +#define READ_PROC_THIRD_MB (1 << 24) + +#define READ_PROC_READ_GEN_UNROLL (1 << 25) +#define READ_PROC_ACCESS_GEN_UNROLL (1 << 26) + +#define READ_PROC_FOURTH_MB (1 << 27) + +/* PROCEDURE_READ_UNLOCK_UNROLL base = << 28 : 28 to 29 */ +#define READ_UNLOCK_UNROLL_BASE 28 +#define READ_UNLOCK_OUT_UNROLL (1 << 29) + + +/* Should not include branches */ +#define READ_PROC_ALL_TOKENS (READ_PROD_NONE \ + | READ_LOCK_OUT \ + | READ_PROC_FIRST_MB \ + | READ_LOCK_NESTED_OUT \ + | READ_PROC_READ_GEN \ + | READ_PROC_ACCESS_GEN \ + | READ_UNLOCK_NESTED_OUT \ + | READ_PROC_SECOND_MB \ + | READ_UNLOCK_OUT \ + | READ_LOCK_OUT_UNROLL \ + | READ_PROC_THIRD_MB \ + | READ_PROC_READ_GEN_UNROLL \ + | READ_PROC_ACCESS_GEN_UNROLL \ + | READ_PROC_FOURTH_MB \ + | READ_UNLOCK_OUT_UNROLL) + +/* Must clear all tokens, including branches */ +#define READ_PROC_ALL_TOKENS_CLEAR ((1 << 30) - 1) + +inline urcu_one_read(i, j, nest_i, tmp, tmp2) +{ + PRODUCE_TOKENS(proc_urcu_reader, READ_PROD_NONE); + +#ifdef NO_MB + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_FIRST_MB); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_SECOND_MB); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_THIRD_MB); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_FOURTH_MB); +#endif + +#ifdef REMOTE_BARRIERS + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_FIRST_MB); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_SECOND_MB); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_THIRD_MB); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_FOURTH_MB); +#endif + + do + :: 1 -> + +#ifdef REMOTE_BARRIERS + /* + * Signal-based memory barrier will only execute when the + * execution order appears in program order. + */ + if + :: 1 -> + atomic { + if + :: CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE, + READ_LOCK_OUT | READ_LOCK_NESTED_OUT + | READ_PROC_READ_GEN | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT + | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT, + READ_LOCK_NESTED_OUT + | READ_PROC_READ_GEN | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT + | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT | READ_LOCK_NESTED_OUT, + READ_PROC_READ_GEN | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT + | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN, + READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT + | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN | READ_PROC_ACCESS_GEN, + READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT + | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN + | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT, + READ_UNLOCK_OUT + | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN + | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT, + READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN + | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT | READ_LOCK_OUT_UNROLL, + READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN + | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL, + READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN + | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL, + READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL, + 0) -> + goto non_atomic3; +non_atomic3_end: + skip; + fi; + } + fi; + + goto non_atomic3_skip; +non_atomic3: + smp_mb_recv(i, j); + goto non_atomic3_end; +non_atomic3_skip: + +#endif /* REMOTE_BARRIERS */ + + atomic { + if + PROCEDURE_READ_LOCK(READ_LOCK_BASE, READ_PROD_NONE, READ_LOCK_OUT); + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_LOCK_OUT, /* post-dominant */ + READ_PROC_FIRST_MB) -> + smp_mb_reader(i, j); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_FIRST_MB); + + PROCEDURE_READ_LOCK(READ_LOCK_NESTED_BASE, READ_PROC_FIRST_MB | READ_LOCK_OUT, + READ_LOCK_NESTED_OUT); + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_PROC_FIRST_MB, /* mb() orders reads */ + READ_PROC_READ_GEN) -> + ooo_mem(i); + ptr_read_first[get_readerid()] = READ_CACHED_VAR(rcu_ptr); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_READ_GEN); + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_PROC_FIRST_MB /* mb() orders reads */ + | READ_PROC_READ_GEN, + READ_PROC_ACCESS_GEN) -> + /* smp_read_barrier_depends */ + goto rmb1; +rmb1_end: + data_read_first[get_readerid()] = + READ_CACHED_VAR(rcu_data[ptr_read_first[get_readerid()]]); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_ACCESS_GEN); + + + /* Note : we remove the nested memory barrier from the read unlock + * model, given it is not usually needed. The implementation has the barrier + * because the performance impact added by a branch in the common case does not + * justify it. + */ + + PROCEDURE_READ_UNLOCK(READ_UNLOCK_NESTED_BASE, + READ_PROC_FIRST_MB + | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT, + READ_UNLOCK_NESTED_OUT); + + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_PROC_ACCESS_GEN /* mb() orders reads */ + | READ_PROC_READ_GEN /* mb() orders reads */ + | READ_PROC_FIRST_MB /* mb() ordered */ + | READ_LOCK_OUT /* post-dominant */ + | READ_LOCK_NESTED_OUT /* post-dominant */ + | READ_UNLOCK_NESTED_OUT, + READ_PROC_SECOND_MB) -> + smp_mb_reader(i, j); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_SECOND_MB); + + PROCEDURE_READ_UNLOCK(READ_UNLOCK_BASE, + READ_PROC_SECOND_MB /* mb() orders reads */ + | READ_PROC_FIRST_MB /* mb() orders reads */ + | READ_LOCK_NESTED_OUT /* RAW */ + | READ_LOCK_OUT /* RAW */ + | READ_UNLOCK_NESTED_OUT, /* RAW */ + READ_UNLOCK_OUT); + + /* Unrolling loop : second consecutive lock */ + /* reading urcu_active_readers, which have been written by + * READ_UNLOCK_OUT : RAW */ + PROCEDURE_READ_LOCK(READ_LOCK_UNROLL_BASE, + READ_UNLOCK_OUT /* RAW */ + | READ_PROC_SECOND_MB /* mb() orders reads */ + | READ_PROC_FIRST_MB /* mb() orders reads */ + | READ_LOCK_NESTED_OUT /* RAW */ + | READ_LOCK_OUT /* RAW */ + | READ_UNLOCK_NESTED_OUT, /* RAW */ + READ_LOCK_OUT_UNROLL); + + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_PROC_FIRST_MB /* mb() ordered */ + | READ_PROC_SECOND_MB /* mb() ordered */ + | READ_LOCK_OUT_UNROLL /* post-dominant */ + | READ_LOCK_NESTED_OUT + | READ_LOCK_OUT + | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT, + READ_PROC_THIRD_MB) -> + smp_mb_reader(i, j); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_THIRD_MB); + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_PROC_FIRST_MB /* mb() orders reads */ + | READ_PROC_SECOND_MB /* mb() orders reads */ + | READ_PROC_THIRD_MB, /* mb() orders reads */ + READ_PROC_READ_GEN_UNROLL) -> + ooo_mem(i); + ptr_read_second[get_readerid()] = READ_CACHED_VAR(rcu_ptr); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_READ_GEN_UNROLL); + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_PROC_READ_GEN_UNROLL + | READ_PROC_FIRST_MB /* mb() orders reads */ + | READ_PROC_SECOND_MB /* mb() orders reads */ + | READ_PROC_THIRD_MB, /* mb() orders reads */ + READ_PROC_ACCESS_GEN_UNROLL) -> + /* smp_read_barrier_depends */ + goto rmb2; +rmb2_end: + data_read_second[get_readerid()] = + READ_CACHED_VAR(rcu_data[ptr_read_second[get_readerid()]]); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_ACCESS_GEN_UNROLL); + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_PROC_READ_GEN_UNROLL /* mb() orders reads */ + | READ_PROC_ACCESS_GEN_UNROLL /* mb() orders reads */ + | READ_PROC_FIRST_MB /* mb() ordered */ + | READ_PROC_SECOND_MB /* mb() ordered */ + | READ_PROC_THIRD_MB /* mb() ordered */ + | READ_LOCK_OUT_UNROLL /* post-dominant */ + | READ_LOCK_NESTED_OUT + | READ_LOCK_OUT + | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT, + READ_PROC_FOURTH_MB) -> + smp_mb_reader(i, j); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_FOURTH_MB); + + PROCEDURE_READ_UNLOCK(READ_UNLOCK_UNROLL_BASE, + READ_PROC_FOURTH_MB /* mb() orders reads */ + | READ_PROC_THIRD_MB /* mb() orders reads */ + | READ_LOCK_OUT_UNROLL /* RAW */ + | READ_PROC_SECOND_MB /* mb() orders reads */ + | READ_PROC_FIRST_MB /* mb() orders reads */ + | READ_LOCK_NESTED_OUT /* RAW */ + | READ_LOCK_OUT /* RAW */ + | READ_UNLOCK_NESTED_OUT, /* RAW */ + READ_UNLOCK_OUT_UNROLL); + :: CONSUME_TOKENS(proc_urcu_reader, READ_PROC_ALL_TOKENS, 0) -> + CLEAR_TOKENS(proc_urcu_reader, READ_PROC_ALL_TOKENS_CLEAR); + break; + fi; + } + od; + /* + * Dependency between consecutive loops : + * RAW dependency on + * WRITE_CACHED_VAR(urcu_active_readers[get_readerid()], tmp2 - 1) + * tmp = READ_CACHED_VAR(urcu_active_readers[get_readerid()]); + * between loops. + * _WHEN THE MB()s are in place_, they add full ordering of the + * generation pointer read wrt active reader count read, which ensures + * execution will not spill across loop execution. + * However, in the event mb()s are removed (execution using signal + * handler to promote barrier()() -> smp_mb()), nothing prevents one loop + * to spill its execution on other loop's execution. + */ + goto end; +rmb1: +#ifndef NO_RMB + smp_rmb(i); +#else + ooo_mem(i); +#endif + goto rmb1_end; +rmb2: +#ifndef NO_RMB + smp_rmb(i); +#else + ooo_mem(i); +#endif + goto rmb2_end; +end: + skip; +} + + + +active proctype urcu_reader() +{ + byte i, j, nest_i; + byte tmp, tmp2; + + wait_init_done(); + + assert(get_pid() < NR_PROCS); + +end_reader: + do + :: 1 -> + /* + * We do not test reader's progress here, because we are mainly + * interested in writer's progress. The reader never blocks + * anyway. We have to test for reader/writer's progress + * separately, otherwise we could think the writer is doing + * progress when it's blocked by an always progressing reader. + */ +#ifdef READER_PROGRESS +progress_reader: +#endif + urcu_one_read(i, j, nest_i, tmp, tmp2); + od; +} + +/* no name clash please */ +#undef proc_urcu_reader + + +/* Model the RCU update process. */ + +/* + * Bit encoding, urcu_writer : + * Currently only supports one reader. + */ + +int _proc_urcu_writer; +#define proc_urcu_writer _proc_urcu_writer + +#define WRITE_PROD_NONE (1 << 0) + +#define WRITE_DATA (1 << 1) +#define WRITE_PROC_WMB (1 << 2) +#define WRITE_XCHG_PTR (1 << 3) + +#define WRITE_PROC_FIRST_MB (1 << 4) + +/* first flip */ +#define WRITE_PROC_FIRST_READ_GP (1 << 5) +#define WRITE_PROC_FIRST_WRITE_GP (1 << 6) +#define WRITE_PROC_FIRST_WAIT (1 << 7) +#define WRITE_PROC_FIRST_WAIT_LOOP (1 << 8) + +/* second flip */ +#define WRITE_PROC_SECOND_READ_GP (1 << 9) +#define WRITE_PROC_SECOND_WRITE_GP (1 << 10) +#define WRITE_PROC_SECOND_WAIT (1 << 11) +#define WRITE_PROC_SECOND_WAIT_LOOP (1 << 12) + +#define WRITE_PROC_SECOND_MB (1 << 13) + +#define WRITE_FREE (1 << 14) + +#define WRITE_PROC_ALL_TOKENS (WRITE_PROD_NONE \ + | WRITE_DATA \ + | WRITE_PROC_WMB \ + | WRITE_XCHG_PTR \ + | WRITE_PROC_FIRST_MB \ + | WRITE_PROC_FIRST_READ_GP \ + | WRITE_PROC_FIRST_WRITE_GP \ + | WRITE_PROC_FIRST_WAIT \ + | WRITE_PROC_SECOND_READ_GP \ + | WRITE_PROC_SECOND_WRITE_GP \ + | WRITE_PROC_SECOND_WAIT \ + | WRITE_PROC_SECOND_MB \ + | WRITE_FREE) + +#define WRITE_PROC_ALL_TOKENS_CLEAR ((1 << 15) - 1) + +/* + * Mutexes are implied around writer execution. A single writer at a time. + */ +active proctype urcu_writer() +{ + byte i, j; + byte tmp, tmp2, tmpa; + byte cur_data = 0, old_data, loop_nr = 0; + byte cur_gp_val = 0; /* + * Keep a local trace of the current parity so + * we don't add non-existing dependencies on the global + * GP update. Needed to test single flip case. + */ + + wait_init_done(); + + assert(get_pid() < NR_PROCS); + + do + :: (loop_nr < 3) -> +#ifdef WRITER_PROGRESS +progress_writer1: +#endif + loop_nr = loop_nr + 1; + + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROD_NONE); + +#ifdef NO_WMB + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_WMB); +#endif + +#ifdef NO_MB + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_FIRST_MB); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_MB); +#endif + +#ifdef SINGLE_FLIP + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_READ_GP); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_WRITE_GP); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_WAIT); + /* For single flip, we need to know the current parity */ + cur_gp_val = cur_gp_val ^ RCU_GP_CTR_BIT; +#endif + + do :: 1 -> + atomic { + if + + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_PROD_NONE, + WRITE_DATA) -> + ooo_mem(i); + cur_data = (cur_data + 1) % SLAB_SIZE; + WRITE_CACHED_VAR(rcu_data[cur_data], WINE); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_DATA); + + + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_DATA, + WRITE_PROC_WMB) -> + smp_wmb(i); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_WMB); + + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_PROC_WMB, + WRITE_XCHG_PTR) -> + /* rcu_xchg_pointer() */ + atomic { + old_data = READ_CACHED_VAR(rcu_ptr); + WRITE_CACHED_VAR(rcu_ptr, cur_data); + } + PRODUCE_TOKENS(proc_urcu_writer, WRITE_XCHG_PTR); + + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_DATA | WRITE_PROC_WMB | WRITE_XCHG_PTR, + WRITE_PROC_FIRST_MB) -> + goto smp_mb_send1; +smp_mb_send1_end: + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_FIRST_MB); + + /* first flip */ + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_PROC_FIRST_MB, + WRITE_PROC_FIRST_READ_GP) -> + tmpa = READ_CACHED_VAR(urcu_gp_ctr); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_FIRST_READ_GP); + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_PROC_FIRST_MB | WRITE_PROC_WMB + | WRITE_PROC_FIRST_READ_GP, + WRITE_PROC_FIRST_WRITE_GP) -> + ooo_mem(i); + WRITE_CACHED_VAR(urcu_gp_ctr, tmpa ^ RCU_GP_CTR_BIT); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_FIRST_WRITE_GP); + + :: CONSUME_TOKENS(proc_urcu_writer, + //WRITE_PROC_FIRST_WRITE_GP /* TEST ADDING SYNC CORE */ + WRITE_PROC_FIRST_MB, /* can be reordered before/after flips */ + WRITE_PROC_FIRST_WAIT | WRITE_PROC_FIRST_WAIT_LOOP) -> + ooo_mem(i); + /* ONLY WAITING FOR READER 0 */ + tmp2 = READ_CACHED_VAR(urcu_active_readers[0]); +#ifndef SINGLE_FLIP + /* In normal execution, we are always starting by + * waiting for the even parity. + */ + cur_gp_val = RCU_GP_CTR_BIT; +#endif + if + :: (tmp2 & RCU_GP_CTR_NEST_MASK) + && ((tmp2 ^ cur_gp_val) & RCU_GP_CTR_BIT) -> + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_FIRST_WAIT_LOOP); + :: else -> + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_FIRST_WAIT); + fi; + + :: CONSUME_TOKENS(proc_urcu_writer, + //WRITE_PROC_FIRST_WRITE_GP /* TEST ADDING SYNC CORE */ + WRITE_PROC_FIRST_WRITE_GP + | WRITE_PROC_FIRST_READ_GP + | WRITE_PROC_FIRST_WAIT_LOOP + | WRITE_DATA | WRITE_PROC_WMB | WRITE_XCHG_PTR + | WRITE_PROC_FIRST_MB, /* can be reordered before/after flips */ + 0) -> +#ifndef GEN_ERROR_WRITER_PROGRESS + goto smp_mb_send2; +smp_mb_send2_end: +#else + ooo_mem(i); +#endif + /* This instruction loops to WRITE_PROC_FIRST_WAIT */ + CLEAR_TOKENS(proc_urcu_writer, WRITE_PROC_FIRST_WAIT_LOOP | WRITE_PROC_FIRST_WAIT); + + /* second flip */ + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_PROC_FIRST_WAIT /* Control dependency : need to branch out of + * the loop to execute the next flip (CHECK) */ + | WRITE_PROC_FIRST_WRITE_GP + | WRITE_PROC_FIRST_READ_GP + | WRITE_PROC_FIRST_MB, + WRITE_PROC_SECOND_READ_GP) -> + ooo_mem(i); + tmpa = READ_CACHED_VAR(urcu_gp_ctr); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_READ_GP); + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_PROC_FIRST_MB + | WRITE_PROC_WMB + | WRITE_PROC_FIRST_READ_GP + | WRITE_PROC_FIRST_WRITE_GP + | WRITE_PROC_SECOND_READ_GP, + WRITE_PROC_SECOND_WRITE_GP) -> + ooo_mem(i); + WRITE_CACHED_VAR(urcu_gp_ctr, tmpa ^ RCU_GP_CTR_BIT); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_WRITE_GP); + + :: CONSUME_TOKENS(proc_urcu_writer, + //WRITE_PROC_FIRST_WRITE_GP /* TEST ADDING SYNC CORE */ + WRITE_PROC_FIRST_WAIT + | WRITE_PROC_FIRST_MB, /* can be reordered before/after flips */ + WRITE_PROC_SECOND_WAIT | WRITE_PROC_SECOND_WAIT_LOOP) -> + ooo_mem(i); + /* ONLY WAITING FOR READER 0 */ + tmp2 = READ_CACHED_VAR(urcu_active_readers[0]); + if + :: (tmp2 & RCU_GP_CTR_NEST_MASK) + && ((tmp2 ^ 0) & RCU_GP_CTR_BIT) -> + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_WAIT_LOOP); + :: else -> + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_WAIT); + fi; + + :: CONSUME_TOKENS(proc_urcu_writer, + //WRITE_PROC_FIRST_WRITE_GP /* TEST ADDING SYNC CORE */ + WRITE_PROC_SECOND_WRITE_GP + | WRITE_PROC_FIRST_WRITE_GP + | WRITE_PROC_SECOND_READ_GP + | WRITE_PROC_FIRST_READ_GP + | WRITE_PROC_SECOND_WAIT_LOOP + | WRITE_DATA | WRITE_PROC_WMB | WRITE_XCHG_PTR + | WRITE_PROC_FIRST_MB, /* can be reordered before/after flips */ + 0) -> +#ifndef GEN_ERROR_WRITER_PROGRESS + goto smp_mb_send3; +smp_mb_send3_end: +#else + ooo_mem(i); +#endif + /* This instruction loops to WRITE_PROC_SECOND_WAIT */ + CLEAR_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_WAIT_LOOP | WRITE_PROC_SECOND_WAIT); + + + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_PROC_FIRST_WAIT + | WRITE_PROC_SECOND_WAIT + | WRITE_PROC_FIRST_READ_GP + | WRITE_PROC_SECOND_READ_GP + | WRITE_PROC_FIRST_WRITE_GP + | WRITE_PROC_SECOND_WRITE_GP + | WRITE_DATA | WRITE_PROC_WMB | WRITE_XCHG_PTR + | WRITE_PROC_FIRST_MB, + WRITE_PROC_SECOND_MB) -> + goto smp_mb_send4; +smp_mb_send4_end: + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_MB); + + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_XCHG_PTR + | WRITE_PROC_FIRST_WAIT + | WRITE_PROC_SECOND_WAIT + | WRITE_PROC_WMB /* No dependency on + * WRITE_DATA because we + * write to a + * different location. */ + | WRITE_PROC_SECOND_MB + | WRITE_PROC_FIRST_MB, + WRITE_FREE) -> + WRITE_CACHED_VAR(rcu_data[old_data], POISON); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_FREE); + + :: CONSUME_TOKENS(proc_urcu_writer, WRITE_PROC_ALL_TOKENS, 0) -> + CLEAR_TOKENS(proc_urcu_writer, WRITE_PROC_ALL_TOKENS_CLEAR); + break; + fi; + } + od; + /* + * Note : Promela model adds implicit serialization of the + * WRITE_FREE instruction. Normally, it would be permitted to + * spill on the next loop execution. Given the validation we do + * checks for the data entry read to be poisoned, it's ok if + * we do not check "late arriving" memory poisoning. + */ + :: else -> break; + od; + /* + * Given the reader loops infinitely, let the writer also busy-loop + * with progress here so, with weak fairness, we can test the + * writer's progress. + */ +end_writer: + do + :: 1 -> +#ifdef WRITER_PROGRESS +progress_writer2: +#endif +#ifdef READER_PROGRESS + /* + * Make sure we don't block the reader's progress. + */ + smp_mb_send(i, j, 5); +#endif + skip; + od; + + /* Non-atomic parts of the loop */ + goto end; +smp_mb_send1: + smp_mb_send(i, j, 1); + goto smp_mb_send1_end; +#ifndef GEN_ERROR_WRITER_PROGRESS +smp_mb_send2: + smp_mb_send(i, j, 2); + goto smp_mb_send2_end; +smp_mb_send3: + smp_mb_send(i, j, 3); + goto smp_mb_send3_end; +#endif +smp_mb_send4: + smp_mb_send(i, j, 4); + goto smp_mb_send4_end; +end: + skip; +} + +/* no name clash please */ +#undef proc_urcu_writer + + +/* Leave after the readers and writers so the pid count is ok. */ +init { + byte i, j; + + atomic { + INIT_CACHED_VAR(urcu_gp_ctr, 1, j); + INIT_CACHED_VAR(rcu_ptr, 0, j); + + i = 0; + do + :: i < NR_READERS -> + INIT_CACHED_VAR(urcu_active_readers[i], 0, j); + ptr_read_first[i] = 1; + ptr_read_second[i] = 1; + data_read_first[i] = WINE; + data_read_second[i] = WINE; + i++; + :: i >= NR_READERS -> break + od; + INIT_CACHED_VAR(rcu_data[0], WINE, j); + i = 1; + do + :: i < SLAB_SIZE -> + INIT_CACHED_VAR(rcu_data[i], POISON, j); + i++ + :: i >= SLAB_SIZE -> break + od; + + init_done = 1; + } +} diff --git a/formal-model/results/urcu-controldataflow-ipi-intel/urcu_free_single_flip.spin.input.trail b/formal-model/results/urcu-controldataflow-ipi-intel/urcu_free_single_flip.spin.input.trail new file mode 100644 index 0000000..f8289ee --- /dev/null +++ b/formal-model/results/urcu-controldataflow-ipi-intel/urcu_free_single_flip.spin.input.trail @@ -0,0 +1,1257 @@ +-2:3:-2 +-4:-4:-4 +1:0:4178 +2:3:4098 +3:3:4101 +4:3:4101 +5:3:4104 +6:3:4112 +7:3:4112 +8:3:4115 +9:3:4121 +10:3:4125 +11:3:4125 +12:3:4128 +13:3:4138 +14:3:4146 +15:3:4146 +16:3:4149 +17:3:4155 +18:3:4159 +19:3:4159 +20:3:4162 +21:3:4168 +22:3:4172 +23:3:4173 +24:0:4178 +25:3:4175 +26:0:4178 +27:2:2511 +28:0:4178 +29:2:2517 +30:0:4178 +31:2:2518 +32:0:4178 +33:2:2520 +34:0:4178 +35:2:2521 +36:0:4178 +37:2:2522 +38:0:4178 +39:2:2523 +40:0:4178 +41:2:2524 +42:0:4178 +43:2:2525 +44:0:4178 +45:2:2526 +46:2:2527 +47:2:2531 +48:2:2532 +49:2:2540 +50:2:2541 +51:2:2545 +52:2:2546 +53:2:2554 +54:2:2559 +55:2:2563 +56:2:2564 +57:2:2572 +58:2:2573 +59:2:2577 +60:2:2578 +61:2:2572 +62:2:2573 +63:2:2577 +64:2:2578 +65:2:2586 +66:2:2591 +67:2:2598 +68:2:2599 +69:2:2606 +70:2:2611 +71:2:2618 +72:2:2619 +73:2:2618 +74:2:2619 +75:2:2626 +76:2:2636 +77:0:4178 +78:2:2525 +79:0:4178 +80:2:2640 +81:2:2644 +82:2:2645 +83:2:2649 +84:2:2653 +85:2:2654 +86:2:2658 +87:2:2666 +88:2:2667 +89:2:2671 +90:2:2675 +91:2:2676 +92:2:2671 +93:2:2672 +94:2:2680 +95:0:4178 +96:2:2525 +97:0:4178 +98:2:2688 +99:2:2689 +100:2:2690 +101:0:4178 +102:2:2525 +103:0:4178 +104:2:2695 +105:0:4178 +106:2:3307 +107:2:3308 +108:2:3312 +109:2:3316 +110:2:3317 +111:2:3321 +112:2:3326 +113:2:3334 +114:2:3338 +115:2:3339 +116:2:3334 +117:2:3338 +118:2:3339 +119:2:3343 +120:2:3350 +121:2:3357 +122:2:3358 +123:2:3365 +124:2:3370 +125:2:3377 +126:2:3378 +127:2:3377 +128:2:3378 +129:2:3385 +130:2:3389 +131:0:4178 +132:2:3394 +133:0:4178 +134:2:3395 +135:0:4178 +136:2:3396 +137:0:4178 +138:2:3397 +139:0:4178 +140:1:2 +141:0:4178 +142:2:3398 +143:0:4178 +144:1:8 +145:0:4178 +146:1:9 +147:0:4178 +148:2:3397 +149:0:4178 +150:1:10 +151:0:4178 +152:2:3398 +153:0:4178 +154:1:11 +155:0:4178 +156:2:3397 +157:0:4178 +158:1:12 +159:0:4178 +160:2:3398 +161:0:4178 +162:1:13 +163:0:4178 +164:2:3397 +165:0:4178 +166:1:14 +167:0:4178 +168:2:3398 +169:0:4178 +170:1:15 +171:0:4178 +172:1:16 +173:0:4178 +174:2:3397 +175:0:4178 +176:1:17 +177:0:4178 +178:2:3398 +179:0:4178 +180:1:26 +181:0:4178 +182:2:3397 +183:0:4178 +184:1:30 +185:1:31 +186:1:35 +187:1:39 +188:1:40 +189:1:44 +190:1:52 +191:1:53 +192:1:57 +193:1:61 +194:1:62 +195:1:57 +196:1:61 +197:1:62 +198:1:66 +199:1:73 +200:1:80 +201:1:81 +202:1:88 +203:1:93 +204:1:100 +205:1:101 +206:1:100 +207:1:101 +208:1:108 +209:1:112 +210:0:4178 +211:2:3398 +212:0:4178 +213:1:117 +214:0:4178 +215:2:3399 +216:0:4178 +217:2:3404 +218:0:4178 +219:2:3405 +220:0:4178 +221:2:3413 +222:2:3414 +223:2:3418 +224:2:3422 +225:2:3423 +226:2:3427 +227:2:3435 +228:2:3436 +229:2:3440 +230:2:3444 +231:2:3445 +232:2:3440 +233:2:3444 +234:2:3445 +235:2:3449 +236:2:3456 +237:2:3463 +238:2:3464 +239:2:3471 +240:2:3476 +241:2:3483 +242:2:3484 +243:2:3483 +244:2:3484 +245:2:3491 +246:2:3495 +247:0:4178 +248:2:2697 +249:2:3288 +250:0:4178 +251:2:2525 +252:0:4178 +253:2:2698 +254:0:4178 +255:2:2525 +256:0:4178 +257:2:2701 +258:2:2702 +259:2:2706 +260:2:2707 +261:2:2715 +262:2:2716 +263:2:2720 +264:2:2721 +265:2:2729 +266:2:2734 +267:2:2738 +268:2:2739 +269:2:2747 +270:2:2748 +271:2:2752 +272:2:2753 +273:2:2747 +274:2:2748 +275:2:2752 +276:2:2753 +277:2:2761 +278:2:2766 +279:2:2773 +280:2:2774 +281:2:2781 +282:2:2786 +283:2:2793 +284:2:2794 +285:2:2793 +286:2:2794 +287:2:2801 +288:2:2810 +289:0:4178 +290:2:2525 +291:0:4178 +292:2:2814 +293:2:2823 +294:2:2824 +295:2:2828 +296:2:2829 +297:2:2833 +298:2:2834 +299:2:2842 +300:2:2847 +301:2:2851 +302:2:2852 +303:2:2860 +304:2:2861 +305:2:2865 +306:2:2866 +307:2:2860 +308:2:2861 +309:2:2865 +310:2:2866 +311:2:2874 +312:2:2881 +313:2:2882 +314:2:2886 +315:2:2887 +316:2:2894 +317:2:2899 +318:2:2906 +319:2:2907 +320:2:2906 +321:2:2907 +322:2:2914 +323:2:2926 +324:2:2927 +325:0:4178 +326:2:2525 +327:0:4178 +328:2:3276 +329:0:4178 +330:1:118 +331:0:4178 +332:1:120 +333:0:4178 +334:1:19 +335:0:4178 +336:1:126 +337:1:127 +338:1:131 +339:1:132 +340:1:140 +341:1:141 +342:1:145 +343:1:146 +344:1:154 +345:1:159 +346:1:163 +347:1:164 +348:1:172 +349:1:173 +350:1:177 +351:1:178 +352:1:172 +353:1:173 +354:1:177 +355:1:178 +356:1:186 +357:1:191 +358:1:198 +359:1:199 +360:1:206 +361:1:211 +362:1:218 +363:1:219 +364:1:218 +365:1:219 +366:1:226 +367:0:4178 +368:1:15 +369:0:4178 +370:1:16 +371:0:4178 +372:1:17 +373:0:4178 +374:1:118 +375:0:4178 +376:1:120 +377:0:4178 +378:1:19 +379:0:4178 +380:1:237 +381:1:238 +382:0:4178 +383:1:15 +384:0:4178 +385:1:16 +386:0:4178 +387:1:17 +388:0:4178 +389:1:118 +390:0:4178 +391:1:120 +392:0:4178 +393:1:19 +394:0:4178 +395:1:244 +396:1:245 +397:1:249 +398:1:250 +399:1:258 +400:1:259 +401:1:263 +402:1:264 +403:1:272 +404:1:277 +405:1:281 +406:1:282 +407:1:290 +408:1:291 +409:1:295 +410:1:296 +411:1:290 +412:1:291 +413:1:295 +414:1:296 +415:1:304 +416:1:309 +417:1:316 +418:1:317 +419:1:324 +420:1:329 +421:1:336 +422:1:337 +423:1:336 +424:1:337 +425:1:344 +426:0:4178 +427:1:15 +428:0:4178 +429:1:16 +430:0:4178 +431:2:3898 +432:2:3906 +433:2:3910 +434:2:3911 +435:2:3915 +436:2:3923 +437:2:3924 +438:2:3928 +439:2:3932 +440:2:3933 +441:2:3928 +442:2:3932 +443:2:3933 +444:2:3937 +445:2:3944 +446:2:3951 +447:2:3952 +448:2:3959 +449:2:3964 +450:2:3971 +451:2:3972 +452:2:3971 +453:2:3972 +454:2:3979 +455:2:3983 +456:0:4178 +457:2:3988 +458:0:4178 +459:2:3989 +460:0:4178 +461:2:3990 +462:0:4178 +463:2:3991 +464:0:4178 +465:1:17 +466:0:4178 +467:2:3992 +468:0:4178 +469:1:26 +470:0:4178 +471:2:3991 +472:0:4178 +473:1:30 +474:1:31 +475:1:35 +476:1:39 +477:1:40 +478:1:44 +479:1:52 +480:1:53 +481:1:57 +482:1:61 +483:1:62 +484:1:57 +485:1:61 +486:1:62 +487:1:66 +488:1:73 +489:1:80 +490:1:81 +491:1:88 +492:1:93 +493:1:100 +494:1:101 +495:1:100 +496:1:101 +497:1:108 +498:1:112 +499:0:4178 +500:2:3992 +501:0:4178 +502:1:117 +503:0:4178 +504:2:3993 +505:0:4178 +506:2:3998 +507:0:4178 +508:2:3999 +509:0:4178 +510:2:4007 +511:2:4008 +512:2:4012 +513:2:4016 +514:2:4017 +515:2:4021 +516:2:4029 +517:2:4030 +518:2:4034 +519:2:4038 +520:2:4039 +521:2:4034 +522:2:4038 +523:2:4039 +524:2:4043 +525:2:4050 +526:2:4057 +527:2:4058 +528:2:4065 +529:2:4070 +530:2:4077 +531:2:4078 +532:2:4077 +533:2:4078 +534:2:4085 +535:2:4089 +536:0:4178 +537:2:3278 +538:2:3288 +539:0:4178 +540:2:2525 +541:0:4178 +542:2:3279 +543:2:3280 +544:0:4178 +545:2:2525 +546:0:4178 +547:2:3284 +548:0:4178 +549:2:3292 +550:0:4178 +551:2:2518 +552:0:4178 +553:2:2520 +554:0:4178 +555:2:2521 +556:0:4178 +557:2:2522 +558:0:4178 +559:2:2523 +560:0:4178 +561:2:2524 +562:0:4178 +563:2:2525 +564:0:4178 +565:2:2526 +566:2:2527 +567:2:2531 +568:2:2532 +569:2:2540 +570:2:2541 +571:2:2545 +572:2:2546 +573:2:2554 +574:2:2559 +575:2:2563 +576:2:2564 +577:2:2572 +578:2:2573 +579:2:2574 +580:2:2572 +581:2:2573 +582:2:2577 +583:2:2578 +584:2:2586 +585:2:2591 +586:2:2598 +587:2:2599 +588:2:2606 +589:2:2611 +590:2:2618 +591:2:2619 +592:2:2618 +593:2:2619 +594:2:2626 +595:2:2636 +596:0:4178 +597:2:2525 +598:0:4178 +599:2:2640 +600:2:2644 +601:2:2645 +602:2:2649 +603:2:2653 +604:2:2654 +605:2:2658 +606:2:2666 +607:2:2667 +608:2:2671 +609:2:2672 +610:2:2671 +611:2:2675 +612:2:2676 +613:2:2680 +614:0:4178 +615:2:2525 +616:0:4178 +617:2:2688 +618:2:2689 +619:2:2690 +620:0:4178 +621:2:2525 +622:0:4178 +623:2:2695 +624:0:4178 +625:1:118 +626:0:4178 +627:1:120 +628:0:4178 +629:1:19 +630:0:4178 +631:1:355 +632:1:356 +633:1:360 +634:1:361 +635:1:369 +636:1:370 +637:1:374 +638:1:375 +639:1:383 +640:1:388 +641:1:392 +642:1:393 +643:1:401 +644:1:402 +645:1:406 +646:1:407 +647:1:401 +648:1:402 +649:1:406 +650:1:407 +651:1:415 +652:1:420 +653:1:427 +654:1:428 +655:1:435 +656:1:440 +657:1:447 +658:1:448 +659:1:447 +660:1:448 +661:1:455 +662:1:464 +663:0:4178 +664:1:15 +665:0:4178 +666:1:16 +667:0:4178 +668:1:17 +669:0:4178 +670:1:118 +671:0:4178 +672:1:120 +673:0:4178 +674:1:19 +675:0:4178 +676:1:584 +677:1:585 +678:1:589 +679:1:590 +680:1:598 +681:1:599 +682:1:600 +683:1:612 +684:1:617 +685:1:621 +686:1:622 +687:1:630 +688:1:631 +689:1:635 +690:1:636 +691:1:630 +692:1:631 +693:1:635 +694:1:636 +695:1:644 +696:1:649 +697:1:656 +698:1:657 +699:1:664 +700:1:669 +701:1:676 +702:1:677 +703:1:676 +704:1:677 +705:1:684 +706:0:4178 +707:1:15 +708:0:4178 +709:1:16 +710:0:4178 +711:1:17 +712:0:4178 +713:1:118 +714:0:4178 +715:1:120 +716:0:4178 +717:1:19 +718:0:4178 +719:1:695 +720:1:698 +721:1:699 +722:0:4178 +723:1:15 +724:0:4178 +725:1:16 +726:0:4178 +727:1:17 +728:0:4178 +729:1:118 +730:0:4178 +731:1:120 +732:0:4178 +733:1:19 +734:0:4178 +735:1:926 +736:1:927 +737:1:931 +738:1:932 +739:1:940 +740:1:941 +741:1:945 +742:1:946 +743:1:954 +744:1:959 +745:1:963 +746:1:964 +747:1:972 +748:1:973 +749:1:977 +750:1:978 +751:1:972 +752:1:973 +753:1:977 +754:1:978 +755:1:986 +756:1:991 +757:1:998 +758:1:999 +759:1:1006 +760:1:1011 +761:1:1018 +762:1:1019 +763:1:1018 +764:1:1019 +765:1:1026 +766:1:1035 +767:1:1039 +768:0:4178 +769:1:15 +770:0:4178 +771:1:16 +772:0:4178 +773:1:17 +774:0:4178 +775:1:118 +776:0:4178 +777:1:120 +778:0:4178 +779:1:19 +780:0:4178 +781:1:1040 +782:1:1041 +783:1:1045 +784:1:1046 +785:1:1054 +786:1:1055 +787:1:1056 +788:1:1068 +789:1:1073 +790:1:1077 +791:1:1078 +792:1:1086 +793:1:1087 +794:1:1091 +795:1:1092 +796:1:1086 +797:1:1087 +798:1:1091 +799:1:1092 +800:1:1100 +801:1:1105 +802:1:1112 +803:1:1113 +804:1:1120 +805:1:1125 +806:1:1132 +807:1:1133 +808:1:1132 +809:1:1133 +810:1:1140 +811:0:4178 +812:1:15 +813:0:4178 +814:1:16 +815:0:4178 +816:2:3307 +817:2:3308 +818:2:3312 +819:2:3316 +820:2:3317 +821:2:3321 +822:2:3326 +823:2:3334 +824:2:3338 +825:2:3339 +826:2:3334 +827:2:3338 +828:2:3339 +829:2:3343 +830:2:3350 +831:2:3357 +832:2:3358 +833:2:3365 +834:2:3370 +835:2:3377 +836:2:3378 +837:2:3377 +838:2:3378 +839:2:3385 +840:2:3389 +841:0:4178 +842:2:3394 +843:0:4178 +844:2:3395 +845:0:4178 +846:2:3396 +847:0:4178 +848:2:3397 +849:0:4178 +850:1:17 +851:0:4178 +852:2:3398 +853:0:4178 +854:1:26 +855:0:4178 +856:2:3397 +857:0:4178 +858:1:30 +859:1:31 +860:1:35 +861:1:39 +862:1:40 +863:1:44 +864:1:52 +865:1:53 +866:1:57 +867:1:61 +868:1:62 +869:1:57 +870:1:61 +871:1:62 +872:1:66 +873:1:73 +874:1:80 +875:1:81 +876:1:88 +877:1:93 +878:1:100 +879:1:101 +880:1:100 +881:1:101 +882:1:108 +883:1:112 +884:0:4178 +885:2:3398 +886:0:4178 +887:1:117 +888:0:4178 +889:2:3399 +890:0:4178 +891:2:3404 +892:0:4178 +893:2:3405 +894:0:4178 +895:2:3413 +896:2:3414 +897:2:3418 +898:2:3422 +899:2:3423 +900:2:3427 +901:2:3435 +902:2:3436 +903:2:3440 +904:2:3444 +905:2:3445 +906:2:3440 +907:2:3444 +908:2:3445 +909:2:3449 +910:2:3456 +911:2:3463 +912:2:3464 +913:2:3471 +914:2:3476 +915:2:3483 +916:2:3484 +917:2:3483 +918:2:3484 +919:2:3491 +920:2:3495 +921:0:4178 +922:2:2697 +923:2:3288 +924:0:4178 +925:2:2525 +926:0:4178 +927:2:2698 +928:0:4178 +929:2:2525 +930:0:4178 +931:2:2701 +932:2:2702 +933:2:2706 +934:2:2707 +935:2:2715 +936:2:2716 +937:2:2720 +938:2:2721 +939:2:2729 +940:2:2734 +941:2:2738 +942:2:2739 +943:2:2747 +944:2:2748 +945:2:2752 +946:2:2753 +947:2:2747 +948:2:2748 +949:2:2752 +950:2:2753 +951:2:2761 +952:2:2766 +953:2:2773 +954:2:2774 +955:2:2781 +956:2:2786 +957:2:2793 +958:2:2794 +959:2:2793 +960:2:2794 +961:2:2801 +962:2:2810 +963:0:4178 +964:2:2525 +965:0:4178 +966:2:2814 +967:2:2815 +968:2:2816 +969:2:2828 +970:2:2829 +971:2:2833 +972:2:2834 +973:2:2842 +974:2:2847 +975:2:2851 +976:2:2852 +977:2:2860 +978:2:2861 +979:2:2865 +980:2:2866 +981:2:2860 +982:2:2861 +983:2:2865 +984:2:2866 +985:2:2874 +986:2:2879 +987:2:2886 +988:2:2887 +989:2:2894 +990:2:2899 +991:2:2906 +992:2:2907 +993:2:2906 +994:2:2907 +995:2:2914 +996:2:2926 +997:2:2927 +998:0:4178 +999:2:2525 +1000:0:4178 +1001:2:3276 +1002:0:4178 +1003:2:3901 +1004:2:3902 +1005:2:3906 +1006:2:3910 +1007:2:3911 +1008:2:3915 +1009:2:3923 +1010:2:3924 +1011:2:3928 +1012:2:3932 +1013:2:3933 +1014:2:3928 +1015:2:3932 +1016:2:3933 +1017:2:3937 +1018:2:3944 +1019:2:3951 +1020:2:3952 +1021:2:3959 +1022:2:3964 +1023:2:3971 +1024:2:3972 +1025:2:3971 +1026:2:3972 +1027:2:3979 +1028:2:3983 +1029:0:4178 +1030:2:3988 +1031:0:4178 +1032:2:3989 +1033:0:4178 +1034:2:3990 +1035:0:4178 +1036:2:3991 +1037:0:4178 +1038:1:26 +1039:0:4178 +1040:2:3992 +1041:0:4178 +1042:1:30 +1043:1:31 +1044:1:35 +1045:1:39 +1046:1:40 +1047:1:44 +1048:1:52 +1049:1:53 +1050:1:57 +1051:1:61 +1052:1:62 +1053:1:57 +1054:1:61 +1055:1:62 +1056:1:66 +1057:1:73 +1058:1:80 +1059:1:81 +1060:1:88 +1061:1:93 +1062:1:100 +1063:1:101 +1064:1:100 +1065:1:101 +1066:1:108 +1067:1:112 +1068:0:4178 +1069:2:3991 +1070:0:4178 +1071:1:117 +1072:0:4178 +1073:2:3992 +1074:0:4178 +1075:2:3993 +1076:0:4178 +1077:2:3998 +1078:0:4178 +1079:2:3999 +1080:0:4178 +1081:2:4007 +1082:2:4008 +1083:2:4012 +1084:2:4016 +1085:2:4017 +1086:2:4021 +1087:2:4029 +1088:2:4030 +1089:2:4034 +1090:2:4038 +1091:2:4039 +1092:2:4034 +1093:2:4038 +1094:2:4039 +1095:2:4043 +1096:2:4050 +1097:2:4057 +1098:2:4058 +1099:2:4065 +1100:2:4070 +1101:2:4077 +1102:2:4078 +1103:2:4077 +1104:2:4078 +1105:2:4085 +1106:2:4089 +1107:0:4178 +1108:2:3278 +1109:2:3288 +1110:0:4178 +1111:2:2525 +1112:0:4178 +1113:2:3279 +1114:2:3280 +1115:0:4178 +1116:2:2525 +1117:0:4178 +1118:2:3284 +1119:0:4178 +1120:2:3292 +1121:0:4178 +1122:2:2518 +1123:0:4178 +1124:2:2520 +1125:0:4178 +1126:2:2521 +1127:0:4178 +1128:2:2522 +1129:0:4178 +1130:2:2523 +1131:0:4178 +1132:2:2524 +1133:0:4178 +1134:2:2525 +1135:0:4178 +1136:2:2526 +1137:2:2527 +1138:2:2531 +1139:2:2532 +1140:2:2540 +1141:2:2541 +1142:2:2545 +1143:2:2546 +1144:2:2554 +1145:2:2559 +1146:2:2563 +1147:2:2564 +1148:2:2572 +1149:2:2573 +1150:2:2577 +1151:2:2578 +1152:2:2572 +1153:2:2573 +1154:2:2574 +1155:2:2586 +1156:2:2591 +1157:2:2598 +1158:2:2599 +1159:2:2606 +1160:2:2611 +1161:2:2618 +1162:2:2619 +1163:2:2618 +1164:2:2619 +1165:2:2626 +1166:2:2636 +1167:0:4178 +1168:2:2525 +1169:0:4178 +1170:1:118 +1171:0:4178 +1172:1:120 +1173:0:4178 +1174:1:19 +1175:0:4178 +1176:1:1151 +1177:0:4178 +1178:1:2417 +1179:1:2424 +1180:1:2425 +1181:1:2432 +1182:1:2437 +1183:1:2444 +1184:1:2445 +1185:1:2444 +1186:1:2445 +1187:1:2452 +1188:1:2456 +1189:0:4178 +1190:2:2640 +1191:2:2644 +1192:2:2645 +1193:2:2649 +1194:2:2653 +1195:2:2654 +1196:2:2658 +1197:2:2666 +1198:2:2667 +1199:2:2671 +1200:2:2675 +1201:2:2676 +1202:2:2671 +1203:2:2672 +1204:2:2680 +1205:0:4178 +1206:2:2525 +1207:0:4178 +1208:2:2688 +1209:2:2689 +1210:2:2690 +1211:0:4178 +1212:2:2525 +1213:0:4178 +1214:2:2695 +1215:0:4178 +1216:2:3307 +1217:2:3308 +1218:2:3312 +1219:2:3316 +1220:2:3317 +1221:2:3321 +1222:2:3326 +1223:2:3334 +1224:2:3338 +1225:2:3339 +1226:2:3334 +1227:2:3338 +1228:2:3339 +1229:2:3343 +1230:2:3350 +1231:2:3357 +1232:2:3358 +1233:2:3365 +1234:2:3370 +1235:2:3377 +1236:2:3378 +1237:2:3377 +1238:2:3378 +1239:2:3385 +1240:2:3389 +1241:0:4178 +1242:2:3394 +1243:0:4178 +1244:2:3395 +1245:0:4178 +1246:2:3396 +1247:0:4178 +1248:2:3397 +1249:0:4178 +1250:1:1153 +1251:1:1154 +1252:0:4176 +1253:2:3398 +1254:0:4182 +1255:1:2145 diff --git a/formal-model/results/urcu-controldataflow-ipi-intel/urcu_progress.ltl b/formal-model/results/urcu-controldataflow-ipi-intel/urcu_progress.ltl new file mode 100644 index 0000000..8718641 --- /dev/null +++ b/formal-model/results/urcu-controldataflow-ipi-intel/urcu_progress.ltl @@ -0,0 +1 @@ +([] <> !np_) diff --git a/formal-model/results/urcu-controldataflow-ipi-intel/urcu_progress_reader.define b/formal-model/results/urcu-controldataflow-ipi-intel/urcu_progress_reader.define new file mode 100644 index 0000000..ff3f783 --- /dev/null +++ b/formal-model/results/urcu-controldataflow-ipi-intel/urcu_progress_reader.define @@ -0,0 +1 @@ +#define READER_PROGRESS diff --git a/formal-model/results/urcu-controldataflow-ipi-intel/urcu_progress_reader.log b/formal-model/results/urcu-controldataflow-ipi-intel/urcu_progress_reader.log new file mode 100644 index 0000000..9fd20b0 --- /dev/null +++ b/formal-model/results/urcu-controldataflow-ipi-intel/urcu_progress_reader.log @@ -0,0 +1,535 @@ +make[1]: Entering directory `/home/compudj/doc/userspace-rcu/formal-model/urcu-controldataflow' +rm -f pan* trail.out .input.spin* *.spin.trail .input.define +touch .input.define +cat .input.define > pan.ltl +cat DEFINES >> pan.ltl +spin -f "!(`cat urcu_progress.ltl | grep -v ^//`)" >> pan.ltl +cp urcu_progress_reader.define .input.define +cat .input.define > .input.spin +cat DEFINES >> .input.spin +cat urcu.spin >> .input.spin +rm -f .input.spin.trail +spin -a -X -N pan.ltl .input.spin +Exit-Status 0 +gcc -O2 -w -DHASH64 -o pan pan.c +./pan -a -f -v -c1 -X -m10000000 -w20 +warning: for p.o. reduction to be valid the never claim must be stutter-invariant +(never claims generated from LTL formulae are stutter-invariant) +depth 0: Claim reached state 5 (line 1272) +depth 23: Claim reached state 9 (line 1277) +depth 132: Claim reached state 9 (line 1276) +Depth= 29926 States= 1e+06 Transitions= 7.64e+06 Memory= 520.256 t= 19.9 R= 5e+04 +Depth= 33506 States= 2e+06 Transitions= 1.57e+07 Memory= 571.818 t= 41.2 R= 5e+04 +Depth= 33506 States= 3e+06 Transitions= 2.45e+07 Memory= 624.943 t= 65.4 R= 5e+04 +pan: resizing hashtable to -w22.. done +Depth= 33506 States= 4e+06 Transitions= 3.46e+07 Memory= 709.873 t= 93.2 R= 4e+04 +Depth= 33506 States= 5e+06 Transitions= 4.22e+07 Memory= 764.756 t= 113 R= 4e+04 +Depth= 33506 States= 6e+06 Transitions= 6.02e+07 Memory= 815.830 t= 165 R= 4e+04 +Depth= 33506 States= 7e+06 Transitions= 7.41e+07 Memory= 867.002 t= 205 R= 3e+04 +Depth= 33506 States= 8e+06 Transitions= 9.02e+07 Memory= 917.197 t= 251 R= 3e+04 +Depth= 33506 States= 9e+06 Transitions= 1.01e+08 Memory= 967.881 t= 283 R= 3e+04 +pan: resizing hashtable to -w24.. done +Depth= 33506 States= 1e+07 Transitions= 1.17e+08 Memory= 1146.467 t= 327 R= 3e+04 +Depth= 33506 States= 1.1e+07 Transitions= 1.53e+08 Memory= 1201.154 t= 438 R= 3e+04 +Depth= 33506 States= 1.2e+07 Transitions= 1.72e+08 Memory= 1252.717 t= 492 R= 2e+04 +Depth= 33506 States= 1.3e+07 Transitions= 1.84e+08 Memory= 1303.401 t= 525 R= 2e+04 +Depth= 33506 States= 1.4e+07 Transitions= 2.05e+08 Memory= 1354.377 t= 586 R= 2e+04 +Depth= 33506 States= 1.5e+07 Transitions= 2.19e+08 Memory= 1404.572 t= 627 R= 2e+04 +Depth= 33506 States= 1.6e+07 Transitions= 2.33e+08 Memory= 1455.451 t= 666 R= 2e+04 +Depth= 33506 States= 1.7e+07 Transitions= 2.45e+08 Memory= 1506.428 t= 700 R= 2e+04 +Depth= 33506 States= 1.8e+07 Transitions= 2.57e+08 Memory= 1557.502 t= 733 R= 2e+04 +Depth= 33506 States= 1.9e+07 Transitions= 2.74e+08 Memory= 1607.697 t= 784 R= 2e+04 +Depth= 33506 States= 2e+07 Transitions= 2.86e+08 Memory= 1659.358 t= 818 R= 2e+04 +Depth= 33506 States= 2.1e+07 Transitions= 2.98e+08 Memory= 1710.920 t= 850 R= 2e+04 +Depth= 33506 States= 2.2e+07 Transitions= 3.1e+08 Memory= 1763.166 t= 883 R= 2e+04 +Depth= 33506 States= 2.3e+07 Transitions= 3.25e+08 Memory= 1814.143 t= 926 R= 2e+04 +Depth= 33506 States= 2.4e+07 Transitions= 3.44e+08 Memory= 1864.631 t= 983 R= 2e+04 +Depth= 33506 States= 2.5e+07 Transitions= 3.62e+08 Memory= 1913.264 t= 1.03e+03 R= 2e+04 +Depth= 33506 States= 2.6e+07 Transitions= 3.75e+08 Memory= 1964.045 t= 1.07e+03 R= 2e+04 +Depth= 33506 States= 2.7e+07 Transitions= 3.86e+08 Memory= 2016.291 t= 1.1e+03 R= 2e+04 +Depth= 33506 States= 2.8e+07 Transitions= 4.23e+08 Memory= 2074.592 t= 1.21e+03 R= 2e+04 +Depth= 33506 States= 2.9e+07 Transitions= 4.42e+08 Memory= 2123.225 t= 1.27e+03 R= 2e+04 +Depth= 33506 States= 3e+07 Transitions= 4.58e+08 Memory= 2173.029 t= 1.32e+03 R= 2e+04 +Depth= 33506 States= 3.1e+07 Transitions= 4.74e+08 Memory= 2224.397 t= 1.36e+03 R= 2e+04 +Depth= 33506 States= 3.2e+07 Transitions= 4.94e+08 Memory= 2276.252 t= 1.42e+03 R= 2e+04 +Depth= 33506 States= 3.3e+07 Transitions= 5.06e+08 Memory= 2325.276 t= 1.46e+03 R= 2e+04 +Depth= 33506 States= 3.4e+07 Transitions= 5.18e+08 Memory= 2376.838 t= 1.49e+03 R= 2e+04 +pan: resizing hashtable to -w26.. done +Depth= 33506 States= 3.5e+07 Transitions= 5.31e+08 Memory= 2923.408 t= 1.53e+03 R= 2e+04 +Depth= 33506 States= 3.6e+07 Transitions= 5.46e+08 Memory= 2976.143 t= 1.58e+03 R= 2e+04 +Depth= 33506 States= 3.7e+07 Transitions= 5.58e+08 Memory= 3026.338 t= 1.61e+03 R= 2e+04 +Depth= 33506 States= 3.8e+07 Transitions= 5.7e+08 Memory= 3079.170 t= 1.64e+03 R= 2e+04 +Depth= 33506 States= 3.9e+07 Transitions= 5.81e+08 Memory= 3130.537 t= 1.67e+03 R= 2e+04 +Depth= 33506 States= 4e+07 Transitions= 6e+08 Memory= 3181.318 t= 1.73e+03 R= 2e+04 +Depth= 33506 States= 4.1e+07 Transitions= 6.17e+08 Memory= 3231.611 t= 1.78e+03 R= 2e+04 +Depth= 33506 States= 4.2e+07 Transitions= 6.34e+08 Memory= 3280.244 t= 1.83e+03 R= 2e+04 +Depth= 33506 States= 4.3e+07 Transitions= 6.52e+08 Memory= 3329.268 t= 1.88e+03 R= 2e+04 + +(Spin Version 5.1.7 -- 23 December 2008) + + Partial Order Reduction + +Full statespace search for: + never claim + + assertion violations + (if within scope of claim) + acceptance cycles + (fairness enabled) + invalid end states - (disabled by never claim) + +State-vector 88 byte, depth reached 33506, errors: 0 + 26582171 states, stored (4.34241e+07 visited) +6.159304e+08 states, matched +6.5935446e+08 transitions (= visited+matched) +1.0143566e+10 atomic steps +hash conflicts: 2.9064765e+08 (resolved) + +Stats on memory usage (in Megabytes): + 2940.685 equivalent memory usage for states (stored*(State-vector + overhead)) + 2381.281 actual memory usage for states (compression: 80.98%) + state-vector as stored = 66 byte + 28 byte overhead + 512.000 memory used for hash table (-w26) + 457.764 memory used for DFS stack (-m10000000) + 1.367 memory lost to fragmentation + 3349.678 total actual memory usage + +unreached in proctype urcu_reader + line 262, "pan.___", state 30, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 270, "pan.___", state 52, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 274, "pan.___", state 61, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 77, "(1)" + line 243, "pan.___", state 85, "(1)" + line 247, "pan.___", state 97, "(1)" + line 251, "pan.___", state 105, "(1)" + line 401, "pan.___", state 131, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 163, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 177, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 195, "(1)" + line 247, "pan.___", state 215, "(1)" + line 251, "pan.___", state 223, "(1)" + line 680, "pan.___", state 242, "_proc_urcu_reader = (_proc_urcu_reader|((1<<2)<<1))" + line 401, "pan.___", state 249, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 281, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 295, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 313, "(1)" + line 247, "pan.___", state 333, "(1)" + line 251, "pan.___", state 341, "(1)" + line 401, "pan.___", state 360, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 392, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 406, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 424, "(1)" + line 247, "pan.___", state 444, "(1)" + line 251, "pan.___", state 452, "(1)" + line 401, "pan.___", state 473, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 401, "pan.___", state 475, "(1)" + line 401, "pan.___", state 476, "((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid)))" + line 401, "pan.___", state 476, "else" + line 401, "pan.___", state 479, "(1)" + line 405, "pan.___", state 487, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 405, "pan.___", state 489, "(1)" + line 405, "pan.___", state 490, "((cache_dirty_urcu_active_readers.bitfield&(1<<_pid)))" + line 405, "pan.___", state 490, "else" + line 405, "pan.___", state 493, "(1)" + line 405, "pan.___", state 494, "(1)" + line 405, "pan.___", state 494, "(1)" + line 403, "pan.___", state 499, "((i<1))" + line 403, "pan.___", state 499, "((i>=1))" + line 410, "pan.___", state 505, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 507, "(1)" + line 410, "pan.___", state 508, "((cache_dirty_rcu_ptr.bitfield&(1<<_pid)))" + line 410, "pan.___", state 508, "else" + line 410, "pan.___", state 511, "(1)" + line 410, "pan.___", state 512, "(1)" + line 410, "pan.___", state 512, "(1)" + line 414, "pan.___", state 519, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 414, "pan.___", state 521, "(1)" + line 414, "pan.___", state 522, "((cache_dirty_rcu_data[i].bitfield&(1<<_pid)))" + line 414, "pan.___", state 522, "else" + line 414, "pan.___", state 525, "(1)" + line 414, "pan.___", state 526, "(1)" + line 414, "pan.___", state 526, "(1)" + line 412, "pan.___", state 531, "((i<2))" + line 412, "pan.___", state 531, "((i>=2))" + line 239, "pan.___", state 537, "(1)" + line 243, "pan.___", state 545, "(1)" + line 243, "pan.___", state 546, "(!((cache_dirty_urcu_active_readers.bitfield&(1<<_pid))))" + line 243, "pan.___", state 546, "else" + line 241, "pan.___", state 551, "((i<1))" + line 241, "pan.___", state 551, "((i>=1))" + line 247, "pan.___", state 557, "(1)" + line 247, "pan.___", state 558, "(!((cache_dirty_rcu_ptr.bitfield&(1<<_pid))))" + line 247, "pan.___", state 558, "else" + line 251, "pan.___", state 565, "(1)" + line 251, "pan.___", state 566, "(!((cache_dirty_rcu_data[i].bitfield&(1<<_pid))))" + line 251, "pan.___", state 566, "else" + line 249, "pan.___", state 571, "((i<2))" + line 249, "pan.___", state 571, "((i>=2))" + line 256, "pan.___", state 575, "(!((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid))))" + line 256, "pan.___", state 575, "else" + line 421, "pan.___", state 577, "(1)" + line 421, "pan.___", state 577, "(1)" + line 680, "pan.___", state 580, "cached_urcu_active_readers.val[_pid] = (tmp+1)" + line 680, "pan.___", state 581, "_proc_urcu_reader = (_proc_urcu_reader|(1<<5))" + line 680, "pan.___", state 582, "(1)" + line 401, "pan.___", state 589, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 621, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 635, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 653, "(1)" + line 247, "pan.___", state 673, "(1)" + line 251, "pan.___", state 681, "(1)" + line 401, "pan.___", state 707, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 401, "pan.___", state 709, "(1)" + line 401, "pan.___", state 710, "((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid)))" + line 401, "pan.___", state 710, "else" + line 401, "pan.___", state 713, "(1)" + line 405, "pan.___", state 721, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 405, "pan.___", state 723, "(1)" + line 405, "pan.___", state 724, "((cache_dirty_urcu_active_readers.bitfield&(1<<_pid)))" + line 405, "pan.___", state 724, "else" + line 405, "pan.___", state 727, "(1)" + line 405, "pan.___", state 728, "(1)" + line 405, "pan.___", state 728, "(1)" + line 403, "pan.___", state 733, "((i<1))" + line 403, "pan.___", state 733, "((i>=1))" + line 410, "pan.___", state 739, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 741, "(1)" + line 410, "pan.___", state 742, "((cache_dirty_rcu_ptr.bitfield&(1<<_pid)))" + line 410, "pan.___", state 742, "else" + line 410, "pan.___", state 745, "(1)" + line 410, "pan.___", state 746, "(1)" + line 410, "pan.___", state 746, "(1)" + line 414, "pan.___", state 753, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 414, "pan.___", state 755, "(1)" + line 414, "pan.___", state 756, "((cache_dirty_rcu_data[i].bitfield&(1<<_pid)))" + line 414, "pan.___", state 756, "else" + line 414, "pan.___", state 759, "(1)" + line 414, "pan.___", state 760, "(1)" + line 414, "pan.___", state 760, "(1)" + line 412, "pan.___", state 765, "((i<2))" + line 412, "pan.___", state 765, "((i>=2))" + line 239, "pan.___", state 771, "(1)" + line 243, "pan.___", state 779, "(1)" + line 243, "pan.___", state 780, "(!((cache_dirty_urcu_active_readers.bitfield&(1<<_pid))))" + line 243, "pan.___", state 780, "else" + line 241, "pan.___", state 785, "((i<1))" + line 241, "pan.___", state 785, "((i>=1))" + line 247, "pan.___", state 791, "(1)" + line 247, "pan.___", state 792, "(!((cache_dirty_rcu_ptr.bitfield&(1<<_pid))))" + line 247, "pan.___", state 792, "else" + line 251, "pan.___", state 799, "(1)" + line 251, "pan.___", state 800, "(!((cache_dirty_rcu_data[i].bitfield&(1<<_pid))))" + line 251, "pan.___", state 800, "else" + line 256, "pan.___", state 809, "(!((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid))))" + line 256, "pan.___", state 809, "else" + line 421, "pan.___", state 811, "(1)" + line 421, "pan.___", state 811, "(1)" + line 401, "pan.___", state 818, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 401, "pan.___", state 820, "(1)" + line 401, "pan.___", state 821, "((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid)))" + line 401, "pan.___", state 821, "else" + line 401, "pan.___", state 824, "(1)" + line 405, "pan.___", state 832, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 405, "pan.___", state 834, "(1)" + line 405, "pan.___", state 835, "((cache_dirty_urcu_active_readers.bitfield&(1<<_pid)))" + line 405, "pan.___", state 835, "else" + line 405, "pan.___", state 838, "(1)" + line 405, "pan.___", state 839, "(1)" + line 405, "pan.___", state 839, "(1)" + line 403, "pan.___", state 844, "((i<1))" + line 403, "pan.___", state 844, "((i>=1))" + line 410, "pan.___", state 850, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 852, "(1)" + line 410, "pan.___", state 853, "((cache_dirty_rcu_ptr.bitfield&(1<<_pid)))" + line 410, "pan.___", state 853, "else" + line 410, "pan.___", state 856, "(1)" + line 410, "pan.___", state 857, "(1)" + line 410, "pan.___", state 857, "(1)" + line 414, "pan.___", state 864, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 414, "pan.___", state 866, "(1)" + line 414, "pan.___", state 867, "((cache_dirty_rcu_data[i].bitfield&(1<<_pid)))" + line 414, "pan.___", state 867, "else" + line 414, "pan.___", state 870, "(1)" + line 414, "pan.___", state 871, "(1)" + line 414, "pan.___", state 871, "(1)" + line 412, "pan.___", state 876, "((i<2))" + line 412, "pan.___", state 876, "((i>=2))" + line 239, "pan.___", state 882, "(1)" + line 243, "pan.___", state 890, "(1)" + line 243, "pan.___", state 891, "(!((cache_dirty_urcu_active_readers.bitfield&(1<<_pid))))" + line 243, "pan.___", state 891, "else" + line 241, "pan.___", state 896, "((i<1))" + line 241, "pan.___", state 896, "((i>=1))" + line 247, "pan.___", state 902, "(1)" + line 247, "pan.___", state 903, "(!((cache_dirty_rcu_ptr.bitfield&(1<<_pid))))" + line 247, "pan.___", state 903, "else" + line 251, "pan.___", state 910, "(1)" + line 251, "pan.___", state 911, "(!((cache_dirty_rcu_data[i].bitfield&(1<<_pid))))" + line 251, "pan.___", state 911, "else" + line 249, "pan.___", state 916, "((i<2))" + line 249, "pan.___", state 916, "((i>=2))" + line 256, "pan.___", state 920, "(!((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid))))" + line 256, "pan.___", state 920, "else" + line 421, "pan.___", state 922, "(1)" + line 421, "pan.___", state 922, "(1)" + line 688, "pan.___", state 926, "_proc_urcu_reader = (_proc_urcu_reader|(1<<11))" + line 401, "pan.___", state 931, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 963, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 977, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 995, "(1)" + line 247, "pan.___", state 1015, "(1)" + line 251, "pan.___", state 1023, "(1)" + line 401, "pan.___", state 1045, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 1077, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 1091, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 1109, "(1)" + line 247, "pan.___", state 1129, "(1)" + line 251, "pan.___", state 1137, "(1)" + line 401, "pan.___", state 1160, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 1192, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 1206, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 1224, "(1)" + line 247, "pan.___", state 1244, "(1)" + line 251, "pan.___", state 1252, "(1)" + line 401, "pan.___", state 1271, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 1303, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 1317, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 1335, "(1)" + line 247, "pan.___", state 1355, "(1)" + line 251, "pan.___", state 1363, "(1)" + line 401, "pan.___", state 1387, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 1419, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 1433, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 1451, "(1)" + line 247, "pan.___", state 1471, "(1)" + line 251, "pan.___", state 1479, "(1)" + line 401, "pan.___", state 1498, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 1530, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 1544, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 1562, "(1)" + line 247, "pan.___", state 1582, "(1)" + line 251, "pan.___", state 1590, "(1)" + line 401, "pan.___", state 1612, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 1644, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 1658, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 1676, "(1)" + line 247, "pan.___", state 1696, "(1)" + line 251, "pan.___", state 1704, "(1)" + line 727, "pan.___", state 1723, "_proc_urcu_reader = (_proc_urcu_reader|((1<<2)<<19))" + line 401, "pan.___", state 1730, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 1762, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 1776, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 1794, "(1)" + line 247, "pan.___", state 1814, "(1)" + line 251, "pan.___", state 1822, "(1)" + line 401, "pan.___", state 1841, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 1873, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 1887, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 1905, "(1)" + line 247, "pan.___", state 1925, "(1)" + line 251, "pan.___", state 1933, "(1)" + line 401, "pan.___", state 1954, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 401, "pan.___", state 1956, "(1)" + line 401, "pan.___", state 1957, "((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid)))" + line 401, "pan.___", state 1957, "else" + line 401, "pan.___", state 1960, "(1)" + line 405, "pan.___", state 1968, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 405, "pan.___", state 1970, "(1)" + line 405, "pan.___", state 1971, "((cache_dirty_urcu_active_readers.bitfield&(1<<_pid)))" + line 405, "pan.___", state 1971, "else" + line 405, "pan.___", state 1974, "(1)" + line 405, "pan.___", state 1975, "(1)" + line 405, "pan.___", state 1975, "(1)" + line 403, "pan.___", state 1980, "((i<1))" + line 403, "pan.___", state 1980, "((i>=1))" + line 410, "pan.___", state 1986, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 1988, "(1)" + line 410, "pan.___", state 1989, "((cache_dirty_rcu_ptr.bitfield&(1<<_pid)))" + line 410, "pan.___", state 1989, "else" + line 410, "pan.___", state 1992, "(1)" + line 410, "pan.___", state 1993, "(1)" + line 410, "pan.___", state 1993, "(1)" + line 414, "pan.___", state 2000, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 414, "pan.___", state 2002, "(1)" + line 414, "pan.___", state 2003, "((cache_dirty_rcu_data[i].bitfield&(1<<_pid)))" + line 414, "pan.___", state 2003, "else" + line 414, "pan.___", state 2006, "(1)" + line 414, "pan.___", state 2007, "(1)" + line 414, "pan.___", state 2007, "(1)" + line 412, "pan.___", state 2012, "((i<2))" + line 412, "pan.___", state 2012, "((i>=2))" + line 239, "pan.___", state 2018, "(1)" + line 243, "pan.___", state 2026, "(1)" + line 243, "pan.___", state 2027, "(!((cache_dirty_urcu_active_readers.bitfield&(1<<_pid))))" + line 243, "pan.___", state 2027, "else" + line 241, "pan.___", state 2032, "((i<1))" + line 241, "pan.___", state 2032, "((i>=1))" + line 247, "pan.___", state 2038, "(1)" + line 247, "pan.___", state 2039, "(!((cache_dirty_rcu_ptr.bitfield&(1<<_pid))))" + line 247, "pan.___", state 2039, "else" + line 251, "pan.___", state 2046, "(1)" + line 251, "pan.___", state 2047, "(!((cache_dirty_rcu_data[i].bitfield&(1<<_pid))))" + line 251, "pan.___", state 2047, "else" + line 249, "pan.___", state 2052, "((i<2))" + line 249, "pan.___", state 2052, "((i>=2))" + line 256, "pan.___", state 2056, "(!((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid))))" + line 256, "pan.___", state 2056, "else" + line 421, "pan.___", state 2058, "(1)" + line 421, "pan.___", state 2058, "(1)" + line 727, "pan.___", state 2061, "cached_urcu_active_readers.val[_pid] = (tmp+1)" + line 727, "pan.___", state 2062, "_proc_urcu_reader = (_proc_urcu_reader|(1<<23))" + line 727, "pan.___", state 2063, "(1)" + line 401, "pan.___", state 2070, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 2102, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 2116, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 2134, "(1)" + line 247, "pan.___", state 2154, "(1)" + line 251, "pan.___", state 2162, "(1)" + line 401, "pan.___", state 2187, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 2219, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 2233, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 2251, "(1)" + line 247, "pan.___", state 2271, "(1)" + line 251, "pan.___", state 2279, "(1)" + line 401, "pan.___", state 2298, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 2330, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 2344, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 2362, "(1)" + line 247, "pan.___", state 2382, "(1)" + line 251, "pan.___", state 2390, "(1)" + line 239, "pan.___", state 2421, "(1)" + line 247, "pan.___", state 2441, "(1)" + line 251, "pan.___", state 2449, "(1)" + line 239, "pan.___", state 2464, "(1)" + line 247, "pan.___", state 2484, "(1)" + line 251, "pan.___", state 2492, "(1)" + line 887, "pan.___", state 2509, "-end-" + (246 of 2509 states) +unreached in proctype urcu_writer + line 401, "pan.___", state 18, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 405, "pan.___", state 32, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 50, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 239, "pan.___", state 82, "(1)" + line 243, "pan.___", state 90, "(1)" + line 247, "pan.___", state 102, "(1)" + line 262, "pan.___", state 131, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 266, "pan.___", state 140, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 270, "pan.___", state 153, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 401, "pan.___", state 193, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 405, "pan.___", state 207, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 225, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 239, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 257, "(1)" + line 243, "pan.___", state 265, "(1)" + line 247, "pan.___", state 277, "(1)" + line 251, "pan.___", state 285, "(1)" + line 405, "pan.___", state 320, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 338, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 352, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 243, "pan.___", state 378, "(1)" + line 247, "pan.___", state 390, "(1)" + line 251, "pan.___", state 398, "(1)" + line 405, "pan.___", state 440, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 458, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 472, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 243, "pan.___", state 498, "(1)" + line 247, "pan.___", state 510, "(1)" + line 251, "pan.___", state 518, "(1)" + line 405, "pan.___", state 551, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 569, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 583, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 243, "pan.___", state 609, "(1)" + line 247, "pan.___", state 621, "(1)" + line 251, "pan.___", state 629, "(1)" + line 405, "pan.___", state 664, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 682, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 696, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 243, "pan.___", state 722, "(1)" + line 247, "pan.___", state 734, "(1)" + line 251, "pan.___", state 742, "(1)" + line 262, "pan.___", state 790, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 266, "pan.___", state 799, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 270, "pan.___", state 812, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 239, "pan.___", state 837, "(1)" + line 243, "pan.___", state 845, "(1)" + line 247, "pan.___", state 857, "(1)" + line 251, "pan.___", state 865, "(1)" + line 262, "pan.___", state 896, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 266, "pan.___", state 905, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 270, "pan.___", state 918, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 274, "pan.___", state 927, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 943, "(1)" + line 243, "pan.___", state 951, "(1)" + line 247, "pan.___", state 963, "(1)" + line 251, "pan.___", state 971, "(1)" + line 262, "pan.___", state 992, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 266, "pan.___", state 1001, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 270, "pan.___", state 1016, "(1)" + line 274, "pan.___", state 1023, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 1039, "(1)" + line 243, "pan.___", state 1047, "(1)" + line 247, "pan.___", state 1059, "(1)" + line 251, "pan.___", state 1067, "(1)" + line 262, "pan.___", state 1098, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 266, "pan.___", state 1107, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 270, "pan.___", state 1120, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 274, "pan.___", state 1129, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 1145, "(1)" + line 243, "pan.___", state 1153, "(1)" + line 247, "pan.___", state 1165, "(1)" + line 251, "pan.___", state 1173, "(1)" + line 266, "pan.___", state 1199, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 270, "pan.___", state 1212, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 274, "pan.___", state 1221, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 1237, "(1)" + line 243, "pan.___", state 1245, "(1)" + line 247, "pan.___", state 1257, "(1)" + line 251, "pan.___", state 1265, "(1)" + line 262, "pan.___", state 1296, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 266, "pan.___", state 1305, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 270, "pan.___", state 1318, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 274, "pan.___", state 1327, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 1343, "(1)" + line 243, "pan.___", state 1351, "(1)" + line 247, "pan.___", state 1363, "(1)" + line 251, "pan.___", state 1371, "(1)" + line 266, "pan.___", state 1397, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 270, "pan.___", state 1410, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 274, "pan.___", state 1419, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 1435, "(1)" + line 243, "pan.___", state 1443, "(1)" + line 247, "pan.___", state 1455, "(1)" + line 251, "pan.___", state 1463, "(1)" + line 262, "pan.___", state 1494, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 266, "pan.___", state 1503, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 270, "pan.___", state 1516, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 274, "pan.___", state 1525, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 1541, "(1)" + line 243, "pan.___", state 1549, "(1)" + line 247, "pan.___", state 1561, "(1)" + line 251, "pan.___", state 1569, "(1)" + line 266, "pan.___", state 1595, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 270, "pan.___", state 1608, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 274, "pan.___", state 1617, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 1633, "(1)" + line 243, "pan.___", state 1641, "(1)" + line 247, "pan.___", state 1653, "(1)" + line 251, "pan.___", state 1661, "(1)" + line 262, "pan.___", state 1692, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 266, "pan.___", state 1701, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 270, "pan.___", state 1714, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 274, "pan.___", state 1723, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 1739, "(1)" + line 243, "pan.___", state 1747, "(1)" + line 247, "pan.___", state 1759, "(1)" + line 251, "pan.___", state 1767, "(1)" + line 1214, "pan.___", state 1783, "-end-" + (118 of 1783 states) +unreached in proctype :init: + (0 of 78 states) +unreached in proctype :never: + line 1279, "pan.___", state 11, "-end-" + (1 of 11 states) + +pan: elapsed time 1.9e+03 seconds +pan: rate 22877.047 states/second +pan: avg transition delay 2.8788e-06 usec +cp .input.spin urcu_progress_reader.spin.input +cp .input.spin.trail urcu_progress_reader.spin.input.trail +make[1]: Leaving directory `/home/compudj/doc/userspace-rcu/formal-model/urcu-controldataflow' diff --git a/formal-model/results/urcu-controldataflow-ipi-intel/urcu_progress_reader.spin.input b/formal-model/results/urcu-controldataflow-ipi-intel/urcu_progress_reader.spin.input new file mode 100644 index 0000000..34cee26 --- /dev/null +++ b/formal-model/results/urcu-controldataflow-ipi-intel/urcu_progress_reader.spin.input @@ -0,0 +1,1250 @@ +#define READER_PROGRESS + +// Poison value for freed memory +#define POISON 1 +// Memory with correct data +#define WINE 0 +#define SLAB_SIZE 2 + +#define read_poison (data_read_first[0] == POISON || data_read_second[0] == POISON) + +#define RCU_GP_CTR_BIT (1 << 7) +#define RCU_GP_CTR_NEST_MASK (RCU_GP_CTR_BIT - 1) + +//disabled +#define REMOTE_BARRIERS + +//#define ARCH_ALPHA +#define ARCH_INTEL +//#define ARCH_POWERPC +/* + * mem.spin: Promela code to validate memory barriers with OOO memory + * and out-of-order instruction scheduling. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * Copyright (c) 2009 Mathieu Desnoyers + */ + +/* Promela validation variables. */ + +/* specific defines "included" here */ +/* DEFINES file "included" here */ + +#define NR_READERS 1 +#define NR_WRITERS 1 + +#define NR_PROCS 2 + +#define get_pid() (_pid) + +#define get_readerid() (get_pid()) + +/* + * Produced process control and data flow. Updated after each instruction to + * show which variables are ready. Using one-hot bit encoding per variable to + * save state space. Used as triggers to execute the instructions having those + * variables as input. Leaving bits active to inhibit instruction execution. + * Scheme used to make instruction disabling and automatic dependency fall-back + * automatic. + */ + +#define CONSUME_TOKENS(state, bits, notbits) \ + ((!(state & (notbits))) && (state & (bits)) == (bits)) + +#define PRODUCE_TOKENS(state, bits) \ + state = state | (bits); + +#define CLEAR_TOKENS(state, bits) \ + state = state & ~(bits) + +/* + * Types of dependency : + * + * Data dependency + * + * - True dependency, Read-after-Write (RAW) + * + * This type of dependency happens when a statement depends on the result of a + * previous statement. This applies to any statement which needs to read a + * variable written by a preceding statement. + * + * - False dependency, Write-after-Read (WAR) + * + * Typically, variable renaming can ensure that this dependency goes away. + * However, if the statements must read and then write from/to the same variable + * in the OOO memory model, renaming may be impossible, and therefore this + * causes a WAR dependency. + * + * - Output dependency, Write-after-Write (WAW) + * + * Two writes to the same variable in subsequent statements. Variable renaming + * can ensure this is not needed, but can be required when writing multiple + * times to the same OOO mem model variable. + * + * Control dependency + * + * Execution of a given instruction depends on a previous instruction evaluating + * in a way that allows its execution. E.g. : branches. + * + * Useful considerations for joining dependencies after branch + * + * - Pre-dominance + * + * "We say box i dominates box j if every path (leading from input to output + * through the diagram) which passes through box j must also pass through box + * i. Thus box i dominates box j if box j is subordinate to box i in the + * program." + * + * http://www.hipersoft.rice.edu/grads/publications/dom14.pdf + * Other classic algorithm to calculate dominance : Lengauer-Tarjan (in gcc) + * + * - Post-dominance + * + * Just as pre-dominance, but with arcs of the data flow inverted, and input vs + * output exchanged. Therefore, i post-dominating j ensures that every path + * passing by j will pass by i before reaching the output. + * + * Other considerations + * + * Note about "volatile" keyword dependency : The compiler will order volatile + * accesses so they appear in the right order on a given CPU. They can be + * reordered by the CPU instruction scheduling. This therefore cannot be + * considered as a depencency. + * + * References : + * + * Cooper, Keith D.; & Torczon, Linda. (2005). Engineering a Compiler. Morgan + * Kaufmann. ISBN 1-55860-698-X. + * Kennedy, Ken; & Allen, Randy. (2001). Optimizing Compilers for Modern + * Architectures: A Dependence-based Approach. Morgan Kaufmann. ISBN + * 1-55860-286-0. + * Muchnick, Steven S. (1997). Advanced Compiler Design and Implementation. + * Morgan Kaufmann. ISBN 1-55860-320-4. + */ + +/* + * Note about loops and nested calls + * + * To keep this model simple, loops expressed in the framework will behave as if + * there was a core synchronizing instruction between loops. To see the effect + * of loop unrolling, manually unrolling loops is required. Note that if loops + * end or start with a core synchronizing instruction, the model is appropriate. + * Nested calls are not supported. + */ + +/* + * Only Alpha has out-of-order cache bank loads. Other architectures (intel, + * powerpc, arm) ensure that dependent reads won't be reordered. c.f. + * http://www.linuxjournal.com/article/8212) +#ifdef ARCH_ALPHA +#define HAVE_OOO_CACHE_READ +#endif + +/* + * Each process have its own data in cache. Caches are randomly updated. + * smp_wmb and smp_rmb forces cache updates (write and read), smp_mb forces + * both. + */ + +typedef per_proc_byte { + byte val[NR_PROCS]; +}; + +typedef per_proc_bit { + bit val[NR_PROCS]; +}; + +/* Bitfield has a maximum of 8 procs */ +typedef per_proc_bitfield { + byte bitfield; +}; + +#define DECLARE_CACHED_VAR(type, x) \ + type mem_##x; \ + per_proc_##type cached_##x; \ + per_proc_bitfield cache_dirty_##x; + +#define INIT_CACHED_VAR(x, v, j) \ + mem_##x = v; \ + cache_dirty_##x.bitfield = 0; \ + j = 0; \ + do \ + :: j < NR_PROCS -> \ + cached_##x.val[j] = v; \ + j++ \ + :: j >= NR_PROCS -> break \ + od; + +#define IS_CACHE_DIRTY(x, id) (cache_dirty_##x.bitfield & (1 << id)) + +#define READ_CACHED_VAR(x) (cached_##x.val[get_pid()]) + +#define WRITE_CACHED_VAR(x, v) \ + atomic { \ + cached_##x.val[get_pid()] = v; \ + cache_dirty_##x.bitfield = \ + cache_dirty_##x.bitfield | (1 << get_pid()); \ + } + +#define CACHE_WRITE_TO_MEM(x, id) \ + if \ + :: IS_CACHE_DIRTY(x, id) -> \ + mem_##x = cached_##x.val[id]; \ + cache_dirty_##x.bitfield = \ + cache_dirty_##x.bitfield & (~(1 << id)); \ + :: else -> \ + skip \ + fi; + +#define CACHE_READ_FROM_MEM(x, id) \ + if \ + :: !IS_CACHE_DIRTY(x, id) -> \ + cached_##x.val[id] = mem_##x;\ + :: else -> \ + skip \ + fi; + +/* + * May update other caches if cache is dirty, or not. + */ +#define RANDOM_CACHE_WRITE_TO_MEM(x, id)\ + if \ + :: 1 -> CACHE_WRITE_TO_MEM(x, id); \ + :: 1 -> skip \ + fi; + +#define RANDOM_CACHE_READ_FROM_MEM(x, id)\ + if \ + :: 1 -> CACHE_READ_FROM_MEM(x, id); \ + :: 1 -> skip \ + fi; + +/* Must consume all prior read tokens. All subsequent reads depend on it. */ +inline smp_rmb(i) +{ + atomic { + CACHE_READ_FROM_MEM(urcu_gp_ctr, get_pid()); + i = 0; + do + :: i < NR_READERS -> + CACHE_READ_FROM_MEM(urcu_active_readers[i], get_pid()); + i++ + :: i >= NR_READERS -> break + od; + CACHE_READ_FROM_MEM(rcu_ptr, get_pid()); + i = 0; + do + :: i < SLAB_SIZE -> + CACHE_READ_FROM_MEM(rcu_data[i], get_pid()); + i++ + :: i >= SLAB_SIZE -> break + od; + } +} + +/* Must consume all prior write tokens. All subsequent writes depend on it. */ +inline smp_wmb(i) +{ + atomic { + CACHE_WRITE_TO_MEM(urcu_gp_ctr, get_pid()); + i = 0; + do + :: i < NR_READERS -> + CACHE_WRITE_TO_MEM(urcu_active_readers[i], get_pid()); + i++ + :: i >= NR_READERS -> break + od; + CACHE_WRITE_TO_MEM(rcu_ptr, get_pid()); + i = 0; + do + :: i < SLAB_SIZE -> + CACHE_WRITE_TO_MEM(rcu_data[i], get_pid()); + i++ + :: i >= SLAB_SIZE -> break + od; + } +} + +/* Synchronization point. Must consume all prior read and write tokens. All + * subsequent reads and writes depend on it. */ +inline smp_mb(i) +{ + atomic { + smp_wmb(i); + smp_rmb(i); + } +} + +#ifdef REMOTE_BARRIERS + +bit reader_barrier[NR_READERS]; + +/* + * We cannot leave the barriers dependencies in place in REMOTE_BARRIERS mode + * because they would add unexisting core synchronization and would therefore + * create an incomplete model. + * Therefore, we model the read-side memory barriers by completely disabling the + * memory barriers and their dependencies from the read-side. One at a time + * (different verification runs), we make a different instruction listen for + * signals. + */ + +#define smp_mb_reader(i, j) + +/* + * Service 0, 1 or many barrier requests. + */ +inline smp_mb_recv(i, j) +{ + do + :: (reader_barrier[get_readerid()] == 1) -> + /* + * We choose to ignore cycles caused by writer busy-looping, + * waiting for the reader, sending barrier requests, and the + * reader always services them without continuing execution. + */ +progress_ignoring_mb1: + smp_mb(i); + reader_barrier[get_readerid()] = 0; + :: 1 -> + /* + * We choose to ignore writer's non-progress caused by the + * reader ignoring the writer's mb() requests. + */ +progress_ignoring_mb2: + break; + od; +} + +#define PROGRESS_LABEL(progressid) progress_writer_progid_##progressid: + +#define smp_mb_send(i, j, progressid) \ +{ \ + smp_mb(i); \ + i = 0; \ + do \ + :: i < NR_READERS -> \ + reader_barrier[i] = 1; \ + /* \ + * Busy-looping waiting for reader barrier handling is of little\ + * interest, given the reader has the ability to totally ignore \ + * barrier requests. \ + */ \ + do \ + :: (reader_barrier[i] == 1) -> \ +PROGRESS_LABEL(progressid) \ + skip; \ + :: (reader_barrier[i] == 0) -> break; \ + od; \ + i++; \ + :: i >= NR_READERS -> \ + break \ + od; \ + smp_mb(i); \ +} + +#else + +#define smp_mb_send(i, j, progressid) smp_mb(i) +#define smp_mb_reader smp_mb(i) +#define smp_mb_recv(i, j) + +#endif + +/* Keep in sync manually with smp_rmb, smp_wmb, ooo_mem and init() */ +DECLARE_CACHED_VAR(byte, urcu_gp_ctr); +/* Note ! currently only one reader */ +DECLARE_CACHED_VAR(byte, urcu_active_readers[NR_READERS]); +/* RCU data */ +DECLARE_CACHED_VAR(bit, rcu_data[SLAB_SIZE]); + +/* RCU pointer */ +#if (SLAB_SIZE == 2) +DECLARE_CACHED_VAR(bit, rcu_ptr); +bit ptr_read_first[NR_READERS]; +bit ptr_read_second[NR_READERS]; +#else +DECLARE_CACHED_VAR(byte, rcu_ptr); +byte ptr_read_first[NR_READERS]; +byte ptr_read_second[NR_READERS]; +#endif + +bit data_read_first[NR_READERS]; +bit data_read_second[NR_READERS]; + +bit init_done = 0; + +inline wait_init_done() +{ + do + :: init_done == 0 -> skip; + :: else -> break; + od; +} + +inline ooo_mem(i) +{ + atomic { + RANDOM_CACHE_WRITE_TO_MEM(urcu_gp_ctr, get_pid()); + i = 0; + do + :: i < NR_READERS -> + RANDOM_CACHE_WRITE_TO_MEM(urcu_active_readers[i], + get_pid()); + i++ + :: i >= NR_READERS -> break + od; + RANDOM_CACHE_WRITE_TO_MEM(rcu_ptr, get_pid()); + i = 0; + do + :: i < SLAB_SIZE -> + RANDOM_CACHE_WRITE_TO_MEM(rcu_data[i], get_pid()); + i++ + :: i >= SLAB_SIZE -> break + od; +#ifdef HAVE_OOO_CACHE_READ + RANDOM_CACHE_READ_FROM_MEM(urcu_gp_ctr, get_pid()); + i = 0; + do + :: i < NR_READERS -> + RANDOM_CACHE_READ_FROM_MEM(urcu_active_readers[i], + get_pid()); + i++ + :: i >= NR_READERS -> break + od; + RANDOM_CACHE_READ_FROM_MEM(rcu_ptr, get_pid()); + i = 0; + do + :: i < SLAB_SIZE -> + RANDOM_CACHE_READ_FROM_MEM(rcu_data[i], get_pid()); + i++ + :: i >= SLAB_SIZE -> break + od; +#else + smp_rmb(i); +#endif /* HAVE_OOO_CACHE_READ */ + } +} + +/* + * Bit encoding, urcu_reader : + */ + +int _proc_urcu_reader; +#define proc_urcu_reader _proc_urcu_reader + +/* Body of PROCEDURE_READ_LOCK */ +#define READ_PROD_A_READ (1 << 0) +#define READ_PROD_B_IF_TRUE (1 << 1) +#define READ_PROD_B_IF_FALSE (1 << 2) +#define READ_PROD_C_IF_TRUE_READ (1 << 3) + +#define PROCEDURE_READ_LOCK(base, consumetoken, producetoken) \ + :: CONSUME_TOKENS(proc_urcu_reader, consumetoken, READ_PROD_A_READ << base) -> \ + ooo_mem(i); \ + tmp = READ_CACHED_VAR(urcu_active_readers[get_readerid()]); \ + PRODUCE_TOKENS(proc_urcu_reader, READ_PROD_A_READ << base); \ + :: CONSUME_TOKENS(proc_urcu_reader, \ + READ_PROD_A_READ << base, /* RAW, pre-dominant */ \ + (READ_PROD_B_IF_TRUE | READ_PROD_B_IF_FALSE) << base) -> \ + if \ + :: (!(tmp & RCU_GP_CTR_NEST_MASK)) -> \ + PRODUCE_TOKENS(proc_urcu_reader, READ_PROD_B_IF_TRUE << base); \ + :: else -> \ + PRODUCE_TOKENS(proc_urcu_reader, READ_PROD_B_IF_FALSE << base); \ + fi; \ + /* IF TRUE */ \ + :: CONSUME_TOKENS(proc_urcu_reader, READ_PROD_B_IF_TRUE << base, \ + READ_PROD_C_IF_TRUE_READ << base) -> \ + ooo_mem(i); \ + tmp2 = READ_CACHED_VAR(urcu_gp_ctr); \ + PRODUCE_TOKENS(proc_urcu_reader, READ_PROD_C_IF_TRUE_READ << base); \ + :: CONSUME_TOKENS(proc_urcu_reader, \ + (READ_PROD_C_IF_TRUE_READ /* pre-dominant */ \ + | READ_PROD_A_READ) << base, /* WAR */ \ + producetoken) -> \ + ooo_mem(i); \ + WRITE_CACHED_VAR(urcu_active_readers[get_readerid()], tmp2); \ + PRODUCE_TOKENS(proc_urcu_reader, producetoken); \ + /* IF_MERGE implies \ + * post-dominance */ \ + /* ELSE */ \ + :: CONSUME_TOKENS(proc_urcu_reader, \ + (READ_PROD_B_IF_FALSE /* pre-dominant */ \ + | READ_PROD_A_READ) << base, /* WAR */ \ + producetoken) -> \ + ooo_mem(i); \ + WRITE_CACHED_VAR(urcu_active_readers[get_readerid()], \ + tmp + 1); \ + PRODUCE_TOKENS(proc_urcu_reader, producetoken); \ + /* IF_MERGE implies \ + * post-dominance */ \ + /* ENDIF */ \ + skip + +/* Body of PROCEDURE_READ_LOCK */ +#define READ_PROC_READ_UNLOCK (1 << 0) + +#define PROCEDURE_READ_UNLOCK(base, consumetoken, producetoken) \ + :: CONSUME_TOKENS(proc_urcu_reader, \ + consumetoken, \ + READ_PROC_READ_UNLOCK << base) -> \ + ooo_mem(i); \ + tmp2 = READ_CACHED_VAR(urcu_active_readers[get_readerid()]); \ + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_READ_UNLOCK << base); \ + :: CONSUME_TOKENS(proc_urcu_reader, \ + consumetoken \ + | (READ_PROC_READ_UNLOCK << base), /* WAR */ \ + producetoken) -> \ + ooo_mem(i); \ + WRITE_CACHED_VAR(urcu_active_readers[get_readerid()], tmp2 - 1); \ + PRODUCE_TOKENS(proc_urcu_reader, producetoken); \ + skip + + +#define READ_PROD_NONE (1 << 0) + +/* PROCEDURE_READ_LOCK base = << 1 : 1 to 5 */ +#define READ_LOCK_BASE 1 +#define READ_LOCK_OUT (1 << 5) + +#define READ_PROC_FIRST_MB (1 << 6) + +/* PROCEDURE_READ_LOCK (NESTED) base : << 7 : 7 to 11 */ +#define READ_LOCK_NESTED_BASE 7 +#define READ_LOCK_NESTED_OUT (1 << 11) + +#define READ_PROC_READ_GEN (1 << 12) +#define READ_PROC_ACCESS_GEN (1 << 13) + +/* PROCEDURE_READ_UNLOCK (NESTED) base = << 14 : 14 to 15 */ +#define READ_UNLOCK_NESTED_BASE 14 +#define READ_UNLOCK_NESTED_OUT (1 << 15) + +#define READ_PROC_SECOND_MB (1 << 16) + +/* PROCEDURE_READ_UNLOCK base = << 17 : 17 to 18 */ +#define READ_UNLOCK_BASE 17 +#define READ_UNLOCK_OUT (1 << 18) + +/* PROCEDURE_READ_LOCK_UNROLL base = << 19 : 19 to 23 */ +#define READ_LOCK_UNROLL_BASE 19 +#define READ_LOCK_OUT_UNROLL (1 << 23) + +#define READ_PROC_THIRD_MB (1 << 24) + +#define READ_PROC_READ_GEN_UNROLL (1 << 25) +#define READ_PROC_ACCESS_GEN_UNROLL (1 << 26) + +#define READ_PROC_FOURTH_MB (1 << 27) + +/* PROCEDURE_READ_UNLOCK_UNROLL base = << 28 : 28 to 29 */ +#define READ_UNLOCK_UNROLL_BASE 28 +#define READ_UNLOCK_OUT_UNROLL (1 << 29) + + +/* Should not include branches */ +#define READ_PROC_ALL_TOKENS (READ_PROD_NONE \ + | READ_LOCK_OUT \ + | READ_PROC_FIRST_MB \ + | READ_LOCK_NESTED_OUT \ + | READ_PROC_READ_GEN \ + | READ_PROC_ACCESS_GEN \ + | READ_UNLOCK_NESTED_OUT \ + | READ_PROC_SECOND_MB \ + | READ_UNLOCK_OUT \ + | READ_LOCK_OUT_UNROLL \ + | READ_PROC_THIRD_MB \ + | READ_PROC_READ_GEN_UNROLL \ + | READ_PROC_ACCESS_GEN_UNROLL \ + | READ_PROC_FOURTH_MB \ + | READ_UNLOCK_OUT_UNROLL) + +/* Must clear all tokens, including branches */ +#define READ_PROC_ALL_TOKENS_CLEAR ((1 << 30) - 1) + +inline urcu_one_read(i, j, nest_i, tmp, tmp2) +{ + PRODUCE_TOKENS(proc_urcu_reader, READ_PROD_NONE); + +#ifdef NO_MB + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_FIRST_MB); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_SECOND_MB); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_THIRD_MB); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_FOURTH_MB); +#endif + +#ifdef REMOTE_BARRIERS + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_FIRST_MB); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_SECOND_MB); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_THIRD_MB); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_FOURTH_MB); +#endif + + do + :: 1 -> + +#ifdef REMOTE_BARRIERS + /* + * Signal-based memory barrier will only execute when the + * execution order appears in program order. + */ + if + :: 1 -> + atomic { + if + :: CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE, + READ_LOCK_OUT | READ_LOCK_NESTED_OUT + | READ_PROC_READ_GEN | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT + | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT, + READ_LOCK_NESTED_OUT + | READ_PROC_READ_GEN | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT + | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT | READ_LOCK_NESTED_OUT, + READ_PROC_READ_GEN | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT + | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN, + READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT + | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN | READ_PROC_ACCESS_GEN, + READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT + | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN + | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT, + READ_UNLOCK_OUT + | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN + | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT, + READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN + | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT | READ_LOCK_OUT_UNROLL, + READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN + | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL, + READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN + | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL, + READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL, + 0) -> + goto non_atomic3; +non_atomic3_end: + skip; + fi; + } + fi; + + goto non_atomic3_skip; +non_atomic3: + smp_mb_recv(i, j); + goto non_atomic3_end; +non_atomic3_skip: + +#endif /* REMOTE_BARRIERS */ + + atomic { + if + PROCEDURE_READ_LOCK(READ_LOCK_BASE, READ_PROD_NONE, READ_LOCK_OUT); + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_LOCK_OUT, /* post-dominant */ + READ_PROC_FIRST_MB) -> + smp_mb_reader(i, j); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_FIRST_MB); + + PROCEDURE_READ_LOCK(READ_LOCK_NESTED_BASE, READ_PROC_FIRST_MB | READ_LOCK_OUT, + READ_LOCK_NESTED_OUT); + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_PROC_FIRST_MB, /* mb() orders reads */ + READ_PROC_READ_GEN) -> + ooo_mem(i); + ptr_read_first[get_readerid()] = READ_CACHED_VAR(rcu_ptr); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_READ_GEN); + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_PROC_FIRST_MB /* mb() orders reads */ + | READ_PROC_READ_GEN, + READ_PROC_ACCESS_GEN) -> + /* smp_read_barrier_depends */ + goto rmb1; +rmb1_end: + data_read_first[get_readerid()] = + READ_CACHED_VAR(rcu_data[ptr_read_first[get_readerid()]]); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_ACCESS_GEN); + + + /* Note : we remove the nested memory barrier from the read unlock + * model, given it is not usually needed. The implementation has the barrier + * because the performance impact added by a branch in the common case does not + * justify it. + */ + + PROCEDURE_READ_UNLOCK(READ_UNLOCK_NESTED_BASE, + READ_PROC_FIRST_MB + | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT, + READ_UNLOCK_NESTED_OUT); + + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_PROC_ACCESS_GEN /* mb() orders reads */ + | READ_PROC_READ_GEN /* mb() orders reads */ + | READ_PROC_FIRST_MB /* mb() ordered */ + | READ_LOCK_OUT /* post-dominant */ + | READ_LOCK_NESTED_OUT /* post-dominant */ + | READ_UNLOCK_NESTED_OUT, + READ_PROC_SECOND_MB) -> + smp_mb_reader(i, j); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_SECOND_MB); + + PROCEDURE_READ_UNLOCK(READ_UNLOCK_BASE, + READ_PROC_SECOND_MB /* mb() orders reads */ + | READ_PROC_FIRST_MB /* mb() orders reads */ + | READ_LOCK_NESTED_OUT /* RAW */ + | READ_LOCK_OUT /* RAW */ + | READ_UNLOCK_NESTED_OUT, /* RAW */ + READ_UNLOCK_OUT); + + /* Unrolling loop : second consecutive lock */ + /* reading urcu_active_readers, which have been written by + * READ_UNLOCK_OUT : RAW */ + PROCEDURE_READ_LOCK(READ_LOCK_UNROLL_BASE, + READ_UNLOCK_OUT /* RAW */ + | READ_PROC_SECOND_MB /* mb() orders reads */ + | READ_PROC_FIRST_MB /* mb() orders reads */ + | READ_LOCK_NESTED_OUT /* RAW */ + | READ_LOCK_OUT /* RAW */ + | READ_UNLOCK_NESTED_OUT, /* RAW */ + READ_LOCK_OUT_UNROLL); + + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_PROC_FIRST_MB /* mb() ordered */ + | READ_PROC_SECOND_MB /* mb() ordered */ + | READ_LOCK_OUT_UNROLL /* post-dominant */ + | READ_LOCK_NESTED_OUT + | READ_LOCK_OUT + | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT, + READ_PROC_THIRD_MB) -> + smp_mb_reader(i, j); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_THIRD_MB); + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_PROC_FIRST_MB /* mb() orders reads */ + | READ_PROC_SECOND_MB /* mb() orders reads */ + | READ_PROC_THIRD_MB, /* mb() orders reads */ + READ_PROC_READ_GEN_UNROLL) -> + ooo_mem(i); + ptr_read_second[get_readerid()] = READ_CACHED_VAR(rcu_ptr); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_READ_GEN_UNROLL); + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_PROC_READ_GEN_UNROLL + | READ_PROC_FIRST_MB /* mb() orders reads */ + | READ_PROC_SECOND_MB /* mb() orders reads */ + | READ_PROC_THIRD_MB, /* mb() orders reads */ + READ_PROC_ACCESS_GEN_UNROLL) -> + /* smp_read_barrier_depends */ + goto rmb2; +rmb2_end: + data_read_second[get_readerid()] = + READ_CACHED_VAR(rcu_data[ptr_read_second[get_readerid()]]); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_ACCESS_GEN_UNROLL); + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_PROC_READ_GEN_UNROLL /* mb() orders reads */ + | READ_PROC_ACCESS_GEN_UNROLL /* mb() orders reads */ + | READ_PROC_FIRST_MB /* mb() ordered */ + | READ_PROC_SECOND_MB /* mb() ordered */ + | READ_PROC_THIRD_MB /* mb() ordered */ + | READ_LOCK_OUT_UNROLL /* post-dominant */ + | READ_LOCK_NESTED_OUT + | READ_LOCK_OUT + | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT, + READ_PROC_FOURTH_MB) -> + smp_mb_reader(i, j); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_FOURTH_MB); + + PROCEDURE_READ_UNLOCK(READ_UNLOCK_UNROLL_BASE, + READ_PROC_FOURTH_MB /* mb() orders reads */ + | READ_PROC_THIRD_MB /* mb() orders reads */ + | READ_LOCK_OUT_UNROLL /* RAW */ + | READ_PROC_SECOND_MB /* mb() orders reads */ + | READ_PROC_FIRST_MB /* mb() orders reads */ + | READ_LOCK_NESTED_OUT /* RAW */ + | READ_LOCK_OUT /* RAW */ + | READ_UNLOCK_NESTED_OUT, /* RAW */ + READ_UNLOCK_OUT_UNROLL); + :: CONSUME_TOKENS(proc_urcu_reader, READ_PROC_ALL_TOKENS, 0) -> + CLEAR_TOKENS(proc_urcu_reader, READ_PROC_ALL_TOKENS_CLEAR); + break; + fi; + } + od; + /* + * Dependency between consecutive loops : + * RAW dependency on + * WRITE_CACHED_VAR(urcu_active_readers[get_readerid()], tmp2 - 1) + * tmp = READ_CACHED_VAR(urcu_active_readers[get_readerid()]); + * between loops. + * _WHEN THE MB()s are in place_, they add full ordering of the + * generation pointer read wrt active reader count read, which ensures + * execution will not spill across loop execution. + * However, in the event mb()s are removed (execution using signal + * handler to promote barrier()() -> smp_mb()), nothing prevents one loop + * to spill its execution on other loop's execution. + */ + goto end; +rmb1: +#ifndef NO_RMB + smp_rmb(i); +#else + ooo_mem(i); +#endif + goto rmb1_end; +rmb2: +#ifndef NO_RMB + smp_rmb(i); +#else + ooo_mem(i); +#endif + goto rmb2_end; +end: + skip; +} + + + +active proctype urcu_reader() +{ + byte i, j, nest_i; + byte tmp, tmp2; + + wait_init_done(); + + assert(get_pid() < NR_PROCS); + +end_reader: + do + :: 1 -> + /* + * We do not test reader's progress here, because we are mainly + * interested in writer's progress. The reader never blocks + * anyway. We have to test for reader/writer's progress + * separately, otherwise we could think the writer is doing + * progress when it's blocked by an always progressing reader. + */ +#ifdef READER_PROGRESS +progress_reader: +#endif + urcu_one_read(i, j, nest_i, tmp, tmp2); + od; +} + +/* no name clash please */ +#undef proc_urcu_reader + + +/* Model the RCU update process. */ + +/* + * Bit encoding, urcu_writer : + * Currently only supports one reader. + */ + +int _proc_urcu_writer; +#define proc_urcu_writer _proc_urcu_writer + +#define WRITE_PROD_NONE (1 << 0) + +#define WRITE_DATA (1 << 1) +#define WRITE_PROC_WMB (1 << 2) +#define WRITE_XCHG_PTR (1 << 3) + +#define WRITE_PROC_FIRST_MB (1 << 4) + +/* first flip */ +#define WRITE_PROC_FIRST_READ_GP (1 << 5) +#define WRITE_PROC_FIRST_WRITE_GP (1 << 6) +#define WRITE_PROC_FIRST_WAIT (1 << 7) +#define WRITE_PROC_FIRST_WAIT_LOOP (1 << 8) + +/* second flip */ +#define WRITE_PROC_SECOND_READ_GP (1 << 9) +#define WRITE_PROC_SECOND_WRITE_GP (1 << 10) +#define WRITE_PROC_SECOND_WAIT (1 << 11) +#define WRITE_PROC_SECOND_WAIT_LOOP (1 << 12) + +#define WRITE_PROC_SECOND_MB (1 << 13) + +#define WRITE_FREE (1 << 14) + +#define WRITE_PROC_ALL_TOKENS (WRITE_PROD_NONE \ + | WRITE_DATA \ + | WRITE_PROC_WMB \ + | WRITE_XCHG_PTR \ + | WRITE_PROC_FIRST_MB \ + | WRITE_PROC_FIRST_READ_GP \ + | WRITE_PROC_FIRST_WRITE_GP \ + | WRITE_PROC_FIRST_WAIT \ + | WRITE_PROC_SECOND_READ_GP \ + | WRITE_PROC_SECOND_WRITE_GP \ + | WRITE_PROC_SECOND_WAIT \ + | WRITE_PROC_SECOND_MB \ + | WRITE_FREE) + +#define WRITE_PROC_ALL_TOKENS_CLEAR ((1 << 15) - 1) + +/* + * Mutexes are implied around writer execution. A single writer at a time. + */ +active proctype urcu_writer() +{ + byte i, j; + byte tmp, tmp2, tmpa; + byte cur_data = 0, old_data, loop_nr = 0; + byte cur_gp_val = 0; /* + * Keep a local trace of the current parity so + * we don't add non-existing dependencies on the global + * GP update. Needed to test single flip case. + */ + + wait_init_done(); + + assert(get_pid() < NR_PROCS); + + do + :: (loop_nr < 3) -> +#ifdef WRITER_PROGRESS +progress_writer1: +#endif + loop_nr = loop_nr + 1; + + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROD_NONE); + +#ifdef NO_WMB + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_WMB); +#endif + +#ifdef NO_MB + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_FIRST_MB); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_MB); +#endif + +#ifdef SINGLE_FLIP + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_READ_GP); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_WRITE_GP); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_WAIT); + /* For single flip, we need to know the current parity */ + cur_gp_val = cur_gp_val ^ RCU_GP_CTR_BIT; +#endif + + do :: 1 -> + atomic { + if + + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_PROD_NONE, + WRITE_DATA) -> + ooo_mem(i); + cur_data = (cur_data + 1) % SLAB_SIZE; + WRITE_CACHED_VAR(rcu_data[cur_data], WINE); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_DATA); + + + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_DATA, + WRITE_PROC_WMB) -> + smp_wmb(i); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_WMB); + + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_PROC_WMB, + WRITE_XCHG_PTR) -> + /* rcu_xchg_pointer() */ + atomic { + old_data = READ_CACHED_VAR(rcu_ptr); + WRITE_CACHED_VAR(rcu_ptr, cur_data); + } + PRODUCE_TOKENS(proc_urcu_writer, WRITE_XCHG_PTR); + + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_DATA | WRITE_PROC_WMB | WRITE_XCHG_PTR, + WRITE_PROC_FIRST_MB) -> + goto smp_mb_send1; +smp_mb_send1_end: + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_FIRST_MB); + + /* first flip */ + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_PROC_FIRST_MB, + WRITE_PROC_FIRST_READ_GP) -> + tmpa = READ_CACHED_VAR(urcu_gp_ctr); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_FIRST_READ_GP); + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_PROC_FIRST_MB | WRITE_PROC_WMB + | WRITE_PROC_FIRST_READ_GP, + WRITE_PROC_FIRST_WRITE_GP) -> + ooo_mem(i); + WRITE_CACHED_VAR(urcu_gp_ctr, tmpa ^ RCU_GP_CTR_BIT); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_FIRST_WRITE_GP); + + :: CONSUME_TOKENS(proc_urcu_writer, + //WRITE_PROC_FIRST_WRITE_GP /* TEST ADDING SYNC CORE */ + WRITE_PROC_FIRST_MB, /* can be reordered before/after flips */ + WRITE_PROC_FIRST_WAIT | WRITE_PROC_FIRST_WAIT_LOOP) -> + ooo_mem(i); + /* ONLY WAITING FOR READER 0 */ + tmp2 = READ_CACHED_VAR(urcu_active_readers[0]); +#ifndef SINGLE_FLIP + /* In normal execution, we are always starting by + * waiting for the even parity. + */ + cur_gp_val = RCU_GP_CTR_BIT; +#endif + if + :: (tmp2 & RCU_GP_CTR_NEST_MASK) + && ((tmp2 ^ cur_gp_val) & RCU_GP_CTR_BIT) -> + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_FIRST_WAIT_LOOP); + :: else -> + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_FIRST_WAIT); + fi; + + :: CONSUME_TOKENS(proc_urcu_writer, + //WRITE_PROC_FIRST_WRITE_GP /* TEST ADDING SYNC CORE */ + WRITE_PROC_FIRST_WRITE_GP + | WRITE_PROC_FIRST_READ_GP + | WRITE_PROC_FIRST_WAIT_LOOP + | WRITE_DATA | WRITE_PROC_WMB | WRITE_XCHG_PTR + | WRITE_PROC_FIRST_MB, /* can be reordered before/after flips */ + 0) -> +#ifndef GEN_ERROR_WRITER_PROGRESS + goto smp_mb_send2; +smp_mb_send2_end: +#else + ooo_mem(i); +#endif + /* This instruction loops to WRITE_PROC_FIRST_WAIT */ + CLEAR_TOKENS(proc_urcu_writer, WRITE_PROC_FIRST_WAIT_LOOP | WRITE_PROC_FIRST_WAIT); + + /* second flip */ + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_PROC_FIRST_WAIT /* Control dependency : need to branch out of + * the loop to execute the next flip (CHECK) */ + | WRITE_PROC_FIRST_WRITE_GP + | WRITE_PROC_FIRST_READ_GP + | WRITE_PROC_FIRST_MB, + WRITE_PROC_SECOND_READ_GP) -> + ooo_mem(i); + tmpa = READ_CACHED_VAR(urcu_gp_ctr); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_READ_GP); + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_PROC_FIRST_MB + | WRITE_PROC_WMB + | WRITE_PROC_FIRST_READ_GP + | WRITE_PROC_FIRST_WRITE_GP + | WRITE_PROC_SECOND_READ_GP, + WRITE_PROC_SECOND_WRITE_GP) -> + ooo_mem(i); + WRITE_CACHED_VAR(urcu_gp_ctr, tmpa ^ RCU_GP_CTR_BIT); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_WRITE_GP); + + :: CONSUME_TOKENS(proc_urcu_writer, + //WRITE_PROC_FIRST_WRITE_GP /* TEST ADDING SYNC CORE */ + WRITE_PROC_FIRST_WAIT + | WRITE_PROC_FIRST_MB, /* can be reordered before/after flips */ + WRITE_PROC_SECOND_WAIT | WRITE_PROC_SECOND_WAIT_LOOP) -> + ooo_mem(i); + /* ONLY WAITING FOR READER 0 */ + tmp2 = READ_CACHED_VAR(urcu_active_readers[0]); + if + :: (tmp2 & RCU_GP_CTR_NEST_MASK) + && ((tmp2 ^ 0) & RCU_GP_CTR_BIT) -> + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_WAIT_LOOP); + :: else -> + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_WAIT); + fi; + + :: CONSUME_TOKENS(proc_urcu_writer, + //WRITE_PROC_FIRST_WRITE_GP /* TEST ADDING SYNC CORE */ + WRITE_PROC_SECOND_WRITE_GP + | WRITE_PROC_FIRST_WRITE_GP + | WRITE_PROC_SECOND_READ_GP + | WRITE_PROC_FIRST_READ_GP + | WRITE_PROC_SECOND_WAIT_LOOP + | WRITE_DATA | WRITE_PROC_WMB | WRITE_XCHG_PTR + | WRITE_PROC_FIRST_MB, /* can be reordered before/after flips */ + 0) -> +#ifndef GEN_ERROR_WRITER_PROGRESS + goto smp_mb_send3; +smp_mb_send3_end: +#else + ooo_mem(i); +#endif + /* This instruction loops to WRITE_PROC_SECOND_WAIT */ + CLEAR_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_WAIT_LOOP | WRITE_PROC_SECOND_WAIT); + + + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_PROC_FIRST_WAIT + | WRITE_PROC_SECOND_WAIT + | WRITE_PROC_FIRST_READ_GP + | WRITE_PROC_SECOND_READ_GP + | WRITE_PROC_FIRST_WRITE_GP + | WRITE_PROC_SECOND_WRITE_GP + | WRITE_DATA | WRITE_PROC_WMB | WRITE_XCHG_PTR + | WRITE_PROC_FIRST_MB, + WRITE_PROC_SECOND_MB) -> + goto smp_mb_send4; +smp_mb_send4_end: + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_MB); + + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_XCHG_PTR + | WRITE_PROC_FIRST_WAIT + | WRITE_PROC_SECOND_WAIT + | WRITE_PROC_WMB /* No dependency on + * WRITE_DATA because we + * write to a + * different location. */ + | WRITE_PROC_SECOND_MB + | WRITE_PROC_FIRST_MB, + WRITE_FREE) -> + WRITE_CACHED_VAR(rcu_data[old_data], POISON); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_FREE); + + :: CONSUME_TOKENS(proc_urcu_writer, WRITE_PROC_ALL_TOKENS, 0) -> + CLEAR_TOKENS(proc_urcu_writer, WRITE_PROC_ALL_TOKENS_CLEAR); + break; + fi; + } + od; + /* + * Note : Promela model adds implicit serialization of the + * WRITE_FREE instruction. Normally, it would be permitted to + * spill on the next loop execution. Given the validation we do + * checks for the data entry read to be poisoned, it's ok if + * we do not check "late arriving" memory poisoning. + */ + :: else -> break; + od; + /* + * Given the reader loops infinitely, let the writer also busy-loop + * with progress here so, with weak fairness, we can test the + * writer's progress. + */ +end_writer: + do + :: 1 -> +#ifdef WRITER_PROGRESS +progress_writer2: +#endif +#ifdef READER_PROGRESS + /* + * Make sure we don't block the reader's progress. + */ + smp_mb_send(i, j, 5); +#endif + skip; + od; + + /* Non-atomic parts of the loop */ + goto end; +smp_mb_send1: + smp_mb_send(i, j, 1); + goto smp_mb_send1_end; +#ifndef GEN_ERROR_WRITER_PROGRESS +smp_mb_send2: + smp_mb_send(i, j, 2); + goto smp_mb_send2_end; +smp_mb_send3: + smp_mb_send(i, j, 3); + goto smp_mb_send3_end; +#endif +smp_mb_send4: + smp_mb_send(i, j, 4); + goto smp_mb_send4_end; +end: + skip; +} + +/* no name clash please */ +#undef proc_urcu_writer + + +/* Leave after the readers and writers so the pid count is ok. */ +init { + byte i, j; + + atomic { + INIT_CACHED_VAR(urcu_gp_ctr, 1, j); + INIT_CACHED_VAR(rcu_ptr, 0, j); + + i = 0; + do + :: i < NR_READERS -> + INIT_CACHED_VAR(urcu_active_readers[i], 0, j); + ptr_read_first[i] = 1; + ptr_read_second[i] = 1; + data_read_first[i] = WINE; + data_read_second[i] = WINE; + i++; + :: i >= NR_READERS -> break + od; + INIT_CACHED_VAR(rcu_data[0], WINE, j); + i = 1; + do + :: i < SLAB_SIZE -> + INIT_CACHED_VAR(rcu_data[i], POISON, j); + i++ + :: i >= SLAB_SIZE -> break + od; + + init_done = 1; + } +} diff --git a/formal-model/results/urcu-controldataflow-ipi-intel/urcu_progress_writer.define b/formal-model/results/urcu-controldataflow-ipi-intel/urcu_progress_writer.define new file mode 100644 index 0000000..1e4417f --- /dev/null +++ b/formal-model/results/urcu-controldataflow-ipi-intel/urcu_progress_writer.define @@ -0,0 +1 @@ +#define WRITER_PROGRESS diff --git a/formal-model/results/urcu-controldataflow-ipi-intel/urcu_progress_writer.log b/formal-model/results/urcu-controldataflow-ipi-intel/urcu_progress_writer.log new file mode 100644 index 0000000..2b68dab --- /dev/null +++ b/formal-model/results/urcu-controldataflow-ipi-intel/urcu_progress_writer.log @@ -0,0 +1,519 @@ +make[1]: Entering directory `/home/compudj/doc/userspace-rcu/formal-model/urcu-controldataflow' +rm -f pan* trail.out .input.spin* *.spin.trail .input.define +touch .input.define +cat .input.define > pan.ltl +cat DEFINES >> pan.ltl +spin -f "!(`cat urcu_progress.ltl | grep -v ^//`)" >> pan.ltl +cp urcu_progress_writer.define .input.define +cat .input.define > .input.spin +cat DEFINES >> .input.spin +cat urcu.spin >> .input.spin +rm -f .input.spin.trail +spin -a -X -N pan.ltl .input.spin +Exit-Status 0 +gcc -O2 -w -DHASH64 -o pan pan.c +./pan -a -f -v -c1 -X -m10000000 -w20 +warning: for p.o. reduction to be valid the never claim must be stutter-invariant +(never claims generated from LTL formulae are stutter-invariant) +depth 0: Claim reached state 5 (line 1272) +depth 23: Claim reached state 9 (line 1277) +depth 51: Claim reached state 9 (line 1276) +Depth= 5851 States= 1e+06 Transitions= 7.93e+06 Memory= 516.154 t= 20.4 R= 5e+04 +Depth= 6593 States= 2e+06 Transitions= 1.7e+07 Memory= 566.545 t= 44.5 R= 4e+04 +Depth= 6593 States= 3e+06 Transitions= 2.76e+07 Memory= 618.205 t= 73.5 R= 4e+04 +pan: resizing hashtable to -w22.. done +Depth= 6593 States= 4e+06 Transitions= 3.59e+07 Memory= 700.791 t= 95.6 R= 4e+04 +Depth= 6593 States= 5e+06 Transitions= 5.42e+07 Memory= 752.647 t= 148 R= 3e+04 +Depth= 6593 States= 6e+06 Transitions= 7.04e+07 Memory= 801.768 t= 194 R= 3e+04 +Depth= 6593 States= 7e+06 Transitions= 8.54e+07 Memory= 850.693 t= 237 R= 3e+04 +Depth= 6593 States= 8e+06 Transitions= 9.51e+07 Memory= 904.307 t= 264 R= 3e+04 +Depth= 6593 States= 9e+06 Transitions= 1.26e+08 Memory= 962.217 t= 356 R= 3e+04 +pan: resizing hashtable to -w24.. done +Depth= 6593 States= 1e+07 Transitions= 1.5e+08 Memory= 1135.627 t= 426 R= 2e+04 +Depth= 6593 States= 1.1e+07 Transitions= 1.66e+08 Memory= 1185.725 t= 473 R= 2e+04 +Depth= 6593 States= 1.2e+07 Transitions= 1.84e+08 Memory= 1237.385 t= 525 R= 2e+04 +Depth= 6593 States= 1.3e+07 Transitions= 2.03e+08 Memory= 1288.654 t= 579 R= 2e+04 +Depth= 6593 States= 1.4e+07 Transitions= 2.15e+08 Memory= 1339.631 t= 613 R= 2e+04 +Depth= 6593 States= 1.5e+07 Transitions= 2.28e+08 Memory= 1390.901 t= 646 R= 2e+04 +Depth= 6593 States= 1.6e+07 Transitions= 2.41e+08 Memory= 1442.756 t= 684 R= 2e+04 +Depth= 6593 States= 1.7e+07 Transitions= 2.55e+08 Memory= 1493.244 t= 724 R= 2e+04 +Depth= 6593 States= 1.8e+07 Transitions= 2.7e+08 Memory= 1545.197 t= 765 R= 2e+04 +Depth= 6593 States= 1.9e+07 Transitions= 2.82e+08 Memory= 1597.346 t= 798 R= 2e+04 +Depth= 6593 States= 2e+07 Transitions= 2.94e+08 Memory= 1649.690 t= 832 R= 2e+04 +Depth= 6593 States= 2.1e+07 Transitions= 3.04e+08 Memory= 1700.959 t= 860 R= 2e+04 +Depth= 6593 States= 2.2e+07 Transitions= 3.24e+08 Memory= 1752.815 t= 917 R= 2e+04 +Depth= 6593 States= 2.3e+07 Transitions= 3.43e+08 Memory= 1801.447 t= 973 R= 2e+04 +Depth= 6593 States= 2.4e+07 Transitions= 3.58e+08 Memory= 1850.568 t= 1.02e+03 R= 2e+04 +Depth= 6593 States= 2.5e+07 Transitions= 3.69e+08 Memory= 1903.596 t= 1.05e+03 R= 2e+04 +Depth= 6593 States= 2.6e+07 Transitions= 3.93e+08 Memory= 1960.041 t= 1.12e+03 R= 2e+04 +Depth= 6593 States= 2.7e+07 Transitions= 4.23e+08 Memory= 2011.506 t= 1.21e+03 R= 2e+04 +Depth= 6593 States= 2.8e+07 Transitions= 4.42e+08 Memory= 2062.776 t= 1.26e+03 R= 2e+04 +Depth= 6593 States= 2.9e+07 Transitions= 4.55e+08 Memory= 2113.264 t= 1.3e+03 R= 2e+04 +Depth= 6593 States= 3e+07 Transitions= 4.75e+08 Memory= 2164.240 t= 1.36e+03 R= 2e+04 +Depth= 6593 States= 3.1e+07 Transitions= 4.88e+08 Memory= 2215.315 t= 1.39e+03 R= 2e+04 +Depth= 6593 States= 3.2e+07 Transitions= 5.02e+08 Memory= 2266.193 t= 1.43e+03 R= 2e+04 +Depth= 6593 States= 3.3e+07 Transitions= 5.14e+08 Memory= 2318.147 t= 1.47e+03 R= 2e+04 +Depth= 6593 States= 3.4e+07 Transitions= 5.28e+08 Memory= 2369.416 t= 1.5e+03 R= 2e+04 +pan: resizing hashtable to -w26.. done +Depth= 6593 States= 3.5e+07 Transitions= 5.41e+08 Memory= 2917.744 t= 1.55e+03 R= 2e+04 +Depth= 6593 States= 3.6e+07 Transitions= 5.53e+08 Memory= 2969.990 t= 1.58e+03 R= 2e+04 +Depth= 6593 States= 3.7e+07 Transitions= 5.65e+08 Memory= 3022.236 t= 1.61e+03 R= 2e+04 +Depth= 6593 States= 3.8e+07 Transitions= 5.76e+08 Memory= 3073.604 t= 1.64e+03 R= 2e+04 +Depth= 6593 States= 3.9e+07 Transitions= 5.94e+08 Memory= 3125.850 t= 1.69e+03 R= 2e+04 +Depth= 6593 States= 4e+07 Transitions= 6.13e+08 Memory= 3173.994 t= 1.75e+03 R= 2e+04 +Depth= 6593 States= 4.1e+07 Transitions= 6.32e+08 Memory= 3223.115 t= 1.8e+03 R= 2e+04 +Depth= 6593 States= 4.2e+07 Transitions= 6.49e+08 Memory= 3272.236 t= 1.85e+03 R= 2e+04 + +(Spin Version 5.1.7 -- 23 December 2008) + + Partial Order Reduction + +Full statespace search for: + never claim + + assertion violations + (if within scope of claim) + acceptance cycles + (fairness enabled) + invalid end states - (disabled by never claim) + +State-vector 88 byte, depth reached 6593, errors: 0 + 25668735 states, stored (4.20113e+07 visited) +6.0674803e+08 states, matched +6.4875934e+08 transitions (= visited+matched) +9.990628e+09 atomic steps +hash conflicts: 2.634972e+08 (resolved) + +Stats on memory usage (in Megabytes): + 2839.635 equivalent memory usage for states (stored*(State-vector + overhead)) + 2304.486 actual memory usage for states (compression: 81.15%) + state-vector as stored = 66 byte + 28 byte overhead + 512.000 memory used for hash table (-w26) + 457.764 memory used for DFS stack (-m10000000) + 1.330 memory lost to fragmentation + 3272.920 total actual memory usage + +unreached in proctype urcu_reader + line 262, "pan.___", state 30, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 270, "pan.___", state 52, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 274, "pan.___", state 61, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 77, "(1)" + line 243, "pan.___", state 85, "(1)" + line 247, "pan.___", state 97, "(1)" + line 251, "pan.___", state 105, "(1)" + line 401, "pan.___", state 131, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 163, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 177, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 195, "(1)" + line 247, "pan.___", state 215, "(1)" + line 251, "pan.___", state 223, "(1)" + line 680, "pan.___", state 242, "_proc_urcu_reader = (_proc_urcu_reader|((1<<2)<<1))" + line 401, "pan.___", state 249, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 281, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 295, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 313, "(1)" + line 247, "pan.___", state 333, "(1)" + line 251, "pan.___", state 341, "(1)" + line 401, "pan.___", state 360, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 392, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 406, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 424, "(1)" + line 247, "pan.___", state 444, "(1)" + line 251, "pan.___", state 452, "(1)" + line 401, "pan.___", state 473, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 401, "pan.___", state 475, "(1)" + line 401, "pan.___", state 476, "((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid)))" + line 401, "pan.___", state 476, "else" + line 401, "pan.___", state 479, "(1)" + line 405, "pan.___", state 487, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 405, "pan.___", state 489, "(1)" + line 405, "pan.___", state 490, "((cache_dirty_urcu_active_readers.bitfield&(1<<_pid)))" + line 405, "pan.___", state 490, "else" + line 405, "pan.___", state 493, "(1)" + line 405, "pan.___", state 494, "(1)" + line 405, "pan.___", state 494, "(1)" + line 403, "pan.___", state 499, "((i<1))" + line 403, "pan.___", state 499, "((i>=1))" + line 410, "pan.___", state 505, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 507, "(1)" + line 410, "pan.___", state 508, "((cache_dirty_rcu_ptr.bitfield&(1<<_pid)))" + line 410, "pan.___", state 508, "else" + line 410, "pan.___", state 511, "(1)" + line 410, "pan.___", state 512, "(1)" + line 410, "pan.___", state 512, "(1)" + line 414, "pan.___", state 519, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 414, "pan.___", state 521, "(1)" + line 414, "pan.___", state 522, "((cache_dirty_rcu_data[i].bitfield&(1<<_pid)))" + line 414, "pan.___", state 522, "else" + line 414, "pan.___", state 525, "(1)" + line 414, "pan.___", state 526, "(1)" + line 414, "pan.___", state 526, "(1)" + line 412, "pan.___", state 531, "((i<2))" + line 412, "pan.___", state 531, "((i>=2))" + line 239, "pan.___", state 537, "(1)" + line 243, "pan.___", state 545, "(1)" + line 243, "pan.___", state 546, "(!((cache_dirty_urcu_active_readers.bitfield&(1<<_pid))))" + line 243, "pan.___", state 546, "else" + line 241, "pan.___", state 551, "((i<1))" + line 241, "pan.___", state 551, "((i>=1))" + line 247, "pan.___", state 557, "(1)" + line 247, "pan.___", state 558, "(!((cache_dirty_rcu_ptr.bitfield&(1<<_pid))))" + line 247, "pan.___", state 558, "else" + line 251, "pan.___", state 565, "(1)" + line 251, "pan.___", state 566, "(!((cache_dirty_rcu_data[i].bitfield&(1<<_pid))))" + line 251, "pan.___", state 566, "else" + line 249, "pan.___", state 571, "((i<2))" + line 249, "pan.___", state 571, "((i>=2))" + line 256, "pan.___", state 575, "(!((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid))))" + line 256, "pan.___", state 575, "else" + line 421, "pan.___", state 577, "(1)" + line 421, "pan.___", state 577, "(1)" + line 680, "pan.___", state 580, "cached_urcu_active_readers.val[_pid] = (tmp+1)" + line 680, "pan.___", state 581, "_proc_urcu_reader = (_proc_urcu_reader|(1<<5))" + line 680, "pan.___", state 582, "(1)" + line 401, "pan.___", state 589, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 621, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 635, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 653, "(1)" + line 247, "pan.___", state 673, "(1)" + line 251, "pan.___", state 681, "(1)" + line 401, "pan.___", state 707, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 401, "pan.___", state 709, "(1)" + line 401, "pan.___", state 710, "((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid)))" + line 401, "pan.___", state 710, "else" + line 401, "pan.___", state 713, "(1)" + line 405, "pan.___", state 721, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 405, "pan.___", state 723, "(1)" + line 405, "pan.___", state 724, "((cache_dirty_urcu_active_readers.bitfield&(1<<_pid)))" + line 405, "pan.___", state 724, "else" + line 405, "pan.___", state 727, "(1)" + line 405, "pan.___", state 728, "(1)" + line 405, "pan.___", state 728, "(1)" + line 403, "pan.___", state 733, "((i<1))" + line 403, "pan.___", state 733, "((i>=1))" + line 410, "pan.___", state 739, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 741, "(1)" + line 410, "pan.___", state 742, "((cache_dirty_rcu_ptr.bitfield&(1<<_pid)))" + line 410, "pan.___", state 742, "else" + line 410, "pan.___", state 745, "(1)" + line 410, "pan.___", state 746, "(1)" + line 410, "pan.___", state 746, "(1)" + line 414, "pan.___", state 753, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 414, "pan.___", state 755, "(1)" + line 414, "pan.___", state 756, "((cache_dirty_rcu_data[i].bitfield&(1<<_pid)))" + line 414, "pan.___", state 756, "else" + line 414, "pan.___", state 759, "(1)" + line 414, "pan.___", state 760, "(1)" + line 414, "pan.___", state 760, "(1)" + line 412, "pan.___", state 765, "((i<2))" + line 412, "pan.___", state 765, "((i>=2))" + line 239, "pan.___", state 771, "(1)" + line 243, "pan.___", state 779, "(1)" + line 243, "pan.___", state 780, "(!((cache_dirty_urcu_active_readers.bitfield&(1<<_pid))))" + line 243, "pan.___", state 780, "else" + line 241, "pan.___", state 785, "((i<1))" + line 241, "pan.___", state 785, "((i>=1))" + line 247, "pan.___", state 791, "(1)" + line 247, "pan.___", state 792, "(!((cache_dirty_rcu_ptr.bitfield&(1<<_pid))))" + line 247, "pan.___", state 792, "else" + line 251, "pan.___", state 799, "(1)" + line 251, "pan.___", state 800, "(!((cache_dirty_rcu_data[i].bitfield&(1<<_pid))))" + line 251, "pan.___", state 800, "else" + line 256, "pan.___", state 809, "(!((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid))))" + line 256, "pan.___", state 809, "else" + line 421, "pan.___", state 811, "(1)" + line 421, "pan.___", state 811, "(1)" + line 401, "pan.___", state 818, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 401, "pan.___", state 820, "(1)" + line 401, "pan.___", state 821, "((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid)))" + line 401, "pan.___", state 821, "else" + line 401, "pan.___", state 824, "(1)" + line 405, "pan.___", state 832, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 405, "pan.___", state 834, "(1)" + line 405, "pan.___", state 835, "((cache_dirty_urcu_active_readers.bitfield&(1<<_pid)))" + line 405, "pan.___", state 835, "else" + line 405, "pan.___", state 838, "(1)" + line 405, "pan.___", state 839, "(1)" + line 405, "pan.___", state 839, "(1)" + line 403, "pan.___", state 844, "((i<1))" + line 403, "pan.___", state 844, "((i>=1))" + line 410, "pan.___", state 850, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 852, "(1)" + line 410, "pan.___", state 853, "((cache_dirty_rcu_ptr.bitfield&(1<<_pid)))" + line 410, "pan.___", state 853, "else" + line 410, "pan.___", state 856, "(1)" + line 410, "pan.___", state 857, "(1)" + line 410, "pan.___", state 857, "(1)" + line 414, "pan.___", state 864, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 414, "pan.___", state 866, "(1)" + line 414, "pan.___", state 867, "((cache_dirty_rcu_data[i].bitfield&(1<<_pid)))" + line 414, "pan.___", state 867, "else" + line 414, "pan.___", state 870, "(1)" + line 414, "pan.___", state 871, "(1)" + line 414, "pan.___", state 871, "(1)" + line 412, "pan.___", state 876, "((i<2))" + line 412, "pan.___", state 876, "((i>=2))" + line 239, "pan.___", state 882, "(1)" + line 243, "pan.___", state 890, "(1)" + line 243, "pan.___", state 891, "(!((cache_dirty_urcu_active_readers.bitfield&(1<<_pid))))" + line 243, "pan.___", state 891, "else" + line 241, "pan.___", state 896, "((i<1))" + line 241, "pan.___", state 896, "((i>=1))" + line 247, "pan.___", state 902, "(1)" + line 247, "pan.___", state 903, "(!((cache_dirty_rcu_ptr.bitfield&(1<<_pid))))" + line 247, "pan.___", state 903, "else" + line 251, "pan.___", state 910, "(1)" + line 251, "pan.___", state 911, "(!((cache_dirty_rcu_data[i].bitfield&(1<<_pid))))" + line 251, "pan.___", state 911, "else" + line 249, "pan.___", state 916, "((i<2))" + line 249, "pan.___", state 916, "((i>=2))" + line 256, "pan.___", state 920, "(!((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid))))" + line 256, "pan.___", state 920, "else" + line 421, "pan.___", state 922, "(1)" + line 421, "pan.___", state 922, "(1)" + line 688, "pan.___", state 926, "_proc_urcu_reader = (_proc_urcu_reader|(1<<11))" + line 401, "pan.___", state 931, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 963, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 977, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 995, "(1)" + line 247, "pan.___", state 1015, "(1)" + line 251, "pan.___", state 1023, "(1)" + line 401, "pan.___", state 1045, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 1077, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 1091, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 1109, "(1)" + line 247, "pan.___", state 1129, "(1)" + line 251, "pan.___", state 1137, "(1)" + line 401, "pan.___", state 1160, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 1192, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 1206, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 1224, "(1)" + line 247, "pan.___", state 1244, "(1)" + line 251, "pan.___", state 1252, "(1)" + line 401, "pan.___", state 1271, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 1303, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 1317, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 1335, "(1)" + line 247, "pan.___", state 1355, "(1)" + line 251, "pan.___", state 1363, "(1)" + line 401, "pan.___", state 1387, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 1419, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 1433, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 1451, "(1)" + line 247, "pan.___", state 1471, "(1)" + line 251, "pan.___", state 1479, "(1)" + line 401, "pan.___", state 1498, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 1530, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 1544, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 1562, "(1)" + line 247, "pan.___", state 1582, "(1)" + line 251, "pan.___", state 1590, "(1)" + line 401, "pan.___", state 1612, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 1644, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 1658, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 1676, "(1)" + line 247, "pan.___", state 1696, "(1)" + line 251, "pan.___", state 1704, "(1)" + line 727, "pan.___", state 1723, "_proc_urcu_reader = (_proc_urcu_reader|((1<<2)<<19))" + line 401, "pan.___", state 1730, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 1762, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 1776, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 1794, "(1)" + line 247, "pan.___", state 1814, "(1)" + line 251, "pan.___", state 1822, "(1)" + line 401, "pan.___", state 1841, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 1873, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 1887, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 1905, "(1)" + line 247, "pan.___", state 1925, "(1)" + line 251, "pan.___", state 1933, "(1)" + line 401, "pan.___", state 1954, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 401, "pan.___", state 1956, "(1)" + line 401, "pan.___", state 1957, "((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid)))" + line 401, "pan.___", state 1957, "else" + line 401, "pan.___", state 1960, "(1)" + line 405, "pan.___", state 1968, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 405, "pan.___", state 1970, "(1)" + line 405, "pan.___", state 1971, "((cache_dirty_urcu_active_readers.bitfield&(1<<_pid)))" + line 405, "pan.___", state 1971, "else" + line 405, "pan.___", state 1974, "(1)" + line 405, "pan.___", state 1975, "(1)" + line 405, "pan.___", state 1975, "(1)" + line 403, "pan.___", state 1980, "((i<1))" + line 403, "pan.___", state 1980, "((i>=1))" + line 410, "pan.___", state 1986, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 1988, "(1)" + line 410, "pan.___", state 1989, "((cache_dirty_rcu_ptr.bitfield&(1<<_pid)))" + line 410, "pan.___", state 1989, "else" + line 410, "pan.___", state 1992, "(1)" + line 410, "pan.___", state 1993, "(1)" + line 410, "pan.___", state 1993, "(1)" + line 414, "pan.___", state 2000, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 414, "pan.___", state 2002, "(1)" + line 414, "pan.___", state 2003, "((cache_dirty_rcu_data[i].bitfield&(1<<_pid)))" + line 414, "pan.___", state 2003, "else" + line 414, "pan.___", state 2006, "(1)" + line 414, "pan.___", state 2007, "(1)" + line 414, "pan.___", state 2007, "(1)" + line 412, "pan.___", state 2012, "((i<2))" + line 412, "pan.___", state 2012, "((i>=2))" + line 239, "pan.___", state 2018, "(1)" + line 243, "pan.___", state 2026, "(1)" + line 243, "pan.___", state 2027, "(!((cache_dirty_urcu_active_readers.bitfield&(1<<_pid))))" + line 243, "pan.___", state 2027, "else" + line 241, "pan.___", state 2032, "((i<1))" + line 241, "pan.___", state 2032, "((i>=1))" + line 247, "pan.___", state 2038, "(1)" + line 247, "pan.___", state 2039, "(!((cache_dirty_rcu_ptr.bitfield&(1<<_pid))))" + line 247, "pan.___", state 2039, "else" + line 251, "pan.___", state 2046, "(1)" + line 251, "pan.___", state 2047, "(!((cache_dirty_rcu_data[i].bitfield&(1<<_pid))))" + line 251, "pan.___", state 2047, "else" + line 249, "pan.___", state 2052, "((i<2))" + line 249, "pan.___", state 2052, "((i>=2))" + line 256, "pan.___", state 2056, "(!((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid))))" + line 256, "pan.___", state 2056, "else" + line 421, "pan.___", state 2058, "(1)" + line 421, "pan.___", state 2058, "(1)" + line 727, "pan.___", state 2061, "cached_urcu_active_readers.val[_pid] = (tmp+1)" + line 727, "pan.___", state 2062, "_proc_urcu_reader = (_proc_urcu_reader|(1<<23))" + line 727, "pan.___", state 2063, "(1)" + line 401, "pan.___", state 2070, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 2102, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 2116, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 2134, "(1)" + line 247, "pan.___", state 2154, "(1)" + line 251, "pan.___", state 2162, "(1)" + line 401, "pan.___", state 2187, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 2219, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 2233, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 2251, "(1)" + line 247, "pan.___", state 2271, "(1)" + line 251, "pan.___", state 2279, "(1)" + line 401, "pan.___", state 2298, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 2330, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 2344, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 2362, "(1)" + line 247, "pan.___", state 2382, "(1)" + line 251, "pan.___", state 2390, "(1)" + line 239, "pan.___", state 2421, "(1)" + line 247, "pan.___", state 2441, "(1)" + line 251, "pan.___", state 2449, "(1)" + line 239, "pan.___", state 2464, "(1)" + line 247, "pan.___", state 2484, "(1)" + line 251, "pan.___", state 2492, "(1)" + line 887, "pan.___", state 2509, "-end-" + (246 of 2509 states) +unreached in proctype urcu_writer + line 401, "pan.___", state 18, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 405, "pan.___", state 32, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 50, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 239, "pan.___", state 82, "(1)" + line 243, "pan.___", state 90, "(1)" + line 247, "pan.___", state 102, "(1)" + line 262, "pan.___", state 131, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 266, "pan.___", state 140, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 270, "pan.___", state 153, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 401, "pan.___", state 193, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 405, "pan.___", state 207, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 225, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 239, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 257, "(1)" + line 243, "pan.___", state 265, "(1)" + line 247, "pan.___", state 277, "(1)" + line 251, "pan.___", state 285, "(1)" + line 405, "pan.___", state 320, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 338, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 352, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 243, "pan.___", state 378, "(1)" + line 247, "pan.___", state 390, "(1)" + line 251, "pan.___", state 398, "(1)" + line 405, "pan.___", state 440, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 458, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 472, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 243, "pan.___", state 498, "(1)" + line 247, "pan.___", state 510, "(1)" + line 251, "pan.___", state 518, "(1)" + line 405, "pan.___", state 551, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 569, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 583, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 243, "pan.___", state 609, "(1)" + line 247, "pan.___", state 621, "(1)" + line 251, "pan.___", state 629, "(1)" + line 405, "pan.___", state 664, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 410, "pan.___", state 682, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 414, "pan.___", state 696, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 243, "pan.___", state 722, "(1)" + line 247, "pan.___", state 734, "(1)" + line 251, "pan.___", state 742, "(1)" + line 262, "pan.___", state 795, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 266, "pan.___", state 804, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 270, "pan.___", state 819, "(1)" + line 274, "pan.___", state 826, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 842, "(1)" + line 243, "pan.___", state 850, "(1)" + line 247, "pan.___", state 862, "(1)" + line 251, "pan.___", state 870, "(1)" + line 262, "pan.___", state 901, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 266, "pan.___", state 910, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 270, "pan.___", state 923, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 274, "pan.___", state 932, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 948, "(1)" + line 243, "pan.___", state 956, "(1)" + line 247, "pan.___", state 968, "(1)" + line 251, "pan.___", state 976, "(1)" + line 266, "pan.___", state 1002, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 270, "pan.___", state 1015, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 274, "pan.___", state 1024, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 1040, "(1)" + line 243, "pan.___", state 1048, "(1)" + line 247, "pan.___", state 1060, "(1)" + line 251, "pan.___", state 1068, "(1)" + line 262, "pan.___", state 1099, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 266, "pan.___", state 1108, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 270, "pan.___", state 1121, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 274, "pan.___", state 1130, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 1146, "(1)" + line 243, "pan.___", state 1154, "(1)" + line 247, "pan.___", state 1166, "(1)" + line 251, "pan.___", state 1174, "(1)" + line 266, "pan.___", state 1200, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 270, "pan.___", state 1213, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 274, "pan.___", state 1222, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 1238, "(1)" + line 243, "pan.___", state 1246, "(1)" + line 247, "pan.___", state 1258, "(1)" + line 251, "pan.___", state 1266, "(1)" + line 262, "pan.___", state 1297, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 266, "pan.___", state 1306, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 270, "pan.___", state 1319, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 274, "pan.___", state 1328, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 1344, "(1)" + line 243, "pan.___", state 1352, "(1)" + line 247, "pan.___", state 1364, "(1)" + line 251, "pan.___", state 1372, "(1)" + line 266, "pan.___", state 1398, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 270, "pan.___", state 1411, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 274, "pan.___", state 1420, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 1436, "(1)" + line 243, "pan.___", state 1444, "(1)" + line 247, "pan.___", state 1456, "(1)" + line 251, "pan.___", state 1464, "(1)" + line 262, "pan.___", state 1495, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 266, "pan.___", state 1504, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 270, "pan.___", state 1517, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 274, "pan.___", state 1526, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 239, "pan.___", state 1542, "(1)" + line 243, "pan.___", state 1550, "(1)" + line 247, "pan.___", state 1562, "(1)" + line 251, "pan.___", state 1570, "(1)" + line 1214, "pan.___", state 1586, "-end-" + (103 of 1586 states) +unreached in proctype :init: + (0 of 78 states) +unreached in proctype :never: + line 1279, "pan.___", state 11, "-end-" + (1 of 11 states) + +pan: elapsed time 1.85e+03 seconds +pan: rate 22712.991 states/second +pan: avg transition delay 2.8511e-06 usec +cp .input.spin urcu_progress_writer.spin.input +cp .input.spin.trail urcu_progress_writer.spin.input.trail +make[1]: Leaving directory `/home/compudj/doc/userspace-rcu/formal-model/urcu-controldataflow' diff --git a/formal-model/results/urcu-controldataflow-ipi-intel/urcu_progress_writer.spin.input b/formal-model/results/urcu-controldataflow-ipi-intel/urcu_progress_writer.spin.input new file mode 100644 index 0000000..6e6d67f --- /dev/null +++ b/formal-model/results/urcu-controldataflow-ipi-intel/urcu_progress_writer.spin.input @@ -0,0 +1,1250 @@ +#define WRITER_PROGRESS + +// Poison value for freed memory +#define POISON 1 +// Memory with correct data +#define WINE 0 +#define SLAB_SIZE 2 + +#define read_poison (data_read_first[0] == POISON || data_read_second[0] == POISON) + +#define RCU_GP_CTR_BIT (1 << 7) +#define RCU_GP_CTR_NEST_MASK (RCU_GP_CTR_BIT - 1) + +//disabled +#define REMOTE_BARRIERS + +//#define ARCH_ALPHA +#define ARCH_INTEL +//#define ARCH_POWERPC +/* + * mem.spin: Promela code to validate memory barriers with OOO memory + * and out-of-order instruction scheduling. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * Copyright (c) 2009 Mathieu Desnoyers + */ + +/* Promela validation variables. */ + +/* specific defines "included" here */ +/* DEFINES file "included" here */ + +#define NR_READERS 1 +#define NR_WRITERS 1 + +#define NR_PROCS 2 + +#define get_pid() (_pid) + +#define get_readerid() (get_pid()) + +/* + * Produced process control and data flow. Updated after each instruction to + * show which variables are ready. Using one-hot bit encoding per variable to + * save state space. Used as triggers to execute the instructions having those + * variables as input. Leaving bits active to inhibit instruction execution. + * Scheme used to make instruction disabling and automatic dependency fall-back + * automatic. + */ + +#define CONSUME_TOKENS(state, bits, notbits) \ + ((!(state & (notbits))) && (state & (bits)) == (bits)) + +#define PRODUCE_TOKENS(state, bits) \ + state = state | (bits); + +#define CLEAR_TOKENS(state, bits) \ + state = state & ~(bits) + +/* + * Types of dependency : + * + * Data dependency + * + * - True dependency, Read-after-Write (RAW) + * + * This type of dependency happens when a statement depends on the result of a + * previous statement. This applies to any statement which needs to read a + * variable written by a preceding statement. + * + * - False dependency, Write-after-Read (WAR) + * + * Typically, variable renaming can ensure that this dependency goes away. + * However, if the statements must read and then write from/to the same variable + * in the OOO memory model, renaming may be impossible, and therefore this + * causes a WAR dependency. + * + * - Output dependency, Write-after-Write (WAW) + * + * Two writes to the same variable in subsequent statements. Variable renaming + * can ensure this is not needed, but can be required when writing multiple + * times to the same OOO mem model variable. + * + * Control dependency + * + * Execution of a given instruction depends on a previous instruction evaluating + * in a way that allows its execution. E.g. : branches. + * + * Useful considerations for joining dependencies after branch + * + * - Pre-dominance + * + * "We say box i dominates box j if every path (leading from input to output + * through the diagram) which passes through box j must also pass through box + * i. Thus box i dominates box j if box j is subordinate to box i in the + * program." + * + * http://www.hipersoft.rice.edu/grads/publications/dom14.pdf + * Other classic algorithm to calculate dominance : Lengauer-Tarjan (in gcc) + * + * - Post-dominance + * + * Just as pre-dominance, but with arcs of the data flow inverted, and input vs + * output exchanged. Therefore, i post-dominating j ensures that every path + * passing by j will pass by i before reaching the output. + * + * Other considerations + * + * Note about "volatile" keyword dependency : The compiler will order volatile + * accesses so they appear in the right order on a given CPU. They can be + * reordered by the CPU instruction scheduling. This therefore cannot be + * considered as a depencency. + * + * References : + * + * Cooper, Keith D.; & Torczon, Linda. (2005). Engineering a Compiler. Morgan + * Kaufmann. ISBN 1-55860-698-X. + * Kennedy, Ken; & Allen, Randy. (2001). Optimizing Compilers for Modern + * Architectures: A Dependence-based Approach. Morgan Kaufmann. ISBN + * 1-55860-286-0. + * Muchnick, Steven S. (1997). Advanced Compiler Design and Implementation. + * Morgan Kaufmann. ISBN 1-55860-320-4. + */ + +/* + * Note about loops and nested calls + * + * To keep this model simple, loops expressed in the framework will behave as if + * there was a core synchronizing instruction between loops. To see the effect + * of loop unrolling, manually unrolling loops is required. Note that if loops + * end or start with a core synchronizing instruction, the model is appropriate. + * Nested calls are not supported. + */ + +/* + * Only Alpha has out-of-order cache bank loads. Other architectures (intel, + * powerpc, arm) ensure that dependent reads won't be reordered. c.f. + * http://www.linuxjournal.com/article/8212) +#ifdef ARCH_ALPHA +#define HAVE_OOO_CACHE_READ +#endif + +/* + * Each process have its own data in cache. Caches are randomly updated. + * smp_wmb and smp_rmb forces cache updates (write and read), smp_mb forces + * both. + */ + +typedef per_proc_byte { + byte val[NR_PROCS]; +}; + +typedef per_proc_bit { + bit val[NR_PROCS]; +}; + +/* Bitfield has a maximum of 8 procs */ +typedef per_proc_bitfield { + byte bitfield; +}; + +#define DECLARE_CACHED_VAR(type, x) \ + type mem_##x; \ + per_proc_##type cached_##x; \ + per_proc_bitfield cache_dirty_##x; + +#define INIT_CACHED_VAR(x, v, j) \ + mem_##x = v; \ + cache_dirty_##x.bitfield = 0; \ + j = 0; \ + do \ + :: j < NR_PROCS -> \ + cached_##x.val[j] = v; \ + j++ \ + :: j >= NR_PROCS -> break \ + od; + +#define IS_CACHE_DIRTY(x, id) (cache_dirty_##x.bitfield & (1 << id)) + +#define READ_CACHED_VAR(x) (cached_##x.val[get_pid()]) + +#define WRITE_CACHED_VAR(x, v) \ + atomic { \ + cached_##x.val[get_pid()] = v; \ + cache_dirty_##x.bitfield = \ + cache_dirty_##x.bitfield | (1 << get_pid()); \ + } + +#define CACHE_WRITE_TO_MEM(x, id) \ + if \ + :: IS_CACHE_DIRTY(x, id) -> \ + mem_##x = cached_##x.val[id]; \ + cache_dirty_##x.bitfield = \ + cache_dirty_##x.bitfield & (~(1 << id)); \ + :: else -> \ + skip \ + fi; + +#define CACHE_READ_FROM_MEM(x, id) \ + if \ + :: !IS_CACHE_DIRTY(x, id) -> \ + cached_##x.val[id] = mem_##x;\ + :: else -> \ + skip \ + fi; + +/* + * May update other caches if cache is dirty, or not. + */ +#define RANDOM_CACHE_WRITE_TO_MEM(x, id)\ + if \ + :: 1 -> CACHE_WRITE_TO_MEM(x, id); \ + :: 1 -> skip \ + fi; + +#define RANDOM_CACHE_READ_FROM_MEM(x, id)\ + if \ + :: 1 -> CACHE_READ_FROM_MEM(x, id); \ + :: 1 -> skip \ + fi; + +/* Must consume all prior read tokens. All subsequent reads depend on it. */ +inline smp_rmb(i) +{ + atomic { + CACHE_READ_FROM_MEM(urcu_gp_ctr, get_pid()); + i = 0; + do + :: i < NR_READERS -> + CACHE_READ_FROM_MEM(urcu_active_readers[i], get_pid()); + i++ + :: i >= NR_READERS -> break + od; + CACHE_READ_FROM_MEM(rcu_ptr, get_pid()); + i = 0; + do + :: i < SLAB_SIZE -> + CACHE_READ_FROM_MEM(rcu_data[i], get_pid()); + i++ + :: i >= SLAB_SIZE -> break + od; + } +} + +/* Must consume all prior write tokens. All subsequent writes depend on it. */ +inline smp_wmb(i) +{ + atomic { + CACHE_WRITE_TO_MEM(urcu_gp_ctr, get_pid()); + i = 0; + do + :: i < NR_READERS -> + CACHE_WRITE_TO_MEM(urcu_active_readers[i], get_pid()); + i++ + :: i >= NR_READERS -> break + od; + CACHE_WRITE_TO_MEM(rcu_ptr, get_pid()); + i = 0; + do + :: i < SLAB_SIZE -> + CACHE_WRITE_TO_MEM(rcu_data[i], get_pid()); + i++ + :: i >= SLAB_SIZE -> break + od; + } +} + +/* Synchronization point. Must consume all prior read and write tokens. All + * subsequent reads and writes depend on it. */ +inline smp_mb(i) +{ + atomic { + smp_wmb(i); + smp_rmb(i); + } +} + +#ifdef REMOTE_BARRIERS + +bit reader_barrier[NR_READERS]; + +/* + * We cannot leave the barriers dependencies in place in REMOTE_BARRIERS mode + * because they would add unexisting core synchronization and would therefore + * create an incomplete model. + * Therefore, we model the read-side memory barriers by completely disabling the + * memory barriers and their dependencies from the read-side. One at a time + * (different verification runs), we make a different instruction listen for + * signals. + */ + +#define smp_mb_reader(i, j) + +/* + * Service 0, 1 or many barrier requests. + */ +inline smp_mb_recv(i, j) +{ + do + :: (reader_barrier[get_readerid()] == 1) -> + /* + * We choose to ignore cycles caused by writer busy-looping, + * waiting for the reader, sending barrier requests, and the + * reader always services them without continuing execution. + */ +progress_ignoring_mb1: + smp_mb(i); + reader_barrier[get_readerid()] = 0; + :: 1 -> + /* + * We choose to ignore writer's non-progress caused by the + * reader ignoring the writer's mb() requests. + */ +progress_ignoring_mb2: + break; + od; +} + +#define PROGRESS_LABEL(progressid) progress_writer_progid_##progressid: + +#define smp_mb_send(i, j, progressid) \ +{ \ + smp_mb(i); \ + i = 0; \ + do \ + :: i < NR_READERS -> \ + reader_barrier[i] = 1; \ + /* \ + * Busy-looping waiting for reader barrier handling is of little\ + * interest, given the reader has the ability to totally ignore \ + * barrier requests. \ + */ \ + do \ + :: (reader_barrier[i] == 1) -> \ +PROGRESS_LABEL(progressid) \ + skip; \ + :: (reader_barrier[i] == 0) -> break; \ + od; \ + i++; \ + :: i >= NR_READERS -> \ + break \ + od; \ + smp_mb(i); \ +} + +#else + +#define smp_mb_send(i, j, progressid) smp_mb(i) +#define smp_mb_reader smp_mb(i) +#define smp_mb_recv(i, j) + +#endif + +/* Keep in sync manually with smp_rmb, smp_wmb, ooo_mem and init() */ +DECLARE_CACHED_VAR(byte, urcu_gp_ctr); +/* Note ! currently only one reader */ +DECLARE_CACHED_VAR(byte, urcu_active_readers[NR_READERS]); +/* RCU data */ +DECLARE_CACHED_VAR(bit, rcu_data[SLAB_SIZE]); + +/* RCU pointer */ +#if (SLAB_SIZE == 2) +DECLARE_CACHED_VAR(bit, rcu_ptr); +bit ptr_read_first[NR_READERS]; +bit ptr_read_second[NR_READERS]; +#else +DECLARE_CACHED_VAR(byte, rcu_ptr); +byte ptr_read_first[NR_READERS]; +byte ptr_read_second[NR_READERS]; +#endif + +bit data_read_first[NR_READERS]; +bit data_read_second[NR_READERS]; + +bit init_done = 0; + +inline wait_init_done() +{ + do + :: init_done == 0 -> skip; + :: else -> break; + od; +} + +inline ooo_mem(i) +{ + atomic { + RANDOM_CACHE_WRITE_TO_MEM(urcu_gp_ctr, get_pid()); + i = 0; + do + :: i < NR_READERS -> + RANDOM_CACHE_WRITE_TO_MEM(urcu_active_readers[i], + get_pid()); + i++ + :: i >= NR_READERS -> break + od; + RANDOM_CACHE_WRITE_TO_MEM(rcu_ptr, get_pid()); + i = 0; + do + :: i < SLAB_SIZE -> + RANDOM_CACHE_WRITE_TO_MEM(rcu_data[i], get_pid()); + i++ + :: i >= SLAB_SIZE -> break + od; +#ifdef HAVE_OOO_CACHE_READ + RANDOM_CACHE_READ_FROM_MEM(urcu_gp_ctr, get_pid()); + i = 0; + do + :: i < NR_READERS -> + RANDOM_CACHE_READ_FROM_MEM(urcu_active_readers[i], + get_pid()); + i++ + :: i >= NR_READERS -> break + od; + RANDOM_CACHE_READ_FROM_MEM(rcu_ptr, get_pid()); + i = 0; + do + :: i < SLAB_SIZE -> + RANDOM_CACHE_READ_FROM_MEM(rcu_data[i], get_pid()); + i++ + :: i >= SLAB_SIZE -> break + od; +#else + smp_rmb(i); +#endif /* HAVE_OOO_CACHE_READ */ + } +} + +/* + * Bit encoding, urcu_reader : + */ + +int _proc_urcu_reader; +#define proc_urcu_reader _proc_urcu_reader + +/* Body of PROCEDURE_READ_LOCK */ +#define READ_PROD_A_READ (1 << 0) +#define READ_PROD_B_IF_TRUE (1 << 1) +#define READ_PROD_B_IF_FALSE (1 << 2) +#define READ_PROD_C_IF_TRUE_READ (1 << 3) + +#define PROCEDURE_READ_LOCK(base, consumetoken, producetoken) \ + :: CONSUME_TOKENS(proc_urcu_reader, consumetoken, READ_PROD_A_READ << base) -> \ + ooo_mem(i); \ + tmp = READ_CACHED_VAR(urcu_active_readers[get_readerid()]); \ + PRODUCE_TOKENS(proc_urcu_reader, READ_PROD_A_READ << base); \ + :: CONSUME_TOKENS(proc_urcu_reader, \ + READ_PROD_A_READ << base, /* RAW, pre-dominant */ \ + (READ_PROD_B_IF_TRUE | READ_PROD_B_IF_FALSE) << base) -> \ + if \ + :: (!(tmp & RCU_GP_CTR_NEST_MASK)) -> \ + PRODUCE_TOKENS(proc_urcu_reader, READ_PROD_B_IF_TRUE << base); \ + :: else -> \ + PRODUCE_TOKENS(proc_urcu_reader, READ_PROD_B_IF_FALSE << base); \ + fi; \ + /* IF TRUE */ \ + :: CONSUME_TOKENS(proc_urcu_reader, READ_PROD_B_IF_TRUE << base, \ + READ_PROD_C_IF_TRUE_READ << base) -> \ + ooo_mem(i); \ + tmp2 = READ_CACHED_VAR(urcu_gp_ctr); \ + PRODUCE_TOKENS(proc_urcu_reader, READ_PROD_C_IF_TRUE_READ << base); \ + :: CONSUME_TOKENS(proc_urcu_reader, \ + (READ_PROD_C_IF_TRUE_READ /* pre-dominant */ \ + | READ_PROD_A_READ) << base, /* WAR */ \ + producetoken) -> \ + ooo_mem(i); \ + WRITE_CACHED_VAR(urcu_active_readers[get_readerid()], tmp2); \ + PRODUCE_TOKENS(proc_urcu_reader, producetoken); \ + /* IF_MERGE implies \ + * post-dominance */ \ + /* ELSE */ \ + :: CONSUME_TOKENS(proc_urcu_reader, \ + (READ_PROD_B_IF_FALSE /* pre-dominant */ \ + | READ_PROD_A_READ) << base, /* WAR */ \ + producetoken) -> \ + ooo_mem(i); \ + WRITE_CACHED_VAR(urcu_active_readers[get_readerid()], \ + tmp + 1); \ + PRODUCE_TOKENS(proc_urcu_reader, producetoken); \ + /* IF_MERGE implies \ + * post-dominance */ \ + /* ENDIF */ \ + skip + +/* Body of PROCEDURE_READ_LOCK */ +#define READ_PROC_READ_UNLOCK (1 << 0) + +#define PROCEDURE_READ_UNLOCK(base, consumetoken, producetoken) \ + :: CONSUME_TOKENS(proc_urcu_reader, \ + consumetoken, \ + READ_PROC_READ_UNLOCK << base) -> \ + ooo_mem(i); \ + tmp2 = READ_CACHED_VAR(urcu_active_readers[get_readerid()]); \ + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_READ_UNLOCK << base); \ + :: CONSUME_TOKENS(proc_urcu_reader, \ + consumetoken \ + | (READ_PROC_READ_UNLOCK << base), /* WAR */ \ + producetoken) -> \ + ooo_mem(i); \ + WRITE_CACHED_VAR(urcu_active_readers[get_readerid()], tmp2 - 1); \ + PRODUCE_TOKENS(proc_urcu_reader, producetoken); \ + skip + + +#define READ_PROD_NONE (1 << 0) + +/* PROCEDURE_READ_LOCK base = << 1 : 1 to 5 */ +#define READ_LOCK_BASE 1 +#define READ_LOCK_OUT (1 << 5) + +#define READ_PROC_FIRST_MB (1 << 6) + +/* PROCEDURE_READ_LOCK (NESTED) base : << 7 : 7 to 11 */ +#define READ_LOCK_NESTED_BASE 7 +#define READ_LOCK_NESTED_OUT (1 << 11) + +#define READ_PROC_READ_GEN (1 << 12) +#define READ_PROC_ACCESS_GEN (1 << 13) + +/* PROCEDURE_READ_UNLOCK (NESTED) base = << 14 : 14 to 15 */ +#define READ_UNLOCK_NESTED_BASE 14 +#define READ_UNLOCK_NESTED_OUT (1 << 15) + +#define READ_PROC_SECOND_MB (1 << 16) + +/* PROCEDURE_READ_UNLOCK base = << 17 : 17 to 18 */ +#define READ_UNLOCK_BASE 17 +#define READ_UNLOCK_OUT (1 << 18) + +/* PROCEDURE_READ_LOCK_UNROLL base = << 19 : 19 to 23 */ +#define READ_LOCK_UNROLL_BASE 19 +#define READ_LOCK_OUT_UNROLL (1 << 23) + +#define READ_PROC_THIRD_MB (1 << 24) + +#define READ_PROC_READ_GEN_UNROLL (1 << 25) +#define READ_PROC_ACCESS_GEN_UNROLL (1 << 26) + +#define READ_PROC_FOURTH_MB (1 << 27) + +/* PROCEDURE_READ_UNLOCK_UNROLL base = << 28 : 28 to 29 */ +#define READ_UNLOCK_UNROLL_BASE 28 +#define READ_UNLOCK_OUT_UNROLL (1 << 29) + + +/* Should not include branches */ +#define READ_PROC_ALL_TOKENS (READ_PROD_NONE \ + | READ_LOCK_OUT \ + | READ_PROC_FIRST_MB \ + | READ_LOCK_NESTED_OUT \ + | READ_PROC_READ_GEN \ + | READ_PROC_ACCESS_GEN \ + | READ_UNLOCK_NESTED_OUT \ + | READ_PROC_SECOND_MB \ + | READ_UNLOCK_OUT \ + | READ_LOCK_OUT_UNROLL \ + | READ_PROC_THIRD_MB \ + | READ_PROC_READ_GEN_UNROLL \ + | READ_PROC_ACCESS_GEN_UNROLL \ + | READ_PROC_FOURTH_MB \ + | READ_UNLOCK_OUT_UNROLL) + +/* Must clear all tokens, including branches */ +#define READ_PROC_ALL_TOKENS_CLEAR ((1 << 30) - 1) + +inline urcu_one_read(i, j, nest_i, tmp, tmp2) +{ + PRODUCE_TOKENS(proc_urcu_reader, READ_PROD_NONE); + +#ifdef NO_MB + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_FIRST_MB); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_SECOND_MB); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_THIRD_MB); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_FOURTH_MB); +#endif + +#ifdef REMOTE_BARRIERS + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_FIRST_MB); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_SECOND_MB); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_THIRD_MB); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_FOURTH_MB); +#endif + + do + :: 1 -> + +#ifdef REMOTE_BARRIERS + /* + * Signal-based memory barrier will only execute when the + * execution order appears in program order. + */ + if + :: 1 -> + atomic { + if + :: CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE, + READ_LOCK_OUT | READ_LOCK_NESTED_OUT + | READ_PROC_READ_GEN | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT + | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT, + READ_LOCK_NESTED_OUT + | READ_PROC_READ_GEN | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT + | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT | READ_LOCK_NESTED_OUT, + READ_PROC_READ_GEN | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT + | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN, + READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT + | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN | READ_PROC_ACCESS_GEN, + READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT + | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN + | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT, + READ_UNLOCK_OUT + | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN + | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT, + READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN + | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT | READ_LOCK_OUT_UNROLL, + READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN + | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL, + READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN + | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL, + READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL, + 0) -> + goto non_atomic3; +non_atomic3_end: + skip; + fi; + } + fi; + + goto non_atomic3_skip; +non_atomic3: + smp_mb_recv(i, j); + goto non_atomic3_end; +non_atomic3_skip: + +#endif /* REMOTE_BARRIERS */ + + atomic { + if + PROCEDURE_READ_LOCK(READ_LOCK_BASE, READ_PROD_NONE, READ_LOCK_OUT); + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_LOCK_OUT, /* post-dominant */ + READ_PROC_FIRST_MB) -> + smp_mb_reader(i, j); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_FIRST_MB); + + PROCEDURE_READ_LOCK(READ_LOCK_NESTED_BASE, READ_PROC_FIRST_MB | READ_LOCK_OUT, + READ_LOCK_NESTED_OUT); + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_PROC_FIRST_MB, /* mb() orders reads */ + READ_PROC_READ_GEN) -> + ooo_mem(i); + ptr_read_first[get_readerid()] = READ_CACHED_VAR(rcu_ptr); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_READ_GEN); + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_PROC_FIRST_MB /* mb() orders reads */ + | READ_PROC_READ_GEN, + READ_PROC_ACCESS_GEN) -> + /* smp_read_barrier_depends */ + goto rmb1; +rmb1_end: + data_read_first[get_readerid()] = + READ_CACHED_VAR(rcu_data[ptr_read_first[get_readerid()]]); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_ACCESS_GEN); + + + /* Note : we remove the nested memory barrier from the read unlock + * model, given it is not usually needed. The implementation has the barrier + * because the performance impact added by a branch in the common case does not + * justify it. + */ + + PROCEDURE_READ_UNLOCK(READ_UNLOCK_NESTED_BASE, + READ_PROC_FIRST_MB + | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT, + READ_UNLOCK_NESTED_OUT); + + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_PROC_ACCESS_GEN /* mb() orders reads */ + | READ_PROC_READ_GEN /* mb() orders reads */ + | READ_PROC_FIRST_MB /* mb() ordered */ + | READ_LOCK_OUT /* post-dominant */ + | READ_LOCK_NESTED_OUT /* post-dominant */ + | READ_UNLOCK_NESTED_OUT, + READ_PROC_SECOND_MB) -> + smp_mb_reader(i, j); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_SECOND_MB); + + PROCEDURE_READ_UNLOCK(READ_UNLOCK_BASE, + READ_PROC_SECOND_MB /* mb() orders reads */ + | READ_PROC_FIRST_MB /* mb() orders reads */ + | READ_LOCK_NESTED_OUT /* RAW */ + | READ_LOCK_OUT /* RAW */ + | READ_UNLOCK_NESTED_OUT, /* RAW */ + READ_UNLOCK_OUT); + + /* Unrolling loop : second consecutive lock */ + /* reading urcu_active_readers, which have been written by + * READ_UNLOCK_OUT : RAW */ + PROCEDURE_READ_LOCK(READ_LOCK_UNROLL_BASE, + READ_UNLOCK_OUT /* RAW */ + | READ_PROC_SECOND_MB /* mb() orders reads */ + | READ_PROC_FIRST_MB /* mb() orders reads */ + | READ_LOCK_NESTED_OUT /* RAW */ + | READ_LOCK_OUT /* RAW */ + | READ_UNLOCK_NESTED_OUT, /* RAW */ + READ_LOCK_OUT_UNROLL); + + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_PROC_FIRST_MB /* mb() ordered */ + | READ_PROC_SECOND_MB /* mb() ordered */ + | READ_LOCK_OUT_UNROLL /* post-dominant */ + | READ_LOCK_NESTED_OUT + | READ_LOCK_OUT + | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT, + READ_PROC_THIRD_MB) -> + smp_mb_reader(i, j); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_THIRD_MB); + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_PROC_FIRST_MB /* mb() orders reads */ + | READ_PROC_SECOND_MB /* mb() orders reads */ + | READ_PROC_THIRD_MB, /* mb() orders reads */ + READ_PROC_READ_GEN_UNROLL) -> + ooo_mem(i); + ptr_read_second[get_readerid()] = READ_CACHED_VAR(rcu_ptr); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_READ_GEN_UNROLL); + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_PROC_READ_GEN_UNROLL + | READ_PROC_FIRST_MB /* mb() orders reads */ + | READ_PROC_SECOND_MB /* mb() orders reads */ + | READ_PROC_THIRD_MB, /* mb() orders reads */ + READ_PROC_ACCESS_GEN_UNROLL) -> + /* smp_read_barrier_depends */ + goto rmb2; +rmb2_end: + data_read_second[get_readerid()] = + READ_CACHED_VAR(rcu_data[ptr_read_second[get_readerid()]]); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_ACCESS_GEN_UNROLL); + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_PROC_READ_GEN_UNROLL /* mb() orders reads */ + | READ_PROC_ACCESS_GEN_UNROLL /* mb() orders reads */ + | READ_PROC_FIRST_MB /* mb() ordered */ + | READ_PROC_SECOND_MB /* mb() ordered */ + | READ_PROC_THIRD_MB /* mb() ordered */ + | READ_LOCK_OUT_UNROLL /* post-dominant */ + | READ_LOCK_NESTED_OUT + | READ_LOCK_OUT + | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT, + READ_PROC_FOURTH_MB) -> + smp_mb_reader(i, j); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_FOURTH_MB); + + PROCEDURE_READ_UNLOCK(READ_UNLOCK_UNROLL_BASE, + READ_PROC_FOURTH_MB /* mb() orders reads */ + | READ_PROC_THIRD_MB /* mb() orders reads */ + | READ_LOCK_OUT_UNROLL /* RAW */ + | READ_PROC_SECOND_MB /* mb() orders reads */ + | READ_PROC_FIRST_MB /* mb() orders reads */ + | READ_LOCK_NESTED_OUT /* RAW */ + | READ_LOCK_OUT /* RAW */ + | READ_UNLOCK_NESTED_OUT, /* RAW */ + READ_UNLOCK_OUT_UNROLL); + :: CONSUME_TOKENS(proc_urcu_reader, READ_PROC_ALL_TOKENS, 0) -> + CLEAR_TOKENS(proc_urcu_reader, READ_PROC_ALL_TOKENS_CLEAR); + break; + fi; + } + od; + /* + * Dependency between consecutive loops : + * RAW dependency on + * WRITE_CACHED_VAR(urcu_active_readers[get_readerid()], tmp2 - 1) + * tmp = READ_CACHED_VAR(urcu_active_readers[get_readerid()]); + * between loops. + * _WHEN THE MB()s are in place_, they add full ordering of the + * generation pointer read wrt active reader count read, which ensures + * execution will not spill across loop execution. + * However, in the event mb()s are removed (execution using signal + * handler to promote barrier()() -> smp_mb()), nothing prevents one loop + * to spill its execution on other loop's execution. + */ + goto end; +rmb1: +#ifndef NO_RMB + smp_rmb(i); +#else + ooo_mem(i); +#endif + goto rmb1_end; +rmb2: +#ifndef NO_RMB + smp_rmb(i); +#else + ooo_mem(i); +#endif + goto rmb2_end; +end: + skip; +} + + + +active proctype urcu_reader() +{ + byte i, j, nest_i; + byte tmp, tmp2; + + wait_init_done(); + + assert(get_pid() < NR_PROCS); + +end_reader: + do + :: 1 -> + /* + * We do not test reader's progress here, because we are mainly + * interested in writer's progress. The reader never blocks + * anyway. We have to test for reader/writer's progress + * separately, otherwise we could think the writer is doing + * progress when it's blocked by an always progressing reader. + */ +#ifdef READER_PROGRESS +progress_reader: +#endif + urcu_one_read(i, j, nest_i, tmp, tmp2); + od; +} + +/* no name clash please */ +#undef proc_urcu_reader + + +/* Model the RCU update process. */ + +/* + * Bit encoding, urcu_writer : + * Currently only supports one reader. + */ + +int _proc_urcu_writer; +#define proc_urcu_writer _proc_urcu_writer + +#define WRITE_PROD_NONE (1 << 0) + +#define WRITE_DATA (1 << 1) +#define WRITE_PROC_WMB (1 << 2) +#define WRITE_XCHG_PTR (1 << 3) + +#define WRITE_PROC_FIRST_MB (1 << 4) + +/* first flip */ +#define WRITE_PROC_FIRST_READ_GP (1 << 5) +#define WRITE_PROC_FIRST_WRITE_GP (1 << 6) +#define WRITE_PROC_FIRST_WAIT (1 << 7) +#define WRITE_PROC_FIRST_WAIT_LOOP (1 << 8) + +/* second flip */ +#define WRITE_PROC_SECOND_READ_GP (1 << 9) +#define WRITE_PROC_SECOND_WRITE_GP (1 << 10) +#define WRITE_PROC_SECOND_WAIT (1 << 11) +#define WRITE_PROC_SECOND_WAIT_LOOP (1 << 12) + +#define WRITE_PROC_SECOND_MB (1 << 13) + +#define WRITE_FREE (1 << 14) + +#define WRITE_PROC_ALL_TOKENS (WRITE_PROD_NONE \ + | WRITE_DATA \ + | WRITE_PROC_WMB \ + | WRITE_XCHG_PTR \ + | WRITE_PROC_FIRST_MB \ + | WRITE_PROC_FIRST_READ_GP \ + | WRITE_PROC_FIRST_WRITE_GP \ + | WRITE_PROC_FIRST_WAIT \ + | WRITE_PROC_SECOND_READ_GP \ + | WRITE_PROC_SECOND_WRITE_GP \ + | WRITE_PROC_SECOND_WAIT \ + | WRITE_PROC_SECOND_MB \ + | WRITE_FREE) + +#define WRITE_PROC_ALL_TOKENS_CLEAR ((1 << 15) - 1) + +/* + * Mutexes are implied around writer execution. A single writer at a time. + */ +active proctype urcu_writer() +{ + byte i, j; + byte tmp, tmp2, tmpa; + byte cur_data = 0, old_data, loop_nr = 0; + byte cur_gp_val = 0; /* + * Keep a local trace of the current parity so + * we don't add non-existing dependencies on the global + * GP update. Needed to test single flip case. + */ + + wait_init_done(); + + assert(get_pid() < NR_PROCS); + + do + :: (loop_nr < 3) -> +#ifdef WRITER_PROGRESS +progress_writer1: +#endif + loop_nr = loop_nr + 1; + + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROD_NONE); + +#ifdef NO_WMB + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_WMB); +#endif + +#ifdef NO_MB + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_FIRST_MB); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_MB); +#endif + +#ifdef SINGLE_FLIP + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_READ_GP); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_WRITE_GP); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_WAIT); + /* For single flip, we need to know the current parity */ + cur_gp_val = cur_gp_val ^ RCU_GP_CTR_BIT; +#endif + + do :: 1 -> + atomic { + if + + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_PROD_NONE, + WRITE_DATA) -> + ooo_mem(i); + cur_data = (cur_data + 1) % SLAB_SIZE; + WRITE_CACHED_VAR(rcu_data[cur_data], WINE); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_DATA); + + + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_DATA, + WRITE_PROC_WMB) -> + smp_wmb(i); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_WMB); + + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_PROC_WMB, + WRITE_XCHG_PTR) -> + /* rcu_xchg_pointer() */ + atomic { + old_data = READ_CACHED_VAR(rcu_ptr); + WRITE_CACHED_VAR(rcu_ptr, cur_data); + } + PRODUCE_TOKENS(proc_urcu_writer, WRITE_XCHG_PTR); + + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_DATA | WRITE_PROC_WMB | WRITE_XCHG_PTR, + WRITE_PROC_FIRST_MB) -> + goto smp_mb_send1; +smp_mb_send1_end: + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_FIRST_MB); + + /* first flip */ + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_PROC_FIRST_MB, + WRITE_PROC_FIRST_READ_GP) -> + tmpa = READ_CACHED_VAR(urcu_gp_ctr); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_FIRST_READ_GP); + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_PROC_FIRST_MB | WRITE_PROC_WMB + | WRITE_PROC_FIRST_READ_GP, + WRITE_PROC_FIRST_WRITE_GP) -> + ooo_mem(i); + WRITE_CACHED_VAR(urcu_gp_ctr, tmpa ^ RCU_GP_CTR_BIT); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_FIRST_WRITE_GP); + + :: CONSUME_TOKENS(proc_urcu_writer, + //WRITE_PROC_FIRST_WRITE_GP /* TEST ADDING SYNC CORE */ + WRITE_PROC_FIRST_MB, /* can be reordered before/after flips */ + WRITE_PROC_FIRST_WAIT | WRITE_PROC_FIRST_WAIT_LOOP) -> + ooo_mem(i); + /* ONLY WAITING FOR READER 0 */ + tmp2 = READ_CACHED_VAR(urcu_active_readers[0]); +#ifndef SINGLE_FLIP + /* In normal execution, we are always starting by + * waiting for the even parity. + */ + cur_gp_val = RCU_GP_CTR_BIT; +#endif + if + :: (tmp2 & RCU_GP_CTR_NEST_MASK) + && ((tmp2 ^ cur_gp_val) & RCU_GP_CTR_BIT) -> + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_FIRST_WAIT_LOOP); + :: else -> + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_FIRST_WAIT); + fi; + + :: CONSUME_TOKENS(proc_urcu_writer, + //WRITE_PROC_FIRST_WRITE_GP /* TEST ADDING SYNC CORE */ + WRITE_PROC_FIRST_WRITE_GP + | WRITE_PROC_FIRST_READ_GP + | WRITE_PROC_FIRST_WAIT_LOOP + | WRITE_DATA | WRITE_PROC_WMB | WRITE_XCHG_PTR + | WRITE_PROC_FIRST_MB, /* can be reordered before/after flips */ + 0) -> +#ifndef GEN_ERROR_WRITER_PROGRESS + goto smp_mb_send2; +smp_mb_send2_end: +#else + ooo_mem(i); +#endif + /* This instruction loops to WRITE_PROC_FIRST_WAIT */ + CLEAR_TOKENS(proc_urcu_writer, WRITE_PROC_FIRST_WAIT_LOOP | WRITE_PROC_FIRST_WAIT); + + /* second flip */ + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_PROC_FIRST_WAIT /* Control dependency : need to branch out of + * the loop to execute the next flip (CHECK) */ + | WRITE_PROC_FIRST_WRITE_GP + | WRITE_PROC_FIRST_READ_GP + | WRITE_PROC_FIRST_MB, + WRITE_PROC_SECOND_READ_GP) -> + ooo_mem(i); + tmpa = READ_CACHED_VAR(urcu_gp_ctr); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_READ_GP); + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_PROC_FIRST_MB + | WRITE_PROC_WMB + | WRITE_PROC_FIRST_READ_GP + | WRITE_PROC_FIRST_WRITE_GP + | WRITE_PROC_SECOND_READ_GP, + WRITE_PROC_SECOND_WRITE_GP) -> + ooo_mem(i); + WRITE_CACHED_VAR(urcu_gp_ctr, tmpa ^ RCU_GP_CTR_BIT); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_WRITE_GP); + + :: CONSUME_TOKENS(proc_urcu_writer, + //WRITE_PROC_FIRST_WRITE_GP /* TEST ADDING SYNC CORE */ + WRITE_PROC_FIRST_WAIT + | WRITE_PROC_FIRST_MB, /* can be reordered before/after flips */ + WRITE_PROC_SECOND_WAIT | WRITE_PROC_SECOND_WAIT_LOOP) -> + ooo_mem(i); + /* ONLY WAITING FOR READER 0 */ + tmp2 = READ_CACHED_VAR(urcu_active_readers[0]); + if + :: (tmp2 & RCU_GP_CTR_NEST_MASK) + && ((tmp2 ^ 0) & RCU_GP_CTR_BIT) -> + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_WAIT_LOOP); + :: else -> + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_WAIT); + fi; + + :: CONSUME_TOKENS(proc_urcu_writer, + //WRITE_PROC_FIRST_WRITE_GP /* TEST ADDING SYNC CORE */ + WRITE_PROC_SECOND_WRITE_GP + | WRITE_PROC_FIRST_WRITE_GP + | WRITE_PROC_SECOND_READ_GP + | WRITE_PROC_FIRST_READ_GP + | WRITE_PROC_SECOND_WAIT_LOOP + | WRITE_DATA | WRITE_PROC_WMB | WRITE_XCHG_PTR + | WRITE_PROC_FIRST_MB, /* can be reordered before/after flips */ + 0) -> +#ifndef GEN_ERROR_WRITER_PROGRESS + goto smp_mb_send3; +smp_mb_send3_end: +#else + ooo_mem(i); +#endif + /* This instruction loops to WRITE_PROC_SECOND_WAIT */ + CLEAR_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_WAIT_LOOP | WRITE_PROC_SECOND_WAIT); + + + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_PROC_FIRST_WAIT + | WRITE_PROC_SECOND_WAIT + | WRITE_PROC_FIRST_READ_GP + | WRITE_PROC_SECOND_READ_GP + | WRITE_PROC_FIRST_WRITE_GP + | WRITE_PROC_SECOND_WRITE_GP + | WRITE_DATA | WRITE_PROC_WMB | WRITE_XCHG_PTR + | WRITE_PROC_FIRST_MB, + WRITE_PROC_SECOND_MB) -> + goto smp_mb_send4; +smp_mb_send4_end: + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_MB); + + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_XCHG_PTR + | WRITE_PROC_FIRST_WAIT + | WRITE_PROC_SECOND_WAIT + | WRITE_PROC_WMB /* No dependency on + * WRITE_DATA because we + * write to a + * different location. */ + | WRITE_PROC_SECOND_MB + | WRITE_PROC_FIRST_MB, + WRITE_FREE) -> + WRITE_CACHED_VAR(rcu_data[old_data], POISON); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_FREE); + + :: CONSUME_TOKENS(proc_urcu_writer, WRITE_PROC_ALL_TOKENS, 0) -> + CLEAR_TOKENS(proc_urcu_writer, WRITE_PROC_ALL_TOKENS_CLEAR); + break; + fi; + } + od; + /* + * Note : Promela model adds implicit serialization of the + * WRITE_FREE instruction. Normally, it would be permitted to + * spill on the next loop execution. Given the validation we do + * checks for the data entry read to be poisoned, it's ok if + * we do not check "late arriving" memory poisoning. + */ + :: else -> break; + od; + /* + * Given the reader loops infinitely, let the writer also busy-loop + * with progress here so, with weak fairness, we can test the + * writer's progress. + */ +end_writer: + do + :: 1 -> +#ifdef WRITER_PROGRESS +progress_writer2: +#endif +#ifdef READER_PROGRESS + /* + * Make sure we don't block the reader's progress. + */ + smp_mb_send(i, j, 5); +#endif + skip; + od; + + /* Non-atomic parts of the loop */ + goto end; +smp_mb_send1: + smp_mb_send(i, j, 1); + goto smp_mb_send1_end; +#ifndef GEN_ERROR_WRITER_PROGRESS +smp_mb_send2: + smp_mb_send(i, j, 2); + goto smp_mb_send2_end; +smp_mb_send3: + smp_mb_send(i, j, 3); + goto smp_mb_send3_end; +#endif +smp_mb_send4: + smp_mb_send(i, j, 4); + goto smp_mb_send4_end; +end: + skip; +} + +/* no name clash please */ +#undef proc_urcu_writer + + +/* Leave after the readers and writers so the pid count is ok. */ +init { + byte i, j; + + atomic { + INIT_CACHED_VAR(urcu_gp_ctr, 1, j); + INIT_CACHED_VAR(rcu_ptr, 0, j); + + i = 0; + do + :: i < NR_READERS -> + INIT_CACHED_VAR(urcu_active_readers[i], 0, j); + ptr_read_first[i] = 1; + ptr_read_second[i] = 1; + data_read_first[i] = WINE; + data_read_second[i] = WINE; + i++; + :: i >= NR_READERS -> break + od; + INIT_CACHED_VAR(rcu_data[0], WINE, j); + i = 1; + do + :: i < SLAB_SIZE -> + INIT_CACHED_VAR(rcu_data[i], POISON, j); + i++ + :: i >= SLAB_SIZE -> break + od; + + init_done = 1; + } +} diff --git a/formal-model/results/urcu-controldataflow-ipi-intel/urcu_progress_writer_error.define b/formal-model/results/urcu-controldataflow-ipi-intel/urcu_progress_writer_error.define new file mode 100644 index 0000000..8d304f5 --- /dev/null +++ b/formal-model/results/urcu-controldataflow-ipi-intel/urcu_progress_writer_error.define @@ -0,0 +1,2 @@ +#define WRITER_PROGRESS +#define GEN_ERROR_WRITER_PROGRESS diff --git a/formal-model/results/urcu-controldataflow-ipi-intel/urcu_progress_writer_error.log b/formal-model/results/urcu-controldataflow-ipi-intel/urcu_progress_writer_error.log new file mode 100644 index 0000000..a80f97b --- /dev/null +++ b/formal-model/results/urcu-controldataflow-ipi-intel/urcu_progress_writer_error.log @@ -0,0 +1,498 @@ +make[1]: Entering directory `/home/compudj/doc/userspace-rcu/formal-model/urcu-controldataflow' +rm -f pan* trail.out .input.spin* *.spin.trail .input.define +touch .input.define +cat .input.define > pan.ltl +cat DEFINES >> pan.ltl +spin -f "!(`cat urcu_progress.ltl | grep -v ^//`)" >> pan.ltl +cp urcu_progress_writer_error.define .input.define +cat .input.define > .input.spin +cat DEFINES >> .input.spin +cat urcu.spin >> .input.spin +rm -f .input.spin.trail +spin -a -X -N pan.ltl .input.spin +Exit-Status 0 +gcc -O2 -w -DHASH64 -o pan pan.c +./pan -a -f -v -c1 -X -m10000000 -w20 +warning: for p.o. reduction to be valid the never claim must be stutter-invariant +(never claims generated from LTL formulae are stutter-invariant) +depth 0: Claim reached state 5 (line 1273) +depth 23: Claim reached state 9 (line 1278) +depth 51: Claim reached state 9 (line 1277) +pan: acceptance cycle (at depth 1559) +pan: wrote .input.spin.trail + +(Spin Version 5.1.7 -- 23 December 2008) +Warning: Search not completed + + Partial Order Reduction + +Full statespace search for: + never claim + + assertion violations + (if within scope of claim) + acceptance cycles + (fairness enabled) + invalid end states - (disabled by never claim) + +State-vector 88 byte, depth reached 4532, errors: 1 + 437005 states, stored (735994 visited) + 5102692 states, matched + 5838686 transitions (= visited+matched) + 78711771 atomic steps +hash conflicts: 422011 (resolved) + +Stats on memory usage (in Megabytes): + 48.344 equivalent memory usage for states (stored*(State-vector + overhead)) + 37.421 actual memory usage for states (compression: 77.41%) + state-vector as stored = 62 byte + 28 byte overhead + 8.000 memory used for hash table (-w20) + 457.764 memory used for DFS stack (-m10000000) + 503.068 total actual memory usage + +unreached in proctype urcu_reader + line 263, "pan.___", state 30, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 271, "pan.___", state 52, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 275, "pan.___", state 61, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 240, "pan.___", state 77, "(1)" + line 244, "pan.___", state 85, "(1)" + line 248, "pan.___", state 97, "(1)" + line 252, "pan.___", state 105, "(1)" + line 402, "pan.___", state 131, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 411, "pan.___", state 163, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 415, "pan.___", state 177, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 240, "pan.___", state 195, "(1)" + line 248, "pan.___", state 215, "(1)" + line 252, "pan.___", state 223, "(1)" + line 681, "pan.___", state 242, "_proc_urcu_reader = (_proc_urcu_reader|((1<<2)<<1))" + line 402, "pan.___", state 249, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 411, "pan.___", state 281, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 415, "pan.___", state 295, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 240, "pan.___", state 313, "(1)" + line 248, "pan.___", state 333, "(1)" + line 252, "pan.___", state 341, "(1)" + line 402, "pan.___", state 360, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 411, "pan.___", state 392, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 415, "pan.___", state 406, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 240, "pan.___", state 424, "(1)" + line 248, "pan.___", state 444, "(1)" + line 252, "pan.___", state 452, "(1)" + line 402, "pan.___", state 473, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 402, "pan.___", state 475, "(1)" + line 402, "pan.___", state 476, "((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid)))" + line 402, "pan.___", state 476, "else" + line 402, "pan.___", state 479, "(1)" + line 406, "pan.___", state 487, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 406, "pan.___", state 489, "(1)" + line 406, "pan.___", state 490, "((cache_dirty_urcu_active_readers.bitfield&(1<<_pid)))" + line 406, "pan.___", state 490, "else" + line 406, "pan.___", state 493, "(1)" + line 406, "pan.___", state 494, "(1)" + line 406, "pan.___", state 494, "(1)" + line 404, "pan.___", state 499, "((i<1))" + line 404, "pan.___", state 499, "((i>=1))" + line 411, "pan.___", state 505, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 411, "pan.___", state 507, "(1)" + line 411, "pan.___", state 508, "((cache_dirty_rcu_ptr.bitfield&(1<<_pid)))" + line 411, "pan.___", state 508, "else" + line 411, "pan.___", state 511, "(1)" + line 411, "pan.___", state 512, "(1)" + line 411, "pan.___", state 512, "(1)" + line 415, "pan.___", state 519, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 415, "pan.___", state 521, "(1)" + line 415, "pan.___", state 522, "((cache_dirty_rcu_data[i].bitfield&(1<<_pid)))" + line 415, "pan.___", state 522, "else" + line 415, "pan.___", state 525, "(1)" + line 415, "pan.___", state 526, "(1)" + line 415, "pan.___", state 526, "(1)" + line 413, "pan.___", state 531, "((i<2))" + line 413, "pan.___", state 531, "((i>=2))" + line 240, "pan.___", state 537, "(1)" + line 244, "pan.___", state 545, "(1)" + line 244, "pan.___", state 546, "(!((cache_dirty_urcu_active_readers.bitfield&(1<<_pid))))" + line 244, "pan.___", state 546, "else" + line 242, "pan.___", state 551, "((i<1))" + line 242, "pan.___", state 551, "((i>=1))" + line 248, "pan.___", state 557, "(1)" + line 248, "pan.___", state 558, "(!((cache_dirty_rcu_ptr.bitfield&(1<<_pid))))" + line 248, "pan.___", state 558, "else" + line 252, "pan.___", state 565, "(1)" + line 252, "pan.___", state 566, "(!((cache_dirty_rcu_data[i].bitfield&(1<<_pid))))" + line 252, "pan.___", state 566, "else" + line 250, "pan.___", state 571, "((i<2))" + line 250, "pan.___", state 571, "((i>=2))" + line 257, "pan.___", state 575, "(!((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid))))" + line 257, "pan.___", state 575, "else" + line 422, "pan.___", state 577, "(1)" + line 422, "pan.___", state 577, "(1)" + line 681, "pan.___", state 580, "cached_urcu_active_readers.val[_pid] = (tmp+1)" + line 681, "pan.___", state 581, "_proc_urcu_reader = (_proc_urcu_reader|(1<<5))" + line 681, "pan.___", state 582, "(1)" + line 402, "pan.___", state 589, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 411, "pan.___", state 621, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 415, "pan.___", state 635, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 240, "pan.___", state 653, "(1)" + line 248, "pan.___", state 673, "(1)" + line 252, "pan.___", state 681, "(1)" + line 402, "pan.___", state 707, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 402, "pan.___", state 709, "(1)" + line 402, "pan.___", state 710, "((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid)))" + line 402, "pan.___", state 710, "else" + line 402, "pan.___", state 713, "(1)" + line 406, "pan.___", state 721, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 406, "pan.___", state 723, "(1)" + line 406, "pan.___", state 724, "((cache_dirty_urcu_active_readers.bitfield&(1<<_pid)))" + line 406, "pan.___", state 724, "else" + line 406, "pan.___", state 727, "(1)" + line 406, "pan.___", state 728, "(1)" + line 406, "pan.___", state 728, "(1)" + line 404, "pan.___", state 733, "((i<1))" + line 404, "pan.___", state 733, "((i>=1))" + line 411, "pan.___", state 739, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 411, "pan.___", state 741, "(1)" + line 411, "pan.___", state 742, "((cache_dirty_rcu_ptr.bitfield&(1<<_pid)))" + line 411, "pan.___", state 742, "else" + line 411, "pan.___", state 745, "(1)" + line 411, "pan.___", state 746, "(1)" + line 411, "pan.___", state 746, "(1)" + line 415, "pan.___", state 753, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 415, "pan.___", state 755, "(1)" + line 415, "pan.___", state 756, "((cache_dirty_rcu_data[i].bitfield&(1<<_pid)))" + line 415, "pan.___", state 756, "else" + line 415, "pan.___", state 759, "(1)" + line 415, "pan.___", state 760, "(1)" + line 415, "pan.___", state 760, "(1)" + line 413, "pan.___", state 765, "((i<2))" + line 413, "pan.___", state 765, "((i>=2))" + line 240, "pan.___", state 771, "(1)" + line 244, "pan.___", state 779, "(1)" + line 244, "pan.___", state 780, "(!((cache_dirty_urcu_active_readers.bitfield&(1<<_pid))))" + line 244, "pan.___", state 780, "else" + line 242, "pan.___", state 785, "((i<1))" + line 242, "pan.___", state 785, "((i>=1))" + line 248, "pan.___", state 791, "(1)" + line 248, "pan.___", state 792, "(!((cache_dirty_rcu_ptr.bitfield&(1<<_pid))))" + line 248, "pan.___", state 792, "else" + line 252, "pan.___", state 799, "(1)" + line 252, "pan.___", state 800, "(!((cache_dirty_rcu_data[i].bitfield&(1<<_pid))))" + line 252, "pan.___", state 800, "else" + line 257, "pan.___", state 809, "(!((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid))))" + line 257, "pan.___", state 809, "else" + line 422, "pan.___", state 811, "(1)" + line 422, "pan.___", state 811, "(1)" + line 402, "pan.___", state 818, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 402, "pan.___", state 820, "(1)" + line 402, "pan.___", state 821, "((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid)))" + line 402, "pan.___", state 821, "else" + line 402, "pan.___", state 824, "(1)" + line 406, "pan.___", state 832, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 406, "pan.___", state 834, "(1)" + line 406, "pan.___", state 835, "((cache_dirty_urcu_active_readers.bitfield&(1<<_pid)))" + line 406, "pan.___", state 835, "else" + line 406, "pan.___", state 838, "(1)" + line 406, "pan.___", state 839, "(1)" + line 406, "pan.___", state 839, "(1)" + line 404, "pan.___", state 844, "((i<1))" + line 404, "pan.___", state 844, "((i>=1))" + line 411, "pan.___", state 850, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 411, "pan.___", state 852, "(1)" + line 411, "pan.___", state 853, "((cache_dirty_rcu_ptr.bitfield&(1<<_pid)))" + line 411, "pan.___", state 853, "else" + line 411, "pan.___", state 856, "(1)" + line 411, "pan.___", state 857, "(1)" + line 411, "pan.___", state 857, "(1)" + line 415, "pan.___", state 864, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 415, "pan.___", state 866, "(1)" + line 415, "pan.___", state 867, "((cache_dirty_rcu_data[i].bitfield&(1<<_pid)))" + line 415, "pan.___", state 867, "else" + line 415, "pan.___", state 870, "(1)" + line 415, "pan.___", state 871, "(1)" + line 415, "pan.___", state 871, "(1)" + line 413, "pan.___", state 876, "((i<2))" + line 413, "pan.___", state 876, "((i>=2))" + line 240, "pan.___", state 882, "(1)" + line 244, "pan.___", state 890, "(1)" + line 244, "pan.___", state 891, "(!((cache_dirty_urcu_active_readers.bitfield&(1<<_pid))))" + line 244, "pan.___", state 891, "else" + line 242, "pan.___", state 896, "((i<1))" + line 242, "pan.___", state 896, "((i>=1))" + line 248, "pan.___", state 902, "(1)" + line 248, "pan.___", state 903, "(!((cache_dirty_rcu_ptr.bitfield&(1<<_pid))))" + line 248, "pan.___", state 903, "else" + line 252, "pan.___", state 910, "(1)" + line 252, "pan.___", state 911, "(!((cache_dirty_rcu_data[i].bitfield&(1<<_pid))))" + line 252, "pan.___", state 911, "else" + line 250, "pan.___", state 916, "((i<2))" + line 250, "pan.___", state 916, "((i>=2))" + line 257, "pan.___", state 920, "(!((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid))))" + line 257, "pan.___", state 920, "else" + line 422, "pan.___", state 922, "(1)" + line 422, "pan.___", state 922, "(1)" + line 689, "pan.___", state 926, "_proc_urcu_reader = (_proc_urcu_reader|(1<<11))" + line 402, "pan.___", state 931, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 411, "pan.___", state 963, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 415, "pan.___", state 977, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 240, "pan.___", state 995, "(1)" + line 248, "pan.___", state 1015, "(1)" + line 252, "pan.___", state 1023, "(1)" + line 402, "pan.___", state 1045, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 411, "pan.___", state 1077, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 415, "pan.___", state 1091, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 240, "pan.___", state 1109, "(1)" + line 248, "pan.___", state 1129, "(1)" + line 252, "pan.___", state 1137, "(1)" + line 402, "pan.___", state 1160, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 411, "pan.___", state 1192, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 415, "pan.___", state 1206, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 240, "pan.___", state 1224, "(1)" + line 248, "pan.___", state 1244, "(1)" + line 252, "pan.___", state 1252, "(1)" + line 402, "pan.___", state 1271, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 411, "pan.___", state 1303, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 415, "pan.___", state 1317, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 240, "pan.___", state 1335, "(1)" + line 248, "pan.___", state 1355, "(1)" + line 252, "pan.___", state 1363, "(1)" + line 402, "pan.___", state 1387, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 411, "pan.___", state 1419, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 415, "pan.___", state 1433, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 240, "pan.___", state 1451, "(1)" + line 248, "pan.___", state 1471, "(1)" + line 252, "pan.___", state 1479, "(1)" + line 402, "pan.___", state 1498, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 411, "pan.___", state 1530, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 415, "pan.___", state 1544, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 240, "pan.___", state 1562, "(1)" + line 248, "pan.___", state 1582, "(1)" + line 252, "pan.___", state 1590, "(1)" + line 402, "pan.___", state 1612, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 411, "pan.___", state 1644, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 415, "pan.___", state 1658, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 240, "pan.___", state 1676, "(1)" + line 248, "pan.___", state 1696, "(1)" + line 252, "pan.___", state 1704, "(1)" + line 728, "pan.___", state 1723, "_proc_urcu_reader = (_proc_urcu_reader|((1<<2)<<19))" + line 402, "pan.___", state 1730, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 411, "pan.___", state 1762, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 415, "pan.___", state 1776, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 240, "pan.___", state 1794, "(1)" + line 248, "pan.___", state 1814, "(1)" + line 252, "pan.___", state 1822, "(1)" + line 402, "pan.___", state 1841, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 411, "pan.___", state 1873, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 415, "pan.___", state 1887, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 240, "pan.___", state 1905, "(1)" + line 248, "pan.___", state 1925, "(1)" + line 252, "pan.___", state 1933, "(1)" + line 402, "pan.___", state 1954, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 402, "pan.___", state 1956, "(1)" + line 402, "pan.___", state 1957, "((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid)))" + line 402, "pan.___", state 1957, "else" + line 402, "pan.___", state 1960, "(1)" + line 406, "pan.___", state 1968, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 406, "pan.___", state 1970, "(1)" + line 406, "pan.___", state 1971, "((cache_dirty_urcu_active_readers.bitfield&(1<<_pid)))" + line 406, "pan.___", state 1971, "else" + line 406, "pan.___", state 1974, "(1)" + line 406, "pan.___", state 1975, "(1)" + line 406, "pan.___", state 1975, "(1)" + line 404, "pan.___", state 1980, "((i<1))" + line 404, "pan.___", state 1980, "((i>=1))" + line 411, "pan.___", state 1986, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 411, "pan.___", state 1988, "(1)" + line 411, "pan.___", state 1989, "((cache_dirty_rcu_ptr.bitfield&(1<<_pid)))" + line 411, "pan.___", state 1989, "else" + line 411, "pan.___", state 1992, "(1)" + line 411, "pan.___", state 1993, "(1)" + line 411, "pan.___", state 1993, "(1)" + line 415, "pan.___", state 2000, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 415, "pan.___", state 2002, "(1)" + line 415, "pan.___", state 2003, "((cache_dirty_rcu_data[i].bitfield&(1<<_pid)))" + line 415, "pan.___", state 2003, "else" + line 415, "pan.___", state 2006, "(1)" + line 415, "pan.___", state 2007, "(1)" + line 415, "pan.___", state 2007, "(1)" + line 413, "pan.___", state 2012, "((i<2))" + line 413, "pan.___", state 2012, "((i>=2))" + line 240, "pan.___", state 2018, "(1)" + line 244, "pan.___", state 2026, "(1)" + line 244, "pan.___", state 2027, "(!((cache_dirty_urcu_active_readers.bitfield&(1<<_pid))))" + line 244, "pan.___", state 2027, "else" + line 242, "pan.___", state 2032, "((i<1))" + line 242, "pan.___", state 2032, "((i>=1))" + line 248, "pan.___", state 2038, "(1)" + line 248, "pan.___", state 2039, "(!((cache_dirty_rcu_ptr.bitfield&(1<<_pid))))" + line 248, "pan.___", state 2039, "else" + line 252, "pan.___", state 2046, "(1)" + line 252, "pan.___", state 2047, "(!((cache_dirty_rcu_data[i].bitfield&(1<<_pid))))" + line 252, "pan.___", state 2047, "else" + line 250, "pan.___", state 2052, "((i<2))" + line 250, "pan.___", state 2052, "((i>=2))" + line 257, "pan.___", state 2056, "(!((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid))))" + line 257, "pan.___", state 2056, "else" + line 422, "pan.___", state 2058, "(1)" + line 422, "pan.___", state 2058, "(1)" + line 728, "pan.___", state 2061, "cached_urcu_active_readers.val[_pid] = (tmp+1)" + line 728, "pan.___", state 2062, "_proc_urcu_reader = (_proc_urcu_reader|(1<<23))" + line 728, "pan.___", state 2063, "(1)" + line 402, "pan.___", state 2070, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 411, "pan.___", state 2102, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 415, "pan.___", state 2116, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 240, "pan.___", state 2134, "(1)" + line 248, "pan.___", state 2154, "(1)" + line 252, "pan.___", state 2162, "(1)" + line 402, "pan.___", state 2187, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 411, "pan.___", state 2219, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 415, "pan.___", state 2233, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 240, "pan.___", state 2251, "(1)" + line 248, "pan.___", state 2271, "(1)" + line 252, "pan.___", state 2279, "(1)" + line 402, "pan.___", state 2298, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 411, "pan.___", state 2330, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 415, "pan.___", state 2344, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 240, "pan.___", state 2362, "(1)" + line 248, "pan.___", state 2382, "(1)" + line 252, "pan.___", state 2390, "(1)" + line 240, "pan.___", state 2421, "(1)" + line 248, "pan.___", state 2441, "(1)" + line 252, "pan.___", state 2449, "(1)" + line 240, "pan.___", state 2464, "(1)" + line 248, "pan.___", state 2484, "(1)" + line 252, "pan.___", state 2492, "(1)" + line 888, "pan.___", state 2509, "-end-" + (246 of 2509 states) +unreached in proctype urcu_writer + line 402, "pan.___", state 18, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 406, "pan.___", state 32, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 411, "pan.___", state 50, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 240, "pan.___", state 82, "(1)" + line 244, "pan.___", state 90, "(1)" + line 248, "pan.___", state 102, "(1)" + line 263, "pan.___", state 131, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 267, "pan.___", state 140, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 271, "pan.___", state 153, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 402, "pan.___", state 193, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 406, "pan.___", state 207, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 411, "pan.___", state 225, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 415, "pan.___", state 239, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 240, "pan.___", state 257, "(1)" + line 244, "pan.___", state 265, "(1)" + line 248, "pan.___", state 277, "(1)" + line 252, "pan.___", state 285, "(1)" + line 406, "pan.___", state 320, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 411, "pan.___", state 338, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 415, "pan.___", state 352, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 244, "pan.___", state 378, "(1)" + line 248, "pan.___", state 390, "(1)" + line 252, "pan.___", state 398, "(1)" + line 402, "pan.___", state 423, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 402, "pan.___", state 425, "(1)" + line 402, "pan.___", state 426, "((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid)))" + line 402, "pan.___", state 426, "else" + line 402, "pan.___", state 429, "(1)" + line 406, "pan.___", state 437, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 406, "pan.___", state 439, "(1)" + line 406, "pan.___", state 440, "((cache_dirty_urcu_active_readers.bitfield&(1<<_pid)))" + line 406, "pan.___", state 440, "else" + line 406, "pan.___", state 443, "(1)" + line 406, "pan.___", state 444, "(1)" + line 406, "pan.___", state 444, "(1)" + line 404, "pan.___", state 449, "((i<1))" + line 404, "pan.___", state 449, "((i>=1))" + line 411, "pan.___", state 455, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 411, "pan.___", state 457, "(1)" + line 411, "pan.___", state 458, "((cache_dirty_rcu_ptr.bitfield&(1<<_pid)))" + line 411, "pan.___", state 458, "else" + line 411, "pan.___", state 461, "(1)" + line 411, "pan.___", state 462, "(1)" + line 411, "pan.___", state 462, "(1)" + line 415, "pan.___", state 469, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 415, "pan.___", state 471, "(1)" + line 415, "pan.___", state 472, "((cache_dirty_rcu_data[i].bitfield&(1<<_pid)))" + line 415, "pan.___", state 472, "else" + line 415, "pan.___", state 475, "(1)" + line 415, "pan.___", state 476, "(1)" + line 415, "pan.___", state 476, "(1)" + line 413, "pan.___", state 481, "((i<2))" + line 413, "pan.___", state 481, "((i>=2))" + line 240, "pan.___", state 487, "(1)" + line 244, "pan.___", state 495, "(1)" + line 244, "pan.___", state 496, "(!((cache_dirty_urcu_active_readers.bitfield&(1<<_pid))))" + line 244, "pan.___", state 496, "else" + line 242, "pan.___", state 501, "((i<1))" + line 242, "pan.___", state 501, "((i>=1))" + line 248, "pan.___", state 507, "(1)" + line 248, "pan.___", state 508, "(!((cache_dirty_rcu_ptr.bitfield&(1<<_pid))))" + line 248, "pan.___", state 508, "else" + line 252, "pan.___", state 515, "(1)" + line 252, "pan.___", state 516, "(!((cache_dirty_rcu_data[i].bitfield&(1<<_pid))))" + line 252, "pan.___", state 516, "else" + line 257, "pan.___", state 525, "(!((cache_dirty_urcu_gp_ctr.bitfield&(1<<_pid))))" + line 257, "pan.___", state 525, "else" + line 422, "pan.___", state 527, "(1)" + line 422, "pan.___", state 527, "(1)" + line 406, "pan.___", state 547, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 411, "pan.___", state 565, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 415, "pan.___", state 579, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 244, "pan.___", state 605, "(1)" + line 248, "pan.___", state 617, "(1)" + line 252, "pan.___", state 625, "(1)" + line 406, "pan.___", state 658, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 411, "pan.___", state 676, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 415, "pan.___", state 690, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 244, "pan.___", state 716, "(1)" + line 248, "pan.___", state 728, "(1)" + line 252, "pan.___", state 736, "(1)" + line 406, "pan.___", state 771, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 411, "pan.___", state 789, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 415, "pan.___", state 803, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 244, "pan.___", state 829, "(1)" + line 248, "pan.___", state 841, "(1)" + line 252, "pan.___", state 849, "(1)" + line 406, "pan.___", state 887, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 411, "pan.___", state 905, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 415, "pan.___", state 919, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 244, "pan.___", state 945, "(1)" + line 248, "pan.___", state 957, "(1)" + line 252, "pan.___", state 965, "(1)" + line 263, "pan.___", state 1009, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 267, "pan.___", state 1018, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 271, "pan.___", state 1033, "(1)" + line 275, "pan.___", state 1040, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 240, "pan.___", state 1056, "(1)" + line 244, "pan.___", state 1064, "(1)" + line 248, "pan.___", state 1076, "(1)" + line 252, "pan.___", state 1084, "(1)" + line 263, "pan.___", state 1115, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 267, "pan.___", state 1124, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 271, "pan.___", state 1137, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 275, "pan.___", state 1146, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 240, "pan.___", state 1162, "(1)" + line 244, "pan.___", state 1170, "(1)" + line 248, "pan.___", state 1182, "(1)" + line 252, "pan.___", state 1190, "(1)" + line 267, "pan.___", state 1216, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 271, "pan.___", state 1229, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 275, "pan.___", state 1238, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 240, "pan.___", state 1254, "(1)" + line 244, "pan.___", state 1262, "(1)" + line 248, "pan.___", state 1274, "(1)" + line 252, "pan.___", state 1282, "(1)" + line 263, "pan.___", state 1313, "cache_dirty_urcu_gp_ctr.bitfield = (cache_dirty_urcu_gp_ctr.bitfield&~((1<<_pid)))" + line 267, "pan.___", state 1322, "cache_dirty_urcu_active_readers.bitfield = (cache_dirty_urcu_active_readers.bitfield&~((1<<_pid)))" + line 271, "pan.___", state 1335, "cache_dirty_rcu_ptr.bitfield = (cache_dirty_rcu_ptr.bitfield&~((1<<_pid)))" + line 275, "pan.___", state 1344, "cache_dirty_rcu_data[i].bitfield = (cache_dirty_rcu_data[i].bitfield&~((1<<_pid)))" + line 240, "pan.___", state 1360, "(1)" + line 244, "pan.___", state 1368, "(1)" + line 248, "pan.___", state 1380, "(1)" + line 252, "pan.___", state 1388, "(1)" + line 1215, "pan.___", state 1404, "-end-" + (110 of 1404 states) +unreached in proctype :init: + (0 of 78 states) +unreached in proctype :never: + line 1280, "pan.___", state 11, "-end-" + (1 of 11 states) + +pan: elapsed time 14.8 seconds +pan: rate 49695.746 states/second +pan: avg transition delay 2.5365e-06 usec +cp .input.spin urcu_progress_writer_error.spin.input +cp .input.spin.trail urcu_progress_writer_error.spin.input.trail +make[1]: Leaving directory `/home/compudj/doc/userspace-rcu/formal-model/urcu-controldataflow' diff --git a/formal-model/results/urcu-controldataflow-ipi-intel/urcu_progress_writer_error.spin.input b/formal-model/results/urcu-controldataflow-ipi-intel/urcu_progress_writer_error.spin.input new file mode 100644 index 0000000..7161faf --- /dev/null +++ b/formal-model/results/urcu-controldataflow-ipi-intel/urcu_progress_writer_error.spin.input @@ -0,0 +1,1251 @@ +#define WRITER_PROGRESS +#define GEN_ERROR_WRITER_PROGRESS + +// Poison value for freed memory +#define POISON 1 +// Memory with correct data +#define WINE 0 +#define SLAB_SIZE 2 + +#define read_poison (data_read_first[0] == POISON || data_read_second[0] == POISON) + +#define RCU_GP_CTR_BIT (1 << 7) +#define RCU_GP_CTR_NEST_MASK (RCU_GP_CTR_BIT - 1) + +//disabled +#define REMOTE_BARRIERS + +//#define ARCH_ALPHA +#define ARCH_INTEL +//#define ARCH_POWERPC +/* + * mem.spin: Promela code to validate memory barriers with OOO memory + * and out-of-order instruction scheduling. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * Copyright (c) 2009 Mathieu Desnoyers + */ + +/* Promela validation variables. */ + +/* specific defines "included" here */ +/* DEFINES file "included" here */ + +#define NR_READERS 1 +#define NR_WRITERS 1 + +#define NR_PROCS 2 + +#define get_pid() (_pid) + +#define get_readerid() (get_pid()) + +/* + * Produced process control and data flow. Updated after each instruction to + * show which variables are ready. Using one-hot bit encoding per variable to + * save state space. Used as triggers to execute the instructions having those + * variables as input. Leaving bits active to inhibit instruction execution. + * Scheme used to make instruction disabling and automatic dependency fall-back + * automatic. + */ + +#define CONSUME_TOKENS(state, bits, notbits) \ + ((!(state & (notbits))) && (state & (bits)) == (bits)) + +#define PRODUCE_TOKENS(state, bits) \ + state = state | (bits); + +#define CLEAR_TOKENS(state, bits) \ + state = state & ~(bits) + +/* + * Types of dependency : + * + * Data dependency + * + * - True dependency, Read-after-Write (RAW) + * + * This type of dependency happens when a statement depends on the result of a + * previous statement. This applies to any statement which needs to read a + * variable written by a preceding statement. + * + * - False dependency, Write-after-Read (WAR) + * + * Typically, variable renaming can ensure that this dependency goes away. + * However, if the statements must read and then write from/to the same variable + * in the OOO memory model, renaming may be impossible, and therefore this + * causes a WAR dependency. + * + * - Output dependency, Write-after-Write (WAW) + * + * Two writes to the same variable in subsequent statements. Variable renaming + * can ensure this is not needed, but can be required when writing multiple + * times to the same OOO mem model variable. + * + * Control dependency + * + * Execution of a given instruction depends on a previous instruction evaluating + * in a way that allows its execution. E.g. : branches. + * + * Useful considerations for joining dependencies after branch + * + * - Pre-dominance + * + * "We say box i dominates box j if every path (leading from input to output + * through the diagram) which passes through box j must also pass through box + * i. Thus box i dominates box j if box j is subordinate to box i in the + * program." + * + * http://www.hipersoft.rice.edu/grads/publications/dom14.pdf + * Other classic algorithm to calculate dominance : Lengauer-Tarjan (in gcc) + * + * - Post-dominance + * + * Just as pre-dominance, but with arcs of the data flow inverted, and input vs + * output exchanged. Therefore, i post-dominating j ensures that every path + * passing by j will pass by i before reaching the output. + * + * Other considerations + * + * Note about "volatile" keyword dependency : The compiler will order volatile + * accesses so they appear in the right order on a given CPU. They can be + * reordered by the CPU instruction scheduling. This therefore cannot be + * considered as a depencency. + * + * References : + * + * Cooper, Keith D.; & Torczon, Linda. (2005). Engineering a Compiler. Morgan + * Kaufmann. ISBN 1-55860-698-X. + * Kennedy, Ken; & Allen, Randy. (2001). Optimizing Compilers for Modern + * Architectures: A Dependence-based Approach. Morgan Kaufmann. ISBN + * 1-55860-286-0. + * Muchnick, Steven S. (1997). Advanced Compiler Design and Implementation. + * Morgan Kaufmann. ISBN 1-55860-320-4. + */ + +/* + * Note about loops and nested calls + * + * To keep this model simple, loops expressed in the framework will behave as if + * there was a core synchronizing instruction between loops. To see the effect + * of loop unrolling, manually unrolling loops is required. Note that if loops + * end or start with a core synchronizing instruction, the model is appropriate. + * Nested calls are not supported. + */ + +/* + * Only Alpha has out-of-order cache bank loads. Other architectures (intel, + * powerpc, arm) ensure that dependent reads won't be reordered. c.f. + * http://www.linuxjournal.com/article/8212) +#ifdef ARCH_ALPHA +#define HAVE_OOO_CACHE_READ +#endif + +/* + * Each process have its own data in cache. Caches are randomly updated. + * smp_wmb and smp_rmb forces cache updates (write and read), smp_mb forces + * both. + */ + +typedef per_proc_byte { + byte val[NR_PROCS]; +}; + +typedef per_proc_bit { + bit val[NR_PROCS]; +}; + +/* Bitfield has a maximum of 8 procs */ +typedef per_proc_bitfield { + byte bitfield; +}; + +#define DECLARE_CACHED_VAR(type, x) \ + type mem_##x; \ + per_proc_##type cached_##x; \ + per_proc_bitfield cache_dirty_##x; + +#define INIT_CACHED_VAR(x, v, j) \ + mem_##x = v; \ + cache_dirty_##x.bitfield = 0; \ + j = 0; \ + do \ + :: j < NR_PROCS -> \ + cached_##x.val[j] = v; \ + j++ \ + :: j >= NR_PROCS -> break \ + od; + +#define IS_CACHE_DIRTY(x, id) (cache_dirty_##x.bitfield & (1 << id)) + +#define READ_CACHED_VAR(x) (cached_##x.val[get_pid()]) + +#define WRITE_CACHED_VAR(x, v) \ + atomic { \ + cached_##x.val[get_pid()] = v; \ + cache_dirty_##x.bitfield = \ + cache_dirty_##x.bitfield | (1 << get_pid()); \ + } + +#define CACHE_WRITE_TO_MEM(x, id) \ + if \ + :: IS_CACHE_DIRTY(x, id) -> \ + mem_##x = cached_##x.val[id]; \ + cache_dirty_##x.bitfield = \ + cache_dirty_##x.bitfield & (~(1 << id)); \ + :: else -> \ + skip \ + fi; + +#define CACHE_READ_FROM_MEM(x, id) \ + if \ + :: !IS_CACHE_DIRTY(x, id) -> \ + cached_##x.val[id] = mem_##x;\ + :: else -> \ + skip \ + fi; + +/* + * May update other caches if cache is dirty, or not. + */ +#define RANDOM_CACHE_WRITE_TO_MEM(x, id)\ + if \ + :: 1 -> CACHE_WRITE_TO_MEM(x, id); \ + :: 1 -> skip \ + fi; + +#define RANDOM_CACHE_READ_FROM_MEM(x, id)\ + if \ + :: 1 -> CACHE_READ_FROM_MEM(x, id); \ + :: 1 -> skip \ + fi; + +/* Must consume all prior read tokens. All subsequent reads depend on it. */ +inline smp_rmb(i) +{ + atomic { + CACHE_READ_FROM_MEM(urcu_gp_ctr, get_pid()); + i = 0; + do + :: i < NR_READERS -> + CACHE_READ_FROM_MEM(urcu_active_readers[i], get_pid()); + i++ + :: i >= NR_READERS -> break + od; + CACHE_READ_FROM_MEM(rcu_ptr, get_pid()); + i = 0; + do + :: i < SLAB_SIZE -> + CACHE_READ_FROM_MEM(rcu_data[i], get_pid()); + i++ + :: i >= SLAB_SIZE -> break + od; + } +} + +/* Must consume all prior write tokens. All subsequent writes depend on it. */ +inline smp_wmb(i) +{ + atomic { + CACHE_WRITE_TO_MEM(urcu_gp_ctr, get_pid()); + i = 0; + do + :: i < NR_READERS -> + CACHE_WRITE_TO_MEM(urcu_active_readers[i], get_pid()); + i++ + :: i >= NR_READERS -> break + od; + CACHE_WRITE_TO_MEM(rcu_ptr, get_pid()); + i = 0; + do + :: i < SLAB_SIZE -> + CACHE_WRITE_TO_MEM(rcu_data[i], get_pid()); + i++ + :: i >= SLAB_SIZE -> break + od; + } +} + +/* Synchronization point. Must consume all prior read and write tokens. All + * subsequent reads and writes depend on it. */ +inline smp_mb(i) +{ + atomic { + smp_wmb(i); + smp_rmb(i); + } +} + +#ifdef REMOTE_BARRIERS + +bit reader_barrier[NR_READERS]; + +/* + * We cannot leave the barriers dependencies in place in REMOTE_BARRIERS mode + * because they would add unexisting core synchronization and would therefore + * create an incomplete model. + * Therefore, we model the read-side memory barriers by completely disabling the + * memory barriers and their dependencies from the read-side. One at a time + * (different verification runs), we make a different instruction listen for + * signals. + */ + +#define smp_mb_reader(i, j) + +/* + * Service 0, 1 or many barrier requests. + */ +inline smp_mb_recv(i, j) +{ + do + :: (reader_barrier[get_readerid()] == 1) -> + /* + * We choose to ignore cycles caused by writer busy-looping, + * waiting for the reader, sending barrier requests, and the + * reader always services them without continuing execution. + */ +progress_ignoring_mb1: + smp_mb(i); + reader_barrier[get_readerid()] = 0; + :: 1 -> + /* + * We choose to ignore writer's non-progress caused by the + * reader ignoring the writer's mb() requests. + */ +progress_ignoring_mb2: + break; + od; +} + +#define PROGRESS_LABEL(progressid) progress_writer_progid_##progressid: + +#define smp_mb_send(i, j, progressid) \ +{ \ + smp_mb(i); \ + i = 0; \ + do \ + :: i < NR_READERS -> \ + reader_barrier[i] = 1; \ + /* \ + * Busy-looping waiting for reader barrier handling is of little\ + * interest, given the reader has the ability to totally ignore \ + * barrier requests. \ + */ \ + do \ + :: (reader_barrier[i] == 1) -> \ +PROGRESS_LABEL(progressid) \ + skip; \ + :: (reader_barrier[i] == 0) -> break; \ + od; \ + i++; \ + :: i >= NR_READERS -> \ + break \ + od; \ + smp_mb(i); \ +} + +#else + +#define smp_mb_send(i, j, progressid) smp_mb(i) +#define smp_mb_reader smp_mb(i) +#define smp_mb_recv(i, j) + +#endif + +/* Keep in sync manually with smp_rmb, smp_wmb, ooo_mem and init() */ +DECLARE_CACHED_VAR(byte, urcu_gp_ctr); +/* Note ! currently only one reader */ +DECLARE_CACHED_VAR(byte, urcu_active_readers[NR_READERS]); +/* RCU data */ +DECLARE_CACHED_VAR(bit, rcu_data[SLAB_SIZE]); + +/* RCU pointer */ +#if (SLAB_SIZE == 2) +DECLARE_CACHED_VAR(bit, rcu_ptr); +bit ptr_read_first[NR_READERS]; +bit ptr_read_second[NR_READERS]; +#else +DECLARE_CACHED_VAR(byte, rcu_ptr); +byte ptr_read_first[NR_READERS]; +byte ptr_read_second[NR_READERS]; +#endif + +bit data_read_first[NR_READERS]; +bit data_read_second[NR_READERS]; + +bit init_done = 0; + +inline wait_init_done() +{ + do + :: init_done == 0 -> skip; + :: else -> break; + od; +} + +inline ooo_mem(i) +{ + atomic { + RANDOM_CACHE_WRITE_TO_MEM(urcu_gp_ctr, get_pid()); + i = 0; + do + :: i < NR_READERS -> + RANDOM_CACHE_WRITE_TO_MEM(urcu_active_readers[i], + get_pid()); + i++ + :: i >= NR_READERS -> break + od; + RANDOM_CACHE_WRITE_TO_MEM(rcu_ptr, get_pid()); + i = 0; + do + :: i < SLAB_SIZE -> + RANDOM_CACHE_WRITE_TO_MEM(rcu_data[i], get_pid()); + i++ + :: i >= SLAB_SIZE -> break + od; +#ifdef HAVE_OOO_CACHE_READ + RANDOM_CACHE_READ_FROM_MEM(urcu_gp_ctr, get_pid()); + i = 0; + do + :: i < NR_READERS -> + RANDOM_CACHE_READ_FROM_MEM(urcu_active_readers[i], + get_pid()); + i++ + :: i >= NR_READERS -> break + od; + RANDOM_CACHE_READ_FROM_MEM(rcu_ptr, get_pid()); + i = 0; + do + :: i < SLAB_SIZE -> + RANDOM_CACHE_READ_FROM_MEM(rcu_data[i], get_pid()); + i++ + :: i >= SLAB_SIZE -> break + od; +#else + smp_rmb(i); +#endif /* HAVE_OOO_CACHE_READ */ + } +} + +/* + * Bit encoding, urcu_reader : + */ + +int _proc_urcu_reader; +#define proc_urcu_reader _proc_urcu_reader + +/* Body of PROCEDURE_READ_LOCK */ +#define READ_PROD_A_READ (1 << 0) +#define READ_PROD_B_IF_TRUE (1 << 1) +#define READ_PROD_B_IF_FALSE (1 << 2) +#define READ_PROD_C_IF_TRUE_READ (1 << 3) + +#define PROCEDURE_READ_LOCK(base, consumetoken, producetoken) \ + :: CONSUME_TOKENS(proc_urcu_reader, consumetoken, READ_PROD_A_READ << base) -> \ + ooo_mem(i); \ + tmp = READ_CACHED_VAR(urcu_active_readers[get_readerid()]); \ + PRODUCE_TOKENS(proc_urcu_reader, READ_PROD_A_READ << base); \ + :: CONSUME_TOKENS(proc_urcu_reader, \ + READ_PROD_A_READ << base, /* RAW, pre-dominant */ \ + (READ_PROD_B_IF_TRUE | READ_PROD_B_IF_FALSE) << base) -> \ + if \ + :: (!(tmp & RCU_GP_CTR_NEST_MASK)) -> \ + PRODUCE_TOKENS(proc_urcu_reader, READ_PROD_B_IF_TRUE << base); \ + :: else -> \ + PRODUCE_TOKENS(proc_urcu_reader, READ_PROD_B_IF_FALSE << base); \ + fi; \ + /* IF TRUE */ \ + :: CONSUME_TOKENS(proc_urcu_reader, READ_PROD_B_IF_TRUE << base, \ + READ_PROD_C_IF_TRUE_READ << base) -> \ + ooo_mem(i); \ + tmp2 = READ_CACHED_VAR(urcu_gp_ctr); \ + PRODUCE_TOKENS(proc_urcu_reader, READ_PROD_C_IF_TRUE_READ << base); \ + :: CONSUME_TOKENS(proc_urcu_reader, \ + (READ_PROD_C_IF_TRUE_READ /* pre-dominant */ \ + | READ_PROD_A_READ) << base, /* WAR */ \ + producetoken) -> \ + ooo_mem(i); \ + WRITE_CACHED_VAR(urcu_active_readers[get_readerid()], tmp2); \ + PRODUCE_TOKENS(proc_urcu_reader, producetoken); \ + /* IF_MERGE implies \ + * post-dominance */ \ + /* ELSE */ \ + :: CONSUME_TOKENS(proc_urcu_reader, \ + (READ_PROD_B_IF_FALSE /* pre-dominant */ \ + | READ_PROD_A_READ) << base, /* WAR */ \ + producetoken) -> \ + ooo_mem(i); \ + WRITE_CACHED_VAR(urcu_active_readers[get_readerid()], \ + tmp + 1); \ + PRODUCE_TOKENS(proc_urcu_reader, producetoken); \ + /* IF_MERGE implies \ + * post-dominance */ \ + /* ENDIF */ \ + skip + +/* Body of PROCEDURE_READ_LOCK */ +#define READ_PROC_READ_UNLOCK (1 << 0) + +#define PROCEDURE_READ_UNLOCK(base, consumetoken, producetoken) \ + :: CONSUME_TOKENS(proc_urcu_reader, \ + consumetoken, \ + READ_PROC_READ_UNLOCK << base) -> \ + ooo_mem(i); \ + tmp2 = READ_CACHED_VAR(urcu_active_readers[get_readerid()]); \ + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_READ_UNLOCK << base); \ + :: CONSUME_TOKENS(proc_urcu_reader, \ + consumetoken \ + | (READ_PROC_READ_UNLOCK << base), /* WAR */ \ + producetoken) -> \ + ooo_mem(i); \ + WRITE_CACHED_VAR(urcu_active_readers[get_readerid()], tmp2 - 1); \ + PRODUCE_TOKENS(proc_urcu_reader, producetoken); \ + skip + + +#define READ_PROD_NONE (1 << 0) + +/* PROCEDURE_READ_LOCK base = << 1 : 1 to 5 */ +#define READ_LOCK_BASE 1 +#define READ_LOCK_OUT (1 << 5) + +#define READ_PROC_FIRST_MB (1 << 6) + +/* PROCEDURE_READ_LOCK (NESTED) base : << 7 : 7 to 11 */ +#define READ_LOCK_NESTED_BASE 7 +#define READ_LOCK_NESTED_OUT (1 << 11) + +#define READ_PROC_READ_GEN (1 << 12) +#define READ_PROC_ACCESS_GEN (1 << 13) + +/* PROCEDURE_READ_UNLOCK (NESTED) base = << 14 : 14 to 15 */ +#define READ_UNLOCK_NESTED_BASE 14 +#define READ_UNLOCK_NESTED_OUT (1 << 15) + +#define READ_PROC_SECOND_MB (1 << 16) + +/* PROCEDURE_READ_UNLOCK base = << 17 : 17 to 18 */ +#define READ_UNLOCK_BASE 17 +#define READ_UNLOCK_OUT (1 << 18) + +/* PROCEDURE_READ_LOCK_UNROLL base = << 19 : 19 to 23 */ +#define READ_LOCK_UNROLL_BASE 19 +#define READ_LOCK_OUT_UNROLL (1 << 23) + +#define READ_PROC_THIRD_MB (1 << 24) + +#define READ_PROC_READ_GEN_UNROLL (1 << 25) +#define READ_PROC_ACCESS_GEN_UNROLL (1 << 26) + +#define READ_PROC_FOURTH_MB (1 << 27) + +/* PROCEDURE_READ_UNLOCK_UNROLL base = << 28 : 28 to 29 */ +#define READ_UNLOCK_UNROLL_BASE 28 +#define READ_UNLOCK_OUT_UNROLL (1 << 29) + + +/* Should not include branches */ +#define READ_PROC_ALL_TOKENS (READ_PROD_NONE \ + | READ_LOCK_OUT \ + | READ_PROC_FIRST_MB \ + | READ_LOCK_NESTED_OUT \ + | READ_PROC_READ_GEN \ + | READ_PROC_ACCESS_GEN \ + | READ_UNLOCK_NESTED_OUT \ + | READ_PROC_SECOND_MB \ + | READ_UNLOCK_OUT \ + | READ_LOCK_OUT_UNROLL \ + | READ_PROC_THIRD_MB \ + | READ_PROC_READ_GEN_UNROLL \ + | READ_PROC_ACCESS_GEN_UNROLL \ + | READ_PROC_FOURTH_MB \ + | READ_UNLOCK_OUT_UNROLL) + +/* Must clear all tokens, including branches */ +#define READ_PROC_ALL_TOKENS_CLEAR ((1 << 30) - 1) + +inline urcu_one_read(i, j, nest_i, tmp, tmp2) +{ + PRODUCE_TOKENS(proc_urcu_reader, READ_PROD_NONE); + +#ifdef NO_MB + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_FIRST_MB); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_SECOND_MB); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_THIRD_MB); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_FOURTH_MB); +#endif + +#ifdef REMOTE_BARRIERS + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_FIRST_MB); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_SECOND_MB); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_THIRD_MB); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_FOURTH_MB); +#endif + + do + :: 1 -> + +#ifdef REMOTE_BARRIERS + /* + * Signal-based memory barrier will only execute when the + * execution order appears in program order. + */ + if + :: 1 -> + atomic { + if + :: CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE, + READ_LOCK_OUT | READ_LOCK_NESTED_OUT + | READ_PROC_READ_GEN | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT + | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT, + READ_LOCK_NESTED_OUT + | READ_PROC_READ_GEN | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT + | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT | READ_LOCK_NESTED_OUT, + READ_PROC_READ_GEN | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT + | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN, + READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT + | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN | READ_PROC_ACCESS_GEN, + READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT + | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN + | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT, + READ_UNLOCK_OUT + | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN + | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT, + READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN + | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT | READ_LOCK_OUT_UNROLL, + READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN + | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL, + READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN + | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL, + READ_UNLOCK_OUT_UNROLL) + || CONSUME_TOKENS(proc_urcu_reader, READ_PROD_NONE | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT | READ_PROC_READ_GEN | READ_PROC_ACCESS_GEN | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT | READ_LOCK_OUT_UNROLL + | READ_PROC_READ_GEN_UNROLL | READ_PROC_ACCESS_GEN_UNROLL | READ_UNLOCK_OUT_UNROLL, + 0) -> + goto non_atomic3; +non_atomic3_end: + skip; + fi; + } + fi; + + goto non_atomic3_skip; +non_atomic3: + smp_mb_recv(i, j); + goto non_atomic3_end; +non_atomic3_skip: + +#endif /* REMOTE_BARRIERS */ + + atomic { + if + PROCEDURE_READ_LOCK(READ_LOCK_BASE, READ_PROD_NONE, READ_LOCK_OUT); + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_LOCK_OUT, /* post-dominant */ + READ_PROC_FIRST_MB) -> + smp_mb_reader(i, j); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_FIRST_MB); + + PROCEDURE_READ_LOCK(READ_LOCK_NESTED_BASE, READ_PROC_FIRST_MB | READ_LOCK_OUT, + READ_LOCK_NESTED_OUT); + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_PROC_FIRST_MB, /* mb() orders reads */ + READ_PROC_READ_GEN) -> + ooo_mem(i); + ptr_read_first[get_readerid()] = READ_CACHED_VAR(rcu_ptr); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_READ_GEN); + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_PROC_FIRST_MB /* mb() orders reads */ + | READ_PROC_READ_GEN, + READ_PROC_ACCESS_GEN) -> + /* smp_read_barrier_depends */ + goto rmb1; +rmb1_end: + data_read_first[get_readerid()] = + READ_CACHED_VAR(rcu_data[ptr_read_first[get_readerid()]]); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_ACCESS_GEN); + + + /* Note : we remove the nested memory barrier from the read unlock + * model, given it is not usually needed. The implementation has the barrier + * because the performance impact added by a branch in the common case does not + * justify it. + */ + + PROCEDURE_READ_UNLOCK(READ_UNLOCK_NESTED_BASE, + READ_PROC_FIRST_MB + | READ_LOCK_OUT + | READ_LOCK_NESTED_OUT, + READ_UNLOCK_NESTED_OUT); + + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_PROC_ACCESS_GEN /* mb() orders reads */ + | READ_PROC_READ_GEN /* mb() orders reads */ + | READ_PROC_FIRST_MB /* mb() ordered */ + | READ_LOCK_OUT /* post-dominant */ + | READ_LOCK_NESTED_OUT /* post-dominant */ + | READ_UNLOCK_NESTED_OUT, + READ_PROC_SECOND_MB) -> + smp_mb_reader(i, j); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_SECOND_MB); + + PROCEDURE_READ_UNLOCK(READ_UNLOCK_BASE, + READ_PROC_SECOND_MB /* mb() orders reads */ + | READ_PROC_FIRST_MB /* mb() orders reads */ + | READ_LOCK_NESTED_OUT /* RAW */ + | READ_LOCK_OUT /* RAW */ + | READ_UNLOCK_NESTED_OUT, /* RAW */ + READ_UNLOCK_OUT); + + /* Unrolling loop : second consecutive lock */ + /* reading urcu_active_readers, which have been written by + * READ_UNLOCK_OUT : RAW */ + PROCEDURE_READ_LOCK(READ_LOCK_UNROLL_BASE, + READ_UNLOCK_OUT /* RAW */ + | READ_PROC_SECOND_MB /* mb() orders reads */ + | READ_PROC_FIRST_MB /* mb() orders reads */ + | READ_LOCK_NESTED_OUT /* RAW */ + | READ_LOCK_OUT /* RAW */ + | READ_UNLOCK_NESTED_OUT, /* RAW */ + READ_LOCK_OUT_UNROLL); + + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_PROC_FIRST_MB /* mb() ordered */ + | READ_PROC_SECOND_MB /* mb() ordered */ + | READ_LOCK_OUT_UNROLL /* post-dominant */ + | READ_LOCK_NESTED_OUT + | READ_LOCK_OUT + | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT, + READ_PROC_THIRD_MB) -> + smp_mb_reader(i, j); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_THIRD_MB); + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_PROC_FIRST_MB /* mb() orders reads */ + | READ_PROC_SECOND_MB /* mb() orders reads */ + | READ_PROC_THIRD_MB, /* mb() orders reads */ + READ_PROC_READ_GEN_UNROLL) -> + ooo_mem(i); + ptr_read_second[get_readerid()] = READ_CACHED_VAR(rcu_ptr); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_READ_GEN_UNROLL); + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_PROC_READ_GEN_UNROLL + | READ_PROC_FIRST_MB /* mb() orders reads */ + | READ_PROC_SECOND_MB /* mb() orders reads */ + | READ_PROC_THIRD_MB, /* mb() orders reads */ + READ_PROC_ACCESS_GEN_UNROLL) -> + /* smp_read_barrier_depends */ + goto rmb2; +rmb2_end: + data_read_second[get_readerid()] = + READ_CACHED_VAR(rcu_data[ptr_read_second[get_readerid()]]); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_ACCESS_GEN_UNROLL); + + :: CONSUME_TOKENS(proc_urcu_reader, + READ_PROC_READ_GEN_UNROLL /* mb() orders reads */ + | READ_PROC_ACCESS_GEN_UNROLL /* mb() orders reads */ + | READ_PROC_FIRST_MB /* mb() ordered */ + | READ_PROC_SECOND_MB /* mb() ordered */ + | READ_PROC_THIRD_MB /* mb() ordered */ + | READ_LOCK_OUT_UNROLL /* post-dominant */ + | READ_LOCK_NESTED_OUT + | READ_LOCK_OUT + | READ_UNLOCK_NESTED_OUT + | READ_UNLOCK_OUT, + READ_PROC_FOURTH_MB) -> + smp_mb_reader(i, j); + PRODUCE_TOKENS(proc_urcu_reader, READ_PROC_FOURTH_MB); + + PROCEDURE_READ_UNLOCK(READ_UNLOCK_UNROLL_BASE, + READ_PROC_FOURTH_MB /* mb() orders reads */ + | READ_PROC_THIRD_MB /* mb() orders reads */ + | READ_LOCK_OUT_UNROLL /* RAW */ + | READ_PROC_SECOND_MB /* mb() orders reads */ + | READ_PROC_FIRST_MB /* mb() orders reads */ + | READ_LOCK_NESTED_OUT /* RAW */ + | READ_LOCK_OUT /* RAW */ + | READ_UNLOCK_NESTED_OUT, /* RAW */ + READ_UNLOCK_OUT_UNROLL); + :: CONSUME_TOKENS(proc_urcu_reader, READ_PROC_ALL_TOKENS, 0) -> + CLEAR_TOKENS(proc_urcu_reader, READ_PROC_ALL_TOKENS_CLEAR); + break; + fi; + } + od; + /* + * Dependency between consecutive loops : + * RAW dependency on + * WRITE_CACHED_VAR(urcu_active_readers[get_readerid()], tmp2 - 1) + * tmp = READ_CACHED_VAR(urcu_active_readers[get_readerid()]); + * between loops. + * _WHEN THE MB()s are in place_, they add full ordering of the + * generation pointer read wrt active reader count read, which ensures + * execution will not spill across loop execution. + * However, in the event mb()s are removed (execution using signal + * handler to promote barrier()() -> smp_mb()), nothing prevents one loop + * to spill its execution on other loop's execution. + */ + goto end; +rmb1: +#ifndef NO_RMB + smp_rmb(i); +#else + ooo_mem(i); +#endif + goto rmb1_end; +rmb2: +#ifndef NO_RMB + smp_rmb(i); +#else + ooo_mem(i); +#endif + goto rmb2_end; +end: + skip; +} + + + +active proctype urcu_reader() +{ + byte i, j, nest_i; + byte tmp, tmp2; + + wait_init_done(); + + assert(get_pid() < NR_PROCS); + +end_reader: + do + :: 1 -> + /* + * We do not test reader's progress here, because we are mainly + * interested in writer's progress. The reader never blocks + * anyway. We have to test for reader/writer's progress + * separately, otherwise we could think the writer is doing + * progress when it's blocked by an always progressing reader. + */ +#ifdef READER_PROGRESS +progress_reader: +#endif + urcu_one_read(i, j, nest_i, tmp, tmp2); + od; +} + +/* no name clash please */ +#undef proc_urcu_reader + + +/* Model the RCU update process. */ + +/* + * Bit encoding, urcu_writer : + * Currently only supports one reader. + */ + +int _proc_urcu_writer; +#define proc_urcu_writer _proc_urcu_writer + +#define WRITE_PROD_NONE (1 << 0) + +#define WRITE_DATA (1 << 1) +#define WRITE_PROC_WMB (1 << 2) +#define WRITE_XCHG_PTR (1 << 3) + +#define WRITE_PROC_FIRST_MB (1 << 4) + +/* first flip */ +#define WRITE_PROC_FIRST_READ_GP (1 << 5) +#define WRITE_PROC_FIRST_WRITE_GP (1 << 6) +#define WRITE_PROC_FIRST_WAIT (1 << 7) +#define WRITE_PROC_FIRST_WAIT_LOOP (1 << 8) + +/* second flip */ +#define WRITE_PROC_SECOND_READ_GP (1 << 9) +#define WRITE_PROC_SECOND_WRITE_GP (1 << 10) +#define WRITE_PROC_SECOND_WAIT (1 << 11) +#define WRITE_PROC_SECOND_WAIT_LOOP (1 << 12) + +#define WRITE_PROC_SECOND_MB (1 << 13) + +#define WRITE_FREE (1 << 14) + +#define WRITE_PROC_ALL_TOKENS (WRITE_PROD_NONE \ + | WRITE_DATA \ + | WRITE_PROC_WMB \ + | WRITE_XCHG_PTR \ + | WRITE_PROC_FIRST_MB \ + | WRITE_PROC_FIRST_READ_GP \ + | WRITE_PROC_FIRST_WRITE_GP \ + | WRITE_PROC_FIRST_WAIT \ + | WRITE_PROC_SECOND_READ_GP \ + | WRITE_PROC_SECOND_WRITE_GP \ + | WRITE_PROC_SECOND_WAIT \ + | WRITE_PROC_SECOND_MB \ + | WRITE_FREE) + +#define WRITE_PROC_ALL_TOKENS_CLEAR ((1 << 15) - 1) + +/* + * Mutexes are implied around writer execution. A single writer at a time. + */ +active proctype urcu_writer() +{ + byte i, j; + byte tmp, tmp2, tmpa; + byte cur_data = 0, old_data, loop_nr = 0; + byte cur_gp_val = 0; /* + * Keep a local trace of the current parity so + * we don't add non-existing dependencies on the global + * GP update. Needed to test single flip case. + */ + + wait_init_done(); + + assert(get_pid() < NR_PROCS); + + do + :: (loop_nr < 3) -> +#ifdef WRITER_PROGRESS +progress_writer1: +#endif + loop_nr = loop_nr + 1; + + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROD_NONE); + +#ifdef NO_WMB + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_WMB); +#endif + +#ifdef NO_MB + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_FIRST_MB); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_MB); +#endif + +#ifdef SINGLE_FLIP + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_READ_GP); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_WRITE_GP); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_WAIT); + /* For single flip, we need to know the current parity */ + cur_gp_val = cur_gp_val ^ RCU_GP_CTR_BIT; +#endif + + do :: 1 -> + atomic { + if + + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_PROD_NONE, + WRITE_DATA) -> + ooo_mem(i); + cur_data = (cur_data + 1) % SLAB_SIZE; + WRITE_CACHED_VAR(rcu_data[cur_data], WINE); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_DATA); + + + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_DATA, + WRITE_PROC_WMB) -> + smp_wmb(i); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_WMB); + + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_PROC_WMB, + WRITE_XCHG_PTR) -> + /* rcu_xchg_pointer() */ + atomic { + old_data = READ_CACHED_VAR(rcu_ptr); + WRITE_CACHED_VAR(rcu_ptr, cur_data); + } + PRODUCE_TOKENS(proc_urcu_writer, WRITE_XCHG_PTR); + + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_DATA | WRITE_PROC_WMB | WRITE_XCHG_PTR, + WRITE_PROC_FIRST_MB) -> + goto smp_mb_send1; +smp_mb_send1_end: + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_FIRST_MB); + + /* first flip */ + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_PROC_FIRST_MB, + WRITE_PROC_FIRST_READ_GP) -> + tmpa = READ_CACHED_VAR(urcu_gp_ctr); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_FIRST_READ_GP); + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_PROC_FIRST_MB | WRITE_PROC_WMB + | WRITE_PROC_FIRST_READ_GP, + WRITE_PROC_FIRST_WRITE_GP) -> + ooo_mem(i); + WRITE_CACHED_VAR(urcu_gp_ctr, tmpa ^ RCU_GP_CTR_BIT); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_FIRST_WRITE_GP); + + :: CONSUME_TOKENS(proc_urcu_writer, + //WRITE_PROC_FIRST_WRITE_GP /* TEST ADDING SYNC CORE */ + WRITE_PROC_FIRST_MB, /* can be reordered before/after flips */ + WRITE_PROC_FIRST_WAIT | WRITE_PROC_FIRST_WAIT_LOOP) -> + ooo_mem(i); + /* ONLY WAITING FOR READER 0 */ + tmp2 = READ_CACHED_VAR(urcu_active_readers[0]); +#ifndef SINGLE_FLIP + /* In normal execution, we are always starting by + * waiting for the even parity. + */ + cur_gp_val = RCU_GP_CTR_BIT; +#endif + if + :: (tmp2 & RCU_GP_CTR_NEST_MASK) + && ((tmp2 ^ cur_gp_val) & RCU_GP_CTR_BIT) -> + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_FIRST_WAIT_LOOP); + :: else -> + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_FIRST_WAIT); + fi; + + :: CONSUME_TOKENS(proc_urcu_writer, + //WRITE_PROC_FIRST_WRITE_GP /* TEST ADDING SYNC CORE */ + WRITE_PROC_FIRST_WRITE_GP + | WRITE_PROC_FIRST_READ_GP + | WRITE_PROC_FIRST_WAIT_LOOP + | WRITE_DATA | WRITE_PROC_WMB | WRITE_XCHG_PTR + | WRITE_PROC_FIRST_MB, /* can be reordered before/after flips */ + 0) -> +#ifndef GEN_ERROR_WRITER_PROGRESS + goto smp_mb_send2; +smp_mb_send2_end: +#else + ooo_mem(i); +#endif + /* This instruction loops to WRITE_PROC_FIRST_WAIT */ + CLEAR_TOKENS(proc_urcu_writer, WRITE_PROC_FIRST_WAIT_LOOP | WRITE_PROC_FIRST_WAIT); + + /* second flip */ + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_PROC_FIRST_WAIT /* Control dependency : need to branch out of + * the loop to execute the next flip (CHECK) */ + | WRITE_PROC_FIRST_WRITE_GP + | WRITE_PROC_FIRST_READ_GP + | WRITE_PROC_FIRST_MB, + WRITE_PROC_SECOND_READ_GP) -> + ooo_mem(i); + tmpa = READ_CACHED_VAR(urcu_gp_ctr); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_READ_GP); + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_PROC_FIRST_MB + | WRITE_PROC_WMB + | WRITE_PROC_FIRST_READ_GP + | WRITE_PROC_FIRST_WRITE_GP + | WRITE_PROC_SECOND_READ_GP, + WRITE_PROC_SECOND_WRITE_GP) -> + ooo_mem(i); + WRITE_CACHED_VAR(urcu_gp_ctr, tmpa ^ RCU_GP_CTR_BIT); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_WRITE_GP); + + :: CONSUME_TOKENS(proc_urcu_writer, + //WRITE_PROC_FIRST_WRITE_GP /* TEST ADDING SYNC CORE */ + WRITE_PROC_FIRST_WAIT + | WRITE_PROC_FIRST_MB, /* can be reordered before/after flips */ + WRITE_PROC_SECOND_WAIT | WRITE_PROC_SECOND_WAIT_LOOP) -> + ooo_mem(i); + /* ONLY WAITING FOR READER 0 */ + tmp2 = READ_CACHED_VAR(urcu_active_readers[0]); + if + :: (tmp2 & RCU_GP_CTR_NEST_MASK) + && ((tmp2 ^ 0) & RCU_GP_CTR_BIT) -> + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_WAIT_LOOP); + :: else -> + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_WAIT); + fi; + + :: CONSUME_TOKENS(proc_urcu_writer, + //WRITE_PROC_FIRST_WRITE_GP /* TEST ADDING SYNC CORE */ + WRITE_PROC_SECOND_WRITE_GP + | WRITE_PROC_FIRST_WRITE_GP + | WRITE_PROC_SECOND_READ_GP + | WRITE_PROC_FIRST_READ_GP + | WRITE_PROC_SECOND_WAIT_LOOP + | WRITE_DATA | WRITE_PROC_WMB | WRITE_XCHG_PTR + | WRITE_PROC_FIRST_MB, /* can be reordered before/after flips */ + 0) -> +#ifndef GEN_ERROR_WRITER_PROGRESS + goto smp_mb_send3; +smp_mb_send3_end: +#else + ooo_mem(i); +#endif + /* This instruction loops to WRITE_PROC_SECOND_WAIT */ + CLEAR_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_WAIT_LOOP | WRITE_PROC_SECOND_WAIT); + + + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_PROC_FIRST_WAIT + | WRITE_PROC_SECOND_WAIT + | WRITE_PROC_FIRST_READ_GP + | WRITE_PROC_SECOND_READ_GP + | WRITE_PROC_FIRST_WRITE_GP + | WRITE_PROC_SECOND_WRITE_GP + | WRITE_DATA | WRITE_PROC_WMB | WRITE_XCHG_PTR + | WRITE_PROC_FIRST_MB, + WRITE_PROC_SECOND_MB) -> + goto smp_mb_send4; +smp_mb_send4_end: + PRODUCE_TOKENS(proc_urcu_writer, WRITE_PROC_SECOND_MB); + + :: CONSUME_TOKENS(proc_urcu_writer, + WRITE_XCHG_PTR + | WRITE_PROC_FIRST_WAIT + | WRITE_PROC_SECOND_WAIT + | WRITE_PROC_WMB /* No dependency on + * WRITE_DATA because we + * write to a + * different location. */ + | WRITE_PROC_SECOND_MB + | WRITE_PROC_FIRST_MB, + WRITE_FREE) -> + WRITE_CACHED_VAR(rcu_data[old_data], POISON); + PRODUCE_TOKENS(proc_urcu_writer, WRITE_FREE); + + :: CONSUME_TOKENS(proc_urcu_writer, WRITE_PROC_ALL_TOKENS, 0) -> + CLEAR_TOKENS(proc_urcu_writer, WRITE_PROC_ALL_TOKENS_CLEAR); + break; + fi; + } + od; + /* + * Note : Promela model adds implicit serialization of the + * WRITE_FREE instruction. Normally, it would be permitted to + * spill on the next loop execution. Given the validation we do + * checks for the data entry read to be poisoned, it's ok if + * we do not check "late arriving" memory poisoning. + */ + :: else -> break; + od; + /* + * Given the reader loops infinitely, let the writer also busy-loop + * with progress here so, with weak fairness, we can test the + * writer's progress. + */ +end_writer: + do + :: 1 -> +#ifdef WRITER_PROGRESS +progress_writer2: +#endif +#ifdef READER_PROGRESS + /* + * Make sure we don't block the reader's progress. + */ + smp_mb_send(i, j, 5); +#endif + skip; + od; + + /* Non-atomic parts of the loop */ + goto end; +smp_mb_send1: + smp_mb_send(i, j, 1); + goto smp_mb_send1_end; +#ifndef GEN_ERROR_WRITER_PROGRESS +smp_mb_send2: + smp_mb_send(i, j, 2); + goto smp_mb_send2_end; +smp_mb_send3: + smp_mb_send(i, j, 3); + goto smp_mb_send3_end; +#endif +smp_mb_send4: + smp_mb_send(i, j, 4); + goto smp_mb_send4_end; +end: + skip; +} + +/* no name clash please */ +#undef proc_urcu_writer + + +/* Leave after the readers and writers so the pid count is ok. */ +init { + byte i, j; + + atomic { + INIT_CACHED_VAR(urcu_gp_ctr, 1, j); + INIT_CACHED_VAR(rcu_ptr, 0, j); + + i = 0; + do + :: i < NR_READERS -> + INIT_CACHED_VAR(urcu_active_readers[i], 0, j); + ptr_read_first[i] = 1; + ptr_read_second[i] = 1; + data_read_first[i] = WINE; + data_read_second[i] = WINE; + i++; + :: i >= NR_READERS -> break + od; + INIT_CACHED_VAR(rcu_data[0], WINE, j); + i = 1; + do + :: i < SLAB_SIZE -> + INIT_CACHED_VAR(rcu_data[i], POISON, j); + i++ + :: i >= SLAB_SIZE -> break + od; + + init_done = 1; + } +} diff --git a/formal-model/results/urcu-controldataflow-ipi-intel/urcu_progress_writer_error.spin.input.trail b/formal-model/results/urcu-controldataflow-ipi-intel/urcu_progress_writer_error.spin.input.trail new file mode 100644 index 0000000..ee9e4b8 --- /dev/null +++ b/formal-model/results/urcu-controldataflow-ipi-intel/urcu_progress_writer_error.spin.input.trail @@ -0,0 +1,1700 @@ +-2:3:-2 +-4:-4:-4 +1:0:3993 +2:3:3913 +3:3:3916 +4:3:3916 +5:3:3919 +6:3:3927 +7:3:3927 +8:3:3930 +9:3:3936 +10:3:3940 +11:3:3940 +12:3:3943 +13:3:3953 +14:3:3961 +15:3:3961 +16:3:3964 +17:3:3970 +18:3:3974 +19:3:3974 +20:3:3977 +21:3:3983 +22:3:3987 +23:3:3988 +24:0:3993 +25:3:3990 +26:0:3993 +27:2:2511 +28:0:3993 +29:2:2517 +30:0:3993 +31:2:2518 +32:0:3993 +33:2:2519 +34:0:3993 +35:2:2520 +36:0:3993 +37:2:2521 +38:0:3993 +39:2:2522 +40:2:2523 +41:2:2527 +42:2:2528 +43:2:2536 +44:2:2537 +45:2:2541 +46:2:2542 +47:2:2550 +48:2:2555 +49:2:2559 +50:2:2560 +51:2:2568 +52:2:2569 +53:2:2573 +54:2:2574 +55:2:2568 +56:2:2569 +57:2:2573 +58:2:2574 +59:2:2582 +60:2:2587 +61:2:2594 +62:2:2595 +63:2:2602 +64:2:2607 +65:2:2614 +66:2:2615 +67:2:2614 +68:2:2615 +69:2:2622 +70:2:2632 +71:0:3993 +72:2:2521 +73:0:3993 +74:2:2636 +75:2:2640 +76:2:2641 +77:2:2645 +78:2:2649 +79:2:2650 +80:2:2654 +81:2:2662 +82:2:2663 +83:2:2667 +84:2:2671 +85:2:2672 +86:2:2667 +87:2:2668 +88:2:2676 +89:0:3993 +90:2:2521 +91:0:3993 +92:2:2684 +93:2:2685 +94:2:2686 +95:0:3993 +96:2:2521 +97:0:3993 +98:2:2691 +99:0:3993 +100:2:3518 +101:2:3519 +102:2:3523 +103:2:3527 +104:2:3528 +105:2:3532 +106:2:3537 +107:2:3545 +108:2:3549 +109:2:3550 +110:2:3545 +111:2:3549 +112:2:3550 +113:2:3554 +114:2:3561 +115:2:3568 +116:2:3569 +117:2:3576 +118:2:3581 +119:2:3588 +120:2:3589 +121:2:3588 +122:2:3589 +123:2:3596 +124:2:3600 +125:0:3993 +126:2:3605 +127:0:3993 +128:2:3606 +129:0:3993 +130:2:3607 +131:0:3993 +132:2:3608 +133:0:3993 +134:1:2 +135:0:3993 +136:1:8 +137:0:3993 +138:1:9 +139:0:3993 +140:2:3609 +141:0:3993 +142:1:10 +143:0:3993 +144:2:3608 +145:0:3993 +146:1:11 +147:0:3993 +148:2:3609 +149:0:3993 +150:1:12 +151:0:3993 +152:2:3608 +153:0:3993 +154:1:13 +155:0:3993 +156:2:3609 +157:0:3993 +158:1:14 +159:0:3993 +160:1:15 +161:0:3993 +162:1:16 +163:0:3993 +164:2:3608 +165:0:3993 +166:1:17 +167:0:3993 +168:2:3609 +169:0:3993 +170:1:26 +171:0:3993 +172:2:3608 +173:0:3993 +174:1:30 +175:1:31 +176:1:35 +177:1:39 +178:1:40 +179:1:44 +180:1:52 +181:1:53 +182:1:57 +183:1:61 +184:1:62 +185:1:57 +186:1:61 +187:1:62 +188:1:66 +189:1:73 +190:1:80 +191:1:81 +192:1:88 +193:1:93 +194:1:100 +195:1:101 +196:1:100 +197:1:101 +198:1:108 +199:1:112 +200:0:3993 +201:2:3609 +202:0:3993 +203:1:117 +204:0:3993 +205:2:3610 +206:0:3993 +207:2:3615 +208:0:3993 +209:2:3616 +210:0:3993 +211:2:3624 +212:2:3625 +213:2:3629 +214:2:3633 +215:2:3634 +216:2:3638 +217:2:3646 +218:2:3647 +219:2:3651 +220:2:3655 +221:2:3656 +222:2:3651 +223:2:3655 +224:2:3656 +225:2:3660 +226:2:3667 +227:2:3674 +228:2:3675 +229:2:3682 +230:2:3687 +231:2:3694 +232:2:3695 +233:2:3694 +234:2:3695 +235:2:3702 +236:2:3706 +237:0:3993 +238:2:2693 +239:2:3499 +240:0:3993 +241:2:2521 +242:0:3993 +243:2:2694 +244:0:3993 +245:2:2521 +246:0:3993 +247:2:2697 +248:2:2698 +249:2:2702 +250:2:2703 +251:2:2711 +252:2:2712 +253:2:2716 +254:2:2717 +255:2:2725 +256:2:2730 +257:2:2734 +258:2:2735 +259:2:2743 +260:2:2744 +261:2:2748 +262:2:2749 +263:2:2743 +264:2:2744 +265:2:2748 +266:2:2749 +267:2:2757 +268:2:2762 +269:2:2769 +270:2:2770 +271:2:2777 +272:2:2782 +273:2:2789 +274:2:2790 +275:2:2789 +276:2:2790 +277:2:2797 +278:2:2806 +279:0:3993 +280:2:2521 +281:0:3993 +282:2:2810 +283:2:2811 +284:2:2812 +285:2:2824 +286:2:2825 +287:2:2829 +288:2:2830 +289:2:2838 +290:2:2843 +291:2:2847 +292:2:2848 +293:2:2856 +294:2:2857 +295:2:2861 +296:2:2862 +297:2:2856 +298:2:2857 +299:2:2861 +300:2:2862 +301:2:2870 +302:2:2875 +303:2:2882 +304:2:2883 +305:2:2890 +306:2:2895 +307:2:2902 +308:2:2903 +309:2:2902 +310:2:2903 +311:2:2910 +312:2:2923 +313:2:2924 +314:0:3993 +315:2:2521 +316:0:3993 +317:2:3037 +318:2:3038 +319:2:3042 +320:2:3043 +321:2:3051 +322:2:3052 +323:2:3056 +324:2:3057 +325:2:3065 +326:2:3070 +327:2:3074 +328:2:3075 +329:2:3083 +330:2:3084 +331:2:3088 +332:2:3089 +333:2:3083 +334:2:3084 +335:2:3088 +336:2:3089 +337:2:3097 +338:2:3102 +339:2:3109 +340:2:3110 +341:2:3117 +342:2:3122 +343:2:3129 +344:2:3130 +345:2:3129 +346:2:3130 +347:2:3137 +348:0:3993 +349:2:2521 +350:0:3993 +351:2:3148 +352:2:3149 +353:2:3153 +354:2:3154 +355:2:3162 +356:2:3163 +357:2:3167 +358:2:3168 +359:2:3176 +360:2:3181 +361:2:3185 +362:2:3186 +363:2:3194 +364:2:3195 +365:2:3199 +366:2:3200 +367:2:3194 +368:2:3195 +369:2:3199 +370:2:3200 +371:2:3208 +372:2:3213 +373:2:3220 +374:2:3221 +375:2:3228 +376:2:3233 +377:2:3240 +378:2:3241 +379:2:3240 +380:2:3241 +381:2:3248 +382:2:3257 +383:0:3993 +384:2:2521 +385:0:3993 +386:2:3261 +387:2:3262 +388:2:3263 +389:2:3275 +390:2:3276 +391:2:3280 +392:2:3281 +393:2:3289 +394:2:3294 +395:2:3298 +396:2:3299 +397:2:3307 +398:2:3308 +399:2:3312 +400:2:3313 +401:2:3307 +402:2:3308 +403:2:3312 +404:2:3313 +405:2:3321 +406:2:3326 +407:2:3333 +408:2:3334 +409:2:3341 +410:2:3346 +411:2:3353 +412:2:3354 +413:2:3353 +414:2:3354 +415:2:3361 +416:2:3373 +417:2:3374 +418:0:3993 +419:2:2521 +420:0:3993 +421:2:3487 +422:0:3993 +423:2:3716 +424:2:3717 +425:2:3721 +426:2:3725 +427:2:3726 +428:2:3730 +429:2:3738 +430:2:3739 +431:2:3743 +432:2:3747 +433:2:3748 +434:2:3743 +435:2:3747 +436:2:3748 +437:2:3752 +438:2:3759 +439:2:3766 +440:2:3767 +441:2:3774 +442:2:3779 +443:2:3786 +444:2:3787 +445:2:3786 +446:2:3787 +447:2:3794 +448:2:3798 +449:0:3993 +450:2:3803 +451:0:3993 +452:2:3804 +453:0:3993 +454:2:3805 +455:0:3993 +456:2:3806 +457:0:3993 +458:1:26 +459:0:3993 +460:2:3807 +461:0:3993 +462:1:30 +463:1:31 +464:1:35 +465:1:39 +466:1:40 +467:1:44 +468:1:52 +469:1:53 +470:1:57 +471:1:61 +472:1:62 +473:1:57 +474:1:61 +475:1:62 +476:1:66 +477:1:73 +478:1:80 +479:1:81 +480:1:88 +481:1:93 +482:1:100 +483:1:101 +484:1:100 +485:1:101 +486:1:108 +487:1:112 +488:0:3993 +489:2:3806 +490:0:3993 +491:1:117 +492:0:3993 +493:2:3807 +494:0:3993 +495:2:3808 +496:0:3993 +497:2:3813 +498:0:3993 +499:2:3814 +500:0:3993 +501:2:3822 +502:2:3823 +503:2:3827 +504:2:3831 +505:2:3832 +506:2:3836 +507:2:3844 +508:2:3845 +509:2:3849 +510:2:3853 +511:2:3854 +512:2:3849 +513:2:3853 +514:2:3854 +515:2:3858 +516:2:3865 +517:2:3872 +518:2:3873 +519:2:3880 +520:2:3885 +521:2:3892 +522:2:3893 +523:2:3892 +524:2:3893 +525:2:3900 +526:2:3904 +527:0:3993 +528:2:3489 +529:2:3499 +530:0:3993 +531:2:2521 +532:0:3993 +533:2:3490 +534:2:3491 +535:0:3993 +536:2:2521 +537:0:3993 +538:2:3495 +539:0:3993 +540:2:3503 +541:0:3993 +542:2:2518 +543:0:3993 +544:2:2519 +545:0:3993 +546:2:2520 +547:0:3993 +548:2:2521 +549:0:3993 +550:2:2522 +551:2:2523 +552:2:2527 +553:2:2528 +554:2:2536 +555:2:2537 +556:2:2541 +557:2:2542 +558:2:2550 +559:2:2555 +560:2:2559 +561:2:2560 +562:2:2568 +563:2:2569 +564:2:2570 +565:2:2568 +566:2:2569 +567:2:2573 +568:2:2574 +569:2:2582 +570:2:2587 +571:2:2594 +572:2:2595 +573:2:2602 +574:2:2607 +575:2:2614 +576:2:2615 +577:2:2614 +578:2:2615 +579:2:2622 +580:2:2632 +581:0:3993 +582:2:2521 +583:0:3993 +584:2:2636 +585:2:2640 +586:2:2641 +587:2:2645 +588:2:2649 +589:2:2650 +590:2:2654 +591:2:2662 +592:2:2663 +593:2:2667 +594:2:2668 +595:2:2667 +596:2:2671 +597:2:2672 +598:2:2676 +599:0:3993 +600:2:2521 +601:0:3993 +602:2:2684 +603:2:2685 +604:2:2686 +605:0:3993 +606:2:2521 +607:0:3993 +608:2:2691 +609:0:3993 +610:2:3518 +611:2:3519 +612:2:3523 +613:2:3527 +614:2:3528 +615:2:3532 +616:2:3537 +617:2:3545 +618:2:3549 +619:2:3550 +620:2:3545 +621:2:3549 +622:2:3550 +623:2:3554 +624:2:3561 +625:2:3568 +626:2:3569 +627:2:3576 +628:2:3581 +629:2:3588 +630:2:3589 +631:2:3588 +632:2:3589 +633:2:3596 +634:2:3600 +635:0:3993 +636:2:3605 +637:0:3993 +638:2:3606 +639:0:3993 +640:2:3607 +641:0:3993 +642:2:3608 +643:0:3993 +644:1:26 +645:0:3993 +646:2:3609 +647:0:3993 +648:1:30 +649:1:31 +650:1:35 +651:1:39 +652:1:40 +653:1:44 +654:1:52 +655:1:53 +656:1:57 +657:1:61 +658:1:62 +659:1:57 +660:1:61 +661:1:62 +662:1:66 +663:1:73 +664:1:80 +665:1:81 +666:1:88 +667:1:93 +668:1:100 +669:1:101 +670:1:100 +671:1:101 +672:1:108 +673:1:112 +674:0:3993 +675:2:3608 +676:0:3993 +677:1:117 +678:0:3993 +679:2:3609 +680:0:3993 +681:2:3610 +682:0:3993 +683:2:3615 +684:0:3993 +685:2:3616 +686:0:3993 +687:2:3624 +688:2:3625 +689:2:3629 +690:2:3633 +691:2:3634 +692:2:3638 +693:2:3646 +694:2:3647 +695:2:3651 +696:2:3655 +697:2:3656 +698:2:3651 +699:2:3655 +700:2:3656 +701:2:3660 +702:2:3667 +703:2:3674 +704:2:3675 +705:2:3682 +706:2:3687 +707:2:3694 +708:2:3695 +709:2:3694 +710:2:3695 +711:2:3702 +712:2:3706 +713:0:3993 +714:2:2693 +715:2:3499 +716:0:3993 +717:2:2521 +718:0:3993 +719:2:2694 +720:0:3993 +721:2:2521 +722:0:3993 +723:2:2697 +724:2:2698 +725:2:2702 +726:2:2703 +727:2:2711 +728:2:2712 +729:2:2716 +730:2:2717 +731:2:2725 +732:2:2730 +733:2:2734 +734:2:2735 +735:2:2743 +736:2:2744 +737:2:2748 +738:2:2749 +739:2:2743 +740:2:2744 +741:2:2748 +742:2:2749 +743:2:2757 +744:2:2762 +745:2:2769 +746:2:2770 +747:2:2777 +748:2:2782 +749:2:2789 +750:2:2790 +751:2:2789 +752:2:2790 +753:2:2797 +754:2:2806 +755:0:3993 +756:2:2521 +757:0:3993 +758:2:2810 +759:2:2811 +760:2:2812 +761:2:2824 +762:2:2825 +763:2:2829 +764:2:2830 +765:2:2838 +766:2:2843 +767:2:2847 +768:2:2848 +769:2:2856 +770:2:2857 +771:2:2861 +772:2:2862 +773:2:2856 +774:2:2857 +775:2:2861 +776:2:2862 +777:2:2870 +778:2:2875 +779:2:2882 +780:2:2883 +781:2:2890 +782:2:2895 +783:2:2902 +784:2:2903 +785:2:2902 +786:2:2903 +787:2:2910 +788:2:2923 +789:2:2924 +790:0:3993 +791:2:2521 +792:0:3993 +793:2:3037 +794:2:3038 +795:2:3042 +796:2:3043 +797:2:3051 +798:2:3052 +799:2:3056 +800:2:3057 +801:2:3065 +802:2:3070 +803:2:3074 +804:2:3075 +805:2:3083 +806:2:3084 +807:2:3088 +808:2:3089 +809:2:3083 +810:2:3084 +811:2:3088 +812:2:3089 +813:2:3097 +814:2:3102 +815:2:3109 +816:2:3110 +817:2:3117 +818:2:3122 +819:2:3129 +820:2:3130 +821:2:3129 +822:2:3130 +823:2:3137 +824:0:3993 +825:2:2521 +826:0:3993 +827:2:3148 +828:2:3149 +829:2:3153 +830:2:3154 +831:2:3162 +832:2:3163 +833:2:3167 +834:2:3168 +835:2:3176 +836:2:3181 +837:2:3185 +838:2:3186 +839:2:3194 +840:2:3195 +841:2:3199 +842:2:3200 +843:2:3194 +844:2:3195 +845:2:3199 +846:2:3200 +847:2:3208 +848:2:3213 +849:2:3220 +850:2:3221 +851:2:3228 +852:2:3233 +853:2:3240 +854:2:3241 +855:2:3240 +856:2:3241 +857:2:3248 +858:2:3257 +859:0:3993 +860:2:2521 +861:0:3993 +862:2:3261 +863:2:3262 +864:2:3263 +865:2:3275 +866:2:3276 +867:2:3280 +868:2:3281 +869:2:3289 +870:2:3294 +871:2:3298 +872:2:3299 +873:2:3307 +874:2:3308 +875:2:3312 +876:2:3313 +877:2:3307 +878:2:3308 +879:2:3312 +880:2:3313 +881:2:3321 +882:2:3326 +883:2:3333 +884:2:3334 +885:2:3341 +886:2:3346 +887:2:3353 +888:2:3354 +889:2:3353 +890:2:3354 +891:2:3361 +892:2:3373 +893:2:3374 +894:0:3993 +895:2:2521 +896:0:3993 +897:2:3487 +898:0:3993 +899:2:3716 +900:2:3717 +901:2:3721 +902:2:3725 +903:2:3726 +904:2:3730 +905:2:3738 +906:2:3739 +907:2:3743 +908:2:3747 +909:2:3748 +910:2:3743 +911:2:3747 +912:2:3748 +913:2:3752 +914:2:3759 +915:2:3766 +916:2:3767 +917:2:3774 +918:2:3779 +919:2:3786 +920:2:3787 +921:2:3786 +922:2:3787 +923:2:3794 +924:2:3798 +925:0:3993 +926:2:3803 +927:0:3993 +928:2:3804 +929:0:3993 +930:2:3805 +931:0:3993 +932:2:3806 +933:0:3993 +934:1:26 +935:0:3993 +936:2:3807 +937:0:3993 +938:1:30 +939:1:31 +940:1:35 +941:1:39 +942:1:40 +943:1:44 +944:1:52 +945:1:53 +946:1:57 +947:1:61 +948:1:62 +949:1:57 +950:1:61 +951:1:62 +952:1:66 +953:1:73 +954:1:80 +955:1:81 +956:1:88 +957:1:93 +958:1:100 +959:1:101 +960:1:100 +961:1:101 +962:1:108 +963:1:112 +964:0:3993 +965:2:3806 +966:0:3993 +967:1:117 +968:0:3993 +969:2:3807 +970:0:3993 +971:2:3808 +972:0:3993 +973:2:3813 +974:0:3993 +975:2:3814 +976:0:3993 +977:2:3822 +978:2:3823 +979:2:3827 +980:2:3831 +981:2:3832 +982:2:3836 +983:2:3844 +984:2:3845 +985:2:3849 +986:2:3853 +987:2:3854 +988:2:3849 +989:2:3853 +990:2:3854 +991:2:3858 +992:2:3865 +993:2:3872 +994:2:3873 +995:2:3880 +996:2:3885 +997:2:3892 +998:2:3893 +999:2:3892 +1000:2:3893 +1001:2:3900 +1002:2:3904 +1003:0:3993 +1004:2:3489 +1005:2:3499 +1006:0:3993 +1007:2:2521 +1008:0:3993 +1009:2:3490 +1010:2:3491 +1011:0:3993 +1012:2:2521 +1013:0:3993 +1014:2:3495 +1015:0:3993 +1016:2:3503 +1017:0:3993 +1018:2:2518 +1019:0:3993 +1020:2:2519 +1021:0:3993 +1022:2:2520 +1023:0:3993 +1024:2:2521 +1025:0:3993 +1026:2:2522 +1027:2:2523 +1028:2:2527 +1029:2:2528 +1030:2:2536 +1031:2:2537 +1032:2:2541 +1033:2:2542 +1034:2:2550 +1035:2:2555 +1036:2:2559 +1037:2:2560 +1038:2:2568 +1039:2:2569 +1040:2:2573 +1041:2:2574 +1042:2:2568 +1043:2:2569 +1044:2:2570 +1045:2:2582 +1046:2:2587 +1047:2:2594 +1048:2:2595 +1049:2:2602 +1050:2:2607 +1051:2:2614 +1052:2:2615 +1053:2:2614 +1054:2:2615 +1055:2:2622 +1056:2:2632 +1057:0:3993 +1058:2:2521 +1059:0:3993 +1060:2:2636 +1061:2:2640 +1062:2:2641 +1063:2:2645 +1064:2:2649 +1065:2:2650 +1066:2:2654 +1067:2:2662 +1068:2:2663 +1069:2:2667 +1070:2:2671 +1071:2:2672 +1072:2:2667 +1073:2:2668 +1074:2:2676 +1075:0:3993 +1076:2:2521 +1077:0:3993 +1078:2:2684 +1079:2:2685 +1080:2:2686 +1081:0:3993 +1082:2:2521 +1083:0:3993 +1084:2:2691 +1085:0:3993 +1086:2:3518 +1087:2:3519 +1088:2:3523 +1089:2:3527 +1090:2:3528 +1091:2:3532 +1092:2:3537 +1093:2:3545 +1094:2:3549 +1095:2:3550 +1096:2:3545 +1097:2:3549 +1098:2:3550 +1099:2:3554 +1100:2:3561 +1101:2:3568 +1102:2:3569 +1103:2:3576 +1104:2:3581 +1105:2:3588 +1106:2:3589 +1107:2:3588 +1108:2:3589 +1109:2:3596 +1110:2:3600 +1111:0:3993 +1112:2:3605 +1113:0:3993 +1114:2:3606 +1115:0:3993 +1116:2:3607 +1117:0:3993 +1118:2:3608 +1119:0:3993 +1120:1:26 +1121:0:3993 +1122:2:3609 +1123:0:3993 +1124:1:30 +1125:1:31 +1126:1:35 +1127:1:39 +1128:1:40 +1129:1:44 +1130:1:52 +1131:1:53 +1132:1:57 +1133:1:61 +1134:1:62 +1135:1:57 +1136:1:61 +1137:1:62 +1138:1:66 +1139:1:73 +1140:1:80 +1141:1:81 +1142:1:88 +1143:1:93 +1144:1:100 +1145:1:101 +1146:1:100 +1147:1:101 +1148:1:108 +1149:1:112 +1150:0:3993 +1151:2:3608 +1152:0:3993 +1153:1:117 +1154:0:3993 +1155:2:3609 +1156:0:3993 +1157:2:3610 +1158:0:3993 +1159:2:3615 +1160:0:3993 +1161:2:3616 +1162:0:3993 +1163:2:3624 +1164:2:3625 +1165:2:3629 +1166:2:3633 +1167:2:3634 +1168:2:3638 +1169:2:3646 +1170:2:3647 +1171:2:3651 +1172:2:3655 +1173:2:3656 +1174:2:3651 +1175:2:3655 +1176:2:3656 +1177:2:3660 +1178:2:3667 +1179:2:3674 +1180:2:3675 +1181:2:3682 +1182:2:3687 +1183:2:3694 +1184:2:3695 +1185:2:3694 +1186:2:3695 +1187:2:3702 +1188:2:3706 +1189:0:3993 +1190:2:2693 +1191:2:3499 +1192:0:3993 +1193:2:2521 +1194:0:3993 +1195:2:2694 +1196:0:3993 +1197:2:2521 +1198:0:3993 +1199:2:2697 +1200:2:2698 +1201:2:2702 +1202:2:2703 +1203:2:2711 +1204:2:2712 +1205:2:2716 +1206:2:2717 +1207:2:2725 +1208:2:2730 +1209:2:2734 +1210:2:2735 +1211:2:2743 +1212:2:2744 +1213:2:2748 +1214:2:2749 +1215:2:2743 +1216:2:2744 +1217:2:2748 +1218:2:2749 +1219:2:2757 +1220:2:2762 +1221:2:2769 +1222:2:2770 +1223:2:2777 +1224:2:2782 +1225:2:2789 +1226:2:2790 +1227:2:2789 +1228:2:2790 +1229:2:2797 +1230:2:2806 +1231:0:3993 +1232:2:2521 +1233:0:3993 +1234:2:2810 +1235:2:2811 +1236:2:2812 +1237:2:2824 +1238:2:2825 +1239:2:2829 +1240:2:2830 +1241:2:2838 +1242:2:2843 +1243:2:2847 +1244:2:2848 +1245:2:2856 +1246:2:2857 +1247:2:2861 +1248:2:2862 +1249:2:2856 +1250:2:2857 +1251:2:2861 +1252:2:2862 +1253:2:2870 +1254:2:2875 +1255:2:2882 +1256:2:2883 +1257:2:2890 +1258:2:2895 +1259:2:2902 +1260:2:2903 +1261:2:2902 +1262:2:2903 +1263:2:2910 +1264:2:2923 +1265:2:2924 +1266:0:3993 +1267:2:2521 +1268:0:3993 +1269:2:3037 +1270:2:3038 +1271:2:3042 +1272:2:3043 +1273:2:3051 +1274:2:3052 +1275:2:3056 +1276:2:3057 +1277:2:3065 +1278:2:3070 +1279:2:3074 +1280:2:3075 +1281:2:3083 +1282:2:3084 +1283:2:3088 +1284:2:3089 +1285:2:3083 +1286:2:3084 +1287:2:3088 +1288:2:3089 +1289:2:3097 +1290:2:3102 +1291:2:3109 +1292:2:3110 +1293:2:3117 +1294:2:3122 +1295:2:3129 +1296:2:3130 +1297:2:3129 +1298:2:3130 +1299:2:3137 +1300:0:3993 +1301:2:2521 +1302:0:3993 +1303:2:3148 +1304:2:3149 +1305:2:3153 +1306:2:3154 +1307:2:3162 +1308:2:3163 +1309:2:3167 +1310:2:3168 +1311:2:3176 +1312:2:3181 +1313:2:3185 +1314:2:3186 +1315:2:3194 +1316:2:3195 +1317:2:3199 +1318:2:3200 +1319:2:3194 +1320:2:3195 +1321:2:3199 +1322:2:3200 +1323:2:3208 +1324:2:3213 +1325:2:3220 +1326:2:3221 +1327:2:3228 +1328:2:3233 +1329:2:3240 +1330:2:3241 +1331:2:3240 +1332:2:3241 +1333:2:3248 +1334:2:3257 +1335:0:3993 +1336:2:2521 +1337:0:3993 +1338:1:118 +1339:0:3993 +1340:1:120 +1341:0:3993 +1342:1:19 +1343:0:3993 +1344:1:126 +1345:1:127 +1346:1:131 +1347:1:132 +1348:1:140 +1349:1:141 +1350:1:145 +1351:1:146 +1352:1:154 +1353:1:159 +1354:1:163 +1355:1:164 +1356:1:172 +1357:1:173 +1358:1:177 +1359:1:178 +1360:1:172 +1361:1:173 +1362:1:177 +1363:1:178 +1364:1:186 +1365:1:191 +1366:1:198 +1367:1:199 +1368:1:206 +1369:1:211 +1370:1:218 +1371:1:219 +1372:1:218 +1373:1:219 +1374:1:226 +1375:0:3993 +1376:1:15 +1377:0:3993 +1378:1:16 +1379:0:3993 +1380:1:17 +1381:0:3993 +1382:1:118 +1383:0:3993 +1384:1:120 +1385:0:3993 +1386:1:19 +1387:0:3993 +1388:1:237 +1389:1:238 +1390:0:3993 +1391:1:15 +1392:0:3993 +1393:1:16 +1394:0:3993 +1395:1:17 +1396:0:3993 +1397:1:118 +1398:0:3993 +1399:1:120 +1400:0:3993 +1401:1:19 +1402:0:3993 +1403:1:244 +1404:1:245 +1405:1:249 +1406:1:250 +1407:1:258 +1408:1:259 +1409:1:263 +1410:1:264 +1411:1:272 +1412:1:277 +1413:1:281 +1414:1:282 +1415:1:290 +1416:1:291 +1417:1:295 +1418:1:296 +1419:1:290 +1420:1:291 +1421:1:295 +1422:1:296 +1423:1:304 +1424:1:309 +1425:1:316 +1426:1:317 +1427:1:324 +1428:1:329 +1429:1:336 +1430:1:337 +1431:1:336 +1432:1:337 +1433:1:344 +1434:0:3993 +1435:1:15 +1436:0:3993 +1437:1:16 +1438:0:3993 +1439:1:17 +1440:0:3993 +1441:1:118 +1442:0:3993 +1443:1:120 +1444:0:3993 +1445:1:19 +1446:0:3993 +1447:1:355 +1448:1:356 +1449:1:360 +1450:1:361 +1451:1:369 +1452:1:370 +1453:1:374 +1454:1:375 +1455:1:383 +1456:1:388 +1457:1:392 +1458:1:393 +1459:1:401 +1460:1:402 +1461:1:406 +1462:1:407 +1463:1:401 +1464:1:402 +1465:1:406 +1466:1:407 +1467:1:415 +1468:1:420 +1469:1:427 +1470:1:428 +1471:1:435 +1472:1:440 +1473:1:447 +1474:1:448 +1475:1:447 +1476:1:448 +1477:1:455 +1478:1:464 +1479:0:3993 +1480:1:15 +1481:0:3993 +1482:1:16 +1483:0:3993 +1484:1:17 +1485:0:3993 +1486:1:118 +1487:0:3993 +1488:1:120 +1489:0:3991 +1490:1:19 +1491:0:3997 +1492:1:1040 +1493:1:1041 +1494:1:1045 +1495:1:1046 +1496:1:1054 +1497:1:1055 +1498:1:1056 +1499:1:1068 +1500:1:1073 +1501:1:1077 +1502:1:1078 +1503:1:1086 +1504:1:1087 +1505:1:1091 +1506:1:1092 +1507:1:1086 +1508:1:1087 +1509:1:1091 +1510:1:1092 +1511:1:1100 +1512:1:1105 +1513:1:1112 +1514:1:1113 +1515:1:1120 +1516:1:1125 +1517:1:1132 +1518:1:1133 +1519:1:1132 +1520:1:1133 +1521:1:1140 +1522:0:3997 +1523:1:15 +1524:0:3997 +1525:1:16 +1526:0:3997 +1527:2:3261 +1528:2:3262 +1529:2:3263 +1530:2:3275 +1531:2:3276 +1532:2:3280 +1533:2:3281 +1534:2:3289 +1535:2:3294 +1536:2:3298 +1537:2:3299 +1538:2:3307 +1539:2:3308 +1540:2:3312 +1541:2:3313 +1542:2:3307 +1543:2:3308 +1544:2:3312 +1545:2:3313 +1546:2:3321 +1547:2:3326 +1548:2:3333 +1549:2:3334 +1550:2:3341 +1551:2:3346 +1552:2:3353 +1553:2:3354 +1554:2:3353 +1555:2:3354 +1556:2:3361 +1557:2:3371 +1558:0:3997 +1559:2:2521 +-1:-1:-1 +1560:0:3997 +1561:2:3377 +1562:2:3378 +1563:2:3382 +1564:2:3383 +1565:2:3391 +1566:2:3392 +1567:2:3396 +1568:2:3397 +1569:2:3405 +1570:2:3410 +1571:2:3414 +1572:2:3415 +1573:2:3423 +1574:2:3424 +1575:2:3428 +1576:2:3429 +1577:2:3423 +1578:2:3424 +1579:2:3428 +1580:2:3429 +1581:2:3437 +1582:2:3442 +1583:2:3449 +1584:2:3450 +1585:2:3457 +1586:2:3462 +1587:2:3469 +1588:2:3470 +1589:2:3469 +1590:2:3470 +1591:2:3477 +1592:0:3997 +1593:2:2521 +1594:0:3997 +1595:2:3261 +1596:2:3262 +1597:2:3266 +1598:2:3267 +1599:2:3275 +1600:2:3276 +1601:2:3280 +1602:2:3281 +1603:2:3289 +1604:2:3294 +1605:2:3298 +1606:2:3299 +1607:2:3307 +1608:2:3308 +1609:2:3312 +1610:2:3313 +1611:2:3307 +1612:2:3308 +1613:2:3312 +1614:2:3313 +1615:2:3321 +1616:2:3326 +1617:2:3333 +1618:2:3334 +1619:2:3341 +1620:2:3346 +1621:2:3353 +1622:2:3354 +1623:2:3353 +1624:2:3354 +1625:2:3361 +1626:2:3371 +1627:0:3997 +1628:2:2521 +1629:0:3997 +1630:2:3377 +1631:2:3378 +1632:2:3382 +1633:2:3383 +1634:2:3391 +1635:2:3392 +1636:2:3396 +1637:2:3397 +1638:2:3405 +1639:2:3410 +1640:2:3414 +1641:2:3415 +1642:2:3423 +1643:2:3424 +1644:2:3428 +1645:2:3429 +1646:2:3423 +1647:2:3424 +1648:2:3428 +1649:2:3429 +1650:2:3437 +1651:2:3442 +1652:2:3449 +1653:2:3450 +1654:2:3457 +1655:2:3462 +1656:2:3469 +1657:2:3470 +1658:2:3469 +1659:2:3470 +1660:2:3477 +1661:0:3997 +1662:2:2521 +1663:0:3997 +1664:2:3261 +1665:2:3262 +1666:2:3266 +1667:2:3267 +1668:2:3275 +1669:2:3276 +1670:2:3280 +1671:2:3281 +1672:2:3289 +1673:2:3294 +1674:2:3298 +1675:2:3299 +1676:2:3307 +1677:2:3308 +1678:2:3312 +1679:2:3313 +1680:2:3307 +1681:2:3308 +1682:2:3312 +1683:2:3313 +1684:2:3321 +1685:2:3326 +1686:2:3333 +1687:2:3334 +1688:2:3341 +1689:2:3346 +1690:2:3353 +1691:2:3354 +1692:2:3353 +1693:2:3354 +1694:2:3361 +1695:2:3371 +1696:0:3997 +1697:2:2521 -- 2.34.1