Spin/Man/spin.10000644000175100017510000002730312346732316011331 0ustar ghgh.ds Z S\s-2PIN\s0 .ds P P\s-2ROMELA\s0 .\" .\" On CYGWIN move this page to c:/cygwin/usr/man/man1/spin.1 .\" .TH SPIN 1 .CT 1 comm_mach protocol .SH NAME .br Spin \(mi verification of multithreaded systems .SH SYNOPSIS .B spin .BI -V .br .B spin [ options ] .I file .SH DESCRIPTION \*Z is a tool for analyzing the logical consistency of asynchronous systems, specifically distributed software, multi-threaded systems, and communication protocols. A model of the system is specified in a guarded command language called Promela (process meta language). This modeling language supports dynamic creation of processes, nondeterministic case selection, loops, gotos, local and global variables. It also allows for a concise specification of logical correctness requirements, including, but not restricted to requirements expressed in linear temporal logic. .PP Given a Promela model stored in .I file , \*Z can perform interactive, guided, or random simulations of the system's execution. It can also generate a C program that performs an exhaustive verification of the correctness requirements for the system. The main options supported are as follows. (You can always get a full list of current options with the command "spin --". .\"----------------------a---------------- .TP .B -a Generate a verifier (a model checker) for the specification. The output is written into a set of C files named .BR pan. [ cbhmt ], that can be compiled .RB ( "cc -o pan pan.c" ) to produce an executable verifier. The online \*Z manuals contain the details on compilation and use of the verifiers. .\"--------------------------b------------ .TP .B -b Do not execute printf statements in a simulation run. .\"--------------------------c------------ .TP .B -c Produce an ASCII approximation of a message sequence chart for a random or guided (when combined with \f3-t\f1) simulation run. See also option \f3-M\f1. .\"--------------------------D------------ .TP .BI -Dxxx Pass \f2-Dxxx\f1 to the preprocessor (see also \f2-E\f1 and \f2-I\f1). .\"--------------------------d------------ .TP .BI -d Produce symbol table information for the model specified in .I file. For each Promela object this information includes the type, name and number of elements (if declared as an array), the initial value (if a data object) or size (if a message channel), the scope (global or local), and whether the object is declared as a variable or as a parameter. For message channels, the data types of the message fields are listed. For structure variables, the 3rd field defines the name of the structure declaration that contains the variable. .\"--------------------------E------------ .TP .BI -Exxx Pass \f2xxx\f1 to the preprocessor (see also \f2-D\f1 and \f2-I\f1). .\"--------------------------e------------ .TP .BI -e If the specification contains multiple never claims, or ltl properties, compute the synchronous product of all claims and write the result to the standard output. .\"--------------------------f------------ .TP .BI "-f \f2LTL\f1" Translate the LTL formula \f2LTL\f1 into a never claim. .br This option reads a formula in LTL syntax from the second argument and translates it into Promela syntax (a never claim, qhich is Promela's equivalent of a B\(u"chi Automaton). The LTL operators are written: [] (always), <> (eventually), and U (strong until). There is no X (next) operator, to secure compatibility with the partial order reduction rules that are applied during the verification process. If the formula contains spaces, it should be quoted to form a single argument to the \*Z command. .br This option has largely been replaced with the support for inline specification of ltl formula, in Spin version 6.0. .\"--------------------------F------------ .TP .BI "-F \f2file\f1" Translate the LTL formula stored in .I file into a never claim. .br This behaves identical to option .B -f but will read the formula from the .I file instead of from the command line. The file should contain the formula as the first line. Any text that follows this first line is ignored, so it can be used to store comments or annotation on the formula. (On some systems the quoting conventions of the shell complicate the use of option .B -f . Option .B -F is meant to solve those problems.) .\"--------------------------g------------ .TP .BI -g In combination with option .BR -p , print all global variable updates in a simulation run. .\"--------------------------h------------ .TP .BI -h At the end of a simulation run, print the value of the seed that was used for the random number generator. By specifying the same seed with the \f3-n\f1 option, the exact run can be repeated later. .\"--------------------------I------------ .TP .BI -I Show the result of inlining and preprocessing. .\"--------------------------i------------ .TP .BI -i Perform an interactive simulation, prompting the user at every execution step that requires a nondeterministic choice to be made. The simulation proceeds without user intervention when execution is deterministic. .\"--------------------------j------------ .TP .BI -j\f2N Skip printing for the first \f2N\f1 steps in a simulation run. .\"--------------------------J------------ .TP .BI -J Reverse the evaluation order for nested unless statements, e.g., to match the way in which Java handles exceptions. .\"--------------------------k------------ .TP .BI "-k \f2file\f1" Use the file name \f2file\f1 as the trail-file, see also \f3-t\f1. .\"--------------------------l------------ .TP .BI -l In combination with option .BR -p , include all local variable updates in the output of a simulation run. .\"--------------------------M------------ .TP .BI -M Produce a message sequence chart in tcl/tk form for a random simulation or a guided simulation (when combined with \f(BI-t\f1), for the model in .I file , and display the result with wish. See also option \f3-c\f1. .\"--------------------------m------------ .TP .BI -m Changes the semantics of send events. Ordinarily, a send action will be (blocked) if the target message buffer is full. With this option a message sent to a full buffer is lost. .\"--------------------------n------------ .TP .BI "-n\f2N" Set the seed for a random simulation to the integer value .I N . There is no space between the \f(BI-n\f1 and the integer \f2N\f1. .\"--------------------------N------------ ,TP .BI "-N \f2file\f1" Use the never claim stored in \f2file\f1 to generate the verified (see \f3-a\f1). .\"--------------------------O------------ .TP .BI -O Use the original scope rules from pre-Spin version 6. .\"--------------------------o------------ .TP .BI -o\f2[123]\f1 Turn off data-flow optimization (\f2-o1\f1). Do not hide write-only variables (\f2-o2\f1) during verification. Turn off statement merging (\f2-o3\f1) during verification. Turn on rendezvous optimization (\f2-o4\f1) during verification. Turn on case caching (\f2-o5\f1) to reduce the size of pan.m, but losing accuracy in reachability reports. .\"--------------------------O------------ .TP .BI -O Use the scope rules pre-version 6.0. In this case there are only two possible levels of scope for all data declarations: global, or proctype local. In version 6.0 and later there is a third level of scope: inlines or blocks. .\"--------------------------P------------ .TP .BI -P\f2xxx\f1 Use the command \f2xxx\f1 for preprocessing instead of the standard C preprocessor. .\"--------------------------p------------ .TP .BI -p Include all statement executions in the output of simulation runs. .\"--------------------------q------------ .TP .BI "-q\f2N\f1" Suppress the output generated for channel \f2N\f1 during simulation runs. .\"--------------------------r------------ .TP .BI -r Show all message-receive events, giving the name and number of the receiving process and the corresponding the source line number. For each message parameter, show the message type and the message channel number and name. .TP .BR -replay Replay an error trace found in an earlier verification (see -search). As with -search, arguments meant for Spin itself (e.g., -p) can be given \f2before\f1 the -replay argument. If the replay can only be done with the ./pan executable, then arguments for the replay with the ./pan executable can be given \f2after\f1 the -replay argument. .TP .BR -search Compile and run directly. Verificaiton compile-time and runtime flags can be added \f2after\f1 this parameter. Any Spin parse-time parameters must come \f2before\f1 the -search parameter. The actual command line executed is printed if -v is specified (before the -search argument). .\"--------------------------s------------ .TP .BI -s Include all send operations in the output of simulation runs. .\"--------------------------T------------ .TP .BI -T Do not automatically indent the printf output of process \f2i\f1 with \f2i\f1 tabs. .\"--------------------------t------------ .TP .BI -t[\f2N\f1] Perform a guided simulation, following the [\f2N\f1th] error trail that was produces by an earlier verification run, see the online manuals for the details on verification. By default the error trail is looked for in a file with the same basename as the model, and with extension .trail. See also \f3-k\f1. .\"--------------------------v------------ .TP .BI -v Verbose mode, add some more detail, and generate more hints and warnings about the model. .\"--------------------------V------------ .TP .BI -V Print the \*Z version number and exit. .\"--------------------------x------------ .TP .BI -x Generate transition tables from model and exit (generates, compiles, and runs pan.c). .\"--------------------------.------------ .PP With only a filename as an argument and no option flags, \*Z performs a random simulation of the model specified in the file. This normally does not generate output, except what is generated explicitly by the user within the model with \f2printf\f1 statements, and some details about the final state that is reached after the simulation completes. The group of options .B -bgilmprstv is used to set the desired level of information that the user wants about a random, guided, or interactive simulation run. Every line of output normally contains a reference to the source line in the specification that generated it. If option .B -i is included, the simulation is \f2interactive\f1, or if option .B -t or .B -k \f2file\f1 is added, the simulation is \f2guided\f1. .\"--------------------------bglprsv------------ .TP .BI -b Suppress the execution of \f(CWprintf\f1 statements within the model. .TP .BI -g Show at each time step the current value of global variables. .TP .BI -l In combination with option .BR -p , show the current value of local variables of the process. .TP .BI -p Show at each simulation step which process changed state, and what source statement was executed. .TP .BI -r Show all message-receive events, giving the name and number of the receiving process and the corresponding the source line number. For each message parameter, show the message type and the message channel number and name. .TP .BI -s Show all message-send events. .TP .BI -v Verbose mode, add some more detail, and generat more hints and warnings about the model. .SH SEE ALSO Online manuals at spinroot.com: .br .in +4 http://spinroot.com/spin/Man/3_SpinGUI.html .br http://spinroot.com/spin/Man/4_SpinVerification.html .br http://spinroot.com/spin/Man/1_Exercises.html .in -4 More background information on the system and the verification process, can be found in, for instance: .br .in +4 .br G.J. Holzmann, \f2The Spin Model Checker \(um Primer and Reference Manual\f1, Addison-Wesley, Reading, Mass., 2004. .br --, `The model checker \*Z,' \f2IEEE Trans. on SE\f1, Vol, 23, No. 5, May 1997. .br --, `Design and validation of protocols: a tutorial,' \f2Computer Networks and ISDN Systems\f1, Vol. 25, No. 9, 1993, pp. 981-1017. .br --, \f2Design and Validation of Computer Protocols\f1, Prentice Hall, Englewood Cliffs, NJ, 1991. .in -4 .br Spin/Examples/0000755000175100017510000000000012636050526011332 5ustar ghghSpin/Examples/wordcount.pml0000644000175100017510000000144311676656751014111 0ustar ghgh/* Example of property-based slicing. Try: spin -A wordcount Requires Spin version 3.4 or later */ chan STDIN; int c, nl, nw, nc; init { bool inword = false; do :: STDIN?c -> if :: c == -1 -> break /* EOF */ :: c == '\n' -> nc++; nl++ :: else -> nc++ fi; if :: c == ' ' || c == '\t' || c == '\n' -> inword = false :: else -> if :: !inword -> nw++; inword = true :: else /* do nothing */ fi fi od; assert(nc >= nl); printf("%d\t%d\t%d\n", nl, nw, nc) } Spin/Examples/for_example.pml0000644000175100017510000000046312330776652014356 0ustar ghghtypedef m { bool b; int i; chan c; } init { m foo; chan x = [8] of { m }; int i; foo.b = true; foo.i = 12; foo.c = x; x!foo; foo.b = false; foo.i = 10; foo.c = 0; x!foo; x!foo; i = 1; for (foo in x) { printf("%d: %d %d %d (len(x)=%d)\n", i, foo.b, foo.i, foo.c, len(x)); i++ } } Spin/Examples/snoopy.pml0000644000175100017510000001163511676656751013420 0ustar ghgh/* Snooping cache algorithm * used in a study at Bell Labs in the early eighties, and * said to be based on Goodman's work. Compare for instance: * "Using cache memory to reduce processor memory traffic", * by J.R. Goodman, Proc. 10th Int. Symp. on Computer Architecture, * June 1983, pp. 124-131. */ #define QSZ 2 mtype = { r, w, raw, RD, WR, RX, MX, MXdone, req0, req1, CtoB, BtoC, grant, done }; chan tocpu0 = [QSZ] of { mtype }; chan fromcpu0 = [QSZ] of { mtype }; chan tobus0 = [QSZ] of { mtype }; chan frombus0 = [QSZ] of { mtype }; chan grant0 = [QSZ] of { mtype }; chan tocpu1 = [QSZ] of { mtype }; chan fromcpu1 = [QSZ] of { mtype }; chan tobus1 = [QSZ] of { mtype }; chan frombus1 = [QSZ] of { mtype }; chan grant1 = [QSZ] of { mtype }; chan claim0 = [QSZ] of { mtype }; chan claim1 = [QSZ] of { mtype }; chan release0 = [QSZ] of { mtype }; chan release1 = [QSZ] of { mtype }; #define W 1 #define R 2 #define X 3 proctype cpu0() { xs fromcpu0; xr tocpu0; do :: fromcpu0!r -> tocpu0?done :: fromcpu0!w -> tocpu0?done :: fromcpu0!raw -> tocpu0?done od } proctype cpu1() { xs fromcpu1; xr tocpu1; do :: fromcpu1!r -> tocpu1?done :: fromcpu1!w -> tocpu1?done :: fromcpu1!raw -> tocpu1?done od } proctype cache0() { byte state = X; byte which; xr frombus0; xr fromcpu0; xs tocpu0; xs tobus0; xr grant0; xs claim0; xs release0; resume: do :: frombus0?RD -> if :: (state == W) -> state = R; tobus0!CtoB :: (state != W) -> tobus0!done fi :: frombus0?MX -> state = X; tobus0!MXdone :: frombus0?RX -> if :: (state == W) -> state = X; tobus0!CtoB :: (state == R) -> state = X; tobus0!done :: (state == X) -> tobus0!done fi :: fromcpu0?r -> if :: (state != X) -> tocpu0!done :: (state == X) -> which = RD; goto buscycle fi :: fromcpu0?w -> if :: (state == W) -> tocpu0!done :: (state != W) -> which = MX; goto buscycle fi :: fromcpu0?raw -> if :: (state == W) -> tocpu0!done :: (state != W) -> which = RX; goto buscycle fi od; buscycle: claim0!req0; do :: frombus0?RD -> if :: (state == W) -> state = R; tobus0!CtoB :: (state != W) -> tobus0!done fi :: frombus0?MX -> state = X; tobus0!MXdone :: frombus0?RX -> if :: (state == W) -> state = X; tobus0!CtoB :: (state == R) -> state = X; tobus0!done :: (state == X) -> tobus0!done fi :: grant0?grant -> if :: (which == RD) -> state = R :: (which == MX) -> state = W :: (which == RX) -> state = W fi; tocpu0!done; break od; release0!done; if :: (which == RD) -> tobus0!RD -> frombus0?BtoC :: (which == MX) -> tobus0!MX -> frombus0?done :: (which == RX) -> tobus0!RX -> frombus0?BtoC fi; goto resume } proctype cache1() { byte state = X; byte which; xr frombus1; xr fromcpu1; xs tobus1; xs tocpu1; xr grant1; xs claim1; xs release1; resume: do :: frombus1?RD -> if :: (state == W) -> state = R; tobus1!CtoB :: (state != W) -> tobus1!done fi :: frombus1?MX -> state = X; tobus1!MXdone :: frombus1?RX -> if :: (state == W) -> state = X; tobus1!CtoB :: (state == R) -> state = X; tobus1!done :: (state == X) -> tobus1!done fi :: fromcpu1?r -> if :: (state != X) -> tocpu1!done :: (state == X) -> which = RD; goto buscycle fi :: fromcpu1?w -> if :: (state == W) -> tocpu1!done :: (state != W) -> which = MX; goto buscycle fi :: fromcpu1?raw -> if :: (state == W) -> tocpu1!done :: (state != W) -> which = RX; goto buscycle fi od; buscycle: claim1!req1; do :: frombus1?RD -> if :: (state == W) -> state = R; tobus1!CtoB :: (state != W) -> tobus1!done fi :: frombus1?MX -> state = X; tobus1!MXdone :: frombus1?RX -> if :: (state == W) -> state = X; tobus1!CtoB :: (state == R) -> state = X; tobus1!done :: (state == X) -> tobus1!done fi :: grant1?grant -> if :: (which == RD) -> state = R :: (which == MX) -> state = W :: (which == RX) -> state = W fi; tocpu1!done; break od; release1!done; if :: (which == RD) -> tobus1!RD -> frombus1?BtoC :: (which == MX) -> tobus1!MX -> frombus1?done :: (which == RX) -> tobus1!RX -> frombus1?BtoC fi; goto resume } proctype busarbiter() { xs grant0; xs grant1; xr claim0; xr claim1; xr release0; xr release1; do :: claim0?req0 -> grant0!grant; release0?done :: claim1?req1 -> grant1!grant; release1?done od } proctype bus() /* models real bus + main memory */ { xs frombus1; xs frombus0; xr tobus0; xr tobus1; do :: tobus0?CtoB -> frombus1!BtoC :: tobus1?CtoB -> frombus0!BtoC :: tobus0?done -> /* M -> B */ frombus1!BtoC :: tobus1?done -> /* M -> B */ frombus0!BtoC :: tobus0?MXdone -> /* B -> M */ frombus1!done :: tobus1?MXdone -> /* B -> M */ frombus0!done :: tobus0?RD -> frombus1!RD :: tobus1?RD -> frombus0!RD :: tobus0?MX -> frombus1!MX :: tobus1?MX -> frombus0!MX :: tobus0?RX -> frombus1!RX :: tobus1?RX -> frombus0!RX od } init { atomic { run cpu0(); run cpu1(); run cache0(); run cache1(); run bus(); run busarbiter() } } Spin/Examples/rtos1.pml0000644000175100017510000000121612331237000013076 0ustar ghghbyte cnt; /* the use of 'priority' tags enforces priority based scheduling it can be combined freely with provided clauses as well to finetune the scheduling choices */ active proctype medium() priority 5 { set_priority(0, 8); printf("medium %d - pid %d pr %d pr1 %d\n", _priority, _pid, get_priority(_pid), get_priority(0)); cnt++ } active proctype high() priority 10 { _priority = 9; printf("high %d\n", _priority); cnt++ } active proctype low() priority 1 { /* * can only execute if this is the highest * priority process with executable statements */ assert(_priority == 1 && cnt == 2); printf("low %d\n", _priority); } Spin/Examples/sort.pml0000644000175100017510000000300311676656751013046 0ustar ghgh/* * A program to sort concurrently N "random" numbers * The reduced space and time should be linear in the * number of processes, and can be reduced when the length of * the buffer queues is increased. * In full search it should be exponential. */ #define N 7 /* Number of Proc */ #define L 10 /* Size of buffer queues */ #define RANDOM (seed * 3 + 14) % 100 /* Calculate "random" number */ chan q[N] = [L] of {byte}; proctype left(chan out) /* leftmost process, generates random numbers */ { byte counter, seed; xs out; counter = 0; seed = 15; do :: out!seed -> /* output value to the right */ counter = counter + 1; if :: counter == N -> break :: counter != N -> skip fi; seed = RANDOM /* next "random" number */ od } proctype middle(chan inp, out; byte procnum) { byte counter, myval, nextval; xs out; xr inp; counter = N - procnum; inp?myval; /* get first value from the left */ do :: counter > 0 -> inp?nextval; /* upon receipt of a new value */ if :: nextval >= myval -> out!nextval :: nextval < myval -> out!myval; myval=nextval /* send bigger, hold smaller */ fi; counter = counter - 1 :: counter == 0 -> break od } proctype right(chan inp) /* rightmost channel */ { byte biggest; xr inp; inp?biggest /* accepts only one value, which is the biggest */ } init { byte proc=1; atomic { run left ( q[0] ); do :: proc < N -> run middle ( q[proc-1] , q[proc], proc ); proc = proc+1 :: proc == N -> break od; run right ( q[N-1] ) } } Spin/Examples/leader_trace.pml0000644000175100017510000000314411676656750014476 0ustar ghgh/* Dolev, Klawe & Rodeh for leader election in unidirectional ring * `An O(n log n) unidirectional distributed algorithm for extrema * finding in a circle,' J. of Algs, Vol 3. (1982), pp. 245-260 */ #define N 5 /* nr of processes (use 5 for demos) */ #define I 3 /* node given the smallest number */ #define L 10 /* size of buffer (>= 2*N) */ mtype = { one, two, winner }; chan q[N] = [L] of { mtype, byte}; byte nr_leaders = 0; notrace { do :: q[0]?one,_ :: q[0]?two,_ -> break od; do :: q[0]?two,_ :: q[0]?winner,_ -> break od } proctype node (chan inp, out; byte mynumber) { bit Active = 1, know_winner = 0; byte nr, maximum = mynumber, neighbourR; xr inp; xs out; printf("MSC: %d\n", mynumber); out!one(mynumber); end: do :: inp?one(nr) -> if :: Active -> if :: nr != maximum -> out!two(nr); neighbourR = nr :: else -> /* Raynal p.39: max is greatest number */ assert(nr == N); know_winner = 1; out!winner,nr; fi :: else -> out!one(nr) fi :: inp?two(nr) -> if :: Active -> if :: neighbourR > nr && neighbourR > maximum -> maximum = neighbourR; out!one(neighbourR) :: else -> Active = 0 fi :: else -> out!two(nr) fi :: inp?winner,nr -> if :: nr != mynumber -> printf("MSC: LOST\n"); :: else -> printf("MSC: LEADER\n"); nr_leaders++; assert(nr_leaders == 1) fi; if :: know_winner :: else -> out!winner,nr fi; break od } init { byte proc; atomic { proc = 1; do :: proc <= N -> run node (q[proc-1], q[proc%N], (N+I-proc)%N+1); proc++ :: proc > N -> break od } } Spin/Examples/priorities.pml0000644000175100017510000000044411676656751014256 0ustar ghgh/* test execution priorities run this as: spin -p -g priorities requires Spin Version 2.5 or later */ int a[5]; proctype A() { do :: printf("%d\n", _pid); a[_pid]++ od } init { atomic { run A() priority 1; run A() priority 2; run A() priority 3; run A() priority 4; } } Spin/Examples/loops.pml0000644000175100017510000000020711676656750013215 0ustar ghghactive proctype loop() { byte a, b; do :: a = (a+1)%3; if :: b = 2*a; skip :: b = 2*a; accept: skip fi; progress: b-- od } Spin/Examples/pan.c0000664000175100017510000117731112636050452012267 0ustar ghgh/*** Generated by Spin Version 6.4.5 -- 4 November 2015 ***/ /*** From source: loops.pml ***/ #ifdef SC #define _FILE_OFFSET_BITS 64 #endif #include #include #include #include #include #include #include #if defined(WIN32) || defined(WIN64) #include #else #include #include #endif #include #include #include #include #define Offsetof(X, Y) ((ulong)(&(((X *)0)->Y))) #ifndef max #define max(a,b) (((a)<(b)) ? (b) : (a)) #endif #ifndef PRINTF int Printf(const char *fmt, ...); /* prototype only */ #endif #include "pan.h" char *TrailFile = PanSource; /* default */ char *trailfilename; #ifdef LOOPSTATE double cnt_loops; #endif State A_Root; /* seed-state for cycles */ State now; /* the full state-vector */ #if NQS > 0 short q_flds[NQS+1]; short q_max[NQS+1]; #endif #undef C_States #if defined(C_States) && (HAS_TRACK==1) void c_update(uchar *p_t_r) { #ifdef VERBOSE printf("c_update %p\n", p_t_r); #endif } void c_revert(uchar *p_t_r) { #ifdef VERBOSE printf("c_revert %p\n", p_t_r); #endif } #endif void globinit(void) { } #if VECTORSZ>32000 extern int #else extern short #endif *proc_offset, *q_offset; void locinit0(int h) { } #ifdef RANDOMIZE #define T_RAND RANDOMIZE #endif #ifdef CNTRSTACK #define onstack_now() (LL[trpt->j6] && LL[trpt->j7]) #define onstack_put() LL[trpt->j6]++; LL[trpt->j7]++ #define onstack_zap() LL[trpt->j6]--; LL[trpt->j7]-- #endif #if !defined(SAFETY) && !defined(NOCOMP) #define V_A (((now._a_t&1)?2:1) << (now._a_t&2)) #define A_V (((now._a_t&1)?1:2) << (now._a_t&2)) int S_A = 0; #else #define V_A 0 #define A_V 0 #define S_A 0 #endif #ifdef MA #undef onstack_now #undef onstack_put #undef onstack_zap #define onstack_put() ; #define onstack_zap() g_store((char *) &now, vsize, 4) #else #if defined(FULLSTACK) && !defined(BITSTATE) #define onstack_put() trpt->ostate = Lstate #define onstack_zap() { \ if (trpt->ostate) \ trpt->ostate->tagged = \ (S_A)? (trpt->ostate->tagged&~V_A) : 0; \ } #endif #endif H_el **H_tab, **S_Tab; /* #ifndef BFS_PAR */ H_el *Lstate; /* #endif */ Trail *trail, *trpt; FILE *efd; uchar *this; long maxdepth=10000; long omaxdepth=10000; #ifdef BCS /* bitflags in trpt->bcs */ #define B_PHASE1 1 #define B_PHASE2 2 #define B_FORCED 4 int sched_max = 0; #endif double quota; /* time limit */ #if NCORE>1 long z_handoff = -1; #endif #ifdef SC char *stackfile; #endif uchar *SS, *LL; uchar reversing = 0; uchar HASH_NR = 0; double memcnt = (double) 0; double memlim = (double) (1<<30); /* 1 GB */ #if NCORE>1 double mem_reserved = (double) 0; #endif /* for emalloc: */ static char *have; static long left = 0L; static double fragment = (double) 0; static ulong grow; unsigned int HASH_CONST[] = { /* generated by hashgen 421 -- assumes 4 bytes per int */ 0x100d4e63, 0x0fc22f87, 0xa7155c77, 0x78f2c3b9, 0xde32d207, 0xc27d305b, 0x1bb3fb2b, 0x2798c7a5, 0x9c675ffd, 0x777d9081, 0x07aef2f1, 0xae08922f, 0x5bd365b7, 0xed51c47b, 0x9b5aeea1, 0xbcc9d431, 0x396d8fff, 0xa2fd1367, 0x08616521, 0x5e84991f, 0x87495bc5, 0x2930039b, 0xceb6a593, 0xfe522d63, 0x7ff60baf, 0xf89b1fbf, 0x74c01755, 0xe0c559bf, 0x3669fc47, 0x8756d3bf, 0x14f78445, 0x24c41779, 0x0af7b129, 0xde22368d, 0x3e1c01e3, 0xaf773e49, 0x5b762459, 0x86d12911, 0x0953a3af, 0xb66dc23d, 0x96b3bd4f, 0x19b1dd51, 0xd886fbc3, 0xa7f3a025, 0xccb48e63, 0x87d8f027, 0x2bea270d, 0xdb0e9379, 0x78c09f21, 0x0cbbfe07, 0xea4bc7c3, 0x5bfbc3c9, 0x3c6e53fd, 0xab320cdd, 0x31041409, 0x416e7485, 0xe41d75fd, 0xc3c5060f, 0x201a9dc1, 0x93dee72b, 0x6461305f, 0xc571dec5, 0xa1fd21c5, 0xfb421ce1, 0x7f024b05, 0xfa518819, 0x6c9777fb, 0x0d4d9351, 0x08b33861, 0xccb9d0f3, 0x34112791, 0xe962d7c9, 0x8d742211, 0xcd9c47a1, 0x64437b69, 0x5fe40feb, 0x806113cb, 0x10e1d593, 0x821851b3, 0x057a1ff3, 0x8ededc0b, 0x90dd5b31, 0x635ff359, 0x68dbcd35, 0x1050ff4f, 0xdbb07257, 0x486336db, 0x83af1e75, 0x432f1799, 0xc1d0e7e7, 0x21f4eb5b, 0x881ec2c1, 0x23f3b539, 0x6cdfb80d, 0x71d474cf, 0x97d5d4a9, 0xf721d2e5, 0xb5ff3711, 0x3f2e58cd, 0x4e06e3d9, 0x7d711739, 0x927887df, 0x7d57ad71, 0x232eb767, 0xe3f5cc51, 0x6576b443, 0xed17bf1f, 0x8828b637, 0xc940f6ab, 0xc7b830ef, 0x11ed8a13, 0xaff20949, 0xf28a8465, 0x0da10cf9, 0xb512497d, 0x44accae1, 0x95e0929f, 0xe08c8901, 0xfd22d6c9, 0xb6a5c029, 0xaadb428d, 0x6e8a453d, 0x3d5c0195, 0x8bf4ae39, 0xbf83ab19, 0x3e9dac33, 0xc4df075d, 0x39472d71, 0xb8647725, 0x1a6d4887, 0x78a03577, 0xafd76ef7, 0xc1a1d6b3, 0x1afb33c5, 0x87896299, 0x5cc992ef, 0x7f805d0d, 0x089a039b, 0xa353cc27, 0x57b296b3, 0x52badec9, 0xc916e431, 0x09171957, 0x14996d51, 0xe87e32c7, 0xb4fdbb5d, 0xdd216a03, 0x4ddd3fff, 0x767d5c57, 0x79c97509, 0xab70543b, 0xc5feca4f, 0x8eb37b89, 0x20a2cefd, 0xf4b00b91, 0xf166593d, 0x7bf50f65, 0x753e6c8b, 0xfb5b81dd, 0xf2d45ef5, 0x9741c04f, 0x300da48d, 0x01dc4121, 0xa112cd47, 0x0223b24b, 0xa89fbce7, 0x681e1f7b, 0xe7c6aedf, 0x1fd3d523, 0x561ba723, 0xf54042fb, 0x1a516751, 0xcd085bd5, 0xe74246d5, 0x8b170b5d, 0x249985e9, 0x5b4d9cf7, 0xe9912323, 0x5fc0f339, 0x41f8f051, 0x8a296fb1, 0x62909f51, 0x2c05d695, 0x095efccb, 0xa91574f1, 0x0f5cc6c3, 0x23a2ca2b, 0xc6053ec1, 0xeb19e081, 0x3d1b3997, 0xb0c5f3cd, 0xe5d85b35, 0x1cb1bdf1, 0x0c8f278f, 0x518249c3, 0x9f61b68d, 0xade0919d, 0x779e29c3, 0xdbac9485, 0x2ce149a9, 0x254c2409, 0x205b34fb, 0xc8ab1a89, 0x6b4a2585, 0x2303d94b, 0x8fa186b9, 0x49826da5, 0xd23a37ad, 0x680b18c9, 0xa46fbd7f, 0xe42c2cf9, 0xf7cfcb5f, 0xb4842b8b, 0xe483780d, 0x66cf756b, 0x3eb73781, 0x41ca17a5, 0x59f91b0f, 0x92fb67d9, 0x0a5c330f, 0x46013fdb, 0x3b0634af, 0x9024f533, 0x96a001a7, 0x15bcd793, 0x3a311fb1, 0x78913b8b, 0x9d4a5ddf, 0x33189b31, 0xa99e8283, 0xf7cb29e9, 0x12d64a27, 0xeda770ff, 0xa7320297, 0xbd3c14a5, 0x96d0156f, 0x0115db95, 0x7f79f52b, 0xa6d52521, 0xa063d4bd, 0x9cb5e039, 0x42cf8195, 0xcb716835, 0x1bc21273, 0x5a67ad27, 0x4b3b0545, 0x162cda67, 0x0489166b, 0x85fd06a9, 0x562b037d, 0x995bc1f3, 0xe144e78b, 0x1e749f69, 0xa36df057, 0xcfee1667, 0x8c4116b7, 0x94647fe3, 0xe6899df7, 0x6d218981, 0xf1069079, 0xd1851a33, 0xf424fc83, 0x24467005, 0xad8caf59, 0x1ae5da13, 0x497612f9, 0x10f6d1ef, 0xeaf4ff05, 0x405f030b, 0x693b041d, 0x2065a645, 0x9fec71b3, 0xc3bd1b0f, 0xf29217a3, 0x0f25e15d, 0xd48c2b97, 0xce8acf2d, 0x0629489b, 0x1a5b0e01, 0x32d0c059, 0x2d3664bf, 0xc45f3833, 0xd57f551b, 0xbdd991c5, 0x9f97da9f, 0xa029c2a9, 0x5dd0cbdf, 0xe237ba41, 0x62bb0b59, 0x93e7d037, 0x7e495619, 0x51b8282f, 0x853e8ef3, 0x9b8abbeb, 0x055f66f9, 0x2736f7e5, 0x8d7e6353, 0x143abb65, 0x4e2bb5b3, 0x872e1adf, 0x8fcac853, 0xb7cf6e57, 0x12177f3d, 0x1d2da641, 0x07856425, 0xc0ed53dd, 0x252271d9, 0x79874843, 0x0aa8c9b5, 0x7e804f93, 0x2d080e09, 0x3929ddfd, 0x36433dbd, 0xd6568c17, 0xe624e939, 0xb33189ef, 0x29e68bff, 0x8aae2433, 0xe6335499, 0xc5facd9d, 0xbd5afc65, 0x7a584fa7, 0xab191435, 0x64bbdeef, 0x9f5cd8e1, 0xb3a1be05, 0xbd0c1753, 0xb00e2c7f, 0x6a96e315, 0x96a31589, 0x660af5af, 0xc0438d43, 0x17637373, 0x6460e8df, 0x7d458de9, 0xd76b923f, 0x316f045f, 0x3ccbd035, 0x63f64d81, 0xd990d969, 0x7c860a93, 0x99269ff7, 0x6fbcac8f, 0xd8cc562b, 0x67141071, 0x09f85ea3, 0x1298f2dd, 0x41fa86e5, 0xce1d7cf5, 0x6b232c9d, 0x8f093d4b, 0x3203ad4b, 0x07d70d5f, 0x38c44c75, 0x0887c9ef, 0x1833acf5, 0xa3607f85, 0x7d367573, 0x0ea4ffc3, 0xad2d09c1, 0x7a1e664f, 0xef41dff5, 0x03563491, 0x67f30a1f, 0x5ce5f9ef, 0xa2487a27, 0xe5077957, 0x9beb36fd, 0x16e41251, 0x216799ef, 0x07181f8d, 0xc191c3cf, 0xba21cab5, 0x73944eb7, 0xdf9eb69d, 0x5fef6cfd, 0xd750a6f5, 0x04f3fa43, 0x7cb2d063, 0xd3bdb369, 0x35f35981, 0x9f294633, 0x5e293517, 0x70e51d05, 0xf8db618d, 0x66ee05db, 0x835eaa77, 0x166a02c3, 0xb516f283, 0x94102293, 0x1ace50a5, 0x64072651, 0x66df7b75, 0x02e1b261, 0x8e6a73b9, 0x19dddfe7, 0xd551cf39, 0x391c17cb, 0xf4304de5, 0xcd67b8d1, 0x25873e8d, 0x115b4c71, 0x36e062f3, 0xaec0c7c9, 0xd929f79d, 0x935a661b, 0xda762b47, 0x170bd76b, 0x1a955cb5, 0x341fb0ef, 0x7f366cef, 0xc98f60c7, 0xa4181af3, 0xa94a8837, 0x5fa3bc43, 0x11c638c1, 0x4e66fabb, 0x30ab85cf, 0x250704ef, 0x8bf3bc07, 0x6d2cd5ab, 0x613ef9c3, 0xb8e62149, 0x0404fd91, 0xa04fd9b1, 0xa5e389eb, 0x9543bd23, 0xad6ca1f9, 0x210c49ab, 0xf8e9532b, 0x854fba89, 0xdc7fc6bb, 0x48a051a7, 0x6b2f383b, 0x61a4b433, 0xd3af231b, 0xc5023fc7, 0xa5aa85df, 0xa0cd1157, 0x4206f64d, 0x3fea31c3, 0x62d510a1, 0x13988957, 0x6a11a033, 0x46f2a3b7, 0x2784ef85, 0x229eb9eb, 0x9c0c3053, 0x5b7ead39, 0x82ae9afb, 0xf99e9fb3, 0x914b6459, 0xaf05edd7, 0xc82710dd, 0x8fc1ea1f, 0x7e0d7a8d, 0x7c7592e9, 0x65321017, 0xea57553f, 0x4aeb49ff, 0x5239ae4d, 0x4b4b4585, 0x94091c21, 0x7eaaf4cb, 0x6b489d6f, 0xecb9c0c3, 0x29a7af63, 0xaf117a0d, 0x969ea6cd, 0x7658a34d, 0x5fc0bba9, 0x26e99b7f, 0x7a6f260f, 0xe37c34f1, 0x1a1569bb, 0xc3bc7371, 0x8567543d, 0xad0c46a9, 0xa1264fd9, 0x16f10b29, 0x5e00dd3b, 0xf85b6bcd, 0xa2d32d8b, 0x4a3c8d43, 0x6b33b959, 0x4fd1e6c9, 0x7938b8a9, 0x1ec795c7, 0xe2ef3409, 0x83c16b9d, 0x0d3fd9eb, 0xeb461ad7, 0xb09c831d, 0xaf052001, 0x7911164d, 0x1a9dc191, 0xb52a0815, 0x0f732157, 0xc68c4831, 0x12cf3cbb }; #if NCORE>1 extern int core_id; #endif long mreached=0; int done=0, errors=0, Nrun=1; int c_init_done=0; char *c_stack_start = (char *) 0; double nstates=0, nlinks=0, truncs=0, truncs2=0; double nlost=0, nShadow=0, hcmp=0, ngrabs=0; #ifdef BFS_PAR extern ulong bfs_punt; #endif #ifdef PUTPID char *progname; #endif #if defined(ZAPH) && defined(BITSTATE) double zstates = 0; #endif /* int c_init_run; */ #ifdef REVERSE #define P_REVERSE #endif #ifdef T_REVERSE int t_reverse = 1; #else int t_reverse = 0; #endif #ifdef BFS double midrv=0, failedrv=0, revrv=0; #endif ulong nr_states=0; /* nodes in DFA */ long Fa=0, Fh=0, Zh=0, Zn=0; long PUT=0, PROBE=0, ZAPS=0; long Ccheck=0, Cholds=0; int a_cycles=0, upto=1, strict=0, verbose = 0, signoff = 0; #ifdef HAS_CODE int gui = 0, coltrace = 0, readtrail = 0; int whichtrail = 0, whichclaim = -1, onlyproc = -1, silent = 0; char *claimname; #endif int state_tables=0, fairness=0, no_rck=0, Nr_Trails=0, dodot=0; char simvals[256]; #ifndef INLINE int TstOnly=0; #endif ulong mask, nmask; #ifdef BITSTATE int ssize=27; /* 16 Mb */ #else int ssize=24; /* 16M slots */ #endif int hmax=0, svmax=0, smax=0; int Maxbody=0, XX; uchar *noptr, *noqptr; /* used by Pptr(x) and Qptr(x) */ #ifdef VAR_RANGES void logval(char *, int); void dumpranges(void); #endif #ifdef MA #define INLINE_REV extern void dfa_init(unsigned short); extern int dfa_member(ulong); extern int dfa_store(uchar *); unsigned int maxgs = 0; #endif #ifdef ALIGNED State comp_now __attribute__ ((aligned (8))); /* gcc 64-bit aligned for Itanium2 systems */ /* MAJOR runtime penalty if not used on those systems */ #else State comp_now; /* compressed state vector */ #endif #ifndef HC #ifdef BFS_PAR State tmp_msk; #endif State comp_msk; uchar *Mask = (uchar *) &comp_msk; #endif #ifdef COLLAPSE State comp_tmp; static char *scratch = (char *) &comp_tmp; #endif _Stack *stack; /* for queues, processes */ Svtack *svtack; /* for old state vectors */ #ifdef BITSTATE static unsigned int hfns = 3; /* new default */ #endif static ulong j1_spin, j2_spin; /* 5.2.1: avoid nameclash with math.h */ static ulong j3_spin, j4_spin; ulong K1, K2; #ifdef BITSTATE long udmem; #endif #ifndef BFS_PAR static long A_depth = 0; #endif long depth = 0; long depthfound = -1; /* loop detection */ #if NCORE>1 long nr_handoffs = 0; #endif uchar warned = 0, iterative = 0, exclusive = 0, like_java = 0, every_error = 0; uchar noasserts = 0, noends = 0, bounded = 0; uint s_rand = 12345; /* default seed */ #if SYNC>0 && ASYNC==0 void set_recvs(void); int no_recvs(int); #endif #if SYNC #define IfNotBlocked if (boq != -1) continue; #define UnBlock boq = -1 #else #define IfNotBlocked /* cannot block */ #define UnBlock /* don't bother */ #endif #ifdef BITSTATE int (*b_store)(char *, int); int bstore_reg(char *, int); int bstore_mod(char *, int); #endif void dfs_uerror(char *); void dfs_Uerror(char *); #ifdef BFS_PAR void bfs_uerror(char *); void bfs_Uerror(char *); #endif void (*uerror)(char *); void (*Uerror)(char *); void (*hasher)(uchar *, int); void (*o_hash)(uchar *, int, int); void d_hash(uchar *, int); void m_hash(uchar *, int); void d_sfh(uchar *, int); void o_hash32(uchar *, int, int); void o_hash64(uchar *, int, int); void active_procs(void); void cleanup(void); void do_the_search(void); void find_shorter(int); void iniglobals(int); void stopped(int); void wrapup(void); int *grab_ints(int); void ungrab_ints(int *, int); #ifdef COLLAPSE #if (NCORE>1 && !defined(SEP_STATE)) || defined(BFS_PAR) volatile ulong *ncomps; /* in shared memory */ #else ulong ncomps[256+2]; #endif #endif Trans ***trans; /* 1 ptr per state per proctype */ #if VECTORSZ>32000 int P_o[MAXPROC], P_o_tmp[MAXPROC+1]; int Q_o[MAXQ], Q_o_tmp[MAXPROC+1]; int *proc_offset = (int *) P_o; int *q_offset = (int *) Q_o; #else short P_o[MAXPROC], P_o_tmp[MAXPROC+1]; short Q_o[MAXQ], Q_o_tmp[MAXPROC+1]; short *proc_offset = (short *) P_o; short *q_offset = (short *) Q_o; #endif uchar P_s[MAXPROC+1], P_s_tmp[MAXPROC+1]; uchar Q_s[MAXQ+1], Q_s_tmp[MAXQ+1]; uchar *proc_skip = (uchar *) P_s; uchar *q_skip = (uchar *) Q_s; #ifdef TRIX TRIX_v6 *freebodies; TRIX_v6 *processes[MAXPROC+1]; TRIX_v6 *channels[MAXQ+1]; long _p_count[MAXPROC]; long _c_count[MAXPROC]; #endif ulong vsize; /* vector size in bytes */ #ifdef SVDUMP int vprefix=0, svfd; /* runtime option -pN */ #endif char *tprefix = "trail"; /* runtime option -tsuffix */ short boq = -1; /* blocked_on_queue status */ int _; /* predefined write-only variable */ #ifdef PEG long peg[NTRANS]; #endif #ifndef NOBOUNDCHECK #define Index(x, y) Boundcheck(x, y, II, tt, t) #else #define Index(x, y) x #endif short src_ln0 [] = { 0, 5, 7, 7, 8, 8, 6, 10, 10, 4, 12, 4, 12, 0, }; S_F_MAP src_file0 [] = { { "-", 0, 0 }, { "loops.pml", 1, 12 }, { "-", 13, 14 } }; uchar reached0 [] = { 0, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, }; uchar *loopstate0; uchar reached1[3]; /* np_ */ uchar *loopstate1; /* np_ */ struct { int tp; short *src; } src_all[] = { { 0, &src_ln0[0] }, { 0, (short *) 0 } }; S_F_MAP *flref[] = { src_file0 }; struct { char *c; char *t; } code_lookup[] = { { (char *) 0, "" } }; short Air[] = { (short) Air0, (short) Air1 }; char *procname[] = { "loop", ":np_:", 0 }; enum btypes { NONE=0, N_CLAIM=1, I_PROC=2, A_PROC=3, P_PROC=4, E_TRACE=5, N_TRACE=6 }; int Btypes[] = { 3, /* loop */ 0 /* :np_: */ }; uchar spin_c_typ[NCLAIMS]; /* claim-types */ uchar *accpstate[2]; uchar *progstate[2]; uchar *loopstate[2]; uchar *reached[2]; uchar *stopstate[2]; uchar *visstate[2]; short *mapstate[2]; #ifdef HAS_CODE int NrStates[2]; #endif #ifdef TRIX int what_p_size(int); int what_q_size(int); void re_mark_all(int whichway) { int j; #ifdef V_TRIX printf("%d: re_mark_all channels %d\n", depth, whichway); #endif #ifndef BFS for (j = 0; j < now._nr_qs; j++) channels[j]->modified = 1; /* channel index moved */ #endif #ifndef TRIX_ORIG if (whichway > 0) { for (j = now._nr_pr + now._nr_qs - 1; j >= now._nr_pr; j--) now._ids_[j] = now._ids_[j-1]; } else { for (j = now._nr_pr; j < now._nr_pr + now._nr_qs; j++) now._ids_[j] = now._ids_[j+1]; } #endif } #endif #ifdef BFS_PAR inline void bfs_prepmask(int caller) { #if !defined(NOCOMP) && !defined(HC) memcpy((char *) &tmp_msk, (const char *) Mask, sizeof(State)); Mask = (uchar *) &tmp_msk; #endif switch (caller) { case 1: /* addproc */ #if VECTORSZ>32000 memcpy((char *) P_o_tmp, (const char *) proc_offset, MAXPROC*sizeof(int)); #else memcpy((char *) P_o_tmp, (const char *) proc_offset, MAXPROC*sizeof(short)); #endif memcpy((char *) P_s_tmp, (const char *) proc_skip, MAXPROC*sizeof(uchar)); proc_offset = P_o_tmp; proc_skip = (uchar *) &P_s_tmp[0]; break; case 2: /* addqueue */ #if VECTORSZ>32000 memcpy((char *) Q_o_tmp, (const char *) q_offset, MAXQ*sizeof(int)); #else memcpy((char *) Q_o_tmp, (const char *) q_offset, MAXQ*sizeof(short)); #endif memcpy((char *) Q_s_tmp, (const char *) q_skip, MAXQ*sizeof(uchar)); q_offset = Q_o_tmp; q_skip = (uchar *) &Q_s_tmp[0]; break; case 3: /* no nothing */ break; default: /* cannot happen */ Uerror("no good"); break; } } typedef struct BFS_saves BFS_saves; struct BFS_saves { char *m; BFS_saves *nxt; } *bfs_save_po, *bfs_save_ps, #if !defined(NOCOMP) && !defined(HC) *bfs_save_mask, #endif *bfs_save_qo, *bfs_save_qs; extern volatile uchar *sh_malloc(ulong); static int bfs_runs; /* 0 before local heaps are initialized */ void bfs_swoosh(BFS_saves **where, char **what, int howmuch) { BFS_saves *m; for (m = *where; m; m = m->nxt) { if (memcmp(m->m, *what, howmuch) == 0) { *what = m->m; return; } } m = (BFS_saves *) emalloc(sizeof(BFS_saves)); if (bfs_runs) { m->m = (char *) sh_malloc(howmuch); } else { m->m = (char *) sh_pre_malloc(howmuch); } memcpy(m->m, *what, howmuch); m->nxt = *where; *where = m; *what = m->m; } void bfs_fixmask(int caller) { #if !defined(NOCOMP) && !defined(HC) bfs_swoosh(&bfs_save_mask, (char **) &Mask, sizeof(State)); #endif #ifndef TRIX switch (caller) { case 1: /* addproc */ #if VECTORSZ>32000 bfs_swoosh(&bfs_save_po, (char **) &proc_offset, MAXPROC*sizeof(int)); #else bfs_swoosh(&bfs_save_po, (char **) &proc_offset, MAXPROC*sizeof(short)); #endif bfs_swoosh(&bfs_save_ps, (char **) &proc_skip, MAXPROC*sizeof(uchar)); break; case 2: /* addqueue */ #if VECTORSZ>32000 bfs_swoosh(&bfs_save_qo, (char **) &q_offset, MAXQ*sizeof(int)); #else bfs_swoosh(&bfs_save_qo, (char **) &q_offset, MAXQ*sizeof(short)); #endif bfs_swoosh(&bfs_save_qs, (char **) &q_skip, MAXQ*sizeof(uchar)); break; case 3: /* do nothing */ break; default: Uerror("double plus ungood"); break; } #endif } #endif int addproc(int calling_pid, int priority, int n) { int j, h = now._nr_pr; #ifndef NOCOMP int k; #endif uchar *o_this = this; #ifndef INLINE if (TstOnly) return (h < MAXPROC); #endif #ifndef NOBOUNDCHECK /* redefine Index only within this procedure */ #undef Index #define Index(x, y) Boundcheck(x, y, 0, 0, 0) #endif if (h >= MAXPROC) Uerror("too many processes"); #ifdef V_TRIX printf("%4d: add process %d\n", depth, h); #endif switch (n) { case 0: j = sizeof(P0); break; case 1: j = sizeof(P1); break; default: Uerror("bad proc - addproc"); } #ifdef BFS_PAR bfs_prepmask(1); /* addproc */ #endif #ifdef TRIX vsize += sizeof(H_el *); #else if (vsize%WS) proc_skip[h] = WS-(vsize%WS); else proc_skip[h] = 0; #if !defined(NOCOMP) && !defined(HC) for (k = vsize + (int) proc_skip[h]; k > vsize; k--) Mask[k-1] = 1; /* align */ #endif vsize += (int) proc_skip[h]; proc_offset[h] = vsize; vsize += j; #if defined(SVDUMP) && defined(VERBOSE) if (vprefix > 0) { int dummy = 0; write(svfd, (uchar *) &dummy, sizeof(int)); /* mark */ write(svfd, (uchar *) &h, sizeof(int)); write(svfd, (uchar *) &n, sizeof(int)); #if VECTORSZ>32000 write(svfd, (uchar *) &proc_offset[h], sizeof(int)); write(svfd, (uchar *) &now, vprefix-4*sizeof(int)); /* padd */ #else write(svfd, (uchar *) &proc_offset[h], sizeof(short)); write(svfd, (uchar *) &now, vprefix-3*sizeof(int)-sizeof(short)); /* padd */ #endif } #endif #endif now._nr_pr += 1; #if defined(BCS) && defined(CONSERVATIVE) if (now._nr_pr >= CONSERVATIVE*8) { printf("pan: error: too many processes -- recompile with "); printf("-DCONSERVATIVE=%d\n", CONSERVATIVE+1); pan_exit(1); } #endif if (fairness && ((int) now._nr_pr + 1 >= (8*NFAIR)/2)) { printf("pan: error: too many processes -- current"); printf(" max is %d procs (-DNFAIR=%d)\n", (8*NFAIR)/2 - 2, NFAIR); printf("\trecompile with -DNFAIR=%d\n", NFAIR+1); pan_exit(1); } #ifndef NOVSZ now._vsz = vsize; #endif hmax = max(hmax, vsize); #ifdef TRIX #ifndef BFS if (freebodies) { processes[h] = freebodies; freebodies = freebodies->nxt; } else { processes[h] = (TRIX_v6 *) emalloc(sizeof(TRIX_v6)); processes[h]->body = (uchar *) emalloc(Maxbody * sizeof(char)); } processes[h]->modified = 1; /* addproc */ #endif processes[h]->psize = j; processes[h]->parent_pid = calling_pid; processes[h]->nxt = (TRIX_v6 *) 0; #else #if !defined(NOCOMP) && !defined(HC) for (k = 1; k <= Air[n]; k++) Mask[vsize - k] = 1; /* pad */ Mask[vsize-j] = 1; /* _pid */ #endif #ifdef BFS_PAR bfs_fixmask(1); /* addproc */ #endif if (vsize >= VECTORSZ) { printf("pan: error, VECTORSZ too small, recompile pan.c"); printf(" with -DVECTORSZ=N with N>%d\n", (int) vsize); Uerror("aborting"); } #endif memset((char *)pptr(h), 0, j); this = pptr(h); if (BASE > 0 && h > 0) { ((P0 *)this)->_pid = h-BASE; } else { ((P0 *)this)->_pid = h; } switch (n) { case 1: /* np_ */ ((P1 *)pptr(h))->_t = 1; ((P1 *)pptr(h))->_p = 0; #ifdef HAS_PRIORITY ((P1 *)pptr(h))->_priority = priority; #endif reached1[0] = 1; accpstate[1][1] = 1; break; case 0: /* loop */ ((P0 *)pptr(h))->_t = 0; ((P0 *)pptr(h))->_p = 9; #ifdef HAS_PRIORITY ((P0 *)pptr(h))->_priority = priority; /* was: 1 */ #endif reached0[9]=1; /* params: */ /* locals: */ ((P0 *)pptr(h))->a = 0; ((P0 *)pptr(h))->b = 0; #ifdef VAR_RANGES logval("loop:a", ((P0 *)pptr(h))->a); logval("loop:b", ((P0 *)pptr(h))->b); #endif #ifdef HAS_CODE locinit0(h); #endif break; } this = o_this; #ifdef TRIX re_mark_all(1); /* addproc */ #endif return h-BASE; #ifndef NOBOUNDCHECK #undef Index #define Index(x, y) Boundcheck(x, y, II, tt, t) #endif } #if defined(BITSTATE) && defined(COLLAPSE) /* just to allow compilation, to generate the error */ long col_p(int i, char *z) { return 0; } long col_q(int i, char *z) { return 0; } #endif #ifndef BITSTATE #ifdef COLLAPSE long col_p(int i, char *z) { int j, k; ulong ordinal(char *, long, short); char *x, *y; P0 *ptr = (P0 *) pptr(i); switch (ptr->_t) { case 0: j = sizeof(P0); break; case 1: j = sizeof(P1); break; default: Uerror("bad proctype - collapse"); } if (z) x = z; else x = scratch; y = (char *) ptr; k = proc_offset[i]; #if !defined(NOCOMP) && !defined(HC) for ( ; j > 0; j--, y++) if (!Mask[k++]) *x++ = *y; #else memcpy(x, y, j); x += j; #endif for (j = 0; j < WS-1; j++) *x++ = 0; x -= j; if (z) return (long) (x - z); return ordinal(scratch, x-scratch, (short) (2+ptr->_t)); } #endif #endif void run(void) { /* int i; */ memset((char *)&now, 0, sizeof(State)); vsize = (ulong) (sizeof(State) - VECTORSZ); #ifndef NOVSZ now._vsz = vsize; #endif #ifdef TRIX if (VECTORSZ != sizeof(now._ids_)) { printf("VECTORSZ is %d, but should be %d in this mode\n", VECTORSZ, (int) sizeof(now._ids_)); Uerror("VECTORSZ set incorrectly, recompile Spin (not pan.c)"); } #endif /* optional provisioning statements, e.g. to */ /* set hidden variables, used as constants */ #ifdef PROV #include PROV #endif settable(); Maxbody = max(Maxbody, ((int) sizeof(P0))); Maxbody = max(Maxbody, ((int) sizeof(P1))); reached[0] = reached0; reached[1] = reached1; accpstate[0] = (uchar *) emalloc(nstates0); accpstate[1] = (uchar *) emalloc(nstates1); progstate[0] = (uchar *) emalloc(nstates0); progstate[1] = (uchar *) emalloc(nstates1); loopstate0 = loopstate[0] = (uchar *) emalloc(nstates0); loopstate1 = loopstate[1] = (uchar *) emalloc(nstates1); stopstate[0] = (uchar *) emalloc(nstates0); stopstate[1] = (uchar *) emalloc(nstates1); visstate[0] = (uchar *) emalloc(nstates0); visstate[1] = (uchar *) emalloc(nstates1); mapstate[0] = (short *) emalloc(nstates0 * sizeof(short)); mapstate[1] = (short *) emalloc(nstates1 * sizeof(short)); stopstate[0][endstate0] = 1; stopstate[1][endstate1] = 1; #ifdef HAS_CODE NrStates[0] = nstates0; NrStates[1] = nstates1; #endif Maxbody = max(Maxbody, sizeof(State)-VECTORSZ); if ((Maxbody % WS) != 0) Maxbody += WS - (Maxbody % WS); progstate[0][8] = 1; accpstate[0][5] = 1; retrans(0, nstates0, start0, src_ln0, reached0, loopstate0); if (state_tables) { if (dodot) exit(0); printf("\nTransition Type: "); printf("A=atomic; D=d_step; L=local; G=global\n"); printf("Source-State Labels: "); printf("p=progress; e=end; a=accept;\n"); #ifdef MERGED printf("Note: statement merging was used. Only the first\n"); printf(" stmnt executed in each merge sequence is shown\n"); printf(" (use spin -a -o3 to disable statement merging)\n"); #endif pan_exit(0); } #if defined(BFS) && defined(TRIX) { int i; for (i = 0; i < MAXPROC+1; i++) { processes[i] = (TRIX_v6 *) emalloc(sizeof(TRIX_v6)); processes[i]->body = (uchar *) emalloc(Maxbody * sizeof(char)); } for (i = 0; i < MAXQ+1; i++) { channels[i] = (TRIX_v6 *) emalloc(sizeof(TRIX_v6)); channels[i]->body = (uchar *) emalloc(Maxbody * sizeof(char)); } } #endif #ifdef BFS_PAR bfs_setup_mem(); #ifdef COLLAPSE /* this must be the very first allocation from the shared heap */ #ifdef BFS_SEP_HASH ncomps = (ulong *) emalloc((ulong)((256+2) * sizeof(ulong))); #else ncomps = (ulong *) sh_pre_malloc((ulong)((256+2) * sizeof(ulong))); #endif #endif #endif iniglobals(258); /* arg outside range of pids */ #if defined(VERI) && !defined(NOREDUCE) && !defined(NP) && !defined(BFS) && !defined(HAS_LTL) if (!state_tables #ifdef HAS_CODE && !readtrail #endif #if NCORE>1 && core_id == 0 #endif ) { printf("warning: for p.o. reduction to be valid "); printf("the never claim must be stutter-invariant\n"); printf("(never claims generated from LTL "); printf("formulae are stutter-invariant)\n"); } #endif UnBlock; /* disable rendez-vous */ #ifdef BITSTATE sinit(); #else hinit(); #endif #if defined(FULLSTACK) && defined(BITSTATE) onstack_init(); #endif #if defined(CNTRSTACK) && !defined(BFS) LL = (uchar *) emalloc(ONE_L<<(ssize-3)); #endif stack = (_Stack *) emalloc(sizeof(_Stack)); svtack = (Svtack *) emalloc(sizeof(Svtack)); /* a place to point for Pptr of non-running procs: */ noqptr = noptr = (uchar *) emalloc(Maxbody * sizeof(char)); #if defined(SVDUMP) && defined(VERBOSE) if (vprefix > 0) (void) write(svfd, (uchar *) &vprefix, sizeof(int)); #endif #ifdef VERI Addproc(VERI,1); /* pid = 0, priority 1 */ #if NCLAIMS>1 if (claimname != NULL) { whichclaim = find_claim(claimname); select_claim(whichclaim); } #endif #endif active_procs(); /* started after never */ #ifdef EVENT_TRACE now._event = start_event; reached[EVENT_TRACE][start_event] = 1; #endif #ifdef HAS_CODE globinit(); #endif #ifdef BITSTATE go_again: #endif do_the_search(); #ifdef BITSTATE if (--Nrun > 0 && HASH_CONST[++HASH_NR]) { printf("Run %d:\n", HASH_NR); wrap_stats(); printf("\n"); if (udmem) /* Dillinger 3/2/09 */ { memset(SS, 0, udmem); } else { memset(SS, 0, ONE_L<<(ssize-3)); } #ifdef CNTRSTACK memset(LL, 0, ONE_L<<(ssize-3)); #endif #ifdef FULLSTACK memset((uchar *) S_Tab, 0, maxdepth*sizeof(H_el *)); #endif nstates=nlinks=truncs=truncs2=ngrabs = 0; nlost=nShadow=hcmp = 0; Fa=Fh=Zh=Zn = 0; PUT=PROBE=ZAPS=Ccheck=Cholds = 0; goto go_again; } #endif } #ifdef HAS_PRIORITY extern int highest_priority(int, short, Trans *); extern int get_priority(int); extern int set_priority(int, int); #endif #ifdef SPIN_HEAP void * spin_malloc(int n) /* reserved for use by Modex generated models */ { char *spin_heap_ptr = &(now.spin_heap[now.spin_heap_n]); if (now.spin_heap_n + n >= sizeof(now.spin_heap)) { Uerror("spin_heap limit reached"); } now.spin_heap_n += n; return spin_heap_ptr; } void spin_free(void *unused) { unused; /* ignore */ } #endif int spin_join(int p, int unused) { /* fprintf(stderr, "join %d when %d\n ", p, now._nr_pr); */ return (now._nr_pr <= p); /* process *p has stopped */ } int spin_mutex_free(int *m) { return (*m == 0); } int spin_mutex_lock(int *m) { *m = 1; return 1; } void spin_mutex_unlock(int *m) { *m = 0; } void spin_mutex_init(int *m, void *val) { if (!val) { *m = 0; } else { Uerror("pthread_mutex_init: unsupported non-default init"); } } int spin_cond_wait(int *cond, int *lck) { /* this version does not scale very far alas */ if (((P0 *)this)->_pid + 1 >= WS*8) { Uerror("pid exceeds range supported by pthread_cond_wait"); } if (((*cond)&1) == 0) { spin_mutex_unlock(lck); *cond |= (1<<(((P0 *)this)->_pid + 1)); return 0; } else { /* if other processes are already waiting */ /* while our wait flag is 0, then they should go first */ if ((*cond)&(~(1 | (1<<(((P0 *)this)->_pid + 1)))) != 0) { spin_mutex_unlock(lck); return 0; } *cond &= ~1; *cond &= ~(1<<(((P0 *)this)->_pid + 1)); return 1; } } void spin_cond_signal(int *cond) { if ( ((*cond)&(~1)) != 0 ) { *cond |= 1; } } #ifdef HAS_PROVIDED int provided(int, uchar, int, Trans *); #endif #ifdef BFS_PAR extern void bfs_shutdown(const char *); #endif #if NCORE>1 #define GLOBAL_LOCK (0) #ifndef CS_N #define CS_N (256*NCORE) #endif #ifdef NGQ #define NR_QS (NCORE) #define CS_NR (CS_N+1) /* 2^N + 1, nr critical sections */ #define GQ_RD GLOBAL_LOCK #define GQ_WR GLOBAL_LOCK #define CS_ID (1 + (int) (j1_spin & (CS_N-1))) /* mask: 2^N - 1, zero reserved */ #define QLOCK(n) (1+n) #else #define NR_QS (NCORE+1) #define CS_NR (CS_N+3) #define GQ_RD (1) #define GQ_WR (2) #define CS_ID (3 + (int) (j1_spin & (CS_N-1))) #define QLOCK(n) (3+n) #endif #ifndef SEP_STATE #define enter_critical(w) e_critical(w) #define leave_critical(w) x_critical(w) #else #ifdef NGQ #define enter_critical(w) { if (w < 1+NCORE) e_critical(w); } #define leave_critical(w) { if (w < 1+NCORE) x_critical(w); } #else #define enter_critical(w) { if (w < 3+NCORE) e_critical(w); } #define leave_critical(w) { if (w < 3+NCORE) x_critical(w); } #endif #endif int cpu_printf(const char *fmt, ...) { va_list args; enter_critical(GLOBAL_LOCK); /* printing */ printf("cpu%d: ", core_id); fflush(stdout); va_start(args, fmt); vprintf(fmt, args); va_end(args); fflush(stdout); leave_critical(GLOBAL_LOCK); return 1; } #else #define enter_critical(w) /* none */ #define leave_critical(w) /* none */ int cpu_printf(const char *fmt, ...) { va_list args; va_start(args, fmt); vprintf(fmt, args); va_end(args); return 1; } #endif int Printf(const char *fmt, ...) { /* Make sure the args to Printf * are always evaluated (e.g., they * could contain a run stmnt) * but do not generate the output * during verification runs * unless explicitly wanted * If this fails on your system * compile SPIN itself -DPRINTF * and this code is not generated */ #ifdef HAS_CODE if (readtrail) { va_list args; va_start(args, fmt); vprintf(fmt, args); va_end(args); return 1; } #endif #ifdef PRINTF va_list args; va_start(args, fmt); vprintf(fmt, args); va_end(args); #endif return 1; } extern void printm(int); #ifndef SC #define getframe(i) &trail[i]; #else static long HHH, DDD, hiwater; static long CNT1, CNT2; static int stackwrite; static int stackread; static Trail frameptr; Trail * getframe(long d) { if (CNT1 == CNT2) return &trail[d]; if (d >= (CNT1-CNT2)*DDD) return &trail[d - (CNT1-CNT2)*DDD]; if (!stackread && (stackread = open(stackfile, 0)) < 0) { printf("getframe: cannot open %s\n", stackfile); wrapup(); } if (lseek(stackread, d* (off_t) sizeof(Trail), SEEK_SET) == -1 || read(stackread, &frameptr, sizeof(Trail)) != sizeof(Trail)) { printf("getframe: frame read error\n"); wrapup(); } return &frameptr; } #endif #if NCORE>1 extern void cleanup_shm(int); volatile uint *search_terminated; /* to signal early termination */ #endif void pan_exit(int val) { void stop_timer(int); #ifdef BFS_PAR extern void bfs_mark_done(int); extern void bfs_drop_shared_memory(void); #endif if (signoff) { printf("--end of output--\n"); } #if NCORE>1 if (search_terminated != NULL) { *search_terminated |= 1; /* pan_exit */ } #ifdef USE_DISK { void dsk_stats(void); dsk_stats(); } #endif if (!state_tables && !readtrail) { cleanup_shm(1); } #endif #ifdef BFS_PAR if (who_am_i != 0) { bfs_mark_done(3); /* stopped */ } bfs_drop_shared_memory(); #endif if (val == 2) { val = 0; } #ifdef BFS_PAR if (who_am_i == 0) #endif stop_timer(1); #ifdef C_EXIT C_EXIT; /* trust that it defines a fct */ #endif exit(val); } #ifdef HAS_CODE static char tbuf[2][2048]; char * transmognify(char *s) { char *v, *w; int i, toggle = 0; if (!s || strlen(s) > 2047) return s; memset(tbuf[0], 0, 2048); memset(tbuf[1], 0, 2048); strcpy(tbuf[toggle], s); while ((v = strstr(tbuf[toggle], "{c_code"))) { *v = '\0'; v++; strcpy(tbuf[1-toggle], tbuf[toggle]); for (w = v; *w != '}' && *w != '\0'; w++) /* skip */; if (*w != '}') return s; *w = '\0'; w++; for (i = 0; code_lookup[i].c; i++) if (strcmp(v, code_lookup[i].c) == 0 && strlen(v) == strlen(code_lookup[i].c)) { if (strlen(tbuf[1-toggle]) + strlen(code_lookup[i].t) + strlen(w) > 2047) return s; strcat(tbuf[1-toggle], code_lookup[i].t); break; } strcat(tbuf[1-toggle], w); toggle = 1 - toggle; } tbuf[toggle][2047] = '\0'; return tbuf[toggle]; } #else char * transmognify(char *s) { return s; } #endif #ifdef HAS_CODE void add_src_txt(int ot, int tt) { Trans *t; char *q; for (t = trans[ot][tt]; t; t = t->nxt) { printf("\t\t"); q = transmognify(t->tp); for ( ; q && *q; q++) if (*q == '\n') printf("\\n"); else putchar(*q); printf("\n"); } } char * find_source(int tp, int s) { if (s >= flref[tp]->from && s <= flref[tp]->upto) { return flref[tp]->fnm; } return PanSource; /* i.e., don't know */ } void wrap_trail(void) { static int wrap_in_progress = 0; int i; short II; P0 *z; if (wrap_in_progress++) return; printf("spin: trail ends after %ld steps\n", depth); if (onlyproc >= 0) { if (onlyproc >= now._nr_pr) { pan_exit(0); } II = onlyproc; z = (P0 *)pptr(II); printf("%3ld: proc %d (%s) ", depth, II, procname[z->_t]); for (i = 0; src_all[i].src; i++) if (src_all[i].tp == (int) z->_t) { printf(" %s:%d", find_source((int) z->_t, (int) z->_p), src_all[i].src[z->_p]); break; } printf(" (state %2d)", z->_p); if (!stopstate[z->_t][z->_p]) printf(" (invalid end state)"); printf("\n"); add_src_txt(z->_t, z->_p); pan_exit(0); } printf("#processes %d:\n", now._nr_pr); if (depth < 0) depth = 0; for (II = 0; II < now._nr_pr; II++) { z = (P0 *)pptr(II); printf("%3ld: proc %d (%s) ", depth, II, procname[z->_t]); for (i = 0; src_all[i].src; i++) if (src_all[i].tp == (int) z->_t) { printf(" %s:%d", find_source((int) z->_t, (int) z->_p), src_all[i].src[z->_p]); break; } printf(" (state %2d)", z->_p); if (!stopstate[z->_t][z->_p]) printf(" (invalid end state)"); printf("\n"); add_src_txt(z->_t, z->_p); } c_globals(); for (II = 0; II < now._nr_pr; II++) { z = (P0 *)pptr(II); c_locals(II, z->_t); } #ifdef ON_EXIT ON_EXIT; #endif pan_exit(0); } FILE * findtrail(void) { FILE *fd; char fnm[512], *q; char MyFile[512]; char MySuffix[16]; int try_core; int candidate_files; if (trailfilename != NULL) { fd = fopen(trailfilename, "r"); if (fd == NULL) { printf("pan: cannot find %s\n", trailfilename); pan_exit(1); } /* else */ goto success; } talk: try_core = 1; candidate_files = 0; tprefix = "trail"; strcpy(MyFile, TrailFile); do { /* see if there's more than one possible trailfile */ if (whichtrail) { sprintf(fnm, "%s%d.%s", MyFile, whichtrail, tprefix); fd = fopen(fnm, "r"); if (fd != NULL) { candidate_files++; if (verbose==100) printf("trail%d: %s\n", candidate_files, fnm); fclose(fd); } if ((q = strchr(MyFile, '.')) != NULL) { *q = '\0'; sprintf(fnm, "%s%d.%s", MyFile, whichtrail, tprefix); *q = '.'; fd = fopen(fnm, "r"); if (fd != NULL) { candidate_files++; if (verbose==100) printf("trail%d: %s\n", candidate_files, fnm); fclose(fd); } } } else { sprintf(fnm, "%s.%s", MyFile, tprefix); fd = fopen(fnm, "r"); if (fd != NULL) { candidate_files++; if (verbose==100) printf("trail%d: %s\n", candidate_files, fnm); fclose(fd); } if ((q = strchr(MyFile, '.')) != NULL) { *q = '\0'; sprintf(fnm, "%s.%s", MyFile, tprefix); *q = '.'; fd = fopen(fnm, "r"); if (fd != NULL) { candidate_files++; if (verbose==100) printf("trail%d: %s\n", candidate_files, fnm); fclose(fd); } } } tprefix = MySuffix; sprintf(tprefix, "cpu%d_trail", try_core++); } while (try_core <= NCORE); if (candidate_files != 1) { if (verbose != 100) { printf("error: there are %d trail files:\n", candidate_files); verbose = 100; goto talk; } else { printf("pan: rm or mv all except one\n"); exit(1); } } try_core = 1; strcpy(MyFile, TrailFile); /* restore */ tprefix = "trail"; try_again: if (whichtrail) { sprintf(fnm, "%s%d.%s", MyFile, whichtrail, tprefix); fd = fopen(fnm, "r"); if (fd == NULL && (q = strchr(MyFile, '.'))) { *q = '\0'; sprintf(fnm, "%s%d.%s", MyFile, whichtrail, tprefix); *q = '.'; fd = fopen(fnm, "r"); } } else { sprintf(fnm, "%s.%s", MyFile, tprefix); fd = fopen(fnm, "r"); if (fd == NULL && (q = strchr(MyFile, '.'))) { *q = '\0'; sprintf(fnm, "%s.%s", MyFile, tprefix); *q = '.'; fd = fopen(fnm, "r"); } } if (fd == NULL) { if (try_core < NCORE) { tprefix = MySuffix; sprintf(tprefix, "cpu%d_trail", try_core++); goto try_again; } printf("pan: cannot find trailfile %s\n", fnm); pan_exit(1); } success: #if NCORE>1 && defined(SEP_STATE) { void set_root(void); /* for partial traces from local root */ set_root(); } #endif return fd; } uchar do_transit(Trans *, short); #ifdef PERMUTED void set_permuted(int); void set_reversed(int); void set_rotated(int); void set_randrot(int); void (*p_reorder)(int) = set_permuted; short p_rotate; #endif void getrail(void) { FILE *fd; char *q, *pnm; int i, t_id, lastnever = -1; short II; Trans *t; P0 *z; #ifdef PERMUTED char sbuf[128]; memset(sbuf, 0, sizeof(sbuf)); #endif fd = findtrail(); /* exits if unsuccessful */ while (fscanf(fd, "%ld:%d:%d\n", &depth, &i, &t_id) == 3) { if (depth == -1) { printf("<<<<>>>>\n"); } #ifdef PERMUTED if (depth < 0) { switch (depth) { case -5: if (i && !t_reverse) { strcat(sbuf, "-t_reverse "); } break; case -6: if (i && p_reorder != set_permuted) { strcat(sbuf, "-p_permute "); } else if (t_id && p_reorder != set_reversed) { strcat(sbuf, "-p_reverse "); } break; case -7: if (i && (p_reorder != set_rotated || p_rotate != t_id)) { char tmp[32]; sprintf(tmp, "-p_rotate%d ", t_id); strcat(sbuf, tmp); } break; case -8: if (i && p_reorder != set_randrot) { strcat(sbuf, "-p_randrot "); } if (s_rand != ++t_id) { char tmp[32]; sprintf(tmp, "-RS%u ", (uint) t_id-1); strcat(sbuf, tmp); } break; default: continue; } } #endif if (depth < 0) { continue; } #ifdef PERMUTED if (strlen(sbuf) > 0) { fprintf(efd, "add: %s\n", sbuf); exit(1); } #endif if (i > now._nr_pr) { printf("pan: Error, proc %d invalid pid ", i); printf("transition %d\n", t_id); break; } II = i; z = (P0 *)pptr(II); for (t = trans[z->_t][z->_p]; t; t = t->nxt) if (t->t_id == (T_ID) t_id) break; if (!t) { for (i = 0; i < NrStates[z->_t]; i++) { t = trans[z->_t][i]; if (t && t->t_id == (T_ID) t_id) { printf("\tRecovered at state %d\n", i); z->_p = i; goto recovered; } } printf("pan: Error, proc %d type %d state %d: ", II, z->_t, z->_p); printf("transition %d not found\n", t_id); printf("pan: list of possible transitions in this process:\n"); if (z->_t >= 0 && z->_t <= _NP_) for (t = trans[z->_t][z->_p]; t; t = t->nxt) printf(" t_id %d -- case %d, [%s]\n", t->t_id, t->forw, t->tp); break; /* pan_exit(1); */ } recovered: q = transmognify(t->tp); if (gui) simvals[0] = '\0'; pnm = procname[z->_t]; this = pptr(II); trpt->tau |= 1; if (!do_transit(t, II)) { if (onlyproc >= 0 && II != onlyproc) goto moveon; if (!verbose) break; printf("pan: error, next transition UNEXECUTABLE on replay\n"); printf(" most likely causes: missing c_track statements\n"); printf(" or illegal side-effects in c_expr statements\n"); } if (onlyproc >= 0 && II != onlyproc) goto moveon; if (verbose) { printf("%3ld: proc %2d (%s) ", depth, II, pnm); for (i = 0; src_all[i].src; i++) if (src_all[i].tp == (int) z->_t) { printf(" %s:%d ", find_source((int) z->_t, (int) z->_p), src_all[i].src[z->_p]); break; } printf("(state %d) trans {%d,%d} [%s]\n", z->_p, t_id, t->forw, q?q:""); c_globals(); for (i = 0; i < now._nr_pr; i++) { c_locals(i, ((P0 *)pptr(i))->_t); } } else if (Btypes[z->_t] == N_CLAIM) { if (lastnever != (int) z->_p) { for (i = 0; src_all[i].src; i++) if (src_all[i].tp == (int) z->_t) { printf("MSC: ~G %d\n", src_all[i].src[z->_p]); break; } if (!src_all[i].src) printf("MSC: ~R %d\n", z->_p); } lastnever = z->_p; goto sameas; } else if (Btypes[z->_t] != 0) /* not :np_: */ { sameas: if (no_rck) goto moveon; if (coltrace) { printf("%ld: ", depth); for (i = 0; i < II; i++) printf("\t\t"); printf("%s(%d):", pnm, II); printf("[%s]\n", q?q:""); } else if (!silent) { if (strlen(simvals) > 0) { printf("%3ld: proc %2d (%s)", depth, II, pnm); for (i = 0; src_all[i].src; i++) if (src_all[i].tp == (int) z->_t) { printf(" %s:%d ", find_source((int) z->_t, (int) z->_p), src_all[i].src[z->_p]); break; } printf("(state %d) [values: %s]\n", z->_p, simvals); } printf("%3ld: proc %2d (%s)", depth, II, pnm); for (i = 0; src_all[i].src; i++) if (src_all[i].tp == (int) z->_t) { printf(" %s:%d ", find_source((int) z->_t, (int) z->_p), src_all[i].src[z->_p]); break; } printf("(state %d) [%s]\n", z->_p, q?q:""); /* printf("\n"); */ } } moveon: z->_p = t->st; } wrap_trail(); } #endif int f_pid(int pt) { int i; P0 *z; for (i = 0; i < now._nr_pr; i++) { z = (P0 *)pptr(i); if (z->_t == (unsigned) pt) return BASE+z->_pid; } return -1; } #if NCORE>1 && !defined(GLOB_HEAP) #define SEP_HEAP /* version 5.1.2 */ #endif #ifdef BITSTATE int bstore_mod(char *v, int n) /* hasharray size not a power of two */ { ulong x, y; uint i = 1; #if defined(MURMUR) && (WS==8) m_hash((uchar *) v, n); /* bstore_mod - sets j3_spin, j4_spin, K1, K2 */ #else d_hash((uchar *) v, n); /* bstore_mod - sets j3_spin, j4_spin, K1, K2 */ #endif x = K1; y = j3_spin; for (;;) { if (!(SS[x%udmem]&(1< RANDSTOR) return 0; #endif for (;;) { SS[x%udmem] |= (1< RANDSTOR) return 0; #endif for (;;) { SS[x] |= (1< 0) { #ifdef PUTPID sprintf(fnm, "%s_%s_%d_%d.%s", MyFile, progname, getpid(), Nr_Trails-1, tprefix); #else sprintf(fnm, "%s%d.%s", MyFile, Nr_Trails-1, tprefix); #endif } else { #ifdef PUTPID sprintf(fnm, "%s_%s_%d.%s", MyFile, progname, getpid(), tprefix); #else sprintf(fnm, "%s.%s", MyFile, tprefix); #endif } if ((fd = open(fnm, w_flags, TMODE)) < 0) { if ((q = strchr(MyFile, '.'))) { *q = '\0'; if (iterative == 0 && Nr_Trails-1 > 0) sprintf(fnm, "%s%d.%s", MyFile, Nr_Trails-1, tprefix); else sprintf(fnm, "%s.%s", MyFile, tprefix); *q = '.'; fd = open(fnm, w_flags, TMODE); } } if (fd < 0) { printf("pan: cannot create %s\n", fnm); perror("cause"); } else { #if NCORE>1 && (defined(SEP_STATE) || !defined(FULL_TRAIL)) void write_root(void); write_root(); #else printf("pan: wrote %s\n", fnm); #endif } return fd; } #ifndef FREQ #define FREQ (1000000) #endif double freq = (double) FREQ; #ifdef TRIX void sv_populate(void); void re_populate(void) /* restore procs and chans from now._ids_ */ { int i, cnt = 0; char *b; #ifdef V_TRIX printf("%4d: re_populate\n", depth); #endif for (i = 0; i < now._nr_pr; i++, cnt++) { b = now._ids_[cnt]; processes[i]->psize = what_p_size( ((P0 *)b)->_t ); memcpy(processes[i]->body, b, processes[i]->psize); #ifdef TRIX_RIX ((P0 *)pptr(i))->_pid = i; if (BASE > 0 && h > 0) { ((P0 *)pptr(i))->_pid -= BASE; } #endif #ifndef BFS processes[i]->modified = 1; /* re-populate */ #endif } for (i = 0; i < now._nr_qs; i++, cnt++) { b = now._ids_[cnt]; channels[i]->psize = what_q_size( ((Q0 *)b)->_t ); memcpy(channels[i]->body, b, channels[i]->psize); #ifndef BFS channels[i]->modified = 1; /* re-populate */ #endif } } #endif #ifdef BFS #ifndef BFS_PAR BFS_State *bfs_trail, *bfs_bot, *bfs_free; SV_Hold *svfree; #else static ulong bfs_pre_allocated; #endif #ifdef BFS_DISK #ifndef BFS_LIMIT #define BFS_LIMIT 100000 #endif #ifndef BFS_DSK_LIMIT #define BFS_DSK_LIMIT 1000000 #endif #if defined(WIN32) || defined(WIN64) #define RFLAGS (O_RDONLY|O_BINARY) #define WFLAGS (O_CREAT|O_WRONLY|O_TRUNC|O_BINARY) #define RWFLAGS (O_RDWR|O_BINARY) #else #define RFLAGS (O_RDONLY) #define WFLAGS (O_CREAT|O_WRONLY|O_TRUNC) #define RWFLAGS (O_RDWR) #endif long bfs_size_limit; int bfs_dsk_write = -1; int bfs_dsk_read = -1; long bfs_dsk_writes, bfs_dsk_reads; int bfs_dsk_seqno_w, bfs_dsk_seqno_r; #endif uchar do_reverse(Trans *, short, uchar); void snapshot(void); #if 0 void select_claim(int x) /* ignored in BFS mode */ { if (verbose) { printf("select %d (ignored)\n", x); } } #endif Trail *ntrpt; #ifndef BFS_PAR SV_Hold * getsv(int n) { SV_Hold *h; if (svfree && n <= svfree->sz) { h = svfree; svfree = h->nxt; h->nxt = (SV_Hold *) 0; } else { h = (SV_Hold *) emalloc(sizeof(SV_Hold)); h->sz = n; #ifdef BFS_DISK if (bfs_size_limit >= BFS_LIMIT) { h->sv = (State *) 0; /* means: read disk */ bfs_dsk_writes++; /* count */ if (bfs_dsk_write < 0 /* file descriptor */ || bfs_dsk_writes%BFS_DSK_LIMIT == 0) { char dsk_nm[32]; if (bfs_dsk_write >= 0) { (void) close(bfs_dsk_write); } sprintf(dsk_nm, "pan_bfs_%d.tmp", bfs_dsk_seqno_w++); bfs_dsk_write = open(dsk_nm, WFLAGS, 0644); if (bfs_dsk_write < 0) { Uerror("could not create tmp disk file"); } printf("pan: created disk file %s\n", dsk_nm); } if (write(bfs_dsk_write, (char *) &now, n) != n) { Uerror("aborting -- disk write failed (disk full?)"); } return h; /* no memcpy */ } bfs_size_limit++; #endif h->sv = (State *) emalloc(sizeof(State) - VECTORSZ + n); } memcpy((char *)h->sv, (char *)&now, n); return h; } EV_Hold * getsv_mask(int n) { EV_Hold *h; static EV_Hold *kept = (EV_Hold *) 0; for (h = kept; h; h = h->nxt) if (n == h->sz #if !defined(NOCOMP) && !defined(HC) && (memcmp((char *) Mask, (char *) h->sv, n) == 0) #endif && (now._nr_pr == h->nrpr) && (now._nr_qs == h->nrqs) #ifdef TRIX ) #else #if VECTORSZ>32000 && (memcmp((char *) proc_offset, (char *) h->po, now._nr_pr * sizeof(int)) == 0) && (memcmp((char *) q_offset, (char *) h->qo, now._nr_qs * sizeof(int)) == 0) #else && (memcmp((char *) proc_offset, (char *) h->po, now._nr_pr * sizeof(short)) == 0) && (memcmp((char *) q_offset, (char *) h->qo, now._nr_qs * sizeof(short)) == 0) #endif && (memcmp((char *) proc_skip, (char *) h->ps, now._nr_pr * sizeof(uchar)) == 0) && (memcmp((char *) q_skip, (char *) h->qs, now._nr_qs * sizeof(uchar)) == 0)) #endif break; if (!h) { h = (EV_Hold *) emalloc(sizeof(EV_Hold)); h->sz = n; h->nrpr = now._nr_pr; h->nrqs = now._nr_qs; h->sv = (char *) emalloc(n * sizeof(char)); #if !defined(NOCOMP) && !defined(HC) memcpy((char *) h->sv, (char *) Mask, n); #endif #ifndef TRIX if (now._nr_pr > 0) { h->ps = (char *) emalloc(now._nr_pr * sizeof(int)); memcpy((char *) h->ps, (char *) proc_skip, now._nr_pr * sizeof(uchar)); #if VECTORSZ>32000 h->po = (char *) emalloc(now._nr_pr * sizeof(int)); memcpy((char *) h->po, (char *) proc_offset, now._nr_pr * sizeof(int)); #else h->po = (char *) emalloc(now._nr_pr * sizeof(short)); memcpy((char *) h->po, (char *) proc_offset, now._nr_pr * sizeof(short)); #endif } if (now._nr_qs > 0) { h->qs = (char *) emalloc(now._nr_qs * sizeof(int)); memcpy((char *) h->qs, (char *) q_skip, now._nr_qs * sizeof(uchar)); #if VECTORSZ>32000 h->qo = (char *) emalloc(now._nr_qs * sizeof(int)); memcpy((char *) h->qo, (char *) q_offset, now._nr_qs * sizeof(int)); #else h->qo = (char *) emalloc(now._nr_qs * sizeof(short)); memcpy((char *) h->qo, (char *) q_offset, now._nr_qs * sizeof(short)); #endif } #endif h->nxt = kept; kept = h; } return h; } void freesv(SV_Hold *p) { SV_Hold *h, *oh; oh = (SV_Hold *) 0; for (h = svfree; h; oh = h, h = h->nxt) { if (p->sz >= h->sz) break; } if (!oh) { p->nxt = svfree; svfree = p; } else { p->nxt = h; oh->nxt = p; } } BFS_State * get_bfs_frame(void) { BFS_State *t; if (bfs_free) { t = bfs_free; bfs_free = bfs_free->nxt; t->nxt = (BFS_State *) 0; } else { t = (BFS_State *) emalloc(sizeof(BFS_State)); } t->frame = (Trail *) emalloc(sizeof(Trail)); /* new because we keep a ptr to the frame of parent states */ /* used for reconstructing path and recovering failed rvs etc */ return t; } void push_bfs(Trail *f, int d) { BFS_State *t; t = get_bfs_frame(); memcpy((char *)t->frame, (char *)f, sizeof(Trail)); t->frame->o_tt = d; /* depth */ t->boq = boq; #ifdef TRIX sv_populate(); #endif t->onow = getsv(vsize); t->omask = getsv_mask(vsize); #if defined(FULLSTACK) && defined(Q_PROVISO) t->lstate = Lstate; /* bfs */ #endif if (!bfs_bot) { bfs_bot = bfs_trail = t; } else { bfs_bot->nxt = t; bfs_bot = t; } #ifdef VERBOSE t->nr = nstates; #endif #ifdef CHECK #ifdef VERBOSE printf("PUSH %lu (depth %d, nr %lu)\n", (ulong) t->frame, d, t->nr); #else printf("PUSH %lu (depth %d)\n", (ulong) t->frame, d); #endif #endif } Trail * pop_bfs(void) { BFS_State *t; if (!bfs_trail) { return (Trail *) 0; } t = bfs_trail; bfs_trail = t->nxt; if (!bfs_trail) { bfs_bot = (BFS_State *) 0; } #if defined(Q_PROVISO) && !defined(BITSTATE) && !defined(NOREDUCE) if (t->lstate) /* bfs */ { t->lstate->tagged = 0; /* bfs */ } #endif t->nxt = bfs_free; bfs_free = t; vsize = t->onow->sz; boq = t->boq; #ifdef BFS_DISK if (t->onow->sv == (State *) 0) { char dsk_nm[32]; bfs_dsk_reads++; /* count */ if (bfs_dsk_read >= 0 /* file descriptor */ && bfs_dsk_reads%BFS_DSK_LIMIT == 0) { (void) close(bfs_dsk_read); sprintf(dsk_nm, "pan_bfs_%d.tmp", bfs_dsk_seqno_r-1); (void) unlink(dsk_nm); bfs_dsk_read = -1; } if (bfs_dsk_read < 0) { sprintf(dsk_nm, "pan_bfs_%d.tmp", bfs_dsk_seqno_r++); bfs_dsk_read = open(dsk_nm, RFLAGS); if (bfs_dsk_read < 0) { Uerror("could not open temp disk file"); } } if (read(bfs_dsk_read, (char *) &now, vsize) != vsize) { Uerror("bad bfs disk file read"); } #ifndef NOVSZ if (now._vsz != vsize) { Uerror("disk read vsz mismatch"); } #endif } else #endif { memcpy((uchar *) &now, (uchar *) t->onow->sv, vsize); #ifndef NOVSZ vsize = now._vsz; #endif } #if !defined(NOCOMP) && !defined(HC) memcpy((uchar *) Mask, (uchar *) t->omask->sv, vsize); #endif #ifdef TRIX re_populate(); #else if (now._nr_pr > 0) #if VECTORSZ>32000 { memcpy((char *)proc_offset, (char *)t->omask->po, now._nr_pr * sizeof(int)); #else { memcpy((char *)proc_offset, (char *)t->omask->po, now._nr_pr * sizeof(short)); #endif memcpy((char *)proc_skip, (char *)t->omask->ps, now._nr_pr * sizeof(uchar)); } if (now._nr_qs > 0) #if VECTORSZ>32000 { memcpy((uchar *)q_offset, (uchar *)t->omask->qo, now._nr_qs * sizeof(int)); #else { memcpy((uchar *)q_offset, (uchar *)t->omask->qo, now._nr_qs * sizeof(short)); #endif memcpy((uchar *)q_skip, (uchar *)t->omask->qs, now._nr_qs * sizeof(uchar)); } #endif #ifdef BFS_DISK if (t->onow->sv != (State *) 0) #endif { freesv(t->onow); /* omask not freed */ } #ifdef CHECK #ifdef VERBOSE printf("POP %lu (depth %d, nr %lu)\n", (ulong) t->frame, t->frame->o_tt, t->nr); #else printf("POP %lu (depth %d)\n", (ulong) t->frame, t->frame->o_tt); #endif #endif return t->frame; } void store_state(Trail *ntrpt, int shortcut, short oboq) { #ifdef VERI Trans *t2 = (Trans *) 0; uchar ot; int tt, E_state; uchar o_opm = trpt->o_pm, *othis = this; if (shortcut) { #ifdef VERBOSE printf("claim: shortcut\n"); #endif goto store_it; /* no claim move */ } this = pptr(0); /* 0 = never claim */ trpt->o_pm = 0; tt = (int) ((P0 *)this)->_p; ot = (uchar) ((P0 *)this)->_t; #ifdef HAS_UNLESS E_state = 0; #endif for (t2 = trans[ot][tt]; t2; t2 = t2?t2->nxt:(Trans *)0) { #ifdef HAS_UNLESS if (E_state > 0 && E_state != t2->e_trans) { break; } #endif if (do_transit(t2, 0)) { #ifdef VERBOSE if (!reached[ot][t2->st]) printf("depth: %d -- claim move from %d -> %d\n", trpt->o_tt, ((P0 *)this)->_p, t2->st); #endif #ifdef HAS_UNLESS E_state = t2->e_trans; #endif if (t2->st > 0) { ((P0 *)this)->_p = t2->st; reached[ot][t2->st] = 1; #ifndef NOCLAIM if (stopstate[ot][t2->st]) { uerror("end state in claim reached"); } #endif } if (now._nr_pr == 0) /* claim terminated */ uerror("end state in claim reached"); #ifdef PEG peg[t2->forw]++; #endif trpt->o_pm |= 1; if (t2->atom&2) { Uerror("atomic in claim not supported in BFS"); } store_it: #endif #if defined(BITSTATE) if (!b_store((char *)&now, vsize)) #elif defined(MA) if (!g_store((char *)&now, vsize, 0)) #else if (!h_store((char *)&now, vsize)) #endif { static long sdone = (long) 0; long ndone; nstates++; #ifndef NOREDUCE trpt->tau |= 64; #endif ndone = (ulong) (nstates/(freq)); if (ndone != sdone && mreached%10 != 0) { snapshot(); sdone = ndone; #if defined(AUTO_RESIZE) && !defined(BITSTATE) && !defined(MA) if (nstates > ((double)(1<<(ssize+1)))) { void resize_hashtable(void); resize_hashtable(); } #endif } #if SYNC if (boq != -1) midrv++; else if (oboq != -1) { Trail *x; x = (Trail *) trpt->ostate; /* pre-rv state */ if (x) x->o_pm |= 4; /* mark success */ } #endif push_bfs(ntrpt, trpt->o_tt+1); } else { truncs++; #if defined(Q_PROVISO) && !defined(NOREDUCE) && defined(FULLSTACK) #if !defined(BITSTATE) if (Lstate && Lstate->tagged) { trpt->tau |= 64; } #else if (trpt->tau&32) { BFS_State *tprov; for (tprov = bfs_trail; tprov; tprov = tprov->nxt) if (tprov->onow->sv != (State *) 0 && memcmp((uchar *)&now, (uchar *)tprov->onow->sv, vsize) == 0) { trpt->tau |= 64; break; /* state is in queue */ } } #endif #endif } #ifdef VERI ((P0 *)this)->_p = tt; /* reset claim */ if (t2) do_reverse(t2, 0, 0); else break; } } this = othis; trpt->o_pm = o_opm; #endif } void bfs(void) { Trans *t; Trail *otrpt, *x; uchar _n, _m, ot, nps = 0; int tt, E_state; short II, From = (short) (now._nr_pr-1), To = BASE; short oboq = boq; ntrpt = (Trail *) emalloc(sizeof(Trail)); trpt->ostate = (H_el *) 0; trpt->tau = 0; trpt->o_tt = -1; store_state(ntrpt, 0, oboq); /* initial state */ while ((otrpt = pop_bfs())) /* also restores now */ { memcpy((char *) trpt, (char *) otrpt, sizeof(Trail)); #if defined(C_States) && (HAS_TRACK==1) c_revert((uchar *) &(now.c_state[0])); #endif if (trpt->o_pm & 4) { #ifdef VERBOSE printf("Revisit of atomic not needed (%d)\n", trpt->o_pm); #endif continue; } #ifndef NOREDUCE nps = 0; #endif if (trpt->o_pm == 8) { revrv++; if (trpt->tau&8) { #ifdef VERBOSE printf("Break atomic (pm:%d,tau:%d)\n", trpt->o_pm, trpt->tau); #endif trpt->tau &= ~8; } #ifndef NOREDUCE else if (trpt->tau&32) { #ifdef VERBOSE printf("Void preselection (pm:%d,tau:%d)\n", trpt->o_pm, trpt->tau); #endif trpt->tau &= ~32; nps = 1; /* no preselection in repeat */ } #endif } trpt->o_pm &= ~(4|8); if (trpt->o_tt > mreached) { mreached = trpt->o_tt; if (mreached%10 == 0) { snapshot(); } } depth = trpt->o_tt; if (depth >= maxdepth) { #if SYNC Trail *x; if (boq != -1) { x = (Trail *) trpt->ostate; if (x) x->o_pm |= 4; /* not failing */ } #endif truncs++; if (!warned) { warned = 1; printf("error: max search depth too small\n"); } if (bounded) { uerror("depth limit reached"); } continue; } #ifndef NOREDUCE if (boq == -1 && !(trpt->tau&8) && nps == 0) for (II = now._nr_pr-1; II >= BASE; II -= 1) { Pickup: this = pptr(II); tt = (int) ((P0 *)this)->_p; ot = (uchar) ((P0 *)this)->_t; if (trans[ot][tt]->atom & 8) { t = trans[ot][tt]; if (t->qu[0] != 0) { Ccheck++; if (!q_cond(II, t)) continue; Cholds++; } From = To = II; trpt->tau |= 32; /* preselect marker */ #ifdef DEBUG printf("%3ld: proc %d PreSelected (tau=%d)\n", depth, II, trpt->tau); #endif goto MainLoop; } } trpt->tau &= ~32; #endif Repeat: if (trpt->tau&8) /* atomic */ { From = To = (short ) trpt->pr; nlinks++; } else { From = now._nr_pr-1; To = BASE; } MainLoop: _n = _m = 0; for (II = From; II >= To; II -= 1) { this = pptr(II); tt = (int) ((P0 *)this)->_p; ot = (uchar) ((P0 *)this)->_t; #if SYNC /* no rendezvous with same proc */ if (boq != -1 && trpt->pr == II) { continue; } #endif ntrpt->pr = (uchar) II; ntrpt->st = tt; trpt->o_pm &= ~1; /* no move yet */ #ifdef EVENT_TRACE trpt->o_event = now._event; #endif #ifdef HAS_PRIORITY if (!highest_priority(((P0 *)this)->_pid, II, t)) { continue; } #else #ifdef HAS_PROVIDED if (!provided(II, ot, tt, t)) { continue; } #endif #endif #ifdef HAS_UNLESS E_state = 0; #endif for (t = trans[ot][tt]; t; t = t->nxt) { #ifdef HAS_UNLESS if (E_state > 0 && E_state != t->e_trans) break; #endif ntrpt->o_t = t; oboq = boq; if (!(_m = do_transit(t, II))) continue; trpt->o_pm |= 1; /* we moved */ (trpt+1)->o_m = _m; /* for unsend */ #ifdef PEG peg[t->forw]++; #endif #ifdef CHECK printf("%3ld: proc %d exec %d, ", depth, II, t->forw); printf("%d to %d, %s %s %s", tt, t->st, t->tp, (t->atom&2)?"atomic":"", (boq != -1)?"rendez-vous":""); #ifdef HAS_UNLESS if (t->e_trans) printf(" (escapes to state %d)", t->st); #endif printf(" %saccepting [tau=%d]\n", (trpt->o_pm&2)?"":"non-", trpt->tau); #endif #ifdef HAS_UNLESS E_state = t->e_trans; #if SYNC>0 if (t->e_trans > 0 && (boq != -1 /* || oboq != -1 */)) { fprintf(efd, "error: a rendezvous stmnt in the escape clause\n"); fprintf(efd, " of an unless stmnt is not compatible with -DBFS\n"); pan_exit(1); } #endif #endif if (t->st > 0) { ((P0 *)this)->_p = t->st; } /* ptr to pred: */ ntrpt->ostate = (H_el *) otrpt; ntrpt->st = tt; if (boq == -1 && (t->atom&2)) /* atomic */ ntrpt->tau = 8; /* record for next move */ else ntrpt->tau = 0; store_state(ntrpt, (boq != -1 || (t->atom&2)), oboq); #ifdef EVENT_TRACE now._event = trpt->o_event; #endif /* undo move and continue */ trpt++; /* this is where ovals and ipt are set */ do_reverse(t, II, _m); /* restore now. */ trpt--; #ifdef CHECK enter_critical(GLOBAL_LOCK); /* verbose mode */ #if NCORE>1 printf("cpu%d: ", core_id); #endif printf("%3lu: proc %d ", depth, II); printf("reverses %d, %d to %d,", t->forw, tt, t->st); printf(" %s [abit=%d,adepth=%ld,", t->tp, now._a_t, A_depth); printf("tau=%d,%d]\n", trpt->tau, (trpt-1)->tau); leave_critical(GLOBAL_LOCK); #endif reached[ot][t->st] = 1; reached[ot][tt] = 1; ((P0 *)this)->_p = tt; _n |= _m; } } #ifndef NOREDUCE /* preselected - no succ definitely outside stack */ if ((trpt->tau&32) && !(trpt->tau&64)) { From = now._nr_pr-1; To = BASE; #ifdef DEBUG cpu_printf("%3ld: proc %d UnSelected (_n=%d, tau=%d)\n", depth, II+1, (int) _n, trpt->tau); #endif _n = 0; trpt->tau &= ~32; if (II >= BASE) { goto Pickup; } goto MainLoop; } trpt->tau &= ~(32|64); #endif if (_n != 0) { continue; } #ifdef DEBUG printf("%3ld: no move [II=%d, tau=%d, boq=%d, _nr_pr=%d]\n", depth, II, trpt->tau, boq, now._nr_pr); #endif if (boq != -1) { failedrv++; x = (Trail *) trpt->ostate; /* pre-rv state */ if (!x) { continue; /* root state */ } if ((x->tau&8) || (x->tau&32)) /* break atomic or preselect at parent */ { x->o_pm |= 8; /* mark failure */ this = pptr(otrpt->pr); #ifdef VERBOSE printf("\treset state of %d from %d to %d\n", otrpt->pr, ((P0 *)this)->_p, otrpt->st); #endif ((P0 *)this)->_p = otrpt->st; unsend(boq); /* retract rv offer */ boq = -1; push_bfs(x, x->o_tt); #ifdef VERBOSE printf("failed rv, repush with %d\n", x->o_pm); #endif } #ifdef VERBOSE else { printf("failed rv, tau at parent: %d\n", x->tau); } #endif } else if (now._nr_pr > 0) { if ((trpt->tau&8)) /* atomic */ { trpt->tau &= ~(1|8); /* 1=timeout, 8=atomic */ #ifdef DEBUG printf("%3ld: atomic step proc %d blocks\n", depth, II+1); #endif goto Repeat; } if (!(trpt->tau&1)) /* didn't try timeout yet */ { trpt->tau |= 1; #ifdef DEBUG printf("%ld: timeout\n", depth); #endif goto MainLoop; } #ifndef VERI if (!noends && !a_cycles && !endstate()) { uerror("invalid end state"); } #endif } } } #endif void putter(Trail *trpt, int fd) { long j; if (!trpt) return; if (trpt != (Trail *) trpt->ostate) putter((Trail *) trpt->ostate, fd); if (trpt->o_t) { sprintf(snap, "%d:%d:%d\n", trcnt++, trpt->pr, trpt->o_t->t_id); j = strlen(snap); if (write(fd, snap, j) != j) { printf("pan: error writing %s\n", fnm); pan_exit(1); } } } void n_ewrite(int fd, char *s, int n) { if (write(fd, s, strlen(s)) != strlen(s)) { printf("pan: error writing %s\n", fnm); pan_exit(1); } } void nuerror(void) { int fd = make_trail(); int j; if (fd < 0) return; #ifdef VERI sprintf(snap, "-2:%d:-2\n", (uchar) ((P0 *)pptr(0))->_t); n_ewrite(fd, snap, strlen(snap)); #endif #ifdef MERGED sprintf(snap, "-4:-4:-4\n"); n_ewrite(fd, snap, strlen(snap)); #endif trcnt = 1; putter(trpt, fd); if (ntrpt->o_t) { sprintf(snap, "%d:%d:%d\n", trcnt++, ntrpt->pr, ntrpt->o_t->t_id); j = strlen(snap); n_ewrite(fd, snap, j); } close(fd); if (errors >= upto && upto != 0) { wrapup(); } } #endif #if (NCORE>1 || defined(BFS_PAR)) && !defined(WIN32) && !defined(WIN64) /* Test and Set assembly code */ #if defined(i386) || defined(__i386__) || defined(__x86_64__) int tas(volatile int *s) /* tested */ { int r; __asm__ __volatile__( "xchgl %0, %1 \n\t" : "=r"(r), "=m"(*s) : "0"(1), "m"(*s) : "memory"); return r; } #elif defined(__arm__) int tas(volatile int *s) /* not tested */ { int r = 1; __asm__ __volatile__( "swpb %0, %0, [%3] \n" : "=r"(r), "=m"(*s) : "0"(r), "r"(s)); return r; } #elif defined(sparc) || defined(__sparc__) int tas(volatile int *s) /* not tested */ { int r = 1; __asm__ __volatile__( " ldstub [%2], %0 \n" : "=r"(r), "=m"(*s) : "r"(s)); return r; } #elif defined(ia64) || defined(__ia64__) /* Intel Itanium */ int tas(volatile int *s) /* tested */ { long int r; __asm__ __volatile__( " xchg4 %0=%1,%2 \n" : "=r"(r), "+m"(*s) : "r"(1) : "memory"); return (int) r; } #elif defined(__powerpc64__) int tas(volatile int *s) /* courtesy srirajpaul */ { int r; #if 1 r = __sync_lock_test_and_set(); #else /* xlc compiler only */ r = __fetch_and_or(s, 1); __isync(); #endif return r; } #else #error missing definition of test and set operation for this platform #endif #ifndef NO_CAS #define cas(a,b,c) __sync_bool_compare_and_swap(a,b,c) #else int cas(volatile uint32_t *a, uint32_t b, uint32_t c) { static volatile int cas_lock; while (tas(&cas_lock) != 0) { ; } if (*a == b) { *a = c; cas_lock = 0; return 1; } cas_lock = 0; return 0; } #endif #endif #if NCORE>1 #if defined(WIN32) || defined(WIN64) #ifndef _CONSOLE #define _CONSOLE #endif #ifdef WIN64 #undef long #endif #include /* #ifdef WIN64 #define long long long #endif */ #else #include #include #include #endif /* code common to cygwin/linux and win32/win64: */ #ifdef VERBOSE #define VVERBOSE (1) #else #define VVERBOSE (0) #endif /* the following values must be larger than 256 and must fit in an int */ #define QUIT 1024 /* terminate now command */ #define QUERY 512 /* termination status query message */ #define QUERY_F 513 /* query failed, cannot quit */ #define GN_FRAMES (int) (GWQ_SIZE / (double) sizeof(SM_frame)) #define LN_FRAMES (int) (LWQ_SIZE / (double) sizeof(SM_frame)) #ifndef VMAX #define VMAX VECTORSZ #endif #ifndef PMAX #define PMAX 64 #endif #ifndef QMAX #define QMAX 64 #endif #if VECTORSZ>32000 #define OFFT int #else #define OFFT short #endif #ifdef SET_SEG_SIZE /* no longer usefule -- being recomputed for local heap size anyway */ double SEG_SIZE = (((double) SET_SEG_SIZE) * 1048576.); #else double SEG_SIZE = (1048576.*1024.); /* 1GB default shared memory pool segments */ #endif double LWQ_SIZE = 0.; /* initialized in main */ #ifdef SET_WQ_SIZE #ifdef NGQ #warning SET_WQ_SIZE applies to global queue -- ignored double GWQ_SIZE = 0.; #else double GWQ_SIZE = (((double) SET_WQ_SIZE) * 1048576.); /* must match the value in pan_proxy.c, if used */ #endif #else #ifdef NGQ double GWQ_SIZE = 0.; #else double GWQ_SIZE = (128.*1048576.); /* 128 MB default queue sizes */ #endif #endif /* Crash Detection Parameters */ #ifndef ONESECOND #define ONESECOND (1<<25) #endif #ifndef SHORT_T #define SHORT_T (0.1) #endif #ifndef LONG_T #define LONG_T (600) #endif double OneSecond = (double) (ONESECOND); /* waiting for a free slot -- checks crash */ double TenSeconds = 10. * (ONESECOND); /* waiting for a lock -- check for a crash */ /* Termination Detection Params -- waiting for new state input in Get_Full_Frame */ double Delay = ((double) SHORT_T) * (ONESECOND); /* termination detection trigger */ double OneHour = ((double) LONG_T) * (ONESECOND); /* timeout termination detection */ typedef struct SM_frame SM_frame; typedef struct SM_results SM_results; typedef struct sh_Allocater sh_Allocater; struct SM_frame { /* about 6K per slot */ volatile int m_vsize; /* 0 means free slot */ volatile int m_boq; /* >500 is a control message */ #ifdef FULL_TRAIL volatile struct Stack_Tree *m_stack; /* ptr to previous state */ #endif volatile uchar m_tau; volatile uchar m_o_pm; volatile int nr_handoffs; /* to compute real_depth */ volatile char m_now [VMAX]; #if !defined(NOCOMP) && !defined(HC) volatile char m_mask [(VMAX + 7)/8]; #endif volatile OFFT m_p_offset[PMAX]; volatile OFFT m_q_offset[QMAX]; volatile uchar m_p_skip [PMAX]; volatile uchar m_q_skip [QMAX]; #if defined(C_States) && (HAS_TRACK==1) && (HAS_STACK==1) volatile uchar m_c_stack [StackSize]; #endif }; int proxy_pid; /* id of proxy if nonzero -- receive half */ int store_proxy_pid; short remote_party; int proxy_pid_snd; /* id of proxy if nonzero -- send half */ char o_cmdline[512]; /* to pass options to children */ int iamin[CS_NR+NCORE]; /* non-shared */ #if defined(WIN32) || defined(WIN64) int tas(volatile LONG *); HANDLE proxy_handle_snd; /* for Windows Create and Terminate */ struct sh_Allocater { /* shared memory for states */ volatile char *dc_arena; /* to allocate states from */ volatile long pattern; /* to detect overruns */ volatile long dc_size; /* nr of bytes left */ volatile void *dc_start; /* where memory segment starts */ volatile void *dc_id; /* to attach, detach, remove shared memory segments */ volatile sh_Allocater *nxt; /* linked list of pools */ }; DWORD worker_pids[NCORE]; /* root mem of pids of all workers created */ HANDLE worker_handles[NCORE]; /* for windows Create and Terminate */ void * shmid [NR_QS]; /* return value from CreateFileMapping */ void * shmid_M; /* shared mem for state allocation in hashtable */ #ifdef SEP_STATE void *shmid_X; #else void *shmid_S; /* shared bitstate arena or hashtable */ #endif #else int tas(volatile int *); struct sh_Allocater { /* shared memory for states */ volatile char *dc_arena; /* to allocate states from */ volatile long pattern; /* to detect overruns */ volatile long dc_size; /* nr of bytes left */ volatile char *dc_start; /* where memory segment starts */ volatile int dc_id; /* to attach, detach, remove shared memory segments */ volatile sh_Allocater *nxt; /* linked list of pools */ }; int worker_pids[NCORE]; /* root mem of pids of all workers created */ int shmid [NR_QS]; /* return value from shmget */ int nibis = 0; /* set after shared mem has been released */ int shmid_M; /* shared mem for state allocation in hashtable */ #ifdef SEP_STATE long shmid_X; #else int shmid_S; /* shared bitstate arena or hashtable */ volatile sh_Allocater *first_pool; /* of shared state memory */ volatile sh_Allocater *last_pool; #endif #endif struct SM_results { /* for shuttling back final stats */ volatile int m_vsize; /* avoid conflicts with frames */ volatile int m_boq; /* these 2 fields are not written in record_info */ /* probably not all fields really need to be volatile */ volatile double m_memcnt; volatile double m_nstates; volatile double m_truncs; volatile double m_truncs2; volatile double m_nShadow; volatile double m_nlinks; volatile double m_ngrabs; volatile double m_nlost; volatile double m_hcmp; volatile double m_frame_wait; volatile int m_hmax; volatile int m_svmax; volatile int m_smax; volatile int m_mreached; volatile int m_errors; volatile int m_VMAX; volatile short m_PMAX; volatile short m_QMAX; volatile uchar m_R; /* reached info for all proctypes */ }; int core_id = 0; /* internal process nr, to know which q to use */ unsigned long nstates_put = 0; /* statistics */ unsigned long nstates_get = 0; int query_in_progress = 0; /* termination detection */ double free_wait = 0.; /* waiting for a free frame */ double frame_wait = 0.; /* waiting for a full frame */ double lock_wait = 0.; /* waiting for access to cs */ double glock_wait[3]; /* waiting for access to global lock */ char *sprefix = "rst"; uchar was_interrupted, issued_kill, writing_trail; static SM_frame cur_Root; /* current root, to be safe with error trails */ SM_frame *m_workq [NR_QS]; /* per cpu work queues + global q */ char *shared_mem[NR_QS]; /* return value from shmat */ #ifdef SEP_HEAP char *my_heap; long my_size; #endif volatile sh_Allocater *dc_shared; /* assigned at initialization */ static int vmax_seen, pmax_seen, qmax_seen; static double gq_tries, gq_hasroom, gq_hasnoroom; volatile int *prfree; volatile int *prfull; volatile int *prcnt; volatile int *prmax; volatile int *sh_lock; /* mutual exclusion locks - in shared memory */ volatile double *is_alive; /* to detect when processes crash */ volatile int *grfree, *grfull, *grcnt, *grmax; /* access to shared global q */ volatile double *gr_readmiss, *gr_writemiss; static int lrfree; /* used for temporary recording of slot */ static int dfs_phase2; void mem_put(int); /* handoff state to other cpu */ void mem_put_acc(void); /* liveness mode */ void mem_get(void); /* get state from work queue */ void sudden_stop(char *); void record_info(SM_results *r) { int i; uchar *ptr; #ifdef SEP_STATE if (0) { cpu_printf("nstates %g nshadow %g -- memory %-6.3f Mb\n", nstates, nShadow, memcnt/(1048576.)); } r->m_memcnt = 0; #else #ifdef BITSTATE r->m_memcnt = 0; /* it's shared */ #endif r->m_memcnt = memcnt; #endif if (a_cycles && core_id == 1) { r->m_nstates = nstates; r->m_nShadow = nstates; } else { r->m_nstates = nstates; r->m_nShadow = nShadow; } r->m_truncs = truncs; r->m_truncs2 = truncs2; r->m_nlinks = nlinks; r->m_ngrabs = ngrabs; r->m_nlost = nlost; r->m_hcmp = hcmp; r->m_frame_wait = frame_wait; r->m_hmax = hmax; r->m_svmax = svmax; r->m_smax = smax; r->m_mreached = mreached; r->m_errors = errors; r->m_VMAX = vmax_seen; r->m_PMAX = (short) pmax_seen; r->m_QMAX = (short) qmax_seen; ptr = (uchar *) &(r->m_R); for (i = 0; i <= _NP_; i++) /* all proctypes */ { memcpy(ptr, reached[i], NrStates[i]*sizeof(uchar)); ptr += NrStates[i]*sizeof(uchar); } if (verbose>1) { cpu_printf("Put Results nstates %g (sz %d)\n", nstates, ptr - &(r->m_R)); } } void snapshot(void); void retrieve_info(SM_results *r) { int i, j; volatile uchar *ptr; snapshot(); /* for a final report */ enter_critical(GLOBAL_LOCK); #ifdef SEP_HEAP if (verbose) { printf("cpu%d: local heap-left %ld KB (%d MB)\n", core_id, (long) (my_size/1024), (int) (my_size/1048576)); } #endif if (verbose && core_id == 0) { printf("qmax: "); for (i = 0; i < NCORE; i++) { printf("%d ", prmax[i]); } #ifndef NGQ printf("G: %d", *grmax); #endif printf("\n"); } leave_critical(GLOBAL_LOCK); memcnt += r->m_memcnt; nstates += r->m_nstates; nShadow += r->m_nShadow; truncs += r->m_truncs; truncs2 += r->m_truncs2; nlinks += r->m_nlinks; ngrabs += r->m_ngrabs; nlost += r->m_nlost; hcmp += r->m_hcmp; /* frame_wait += r->m_frame_wait; */ errors += r->m_errors; if (hmax < r->m_hmax) hmax = r->m_hmax; if (svmax < r->m_svmax) svmax = r->m_svmax; if (smax < r->m_smax) smax = r->m_smax; if (mreached < r->m_mreached) mreached = r->m_mreached; if (vmax_seen < r->m_VMAX) vmax_seen = r->m_VMAX; if (pmax_seen < (int) r->m_PMAX) pmax_seen = (int) r->m_PMAX; if (qmax_seen < (int) r->m_QMAX) qmax_seen = (int) r->m_QMAX; ptr = &(r->m_R); for (i = 0; i <= _NP_; i++) /* all proctypes */ { for (j = 0; j < NrStates[i]; j++) { if (*(ptr + j) != 0) { reached[i][j] = 1; } } ptr += NrStates[i]*sizeof(uchar); } if (verbose>1) { cpu_printf("Got Results (%d)\n", (int) (ptr - &(r->m_R))); snapshot(); } } #if !defined(WIN32) && !defined(WIN64) static void rm_shared_segments(void) { int m; volatile sh_Allocater *nxt_pool; /* * mark all shared memory segments for removal * the actual removes wont happen intil last process dies or detaches * the shmctl calls can return -1 if not all procs have detached yet */ for (m = 0; m < NR_QS; m++) /* +1 for global q */ { if (shmid[m] != -1) { (void) shmctl(shmid[m], IPC_RMID, NULL); } } #ifdef SEP_STATE if (shmid_M != -1) { (void) shmctl(shmid_M, IPC_RMID, NULL); } #else if (shmid_S != -1) { (void) shmctl(shmid_S, IPC_RMID, NULL); } for (last_pool = first_pool; last_pool != NULL; last_pool = nxt_pool) { shmid_M = (int) (last_pool->dc_id); nxt_pool = last_pool->nxt; /* as a pre-caution only */ if (shmid_M != -1) { (void) shmctl(shmid_M, IPC_RMID, NULL); } } #endif } #endif void sudden_stop(char *s) { char b[64]; int i; printf("cpu%d: stop - %s\n", core_id, s); #if !defined(WIN32) && !defined(WIN64) if (proxy_pid != 0) { rm_shared_segments(); } #endif if (search_terminated != NULL) { if (*search_terminated != 0) { if (verbose) { printf("cpu%d: termination initiated (%d)\n", core_id, (int) *search_terminated); } } else { if (verbose) { printf("cpu%d: initiated termination\n", core_id); } *search_terminated |= 8; /* sudden_stop */ } if (core_id == 0) { if (((*search_terminated) & 4) /* uerror in one of the cpus */ && !((*search_terminated) & (8|32|128|256))) /* abnormal stop */ { if (errors == 0) errors++; /* we know there is at least 1 */ } wrapup(); /* incomplete stats, but at least something */ } return; } /* else: should rarely happen, take more drastic measures */ if (core_id == 0) /* local root process */ { for (i = 1; i < NCORE; i++) /* not for 0 of course */ { int ignore; #if defined(WIN32) || defined(WIN64) DWORD dwExitCode = 0; GetExitCodeProcess(worker_handles[i], &dwExitCode); if (dwExitCode == STILL_ACTIVE) { TerminateProcess(worker_handles[i], 0); } printf("cpu0: terminate %d %d\n", (int) worker_pids[i], (dwExitCode == STILL_ACTIVE)); #else sprintf(b, "kill -%d %d", (int) SIGKILL, (int) worker_pids[i]); ignore = system(b); /* if this is a proxy: receive half */ printf("cpu0: %s\n", b); #endif } issued_kill++; } else { /* on WIN32/WIN64 -- these merely kills the root process... */ if (was_interrupted == 0) { int ignore; sprintf(b, "kill -%d %d", (int) SIGINT, (int) worker_pids[0]); ignore = system(b); /* warn the root process */ printf("cpu%d: %s\n", core_id, b); issued_kill++; } } } #define iam_alive() is_alive[core_id]++ extern int crash_test(double); extern void crash_reset(void); int someone_crashed(int wait_type) { static double last_value = 0.0; static int count = 0; if (search_terminated == NULL || *search_terminated != 0) { if (!(*search_terminated & (8|32|128|256))) { if (count++ < 100*NCORE) { return 0; } } return 1; } /* check left neighbor only */ if (last_value == is_alive[(core_id + NCORE - 1) % NCORE]) { if (count++ >= 100) /* to avoid unnecessary checks */ { return 1; } return 0; } last_value = is_alive[(core_id + NCORE - 1) % NCORE]; count = 0; crash_reset(); return 0; } void sleep_report(void) { enter_critical(GLOBAL_LOCK); if (verbose) { #ifdef NGQ printf("cpu%d: locks: global %g\tother %g\t", core_id, glock_wait[0], lock_wait - glock_wait[0]); #else printf("cpu%d: locks: GL %g, RQ %g, WQ %g, HT %g\t", core_id, glock_wait[0], glock_wait[1], glock_wait[2], lock_wait - glock_wait[0] - glock_wait[1] - glock_wait[2]); #endif printf("waits: states %g slots %g\n", frame_wait, free_wait); #ifndef NGQ printf("cpu%d: gq [tries %g, room %g, noroom %g]\n", core_id, gq_tries, gq_hasroom, gq_hasnoroom); if (core_id == 0 && (*gr_readmiss >= 1.0 || *gr_readmiss >= 1.0 || *grcnt != 0)) printf("cpu0: gq [readmiss: %g, writemiss: %g cnt %d]\n", *gr_readmiss, *gr_writemiss, *grcnt); #endif } if (free_wait > 1000000.) #ifndef NGQ if (!a_cycles) { printf("hint: this search may be faster with a larger work-queue\n"); printf(" (-DSET_WQ_SIZE=N with N>%g), and/or with -DUSE_DISK\n", GWQ_SIZE/sizeof(SM_frame)); printf(" or with a larger value for -zN (N>%ld)\n", z_handoff); #else { printf("hint: this search may be faster if compiled without -DNGQ, with -DUSE_DISK, "); printf("or with a larger -zN (N>%d)\n", z_handoff); #endif } leave_critical(GLOBAL_LOCK); } #ifndef MAX_DSK_FILE #define MAX_DSK_FILE 1000000 /* default is max 1M states per file */ #endif void multi_usage(FILE *fd) { static int warned = 0; if (warned > 0) { return; } else { warned++; } fprintf(fd, "\n"); fprintf(fd, "Defining multi-core mode:\n\n"); fprintf(fd, " -DDUAL_CORE --> same as -DNCORE=2\n"); fprintf(fd, " -DQUAD_CORE --> same as -DNCORE=4\n"); fprintf(fd, " -DNCORE=N --> enables multi_core verification if N>1\n"); fprintf(fd, "\n"); fprintf(fd, "Additional directives supported in multi-core mode:\n\n"); fprintf(fd, " -DSEP_STATE --> forces separate statespaces instead of a single shared state space\n"); fprintf(fd, " -DNUSE_DISK --> use disk for storing states when a work queue overflows\n"); fprintf(fd, " -DMAX_DSK_FILE --> max nr of states per diskfile (%d)\n", MAX_DSK_FILE); fprintf(fd, " -DFULL_TRAIL --> support full error trails (increases memory use)\n"); fprintf(fd, "\n"); fprintf(fd, "More advanced use (should rarely need changing):\n\n"); fprintf(fd, " To change the nr of states that can be stored in the global queue\n"); fprintf(fd, " (lower numbers allow for more states to be stored, prefer multiples of 8):\n"); fprintf(fd, " -DVMAX=N --> upperbound on statevector for handoffs (N=%d)\n", VMAX); fprintf(fd, " -DPMAX=N --> upperbound on nr of procs (default: N=%d)\n", PMAX); fprintf(fd, " -DQMAX=N --> upperbound on nr of channels (default: N=%d)\n", QMAX); fprintf(fd, "\n"); fprintf(fd, " To set the total amount of memory reserved for the global workqueue:\n"); fprintf(fd, " -DSET_WQ_SIZE=N --> default: N=128 (defined in MBytes)\n\n"); fprintf(fd, " To force the use of a single global heap, instead of separate heaps:\n"); fprintf(fd, " -DGLOB_HEAP\n"); fprintf(fd, "\n"); fprintf(fd, " To define a fct to initialize data before spawning processes (use quotes):\n"); fprintf(fd, " \"-DC_INIT=fct()\"\n"); fprintf(fd, "\n"); fprintf(fd, " Timer settings for termination and crash detection:\n"); fprintf(fd, " -DSHORT_T=N --> timeout for termination detection trigger (N=%g)\n", (double) SHORT_T); fprintf(fd, " -DLONG_T=N --> timeout for giving up on termination detection (N=%g)\n", (double) LONG_T); fprintf(fd, " -DONESECOND --> (1<<29) --> timeout waiting for a free slot -- to check for crash\n"); fprintf(fd, " -DT_ALERT --> collect stats on crash alert timeouts\n\n"); fprintf(fd, "Help with Linux/Windows/Cygwin configuration for multi-core:\n"); fprintf(fd, " http://spinroot.com/spin/multicore/V5_Readme.html\n"); fprintf(fd, "\n"); } #if NCORE>1 && defined(FULL_TRAIL) typedef struct Stack_Tree { uchar pr; /* process that made transition */ T_ID t_id; /* id of transition */ volatile struct Stack_Tree *prv; /* backward link towards root */ } Stack_Tree; H_el *grab_shared(int); volatile Stack_Tree **stack_last; /* in shared memory */ char *stack_cache = NULL; /* local */ int nr_cached = 0; /* local */ #ifndef CACHE_NR #define CACHE_NR 1024 #endif volatile Stack_Tree * stack_prefetch(void) { volatile Stack_Tree *st; if (nr_cached == 0) { stack_cache = (char *) grab_shared(CACHE_NR * sizeof(Stack_Tree)); nr_cached = CACHE_NR; } st = (volatile Stack_Tree *) stack_cache; stack_cache += sizeof(Stack_Tree); nr_cached--; return st; } void Push_Stack_Tree(short II, T_ID t_id) { volatile Stack_Tree *st; st = (volatile Stack_Tree *) stack_prefetch(); st->pr = II; st->t_id = t_id; st->prv = (Stack_Tree *) stack_last[core_id]; stack_last[core_id] = st; } void Pop_Stack_Tree(void) { volatile Stack_Tree *cf = stack_last[core_id]; if (cf) { stack_last[core_id] = cf->prv; } else if (nr_handoffs * z_handoff + depth > 0) { printf("cpu%d: error pop_stack_tree (depth %ld)\n", core_id, depth); } } #endif void e_critical(int which) { double cnt_start; if (readtrail || iamin[which] > 0) { if (!readtrail && verbose) { printf("cpu%d: Double Lock on %d (now %d)\n", core_id, which, iamin[which]+1); fflush(stdout); } iamin[which]++; /* local variable */ return; } cnt_start = lock_wait; while (sh_lock != NULL) /* as long as we have shared memory */ { int r = tas(&sh_lock[which]); if (r == 0) { iamin[which] = 1; return; /* locked */ } lock_wait++; #ifndef NGQ if (which < 3) { glock_wait[which]++; } #else if (which == 0) { glock_wait[which]++; } #endif iam_alive(); if (lock_wait - cnt_start > TenSeconds) { printf("cpu%d: lock timeout on %d\n", core_id, which); cnt_start = lock_wait; if (someone_crashed(1)) { sudden_stop("lock timeout"); pan_exit(1); } } } } void x_critical(int which) { if (iamin[which] != 1) { if (iamin[which] > 1) { iamin[which]--; /* this is thread-local - no races on this one */ if (!readtrail && verbose) { printf("cpu%d: Partial Unlock on %d (%d more needed)\n", core_id, which, iamin[which]); fflush(stdout); } return; } else /* iamin[which] <= 0 */ { if (!readtrail) { printf("cpu%d: Invalid Unlock iamin[%d] = %d\n", core_id, which, iamin[which]); fflush(stdout); } return; } } if (sh_lock != NULL) { iamin[which] = 0; #if defined(__powerpc64__) #if 1 __sync_synchronize(); /* srirajpaul */ #else __lwsync(); /* xlc compiler only */ #endif #endif sh_lock[which] = 0; /* unlock */ } } void #if defined(WIN32) || defined(WIN64) start_proxy(char *s, DWORD r_pid) #else start_proxy(char *s, int r_pid) #endif { char Q_arg[16], Z_arg[16], Y_arg[16]; char *args[32], *ptr; int argcnt = 0; sprintf(Q_arg, "-Q%d", getpid()); sprintf(Y_arg, "-Y%d", r_pid); sprintf(Z_arg, "-Z%d", proxy_pid /* core_id */); args[argcnt++] = "proxy"; args[argcnt++] = s; /* -r or -s */ args[argcnt++] = Q_arg; args[argcnt++] = Z_arg; args[argcnt++] = Y_arg; if (strlen(o_cmdline) > 0) { ptr = o_cmdline; /* assume args separated by spaces */ do { args[argcnt++] = ptr++; if ((ptr = strchr(ptr, ' ')) != NULL) { while (*ptr == ' ') { *ptr++ = '\0'; } } else { break; } } while (argcnt < 31); } args[argcnt] = NULL; #if defined(WIN32) || defined(WIN64) execvp("pan_proxy", args); /* no return */ #else execvp("./pan_proxy", args); /* no return */ #endif Uerror("pan_proxy exec failed"); } /*** end of common code fragment ***/ #if !defined(WIN32) && !defined(WIN64) void init_shm(void) /* initialize shared work-queues - linux/cygwin */ { key_t key[NR_QS]; int n, m; int must_exit = 0; if (core_id == 0 && verbose) { printf("cpu0: step 3: allocate shared workqueues %g MB\n", ((double) NCORE * LWQ_SIZE + GWQ_SIZE) / (1048576.) ); } for (m = 0; m < NR_QS; m++) /* last q is the global q */ { double qsize = (m == NCORE) ? GWQ_SIZE : LWQ_SIZE; key[m] = ftok(PanSource, m+1); if (key[m] == -1) { perror("ftok shared queues"); must_exit = 1; break; } if (core_id == 0) /* root creates */ { /* check for stale copy */ shmid[m] = shmget(key[m], (size_t) qsize, 0600); if (shmid[m] != -1) /* yes there is one; remove it */ { printf("cpu0: removing stale q%d, status: %d\n", m, shmctl(shmid[m], IPC_RMID, NULL)); } shmid[m] = shmget(key[m], (size_t) qsize, 0600|IPC_CREAT|IPC_EXCL); memcnt += qsize; } else /* workers attach */ { shmid[m] = shmget(key[m], (size_t) qsize, 0600); /* never called, since we create shm *before* we fork */ } if (shmid[m] == -1) { perror("shmget shared queues"); must_exit = 1; break; } shared_mem[m] = (char *) shmat(shmid[m], (void *) 0, 0); /* attach */ if (shared_mem[m] == (char *) -1) { fprintf(stderr, "error: cannot attach shared wq %d (%d Mb)\n", m+1, (int) (qsize/(1048576.))); perror("shmat shared queues"); must_exit = 1; break; } m_workq[m] = (SM_frame *) shared_mem[m]; if (core_id == 0) { int nframes = (m == NCORE) ? GN_FRAMES : LN_FRAMES; for (n = 0; n < nframes; n++) { m_workq[m][n].m_vsize = 0; m_workq[m][n].m_boq = 0; } } } if (must_exit) { rm_shared_segments(); fprintf(stderr, "pan: check './pan --' for usage details\n"); pan_exit(1); /* calls cleanup_shm */ } } static uchar * prep_shmid_S(size_t n) /* either sets SS or H_tab, linux/cygwin */ { char *rval; #ifndef SEP_STATE key_t key; if (verbose && core_id == 0) { #ifdef BITSTATE printf("cpu0: step 1: allocate shared bitstate %g Mb\n", (double) n / (1048576.)); #else printf("cpu0: step 1: allocate shared hastable %g Mb\n", (double) n / (1048576.)); #endif } #ifdef MEMLIM if (memcnt + (double) n > memlim) { printf("cpu0: S %8g + %d Kb exceeds memory limit of %8g Mb\n", memcnt/1024., (int) (n/1024), memlim/(1048576.)); printf("cpu0: insufficient memory -- aborting\n"); exit(1); } #endif key = ftok(PanSource, NCORE+2); /* different from queues */ if (key == -1) { perror("ftok shared bitstate or hashtable"); fprintf(stderr, "pan: check './pan --' for usage details\n"); pan_exit(1); } if (core_id == 0) /* root */ { shmid_S = shmget(key, n, 0600); if (shmid_S != -1) { printf("cpu0: removing stale segment, status: %d\n", (int) shmctl(shmid_S, IPC_RMID, NULL)); } shmid_S = shmget(key, n, 0600 | IPC_CREAT | IPC_EXCL); memcnt += (double) n; } else /* worker */ { shmid_S = shmget(key, n, 0600); } if (shmid_S == -1) { perror("shmget shared bitstate or hashtable too large?"); fprintf(stderr, "pan: check './pan --' for usage details\n"); pan_exit(1); } rval = (char *) shmat(shmid_S, (void *) 0, 0); /* attach */ if ((char *) rval == (char *) -1) { perror("shmat shared bitstate or hashtable"); fprintf(stderr, "pan: check './pan --' for usage details\n"); pan_exit(1); } #else rval = (char *) emalloc(n); #endif return (uchar *) rval; } #define TRY_AGAIN 1 #define NOT_AGAIN 0 static char shm_prep_result; static uchar * prep_state_mem(size_t n) /* sets memory arena for states linux/cygwin */ { char *rval; key_t key; static int cnt = 3; /* start larger than earlier ftok calls */ shm_prep_result = NOT_AGAIN; /* default */ if (verbose && core_id == 0) { printf("cpu0: step 2+: pre-allocate memory arena %d of %6.2g Mb\n", cnt-3, (double) n / (1048576.)); } #ifdef MEMLIM if (memcnt + (double) n > memlim) { printf("cpu0: error: M %.0f + %.0f Kb exceeds memory limit of %.0f Mb\n", memcnt/1024.0, (double) n/1024.0, memlim/(1048576.)); return NULL; } #endif key = ftok(PanSource, NCORE+cnt); cnt++; if (key == -1) { perror("ftok T"); printf("pan: check './pan --' for usage details\n"); pan_exit(1); } if (core_id == 0) { shmid_M = shmget(key, n, 0600); if (shmid_M != -1) { printf("cpu0: removing stale memory segment %d, status: %d\n", cnt-3, shmctl(shmid_M, IPC_RMID, NULL)); } shmid_M = shmget(key, n, 0600 | IPC_CREAT | IPC_EXCL); /* memcnt += (double) n; -- only amount actually used is counted */ } else { shmid_M = shmget(key, n, 0600); } if (shmid_M == -1) { if (verbose) { printf("error: failed to get pool of shared memory %d of %.0f Mb\n", cnt-3, ((double)n)/(1048576.)); perror("state mem"); printf("pan: check './pan --' for usage details\n"); } shm_prep_result = TRY_AGAIN; return NULL; } rval = (char *) shmat(shmid_M, (void *) 0, 0); /* attach */ if ((char *) rval == (char *) -1) { printf("cpu%d error: failed to attach pool of shared memory %d of %.0f Mb\n", core_id, cnt-3, ((double)n)/(1048576.)); perror("state mem"); return NULL; } return (uchar *) rval; } void init_HT(unsigned long n) /* cygwin/linux version */ { volatile char *x; double get_mem; #ifndef SEP_STATE volatile char *dc_mem_start; double need_mem, got_mem = 0.; #endif #ifdef SEP_STATE #ifndef MEMLIM if (verbose) { printf("cpu0: steps 0,1: no -DMEMLIM set\n"); } #else if (verbose) { printf("cpu0: steps 0,1: -DMEMLIM=%d Mb - (hashtable %g Mb + workqueues %g Mb)\n", MEMLIM, ((double)n/(1048576.)), (((double) NCORE * LWQ_SIZE) + GWQ_SIZE) /(1048576.) ); } #endif get_mem = NCORE * sizeof(double) + (1 + CS_NR) * sizeof(void *) + 4*sizeof(void *) + 2*sizeof(double); /* NCORE * is_alive + search_terminated + CS_NR * sh_lock + 6 gr vars */ get_mem += 4 * NCORE * sizeof(void *); /* prfree, prfull, prcnt, prmax */ #ifdef FULL_TRAIL get_mem += (NCORE) * sizeof(Stack_Tree *); /* NCORE * stack_last */ #endif x = (volatile char *) prep_state_mem((size_t) get_mem); /* work queues and basic structs */ shmid_X = (long) x; if (x == NULL) { printf("cpu0: could not allocate shared memory, see ./pan --\n"); exit(1); } search_terminated = (volatile unsigned int *) x; /* comes first */ x += sizeof(void *); /* maintain alignment */ is_alive = (volatile double *) x; x += NCORE * sizeof(double); sh_lock = (volatile int *) x; x += CS_NR * sizeof(void *); grfree = (volatile int *) x; x += sizeof(void *); grfull = (volatile int *) x; x += sizeof(void *); grcnt = (volatile int *) x; x += sizeof(void *); grmax = (volatile int *) x; x += sizeof(void *); prfree = (volatile int *) x; x += NCORE * sizeof(void *); prfull = (volatile int *) x; x += NCORE * sizeof(void *); prcnt = (volatile int *) x; x += NCORE * sizeof(void *); prmax = (volatile int *) x; x += NCORE * sizeof(void *); gr_readmiss = (volatile double *) x; x += sizeof(double); gr_writemiss = (volatile double *) x; x += sizeof(double); #ifdef FULL_TRAIL stack_last = (volatile Stack_Tree **) x; x += NCORE * sizeof(Stack_Tree *); #endif #ifndef BITSTATE H_tab = (H_el **) emalloc(n); #endif #else #ifndef MEMLIM #warning MEMLIM not set #define MEMLIM (2048) #endif if (core_id == 0 && verbose) { printf("cpu0: step 0: -DMEMLIM=%d Mb minus hashtable+workqs (%g + %g Mb) leaves %g Mb\n", MEMLIM, ((double)n/(1048576.)), (NCORE * LWQ_SIZE + GWQ_SIZE)/(1048576.), (memlim - memcnt - (double) n - (NCORE * LWQ_SIZE + GWQ_SIZE))/(1048576.)); } #ifndef BITSTATE H_tab = (H_el **) prep_shmid_S((size_t) n); /* hash_table */ #endif need_mem = memlim - memcnt - ((double) NCORE * LWQ_SIZE) - GWQ_SIZE; if (need_mem <= 0.) { Uerror("internal error -- shared state memory"); } if (core_id == 0 && verbose) { printf("cpu0: step 2: pre-allocate shared state memory %g Mb\n", need_mem/(1048576.)); } #ifdef SEP_HEAP SEG_SIZE = need_mem / NCORE; if (verbose && core_id == 0) { printf("cpu0: setting segsize to %6g MB\n", SEG_SIZE/(1048576.)); } #if defined(CYGWIN) || defined(__CYGWIN__) if (SEG_SIZE > 512.*1024.*1024.) { printf("warning: reducing SEG_SIZE of %g MB to 512MB (exceeds max for Cygwin)\n", SEG_SIZE/(1024.*1024.)); SEG_SIZE = 512.*1024.*1024.; } #endif #endif mem_reserved = need_mem; while (need_mem > 1024.) { get_mem = need_mem; shm_more: if (get_mem > (double) SEG_SIZE) { get_mem = (double) SEG_SIZE; } if (get_mem <= 0.0) break; /* for allocating states: */ x = dc_mem_start = (volatile char *) prep_state_mem((size_t) get_mem); if (x == NULL) { if (shm_prep_result == NOT_AGAIN || first_pool != NULL || SEG_SIZE < (16. * 1048576.)) { break; } SEG_SIZE /= 2.; if (verbose) { printf("pan: lowered segsize to 0.000000\n", SEG_SIZE); } if (SEG_SIZE >= 1024.) { goto shm_more; } break; } need_mem -= get_mem; got_mem += get_mem; if (first_pool == NULL) { search_terminated = (volatile unsigned int *) x; /* comes first */ x += sizeof(void *); /* maintain alignment */ is_alive = (volatile double *) x; x += NCORE * sizeof(double); sh_lock = (volatile int *) x; x += CS_NR * sizeof(void *); grfree = (volatile int *) x; x += sizeof(void *); grfull = (volatile int *) x; x += sizeof(void *); grcnt = (volatile int *) x; x += sizeof(void *); grmax = (volatile int *) x; x += sizeof(void *); prfree = (volatile int *) x; x += NCORE * sizeof(void *); prfull = (volatile int *) x; x += NCORE * sizeof(void *); prcnt = (volatile int *) x; x += NCORE * sizeof(void *); prmax = (volatile int *) x; x += NCORE * sizeof(void *); gr_readmiss = (volatile double *) x; x += sizeof(double); gr_writemiss = (volatile double *) x; x += sizeof(double); #ifdef FULL_TRAIL stack_last = (volatile Stack_Tree **) x; x += NCORE * sizeof(Stack_Tree *); #endif if (((long)x)&(sizeof(void *)-1)) /* 64-bit word alignment */ { x += sizeof(void *)-(((long)x)&(sizeof(void *)-1)); } #ifdef COLLAPSE ncomps = (unsigned long *) x; x += (256+2) * sizeof(unsigned long); #endif } dc_shared = (sh_Allocater *) x; /* must be in shared memory */ x += sizeof(sh_Allocater); if (core_id == 0) /* root only */ { dc_shared->dc_id = shmid_M; dc_shared->dc_start = dc_mem_start; dc_shared->dc_arena = x; dc_shared->pattern = 1234567; /* protection */ dc_shared->dc_size = (long) get_mem - (long) (x - dc_mem_start); dc_shared->nxt = (long) 0; if (last_pool == NULL) { first_pool = last_pool = dc_shared; } else { last_pool->nxt = dc_shared; last_pool = dc_shared; } } else if (first_pool == NULL) { first_pool = dc_shared; } } if (need_mem > 1024.) { printf("cpu0: could allocate only %g Mb of shared memory (wanted %g more)\n", got_mem/(1048576.), need_mem/(1048576.)); } if (!first_pool) { printf("cpu0: insufficient memory -- aborting.\n"); exit(1); } /* we are still single-threaded at this point, with core_id 0 */ dc_shared = first_pool; #endif } void cleanup_shm(int val) { volatile sh_Allocater *nxt_pool; unsigned long cnt = 0; int m; if (nibis != 0) { printf("cpu%d: Redundant call to cleanup_shm(%d)\n", core_id, val); return; } else { nibis = 1; } if (search_terminated != NULL) { *search_terminated |= 16; /* cleanup_shm */ } for (m = 0; m < NR_QS; m++) { if (shmdt((void *) shared_mem[m]) > 0) { perror("shmdt detaching from shared queues"); } } #ifdef SEP_STATE if (shmdt((void *) shmid_X) != 0) { perror("shmdt detaching from shared state memory"); } #else #ifdef BITSTATE if (SS > 0 && shmdt((void *) SS) != 0) { if (verbose) { perror("shmdt detaching from shared bitstate arena"); } } #else if (core_id == 0) { /* before detaching: */ for (nxt_pool = dc_shared; nxt_pool != NULL; nxt_pool = nxt_pool->nxt) { cnt += nxt_pool->dc_size; } if (verbose) { printf("cpu0: done, %ld Mb of shared state memory left\n", cnt / (long)(1048576)); } } if (shmdt((void *) H_tab) != 0) { perror("shmdt detaching from shared hashtable"); } for (last_pool = first_pool; last_pool != NULL; last_pool = nxt_pool) { nxt_pool = last_pool->nxt; if (shmdt((void *) last_pool->dc_start) != 0) { perror("shmdt detaching from shared state memory"); } } first_pool = last_pool = NULL; /* precaution */ #endif #endif /* detached from shared memory - so cannot use cpu_printf */ if (verbose) { printf("cpu%d: done -- got %ld states from queue\n", core_id, nstates_get); } } extern void give_up(int); extern void Read_Queue(int); void mem_get(void) { SM_frame *f; int is_parent; #if defined(MA) && !defined(SEP_STATE) #error MA without SEP_STATE is not supported with multi-core #endif #ifdef BFS #error instead of -DNCORE -DBFS use -DBFS_PAR #endif #ifdef SC #error SC is not supported with multi-core #endif init_shm(); /* we are single threaded when this starts */ if (core_id == 0 && verbose) { printf("cpu0: step 4: calling fork()\n"); } fflush(stdout); /* if NCORE > 1 the child or the parent should fork N-1 more times * the parent is the only process with core_id == 0 and is_parent > 0 * the workers have is_parent = 0 and core_id = 1..NCORE-1 */ if (core_id == 0) { worker_pids[0] = getpid(); /* for completeness */ while (++core_id < NCORE) /* first worker sees core_id = 1 */ { is_parent = fork(); if (is_parent == -1) { Uerror("fork failed"); } if (is_parent == 0) /* this is a worker process */ { if (proxy_pid == core_id) /* always non-zero */ { start_proxy("-r", 0); /* no return */ } goto adapt; /* root process continues spawning */ } worker_pids[core_id] = is_parent; } /* note that core_id is now NCORE */ if (proxy_pid > 0 && proxy_pid < NCORE) { proxy_pid_snd = fork(); if (proxy_pid_snd == -1) { Uerror("proxy fork failed"); } if (proxy_pid_snd == 0) { start_proxy("-s", worker_pids[proxy_pid]); /* no return */ } } /* else continue */ if (is_parent > 0) { core_id = 0; /* reset core_id for root process */ } } else /* worker */ { static char db0[16]; /* good for up to 10^6 cores */ static char db1[16]; adapt: tprefix = db0; sprefix = db1; sprintf(tprefix, "cpu%d_trail", core_id); sprintf(sprefix, "cpu%d_rst", core_id); memcnt = 0; /* count only additionally allocated memory */ } signal(SIGINT, give_up); if (proxy_pid == 0) /* not in a cluster setup, pan_proxy must attach */ { rm_shared_segments(); /* mark all shared segments for removal on exit */ } if (verbose) { cpu_printf("starting core_id %d -- pid %d\n", core_id, getpid()); } #if defined(SEP_HEAP) && !defined(SEP_STATE) { int i; volatile sh_Allocater *ptr; ptr = first_pool; for (i = 0; i < NCORE && ptr != NULL; i++) { if (i == core_id) { my_heap = (char *) ptr->dc_arena; my_size = (long) ptr->dc_size; if (verbose) cpu_printf("local heap %ld MB\n", my_size/(1048576)); break; } ptr = ptr->nxt; /* local */ } if (my_heap == NULL) { printf("cpu%d: no local heap\n", core_id); pan_exit(1); } /* else */ #if defined(CYGWIN) || defined(__CYGWIN__) ptr = first_pool; for (i = 0; i < NCORE && ptr != NULL; i++) { ptr = ptr->nxt; /* local */ } dc_shared = ptr; /* any remainder */ #else dc_shared = NULL; /* used all mem for local heaps */ #endif } #endif if (core_id == 0 && !remote_party) { new_state(); /* cpu0 explores root */ if (verbose) cpu_printf("done with 1st dfs, nstates %g (put %d states), read q\n", nstates, nstates_put); dfs_phase2 = 1; } Read_Queue(core_id); /* all cores */ if (verbose) { cpu_printf("put %6d states into queue -- got %6d\n", nstates_put, nstates_get); } if (proxy_pid != 0) { rm_shared_segments(); } done = 1; wrapup(); exit(0); } #else int unpack_state(SM_frame *, int); #endif H_el * grab_shared(int n) { #ifndef SEP_STATE char *rval = (char *) 0; if (n == 0) { printf("cpu%d: grab shared zero\n", core_id); fflush(stdout); return (H_el *) rval; } else if (n&(sizeof(void *)-1)) { n += sizeof(void *)-(n&(sizeof(void *)-1)); /* alignment */ } #ifdef SEP_HEAP /* no locking */ if (my_heap != NULL && my_size > n) { rval = my_heap; my_heap += n; my_size -= n; goto done; } #endif if (!dc_shared) { sudden_stop("pan: out of memory"); } /* another lock is always already in effect when this is called */ /* but not always the same lock -- i.e., on different parts of the hashtable */ enter_critical(GLOBAL_LOCK); /* this must be independently mutex */ #if defined(SEP_HEAP) && !defined(WIN32) && !defined(WIN64) { static int noted = 0; if (!noted) { noted = 1; printf("cpu%d: global heap has %ld bytes left, needed %d\n", core_id, dc_shared?dc_shared->dc_size:0, n); } } #endif #if 0 if (dc_shared->pattern != 1234567) { leave_critical(GLOBAL_LOCK); Uerror("overrun -- memory corruption"); } #endif if (dc_shared->dc_size < n) { if (verbose) { printf("Next Pool %g Mb + %d\n", memcnt/(1048576.), n); } if (dc_shared->nxt == NULL || dc_shared->nxt->dc_arena == NULL || dc_shared->nxt->dc_size < n) { printf("cpu%d: memcnt %g Mb + wanted %d bytes more\n", core_id, memcnt / (1048576.), n); leave_critical(GLOBAL_LOCK); sudden_stop("out of memory -- aborting"); wrapup(); /* exits */ } else { dc_shared = (sh_Allocater *) dc_shared->nxt; } } rval = (char *) dc_shared->dc_arena; dc_shared->dc_arena += n; dc_shared->dc_size -= (long) n; #if 0 if (VVERBOSE) printf("cpu%d grab shared (%d bytes) -- %ld left\n", core_id, n, dc_shared->dc_size); #endif leave_critical(GLOBAL_LOCK); done: memset(rval, 0, n); memcnt += (double) n; return (H_el *) rval; #else return (H_el *) emalloc(n); #endif } SM_frame * Get_Full_Frame(int n) { SM_frame *f; double cnt_start = frame_wait; f = &m_workq[n][prfull[n]]; while (f->m_vsize == 0) /* await full slot LOCK : full frame */ { iam_alive(); #ifndef NGQ #ifndef SAFETY if (!a_cycles || core_id != 0) #endif if (*grcnt > 0) /* accessed outside lock, but safe even if wrong */ { enter_critical(GQ_RD); /* gq - read access */ if (*grcnt > 0) /* could have changed */ { f = &m_workq[NCORE][*grfull]; /* global q */ if (f->m_vsize == 0) { /* writer is still filling the slot */ *gr_writemiss++; f = &m_workq[n][prfull[n]]; /* reset */ } else { *grfull = (*grfull+1) % (GN_FRAMES); enter_critical(GQ_WR); *grcnt = *grcnt - 1; leave_critical(GQ_WR); leave_critical(GQ_RD); return f; } } leave_critical(GQ_RD); } #endif if (frame_wait++ - cnt_start > Delay) { if (0) { cpu_printf("timeout on q%d -- %u -- query %d\n", n, f, query_in_progress); } return (SM_frame *) 0; /* timeout */ } } iam_alive(); if (VVERBOSE) cpu_printf("got frame from q%d\n", n); prfull[n] = (prfull[n] + 1) % (LN_FRAMES); enter_critical(QLOCK(n)); prcnt[n]--; /* lock out increments */ leave_critical(QLOCK(n)); return f; } SM_frame * Get_Free_Frame(int n) { SM_frame *f; double cnt_start = free_wait; if (VVERBOSE) { cpu_printf("get free frame from q%d\n", n); } if (n == NCORE) /* global q */ { f = &(m_workq[n][lrfree]); } else { f = &(m_workq[n][prfree[n]]); } while (f->m_vsize != 0) /* await free slot LOCK : free slot */ { iam_alive(); if (free_wait++ - cnt_start > OneSecond) { if (verbose) { cpu_printf("timeout waiting for free slot q%d\n", n); } cnt_start = free_wait; if (someone_crashed(1)) { printf("cpu%d: search terminated\n", core_id); sudden_stop("get free frame"); pan_exit(1); } } } if (n != NCORE) { prfree[n] = (prfree[n] + 1) % (LN_FRAMES); enter_critical(QLOCK(n)); prcnt[n]++; /* lock out decrements */ if (prmax[n] < prcnt[n]) { prmax[n] = prcnt[n]; } leave_critical(QLOCK(n)); } return f; } #ifndef NGQ int GlobalQ_HasRoom(void) { int rval = 0; gq_tries++; if (*grcnt < GN_FRAMES) /* there seems to be room */ { enter_critical(GQ_WR); /* gq write access */ if (*grcnt < GN_FRAMES) { if (m_workq[NCORE][*grfree].m_vsize != 0) { /* can happen if reader is slow emptying slot */ *gr_readmiss++; goto out; /* dont wait: release lock and return */ } lrfree = *grfree; /* Get_Free_Frame use lrfree in this mode */ *grfree = (*grfree + 1) % GN_FRAMES; *grcnt = *grcnt + 1; /* count nr of slots filled -- no additional lock needed */ if (*grmax < *grcnt) *grmax = *grcnt; leave_critical(GQ_WR); /* for short lock duration */ gq_hasroom++; mem_put(NCORE); /* copy state into reserved slot */ rval = 1; /* successfull handoff */ } else { gq_hasnoroom++; out: leave_critical(GQ_WR); } } return rval; } #endif int unpack_state(SM_frame *f, int from_q) { int i, j; static H_el D_State; if (f->m_vsize > 0) { boq = f->m_boq; if (boq > 256) { cpu_printf("saw control %d, expected state\n", boq); return 0; } vsize = f->m_vsize; correct: memcpy((uchar *) &now, (uchar *) f->m_now, vsize); #if !defined(NOCOMP) && !defined(HC) for (i = j = 0; i < VMAX; i++, j = (j+1)%8) { Mask[i] = (f->m_mask[i/8] & (1< 0) { memcpy((uchar *) proc_offset, (uchar *) f->m_p_offset, now._nr_pr * sizeof(OFFT)); memcpy((uchar *) proc_skip, (uchar *) f->m_p_skip, now._nr_pr * sizeof(uchar)); } if (now._nr_qs > 0) { memcpy((uchar *) q_offset, (uchar *) f->m_q_offset, now._nr_qs * sizeof(OFFT)); memcpy((uchar *) q_skip, (uchar *) f->m_q_skip, now._nr_qs * sizeof(uchar)); } #ifndef NOVSZ if (vsize != now._vsz) { cpu_printf("vsize %d != now._vsz %d (type %d) %d\n", vsize, now._vsz, f->m_boq, f->m_vsize); vsize = now._vsz; goto correct; /* rare event: a race */ } #endif hmax = max(hmax, vsize); if (f != &cur_Root) { memcpy((uchar *) &cur_Root, (uchar *) f, sizeof(SM_frame)); } if (((now._a_t) & 1) == 1) /* i.e., when starting nested DFS */ { A_depth = depthfound = 0; memcpy((uchar *)&A_Root, (uchar *)&now, vsize); } nr_handoffs = f->nr_handoffs; } else { cpu_printf("pan: state empty\n"); } depth = 0; trpt = &trail[1]; trpt->tau = f->m_tau; trpt->o_pm = f->m_o_pm; (trpt-1)->ostate = &D_State; /* stub */ trpt->ostate = &D_State; #ifdef FULL_TRAIL if (upto > 0) { stack_last[core_id] = (Stack_Tree *) f->m_stack; } #if defined(VERBOSE) if (stack_last[core_id]) { cpu_printf("%d: UNPACK -- SET m_stack %u (%d,%d)\n", depth, stack_last[core_id], stack_last[core_id]->pr, stack_last[core_id]->t_id); } #endif #endif if (!trpt->o_t) { static Trans D_Trans; trpt->o_t = &D_Trans; } #ifdef VERI if ((trpt->tau & 4) != 4) { trpt->tau |= 4; /* the claim moves first */ cpu_printf("warning: trpt was not up to date\n"); } #endif for (i = 0; i < (int) now._nr_pr; i++) { P0 *ptr = (P0 *) pptr(i); #ifndef NP if (accpstate[ptr->_t][ptr->_p]) { trpt->o_pm |= 2; } #else if (progstate[ptr->_t][ptr->_p]) { trpt->o_pm |= 4; } #endif } #ifdef EVENT_TRACE #ifndef NP if (accpstate[EVENT_TRACE][now._event]) { trpt->o_pm |= 2; } #else if (progstate[EVENT_TRACE][now._event]) { trpt->o_pm |= 4; } #endif #endif #if defined(C_States) && (HAS_TRACK==1) /* restore state of tracked C objects */ c_revert((uchar *) &(now.c_state[0])); #if (HAS_STACK==1) c_unstack((uchar *) f->m_c_stack); /* unmatched tracked data */ #endif #endif return 1; } void write_root(void) /* for trail file */ { int fd; if (iterative == 0 && Nr_Trails > 1) sprintf(fnm, "%s%d.%s", TrailFile, Nr_Trails-1, sprefix); else sprintf(fnm, "%s.%s", TrailFile, sprefix); if (cur_Root.m_vsize == 0) { (void) unlink(fnm); /* remove possible old copy */ return; /* its the default initial state */ } if ((fd = creat(fnm, TMODE)) < 0) { char *q; if ((q = strchr(TrailFile, '.'))) { *q = '\0'; /* strip .pml */ if (iterative == 0 && Nr_Trails-1 > 0) sprintf(fnm, "%s%d.%s", TrailFile, Nr_Trails-1, sprefix); else sprintf(fnm, "%s.%s", TrailFile, sprefix); *q = '.'; fd = creat(fnm, TMODE); } if (fd < 0) { cpu_printf("pan: cannot create %s\n", fnm); perror("cause"); return; } } if (write(fd, &cur_Root, sizeof(SM_frame)) != sizeof(SM_frame)) { cpu_printf("pan: error writing %s\n", fnm); } else { cpu_printf("pan: wrote %s\n", fnm); } close(fd); } void set_root(void) { int fd; char *q; char MyFile[512]; char MySuffix[16]; char *ssuffix = "rst"; int try_core = 1; strcpy(MyFile, TrailFile); try_again: if (whichtrail > 0) { sprintf(fnm, "%s%d.%s", MyFile, whichtrail, ssuffix); fd = open(fnm, O_RDONLY, 0); if (fd < 0 && (q = strchr(MyFile, '.'))) { *q = '\0'; /* strip .pml */ sprintf(fnm, "%s%d.%s", MyFile, whichtrail, ssuffix); *q = '.'; fd = open(fnm, O_RDONLY, 0); } } else { sprintf(fnm, "%s.%s", MyFile, ssuffix); fd = open(fnm, O_RDONLY, 0); if (fd < 0 && (q = strchr(MyFile, '.'))) { *q = '\0'; /* strip .pml */ sprintf(fnm, "%s.%s", MyFile, ssuffix); *q = '.'; fd = open(fnm, O_RDONLY, 0); } } if (fd < 0) { if (try_core < NCORE) { ssuffix = MySuffix; sprintf(ssuffix, "cpu%d_rst", try_core++); goto try_again; } cpu_printf("no file '%s.rst' or '%s' (not an error)\n", MyFile, fnm); } else { if (read(fd, &cur_Root, sizeof(SM_frame)) != sizeof(SM_frame)) { cpu_printf("read error %s\n", fnm); close(fd); pan_exit(1); } close(fd); (void) unpack_state(&cur_Root, -2); #ifdef SEP_STATE cpu_printf("partial trail -- last few steps only\n"); #endif cpu_printf("restored root from '%s'\n", fnm); printf("=====State:=====\n"); { int i, j; P0 *z; for (i = 0; i < now._nr_pr; i++) { z = (P0 *)pptr(i); printf("proc %2d (%s) ", i, procname[z->_t]); for (j = 0; src_all[j].src; j++) if (src_all[j].tp == (int) z->_t) { printf(" %s:%d ", PanSource, src_all[j].src[z->_p]); break; } printf("(state %d)\n", z->_p); c_locals(i, z->_t); } c_globals(); } printf("================\n"); } } #ifdef USE_DISK unsigned long dsk_written, dsk_drained; void mem_drain(void); #endif void m_clear_frame(SM_frame *f) { int i, clr_sz = sizeof(SM_results); for (i = 0; i <= _NP_; i++) /* all proctypes */ { clr_sz += NrStates[i]*sizeof(uchar); } memset(f, 0, clr_sz); /* caution if sizeof(SM_results) > sizeof(SM_frame) */ } #define TargetQ_Full(n) (m_workq[n][prfree[n]].m_vsize != 0) #define TargetQ_NotFull(n) (m_workq[n][prfree[n]].m_vsize == 0) int AllQueuesEmpty(void) { int q; #ifndef NGQ if (*grcnt != 0) { return 0; } #endif for (q = 0; q < NCORE; q++) { if (prcnt[q] != 0) { return 0; } } return 1; } void Read_Queue(int q) { SM_frame *f, *of; int remember, target_q; SM_results *r; double patience = 0.0; target_q = (q + 1) % NCORE; for (;;) { f = Get_Full_Frame(q); if (!f) /* 1 second timeout -- and trigger for Query */ { if (someone_crashed(2)) { printf("cpu%d: search terminated [code %d]\n", core_id, search_terminated?*search_terminated:-1); sudden_stop(""); pan_exit(1); } #ifdef TESTING /* to profile with cc -pg and gprof pan.exe -- set handoff depth beyond maxdepth */ exit(0); #endif remember = *grfree; if (core_id == 0 /* root can initiate termination */ && remote_party == 0 /* and only the original root */ && query_in_progress == 0 /* unless its already in progress */ && AllQueuesEmpty()) { f = Get_Free_Frame(target_q); query_in_progress = 1; /* only root process can do this */ if (!f) { Uerror("Fatal1: no free slot"); } f->m_boq = QUERY; /* initiate Query */ if (verbose) { cpu_printf("snd QUERY to q%d (%d) into slot %d\n", target_q, nstates_get + 1, prfree[target_q]-1); } f->m_vsize = remember + 1; /* number will not change unless we receive more states */ } else if (patience++ > OneHour) /* one hour watchdog timer */ { cpu_printf("timeout -- giving up\n"); sudden_stop("queue timeout"); pan_exit(1); } if (0) cpu_printf("timed out -- try again\n"); continue; } patience = 0.0; /* reset watchdog */ if (f->m_boq == QUERY) { if (verbose) { cpu_printf("got QUERY on q%d (%d <> %d) from slot %d\n", q, f->m_vsize, nstates_put + 1, prfull[q]-1); snapshot(); } remember = f->m_vsize; f->m_vsize = 0; /* release slot */ if (core_id == 0 && remote_party == 0) /* original root cpu0 */ { if (query_in_progress == 1 /* didn't send more states in the interim */ && *grfree + 1 == remember) /* no action on global queue meanwhile */ { if (verbose) cpu_printf("Termination detected\n"); if (TargetQ_Full(target_q)) { if (verbose) cpu_printf("warning: target q is full\n"); } f = Get_Free_Frame(target_q); if (!f) { Uerror("Fatal2: no free slot"); } m_clear_frame(f); f->m_boq = QUIT; /* send final Quit, collect stats */ f->m_vsize = 111; /* anything non-zero will do */ if (verbose) cpu_printf("put QUIT on q%d\n", target_q); } else { if (verbose) cpu_printf("Stale Query\n"); #ifdef USE_DISK mem_drain(); #endif } query_in_progress = 0; } else { if (TargetQ_Full(target_q)) { if (verbose) cpu_printf("warning: forward query - target q full\n"); } f = Get_Free_Frame(target_q); if (verbose) cpu_printf("snd QUERY response to q%d (%d <> %d) in slot %d\n", target_q, remember, *grfree + 1, prfree[target_q]-1); if (!f) { Uerror("Fatal4: no free slot"); } if (*grfree + 1 == remember) /* no action on global queue */ { f->m_boq = QUERY; /* forward query, to root */ f->m_vsize = remember; } else { f->m_boq = QUERY_F; /* no match -- busy */ f->m_vsize = 112; /* anything non-zero */ #ifdef USE_DISK if (dsk_written != dsk_drained) { mem_drain(); } #endif } } continue; } if (f->m_boq == QUERY_F) { if (verbose) { cpu_printf("got QUERY_F on q%d from slot %d\n", q, prfull[q]-1); } f->m_vsize = 0; /* release slot */ if (core_id == 0 && remote_party == 0) /* original root cpu0 */ { if (verbose) cpu_printf("No Match on Query\n"); query_in_progress = 0; } else { if (TargetQ_Full(target_q)) { if (verbose) cpu_printf("warning: forwarding query_f, target queue full\n"); } f = Get_Free_Frame(target_q); if (verbose) cpu_printf("forward QUERY_F to q%d into slot %d\n", target_q, prfree[target_q]-1); if (!f) { Uerror("Fatal5: no free slot"); } f->m_boq = QUERY_F; /* cannot terminate yet */ f->m_vsize = 113; /* anything non-zero */ } #ifdef USE_DISK if (dsk_written != dsk_drained) { mem_drain(); } #endif continue; } if (f->m_boq == QUIT) { if (0) cpu_printf("done -- local memcnt %g Mb\n", memcnt/(1048576.)); retrieve_info((SM_results *) f); /* collect and combine stats */ if (verbose) { cpu_printf("received Quit\n"); snapshot(); } f->m_vsize = 0; /* release incoming slot */ if (core_id != 0) { f = Get_Free_Frame(target_q); /* new outgoing slot */ if (!f) { Uerror("Fatal6: no free slot"); } m_clear_frame(f); /* start with zeroed stats */ record_info((SM_results *) f); f->m_boq = QUIT; /* forward combined results */ f->m_vsize = 114; /* anything non-zero */ if (verbose>1) cpu_printf("fwd Results to q%d\n", target_q); } break; /* successful termination */ } /* else: 0<= boq <= 255, means STATE transfer */ if (unpack_state(f, q) != 0) { nstates_get++; f->m_vsize = 0; /* release slot */ if (VVERBOSE) cpu_printf("Got state\n"); if (search_terminated != NULL && *search_terminated == 0) { new_state(); /* explore successors */ memset((uchar *) &cur_Root, 0, sizeof(SM_frame)); /* avoid confusion */ } else { pan_exit(0); } } else { pan_exit(0); } } if (verbose) cpu_printf("done got %d put %d\n", nstates_get, nstates_put); sleep_report(); } void give_up(int unused_x) { if (search_terminated != NULL) { *search_terminated |= 32; /* give_up */ } if (!writing_trail) { was_interrupted = 1; snapshot(); cpu_printf("Give Up\n"); sleep_report(); pan_exit(1); } else /* we are already terminating */ { cpu_printf("SIGINT\n"); } } void check_overkill(void) { vmax_seen = (vmax_seen + 7)/ 8; vmax_seen *= 8; /* round up to a multiple of 8 */ if (core_id == 0 && !remote_party && nstates_put > 0 && VMAX - vmax_seen > 8) { #ifdef BITSTATE printf("cpu0: max VMAX value seen in this run: "); #else printf("cpu0: recommend recompiling with "); #endif printf("-DVMAX=%d\n", vmax_seen); } } void mem_put(int q) /* handoff state to other cpu, workq q */ { SM_frame *f; int i, j; if (vsize > VMAX) { vsize = (vsize + 7)/8; vsize *= 8; /* round up */ printf("pan: recompile with -DVMAX=N with N >= %d\n", (int) vsize); Uerror("aborting"); } if (now._nr_pr > PMAX) { printf("pan: recompile with -DPMAX=N with N >= %d\n", now._nr_pr); Uerror("aborting"); } if (now._nr_qs > QMAX) { printf("pan: recompile with -DQMAX=N with N >= %d\n", now._nr_qs); Uerror("aborting"); } if (vsize > vmax_seen) vmax_seen = vsize; if (now._nr_pr > pmax_seen) pmax_seen = now._nr_pr; if (now._nr_qs > qmax_seen) qmax_seen = now._nr_qs; f = Get_Free_Frame(q); /* not called in likely deadlock states */ if (!f) { Uerror("Fatal3: no free slot"); } if (VVERBOSE) cpu_printf("putting state into q%d\n", q); memcpy((uchar *) f->m_now, (uchar *) &now, vsize); #if !defined(NOCOMP) && !defined(HC) memset((uchar *) f->m_mask, 0, (VMAX+7)/8 * sizeof(char)); for (i = j = 0; i < VMAX; i++, j = (j+1)%8) { if (Mask[i]) { f->m_mask[i/8] |= (1< 0) { memcpy((uchar *) f->m_p_offset, (uchar *) proc_offset, now._nr_pr * sizeof(OFFT)); memcpy((uchar *) f->m_p_skip, (uchar *) proc_skip, now._nr_pr * sizeof(uchar)); } if (now._nr_qs > 0) { memcpy((uchar *) f->m_q_offset, (uchar *) q_offset, now._nr_qs * sizeof(OFFT)); memcpy((uchar *) f->m_q_skip, (uchar *) q_skip, now._nr_qs * sizeof(uchar)); } #if defined(C_States) && (HAS_TRACK==1) && (HAS_STACK==1) c_stack((uchar *) f->m_c_stack); /* save unmatched tracked data */ #endif #ifdef FULL_TRAIL f->m_stack = stack_last[core_id]; #endif f->nr_handoffs = nr_handoffs+1; f->m_tau = trpt->tau; f->m_o_pm = trpt->o_pm; f->m_boq = boq; f->m_vsize = vsize; /* must come last - now the other cpu can see it */ if (query_in_progress == 1) query_in_progress = 2; /* make sure we know, if a query makes the rounds */ nstates_put++; } #ifdef USE_DISK int Dsk_W_Nr, Dsk_R_Nr; int dsk_file = -1, dsk_read = -1; unsigned long dsk_written, dsk_drained; char dsk_name[512]; #ifndef BFS_DISK #if defined(WIN32) || defined(WIN64) #define RFLAGS (O_RDONLY|O_BINARY) #define WFLAGS (O_CREAT|O_WRONLY|O_TRUNC|O_BINARY) #else #define RFLAGS (O_RDONLY) #define WFLAGS (O_CREAT|O_WRONLY|O_TRUNC) #endif #endif void dsk_stats(void) { int i; if (dsk_written > 0) { cpu_printf("dsk_written %d states in %d files\ncpu%d: dsk_drained %6d states\n", dsk_written, Dsk_W_Nr, core_id, dsk_drained); close(dsk_read); close(dsk_file); for (i = 0; i < Dsk_W_Nr; i++) { sprintf(dsk_name, "Q%.3d_%.3d.tmp", i, core_id); unlink(dsk_name); } } } void mem_drain(void) { SM_frame *f, g; int q = (core_id + 1) % NCORE; /* target q */ int sz; if (dsk_read < 0 || dsk_written <= dsk_drained) { return; } while (dsk_written > dsk_drained && TargetQ_NotFull(q)) { f = Get_Free_Frame(q); if (!f) { Uerror("Fatal: unhandled condition"); } if ((dsk_drained+1)%MAX_DSK_FILE == 0) /* 100K states max per file */ { (void) close(dsk_read); /* close current read handle */ sprintf(dsk_name, "Q%.3d_%.3d.tmp", Dsk_R_Nr++, core_id); (void) unlink(dsk_name); /* remove current file */ sprintf(dsk_name, "Q%.3d_%.3d.tmp", Dsk_R_Nr, core_id); cpu_printf("reading %s\n", dsk_name); dsk_read = open(dsk_name, RFLAGS); /* open next file */ if (dsk_read < 0) { Uerror("could not open dsk file"); } } if (read(dsk_read, &g, sizeof(SM_frame)) != sizeof(SM_frame)) { Uerror("bad dsk file read"); } sz = g.m_vsize; g.m_vsize = 0; memcpy(f, &g, sizeof(SM_frame)); f->m_vsize = sz; /* last */ dsk_drained++; } } void mem_file(void) { SM_frame f; int i, j, q = (core_id + 1) % NCORE; /* target q */ if (vsize > VMAX) { printf("pan: recompile with -DVMAX=N with N >= %d\n", vsize); Uerror("aborting"); } if (now._nr_pr > PMAX) { printf("pan: recompile with -DPMAX=N with N >= %d\n", now._nr_pr); Uerror("aborting"); } if (now._nr_qs > QMAX) { printf("pan: recompile with -DQMAX=N with N >= %d\n", now._nr_qs); Uerror("aborting"); } if (VVERBOSE) cpu_printf("filing state for q%d\n", q); memcpy((uchar *) f.m_now, (uchar *) &now, vsize); #if !defined(NOCOMP) && !defined(HC) memset((uchar *) f.m_mask, 0, (VMAX+7)/8 * sizeof(char)); for (i = j = 0; i < VMAX; i++, j = (j+1)%8) { if (Mask[i]) { f.m_mask[i/8] |= (1< 0) { memcpy((uchar *)f.m_p_offset, (uchar *)proc_offset, now._nr_pr*sizeof(OFFT)); memcpy((uchar *)f.m_p_skip, (uchar *)proc_skip, now._nr_pr*sizeof(uchar)); } if (now._nr_qs > 0) { memcpy((uchar *) f.m_q_offset, (uchar *) q_offset, now._nr_qs*sizeof(OFFT)); memcpy((uchar *) f.m_q_skip, (uchar *) q_skip, now._nr_qs*sizeof(uchar)); } #if defined(C_States) && (HAS_TRACK==1) && (HAS_STACK==1) c_stack((uchar *) f.m_c_stack); /* save unmatched tracked data */ #endif #ifdef FULL_TRAIL f.m_stack = stack_last[core_id]; #endif f.nr_handoffs = nr_handoffs+1; f.m_tau = trpt->tau; f.m_o_pm = trpt->o_pm; f.m_boq = boq; f.m_vsize = vsize; if (query_in_progress == 1) { query_in_progress = 2; } if (dsk_file < 0) { sprintf(dsk_name, "Q%.3d_%.3d.tmp", Dsk_W_Nr, core_id); dsk_file = open(dsk_name, WFLAGS, 0644); dsk_read = open(dsk_name, RFLAGS); if (dsk_file < 0 || dsk_read < 0) { cpu_printf("File: <%s>\n", dsk_name); Uerror("cannot open diskfile"); } Dsk_W_Nr++; /* nr of next file to open */ cpu_printf("created temporary diskfile %s\n", dsk_name); } else if ((dsk_written+1)%MAX_DSK_FILE == 0) { close(dsk_file); /* close write handle */ sprintf(dsk_name, "Q%.3d_%.3d.tmp", Dsk_W_Nr++, core_id); dsk_file = open(dsk_name, WFLAGS, 0644); if (dsk_file < 0) { cpu_printf("File: <%s>\n", dsk_name); Uerror("aborting: cannot open new diskfile"); } cpu_printf("created temporary diskfile %s\n", dsk_name); } if (write(dsk_file, &f, sizeof(SM_frame)) != sizeof(SM_frame)) { Uerror("aborting -- disk write failed (disk full?)"); } nstates_put++; dsk_written++; } #endif int mem_hand_off(void) { if (search_terminated == NULL || *search_terminated != 0) /* not a full crash check */ { pan_exit(0); } iam_alive(); /* on every transition of Down */ #ifdef USE_DISK mem_drain(); /* maybe call this also on every Up */ #endif if (depth > z_handoff /* above handoff limit */ #ifndef SAFETY && !a_cycles /* not in liveness mode */ #endif #if SYNC && boq == -1 /* not mid-rv */ #endif #ifdef VERI && (trpt->tau&4) /* claim moves first */ && !((trpt-1)->tau&128) /* not a stutter move */ #endif && !(trpt->tau&8)) /* not an atomic move */ { int q = (core_id + 1) % NCORE; /* circular handoff */ #ifdef GENEROUS if (prcnt[q] < LN_FRAMES) #else if (TargetQ_NotFull(q) && (dfs_phase2 == 0 || prcnt[core_id] > 0)) #endif { mem_put(q); return 1; } { int rval; #ifndef NGQ rval = GlobalQ_HasRoom(); #else rval = 0; #endif #ifdef USE_DISK if (rval == 0) { void mem_file(void); mem_file(); rval = 1; } #endif return rval; } } return 0; /* i.e., no handoff */ } void mem_put_acc(void) /* liveness mode */ { int q = (core_id + 1) % NCORE; if (search_terminated == NULL || *search_terminated != 0) { pan_exit(0); } #ifdef USE_DISK mem_drain(); #endif /* some tortured use of preprocessing: */ #if !defined(NGQ) || defined(USE_DISK) if (TargetQ_Full(q)) { #endif #ifndef NGQ if (GlobalQ_HasRoom()) { return; } #endif #ifdef USE_DISK mem_file(); } else #else #if !defined(NGQ) || defined(USE_DISK) } #endif #endif { mem_put(q); } } #if defined(WIN32) || defined(WIN64) void init_shm(void) /* initialize shared work-queues */ { char key[512]; int n, m; int must_exit = 0; if (core_id == 0 && verbose) { printf("cpu0: step 3: allocate shared work-queues %g Mb\n", ((double) NCORE * LWQ_SIZE + GWQ_SIZE) / (1048576.)); } for (m = 0; m < NR_QS; m++) /* last q is global 1 */ { double qsize = (m == NCORE) ? GWQ_SIZE : LWQ_SIZE; sprintf(key, "Global\\pan_%s_%.3d", PanSource, m); if (core_id == 0) { shmid[m] = CreateFileMapping( INVALID_HANDLE_VALUE, /* use paging file */ NULL, /* default security */ PAGE_READWRITE, /* access permissions */ 0, /* high-order 4 bytes */ qsize, /* low-order bytes, size in bytes */ key); /* name */ } else /* worker nodes just open these segments */ { shmid[m] = OpenFileMapping( FILE_MAP_ALL_ACCESS, /* read/write access */ FALSE, /* children do not inherit handle */ key); } if (shmid[m] == NULL) { fprintf(stderr, "cpu%d: could not create or open shared queues\n", core_id); must_exit = 1; break; } /* attach: */ shared_mem[m] = (char *) MapViewOfFile(shmid[m], FILE_MAP_ALL_ACCESS, 0, 0, 0); if (shared_mem[m] == NULL) { fprintf(stderr, "cpu%d: cannot attach shared q%d (%d Mb)\n", core_id, m+1, (int) (qsize/(1048576.))); must_exit = 1; break; } memcnt += qsize; m_workq[m] = (SM_frame *) shared_mem[m]; if (core_id == 0) { int nframes = (m == NCORE) ? GN_FRAMES : LN_FRAMES; for (n = 0; n < nframes; n++) { m_workq[m][n].m_vsize = 0; m_workq[m][n].m_boq = 0; } } } if (must_exit) { fprintf(stderr, "pan: check './pan --' for usage details\n"); pan_exit(1); /* calls cleanup_shm */ } } static uchar * prep_shmid_S(size_t n) /* either sets SS or H_tab, WIN32/WIN64 */ { char *rval; #ifndef SEP_STATE char key[512]; if (verbose && core_id == 0) { #ifdef BITSTATE printf("cpu0: step 1: allocate shared bitstate %g Mb\n", (double) n / (1048576.)); #else printf("cpu0: step 1: allocate shared hastable %g Mb\n", (double) n / (1048576.)); #endif } #ifdef MEMLIM if (memcnt + (double) n > memlim) { printf("cpu%d: S %8g + %d Kb exceeds memory limit of %8g Mb\n", core_id, memcnt/1024., n/1024, memlim/(1048576.)); printf("cpu%d: insufficient memory -- aborting\n", core_id); exit(1); } #endif /* make key different from queues: */ sprintf(key, "Global\\pan_%s_%.3d", PanSource, NCORE+2); /* different from qs */ if (core_id == 0) /* root */ { shmid_S = CreateFileMapping(INVALID_HANDLE_VALUE, NULL, #ifdef WIN64 PAGE_READWRITE, (n>>32), (n & 0xffffffff), key); #else PAGE_READWRITE, 0, n, key); #endif memcnt += (double) n; } else /* worker */ { shmid_S = OpenFileMapping(FILE_MAP_ALL_ACCESS, FALSE, key); } if (shmid_S == NULL) { #ifdef BITSTATE fprintf(stderr, "cpu%d: cannot %s shared bitstate", core_id, core_id?"open":"create"); #else fprintf(stderr, "cpu%d: cannot %s shared hashtable", core_id, core_id?"open":"create"); #endif fprintf(stderr, "pan: check './pan --' for usage details\n"); pan_exit(1); } rval = (char *) MapViewOfFile(shmid_S, FILE_MAP_ALL_ACCESS, 0, 0, 0); /* attach */ if ((char *) rval == NULL) { fprintf(stderr, "cpu%d: cannot attach shared bitstate or hashtable\n", core_id); fprintf(stderr, "pan: check './pan --' for usage details\n"); pan_exit(1); } #else rval = (char *) emalloc(n); #endif return (uchar *) rval; } static uchar * prep_state_mem(size_t n) /* WIN32/WIN64 sets memory arena for states */ { char *rval; char key[512]; static int cnt = 3; /* start larger than earlier ftok calls */ if (verbose && core_id == 0) { printf("cpu0: step 2+: pre-allocate memory arena %d of %g Mb\n", cnt-3, (double) n / (1048576.)); } #ifdef MEMLIM if (memcnt + (double) n > memlim) { printf("cpu%d: error: M %.0f + %.0f exceeds memory limit of %.0f Kb\n", core_id, memcnt/1024.0, (double) n/1024.0, memlim/1024.0); return NULL; } #endif sprintf(key, "Global\\pan_%s_%.3d", PanSource, NCORE+cnt); cnt++; if (core_id == 0) { shmid_M = CreateFileMapping(INVALID_HANDLE_VALUE, NULL, #ifdef WIN64 PAGE_READWRITE, (n>>32), (n & 0xffffffff), key); #else PAGE_READWRITE, 0, n, key); #endif } else { shmid_M = OpenFileMapping(FILE_MAP_ALL_ACCESS, FALSE, key); } if (shmid_M == NULL) { printf("cpu%d: failed to get pool of shared memory nr %d of size %d\n", core_id, cnt-3, n); printf("pan: check './pan --' for usage details\n"); return NULL; } rval = (char *) MapViewOfFile(shmid_M, FILE_MAP_ALL_ACCESS, 0, 0, 0); /* attach */ if (rval == NULL) { printf("cpu%d: failed to attach pool of shared memory nr %d of size %d\n", core_id, cnt-3, n); return NULL; } return (uchar *) rval; } void init_HT(unsigned long n) /* WIN32/WIN64 version */ { volatile char *x; double get_mem; #ifndef SEP_STATE char *dc_mem_start; #endif if (verbose) printf("cpu%d: initialization for Windows\n", core_id); #ifdef SEP_STATE #ifndef MEMLIM if (verbose) { printf("cpu0: steps 0,1: no -DMEMLIM set\n"); } #else if (verbose) printf("cpu0: steps 0,1: -DMEMLIM=%d Mb - (hashtable %g Mb + workqueues %g Mb)\n", MEMLIM, ((double)n/(1048576.)), ((double) NCORE * LWQ_SIZE + GWQ_SIZE)/(1048576.)); #endif get_mem = NCORE * sizeof(double) + (1 + CS_NR) * sizeof(void *)+ 4*sizeof(void *) + 2*sizeof(double); /* NCORE * is_alive + search_terminated + CS_NR * sh_lock + 6 gr vars */ get_mem += 4 * NCORE * sizeof(void *); #ifdef FULL_TRAIL get_mem += (NCORE) * sizeof(Stack_Tree *); /* NCORE * stack_last */ #endif x = (volatile char *) prep_state_mem((size_t) get_mem); shmid_X = (void *) x; if (x == NULL) { printf("cpu0: could not allocate shared memory, see ./pan --\n"); exit(1); } search_terminated = (volatile unsigned int *) x; /* comes first */ x += sizeof(void *); /* maintain alignment */ is_alive = (volatile double *) x; x += NCORE * sizeof(double); sh_lock = (volatile int *) x; x += CS_NR * sizeof(void *); /* allow 1 word per entry */ grfree = (volatile int *) x; x += sizeof(void *); grfull = (volatile int *) x; x += sizeof(void *); grcnt = (volatile int *) x; x += sizeof(void *); grmax = (volatile int *) x; x += sizeof(void *); prfree = (volatile int *) x; x += NCORE * sizeof(void *); prfull = (volatile int *) x; x += NCORE * sizeof(void *); prcnt = (volatile int *) x; x += NCORE * sizeof(void *); prmax = (volatile int *) x; x += NCORE * sizeof(void *); gr_readmiss = (volatile double *) x; x += sizeof(double); gr_writemiss = (volatile double *) x; x += sizeof(double); #ifdef FULL_TRAIL stack_last = (volatile Stack_Tree **) x; x += NCORE * sizeof(Stack_Tree *); #endif #ifndef BITSTATE H_tab = (H_el **) emalloc(n); #endif #else #ifndef MEMLIM #warning MEMLIM not set #define MEMLIM (2048) #endif if (core_id == 0 && verbose) printf("cpu0: step 0: -DMEMLIM=%d Mb - (hashtable %g Mb + workqueues %g Mb) = %g Mb for state storage\n", MEMLIM, ((double)n/(1048576.)), ((double) NCORE * LWQ_SIZE + GWQ_SIZE)/(1048576.), (memlim - memcnt - (double) n - ((double) NCORE * LWQ_SIZE + GWQ_SIZE))/(1048576.)); #ifndef BITSTATE H_tab = (H_el **) prep_shmid_S((size_t) n); /* hash_table */ #endif get_mem = memlim - memcnt - ((double) NCORE) * LWQ_SIZE - GWQ_SIZE; if (get_mem <= 0) { Uerror("internal error -- shared state memory"); } if (core_id == 0 && verbose) { printf("cpu0: step 2: shared state memory %g Mb\n", get_mem/(1048576.)); } x = dc_mem_start = (char *) prep_state_mem((size_t) get_mem); /* for states */ if (x == NULL) { printf("cpu%d: insufficient memory -- aborting\n", core_id); exit(1); } search_terminated = (volatile unsigned int *) x; /* comes first */ x += sizeof(void *); /* maintain alignment */ is_alive = (volatile double *) x; x += NCORE * sizeof(double); sh_lock = (volatile int *) x; x += CS_NR * sizeof(int); grfree = (volatile int *) x; x += sizeof(void *); grfull = (volatile int *) x; x += sizeof(void *); grcnt = (volatile int *) x; x += sizeof(void *); grmax = (volatile int *) x; x += sizeof(void *); prfree = (volatile int *) x; x += NCORE * sizeof(void *); prfull = (volatile int *) x; x += NCORE * sizeof(void *); prcnt = (volatile int *) x; x += NCORE * sizeof(void *); prmax = (volatile int *) x; x += NCORE * sizeof(void *); gr_readmiss = (volatile double *) x; x += sizeof(double); gr_writemiss = (volatile double *) x; x += sizeof(double); #ifdef FULL_TRAIL stack_last = (volatile Stack_Tree **) x; x += NCORE * sizeof(Stack_Tree *); #endif if (((long)x)&(sizeof(void *)-1)) /* word alignment */ { x += sizeof(void *)-(((long)x)&(sizeof(void *)-1)); /* 64-bit align */ } #ifdef COLLAPSE ncomps = (unsigned long *) x; x += (256+2) * sizeof(unsigned long); #endif dc_shared = (sh_Allocater *) x; /* in shared memory */ x += sizeof(sh_Allocater); if (core_id == 0) /* root only */ { dc_shared->dc_id = shmid_M; dc_shared->dc_start = (void *) dc_mem_start; dc_shared->dc_arena = x; dc_shared->pattern = 1234567; dc_shared->dc_size = (long) get_mem - (long) (x - dc_mem_start); dc_shared->nxt = NULL; } #endif } #if defined(WIN32) || defined(WIN64) || defined(__i386__) || defined(__x86_64__) extern BOOLEAN InterlockedBitTestAndSet(LONG volatile* Base, LONG Bit); int tas(volatile LONG *s) { return InterlockedBitTestAndSet(s, 1); } #else #error missing definition of test and set operation for this platform #endif void cleanup_shm(int val) { int m; static int nibis = 0; if (nibis != 0) { printf("cpu%d: Redundant call to cleanup_shm(%d)\n", core_id, val); return; } else { nibis = 1; } if (search_terminated != NULL) { *search_terminated |= 16; /* cleanup_shm */ } for (m = 0; m < NR_QS; m++) { if (shmid[m] != NULL) { UnmapViewOfFile((char *) shared_mem[m]); CloseHandle(shmid[m]); } } #ifdef SEP_STATE UnmapViewOfFile((void *) shmid_X); CloseHandle((void *) shmid_M); #else #ifdef BITSTATE if (shmid_S != NULL) { UnmapViewOfFile(SS); CloseHandle(shmid_S); } #else if (core_id == 0 && verbose) { printf("cpu0: done, %ld Mb of shared state memory left\n", dc_shared->dc_size / (long)(1048576)); } if (shmid_S != NULL) { UnmapViewOfFile(H_tab); CloseHandle(shmid_S); } shmid_M = (void *) (dc_shared->dc_id); UnmapViewOfFile((char *) dc_shared->dc_start); CloseHandle(shmid_M); #endif #endif /* detached from shared memory - so cannot use cpu_printf */ if (verbose) { printf("cpu%d: done -- got %d states from queue\n", core_id, nstates_get); } } void mem_get(void) { SM_frame *f; int is_parent; #if defined(MA) && !defined(SEP_STATE) #error MA requires SEP_STATE in multi-core mode #endif #ifdef BFS #error instead of -DNCORE -DBFS use -DBFS_PAR #endif #ifdef SC #error SC is not supported in multi-core mode #endif init_shm(); /* we are single threaded when this starts */ signal(SIGINT, give_up); /* windows control-c interrupt */ if (core_id == 0 && verbose) { printf("cpu0: step 4: creating additional workers (proxy %d)\n", proxy_pid); } #if 0 if NCORE > 1 the child or the parent should fork N-1 more times the parent is the only process with core_id == 0 and is_parent > 0 the others (workers) have is_parent = 0 and core_id = 1..NCORE-1 #endif if (core_id == 0) /* root starts up the workers */ { worker_pids[0] = (DWORD) getpid(); /* for completeness */ while (++core_id < NCORE) /* first worker sees core_id = 1 */ { char cmdline[64]; STARTUPINFO si = { sizeof(si) }; PROCESS_INFORMATION pi; if (proxy_pid == core_id) /* always non-zero */ { sprintf(cmdline, "pan_proxy.exe -r %s-Q%d -Z%d", o_cmdline, getpid(), core_id); } else { sprintf(cmdline, "pan.exe %s-Q%d -Z%d", o_cmdline, getpid(), core_id); } if (verbose) printf("cpu%d: spawn %s\n", core_id, cmdline); is_parent = CreateProcess(0, cmdline, 0, 0, FALSE, 0, 0, 0, &si, &pi); if (is_parent == 0) { Uerror("fork failed"); } worker_pids[core_id] = pi.dwProcessId; worker_handles[core_id] = pi.hProcess; if (verbose) { cpu_printf("created core %d, pid %d\n", core_id, pi.dwProcessId); } if (proxy_pid == core_id) /* we just created the receive half */ { /* add proxy send, store pid in proxy_pid_snd */ sprintf(cmdline, "pan_proxy.exe -s %s-Q%d -Z%d -Y%d", o_cmdline, getpid(), core_id, worker_pids[proxy_pid]); if (verbose) printf("cpu%d: spawn %s\n", core_id, cmdline); is_parent = CreateProcess(0, cmdline, 0,0, FALSE, 0,0,0, &si, &pi); if (is_parent == 0) { Uerror("fork failed"); } proxy_pid_snd = pi.dwProcessId; proxy_handle_snd = pi.hProcess; if (verbose) { cpu_printf("created core %d, pid %d (send proxy)\n", core_id, pi.dwProcessId); } } } core_id = 0; /* reset core_id for root process */ } else /* worker */ { static char db0[16]; /* good for up to 10^6 cores */ static char db1[16]; tprefix = db0; sprefix = db1; sprintf(tprefix, "cpu%d_trail", core_id); /* avoid conflicts on file access */ sprintf(sprefix, "cpu%d_rst", core_id); memcnt = 0; /* count only additionally allocated memory */ } if (verbose) { cpu_printf("starting core_id %d -- pid %d\n", core_id, getpid()); } if (core_id == 0 && !remote_party) { new_state(); /* root starts the search */ if (verbose) cpu_printf("done with 1st dfs, nstates %g (put %d states), start reading q\n", nstates, nstates_put); dfs_phase2 = 1; } Read_Queue(core_id); /* all cores */ if (verbose) { cpu_printf("put %6d states into queue -- got %6d\n", nstates_put, nstates_get); } done = 1; wrapup(); exit(0); } #endif #ifdef BITSTATE void init_SS(unsigned long n) { SS = (uchar *) prep_shmid_S((size_t) n); init_HT(0L); } #endif #endif clock_t start_time; #if NCORE>1 clock_t crash_stamp; #endif #if !defined(WIN32) && !defined(WIN64) struct tms start_tm; #endif #if SYNC extern int q_zero(int); extern int not_RV(int); #endif void start_timer(void) { #if defined(WIN32) || defined(WIN64) start_time = clock(); #else start_time = times(&start_tm); #endif } double delta_time; void report_time(void) { printf("\npan: elapsed time %.3g seconds\n", delta_time); if (delta_time > 0.01) { printf("pan: rate %9.8g states/second\n", nstates/delta_time); if (verbose) { printf("pan: avg transition delay %.5g usec\n", delta_time/(nstates+truncs)); } } } void stop_timer(int report) { clock_t stop_time; #if !defined(WIN32) && !defined(WIN64) struct tms stop_tm; stop_time = times(&stop_tm); delta_time = ((double) (stop_time - start_time)) / ((double) sysconf(_SC_CLK_TCK)); #else stop_time = clock(); delta_time = ((double) (stop_time - start_time)) / ((double) CLOCKS_PER_SEC); #endif if (readtrail || delta_time < 0.00) return; #if NCORE>1 if (core_id == 0 && nstates > (double) 0) { printf("\ncpu%d: elapsed time %.3g seconds (%g states visited)\n", core_id, delta_time, nstates); if (delta_time > 0.01) { printf("cpu%d: rate %g states/second\n", core_id, nstates/delta_time); } { void check_overkill(void); check_overkill(); } } #else if (report) { report_time(); } #endif } #if NCORE>1 #ifdef T_ALERT double t_alerts[17]; void crash_report(void) { int i; printf("crash alert intervals:\n"); for (i = 0; i < 17; i++) { printf("%d\t%g\n", i, t_alerts[i]); } } #endif void crash_reset(void) { /* false alarm */ if (crash_stamp != (clock_t) 0) { #ifdef T_ALERT double delta_time; int i; #if defined(WIN32) || defined(WIN64) delta_time = ((double) (clock() - crash_stamp)) / ((double) CLOCKS_PER_SEC); #else delta_time = ((double) (times(&start_tm) - crash_stamp)) / ((double) sysconf(_SC_CLK_TCK)); #endif for (i = 0; i < 16; i++) { if (delta_time <= (i*30)) { t_alerts[i] = delta_time; break; } } if (i == 16) t_alerts[i] = delta_time; #endif if (verbose) printf("cpu%d: crash alert off\n", core_id); } crash_stamp = (clock_t) 0; } int crash_test(double maxtime) { double delta_time; if (crash_stamp == (clock_t) 0) { /* start timing */ #if defined(WIN32) || defined(WIN64) crash_stamp = clock(); #else crash_stamp = times(&start_tm); #endif if (verbose) { printf("cpu%d: crash detection\n", core_id); } return 0; } #if defined(WIN32) || defined(WIN64) delta_time = ((double) (clock() - crash_stamp)) / ((double) CLOCKS_PER_SEC); #else delta_time = ((double) (times(&start_tm) - crash_stamp)) / ((double) sysconf(_SC_CLK_TCK)); #endif return (delta_time >= maxtime); } #endif #ifdef BFS_PAR int ncores = 0; #endif void do_the_search(void) { int i; depth = mreached = 0; trpt = &trail[0]; #ifdef VERI trpt->tau |= 4; /* the claim moves first */ #endif for (i = 0; i < (int) now._nr_pr; i++) { P0 *ptr = (P0 *) pptr(i); #ifndef NP if (!(trpt->o_pm&2) && accpstate[ptr->_t][ptr->_p]) { trpt->o_pm |= 2; break; } #else if (!(trpt->o_pm&4) && progstate[ptr->_t][ptr->_p]) { trpt->o_pm |= 4; break; } #endif } #ifdef EVENT_TRACE #ifndef NP if (accpstate[EVENT_TRACE][now._event]) { trpt->o_pm |= 2; } #else if (progstate[EVENT_TRACE][now._event]) { trpt->o_pm |= 4; } #endif #endif #if !defined(NOCOMP) && !defined(HC) Mask[0] = Mask[1] = 1; /* _nr_pr, _nr_qs */ if (!a_cycles) { i = &(now._a_t) - (uchar *) &now; Mask[i] = 1; /* _a_t */ } #ifndef NOFAIR if (!fairness) { int j = 0; i = &(now._cnt[0]) - (uchar *) &now; while (j++ < NFAIR) Mask[i++] = 1; /* _cnt[] */ } #endif #endif #ifndef NOFAIR if (fairness && (a_cycles && (trpt->o_pm&2))) { now._a_t = 2; /* set the A-bit */ now._cnt[0] = now._nr_pr + 1; #ifdef VERBOSE printf("%3ld: fairness Rule 1, cnt=%d, _a_t=%d\n", depth, now._cnt[now._a_t&1], now._a_t); #endif } #endif c_stack_start = (char *) &i; /* meant to be read-only */ #if defined(HAS_CODE) && defined (C_INIT) C_INIT; /* initialization of data that must precede fork() */ c_init_done++; #endif #if defined(C_States) && (HAS_TRACK==1) /* capture initial state of tracked C objects */ c_update((uchar *) &(now.c_state[0])); #endif #ifdef HAS_CODE if (readtrail) getrail(); /* no return */ #endif #ifndef BFS_PAR start_timer(); #endif #ifdef BFS #ifdef BFS_PAR bfs_main(ncores,0); #else bfs(); #endif #else #if defined(C_States) && defined(HAS_STACK) && (HAS_TRACK==1) /* initial state of tracked & unmatched objects */ c_stack((uchar *) &(svtack->c_stack[0])); #endif #if defined(P_RAND) || defined(T_RAND) srand(s_rand+HASH_NR); #endif #if NCORE>1 mem_get(); #else new_state(); /* start 1st DFS */ #endif #endif } #ifdef INLINE_REV uchar do_reverse(Trans *t, short II, uchar M) { uchar _m = M; int tt = (int) ((P0 *)this)->_p; #include BACKWARD_MOVES R999: return _m; } #endif #ifndef INLINE #ifdef EVENT_TRACE static char _tp = 'n'; static int _qid = 0; #endif uchar do_transit(Trans *t, short II) { uchar _m = 0; int tt = (int) ((P0 *)this)->_p; #ifdef M_LOSS uchar delta_m = 0; #endif #ifdef EVENT_TRACE short oboq = boq; uchar ot = (uchar) ((P0 *)this)->_t; if (II == -EVENT_TRACE) boq = -1; #define continue { boq = oboq; return 0; } #else #define continue return 0 #ifdef SEPARATE uchar ot = (uchar) ((P0 *)this)->_t; #endif #endif #include FORWARD_MOVES P999: #ifdef EVENT_TRACE if (II == -EVENT_TRACE) boq = oboq; #endif return _m; #undef continue } #ifdef EVENT_TRACE void require(char tp, int qid) { Trans *t; _tp = tp; _qid = qid; if (now._event != endevent) for (t = trans[EVENT_TRACE][now._event]; t; t = t->nxt) { if (do_transit(t, -EVENT_TRACE)) { now._event = t->st; reached[EVENT_TRACE][t->st] = 1; #ifdef VERBOSE printf(" event_trace move to -> %d\n", t->st); #endif #ifndef BFS #ifndef NP if (accpstate[EVENT_TRACE][now._event]) (trpt+1)->o_pm |= 2; #else if (progstate[EVENT_TRACE][now._event]) (trpt+1)->o_pm |= 4; #endif #endif #ifdef NEGATED_TRACE if (now._event == endevent) { #ifndef BFS depth++; trpt++; #endif uerror("event_trace error (all events matched)"); #ifndef BFS trpt--; depth--; #endif break; } #endif for (t = t->nxt; t; t = t->nxt) { if (do_transit(t, -EVENT_TRACE)) Uerror("non-determinism in event-trace"); } return; } #ifdef VERBOSE else printf(" event_trace miss '%c' -- %d, %d, %d\n", tp, qid, now._event, t->forw); #endif } #ifdef NEGATED_TRACE now._event = endevent; /* only 1st try will count -- fixed 4.2.6 */ #else #ifndef BFS depth++; trpt++; #endif uerror("event_trace error (no matching event)"); #ifndef BFS trpt--; depth--; #endif #endif } #endif int enabled(int iam, int pid) { Trans *t; uchar *othis = this; int res = 0; int tt; uchar ot; pid += BASE; if (pid == iam) Uerror("used: enabled(pid=thisproc)"); if (pid < 0 || pid >= (int) now._nr_pr) return 0; this = pptr(pid); TstOnly = 1; tt = (int) ((P0 *)this)->_p; ot = (uchar) ((P0 *)this)->_t; for (t = trans[ot][tt]; t; t = t->nxt) if (do_transit(t, (short) pid)) { res = 1; break; } TstOnly = 0; this = othis; return res; } #endif #ifdef HAS_PRIORITY int highest_priority(int pid, short nII, Trans *t) { int i = pid; uchar *othis = this; #ifdef VERI if (nII == 0) { return 1; } #endif #ifdef HAS_PROVIDED i = pid+BASE; #endif if (i < 0 || i >= (int) now._nr_pr #ifdef HAS_PROVIDED || !provided(i, (uchar) ((P0 *)this)->_t, (int) ((P0 *)this)->_p, t) #endif ) { return 0; } for (i = BASE; i < now._nr_pr; i++) { this = pptr(i); if (i != pid+BASE && ((P0 *)this)->_priority > ((P0 *)pptr(pid+BASE))->_priority #ifdef HAS_PROVIDED && provided(i, (uchar) ((P0 *)this)->_t, (int) ((P0 *)this)->_p, 0) #endif && enabled(i+1, i-BASE)) { this = othis; return 0; } } this = othis; return 1; } int get_priority(int pid) { pid += BASE; /* 6.2.7 */ if (pid < 0 || pid >= (int) now._nr_pr) return 0; return ((P0 *)pptr(pid))->_priority; } int set_priority(int pid, int pr) { pid += BASE; /* 6.2.7 */ if (pid < 0 || pid >= (int) now._nr_pr) { #ifdef VERBOSE printf("warning: bad pid %d, no such process (set_priority)\n", pid); #endif return 1; } if (pr < 1 || pr > 255) { Uerror("priority is out of range"); } if (!TstOnly) { (trpt+1)->o_priority = (((P0 *)pptr(pid))->_priority & 255) | (pid << 8); ((P0 *)pptr(pid))->_priority = pr; } return 1; } #endif void snap_time(void) { clock_t stop_time; double delta_time; #if !defined(WIN32) && !defined(WIN64) struct tms stop_tm; stop_time = times(&stop_tm); delta_time = ((double) (stop_time - start_time)) / ((double) sysconf(_SC_CLK_TCK)); #else stop_time = clock(); delta_time = ((double) (stop_time - start_time)) / ((double) CLOCKS_PER_SEC); #endif if (delta_time > 0.01) { printf("t= %8.3g ", delta_time); printf("R= %7.0g", nstates/delta_time); } printf("\n"); if (quota > 0.1 && delta_time > quota) { printf("Time limit of %6.3g minutes exceeded\n", quota/60.0); #if NCORE>1 fflush(stdout); leave_critical(GLOBAL_LOCK); sudden_stop("time-limit"); exit(1); #endif wrapup(); } } void snapshot(void) { #ifdef BFS_PAR e_critical(BFS_GLOB); /* bfs_par / snapshot */ printf("cpu%d: ", who_am_i); #endif #if NCORE>1 enter_critical(GLOBAL_LOCK); /* ncore / snapshot */ printf("cpu%d: ", core_id); #endif printf("Depth= %7ld States= %8.3g ", #if NCORE>1 (long) (nr_handoffs * z_handoff) + #endif mreached, nstates); printf("Transitions= %8.3g ", nstates+truncs); #ifdef MA printf("Nodes= %7lu ", nr_states); #endif printf("Memory= %9.3f\t", memcnt/1048576.); snap_time(); fflush(stdout); #if NCORE>1 leave_critical(GLOBAL_LOCK); #endif #ifdef BFS_PAR x_critical(BFS_GLOB); #endif } #ifdef SC void stack2disk(void) { if (!stackwrite && (stackwrite = creat(stackfile, TMODE)) < 0) Uerror("cannot create stackfile"); if (write(stackwrite, trail, DDD*sizeof(Trail)) != DDD*sizeof(Trail)) Uerror("stackfile write error -- disk is full?"); memmove(trail, &trail[DDD], (HHH-DDD+2)*sizeof(Trail)); memset(&trail[HHH-DDD+2], 0, (omaxdepth - HHH + DDD - 2)*sizeof(Trail)); CNT1++; } void disk2stack(void) { long have; CNT2++; memmove(&trail[DDD], trail, (HHH-DDD+2)*sizeof(Trail)); if (!stackwrite || lseek(stackwrite, -DDD* (off_t) sizeof(Trail), SEEK_CUR) == -1) Uerror("disk2stack lseek error"); if (!stackread && (stackread = open(stackfile, 0)) < 0) Uerror("cannot open stackfile"); if (lseek(stackread, (CNT1-CNT2)*DDD* (off_t) sizeof(Trail), SEEK_SET) == -1) Uerror("disk2stack lseek error"); have = read(stackread, trail, DDD*sizeof(Trail)); if (have != DDD*sizeof(Trail)) Uerror("stackfile read error"); } #endif uchar * Pptr(int x) { if (x < 0 || x >= MAXPROC #ifdef TRIX || !processes[x]) #else || !proc_offset[x]) #endif return noptr; else return (uchar *) pptr(x); } uchar * Qptr(int x) { if (x < 0 || x >= MAXQ #ifdef TRIX || !channels[x]) #else || !q_offset[x]) #endif return noqptr; else return (uchar *) qptr(x); } #if NCLAIMS>1 void select_claim(int n) { int m, i; if (n < 0 || n >= NCLAIMS) { uerror("non-existing claim"); } else { m = ((Pclaim *)pptr(0))->_n; if (verbose) { printf("%d: Claim %s (%d), from state %d\n", (int) depth, procname[spin_c_typ[n]], n, ((Pclaim *)pptr(0))->c_cur[n]); } else { printf("pan: ltl formula %s\n", procname[spin_c_typ[n]]); } ((Pclaim *)pptr(0))->c_cur[m] = ((Pclaim *)pptr(0))->_p; ((Pclaim *)pptr(0))->_t = spin_c_typ[n]; ((Pclaim *)pptr(0))->_p = ((Pclaim *)pptr(0))->c_cur[n]; ((Pclaim *)pptr(0))->_n = n; for (i = 0; src_all[i].src != (short *) 0; i++) { if (src_all[i].tp == spin_c_typ[n]) { src_claim = src_all[i].src; break; } } if (src_all[i].src == (short *) 0) { uerror("cannot happen: src_ln ref"); } } } #else void select_claim(int n) { if (n != 0) uerror("non-existing claim"); } #endif int qs_empty(void); #if !defined(BFS) && (!defined(BITSTATE) || !defined(MA)) #ifdef NSUCC int N_succ[512]; void tally_succ(int cnt) { if (cnt < 512) N_succ[cnt]++; else printf("tally_succ: cnt %d exceeds range\n", cnt); } void dump_succ(void) { int i; double sum = 0.0; double w_avg = 0.0; printf("Successor counts:\n"); for (i = 0; i < 512; i++) { sum += (double) N_succ[i]; } for (i = 0; i < 512; i++) { if (N_succ[i] > 0) { printf("%3d %10d (%.4g %% of total)\n", i, N_succ[i], (100.0 * (double) N_succ[i])/sum); w_avg += (double) i * (double) N_succ[i]; } } if (sum > N_succ[0]) printf("mean %.4g (without 0: %.4g)\n", w_avg / sum, w_avg / (sum - (double) N_succ[0])); } #endif #ifdef P_REVERSE #define FROM_P (BASE) #define UPTO_P (now._nr_pr-1) #define MORE_P (II <= To) #define INI_P (From-1) #define CNT_P (1 + (To - From)) #define NDONE_P (From <= To) #define ALL_P (II = From; II <= To; II++) #else #define FROM_P (now._nr_pr-1) #define UPTO_P (BASE) #define MORE_P (II >= BASE) #define INI_P (From+1) #define CNT_P (1 + (From - To)) #define NDONE_P (From >= To) #define ALL_P (II = From; II >= To; II--) #endif #ifdef PERMUTED #define CONTINUE0 { if (reversing&2) { II = oII; } continue; } #define CONTINUE { if (reversing&2) { p_reorder(seed); II = oII; } continue; } #else #define CONTINUE0 { continue; } #define CONTINUE { continue; } #endif #ifdef PERMUTED uchar _permutation_[256]; void set_reversed(int unused) { int i, n = now._nr_pr; #ifdef VERBOSE printf("%ld: Set_reversed\n", depth); #endif #if defined(VERI) && !defined(NOCLAIM) for (i = 1; i < n; i++) { _permutation_[i] = n-i; } #else for (i = 0; i < n; i++) { _permutation_[i] = n-1-i; } #endif } void set_rotated(int unused) { int i, n = now._nr_pr; #ifdef VERBOSE printf("%ld: Set_rotated %d\n", depth, p_rotate); #endif #if defined(VERI) && !defined(NOCLAIM) for (i = 1; i < n; i++) { _permutation_[i] = 1+(i-1+p_rotate)%(n-1); } #else for (i = 0; i < n; i++) { _permutation_[i] = (i+p_rotate)%n; } #endif } void set_randrot(int unused) { if (now._nr_pr > 1) { p_rotate = 1+rand()%(now._nr_pr-1); } else { p_rotate = 0; } set_rotated(0); } void set_permuted(int T) { /* permute nrs 1..n-1, leave 0 in place */ int i, j, k, n = now._nr_pr; char tmp, *in = &(_permutation_[0]); #ifdef VERBOSE printf("%ld: Set_permuted %d\n", depth, T); #endif srand(T); for (i = 0; i < n; i++) { in[i] = i; } if (n > 1) { for (i = 0; i < n; i++) { #if defined(VERI) && !defined(NOCLAIM) j = 1 + rand()%(n-1); k = 1 + rand()%(n-1); #else j = rand()%(n); k = rand()%(n); #endif tmp = in[j]; in[j] = in[k]; in[k] = tmp; } } } #ifdef VERBOSE short get_permuted(int x) { printf("%ld: Get_permuted %d -> %d\n", depth, x, _permutation_[x]); return (short) _permutation_[x]; } #else #define get_permuted(x) (short) _permutation_[x] #endif #endif /* * new_state() is the main DFS search routine in the verifier * it has a lot of code ifdef-ed together to support * different search modes, which makes it quite unreadable. * if you are studying the code, use the C preprocessor * to generate a specific version from the pan.c source, * e.g. by saying: * gcc -E -DNOREDUCE -DBITSTATE pan.c > ppan.c * and then study the resulting file, instead of this version */ void new_state(void) { Trans *t; uchar _n, _m, ot; #ifdef T_RAND short ooi, eoi; #endif #ifdef PERMUTED short oII; uint seed; #endif #ifdef M_LOSS uchar delta_m = 0; #endif short II, JJ = 0, kk; int tt; short From = FROM_P, To = UPTO_P; #ifdef BCS trpt->sched_limit = 0; /* at depth=0 only */ #endif Down: #ifdef CHECK cpu_printf("%d: Down - %s %saccepting [pids %d-%d]\n", depth, (trpt->tau&4)?"claim":"program", (trpt->o_pm&2)?"":"non-", From, To); #endif #ifdef P_RAND trpt->p_skip = -1; #endif #ifdef SC if (depth > hiwater) { stack2disk(); maxdepth += DDD; hiwater += DDD; trpt -= DDD; if(verbose) printf("zap %ld: %ld (maxdepth now %ld)\n", CNT1, hiwater, maxdepth); } #endif trpt->tau &= ~(16|32|64); /* make sure these are off */ #if defined(FULLSTACK) && defined(MA) trpt->proviso = 0; #endif #ifdef NSUCC trpt->n_succ = 0; #endif #if NCORE>1 if (mem_hand_off()) { #if SYNC (trpt+1)->o_n = 1; /* not a deadlock: as below */ #endif #ifndef LOOPSTATE (trpt-1)->tau |= 16; /* worstcase guess: as below */ #endif #if NCORE>1 && defined(FULL_TRAIL) if (upto > 0) { Pop_Stack_Tree(); } #endif goto Up; } #endif if (depth >= maxdepth) { if (!warned) { warned = 1; printf("error: max search depth too small\n"); } if (bounded) { uerror("depth limit reached"); } truncs++; #if SYNC (trpt+1)->o_n = 1; /* not a deadlock */ #endif #ifndef LOOPSTATE (trpt-1)->tau |= 16; /* worstcase guess */ #endif #if NCORE>1 && defined(FULL_TRAIL) if (upto > 0) { Pop_Stack_Tree(); } #endif goto Up; } AllOver: #if (defined(FULLSTACK) && !defined(MA)) || NCORE>1 /* if atomic or rv move, carry forward previous state */ trpt->ostate = (trpt-1)->ostate; #endif #ifdef VERI if ((trpt->tau&4) || ((trpt-1)->tau&128)) #endif if (boq == -1) { /* if not mid-rv */ #ifndef SAFETY if ((now._a_t&1) && depth > A_depth) { int delta = S_A + 2; if (!memcmp((char *)&A_Root + delta, (char *)&now + delta, vsize - delta)) { #ifndef NOFAIR if (fairness && now._cnt[1] != 1) /* was > 1 */ { #ifdef CHECK printf(" fairness count non-zero\n"); #endif /* treat as new state */ } else #endif { depthfound = A_depth; #ifdef CHECK printf("matches seed\n"); #endif #ifdef NP uerror("non-progress cycle"); #else uerror("acceptance cycle"); #endif #if NCORE>1 && defined(FULL_TRAIL) if (upto > 0) { Pop_Stack_Tree(); } #endif goto Up; } } #ifdef CHECK else { printf("not seed\n"); } #endif } #endif if (!(trpt->tau&8)) /* if no atomic move */ { #if defined(BCS) && defined(NO_LAST) && defined(HAS_LAST) uchar was_last = now._last; now._last = 0; /* value not stored */ #endif #ifdef BITSTATE #ifdef CNTRSTACK #if defined(BCS) && defined(STORE_CTX) { int xj; for (xj = trpt->sched_limit; xj <= sched_max; xj++) { now._ctx = xj; II = b_store((char *)&now, vsize); trpt->j6 = j1_spin; trpt->j7 = j2_spin; JJ = LL[j1_spin] && LL[j2_spin]; if (II != 0) { break; } } now._ctx = 0; /* just in case */ } #else II = b_store((char *)&now, vsize); trpt->j6 = j1_spin; trpt->j7 = j2_spin; JJ = LL[j1_spin] && LL[j2_spin]; #endif #else #ifdef FULLSTACK #if defined(BCS) && defined(STORE_CTX) { int xj; now._ctx = 0; JJ = onstack_now(); for (xj = trpt->sched_limit; xj <= sched_max; xj++) { now._ctx = xj; II = b_store((char *)&now, vsize); if (II != 0) { break; } } now._ctx = 0; } #else JJ = onstack_now(); II = b_store((char *)&now, vsize); #endif #else #if defined(BCS) && defined(STORE_CTX) { int xj; for (xj = trpt->sched_limit; xj <= sched_max; xj++) { now._ctx = xj; II = b_store((char *)&now, vsize); JJ = II; /* worstcase guess for p.o. - order corrected in 5.2.1 */ if (II != 0) { break; } } now._ctx = 0; } #else II = b_store((char *)&now, vsize); JJ = II; /* worstcase guess for p.o. - order corrected in 5.2.1 */ #endif #endif #endif #else #ifdef MA II = g_store((char *)&now, vsize, 0); #ifndef FULLSTACK JJ = II; #else JJ = (II == 2)?1:0; #endif #else II = h_store((char *)&now, vsize); /* @hash j1_spin II */ #ifdef FULLSTACK JJ = (II == 2)?1:0; #endif #endif #endif kk = (II == 1 || II == 2); #if defined(BCS) && defined(NO_LAST) && defined(HAS_LAST) now._last = was_last; /* restore value */ #endif #ifndef SAFETY #if !defined(HC) && (NCORE==1 || defined (SEP_STATE)) if (II == 2 && ((trpt->o_pm&2) || ((trpt-1)->o_pm&2))) #ifndef NOFAIR if (a_cycles && !fairness) /* 5.1.6 -- example by Hirofumi Watanabe */ #endif if (depth > A_depth) /* forum example by adl */ { II = 3; /* Schwoon & Esparza 2005, Gastin&Moro 2004 */ #ifdef VERBOSE printf("state match on dfs stack\n"); #endif goto same_case; } #endif #if defined(FULLSTACK) && defined(BITSTATE) if (!JJ && (now._a_t&1) && depth > A_depth) { int oj1 = j1_spin; uchar o_a_t = now._a_t; now._a_t &= ~(1|16|32); if (onstack_now()) { II = 3; #ifdef VERBOSE printf("state match on 1st dfs stack\n"); #endif } now._a_t = o_a_t; j1_spin = oj1; } #endif if (II == 3 && a_cycles && (now._a_t&1)) { #ifndef NOFAIR if (fairness && now._cnt[1] != 1) /* was > 1 */ { #ifdef CHECK printf(" fairness count non-zero\n"); #endif II = 0; } else #endif { #ifndef BITSTATE nShadow--; #endif same_case: if (Lstate) depthfound = Lstate->D; #ifdef NP uerror("non-progress cycle"); #else uerror("acceptance cycle"); #endif #if NCORE>1 && defined(FULL_TRAIL) if (upto > 0) { Pop_Stack_Tree(); } #endif goto Up; } } #endif #ifndef NOREDUCE #ifndef SAFETY #if NCORE>1 && !defined(SEP_STATE) && defined(V_PROVISO) if (II != 0 && (!Lstate || Lstate->cpu_id < core_id)) { (trpt-1)->tau |= 16; } #endif if ((II && JJ) || (II == 3)) { /* marker for liveness proviso */ #ifndef LOOPSTATE (trpt-1)->tau |= 16; #endif truncs2++; } #else #if NCORE>1 && !defined(SEP_STATE) && defined(V_PROVISO) if (!(II != 0 && (!Lstate || Lstate->cpu_id < core_id))) { /* treat as stack state */ (trpt-1)->tau |= 16; } else { /* treat as non-stack state */ (trpt-1)->tau |= 64; } #endif if (!II || !JJ) { /* successor outside stack */ (trpt-1)->tau |= 64; } #endif #endif #if defined(BCS) && (defined(NOREDUCE) || !defined(SAFETY)) if (!II || !JJ) { (trpt-1)->tau |= 64; } #endif if (II) { truncs++; #if NCORE>1 && defined(FULL_TRAIL) if (upto > 0) { Pop_Stack_Tree(); if (depth == 0) { return; } } #endif goto Up; } if (!kk) { static long sdone = (long) 0; long ndone; nstates++; #if defined(ZAPH) && defined(BITSTATE) zstates += (double) hfns; #endif ndone = (ulong) (nstates/(freq)); if (ndone != sdone) { snapshot(); sdone = ndone; #if defined(AUTO_RESIZE) && !defined(BITSTATE) && !defined(MA) if (nstates > ((double)(ONE_L<<(ssize+1)))) { void resize_hashtable(void); resize_hashtable(); } #endif #if defined(ZAPH) && defined(BITSTATE) if (zstates > ((double)(ONE_L<<(ssize-2)))) { /* more than half the bits set */ void zap_hashtable(void); zap_hashtable(); zstates = 0; } #endif } #ifdef SVDUMP if (vprefix > 0) #ifdef SHO /* always use the same hashfunction, for consistency across runs */ if (HASH_NR != 0) { int oh = HASH_NR; HASH_NR = 0; d_hash((uchar *) &now, vsize); /* SHO - set K1 */ HASH_NR = oh; } if (write(svfd, (uchar *) &K1, sizeof(ulong)) != sizeof(ulong)) #else if (write(svfd, (uchar *) &now, vprefix) != vprefix) #endif { fprintf(efd, "writing %s.svd failed\n", PanSource); wrapup(); } #endif #if defined(MA) && defined(W_XPT) if ((ulong) nstates%W_XPT == 0) { void w_xpoint(void); w_xpoint(); } #endif } #if defined(FULLSTACK) || defined(CNTRSTACK) onstack_put(); #ifdef DEBUG2 #if defined(FULLSTACK) && !defined(MA) printf("%d: putting %u (%d)\n", depth, trpt->ostate, (trpt->ostate)?trpt->ostate->tagged:0); #else printf("%d: putting\n", depth); #endif #endif #else #if NCORE>1 trpt->ostate = Lstate; #endif #endif } } if (depth > mreached) mreached = depth; #ifdef VERI if (trpt->tau&4) #endif trpt->tau &= ~(1|2); /* timeout and -request off */ _n = 0; #if SYNC (trpt+1)->o_n = 0; #endif #ifdef VERI if (now._nr_pr == 0) /* claim terminated */ { uerror("end state in claim reached"); } if (stopstate[((Pclaim *)pptr(0))->_t][((Pclaim *)pptr(0))->_p]) { uerror("end state in claim reached"); } Stutter: if (trpt->tau&4) /* must make a claimmove */ { #ifndef NOFAIR if ((now._a_t&2) /* A-bit set */ && now._cnt[now._a_t&1] == 1) { now._a_t &= ~2; now._cnt[now._a_t&1] = 0; trpt->o_pm |= 16; #ifdef DEBUG printf("%3d: fairness Rule 3.: _a_t = %d\n", (int) depth, now._a_t); #endif } #endif II = 0; /* never */ goto Veri0; } #endif #ifdef PERMUTED if (reversing&2) { seed = rand(); p_reorder(seed); } #endif #ifndef NOREDUCE /* Look for a process with only safe transitions */ /* (special rules apply in the 2nd dfs) */ if (boq == -1 && From != To #ifdef SAFETY #if NCORE>1 && (depth < z_handoff) #endif ) #else #if NCORE>1 && ((a_cycles) || (!a_cycles && depth < z_handoff)) #endif #ifdef BCS && (sched_max > 0 || depth > BASE) #endif && (!(now._a_t&1) || (a_cycles && #ifndef BITSTATE #ifdef MA #ifdef VERI !((trpt-1)->proviso)) #else !(trpt->proviso)) #endif #else #ifdef VERI (trpt-1)->ostate && !(((char *)&((trpt-1)->ostate->state))[0] & 128)) #else !(((char *)&(trpt->ostate->state))[0] & 128)) #endif #endif #else #ifdef VERI (trpt-1)->ostate && (trpt-1)->ostate->proviso == 0) #else trpt->ostate->proviso == 0) #endif #endif )) #endif /* attempt Partial Order Reduction as preselect moves */ #ifdef BCS if (trpt->sched_limit < sched_max) #endif { for ALL_P { Resume: /* pick up here if preselect fails */ this = pptr(II); tt = (int) ((P0 *)this)->_p; ot = (uchar) ((P0 *)this)->_t; if (trans[ot][tt]->atom & 8) { t = trans[ot][tt]; if (t->qu[0] != 0) { Ccheck++; if (!q_cond(II, t)) { continue; } Cholds++; } From = To = II; /* preselect process */ #ifdef NIBIS t->om = 0; #endif trpt->tau |= 32; /* preselect marker */ #ifdef DEBUG printf("%3ld: proc %d PreSelected (tau=%d)\n", depth, II, trpt->tau); #endif goto Again; } else { continue; } } } trpt->tau &= ~32; #endif #if !defined(NOREDUCE) || (defined(ETIM) && !defined(VERI)) Again: #endif trpt->o_pm &= ~(8|16|32|64); /* clear fairness-marks */ #ifndef NOFAIR if (fairness && boq == -1 #ifdef VERI && (!(trpt->tau&4) && !((trpt-1)->tau&128)) #endif && !(trpt->tau&8)) { /* A_bit = 1; Cnt = N in acc states with A_bit 0 */ if (!(now._a_t&2)) { if (a_cycles && (trpt->o_pm&2)) { /* Accepting state */ now._a_t |= 2; now._cnt[now._a_t&1] = now._nr_pr + 1; trpt->o_pm |= 8; #ifdef DEBUG printf("%3ld: fairness Rule 1: cnt=%d, _a_t=%d\n", depth, now._cnt[now._a_t&1], now._a_t); #endif } } else { /* A_bit = 0 when Cnt 0 */ if (now._cnt[now._a_t&1] == 1) { now._a_t &= ~2; now._cnt[now._a_t&1] = 0; trpt->o_pm |= 16; #ifdef DEBUG printf("%3ld: fairness Rule 3: _a_t = %d\n", depth, now._a_t); #endif } } } #endif #ifdef BCS trpt->bcs = trpt->b_pno = 0; /* initial */ if (From != To /* not a PO or atomic move */ && depth > BASE) /* there is a prior move */ { trpt->b_pno = now._last + BASE; trpt->bcs = B_PHASE1; #ifdef VERBOSE printf("%3ld: BCS phase 1 proc %d limit %d\n", depth, trpt->b_pno, trpt->sched_limit); #endif /* allow only process b_pno to move in this phase */ } c_switch: /* jumps here with bcs == B_PHASE2 with or wo B_FORCED added */ #ifdef VERBOSE printf("%3ld: BCS c_switch phase=%d pno=%d [forced %d]\n", depth, trpt->bcs, trpt->b_pno, (trpt->bcs&B_FORCED)?1:0); #endif #endif #ifdef P_RAND trpt->p_left = CNT_P; if (trpt->p_left > 1) { trpt->p_skip = rand() % (trpt->p_left); } else { trpt->p_skip = -1; } r_switch: #ifdef VERBOSE printf("%3ld: P_RAND r_switch p_skip=%d p_left=%d\n", depth, trpt->p_skip, trpt->p_left); #endif #endif for ALL_P { #ifdef PERMUTED if (reversing&2) { oII = II; if (From != To) { II = get_permuted(II); } } #endif #ifdef P_RAND if (trpt->p_skip >= 0) { trpt->p_skip--; /* skip random nr of procs */ #ifdef VERBOSE printf("%3ld: P_RAND skipping %d [new p_skip=%d p_left=%d]\n", depth, II, trpt->p_skip, trpt->p_left); #endif CONTINUE0; } if (trpt->p_left == 0) { #ifdef VERBOSE printf("%3ld: P_RAND done at %d\n", depth, II); #endif break; /* done */ } #ifdef VERBOSE printf("%3ld: P_RAND explore %d [p_left=%d]\n", depth, II, trpt->p_left); #endif trpt->p_left--; #endif #if SYNC /* no rendezvous with same proc */ if (boq != -1 && trpt->pr == II) { CONTINUE0; } #endif #ifdef BCS if ((trpt->bcs & B_PHASE1) && trpt->b_pno != II) { #ifdef VERBOSE printf("%3ld: BCS NotPre II=%d bcs=%d pno=%d [forced %d]\n", depth, II, trpt->bcs, trpt->b_pno, (trpt->bcs&B_FORCED)?1:0); #endif CONTINUE0; } #ifdef VERBOSE else if ((trpt->bcs & B_PHASE1) && trpt->b_pno == II) printf("%3ld: BCS IsPre II=%d bcs=%d pno=%d [forced %d]\n", depth, II, trpt->bcs, trpt->b_pno, (trpt->bcs&B_FORCED)?1:0); #endif if (trpt->bcs & B_PHASE2) /* 2nd phase */ { if (trpt->b_pno == II) /* was already done in phase 1 */ { #ifdef VERBOSE printf("%3ld: BCS NoRepeat II=%d bcs=%d pno=%d [forced %d]\n", depth, II, trpt->bcs, trpt->b_pno, (trpt->bcs&B_FORCED)?1:0); #endif CONTINUE0; } if (!(trpt->bcs & B_FORCED) /* unless forced */ && trpt->sched_limit >= sched_max) { #ifdef VERBOSE printf("%3ld: BCS Bound II=%d bcs=%d pno=%d [forced %d]\n", depth, II, trpt->bcs, trpt->b_pno, (trpt->bcs&B_FORCED)?1:0); #endif CONTINUE0; /* enforce bound */ } } #endif #ifdef VERI Veri0: #endif this = pptr(II); tt = (int) ((P0 *)this)->_p; ot = (uchar) ((P0 *)this)->_t; #ifdef NIBIS /* don't repeat a previous preselected expansion */ /* could hit this if reduction proviso was false */ t = trans[ot][tt]; if (!(trpt->tau&4) && !(trpt->tau&1) && !(trpt->tau&32) && (t->atom & 8) && boq == -1 && From != To) { if (t->qu[0] == 0 || q_cond(II, t)) { _m = t->om; if (_m>_n||(_n>3&&_m!=0)) { _n=_m; } CONTINUE0; /* did it before */ } } #endif trpt->o_pm &= ~1; /* no move in this pid yet */ #ifdef EVENT_TRACE (trpt+1)->o_event = now._event; #endif /* Fairness: Cnt++ when Cnt == II */ #ifndef NOFAIR trpt->o_pm &= ~64; /* didn't apply rule 2 */ if (fairness && boq == -1 && !(trpt->o_pm&32) && (now._a_t&2) && now._cnt[now._a_t&1] == II+2) { now._cnt[now._a_t&1] -= 1; #ifdef VERI /* claim need not participate */ if (II == 1) now._cnt[now._a_t&1] = 1; #endif #ifdef DEBUG printf("%3ld: proc %d fairness ", depth, II); printf("Rule 2: --cnt to %d (%d)\n", now._cnt[now._a_t&1], now._a_t); #endif trpt->o_pm |= (32|64); } #endif #ifdef HAS_PRIORITY if (!highest_priority(((P0 *)this)->_pid, II, t)) { CONTINUE0; } #else #ifdef HAS_PROVIDED if (!provided(II, ot, tt, t)) { CONTINUE0; } #endif #endif /* check all trans of proc II - escapes first */ #ifdef HAS_UNLESS trpt->e_state = 0; #endif (trpt+1)->pr = (uchar) II; (trpt+1)->st = tt; #ifdef T_RAND for (ooi = eoi = 0, t = trans[ot][tt]; t; t = t->nxt, ooi++) { if (strcmp(t->tp, "else") == 0 #ifdef HAS_UNLESS || t->e_trans != 0 #endif ) { eoi++; } } if (eoi > 0) { t = trans[ot][tt]; #ifdef VERBOSE printf("randomizer: suppressed, saw else or escape\n"); #endif } else if (ooi > 0) { eoi = rand()%ooi; #ifdef VERBOSE printf("randomizer: skip %d in %d\n", eoi, ooi); #endif for (t = trans[ot][tt]; t; t = t->nxt) if (eoi-- <= 0) break; } domore: for ( ; t && ooi > 0; t = t->nxt, ooi--) #else for (t = trans[ot][tt]; t; t = t->nxt) #endif { #ifdef HAS_UNLESS /* exploring all transitions from * a single escape state suffices */ if (trpt->e_state > 0 && trpt->e_state != t->e_trans) { #ifdef DEBUG printf("skip 2nd escape %d (did %d before)\n", t->e_trans, trpt->e_state); #endif break; } #endif #if defined(TRIX) && !defined(TRIX_ORIG) && !defined(BFS) (trpt+1)->p_bup = now._ids_[II]; #endif (trpt+1)->o_t = t; #ifdef INLINE #include FORWARD_MOVES P999: /* jumps here when move succeeds */ #else if (!(_m = do_transit(t, II))) { continue; } #endif #ifdef BCS if (depth > BASE && II >= BASE && From != To #ifndef BCS_NOFIX /* added 5.2.5: prior move was not po */ && !((trpt-(BASE+1))->tau & 32) #endif && boq == -1 && (trpt->bcs & B_PHASE2) && trpt->b_pno != II /* context switch */ && !(trpt->bcs & B_FORCED)) /* unless forced */ { (trpt+1)->sched_limit = 1 + trpt->sched_limit; #ifdef VERBOSE printf("%3ld: up sched count to %d\n", depth, (trpt+1)->sched_limit); #endif } else { (trpt+1)->sched_limit = trpt->sched_limit; #ifdef VERBOSE printf("%3ld: keep sched count at %d\n", depth, (trpt+1)->sched_limit); #endif } #endif if (boq == -1) #ifdef CTL /* for branching-time, can accept reduction only if */ /* the persistent set contains just 1 transition */ { if ((trpt->tau&32) && (trpt->o_pm&1)) trpt->tau |= 16; trpt->o_pm |= 1; /* we moved */ } #else trpt->o_pm |= 1; /* we moved */ #endif #ifdef LOOPSTATE if (loopstate[ot][tt]) { #ifdef VERBOSE printf("exiting from loopstate:\n"); #endif trpt->tau |= 16; cnt_loops++; } #endif #ifdef PEG peg[t->forw]++; #endif #if defined(VERBOSE) || defined(CHECK) #if defined(SVDUMP) cpu_printf("%3ld: proc %d exec %d \n", depth, II, t->t_id); #else cpu_printf("%3ld: proc %d exec %d, %d to %d, %s %s %s %saccepting [tau=%d]\n", depth, II, t->forw, tt, t->st, t->tp, (t->atom&2)?"atomic":"", (boq != -1)?"rendez-vous":"", (trpt->o_pm&2)?"":"non-", trpt->tau); #ifdef HAS_UNLESS if (t->e_trans) cpu_printf("\t(escape to state %d)\n", t->st); #endif #endif #ifdef T_RAND cpu_printf("\t(randomizer %d)\n", ooi); #endif #endif #ifdef HAS_LAST #ifdef VERI if (II != 0) #endif now._last = II - BASE; #endif #ifdef HAS_UNLESS trpt->e_state = t->e_trans; #endif depth++; trpt++; trpt->pr = (uchar) II; trpt->st = tt; trpt->o_pm &= ~(2|4); if (t->st > 0) { ((P0 *)this)->_p = t->st; /* moved down reached[ot][t->st] = 1; */ } #ifndef SAFETY if (a_cycles) { #if (ACCEPT_LAB>0 && !defined(NP)) || (PROG_LAB>0 && defined(HAS_NP)) int ii; #endif #define P__Q ((P0 *)pptr(ii)) #if ACCEPT_LAB>0 #ifdef NP /* state 1 of np_ claim is accepting */ if (((P0 *)pptr(0))->_p == 1) trpt->o_pm |= 2; #else for (ii = 0; ii < (int) now._nr_pr; ii++) { if (accpstate[P__Q->_t][P__Q->_p]) { trpt->o_pm |= 2; break; } } #endif #endif #if defined(HAS_NP) && PROG_LAB>0 for (ii = 0; ii < (int) now._nr_pr; ii++) { if (progstate[P__Q->_t][P__Q->_p]) { trpt->o_pm |= 4; break; } } #endif #undef P__Q } #endif trpt->o_t = t; trpt->o_n = _n; trpt->o_ot = ot; trpt->o_tt = tt; trpt->o_To = To; trpt->o_m = _m; trpt->tau = 0; #ifdef PERMUTED if (reversing&2) { trpt->seed = seed; trpt->oII = oII; } #endif #if defined(T_RAND) && !defined(BFS) trpt->oo_i = ooi; #endif if (boq != -1 || (t->atom&2)) { trpt->tau |= 8; #ifdef VERI /* atomic sequence in claim */ if((trpt-1)->tau&4) trpt->tau |= 4; else trpt->tau &= ~4; } else { if ((trpt-1)->tau&4) trpt->tau &= ~4; else trpt->tau |= 4; } /* if claim allowed timeout, so */ /* does the next program-step: */ if (((trpt-1)->tau&1) && !(trpt->tau&4)) trpt->tau |= 1; #else } else trpt->tau &= ~8; #endif if (boq == -1 && (t->atom&2)) { From = To = II; nlinks++; } else { From = FROM_P; To = UPTO_P; } #if NCORE>1 && defined(FULL_TRAIL) if (upto > 0) { Push_Stack_Tree(II, t->t_id); } #endif #ifdef TRIX if (processes[II]) { processes[II]->modified = 1; /* transition in II */ #ifdef V_TRIX printf("%4d: process %d modified\n", depth, II); } else { printf("%4d: process %d modified but gone (%p)\n", depth, II, trpt); #endif } #endif goto Down; /* pseudo-recursion */ Up: #ifdef TRIX #ifndef TRIX_ORIG #ifndef BFS now._ids_[trpt->pr] = trpt->p_bup; #endif #else if (processes[trpt->pr]) { processes[trpt->pr]->modified = 1; /* reverse move */ #ifdef V_TRIX printf("%4d: unmodify pr %d (%p)\n", depth, trpt->pr, trpt); } else { printf("%4d: unmodify pr %d (gone) (%p)\n", depth, trpt->pr, trpt); #endif } #endif #endif #ifdef CHECK cpu_printf("%d: Up - %s\n", depth, (trpt->tau&4)?"claim":"program"); #endif #if NCORE>1 iam_alive(); #ifdef USE_DISK mem_drain(); #endif #endif #if defined(MA) || NCORE>1 if (depth <= 0) return; /* e.g., if first state is old, after a restart */ #endif #ifdef SC if (CNT1 > CNT2 && depth < hiwater - (HHH-DDD) - 2) { trpt += DDD; disk2stack(); maxdepth -= DDD; hiwater -= DDD; if(verbose) printf("unzap %ld: %ld\n", CNT2, hiwater); } #endif #ifndef SAFETY if ((now._a_t&1) && depth <= A_depth) return; /* to checkcycles() */ #endif #ifndef NOFAIR if (trpt->o_pm&128) /* fairness alg */ { now._cnt[now._a_t&1] = trpt->bup.oval; _n = 1; trpt->o_pm &= ~128; depth--; trpt--; #if defined(VERBOSE) || defined(CHECK) printf("%3ld: reversed fairness default move\n", depth); #endif goto Q999; } #endif #ifdef HAS_LAST #ifdef VERI { long d; Trail *trl; now._last = 0; for (d = 1; d < depth; d++) { trl = getframe(depth-d); /* was (trpt-d) */ if (trl->pr != 0) { now._last = trl->pr - BASE; break; } } } #else now._last = (depth<1)?0:(trpt-1)->pr; #endif #endif #ifdef EVENT_TRACE now._event = trpt->o_event; #endif t = trpt->o_t; _n = trpt->o_n; ot = trpt->o_ot; II = trpt->pr; tt = trpt->o_tt; this = Pptr(II); To = trpt->o_To; _m = trpt->o_m; #ifdef PERMUTED if (reversing&2) { seed = trpt->seed; oII = trpt->oII; } #endif #if defined(T_RAND) && !defined(BFS) ooi = trpt->oo_i; #endif #ifdef INLINE_REV _m = do_reverse(t, II, _m); #else #include BACKWARD_MOVES R999: /* jumps here when done */ #endif #ifdef VERBOSE cpu_printf("%3ld: proc %d reverses %d, %d to %d\n", depth, II, t->forw, tt, t->st); cpu_printf("\t%s [abit=%d,adepth=%ld,tau=%d,%d]\n", t->tp, now._a_t, A_depth, trpt->tau, (trpt-1)->tau); #endif #ifndef NOREDUCE /* pass the proviso tags */ if ((trpt->tau&8) /* rv or atomic */ && (trpt->tau&16)) (trpt-1)->tau |= 16; #ifdef SAFETY if ((trpt->tau&8) /* rv or atomic */ && (trpt->tau&64)) (trpt-1)->tau |= 64; #endif #endif #if defined(BCS) && (defined(NOREDUCE) || !defined(SAFETY)) if ((trpt->tau&8) && (trpt->tau&64)) (trpt-1)->tau |= 64; #endif depth--; trpt--; #ifdef NSUCC trpt->n_succ++; #endif #ifdef NIBIS (trans[ot][tt])->om = _m; /* head of list */ #endif /* i.e., not set if rv fails */ if (_m) { reached[ot][t->st] = 1; reached[ot][tt] = 1; } #ifdef HAS_UNLESS else trpt->e_state = 0; /* undo */ #endif if (_m>_n||(_n>3&&_m!=0)) _n=_m; ((P0 *)this)->_p = tt; } /* all options */ #ifdef T_RAND if (!t && ooi > 0) { t = trans[ot][tt]; #ifdef VERBOSE printf("randomizer: continue for %d more\n", ooi); #endif goto domore; } #ifdef VERBOSE else printf("randomizer: done\n"); #endif #endif #ifndef NOFAIR /* Fairness: undo Rule 2 */ if ((trpt->o_pm&32) && (trpt->o_pm&64)) { if (trpt->o_pm&1) { #ifdef VERI if (now._cnt[now._a_t&1] == 1) now._cnt[now._a_t&1] = 2; #endif now._cnt[now._a_t&1] += 1; #ifdef VERBOSE printf("%3ld: proc %d fairness ", depth, II); printf("undo Rule 2, cnt=%d, _a_t=%d\n", now._cnt[now._a_t&1], now._a_t); #endif trpt->o_pm &= ~(32|64); } else { if (_n > 0) { trpt->o_pm &= ~64; II = INI_P; } } } #endif #ifdef VERI if (II == 0) { break; /* never claim */ } #endif CONTINUE; } /* ALL_P */ #ifdef NSUCC tally_succ(trpt->n_succ); #endif #ifdef P_RAND if (trpt->p_left > 0 && NDONE_P) { trpt->p_skip = -1; /* probably rendundant */ #ifdef VERBOSE printf("%3ld: P_RAND -- explore remainder\n", depth); #endif goto r_switch; /* explore the remaining procs */ } else { #ifdef VERBOSE printf("%3ld: P_RAND -- none left\n", depth); #endif } #endif #ifdef BCS if (trpt->bcs & B_PHASE1) { trpt->bcs = B_PHASE2; /* start 2nd phase */ if (_n == 0 || !(trpt->tau&64)) /* pre-move unexecutable or led to stackstate */ { trpt->bcs |= B_FORCED; /* forced switch */ } #ifdef VERBOSE printf("%3ld: BCS move to phase 2, _n=%d %s\n", depth, _n, (trpt->bcs & B_FORCED)?"forced":"free"); #endif From = FROM_P; To = UPTO_P; goto c_switch; } if (_n == 0 /* no process could move */ && II >= BASE /* not the never claim */ && trpt->sched_limit >= sched_max) { _n = 1; #ifdef VERBOSE printf("%3ld: BCS not a deadlock\n", depth); #endif } #endif #ifndef NOFAIR /* Fairness: undo Rule 2 */ if (trpt->o_pm&32) /* remains if proc blocked */ { #ifdef VERI if (now._cnt[now._a_t&1] == 1) now._cnt[now._a_t&1] = 2; #endif now._cnt[now._a_t&1] += 1; #ifdef VERBOSE printf("%3ld: proc -- fairness ", depth); printf("undo Rule 2, cnt=%d, _a_t=%d\n", now._cnt[now._a_t&1], now._a_t); #endif trpt->o_pm &= ~32; } #ifndef NP if (fairness && _n == 0 /* nobody moved */ #ifdef VERI && !(trpt->tau&4) /* in program move */ #endif && !(trpt->tau&8) /* not an atomic one */ #ifdef ETIM && (trpt->tau&1) /* already tried timeout */ #endif #ifndef NOREDUCE /* see below */ && !((trpt->tau&32) && (_n == 0 || (trpt->tau&16))) #endif && now._cnt[now._a_t&1] > 0) /* needed more procs */ { depth++; trpt++; trpt->o_pm |= 128 | ((trpt-1)->o_pm&(2|4)); trpt->bup.oval = now._cnt[now._a_t&1]; now._cnt[now._a_t&1] = 1; #ifdef VERI trpt->tau = 4; #else trpt->tau = 0; #endif From = FROM_P; To = UPTO_P; #if defined(VERBOSE) || defined(CHECK) printf("%3ld: fairness default move ", depth); printf("(all procs block)\n"); #endif goto Down; } #endif Q999: /* returns here with _n>0 when done */; if (trpt->o_pm&8) { now._a_t &= ~2; now._cnt[now._a_t&1] = 0; trpt->o_pm &= ~8; #ifdef VERBOSE printf("%3ld: fairness undo Rule 1, _a_t=%d\n", depth, now._a_t); #endif } if (trpt->o_pm&16) { now._a_t |= 2; now._cnt[now._a_t&1] = 1; trpt->o_pm &= ~16; #ifdef VERBOSE printf("%3ld: fairness undo Rule 3, _a_t=%d\n", depth, now._a_t); #endif } #endif #ifndef NOREDUCE #ifdef SAFETY #ifdef LOOPSTATE /* at least one move that was preselected at this */ /* level, blocked or was a loop control flow point */ if ((trpt->tau&32) && (_n == 0 || (trpt->tau&16))) #else /* preselected move - no successors outside stack */ if ((trpt->tau&32) && !(trpt->tau&64)) #endif { From = FROM_P; To = UPTO_P; /* undo From == To */ #ifdef DEBUG printf("%3ld: proc %d UnSelected (_n=%d, tau=%d)\n", depth, II+1, _n, trpt->tau); #endif _n = 0; trpt->tau &= ~(16|32|64); if (MORE_P) /* II already restored and updated */ { goto Resume; } else { goto Again; } } #else /* at least one move that was preselected at this */ /* level, blocked or truncated at the next level */ if ((trpt->tau&32) && (_n == 0 || (trpt->tau&16))) { #ifdef DEBUG printf("%3ld: proc %d UnSelected (_n=%d, tau=%d)\n", depth, II+1, (int) _n, trpt->tau); #endif if (a_cycles && (trpt->tau&16)) { if (!(now._a_t&1)) { #ifdef DEBUG printf("%3ld: setting proviso bit\n", depth); #endif #ifndef BITSTATE #ifdef MA #ifdef VERI (trpt-1)->proviso = 1; #else trpt->proviso = 1; #endif #else #ifdef VERI if ((trpt-1)->ostate) ((char *)&((trpt-1)->ostate->state))[0] |= 128; #else ((char *)&(trpt->ostate->state))[0] |= 128; #endif #endif #else #ifdef VERI if ((trpt-1)->ostate) (trpt-1)->ostate->proviso = 1; #else trpt->ostate->proviso = 1; #endif #endif From = FROM_P; To = UPTO_P; _n = 0; trpt->tau &= ~(16|32|64); goto Again; /* do full search */ } /* else accept reduction */ } else { From = FROM_P; To = UPTO_P; _n = 0; trpt->tau &= ~(16|32|64); if (MORE_P) /* II already updated */ { goto Resume; } else { goto Again; } } } #endif #endif if (_n == 0 || ((trpt->tau&4) && (trpt->tau&2))) { #ifdef DEBUG cpu_printf("%3ld: no move [II=%d, tau=%d, boq=%d]\n", depth, II, trpt->tau, boq); #endif #if SYNC /* ok if a rendez-vous fails: */ if (boq != -1) goto Done; #endif /* ok if no procs or we're at maxdepth */ if ((now._nr_pr == 0 && (!strict || qs_empty())) || depth >= maxdepth-1) goto Done; /* undo change from 5.2.3 */ if ((trpt->tau&8) && !(trpt->tau&4)) { trpt->tau &= ~(1|8); /* 1=timeout, 8=atomic */ From = FROM_P; To = UPTO_P; #ifdef DEBUG cpu_printf("%3ld: atomic step proc %d unexecutable\n", depth, II+1); #endif #ifdef VERI trpt->tau |= 4; /* switch to claim */ #endif goto AllOver; } #ifdef ETIM if (!(trpt->tau&1)) /* didn't try timeout yet */ { #ifdef VERI if (trpt->tau&4) { #ifndef NTIM if (trpt->tau&2) /* requested */ #endif { trpt->tau |= 1; trpt->tau &= ~2; #ifdef DEBUG cpu_printf("%d: timeout\n", depth); #endif goto Stutter; } } else { /* only claim can enable timeout */ if ((trpt->tau&8) && !((trpt-1)->tau&4)) /* blocks inside an atomic */ goto BreakOut; #ifdef DEBUG cpu_printf("%d: req timeout\n", depth); #endif (trpt-1)->tau |= 2; /* request */ #if NCORE>1 && defined(FULL_TRAIL) if (upto > 0) { Pop_Stack_Tree(); } #endif goto Up; } #else #ifdef DEBUG cpu_printf("%d: timeout\n", depth); #endif trpt->tau |= 1; goto Again; #endif } #endif #ifdef VERI BreakOut: #ifndef NOSTUTTER if (!(trpt->tau&4)) { trpt->tau |= 4; /* claim stuttering */ trpt->tau |= 128; /* stutter mark */ #ifdef DEBUG cpu_printf("%d: claim stutter\n", depth); #endif goto Stutter; } #else ; #endif #else if (!noends && !a_cycles && !endstate()) { depth--; trpt--; /* new 4.2.3 */ uerror("invalid end state"); depth++; trpt++; } #ifndef NOSTUTTER else if (a_cycles && (trpt->o_pm&2)) /* new 4.2.4 */ { depth--; trpt--; uerror("accept stutter"); depth++; trpt++; } #endif #endif } Done: if (!(trpt->tau&8)) /* not in atomic seqs */ { #ifndef MA #if defined(FULLSTACK) || defined(CNTRSTACK) #ifdef VERI if (boq == -1 && (((trpt->tau&4) && !(trpt->tau&128)) || ( (trpt-1)->tau&128))) #else if (boq == -1) #endif { #ifdef DEBUG2 #if defined(FULLSTACK) printf("%ld: zapping %u (%d)\n", depth, trpt->ostate, (trpt->ostate)?trpt->ostate->tagged:0); #endif #endif onstack_zap(); } #endif #else #ifdef VERI if (boq == -1 && (((trpt->tau&4) && !(trpt->tau&128)) || ( (trpt-1)->tau&128))) #else if (boq == -1) #endif { #ifdef DEBUG printf("%ld: zapping\n", depth); #endif onstack_zap(); #ifndef NOREDUCE if (trpt->proviso) g_store((char *) &now, vsize, 1); #endif } #endif #ifndef SAFETY if (_n != 0 #ifdef VERI /* --after-- a program-step, i.e., */ /* after backtracking a claim-step */ && (trpt->tau&4) /* with at least one running process */ /* unless in a stuttered accept state */ && ((now._nr_pr > 1) || (trpt->o_pm&2)) #endif && !(now._a_t&1)) { #ifndef NOFAIR if (fairness) { #ifdef VERBOSE cpu_printf("Consider check %d %d...\n", now._a_t, now._cnt[0]); #endif if ((now._a_t&2) /* A-bit */ && (now._cnt[0] == 1)) checkcycles(); } else #endif if (a_cycles && (trpt->o_pm&2)) checkcycles(); } #endif } if (depth > 0) { #if NCORE>1 && defined(FULL_TRAIL) if (upto > 0) { Pop_Stack_Tree(); } #endif goto Up; } } #else void new_state(void) { /* place holder */ } #endif void spin_assert(int a, char *s, int ii, int tt, Trans *t) { if (!a && !noasserts) { char bad[1024]; strcpy(bad, "assertion violated "); if (strlen(s) > 1000) { strncpy(&bad[19], (const char *) s, 1000); bad[1019] = '\0'; } else strcpy(&bad[19], s); uerror(bad); } } #ifndef NOBOUNDCHECK int Boundcheck(int x, int y, int a1, int a2, Trans *a3) { spin_assert((x >= 0 && x < y), "- invalid array index", a1, a2, a3); return x; } #endif int do_hashgen = 0; void wrap_stats(void) { if (nShadow>0) printf("%9.8g states, stored (%g visited)\n", nstates - nShadow, nstates); else printf("%9.8g states, stored\n", nstates); #ifdef BFS_PAR if (bfs_punt > 0) printf("%9.8g states lost (lack of queue memory)\n", (double) bfs_punt); #endif #ifdef BFS #if SYNC printf(" %8g nominal states (- rv and atomic)\n", nstates-midrv-nlinks+revrv); printf(" %8g rvs succeeded\n", midrv-failedrv); #else printf(" %8g nominal states (stored-atomic)\n", nstates-nlinks); #endif #ifdef DEBUG printf(" %8g midrv\n", midrv); printf(" %8g failedrv\n", failedrv); printf(" %8g revrv\n", revrv); #endif #endif printf("%9.8g states, matched\n", truncs); #ifdef CHECK printf("%9.8g matches within stack\n",truncs2); #endif if (nShadow>0) printf("%9.8g transitions (= visited+matched)\n", nstates+truncs); else printf("%9.8g transitions (= stored+matched)\n", nstates+truncs); printf("%9.8g atomic steps\n", nlinks); if (nlost) printf("%g lost messages\n", (double) nlost); #ifndef BITSTATE #ifndef MA printf("hash conflicts: %9.8g (resolved)\n", hcmp); #if !defined(AUTO_RESIZE) && !defined(BFS_PAR) if (hcmp > (double) (1< 1.0) { fp = 100. / fp; while (fp > 2.) { fi++; fp /= 2.; } if (fi > 0) { printf(" (hint: rerun with -w%d to reduce runtime)", ssize-fi); } } printf("\n"); } #endif #endif #else #ifdef CHECK printf("%8g states allocated for dfs stack\n", ngrabs); #endif if (udmem) printf("\nhash factor: %4g (best if > 100.)\n\n", (double)(((double) udmem) * 8.0) / (double) nstates); else printf("\nhash factor: %4g (best if > 100.)\n\n", ((double)(((ulong)1)<<(ssize-10)) / (double) nstates) * 1024.0); printf("bits set per state: %u (-k%u)\n", hfns, hfns); if (do_hashgen) printf("hash polynomial used: 0x%.8x\n", HASH_CONST[HASH_NR]); if (s_rand != 12345) printf("random seed used: 0\n", (uint) (s_rand-1)); #endif #if defined(BFS_DISK) && !defined(BFS_PAR) printf("bfs disk reads: %ld writes %ld -- diff %ld\n", bfs_dsk_reads, bfs_dsk_writes, bfs_dsk_writes-bfs_dsk_reads); if (bfs_dsk_read >= 0) (void) close(bfs_dsk_read); if (bfs_dsk_write >= 0) (void) close(bfs_dsk_write); (void) unlink("pan_bfs_dsk.tmp"); #endif } void wrapup(void) { double nr1, nr2, nr3 = 0.0, nr4, nr5 = 0.0; #ifdef BFS_PAR if (who_am_i != 0) { pan_exit(0); } #endif #if NCORE>1 if (verbose) cpu_printf("wrapup -- %d error(s)\n", errors); if (core_id != 0) { #ifdef USE_DISK void dsk_stats(void); dsk_stats(); #endif if (search_terminated != NULL) { *search_terminated |= 2; /* wrapup */ } exit(0); /* normal termination, not an error */ } #endif #if !defined(WIN32) && !defined(WIN64) signal(SIGINT, SIG_DFL); #endif printf("\n(%s)\n", SpinVersion); if (!done) printf("Warning: Search not completed\n"); #if defined(BFS_PAR) && !defined(BITSTATE) if (bfs_punt > 0) printf("Warning: Search incomplete\n"); #endif #ifdef SC (void) unlink((const char *)stackfile); #endif #ifdef BFS_PAR printf(" + Multi-Core (using %d cores)\n", Cores); #ifdef BFS_SEP_HASH printf(" + Seperate Hash Tables\n"); #endif #ifdef BFS_DISK printf(" + Disk storage\n"); #endif #endif #if NCORE>1 if (a_cycles) { printf(" + Multi-Core (NCORE=%d)\n", NCORE); } else { printf(" + Multi-Core (NCORE=%d -z%ld)\n", NCORE, z_handoff); } #endif #ifdef BFS printf(" + Breadth-First Search\n"); #endif #ifndef NOREDUCE printf(" + Partial Order Reduction\n"); #endif #ifdef PERMUTED printf(" + Process Scheduling Permutation\n"); #endif #ifdef P_REVERSE printf(" + Reverse Depth-First Search Order\n"); #endif if (t_reverse) printf(" + Reverse Transition Ordering\n"); #ifdef T_RAND printf(" + Randomized Transition Ordering\n"); #endif #ifdef P_RAND printf(" + Randomized Process Ordering\n"); #endif #ifdef BCS printf(" + Scheduling Restriction (-L%d)\n", sched_max); #endif #ifdef TRIX printf(" + Tree Index Compression\n"); #endif #ifdef COLLAPSE printf(" + Compression\n"); #endif #ifdef MA printf(" + Graph Encoding (-DMA=%d)\n", MA); #ifdef R_XPT printf(" Restarted from checkpoint %s.xpt\n", PanSource); #endif #endif #ifdef CHECK #ifdef FULLSTACK printf(" + FullStack Matching\n"); #endif #ifdef CNTRSTACK printf(" + CntrStack Matching\n"); #endif #endif #ifdef PERMUTED if (reversing & 2) { if (p_reorder == set_permuted) { printf(" + Permuted\n"); } if (p_reorder == set_reversed) { printf(" + Reversed\n"); } if (p_reorder == set_rotated) { printf(" + Rotated %d\n", p_rotate); } if (p_reorder == set_randrot) { printf(" + RandRotated\n"); } } #endif #ifdef BITSTATE printf("\nBit statespace search for:\n"); #else #ifdef HC printf("\nHash-Compact %d search for:\n", HC); #else printf("\nFull statespace search for:\n"); #endif #endif #ifdef EVENT_TRACE #ifdef NEGATED_TRACE printf(" notrace assertion +\n"); #else printf(" trace assertion +\n"); #endif #endif #ifdef VERI printf(" never claim +"); printf(" (%s)\n", procname[((Pclaim *)pptr(0))->_t]); printf(" assertion violations "); if (noasserts) printf("- (disabled by -A flag)\n"); else printf("+ (if within scope of claim)\n"); #else #ifdef NOCLAIM printf(" never claim - (not selected)\n"); #else printf(" never claim - (none specified)\n"); #endif printf(" assertion violations "); if (noasserts) printf("- (disabled by -A flag)\n"); else printf("+\n"); #endif #ifndef SAFETY #ifdef NP printf(" non-progress cycles "); #else printf(" acceptance cycles "); #endif if (a_cycles) printf("+ (fairness %sabled)\n", fairness?"en":"dis"); else printf("- (not selected)\n"); #else #if !defined(BFS_PAR) || !defined(L_BOUND) printf(" cycle checks - (disabled by -DSAFETY)\n"); #else printf(" cycle checks + (bound %d)\n", L_bound); #endif #endif #ifdef VERI printf(" invalid end states - "); printf("(disabled by "); if (noends) printf("-E flag)\n\n"); else printf("never claim)\n\n"); #else printf(" invalid end states "); if (noends) printf("- (disabled by -E flag)\n\n"); else printf("+\n\n"); #endif printf("State-vector %d byte, depth reached %ld", hmax, #if NCORE>1 (nr_handoffs * z_handoff) + #endif mreached); printf(", errors: %d\n", errors); fflush(stdout); #ifdef MA if (done) { extern void dfa_stats(void); if (maxgs+a_cycles+2 < MA) printf("MA stats: -DMA=%d is sufficient\n", maxgs+a_cycles+2); dfa_stats(); } #endif wrap_stats(); #ifdef CHECK printf("stackframes: %d/%d\n\n", smax, svmax); printf("stats: fa %ld, fh %ld, zh %ld, zn %ld - ", Fa, Fh, Zh, Zn); printf("check %ld holds %ld\n", Ccheck, Cholds); printf("stack stats: puts %ld, probes %ld, zaps %ld\n", PUT, PROBE, ZAPS); #else printf("\n"); #endif #if !defined(BITSTATE) && defined(NOCOMP) if (!verbose) { goto jump_here; } #endif #if 1 nr1 = (nstates-nShadow)* (double)(hmax+sizeof(H_el)-sizeof(unsigned)); #ifdef BFS nr2 = 0.0; #else nr2 = (double) ((maxdepth+3)*sizeof(Trail)); #endif #ifndef BITSTATE #if !defined(MA) || defined(COLLAPSE) nr3 = (double) (ONE_L<1 && !defined(SEP_STATE) tmp_nr -= ((double) NCORE * LWQ_SIZE) + GWQ_SIZE; #endif if (tmp_nr < 0.0) tmp_nr = 0.; printf("Stats on memory usage (in Megabytes):\n"); printf("%9.3f equivalent memory usage for states", nr1/1048576.); /* 1024*1024=1048576 */ printf(" (stored*(State-vector + overhead))\n"); #if NCORE>1 && !defined(WIN32) && !defined(WIN64) printf("%9.3f shared memory reserved for state storage\n", mem_reserved/1048576.); #ifdef SEP_HEAP printf(" in %d local heaps of %7.3f MB each\n", NCORE, mem_reserved/(NCORE*1048576.)); #endif printf("\n"); #endif #ifdef BITSTATE if (udmem) printf("%9.3f memory used for hash array (-M%ld)\n", nr3/1048576., udmem/(1024L*1024L)); else printf("%9.3f memory used for hash array (-w%d)\n", nr3/1048576., ssize); if (nr5 > 0.0) printf("%9.3f memory used for bit stack\n", nr5/1048576.); remainder = remainder - nr3 - nr5; #else #ifndef USE_TDH printf("%9.3f actual memory usage for states", tmp_nr/1048576.); remainder -= tmp_nr; if (tmp_nr > 0.) { if (tmp_nr < nr1) { printf(" (compression: %.2f%%)\n", (100.0*tmp_nr)/nr1); } else { printf("\n"); } } else { printf(" (less than 1k)\n"); } #ifndef MA if (tmp_nr > 0. && tmp_nr < nr1) { printf(" state-vector as stored = %.0f byte", (tmp_nr)/(nstates-nShadow) - (double) (sizeof(H_el) - sizeof(unsigned))); printf(" + %ld byte overhead\n", (long int) sizeof(H_el)-sizeof(unsigned)); } #endif #endif #if !defined(MA) || defined(COLLAPSE) #ifdef BFS_PAR printf("%9.3f shared memory used for hash table (-w%d)\n", ((double) bfs_pre_allocated)/1048576., ssize); #else printf("%9.3f memory used for hash table (-w%d)\n", nr3/1048576., ssize); remainder -= nr3; #endif #endif #endif #ifndef BFS printf("%9.3f memory used for DFS stack (-m%ld)\n", nr2/1048576., maxdepth); remainder -= nr2; #endif #if NCORE>1 remainder -= ((double) NCORE * LWQ_SIZE) + GWQ_SIZE; printf("%9.3f shared memory used for work-queues\n", (GWQ_SIZE + (double) NCORE * LWQ_SIZE) /1048576.); printf(" in %d queues of %7.3f MB each", NCORE, (double) LWQ_SIZE /1048576.); #ifndef NGQ printf(" + a global q of %7.3f MB\n", (double) GWQ_SIZE / 1048576.); #else printf("\n"); #endif #endif if (remainder - fragment > 1048576.) { printf("%9.3f other (proc and chan stacks)\n", (remainder-fragment)/1048576.); } if (fragment > 1048576.) { printf("%9.3f memory lost to fragmentation\n", fragment/1048576.); } #ifdef BFS_PAR printf("%9.3f total non-shared memory usage\n\n", memcnt/1048576.); #else printf("%9.3f total actual memory usage\n\n", memcnt/1048576.); #endif } #ifndef MA else #endif #endif #if !defined(BITSTATE) && defined(NOCOMP) jump_here: #endif #ifndef MA printf("%9.3f memory usage (Mbyte)\n", memcnt/1048576.); #endif #ifdef BFS_PAR bfs_report_mem(); #else printf("\n"); #endif #ifdef COLLAPSE printf("nr of templates: [ 0:globals 1:chans 2:procs ]\n"); printf("collapse counts: [ "); { int i; for (i = 0; i < 256+2; i++) if (ncomps[i] != 0) printf("%d:%lu ", i, ncomps[i]); printf("]\n"); } #endif #ifdef TRIX if (verbose) { int i; printf("TRIX counts:\n"); printf(" processes: "); for (i = 0; i < MAXPROC; i++) if (_p_count[i] != 0) { printf("%3d:%ld ", i, _p_count[i]); } printf("\n channels : "); for (i = 0; i < MAXQ; i++) if (_c_count[i] != 0) { printf("%3d:%ld ", i, _c_count[i]); } printf("\n\n"); } #endif if ((done || verbose) && !no_rck) do_reach(); #ifdef PEG { int i; printf("\nPeg Counts (transitions executed):\n"); for (i = 1; i < NTRANS; i++) { if (peg[i]) putpeg(i, peg[i]); } } #endif #ifdef VAR_RANGES dumpranges(); #endif #ifdef SVDUMP if (vprefix > 0) close(svfd); #endif #ifdef LOOPSTATE printf("%g loopstates hit\n", cnt_loops); #endif #ifdef NSUCC dump_succ(); #endif #if NCORE>1 && defined(T_ALERT) crash_report(); #endif #ifndef BFS_PAR pan_exit(0); #endif } void stopped(int arg) { #ifdef BFS_PAR bfs_shutdown("interrupted"); #endif printf("Interrupted\n"); #if NCORE>1 was_interrupted = 1; #endif wrapup(); pan_exit(0); } /* * super fast hash, based on Paul Hsieh's function * http://www.azillionmonkeys.com/qed/hash.html */ #include #undef get16bits #if defined(__GNUC__) && defined(__i386__) #define get16bits(d) (*((const uint16_t *) (d))) #else #define get16bits(d) ((((uint32_t)(((const uint8_t *)(d))[1])) << 8)\ +(uint32_t)(((const uint8_t *)(d))[0]) ) #endif void d_sfh(uchar *s, int len) { uint32_t h = len, tmp; int rem; rem = len & 3; len >>= 2; for ( ; len > 0; len--) { h += get16bits(s); tmp = (get16bits(s+2) << 11) ^ h; h = (h << 16) ^ tmp; s += 2*sizeof(uint16_t); h += h >> 11; } switch (rem) { case 3: h += get16bits(s); h ^= h << 16; h ^= s[sizeof(uint16_t)] << 18; h += h >> 11; break; case 2: h += get16bits(s); h ^= h << 11; h += h >> 17; break; case 1: h += *s; h ^= h << 10; h += h >> 1; break; } h ^= h << 3; h += h >> 5; h ^= h << 4; h += h >> 17; h ^= h << 25; h += h >> 6; K1 = h; } #if WS>4 /* 64-bit Jenkins hash, 1997 * http://burtleburtle.net/bob/c/lookup8.c */ #define mix(a,b,c) \ { a -= b; a -= c; a ^= (c>>43); \ b -= c; b -= a; b ^= (a<<9); \ c -= a; c -= b; c ^= (b>>8); \ a -= b; a -= c; a ^= (c>>38); \ b -= c; b -= a; b ^= (a<<23); \ c -= a; c -= b; c ^= (b>>5); \ a -= b; a -= c; a ^= (c>>35); \ b -= c; b -= a; b ^= (a<<49); \ c -= a; c -= b; c ^= (b>>11); \ a -= b; a -= c; a ^= (c>>12); \ b -= c; b -= a; b ^= (a<<18); \ c -= a; c -= b; c ^= (b>>22); \ } #else /* 32-bit Jenkins hash, 2006 * http://burtleburtle.net/bob/c/lookup3.c */ #define rot(x,k) (((x)<<(k))|((x)>>(32-(k)))) #define mix(a,b,c) \ { a -= c; a ^= rot(c, 4); c += b; \ b -= a; b ^= rot(a, 6); a += c; \ c -= b; c ^= rot(b, 8); b += a; \ a -= c; a ^= rot(c,16); c += b; \ b -= a; b ^= rot(a,19); a += c; \ c -= b; c ^= rot(b, 4); b += a; \ } #define final(a,b,c) \ { c ^= b; c -= rot(b,14); \ a ^= c; a -= rot(c,11); \ b ^= a; b -= rot(a,25); \ c ^= b; c -= rot(b,16); \ a ^= c; a -= rot(c,4); \ b ^= a; b -= rot(a,14); \ c ^= b; c -= rot(b,24); \ } #endif void d_hash(uchar *kb, int nbytes) { uint8_t *bp; #if WS>4 uint64_t a = 0, b, c, n; const uint64_t *k = (uint64_t *) kb; #else uint32_t a = 0, b, c, n; const uint32_t *k = (uint32_t *) kb; #endif n = nbytes/WS; /* nr of words */ /* extend to multiple of words, if needed */ a = WS - (nbytes % WS); if (a > 0 && a < WS) { n++; bp = kb + nbytes; switch (a) { #if WS>4 case 7: *bp++ = 0; /* fall thru */ case 6: *bp++ = 0; /* fall thru */ case 5: *bp++ = 0; /* fall thru */ case 4: *bp++ = 0; /* fall thru */ #endif case 3: *bp++ = 0; /* fall thru */ case 2: *bp++ = 0; /* fall thru */ case 1: *bp = 0; case 0: break; } } #if WS>4 b = HASH_CONST[HASH_NR]; c = 0x9e3779b97f4a7c13LL; /* arbitrary value */ while (n >= 3) { a += k[0]; b += k[1]; c += k[2]; mix(a,b,c); n -= 3; k += 3; } c += (((uint64_t) nbytes)<<3); switch (n) { case 2: b += k[1]; case 1: a += k[0]; case 0: break; } mix(a,b,c); #else a = c = 0xdeadbeef + (n<<2); b = HASH_CONST[HASH_NR]; while (n > 3) { a += k[0]; b += k[1]; c += k[2]; mix(a,b,c); n -= 3; k += 3; } switch (n) { case 3: c += k[2]; case 2: b += k[1]; case 1: a += k[0]; final(a,b,c); case 0: break; } #endif j1_spin = c&nmask; j3_spin = a&7; /* 1st bit */ j2_spin = b&nmask; j4_spin = (a>>3)&7; /* 2nd bit */ K1 = c; K2 = b; } #if defined(MURMUR) && (WS==8) /* public-domain, 64-bit MurmurHash3, by Austin Appleby */ /* https://code.google.com/p/smhasher/wiki/MurmurHash3 */ void m_hash(uchar *v, int len) { uint8_t *bp, *data = (uint8_t*) v; int i, nblocks = len / 16; uint64_t h1 = HASH_CONST[HASH_NR]; uint64_t h2 = 0x9e3779b97f4a7c13LL; uint64_t c1 = 0x87c37b91114253d5; uint64_t c2 = 0x4cf5ad432745937f; uint64_t *blocks = (uint64_t *)(data); /* guarantee a multiple of 16 bytes */ i = 16 - (len % 16); if (i > 0 && i < 16) { nblocks++; bp = v + len; switch (i) { case 15: *bp++ = 0; /* fall thru */ case 14: *bp++ = 0; case 13: *bp++ = 0; case 12: *bp++ = 0; case 11: *bp++ = 0; case 10: *bp++ = 0; case 9: *bp++ = 0; case 8: *bp++ = 0; case 7: *bp++ = 0; case 6: *bp++ = 0; case 5: *bp++ = 0; case 4: *bp++ = 0; case 3: *bp++ = 0; case 2: *bp++ = 0; case 1: *bp = 0; case 0: break; } } for (i = 0; i < nblocks; i++) { uint64_t k1 = blocks[i*2]; uint64_t k2 = blocks[i*2+1]; k1 *= c1; k1 = (k1 << 31) | (k1 >> 33); k1 *= c2; h1 ^= k1; h1 = (h1 << 27) | (h1 >> 37); h1 += h2; h1 = h1 * 5 + 0x52dce729; k2 *= c2; k2 = (k2 << 33) | (k2 >> 31); k2 *= c1; h2 ^= k2; h2 = (h2 << 31) | (h2 >> 33); h2 += h1; h2 = h2 * 5 + 0x38495ab5; } uint8_t *tail = (uint8_t*)(data + (nblocks * 16)); uint64_t k1 = 0; uint64_t k2 = 0; switch(len & 15) { case 15: k2 ^= ((uint64_t) tail[14]) << 48; break; case 14: k2 ^= ((uint64_t) tail[13]) << 40; break; case 13: k2 ^= ((uint64_t) tail[12]) << 32; break; case 12: k2 ^= ((uint64_t) tail[11]) << 24; break; case 11: k2 ^= ((uint64_t) tail[10]) << 16; break; case 10: k2 ^= ((uint64_t) tail[ 9]) << 8; break; case 9: k2 ^= ((uint64_t) tail[ 8]) << 0; break; k2 *= c2; k2 = (k2 << 33) | (k2 >> 31); k2 *= c1; h2 ^= k2; break; case 8: k1 ^= ((uint64_t) tail[7]) << 56; break; case 7: k1 ^= ((uint64_t) tail[6]) << 48; break; case 6: k1 ^= ((uint64_t) tail[5]) << 40; break; case 5: k1 ^= ((uint64_t) tail[4]) << 32; break; case 4: k1 ^= ((uint64_t) tail[3]) << 24; break; case 3: k1 ^= ((uint64_t) tail[2]) << 16; break; case 2: k1 ^= ((uint64_t) tail[1]) << 8; break; case 1: k1 ^= ((uint64_t) tail[0]) << 0; break; k1 *= c1; k1 = (k1 << 31) | (k1 >> 33); k1 *= c2; h1 ^= k1; }; h1 ^= len; h2 ^= len; h1 += h2; h2 += h1; h1 ^= h1 >> 33; h1 *= 0xff51afd7ed558ccd; h1 ^= h1 >> 33; h1 *= 0xc4ceb9fe1a85ec53; h1 ^= h1 >> 33; h2 ^= h2 >> 33; h2 *= 0xff51afd7ed558ccd; h2 ^= h2 >> 33; h2 *= 0xc4ceb9fe1a85ec53; h2 ^= h2 >> 33; h1 += h2; h2 += h1; j1_spin = h1&nmask; j3_spin = (h1>>48)&7; j2_spin = h2&nmask; j4_spin = (h2>>48)&7; K1 = h1; K2 = h2; } #endif void s_hash(uchar *cp, int om) { hasher(cp, om); /* sets K1 */ #ifdef BITSTATE if (S_Tab == H_tab) j1_spin = K1 % omaxdepth; else #endif if (ssize < 8*WS) j1_spin = K1&mask; else j1_spin = K1; } #ifndef RANDSTOR int *prerand; void inirand(void) { int i; srand(s_rand+HASH_NR); prerand = (int *) emalloc((omaxdepth+3)*sizeof(int)); for (i = 0; i < omaxdepth+3; i++) { prerand[i] = rand(); } } int pan_rand(void) { if (!prerand) inirand(); return prerand[depth]; } #endif void set_masks(void) { if (WS == 4 && ssize >= 32) { mask = 0xffffffff; #ifdef BITSTATE switch (ssize) { case 34: nmask = (mask>>1); break; case 33: nmask = (mask>>2); break; default: nmask = (mask>>3); break; } #else nmask = mask; #endif } else if (WS == 8) { mask = ((ONE_L<>3; #else nmask = mask; #endif } else if (WS != 4) { fprintf(stderr, "pan: wordsize %ld not supported\n", (long int) WS); exit(1); } else /* WS == 4 and ssize < 32 */ { mask = ((ONE_L<>3); } } #if defined(AUTO_RESIZE) && !defined(BITSTATE) && !defined(MA) #if NCORE>1 #error cannot combine AUTO_RESIZE with NCORE>1 #endif static long reclaim_size; static char *reclaim_mem; static H_el **N_tab; void reverse_capture(H_el *p) { if (!p) return; reverse_capture(p->nxt); /* last element of list moves first */ /* to preserve list-order */ j2_spin = p->m_K1; if (ssize < 8*WS) /* probably always true */ { j2_spin &= mask; } p->nxt = N_tab[j2_spin]; N_tab[j2_spin] = p; } void resize_hashtable(void) { #ifndef BFS_PAR if (WS == 4 && ssize >= 27 - 1) #endif { return; /* cannot increase further */ } ssize += 2; /* 4x size @htable ssize */ printf("pan: resizing hashtable to -w%d.. ", ssize); N_tab = (H_el **) emalloc((ONE_L<1 int find_claim(char *s) { int i, j; for (i = 0; strncmp(procname[i], ":np_:", 5) != 0; i++) { if (strcmp(s, procname[i]) == 0) { for (j = 0; j < NCLAIMS; j++) { if (spin_c_typ[j] == i) { return j; } } break; } } printf("pan: error: cannot find claim '%s'\n", s); exit(1); return -1; /* unreachable */ } #endif #if defined(BFS_PAR) && defined(BFS_SEP_HASH) int /* to avoid having to include and compile with -lm */ blog2(int n) /* n >= 1 */ { int m=1, r=2; if (n == 1) { return 0; } if (n == 2) { return 1; } while (n > r) { m++; r *= 2; } return m; } #endif uint pp[33]; uint mul(uint a, uint b, uint p) { int c = 0; while (a) { if (a&1) { a ^= 1; c ^= b; } a = (a>>1); if (b & 0x80000000) { b += b; b ^= p; } else { b += b; } } return c; } uint ppow(int n, uint p) { uint t = 1; int i; for (i = 0; i < 32; i++) { if (n & (1<0) s_rand = T_RAND; #elif defined(P_RAND) && (P_RAND>0) s_rand = P_RAND; #endif #ifdef PUTPID { char *ptr = strrchr(argv[0], '/'); if (ptr == NULL) { ptr = argv[0]; } else { ptr++; } progname = emalloc(strlen(ptr)); strcpy(progname, ptr); /* printf("progname: %s\n", progname); */ } #endif #ifdef BITSTATE b_store = bstore_reg; /* default */ #endif #if NCORE>1 { int i, j; strcpy(o_cmdline, ""); for (j = 1; j < argc; j++) { strcat(o_cmdline, argv[j]); strcat(o_cmdline, " "); } /* printf("Command Line: %s\n", o_cmdline); */ if (strlen(o_cmdline) >= sizeof(o_cmdline)) { Uerror("option list too long"); } } #endif while (argc > 1 && argv[1][0] == '-') { switch (argv[1][1]) { #ifndef SAFETY #ifdef NP case 'a': fprintf(efd, "warning: -a is disabled by -DNP, ignored"); break; #else case 'a': a_cycles = 1; break; #endif #else #if defined(BFS_PAR) && defined(L_BOUND) case 'a': if (isdigit(argv[1][2])) { L_bound = atoi(&argv[1][2]); if (L_bound < 1 || L_bound > 255) { printf("usage: -aN with 00 case 'C': coltrace = 1; goto samething; #endif #endif case 'c': upto = atoi(&argv[1][2]); break; case 'D': dodot++; state_tables++; break; case 'd': state_tables++; break; case 'e': every_error = 1; upto = 0; Nr_Trails = 1; break; case 'E': noends = 1; break; #ifdef SC case 'F': if (strlen(argv[1]) > 2) stackfile = &argv[1][2]; break; #endif #if !defined(SAFETY) && !defined(NOFAIR) case 'f': fairness = 1; break; #endif #ifdef HAS_CODE #if HAS_CODE>0 case 'g': gui = 1; goto samething; #endif #endif case 'h': if (strncmp(&argv[1][1], "hash", strlen("hash")) == 0) { do_hashgen = 1; break; } if (!argv[1][2] || !isdigit((int) argv[1][2])) { usage(efd); /* exits */ } HASH_NR = atoi(&argv[1][2])%(sizeof(HASH_CONST)/sizeof(uint)); break; case 'I': iterative = 2; every_error = 1; break; case 'i': if (strncmp(&argv[1][1], "i_reverse", strlen("i_reverse")) == 0) { reversing |= 1; } else { iterative = 1; every_error = 1; } break; case 'J': like_java = 1; break; /* Klaus Havelund */ #ifdef BITSTATE case 'k': hfns = atoi(&argv[1][2]); break; #endif #ifdef BCS case 'L': sched_max = atoi(&argv[1][2]); if (sched_max > 255) /* stored as one byte */ { fprintf(efd, "warning: using max bound (255)\n"); sched_max = 255; } #ifndef NOREDUCE if (sched_max == 0) { fprintf(efd, "warning: with (default) bound -L0, "); fprintf(efd, "using -DNOREDUCE performs better\n"); } #endif break; #endif #ifndef SAFETY #ifdef NP case 'l': a_cycles = 1; break; #else case 'l': fprintf(efd, "error: -l not available (compile with -DNP)"); usage(efd); break; #endif #endif #ifdef BITSTATE case 'M': udmem = atoi(&argv[1][2]); break; case 'G': udmem = atoi(&argv[1][2]); udmem *= 1024; break; #else case 'M': case 'G': fprintf(stderr, "-M and -G affect only -DBITSTATE\n"); break; #endif case 'm': maxdepth = atoi(&argv[1][2]); break; #ifndef NOCLAIM case 'N': #if NCLAIMS>1 if (isdigit((int)argv[1][2])) { whichclaim = atoi(&argv[1][2]); } else if (isalpha((int)argv[1][2])) { claimname = &argv[1][2]; } else if (argc > 2 && argv[2][0] != '-') /* check next arg */ { claimname = argv[2]; argc--; argv++; /* skip next arg */ } #else #if NCLAIMS==1 fprintf(stderr, "warning: only one claim defined, -N ignored\n"); #else fprintf(stderr, "warning: no claims defined, -N ignored\n"); #endif if (!isdigit((int)argv[1][2]) && argc > 2 && argv[2][0] != '-') { argc--; argv++; } #endif #endif break; case 'n': no_rck = 1; break; case 'P': if (!readtrail && isdigit((int) argv[1][2])) { int x = atoi(&argv[1][2]); if (x != 0 && x != 1) { fprintf(efd, "pan: bad option -P[01], ignored\n"); } if (x == 0) { reversing &= ~1; break; } if (x == 1) { reversing |= 1; break; } if (verbose) fprintf(efd, "pan: reversed *active* process creation %s\n", reversing&1?"on":"off"); break; } /* else */ #ifdef HAS_CODE #if HAS_CODE>0 readtrail = 1; onlyproc = atoi(&argv[1][2]); if (argc > 2 && argv[2][0] != '-') /* check next arg */ { trailfilename = argv[2]; argc--; argv++; /* skip next arg */ } #else fprintf(efd, "pan: option -P not recognized, ignored\n"); #endif #else fprintf(efd, "pan: option -P not recognized, ignored\n"); #endif break; case 'p': #if !defined(BFS) && !defined(BFS_PAR) #ifdef PERMUTED if (strncmp(&argv[1][1], "p_normal", strlen("p_normal")) == 0) { reversing &= ~2; break; } reversing |=2; if (strncmp(&argv[1][1], "p_permute", strlen("p_permute")) == 0) { p_reorder = set_permuted; break; } if (strncmp(&argv[1][1], "p_rotate", strlen("p_rotate")) == 0) { p_reorder = set_rotated; if (isdigit((int) argv[1][9])) { p_rotate = atoi(&argv[1][9]); } else { p_rotate = 1; } break; } if (strncmp(&argv[1][1], "p_randrot", strlen("p_randrot")) == 0) { p_reorder = set_randrot; break; } if (strncmp(&argv[1][1], "p_reverse", strlen("p_reverse")) == 0) { p_reorder = set_reversed; break; } #else if (strncmp(&argv[1][1], "p_permute", strlen("p_permute")) == 0 || strncmp(&argv[1][1], "p_rotate", strlen("p_rotate")) == 0 || strncmp(&argv[1][1], "p_randrot", strlen("p_randrot")) == 0 || strncmp(&argv[1][1], "p_reverse", strlen("p_reverse")) == 0) { fprintf(efd, "option %s required compilation with -DPERMUTED\n", argv[1]); exit(1); } #endif #endif #ifdef SVDUMP vprefix = atoi(&argv[1][2]); #else fprintf(efd, "invalid option '%s' -- ignored\n", argv[1]); #endif break; #if NCORE==1 case 'Q': quota = (double) 60.0 * (double) atoi(&argv[1][2]); #ifndef FREQ freq /= 10.; /* for better resolution */ #endif break; #endif case 'q': strict = 1; break; case 'R': if (argv[1][2] == 'S') /* e.g., -RS76842 */ { s_rand = atoi(&argv[1][3]); break; } #ifdef BITSTATE Nrun = atoi(&argv[1][2]); if (Nrun > 100) { Nrun = 100; } else if (Nrun < 1) { Nrun = 1; } #else usage(efd); break; #endif case 'r': if (strncmp(&argv[1][1], "rhash", strlen("rhash")) == 0) { if (s_rand == 12345) /* default seed */ { #if defined(WIN32) || defined(WIN64) s_rand = (uint) clock(); #else struct tms dummy_tm; s_rand = (uint) times(&dummy_tm); #endif } srand(s_rand++); #ifdef PERMUTED do_hashgen = 1; switch (rand()%5) { case 0: p_reorder = set_permuted; reversing |=2; break; case 1: p_reorder = set_reversed; reversing |=2; break; /* fully randomize p_rotate: */ case 2: p_reorder = set_randrot; reversing |=2; break; /* choose once, then keep p_rotate fixed: */ case 3: p_reorder = set_rotated; p_rotate = rand()%3; reversing |=2; break; default: /* standard search */ break; } if (rand()%2 == 0) { t_reverse = 1; } break; #else fprintf(efd, "option -rhash requires compilation with -DPERMUTED\n"); exit(1); #endif } #if defined(HAS_CODE) && HAS_CODE>0 samething: readtrail = 1; if (isdigit((int)argv[1][2])) whichtrail = atoi(&argv[1][2]); else if (argc > 2 && argv[2][0] != '-') /* check next arg */ { trailfilename = argv[2]; argc--; argv++; /* skip next arg */ } break; case 'S': silent = 1; goto samething; #else fprintf(efd, "options -r is for models with embedded C code\n"); break; #endif case 'T': if (isdigit((int) argv[1][2])) { t_reverse = atoi(&argv[1][2]); if (verbose) printf("pan: reverse transition ordering %s\n", t_reverse?"on":"off"); break; } TMODE = 0444; break; case 't': if (strncmp(&argv[1][1], "t_reverse", strlen("t_reverse")) == 0) { t_reverse = 1; break; } if (argv[1][2]) { tprefix = &argv[1][2]; } break; case 'u': #ifdef BFS_PAR ncores = atoi(&argv[1][2]); #endif break; case 'V': start_timer(); printf("Generated by %s\n", SpinVersion); to_compile(); pan_exit(2); break; case 'v': verbose++; break; case 'w': ssize = atoi(&argv[1][2]); #if defined(BFS_PAR) && defined(BFS_SEP_HASH) used_w = 1; #endif break; case 'Y': signoff = 1; break; case 'X': efd = stdout; break; case 'x': exclusive = 1; break; #if NCORE>1 /* -B ip is passthru to proxy of remote ip address: */ case 'B': argc--; argv++; break; case 'Q': worker_pids[0] = atoi(&argv[1][2]); break; /* -Un means that the nth worker should be instantiated as a proxy */ case 'U': proxy_pid = atoi(&argv[1][2]); break; /* -W means this copy is started by a cluster-server as a remote */ /* this flag is passed to ./pan_proxy, which interprets it */ case 'W': remote_party++; break; case 'Z': core_id = atoi(&argv[1][2]); if (verbose) { printf("cpu%d: pid %d parent %d\n", core_id, getpid(), worker_pids[0]); } break; case 'z': z_handoff = atoi(&argv[1][2]); break; #else case 'z': break; /* ignored for single-core */ #endif default : fprintf(efd, "saw option -%c\n", argv[1][1]); usage(efd); break; } argc--; argv++; } #if defined(BFS_PAR) && defined(BFS_SEP_HASH) if (used_w == 0) { if (ncores == 0) /* all cores used, by default */ { ssize -= blog2(BFS_MAXPROCS - 1); } else { ssize -= blog2(ncores); } } #endif if (do_hashgen) { hashgen(); } #ifndef SAFETY if (fairness && !a_cycles) { fprintf(efd, "error: -f requires the use of -a or -l\n"); usage(efd); } #if ACCEPT_LAB==0 if (a_cycles) { fprintf(efd, "warning: no accept labels are defined, "); fprintf(efd, "so option -a has no effect (ignored)\n"); a_cycles = 0; } #endif #endif #ifdef BFS_PAR uerror = bfs_uerror; Uerror = bfs_Uerror; #else uerror = dfs_uerror; Uerror = dfs_Uerror; #endif if (ssize <= 32) /* 6.2.0 */ { hasher = d_sfh; #if !defined(BITSTATE) && defined(USE_TDH) o_hash = o_hash32; #endif } else { hasher = d_hash; #if !defined(BITSTATE) && defined(USE_TDH) o_hash = o_hash64; #endif } if (iterative && TMODE != 0666) { TMODE = 0666; fprintf(efd, "warning: -T ignored when -i or -I is used\n"); } #if defined(WIN32) || defined(WIN64) #ifndef _S_IWRITE #define S_IWRITE 0000200 /* write permission, owner */ #endif #ifndef _S_IREAD #define S_IREAD 0000400 /* read permission, owner */ #endif if (TMODE == 0666) TMODE = S_IWRITE | S_IREAD; else TMODE = S_IREAD; #endif #if NCORE>1 store_proxy_pid = proxy_pid; /* for checks in mem_file() and someone_crashed() */ if (core_id != 0) { proxy_pid = 0; } #ifndef SEP_STATE if (core_id == 0 && a_cycles) { fprintf(efd, "hint: this search may be more efficient "); fprintf(efd, "if pan.c is compiled -DSEP_STATE\n"); } #endif if (z_handoff < 0) { z_handoff = 20; /* conservative default - for non-liveness checks */ } #if defined(NGQ) || defined(LWQ_FIXED) LWQ_SIZE = (double) (128.*1048576.); #else LWQ_SIZE = (double) ( z_handoff + 2.) * (double) sizeof(SM_frame); #endif #if NCORE>2 if (a_cycles) { fprintf(efd, "warning: the intended nr of cores to be used in liveness mode is 2\n"); #ifndef SEP_STATE fprintf(efd, "warning: without -DSEP_STATE there is no guarantee that all liveness violations are found\n"); #endif } #endif #ifdef HAS_HIDDEN #error cannot use hidden variables when compiling multi-core #endif #endif #if defined(T_RAND) && defined(ELSE_IN_GUARD) #error cannot hide 'else' as guard in d_step, when using -DT_RAND #endif #ifdef BITSTATE if (hfns <= 0) { hfns = 1; fprintf(efd, "warning: using -k%d as minimal usable value\n", hfns); } #endif omaxdepth = maxdepth; #ifdef BITSTATE if (WS == 4 && ssize > 34) { ssize = 34; fprintf(efd, "warning: using -w%d as max usable value\n", ssize); /* * -w35 would not work: 35-3 = 32 but 1^31 is the largest * power of 2 that can be represented in an ulong */ } #else if (WS == 4 && ssize > 27) { ssize = 27; fprintf(efd, "warning: using -w%d as max usable value\n", ssize); /* * for emalloc, the lookup table size multiplies by 4 for the pointers * the largest power of 2 that can be represented in a ulong is 1^31 * hence the largest number of lookup table slots is 31-4 = 27 */ } #endif #ifdef SC hiwater = HHH = maxdepth-10; DDD = HHH/2; if (!stackfile) { stackfile = (char *) emalloc(strlen(PanSource)+4+1); sprintf(stackfile, "%s._s_", PanSource); } if (iterative) { fprintf(efd, "error: cannot use -i or -I with -DSC\n"); pan_exit(1); } #endif #if (defined(R_XPT) || defined(W_XPT)) && !defined(MA) #warning -DR_XPT and -DW_XPT assume -DMA (ignored) #endif if (iterative && a_cycles) fprintf(efd, "warning: -i or -I work for safety properties only\n"); #ifdef BFS #ifdef SC #error -DBFS not compatible with -DSC #endif #ifdef HAS_LAST #error -DBFS not compatible with _last #endif #ifdef HAS_STACK #error cannot use c_track UnMatched with BFS #endif #ifdef BCS #error -DBFS not compatible with -DBCS #endif #ifdef REACH #warning -DREACH is redundant when -DBFS is used #endif #endif #ifdef TRIX #ifdef BITSTATE #error cannot combine -DTRIX and -DBITSTATE #endif #ifdef COLLAPSE #error cannot combine -DTRIX and -DCOLLAPSE #endif #ifdef MA #error cannot combine -DTRIX and -DMA #endif #if defined(BFS_PAR) && defined(BFS_SEP_HEAP) #error cannot combined -DBFS_SEP_HEAP with -DTRIX #endif #endif #ifdef BFS_PAR #ifdef NP #error cannot combine -DBFS_PAR and -DNP #undef NP #endif #endif #ifdef BCS #ifdef P_RAND #error cannot combine -DBCS and -DP_RAND #endif #ifdef BFS #error cannot combine -DBCS and -DBFS #endif #endif #if defined(MERGED) && defined(PEG) #error to use -DPEG use: spin -o3 -a #endif #if defined(HC) && !defined(BFS_PAR) #ifdef NOCOMP #error cannot combine -DHC and -DNOCOMP #endif #ifdef BITSTATE #error cannot combine -DHC and -DBITSTATE #endif #endif #if defined(SAFETY) && defined(NP) #error cannot combine -DNP and -DBFS or -DSAFETY #endif #ifdef MA #ifdef BITSTATE #error cannot combine -DMA and -DBITSTATE #endif #if MA <= 0 #error usage: -DMA=N with N > 0 and N < VECTORSZ #endif #endif #ifdef COLLAPSE #ifdef BITSTATE #error cannot combine -DBITSTATE and -DCOLLAPSE #endif #ifdef NOCOMP #error cannot combine -DCOLLAPSE and -DNOCOMP #endif #endif if (maxdepth <= 0 || ssize <= 1) usage(efd); #if SYNC>0 && !defined(NOREDUCE) if (a_cycles && fairness) { fprintf(efd, "error: p.o. reduction not compatible with "); fprintf(efd, "fairness (-f) in models\n"); fprintf(efd, " with rendezvous operations: "); fprintf(efd, "recompile with -DNOREDUCE\n"); pan_exit(1); } #endif #if defined(REM_VARS) && !defined(NOREDUCE) #warning p.o. reduction not compatible with remote varrefs (use -DNOREDUCE) #endif #if defined(NOCOMP) && !defined(BITSTATE) if (a_cycles) { fprintf(efd, "error: use of -DNOCOMP voids -l and -a\n"); pan_exit(1); } #endif #ifdef MEMLIM memlim = ((double) MEMLIM) * (double) (1<<20); /* size in Mbyte */ #endif #if SYNC>0 #ifdef HAS_PRIORITY #error use of priorities cannot be combined with rendezvous #elif HAS_ENABLED #error use of enabled() cannot be combined with rendezvous #endif #endif #ifndef NOREDUCE #ifdef HAS_PRIORITY #warning use of priorities requires -DNOREDUCE #elif HAS_ENABLED #error use of enabled() requires -DNOREDUCE #endif #ifdef HAS_PCVALUE #error use of pcvalue() requires -DNOREDUCE #endif #ifdef HAS_BADELSE #error use of 'else' combined with i/o stmnts requires -DNOREDUCE #endif #if defined(HAS_LAST) && !defined(BCS) #error use of _last requires -DNOREDUCE #endif #endif #if SYNC>0 && !defined(NOREDUCE) #ifdef HAS_UNLESS fprintf(efd, "warning: use of a rendezvous stmnts in the escape\n"); fprintf(efd, " of an unless clause, if present, could make p.o. reduction\n"); fprintf(efd, " invalid (use -DNOREDUCE to avoid this)\n"); #ifdef BFS fprintf(efd, " (this type of rv is also not compatible with -DBFS)\n"); #endif #endif #endif #if SYNC>0 && defined(BFS) if (!noends) fprintf(efd, "warning: use of rendezvous with BFS does not preserve all invalid endstates\n"); #endif #if !defined(REACH) && !defined(BITSTATE) if (iterative != 0 && a_cycles == 0) { fprintf(efd, "warning: -i and -I need -DREACH to work accurately\n"); } #endif #if defined(BITSTATE) && defined(REACH) #warning -DREACH is voided by -DBITSTATE #endif #if defined(MA) && defined(REACH) #warning -DREACH is voided by -DMA #endif #if defined(FULLSTACK) && defined(CNTRSTACK) #error cannot combine -DFULLSTACK and -DCNTRSTACK #endif #if defined(VERI) #if ACCEPT_LAB>0 #ifndef BFS if (!a_cycles #ifdef HAS_CODE && !readtrail #endif #if NCORE>1 && core_id == 0 #endif && !state_tables) { fprintf(efd, "warning: never claim + accept labels "); fprintf(efd, "requires -a flag to fully verify\n"); } #else if (verbose && !state_tables #ifdef HAS_CODE && !readtrail #endif ) { fprintf(efd, "warning: verification in BFS mode "); fprintf(efd, "is restricted to safety properties\n"); } #endif #endif #endif #ifndef SAFETY #if 0 if (!a_cycles #ifdef HAS_CODE && !readtrail #endif #if NCORE>1 && core_id == 0 #endif && !state_tables) { fprintf(efd, "hint: this search is more efficient "); fprintf(efd, "if pan.c is compiled -DSAFETY\n"); } #endif #ifndef NOCOMP if (!a_cycles) { S_A = 0; } else { if (!fairness) { S_A = 1; /* _a_t */ #ifndef NOFAIR } else /* _a_t and _cnt[NFAIR] */ { S_A = (&(now._cnt[0]) - (uchar *) &now) + NFAIR - 2; /* -2 because first two uchars in now are masked */ #endif } } #endif #endif signal(SIGINT, stopped); set_masks(); #if defined(BFS) || defined(BFS_PAR) trail = (Trail *) emalloc(6*sizeof(Trail)); trail += 3; #else trail = (Trail *) emalloc((maxdepth+3)*sizeof(Trail)); trail++; /* protect trpt-1 refs at depth 0 */ #endif trpt = &trail[0]; /* precaution -- in case uerror is called early */ #ifdef BFS ntrpt = trpt; #endif #ifdef SVDUMP if (vprefix > 0) { char nm[64]; sprintf(nm, "%s.svd", PanSource); if ((svfd = creat(nm, TMODE)) < 0) { fprintf(efd, "couldn't create %s\n", nm); vprefix = 0; } } #endif #ifdef RANDSTOR srand(s_rand+HASH_NR); #endif #if SYNC>0 && ASYNC==0 set_recvs(); #endif run(); done = 1; wrapup(); return 0; } void usage(FILE *fd) { fprintf(fd, "%s\n", SpinVersion); fprintf(fd, "Valid Options are:\n"); #ifndef SAFETY #ifdef NP fprintf(fd, " -a -> is disabled by -DNP "); fprintf(fd, "(-DNP compiles for -l only)\n"); #else fprintf(fd, " -a find acceptance cycles\n"); #endif #else fprintf(fd, " -a,-l,-f -> are disabled by -DSAFETY\n"); #endif fprintf(fd, " -A ignore assert() violations\n"); fprintf(fd, " -b consider it an error to exceed the depth-limit\n"); fprintf(fd, " -cN stop at Nth error "); fprintf(fd, "(defaults to -c1)\n"); fprintf(fd, " -D print state tables in dot-format and stop\n"); fprintf(fd, " -d print state tables and stop\n"); fprintf(fd, " -e create trails for all errors\n"); fprintf(fd, " -E ignore invalid end states\n"); #ifdef SC fprintf(fd, " -Ffile use 'file' to store disk-stack\n"); #endif #ifndef NOFAIR fprintf(fd, " -f add weak fairness (to -a or -l)\n"); #endif fprintf(fd, " -hN use different hash-seed N:0..499 (defaults to -h0)\n"); fprintf(fd, " -hash generate a random hash-polynomial for -h0 (see also -rhash)\n"); fprintf(fd, " using a seed set with -RSn (default %u)\n", s_rand); fprintf(fd, " -i search for shortest path to error\n"); fprintf(fd, " -I like -i, but approximate and faster\n"); fprintf(fd, " -J reverse eval order of nested unlesses\n"); #ifdef BITSTATE fprintf(fd, " -kN set N bits per state (defaults to 3)\n"); #endif #ifdef BCS fprintf(fd, " -LN set scheduling restriction to N (default 0)\n"); #endif #ifndef SAFETY #ifdef NP fprintf(fd, " -l find non-progress cycles\n"); #else fprintf(fd, " -l find non-progress cycles -> "); fprintf(fd, "disabled, requires "); fprintf(fd, "compilation with -DNP\n"); #endif #endif #ifdef BITSTATE fprintf(fd, " -MN use N Megabytes for bitstate hash array\n"); fprintf(fd, " -GN use N Gigabytes for bitstate hash array\n"); #endif fprintf(fd, " -mN max depth N steps (default=10k)\n"); #if NCLAIMS>1 fprintf(fd, " -N cn -- use the claim named cn\n"); fprintf(fd, " -Nn -- use claim number n\n"); #endif fprintf(fd, " -n no listing of unreached states\n"); #ifdef PERMUTED fprintf(fd, " -p_permute randomize order in which processes are scheduled (see also -rhash)\n"); fprintf(fd, " -p_reverse reverse order in which processes are scheduled (see also -rhash)\n"); fprintf(fd, " -p_rotateN rotate by N the process scheduling order (see also -rhash)\n"); #endif #ifdef SVDUMP fprintf(fd, " -pN create svfile (save N bytes per state)\n"); #endif fprintf(fd, " -QN set time-limit on execution of N minutes\n"); fprintf(fd, " -q require empty chans in valid end states\n"); #ifdef HAS_CODE fprintf(fd, " -r read and execute trail - can add -v,-n,-PN,-g,-C\n"); fprintf(fd, " -r trailfilename read and execute trail in file\n"); fprintf(fd, " -rN read and execute N-th error trail\n"); fprintf(fd, " -C read and execute trail - columnated output (can add -v,-n)\n"); fprintf(fd, " -r -PN read and execute trail - restrict trail output to proc N\n"); fprintf(fd, " -g read and execute trail + msc gui support\n"); fprintf(fd, " -S silent replay: only user defined printfs show\n"); #endif fprintf(fd, " -RSn use randomization seed n\n"); fprintf(fd, " -rhash use random hash-polynomial and randomly choose -p_rotateN, -p_permute, or p_reverse\n"); #ifdef BITSTATE fprintf(fd, " -Rn run n times n: [1..100] using n "); fprintf(fd, " different hash functions\n"); #endif fprintf(fd, " -T create trail files in read-only mode\n"); fprintf(fd, " -t_reverse reverse order in which transitions are explored\n"); fprintf(fd, " -tsuf replace .trail with .suf on trailfiles\n"); fprintf(fd, " -V print SPIN version number\n"); fprintf(fd, " -v verbose -- filenames in unreached state listing\n"); fprintf(fd, " -wN hashtable of 2^N entries "); fprintf(fd, "(defaults to -w%d)\n", ssize); fprintf(fd, " -x do not overwrite an existing trail file\n"); #if NCORE>1 fprintf(fd, " -zN handoff states below depth N to 2nd cpu (multi_core)\n"); #endif #ifdef HAS_CODE fprintf(fd, "\n options -r, -C, -PN, -g, and -S can optionally be followed by\n"); fprintf(fd, " a filename argument, as in '-r filename', naming the trailfile\n"); #endif #if NCORE>1 multi_usage(fd); #endif exit(1); } char * Malloc(ulong n) { char *tmp; #ifdef MEMLIM if (memcnt + (double) n > memlim) { printf("pan: reached -DMEMLIM bound\n"); goto err; } #endif tmp = (char *) malloc(n); if (!tmp) { #ifdef BFS_PAR Uerror("out of non-shared memory"); #endif printf("pan: out of memory\n"); #ifdef MEMLIM err: printf(" %g bytes used\n", memcnt); printf(" %g bytes more needed\n", (double) n); printf(" %g bytes limit\n", memlim); #endif #ifdef COLLAPSE printf("hint: to reduce memory, recompile with\n"); #ifndef MA printf(" -DMA=%d # better/slower compression, or\n", hmax); #endif printf(" -DBITSTATE # supertrace, approximation\n"); #else #ifndef BITSTATE printf("hint: to reduce memory, recompile with\n"); #ifndef HC printf(" -DCOLLAPSE # good, fast compression, or\n"); #ifndef MA printf(" -DMA=%d # better/slower compression, or\n", hmax); #endif printf(" -DHC # hash-compaction, approximation\n"); #endif printf(" -DBITSTATE # supertrace, approximation\n"); #endif #endif #if NCORE>1 #ifdef FULL_TRAIL printf(" omit -DFULL_TRAIL or use pan -c0 to reduce memory\n"); #endif #ifdef SEP_STATE printf("hint: to reduce memory, recompile without\n"); printf(" -DSEP_STATE # may be faster, but uses more memory\n"); #endif #endif wrapup(); } memcnt += (double) n; return tmp; } #define CHUNK (100*VECTORSZ) char * emalloc(ulong n) /* never released or reallocated */ { char *tmp; if (n == 0) return (char *) NULL; if (n&(sizeof(void *)-1)) /* for proper alignment */ n += sizeof(void *)-(n&(sizeof(void *)-1)); if ((ulong) left < n) { grow = (n < CHUNK) ? CHUNK : n; have = Malloc(grow); fragment += (double) left; left = grow; } tmp = have; have += (long) n; left -= (long) n; memset(tmp, 0, n); return tmp; } void dfs_Uerror(char *str) { /* always fatal */ uerror(str); #if NCORE>1 sudden_stop("Uerror"); #endif #ifdef BFS_PAR bfs_shutdown("Uerror"); #endif wrapup(); } #if defined(MA) && !defined(SAFETY) int Unwind(void) { Trans *t; uchar ot, _m; int tt; short II; #ifdef VERBOSE int i; #endif uchar oat = now._a_t; now._a_t &= ~(1|16|32); memcpy((char *) &comp_now, (char *) &now, vsize); now._a_t = oat; Up: #ifdef SC trpt = getframe(depth); #endif #ifdef VERBOSE printf("%ld State: ", depth); #if !defined(NOCOMP) && !defined(HC) for (i = 0; i < vsize; i++) printf("%d%s,", ((char *)&now)[i], Mask[i]?"*":""); #else for (i = 0; i < vsize; i++) printf("%d,", ((char *)&now)[i]); #endif printf("\n"); #endif #ifndef NOFAIR if (trpt->o_pm&128) /* fairness alg */ { now._cnt[now._a_t&1] = trpt->bup.oval; depth--; #ifdef SC trpt = getframe(depth); #else trpt--; #endif goto Q999; } #endif #ifdef HAS_LAST #ifdef VERI { long d; Trail *trl; now._last = 0; for (d = 1; d < depth; d++) { trl = getframe(depth-d); /* was trl = (trpt-d); */ if (trl->pr != 0) { now._last = trl->pr - BASE; break; } } } #else now._last = (depth<1)?0:(trpt-1)->pr; #endif #endif #ifdef EVENT_TRACE now._event = trpt->o_event; #endif if ((now._a_t&1) && depth <= A_depth) { now._a_t &= ~(1|16|32); if (fairness) now._a_t |= 2; /* ? */ A_depth = 0; goto CameFromHere; /* checkcycles() */ } t = trpt->o_t; ot = trpt->o_ot; II = trpt->pr; tt = trpt->o_tt; this = pptr(II); _m = do_reverse(t, II, trpt->o_m); #ifdef VERBOSE printf("%3ld: proc %d ", depth, II); printf("reverses %d, %d to %d,", t->forw, tt, t->st); printf(" %s [abit=%d,adepth=%ld,", t->tp, now._a_t, A_depth); printf("tau=%d,%d] \n", trpt->tau, (trpt-1)->tau); #endif depth--; #ifdef SC trpt = getframe(depth); #else trpt--; #endif /* reached[ot][t->st] = 1; 3.4.13 */ ((P0 *)this)->_p = tt; #ifndef NOFAIR if ((trpt->o_pm&32)) { #ifdef VERI if (now._cnt[now._a_t&1] == 0) now._cnt[now._a_t&1] = 1; #endif now._cnt[now._a_t&1] += 1; } Q999: if (trpt->o_pm&8) { now._a_t &= ~2; now._cnt[now._a_t&1] = 0; } if (trpt->o_pm&16) now._a_t |= 2; #endif CameFromHere: if (memcmp((char *) &now, (char *) &comp_now, vsize) == 0) return depth; if (depth > 0) goto Up; return 0; } #endif static char unwinding; void dfs_uerror(char *str) { static char laststr[256]; int is_cycle; if (unwinding) return; /* 1.4.2 */ if (strncmp(str, laststr, 254)) #if NCORE>1 cpu_printf("pan:%d: %s (at depth %ld)\n", errors+1, str, #else printf("pan:%d: %s (at depth %ld)\n", errors+1, str, #endif #if NCORE>1 (nr_handoffs * z_handoff) + #endif ((depthfound == -1)?depth:depthfound)); strncpy(laststr, str, 254); errors++; #ifdef HAS_CODE if (readtrail) { wrap_trail(); return; } #endif is_cycle = (strstr(str, " cycle") != (char *) 0); if (!is_cycle) { depth++; trpt++; } if ((every_error != 0) || errors == upto) { #if defined(MA) && !defined(SAFETY) if (is_cycle) { int od = depth; unwinding = 1; depthfound = Unwind(); unwinding = 0; depth = od; } #endif #if NCORE>1 writing_trail = 1; #endif #ifdef BFS if (depth > 1) trpt--; nuerror(); if (depth > 1) trpt++; #else putrail(); #endif #if defined(MA) && !defined(SAFETY) if (strstr(str, " cycle")) { if (every_error) printf("sorry: MA writes 1 trail max\n"); wrapup(); /* no recovery from unwind */ } #endif #if NCORE>1 if (search_terminated != NULL) { *search_terminated |= 4; /* uerror */ } writing_trail = 0; #endif } if (!is_cycle) { depth--; trpt--; /* undo */ } #ifndef BFS if (iterative != 0 && maxdepth > 0) { if (maxdepth > depth) { maxdepth = (iterative == 1)?(depth+1):(depth/2); } warned = 1; printf("pan: reducing search depth to %ld\n", maxdepth); } else #endif if (errors >= upto && upto != 0) { #ifdef BFS_PAR bfs_shutdown("uerror"); /* no return */ #endif #if NCORE>1 sudden_stop("uerror"); #endif wrapup(); } depthfound = -1; } int xrefsrc(int lno, S_F_MAP *mp, int M, int i) { Trans *T; int j, retval=1; for (T = trans[M][i]; T; T = T->nxt) if (T && T->tp) { if (strcmp(T->tp, ".(goto)") == 0 || strncmp(T->tp, "goto :", 6) == 0) return 1; /* not reported */ for (j = 0; j < sizeof(mp); j++) if (i >= mp[j].from && i <= mp[j].upto) { printf("\t%s:%d", mp[j].fnm, lno); break; } if (j >= sizeof(mp)) /* fnm not found in list */ { printf("\t%s:%d", PanSource, lno); /* use default */ } printf(", state %d", i); if (strcmp(T->tp, "") != 0) { char *q; q = transmognify(T->tp); printf(", \"%s\"", q?q:""); } else if (stopstate[M][i]) printf(", -end state-"); printf("\n"); retval = 0; /* reported */ } return retval; } void r_ck(uchar *which, int N, int M, short *src, S_F_MAP *mp) { int i, m=0; if ((enum btypes) Btypes[M] == N_CLAIM && claimname != NULL && strcmp(claimname, procname[M]) != 0) { return; } switch ((enum btypes) Btypes[M]) { case P_PROC: case A_PROC: printf("unreached in proctype %s\n", procname[M]); break; case I_PROC: printf("unreached in init\n"); break; case E_TRACE: case N_TRACE: case N_CLAIM: default: printf("unreached in claim %s\n", procname[M]); break; } for (i = 1; i < N; i++) { if (which[i] == 0 && (mapstate[M][i] == 0 || which[mapstate[M][i]] == 0)) { m += xrefsrc((int) src[i], mp, M, i); } else { m++; } } printf(" (%d of %d states)\n", N-1-m, N-1); } #if NCORE>1 && !defined(SEP_STATE) static long rev_trail_cnt; #ifdef FULL_TRAIL void rev_trail(int fd, volatile Stack_Tree *st_tr) { long j; char snap[64]; if (!st_tr) { return; } rev_trail(fd, st_tr->prv); #ifdef VERBOSE printf("%d (%d) LRT [%d,%d] -- %9u (root %9u)\n", depth, rev_trail_cnt, st_tr->pr, st_tr->t_id, st_tr, stack_last[core_id]); #endif if (st_tr->pr != 255) { sprintf(snap, "%ld:%d:%d\n", rev_trail_cnt++, st_tr->pr, st_tr->t_id); j = strlen(snap); if (write(fd, snap, j) != j) { printf("pan: error writing trailfile\n"); close(fd); wrapup(); return; } } else /* handoff point */ { if (a_cycles) { (void) write(fd, "-1:-1:-1\n", 9); } } } #endif #endif void putrail(void) { int fd; #if defined VERI || defined(MERGED) char snap[64]; #endif #if NCORE==1 || defined(SEP_STATE) || !defined(FULL_TRAIL) long i, j; Trail *trl; #endif fd = make_trail(); if (fd < 0) return; #ifdef VERI sprintf(snap, "-2:%d:-2\n", (uchar) ((P0 *)pptr(0))->_t); if (write(fd, snap, strlen(snap)) < 0) return; #endif #ifdef MERGED sprintf(snap, "-4:-4:-4\n"); if (write(fd, snap, strlen(snap)) < 0) return; #endif #ifdef PERMUTED sprintf(snap, "-5:%d:%d\n", t_reverse, reversing&2); if (write(fd, snap, strlen(snap)) < 0) return; sprintf(snap, "-6:%d:%d\n", p_reorder==set_permuted, p_reorder==set_reversed); if (write(fd, snap, strlen(snap)) < 0) return; sprintf(snap, "-7:%d:%d\n", p_reorder==set_rotated, p_rotate); if (write(fd, snap, strlen(snap)) < 0) return; sprintf(snap, "-8:%d:%d\n", p_reorder==set_randrot, --s_rand); if (write(fd, snap, strlen(snap)) < 0) return; #endif #if NCORE>1 && !defined(SEP_STATE) && defined(FULL_TRAIL) rev_trail_cnt = 1; enter_critical(GLOBAL_LOCK); rev_trail(fd, stack_last[core_id]); leave_critical(GLOBAL_LOCK); #else i = 1; /* trail starts at position 1 */ #if NCORE>1 && defined(SEP_STATE) if (cur_Root.m_vsize > 0) { i++; depth++; } #endif for ( ; i <= depth; i++) { if (i == depthfound+1) { if (write(fd, "-1:-1:-1\n", 9) != 9) { goto notgood; } } trl = getframe(i); if (!trl->o_t) continue; if (trl->o_pm&128) continue; sprintf(snap, "%ld:%d:%d\n", i, trl->pr, trl->o_t->t_id); j = strlen(snap); if (write(fd, snap, j) != j) { notgood: printf("pan: error writing trailfile\n"); close(fd); wrapup(); } } #endif close(fd); #if NCORE>1 cpu_printf("pan: wrote trailfile\n"); #endif } void sv_save(void) /* push state vector onto save stack */ { if (!svtack->nxt) { svtack->nxt = (Svtack *) emalloc(sizeof(Svtack)); svtack->nxt->body = emalloc(vsize*sizeof(char)); svtack->nxt->lst = svtack; svtack->nxt->m_delta = vsize; svmax++; } else if (vsize > svtack->nxt->m_delta) { svtack->nxt->body = emalloc(vsize*sizeof(char)); svtack->nxt->lst = svtack; svtack->nxt->m_delta = vsize; svmax++; } svtack = svtack->nxt; #if SYNC svtack->o_boq = boq; #endif #ifdef TRIX sv_populate(); #endif svtack->o_delta = vsize; /* don't compress */ memcpy((char *)(svtack->body), (char *) &now, vsize); #if defined(C_States) && defined(HAS_STACK) && (HAS_TRACK==1) c_stack((uchar *) &(svtack->c_stack[0])); #endif #ifdef DEBUG cpu_printf("%d: sv_save\n", depth); #endif } void sv_restor(void) /* pop state vector from save stack */ { memcpy((char *)&now, svtack->body, svtack->o_delta); #if SYNC boq = svtack->o_boq; #endif #ifdef TRIX re_populate(); #endif #if defined(C_States) && (HAS_TRACK==1) #ifdef HAS_STACK c_unstack((uchar *) &(svtack->c_stack[0])); #endif c_revert((uchar *) &(now.c_state[0])); #endif if (vsize != svtack->o_delta) Uerror("sv_restor"); if (!svtack->lst) Uerror("error: sv_restor"); svtack = svtack->lst; #ifdef DEBUG cpu_printf(" sv_restor\n"); #endif } void p_restor(int h) { int i; char *z = (char *) &now; #ifdef BFS_PAR bfs_prepmask(1); /* p_restor */ #endif #ifndef TRIX proc_offset[h] = stack->o_offset; proc_skip[h] = (uchar) stack->o_skip; #else char *oi; #ifdef V_TRIX printf("%4d: p_restor %d\n", depth, h); #endif #endif #ifndef XUSAFE p_name[h] = stack->o_name; #endif #ifdef TRIX vsize += sizeof(char *); #ifndef BFS if (processes[h] != NULL || freebodies == NULL) { Uerror("processes error"); } processes[h] = freebodies; freebodies = freebodies->nxt; processes[h]->nxt = (TRIX_v6 *) 0; processes[h]->modified = 1; /* p_restor */ #endif processes[h]->parent_pid = stack->parent; processes[h]->psize = stack->o_delta; memcpy((char *)pptr(h), stack->b_ptr, stack->o_delta); oi = stack->b_ptr; #else #if !defined(NOCOMP) && !defined(HC) for (i = vsize + stack->o_skip; i > vsize; i--) Mask[i-1] = 1; /* align */ #endif vsize += stack->o_skip; memcpy(z+vsize, stack->body, stack->o_delta); vsize += stack->o_delta; #if !defined(NOCOMP) && !defined(HC) for (i = 1; i <= Air[((P0 *)pptr(h))->_t]; i++) Mask[vsize - i] = 1; /* pad */ Mask[proc_offset[h]] = 1; /* _pid */ #endif if (BASE > 0 && h > 0) ((P0 *)pptr(h))->_pid = h-BASE; else ((P0 *)pptr(h))->_pid = h; #ifdef BFS_PAR bfs_fixmask(1); /* p_restor */ #endif #endif now._nr_pr += 1; #ifndef NOVSZ now._vsz = vsize; #endif i = stack->o_delqs; if (!stack->lst) Uerror("error: p_restor"); stack = stack->lst; this = pptr(h); while (i-- > 0) q_restor(); #ifdef TRIX re_mark_all(1); /* p_restor - all chans move up in _ids_ */ now._ids_[h] = oi; /* restor the original contents */ #endif } void q_restor(void) { int h = now._nr_qs; #ifdef TRIX #ifdef V_TRIX printf("%4d: q_restor %d\n", depth, h); #endif vsize += sizeof(char *); #ifndef BFS if (channels[h] != NULL || freebodies == NULL) { Uerror("channels error"); } channels[h] = freebodies; freebodies = freebodies->nxt; channels[h]->nxt = (TRIX_v6 *) 0; channels[h]->modified = 1; /* q_restor */ #endif channels[h]->parent_pid = stack->parent; channels[h]->psize = stack->o_delta; memcpy((char *)qptr(h), stack->b_ptr, stack->o_delta); now._ids_[now._nr_pr + h] = stack->b_ptr; #else char *z = (char *) &now; #ifndef NOCOMP int k, k_end; #endif #ifdef BFS_PAR bfs_prepmask(2); /* q_restor */ #endif q_offset[h] = stack->o_offset; q_skip[h] = (uchar) stack->o_skip; vsize += stack->o_skip; memcpy(z+vsize, stack->body, stack->o_delta); vsize += stack->o_delta; #endif #ifndef XUSAFE q_name[h] = stack->o_name; #endif #ifndef NOVSZ now._vsz = vsize; #endif now._nr_qs += 1; #ifndef TRIX #if !defined(NOCOMP) && !defined(HC) k_end = stack->o_offset; k = k_end - stack->o_skip; #if SYNC #ifndef BFS if (q_zero(now._nr_qs)) k_end += stack->o_delta; #endif #endif for ( ; k < k_end; k++) Mask[k] = 1; #endif #ifdef BFS_PAR bfs_fixmask(2); /* q_restor */ #endif #endif if (!stack->lst) Uerror("error: q_restor"); stack = stack->lst; } typedef struct IntChunks { int *ptr; struct IntChunks *nxt; } IntChunks; IntChunks *filled_chunks[512]; IntChunks *empty_chunks[512]; int * grab_ints(int nr) { IntChunks *z; if (nr >= 512) Uerror("cannot happen grab_int"); if (filled_chunks[nr]) { z = filled_chunks[nr]; filled_chunks[nr] = filled_chunks[nr]->nxt; } else { z = (IntChunks *) emalloc(sizeof(IntChunks)); z->ptr = (int *) emalloc(nr * sizeof(int)); } z->nxt = empty_chunks[nr]; empty_chunks[nr] = z; return z->ptr; } void ungrab_ints(int *p, int nr) { IntChunks *z; if (!empty_chunks[nr]) Uerror("cannot happen ungrab_int"); z = empty_chunks[nr]; empty_chunks[nr] = empty_chunks[nr]->nxt; z->ptr = p; z->nxt = filled_chunks[nr]; filled_chunks[nr] = z; } int delproc(int sav, int h) { int d, i=0; #ifndef NOCOMP int o_vsize = vsize; #endif if (h+1 != (int) now._nr_pr) { return 0; } #ifdef TRIX #ifdef V_TRIX printf("%4d: delproc %d -- parent %d\n", depth, h, processes[h]->parent_pid); if (now._nr_qs > 0) printf(" top channel: %d -- parent %d\n", now._nr_qs-1, channels[now._nr_qs-1]->parent_pid); #endif while (now._nr_qs > 0 && channels[now._nr_qs-1]->parent_pid == processes[h]->parent_pid) { delq(sav); i++; } d = processes[h]->psize; if (sav) { if (!stack->nxt) { stack->nxt = (_Stack *) emalloc(sizeof(_Stack)); stack->nxt->lst = stack; smax++; } stack = stack->nxt; #ifndef XUSAFE stack->o_name = p_name[h]; #endif stack->parent = processes[h]->parent_pid; stack->o_delta = d; stack->o_delqs = i; stack->b_ptr = now._ids_[h]; } memset((char *)pptr(h), 0, d); #ifndef BFS processes[h]->nxt = freebodies; freebodies = processes[h]; processes[h] = (TRIX_v6 *) 0; #endif vsize -= sizeof(char *); now._nr_pr -= 1; re_mark_all(-1); /* delproc - all chans move down in _ids_ */ #else while (now._nr_qs && q_offset[now._nr_qs-1] > proc_offset[h]) { delq(sav); i++; } d = vsize - proc_offset[h]; if (sav) { if (!stack->nxt) { stack->nxt = (_Stack *) emalloc(sizeof(_Stack)); stack->nxt->body = emalloc(Maxbody * sizeof(char)); stack->nxt->lst = stack; smax++; } stack = stack->nxt; stack->o_offset = proc_offset[h]; #if VECTORSZ>32000 stack->o_skip = (int) proc_skip[h]; #else stack->o_skip = (short) proc_skip[h]; #endif #ifndef XUSAFE stack->o_name = p_name[h]; #endif stack->o_delta = d; stack->o_delqs = i; memcpy(stack->body, (char *)pptr(h), d); } vsize = proc_offset[h]; now._nr_pr -= 1; memset((char *)pptr(h), 0, d); vsize -= (int) proc_skip[h]; #if !defined(NOCOMP) && !defined(HC) #ifdef BFS_PAR bfs_prepmask(3); /* delproc - no chance in proc_offset or proc_skip */ #endif for (i = vsize; i < o_vsize; i++) Mask[i] = 0; /* reset */ #ifdef BFS_PAR bfs_fixmask(3); /* delproc */ #endif #endif #endif #ifndef NOVSZ now._vsz = vsize; #endif return 1; } void delq(int sav) { int h = now._nr_qs - 1; #ifdef TRIX int d = channels[now._nr_qs - 1]->psize; #else int d = vsize - q_offset[now._nr_qs - 1]; #endif #ifndef NOCOMP int k, o_vsize = vsize; #endif if (sav) { if (!stack->nxt) { stack->nxt = (_Stack *) emalloc(sizeof(_Stack)); #ifndef TRIX stack->nxt->body = emalloc(Maxbody * sizeof(char)); #endif stack->nxt->lst = stack; smax++; } stack = stack->nxt; #ifdef TRIX stack->parent = channels[h]->parent_pid; stack->b_ptr = now._ids_[h]; #else stack->o_offset = q_offset[h]; #if VECTORSZ>32000 stack->o_skip = (int) q_skip[h]; #else stack->o_skip = (short) q_skip[h]; #endif #endif #ifndef XUSAFE stack->o_name = q_name[h]; #endif stack->o_delta = d; #ifndef TRIX memcpy(stack->body, (char *)qptr(h), d); #endif } #ifdef TRIX vsize -= sizeof(char *); #ifdef V_TRIX printf("%4d: delq %d parent %d\n", depth, h, channels[h]->parent_pid); #endif #else vsize = q_offset[h]; vsize -= (int) q_skip[h]; #if !defined(NOCOMP) && !defined(HC) #ifdef BFS_PAR bfs_prepmask(3); /* delq - no change in q_offset or q_skip */ #endif for (k = vsize; k < o_vsize; k++) Mask[k] = 0; /* reset */ #ifdef BFS_PAR bfs_fixmask(3); /* delq */ #endif #endif #endif now._nr_qs -= 1; memset((char *)qptr(h), 0, d); #ifdef TRIX #ifndef BFS channels[h]->nxt = freebodies; freebodies = channels[h]; channels[h] = (TRIX_v6 *) 0; #endif #endif #ifndef NOVSZ now._vsz = vsize; #endif } int qs_empty(void) { int i; for (i = 0; i < (int) now._nr_qs; i++) { if (q_sz(i) > 0) return 0; } return 1; } int endstate(void) { int i; P0 *ptr; for (i = BASE; i < (int) now._nr_pr; i++) { ptr = (P0 *) pptr(i); if (!stopstate[ptr->_t][ptr->_p]) return 0; } if (strict) return qs_empty(); #if defined(EVENT_TRACE) if (!stopstate[EVENT_TRACE][now._event] && !a_cycles) { printf("pan: event_trace not completed\n"); return 0; } #endif return 1; } #if !defined(SAFETY) && !defined(BFS) void checkcycles(void) { uchar o_a_t = now._a_t; #ifndef NOFAIR uchar o_cnt = now._cnt[1]; #endif #ifdef FULLSTACK #ifndef MA H_el *sv = trpt->ostate; /* save */ #else uchar prov = trpt->proviso; /* save */ #endif #endif #ifdef DEBUG { int i; uchar *v = (uchar *) &now; printf(" set Seed state "); #ifndef NOFAIR if (fairness) printf("(cnt = %d:%d, nrpr=%d) ", now._cnt[0], now._cnt[1], now._nr_pr); #endif /* for (i = 0; i < n; i++) printf("%d,", v[i]); */ printf("\n"); } printf("%ld: cycle check starts\n", depth); #endif now._a_t |= (1|16|32); /* 1 = 2nd DFS; (16|32) to improve hashing */ #ifndef NOFAIR now._cnt[1] = now._cnt[0]; #endif memcpy((char *)&A_Root, (char *)&now, vsize); A_depth = depthfound = depth; #if NCORE>1 mem_put_acc(); #else new_state(); /* start 2nd DFS */ #endif now._a_t = o_a_t; #ifndef NOFAIR now._cnt[1] = o_cnt; #endif A_depth = 0; depthfound = -1; #ifdef DEBUG printf("%ld: cycle check returns\n", depth); #endif #ifdef FULLSTACK #ifndef MA trpt->ostate = sv; /* restore */ #else trpt->proviso = prov; #endif #endif } #endif #if defined(FULLSTACK) && defined(BITSTATE) H_el *Free_list = (H_el *) 0; void onstack_init(void) /* to store stack states in a bitstate search */ { S_Tab = (H_el **) emalloc(maxdepth*sizeof(H_el *)); } #endif #if !defined(BFS_PAR) #if defined(FULLSTACK) && defined(BITSTATE) H_el * grab_state(int n) { H_el *v, *last = 0; if (H_tab == S_Tab) { for (v = Free_list; v && ((int) v->tagged >= n); v=v->nxt) { if ((int) v->tagged == n) { if (last) last->nxt = v->nxt; else gotcha: Free_list = v->nxt; v->tagged = 0; v->nxt = 0; #ifdef COLLAPSE v->ln = 0; #endif return v; } Fh++; last=v; } /* new: second try */ v = Free_list; if (v && ((int) v->tagged >= n)) goto gotcha; ngrabs++; } return (H_el *) emalloc(sizeof(H_el)+n-sizeof(unsigned)); } #else #if NCORE>1 H_el * grab_state(int n) { H_el *grab_shared(int); return grab_shared(sizeof(H_el)+n-sizeof(unsigned)); } #else #ifndef AUTO_RESIZE #define grab_state(n) (H_el *) \ emalloc(sizeof(H_el)+n-sizeof(ulong)); #else H_el * grab_state(int n) { H_el *p; int cnt = sizeof(H_el)+n-sizeof(ulong); #ifndef MA if (reclaim_size >= cnt+WS) { if ((cnt & (WS-1)) != 0) /* alignment */ { cnt += WS - (cnt & (WS-1)); } p = (H_el *) reclaim_mem; reclaim_mem += cnt; reclaim_size -= cnt; memset(p, 0, cnt); } else #endif { p = (H_el *) emalloc(cnt); } return p; } #endif #endif #endif #else extern volatile uchar *sh_pre_malloc(ulong); extern volatile uchar *sh_malloc(ulong); H_el * grab_state(int n) /* bfs_par */ { volatile uchar *rval = NULL; int m = sizeof(H_el) + n - sizeof(unsigned); if (n == 0) m = m/n; #ifdef BFS_SEP_HASH rval = emalloc((ulong) m); #else rval = sh_malloc((ulong) m); #endif memset((void *) rval, 0, (size_t) m); return (H_el *) rval; } #endif #ifdef COLLAPSE ulong ordinal(char *v, long n, short tp) { H_el *tmp, *ntmp; long m; H_el *olst = (H_el *) 0; s_hash((uchar *)v, n); #if defined(BFS_PAR) && !defined(BFS_SEP_HASH) e_critical(BFS_ID); /* bfs_par / collapse */ #endif #if NCORE>1 && !defined(SEP_STATE) enter_critical(CS_ID); /* uses spinlock - 1..128 */ #endif tmp = H_tab[j1_spin]; if (!tmp) { tmp = grab_state(n); H_tab[j1_spin] = tmp; } else for ( ;; olst = tmp, tmp = tmp->nxt) { if (n == tmp->ln) { m = memcmp(((char *)&(tmp->state)), v, n); if (m == 0) goto done; if (m < 0) { Insert: ntmp = grab_state(n); ntmp->nxt = tmp; if (!olst) H_tab[j1_spin] = ntmp; else olst->nxt = ntmp; tmp = ntmp; break; } else if (!tmp->nxt) { Append: tmp->nxt = grab_state(n); tmp = tmp->nxt; break; } continue; } if (n < tmp->ln) goto Insert; else if (!tmp->nxt) goto Append; } #if NCORE>1 && !defined(SEP_STATE) enter_critical(GLOBAL_LOCK); #endif #ifdef BFS_PAR e_critical(BFS_ORD); /* bfs_par */ #endif m = ++ncomps[tp]; #ifdef BFS_PAR x_critical(BFS_ORD); #endif #if NCORE>1 && !defined(SEP_STATE) leave_critical(GLOBAL_LOCK); #endif #ifdef FULLSTACK tmp->tagged = m; #else tmp->st_id = m; #endif #if defined(AUTO_RESIZE) && !defined(BITSTATE) tmp->m_K1 = K1; #endif memcpy(((char *)&(tmp->state)), v, n); tmp->ln = n; done: #if NCORE>1 && !defined(SEP_STATE) leave_critical(CS_ID); #endif #if defined(BFS_PAR) && !defined(BFS_SEP_HASH) x_critical(BFS_ID); #endif #ifdef FULLSTACK return tmp->tagged; #else return tmp->st_id; #endif } int compress(char *vin, int nin) /* collapse compression */ { char *w, *v = (char *) &comp_now; int i, j; ulong n; static char *x; static uchar nbytes[513]; /* 1 + 256 + 256 */ static unsigned short nbytelen; long col_q(int, char *); long col_p(int, char *); #ifndef SAFETY if (a_cycles) *v++ = now._a_t; #ifndef NOFAIR if (fairness) for (i = 0; i < NFAIR; i++) *v++ = now._cnt[i]; #endif #endif nbytelen = 0; #ifndef JOINPROCS for (i = 0; i < (int) now._nr_pr; i++) { n = col_p(i, (char *) 0); #ifdef NOFIX nbytes[nbytelen] = 0; #else nbytes[nbytelen] = 1; *v++ = ((P0 *) pptr(i))->_t; #endif *v++ = n&255; if (n >= (1<<8)) { nbytes[nbytelen]++; *v++ = (n>>8)&255; } if (n >= (1<<16)) { nbytes[nbytelen]++; *v++ = (n>>16)&255; } if (n >= (1<<24)) { nbytes[nbytelen]++; *v++ = (n>>24)&255; } nbytelen++; } #else x = scratch; for (i = 0; i < (int) now._nr_pr; i++) x += col_p(i, x); n = ordinal(scratch, x-scratch, 2); /* procs */ *v++ = n&255; nbytes[nbytelen] = 0; if (n >= (1<<8)) { nbytes[nbytelen]++; *v++ = (n>>8)&255; } if (n >= (1<<16)) { nbytes[nbytelen]++; *v++ = (n>>16)&255; } if (n >= (1<<24)) { nbytes[nbytelen]++; *v++ = (n>>24)&255; } nbytelen++; #endif #ifdef SEPQS for (i = 0; i < (int) now._nr_qs; i++) { n = col_q(i, (char *) 0); nbytes[nbytelen] = 0; *v++ = n&255; if (n >= (1<<8)) { nbytes[nbytelen]++; *v++ = (n>>8)&255; } if (n >= (1<<16)) { nbytes[nbytelen]++; *v++ = (n>>16)&255; } if (n >= (1<<24)) { nbytes[nbytelen]++; *v++ = (n>>24)&255; } nbytelen++; } #endif #ifdef NOVSZ /* 3 = _a_t, _nr_pr, _nr_qs */ w = (char *) &now + 3 * sizeof(uchar); #ifndef NOFAIR w += NFAIR; #endif #else #if VECTORSZ<65536 w = (char *) &(now._vsz) + sizeof(unsigned short); #else w = (char *) &(now._vsz) + sizeof(ulong); #endif #endif x = scratch; *x++ = now._nr_pr; *x++ = now._nr_qs; if (now._nr_qs > 0 && qptr(0) < pptr(0)) n = qptr(0) - (uchar *) w; else n = pptr(0) - (uchar *) w; j = w - (char *) &now; #if !defined(NOCOMP) && !defined(HC) for (i = 0; i < (int) n; i++, w++) if (!Mask[j++]) *x++ = *w; #else memcpy(x, w, n); x += n; #endif #ifndef SEPQS for (i = 0; i < (int) now._nr_qs; i++) x += col_q(i, x); #endif x--; for (i = 0, j = 6; i < nbytelen; i++) { if (j == 6) { j = 0; *(++x) = 0; } else j += 2; *x |= (nbytes[i] << j); } x++; for (j = 0; j < WS-1; j++) *x++ = 0; x -= j; j = 0; n = ordinal(scratch, x-scratch, 0); /* globals */ *v++ = n&255; if (n >= (1<< 8)) { *v++ = (n>> 8)&255; j++; } if (n >= (1<<16)) { *v++ = (n>>16)&255; j++; } if (n >= (1<<24)) { *v++ = (n>>24)&255; j++; } *v++ = j; /* add last count as a byte */ for (i = 0; i < WS-1; i++) *v++ = 0; v -= i; #if 0 printf("collapse %d -> %d\n", vsize, v - (char *)&comp_now); #endif return v - (char *)&comp_now; } #else #if !defined(NOCOMP) int compress(char *vin, int n) /* default compression */ { #ifdef HC int delta = 0; s_hash((uchar *)vin, n); /* sets K1 and K2 */ #ifndef SAFETY if (S_A) { delta++; /* _a_t */ #ifndef NOFAIR if (S_A > NFAIR) delta += NFAIR; /* _cnt[] */ #endif } #endif memcpy((char *) &comp_now + delta, (char *) &K1, WS); delta += WS; #if HC>0 memcpy((char *) &comp_now + delta, (char *) &K2, HC); delta += HC; #endif return delta; #else char *vv = vin; char *v = (char *) &comp_now; int i; #ifndef NO_FAST_C int r = 0, unroll = n/8; if (unroll > 0) { i = 0; while (r++ < unroll) { /* unroll 8 times, avoid ifs */ /* 1 */ *v = *vv++; v += 1 - Mask[i++]; /* 2 */ *v = *vv++; v += 1 - Mask[i++]; /* 3 */ *v = *vv++; v += 1 - Mask[i++]; /* 4 */ *v = *vv++; v += 1 - Mask[i++]; /* 5 */ *v = *vv++; v += 1 - Mask[i++]; /* 6 */ *v = *vv++; v += 1 - Mask[i++]; /* 7 */ *v = *vv++; v += 1 - Mask[i++]; /* 8 */ *v = *vv++; v += 1 - Mask[i++]; } r = n - i; /* the rest, at most 7 */ switch (r) { case 7: *v = *vv++; v += 1 - Mask[i++]; case 6: *v = *vv++; v += 1 - Mask[i++]; case 5: *v = *vv++; v += 1 - Mask[i++]; case 4: *v = *vv++; v += 1 - Mask[i++]; case 3: *v = *vv++; v += 1 - Mask[i++]; case 2: *v = *vv++; v += 1 - Mask[i++]; case 1: *v = *vv++; v += 1 - Mask[i++]; case 0: break; } n = i = v - (char *)&comp_now; /* bytes written so far */ r = (n+WS-1)/WS; /* in words, rounded up */ r *= WS; /* total bytes to fill */ i = r - i; /* remaining bytes */ switch (i) { case 7: *v++ = 0; /* fall thru */ case 6: *v++ = 0; case 5: *v++ = 0; case 4: *v++ = 0; case 3: *v++ = 0; case 2: *v++ = 0; case 1: *v++ = 0; case 0: break; default: Uerror("unexpected wordsize"); } v -= i; } else #endif { for (i = 0; i < n; i++, vv++) if (!Mask[i]) *v++ = *vv; for (i = 0; i < WS-1; i++) *v++ = 0; v -= i; } #if 0 printf("compress %d -> %d\n", n, v - (char *)&comp_now); #endif return v - (char *)&comp_now; #endif } #endif #endif #if defined(FULLSTACK) && defined(BITSTATE) #if defined(MA) #if !defined(onstack_now) int onstack_now(void) {} #endif #if !defined(onstack_put) void onstack_put(void) {} #endif #if !defined(onstack_zap) void onstack_zap(void) {} #endif #else void onstack_zap(void) { H_el *v, *w, *last = 0; H_el **tmp = H_tab; char *nv; int n, m; static char warned = 0; #if defined(BCS) && defined(NO_LAST) && defined(HAS_LAST) uchar was_last = now._last; now._last = 0; #endif H_tab = S_Tab; #ifndef NOCOMP nv = (char *) &comp_now; n = compress((char *)&now, vsize); #else #if defined(BITSTATE) && defined(LC) nv = (char *) &comp_now; n = compact_stack((char *)&now, vsize); #else nv = (char *) &now; n = vsize; #endif #endif #if !defined(HC) && !(defined(BITSTATE) && defined(LC)) s_hash((uchar *)nv, n); #endif H_tab = tmp; for (v = S_Tab[j1_spin]; v; Zh++, last=v, v=v->nxt) { m = memcmp(&(v->state), nv, n); if (m == 0) goto Found; if (m < 0) break; } /* NotFound: */ #ifndef ZAPH /* seen this happen, likely harmless in multicore */ if (warned == 0) { /* Uerror("stack out of wack - zap"); */ cpu_printf("pan: warning, stack incomplete\n"); warned = 1; } #endif goto done; Found: ZAPS++; if (last) last->nxt = v->nxt; else S_Tab[j1_spin] = v->nxt; v->tagged = (unsigned) n; #if !defined(NOREDUCE) && !defined(SAFETY) v->proviso = 0; #endif v->nxt = last = (H_el *) 0; for (w = Free_list; w; Fa++, last=w, w = w->nxt) { if ((int) w->tagged <= n) { if (last) { v->nxt = w; last->nxt = v; } else { v->nxt = Free_list; Free_list = v; } goto done; } if (!w->nxt) { w->nxt = v; goto done; } } Free_list = v; done: #if defined(BCS) && defined(NO_LAST) && defined(HAS_LAST) now._last = was_last; #endif return; } #ifndef BFS_PAR void onstack_put(void) { H_el **tmp = H_tab; #if defined(BCS) && defined(NO_LAST) && defined(HAS_LAST) uchar was_last = now._last; now._last = 0; #endif H_tab = S_Tab; if (h_store((char *)&now, vsize) != 0) #if defined(BITSTATE) && defined(LC) printf("pan: warning, double stack entry\n"); #else #ifndef ZAPH Uerror("cannot happen - unstack_put"); #endif #endif H_tab = tmp; trpt->ostate = Lstate; PUT++; #if defined(BCS) && defined(NO_LAST) && defined(HAS_LAST) now._last = was_last; #endif } int onstack_now(void) { H_el *tmp; H_el **tmp2 = H_tab; char *v; int n, m = 1; #if defined(BCS) && defined(NO_LAST) && defined(HAS_LAST) uchar was_last = now._last; now._last = 0; #endif H_tab = S_Tab; #ifdef NOCOMP #if defined(BITSTATE) && defined(LC) v = (char *) &comp_now; n = compact_stack((char *)&now, vsize); #else v = (char *) &now; n = vsize; #endif #else v = (char *) &comp_now; n = compress((char *)&now, vsize); #endif #if !defined(HC) && !(defined(BITSTATE) && defined(LC)) s_hash((uchar *)v, n); #endif H_tab = tmp2; for (tmp = S_Tab[j1_spin]; tmp; Zn++, tmp = tmp->nxt) { m = memcmp(((char *)&(tmp->state)),v,n); if (m <= 0) { Lstate = (H_el *) tmp; /* onstack_now */ break; } } PROBE++; #if defined(BCS) && defined(NO_LAST) && defined(HAS_LAST) now._last = was_last; #endif return (m == 0); } #endif #endif #endif #ifdef BITSTATE void init_SS(ulong); void sinit(void) { if (udmem) { udmem *= 1024L*1024L; #if NCORE>1 if (!readtrail) { init_SS((ulong) udmem); } else #endif #if defined(BFS_PAR) && !defined(BFS_SEP_HASH) SS = (uchar *) sh_pre_malloc((ulong) udmem); #else SS = (uchar *) emalloc(udmem); #endif b_store = bstore_mod; } else { #if NCORE>1 init_SS(ONE_L<<(ssize-3)); #else #if defined(BFS_PAR) && !defined(BFS_SEP_HASH) SS = (uchar *) sh_pre_malloc((ulong)(ONE_L<<(ssize-3))); #else SS = (uchar *) emalloc(ONE_L<<(ssize-3)); #endif #endif } } #else #if !defined(MA) || defined(COLLAPSE) void set_H_tab(void) { #if defined(BFS_PAR) && !defined(BFS_SEP_HASH) H_tab = (H_el **) sh_pre_malloc((ulong)((ONE_L<1 && !defined(COLLAPSE) if (!readtrail) { void init_HT(ulong); init_HT(0L); } #endif #endif #endif #if !defined(MA) || defined(COLLAPSE) #if NCORE>1 || (defined(BFS_PAR) && defined(USE_TDH) && !defined(WIN32) && !defined(WIN64)) if (!readtrail) { void init_HT(ulong); init_HT((ulong) (ONE_L<= MA) { printf("pan: error, MA too small, recompile pan.c"); printf(" with -DMA=N with N>%d\n", n); Uerror("aborting"); } if (n > (int) maxgs) { maxgs = (uint) n; } for (i = 0; i < n; i++) { Info[i] = v[i]; } for ( ; i < MA-1; i++) { Info[i] = 0; } Info[MA-1] = pbit; if (a_cycles) /* place _a_t at the end */ { Info[MA] = Info[0]; Info[0] = 0; } #ifdef BFS_PAR e_critical(BFS_STATE); /* bfs_par / g_store */ #endif #if NCORE>1 && !defined(SEP_STATE) enter_critical(GLOBAL_LOCK); /* crude, but necessary */ /* to make this mode work, also replace emalloc with grab_shared inside store MA routines */ #endif if (!dfa_store(Info)) { if (pbit == 0 && (now._a_t&1) && depth > A_depth) { Info[MA] &= ~(1|16|32); /* _a_t */ if (dfa_member(MA)) { Info[MA-1] = 4; /* off-stack bit */ nShadow++; if (!dfa_member(MA-1)) { ret_val = 3; #ifdef VERBOSE printf("intersected 1st dfs stack\n"); #endif goto done; } } } ret_val = 0; #ifdef VERBOSE printf("new state\n"); #endif goto done; } #ifdef FULLSTACK if (pbit == 0) { Info[MA-1] = 1; /* proviso bit */ #ifndef BFS trpt->proviso = dfa_member(MA-1); #endif Info[MA-1] = 4; /* off-stack bit */ if (dfa_member(MA-1)) { ret_val = 1; /* off-stack */ #ifdef VERBOSE printf("old state\n"); #endif } else { ret_val = 2; /* on-stack */ #ifdef VERBOSE printf("on-stack\n"); #endif } goto done; } #endif ret_val = 1; #ifdef VERBOSE printf("old state\n"); #endif done: #ifdef BFS_PAR x_critical(BFS_STATE); #endif #if NCORE>1 && !defined(SEP_STATE) leave_critical(GLOBAL_LOCK); #endif return ret_val; /* old state */ } #endif #if defined(BITSTATE) && defined(LC) int compact_stack(char *vin, int n) { int delta = 0; s_hash((uchar *)vin, n); /* sets K1 and K2 */ #ifndef SAFETY delta++; /* room for state[0] |= 128 */ #endif memcpy((char *) &comp_now + delta, (char *) &K1, WS); delta += WS; memcpy((char *) &comp_now + delta, (char *) &K2, WS); delta += WS; /* use all available bits */ return delta; } #endif #ifdef TRIX void sv_populate(void) { int i, cnt = 0; TRIX_v6 **base = processes; int bound = now._nr_pr; /* MAXPROC+1; */ #ifdef V_TRIX printf("%4d: sv_populate\n", depth); #endif again: for (i = 0; i < bound; i++) { if (base[i] != NULL) { H_el *tmp; int m, n; uchar *v; #ifndef BFS if (base[i]->modified == 0) { cnt++; #ifdef V_TRIX printf("%4d: %s %d not modified\n", depth, (base == processes)?"proc":"chan", i); #endif continue; } #ifndef V_MOD base[i]->modified = 0; #endif #endif #ifdef TRIX_RIX if (base == processes) { ((P0 *)pptr(i))->_pid = 0; } #endif n = base[i]->psize; v = base[i]->body; s_hash(v, n); /* sets j1_spin */ tmp = H_tab[j1_spin]; if (!tmp) /* new */ { tmp = grab_state(n); H_tab[j1_spin] = tmp; m = 1; /* non-zero */ } else { H_el *ntmp, *olst = (H_el *) 0; for (;; hcmp++, olst = tmp, tmp = tmp->nxt) { m = memcmp(((char *)&(tmp->state)), v, n); if (m == 0) /* match */ { break; } else if (m < 0) /* insert */ { ntmp = grab_state(n); ntmp->nxt = tmp; if (!olst) H_tab[j1_spin] = ntmp; else olst->nxt = ntmp; tmp = ntmp; break; } else if (!tmp->nxt) /* append */ { tmp->nxt = grab_state(n); tmp = tmp->nxt; break; } } } if (m != 0) { memcpy((char *)&(tmp->state), v, n); #if defined(AUTO_RESIZE) && !defined(BITSTATE) tmp->m_K1 = K1; /* set via s_hash */ #endif if (verbose) { if (base == processes) { _p_count[i]++; } else { _c_count[i]++; } } } now._ids_[cnt++] = (char *)&(tmp->state); #ifdef TRIX_RIX if (base == processes) { ((P0 *)pptr(i))->_pid = i; if (BASE > 0 && i > 0) { ((P0 *)pptr(i))->_pid -= BASE; } } #endif } } /* do the same for all channels */ if (base == processes) { base = channels; bound = now._nr_qs; /* MAXQ+1; */ goto again; } } #endif #if !defined(BFS_PAR) || (!defined(BITSTATE) && !defined(USE_TDH)) int h_store(char *vin, int nin) /* hash table storage */ { H_el *ntmp; H_el *tmp, *olst = (H_el *) 0; char *v; int n, m=0; #ifdef HC uchar rem_a; #endif #ifdef TRIX sv_populate(); /* update proc and chan ids */ #endif #ifdef NOCOMP #if defined(BITSTATE) && defined(LC) if (S_Tab == H_tab) { v = (char *) &comp_now; n = compact_stack(vin, nin); } else { v = vin; n = nin; } #else v = vin; n = nin; #endif #else v = (char *) &comp_now; #ifdef HC rem_a = now._a_t; now._a_t = 0; #endif n = compress(vin, nin); #ifdef HC now._a_t = rem_a; #endif #ifndef SAFETY if (S_A) { v[0] = 0; /* _a_t */ #ifndef NOFAIR if (S_A > NFAIR) for (m = 0; m < NFAIR; m++) v[m+1] = 0; /* _cnt[] */ #endif m = 0; } #endif #endif #if !defined(HC) && !(defined(BITSTATE) && defined(LC)) s_hash((uchar *)v, n); #endif /* for BFS_PAR we can only get here in BITSTATE mode */ /* and in that case we don't use locks */ #if defined(BFS_PAR) && !defined(BFS_SEP_HASH) e_critical(BFS_ID); /* bfs_par / h_store */ #endif #if NCORE>1 && !defined(SEP_STATE) && !defined(BITSTATE) enter_critical(CS_ID); #endif tmp = H_tab[j1_spin]; if (!tmp) { tmp = grab_state(n); #if NCORE>1 if (!tmp) { /* if we get here -- we've already issued a warning */ /* but we want to allow the normal distributed termination */ /* to collect the stats on all cpus in the wrapup */ #if !defined(SEP_STATE) && !defined(BITSTATE) leave_critical(CS_ID); #endif return 1; /* allow normal termination */ } #endif H_tab[j1_spin] = tmp; } else { for (;; hcmp++, olst = tmp, tmp = tmp->nxt) { /* skip the _a_t and the _cnt bytes */ #ifdef COLLAPSE if (tmp->ln != 0) { if (!tmp->nxt) goto Append; continue; } #endif m = memcmp(((char *)&(tmp->state)) + S_A, v + S_A, n - S_A); if (m == 0) { #ifdef SAFETY #define wasnew 0 #else int wasnew = 0; #endif #if !defined(SAFETY) && !defined(NOCOMP) if (S_A) { if ((((char *)&(tmp->state))[0] & V_A) != V_A) { wasnew = 1; nShadow++; ((char *)&(tmp->state))[0] |= V_A; } #ifndef NOFAIR if (S_A > NFAIR) { /* 0 <= now._cnt[now._a_t&1] < MAXPROC */ uint ci, bp; /* index, bit pos */ ci = (now._cnt[now._a_t&1] / 8); bp = (now._cnt[now._a_t&1] - 8*ci); if (now._a_t&1) /* use tail-bits in _cnt */ { ci = (NFAIR - 1) - ci; bp = 7 - bp; /* bp = 0..7 */ } ci++; /* skip over _a_t */ bp = 1 << bp; /* the bit mask */ if ((((char *)&(tmp->state))[ci] & bp)==0) { if (!wasnew) { wasnew = 1; nShadow++; } ((char *)&(tmp->state))[ci] |= bp; } } /* else: wasnew == 0, i.e., old state */ #endif } #endif #if NCORE>1 Lstate = (H_el *) tmp; /* h_store */ #endif #ifdef FULLSTACK #ifndef SAFETY if (wasnew) { Lstate = (H_el *) tmp; /* h_store */ tmp->tagged |= V_A; if ((now._a_t&1) && (tmp->tagged&A_V) && depth > A_depth) { intersect: #ifdef CHECK #if NCORE>1 printf("cpu%d: ", core_id); #endif printf("1st dfs-stack intersected on state %d+\n", (int) tmp->st_id); #endif #if defined(BFS_PAR) && !defined(BFS_SEP_HASH) x_critical(BFS_ID); #endif #if NCORE>1 && !defined(SEP_STATE) && !defined(BITSTATE) leave_critical(CS_ID); #endif return 3; } #ifdef CHECK #if NCORE>1 printf("cpu%d: ", core_id); #endif printf(" New state %d+\n", (int) tmp->st_id); #endif #ifdef DEBUG dumpstate(1, (char *)&(tmp->state),n,tmp->tagged); #endif #if defined(BFS_PAR) && !defined(BFS_SEP_HASH) x_critical(BFS_ID); #endif #if NCORE>1 && !defined(SEP_STATE) && !defined(BITSTATE) leave_critical(CS_ID); #endif return 0; } else #endif if ((S_A)?(tmp->tagged&V_A):tmp->tagged) { Lstate = (H_el *) tmp; /* h_store */ #ifndef SAFETY /* already on current dfs stack */ /* but may also be on 1st dfs stack */ if ((now._a_t&1) && (tmp->tagged&A_V) && depth > A_depth #ifndef NOFAIR && (!fairness || now._cnt[1] <= 1) #endif ) goto intersect; #endif #ifdef CHECK #if NCORE>1 printf("cpu%d: ", core_id); #endif printf(" Stack state %d\n", (int) tmp->st_id); #endif #ifdef DEBUG dumpstate(0, (char *)&(tmp->state),n,tmp->tagged); #endif #if defined(BFS_PAR) && !defined(BFS_SEP_HASH) x_critical(BFS_ID); #endif #if NCORE>1 && !defined(SEP_STATE) && !defined(BITSTATE) leave_critical(CS_ID); #endif return 2; /* match on stack */ } #else if (wasnew) { #ifdef CHECK #if NCORE>1 printf("cpu%d: ", core_id); #endif printf(" New state %d+\n", (int) tmp->st_id); #endif #ifdef DEBUG dumpstate(1, (char *)&(tmp->state), n, 0); #endif #if defined(BFS_PAR) && !defined(BFS_SEP_HASH) x_critical(BFS_ID); #endif #if NCORE>1 && !defined(SEP_STATE) && !defined(BITSTATE) leave_critical(CS_ID); #endif return 0; } #endif #ifdef CHECK #if NCORE>1 printf("cpu%d: ", core_id); #endif printf(" Old state %d\n", (int) tmp->st_id); #endif #ifdef DEBUG dumpstate(0, (char *)&(tmp->state), n, 0); #endif #if defined(BCS) #ifdef CONSERVATIVE if (tmp->ctx_low > trpt->sched_limit) { tmp->ctx_low = trpt->sched_limit; tmp->ctx_pid[(now._last)/8] = 1 << ((now._last)%8); /* new */ #ifdef CHECK #if NCORE>1 printf("cpu%d: ", core_id); #endif printf(" Revisit with fewer context switches\n"); #endif nstates--; #if defined(BFS_PAR) && !defined(BFS_SEP_HASH) x_critical(BFS_ID); #endif #if NCORE>1 && !defined(SEP_STATE) && !defined(BITSTATE) leave_critical(CS_ID); #endif return 0; } else if ((tmp->ctx_low == trpt->sched_limit && (tmp->ctx_pid[(now._last)/8] & ( 1 << ((now._last)%8) )) == 0 )) { tmp->ctx_pid[(now._last)/8] |= 1 << ((now._last)%8); /* add */ #ifdef CHECK #if NCORE>1 printf("cpu%d: ", core_id); #endif printf(" Revisit with same nr of context switches\n"); #endif nstates--; #if defined(BFS_PAR) && !defined(BFS_SEP_HASH) x_critical(BFS_ID); #endif #if NCORE>1 && !defined(SEP_STATE) && !defined(BITSTATE) leave_critical(CS_ID); #endif return 0; } #endif #endif #ifdef REACH if (tmp->D > depth) { tmp->D = depth; #ifdef CHECK #if NCORE>1 printf("cpu%d: ", core_id); #endif printf(" ReVisiting (from smaller depth)\n"); #endif nstates--; #if defined(BFS_PAR) && !defined(BFS_SEP_HASH) x_critical(BFS_ID); #endif #if NCORE>1 && !defined(SEP_STATE) && !defined(BITSTATE) leave_critical(CS_ID); #endif return 0; } #endif #if (defined(BFS) && defined(Q_PROVISO)) || NCORE>1 Lstate = (H_el *) tmp; /* h_store */ #endif #if defined(BFS_PAR) && !defined(BFS_SEP_HASH) x_critical(BFS_ID); #endif #if NCORE>1 && !defined(SEP_STATE) && !defined(BITSTATE) leave_critical(CS_ID); #endif return 1; /* match outside stack */ } else if (m < 0) { /* insert state before tmp */ ntmp = grab_state(n); #if NCORE>1 if (!ntmp) { #if !defined(SEP_STATE) && !defined(BITSTATE) leave_critical(CS_ID); #endif return 1; /* allow normal termination */ } #endif ntmp->nxt = tmp; if (!olst) H_tab[j1_spin] = ntmp; else olst->nxt = ntmp; tmp = ntmp; break; } else if (!tmp->nxt) { /* append after tmp */ #ifdef COLLAPSE Append: #endif tmp->nxt = grab_state(n); #if NCORE>1 if (!tmp->nxt) { #if !defined(SEP_STATE) && !defined(BITSTATE) leave_critical(CS_ID); #endif return 1; /* allow normal termination */ } #endif tmp = tmp->nxt; break; } } } #ifdef CHECK tmp->st_id = (unsigned) nstates; #if NCORE>1 printf("cpu%d: ", core_id); #endif #ifdef BITSTATE printf(" Push state %d\n", ((int) nstates) - 1); #else printf(" New state %d\n", (int) nstates); #endif #endif #if defined(BCS) tmp->ctx_low = trpt->sched_limit; #ifdef CONSERVATIVE tmp->ctx_pid[(now._last)/8] = 1 << ((now._last)%8); /* new limit */ #endif #endif #if !defined(SAFETY) || defined(REACH) tmp->D = depth; #endif #if !defined(SAFETY) && !defined(NOCOMP) if (S_A) { v[0] = V_A; #ifndef NOFAIR if (S_A > NFAIR) { uint ci, bp; /* as above */ ci = (now._cnt[now._a_t&1] / 8); bp = (now._cnt[now._a_t&1] - 8*ci); if (now._a_t&1) { ci = (NFAIR - 1) - ci; bp = 7 - bp; /* bp = 0..7 */ } v[1+ci] = 1 << bp; } #endif } #endif #if defined(AUTO_RESIZE) && !defined(BITSTATE) tmp->m_K1 = K1; #endif memcpy(((char *)&(tmp->state)), v, n); #ifdef FULLSTACK tmp->tagged = (S_A)?V_A:(depth+1); #ifdef DEBUG dumpstate(-1, v, n, tmp->tagged); #endif Lstate = (H_el *) tmp; /* end of h_store */ #else #ifdef DEBUG dumpstate(-1, v, n, 0); #endif #if NCORE>1 Lstate = (H_el *) tmp; /* end of h_store */ #endif #endif #if defined(BFS_PAR) && !defined(BFS_SEP_HASH) x_critical(BFS_ID); #endif #if NCORE>1 #ifdef V_PROVISO tmp->cpu_id = core_id; #endif #if !defined(SEP_STATE) && !defined(BITSTATE) leave_critical(CS_ID); #endif #endif return 0; } #endif void o_hash32(uchar *s, int len, int h) /* 32-bit, like d_sfh, but with seed */ { uint32_t tmp; int rem; rem = len & 3; len >>= 2; for ( ; len > 0; len--) { h += get16bits(s); tmp = (get16bits(s+2) << 11) ^ h; h = (h << 16) ^ tmp; s += 2*sizeof(uint16_t); h += h >> 11; } switch (rem) { case 3: h += get16bits(s); h ^= h << 16; h ^= s[sizeof(uint16_t)] << 18; h += h >> 11; break; case 2: h += get16bits(s); h ^= h << 11; h += h >> 17; break; case 1: h += *s; h ^= h << 10; h += h >> 1; break; } h ^= h << 3; h += h >> 5; h ^= h << 4; h += h >> 17; h ^= h << 25; h += h >> 6; K1 = h; } void o_hash64(uchar *kb, int nbytes, int seed) { uint8_t *bp; uint64_t a, b, c, n; const uint64_t *k = (uint64_t *) kb; n = nbytes/WS; /* nr of 8-byte chunks */ /* extend to multiple of words, if needed */ a = WS - (nbytes % WS); if (a > 0 && a < WS) { n++; bp = kb + nbytes; switch (a) { case 7: *bp++ = 0; /* fall thru */ case 6: *bp++ = 0; /* fall thru */ case 5: *bp++ = 0; /* fall thru */ case 4: *bp++ = 0; /* fall thru */ case 3: *bp++ = 0; /* fall thru */ case 2: *bp++ = 0; /* fall thru */ case 1: *bp = 0; case 0: break; } } a = (uint64_t) seed; b = HASH_CONST[HASH_NR]; c = 0x9e3779b97f4a7c13LL; /* arbitrary */ while (n >= 3) { a += k[0]; b += k[1]; c += k[2]; mix(a,b,c); n -= 3; k += 3; } c += (((uint64_t) nbytes)<<3); switch (n) { case 2: b += k[1]; case 1: a += k[0]; case 0: break; } mix(a,b,c); K1 = a; } #if defined(USE_TDH) && !defined(WIN32) && !defined(WIN64) #ifdef HC #ifndef T_HC #ifdef BFS_HC #define T_HC BFS_HC #else #define T_HC 2 #endif #endif #if T_HC<1 || T_HC>4 #error "BFS_HC must be 1, 2, 3, or 4 (default is 2)" #endif #endif #define T_ROW 6 #define T_ROW_SIZE (1< x)) { Uerror("assertion x * (ulong) T_VSZ > x fails"); } #ifdef BFS_SEP_HASH ohash_sd = (char *) emalloc(x * (ulong) T_VSZ); #else ohash_sd = (volatile char *) sh_pre_malloc(x * (ulong) T_VSZ); #endif #else ohash_hc_sz = (ulong) (T_HC * (ulong) sizeof(uint32_t)); if (!(x * ohash_hc_sz > x)) { Uerror("assertion x * ohash_hc_sz > x fails"); } #ifdef BFS_SEP_HASH ohash_sd = (char *) emalloc(x * ohash_hc_sz); #else ohash_sd = (volatile char *) sh_pre_malloc(x * ohash_hc_sz); #endif #endif #ifdef BFS_SEP_HASH ohash_hv = (uint32_t *) emalloc(x * (ulong) sizeof(uint32_t)); #else ohash_hv = (volatile uint32_t *) sh_pre_malloc(x * (ulong) sizeof(uint32_t)); #endif ohash_mask = (((ulong)1)<o_pm &= ~2; #ifdef VERBOSE bfs_printf("check to mark\n"); #endif for (i = 0; i < (int) now._nr_pr; i++) { P0 *ptr = (P0 *) pptr(i); if (accpstate[ptr->_t][ptr->_p]) { trpt->o_pm |= 2; now._l_bnd = L_bound; now._l_sds = (uchar *) 0; #ifdef VERBOSE bfs_printf("mark state live\n"); #endif break; } } } void bfs_check_live(uchar b, uchar *s) { /* assert(b>0); */ now._l_bnd = b-1; /* decrease bound */ #ifdef VERBOSE bfs_printf("check live %d\n", b); #endif if (b == L_bound && boq == -1) { now._l_sds = (uchar *) Lstate; /* new target */ } else { now._l_sds = s; /* restore target */ if (s == (uchar *) Lstate) { depthfound = depth - (BASE+1)*(L_bound - now._l_bnd - 1); uerror("accept cycle found"); depthfound = -1; now._l_bnd = 0; now._l_sds = (uchar *) 0; } } #ifdef VERBOSE bfs_printf("set l_bound to %d -- sds %p\n", b-1, (void *) now._l_sds); #endif } #endif /* closed hashing with locality - similar to ltsmin */ int o_store(const char *vin, int nin) { int i, seed = 0; ulong hash_v, ix, ex; uint32_t T_BUSY, T_DONE; volatile uint32_t *t_entry; #ifdef HC ulong vs = ohash_hc_sz; #else ulong vs = (ulong) T_VSZ; #endif #ifdef L_BOUND uchar o_bnd, *o_sds; #endif #ifndef STOP_ON_FULL if (h_table_full) { goto done; } #endif #ifdef L_BOUND if (now._l_bnd == 0) { bfs_mark_live(); } #ifdef VERBOSE else { bfs_printf("non-markable state %d\n", now._l_bnd); } #endif o_bnd = now._l_bnd; o_sds = now._l_sds; now._l_bnd = (o_bnd)?1:0; /* mark nested phase of bounded search */ now._l_sds = (uchar *) 0; #endif #if !defined(HC) && !defined(T_NOCOMP) nin = compress((char *)vin, nin); vin = (char *) &comp_now; #endif do { o_hash((uchar *)vin, nin, seed++); hash_v = K1; } while (hash_v == T_FREE || hash_v == T_STAT); /* unlikely, hash_v 0 or 1 */ T_BUSY = ((uint32_t) hash_v & ~((uint32_t) T_STAT)); /* hash with status bit 0 */ T_DONE = ((uint32_t) hash_v | ((uint32_t) T_STAT)); /* hash with status bit 1 */ #ifdef HC d_hash((uchar *)vin, nin); ohash_hc[0] = (uint32_t) K1; #if T_HC>1 ohash_hc[1] = (uint32_t) (K1>>32); #endif #if T_HC>2 ohash_hc[2] = (uint32_t) K2; #endif #if T_HC>3 ohash_hc[3] = (uint32_t) (K2>>32); #endif #endif while (seed < ohash_max) { ix = hash_v & ohash_mask; ex = (ix & T_ROW_MASK) + T_ROW_SIZE; for (i = 0; i < T_ROW_SIZE; i++) { t_entry = (uint32_t *) &ohash_hv[ix]; if (*t_entry == T_FREE && cas(t_entry, T_FREE, T_BUSY)) { #ifndef HC memcpy((char *) &ohash_sd[ix * vs], vin, nin); #else memcpy((char *) &ohash_sd[ix * vs], (char *) ohash_hc, vs); #endif #if defined(USE_TDH) && defined(Q_PROVISO) ohash_inq[ix] = (uchar) BFS_INQ; Lstate = (H_el *) &ohash_inq[ix]; #endif *t_entry = T_DONE; #ifdef VERBOSE #ifdef L_BOUND bfs_printf("New state %p [%p]\n", (void *) Lstate, (void *) o_sds); #else bfs_printf("New state %p\n", (void *) Lstate); #endif #endif #ifdef L_BOUND if (o_bnd) { bfs_check_live(o_bnd, o_sds); } #endif return 0; /* New State */ } while (*t_entry == T_BUSY) { usleep(2); /* wait */ } if (*t_entry == T_DONE /* (first) hash matches, check data */ #ifndef HC && memcmp((char *) &ohash_sd[ix * vs], vin, nin) == 0) #else && memcmp((char *) &ohash_sd[ix * vs], (char *) ohash_hc, vs) == 0) #endif { #if defined(USE_TDH) && defined(Q_PROVISO) Lstate = (H_el *) &ohash_inq[ix]; #endif #ifdef VERBOSE #ifdef L_BOUND bfs_printf("Old state %p [%p]\n", (void *) Lstate, (void *) o_sds); #else bfs_printf("Old state %p\n", (void *) Lstate); #endif #endif #ifdef L_BOUND if (o_bnd) { bfs_check_live(o_bnd, o_sds); } #endif return 1; /* Old State */ } hcmp++; ix++; ix = (ix==ex) ? ex - T_ROW_SIZE : ix; } /* find a new slot: */ do { o_hash((uchar *)vin, nin, (int) (hash_v + seed++)); hash_v = K1; } while (hash_v == T_FREE || hash_v == T_STAT); T_BUSY = ((uint32_t) hash_v & ~((uint32_t) T_STAT)); T_DONE = ((uint32_t) hash_v | ((uint32_t) T_STAT)); } #ifdef STOP_ON_FULL Uerror("hash table full"); /* no return from Uerror */ #else if (!h_table_full) { h_table_full++; if (who_am_i == 0) { bfs_printf("hash table is full\n"); } } done: bfs_punt++; /* counts this as a lost state */ #endif #ifdef L_BOUND now._l_bnd = 0; /* no more checking */ now._l_sds = (uchar *) 0; #endif return 1; /* technically should be 0, but we want to throttle down */ } #endif #endif #include TRANSITIONS void do_reach(void) { r_ck(reached0, nstates0, 0, src_ln0, src_file0); } void iniglobals(int calling_pid) { } int addqueue(int calling_pid, int n, int is_rv) { int j=0, i = now._nr_qs; #if !defined(NOCOMP) && !defined(TRIX) int k; #endif if (i >= MAXQ) Uerror("too many queues"); #ifdef V_TRIX printf("%4d: add queue %d\n", depth, i); #endif switch (n) { default: Uerror("bad queue - addqueue"); } #ifdef BFS_PAR bfs_prepmask(2); /* addqueue */ #endif #ifdef TRIX vsize += sizeof(H_el *); #else if (vsize%WS) q_skip[i] = WS-(vsize%WS); else q_skip[i] = 0; #if !defined(NOCOMP) && !defined(HC) k = vsize; #ifndef BFS if (is_rv) k += j; #endif for (k += (int) q_skip[i]; k > vsize; k--) Mask[k-1] = 1; #endif vsize += (int) q_skip[i]; q_offset[i] = vsize; vsize += j; #ifdef BFS_PAR bfs_fixmask(2); /* addqueue */ #endif #endif now._nr_qs += 1; #ifndef NOVSZ now._vsz = vsize; #endif hmax = max(hmax, vsize); #ifdef TRIX #ifndef BFS if (freebodies) { channels[i] = freebodies; freebodies = freebodies->nxt; } else { channels[i] = (TRIX_v6 *) emalloc(sizeof(TRIX_v6)); channels[i]->body = (uchar *) emalloc(Maxbody * sizeof(char)); } channels[i]->modified = 1; /* addq */ #endif channels[i]->psize = j; channels[i]->parent_pid = calling_pid; channels[i]->nxt = (TRIX_v6 *) 0; #else if (vsize >= VECTORSZ) Uerror("VECTORSZ is too small, edit pan.h"); #endif if (j > 0) { memset((char *)qptr(i), 0, j); } ((Q0 *)qptr(i))->_t = n; return i+1; } #ifdef TRIX int what_p_size(int t) { int j; switch (t) { case 0: j = sizeof(P0); break; case 1: j = sizeof(P1); break; default: Uerror("bad proctype"); } return j; } int what_q_size(int t) { int j; switch (t) { case 0: j = sizeof(Q0); break; default: Uerror("bad qtype"); } return j; } #endif #if NQS>0 void qsend(int into, int sorted, int args_given) { int j; uchar *z; #ifdef HAS_SORTED int k; #endif if (!into--) uerror("ref to uninitialized chan name (sending)"); if (into >= (int) now._nr_qs || into < 0) Uerror("qsend bad queue#"); #if defined(TRIX) && !defined(BFS) #ifndef TRIX_ORIG (trpt+1)->q_bup = now._ids_[now._nr_pr+into]; #ifdef V_TRIX printf("%4d: channel %d s save %p from %d\n", depth, into, (trpt+1)->q_bup, now._nr_pr+into); #endif #endif channels[into]->modified = 1; /* qsend */ #ifdef V_TRIX printf("%4d: channel %d modified\n", depth, into); #endif #endif z = qptr(into); j = ((Q0 *)qptr(into))->Qlen; switch (((Q0 *)qptr(into))->_t) { case 0: printf("queue %d was deleted\n", into+1); default: Uerror("bad queue - qsend"); } #ifdef EVENT_TRACE if (in_s_scope(into+1)) require('s', into); #endif } #endif #if SYNC int q_zero(int from) { if (!from--) { uerror("ref to uninitialized chan name (q_zero)"); return 0; } switch(((Q0 *)qptr(from))->_t) { case 0: printf("queue %d was deleted\n", from+1); } Uerror("bad queue q-zero"); return -1; } int not_RV(int from) { if (q_zero(from)) { printf("==>> a test of the contents of a rv "); printf("channel always returns FALSE\n"); uerror("error to poll rendezvous channel"); } return 1; } #endif #ifndef XUSAFE void setq_claim(int x, int m, char *s, int y, char *p) { if (x == 0) uerror("x[rs] claim on uninitialized channel"); if (x < 0 || x > MAXQ) Uerror("cannot happen setq_claim"); q_claim[x] |= m; p_name[y] = p; q_name[x] = s; if (m&2) q_S_check(x, y); if (m&1) q_R_check(x, y); } short q_sender[MAXQ+1]; int q_S_check(int x, int who) { if (!q_sender[x]) { q_sender[x] = who+1; #if SYNC if (q_zero(x)) { printf("chan %s (%d), ", q_name[x], x-1); printf("sndr proc %s (%d)\n", p_name[who], who); uerror("xs chans cannot be used for rv"); } #endif } else if (q_sender[x] != who+1) { printf("pan: xs assertion violated: "); printf("access to chan <%s> (%d)\npan: by ", q_name[x], x-1); if (q_sender[x] > 0 && p_name[q_sender[x]-1]) printf("%s (proc %d) and by ", p_name[q_sender[x]-1], q_sender[x]-1); printf("%s (proc %d)\n", p_name[who], who); uerror("error, partial order reduction invalid"); } return 1; } short q_recver[MAXQ+1]; int q_R_check(int x, int who) { #ifdef VERBOSE printf("q_R_check x=%d who=%d\n", x, who); #endif if (!q_recver[x]) { q_recver[x] = who+1; #if SYNC if (q_zero(x)) { printf("chan %s (%d), ", q_name[x], x-1); printf("recv proc %s (%d)\n", p_name[who], who); uerror("xr chans cannot be used for rv"); } #endif } else if (q_recver[x] != who+1) { printf("pan: xr assertion violated: "); printf("access to chan %s (%d)\npan: ", q_name[x], x-1); if (q_recver[x] > 0 && p_name[q_recver[x]-1]) printf("by %s (proc %d) and ", p_name[q_recver[x]-1], q_recver[x]-1); printf("by %s (proc %d)\n", p_name[who], who); uerror("error, partial order reduction invalid"); } return 1; } #endif int q_len(int x) { if (!x--) uerror("ref to uninitialized chan name (len)"); return ((Q0 *)qptr(x))->Qlen; } int q_full(int from) { if (!from--) uerror("ref to uninitialized chan name (qfull)"); switch(((Q0 *)qptr(from))->_t) { case 0: printf("queue %d was deleted\n", from+1); } Uerror("bad queue - q_full"); return 0; } #ifdef HAS_UNLESS int q_e_f(int from) { /* empty or full */ return !q_len(from) || q_full(from); } #endif #if NQS>0 int qrecv(int from, int slot, int fld, int done) { uchar *z; int j, k, r=0; if (!from--) uerror("ref to uninitialized chan name (receiving)"); #if defined(TRIX) && !defined(BFS) #ifndef TRIX_ORIG (trpt+1)->q_bup = now._ids_[now._nr_pr+from]; #ifdef V_TRIX printf("%4d: channel %d r save %p from %d\n", depth, from, (trpt+1)->q_bup, now._nr_pr+from); #endif #endif channels[from]->modified = 1; /* qrecv */ #ifdef V_TRIX printf("%4d: channel %d modified\n", depth, from); #endif #endif if (from >= (int) now._nr_qs || from < 0) Uerror("qrecv bad queue#"); z = qptr(from); #ifdef EVENT_TRACE if (done && (in_r_scope(from+1))) require('r', from); #endif switch (((Q0 *)qptr(from))->_t) { case 0: printf("queue %d was deleted\n", from+1); default: Uerror("bad queue - qrecv"); } return r; } #endif #ifndef BITSTATE #ifdef COLLAPSE long col_q(int i, char *z) { int j=0, k; char *x, *y; Q0 *ptr = (Q0 *) qptr(i); switch (ptr->_t) { default: Uerror("bad qtype - collapse"); } if (z) x = z; else x = scratch; y = (char *) ptr; k = q_offset[i]; #if NQS > 0 /* no need to store the empty slots at the end */ j -= (q_max[ptr->_t] - ptr->Qlen) * ((j - 2)/q_max[ptr->_t]); #endif #if !defined(NOCOMP) && !defined(HC) for ( ; j > 0; j--, y++) if (!Mask[k++]) *x++ = *y; #else memcpy(x, y, j); x += j; #endif for (j = 0; j < WS-1; j++) *x++ = 0; x -= j; if (z) return (long) (x - z); return ordinal(scratch, x-scratch, 1); /* chan */ } #endif #endif int unsend(int into) { int _m=0, j; uchar *z; #ifdef HAS_SORTED int k; #endif if (!into--) uerror("ref to uninitialized chan (unsend)"); #if defined(TRIX) && !defined(BFS) #ifndef TRIX_ORIG now._ids_[now._nr_pr+into] = trpt->q_bup; #ifdef V_TRIX printf("%4d: channel %d s restore %p into %d\n", depth, into, trpt->q_bup, now._nr_pr+into); #endif #else channels[into]->modified = 1; /* unsend */ #ifdef V_TRIX printf("%4d: channel %d unmodify\n", depth, into); #endif #endif #endif z = qptr(into); j = ((Q0 *)z)->Qlen; ((Q0 *)z)->Qlen = --j; switch (((Q0 *)qptr(into))->_t) { default: Uerror("bad queue - unsend"); } return _m; } void unrecv(int from, int slot, int fld, int fldvar, int strt) { int j; uchar *z; if (!from--) uerror("ref to uninitialized chan (unrecv)"); #if defined(TRIX) && !defined(BFS) #ifndef TRIX_ORIG now._ids_[now._nr_pr+from] = trpt->q_bup; #ifdef V_TRIX printf("%4d: channel %d r restore %p into %d\n", depth, from, trpt->q_bup, now._nr_pr+from); #endif #else channels[from]->modified = 1; /* unrecv */ #ifdef V_TRIX printf("%4d: channel %d unmodify\n", depth, from); #endif #endif #endif z = qptr(from); j = ((Q0 *)z)->Qlen; if (strt) ((Q0 *)z)->Qlen = j+1; switch (((Q0 *)qptr(from))->_t) { default: Uerror("bad queue - qrecv"); } } int q_cond(short II, Trans *t) { int i = 0; for (i = 0; i < 6; i++) { if (t->ty[i] == TIMEOUT_F) return 1; if (t->ty[i] == ALPHA_F) #ifdef GLOB_ALPHA return 0; #else return (II+1 == (short) now._nr_pr && II+1 < MAXPROC); #endif switch (t->qu[i]) { case 0: break; default: Uerror("unknown qid - q_cond"); return 0; } } return 1; } void to_compile(void) { char ctd[2048], carg[128]; #ifdef BITSTATE strcpy(ctd, "-DBITSTATE "); #else strcpy(ctd, ""); #endif #ifdef BFS_PAR strcat(ctd, "-DBFS_PAR "); #endif #ifdef NOVSZ strcat(ctd, "-DNOVSZ "); #endif #ifdef RHASH strcat(ctd, "-DRHASH "); #else #ifdef PERMUTED strcat(ctd, "-DPERMUTED "); #endif #endif #ifdef P_REVERSE strcat(ctd, "-DP_REVERSE "); #endif #ifdef T_REVERSE strcat(ctd, "-DT_REVERSE "); #endif #ifdef T_RAND #if T_RAND>0 sprintf(carg, "-DT_RAND=%d ", T_RAND); strcat(ctd, carg); #else strcat(ctd, "-DT_RAND "); #endif #endif #ifdef P_RAND #if P_RAND>0 sprintf(carg, "-DP_RAND=%d ", P_RAND); strcat(ctd, carg); #else strcat(ctd, "-DP_RAND "); #endif #endif #ifdef BCS sprintf(carg, "-DBCS=%d ", BCS); strcat(ctd, carg); #endif #ifdef BFS strcat(ctd, "-DBFS "); #endif #ifdef MEMLIM sprintf(carg, "-DMEMLIM=%d ", MEMLIM); strcat(ctd, carg); #else #ifdef MEMCNT sprintf(carg, "-DMEMCNT=%d ", MEMCNT); strcat(ctd, carg); #endif #endif #ifdef NOCLAIM strcat(ctd, "-DNOCLAIM "); #endif #ifdef SAFETY strcat(ctd, "-DSAFETY "); #else #ifdef NOFAIR strcat(ctd, "-DNOFAIR "); #else #ifdef NFAIR if (NFAIR != 2) { sprintf(carg, "-DNFAIR=%d ", NFAIR); strcat(ctd, carg); } #endif #endif #endif #ifdef NOREDUCE strcat(ctd, "-DNOREDUCE "); #else #ifdef XUSAFE strcat(ctd, "-DXUSAFE "); #endif #endif #ifdef NP strcat(ctd, "-DNP "); #endif #ifdef PEG strcat(ctd, "-DPEG "); #endif #ifdef VAR_RANGES strcat(ctd, "-DVAR_RANGES "); #endif #ifdef HC strcat(ctd, "-DHC "); #endif #ifdef CHECK strcat(ctd, "-DCHECK "); #endif #ifdef CTL strcat(ctd, "-DCTL "); #endif #ifdef TRIX strcat(ctd, "-DTRIX "); #endif #ifdef NIBIS strcat(ctd, "-DNIBIS "); #endif #ifdef NOBOUNDCHECK strcat(ctd, "-DNOBOUNDCHECK "); #endif #ifdef NOSTUTTER strcat(ctd, "-DNOSTUTTER "); #endif #ifdef REACH strcat(ctd, "-DREACH "); #endif #ifdef PRINTF strcat(ctd, "-DPRINTF "); #endif #ifdef COLLAPSE strcat(ctd, "-DCOLLAPSE "); #endif #ifdef MA sprintf(carg, "-DMA=%d ", MA); strcat(ctd, carg); #endif #ifdef SVDUMP strcat(ctd, "-DSVDUMP "); #endif #if defined(VECTORSZ) && !defined(TRIX) if (VECTORSZ != 1024) { sprintf(carg, "-DVECTORSZ=%d ", VECTORSZ); strcat(ctd, carg); } #endif #ifdef VERBOSE strcat(ctd, "-DVERBOSE "); #endif #ifdef CHECK strcat(ctd, "-DCHECK "); #endif #ifdef SDUMP strcat(ctd, "-DSDUMP "); #endif #if NCORE>1 sprintf(carg, "-DNCORE=%d ", NCORE); strcat(ctd, carg); #endif #ifdef VMAX if (VMAX != 256) { sprintf(carg, "-DVMAX=%d ", VMAX); strcat(ctd, carg); } #endif #ifdef PMAX if (PMAX != 16) { sprintf(carg, "-DPMAX=%d ", PMAX); strcat(ctd, carg); } #endif #ifdef QMAX if (QMAX != 16) { sprintf(carg, "-DQMAX=%d ", QMAX); strcat(ctd, carg); } #endif #ifdef SET_WQ_SIZE sprintf(carg, "-DSET_WQ_SIZE=%d ", SET_WQ_SIZE); strcat(ctd, carg); #endif printf("Compiled as: cc -o pan %span.c\n", ctd); } void active_procs(void) { if (reversing == 0) { Addproc(0, 1); } else { Addproc(0, 1); } } #ifdef MA #define TWIDTH 256 #define HASH(y,n) (n)*(((long)y)) #define INRANGE(e,h) ((h>=e->From && h<=e->To)||(e->s==1 && e->S==h)) extern char *emalloc(unsigned long); /* imported routine */ extern void dfa_init(ushort); /* 4 exported routines */ extern int dfa_member(ulong); extern int dfa_store(uchar *); extern void dfa_stats(void); typedef struct Edge { uchar From, To; /* max range 0..255 */ uchar s, S; /* if s=1, S is singleton */ struct Vertex *Dst; struct Edge *Nxt; } Edge; typedef struct Vertex { ulong key, num; /* key for splay tree, nr incoming edges */ uchar from[2], to[2]; /* in-node predefined edge info */ struct Vertex *dst[2];/* most nodes have 2 or more edges */ struct Edge *Succ; /* in case there are more edges */ struct Vertex *lnk, *left, *right; /* splay tree plumbing */ } Vertex; static Edge *free_edges; static Vertex *free_vertices; static Vertex **layers; /* one splay tree of nodes per layer */ static Vertex **path; /* run of word in the DFA */ static Vertex *R, *F, *NF; /* Root, Final, Not-Final */ static uchar *word, *lastword;/* string, and last string inserted */ static int dfa_depth, iv=0, nv=0, pfrst=0, Tally; static void insert_it(Vertex *, int); /* splay-tree code */ static void delete_it(Vertex *, int); static Vertex *find_it(Vertex *, Vertex *, uchar, int); static void recyc_edges(Edge *e) { if (!e) return; recyc_edges(e->Nxt); e->Nxt = free_edges; free_edges = e; } static Edge * new_edge(Vertex *dst) { Edge *e; if (free_edges) { e = free_edges; free_edges = e->Nxt; e->From = e->To = e->s = e->S = 0; e->Nxt = (Edge *) 0; } else e = (Edge *) emalloc(sizeof(Edge)); e->Dst = dst; return e; } static void recyc_vertex(Vertex *v) { recyc_edges(v->Succ); v->Succ = (Edge *) free_vertices; free_vertices = v; nr_states--; } static Vertex * new_vertex(void) { Vertex *v; if (free_vertices) { v = free_vertices; free_vertices = (Vertex *) v->Succ; v->Succ = (Edge *) 0; v->num = 0; } else v = (Vertex *) emalloc(sizeof(Vertex)); nr_states++; return v; } static Vertex * allDelta(Vertex *v, int n) { Vertex *dst = new_vertex(); v->from[0] = 0; v->to[0] = 255; v->dst[0] = dst; dst->num = 256; insert_it(v, n); return dst; } static void insert_edge(Vertex *v, Edge *e) { /* put new edge first */ if (!v->dst[0]) { v->dst[0] = e->Dst; v->from[0] = e->From; v->to[0] = e->To; recyc_edges(e); return; } if (!v->dst[1]) { v->from[1] = v->from[0]; v->from[0] = e->From; v->to[1] = v->to[0]; v->to[0] = e->To; v->dst[1] = v->dst[0]; v->dst[0] = e->Dst; recyc_edges(e); return; } /* shift */ { int f = v->from[1]; int t = v->to[1]; Vertex *d = v->dst[1]; v->from[1] = v->from[0]; v->from[0] = e->From; v->to[1] = v->to[0]; v->to[0] = e->To; v->dst[1] = v->dst[0]; v->dst[0] = e->Dst; e->From = f; e->To = t; e->Dst = d; } e->Nxt = v->Succ; v->Succ = e; } static void copyRecursive(Vertex *v, Edge *e) { Edge *f; if (e->Nxt) copyRecursive(v, e->Nxt); f = new_edge(e->Dst); f->From = e->From; f->To = e->To; f->s = e->s; f->S = e->S; f->Nxt = v->Succ; v->Succ = f; } static void copyEdges(Vertex *to, Vertex *from) { int i; for (i = 0; i < 2; i++) { to->from[i] = from->from[i]; to->to[i] = from->to[i]; to->dst[i] = from->dst[i]; } if (from->Succ) copyRecursive(to, from->Succ); } static Edge * cacheDelta(Vertex *v, int h, int first) { static Edge *ov, tmp; int i; if (!first && INRANGE(ov,h)) return ov; /* intercepts about 10% */ for (i = 0; i < 2; i++) if (v->dst[i] && h >= v->from[i] && h <= v->to[i]) { tmp.From = v->from[i]; tmp.To = v->to[i]; tmp.Dst = v->dst[i]; tmp.s = tmp.S = 0; ov = &tmp; return ov; } for (ov = v->Succ; ov; ov = ov->Nxt) if (INRANGE(ov,h)) return ov; Uerror("cannot get here, cacheDelta"); return (Edge *) 0; } static Vertex * Delta(Vertex *v, int h) /* v->delta[h] */ { Edge *e; if (v->dst[0] && h >= v->from[0] && h <= v->to[0]) return v->dst[0]; /* oldest edge */ if (v->dst[1] && h >= v->from[1] && h <= v->to[1]) return v->dst[1]; for (e = v->Succ; e; e = e->Nxt) if (INRANGE(e,h)) return e->Dst; Uerror("cannot happen Delta"); return (Vertex *) 0; } static void numDelta(Vertex *v, int d) { Edge *e; ulong cnt; int i; for (i = 0; i < 2; i++) if (v->dst[i]) { cnt = v->dst[i]->num + d*(1 + v->to[i] - v->from[i]); if (d == 1 && cnt < v->dst[i]->num) goto bad; v->dst[i]->num = cnt; } for (e = v->Succ; e; e = e->Nxt) { cnt = e->Dst->num + d*(1 + e->To - e->From + e->s); if (d == 1 && cnt < e->Dst->num) bad: Uerror("too many incoming edges"); e->Dst->num = cnt; } } static void setDelta(Vertex *v, int h, Vertex *newdst) /* v->delta[h] = newdst; */ { Edge *e, *f = (Edge *) 0, *g; int i; /* remove the old entry, if there */ for (i = 0; i < 2; i++) if (v->dst[i] && h >= v->from[i] && h <= v->to[i]) { if (h == v->from[i]) { if (h == v->to[i]) { v->dst[i] = (Vertex *) 0; v->from[i] = v->to[i] = 0; } else v->from[i]++; } else if (h == v->to[i]) { v->to[i]--; } else { g = new_edge(v->dst[i]);/* same dst */ g->From = v->from[i]; g->To = h-1; /* left half */ v->from[i] = h+1; /* right half */ insert_edge(v, g); } goto part2; } for (e = v->Succ; e; f = e, e = e->Nxt) { if (e->s == 1 && e->S == h) { e->s = e->S = 0; goto rem_tst; } if (h >= e->From && h <= e->To) { if (h == e->From) { if (h == e->To) { if (e->s) { e->From = e->To = e->S; e->s = 0; break; } else goto rem_do; } else e->From++; } else if (h == e->To) { e->To--; } else /* split */ { g = new_edge(e->Dst); /* same dst */ g->From = e->From; g->To = h-1; /* g=left half */ e->From = h+1; /* e=right half */ g->Nxt = e->Nxt; /* insert g */ e->Nxt = g; /* behind e */ break; /* done */ } rem_tst: if (e->From > e->To) { if (e->s == 0) { rem_do: if (f) f->Nxt = e->Nxt; else v->Succ = e->Nxt; e->Nxt = (Edge *) 0; recyc_edges(e); } else { e->From = e->To = e->S; e->s = 0; } } break; } } part2: /* check if newdst is already there */ for (i = 0; i < 2; i++) if (v->dst[i] == newdst) { if (h+1 == (int) v->from[i]) { v->from[i] = h; return; } if (h == (int) v->to[i]+1) { v->to[i] = h; return; } } for (e = v->Succ; e; e = e->Nxt) { if (e->Dst == newdst) { if (h+1 == (int) e->From) { e->From = h; if (e->s == 1 && e->S+1 == e->From) { e->From = e->S; e->s = e->S = 0; } return; } if (h == (int) e->To+1) { e->To = h; if (e->s == 1 && e->S == e->To+1) { e->To = e->S; e->s = e->S = 0; } return; } if (e->s == 0) { e->s = 1; e->S = h; return; } } } /* add as a new edge */ e = new_edge(newdst); e->From = e->To = h; insert_edge(v, e); } static ulong cheap_key(Vertex *v) { ulong vk2 = 0; if (v->dst[0]) { vk2 = (ulong) v->dst[0]; if ((ulong) v->dst[1] > vk2) vk2 = (ulong) v->dst[1]; } else if (v->dst[1]) vk2 = (ulong) v->dst[1]; if (v->Succ) { Edge *e; for (e = v->Succ; e; e = e->Nxt) if ((ulong) e->Dst > vk2) vk2 = (ulong) e->Dst; } Tally = (vk2>>2)&(TWIDTH-1); return v->key; } static ulong mk_key(Vertex *v) /* not sensitive to order */ { ulong m = 0, vk2 = 0; Edge *e; if (v->dst[0]) { m += HASH(v->dst[0], v->to[0] - v->from[0] + 1); vk2 = (ulong) v->dst[0]; } if (v->dst[1]) { m += HASH(v->dst[1], v->to[1] - v->from[1] + 1); if ((ulong) v->dst[1] > vk2) vk2 = (ulong) v->dst[1]; } for (e = v->Succ; e; e = e->Nxt) { m += HASH(e->Dst, e->To - e->From + 1 + e->s); if ((ulong) e->Dst > vk2) vk2 = (ulong) e->Dst; } Tally = (vk2>>2)&(TWIDTH-1); return m; } static ulong mk_special(int sigma, Vertex *n, Vertex *v) { ulong m = 0, vk2 = 0; Edge *f; int i; for (i = 0; i < 2; i++) if (v->dst[i]) { if (sigma >= v->from[i] && sigma <= v->to[i]) { m += HASH(v->dst[i], v->to[i]-v->from[i]); if ((ulong) v->dst[i] > vk2 && v->to[i] > v->from[i]) vk2 = (ulong) v->dst[i]; } else { m += HASH(v->dst[i], v->to[i]-v->from[i]+1); if ((ulong) v->dst[i] > vk2) vk2 = (ulong) v->dst[i]; } } for (f = v->Succ; f; f = f->Nxt) { if (sigma >= f->From && sigma <= f->To) { m += HASH(f->Dst, f->To - f->From + f->s); if ((ulong) f->Dst > vk2 && f->To - f->From + f->s > 0) vk2 = (ulong) f->Dst; } else if (f->s == 1 && sigma == f->S) { m += HASH(f->Dst, f->To - f->From + 1); if ((ulong) f->Dst > vk2) vk2 = (ulong) f->Dst; } else { m += HASH(f->Dst, f->To - f->From + 1 + f->s); if ((ulong) f->Dst > vk2) vk2 = (ulong) f->Dst; } } if ((ulong) n > vk2) vk2 = (ulong) n; Tally = (vk2>>2)&(TWIDTH-1); m += HASH(n, 1); return m; } void dfa_init(ushort nr_layers) { int i; Vertex *r, *t; dfa_depth = nr_layers; /* one byte per layer */ path = (Vertex **) emalloc((dfa_depth+1)*sizeof(Vertex *)); layers = (Vertex **) emalloc(TWIDTH*(dfa_depth+1)*sizeof(Vertex *)); lastword = (uchar *) emalloc((dfa_depth+1)*sizeof(uchar)); lastword[dfa_depth] = lastword[0] = 255; path[0] = R = new_vertex(); F = new_vertex(); for (i = 1, r = R; i < dfa_depth; i++, r = t) t = allDelta(r, i-1); NF = allDelta(r, i-1); } #if 0 static void complement_dfa(void) { Vertex *tmp = F; F = NF; NF = tmp; } #endif double tree_stats(Vertex *t) { Edge *e; double cnt=0.0; if (!t) return 0; if (!t->key) return 0; t->key = 0; /* precaution */ if (t->dst[0]) cnt++; if (t->dst[1]) cnt++; for (e = t->Succ; e; e = e->Nxt) cnt++; cnt += tree_stats(t->lnk); cnt += tree_stats(t->left); cnt += tree_stats(t->right); return cnt; } void dfa_stats(void) { int i, j; double cnt = 0.0; for (j = 0; j < TWIDTH; j++) for (i = 0; i < dfa_depth+1; i++) cnt += tree_stats(layers[i*TWIDTH+j]); printf("Minimized Automaton: %6lu nodes and %6g edges\n", nr_states, cnt); } int dfa_member(ulong n) { Vertex **p, **q; uchar *w = &word[n]; int i; p = &path[n]; q = (p+1); for (i = n; i < dfa_depth; i++) *q++ = Delta(*p++, *w++); return (*p == F); } int dfa_store(uchar *sv) { Vertex **p, **q, *s, *y, *old, *new = F; uchar *w, *u = lastword; int i, j, k; w = word = sv; while (*w++ == *u++) /* find first byte that differs */ ; pfrst = (int) (u - lastword) - 1; memcpy(&lastword[pfrst], &sv[pfrst], dfa_depth-pfrst); if (pfrst > iv) pfrst = iv; if (pfrst > nv) pfrst = nv; /* phase1: */ p = &path[pfrst]; q = (p+1); w = &word[pfrst]; for (i = pfrst; i < dfa_depth; i++) *q++ = Delta(*p++, *w++); /* (*p)->delta[*w++]; */ if (*p == F) return 1; /* it's already there */ /* phase2: */ iv = dfa_depth; do { iv--; old = new; new = find_it(path[iv], old, word[iv], iv); } while (new && iv > 0); /* phase3: */ nv = k = 0; s = path[0]; for (j = 1; j <= iv; ++j) if (path[j]->num > 1) { y = new_vertex(); copyEdges(y, path[j]); insert_it(y, j); numDelta(y, 1); delete_it(s, j-1); setDelta(s, word[j-1], y); insert_it(s, j-1); y->num = 1; /* initial value 1 */ s = y; path[j]->num--; /* only 1 moved from j to y */ k = 1; } else { s = path[j]; if (!k) nv = j; } y = Delta(s, word[iv]); y->num--; delete_it(s, iv); setDelta(s, word[iv], old); insert_it(s, iv); old->num++; for (j = iv+1; j < dfa_depth; j++) if (path[j]->num == 0) { numDelta(path[j], -1); delete_it(path[j], j); recyc_vertex(path[j]); } else break; return 0; } static Vertex * splay(ulong i, Vertex *t) { Vertex N, *l, *r, *y; if (!t) return t; N.left = N.right = (Vertex *) 0; l = r = &N; for (;;) { if (i < t->key) { if (!t->left) break; if (i < t->left->key) { y = t->left; t->left = y->right; y->right = t; t = y; if (!t->left) break; } r->left = t; r = t; t = t->left; } else if (i > t->key) { if (!t->right) break; if (i > t->right->key) { y = t->right; t->right = y->left; y->left = t; t = y; if (!t->right) break; } l->right = t; l = t; t = t->right; } else break; } l->right = t->left; r->left = t->right; t->left = N.right; t->right = N.left; return t; } static void insert_it(Vertex *v, int L) { Vertex *new, *t; ulong i; int nr; i = mk_key(v); nr = ((L*TWIDTH)+Tally); t = layers[nr]; v->key = i; if (!t) { layers[nr] = v; return; } t = splay(i, t); if (i < t->key) { new = v; new->left = t->left; new->right = t; t->left = (Vertex *) 0; } else if (i > t->key) { new = v; new->right = t->right; new->left = t; t->right = (Vertex *) 0; } else /* it's already there */ { v->lnk = t->lnk; /* put in linked list off v */ t->lnk = v; new = t; } layers[nr] = new; } static int checkit(Vertex *h, Vertex *v, Vertex *n, uchar sigma) { Edge *g, *f; int i, k, j = 1; for (k = 0; k < 2; k++) if (h->dst[k]) { if (sigma >= h->from[k] && sigma <= h->to[k]) { if (h->dst[k] != n) goto no_match; } for (i = h->from[k]; i <= h->to[k]; i++) { if (i == sigma) continue; g = cacheDelta(v, i, j); j = 0; if (h->dst[k] != g->Dst) goto no_match; if (g->s == 0 || g->S != i) i = g->To; } } for (f = h->Succ; f; f = f->Nxt) { if (INRANGE(f,sigma)) { if (f->Dst != n) goto no_match; } for (i = f->From; i <= f->To; i++) { if (i == sigma) continue; g = cacheDelta(v, i, j); j = 0; if (f->Dst != g->Dst) goto no_match; if (g->s == 1 && i == g->S) continue; i = g->To; } if (f->s && f->S != sigma) { g = cacheDelta(v, f->S, 1); if (f->Dst != g->Dst) goto no_match; } } if (h->Succ || h->dst[0] || h->dst[1]) return 1; no_match: return 0; } static Vertex * find_it(Vertex *v, Vertex *n, uchar sigma, int L) { Vertex *z, *t; ulong i; int nr; i = mk_special(sigma,n,v); nr = ((L*TWIDTH)+Tally); t = layers[nr]; if (!t) return (Vertex *) 0; layers[nr] = t = splay(i, t); if (i == t->key) for (z = t; z; z = z->lnk) if (checkit(z, v, n, sigma)) return z; return (Vertex *) 0; } static void delete_it(Vertex *v, int L) { Vertex *x, *t; ulong i; int nr; i = cheap_key(v); nr = ((L*TWIDTH)+Tally); t = layers[nr]; if (!t) return; t = splay(i, t); if (i == t->key) { Vertex *z, *y = (Vertex *) 0; for (z = t; z && z != v; y = z, z = z->lnk) ; if (z != v) goto bad; if (y) { y->lnk = z->lnk; z->lnk = (Vertex *) 0; layers[nr] = t; return; } else if (z->lnk) /* z == t == v */ { y = z->lnk; y->left = t->left; y->right = t->right; t->left = t->right = t->lnk = (Vertex *) 0; layers[nr] = y; return; } /* delete the node itself */ if (!t->left) { x = t->right; } else { x = splay(i, t->left); x->right = t->right; } t->left = t->right = t->lnk = (Vertex *) 0; layers[nr] = x; return; } bad: Uerror("cannot happen delete"); } #endif #if defined(MA) && (defined(W_XPT) || defined(R_XPT)) static Vertex **temptree; static char wbuf[4096]; static int WCNT = 4096, wcnt=0; static uchar stacker[MA+1]; static ulong stackcnt = 0; extern double nstates, nlinks, truncs, truncs2; static void xwrite(int fd, char *b, int n) { if (wcnt+n >= 4096) { write(fd, wbuf, wcnt); wcnt = 0; } memcpy(&wbuf[wcnt], b, n); wcnt += n; } static void wclose(fd) { if (wcnt > 0) write(fd, wbuf, wcnt); wcnt = 0; close(fd); } static void w_vertex(int fd, Vertex *v) { char t[3]; int i; Edge *e; xwrite(fd, (char *) &v, sizeof(Vertex *)); t[0] = 0; for (i = 0; i < 2; i++) if (v->dst[i]) { t[1] = v->from[i], t[2] = v->to[i]; xwrite(fd, t, 3); xwrite(fd, (char *) &(v->dst[i]), sizeof(Vertex *)); } for (e = v->Succ; e; e = e->Nxt) { t[1] = e->From, t[2] = e->To; xwrite(fd, t, 3); xwrite(fd, (char *) &(e->Dst), sizeof(Vertex *)); if (e->s) { t[1] = t[2] = e->S; xwrite(fd, t, 3); xwrite(fd, (char *) &(e->Dst), sizeof(Vertex *)); } } } static void w_layer(int fd, Vertex *v) { uchar c=1; if (!v) return; xwrite(fd, (char *) &c, 1); w_vertex(fd, v); w_layer(fd, v->lnk); w_layer(fd, v->left); w_layer(fd, v->right); } void w_xpoint(void) { int fd; char nm[64]; int i, j; uchar c; static uchar xwarned = 0; sprintf(nm, "%s.xpt", PanSource); if ((fd = creat(nm, 0666)) <= 0) if (!xwarned) { xwarned = 1; printf("cannot creat checkpoint file\n"); return; } xwrite(fd, (char *) &nstates, sizeof(double)); xwrite(fd, (char *) &truncs, sizeof(double)); xwrite(fd, (char *) &truncs2, sizeof(double)); xwrite(fd, (char *) &nlinks, sizeof(double)); xwrite(fd, (char *) &dfa_depth, sizeof(int)); xwrite(fd, (char *) &R, sizeof(Vertex *)); xwrite(fd, (char *) &F, sizeof(Vertex *)); xwrite(fd, (char *) &NF, sizeof(Vertex *)); for (j = 0; j < TWIDTH; j++) for (i = 0; i < dfa_depth+1; i++) { w_layer(fd, layers[i*TWIDTH+j]); c = 2; xwrite(fd, (char *) &c, 1); } wclose(fd); } static void xread(int fd, char *b, int n) { int m = wcnt; int delta = 0; if (m < n) { if (m > 0) memcpy(b, &wbuf[WCNT-m], m); delta = m; WCNT = wcnt = read(fd, wbuf, 4096); if (wcnt < n-m) Uerror("xread failed -- insufficient data"); n -= m; } memcpy(&b[delta], &wbuf[WCNT-wcnt], n); wcnt -= n; } static void x_cleanup(Vertex *c) { Edge *e; /* remove the tree and edges from c */ if (!c) return; for (e = c->Succ; e; e = e->Nxt) x_cleanup(e->Dst); recyc_vertex(c); } static void x_remove(void) { Vertex *tmp; int i, s; int r, j; /* double-check: */ stacker[dfa_depth-1] = 0; r = dfa_store(stacker); stacker[dfa_depth-1] = 4; j = dfa_member(dfa_depth-1); if (r != 1 || j != 0) { printf("%lu: ", stackcnt); for (i = 0; i < dfa_depth; i++) printf("%d,", stacker[i]); printf(" -- not a stackstate \n", r, j); return; } stacker[dfa_depth-1] = 1; s = dfa_member(dfa_depth-1); { tmp = F; F = NF; NF = tmp; } /* complement */ if (s) dfa_store(stacker); stacker[dfa_depth-1] = 0; dfa_store(stacker); stackcnt++; { tmp = F; F = NF; NF = tmp; } } static void x_rm_stack(Vertex *t, int k) { int j; Edge *e; if (k == 0) { x_remove(); return; } if (t) for (e = t->Succ; e; e = e->Nxt) { for (j = e->From; j <= (int) e->To; j++) { stacker[k] = (uchar) j; x_rm_stack(e->Dst, k-1); } if (e->s) { stacker[k] = e->S; x_rm_stack(e->Dst, k-1); } } } static Vertex * insert_withkey(Vertex *v, int L) { Vertex *new, *t = temptree[L]; if (!t) { temptree[L] = v; return v; } t = splay(v->key, t); if (v->key < t->key) { new = v; new->left = t->left; new->right = t; t->left = (Vertex *) 0; } else if (v->key > t->key) { new = v; new->right = t->right; new->left = t; t->right = (Vertex *) 0; } else { if (t != R && t != F && t != NF) Uerror("double insert, bad checkpoint data"); else { recyc_vertex(v); new = t; } } temptree[L] = new; return new; } static Vertex * find_withkey(Vertex *v, int L) { Vertex *t = temptree[L]; if (t) { temptree[L] = t = splay((ulong) v, t); if (t->key == (ulong) v) return t; } Uerror("not found error, bad checkpoint data"); return (Vertex *) 0; } void r_layer(int fd, int n) { Vertex *v; Edge *e; char c, t[2]; for (;;) { xread(fd, &c, 1); if (c == 2) break; if (c == 1) { v = new_vertex(); xread(fd, (char *) &(v->key), sizeof(Vertex *)); v = insert_withkey(v, n); } else /* c == 0 */ { e = new_edge((Vertex *) 0); xread(fd, t, 2); e->From = t[0]; e->To = t[1]; xread(fd, (char *) &(e->Dst), sizeof(Vertex *)); insert_edge(v, e); } } } static void v_fix(Vertex *t, int nr) { int i; Edge *e; if (!t) return; for (i = 0; i < 2; i++) if (t->dst[i]) t->dst[i] = find_withkey(t->dst[i], nr); for (e = t->Succ; e; e = e->Nxt) e->Dst = find_withkey(e->Dst, nr); v_fix(t->left, nr); v_fix(t->right, nr); } static void v_insert(Vertex *t, int nr) { Edge *e; int i; if (!t) return; v_insert(t->left, nr); v_insert(t->right, nr); /* remove only leafs from temptree */ t->left = t->right = t->lnk = (Vertex *) 0; insert_it(t, nr); /* into layers */ for (i = 0; i < 2; i++) if (t->dst[i]) t->dst[i]->num += (t->to[i] - t->from[i] + 1); for (e = t->Succ; e; e = e->Nxt) e->Dst->num += (e->To - e->From + 1 + e->s); } static void x_fixup(void) { int i; for (i = 0; i < dfa_depth; i++) v_fix(temptree[i], (i+1)); for (i = dfa_depth; i >= 0; i--) v_insert(temptree[i], i); } static Vertex * x_tail(Vertex *t, ulong want) { int i, yes, no; Edge *e; Vertex *v = (Vertex *) 0; if (!t) return v; yes = no = 0; for (i = 0; i < 2; i++) if ((ulong) t->dst[i] == want) { /* was t->from[i] <= 0 && t->to[i] >= 0 */ /* but from and to are uchar */ if (t->from[i] == 0) yes = 1; else if (t->from[i] <= 4 && t->to[i] >= 4) no = 1; } for (e = t->Succ; e; e = e->Nxt) if ((ulong) e->Dst == want) { /* was INRANGE(e,0) but From and To are uchar */ if ((e->From == 0) || (e->s==1 && e->S==0)) yes = 1; else if (INRANGE(e, 4)) no = 1; } if (yes && !no) return t; v = x_tail(t->left, want); if (v) return v; v = x_tail(t->right, want); if (v) return v; return (Vertex *) 0; } static void x_anytail(Vertex *t, Vertex *c, int nr) { int i; Edge *e, *f; Vertex *v; if (!t) return; for (i = 0; i < 2; i++) if ((ulong) t->dst[i] == c->key) { v = new_vertex(); v->key = t->key; f = new_edge(v); f->From = t->from[i]; f->To = t->to[i]; f->Nxt = c->Succ; c->Succ = f; if (nr > 0) x_anytail(temptree[nr-1], v, nr-1); } for (e = t->Succ; e; e = e->Nxt) if ((ulong) e->Dst == c->key) { v = new_vertex(); v->key = t->key; f = new_edge(v); f->From = e->From; f->To = e->To; f->s = e->s; f->S = e->S; f->Nxt = c->Succ; c->Succ = f; x_anytail(temptree[nr-1], v, nr-1); } x_anytail(t->left, c, nr); x_anytail(t->right, c, nr); } static Vertex * x_cpy_rev(void) { Vertex *c, *v; /* find 0 and !4 predecessor of F */ v = x_tail(temptree[dfa_depth-1], F->key); if (!v) return (Vertex *) 0; c = new_vertex(); c->key = v->key; /* every node on dfa_depth-2 that has v->key as succ */ /* make copy and let c point to these (reversing ptrs) */ x_anytail(temptree[dfa_depth-2], c, dfa_depth-2); return c; } void r_xpoint(void) { int fd; char nm[64]; Vertex *d; int i, j; wcnt = 0; sprintf(nm, "%s.xpt", PanSource); if ((fd = open(nm, 0)) < 0) /* O_RDONLY */ Uerror("cannot open checkpoint file"); xread(fd, (char *) &nstates, sizeof(double)); xread(fd, (char *) &truncs, sizeof(double)); xread(fd, (char *) &truncs2, sizeof(double)); xread(fd, (char *) &nlinks, sizeof(double)); xread(fd, (char *) &dfa_depth, sizeof(int)); if (dfa_depth != MA+a_cycles) Uerror("bad dfa_depth in checkpoint file"); path = (Vertex **) emalloc((dfa_depth+1)*sizeof(Vertex *)); layers = (Vertex **) emalloc(TWIDTH*(dfa_depth+1)*sizeof(Vertex *)); temptree = (Vertex **) emalloc((dfa_depth+2)*sizeof(Vertex *)); lastword = (uchar *) emalloc((dfa_depth+1)*sizeof(uchar)); lastword[dfa_depth] = lastword[0] = 255; path[0] = R = new_vertex(); xread(fd, (char *) &R->key, sizeof(Vertex *)); R = insert_withkey(R, 0); F = new_vertex(); xread(fd, (char *) &F->key, sizeof(Vertex *)); F = insert_withkey(F, dfa_depth); NF = new_vertex(); xread(fd, (char *) &NF->key, sizeof(Vertex *)); NF = insert_withkey(NF, dfa_depth); for (j = 0; j < TWIDTH; j++) for (i = 0; i < dfa_depth+1; i++) r_layer(fd, i); if (wcnt != 0) Uerror("bad count in checkpoint file"); d = x_cpy_rev(); x_fixup(); stacker[dfa_depth-1] = 0; x_rm_stack(d, dfa_depth-2); x_cleanup(d); close(fd); printf("pan: removed %lu stackstates\n", stackcnt); nstates -= (double) stackcnt; } #endif void c_globals(void) { /* int i; */ printf("global vars:\n"); } void c_locals(int pid, int tp) { /* int i; */ switch(tp) { case 0: printf("local vars proc %d (loop):\n", pid); printf(" byte a: %d\n", ((P0 *)pptr(pid))->a); printf(" byte b: %d\n", ((P0 *)pptr(pid))->b); break; } } void printm(int x) { switch (x) { default: Printf("%d", x); } } void c_chandump(int unused) { unused++; /* avoid complaints */ } Trans *t_id_lkup[12]; #ifdef BFS_PAR #include "pan.p" #endif /* end of pan.c */ Spin/Examples/pan.h0000664000175100017510000003677112636050452012277 0ustar ghgh#ifndef PAN_H #define PAN_H #define SpinVersion "Spin Version 6.4.5 -- 4 November 2015" #define PanSource "loops.pml" #define G_long 8 #define G_int 4 #define ulong unsigned long #define ushort unsigned short #ifdef WIN64 #define ONE_L (1L) /* #define long long long */ #else #define ONE_L (1L) #endif #ifdef BFS_PAR #define NRUNS 0 #ifndef BFS #define BFS #endif #ifndef PUTPID #define PUTPID #endif #if !defined(USE_TDH) && !defined(NO_TDH) #define USE_TDH #endif #if defined(USE_TDH) && !defined(NO_HC) #define HC /* default for USE_TDH */ #endif #ifndef BFS_MAXPROCS #define BFS_MAXPROCS 64 /* max nr of cores to use */ #endif #define BFS_GLOB 0 /* global lock */ #define BFS_ORD 1 /* used with -DCOLLAPSE */ #define BFS_MEM 2 /* malloc from shared heap */ #define BFS_PRINT 3 /* protect printfs */ #define BFS_STATE 4 /* hashtable */ #define BFS_INQ 2 /* state is in q */ #ifdef BFS_FIFO #define BFS_ID(a,b) (BFS_STATE + (int) ((a)*BFS_MAXPROCS+(b))) #define BFS_MAXLOCKS (BFS_STATE + (BFS_MAXPROCS*BFS_MAXPROCS)) #else #ifndef BFS_W #define BFS_W 10 #endif #define BFS_MASK ((1<1 && !defined(SEP_STATE) #define SEP_STATE #endif #if MA==1 #undef MA #define MA 100 #endif #endif #ifdef W_XPT #if W_XPT==1 #undef W_XPT #define W_XPT 1000000 #endif #endif #ifndef NFAIR #define NFAIR 2 /* must be >= 2 */ #endif #define HAS_CODE 1 #if defined(RANDSTORE) && !defined(RANDSTOR) #define RANDSTOR RANDSTORE #endif #define MERGED 1 #if !defined(HAS_LAST) && defined(BCS) #define HAS_LAST 1 /* use it, but */ #ifndef STORE_LAST #define NO_LAST 1 /* dont store it */ #endif #endif #if defined(BCS) && defined(BITSTATE) #ifndef NO_CTX #define STORE_CTX 1 #endif #endif #ifdef NP #define HAS_NP 2 #define VERI 1 /* np_ */ #endif typedef struct S_F_MAP { char *fnm; int from; int upto; } S_F_MAP; #define nstates0 13 /* loop */ #define minseq0 0 #define maxseq0 11 #define endstate0 12 extern short src_ln0[]; extern S_F_MAP src_file0[]; #define T_ID unsigned char #define _T5 8 #define _T2 9 #define WS 8 /* word size in bytes */ #define SYNC 0 #define ASYNC 0 #ifndef NCORE #ifdef DUAL_CORE #define NCORE 2 #elif QUAD_CORE #define NCORE 4 #else #define NCORE 1 #endif #endif #define Ploop ((P0 *)this) typedef struct P0 { /* loop */ unsigned _pid : 8; /* 0..255 */ unsigned _t : 2; /* proctype */ unsigned _p : 5; /* state */ #ifdef HAS_PRIORITY unsigned _priority : 8; /* 0..255 */ #endif uchar a; uchar b; } P0; #define Air0 (sizeof(P0) - Offsetof(P0, b) - 1*sizeof(uchar)) typedef struct P1 { /* np_ */ unsigned _pid : 8; /* 0..255 */ unsigned _t : 2; /* proctype */ unsigned _p : 5; /* state */ #ifdef HAS_PRIORITY unsigned _priority : 8; /* 0..255 */ #endif } P1; #define Air1 (sizeof(P1) - 2) #define Pclaim P0 #ifndef NCLAIMS #define NCLAIMS 1 #endif #if defined(BFS) && defined(REACH) #undef REACH #endif #ifdef VERI #define BASE 1 #else #define BASE 0 #endif typedef struct Trans { short atom; /* if &2 = atomic trans; if &8 local */ #ifdef HAS_UNLESS short escp[HAS_UNLESS]; /* lists the escape states */ short e_trans; /* if set, this is an escp-trans */ #endif short tpe[2]; /* class of operation (for reduction) */ short qu[6]; /* for conditional selections: qid's */ uchar ty[6]; /* ditto: type's */ #ifdef NIBIS short om; /* completion status of preselects */ #endif char *tp; /* src txt of statement */ int st; /* the nextstate */ int t_id; /* transition id, unique within proc */ int forw; /* index forward transition */ int back; /* index return transition */ struct Trans *nxt; } Trans; #ifdef TRIX #define qptr(x) (channels[x]->body) #define pptr(x) (processes[x]->body) #else #define qptr(x) (((uchar *)&now)+(int)q_offset[x]) #define pptr(x) (((uchar *)&now)+(int)proc_offset[x]) #endif extern uchar *Pptr(int); extern uchar *Qptr(int); #define q_sz(x) (((Q0 *)qptr(x))->Qlen) #ifdef TRIX #ifdef VECTORSZ #undef VECTORSZ #endif #if WS==4 #define VECTORSZ 2056 /* ((MAXPROC+MAXQ+4)*sizeof(uchar *)) */ #else #define VECTORSZ 4112 /* the formula causes probs in preprocessing */ #endif #else #ifndef VECTORSZ #define VECTORSZ 1024 /* sv size in bytes */ #endif #endif #define MAXQ 255 #define MAXPROC 255 #ifdef VERBOSE #ifndef CHECK #define CHECK #endif #ifndef DEBUG #define DEBUG #endif #endif #ifdef SAFETY #ifndef NOFAIR #define NOFAIR #endif #endif #ifdef NOREDUCE #ifndef XUSAFE #define XUSAFE #endif #if !defined(SAFETY) && !defined(MA) #define FULLSTACK #endif #else #ifdef BITSTATE #if defined(SAFETY) && WS<=4 #define CNTRSTACK #else #define FULLSTACK #endif #else #define FULLSTACK #endif #endif #ifdef BITSTATE #ifndef NOCOMP #define NOCOMP #endif #if !defined(LC) && defined(SC) #define LC #endif #endif #if defined(COLLAPSE2) || defined(COLLAPSE3) || defined(COLLAPSE4) /* accept the above for backward compatibility */ #define COLLAPSE #endif #ifdef HC #undef HC #define HC4 #endif #if defined(HC0) || defined(HC1) || defined(HC2) || defined(HC3) || defined(HC4) #define HC 4 #endif typedef struct _Stack { /* for queues and processes */ #if VECTORSZ>32000 int o_delta; #ifndef TRIX int o_offset; int o_skip; #endif int o_delqs; #else short o_delta; #ifndef TRIX short o_offset; short o_skip; #endif short o_delqs; #endif short o_boq; #ifdef TRIX short parent; char *b_ptr; #else char *body; #endif #ifndef XUSAFE char *o_name; #endif struct _Stack *nxt; struct _Stack *lst; } _Stack; typedef struct Svtack { /* for complete state vector */ #if VECTORSZ>32000 int o_delta; int m_delta; #else short o_delta; /* current size of frame */ short m_delta; /* maximum size of frame */ #endif #if SYNC short o_boq; #endif #define StackSize (WS) char *body; struct Svtack *nxt; struct Svtack *lst; } Svtack; typedef struct State { uchar _nr_pr; uchar _nr_qs; uchar _a_t; /* cycle detection */ #ifndef NOFAIR uchar _cnt[NFAIR]; /* counters, weak fairness */ #endif #ifndef NOVSZ #if VECTORSZ<65536 unsigned short _vsz; #else ulong _vsz; #endif #endif #ifdef HAS_LAST uchar _last; /* pid executed in last step */ #endif #if defined(BITSTATE) && defined(BCS) && defined(STORE_CTX) uchar _ctx; /* nr of context switches so far */ #endif #if defined(BFS_PAR) && defined(L_BOUND) uchar _l_bnd; /* bounded liveness */ uchar *_l_sds; /* seed state */ #endif #ifdef EVENT_TRACE #if nstates_event<256 uchar _event; #else unsigned short _event; #endif #endif #ifdef TRIX /* room for 512 proc+chan ptrs, + safety margin */ char *_ids_[MAXPROC+MAXQ+4]; #else uchar sv[VECTORSZ]; #endif } State; #ifdef TRIX typedef struct TRIX_v6 { uchar *body; /* aligned */ #ifndef BFS short modified; #endif short psize; short parent_pid; struct TRIX_v6 *nxt; } TRIX_v6; #endif #define HAS_TRACK 0 #define FORWARD_MOVES "pan.m" #define BACKWARD_MOVES "pan.b" #define TRANSITIONS "pan.t" #define _NP_ 1 #define nstates1 3 /* np_ */ #define endstate1 2 /* np_ */ #define start1 0 /* np_ */ #define start0 9 #ifdef NP #define ACCEPT_LAB 1 /* at least 1 in np_ */ #else #define ACCEPT_LAB 1 /* user-defined accept labels */ #endif #ifdef MEMCNT #ifdef MEMLIM #warning -DMEMLIM takes precedence over -DMEMCNT #undef MEMCNT #else #if MEMCNT<20 #warning using minimal value -DMEMCNT=20 (=1MB) #define MEMLIM (1) #undef MEMCNT #else #if MEMCNT==20 #define MEMLIM (1) #undef MEMCNT #else #if MEMCNT>=50 #error excessive value for MEMCNT #else #define MEMLIM (1<<(MEMCNT-20)) #endif #endif #endif #endif #endif #if NCORE>1 && !defined(MEMLIM) #define MEMLIM (2048) /* need a default, using 2 GB */ #endif #define PROG_LAB 1 /* progress labels */ #define NQS 0 typedef struct Q0 { /* generic q */ uchar Qlen; /* q_size */ uchar _t; } Q0; /** function prototypes **/ char *emalloc(ulong); char *Malloc(ulong); int Boundcheck(int, int, int, int, Trans *); int addqueue(int, int, int); /* int atoi(char *); */ /* int abort(void); */ int close(int); int delproc(int, int); int endstate(void); int find_claim(char *); int h_store(char *, int); int pan_rand(void); int q_cond(short, Trans *); int q_full(int); int q_len(int); int q_zero(int); int qrecv(int, int, int, int); int unsend(int); /* void *sbrk(int); */ void spin_assert(int, char *, int, int, Trans *); #ifdef BFS_PAR void bfs_printf(const char *, ...); volatile uchar *sh_pre_malloc(ulong); #endif void c_chandump(int); void c_globals(void); void c_locals(int, int); void checkcycles(void); void crack(int, int, Trans *, short *); void d_sfh(uchar *, int); void d_hash(uchar *, int); void m_hash(uchar *, int); void s_hash(uchar *, int); void delq(int); void dot_crack(int, int, Trans *); void do_reach(void); void pan_exit(int); void exit(int); #ifdef BFS_PAR void bfs_setup_mem(void); #endif #ifdef BITSTATE void sinit(void); #else void hinit(void); #endif void imed(Trans *, int, int, int); void new_state(void); void p_restor(int); void putpeg(int, int); void putrail(void); void q_restor(void); void retrans(int, int, int, short *, uchar *, uchar *); void select_claim(int); void settable(void); void setq_claim(int, int, char *, int, char *); void sv_restor(void); void sv_save(void); void tagtable(int, int, int, short *, uchar *); void do_dfs(int, int, int, short *, uchar *, uchar *); void unrecv(int, int, int, int, int); void usage(FILE *); void wrap_stats(void); #ifdef MA int g_store(char *, int, uchar); #endif #if defined(FULLSTACK) && defined(BITSTATE) int onstack_now(void); void onstack_init(void); void onstack_put(void); void onstack_zap(void); #endif #ifndef XUSAFE int q_S_check(int, int); int q_R_check(int, int); uchar q_claim[MAXQ+1]; char *q_name[MAXQ+1]; char *p_name[MAXPROC+1]; #endif #ifndef NO_V_PROVISO #define V_PROVISO #endif #if !defined(NO_RESIZE) && !defined(AUTO_RESIZE) && !defined(BITSTATE) && !defined(SPACE) && !defined(USE_TDH) && NCORE==1 #define AUTO_RESIZE #endif typedef struct Trail Trail; typedef struct H_el H_el; struct H_el { H_el *nxt; #ifdef FULLSTACK unsigned int tagged; #if defined(BITSTATE) && !defined(NOREDUCE) && !defined(SAFETY) unsigned int proviso; #endif #endif #if defined(CHECK) || (defined(COLLAPSE) && !defined(FULLSTACK)) ulong st_id; #endif #if !defined(SAFETY) || defined(REACH) uint D; #endif #ifdef BCS #ifndef CONSERVATIVE #define CONSERVATIVE 1 /* good for up to 8 processes */ #endif #ifdef CONSERVATIVE #if CONSERVATIVE <= 0 || CONSERVATIVE>32 #error sensible values for CONSERVATIVE are 1..32 (256/8 = 32) #endif uchar ctx_pid[CONSERVATIVE]; #endif uchar ctx_low; #endif #if NCORE>1 /* could cost 1 extra word: 4 bytes if 32-bit and 8 bytes if 64-bit */ #ifdef V_PROVISO uchar cpu_id; /* id of cpu that created the state */ #endif #endif #ifdef COLLAPSE #if VECTORSZ<65536 ushort ln; #else ulong ln; #endif #endif #if defined(AUTO_RESIZE) && !defined(BITSTATE) ulong m_K1; #endif ulong state; }; #ifdef BFS_PAR typedef struct BFS_Trail BFS_Trail; struct BFS_Trail { H_el *ostate; int st; int o_tt; T_ID t_id; uchar pr; uchar o_pm; uchar tau; }; #if SYNC>0 #undef BFS_NOTRAIL #endif #endif #ifdef RHASH #ifndef PERMUTED #define PERMUTED #endif #endif struct Trail { int st; /* current state */ int o_tt; #ifdef PERMUTED uint seed; uchar oII; #endif uchar pr; /* process id */ uchar tau; /* 8 bit-flags */ uchar o_pm; /* 8 more bit-flags */ #if 0 Meaning of bit-flags on tau and o_pm: tau&1 -> timeout enabled tau&2 -> request to enable timeout 1 level up (in claim) tau&4 -> current transition is a claim move tau&8 -> current transition is an atomic move tau&16 -> last move was truncated on stack tau&32 -> current transition is a preselected move tau&64 -> at least one next state is not on the stack tau&128 -> current transition is a stutter move o_pm&1 -> the current pid moved -- implements else o_pm&2 -> this is an acceptance state o_pm&4 -> this is a progress state o_pm&8 -> fairness alg rule 1 undo mark o_pm&16 -> fairness alg rule 3 undo mark o_pm&32 -> fairness alg rule 2 undo mark o_pm&64 -> the current proc applied rule2 o_pm&128 -> a fairness, dummy move - all procs blocked #endif #ifdef NSUCC uchar n_succ; /* nr of successor states */ #endif #if defined(FULLSTACK) && defined(MA) && !defined(BFS) uchar proviso; #endif #ifndef BFS uchar o_n, o_ot; /* to save locals */ #endif uchar o_m; #ifdef EVENT_TRACE #if nstates_event<256 uchar o_event; #else unsigned short o_event; #endif #endif #ifndef BFS short o_To; #if defined(T_RAND) || defined(RANDOMIZE) short oo_i; #endif #endif #if defined(HAS_UNLESS) && !defined(BFS) int e_state; /* if escape trans - state of origin */ #endif #if (defined(FULLSTACK) && !defined(MA)) || defined(BFS) || (NCORE>1) H_el *ostate; /* pointer to stored state */ #endif #if defined(CNTRSTACK) && !defined(BFS) long j6, j7; #endif Trans *o_t; #if !defined(BFS) && !defined(TRIX_ORIG) char *p_bup; char *q_bup; #endif #ifdef BCS unsigned short sched_limit; unsigned char bcs; /* phase 1 or 2, or forced 4 */ unsigned char b_pno; /* preferred pid */ #endif #ifdef P_RAND unsigned char p_left; /* nr of procs left to explore */ short p_skip; /* to find starting point in list */ #endif #ifdef HAS_SORTED short ipt; #endif #ifdef HAS_PRIORITY short o_priority; #endif union { int oval; int *ovals; } bup; }; /* end of struct Trail */ #ifdef BFS #define Q_PROVISO #ifndef INLINE_REV #define INLINE_REV #endif typedef struct SV_Hold { State *sv; #ifndef BFS_PAR int sz; #endif struct SV_Hold *nxt; } SV_Hold; #if !defined(BFS_PAR) || NRUNS>0 typedef struct EV_Hold { #if !defined(BFS_PAR) || (!defined(NOCOMP) && !defined(HC) && NRUNS>0) char *sv; /* Mask */ #endif #if VECTORSZ<65536 ushort sz; /* vsize */ #else ulong sz; #endif #ifdef BFS_PAR uchar owner; #endif uchar nrpr; uchar nrqs; #if !defined(BFS_PAR) || (!defined(TRIX) && NRUNS>0) char *po, *qo; char *ps, *qs; #endif struct EV_Hold *nxt; } EV_Hold; #endif typedef struct BFS_State { #ifdef BFS_PAR BFS_Trail *t_info; State *osv; #else Trail *frame; SV_Hold *onow; #endif #if !defined(BFS_PAR) || NRUNS>0 EV_Hold *omask; #endif #if defined(Q_PROVISO) && !defined(NOREDUCE) H_el *lstate; #endif #if !defined(BFS_PAR) || SYNC>0 short boq; #endif #ifdef VERBOSE ulong nr; #endif #ifndef BFS_PAR struct BFS_State *nxt; #endif } BFS_State; #endif void qsend(int, int, int); #define Addproc(x,y) addproc(256, y, x) #define LOCAL 1 #define Q_FULL_F 2 #define Q_EMPT_F 3 #define Q_EMPT_T 4 #define Q_FULL_T 5 #define TIMEOUT_F 6 #define GLOBAL 7 #define BAD 8 #define ALPHA_F 9 #define NTRANS 10 #if defined(BFS_PAR) || NCORE>1 void e_critical(int); void x_critical(int); #ifdef BFS_PAR void bfs_main(int, int); void bfs_report_mem(void); #endif #endif /* end of PAN_H */ #endif Spin/Examples/cambridge.pml0000644000175100017510000001007112331230255013747 0ustar ghgh#if 0 Cambridge Ring Protocol [Needham 82] basic protocol - no LTL properties LOSS RELAXED states depth 0 0 482,061 9,232 no reduction 1 0 993,547 10,234 no reduction 0 1 629,079 18,268 no reduction 1 1 1,252,660 17,117 no reduction #endif #define LOSS 1 #define RELAXED 1 #if RELAXED==1 #define stimeout empty(sender) #define rtimeout empty(recv) #else #define stimeout timeout #define rtimeout timeout #endif #define QSZ 6 /* length of message queues - should be 6 */ mtype = { RDY, NOTRDY, DATA, NODATA, RESET }; chan sender = [QSZ] of { mtype, byte }; chan recv = [QSZ] of { mtype, byte }; active proctype Sender() { short n = -1; byte t,m; xr sender; xs recv; I: /* Idle State */ do #if LOSS==1 :: sender?_,_ -> progress2: skip #endif :: sender?RESET,0 -> ackreset: recv!RESET,0; /* stay in idle */ n = -1; goto I /* E-rep: protocol error */ :: sender?RDY,m -> /* E-exp */ assert(m == (n+1)%4); advance: n = (n+1)%4; if /* buffer */ :: atomic { printf("MSC: NEW\n"); recv!DATA,n; goto E } /* no buffer */ :: recv!NODATA,n; goto N fi :: sender?NOTRDY,m -> /* N-exp */ expected: assert(m == (n+1)%4); goto I /* Timeout */ /* ignored (p.154, in [Needham'82]) */ :: goto reset od; E: /* Essential element sent, ack expected */ do #if LOSS==1 :: sender?_,_ -> progress0: skip #endif :: sender?RESET,0 -> goto ackreset :: sender?RDY,m -> if :: (m == n) -> /* E-rep */ goto retrans :: (m == (n+1)%4) -> /* E-exp */ goto advance fi :: sender?NOTRDY,m -> /* N-exp */ goto expected /* Timeout */ :: stimeout -> printf("MSC: STO\n"); retrans: recv!DATA,n /* retransmit */ :: goto reset od; N: /* Non-essential element sent */ do #if LOSS==1 :: sender?_,_ -> progress1: skip #endif :: sender?RESET,0 -> goto ackreset :: sender?RDY,m -> /* E-rep */ assert(m == n) /* E-exp: protocol error */ -> recv!NODATA,n /* retransmit and stay in N */ :: recv!DATA,n; /* buffer ready event */ goto E :: goto reset /* Timeout */ /* ignored (p.154, in [Needham'82]) */ od; reset: recv!RESET,0; do #if LOSS==1 :: sender?_,_ -> progress3: skip #endif :: sender?t,m -> if :: t == RESET -> n = -1; goto I :: else /* ignored, p. 152 */ fi :: timeout -> /* a real timeout */ goto reset od } active proctype Receiver() { byte t, n, m, Nexp; xr recv; xs sender; I: /* Idle State */ do #if LOSS==1 :: recv?_,_ -> progress2: skip #endif :: recv?RESET,0 -> ackreset: sender!RESET,0; /* stay in idle */ n = 0; Nexp = 0; goto I :: atomic { recv?DATA(m) -> /* E-exp */ assert(m == n); advance: printf("MSC: EXP\n"); n = (n+1)%4; assert(m == Nexp); Nexp = (m+1)%4; if :: sender!RDY,n; goto E :: sender!NOTRDY,n; goto N fi } :: recv?NODATA(m) -> /* N-exp */ assert(m == n) /* Timeout: ignored */ /* only receiver can initiate transfer; p. 156 */ :: empty(recv) -> sender!RDY,n; goto E :: goto reset od; E: do #if LOSS==1 :: recv?_,_ -> progress1: skip #endif :: recv?RESET,0 -> goto ackreset :: atomic { recv?DATA(m) -> if :: ((m+1)%4 == n) -> /* E-rep */ printf("MSC: REP\n"); goto retrans :: (m == n) -> /* E-exp */ goto advance fi } :: recv?NODATA(m) -> /* N-exp */ assert(m == n); goto I :: rtimeout -> printf("MSC: RTO\n"); retrans: sender!RDY,n; goto E :: goto reset od; N: do #if LOSS==1 :: recv?_,_ -> progress0: skip #endif :: recv?RESET,0 -> goto ackreset :: recv?DATA(m) -> /* E-rep */ assert((m+1)%4 == n); /* E-exp and N-exp: protocol error */ printf("MSC: REP\n"); sender!NOTRDY,n /* retransmit and stay in N */ :: sender!RDY,n -> /* buffer ready event */ goto E /* Timeout: ignored */ :: goto reset od; progress: reset: sender!RESET,0; do #if LOSS==1 :: recv?_,_ -> progress3: skip #endif :: recv?t,m -> if :: t == RESET -> n = 0; Nexp = 0; goto I :: else /* ignored, p. 152 */ fi :: timeout -> /* a real timeout */ goto reset od } Spin/Examples/abp.pml0000644000175100017510000000133711676656747012636 0ustar ghgh/* * a simple example of the use of inline's * (requires Spin version 3.2 or later) * */ mtype = { msg0, msg1, ack0, ack1 }; chan sender = [1] of { mtype }; chan receiver = [1] of { mtype }; inline phase(msg, good_ack, bad_ack) { do :: sender?good_ack -> break :: sender?bad_ack :: timeout -> if :: receiver!msg; :: skip /* lose message */ fi; od } inline recv(cur_msg, cur_ack, lst_msg, lst_ack) { do :: receiver?cur_msg -> sender!cur_ack; break /* accept */ :: receiver?lst_msg -> sender!lst_ack od; } active proctype Sender() { do :: phase(msg1, ack1, ack0); phase(msg0, ack0, ack1) od } active proctype Receiver() { do :: recv(msg1, ack1, msg0, ack0); recv(msg0, ack0, msg1, ack1) od } Spin/Examples/dtp.pml0000644000175100017510000001327712331230353012633 0ustar ghgh mtype = { /*1*/ ack, /*2*/ can, /*3*/ crcck, /* checksum error */ /*4*/ data8, /*5*/ last8, /*6*/ nak, /*7*/ query8, /*8*/ rvnak, /*9*/ zak }; chan StoC = [2] of { short, short }; chan CtoR = [2] of { short, short }; chan RtoC = [2] of { short, short }; chan RtoS = [2] of { short, short }; init { atomic { run sender(RtoS, StoC); run channel(StoC, CtoR); run receiver(CtoR, RtoS) } } proctype channel(chan inp, out) { short a, b; byte cnt; xr inp; xs out; end: do :: inp?a,b -> if :: out!a,b :: (cnt == 0 && a != zak) -> cnt = cnt+1; out!crcck,b /* :: (cnt == 0) -> cnt = cnt+1; out!-3,a :: (cnt == 0) -> cnt = cnt+1; out!-1,a :: (cnt == 0) -> cnt = cnt+1; out!-2,a :: (cnt == 0) -> cnt = cnt+1; out!-4,a */ fi od } proctype sender(chan inp, out) { bit rcvrrdy; short state, queryt, datat, lastt; short t, type; short seqno, toff, offset, cnt, retries, maxretries; xs out; start: atomic { offset = 0; retries = 0; maxretries = 6; rcvrrdy = 0; state = 2; datat = data8; queryt = query8; lastt = last8; goto s1 }; s1: if /* if we received an interrupt for incoming data */ :: (len(inp) > 0) -> state = 2 :: (len(inp) == 0) fi; goto s2; s2: if :: (state == 0) -> goto s3 :: (state == 1) -> goto s4 :: (state == 2) -> goto s7 :: (state >= 3) -> goto s1 fi; s3: out!queryt,offset; state = 2; goto s1; s4: atomic { if :: (offset < 3) -> type = datat :: (offset > 2) -> type = lastt fi; if :: (retries > 0) -> type = queryt :: (retries <= 0) fi }; out!type,offset; /* it can fail, but ignore that */ goto s6; s5: out!can,-1; goto F; s6: atomic { offset = offset + 1; /* assume cnt > 0 */ if /* :: goto s5 /* channel disconnected */ :: (type == queryt || type == lastt) -> state = 2 :: !(type == queryt || type == lastt) fi; goto s1 }; s7: atomic { inp?t,seqno; if :: (t == zak) -> goto s8 :: (t == ack) -> goto s9 :: (t == nak) -> goto s12 :: (t == -2) -> goto F /* remote canceled */ :: (t == -3) -> goto s13 /* serial port overrun or timeout */ :: (t == crcck) -> goto s13 :: !(t == zak || t == ack || t == nak || t == -2 || t == -3 || t == crcck) -> goto s5 fi }; s8: offset = seqno; out!zak,offset; goto S; s9: toff = seqno; goto s10; s10: atomic { retries = 0; if :: (offset > toff) -> /* worthless ack */ goto s1 :: (offset <= toff) -> offset = toff; goto s11 fi }; s11: atomic { if :: (!rcvrrdy) -> rcvrrdy = 1; maxretries = 5; /* ack/nak received - start transmit */ retries = 0 :: (rcvrrdy) -> skip fi; state = 1; goto s1 }; s12: atomic { toff = seqno; if :: (toff >= offset) -> goto s10 :: (toff < offset) fi; retries = retries+1; if :: (retries >= maxretries) -> goto s5 :: (retries < maxretries) fi; offset = toff; goto s11 }; s13: atomic { if :: (retries >= maxretries) -> goto s5 :: (retries < maxretries) -> if :: (rcvrrdy) -> state = 1 :: (!rcvrrdy) -> state = 0 fi; goto s1 fi }; F: /* failure */ assert(0); S: /* success */ skip; end: do :: inp?t,seqno od } proctype receiver(chan inp, out) { short state, lasttyp; short offset, retries, lastack; short readStat, cnt, seqno; short rtype, type; short respreq, typ; xr inp; start: atomic { offset = 0; state = 0; lasttyp = 0; retries = 0; lastack = 0; rtype = nak; readStat = 0; goto s4 }; s2: if :: (readStat == -1 || readStat == -2 || readStat == -4) -> goto F :: (readStat == -3) -> goto s3 :: (readStat >= 0) -> goto s4 fi; s3: atomic { if /* :: rtype == rvnak -> goto s4 /* too soon */ :: skip fi; retries = retries+1 }; if :: (retries >= 7) -> out!can,-1; goto F :: (retries < 7) -> skip fi; atomic { if :: (retries == 0) -> /* how can it be zero ever? */ state = 3 :: (retries != 0) -> state = 0 /* send nak state */ fi; goto s4 }; s4: if :: (state == 0) -> goto s5 :: (state == 1) -> goto s6 :: (state == 2) -> goto s12 :: (state >= 3) -> goto S fi; s5: out!rtype,offset; state = 1; goto s4; s6: atomic { inp?type,seqno; rtype = nak; /* was: rtype = rvnak */ typ = ack; if :: ( type == -1 || type == -2) -> goto s7 :: ( type == -3 || type == crcck) -> goto s3 :: ( type == -4) -> goto s11 :: ( type == last8) -> goto s8 :: ( type == query8) -> goto s9 :: ( type == data8) -> goto s10 :: !( type == -1 || type == -2 || type == -3 || type == crcck || type == -4 || type == last8 || type == query8 || type == data8) -> goto s11 fi }; s7: readStat = type; goto s2; s8: atomic { typ = zak; state = 2; goto s9 }; s9: atomic { rtype = nak; respreq = 1; goto s10 }; s10: atomic { if :: (seqno > offset) -> goto s3 :: (seqno == offset) -> cnt = 1 :: (seqno < offset) -> cnt = 0 fi; if :: (cnt < 0) -> readStat = cnt; goto s2 :: (cnt >= 0) -> skip fi; offset = offset + cnt }; if :: (respreq) -> out!typ,offset; lastack = offset; lasttyp = typ :: !(respreq) -> skip fi; atomic { if :: (typ == zak) -> retries = -2 :: (typ != zak) -> retries = 2 fi; goto s4 }; s11: out!can,-1; goto F; s12: atomic { inp?type,seqno; if :: (type == -1) -> goto s13 :: (type == -3) -> goto s13 :: (type == -2) -> goto s11 :: (type == -4) -> goto s11 :: (type == query8 || type == last8 || type == data8 || type == crcck) -> goto s14 :: !(type == -1 || type == -3 || type == -2 || type == -4 || type == query8 || type == last8 || type == data8 || type == crcck) -> goto S fi }; s13: readStat = type; goto s2; s14: out!lasttyp,lastack; retries = -2; goto s4; F: assert(0); S: skip; end: do :: inp?type,seqno od } Spin/Examples/Book_1991/0000775000175100017510000000000012331225445012705 5ustar ghghSpin/Examples/Book_1991/p96.1.pml0000644000175100017510000000022311476234213014171 0ustar ghghbyte state = 1; proctype A() { (state == 1) -> state = state + 1 } proctype B() { (state == 1) -> state = state - 1 } init { run A(); run B() } Spin/Examples/Book_1991/p347.pftp.ses5.pml0000644000175100017510000000055211476261230015743 0ustar ghgh/* * PROMELA Validation Model * Session Layer */ #include "p337.defines2.h" #include "p347.pres.sim.h" #include "p347.session.prog.h" #include "p337.fserver.h" init { atomic { run present(0); run present(1); run session(0); run session(1); run fserver(0); run fserver(1); flow_to_ses[0] = ses_to_flow[1]; flow_to_ses[1] = ses_to_flow[0] } } Spin/Examples/Book_1991/p94.pml0000644000175100017510000000021011476234213014024 0ustar ghghbyte state = 2; proctype A() { (state == 1) -> state = 3 } proctype B() { state = state - 1 } /* added: */ init { run A(); run B() } Spin/Examples/Book_1991/p248.pml0000644000175100017510000000044611476257727014137 0ustar ghghproctype fact(int n; chan p) { int result; chan child = [1] of { int }; if :: (n <= 1) -> p!1 :: (n >= 2) -> run fact(n-1, child); child?result; p!n*result fi } init { int result; chan child = [1] of { int }; run fact(12, child); child?result; printf("result: %d\n", result) } Spin/Examples/Book_1991/p312.pml0000644000175100017510000000145311476257756014130 0ustar ghgh#define MIN 9 /* first data message to send */ #define MAX 12 /* last data message to send */ #define FILL 99 /* filler message */ mtype = { ack, nak, err } proctype transfer(chan chin, chout) { byte o, i, last_i=MIN; o = MIN+1; do :: chin?nak(i) -> assert(i == last_i+1); chout!ack(o) :: chin?ack(i) -> if :: (o < MAX) -> o = o+1 /* next */ :: (o >= MAX) -> o = FILL /* done */ fi; chout!ack(o) :: chin?err(i) -> chout!nak(o) od } proctype channel(chan inp, out) { byte md, mt; do :: inp?mt,md -> if :: out!mt,md :: out!err,0 fi od } init { chan AtoB = [1] of { byte, byte }; chan BtoC = [1] of { byte, byte }; chan CtoA = [1] of { byte, byte }; atomic { run transfer(AtoB, BtoC); run channel(BtoC, CtoA); run transfer(CtoA, AtoB) }; AtoB!err,0 /* start */ } Spin/Examples/Book_1991/p347.session.prog.h0000644000175100017510000000506011476234213016204 0ustar ghgh/* * Session Layer Validation Model */ proctype session(bit n) { bit toggle; byte type, status; endIDLE: do :: pres_to_ses[n]?type -> if :: (type == transfer) -> goto progressDATA_OUT :: (type != transfer) /* ignore */ fi :: flow_to_ses[n]?type,0 -> if :: (type == connect) -> goto progressDATA_IN :: (type != connect) /* ignore */ fi od; progressDATA_IN: /* 1. prepare local file fsrver */ ses_to_fsrv[n]!create; do :: fsrv_to_ses[n]?reject -> ses_to_flow[n]!reject,0; goto endIDLE :: fsrv_to_ses[n]?accept -> ses_to_flow[n]!accept,0; break od; /* 2. Receive the data, upto eof */ do :: flow_to_ses[n]?data,0 -> progress: ses_to_fsrv[n]!data :: flow_to_ses[n]?eof,0 -> ses_to_fsrv[n]!eof; break :: pres_to_ses[n]?transfer -> ses_to_pres[n]!reject(NON_FATAL) :: flow_to_ses[n]?close,0 -> /* remote user aborted */ ses_to_fsrv[n]!close; break :: timeout -> /* got disconnected */ ses_to_fsrv[n]!close; goto endIDLE od; /* 3. Close the connection */ ses_to_flow[n]!close,0; goto endIDLE; progressDATA_OUT: /* 1. prepare local file fsrver */ ses_to_fsrv[n]!open; if :: fsrv_to_ses[n]?reject -> ses_to_pres[n]!reject(FATAL); goto endIDLE :: fsrv_to_ses[n]?accept -> skip fi; /* 2. initialize flow control *** disabled ses_to_flow[n]!sync,toggle; do :: atomic { flow_to_ses[n]?sync_ack,type -> if :: (type != toggle) :: (type == toggle) -> break fi } :: timeout -> ses_to_fsrv[n]!close; ses_to_pres[n]!reject(FATAL); goto endIDLE od; toggle = 1 - toggle; /* 3. prepare remote file fsrver */ ses_to_flow[n]!connect,0; if :: flow_to_ses[n]?reject,status -> ses_to_fsrv[n]!close; ses_to_pres[n]!reject(FATAL); goto endIDLE :: flow_to_ses[n]?connect,0 -> ses_to_fsrv[n]!close; ses_to_pres[n]!reject(NON_FATAL); goto endIDLE :: flow_to_ses[n]?accept,0 -> skip :: timeout -> ses_to_fsrv[n]!close; ses_to_pres[n]!reject(FATAL); goto endIDLE fi; /* 4. Transmit the data, upto eof */ do :: fsrv_to_ses[n]?data -> ses_to_flow[n]!data,0 :: fsrv_to_ses[n]?eof -> ses_to_flow[n]!eof,0; status = COMPLETE; break :: pres_to_ses[n]?abort -> /* local user aborted */ ses_to_fsrv[n]!close; ses_to_flow[n]!close,0; status = FATAL; break od; /* 5. Close the connection */ do :: pres_to_ses[n]?abort /* ignore */ :: flow_to_ses[n]?close,0 -> if :: (status == COMPLETE) -> ses_to_pres[n]!accept,0 :: (status != COMPLETE) -> ses_to_pres[n]!reject(status) fi; break :: timeout -> ses_to_pres[n]!reject(FATAL); break od; goto endIDLE } Spin/Examples/Book_1991/p327.upper.h0000644000175100017510000000203111476234212014676 0ustar ghghproctype upper() { byte s_state, r_state; byte type, toggle; ses_to_flow[0]!sync,toggle; do :: flow_to_ses[0]?sync_ack,type -> if :: (type != toggle) :: (type == toggle) -> break fi :: timeout -> ses_to_flow[0]!sync,toggle od; toggle = 1 - toggle; do /* sender */ :: ses_to_flow[0]!white,0 :: atomic { (s_state == 0 && len (ses_to_flow[0]) < QSZ) -> ses_to_flow[0]!red,0 -> s_state = 1 } :: atomic { (s_state == 1 && len (ses_to_flow[0]) < QSZ) -> ses_to_flow[0]!blue,0 -> s_state = 2 } /* receiver */ :: flow_to_ses[1]?white,0 :: atomic { (r_state == 0 && flow_to_ses[1]?[red]) -> flow_to_ses[1]?red,0 -> r_state = 1 } :: atomic { (r_state == 0 && flow_to_ses[1]?[blue]) -> assert(0) } :: atomic { (r_state == 1 && flow_to_ses[1]?[blue]) -> flow_to_ses[1]?blue,0; break } :: atomic { (r_state == 1 && flow_to_ses[1]?[red]) -> assert(0) } od; end: do :: flow_to_ses[1]?white,0 :: flow_to_ses[1]?red,0 -> assert(0) :: flow_to_ses[1]?blue,0 -> assert(0) od } Spin/Examples/Book_1991/p337.user.h0000644000175100017510000000051211476234213014525 0ustar ghgh/* * User Layer Validation Model */ proctype userprc(bit n) { use_to_pres[n]!transfer; if :: pres_to_use[n]?accept -> goto Done :: pres_to_use[n]?reject -> goto Done :: use_to_pres[n]!abort -> goto Aborted fi; Aborted: if :: pres_to_use[n]?accept -> goto Done :: pres_to_use[n]?reject -> goto Done fi; Done: skip } Spin/Examples/Book_1991/p123.pml0000644000175100017510000000202211476234212014077 0ustar ghgh/* alternating bit - version with message loss */ #define MAX 3 mtype = { msg0, msg1, ack0, ack1 }; chan sender =[1] of { byte }; chan receiver=[1] of { byte }; proctype Sender() { byte any; again: do :: receiver!msg1; if :: sender?ack1 -> break :: sender?any /* lost */ :: timeout /* retransmit */ fi od; do :: receiver!msg0; if :: sender?ack0 -> break :: sender?any /* lost */ :: timeout /* retransmit */ fi od; goto again } proctype Receiver() { byte any; again: do :: receiver?msg1 -> sender!ack1; break :: receiver?msg0 -> sender!ack0 :: receiver?any /* lost */ od; P0: do :: receiver?msg0 -> sender!ack0; break :: receiver?msg1 -> sender!ack1 :: receiver?any /* lost */ od; P1: goto again } init { atomic { run Sender(); run Receiver() } } never { do :: skip /* allow any time delay */ :: receiver?[msg0] -> goto accept0 :: receiver?[msg1] -> goto accept1 od; accept0: do :: !Receiver[2]@P0 /* n.b. new syntax of remote reference */ od; accept1: do :: !Receiver[2]@P1 od } Spin/Examples/Book_1991/App.F.user.h0000644000175100017510000000051211476234212014734 0ustar ghgh/* * User Layer Validation Model */ proctype userprc(bit n) { use_to_pres[n]!transfer; if :: pres_to_use[n]?accept -> goto Done :: pres_to_use[n]?reject -> goto Done :: use_to_pres[n]!abort -> goto Aborted fi; Aborted: if :: pres_to_use[n]?accept -> goto Done :: pres_to_use[n]?reject -> goto Done fi; Done: skip } Spin/Examples/Book_1991/p116.pml0000644000175100017510000000027311476234212014107 0ustar ghghbyte state = 1; proctype A() { (state == 1) -> state = state + 1; assert(state == 2) } proctype B() { (state == 1) -> state = state - 1; assert(state == 0) } init { run A(); run B() } Spin/Examples/Book_1991/App.F.fserver.h0000644000175100017510000000102711476234212015434 0ustar ghgh/* * File Server Validation Model */ proctype fserver(bit n) { end: do :: ses_to_fsrv[n]?create -> /* incoming */ if :: fsrv_to_ses[n]!reject :: fsrv_to_ses[n]!accept -> do :: ses_to_fsrv[n]?data :: ses_to_fsrv[n]?eof -> break :: ses_to_fsrv[n]?close -> break od fi :: ses_to_fsrv[n]?open -> /* outgoing */ if :: fsrv_to_ses[n]!reject :: fsrv_to_ses[n]!accept -> do :: fsrv_to_ses[n]!data -> progress: skip :: ses_to_fsrv[n]?close -> break :: fsrv_to_ses[n]!eof -> break od fi od } Spin/Examples/Book_1991/App.F.session.h0000644000175100017510000000477111476234212015454 0ustar ghgh/* * Session Layer Validation Model */ proctype session(bit n) { bit toggle; byte type, status; endIDLE: do :: pres_to_ses[n]?type -> if :: (type == transfer) -> goto DATA_OUT :: (type != transfer) /* ignore */ fi :: flow_to_ses[n]?type,0 -> if :: (type == connect) -> goto DATA_IN :: (type != connect) /* ignore */ fi od; DATA_IN: /* 1. prepare local file fsrver */ ses_to_fsrv[n]!create; do :: fsrv_to_ses[n]?reject -> ses_to_flow[n]!reject,0; goto endIDLE :: fsrv_to_ses[n]?accept -> ses_to_flow[n]!accept,0; break od; /* 2. Receive the data, upto eof */ do :: flow_to_ses[n]?data,0 -> ses_to_fsrv[n]!data :: flow_to_ses[n]?eof,0 -> ses_to_fsrv[n]!eof; break :: pres_to_ses[n]?transfer -> ses_to_pres[n]!reject(NON_FATAL) :: flow_to_ses[n]?close,0 -> /* remote user aborted */ ses_to_fsrv[n]!close; break :: timeout -> /* got disconnected */ ses_to_fsrv[n]!close; goto endIDLE od; /* 3. Close the connection */ ses_to_flow[n]!close,0; goto endIDLE; DATA_OUT: /* 1. prepare local file fsrver */ ses_to_fsrv[n]!open; if :: fsrv_to_ses[n]?reject -> ses_to_pres[n]!reject(FATAL); goto endIDLE :: fsrv_to_ses[n]?accept -> skip fi; /* 2. initialize flow control */ ses_to_flow[n]!sync,toggle; do :: atomic { flow_to_ses[n]?sync_ack,type -> if :: (type != toggle) :: (type == toggle) -> break fi } :: timeout -> ses_to_fsrv[n]!close; ses_to_pres[n]!reject(FATAL); goto endIDLE od; toggle = 1 - toggle; /* 3. prepare remote file fsrver */ ses_to_flow[n]!connect,0; if :: flow_to_ses[n]?reject,0 -> ses_to_fsrv[n]!close; ses_to_pres[n]!reject(FATAL); goto endIDLE :: flow_to_ses[n]?connect,0 -> ses_to_fsrv[n]!close; ses_to_pres[n]!reject(NON_FATAL); goto endIDLE :: flow_to_ses[n]?accept,0 -> skip :: timeout -> ses_to_fsrv[n]!close; ses_to_pres[n]!reject(FATAL); goto endIDLE fi; /* 4. Transmit the data, upto eof */ do :: fsrv_to_ses[n]?data -> ses_to_flow[n]!data,0 :: fsrv_to_ses[n]?eof -> ses_to_flow[n]!eof,0; status = COMPLETE; break :: pres_to_ses[n]?abort -> /* local user aborted */ ses_to_fsrv[n]!close; ses_to_flow[n]!close,0; status = FATAL; break od; /* 5. Close the connection */ do :: pres_to_ses[n]?abort /* ignore */ :: flow_to_ses[n]?close,0 -> if :: (status == COMPLETE) -> ses_to_pres[n]!accept,0 :: (status != COMPLETE) -> ses_to_pres[n]!reject(status) fi; break :: timeout -> ses_to_pres[n]!reject(FATAL); break od; goto endIDLE } Spin/Examples/Book_1991/p95.1.pml0000644000175100017510000000004111476234213014166 0ustar ghghinit { printf("hello world\n") } Spin/Examples/Book_1991/p107.pml0000644000175100017510000000112111476257700014107 0ustar ghghmtype = { ack, nak, err, next, accept } proctype transfer(chan inp, out, chin, chout) { byte o, i; inp?next(o); do :: chin?nak(i) -> out!accept(i); chout!ack(o) :: chin?ack(i) -> out!accept(i); inp?next(o); chout!ack(o) :: chin?err(i) -> chout!nak(o) od } init { chan AtoB = [1] of { byte, byte }; chan BtoA = [1] of { byte, byte }; chan Ain = [2] of { byte, byte }; chan Bin = [2] of { byte, byte }; chan Aout = [2] of { byte, byte }; chan Bout = [2] of { byte, byte }; atomic { run transfer(Ain, Aout, AtoB, BtoA); run transfer(Bin, Bout, BtoA, AtoB) }; AtoB!err(0) } Spin/Examples/Book_1991/p105.2.pml0000644000175100017510000000044511476257636014265 0ustar ghghproctype fact(int n; chan p) { int result; chan child = [1] of { int }; if :: (n <= 1) -> p!1 :: (n >= 2) -> run fact(n-1, child); child?result; p!n*result fi } init { int result; chan child = [1] of { int }; run fact(7, child); child?result; printf("result: %d\n", result) } Spin/Examples/Book_1991/App.F.datalink.h0000644000175100017510000000045211476234212015550 0ustar ghgh/* * Datalink Layer Validation Model */ proctype data_link() { byte type, seq; end: do :: flow_to_dll[0]?type,seq -> if :: dll_to_flow[1]!type,seq :: skip /* lose message */ fi :: flow_to_dll[1]?type,seq -> if :: dll_to_flow[0]!type,seq :: skip /* lose message */ fi od } Spin/Examples/Book_1991/p330.pml0000644000175100017510000000125711476261006014111 0ustar ghgh/* * PROMELA Validation Model * FLOW CONTROL LAYER VALIDATION */ #define LOSS 0 /* message loss */ #define DUPS 0 /* duplicate msgs */ #define QSZ 2 /* queue size */ mtype = { red, white, blue, abort, accept, ack, sync_ack, close, connect, create, data, eof, open, reject, sync, transfer, FATAL, NON_FATAL, COMPLETE } chan ses_to_flow[2] = [QSZ] of { byte, byte }; chan flow_to_ses[2] = [QSZ] of { byte, byte }; chan dll_to_flow[2] = [QSZ] of { byte, byte }; chan flow_to_dll[2]; #include "App.F.flow_cl.h" #include "p327.upper.h" init { atomic { flow_to_dll[0] = dll_to_flow[1]; flow_to_dll[1] = dll_to_flow[0]; run fc(0); run fc(1); run upper() } } Spin/Examples/Book_1991/p108.pml0000644000175100017510000000250511476234212014110 0ustar ghgh/***** Ackermann's function *****/ /* a good example where a simulation run is the better choice - and verification is overkill. 1. simulation -> straight simulation (spin p108) takes -> approx. 6.4 sec on an SGI R3000 -> prints the answer: ack(3,3) = 61 -> after creating 2433 processes note: all process invocations can, at least in one feasible execution scenario, overlap - if each process chooses to hang around indefinitely in its dying state, at the closing curly brace. this means that the maximum state vector `could' grow to hold all 2433 processes or about 2433*12 bytes of data. the assert(0) at the end makes sure though that the run stops the first time we complete an execution sequence that computes the answer, so the following suffices: 2. verification -> spin -a p108 -> cc -DVECTORSZ=2048 -o pan pan.c -> pan -m15000 -> which completes in about 5 sec */ proctype ack(short a, b; chan ch1) { chan ch2 = [1] of { short }; short ans; if :: (a == 0) -> ans = b+1 :: (a != 0) -> if :: (b == 0) -> run ack(a-1, 1, ch2) :: (b != 0) -> run ack(a, b-1, ch2); ch2?ans; run ack(a-1, ans, ch2) fi; ch2?ans fi; ch1!ans } init { chan ch = [1] of { short }; short ans; run ack(3, 3, ch); ch?ans; printf("ack(3,3) = %d\n", ans); assert(0) /* a forced stop, (Chapter 6) */ } Spin/Examples/Book_1991/p104.1.pml0000644000175100017510000000044711476257504014257 0ustar ghgh#define N 128 #define size 16 chan inp = [size] of { short }; chan large = [size] of { short }; chan small = [size] of { short }; proctype split() { short cargo; do :: inp?cargo -> if :: (cargo >= N) -> large!cargo :: (cargo < N) -> small!cargo fi od } init { run split() } Spin/Examples/Book_1991/p104.2.pml0000644000175100017510000000070611476257570014261 0ustar ghgh#define N 128 #define size 16 chan inp = [size] of { short }; chan large = [size] of { short }; chan small = [size] of { short }; proctype split() { short cargo; do :: inp?cargo -> if :: (cargo >= N) -> large!cargo :: (cargo < N) -> small!cargo fi od } proctype merge() { short cargo; do :: if :: large?cargo :: small?cargo fi; inp!cargo od } init { inp!345; inp!12; inp!6777; inp!32; inp!0; run split(); run merge() } Spin/Examples/Book_1991/p319.pml0000644000175100017510000000137711476260043014123 0ustar ghgh#define true 1 #define false 0 bool busy[3]; chan up[3] = [1] of { byte }; chan down[3] = [1] of { byte }; mtype = { start, attention, data, stop } proctype station(byte id; chan inp, out) { do :: inp?start -> atomic { !busy[id] -> busy[id] = true }; out!attention; do :: inp?data -> out!data :: inp?stop -> break od; out!stop; busy[id] = false :: atomic { !busy[id] -> busy[id] = true }; out!start; inp?attention; do :: out!data -> inp?data :: out!stop -> break od; inp?stop; busy[id] = false od } init { atomic { run station(0, up[2], down[2]); run station(1, up[0], down[0]); run station(2, up[1], down[1]); run station(0, down[0], up[0]); run station(1, down[1], up[1]); run station(2, down[2], up[2]) } } Spin/Examples/Book_1991/App.F.present.h0000644000175100017510000000124111476234212015436 0ustar ghgh/* * Presentation Layer Validation Model */ proctype present(bit n) { byte status, uabort; endIDLE: do :: use_to_pres[n]?transfer -> uabort = 0; break :: use_to_pres[n]?abort -> skip od; TRANSFER: pres_to_ses[n]!transfer; do :: use_to_pres[n]?abort -> if :: (!uabort) -> uabort = 1; pres_to_ses[n]!abort :: (uabort) -> assert(1+1!=2) fi :: ses_to_pres[n]?accept,0 -> goto DONE :: ses_to_pres[n]?reject(status) -> if :: (status == FATAL || uabort) -> goto FAIL :: (status == NON_FATAL && !uabort) -> progress: goto TRANSFER fi od; DONE: pres_to_use[n]!accept; goto endIDLE; FAIL: pres_to_use[n]!reject; goto endIDLE } Spin/Examples/Book_1991/p337.session.h0000644000175100017510000000500311476234213015232 0ustar ghgh/* * Session Layer Validation Model */ proctype session(bit n) { bit toggle; byte type, status; endIDLE: do :: pres_to_ses[n]?type -> if :: (type == transfer) -> goto DATA_OUT :: (type != transfer) /* ignore */ fi :: flow_to_ses[n]?type,0 -> if :: (type == connect) -> goto DATA_IN :: (type != connect) /* ignore */ fi od; DATA_IN: /* 1. prepare local file fsrver */ ses_to_fsrv[n]!create; do :: fsrv_to_ses[n]?reject -> ses_to_flow[n]!reject,0; goto endIDLE :: fsrv_to_ses[n]?accept -> ses_to_flow[n]!accept,0; break od; /* 2. Receive the data, upto eof */ do :: flow_to_ses[n]?data,0 -> ses_to_fsrv[n]!data :: flow_to_ses[n]?eof,0 -> ses_to_fsrv[n]!eof; break :: pres_to_ses[n]?transfer -> ses_to_pres[n]!reject(NON_FATAL) :: flow_to_ses[n]?close,0 -> /* remote user aborted */ ses_to_fsrv[n]!close; break :: timeout -> /* got disconnected */ ses_to_fsrv[n]!close; goto endIDLE od; /* 3. Close the connection */ ses_to_flow[n]!close,0; goto endIDLE; DATA_OUT: /* 1. prepare local file fsrver */ ses_to_fsrv[n]!open; if :: fsrv_to_ses[n]?reject -> ses_to_pres[n]!reject(FATAL); goto endIDLE :: fsrv_to_ses[n]?accept -> skip fi; /* 2. initialize flow control *** disabled ses_to_flow[n]!sync,toggle; do :: atomic { flow_to_ses[n]?sync_ack,type -> if :: (type != toggle) :: (type == toggle) -> break fi } :: timeout -> ses_to_fsrv[n]!close; ses_to_pres[n]!reject(FATAL); goto endIDLE od; toggle = 1 - toggle; /* 3. prepare remote file fsrver */ ses_to_flow[n]!connect,0; if :: flow_to_ses[n]?reject,0 -> ses_to_fsrv[n]!close; ses_to_pres[n]!reject(FATAL); goto endIDLE :: flow_to_ses[n]?connect,0 -> ses_to_fsrv[n]!close; ses_to_pres[n]!reject(NON_FATAL); goto endIDLE :: flow_to_ses[n]?accept,0 -> skip :: timeout -> ses_to_fsrv[n]!close; ses_to_pres[n]!reject(FATAL); goto endIDLE fi; /* 4. Transmit the data, upto eof */ do :: fsrv_to_ses[n]?data -> ses_to_flow[n]!data,0 :: fsrv_to_ses[n]?eof -> ses_to_flow[n]!eof,0; status = COMPLETE; break :: pres_to_ses[n]?abort -> /* local user aborted */ ses_to_fsrv[n]!close; ses_to_flow[n]!close,0; status = FATAL; break od; /* 5. Close the connection */ do :: pres_to_ses[n]?abort /* ignore */ :: flow_to_ses[n]?close,0 -> if :: (status == COMPLETE) -> ses_to_pres[n]!accept,0 :: (status != COMPLETE) -> ses_to_pres[n]!reject(status) fi; break :: timeout -> ses_to_pres[n]!reject(FATAL); break od; goto endIDLE } Spin/Examples/Book_1991/README.txt0000644000175100017510000001021512331055371014377 0ustar ghghContents -------- The files in this set contain the text of examples used in the 1991 Design and Validation of Computer Protocols book. The name of each file corresponds to the page number in the book where the example appears in its most useful version. The overview below gives a short descriptive phrase for each file. Description Page Nr = Filename prefix ----------- ------------------------- hello world p95.1 tiny examples p94 p95.2 p96.1 p97.1 p97.2 p101 p102 p104.1 useful demos p99 p104.2 p105.2 p116 p248 mutual exclusion p96.2 p105.1 p117 p320 Lynch's protocol p107 p312 alternatin bit p123 chappe's protocol p319 We have renamed the main promela files with the standard file extension .pml, and gave all promela files that are not meant to be used standalone, but only as include files, the extension .h. This gives 28 files with extension .pml, and 17 more with extensions .h. We've also renamed variables named 'in' in the original version of each file with 'inp' or 'cnt', to avoid the name-clash with what is today a keyword, starting with Spin version 6.0. Other minor changes include moving channel declarations to the start of a proctype declaration, to satisfy new syntax rules, etc. Large runs ---------- ackerman's fct p108 # read info at start of the file Pftp Protocol ------------- upper tester p325.test # not runnable flow control l. p329 p330 session layer p337.pftp.ses p342.pftp.ses1 p347.pftp.ses5 all pftp App.F.pftp - plus 8 include files See also the single file version of pftp in: Test/pftp.pml General ------- Use these examples for inspiration, and to get acquainted with the language and the Spin software. All examples - except p123.pml - can be used with both version 1 and version 2 of SPIN. (p123.pml was modifed for version 2.0 to use the new syntax for remote referencing). If you repeat the runs that are listed in the book for these examples, you should not expect to get the same numbers in the result - given the algorithmic improvements that have been made since book version of Spin Version 1.0. Generally, the numbers of states, memory, and runtime should all be lower (sometimes considerably so) than what the first book reported. For instance, for p329.pml, the book (Spin V1.0) says on pg. 332, using a BITSTATE run, that there are: 90845 + 317134 + 182425 states (stored + linked + matched) Spin V6.0 (December 2010) reports lower numbers: 56713 + 35321 + 76958 states (stored + atomic + matched) If you repeat a BITSTATE run, of course, by the nature of the machine dependent effect of hashing, you may get different coverage and hash-factors for larger runs. The implementation of the hash functions has also been changed to improve their performance and quality, so the numbers you see will likely differ. The last set of files (prefixed App.F) is included for completeness. As explained in the book: don't expect to be able to do an exhaustive verification for this specification as listed. In chapter 14 it is illustrated how the spec can be broken up into smaller portions that are more easily verified. Some Small Experiments ----------------------- Try: spin p95.1.pml # small simulation run spin -s p108.pml # a bigger simulation run, track send stmnts spin -c p108.pml # same with different output format spin -a p312.pml # lynch's protocol - generate verifier cc -o pan pan.c # compile it for exhaustive verification ./pan # prove correctness of assertions etc. spin -t -r -s p312.pml # display the error trace you can edit p312.pml to change all three channel declarations in init to look like: ``chan AtoB = [1] of { mtype byte }'' and repeat the last four steps for a more legible error trace. spin -a p123.pml # alternating bit protocol - generate verifier cc -o pan pan.c # compile it for exhaustive verification pan -a # check violations of the never claim spin -t -r -s p123.pml # display the error trace for an alternative view of these runs try the new graphical interface ispin (the successor to xspin), and repeat the experiments. ============================================ Updated for Spin Version 6, December 3, 2010 Spin/Examples/Book_1991/p337.pftp.ses.pml0000644000175100017510000000063711476261114015662 0ustar ghgh/* * PROMELA Validation Model * Session Layer */ #include "p337.defines2.h" #include "p337.user.h" #include "App.F.present.h" #include "p337.session.h" #include "p337.fserver.h" init { atomic { run userprc(0); run userprc(1); run present(0); run present(1); run session(0); run session(1); run fserver(0); run fserver(1); flow_to_ses[0] = ses_to_flow[1]; flow_to_ses[1] = ses_to_flow[0] } } Spin/Examples/Book_1991/p117.pml0000644000175100017510000000067211476234212014113 0ustar ghgh#define p 0 #define v 1 chan sema = [0] of { bit }; /* typo in original `=' was missing */ proctype dijkstra() { do :: sema!p -> sema?v od } byte count; proctype user() { sema?p; count = count+1; skip; /* critical section */ count = count-1; sema!v; skip /* non-critical section */ } proctype monitor() { assert(count == 0 || count == 1) } init { atomic { run dijkstra(); run monitor(); run user(); run user(); run user() } } Spin/Examples/Book_1991/p329.pml0000644000175100017510000000125711476260657014134 0ustar ghgh/* * PROMELA Validation Model * FLOW CONTROL LAYER VALIDATION */ #define LOSS 0 /* message loss */ #define DUPS 0 /* duplicate msgs */ #define QSZ 2 /* queue size */ mtype = { red, white, blue, abort, accept, ack, sync_ack, close, connect, create, data, eof, open, reject, sync, transfer, FATAL, NON_FATAL, COMPLETE } chan ses_to_flow[2] = [QSZ] of { byte, byte }; chan flow_to_ses[2] = [QSZ] of { byte, byte }; chan dll_to_flow[2] = [QSZ] of { byte, byte }; chan flow_to_dll[2]; #include "App.F.flow_cl.h" #include "p327.upper.h" init { atomic { flow_to_dll[0] = dll_to_flow[1]; flow_to_dll[1] = dll_to_flow[0]; run fc(0); run fc(1); run upper() } } Spin/Examples/Book_1991/p105.1.pml0000644000175100017510000000041711476234212014244 0ustar ghgh#define p 0 #define v 1 chan sema = [0] of { bit }; proctype dijkstra() { do :: sema!p -> sema?v od } proctype user() { sema?p; /* critical section */ sema!v /* non-critical section */ } init { atomic { run dijkstra(); run user(); run user(); run user() } } Spin/Examples/Book_1991/App.F.flow_cl.h0000644000175100017510000000452112331055663015411 0ustar ghgh/* * Flow Control Layer Validation Model */ #define true 1 #define false 0 #define M 4 /* range sequence numbers */ #define W 2 /* window size: M/2 */ proctype fc(bit n) { bool busy[M]; /* outstanding messages */ byte q; /* seq# oldest unacked msg */ byte m; /* seq# last msg received */ byte s; /* seq# next msg to send */ byte window; /* nr of outstanding msgs */ byte type; /* msg type */ bit received[M]; /* receiver housekeeping */ bit x; /* scratch variable */ byte p; /* seq# of last msg acked */ byte I_buf[M], O_buf[M]; /* message buffers */ /* sender part */ end: do :: atomic { (window < W && len(ses_to_flow[n]) > 0 && len(flow_to_dll[n]) < QSZ) -> ses_to_flow[n]?type,x; window = window + 1; busy[s] = true; O_buf[s] = type; flow_to_dll[n]!type,s; if :: (type != sync) -> s = (s+1)%M :: (type == sync) -> window = 0; s = M; do :: (s > 0) -> s = s-1; busy[s] = false :: (s == 0) -> break od fi } :: atomic { (window > 0 && busy[q] == false) -> window = window - 1; q = (q+1)%M } #if DUPS :: atomic { (len(flow_to_dll[n]) < QSZ && window > 0 && busy[q] == true) -> flow_to_dll[n]! O_buf[q],q } #endif :: atomic { (timeout && len(flow_to_dll[n]) < QSZ && window > 0 && busy[q] == true) -> flow_to_dll[n]! O_buf[q],q } /* receiver part */ #if LOSS :: dll_to_flow[n]?type,m /* lose any message */ #endif :: dll_to_flow[n]?type,m -> if :: atomic { (type == ack) -> busy[m] = false } :: atomic { (type == sync) -> flow_to_dll[n]!sync_ack,m; m = 0; do :: (m < M) -> received[m] = 0; m = m+1 :: (m == M) -> break od } :: (type == sync_ack) -> flow_to_ses[n]!sync_ack,m :: (type != ack && type != sync && type != sync_ack)-> if :: atomic { (received[m] == true) -> x = ((0 flow_to_dll[n]!ack,m :: (!x) /* else skip */ fi :: atomic { (received[m] == false) -> I_buf[m] = type; received[m] = true; received[(m-W+M)%M] = false } fi fi :: (received[p] == true && len(flow_to_ses[n]) flow_to_ses[n]!I_buf[p],0; flow_to_dll[n]!ack,p; p = (p+1)%M od } Spin/Examples/Book_1991/p101.pml0000644000175100017510000000040411476234212014075 0ustar ghgh#define msgtype 33 chan name = [0] of { byte, byte }; /* byte name; typo - this line shouldn't have been here */ proctype A() { name!msgtype(124); name!msgtype(121) } proctype B() { byte state; name?msgtype(state) } init { atomic { run A(); run B() } } Spin/Examples/Book_1991/p97.1.pml0000644000175100017510000000024611476234213014177 0ustar ghghbyte state = 1; proctype A() { atomic { (state == 1) -> state = state + 1 } } proctype B() { atomic { (state == 1) -> state = state - 1 } } init { run A(); run B() } Spin/Examples/Book_1991/p342.pftp.ses1.h0000644000175100017510000000105211476261177015377 0ustar ghgh/* * PROMELA Validation Model * Session Layer */ #include "p337.defines2.h" #include "p337.user.h" #include "App.F.present.h" #include "p337.session.h" #include "p337.fserver.h" init { atomic { run userprc(0); run userprc(1); run present(0); run present(1); run session(0); run session(1); run fserver(0); run fserver(1); flow_to_ses[0] = ses_to_flow[1]; flow_to_ses[1] = ses_to_flow[0] }; atomic { byte any; chan foo = [1] of { byte, byte }; ses_to_flow[0] = foo; ses_to_flow[1] = foo }; end: do :: foo?any,any od } Spin/Examples/Book_1991/p102.pml0000644000175100017510000000027111476234212014100 0ustar ghgh#define a 1 #define b 2 chan ch = [1] of { byte }; proctype A() { ch!a } proctype B() { ch!b } proctype C() { if :: ch?a :: ch?b fi } init { atomic { run A(); run B(); run C() } } Spin/Examples/Book_1991/p347.pres.sim.h0000644000175100017510000000061411476234213015313 0ustar ghgh/* * PROMELA Validation Model * Presentation & User Layer - combined and reduced */ proctype present(bit n) { byte status; progress0: pres_to_ses[n]!transfer -> do :: pres_to_ses[n]!abort; progress1: skip :: ses_to_pres[n]?accept,status -> break :: ses_to_pres[n]?reject,status -> if :: (status == NON_FATAL) -> goto progress0 :: (status != NON_FATAL) -> break fi od } Spin/Examples/Book_1991/p320.pml0000644000175100017510000000066111476234212014105 0ustar ghgh#define true 1 #define false 0 #define Aturn false #define Bturn true bool x, y, t; bool ain, bin; proctype A() { x = true; t = Bturn; (y == false || t == Aturn); ain = true; assert(bin == false); /* critical section */ ain = false; x = false } proctype B() { y = true; t = Aturn; (x == false || t == Bturn); bin = true; assert(ain == false); /* critical section */ bin = false; y = false } init { run A(); run B() } Spin/Examples/Book_1991/App.F.pftp.pml0000644000175100017510000000070311476260543015300 0ustar ghgh/* * PROMELA Validation Model - startup script */ #include "App.F.defines.h" #include "App.F.user.h" #include "App.F.present.h" #include "App.F.session.h" #include "App.F.fserver.h" #include "App.F.flow_cl.h" #include "App.F.datalink.h" init { atomic { run userprc(0); run userprc(1); run present(0); run present(1); run session(0); run session(1); run fserver(0); run fserver(1); run fc(0); run fc(1); run data_link() } } Spin/Examples/Book_1991/p95.2.pml0000644000175100017510000000013011476234213014166 0ustar ghghproctype A(byte state; short set) { (state == 1) -> state = set } init { run A(1, 3) } Spin/Examples/Book_1991/p99.pml0000644000175100017510000000036311476234213014042 0ustar ghghproctype A(chan q1) { chan q2; q1?q2; q2!123 } proctype B(chan qforb) { int x; qforb?x; printf("x = %d\n", x) } init { chan qname[2] = [1] of { chan }; chan qforb = [1] of { int }; run A(qname[0]); run B(qforb); qname[0]!qforb } Spin/Examples/Book_1991/App.F.defines.h0000644000175100017510000000133711476234212015401 0ustar ghgh/* * Global Definitions */ #define LOSS 0 /* message loss */ #define DUPS 0 /* duplicate msgs */ #define QSZ 2 /* queue size */ mtype = { red, white, blue, abort, accept, ack, sync_ack, close, connect, create, data, eof, open, reject, sync, transfer, FATAL, NON_FATAL, COMPLETE } chan use_to_pres[2] = [QSZ] of { byte }; chan pres_to_use[2] = [QSZ] of { byte }; chan pres_to_ses[2] = [QSZ] of { byte }; chan ses_to_pres[2] = [QSZ] of { byte, byte }; chan ses_to_flow[2] = [QSZ] of { byte, byte }; chan flow_to_ses[2] = [QSZ] of { byte, byte }; chan dll_to_flow[2] = [QSZ] of { byte, byte }; chan flow_to_dll[2] = [QSZ] of { byte, byte }; chan ses_to_fsrv[2] = [0] of { byte }; chan fsrv_to_ses[2] = [0] of { byte }; Spin/Examples/Book_1991/p343.claim.h0000644000175100017510000000057711476234213014644 0ustar ghghnever { skip; /* match first step of init (spin version 2.0) */ do :: !pres_to_ses[0]?[transfer] && !flow_to_ses[0]?[connect] :: pres_to_ses[0]?[transfer] -> goto accept0 :: flow_to_ses[0]?[connect] -> goto accept1 od; accept0: do :: !ses_to_pres[0]?[accept] && !ses_to_pres[0]?[reject] od; accept1: do :: !ses_to_pres[1]?[accept] && !ses_to_pres[1]?[reject] od } Spin/Examples/Book_1991/p96.2.pml0000644000175100017510000000046711476234213014204 0ustar ghgh#define true 1 #define false 0 #define Aturn 1 #define Bturn 0 bool x, y, t; proctype A() { x = true; t = Bturn; (y == false || t == Aturn); /* critical section */ x = false } proctype B() { y = true; t = Aturn; (x == false || t == Bturn); /* critical section */ y = false } init { run A(); run B() } Spin/Examples/Book_1991/p97.2.pml0000644000175100017510000000024311476261451014201 0ustar ghghproctype nr(short id, a, b) { int res; atomic { res = (a*a+b)/2*a; printf("result %d: %d\n", id, res) } } init { run nr(1,1,1); run nr(1,2,2); run nr(1,3,2) } Spin/Examples/Book_1991/p325.test.h0000644000175100017510000000125611476234212014530 0ustar ghghproctype test_sender(bit n) { byte type, toggle; ses_to_flow[n]!sync,toggle; do :: flow_to_ses[n]?sync_ack,type -> if :: (type != toggle) :: (type == toggle) -> break fi :: timeout -> ses_to_flow[n]!sync,toggle od; toggle = 1 - toggle; do :: ses_to_flow[n]!data,white :: ses_to_flow[n]!data,red -> break od; do :: ses_to_flow[n]!data,white :: ses_to_flow[n]!data,blue -> break od; do :: ses_to_flow[n]!data,white :: break od } proctype test_receiver(bit n) { do :: flow_to_ses[n]?data,white :: flow_to_ses[n]?data,red -> break od; do :: flow_to_ses[n]?data,white :: flow_to_ses[n]?data,blue -> break od; end: do :: flow_to_ses[n]?data,white od } Spin/Examples/Book_1991/p337.defines2.h0000644000175100017510000000110011476234213015240 0ustar ghgh/* * PROMELA Validation Model * global definitions */ #define QSZ 2 /* queue size */ mtype = { red, white, blue, abort, accept, ack, sync_ack, close, connect, create, data, eof, open, reject, sync, transfer, FATAL, NON_FATAL, COMPLETE } chan use_to_pres[2] = [QSZ] of { mtype }; chan pres_to_use[2] = [QSZ] of { mtype }; chan pres_to_ses[2] = [QSZ] of { mtype }; chan ses_to_pres[2] = [QSZ] of { mtype, byte }; chan ses_to_flow[2] = [QSZ] of { mtype, byte }; chan ses_to_fsrv[2] = [0] of { mtype }; chan fsrv_to_ses[2] = [0] of { mtype }; chan flow_to_ses[2]; Spin/Examples/Book_1991/p337.fserver.h0000644000175100017510000000102711476234213015225 0ustar ghgh/* * File Server Validation Model */ proctype fserver(bit n) { end: do :: ses_to_fsrv[n]?create -> /* incoming */ if :: fsrv_to_ses[n]!reject :: fsrv_to_ses[n]!accept -> do :: ses_to_fsrv[n]?data :: ses_to_fsrv[n]?eof -> break :: ses_to_fsrv[n]?close -> break od fi :: ses_to_fsrv[n]?open -> /* outgoing */ if :: fsrv_to_ses[n]!reject :: fsrv_to_ses[n]!accept -> do :: fsrv_to_ses[n]!data -> progress: skip :: ses_to_fsrv[n]?close -> break :: fsrv_to_ses[n]!eof -> break od fi od } Spin/Examples/life.pml0000644000175100017510000000315612331274305012763 0ustar ghgh// Conway's game of life #define MAX 5 #define Board(x,y) board[(which*MAX*MAX)+((x)*MAX)+(y)] #define NewBoard(x,y) board[((1-which)*MAX*MAX)+((x)*MAX)+(y)] byte board[2*(MAX+1)*(MAX+1)]; int moveall; int which; inline print_board() { x = 0; do :: x < MAX -> y = 0; printf("|"); do :: y < MAX -> if :: Board(x,y) -> printf("+") :: else -> printf(".") fi; y++ :: else -> printf("|\n"); break od; x++ :: else -> printf(" -----\n"); break od; } proctype cell(int x; int y) { int cnt, i, j; do :: d_step { moveall > 0 -> moveall--; cnt = 0; i = -1; do :: i <= 1 -> j = -1; do :: j <= 1 -> if :: (i != 0 || j != 0) && Board((x+i),(y+j)) -> cnt++ :: else fi; j++; :: else -> break od; i++ :: else -> break od; NewBoard(x,y) = Board(x,y); if :: Board(x,y) -> // Any live cell with fewer than two live neighbours dies // Any live cell with more than three live neighbours dies // Any live cell with two or three live neighbours lives on to the next generation if :: cnt < 2 || cnt > 3 -> NewBoard(x,y) = 0 :: else fi :: else -> // Any dead cell with exactly three live neighbours becomes a live cell if :: cnt == 3 -> NewBoard(x,y) = 1 :: else fi fi; }; moveall == 0 od } init { int x, y; NewBoard(2,1) = 1; NewBoard(2,2) = 1; NewBoard(2,3) = 1; atomic { x = 1; do :: x < MAX -> y = 1; do :: y < MAX -> run cell(x,y); y++ :: else -> break od; x++ :: else -> break od } do :: moveall == 0 -> which = 1 - which; print_board(); moveall = (MAX-1)*(MAX-1) od } Spin/Examples/calculator.pml0000664000175100017510000000125612335437015014201 0ustar ghgh// reverse polish #define N 12 mtype = { operator, value } chan f = [N] of { mtype, int } proctype calc(chan you) { int s, lft, rgt chan me = [0] of { int } if :: f?operator(s) run calc(me); me?lft run calc(me); me?rgt if :: s == '+' -> you!(lft+rgt) :: s == '-' -> you!(lft-rgt) :: s == '*' -> you!(lft*rgt) :: s == '/' -> assert(rgt != 0) you!(lft/rgt) :: else -> assert(false) fi :: f?value(s) -> you!s fi } init { chan me = [0] of { int } int result f!operator('+') f!operator('/') f!value(84) f!value(2) f!operator('-') f!value(36) f!operator('*') f!value(3) f!value(4) run calc(me); me?result printf("result: %d\n", result) } Spin/Examples/welfare.pml0000644000175100017510000000165612331274305013474 0ustar ghgh/* a problem due to W. Feijen [described in D. Gries, "The Science of Programming," Springer, New York, 1981] a, b, and c are three ordered lists of integers (originally: three magnetic tapes with sorted lists of names; a list of welfare recipients, a payroll list of a company, and a list of University students) At least one element appears in all three lists. Find the smallest indices i, j, and k such that a[i] == b[j] == c[k] (i.e., the first name in alphabetical order that appears in all three lists) */ int a[5], b[5], c[5] active proctype cr() { byte i, j, k a[0] = 1; a[1] = 3; a[2] = 4; a[3] = 13; a[4] = 18 b[0] = 1; b[1] = 4; b[2] = 18; b[3] = 20; b[4] = 25 c[0] = 5; c[1] = 8; c[2] = 12; c[3] = 18; c[4] = 24 do /* non-deterministic */ :: a[i] < b[j] -> i++ :: b[j] < c[k] -> j++ :: c[k] < a[i] -> k++ :: else -> break od; assert(a[i] == b[j] && b[j] == c[k]) assert(i < 5 && j < 5 && k < 5) } Spin/Examples/README_tests.txt0000644000175100017510000002344012333741502014250 0ustar ghgh-- Updated for SPIN Version 6.3 --- May 2014 --- To get comfortable with using Spin, perform the tests test0 to test5 in the order listed, and check that you get the same results. The next four tests are to assess the effect of partial order reductions. In exhaustive mode, they may not all be executable within the bounds of your system - with reduction turned on, though, they should all run as specified. The last test checks the use of execution priorities during random simulations. You can always check valid options of spin by typing (at command prompt $): $ spin -- Similarly, you can check valid options of the compiled verifiers by typing: $ pan -- test 0 check that spin exists, is executable, and is the version that you expect $ spin -V Spin Version 6.0.0 -- 18 September 2010 test 1 check that you can run a simulation $ spin hello.pml passed first test! 1 process created or without the default indenting of output: $ spin -T hello.pml passed first test! 1 process created test 2 a basic reachability check (safety) $ spin -a loops.pml # generate c-verifier $ cc -DNOREDUCE -o pan pan.c # no reduction (test) $ ./pan # default run hint: this search is more efficient if pan.c is compiled -DSAFETY (Spin Version 6.0.0 -- 18 September 2010) Full statespace search for: never-claim - (none specified) assertion violations + acceptance cycles - (not selected) invalid endstates + State-vector 12 byte, depth reached 11, errors: 0 15 states, stored 4 states, matched 19 transitions (= stored+matched) 0 atomic steps hash conflicts: 0 (resolved) 2.501 memory usage (Mbyte) unreached in proctype loop line 12, state 12, "-end-" (1 of 12 states) pan: elapsed time 0 seconds test 3 cycle detection check (liveness): $ ./pan -a # search for acceptance cycles pan: acceptance cycle (at depth 0) pan: wrote loops.pml.trail (Spin Version 6.0.0 -- 18 September 2010) Warning: Search not completed Full statespace search for: never-claim - (none specified) assertion violations + > acceptance cycles + (fairness disabled) invalid endstates + State-vector 12 byte, depth reached 11, errors: 1 13 states, stored (15 visited) 2 states, matched 17 transitions (= visited+matched) 0 atomic steps hash conflicts: 0 (resolved) 2.501 memory usage (Mbyte) pan: elapsed time 0.015 seconds pan: rate 1000 states/second test 4 guided simulation check (playback the error trail found in test 3) $ spin -t -p loops.pml # guided simulation for the error-cycle <<<<>>>> 1: proc 0 (loop) loops.pml:5 (state 1) [a = ((a+1)%3)] 2: proc 0 (loop) loops.pml:7 (state 2) [b = (2*a)] 3: proc 0 (loop) loops.pml:7 (state 3) [(1)] 4: proc 0 (loop) loops.pml:10 (state 8) [b = (b-1)] 5: proc 0 (loop) loops.pml:5 (state 1) [a = ((a+1)%3)] 6: proc 0 (loop) loops.pml:7 (state 2) [b = (2*a)] 7: proc 0 (loop) loops.pml:7 (state 3) [(1)] 8: proc 0 (loop) loops.pml:10 (state 8) [b = (b-1)] 9: proc 0 (loop) loops.pml:5 (state 1) [a = ((a+1)%3)] 10: proc 0 (loop) loops.pml:8 (state 4) [b = (2*a)] 11: proc 0 (loop) loops.pml:8 (state 5) [(1)] spin: loops.pml:10, Error: value (-1->255 (8)) truncated in assignment 12: proc 0 (loop) loops.pml:10 (state 8) [b = (b-1)] spin: trail ends after 12 steps #processes: 1 12: proc 0 (loop) loops.pml:4 (state 9) 1 process created test 5 try to find a cycle that avoids the progress labels (there are none) $ cc -DNP -DNOREDUCE -o pan pan.c # add support for non-progress $ ./pan -l # search for non-progress cycles (Spin Version 6.0.0 -- 18 September 2010) Full statespace search for: never claim + assertion violations + (if within scope of claim) non-progress cycles + (fairness disabled) invalid end states - (disabled by never claim) State-vector 16 byte, depth reached 23, errors: 0 27 states, stored (39 visited) 28 states, matched 67 transitions (= visited+matched) 0 atomic steps hash conflicts: 0 (resolved) 2.501 memory usage (Mbyte) unreached in proctype loop line 12, state 12, "-end-" (1 of 12 states) pan: elapsed time 0 seconds test 6: check partial order reduction algorithm -- first disable it $ spin -a leader0.pml # note leader0.pml not leader.pml $ cc -DSAFETY -DNOREDUCE -DNOCLAIM -o pan pan.c # safety only $ ./pan -c0 -n # exhaustive, -c0 = ignore errors (Spin Version 6.0.0 -- 18 September 2010) Full statespace search for: never claim - (not selected) assertion violations + cycle checks - (disabled by -DSAFETY) invalid end states + State-vector 196 byte, depth reached 108, errors: 0 15779 states, stored 42402 states, matched 58181 transitions (= stored+matched) 12 atomic steps hash conflicts: 440 (resolved) Stats on memory usage (in Megabytes): 3.010 equivalent memory usage for states (stored*(State-vector + overhead)) 2.731 actual memory usage for states (compression: 90.73%) state-vector as stored = 177 byte + 4 byte overhead 2.000 memory used for hash table (-w19) 0.267 memory used for DFS stack (-m10000) 0.094 memory lost to fragmentation 4.904 total actual memory usage pan: elapsed time 0.125 seconds pan: rate 126232 states/second test 6b: now leave p.o. reduction enabled (i.e., do not disable it) $ cc -DSAFETY -DNOCLAIM -o pan pan.c # safety only, reduced search $ ./pan -c0 -n # -n = no dead code listing (Spin Version 6.0.0 -- 18 September 2010) + Partial Order Reduction Full statespace search for: never claim - (not selected) assertion violations + cycle checks - (disabled by -DSAFETY) invalid end states + State-vector 196 byte, depth reached 108, errors: 0 97 states, stored 0 states, matched 97 transitions (= stored+matched) 12 atomic steps hash conflicts: 0 (resolved) 2.501 memory usage (Mbyte) pan: elapsed time 0 seconds If compiled as above, the results should match the results from the table below. The numbers in the first two columns of the table should match precisely. The numbers in the third column should match approximately (how well it matches depends only on the properties of the C-compiler and the speed of the hardware you use to run the tests.) The first line for each test is for the exhaustive run, the second line is for the default run using partial order reduction. The times given are for a 2.4GHz dual-core Intel PC, with 2 GB of memory. States Stored Transitions Memory Used Time (s) leader0 S= 15779 T= 58181 M= 4.904 Mb t= 0.125 S= 97 T= 97 M= 2.501 Mb t= <0.1 snoopy S= 61619 T= 211398 M= 8.03 Mb t= 0.328 S= 9343 T= 12706 M= 3.38 Mb t= 0.03 pftp S= 144813 T= 397948 M= 18.97 Mb t= 0.79 S= 47356 T= 64970 M= 8.07 Mb t= 0.14 sort S= 107713 T= 512419 M= 18.87 Mb t= 1.08 S= 135 T= 135 M= 2.50 Mb t= <0.1 test 7 check random number generator $ spin -o6 -p -g -u10000 priorities.pml # runs 10000 steps # the -o6 restores the pre-release 6.2 functionality of priorities # for more info: http://spinroot.com/spin/multicore/priority.html .... depth-limit (-u10000 steps) reached #processes: 5 a[0] = 0 a[1] = 334 a[2] = 677 a[3] = 994 a[4] = 1327 10000: proc 4 (A) line 11 "priorities" (state 3) 10000: proc 3 (A) line 12 "priorities" (state 2) 10000: proc 2 (A) line 14 "priorities" (state 4) 10000: proc 1 (A) line 11 "priorities" (state 3) 10000: proc 0 (:init:) line 22 "priorities" (state 6) 5 processes created The numbers in the array should tend to the ratio 1:2:3:4 if the random number generator works properly. array index 0 remains unused (it's the pid of the init process) test 8 test the generation of never claims from LTL formulae: $ spin -f "[] ( p U ( <> q ))" never { /* [] ( p U ( <> q )) */ T0_init: if :: ((q)) -> goto accept_S9 :: (1) -> goto T0_init fi; accept_S9: if :: (1) -> goto T0_init fi; } Note: ltl formula are more conveniently specified inline when using Spin version 6 or later. Explore the use of inline ltl formula in the 16 examples in the LTL sub-directory There are additional examples of Promela models in this directory as well, not covered by the tests above. The tests used: hello.pml leader0.pml loops.pml priorities.pml Other examples include: abp.pml cambridge.pml dtp.pml eratosthenes.pml for_example.pml for_select_example.pml hajek.pml leader_trace.pml life.pml manna_pnueli.pml pathfinder.pml peterson.pml rtos1.pml sat.pml snoopy.pml sort.pml welfare.pml werkplaats.pml wordcount.pml The file pathfinder.pml, for instance, illustrates the use of 'provided' clauses (using as inspiration the bug in the control software of the Mars pathfinder that struck an otherwise perfect mission in July 1997) The file rtos1.pml illustrates the use of priorities. The file life.pml does a simple encoding of Conway's game of life. File sat.pml shows a satisfiability problem. The 10 files in the Exercises sub-directory include all exercises and examples from: http://spinroot.com/spin/Man/Exercises.html Last Updated: 11 May 2014 Spin/Examples/pan.m0000664000175100017510000000423712636050452012274 0ustar ghgh#define rand pan_rand #define pthread_equal(a,b) ((a)==(b)) #if defined(HAS_CODE) && defined(VERBOSE) #ifdef BFS_PAR bfs_printf("Pr: %d Tr: %d\n", II, t->forw); #else cpu_printf("Pr: %d Tr: %d\n", II, t->forw); #endif #endif switch (t->forw) { default: Uerror("bad forward move"); case 0: /* if without executable clauses */ continue; case 1: /* generic 'goto' or 'skip' */ IfNotBlocked _m = 3; goto P999; case 2: /* generic 'else' */ IfNotBlocked if (trpt->o_pm&1) continue; _m = 3; goto P999; /* PROC loop */ case 3: // STATE 1 - loops.pml:5 - [a = ((a+1)%3)] (0:0:1 - 1) IfNotBlocked reached[0][1] = 1; (trpt+1)->bup.oval = ((int)((P0 *)this)->a); ((P0 *)this)->a = ((((int)((P0 *)this)->a)+1)%3); #ifdef VAR_RANGES logval("loop:a", ((int)((P0 *)this)->a)); #endif ; _m = 3; goto P999; /* 0 */ case 4: // STATE 2 - loops.pml:7 - [b = (2*a)] (0:0:1 - 1) IfNotBlocked reached[0][2] = 1; (trpt+1)->bup.oval = ((int)((P0 *)this)->b); ((P0 *)this)->b = (2*((int)((P0 *)this)->a)); #ifdef VAR_RANGES logval("loop:b", ((int)((P0 *)this)->b)); #endif ; _m = 3; goto P999; /* 0 */ case 5: // STATE 4 - loops.pml:8 - [b = (2*a)] (0:0:1 - 1) IfNotBlocked reached[0][4] = 1; (trpt+1)->bup.oval = ((int)((P0 *)this)->b); ((P0 *)this)->b = (2*((int)((P0 *)this)->a)); #ifdef VAR_RANGES logval("loop:b", ((int)((P0 *)this)->b)); #endif ; _m = 3; goto P999; /* 0 */ case 6: // STATE 8 - loops.pml:10 - [b = (b-1)] (0:0:2 - 3) IfNotBlocked reached[0][8] = 1; (trpt+1)->bup.ovals = grab_ints(2); (trpt+1)->bup.ovals[0] = ((int)((P0 *)this)->b); ((P0 *)this)->b = (((int)((P0 *)this)->b)-1); #ifdef VAR_RANGES logval("loop:b", ((int)((P0 *)this)->b)); #endif ; if (TstOnly) return 1; /* TT */ /* dead 2: b */ #ifdef HAS_CODE if (!readtrail) #endif ((P0 *)this)->b = 0; _m = 3; goto P999; /* 0 */ case 7: // STATE 12 - loops.pml:12 - [-end-] (0:0:0 - 1) IfNotBlocked reached[0][12] = 1; if (!delproc(1, II)) continue; _m = 3; goto P999; /* 0 */ case _T5: /* np_ */ if (!((!(trpt->o_pm&4) && !(trpt->tau&128)))) continue; /* else fall through */ case _T2: /* true */ _m = 3; goto P999; #undef rand } Spin/Examples/hajek.pml0000644000175100017510000000203712331230217013115 0ustar ghgh/* * Hajek's THE protocol */ #define MAX 8 #define printf(a,b) skip chan q0 = [1] of { bit, byte }; chan q1 = [1] of { bit, byte }; proctype station(chan inp, out) { bit phased, phase, everaccepted, everfetched, c, v; bit gotack = 1; byte din, prev_din, dout=1; do :: empty(inp) -> printf("%d empty\n", _pid); c = 1; goto pr :: inp?v,din -> if :: c = 0 :: c = 1 fi; pr: if :: c == 0 -> if :: (!everaccepted && v) || (v != phased) -> gotack = 1; :: else fi; if :: (v != phased) || (!everaccepted) -> printf("%d accept\n", _pid); assert(din == (prev_din+1)%MAX); /* ACCEPT */ prev_din = din; everaccepted = 1; phased = v; phase = 1 - phase :: else fi :: c != 0 -> printf("%d error\n", _pid); fi; if :: gotack -> if :: everfetched -> progress: printf("%d fetch\n", _pid); dout = (dout+1)%MAX :: else fi; everfetched = 1 :: else fi; out!phase,dout; gotack = 0 od } init { atomic { run station(q0, q1); run station(q1, q0) } } Spin/Examples/Exercises/0000775000175100017510000000000012345167562013274 5ustar ghghSpin/Examples/Exercises/ex_3c.pml0000664000175100017510000000073612333741426015007 0ustar ghgh// http://spinroot.com/spin/Doc/Exercises.html // faulty mutual exclusion algorithm byte cnt byte x, y, z active [2] proctype user() { byte me = _pid+1 // 1 or 2 L1: x = me if :: (y != 0 && y != me) -> goto L1 // try again :: (y == 0 || y == me) fi z = me if :: (x != me) -> goto L1 // try again :: (x == me) fi y = me if :: (z != me) -> goto L1 // try again :: (z == me) fi // success cnt++ assert(cnt == 1) // critical section cnt-- goto L1 } Spin/Examples/Exercises/ex_6.pml0000664000175100017510000000342412333741426014644 0ustar ghgh// http://spinroot.com/spin/Doc/Exercises.html #define MaxSeq 3 #define inc(x) x = (x+1)%(MaxSeq+1) mtype = { none, red, white, blue } // Wolper's test bool sent_r, sent_b // initialized to false bool received_r, received_b // initialized to false chan q[2] = [MaxSeq] of { mtype, byte, byte } chan source = [0] of { mtype } active [2] proctype p5() { byte NextFrame, AckExp, FrameExp, r, s, nbuf, i byte frames[MaxSeq+1] mtype ball = none chan inp, out inp = q[_pid] out = q[1-_pid] do :: nbuf < MaxSeq -> nbuf++ if :: _pid%2 -> source?ball :: else fi frames[NextFrame] = ball out!ball, NextFrame, (FrameExp + MaxSeq) % (MaxSeq + 1) printf("MSC: nbuf: %d\n", nbuf) inc(NextFrame) :: inp?ball,r,s -> if :: r == FrameExp -> printf("MSC: accept %e %d\n", ball, r) if :: !(_pid%2) && ball == red -> received_r = true :: !(_pid%2) && ball == blue -> received_b = true :: else fi inc(FrameExp) :: else -> printf("MSC: reject\n") fi do :: ((AckExp <= s) && (s < NextFrame)) || ((AckExp <= s) && (NextFrame < AckExp)) || ((s < NextFrame) && (NextFrame < AckExp)) -> nbuf-- printf("MSC: nbuf: %d\n", nbuf) inc(AckExp) :: else -> printf("MSC: %d %d %d\n", AckExp, s, NextFrame) break od :: timeout -> NextFrame = AckExp printf("MSC: timeout\n") i = 1 do :: i <= nbuf -> if :: _pid%2 -> ball = frames[NextFrame] :: else fi out!ball, NextFrame, (FrameExp + MaxSeq) % (MaxSeq + 1) inc(NextFrame) i++ :: else -> break od od } active proctype Source() { do :: source!white :: source!red -> sent_r = true break od do :: source!white :: source!blue -> sent_b = true break od end: do :: source!white od } ltl p1 { (<> sent_r -> <> (received_r && !received_b)) } Spin/Examples/Exercises/ex_2.pml0000664000175100017510000000114012333741426014631 0ustar ghgh// http://spinroot.com/spin/Doc/Exercises.html mtype = { a0, a1, b0, b1, err } chan a2b = [0] of { mtype } // a rendezvous channel for messages from A to B chan b2a = [0] of { mtype } // a second channel for the reverse direction active proctype A() { S1: a2b!a1 S2: if :: b2a?b1 -> goto S1 :: b2a?b0 -> goto S3 :: b2a?err -> goto S5 fi S3: a2b!a1 -> goto S2 S4: b2a?err -> goto S5 S5: a2b!a0 -> goto S4 } active proctype B() { goto S2 S1: b2a!b1 S2: if :: a2b?a0 -> goto S3 :: a2b?a1 -> goto S1 :: a2b?err -> goto S5 fi S3: b2a!b0 -> goto S2 S4: a2b?_ -> goto S1 S5: a2b!b0 -> goto S4 } Spin/Examples/Exercises/ex_1f.pml0000664000175100017510000000040512333741426015001 0ustar ghgh// http://spinroot.com/spin/Doc/Exercises.html #ifndef N #define N 2 #endif init { chan dummy = [N] of { byte } // a message channel of N slots do :: dummy!85 // send byte value 85 to the channel :: dummy!170 // send byte value 170 to the channel od } Spin/Examples/Exercises/ex_3b.pml0000664000175100017510000000040512333741426014777 0ustar ghgh// http://spinroot.com/spin/Doc/Exercises.html // Peterson's algorithm, 1981 bool flag[2] bool turn active [2] proctype user() { flag[_pid] = true turn = _pid (flag[1-_pid] == false || turn == 1-_pid) crit: skip // critical section flag[_pid] = false } Spin/Examples/Exercises/ex_3a.pml0000664000175100017510000000112612333741426014777 0ustar ghghbool b[2] // Boolean array b(0;1) integer k, i, j active [2] proctype p() // comment process i { pid k, i = _pid, j = 1 -_pid // with i either 0 or 1 and j = 1-i; C0: b[i] = false // C0: b(i) := false; C1: if :: k != i // C1: if k != i then begin C2: if :: !b[j] -> goto C2 // C2: if not (b(j) then go to C2; :: else -> k = i; goto C1 // else k := i; go to C1 end; fi :: else CS: skip // else critical section; fi b[i] = true // b(i) := true; skip // remainder of program; goto C0 // go to C0; } // end ltl invariant { [] (!p[0]@CS || !p[1]@CS)} Spin/Examples/Exercises/ex_5.pml0000664000175100017510000000206212333741426014640 0ustar ghgh// http://spinroot.com/spin/Doc/Exercises.html // Sleep/Wakeup scheduling in the UTS kernel, Ruane 1990 mtype = { Wakeme, Running } bit lk, sleep_q bit r_lock, r_want mtype State = Running active proctype client() { sleep: // sleep routine atomic { (lk == 0) -> lk = 1 } // spinlock(&lk) do // while r->lock :: (r_lock == 1) -> // r->lock == 1 r_want = 1 State = Wakeme lk = 0 // freelock(&lk) (State == Running) // wait for wakeup :: else -> // r->lock == 0 break od; progress: assert(r_lock == 0) // should still be true r_lock = 1 // consumed resource lk = 0 // freelock(&lk) goto sleep } active proctype server() // interrupt routine { wakeup: // wakeup routine r_lock = 0 // r->lock = 0 (lk == 0) // waitlock(&lk) if :: r_want -> // someone is sleeping atomic { // spinlock on sleep queue (sleep_q == 0) -> sleep_q = 1 } r_want = 0 #ifdef PROPOSED_FIX (lk == 0) // waitlock(&lk) #endif if :: (State == Wakeme) -> State = Running :: else -> fi; sleep_q = 0 :: else -> fi goto wakeup } Spin/Examples/Exercises/ex_1a.pml0000664000175100017510000000020612333741426014773 0ustar ghgh// http://spinroot.com/spin/Doc/Exercises.html init { byte i // initialized to 0 by default do :: i++ // increment i by one od } Spin/Examples/Exercises/ex_4.pml0000664000175100017510000000103012333741426014631 0ustar ghgh// http://spinroot.com/spin/Doc/Exercises.html // a simple model of a Petri Net #define Place byte // assume at most 255 tokens per place Place p1=1, p2, p3 Place p4=1, p5, p6 #define inp1(x) (x>0) -> x-- #define inp2(x,y) (x>0 && y>0) -> x--; y-- #define out1(x) x++ #define out2(x,y) x++; y++ init { do :: inp1(p1) -> out1(p2) // t1 :: inp2(p2,p4) -> out1(p3) // t2 :: inp1(p3) -> out2(p1,p4) // t3 :: inp1(p4) -> out1(p5) // t4 :: inp2(p1,p5) -> out1(p6) // t5 :: inp1(p6) -> out2(p4,p1) // t6 od } Spin/Examples/pan.p0000664000175100017510000015553712636050452012311 0ustar ghgh#include #include #include #include #include #ifdef BFS_DISK #include #include #include #include #endif #define Max(a,b) (((a)>(b))?(a):(b)) #ifndef WAIT_MAX #define WAIT_MAX 2 /* seconds */ #endif #define BFS_GEN 2 /* current and next generation */ typedef struct BFS_Slot BFS_Slot; typedef struct BFS_shared BFS_shared; typedef struct BFS_data BFS_data; struct BFS_Slot { #ifdef BFS_FIFO enum bfs_types type; /* message type */ #endif BFS_State *s_data; /* state data */ #ifndef BFS_QSZ BFS_Slot *nxt; /* linked list */ #endif }; struct BFS_data { double memcnt; double nstates; double nlinks; double truncs; ulong mreached; ulong vsize; ulong memory_left; ulong punted; ulong errors; int override; /* after crash, if another proc clears locks */ }; struct BFS_shared { /* about 13K for BFS_MAXPROCS=16 and BFS_MAXLOCKS=1028 */ volatile ulong quit; /* set to signal termination -- one word */ volatile ulong started; volatile uchar sh_owner[BFS_MAXLOCKS]; /* optional */ #ifdef BFS_CHECK volatile uchar in_count[BFS_MAXLOCKS]; /* optional */ #endif volatile int sh_locks[BFS_MAXLOCKS]; volatile ulong wait_count[BFS_MAXLOCKS]; /* optional */ volatile BFS_data bfs_data[BFS_MAXPROCS]; volatile uchar bfs_flag[BFS_MAXPROCS]; /* running 0, normal exit 1, abnormal 2 */ volatile uchar bfs_idle[BFS_MAXPROCS]; /* set when all input queues are empty */ #ifdef BFS_DISK volatile uchar bfs_out_cnt[BFS_MAXPROCS]; /* set when core writes a state */ #endif #ifdef BFS_QSZ #define BFS_NORECYCLE #if BFS_QSZ<=0 #error BFS_QSZ must be positive #endif #ifdef BFS_FIFO #error BFS_QSZ cannot be combined with BFS_FIFO #endif #ifdef BFS_DISK #error BFS_QSZ cannot be combined with BFS_DISK #endif volatile BFS_Slot bfsq[BFS_GEN][BFS_MAXPROCS][BFS_MAXPROCS][BFS_QSZ]; volatile uint bfs_ix[BFS_GEN][BFS_MAXPROCS][BFS_MAXPROCS]; #else volatile BFS_Slot *head[BFS_GEN][BFS_MAXPROCS][BFS_MAXPROCS]; #endif #ifdef BFS_FIFO volatile BFS_Slot *tail[BFS_GEN][BFS_MAXPROCS][BFS_MAXPROCS]; volatile BFS_Slot *dels[BFS_GEN][BFS_MAXPROCS][BFS_MAXPROCS]; #endif #ifdef BFS_LOGMEM volatile ulong logmem[1024]; #endif volatile ulong mem_left; volatile uchar *allocator; /* start of shared heap, must be last */ }; enum bfs_types { EMPTY = 0, STATE, DELETED }; extern volatile uchar *bfs_get_shared_mem(key_t, size_t); extern BFS_Slot * bfs_new_slot(BFS_Trail *); extern BFS_Slot * bfs_prep_slot(BFS_Trail *, BFS_Slot *); extern BFS_Slot * bfs_next(void); extern BFS_Slot * bfs_pack_state(Trail *, BFS_Trail *, int, BFS_Slot *); extern SV_Hold * bfs_new_sv(int); #if NRUNS>0 extern EV_Hold * bfs_new_sv_mask(int); #endif extern BFS_Trail * bfs_grab_trail(void); extern BFS_Trail * bfs_unpack_state(BFS_Slot *); extern int bfs_all_empty(void); extern int bfs_all_idle(void); extern int bfs_all_running(void); extern int bfs_idle_and_empty(void); extern size_t bfs_find_largest(key_t); extern void bfs_clear_locks(void); extern void bfs_drop_shared_memory(void); extern void bfs_explore_state(BFS_Slot *); extern void bfs_initial_state(void); extern void bfs_mark_done(int); extern void bfs_printf(const char *fmt, ...); extern void bfs_push_state(Trail *, BFS_Trail *, int); extern void bfs_recycle(BFS_Slot *); extern void bfs_release_trail(BFS_Trail *); extern void bfs_run(void); extern void bfs_setup_mem(void); extern void bfs_setup(void); extern void bfs_shutdown(const char *); extern void bfs_statistics(void); extern void bfs_store_state(Trail *, short); extern void bfs_set_toggle(void); extern void bfs_update(void); #ifdef MA #error cannot combine -DMA with -DBFS_PAR /* would require us to parallize g_store */ #endif #ifdef BCS #error cannot combine -DBCS with -DBFS_PAR #endif #ifdef BFS_DISK #ifdef BFS_FIFO #error cannot combine BFS_DISK and BFS_FIFO #endif extern void bfs_disk_start(void); extern void bfs_disk_stop(void); extern void bfs_disk_out(void); extern void bfs_disk_inp(void); extern void bfs_disk_iclose(void); extern void bfs_disk_oclose(void); int bfs_out_fd[BFS_MAXPROCS]; int bfs_inp_fd[BFS_MAXPROCS]; #endif static BFS_shared *shared_memory; #ifndef BFS_QSZ static BFS_Slot *bfs_free_slot; /* local free list */ #endif static BFS_Slot bfs_null; static SV_Hold *bfs_svfree[VECTORSZ]; static uchar *bfs_heap; /* local pointer into heap */ static ulong bfs_left; /* local part of shared heap */ #if NRUNS>0 static void bfs_keep(EV_Hold *); #endif static long bfs_sent; /* nr msgs sent -- local to each process */ static long bfs_rcvd; /* nr msgs rcvd */ static long bfs_sleep_cnt; /* stats */ static long bfs_wcount; static long bfs_gcount; static ulong bfs_total_shared; #ifdef BFS_STAGGER static int bfs_stage_cnt = 0; static void bfs_stagger_flush(void); #endif static int bfs_toggle; /* local variable, 0 or 1 */ static int bfs_qscan; /* scan input queues in order */ static ulong bfs_snapped; static int shared_mem_id; #ifndef NOREDUCE static int bfs_nps; /* no preselection */ #endif ulong bfs_punt; /* states dropped for lack of memory */ #if defined(VERBOSE) || defined(BFS_CHECK) static const char *bfs_sname[] = { "EMPTY", /* 0 */ "STATE", /* 1 */ "STATE", /* 2 = DELETED */ 0 }; #endif static const char *bfs_lname[] = { /* match values defined in pangen2.c */ "global lock", /* BFS_GLOB */ "ordinal", /* BFS_ORD */ "shared memory", /* BFS_MEM */ "print to stdout", /* BFS_PRINT */ "hashtable", /* BFS_STATE */ 0 }; static ulong bfs_count[DELETED+1]; /* indexed with bfs_types: EMPTY=0, STATE=1, DELETED=2 */ static int bfs_keep_state; int Cores = 1; int who_am_i = 0; /* root */ #ifdef L_BOUND int L_bound = L_BOUND; #endif #ifdef BFS_CHECK void bfs_dump_now(char *s) { int i; char *p = (char *) &now; e_critical(BFS_PRINT); printf("%s\t", s); printf("%3lu: ", vsize); for (i = 0; i < vsize; i++) { printf("%3d ", *p++); } printf(" %s\noffsets:\t", s); for (i = 0; i < now._nr_pr; i++) { printf("%3d ", proc_offset[i]); } printf("\n"); x_critical(BFS_PRINT); } void view_state(char *s) /* debugging */ { int i; char *p; e_critical(BFS_PRINT); printf("cpu%02d %s: ", who_am_i, s); p = (char *)&now; for (i = 0; i < vsize; i++) printf("%3d, ", *p++); printf("\n"); fflush(stdout); x_critical(BFS_PRINT); } #endif void bfs_main(int ncores, int cycles) { if (cycles) { fprintf(stderr, "pan: cycle detection is not supported in this mode\n"); exit(1); } if (ncores == 0) /* i.e., find out */ { FILE *fd; char buf[512]; if ((fd = fopen("/proc/cpuinfo", "r")) == NULL) { /* cannot tell */ ncores = Cores; /* use the default */ } else { while (fgets(buf, sizeof(buf), fd)) { if (strncmp(buf, "processor", strlen("processor")) == 0) { ncores++; } } fclose(fd); ncores--; if (verbose) { printf("pan: %d available cores\n", ncores+1); } } } if (ncores >= BFS_MAXPROCS) { Cores = BFS_MAXPROCS-1; /* why -1? */ } else if (ncores < 1) { Cores = 1; } else { Cores = ncores; } printf("pan: using %d core%s\n", Cores, (Cores>1)?"s":""); fflush(stdout); #ifdef BFS_DISK bfs_disk_start(); #endif bfs_setup(); /* shared memory segments and fork */ bfs_run(); if (who_am_i == 0) { stop_timer(0); } bfs_statistics(); bfs_mark_done(1); if (who_am_i == 0) { report_time(); #ifdef BFS_DISK bfs_disk_stop(); #endif } #ifdef C_EXIT C_EXIT; /* trust that it defines a fct */ #endif bfs_drop_shared_memory(); exit(0); } void bfs_setup_mem(void) { size_t n; key_t key; #ifdef BFS_FIFO bfs_null.type = EMPTY; #endif ntrpt = (Trail *) emalloc(sizeof(Trail)); if ((key = ftok(".", (int) 'L')) == -1) { perror("ftok shared memory"); exit(1); } n = bfs_find_largest(key); bfs_total_shared = (ulong) n; shared_memory = (BFS_shared *) bfs_get_shared_mem(key, n); /* root */ shared_memory->allocator = (uchar *) shared_memory + sizeof(BFS_shared); shared_memory->mem_left = (ulong) (n - sizeof(BFS_shared)); } ulong bfs_LowLim; #ifndef BFS_RESERVE #define BFS_RESERVE 5 #else #if BFS_RESERVE<1 #error BFS_RESERVE must be at least 1 #endif #endif void bfs_setup(void) /* executed by root */ { int i, j; ulong n; /* share of shared memory allocated to each core */ n = shared_memory->mem_left / (Cores + Cores/(BFS_RESERVE)); /* keep some reserve */ if ((n%sizeof(void *)) != 0) { n -= (n%sizeof(void *)); /* align, without exceeding total */ } for (i = 0; i < Cores-1; i++) { j = fork(); if (j == -1) { bfs_printf("fork failed\n"); exit(1); } if (j == 0) { who_am_i = i+1; /* 1..Cores-1 */ break; } } e_critical(BFS_MEM); bfs_heap = (uchar *) shared_memory->allocator; shared_memory->allocator += n; shared_memory->mem_left -= n; x_critical(BFS_MEM); bfs_left = n; bfs_runs = 1; bfs_LowLim = n / (2 * (ulong) Cores); } void bfs_run(void) { BFS_Slot *v; #ifdef BFS_DISK bfs_disk_out(); #endif if (who_am_i == 0) { bfs_initial_state(); } #ifdef BFS_DISK #ifdef BFS_STAGGER bfs_stagger_flush(); #endif bfs_disk_oclose(); #endif #ifdef BFS_FIFO static int i_count; #endif srand(s_rand+HASH_NR); bfs_qscan = 0; bfs_toggle = 1 - bfs_toggle; /* after initial state */ e_critical(BFS_GLOB); shared_memory->started++; x_critical(BFS_GLOB); while (shared_memory->started != Cores) /* wait for all cores to connect */ { usleep(1); } #ifdef BFS_DISK bfs_disk_out(); bfs_disk_inp(); #endif start_timer(); while (shared_memory->quit == 0) { v = bfs_next(); /* get next message from current generation */ if (v->s_data) /* v->type == STATE || v->type == DELETED */ { bfs_count[STATE]++; #ifdef VERBOSE bfs_printf("GOT STATE (depth %d, nr %u)\n", v->s_data->t_info->o_tt, v->s_data->nr); #endif /* last resort: start dropping states when out of memory */ if (bfs_left > 1024 || shared_memory->mem_left > 1024) { bfs_explore_state(v); } else { static int warned_loss = 0; if (warned_loss == 0 && who_am_i == 0) { warned_loss++; bfs_printf("out of shared memory - losing states\n"); } bfs_punt++; } #if !defined(BFS_FIFO) && !defined(BFS_NORECYCLE) bfs_recycle(v); #endif #ifdef BFS_FIFO i_count = 0; #endif } else { bfs_count[EMPTY]++; #if defined(BFS_FIFO) && defined(BFS_CHECK) assert(v->type == EMPTY); #endif #ifdef BFS_FIFO if (who_am_i == 0) { if (bfs_idle_and_empty()) { if (i_count++ > 10) { shared_memory->quit = 1; } else usleep(1); } } else if (!bfs_all_running()) { bfs_shutdown("early termination"); } #else if (who_am_i == 0) { if (bfs_all_idle()) /* wait for it */ { if (!bfs_all_empty()) /* more states to process */ { bfs_set_toggle(); goto do_toggle; } else /* done */ { shared_memory->quit = 1; /* step 4 */ } } else { bfs_sleep_cnt++; } } else { /* wait for quit or idle bit to be reset by root */ while (shared_memory->bfs_idle[who_am_i] == 1 && shared_memory->quit == 0) { if (bfs_all_running()) { bfs_sleep_cnt++; usleep(10); /* new 6.2.3 */ } else { bfs_shutdown("early termination"); /* no return */ } } do_toggle: bfs_qscan = 0; #ifdef BFS_DISK bfs_disk_iclose(); bfs_disk_oclose(); #endif bfs_toggle = 1 - bfs_toggle; #ifdef BFS_DISK bfs_disk_out(); bfs_disk_inp(); #endif #ifdef BFS_CHECK bfs_printf("toggle: recv from %d, send to %d\n", bfs_toggle, 1 - bfs_toggle); #endif } #endif } } #ifdef BFS_CHECK bfs_printf("done, sent %5ld recvd %5ld punt %5lu sleep: %ld\n", bfs_sent, bfs_rcvd, bfs_punt, bfs_sleep_cnt); #endif } void bfs_report_mem(void) /* called from within wrapup() */ { printf("%9.3f total shared memory usage\n\n", ((double) bfs_total_shared - (double) bfs_left)/(1024.*1024.)); } void bfs_statistics(void) { #ifdef VERBOSE enum bfs_types i; #endif if (verbose) bfs_printf("states sent %7ld recvd %7ld stored %8g sleeps: %4ld, %4ld, %ld\n", bfs_sent, bfs_rcvd, nstates, bfs_wcount, bfs_gcount, bfs_sleep_cnt); if (0) bfs_printf("states punted %7lu\n", bfs_punt); #ifdef VERBOSE for (i = EMPTY; i <= DELETED; i++) { if (bfs_count[i] > 0) { bfs_printf("%6s %8lu\n", bfs_sname[i], bfs_count[i]); } } #endif bfs_update(); if (who_am_i == 0 && shared_memory) { int i; ulong count = 0L; done = 1; e_critical(BFS_PRINT); wrapup(); if (verbose) { printf("\nlock-wait counts:\n"); for (i = 0; i < BFS_STATE; i++) printf("%16s %9lu\n", bfs_lname[i], shared_memory->wait_count[i]); #ifndef BITSTATE for (i = BFS_STATE; i < BFS_MAXLOCKS; i++) { if (0) printf(" [%6d] %9lu\n", i, shared_memory->wait_count[i]); count += shared_memory->wait_count[i]; } printf("%16s %9lu (avg per region)\n", bfs_lname[BFS_STATE], count/(BFS_MAXLOCKS - BFS_STATE)); #endif } fflush(stdout); x_critical(BFS_PRINT); } } void bfs_snapshot(void) { clock_t stop_time; double delta_time; struct tms stop_tm; volatile BFS_data *s; e_critical(BFS_PRINT); printf("cpu%02d Depth= %7lu States= %8.3g Transitions= %8.3g ", who_am_i, mreached, nstates, nstates+truncs); printf("Memory= %9.3f\t", memcnt/1048576.); printf("SharedMLeft= %4lu ", bfs_left/1048576); stop_time = times(&stop_tm); delta_time = ((double) (stop_time - start_time))/((double) sysconf(_SC_CLK_TCK)); if (delta_time > 0.01) { printf("t= %6.3g R= %6.0g\n", delta_time, nstates/delta_time); } else { printf("t= %6.3g R= %6.0g\n", 0., 0.); } fflush(stdout); x_critical(BFS_PRINT); s = &shared_memory->bfs_data[who_am_i]; s->mreached = (ulong) mreached; s->vsize = (ulong) vsize; s->errors = (int) errors; s->memcnt = (double) memcnt; s->nstates = (double) nstates; s->nlinks = (double) nlinks; s->truncs = (double) truncs; s->memory_left = (ulong) bfs_left; s->punted = (ulong) bfs_punt; bfs_snapped++; /* for bfs_best */ } void bfs_shutdown(const char *s) { bfs_clear_locks(); /* in case we interrupted at a bad point */ if (!strstr(s, "early ") || verbose) { bfs_printf("stop (%s)\n", s); } bfs_update(); if (who_am_i == 0) { wrapup(); #ifdef BFS_DISK bfs_disk_stop(); #endif } bfs_mark_done(2); pan_exit(2); } SV_Hold *bfs_free_hold; SV_Hold * bfs_get_hold(void) { SV_Hold *x; if (bfs_free_hold) { x = bfs_free_hold; bfs_free_hold = bfs_free_hold->nxt; } else { x = (SV_Hold *) sh_malloc((ulong) sizeof(SV_Hold)); } return x; } BFS_Trail * bfs_unpack_state(BFS_Slot *n) /* called in bfs_explore_state */ { BFS_Trail *otrpt; BFS_State *bfs_t; int vecsz; if (!n || !n->s_data || !n->s_data->t_info) { bfs_Uerror("internal error"); } otrpt = (BFS_Trail *) ((BFS_State *) n->s_data)->t_info; trpt->ostate = otrpt->ostate; trpt->st = otrpt->st; trpt->o_tt = otrpt->o_tt; trpt->pr = otrpt->pr; trpt->tau = otrpt->tau; trpt->o_pm = otrpt->o_pm; if (trpt->ostate) trpt->o_t = t_id_lkup[otrpt->t_id]; #if defined(C_States) && (HAS_TRACK==1) c_revert((uchar *) &(now.c_state[0])); #endif if (trpt->o_pm & 4) /* rv succeeded */ { return (BFS_Trail *) 0; /* revisit not needed */ } #ifndef NOREDUCE bfs_nps = 0; #endif if (trpt->o_pm & 8) /* rv attempt failed */ { revrv++; if (trpt->tau&8) { trpt->tau &= ~8; /* break atomic */ #ifndef NOREDUCE } else if (trpt->tau&32) /* void preselection */ { trpt->tau &= ~32; bfs_nps = 1; /* no preselection in repeat */ #endif } } trpt->o_pm &= ~(4|8); if (trpt->o_tt > mreached) { static ulong nr = 0L, nc; mreached = trpt->o_tt; nc = (long) nstates/FREQ; if (nc > nr) { nr = nc; bfs_snapshot(); } } depth = trpt->o_tt; if (depth >= maxdepth) { #if SYNC if (boq != -1) { BFS_Trail *x = (BFS_Trail *) trpt->ostate; if (x) x->o_pm |= 4; /* rv not failing */ } #endif truncs++; if (!warned) { warned = 1; bfs_printf("error: max search depth too small\n"); } if (bounded) { bfs_uerror("depth limit reached"); } return (BFS_Trail *) 0; } bfs_t = n->s_data; #if NRUNS>0 vsize = bfs_t->omask->sz; #else vsize = ((State *) (bfs_t->osv))->_vsz; #endif #if SYNC boq = bfs_t->boq; #endif #if defined(Q_PROVISO) && !defined(BITSTATE) && defined(FULLSTACK) #ifdef USE_TDH if (((uchar *)(bfs_t->lstate))) /* if BFS_INQ is set */ { *((uchar *) bfs_t->lstate) = 0; /* turn it off */ } #else if (bfs_t->lstate) /* bfs_par */ { bfs_t->lstate->tagged = 0; /* bfs_par state removed from q */ } #endif #endif memcpy((char *) &now, (uchar *) bfs_t->osv, vsize); #if !defined(NOCOMP) && !defined(HC) && NRUNS>0 Mask = (uchar *) bfs_t->omask->sv; /* in shared memory */ #endif #ifdef BFS_CHECK if (0) bfs_dump_now("got1"); #endif #ifdef TRIX re_populate(); #else #if NRUNS>0 if (now._nr_pr > 0) { #if VECTORSZ>32000 proc_offset = (int *) bfs_t->omask->po; #else proc_offset = (short *) bfs_t->omask->po; #endif proc_skip = (uchar *) bfs_t->omask->ps; } if (now._nr_qs > 0) { #if VECTORSZ>32000 q_offset = (int *) bfs_t->omask->qo; #else q_offset = (short *) bfs_t->omask->qo; #endif q_skip = (uchar *) bfs_t->omask->qs; } #endif #endif vecsz = ((State *) bfs_t->osv)->_vsz; #ifdef BFS_CHECK assert(vecsz > 0 && vecsz < VECTORSZ); #endif { SV_Hold *x = bfs_get_hold(); x->sv = bfs_t->osv; x->nxt = bfs_svfree[vecsz]; bfs_svfree[vecsz] = x; bfs_t->osv = (State *) 0; } #if NRUNS>0 bfs_keep(bfs_t->omask); #endif #ifdef BFS_CHECK if (0) bfs_dump_now("got2"); if (0) view_state("after"); #endif return (BFS_Trail *) bfs_t->t_info; } void bfs_initial_state(void) { #ifdef BFS_CHECK assert(trpt != NULL); #endif trpt->ostate = (H_el *) 0; trpt->o_tt = -1; trpt->tau = 0; #ifdef VERI trpt->tau |= 4; /* claim moves first */ #endif bfs_store_state(trpt, boq); /* initial state : bfs_lib.c */ } #ifdef BITSTATE #define bfs_do_store(v, n) b_store(v, n) #else #ifdef USE_TDH #define bfs_do_store(v, n) o_store(v, n) #else #define bfs_do_store(v, n) h_store(v, n) #endif #endif #ifdef BFS_SEP_HASH int bfs_seen_before(void) { /* cannot set trpt->tau |= 64 to mark successors outside stack */ /* since the check is done remotely and the trpt value is gone */ #ifdef VERI if (!trpt->ostate /* initial state */ || ((trpt->tau&4) /* starting claim moves(s) */ && !(((BFS_Trail *)trpt->ostate)->tau&4))) /* prev move: prog */ { return 0; /* claim move: mid-state not stored */ } /* else */ #endif if (!bfs_do_store((char *)&now, vsize)) /* sep_hash */ { nstates++; /* local count */ return 0; /* new state */ } #ifdef BFS_CHECK bfs_printf("seen before\n"); #endif truncs++; return 1; /* old state */ } #endif void bfs_explore_state(BFS_Slot *v) /* generate all successors of v */ { BFS_Trail *otrpt; Trans *t; #ifdef HAS_UNLESS int E_state; #endif int tt; short II, To = BASE, From = (short) (now._nr_pr-1); short oboq = boq; uchar _n, _m, ot; memset(ntrpt, 0, sizeof(Trail)); otrpt = bfs_unpack_state(v); /* BFS_Trail */ if (!otrpt) { return; } /* e.g., depth limit reached */ #ifdef L_BOUND #if defined(VERBOSE) bfs_printf("Unpacked state with l_bound %d -- sds %p\n", now._l_bnd, now._l_sds); #endif #endif #if defined(C_States) && (HAS_TRACK==1) c_revert((uchar *) &(now.c_state[0])); #endif #ifdef BFS_SEP_HASH if (bfs_seen_before()) return; #endif #ifdef VERI if (now._nr_pr == 0 /* claim terminated */ || stopstate[((Pclaim *)pptr(0))->_t][((Pclaim *)pptr(0))->_p]) { bfs_uerror("end state in claim reached"); } #endif trpt->tau &= ~1; /* timeout off */ #ifdef VERI if (trpt->tau&4) /* claim move */ { trpt->tau |= (otrpt->tau)&1; /* inherit from prog move */ From = To = 0; /* claim */ goto Repeat_two; } #endif #ifndef NOREDUCE if (boq == -1 && !(trpt->tau&8) && bfs_nps == 0) for (II = now._nr_pr-1; II >= BASE; II -= 1) { Pickup: this = pptr(II); tt = (int) ((P0 *)this)->_p; ot = (uchar) ((P0 *)this)->_t; if (trans[ot][tt]->atom & 8) { t = trans[ot][tt]; if (t->qu[0] != 0) { if (!q_cond(II, t)) continue; } From = To = II; trpt->tau |= 32; /* preselect marker */ #ifdef VERBOSE bfs_printf("%3ld: proc %d PreSelected (tau=%d)\n", depth, II, trpt->tau); #endif goto Repeat_two; } } trpt->tau &= ~32; #endif Repeat_one: if (trpt->tau&8) { From = To = (short ) trpt->pr; /* atomic */ } else { From = now._nr_pr-1; To = BASE; } #if defined(VERI) || !defined(NOREDUCE) || defined(ETIM) Repeat_two: /* MainLoop */ #endif _n = _m = 0; for (II = From; II >= To; II -= 1) /* all processes */ { #ifdef BFS_CHECK bfs_printf("proc %d (%d - %d)\n", II, From, To); #endif #if SYNC if (boq != -1 && trpt->pr == II) { continue; /* no rendezvous with same proc */ } #endif this = pptr(II); tt = (int) ((P0 *)this)->_p; ot = (uchar) ((P0 *)this)->_t; ntrpt->pr = (uchar) II; ntrpt->st = tt; trpt->o_pm &= ~1; /* no move yet */ #ifdef EVENT_TRACE trpt->o_event = now._event; #endif #ifdef HAS_PRIORITY if (!highest_priority(((P0 *)this)->_pid, II, t)) { continue; } #else #ifdef HAS_PROVIDED if (!provided(II, ot, tt, t)) { continue; } #endif #endif #ifdef HAS_UNLESS E_state = 0; #endif for (t = trans[ot][tt]; t; t = t->nxt) /* all process transitions */ { #ifdef BFS_CHECK assert(t_id_lkup[t->t_id] == t); /* for reverse lookup in bfs_unpack_state */ #endif #ifdef VERBOSE if (0) bfs_printf("\tproc %d tr %d\n", II, t->forw); #endif #ifdef HAS_UNLESS if (E_state > 0 && E_state != t->e_trans) break; #endif /* trpt->o_t = */ ntrpt->o_t = t; oboq = boq; if (!(_m = do_transit(t, II))) continue; trpt->o_pm |= 1; /* we moved */ (trpt+1)->o_m = _m; /* for unsend */ #ifdef PEG peg[t->forw]++; #endif #ifdef VERBOSE e_critical(BFS_PRINT); printf("%3ld: proc %d exec %d, ", depth, II, t->forw); printf("%d to %d, %s %s %s", tt, t->st, t->tp, (t->atom&2)?"atomic":"", (boq != -1)?"rendez-vous":""); #ifdef HAS_UNLESS if (t->e_trans) printf(" (escapes to state %d)", t->st); #endif printf(" %saccepting [tau=%d]\n", (trpt->o_pm&2)?"":"non-", trpt->tau); x_critical(BFS_PRINT); #endif #ifdef HAS_UNLESS E_state = t->e_trans; #if SYNC>0 if (t->e_trans > 0 && boq != -1) { fprintf(efd, "error: rendezvous stmnt in the escape clause\n"); fprintf(efd, " of unless stmnt not compatible with -DBFS\n"); pan_exit(1); } #endif #endif if (t->st > 0) { ((P0 *)this)->_p = t->st; } /* use the ostate ptr, with type *H_el, to temporarily store *BFS_Trail */ #ifdef BFS_NOTRAIL ntrpt->ostate = (H_el *) 0; /* no error-traces in this mode */ #else ntrpt->ostate = (H_el *) otrpt; /* parent stackframe */ #endif /* ntrpt->st = tt; * was already set above */ if (boq == -1 && (t->atom&2)) /* atomic */ { ntrpt->tau = 8; /* record for next move */ } else { ntrpt->tau = 0; /* no timeout or preselect etc */ } #ifdef VERI ntrpt->tau |= trpt->tau&4; /* if claim, inherit */ if (boq == -1 && !(ntrpt->tau&8)) /* unless rv or atomic */ { if (ntrpt->tau&4) /* claim */ { ntrpt->tau &= ~4; /* switch to prog */ } else { ntrpt->tau |= 4; /* switch to claim */ } } #endif #ifdef L_BOUND { uchar obnd = now._l_bnd; uchar *os = now._l_sds; #ifdef VERBOSE bfs_printf("saving bound %d -- sds %p\n", obnd, (void *) os); #endif #endif bfs_store_state(ntrpt, oboq); #ifdef EVENT_TRACE now._event = trpt->o_event; #endif /* undo move and generate other successor states */ trpt++; /* this is where ovals and ipt are set */ do_reverse(t, II, _m); /* restore now. */ #ifdef L_BOUND #ifdef VERBOSE bfs_printf("restoring bound %d -- sds %p\n", obnd, (void *) os); #endif now._l_bnd = obnd; now._l_sds = os; } #endif trpt--; #ifdef VERBOSE e_critical(BFS_PRINT); printf("%3ld: proc %d ", depth, II); printf("reverses %d, %d to %d,", t->forw, tt, t->st); printf(" %s [abit=%d,adepth=%d,", t->tp, now._a_t, 0); printf("tau=%d,%d]\n", trpt->tau, (trpt-1)->tau); x_critical(BFS_PRINT); #endif reached[ot][t->st] = 1; reached[ot][tt] = 1; ((P0 *)this)->_p = tt; _n |= _m; } } #ifdef VERBOSE bfs_printf("done _n = %d\n", _n); #endif #ifndef NOREDUCE /* preselected - no succ definitely outside stack */ if ((trpt->tau&32) && !(trpt->tau&64)) { From = now._nr_pr-1; To = BASE; #ifdef VERBOSE bfs_printf("%3ld: proc %d UnSelected (_n=%d, tau=%d)\n", depth, II+1, (int) _n, trpt->tau); #endif _n = 0; trpt->tau &= ~32; if (II >= BASE) { goto Pickup; } goto Repeat_two; } trpt->tau &= ~(32|64); #endif if (_n == 0 #ifdef VERI && !(trpt->tau&4) #endif ) { /* no successor states generated */ if (boq != -1) /* was rv move */ { BFS_Trail *x = (BFS_Trail *) trpt->ostate; /* pre-rv state */ if (x && ((x->tau&8) || (x->tau&32))) /* break atomic or preselect */ { x->o_pm |= 8; /* mark failure */ this = pptr(otrpt->pr); ((P0 *) this)->_p = otrpt->st; /* reset state */ unsend(boq); /* retract rv offer */ boq = -1; #ifdef VERBOSE printf("repush state\n"); #endif bfs_push_state(NULL, x, x->o_tt); /* repush rv fail */ } /* else the rv need not be retried */ } else if (now._nr_pr > BASE) /* possible deadlock */ { if ((trpt->tau&8)) /* atomic step blocked */ { trpt->tau &= ~(1|8); /* 1=timeout, 8=atomic */ goto Repeat_one; } #ifdef ETIM /* if timeouts were used in the model */ if (!(trpt->tau&1)) { trpt->tau |= 1; /* enable timeout */ goto Repeat_two; } #endif if (!noends && !endstate()) { bfs_uerror("invalid end state."); } } #ifdef VERI else /* boq == -1 && now._nr_pr == BASE && trpt->tau != 4 */ { trpt->tau |= 4; /* switch to claim for stutter moves */ #ifdef VERBOSE printf("%3ld: proc -1 exec -1, (stutter move)\n", depth, II); #endif bfs_store_state(trpt, boq); #ifdef VERBOSE printf("%3ld: proc -1 reverses -1, (stutter move)\n", depth, II); #endif trpt->tau &= ~4; /* undo, probably not needed */ } #endif } #ifdef BFS_NOTRAIL bfs_release_trail(otrpt); #endif } #if !defined(BFS_FIFO) && !defined(BFS_NORECYCLE) void bfs_recycle(BFS_Slot *n) { #ifdef BFS_CHECK assert(n != &bfs_null); #endif n->nxt = bfs_free_slot; bfs_free_slot = n; #ifdef BFS_CHECK bfs_printf("recycles %s -- %p\n", n->s_data?"STATE":"EMPTY", (void *) n); #endif } #endif #ifdef BFS_FIFO int bfs_empty(int p) { int i; const int dst = 0; for (i = 0; i < Cores; i++) { if (shared_memory->head[dst][p][i] != (BFS_Slot *) 0) { volatile BFS_Slot *x = shared_memory->head[dst][p][i]; while (x && x->type == DELETED) { x = x->nxt; } if (!x) { continue; } if (p == who_am_i) { shared_memory->head[dst][p][i] = x; } #ifdef BFS_CHECK bfs_printf("input q [%d][%d][%d] !empty\n", dst, p, i); #endif return i; } } #ifdef BFS_CHECK bfs_printf("all input qs [%d][%d][0..max] empty\n", dst, p); #endif return Cores; } #endif #ifdef BFS_DISK void bfs_ewrite(int fd, const void *p, size_t count) { if (write(fd, p, count) != count) { perror("diskwrite"); Uerror("aborting"); } } void bfs_eread(int fd, void *p, size_t count) { if (read(fd, p, count) != count) { perror("diskread"); Uerror("aborting"); } } void bfs_sink_disk(int who_are_you, BFS_Slot *n) { SV_Hold *x; #ifdef VERBOSE bfs_printf("sink_disk -> %d\n", who_are_you); #endif bfs_ewrite(bfs_out_fd[who_are_you], (const void *) n->s_data->t_info, sizeof(BFS_Trail)); bfs_ewrite(bfs_out_fd[who_are_you], (const void *) &vsize, sizeof(ulong)); bfs_ewrite(bfs_out_fd[who_are_you], &now, vsize); bfs_release_trail(n->s_data->t_info); n->s_data->t_info = (BFS_Trail *) 0; #if NRUNS>0 bfs_ewrite(bfs_out_fd[who_are_you], (const void *) &(n->s_data->omask), sizeof(EV_Hold *)); #endif #ifdef Q_PROVISO bfs_ewrite(bfs_out_fd[who_are_you], (const void *) &(n->s_data->lstate), sizeof(H_el *)); #endif #if SYNC>0 bfs_ewrite(bfs_out_fd[who_are_you], (const void *) &(n->s_data->boq), sizeof(short)); #endif #if VERBOSE bfs_ewrite(bfs_out_fd[who_are_you], (const void *) &(n->s_data->nr), sizeof(ulong)); #endif shared_memory->bfs_out_cnt[who_am_i] = 1; } void bfs_source_disk(int fd, volatile BFS_Slot *n) { ulong nb; /* local temporary */ SV_Hold *x; #ifdef VERBOSE bfs_printf("source_disk <- %d\n", who_am_i); #endif n->s_data->t_info = bfs_grab_trail(); bfs_eread(fd, (void *) n->s_data->t_info, sizeof(BFS_Trail)); bfs_eread(fd, (void *) &nb, sizeof(ulong)); x = bfs_new_sv(nb); /* space for osv isn't already allocated */ n->s_data->osv = x->sv; x->sv = (State *) 0; x->nxt = bfs_free_hold; bfs_free_hold = x; bfs_eread(fd, (void *) n->s_data->osv, (size_t) nb); #if NRUNS>0 bfs_eread(fd, (void *) &(n->s_data->omask), sizeof(EV_Hold *)); #endif #ifdef Q_PROVISO bfs_eread(fd, (void *) &(n->s_data->lstate), sizeof(H_el *)); #endif #if SYNC>0 bfs_eread(fd, (void *) &(n->s_data->boq), sizeof(short)); #endif #if VERBOSE bfs_eread(fd, (void *) &(n->s_data->nr), sizeof(ulong)); #endif } #endif #ifndef BFS_QSZ #ifdef BFS_STAGGER static BFS_Slot *bfs_stage[BFS_STAGGER]; static void bfs_stagger_flush(void) { int i, who_are_you; int dst = 1 - bfs_toggle; BFS_Slot *n; who_are_you = (rand()%Cores); for (i = bfs_stage_cnt-1; i >= 0; i--) { n = bfs_stage[i]; #ifdef BFS_DISK bfs_sink_disk(who_are_you, n); bfs_stage[i] = (BFS_Slot *) 0; #endif n->nxt = (BFS_Slot *) shared_memory->head[dst][who_are_you][who_am_i]; shared_memory->head[dst][who_are_you][who_am_i] = n; /* bfs_sent++; */ } #ifdef VERBOSE bfs_printf("stagger flush %d states to %d\n", bfs_stage_cnt, who_are_you); #endif bfs_stage_cnt = 0; } void bfs_stagger_add(BFS_Slot *n) { if (bfs_stage_cnt == BFS_STAGGER) { bfs_stagger_flush(); } bfs_stage[bfs_stage_cnt++] = n; } #endif #endif void bfs_push_state(Trail *x, BFS_Trail *y, int tt) { int who_are_you; #ifdef BFS_FIFO const int dst = 0; #else int dst = 1 - bfs_toggle; #endif #ifdef BFS_QSZ uint z; if (bfs_keep_state > 0) { who_are_you = bfs_keep_state - 1; } else { who_are_you = (rand()%Cores); } z = shared_memory->bfs_ix[dst][who_are_you][who_am_i]; if (z >= BFS_QSZ) { static int warned_qloss = 0; if (warned_qloss == 0 && who_am_i == 0) { warned_qloss++; bfs_printf("BFS_QSZ too small - losing states\n"); } bfs_punt++; return; } shared_memory->bfs_ix[dst][who_are_you][who_am_i] = z+1; BFS_Slot *n = bfs_pack_state(x, y, tt, bfs_prep_slot(y, (BFS_Slot *) &(shared_memory->bfsq[dst][who_are_you][who_am_i][z]))); #else BFS_Slot *n = bfs_pack_state(x, y, tt, bfs_new_slot(y)); #ifdef BFS_GREEDY who_are_you = who_am_i; /* for testing only */ #else if (bfs_keep_state > 0) { who_are_you = bfs_keep_state - 1; } else { #ifdef BFS_STAGGER who_are_you = -1; bfs_stagger_add(n); goto done; #else who_are_you = (rand()%Cores); #endif } #endif #ifdef BFS_FIFO if (!shared_memory->tail[dst][who_are_you][who_am_i]) { shared_memory->dels[dst][who_are_you][who_am_i] = shared_memory->tail[dst][who_are_you][who_am_i] = shared_memory->head[dst][who_are_you][who_am_i] = n; } else { shared_memory->tail[dst][who_are_you][who_am_i]->nxt = n; shared_memory->tail[dst][who_are_you][who_am_i] = n; } shared_memory->bfs_idle[who_are_you] = 0; #else #ifdef BFS_DISK bfs_sink_disk(who_are_you, n); #endif n->nxt = (BFS_Slot *) shared_memory->head[dst][who_are_you][who_am_i]; shared_memory->head[dst][who_are_you][who_am_i] = n; #endif #ifdef BFS_STAGGER done: #endif #endif #ifdef VERBOSE bfs_printf("PUT STATE (depth %ld, nr %u) to %d -- s_data: %p\n", tt, n->s_data->nr, who_are_you, n->s_data); #endif bfs_sent++; } BFS_Slot * bfs_next(void) { volatile BFS_Slot *n = &bfs_null; #ifdef BFS_FIFO const int src = 0; bfs_qscan = bfs_empty(who_am_i); #else const int src = bfs_toggle; #ifdef BFS_QSZ while (bfs_qscan < Cores && shared_memory->bfs_ix[src][who_am_i][bfs_qscan] == 0) { bfs_qscan++; } #else while (bfs_qscan < Cores && shared_memory->head[src][who_am_i][bfs_qscan] == (BFS_Slot *) 0) { bfs_qscan++; } #endif #endif if (bfs_qscan < Cores) { #ifdef BFS_FIFO shared_memory->bfs_idle[who_am_i] = 0; for (n = shared_memory->head[src][who_am_i][bfs_qscan]; n; n = n->nxt) { if (n->type != DELETED) { break; } } #ifdef BFS_CHECK assert(n && n->type == STATE); /* q cannot be empty */ #endif if (n->nxt) { shared_memory->head[src][who_am_i][bfs_qscan] = n->nxt; } n->type = DELETED; #else #ifdef BFS_QSZ uint x = --shared_memory->bfs_ix[src][who_am_i][bfs_qscan]; n = &(shared_memory->bfsq[src][who_am_i][bfs_qscan][x]); #else n = shared_memory->head[src][who_am_i][bfs_qscan]; shared_memory->head[src][who_am_i][bfs_qscan] = n->nxt; #if defined(BFS_FIFO) && defined(BFS_CHECK) assert(n->type == STATE); #endif n->nxt = (BFS_Slot *) 0; #endif #ifdef BFS_DISK /* the states actually show up in reverse order (FIFO iso LIFO) here */ /* but that doesnt really matter as long as the count is right */ bfs_source_disk(bfs_inp_fd[bfs_qscan], n); /* get the data */ #endif #endif #ifdef BFS_CHECK bfs_printf("rcv STATE from [%d][%d][%d]\n", src, who_am_i, bfs_qscan); #endif bfs_rcvd++; } else { #if defined(BFS_STAGGER) && !defined(BFS_QSZ) if (bfs_stage_cnt > 0) { bfs_stagger_flush(); } #endif shared_memory->bfs_idle[who_am_i] = 1; #if defined(BFS_FIFO) && defined(BFS_CHECK) assert(n->type == EMPTY); #endif } return (BFS_Slot *) n; } int bfs_all_empty(void) { int i; #ifdef BFS_DISK for (i = 0; i < Cores; i++) { if (shared_memory->bfs_out_cnt[i] != 0) { #ifdef VERBOSE bfs_printf("bfs_all_empty %d not empty\n", i); #endif return 0; } } #else int p; #ifdef BFS_FIFO const int dst = 0; #else int dst = 1 - bfs_toggle; /* next generation */ #endif for (p = 0; p < Cores; p++) for (i = 0; i < Cores; i++) #ifdef BFS_QSZ { if (shared_memory->bfs_ix[dst][p][i] > 0) #else { if (shared_memory->head[dst][p][i] != (BFS_Slot *) 0) #endif { return 0; } } #endif #ifdef VERBOSE bfs_printf("bfs_all_empty\n"); #endif return 1; } #ifdef BFS_FIFO BFS_Slot * bfs_sweep(void) { BFS_Slot *n; int i; for (i = 0; i < Cores; i++) for (n = (BFS_Slot *) shared_memory->dels[0][who_am_i][i]; n && n != shared_memory->head[0][who_am_i][i]; n = n->nxt) { if (n->type == DELETED && n->nxt) { shared_memory->dels[0][who_am_i][i] = n->nxt; n->nxt = (BFS_Slot *) 0; return n; } } return (BFS_Slot *) sh_malloc((ulong) sizeof(BFS_Slot)); } #endif typedef struct BFS_T_Hold BFS_T_Hold; struct BFS_T_Hold { volatile BFS_Trail *t; BFS_T_Hold *nxt; }; BFS_T_Hold *bfs_t_held, *bfs_t_free; BFS_Trail * bfs_grab_trail(void) { BFS_Trail *t; BFS_T_Hold *h; #ifdef VERBOSE bfs_printf("grab trail - bfs_t_held %p\n", (void *) bfs_t_held); #endif if (bfs_t_held) { h = bfs_t_held; bfs_t_held = bfs_t_held->nxt; t = (BFS_Trail *) h->t; h->t = (BFS_Trail *) 0; /* make sure it cannot be reused */ h->nxt = bfs_t_free; bfs_t_free = h; } else { t = (BFS_Trail *) sh_malloc((ulong) sizeof(BFS_Trail)); } #ifdef BFS_CHECK assert(t); #endif t->ostate = (H_el *) 0; #ifdef VERBOSE bfs_printf("grab trail %p\n", (void *) t); #endif return t; } #if defined(BFS_DISK) || defined(BFS_NOTRAIL) void bfs_release_trail(BFS_Trail *t) { BFS_T_Hold *h; #ifdef BFS_CHECK assert(t); #endif #ifdef VERBOSE bfs_printf("release trail %p\n", (void *) t); #endif if (bfs_t_free) { h = bfs_t_free; bfs_t_free = bfs_t_free->nxt; } else { h = (BFS_T_Hold *) emalloc(sizeof(BFS_T_Hold)); } h->t = t; h->nxt = bfs_t_held; bfs_t_held = h; #ifdef VERBOSE bfs_printf("release trail - bfs_t_held %p\n", (void *) bfs_t_held); #endif } #endif #ifndef BFS_QSZ BFS_Slot * bfs_new_slot(BFS_Trail *f) { BFS_Slot *t; #ifdef BFS_FIFO t = bfs_sweep(); #else if (bfs_free_slot) /* local */ { t = bfs_free_slot; bfs_free_slot = bfs_free_slot->nxt; t->nxt = (BFS_Slot *) 0; } else { t = (BFS_Slot *) sh_malloc((ulong) sizeof(BFS_Slot)); } #endif if (t->s_data) { memset(t->s_data, 0, sizeof(BFS_State)); } else { t->s_data = (BFS_State *) sh_malloc((ulong) sizeof(BFS_State)); } /* we keep a ptr to the frame of parent states, which is */ /* used for reconstructing path and recovering failed rvs etc */ /* we should not overwrite the data at this address with a memset */ if (f) { t->s_data->t_info = f; } else { t->s_data->t_info = bfs_grab_trail(); } return t; } #else BFS_Slot * bfs_prep_slot(BFS_Trail *f, BFS_Slot *t) { if (t->s_data) { memset(t->s_data, 0, sizeof(BFS_State)); } else { t->s_data = (BFS_State *) sh_malloc((ulong) sizeof(BFS_State)); } if (f) { t->s_data->t_info = f; } else { t->s_data->t_info = bfs_grab_trail(); } return t; } #endif SV_Hold * bfs_new_sv(int n) { SV_Hold *h; if (bfs_svfree[n]) { h = bfs_svfree[n]; bfs_svfree[n] = h->nxt; h->nxt = (SV_Hold *) 0; } else { h = (SV_Hold *) sh_malloc((ulong) sizeof(SV_Hold)); #if 0 h->sz = n; #endif h->sv = (State *) sh_malloc((ulong)(sizeof(State) - VECTORSZ + n)); } memcpy((char *)h->sv, (char *)&now, n); return h; } #if NRUNS>0 static EV_Hold *kept[VECTORSZ]; /* local */ static void bfs_keep(EV_Hold *v) { EV_Hold *h; for (h = kept[v->sz]; h; h = h->nxt) /* check local list */ { if (v->nrpr == h->nrpr && v->nrqs == h->nrqs #if !defined(NOCOMP) && !defined(HC) && (v->sv == h->sv || memcmp((char *) v->sv, (char *) h->sv, v->sz) == 0) #endif #ifdef TRIX ) #else #if NRUNS>0 #if VECTORSZ>32000 && (memcmp((char *) v->po, (char *) h->po, v->nrpr * sizeof(int)) == 0) && (memcmp((char *) v->qo, (char *) h->qo, v->nrqs * sizeof(int)) == 0) #else && (memcmp((char *) v->po, (char *) h->po, v->nrpr * sizeof(short)) == 0) && (memcmp((char *) v->qo, (char *) h->qo, v->nrqs * sizeof(short)) == 0) #endif && (memcmp((char *) v->ps, (char *) h->ps, v->nrpr * sizeof(uchar)) == 0) && (memcmp((char *) v->qs, (char *) h->qs, v->nrqs * sizeof(uchar)) == 0)) #else ) #endif #endif { break; } } if (!h) /* we don't have one like it yet */ { v->nxt = kept[v->sz]; /* keep the original owner field */ kept[v->sz] = v; /* all ptrs inside are to shared memory, but nxt is local */ } } EV_Hold * bfs_new_sv_mask(int n) { EV_Hold *h; for (h = kept[n]; h; h = h->nxt) { if ((now._nr_pr == h->nrpr) && (now._nr_qs == h->nrqs) #if !defined(NOCOMP) && !defined(HC) && NRUNS>0 && ((char *) Mask == h->sv || (memcmp((char *) Mask, h->sv, n) == 0)) #endif #ifdef TRIX ) #else #if NRUNS>0 #if VECTORSZ>32000 && (memcmp((char *) proc_offset, (char *) h->po, now._nr_pr * sizeof(int)) == 0) && (memcmp((char *) q_offset, (char *) h->qo, now._nr_qs * sizeof(int)) == 0) #else && (memcmp((char *) proc_offset, (char *) h->po, now._nr_pr * sizeof(short)) == 0) && (memcmp((char *) q_offset, (char *) h->qo, now._nr_qs * sizeof(short)) == 0) #endif && (memcmp((char *) proc_skip, (char *) h->ps, now._nr_pr * sizeof(uchar)) == 0) && (memcmp((char *) q_skip, (char *) h->qs, now._nr_qs * sizeof(uchar)) == 0)) #else ) #endif #endif { break; } } if (!h) { /* once created, the contents are never modified */ h = (EV_Hold *) sh_malloc((ulong)sizeof(EV_Hold)); h->owner = who_am_i; h->sz = n; h->nrpr = now._nr_pr; h->nrqs = now._nr_qs; #if !defined(NOCOMP) && !defined(HC) && NRUNS>0 h->sv = (char *) Mask; /* in shared memory, and never modified */ #endif #if NRUNS>0 && !defined(TRIX) if (now._nr_pr > 0) { h->ps = (char *) proc_skip; h->po = (char *) proc_offset; } if (now._nr_qs > 0) { h->qs = (char *) q_skip; h->qo = (char *) q_offset; } #endif h->nxt = kept[n]; kept[n] = h; } return h; } #endif BFS_Slot * bfs_pack_state(Trail *f, BFS_Trail *g, int search_depth, BFS_Slot *t) { #ifdef BFS_CHECK assert(t->s_data != NULL); assert(t->s_data->t_info != NULL); assert(f || g); #endif if (!g) { t->s_data->t_info->ostate = f->ostate; t->s_data->t_info->st = f->st; t->s_data->t_info->o_tt = search_depth; t->s_data->t_info->pr = f->pr; t->s_data->t_info->tau = f->tau; t->s_data->t_info->o_pm = f->o_pm; if (f->o_t) { t->s_data->t_info->t_id = f->o_t->t_id; } else { t->s_data->t_info->t_id = -1; t->s_data->t_info->ostate = NULL; } } /* else t->s_data->t_info == g */ #if SYNC t->s_data->boq = boq; #endif #ifdef VERBOSE { static ulong u_cnt; t->s_data->nr = u_cnt++; } #endif #ifdef TRIX sv_populate(); /* make sure now is up to date */ #endif #ifndef BFS_DISK { SV_Hold *x = bfs_new_sv(vsize); t->s_data->osv = x->sv; x->sv = (State *) 0; x->nxt = bfs_free_hold; bfs_free_hold = x; } #endif #if NRUNS>0 t->s_data->omask = bfs_new_sv_mask(vsize); #endif #if defined(Q_PROVISO) && !defined(BITSTATE) && !defined(NOREDUCE) t->s_data->lstate = Lstate; /* Lstate is set in o_store or h_store */ #endif #ifdef BFS_FIFO t->type = STATE; #endif return t; } void bfs_store_state(Trail *t, short oboq) { #ifdef TRIX sv_populate(); #endif #if defined(VERI) && defined(Q_PROVISO) && !defined(BITSTATE) && defined(FULLSTACK) if (!(t->tau&4) && t->ostate) { t->tau |= ((BFS_Trail *) t->ostate)->tau&64; } /* lift 64 across claim moves */ #endif #ifdef BFS_SEP_HASH #if SYNC if (boq == -1 && oboq != -1) /* post-rv */ { BFS_Trail *x = (BFS_Trail *) trpt->ostate; /* pre-rv state */ if (x) { x->o_pm |= 4; /* rv complete */ } } #endif d_sfh((uchar *)&now, (int) vsize); /* sep-hash -- sets K1 -- overkill */ bfs_keep_state = K1%Cores + 1; bfs_push_state(t, NULL, trpt->o_tt+1); /* bfs_store_state - sep_hash */ bfs_keep_state = 0; #else #ifdef VERI if (!(t->tau&4) && t->ostate && (((BFS_Trail *)t->ostate)->tau&4)) { /* do not store intermediate state */ #if defined(VERBOSE) && defined(L_BOUND) bfs_printf("Un-Stored state bnd %d -- sds %p\n", now._l_bnd, now._l_sds); #endif bfs_push_state(t, NULL, trpt->o_tt+1); /* claim move */ } else #endif if (!bfs_do_store((char *)&now, vsize)) /* includes bfs_visited */ { nstates++; /* local count */ trpt->tau |= 64; /* bfs: succ outside stack */ #if SYNC if (boq == -1 && oboq != -1) /* post-rv */ { BFS_Trail *x = (BFS_Trail *) trpt->ostate; /* pre-rv state */ if (x) { x->o_pm |= 4; /* rv complete */ } } #endif bfs_push_state(t, NULL, trpt->o_tt+1); /* successor */ } else { truncs++; #ifdef BFS_CHECK bfs_printf("seen before\n"); #endif #if defined(Q_PROVISO) && !defined(BITSTATE) && defined(FULLSTACK) #ifdef USE_TDH if (Lstate) { trpt->tau |= 64; } #else if (Lstate && Lstate->tagged) /* bfs_store_state */ { trpt->tau |= 64; } #endif #endif } #endif } /*** support routines ***/ void bfs_clear_locks(void) { int i; /* clear any locks held by this process only */ if (shared_memory) for (i = 0; i < BFS_MAXLOCKS; i++) { if (shared_memory->sh_owner[i] == who_am_i + 1) { shared_memory->sh_locks[i] = 0; #ifdef BFS_CHECK shared_memory->in_count[i] = 0; #endif shared_memory->sh_owner[i] = 0; } } } void e_critical(int which) { int w; #ifdef BFS_CHECK assert(which >= 0 && which < BFS_MAXLOCKS); #endif if (shared_memory == NULL) return; while (tas(&(shared_memory->sh_locks[which])) != 0) { w = shared_memory->sh_owner[which]; /* sh_locks[which] could be 0 by now */ assert(w >= 0 && w <= BFS_MAXPROCS); if (w > 0 && shared_memory->bfs_flag[w-1] == 2) { /* multiple processes can get here; only one should do this: */ if (tas(&(shared_memory->bfs_data[w - 1].override)) == 0) { fprintf(stderr, "cpu%02d: override lock %d - held by %d\n", who_am_i, which, shared_memory->sh_owner[which]); #ifdef BFS_CHECK shared_memory->in_count[which] = 0; #endif shared_memory->sh_locks[which] = 0; shared_memory->sh_owner[which] = 0; } } shared_memory->wait_count[which]++; /* not atomic of course */ } #ifdef BFS_CHECK if (shared_memory->in_count[which] != 0) { fprintf(stderr, "cpu%02d: cannot happen lock %d count %d\n", who_am_i, which, shared_memory->in_count[which]); } shared_memory->in_count[which]++; #endif shared_memory->sh_owner[which] = who_am_i+1; } void x_critical(int which) { if (shared_memory == NULL) return; #ifdef BFS_CHECK assert(shared_memory->in_count[which] == 1); shared_memory->in_count[which] = 0; #endif shared_memory->sh_locks[which] = 0; shared_memory->sh_owner[which] = 0; } void bfs_printf(const char *fmt, ...) { va_list args; e_critical(BFS_PRINT); #ifdef BFS_CHECK if (1) { int i=who_am_i; while (i-- > 0) printf(" "); } #endif printf("cpu%02d: ", who_am_i); va_start(args, fmt); vprintf(fmt, args); va_end(args); fflush(stdout); x_critical(BFS_PRINT); } int bfs_all_idle(void) { int i; if (shared_memory) for (i = 0; i < Cores; i++) { if (shared_memory->bfs_flag[i] == 0 && shared_memory->bfs_idle[i] == 0) { return 0; } } return 1; } #ifdef BFS_FIFO int bfs_idle_and_empty(void) { int p; /* read-only */ for (p = 0; p < Cores; p++) { if (shared_memory->bfs_flag[p] == 0 && shared_memory->bfs_idle[p] == 0) { return 0; } } for (p = 0; p < Cores; p++) { if (bfs_empty(p) < Cores) { return 0; } } return 1; } #endif void bfs_set_toggle(void) /* executed by root */ { int i; if (shared_memory) for (i = 0; i < Cores; i++) { shared_memory->bfs_idle[i] = 0; } } int bfs_all_running(void) /* crash detection */ { int i; for (i = 0; i < Cores; i++) { if (!shared_memory || shared_memory->bfs_flag[i] > 1) { return 0; } } return 1; } void bfs_mark_done(int code) { if (shared_memory) { shared_memory->bfs_flag[who_am_i] = (int) code; shared_memory->quit = 1; } } static uchar * bfs_offset(int c) { int p, N; #ifdef COLLAPSE uchar *q = (uchar *) ncomps; /* it is the first object allocated */ q += (256+2) * sizeof(ulong); /* preserve contents of ncomps */ #else uchar *q = (uchar *) &(shared_memory->allocator); #endif /* _NP_+1 proctypes, reachability info: * reached[x : 0 .. _NP_+1][ 0 .. NrStates[x] ] */ for (p = N = 0; p <= _NP_; p++) { N += NrStates[p]; /* sum for all proctypes */ } /* space needed per proctype: N bytes */ /* rounded up to a multiple of the word size */ if ((N%sizeof(void *)) != 0) /* aligned */ { N += sizeof(void *) - (N%sizeof(void *)); } q += ((c - 1) * (_NP_ + 1) * N); return q; } static void bfs_putreached(void) { uchar *q; int p; assert(who_am_i > 0); q = bfs_offset(who_am_i); for (p = 0; p <= _NP_; p++) { memcpy((void *) q, (const void *) reached[p], (size_t) NrStates[p]); q += NrStates[p]; } } static void bfs_getreached(int c) { uchar *q; int p, i; assert(who_am_i == 0 && c >= 1 && c < Cores); q = (uchar *) bfs_offset(c); for (p = 0; p <= _NP_; p++) for (i = 0; i < NrStates[p]; i++) { reached[p][i] += *q++; /* update local copy */ } } void bfs_update(void) { int i; volatile BFS_data *s; if (!shared_memory) return; s = &shared_memory->bfs_data[who_am_i]; if (who_am_i == 0) { shared_memory->bfs_flag[who_am_i] = 3; /* or else others dont stop */ bfs_gcount = 0; for (i = 1; i < Cores; i++) /* start at 1 not 0 */ { while (shared_memory->bfs_flag[i] == 0) { sleep(1); if (bfs_gcount++ > WAIT_MAX) /* excessively long wait */ { printf("cpu00: give up waiting for cpu%2d (%d cores)\n", i, Cores); bfs_gcount = 0; break; } } s = &shared_memory->bfs_data[i]; mreached = Max(mreached, s->mreached); hmax = vsize = Max(vsize, s->vsize); errors += s->errors; memcnt += s->memcnt; nstates += s->nstates; nlinks += s->nlinks; truncs += s->truncs; bfs_left += s->memory_left; bfs_punt += s->punted; bfs_getreached(i); } } else { s->mreached = (ulong) mreached; s->vsize = (ulong) vsize; s->errors = (int) errors; s->memcnt = (double) memcnt; s->nstates = (double) nstates; s->nlinks = (double) nlinks; s->truncs = (double) truncs; s->memory_left = (ulong) bfs_left; s->punted = (ulong) bfs_punt; bfs_putreached(); } } volatile uchar * sh_pre_malloc(ulong n) /* used before the local heaps are populated */ { volatile uchar *ptr = NULL; assert(!bfs_runs); if ((n%sizeof(void *)) != 0) { n += sizeof(void *) - (n%sizeof(void *)); assert((n%sizeof(void *)) == 0); } e_critical(BFS_MEM); /* needed? */ if (shared_memory->mem_left < n + 7) { x_critical(BFS_MEM); bfs_printf("want %lu, have %lu\n", n, shared_memory->mem_left); bfs_shutdown("out of shared memory"); assert(0); /* should be unreachable */ } ptr = shared_memory->allocator; #if WS>4 { int b = (int) ((uint64_t) ptr)&7; if (b != 0) { ptr += (8-b); shared_memory->allocator = ptr; } } #endif shared_memory->allocator += n; shared_memory->mem_left -= n; x_critical(BFS_MEM); bfs_pre_allocated += n; return ptr; } volatile uchar * sh_malloc(ulong n) { volatile uchar *ptr = NULL; #ifdef BFS_CHECK assert(bfs_runs); #endif if ((n%sizeof(void *)) != 0) { n += sizeof(void *) - (n%sizeof(void *)); #ifdef BFS_CHECK assert((n%sizeof(void *)) == 0); #endif } /* local heap -- no locks needed */ if (bfs_left < n) { e_critical(BFS_MEM); if (shared_memory->mem_left >= n) { ptr = (uchar *) shared_memory->allocator; shared_memory->allocator += n; shared_memory->mem_left -= n; x_critical(BFS_MEM); return ptr; } x_critical(BFS_MEM); #ifdef BFS_LOGMEM int i; e_critical(BFS_MEM); for (i = 0; i < 1024; i++) { if (shared_memory->logmem[i] > 0) { bfs_printf(" log[%d] %d\n", i, shared_memory->logmem[i]); } } x_critical(BFS_MEM); #endif bfs_shutdown("out of shared memory"); /* no return */ } #ifdef BFS_LOGMEM e_critical(BFS_MEM); if (n < 1023) { shared_memory->logmem[n]++; } else { shared_memory->logmem[1023]++; } x_critical(BFS_MEM); #endif ptr = (uchar *) bfs_heap; bfs_heap += n; bfs_left -= n; if (0) printf("sh_malloc %ld\n", n); return ptr; } volatile uchar * bfs_get_shared_mem(key_t key, size_t n) { char *rval; assert(who_am_i == 0); shared_mem_id = shmget(key, n, 0600 | IPC_CREAT | IPC_EXCL); /* create */ if (shared_mem_id == -1) { fprintf(stderr, "cpu%02d: tried to get %d MB of shared memory\n", who_am_i, (int) n/(1024*1024)); perror("shmget"); exit(1); } if ((rval = (char *) shmat(shared_mem_id, (void *) 0, 0)) == (char *) -1) /* attach */ { perror("shmat"); exit(1); } return (uchar *) rval; } void bfs_drop_shared_memory(void) { if (who_am_i == 0) { printf("pan: releasing shared memory..."); fflush(stdout); } if (shared_memory) { shmdt(shared_memory); /* detach */ if (who_am_i == 0) { shmctl(shared_mem_id, IPC_RMID, (void *) 0); /* remove */ } } if (who_am_i == 0) { printf("done\n"); fflush(stdout); } } size_t bfs_find_largest(key_t key) { size_t n; const size_t delta = 32*1024*1024; int temp_id = -1; int atleastonce = 0; for (n = delta; ; n += delta) { if (WS <= 4 && n >= 1024*1024*1024) { n = 1024*1024*1024; break; } #ifdef MEMLIM if ((double) n > memlim) { n = (size_t) memlim; break; } #endif temp_id = shmget(key, n, 0600); /* check for stale copy */ if (temp_id != -1) { if (shmctl(temp_id, IPC_RMID, ((void *) 0)) < 0) /* remove */ { perror("remove_segment_fails 2"); exit(1); } } temp_id = shmget(key, n, 0600 | IPC_CREAT | IPC_EXCL); /* create new */ if (temp_id == -1) { n -= delta; break; } else { atleastonce++; if (shmctl(temp_id, IPC_RMID, ((void *) 0)) < 0) { perror("remove_segment_fails 0"); exit(1); } } } if (!atleastonce) { printf("cpu%02d: no shared memory n=%d\n", who_am_i, (int) n); exit(1); } printf("cpu%02d: largest shared memory segment: %lu MB\n", who_am_i, (ulong) n/(1024*1024)); #if 0 #ifdef BFS_SEP_HASH n /= 2; /* not n /= Cores because the queues take most memory */ printf("cpu%02d: using %lu MB\n", who_am_i, (ulong) n/(1024*1024)); #endif #endif fflush(stdout); if ((n/(1024*1024)) == 32) { if (sizeof(void *) == 4) /* a 32 bit machine */ { fprintf(stderr, "\t32MB is the default; increase it to 1 GB with:\n"); fprintf(stderr, "\tsudo /sbin/sysctl kernel.shmmax=%d\n", (1<<30)); fprintf(stderr, "\tsudo /sbin/sysctl kernel.shmall=%d\n", (1<<30)/8192); } else if (sizeof(void *) == 8) /* a 64 bit machine */ { fprintf(stderr, "\t32MB is the default; increase it to 30 GB with:\n"); fprintf(stderr, "\tsudo /sbin/sysctl kernel.shmmax=32212254720\n"); fprintf(stderr, "\tsudo /sbin/sysctl kernel.shmall=7864320\n"); fprintf(stderr, "\tor for 60 GB:\n"); fprintf(stderr, "\tsudo /sbin/sysctl kernel.shmmax=60000000000\n"); fprintf(stderr, "\tsudo /sbin/sysctl kernel.shmall=30000000\n"); } else { fprintf(stderr, "\tweird wordsize %d\n", (int) sizeof(void *)); } } return n; } #ifdef BFS_DISK void bfs_disk_start(void) { int unused = system("rm -fr .spin"); if (mkdir(".spin", 0777) != 0) { perror("mkdir"); Uerror("aborting"); } } void bfs_disk_stop(void) { if (system("rm -fr .spin") < 0) { perror("rm -fr .spin/"); } } void bfs_disk_inp(void) { int i; char fnm[16]; #ifdef VERBOSE bfs_printf("inp %d %d 0..%d\n", bfs_toggle, who_am_i, Cores); #endif for (i = 0; i < Cores; i++) { sprintf(fnm, ".spin/q%d_%d_%d", bfs_toggle, who_am_i, i); if ((bfs_inp_fd[i] = open(fnm, 0444)) < 0) { perror("open"); Uerror(fnm); } } } void bfs_disk_out(void) { int i; char fnm[16]; #ifdef VERBOSE bfs_printf("out %d 0..%d %d\n", 1-bfs_toggle, Cores, who_am_i); #endif shared_memory->bfs_out_cnt[who_am_i] = 0; for (i = 0; i < Cores; i++) { sprintf(fnm, ".spin/q%d_%d_%d", 1-bfs_toggle, i, who_am_i); if ((bfs_out_fd[i] = creat(fnm, 0666)) < 0) { perror("creat"); Uerror(fnm); } } } void bfs_disk_iclose(void) { int i; #ifdef VERBOSE bfs_printf("close_inp\n"); #endif for (i = 0; i < Cores; i++) { if (close(bfs_inp_fd[i]) < 0) { perror("iclose"); } } } void bfs_disk_oclose(void) { int i; #ifdef VERBOSE bfs_printf("close_out\n"); #endif for (i = 0; i < Cores; i++) { if (fsync(bfs_out_fd[i]) < 0) { perror("fsync"); } if (close(bfs_out_fd[i]) < 0) { perror("oclose"); } } } #endif void bfs_write_snap(int fd) { if (write(fd, snap, strlen(snap)) != strlen(snap)) { printf("pan: error writing %s\n", fnm); bfs_shutdown("file system error"); } } void bfs_one_step(BFS_Trail *t, int fd) { if (t && t->t_id != (T_ID) -1) { sprintf(snap, "%d:%d:%d\n", trcnt++, t->pr, t->t_id); bfs_write_snap(fd); } } void bfs_putter(BFS_Trail *t, int fd) { if (t && t != (BFS_Trail *) t->ostate) bfs_putter((BFS_Trail *) t->ostate, fd); #ifdef L_BOUND if (depthfound == trcnt) { strcpy(snap, "-1:-1:-1\n"); bfs_write_snap(fd); depthfound = -1; } #endif bfs_one_step(t, fd); } void bfs_nuerror(char *str) { int fd = make_trail(); if (fd < 0) return; #ifdef VERI sprintf(snap, "-2:%d:-2\n", (uchar) ((P0 *)pptr(0))->_t); bfs_write_snap(fd); #endif #ifdef MERGED sprintf(snap, "-4:-4:-4\n"); bfs_write_snap(fd); #endif trcnt = 1; if (strstr(str, "invalid")) { bfs_putter((BFS_Trail *) trpt->ostate, fd); } else { BFS_Trail x; memset((char *) &x, 0, sizeof(BFS_Trail)); x.pr = trpt->pr; x.t_id = (trpt->o_t)?trpt->o_t->t_id:0; x.ostate = trpt->ostate; bfs_putter(&x, fd); } close(fd); if (errors >= upto && upto != 0) { bfs_shutdown(str); } } void bfs_uerror(char *str) { static char laststr[256]; errors++; if (strncmp(str, laststr, 254) != 0) { bfs_printf("pan:%d: %s (at depth %ld)\n", errors, str, ((depthfound == -1)?depth:depthfound)); strncpy(laststr, str, 254); } #ifdef HAS_CODE if (readtrail) { wrap_trail(); return; } #endif if (every_error != 0 || errors == upto) { bfs_nuerror(str); } if (errors >= upto && upto != 0) { bfs_shutdown("bfs_uerror"); } depthfound = -1; } void bfs_Uerror(char *str) { /* bfs_uerror(str); */ bfs_printf("pan:%d: %s (at depth %ld)\n", ++errors, str, ((depthfound == -1)?depth:depthfound)); bfs_shutdown("bfs_Uerror"); } Spin/Examples/eratosthenes.pml0000644000175100017510000000136211676656747014576 0ustar ghgh/* The Sieve of Eratosthenes (c. 276-196 BC) Prints all prime numbers up to MAX */ #define MAX 25 mtype = { number, eof }; chan root = [0] of { mtype, int }; proctype sieve(chan c; int prime) { chan child = [0] of { mtype, int }; bool haschild; int n; printf("MSC: %d is prime\n", prime); end: do :: c?number(n) -> if :: (n%prime) == 0 -> printf("MSC: %d = %d*%d\n", n, prime, n/prime) :: else -> if :: !haschild -> /* new prime */ haschild = true; run sieve(child, n); :: else -> child!number(n) fi; fi :: c?eof(0) -> break od; if :: haschild -> child!eof(0) :: else fi } init { int n = 2; run sieve(root, n); do :: (n < MAX) -> n++; root!number(n) :: (n >= MAX) -> root!eof(0); break od } Spin/Examples/pathfinder.pml0000644000175100017510000000244611676656751014215 0ustar ghgh/* * Models the Pathfinder scheduling algorithm and explains the * cause of the recurring reset problem during the mission on Mars * * there is a high priority process, that consumes * data produced by a low priority process. * data consumption and production happens under * the protection of a mutex lock * the mutex lock conflicts with the scheduling priorities * which can deadlock the system if high() starts up * while low() has the lock set * there are 12 reachable states in the full (non-reduced) * state space -- two of which are deadlock states * partial order reduction cannot be used here because of * the 'provided' clause that models the process priorities */ mtype = { free, busy, idle, waiting, running }; show mtype h_state = idle; show mtype l_state = idle; show mtype mutex = free; active proctype high() /* can run at any time */ { end: do :: h_state = waiting; atomic { mutex == free -> mutex = busy }; h_state = running; /* critical section - consume data */ atomic { h_state = idle; mutex = free } od } active proctype low() provided (h_state == idle) /* scheduling rule */ { end: do :: l_state = waiting; atomic { mutex == free -> mutex = busy}; l_state = running; /* critical section - produce data */ atomic { l_state = idle; mutex = free } od } Spin/Examples/hello.pml0000644000175100017510000000005111676656750013161 0ustar ghghinit { printf("passed first test!\n") } Spin/Examples/werkplaats.pml0000644000175100017510000000415712331274305014223 0ustar ghgh#if 0 given 2 jobs: j1, j2 and 3 machines: m1, m2, m3 job j1 needs: 2 hours on m3, followed by 2 hours on m2, followed by 4 hours on m1 job j2 needs: 3 hours on m2, followed by 1 hour on m3 Q1 Can both jobs be completed in 7 hours or less? [A: no, j1 already needs 8 hours -- total time will be 8..11 hours] Q2 What is the shortest time to complete both jobs? [A: 9] Q3 Add a third job j3, which needs: 2 hours on m2, followed by 3 hours on m1, followed by 2 hours on m3 What is the shortest time to complete all three jobs? [A: 10] Q4 Add another extra copy of machine m1 What is the shortest time to complete all three jobs now? [A: 9] #endif #ifndef MAXTIME #define MAXTIME 9 #endif byte m1[MAXTIME] // records who's using m1 each hour byte m2[MAXTIME] byte m3[MAXTIME] byte m4[MAXTIME] // extra machine bool j1_done bool j2_done bool j3_done #define Find1(m,t,id) \ do :: i < MAXTIME-t -> \ if \ :: atomic { !m[i] -> m[i] = id; i++; break } \ :: else -> i++ \ fi \ od #define Find2(m,t,id) \ do :: i < MAXTIME-t -> \ if \ :: atomic { !m[i] && !m[i+1] -> \ m[i] = id; m[i+1] = id; \ i = i+2; break } \ :: else -> i++ \ fi \ od #define Find3(m,t,id) \ do :: i < MAXTIME-t -> \ if \ :: atomic { !m[i] && !m[i+1] && !m[i+2] -> \ m[i] = id; m[i+1] = id; m[i+2] = id; \ i = i+3; break } \ :: else -> i++ \ fi \ od #define Find4(m,t,id) \ do :: i < MAXTIME-t -> \ if \ :: atomic { !m[i] && !m[i+1] && !m[i+2] && !m[i+3] -> \ m[i] = id; m[i+1] = id; m[i+2] = id; m[i+3] = id; \ i = i+3; break } \ :: else -> i++ \ fi \ od active proctype j1() { int i Find2(m3, 8, 1) // 2 hours on m3; 8 remain Find2(m2, 6, 1) // 2 hours on m2; 6 remain if :: Find4(m1, 4, 1) // 4 hours on m1; 4 remain // :: Find4(m4, 4, 1) fi j1_done = 1 } active proctype j2() { int i Find3(m2, 4, 2) // 3 hours on m2 Find1(m3, 1, 2) // 1 hour on m3 j2_done = 1 } active proctype j3() { int i Find2(m2, 7, 3) // 2 hours on m2 Find3(m1, 5, 3) // 3 hours on m1 Find2(m3, 2, 3) // 2 hours on m3 j3_done = 1 } never { do :: assert(!(j1_done && j2_done && j3_done)) od } Spin/Examples/manna_pnueli.pml0000644000175100017510000000061612331274305014510 0ustar ghgh/* Alg. 5.9 Apt & Olderog book, * 'Manna-Pnueli central server algorithm */ byte cnt, request, respond active proctype server() { do :: (request != 0) -> respond = request (respond == 0) request = 0 od } active [2] proctype client() { assert(_pid > 0) do :: respond != _pid request = _pid :: else -> cnt++ assert(cnt == 1) /* critical section */ cnt-- respond = 0 od } Spin/Examples/leader0.pml0000644000175100017510000000276411676656750013407 0ustar ghgh/* Dolev, Klawe & Rodeh for leader election in unidirectional ring * `An O(n log n) unidirectional distributed algorithm for extrema * finding in a circle,' J. of Algs, Vol 3. (1982), pp. 245-260 */ #define N 5 /* nr of processes (use 5 for demos) */ #define I 3 /* node given the smallest number */ #define L 10 /* size of buffer (>= 2*N) */ mtype = { one, two, winner }; chan q[N] = [L] of { mtype, byte}; byte nr_leaders = 0; proctype node (chan inp, out; byte mynumber) { bit Active = 1, know_winner = 0; byte nr, maximum = mynumber, neighbourR; xr inp; xs out; printf("MSC: %d\n", mynumber); out!one(mynumber); end: do :: inp?one(nr) -> if :: Active -> if :: nr != maximum -> out!two(nr); neighbourR = nr :: else -> /* Raynal p.39: max is greatest number */ assert(nr == N); know_winner = 1; out!winner,nr; fi :: else -> out!one(nr) fi :: inp?two(nr) -> if :: Active -> if :: neighbourR > nr && neighbourR > maximum -> maximum = neighbourR; out!one(neighbourR) :: else -> Active = 0 fi :: else -> out!two(nr) fi :: inp?winner,nr -> if :: nr != mynumber -> printf("MSC: LOST\n"); :: else -> printf("MSC: LEADER\n"); nr_leaders++; assert(nr_leaders == 1) fi; if :: know_winner :: else -> out!winner,nr fi; break od } init { byte proc; atomic { proc = 1; do :: proc <= N -> run node (q[proc-1], q[proc%N], (N+I-proc)%N+1); proc++ :: proc > N -> break od } } Spin/Examples/pan.b0000664000175100017510000000103212636050452012247 0ustar ghgh switch (t->back) { default: Uerror("bad return move"); case 0: goto R999; /* nothing to undo */ /* PROC loop */ case 3: // STATE 1 ; ((P0 *)this)->a = trpt->bup.oval; ; goto R999; case 4: // STATE 2 ; ((P0 *)this)->b = trpt->bup.oval; ; goto R999; case 5: // STATE 4 ; ((P0 *)this)->b = trpt->bup.oval; ; goto R999; case 6: // STATE 8 ; ((P0 *)this)->b = trpt->bup.ovals[0]; ; ungrab_ints(trpt->bup.ovals, 2); goto R999; case 7: // STATE 12 ; p_restor(II); ; ; goto R999; } Spin/Examples/LTL/0000775000175100017510000000000012615457254011775 5ustar ghghSpin/Examples/LTL/train.pml0000644000175100017510000000330511470616632013616 0ustar ghgh/* * modified uppaal train/gate example * removed assumptions about relative speeds */ /* see end of file for LTL properties */ #define N 4 mtype = { appr, leave, go, stop, Empty, Notempty, add, rem, hd }; chan g = [N] of { mtype, pid }; chan qg = [0] of { mtype, pid }; chan q = [0] of { mtype, pid }; chan t[N] = [0] of { mtype }; active [N] proctype train() { assert(_pid >= 0 && _pid < N); Safe: do :: g!appr(_pid); Approaching: if :: t[_pid]?go -> goto Start :: t[_pid]?stop fi; Stopped: t[_pid]?go; Start: skip; /* crossing */ Crossed: g!leave(_pid) od } active proctype gate() { pid who; Free: if :: qg?Empty(_) -> g?appr(who); Add1: q!add(who) :: qg?Notempty(who) fi; t[who]!go; Occupied: do :: g?appr(who) -> t[who]!stop; Add2: q!add(who) :: g?leave(who) -> q!rem(who); goto Free od } chan list = [N] of { pid }; active proctype queue() { pid who, x; Start: if :: nempty(list) -> list?; qg!Notempty(who) :: empty(list) -> qg!Empty(0) fi; do :: q?add(who) -> list!who :: q?rem(who) -> Shiftdown: list?x; assert(x == who); goto Start od } /* * ltl format specifies positive properties * that should be satisfied -- spin will * look for counter-examples to these properties */ ltl c1 { []<> (gate@Occupied) } ltl c2 { []<> (train[0]@Crossed) } ltl c3 { []<> (train[0]@Crossed && train[1]@Stopped) } ltl c4 { []<> (train[0]@Crossed && train[1]@Stopped && train[2]@Stopped && train[3]@Stopped) } ltl c5 { [] (train[0]@Crossed + train[1]@Crossed + train[2]@Crossed + train[3]@Crossed <= 1) } ltl c6 { [] (len(list) < N) } ltl c7 { [] (((gate@Add1 || gate@Add2)) -> (len(list) < N)) } ltl c8 { [] (train[0]@Approaching) -> <> (train[0]@Crossed) } Spin/Examples/LTL/ltl_gen.pml0000644000175100017510000000512611476264020014124 0ustar ghgh/* Generate all LTL formula with 4 or fewer operators */ /* Ed Gamble and Gerard Holzmann, November 2010 */ /* to run: spin -a ltl_gen.pml cc -DPRINTF -o pan pan.c ./pan */ #define DEPTH_LIMIT 4 #define NUMBER_OF_NODES 31 /* worst case: 1 + 2 + 4 + 8 binops + 16 leaves */ #define Operator mtype mtype = { NoOp, UnOp, BiOp }; #define Action mtype mtype = { Always, Eventually, Next, Not, Until, And, Or, Implies, Equiv }; #define NodeId byte typedef Node { Operator op; NodeId f; NodeId g; Action act; }; Node nodes[NUMBER_OF_NODES]; #define Descend(X) \ printf(" ("); \ n = _nr_pr; \ run view (nodes[this].X, next); \ (n == _nr_pr) -> \ printf(") ") #define Unary(s) printf(#s); Descend(f) #define Binary(s) Descend(f); printf(#s); Descend(g) proctype view ( byte this, next ) { byte n; if :: this <= next -> if :: nodes[this].op == UnOp -> if :: nodes[this].act == Always -> Unary([]) :: nodes[this].act == Eventually -> Unary(<>) :: nodes[this].act == Next -> Unary(X) :: nodes[this].act == Not -> Unary(!) fi :: nodes[this].op == BiOp -> if :: nodes[this].act == Until -> Binary(U) :: nodes[this].act == And -> Binary(&&) :: nodes[this].act == Or -> Binary(||) :: nodes[this].act == Implies -> Binary(->) :: nodes[this].act == Equiv -> Binary(<->) fi :: nodes[this].op == NoOp -> printf ("p%d ", this) :: else -> assert(false) fi; this++ :: else fi } init { byte depth = 0; NodeId next = 0; NodeId this = 0; NodeId dpth = 0; do :: depth < DEPTH_LIMIT -> if :: nodes[this].op = NoOp :: nodes[this].op = UnOp; next++; nodes[this].f = next; if :: nodes[this].act = Always :: nodes[this].act = Eventually :: nodes[this].act = Next :: nodes[this].act = Not fi :: nodes[this].op = BiOp; next++; nodes[this].f = next; next++; nodes[this].g = next; if :: nodes[this].act = Until :: nodes[this].act = And :: nodes[this].act = Or :: nodes[this].act = Implies :: nodes[this].act = Equiv fi fi; if :: this == next -> break :: else fi; if :: dpth == this -> dpth = next; depth++ :: else fi; this++; :: else -> /* Depth reached; Fill leaves with NoOp */ do :: this <= next -> nodes[this].op = NoOp; this++ :: else -> break od; break od; assert (this != NUMBER_OF_NODES); #if 1 printf("ltl { "); run view(0, next); _nr_pr == 1; printf(" }\n") #endif } Spin/Examples/LTL/mobile1.pml0000644000175100017510000000525211676656750014051 0ustar ghgh/* * Model of cell-phone handoff strategy in a mobile network. * A translation from the pi-calculus description of this * model presented in: * Fredrik Orava and Joachim Parrow, 'An algebraic verification * of a mobile network,' Formal aspects of computing, 4:497-543 (1992). * For more information on this model, email: joachim@it.kth.se * * See also the simplified version of this model in mobile2 * * to perform the verification: * $ spin -a mobile1 * $ cc -o pan pan.c * $ pan -a */ mtype = { data, ho_cmd, ho_com, ho_acc, ho_fail, ch_rel, white, red, blue }; byte a_id, p_id; /* ids of processes refered to in the property */ chan inp = [1] of { mtype }; chan out = [1] of { mtype }; proctype CC(chan fa, fp, l) /* communication controller */ { chan m_old, m_new, x; mtype v; do :: inp?v -> printf("MSC: DATA\n"); fa!data; fa!v :: l?m_new -> fa!ho_cmd; fa!m_new; printf("MSC: HAND-OFF\n"); if :: fp?ho_com -> printf("MSC: CH_REL\n"); fa!ch_rel; fa?m_old; l!m_old; x = fa; fa = fp; fp = x :: fa?ho_fail -> printf("MSC: FAIL\n"); l!m_new fi od } proctype HC(chan l, m) /* handover controller */ { do :: l!m; l?m od } proctype MSC(chan fa, fp, m) /* mobile switching center */ { chan l = [0] of { chan }; atomic { run HC(l, m); run CC(fa, fp, l) } } proctype BS(chan f, m; bit how) /* base station */ { chan v; if :: how -> goto Active :: else -> goto Passive fi; Active: printf("MSC: ACTIVE\n"); do :: f?data -> f?v; m!data; m!v :: f?ho_cmd -> /* handover command */ progress: f?v; m!ho_cmd; m!v; if :: f?ch_rel -> f!m; goto Passive :: m?ho_fail -> printf("MSC: FAILURE\n"); f!ho_fail fi od; Passive: printf("MSC: PASSIVE\n"); m?ho_acc -> f!ho_com; goto Active } proctype MS(chan m) /* mobile station */ { chan m_new; mtype v; do :: m?data -> m?v; out!v :: m?ho_cmd; m?m_new; if :: m_new!ho_acc; m = m_new :: m!ho_fail fi od } proctype P(chan fa, fp) { chan m = [0] of { mtype }; atomic { run MSC(fa, fp, m); p_id = run BS(fp, m, 0) /* passive base station */ } } proctype Q(chan fa) { chan m = [0] of { mtype }; /* mixed use as mtype/chan */ atomic { a_id = run BS(fa, m, 1); /* active base station */ run MS(m) } } active proctype System() { chan fa = [0] of { mtype }; /* mixed use as mtype/chan */ chan fp = [0] of { mtype }; /* mixed use as mtype/chan */ atomic { run P(fa, fp); run Q(fa) } } active proctype top() { do :: inp!red; inp!white; inp!blue od } active proctype bot() { do /* deadlock on loss or duplication */ :: out?red; out?white; out?blue od } ltl { (![]<>((BS[a_id]@progress || BS[p_id]@progress))) -> [](<>inp?[red] -> <>out?[red]) } Spin/Examples/LTL/petersonN.pml0000644000175100017510000000141212331217514014444 0ustar ghgh/* Peterson's algorithm for N processes - see Lynch's book, p. 284 */ #define N 5 /* nr of processes */ byte turn[N], flag[N]; byte ncrit; /* auxiliary var to check mutual exclusion */ active [N] proctype user() { byte j, k; /* the _pid's are: 0 .. N-1 */ again: k = 0; /* count max N-1 rounds of competition */ do :: k < N-1 -> flag[_pid] = k; turn[k] = _pid; j = 0; /* for all j != _pid */ do :: j == _pid -> j++ :: j != _pid -> if :: j < N -> (flag[j] < k || turn[k] != _pid); j++ :: j >= N -> break fi od; k++ :: else -> /* survived all N-1 rounds */ break od; ncrit++; cs: assert(ncrit == 1); /* critical section */ ncrit--; flag[_pid] = 0; goto again } ltl bounded_bypass { user[1]@again -> <> user[1]@cs } Spin/Examples/LTL/pftp.pml0000644000175100017510000000761011470622506013452 0ustar ghgh/* * PROMELA Validation Model * FLOW CONTROL LAYER VALIDATION */ /* see end of file for LTL properties */ #define LOSS 1 /* message loss */ #define DUPS 0 /* duplicate msgs */ #define QSZ 2 /* queue size */ mtype = { red, white, blue, abort, accept, ack, sync_ack, close, connect, create, data, eof, open, reject, sync, transfer, FATAL, NON_FATAL, COMPLETE } chan ses_to_flow[2] = [QSZ] of { byte, byte }; chan flow_to_ses[2] = [QSZ] of { byte, byte }; chan dll_to_flow[2] = [QSZ] of { byte, byte }; /* * Flow Control Layer Validation Model */ #define true 1 #define false 0 #define M 4 /* range sequence numbers */ #define W 2 /* window size: M/2 */ proctype fc(chan s2f, f2d, f2s, d2f) { bool busy[M]; /* outstanding messages */ byte q; /* seq# oldest unacked msg */ byte m; /* seq# last msg received */ byte s; /* seq# next msg to send */ byte window; /* nr of outstanding msgs */ byte type; /* msg type */ bit received[M]; /* receiver housekeeping */ bit x; /* scratch variable */ byte p; /* seq# of last msg acked */ byte I_buf[M], O_buf[M]; /* message buffers */ xr s2f; xs f2d; xs f2s; xr d2f; /* sender part */ end: do :: atomic { (window < W && nempty(s2f) && nfull(f2d)) -> s2f?type,x; window = window + 1; busy[s] = true; O_buf[s] = type; f2d!type,s; if :: (type != sync) -> s = (s+1)%M :: (type == sync) -> window = 0; s = M; do :: (s > 0) -> s = s-1; busy[s] = false :: (s == 0) -> break od fi } :: atomic { (window > 0 && busy[q] == false) -> window = window - 1; q = (q+1)%M } #if DUPS :: atomic { (nfull(f2d) && window > 0 && busy[q] == true) -> f2d!O_buf[q],q } #endif :: atomic { (timeout && nfull(f2d) && window > 0 && busy[q] == true) -> f2d!O_buf[q],q } /* receiver part */ #if LOSS :: d2f?type,m /* lose any message */ #endif :: d2f?type,m -> if :: atomic { (type == ack) -> busy[m] = false } :: atomic { (type == sync) -> m = 0; do :: (m < M) -> received[m] = 0; m = m+1 :: (m == M) -> break od }; f2d!sync_ack,0 :: (type == sync_ack) -> f2s!sync_ack,0 :: (type != ack && type != sync && type != sync_ack)-> if :: atomic { (received[m] == true) -> x = ((0 f2d!ack,m :: (!x) /* else skip */ fi :: atomic { (received[m] == false) -> I_buf[m] = type; received[m] = true; received[(m-W+M)%M] = false } fi fi :: /* atomic { */ (received[p] == true && nfull(f2s) && nfull(f2d)) -> f2s!I_buf[p],0; f2d!ack,p; p = (p+1)%M /* } */ od } proctype upper_s(chan s2f, f2s0) { byte s_state; byte type, toggle; xs s2f; xr f2s0; s2f!sync,toggle; do :: f2s0?sync_ack,type -> if :: (type != toggle) :: (type == toggle) -> break fi :: timeout -> s2f!sync,toggle od; toggle = 1 - toggle; end: do :: s2f!white,0 :: atomic { (s_state == 0 && nfull(s2f)) -> s2f!red,0 -> s_state = 1 } :: atomic { (s_state == 1 && nfull(s2f)) -> s2f!blue,0 -> s_state = 2 } od } proctype upper_r(chan f2s1) { byte r_state; xr f2s1; do :: f2s1?white,0 :: f2s1?red,0 -> break :: f2s1?blue,0 -> assert(0) od; do :: f2s1?white,0 :: f2s1?red,0 -> assert(0) :: f2s1?blue,0 -> goto end od; end: do :: f2s1?white,0 :: f2s1?red,0 -> assert(0) :: f2s1?blue,0 -> assert(0) od } init { atomic { run fc(ses_to_flow[0], dll_to_flow[1], flow_to_ses[0], dll_to_flow[0]); run fc(ses_to_flow[1], dll_to_flow[0], flow_to_ses[1], dll_to_flow[1]); run upper_s(ses_to_flow[0], flow_to_ses[0]); run upper_r(flow_to_ses[1]) } } ltl p1 { ( len(flow_to_ses[1]) > 0 -> flow_to_ses[1]?[white]) U ( flow_to_ses[1]?[red] ) } ltl p2 { (!(flow_to_ses[1]?[blue])) U (flow_to_ses[1]?[red]) } ltl p3 { <> (flow_to_ses[1]?[blue]) } Spin/Examples/LTL/bakery.pml0000644000175100017510000000075012431501301013737 0ustar ghgh/* Lamport's Bakery algorithm for 2 processes */ byte turn[2]; /* who's turn is it? */ byte mutex; /* # procs in critical section */ active [2] proctype P() { byte i = _pid; do :: turn[i] = 1; turn[i] = turn[1-i] + 1; (turn[1-i] == 0) || (turn[i] < turn[1-i]) -> mutex++; CS: /* critical section */ mutex--; turn[i] = 0 od } /* * place the ltl property goes at the end, * so that P and mutex are defined */ ltl invariant { [] ((P@CS) -> (mutex == 1)) } Spin/Examples/LTL/diskhead.pml0000644000175100017510000000206412331274305014250 0ustar ghgh#define Nclients 3 bool client_busy[Nclients] bool Interrupt_set inline disk_io() { disk_busy = curproc assert(Interrupt_set == false) Interrupt_set = true } inline Serve_client(x) { client_busy[x] = true curproc = x+1 if /* disk status */ :: !disk_busy -> disk_io() :: else /* busy */ -> req_q!curproc fi } inline Handle() { Interrupt_set = false client_busy[disk_busy-1] = false if :: req_q?curproc -> disk_io() :: empty(req_q) -> disk_busy = 0 fi } active proctype disk_sched() { chan req_q = [Nclients] of { byte } byte disk_busy, curproc do :: !client_busy[0] -> progress_0: Serve_client(0) :: !client_busy[1] -> progress_1: Serve_client(1) :: !client_busy[2] -> progress_2: Serve_client(2) :: Interrupt_set -> Handle() od } ltl p { [] (client_busy[1] -> <> !client_busy[1]) } // exercise: // 1. negate the property, and check the error sequence found // 2. would it in principle be possible for both property p and // negated property !p to produce a counter-example? Spin/Examples/LTL/ltl_example.pml0000644000175100017510000000014111470610512014771 0ustar ghghchan q; int a; ltl c6 { [] ( (len(q) < 2) -> (len(q) > 0) ) } init { printf("hello world\n") } Spin/Examples/LTL/leader_pre.pml0000644000175100017510000000546212312737171014607 0ustar ghgh/* Dolev, Klawe & Rodeh for leader election in unidirectional ring * `An O(n log n) unidirectional distributed algorithm for extrema * finding in a circle,' J. of Algs, Vol 3. (1982), pp. 245-260 * Randomized initialization added -- Feb 17, 1997 */ /* sample properties: * <> elected * <>[]oneLeader * [] (noLeader U oneLeader) * ![] noLeader * * ltl format specifies positive properties * that should be satisfied -- spin will * look for counter-examples to these properties */ byte nr_leaders = 0; /* enclose ltl formula in $..$ if preprocessing symbols are used (they are not used below, but this illustrates the basic idea) use either <> or the word 'eventually' other word-equivalents: 'always' 'until' and 'not' enclose state expressions in (parentheses) the following two sets of formula are equivalent: ltl p0 $ eventually ( nr_leaders > 0 ) $ ltl p1 $ eventually always ( nr_leaders == 1 ) $ ltl p2 $ always ( (nr_leaders == 0) U (nr_leaders == 1) ) $ ltl p3 $ not always ( nr_leaders == 0 ) $ */ ltl p0 {<> (nr_leaders > 0)} ltl p1 {<>[] (nr_leaders == 1)} ltl p2 {[] ((nr_leaders == 0) U (nr_leaders == 1))} ltl p3 {![] (nr_leaders == 0)} #define N 5 /* number of processes in the ring */ #define L 10 /* 2xN */ byte I; mtype = { one, two, winner }; chan q[N] = [L] of { mtype, byte}; proctype nnode (chan inp, out; byte mynumber) { bit Active = 1, know_winner = 0; byte nr, maximum = mynumber, neighbourR; xr inp; xs out; printf("MSC: #%d\n", mynumber); out!one(mynumber); end: do :: inp?one(nr) -> if :: Active -> if :: nr != maximum -> out!two(nr); neighbourR = nr :: else -> know_winner = 1; out!winner,nr; fi :: else -> out!one(nr) fi :: inp?two(nr) -> if :: Active -> if :: neighbourR > nr && neighbourR > maximum -> maximum = neighbourR; out!one(neighbourR) :: else -> Active = 0 fi :: else -> out!two(nr) fi :: inp?winner,nr -> if :: nr != mynumber -> printf("MSC: LOST\n"); :: else -> printf("MSC: LEADER\n"); nr_leaders++; assert(nr_leaders == 1) fi; if :: know_winner :: else -> out!winner,nr fi; break od } init { byte proc; byte Ini[6]; /* N<=6 randomize the process numbers */ atomic { I = 1; /* pick a number to be assigned 1..N */ do :: I <= N -> if /* non-deterministic choice */ :: Ini[0] == 0 && N >= 1 -> Ini[0] = I :: Ini[1] == 0 && N >= 2 -> Ini[1] = I :: Ini[2] == 0 && N >= 3 -> Ini[2] = I :: Ini[3] == 0 && N >= 4 -> Ini[3] = I :: Ini[4] == 0 && N >= 5 -> Ini[4] = I :: Ini[5] == 0 && N >= 6 -> Ini[5] = I /* works for up to N=6 */ fi; I++ :: I > N -> /* assigned all numbers 1..N */ break od; proc = 1; do :: proc <= N -> run nnode (q[proc-1], q[proc%N], Ini[proc-1]); proc++ :: proc > N -> break od } } Spin/Examples/LTL/patterns.pml0000644000175100017510000001123712331272717014343 0ustar ghghinit { printf("hello ltl\n") } int P, Q, R, S, T, Z; /* Absence -- P is false: */ /* Globally */ ltl a1 { [](!P) } /* Before R */ ltl a2 { <>R -> (!P U R) } /* After Q */ ltl a3 { [](Q -> [](!P)) } /* Between Q and R */ ltl a4 { []((Q && !R && <> R) -> (!P U R)) } /* After Q until R */ ltl a5 { [](Q && !R -> (!P W R)) } /* Existence -- P becomes true: */ /* Globally */ ltl e1 { <>(P) } /* Before R */ ltl e2 { !R W (P && !R) } /* After Q */ ltl e3 { [](!Q || <>(Q && <>P)) } /* Between Q and R */ ltl e4 { [](Q && !R -> (!R W (P && !R))) } /* After Q until R */ ltl e5 { [](Q && !R -> (!R U (P && !R))) } #if 0 /* Bounded Existence -- P occurs at most twice: [tends to be complex] */ /* the next two formula can take a while to convert into never claims */ /* Globally */ ltl be1 { (!P W (P W (!P W (P W []!P)))) } /* Before R */ ltl be2 { <>R -> ((!P && !R U (R || ((P && !R) U (R || ((!P && !R U (R || ((P && !R) U (R || (!P U R))))))))))) } /* for the next three spin runs out of memory */ /* After Q */ ltl be3 { <>Q -> (!Q U (Q && (!P W (P W (!P W (P W []!P)))))) } /* Between Q and R */ ltl be4 { []((Q && <>R-> ((!P && !R U (R || ((P && !R) U (R || ((!P && !R U (R || ((P && !R) U (R || (!P U R))))))))))))) } /* After Q until R */ ltl be5 { [](Q -> ((!P && !R U (R || ((P && !R) U (R || ((!P && !R U (R || ((P && !R) U (R || (!P W R || []P)))))))))))) } #endif /* Universality -- P is true: */ /* Globally */ ltl u1 { [](P) } /* Before R */ ltl u2 { <>R -> (P U R) } /* After Q */ ltl u3 { [](Q -> [](P)) } /* Between Q and R */ ltl u4 { []((Q && !R && <> R-> (P U R))) } /* After Q until R */ ltl u5 { [](Q && !R -> (P W R)) } /* Precedence -- S precedes P: */ /* Globally */ ltl p1 { !P W S } /* Before R */ ltl p2 { <>R -> (!P U (S || R)) } /* After Q */ ltl p3 { []!Q || <>(Q && (!P W S)) } /* Between Q and R */ ltl p4 { []((Q && !R && <>R) -> (!P U (S || R))) } /* After Q until R */ ltl p5 { [](Q && !R -> (!P W (S || R))) } /* Response -- S responds to P: */ /* Globally */ ltl r1 { [](P -> <>S) } /* Before R */ ltl r2 { <>R -> (P -> (!R U (S && !R))) U R } /* After Q */ ltl r3 { [](Q -> [](P -> <>S)) } /* Between Q and R */ ltl r4 { []((Q && !R && <>R) -> (P -> (!R U (S && !R))) U R) } /* After Q until R */ ltl r5 { [](Q && !R -> ((P -> (!R U (S && !R))) W R)) } /* Precedence Chain -- S, T precedes P: */ /* Globally */ ltl pc1 { <>P -> (!P U (S && !P && X(!P U T))) } /* Before R */ ltl pc2 { <>R -> (!P U (R || (S && !P && X(!P U T)))) } /* After Q */ ltl pc3 { ([]!Q || (!Q U (Q && <>P -> (!P U (S && !P && X(!P U T)))))) } /* Between Q and R */ ltl pc4 { []((Q && <>R-> (!P U (R || (S && !P && X(!P U T)))))) } /* After Q until R */ ltl pc5 { [](Q -> (<>P -> (!P U (R || (S && !P && X(!P U T)))))) } /* Precedence Chain -- P precedes (S, T): */ /* Globally */ ltl pc6 { (<>(S && X<>T) -> ((!S) U P)) } /* Before R */ ltl pc7 { <>R -> ((!(S && (!R && X(!R U (T && !R)))) U (R || P))) } /* After Q */ ltl pc8 { ([]!Q || ((!Q) U (Q && ((<>(S && X<>T)) -> ((!S) U P))))) } /* Between Q and R */ ltl pc9 { []((Q && <>R) -> ((!(S && (!R) && X(!R U (T && !R)))) U (R || P))) } /* After Q until R */ ltl pc10 { [](Q -> (!(S && (!R& X(!R U (T && !R))) U (R || P) || [](!(S && X<>T))))) } /* Response Chain -- P responds to S,T: */ /* Globally */ ltl rc1 { [] (S && X<> T -> X(<>(T && <> P))) } /* Before R */ ltl rc2 { <>R -> (S && X(!R U T-> X(!R U (T && <> P))) U R) } /* After Q */ ltl rc3 { [] (Q -> [] (S && X<> T -> X(!T U (T && <> P)))) } /* Between Q and R */ ltl rc4 { [] ((Q && <>R) -> (S && X(!R U T) -> X(!R U (T && <> P))U R)) } /* After Q until R */ ltl rc5 { [] (Q -> (S && X(!R U T-> X(!R U (T && <> P))) U (R || [] (S && X(!R U T-> X(!R U (T && <> P))))))) } /* Response Chain -- S,T responds to P: */ /* Globally */ ltl rc6 { [] (P -> <>(S && X<>T)) } /* Before R */ ltl rc7 { <>R -> (P -> (!R U (S && !R && X(!R U T))) U R) } /* After Q */ ltl rc8 { [] (Q -> [] (P -> (S && X<> T))) } /* Between Q and R */ ltl rc9 { [] ((Q && <>R)-> (P -> (!R U (S && !R && X(!R U T)))) U R) } /* After Q until R */ ltl rc10 { [] (Q -> (P -> (!R U (S && !R && X(!R U T)))U (R || [] (P -> (S && X<> T))))) } /* Constrained Chain -- S,T without Z responds to P: */ /* Globally */ ltl cc1 { [] (P -> <>(S && !Z && X(!Z U T))) } /* Before R */ ltl cc2 { <>R -> (P -> (!R U (S && !R && !Z && X((!R && !Z U T)))) U R) } /* After Q */ ltl cc3 { [] (Q -> [] (P -> (S && !Z && X(!Z U T)))) } /* Between Q and R */ ltl cc4 { [] ((Q && <>R)-> (P -> (!R U (S && !R && !Z && X((!R && !Z U T)))) U R)) } /* After Q until R */ ltl cc5 { [] (Q -> (P -> (!R U (S && !R && !Z && X((!R && !Z U T)))) U (R || [] (P -> (S && !Z && X(!Z U T)))))) } Spin/Examples/LTL/mobile2.pml0000644000175100017510000000501711676656751014052 0ustar ghgh/* * Simplified model of cell-phone handoff strategy in a mobile network. * A translation from the pi-calculus description of this * model presented in: * Fredrik Orava and Joachim Parrow, 'An algebraic verification * of a mobile network,' Formal aspects of computing, 4:497-543 (1992). * For more information on this model, email: joachim@it.kth.se * * This version exploits some Promela features to reduce the number * of processes -- which looks better in simulations, and reduces * complexity (by about 60%) in verification. * * See also the more literal version of this model in mobile1. * * to perform the verification: * $ spin -a mobile2 * $ cc -o pan pan.c * $ pan -a */ mtype = { data, ho_cmd, ho_com, ho_acc, ho_fail, ch_rel, white, red, blue }; chan inp = [1] of { mtype }; chan out = [1] of { mtype }; chan fa = [0] of { chan }; chan fp = [0] of { chan }; chan m1 = [0] of { chan }; chan m2 = [0] of { chan }; chan l = [0] of { chan }; byte a_id, p_id; /* ids of processes refered to in the property */ proctype CC() /* communication controller */ { chan m_old, m_new, x; mtype v; do :: inp?v -> printf("MSC: DATA\n"); fa!data; fa!v :: l?m_new -> fa!ho_cmd; fa!m_new; printf("MSC: HAND-OFF\n"); if :: fp?ho_com -> printf("MSC: CH_REL\n"); fa!ch_rel; fa?m_old; l!m_old; x = fa; fa = fp; fp = x :: fa?ho_fail -> printf("MSC: FAIL\n"); l!m_new fi od } proctype HC(chan m) /* handover controller */ { do :: l!m; l?m od } proctype BS(chan f, m; bit how) /* base station */ { chan v; if :: how -> goto Active :: else -> goto Passive fi; Active: printf("MSC: ACTIVE\n"); do :: f?data -> f?v; m!data; m!v :: f?ho_cmd -> /* handover command */ progress: f?v; m!ho_cmd; m!v; if :: f?ch_rel -> f!m; goto Passive :: m?ho_fail -> printf("MSC: FAILURE\n"); f!ho_fail fi od; Passive: printf("MSC: PASSIVE\n"); m?ho_acc -> f!ho_com; goto Active } proctype MS(chan m) /* mobile station */ { chan m_new; mtype v; do :: m?data -> m?v; out!v :: m?ho_cmd; m?m_new; if :: m_new!ho_acc; m = m_new :: m!ho_fail fi od } active proctype System() { atomic { run HC(m1); run CC(); p_id = run BS(fp, m1, 0); /* passive base station */ a_id = run BS(fa, m2, 1); /* active base station */ run MS(m2) } end: do :: inp!red; inp!white; inp!blue od } active proctype Out() { end: do /* deadlocks if order is disturbed */ :: out?red; out?white; out?blue od } ltl { (![]<>(BS[a_id]@progress || BS[p_id]@progress)) -> []<>(inp?[red] -> <>out?[red]) } Spin/Examples/LTL/salesman1.pml0000644000175100017510000000177412331274305014367 0ustar ghgh#define N 4 #ifndef MAX #define MAX 97 #endif byte distance[N*N]; byte city, dest, tour, seen; bool visited[N]; #define Dist(a,b) distance[((a)*N)+(b)] // (0) -- (1) // | \__/ | // | / \ | // (2) -- (3) inline travel2(dest) { (city != dest && tour <= MAX) -> tour = tour + Dist(city,dest) city = dest if :: !visited[city] -> visited[city] = true printf("visit %d -- tour %d\n", city, tour) seen++ :: else fi } init { Dist(0,1) = 20; Dist(1,0) = 20 Dist(0,2) = 42; Dist(1,2) = 30 Dist(0,3) = 35; Dist(1,3) = 34 Dist(2,0) = 42; Dist(3,0) = 35 Dist(2,1) = 30; Dist(3,1) = 34 Dist(2,3) = 12; Dist(3,2) = 12 // find shortest route to visit all nodes starting and ending at 0 do :: select(dest : 0 .. (N-1)) -> travel2(dest) od } ltl p { [] ((seen < N) || (tour > MAX)) } // exercises: // 1. change it so that the distance going from a higher // city number to a lower number is half that of going // the other way (downhill/uphill) // 2. change it to find the longest iso shortest tour Spin/Examples/LTL/leader.pml0000644000175100017510000000463311676656750013757 0ustar ghgh/* Dolev, Klawe & Rodeh for leader election in unidirectional ring * `An O(n log n) unidirectional distributed algorithm for extrema * finding in a circle,' J. of Algs, Vol 3. (1982), pp. 245-260 * Randomized initialization added -- Feb 17, 1997 */ /* sample properties: * <> elected * <>[]oneLeader * [] (noLeader U oneLeader) * ![] noLeader * * ltl format specifies positive properties * that should be satisfied -- spin will * look for counter-examples to these properties * verify as: * spin -a leader.pml * cc -o pan pan.c * ./pan -N p0 * ./pan -N p1 * ./pan -N p2 * ./pan -N p3 */ byte nr_leaders = 0; ltl p0 { <> (nr_leaders > 0) } ltl p1 { <>[] (nr_leaders == 1) } ltl p2 { [] (nr_leaders == 0 U nr_leaders == 1) } ltl p3 { ![] (nr_leaders == 0) } #define N 5 /* number of processes in the ring */ #define L 10 /* 2xN */ byte I; mtype = { one, two, winner }; chan q[N] = [L] of { mtype, byte}; proctype nnode (chan inp, out; byte mynumber) { bit Active = 1, know_winner = 0; byte nr, maximum = mynumber, neighbourR; xr inp; xs out; printf("MSC: %d\n", mynumber); out!one(mynumber); end: do :: inp?one(nr) -> if :: Active -> if :: nr != maximum -> out!two(nr); neighbourR = nr :: else -> know_winner = 1; out!winner,nr; fi :: else -> out!one(nr) fi :: inp?two(nr) -> if :: Active -> if :: neighbourR > nr && neighbourR > maximum -> maximum = neighbourR; out!one(neighbourR) :: else -> Active = 0 fi :: else -> out!two(nr) fi :: inp?winner,nr -> if :: nr != mynumber -> printf("MSC: LOST\n"); :: else -> printf("MSC: LEADER\n"); nr_leaders++; assert(nr_leaders == 1) fi; if :: know_winner :: else -> out!winner,nr fi; break od } init { byte proc; byte Ini[6]; /* N<=6 randomize the process numbers */ atomic { I = 1; /* pick a number to be assigned 1..N */ do :: I <= N -> if /* non-deterministic choice */ :: Ini[0] == 0 && N >= 1 -> Ini[0] = I :: Ini[1] == 0 && N >= 2 -> Ini[1] = I :: Ini[2] == 0 && N >= 3 -> Ini[2] = I :: Ini[3] == 0 && N >= 4 -> Ini[3] = I :: Ini[4] == 0 && N >= 5 -> Ini[4] = I :: Ini[5] == 0 && N >= 6 -> Ini[5] = I /* works for up to N=6 */ fi; I++ :: I > N -> /* assigned all numbers 1..N */ break od; proc = 1; do :: proc <= N -> run nnode (q[proc-1], q[proc%N], Ini[proc-1]); proc++ :: proc > N -> break od } } Spin/Examples/LTL/ltl_always_eventually.pml0000644000175100017510000000012312330777267017127 0ustar ghghint p; init { printf("hello world\n") } ltl name { always eventually (p > 5) } Spin/Examples/LTL/zune.pml0000644000175100017510000000270112331054360013450 0ustar ghgh/* * input: days elapsed since Jan 1, 1980 * intended output: year and daynr in current year * * a bug caused all Zune-30 players to freeze on Dec 31, 2008 * http://www.zuneboards.com/forums/zune-news/38143-cause-zune-30-leapyear-problem-isolated.html * * Wikepedia: * The bug was in the firmware clock-driver, which was written by Freescale * for their MC13783 PMIC processor. The same bug froze up Toshiba Gigabeat S * media players that share the same hardware and driver. */ #define IsLeapYear(y) (((y%4 == 0) && (y%100 != 0)) || (y%400 == 0)) chan q = [0] of { short }; active proctype zune() { short year = 1980; short days; end: do :: q?days -> S: do :: days > 365 -> if :: IsLeapYear(year) -> if :: days > 366 -> days = days - 366; year++ :: else #ifdef FIX -> break #endif fi :: else -> days = days - 365; year++ fi :: else -> break od; E: printf("Year: %d, Day %d\n", year, days) od; /* check that the date is in a valid range */ assert(days >= 1 && days <= 366); assert(days < 366 || IsLeapYear(year)) } init { /* jan 1, 2008 */ short days = (2008 - 1980) * 365 + (2008-1980)/4; if :: q!days + 365 :: q!days + 366 :: q!days + 367 fi } ltl p1 { [] (( zune@S ) -> ( <> zune@E ) ) } /* sample analysis: spin -a zune.pml # spin version 6 or later cc -o pan pan.c # compile ./pan -a -N p1 # find matches of formula spin -t -p -l zune.pml # replay error sequence */ Spin/Examples/LTL/salesman2.pml0000644000175100017510000000213012331274305014353 0ustar ghgh#define N 4 #ifndef MAX #define MAX 97 #endif byte distance[N*N]; byte city, dest, tour, seen; byte visited[N]; // shortest tour so far #define Dist(a,b) distance[((a)*N)+(b)] // (0) -- (1) // | \__/ | // | / \ | // (2) -- (3) inline travel2(dest) { (city != dest && tour <= MAX && (visited[dest] == 0 || tour + Dist(city,dest) < visited[dest])) -> tour = tour + Dist(city,dest) city = dest if :: !visited[city] -> visited[city] = tour printf("visit %d -- tour %d\n", city, tour) seen++ :: else fi } init { Dist(0,1) = 20; Dist(1,0) = 20 Dist(0,2) = 42; Dist(1,2) = 30 Dist(0,3) = 35; Dist(1,3) = 34 Dist(2,0) = 42; Dist(3,0) = 35 Dist(2,1) = 30; Dist(3,1) = 34 Dist(2,3) = 12; Dist(3,2) = 12 // find shortest route to visit all nodes starting and ending at 0 do :: select(dest : 0 .. (N-1)) -> travel2(dest) od } ltl p { [] ((seen < N) || (tour > MAX)) } // exercises: // 1. change it so that the distance going from a higher // city number to a lower number is half that of going // the other way (downhill/uphill) // 2. change it to find the longest iso shortest tour Spin/Examples/peterson.pml0000644000175100017510000000052411676656751013723 0ustar ghgh/* Peterson's solution to the mutual exclusion problem - 1981 */ bool turn, flag[2]; byte ncrit; active [2] proctype user() { assert(_pid == 0 || _pid == 1); again: flag[_pid] = 1; turn = _pid; (flag[1 - _pid] == 0 || turn == 1 - _pid); ncrit++; assert(ncrit == 1); /* critical section */ ncrit--; flag[_pid] = 0; goto again } Spin/Examples/pan.t0000664000175100017510000004417712636050452012312 0ustar ghgh#ifdef PEG struct T_SRC { char *fl; int ln; } T_SRC[NTRANS]; void tr_2_src(int m, char *file, int ln) { T_SRC[m].fl = file; T_SRC[m].ln = ln; } void putpeg(int n, int m) { printf("%5d trans %4d ", m, n); printf("%s:%d\n", T_SRC[n].fl, T_SRC[n].ln); } #endif void settable(void) { Trans *T; Trans *settr(int, int, int, int, int, char *, int, int, int); trans = (Trans ***) emalloc(2*sizeof(Trans **)); /* proctype 0: loop */ trans[0] = (Trans **) emalloc(13*sizeof(Trans *)); trans[0][10] = settr(9,0,9,1,0,".(goto)", 0, 2, 0); T = trans[0][9] = settr(8,0,0,0,0,"DO", 0, 2, 0); T->nxt = settr(8,0,1,0,0,"DO", 0, 2, 0); trans[0][1] = settr(0,0,6,3,3,"a = ((a+1)%3)", 0, 2, 0); T = trans[0][6] = settr(5,0,0,0,0,"IF", 0, 2, 0); T = T->nxt = settr(5,0,2,0,0,"IF", 0, 2, 0); T->nxt = settr(5,0,4,0,0,"IF", 0, 2, 0); trans[0][2] = settr(1,0,3,4,4,"b = (2*a)", 0, 2, 0); trans[0][3] = settr(2,0,8,1,0,"(1)", 0, 2, 0); trans[0][7] = settr(6,0,8,1,0,".(goto)", 0, 2, 0); trans[0][4] = settr(3,0,5,5,5,"b = (2*a)", 0, 2, 0); trans[0][5] = settr(4,0,8,1,0,"(1)", 0, 2, 0); trans[0][8] = settr(7,0,9,6,6,"b = (b-1)", 0, 2, 0); trans[0][11] = settr(10,0,12,1,0,"break", 0, 2, 0); trans[0][12] = settr(11,0,0,7,7,"-end-", 0, 3500, 0); /* np_ demon: */ trans[_NP_] = (Trans **) emalloc(2*sizeof(Trans *)); T = trans[_NP_][0] = settr(9997,0,1,_T5,0,"(np_)", 1,2,0); T->nxt = settr(9998,0,0,_T2,0,"(1)", 0,2,0); T = trans[_NP_][1] = settr(9999,0,1,_T5,0,"(np_)", 1,2,0); } Trans * settr( int t_id, int a, int b, int c, int d, char *t, int g, int tpe0, int tpe1) { Trans *tmp = (Trans *) emalloc(sizeof(Trans)); tmp->atom = a&(6|32); /* only (2|8|32) have meaning */ if (!g) tmp->atom |= 8; /* no global references */ tmp->st = b; tmp->tpe[0] = tpe0; tmp->tpe[1] = tpe1; tmp->tp = t; tmp->t_id = t_id; tmp->forw = c; tmp->back = d; return tmp; } Trans * cpytr(Trans *a) { Trans *tmp = (Trans *) emalloc(sizeof(Trans)); int i; tmp->atom = a->atom; tmp->st = a->st; #ifdef HAS_UNLESS tmp->e_trans = a->e_trans; for (i = 0; i < HAS_UNLESS; i++) tmp->escp[i] = a->escp[i]; #endif tmp->tpe[0] = a->tpe[0]; tmp->tpe[1] = a->tpe[1]; for (i = 0; i < 6; i++) { tmp->qu[i] = a->qu[i]; tmp->ty[i] = a->ty[i]; } tmp->tp = (char *) emalloc(strlen(a->tp)+1); strcpy(tmp->tp, a->tp); tmp->t_id = a->t_id; tmp->forw = a->forw; tmp->back = a->back; return tmp; } #ifndef NOREDUCE int srinc_set(int n) { if (n <= 2) return LOCAL; if (n <= 2+ DELTA) return Q_FULL_F; /* 's' or nfull */ if (n <= 2+2*DELTA) return Q_EMPT_F; /* 'r' or nempty */ if (n <= 2+3*DELTA) return Q_EMPT_T; /* empty */ if (n <= 2+4*DELTA) return Q_FULL_T; /* full */ if (n == 5*DELTA) return GLOBAL; if (n == 6*DELTA) return TIMEOUT_F; if (n == 7*DELTA) return ALPHA_F; Uerror("cannot happen srinc_class"); return BAD; } int srunc(int n, int m) { switch(m) { case Q_FULL_F: return n-2; case Q_EMPT_F: return n-2-DELTA; case Q_EMPT_T: return n-2-2*DELTA; case Q_FULL_T: return n-2-3*DELTA; case ALPHA_F: case TIMEOUT_F: return 257; /* non-zero, and > MAXQ */ } Uerror("cannot happen srunc"); return 0; } #endif int cnt; #ifdef HAS_UNLESS int isthere(Trans *a, int b) { Trans *t; for (t = a; t; t = t->nxt) if (t->t_id == b) return 1; return 0; } #endif #ifndef NOREDUCE int mark_safety(Trans *t) /* for conditional safety */ { int g = 0, i, j, k; if (!t) return 0; if (t->qu[0]) return (t->qu[1])?2:1; /* marked */ for (i = 0; i < 2; i++) { j = srinc_set(t->tpe[i]); if (j >= GLOBAL && j != ALPHA_F) return -1; if (j != LOCAL) { k = srunc(t->tpe[i], j); if (g == 0 || t->qu[0] != k || t->ty[0] != j) { t->qu[g] = k; t->ty[g] = j; g++; } } } return g; } #endif void retrans(int n, int m, int is, short srcln[], uchar reach[], uchar lpstate[]) /* process n, with m states, is=initial state */ { Trans *T0, *T1, *T2, *T3; Trans *T4, *T5; /* t_reverse or has_unless */ int i; #if defined(HAS_UNLESS) || !defined(NOREDUCE) int k; #endif #ifndef NOREDUCE int g, h, j, aa; #endif #ifdef HAS_UNLESS int p; #endif if (state_tables >= 4) { printf("STEP 1 %s\n", procname[n]); for (i = 1; i < m; i++) for (T0 = trans[n][i]; T0; T0 = T0->nxt) crack(n, i, T0, srcln); return; } do { for (i = 1, cnt = 0; i < m; i++) { T2 = trans[n][i]; T1 = T2?T2->nxt:(Trans *)0; /* prescan: */ for (T0 = T1; T0; T0 = T0->nxt) /* choice in choice */ { if (T0->st && trans[n][T0->st] && trans[n][T0->st]->nxt) break; } #if 0 if (T0) printf("\tstate %d / %d: choice in choice\n", i, T0->st); #endif if (T0) for (T0 = T1; T0; T0 = T0->nxt) { T3 = trans[n][T0->st]; if (!T3->nxt) { T2->nxt = cpytr(T0); T2 = T2->nxt; imed(T2, T0->st, n, i); continue; } do { T3 = T3->nxt; T2->nxt = cpytr(T3); T2 = T2->nxt; imed(T2, T0->st, n, i); } while (T3->nxt); cnt++; } } } while (cnt); if (state_tables >= 3) { printf("STEP 2 %s\n", procname[n]); for (i = 1; i < m; i++) for (T0 = trans[n][i]; T0; T0 = T0->nxt) crack(n, i, T0, srcln); return; } for (i = 1; i < m; i++) { if (trans[n][i] && trans[n][i]->nxt) /* optimize */ { T1 = trans[n][i]->nxt; #if 0 printf("\t\tpull %d (%d) to %d\n", T1->st, T1->forw, i); #endif srcln[i] = srcln[T1->st]; /* Oyvind Teig, 5.2.0 */ if (!trans[n][T1->st]) continue; T0 = cpytr(trans[n][T1->st]); trans[n][i] = T0; reach[T1->st] = 1; imed(T0, T1->st, n, i); for (T1 = T1->nxt; T1; T1 = T1->nxt) { #if 0 printf("\t\tpull %d (%d) to %d\n", T1->st, T1->forw, i); #endif /* srcln[i] = srcln[T1->st]; gh: not useful */ if (!trans[n][T1->st]) continue; T0->nxt = cpytr(trans[n][T1->st]); T0 = T0->nxt; reach[T1->st] = 1; imed(T0, T1->st, n, i); } } } if (state_tables >= 2) { printf("STEP 3 %s\n", procname[n]); for (i = 1; i < m; i++) for (T0 = trans[n][i]; T0; T0 = T0->nxt) crack(n, i, T0, srcln); return; } #ifdef HAS_UNLESS for (i = 1; i < m; i++) { if (!trans[n][i]) continue; /* check for each state i if an * escape to some state p is defined * if so, copy and mark p's transitions * and prepend them to the transition- * list of state i */ if (!like_java) /* the default */ { for (T0 = trans[n][i]; T0; T0 = T0->nxt) for (k = HAS_UNLESS-1; k >= 0; k--) { if (p = T0->escp[k]) for (T1 = trans[n][p]; T1; T1 = T1->nxt) { if (isthere(trans[n][i], T1->t_id)) continue; T2 = cpytr(T1); T2->e_trans = p; T2->nxt = trans[n][i]; trans[n][i] = T2; } } } else /* outermost unless checked first */ { T4 = T3 = (Trans *) 0; for (T0 = trans[n][i]; T0; T0 = T0->nxt) for (k = HAS_UNLESS-1; k >= 0; k--) { if (p = T0->escp[k]) for (T1 = trans[n][p]; T1; T1 = T1->nxt) { if (isthere(trans[n][i], T1->t_id)) continue; T2 = cpytr(T1); T2->nxt = (Trans *) 0; T2->e_trans = p; if (T3) T3->nxt = T2; else T4 = T2; T3 = T2; } } if (T4) { T3->nxt = trans[n][i]; trans[n][i] = T4; } } } #endif #ifndef NOREDUCE for (i = 1; i < m; i++) { if (a_cycles) { /* moves through these states are visible */ #if PROG_LAB>0 && defined(HAS_NP) if (progstate[n][i]) goto degrade; for (T1 = trans[n][i]; T1; T1 = T1->nxt) if (progstate[n][T1->st]) goto degrade; #endif if (accpstate[n][i] || visstate[n][i]) goto degrade; for (T1 = trans[n][i]; T1; T1 = T1->nxt) if (accpstate[n][T1->st]) goto degrade; } T1 = trans[n][i]; if (!T1) continue; g = mark_safety(T1); /* V3.3.1 */ if (g < 0) goto degrade; /* global */ /* check if mixing of guards preserves reduction */ if (T1->nxt) { k = 0; for (T0 = T1; T0; T0 = T0->nxt) { if (!(T0->atom&8)) goto degrade; for (aa = 0; aa < 2; aa++) { j = srinc_set(T0->tpe[aa]); if (j >= GLOBAL && j != ALPHA_F) goto degrade; if (T0->tpe[aa] && T0->tpe[aa] != T1->tpe[0]) k = 1; } } /* g = 0; V3.3.1 */ if (k) /* non-uniform selection */ for (T0 = T1; T0; T0 = T0->nxt) for (aa = 0; aa < 2; aa++) { j = srinc_set(T0->tpe[aa]); if (j != LOCAL) { k = srunc(T0->tpe[aa], j); for (h = 0; h < 6; h++) if (T1->qu[h] == k && T1->ty[h] == j) break; if (h >= 6) { T1->qu[g%6] = k; T1->ty[g%6] = j; g++; } } } if (g > 6) { T1->qu[0] = 0; /* turn it off */ printf("pan: warning, line %d, ", srcln[i]); printf("too many stmnt types (%d)", g); printf(" in selection\n"); goto degrade; } } /* mark all options global if >=1 is global */ for (T1 = trans[n][i]; T1; T1 = T1->nxt) if (!(T1->atom&8)) break; if (T1) degrade: for (T1 = trans[n][i]; T1; T1 = T1->nxt) T1->atom &= ~8; /* mark as unsafe */ /* can only mix 'r's or 's's if on same chan */ /* and not mixed with other local operations */ T1 = trans[n][i]; if (!T1 || T1->qu[0]) continue; j = T1->tpe[0]; if (T1->nxt && T1->atom&8) { if (j == 5*DELTA) { printf("warning: line %d ", srcln[i]); printf("mixed condition "); printf("(defeats reduction)\n"); goto degrade; } for (T0 = T1; T0; T0 = T0->nxt) for (aa = 0; aa < 2; aa++) if (T0->tpe[aa] && T0->tpe[aa] != j) { printf("warning: line %d ", srcln[i]); printf("[%d-%d] mixed %stion ", T0->tpe[aa], j, (j==5*DELTA)?"condi":"selec"); printf("(defeats reduction)\n"); printf(" '%s' <-> '%s'\n", T1->tp, T0->tp); goto degrade; } } } #endif for (i = 1; i < m; i++) { T2 = trans[n][i]; if (!T2 || T2->nxt || strncmp(T2->tp, ".(goto)", 7) || !stopstate[n][i]) continue; stopstate[n][T2->st] = 1; } if (state_tables && !verbose) { if (dodot) { char buf[256], *q = buf, *p = procname[n]; while (*p != '\0') { if (*p != ':') { *q++ = *p; } p++; } *q = '\0'; printf("digraph "); switch (Btypes[n]) { case I_PROC: printf("init {\n"); break; case N_CLAIM: printf("claim_%s {\n", buf); break; case E_TRACE: printf("notrace {\n"); break; case N_TRACE: printf("trace {\n"); break; default: printf("p_%s {\n", buf); break; } printf("size=\"8,10\";\n"); printf(" GT [shape=box,style=dotted,label=\"%s\"];\n", buf); printf(" GT -> S%d;\n", is); } else { switch (Btypes[n]) { case I_PROC: printf("init\n"); break; case N_CLAIM: printf("claim %s\n", procname[n]); break; case E_TRACE: printf("notrace assertion\n"); break; case N_TRACE: printf("trace assertion\n"); break; default: printf("proctype %s\n", procname[n]); break; } } for (i = 1; i < m; i++) { reach[i] = 1; } tagtable(n, m, is, srcln, reach); if (dodot) printf("}\n"); } else for (i = 1; i < m; i++) { int nrelse; if (Btypes[n] != N_CLAIM) { for (T0 = trans[n][i]; T0; T0 = T0->nxt) { if (T0->st == i && strcmp(T0->tp, "(1)") == 0) { printf("error: proctype '%s' ", procname[n]); printf("line %d, state %d: has un", srcln[i], i); printf("conditional self-loop\n"); pan_exit(1); } } } nrelse = 0; for (T0 = trans[n][i]; T0; T0 = T0->nxt) { if (strcmp(T0->tp, "else") == 0) nrelse++; } if (nrelse > 1) { printf("error: proctype '%s' state", procname[n]); printf(" %d, inherits %d", i, nrelse); printf(" 'else' stmnts\n"); pan_exit(1); } } #if !defined(LOOPSTATE) && !defined(BFS_PAR) if (state_tables) #endif do_dfs(n, m, is, srcln, reach, lpstate); if (!t_reverse) { return; } /* process n, with m states, is=initial state -- reverse list */ if (!state_tables && Btypes[n] != N_CLAIM) { for (i = 1; i < m; i++) { Trans *Tx = (Trans *) 0; /* list of escapes */ Trans *Ty = (Trans *) 0; /* its tail element */ T1 = (Trans *) 0; /* reversed list */ T2 = (Trans *) 0; /* its tail */ T3 = (Trans *) 0; /* remembers possible 'else' */ /* find unless-escapes, they should go first */ T4 = T5 = T0 = trans[n][i]; #ifdef HAS_UNLESS while (T4 && T4->e_trans) /* escapes are first in orig list */ { T5 = T4; /* remember predecessor */ T4 = T4->nxt; } #endif /* T4 points to first non-escape, T5 to its parent, T0 to original list */ if (T4 != T0) /* there was at least one escape */ { T3 = T5->nxt; /* start of non-escapes */ T5->nxt = (Trans *) 0; /* separate */ Tx = T0; /* start of the escapes */ Ty = T5; /* its tail */ T0 = T3; /* the rest, to be reversed */ } /* T0 points to first non-escape, Tx to the list of escapes, Ty to its tail */ /* first tail-add non-escape transitions, reversed */ T3 = (Trans *) 0; for (T5 = T0; T5; T5 = T4) { T4 = T5->nxt; #ifdef HAS_UNLESS if (T5->e_trans) { printf("error: cannot happen!\n"); continue; } #endif if (strcmp(T5->tp, "else") == 0) { T3 = T5; T5->nxt = (Trans *) 0; } else { T5->nxt = T1; if (!T1) { T2 = T5; } T1 = T5; } } /* T3 points to a possible else, which is removed from the list */ /* T1 points to the reversed list so far (without escapes) */ /* T2 points to the tail element -- where the else should go */ if (T2 && T3) { T2->nxt = T3; /* add else */ } else { if (T3) /* there was an else, but there's no tail */ { if (!T1) /* and no reversed list */ { T1 = T3; /* odd, but possible */ } else /* even stranger */ { T1->nxt = T3; } } } /* add in the escapes, to that they appear at the front */ if (Tx && Ty) { Ty->nxt = T1; T1 = Tx; } trans[n][i] = T1; /* reversed, with escapes first and else last */ } } if (state_tables && verbose) { printf("FINAL proctype %s\n", procname[n]); for (i = 1; i < m; i++) for (T0 = trans[n][i]; T0; T0 = T0->nxt) crack(n, i, T0, srcln); } } void imed(Trans *T, int v, int n, int j) /* set intermediate state */ { progstate[n][T->st] |= progstate[n][v]; accpstate[n][T->st] |= accpstate[n][v]; stopstate[n][T->st] |= stopstate[n][v]; mapstate[n][j] = T->st; } void tagtable(int n, int m, int is, short srcln[], uchar reach[]) { Trans *z; if (is >= m || !trans[n][is] || is <= 0 || reach[is] == 0) return; reach[is] = 0; if (state_tables) for (z = trans[n][is]; z; z = z->nxt) { if (dodot) dot_crack(n, is, z); else crack(n, is, z, srcln); } for (z = trans[n][is]; z; z = z->nxt) { #ifdef HAS_UNLESS int i, j; #endif tagtable(n, m, z->st, srcln, reach); #ifdef HAS_UNLESS for (i = 0; i < HAS_UNLESS; i++) { j = trans[n][is]->escp[i]; if (!j) break; tagtable(n, m, j, srcln, reach); } #endif } } extern Trans *t_id_lkup[]; void dfs_table(int n, int m, int is, short srcln[], uchar reach[], uchar lpstate[]) { Trans *z; if (is >= m || is <= 0 || !trans[n][is]) return; if ((reach[is] & (4|8|16)) != 0) { if ((reach[is] & (8|16)) == 16) /* on stack, not yet recorded */ { lpstate[is] = 1; reach[is] |= 8; /* recorded */ if (state_tables && verbose) { printf("state %d line %d is a loopstate\n", is, srcln[is]); } } return; } reach[is] |= (4|16); /* visited | onstack */ for (z = trans[n][is]; z; z = z->nxt) { t_id_lkup[z->t_id] = z; #ifdef HAS_UNLESS int i, j; #endif dfs_table(n, m, z->st, srcln, reach, lpstate); #ifdef HAS_UNLESS for (i = 0; i < HAS_UNLESS; i++) { j = trans[n][is]->escp[i]; if (!j) break; dfs_table(n, m, j, srcln, reach, lpstate); } #endif } reach[is] &= ~16; /* no longer on stack */ } void do_dfs(int n, int m, int is, short srcln[], uchar reach[], uchar lpstate[]) { int i; dfs_table(n, m, is, srcln, reach, lpstate); for (i = 0; i < m; i++) reach[i] &= ~(4|8|16); } void crack(int n, int j, Trans *z, short srcln[]) { int i; if (!z) return; printf(" state %3d -(tr %3d)-> state %3d ", j, z->forw, z->st); printf("[id %3d tp %3d", z->t_id, z->tpe[0]); if (z->tpe[1]) printf(",%d", z->tpe[1]); #ifdef HAS_UNLESS if (z->e_trans) printf(" org %3d", z->e_trans); else if (state_tables >= 2) for (i = 0; i < HAS_UNLESS; i++) { if (!z->escp[i]) break; printf(" esc %d", z->escp[i]); } #endif printf("]"); printf(" [%s%s%s%s%s] %s:%d => ", z->atom&6?"A":z->atom&32?"D":"-", accpstate[n][j]?"a" :"-", stopstate[n][j]?"e" : "-", progstate[n][j]?"p" : "-", z->atom & 8 ?"L":"G", PanSource, srcln[j]); for (i = 0; z->tp[i]; i++) if (z->tp[i] == '\n') printf("\\n"); else putchar(z->tp[i]); if (verbose && z->qu[0]) { printf("\t["); for (i = 0; i < 6; i++) if (z->qu[i]) printf("(%d,%d)", z->qu[i], z->ty[i]); printf("]"); } printf("\n"); fflush(stdout); } /* spin -a m.pml; cc -o pan pan.c; ./pan -D | dot -Tps > foo.ps; ps2pdf foo.ps */ void dot_crack(int n, int j, Trans *z) { int i; if (!z) return; printf(" S%d -> S%d [color=black", j, z->st); if (z->atom&6) printf(",style=dashed"); else if (z->atom&32) printf(",style=dotted"); else if (z->atom&8) printf(",style=solid"); else printf(",style=bold"); printf(",label=\""); for (i = 0; z->tp[i]; i++) { if (z->tp[i] == '\\' && z->tp[i+1] == 'n') { i++; printf(" "); } else { putchar(z->tp[i]); } } printf("\"];\n"); if (accpstate[n][j]) printf(" S%d [color=red,style=bold];\n", j); else if (progstate[n][j]) printf(" S%d [color=green,style=bold];\n", j); if (stopstate[n][j]) printf(" S%d [color=blue,style=bold,shape=box];\n", j); } #ifdef VAR_RANGES #define BYTESIZE 32 /* 2^8 : 2^3 = 256:8 = 32 */ typedef struct Vr_Ptr { char *nm; uchar vals[BYTESIZE]; struct Vr_Ptr *nxt; } Vr_Ptr; Vr_Ptr *ranges = (Vr_Ptr *) 0; void logval(char *s, int v) { Vr_Ptr *tmp; if (v<0 || v > 255) return; for (tmp = ranges; tmp; tmp = tmp->nxt) if (!strcmp(tmp->nm, s)) goto found; tmp = (Vr_Ptr *) emalloc(sizeof(Vr_Ptr)); tmp->nxt = ranges; ranges = tmp; tmp->nm = s; found: tmp->vals[(v)/8] |= 1<<((v)%8); } void dumpval(uchar X[], int range) { int w, x, i, j = -1; for (w = i = 0; w < range; w++) for (x = 0; x < 8; x++, i++) { from: if ((X[w] & (1<= 0 && j != 255) printf("-255"); } void dumpranges(void) { Vr_Ptr *tmp; printf("\nValues assigned within "); printf("interval [0..255]:\n"); for (tmp = ranges; tmp; tmp = tmp->nxt) { printf("\t%s\t: ", tmp->nm); dumpval(tmp->vals, BYTESIZE); printf("\n"); } } #endif Spin/Examples/pan0000775000175100017510000025171312636050467012055 0ustar ghghELF>ð@@@8 @@@@@@øø88@8@@@ÜÜ ((a(a€ ¨b PPaPaTT@T@DDPåtdØïØï@Øï@LLQåtdRåtd((a(aØØ/lib64/ld-linux-x86-64.so.2GNUGNU.éÔ¶¹W´Ã0“™±ØÇ6Jß…-''()Œ9ò‹}_A!¡gë¸löþI…¹5“ Xý ±Ç¿<;Q$ñÎ-(êŒ6ÕšÀaãÈa__gmon_start__libc.so.6fflushstrcpyexitsprintfsrandfopenstrncmpstrrchrperrorsignalstrncpyputs__stack_chk_failputcharmemsetstrstrmemcmpstdout__isoc99_fscanfmemcpyfclosevprintfmallocstrcat__ctype_b_locstderrfwriteatoistrchrfprintftimesstrcmp__libc_start_mainsysconfGLIBC_2.3GLIBC_2.14GLIBC_2.4GLIBC_2.7GLIBC_2.2.5ii ,”‘–6ii Aii Kui UàaÀa'Èa(aaaa a(a0a8a@a Ha Pa Xa `a hapaxa€aˆaa˜a a¨a°a¸aÀaÈaÐaØaàaèaða øa!a"a#a$a% a&Hƒìè£è2è=ÀHƒÄÃÿ5Z!ÿ%\!@ÿ%Z!héàÿÿÿÿ%R!héÐÿÿÿÿ%J!héÀÿÿÿÿ%B!hé°ÿÿÿÿ%:!hé ÿÿÿÿ%2!héÿÿÿÿ%*!hé€ÿÿÿÿ%"!hépÿÿÿÿ%!hé`ÿÿÿÿ%!h éPÿÿÿÿ% !h é@ÿÿÿÿ%!h é0ÿÿÿÿ%ú!h é ÿÿÿÿ%ò!h éÿÿÿÿ%ê!héÿÿÿÿ%â!héðþÿÿÿ%Ú!héàþÿÿÿ%Ò!héÐþÿÿÿ%Ê!héÀþÿÿÿ%Â!hé°þÿÿÿ%º!hé þÿÿÿ%²!héþÿÿÿ%ª!hé€þÿÿÿ%¢!hépþÿÿÿ%š!hé`þÿÿÿ%’!héPþÿÿÿ%Š!hé@þÿÿÿ%‚!hé0þÿÿÿ%z!hé þÿÿÿ%r!héþÿÿÿ%j!héþÿÿÿ%b!héðýÿÿÿ%Z!h éàýÿÿÿ%R!h!éÐýÿÿÿ%J!h"éÀýÿÿÿ%B!h#é°ýÿÿÿ%:!h$é ýÿÿ1íI‰Ñ^H‰âHƒäðPTIÇÀ°Ì@HÇÁ Ì@HÇÇg@ègþÿÿôHƒìH‹¹!H…ÀtÿÐHƒÄÃUH‰åSHƒì€=€ !uK»@aH‹z !Hë8aHÁûHƒëH9Øs$fDHƒÀH‰U !ÿÅ8aH‹G !H9ØrâÆ3 !HƒÄ[]Ãfff.„Hƒ=þ UH‰åt¸H…Àt]¿Haÿà]ÃUH‰å]ÃUH‰å‰}ü]ÃUH‰åSHƒì8‰}̉uȉUĶ$[!¶À‰EìH‹S!H‰EØ‹Í !…Àt}ìþžÀ¶Àé4}ìþ~H‹GP!¿.Í@ÿЋEÄ…Àtƒøt ëÇEäëÇEäëH‹P!¿AÍ@ÿÐH‹‹Z!ƒàH…Àt&H‹ !‹EìH˜HÐH‹mZ!‰Ñƒáº(ʈëH‹æ!‹EìH˜HÐÆH‹Ô!‹EìH˜Hж¶ÐH‹/Z!ЉEèëH‹‰!‹UèHcÒHƒêHÐƃmè‹EèHcÐH‹Z!H9ÂwÓH‹„!‹EìH˜Hж¶ÐH‹ßY!HÐH‰ÕY!H‹N!‹UìHcÒHÒHÂH‹»Y!f‰‹EäHcÐH‹«Y!HÐH‰¡Y!¶ºY!ƒÀˆ±Y!‹[ !…Àta¶ Y!¶ÀƒÀƒø~O¸XÍ@H‰Ç¸è£ûÿÿ¸ˆÍ@º¾H‰Ç¸è‡ûÿÿ¸§Í@¾H‰Ç¸èpûÿÿ¿èÈH‹Y!f‰>Y!‹ö !HcÐH‹Y!H9ÂHC‰ß !ÇEèë'H‹S!H‹ äX!‹UèHcÒH‰ËH)ÓH‰ÚHÐƃEè‹EÄH˜·„`a˜;Eè}ÆH‹!H‹ ªX!‹UäHcÒH‰ËH)ÓH‰ÚHÐÆH‹ŽX!H=ÿv=¸ÈÍ@H‰Ç¸è´úÿÿH‹mX!‰Â¸øÍ@‰ÖH‰Ç¸è—úÿÿH‹ÐM!¿Î@ÿЋEäHcÐH‹¼!‹MìHcÉHÉHÈ·H¿ÀH ka¾H‰ÇèvúÿÿH‹!‹UìHcÒHÒHзH¿ÀH kaH‰P!H‹P!‹U숋EÄ…Àtzƒø…"H‹L!‹UìHcÒHÒHзH¿ÀH ka¶PƒâüƒÊˆPH‹!‹UìHcÒHÒHзH¿ÀH ka¶PƒâƒˆPÆÕS!H‹6T!HƒÀÆé±H‹Û!‹UìHcÒHÒHзH¿ÀH ka¶PƒâüˆPH‹±!‹UìHcÒHÒHзH¿ÀH ka¶PƒâƒƒÊ$ˆPÆ!H‹}!‹UìHcÒHÒHзH¿ÀH kaÆ@H‹Y!‹UìHcÒHÒHзH¿ÀH kaÆ@‹Eì‰ÇèŒûÿÿH‹EØH‰ÆN!‹EìHƒÄ8[]ÃUH‰å¾ ka¸ºH‰÷H‰ÑóH«HÇuV!H‹nV!f‰V!莋L!ºƒøL‰;!‹5!ºƒøL‰$!HÇ™R!aHÇ–R!`ga¿ èdH‰ÍR!¿èŒdH‰ÄR!¿ è{dH‰‹R!¿èjdH‰‚R!¿ èYdH‰ C!H‹C!H‰+I!¿è:dH‰òB!H‹ëB!H‰ÄY!¿ èdH‰‹A!¿è dH‰‚A!¿ èùcH‰ùG!¿èècH‰ðG!¿è×cH‰—H!¿èÆcH‰ŽH!H‹/A!HƒÀ ÆH‹)A!HƒÀÆÇ°G! ǪG!‹ð!ºƒøB‰ß!‹Ù!ƒà…Àt*‹Ì!‰ÂÁúÁêЃà)к)‹°!Љ¨!H‹QQ!HƒÀÆH‹cQ!HƒÀÆH‹H!I‰ÁA¸a¹°aº ¾ ¿è»“‹9!…Àtt‹?!…Àt ¿èõ÷ÿÿ¸Î@H‰Ç¸èƒöÿÿ¿8Î@è)öÿÿ¸^Î@H‰Ç¸ègöÿÿ¿tÎ@è öÿÿ¿˜Î@èöÿÿ¿ÐÎ@èùõÿÿ¿Ï@èïõÿÿ¿è—¿莮è¼~¿(èebH‰ÝS!¿ èTbH‰¤,!‹®!H˜H‰Çè=bH‰Q!H‹†Q!H‰gY!葳èiøÿÿè¯!]ÃUH‰å‰}ü‰uø¶S!¶À;EüžÀ¶À]ÃUH‰åH‰}øH‹Eø‹…À”À¶À]ÃUH‰åH‰}øH‹EøǸ]ÃUH‰åH‰}øH‹EøÇ]ÃUH‰åHƒìH‰}øH‰uðHƒ}ðu H‹EøÇëH‹€H!¿@Ï@ÿÐÉÃUH‰åSHƒìH‰}èH‰uàH‹ÿJ!¶¶ÀƒÀƒø?~H‹JH!¿xÏ@ÿÐH‹E苃à…ÀuAH‹EàH‰ÇèlÿÿÿH‹Eè‹H‹½J!¶¶ÀƒÀ¾‰ó‰ÁÓã‰Ø ÂH‹E艸é‹H‹Eè‹H‹ˆJ!¶¶ÀƒÀ¾‰ó‰ÁÓã‰ØƒÈƒøÿ•À¶À!Ð…ÀtH‹EàH‰Çèöþÿÿ¸ëCH‹E苉ƒâþH‹Eè‰H‹Eè‹H‹/J!¶¶ÀƒÀ¾‰ó‰ÁÓã‰Ø÷Ð!ÂH‹E艸HƒÄ[]ÃUH‰åH‰}øH‹Eø‹ƒàþ…ÀtH‹Eø‹‰ÂƒÊH‹Eø‰]ÃUH‰åHìàH‰µXÿÿÿH‰•`ÿÿÿH‰hÿÿÿL‰…pÿÿÿL‰xÿÿÿ„Àt )E€)M)U )]°)eÀ)mÐ)uà)}ðH‰½(ÿÿÿÇ…8ÿÿÿÇ…<ÿÿÿ0HEH‰…@ÿÿÿH…PÿÿÿH‰…HÿÿÿH•8ÿÿÿH‹…(ÿÿÿH‰ÖH‰Çè,ôÿÿ¸ÉÃUH‰åHìàH‰µXÿÿÿH‰•`ÿÿÿH‰hÿÿÿL‰…pÿÿÿL‰xÿÿÿ„Àt )E€)M)U )]°)eÀ)mÐ)uà)}ðH‰½(ÿÿÿ‹v!…ÀtMÇ…8ÿÿÿÇ…<ÿÿÿ0HEH‰…@ÿÿÿH…PÿÿÿH‰…HÿÿÿH•8ÿÿÿH‹…(ÿÿÿH‰ÖH‰Çè|óÿÿ¸ë¸ÉÃUH‰åHƒì‰}ü‹!…Àt ¿©Ï@è/òÿÿƒ}üuÇEü¿è¹‹Eü‰Çè¾óÿÿUH‰åHƒì0H‰}ØÇEüHƒ}Øt/H‹EØHÇEÐÿÿÿÿH‰Â¸H‹MÐH‰×ò®H‰ÈH÷ÐHƒèH=ÿv H‹EØéí¾`a¸ºH‰÷H‰ÑóH«¾`$a¸ºH‰÷H‰ÑóH«H‹EØ‹UüHcÒHÁâ HÂ`aH‰ÆH‰×èLñÿÿéLH‹EðÆHƒEð¸`a‹UüHcÒHÁâ H¸+EüH˜HÁà H`aH‰ÖH‰Çè ñÿÿH‹EðH‰EèëHƒEèH‹Eè¶<}t H‹E趄ÀuåH‹Eè¶<}t H‹EØé"H‹EèÆHƒEèÇEøés‹EøH˜HÁàHPaH‹H‹EðH‰ÖH‰Çèxñÿÿ…À…FH‹EðHÇEÐÿÿÿÿH‰Â¸H‹MÐH‰×ò®H‰ÈH÷ÐHpÿ‹EøH˜HÁàHPaH‹HÇEÐÿÿÿÿH‰Â¸H‹MÐH‰×ò®H‰ÈH÷ÐHƒèH9Æ…á¸+EüH˜HÁà H`aHÇEÐÿÿÿÿH‰Â¸H‹MÐH‰×ò®H‰ÈH÷ÐHpÿ‹EøH˜HÁàHPaH‹@HÇEÐÿÿÿÿH‰Â¸H‹MÐH‰×ò®H‰ÈH÷ÐHƒèHÆH‹EèHÇEÐÿÿÿÿH‰Â¸H‹MÐH‰×ò®H‰ÈH÷ÐHƒèHðH=ÿv H‹EØéÑ‹EøH˜HÁàHPaH‹@º+UüHcÒHÁâ HÂ`aH‰ÆH‰×èüðÿÿëƒEø‹EøH˜HÁàHPaH‹H…À…rþÿÿH‹Eèº+UüHcÒHÁâ HÂ`aH‰ÆH‰×è¶ðÿÿ¸+Eü‰Eü‹EüH˜HÁà H`a¾»Ï@H‰ÇèÏðÿÿH‰EðHƒ}ð…‰ýÿÿ‹EüH˜HÁà H_$aÆ‹EüH˜HÁà H`aÉÃUH‰åHƒì ‰}ì‰uèH‹à8!‹UìHcÒHÁâHÐH‹‹UèHcÒHÁâHÐH‹H‰Eðé…¸ÃÏ@H‰Ç¸èÍîÿÿH‹EðH‹@H‰Çè_üÿÿH‰Eøë5H‹Eø¶< u¸ÆÏ@H‰Ç¸èšîÿÿëH‹Eø¶¾À‰ÇèçíÿÿHƒEøHƒ}øt H‹Eø¶„Àu¹¿ èÆíÿÿH‹EðH‹@0H‰EðHƒ}ð…pÿÿÿÉÃUH‰å‰}ü‰uø‹EüH˜H‹Å@a‹@;Eø'‹EüH˜H‹Å@a‹@ ;Eø|‹EüH˜H‹Å@aH‹ë¸Í@]ÃUH‰åSHƒì‹9!…À•ÂƒÀ‰+!„Ò…“H‹Œü ¸ÐÏ@H‰ÖH‰Ç¸è¿íÿÿ‹Õù …Àˆé¶ŠK!¶Ð‹½ù 9 ¿èõúÿÿ‹©ù f‰EîH‹Âù H¿UîHÒHзH¿ÀH kaH‰EàH‹Eà¶@ƒà¶ÀH˜H‹ Åpa¿UîH‹5ûû ¸òÏ@H‰Ç¸è1íÿÿÇEè雋EèH˜HÁàH a‹H‹Eà¶@ƒà¶À9Âut‹EèH˜HÁàH aH‹PH‹Eà¶@Àèƒà¶ÀHÀHз¿ØH‹Eà¶@Àèƒà¶ÐH‹Eà¶@ƒà¶À‰Ö‰Çè]þÿÿH‰Á¸Ð@‰ÚH‰ÎH‰Ç¸èìÿÿë ƒEè‹EèH˜HÁàH aH‹@H…À…IÿÿÿH‹Eà¶@Àèƒà¶Ð¸ Ð@‰ÖH‰Ç¸èIìÿÿH‹Eà¶@ƒà¶ÀH˜H‹ÅWaH‹Eà¶@Àèƒà¶ÀHж„Àu¸Ð@H‰Ç¸èìÿÿ¿ èZëÿÿH‹Eà¶@Àèƒà¶ÐH‹Eà¶@ƒà¶À‰Ö‰Çèµüÿÿ¿è*ùÿÿ¶¡I!¶Ð¸/Ð@‰ÖH‰Ç¸èªëÿÿH‹[ú H…Ày HÇKú fÇEîé¼H‹Á÷ H¿UîHÒHзH¿ÀH kaH‰EàH‹Eà¶@ƒà¶ÀH˜H‹ Åpa¿UîH‹5úù ¸òÏ@H‰Ç¸è0ëÿÿÇEè雋EèH˜HÁàH a‹H‹Eà¶@ƒà¶À9Âut‹EèH˜HÁàH aH‹PH‹Eà¶@Àèƒà¶ÀHÀHз¿ØH‹Eà¶@Àèƒà¶ÐH‹Eà¶@ƒà¶À‰Ö‰Çè\üÿÿH‰Á¸Ð@‰ÚH‰ÎH‰Ç¸èêÿÿë ƒEè‹EèH˜HÁàH aH‹@H…À…IÿÿÿH‹Eà¶@Àèƒà¶Ð¸ Ð@‰ÖH‰Ç¸èHêÿÿH‹Eà¶@ƒà¶ÀH˜H‹ÅWaH‹Eà¶@Àèƒà¶ÀHж„Àu¸Ð@H‰Ç¸èêÿÿ¿ èYéÿÿH‹Eà¶@Àèƒà¶ÐH‹Eà¶@ƒà¶À‰Ö‰Çè´úÿÿfƒEî¿UG!¶À9ÂŒ.þÿÿ裧fÇEîëCH‹âõ H¿UîHÒHзH¿ÀH kaH‰EàH‹Eà¶@ƒà¶Ð¿Eî‰Ö‰Çèm§fƒEî¿Uî¶;G!¶À9Â|«¿è¬öÿÿëHƒÄ[]ÃUH‰åHì@dH‹%(H‰Eø1ÀH‹G:!H…ÀtWº?Ð@H‹6:!H‰ÖH‰ÇèêÿÿH‰…ÈûÿÿHƒ½Èûÿÿ…KH‹:!¸AÐ@H‰ÖH‰Ç¸èÒèÿÿ¿è*öÿÿé Ç…ØûÿÿÇ…ÜûÿÿHÇõ Í@H‹½ì H‰ÂH…àýÿÿH‰ÖH‰Çèèÿÿ‹÷ …À„zH‹=Óô ‹ ñö ¾VÐ@H•àýÿÿH…àûÿÿI‰øH‰Ç¸èšéÿÿº?Ð@H…àûÿÿH‰ÖH‰Çè3éÿÿH‰…ÈûÿÿHƒ½ÈûÿÿtBƒ…Üûÿÿ‹…ö ƒødu!¸^Ð@H•àûÿÿ‹Üûÿÿ‰ÎH‰Ç¸èïçÿÿH‹…ÈûÿÿH‰Çè°çÿÿH…àýÿÿ¾.H‰Çè¼çÿÿH‰…ÐûÿÿHƒ½Ðûÿÿ„H‹…ÐûÿÿÆH‹=ô ‹ $ö ¾VÐ@H•àýÿÿH…àûÿÿI‰øH‰Ç¸èÍèÿÿH‹…ÐûÿÿÆ.º?Ð@H…àûÿÿH‰ÖH‰Çè\èÿÿH‰…ÈûÿÿHƒ½Èûÿÿ„¦ƒ…Üûÿÿ‹ªõ ƒødu!¸^Ð@H•àûÿÿ‹Üûÿÿ‰ÎH‰Ç¸èçÿÿH‹…ÈûÿÿH‰ÇèÕæÿÿé_H‹ Yó ¾kÐ@H•àýÿÿH…àûÿÿH‰Ç¸è)èÿÿº?Ð@H…àûÿÿH‰ÖH‰ÇèÂçÿÿH‰…ÈûÿÿHƒ½ÈûÿÿtBƒ…Üûÿÿ‹õ ƒødu!¸^Ð@H•àûÿÿ‹Üûÿÿ‰ÎH‰Ç¸è~æÿÿH‹…ÈûÿÿH‰Çè?æÿÿH…àýÿÿ¾.H‰ÇèKæÿÿH‰…ÐûÿÿHƒ½Ðûÿÿ„¥H‹…ÐûÿÿÆH‹ •ò ¾kÐ@H•àýÿÿH…àûÿÿH‰Ç¸èeçÿÿH‹…ÐûÿÿÆ.º?Ð@H…àûÿÿH‰ÖH‰ÇèôæÿÿH‰…ÈûÿÿHƒ½ÈûÿÿtBƒ…Üûÿÿ‹Fô ƒødu!¸^Ð@H•àûÿÿ‹Üûÿÿ‰ÎH‰Ç¸è°åÿÿH‹…ÈûÿÿH‰ÇèqåÿÿHEàH‰öñ ‹•Øûÿÿƒ…Øûÿÿ¹qÐ@H‹Ýñ H‰ÎH‰Ç¸è½æÿÿƒ½ØûÿÿŽØüÿÿƒ½ÜûÿÿtH‹Áó ƒødt)¸€Ð@‹•Üûÿÿ‰ÖH‰Ç¸è2åÿÿǘó dé`üÿÿ¿¢Ð@èÉäÿÿ¿èoæÿÿÇ…ØûÿÿH‹é H‰ÂH…àýÿÿH‰ÖH‰ÇèyäÿÿHÇ>ñ Í@‹\ó …À„ìH‹=)ñ ‹ Gó ¾VÐ@H•àýÿÿH…àûÿÿI‰øH‰Ç¸èðåÿÿº?Ð@H…àûÿÿH‰ÖH‰Çè‰åÿÿH‰…ÈûÿÿHƒ½Èûÿÿ…]H…àýÿÿ¾.H‰ÇèPäÿÿH‰…ÐûÿÿHƒ½Ðûÿÿ„4H‹…ÐûÿÿÆH‹=šð ‹ ¸ò ¾VÐ@H•àýÿÿH…àûÿÿI‰øH‰Ç¸èaåÿÿH‹…ÐûÿÿÆ.º?Ð@H…àûÿÿH‰ÖH‰ÇèðäÿÿH‰…ÈûÿÿéÍH‹ =ð ¾kÐ@H•àýÿÿH…àûÿÿH‰Ç¸è åÿÿº?Ð@H…àûÿÿH‰ÖH‰Çè¦äÿÿH‰…ÈûÿÿHƒ½Èûÿÿu~H…àýÿÿ¾.H‰ÇèqãÿÿH‰…ÐûÿÿHƒ½ÐûÿÿtYH‹…ÐûÿÿÆH‹ ¿ï ¾kÐ@H•àýÿÿH…àûÿÿH‰Ç¸èäÿÿH‹…ÐûÿÿÆ.º?Ð@H…àûÿÿH‰ÖH‰ÇèäÿÿH‰…ÈûÿÿHƒ½Èûÿÿukƒ½Øûÿÿ9HEàH‰Yï ‹•Øûÿÿƒ…Øûÿÿ¹qÐ@H‹@ï H‰ÎH‰Ç¸è äÿÿéíýÿÿ¸ÀÐ@H•àûÿÿH‰ÖH‰Ç¸è¯âÿÿ¿èðÿÿëH‹…ÈûÿÿH‹UødH3%(tègâÿÿÉÃUH‰åSHƒìHÇEèÿÿÿÿè0ùÿÿH‰EÀé× H‹ñ Hƒøÿu ¿ßÐ@èâÿÿH‹ñ H…Àˆ¯ ¶@!¶Ð‹Eà9Â}3‹Uà¸øÐ@‰ÖH‰Ç¸èâÿÿ‹Uä¸Ñ@‰ÖH‰Ç¸èâÿÿé¤ ‹Eàf‰EîH‹.î H¿UîHÒHзH¿ÀH kaH‰EÈH‹£+!H‹Eȶ@ƒà¶ÀHÁàHÐH‹H‹Eȶ@Àèƒà¶ÀHÁàHÐH‹H‰E¸ëH‹E¸‹P$‹Eä¶À9ÂtH‹E¸H‹@0H‰E¸Hƒ}¸uÜëHƒ}¸…ÃÇEàé’H‹%+!H‹Eȶ@ƒà¶ÀHÁàHÐH‹‹UàHcÒHÁâHÐH‹H‰E¸Hƒ}¸tOH‹E¸‹P$‹Eä¶À9Âu>‹Uà¸(Ñ@‰ÖH‰Ç¸èòàÿÿ‹Eà‰ÂƒâH‹Eȃâ •¶Pƒâƒ ʈPé.‹EàƒÀ‰EàH‹Eȶ@ƒà¶ÀH˜‹… ]a‹Eà9ÂLÿÿÿH‹Eȶ@Àèƒà¶ÈH‹Eȶ@ƒà¶Ð¿uî¸@Ñ@H‰Ç¸èkàÿÿ‹Uä¸gÑ@‰ÖH‰Ç¸èTàÿÿ¿€Ñ@èúßÿÿH‹Eȶ@ƒà¶À…ÀˆØH‹Eȶ@ƒà¶ÀƒøÁH‹î)!H‹Eȶ@ƒà¶ÀHÁàHÐH‹H‹Eȶ@Àèƒà¶ÀHÁàHÐH‹H‰E¸ë4H‹E¸H‹HH‹E¸‹P(H‹E¸‹p$¸³Ñ@H‰Ç¸èµßÿÿH‹E¸H‹@0H‰E¸Hƒ}¸uÅéAH‹E¸H‹@H‰Çè/íÿÿH‰EЋûí …ÀtƸ.!H‹Eȶ@ƒà¶ÀH˜H‹ÅpaH‰EØH‹•ë H¿UîHÒHзH¿ÀH kaH‰5!H‹O0!H‹H0!¶R ƒÊˆP ¿UîH‹E¸‰ÖH‰Çè¯ „ÀuH‹ë …Àx¿Uî‹ë 9Â…,‹Ví …À„…¿ÐÑ@è„Þÿÿ¿Ò@èzÞÿÿ¿@Ò@èpÞÿÿ‹Öê …Àx¿Uî‹Èê 9Â…ç‹í …À„¿UîH‹5Cí ¸tÒ@H‹MØH‰Ç¸èuÞÿÿÇEàé ‹EàH˜HÁàH a‹H‹Eȶ@ƒà¶À9Âut‹EàH˜HÁàH aH‹PH‹Eȶ@Àèƒà¶ÀHÀHз¿ØH‹Eȶ@Àèƒà¶ÐH‹Eȶ@ƒà¶À‰Ö‰Çè¡ïÿÿH‰Á¸‰Ò@‰ÚH‰ÎH‰Ç¸èÔÝÿÿë%‹EàƒÀ‰Eà‹EàH˜HÁàH aH‹@H…À…DÿÿÿHƒ}ÐtH‹UÐëº"Í@H‹E¸‹H(‹}äH‹Eȶ@Àèƒà¶ð¸˜Ò@I‰Ð‰úH‰Ç¸èiÝÿÿèV›ÇEàë?H‹”é ‹UàHcÒHÒHзH¿ÀH ka¶@ƒà¶Ð‹Eà‰Ö‰Çè'›‹EàƒÀ‰Eà¶õ:!¶Ð‹Eà9°éMH‹Eȶ@ƒà¶ÀH˜‹…ˆaƒø…H‹Eȶ@Àèƒà¶À;Eè„ÔÇEàër‹EàH˜HÁàH a‹H‹Eȶ@ƒà¶À9ÂuF‹EàH˜HÁàH aH‹PH‹Eȶ@Àèƒà¶ÀHÀHз¿Ð¸·Ò@‰ÖH‰Ç¸è\Üÿÿë%‹EàƒÀ‰Eà‹EàH˜HÁàH aH‹@H…À…rÿÿÿ‹EàH˜HÁàH aH‹@H…Àu%H‹Eȶ@Àèƒà¶Ð¸ÃÒ@‰ÖH‰Ç¸èøÛÿÿH‹Eȶ@Àèƒà¶À‰EèëH‹Eȶ@ƒà¶ÀH˜‹…ˆa…À„ ‹Qê …À…û‹+ê …À„”H‹Xê ¸ÏÒ@H‰ÖH‰Ç¸è‹ÛÿÿÇEàë¸ÃÏ@H‰Ç¸èpÛÿÿ‹EàƒÀ‰Eà¿Uî‹Eà9ÂÚ¿Uî¸ÕÒ@H‹MØH‰ÎH‰Ç¸è?ÛÿÿHƒ}ÐtH‹EÐë¸"Í@ºÝÒ@H‰ÆH‰×¸èÛÿÿéZ‹•é …À…L¸€\a¶„À„¿UîH‹5¢é ¸ãÒ@H‹MØH‰Ç¸èÔÚÿÿÇEàé ‹EàH˜HÁàH a‹H‹Eȶ@ƒà¶À9Âut‹EàH˜HÁàH aH‹PH‹Eȶ@Àèƒà¶ÀHÀHз¿ØH‹Eȶ@Àèƒà¶ÐH‹Eȶ@ƒà¶À‰Ö‰ÇèìÿÿH‰Á¸‰Ò@‰ÚH‰ÎH‰Ç¸è3Úÿÿë%‹EàƒÀ‰Eà‹EàH˜HÁàH aH‹@H…À…DÿÿÿH‹Eȶ@Àèƒà¶È¸÷Ò@º€\a‰ÎH‰Ç¸èâÙÿÿ¿UîH‹5è ¸ãÒ@H‹MØH‰Ç¸èÁÙÿÿÇEàé ‹EàH˜HÁàH a‹H‹Eȶ@ƒà¶À9Âut‹EàH˜HÁàH aH‹PH‹Eȶ@Àèƒà¶ÀHÀHз¿ØH‹Eȶ@Àèƒà¶ÐH‹Eȶ@ƒà¶À‰Ö‰ÇèíêÿÿH‰Á¸‰Ò@‰ÚH‰ÎH‰Ç¸è Ùÿÿë%‹EàƒÀ‰Eà‹EàH˜HÁàH aH‹@H…À…DÿÿÿHƒ}ÐtH‹UÐëº"Í@H‹Eȶ@Àèƒà¶È¸Ó@‰ÎH‰Ç¸èÂØÿÿëëëH‹E¸‹@ ‰ÂƒâH‹Eȃâ •¶Pƒâƒ ʈPë¾!Ó@HMäHUàH‹EÀI‰ÈH‰ÑºøaH‰Ç¸èØÿÿƒø„÷õÿÿëëèSêÿÿHƒÄH[]ÃUH‰å‰}ìÇEüëIH‹uä ‹UüHcÒHÒHзH¿ÀH kaH‰EðH‹Eð¶@ƒà¶Ð‹Eì9Âu H‹Eð¶¶ÀëƒEü¶Ì5!¶À;Eü¨¸ÿÿÿÿ]ÃUH‰åHì dH‹%(H‰Eø1ÀÇ…ìýÿÿA¶tæ <u¶hæ „Àu ìýÿÿ€H‹²Û ¾/H‰Çè•×ÿÿH‰…àýÿÿHƒ½àýÿÿuH‹Û H‰…àýÿÿëHƒ…àýÿÿH‹•àýÿÿH…ðýÿÿH‰ÖH‰ÇèÓÖÿÿ¶ýå „ÀuK‹Êå …ÀŸÂƒÀ‰¼å „Òt3H‹5yã ‹«å Hÿ¸VÐ@H•ðýÿÿI‰ðH‰Æ¿ aa¸è?Øÿÿë%H‹ Fã ¸kÐ@H•ðýÿÿH‰Æ¿ aa¸èØÿÿH‹ä ‹…ìýÿÿ‰Æ¿ aa¸èŠ×ÿÿ‰…èýÿÿƒ½èýÿÿ‰ÑH…ðýÿÿ¾.H‰ÇèsÖÿÿH‰…àýÿÿHƒ½àýÿÿ„¨H‹…àýÿÿÆ¶å „Àu@‹ëä ƒè…À~3H‹5¥â ‹×ä Hÿ¸VÐ@H•ðýÿÿI‰ðH‰Æ¿ aa¸èk×ÿÿë%H‹ râ ¸kÐ@H•ðýÿÿH‰Æ¿ aa¸èD×ÿÿH‹…àýÿÿÆ.H‹3ã ‹…ìýÿÿ‰Æ¿ aa¸è¬Öÿÿ‰…èýÿÿƒ½èýÿÿy#¸,Ó@¾ aaH‰Ç¸è¦Õÿÿ¿CÓ@è¬Öÿÿë¸IÓ@¾ aaH‰Ç¸èƒÕÿÿ‹…èýÿÿH‹UødH3%(tèIÕÿÿÉÃUH‰å¿ paèIÖÿÿH‰b/!]ÃUH‰åòÄ8!¸XÓ@H‰Ç¸è2Õÿÿòª8!f.r·—À„Àtjòãâ ò ‹8!ò^Á¸€Ó@H‰Ç¸èõÔÿÿ‹_ã …Àt:ò c8!ò«â ò³â òXÂf(Ñò^Ðf(¸ Ó@H‰Ç¸è±Ôÿÿ]ÃUH‰åHƒì@‰}ÌHEÐH‰ÇèˆÕÿÿH‰EøH‹.!H‹UøH‰ÑH)ÁH‰ÈòH*ÀòEÀ¿èŒÕÿÿòH*ÀòMÀò^Èf(ÁòÒ7!‹Ìâ …Àu$ò À7!fWÀf.Á—À„Àu ƒ}ÌtèÖþÿÿëÉÃUH‰åHƒìHǾá H‹·á H‰¸â H‹.!H‰%!ÇEøéH‹à ‹UøHcÒHÒHзH¿ÀH kaH‰EðH‹Û$!¶@ ¶Àƒà…ÀuMH‹Eð¶@ƒà¶ÀH˜H‹ÅÀgaH‹Eð¶@Àèƒà¶ÀHж„ÀtH‹“$!H‹Œ$!¶R ƒÊˆP ë‹EøƒÀ‰Eø¶01!¶Ð‹Eø9Â\ÿÿÿH‹cß H‹\ß HƒÀƶˆ‹Šá …ÀuÇEøH‹8ß ‹EøH˜HÐÆ‹á …Àu8ÇEüÇEøëH‹ ß ‹EøHcÐHÊƃÀ‰Eøƒ}üžÀƒEü„ÀuØ‹Má …Àt6‹á …Àt,H‹È#!¶@ ¶Àƒà…ÀtÆu0!¶l0!ƒÀˆf0!HEøH‰@à ‹òà …ÀtèäïÿÿèýüÿÿèÉÃUH‰åSHƒì(H‰}؉ðf‰EÔÆEïH‹(!¶@Àèƒà¶À‰EèH‹EØ‹@(ƒø w ‰ÀH‹ÅØÓ@ÿàH‹P%!¿ÅÓ@ÿиéÆEïéH‹#!¶@ ¶Àƒà„Àt ¸éôÆEïéçH‹÷+!HƒÀÆH‹Ù"!HP8H‹Ž'!¶@¶À‰B0H‹5}'!H‹v'!¶@¶ÀHºVUUU‰È÷ê‰ÈÁø)‰ÐÀЉÊ)‰ЈFÆEïé}H‹+!HƒÀÆH‹o"!HP8H‹$'!¶@¶À‰B0H‹'!H‹ '!¶RÒˆPÆEïé3H‹C+!HƒÀÆH‹%"!HP8H‹Ú&!¶@¶À‰B0H‹É&!H‹Â&!¶RÒˆPÆEïééH‹ù*!HƒÀÆH‹Û!!HX8¿è"KH‰C0H‹Â!!HƒÀ8H‹@0H‹s&!¶R¶Ò‰H‹c&!H‹\&!¶RƒêˆP‹ ß …Àt¸ë~‹ÛÞ …Àu H‹0&!Æ@ÆEïë_H‹o*!HƒÀ Æ¿EԉƿèèK…Àu¸ë:ÆEïë0H‹0!!¶@ ¶Àƒà…ÀuH‹!!¶@ „Ày¸ë ÆEï¶EïHƒÄ([]ÃUH‰åHƒì0‰}܉uØH‹§%!H‰EèÇEô‹EØ;EÜuH‹í"!¿(Ô@ÿЃ}Øx¶y-!¶À;EØ ¸éÐH‹ÀÛ ‹UØHcÒHÒHзH¿ÀH kaH‰@%!ÇöÝ H‹/%!¶@Àèƒà¶À‰EøH‹%!¶@ƒàˆEÿH‹ÿ!¶UÿHÁâHÐH‹‹UøHcÒHÁâHÐH‹H‰Eàë-‹EØ¿ÐH‹Eà‰ÖH‰Çè’üÿÿ„Àt ÇEôëH‹EàH‹@0H‰EàHƒ}àuÌÇeÝ H‹EèH‰š$!‹EôÉÃUH‰åHƒì@HEÐH‰Çè‘ÏÿÿH‰EðH‹¦(!H‹UðH‰ÑH)ÁH‰ÈòH*ÀòEÈ¿è•ÏÿÿòH*ÀòMÈò^Èf(ÁòEøòEøf.¡°—À„Àt6¸DÔ@òEøH‰Ç¸è3ÎÿÿòûÛ ò^Eø¸NÔ@H‰Ç¸èÎÿÿ¿ èjÍÿÿòr(!f.R°—À„ÀtCò [(!òEøf.Á—À„Àt+òC(!ò +°ò^Á¸XÔ@H‰Ç¸èµÍÿÿèËÉÃUH‰åòrÛ H‹KÛ ¸~Ô@H‰ÖH‰Ç¸è†Íÿÿò NÛ òVÛ òXÁ¸™Ô@H‰Ç¸è`ÍÿÿòÛ ò ¸¯ò^Á¸­Ô@H‰Ç¸è:Íÿÿè€þÿÿH‹®Ú H‰ÇèæÍÿÿ]ÃUH‰å‰}üƒ}üx$}üþH‹GÙ ‹UüHcÒHÒHзf…Àu H‹Œ(!ë H‹#Ù ‹UüHcÒHÒHзH¿ÀH ka]ÃUH‰å‰}üƒ}üx$}üþH‹óØ ‹UüHcÒHÒHзf…Àu H‹0!ë H‹ÏØ ‹UüHcÒHÒHзH¿ÀH ka]ÃUH‰åHƒì‰}üƒ}ütH‹$!¿¼Ô@ÿÐÉÃUH‰åSHƒì8fÇEè¶*!¶Àƒèf‰EäfÇEæH‹>!H‹7!¶R ƒâˆP H‹¾Ú H‹'Ð H9Â|v¶³Ú „ÀuÆ¨Ú ¿ÐÔ@èŽËÿÿ¶žÚ „ÀtH‹œ!¿òÔ@ÿÐò Ù ò%®òXÁò‰Ù H‹Â!HPÈH‹·!Hƒè8¶@ ƒÈˆB éºH‹!H‹–!Hƒê8H‹RH‰P·Ë× fƒøÿ…ì¶4)!¶Àƒà„À„ŠH‹õÙ H‹FÚ H9Â~w‹ËØ ƒÀ‰EÜH‹Þ(!‹EÜH˜H)‹EÜH˜Hˆ ka‹EÜH˜H@caH‰ÎH‰ÇèTËÿÿ…Àu6‹zÙ …Àt ¶Ã(!<u!H‹äÙ H‰ýÖ H‹–!¿Õ@ÿÐéðH‹Ó!¶@ ¶Àƒà…À…4H‹Z(!‰Æ¿ kaè/Sf‰Eâfƒ}â”À¶Àf‰Eèfƒ}âtfƒ}âu¸ë¸f‰Eêfƒ}âu]H‹o!¶@ ¶Àƒà…ÀuH‹Z!Hƒè8¶@ ¶Àƒà…Àt/‹ŠØ …Àt%‹¨Ø …ÀuH‹ÅØ H‹Ù H9Â~fÇEâë_fƒ}â…†‹PØ …Àt|¶¿'!¶Àƒà„Àtk‹]Ø …Àt¶¦'!<tfÇEâëNò¦× ò ¬ò\Áò’× H‹{!H…ÀtH‹o!‹@ ‰ÀH‰«Õ H‹D!¿Õ@ÿÐéžfƒ}ât!ò 9× òÁ«òXÁò%× évfƒ}ê…¶ò ýÖ ò•«òXÁòéÖ òáÖ ò iÖ ò^Áf.u«sòH,Àëò d«ò\ÁòH,ÀHº€H1ÐH‰EÈH‹ é H9EÈtFèûÿÿH‹EÈH‰õè ‹ÏÔ ƒÀºH‰Ó‰ÁHÓãH‰ØòH*Àò _Ö f.È—À„Àtè‡H‹˜!H‹Y!H‰PH‹× H‹Ö H9Â~H‹ × H‰üÕ H‹e!H‹^!¶R ƒâüˆP ÆEíH‹I!H‹B!¶R ƒâ‡ˆP ‹¢Ö …À„·kÔ fƒøÿ…õH‹!¶@ ¶Àƒà…À…ܶ»%!¶Àƒà…Àus‹1Ö …À„½H‹Ú!¶@ ¶Àƒà…À„¤¶ƒ%!ƒÈˆz%!¶s%!¶À‰Áƒá¶b%!PHcÁˆ#kaH‹!H‹ˆ!¶R ƒÊˆP ëX¶7%!¶ÀƒàH˜¶€#ka<u>¶%!ƒàýˆ%!¶ %!¶ÀƒàH˜Æ€#kaH‹5!H‹.!¶R ƒÊˆP ·Eäf‰EâékH‹0Ó H¿UâHÒHзH¿ÀH kaH‰±!H‹ª!¶@Àèƒà¶À‰EÔH‹“!¶@ƒàˆEîH‹Â!H‹»!¶R ƒâþˆP H‹ª!H‹£!¶R ƒâ¿ˆP ‹Õ …À„¤·ÌÒ fƒøÿ…“H‹s!¶@ ¶Àƒà …Àu~¶ $!¶Àƒà…Àtm¶$!¶ÀƒàH˜¶€#ka¶À¿UâƒÂ9ÐuI¶ë#!¶À‰Áƒá¶Ü#!¶ÀƒàH˜¶€#kaPÿHcÁˆ#kaH‹ø!H‹ñ!¶R ƒÊ`ˆP H‹à!HP8·EâˆBH‹Î!HP8‹EÔ‰H‹v!¶UîHÁâHÐH‹‹UÔHcÒHÁâHÐH‹H‰EÀé H‹!HP8H‹EÀH‰B¿UâH‹EÀ‰ÖH‰ÇèõòÿÿˆEï€}ï„á·¦Ñ fƒøÿuH‹Q!H‹J!¶R ƒÊˆP H‹ÑÓ HƒÀH‰ÆÓ H‹'!HƒÀ8H‰!H‹!·UâˆPH‹!‹UÔ‰H‹û!H‹ô!¶R ƒâùˆP H‹EÀ‹@ …À~'H‹˜!H‹UÀ‹R ƒâƒâ •¶Pƒâƒ ʈP‹úÒ …À„¨ÇEØé‰H‹·Ð ‹UØHcÒHÒHзH¿ÀH ka¶@ƒà¶ÀH˜H‹ÅÀgaH‹ƒÐ ‹MØHcÉHÉHÈ·H¿ÀH ka¶@Àèƒà¶ÀHж„ÀtH‹,!H‹%!¶R ƒÊˆP ëƒEضÎ!!¶À;EØdÿÿÿH‹û!H‹UÀH‰PH‹ì!¶UíˆP H‹Þ!¶UîˆP H‹Ð!‹UÔ‰PH‹Ã!·Uæf‰PH‹´!¶UïˆP H‹¦!Æ@ ·ãÏ fƒøÿuH‹EÀ·˜ƒà…ÀtH‹!H‹x!¶R ƒÊˆP ëH‹e!H‹^!¶R ƒâ÷ˆP ·•Ï fƒøÿu@H‹EÀ·˜ƒà…Àt1·Eâf‰Eæ·Eæf‰Eäò ØÐ òh¥òXÁòÄÐ éÂöÿÿ¶À !¶Àƒèf‰EäfÇEæé¦öÿÿ¶¥ !¶Àƒà„ÀtH‹jÑ H‹»Ñ H9ÂŽùH‹»!¶@ „Àyi¶n !¶À‰ÁƒáH‹!‹@0‰ÂHcÁˆ#kaÆEíH‹„!H‹}!¶R ƒâˆP H‹Ñ HƒèH‰ùÐ H‹Z!Hƒè8H‰O!é H‹C!H‹@H‰EÀH‹4!¶@ ˆEíH‹&!¶@ ˆEîH‹!¶@¶Àf‰EâH‹!‹@‰EÔ¿Eâ‰Çè±ôÿÿH‰®!H‹ç!·@f‰EæH‹Ø!¶@ ˆEïH‹EÀ‹@,ƒøw ‰ÀH‹ÅHÕ@ÿàH‹Ò!¿Õ@ÿÐé€H‹_!H‹˜!‹R0ˆPëkH‹I!H‹‚!‹R0ˆPëUH‹3!H‹l!‹R0ˆPë?H‹!H‹V!H‹R0‹ˆPH‹F!H‹@0¾H‰ÇèD<ë¿Eâ‰Çè²7ëH‹¶Ï HƒèH‰«Ï H‹ !Hƒè8H‰!€}ït6¶EîH˜H‹ÅpgaH‹EÀ‹@ H˜HÐƶEîH˜H‹Åpga‹EÔH˜HÐƶEï:Eíw €}ív €}ït¶EïˆEíH‹b!‹UÔƒâƒâ •¶Pƒâƒ ʈPëH‹EÀH‹@0H‰EÀHƒ}À…ÕúÿÿH‹e!¶@ ¶Àƒà …À„¢H‹L!¶@ ¶Àƒà@…À„‰H‹3!¶@ ¶Àƒà„ÀtK¶à!¶À‰Áƒá¶Ñ!¶ÀƒàH˜¶€#kaPHcÁˆ#kaH‹í!H‹æ!¶R ƒâŸˆP ë)€}ít#H‹Í!H‹Æ!¶R ƒâ¿ˆP ·EäƒÀf‰Eâfƒmâ·Eâf;Eæ‡øÿÿH‹—!¶@ ¶Àƒà …ÀtI¶D!¶À‰Áƒá¶5!¶ÀƒàH˜¶€#kaPHcÁˆ#kaH‹Q!H‹J!¶R ƒâ߈P ‹ªÍ …À„ô€}í…êH‹!!¶@ ¶Àƒà…À…ѶÊ!¶ÀƒàH˜¶€#ka„À„³H‹‚Í HƒÀH‰wÍ H‹Ø!HƒÀ8H‰Í!H‹Æ!H‹¿!¶R ‰ÑH‹²!Hƒê8¶R ƒâƒÊ€ ʈP H‹˜!¶S!¶ÒƒâHcÒ¶’#ka¶Ò‰P0¶6!¶ÀƒàH˜Æ€#kaH‹^!Æ@ ¶!¶Àƒèf‰EäfÇEæéùñÿÿH‹7!¶@ ¶Àƒà…Àt>¶ä!ƒàýˆÛ!¶Ô!¶ÀƒàH˜Æ€#kaH‹ü!H‹õ!¶R ƒâ÷ˆP H‹ä!¶@ ¶Àƒà…Àt>¶‘!ƒÈˆˆ!¶!¶ÀƒàH˜Æ€#kaH‹©!H‹¢!¶R ƒâïˆP €}ít2H‹‹!¶@ ¶Àƒà…À„£H‹r!¶@ ¶Àƒà…À„Š¶!„Àu‹›Ë …À„qèÊ=…À…dH‹;Á HPÿH‹ÀË H9ÂŽIH‹!¶@ ¶Àƒà…ÀtIH‹!¶@ ¶Àƒà…Àu4H‹î !H‹ç !¶R ƒâöˆP ¶–!¶Àƒèf‰EäfÇEæéñÿÿ¶`Ë „Àuk‹øÊ …Àuaè„=…ÀuXH‹4Ë HƒèH‰)Ë H‹Š !Hƒè8H‰ !H‹(!¿'Õ@ÿÐH‹Ë HƒÀH‰÷Ê H‹X !HƒÀ8H‰M !ëu‹Ê …ÀtkH‹: !¶@ ¶Àƒà…ÀtVH‹½Ê HƒèH‰²Ê H‹ !Hƒè8H‰ !H‹±!¿9Õ@ÿÐH‹‹Ê HƒÀH‰€Ê H‹á !HƒÀ8H‰Ö !H‹Ï !¶@ ¶Àƒà…À…â·þÇ fƒøÿumH‹© !H‹@H…Àt]H‹™ !H‹P‹É …Àt@H‹„ !H‹@‹p¶8!¶Àƒà„Àt¸ë¸¶ !¶ÉƒáÓà÷Ð!ð븉B€}ítb¶ø!¶Àƒà…ÀuQ‹–É …Àt#¶Ý!¶Àƒà…Àt6¶Í!<u+èx<ë$‹AÉ …ÀtH‹î !¶@ ¶Àƒà…ÀtèR<H‹lÉ H…Àà÷ÿÿëHƒÄ8[]ÃUH‰åHì@‰½ìûÿÿH‰µàûÿÿ‰•èûÿÿ‰ÜûÿÿL‰…ÐûÿÿdH‹%(H‰Eø1Àƒ½ìûÿÿ…¿¶É „À…°ºˆÕ@H…ðûÿÿH‹ H‰H‹JH‰H‹R‰PH‹…àûÿÿHÇ…ÈûÿÿÿÿÿÿH‰Â¸H‹ÈûÿÿH‰×ò®H‰ÈH÷ÐHƒèH=èv(H‹…àûÿÿH•ðûÿÿHJºèH‰ÆH‰ÏèA¹ÿÿÆEëëH‹…àûÿÿH•ðûÿÿHƒÂH‰ÆH‰×è>¹ÿÿH‹w!H…ðûÿÿH‰ÇÿÒH‹EødH3%(tèg¹ÿÿÉÃUH‰åHƒì ‰}ü‰uø‰Uô‰MðL‰Eèƒ}üx‹Eü;Eø}¸ë¸H‹uè‹Mð‹UôI‰ð¾œÕ@‰Çè™þÿÿ‹EüÉÃUH‰åò!Ç fWÉf.Á—À„Àt0ò âÆ òÚÆ òúÆ ò\¸¸Õ@H‰Ç¸èì¸ÿÿëò²Æ ¸ÛÕ@H‰Ç¸èиÿÿò¨Æ ¸ñÕ@H‰Ç¸趸ÿÿò¦Æ fWÉf.Á—À„Àt(ò gÆ òoÆ òXÁ¸Ö@H‰Ç¸èy¸ÿÿë&ò ?Æ òGÆ òXÁ¸0Ö@H‰Ç¸èQ¸ÿÿò!Æ ¸VÖ@H‰Ç¸è7¸ÿÿòÆ fWÉf.Áz fWÉf.ÁtòÆ ¸jÖ@H‰Ç¸è¸ÿÿòùÅ ¸€Ö@H‰Ç¸èç·ÿÿ]ÃUH‰åSHƒìH¸H‰EÀ¸H‰EȾ¿è;¸ÿÿ¸¢Ö@¾°Ö@H‰Ç¸è¤·ÿÿ‹VÅ …Àu ¿ÖÖ@è@·ÿÿ‹šÅ …Àt ¿øÖ@è,·ÿÿ¿×@è"·ÿÿ¿8×@è·ÿÿ¸a×@H‰Ç¸èV·ÿÿ¶Æ „Àt ¿x×@èñ¶ÿÿë ¿×@èå¶ÿÿ¸’×@H‰Ç¸è#·ÿÿ‹…Å …Àt-‹£Å …Àt¸©×@븬×@º°×@H‰ÆH‰×¸èî¶ÿÿë ¿Æ×@è’¶ÿÿ¸××@H‰Ç¸èжÿÿ¶Å „Àt ¿ì×@èk¶ÿÿë ¿Ø@è_¶ÿÿH‹XÄ ‹ FÅ ¸Ø@‰ÎH‰Ç¸èŽ¶ÿÿ‹DÄ ¸0Ø@‰ÖH‰Ç¸èt¶ÿÿH‹íà H‰Çè%·ÿÿè+ýÿÿ¿ 趵ÿÿòÄ ò >Ä f(Ðò\Ñf(Ê‹ØÄ H˜HƒÀH…ÀxòH*ÀëH‰ÂHÑêƒàH ÂòH*ÂòXÀòYÁòEÐH‹%º HÁàHÅH‰ÑH)ÁH‰ÈH¨H…ÀxòH*ÀëH‰ÂHÑêƒàH ÂòH*ÂòXÀòEØ‹ÖÁ ºH‰Ó‰ÁHÓãH‰ØòH*Àò ˜òYÁòEÀ‹2Ä H˜‹&Ä HcÒHƒÂ H¯ÂH…ÀxòH*ÈëH‰ÂHÑêƒàH ÂòH*Âf(ÈòXÈ‹øà H˜‹ôà HcÒHƒÂ(H¯ÂH…ÀxòH*ÀëH‰ÂHÑêƒàH ÂòH*ÂòXÀòXÁòEàH‹°Â H‰Eèò¤Â ò\EÀò\EàòÊà òMØò\Êò\Áò\EÈòE¸fWÀf.E¸—À„Àt ¸H‰E¸¿@Ø@è`´ÿÿòEÐò —ò^Á¸hØ@H‰Ç¸è´ÿÿ¿˜Ø@è3´ÿÿòE¸ò Þ–ò^Á¸ÀØ@H‰Ç¸è`´ÿÿòEèò\E¸òEèòE¸fWÉf.Á—À„ÀtGòEÐf.E¸—À„Àt*òM¸ò§–òYÁò^EиåØ@H‰Ç¸è´ÿÿë¿ èX³ÿÿë ¿ýØ@蜳ÿÿòE¸fWÉf.Á—À„ÀtkòEÐf.E¸—À„ÀtZòÁ ò ¯Á ò\ÁòM¸f(Ñò^Ðf(Âò *–ò\Á¸Ù@H‰Ç¸脳ÿÿ¸=Ù@¾H‰Ç¸èm³ÿÿ‹‡¿ òEÀò •ò^Á¸XÙ@‰ÖH‰Ç¸èB³ÿÿòEèò\EÀòEèH‹T· òEØò ‡•ò^Á¸ˆÙ@H‰ÖH‰Ç¸è³ÿÿòEèò\EØòEèò ÏÁ òEèò\Áf.F•—À„Àt/ò ¯Á òEèò\Áò &•ò^Á¸¸Ù@H‰Ç¸訲ÿÿò€Á f.•—À„Àt&òiÁ ò é”ò^Á¸àÙ@H‰Ç¸èk²ÿÿò À ò Ôò^Á¸Ú@H‰Ç¸èE²ÿÿ¿ è›±ÿÿ‹í¿ …Àu ‹›À …Àt‹µÀ …ÀuèVj¿èp¿ÿÿHƒÄH[]ÃUH‰åHƒì‰}ü¿*Ú@袱ÿÿèúÿÿ¿èE¿ÿÿÉÃUH‰åH‰}è‰uä‹Eä‰Eô‹Eäƒà‰EøÁ}äëlH‹EèHƒÀ¶¶À‰ÂÁâH‹E趶ÀÐEôH‹EèHƒÀ¶¶À‰ÂÁâH‹EèHƒÀ¶¶ÀÐÁà 3Eô‰Eü‹EôÁà3Eü‰EôHƒEè‹EôÁè Eôƒmäƒ}䎋Eøƒøt]ƒøtƒø„…éŸH‹EèHƒÀ¶¶À‰ÂÁâH‹E趶ÀÐEô‹EôÁà1EôH‹EèHƒÀ¶¶ÀÁà1Eô‹EôÁè EôëUH‹EèHƒÀ¶¶À‰ÂÁâH‹E趶ÀÐEô‹EôÁà 1Eô‹EôÁèEôëH‹E趶ÀEô‹EôÁà 1Eô‹EôÑèEô‹EôÁà1Eô‹EôÁèEô‹EôÁà1Eô‹EôÁèEô‹EôÁà1Eô‹EôÁèEô‹EôH‰m !]ÃUH‰åH‰}ȉuÄHÇEØH‹EÈH‰Eø‹EÄP…ÀHÂÁøH˜H‰Eð‹EĉÂÁúÁêЃà)к‰Ñ)Á‰ÈH˜H‰EØHƒ}Ø„ƒHƒ}Øw|HƒEð‹EÄH˜HEÈH‰EÐHƒ}ØwcH‹EØHÁàH8Ú@H‹ÿàH‹EÐÆHƒEÐH‹EÐÆHƒEÐH‹EÐÆHƒEÐH‹EÐÆHƒEÐH‹EÐÆHƒEÐH‹EÐÆHƒEÐH‹EÐƶ½ ¶ÀH˜‹…€a‰ÀH‰EàÇEè|JÇEì¹y7žéƒH‹EøH‹HEØH‹EøHƒÀH‹HEàH‹EøHƒÀH‹HEèH‹EàH)EØH‹EèH)EØH‹EèHÁè+H1EØH‹EèH)EàH‹EØH)EàH‹EØHÁà H1EàH‹EØH)EèH‹EàH)EèH‹EàHÁèH1EèH‹EàH)EØH‹EèH)EØH‹EèHÁè&H1EØH‹EèH)EàH‹EØH)EàH‹EØHÁàH1EàH‹EØH)EèH‹EàH)EèH‹EàHÁèH1EèH‹EàH)EØH‹EèH)EØH‹EèHÁè#H1EØH‹EèH)EàH‹EØH)EàH‹EØHÁà1H1EàH‹EØH)EèH‹EàH)EèH‹EàHÁè H1EèH‹EàH)EØH‹EèH)EØH‹EèHÁè H1EØH‹EèH)EàH‹EØH)EàH‹EØHÁàH1EàH‹EØH)EèH‹EàH)EèH‹EàHÁèH1EèHƒmðHƒEøHƒ}ð‡rþÿÿ‹EÄH˜HÁàHEèH‹EðHƒøtHƒør HƒøuH‹EøHƒÀH‹HEàH‹EøH‹HEØH‹EàH)EØH‹EèH)EØH‹EèHÁè+H1EØH‹EèH)EàH‹EØH)EàH‹EØHÁà H1EàH‹EØH)EèH‹EàH)EèH‹EàHÁèH1EèH‹EàH)EØH‹EèH)EØH‹EèHÁè&H1EØH‹EèH)EàH‹EØH)EàH‹EØHÁàH1EàH‹EØH)EèH‹EàH)EèH‹EàHÁèH1EèH‹EàH)EØH‹EèH)EØH‹EèHÁè#H1EØH‹EèH)EàH‹EØH)EàH‹EØHÁà1H1EàH‹EØH)EèH‹EàH)EèH‹EàHÁè H1EèH‹EàH)EØH‹EèH)EØH‹EèHÁè H1EØH‹EèH)EàH‹EØH)EàH‹EØHÁàH1EàH‹EØH)EèH‹EàH)EèH‹EàHÁèH1EèH‹Lû H#EèH‰ » H‹E؃àH‰ » H‹,û H#EàH‰ñº H‹EØHÁèƒàH‰ïº H‹EèH‰ô!H‹EàH‰yâ ]ÃUH‰åHƒìH‰}ø‰uôH‹ ™õ ‹UôH‹Eø‰ÖH‰ÇÿÑ‹Å· ƒø?H‹±!H‹Ú!H!ÐH‰xº ëH‹—!H‰hº ÉÃUH‰åSHƒì¶ ¹ ¶Ð‹•· ЉÇ褫ÿÿH‹}¯ HƒÀHÁàH‰Çè†H‰–Ë ÇEìë H‹†Ë ‹UìHcÒHÁâH裬ÿÿ‰ƒEì‹EìH˜H‹1¯ HƒÂH9Ð|ËHƒÄ[]ÃUH‰åH‹FË H…ÀuèfÿÿÿH‹5Ë H‹†¹ HÁâHЋ]ÃUH‰åS‹ض ºH‰Ó‰ÁHÓãH‰ØHƒèH‰å !H‹Þ !H‰·ù []ÃUH‰åHƒìH‰}øHƒ}øt~H‹EøH‹H‰ÇèÞÿÿÿH‹EøH‹@H‰S¹ ‹u¶ ƒø?H‹A¹ H‹Š !H!ÐH‰0¹ H‹aÉ H‹"¹ HÁâHÐH‹H‹EøH‰H‹BÉ H‹¹ HÁâHÂH‹EøH‰ëÉÃUH‰åSHƒì‹ ¶ ƒÀ‰¶ ‹úµ ¸xÚ@‰ÖH‰Ç¸èÆ©ÿÿ‹ൠºH‰Ó‰ÁHÓãH‰ØH‰ÇèñH‰ÑÈ èÙþÿÿHǸ ë2H‹Hý H‹q¸ HÁâHÐH‹H‰ÇèãþÿÿH‹X¸ HƒÀH‰M¸ ‹wµ ƒèºH‰Ó‰ÁHÓãH‰ØH‰ÂH‹*¸ H9Âw¦H‹îü H‰OÈ ‹Aµ ƒèºH‰Ó‰ÁHÓãH‰ØH‰'È H‹0È H‰¹ü ¿›Ú@蟨ÿÿHƒÄ[]ÃUH‰å‰}ì‰uè‰UäÇEüë9‹Eìƒà„Àt ƒuì‹Eü3Eè‰EüÑmì‹Eè…Ày‹EèÀ‰Eè‹Eä1Eèë‹EèÀ‰Eèƒ}ìuÁ‹Eü]ÃUH‰åSHƒì‰}ä‰uàÇEðÇEôë7‹Eô‹Uä‰Ó‰ÁÓû‰Øƒà„Àt‹EôH˜‹ …À]a‹Uà‹Eð‰Î‰ÇèWÿÿÿ‰EðƒEôƒ}ô~ËEðHƒÄ[]ÃUH‰åSHƒìXÇE ÇE¤ÇE¨ÇE¬ÇE°‹.´ ‰Çè?¨ÿÿ‹U¤‹E¨¯Ð‹E¬¯Ð‹E°¯Â‰EÀ‹U ‹E¨¯Ð‹E¬¯Ð‹E°¯Â‰EÄ‹U ‹E¤¯Ð‹E¬¯Ð‹E°¯Â‰EÈ‹U ‹E¤¯Ð‹E¨¯Ð‹E°¯Â‰EÌ‹U ‹E¤¯Ð‹E¨¯Ð‹E¬¯Â‰EÐÇEäéæÇEèèï¨ÿÿ‰ÃÁã èå¨ÿÿ1؃ȉEì‹Eè‰Ä÷ ÇEàë8‹EàX‹EàH˜‹ …À]a‹EàH˜‹…À]a‹Uì‰Î‰Çè)þÿÿHcÓ‰•À]aƒEàƒ}à~‹÷÷ ;EèuiÇEàë"‹EàH˜‹D…À‹Uì‰Ö‰ÇèFþÿÿ‰E܃}Üt ƒEàƒ}à~Øëƒ}Üt/‹Eì‰ïª ‹µ …Àtw¸¨Ú@‹Uä‹Mì‰ÎH‰Ç¸è‹¦ÿÿë\ƒEä}䇎 ÿÿÿ¹ÈÚ@H‹t÷ ‹UäH‰ÎH‰Ç¸èé¦ÿÿH‹Z÷ ¸øÚ@H‰Ñº$¾H‰Ç訧ÿÿ¿莧ÿÿHƒÄX[]ÃUH‰åHƒìP‰}ÌH‰uÀH‹˜³ H‰÷ é H‹EÀHƒÀH‹HƒÀ¶¾ÀƒèAƒø9‡— ‰ÀH‹ÅàÝ@ÿàÇ5´ éÑ Æ†´ éÅ Æ|´ é¹ Ç"´ é H‹EÀHƒÀH‹HƒÀH‰Ç躦ÿÿ‰˜± éˆ ‹´ ƒÀ‰ ´ ‹ö³ ƒÀ‰í³ ée ‹â³ ƒÀ‰Ù³ éQ Æ´ ÇK± Çų é1 Æç³ é% Ç¢³ é Ç{³ éfH‹EÀHƒÀH‹HƒÀH‰Â¸Û@¹H‰ÖH‰Çó¦—Â’À‰Ñ(Á‰È¾À…ÀuÇ…³ éÁH‹EÀHƒÀH‹HƒÀ¶„Àt3è=¦ÿÿH‹H‹UÀHƒÂH‹HƒÂ¶H¾ÒHÒHз·À%…ÀuH‹põ H‰Çè¶ H‹EÀHƒÀH‹HƒÀH‰Çèy¥ÿÿHcÈH‰ÎHÁîH‰u¸HºÏ÷Sã¥›Ä H‹E¸H÷âH‰ÐHÁèHiÀôH‰ÊH)ÂH‰Ðˆ²± éƲ ƾ² éþH‹EÀHƒÀH‹HƒÀH‰Â¸"Û@¹ H‰ÖH‰Çó¦—Â’À‰Ñ(Á‰È¾À…Àu¶[± ƒÈˆR± é²Æc² Æ_² éŸÆR² é“H‹‹ô ¸0Û@H‰Ñº+¾H‰ÇèÙ¤ÿÿH‹jô H‰Çè° é^H‹Ö° H‰Â¸`Û@H‰Ñº!¾H‰Ç衤ÿÿé5H‹EÀHƒÀH‹HƒÀH‰ÇèE¤ÿÿH˜H‰4§ éH‹ˆ° H‰Â¸ˆÛ@H‰Ñº,¾H‰ÇèS¤ÿÿè~¤ÿÿH‹H‹UÀHƒÂH‹HƒÂ¶H¾ÒHÒHз·À%…À…¥ƒ}ÌŽ›H‹EÀHƒÀH‹¶<-„…ƒmÌHƒEÀéwDZ éx‹é° …À…èü£ÿÿH‹H‹UÀHƒÂH‹HƒÂ¶H¾ÒHÒHз·À%…À„ÉH‹EÀHƒÀH‹HƒÀH‰ÇèC£ÿÿ‰Eüƒ}üt'ƒ}üt!H‹ó ¸¸Û@H‰Ñº ¾H‰ÇèS£ÿÿƒ}üu¶z¯ ƒàþˆq¯ éу}üu¶_¯ ƒÈˆV¯ 鶋° …À„›¶<¯ ¶Àƒà„Àt¸ÙÛ@ë¸ÜÛ@¾àÛ@H‹ ~ò H‰ÂH‰Ï¸èö¡ÿÿé]Çׯ H‹EÀHƒÀH‹HƒÀH‰Çèp¢ÿÿ‰V­ ƒ}ÌŽ/H‹EÀHƒÀH‹¶<-„H‹EÀH‹@H‰3ò ƒmÌHƒEÀéüH‹EÀHƒÀH‹HƒÀH‰Â¸ Ü@¹ H‰ÖH‰Çó¦—Â’À‰Ñ(Á‰È¾À…À„¥H‹EÀHƒÀH‹HƒÀH‰Â¸Ü@¹H‰ÖH‰Çó¦—Â’À‰Ñ(Á‰È¾À…ÀtnH‹EÀHƒÀH‹HƒÀH‰Â¸Ü@¹ H‰ÖH‰Çó¦—Â’À‰Ñ(Á‰È¾À…Àt7H‹EÀHƒÀH‹HƒÀH‰Â¸)Ü@¹ H‰ÖH‰Çó¦—Â’À‰Ñ(Á‰È¾À…Àu1H‹EÀHƒÀH‹¹8Ü@H‹ñ H‰ÎH‰Ç¸è† ÿÿ¿èL¡ÿÿH‹EÀHƒÀH‹¹hÜ@H‹Ýð H‰ÎH‰Ç¸èU ÿÿéÉH‹EÀHƒÀH‹HƒÀH‰ÇèÙ ÿÿò*Àò ýòYÁòú é•Çî­ é†H‹EÀHƒÀH‹HƒÀ¶ß ¶ÉHƒéHÉHÈ·˜‰Ñ)Á‰È‰EèH‹üÞ ‰Eìƒ}Ü„H‹ðÞ H‹@H…ÀuYH‹àÞ ¿(èWíÿÿH‰CH‹ËÞ H‹X‹© H˜H‰Çè8íÿÿH‰CH‹¬Þ H‹@H‹¡Þ H‰P ‹{ ƒÀ‰r H‹‡Þ H‹@H‰|Þ H‹uÞ H‹îŒ ‹MäHcÉHÉHÊ·f‰PH‹TÞ H‹ ÝŒ ‹UäHcÒHʶ¶Òf‰PH‹3Þ ‹Uèf‰‹EèHcй kaH‹›Œ ‹uäHcöHöHð·H¿ÀHÁH‹þÝ H‹@H‰ÎH‰ÇèÇ€ÿÿH‹hŒ ‹UäHcÒHÒHзH¿ÀH‰ÆÝ H‹¿Ý H‹ PŒ ‹EäH˜Hȶ¶ÀH‰ÑH)ÁH‰ÈH‰šÝ H‹“Ý ‰EàëH‹ï‹ ‹EàH˜HÐƃEà‹Eà;Eì|â¶ŠÝ ƒèˆÝ ‹EèHcÐH‹Û‹ ‹MäHcÉHÉHÈ·H¿ÀH ka¾H‰ÇèÿÿH‹&Ý f‰EÝ HƒÄ([]ÃUH‰åÇEüë2H‹Œ‹ ‹UüHcÒHÒHзH¿ÀH ka¶„Àt¸ëƒEü¶óÜ ¶À;Eü¿¸]ÃUH‰åHƒìÇEüëbH‹+‹ ‹UüHcÒHÒHзH¿ÀH kaH‰EðH‹Eð¶@ƒà¶ÀH˜H‹ÅWaH‹Eð¶@Àèƒà¶ÀHж„Àu¸ë)ƒEü¶iÜ ¶À;Eü‹çŒ …Àtèÿÿÿë¸ÉÃUH‰åHƒì¶<Ü ˆEþ¶4Ü ˆEÿH‹fÏ H‹@H‰Eð¶Ü ƒÈ1ˆÜ ¶ Ü ˆÜ H‹ÚÛ ¹ ka¸@caH‰ÎH‰Çè¥~ÿÿH‹¶Œ H‰'Š H‹ Š H‰ùŒ è™±ÿÿ¶Eþˆ¼Û ¶Eÿˆ´Û HÇÕŒ HÇê‰ ÿÿÿÿH‹ÓÎ H‹UðH‰PÉÃUH‰åHƒì ‰}ì‹EìƒÀ‰Eü‹EüƒÀHcÐH‹¥œ H9Âr‹Eüƒà…Àt‹Eü‰Âƒâ¸)ÐEüH‹…œ H‰EðH‹zœ ‹EüH˜HÐH‰kœ H‹\œ ‹EüH˜H‰ÑH)ÁH‰ÈH‰Gœ ‹EüHcÐH‹Eð¾H‰Çè0}ÿÿë‹EüH˜H‰ÇèJéÿÿH‰EðH‹EðÉÃUH‰åHƒì0H‰}؉uÔH‹EØH‰EàHÇEèÀ/aÇEø‹EÔP…ÀHÂÁø‰Eüƒ}üŽ–ÇEôéàH‹Eà¶H‹EèˆHƒEàH‹¹ˆ ‹EôH˜Hж¶Àº‰Ñ)Á‰ÈH˜HEèƒEôH‹Eà¶H‹EèˆHƒEàH‹}ˆ ‹EôH˜Hж¶Àº‰Ñ)Á‰ÈH˜HEèƒEôH‹Eà¶H‹EèˆHƒEàH‹Aˆ ‹EôH˜Hж¶Àº‰Ñ)Á‰ÈH˜HEèƒEôH‹Eà¶H‹EèˆHƒEàH‹ˆ ‹EôH˜Hж¶Àº‰Ñ)Á‰ÈH˜HEèƒEôH‹Eà¶H‹EèˆHƒEàH‹ɇ ‹EôH˜Hж¶Àº‰Ñ)Á‰ÈH˜HEèƒEôH‹Eà¶H‹EèˆHƒEàH‹‡ ‹EôH˜Hж¶Àº‰Ñ)Á‰ÈH˜HEèƒEôH‹Eà¶H‹EèˆHƒEàH‹Q‡ ‹EôH˜Hж¶Àº‰Ñ)Á‰ÈH˜HEèƒEôH‹Eà¶H‹EèˆHƒEàH‹‡ ‹EôH˜Hж¶Àº‰Ñ)Á‰ÈH˜HEèƒEô‹Eø;EüœÀƒEø„À… þÿÿ‹Eô‹UÔ‰Ñ)Á‰È‰Eøƒ}ø‡²‹EøH‹Åèé@ÿàH‹Eà¶H‹EèˆHƒEàH‹ž† ‹EôH˜Hж¶Àº‰Ñ)Á‰ÈH˜HEèƒEôH‹Eà¶H‹EèˆHƒEàH‹b† ‹EôH˜Hж¶Àº‰Ñ)Á‰ÈH˜HEèƒEôH‹Eà¶H‹EèˆHƒEàH‹&† ‹EôH˜Hж¶Àº‰Ñ)Á‰ÈH˜HEèƒEôH‹Eà¶H‹EèˆHƒEàH‹ê… ‹EôH˜Hж¶Àº‰Ñ)Á‰ÈH˜HEèƒEôH‹Eà¶H‹EèˆHƒEàH‹®… ‹EôH˜Hж¶Àº‰Ñ)Á‰ÈH˜HEèƒEôH‹Eà¶H‹EèˆHƒEàH‹r… ‹EôH˜Hж¶Àº‰Ñ)Á‰ÈH˜HEèƒEôH‹Eà¶H‹EèˆHƒEàH‹6… ‹EôH˜Hж¶Àº‰Ñ)Á‰ÈH˜HEèƒEôH‹Uè¸À/aH‰ÑH)ÁH‰È‰Eô‹Eô‰EÔ‹EÔƒÀP…ÀHÂÁø‰EøÁeø‹Eô‹Uø‰Ñ)Á‰È‰Eôƒ}ôwc‹EôH‹Å(ê@ÿàH‹EèÆHƒEèH‹EèÆHƒEèH‹EèÆHƒEèH‹EèÆHƒEèH‹EèÆHƒEèH‹EèÆHƒEèH‹EèÆHƒEèëH‹xË ¿Ôé@ÿÐë‹EôH˜H÷ØHEèëmÇEôë1H‹8„ ‹EôH˜Hж„ÀuH‹Eà¶H‹EèˆHƒEèƒEôHƒEà‹Eô;EÔ|ÇÇEôëH‹EèÆHƒEèƒEôƒ}ô~ê‹EôH˜H÷ØHEèH‹Uè¸À/aH‰ÑH)ÁH‰ÈÉÃUH‰åSHƒì‹°ƒ ºH‰Ó‰ÁHÓãH‰ØH‰ÇèÁãÿÿH‰1Ë HƒÄ[]ÃUH‰åèÂÿÿÿ]ÃUH‰åSHƒìXH‰}¨‰u¤HÇE¸ÇEÔHÇEÀÀ/a‹U¤H‹E¨‰ÖH‰Çè0úÿÿ‰E싾„ …Àt ƒÀH‹U°‰BH‹E°H‰Yº ¸HƒÄX[]ÃUH‰åH‰}è‰uä‰Uà‹Eäƒà‰EøÁ}äëuH‹EèHƒÀ¶¶À‰ÂÁâH‹E趶À‹EàЉEàH‹EèHƒÀ¶¶À‰ÂÁâH‹EèHƒÀ¶¶ÀЉÂÁâ ‹Eà1ЉEü‹EàÁà3Eü‰EàHƒEè‹EàÁø Eàƒmäƒ}ä…‹Eøƒøtbƒøtƒø„é©H‹EèHƒÀ¶¶À‰ÂÁâH‹E趶À‹EàЉEà‹EàÁà1EàH‹EèHƒÀ¶¶ÀÁà1Eà‹EàÁø EàëZH‹EèHƒÀ¶¶À‰ÂÁâH‹E趶À‹EàЉEà‹EàÁà 1Eà‹EàÁøEàëH‹E趶ÀEà‹EàÁà 1Eà‹EàÑøEà‹EàÁà1Eà‹EàÁøEà‹EàÁà1Eà‹EàÁøEà‹EàÁà1Eà‹EàÁøEà‹EàH˜H‰ßÈ ]ÃUH‰åH‰}ȉuĉUÀH‹EÈH‰Eø‹EÄP…ÀHÂÁøH˜H‰Eð‹EĉÂÁúÁêЃà)к‰Ñ)Á‰ÈH˜H‰EØHƒ}Ø„ƒHƒ}Øw|HƒEð‹EÄH˜HEÈH‰EÐHƒ}ØwcH‹EØHÁàHhê@H‹ÿàH‹EÐÆHƒEÐH‹EÐÆHƒEÐH‹EÐÆHƒEÐH‹EÐÆHƒEÐH‹EÐÆHƒEÐH‹EÐÆHƒEÐH‹EÐÆ‹EÀH˜H‰Eض{ ¶ÀH˜‹…€a‰ÀH‰EàÇEè|JÇEì¹y7žéƒH‹EøH‹HEØH‹EøHƒÀH‹HEàH‹EøHƒÀH‹HEèH‹EàH)EØH‹EèH)EØH‹EèHÁè+H1EØH‹EèH)EàH‹EØH)EàH‹EØHÁà H1EàH‹EØH)EèH‹EàH)EèH‹EàHÁèH1EèH‹EàH)EØH‹EèH)EØH‹EèHÁè&H1EØH‹EèH)EàH‹EØH)EàH‹EØHÁàH1EàH‹EØH)EèH‹EàH)EèH‹EàHÁèH1EèH‹EàH)EØH‹EèH)EØH‹EèHÁè#H1EØH‹EèH)EàH‹EØH)EàH‹EØHÁà1H1EàH‹EØH)EèH‹EàH)EèH‹EàHÁè H1EèH‹EàH)EØH‹EèH)EØH‹EèHÁè H1EØH‹EèH)EàH‹EØH)EàH‹EØHÁàH1EàH‹EØH)EèH‹EàH)EèH‹EàHÁèH1EèHƒmðHƒEøHƒ}ð‡rþÿÿ‹EÄH˜HÁàHEèH‹EðHƒøtHƒør HƒøuH‹EøHƒÀH‹HEàH‹EøH‹HEØH‹EàH)EØH‹EèH)EØH‹EèHÁè+H1EØH‹EèH)EàH‹EØH)EàH‹EØHÁà H1EàH‹EØH)EèH‹EàH)EèH‹EàHÁèH1EèH‹EàH)EØH‹EèH)EØH‹EèHÁè&H1EØH‹EèH)EàH‹EØH)EàH‹EØHÁàH1EàH‹EØH)EèH‹EàH)EèH‹EàHÁèH1EèH‹EàH)EØH‹EèH)EØH‹EèHÁè#H1EØH‹EèH)EàH‹EØH)EàH‹EØHÁà1H1EàH‹EØH)EèH‹EàH)EèH‹EàHÁè H1EèH‹EàH)EØH‹EèH)EØH‹EèHÁè H1EØH‹EèH)EàH‹EØH)EàH‹EØHÁàH1EàH‹EØH)EèH‹EàH)EèH‹EàHÁèH1EèH‹EØH‰¦Ä ]ÃUH‰åSHƒì8¿èÂÖÿÿH‰J´ H‹C´ ¿hèªÖÿÿH‰H‹/´ H‹HXPÇD$ÇD$Ç$A¹«è@A¸¹º ¾¿ èGH‰H‹â³ H‹HXHÇD$ÇD$Ç$A¹¨ê@A¸¹º¾¿èúH‰H‹H‰EèÇD$ÇD$Ç$A¹¨ê@A¸¹º¾¿è´H‹UèH‰B0H‹J³ H‹HXÇD$ÇD$Ç$A¹«ê@A¸¹º¾¿èbH‰H‹ý² H‹HX0ÇD$ÇD$Ç$A¹¹ê@A¸¹º¾¿èH‰H‹H‰EèÇD$ÇD$Ç$A¹¹ê@A¸¹º¾¿èÏH‹UèH‰B0H‹EèH‹@0H‰EèÇD$ÇD$Ç$A¹¹ê@A¸¹º¾¿èH‹UèH‰B0H‹² H‹HXÇD$ÇD$Ç$A¹¼ê@A¸¹º¾¿è-H‰H‹ȱ H‹HXÇD$ÇD$Ç$A¹Æê@A¸¹º¾¿èàH‰H‹{± H‹HX8ÇD$ÇD$Ç$A¹«è@A¸¹º¾¿è“H‰H‹.± H‹HX ÇD$ÇD$Ç$A¹¼ê@A¸¹º¾¿èFH‰H‹á° H‹HX(ÇD$ÇD$Ç$A¹Æê@A¸¹º¾¿èùH‰H‹”° H‹HX@ÇD$ÇD$Ç$A¹Êê@A¸¹º ¾¿è¬H‰H‹G° H‹HXXÇD$ÇD$Ç$A¹Ôê@A¸¹º ¾¿ è_H‰H‹ú¯ H‹HX`ÇD$ÇD$¬ Ç$A¹Úê@A¸¹º¾¿ èH‰H‹­¯ HX¿èÒÿÿH‰H‹•¯ HƒÀH‹ÇD$ÇD$Ç$A¹àê@A¸¹º¾¿ 'è­H‰H‹H‰EèÇD$ÇD$Ç$A¹Æê@A¸¹ º¾¿'ègH‹UèH‰B0H‹ý® HƒÀH‹HXÇD$ÇD$Ç$A¹àê@A¸¹º¾¿'èH‰H‹H‰EèHƒÄ8[]ÃUH‰åHƒì0‰}ì‰uè‰Uä‰MàD‰EÜL‰Mп8èðÐÿÿH‰Eø‹Eè‰Âƒâ&H‹Eøf‰ƒ}uH‹Eø·‰ÂƒÊH‹Eøf‰H‹Eø‹Uä‰P ‹E‰ÂH‹Eøf‰P‹E ‰ÂH‹Eøf‰PH‹EøH‹UÐH‰PH‹Eø‹Uì‰P$H‹Eø‹Uà‰P(H‹Eø‹U܉P,H‹EøÉÃUH‰åHƒì H‰}è¿8èZÐÿÿH‰EðH‹Eè·H‹Eðf‰H‹Eè‹P H‹Eð‰P H‹Eè·PH‹Eðf‰PH‹Eè·PH‹Eðf‰PÇEüë=H‹Eè‹UüHcÒ·LPH‹Eð‹UüHcÒf‰LPH‹Uè‹EüH˜¶LH‹Uð‹EüH˜ˆLƒEüƒ}ü~½H‹EèH‹@HÇEàÿÿÿÿH‰Â¸H‹MàH‰×ò®H‰ÈH÷ÐHƒèHƒÀH‰Çè—ÏÿÿH‹UðH‰BH‹EèH‹@H‰ÂH‹EðH‹@H‰ÖH‰Çè¸bÿÿH‹Eè‹P$H‹Eð‰P$H‹Eè‹P(H‹Eð‰P(H‹Eè‹P,H‹Eð‰P,H‹EðÉÃUH‰åHì ‰½Œþÿÿ‰µˆþÿÿ‰•„þÿÿH‰xþÿÿL‰…pþÿÿL‰hþÿÿdH‹%(H‰Eø1À‹=q ƒøŽÂ‹…ŒþÿÿH˜H‹Åpa¸æê@H‰ÖH‰Ç¸èƒbÿÿÇ…èþÿÿëzH‹H¬ ‹•ŒþÿÿHcÒHÁâHÐH‹‹•èþÿÿHcÒHÁâHÐH‹H‰…˜þÿÿë3H‹xþÿÿH‹•˜þÿÿ‹µèþÿÿ‹…Œþÿÿ‰Çè©H‹…˜þÿÿH‹@0H‰…˜þÿÿHƒ½˜þÿÿuÃ…èþÿÿ‹…èþÿÿ;…ˆþÿÿŒtÿÿÿéœÇ…èþÿÿÇÅ épH‹ž« ‹•ŒþÿÿHcÒHÁâHÐH‹‹•èþÿÿHcÒHÁâHÐH‹H‰…¨þÿÿHƒ½¨þÿÿt H‹…¨þÿÿH‹@0ë¸H‰… þÿÿH‹… þÿÿH‰…˜þÿÿéŽH‹…˜þÿÿ‹@ …ÀtnH‹&« ‹•ŒþÿÿHcÒHÁâHÐH‹H‹…˜þÿÿ‹@ H˜HÁàHÐH‹H…Àt9H‹ñª ‹•ŒþÿÿHcÒHÁâHÐH‹H‹…˜þÿÿ‹@ H˜HÁàHÐH‹H‹@0H…Àu"H‹…˜þÿÿH‹@0H‰…˜þÿÿHƒ½˜þÿÿ…dÿÿÿëHƒ½˜þÿÿ„RH‹… þÿÿH‰…˜þÿÿé1H‹tª ‹•ŒþÿÿHcÒHÁâHÐH‹H‹…˜þÿÿ‹@ H˜HÁàHÐH‹H‰…°þÿÿH‹…°þÿÿH‹@0H…ÀuVH‹…˜þÿÿH‰Çè&üÿÿH‹•¨þÿÿH‰B0H‹…¨þÿÿH‹@0H‰…¨þÿÿH‹…˜þÿÿ‹p ‹èþÿÿ‹•ŒþÿÿH‹…¨þÿÿH‰Çè×é‚H‹…°þÿÿH‹@0H‰…°þÿÿH‹…°þÿÿH‰Çè¾ûÿÿH‹•¨þÿÿH‰B0H‹…¨þÿÿH‹@0H‰…¨þÿÿH‹…˜þÿÿ‹p ‹èþÿÿ‹•ŒþÿÿH‹…¨þÿÿH‰ÇèoH‹…°þÿÿH‹@0H…Àu‹Í ƒÀ‰Ä H‹…˜þÿÿH‹@0H‰…˜þÿÿHƒ½˜þÿÿ…Áþÿÿƒ…èþÿÿ‹…èþÿÿ;…ˆþÿÿŒ~ýÿÿ‹… …À…Wýÿÿ‹Ãm ƒøŽÂ‹…ŒþÿÿH˜H‹Åpa¸ñê@H‰ÖH‰Ç¸è _ÿÿÇ…èþÿÿëzH‹Ψ ‹•ŒþÿÿHcÒHÁâHÐH‹‹•èþÿÿHcÒHÁâHÐH‹H‰…˜þÿÿë3H‹xþÿÿH‹•˜þÿÿ‹µèþÿÿ‹…Œþÿÿ‰Çè/H‹…˜þÿÿH‹@0H‰…˜þÿÿHƒ½˜þÿÿuÃ…èþÿÿ‹…èþÿÿ;…ˆþÿÿŒtÿÿÿé" Ç…èþÿÿéËH‹.¨ ‹•ŒþÿÿHcÒHÁâHÐH‹‹•èþÿÿHcÒHÁâHÐH‹H…À„ŽH‹ø§ ‹•ŒþÿÿHcÒHÁâHÐH‹‹•èþÿÿHcÒHÁâHÐH‹H‹@0H…À„TH‹¾§ ‹•ŒþÿÿHcÒHÁâHÐH‹‹•èþÿÿHcÒHÁâHÐH‹H‹@0H‰… þÿÿ‹…èþÿÿH˜HÀH…xþÿÿH‹• þÿÿ‹R HcÒHÒH•xþÿÿ·f‰H‹W§ ‹•ŒþÿÿHcÒHÁâHÐH‹H‹… þÿÿ‹@ H˜HÁàHÐH‹H…À„³H‹§ ‹•ŒþÿÿHcÒHÁâHÐH‹H‹… þÿÿ‹@ H˜HÁàHÐH‹H‰ÇèîøÿÿH‰…˜þÿÿH‹ߦ ‹•ŒþÿÿHcÒHÁâHÐH‹‹•èþÿÿHcÒHÁâHÂH‹…˜þÿÿH‰H‹… þÿÿ‹@ H˜H…pþÿÿÆH‹… þÿÿ‹p ‹èþÿÿ‹•ŒþÿÿH‹…˜þÿÿH‰Çèk H‹… þÿÿH‹@0H‰… þÿÿéÞH‹Y¦ ‹•ŒþÿÿHcÒHÁâHÐH‹H‹… þÿÿ‹@ H˜HÁàHÐH‹H…À„’H‹ ¦ ‹•ŒþÿÿHcÒHÁâHÐH‹H‹… þÿÿ‹@ H˜HÁàHÐH‹H‰Çèð÷ÿÿH‹•˜þÿÿH‰B0H‹…˜þÿÿH‹@0H‰…˜þÿÿH‹… þÿÿ‹@ H˜H…pþÿÿÆH‹… þÿÿ‹p ‹èþÿÿ‹•ŒþÿÿH‹…˜þÿÿH‰Çè‹ ëH‹… þÿÿH‹@0H‰… þÿÿHƒ½ þÿÿ…ÿÿÿ냅èþÿÿ‹…èþÿÿ;…ˆþÿÿŒ#ýÿÿ‹j ƒøŽÂ‹…ŒþÿÿH˜H‹Åpa¸üê@H‰ÖH‰Ç¸èL[ÿÿÇ…èþÿÿëzH‹¥ ‹•ŒþÿÿHcÒHÁâHÐH‹‹•èþÿÿHcÒHÁâHÐH‹H‰…˜þÿÿë3H‹xþÿÿH‹•˜þÿÿ‹µèþÿÿ‹…Œþÿÿ‰ÇèrH‹…˜þÿÿH‹@0H‰…˜þÿÿHƒ½˜þÿÿuÃ…èþÿÿ‹…èþÿÿ;…ˆþÿÿŒtÿÿÿée Ç…èþÿÿé½H‹q¤ ‹•ŒþÿÿHcÒHÁâHÐH‹‹•èþÿÿHcÒHÁâHÐH‹H‰…¨þÿÿHƒ½¨þÿÿtwH‹…¨þÿÿH‹@0H…ÀugH‹…¨þÿÿH‹@º¾«è@H‰ÇèµYÿÿ…ÀuF‹…ŒþÿÿH˜H‹ÅWa‹…èþÿÿH˜Hж„Àt$‹…ŒþÿÿH˜H‹ÅWaH‹…¨þÿÿ‹@ H˜HÐÆ냅èþÿÿ‹…èþÿÿ;…ˆþÿÿŒ1ÿÿÿ‹Wh …À„…‹-h …À…w‹Kh …À„RH…ðþÿÿH‰…Àþÿÿ‹…ŒþÿÿH˜H‹ÅpaH‰…Èþÿÿë1H‹…Èþÿÿ¶<:tH‹…Èþÿÿ¶H‹…ÀþÿÿˆHƒ…ÀþÿÿHƒ…ÈþÿÿH‹…Èþÿÿ¶„ÀuÁH‹…ÀþÿÿƸë@H‰Ç¸è%Yÿÿ‹…ŒþÿÿH˜‹…ˆaƒøtƒøƒøtëNƒøt1ƒøt8ëB¿ë@èŸXÿÿëS¸ë@H•ðþÿÿH‰ÖH‰Ç¸èÑXÿÿë5¿#ë@èuXÿÿë)¿-ë@èiXÿÿë¸5ë@H•ðþÿÿH‰ÖH‰Ç¸è›Xÿÿ¿=ë@è@Xÿÿ¸Pë@H•ðþÿÿH‰ÖH‰Ç¸ètXÿÿ¸{ë@‹•„þÿÿ‰ÖH‰Ç¸èZXÿÿé‹…ŒþÿÿH˜‹…ˆaƒøtƒøƒøtëWƒøt:ƒøtAëK¿‰ë@èÏWÿÿëe‹…ŒþÿÿH˜H‹Åpa¸Žë@H‰ÖH‰Ç¸èøWÿÿë>¿˜ë@èœWÿÿë2¿ªë@èWÿÿë&‹…ŒþÿÿH˜H‹Åpa¸ºë@H‰ÖH‰Ç¸è¹WÿÿÇ…èþÿÿë‹…èþÿÿH˜H…pþÿÿƃ…èþÿÿ‹…èþÿÿ;…ˆþÿÿ|ÙH‹½pþÿÿH‹xþÿÿ‹•„þÿÿ‹µˆþÿÿ‹…ŒþÿÿI‰ø‰ÇèP‹ñe …À„&¿Çë@èóVÿÿéÇ…èþÿÿéö‹…ŒþÿÿH˜‹…ˆaƒø„öH‹è  ‹•ŒþÿÿHcÒHÁâHÐH‹‹•èþÿÿHcÒHÁâHÐH‹H‰…˜þÿÿé¯H‹…˜þÿÿ‹@ ;…èþÿÿ…‡H‹…˜þÿÿH‹@¾Æê@H‰Çè Wÿÿ…Àuk‹…ŒþÿÿH˜H‹Åpa¸Éë@H‰ÖH‰Ç¸è‡Vÿÿ‹…èþÿÿH˜HÀH…xþÿÿ·¿È¸ßë@‹•èþÿÿ‰ÎH‰Ç¸èUVÿÿ¿ùë@èûUÿÿ¿è£cÿÿH‹…˜þÿÿH‹@0H‰…˜þÿÿHƒ½˜þÿÿ…CÿÿÿÇ…ìþÿÿH‹èŸ ‹•ŒþÿÿHcÒHÁâHÐH‹‹•èþÿÿHcÒHÁâHÐH‹H‰…˜þÿÿë5H‹…˜þÿÿH‹@¾ì@H‰Çè9Vÿÿ…Àuƒ…ìþÿÿH‹…˜þÿÿH‹@0H‰…˜þÿÿHƒ½˜þÿÿuÁƒ½ìþÿÿ~Y‹…ŒþÿÿH˜H‹Åpa¸ì@H‰ÖH‰Ç¸ètUÿÿ¸/ì@‹•ìþÿÿ‹èþÿÿ‰ÎH‰Ç¸èTUÿÿ¿@ì@èúTÿÿ¿è¢bÿÿƒ…èþÿÿ‹…èþÿÿ;…ˆþÿÿŒøýÿÿ‹­c …Àt4L‹…hþÿÿH‹½pþÿÿH‹xþÿÿ‹•„þÿÿ‹µˆþÿÿ‹…ŒþÿÿM‰ÁI‰ø‰Çè‹ób …À„‹ac …À…§‹…ŒþÿÿH˜‹…ˆaƒø„Ç…èþÿÿénHÇ…ÐþÿÿHÇ…ØþÿÿHÇ… þÿÿHÇ…¨þÿÿHÇ…°þÿÿH‹@ž ‹•ŒþÿÿHcÒHÁâHÐH‹‹•èþÿÿHcÒHÁâHÐH‹H‰…˜þÿÿH‹…˜þÿÿH‰…¸þÿÿH‹…¸þÿÿH‰…àþÿÿH‹…àþÿÿH;…˜þÿÿtKH‹…¸þÿÿH‹@0H‰…°þÿÿH‹…¸þÿÿHÇ@0H‹…˜þÿÿH‰…ÐþÿÿH‹…¸þÿÿH‰…ØþÿÿH‹…°þÿÿH‰…˜þÿÿHÇ…°þÿÿH‹…˜þÿÿH‰…¸þÿÿé“H‹…¸þÿÿH‹@0H‰…àþÿÿH‹…¸þÿÿH‹@¾ì@H‰ÇèìSÿÿ…ÀuH‹…¸þÿÿH‰…°þÿÿH‹…¸þÿÿHÇ@0ë8H‹…¸þÿÿH‹• þÿÿH‰P0Hƒ½ þÿÿuH‹…¸þÿÿH‰…¨þÿÿH‹…¸þÿÿH‰… þÿÿH‹…àþÿÿH‰…¸þÿÿHƒ½¸þÿÿ…_ÿÿÿHƒ½¨þÿÿtHƒ½°þÿÿtH‹…¨þÿÿH‹•°þÿÿH‰P0ë6Hƒ½°þÿÿt,Hƒ½ þÿÿuH‹…°þÿÿH‰… þÿÿëH‹… þÿÿH‹•°þÿÿH‰P0Hƒ½Ðþÿÿt*Hƒ½Øþÿÿt H‹…ØþÿÿH‹• þÿÿH‰P0H‹…ÐþÿÿH‰… þÿÿH‹Dœ ‹•ŒþÿÿHcÒHÁâHÐH‹‹•èþÿÿHcÒHÁâHÂH‹… þÿÿH‰ƒ…èþÿÿ‹…èþÿÿ;…ˆþÿÿŒ€ýÿÿ‹¬` …À„΋‚` …À„À‹…ŒþÿÿH˜H‹Åpa¸Oì@H‰ÖH‰Ç¸èåQÿÿÇ…èþÿÿëzH‹ª› ‹•ŒþÿÿHcÒHÁâHÐH‹‹•èþÿÿHcÒHÁâHÐH‹H‰…˜þÿÿë3H‹xþÿÿH‹•˜þÿÿ‹µèþÿÿ‹…Œþÿÿ‰Çè H‹…˜þÿÿH‹@0H‰…˜þÿÿHƒ½˜þÿÿuÃ…èþÿÿ‹…èþÿÿ;…ˆþÿÿŒtÿÿÿëH‹EødH3%(tèQÿÿÉÃUH‰åH‰}ø‰uô‰Uð‰Mì‹EðH˜H‹Å gaH‹Eø‹@ H˜H‹EðH˜H‹ Å gaH‹Eø‹@ H˜Hȶ‹EðH˜H‹4Å ga‹EôH˜Hð¶ Ȉ‹EðH˜H‹ÅÀgaH‹Eø‹@ H˜H‹EðH˜H‹ ÅÀgaH‹Eø‹@ H˜Hȶ‹EðH˜H‹4ÅÀga‹EôH˜Hð¶ Ȉ‹EðH˜H‹ÅWaH‹Eø‹@ H˜H‹EðH˜H‹ ÅWaH‹Eø‹@ H˜Hȶ‹EðH˜H‹4ÅWa‹EôH˜Hð¶ Ȉ‹EðH˜H‹ÅP^a‹UìHcÒHÒHÂH‹Eø‹@ f‰]ÃUH‰åHƒì0‰}ì‰uè‰UäH‰MØL‰EЋEä;Eè9H‹·™ ‹UìHcÒHÁâHÐH‹‹UäHcÒHÁâHÐH‹H…À„ ƒ}äŽÿ‹EäH˜HEж„À„ë‹EäH˜HEÐÆ‹^ …ÀttH‹S™ ‹UìHcÒHÁâHÐH‹‹UäHcÒHÁâHÐH‹H‰Eøë@‹ë] …ÀtH‹Uø‹Mä‹Eì‰Î‰Çè€ëH‹MØH‹Uø‹uä‹Eì‰ÇèªH‹EøH‹@0H‰EøHƒ}øu¹H‹ߘ ‹UìHcÒHÁâHÐH‹‹UäHcÒHÁâHÐH‹H‰Eøë+H‹Eø‹P H‹}ÐH‹MØ‹uè‹EìI‰ø‰Çè·þÿÿH‹EøH‹@0H‰EøHƒ}øuÎëÉÃUH‰åHƒì@‰}ì‰uè‰UäH‰MØL‰EÐL‰MÈ‹Eä;E蓃}䎉H‹H˜ ‹UìHcÒHÁâHÐH‹‹UäHcÒHÁâHÐH‹H…À„Y‹EäH˜HEж¶Àƒà…À„Œ‹EäH˜HEж¶Àƒàƒø…'‹EäH˜HEÈÆ‹EäH˜HEЋUäHcÒHUжƒÊˆ‹q\ …À„ò‹G\ …À„ä‹EäH˜HÀHEØ·¿Ð¸hì@‹Mä‰ÎH‰Ç¸è¦Mÿÿ鶋EäH˜HEЋUäHcÒHUжƒÊˆH‹W— ‹UìHcÒHÁâHÐH‹‹UäHcÒHÁâHÐH‹H‰EøëGH‹Eø‹@$H˜H‹UøH‰Å `aH‹Eø‹P L‹EÈH‹}ÐH‹MØ‹uè‹EìM‰ÁI‰ø‰ÇètþÿÿH‹EøH‹@0H‰EøHƒ}øu²‹EäH˜HEЋUäHcÒHUжƒâïˆëëÉÃUH‰åHƒì@‰}ì‰uè‰UäH‰MØL‰EÐL‰MÈL‹EÈH‹}ÐH‹MØ‹Uä‹uè‹EìM‰ÁI‰ø‰ÇèÿýÿÿÇEüë‹EüH˜HEЋUüHcÒHUжƒâ㈃Eü‹Eü;Eè|ÙÉÃUH‰åHƒì@‰}ì‰uèH‰UàH‰MØHƒ}à„›H‹Eà‹H H‹Eà‹P(¸ì@‹uèH‰Ç¸è3LÿÿH‹Eà·@¿ÐH‹Eà‹H$¸³ì@‰ÎH‰Ç¸è LÿÿH‹Eà·@f…ÀtH‹Eà·@¿Ð¸Âì@‰ÖH‰Ç¸èáKÿÿ¿]è7Kÿÿ‹EèH˜HÀHEØ·D¿ÀH‹Eà·˜ƒà…Àt¿Æì@ë¿Èì@‹EìH˜H‹Å ga‹EèH˜Hж„Àt¾Êì@ë¾ Í@‹EìH˜H‹ÅWa‹EèH˜Hж„Àt¹Ìì@ë¹ Í@‹EìH˜H‹ÅÀga‹EèH˜Hж„ÀtºÎì@ëº Í@H‹Eà·˜ƒà…ÀuH‹Eà·˜ƒà …Àt¸Ðì@ë¸ Í@ë¸Òì@AºÔì@D‰D$HÇ$Í@I‰ùI‰ðH‰ÆL‰×¸è×JÿÿÇEüëLH‹EàH‹P‹EüH˜Hж< u¸ÆÏ@H‰Ç¸è¥JÿÿëH‹EàH‹P‹EüH˜Hж¾À‰ÇèæIÿÿƒEüH‹EàH‹P‹EüH˜Hж„Àu‹ÕX …À„‡H‹Eà·@f…Àtz¸ìì@H‰Ç¸è>JÿÿÇEüëOH‹Eà‹UüHcÒ·DPf…Àt7H‹Uà‹EüH˜¶D¶ÐH‹Eà‹MüHcÉ·DH¿È¸ïì@‰ÎH‰Ç¸èêIÿÿƒEüƒ}ü~«¿]è6Iÿÿ¿ è,IÿÿH‹EW H‰Çè}JÿÿëÉÃUH‰åHƒì ‰}ì‰uèH‰UàHƒ}à„ÖH‹Eà‹P ¸÷ì@‹Mè‰ÎH‰Ç¸è}IÿÿH‹Eà·˜ƒà…Àt¸í@H‰Ç¸è\IÿÿëXH‹Eà·˜ƒà …Àt¸í@H‰Ç¸è9Iÿÿë5H‹Eà·˜ƒà…Àt¸-í@H‰Ç¸èIÿÿë¸:í@H‰Ç¸èIÿÿ¸Fí@H‰Ç¸èðHÿÿÇEüëdH‹EàH‹P‹EüH˜Hж<\u,H‹EàH‹@‹UüHcÒHƒÂHжS ‹EüH˜Hж¶ÀEôëH‹ôR ‹UôHcÒHƒêHÐƃmô‹EôHcÐH‹k¤ H9ÂwÓH‹÷R ‹EüH˜Hж¶ÐH‹J¤ HÐH‰@¤ H‹ÁR ‹UüHcÒHÒHÂH‹&¤ f‰‹EøHcÐH‹¤ HÐH‰ ¤ ¶&¤ ƒÀˆ¤ H‹õ£ f‰¤ ‹ÌT HcÐH‹Þ£ H9ÂHC‰µT H‹Ê£ H=ÿvH‹;™ ¿ðí@ÿЃ}ø~3‹EøHcÐH‹)R ‹MüHcÉHÉHÈ·H¿ÀH ka¾H‰ÇèÛEÿÿH‹üQ ‹UüHcÒHÒHзH¿ÀH ka‹EèˆB‹EüƒÀÉÃUH‰åHƒì‰}üƒ}ü”Àƒmü„ÀtH‹; ¿î@ÿÐH‹¥Q ‹UüHcÒHÒHзH¿ÀH ka¶¶ÀÉÃUH‰åHƒì‰}üƒ}ü”Àƒmü„ÀtH‹ëŽ ¿@î@ÿÐH‹UQ ‹UüHcÒHÒHзH¿ÀH ka¶@¶À…Àu‹EüP¸gî@‰ÖH‰Ç¸èÏDÿÿH‹˜ ¿}î@ÿиÉÃUH‰åHƒì ‰}ìÇEøƒ}ì”Àƒmì„ÀtH‹bŽ ¿î@ÿÐH‹ÌP ‹UìHcÒHÒHзH¿ÀH kaH‰EðH‹Eð¶¶À‰Eüƒmü‹Eü‰ÂH‹EðˆH‹„— ¿³î@ÿЋEøÉÃUH‰åHƒì0‰}ì‰uè‰Uä‰MàD‰E܃}ì”Àƒmì„ÀtH‹Ú ¿Èî@ÿÐH‹DP ‹UìHcÒHÒHзH¿ÀH kaH‰EðH‹Eð¶¶À‰Eüƒ}Üt ‹EüPH‹EðˆH‹ù– ¿ëî@ÿÐÉÃUH‰åHƒì ‰øH‰uàf‰EìÇEüÇEüéH‹Uà‹EüH˜¶D<u ¸é€H‹Uà‹EüH˜¶D< u1¿EìP¶/¡ ¶À9Âu¿EìƒÀ=þ¸ë¸ë=H‹Eà‹UüHcÒ·DP˜…ÀtH‹Q– ¿ýî@ÿиëƒEüƒ}üŽiÿÿÿ¸ÉÃUH‰åHì dH‹%(H‰Eø1À¶®ˆ…p÷ÿÿºï@H…p÷ÿÿHÇ…h÷ÿÿÿÿÿÿH‰Æ¸H‹h÷ÿÿH‰÷ò®H‰ÈH÷ÐHHÿH…p÷ÿÿHÈH‹ H‰‹R‰P¸ ï@H•p÷ÿÿH‰ÖH‰Ç¸è_BÿÿH‹EødH3%(tè+BÿÿÉÃUH‰å¶âO „Àuº¾¿èÉDÿÿ뺾¿è³Dÿÿ]ÃUH‰å¿@ï@è°Aÿÿ]ÃUH‰åHƒì‰}ü‰uø‹Eø…À…Ž¸Mï@‹Uü‰ÖH‰Ç¸èÎAÿÿH‹N ‹UüHcÒHÒHзH¿ÀH ka¶@¶Ð¸iï@‰ÖH‰Ç¸è“AÿÿH‹ÌM ‹UüHcÒHÒHзH¿ÀH ka¶@¶Ð¸xï@‰ÖH‰Ç¸èXAÿÿÉÃUH‰åHƒì‰}ü‹Eü‰Æ¿‡ï@¸èáMÿÿÉÃUH‰å‰}üƒEü]ÃH‰l$ØL‰d$àH-óA L%ìA L‰l$èL‰t$ðL‰|$øH‰\$ÐHƒì8L)åA‰ýI‰öHÁýI‰×è @ÿÿH…ít1Û@L‰úL‰öD‰ïAÿÜHƒÃH9ëuêH‹\$H‹l$L‹d$L‹l$ L‹t$(L‹|$0HƒÄ8ÀóÃUH‰åSHƒìH‹XA Hƒøÿt»(aDHƒëÿÐH‹HƒøÿuñHƒÄ[]ÃHƒìè?BÿÿHƒÄÃloops.pmltrail-loop:np_:too many processesbad proc - addprocpan: error: too many processes -- current max is %d procs (-DNFAIR=%d) recompile with -DNFAIR=%d pan: error, VECTORSZ too small, recompile pan.c with -DVECTORSZ=N with N>%d aborting Transition Type: A=atomic; D=d_step; L=local; G=globalSource-State Labels: p=progress; e=end; a=accept;Note: statement merging was used. Only the first stmnt executed in each merge sequence is shown (use spin -a -o3 to disable statement merging)pthread_mutex_init: unsupported non-default initpid exceeds range supported by pthread_cond_wait--end of output--{c_code \nspin: trail ends after %ld steps %3ld: proc %d (%s) %s:%d (state %2d) (invalid end state)#processes %d: rpan: cannot find %s %s%d.%strail%d: %s %s.%scpu%d_trailerror: there are %d trail files: pan: rm or mv all except onepan: cannot find trailfile %s <<<<>>>>pan: Error, proc %d invalid pid transition %d Recovered at state %d pan: Error, proc %d type %d state %d: transition %d not found pan: list of possible transitions in this process: t_id %d -- case %d, [%s] pan: error, next transition UNEXECUTABLE on replay most likely causes: missing c_track statements or illegal side-effects in c_expr statements%3ld: proc %2d (%s) %s:%d (state %d) trans {%d,%d} [%s] MSC: ~G %d MSC: ~R %d %ld: %s(%d):[%s] %3ld: proc %2d (%s)(state %d) [values: %s] (state %d) [%s] %ld:%d:%d pan: cannot create %s causepan: wrote %s pan: elapsed time %.3g seconds pan: rate %9.8g states/second pan: avg transition delay %.5g usec bad forward move7;@A;@J;@r;@Ü;@&<@p<@ú<@)=@T=@used: enabled(pid=thisproc)t= %8.3g R= %7.0gTime limit of %6.3g minutes exceeded Depth= %7ld States= %8.3g Transitions= %8.3g Memory= %9.3f non-existing claimerror: max search depth too smalldepth limit reachedacceptance cyclebad return moveinvalid end stateaccept stutter:L@§K@§K@ºK@ÐK@æK@üK@-L@assertion violated - invalid array index%9.8g states, stored (%g visited) %9.8g states, stored %9.8g states, matched %9.8g transitions (= visited+matched) %9.8g transitions (= stored+matched) %9.8g atomic steps %g lost messages hash conflicts: %9.8g (resolved) (%s) Spin Version 6.4.5 -- 4 November 2015Warning: Search not completed + Reverse Transition Ordering Full statespace search for: never claim - (none specified) assertion violations - (disabled by -A flag)+ acceptance cycles endis+ (fairness %sabled) - (not selected) invalid end states - (disabled by -E flag) + State-vector %d byte, depth reached %ld, errors: %d Stats on memory usage (in Megabytes):%9.3f equivalent memory usage for states (stored*(State-vector + overhead))%9.3f actual memory usage for states (compression: %.2f%%) (less than 1k) state-vector as stored = %.0f byte + %ld byte overhead %9.3f memory used for hash table (-w%d) %9.3f memory used for DFS stack (-m%ld) %9.3f other (proc and chan stacks) %9.3f memory lost to fragmentation %9.3f total actual memory usage InterruptedÌ]@Å]@¹]@­]@¡]@•]@‰]@}]@pan: resizing hashtable to -w%d.. donepolynomial: 0x%.8x (%d tries) pan: could not find a polynomial in %d tries pan: try a different seed with -RSn hashi_reverseerror: -l not available (compile with -DNP)-M and -G affect only -DBITSTATE warning: only one claim defined, -N ignored pan: bad option -P[01], ignored onoffpan: reversed *active* process creation %s p_permutep_rotatep_randrotp_reverseoption %s required compilation with -DPERMUTED invalid option '%s' -- ignored rhashoption -rhash requires compilation with -DPERMUTED pan: reverse transition ordering %s t_reverseGenerated by %s saw option -%c error: -f requires the use of -a or -l warning: -T ignored when -i or -I is used warning: -i or -I work for safety properties only warning: -i and -I need -DREACH to work accurately xg@ôp@g@Ág@h@ôp@ëi@ôp@8i@ªi@ôp@ôp@ëi@9j@ôp@Ñj@€m@Ãm@Do@So@ôp@lp@ôp@Ûp@Ïp@ôp@ôp@ôp@ôp@ôp@ôp@ôp@ig@„g@Ÿg@äg@øg@$h@3h@Bh@Ki@ôp@ôp@¶i@j@Âj@ôp@Cl@´m@n@ôp@ño@6q@œp@°p@ëp@ôp@6q@%s Valid Options are: -a find acceptance cycles -A ignore assert() violations -b consider it an error to exceed the depth-limit -cN stop at Nth error (defaults to -c1) -D print state tables in dot-format and stop -d print state tables and stop -e create trails for all errors -E ignore invalid end states -f add weak fairness (to -a or -l) -hN use different hash-seed N:0..499 (defaults to -h0) -hash generate a random hash-polynomial for -h0 (see also -rhash) using a seed set with -RSn (default %u) -i search for shortest path to error -I like -i, but approximate and faster -J reverse eval order of nested unlesses -l find non-progress cycles -> disabled, requires compilation with -DNP -mN max depth N steps (default=10k) -n no listing of unreached states -QN set time-limit on execution of N minutes -q require empty chans in valid end states -r read and execute trail - can add -v,-n,-PN,-g,-C -r trailfilename read and execute trail in file -rN read and execute N-th error trail -C read and execute trail - columnated output (can add -v,-n) -r -PN read and execute trail - restrict trail output to proc N -g read and execute trail + msc gui support -S silent replay: only user defined printfs show -RSn use randomization seed n -rhash use random hash-polynomial and randomly choose -p_rotateN, -p_permute, or p_reverse -T create trail files in read-only mode -t_reverse reverse order in which transitions are explored -tsuf replace .trail with .suf on trailfiles -V print SPIN version number -v verbose -- filenames in unreached state listing -wN hashtable of 2^N entries (defaults to -w%d) -x do not overwrite an existing trail file options -r, -C, -PN, -g, and -S can optionally be followed by a filename argument, as in '-r filename', naming the trailfile pan: out of memoryhint: to reduce memory, recompile with -DCOLLAPSE # good, fast compression, or -DMA=%d # better/slower compression, or -DHC # hash-compaction, approximation -DBITSTATE # supertrace, approximationpan:%d: %s (at depth %ld) cyclepan: reducing search depth to %ld .(goto)goto : %s:%d, state %d, "%s", -end state-unreached in proctype %s unreached in initunreached in claim %s (%d of %d states) -4:-4:-4 -1:-1:-1 pan: error writing trailfilesv_restorerror: sv_restorerror: p_restorerror: q_restorcannot happen grab_intcannot happen ungrab_intunexpected wordsizeU”@”@Ý“@¡“@e“@)“@í’@±’@•@ó”@ç”@Û”@Ï”@Ô@·”@«”@UŸ@NŸ@BŸ@6Ÿ@*Ÿ@Ÿ@Ÿ@Ÿ@DOa = ((a+1)%3)IFb = (2*a)(1)b = (b-1)break-end-(np_)STEP 1 %s STEP 2 %s STEP 3 %s digraph init {claim_%s { notrace {trace {p_%s { size="8,10"; GT [shape=box,style=dotted,label="%s"]; GT -> S%d; initclaim %s notrace assertiontrace assertionproctype %s }error: proctype '%s' line %d, state %d: has unconditional self-loopelseerror: proctype '%s' state %d, inherits %d 'else' stmntsFINAL proctype %s state %d line %d is a loopstate state %3d -(tr %3d)-> state %3d [id %3d tp %3d,%dLGpeaDA [%s%s%s%s%s] %s:%d => [(%d,%d) S%d -> S%d [color=black,style=dashed,style=dotted,style=solid,style=bold,label=""]; S%d [color=red,style=bold]; S%d [color=green,style=bold]; S%d [color=blue,style=bold,shape=box]; too many queuesbad queue - addqueueVECTORSZ is too small, edit pan.href to uninitialized chan name (len)ref to uninitialized chan name (qfull)queue %d was deleted bad queue - q_fullref to uninitialized chan (unsend)bad queue - unsendref to uninitialized chan (unrecv)bad queue - qrecvunknown qid - q_cond-DNOREDUCE Compiled as: cc -o pan %span.c global vars:local vars proc %d (loop): byte a: %d byte b: %d %d{®Gáz„?š™™™™™¹?N@0Að?àC @Y@<@;Lh¸ÿÿhüÿÿ ÿÿ° ÿÿÐŒ$ÿÿøš'ÿÿ¹'ÿÿ8Ñ'ÿÿXê'ÿÿxþ'ÿÿ˜1(ÿÿ¸E)ÿÿàm)ÿÿ*ÿÿ Ê*ÿÿ@ +ÿÿ`K.ÿÿ€/ÿÿ h/ÿÿÀ(4ÿÿèã:ÿÿEÿÿ0‹EÿÿPHÿÿpHÿÿ¹Hÿÿ°GIÿÿÐ KÿÿðŒMÿÿ³Nÿÿ8ºOÿÿXDPÿÿx Pÿÿ˜üPÿÿ¸QÿÿØÇbÿÿãcÿÿ 3dÿÿ@ƒeÿÿ`akÿÿˆ‡kÿÿ¨mÿÿÈ™qÿÿèòqÿÿ wrÿÿ0 ¥rÿÿP Ürÿÿp psÿÿ €tÿÿ¸ ÚtÿÿØ @uÿÿ Bwÿÿ( ¾ƒÿÿH þˆÿÿh ±‰ÿÿˆ §Šÿÿ¨ ÊŠÿÿÈ ¶Œÿÿè ¨Žÿÿ Gÿÿ( ;’ÿÿP ˆ“ÿÿx ”ÿÿ˜ x–ÿÿÀ Ý—ÿÿà —˜ÿÿ (™ÿÿ Ø›ÿÿH žÿÿp ežÿÿ ÿžÿÿ° ¿ŸÿÿÐ q ÿÿð É¥ÿÿ þ¥ÿÿ0 ¦ÿÿP ­ÿÿx £®ÿÿ˜ ܲÿÿ¸ ›¸ÿÿà A¹ÿÿpºÿÿ 4Ìÿÿ@]Íÿÿ`¾Îÿÿ€€Ðÿÿ ñÐÿÿÀ°Óÿÿà¦ÕÿÿËÕÿÿ ÔÕÿÿ@Ü×ÿÿ`,Øÿÿ€®Øÿÿ 0ÙÿÿÀ¸Ùÿÿà{ÚÿÿÛÿÿ ZÛÿÿ@jÛÿÿ`Üÿÿ€4Üÿÿ HÜÿÿÀØÜÿÿèzRx $Hÿÿ`FJ w€?;*3$"DdÿÿA†C A dJÿÿ A†C D $„3ÿÿA†C pƒL ¬Œ ÿÿA†C   Ìz#ÿÿA†C Z ìy#ÿÿA†C S  q#ÿÿA†C T ,j#ÿÿA†C O L^#ÿÿ3A†C n $lq#ÿÿA†C bƒí ”]$ÿÿ(A†C c ´e$ÿÿ¦A†C ¡ Ôë$ÿÿ·A†C ² ô‚%ÿÿ@A†C ¢%ÿÿAA†C < 4Ã(ÿÿÐA†C Ë Ts)ÿÿMA†C H $t )ÿÿÀA†C aƒš œ8.ÿÿ»A†C ¶ $¼Ó4ÿÿ9 A†C Lƒ( ää>ÿÿoA†C j 3?ÿÿvA†C q $‰AÿÿA†C R D€Aÿÿ¡A†C œ dBÿÿŽA†C ‰ „oBÿÿÄA†C ¿ $¤DÿÿA†C vƒF ÌlFÿÿ'A†C " ìsGÿÿA†C   ZHÿÿŠA†C … ,ÄHÿÿ\A†C W LIÿÿ\A†C W lI>w¯Y$v[)ц¯£S =Âm¶O½³–QݱÃû†Ø% ó§cŽ´Ì'ð؇ 'ê+y“Û!ŸÀxþ» ÃÇKêÉÃû[ýSn<Ý 2« 1…tnAýuäÅÃÁ +çÞ“_0adÅÞqÅÅ!ý¡áBûKˆQúûw—lQ“M a8³óй̑'4É×bé"t¡GœÍi{Cdëä_Ëa€“Õá³Q‚óz ÜÞŽ1[ÝYó_c5ÍÛhOÿPWr°ÛÛ6cHu¯ƒ™/CççÐÁ[ëô!Áˆ9µó# ¸ßlÏtÔq©ÔÕ—åÒ!÷7ÿµÍX.?ÙãN9q}߇x’q­W}g·.#QÌõãC´ve¿í7¶(ˆ«ö@Éï0¸ÇŠíI ò¯e„Šòù ¡ }IµáʬDŸ’à•‰ŒàÉÖ"ý)À¥¶BÛª=EŠn•\=9®ô‹«ƒ¿3¬>]ßÄq-G9%wd¸‡Hmw5 x÷nׯ³Ö¡ÁÅ3û™b‰‡ï’É\ ]€›š'ÌS£³–²WÉÞºR1äÉW Qm™Ç2~è]»ý´j!Ýÿ?ÝMW\}v uÉy;Tp«OÊþʼn{³Žý΢ ‘ °ô=Yfñeõ{‹l>uÝ[ûõ^ÔòOÀA—¤ 0!AÜGÍ¡K²#缟¨{hß®Æç#ÕÓ#§VûB@õQgQÕ[ÍÕFBç] ‹é…™$÷œM[##‘é9óÀ_QðøA±o)ŠQŸb•Ö,Ëü^ ñt©ÃÆ\+Ê¢#Á>Æàë—9=ÍóÅ°5[Øåñ½±' ÃI‚Q¶aŸ‘à­Ã)žw…”¬Û©Iá, $L%û4[ ‰«È…%JkKÙ#¹†¡¥m‚I­7:ÒÉ h½o¤ù,,ä_ËÏ÷‹+„´ xƒäkuÏf7·>¥ÊAùYÙgû’3\ Û?F¯4;3õ$§ –“×¼±1:‹;‘xß]J1›3ƒ‚ž©é)Ë÷'JÖÿp§í—2§¥<½oЖ•Û+õy!%Õ¦½Ôc 9൜•ÏB5hqËsÂ'­gZE;KgÚ,k‰©ý…}+VóÁ[™‹çDáiŸtWðm£gîÏ·AŒãd”÷‰æ‰!myñ3…уü$ôpF$Y¯Œ­ÚåùvIïÑöÿôê _@;iE¦e ³q쟽ã’ò]á%—+ŒÔ-ϊΛH)[YÀÐ2¿d6-38_ÄUÕÅ‘Ù½ŸÚ—Ÿ©Â) ßËÐ]Aº7âY »b7Ðç“VI~/(¸QóŽ>…뻊›ùf_å÷6'Sc~e»:³µ+Nß.‡SÈÊWnÏ·=A¦-%d…ÝSíÀÙq"%CH‡yµÉ¨ “O€~ -ýÝ)9½=C6ŒVÖ9é$æï‰1³ÿ‹æ)3$®Š™T3æÍúÅeüZ½§OXz5«ïÞ»dáØ\Ÿ¾¡³S ½,°ã–j‰£–¯õ fCCÀsscßè`déE}?’k×_o15Ðˇ%qL[óbà6ÉÇÀ®÷)ÙfZ“G+vÚk× µ\•ï°4ïl6Ç`Éó¤7ˆJ©C¼£_Á8Æ»úfNÏ…«0ï%¼ó‹«Õ,mÃù>aI!渑ý±ÙO ë‰ã¥#½C•ù¡l­«I !+Séø‰ºO…»ÆܧQ H;8/k3´¤a#¯ÓÇ?Åß…ª¥WÍ MöBÃ1ê?¡ÕbW‰˜3 j·£òF…ï„'빞"S0 œ9­~[ûš®‚³ŸžùYdK‘×í¯Ý'ÈêÁz ~é’u|2e?UWêÿIëJM®9R…EKK! ”Ëôª~oHkÃÀ¹ìc¯§) z¯Í¦ž–M£Xv©»À_›é&&ozñ4|ã»iqs¼Ã=Tg…©F ­ÙO&¡) ñ;Ý^Ík[ø‹-Ó¢C@ºÀ]a„½ ׎@ÀÉÝaç`aëXaõ #@Ð ’?@Š  }b@7 É@Ã.H^a2àa: aAaLP^aU@ab ²d@fgao ŸR@{ða„£¶Ê T@PÕ`^aÚ ó@Mæh^aôp^aÿ€^a Ô@@!äaTa#€`a*@a7K ÷Ê@;XPadx 5½@aa‹ `a`• â@A¢aa¨ aa¬Á ‰@°É ØaÞ `ƒ@Šè ´Ç@PîHaû€a caÍ@.a8 È@‚? aGxaJ`aT@ca[ 2Ë@epah`ak BË@©tHgaza@a‡ Ö@3— ‘@§ Ì@‰·PgaÂXgaÅÙ`gaâpaí `a àa0 pga xa Äa+  P†@e4 €ga7 èa= aI  s¨@¦O ñÿÐpaT i °aq  ð@x  £Å@ ƒ  SÊ@¤Ž ˆga  ‰y@ö˜  a    ˆÃ@öª  @@Àµ pa¾ XaÉ gaÏ  @Þ  Ž|@òæ  °‹@8ë  aò ñÿ¨aþ  ga  d=@'  g@|   oˆ@‘!  E@¦,  –s@@2 üa9  ÉÀ@¿? °gaE  Ù7@Q ÐaZ  Xd@Z^ hag Han  µ‡@ºx Àga‚ Ðga…  êƒ@fŽ àga’ àha˜ iaþœ ´a¤  z@#¯  Â@Á kaÇ  É@ˆÎ  e@Ö ˜aÝ ï  Ôa   Ö•@ " øa( ¬a/ C X l  õ@@ªv ka|  ka€ aŒ °a”  ¼@)™  qa@Y  ² pa¼ Ð aØ ˜aß  @@\ä (oaï @oa÷ ¨a  ‘8@Ž  x@@\ % 7 @pa@< aF Z  ð7@¡f €paj at a{  XÀ@q‚ ¼a‹ èa’ ˜a˜ ða   ´¢@¿©  ¬Å@²  ~Å@%»  ¢@@Ä  †È@‚Ë ˆpaÐ  —@²Û  á•@úã äaè  »S@Pó  pa ü Àpa  í\@„  p @  Ú@  1 ˆa: ¨a> P ÈpaW p Øaz ÈaŽ Ìacall_gmon_startcrtstuff.c__CTOR_LIST____DTOR_LIST____JCR_LIST____do_global_dtors_auxcompleted.6517dtor_idx.6519frame_dummy__CTOR_END____FRAME_END____JCR_END____do_global_ctors_auxpan.chaveleftfragmentgrowj1_spinj2_spinj3_spinj4_spinA_depthtbufwrap_in_progress.4452sdone.4645reclaim_sizereclaim_memN_tabunwindinglaststr.4906__init_array_end_DYNAMIC__init_array_start_GLOBAL_OFFSET_TABLE___libc_csu_finiprintmpreranddo_transitnlostFhspin_mutex_lockPUTQ_oo_hash64comp_nowputchar@@GLIBC_2.2.5spin_c_typMallocguiglobinitempty_chunkssilentS_Acompressdfs_tablestrncpy@@GLIBC_2.2.5nShadowstrncmp@@GLIBC_2.2.5sv_savesvtackK2reached0stdout@@GLIBC_2.2.5Q_sdata_startP_o_tmpsmaxstrcpy@@GLIBC_2.2.5__isoc99_fscanf@@GLIBC_2.7filled_chunksstopstateputs@@GLIBC_2.2.5set_H_tabuerrorPROBEHASH_NRaddproconlyprochcmpdfs_uerrortransstoppedr_ckwrite@@GLIBC_2.2.5memlimspin_cond_signald_sfhdonefreqfindtrailhasherLstateP_s_tmp_edatao_hash32loopstatewarnedqs_emptydo_the_searchfclose@@GLIBC_2.2.5comp_msknmaskmake_trailrunpan_randBtypesretransPrintf_finiputrailreadtrailc_chandump__stack_chk_fail@@GLIBC_2.4simvalsMaskcpytrendstatetruncs2strchr@@GLIBC_2.2.5printf@@GLIBC_2.2.5Nrunspin_joinXXresize_hashtabledodotf_pidZAPSvisstateNrStatesc_stack_startt_reverseclaimnamestrrchr@@GLIBC_2.2.5reverse_capturewrapupinirandgetrailo_hashHASH_CONSTsnap_timeppcheckcyclesmemset@@GLIBC_2.2.5proc_skipAirnr_statesadd_src_txtsnapshotset_masksq_condclose@@GLIBC_2.2.5efdTstOnlytruncsdo_hashgenmapstate__DTOR_END__ppownstatesspin_assertmreached__libc_start_main@@GLIBC_2.2.5srand@@GLIBC_2.2.5memcmp@@GLIBC_2.2.5wrap_statstrptfind_sourcetrailfilenameloopstate0Q_o_tmpselect_claimreversinguptoUerror__data_startstrcmp@@GLIBC_2.2.5active_procscode_lookupsignal@@GLIBC_2.2.5tagtableexclusivet_id_lkuptransmognifyH_tabfnmfprintf@@GLIBC_2.2.5delproc__gmon_start__TMODEsv_restorq_len__dso_handleproc_offsetmemcpy@@GLIBC_2.14this_IO_stdin_usednoassertsq_fulltprefixZnTrailFileA_Rootc_globalsZhFac_localstrailnoendsflrefspin_mutex_initspin_mutex_free__libc_csu_initstart_timeK1malloc@@GLIBC_2.2.5reached1depthfoundfflush@@GLIBC_2.2.5ssizesrc_file0reacheds_randwhichtrailq_restorSSsvmaxevery_errorsettr_endvprintf@@GLIBC_2.2.5src_ln0_startiniglobalsto_compile_emallocsrc_alldot_crackwrap_trailprocnamewhichclaimS_Tabspin_cond_waitxrefsrcdelqCholds__bss_startprogstateenabledmainungrab_intscpu_printfusageerrorscrackquotastart_timerfairnessmulmaxdepthngrabsgrab_intsaccpstateLLp_restorP_snoptrP_osignoffdfs_Uerrorspin_mutex_unlockvsizeunrecvhashgenq_skipopen@@GLIBC_2.2.5times@@GLIBC_2.2.5no_rckfopen@@GLIBC_2.2.5hinitdepthstrictperror@@GLIBC_2.2.5sysconf@@GLIBC_2.2.5_Jv_RegisterClassesnew_statestacknowc_init_doneverboseimeds_hashatoi@@GLIBC_2.2.5omaxdepthstrcat@@GLIBC_2.2.5boundedCcheckPptrloopstate1Q_s_tmpa_cyclesstop_timerQptrsprintf@@GLIBC_2.2.5exit@@GLIBC_2.2.5snaplike_javafwrite@@GLIBC_2.2.5report_timecntiterativenlinksdo_dfscoltracememcnttrcntMaxbodysettableaddqueuedo_reachpan_exitunsendmaskgrab_stateh_storehmaxBoundcheckstart_tmdelta_timed_hash_initlocinit0strstr@@GLIBC_2.2.5q_offsetboqrand@@GLIBC_2.2.5noqptr__ctype_b_loc@@GLIBC_2.3Nr_Trailsstderr@@GLIBC_2.2.5state_tablesSpin/Examples/cobra.prog0000664000175100017510000001003112636063466013315 0ustar ghgh{ new bin; # binary operator count new bop; # boolean new aop; # arithmetic new pm; # marker new none; new L1, L2, L3, L4, L5, L6, L7; # precedence levels new L8, L9, L10, L11, L12, L13; if (.txt == "++" || .txt == "--") { aop.mark++; . = .prv; if (@ident) { . = .nxt; label L1; } else { label L2; . = .nxt; } Next; } if (.txt == "~") { bin.mark++; label L2; Next; } if (.txt == "*") { aop.mark++; label L3; Next; } if (.txt == "/") { aop.mark++; label L3; Next; } if (.txt == "%") { aop.mark++; label L3; Next; } if (.txt == "+") { aop.mark++; label L4; Next; } if (.txt == "-") { aop.mark++; label L4; Next; } if (.txt == "<<") { bin.mark++; label L5; Next; } if (.txt == ">>") { bin.mark++; label L5; Next; } if (.txt == ">") { bop.mark++; label L6; Next; } if (.txt == ">=") { bop.mark++; label L6; Next; } if (.txt == "<") { bop.mark++; label L6; Next; } if (.txt == "<=") { bop.mark++; label L6; Next; } if (.txt == "==") { bop.mark++; label L7; Next; } if (.txt == "!=") { bop.mark++; label L7; Next; } if (.txt == "&") { . = .prv; if (!@ident) { . = .nxt; Next; } . = .nxt; bin.mark++; label L8; Next; } if (.txt == "^") { bin.mark++; label L9; Next; } if (.txt == "|") { bin.mark++; label L10; Next; } if (.txt == "&&") { bop.mark++; label L11; Next; } if (.txt == "||") { bop.mark++; label L12; Next; } if (.txt == "?") { bop.mark++; label L13; Next; } if (.txt == "=" # L14 || .txt == "(") { L1 = none; L2 = none; L3 = none; L4 = none; L5 = none; L6 = none; L7 = none; L8 = none; L9 = none; L10 = none; L11 = none; L12 = none; L13 = none; bin.mark = 0; aop.mark = 0; bop.mark = 0; pm.mark = 0; if (.txt == "(") { . = .forw; label pm; . = .back; } else { label pm; } Next; } if (pm.lnr == 0) { Next; } if (.txt == ";" || .txt == "," # L15 || . == pm # ")" || .round < pm.round || .curly < pm.curly) { if ((aop.mark + bop.mark) && bin.mark) { pm.mark = 0; # find multiple operators with .round == pm.round and .bracket == 0 if (L1.round == pm.round && !L1.bracket && L1.txt != "") { pm.mark++; } if (L2.round == pm.round && !L2.bracket && L2.txt != "") { pm.mark++; } if (L3.round == pm.round && !L3.bracket && L3.txt != "") { pm.mark++; } if (L4.round == pm.round && !L4.bracket && L4.txt != "") { pm.mark++; } if (L5.round == pm.round && !L5.bracket && L5.txt != "") { pm.mark++; } if (L6.round == pm.round && !L6.bracket && L6.txt != "") { pm.mark++; } if (L7.round == pm.round && !L7.bracket && L7.txt != "") { pm.mark++; } if (L8.round == pm.round && !L8.bracket && L8.txt != "") { pm.mark++; } if (L9.round == pm.round && !L9.bracket && L9.txt != "") { pm.mark++; } if (L10.round == pm.round && !L10.bracket && L10.txt != "") { pm.mark++; } if (L11.round == pm.round && !L11.bracket && L11.txt != "") { pm.mark++; } if (L12.round == pm.round && !L12.bracket && L12.txt != "") { pm.mark++; } if (L13.round == pm.round && !L13.bracket && L13.txt != "") { pm.mark++; } if (pm.mark > 1) { print .fnm ":" .lnr ": '" pm.txt "' precedence high to low: "; if (L1.round == pm.round && !L1.bracket) { print L1.txt " "; } if (L2.round == pm.round && !L2.bracket) { print L2.txt " "; } if (L3.round == pm.round && !L3.bracket) { print L3.txt " "; } if (L4.round == pm.round && !L4.bracket) { print L4.txt " "; } if (L5.round == pm.round && !L5.bracket) { print L5.txt " "; } if (L6.round == pm.round && !L6.bracket) { print L6.txt " "; } if (L7.round == pm.round && !L7.bracket) { print L7.txt " "; } if (L8.round == pm.round && !L8.bracket) { print L8.txt " "; } if (L9.round == pm.round && !L9.bracket) { print L9.txt " "; } if (L10.round == pm.round && !L10.bracket) { print L10.txt " "; } if (L11.round == pm.round && !L11.bracket) { print L11.txt " "; } if (L12.round == pm.round && !L12.bracket) { print L12.txt " "; } if (L13.round == pm.round && !L13.bracket) { print L13.txt " "; } print " (" pm.mark "," pm.lnr "," .round ",'" .txt "')\n"; Stop; } } L1 = none; L2 = none; L3 = none; L4 = none; L5 = none; L6 = none; L7 = none; L8 = none; L9 = none; L10 = none; L11 = none; L12 = none; L13 = none; bin.mark = 0; aop.mark = 0; bop.mark = 0; pm = none; } } Spin/Examples/sat.pml0000644000175100017510000000027312331274305012630 0ustar ghghactive proctype P() { bool a, b, c select(a: 0..1) select(b: 0..1) select(c: 0..1) assert(!((a || c) && (!a || !c) && (a || !b) && (!a || b) && (b || !c) && (!b || !c))) } Spin/Examples/for_select_example.pml0000644000175100017510000000155412330777113015710 0ustar ghgh/* some simple examples of for and select */ #define N 10 typedef m { bit b; int x; chan c; }; init { int i, j; chan a[N] = [7] of { m }; chan b[4]; m foo, bar, goo; select ( i : 8..21 ); printf("i=%d\n", i); assert(i != 21); foo.b = 1; foo.x = 3; foo.c = a[3]; a[3]!foo; bar.b = 0; bar.x = 978; bar.c = a[6]; a[3]!bar; /* * make sure to leave a space after the .. * or else the preprocessor will not see the N */ for (i : 1 .. N) { printf("i = %d\n", i) } for (i in a) { printf("a[%d]\t", i); for (j in b) { printf("b[%d], ", j); } printf("\n"); } for (goo in a[3]) { printf("goo: %d %d %d -- %d\t", goo.b, goo.x, goo.c, len(a[3])); for (foo in a[3]) { printf("foo: %d %d %d -- %d\t", foo.b, foo.x, foo.c, len(a[3])); } printf("\n"); } a[3]?goo; printf("%d %d %d -- %d\n", goo.b, goo.x, goo.c, len(a[3])) } Spin/Doc/0000755000175100017510000000000012641606005010254 5ustar ghghSpin/Doc/README.html0000644000175100017510000005512612641606227012116 0ustar ghgh Spin - Version 6.4 - January 2016

SPIN README

    Overview of this File

    1. Downloading Spin
    2. Installing Spin
    3. Related software (gcc, cpp, tcl/tk wish, yacc, dot, etch, jspin, erigone, spinja, ltl2ba)

    0. Overview

    This readme file contains the guidelines for downloading and installing Spin and related software on Unix/Linux and Windows platforms. Refer to Spin's homepage for a general description of Spin, with pointers to manual pages, newsletters.

    Spin is distributed freely in source form to encourage research in formal verification, and to help a support friendly and open exchange of algorithms, ideas, and tools.

      Copyright and License

      The original version of the Spin source code was developed by Gerard Holzmann at Bell Laboratories between 1980 and 1990. It was first publically released in January 1991, initially through the Netlib source code repository. It has been distributed freely since then for research and educational purposes, without any guarantee of any kind expressed or implied. On 30 December 2015 Alcatel-Lucent (the company that inherited Bell Laboratories from AT&T in the trivestiture from 1996) transfered the copyright to all sources to Gerard Holzmann, explicitly to enable a standard open source release under the BSD 3-Clause license. Starting with Spin Version 6.4.5 all Spin code, sources and executables, are now available under the BSD 3-Clause license.

      From the early development of the Plan9 Operating System, Spin has also been part of that system. This means that versions of the Spin source code can also be found in the Plan9 distributions. One branch of that code, for instance, is distributed also by UC Berkeley under a GPLv2 license (see UCB). (Although the sources in that version are still labeled under the older copyright from AT&T and Lucent Technologies.) The BSD version of Spin 6.4.5 and later is likely to find its way into newer distributions of the Plan9 code as well.

    1. Downloading Spin

    Spin runs on Unix, Solaris, and Linux machines, on most flavors of Windows PCs, and on Macs. Precompiled binary executables for some popular types of machines are available in the Spin Binaries.

    All binaries have an extension that matches the Spin version number, such as spin644.exe. To install the binary, rename it to spin.exe and copy it into your bin directory.

    If you have machine type that is not available there, or if you are installing Spin for the first time, then follow the more detailed instructions below.

    • Unix systems:
      download the most recent .tar-file with sources, the graphical interface iSpin, documentation and examples from the Spin Distribution, and continue at Step 2a.

    • PCs (Windows95/98/2000/NT/XP):
      download the most recent pc_spin*.zip file, with a precompiled Spin executable, the graphical interface iSpin, and some examples from the Spin Distribution, and continue at Step 2b.

    • Macs (Mac OS X):
      download the most recent .tar-file with sources, from the Spin Distribution, and continue at Step 2c.

    2. Installing Spin

    2a. Installing Spin on a Unix/Linux System

      Place the *.tar.gz file from the Spin Source Distribution in clean directory, and cd to that directory. If you have a standard Unix/Linux system, unpack the archive, and compile an executable, for instance as follows: 
      	gunzip *.tar.gz
	tar -xf *.tar
	cd Src*
	make

      If you are on a SOLARIS system, edit the makefile and add -DSOLARIS to the compiler directives in the makefile before you type 'make'. Similarly, if you use a different C compiler than defined in the makefile, edit the makefile first. You need to have at least a C compiler and a copy of yacc.

      If all else fails, you can also compile everything with the following line: 

      	yacc -v -d spin.y; cc -o spin *.c

      Spin should compile without warnings. Install the executable version of spin in a directory that is within your default search path (such as your home bin directory, or /usr/local/bin etc.)

      On Unix/Linux systems Spin assumes that the standard C preprocessor cpp is stored in file "/lib/cpp". On some systems this is different: check the comments in the makefile for details if you run into this problem.

      Testing

      To test the basic sanity of the Spin executable, or to get familiar with the basic usage of Spin, cd to the Examples directory that was created when you unpacked the source archive, and follow the instructions in README.tests file that is included there.

      Adding iSpin (Unix/Linux)

      iSpin is an optional, but highly recommended, graphical user interface to Spin, written in Tcl/Tk. To obtain Tcl/Tk, see Related software. The iSpin source can be found the iSpin/ subdirectory that will is created when you unpack the source tarfile.

      iSpin is compatible with Tcl/Tk version 8.4 and 8.5.

      iSpin prints the version numbers of Spin, iSpin, and Tcl/Tk when it starts up. You can also check separately which version of Tcl/Tk you have installed by executing the following commands in `wish' (a Tcl/Tk command): 

      	info tclversion
	puts $tk_version
      You can find out which version of Spin you have by typing, at a shell command prompt: 
      	$ spin -V
      Spin and iSpin need a working version of a C compiler installed on your system.

      iSpin can also make use the graph layout program 'dot' if it is available on your system. For information on 'dot,' see Related software.

      To install iSpin run the iSpin/install.sh script (after possibly editing it).

      • invoke the program by typing
        	ispin
or
	ispin promela_spec

For example:
	ispin Spin/Examples/LTL/leader.pml
      Check the online Help menus in ispin for more details on routine use.

    2b. Installing Spin on a Windows PC

      If you just need to update the Spin executable itself, download a new version from http://spinroot.com/spin/Bin/index.html If you need more files, e.g. a new copy of iSpin, download the latest pc_spin*.zip file from http://spinroot.com/spin/Src/index.html Extract the files from pc_spin*.zip, and copy spin*.exe, renamed spin.exe, into the directory where all your commands reside and that is within your default search path (e.g., c:/cygwin/bin/, or c:\apps\spin\) You can find out what your search path is set to by typing 'set' at an MS-DOS prompt -- this prints a list of all defined variables in your environment, including the search path that is used to find executable commands. (Note that you may need to set the search path in the environment variables)

      If you use Spin from the command line (i.e., without iSpin), be warned that some command shells, e.g., the MKS Korn-shell, have none-standard rules for argument parsing (i.e., you can not reliably quote an argument that contains spaces, such as an LTL formula). In most cases this will not be much of a problem, except with the conversion of LTL formula with the spin -f option. Use single-quotes when needed, e.g.: spin -f '[]<>p' You can circumvent the problem by using inline LTL formula, which are supported in Spin version 6, or by using sping option -F instead of -f, to read the formula from a file instead of the command line.

      To run Spin, also with the precompiled version, you need a working C-compiler and a C-preprocessor, because Spin generates its model checking software as C-source files that require compilation before a verification can be performed. This guarantees fast model checking, because each model checker can be optimized to the specific model being checked. Check, for instance, if you can compile and run a minimal C program succesfully, e.g.: 

      	#include <stdio.h>
	int main(void) { printf("hello\n"); }

      To find a public version of a C compiler and some instructions on how to install it see Related software.

      Adding iSpin (PC)

      To run iSpin on a PC, you need the PC version of Tcl/Tk, which you can find under Related software.

      The ispin*.tcl source is contained in the .zip file of the distribution. Copy the .tcl file as is into a directory where you plan to work, or put a shortcut to this file on the Desktop or in the Start Menu. If you keep the extension .tcl, make sure it is recognized as a 'wish' file by the system, so that ispin starts when you double click the ispin*.tcl script.

      Under cygwin, copy the ispin*.tcl file to /bin/ispin and make it executable You can now use ispin as a normal Unix-style command, and you can pass the name of a filename to it, for instance as: 

      	ispin leader

      An alternative is to start ispin from its source by invoking wish: 

      	wish -f ispin.tcl
  or	wish -f /bin/ispin
      An even more indirect way to force ispin to startup is to first start `wish' from the Start Menu, under Programs, then select the larger window that comes up (the command window), and cd to the directory where you've stored the ispin tcl/tk source file. Then you can then start it up by typing: 
      	source ispin.tcl  # or whatever else you've named this
      and you should be up and running.

      The PC installation assumes that you have a command called "cpp.exe" or "gcc.exe" available (which comes with the gnu-c installation). "cpp" is the traditional name of the C preprocessor. Alternatively, ispin can also use the Visual C++ compiler, which is named cl.exe for preprocessing. To complicate your life somewhat, if you have a copy of the Borland C++ compiler installed, you'll notice that this cplusplus compiler was also named cpp.exe -- that's not the cpp you want. To avoid the name clash, you either have to edit the Spin source code to give it the full path name of the 'real' cpp.exe and recompile, or use Spin with the command-line option -Pxxxx where xxxx is the path for cpp.exe. Or better still (the current default) use gcc for both compilation and for preprocessing. Nothing much in Spin will work without access to a preprocessor. You can do a reasonable number of things without a full-blown compiler though (like simulations). The C-compiler (e.g., gcc) is required for all verifications and for the automata views in iSpin.

      If iSpin cannot locate the gcc executable on your system, it will put up a warning message when it first starts up. On recent versions of cygwin gcc is actually a link from /bin/gcc to /bin/gcc-3 or /bin/gcc-4
      Depending on how the name changes, iSpin may not always recognize it. To fix this -- edit the iSpin source (it's tcl/tk text) and define CC as 

      	set CC c:/cygwin/bin/gcc-5
      or whatever the new name is.

    2c. Installing Spin on a Mac

      Compile Spin from its sources, as described under 2a for Unix systems in general, while following the suggestions below, which were provided by Dominik Brettnacher, email: domi@saargate.de.

      The C preprocessor on Mac OS X cannot be found in /lib. Change the path in the makefile for the proper location (/usr/bin/cpp), and in addition also tell the Mac preprocessor to handle its input as "assembler-with-cpp." This can be done by adding a flag to cpp, for instance in the makefile by adding the directive 

        -DCPP="\"gcc -E -x c -xassembler-with-cpp\""
      to the definition of CFLAGS. If you prefer clang, you can also try if the following works (not tested): 
        -DCPP="\"clang -E -x c\""

      Adding iSpin

      On the Mac, iSpin is known to work correctly with Tcl/Tk Aqua, which offers a self-contained binary distribution for the Mac. Use, for instance, "TclTkAquaStandalone", version 8.4.4 from

      Some users reported that on a Mac iSpin by default places its temporary files into the root directory. This is nasty if you have admin privileges and probably leads to error messages if you don't. To prevent this, add a "cd" statement to iSpin (no arguments, just cd by itself on a line), as the first command executed. Place it, for instance, directly after the opening comments in the file. This makes iSpin use the home directory for these files.

      TclTk Aqua also provides the possibility to start a script when being run. For instance, to make iSpin start if you launch the TCL interpreter: move the ispin file into the "Wish Shell.app", as follows: 

        chmod -R u+w Wish\ Shell.app
mkdir Wish\ Shell.app/Contents/Resources/Scripts
mv ispin*.tcl Wish\ Shell.app/Contents/Resources/Scripts/AppMain.tcl

    3. Related Software

      Some pointers to public domain versions of related software packages. Some (e.g, a C compiler) are required to run Spin, but most other packages are optional extensions or alternatives.

      GCC (needed for Spin)

      On Unix/Linux you probably have gcc, or an equivalent, installed. On the PC you need either a copy of Visual Studio Express (for the cl command), or an installation of gcc with minimally the executables: gcc.exe, and cpp.exe in your search path, together with all the standard C library routines and header files. You can get good free version of all these files with the cygwin toolkit, which is mostly self-installing and available from: http://www.cygwin.com/
      See also what's available in http://spinroot.com/spin/Bin/index.html.

      Tcl/Tk Wish (needed for iSpin only)

      To run iSpin you'll need Tcl/Tk. Tcl/Tk was written by John Ousterhout (john.ousterhout@eng.sun.com) and is public domain. It can be obtained (for PCs or Unix) from cygwin, or from: http://www.tcl.tk/ or also (a more recent extension): http://www.activestate.com/Products/ActiveTcl/
      More details can be found in netnews-group: comp.lang.tcl

      Yacc (optional)

      To compile Spin itself from its sources on a PC, you'll need to have a copy of yacc installed. A public domain version for a Windows PC can most easily be obtained from cygwin, or also from: 
      	ftp://ftp.cs.berkeley.edu/ucb/4bsd/byacc.tar.Z
      A copy of this file is also available in: http://spinroot.com/spin/Bin/index.html (You don't need yacc on the PC if you use the pre-compiled version of Spin for the pc in the pc*.zip file from the distribution) Look at the file make_it.bat for an example on how to perform the compilation.
      On a Unix/Linux/Ubuntu system you can install yacc in the usual way, with apt-get.

      Dot (optional)

      Dot is a graph layout tool developed by Stephen North and colleagues at AT&T (email: north@research.att.com). iSpin can make use of dot to show a graph layout of the state-machines in the automata-view option (recommended!). To obtain Dot, see 
      	http://www.graphviz.org/
      The are both PC and Unix versions of dot available. For documentation of dot see, for instance: 
      	A technique for drawing directed graphs,
	by Gansner, Koutsofios, North and Vo,
	IEEE-TSE, March, 1993.
      If you accept the default installation on a PC, you will need to define the location of dot.exe in the ispin source as follows: 
      	set DOT "C:/Program\\ Files\ATT\Graphviz/bin/dot.exe"
      (the line that sets the location of DOT appears near the top of the ispin.tcl file).

      Etch (optional)

      Etch, short for Enhanced Type CHecker, can perform more thorough static checking than the default SPIN type checker, using type inference to reconstruct types of channels which can only be incompletely specified in Promela. The techniques are described in a SPIN 2005 tool demo paper.
      The Etch tool can be downloaded from: 
      	http://www.doc.ic.ac.uk/~afd/etch/

      TopSpin (optional)

      TopSpin is a symmetry reduction package for Spin, developed by Alastair Donaldson. It can be applied to a Promela model and, provided that the model adheres to some restrictions (detailed in a user manual) uses computational group theory to determine a group of component symmetries associated with the model. The tool can modify the model checking algorithm used by Spin to exploit the symmetries during verification, resulting in reduced memory use and in many cases also shorter verification time. The package can be downloaded from: 
      	http://www.doc.ic.ac.uk/~afd/topspin/

      JSpin (optional)

      jSpin, developed by Moti Ben-Ari, is an alternative to the iSpin GUI written in Java instead of Tcl/Tk. It is meant as a teaching aid. See: 
      	http://stwww.weizmann.ac.il/g-cs/benari/jspin/
      The jSpin tool can be configured for use on Linux and Macs, and can also run under Windows, with or without cygwin installed (e.g., with mingw).
      The jSpin tool can be downloaded from GoogleCode: 
      	http://code.google.com/p/jspin/

      Erigone (optional)

      Erigone, also developed by Moti Ben-Ari, is a reimplementation of a subset of Spin, meant for educational use. Erigone is written in Ada 2005 instead of C. See: 
      	http://stwww.weizmann.ac.il/g-cs/benari/erigone/
      Erigone can be downloaded from GoogleCode: 
      	http://code.google.com/p/erigone/

      SpinJa (optional)

      SpinJa is reimplementation of a subset of Spin in Java, developed by Marc de Jonge at Twente University in The Netherlands. A more detailed description of SpinJa was presented at the 2010 Spin Workshop by Marc de Jonge and Theo Ruys. The tool can be downloaded from: 
      	http://code.google.com/p/spinja/

      Ltl2Ba (optional)

      A faster method to generate very small never claims from LTL formulae, developed by Denis Oddoux and Paul Gastin is available online in source form: 
      	http://spinroot.com/spin/Src/ltl2ba.tar.gz
      The latest version can be obtained from the authors website via: 
      	http://www.lsv.ens-cachan.fr/~gastin/ltl2ba/download.php
See also
	http://www.lsv.ens-cachan.fr/~gastin/ltl2ba/index.php
      The C source code can be linked with Spin, or run as a standalone tool.

      For an overview of related conversion tools see: http://spot.lip6.fr/wiki/LtlTranslationAlgorithms

      Swarm (optional)

      See http://spinroot.com/swarm.

      Runspin and Parsepan (optional)

      Two useful scripts by Theo Ruys, to help with setting up (and remembering) configurations for multiple verification runs:
    Spin HomePage (Page Last Updated: 1 November 2015)
    Spin/Doc/Pan.html0000644000175100017510000006716012641606227011700 0ustar ghgh Pan Verification Options

    Pan

    Verification Options

    Overview

    NAME
    pan - Spin generated source for a model-specific verifier.

    DESCRIPTION
    Overview of options that are available with the verifiers generated by Spin with Spin's run-time option -a. There are two groups of options: those that are available after the verifier source in pan.c has been compiled, and those that are available at compilation time. The reason for the split is that knowledge of some options at compile time can be used to produce a more efficient verification system. Attached is also a brief explanation of the numbers that are printed by the verifiers at the end of a run.

    See V5_Readme for options specific to multi-core verifications with version 5.0 and later.

    Run-Time Options for Pan

    • -A
      suppress the reporting of assertion violations (see also -E)
    • -a
      find acceptance cycles (available if compiled without -DNP) -B
      reserved
    • -b
      bounded search mode, makes it an error to exceed the search depth, triggering and error trail
    • -C
      for models with embedded C code, reproduce error trail in columnated format
    • -cN
      stop at Nth error (defaults to first error if N is absent)
    • -d
      print state tables and stop (-d -d or -d -d -d will print versions of the state tables before additional optimizations are applied)
    • -E
      suppress the reporting of invalid endstate errors (see also -A)
    • -e
      create trails for all errors encountered (default is first one only)
    • -Ffilename
      when compiled with -DSC, names the file to be used for the stack data
    • -f
      add weak fairness (to -a or -l)
    • -g
      for models with embedded C code, reproduce error trail with msc gui support
    • -hN
      choose another hash-function, with N: 1..32 (defaults to 1)
    • -I
      like -i, but approximate and faster
    • -i
      search for shortest path to error (causes an increase of complexity)
    • -J
      reverse the evaluation order of nested unless statements (to conform to the one used in Java)
    • -kN
      set the number of hashfunctions used in bitstate hashing mode to N (bitstate mode) The default is k=2. This option was introduced in version 4.2.0.
    • -LN when compiled -DSCHED, sets a restriction on the max nr of context switches to N (default 10). Introduced in version 5.1.5.
    • -l
      find non-progress cycles (requires compilation with -DNP)
    • -MN
      use N Megabytes for bitstate hash array (bitstate mode)
    • -GN
      use N Gigabytes for bitstate hash array (bitstate mode)
    • -mN
      set max search depth to N steps (default N=10000)
    • -n
      no listing of unreached states at the end of the run
    • -N n
      if more than one LTL property or never claim is defined, use the n-th one. Instead of n also the name of the claim or the LTL property can be used. If only one claim/property appears, or if none are used, then this option is not available.
    • -PN
      for models with embedded C code, reproduce trail, but print only steps from the process with pid N
    • -QN
      set time-limit on execution of N minutes (not in multicore mode)
    • -q
      require empty channels in valid endstates
    • -RSN
      Use N as a seed for the random number generator.
      Can be used in combination with compilation directives -DT_RAND and -DP_RAND (defined under experimental options below) to randomize the search process. N can be any non-negative integer value.
    • -r, -P, -C
      for models with embedded C code, play back error trail (optionally followed by the name of a trailfile, as the next argument)
    • -rN
      play back error trail numbered N
    • -r filename
      play back error trail stored in filename (works also with options -C, -PN, -g and -S).
    • -S
      for models with embedded C code, replay in silent mode, printing only the output from the user-defined printf statements in the model
    • -s
      use 1-bit hashing (default is 2-bit hashing, assumes compilation -DBITSTATE). In version 4.2.0 and later, the option -s is equivalent to -k1.
    • -T
      create trail files in read-only mode (see also -x)
    • -tsuff
      instead of .trail use .suf on trailfiles
    • -U
      reserved
    • -V
      prints the Spin version number, and shows how the pan.c was compiled, then stops.
    • -v
      verbose mode
    • -W
      reserved
    • -wN
      use a hashtable of 2^N entries(defaults to -w23 in bitstate mode and -w19 in exhaustive search mode)
    • -X
      print all stderr output onto stdout instead
    • -x
      do not overwrite an existing trail file
    • -Y and -Z
      reserved
    • -zN [Version 5 and later]
      Set handoff depth for multi-core search to N (default is 20).

    B Compile Time Options for Spin and Pan

    The directives are grouped in eight sets, depending on their main purpose. There are four directives that can be used for compiling the Spin sources itself. These should never be needed by Spin users, only (once) by someone recompiling and installing Spin from its sources.

    Directives for Compiling Spin itself

    NXT if defined, the NEXT operator X can be used in LTL formulae; risky, not compatible with partial order reductions
    PC required when compiling Spin on a PC
    PRINTF if defined, printf statements in the model are enabled during the verification process (not recommended)
    SOLARIS required when compiling Spin on a Solaris system

    The next tables give optional directives for compiling the verifiers that are generated by Spin. Traditionally these are stored in a file named pan.c (with a number of dependent files). Usage of the directives below is always optional, and typically of the form: 

      $ spin -a spec
$ cc -o pan -DNOBOUNDCHECK pan.c
    Each directive modifies the default behavior of the verifier to achieve a specific effect noted in the tables below.

    Directives Supported by Xspin

    BITSTATE use supertrace/bitstate instead of exhaustive exploration
    MEMCNT=N sets upperbound to the amount of memory that can be allocated usage, e.g.: -DMEMCNT=20 for a maximum of 2^20 bytes.
    Use of MEMLIM is preferred.
    MEMLIM=N sets upperbound to the true number of Megabytes that can be allocated; usage, e.g.: -DMEMLIM=200 for a maximum of 200 Megabytes (meant to be a simple alternative to MEMCNT)
    NOCLAIM exclude the never claim from the verification, if present
    NOFAIR disable the code for weak-fairness (is faster)
    NOREDUCE disables the partial order reduction algorithm
    NP enable non-progress cycle detection (option -l), replacing option -a for acceptance cycle detection
    PEG add complexity profiling (transition counts)
    SAFETY optimize for the case where no cycle detection is needed (faster, uses less memory, disables both -l and -a)
    VAR_RANGES compute the effective value range of variables (restricted to the interval 0..255)
    CHECK generate debugging information (see also DEBUG)

    Directives Related to Partial Order Reduction

    CTL allow only those reductions that are consistent with branching time logics like CTL (i.e., the persistent set contains either one or all transitions)
    GLOB_ALPHA consider process death a global action (for compatibility with versions of Spin between 2.8.5 and 2.9.7)
    NIBIS apply a small optimization of partial order reduction (sometimes faster, sometimes not...)
    NOREDUCE disables the partial order reduction algorithm
    XUSAFE disable validity checks of x[rs] assertions (faster, and sometimes useful if the check is too strict, e.g. when channels are passed around as process parameters)

    Other Main Search and Compilation Modes

    BFS use breadth-first, instead of depth-first search
    BFS_DISK in BFS mode, store some of the data on disk
    BFS_DSK_LIMIT=N in BFS mode, max number of states stored per diskfile, default 1 million
    BFS_LIMIT=N in BFS mode, point beyond which states move to disk, default 100,0000
    CYGWIN compile pan.c for 32-bit cygwin
    WIN32 compile pan.c for 32-bit Windows
    WIN64 compile pan.c for 64-bit Windows

    Directives to Increase Speed

    NOBOUNDCHECK don't check array bound violations (faster)
    NOCOMP don't compress states with fullstate storage (faster, but not compatible with liveness unless -DBITSTATE)
    NOFAIR disable the code for weak-fairness (is faster)
    NOSTUTTER disable stuttering rules (warning: changes semantics) stuttering rules are the standard way to extend a finite execution sequence into and infinite one, to allow for a consistent interpretation of B\(u"chi acceptance rules
    SAFETY optimize for the case where no cycle detection is needed (faster, uses less memory, disables both -l and -a)
    SFH
    version 5    		 faster verification of safety properties, sets also NOCOMP (faster, uses slightly more memory, disables both -l and -a)

    Directives to Reduce Memory Use

    BITSTATE use supertrace/bitstate instead of exhaustive exploration
    COLLAPSE a state vector compression mode; collapses state vector sizes by up to 80% to 90% (see Spin97 workshop paper) variations: add -DSEPQS or -DJOINPROCS (off by default)
    FULL_TRAIL
    version 5    		 leaving this directive out significantly reduces memory in multi-core mode, but reduces error-trails to a suffix of the full trail only. adding it restores the capability to generate full error trails.
    Only relevant in mult-core verfications; no effect elsewhere.
    HC a state vector compression mode; collapses state vector sizes down to 32+16 bits and stores them in conventional hash-table (a version of Wolper's hash-compact method -- new in version 3.2.2.) Variations: HC0, HC1, HC2, HC3 for 32, 40, 48, or 56 bits respectively. The default is equivalent to HC2.
    MA=N use a minimized DFA encoding for the state space, similar to a BDD, assuming a maximum of N bytes in the state-vector (this can be combined with -DCOLLAPSE for greater effect in cases when the original state vector is long)
    MEMCNT=N set upperbound to the amount of memory that can be allocated usage, e.g.: -DMEMCNT=20 for a maximum of 2^20 bytes
    MEMLIM=N set upperbound to the true number of Megabytes that can be allocated; usage, e.g.: -DMEMLIM=200 for a maximum of 200 Megabytes (meant to be a simple alternative to MEMCNT)
    SC enables stack cycling. this will swap parts of a very long search stack to a diskfile during verifications. the runtime flag -m for setting the size of the search stack still remains, but now sets the size of the part of the stack that remains in core. it is meant for rare applications where the search stack is many millions of states deep and eats up the majority of the memory requirements.
    SPACE optimize for space not speed

    Directives Reserved for Use When Prompted by Pan

    NFAIR=N allocates memory for enforcing weak fairness usage, e.g.: -DNFAIR=3 (default is 2)
    VECTORSZ=N allocates memory (in bytes) for state vector usage, e.g.: -DVECTORSZ=2048 (default is 1024)
    VMAX=N
    version 5    		 allocates memory (in bytes) for state vector queues in Multicore mode, e.g.: -DVMAX=500 (default is 256) (Can also safely be ignored -- but optimizing the values can increase the number of states that can be accomodated in the handoff queues)
    PMAX=N
    version 5    		 allocates memory (in bytes) for process structures inside queues in Multicore mode, e.g.: -DPMAX=32 (default is 16) (Can also safely be ignored -- but optimizing the values can increase the number of states that can be accomodated in the handoff queues)
    QMAX=N
    version 5    		 allocates memory (in bytes) for chan structures inside queues in Multicore mode, e.g.: -DQMAX=32 (default is 16) (Can also safely be ignored -- but optimizing the values can increase the number of states that can be accomodated in the handoff queues)

    Directives For Debugging Pan Verifiers

    CHECK more frugal debugging printouts (see also -DVERBOSE)
    SDUMP if used in addition to CHECK: adds ascii dumps of state vectors to verbose output (i.e., an ascii version of SVDUMP)
    SVDUMP if defined, adds an option -pN to the runtime verifiers to produce a file sv_dump at the end of the run, with a binary representation of all states, using a fixed size of N bytes per state. (see also SDUMP below)
    VERBOSE adds elaborate debugging printouts (see also -DCHECK)

    Directives For Experimental Use

    ALIGNED on some platforms, to avoid complaints from the runtime system about unaligned data access
    FREQ=N
    version 5    		 changes the frequency of snapshot updates during a run from once every 1000000 states to once every N states
    HASH32
    version 5    		 force the use of 32-bit hash (on 64-bit machine)
    HASH64
    version 5    		 force the use of 64-bit hash (on 32-bit machine)
    JOINPROCS a variant of collapse
    LC to be used in combination with BITSTATE hashing only. it is automatically enabled when -DSC is used in BITSTATE mode. LC forces the use of hashcompact compression for stackstates (instead of the dedault which is full-state storage for states while they are on the search stack, even in bitstate mode). it slows down the search, but can save memory. it uses 4 bytes per state (giving very low probability of collision).
    NO_FAST_C
    version 5    		 supress loop unrolling in compress() function
    NO_RESIZE
    version 5    		 suppress automatic resize of hashtable (bitstate mode)
    NOVSZ risky - removes 4 bytes from state vector - its length field. in most cases this is redundant - so when memory is tight in fullstate storage, try this mode. if the number of states stored changes when -DNOVSZ is used, the information wasn't redundant... (safety checks will still be valid, but liveness checks may then fail) NOVSZ cannot be combined with COLLAPSE
    NSUCC
    version 5    		 computes the average fanout of states in the statespace and prints a summary at the end of the run
    ON_EXIT=fct() optional function to call just before pan exits
    P_RAND=N
    version 5.2.5    		 randomize order in which processes are scheduled, using (optional) seed N
    the seed can also be set (or changed) with pan runtime option -RSN
    the value provided can be any non-negative integer
    (See also T_RAND)
    PRINTF enables printfs during verification runs (Version 2.8 and later -- earlier versions always left these enabled)
    PUTPID
    version 5.1.5    		 include the process pid number in trailfile names
    RANDSTORE when in BITSTATE mode, use for instance -DRANDSTORE=33 to reduce the probability of storing the bits in the hasharray to 33%. the value assigned must be between 0 and 99 low values increase the amount of work done (time complexity) and increase the effective coverage for large state spaces. most useful in sequential bitstate hashing runs to improve the accumulative coverage of all runs significantly
    REACH guarantee absence of errors within the -m depth-limit (described in more detail in Newsletter 4 and in the V2.Updates notes for Version 2.2.)
    REVERSE
    version 5.1.4    		 reverse the order in which process interleavings are explored
    (see also T_RAND, P_RAND, SCHED, and T_REVERSE
    R_XPT in combination with MA, restart a verification run from the last checkpoint file written, can be combined with W_XPT
    SCHED
    version 5.1.5    		 restrict the maximum number of process context switches (using pan runtime option -L)
    T_RAND=N
    version 5.2.5    		 randomize order in which transitions are explored, using (optional) seed N
    the seed can also be set (or changed) with pan runtime option -RSN
    the value provided can be any non-negative integer
    (See also P_RAND)
    T_REVERSE
    version 5.1.5    		 reverse order in which transitions are explored (See also T_RAND, and REVERSE)
    W_XPT=N in combination with MA, write checkpoint files every multiple of N states stored
    ZAPH in bitstate mode, reset the hash array to empty each time it becomes half full

    C Pan's Output Format

    A typical printout of a verification run is as follows: This is what each line in this listing means: 
    	(Spin Version 3.0 -- 21 July 1997)
    Identifies the version of Spin that generated the pan.c source from which this verifier was compiled. 
    		+ Partial Order Reduction
    The plus sign means that the default partial order reduction algorithm was used. A minus sign would indicate compilation for exhaustive, non-reduced, verification with option -DNOREDUCE . 
    	Full statespace search for:
    Indicates the type of search. The default is a full statespace search. Large models can also be verified with a Bitstate search, which is approximate. 
    		never-claim         	- (none specified)
    The minus sign indicates that no never claim, or LTL fomrula was used for this run. If a never claim was part of the model, it could have been suppressed with the compiler directive -DNOCLAIM . 
    		assertion violations	+
    The plus indicates that the search checked for violations of user specified assertions, which is the default. 
    		acceptance   cycles 	- (not selected)
    The minus indicates that the search did not check for the presence of acceptance or non-progress cycles. To do so would require a run-time option -a or compilation with -DNP combined with the run-time option -l. 
    		invalid endstates	+
    The plus indicates that a check for invalid endstates was done (i.e., for absence of deadlocks). 
    	State-vector 32 byte, depth reached 13, errors: 0
    The complete description of a global system state required 32 bytes of memory (per state). The longest depth-first search path contained 13 transitions from the root of the tree (i.e., from the initial system state). No errors were found in this search. 
    	      74 states, stored
    A total of 74 unique global system states were stored in the statespace (each represented effectively by a vector of 32 bytes). 
    	      30 states, matched
    In 30 cases did the search return to a previously visited state in the search tree. 
    	     104 transitions (= stored+matched)
    A total of 104 transitions were explored in the search, which can serve as a statistic for the amount of work that has been performed to complete the verification. 
    	       1 atomic steps
    One of the transitions was part of an atomic sequence, all others were outside atomic sequences. 
    	hash conflicts: 2 (resolved)
    In 2 cases the default hashing scheme (a weaker version than what is used in bitstate hashing) encountered a collision, and had to place the states into a linked list in the hash-table. 
    	(max size 2^18 states)
    The (perhaps default) argument that was specified for the size of the hash-table was 2^18; equivalent to a run-time option -w18. 
    	1.533 	memory usage (Mbyte)
    Total memory usage was 1.533 Megabytes, including the stack, the hashtable, and all related data structures. Memory use would go down for smaller than the default choices for run-time options -m and -w, which could in this case, with only 74 reachable states of 32 bytes each, considerably reduce memory use. 
    	unreached in proctype ProcA
		line 7, state 8, "Gaap = 4"
		(1 of 13 states)
	unreached in proctype :init:
		line 21, state 14, "Gaap = 3"
		(1 of 19 states)
    A listing of the state numbers and approximate line numbers for the basic statements in the specification that were not reached. Since this is a full statespace search that ran to completion this means that these transitions are effectively unreachable (dead code).
    Spin Online References
    Promela Manual Index
    Spin HomePage     		(Page Updated: 10 July 2011)
    Spin/Doc/Spin.html0000644000175100017510000002745212641606227012073 0ustar ghgh Spin Run-Time Options

    Spin

    Run-Time Options

    Overview

    NAME
    spin - verification tool for models of distributed systems

    SYNTAX
    spin [options] file
    spin -V

    DESCRIPTION
    Spin is a tool for analyzing the logical consistency of asynchronous systems, specifically distributed software and communication protocols. A verification model of the system is first specified in a guarded command language called Promela. This specification language, described in the reference, allows for the modeling of dynamic creation of asynchronous processes, nondeterministic case selection, loops, gotos, local and global variables. It also allows for a concise specification of logical correctness requirements, including, but not restricted to requirements expressed in linear temporal logic.

    Given a Promela model stored in file , Spin can perform interactive, guided, or random simulations of the system's execution. It can also generate a C program that performs an exhaustive or approximate verification of the correctness requirements for the system.

    Simulation Options

    With only a filename as an argument and no option flags, Spin performs a random simulation of the model specified in the file (standard input is the default if the filename is omitted). This normally does not generate output, except what is generated explicitly by the user within the model with printf statements, and some details about the final state that is reached after the simulation completes. A first group of option flags can be used to set the desired level of information that the user wants to see in a random, guided, or interactive simulation run. Every line of output normally contains a reference to the source line in the specification that generated it. If option -i is added, the simulation is interactive, or if option -t is added, the simulation is guided.

    • -B Suppresses the verbose printout at the end of a simulation run (giving process states etc.).
    • -b Suppresses the execution of printf statements within the model (see also -T).
    • -c Produce an ASCII approximation of a message sequence chart for a random or guided (when combined with -t) simulation run. See also option -M.
    • -g Shows at each time step the current value of global variables (see also -w).
    • -i Perform an interactive simulation, prompting the user at every execution step that requires a nondeterministic choice to be made. The simulation proceeds without user intervention when execution is deterministic.
    • -jN Skip the first N steps of a random or guided simulation. (See also option -uN.)
    • -l In combination with option -p, shows the current value of local variables of the process (see also -w).
    • -M Produce a message sequence chart in Postscript form for a random simulation or a guided simulation (when combined with -t), for the model in file , and write the result into file.ps . See also option -c.
    • -nN Set the seed for a random simulation to the integer value N. There is no space between the -n and the integer N. -p, shows the current value of local variables of the process.
    • -p Shows at each simulation step which process changed state, and what source statement was executed.
    • -qN In columnated output (option -c) and elsewhere, suppress the printing of output for send or receive operations on the channel numbered N.
    • -r Shows all message-receive events, giving the name and number of the receiving process and the corresponding the source line number. For each message parameter, show the message type and the message channel number and name.
    • -s Shows all message-send events.
    • -T Suppress the default indentation of output from print statements. By default the output from process i is indented by i spaces. See also option -b.
    • -t[N] Perform a guided simulation, following the error trail that was produces by an earlier verification run, see the online manuals for the details on verification. If an optional number is attached (no space between the number and the -t) the error trail with that sequence number is opened, instead of the default trail, without sequence number.
    • -uN Stop a random or guided simulation after the first N steps. (See also option -jN.)
    • -v Verbose mode, adds some more detail, and generates more hints and warnings about the model.
    • -w Even more verbose output with options -l and -g (e.g., prints all variable values, not just those that change).

    Generate, Compile, and Run

    • -search Generate the verifier source code in pan.c (like -a does) and immediately compile and execute the verifier. Options that follow the -search argument are passed through to the compiler (options starting with -[ODUE] or to the verifier as runtime flags (all other options).
      Options to Spin itself, for parsing the Promela specification (e.g., macro definitions), should precede the -search argument.
      Options that can follow the -search argument include: 
      	-bfs, -bfspar, -bcs, -ltl name, -safety, -noclaim, -bitstate, -hc, -collapse, -i, -l, -a

    Verifier Generation Related

    • -a Generate a verifier (model checker) for the specification. The output is written into a set of C files, named pan.[ cbhmt ] that can be compiled, (e.g., cc pan.c ) to produce an executable verifier. The online Spin manuals (see below) contain the details on compilation and use of the verifiers.
    • -A Perform property-based slicing, warning the user of all statements and data objects that are likely to be redundant for the stated properties (i.e., in assertions and never claims).
    • -d Produce symbol table information for the model specified in file . For each Promela object this information includes the type, name and number of elements (if declared as an array), the initial value (if a data object) or size (if a message channel), the scope (global or local), and whether the object is declared as a variable or as a parameter. For message channels, the data types of the message fields are listed. For structure variables, the 3rd field defines the name of the structure declaration that contains the variable.
    • -F file This behaves identical to option -f but will read the formula from the file instead of from the command line. The file should contain the formula as the first line. Any text that follows this first line is ignored, so it can be used to store comments or annotation on the formula. (On some systems the quoting conventions of the shell complicate the use of option -f. Option -F is meant to solve those problems.)
    • -f LTL Translate the LTL formula LTL into a never claim.
      This option reads a formula in LTL syntax from the second argument and translates it into Promela syntax (a never claim, qhich is Promela's equivalent of a Buchi Automaton). The LTL operators are written: [] (always), <> (eventually), and U (strong until). There is no X (next) operator, to secure compatibility with the partial order reduction rules that are applied during the verification process. If the formula contains spaces, it should be quoted to form a single argument to the Spin command. As the name suggests, a Spin never claim is used to specify behavior than is required to be impossible, i.e., behavior that would violate a user-specified property. This means that to check for compliance with an LTL formula, the formula must be negated explicitly before it is converted into a never claim. Negating an LTL formula is easy: just place the formula "f" in parentheses and negate it: "!(f)".
    • -J Reverse the evaluation order of nested 'unless' statements (so that it conforms to the evaluation order of nested 'catch' statements in Java).
    • -m Changes the semantics of send events. Ordinarily, a send action will be (blocked) if the target message buffer is full. With this option a message sent to a full buffer is lost.
    • -N filename add the never claim stored in filename.
    • -S1 and -S2 separate pan source for claim and model (see book for details).
    • -V Prints the Spin version number and exits.

    Optimization

    The following group of options controls which optimizations are enabled or disabled for verifier generation. By default most of the important optimizations are enabled.
    • -o1 disable dataflow-optimizations in verifier. this marks variables as temporarily dead when they cannot be read before written. their value is then reset to zero, in an attempt to avoid redundant values in the state-vector. in rare cases, this option can increase complexity (by adding the zero value where it did not appear before).
    • -o2 disable dead variables elimination in verifier (should never be necessary, other than to confirm its effect on the length of the state vector and reduction of memory requirements).
    • -o3 disable statement merging in verifier. this option can make it harder to read the pan -d output (of the internal state machines used in the verifier). disabling it restores the old, more explicit, format, but loses the advantage of statement merging during model checking.
    • -o4 enable rendez-vous optimizations (experimental). this attempts to precompute the feasibility of a rendez-vous operation, rather than letting the model checker determine this at run-time. we have been unable to see a positive effect on runtime when this option is enabled, so it is likely to disappear again.
    • -o5 disable case caching (having this option enabled makes smarter use of the case-statements in the pan.m and pan.b files, and allows for faster compilation times; disable only when bugs are encountered).
    • -o6 revert to the old rules for interpreting priority tags (pre version 6.2)
    • -o7 revert to the old rules for semi-colon usage (pre version 6.3)

    SEE ALSO

    More background information on the system and the verification process, can be found in:

    Spin Online References
    Promela Manual Index
    Spin HomePage     		(Page Updated: 11 May 2014)
    Spin/Doc/Intro.html0000644000175100017510000007327712641606227012263 0ustar ghgh Promela Reference -- Intro

    Promela

    Document Structure

    Intro

    INTRODUCTION
    Five parts of the Promela language are discussed in separate sections of this manual. A sixt section gives a brief motivation for things that are intentionally outside the language. The sections are:

    • 1. Meta Terms (translated by preprocessors into vanilla Promela)
    • 2. Declarators (for defining process, channel, and data objects)
    • 3. Control Flow Constructors (separators, compound statements, jumps, labels, etc.)
    • 4. Basic Statements (such as send, receive, assignment, etc.)
    • 5. Predefined Functions and Operators (such as len, run, nempty, etc.)
    • 6. Omissions (such as floating point, probabilities, etc.)

    References to terms defined in this manual are linked to the corresponding manual page, e.g. send, len.

    In the tradition of the Unix manuals, each manual page that follows this introduction contains some or all of the following defining elements.

    • NAME
      A one sentence synopsis of the construct and its main purpose.
    • SYNTAX
      In the syntax rules text is reproduced as it is typed. Optional terms are enclosed in (non-quoted) square brackets. The Kleene star * is used to indicate zero or more repetitions of an optional term. When the special symbols '[', ']', '*', appear as literals, they are quoted. For instance, in 
      chan name = '[' const ']' of { typename [ , typename ] * }
      the first two square brackets are literals, and the last two enclose an optional part of the definition.

    All terms set in italic , such as name , const, and typename , refer to the grammar rules.

    • EXECUTABILITY
      In Section 4, defines all conditions that must be satisfied for a basic statement to be eligible for execution. Some standard parts of this condition are implied, and not repeated throughout. One such implied condition is, for instance, that there is a process that has reached the point in its code where the basic statement is defined. Implied conditions of this type are defined in the section titled Semantics below. If the executability clause is described as True , no conditions other than the implied conditions apply.
    • EFFECT
      In Section 4, defines the effect that the execution of a basic statement will cause on any data, channel, or process objects. One standard part of the effect is implied, and not repeated everywhere: the execution of the statement may change the local state of the executing process. If the effect clause is described as None , no effect other than the implicit change in local state is defined. See also the description under Semantics below.
    • DESCRIPTION
      Describes in informal terms what the purpose and use is of the language element being defined.
    • EXAMPLES
      Gives some typical applications of the construct.
    • NOTES
      Adds some additional notes about special circumstances or cautions.
    • SEE ALSO
      Gives references to other parts of this reference manual that may provide additional explanations.

    SEMANTICS
    The semantics of the language is defined in terms of an operational model. The model contains one or more ``processes,'' zero or more ``variables,'' zero or more message ``channels,'' and a ``semantics engine'' that defines how the actions of the processes may be interleaved in time. The processes are defined by labeled transition systems, which are in turn derived from proctype declarations. Similarly, the domains of values that variables can hold are derived from variable type declarations.

    The semantics engine executes the model in a step by step manner. In each step, one executable basic statement is selected at random. To determine if a statement is executable or not, one of the conditions that must be evaluated is the corresponding executability clause, as described in this manual. For the selected statement, the effect clause from the statement is then applied, as also described in this manual, and the current state of the process that contained the statement is updated. The semantics engine continues executing statements until no executable statements remain, which happens if either the number of active processes goes to zero, or when a valid or invalid end-state is reached.

    Declarators, defined in Section 2, define the basic elements of the system. Control flow statements, defined in Section 3, affect only the structure of the underlying transition system. Basic statements, defined in Section 4, are the only language elements that define state changes. Smaller building blocks for the system, such as predefined variables and functions, are defined in Section 5.

    Central to the operational semantics definition is the description of the semantics engine that defines when and how statements may be executed. Before giving the definition of this engine, we give a definition of the formal objects that this engine manipulates: variables, message channels, and processes. We also define what the main component of a transition and of a global system state are. Not defined here are more basic terms, such as sets , identifiers , integers , and Booleans .

    • (S.1) A variable is a tuple {name,scope,domain,inival,curval}
      where
      • name is an identifier that is unique within scope ,
      • scope is defined by an integer (see below).
      • domain is a finite set of integer s.
      • inival , the initial value, is an integer within domain , and
      • curval , the current value, is an integer within domain .

    In the remainder of this section we refer to the elements of a tuple with a dot notation. For instance, if v is a variable, then v.scope is its scope.

    The scope of a variable either identifies all active processes (for globally declared variables) or one specific active process. For the purposes of this definition, we can assume that a positive integer identifies the pid (S.4) of one active process, and a negative integer identifies all active processes. The type of a variable determines its domain . For instance, a variable of type bit (see datatypes) has domain {0,1}.

    • (S.2) A message is an ordered set of variables (S.1).
    • (S.3) A channel is a tuple {ch_id,nslots,contents}
      where
      • ch_id is an integer (see below),
      • nslots is an integer , and
      • contents is an ordered set of messages (S.2) with maximum cardinality nslots .

    A positive ch_id will be used to identify an active channel , while a negative number will identify a channel template from which more channels of the same type may be instantiated. Note that the definition of a channel does not contain a scope , like the definition of a variable. The reason is that a channel always has global scope. It can be created either globally or locally, by an active process, but its method of creation will not affect its scope in Promela, i.e., every channel is in principle accessible to every active process, by knowledge of the identifying ch_id .

    • (S.4) A process is a tuple {pid,lvars,lstates,initial,curstate,trans}
      where
      • pid is an integer (see below),
      • lvars is a finite set of variables (S.1), each with scope=pid ,
      • lstates is a finite set of integers (see below),
      • initial and curstate are elements of set lstates , and
      • trans is transition relation (S.5) defined on lstates .
      For the purpose of definition S.4, we can assume that a positive value of pid identifies an active process , while a negative value for the pid field identifies a process template from which extra active processes of the same type may be instantiated. In the initial state of a newly instantiated process (see active, run) curstate=initial , and all elements of lvars have curval=inival .

    We will refer to the elements of set lstates as the local states of a process (S.4). The integer values suffice to uniquely identify each state within the set, but hold no more information.

    • (S.5) A transition relation is a finite set of tuples {tr_id,source,target,cond,effect,prty,rv}
      where
      • tr_id is a non-negative integer ,
      • source and target are local states (i.e., integer s),
      • cond is a Boolean condition on the global system state (S.6),
      • effect is a function that modifies the global system state (S.6),
      • prty and rv are integer s.

    The elements prty and rv are used in cond and effect definitions to enforce the semantics of, respectively, the unless construct, and of synchronous message passing operations, see send.

    • (S.6) A global system state is a tuple of the form {gvars,procs,chans,exclusive,handshake,timeout,else,stutter}
      where
      • gvars is a finite set of global variables (S.1), each with scope=-1 ,
      • procs is a finite set of active processes (S.4), each with pid>0 ,
      • chans is a finite set of channels (S.3), each with ch_id>0 ,
      • exclusive , and handshake are integer s, and
      • timeout , else , and stutter are Boolean s.
    • In the initial system state all elements of procs are in their initial state (see S.4), all elements of gvars have curval=inival (see S.1), all elements of chans have contents={} (i.e., the empty set) (see S.3), exclusive and handshake are zero, and timeout and else are False . The initial value of stutter is also False . (It can be set to True only by the verifier, when it replaces the default check for safety properties with a check for liveness properties.)

    The definitions S.1 to S.6 capture the minimal information that is needed to define the semantics of the Promela language in terms of an operational model, with processes defined as transition systems. The purpose of the definition of the semantics engine in the next subsection is to offer a mechanism for resolving questions about the interpretation of Promela constructs that is independent of the Spin tool.

    OPERATIONAL MODEL, SEMANTICS ENGINE
    The semantics engine executes the system, at least conceptually, in a stepwise manner: selecting and executing one basic statement at a time. At the highest level of abstraction, the behavior of this engine can be defined as follows.

    Let E be a set of pairs { p,t }, with p a process, and t a transition. Let executable(s) be a function, yet to be defined, that returns a set of such pairs, one for each executable transitions in system state s . The semantics engine then performs as follows. 

      1 while ((E = executable(s)) != {})
  2 {
  3 	for some {p,t} from E
  4 	{	s' = apply(t.effect, s)
  5 
  6 		if (handshake == 0)
  7 		{	p.curstate = t.target
  8 			s = s'
  9 		} else
 10 		{	# try to complete an rv handshake
 11 			E' = executable(s')
 12 			# if E' is {}, s remains unchanged
 13 
 14 			for some {p',t'} from E'
 15 			{	p.curstate = t.target
 16 				s = apply(t'.effect, s')
 17 				p'.curstate = t'.target
 18 			}
 19 			handshake = 0
 20 	}	}	
 21 }
 22 while (stutter) { s = s }	/* the 'stutter' extension */
    As long as there are executable transitions (corresponding to the basic statements of Promela), the semantics engine will select one of them at random and execute it.

    To verify liveness properties with Spin, we must be able to treat finite executions as special cases of infinite executions. The standard way of doing so is to define a stutter extension of finite executions, where the final state is repeated ad infinitum. The semantics engine above uses the system variable stutter to determine if the stuttering rule is in effect. Only the verification system can change this variable. More on verification, which is strictly seen outside the semantics definition, follows at the end of these notes.

    The function apply() applies the effect of the selected transition to the system state, possibly modifying system and local variables, the contents of channels, or even the values of exclusive and handshake , as defined in the effect clauses from atomic, and send, respectively. If no rendezvous offer was made (line 6), the current state of the process that executed the transition is updated (line 7), and the global state change takes effect by an update of the system state itself (line 8). If a rendezvous offer was made in the last transition, it cannot result in a global state change unless the offer can also be accepted (cf. send). On line 11 the transitions that have now become executable are selected. The definition of the function executable() below guarantees that this set can only contain accepting transitions for the given offer. If there are none, the global state change is declined, and execution proceeds with the selection of a new executable candidate transition from the original set E . If the offer can be matched, the global state change takes effect. The current states of both processes are now updated from source to target state (where the two may, of course, be equal).

    The main part of the semantics definition is in the definition of what precisely constitutes an executable transition. One part will be clear: in the current system state the executability clause t.cond must be satisfied. But there is more.

    The following specification of the function executable() resolves these issues. To avoid confusion, the state variables timeout, else and exclusive are set in bold. These variables are the only ones that can be modified within this function, as part of the selection process. 

      1 Set
  2 executable(State s)
  3 {	new Set E
  4 	new Set e
  5 
  6 	E = {}
  7 	timeout = False
  8 AllProcs:
  9 	for each active process p
 10 	{	if (exclusive == 0
 11 		or  exclusive == p.pid)
 12 		{	for u from high to low	# priority ('unless')
 13 			{	e = {};  else = False
 14 OneProc:			for each transition t in p.trans
 15 				{	if (t.source == p.curstate
 16 					and t.prty == u
 17 					and (handshake == 0
 18 					or   handshake == t.rv)
 19 					and  eval(t.cond) == True)
 20 					{	add {p,t} to set e
 21 				}	}
 22 				if (e != {})
 23 				{	add all elements of e to set E
 24 					break	# on to next process
 25 				} else if (else == False)
 26				{	else = True
 27					goto OneProc
 28				} # or else lower the priority
 29 	}	}	}
 30 
 31 	if (E == {} and exclusive != 0)
 32 	{	exclusive = 0
 33 		goto AllProcs
 34 	}
 35 	if (E == {} and timeout == False)
 36 	{	timeout = True
 37 		goto AllProcs
 38 	}
 39 
 40 	return E	# defining the set of executable transitions
 41 }
    For a transition to be added to the set of executable transitions it has to pass a number of tests.
    • The test on line 10-11 checks the value of the system variable exclusive . By default it is zero, and the semantics engine itself will never change the value to non-zero. Any transition that is part of an atomic sequence (see atomic) will set exclusive to the value of the p.pid , to make sure that the sequence is not interrupted by other processes, unless the sequence itself blocks. In the latter case the semantics engine will restore the defaults (line 32).
    • The test on line 16 checks the priority level, set on line 12. Within each process, the semantics engine selects the highest priority transitions that are executable. Note that priorities can affect the selection of transitions within a process, not between processes. Priorities are defined in Promela with the unless construct, see unless.
    • The test on line 15 matches the source state of the transition in the labeled transition system with the current state of the process, selected on line 9.
    • The test on line 17-18 makes sure that either no rendezvous offer is outstanding, or, if one is, that the transition being considered can accept the offer on the corresponding rendezvous port.
    • The test on line 19, finally, checks if the executability condition for the transition itself is satisfied.

    If no transitions are found to be executable with the default value False for system variable else, the transitions of the current process are checked again, this time with else equal to True (line 26-27). If no transitions are executable in any process, the value of system variable timeout is changed to True and the entire selection process is repeated (line 32-35). The new value of timeout will stick for just one step (line 7), but it can cause any number of transitions in any number of processes to become executable in the current global system state. The syntax of Promela prohibits the use of both else and timeout within a single condition statement.

    Note that the semantics engine does not establish the validity or invalidity of correctness requirements.

    INTERPRETING PROMELA SEMANTICS
    The basic objects that are manipulated by the semantics engine we have defined above are, of course, intended to correspond to the basic objects of a Promela specification. Much of the language, however, merely provides a convenient mechanism for dealing with the underlying objects. Section 1 of this manual, for instance, describes some ``pseudo'' language features, or meta-terms, that are translated into Promela proper by preprocessors. Section 2 defines the Promela syntax for declaration of variables, processes, and channels. Section 3 defines how Promela's control-flow constructs correspond to the underlying transition relations. An if statement, for instance, merely defines how multiple transitions can exit from the same local process state. The semantics engine does not have to know anything about if , do , break , or goto ; it merely deals with local states and transitions.

    Some Promela constructs cannot be translated away. The semantics model is defined in such a way that these primitive constructs correspond directly to the transitions as defined in S.5. We call these Promela constructs basic statements . Section 4 defines the transition elements for each basic statement in the language. Section 5 of this manual, together with the grammar definition, defines the remaining Promela syntax rules for the elements of a basic statement.

    THREE EXAMPLES
    Consider the following Promela system. 

    chan x = [0] of { bit };
chan y = [0] of { bit };
active proctype A() { x?0 unless y!0 }
active proctype B() { y?0 unless x!0 }
    Only one of two possible rendezvous handshakes can take place. Do the semantics rules tell us which one? If so, can the same rules also resolve the following, very similar, situation? 
    chan x = [0] of { bit };
chan y = [0] of { bit };
active proctype A() { x!0 unless y!0 }
active proctype B() { y?0 unless x?0 }
    And, finally, what should we expect to happen in this case. 
    chan x = [0] of { bit };
chan y = [0] of { bit };
active proctype A() { x!0 unless y?0 }
active proctype B() { y!0 unless x?0 }
    Each of these cases can be hard to resolve without guidance from a semantics definition. The semantics rules for handling rendezvous communication and for handling unless statements seem to conflict here. This is what we know.
    • The definition of unless states that the statement that precedes the unless keyword has a lower execution priority than the statement that follows it. These priorities must be used to resolve executability conflicts between the two transitions within each process.
    • Rendezvous handshakes occur in two parts: the send statement constitutes a rendezvous offer, which can succeed if it is matched by a receive operation on the same channel in the immediately following execution step by the other process. To make the offer, the send statement must be executable by the rules of the semantics engine, and to accept the offer the matching receive operation must be executable.
    • The effect clause of the rendezvous send operation, send, states that the value of handshake will be set the value of ch_id for the channel used. Lines 17-18 in the semantics engine then imply that no statement can now be executed unless it has the rv parameter on that transition set to the same value, which is only the case for receive operations that target the same channel. A global state transition in the main execution loop of the semantics engine can only take place for rendezvous operations if the offer can be accepted.

    We are now ready to resolve the semantics questions for each of the three cases.

    In the first example , according to the priority rule enforced by the unless operator, two statements will be executable in the initial state: x!0 and y!0 . Either one could be selected for execution. If the first is executed, we enter a rendezvous offer, with handshake set to the ch_id of channel x . In the intermediate global state s' then reached (line 11-18 in the main execution loop of the semantics engine), only one statement can be added to set E' , namely x?0 . The final successor state will have handshake == 0 and both processes in their final state. Alternatively, y!0 could be selected for execution, with an analogous result.

    In the second example , only one statement is executable in the initial system state: y!0 , and only the corresponding handshake can take place.

    In the third example , the first two statements considered, at the highest priority, are both unexecutable. One priority level lower, though, two statements become executable: x!0 and y!0 , and the resulting two system executions are again analogous to those from the first example.

    NOTES ON VERIFICATION
    The addition of a verification option does not affect the semantics of a Promela model as it is defined here. Note, for instance, that the semantics engine does not include any special mention or interpretation of end states, accepting states, non-progress states, or assertions, and it does not include a definition for the semantics of a never claim. The reason is that these language elements have no formal semantics within the model: they cannot be used to define any part of the behavior of a model.

    Assertions, special labels, and never claims are used for making meta statements about the semantics of a model. The verifier determines how such meta statements are to be interpreted.

    When the verifier checks for safety properties, it is interested in cases where an assert statement can fail, or in the presence of finite executions with a final state that violate some proper termination condition (e.g., with all processes in a valid end-state, and all message channels empty). The predefined system variable stutter, used in the definition of the semantics engine on line 22, is set to False in this case, and any mechanism can be in principle used to generate the executions of the system, in search of the violations.

    When the verifier checks for liveness properties, it is interested in the presence of infinite executions that either contain finitely many traversals of user-defined progress states, or infinitely many traversals of user-defined accept states. The predefined system variable stutter, used in the definition of the semantics engine on line 22, is set to True in this case, and, again, any mechanism can be used to generate the infinite executions, as long as it conforms to the semantics as defined before.

    THE NEVER CLAIM
    For purposes of verification it is not necessary that indeed all finite or infinite executions that comply with the formal semantics are also generated. In fact, the verifier Spin will make every effort to avoid generating all possible executions, and instead concentrate its efforts on a minimal set of executions that could possibly produce counter-examples. This is where the never claim comes in: the never claim does not define new semantics, but is used to identify that part of the existing semantics that violates an independently stated correctness criterion.

    The interpretation of the never claim by the verifier in the context of the semantics engine is as follows. Note that the purpose of the claim is to suppress the inspection of executions that could not possibly lead to a counter-example. To accomplish this, the verifier will reject some valid executions as soon as possible. The evaluation whether an execution should be rejected or continued can happen in two places: at line 2 of the semantics engine, and at line 22. 

      1 while ((E = executable(s)) != {})
 *2 {	if (check_fails()) Stop;
  3 	for some {p,t} from E
    . . .
 21 }
*22 while (stutter) { s = s; if (check_fails()) Stop; }
    The check is implemented in Spin as a check to see if the never claim automaton can execute at least one more transition. When the claim is generated from an LTL formula, all its transitions are condition statements, formalizing atomic propositions on the global system state. Only infinite executions that are consistent with the formal semantics of the model and with the constraint expressed by the never claim can now be generated.

    With or without a constraint provided by a never claim, a verifier hunting for violations of liveness properties can check infinite executions for those that constitute counter-examples to a correctness property. The precise method that the verifier uses to recognize and report those infinite executions is of course critical to the verification process, but irrelevant to the Promela semantics definition given here.

    Spin Online References
    Promela Manual Index
    Promela Grammar
    Spin HomePage     		(Page Updated: 28 November 2004)
    Spin/Doc/V6.Updates0000644000175100017510000012530512641606227012112 0ustar ghghDistribution Update History of the SPIN sources =============================================== ==== Version 6.0 - 5 December 2010 ==== The update history since 1989: Version 0: Jan. 1989 - Jan. 1990 5.6K lines: original book version Version 1: Jan. 1990 - Jan. 1995 7.9K lines: first version on netlib Version 2: Jan. 1995 - Aug. 1997 6.1K lines: partial-order reduction Version 3: Aug. 1997 - Jan. 2003 17.9K lines: bdd-like compression (MA) Version 4: Jan. 2003 - Oct. 2007 28.2K lines: embedded c-code, bfs Version 5: Oct. 2007 - Dec. 2010 32.8K lines: multi-core & swarm support Version 6: Dec. 2010 - 36.8K lines: inline ltl formula, parallel bfs Version 6.4.4: 2015 - 39.6K lines ==== Version 6.0.0 - 5 December 2010 ==== the main improvements in Spin version 6 are: - support for inline specification of LTL properties: Instead of specifying a never claim, you can now specify LTL formulae directly inside a verification model. Any number of named LTL formulae can be listed and named. The formulae are converted by Spin into never claims in the background, and you can choose which property should be checked for any run using a new pan runtime parameter pan -N name. Example: ltl p1 { []<>p } ltl p2 { <> (a > b) implies len(q) == 0 } There are a few additional points to note: - Inline LTL properties state *positive* properties to prove, i.e., they do not need to be negated to find counter-examples. (Spin performs the negation automatically in the conversions.) - You can use any valid Promela syntax to specify the predicates (state properties). See, for instance, the use of expressions (a>b) and (len(q) == 0) in the examples above. So it is no longer needed to introduce macros for propositional symbols. - White space is irrelevant -- you can insert newlines anywhere in an LTL block (i.e., in the part of the LTL formula between the curly braces). - You can use textual alternatives to all temporal and some propositional operators. This includes the terms always, eventually, until, weakuntil, stronguntil, implies, equivalent, and release (the V operator), which are now keywords. So the first formula (p1) above could also be written as: ltl p1 { always eventually p /* maybe some comment here */ } - Improved scope rules: So far, there were only two levels of scope for variable declarations: global or proctype local. Version 6 adopts more traditional block scoping rules: for instance, a variable declared inside an inline definition or inside an atomic or non-atomic block now has scope that is limited to that inline or block. You can revert to the old scope rules by using spin -O (the capital letter Oh) - New language constructs: There are two new language constructs, that can simplify the specification of common constructs: 'for' and 'select'. Both are implemented as meta- terms, which means that they are translated by the parser into existing language constructs (using 'do' or 'if'). The new 'for' construct has three different uses: for (i : 1 .. 9) { printf("i=%d\n", i) } simply prints the values from 1 through 9, meaning that the body of the for is repeated once for each value in the range specified. int a[10]; for (i in a) { printf("a[%d] = %d\n", i, a[i]) } is a way to repeat an fragment of code once for each element in an array. In the example above, the printf will be executed once for each value from 0 through 9 (note that this is different from the first example). This works for any array, independent of its type. The last use of the for is on channels. typedef utype { bin b; byte c; }; chan c = [10] of { utype }; utype x; for (x in c) { printf("b=%d c=%d\n", x.b, x.c) } which retrieves each message in the channel and makes it available for the enclosed code. In this case, the channel (c above) must have been declared with a single parameter, the type of which must match the variable type specified in the for statement (the name before the 'in' keyword). [Note that with the introduction of the new keyword 'in' some early Spin models may now have syntax errors, if 'in' is used as a variable name.) The second new language statement is 'select' and its use is illustrated by this example: int i; select (i : 1..10); printf("%d\n", i); Select non-deterministically picks a value for i out of the range that is provided. - Multiple never claims: Other than multiple and named inline LTL properties, you can also include multiple explicit (and named) never claims in a model. The name goes after the keyword 'never' and before the curly brace. As with inline LTL properties, the model checker will still only use one never claim to perform a verification run, but you can choose on the command line of pan which claim you want to use: pan -N name - Synchronous product of claims: If multiple never claims are defined, you can use spin to generate a single claim which encodes the synchronous product of all never claims defined, using the new option: spin -e spec.pml (this should rarely be needed). - Dot support: A new option for the executable pan supports the generation of the state tables in the format accepted by the dot tool from graphviz: pan -D The older ascii format remains available as pan -d. - Standardized output: All filename / linenumber references are now in a new single standard format, given as filename:linenumber, which allows postprocessing tools to easily hotlink such references to the source. This feature is exploited by the new replacement for xspin, called ispin that will also be distributed soon. Smaller changes: - bugfix for line numbers being reported incorrectly in reachability reports - all filename linenumber references unified as filename:linenr ==== Version 6.0.1 - 16 December 2010 ==== - fixed a bug in the implementation of the new 'for' and 'select' statements where the end of the range could be one larger than intended. - extend the implementation of the new for and select meta-statements to allow expressions for the start and end value of the ranges - when executing on Windowns without cygwin, better treatment of filenames with backslashes, avoiding that the backslash is interpreted as an escape in the pan.h source - fix small problem in generation of pan.h, avoiding the string intialization ""-"" (when what is intended is "-"). remarkably, the C compiler does not complain about the first version and merrily subtracts the two addresses of the constant string "" and returns a 0... - prevented the ltl conversion algorithm to run in verbose mode when spin -a is run with a -v flag (this produced a large amount of uninteresting output) - also a couple of updates to the new iSpin GUI -- so that it works better on smaller screens, and also displays the automata view better (by adding option -o3 in the pan.c generation, so that all transitions are visible in the automata displayed.) ==== Version 6.1.0 - 4 May 2011 ==== - removed calls to tmpfile(), which seems to fail on some Windows 7 systems - made it an error to have an 'else' statement combined with an i/o statement when xs or xr assertions are used to strengthen the partial order reduction. the 'else' would be equivalent to an 'empty()' call, which violates the xr/xs rules and could make the partial order reduction unsound - avoid misinterpretation of U V an X characters when part of variable names used in the new style of inline specification of ltl formula - improved treatment of remote references, under the new scope rules - some support for an experimental new version of bfs, not yet enabled - general code cleanup ==== Version 6.2.0 - 4 May 2012 ==== - added a new algorithm for parallel breadth-first search, with support for the verification of both safety and at least some liveness properties more detail is available at http://spinroot.com/spin/multicore/bfs.html the main new directive to enable parallel breadth-first search mode is -DBFS_PAR by default the storage mode that is used is hashcompact in a fixed size table (using open addressing). by default verification will continue as long as possible, but it can be forced to stop when the table is filled to capacity by defining -DSTOP_ON_FULL storage can be changed from hashcompact to full statevector storage with -DNO_HC (although this is not really recommended) you can also use bitstate hashing instead, by compiling with -DBITSTATE and (independently) you can use diskstorage to save some memory, with -DBFS_DISK but this has the disadvantage of making the verifier run slower, defeating much of the benefit of the parallel search algorithm. the default maximum length of a cycle for liveness violations is set to 10 steps; this can be changed by defining -DL_BOUND=N (which is safe, but should rarely be necessary -- setting it too large reduces the accuracy of the search (see the spin2012 paper)). when no compare and swap function __sync_bool_compare_and_swap is predefined (e.g. cygwin when compiling with gcc) you can define: -DNO_CAS the new -DBFS_PAR mode cannot be combined with -DBCS, -DNP, or -DMA - some new language features to support modeling priority-based embedded software (more detail on this at http://spinroot.com/spin/multicore/priority.html) a new predefined local variable in proctypes: _priority holds the current priority of the executing process two new predefined functions: get_priority(p) returns the priority of process p (p can be an expression) set_priority(p, c) sets priority of process p to c (p and c can be expressions) the use of these priority features cannot be combined with rendezvous statements and it requires compilation with -DNOREDUCE when process priorities are used (and the new mode is not disabled with -o6 see below) then only the highest priority enabled process can run process priorities must be in the range 1..255 - inlines can now contain a return statement, but it can be used only in a few simple cases to return a single integer value using this feature a single inline call can now be used on the right-hand side of a simple assignment statement, for example x = f(a,b); # works but not in other contexts where one would normally expect a value to be returned, like an expression) e.g., these cases do not work: if :: (a > fct()) -> # does not work if :: (fct()) -> # does not work x = f(a,b) + g(x) # does not work the return statement, being so restricted is of limited use, may therefore disappear again in future versions - a label name can now appear also without a statement following it (useful, for instance, to place a label at the end of the proctype or sequence without having to add a dummy skip statement) - and else statement can now appear as the only option in an if or do and then evaluates to 'true' -- this can be useful in some cases with machine generated models - new spin options spin option -o6 reverts to the old (pre 6.2.0) rules for interpreting priority annotations there's also a new experimental option -pp to improve the formatting of a badly formatted spin model (e.g. machine generated). it is far from perfect and the option may therefore disappear again in some future version - restructed how pan.h is generated, to make sure that it does not declare any objects, only prototypes, datatypes, and structures -- this makes it possible to include pan.h safely in other files as well - also made separate compilation of claims and code work again (if you don't know what this means, it's best that you don't learn it either... it's an obscure feature that almost nobody uses) - in bitstate mode the default size of the bitarray is now 16 MB (-w27), was 1MB (-w23) - in standard mode the default hashtable size is now -w24 (up from -w19) - bug fixes the clang analyzer noted that the code in dstep.c left a local array buf accessible via a global pointer (NextLab) also after the function returned. corrected by declaring the local array as a static structure similarly, removed some dead assignments in mesg.c flagged by clang. - cleaned up the scope rule enforcement a bit, so that top level local variable declarations do not get any prefix -- simplifying the remote referencing only declarations in inner-blocks or inlines are now affected, and get a scope unique prefix (which is hidden from the user level in almost all cases) - corrected a problem noted on the spinroot forum that one could not use a break statement inside the new 'for' construct (correction in spin.y and flow.c) problem was that the break target was not defined early enough in the parsing - corrected a problem where label names were affected by the new scope rules, causing some confusion with remote references and jumps - made the format of spin warning messages more consistent throughout the code - better recognition of invalid transition references in guided simulation (scenario replay) in guided.c - statement merging is now disabled when proctype 'provided' clauses are used - corrected problem when an conditional expression was used in an argument to an inline - corrected problem when a remote reference was used as an array index inside an inline ltl formula - corrected the makefile to allow the use of multiple cores for parallel compilation (using, for instance, "make -j 8") - now preventing assignments to the predefined local variable _pid (...) - fixed treatment of <-> or "equivalent" in ltl formula -- it wasn't always recognized correctly - some more general code cleanup ==== Version 6.2.1 - 14 May 2012 ==== - first bug in 6.2: the new 'select' statement was broken and triggered a syntax error 'misplaced break statement' -- fixed ==== Version 6.2.2 - 6 June 2012 ==== - fixed bug in handling of the new 'set_priority' call. priorities were not properly restored during the depth-first search, which could lead to strange verification results. - fixed a bug that prevented use of parallel bfs in combination with collapse compression. the combination isn't really recommended, but at least it shouldn't crash of course... (the recommended mode for parallel bfs is the default storage mode, which ias based on hashcompact, or bitstate). - added missing "extern YYSTYPE yylval;" in reprosrc.c, which prevented compilation in some platforms - added warning against the use of hidden variables when using bfs - excluded run statements from statement merging, to secure correctness when priority tags are used - omitted the message type field in datapackets exchanged with other cores in parallel bfs mode, in those modes where the type field can be deduced from other parts of the data, to reduce memory needed for the bfs queues ==== Version 6.2.3 - 24 October 2012 ==== - fixed bug when using BFS_DISK in combination with BFS_PAR - fixed a bug when using process priorities, added initialization for the priority to make sure it is set when a priority is not explicitly defined - fixed code when using COLLAPSE in combination with BFS_PAR - added warning when replaying an error-trail for a model with embedded c-code, to make sure the user knows that the c-code fragments are not executed. to replay an error-trail for models with embedded c-code only the compiled pan.c file can be used (e.g., by executing ./pan -C) - no longer pointing to /lib/cpp for preprocessing, which dates to early unix system; the default is to use gcc, or plain cpp - renamed global vars j2, j3 and j4 in pan.c to j2_spin, j3_spin and j4_spin to avoid potential name clashes with embedded c-code fragments in models - added hints in bfs parallel mode at end of runs if the hash-table could be resized in a new run, to improve performance - small additional speedups in BFS_PAR mode (finetuning the wait discipline when switching from one generation of states to the next) - changed the default max nr of cores in BFS_PAR mode from 32 to 64 - better memory alignment in BFS_PAR mode - other small fixes and minor code cleanup ==== Version 6.2.4 - 10 March 2013 ==== - never claims generated from inline ltl formula are now automatically added when replaying an error trial (so it will no longer say 'claim ignored' in those cases) - improved treatment of the STDIN channel on linux systems - changed the format of never claims to improve error-trails (by using an assertion in some cases instead of a goto to the end of the claim -- this also includes changing 'if' into 'do' in some cases, which may affect postprocessors that rely on the older format) - changed parser to allow constant expressions in more places where earlier only numeric constants were accepted (e.g., for active [...] specifying the size of a channel, and the size of an array) - small improvements in memory use for parallel bfs mode (BFS_PAR) - added a BFS_NOTRAIL mode for parallel bfs, reducing memory use if no counter-example error trail is expected - fixed bug in the evaluation of 'enabled(pid)' during verifications - fixed bug in implementation of weak-fairness algorithm, which could in rare causes cause a fair cycle to go unreported. - improved calculation of hash-factor for very large bitstate spaces - fix bug introduced in 6.2.3 that gave a compiler error for -DBITSTATE - other minor code cleanup ==== Version 6.2.5 - 4 May 2013 ==== - fixed bug when priorities are used and statement merging is enabled (the default) -- this could cause state updates to get out of sync, leading to a possible crash of the verifier. - added the keyword "const" to many of the constant array declarations, to reassure static analyzers that printfs would not alter the contents of these arrays - fixed bug in verifier in handling of priority based scheduling, which could lead it to erroneously get process ids wrong; fixed problems with the use of priorities when used in combination with ltl properties or never claims; fixed a bug that could lead to a crash due to not correctly storing backup values for priorities that are modified dynamically with 'set_priority()' calls - more small changes to appease static source code analyzers - increased various buffer sizes to allow the parsing of larger ltl formula ==== Version 6.2.6 - 17 February 2014 ==== - corrected bug in treatment of break statements hiding in unless constructs - corrected treatment of priorities (example by Mirtha Line Fernandez Venero) - added some new predefined routines to simplify integration with modex: spin_malloc, spin_join, spin_mutex_free, spin_mutex_lock, spin_mutex_unlock, and spn_mutex_init (not all of these may survive future updates) - added a new spin option -x to directly print the transition table for a model (the option parses the model, generates pan.c, compiles it, and then runs it with option -d) - ONE_L is now defined as 1L instead of (unsigned long) 1 to avoid a double expansion of unsigned long to unsigned long long caused by a macro used for compilation for 64-bit windows systems - mildly improved error reporting - doubled the size of the yacc parse stack (YYMAXSTACK), to support parsing larger models ==== Version 6.2.7 - 2 March 2014 ==== - another fix of enforcement of priorities during verification - fixed a bug in treatment of -DT_RAND and -DP_RAND that could lead to the analyzer hanging in some cases ==== Version 6.3.0 - 4 May 2014 ==== - A new minor version number because the Promela syntax rules changed. A semi-colon at the end of the line is now optional. this is implemented by having the lexical analyzer insert the semi-colons automatically if they are missing. Almost all models will still parse correctly, but the change can in a few cases cause older models to trigger a syntax error if a statement seperator is assumed in an unsuspected place, e.g., in the middle of a multi-line expression. Avoid it by making sure a multi-line boolean expression is always enclosed in round braces, or by having the last token on a line be an operator. For instance, these expressions will parse correctly: if :: (a && b) -> ... :: a && b -> ... fi but these do not: if :: (a) // parser cannot see that the expression is incomplete && (b) -> ... :: a // same here && b -> ... fi To revert to the old syntax rules, use spin option -o7 - added 5 new options: -run compile and run, verify safety properties # Note the next four have been replaced in later versions, see 6.4.0 -runA compile and run, find acceptance cycles -runAF compile and run, find weakly-fair acceptance cycles -runNP compile and run, find non-progress cycles -runNPF compile and run, find weakly-fair non-progress cycles for instance: spin -runA leader.pml - spin option -M changed: replaced ps_msc.c with msc_tcl.c and with it changed the spin -M option from generating scenarios in Postscript to generating them as TclTk output. the new version of iSpin makes use of this as well. By default the maximum length of the scenario generated is 1024 (equivalent to an option -u1024). To change it to a different value, use the -u option (e.g., spin -u2048 -M leader.pml). - when using randomized searches (T_RAND, P_RAND, or RANDOMIZE, or pan_rand()) the seed for the random number generator now also depends on the choice of -h (i.e., the seed will change if you change the hashfunction used with ./pan -h) - added more support for verification of models extracted by Modex from C code with pthread library calls embedded. - simplified the directory structure of the distribution somewhat by combining all examples Spin models in a single directory Examples, with subdirectories for specific subsets: LTL, Exercises, Book_1991 (the old subdirectories Samples, Test, and iSpin/ltl_examples are now gone) - bug fixes: - another bug fix in treatment of priorities in verification runs the priority tag in active proctype declarations was erroneously ignored - fixed the accuracy of reporting the cycle-point in liveness errors discovered in a breadth-first search with the piggyback algorithm (courtesy Ioannis Filippidis, 4/2014) - restored original settings for the piggyback algorithm, which restored much of the cycle finding capabilities that were lost after version 6.2.2 - improved parser so that it can continue after the first syntax error - improved accuracy of line numbers in traces (courtesy Akira Tanaka, 3/2014) - prevented some compilation errors for unusual combinations of directives - removed some warnings for printf statements with the wrong qualifiers (e.g., %d for a long int, which should be %ld, etc.) ==== Version 6.3.1 - 11 May 2014 ==== - big improvement in the handling of the new -run parameter to Spin that will make it much easier to work with Spin. all new functionality is now supported by the -run parameter alone, so these four experimental options from 6.3.0 are no longer needed: -runA,-runAF, -runNP, -runNPF in the new setup, a -run parameter can be followed by any additional settings and options that should be passed to either the compiler (for compiling pan.c) or the ./pan verifier itself as runtime options. the rule is that all parameters that preceed a -run argument are interpreted by Spin itself for parsing the model; all parameters that follow a -run parameter are passed down to compiler or verifier for instance, to get the equivalent of -runNPF from 6.3.0, you can now say: spin -run -DNP -l -f spec.pml to get an immediate run searching for weakly fair non-progress cycles similarly, to optimize the compilation and reduce the run to a depth of 3000 step, you would say: spin -run -O2 -DNP -l -f -m3000 spec.pml with this new setup you should in principle never have to compile the pan.c source files manually, or invoke the verification manually. if you want to redefine a macro used in the Spin model itself, you can still pass that new definition directly to spin, by placing it before the -run parameter, for instance: spin -DMAX=24 -run -O2 -DNP -l -f -m3000 spec.pml (assuming that macro MAX is used inside spec.pml) - new exercises and tutorials to match these changes in http://spinroot.com/spin/Man/1_Exercises.html http://spinroot.com/spin/Man/3_SpinGUI.html http://spinroot.com/spin/Man/4_SpinVerification.html - bug fixes: - in simulations, dynamically changing process priorities did not always work correctly. now fixed - additional corrections to the line number reporting in simulations ==== Version 6.3.2 - 17 May 2014 ==== - this update makes all new spin options work correctly, and can be compiled cleanly, on Linux, Windows PCs, and Mac's, and it supports all new Modex options for direct verification of C source code (http://spinroot.com/modex) - other updates and fixes: - assigning to the reserved predefined variables (_last, _p, _pid, _nr_qs, _nr_pr) is now intercepted correctly - assigning to _priority now works correctly also in simulations - new features: - you can now initialize an array of integers with a list in proctypes, and in global declarations (but not yet if the array is declared inside an inline definition) for instance: int a[4] = { 3, 1, 4, 1 } all initialization values must be constants - parser improved so that it can allow the use of variables or channels named 'in' -- without causing a conflict with the token 'in' from for-statements - process priorities now work in simulation the same as in verification -- you can revert to the old behavior with -o7 - for this version added a Mac executable to the distribution (no guarantees that future versions will also have this though) ==== Version 6.4.0 - 19 September 2014 ==== - main new features: - new ./pan runtime option flag -hash to randomly generate a hash polynomial, for instance to separate multiple runs with bitstate hashing better. the seed for the random number generator determines what polynomial is going to be generated (same seed means same polynomial). the seed can be changed with ./pan option -RSn where n is any positive integer e.g., obtained from a Unix/Linux system call 'rand.' for instance ./pan -RS`rand` -hash # using backquotes around rand - extended the number of features that is supported in combination with the new spin runtime options that were introduced in 6.3.0 four main types of spin (not pan) options are now supported: spin [..options1..] -run [..options2..] modelname.pml spin [..options1..] -replay [..options2..] modelname.pml spin [..options1..] -biterate [..options2..] modelname.pml spin [..options1..] -swarmN,M [..options2..] modelname.pml other parse-time (options1) or runtime (options2) options can be passed along as shown above, and as explained below: o parse-time options are placed *before* the mode flag (-run, -replay, etc.) o compile-time and run-time options are placed *after* the mode flag. this can include compiler directives to be used to compile pan.c (which happens in the background), or to execute the resulting ./pan executable (which now also happens automatically). note 1: when you use this command: spin -DX=2 -m -run -DSAFETY -m100 modelname compiler directive -DX=2 is used in the preprocessing of the model, and compiler directive -DSAFETY is used to compile the resulting pan.c. and further, the first -m argument is interpreted by spin, and the second -m100 argument is interpreted by ./pan note 2: the new options make use of gcc, which is assumed to be installed on your system, so on Windows systems this is unlikely to work unless you also have cygwin with gcc installed. you can change the compiler to be used by compiling the spin sources with a different choice for -DCPP (e.g., "-DCPP=clang -E -x c" might work) when using the new options on a Windows system with gcc may also doom you to 32-bit pan executables, which will limit the size of memory you can allocate for a search to 2GB. using linux is recommended. explanation of the use of the spin -replay option: this option can be used to replay an existing error trail-file (e.g., found with an earlier spin -run) if the model contains embedded c-code, the ./pan executable is used for the replay; otherwise spin itself is used for the replay. note that ./pan recognizes different runtime options than spin itself so it can matter which of these two cases applies for [..options2..] you can of course always still fall back on the old spin -t -p modelname.pml method for models withnout embedded C code, or the ./pan -r method for models with embedded C code. explanation of the use of the spin -run option: a synonym of this option is -search -- it behaves identical to -run. this option is used to generate a verifier (pan.c), compile it, and execute it run, all without further user intervention. new options that can be used in the [..options2..] part include: -bfs to perform a breadth-first search -bfspar to perform a parallel breadth-first search -bcs to use the bounded-context-switching algorithm -bitstate or -bit, to use bitstate storage -link file.c to link the pan.c to file.c in the compilation -collapse to use collapse state compression -hc to use hashcompact storage -noclaim to ignore all ltl and never claims -p_permute to use process scheduling order permutation -p_rotateN to use process scheduling order rotation by N (default 0) -p_reverse to use process scheduling order reversal -ltl p to verify the ltl property named p -safety to compile for safety properties only (default is liveness+safety) -i to use the dfs iterative shortening algorithm -a to search for acceptance cycles (and compile correspondingly) -l to search for non-progress cycles (and compile correspondingly) explanation of the use of the new spin -biterate option: uses bitstate compilation plus iterative search refinement for the execution of ./pan with hashtable size increasing step by step from -w18 upto -w35 -- until an error is found. this performs 18 runs sequentially, with the first runs executing very fast -- thus making it likely that errors are found very quickly each new run increases precision and runtime, until the max is reached explanation of the use of the new spin -swarmN,M option: the most advanced new search mode -- only for use on larger multi-core systems (e.g., 16 cores and up). this option performs N runs in parallel and increments -w every M runs for each run performed several other parameters are also randomized (e.g., the hash function used, process scheduling decisions, transition ordering, etc. similar to what the swarm preprocessor would do) the default value for N is 10, and the default for M is 1 the swarm option makes use of a new compiler directive for pan.c files called -DPERMUTED that allows for more extensive options for process scheduling randomization (p_rotate, p_reverse, and p_permute, see below) spin -swarmN,M will use the following compilation directives and runtime parameters (most of this is meant to be internal to Spin, but listed here for completeness as background information). (the new options below are probably not too useful when used separately) swarm compilation adds: -DBITSTATE -DPUTPID and -DPERMUTED (a new directive, see below) -DSAFETY unless there is also -a or -l parameter in [..options2..] -DNOFAIR unless there is a -f parameter or there is no -a or -l runtime flags used (with randomized arguments): -w18 unless there already is a -w argument, then use that as starting point -i_reverse envoked on some of the runs, to change initialization orders of processes -t_reverse envoked on some of the runs, to reverse transition orders unless -DT_RAND or -DT_REVERSE are defined -h0 unless there already is a -hN argument, then use that as starting point or if the user specified -hash, then do not use -h -k1 unless there already is a -k argument, then use that as starting point -p_rotate0 unless there already is a different -p_rotateN argument, unless there is a -p_permute argument, then do not use -RSn using internal choice for n, overrides a user-defined argument -a unless there is already a -a or -l argument or there is a -DNOCLAIM directive or there are no accept-state labels in the model or ltl formula the swarm option varies these parameters across all parallel runs: -w every Nth iteration (from -swarmN,M): 18..35 -h every run 0..499 (unless the user defined -hash) -p_rotate every run 0..255 (unless suppressed by p_normal or p_reverse) -k every run 1..3 -T every run 0..1 -P every run 0..3 -RSn every run -p_reverse is enabled on every 5th run, but overriden by -P0/1 in half the cases (overrides p_rotate if selected) -p_normal to revert to normal process scheduling at least once ever 6 runs the new -DPERMUTED directive enables a set of new runtime options to pan that support how the process scheduling selecting can be modified during the search: -p_permute -- to randomly permute the processes (the default) -p_rotate -- to rotate the process ready queue 1 slot -p_rotateN -- to rotate the process ready queue N slots (using -p_rotate0 will have no effect of course) -p_reverse -- to reverse order for all processes -p_normal -- perform process scheduling as if -DPERMUTED was not defined if more than one of these options is used, the last one wins. if -DPERMUTED is defined and none of these flags are used the default process scheduling order is -p_permute note that using -DPERMUTED adds overhead and slows down a search, which is only reasonable when used in combination with the swarm randomizations - two additional pan runtime options were added that can affect process scheduling and transition selection orders: -i_reverse -- reverse the initialization order of all processes declared 'active' -t_reverse -- reverse the order of transition selections - other smaller additions: - extended the number of builtin hash-polynomials (selected via -hN) from 32 to 100 - can now place ltl formula anywhere in a Promela file -- it does not need to appear after all symbols that are referenced in the formula have been declared (the parser will now always defer processing until the entire specification has been parsed) - added a quick sanity check to parsing of ltl formula, to catch some common mistakes. - some fixes: - removed some false warnings about duplicate label declarations - added -std=gnu99 to calls to the gcc compiler an preprocessor to make sure that // comments in Promela specifications are recognized - removed pc_zpp.c -- the builtin preprocessor used when compiled with -DPC the original reason for adding this was to avoid a command window from flashing on the screen when an external preprocessor was called from within xspin. that problem no longer seems to exist, and so this restricted version of the preprocessor is no longer needed - small improvements in typechecking in receive statements - improved the look of message sequence charts generated with spin -M - fewer compiler warnings when using models with priorities - deprecated flag ./pan -s now removed (sam as ./pan -k1) - fixed bug in implementation of bounded context switching code (-DBCS) that could cause states to be restored incorrectly - removed the mapping of type long to long long on windows pcs (-DPC) - improved parsing for very large models, saving about 20% of cpu-time, by switching from unsorted to sorted linked lists in a few places - a few more bug fixes in the implementation of support for dynamically changing priorities - fixed a bug in replay of error trails for ltl formula, for models where multiple formula are used, to make sure that the formula are parsed in the same way for verification and for replay. - new or renamed compilation directives - -DREVERSE (gone) to reverse process selection order is renamed to -DP_REVERSE to make it more symmetric with the older -DT_REVERSE used to reverse the transition selection order - the new directive -DPERMUTED overrides -DP_REVERSE if both are used ==== Version 6.4.1 - 5 October 2014 ==== - two small fixes to 6.4.0 - the new -run -biterate options wasn't working correctly - on windows32 and windows64 versions, suppressed logos from gcc and improved method for detecting whether gcc.exe is a symbolic link or not ==== Version 6.4.2 - 8 October 2014 ==== - restored the correct behavior for a standalone -run argument (i.e., without -swarm or -biterate), which should perform a single compilation and execution of the ./pan verifier - less chatter on stdout for executed background commands (you can restore this by adding -v or -w -- if you use -w the commands generated for -biterate or -swarm are shown, but not executed) ==== Version 6.4.3 - 16 December 2014 ==== - added definition of tas() function for powerpc64, courtesy of srirajpaul (Rice CAF group) - corrected parsing unsigned int variables in c_state declarations - allow use of a variable name in an array bound, provided that variable is an initialized scalar - generats a warning when this is used - made sure ltl formula are parsed the same way on replay of an error trail as when generating a verifier - improved matching of labels if the same labelname is used in multiple scopes (e.g., different inlines) - fewer issues with WindowsPC compiled versions - the label "accept_all" in neverclaims is no longer treated as an indication of a check that requires cycle detection - presence of -bfs will now preclude addition of -a flag in auto-generated runs - fixed limit that was set too short when reproducing an MSC from an error-trail with spin option -M - small improvement in replays of error-trails with ./pan -r - improved support for Modex generated models - now handles select statements in preprocessor (spinlex.c) rather than in the grammar -- replaces it with a true non-deterministic choice for relatively small ranges (1..32 entries), rather than a non-deterministically terminated do-loop, for simpler error trails - fixed some minor type inaccuracies ==== Version 6.4.4 - 1 November 2015 ==== - when compiletime option -DNP is defined after a -run flag, the runtime option -l is now added, if missing. - removed the dummy definition of yywrap() - added make32 for 32-bit linux builds (make -f make32) - improved printing of mtype values in trace replay with pan - improved support for cond_wait, cond_signal, and mutex_init for models extracted by modex (not meant to be called directly) - improved replay of error traces when -DPERMUTED is used - improved verbose output for -DPERMUTED options - added 64-bit murmurhash function as an alternative on 64-bit systems it is enabled by compiling pan.c with an additional -DMURMUR directive - replaced call srandom() with srand() and replaced random() with rand() - added p_randrot to the set of options supported by -DPERMUTED for rotating the process scheduling list by a random amount (see 6.4.0) - added a runtime option (for pan.c) called -rhash to generated a random hash-polynomial for the run (as determined by the seed for the random number generator, which can be changed with runtime option -RSnnn) if no seed is selected with -RS, then time is used to seed the random number generator. Compile pan.c with -DRHASH to enable this option. If -DRHASH is defined it will also enable directive -DPERMUTED. see VMCAI2016 paper for examples of its use in cloud / swarm verification. - removed the warning "this search is more efficient if compiled with -DSAFETY" - improved spin replay of error-traces for models using process priorities together with ltl properties or never claims - added support for using c_expr inside ltl formula - made select ( name : constant .. constant-expression ) work again, e.g. so that you can again say: select (i : 0 .. N-1) - other minor fixes and improvements throughout ==== Version 6.4.5 - 1 January 2016 ==== - The first version of Spin that is released under a standard BSd 3-Clause open source license. This was possible thanks to the transfer of the copyright on all Spin sources from Alcatel-Lucent (the successor to AT&T in ownership of Bell Labs), to me on 30 December 2015. This release also comes 25 years after the very first source release of Version 1.0 in Jan. 1991. Since the license is now standard, and no longer Lucent specific, the Spin sources and executables are now more easily packaged for distribution in other open source systems, e.g., Ubuntu. - other minor updates, e.g. to remove a sanity check that caused inline ltl formulae like ltl { true U (true U true) } to be flagged as incorrect, and the correction of an incorrectly bracketed expression in function spin_cond_wait, which is used by the modex model extractor. Spin/Doc/Manual.html0000644000175100017510000023060612641606227012374 0ustar ghgh Basic Spin Manual

    Basic Spin Manual

    Spin is a tool for analyzing the logical consistency of concurrent systems, specifically of data communication protocols. The system is described in a modeling language called Promela (Process Meta Language). The language allows for the dynamic creation of concurrent processes. Communication via message channels can be defined to be synchronous (i.e., rendezvous), or asynchronous (i.e., buffered).

    Given a model system specified in Promela, Spin can either perform random simulations of the system's execution or it can generate a C program that performs an efficient online verification of the system's correctness properties. During simulation and verification Spin checks for the absence of deadlocks, unspecified receptions, and unexecutable code. The verifier can also be used to verify the correctness of system invariants, it can find non-progress execution cycles, and it can verify correctness properties expressed in next-time free linear temporal logic formulae.

    The verifier is setup to be efficient and to use a minimal amount of memory. An exhaustive verification performed by Spin can establish with mathematical certainty whether or not a given behavior is error-free. Very large verification problems, that can ordinarily not be solved within the constraints of a given computer system, can be attacked with a frugal ``bit state storage'' technique, also known as supertrace. With this method the state space can be collapsed to a small number of bits per reachable system state, with minimal side-effects.

    The first part of this memo gives an introduction to Promela, the second part discusses the usage of Spin. A concise reference to Promela can be found in a companion document. In the Appendix some examples are used to illustrate the construction of a basic Promela model for Spin verification.

    This manual discusses only the most basic use of Spin. It does not discuss extensions to the language that are part of more recent versions of the tool (see the notes at the end of this manual). It also does not discuss the builtin support for the verification of linear temporal logic formulae.

    Modeling Language

    Promela is a verification modeling language. It provides a vehicle for making abstractions of protocols (or distributed systems in general) that suppress details that are unrelated to process interaction. The intended use of Spin is to verify fractions of process behavior, that for one reason or another are considered suspect. The relevant behavior is modeled in Promela and verified. A complete verification is therefore typically performed in a series of steps, with the construction of increasingly detailed Promela models. Each model can be verified with Spin under different types of assumptions about the environment (e.g., message loss, message duplications etc). Once the correctness of a model has been established with Spin, that fact can be used in the construction and verification of all subsequent models.

    Promela programs consist of processes, message channels, and variables. Processes are global objects. Message channels and variables can be declared either globally or locally within a process. Processes specify behavior, channels and global variables define the environment in which the processes run.

    Executability

    In Promela there is no difference between conditions and statements, even isolated boolean conditions can be used as statements. The execution of every statement is conditional on its executability . Statements are either executable or blocked. The executability is the basic means of synchronization. A process can wait for an event to happen by waiting for a statement to become executable. For instance, instead of writing a busy wait loop: 

    	while (a != b)
		skip	/* wait for a==b */
    one can achieve the same effect in Promela with the statement 
    	(a == b)
    A condition can only be executed (passed) when it holds. If the condition does not hold, execution blocks until it does.

    Variables are used to store either global information about the system as a whole, or information local to one specific process, depending on where the declaration for the variable is placed. The declarations 

    	bool flag;
	int state;
	byte msg;
    define variables that can store integer values in three different ranges. The scope of a variable is global if it is declared outside all process declarations, and local if it is declared within a process declaration.

    Data Types

    The table below summarizes the basic data types, sizes, and typical value ranges on a 32-bit wordsize computer. (See also datatypes.)

    Table 1 - Data Types
    Typename
    bit or bool
    byte
    short
    int
    		 C-equivalent
    bit-field
    uchar
    short
    int
    		 Macro in limits.h
    -
    CHAR_BIT (width in bits)
    SHRT_MIN..SHRT_MAX
    INT_MIN..INT_MAX
    		 Typical Range
    0..1
    0..255
    -2^15 - 1 .. 2^15 - 1
    -2^31 - 1 .. 2^31 - 1

    The names bit and bool are synonyms for a single bit of information. A byte is an unsigned quantity that can store a value between 0 and 255. shorts and ints are signed quantities that differ only in the range of values they can hold.

    An mtype variable can be assigned symbolic values that are declared in an mtype = { ... } statement, to be discussed below.

    Array Variables

    Variables can be declared as arrays. For instance, 

    	byte state[N]
    declares an array of N bytes that can be accessed in statements such as 
    	state[0] = state[3] + 5 * state[3*2/n]
    wheren is a constant or a variable declared elsewhere. The index to an array can be any expression that determines a unique integer value. The effect of an index value outside the range 0.. N-1 is undefined; most likely it will cause a runtime error. (Multi-dimensional arrays can be defined indirectly with the help of the typedef construct, see WhatsNew.html, Section 2.1.7)

    So far we have seen examples of variable declarations and of two types of statements: boolean conditions and assignments. Declarations and assignments are always executable. Conditions are only executable when they hold.

    Process Types

    The state of a variable or of a message channel can only be changed or inspected by processes. The behavior of a process is defined in a proctype declaration. The following, for instance, declares a process with one local variable state. 

    	proctype A()
	{	byte state;

		state = 3
	}
    The process type is named A. The body of the declaration is enclosed in curly braces. The declaration body consists of a list of zero or more declarations of local variables and/or statements. The declaration above contains one local variable declaration and a single statement: an assignment of the value 3 to variable state.

    The semicolon is a statement separator (not a statement terminator, hence there is no semicolon after the last statement). Promela accepts two different statement separators: an arrow `->'and the semicolon `;'. The two statement separators are equivalent. The arrow is sometimes used as an informal way to indicate a causal relation between two statements. Consider the following example. 

    	byte state = 2;

	proctype A()
	{	(state == 1) -> state = 3
	}

	proctype B()
	{	state = state - 1
	}
    In this example we declared two types of processes, A and B. Variable state is now a global, initialized to the value two. Process type A contains two statements, separated by an arrow. In the example, process declaration B contains a single statement that decrements the value of the state variable by one. Since the assignment is always executable, processes of type B can always complete without delay. Processes of type A, however, are delayed at the condition until the variable state contains the proper value.

    Process Instantiation

    A proctype definition only declares process behavior, it does not execute it. Initially, in the Promela model, just one process will be executed: a process of type init, that must be declared explicitly in every Promela specification. The smallest possible Promela specification, therefore, is: 

    	init { skip }
    where skip is a dummy, null statement. More interestingly, however, the initial process can initialize global variables, and instantiate processes. An init declaration for the above system, for instance, could look as follows. 
    	init
	{	run A(); run B()
	}

    run is used as a unary operator that takes the name of a process type (e.g. A). It is executable only if a process of the type specified can be instantiated. It is unexecutable if this cannot be done, for instance if too many processes are already running.

    The run statement can pass parameter values of all basic data types to the new process. The declarations are then written, for instance, as follows: 

    	proctype A(byte state; short foo)
	{
		(state == 1) -> state = foo
	}

	init
	{
		run A(1, 3)
	}
    Data arrays or process types can not be passed as parameters. As we will see below, there is just one other data type that can be used as a parameter: a message channel.

    Run statements can be used in any process to spawn new processes, not just in the initial process. Processes are created with the run statements. An executing process disappears again when it terminates (i.e., reaches the end of the body of its process type declaration), but not before all processes that it started have terminated.

    With the run statement we can create any number of copies of the process types A and B. If, however, more than one concurrent process is allowed to both read and write the value of a global variable a well-known set of problems can result; for example see [2]. Consider, for instance, the following system of two processes, sharing access to the global variable state. 

    	byte state = 1;

	proctype A()
	{	byte tmp;
		(state==1) -> tmp = state; tmp = tmp+1; state = tmp
	}

	proctype B()
	{	byte tmp;
		(state==1) -> tmp = state; tmp = tmp-1; state = tmp
	}

	init
	{	run A(); run B()
	}
    If one of the two processes completes before its competitor has started, the other process will block forever on the initial condition. If both pass the condition simultaneously, both will complete, but the resulting value of state is unpredictable. It can be any of the values 0, 1, or 2.

    Many solutions to this problem have been considered, ranging from an abolishment of global variables to the provision of special machine instructions that can guarantee an indivisible test and set sequence on a shared variable. The example below was one of the first solutions published. It is due to the Dutch mathematician Dekker. It grants two processes mutually exclusion access to an arbitrary critical section in their code, by manipulation three additional global variables. The first four lines in the Promela specification below are C-style macro definitions. The first two macros define true to be a constant value equal to 1 and false to be a constant 0. Similarly, Aturn and Bturn are defined as constants. 

    	#define true	1
	#define false	0
	#define Aturn	false
	#define Bturn	true

	bool x, y, t;

	proctype A()
	{	x = true;
		t = Bturn;
		(y == false || t == Aturn);
		/* critical section */
		x = false
	}

	proctype B()
	{	y = true;
		t = Aturn;
		(x == false || t == Bturn);
		/* critical section */
		y = false
	}

	init
	{	run A(); run B()
	}
    The algorithm can be executed repeatedly and is independent of the relative speeds of the two processes.

    Atomic Sequences

    In Promela there is also another way to avoid the test and set problem: atomic sequences. By prefixing a sequence of statements enclosed in curly braces with the keyword atomic the user can indicate that the sequence is to be executed as one indivisible unit, non-interleaved with any other processes. It causes a run-time error if any statement, other than the first statement, blocks in an atomic sequence. This is how we can use atomic sequences to protect the concurrent access to the global variable state in the earlier example. 

    	byte state = 1;

	proctype A()
	{	atomic {
		  (state==1) -> state = state+1
		}
	}

	proctype B()
	{	atomic {
		  (state==1) -> state = state-1
		}
	}

	init
	{	run A(); run B()
	}
    In this case the final value of state is either zero or two, depending on which process executes. The other process will be blocked forever.

    Atomic sequences can be an important tool in reducing the complexity of verification models. Note that atomic sequence restricts the amount of interleaving that is allowed in a distributed system. Otherwise untractable models can be made tractable by, for instance, labeling all manipulations of local variables with atomic sequences. The reduction in complexity can be dramatic.

    Message Passing

    Message channels are used to model the transfer of data from one process to another. They are declared either locally or globally, for instance as follows: 

    	chan qname = [16] of { short }
    This declares a channel that can store up to 16 messages of type short. Channel names can be passed from one process to another via channels or as parameters in process instantiations. If the messages to be passed by the channel have more than one field, the declaration may look as follows: 
    	chan qname = [16] of { byte, int, chan, byte }
    This time the channel stores up to sixteen messages, each consisting of two 8-bit values, one 32-bit value, and a channel name.

    The statement 

    	qname!expr
    sends the value of expression expr to the channel that we just created, that is: it appends the value to the tail of the channel. 
    	qname?msg
    receives the message, it retrieves it from the head of the channel, and stores it in a variable msg. The channels pass messages in first-in-first-out order. In the above cases only a single value is passed through the channel. If more than one value is to be transferred per message, they are specified in a comma separated list 
    	qname!expr1,expr2,expr3
	qname?var1,var2,var3
    It is an error to send or receive either more or fewer parameters per message than was declared for the message channel used.
    By convention, the first message field is often used to specify the message type (i.e. a constant). An alternative, and equivalent, notation for the send and receive operations is therefore to specify the message type, followed by a list of message fields enclosed in braces. In general: 
    	qname!expr1(expr2,expr3)
	qname?var1(var2,var3)

    The send operation is executable only when the channel addressed is not full. The receive operation, similarly, is only executable when the channel is non empty. Optionally, some of the arguments of the receive operation can be constants: 

    	qname?cons1,var2,cons2
    in this case, a further condition on the executability of the receive operation is that the value of all message fields that are specified as constants match the value of the corresponding fields in the message that is at the head of the channel. Again, nothing bad will happen if a statement happens to be non-executable. The process trying to execute it will be delayed until the statement, or, more likely, an alternative statement, becomes executable.

    Here is an example that uses some of the mechanisms introduced so far. 

    	proctype A(chan q1)
	{	chan q2;
		q1?q2;
		q2!123
	}

	proctype B(chan qforb)
	{	int x;
		qforb?x;
		printf("x = %d\n", x)
	}

	init {
		chan qname = [1] of { chan };
		chan qforb = [1] of { int };
		run A(qname);
		run B(qforb);
		qname!qforb
	}
    The value printed will be 123.

    A predefined function len(qname) returns the number of messages currently stored in channel qname. Note that if len is used as a statement, rather than on the right hand side of an assignment, it will be unexecutable if the channel is empty: it returns a zero result, which by definition means that the statement is temporarily unexecutable. Composite conditions such as 

    	(qname?var == 0)	/* syntax error */
    or 
    	(a > b && qname!123)	/* syntax error */
    are invalid in Promela (note that these conditions can not be evaluated without side-effects). For a receive statement there is an alternative, using square brackets around the clause behind the question mark. 
    	qname?[ack,var]
    is evaluated as a condition. It returns 1 if the corresponding receive statement 
    	qname?ack,var
    is executable, i.e., if there is indeed a message ack at the head of the channel. It returns 0 otherwise. In neither case has the evaluation of a statement such as 
    	qname?[ack,var]
    any side-effects: the receive is evaluated, not executed.

    Note carefully that in non-atomic sequences of two statements such as 

    	(len(qname) < MAX) -> qname!msgtype
    or 
    	qname?[msgtype] -> qname?msgtype
    the second statement is not necessarily executable after the first one has been executed. There may be race conditions if access to the channels is shared between several processes. In the first case another process can send a message to channel qname just after this process determined that the channel was not full. In the second case, the other process can steal away the message just after our process determined its presence.

    Rendez-Vous Communication

    So far we have talked about asynchronous communication between processes via message channels, declared in statements such as 

    	chan qname = [N] of { byte }
    where N is a positive constant that defines the buffer size. A logical extension is to allow for the declaration 
    	chan port = [0] of { byte }
    to define a rendezvous port that can pass single byte messages. The channel size is zero, that is, the channel port can pass, but can not store messages. Message interactions via such rendezvous ports are by definition synchronous. Consider the following example. 
    	#define msgtype 33

	chan name = [0] of { byte, byte };

	proctype A()
	{	name!msgtype(124);
		name!msgtype(121)
	}

	proctype B()
	{	byte state;
		name?msgtype(state)
	}

	init
	{	atomic { run A(); run B() }
	}
    Channel name is a global rendezvous port. The two processes will synchronously execute their first statement: a handshake on message msgtype and a transfer of the value 124 to local variable state. The second statement in process A will be unexecutable, because there is no matching receive operation in process B.

    If the channel name is defined with a non-zero buffer capacity, the behavior is different. If the buffer size is at least 2, the process of type A can complete its execution, before its peer even starts. If the buffer size is 1, the sequence of events is as follows. The process of type A can complete its first send action, but it blocks on the second, because the channel is now filled to capacity. The process of type B can then retrieve the first message and complete. At this point A becomes executable again and completes, leaving its last message as a residual in the channel.

    Rendez-vous communication is binary: only two processes, a sender and a receiver, can be synchronized in a rendezvous handshake. We will see an example of a way to exploit this to build a semaphore below. But first, let us introduce a few more control flow structures that may be useful.

    Control Flow

    Between the lines, we have already introduced three ways of defining control flow: concatenation of statements within a process, parallel execution of processes, and atomic sequences. There are three other control flow constructs in Promela to be discussed. They are case selection, repetition, and unconditional jumps.

    Case Selection

    The simplest construct is the selection structure. Using the relative values of two variables a and b to choose between two options, for instance, we can write: 

    	if
	:: (a != b) -> option1
	:: (a == b) -> option2
	fi
    The selection structure contains two execution sequences, each preceded by a double colon. Only one sequence from the list will be executed. A sequence can be selected only if its first statement is executable. The first statement is therefore called a guard.

    In the above example the guards are mutually exclusive, but they need not be. If more than one guard is executable, one of the corresponding sequences is selected nondeterministically. If all guards are unexecutable the process will block until at least one of them can be selected. There is no restriction on the type of statements that can be used as a guard. The following example, for instance, uses input statements. 

    	#define a 1
	#define b 2

	chan ch = [1] of { byte };

	proctype A()
	{	ch!a
	}

	proctype B()
	{	ch!b
	}

	proctype C()
	{	if
		:: ch?a
		:: ch?b
		fi
	}

	init
	{	atomic { run A(); run B(); run C() }
	}
    The example defines three processes and one channel. The first option in the selection structure of the process of type C is executable if the channel contains a message a, where a is a constant with value 1, defined in a macro definition at the start of the program. The second option is executable if it contains a message b, where, similarly, b is a constant. Which message will be available depends on the unknown relative speeds of the processes.

    A process of the following type will either increment or decrement the value of variable count once. 

    	byte count;

	proctype counter()
	{
		if
		:: count = count + 1
		:: count = count - 1
		fi
	}

    Repetition

    A logical extension of the selection structure is the repetition structure. We can modify the above program as follows, to obtain a cyclic program that randomly changes the value of the variable up or down. 

    	byte count;

	proctype counter()
	{
		do
		:: count = count + 1
		:: count = count - 1
		:: (count == 0) -> break
		od
	}

    Only one option can be selected for execution at a time. After the option completes, the execution of the structure is repeated. The normal way to terminate the repetition structure is with a break statement. In the example, the loop can be broken when the count reaches zero. Note, however, that it need not terminate since the other two options always remain executable. To force termination when the counter reaches zero, we could modify the program as follows. 

    	proctype counter()
	{
		do
		:: (count != 0) ->
			if
			:: count = count + 1
			:: count = count - 1
			fi
		:: (count == 0) -> break
		od
	}

    Unconditional Jumps

    Another way to break the loop is with an unconditional jump: the infamous goto statement. This is illustrated in the following implementation of Euclid's algorithm for finding the greatest common divisor of two non-zero, positive numbers: 

    	proctype Euclid(int x, y)
	{
		do
		:: (x >  y) -> x = x - y
		:: (x <  y) -> y = y - x
		:: (x == y) -> goto done
		od;
	done:
		skip
	}
    The goto in this example jumps to a label named done. A label can only appear before a statement. Above we want to jump to the end of the program. In this case a dummy statement skip is useful: it is a place holder that is always executable and has no effect. The goto is also always executable.

    The following example specifies a filter that receives messages from a channel in and divides them over two channels large and small depending on the values attached. The constant N is defined to be 128 and size is defined to be 16 in the two macro definitions. 

    	#define N    128
	#define size  16

	chan in    = [size] of { short };
	chan large = [size] of { short };
	chan small = [size] of { short };

	proctype split()
	{	short cargo;

		do
		:: in?cargo ->
			if
			:: (cargo >= N) ->
				large!cargo
			:: (cargo <  N) ->
				small!cargo
			fi
		od
	}

	init
	{	run split()
	}
    A process type that merges the two streams back into one, most likely in a different order, and writes it back into the channel in could be specified as follows. 
    	proctype merge()
	{	short cargo;
	
		do
		::	if
			:: large?cargo
			:: small?cargo
			fi;
			in!cargo
		od
	}
    If we now modify the init process as follows, the split and merge processes could busily perform their duties forever on. 
    	init
	{	in!345; in!12; in!6777;
		in!32;  in!0;
		run split();
		run merge()
	}

    As a final example, consider the following implementation of a Dijkstra semaphore, using binary rendezvous communication. 

    	#define p	0
	#define v	1
	
	chan sema = [0] of { bit };
	
	proctype dijkstra()
	{	byte count = 1;
	
		do
		:: (count == 1) ->
			sema!p; count = 0
		:: (count == 0) ->
			sema?v; count = 1
		od	
	}
	
	proctype user()
	{	do
		:: sema?p;
		   /*     critical section */
		   sema!v;
		   /* non-critical section */
		od
	}
	
	init
	{	run dijkstra();
		run user();
		run user();
		run user()
	}
    The semaphore guarantees that only one of the user processes can enter its critical section at a time. It does not necessarily prevent the monopolization of the access to the critical section by one of the processes.

    Modeling Procedures and Recursion

    Procedures can be modeled as processes, even recursive ones. The return value can be passed back to the calling process via a global variable, or via a message. The following program illustrates this. 

    	proctype fact(int n; chan p)
	{	chan child = [1] of { int };
		int result;
	
		if
		:: (n <= 1) -> p!1
		:: (n >= 2) ->
			run fact(n-1, child);
			child?result;
			p!n*result
		fi
	}
	init
	{	chan child = [1] of { int };
		int result;
	
		run fact(7, child);
		child?result;
		printf("result: %d\n", result)
	}
    The process fact(n, p) recursively calculates the factorial of n , communicating the result via a message to its parent process p.

    Timeouts

    We have already discussed two types of statement with a predefined meaning in Promela: skip, and break. Another predefined statement is timeout. The timeout models a special condition that allows a process to abort the waiting for a condition that may never become true, e.g. an input from an empty channel. The timeout keyword is a modeling feature in Promela that provides an escape from a hang state. The timeout condition becomes true only when no other statements within the distributed system is executable. Note that we deliberately abstract from absolute timing considerations, which is crucial in verification work, and we do not specify how the timeout should be implemented. A simple example is the following process that will send a reset message to a channel named guard whenever the system comes to a standstill. 

    	proctype watchdog()
	{
		do
		:: timeout -> guard!reset
		od
	}

    Assertions

    Another important language construct in Promela that needs little explanation is the assert statement. Statements of the form 

    	assert(any_boolean_condition)
    are always executable. If the boolean condition specified holds, the statement has no effect. If, however, the condition does not necessarily hold, the statement will produce an error report during verifications with Spin.

    Advanced Usage

    The modeling language has a few features that specifically address the verification aspects. It shows up in the way labels are used, in the semantics of the Promela timeout statement, and in the usage of statements such as assert that we discuss next.

    End-State Labels

    When Promela is used as a verification language the user must be able to make very specific assertions about the behavior that is being modeled. In particular, if a Promela is checked for the presence of deadlocks, the verifier must be able to distinguish a normal end state from an abnormal one.

    A normal end state could be a state in which every Promela process that was instantiated has properly reached the end of the defining program body, and all message channels are empty. But, not all Promela process are, of course, meant to reach the end of their program body. Some may very well linger in an IDLE state, or they may sit patiently in a loop ready to spring into action when new input arrives.

    To make it clear to the verifier that these alternate end states are legal, and do not constitute a deadlock, a Promela model can use end state labels. For instance, if by adding a label to the process type dijkstra() we discussed earlier: 

    	proctype dijkstra()
	{	byte count = 1;
	
	end:	do
		:: (count == 1) ->
			sema!p; count = 0
		:: (count == 0) ->
			sema?v; count = 1
		od	
	}
    we indicate that it is not an error if, at the end of an execution sequence, a process of type dijkstra() has not reached its closing curly brace, but waits in the loop. Of course, such a state could still be part of a deadlock state, but if so, it is not caused by this particular process. (It will still be reported if any one of the other processes in not in a valid end-state).

    There may be more than one end state label per verification model. If so, all labels that occur within the same process body must be unique. The rule is that every label name that starts with the three character sequence "end" is an endstate label. So it is perfectly valid to use variations such as enddne, end0, end_appel, etc.

    Progress-State Labels

    In the same spirit as the end state labels, the user can also define progress state labels. In this case, a progress state labels will mark a state that must be executed for the protocol to make progress. Any infinite cycle in the protocol execution that does not pass through at least one of these progress states, is a potential starvation loop. In the dijkstra example, for instance, we can label the successful passing of a semaphore test as ``progress'' and ask a verifier to make sure that there is no cycle in the protocol execution where at least one process succeeds in passing the semaphore guard. 

    	proctype dijkstra()
	{	byte count = 1;
	
	end:	do
		:: (count == 1) ->
	progress:	sema!p; count = 0
		:: (count == 0) ->
			sema?v; count = 1
		od	
	}
    Note that a label cannot be added immediately before or immediately after the "::" symbol, so you may have to be more creative to find a good place to put it.
    If more than one state carries a progress label, variations with a common prefix are again valid: progress0, progress_foo, etc.

    All analyzers generated by Spin with the -a flag have a runtime option (after compilation) named -l. Invoking the generated analyzer with that flag will cause a fast search for non-progress loops, instead of the default search for deadlocks. The search takes about twice as long (and uses twice as much memory) as the default search for deadlocks. (A considerable improvement over standard methods that are based on the analysis of strongly connected components.)

    Message Type Definitions

    We have seen how variables are declared and how constants can be defined using C-style macros. Promela also allows for message type definitions that look as follows: 

    	mtype = { ack, nak, err, next, accept }
    This is a preferred way of specifying the message types since it abstracts from the specific values to be used, and it makes the names of the constants available to an implementation, which can improve error reporting.

    By using the mtype keyword in channel declarations, the corresponding message field will always be interpreted symbolically, instead of numerically. For instance: 

    	chan q = [4] of { mtype, mtype, bit, short };

    Pseudo Statements

    We have now discussed all the basic types of statements defined in Promela: assignments, conditions, send and receive, assert, timeout, goto, break and skip. Note that chan, len and run are not really statements but unary operators that can be used in conditions and assignments.

    The skip statement was mentioned in passing as a statement that can be a useful filler to satisfy syntax requirements, but that really has no effect. It is formally not part of the language but a pseudo-statement, merely a synonym of another statement with the same effect: a simple condition of a constant value (1). In the same spirit other pseudo-statements could be defined (but are not), such as block or hang, as equivalents of (0), and halt, as an equivalent of assert(0).. Another pseudo-statement is else, that can be used as the initial statement of the last option sequence in a selection or iteration. 

    	if
	:: a > b -> ...
	:: else -> ...
	fi
    The else is only executable (true) if all other options in the same selection are not executable.

    Example

    Here is a simple example of a (flawed) protocol, modeled in Promela. 

    	mtype = { ack, nak, err, next, accept };

	proctype transfer(chan in,out,chin,chout)
	{	byte o, i;
	
		in?next(o);
	
		do
		:: chin?nak(i) ->
				out!accept(i);
				chout!ack(o)
	
		:: chin?ack(i) ->
				out!accept(i);
				in?next(o);
				chout!ack(o)
	
		:: chin?err(i) ->
				chout!nak(o)
		od
	}

	init
	{	chan AtoB = [1] of { mtype, byte };
		chan BtoA = [1] of { mtype, byte };
	
		chan Ain  = [2] of { mtype, byte };
		chan Bin  = [2] of { mtype, byte };
	
		chan Aout = [2] of { mtype, byte };
		chan Bout = [2] of { mtype, byte };
	
		atomic {
		  run transfer(Ain,Aout, AtoB,BtoA);
		  run transfer(Bin,Bout, BtoA,AtoB)
		};
	
		AtoB!err(0)
	}
    The channels Ain and Bin are to be filled with token messages of type next and arbitrary values (e.g. ASCII character values) by unspecified background processes: the users of the transfer service. Similarly, these user processes can read received data from the channels Aout and Bout. The channels and processes are initialized in a single atomic statement, and started with the dummy err message.

    Spin (see also Spin.html)

    Given a model system specified in Promela, Spin can either perform random simulations of the system's execution or it can generate a C program that performs a fast exhaustive verification of the system state space. The verifier can check, for instance, if user specified system invariants may be violated during a protocol's execution.

    If Spin is invoked without any options it performs a random simulation. With option -n N the seed for the simulation is set explicitly to the integer value N .

    A group of options pglrs can be used to set the desired level of information that the user wants about the simulation run. Every line of output normally contains a reference to the source line in the specification that caused it.

    -p Shows the state changes of the Promela processes at every time step.

    -g Shows the current value of global variables at every time step.

    -l Shows the current value of local variables, after the process that owns them has changed state. It is best used in combination with option -p.

    -r Shows all message receive events. It shows the process performing the receive, its name and number, the source line number, the message parameter number (there is one line for each parameter), the message type and the message channel number and name.

    -s Shows all message send events.

    Spin understands three other options (-a, -m, and -t):

    -a Generates a protocol specific analyzer. The output is written into a set of C files, named pan.[cbhmt], that can be compiled to produce the analyzer (which is then executed to perform the analysis). To guarantee an exhaustive exploration of the state space, the program can be compiled simply as 

    	$ gcc -o pan pan.c
    For larger systems this may, however, exhaust the available memory on the machine used. Large to very large systems can still be analyzed by using a memory efficient bit state space method by 
    	$ gcc -DBITSTATE -o pan pan.c
    An indication of the coverage of such a search can be derived from the hash factor (see below). The generated executable analyzer, named run above, has its own set of options that can be seen by typing "./pan -?" (see also below in Using the Analyzer ).

    -m can be used to change the default semantics of send actions. Normally, a send operation is only executable if the target channel is non-full. This imposes an implicit synchronization that can not always be justified. Option -m causes send actions to be always executable. Messages sent to a channel that is full are then dropped. If this option is combined with -a the semantics of send in the analyzers generated is similarly altered, and the verifications will take the effects of this type of message loss into consideration.

    -t is a trail-hunting option. If the analyzer finds a violation of an assertion, a deadlock or an unspecified reception, it writes an error trail into a file named pan.trail. The trail can be inspected in detail by invoking Spin with the -t option. In combination with the options pglrs different views of the error sequence are then easily obtained.

    For brevity, other options of Spin are not discussed here. For details see [5]. For a hint of their purpose, see ``Digging Deeper'' at the end of this manual.

    The Simulator

    Consider the following example protocol, that we will store in a file named lynch. 

       1  #define MIN	9
   2  #define MAX	12
   3  #define FILL	99
   4  
   5  mtype = { ack, nak, err }
   6  
   7  proctype transfer(chan chin, chout)
   8  {	byte o, i, last_i=MIN;
   9  
  10  	o = MIN+1;
  11  	do
  12  	:: chin?nak(i) ->
  13  		assert(i == last_i+1);
  14  		chout!ack(o)
  15  	:: chin?ack(i) ->
  16  		if
  17  		:: (o <  MAX) -> o = o+1
  18  		:: (o >= MAX) -> o = FILL
  19  		fi;
  20  		chout!ack(o)
  21  	:: chin?err(i) ->
  22  		chout!nak(o)
  23  	od
  24  }
  25  
  26  proctype channel(chan in, out)
  27  {	byte md, mt;
  28  	do
  29  	:: in?mt,md ->
  30  		if
  31  		:: out!mt,md
  32  		:: out!err,0
  33  		fi
  34  	od
  35  }
  36  
  37  init
  38  {	chan AtoB = [1] of { mtype, byte };
  39  	chan BtoC = [1] of { mtype, byte };
  40  	chan CtoA = [1] of { mtype, byte };
  41  	atomic {
  42  		run transfer(AtoB, BtoC);
  43  		run channel(BtoC, CtoA);
  44  		run transfer(CtoA, AtoB)
  45  	};
  46  	AtoB!err,0;	/* start */
  47  	0		/* hang */
  48  }
    The protocol uses three message types: ack, nak, and a special type err that is used to model message distortions on the communication channel between the two transfer processes. The behavior of the channel is modeled explicitly with a channel process. There is also an assert statement that claims a, faulty, invariant relation between two local variables in the transfer processes.

    Running Spin without options gives us a random simulation that will only provide output when execution terminates, or if a printf statement is encountered. In this case: 

    	$ spin lynch	# no options, not recommended
	spin: "lynch" line 13: assertion violated
	#processes: 4
	proc  3 (transfer)	line 11 (state 15)
	proc  2 (channel)	line 28 (state 6)
	proc  1 (transfer)	line 13 (state 3)
	proc  0 (:init:)	line 48 (state 6)
	4 processes created
	$
    There are no printf's in the specification, but we do get some output because the execution stops on an assertion violation. Curious to find out more, we can repeat the run with more verbose output, e.g. printing all receive events. The result of that run is shown in Figure 1. Most output will be self-explanatory.

    The above simulation run ends in the same assertion violation. Since the simulation resolves nondeterministic choices in a random manner, this need not always be the case. To force a reproducible run, the option -n N can be used. For instance: 

    	$ spin -r -n100 lynch
    will seed the random number generator with the integer value 100 and is guaranteed to produce the same output each time it is executed.

    The other options can add still more output to the simulation run, but the amount of text can quickly become overwhelming. An easy solution is to filter the output through grep. For instance, if we are only interested in the behavior of the channel process in the above example, we say: 

    	$ spin -n100 -r lynch | grep "proc  2"
    The results are shown in Figure 1. 
    	$ spin -r lynch
	proc  1 (transfer) line  21, Recv err,0  <- queue 1 (chin)
	proc  2 (channel)  line  29, Recv nak,10 <- queue 2 (in)
	proc  3 (transfer) line  12, Recv nak,10 <- queue 3 (chin)
	proc  1 (transfer) line  15, Recv ack,10 <- queue 1 (chin)
	...
	proc  1 (transfer) line  15, Recv ack,12 <- queue 1 (chin)
	proc  2 (channel)  line  29, Recv ack,99 <- queue 2 (in)
	proc  3 (transfer) line  15, Recv ack,99 <- queue 3 (chin)
	proc  1 (transfer) line  15, Recv ack,99 <- queue 1 (chin)
	proc  2 (channel)  line  29, Recv ack,99 <- queue 2 (in)
	proc  3 (transfer) line  21, Recv err,0  <- queue 3 (chin)
	proc  1 (transfer) line  12, Recv nak,99 <- queue 1 (chin)
	spin: "lynch" line 13: assertion violated
	#processes: 4
	proc  3 (transfer) line 11 (state 15)
	proc  2 (channel)  line 28 (state 6)
	proc  1 (transfer) line 13 (state 3)
	proc  0 (:init:)   line 48 (state 6)
	4 processes created
	$ spin -n100 -r lynch | grep "proc  2"
	proc  2 (channel) line 29, Recv nak,10 <- queue 2 (in)
	proc  2 (channel) line 29, Recv ack,11 <- queue 2 (in)
	proc  2 (channel) line 29, Recv ack,12 <- queue 2 (in)
	proc  2 (channel) line 28 (state 6)

	Figure 1.  Simulation Run Output
    A good way to start simulation runs like this is to use option -c (new in version 3.0), which produces the following output: 
    	$ spin -c lynch
	proc 0 = :init:
	proc 1 = transfer
	proc 2 = channel
	proc 3 = transfer
	q\p   0   1   2   3
	  1   AtoB!err,0
	  1   .   chin?err,0
	  2   .   chout!nak,10
	  2   .   .   in?nak,10
	  3   .   .   out!err,0
	  3   .   .   .   chin?err,0
	  1   .   .   .   chout!nak,10
	  1   .   chin?nak,10
	  2   .   chout!ack,10
	  2   .   .   in?ack,10
	  3   .   .   out!ack,10
	  3   .   .   .   chin?ack,10
	  1   .   .   .   chout!ack,11
	  1   .   chin?ack,11
	  2   .   chout!ack,11
	  2   .   .   in?ack,11
	  3   .   .   out!ack,11
	  3   .   .   .   chin?ack,11
	  1   .   .   .   chout!ack,12
	  1   .   chin?ack,12
	  2   .   chout!ack,12
	  2   .   .   in?ack,12
	  3   .   .   out!ack,12
	  3   .   .   .   chin?ack,12
	  1   .   .   .   chout!ack,99
	  1   .   chin?ack,99
	  2   .   chout!ack,99
	  2   .   .   in?ack,99
	  3   .   .   out!err,0
	  3   .   .   .   chin?err,0
	  1   .   .   .   chout!nak,99
	  1   .   chin?nak,99
	spin: line  13 "lynch", Error: assertion violated
	-------------
	final state:
	-------------
	#processes: 4
	 79:    proc  3 (transfer) line  11 "lynch" (state 15)
	 79:    proc  2 (channel) line  28 "lynch" (state 6)
	 79:    proc  1 (transfer) line  13 "lynch" (state 3)
	 79:    proc  0 (:init:) line  47 "lynch" (state 6)
	4 processes created
    The first column gives the channel id numbers, the first row gives the process id numbers involved in message transfers plotted in the remained of the table.

    The Analyzer (see also Pan.html and Roadmap.html)

    The simulation runs can be useful in quick debugging of new designs, but by simulation alone we can not prove that the system is really error free. A verification of even very large models can be performed with the -a and -t options of Spin.

    An exhaustive state space searching program for a protocol model is generated as follows, producing five files, named pan.[bchmt]. 

    	$ spin -a lynch
	$ wc pan.[bchmt]
	     99     285    1893 pan.b
	   3158   10208   70337 pan.c
	    356    1238    7786 pan.h
	    216     903    6045 pan.m
	    575    2099   14017 pan.t
	   4404   14733  100078 total
    The details are none too interesting: pan.c contains most of the C code for the analysis of the protocol. File pan.t contains a transition matrix that encodes the protocol control flow; pan.b and pan.m contain C code for forward and backward transitions and pan.h is a general header file. The program can be compiled in several ways, e.g., with a full state space or with a bit state space.

    Exhaustive Search

    The best method, that works up to system state spaces of roughly 100,000 states, is to use the default compilation of the program: 

    	$ gcc -o pan pan.c
    The executable program pan can now be executed to perform the verification. The verification is truly exhaustive: it tests all possible event sequences in all possible orders. It should, of course, find the same assertion violation. 
    	$ ./pan
	assertion violated (i == last_i + 1))
	pan: aborted
	pan: wrote pan.trail
	search interrupted
	vector 64 byte, depth reached 56
	      61 states, stored
	       5 states, linked
	       1 states, matched
	hash conflicts: 0 (resolved)
	(size 2^18 states, stack frames: 0/5)
    (The output format of the more recent versions of Spin is more elaborate, but it includes the same information.)

    The first line of the output announces the assertion violation and attempts to give a first indication of the invariant that was violated. The violation was found after 61 states had been generated. Hash "conflicts" gives the number of hash collisions that happened during access to the state space. As indicated, all collissions are resolved in full search mode, since all states are placed in a linked list. The most relevant piece of output in this case, however, is on the third line which tells us that a trail file was created that can be used in combination with the simulator to recreate the error sequence. We can now say, for instance 

    	$ spin -t -r lynch | grep "proc  2"
    to determine the cause of the error. Note carefully that the verifier is guaranteed to find the assertion violation if it is feasible. If an exhaustive search does not report such a violation, it is certain that no execution execution sequence exists that can violate the assertion.

    Options

    The executable analyzer that is generated comes with a modest number of options that can be checked as follows 

    	$ ./pan --
	-cN stop at Nth error (default=1)
	-l  find non-progress cycles	# when compiled with -DNP
	-a  find acceptance cycles	# when not compiled with -DNP
	-mN max depth N (default=10k)
	-wN hash table of 2^N entries (default=18)
	 ...etc.
    Using a zero as an argument to the first option forces the state space search to continue, even if errors are found. An overview of unexecutable (unreachable) code is given with every complete run: either the default run if it did not find any errors, or the run with option -c0. In this case the output is: 
    	$ ./pan -c0
	assertion violated (i == (last_i + 1))
	
	vector 64 byte, depth reached 60, errors: 5
	     165 states, stored
	       5 states, linked
	      26 states, matched
	hash conflicts: 1 (resolved)
	(size 2^18 states, stack frames: 0/6)
	
	unreached code :init: (proc 0):
		reached all 9 states
	unreached code channel (proc 1):
		 line 35 (state 9),
		reached: 8 of 9 states
	unreached code transfer (proc 2):
		 line 24 (state 18),
		reached: 17 of 18 states
    There were five assertion violations, and some 165 unique system states were generated. Each state description (the vector size) took up 64 bytes of memory; the longest non-cyclic execution sequence was 60. There is one unreachable state both in the channel process and in the transfer process. In both cases the unreachable state is the control flow point just after the do-loop in each process. Note that both loops are indeed meant to be non-terminating.

    The -l option will cause the analyzer to search for non-progress loops rather than deadlocks or assertion violations. The option is explained in the section on ``More Advanced Usage.''

    The executable analyzer has two other options. By default the search depth is restricted to a rather arbitrary 10,000 steps. If the depth limit is reached, the search is truncated, making the verification less than exhaustive. To make certain that the search is exhaustive, make sure that the "depth reached" notice is within the maximum search depth, and if not, repeat the analysis with an explicit -m argument.

    The -m option can of course also be used to truncate the search explicitly, in an effort to find the shortest possible execution sequence that violates a given assertion. Such a truncated search, however, is not guaranteed to find every possible violation, even within the search depth.

    The last option -w N can only affect the run time, not the scope, of an analysis with a full state space. This "hash table width" should normally be set equal to, or preferably higher than, the logarithm of the expected number of unique system states generated by the analyzer. (If it is set too low, the number of hash collisions will increase and slow down the search.) The default N of 18 handles up to 262,144 system states, which should suffice for almost all applications of a full state space analysis.

    Bit State Space Analyses

    It can easily be calculated what the memory requirements of an analysis with a full state space are [4]. If, as in the example we have used, the protocol requires 64 bytes of memory to encode one system state, and we have a total of 2MB of memory available for the search, we can store up to 32,768 states. The analysis fails if there are more reachable states in the system state space. So far, Spin is the only verification system that can avoid this trap. All other existing automated verification system (irrespective on which formalism they are based) simply run out of memory and abort their analysis without returning a useful answer to the user.

    The coverage of a conventional analysis goes down rapidly when the memory limit is hit, i.e. if there are twice as many states in the full state space than we can store, the effective coverage of the search is only 50% and so on. Spin does substantially better in those cases by using the bit state space storage method [4]. The bit state space can be included by compiling the analyzer as follows: 

    	$ gcc -DBITSTATE -o pan pan.c
    The analyzer compiled in this way should of course find the same assertion violation again: 
    	$ ./pan
	assertion violated (i == ((last_i + 1))
	pan: aborted
	pan: wrote pan.trail
	search interrupted
	vector 64 byte, depth reached 56
	      61 states, stored
	       5 states, linked
	       1 states, matched
	hash factor: 67650.064516
	(size 2^22 states, stack frames: 0/5)
	$
    In fact, for small to medium size problems there is very little difference between the full state space method and the bit state space method (with the exception that the latter is somewhat faster and uses substantially less memory). The big difference comes for larger problems. The last two lines in the output are useful in estimating the coverage of a large run. The maximum number of states that the bit state space can accommodate is written on the last line (here 2 22 bytes or about 32 million bits = states). The line above it gives the hash factor: roughly equal to the maximum number of states divided by the actual number of states. A large hash factor (larger than 100) means, with high reliability, a coverage of 99% or 100%. As the hash factor approaches 1 the coverage approaches 0%.

    Note carefully that the analyzer realizes a partial coverage only in cases where traditional verifiers are either unable to perform a search, or realize a far smaller coverage. In no case will Spin produce an answer that is less reliable than that produced by other automated verification systems (quite on the contrary).

    The object of a bit state verification is to achieve a hash factor larger than 100 by allocating the maximum amount of memory for the bit state space. For the best result obtainable: use the -w N option to size the state space to precisely the amount of real (not virtual) memory available on your machine. By default, N is 22, corresponding to a state space of 4MB. For example, if your machine has 128MB of real memory, you can use -w27 to analyze systems with up to a billion reachable states.

    Summary

    In the first part of this manual we have introduced a notation for modeling concurrent systems, including but not limited to asynchronous data communication protocols, in a language named Promela. The language has several unusual features. All communication between processes takes place via either messages or shared variables. Both synchronous and asynchronous communication are modeled as two special cases of a general message passing mechanism. Every statement in Promela can potentially model delay: it is either executable or not, in most cases depending on the state of the environment of the running process. Process interaction and process coordination is thus at the very basis of the language. More about the design of Promela, of the verifier Spin, and its range of applications, can be found in [5].

    Promela is deliberately a verification modeling language, not a programming language. There are, for instance, no elaborate abstract data types, or more than a few basic types of variable. A verification model is an abstraction of a protocol implementation. The abstraction maintains the essentials of the process interactions, so that it can be studied in isolation. It suppresses implementation and programming detail.

    The syntax of Promela expressions, declarations, and assignments is loosely based on the language C[6]. The language was influenced significantly by the ``guarded command languages'' of E.W. Dijkstra [1] and C.A.R. Hoare [3]. There are, however, important differences. Dijkstra's language had no primitives for process interaction. Hoare's language was based exclusively on synchronous communication. Also in Hoare's language, the type of statements that could appear in the guards of an option was restricted. The semantics of the selection and cycling statements in Promela is also rather different from other guarded command languages: the statements are not aborted when all guards are false but they block: thus providing the required synchronization.

    With minimal effort Spin allows the user to generate sophisticated analyzers from Promela verification models. Both the Spin software itself, and the analyzers it can generate, are written in ANSI C and are portable across Unix systems. They can be scaled to fully exploit the physical limitations of the host computer, and deliver within those limits the best possible analyses that can be realized with the current state of the art in protocol analysis.

    Appendix: Building a Verification Suite

    See also Exercises.html, and Roadmap.html

    The first order of business in using Spin for a verification is the construction of a faithful model in Promela of the problem at hand. The language is deliberately kept small. The purpose of the modeling is to extract those aspects of the system that are relevant to the coordination problem being studied. All other details are suppressed. Formally: the model is a reduction of the system that needs to be equivalent to the full system only with respect to the properties that are being verified. Once a model has been constructed, it becomes the basis for the construction of a series of, what we may call, ``verification suites'' that are used to verify its properties. To build a verification suite we can prime the model with assertions. The assertions can formalize invariant relations about the values of variables or about allowable sequences of events in the model.

    As a first example we take the following solution to the mutual exclusion problem, discussed earlier, published in 1966 by H. Hyman in the Communications of the ACM. It was listed, in pseudo Algol, as follows. 

      1 Boolean array b(0;1) integer k, i,
  2 comment process i, with i either 0 or 1, and k = 1-i;
  3 C0:	b(i) := false;
  4 C1:	if k != i then begin;
  5 C2:	if not b(1-i) then go to C2;
  6 	else k := i; go to C1 end;
  7 	else critical section;
  8 	b(i) := true;
  9 	remainder of program;
 10 	go to C0;
 11 	end
    The solution, as Dekker's earlier solution, is for two processes, numbered 0 and 1. Suppose we wanted to prove that Hyman's solution truly guaranteed mutually exclusive access to the critical section. Our first task is to build a model of the solution in Promela. While we're at it, we can pick some more useful names for the variables that are used. 
       1  bool want[2];	/* Bool array b */
   2  bool turn;	/* integer    k */
   3  
   4  proctype P(bool i)
   5  {
   6  	want[i] = 1;
   7  	do
   8  	:: (turn != i) ->
   9  		(!want[1-i]);
  10  		turn = i
  11  	:: (turn == i) ->
  12  		break
  13  	od;
  14  	skip; /* critical section */
  15  	want[i] = 0
  16  }
  17  
  18  init { run P(0); run P(1) }
    We can generate, compile, and run a verifier for this model, to see if there are any major problems, such as a global system deadlock. 
    	$ spin -a hyman0
	$ gcc -o pan pan.c
	$ ./pan
	full statespace search for:
	assertion violations and invalid endstates
	vector 20 byte, depth reached 19, errors: 0
	      79 states, stored
	       0 states, linked
	      38 states, matched	total: 117
	hash conflicts: 4 (resolved)
	(size 2^18 states, stack frames: 3/0)
	
	unreached code _init (proc 0):
		reached all 3 states
	unreached code P (proc 1):
		reached all 12 states
    The model passes this first test. What we are really interested in, however, is if the algorithm guarantees mutual exclusion. There are several ways to proceed. The simplest is to just add enough information to the model that we can express the correctness requirement in a Promela assertion. 
       1  bool want[2];
   2  bool turn;
   3  byte cnt;
   4  
   5  proctype P(bool i)
   6  {
   7  	want[i] = 1;
   8  	do
   9  	:: (turn != i) ->
  10  		(!want[1-i]);
  11  		turn = i
  12  	:: (turn == i) ->
  13  		break
  14  	od;
  15  	skip; /* critical section */
  16  	cnt = cnt+1;
  17  	assert(cnt == 1);
  18  	cnt = cnt-1;
  19  	want[i] = 0
  20  }
  21  
  22  init { run P(0); run P(1) }
    We have added a global variable cnt that is incremented upon each access to the critical section, and decremented upon each exit from it. The maximum value that this variable should ever have is 1, and it can only have this value when a process is inside the critical section. 
    	$ spin -a hyman1
	$ gcc -o pan pan.c
	$ ./pan
	assertion violated (cnt==1)
	pan: aborted (at depth 15)
	pan: wrote pan.trail
	full statespace search for:
	assertion violations and invalid endstates
	search was not completed
	vector 20 byte, depth reached 25, errors: 1
	     123 states, stored
	       0 states, linked
	      55 states, matched	total: 178
	hash conflicts: 42 (resolved)
	(size 2^18 states, stack frames: 3/0)
    The verifier claims that the assertion can be violated. We can use the error trail to check it with Spin's -t option: 
    	$ spin -t -p hyman1
	proc  0 (_init)	line 24 (state 2)
	proc  0 (_init)	line 24 (state 3)
	proc  2 (P)	line 8 (state 7)
	proc  2 (P)	line 9 (state 2)
	proc  2 (P)	line 10 (state 3)
	proc  2 (P)	line 11 (state 4)
	proc  1 (P)	line 8 (state 7)
	proc  1 (P)	line 12 (state 5)
	proc  1 (P)	line 15 (state 10)
	proc  2 (P)	line 8 (state 7)
	proc  2 (P)	line 12 (state 5)
	proc  2 (P)	line 15 (state 10)
	proc  2 (P)	line 16 (state 11)
	proc  2 (P)	line 17 (state 12)
	proc  2 (P)	line 18 (state 13)
	proc  1 (P)	line 16 (state 11)
	proc  1 (P)	line 17 (state 12)
	spin: "hyman1" line 17: assertion violated
	step 17, #processes: 3
			want[0] = 1
			_p[0] = 12
			turn[0] = 1
			cnt[0] = 2
	
	proc  2 (P)	line 18 (state 13)
	proc  1 (P)	line 17 (state 12)
	proc  0 (_init)	line 24 (state 3)
	3 processes created
    Here is another way to catch the error. We again lace the model with the information that will allow us to count the number of processes in the critical section. 
       1  bool want[2];
   2  bool turn;
   3  byte cnt;
   4  
   5  proctype P(bool i)
   6  {
   7  	want[i] = 1;
   8  	do
   9  	:: (turn != i) ->
  10  		(!want[1-i]);
  11  		turn = i
  12  	:: (turn == i) ->
  13  		break
  14  	od;
  15  	cnt = cnt+1;
  16  	skip;	/* critical section */
  17  	cnt = cnt-1;
  18  	want[i] = 0
  19  }
  20  
  21  proctype monitor()
  22  {
  23  	assert(cnt == 0 || cnt == 1)
  24  }
  25  
  26  init {
  27  	run P(0); run P(1); run monitor()
  28  }
    The invariant condition on the value of counter cnt is now place in a separate process monitor() (the name is immaterial). The extra process runs along with the two others. It will always terminate in one step, but it could execute that step at any time. The systems modeled by Promela and verified by Spin are completely asynchronous. That means that the verification of Spin take into account all possible relative timings of the three processes. In a full verification, the assertion therefore can be evaluated at any time during the lifetime of the other two processes. If the verifier reports that it is not violated we can indeed conclude that there is no execution sequence at all (no way to select relative speeds for the three processes) in which the assertion can be violated. The setup with the monitor process is therefore an elegant way to check the validity of a system invariant. The verification produces: 
    	$ spin -a hyman2
	$ gcc -o pan pan.c
	$ ./pan
	assertion violated ((cnt==0)||(cnt==1))
	pan: aborted (at depth 15)
	pan: wrote pan.trail
	full statespace search for:
	assertion violations and invalid endstates
	search was not completed
	vector 24 byte, depth reached 26, errors: 1
	     368 states, stored
	       0 states, linked
	     379 states, matched	total: 747
	hash conflicts: 180 (resolved)
	(size 2^18 states, stack frames: 4/0)
    Because of the extra interleaving of the two processes with a third monitor, the number of system states that had to be searched has increased, but the error is again correctly reported.

    Another Example

    Not always can a correctness requirement be cast in terms of a global system invariant. Here is an example that illustrates this. It is a simple alternating bit protocol, modeling the possibility of message loss, and distortion, and extended with negative acknowledgements. 

       1  #define MAX	5
   2  
   3  mtype = { mesg, ack, nak, err };
   4  
   5  proctype sender(chan in, out)
   6  {	byte o, s, r;
   7  
   8  	o=MAX-1;
   9  	do
  10  	:: o = (o+1)%MAX; /* next msg */
  11  again: if
  12         :: out!mesg(o,s) /* send */
  13         :: out!err(0,0)  /* distort */
  14         :: skip       /* or lose */
  15         fi;
  16         if
  17         :: timeout   -> goto again
  18         :: in?err(0,0) -> goto again
  19         :: in?nak(r,0) -> goto again
  20         :: in?ack(r,0) ->
  21  		if
  22  		:: (r == s) -> goto progress
  23  		:: (r != s) -> goto again
  24  		fi
  25         fi;
  26  progress:	s = 1-s	/* toggle seqno */
  27  	od
  28  }
  29  
  30  proctype receiver(chan in, out)
  31  {	byte i;		/* actual input   */
  32  	byte s;		/* actual seqno   */
  33  	byte es;	/* expected seqno */
  34  	byte ei;	/* expected input */
  35  
  36  	do
  37  	:: in?mesg(i, s) ->
  38  		if
  39  		:: (s == es) ->
  40  			assert(i == ei);
  41  progress:		es = 1 - es;
  42  			ei = (ei + 1)%MAX;
  43  			if
  44  	/* send,   */	:: out!ack(s,0)
  45  	/* distort */	:: out!err(0,0)
  46  	/* or lose */	:: skip
  47  			fi
  48  		:: (s != es) ->
  49  			if
  50  	/* send,   */	:: out!nak(s,0)
  51  	/* distort */	:: out!err(0,0)
  52  	/* or lose */	:: skip
  53  			fi
  54  		fi
  55  	:: in?err ->
  56  		out!nak(s,0)
  57  	od
  58  }
  59  
  60  init {
  61  	chan s_r = [1] of { mtype,byte,byte };
  62  	chan r_s = [1] of { mtype,byte,byte };
  63  	atomic {
  64  		run sender(r_s, s_r);
  65  		run receiver(s_r, r_s)
  66  	}
  67  }
    To test the proposition that this protocol will correctly transfer data, the model has already been primed for the first verification runs. First, the sender is setup to transfer an infinite series of integers as messages, where the value of the integers are incremented modulo MAX. The value of MAX is not really too interesting, as long as it is larger than the range of the sequence numbers in the protocol: in this case 2. We want to verify that data that is sent can only be delivered to the receiver without any deletions or reorderings, despite the possibility of arbitrary message loss. The assertion on line 40 verifies precisely that. Note that if it were ever possible for the protocol to fail to meet the above requirement, the assertion can be violated.

    A first verification run reassures us that this is not possible. 

    	$ spin -a ABP0
	$ gcc -o pan pan.c
	$ ./pan
	full statespace search for:
	assertion violations and invalid endstates
	vector 40 byte, depth reached 131, errors: 0
	     346 states, stored
	       1 states, linked
	     125 states, matched	 total: 472
	hash conflicts: 17 (resolved)
	(size 2^18 states, stack frames: 0/25)
	
	unreached code _init (proc 0):
		reached all 4 states
	unreached code receiver (proc 1):
		line 58 (state 24)
		reached: 23 of 24 states
	unreached code sender (proc 2):
		line 28 (state 27)
		reached: 26 of 27 states
    But, be careful. The result means that all data that is delivered, is delivered in the correct order without deletions etc. We did not check that the data will necessarily be delivered. It may be possible for sender and receiver to cycle through a series of states, exchanges erroneous messages, without ever making effective progress. To check this, the state in the sender and in the receiver process that unmistakingly signify progress, were labeled as a ``progress states.'' (In fact, either one by itself would suffice.)

    We should now be able to demonstrate the absence of infinite execution cycles that do not pass through any of these progress states. We cannot use the same executable from the last run, but it's easy to setup the verifier for non-progress cycle detection: 

    	$ gcc -DNP -o pan pan.c
	$ ./pan -l
	pan: non-progress cycle (at depth 6)
	pan: wrote pan.trail
	full statespace search for:
	assertion violations and non-progress loops
	search was not completed
	vector 44 byte, depth reached 8, loops: 1
	      12 states, stored
	       1 states, linked
	       0 states, matched	total: 13
	hash conflicts: 0 (resolved)
	(size 2^18 states, stack frames: 0/1)
    There is at least one non-progress cycle. The first one encountered is dumped into the error trail by the verifier, and we can inspect it. The results are shown in the first half of Figure 2. The channel can distort or lose the message infinitely often; true, but not too exciting as an error scenario. To see how many non-progress cycles there are, we can use the -c flag. If we set its numeric argument to zero, only a total count of all errors will be printed. 
    	$ pan -l -c0
	full statespace search for:
	assertion violations and non-progress loops
	vector 44 byte, depth reached 137, loops: 92
	     671 states, stored
	       2 states, linked
	     521 states, matched	 total: 1194
	hash conflicts: 39 (resolved)
	(size 2^18 states, stack frames: 0/26)
    There are 92 cases to consider, and we could look at each one, using the -c option (-c1, -c2, -c3, ...etc.) But, we can make the job a little easier by at least filtering out the errors caused by infinite message loss. We label all loss events (lines 13, 43, and 48) as progress states, using label names with the common 8-character prefix ``progress,'' and look at the cycles that remain. (Labels go behind the ``::'' flags.) 
    	$ spin -a ABP1
	$ gcc -DNP -o pan pan.c
	
	$ ./pan -l
	pan: non-progress cycle (at depth 133)
	pan: wrote pan.trail
	
	full statespace search for:
	assertion violations and non-progress loops
	search was not completed
	
	vector 44 byte, depth reached 136, loops: 1
	
	     148 states, stored
	       2 states, linked
	       2 states, matched	 total: 152
	
	hash conflicts: 0 (resolved)
	(size 2^18 states, stack frames: 0/26)
    This time, the trace reveals an honest and a serious bug in the protocol. The second half of Figure 2 shows the trace-back. 
          $ spin -t -r -s ABP0
      <<<<>>>>
      proc  1 (sender)   line  13, Send err,0,0 -> queue 2 (out)
      proc  2 (receiver) line  55, Recv err,0,0 <- queue 2 (in)
      proc  2 (receiver) line  56, Send nak,0,0 -> queue 1 (out)
      proc  1 (sender)   line  19, Recv nak,0,0 <- queue 1 (in)
      spin: trail ends after 12 steps
      step 12, #processes: 3
		_p[0] = 6
      proc  2 (receiver)	line 36 (state 21)
      proc  1 (sender)	line 11 (state 6)
      proc  0 (_init)	line 67 (state 4)
      3 processes created
      $ 
      $ spin -t -r -s ABP1
      ...
      proc  2 (receiver) line  39, Recv mesg,0,0 <- queue 2 (in)
      proc  2 (receiver) line  47, Send err,0,0  -> queue 1 (out)
      proc  1 (sender)   line  20, Recv err,1,0  <- queue 1 (in)
      proc  1 (sender)   line  12, Send mesg,0,0 -> queue 2 (out)
      proc  2 (receiver) line  39, Recv mesg,0,0 <- queue 2 (in)
      proc  2 (receiver) line  52, Send nak,0,0  -> queue 1 (out)
      proc  1 (sender)   line  21, Recv nak,0,0  <- queue 1 (in)
      proc  1 (sender)   line  12, Send mesg,0,0 -> queue 2 (out)
      proc  2 (receiver) line  39, Recv mesg,0,0 <- queue 2 (in)
      proc  2 (receiver) line  52, Send nak,0,0  -> queue 1 (out)
      <<<<>>>>
      proc  1 (sender)   line  21, Recv nak,0,0  <- queue 1 (in)
      proc  1 (sender)   line  12, Send mesg,0,0 -> queue 2 (out)
      proc  2 (receiver) line  39, Recv mesg,0,0 <- queue 2 (in)
      proc  2 (receiver) line  52, Send nak,0,0  -> queue 1 (out)
      spin: trail ends after 226 steps
      ...

	Figure 2.  Error Trails - Extended Alternating Bit Protocol

    After a single positive acknowledgement is distorted and transformed into an err message, sender and receiver get caught in an infinite cycle, where the sender will stubbornly repeat the last message for which it did not receive an acknowledgement, and the receiver, just as stubbornly, will reject that message with a negative acknowledgment.

    Digging Deeper

    This manual can only give an outline of the main features of Spin, and the more common ways in which it can be used for verifications. There is a number of Spin features that have not been discussed here, but that may be useful for tackling verification problems.

    Spin also allows for a straightforward verification of `tasks,' or `requirements,' modeled as never-claims. That is, if the user formalizes a task that is claimed to be performed by the system, Spin can quickly either prove or disprove that claim. A never-claim is equivalent to a Büchi Automaton, and can thus model any linear time temporal logic formula. In the newer versions of Spin, the user can use normal LTL syntax to define the requirements, and let Spin perform the translation chore to the corresponding never-claim.

    Spin also allows the user to formalize `reductions' of the system state space, which can be used to restrict a search it to a user defined subset (again, using never claims, this time to `prune' the statespace). With this method it becomes possible to verify quickly whether or not a given error pattern is within the range of behaviors of a system, even when a complete verification is considered to be infeasible.

    For details about these alternative uses of Promela and the Spin software, refer to [5]. The extensions to Spin with version 2.0 and 3.0 are outlined in WhatsNew.html.

    References

    [1] Dijkstra, E.W., ``Guarded commands, non-determinacy and formal derivation of programs.'' CACM 18, 8 (1975), 453-457.
    [2] Dijkstra, E.W., ``Solution to a problem in concurrent programming control.'' CACM 8, 9 (1965), 569.
    [3] Hoare, C.A.R., ``Communicating Sequential Processes.'' CACM 21, 8 (1978), 666-677.
    [4] Holzmann, G.J., ``Algorithms for automated protocol verification.'' AT&T Technical Journal 69, 1 (Jan/Feb 1990). Special Issue on Protocol Testing, Specification, Verification.
    [5] Holzmann, G.J., The Spin Model Checker: Primer and Reference Manual (2003), Addison-Wesley.
    [6] Kernighan, B.W. and Ritchie, D.M., The C Programming Language. 2nd ed. (1988), Prentice Hall.

    Spin Online References
    Promela Manual Index
    Promela Grammar
    Spin HomePage     		(Page Updated: 3 June 2007)
    Spin/Doc/1_Exercises.html0000644000175100017510000011330412641606227013324 0ustar ghgh SPIN VERIFICATION EXAMPLES AND EXERCISES

    SPIN VERIFICATION EXAMPLES AND EXERCISES

    Included below are some verification exercises that can help you get acquainted with the Spin model checker. All examples used here are available as Promela files in the Examples directory of the Spin distribution.

    0. Installing Spin

    We will assume you are using the most recent version of Spin, which at the time of writing is Version 6.4.0. If Spin is not yet installed on your machine, do this (assuming a linux-like machine): 
    	$ cd
	$ wget http://spinroot.com/spin/Src/spin640.tar.gz
	$ tar -xzvf spin640.tar.gz
	$ cd Spin/Src6.4.0
	$ make
	$ cp spin /usr/local/bin	# on a Mac: cp spin /usr/bin
	$ cd ../Examples/Exercises
	$ spin -V	# make sure it's there
	Spin Version 6.4.0 -- 19 September 2014

    1. Evaluating Search Complexity

    This first set of exercises is meant to give an indication of the nature of the state space explosion phenomenon, and how Spin deals with it. It consists of small problems that can be solved with Spin. At each step, it is best to first try to determine what should happen, write down your prediction, and only then perform the experiment with Spin, and explain the result. (Especially if it differs from what you thought would happen.) Answer each of the questions marked a) ... k), spending as much as you need to understand what really happens.

    a) How many reachable states do you predict will the following small Promela model generate? 

    	init {	// file: ex_1a.pml
		byte i	// initialized to 0 by default
		do	// loop forever
		:: i++	// a C-ism for i = i + 1
		od
	}
    Try a simulation run of 514 steps: 
    	$ spin -u514 -p -l ex_1a.pml	# print out local vars at every step
    Notice what happens with the value of byte variable i on the 255-th increment (in step 511).
    Note: The first argument -u514, limits the similation to 514 steps. The second argument -p tells Spin to print some information about every step that it executes, and the third argument -l tells Spin to print also the value of all local variables whenever they change.
    You can see all options that Spin supports by executing: 
    	$ spin --
    i.e., using two dashes as the argument.


    b) Would the simulation terminate if you didn't limit the number of steps?
    c) The model allows for an infinite number of increments of variable i. Is this still a finite state model?

    Note: Spin converts the program-like model into a state machine. You can see this in the simulation sequence, where every increment ends up taking two steps, instead of one. The second step is the jump back to the start of the loop. When we do verification, where performance is important, Spin optimizes the statemachines a bit more, and it gets rid of that second step again. You can see the optimized state machine that Spin generates by executing: 
    	$ spin -search -dump ex_1a.pml
    d) Estimate the number of reachable states for this model. Is it finite? Will a verification run terminate? Try it as follows. 
    	$ spin -search ex_1a.pml	# equivalently: spin -run ex_1a.pml
    Explain the output and the number of states that is reported.
    The -search argument is a shorthand in Spin version 6.4 for a series of steps to perform a formal verification, that you can also execute one by one (but would only do in exceptional cases): 
    	$ spin -a ex_1a.pml # generate a C verifier for the model in pan.c
	$ cc -o pan pan.c   # compile it
	$ ./pan             # execute it
    Spin's -search argument separates arguments processed by Spin in interpreting the model itself (these would go before the -search argument) and arguments that are used to compile and run the verifier (these would go after the -search argument). In our example we needed no additional arguments of either type.

    e) What would happen if you had declared the variable to be of type short instead of byte ? What if you use a bit ? Try these with a verification run and explain the results.

    Note: A bit or boolean variable can only store two different values. As you noted above, a byte variable can store 256 possible values, and is unsigned. The datatype short is defined the same way as it is in the C programming language: it is a signed quantity of 16 bits. See the definition of the data ranges for all Promela types in the manual pages for Promela: here. Note that the ranges can be machine dependent, as they are in C.

    f) Predict how many reachable states there are for the following system, and write them down as a reachability tree. 

    	#ifndef N
	 #define N	2
	#endif
	init {	// file: ex_1f.pml
		chan dummy = [N] of { byte } // a message channel of N slots
		do
		:: dummy!85    // send value  85 to the channel
		:: dummy!170   // send value 170 to the channel
		od
	}
    Note: All Spin models are preprocessed with the standard C preprocessor. This means that we can use include files and macro definitions. In this case, the macro N is defined to have the value 2, unless you define a different value on the command line when you invoke Spin. For instance, you can define N to be 4 by executing: 
    	$ spin -DN=4 -m -search ex_1f.pml
    You can check your prediction as follows. We're only interested in the size of the state space, not in problems that may be caused by blocking on a full channel, so we use the -m option to define that the sender of a message never blocks. (Messages sent to a full channel are then lost.) 
    	$ spin -m -search ex_1f.pml	# use -m to ignore buffer overflow
    Explain the result.
    Note: If you were brave enough to omit the -m argument, you've noticed that there are far fewer states. Spin will in this case report all invalid end-state errors it finds. That term is a nice euphemism for deadlock: a state from which no further progress is possible, but where the process(es) in the model have not all terminated.

    An invalid endstate does not always correspond to an actual deadlock. If it does not, we can label the state where a process is okay to stop with an end-state label. We can place one at the first do keyword in the model, for instance, and then you'd be free to omit the -m flag, since the verifier now knows that it is okay to block the init process at that point in the code. You should get the same number of reachable states as before: 

    	init {
		chan dummy = [N] of { byte } // a message channel of N slots
	end:	do
		:: dummy!85    // send value  85 to the channel
		:: dummy!170   // send value 170 to the channel
		od
	}

    g) What happens if you set N to 3, 4, 5, etc. ? Express the number of states as a function of N. Use your formula to calculate how many states there will be if you set N to 14 ? Check your prediction as follows. 

    	$ spin -DN=14 -m -search ex_1f.pml
    Set N to 20 and repeat the run. 
    	$ spin -DN=20 -m -search ex_1f.pml

    Consider the following metrics on this verification run: 

    	T: the elapsed time for the run that is reported at the end
	S: the number of states stored
	G: the number of total number of states stored and matched
	V: the State-vector size (the amount of memory needed to store one state)
    Note:
    T measures only the time needed to perform the verification. It excludes the time needed for the generation and compilation of the verification code itself. (At higher settings for compiler optimization, and for more complexi models, this can introduce a notable time delay as well.)

    G counts not just new states visited in the search, but also states that were re-visited (matched), so it reflects more accurately how much work was done by the verifier.

    S/T (or G/T) gives you a measure for the efficiency of the verification process, or the rate at which reachable states are processed. Generally this rate will depend on a number of factors, including the size S, and, of course, the speed of your machine. For Spin this rate is typically in the range 105 to 106 states per second. We look at a few other factors that can influence performance below.

    S*V gives you the amount of memory that would be needed to store the full state space without compression. The statespace is not the only place where memory is used during the search (e.g., the stack also consumes memory) but it is typically the largest factor.

    h) The efficiency of a reachability analysis also depends critically on the state space storage algorithm that is used. By default, Spin uses a standard hash-table with linked lists to store states. To study the effect of the hash-table size on performance, repeat the last verification run with a very small hash table, for instance as follows: 

    	$ spin -DN=20 -m -search -w12 ex_1f.pml
    Note: runtime parameter -w12 goes after the -search option, and the other parameters for parsing the model itself go before it.

    Explain the results.
    Hint: compare the number of hash conflicts that is reported for each run.
    Try different settings for the -w argument. Notice that the number of states stored does not change, but the number of hash-conflicts, and the runtime needed, does.

    i) How much memory would you need to do a verification run for our last example with N=24 ?

    Note: both the number of reachable states and the number of bytes per state goes up with N. Estimate that you would need about 42 bytes per state for N=24.

    Now assume that you only have 16 Megabyte of memory available to store the statespace. You likely have much more, but we're going for the dramatic effect here.
    16 MB is 224 bytes, so we could store no more than 16,777,216 / 42 = 399,457, or about 399,000 reachable states in this much memory. Other parts of the verification consume some memory as well, so this is an upper-bound only. To find out the real number, try it as follows. In this command we limit the search to 16 MB plus a 1 MB margin, and we use a small hashtable size (-w15: 
    	$ spin -DN=24 -m -search -DMEMLIM=17 -w15 ex_1f.pml
    We use a small setting for the hash-table -w15, to avoid that the hash-table itself would dominate the memory requirements. The default size of the hash-table would exceed the memory limit we are imposing here.
    All arguments that follow a -search argument are passed by Spin to either the compiler or the runtime verifier. In this case we used both types of pass-thru options. All arguments that preceed the -search argument are processed by Spin itself as before.


    If the real statespace size is2(N+1)-1 states (33,554,431), what fraction of that statespace did you cover in your verification run? Is it more than 1%?

    j) Let's see if we can improve over that last result, without increasing the amount of memory.
    Perform a bitstate search with Spin, as follows. 

    	$ spin -DN=24 -m -search -DMEMLIM=17 -bitstate ex_1f.pml
    The default argument for -w gives us precisely the right size of the hash-array of 16 MB here. (The default is -w27). Compare the number of states stored with that of the earlier run. It should have increased to about 64% of the actual number that you calculated before: a significant increase.
    Note: a few things are worth pointing out here. First, the coverage of the bitstate run is significantly greater than that of the exhaustive run, but both used precisely the same amount of memory. This improves the accuracy of a verification, and improves our chances of finding errors, but it will generally deny us the certainty of a proof if no errors are found.
    We can improve our chances of finding errors even more if we repeat the run with different hash-functions. By changing hash-functions we can achieve that hash-conflicts (which now remain unresolved and lead to truncation of the search) appear in different places, meaning that a different sampling of the state space will result. Spin has 100 different hash-functions builtin. You can change the default of -h1 to for instance -h71 to get a different sampling of the statespace.
    One other things you can vary, to influence the sampling, is the number of bits that is set per state (i.e., the number of independent hash-functions that is used per state). You do so by specifying a -k argument. The default is -k3, which sets three bit-positions per state by using three independent hash-functions, but you can specify any other value greater than zero.

    k) The default setting for the -w argument in a bitstate search is -w27. This defines a bitstate hash-array size of 227 bits, which at 8 bits per byte equals 224 bytes, or 16 MB. In a bitstate search the -w argument does determine the maximum number of states that can be recorded in the bitstate hash-array.
    Repeat the run without the memory bound, and enable some compiler optimization while you're at it, as follows: 

    	$ spin -DN=24 -m -search -O2 -bitstate -w29 ex_1f.pml
    and perform some additional runs with different sizes of the bitstate array (different from the default of -w27). Notice how the coverage achieved is changing for smaller and larger hash-array sizes.
    You should be able to get pretty close to exhaustive coverage of the statespace with a -w30 or -w31 argument, using no more than about 128 MB or 256 MB (a small fraction of what an exhaustive search would consume). Note also if the rate at which states are explored is changing much.
    For added credit, check also how the performance changes if you compile with or without different levels of compiler optimization, e.g., -O, -O2, or -O3.

    2. Verifying a Protocol

    The figure below shows a protocol specification given by Bartlett et al. This figure appears as Figure 3c in the paper referenced, which introduced what became known as the alternating-bit protocol. It was originally designed to make it possible to transmit information reliably over noisy telephone lines with low-speed (e.g., 300 baud) modems.

    A Promela version of this protocol is shown below.

    State S1 is the initial state in process A and state S2 is the initial state in process B. 

      1 mtype = { a0, a1, b0, b1, err } // file ex_2.pml
  2 
  3 chan a2b = [0] of { mtype }	// a rendezvous channel for messages from A to B
  4 chan b2a = [0] of { mtype }	// a second channel for the reverse direction
  5 
  6 active proctype A()
  7 {
  8 S1:	a2b!a1
  9 S2:	if
 10 	:: b2a?b1  -> goto S1
 11 	:: b2a?b0  -> goto S3
 12 	:: b2a?err -> goto S5
 13 	fi
 14 S3:	a2b!a1  -> goto S2
 15 S4:	b2a?err -> goto S5
 16 S5:	a2b!a0  -> goto S4
 17 }
 18 
 19 active proctype B()
 20 {
 21 	goto S2
 22 S1:	b2a!b1
 23 S2:	if
 24 	:: a2b?a0  -> goto S3
 25 	:: a2b?a1  -> goto S1
 26 	:: a2b?err -> goto S5
 27 	fi
 28 S3:	b2a!b0 -> goto S2
 29 S4:	a2b?_  -> goto S1
 30 S5:	a2b!b0 -> goto S4
 31 }
    a) Use a spin verification to see if there are any unreachable states. Explain the result.

    b) How would you modify the model to make all states reachable?

    Consider modeling unreliable channel behavior, by including message loss and/or message corruption as possible behaviors. You can do so by introducing an additional channel process, that shuttles messages from sender to receiver, or you can do so by adding an option at the sender to either send message correctly, or as an err message, to simulate corruption.
    Like this: 
    	S1:	if
		:: b2a!b1	// correct transmission
		:: b2a!err	// model message corruption
		fi
    c) How could you extend the model to be able to prove the following property:
      "Every message fetched by A is received error-free at least once and accepted at most once by B."
    This problem is a little harder. Skip it if you're not already familiar with writing Promela specifications.
    Hint: you can add fields to the messages with data values. To do so you have to change the channel declarations. For instance, as follows: 
    	chan a2b = [0] of { mtype, byte }
	chan b2a = [0] of { mtype, byte }
    where the send and receive operations now have two field of matching types. For instance: 
    	a2b!a1(78)
    You can find more hints about proving this type of property in the last problem in this set, below.

    3. Verifying a Mutual Exclusion Algorithm

    If two or more concurrent processes execute the same code and access the same data, there is a potential problem that they may overwrite each others results and corrupt the data. The mutual exclusion problem is the problem of restricting access to a critical section in the code to a single process at a time, assuming only the indivisibility of read and write instructions. The problem was first described by Edsger Dijkstra.

    In practical applications, the mutual exclusion problem is normally solved by using locks or semaphores. (The concept of a semaphore was also first proposed by Dijkstra.) Locks and semaphores in turn are typically implemented with special indivisible machine instructions for test and set or compare and swap operations.
    It is especially important to note that mutual exclusion algorithms that do not use any special machine instructions no longer work correctly on modern CPU architectures with out-of-order execution. On these machines (i.e., the machine your using now, no matter which brand it is) the problem can not be solved under the constraints that Dijkstra defined in 1965. Nonetheless, for mysterious reasons, mutual exclusion algorithms still remain popular as examples of the application of logic model checking.

    a) Dijkstra published a first solution to the problem (that worked on the CPUs from that time) in his 1965 paper. A year later a different author published an "improved" solution" in the same journal (Comm. of the ACM, Vol. 9, No. 1, p. 45). It is reproduced here as it was published (in pseudo Algol). 

      1 Boolean array b(0;1) integer k, i, j,
  2 comment process i, with i either 0 or 1 and j = 1-i;
  3 C0:	b(i) := false;
  4 C1:	if k != i then begin
  5 C2:	if not (b(j) then go to C2;
  6 	else k := i; go to C1 end;
  7 	else critical section;
  8 	b(i) := true;
  9 	remainder of program;
 10 	go to C0;
 11 	end
    Model this algorithm as a Spin model, and prove or disprove the correctness of the algorithm. You do not need to, and should not, consider out of order executions.
    If you get stuck, take a look at a sample solution in file ex_3a.pml -- and analyze it as follows: 
    	$ spin -search ex_3a.pml
	$ spin -p -replay ex_3a.pml
    In this sample solution an LTL property is used to verify the algorithm. You can also verify this simple safety property with a plain assertion. For hints on how to do that, see the suggestion box at problem 3b below. For more suggestions for replaying counter-examples, or finding shorter alternative sequences, look for the suggestion box under problem 3c below.

    b) The mutual exclusion problem was popular as an intellectual challenge for a very long time. For an overview solution attempts up to roughly 1984, see Raynal or Lamport. An elegant solution was published by Peterson. In Promela the solution can be modeled as follows. The predefined Promela variable _pid contains the id of the running process: which in this case is either 0 or 1. 

      1 bool flag[2]	// file: ex_3b.pml
  2 bool turn
  3 
  4 active [2] proctype user()
  5 {
  6 	flag[_pid] = true
  7 	turn = _pid
  8 	(flag[1-_pid] == false || turn == 1-_pid)
  9 
 10 crit: skip	// critical section
 11 
 12 	flag[_pid] = false
 13 }
    Verify Peterson's algorithm with Spin.
    A simple way to do the check is to count the number of processes that can reach the label crit. You can add a global variable cnt, and increment it before reaching the label, and decrement it afterwards. Now it is easy to perform the critical check, simply with an assertion. For instance: 
    	 9       cnt++
	10 crit: assert(cnt == 1)
	11       cnt--
    Additional questions: what data type should cnt have? Could it be a bit? Could it be an int? Should it? Could the variable cnt be declared locally instead of globally? Explain your answer.

    c) Far too many publications contained what later turned out to be faulty solutions to the mutual exclusion problem. In the sixties and seventies there were no model checkers to quickly find out whether or not a solution was sound. As an example, the next version of the algorithm was recommended by a computer manufacturer to a customer in the late eighties. 

      1 byte cnt                                    // file ex_3c.pml
  2 byte x, y, z
  3 
  4 active [2] proctype user()
  5 {	byte me = _pid+1			// 1 or 2
  6 
  7 L1:	x = me
  8 	if
  9 	:: (y != 0 && y != me) -> goto L1	// try again
 10 	:: (y == 0 || y == me)
 11 	fi
 12 	z = me
 13 	if
 14 	:: (x != me)  -> goto L1		// try again
 15 	:: (x == me)
 16 	fi
 17 	y = me
 18 	if
 19 	:: (z != me) -> goto L1			// try again
 20 	:: (z == me)
 21 	fi					// success
 22 	cnt++
 23 	assert(cnt == 1)			// critical section
 24 	cnt--
 25 	goto L1					// Dijkstra wouldn't like this either
 26 }
    First try to find a scenario that leads to the assertion violation by studying the algorithm. Next generate the counter-example with Spin.
    Assuming that you easily generated a counter-example (spin -search ex_3c.pml will do it), the next question you'll have is how to inspect it. You'll need the Spin flag -replay for this. The -replay argument tells spin to look for a counter-example trail that is store in a file with the same name as the Promela model, but with file extension .trail. You can try, for instance: 
    	$ spin -replay ex_3c.pml
    which will show you a final value for the global variable cnt of 2, but it doesn't show the steps leading to the assertion violation. To do so you will have to add some more options, telling Spin what to print at each step. For instance:
    	$ spin -p -replay ex_3c.pml
    is far more informative.
    You'll also notice that the trail is longer than it would need to be. To get a shorter trail, you can try running the verification with an iterative shortening option -i. For instance 
    	$ spin -search -i ex_3c.pml		# add runtime parameter -i
	$ spin -p -replay ex_3c.pml
    # -p goes before -replay This is still not the shortest possible trail. To get that, you can recompile Spin to force it to search for the shortest possible counter-example. For instance by using a breadth-first, instead of the default depth-first search, as follows: 
    	$ spin -search -bfs ex_3c.pml		# use breadth-first search
	$ spin -p -replay ex_3c.pml
    You can also get the shortest counter-example with the default depth-first search, but now you have to tell the verifier to remember the length of execution sequences (which uses more memory) and use the iterative shortening method: 
    	$ spin -search -i ex_3c.pml	# modified depth-first with shortening
	$ spin -p -replay ex_3c.pml

    4. Verifying Petri Nets

    It is often easier to build a small Spin model and ask the model checker to verify it than it is to write or to check a thorough manual proof of correctness. Petri Nets are relatively easy to model as Promela verification models. For this exercise, consider the Petri Net model shown below, which first appeared as Figure 1 in Berthelot et al.

    A Spin model for this Petri net can be written as follows. 

      1 #define Place	byte	// assume at most 255 tokens per place
  2                             // file ex_4.pml
  3 Place p1=1, p2, p3          // place p1 has an initial token
  4 Place p4=1, p5, p6          // place p4 has an initial token
  5 
  6 #define inp1(x)	x>0 -> x--
  7 #define inp2(x,y)	x>0 && y>0 -> x--; y--
  8 #define out1(x)	x++
  9 #define out2(x,y)	x++; y++
 10 
 11 init
 12 {
 13   do
 14   :: inp1(p1)    -> out1(p2)	// t1
 15   :: inp2(p2,p4) -> out1(p3)	// t2
 16   :: inp1(p3)    -> out2(p1,p4)	// t3
 17   :: inp1(p4)    -> out1(p5)	// t4
 18   :: inp2(p1,p5) -> out1(p6)	// t5
 19   :: inp1(p6)    -> out2(p4,p1)	// t6
 20   od
 21 }

    The net was proven to be deadlock free in the paper referenced, with a manual reduction and proof technique. Verify the result with Spin. Explain the result in detail.

    5. Veryfying a Process Scheduling Algorithm

    The model below for implementing sleep and wakeup routines in a distributed operating systems kernel is based on Ruane's description. The model contains an error that can be detected as a fair non-progress cycle (use runtime options -l and -f). Check if the proposed fix by Ruane, indicated in the model, suffices to remove the problem. 

      1 mtype = { Wakeme, Running }		// file ex_5.pml
  2 
  3 bit	lk,	sleep_q
  4 bit	r_lock,	r_want
  5 mtype	State =	Running
  6 
  7 active proctype client()
  8 {
  9 sleep:					// sleep routine
 10 	atomic { (lk == 0) -> lk = 1 }	// spinlock(&lk)
 11 	do				// while r->lock
 12 	:: (r_lock == 1) ->		// r->lock == 1
 13 		r_want = 1
 14 		State = Wakeme
 15 		lk = 0			// freelock(&lk)
 16 		(State == Running)	// wait for wakeup
 17 	:: else ->			// r->lock == 0
 18 		break
 19 	od;
 20 progress:
 21 	assert(r_lock == 0)		// should still be true
 22 	r_lock = 1			// consumed resource
 23 	lk = 0				// freelock(&lk)
 24 	goto sleep
 25 }
 26 
 27 active proctype server()		// interrupt routine
 28 {
 29 wakeup:					// wakeup routine
 30 	r_lock = 0			// r->lock = 0
 31 	(lk == 0)			// waitlock(&lk)
 32 	if
 33 	:: r_want ->			// someone is sleeping
 34 		atomic {		// spinlock on sleep queue
 35 			(sleep_q == 0) -> sleep_q = 1
 36 		}
 37 		r_want = 0
 38 #ifdef PROPOSED_FIX
 39 		(lk == 0)		// waitlock(&lk)
 40 #endif
 41 		if
 42 		:: (State == Wakeme) ->
 43 			State = Running
 44 		:: else ->
 45 		fi;
 46 		sleep_q = 0
 47 	:: else ->
 48 	fi
 49 	goto wakeup
 50 }
    To verify this model we need a few more Spin features than we have discussed so far. First, to allow the model checker to find non-progress cycles (infinite executions that fail to include at least one state labeled with a progress tag), we need to pass an different run argument to Spin. Like this: 
    	$ spin -search -l -f ex_5.pml
    Which, if an error is reported, can be followed with the replay command: 
    	$ spin -p -replay ex_5.pml
    The first command directs spin to perform the verification with a search for non-progress loops (-l), while restricting to fair loops (-f).
    Without going into too much detail, the counter-example that we would find if we omit the -f option could be classified as "unrealistic", because it ignores normal process scheduling rules that allow processes that are not blocked to eventually execute. This is reasonable finite progress criterion for non-blocked processes. By default though, the model checker will report all possible counter-examples, and not just the reasonable ones: it takes a demonic approach to finding errors. (Plus, just like in real life, restricting to reasonable behavior is usually somewhat more complex than not doing so...)

    6. Verifying A Go-Back-N Sliding Window Protocol

    This go-back-n sliding window protocol follows the description from Tanenbaum in 1989. The model below includes some annotations, with printf statements, to facilitate the interpretation of simulation trails. 

      1 #define MaxSeq	3	 // file: ex_6.pml
  2 #define inc(x)	x = (x+1)%(MaxSeq+1)
  3 
  4 mtype = { red, white, blue } // for Wolper's test
  5 
  6 bool sent_r, sent_b		 // initialized to false
  7 bool received_r, received_b	 // initialized to false
  8 
  9 chan q[2] = [MaxSeq] of { mtype, byte, byte }
 10 chan source = [0] of { mtype }
 11 
 12 active [2] proctype p5()
 13 {	byte NextFrame, AckExp, FrameExp, r, s, nbuf, i
 14 	byte  frames[MaxSeq+1]
 15 	chan  inp, out
 16 	mtype ball
 17 
 18 	inp = q[_pid]
 19 	out = q[1-_pid]
 20 
 21 	do
 22 	:: nbuf < MaxSeq ->
 23 		nbuf++
 24 		if
 25 		:: _pid%2 -> source?ball
 26 		:: else
 27 		fi
 28 		frames[NextFrame] = ball
 29 		out!ball, NextFrame, (FrameExp + MaxSeq) % (MaxSeq + 1)
 30 		printf("MSC: nbuf: %d\n", nbuf)
 31 		inc(NextFrame)
 32 	:: inp?ball,r,s ->
 33 		if
 34 		:: r == FrameExp ->
 35 			printf("MSC: accept %e %d\n", ball, r)
 36 			if
 37 			:: !(_pid%2) && ball == red -> received_r = true
 38 			:: !(_pid%2) && ball == blue -> received_b = true
 39 			:: else
 40 			fi
 41 			inc(FrameExp)
 42 		:: else ->
 43 			printf("MSC: reject\n")
 44 		fi
 45 	 	do
 46 		:: ((AckExp <= s) && (s <  NextFrame)) ||
 47 		   ((AckExp <= s) && (NextFrame <  AckExp)) ||
 48 		   ((s <  NextFrame) && (NextFrame <  AckExp)) ->
 49 			nbuf--
 50 			printf("MSC: nbuf: %d\n", nbuf)
 51 			inc(AckExp)
 52 		:: else ->
 53 			printf("MSC: %d %d %d\n", AckExp, s, NextFrame)
 54 			break
 55 		od
 56 	:: timeout ->
 57 		NextFrame = AckExp
 58 		printf("MSC: timeout\n")
 59 		i = 1
 60 		do
 61 		:: i <= nbuf ->
 62 			if
 63 			:: _pid%2 -> ball = frames[NextFrame]
 64 			:: else
 65 			fi	
 66 			out!ball, NextFrame, (FrameExp + MaxSeq) % (MaxSeq + 1)
 67 			inc(NextFrame)
 68 			i++
 69 		:: else ->
 70 			break
 71 		od
 72 	od
 73 }
 74 
 75 active proctype Source()
 76 {
 77 	do
 78 	:: source!white
 79 	:: source!red ->
 80 		sent_r = true
 81 		break
 82 	od
 83 	do
 84 	:: source!white
 85 	:: source!blue ->
 86 		sent_b = true
 87 		break
 88 	od
 89 end:	do
 90 	:: source!white
 91 	od
 92 }
 93 
 94 ltl p1 { (<> sent_r -> <> (received_r && !received_b)) }
    Perform a simulation, to see approximately how the protocol executes, for instance as follows, limiting the number of steps to the first 200: 
    	$ spin -u200 ex_6.pml
    Notice that in this case, because of the printf statements in the model, we don't really need to add the -p to the simulator. The two processes named p5 are printing messages to indicate key steps in their execution. To verify the model for safety properties (assertion violations or reachable invalid end-states) we can say: 
    	$ spin -search ex_6.pml
    The verifier will then warn us about a problem: 
    	error: max search depth too small
    The error notice says that the default search depth was not sufficient to perform a full search. To fix that we have to use a larger depth limit than the default (10,000 steps).
    There's also another change we may want to make at this step, e.g., to temporarily ignore the LTL claim in a first check. We can do so by using the compilation directive -noclaim. This leads to the following command line: 
    	$ spin -search -O2 -noclaim -m100000 ex_6.pml
    This gives us a first impression of the complexity of the search, which is still quite manageable, but requires a fair amount of memory.

    Next we want to verify that this protocol correctly transfers data, without loss or reordering. This type of verification can be simplified by making use of Wolper's data independence theorem. To do so, the protocol must be able to transfer at least three colored messages (balls). In our version of the model we made sure that only one process transmits the colored balls, while the other checks that they are accepted in the proper sequence. The return direction transmits only dummy balls of one single type none, which the other side accepts without check.

    The LTL property p1 that we specified at the end of the file can be used to prove that every execution sequence where a red message is sent eventually contains a state where a red message is received, and in that state no blue message could have been received yet. This establishes that the blue message cannot overtake the red message, and the red message cannot be lost.

    The LTL property will be verified by default, unless you disable it with the -noclaim parameter. There's also only one LTL property in this case -- if there was more than one you'd have to choose the one to use in the verification, for instance as: spin -O2 -search -ltl p1 -m100000 ex_6.pml . 
    	$ spin -search -O2 -m100000 ex_6.pml # leave the LTL property enabled
    Notice that the search completes faster than before, requiring a smaller statespace to be explored, because we limited the verification to the specific problem of finding a counter-example to the LTL property. For that, not all possible behaviors are relevant. (I.e., we are exploring the intersection of program behavior and property behavior only.)

    References

    • Bartlett, K.A., Scantlebury, R.A., and Wilkinson, P.T. `A note on reliable full-duplex transmission over half-duplex lines,' Comm. of the ACM, 1969, Vol. 12, No. 5, 260-265, Figure 3c.
    • E.W. Dijkstra, `Solution to a problem in concurrent programming control,' Comm. of the ACM, 1965, Vol 8, No. 9, p. 569.
    • M. Raynal, Algorithms for Mutual Exclusion, MIT Press, Cambridge, Mass., 1986, 107 pgs. (The 1986 edition is a translation from the original French version published in 1984.)
    • L. Lamport, `The mutual exclusion problem -- parts I and II,' Journal of the ACM, Vol. 33, No. 2, April 1986, pp. 313-347.
    • G.L. Peterson, `Myths about the mutual exclusion problem,' Inf. Proc. Letters, 1981, Vol. 12, No. 3, pp. 115-116.
    • G. Berthelot, and R. Terrat, `Petri Net Theory for the correctness of protocols,' IEEE Trans. on Comm., Vol COM-30, No. 12, Dec. 1982, pp. 2497-2505.
    • L.M. Ruane, `Process synchronization in the UTS kernel,' Computing Systems, (Usenix, Summer 1990), Vol. 3, No. 3, pp. 387--421.
    • D. Dolev, M. Klawe, and M. Rodeh, `An O(n log n) unidirectional distributed algorithm for extrema finding in a circle,' Journal of Algorithms, Vol 3. (1982), pp. 245-260.
    • M. Raynal, Distributed algorithms and protocols, John Wiley and Sons, New York, 1992.
    • A. Tanenbaum, Computer Networks, 2nd Ed., Prentice Hall, Englewood Cliffs, NJ., 1989, p. 214, 232-233.
    • P. Wolper, ``Specifying interesting properties of programs in propositional temporal logic,'' Proc. 13th ACM Symposium on Principles of Programming Languages, St. Petersburg Beach, Fla., January 1986, pp. 148-193.

    Spin Online References
    ProMeLa Manual Pages
    ProMeLa Grammar Rules
    Spin HomePage     		(Page Updated: 19 September 2014)
    Spin/Doc/Book2003_Errata.html0000644000175100017510000004447611753004053013654 0ustar ghgh Book Errata - The Spin Model Checker

    Typos found in the first printing (August 2003)

    • p. vi chapter 8 topic listings, Breath-First -> Breadth-First
    • p. 2 line 16 "always explicitly" -> "usually"
    • p. 3 figure 1.1 is mirror reversed
    • p. 4 the website crashdatabas.com no longer seems to exist
    • p. 20 See note (*) below, provided by Heikki Tauriainen (Feb 1, 2006).
    • p. 22 6th line from the bottom: "if" -> "of"
    • p. 25 4th line from the bottom: "variable in" -> "variable cnt"
    • p. 26 10th line from bottom: "set to false" -> "set to true"
    • p. 27 an error slipped into Figure 2.6. The fragment 
      	M?data ->       /* receive data */
	do
	:: W!data       /* send data */
	:: W!shutup;    /* or shutdown */
		break
	od
      is an unfortunate last-minute rewrite of the originally intended version: 
      	do
	:: M?data -> W!data
	:: M?data -> W!shutup;
		break
	od
      The behavior is of course not equivalent. In particular, the version in the book cannot create the error scenario given on page 29, but the intended version can.
    • p. 33 8th line from bottom: "the specification" -> "the specification of"
    • p. 33 3rd line from bottom: "functions pointers" -> "function pointers
    • p. 41 "1 <= n <= 32" -> "1 <= n < 32".
    • p. 43 appel -> apple
    • p. 52 11th line from the top: "p. 39." -> "p. 38."
    • p. 69 bottom line: "exclusive read and exclusive write" -> "exclusive receive and exclusive send"
    • p. 75 and 548 Goldstein -> Goldstine
    • p. 81 and 271 pan.trail -> fair.pml.trail
    • p. 81 3rd line from the bottom: "trace fpr" -> "trace for"
    • p. 82 18th line from the bottom: "process than" -> "process that"
    • p. 92 4th line from bottom: "Even traces" -> "Event traces"
    • p. 96 middle of page identify -> identity
    • p. 96 l. -6, for -> by
    • p. 111 below figure 5.4: "f==free" -> "f=free"
    • p. 119 12th line from the bottom; "xDm" -> "Dm"
    • p. 121 figure 5.8, in captions on bottom two figures: "p" -> "q"
    • p. 137 14th line from bottom (first rule in list): first 3 chars in wrong font
    • p. 139 last line; italic P -> roman P
    • p. 142 3rd line from bottom: "reach" -> "reached"
    • p. 142 5th line from bottom: omit comma
    • p. 148 middle of the page: "can be express" -> "can be expressed"
    • p. 149 5th line from bottom: "eventually always" -> "always eventually"
    • p. 150 replace "it is impossible for p to hold only in even steps in a run, but never at odd steps" with "it is possible for p to hold in even steps in a run, but it is not possible for p to hold in odd steps"
    • p. 150 Omega-Regular Properties, line 1: "that" -> "than"
    • p. 158 middle of page: redundant space after "("
    • p. 168 the list of properties given for < and > is not exhaustive
    • p. 174 11th line from bottom: "but" -> "by"
    • p. 177 Procedure Search() in Figure 8.6 is incorrect. A corrected version is: 
      Search()
{
	while (Empty_Queue(D) == false)
	{	s = Del_Queue(D)
		for each (s,1,s') member A.T
		if In_Statespace(V, s') == false
		{	Add_Statespace(V, s')
			Add_Queue(D, s')
		}
	}
}
    • p. 178 2nd line from top: "at state" -> "at each state", "of each state" -> "of that state"
    • p. 179 lead -> led
    • p. 180 before first 'if' stmnt inside for loop add: if (toggle == true)
    • p. 185 Fig. 8.10, circle at s^{1}_{2} should be dotted
    • p. 187 line -11: "interative" -> "iterative"
    • p. 188 replace "(RxB)+(k+2)" with "Rx(B+k+2)"
    • p. 193 Fig. 9.2, the two circles labeled 0,1,0 should be dashed
    • p. 193 7th line from bottom: "g=g*2," -> "g=g*2."
    • p. 196 line -9: "control control" -> "control"
    • p. 204 last line, "to 133 seconds" -> "to 53 seconds"
    • p. 208 a goof: m changes from bits to bytes between 2nd and 3rd paragraph
    • p. 209 in first two formulas: (1-1/m) sup {kr}.
    • p. 211 3rd line from below: probabilitie -> probabilities
    • p. 212 line -2: "ration" -> "ratio"
    • p. 214 A formal -> Formal
    • p. 216 1st-2nd line: 'collissions' -> 'collisions'
    • p. 219 last paragraph: missing right parenthesis
    • p. 228 Celcius -> Celsius
    • p. 228 in the list at the bottom: there are just 6 entries with 'keep' as a target
    • p. 237 12th line from below: "postive" -> "zero".
    • p. 237 4th line from below: "unsound" -> "incomplete".
    • p. 238 knifes -> knives
    • p. 241 7th line from bottom: "world0" -> "world\n"
    • p. 243 Pressburger -> Presburger
    • p. 251 Selet -> Select
    • p. 262 10th line from bottom: "do to" -> "due to"
    • p. 272 an basic -> a basic
    • p. 272 "As a special feature [...], if the statement" omit "if"
    • p. 279 "#define q" -> "#define r"
    • p. 281 Automata View -> Automaton View
    • p. 283 The correct wording of the quote from Willem L. van der Poel, as corrected by its author: 
      "There are no wrong programs, it simply is another program."
      (email from the author, Feb 1, 2006).
    • p. 284 8th line from bottom: omit "blue"
    • p. 287 6th line from top: omit "blue"
    • p. 307 top of page: "ringtone" -> "ring tone"
    • p. 307 top of page: "dialtone" -> "dial tone"
    • p. 307 top of page: "notone" -> "no tone"
    • p. 333 11th line from top: "and early version" -> "an early version"
    • p. 338 the line numbered [19] is actually from the FIX
    • p. 339 6th line from below: pid 1 -> pid 0
    • p. 393 2nd line from top: "innermostn" -> "innermost"
    • p. 341 10th line from top: "body ," -> "body,"
    • p. 346 identificatio -> identification
    • p. 346 middle of the page: "tranaction" -> "transaction"
    • p. 349 55 is not the integer square root of either 1024 or 3601.
    • p. 356 n=1<<30 does not fail on all systems
    • p. 359 Fig. 15.8: what looks like commas are really single quotes
    • p. 359 Fig. 15.8: the automaton fails to detect strings that start inside a comment;
      • unfortunate given the example that also appears on this page...
    • p. 365 the grammar listing misses productions for inlines
    • p. 365 [active] PROCTYPE -> [active ['[' const ']']] PROCTYPE
    • p. 367 "PRINT" -> "PRINTF"
    • p. 369 in PREDEFINED: "373last" -> "374"
    • p. 369 in PREDEFINED: "373nr_pr" -> "376"
    • p. 369 5th line from bottom: "special case" -> "special cases"
    • p. 370 8th line from bottom: "p.272" -> "p. 272"
    • p. 370 2nd line from bottom: "(434)" -> "(p. 434)"
    • p. 370 2nd line from bottom: "(p, 483)" -> "(p. 483)"
    • p. 371 2nd line from top: "Two" -> "Three"
    • p. 371 9th line from top: "or both of the above two" -> "of the above"
    • p. 374 11th line from bottom: "from into" -> "to"
    • p. 376 5th line from bottom: "at 256" -> "at 255"
    • p. 377 5th line in DESCRIPTION: "process" -> "processes"
    • p. 381 4th line from bottom: "four process" -> "four processes"
    • p. 381 3rd line from bottom: "to three" -> "to four"
    • p. 390 9th line from bottom: "recepient" -> "recipient"
    • p. 393 10th line from bottom: "label L1" -> "label L2"
    • p. 395 6th line from top: "multiple field" -> "multiple fields"
    • p. 397 4th line from top: "the the" -> "the"
    • p. 398 11th line from bottom: redundant space after "("
    • p. 402 7th line from top, "accidentily" -> "accidentally"
    • p. 404 mixed fonts in Table
    • p. 404 5th line from bottom: "the fact the" -> "the fact that the"
    • p. 407 in Notes, 2nd line: "tha" -> "that"
    • p. 408 "(x < 0)" -> "(x <= 0)"
    • p. 411 last line: "ltl len" -> "ltl, len"
    • p. 425 11th line from top: "followin" -> "following"
    • p. 440 11th line from top: "equivalents" -> "equivalent"
    • p. 441 middle of page: "LTL formula" -> "LTL formulae"
    • p. 446 10th line from top: "equivalents" -> "equivalent"
    • p. 450 last example in notes should be: atomic { P && qname?[ack,var] -> qname?ack,var }
    • p. 452 15th line from bottom: "will included" -> "will be included"
    • p. 455 5th line from top: "restrction" -> "restriction"
    • p. 456 middle of page: "type main" -> "type fact"
    • p. 456 12th line from bottom: "2,147,483,648" ->"2,147,483,647"
    • p. 456 10th line from bottom: 13! = 6,227,020,800 (and so even 13! > 2^31-1)
    • p. 464 9th line from bottom: "just and safe" -> "justified and safe" (2x)
    • p. 466 1st line in EFFECT: "to the" -> "of the"
    • p. 476 in EXAMPLES (2x): "b = a" -> "b = tmp"
    • p. 479 7th line from top: "can are" -> "are"
    • p. 496 6th line: "in in" -> "in"
    • p. 498 2nd line from bottom: "coord.trail" -> "example.trail"
    • p. 509 13th line from bottom: "known the" -> "known. The"
    • p. 512 middle of page: "an pointer" -> "a pointer"
    • p. 518 l -8, most -> must
    • p. 519 l -10, -rthis -> -r, this
    • p. 521 5th line from bottom: "substitions" -> "substitutions"
    • p. 528 under basic options -DBFS, "reducting" -> "reducing"
    • p. 532 under -DSDUMP, replace "-DCHECK" with: "-DVERBOSE or -DDEBUG"
    • p. 532 under -DSVDUMP, replace "a file named svdump" with "a file with extension .svd"
    • p. 541 11th line from bottom: "-a" in wrong font
    • p. 543 middle of page: "two for processes" -> "three for processes"
    • p. 547 Americans would put "Dijkstra" above "Dillon" in alphabetical order. Dutchmen, though, recognize the "ij" as a single letter, and place "Dijkstra" below "Doran" as shown. Dijkstra was, of course, a Dutchman...
    • p. 547 Entry for Emerson: "model logic" -> "modal logic"
    • p. 553 13th line from bottom: "to represents" -> "to represent"
    • p. 554 10th line from top: "product" -> "products"
    • p. 561 DEADLOCK DETECTION, 1st line: "is system" -> "is a system"
    • p. 561 10th line from bottom: replace "invalid endstate" with "valid endstate", and replace the subsentence after the comma with: "from which we can derive the definition of an invalid endstate, matching Spin's formalization of a system deadlock. In an invalid endstate at least one process has not reached its closing curly brace or a state marked with an endstate label."
    • p. 565 4th line from top: "andq, r" -> "q and r"
    • p. 566 define BDD (Binary Decision Diagram) and NP (Non-deterministic Polynomial)
    • p. 572 l 8, wil -> will
    • p. 575 10th line from bottom should be: spin -a -m ex2
    • p. 575 9th line from bottom should be: cc -DPC -DBITSTATE -DSAFETY -o pan pan.c
    • p. 577 C.9., 1st line: "an little" -> "a little"
    • p. 579 5th line from top: "these tool" -> "these tools"
    Statistics: The list above contains roughly 128 reported typos and goofs in the first printing of the book. There are approximately 340K words in the book, giving 1 reported defect per 2,650 words written. At and average of 10 words per sentence, this is about 4 reported defects per 1,000 sentences in the book, which is roughly on par with a reasonably good software development process of 1-10 residual defects (after testing) per 1,000 lines of non-comment source code written. As in software, the number of reported defects depends both on the number of latent defects and on the number of users/readers (i.e., unread books will have no reported typos...).
    Note (*) on the example used on p. 20, provided by Heikki Tauriainen. 
    Date: Wed, 01 Feb 2006 21:10:54 +0200 (EET) 
From: heikki.tauriainen [atsign] tkk [dot] fi 
Subject: Spin book: Doran & Thomas's mutual exclusion algorithm 

Dear Dr. Holzmann,

Keijo Heljanko and I are giving at Helsinki University of Technology
a basic course on parallel and distributed systems, using Spin for
examples on model checking.  To demonstrate using the tool, we
considered Dekker's mutual exclusion algorithm found in your Spin
book (p. 20) and the variant of the algorithm by Doran and Thomas
mentioned on p. 22.

According to the Spin book, Doran and Thomas's algorithm can be
obtained from Dekker's algorithm by simply changing the outer do-loop
of the algorithm into an if-selection, and this change is claimed to
preserve the correctness of the algorithm.  This doesn't, however,
seem to be the case, as the verification results using the Promela
models distributed in the package
 were
somewhat unexpected (unless, of course, the models in the package are
deliberately faulty).  I'm referring to the file CH2/mutex.pml in the
package.

The Promela model uses a preprocessor directive (DORAN) to choose
between the algorithm with the do-loop and the algorithm with the
if-selection. Verifying the model with the do-loop indeed gives the
expected result (no assertion violations).  Firstly, however, Spin
doesn't directly accept the model of the variant of the algorithm:

$ spin -DDORAN -a mutex.pml
spin: line  30 "mutex.pml", Error: misplaced break statement    saw '-2'' near 'break'
$

After the obvious change of making the 'break' keyword at line 30
apply only to the variant with the do-loop, that is, changing lines
29--35 to read

        :: else ->
#ifdef DORAN
        fi;
#else
                break
        od;
#endif

and then verifying the mutual exclusion algorithm gives, however,
the following (unexpected) result:

$ spin -DDORAN -a mutex.pml
$ gcc -o -DBFS -o pan pan.c
$ ./pan
pan: assertion violated (cnt==1) (at depth 9)
pan: wrote mutex.pml.trail
(Spin Version 4.2.6 -- 27 October 2005)
Warning: Search not completed
        + Using Breadth-First Search
        + Partial Order Reduction

Full statespace search for:
        never claim             - (none specified)
        assertion violations    +
        cycle checks            - (disabled by -DSAFETY)
        invalid end states      +

State-vector 20 byte, depth reached 9, errors: 1
      56 states, stored
              56 nominal states (stored-atomic)
      32 states, matched
      88 transitions (= stored+matched)
       0 atomic steps
hash conflicts: 0 (resolved)

2.302   memory usage (Mbyte)

$ spin -DDORAN -p -t mutex.pml
Starting mutex with pid 0
Starting mutex with pid 1
  1:    proc  1 (mutex) line  11 "mutex.pml" (state 1)  [i = _pid]
  1:    proc  1 (mutex) line  12 "mutex.pml" (state 2)  [j = (1-_pid)]
  2:    proc  0 (mutex) line  11 "mutex.pml" (state 1)  [i = _pid]
  2:    proc  0 (mutex) line  12 "mutex.pml" (state 2)  [j = (1-_pid)]
  3:    proc  1 (mutex) line  14 "mutex.pml" (state 3)  [flag[i] = 1]
  4:    proc  1 (mutex) line  29 "mutex.pml" (state 12) [else]
  5:    proc  1 (mutex) line  37 "mutex.pml" (state 15) [cnt = (cnt+1)]
  6:    proc  0 (mutex) line  14 "mutex.pml" (state 3)  [flag[i] = 1]
  7:    proc  0 (mutex) line  21 "mutex.pml" (state 4)  [(flag[j])]
  8:    proc  0 (mutex) line  27 "mutex.pml" (state 9)  [else]
  9:    proc  0 (mutex) line  37 "mutex.pml" (state 15) [cnt = (cnt+1)]
spin: trail ends after 9 steps
#processes: 2
                turn = 0
                flag[0] = 1
                flag[1] = 1
                cnt = 2
  9:    proc  1 (mutex) line  38 "mutex.pml" (state 16)
  9:    proc  0 (mutex) line  38 "mutex.pml" (state 16)
2 processes created
$

Trying to find a reason for this unexpected result, I compared the
model with the algorithm in Doran and Thomas's original article [1].
It appears that the model in fact differs from that algorithm
(repeated below from [1], Fig. 1)

Process A                           Process B
  1. A_needs := true;                    B_needs :=  true;
  2. if B_needs then begin               if A_needs then begin
  3.   if turn = 'B' then begin            if turn = 'A' then begin
  4.     A_needs := false;                   B_needs := false;
  5.     wait until turn = 'A';              wait until turn = 'B';
  6.     A_needs := true;                    B_needs := true;
  7.     end;                                end;
  8.   wait until !B_needs;                wait until !A_needs;
  9.   end;                                end;
 10. CRITICAL SECTION                    CRITICAL SECTION
 11. turn := 'B';                        turn := 'A';
 12. A_needs := false;                   B_needs := false;
 13. NON-CRITICAL SECTION                NON-CRITICAL SECTION

In particular, the Promela model has no corresponding construct for
line 8 of this algorithm, which appears to be critical to its
correctness: changing the outer if-selection to read

        if
        :: flag[j] ->
                if
                :: turn == j ->
                        flag[i] = false;
                        !(turn == j);
                        flag[i] = true
                :: else
                fi;
                (!flag[j]);    /* needed for correctness */
        :: else ->
        fi;

fixes the error.  However, it is not sufficient to simply
replace the do-loop with an if-selection, although the wording
on page 22 of the Spin book can be interpreteted to suggest
otherwise (at least both I and Keijo were surprised, that's why
we decided to write this report).

(The example file suggests that the model is taken from the book
[2] instead of directly from Doran and Thomas's original article [1].
As a matter of fact, this book---at least its English translation---contains the same error.  This is probably also the
reason why the model is faulty.)

Best regards,
Heikki Tauriainen


References:

[1] R. W. Doran and L. K. Thomas.  Variants of the software solution to
    mutual exclusion.  Information Processing Letters 10(4--5):206--208,
    1980.

[2] M. Raynal.  Algorithms for mutual exclusion.  North Oxford Academic
    Publishers Ltd., 1986.
    book home page
    Spin home page
    Last updated: 1 February 2006 Spin/Doc/4_SpinVerification.html0000644000175100017510000003724412641606227014661 0ustar ghgh SPIN Verifier's Roadmap: Spin

    SPIN VERIFIER's ROADMAP:
    BUILDING AND VERIFYING Spin MODELS

    The following description provides a basic overview of the verification options that can be used with the Spin model checker. This description assumes that Spin has been installed and that you have a standard C compiler (such as gcc) as well. It also assumes that you are familiar with standard shell command use on a Unix-like system (e.g., Ubuntu Linux, MAC-OS-X, or Cygwin on a Windows-PC).

    -0-

    Verification begins with the specification of a prototype of the system to be studied in the specification language supported by Spin. This language is called ProMeLa (short for Process Meta Language), and the model is called a verification model, or a Spin model.
    By convention, ProMeLa specification files have a .pml file extension.

    Next you must consider how you can express the critical correctness requirements for your model. You can use assertions, end-state labels, progress-state labels, acceptance-state labels, or LTL properties. But don't worry, in most cases of practical interest you will only need assertions, and less frequently simple LTL properties.

    -1-

    For a quick checkout of the model you have just defined: do a simulation run to catch the simpler mistakes.
    If no flags are provided, Spin performs a random simulation of the model. 
    	$ spin spec.pml		# no options: only print statements produce output
    It is often very helpful, especially at this stage in debugging the basic verification model, to add printf statements to the specification to make things more clear.

    You can add more options to see useful things happening. Without additional flags, only print statements that you use in the model will produce output. If there are none, you may want to use some additional flags. 

    	$ spin -p spec.pml	# simulation run, show all execution steps
	$ spin -c spec.pml	# columnated output for message i/o
    You can use the command: 
    	$ spin --
    to see what other options are available for including additional information in the simulation runs.
    An important one, in case your model can execute forever, is the ability to set an upper-limit on the number of execution steps performed in a simulation. For instance, to limit the simulation to the first 200 steps: 
    	$ spin -u200 -p -l -g -v spec.pml
    Check in the output of spin -- what the additional flags that are used here do.

    When done debugging, you can perform a more thorough check of your model with this command: 

    	$ spin -a spec.pml		# thorough check
    This step can report syntax errors and impurities that the simulation commands don't catch. For feedback on possible redundancies in your specification, try also: 
    	$ spin -A spec.pml		# check for redundancies
    And, if you really want to get carried away, you can look at the automata descriptions that Spin generates for you for the verifier's use, by executing: 
    	$ spin -search -dump spec.pml
or just
	$ spin -search -d spec.pml
    If, on the other hand you just want to get a quick basic verification run going, use this command, which will compile and run your verification immediately: 
    	$ spin -search spec.pml
    And the rest, as they say, is just detail. We will indulge in some of that detail in the next few points.

    -2-

    The biggest decision to make is if the model you created is simple enough to perform a fully exhaustive verification on the machine that you are using. The limits, as always, are CPU-time and RAM memory. The good news is that even if you do not have enough time or memory, Spin can be configured to give you the best possible result within the constraints that you do have. We will first consider how you can setup a standard exhaustive verification run.
    Exhaustive
    For an exhaustive verification, you can compile the generated verification code as follows. 
    	$ spin -search -O2 spec.pml            # use optimized compilation
    It is always smart to use the -O2 flag to optimize the code: it can often reduce the runtime needed by about 50%.

    If you know how much physical (not virtual) RAM memory your system has, you can use this to restrict the maximum amount that a verification can take to avoid unpleasant paging behavior, for instance, if you have 256 Megabyte available compile as follows. 

    	$ spin -search -O2 -DMEMLIM=256 spec.pml   # set memory bound at 256MB
    If the amount of memory you have is not sufficient to complete a verification, consider using one of the compression options that Spin supports. For instance: 
    	$ spin -search -O2 -DMEMLIM=256 -collapse spec.pml # use compression
    or, for a still more aggressive option, try: 
    	$ spin -search -O2 -DMEMLIM=256 -hc spec.pml # use hash-compact compression
    If also this is insufficient, and your verification still exceeds the memory bounds, switch to Bitstate verification run (also known as a Supertrace verification).

    Bitstate
    For a Bitstate verification run, compile as follows. 

    	$ spin -search -O2 -bitstate spec.pml    # use bitstate search
    This is often used as a method of last resort when a full verication is infeasible because of memory limitations or problem size. It can also be used as a fast prescan of a problem, to get an early and quick indication of the presence or absence of errors.

    -3-

    Up to this point we have ignored what type of property you are trying to verify, or what impact problem size may have on your chances of performing a successful verification. We will address these points now.

    There are four more decisions you have to make to perform verifications optimally. These four decisions are:

    1. Selecting the type of property to be verified (safety or liveness)
    2. Selecting the maximum search depth,
    3. If you use a Bitstate search: selecting the size of the hash-table
    4. Selecting the parameters for a replay of an error, if one is found.
    We'll now explore each of these decisions in more detail.

    1. The first decision is to decide if you want to check the model for Safety properties or for Liveness properties.
      Safety
      Examples of safety properties are assertion violations, deadlocks (invalid end-states), etc.

      To check safety properties only (the most frequently used search mode), you can obtain a fast verifier by adding a -safety argument: 

      		$ spin -search -safety spec.pml
      plus of course any of the other arguments we discussed earlier, for instance: 
      		$ spin -search -O2 -bitstate -safety spec.pml
      In this case you can also use Spin's breadth-first search mode, which works only for safety properties but has the advantage of finding the shortest possible error traces: 
      		$ spin -search -bfs spec.pml
      again combined with any other options you need.

      Liveness
      Examples of liveness properties are non-progress or acceptance cycles. LTL properties can express both safety and liveness properties. In case of doubt: assume you have a liveness property.

      To perform a search for violations of general liveness properties you use the runtime parameter -a following the -search argument to Spin. For instance: 

      		$ spin -search -a spec.pml
      plus any other runtime arguments you selected.

      Non-Progress
      A non-progress cycle is an infinite execution that never passes through any state in the specification that is marked with a labelname that starts with the prefix "progress".

      To search for non-progress cycles you add run-time option -l, for instance as in: 

      		$ spin -search -l spec.pml
      plus any other runtime arguments you selected.

    2. By default the Spin verifiers enforce a search depth restrictionof 10,000 steps. In most cases this will suffice, but when it doesn't the search depth will artificially be truncated to 9,999 steps and become incomplete. You can define a different search-depth by adding a runtime parameter -m. For instance: 
      	$ spin -search -m100000 spec.pml
      (again, combined with any other options you select).

      You can also try to set a lower search depth to try to find a shorter variant of an error sequence. For instance 

      	$ spin -search -m40 spec.pml
      But in thise case there is no guarantee that if a shorter error sequence exists it will also be found. To get that guarantee you also have to instruct Spin to modify the search algorithm itself, with a runtime parameter -i to force a search for a short error. For instance, to search for errors shorter than 100 steps: 
      	$ spin -search O2 -i -m100 spec.pml	# iterative search for short errors
    3. If you perform a Bitstate verification (i.e., you used the search argument -bitstate), the size of the memory arena that is used to store states very compactly is determined by your choice of a -w parameter. By default, this parameter is set to -w27, which defines a memory arena of 227 bits, corresponding to a modest 16 MB of RAM.
      For maximum coverage you want to set the hash-array size to the maximum size of memory you can grab without making the system page (i.e., below the amount of real physical RAM memory that you can access).

      More specifically, for maximum coverage, the value you set with the -w parameter should at least be larger than the nearest power of 2 of the number of reachable system states that you expect, without exceeding your physical memory size. (And for obvious reasons, you cannot allocate more than about 2 GB of memory on a 32-bit system. For larger memory arenas you will have to use a 64-bit system.)

      For instance, use -w23 if you expect less than 8 million reachable states and can use 8 million bits of memory (i.e., 223 bits equals 8 million bits, which equals 220 bytes or 1 MB of RAM).

      A -w value lower than required for full coverage will give you a faster run, but less coverage. A value higher than needed, will give you a slower run, but it will also cover a larger fraction of the statespace.

    4. If the verifier finds an error, any error, it will write an error-trail into a file named spec.pml.trail, if spec.pml is the name of your Spin model. To inspect the trail, and examine the cause of the error, you can use Spin's guided simulation option -replay.
      For instance: 
      	$ spin -p -replay spec.pml
or
	$ spin -c -replay spec.pml
      Note that options to spin like -p and -c go before the -replay argument.
      If, however, a replay must be done with the executable verifier ./pan, which automatically happens for all models that contain embedded C code fragments in c_expr or c_code statements, then replay options to the executable verifier are placed after the -replay argument, for instance as in: spin -replay -P2 spec.pml. The executable verifier accepts different options for replay then spin itself, so it is good to keep these separate.
      Options placed after the -replay argument for a pure Promela model, and options placed before the -replay argument for a model with embedded C code, are politely ignored.

      Add as many extra or different options as you need to pin down the error. (Remember, you can check Spin's available options by executing: spin --, and options of the executable verifier with ./pan --.) One option is to convert the trail into a Tcl/Tk represetation of a message sequence chart of send and receive actions, which will then be displayed with the wish command (assuming wish is installed on your system): 
      	$ spin -M -replay spec.pml
      For more detailed tracebacks you can use, for instance: 
      	$ spin -r -s -l -g -replay spec.pml
      Make sure the file spec.pml didn't change since you generated the verifier. Spin will warn if you did.

      If you're not interested in the first error that is reported, add runtime option -c to select others: 

      	$ spin -search ... -c3 spec.html
      generates a counter-example trail for the third error found in the search. If you just want to count all errors and not see them, use 
      	$ spin -search ... -c0 spec.html
      By default, the argument to -c is 1.

      If you want to obtain a trail for each and every error found (usually not recommended, because there may be an overwhelming number of these), use: 

      	$ spin -search ... -c0 -e spec.html
      This creates a series of error trails in files numbers spec2.pml.trail, spec3.pml.trail, ...etc. To trace back a specific one of these trails, you can specify the specific trail file you want to see with a -k option: 
      	$ spin -k trailfilename -p -replay spec.pml

    Finally

    Internally Spin and pan deal with a formalization of the model in terms of automata. Spin assigns numbers to all statements in the input. These state numbers are listed in all output so that you can, if you want, use that information to track down what happens. To see the state assignments use the runtime option -d for the executable verifier pan: 
    	$ spin -o3 -search -d spec.pml	# show optimized state machines
    to print the optimized state machine assignments, as it is used during verification. (The -o3 argument turns off a default statement merging option that can sometimes make it harder to interpret the output.)
    The unoptimized machine (used during random or guided simulations with spin -replay for instance) can also be printed, but you need the executable verifier for that. (It will exist if you've executed the above command first): 
    	$ spin -o3 -search -d -d spec.pml	# show full, unoptimized state machines
    These two options should also make it easier to understand and verify the working of Spin and pan in terms of the underlying automata theoretic foundation.

    In very rare cases, when you need to debug the working of the verifier itself, you can also consider compiling the verifier with an additional compiler directive -DCHECK or -DVERBOSE.

    Spin HomePage (Page Updated: 8 June 2014)
    Spin/Doc/Book1991_answers.txt0000644000175100017510000004323311753004053014000 0ustar ghgh Answers to selected exercises from 'Design and Validation of Computer Protocols' ============================================= 1.1 Assuming that torches in the two groups would be raised and lowered simultaneously, the code for the first character in the first group could have clashed with the pre-defined start of text code. If torches are not raised simultaneously it is conceivable that group numbers could be paired with the wrong character numbers. A well-trained transmitter might also overestimate the receiver's ability to translate the codes on the fly. as is still true today: receiving is a more time consuming task than transmitting. 1.2 Assuming that a torch code is displayed for a minimum of 30 seconds, the torch telegraph transmits a choice of 1 out of 25 (between 4 and 5 bits of information), giving a speed of roughly 0.15 bits/sec. Chappe's telegraph transmitted a choice of 1 out of 128 every 15 to 20 seconds, giving a transmission speed of roughly 0.5 bits/sec. On Polybius' telegraph the 15 characters of the message ``protocol failure'' would take 15x30 seconds or 7.5 minutes to transmit... (Note that a code for the space was not available.) On Chappe's system the 16 characters (space included) would be transmitted in 4 minutes, assuming that no predefined code was assigned to either the word `protocol' or the word `failure.' (As far as we know, there wasn't.) 1.3 Removing the redundancy in messages increases the chance that a single transmission error would make a large part of a message inrecognizable. It could cause a lot of extra traffic from receiver back to sender, asking for retransmissions, and additional transmissions of messages. The same tradeoff is still valid on today's communication channels (see Chapter 3). 1.4 The signalman at A had to make sure that not one but two trains would leave the tunnel, before he admitted the third. The two trains could reach signalman B in approximately 2 minutes. At 25 symbols per minute, that would allow the two signalmen to exchange roughly 50 characters of text. A could have signaled: "two trains now in tunnel - how many left?" for a total of 42 characters. Assuming that B would have answered eventually "one train left," that would still leave A puzzling if B had really understood his message, and if so, where the second train could possibly be. Considering also that signalman A had been on duty for almost 18 hours when the accident occured, it is not entirely certain that he could have succesfully resolved the protocol problem. Note that he still would have had to `invent' part of the protocol for resolving the problem in real-time. 1.5 Replace the message `train in tunnel' with `increment the number of trains in the tunnel by one.' Similarly, replace the message `tunnel is clear' by `decrement the number of trains in the tunnel by one.' The message `is tunnel clear' becomes `how many trains are in the tunnel?' with the possible responses spelled out with numerals 0 to 9. Either signalman can increment or decrement the number. The rule of the tunnel is invariantly that the number of trains in the tunnel is either zero or one, and only one signalman may transmit at a time. (To resolve conflicts on access to the transmission line, one could simply give one of the signalmen a fixed priority.) 1.6 A livelock would result. Assuming that the semaphore operators would quickly enough recognize the livelock, it is still an open question what they would (should) do to recover properly from such an occurence. 1.7 One possible scenario, observed by Jon Bentley in real life, is that two connections are made, and both parties are charged for the call. Clearly, a dream come true for the telephone companies. 2.1 Service - the simplex transfer of arbitrary messages from a designated sender to a designated receiver. Assumptions about the environment - sufficient visibility and small enough distance to make and accurate detection (and counting) of torches possible for both sender and receiver. There seems to be an implicit assumption of an error-free channel. There is also the implicit assumption that the receiver will always be able to keep up with the sender and will not get out of sync with the symbols that have to be decoded. Vocabulary - 24 characters from the Greek alphabet, plus two control messages (the start of text message and its acknowledgement). Encoding - each character, and each control message, is encoded into two numbers, both between 1 and 5. Since there are 26 distinct messages and only 5x5=25 distinct codes, some ambiguity is unavoidable. Procedure rules - minimal. Apparently there was only a single handshake at the start of the transmission. All other interactions (end of transmission, error recovery, flow control) were undefined and would have had to be improvised in the field. There is also no resolution of a potential conflict at the start of transmission (assuming that both parties could decide to start sending at the same time). 2.2 The procedure rules can include a poll message once per complete page - interrogating the printer about it's status (confirming that it is online and confirming that it is not out of paper - both conditions that can change from one page to the next). Note that the procedure rules must also guarantee that no more than one user can use the printer at a time. 2.3 Service - establishing a voice connection between two subscribers of a phone system. (Let's conveniently ignore multi-party connections, or faxes and modems.) Assumptions about environment - the phone system is infinitely available and error-free (sic). Vocabulary - off-hook, on-hook, dial 0 ... dial 9 (ignore star and sharp). Dial-tone, busy-tone, ring-tone. All messages listed here are control messages - the `data' of the protocol is encoded in the voice message. (For completeness then we could list `voice' as a separate message in the vocabulary, without attempting to formalize it's `encoding.') Encoding - lifting the receiver, lowering the receiver, pushing one of 10 labeled buttons. Informal procedure rules - Go off-hook, if no dial-tone is returned go on-hook and repeat a random amount of time later. If there is a dial-tone, push the sequence of buttons that identify the required destination to the phone system. If a busy-tone is returned in this interval, go on-hook, wait a random amount of time, and repeat from the start. If a ring-tone is returned - the call has been established - wait a random amount of time, go on-hook. Note that the random wait period after a busy signal makes it less likely that a `Lovers' Paradox' can be created (cf. Exercise 1.7). To be complete, the phone systems behavior should also be listed. Be warned that the latter is not a trivial exercise.... 2.4 The revised version is the famous alternating bit protocol, see Chapter 4. 2.5 The receiver can then determine where a message (should) end by counting the number of bytes it receives, following the header. It does not have to scan for a pre-defined message terminator. 2.6 For isntance, a character stuffed protocol always transmits an integral number of bytes. A bit stuffed protocol carries slightly less overhead. 2.7 See Bertsekas and Gallager, [1987, p. 78-79]. 2.8 More detailed sample assignments for software projects such as this one are available from the author (email to gerard@research.att.com). 3.1 The code rate is 0.2. Protection against bursts is limited to errors affecting maximally 2 out of the 5 bytes. At 56 Kbits/sec that means bursts smaller than 0.28 msec. 3.3 Does the crc need to be protected by a crc? 3.4 In many cases English sentences are redundant enough that forward error correction is possible. Any real conversation, though, contains many examples of feedback error correction to resolve ambiguities. To stick with the example - if the sentence ``the dog run'' is received, the original version (i.e., one or more dogs) cannot be determined without feedback error control. 3.5 (a) - the checksum is 6 bits wide. (b) - the original data is equal to the first n-6 bits of the code word (6 bits in this case). (c) - there were no transmission errors other than possible multiples of the generator polynomial itself. 3.6 The standard example is that of the voyager space craft near the planet Jupiter receiving a course adjustment from earth. A retransmission of the message would mean hours delay and invalidate the original commands. If the return channel has a high probability of error (e.g., a low power transmitter on board the spacecraft, sending out a very weak signal back to earth), the chances that a retransmission request would reach the earth intact may also be unacceptably low. 3.8 It is impossible to reduce a non-zero error rate to zero. The probability of error can be brought arbitrarily close to zero, at the expense of transmission speed, but it cannot reach zero. The scheme suggested would violate this principle and therefore should be placed in the same category as perpetuum mobiles and time-travel. 3.9 Fletcher's algorithm can be classified as a systematic block code. 4.2 The alternating bit protocol does not protect against duplication errors or reordering errors. Duplication errors persist (duplicate messages do not dissapear but generate duplicate acks etc, for the duration of the session.) Reordering can cause erroneous data to be accepted. 4.5 Too short a timeout creates duplicate messages. The duplicates lower the throughput for the remainder of the session. Too long a timeout increases idle-time and lowers the throughput. 4.6 Ignore duplicate acks. 4.8 See Bertsekas and Gallager [1987, pp. 28-29]. 4.9 In at least one case (when the receiver is one full window of messages behind the sender) there is a confusion case where the receiver cannot tell if an incoming message is a repeat from W messages back, or a new message. 4.10 Store the data in buffer[n%W] where W is window size. 4.11 Use time-stamps and restrict the maximum life time of a message. Note however that time-stamps are just another flavor of sequence numbers and they would have to be selected from a sufficiently large window. For 32 bit sequence numbers one message transmission per micro-second would recycle the number in 71 minutes. For 64 bit sequence numbers, the number recycles at the same transmission speed in 500,000 years. 4.12 Alpha controls the rate of adaption to changes in network performance. Beta controls the allowed variance in response time. (It estimates the load variance of the remote host.) 4.13 Most importantly, all assumptions about the environment, specifically of the tranmission channel used, are missing completely. 4.14 The message could be received again and cause a duplicate acceptance. 5.1 An assignment is always executable. The variable b would be set to the value 0. 5.2 If the receive is executable on the first attempt to execute the statement, the message would be received, and the condition would be false (since the `executability' value of the receive is non-zero). The statement would block, and would be repeated. If the receive is (finally) non-executable, the receive fails, but the condition becomes true and executable. For all clarity: this is not valid Promela syntax. In Promela the rule is that the evaluation of a condition must always be completely side-effect free. 5.3 /***** Factorial - without channels *****/ int par[16]; int done[16]; int depth; proctype fact() { int r, n, m; m = depth; n = par[m]; if :: (n <= 1) -> r = 1 :: (n >= 2) -> depth = m + 1; par[m+1] = n-1; run fact(); done[m+1]; r = par[m+1]; depth = m; r = r*n fi; par[m] = r; printf("Value: %d\n", par[m]); done[m] = 1 } init { depth = 0; par[0] = 12; run fact(); done[0]; printf("value: %d\n", par[0]) /* factorial of 12: 12*11*10....*2*1 = 479001600 */ } /***** Ackermann's function *****/ short ans[100]; short done[100]; /* synchronization */ proctype ack(short a, b, c) { if :: (a == 0) -> ans[c] = b+1 :: (a != 0) -> done[c+1] = 0; if :: (b == 0) -> run ack(a-1, 1, c+1) :: (b != 0) -> run ack(a, b-1, c+1); done[c+1]; /* wait */ done[c+1] = 0; run ack(a-1, ans[c+1], c+1) fi; done[c+1]; /* wait */ ans[c] = ans[c+1] fi; done[c] = 1 } init { run ack(3, 3, 0); done[0]; /* wait */ printf("ack(3,3) = %d\n", ans[0]) } 5.10 Here, as an inspiration, is another sort program, performing a tree-sort. /**** Tree sorter ****/ mtype = { data, eof }; proctype seed(chan in) { byte num, nr; do :: (num < 250) -> num = num + 5 :: (num > 3) -> num = num - 3 :: in!data,num :: (num > 200) -> in!eof,0 -> break od } init { chan in[1] of { byte, byte }; chan rgt [1] of { byte, byte }; byte n; run seed(in); in?data,n; run node(n, rgt, in); do :: rgt?eof,0 -> printf("\n"); break :: rgt?data,n -> printf("%d, ", n) od } proctype node(byte hold; chan up, down) { chan lft [1] of { byte, byte }; chan rgt [1] of { byte, byte }; chan ret [1] of { byte, byte }; byte n; bit havergt, havelft; do :: down?data,n -> if :: (n > hold) -> if :: ( havelft) -> lft!data,n :: (!havelft) -> havelft=1; run node(n, ret, lft) fi :: (n <= hold) -> if :: ( havergt) -> rgt!data,n :: (!havergt) -> havergt=1; run node(n, ret, rgt) fi fi :: down?eof,0 -> break od; if :: (!havergt) -> skip :: ( havergt) -> rgt!eof,0; do :: ret?data,n -> up!data,n :: ret?eof,0 -> break od fi; up!data,hold; if :: (!havelft) -> skip :: ( havelft) -> lft!eof,0; do :: ret?data,n -> up!data,n :: ret?eof,0 -> break od fi; up!eof,0 } 5.13 Promela is a validation modeling language, not an implementation language. Why does a civil engineer not use steel beams in wooden bridge models? 6.1 The assertion can be placed inside the critical section. The simplest way is as follows (rewritten with some features from the more recent versions of Spin): mtype = { p, v } chan sema[0] of { mtype }; byte cnt; active proctype dijkstra() /* 1 semaphore process */ { do :: sema!p -> sema?v od } active [3] proctype user() /* 3 user processes */ { sema?p; cnt++; assert (cnt == 0 || cnt == 1); /* critical section */ cnt--; sem!v skip /* non-critical section */ } 6.2 To check the truth of the invariant for every reachable state, one can write simply: never { do :: assert(invariant) od } Or to match an invalid behavior by reaching the end of the never claim, without assertions: never { do :: (invariant) /* things are fine, the invariant holds */ :: !(invariant) -> break /* invariant fails - match */ od } Note that semi-colons (or arrows) in never claims match system transitions, (i.e., each transition in the system must be matched by a move in the never claim; the claim does not move independently). 6.5 Using accept labels, for instance: proctype A() { do :: x = true; t = Bturn; (y == false || t == Aturn); ain = true; CS: skip; /* the critical section */ ain = false; x = false od } ... and simularly for proctype B() never { do :: skip /* allow arbitrary initial execution */ :: !A[1]@CS -> goto accept1 :: !B[2]@CS -> goto accept2 od; accept1: do :: !A[1]@CS od /* process 1 denied access forever */ accept2: do :: !B[2]@CS od /* process 2 denied access forever */ } 6.6.a never { do :: skip /* after an arbitrary number of steps */ :: p -> break od; accept: do :: p /* can only match if p remains true forever */ od } 6.6.b For instance: never { do :: assert(q || p) /* "!q implies p" */ od } 6.6.c never { /* <> (p U q) */ do :: skip /* after an arbitrary number of steps */ :: p -> break /* eventually */ od; do :: p /* p remains true */ :: q -> break /* at least until q becomes true */ od /* invalid behavior is matched if we get here */ } The translation has been automated, and is standard in Spin version 2.7 and later (Spin option -f). 6.7 A research problem -- there are no easy answers. 6.8 assert(0) is an immediate violation in both finite or infinite execution sequences, and is a safety property. accept: do :: skip od is only a violation for an infinite execution sequence, and is a liveness property (i.e., requires a nested depth-first search for acceptance cycles). The safety property can be proven more effieciently. Other than this, the two properties are equivalent; 7.1 Layers 3 to 5 and layer 7. 7.2 At the sender: first checksumming, then byte stuffing and framing. At the receiver: first unstuffing and de-framing, then checksum verification. 7.3 Rate control is placed at the layer that handles the units it refers too (for bit rates, it is the physical layer - for packets it would be the layer that produces packets, etc.). Dynamic flow control belongs in the flow control module. 7.13 The one-bit solution will no longer work. 8.1 The dash is used as a don't care symbol - any valid symbol could replace it without changing the validity of the specification. The epsilon is a null-element, i.e. it represents the absence of a symbol (the empty set). 8.7 No, the run and chan operators are defined to be unexecutable when an (implementation dependent) bound is reached. 9.2 No. 9.5 More states, up to a predefined bound only. Fewer states, yes. 9.6 No, the IUT could be arbitrarily large. 9.8 It can no longer detect transfer errors. 10.2 The computational complexity will make an interactive solution impossible for all but the simplest applications. 11.3 Missing from the program text is that variable j is initialized to 1 minus the value of i. 12.1 Note that the number of states to be searched by a validator on such a protocol would multiply by the range of the time count... 13.1 If done right, the changes will be minimal (say 10 to 20 lines of source). The memory requirements will very quickly make validations effectively impossible. Spin/Doc/Quick.html0000644000175100017510000012651612641606227012237 0ustar ghgh Concise Promela Reference

    Concise Promela Reference

    by Rob Gerth, June 1997

    This is a quick reference for things that can be found in the Spin man pages. It is less cursory on matters the discussion of which is scattered through the various Spin documentation files or only found in papers. In particular, sections Execution and Analysis are more descriptive. This reference is based on Spin version 2.9.7. For a slightly more detailed description see the Basic Spin Manual. A full description can be found in the Spin book.

    Introduction

    Spin is a tool for analyzing the logical consistency of distributed systems, specifically of data communication protocols. The system is described in a modeling language called Promela (Process or Protocol Meta Language). The language allows for the dynamic creation of concurrent processes. Communication via message channels can be defined to be synchronous (i.e., rendez-vous), or asynchronous (i.e., buffered). Xspin is a graphical front-end to drive Spin (written in Tcl/Tk).

    Given a model system specified in Promela, Spin can perform random or interactive simulations of the system's execution or it can generate a C program that performs a fast exhaustive verification of the system state space. During simulations and verifications Spin checks for the absence of deadlocks, unspecified receptions, and unexecutable code. The verifier can also be used to prove the correctness of system invariants and it can find non-progress execution cycles. Finally, it supports the verification of linear time temporal constraints; either with Promela never-claims or by directly formulating the constraints in temporal logic.

    The verifier is setup to be fast and to use a minimal amount of memory. The exhaustive verifications performed by Spin are conclusive. They establish with certainty whether or not a system's behavior is error-free. Very large verification runs, that can ordinarily not be performed with automated techniques, can be done in Spin with a ``bit state space'' technique. With this method the state space is collapsed to a few bits per system state stored. Although this technique doesn't guarantee certainty, the coverage is better, and often much better, than that obtained with traditional random simulation.

    Promela

    Spin models consist of 3 types of objects: processes, message channels, and variables. Processes are global objects. Message channels and variables can be declared either globally or locally within a process. Processes specify behavior, channels and global variables define the environment in which the processes run.

    The syntax of Promela is C-like. Below, our tendency is to use examples for those parts that are similar to C, but we attempt to be more precise elsewhere.

    Lexical conventions

    There are five classes of tokens: identifiers, keywords, constants, operators and statement separators. Blanks, tabs, newlines, formfeeds and comments serve only to separate tokens. If more than one interpretation is possible, a token is taken to be the longest string of characters that can constitute a token.

    Comments

    A comment starts with /* and terminates with */. Comments may not be nested.

    Identifiers

    An identifier is a single letter, period, or underscore followed by zero or more letters, digits, periods, or underscores.

    Keywords

    The following identifiers are reserved for use as keywords. 
    	active		assert		atomic		bit
	bool		break		byte		chan
	d_step		D_proctype	do		else
	empty		enabled		fi		full
	goto		hidden		if		init
	int		len		mtype		nempty
	never		nfull		od		of
	pc_value	printf		priority	proctype
	provided	run		short		skip
	timeout		typedef		unless		unsigned
	xr		xs

    Labels

    A label is an identifier followed by a colon (:). Any statement can be labeled. Labels that start with one of the sequences end, progress or accept have a special meaning, discussed in Section Analysis below.

    Constants

    A constant is a sequence of digits representing a decimal integer. There are no floating point numbers in Promela. Symbolic names for constants can be defined in two ways. The first method is to use a C-style macro definition 
    	#define NAME	5
    The second method is to use the keyword mtype; see symconst.

    Expressions

    The following operators and functions can be used to build expressions: 
    	+	-	*	/	%	>
	>=	<	<=	==	!=	!
	&	||	&&	|	~	>>
	<<	^	++	--
	len()	empty()	nempty()	nfull()	full()
	run	eval()	enabled()	pc_value()
    Most operators are binary. The logical negation (!) and the minus (-) operator can be both unary and binary, depending on context. The ++ and -- operators are unary suffix operators, like they are defined in C. The exclusive-or is ^. The functions on the one-but-last line are unary and apply only to message channels (see MsgChan); len measures the number of messages an existing channel holds; the other channel operators have the expected meaning and are introduced to assist partial order reductions; see pored. These functions cannot be used in larger expressions. E.g., !empty(q) will result in a syntax error and nempty(q) should be used instead. The unary functions on the last line are special. The first operator is used for process instantiation (see Processes below). When executed it yields the instantiation number of the instance it created. The second one is discussed in ChanOps and the others in never. The operators on the first four lines are defined as in C. Promela follows the C-convention that the boolean false-condition corresponds with the value 0; any non-zero value denotes truth.

    Conditional expressions

    	(expr1 -> expr2 : expr3)
    has the value of expr3 if expr1 evaluates to zero, and the value of expr2 otherwise. Note that -> is required here and cannot be replaced by a ;.

    Declarations

    Processes, channels, variables, etc. must be declared before they can be used. Variables and channels can be declared either locally, within a process, or globally. A process can only be declared globally in a proctype declaration. Local declarations may appear anywhere in a process body.

    Variables

    A variable declaration is started by a keyword indicating the basic data type of the variable, bit, bool, byte, short or int, followed by one or more identifiers, optionally followed by an initializer: 
    	byte name1, name2 = 4, name3
    An initializer, if specified, must be a constant. By default variables are initialized to zero. The bit-widths of these basic types are, respectively, 1, 1, 8, 16 and 32. The last two are signed quantities; the first three are unsigned. A variable can have a user-defined type as well; see structs.

    Arrays

    An array of variables is declared, e.g., by 
    	int name[4]
    An array can have a single constant as an initializer, initializing all array elements. Array indices start at 0, as in C; hence, the largest index would be 3 in this case.

    Symbolic constants

    Symbolic constants can be declared by 
    	mtype = {OK, READY, ACK}
    and variables of this type by 
    	mtype Status = OK;
    Only one mtype-definition is allowed which must be global and at most 256 symbolic constants can be declared; an mtype variable is 8 bits wide.

    The advantage of mtypes over #defines is that the former type of symbolic constants is recognized by Spin and during simulations the symbolic names are used instead of the values they represent.

    Message channels

    Message channels are declared, e.g., by 
    	chan Transfer  = [2] of {mtype, bit, short, chan};
	chan Device[3] = [0] of {byte};
	chan Channel;
    Here, Transfer can store up to 2 messages in the channel; the message type is indicated between the braces (in this case each message consists of 4 parts). Device is an array of channels; each channel is synchronous, i.e., sends and receives must synchronize as no messages can be stored. Finally, Channel is an uninitialized channel that can be used only after an initialized channel has been assigned to it.

    Note that an object of type chan can be part of a message declaration in another channel.

    Exclusive receive (xr) and send (xs) on channels

    	xr Transfer;
	xs Channel;
    in some process, declares that this process is the only one to receive messages on Transfer and the only one to send on Channel.

    It is a run-time error if during analysis it turns out that some other process receives from Transfer or sends to Channel.

    See Reductions for more detail.

    Structures

    User-defined data types are supported through typedef definitions, 
    	typedef Msg {
		byte a[3], b;
		chan p
	}
    that can be used in variable declarations and, more generally, wherever a type definition is needed: 
    	Msg foo;
	chan stream =[0] of {mtype,Msg}
    Elements of structures are accessed as in C; e.g., 
    	foo.a[1]

    Hidden variables

       hidden int foo
    A hidden variable is not part of the system state (see Execution) and its value is always undefined, although it can be assigned to. It is useful when a `scratch' variable is needed, e.g., to flush the values in a channel buffer, because it does not add to the size of the state-vector during analysis and thus reduces the memory requirements for analysis; cf. MemTim.

    Only global declarations can be thus qualified; elements of a structure are considered local. Bit, bool and channel variables cannot be hidden.

    There is a pre-declared hidden variable, _, which can be assigned to in any context. Its (implicit) type is int so that it can be used to assign bit, bool, byte, mtype, short and int values to.

    Processes

    A basic process declaration has the form 
    	proctype pname( chan In, Out; byte id )
	{ statements }
    Such a process is instantiated by a run-operation: 
    	run pname(Transfer, Device[0], 0)
    that first assigns the actual parameters to the formal ones and then executes the statements in the body. Each process instance has a unique, positive instantiation number, which is yielded by the run-operator (and by pid); see specvar. A process-instance remains active until the process' body terminates (if ever).

    Processes cannot have arrays as (part of) a formal parameter type, but structures are allowed.

    Process declarations can be augmented in various ways. The most general form is 

    	active [N] proctype pname(...) provided (E) priority M
    The active modifier causes N instances of the proctype to be active in the initial system state, where N is a constant. If [N] is absent, only one instance is activated. Formal parameters of instances activated through the active modifier are initialized to 0; i.e. actual parameters can only be passed using run-statements.

    A proctype can have an enabling condition E associated with it, which is a general side-effect free expression that may contain constants, global variables, the predefined variables timeout and pid, but not other local variables or parameters, and no remote references. Enabling conditions are evaluated once, in the initial state.

    For use during random simulations, a process instance can run with a priority M, a constant >=1. Such a process is M times as likely to be scheduled than a default (priority 1) process. Execution priorities can be used in a run-statement as well: 

    	run pname(...) priority M
    A process instantiated with a run statement always gets the priority that is explicitly or implicitly specified there (the default is 1).

    Note that priorities have no effect during analysis.

    Deterministic processes

    	D_proctype pname( chan In, Out; byte id )
	{ statements }
    declares that any instance of pname is deterministic. It has no other effect, then causing an error during analysis if some instance is not.

    Note that determinism is a dynamic property. E.g., if pname has in its body the statement 

    	if
	:: In?v  -> ...
	:: Out!e -> ...
	fi
    then non-determinism is flagged only if during some computation, there is an instance of pname for which the receive and send on the actual channels bound to In and Out are simultaneously enabled.

    Init process

    	init { statements }
    This process, if present, is instantiated once, and is often used to prepare the true initial state of a system by initializing variables and running the appropriate process-instances.

    Never claim

    	never { statements }
    is a special type of process that, if present, is instantiated once. As explained further in tempclaim, never claims are used to detect behaviors that are considered undesirable or illegal.

    The individual statements in statements are interpreted as conditions (see Exec and ExprStat) and, therefore, should not have side-effects (although this will cause warnings rather than syntax-errors).

    Statements that can have side-effect are assignments, auto-increment and decrement operations, communications, run and assert statements.

    Never claims can use three additional functions:

    • enabled(pid) This boolean function returns true if the process with instantiation number denoted by pid is able to perform an operation. This function can only be used in systems that do not admit synchronous communication
    • pc_value(pid) This function returns the number of the state that the process with instantiation number denoted by pid is currently in. (With state-numbers as given by the -d runtime option.)
    • _np This predicate is true if the system is in a non-progress state and is false otherwise. It is introduced to enable more efficient searches for non-progress cycles. See progress and SearchNPC.

    Special variables

    	_pid, _last
    _pid is a predefined local variable that holds the instantiation number of the process' instance. _last is a predefined global variable that holds the instantiation number of the process instance that performed the last step in the current execution sequence. Initially, _last is zero.

    Remote references

    The expression 
    	procname[pid]@label
    is true precisely if the process with instantiation number pid of proctype procname is currently at the statement labeled with label.

    Statements

    The following can be used as statements: 
    	assert		assignment	atomic		break
	declaration	d_step		else		expression
	goto		receive		selection	skip
	repetition	send		timeout		unless
    In particular, note that expressions can be used as statements as well.

    Statements are separated by either a semi-colon (;) or, equivalently, an arrow (->). The arrow is sometimes used to indicate a causal relation between successive statements and also in selection and repetition statements to separate the guard from the statements it is guarding; see select and repet.

    Statements that have no smaller statements as a constituent, are called basic. E.g., an assignment is a basic statement whereas a selection is not.

    Executability

    The execution of a statement is conditional on its enabledness (or ``executability''). Statements are either enabled or blocked. Of the above listed statements, assignments, declarations, assert, skip, goto and break are always enabled. If a statement is blocked, execution at that point halts until the statement becomes enabled.

    Assert

    	assert( expression )
    aborts the program if the expression returns a zero result; otherwise it is just passed.

    Atomic

    	atomic { statements }
    attempts to execute the statements in one indivisible step; i.e., without interleaved execution of other processes. An atomic statement is enabled if its first statement is.

    Making local computations atomic can effect important reductions of the complexity of the verification system; cf. MemAtD.

    During its execution, control can only be transferred outside the scope of an atomic statement by an explicit goto or at a point where a statement within its scope becomes blocked. If this statement subsequently becomes enabled again, execution may continue at that point.

    There is no constraint on what may occur inside the scope. In particular, it is possible to jump to any (labeled) location within the scope of an atomic.

    The body of a process instance activated by a run-statement is considered to be outside the scope of the atomic statement performing the activation.

    Break

    See Repetition.

    Goto

    	goto label
    transfers control to the statement labeled by label which has to occur in the same procedure as the goto.

    Deterministic step

    	d_step { statements }
    has the same effect as atomic but is even more efficient; cf. MemAtD. However, statements within its scope must be completely deterministic; they may not jump to labels outside the d_step's scope; there may be no jumps from the outside to labeled statements within the scope; remote references (see RmtRef) are disallowed. Finally, statements other than the first may not block. A d_step is enabled precisely if its first statement is. Promela considers the location in front of the d_step to be within its scope and the location just after its last statement to be outside. Hence, to achieve the intended effect of the following incorrect code-fragment: 
    	goto label;
	...
label:
	d_step {
		...
		do
		...
			break
		...
		od
	}
    use this code instead: 
    	goto label;
	...
label: skip;
	d_step {
		...
		do
		...
			break
		...
	od; skip
	}

    Else

    See select.

    Expressions

    Any expression that does not use auto-increment or decrement operations (++ or --) can be used as a statement. In that case, it is enabled precisely if it evaluates to a non-zero value. An enabled expression is just passed, without affecting the state.

    For example, instead of writing a busy wait loop 

    	while (a != b) skip
    the same effect is achieved in Promela by the statement 
    	(a == b)

    Channel operations

     	q!var1,const,var2,...  or, equivalently  q!var1(const,var2,...)
	q?var1,const,var2,...  or, equivalently  q?var1(const,var2,...)
    Are the standard channel operations; the first is a send statement, the second a receive. Here, q denotes a channel and the list var1,const,var2,... should be compatible with the channel's message type. For a send or receive to be enabled, q has to be initialized. Furthermore, if the channel is buffered, a send is enabled if the buffer is not full; a receive is enabled if the buffer is non-empty. On an unbuffered channel, a send (receive) is enabled only if there is a corresponding receive (send) that can be executed simultaneously. A receive statement executes by reading the oldest message on the channel; if the channel is unbuffered, it reads the message of the simultaneously executing send statement. A send statement executes by putting its message in the buffer (if there is one). Note that a channel operation on an unbuffered channel can only execute if a matching operation executes simultaneously.

    Constants in the list of a receive, constrain its enabledness by forcing the corresponding values in the oldest message (or matching send) to be the same; if not, the receive is blocked.

    It is possible to use a local or global variable to likewise constrain a channel operation's enabledness: 

    	q?var1,eval(var2),var3
    blocks in case a matching send's 2nd value does not equal the value of var2. Note that the value of var2 is not changed.

    For buffered channels, there are additional operations:

    • q?[var1,const,var2] returns true (i.e. a non-zero value) precisely if the corresponding receive operation would be enabled.
    • q?<var1,const,var2> like a standard receive operation except that the message is not removed from the buffer.
    • q!!var1,const,var sorted send; it inserts its message into the buffer immediately ahead of (so that it will be younger than) the oldest message that succeeds it in numerical, lexicographic order.
    • q??var1,const,var random receive; it executes if there is some message in the buffer for which it is enabled and then retrieves the oldest such message.
    • q??[var1,const,var2] returns true (i.e. a non-zero value) precisely if the corresponding receive operation would be enabled.
    • q??<var1,const,var2> like a standard random receive operation except that the message is not removed from the buffer.
    The behavior of buffered channels can be influenced by the Spin command line switch -m: in that case, send actions on a channel do not block if the channnel's buffer is full; instead, messages send when the buffer is full are lost.

    Selection

    	if
	:: statements
	...
	:: statements
	fi
    Selects one among its options (each of them starts with ::) and executes it. An option can be selected if its first statement (the guard) is enabled. A selection blocks until there is at least one selectable branch. If more than one option is selectable, one will be selected at random. The special guard else can be used (once) in selection and repetition statements and is enabled precisely if all other guards are blocked. It may not be used if a send or receive statement is used as guard.

    Repetition

    	do
	:: statements
	...
	:: statements
	od
    Similar to a selection, except that the statement is executed repeatedly, until control is explicitly transferred to outside the statement by a goto or break. A break will terminate the innermost repetition statement in which it is executed and cannot be used outside a repetition.

    Skip

    Has no effect and is mainly used to satisfy syntactic requirements.

    Timeout

    A timeout statement becomes enabled precisely when every other statement in the system is blocked. It has no effect when executed.

    Unless

    	{ statements-1 } unless { statements-2 }
    Starts execution in statements-1. Before each statement in statements-1 (including the first one) is executed, enabledness of statements-2 is checked and if it is, execution of statements-1 is aborted and control transfers to statements-2; control remains in statements-1, otherwise. If statements-1 terminates, statements-2 is ignored.

    In an unless, a d_step, in contrast with an atomic, is considered indivisible; i.e., enabledness of statements-2 is not checked if control in statements-1 resides within the scope of a d_step.

    Executing a Promela system

    A system state of a Promela system comprises the values of the global variables, the contents of the channel buffers and for each process instance, the values of its location counter, its local variables and local channel buffers. If a never claim is present, the state also includes the value of the claim's location counter.

    Initially, all global (non-initialized) variables contain the value 0 and the channel buffers are empty. The existing process instances are the ones created through the active modifier on the proctype declarations together with the init and never processes, if present. The location counters of these instances are at their first statements.

    A system state of a Promela system uniquely identifies the enabled statements in every (active) process instance. An execution step in a system without never claim, proceeds by arbitrarily selecting one of the enabled statements and then executing that statement, thus arriving in a new system state. So, process instances execute asynchronously. Note, however, that in case the selected statement was an unbuffered send (receive), a corresponding receive (send) statement was executed simultaneously.

    If the system does have a never claim, an execution step is a combined, synchronized step: executing an (enabled) statement from the never claim together with a step from the rest of the system, as above. Thus, a never claim blocks execution of the system, in those situations in which the never claim has no enabled statements (in the current state); also see tempclaim.

    The execution sequences, or behaviors, of a Promela system are the maximal (possibly infinite) sequences of execution steps, in which the first step is taken from the initial system state and each successive step from the state produced by the preceding step. In particular, notice that Promela allows starvation of processes during an execution. This behavior can be influenced by the analyzer command line switch -f (the weak fairness option). If used, process starvation cannot occur; i.e., execution sequences along which some process instance eventually does not make a move anymore although the instance remains continuously enabled are no longer possible.

    Atomic statements and d_steps

    Atomic statements and d_steps constrain execution elsewhere in the system, as they execute (in principle) as a single basic statement. Accordingly, in the presence of a never claim, an execution step of the system combines a single step in the never claim with an execution sequence of the atomic statement or d_step (defined as if there were no never claim). Note that in the case of an atomic statement, such an execution sequence may end in the middle of it and the above holds for subsequent steps within the atomic statement as well.

    Analysis

    A Promela system can be exhaustively (but efficiently) analyzed for correctness violations: i.e., for the existence of execution sequences that abort through an assert; that end in an invalid end-state; that avoid cycling through certain desirable, so-called progress states or that cycle through undesirable, so-called acceptance states; and for executions satisfying general (linear time) temporal properties (or claims) defined through never-claims.

    End-states

    Valid end-states are those system states in which every process instance and the init process has either reached the end of its defining program body or is blocked at a statement that is labeled with a label that starts with the prefix end. All other states are invalid end-states.

    Strictly speaking, valid end-states should also require channels to be empty. Conformance with this stricter condition is obtained through Spin's -q option.

    When checking for state properties, the verifier will complain if there is an execution that terminates in an invalid end-state.

    Progress states

    A progress state is any system state in which some process instance is at a statement labeled with a label that starts with the prefix progress; a progress label.

    When checking for non-progress cycles, the verifier will complain if there is an execution that does not visit infinitely often a progress state.

    Acceptance states

    An acceptance state is any system state in which some process instance is at a statement labeled with a label that starts with the prefix accept; an acceptance label.

    When checking for acceptance cycles, the verifier will complain if there is an execution that visits infinitely often an acceptance state.

    Temporal claims

    Temporal claims are defined by Promela never claims (see never) and are used to detect behaviors that are considered undesirable or illegal.

    When checking for state properties, the verifier will complain if there is an execution that ends in a state in which the never claim has terminated; i.e., has reached the closing } of its body. When checking for acceptance cycles, the verifier will complain if there is an execution that visits infinitely often an acceptance state. Thus, a temporal claim can detect illegal infinite (hence cyclic) behavior by labeling some statements in the never claim with an acceptance label.

    In such situations the never claim is said to be matched. In the absence of acceptance labels, no cyclic behavior can be matched by a temporal claim. Also, to check a cyclic temporal claim, acceptance labels should only occur within the claim and nowhere else in the Promela system.

    A never claim is intended to monitor every execution step in the rest of the system for illegal behavior and for this reason it executes in lock-step. Such illegal behavior is detected if the never claim matches along a computation. If a claim blocks (because no statement in its body is enabled) but it is not at its closing }, then there is no need to explore this computation any further because it cannot lead to a violation; whence a blocked claim terminates execution in the rest of the system so that other executions can be explored.

    Note that if a never claim exhibits non-determinism then, according to the definition of execution sequence, the different ways in which this non-determinism is resolved result in different executions.

    Example claim

    Let p and q be two boolean expressions and consider the property that
      ``along every computation, each system state in which p is true (a p-state) is eventually followed by a q-state''
    The following never claim verifies whether the property holds; i.e., it will detect any violation of the property: 
    never {
	do
	:: p -> break
	:: true		/* or equivalently: (p || !p) */
	od;
accept:
	do
	:: !q
	od
}
    The first repetition terminates only in p-states. Such a state should eventually be followed by a q-state. The second repetition (hence the never claim) cannot terminate, so the never claim either eventually blocks because the computation sequence reaches a q-state or matches because the (infinite) computation cycles through an acceptance state. The latter occurs precisely if there are no subsequent q-states. Because the analyzer guarantees an exhaustive search for computations along which the never claim is matched, a computation violating the property is guaranteed to be detected (if there is one).

    Note that replacing skip by else would check only the first occurrence of a p-state along computations. Stated differently, by giving the first repetition the non-deterministic choice in p-states to either break or continue and by relying on the exhaustive search mechanism of the analyzer, every occurrence of a p-state is checked. In fact, one can show that it is impossible to check this property without using non-determinism as above.

    Memory and Time requirements

    For this, a bit more must be said about the actual analysis process. The basic process is recursive (though its implementation is not) and starts in the initial system state. In each system state, the list of enabled actions is determined. Then each action in this list is selected, it is executed and the procedure is recursively applied to the new system state. If a never claim is present, the list becomes a list of action-pairs: one from the never claim together with an action (or execution sequence if an atomic or d_step is involved) from some active process instance. The recursion backtracks from any system state that has already been visited or in which there is no enabled action (pair) that has not already been selected in this state. Thus, the basic process is a depth-first generation of all (reachable) system states. In reality the process is more complex because the absence of correctness violations need be established as well.

    As to the memory demands when checking for state properties, the visited system states need to be stored in order to decide when to backtrack, as well as the partial computation that is being extended (the `stack' in terms of depth-first generation) in order to know where to backtrack to. This, together with the number of bytes needed to represent a system state, i.e., the size of the state vector, determines the amount of memory that is needed to complete an analysis. In particular, the set of already visited system states must be kept in main memory as this set is accessed in an, essentially, random way during analysis. This is the reason why the size of the system that can be analyzed is directly determined by the amount of physical RAM.

    If analysis has to establish the presence (progress) or absence (acceptance) of cyclic computations, both the number of stored states and the size of the `stack' at worst doubles when compared to the case of checking state properties. Note that checking a never claim corresponds to the analysis of a property in one of these three classes. Also note that adding a non-deterministic never claim to a system will in itself increase the state space so that it is quite possible that the memory demands increase more than twofold when searching for behavior matching a never-claim that has an acceptance state.

    Analysis time is proportional to the number of visited configurations.

    Atomic statements and d_steps

    An atomic statement or d_step causes the statements in its scope to execute, in principle, as a single basic statement. Accordingly, the number of system states is reduced, whence the memory needed to record the visited (global) states, because no process instance can change state other than the one in which control resides within the atomic statement or d_step. In addition, system states in which control resides inside some d_step need not be recorded at all; not even on the stack.

    Partial order reduction

    This is an optimized search technique that decreases the memory and time needed for an analysis by an order of magnitude in most cases; sometimes substantially more. It will never increase the necessary memory and, at worst, only slightly increase the analysis time. The reduction method is invoked by default and the analysis results are guaranteed to be the same as those obtained without reduction. Generally speaking, partial order reduction works during analysis by deciding in each system state where there is non-determinism, whether the property that is being verified depends on the order in which execution steps are taken. If it is independent of this order, the analyzer fixes an ordering and ignores executions in which these steps are taken in a different order. Thus, the effect is as if pieces of Promela code had been enclosed in atomic statements, except that they are dynamically placed. I.e., the execution order of syntactically the same two statements can influence the property in one system state, whereas the property can be independent of the ordering in another.

    Partial order reduction as implemented in Spin has the most effect on loosely coupled systems that interact through shared, global variables and/or buffered channels. If a system has no shared variables and uses only unbuffered communication channels, there will be no reduction in memory or time.

    Stutter closedness

    The only requirement for using partial order reduction is that a Promela never claim must be stutter-closed. This means that the property expressed by the claim must not depend on the number of execution steps that it remains true or false. For example, the two never claims in the example are stutter-closed, whereas the claim 
    	never { p; p }
    is not, since it depends on the expression p remaining true for at least one execution step (and it has to be true in the initial system state).

    Any property that can be expressed in linear temporal logic without using the `next-state' (X) operator is guaranteed to be stutter-closed. In fact, the above never claim would correspond to the temporal logic formula: p && X p.

    In fact, independently of whether partial order reduction is used or not, it is probably a good idea to only verify stutter closed never claims.

    Searching for non-progress cycles

    Non-progress cycles can be detected using the runtime -l option. This will cause a search for acceptance cycles with the following never claim compiled in: 
    never {
	/* non-progress: <>[] np_ */
	do
	:: skip
	:: np_ -> break
	od;
accept:
	do
	:: np_
	od
}
    This never claim matches along behaviors on which from some point onwards, the predicate np_ remains true; i.e., only non-progress states are visited.

    Note that for more complex non-progress properties, the user has to supply her own never claim and it is here that the np_-predicate is of use.

    Increasing the amount of reduction

    If a system uses buffered communications, the effectiveness of partial order reduction can be enhanced by declaring proctypes to have exclusive access to channels (xr and xs) whenever this is the case. However, doing so constrains the way a channel can be accessed: 
    	If you declare   Other processes may only do
	xr q             send actions on q
	                 nfull(q)
	xs q             receive actions on q
	                 nempty(q)
    Any other type of access will give an error during analysis. In particular the functions full() and empty(), which are included for reasons of symmetry.

    Bitstate hashing

    Bitstate hashing is used in cases where memory is insufficient to perform an exhaustive analysis (even with partial order reduction). It is compatible with partial order reduction. Bit-state hashing applies to larger models but (or, rather, because) it does not guarantee an exhaustive analysis. On the other hand, when set-off against classical random simulation techniques, it is always better to use bit-state hashing because the coverage (i.e., the number of visited stated relative to the number of actual states) is never worse, and usually much better, than that achieved with random simulation. Using this technique, the analyzer will never incorrectly flag errors; however, it may miss errors.

    Bit-state hashing works by allowing more states to be stored in the memory, M, set aside for recording visited states; the memory needed to store the stack is not reduced. It achieves this reduction by viewing every bit in M as a bucket in a hash table. Each system state is hashed onto a fixed number of buckets (i.e., 2), but only the fact that a bucket has become filled is recorded. In other words, there is no collision detection and if two system states hash onto the same buckets, they are deemed to be the same states. It is this feature that allows many more states to be stored. E.g., if the state vector of a system is 100 bytes then bit-state hashing, in the ideal case of a perfect hashing function, allows upto 800 times as many states to be stored and visited as would be possible with an exhaustive analysis using the same amount of memory.

    Reality is more complex. Hash functions are not perfect, collisions will occur and get more common the fuller the hash table becomes and each collision potentially causes a part of the state space to remain unexplored.

    The analyzer gives an indication of the quality of a bit-state search in the form of a hash factor: the fraction of buckets that were filled. I.e., a hash-factor of 100 means that, on average, at most 1 out of every 100 bits in M was set. This is taken as indicating a good quality search. Spin reports in this case ``expected coverage: >= 99.9% on avg.''. For a hash-factor between 10 and 100, Spin gives an expected coverage of 98% on average. These are heuristic estimates, and the variance can be large. E.g., experiments indicate that `98% coverage on average' can mean as low as 84% during an actual analyzer run. On the other hand, such coverage still is much superior over what is achieved by a standard random simulation.

    Spin Online References
    Promela Manual Index
    Promela Grammar     		Spin HomePage
    Spin/Doc/Book1991_Ch6_add.txt0000644000175100017510000001730211753004053013544 0ustar ghghAn appendix to Chapter 6 of the book: some extra explanation on pid's and on temporal claims. Updated for Spin Version 2.0 - January 1995. PROCESS IDs In Spin 2.0 and later the never claim can refer to the control state of any process, but not to their local variables. This functionality is meant to be used for building correctness assertions with never claims. It should never be used for anything else. An example is Receiver[pid]@place where `place' the name of a label within `proctype Receiver,' and `pid' is the value returned by the run statement that instantiated the copy of the Receiver proctype that we are interested in. There is a misleading suggestion in the book that says that you can usually guess the `pid's. Wiser is to always use the explicit value returned by the `run()' statement that instantiated the proces. Processes started with the `active' prefix obtain instantiation numbers starting at value 1, in the order in which they appear in the specification. Each process also has a local variable _pid that holds its own instantiation number. SPECIFYING TEMPORAL CLAIMS The body of a temporal claim is defined just like PROMELA proctype bodies. This means that all control flow structures, such as if-fi selections, do-od repetitions, and goto jumps, are allowed. There is, however, one important difference: Every statement inside a temporal claim is (interpreted as) a condition. A never claim should therefore never contain statements that can have side-effects (assignments, communications, run-statements, etc.) Temporal claims are used to express behaviors that are considered undesirable or illegal. We say that a temporal claim is `matched' if the undesirable behavior can be realized, and thus the claim violated. The recommended use of a temporal claim is in combination with acceptance labels. There are two ways to `match' a temporal claim, depending on whether the undesirable behavior defines a terminating or a cyclic execution sequence. o A temporal claim is matched when it terminates (reaches its closing curly brace). That is, the claim can be violated if the closing curly brace of the PROMELA body of the claim is reachable for at least one execution sequence. o For a cyclic execution sequence, the claim is matched only when an explicit acceptance cycle exists. The acceptance labels within temporal claims are user defined, there are no defaults. This means that in the absence of acceptance labels no cyclic behavior can be matched by a temporal claim. It also means that to check a cyclic temporal claim, acceptance labels should only occur within the claim and not elsewhere in the PROMELA code. SEMANTICS The normal system behavior of a PROMELA system is defined as the `asynchronous product' of the behaviors of the individual processes. Given an arbitrary system state, its successor states are obtained in two steps. In the first step all the executable (atomic) statements in the individual processes are identified. In the second step, each one of these statements is executed. Each single execution produces a successor state in the asynchronous product. The complete system behavior is thus defined recursively and represents all possible interleavings of the individual process behaviors. Call this asynchronous product machine the `global machine'. The addition of a temporal claim defines an additional `synchronous product' of this global machine with the state machine that defines the temporal claim. Call the latter machine the `claim machine', and call the new synchronous product the `labeled machine'. Every state in the labeled machine is a pair (p,q) with p a state in the global machine and q a state in the claim machine. Every transition in the labeled machine is similarly defined by a pair (r,s) with r a transition in the global machine and s a transition in the claim machine. In other words, every transition in the `synchronous' product is a joint move of the global machine and the claim machine. (By contrast, every transition in an `asynchronous' product would correspond to a single transition in either the global machine or the claim machine, thus interleaving transitions instead of combining them.) Since all statements in the claim machine are boolean propositions, the second half of the transition pair (r,s) is either true or false. Call all transitions where this proposition is true `matching transitions'. In a matching transition proposition s evaluates to true in state system state r. Notice that the claim machine has at least one stop state E, the state at the closing curly brace of the claim body. The semantics of temporal claims can now be summed up as follows. o If the labeled machine contains any sequence of matching transitions only, that connects its initial state with a state (p,E) for any p, the temporal claim can be matched by a terminating sequence (a correctness violation). o If the labeled machine contains any cycle of matching transitions only, that passes through an acceptance state, the temporal claim can be matched by a cyclic sequence. EXAMPLES Listed below are the equivalent PROMELA definitions for the three basic temporal properties defined by Zohar Manna & Amir Pnueli in ``Tools and Rules for the Practicing Verifier'' Stanford University, Report STAN-CS-90-1321, July 1990, 34 pgs. The following descriptions are quoted from Manna & Pnueli: ``There are three classes of properties we [...] believe to cover the majority of properties one would ever wish to verify.'' 1. Invariance ``An invariance property refers to an assertion p, and requires that p is an invariant over all the computations of a program P, i.e. all the states arising in a computation of P satisfy p. In temporal logic notation, such properties are expressed by [] p, for a state formula p.'' Corresponding Temporal Claim in PROMELA: never { do :: p :: !p -> break od } 2. Response ``A response property refers to two assertions p and q, and requires that every p-state (a state satisfying p) arising in a computation is eventually followed by a q-state. In temporal logic notation this is written as p -> <> q.'' Corresponding Temporal Claim in PROMELA: never { do :: true :: p && !q -> break od; accept: do :: !q od } Note that using (!p || q) instead of `skip' would check only the first occurrence of p becoming true while q is false. The above formalization checks for all occurrences, also future ones. Strictly seen, therefore, the claim above uses a common interpretation of the formula, requiring it to hold always, or: [] { p -> <> q } 3. Precedence ``A simple precedence property refers to three assertions p, q, and r. It requires that any p-state initiates a q-interval (i.e. an interval all of whose states satisfy q) which, either runs to the end of the computation, or is terminated by an r-state. Such a property is useful to express the restriction that, following a certain condition, one future event will always be preceded by another future event. For example, it may express the property that, from the time a certain input has arrived, there will be an output before the next input. Note that this does not guarantee [require] that the output will actually be produced. It only guarantees [requires] that the next input (if any) will be preceded by an output. In temporal logic, this property is expressed by p -> (q U r), using the unless operator (weak until) U. Corresponding Temporal Claim in PROMELA: never { do :: true /* to match any occurrence */ :: p && q && !r -> break :: p && !q && !r -> goto error od; do :: q && !r :: !q && !r -> break od; error: skip } Strictly again, this encodes: [] { p -> (q U r) } To match just the first occurence, replace 'true' with (!p || r). Spin/Doc/3_SpinGUI.html0000644000175100017510000002500012641606227012645 0ustar ghgh Getting Started: Using iSpin

    Getting Started:
    Using iSPIN

    A convenient way to get started with routine use of Spin is to use the graphical interface iSpin. The graphical interface runs independently from Spin itself, and helps by generating the proper Spin commands based on menu selections. iSpin invoked Spin itself in the background to obtain the desired output, and wherever possible it will attempt to generate a graphical representation of that output. iSpin knows when and how to compile code for the model checkers that Spin can generate, and it knows when and how to execute it, so there is less to remember. For more information on running Spin directly, see the companion document Spin_Verification.html, and to get familiar with it, try the exercises in Spin_Exercises.html.

    The description below assumes that the appropriate software packages (spin, ispin, wish for tcl/tk support, optionally the dot tool from the GraphViz distribution, and a standard C compiler such as gcc) have been installed on your system and that all relevant commands are within your search path. If this is not the case, follow the instructions in the README file first.

    One

    To start a first session with iSpin, use one of the example Promela specifications from the Examples directory of the Spin distribution. For instance: 
      $ cd Examples/LTL
$ ispin leader.pml
    The dollar sign above ($) is the prompt of the command-shell. The next two words are typed by the user. If all is well, after ispin starts up it will print something like the following in its command-log at the bottom of the main window: 
      SPIN LOG:
 Spin Version 6.3.0 -- 4 May 2014
iSpin Version 1.1.1 -- 22 February 2014
TclTk Version 8.5/8.5
1 leader.pml:1
    All further commands executed in the background, prompted by user selections in the other windows, appear here as well.

    Two

    You should now have the main iSpin control window on the display, with a Promela specification of the leader election protocol loaded. First, press the Help button in the top menu bar to view the available help topics. Browse some of the topics, and close the Help window when done.

    The main text window on the left offers some basic edit and search capabilities. You can scroll through the specification either with button-2 down (on a 3-button mouse), or with the scroll-bar.

    You can select text fragments by sweeping the mouse with button-1 (the left-most button) down. Control-C (copy), Control-V (past), and Control-Z (undo) are supported. If you are more comfortable working with another text-editor, a reasonable way of working with iSpin is also to have the text of a specification open in your favorite editor. To update iSpin's view of the file after externally editing it, select ReOpen from the top menu bar.

    Three

    Still within this first view, you can perform a basic Syntax Check, and a basic check for Redundancies, by selecting the corresponding buttons near the top of the screen. You can also get the Symbol table of the Promela specification printed out in the same way.

    The Automata View panel on the right hand side of the screen relies on the availability of the dot tool from the graphviz distribution. If you have it installed, clicking on the automata view button can display each proctype as a graph.

    Next, move to the Simulate/Replay tab, at the top-left of the display. This allows you to select a range of parameters for a simulation run. For now, just accept the default settings that are shown, and press the Run button, on the right, to perform a first simulation run.

    Four

    A Message Sequence Chart will be created in the right mid-panel (assuming your model includes message passing operations of course). Resize it to suit your needs.

    The panels on the bottom of the screen contain additional information about the run. The lower-left and lower-right display the current Data Values and Channel Contents respectively, at each point in the run. For very large models, you may want to turn off data value tracking, if it starts slowing down the simulations.

    The simulation output itself appears in the middle panel at the bottom. Once a run is completed, or stopped, you can use the Rewind button to go back to the start of the run, and step forwards or backwards through it -- with all values and queue states updated appropriately. You can also click in the message sequence chart or the output panel to move to a specific point in the run.

    Five

    A log window at the upper right of the iSpin display shows which commands are being generated by iSpin and executed by Spin in the background. For instance, the simulation run will probably be invoked as follows: 
      spin -X -p -v -g -l -s -r -n1 -j0 leader.pml
    The advantage of using iSpin is that you do not have to remember the meaning of all the options that Spin recognizes. (Not all the the options used above are critical though, so there's also no need for concern if you rather use Spin without this interface. You can find out what all the options to Spin are by typing in a regular shell window: "spin --"

    Six

    By clicking in the boxes in the Message Sequence Chart displayed on the right, the text window with the Spin model on the middle left should move to the corresponding point in the code.

    Seven

    Next, move to the tab labeled Verification in the top menu bar. There are lots of choices that can be made about the type of verification that can be done. The most common choices are in the panels at the top left, colored light blue. The less frequently used, and more advanced options can be displayed by clicking the black option buttons titled Show... to the right. For now, accept the default settings of the parameters and press the Run button near the middle of the display.

    The commands that iSpin generates are printed in the log, which is now shown in the black right-hand side panel. iSpin first generates a verifier, then compiles and executes it, and shows the results. If all is well, no errors are detected in the specification. The version of the leader election protocol that is being verified contains several correctness requirements specified as inline LTL formula.

    By default, iSpin is setup to perform a safety verification only. To check one of the LTL properties, select under Liveness (left side of the screen, in light blue), the option acceptance cycles and type the name of the LTL property to be verified in the box just above the Run and Stop buttons. For instance, type p0, p1, p2, or p3.

    Eight

    Introduce an artificial error in the specification by adding an 
      assert(false)
    statement on line 27, as follows: 
      :: Active ->
    becomes: 
      :: Active -> assert(false)
    Save the file (you have to move to the Edit/View panel to do that), and repeat the verification by clicking the Run button.

    This time, the verification should come back with an error sequence, and notice at the bottom of the output window recommends to replay the error trail from the Simulate/Replay panel. Bring up that tab and make sure a Guided simulation is selected. (A guided simulation can only be done for an error sequence that was produced earlier by the verifier.) Perform the guided simulation, which will now replay the error sequence found, ending with the assertion violation.

    Nine

    For advanced use. Bring up the Swarm Run panel. If you have swarm installed (if not, see http://spinroot.com/swarm), and you have a multi-core computer with a reasonable number of CPU cores, you can now setup a swarm run, using as many cores as you have available.
      Note: This option will become more attractive as standard PCs start getting more and more CPU cores.
    Don't select more cores than you physically have on your system and don't select more memory than you have. The options in the top right-panel show how Spin will compile the verifier to create lots of different types of verification runs. This method is especially useful for very large verification models that cannot be exhaustively verified, but where we still want to gain maximum confidence that we can find the errors in a reasonable amount of time.

    Ten

    The final two tabs at the top of the iSpin display are to Save or Restore an entire verification session, including all options selected and intermediate results created. It can be useful to remember what precisely you did and how you found counter-examples. It provides a small approximation of a version management system for Spin verification runs.
    The very last button in the top menu ribbon is Quit, but why would you ever want to do that?

    Spin HomePage (Page Updated: 8 May 2014)
    Spin/Doc/Book1991_Errata.txt0000644000175100017510000003264511753004053013541 0ustar ghghErrata for `Design and Validation of Computer Protocols' [trivial typos not listed] CHAPTER 2, page 26 - Example of a Shorter Error Scenario ============================================================ A duplicate message can be accepted after even a single transmission error occurs. E.g.: (A) (B) ~ ~ | | | ack 'z' /-----------<---------+ +-----------/ | accept(z) | | +-----------\ ack 'a' -> err | | \----------->--------+ | | | nak 'z' /-----------<--------+ +------------/ | accept(z) | | CHAPTER 3, page 61/62 - Revised CRC-Algorithm (Bits renumbered in more standard right to left order.) ============================================================ The following C program, by Don Mitchell of AT&T Bell Laboratories, generates a lookup table for an arbitrary checksum polynomial. Input for the routine is an octal number, specified as an argument, that encodes the generator polynomial. In the version of the program shown here, compliments of Ned W. Rhodes, Software Systems Group, bits are numbered from zero to r-1, with bit zero corresponding to the right-most bit, and r the degree of the generator polynomial. (In Mitchell's original algorithm the bits in the message and generator polynomial were reversed.) The r-th bit itself is omitted from the code word, since it is implicit in the length. Using this program takes two separate steps. First, the program is compiled and run to generate the lookup tables. Then the checksum generation routine can be compiled, with the precalculated lookup tables in place. On a UNIX system, the program is compiled as $ cc -o crc_init crc_init.c Lookup tables for the two most popular CRC-polynomials can now be produced as follows: $ crc_init 0100005 > crc_16.h $ crc_init 010041 > crc_ccitt.h This is the text of crc_init.c: main(argc, argv) int argc; char *argv[]; { unsigned long crc, poly; int n, i; sscanf(argv[1], "%lo", &poly); if (poly & 0xffff0000) { fprintf(stderr, "polynomial is too large\n"); exit(1); } printf("/*\n * CRC 0%o\n */\n", poly); printf("static unsigned short crc_table[256] = {\n"); for (n = 0; n < 256; n++) { if (n % 8 == 0) printf(" "); crc = n << 8; for (i = 0; i < 8; i++) { if (crc & 0x8000) crc = (crc << 1) ^ poly; else crc <<= 1; crc &= 0xFFFF; } if (n == 255) printf("0x%04X ", crc); else printf("0x%04X, ", crc); if (n % 8 == 7) printf("\n"); } exit(0); } The table can now be used to generate checksums: unsigned short cksum(s, n) register unsigned char *s; register int n; { register unsigned short crc=0; while (n-- > 0) crc = crc_table[(crc>>8 ^ *s++) & 0xff] ^ (crc<<8); return crc; } CHAPTER 4, page 81 - Typo ============================================================ old< Taking the modulo M effect into account, this becomes: valid(m) = ( 0 < p - m <= W ) || ( 0 < p - M - m <= W ) new> Taking the modulo M effect into account (p is always smaller than M), this becomes: valid(m) = ( 0 < p - m <= W ) || ( 0 < p + M - m <= W ) ERROR, Page 83, Figure 4.14 =========================== should not "accept:i" if (a==e) is false CHAPTER 5, error/typos =========================== Page 96, bottom The mutual exclusion algorithm attributed to Dekker is really a simplication of Dekker's algorithm that is known as Peterson's algorithm. Dekker's original solution is modeled in Promela like this: #define true 1 #define false 0 #define Aturn 1 #define Bturn 0 bool x, y, t; proctype A() { do :: x = true; if :: y == true && t == Bturn -> x = false; (t == Aturn) :: y == false -> break fi od; /* critical section */ t = Bturn; x = false } proctype B() { do :: y = true; if :: x == true && t == Aturn -> y = false; (t == Bturn) :: x == false -> break fi od; /* critical section */ t = Aturn; y = false } init { run A(); run B() } =========================== Page 98, last paragraph old> "If the receive operation tries to retrieve more parameters than are available, the value of the extra parameters is undefined; if it receives fewer than the number of parameters that was sent, the extra information is lost." new> "It is always an error if the receive operation tries to retrieve a different number of parameters than the corresponding channel declaration specifies." =========================== Page 99, last line of "init", middle of page: old< qname!qforb new> qname[0]!qforb Page 100, delete last line on page: old< byte name; /* delete */ Page 103, in the Dijkstra example: old< chan sema = [0] of { bit }; new> chan sema = [0] of { mtype }; Page 108, "init" section, top of page: old< chan Ain = [2] of { byte }; chan Bin = [2] of { byte }; chan Aout = [2] of { byte }; chan Bout = [2] of { byte }; new> chan Ain = [2] of { byte, byte }; chan Bin = [2] of { byte, byte }; chan Aout = [2] of { byte, byte }; chan Bout = [2] of { byte, byte }; =========================== Page 107, last sentence of first paragraph Section 5.12: old< discussed in Section 2.4. new> discussed in Section 2.3. =========================== Page 110, exercise 5-3: old< Revise the two programs from Section 5.6 new> Revise the two programs from Section 5.8 CHAPTER 6 TYPO, page 117 ======================= old< chan sema[0] of {bit}; new> chan sema = [0] of {bit}; SERIOUS OMISSION, Section 6.4, page 116-117: ================================================= The treatment of formalizing system invariants in a 1-statement monitor process is correct only if the model does not contain any timeout statements. If it does, the statements in the model that would be executed after a timeout expires are not checked (since assert is always executable, it would always be executed before the timeout expires under default timeout heuristics used in spin). there are two possible solutions: - disable the default timeout heuristics for a fully exhaustive search for all possible choices of timeouts (brute force) to do this, include a single line #define timeout skip as the first line of your model - and nothing else has to change - use a safer formalization of the system invariant, using a never claim. the simples formalization is: never { do :: assert(invariant) od } which checks the truth of the invariant for every reachable state, independent of timeouts. another way would be to use the implicit matching behavior of a never claim, without an explicit assertion: never { do :: (invariant) /* things are fine, the invariant holds */ :: !(invariant) -> break /* invariant fails - match */ od } CLARIFICATION, page 118, Section 6.5 ==================================== The validator SPIN does not enforce the second criterion for a proper endstate, i.e., the emptiness of all channels. It does enforce the revised first criterion from the bottom of page 118. TYPO, page 121 middle: ================================================= old< never { do :: skip od -> P -> !Q } new> never { do :: skip :: break od -> P -> !Q } ADDED EXPLANATIONS (throughout page 121 and onw.): ================================================= A terminating claim is matched, and the corresponding correctness property thereby violated, if and when the claim body terminates. A non-terminating claim is matched, and the corresponding correctness property violated, if and when an acceptance cycle is detected. SPECIFYING TEMPORAL CLAIMS The body of a temporal claim is defined just like PROMELA proctype bodies. This means that all control flow struc- tures, such as if-fi selections, do-od repetitions, and goto jumps, are allowed. There is, however, one important difference: Every statement inside a temporal claim is (interpreted as) a boolean condition. Specifically, this means that the statements inside temporal claims should be free of side-effects. For reference, the PROMELA statements with side-effects are: assignments, assertions, sends, receives, and printf statements. Temporal claims are used to express system behaviors that are considered undesirable or illegal. We say that a temporal claim is matched if the undesirable behavior can be realized, and thus our correctness claim can be violated. The most useful application of temporal claims is in combination with acceptance labels. There are then two ways to match a temporal claim, depending on whether the undesirable behavior defines terminating or cyclic execution sequences. For a terminating execution sequence, a temporal claim is matched only when it can terminate (reaches the closing curly brace) That is, the claim can be violated if the closing curly brace of the PROMELA body of the claim is reachable. For a cyclic execution sequence, the claim is matched only when an explicit acceptance cycle exists. The acceptance labels within temporal claims are user defined, there are no defaults. This means that in the absence of acceptance labels no cyclic behavior can be matched by a temporal claim. It also means that to check a cyclic temporal claim, acceptance labels should only occur within the claim and not elsewhere in the PROMELA code. ERROR, page 124, top ======================= old< :: len(receiver) == 0 new> :: skip /* allow any time delay */ ERROR, page 125, top ======================= the claim can of course always be violated (== matched), whether timeout is redefined or not. CHAPTER 7 ERROR, page 139, bottom ======================= old< Pr(Burst >= 17) = 0.08 . e ^ { -0.08 . 17 } = 0.007 new> Pr(Burst >= 17) = 0.009 . e ^ { -0.009 . 17 } = 0.007 ERROR, page 156, middle ======================= old< flow_to_dll[n]!sync_ack,0 new> flow_to_dll[n]!sync_ack,m (and move the new line up to precede: "m=0;") old< flow_to_ses[n]!sync_ack,0 new> flow_to_ses[n]!sync_ack,m old< To avoid circularity, the synchronization messages do not carry sequence numbers. new> The sync_ack message echos the session number of the sync message. ERROR, page 156, bottom ======================= old< || (0 || (0 q = last element from W; further down: ============= old< If states are stored in set W in first-in first-out order, the algorithm performs a breadth-first search of the state space tree. new> If states are stored in set W in first-in last-out (i.e., stack) order, the algorithm performs a depth-first search of the state space tree. further down: ============= old< If states are stored in first-in last-out (i.e., stack) < order, this changes into a depth-first search. new> If states are stored and removed in first-in first-out order, this changes into a breadth-first search (element q must be deleted upon retrieval from set W in this type of algorithm). Page 227, top ============= old< q = element from W; new> q = last element from W; Page 237, bottom ================ old< after removing states 4, 3, and 2 from the stack... new> after removing states 4, and 3 from the stack... CHAPTER 13 Page 315, 2nd para in 13.9 ========================== The first two sentences of this paragraph are incorrect. At the low end, just 1 state would be stored in the hash-array, taking up 2 bits of storage out of N available bits; at the high end, all N bits would be set at the end of the run, and (allowing overlaps) we cannot have seen more than N states. This leads to a possible range of values for the hash factor of N/2 >= hf >= 1 For full state space storage the hash factor is meaningless. CHAPTER 14 Page 331, lines 86, 88, and 94 ============================== See the corrections described for CHAPTER 7, page 156. APPENDIX C ============================== Page 387-388 The syntax of remote referencing has changed in SPIN Version 2.0. Remote referencing to local variables is no longer allowed (page 387, 5th line from below). The syntax for referencing the state of another process has changed from (page 388, 3rd line): same[2]:here to: same[2]@here /===================================================================\ | Final Erratum: | | | | This book is now replaced with the new, up to date description of | | the current version of Spin (per 9/2003): | | http://spinroot.com/spin/Doc/Book_extras/index.html | \===================================================================/ =end errata= Spin/Src6.4.5/0000775000175100017510000000000012641605047010700 5ustar ghghSpin/Src6.4.5/tl_lex.c0000664000175100017510000001246712641605057012346 0ustar ghgh/***** tl_spin: tl_lex.c *****/ /* * This file is part of the public release of Spin. It is subject to the * terms in the LICENSE file that is included in this source directory. * Tool documentation is available at http://spinroot.com * * Based on the translation algorithm by Gerth, Peled, Vardi, and Wolper, * presented at the PSTV Conference, held in 1995, Warsaw, Poland 1995. */ #include #include #include "tl.h" static Symbol *symtab[Nhash+1]; static int tl_lex(void); extern int tl_peek(int); extern YYSTYPE tl_yylval; extern char yytext[]; #define Token(y) tl_yylval = tl_nn(y,ZN,ZN); return y static void tl_getword(int first, int (*tst)(int)) { int i=0; int c; yytext[i++] = (char ) first; c = tl_Getchar(); while (c != -1 && tst(c)) { yytext[i++] = (char) c; c = tl_Getchar(); } /* while (tst(c = tl_Getchar())) * yytext[i++] = c; */ yytext[i] = '\0'; tl_UnGetchar(); } static int tl_follow(int tok, int ifyes, int ifno) { int c; char buf[32]; extern int tl_yychar; if ((c = tl_Getchar()) == tok) return ifyes; tl_UnGetchar(); tl_yychar = c; sprintf(buf, "expected '%c'", tok); tl_yyerror(buf); /* no return from here */ return ifno; } int tl_yylex(void) { int c = tl_lex(); #if 0 printf("c = %c (%d)\n", c, c); #endif return c; } static int is_predicate(int z) { char c, c_prev = z; char want = (z == '{') ? '}' : ')'; int i = 0, j, nesting = 0; char peek_buf[512]; c = tl_peek(i++); /* look ahead without changing position */ while ((c != want || nesting > 0) && c != -1 && i < 2047) { if (islower((int) c) || c == '_') { peek_buf[0] = c; j = 1; while (j < (int) sizeof(peek_buf) && (isalnum((int)(c = tl_peek(i))) || c == '_')) { peek_buf[j++] = c; i++; } c = 0; /* make sure we don't match on z or want on the peekahead */ if (j >= (int) sizeof(peek_buf)) { peek_buf[j-1] = '\0'; fatal("name '%s' in ltl formula too long", peek_buf); } peek_buf[j] = '\0'; if (strcmp(peek_buf, "always") == 0 || strcmp(peek_buf, "equivalent") == 0 || strcmp(peek_buf, "eventually") == 0 || strcmp(peek_buf, "until") == 0 || strcmp(peek_buf, "next") == 0 || strcmp(peek_buf, "c_expr") == 0) { return 0; } } else { int c_nxt = tl_peek(i); if (((c == 'U' || c == 'V' || c == 'X') && !isalnum_(c_prev) && (c_nxt == -1 || !isalnum_(c_nxt))) || (c == '<' && c_nxt == '>') || (c == '<' && c_nxt == '-') || (c == '-' && c_nxt == '>') || (c == '[' && c_nxt == ']')) { return 0; } } if (c == z) { nesting++; } if (c == want) { nesting--; } c_prev = c; c = tl_peek(i++); } return 1; } static void read_upto_closing(int z) { char c, want = (z == '{') ? '}' : ')'; int i = 0, nesting = 0; c = tl_Getchar(); while ((c != want || nesting > 0) && c != -1 && i < 2047) /* yytext is 2048 */ { yytext[i++] = c; if (c == z) { nesting++; } if (c == want) { nesting--; } c = tl_Getchar(); } yytext[i] = '\0'; } static int tl_lex(void) { int c; do { c = tl_Getchar(); yytext[0] = (char ) c; yytext[1] = '\0'; if (c <= 0) { Token(';'); } } while (c == ' '); /* '\t' is removed in tl_main.c */ if (c == '{' || c == '(') /* new 6.0.0 */ { if (is_predicate(c)) { read_upto_closing(c); tl_yylval = tl_nn(PREDICATE,ZN,ZN); if (!tl_yylval) { fatal("unexpected error 4", (char *) 0); } tl_yylval->sym = tl_lookup(yytext); return PREDICATE; } } if (c == '}') { tl_yyerror("unexpected '}'"); } if (islower(c)) { tl_getword(c, isalnum_); if (strcmp("true", yytext) == 0) { Token(TRUE); } if (strcmp("false", yytext) == 0) { Token(FALSE); } if (strcmp("always", yytext) == 0) { Token(ALWAYS); } if (strcmp("eventually", yytext) == 0) { Token(EVENTUALLY); } if (strcmp("until", yytext) == 0) { Token(U_OPER); } #ifdef NXT if (strcmp("next", yytext) == 0) { Token(NEXT); } #endif if (strcmp("c_expr", yytext) == 0) { Token(CEXPR); } if (strcmp("not", yytext) == 0) { Token(NOT); } tl_yylval = tl_nn(PREDICATE,ZN,ZN); if (!tl_yylval) { fatal("unexpected error 5", (char *) 0); } tl_yylval->sym = tl_lookup(yytext); return PREDICATE; } if (c == '<') { c = tl_Getchar(); if (c == '>') { Token(EVENTUALLY); } if (c != '-') { tl_UnGetchar(); tl_yyerror("expected '<>' or '<->'"); } c = tl_Getchar(); if (c == '>') { Token(EQUIV); } tl_UnGetchar(); tl_yyerror("expected '<->'"); } switch (c) { case '/' : c = tl_follow('\\', AND, '/'); break; case '\\': c = tl_follow('/', OR, '\\'); break; case '&' : c = tl_follow('&', AND, '&'); break; case '|' : c = tl_follow('|', OR, '|'); break; case '[' : c = tl_follow(']', ALWAYS, '['); break; case '-' : c = tl_follow('>', IMPLIES, '-'); break; case '!' : c = NOT; break; case 'U' : c = U_OPER; break; case 'V' : c = V_OPER; break; #ifdef NXT case 'X' : c = NEXT; break; #endif default : break; } Token(c); } Symbol * tl_lookup(char *s) { Symbol *sp; int h = hash(s); for (sp = symtab[h]; sp; sp = sp->next) if (strcmp(sp->name, s) == 0) return sp; sp = (Symbol *) tl_emalloc(sizeof(Symbol)); sp->name = (char *) tl_emalloc((int) strlen(s) + 1); strcpy(sp->name, s); sp->next = symtab[h]; symtab[h] = sp; return sp; } Symbol * getsym(Symbol *s) { Symbol *n = (Symbol *) tl_emalloc(sizeof(Symbol)); n->name = s->name; return n; } Spin/Src6.4.5/pangen5.h0000664000175100017510000002500112641605057012405 0ustar ghgh/***** spin: pangen5.h *****/ /* * This file is part of the public release of Spin. It is subject to the * terms in the LICENSE file that is included in this source directory. * Tool documentation is available at http://spinroot.com */ static const char *Xpt[] = { "#if defined(MA) && (defined(W_XPT) || defined(R_XPT))", "static Vertex **temptree;", "static char wbuf[4096];", "static int WCNT = 4096, wcnt=0;", "static uchar stacker[MA+1];", "static ulong stackcnt = 0;", "extern double nstates, nlinks, truncs, truncs2;", "", "static void", "xwrite(int fd, char *b, int n)", "{", " if (wcnt+n >= 4096)", " { write(fd, wbuf, wcnt);", " wcnt = 0;", " }", " memcpy(&wbuf[wcnt], b, n);", " wcnt += n;", "}", "", "static void", "wclose(fd)", "{", " if (wcnt > 0)", " write(fd, wbuf, wcnt);", " wcnt = 0;", " close(fd);", "}", "", "static void", "w_vertex(int fd, Vertex *v)", "{ char t[3]; int i; Edge *e;", "", " xwrite(fd, (char *) &v, sizeof(Vertex *));", " t[0] = 0;", " for (i = 0; i < 2; i++)", " if (v->dst[i])", " { t[1] = v->from[i], t[2] = v->to[i];", " xwrite(fd, t, 3);", " xwrite(fd, (char *) &(v->dst[i]), sizeof(Vertex *));", " }", " for (e = v->Succ; e; e = e->Nxt)", " { t[1] = e->From, t[2] = e->To;", " xwrite(fd, t, 3);", " xwrite(fd, (char *) &(e->Dst), sizeof(Vertex *));", "", " if (e->s)", " { t[1] = t[2] = e->S;", " xwrite(fd, t, 3);", " xwrite(fd, (char *) &(e->Dst), sizeof(Vertex *));", " } }", "}", "", "static void", "w_layer(int fd, Vertex *v)", "{ uchar c=1;", "", " if (!v) return;", " xwrite(fd, (char *) &c, 1);", " w_vertex(fd, v);", " w_layer(fd, v->lnk);", " w_layer(fd, v->left);", " w_layer(fd, v->right);", "}", "", "void", "w_xpoint(void)", "{ int fd; char nm[64];", " int i, j; uchar c;", " static uchar xwarned = 0;", "", " sprintf(nm, \"%%s.xpt\", PanSource);", " if ((fd = creat(nm, 0666)) <= 0)", " if (!xwarned)", " { xwarned = 1;", " printf(\"cannot creat checkpoint file\\n\");", " return;", " }", " xwrite(fd, (char *) &nstates, sizeof(double));", " xwrite(fd, (char *) &truncs, sizeof(double));", " xwrite(fd, (char *) &truncs2, sizeof(double));", " xwrite(fd, (char *) &nlinks, sizeof(double));", " xwrite(fd, (char *) &dfa_depth, sizeof(int));", " xwrite(fd, (char *) &R, sizeof(Vertex *));", " xwrite(fd, (char *) &F, sizeof(Vertex *));", " xwrite(fd, (char *) &NF, sizeof(Vertex *));", "", " for (j = 0; j < TWIDTH; j++)", " for (i = 0; i < dfa_depth+1; i++)", " { w_layer(fd, layers[i*TWIDTH+j]);", " c = 2; xwrite(fd, (char *) &c, 1);", " }", " wclose(fd);", "}", "", "static void", "xread(int fd, char *b, int n)", "{ int m = wcnt; int delta = 0;", " if (m < n)", " { if (m > 0) memcpy(b, &wbuf[WCNT-m], m);", " delta = m;", " WCNT = wcnt = read(fd, wbuf, 4096);", " if (wcnt < n-m)", " Uerror(\"xread failed -- insufficient data\");", " n -= m;", " }", " memcpy(&b[delta], &wbuf[WCNT-wcnt], n);", " wcnt -= n;", "}", "", "static void", "x_cleanup(Vertex *c)", "{ Edge *e; /* remove the tree and edges from c */", " if (!c) return;", " for (e = c->Succ; e; e = e->Nxt)", " x_cleanup(e->Dst);", " recyc_vertex(c);", "}", "", "static void", "x_remove(void)", "{ Vertex *tmp; int i, s;", " int r, j;", " /* double-check: */", " stacker[dfa_depth-1] = 0; r = dfa_store(stacker);", " stacker[dfa_depth-1] = 4; j = dfa_member(dfa_depth-1);", " if (r != 1 || j != 0)", " { printf(\"%%lu: \", stackcnt);", " for (i = 0; i < dfa_depth; i++)", " printf(\"%%d,\", stacker[i]);", " printf(\" -- not a stackstate \\n\", r, j);", " return;", " }", " stacker[dfa_depth-1] = 1;", " s = dfa_member(dfa_depth-1);", "", " { tmp = F; F = NF; NF = tmp; } /* complement */", " if (s) dfa_store(stacker);", " stacker[dfa_depth-1] = 0;", " dfa_store(stacker);", " stackcnt++;", " { tmp = F; F = NF; NF = tmp; }", "}", "", "static void", "x_rm_stack(Vertex *t, int k)", "{ int j; Edge *e;", "", " if (k == 0)", " { x_remove();", " return;", " }", " if (t)", " for (e = t->Succ; e; e = e->Nxt)", " { for (j = e->From; j <= (int) e->To; j++)", " { stacker[k] = (uchar) j;", " x_rm_stack(e->Dst, k-1);", " }", " if (e->s)", " { stacker[k] = e->S;", " x_rm_stack(e->Dst, k-1);", " } }", "}", "", "static Vertex *", "insert_withkey(Vertex *v, int L)", "{ Vertex *new, *t = temptree[L];", "", " if (!t) { temptree[L] = v; return v; }", " t = splay(v->key, t);", " if (v->key < t->key)", " { new = v;", " new->left = t->left;", " new->right = t;", " t->left = (Vertex *) 0;", " } else if (v->key > t->key)", " { new = v;", " new->right = t->right;", " new->left = t;", " t->right = (Vertex *) 0;", " } else", " { if (t != R && t != F && t != NF)", " Uerror(\"double insert, bad checkpoint data\");", " else", " { recyc_vertex(v);", " new = t;", " } }", " temptree[L] = new;", "", " return new;", "}", "", "static Vertex *", "find_withkey(Vertex *v, int L)", "{ Vertex *t = temptree[L];", " if (t)", " { temptree[L] = t = splay((ulong) v, t);", " if (t->key == (ulong) v)", " return t;", " }", " Uerror(\"not found error, bad checkpoint data\");", " return (Vertex *) 0;", "}", "", "void", "r_layer(int fd, int n)", "{ Vertex *v;", " Edge *e;", " char c, t[2];", "", " for (;;)", " { xread(fd, &c, 1);", " if (c == 2) break;", " if (c == 1)", " { v = new_vertex();", " xread(fd, (char *) &(v->key), sizeof(Vertex *));", " v = insert_withkey(v, n);", " } else /* c == 0 */", " { e = new_edge((Vertex *) 0);", " xread(fd, t, 2);", " e->From = t[0];", " e->To = t[1];", " xread(fd, (char *) &(e->Dst), sizeof(Vertex *));", " insert_edge(v, e);", " } }", "}", "", "static void", "v_fix(Vertex *t, int nr)", "{ int i; Edge *e;", "", " if (!t) return;", "", " for (i = 0; i < 2; i++)", " if (t->dst[i])", " t->dst[i] = find_withkey(t->dst[i], nr);", "", " for (e = t->Succ; e; e = e->Nxt)", " e->Dst = find_withkey(e->Dst, nr);", " ", " v_fix(t->left, nr);", " v_fix(t->right, nr);", "}", "", "static void", "v_insert(Vertex *t, int nr)", "{ Edge *e; int i;", "", " if (!t) return;", " v_insert(t->left, nr);", " v_insert(t->right, nr);", "", " /* remove only leafs from temptree */", " t->left = t->right = t->lnk = (Vertex *) 0;", " insert_it(t, nr); /* into layers */", " for (i = 0; i < 2; i++)", " if (t->dst[i])", " t->dst[i]->num += (t->to[i] - t->from[i] + 1);", " for (e = t->Succ; e; e = e->Nxt)", " e->Dst->num += (e->To - e->From + 1 + e->s);", "}", "", "static void", "x_fixup(void)", "{ int i;", "", " for (i = 0; i < dfa_depth; i++)", " v_fix(temptree[i], (i+1));", "", " for (i = dfa_depth; i >= 0; i--)", " v_insert(temptree[i], i);", "}", "", "static Vertex *", "x_tail(Vertex *t, ulong want)", "{ int i, yes, no; Edge *e; Vertex *v = (Vertex *) 0;", "", " if (!t) return v;", "", " yes = no = 0;", " for (i = 0; i < 2; i++)", " if ((ulong) t->dst[i] == want)", " { /* was t->from[i] <= 0 && t->to[i] >= 0 */", " /* but from and to are uchar */", " if (t->from[i] == 0)", " yes = 1;", " else", " if (t->from[i] <= 4 && t->to[i] >= 4)", " no = 1;", " }", "", " for (e = t->Succ; e; e = e->Nxt)", " if ((ulong) e->Dst == want)", " { /* was INRANGE(e,0) but From and To are uchar */", " if ((e->From == 0) || (e->s==1 && e->S==0))", " yes = 1;", " else if (INRANGE(e, 4))", " no = 1;", " }", " if (yes && !no) return t;", " v = x_tail(t->left, want); if (v) return v;", " v = x_tail(t->right, want); if (v) return v;", " return (Vertex *) 0;", "}", "", "static void", "x_anytail(Vertex *t, Vertex *c, int nr)", "{ int i; Edge *e, *f; Vertex *v;", "", " if (!t) return;", "", " for (i = 0; i < 2; i++)", " if ((ulong) t->dst[i] == c->key)", " { v = new_vertex(); v->key = t->key;", " f = new_edge(v);", " f->From = t->from[i];", " f->To = t->to[i];", " f->Nxt = c->Succ;", " c->Succ = f;", " if (nr > 0)", " x_anytail(temptree[nr-1], v, nr-1);", " }", "", " for (e = t->Succ; e; e = e->Nxt)", " if ((ulong) e->Dst == c->key)", " { v = new_vertex(); v->key = t->key;", " f = new_edge(v);", " f->From = e->From;", " f->To = e->To;", " f->s = e->s;", " f->S = e->S;", " f->Nxt = c->Succ;", " c->Succ = f;", " x_anytail(temptree[nr-1], v, nr-1);", " }", "", " x_anytail(t->left, c, nr);", " x_anytail(t->right, c, nr);", "}", "", "static Vertex *", "x_cpy_rev(void)", "{ Vertex *c, *v; /* find 0 and !4 predecessor of F */", "", " v = x_tail(temptree[dfa_depth-1], F->key);", " if (!v) return (Vertex *) 0;", "", " c = new_vertex(); c->key = v->key;", "", " /* every node on dfa_depth-2 that has v->key as succ */", " /* make copy and let c point to these (reversing ptrs) */", "", " x_anytail(temptree[dfa_depth-2], c, dfa_depth-2);", " ", " return c;", "}", "", "void", "r_xpoint(void)", "{ int fd; char nm[64]; Vertex *d;", " int i, j;", "", " wcnt = 0;", " sprintf(nm, \"%%s.xpt\", PanSource);", " if ((fd = open(nm, 0)) < 0) /* O_RDONLY */", " Uerror(\"cannot open checkpoint file\");", "", " xread(fd, (char *) &nstates, sizeof(double));", " xread(fd, (char *) &truncs, sizeof(double));", " xread(fd, (char *) &truncs2, sizeof(double));", " xread(fd, (char *) &nlinks, sizeof(double));", " xread(fd, (char *) &dfa_depth, sizeof(int));", "", " if (dfa_depth != MA+a_cycles)", " Uerror(\"bad dfa_depth in checkpoint file\");", "", " path = (Vertex **) emalloc((dfa_depth+1)*sizeof(Vertex *));", " layers = (Vertex **) emalloc(TWIDTH*(dfa_depth+1)*sizeof(Vertex *));", " temptree = (Vertex **) emalloc((dfa_depth+2)*sizeof(Vertex *));", " lastword = (uchar *) emalloc((dfa_depth+1)*sizeof(uchar));", " lastword[dfa_depth] = lastword[0] = 255; ", "", " path[0] = R = new_vertex();", " xread(fd, (char *) &R->key, sizeof(Vertex *));", " R = insert_withkey(R, 0);", "", " F = new_vertex();", " xread(fd, (char *) &F->key, sizeof(Vertex *));", " F = insert_withkey(F, dfa_depth);", "", " NF = new_vertex();", " xread(fd, (char *) &NF->key, sizeof(Vertex *));", " NF = insert_withkey(NF, dfa_depth);", "", " for (j = 0; j < TWIDTH; j++)", " for (i = 0; i < dfa_depth+1; i++)", " r_layer(fd, i);", "", " if (wcnt != 0) Uerror(\"bad count in checkpoint file\");", "", " d = x_cpy_rev();", " x_fixup();", " stacker[dfa_depth-1] = 0;", " x_rm_stack(d, dfa_depth-2);", " x_cleanup(d);", " close(fd);", "", " printf(\"pan: removed %%lu stackstates\\n\", stackcnt);", " nstates -= (double) stackcnt;", "}", "#endif", 0, }; Spin/Src6.4.5/makefile0000664000175100017510000000334312641605057012404 0ustar ghgh# SPIN - Verification Software - Version 6.4 - January 2016 # # This file is part of the public release of Spin. It is subject to the # terms in the LICENSE file that is included in this source directory. # Tool documentation is available at http://spinroot.com # # see also ./make_pc for a simpler script not requiring make # for 32-bit compilation, use ./make32 CC=gcc CFLAGS=-O2 -DNXT # on some systems add: -I/usr/include # on a PC: add -DPC # on Solaris: add -DSOLARIS # on a Mac: add -DMAC # on HP-UX: add -Aa # CFLAGS=-pg -g -DNXT # for a more picky compilation use gcc-4 and add: PICKY=-std=c99 -Wstrict-prototypes -pedantic -fno-strength-reduce \ -fno-builtin -W -Wshadow -Wpointer-arith \ -Wcast-qual -Winline -Wall # when running spin with a different compiler: # on OS2: spin -Picc -E/Pd+ -E/Q+ # for Visual C++: spin -PCL -E/E YACC=yacc # on Solaris: /usr/ccs/bin/yacc YFLAGS=-v -d # creates y.output and y.tab.h SPIN_OS= spinlex.o sym.o vars.o main.o msc_tcl.o \ mesg.o flow.o sched.o run.o pangen1.o pangen2.o \ pangen3.o pangen4.o pangen5.o guided.o dstep.o \ structs.o pangen6.o pangen7.o reprosrc.o TL_OS= tl_parse.o tl_lex.o tl_main.o tl_trans.o tl_buchi.o \ tl_mem.o tl_rewrt.o tl_cache.o spin: $(SPIN_OS) $(TL_OS) spin.o $(CC) $(CFLAGS) -o spin spin.o $(SPIN_OS) $(TL_OS) install: spin cp spin /usr/local/bin spin.o: spin.y $(YACC) $(YFLAGS) spin.y $(CC) $(CFLAGS) -c y?tab.c rm -f y?tab.c mv y?tab.o spin.o $(SPIN_OS): spin.h spin.o $(TL_OS): tl.h spin.o main.o pangen2.o msc_tcl.o: version.h pangen1.o: pangen1.h pangen3.h pangen6.h pangen2.o: pangen2.h pangen4.h pangen5.h pangen7.h clean: rm -f spin *.o y?tab.[ch] y.output y.debug rm -f pan.[chmotb] a.out core *stackdump Spin/Src6.4.5/msc_tcl.c0000664000175100017510000002244412641605057012477 0ustar ghgh/***** spin: msc_tcl.c *****/ /* * This file is part of the public release of Spin. It is subject to the * terms in the LICENSE file that is included in this source directory. * Tool documentation is available at http://spinroot.com */ #include #include "spin.h" #include "version.h" #define MW 500 /* page width */ #define RH 100 /* right margin */ #define WW 80 /* distance between process lines */ #define HH 12 /* vertical distance between steps */ #define LW 2 /* line width of message arrows */ #define RVC "darkred" /* rendezvous arrows */ #define MPC "darkblue" /* asynchronous message passing arrow */ #define GRC "lightgrey" /* grid lines */ static int MH = 600; /* anticipated page-length */ static FILE *pfd; static char **I; /* initial procs */ static int *D,*R; /* maps between depth (stepnr) and ldepth (msc-step) */ static short *M; /* x location of each box at index y */ static short *T; /* y index of match for each box at index y */ static char **L; /* text labels */ static int ProcLine[256]; /* active processes */ static int UsedLine[256]; /* process line has at least one entry */ static int ldepth = 1; static int maxx, TotSteps = 2*4096; /* max nr of steps for simulation output */ static float Scaler = (float) 1.0; static int xscale = 2; static int yscale = 1; static int no_box; extern int ntrail, s_trail, pno, depth; extern Symbol *oFname; extern void exit(int); extern void putpostlude(void); static void putpages(void); static void psline(int x0, int y0, int x1, int y1, char *color) { char *side = "last"; if (x0 == x1) /* gridline */ { fprintf(pfd, ".c create line %d %d %d %d -fill %s -tags grid -width 1 \n", xscale*(x0+1)*WW-20, yscale*y0+20, xscale*(x1+1)*WW-20, yscale*y1+20, color); fprintf(pfd, ".c lower grid\n"); } else { int xm = xscale*(x0+1)*WW + (xscale*(x1 - x0)*WW)/2 - 20; /* mid x */ if (y1 - y0 <= HH+20) { y1 = y0+20; /* close enough to horizontal - looks better */ } fprintf(pfd, ".c create line %d %d %d %d -fill %s -tags mesg -width %d\n", xscale*(x0+1)*WW-20, yscale*y0+20+10, xm, yscale*y0+20+10, color, LW); if (y1 != y0+20) { fprintf(pfd, ".c create line %d %d %d %d -fill %s -tags mesg -width %d\n", xm, yscale*y0+20+10, xm, yscale*y1+20-10, color, LW); } fprintf(pfd, ".c create line %d %d %d %d -fill %s -width %d ", xm, yscale*y1+20-10, xscale*(x1+1)*WW-20, yscale*y1+20-10, color, LW); if (strcmp(color, RVC) == 0) { side = "both"; } fprintf(pfd, "-arrow %s -arrowshape {5 5 5} -tags mesg\n", side); fprintf(pfd, ".c raise mesg\n"); } } static void colbox(int ix, int iy, int w, int h_unused, char *color) { int x = ix*WW; int y = iy*HH; if (ix < 0 || ix > 255) { fatal("msc_tcl: unexpected\n", (char *) 0); } if (ProcLine[ix] < iy) { /* if (ProcLine[ix] > 0) */ { psline(ix-1, ProcLine[ix]*HH+HH+4, ix-1, iy*HH-HH, GRC); } fprintf(pfd, "# ProcLine[%d] from %d to %d (Used %d nobox %d)\n", ix, ProcLine[ix], iy, UsedLine[ix], no_box); ProcLine[ix] = iy; } else { fprintf(pfd, "# ProcLine[%d] stays at %d (Used %d nobox %d)\n", ix, ProcLine[ix], UsedLine[ix], no_box); } if (UsedLine[ix]) { no_box = 2; } if (strcmp(color, "black") == 0) { if (no_box == 0) /* shadow */ { fprintf(pfd, ".c create rectangle %d %d %d %d -fill black\n", xscale*x-(xscale*4*w/3)-20+4, (yscale*y-10)+20+2, xscale*x+(xscale*4*w/3)-20, (yscale*y+10)+20+2); } } else { if (no_box == 0) /* box with outline */ { fprintf(pfd, ".c create rectangle %d %d %d %d -fill ivory\n", xscale*x-(xscale*4*w/3)-20, (yscale*y-10)+20, xscale*x+(xscale*4*w/3)-20, (yscale*y+10)+20); UsedLine[ix]++; } else /* no outline */ { fprintf(pfd, ".c create rectangle %d %d %d %d -fill white -width 0\n", xscale*x-(xscale*4*w/3)-20, (yscale*y-10)+20, xscale*x+(xscale*4*w/3)-20, (yscale*y+10)+20); } } if (no_box > 0) { no_box--; } } static void stepnumber(int i) { int y = (yscale*i*HH) + 20; fprintf(pfd, ".c create text %d %d -fill #eef -text \"%d\"\n", -10+(xscale*WW)/2, y, i); /* horizontal dashed grid line */ fprintf(pfd, ".c create line %d %d %d %d -fill #eef -dash {6 4}\n", -20+WW*xscale, y, (maxx+1)*WW*xscale-20, y); } static void spitbox(int ix, int y, char *s) { float bw; /* box width */ char d[256], *t, *z; int a, i, x = ix+1; char *color = "black"; if (y > 0) { stepnumber(y); } bw = (float)1.8*(float)strlen(s); /* guess at default font width */ colbox(x, y, (int) (bw+1.0), 5, "black"); if (s[0] == '~') { switch (s[1]) { default : case 'R': color = "red"; break; case 'B': color = "blue"; break; case 'G': color = "green"; break; } s += 2; } else if (strchr(s, '!')) { color = "ivory"; } else if (strchr(s, '?')) { color = "azure"; } else { color = "pink"; if (sscanf(s, "%d:%250s", &a, d) == 2 && a >= 0 && a < TotSteps) { if (!I[a] || strlen(I[a]) <= strlen(s)) { I[a] = (char *) emalloc((int) strlen(s)+1); } strcpy(I[a], s); } } colbox(x, y, (int) bw, 4, color); z = t = (char *) emalloc(2*strlen(s)+1); for (i = 0; i < (int) strlen(s); i++) { if (s[i] == '\n') { continue; } if (s[i] == '[' || s[i] == ']') { *t++ = '\\'; } *t++ = s[i]; } fprintf(pfd, ".c create text %d %d -text \"%s\"\n", xscale*x*WW-20, yscale*y*HH+20, z); } static void putpages(void) { int i, lasti=0; float nmh; if (maxx*xscale*WW > MW-RH/2) { Scaler = (float) (MW-RH/2) / (float) (maxx*xscale*WW); nmh = (float) MH; nmh /= Scaler; MH = (int) nmh; fprintf(pfd, "# Scaler %f, MH %d\n", Scaler, MH); } if (ldepth >= TotSteps) { ldepth = TotSteps-1; } /* W: (maxx+2)*xscale*WW */ /* H: ldepth*HH*yscale+50 */ fprintf(pfd, "wm title . \"scenario\"\n"); fprintf(pfd, "wm geometry . %dx600+650+100\n", (maxx+2)*xscale*WW); fprintf(pfd, "canvas .c -width 800 -height 800 \\\n"); fprintf(pfd, " -scrollregion {0c -1c 30c 100c} \\\n"); fprintf(pfd, " -xscrollcommand \".hscroll set\" \\\n"); fprintf(pfd, " -yscrollcommand \".vscroll set\" \\\n"); fprintf(pfd, " -bg white -relief raised -bd 2\n"); fprintf(pfd, "scrollbar .vscroll -relief sunken "); fprintf(pfd, " -command \".c yview\"\n"); fprintf(pfd, "scrollbar .hscroll -relief sunken -orient horiz "); fprintf(pfd, " -command \".c xview\"\n"); fprintf(pfd, "pack append . \\\n"); fprintf(pfd, " .vscroll {right filly} \\\n"); fprintf(pfd, " .hscroll {bottom fillx} \\\n"); fprintf(pfd, " .c {top expand fill}\n"); fprintf(pfd, ".c yview moveto 0\n"); for (i = TotSteps-1; i >= 0; i--) { if (I[i]) { spitbox(i, -1, I[i]); } } for (i = 0; i <= ldepth; i++) { if (!M[i] && !L[i]) { continue; /* no box */ } if (T[i] > 0) /* arrow */ { if (T[i] == i) /* rv handshake */ { psline( M[lasti], lasti*HH, M[i], i*HH, RVC); } else { psline( M[i], i*HH, M[T[i]], T[i]*HH, MPC); } } if (L[i]) { spitbox(M[i], i, L[i]); lasti = i; } } } static void putbox(int x) { if (ldepth >= TotSteps) { fprintf(stderr, "max length of %d steps exceeded - ps file truncated\n", TotSteps); putpostlude(); } M[ldepth] = x; if (x > maxx) { maxx = x; fprintf(pfd, "# maxx %d\n", x); } } /* functions called externally: */ extern int WhatSeed(void); void putpostlude(void) { char cmd[512]; putpages(); fprintf(pfd, ".c lower grid\n"); fprintf(pfd, ".c raise mesg\n"); fclose(pfd); fprintf(stderr, "seed used: -n%d\n", WhatSeed()); sprintf(cmd, "wish -f %s.tcl &", oFname?oFname->name:"msc"); fprintf(stderr, "%s\n", cmd); (void) unlink("pan.pre"); exit (system(cmd)); } void putprelude(void) { char snap[256]; FILE *fd; sprintf(snap, "%s.tcl", oFname?oFname->name:"msc"); if (!(pfd = fopen(snap, MFLAGS))) { fatal("cannot create file '%s'", snap); } if (s_trail) { if (ntrail) sprintf(snap, "%s%d.trail", oFname?oFname->name:"msc", ntrail); else sprintf(snap, "%s.trail", oFname?oFname->name:"msc"); if (!(fd = fopen(snap, "r"))) { snap[strlen(snap)-2] = '\0'; if (!(fd = fopen(snap, "r"))) fatal("cannot open trail file", (char *) 0); } TotSteps = 1; while (fgets(snap, 256, fd)) TotSteps++; fclose(fd); } TotSteps *= 2; R = (int *) emalloc(TotSteps * sizeof(int)); D = (int *) emalloc(TotSteps * sizeof(int)); M = (short *) emalloc(TotSteps * sizeof(short)); T = (short *) emalloc(TotSteps * sizeof(short)); L = (char **) emalloc(TotSteps * sizeof(char *)); I = (char **) emalloc(TotSteps * sizeof(char *)); } void putarrow(int from, int to) { /* from rv if from == to */ /* which means that D[from] == D[to] */ /* which means that T[x] == x */ if (from < TotSteps && to < TotSteps && D[from] < TotSteps) { T[D[from]] = D[to]; } } void pstext(int x, char *s) { char *tmp = emalloc((int) strlen(s)+1); strcpy(tmp, s); if (depth == 0) { I[x] = tmp; } else { if (depth >= TotSteps || ldepth >= TotSteps) { fprintf(stderr, "spin: error: max nr of %d steps exceeded\n", TotSteps); fatal("use -uN to limit steps", (char *) 0); } putbox(x); D[depth] = ldepth; R[ldepth] = depth; L[ldepth] = tmp; ldepth += 2; } } void dotag(FILE *fd, char *s) { extern int columns, notabs; extern RunList *X; int i = (!strncmp(s, "MSC: ", 5))?5:0; int pid = s_trail ? pno : (X?X->pid:0); if (columns == 2) { pstext(pid, &s[i]); } else { if (!notabs) { printf(" "); for (i = 0; i <= pid; i++) { printf(" "); } } fprintf(fd, "%s", s); fflush(fd); } } Spin/Src6.4.5/LICENSE0000664000175100017510000000401312641605057011704 0ustar ghgh Spin open source distribution ============================= Copyright (c) 1989-2016 Gerard J. Holzmann. All rights reserved. This software was originally authored by employees of Bell Laboratories, a unit of Lucent Technologies, Inc. All Alcatel-Lucent copyrights in the software were assigned to Gerard J. Holzmann on 30 December 2015, and thus no rights are herein granted by Lucent Technologies itself, or by its successor Alcatel-Lucent. This and subsequent versions of the Spin source code are made available as open source code under the terms of the BSD 3-Clause License: Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. Spin/Src6.4.5/pangen5.c0000664000175100017510000004137712641605057012416 0ustar ghgh/***** spin: pangen5.c *****/ /* * This file is part of the public release of Spin. It is subject to the * terms in the LICENSE file that is included in this source directory. * Tool documentation is available at http://spinroot.com */ #include "spin.h" #include "y.tab.h" typedef struct BuildStack { FSM_trans *t; struct BuildStack *nxt; } BuildStack; extern ProcList *rdy; extern int verbose, eventmapnr, claimnr, rvopt, export_ast, u_sync; extern Element *Al_El; static FSM_state *fsm_free; static FSM_trans *trans_free; static BuildStack *bs, *bf; static int max_st_id; static int cur_st_id; int o_max; FSM_state *fsm; FSM_state **fsm_tbl; FSM_use *use_free; static void ana_seq(Sequence *); static void ana_stmnt(FSM_trans *, Lextok *, int); extern void AST_slice(void); extern void AST_store(ProcList *, int); extern int has_global(Lextok *); extern void exit(int); static void fsm_table(void) { FSM_state *f; max_st_id += 2; /* fprintf(stderr, "omax %d, max=%d\n", o_max, max_st_id); */ if (o_max < max_st_id) { o_max = max_st_id; fsm_tbl = (FSM_state **) emalloc(max_st_id * sizeof(FSM_state *)); } else memset((char *)fsm_tbl, 0, max_st_id * sizeof(FSM_state *)); cur_st_id = max_st_id; max_st_id = 0; for (f = fsm; f; f = f->nxt) fsm_tbl[f->from] = f; } static int FSM_DFS(int from, FSM_use *u) { FSM_state *f; FSM_trans *t; FSM_use *v; int n; if (from == 0) return 1; f = fsm_tbl[from]; if (!f) { printf("cannot find state %d\n", from); fatal("fsm_dfs: cannot happen\n", (char *) 0); } if (f->seen) return 1; f->seen = 1; for (t = f->t; t; t = t->nxt) { for (n = 0; n < 2; n++) for (v = t->Val[n]; v; v = v->nxt) if (u->var == v->var) return n; /* a read or write */ if (!FSM_DFS(t->to, u)) return 0; } return 1; } static void new_dfs(void) { int i; for (i = 0; i < cur_st_id; i++) if (fsm_tbl[i]) fsm_tbl[i]->seen = 0; } static int good_dead(Element *e, FSM_use *u) { switch (u->special) { case 2: /* ok if it's a receive */ if (e->n->ntyp == ASGN && e->n->rgt->ntyp == CONST && e->n->rgt->val == 0) return 0; break; case 1: /* must be able to use oval */ if (e->n->ntyp != 'c' && e->n->ntyp != 'r') return 0; /* can't really happen */ break; } return 1; } #if 0 static int howdeep = 0; #endif static int eligible(FSM_trans *v) { Element *el = ZE; Lextok *lt = ZN; if (v) el = v->step; if (el) lt = v->step->n; if (!lt /* dead end */ || v->nxt /* has alternatives */ || el->esc /* has an escape */ || (el->status&CHECK2) /* remotely referenced */ || lt->ntyp == ATOMIC || lt->ntyp == NON_ATOMIC /* used for inlines -- should be able to handle this */ || lt->ntyp == IF || lt->ntyp == C_CODE || lt->ntyp == C_EXPR || has_lab(el, 0) /* any label at all */ || lt->ntyp == SET_P /* to prevent multiple set_p merges */ || lt->ntyp == DO || lt->ntyp == UNLESS || lt->ntyp == D_STEP || lt->ntyp == ELSE || lt->ntyp == '@' || lt->ntyp == 'c' || lt->ntyp == 'r' || lt->ntyp == 's') return 0; if (!(el->status&(2|4))) /* not atomic */ { int unsafe = (el->status&I_GLOB)?1:has_global(el->n); if (unsafe) return 0; } return 1; } static int canfill_in(FSM_trans *v) { Element *el = v->step; Lextok *lt = v->step->n; if (!lt /* dead end */ || v->nxt /* has alternatives */ || el->esc /* has an escape */ || (el->status&CHECK2)) /* remotely referenced */ return 0; if (!(el->status&(2|4)) /* not atomic */ && ((el->status&I_GLOB) || has_global(el->n))) /* and not safe */ return 0; return 1; } static int pushbuild(FSM_trans *v) { BuildStack *b; for (b = bs; b; b = b->nxt) if (b->t == v) return 0; if (bf) { b = bf; bf = bf->nxt; } else b = (BuildStack *) emalloc(sizeof(BuildStack)); b->t = v; b->nxt = bs; bs = b; return 1; } static void popbuild(void) { BuildStack *f; if (!bs) fatal("cannot happen, popbuild", (char *) 0); f = bs; bs = bs->nxt; f->nxt = bf; bf = f; /* freelist */ } static int build_step(FSM_trans *v) { FSM_state *f; Element *el; #if 0 Lextok *lt = ZN; #endif int st; int r; if (!v) return -1; el = v->step; st = v->to; if (!el) return -1; if (v->step->merge) return v->step->merge; /* already done */ if (!eligible(v)) /* non-blocking */ return -1; if (!pushbuild(v)) /* cycle detected */ return -1; /* break cycle */ f = fsm_tbl[st]; #if 0 lt = v->step->n; if (verbose&32) { if (++howdeep == 1) printf("spin: %s:%d, merge:\n", lt->fn->name, lt->ln); printf("\t[%d] \t", howdeep, el->seqno); comment(stdout, lt, 0); printf(";\n"); } #endif r = build_step(f->t); v->step->merge = (r == -1) ? st : r; #if 0 if (verbose&32) { printf(" merge value: %d (st=%d,r=%d, line %d)\n", v->step->merge, st, r, el->n->ln); howdeep--; } #endif popbuild(); return v->step->merge; } static void FSM_MERGER(/* char *pname */ void) /* find candidates for safely merging steps */ { FSM_state *f, *g; FSM_trans *t; Lextok *lt; for (f = fsm; f; f = f->nxt) /* all states */ for (t = f->t; t; t = t->nxt) /* all edges */ { if (!t->step) continue; /* happens with 'unless' */ t->step->merge_in = f->in; /* ?? */ if (t->step->merge) continue; lt = t->step->n; if (lt->ntyp == 'c' || lt->ntyp == 'r' || lt->ntyp == 's') /* blocking stmnts */ continue; /* handled in 2nd scan */ if (!eligible(t)) continue; g = fsm_tbl[t->to]; if (!g || !eligible(g->t)) { #define SINGLES #ifdef SINGLES t->step->merge_single = t->to; #if 0 if ((verbose&32)) { printf("spin: %s:%d, merge_single:\n\t\t", t->step->n->fn->name, t->step->n->ln, t->step->seqno); comment(stdout, t->step->n, 0); printf(";\n"); } #endif #endif /* t is an isolated eligible step: * * a merge_start can connect to a proper * merge chain or to a merge_single * a merge chain can be preceded by * a merge_start, but not by a merge_single */ continue; } (void) build_step(t); } /* 2nd scan -- find possible merge_starts */ for (f = fsm; f; f = f->nxt) /* all states */ for (t = f->t; t; t = t->nxt) /* all edges */ { if (!t->step || t->step->merge) continue; lt = t->step->n; #if 0 4.1.3: an rv send operation ('s') inside an atomic, *loses* atomicity when executed, and should therefore never be merged with a subsequent statement within the atomic sequence the same is not true for non-rv send operations; 6.2.2: RUN statements can start a new process at a higher priority level which interferes with statement merging, so it too is not a suitable merge target #endif if ((lt->ntyp == 'c' && !any_oper(lt->lft, RUN)) /* 2nd clause 6.2.2 */ || lt->ntyp == 'r' || (lt->ntyp == 's' && u_sync == 0)) /* added !u_sync in 4.1.3 */ { if (!canfill_in(t)) /* atomic, non-global, etc. */ continue; g = fsm_tbl[t->to]; if (!g || !g->t || !g->t->step) continue; if (g->t->step->merge) t->step->merge_start = g->t->step->merge; #ifdef SINGLES else if (g->t->step->merge_single) t->step->merge_start = g->t->step->merge_single; #endif #if 0 if ((verbose&32) && t->step->merge_start) { printf("spin: %s:%d, merge_START:\n\t\t", lt->fn->name, lt->ln, t->step->seqno); comment(stdout, lt, 0); printf(";\n"); } #endif } } } static void FSM_ANA(void) { FSM_state *f; FSM_trans *t; FSM_use *u, *v, *w; int n; for (f = fsm; f; f = f->nxt) /* all states */ for (t = f->t; t; t = t->nxt) /* all edges */ for (n = 0; n < 2; n++) /* reads and writes */ for (u = t->Val[n]; u; u = u->nxt) { if (!u->var->context /* global */ || u->var->type == CHAN || u->var->type == STRUCT) continue; new_dfs(); if (FSM_DFS(t->to, u)) /* cannot hit read before hitting write */ u->special = n+1; /* means, reset to 0 after use */ } if (!export_ast) for (f = fsm; f; f = f->nxt) for (t = f->t; t; t = t->nxt) for (n = 0; n < 2; n++) for (u = t->Val[n], w = (FSM_use *) 0; u; ) { if (u->special) { v = u->nxt; if (!w) /* remove from list */ t->Val[n] = v; else w->nxt = v; #if q if (verbose&32) { printf("%s : %3d: %d -> %d \t", t->step->n->fn->name, t->step->n->ln, f->from, t->to); comment(stdout, t->step->n, 0); printf("\t%c%d: %s\n", n==0?'R':'L', u->special, u->var->name); } #endif if (good_dead(t->step, u)) { u->nxt = t->step->dead; /* insert into dead */ t->step->dead = u; } u = v; } else { w = u; u = u->nxt; } } } void rel_use(FSM_use *u) { if (!u) return; rel_use(u->nxt); u->var = (Symbol *) 0; u->special = 0; u->nxt = use_free; use_free = u; } static void rel_trans(FSM_trans *t) { if (!t) return; rel_trans(t->nxt); rel_use(t->Val[0]); rel_use(t->Val[1]); t->Val[0] = t->Val[1] = (FSM_use *) 0; t->nxt = trans_free; trans_free = t; } static void rel_state(FSM_state *f) { if (!f) return; rel_state(f->nxt); rel_trans(f->t); f->t = (FSM_trans *) 0; f->nxt = fsm_free; fsm_free = f; } static void FSM_DEL(void) { rel_state(fsm); fsm = (FSM_state *) 0; } static FSM_state * mkstate(int s) { FSM_state *f; /* fsm_tbl isn't allocated yet */ for (f = fsm; f; f = f->nxt) if (f->from == s) break; if (!f) { if (fsm_free) { f = fsm_free; memset(f, 0, sizeof(FSM_state)); fsm_free = fsm_free->nxt; } else f = (FSM_state *) emalloc(sizeof(FSM_state)); f->from = s; f->t = (FSM_trans *) 0; f->nxt = fsm; fsm = f; if (s > max_st_id) max_st_id = s; } return f; } static FSM_trans * get_trans(int to) { FSM_trans *t; if (trans_free) { t = trans_free; memset(t, 0, sizeof(FSM_trans)); trans_free = trans_free->nxt; } else t = (FSM_trans *) emalloc(sizeof(FSM_trans)); t->to = to; return t; } static void FSM_EDGE(int from, int to, Element *e) { FSM_state *f; FSM_trans *t; f = mkstate(from); /* find it or else make it */ t = get_trans(to); t->step = e; t->nxt = f->t; f->t = t; f = mkstate(to); f->in++; if (export_ast) { t = get_trans(from); t->step = e; t->nxt = f->p; /* from is a predecessor of to */ f->p = t; } if (t->step) ana_stmnt(t, t->step->n, 0); } #define LVAL 1 #define RVAL 0 static void ana_var(FSM_trans *t, Lextok *now, int usage) { FSM_use *u, *v; if (!t || !now || !now->sym) return; if (now->sym->name[0] == '_' && (strcmp(now->sym->name, "_") == 0 || strcmp(now->sym->name, "_pid") == 0 || strcmp(now->sym->name, "_priority") == 0 || strcmp(now->sym->name, "_last") == 0)) return; v = t->Val[usage]; for (u = v; u; u = u->nxt) if (u->var == now->sym) return; /* it's already there */ if (!now->lft) { /* not for array vars -- it's hard to tell statically if the index would, at runtime, evaluate to the same values at lval and rval references */ if (use_free) { u = use_free; use_free = use_free->nxt; } else u = (FSM_use *) emalloc(sizeof(FSM_use)); u->var = now->sym; u->nxt = t->Val[usage]; t->Val[usage] = u; } else ana_stmnt(t, now->lft, RVAL); /* index */ if (now->sym->type == STRUCT && now->rgt && now->rgt->lft) ana_var(t, now->rgt->lft, usage); } static void ana_stmnt(FSM_trans *t, Lextok *now, int usage) { Lextok *v; if (!t || !now) return; switch (now->ntyp) { case '.': case BREAK: case GOTO: case CONST: case TIMEOUT: case NONPROGRESS: case ELSE: case '@': case 'q': case IF: case DO: case ATOMIC: case NON_ATOMIC: case D_STEP: case C_CODE: case C_EXPR: break; case ',': /* reached with SET_P and array initializers */ if (now->lft && now->lft->rgt) { ana_stmnt(t, now->lft->rgt, RVAL); } break; case '!': case UMIN: case '~': case ENABLED: case GET_P: case PC_VAL: case LEN: case FULL: case EMPTY: case NFULL: case NEMPTY: case ASSERT: case 'c': ana_stmnt(t, now->lft, RVAL); break; case SET_P: ana_stmnt(t, now->lft, RVAL); /* ',' */ ana_stmnt(t, now->lft->rgt, RVAL); break; case '/': case '*': case '-': case '+': case '%': case '&': case '^': case '|': case LT: case GT: case LE: case GE: case NE: case EQ: case OR: case AND: case LSHIFT: case RSHIFT: ana_stmnt(t, now->lft, RVAL); ana_stmnt(t, now->rgt, RVAL); break; case ASGN: if (check_track(now) == STRUCT) { break; } ana_stmnt(t, now->lft, LVAL); if (now->rgt->ntyp) ana_stmnt(t, now->rgt, RVAL); break; case PRINT: case RUN: for (v = now->lft; v; v = v->rgt) ana_stmnt(t, v->lft, RVAL); break; case PRINTM: if (now->lft && !now->lft->ismtyp) ana_stmnt(t, now->lft, RVAL); break; case 's': ana_stmnt(t, now->lft, RVAL); for (v = now->rgt; v; v = v->rgt) ana_stmnt(t, v->lft, RVAL); break; case 'R': case 'r': ana_stmnt(t, now->lft, RVAL); for (v = now->rgt; v; v = v->rgt) { if (v->lft->ntyp == EVAL) ana_stmnt(t, v->lft->lft, RVAL); else if (v->lft->ntyp != CONST && now->ntyp != 'R') /* was v->lft->ntyp */ ana_stmnt(t, v->lft, LVAL); } break; case '?': ana_stmnt(t, now->lft, RVAL); if (now->rgt) { ana_stmnt(t, now->rgt->lft, RVAL); ana_stmnt(t, now->rgt->rgt, RVAL); } break; case NAME: ana_var(t, now, usage); break; case 'p': /* remote ref */ ana_stmnt(t, now->lft->lft, RVAL); /* process id */ ana_var(t, now, RVAL); ana_var(t, now->rgt, RVAL); break; default: printf("spin: %s:%d, bad node type %d (ana_stmnt)\n", now->fn->name, now->ln, now->ntyp); fatal("aborting", (char *) 0); } } void ana_src(int dataflow, int merger) /* called from main.c and guided.c */ { ProcList *p; Element *e; #if 0 int counter = 1; #endif for (p = rdy; p; p = p->nxt) { ana_seq(p->s); fsm_table(); e = p->s->frst; #if 0 if (dataflow || merger) { printf("spin: %d, optimizing '%s'", counter++, p->n->name); fflush(stdout); } #endif if (dataflow) { FSM_ANA(); } if (merger) { FSM_MERGER(/* p->n->name */); huntele(e, e->status, -1)->merge_in = 1; /* start-state */ #if 0 printf("\n"); #endif } if (export_ast) AST_store(p, huntele(e, e->status, -1)->seqno); FSM_DEL(); } for (e = Al_El; e; e = e->Nxt) { if (!(e->status&DONE) && (verbose&32)) { printf("unreachable code: "); printf("%s:%3d ", e->n->fn->name, e->n->ln); comment(stdout, e->n, 0); printf("\n"); } e->status &= ~DONE; } if (export_ast) { AST_slice(); alldone(0); /* changed in 5.3.0: was exit(0) */ } } void spit_recvs(FILE *f1, FILE *f2) /* called from pangen2.c */ { Element *e; Sequence *s; extern int Unique; fprintf(f1, "unsigned char Is_Recv[%d];\n", Unique); fprintf(f2, "void\nset_recvs(void)\n{\n"); for (e = Al_El; e; e = e->Nxt) { if (!e->n) continue; switch (e->n->ntyp) { case 'r': markit: fprintf(f2, "\tIs_Recv[%d] = 1;\n", e->Seqno); break; case D_STEP: s = e->n->sl->this; switch (s->frst->n->ntyp) { case DO: fatal("unexpected: do at start of d_step", (char *) 0); case IF: /* conservative: fall through */ case 'r': goto markit; } break; } } fprintf(f2, "}\n"); if (rvopt) { fprintf(f2, "int\nno_recvs(int me)\n{\n"); fprintf(f2, " int h; uchar ot; short tt;\n"); fprintf(f2, " Trans *t;\n"); fprintf(f2, " for (h = BASE; h < (int) now._nr_pr; h++)\n"); fprintf(f2, " { if (h == me) continue;\n"); fprintf(f2, " tt = (short) ((P0 *)pptr(h))->_p;\n"); fprintf(f2, " ot = (uchar) ((P0 *)pptr(h))->_t;\n"); fprintf(f2, " for (t = trans[ot][tt]; t; t = t->nxt)\n"); fprintf(f2, " if (Is_Recv[t->t_id]) return 0;\n"); fprintf(f2, " }\n"); fprintf(f2, " return 1;\n"); fprintf(f2, "}\n"); } } static void ana_seq(Sequence *s) { SeqList *h; Sequence *t; Element *e, *g; int From, To; for (e = s->frst; e; e = e->nxt) { if (e->status & DONE) goto checklast; e->status |= DONE; From = e->seqno; if (e->n->ntyp == UNLESS) ana_seq(e->sub->this); else if (e->sub) { for (h = e->sub; h; h = h->nxt) { g = huntstart(h->this->frst); To = g->seqno; if (g->n->ntyp != 'c' || g->n->lft->ntyp != CONST || g->n->lft->val != 0 || g->esc) FSM_EDGE(From, To, e); /* else it's a dead link */ } for (h = e->sub; h; h = h->nxt) ana_seq(h->this); } else if (e->n->ntyp == ATOMIC || e->n->ntyp == D_STEP || e->n->ntyp == NON_ATOMIC) { t = e->n->sl->this; g = huntstart(t->frst); t->last->nxt = e->nxt; To = g->seqno; FSM_EDGE(From, To, e); ana_seq(t); } else { if (e->n->ntyp == GOTO) { g = get_lab(e->n, 1); g = huntele(g, e->status, -1); if (!g) { fatal("unexpected error 2", (char *) 0); } To = g->seqno; } else if (e->nxt) { g = huntele(e->nxt, e->status, -1); if (!g) { fatal("unexpected error 3", (char *) 0); } To = g->seqno; } else To = 0; FSM_EDGE(From, To, e); if (e->esc && e->n->ntyp != GOTO && e->n->ntyp != '.') for (h = e->esc; h; h = h->nxt) { g = huntstart(h->this->frst); To = g->seqno; FSM_EDGE(From, To, ZE); ana_seq(h->this); } } checklast: if (e == s->last) break; } } Spin/Src6.4.5/tl_cache.c0000664000175100017510000001262512641605057012615 0ustar ghgh/***** tl_spin: tl_cache.c *****/ /* * This file is part of the public release of Spin. It is subject to the * terms in the LICENSE file that is included in this source directory. * Tool documentation is available at http://spinroot.com * * Based on the translation algorithm by Gerth, Peled, Vardi, and Wolper, * presented at the PSTV Conference, held in 1995, Warsaw, Poland 1995. */ #include "tl.h" typedef struct Cache { Node *before; Node *after; int same; struct Cache *nxt; } Cache; static Cache *stored = (Cache *) 0; static unsigned long Caches, CacheHits; static int ismatch(Node *, Node *); static int sameform(Node *, Node *); extern void fatal(char *, char *); void ini_cache(void) { stored = (Cache *) 0; Caches = 0; CacheHits = 0; } #if 0 void cache_dump(void) { Cache *d; int nr=0; printf("\nCACHE DUMP:\n"); for (d = stored; d; d = d->nxt, nr++) { if (d->same) continue; printf("B%3d: ", nr); dump(d->before); printf("\n"); printf("A%3d: ", nr); dump(d->after); printf("\n"); } printf("============\n"); } #endif Node * in_cache(Node *n) { Cache *d; int nr=0; for (d = stored; d; d = d->nxt, nr++) if (isequal(d->before, n)) { CacheHits++; if (d->same && ismatch(n, d->before)) return n; return dupnode(d->after); } return ZN; } Node * cached(Node *n) { Cache *d; Node *m; if (!n) return n; if ((m = in_cache(n)) != ZN) return m; Caches++; d = (Cache *) tl_emalloc(sizeof(Cache)); d->before = dupnode(n); d->after = Canonical(n); /* n is released */ if (ismatch(d->before, d->after)) { d->same = 1; releasenode(1, d->after); d->after = d->before; } d->nxt = stored; stored = d; return dupnode(d->after); } void cache_stats(void) { printf("cache stores : %9ld\n", Caches); printf("cache hits : %9ld\n", CacheHits); } void releasenode(int all_levels, Node *n) { if (!n) return; if (all_levels) { releasenode(1, n->lft); n->lft = ZN; releasenode(1, n->rgt); n->rgt = ZN; } tfree((void *) n); } Node * tl_nn(int t, Node *ll, Node *rl) { Node *n = (Node *) tl_emalloc(sizeof(Node)); n->ntyp = (short) t; n->lft = ll; n->rgt = rl; return n; } Node * getnode(Node *p) { Node *n; if (!p) return p; n = (Node *) tl_emalloc(sizeof(Node)); n->ntyp = p->ntyp; n->sym = p->sym; /* same name */ n->lft = p->lft; n->rgt = p->rgt; return n; } Node * dupnode(Node *n) { Node *d; if (!n) return n; d = getnode(n); d->lft = dupnode(n->lft); d->rgt = dupnode(n->rgt); return d; } int one_lft(int ntyp, Node *x, Node *in) { if (!x) return 1; if (!in) return 0; if (sameform(x, in)) return 1; if (in->ntyp != ntyp) return 0; if (one_lft(ntyp, x, in->lft)) return 1; return one_lft(ntyp, x, in->rgt); } int all_lfts(int ntyp, Node *from, Node *in) { if (!from) return 1; if (from->ntyp != ntyp) return one_lft(ntyp, from, in); if (!one_lft(ntyp, from->lft, in)) return 0; return all_lfts(ntyp, from->rgt, in); } int sametrees(int ntyp, Node *a, Node *b) { /* toplevel is an AND or OR */ /* both trees are right-linked, but the leafs */ /* can be in different places in the two trees */ if (!all_lfts(ntyp, a, b)) return 0; return all_lfts(ntyp, b, a); } static int /* a better isequal() */ sameform(Node *a, Node *b) { if (!a && !b) return 1; if (!a || !b) return 0; if (a->ntyp != b->ntyp) return 0; if (a->sym && b->sym && strcmp(a->sym->name, b->sym->name) != 0) return 0; switch (a->ntyp) { case TRUE: case FALSE: return 1; case PREDICATE: if (!a->sym || !b->sym) fatal("sameform...", (char *) 0); return !strcmp(a->sym->name, b->sym->name); case NOT: #ifdef NXT case NEXT: #endif case CEXPR: return sameform(a->lft, b->lft); case U_OPER: case V_OPER: if (!sameform(a->lft, b->lft)) return 0; if (!sameform(a->rgt, b->rgt)) return 0; return 1; case AND: case OR: /* the hard case */ return sametrees(a->ntyp, a, b); default: printf("type: %d\n", a->ntyp); fatal("cannot happen, sameform", (char *) 0); } return 0; } int isequal(Node *a, Node *b) { if (!a && !b) return 1; if (!a || !b) { if (!a) { if (b->ntyp == TRUE) return 1; } else { if (a->ntyp == TRUE) return 1; } return 0; } if (a->ntyp != b->ntyp) return 0; if (a->sym && b->sym && strcmp(a->sym->name, b->sym->name) != 0) return 0; if (isequal(a->lft, b->lft) && isequal(a->rgt, b->rgt)) return 1; return sameform(a, b); } static int ismatch(Node *a, Node *b) { if (!a && !b) return 1; if (!a || !b) return 0; if (a->ntyp != b->ntyp) return 0; if (a->sym && b->sym && strcmp(a->sym->name, b->sym->name) != 0) return 0; if (ismatch(a->lft, b->lft) && ismatch(a->rgt, b->rgt)) return 1; return 0; } int any_term(Node *srch, Node *in) { if (!in) return 0; if (in->ntyp == AND) return any_term(srch, in->lft) || any_term(srch, in->rgt); return isequal(in, srch); } int any_and(Node *srch, Node *in) { if (!in) return 0; if (srch->ntyp == AND) return any_and(srch->lft, in) && any_and(srch->rgt, in); return any_term(srch, in); } int any_lor(Node *srch, Node *in) { if (!in) return 0; if (in->ntyp == OR) return any_lor(srch, in->lft) || any_lor(srch, in->rgt); return isequal(in, srch); } int anywhere(int tok, Node *srch, Node *in) { if (!in) return 0; switch (tok) { case AND: return any_and(srch, in); case OR: return any_lor(srch, in); case 0: return any_term(srch, in); } fatal("cannot happen, anywhere", (char *) 0); return 0; } Spin/Src6.4.5/tl.h0000664000175100017510000000573612641605057011504 0ustar ghgh/***** tl_spin: tl.h *****/ /* * This file is part of the public release of Spin. It is subject to the * terms in the LICENSE file that is included in this source directory. * Tool documentation is available at http://spinroot.com * * Based on the translation algorithm by Gerth, Peled, Vardi, and Wolper, * presented at the PSTV Conference, held in 1995, Warsaw, Poland 1995. */ #include #include typedef struct Symbol { char *name; struct Symbol *next; /* linked list, symbol table */ } Symbol; typedef struct Node { short ntyp; /* node type */ struct Symbol *sym; struct Node *lft; /* tree */ struct Node *rgt; /* tree */ struct Node *nxt; /* if linked list */ } Node; typedef struct Graph { Symbol *name; Symbol *incoming; Symbol *outgoing; Symbol *oldstring; Symbol *nxtstring; Node *New; Node *Old; Node *Other; Node *Next; unsigned char isred[64], isgrn[64]; unsigned char redcnt, grncnt; unsigned char reachable; struct Graph *nxt; } Graph; typedef struct Mapping { char *from; Graph *to; struct Mapping *nxt; } Mapping; enum { ALWAYS=257, AND, /* 258 */ EQUIV, /* 259 */ EVENTUALLY, /* 260 */ FALSE, /* 261 */ IMPLIES, /* 262 */ NOT, /* 263 */ OR, /* 264 */ PREDICATE, /* 265 */ TRUE, /* 266 */ U_OPER, /* 267 */ V_OPER /* 268 */ #ifdef NXT , NEXT /* 269 */ #endif , CEXPR /* 270 */ }; Node *Canonical(Node *); Node *canonical(Node *); Node *cached(Node *); Node *dupnode(Node *); Node *getnode(Node *); Node *in_cache(Node *); Node *push_negation(Node *); Node *right_linked(Node *); Node *tl_nn(int, Node *, Node *); Symbol *tl_lookup(char *); Symbol *getsym(Symbol *); Symbol *DoDump(Node *); extern char *emalloc(size_t); /* in main.c */ int anywhere(int, Node *, Node *); int dump_cond(Node *, Node *, int); int hash(char *); /* in sym.c */ int isalnum_(int); /* in spinlex.c */ int isequal(Node *, Node *); int tl_Getchar(void); void *tl_emalloc(int); void a_stats(void); void addtrans(Graph *, char *, Node *, char *); void cache_stats(void); void dump(Node *); void exit(int); void Fatal(char *, char *); void fatal(char *, char *); void fsm_print(void); void ini_buchi(void); void ini_cache(void); void ini_rewrt(void); void ini_trans(void); void releasenode(int, Node *); void tfree(void *); void tl_explain(int); void tl_UnGetchar(void); void tl_parse(void); void tl_yyerror(char *); void trans(Node *); #define ZN (Node *)0 #define ZS (Symbol *)0 #define Nhash 255 /* must match size in spin.h */ #define True tl_nn(TRUE, ZN, ZN) #define False tl_nn(FALSE, ZN, ZN) #define Not(a) push_negation(tl_nn(NOT, a, ZN)) #define rewrite(n) canonical(right_linked(n)) typedef Node *Nodeptr; #define YYSTYPE Nodeptr #define Debug(x) { if (tl_verbose) printf(x); } #define Debug2(x,y) { if (tl_verbose) printf(x,y); } #define Dump(x) { if (tl_verbose) dump(x); } #define Explain(x) { if (tl_verbose) tl_explain(x); } #define Assert(x, y) { if (!(x)) { tl_explain(y); \ Fatal(": assertion failed\n",(char *)0); } } Spin/Src6.4.5/vars.c0000664000175100017510000002170412641605057012024 0ustar ghgh/***** spin: vars.c *****/ /* * This file is part of the public release of Spin. It is subject to the * terms in the LICENSE file that is included in this source directory. * Tool documentation is available at http://spinroot.com */ #include "spin.h" #include "y.tab.h" extern Ordered *all_names; extern RunList *X, *LastX; extern Symbol *Fname; extern char Buf[]; extern int lineno, depth, verbose, xspin, limited_vis; extern int analyze, jumpsteps, nproc, nstop, columns, old_priority_rules; extern short no_arrays, Have_claim; extern void sr_mesg(FILE *, int, int); extern void sr_buf(int, int); static int getglobal(Lextok *); static int setglobal(Lextok *, int); static int maxcolnr = 1; int getval(Lextok *sn) { Symbol *s = sn->sym; if (strcmp(s->name, "_") == 0) { non_fatal("attempt to read value of '_'", 0); return 0; } if (strcmp(s->name, "_last") == 0) return (LastX)?LastX->pid:0; if (strcmp(s->name, "_p") == 0) return (X && X->pc)?X->pc->seqno:0; if (strcmp(s->name, "_pid") == 0) { if (!X) return 0; return X->pid - Have_claim; } if (strcmp(s->name, "_priority") == 0) { if (!X) return 0; if (old_priority_rules) { non_fatal("cannot refer to _priority with -o6", (char *) 0); return 1; } return X->priority; } if (strcmp(s->name, "_nr_pr") == 0) { return nproc-nstop; /* new 3.3.10 */ } if (s->context && s->type) { return getlocal(sn); } if (!s->type) /* not declared locally */ { s = lookup(s->name); /* try global */ sn->sym = s; /* fix it */ } return getglobal(sn); } int setval(Lextok *v, int n) { if (strcmp(v->sym->name, "_last") == 0 || strcmp(v->sym->name, "_p") == 0 || strcmp(v->sym->name, "_pid") == 0 || strcmp(v->sym->name, "_nr_qs") == 0 || strcmp(v->sym->name, "_nr_pr") == 0) { non_fatal("illegal assignment to %s", v->sym->name); } if (strcmp(v->sym->name, "_priority") == 0) { if (old_priority_rules) { non_fatal("cannot refer to _priority with -o6", (char *) 0); return 1; } if (!X) { non_fatal("no context for _priority", (char *) 0); return 1; } X->priority = n; } if (v->sym->context && v->sym->type) return setlocal(v, n); if (!v->sym->type) v->sym = lookup(v->sym->name); return setglobal(v, n); } void rm_selfrefs(Symbol *s, Lextok *i) { if (!i) return; if (i->ntyp == NAME && strcmp(i->sym->name, s->name) == 0 && ( (!i->sym->context && !s->context) || ( i->sym->context && s->context && strcmp(i->sym->context->name, s->context->name) == 0))) { lineno = i->ln; Fname = i->fn; non_fatal("self-reference initializing '%s'", s->name); i->ntyp = CONST; i->val = 0; } else { rm_selfrefs(s, i->lft); rm_selfrefs(s, i->rgt); } } int checkvar(Symbol *s, int n) { int i, oln = lineno; /* calls on eval() change it */ Symbol *ofnm = Fname; Lextok *z, *y; if (!in_bound(s, n)) return 0; if (s->type == 0) { non_fatal("undecl var %s (assuming int)", s->name); s->type = INT; } /* not a STRUCT */ if (s->val == (int *) 0) /* uninitialized */ { s->val = (int *) emalloc(s->nel*sizeof(int)); z = s->ini; for (i = 0; i < s->nel; i++) { if (z && z->ntyp == ',') { y = z->lft; z = z->rgt; } else { y = z; } if (s->type != CHAN) { rm_selfrefs(s, y); s->val[i] = eval(y); } else if (!analyze) { s->val[i] = qmake(s); } } } lineno = oln; Fname = ofnm; return 1; } static int getglobal(Lextok *sn) { Symbol *s = sn->sym; int i, n = eval(sn->lft); if (s->type == 0 && X && (i = find_lab(s, X->n, 0))) /* getglobal */ { printf("findlab through getglobal on %s\n", s->name); return i; /* can this happen? */ } if (s->type == STRUCT) { return Rval_struct(sn, s, 1); /* 1 = check init */ } if (checkvar(s, n)) { return cast_val(s->type, s->val[n], s->nbits); } return 0; } int cast_val(int t, int v, int w) { int i=0; short s=0; unsigned int u=0; if (t == PREDEF || t == INT || t == CHAN) i = v; /* predef means _ */ else if (t == SHORT) s = (short) v; else if (t == BYTE || t == MTYPE) u = (unsigned char)v; else if (t == BIT) u = (unsigned char)(v&1); else if (t == UNSIGNED) { if (w == 0) fatal("cannot happen, cast_val", (char *)0); /* u = (unsigned)(v& ((1<>(8*sizeof(unsigned)-w))); /* doug */ } if (v != i+s+ (int) u) { char buf[64]; sprintf(buf, "%d->%d (%d)", v, i+s+(int)u, t); non_fatal("value (%s) truncated in assignment", buf); } return (int)(i+s+(int)u); } static int setglobal(Lextok *v, int m) { if (v->sym->type == STRUCT) { (void) Lval_struct(v, v->sym, 1, m); } else { int n = eval(v->lft); if (checkvar(v->sym, n)) { int oval = v->sym->val[n]; int nval = cast_val(v->sym->type, m, v->sym->nbits); v->sym->val[n] = nval; if (oval != nval) { v->sym->setat = depth; } } } return 1; } void dumpclaims(FILE *fd, int pid, char *s) { extern Lextok *Xu_List; extern int Pid; extern short terse; Lextok *m; int cnt = 0; int oPid = Pid; for (m = Xu_List; m; m = m->rgt) if (strcmp(m->sym->name, s) == 0) { cnt=1; break; } if (cnt == 0) return; Pid = pid; fprintf(fd, "#ifndef XUSAFE\n"); for (m = Xu_List; m; m = m->rgt) { if (strcmp(m->sym->name, s) != 0) continue; no_arrays = 1; putname(fd, "\t\tsetq_claim(", m->lft, 0, ""); no_arrays = 0; fprintf(fd, ", %d, ", m->val); terse = 1; putname(fd, "\"", m->lft, 0, "\", h, "); terse = 0; fprintf(fd, "\"%s\");\n", s); } fprintf(fd, "#endif\n"); Pid = oPid; } void dumpglobals(void) { Ordered *walk; static Lextok *dummy = ZN; Symbol *sp; int j; if (!dummy) dummy = nn(ZN, NAME, nn(ZN,CONST,ZN,ZN), ZN); for (walk = all_names; walk; walk = walk->next) { sp = walk->entry; if (!sp->type || sp->context || sp->owner || sp->type == PROCTYPE || sp->type == PREDEF || sp->type == CODE_FRAG || sp->type == CODE_DECL || (sp->type == MTYPE && ismtype(sp->name))) continue; if (sp->type == STRUCT) { if ((verbose&4) && !(verbose&64) && (sp->setat < depth && jumpsteps != depth)) { continue; } dump_struct(sp, sp->name, 0); continue; } for (j = 0; j < sp->nel; j++) { int prefetch; if (sp->type == CHAN) { doq(sp, j, 0); continue; } if ((verbose&4) && !(verbose&64) && (sp->setat < depth && jumpsteps != depth)) { continue; } dummy->sym = sp; dummy->lft->val = j; /* in case of cast_val warnings, do this first: */ prefetch = getglobal(dummy); printf("\t\t%s", sp->name); if (sp->nel > 1 || sp->isarray) printf("[%d]", j); printf(" = "); sr_mesg(stdout, prefetch, sp->type == MTYPE); printf("\n"); if (limited_vis && (sp->hidden&2)) { int colpos; Buf[0] = '\0'; if (!xspin) { if (columns == 2) sprintf(Buf, "~G%s = ", sp->name); else sprintf(Buf, "%s = ", sp->name); } sr_buf(prefetch, sp->type == MTYPE); if (sp->colnr == 0) { sp->colnr = (unsigned char) maxcolnr; maxcolnr = 1+(maxcolnr%10); } colpos = nproc+sp->colnr-1; if (columns == 2) { pstext(colpos, Buf); continue; } if (!xspin) { printf("\t\t%s\n", Buf); continue; } printf("MSC: ~G %s %s\n", sp->name, Buf); printf("%3d:\tproc %3d (TRACK) line 1 \"var\" ", depth, colpos); printf("(state 0)\t[printf('MSC: globvar\\\\n')]\n"); printf("\t\t%s", sp->name); if (sp->nel > 1 || sp->isarray) printf("[%d]", j); printf(" = %s\n", Buf); } } } } void dumplocal(RunList *r) { static Lextok *dummy = ZN; Symbol *z, *s; int i; if (!r) return; s = r->symtab; if (!dummy) dummy = nn(ZN, NAME, nn(ZN,CONST,ZN,ZN), ZN); for (z = s; z; z = z->next) { if (z->type == STRUCT) { dump_struct(z, z->name, r); continue; } for (i = 0; i < z->nel; i++) { if (z->type == CHAN) { doq(z, i, r); continue; } if ((verbose&4) && !(verbose&64) && (z->setat < depth && jumpsteps != depth)) continue; dummy->sym = z; dummy->lft->val = i; printf("\t\t%s(%d):%s", r->n->name, r->pid - Have_claim, z->name); if (z->nel > 1 || z->isarray) printf("[%d]", i); printf(" = "); sr_mesg(stdout, getval(dummy), z->type == MTYPE); printf("\n"); if (limited_vis && (z->hidden&2)) { int colpos; Buf[0] = '\0'; if (!xspin) { if (columns == 2) sprintf(Buf, "~G%s(%d):%s = ", r->n->name, r->pid, z->name); else sprintf(Buf, "%s(%d):%s = ", r->n->name, r->pid, z->name); } sr_buf(getval(dummy), z->type==MTYPE); if (z->colnr == 0) { z->colnr = (unsigned char) maxcolnr; maxcolnr = 1+(maxcolnr%10); } colpos = nproc+z->colnr-1; if (columns == 2) { pstext(colpos, Buf); continue; } if (!xspin) { printf("\t\t%s\n", Buf); continue; } printf("MSC: ~G %s(%d):%s %s\n", r->n->name, r->pid, z->name, Buf); printf("%3d:\tproc %3d (TRACK) line 1 \"var\" ", depth, colpos); printf("(state 0)\t[printf('MSC: locvar\\\\n')]\n"); printf("\t\t%s(%d):%s", r->n->name, r->pid, z->name); if (z->nel > 1 || z->isarray) printf("[%d]", i); printf(" = %s\n", Buf); } } } } Spin/Src6.4.5/pangen6.c0000664000175100017510000013523012641605057012407 0ustar ghgh/***** spin: pangen6.c *****/ /* * This file is part of the public release of Spin. It is subject to the * terms in the LICENSE file that is included in this source directory. * Tool documentation is available at http://spinroot.com */ #include "spin.h" #include "y.tab.h" extern Ordered *all_names; extern FSM_use *use_free; extern FSM_state **fsm_tbl; extern FSM_state *fsm; extern int verbose, o_max; static FSM_trans *cur_t; static FSM_trans *expl_par; static FSM_trans *expl_var; static FSM_trans *explicit; extern void rel_use(FSM_use *); #define ulong unsigned long typedef struct Pair { FSM_state *h; int b; struct Pair *nxt; } Pair; typedef struct AST { ProcList *p; /* proctype decl */ int i_st; /* start state */ int nstates, nwords; int relevant; Pair *pairs; /* entry and exit nodes of proper subgraphs */ FSM_state *fsm; /* proctype body */ struct AST *nxt; /* linked list */ } AST; typedef struct RPN { /* relevant proctype names */ Symbol *rn; struct RPN *nxt; } RPN; typedef struct ALIAS { /* channel aliasing info */ Lextok *cnm; /* this chan */ int origin; /* debugging - origin of the alias */ struct ALIAS *alias; /* can be an alias for these other chans */ struct ALIAS *nxt; /* linked list */ } ALIAS; typedef struct ChanList { Lextok *s; /* containing stmnt */ Lextok *n; /* point of reference - could be struct */ struct ChanList *nxt; /* linked list */ } ChanList; /* a chan alias can be created in one of three ways: assignement to chan name a = b -- a is now an alias for b passing chan name as parameter in run run x(b) -- proctype x(chan a) passing chan name through channel x!b -- x?a */ #define USE 1 #define DEF 2 #define DEREF_DEF 4 #define DEREF_USE 8 static AST *ast; static ALIAS *chalcur; static ALIAS *chalias; static ChanList *chanlist; static Slicer *slicer; static Slicer *rel_vars; /* all relevant variables */ static int AST_Changes; static int AST_Round; static RPN *rpn; static int in_recv = 0; static int AST_mutual(Lextok *, Lextok *, int); static void AST_dominant(void); static void AST_hidden(void); static void AST_setcur(Lextok *); static void check_slice(Lextok *, int); static void curtail(AST *); static void def_use(Lextok *, int); static void name_AST_track(Lextok *, int); static void show_expl(void); static int AST_isini(Lextok *n) /* is this an initialized channel */ { Symbol *s; if (!n || !n->sym) return 0; s = n->sym; if (s->type == CHAN) return (s->ini->ntyp == CHAN); /* freshly instantiated */ if (s->type == STRUCT && n->rgt) return AST_isini(n->rgt->lft); return 0; } static void AST_var(Lextok *n, Symbol *s, int toplevel) { if (!s) return; if (toplevel) { if (s->context && s->type) printf(":%s:L:", s->context->name); else printf("G:"); } printf("%s", s->name); /* array indices ignored */ if (s->type == STRUCT && n && n->rgt && n->rgt->lft) { printf(":"); AST_var(n->rgt->lft, n->rgt->lft->sym, 0); } } static void name_def_indices(Lextok *n, int code) { if (!n || !n->sym) return; if (n->sym->nel > 1 || n->sym->isarray) def_use(n->lft, code); /* process the index */ if (n->sym->type == STRUCT /* and possible deeper ones */ && n->rgt) name_def_indices(n->rgt->lft, code); } static void name_def_use(Lextok *n, int code) { FSM_use *u; if (!n) return; if ((code&USE) && cur_t->step && cur_t->step->n) { switch (cur_t->step->n->ntyp) { case 'c': /* possible predicate abstraction? */ n->sym->colnr |= 2; /* yes */ break; default: n->sym->colnr |= 1; /* no */ break; } } for (u = cur_t->Val[0]; u; u = u->nxt) if (AST_mutual(n, u->n, 1) && u->special == code) return; if (use_free) { u = use_free; use_free = use_free->nxt; } else u = (FSM_use *) emalloc(sizeof(FSM_use)); u->n = n; u->special = code; u->nxt = cur_t->Val[0]; cur_t->Val[0] = u; name_def_indices(n, USE|(code&(~DEF))); /* not def, but perhaps deref */ } static void def_use(Lextok *now, int code) { Lextok *v; if (now) switch (now->ntyp) { case '!': case UMIN: case '~': case 'c': case ENABLED: case SET_P: case GET_P: case ASSERT: case EVAL: def_use(now->lft, USE|code); break; case LEN: case FULL: case EMPTY: case NFULL: case NEMPTY: def_use(now->lft, DEREF_USE|USE|code); break; case '/': case '*': case '-': case '+': case '%': case '&': case '^': case '|': case LE: case GE: case GT: case LT: case NE: case EQ: case OR: case AND: case LSHIFT: case RSHIFT: def_use(now->lft, USE|code); def_use(now->rgt, USE|code); break; case ASGN: def_use(now->lft, DEF|code); def_use(now->rgt, USE|code); break; case TYPE: /* name in parameter list */ name_def_use(now, code); break; case NAME: name_def_use(now, code); break; case RUN: name_def_use(now, USE); /* procname - not really needed */ for (v = now->lft; v; v = v->rgt) def_use(v->lft, USE); /* params */ break; case 's': def_use(now->lft, DEREF_DEF|DEREF_USE|USE|code); for (v = now->rgt; v; v = v->rgt) def_use(v->lft, USE|code); break; case 'r': def_use(now->lft, DEREF_DEF|DEREF_USE|USE|code); for (v = now->rgt; v; v = v->rgt) { if (v->lft->ntyp == EVAL) def_use(v->lft, code); /* will add USE */ else if (v->lft->ntyp != CONST) def_use(v->lft, DEF|code); } break; case 'R': def_use(now->lft, DEREF_USE|USE|code); for (v = now->rgt; v; v = v->rgt) { if (v->lft->ntyp == EVAL) def_use(v->lft, code); /* will add USE */ } break; case '?': def_use(now->lft, USE|code); if (now->rgt) { def_use(now->rgt->lft, code); def_use(now->rgt->rgt, code); } break; case PRINT: for (v = now->lft; v; v = v->rgt) def_use(v->lft, USE|code); break; case PRINTM: def_use(now->lft, USE); break; case CONST: case ELSE: /* ? */ case NONPROGRESS: case PC_VAL: case 'p': case 'q': break; case '.': case GOTO: case BREAK: case '@': case D_STEP: case ATOMIC: case NON_ATOMIC: case IF: case DO: case UNLESS: case TIMEOUT: case C_CODE: case C_EXPR: default: break; } } static int AST_add_alias(Lextok *n, int nr) { ALIAS *ca; int res; for (ca = chalcur->alias; ca; ca = ca->nxt) if (AST_mutual(ca->cnm, n, 1)) { res = (ca->origin&nr); ca->origin |= nr; /* 1, 2, or 4 - run, asgn, or rcv */ return (res == 0); /* 0 if already there with same origin */ } ca = (ALIAS *) emalloc(sizeof(ALIAS)); ca->cnm = n; ca->origin = nr; ca->nxt = chalcur->alias; chalcur->alias = ca; return 1; } static void AST_run_alias(char *pn, char *s, Lextok *t, int parno) { Lextok *v; int cnt; if (!t) return; if (t->ntyp == RUN) { if (strcmp(t->sym->name, s) == 0) for (v = t->lft, cnt = 1; v; v = v->rgt, cnt++) if (cnt == parno) { AST_add_alias(v->lft, 1); /* RUN */ break; } } else { AST_run_alias(pn, s, t->lft, parno); AST_run_alias(pn, s, t->rgt, parno); } } static void AST_findrun(char *s, int parno) { FSM_state *f; FSM_trans *t; AST *a; for (a = ast; a; a = a->nxt) /* automata */ for (f = a->fsm; f; f = f->nxt) /* control states */ for (t = f->t; t; t = t->nxt) /* transitions */ { if (t->step) AST_run_alias(a->p->n->name, s, t->step->n, parno); } } static void AST_par_chans(ProcList *p) /* find local chan's init'd to chan passed as param */ { Ordered *walk; Symbol *sp; for (walk = all_names; walk; walk = walk->next) { sp = walk->entry; if (sp && sp->context && strcmp(sp->context->name, p->n->name) == 0 && sp->Nid >= 0 /* not itself a param */ && sp->type == CHAN && sp->ini->ntyp == NAME) /* != CONST and != CHAN */ { Lextok *x = nn(ZN, 0, ZN, ZN); x->sym = sp; AST_setcur(x); AST_add_alias(sp->ini, 2); /* ASGN */ } } } static void AST_para(ProcList *p) { Lextok *f, *t, *c; int cnt = 0; AST_par_chans(p); for (f = p->p; f; f = f->rgt) /* list of types */ for (t = f->lft; t; t = t->rgt) { if (t->ntyp != ',') c = t; else c = t->lft; /* expanded struct */ cnt++; if (Sym_typ(c) == CHAN) { ALIAS *na = (ALIAS *) emalloc(sizeof(ALIAS)); na->cnm = c; na->nxt = chalias; chalcur = chalias = na; #if 0 printf("%s -- (par) -- ", p->n->name); AST_var(c, c->sym, 1); printf(" => <<"); #endif AST_findrun(p->n->name, cnt); #if 0 printf(">>\n"); #endif } } } static void AST_haschan(Lextok *c) { if (!c) return; if (Sym_typ(c) == CHAN) { AST_add_alias(c, 2); /* ASGN */ #if 0 printf("<<"); AST_var(c, c->sym, 1); printf(">>\n"); #endif } else { AST_haschan(c->rgt); AST_haschan(c->lft); } } static int AST_nrpar(Lextok *n) /* 's' or 'r' */ { Lextok *m; int j = 0; for (m = n->rgt; m; m = m->rgt) j++; return j; } static int AST_ord(Lextok *n, Lextok *s) { Lextok *m; int j = 0; for (m = n->rgt; m; m = m->rgt) { j++; if (s->sym == m->lft->sym) return j; } return 0; } #if 0 static void AST_ownership(Symbol *s) { if (!s) return; printf("%s:", s->name); AST_ownership(s->owner); } #endif static int AST_mutual(Lextok *a, Lextok *b, int toplevel) { Symbol *as, *bs; if (!a && !b) return 1; if (!a || !b) return 0; as = a->sym; bs = b->sym; if (!as || !bs) return 0; if (toplevel && as->context != bs->context) return 0; if (as->type != bs->type) return 0; if (strcmp(as->name, bs->name) != 0) return 0; if (as->type == STRUCT && a->rgt && b->rgt) /* we know that a and b are not null */ return AST_mutual(a->rgt->lft, b->rgt->lft, 0); return 1; } static void AST_setcur(Lextok *n) /* set chalcur */ { ALIAS *ca; for (ca = chalias; ca; ca = ca->nxt) if (AST_mutual(ca->cnm, n, 1)) /* if same chan */ { chalcur = ca; return; } ca = (ALIAS *) emalloc(sizeof(ALIAS)); ca->cnm = n; ca->nxt = chalias; chalcur = chalias = ca; } static void AST_other(AST *a) /* check chan params in asgns and recvs */ { FSM_state *f; FSM_trans *t; FSM_use *u; ChanList *cl; for (f = a->fsm; f; f = f->nxt) /* control states */ for (t = f->t; t; t = t->nxt) /* transitions */ for (u = t->Val[0]; u; u = u->nxt) /* def/use info */ if (Sym_typ(u->n) == CHAN && (u->special&DEF)) /* def of chan-name */ { AST_setcur(u->n); switch (t->step->n->ntyp) { case ASGN: AST_haschan(t->step->n->rgt); break; case 'r': /* guess sends where name may originate */ for (cl = chanlist; cl; cl = cl->nxt) /* all sends */ { int aa = AST_nrpar(cl->s); int bb = AST_nrpar(t->step->n); if (aa != bb) /* matching nrs of params */ continue; aa = AST_ord(cl->s, cl->n); bb = AST_ord(t->step->n, u->n); if (aa != bb) /* same position in parlist */ continue; AST_add_alias(cl->n, 4); /* RCV assume possible match */ } break; default: printf("type = %d\n", t->step->n->ntyp); non_fatal("unexpected chan def type", (char *) 0); break; } } } static void AST_aliases(void) { ALIAS *na, *ca; for (na = chalias; na; na = na->nxt) { printf("\npossible aliases of "); AST_var(na->cnm, na->cnm->sym, 1); printf("\n\t"); for (ca = na->alias; ca; ca = ca->nxt) { if (!ca->cnm->sym) printf("no valid name "); else AST_var(ca->cnm, ca->cnm->sym, 1); printf("<"); if (ca->origin & 1) printf("RUN "); if (ca->origin & 2) printf("ASGN "); if (ca->origin & 4) printf("RCV "); printf("[%s]", AST_isini(ca->cnm)?"Initzd":"Name"); printf(">"); if (ca->nxt) printf(", "); } printf("\n"); } printf("\n"); } static void AST_indirect(FSM_use *uin, FSM_trans *t, char *cause, char *pn) { FSM_use *u; /* this is a newly discovered relevant statement */ /* all vars it uses to contribute to its DEF are new criteria */ if (!(t->relevant&1)) AST_Changes++; t->round = AST_Round; t->relevant = 1; if ((verbose&32) && t->step) { printf("\tDR %s [[ ", pn); comment(stdout, t->step->n, 0); printf("]]\n\t\tfully relevant %s", cause); if (uin) { printf(" due to "); AST_var(uin->n, uin->n->sym, 1); } printf("\n"); } for (u = t->Val[0]; u; u = u->nxt) if (u != uin && (u->special&(USE|DEREF_USE))) { if (verbose&32) { printf("\t\t\tuses(%d): ", u->special); AST_var(u->n, u->n->sym, 1); printf("\n"); } name_AST_track(u->n, u->special); /* add to slice criteria */ } } static void def_relevant(char *pn, FSM_trans *t, Lextok *n, int ischan) { FSM_use *u; ALIAS *na, *ca; int chanref; /* look for all DEF's of n * mark those stmnts relevant * mark all var USEs in those stmnts as criteria */ if (n->ntyp != ELSE) for (u = t->Val[0]; u; u = u->nxt) { chanref = (Sym_typ(u->n) == CHAN); if (ischan != chanref /* no possible match */ || !(u->special&(DEF|DEREF_DEF))) /* not a def */ continue; if (AST_mutual(u->n, n, 1)) { AST_indirect(u, t, "(exact match)", pn); continue; } if (chanref) for (na = chalias; na; na = na->nxt) { if (!AST_mutual(u->n, na->cnm, 1)) continue; for (ca = na->alias; ca; ca = ca->nxt) if (AST_mutual(ca->cnm, n, 1) && AST_isini(ca->cnm)) { AST_indirect(u, t, "(alias match)", pn); break; } if (ca) break; } } } static void AST_relevant(Lextok *n) { AST *a; FSM_state *f; FSM_trans *t; int ischan; /* look for all DEF's of n * mark those stmnts relevant * mark all var USEs in those stmnts as criteria */ if (!n) return; ischan = (Sym_typ(n) == CHAN); if (verbose&32) { printf("<ntyp); AST_var(n, n->sym, 1); printf(">>\n"); } for (t = expl_par; t; t = t->nxt) /* param assignments */ { if (!(t->relevant&1)) def_relevant(":params:", t, n, ischan); } for (t = expl_var; t; t = t->nxt) { if (!(t->relevant&1)) /* var inits */ def_relevant(":vars:", t, n, ischan); } for (a = ast; a; a = a->nxt) /* all other stmnts */ { if (a->p->b != N_CLAIM && a->p->b != E_TRACE && a->p->b != N_TRACE) for (f = a->fsm; f; f = f->nxt) for (t = f->t; t; t = t->nxt) { if (!(t->relevant&1)) def_relevant(a->p->n->name, t, n, ischan); } } } static int AST_relpar(char *s) { FSM_trans *t, *T; FSM_use *u; for (T = expl_par; T; T = (T == expl_par)?expl_var: (FSM_trans *) 0) for (t = T; t; t = t->nxt) { if (t->relevant&1) for (u = t->Val[0]; u; u = u->nxt) { if (u->n->sym->type && u->n->sym->context && strcmp(u->n->sym->context->name, s) == 0) { if (verbose&32) { printf("proctype %s relevant, due to symbol ", s); AST_var(u->n, u->n->sym, 1); printf("\n"); } return 1; } } } return 0; } static void AST_dorelevant(void) { AST *a; RPN *r; for (r = rpn; r; r = r->nxt) { for (a = ast; a; a = a->nxt) if (strcmp(a->p->n->name, r->rn->name) == 0) { a->relevant |= 1; break; } if (!a) fatal("cannot find proctype %s", r->rn->name); } } static void AST_procisrelevant(Symbol *s) { RPN *r; for (r = rpn; r; r = r->nxt) if (strcmp(r->rn->name, s->name) == 0) return; r = (RPN *) emalloc(sizeof(RPN)); r->rn = s; r->nxt = rpn; rpn = r; } static int AST_proc_isrel(char *s) { AST *a; for (a = ast; a; a = a->nxt) if (strcmp(a->p->n->name, s) == 0) return (a->relevant&1); non_fatal("cannot happen, missing proc in ast", (char *) 0); return 0; } static int AST_scoutrun(Lextok *t) { if (!t) return 0; if (t->ntyp == RUN) return AST_proc_isrel(t->sym->name); return (AST_scoutrun(t->lft) || AST_scoutrun(t->rgt)); } static void AST_tagruns(void) { AST *a; FSM_state *f; FSM_trans *t; /* if any stmnt inside a proctype is relevant * or any parameter passed in a run * then so are all the run statements on that proctype */ for (a = ast; a; a = a->nxt) { if (a->p->b == N_CLAIM || a->p->b == I_PROC || a->p->b == E_TRACE || a->p->b == N_TRACE) { a->relevant |= 1; /* the proctype is relevant */ continue; } if (AST_relpar(a->p->n->name)) a->relevant |= 1; else { for (f = a->fsm; f; f = f->nxt) for (t = f->t; t; t = t->nxt) if (t->relevant) goto yes; yes: if (f) a->relevant |= 1; } } for (a = ast; a; a = a->nxt) for (f = a->fsm; f; f = f->nxt) for (t = f->t; t; t = t->nxt) if (t->step && AST_scoutrun(t->step->n)) { AST_indirect((FSM_use *)0, t, ":run:", a->p->n->name); /* BUT, not all actual params are relevant */ } } static void AST_report(AST *a, Element *e) /* ALSO deduce irrelevant vars */ { if (!(a->relevant&2)) { a->relevant |= 2; printf("spin: redundant in proctype %s (for given property):\n", a->p->n->name); } printf(" %s:%d (state %d)", e->n?e->n->fn->name:"-", e->n?e->n->ln:-1, e->seqno); printf(" ["); comment(stdout, e->n, 0); printf("]\n"); } static int AST_always(Lextok *n) { if (!n) return 0; if (n->ntyp == '@' /* -end */ || n->ntyp == 'p') /* remote reference */ return 1; return AST_always(n->lft) || AST_always(n->rgt); } static void AST_edge_dump(AST *a, FSM_state *f) { FSM_trans *t; FSM_use *u; for (t = f->t; t; t = t->nxt) /* edges */ { if (t->step && AST_always(t->step->n)) t->relevant |= 1; /* always relevant */ if (verbose&32) { switch (t->relevant) { case 0: printf(" "); break; case 1: printf("*%3d ", t->round); break; case 2: printf("+%3d ", t->round); break; case 3: printf("#%3d ", t->round); break; default: printf("? "); break; } printf("%d\t->\t%d\t", f->from, t->to); if (t->step) comment(stdout, t->step->n, 0); else printf("Unless"); for (u = t->Val[0]; u; u = u->nxt) { printf(" <"); AST_var(u->n, u->n->sym, 1); printf(":%d>", u->special); } printf("\n"); } else { if (t->relevant) continue; if (t->step) switch(t->step->n->ntyp) { case ASGN: case 's': case 'r': case 'c': if (t->step->n->lft->ntyp != CONST) AST_report(a, t->step); break; case PRINT: /* don't report */ case PRINTM: case ASSERT: case C_CODE: case C_EXPR: default: break; } } } } static void AST_dfs(AST *a, int s, int vis) { FSM_state *f; FSM_trans *t; f = fsm_tbl[s]; if (f->seen) return; f->seen = 1; if (vis) AST_edge_dump(a, f); for (t = f->t; t; t = t->nxt) AST_dfs(a, t->to, vis); } static void AST_dump(AST *a) { FSM_state *f; for (f = a->fsm; f; f = f->nxt) { f->seen = 0; fsm_tbl[f->from] = f; } if (verbose&32) printf("AST_START %s from %d\n", a->p->n->name, a->i_st); AST_dfs(a, a->i_st, 1); } static void AST_sends(AST *a) { FSM_state *f; FSM_trans *t; FSM_use *u; ChanList *cl; for (f = a->fsm; f; f = f->nxt) /* control states */ for (t = f->t; t; t = t->nxt) /* transitions */ { if (t->step && t->step->n && t->step->n->ntyp == 's') for (u = t->Val[0]; u; u = u->nxt) { if (Sym_typ(u->n) == CHAN && ((u->special&USE) && !(u->special&DEREF_USE))) { #if 0 printf("%s -- (%d->%d) -- ", a->p->n->name, f->from, t->to); AST_var(u->n, u->n->sym, 1); printf(" -> chanlist\n"); #endif cl = (ChanList *) emalloc(sizeof(ChanList)); cl->s = t->step->n; cl->n = u->n; cl->nxt = chanlist; chanlist = cl; } } } } static ALIAS * AST_alfind(Lextok *n) { ALIAS *na; for (na = chalias; na; na = na->nxt) if (AST_mutual(na->cnm, n, 1)) return na; return (ALIAS *) 0; } static void AST_trans(void) { ALIAS *na, *ca, *da, *ea; int nchanges; do { nchanges = 0; for (na = chalias; na; na = na->nxt) { chalcur = na; for (ca = na->alias; ca; ca = ca->nxt) { da = AST_alfind(ca->cnm); if (da) for (ea = da->alias; ea; ea = ea->nxt) { nchanges += AST_add_alias(ea->cnm, ea->origin|ca->origin); } } } } while (nchanges > 0); chalcur = (ALIAS *) 0; } static void AST_def_use(AST *a) { FSM_state *f; FSM_trans *t; for (f = a->fsm; f; f = f->nxt) /* control states */ for (t = f->t; t; t = t->nxt) /* all edges */ { cur_t = t; rel_use(t->Val[0]); /* redo Val; doesn't cover structs */ rel_use(t->Val[1]); t->Val[0] = t->Val[1] = (FSM_use *) 0; if (!t->step) continue; def_use(t->step->n, 0); /* def/use info, including structs */ } cur_t = (FSM_trans *) 0; } static void name_AST_track(Lextok *n, int code) { extern int nr_errs; #if 0 printf("AST_name: "); AST_var(n, n->sym, 1); printf(" -- %d\n", code); #endif if (in_recv && (code&DEF) && (code&USE)) { printf("spin: %s:%d, error: DEF and USE of same var in rcv stmnt: ", n->fn->name, n->ln); AST_var(n, n->sym, 1); printf(" -- %d\n", code); nr_errs++; } check_slice(n, code); } void AST_track(Lextok *now, int code) /* called from main.c */ { Lextok *v; extern int export_ast; if (!export_ast) return; if (now) switch (now->ntyp) { case LEN: case FULL: case EMPTY: case NFULL: case NEMPTY: AST_track(now->lft, DEREF_USE|USE|code); break; case '/': case '*': case '-': case '+': case '%': case '&': case '^': case '|': case LE: case GE: case GT: case LT: case NE: case EQ: case OR: case AND: case LSHIFT: case RSHIFT: AST_track(now->rgt, USE|code); /* fall through */ case '!': case UMIN: case '~': case 'c': case ENABLED: case SET_P: case GET_P: case ASSERT: AST_track(now->lft, USE|code); break; case EVAL: AST_track(now->lft, USE|(code&(~DEF))); break; case NAME: name_AST_track(now, code); if (now->sym->nel > 1 || now->sym->isarray) AST_track(now->lft, USE); /* index, was USE|code */ break; case 'R': AST_track(now->lft, DEREF_USE|USE|code); for (v = now->rgt; v; v = v->rgt) AST_track(v->lft, code); /* a deeper eval can add USE */ break; case '?': AST_track(now->lft, USE|code); if (now->rgt) { AST_track(now->rgt->lft, code); AST_track(now->rgt->rgt, code); } break; /* added for control deps: */ case TYPE: name_AST_track(now, code); break; case ASGN: AST_track(now->lft, DEF|code); AST_track(now->rgt, USE|code); break; case RUN: name_AST_track(now, USE); for (v = now->lft; v; v = v->rgt) AST_track(v->lft, USE|code); break; case 's': AST_track(now->lft, DEREF_DEF|DEREF_USE|USE|code); for (v = now->rgt; v; v = v->rgt) AST_track(v->lft, USE|code); break; case 'r': AST_track(now->lft, DEREF_DEF|DEREF_USE|USE|code); for (v = now->rgt; v; v = v->rgt) { in_recv++; AST_track(v->lft, DEF|code); in_recv--; } break; case PRINT: for (v = now->lft; v; v = v->rgt) AST_track(v->lft, USE|code); break; case PRINTM: AST_track(now->lft, USE); break; /* end add */ case 'p': #if 0 'p' -sym-> _p / '?' -sym-> a (proctype) / b (pid expr) #endif AST_track(now->lft->lft, USE|code); AST_procisrelevant(now->lft->sym); break; case CONST: case ELSE: case NONPROGRESS: case PC_VAL: case 'q': break; case '.': case GOTO: case BREAK: case '@': case D_STEP: case ATOMIC: case NON_ATOMIC: case IF: case DO: case UNLESS: case TIMEOUT: case C_CODE: case C_EXPR: break; default: printf("AST_track, NOT EXPECTED ntyp: %d\n", now->ntyp); break; } } static int AST_dump_rel(void) { Slicer *rv; Ordered *walk; char buf[64]; int banner=0; if (verbose&32) { printf("Relevant variables:\n"); for (rv = rel_vars; rv; rv = rv->nxt) { printf("\t"); AST_var(rv->n, rv->n->sym, 1); printf("\n"); } return 1; } for (rv = rel_vars; rv; rv = rv->nxt) rv->n->sym->setat = 1; /* mark it */ for (walk = all_names; walk; walk = walk->next) { Symbol *s; s = walk->entry; if (!s->setat && (s->type != MTYPE || s->ini->ntyp != CONST) && s->type != STRUCT /* report only fields */ && s->type != PROCTYPE && !s->owner && sputtype(buf, s->type)) { if (!banner) { banner = 1; printf("spin: redundant vars (for given property):\n"); } printf("\t"); symvar(s); } } return banner; } static void AST_suggestions(void) { Symbol *s; Ordered *walk; FSM_state *f; FSM_trans *t; AST *a; int banner=0; int talked=0; for (walk = all_names; walk; walk = walk->next) { s = walk->entry; if (s->colnr == 2 /* only used in conditionals */ && (s->type == BYTE || s->type == SHORT || s->type == INT || s->type == MTYPE)) { if (!banner) { banner = 1; printf("spin: consider using predicate"); printf(" abstraction to replace:\n"); } printf("\t"); symvar(s); } } /* look for source and sink processes */ for (a = ast; a; a = a->nxt) /* automata */ { banner = 0; for (f = a->fsm; f; f = f->nxt) /* control states */ for (t = f->t; t; t = t->nxt) /* transitions */ { if (t->step) switch (t->step->n->ntyp) { case 's': banner |= 1; break; case 'r': banner |= 2; break; case '.': case D_STEP: case ATOMIC: case NON_ATOMIC: case IF: case DO: case UNLESS: case '@': case GOTO: case BREAK: case PRINT: case PRINTM: case ASSERT: case C_CODE: case C_EXPR: break; default: banner |= 4; goto no_good; } } no_good: if (banner == 1 || banner == 2) { printf("spin: proctype %s defines a %s process\n", a->p->n->name, banner==1?"source":"sink"); talked |= banner; } else if (banner == 3) { printf("spin: proctype %s mimics a buffer\n", a->p->n->name); talked |= 4; } } if (talked&1) { printf("\tto reduce complexity, consider merging the code of\n"); printf("\teach source process into the code of its target\n"); } if (talked&2) { printf("\tto reduce complexity, consider merging the code of\n"); printf("\teach sink process into the code of its source\n"); } if (talked&4) printf("\tto reduce complexity, avoid buffer processes\n"); } static void AST_preserve(void) { Slicer *sc, *nx, *rv; for (sc = slicer; sc; sc = nx) { if (!sc->used) break; /* done */ nx = sc->nxt; for (rv = rel_vars; rv; rv = rv->nxt) if (AST_mutual(sc->n, rv->n, 1)) break; if (!rv) /* not already there */ { sc->nxt = rel_vars; rel_vars = sc; } } slicer = sc; } static void check_slice(Lextok *n, int code) { Slicer *sc; for (sc = slicer; sc; sc = sc->nxt) if (AST_mutual(sc->n, n, 1) && sc->code == code) return; /* already there */ sc = (Slicer *) emalloc(sizeof(Slicer)); sc->n = n; sc->code = code; sc->used = 0; sc->nxt = slicer; slicer = sc; } static void AST_data_dep(void) { Slicer *sc; /* mark all def-relevant transitions */ for (sc = slicer; sc; sc = sc->nxt) { sc->used = 1; if (verbose&32) { printf("spin: slice criterion "); AST_var(sc->n, sc->n->sym, 1); printf(" type=%d\n", Sym_typ(sc->n)); } AST_relevant(sc->n); } AST_tagruns(); /* mark 'run's relevant if target proctype is relevant */ } static int AST_blockable(AST *a, int s) { FSM_state *f; FSM_trans *t; f = fsm_tbl[s]; for (t = f->t; t; t = t->nxt) { if (t->relevant&2) return 1; if (t->step && t->step->n) switch (t->step->n->ntyp) { case IF: case DO: case ATOMIC: case NON_ATOMIC: case D_STEP: if (AST_blockable(a, t->to)) { t->round = AST_Round; t->relevant |= 2; return 1; } /* else fall through */ default: break; } else if (AST_blockable(a, t->to)) /* Unless */ { t->round = AST_Round; t->relevant |= 2; return 1; } } return 0; } static void AST_spread(AST *a, int s) { FSM_state *f; FSM_trans *t; f = fsm_tbl[s]; for (t = f->t; t; t = t->nxt) { if (t->relevant&2) continue; if (t->step && t->step->n) switch (t->step->n->ntyp) { case IF: case DO: case ATOMIC: case NON_ATOMIC: case D_STEP: AST_spread(a, t->to); /* fall thru */ default: t->round = AST_Round; t->relevant |= 2; break; } else /* Unless */ { AST_spread(a, t->to); t->round = AST_Round; t->relevant |= 2; } } } static int AST_notrelevant(Lextok *n) { Slicer *s; for (s = rel_vars; s; s = s->nxt) if (AST_mutual(s->n, n, 1)) return 0; for (s = slicer; s; s = s->nxt) if (AST_mutual(s->n, n, 1)) return 0; return 1; } static int AST_withchan(Lextok *n) { if (!n) return 0; if (Sym_typ(n) == CHAN) return 1; return AST_withchan(n->lft) || AST_withchan(n->rgt); } static int AST_suspect(FSM_trans *t) { FSM_use *u; /* check for possible overkill */ if (!t || !t->step || !AST_withchan(t->step->n)) return 0; for (u = t->Val[0]; u; u = u->nxt) if (AST_notrelevant(u->n)) return 1; return 0; } static void AST_shouldconsider(AST *a, int s) { FSM_state *f; FSM_trans *t; f = fsm_tbl[s]; for (t = f->t; t; t = t->nxt) { if (t->step && t->step->n) switch (t->step->n->ntyp) { case IF: case DO: case ATOMIC: case NON_ATOMIC: case D_STEP: AST_shouldconsider(a, t->to); break; default: AST_track(t->step->n, 0); /* AST_track is called here for a blockable stmnt from which a relevant stmnmt was shown to be reachable for a condition this makes all USEs relevant but for a channel operation it only makes the executability relevant -- in those cases, parameters that aren't already relevant may be replaceable with arbitrary tokens */ if (AST_suspect(t)) { printf("spin: possibly redundant parameters in: "); comment(stdout, t->step->n, 0); printf("\n"); } break; } else /* an Unless */ AST_shouldconsider(a, t->to); } } static int FSM_critical(AST *a, int s) { FSM_state *f; FSM_trans *t; /* is a 1-relevant stmnt reachable from this state? */ f = fsm_tbl[s]; if (f->seen) goto done; f->seen = 1; f->cr = 0; for (t = f->t; t; t = t->nxt) if ((t->relevant&1) || FSM_critical(a, t->to)) { f->cr = 1; if (verbose&32) { printf("\t\t\t\tcritical(%d) ", t->relevant); comment(stdout, t->step->n, 0); printf("\n"); } break; } #if 0 else { if (verbose&32) { printf("\t\t\t\tnot-crit "); comment(stdout, t->step->n, 0); printf("\n"); } } #endif done: return f->cr; } static void AST_ctrl(AST *a) { FSM_state *f; FSM_trans *t; int hit; /* add all blockable transitions * from which relevant transitions can be reached */ if (verbose&32) printf("CTL -- %s\n", a->p->n->name); /* 1 : mark all blockable edges */ for (f = a->fsm; f; f = f->nxt) { if (!(f->scratch&2)) /* not part of irrelevant subgraph */ for (t = f->t; t; t = t->nxt) { if (t->step && t->step->n) switch (t->step->n->ntyp) { case 'r': case 's': case 'c': case ELSE: t->round = AST_Round; t->relevant |= 2; /* mark for next phases */ if (verbose&32) { printf("\tpremark "); comment(stdout, t->step->n, 0); printf("\n"); } break; default: break; } } } /* 2: keep only 2-marked stmnts from which 1-marked stmnts can be reached */ for (f = a->fsm; f; f = f->nxt) { fsm_tbl[f->from] = f; f->seen = 0; /* used in dfs from FSM_critical */ } for (f = a->fsm; f; f = f->nxt) { if (!FSM_critical(a, f->from)) for (t = f->t; t; t = t->nxt) if (t->relevant&2) { t->relevant &= ~2; /* clear mark */ if (verbose&32) { printf("\t\tnomark "); if (t->step && t->step->n) comment(stdout, t->step->n, 0); printf("\n"); } } } /* 3 : lift marks across IF/DO etc. */ for (f = a->fsm; f; f = f->nxt) { hit = 0; for (t = f->t; t; t = t->nxt) { if (t->step && t->step->n) switch (t->step->n->ntyp) { case IF: case DO: case ATOMIC: case NON_ATOMIC: case D_STEP: if (AST_blockable(a, t->to)) hit = 1; break; default: break; } else if (AST_blockable(a, t->to)) /* Unless */ hit = 1; if (hit) break; } if (hit) /* at least one outgoing trans can block */ for (t = f->t; t; t = t->nxt) { t->round = AST_Round; t->relevant |= 2; /* lift */ if (verbose&32) { printf("\t\t\tliftmark "); if (t->step && t->step->n) comment(stdout, t->step->n, 0); printf("\n"); } AST_spread(a, t->to); /* and spread to all guards */ } } /* 4: nodes with 2-marked out-edges contribute new slice criteria */ for (f = a->fsm; f; f = f->nxt) for (t = f->t; t; t = t->nxt) if (t->relevant&2) { AST_shouldconsider(a, f->from); break; /* inner loop */ } } static void AST_control_dep(void) { AST *a; for (a = ast; a; a = a->nxt) { if (a->p->b != N_CLAIM && a->p->b != E_TRACE && a->p->b != N_TRACE) { AST_ctrl(a); } } } static void AST_prelabel(void) { AST *a; FSM_state *f; FSM_trans *t; for (a = ast; a; a = a->nxt) { if (a->p->b != N_CLAIM && a->p->b != E_TRACE && a->p->b != N_TRACE) for (f = a->fsm; f; f = f->nxt) for (t = f->t; t; t = t->nxt) { if (t->step && t->step->n && t->step->n->ntyp == ASSERT ) { t->relevant |= 1; } } } } static void AST_criteria(void) { /* * remote labels are handled separately -- by making * sure they are not pruned away during optimization */ AST_Changes = 1; /* to get started */ for (AST_Round = 1; slicer && AST_Changes; AST_Round++) { AST_Changes = 0; AST_data_dep(); AST_preserve(); /* moves processed vars from slicer to rel_vars */ AST_dominant(); /* mark data-irrelevant subgraphs */ AST_control_dep(); /* can add data deps, which add control deps */ if (verbose&32) printf("\n\nROUND %d -- changes %d\n", AST_Round, AST_Changes); } } static void AST_alias_analysis(void) /* aliasing of promela channels */ { AST *a; for (a = ast; a; a = a->nxt) AST_sends(a); /* collect chan-names that are send across chans */ for (a = ast; a; a = a->nxt) AST_para(a->p); /* aliasing of chans thru proctype parameters */ for (a = ast; a; a = a->nxt) AST_other(a); /* chan params in asgns and recvs */ AST_trans(); /* transitive closure of alias table */ if (verbose&32) AST_aliases(); /* show channel aliasing info */ } void AST_slice(void) { AST *a; int spurious = 0; if (!slicer) { printf("spin: warning: no slice criteria found (no assertions and no claim)\n"); spurious = 1; } AST_dorelevant(); /* mark procs refered to in remote refs */ for (a = ast; a; a = a->nxt) AST_def_use(a); /* compute standard def/use information */ AST_hidden(); /* parameter passing and local var inits */ AST_alias_analysis(); /* channel alias analysis */ AST_prelabel(); /* mark all 'assert(...)' stmnts as relevant */ AST_criteria(); /* process the slice criteria from * asserts and from the never claim */ if (!spurious || (verbose&32)) { spurious = 1; for (a = ast; a; a = a->nxt) { AST_dump(a); /* marked up result */ if (a->relevant&2) /* it printed something */ spurious = 0; } if (!AST_dump_rel() /* relevant variables */ && spurious) printf("spin: no redundancies found (for given property)\n"); } AST_suggestions(); if (verbose&32) show_expl(); } void AST_store(ProcList *p, int start_state) { AST *n_ast; if (p->b != N_CLAIM && p->b != E_TRACE && p->b != N_TRACE) { n_ast = (AST *) emalloc(sizeof(AST)); n_ast->p = p; n_ast->i_st = start_state; n_ast->relevant = 0; n_ast->fsm = fsm; n_ast->nxt = ast; ast = n_ast; } fsm = (FSM_state *) 0; /* hide it from FSM_DEL */ } static void AST_add_explicit(Lextok *d, Lextok *u) { FSM_trans *e = (FSM_trans *) emalloc(sizeof(FSM_trans)); e->to = 0; /* or start_state ? */ e->relevant = 0; /* to be determined */ e->step = (Element *) 0; /* left blank */ e->Val[0] = e->Val[1] = (FSM_use *) 0; cur_t = e; def_use(u, USE); def_use(d, DEF); cur_t = (FSM_trans *) 0; e->nxt = explicit; explicit = e; } static void AST_fp1(char *s, Lextok *t, Lextok *f, int parno) { Lextok *v; int cnt; if (!t) return; if (t->ntyp == RUN) { if (strcmp(t->sym->name, s) == 0) for (v = t->lft, cnt = 1; v; v = v->rgt, cnt++) if (cnt == parno) { AST_add_explicit(f, v->lft); break; } } else { AST_fp1(s, t->lft, f, parno); AST_fp1(s, t->rgt, f, parno); } } static void AST_mk1(char *s, Lextok *c, int parno) { AST *a; FSM_state *f; FSM_trans *t; /* concoct an extra FSM_trans *t with the asgn of * formal par c to matching actual pars made explicit */ for (a = ast; a; a = a->nxt) /* automata */ for (f = a->fsm; f; f = f->nxt) /* control states */ for (t = f->t; t; t = t->nxt) /* transitions */ { if (t->step) AST_fp1(s, t->step->n, c, parno); } } static void AST_par_init(void) /* parameter passing -- hidden assignments */ { AST *a; Lextok *f, *t, *c; int cnt; for (a = ast; a; a = a->nxt) { if (a->p->b == N_CLAIM || a->p->b == I_PROC || a->p->b == E_TRACE || a->p->b == N_TRACE) { continue; /* has no params */ } cnt = 0; for (f = a->p->p; f; f = f->rgt) /* types */ for (t = f->lft; t; t = t->rgt) /* formals */ { cnt++; /* formal par count */ c = (t->ntyp != ',')? t : t->lft; /* the formal parameter */ AST_mk1(a->p->n->name, c, cnt); /* all matching run statements */ } } } static void AST_var_init(void) /* initialized vars (not chans) - hidden assignments */ { Ordered *walk; Lextok *x; Symbol *sp; AST *a; for (walk = all_names; walk; walk = walk->next) { sp = walk->entry; if (sp && !sp->context /* globals */ && sp->type != PROCTYPE && sp->ini && (sp->type != MTYPE || sp->ini->ntyp != CONST) /* not mtype defs */ && sp->ini->ntyp != CHAN) { x = nn(ZN, TYPE, ZN, ZN); x->sym = sp; AST_add_explicit(x, sp->ini); } } for (a = ast; a; a = a->nxt) { if (a->p->b != N_CLAIM && a->p->b != E_TRACE && a->p->b != N_TRACE) /* has no locals */ for (walk = all_names; walk; walk = walk->next) { sp = walk->entry; if (sp && sp->context && strcmp(sp->context->name, a->p->n->name) == 0 && sp->Nid >= 0 /* not a param */ && sp->type != LABEL && sp->ini && sp->ini->ntyp != CHAN) { x = nn(ZN, TYPE, ZN, ZN); x->sym = sp; AST_add_explicit(x, sp->ini); } } } } static void show_expl(void) { FSM_trans *t, *T; FSM_use *u; printf("\nExplicit List:\n"); for (T = expl_par; T; T = (T == expl_par)?expl_var: (FSM_trans *) 0) { for (t = T; t; t = t->nxt) { if (!t->Val[0]) continue; printf("%s", t->relevant?"*":" "); printf("%3d", t->round); for (u = t->Val[0]; u; u = u->nxt) { printf("\t<"); AST_var(u->n, u->n->sym, 1); printf(":%d>, ", u->special); } printf("\n"); } printf("==\n"); } printf("End\n"); } static void AST_hidden(void) /* reveal all hidden assignments */ { AST_par_init(); expl_par = explicit; explicit = (FSM_trans *) 0; AST_var_init(); expl_var = explicit; explicit = (FSM_trans *) 0; } #define BPW (8*sizeof(ulong)) /* bits per word */ static int bad_scratch(FSM_state *f, int upto) { FSM_trans *t; #if 0 1. all internal branch-points have else-s 2. all non-branchpoints have non-blocking out-edge 3. all internal edges are non-relevant subgraphs like this need NOT contribute control-dependencies #endif if (!f->seen || (f->scratch&4)) return 0; if (f->scratch&8) return 1; f->scratch |= 4; if (verbose&32) printf("X[%d:%d:%d] ", f->from, upto, f->scratch); if (f->scratch&1) { if (verbose&32) printf("\tbad scratch: %d\n", f->from); bad: f->scratch &= ~4; /* f->scratch |= 8; wrong */ return 1; } if (f->from != upto) for (t = f->t; t; t = t->nxt) if (bad_scratch(fsm_tbl[t->to], upto)) goto bad; return 0; } static void mark_subgraph(FSM_state *f, int upto) { FSM_trans *t; if (f->from == upto || !f->seen || (f->scratch&2)) return; f->scratch |= 2; for (t = f->t; t; t = t->nxt) mark_subgraph(fsm_tbl[t->to], upto); } static void AST_pair(AST *a, FSM_state *h, int y) { Pair *p; for (p = a->pairs; p; p = p->nxt) if (p->h == h && p->b == y) return; p = (Pair *) emalloc(sizeof(Pair)); p->h = h; p->b = y; p->nxt = a->pairs; a->pairs = p; } static void AST_checkpairs(AST *a) { Pair *p; for (p = a->pairs; p; p = p->nxt) { if (verbose&32) printf(" inspect pair %d %d\n", p->b, p->h->from); if (!bad_scratch(p->h, p->b)) /* subgraph is clean */ { if (verbose&32) printf("subgraph: %d .. %d\n", p->b, p->h->from); mark_subgraph(p->h, p->b); } } } static void subgraph(AST *a, FSM_state *f, int out) { FSM_state *h; int i, j; ulong *g; #if 0 reverse dominance suggests that this is a possible entry and exit node for a proper subgraph #endif h = fsm_tbl[out]; i = f->from / BPW; j = f->from % BPW; /* assert(j <= 32); else lshift undefined? */ g = h->mod; if (verbose&32) printf("possible pair %d %d -- %d\n", f->from, h->from, (g[i]&(1<from); /* record this pair */ } static void act_dom(AST *a) { FSM_state *f; FSM_trans *t; int i, j, cnt; for (f = a->fsm; f; f = f->nxt) { if (!f->seen) continue; #if 0 f->from is the exit-node of a proper subgraph, with the dominator its entry-node, if: a. this node has more than 1 reachable predecessor b. the dominator has more than 1 reachable successor (need reachability - in case of reverse dominance) d. the dominator is reachable, and not equal to this node #endif for (t = f->p, i = 0; t; t = t->nxt) { i += fsm_tbl[t->to]->seen; } if (i <= 1) { continue; /* a. */ } for (cnt = 1; cnt < a->nstates; cnt++) /* 0 is endstate */ { if (cnt == f->from || !fsm_tbl[cnt]->seen) { continue; /* c. */ } i = cnt / BPW; j = cnt % BPW; /* assert(j <= 32); */ if (!(f->dom[i]&(1<t, i = 0; t; t = t->nxt) { i += fsm_tbl[t->to]->seen; } if (i <= 1) { continue; /* b. */ } if (f->mod) /* final check in 2nd phase */ { subgraph(a, f, cnt); /* possible entry-exit pair */ } } } } static void reachability(AST *a) { FSM_state *f; for (f = a->fsm; f; f = f->nxt) f->seen = 0; /* clear */ AST_dfs(a, a->i_st, 0); /* mark 'seen' */ } static int see_else(FSM_state *f) { FSM_trans *t; for (t = f->t; t; t = t->nxt) { if (t->step && t->step->n) switch (t->step->n->ntyp) { case ELSE: return 1; case IF: case DO: case ATOMIC: case NON_ATOMIC: case D_STEP: if (see_else(fsm_tbl[t->to])) return 1; default: break; } } return 0; } static int is_guard(FSM_state *f) { FSM_state *g; FSM_trans *t; for (t = f->p; t; t = t->nxt) { g = fsm_tbl[t->to]; if (!g->seen) continue; if (t->step && t->step->n) switch(t->step->n->ntyp) { case IF: case DO: return 1; case ATOMIC: case NON_ATOMIC: case D_STEP: if (is_guard(g)) return 1; default: break; } } return 0; } static void curtail(AST *a) { FSM_state *f, *g; FSM_trans *t; int i, haselse, isrel, blocking; #if 0 mark nodes that do not satisfy these requirements: 1. all internal branch-points have else-s 2. all non-branchpoints have non-blocking out-edge 3. all internal edges are non-data-relevant #endif if (verbose&32) printf("Curtail %s:\n", a->p->n->name); for (f = a->fsm; f; f = f->nxt) { if (!f->seen || (f->scratch&(1|2))) continue; isrel = haselse = i = blocking = 0; for (t = f->t; t; t = t->nxt) { g = fsm_tbl[t->to]; isrel |= (t->relevant&1); /* data relevant */ i += g->seen; if (t->step && t->step->n) { switch (t->step->n->ntyp) { case IF: case DO: haselse |= see_else(g); break; case 'c': case 's': case 'r': blocking = 1; break; } } } #if 0 if (verbose&32) printf("prescratch %d -- %d %d %d %d -- %d\n", f->from, i, isrel, blocking, haselse, is_guard(f)); #endif if (isrel /* 3. */ || (i == 1 && blocking) /* 2. */ || (i > 1 && !haselse)) /* 1. */ { if (!is_guard(f)) { f->scratch |= 1; if (verbose&32) printf("scratch %d -- %d %d %d %d\n", f->from, i, isrel, blocking, haselse); } } } } static void init_dom(AST *a) { FSM_state *f; int i, j, cnt; #if 0 (1) D(s0) = {s0} (2) for s in S - {s0} do D(s) = S #endif for (f = a->fsm; f; f = f->nxt) { if (!f->seen) continue; f->dom = (ulong *) emalloc(a->nwords * sizeof(ulong)); if (f->from == a->i_st) { i = a->i_st / BPW; j = a->i_st % BPW; /* assert(j <= 32); */ f->dom[i] = (1<nwords; i++) { f->dom[i] = (ulong) ~0; /* all 1's */ } if (a->nstates % BPW) for (i = (a->nstates % BPW); i < (int) BPW; i++) { f->dom[a->nwords-1] &= ~(1<< ((ulong) i)); /* clear tail */ } for (cnt = 0; cnt < a->nstates; cnt++) { if (!fsm_tbl[cnt]->seen) { i = cnt / BPW; j = cnt % BPW; /* assert(j <= 32); */ f->dom[i] &= ~(1<< ((ulong) j)); } } } } } static int dom_perculate(AST *a, FSM_state *f) { static ulong *ndom = (ulong *) 0; static int on = 0; int i, j, cnt = 0; FSM_state *g; FSM_trans *t; if (on < a->nwords) { on = a->nwords; ndom = (ulong *) emalloc(on * sizeof(ulong)); } for (i = 0; i < a->nwords; i++) ndom[i] = (ulong) ~0; for (t = f->p; t; t = t->nxt) /* all reachable predecessors */ { g = fsm_tbl[t->to]; if (g->seen) for (i = 0; i < a->nwords; i++) ndom[i] &= g->dom[i]; /* (5b) */ } i = f->from / BPW; j = f->from % BPW; /* assert(j <= 32); */ ndom[i] |= (1<nwords; i++) if (f->dom[i] != ndom[i]) { cnt++; f->dom[i] = ndom[i]; } return cnt; } static void dom_forward(AST *a) { FSM_state *f; int cnt; init_dom(a); /* (1,2) */ do { cnt = 0; for (f = a->fsm; f; f = f->nxt) { if (f->seen && f->from != a->i_st) /* (4) */ cnt += dom_perculate(a, f); /* (5) */ } } while (cnt); /* (3) */ dom_perculate(a, fsm_tbl[a->i_st]); } static void AST_dominant(void) { FSM_state *f; FSM_trans *t; AST *a; int oi; static FSM_state no_state; #if 0 find dominators Aho, Sethi, & Ullman, Compilers - principles, techniques, and tools Addison-Wesley, 1986, p.671. (1) D(s0) = {s0} (2) for s in S - {s0} do D(s) = S (3) while any D(s) changes do (4) for s in S - {s0} do (5) D(s) = {s} union with intersection of all D(p) where p are the immediate predecessors of s the purpose is to find proper subgraphs (one entry node, one exit node) #endif if (AST_Round == 1) /* computed once, reused in every round */ for (a = ast; a; a = a->nxt) { a->nstates = 0; for (f = a->fsm; f; f = f->nxt) { a->nstates++; /* count */ fsm_tbl[f->from] = f; /* fast lookup */ f->scratch = 0; /* clear scratch marks */ } for (oi = 0; oi < a->nstates; oi++) if (!fsm_tbl[oi]) fsm_tbl[oi] = &no_state; a->nwords = (a->nstates + BPW - 1) / BPW; /* round up */ if (verbose&32) { printf("%s (%d): ", a->p->n->name, a->i_st); printf("states=%d (max %d), words = %d, bpw %d, overflow %d\n", a->nstates, o_max, a->nwords, (int) BPW, (int) (a->nstates % BPW)); } reachability(a); dom_forward(a); /* forward dominance relation */ curtail(a); /* mark ineligible edges */ for (f = a->fsm; f; f = f->nxt) { t = f->p; f->p = f->t; f->t = t; /* invert edges */ f->mod = f->dom; f->dom = (ulong *) 0; } oi = a->i_st; if (fsm_tbl[0]->seen) /* end-state reachable - else leave it */ a->i_st = 0; /* becomes initial state */ dom_forward(a); /* reverse dominance -- don't redo reachability! */ act_dom(a); /* mark proper subgraphs, if any */ AST_checkpairs(a); /* selectively place 2 scratch-marks */ for (f = a->fsm; f; f = f->nxt) { t = f->p; f->p = f->t; f->t = t; /* restore */ } a->i_st = oi; /* restore */ } else for (a = ast; a; a = a->nxt) { for (f = a->fsm; f; f = f->nxt) { fsm_tbl[f->from] = f; f->scratch &= 1; /* preserve 1-marks */ } for (oi = 0; oi < a->nstates; oi++) if (!fsm_tbl[oi]) fsm_tbl[oi] = &no_state; curtail(a); /* mark ineligible edges */ for (f = a->fsm; f; f = f->nxt) { t = f->p; f->p = f->t; f->t = t; /* invert edges */ } AST_checkpairs(a); /* recompute 2-marks */ for (f = a->fsm; f; f = f->nxt) { t = f->p; f->p = f->t; f->t = t; /* restore */ } } } Spin/Src6.4.5/tl_rewrt.c0000664000175100017510000001305612641605057012714 0ustar ghgh/***** tl_spin: tl_rewrt.c *****/ /* * This file is part of the public release of Spin. It is subject to the * terms in the LICENSE file that is included in this source directory. * Tool documentation is available at http://spinroot.com * * Based on the translation algorithm by Gerth, Peled, Vardi, and Wolper, * presented at the PSTV Conference, held in 1995, Warsaw, Poland 1995. */ #include "tl.h" extern int tl_verbose; static Node *can = ZN; void ini_rewrt(void) { can = ZN; } Node * right_linked(Node *n) { if (!n) return n; if (n->ntyp == AND || n->ntyp == OR) while (n->lft && n->lft->ntyp == n->ntyp) { Node *tmp = n->lft; n->lft = tmp->rgt; tmp->rgt = n; n = tmp; } n->lft = right_linked(n->lft); n->rgt = right_linked(n->rgt); return n; } Node * canonical(Node *n) { Node *m; /* assumes input is right_linked */ if (!n) return n; if ((m = in_cache(n)) != ZN) return m; n->rgt = canonical(n->rgt); n->lft = canonical(n->lft); return cached(n); } Node * push_negation(Node *n) { Node *m; Assert(n->ntyp == NOT, n->ntyp); switch (n->lft->ntyp) { case TRUE: Debug("!true => false\n"); releasenode(0, n->lft); n->lft = ZN; n->ntyp = FALSE; break; case FALSE: Debug("!false => true\n"); releasenode(0, n->lft); n->lft = ZN; n->ntyp = TRUE; break; case NOT: Debug("!!p => p\n"); m = n->lft->lft; releasenode(0, n->lft); n->lft = ZN; releasenode(0, n); n = m; break; case V_OPER: Debug("!(p V q) => (!p U !q)\n"); n->ntyp = U_OPER; goto same; case U_OPER: Debug("!(p U q) => (!p V !q)\n"); n->ntyp = V_OPER; goto same; #ifdef NXT case NEXT: Debug("!X -> X!\n"); n->ntyp = NEXT; n->lft->ntyp = NOT; n->lft = push_negation(n->lft); break; #endif case AND: Debug("!(p && q) => !p || !q\n"); n->ntyp = OR; goto same; case OR: Debug("!(p || q) => !p && !q\n"); n->ntyp = AND; same: m = n->lft->rgt; n->lft->rgt = ZN; n->rgt = Not(m); n->lft->ntyp = NOT; m = n->lft; n->lft = push_negation(m); break; } return rewrite(n); } static void addcan(int tok, Node *n) { Node *m, *prev = ZN; Node **ptr; Node *N; Symbol *s, *t; int cmp; if (!n) return; if (n->ntyp == tok) { addcan(tok, n->rgt); addcan(tok, n->lft); return; } N = dupnode(n); if (!can) { can = N; return; } s = DoDump(N); if (!s) { fatal("unexpected error 6", (char *) 0); } if (can->ntyp != tok) /* only one element in list so far */ { ptr = &can; goto insert; } /* there are at least 2 elements in list */ prev = ZN; for (m = can; m->ntyp == tok && m->rgt; prev = m, m = m->rgt) { t = DoDump(m->lft); if (t != ZS) cmp = strcmp(s->name, t->name); else cmp = 0; if (cmp == 0) /* duplicate */ return; if (cmp < 0) { if (!prev) { can = tl_nn(tok, N, can); return; } else { ptr = &(prev->rgt); goto insert; } } } /* new entry goes at the end of the list */ ptr = &(prev->rgt); insert: t = DoDump(*ptr); cmp = strcmp(s->name, t->name); if (cmp == 0) /* duplicate */ return; if (cmp < 0) *ptr = tl_nn(tok, N, *ptr); else *ptr = tl_nn(tok, *ptr, N); } static void marknode(int tok, Node *m) { if (m->ntyp != tok) { releasenode(0, m->rgt); m->rgt = ZN; } m->ntyp = -1; } Node * Canonical(Node *n) { Node *m, *p, *k1, *k2, *prev, *dflt = ZN; int tok; if (!n) return n; tok = n->ntyp; if (tok != AND && tok != OR) return n; can = ZN; addcan(tok, n); #if 0 Debug("\nA0: "); Dump(can); Debug("\nA1: "); Dump(n); Debug("\n"); #endif releasenode(1, n); /* mark redundant nodes */ if (tok == AND) { for (m = can; m; m = (m->ntyp == AND) ? m->rgt : ZN) { k1 = (m->ntyp == AND) ? m->lft : m; if (k1->ntyp == TRUE) { marknode(AND, m); dflt = True; continue; } if (k1->ntyp == FALSE) { releasenode(1, can); can = False; goto out; } } for (m = can; m; m = (m->ntyp == AND) ? m->rgt : ZN) for (p = can; p; p = (p->ntyp == AND) ? p->rgt : ZN) { if (p == m || p->ntyp == -1 || m->ntyp == -1) continue; k1 = (m->ntyp == AND) ? m->lft : m; k2 = (p->ntyp == AND) ? p->lft : p; if (isequal(k1, k2)) { marknode(AND, p); continue; } if (anywhere(OR, k1, k2)) { marknode(AND, p); continue; } } } if (tok == OR) { for (m = can; m; m = (m->ntyp == OR) ? m->rgt : ZN) { k1 = (m->ntyp == OR) ? m->lft : m; if (k1->ntyp == FALSE) { marknode(OR, m); dflt = False; continue; } if (k1->ntyp == TRUE) { releasenode(1, can); can = True; goto out; } } for (m = can; m; m = (m->ntyp == OR) ? m->rgt : ZN) for (p = can; p; p = (p->ntyp == OR) ? p->rgt : ZN) { if (p == m || p->ntyp == -1 || m->ntyp == -1) continue; k1 = (m->ntyp == OR) ? m->lft : m; k2 = (p->ntyp == OR) ? p->lft : p; if (isequal(k1, k2)) { marknode(OR, p); continue; } if (anywhere(AND, k1, k2)) { marknode(OR, p); continue; } } } for (m = can, prev = ZN; m; ) /* remove marked nodes */ { if (m->ntyp == -1) { k2 = m->rgt; releasenode(0, m); if (!prev) { m = can = can->rgt; } else { m = prev->rgt = k2; /* if deleted the last node in a chain */ if (!prev->rgt && prev->lft && (prev->ntyp == AND || prev->ntyp == OR)) { k1 = prev->lft; prev->ntyp = prev->lft->ntyp; prev->sym = prev->lft->sym; prev->rgt = prev->lft->rgt; prev->lft = prev->lft->lft; releasenode(0, k1); } } continue; } prev = m; m = m->rgt; } out: #if 0 Debug("A2: "); Dump(can); Debug("\n"); #endif if (!can) { if (!dflt) fatal("cannot happen, Canonical", (char *) 0); return dflt; } return can; } Spin/Src6.4.5/make320000664000175100017510000000331412641605057011707 0ustar ghgh# SPIN - Verification Software - Version 6.4 - January 2016 # # This file is part of the public release of Spin. It is subject to the # terms in the LICENSE file that is included in this source directory. # Tool documentation is available at http://spinroot.com # # see also ./make_pc for a alternate script not requiring make CC=gcc CC=gcc -m32 # 32bit compilation on a 64bit system CFLAGS=-O2 -DNXT # on some systems add: -I/usr/include # on a PC: add -DPC # on Solaris: add -DSOLARIS # on a Mac: add -DMAC # on HP-UX: add -Aa # CFLAGS=-pg -g -DNXT # for a more picky compilation use gcc-4 and add: PICKY=-std=c99 -Wstrict-prototypes -pedantic -fno-strength-reduce \ -fno-builtin -W -Wshadow -Wpointer-arith \ -Wcast-qual -Winline -Wall # when running spin with a different compiler: # on OS2: spin -Picc -E/Pd+ -E/Q+ # for Visual C++: spin -PCL -E/E YACC=yacc # on Solaris: /usr/ccs/bin/yacc YFLAGS=-v -d # creates y.output and y.tab.h SPIN_OS= spinlex.o sym.o vars.o main.o msc_tcl.o \ mesg.o flow.o sched.o run.o pangen1.o pangen2.o \ pangen3.o pangen4.o pangen5.o guided.o dstep.o \ structs.o pangen6.o pangen7.o reprosrc.o TL_OS= tl_parse.o tl_lex.o tl_main.o tl_trans.o tl_buchi.o \ tl_mem.o tl_rewrt.o tl_cache.o spin: $(SPIN_OS) $(TL_OS) spin.o $(CC) $(CFLAGS) -o spin spin.o $(SPIN_OS) $(TL_OS) spin.o: spin.y $(YACC) $(YFLAGS) spin.y $(CC) $(CFLAGS) -c y?tab.c rm -f y?tab.c mv y?tab.o spin.o $(SPIN_OS): spin.h spin.o $(TL_OS): tl.h spin.o main.o pangen2.o msc_tcl.o: version.h pangen1.o: pangen1.h pangen3.h pangen6.h pangen2.o: pangen2.h pangen4.h pangen5.h pangen7.h clean: rm -f spin *.o y?tab.[ch] y.output y.debug rm -f pan.[chmotb] a.out core *stackdump Spin/Src6.4.5/flow.c0000664000175100017510000006101112641605057012013 0ustar ghgh/***** spin: flow.c *****/ /* * This file is part of the public release of Spin. It is subject to the * terms in the LICENSE file that is included in this source directory. * Tool documentation is available at http://spinroot.com */ #include "spin.h" #include "y.tab.h" extern Symbol *Fname; extern int nr_errs, lineno, verbose, in_for, old_scope_rules, s_trail; extern short has_unless, has_badelse, has_xu; extern char CurScope[MAXSCOPESZ]; Element *Al_El = ZE; Label *labtab = (Label *) 0; int Unique = 0, Elcnt = 0, DstepStart = -1; int initialization_ok = 1; short has_accept; static Lbreak *breakstack = (Lbreak *) 0; static Lextok *innermost; static SeqList *cur_s = (SeqList *) 0; static int break_id=0; static Element *if_seq(Lextok *); static Element *new_el(Lextok *); static Element *unless_seq(Lextok *); static void add_el(Element *, Sequence *); static void attach_escape(Sequence *, Sequence *); static void mov_lab(Symbol *, Element *, Element *); static void walk_atomic(Element *, Element *, int); void open_seq(int top) { SeqList *t; Sequence *s = (Sequence *) emalloc(sizeof(Sequence)); s->minel = -1; t = seqlist(s, cur_s); cur_s = t; if (top) { Elcnt = 1; initialization_ok = 1; } } void rem_Seq(void) { DstepStart = Unique; } void unrem_Seq(void) { DstepStart = -1; } static int Rjumpslocal(Element *q, Element *stop) { Element *lb, *f; SeqList *h; /* allow no jumps out of a d_step sequence */ for (f = q; f && f != stop; f = f->nxt) { if (f && f->n && f->n->ntyp == GOTO) { lb = get_lab(f->n, 0); if (!lb || lb->Seqno < DstepStart) { lineno = f->n->ln; Fname = f->n->fn; return 0; } } for (h = f->sub; h; h = h->nxt) { if (!Rjumpslocal(h->this->frst, h->this->last)) return 0; } } return 1; } void cross_dsteps(Lextok *a, Lextok *b) { if (a && b && a->indstep != b->indstep) { lineno = a->ln; Fname = a->fn; if (!s_trail) fatal("jump into d_step sequence", (char *) 0); } } int is_skip(Lextok *n) { return (n->ntyp == PRINT || n->ntyp == PRINTM || (n->ntyp == 'c' && n->lft && n->lft->ntyp == CONST && n->lft->val == 1)); } void check_sequence(Sequence *s) { Element *e, *le = ZE; Lextok *n; int cnt = 0; for (e = s->frst; e; le = e, e = e->nxt) { n = e->n; if (is_skip(n) && !has_lab(e, 0)) { cnt++; if (cnt > 1 && n->ntyp != PRINT && n->ntyp != PRINTM) { if (verbose&32) printf("spin: %s:%d, redundant skip\n", n->fn->name, n->ln); if (e != s->frst && e != s->last && e != s->extent) { e->status |= DONE; /* not unreachable */ le->nxt = e->nxt; /* remove it */ e = le; } } } else cnt = 0; } } void prune_opts(Lextok *n) { SeqList *l; extern Symbol *context; extern char *claimproc; if (!n || (context && claimproc && strcmp(context->name, claimproc) == 0)) return; for (l = n->sl; l; l = l->nxt) /* find sequences of unlabeled skips */ check_sequence(l->this); } Sequence * close_seq(int nottop) { Sequence *s = cur_s->this; Symbol *z; if (nottop == 0) /* end of proctype body */ { initialization_ok = 1; } if (nottop > 0 && s->frst && (z = has_lab(s->frst, 0))) { printf("error: (%s:%d) label %s placed incorrectly\n", (s->frst->n)?s->frst->n->fn->name:"-", (s->frst->n)?s->frst->n->ln:0, z->name); switch (nottop) { case 1: printf("=====> stmnt unless Label: stmnt\n"); printf("sorry, cannot jump to the guard of an\n"); printf("escape (it is not a unique state)\n"); break; case 2: printf("=====> instead of "); printf("\"Label: stmnt unless stmnt\"\n"); printf("=====> always use "); printf("\"Label: { stmnt unless stmnt }\"\n"); break; case 3: printf("=====> instead of "); printf("\"atomic { Label: statement ... }\"\n"); printf("=====> always use "); printf("\"Label: atomic { statement ... }\"\n"); break; case 4: printf("=====> instead of "); printf("\"d_step { Label: statement ... }\"\n"); printf("=====> always use "); printf("\"Label: d_step { statement ... }\"\n"); break; case 5: printf("=====> instead of "); printf("\"{ Label: statement ... }\"\n"); printf("=====> always use "); printf("\"Label: { statement ... }\"\n"); break; case 6: printf("=====> instead of\n"); printf(" do (or if)\n"); printf(" :: ...\n"); printf(" :: Label: statement\n"); printf(" od (of fi)\n"); printf("=====> use\n"); printf("Label: do (or if)\n"); printf(" :: ...\n"); printf(" :: statement\n"); printf(" od (or fi)\n"); break; case 7: printf("cannot happen - labels\n"); break; } if (nottop != 6) { alldone(1); } } if (nottop == 4 && !Rjumpslocal(s->frst, s->last)) fatal("non_local jump in d_step sequence", (char *) 0); cur_s = cur_s->nxt; s->maxel = Elcnt; s->extent = s->last; if (!s->last) fatal("sequence must have at least one statement", (char *) 0); return s; } Lextok * do_unless(Lextok *No, Lextok *Es) { SeqList *Sl; Lextok *Re = nn(ZN, UNLESS, ZN, ZN); Re->ln = No->ln; Re->fn = No->fn; has_unless++; if (Es->ntyp == NON_ATOMIC) { Sl = Es->sl; } else { open_seq(0); add_seq(Es); Sl = seqlist(close_seq(1), 0); } if (No->ntyp == NON_ATOMIC) { No->sl->nxt = Sl; Sl = No->sl; } else if (No->ntyp == ':' && (No->lft->ntyp == NON_ATOMIC || No->lft->ntyp == ATOMIC || No->lft->ntyp == D_STEP)) { int tok = No->lft->ntyp; No->lft->sl->nxt = Sl; Re->sl = No->lft->sl; open_seq(0); add_seq(Re); Re = nn(ZN, tok, ZN, ZN); Re->sl = seqlist(close_seq(7), 0); Re->ln = No->ln; Re->fn = No->fn; Re = nn(No, ':', Re, ZN); /* lift label */ Re->ln = No->ln; Re->fn = No->fn; return Re; } else { open_seq(0); add_seq(No); Sl = seqlist(close_seq(2), Sl); } Re->sl = Sl; return Re; } SeqList * seqlist(Sequence *s, SeqList *r) { SeqList *t = (SeqList *) emalloc(sizeof(SeqList)); t->this = s; t->nxt = r; return t; } static Element * new_el(Lextok *n) { Element *m; if (n) { if (n->ntyp == IF || n->ntyp == DO) return if_seq(n); if (n->ntyp == UNLESS) return unless_seq(n); } m = (Element *) emalloc(sizeof(Element)); m->n = n; m->seqno = Elcnt++; m->Seqno = Unique++; m->Nxt = Al_El; Al_El = m; return m; } static int has_chanref(Lextok *n) { if (!n) return 0; switch (n->ntyp) { case 's': case 'r': #if 0 case 'R': case LEN: #endif case FULL: case NFULL: case EMPTY: case NEMPTY: return 1; default: break; } if (has_chanref(n->lft)) return 1; return has_chanref(n->rgt); } void loose_ends(void) /* properly tie-up ends of sub-sequences */ { Element *e, *f; for (e = Al_El; e; e = e->Nxt) { if (!e->n || !e->nxt) continue; switch (e->n->ntyp) { case ATOMIC: case NON_ATOMIC: case D_STEP: f = e->nxt; while (f && f->n->ntyp == '.') f = f->nxt; if (0) printf("link %d, {%d .. %d} -> %d (ntyp=%d) was %d\n", e->seqno, e->n->sl->this->frst->seqno, e->n->sl->this->last->seqno, f?f->seqno:-1, f?f->n->ntyp:-1, e->n->sl->this->last->nxt?e->n->sl->this->last->nxt->seqno:-1); if (!e->n->sl->this->last->nxt) e->n->sl->this->last->nxt = f; else { if (e->n->sl->this->last->nxt->n->ntyp != GOTO) { if (!f || e->n->sl->this->last->nxt->seqno != f->seqno) non_fatal("unexpected: loose ends", (char *)0); } else e->n->sl->this->last = e->n->sl->this->last->nxt; /* * fix_dest can push a goto into the nxt position * in that case the goto wins and f is not needed * but the last fields needs adjusting */ } break; } } } void popbreak(void) { if (!breakstack) fatal("cannot happen, breakstack", (char *) 0); breakstack = breakstack->nxt; /* pop stack */ } static Lbreak *ob = (Lbreak *) 0; void safe_break(void) { ob = breakstack; popbreak(); } void restore_break(void) { breakstack = ob; ob = (Lbreak *) 0; } static Element * if_seq(Lextok *n) { int tok = n->ntyp; SeqList *s = n->sl; Element *e = new_el(ZN); Element *t = new_el(nn(ZN,'.',ZN,ZN)); /* target */ SeqList *z, *prev_z = (SeqList *) 0; SeqList *move_else = (SeqList *) 0; /* to end of optionlist */ int ref_chans = 0; for (z = s; z; z = z->nxt) { if (!z->this->frst) continue; if (z->this->frst->n->ntyp == ELSE) { if (move_else) fatal("duplicate `else'", (char *) 0); if (z->nxt) /* is not already at the end */ { move_else = z; if (prev_z) prev_z->nxt = z->nxt; else s = n->sl = z->nxt; continue; } } else ref_chans |= has_chanref(z->this->frst->n); prev_z = z; } if (move_else) { move_else->nxt = (SeqList *) 0; /* if there is no prev, then else was at the end */ if (!prev_z) fatal("cannot happen - if_seq", (char *) 0); prev_z->nxt = move_else; prev_z = move_else; } if (prev_z && ref_chans && prev_z->this->frst->n->ntyp == ELSE) { prev_z->this->frst->n->val = 1; has_badelse++; if (has_xu) { fatal("invalid use of 'else' combined with i/o and xr/xs assertions,", (char *)0); } else { non_fatal("dubious use of 'else' combined with i/o,", (char *)0); } nr_errs--; } e->n = nn(n, tok, ZN, ZN); e->n->sl = s; /* preserve as info only */ e->sub = s; for (z = s; z; z = z->nxt) add_el(t, z->this); /* append target */ if (tok == DO) { add_el(t, cur_s->this); /* target upfront */ t = new_el(nn(n, BREAK, ZN, ZN)); /* break target */ set_lab(break_dest(), t); /* new exit */ popbreak(); } add_el(e, cur_s->this); add_el(t, cur_s->this); return e; /* destination node for label */ } static void escape_el(Element *f, Sequence *e) { SeqList *z; for (z = f->esc; z; z = z->nxt) if (z->this == e) return; /* already there */ /* cover the lower-level escapes of this state */ for (z = f->esc; z; z = z->nxt) attach_escape(z->this, e); /* now attach escape to the state itself */ f->esc = seqlist(e, f->esc); /* in lifo order... */ #ifdef DEBUG printf("attach %d (", e->frst->Seqno); comment(stdout, e->frst->n, 0); printf(") to %d (", f->Seqno); comment(stdout, f->n, 0); printf(")\n"); #endif switch (f->n->ntyp) { case UNLESS: attach_escape(f->sub->this, e); break; case IF: case DO: for (z = f->sub; z; z = z->nxt) attach_escape(z->this, e); break; case D_STEP: /* attach only to the guard stmnt */ escape_el(f->n->sl->this->frst, e); break; case ATOMIC: case NON_ATOMIC: /* attach to all stmnts */ attach_escape(f->n->sl->this, e); break; } } static void attach_escape(Sequence *n, Sequence *e) { Element *f; for (f = n->frst; f; f = f->nxt) { escape_el(f, e); if (f == n->extent) break; } } static Element * unless_seq(Lextok *n) { SeqList *s = n->sl; Element *e = new_el(ZN); Element *t = new_el(nn(ZN,'.',ZN,ZN)); /* target */ SeqList *z; e->n = nn(n, UNLESS, ZN, ZN); e->n->sl = s; /* info only */ e->sub = s; /* need 2 sequences: normal execution and escape */ if (!s || !s->nxt || s->nxt->nxt) fatal("unexpected unless structure", (char *)0); /* append the target state to both */ for (z = s; z; z = z->nxt) add_el(t, z->this); /* attach escapes to all states in normal sequence */ attach_escape(s->this, s->nxt->this); add_el(e, cur_s->this); add_el(t, cur_s->this); #ifdef DEBUG printf("unless element (%d,%d):\n", e->Seqno, t->Seqno); for (z = s; z; z = z->nxt) { Element *x; printf("\t%d,%d,%d :: ", z->this->frst->Seqno, z->this->extent->Seqno, z->this->last->Seqno); for (x = z->this->frst; x; x = x->nxt) printf("(%d)", x->Seqno); printf("\n"); } #endif return e; } Element * mk_skip(void) { Lextok *t = nn(ZN, CONST, ZN, ZN); t->val = 1; return new_el(nn(ZN, 'c', t, ZN)); } static void add_el(Element *e, Sequence *s) { if (e->n->ntyp == GOTO) { Symbol *z = has_lab(e, (1|2|4)); if (z) { Element *y; /* insert a skip */ y = mk_skip(); mov_lab(z, e, y); /* inherit label */ add_el(y, s); } } #ifdef DEBUG printf("add_el %d after %d -- ", e->Seqno, (s->last)?s->last->Seqno:-1); comment(stdout, e->n, 0); printf("\n"); #endif if (!s->frst) s->frst = e; else s->last->nxt = e; s->last = e; } static Element * colons(Lextok *n) { if (!n) return ZE; if (n->ntyp == ':') { Element *e = colons(n->lft); set_lab(n->sym, e); return e; } innermost = n; return new_el(n); } void add_seq(Lextok *n) { Element *e; if (!n) return; innermost = n; e = colons(n); if (innermost->ntyp != IF && innermost->ntyp != DO && innermost->ntyp != UNLESS) add_el(e, cur_s->this); } void set_lab(Symbol *s, Element *e) { Label *l; extern Symbol *context; int cur_uiid = is_inline(); if (!s) return; for (l = labtab; l; l = l->nxt) { if (strcmp(l->s->name, s->name) == 0 && l->c == context && (old_scope_rules || strcmp((const char *) s->bscp, (const char *) l->s->bscp) == 0) && l->uiid == cur_uiid) { non_fatal("label %s redeclared", s->name); break; } } if (strncmp(s->name, "accept", 6) == 0 && strncmp(s->name, "accept_all", 10) != 0) { has_accept = 1; } l = (Label *) emalloc(sizeof(Label)); l->s = s; l->c = context; l->e = e; l->uiid = cur_uiid; l->nxt = labtab; labtab = l; } static Label * get_labspec(Lextok *n) { Symbol *s = n->sym; Label *l, *anymatch = (Label *) 0; int ln; /* * try to find a label with the same inline id (uiid) * but if it doesn't exist, return any other match * within the same scope */ for (l = labtab; l; l = l->nxt) { if (strcmp(l->s->name, s->name) == 0 /* labelname matches */ && s->context == l->s->context) /* same scope */ { #if 0 if (anymatch && n->uiid == anymatch->uiid) { if (0) non_fatal("label %s re-declared", s->name); } if (0) { printf("Label %s uiid now::then %d :: %d bcsp %s :: %s\n", s->name, n->uiid, l->uiid, s->bscp, l->s->bscp); printf("get_labspec match on %s %s (bscp goto %s - label %s)\n", s->name, s->context->name, s->bscp, l->s->bscp); } #endif /* same block scope */ if (strcmp((const char *) s->bscp, (const char *) l->s->bscp) == 0) { return l; /* definite match */ } /* higher block scope */ ln = strlen((const char *) l->s->bscp); if (strncmp((const char *) s->bscp, (const char *) l->s->bscp, ln) == 0) { anymatch = l; /* possible match */ } else if (!anymatch) { anymatch = l; /* somewhere else in same context */ } } } return anymatch; /* return best match */ } Element * get_lab(Lextok *n, int md) { Label *l = get_labspec(n); if (l != (Label *) 0) { return (l->e); } if (md) { lineno = n->ln; Fname = n->fn; fatal("undefined label %s", n->sym->name); } return ZE; } Symbol * has_lab(Element *e, int special) { Label *l; for (l = labtab; l; l = l->nxt) { if (e != l->e) continue; if (special == 0 || ((special&1) && !strncmp(l->s->name, "accept", 6)) || ((special&2) && !strncmp(l->s->name, "end", 3)) || ((special&4) && !strncmp(l->s->name, "progress", 8))) return (l->s); } return ZS; } static void mov_lab(Symbol *z, Element *e, Element *y) { Label *l; for (l = labtab; l; l = l->nxt) if (e == l->e) { l->e = y; return; } if (e->n) { lineno = e->n->ln; Fname = e->n->fn; } fatal("cannot happen - mov_lab %s", z->name); } void fix_dest(Symbol *c, Symbol *a) /* c:label name, a:proctype name */ { Label *l; extern Symbol *context; #if 0 printf("ref to label '%s' in proctype '%s', search:\n", c->name, a->name); for (l = labtab; l; l = l->nxt) printf(" %s in %s\n", l->s->name, l->c->name); #endif for (l = labtab; l; l = l->nxt) { if (strcmp(c->name, l->s->name) == 0 && strcmp(a->name, l->c->name) == 0) /* ? */ break; } if (!l) { printf("spin: label '%s' (proctype %s)\n", c->name, a->name); non_fatal("unknown label '%s'", c->name); if (context == a) printf("spin: cannot remote ref a label inside the same proctype\n"); return; } if (!l->e || !l->e->n) fatal("fix_dest error (%s)", c->name); if (l->e->n->ntyp == GOTO) { Element *y = (Element *) emalloc(sizeof(Element)); int keep_ln = l->e->n->ln; Symbol *keep_fn = l->e->n->fn; /* insert skip - or target is optimized away */ y->n = l->e->n; /* copy of the goto */ y->seqno = find_maxel(a); /* unique seqno within proc */ y->nxt = l->e->nxt; y->Seqno = Unique++; y->Nxt = Al_El; Al_El = y; /* turn the original element+seqno into a skip */ l->e->n = nn(ZN, 'c', nn(ZN, CONST, ZN, ZN), ZN); l->e->n->ln = l->e->n->lft->ln = keep_ln; l->e->n->fn = l->e->n->lft->fn = keep_fn; l->e->n->lft->val = 1; l->e->nxt = y; /* append the goto */ } l->e->status |= CHECK2; /* treat as if global */ if (l->e->status & (ATOM | L_ATOM | D_ATOM)) { printf("spin: %s:%d, warning, reference to label ", Fname->name, lineno); printf("from inside atomic or d_step (%s)\n", c->name); } } int find_lab(Symbol *s, Symbol *c, int markit) { Label *l, *pm = (Label *) 0, *apm = (Label *) 0; int ln; /* generally called for remote references in never claims */ for (l = labtab; l; l = l->nxt) { if (strcmp(s->name, l->s->name) == 0 && strcmp(c->name, l->c->name) == 0) { ln = strlen((const char *) l->s->bscp); if (0) { printf("want '%s' in context '%s', scope ref '%s' - label '%s'\n", s->name, c->name, s->bscp, l->s->bscp); } /* same or higher block scope */ if (strcmp((const char *) s->bscp, (const char *) l->s->bscp) == 0) { pm = l; /* definite match */ break; } if (strncmp((const char *) s->bscp, (const char *) l->s->bscp, ln) == 0) { pm = l; /* possible match */ } else { apm = l; /* remote */ } } } if (pm) { pm->visible |= markit; return pm->e->seqno; } if (apm) { apm->visible |= markit; return apm->e->seqno; } /* else printf("Not Found\n"); */ return 0; } void pushbreak(void) { Lbreak *r = (Lbreak *) emalloc(sizeof(Lbreak)); Symbol *l; char buf[64]; sprintf(buf, ":b%d", break_id++); l = lookup(buf); r->l = l; r->nxt = breakstack; breakstack = r; } Symbol * break_dest(void) { if (!breakstack) fatal("misplaced break statement", (char *)0); return breakstack->l; } void make_atomic(Sequence *s, int added) { Element *f; walk_atomic(s->frst, s->last, added); f = s->last; switch (f->n->ntyp) { /* is last step basic stmnt or sequence ? */ case NON_ATOMIC: case ATOMIC: /* redo and search for the last step of that sequence */ make_atomic(f->n->sl->this, added); break; case UNLESS: /* escapes are folded into main sequence */ make_atomic(f->sub->this, added); break; default: f->status &= ~ATOM; f->status |= L_ATOM; break; } } #if 0 static int depth = 0; void dump_sym(Symbol *, char *); void dump_lex(Lextok *t, char *s) { int i; depth++; printf(s); for (i = 0; i < depth; i++) printf("\t"); explain(t->ntyp); if (t->ntyp == NAME) printf(" %s ", t->sym->name); if (t->ntyp == CONST) printf(" %d ", t->val); if (t->ntyp == STRUCT) { dump_sym(t->sym, "\n:Z:"); } if (t->lft) { dump_lex(t->lft, "\nL"); } if (t->rgt) { dump_lex(t->rgt, "\nR"); } depth--; } void dump_sym(Symbol *z, char *s) { int i; char txt[64]; depth++; printf(s); for (i = 0; i < depth; i++) printf("\t"); if (z->type == CHAN) { if (z->ini && z->ini->rgt && z->ini->rgt->sym) { /* dump_sym(z->ini->rgt->sym, "\n:I:"); -- could also be longer list */ if (z->ini->rgt->rgt || !z->ini->rgt->sym) fatal("chan %s in for should have only one field (a typedef)", z->name); printf(" -- %s %p -- ", z->ini->rgt->sym->name, z->ini->rgt->sym); } } else if (z->type == STRUCT) { if (z->Snm) printf(" == %s %p == ", z->Snm->name, z->Snm); else { if (z->Slst) dump_lex(z->Slst, "\n:X:"); if (z->ini) dump_lex(z->ini, "\n:I:"); } } depth--; } #endif int match_struct(Symbol *s, Symbol *t) { if (!t || !t->ini || !t->ini->rgt || !t->ini->rgt->sym || t->ini->rgt->rgt) { fatal("chan %s in for should have only one field (a typedef)", t?t->name:"--"); } /* we already know that s is a STRUCT */ if (0) { printf("index type %s %p ==\n", s->Snm->name, s->Snm); printf("chan type %s %p --\n\n", t->ini->rgt->sym->name, t->ini->rgt->sym); } return (s->Snm == t->ini->rgt->sym); } void valid_name(Lextok *a3, Lextok *a5, Lextok *a8, char *tp) { if (a3->ntyp != NAME) { fatal("%s ( .name : from .. to ) { ... }", tp); } if (a3->sym->type == CHAN || a3->sym->type == STRUCT || a3->sym->isarray != 0) { fatal("bad index in for-construct %s", a3->sym->name); } if (a5->ntyp == CONST && a8->ntyp == CONST && a5->val > a8->val) { non_fatal("start value for %s exceeds end-value", a3->sym->name); } } void for_setup(Lextok *a3, Lextok *a5, Lextok *a8) { /* for ( a3 : a5 .. a8 ) */ valid_name(a3, a5, a8, "for"); /* a5->ntyp = a8->ntyp = CONST; */ add_seq(nn(a3, ASGN, a3, a5)); /* start value */ open_seq(0); add_seq(nn(ZN, 'c', nn(a3, LE, a3, a8), ZN)); /* condition */ } Lextok * for_index(Lextok *a3, Lextok *a5) { Lextok *z0, *z1, *z2, *z3; Symbol *tmp_cnt; char tmp_nm[MAXSCOPESZ+16]; /* for ( a3 in a5 ) { ... } */ if (a3->ntyp != NAME) { fatal("for ( .name in name ) { ... }", (char *) 0); } if (a5->ntyp != NAME) { fatal("for ( %s in .name ) { ... }", a3->sym->name); } if (a3->sym->type == STRUCT) { if (a5->sym->type != CHAN) { fatal("for ( %s in .channel_name ) { ... }", a3->sym->name); } z0 = a5->sym->ini; if (!z0 || z0->val <= 0 || z0->rgt->ntyp != STRUCT || z0->rgt->rgt != NULL) { fatal("bad channel type %s in for", a5->sym->name); } if (!match_struct(a3->sym, a5->sym)) { fatal("type of %s does not match chan", a3->sym->name); } z1 = nn(ZN, CONST, ZN, ZN); z1->val = 0; z2 = nn(a5, LEN, a5, ZN); sprintf(tmp_nm, "_f0r_t3mp%s", CurScope); /* make sure it's unique */ tmp_cnt = lookup(tmp_nm); if (z0->val > 255) /* check nr of slots, i.e. max length */ { tmp_cnt->type = SHORT; /* should be rare */ } else { tmp_cnt->type = BYTE; } z3 = nn(ZN, NAME, ZN, ZN); z3->sym = tmp_cnt; add_seq(nn(z3, ASGN, z3, z1)); /* start value 0 */ open_seq(0); add_seq(nn(ZN, 'c', nn(z3, LT, z3, z2), ZN)); /* condition */ /* retrieve message from the right slot -- for now: rotate contents */ in_for = 0; add_seq(nn(a5, 'r', a5, expand(a3, 1))); /* receive */ add_seq(nn(a5, 's', a5, expand(a3, 1))); /* put back in to rotate */ in_for = 1; return z3; } else { if (a5->sym->isarray == 0 || a5->sym->nel <= 0) { fatal("bad arrayname %s", a5->sym->name); } z1 = nn(ZN, CONST, ZN, ZN); z1->val = 0; z2 = nn(ZN, CONST, ZN, ZN); z2->val = a5->sym->nel - 1; for_setup(a3, z1, z2); return a3; } } Lextok * for_body(Lextok *a3, int with_else) { Lextok *t1, *t2, *t0, *rv; rv = nn(ZN, CONST, ZN, ZN); rv->val = 1; rv = nn(ZN, '+', a3, rv); rv = nn(a3, ASGN, a3, rv); add_seq(rv); /* initial increment */ /* completed loop body, main sequence */ t1 = nn(ZN, 0, ZN, ZN); t1->sq = close_seq(8); open_seq(0); /* add else -> break sequence */ if (with_else) { add_seq(nn(ZN, ELSE, ZN, ZN)); } t2 = nn(ZN, GOTO, ZN, ZN); t2->sym = break_dest(); add_seq(t2); t2 = nn(ZN, 0, ZN, ZN); t2->sq = close_seq(9); t0 = nn(ZN, 0, ZN, ZN); t0->sl = seqlist(t2->sq, seqlist(t1->sq, 0)); rv = nn(ZN, DO, ZN, ZN); rv->sl = t0->sl; return rv; } Lextok * sel_index(Lextok *a3, Lextok *a5, Lextok *a7) { /* select ( a3 : a5 .. a7 ) */ valid_name(a3, a5, a7, "select"); /* a5->ntyp = a7->ntyp = CONST; */ add_seq(nn(a3, ASGN, a3, a5)); /* start value */ open_seq(0); add_seq(nn(ZN, 'c', nn(a3, LT, a3, a7), ZN)); /* condition */ pushbreak(); /* new 6.2.1 */ return for_body(a3, 0); /* no else, just a non-deterministic break */ } static void walk_atomic(Element *a, Element *b, int added) { Element *f; Symbol *ofn; int oln; SeqList *h; ofn = Fname; oln = lineno; for (f = a; ; f = f->nxt) { f->status |= (ATOM|added); switch (f->n->ntyp) { case ATOMIC: if (verbose&32) printf("spin: %s:%d, warning, atomic inside %s (ignored)\n", f->n->fn->name, f->n->ln, (added)?"d_step":"atomic"); goto mknonat; case D_STEP: if (!(verbose&32)) { if (added) goto mknonat; break; } printf("spin: %s:%d, warning, d_step inside ", f->n->fn->name, f->n->ln); if (added) { printf("d_step (ignored)\n"); goto mknonat; } printf("atomic\n"); break; case NON_ATOMIC: mknonat: f->n->ntyp = NON_ATOMIC; /* can jump here */ h = f->n->sl; walk_atomic(h->this->frst, h->this->last, added); break; case UNLESS: if (added) { printf("spin: error, %s:%d, unless in d_step (ignored)\n", f->n->fn->name, f->n->ln); } } for (h = f->sub; h; h = h->nxt) walk_atomic(h->this->frst, h->this->last, added); if (f == b) break; } Fname = ofn; lineno = oln; } void dumplabels(void) { Label *l; for (l = labtab; l; l = l->nxt) if (l->c != 0 && l->s->name[0] != ':') { printf("label %s %d ", l->s->name, l->e->seqno); if (l->uiid == 0) printf("<%s>", l->c->name); else printf("<%s i%d>", l->c->name, l->uiid); if (!old_scope_rules) { printf("\t{scope %s}", l->s->bscp); } printf("\n"); } } Spin/Src6.4.5/pangen3.c0000664000175100017510000002523712641605057012411 0ustar ghgh/***** spin: pangen3.c *****/ /* * This file is part of the public release of Spin. It is subject to the * terms in the LICENSE file that is included in this source directory. * Tool documentation is available at http://spinroot.com */ #include "spin.h" #include "y.tab.h" #include extern FILE *th, *tc; extern int eventmapnr, old_priority_rules; typedef struct SRC { int ln, st; /* linenr, statenr */ Symbol *fn; /* filename */ struct SRC *nxt; } SRC; static int col; static Symbol *lastfnm; static Symbol lastdef; static int lastfrom; static SRC *frst = (SRC *) 0; static SRC *skip = (SRC *) 0; extern int ltl_mode; extern void sr_mesg(FILE *, int, int); static void putnr(int n) { if (col++ == 8) { fprintf(tc, "\n\t"); /* was th */ col = 1; } fprintf(tc, "%3d, ", n); /* was th */ } static void putfnm(int j, Symbol *s) { if (lastfnm && lastfnm == s && j != -1) return; if (lastfnm) fprintf(tc, "{ \"%s\", %d, %d },\n\t", /* was th */ lastfnm->name, lastfrom, j-1); lastfnm = s; lastfrom = j; } static void putfnm_flush(int j) { if (lastfnm) fprintf(tc, "{ \"%s\", %d, %d }\n", /* was th */ lastfnm->name, lastfrom, j); } static SRC * newsrc(int m, SRC *n) { SRC *tmp; tmp = (SRC *) emalloc(sizeof(SRC)); tmp->st = m; tmp->nxt = n; return tmp; } void putskip(int m) /* states that need not be reached */ { SRC *tmp, *lst = (SRC *)0; /* 6.4.0: now an ordered list */ for (tmp = skip; tmp; lst = tmp, tmp = tmp->nxt) { if (tmp->st == m) { return; } if (tmp->st > m) /* insert before */ { if (tmp == skip) { tmp = newsrc(m, skip); skip = tmp; } else { assert(lst); tmp = newsrc(m, lst->nxt); lst->nxt = tmp; } return; } } /* insert at the end */ if (lst) { lst->nxt = newsrc(m, 0); } else /* empty list */ { skip = newsrc(m, 0); } } void unskip(int m) /* a state that needs to be reached after all */ { SRC *tmp, *lst = (SRC *)0; for (tmp = skip; tmp; lst = tmp, tmp = tmp->nxt) { if (tmp->st == m) { if (tmp == skip) skip = skip->nxt; else if (lst) /* always true, but helps coverity */ lst->nxt = tmp->nxt; break; } if (tmp->st > m) { break; /* m is not in list */ } } } void putsrc(Element *e) /* match states to source lines */ { SRC *tmp, *lst = (SRC *)0; int n, m; if (!e || !e->n) return; n = e->n->ln; m = e->seqno; /* 6.4.0: now an ordered list */ for (tmp = frst; tmp; lst = tmp, tmp = tmp->nxt) { if (tmp->st == m) { if (tmp->ln != n || tmp->fn != e->n->fn) printf("putsrc mismatch seqno %d, line %d - %d, file %s\n", m, n, tmp->ln, tmp->fn->name); return; } if (tmp->st > m) /* insert before */ { if (tmp == frst) { tmp = newsrc(m, frst); frst = tmp; } else { assert(lst); tmp = newsrc(m, lst->nxt); lst->nxt = tmp; } tmp->ln = n; tmp->fn = e->n->fn; return; } } /* insert at the end */ tmp = newsrc(m, lst?lst->nxt:0); tmp->ln = n; tmp->fn = e->n->fn; if (lst) { lst->nxt = tmp; } else { frst = tmp; } } static void dumpskip(int n, int m) { SRC *tmp, *lst; FILE *tz = tc; /* was th */ int j; fprintf(tz, "uchar reached%d [] = {\n\t", m); tmp = skip; lst = (SRC *) 0; for (j = 0, col = 0; j <= n; j++) { /* find j in the sorted list */ for ( ; tmp; lst = tmp, tmp = tmp->nxt) { if (tmp->st == j) { putnr(1); if (lst) lst->nxt = tmp->nxt; else skip = tmp->nxt; break; } if (tmp->st > j) { putnr(0); break; /* j is not in the list */ } } if (!tmp) { putnr(0); } } fprintf(tz, "};\n"); fprintf(tz, "uchar *loopstate%d;\n", m); if (m == eventmapnr) fprintf(th, "#define reached_event reached%d\n", m); skip = (SRC *) 0; } void dumpsrc(int n, int m) { SRC *tmp, *lst; int j; static int did_claim = 0; FILE *tz = tc; /* was th */ fprintf(tz, "\nshort src_ln%d [] = {\n\t", m); tmp = frst; for (j = 0, col = 0; j <= n; j++) { for ( ; tmp; tmp = tmp->nxt) { if (tmp->st == j) { putnr(tmp->ln); break; } if (tmp->st > j) { putnr(0); break; } } if (!tmp) { putnr(0); } } fprintf(tz, "};\n"); lastfnm = (Symbol *) 0; lastdef.name = "-"; fprintf(tz, "S_F_MAP src_file%d [] = {\n\t", m); tmp = frst; lst = (SRC *) 0; for (j = 0, col = 0; j <= n; j++) { for ( ; tmp; lst = tmp, tmp = tmp->nxt) { if (tmp->st == j) { putfnm(j, tmp->fn); if (lst) lst->nxt = tmp->nxt; else frst = tmp->nxt; break; } if (tmp->st > j) { putfnm(j, &lastdef); break; } } if (!tmp) { putfnm(j, &lastdef); } } putfnm_flush(j); fprintf(tz, "};\n"); if (pid_is_claim(m) && !did_claim) { fprintf(tz, "short *src_claim;\n"); did_claim++; } if (m == eventmapnr) fprintf(th, "#define src_event src_ln%d\n", m); frst = (SRC *) 0; dumpskip(n, m); } #define Cat0(x) comwork(fd,now->lft,m); fprintf(fd, x); \ comwork(fd,now->rgt,m) #define Cat1(x) fprintf(fd,"("); Cat0(x); fprintf(fd,")") #define Cat2(x,y) fprintf(fd,x); comwork(fd,y,m) #define Cat3(x,y,z) fprintf(fd,x); comwork(fd,y,m); fprintf(fd,z) static int symbolic(FILE *fd, Lextok *tv) { Lextok *n; extern Lextok *Mtype; int cnt = 1; if (tv->ismtyp) for (n = Mtype; n; n = n->rgt, cnt++) if (cnt == tv->val) { fprintf(fd, "%s", n->lft->sym->name); return 1; } return 0; } static void comwork(FILE *fd, Lextok *now, int m) { Lextok *v; int i, j; if (!now) { fprintf(fd, "0"); return; } switch (now->ntyp) { case CONST: sr_mesg(fd, now->val, now->ismtyp); break; case '!': Cat3("!(", now->lft, ")"); break; case UMIN: Cat3("-(", now->lft, ")"); break; case '~': Cat3("~(", now->lft, ")"); break; case '/': Cat1("/"); break; case '*': Cat1("*"); break; case '-': Cat1("-"); break; case '+': Cat1("+"); break; case '%': Cat1("%%"); break; case '&': Cat1("&"); break; case '^': Cat1("^"); break; case '|': Cat1("|"); break; case LE: Cat1("<="); break; case GE: Cat1(">="); break; case GT: Cat1(">"); break; case LT: Cat1("<"); break; case NE: Cat1("!="); break; case EQ: if (ltl_mode && now->lft->ntyp == 'p' && now->rgt->ntyp == 'q') /* remote ref */ { Lextok *p = now->lft->lft; fprintf(fd, "("); fprintf(fd, "%s", p->sym->name); if (p->lft) { fprintf(fd, "["); putstmnt(fd, p->lft, 0); /* pid */ fprintf(fd, "]"); } fprintf(fd, "@"); fprintf(fd, "%s", now->rgt->sym->name); fprintf(fd, ")"); break; } Cat1("=="); break; case OR: Cat1("||"); break; case AND: Cat1("&&"); break; case LSHIFT: Cat1("<<"); break; case RSHIFT: Cat1(">>"); break; case RUN: fprintf(fd, "run %s(", now->sym->name); for (v = now->lft; v; v = v->rgt) if (v == now->lft) { comwork(fd, v->lft, m); } else { Cat2(",", v->lft); } fprintf(fd, ")"); break; case LEN: putname(fd, "len(", now->lft, m, ")"); break; case FULL: putname(fd, "full(", now->lft, m, ")"); break; case EMPTY: putname(fd, "empty(", now->lft, m, ")"); break; case NFULL: putname(fd, "nfull(", now->lft, m, ")"); break; case NEMPTY: putname(fd, "nempty(", now->lft, m, ")"); break; case 's': putname(fd, "", now->lft, m, now->val?"!!":"!"); for (v = now->rgt, i=0; v; v = v->rgt, i++) { if (v != now->rgt) fprintf(fd,","); if (!symbolic(fd, v->lft)) comwork(fd,v->lft,m); } break; case 'r': putname(fd, "", now->lft, m, "?"); switch (now->val) { case 0: break; case 1: fprintf(fd, "?"); break; case 2: fprintf(fd, "<"); break; case 3: fprintf(fd, "?<"); break; } for (v = now->rgt, i=0; v; v = v->rgt, i++) { if (v != now->rgt) fprintf(fd,","); if (!symbolic(fd, v->lft)) comwork(fd,v->lft,m); } if (now->val >= 2) fprintf(fd, ">"); break; case 'R': putname(fd, "", now->lft, m, now->val?"??[":"?["); for (v = now->rgt, i=0; v; v = v->rgt, i++) { if (v != now->rgt) fprintf(fd,","); if (!symbolic(fd, v->lft)) comwork(fd,v->lft,m); } fprintf(fd, "]"); break; case ENABLED: Cat3("enabled(", now->lft, ")"); break; case GET_P: if (old_priority_rules) { fprintf(fd, "1"); } else { Cat3("get_priority(", now->lft, ")"); } break; case SET_P: if (!old_priority_rules) { fprintf(fd, "set_priority("); comwork(fd, now->lft->lft, m); fprintf(fd, ", "); comwork(fd, now->lft->rgt, m); fprintf(fd, ")"); } break; case EVAL: Cat3("eval(", now->lft, ")"); break; case NONPROGRESS: fprintf(fd, "np_"); break; case PC_VAL: Cat3("pc_value(", now->lft, ")"); break; case 'c': Cat3("(", now->lft, ")"); break; case '?': if (now->lft) { Cat3("( (", now->lft, ") -> "); } if (now->rgt) { Cat3("(", now->rgt->lft, ") : "); Cat3("(", now->rgt->rgt, ") )"); } break; case ASGN: if (check_track(now) == STRUCT) { break; } comwork(fd,now->lft,m); fprintf(fd," = "); comwork(fd,now->rgt,m); break; case PRINT: { char c, buf[1024]; strncpy(buf, now->sym->name, 510); for (i = j = 0; i < 510; i++, j++) { c = now->sym->name[i]; buf[j] = c; if (c == '\\') buf[++j] = c; if (c == '\"') buf[j] = '\''; if (c == '\0') break; } if (now->ntyp == PRINT) fprintf(fd, "printf"); else fprintf(fd, "annotate"); fprintf(fd, "(%s", buf); } for (v = now->lft; v; v = v->rgt) { Cat2(",", v->lft); } fprintf(fd, ")"); break; case PRINTM: fprintf(fd, "printm("); comwork(fd, now->lft, m); fprintf(fd, ")"); break; case NAME: putname(fd, "", now, m, ""); break; case 'p': if (ltl_mode) { fprintf(fd, "%s", now->lft->sym->name); /* proctype */ if (now->lft->lft) { fprintf(fd, "["); putstmnt(fd, now->lft->lft, 0); /* pid */ fprintf(fd, "]"); } fprintf(fd, ":"); /* remote varref */ fprintf(fd, "%s", now->sym->name); /* varname */ break; } putremote(fd, now, m); break; case 'q': fprintf(fd, "%s", now->sym->name); break; case C_EXPR: case C_CODE: fprintf(fd, "{%s}", now->sym->name); break; case ASSERT: Cat3("assert(", now->lft, ")"); break; case '.': fprintf(fd, ".(goto)"); break; case GOTO: fprintf(fd, "goto %s", now->sym->name); break; case BREAK: fprintf(fd, "break"); break; case ELSE: fprintf(fd, "else"); break; case '@': fprintf(fd, "-end-"); break; case D_STEP: fprintf(fd, "D_STEP%d", now->ln); break; case ATOMIC: fprintf(fd, "ATOMIC"); break; case NON_ATOMIC: fprintf(fd, "sub-sequence"); break; case IF: fprintf(fd, "IF"); break; case DO: fprintf(fd, "DO"); break; case UNLESS: fprintf(fd, "unless"); break; case TIMEOUT: fprintf(fd, "timeout"); break; default: if (isprint(now->ntyp)) fprintf(fd, "'%c'", now->ntyp); else fprintf(fd, "%d", now->ntyp); break; } } void comment(FILE *fd, Lextok *now, int m) { extern short terse, nocast; terse=nocast=1; comwork(fd, now, m); terse=nocast=0; } Spin/Src6.4.5/pangen1.c0000664000175100017510000011767012641605057012412 0ustar ghgh/***** spin: pangen1.c *****/ /* * This file is part of the public release of Spin. It is subject to the * terms in the LICENSE file that is included in this source directory. * Tool documentation is available at http://spinroot.com */ #include "spin.h" #include "y.tab.h" #include "pangen1.h" #include "pangen3.h" #include "pangen6.h" #include #ifdef SOLARIS #include #else #include #endif extern FILE *tc, *th, *tt; extern Label *labtab; extern Ordered *all_names; extern ProcList *rdy; extern Queue *qtab; extern Symbol *Fname; extern int lineno, verbose, Pid, separate, old_scope_rules, nclaims; extern int nrRdy, nqs, mst, Mpars, claimnr, eventmapnr; extern short has_sorted, has_random, has_provided, has_priority; extern Queue *ltab[]; int Npars=0, u_sync=0, u_async=0, hastrack = 1; short has_io = 0; short has_state=0; /* code contains c_state */ static Symbol *LstSet=ZS; static int acceptors=0, progressors=0, nBits=0; static int Types[] = { UNSIGNED, BIT, BYTE, CHAN, MTYPE, SHORT, INT, STRUCT }; static int doglobal(char *, int); static void dohidden(void); static void do_init(FILE *, Symbol *); static void end_labs(Symbol *, int); static void put_ptype(char *, int, int, int, enum btypes); static void tc_predef_np(void); static void put_pinit(ProcList *); static void multi_init(void); void walk_struct(FILE *, int, char *, Symbol *, char *, char *, char *); static void reverse_names(ProcList *p) { if (!p) return; reverse_names(p->nxt); fprintf(tc, " \"%s\",\n", p->n->name); } static void reverse_types(ProcList *p) { if (!p) return; reverse_types(p->nxt); fprintf(tc, " %d, /* %s */\n", p->b, p->n->name); } static int blog(int n) /* for small log2 without rounding problems */ { int m=1, r=2; while (r < n) { m++; r *= 2; } return 1+m; } void genheader(void) { ProcList *p; int i; if (separate == 2) { putunames(th); goto here; } /* 5.2.3: gcc 3 no longer seems to compute sizeof at compile time */ fprintf(th, "#define WS %d /* word size in bytes */\n", (int) sizeof(void *)); fprintf(th, "#define SYNC %d\n", u_sync); fprintf(th, "#define ASYNC %d\n\n", u_async); fprintf(th, "#ifndef NCORE\n"); fprintf(th, " #ifdef DUAL_CORE\n"); fprintf(th, " #define NCORE 2\n"); fprintf(th, " #elif QUAD_CORE\n"); fprintf(th, " #define NCORE 4\n"); fprintf(th, " #else\n"); fprintf(th, " #define NCORE 1\n"); fprintf(th, " #endif\n"); fprintf(th, "#endif\n\n"); putunames(th); fprintf(tc, "\nshort Air[] = { "); for (p = rdy, i=0; p; p = p->nxt, i++) fprintf(tc, "%s (short) Air%d", (p!=rdy)?",":"", i); fprintf(tc, ", (short) Air%d", i); /* np_ */ if (nclaims > 1) { fprintf(tc, "\n#ifndef NOCLAIM\n"); fprintf(tc, " , (short) Air%d", i+1); /* Multi */ fprintf(tc, "\n#endif\n\t"); } fprintf(tc, " };\n"); fprintf(tc, "char *procname[] = {\n"); reverse_names(rdy); fprintf(tc, " \":np_:\",\n"); fprintf(tc, " 0\n"); fprintf(tc, "};\n\n"); fprintf(tc, "enum btypes { NONE=%d, N_CLAIM=%d,", NONE, N_CLAIM); fprintf(tc, " I_PROC=%d, A_PROC=%d,", I_PROC, A_PROC); fprintf(tc, " P_PROC=%d, E_TRACE=%d, N_TRACE=%d };\n\n", P_PROC, E_TRACE, N_TRACE); fprintf(tc, "int Btypes[] = {\n"); reverse_types(rdy); fprintf(tc, " 0 /* :np_: */\n"); fprintf(tc, "};\n\n"); here: for (p = rdy; p; p = p->nxt) put_ptype(p->n->name, p->tn, mst, nrRdy+1, p->b); /* +1 for np_ */ put_ptype("np_", nrRdy, mst, nrRdy+1, 0); if (nclaims > 1) { /* this is the structure that goes into the state-vector * instead of the actual never claims * this assumes that the claims do not have any local variables * this claim records the types and states of all subclaims in an array * NB: not sure if we need the first 3 fields in this structure * it's here for now to avoid breaking some possible dependence * in the calculations above, we were already taking into account * that there is one never-claim, which will now be this one */ i = blog(mst); fprintf(th, "\n"); fprintf(th, "#ifndef NOCLAIM\n"); fprintf(th, " #undef VERI\n"); fprintf(th, " #define VERI %d\n", nrRdy+1); fprintf(th, " #define Pclaim P%d\n\n", nrRdy+1); fprintf(th, "typedef struct P%d {\n", nrRdy+1); fprintf(th, " unsigned _pid : 8; /* always zero */\n"); fprintf(th, " unsigned _t : %d; /* active-claim type */\n", blog(nrRdy+1)); fprintf(th, " unsigned _p : %d; /* active-claim state */\n", i); fprintf(th, " unsigned _n : %d; /* active-claim index */\n", blog(nclaims)); if (i <= UINT8_MAX) /* in stdint.h = UCHAR_MAX from limits.h */ { fprintf(th, " uchar c_cur[NCLAIMS]; /* claim-states */\n"); } else if (i <= UINT16_MAX) /* really USHRT_MAX from limits.h */ { fprintf(th, " ushort c_cur[NCLAIMS]; /* claim-states */\n"); } else /* the most unlikely case */ { fprintf(th, " uint c_cur[NCLAIMS]; /* claim-states */\n"); } fprintf(th, "} P%d;\n", nrRdy+1); fprintf(tc, "#ifndef NOCLAIM\n"); fprintf(tc, "uchar spin_c_typ[NCLAIMS]; /* claim-types */\n"); fprintf(tc, "#endif\n"); fprintf(th, " #define Air%d (0)\n\n", nrRdy+1); fprintf(th, "#endif\n"); /* * find special states as: * stopstate [ claimnr ][ curstate ] == 1 * accpstate [ claimnr ][ curstate ] * progstate [ claimnr ][ curstate ] * reached [ claimnr ][ curstate ] * visstate [ claimnr ][ curstate ] * loopstate [ claimnr ][ curstate ] * mapstate [ claimnr ][ curstate ] */ } else { fprintf(th, "#define Pclaim P0\n"); fprintf(th, "#ifndef NCLAIMS\n"); fprintf(th, " #define NCLAIMS 1\n"); fprintf(th, "#endif\n"); fprintf(tc, "uchar spin_c_typ[NCLAIMS]; /* claim-types */\n"); } ntimes(th, 0, 1, Head0); if (separate != 2) { extern void c_add_stack(FILE *); extern void c_stack_size(FILE *); ntimes(th, 0, 1, Header); fprintf(th, "#define StackSize ("); c_stack_size(th); fprintf(th, ")\n"); c_add_stack(th); ntimes(th, 0, 1, Header0); } else { fprintf(th, "extern char *emalloc(unsigned long);\n"); } ntimes(th, 0, 1, Head1); LstSet = ZS; (void) doglobal("", PUTV); hastrack = c_add_sv(th); fprintf(th, "#ifdef TRIX\n"); fprintf(th, " /* room for 512 proc+chan ptrs, + safety margin */\n"); fprintf(th, " char *_ids_[MAXPROC+MAXQ+4];\n"); fprintf(th, "#else\n"); fprintf(th, " uchar sv[VECTORSZ];\n"); fprintf(th, "#endif\n"); fprintf(th, "} State"); #ifdef SOLARIS fprintf(th,"\n#ifdef GCC\n"); fprintf(th, "\t__attribute__ ((aligned(8)))"); fprintf(th, "\n#endif\n\t"); #endif fprintf(th, ";\n\n"); fprintf(th, "#ifdef TRIX\n"); fprintf(th, "typedef struct TRIX_v6 {\n"); fprintf(th, " uchar *body; /* aligned */\n"); fprintf(th, "#ifndef BFS\n"); fprintf(th, " short modified;\n"); fprintf(th, "#endif\n"); fprintf(th, " short psize;\n"); fprintf(th, " short parent_pid;\n"); fprintf(th, " struct TRIX_v6 *nxt;\n"); fprintf(th, "} TRIX_v6;\n"); fprintf(th, "#endif\n\n"); fprintf(th, "#define HAS_TRACK %d\n", hastrack); if (0 && hastrack) /* not really a problem */ { fprintf(th, "#ifdef BFS_PAR\n"); fprintf(th, " #error cannot use BFS_PAR on models with c_track stmnts\n"); fprintf(th, "#endif\n"); } if (separate != 2) dohidden(); } void genaddproc(void) { ProcList *p; int i = 0; if (separate == 2) goto shortcut; ntimes(tc, nrRdy+1, nrRdy+2, R2); /* +1 for np_ -- was th */ fprintf(tc, "#ifdef TRIX\n"); fprintf(tc, "int what_p_size(int);\n"); fprintf(tc, "int what_q_size(int);\n\n"); /* the number of processes just changed by 1 (up or down) */ /* this means that the channel indices move up or down by one slot */ /* not all new channels may have a valid index yet, but we move */ /* all of them anyway, as if they existed */ ntimes(tc, 0, 1, R7a); fprintf(tc, "#endif\n\n"); ntimes(tc, 0, 1, R7b); fprintf(tc, "int\naddproc(int calling_pid, int priority, int n"); for (/* i = 0 */; i < Npars; i++) fprintf(tc, ", int par%d", i); ntimes(tc, 0, 1, Addp0); ntimes(tc, 1, nrRdy+1, R5); /* +1 for np_ */ if (nclaims > 1) { fprintf(tc, "#ifndef NOCLAIM\n"); ntimes(tc, nrRdy+1, nrRdy+2, R5); fprintf(tc, "#endif\n"); } ntimes(tc, 0, 1, Addp1); if (has_provided) { fprintf(tt, "\nint\nprovided(int II, unsigned char ot, "); fprintf(tt, "int tt, Trans *t)\n"); fprintf(tt, "{\n\tswitch(ot) {\n"); } shortcut: if (nclaims > 1) { multi_init(); } tc_predef_np(); for (p = rdy; p; p = p->nxt) { Pid = p->tn; put_pinit(p); } if (separate == 2) return; Pid = 0; if (has_provided) { fprintf(tt, "\tdefault: return 1; /* e.g., a claim */\n"); fprintf(tt, "\t}\n\treturn 0;\n}\n"); } ntimes(tc, i, i+1, R6); if (separate == 0) ntimes(tc, 1, nrRdy+1, R5); /* +1 for np_ */ else ntimes(tc, 1, nrRdy, R5); ntimes(tc, 0, 1, R8a); } void do_locinits(FILE *fd) { ProcList *p; /* the locinit functions may refer to pptr or qptr */ fprintf(fd, "#if VECTORSZ>32000\n"); fprintf(fd, " extern int \n"); fprintf(fd, "#else\n"); fprintf(fd, " extern short \n"); fprintf(fd, "#endif\n"); fprintf(fd, " *proc_offset, *q_offset;\n"); for (p = rdy; p; p = p->nxt) { c_add_locinit(fd, p->tn, p->n->name); } } void genother(void) { ProcList *p; switch (separate) { case 2: if (nclaims > 0) { for (p = rdy; p; p = p->nxt) { if (p->b == N_CLAIM) { ntimes(tc, p->tn, p->tn+1, R0); /* claims only */ fprintf(tc, "#ifdef HAS_CODE\n"); ntimes(tc, p->tn, p->tn+1, R00); fprintf(tc, "#endif\n"); } } } break; case 1: ntimes(tc, 0, 1, Code0); for (p = rdy; p; p = p->nxt) { if (p->b != N_CLAIM) { ntimes(tc, p->tn, p->tn+1, R0); /* all except claims */ fprintf(tc, "#ifdef HAS_CODE\n"); ntimes(tc, p->tn, p->tn+1, R00); fprintf(tc, "#endif\n"); } } break; case 0: ntimes(tc, 0, 1, Code0); ntimes(tc, 0, nrRdy+1, R0); /* +1 for np_ */ fprintf(tc, "#ifdef HAS_CODE\n"); ntimes(tc, 0, nrRdy+1, R00); /* +1 for np_ */ fprintf(tc, "#endif\n"); break; } /* new place, make sure Maxbody is set to its final value here */ fprintf(tc, "\n"); if (separate != 2) { ntimes(tc, 1, u_sync+u_async+1, R3); /* nqs is still 0 */ fprintf(tc, "\tMaxbody = max(Maxbody, sizeof(State)-VECTORSZ);\n"); fprintf(tc, "\tif ((Maxbody %% WS) != 0)\n"); fprintf(tc, "\t Maxbody += WS - (Maxbody %% WS);\n\n"); } for (p = rdy; p; p = p->nxt) end_labs(p->n, p->tn); switch (separate) { case 2: if (nclaims > 0) { for (p = rdy; p; p = p->nxt) { if (p->b == N_CLAIM) { ntimes(tc, p->tn, p->tn+1, R0a); /* claims only */ } } } return; case 1: for (p = rdy; p; p = p->nxt) { if (p->b != N_CLAIM) { ntimes(tc, p->tn, p->tn+1, R0a); /* all except claims */ } } fprintf(tc, " if (state_tables)\n"); fprintf(tc, " ini_claim(%d, 0);\n", claimnr); /* the default claim */ if (acceptors == 0) { acceptors = 1; /* assume at least 1 acceptstate */ } break; case 0: ntimes(tc, 0, nrRdy, R0a); /* all */ break; } ntimes(th, acceptors, acceptors+1, Code1); ntimes(th, progressors, progressors+1, Code3); ntimes(tc, 0, 1, Code2a); /* dfs, bfs */ ntimes(tc, 0, 1, Code2e); /* multicore */ ntimes(tc, 0, 1, Code2c); /* multicore */ ntimes(tc, 0, 1, Code2d); fprintf(tc, "void\ndo_reach(void)\n{\n"); ntimes(tc, 0, nrRdy, R4); fprintf(tc, "}\n\n"); fprintf(tc, "void\niniglobals(int calling_pid)\n{\n"); if (doglobal("", INIV) > 0) { fprintf(tc, "#ifdef VAR_RANGES\n"); (void) doglobal("logval(\"", LOGV); fprintf(tc, "#endif\n"); } fprintf(tc, "}\n\n"); } void gensvmap(void) { ntimes(tc, 0, 1, SvMap); } static struct { char *s, *t; int n, m, p; } ln[] = { {"end", "stopstate", 3, 0, 0}, {"progress", "progstate", 8, 0, 1}, {"accept", "accpstate", 6, 1, 0}, {0, 0, 0, 0, 0}, }; static void end_labs(Symbol *s, int i) { int oln = lineno; Symbol *ofn = Fname; Label *l; int j; char foo[128]; if ((pid_is_claim(i) && separate == 1) || (!pid_is_claim(i) && separate == 2)) return; for (l = labtab; l; l = l->nxt) for (j = 0; ln[j].n; j++) { if (strncmp(l->s->name, ln[j].s, ln[j].n) == 0 && strcmp(l->c->name, s->name) == 0) { fprintf(tc, "\t%s[%d][%d] = 1;\n", ln[j].t, i, l->e->seqno); acceptors += ln[j].m; progressors += ln[j].p; if (l->e->status & D_ATOM) { sprintf(foo, "%s label inside d_step", ln[j].s); goto complain; } if (j > 0 && (l->e->status & ATOM)) { sprintf(foo, "%s label inside atomic", ln[j].s); complain: lineno = l->e->n->ln; Fname = l->e->n->fn; printf("spin: %3d:%s, warning, %s - is invisible\n", lineno, Fname?Fname->name:"-", foo); } } } /* visible states -- through remote refs: */ for (l = labtab; l; l = l->nxt) if (l->visible && strcmp(l->s->context->name, s->name) == 0) fprintf(tc, "\tvisstate[%d][%d] = 1;\n", i, l->e->seqno); lineno = oln; Fname = ofn; } void ntimes(FILE *fd, int n, int m, const char *c[]) { int i, j; for (j = 0; c[j]; j++) for (i = n; i < m; i++) { fprintf(fd, c[j], i, i, i, i, i, i); fprintf(fd, "\n"); } } void prehint(Symbol *s) { Lextok *n; printf("spin: warning, "); if (!s) return; n = (s->context != ZS)?s->context->ini:s->ini; if (n) printf("line %s:%d, ", n->fn->name, n->ln); } void checktype(Symbol *sp, char *s) { char buf[128]; int i; if (!s || (sp->type != BYTE && sp->type != SHORT && sp->type != INT)) return; if (sp->hidden&16) /* formal parameter */ { ProcList *p; Lextok *f, *t; int posnr = 0; for (p = rdy; p; p = p->nxt) if (p->n->name && strcmp(s, p->n->name) == 0) break; if (p) for (f = p->p; f; f = f->rgt) /* list of types */ for (t = f->lft; t; t = t->rgt, posnr++) if (t->sym && strcmp(t->sym->name, sp->name) == 0) { checkrun(sp, posnr); return; } } else if (!(sp->hidden&4)) { if (!(verbose&32)) return; sputtype(buf, sp->type); i = (int) strlen(buf); while (i > 0 && buf[--i] == ' ') buf[i] = '\0'; prehint(sp); if (sp->context) printf("proctype %s:", s); else printf("global"); printf(" '%s %s' could be declared 'bit %s'\n", buf, sp->name, sp->name); } else if (sp->type != BYTE && !(sp->hidden&8)) { if (!(verbose&32)) return; sputtype(buf, sp->type); i = (int) strlen(buf); while (buf[--i] == ' ') buf[i] = '\0'; prehint(sp); if (sp->context) printf("proctype %s:", s); else printf("global"); printf(" '%s %s' could be declared 'byte %s'\n", buf, sp->name, sp->name); } } static int dolocal(FILE *ofd, char *pre, int dowhat, int p, char *s, enum btypes b) { int h, j, k=0; extern int nr_errs; Ordered *walk; Symbol *sp; char buf[128], buf2[128], buf3[128]; if (dowhat == INIV) { /* initialize in order of declaration */ for (walk = all_names; walk; walk = walk->next) { sp = walk->entry; if (sp->context && !sp->owner && strcmp(s, sp->context->name) == 0) { checktype(sp, s); /* fall through */ if (!(sp->hidden&16)) { sprintf(buf, "((P%d *)pptr(h))->", p); do_var(ofd, dowhat, buf, sp, "", " = ", ";\n"); } k++; } } } else { for (j = 0; j < 8; j++) for (h = 0; h <= 1; h++) for (walk = all_names; walk; walk = walk->next) { sp = walk->entry; if (sp->context && !sp->owner && sp->type == Types[j] && ((h == 0 && (sp->nel == 1 && sp->isarray == 0)) || (h == 1 && (sp->nel > 1 || sp->isarray == 1))) && strcmp(s, sp->context->name) == 0) { switch (dowhat) { case LOGV: if (sp->type == CHAN && verbose == 0) break; sprintf(buf, "%s%s:", pre, s); { sprintf(buf2, "\", ((P%d *)pptr(h))->", p); sprintf(buf3, ");\n"); } do_var(ofd, dowhat, "", sp, buf, buf2, buf3); break; case PUTV: sprintf(buf, "((P%d *)pptr(h))->", p); do_var(ofd, dowhat, buf, sp, "", " = ", ";\n"); k++; break; } if (b == N_CLAIM) { printf("error: %s defines local %s\n", s, sp->name); nr_errs++; } } } } return k; } void c_chandump(FILE *fd) { Queue *q; char buf[256]; int i; if (!qtab) { fprintf(fd, "void\nc_chandump(int unused)\n"); fprintf(fd, "{\tunused++; /* avoid complaints */\n}\n"); return; } fprintf(fd, "void\nc_chandump(int from)\n"); fprintf(fd, "{ uchar *z; int slot;\n"); fprintf(fd, " from--;\n"); fprintf(fd, " if (from >= (int) now._nr_qs || from < 0)\n"); fprintf(fd, " { printf(\"pan: bad qid %%d\\n\", from+1);\n"); fprintf(fd, " return;\n"); fprintf(fd, " }\n"); fprintf(fd, " z = qptr(from);\n"); fprintf(fd, " switch (((Q0 *)z)->_t) {\n"); for (q = qtab; q; q = q->nxt) { fprintf(fd, " case %d:\n\t\t", q->qid); sprintf(buf, "((Q%d *)z)->", q->qid); fprintf(fd, "for (slot = 0; slot < %sQlen; slot++)\n\t\t", buf); fprintf(fd, "{ printf(\" [\");\n\t\t"); for (i = 0; i < q->nflds; i++) { if (q->fld_width[i] == MTYPE) { fprintf(fd, "\tprintm(%scontents[slot].fld%d);\n\t\t", buf, i); } else fprintf(fd, "\tprintf(\"%%d,\", %scontents[slot].fld%d);\n\t\t", buf, i); } fprintf(fd, " printf(\"],\");\n\t\t"); fprintf(fd, "}\n\t\t"); fprintf(fd, "break;\n"); } fprintf(fd, " }\n"); fprintf(fd, " printf(\"\\n\");\n}\n"); } void c_var(FILE *fd, char *pref, Symbol *sp) { char *ptr, buf[256]; int i; if (!sp) { fatal("cannot happen - c_var", 0); } ptr = sp->name; if (!old_scope_rules) { while (*ptr == '_' || isdigit((int)*ptr)) { ptr++; } } switch (sp->type) { case STRUCT: /* c_struct(fd, pref, sp); */ fprintf(fd, "\t\tprintf(\"\t(struct %s)\\n\");\n", sp->name); sprintf(buf, "%s%s.", pref, sp->name); c_struct(fd, buf, sp); break; case MTYPE: case BIT: case BYTE: case SHORT: case INT: case UNSIGNED: sputtype(buf, sp->type); if (sp->nel == 1 && sp->isarray == 0) { if (sp->type == MTYPE && ismtype(sp->name)) { fprintf(fd, "\tprintf(\"\t%s %s:\t%d\\n\");\n", buf, ptr, ismtype(sp->name)); } else { fprintf(fd, "\tprintf(\"\t%s %s:\t%%d\\n\", %s%s);\n", buf, ptr, pref, sp->name); } } else { fprintf(fd, "\t{\tint l_in;\n"); fprintf(fd, "\t\tfor (l_in = 0; l_in < %d; l_in++)\n", sp->nel); fprintf(fd, "\t\t{\n"); fprintf(fd, "\t\t\tprintf(\"\t%s %s[%%d]:\t%%d\\n\", l_in, %s%s[l_in]);\n", buf, ptr, pref, sp->name); fprintf(fd, "\t\t}\n"); fprintf(fd, "\t}\n"); } break; case CHAN: if (sp->nel == 1 && sp->isarray == 0) { fprintf(fd, "\tprintf(\"\tchan %s (=%%d):\tlen %%d:\\t\", ", ptr); fprintf(fd, "%s%s, q_len(%s%s));\n", pref, sp->name, pref, sp->name); fprintf(fd, "\tc_chandump(%s%s);\n", pref, sp->name); } else for (i = 0; i < sp->nel; i++) { fprintf(fd, "\tprintf(\"\tchan %s[%d] (=%%d):\tlen %%d:\\t\", ", ptr, i); fprintf(fd, "%s%s[%d], q_len(%s%s[%d]));\n", pref, sp->name, i, pref, sp->name, i); fprintf(fd, "\tc_chandump(%s%s[%d]);\n", pref, sp->name, i); } break; } } int c_splurge_any(ProcList *p) { Ordered *walk; Symbol *sp; if (p->b != N_CLAIM && p->b != E_TRACE && p->b != N_TRACE) for (walk = all_names; walk; walk = walk->next) { sp = walk->entry; if (!sp->context || sp->type == 0 || strcmp(sp->context->name, p->n->name) != 0 || sp->owner || (sp->hidden&1) || (sp->type == MTYPE && ismtype(sp->name))) continue; return 1; } return 0; } void c_splurge(FILE *fd, ProcList *p) { Ordered *walk; Symbol *sp; char pref[64]; if (p->b != N_CLAIM && p->b != E_TRACE && p->b != N_TRACE) for (walk = all_names; walk; walk = walk->next) { sp = walk->entry; if (!sp->context || sp->type == 0 || strcmp(sp->context->name, p->n->name) != 0 || sp->owner || (sp->hidden&1) || (sp->type == MTYPE && ismtype(sp->name))) continue; sprintf(pref, "((P%d *)pptr(pid))->", p->tn); c_var(fd, pref, sp); } } void c_wrapper(FILE *fd) /* allow pan.c to print out global sv entries */ { Ordered *walk; ProcList *p; Symbol *sp; Lextok *n; extern Lextok *Mtype; int j; fprintf(fd, "void\nc_globals(void)\n{\t/* int i; */\n"); fprintf(fd, " printf(\"global vars:\\n\");\n"); for (walk = all_names; walk; walk = walk->next) { sp = walk->entry; if (sp->context || sp->owner || (sp->hidden&1)) continue; c_var(fd, "now.", sp); } fprintf(fd, "}\n"); fprintf(fd, "void\nc_locals(int pid, int tp)\n{\t/* int i; */\n"); fprintf(fd, " switch(tp) {\n"); for (p = rdy; p; p = p->nxt) { fprintf(fd, " case %d:\n", p->tn); if (c_splurge_any(p)) { fprintf(fd, " \tprintf(\"local vars proc %%d (%s):\\n\", pid);\n", p->n->name); c_splurge(fd, p); } else { fprintf(fd, " \t/* none */\n"); } fprintf(fd, " \tbreak;\n"); } fprintf(fd, " }\n}\n"); fprintf(fd, "void\nprintm(int x)\n{\n"); fprintf(fd, " switch (x) {\n"); for (n = Mtype, j = 1; n && j; n = n->rgt, j++) fprintf(fd, "\tcase %d: Printf(\"%s\"); break;\n", j, n->lft->sym->name); fprintf(fd, " default: Printf(\"%%d\", x);\n"); fprintf(fd, " }\n"); fprintf(fd, "}\n"); } static int doglobal(char *pre, int dowhat) { Ordered *walk; Symbol *sp; int j, cnt = 0; for (j = 0; j < 8; j++) for (walk = all_names; walk; walk = walk->next) { sp = walk->entry; if (!sp->context && !sp->owner && sp->type == Types[j]) { if (Types[j] != MTYPE || !ismtype(sp->name)) switch (dowhat) { case LOGV: if (sp->type == CHAN && verbose == 0) break; if (sp->hidden&1) break; do_var(tc, dowhat, "", sp, pre, "\", now.", ");\n"); break; case INIV: checktype(sp, (char *) 0); cnt++; /* fall through */ case PUTV: do_var(tc, dowhat, (sp->hidden&1)?"":"now.", sp, "", " = ", ";\n"); break; } } } return cnt; } static void dohidden(void) { Ordered *walk; Symbol *sp; int j; for (j = 0; j < 8; j++) for (walk = all_names; walk; walk = walk->next) { sp = walk->entry; if ((sp->hidden&1) && sp->type == Types[j]) { if (sp->context || sp->owner) fatal("cannot hide non-globals (%s)", sp->name); if (sp->type == CHAN) fatal("cannot hide channels (%s)", sp->name); fprintf(th, "/* hidden variable: */"); typ2c(sp); } } } void do_var(FILE *ofd, int dowhat, char *s, Symbol *sp, char *pre, char *sep, char *ter) { int i; char *ptr = sp?sp->name:""; if (!sp) { fatal("cannot happen - do_var", 0); } switch(dowhat) { case PUTV: if (sp->hidden&1) break; typ2c(sp); break; case LOGV: if (!old_scope_rules) { while (*ptr == '_' || isdigit((int)*ptr)) { ptr++; } } /* fall thru */ case INIV: if (sp->type == STRUCT) { /* struct may contain a chan */ walk_struct(ofd, dowhat, s, sp, pre, sep, ter); break; } if (!sp->ini && dowhat != LOGV) /* it defaults to 0 */ break; if (sp->nel == 1 && sp->isarray == 0) { if (dowhat == LOGV) { fprintf(ofd, "\t\t%s%s%s%s", pre, s, ptr, sep); fprintf(ofd, "%s%s", s, sp->name); } else { fprintf(ofd, "\t\t%s%s%s%s", pre, s, sp->name, sep); do_init(ofd, sp); } fprintf(ofd, "%s", ter); } else { if (sp->ini && sp->ini->ntyp == CHAN) { for (i = 0; i < sp->nel; i++) { fprintf(ofd, "\t\t%s%s%s[%d]%s", pre, s, sp->name, i, sep); if (dowhat == LOGV) fprintf(ofd, "%s%s[%d]", s, sp->name, i); else do_init(ofd, sp); fprintf(ofd, "%s", ter); } } else if (sp->ini) { if (dowhat != LOGV && sp->isarray && sp->ini->ntyp == ',') { Lextok *z, *y; z = sp->ini; for (i = 0; i < sp->nel; i++) { if (z && z->ntyp == ',') { y = z->lft; z = z->rgt; } else { y = z; } fprintf(ofd, "\t\t%s%s%s[%d]%s", pre, s, sp->name, i, sep); putstmnt(ofd, y, 0); fprintf(ofd, "%s", ter); } } else { fprintf(ofd, "\t{\tint l_in;\n"); fprintf(ofd, "\t\tfor (l_in = 0; l_in < %d; l_in++)\n", sp->nel); fprintf(ofd, "\t\t{\n"); fprintf(ofd, "\t\t\t%s%s%s[l_in]%s", pre, s, sp->name, sep); if (dowhat == LOGV) { fprintf(ofd, "%s%s[l_in]", s, sp->name); } else { putstmnt(ofd, sp->ini, 0); } fprintf(ofd, "%s", ter); fprintf(ofd, "\t\t}\n"); fprintf(ofd, "\t}\n"); } } } break; } } static void do_init(FILE *ofd, Symbol *sp) { int i; if (sp->ini && sp->type == CHAN && ((i = qmake(sp)) > 0)) { if (sp->ini->ntyp == CHAN) { fprintf(ofd, "addqueue(calling_pid, %d, %d)", i, ltab[i-1]->nslots == 0); } else { fprintf(ofd, "%d", i); } } else { putstmnt(ofd, sp->ini, 0); } } static void put_ptype(char *s, int i, int m0, int m1, enum btypes b) { int k; if (b == I_PROC) { fprintf(th, "#define Pinit ((P%d *)this)\n", i); } else if (b == P_PROC || b == A_PROC) { fprintf(th, "#define P%s ((P%d *)this)\n", s, i); } fprintf(th, "typedef struct P%d { /* %s */\n", i, s); fprintf(th, " unsigned _pid : 8; /* 0..255 */\n"); fprintf(th, " unsigned _t : %d; /* proctype */\n", blog(m1)); fprintf(th, " unsigned _p : %d; /* state */\n", blog(m0)); fprintf(th, "#ifdef HAS_PRIORITY\n"); fprintf(th, " unsigned _priority : 8; /* 0..255 */\n"); fprintf(th, "#endif\n"); LstSet = ZS; nBits = 8 + blog(m1) + blog(m0); k = dolocal(tc, "", PUTV, i, s, b); /* includes pars */ c_add_loc(th, s); fprintf(th, "} P%d;\n", i); if ((!LstSet && k > 0) || has_state) fprintf(th, "#define Air%d 0\n\n", i); else if (LstSet || k == 0) /* 5.0, added condition */ { fprintf(th, "#define Air%d (sizeof(P%d) - ", i, i); if (k == 0) { fprintf(th, "%d", (nBits+7)/8); goto done; } if ((LstSet->type != BIT && LstSet->type != UNSIGNED) || LstSet->nel != 1) { fprintf(th, "Offsetof(P%d, %s) - %d*sizeof(", i, LstSet->name, LstSet->nel); } switch(LstSet->type) { case UNSIGNED: fprintf(th, "%d", (nBits+7)/8); break; case BIT: if (LstSet->nel == 1) { fprintf(th, "%d", (nBits+7)/8); break; } /* else fall through */ case MTYPE: case BYTE: case CHAN: fprintf(th, "uchar)"); break; case SHORT: fprintf(th, "short)"); break; case INT: fprintf(th, "int)"); break; default: fatal("cannot happen Air %s", LstSet->name); } done: fprintf(th, ")\n\n"); } } static void tc_predef_np(void) { fprintf(th, "#define _NP_ %d\n", nrRdy); /* 1+ highest proctype nr */ fprintf(th, "#define nstates%d 3 /* np_ */\n", nrRdy); fprintf(th, "#define endstate%d 2 /* np_ */\n\n", nrRdy); fprintf(th, "#define start%d 0 /* np_ */\n", nrRdy); fprintf(tc, "\tcase %d: /* np_ */\n", nrRdy); if (separate == 1) { fprintf(tc, "\t\tini_claim(%d, h);\n", nrRdy); } else { fprintf(tc, "\t\t((P%d *)pptr(h))->_t = %d;\n", nrRdy, nrRdy); fprintf(tc, "\t\t((P%d *)pptr(h))->_p = 0;\n", nrRdy); fprintf(tc, "#ifdef HAS_PRIORITY\n"); fprintf(tc, "\t\t((P%d *)pptr(h))->_priority = priority;\n", nrRdy); fprintf(tc, "#endif\n"); fprintf(tc, "\t\treached%d[0] = 1;\n", nrRdy); fprintf(tc, "\t\taccpstate[%d][1] = 1;\n", nrRdy); } fprintf(tc, "\t\tbreak;\n"); } static void multi_init(void) { ProcList *p; Element *e; int i = nrRdy+1; int ini, j; int nrc = nclaims; fprintf(tc, "#ifndef NOCLAIM\n"); fprintf(tc, "\tcase %d: /* claim select */\n", i); for (p = rdy, j = 0; p; p = p->nxt, j++) { if (p->b == N_CLAIM) { e = p->s->frst; ini = huntele(e, e->status, -1)->seqno; fprintf(tc, "\t\tspin_c_typ[%d] = %d; /* %s */\n", j, p->tn, p->n->name); fprintf(tc, "\t\t((P%d *)pptr(h))->c_cur[%d] = %d;\n", i, j, ini); fprintf(tc, "\t\treached%d[%d]=1;\n", p->tn, ini); /* the default initial claim is first one in model */ if (--nrc == 0) { fprintf(tc, "\t\t((P%d *)pptr(h))->_t = %d;\n", i, p->tn); fprintf(tc, "\t\t((P%d *)pptr(h))->_p = %d;\n", i, ini); fprintf(tc, "\t\t((P%d *)pptr(h))->_n = %d; /* %s */\n", i, j, p->n->name); fprintf(tc, "\t\tsrc_claim = src_ln%d;\n", p->tn); fprintf(tc, "#ifndef BFS\n"); fprintf(tc, "\t\tif (whichclaim == -1 && claimname == NULL)\n"); fprintf(tc, "\t\t\tprintf(\"0: Claim %s (%d), from state %d\\n\");\n", p->n->name, p->tn, ini); fprintf(tc, "#endif\n"); } } } fprintf(tc, "\t\tif (whichclaim != -1)\n"); fprintf(tc, "\t\t{ select_claim(whichclaim);\n"); fprintf(tc, "\t\t}\n"); fprintf(tc, "\t\tbreak;\n\n"); fprintf(tc, "#endif\n"); } static void put_pinit(ProcList *P) { Lextok *fp, *fpt, *t; Element *e = P->s->frst; Symbol *s = P->n; Lextok *p = P->p; int i = P->tn; int ini, j, k; if (pid_is_claim(i) && separate == 1) { fprintf(tc, "\tcase %d: /* %s */\n", i, s->name); fprintf(tc, "\t\tini_claim(%d, h);\n", i); fprintf(tc, "\t\tbreak;\n"); return; } if (!pid_is_claim(i) && separate == 2) return; ini = huntele(e, e->status, -1)->seqno; fprintf(th, "#define start%d %d\n", i, ini); if (i == eventmapnr) fprintf(th, "#define start_event %d\n", ini); fprintf(tc, "\tcase %d: /* %s */\n", i, s->name); fprintf(tc, "\t\t((P%d *)pptr(h))->_t = %d;\n", i, i); fprintf(tc, "\t\t((P%d *)pptr(h))->_p = %d;\n", i, ini); fprintf(tc, "#ifdef HAS_PRIORITY\n"); fprintf(tc, "\t\t((P%d *)pptr(h))->_priority = priority; /* was: %d */\n", i, (P->priority<1)? 1 : P->priority); fprintf(tc, "#endif\n"); fprintf(tc, "\t\treached%d[%d]=1;\n", i, ini); if (P->b == N_CLAIM) { fprintf(tc, "\t\tsrc_claim = src_ln%d;\n", i); } if (has_provided) { fprintf(tt, "\tcase %d: /* %s */\n\t\t", i, s->name); if (P->prov) { fprintf(tt, "if ("); putstmnt(tt, P->prov, 0); fprintf(tt, ")\n\t\t\t"); } fprintf(tt, "return 1;\n"); if (P->prov) fprintf(tt, "\t\tbreak;\n"); } fprintf(tc, "\t\t/* params: */\n"); for (fp = p, j=0; fp; fp = fp->rgt) for (fpt = fp->lft; fpt; fpt = fpt->rgt, j++) { t = (fpt->ntyp == ',') ? fpt->lft : fpt; if (t->sym->nel > 1 || t->sym->isarray) { lineno = t->ln; Fname = t->fn; fatal("array in parameter list, %s", t->sym->name); } fprintf(tc, "\t\t((P%d *)pptr(h))->", i); if (t->sym->type == STRUCT) { if (full_name(tc, t, t->sym, 1)) { lineno = t->ln; Fname = t->fn; fatal("hidden array in parameter %s", t->sym->name); } } else fprintf(tc, "%s", t->sym->name); fprintf(tc, " = par%d;\n", j); } fprintf(tc, "\t\t/* locals: */\n"); k = dolocal(tc, "", INIV, i, s->name, P->b); if (k > 0) { fprintf(tc, "#ifdef VAR_RANGES\n"); (void) dolocal(tc, "logval(\"", LOGV, i, s->name, P->b); fprintf(tc, "#endif\n"); } fprintf(tc, "#ifdef HAS_CODE\n"); fprintf(tc, "\t\tlocinit%d(h);\n", i); fprintf(tc, "#endif\n"); dumpclaims(tc, i, s->name); fprintf(tc, "\t break;\n"); } Element * huntstart(Element *f) { Element *e = f; Element *elast = (Element *) 0; int cnt = 0; while (elast != e && cnt++ < 200) /* new 4.0.8 */ { elast = e; if (e->n) { if (e->n->ntyp == '.' && e->nxt) e = e->nxt; else if (e->n->ntyp == UNLESS) e = e->sub->this->frst; } } if (cnt >= 200 || !e) { lineno = (f && f->n)?f->n->ln:lineno; fatal("confusing control. structure", (char *) 0); } return e; } Element * huntele(Element *f, unsigned int o, int stopat) { Element *g, *e = f; int cnt=0; /* a precaution against loops */ if (e) for ( ; cnt < 500 && e->n; cnt++) { if (e->seqno == stopat) break; switch (e->n->ntyp) { case GOTO: g = get_lab(e->n,1); if (e == g) { lineno = (f && f->n)?f->n->ln:lineno; fatal("infinite goto loop", (char *) 0); } cross_dsteps(e->n, g->n); break; case '.': case BREAK: if (!e->nxt) return e; g = e->nxt; break; case UNLESS: g = huntele(e->sub->this->frst, o, stopat); if (!g) { fatal("unexpected error 1", (char *) 0); } break; case D_STEP: case ATOMIC: case NON_ATOMIC: default: return e; } if ((o & ATOM) && !(g->status & ATOM)) return e; e = g; } if (cnt >= 500 || !e) { lineno = (f && f->n)?f->n->ln:lineno; fatal("confusing control structure", (char *) 0); } return e; } void typ2c(Symbol *sp) { int wsbits = sizeof(long)*8; /* wordsize in bits */ switch (sp->type) { case UNSIGNED: if (sp->hidden&1) fprintf(th, "\tuchar %s;", sp->name); else fprintf(th, "\tunsigned %s : %d", sp->name, sp->nbits); LstSet = sp; if (nBits%wsbits > 0 && wsbits - nBits%wsbits < sp->nbits) { /* must padd to a word-boundary */ nBits += wsbits - nBits%wsbits; } nBits += sp->nbits; break; case BIT: if (sp->nel == 1 && sp->isarray == 0 && !(sp->hidden&1)) { fprintf(th, "\tunsigned %s : 1", sp->name); LstSet = sp; nBits++; break; } /* else fall through */ if (!(sp->hidden&1) && (verbose&32)) printf("spin: warning: bit-array %s[%d] mapped to byte-array\n", sp->name, sp->nel); nBits += 8*sp->nel; /* mapped onto array of uchars */ case MTYPE: case BYTE: case CHAN: /* good for up to 255 channels */ fprintf(th, "\tuchar %s", sp->name); LstSet = sp; break; case SHORT: fprintf(th, "\tshort %s", sp->name); LstSet = sp; break; case INT: fprintf(th, "\tint %s", sp->name); LstSet = sp; break; case STRUCT: if (!sp->Snm) fatal("undeclared structure element %s", sp->name); fprintf(th, "\tstruct %s %s", sp->Snm->name, sp->name); LstSet = ZS; break; case CODE_FRAG: case PREDEF: return; default: fatal("variable %s undeclared", sp->name); } if (sp->nel > 1 || sp->isarray) fprintf(th, "[%d]", sp->nel); fprintf(th, ";\n"); } static void ncases(FILE *fd, int p, int n, int m, const char *c[]) { int i, j; for (j = 0; c[j]; j++) for (i = n; i < m; i++) { fprintf(fd, c[j], i, p, i); fprintf(fd, "\n"); } } void qlen_type(int qmax) { fprintf(th, "\t"); if (qmax < 256) fprintf(th, "uchar"); else if (qmax < 65535) fprintf(th, "ushort"); else fprintf(th, "uint"); fprintf(th, " Qlen; /* q_size */\n"); } void genaddqueue(void) { char buf0[256]; int j, qmax = 0; Queue *q; ntimes(tc, 0, 1, Addq0); if (has_io && !nqs) fprintf(th, "#define NQS 1 /* nqs=%d, but has_io */\n", nqs); else fprintf(th, "#define NQS %d\n", nqs); for (q = qtab; q; q = q->nxt) if (q->nslots > qmax) qmax = q->nslots; for (q = qtab; q; q = q->nxt) { j = q->qid; fprintf(tc, "\tcase %d: j = sizeof(Q%d);", j, j); fprintf(tc, " q_flds[%d] = %d;", j, q->nflds); fprintf(tc, " q_max[%d] = %d;", j, max(1,q->nslots)); fprintf(tc, " break;\n"); fprintf(th, "typedef struct Q%d {\n", j); qlen_type(qmax); /* 4.2.2 */ fprintf(th, " uchar _t; /* q_type */\n"); fprintf(th, " struct {\n"); for (j = 0; j < q->nflds; j++) { switch (q->fld_width[j]) { case BIT: if (q->nflds != 1) { fprintf(th, "\t\tunsigned"); fprintf(th, " fld%d : 1;\n", j); break; } /* else fall through: smaller struct */ case MTYPE: case CHAN: case BYTE: fprintf(th, "\t\tuchar fld%d;\n", j); break; case SHORT: fprintf(th, "\t\tshort fld%d;\n", j); break; case INT: fprintf(th, "\t\tint fld%d;\n", j); break; default: fatal("bad channel spec", ""); } } fprintf(th, " } contents[%d];\n", max(1, q->nslots)); fprintf(th, "} Q%d;\n", q->qid); } fprintf(th, "typedef struct Q0 {\t/* generic q */\n"); qlen_type(qmax); /* 4.2.2 */ fprintf(th, " uchar _t;\n"); fprintf(th, "} Q0;\n"); ntimes(tc, 0, 1, Addq1); fprintf(tc, "#ifdef TRIX\n"); fprintf(tc, "int\nwhat_p_size(int t)\n{\tint j;\n"); fprintf(tc, " switch (t) {\n"); ntimes(tc, 0, nrRdy+1, R5); /* +1 for np_ */ fprintf(tc, " default: Uerror(\"bad proctype\");\n"); fprintf(tc, " }\n return j;\n}\n\n"); fprintf(tc, "int\nwhat_q_size(int t)\n{\tint j;\n"); fprintf(tc, " switch (t) {\n"); for (j = 0; j < nqs+1; j++) { fprintf(tc, " case %d: j = sizeof(Q%d); break;\n", j, j); } fprintf(tc, " default: Uerror(\"bad qtype\");\n"); fprintf(tc, " }\n return j;\n}\n"); fprintf(tc, "#endif\n\n"); if (has_random) { fprintf(th, "int Q_has(int"); for (j = 0; j < Mpars; j++) fprintf(th, ", int, int"); fprintf(th, ");\n"); fprintf(tc, "int\nQ_has(int into"); for (j = 0; j < Mpars; j++) fprintf(tc, ", int want%d, int fld%d", j, j); fprintf(tc, ")\n"); fprintf(tc, "{ int i;\n\n"); fprintf(tc, " if (!into--)\n"); fprintf(tc, " uerror(\"ref to unknown chan "); fprintf(tc, "(recv-poll)\");\n\n"); fprintf(tc, " if (into >= now._nr_qs || into < 0)\n"); fprintf(tc, " Uerror(\"qrecv bad queue#\");\n\n"); fprintf(tc, " for (i = 0; i < ((Q0 *)qptr(into))->Qlen;"); fprintf(tc, " i++)\n"); fprintf(tc, " {\n"); for (j = 0; j < Mpars; j++) { fprintf(tc, " if (want%d && ", j); fprintf(tc, "qrecv(into+1, i, %d, 0) != fld%d)\n", j, j); fprintf(tc, " continue;\n"); } fprintf(tc, " return i+1;\n"); fprintf(tc, " }\n"); fprintf(tc, " return 0;\n"); fprintf(tc, "}\n"); } fprintf(tc, "#if NQS>0\n"); fprintf(tc, "void\nqsend(int into, int sorted"); for (j = 0; j < Mpars; j++) fprintf(tc, ", int fld%d", j); fprintf(tc, ", int args_given)\n"); ntimes(tc, 0, 1, Addq11); for (q = qtab; q; q = q->nxt) { sprintf(buf0, "((Q%d *)z)->", q->qid); fprintf(tc, "\tcase %d:%s\n", q->qid, (q->nslots)?"":" /* =rv= */"); if (q->nslots == 0) /* reset handshake point */ fprintf(tc, "\t\t(trpt+2)->o_m = 0;\n"); if (has_sorted) { fprintf(tc, "\t\tif (!sorted) goto append%d;\n", q->qid); fprintf(tc, "\t\tfor (j = 0; j < %sQlen; j++)\n", buf0); fprintf(tc, "\t\t{\t/* find insertion point */\n"); sprintf(buf0, "((Q%d *)z)->contents[j].fld", q->qid); for (j = 0; j < q->nflds; j++) { fprintf(tc, "\t\t\tif (fld%d > %s%d) continue;\n", j, buf0, j); fprintf(tc, "\t\t\tif (fld%d < %s%d) ", j, buf0, j); fprintf(tc, "goto found%d;\n\n", q->qid); } fprintf(tc, "\t\t}\n"); fprintf(tc, "\tfound%d:\n", q->qid); sprintf(buf0, "((Q%d *)z)->", q->qid); fprintf(tc, "\t\tfor (k = %sQlen - 1; k >= j; k--)\n", buf0); fprintf(tc, "\t\t{\t/* shift up */\n"); for (j = 0; j < q->nflds; j++) { fprintf(tc, "\t\t\t%scontents[k+1].fld%d = ", buf0, j); fprintf(tc, "%scontents[k].fld%d;\n", buf0, j); } fprintf(tc, "\t\t}\n"); fprintf(tc, "\tappend%d:\t/* insert in slot j */\n", q->qid); } fprintf(tc, "#ifdef HAS_SORTED\n"); fprintf(tc, "\t\t(trpt+1)->ipt = j;\n"); /* ipt was bup.oval */ fprintf(tc, "#endif\n"); fprintf(tc, "\t\t%sQlen = %sQlen + 1;\n", buf0, buf0); sprintf(buf0, "((Q%d *)z)->contents[j].fld", q->qid); for (j = 0; j < q->nflds; j++) fprintf(tc, "\t\t%s%d = fld%d;\n", buf0, j, j); fprintf(tc, "\t\tif (args_given != %d)\n", q->nflds); fprintf(tc, "\t\t{ if (args_given > %d)\n", q->nflds); fprintf(tc, "\t\t uerror(\"too many parameters in send stmnt\");\n"); fprintf(tc, "\t\t else\n"); fprintf(tc, "\t\t uerror(\"too few parameters in send stmnt\");\n"); fprintf(tc, "\t\t}\n"); fprintf(tc, "\t\tbreak;\n"); } ntimes(tc, 0, 1, Addq2); for (q = qtab; q; q = q->nxt) fprintf(tc, "\tcase %d: return %d;\n", q->qid, (!q->nslots)); ntimes(tc, 0, 1, Addq3); for (q = qtab; q; q = q->nxt) fprintf(tc, "\tcase %d: return (q_sz(from) == %d);\n", q->qid, max(1, q->nslots)); ntimes(tc, 0, 1, Addq4); for (q = qtab; q; q = q->nxt) { sprintf(buf0, "((Q%d *)z)->", q->qid); fprintf(tc, " case %d:%s\n\t\t", q->qid, (q->nslots)?"":" /* =rv= */"); if (q->nflds == 1) { fprintf(tc, "if (fld == 0) r = %s", buf0); fprintf(tc, "contents[slot].fld0;\n"); } else { fprintf(tc, "switch (fld) {\n"); ncases(tc, q->qid, 0, q->nflds, R12); fprintf(tc, "\t\tdefault: Uerror"); fprintf(tc, "(\"too many fields in recv\");\n"); fprintf(tc, "\t\t}\n"); } fprintf(tc, "\t\tif (done)\n"); if (q->nslots == 0) { fprintf(tc, "\t\t{ j = %sQlen - 1;\n", buf0); fprintf(tc, "\t\t %sQlen = 0;\n", buf0); sprintf(buf0, "\t\t\t((Q%d *)z)->contents", q->qid); } else { fprintf(tc, "\t\t{ j = %sQlen;\n", buf0); fprintf(tc, "\t\t %sQlen = --j;\n", buf0); fprintf(tc, "\t\t for (k=slot; kcontents", q->qid); for (j = 0; j < q->nflds; j++) { fprintf(tc, "\t%s[k].fld%d = \n", buf0, j); fprintf(tc, "\t\t%s[k+1].fld%d;\n", buf0, j); } fprintf(tc, "\t\t }\n"); } for (j = 0; j < q->nflds; j++) fprintf(tc, "%s[j].fld%d = 0;\n", buf0, j); fprintf(tc, "\t\t\tif (fld+1 != %d)\n\t\t\t", q->nflds); fprintf(tc, "\tuerror(\"missing pars in receive\");\n"); /* incompletely received msgs cannot be unrecv'ed */ fprintf(tc, "\t\t}\n"); fprintf(tc, "\t\tbreak;\n"); } ntimes(tc, 0, 1, Addq5); for (q = qtab; q; q = q->nxt) fprintf(tc, " case %d: j = sizeof(Q%d); break;\n", q->qid, q->qid); ntimes(tc, 0, 1, R8b); ntimes(th, 0, 1, Proto); /* function prototypes */ fprintf(th, "void qsend(int, int"); for (j = 0; j < Mpars; j++) fprintf(th, ", int"); fprintf(th, ", int);\n\n"); fprintf(th, "#define Addproc(x,y) addproc(256, y, x"); /* 256 is param outside the range of valid pids */ for (j = 0; j < Npars; j++) fprintf(th, ", 0"); fprintf(th, ")\n"); } Spin/Src6.4.5/spin.h0000664000175100017510000003174412641605057012034 0ustar ghgh/***** spin: spin.h *****/ /* * This file is part of the public release of Spin. It is subject to the * terms in the LICENSE file that is included in this source directory. * Tool documentation is available at http://spinroot.com */ #ifndef SEEN_SPIN_H #define SEEN_SPIN_H #include #include #include #if !defined(WIN32) && !defined(WIN64) #include #endif #ifndef PC #include #endif enum { INIV, PUTV, LOGV }; /* used in pangen1.c */ enum btypes { NONE, N_CLAIM, I_PROC, A_PROC, P_PROC, E_TRACE, N_TRACE }; typedef struct Lextok { unsigned short ntyp; /* node type */ short ismtyp; /* CONST derived from MTYP */ int val; /* value attribute */ int ln; /* line number */ int indstep; /* part of d_step sequence */ int uiid; /* inline id, if non-zero */ struct Symbol *fn; /* file name */ struct Symbol *sym; /* symbol reference */ struct Sequence *sq; /* sequence */ struct SeqList *sl; /* sequence list */ struct Lextok *lft, *rgt; /* children in parse tree */ } Lextok; typedef struct Slicer { Lextok *n; /* global var, usable as slice criterion */ short code; /* type of use: DEREF_USE or normal USE */ short used; /* set when handled */ struct Slicer *nxt; /* linked list */ } Slicer; typedef struct Access { struct Symbol *who; /* proctype name of accessor */ struct Symbol *what; /* proctype name of accessed */ int cnt, typ; /* parameter nr and, e.g., 's' or 'r' */ struct Access *lnk; /* linked list */ } Access; typedef struct Symbol { char *name; int Nid; /* unique number for the name */ unsigned short type; /* bit,short,.., chan,struct */ unsigned char hidden; /* bit-flags: 1=hide, 2=show, 4=bit-equiv, 8=byte-equiv, 16=formal par, 32=inline par, 64=treat as if local; 128=read at least once */ unsigned char colnr; /* for use with xspin during simulation */ unsigned char isarray; /* set if decl specifies array bound */ unsigned char *bscp; /* block scope */ int sc; /* scope seq no -- set only for proctypes */ int nbits; /* optional width specifier */ int nel; /* 1 if scalar, >1 if array */ int setat; /* last depth value changed */ int *val; /* runtime value(s), initl 0 */ Lextok **Sval; /* values for structures */ int xu; /* exclusive r or w by 1 pid */ struct Symbol *xup[2]; /* xr or xs proctype */ struct Access *access;/* e.g., senders and receives of chan */ Lextok *ini; /* initial value, or chan-def */ Lextok *Slst; /* template for structure if struct */ struct Symbol *Snm; /* name of the defining struct */ struct Symbol *owner; /* set for names of subfields in typedefs */ struct Symbol *context; /* 0 if global, or procname */ struct Symbol *next; /* linked list */ } Symbol; typedef struct Ordered { /* links all names in Symbol table */ struct Symbol *entry; struct Ordered *next; } Ordered; typedef struct Queue { short qid; /* runtime q index */ int qlen; /* nr messages stored */ int nslots, nflds; /* capacity, flds/slot */ int setat; /* last depth value changed */ int *fld_width; /* type of each field */ int *contents; /* the values stored */ int *stepnr; /* depth when each msg was sent */ struct Queue *nxt; /* linked list */ } Queue; typedef struct FSM_state { /* used in pangen5.c - dataflow */ int from; /* state number */ int seen; /* used for dfs */ int in; /* nr of incoming edges */ int cr; /* has reachable 1-relevant successor */ int scratch; unsigned long *dom, *mod; /* to mark dominant nodes */ struct FSM_trans *t; /* outgoing edges */ struct FSM_trans *p; /* incoming edges, predecessors */ struct FSM_state *nxt; /* linked list of all states */ } FSM_state; typedef struct FSM_trans { /* used in pangen5.c - dataflow */ int to; short relevant; /* when sliced */ short round; /* ditto: iteration when marked */ struct FSM_use *Val[2]; /* 0=reads, 1=writes */ struct Element *step; struct FSM_trans *nxt; } FSM_trans; typedef struct FSM_use { /* used in pangen5.c - dataflow */ Lextok *n; Symbol *var; int special; struct FSM_use *nxt; } FSM_use; typedef struct Element { Lextok *n; /* defines the type & contents */ int Seqno; /* identifies this el within system */ int seqno; /* identifies this el within a proc */ int merge; /* set by -O if step can be merged */ int merge_start; int merge_single; short merge_in; /* nr of incoming edges */ short merge_mark; /* state was generated in merge sequence */ unsigned int status; /* used by analyzer generator */ struct FSM_use *dead; /* optional dead variable list */ struct SeqList *sub; /* subsequences, for compounds */ struct SeqList *esc; /* zero or more escape sequences */ struct Element *Nxt; /* linked list - for global lookup */ struct Element *nxt; /* linked list - program structure */ } Element; typedef struct Sequence { Element *frst; Element *last; /* links onto continuations */ Element *extent; /* last element in original */ int minel; /* minimum Seqno, set and used only in guided.c */ int maxel; /* 1+largest id in sequence */ } Sequence; typedef struct SeqList { Sequence *this; /* one sequence */ struct SeqList *nxt; /* linked list */ } SeqList; typedef struct Label { Symbol *s; Symbol *c; Element *e; int uiid; /* non-zero if label appears in an inline */ int visible; /* label referenced in claim (slice relevant) */ struct Label *nxt; } Label; typedef struct Lbreak { Symbol *l; struct Lbreak *nxt; } Lbreak; typedef struct L_List { Lextok *n; struct L_List *nxt; } L_List; typedef struct RunList { Symbol *n; /* name */ int tn; /* ordinal of type */ int pid; /* process id */ int priority; /* for simulations only */ enum btypes b; /* the type of process */ Element *pc; /* current stmnt */ Sequence *ps; /* used by analyzer generator */ Lextok *prov; /* provided clause */ Symbol *symtab; /* local variables */ struct RunList *nxt; /* linked list */ } RunList; typedef struct ProcList { Symbol *n; /* name */ Lextok *p; /* parameters */ Sequence *s; /* body */ Lextok *prov; /* provided clause */ enum btypes b; /* e.g., claim, trace, proc */ short tn; /* ordinal number */ unsigned char det; /* deterministic */ unsigned char unsafe; /* contains global var inits */ unsigned char priority; /* process priority, if any */ struct ProcList *nxt; /* linked list */ } ProcList; typedef struct QH { int n; struct QH *nxt; } QH; typedef Lextok *Lexptr; #define YYSTYPE Lexptr #define ZN (Lextok *)0 #define ZS (Symbol *)0 #define ZE (Element *)0 #define DONE 1 /* status bits of elements */ #define ATOM 2 /* part of an atomic chain */ #define L_ATOM 4 /* last element in a chain */ #define I_GLOB 8 /* inherited global ref */ #define DONE2 16 /* used in putcode and main*/ #define D_ATOM 32 /* deterministic atomic */ #define ENDSTATE 64 /* normal endstate */ #define CHECK2 128 /* status bits for remote ref check */ #define CHECK3 256 /* status bits for atomic jump check */ #define Nhash 255 /* slots in symbol hash-table */ #define XR 1 /* non-shared receive-only */ #define XS 2 /* non-shared send-only */ #define XX 4 /* overrides XR or XS tag */ #define CODE_FRAG 2 /* auto-numbered code-fragment */ #define CODE_DECL 4 /* auto-numbered c_decl */ #define PREDEF 3 /* predefined name: _p, _last */ #define UNSIGNED 5 /* val defines width in bits */ #define BIT 1 /* also equal to width in bits */ #define BYTE 8 /* ditto */ #define SHORT 16 /* ditto */ #define INT 32 /* ditto */ #define CHAN 64 /* not */ #define STRUCT 128 /* user defined structure name */ #define SOMETHINGBIG 65536 #define RATHERSMALL 512 #define MAXSCOPESZ 1024 #ifndef max #define max(a,b) (((a)<(b)) ? (b) : (a)) #endif #ifdef PC #define MFLAGS "wb" #else #define MFLAGS "w" #endif /***** prototype definitions *****/ Element *eval_sub(Element *); Element *get_lab(Lextok *, int); Element *huntele(Element *, unsigned int, int); Element *huntstart(Element *); Element *mk_skip(void); Element *target(Element *); Lextok *do_unless(Lextok *, Lextok *); Lextok *expand(Lextok *, int); Lextok *getuname(Symbol *); Lextok *mk_explicit(Lextok *, int, int); Lextok *nn(Lextok *, int, Lextok *, Lextok *); Lextok *rem_lab(Symbol *, Lextok *, Symbol *); Lextok *rem_var(Symbol *, Lextok *, Symbol *, Lextok *); Lextok *tail_add(Lextok *, Lextok *); Lextok *return_statement(Lextok *); ProcList *ready(Symbol *, Lextok *, Sequence *, int, Lextok *, enum btypes); SeqList *seqlist(Sequence *, SeqList *); Sequence *close_seq(int); Symbol *break_dest(void); Symbol *findloc(Symbol *); Symbol *has_lab(Element *, int); Symbol *lookup(char *); Symbol *prep_inline(Symbol *, Lextok *); char *put_inline(FILE *, char *); char *emalloc(size_t); long Rand(void); int any_oper(Lextok *, int); int any_undo(Lextok *); int c_add_sv(FILE *); int cast_val(int, int, int); int checkvar(Symbol *, int); int check_track(Lextok *); int Cnt_flds(Lextok *); int cnt_mpars(Lextok *); int complete_rendez(void); int enable(Lextok *); int Enabled0(Element *); int eval(Lextok *); int find_lab(Symbol *, Symbol *, int); int find_maxel(Symbol *); int full_name(FILE *, Lextok *, Symbol *, int); int getlocal(Lextok *); int getval(Lextok *); int glob_inline(char *); int has_typ(Lextok *, int); int in_bound(Symbol *, int); int interprint(FILE *, Lextok *); int printm(FILE *, Lextok *); int is_inline(void); int ismtype(char *); int isproctype(char *); int isutype(char *); int Lval_struct(Lextok *, Symbol *, int, int); int main(int, char **); int pc_value(Lextok *); int pid_is_claim(int); int proper_enabler(Lextok *); int putcode(FILE *, Sequence *, Element *, int, int, int); int q_is_sync(Lextok *); int qlen(Lextok *); int qfull(Lextok *); int qmake(Symbol *); int qrecv(Lextok *, int); int qsend(Lextok *); int remotelab(Lextok *); int remotevar(Lextok *); int Rval_struct(Lextok *, Symbol *, int); int setlocal(Lextok *, int); int setval(Lextok *, int); int sputtype(char *, int); int Sym_typ(Lextok *); int tl_main(int, char *[]); int Width_set(int *, int, Lextok *); int yyparse(void); int yylex(void); void AST_track(Lextok *, int); void add_seq(Lextok *); void alldone(int); void announce(char *); void c_state(Symbol *, Symbol *, Symbol *); void c_add_def(FILE *); void c_add_loc(FILE *, char *); void c_add_locinit(FILE *, int, char *); void c_chandump(FILE *); void c_preview(void); void c_struct(FILE *, char *, Symbol *); void c_track(Symbol *, Symbol *, Symbol *); void c_var(FILE *, char *, Symbol *); void c_wrapper(FILE *); void chanaccess(void); void check_param_count(int, Lextok *); void checkrun(Symbol *, int); void comment(FILE *, Lextok *, int); void cross_dsteps(Lextok *, Lextok *); void disambiguate(void); void doq(Symbol *, int, RunList *); void dotag(FILE *, char *); void do_locinits(FILE *); void do_var(FILE *, int, char *, Symbol *, char *, char *, char *); void dump_struct(Symbol *, char *, RunList *); void dumpclaims(FILE *, int, char *); void dumpglobals(void); void dumplabels(void); void dumplocal(RunList *); void dumpsrc(int, int); void fatal(char *, char *); void fix_dest(Symbol *, Symbol *); void genaddproc(void); void genaddqueue(void); void gencodetable(FILE *); void genheader(void); void genother(void); void gensrc(void); void gensvmap(void); void genunio(void); void ini_struct(Symbol *); void loose_ends(void); void make_atomic(Sequence *, int); void mark_last(void); void match_trail(void); void no_side_effects(char *); void nochan_manip(Lextok *, Lextok *, int); void non_fatal(char *, char *); void ntimes(FILE *, int, int, const char *c[]); void open_seq(int); void p_talk(Element *, int); void pickup_inline(Symbol *, Lextok *, Lextok *); void plunk_c_decls(FILE *); void plunk_c_fcts(FILE *); void plunk_expr(FILE *, char *); void plunk_inline(FILE *, char *, int, int); void prehint(Symbol *); void preruse(FILE *, Lextok *); void pretty_print(void); void prune_opts(Lextok *); void pstext(int, char *); void pushbreak(void); void putname(FILE *, char *, Lextok *, int, char *); void putremote(FILE *, Lextok *, int); void putskip(int); void putsrc(Element *); void putstmnt(FILE *, Lextok *, int); void putunames(FILE *); void rem_Seq(void); void runnable(ProcList *, int, int); void sched(void); void setaccess(Symbol *, Symbol *, int, int); void set_lab(Symbol *, Element *); void setmtype(Lextok *); void setpname(Lextok *); void setptype(Lextok *, int, Lextok *); void setuname(Lextok *); void setutype(Lextok *, Symbol *, Lextok *); void setxus(Lextok *, int); void Srand(unsigned); void start_claim(int); void struct_name(Lextok *, Symbol *, int, char *); void symdump(void); void symvar(Symbol *); void sync_product(void); void trackchanuse(Lextok *, Lextok *, int); void trackvar(Lextok *, Lextok *); void trackrun(Lextok *); void trapwonly(Lextok * /* , char * */); /* spin.y and main.c */ void typ2c(Symbol *); void typ_ck(int, int, char *); void undostmnt(Lextok *, int); void unrem_Seq(void); void unskip(int); void whoruns(int); void wrapup(int); void yyerror(char *, ...); extern int unlink(const char *); #define TMP_FILE1 "._s_p_i_n_" #define TMP_FILE2 "._n_i_p_s_" #endif Spin/Src6.4.5/pangen2.h0000664000175100017510000011103412641605057012404 0ustar ghgh/***** spin: pangen2.h *****/ /* * This file is part of the public release of Spin. It is subject to the * terms in the LICENSE file that is included in this source directory. * Tool documentation is available at http://spinroot.com */ static const char *Pre0[] = { "#ifdef SC", " #define _FILE_OFFSET_BITS 64", /* allows file sizes greater than 2Gb */ "#endif", "#include ", "#include ", "#include ", "#include ", "#include ", "#include ", "#include ", "#if defined(WIN32) || defined(WIN64)", "#include ", "#else", "#include ", "#include ", "#endif", "#include ", /* defines off_t */ "#include ", "#include ", "#include ", "#define Offsetof(X, Y) ((ulong)(&(((X *)0)->Y)))", "#ifndef max", "#define max(a,b) (((a)<(b)) ? (b) : (a))", "#endif", "#ifndef PRINTF", "int Printf(const char *fmt, ...); /* prototype only */", "#endif", 0, }; static const char *Separate[] = { "#ifdef COLLAPSE", " #if (NCORE>1 && !defined(SEP_STATE)) || defined(BFS_PAR)", " volatile ulong *ncomps; /* in shared memory */", " #else", " ulong ncomps[256+2];", " #endif", "#endif", "Trans ***trans; /* 1 ptr per state per proctype */\n", "", "#if VECTORSZ>32000", " int P_o[MAXPROC], P_o_tmp[MAXPROC+1];", " int Q_o[MAXQ], Q_o_tmp[MAXPROC+1];", "", " int *proc_offset = (int *) P_o;", " int *q_offset = (int *) Q_o;", "#else", " short P_o[MAXPROC], P_o_tmp[MAXPROC+1];", " short Q_o[MAXQ], Q_o_tmp[MAXPROC+1];", "", " short *proc_offset = (short *) P_o;", " short *q_offset = (short *) Q_o;", "#endif", "uchar P_s[MAXPROC+1], P_s_tmp[MAXPROC+1];", "uchar Q_s[MAXQ+1], Q_s_tmp[MAXQ+1];", "uchar *proc_skip = (uchar *) P_s;", "uchar *q_skip = (uchar *) Q_s;", "", "#ifdef TRIX", " TRIX_v6 *freebodies;", " TRIX_v6 *processes[MAXPROC+1];", " TRIX_v6 *channels[MAXQ+1];", " long _p_count[MAXPROC];", " long _c_count[MAXPROC];", "#endif\n", "ulong vsize; /* vector size in bytes */", "#ifdef SVDUMP", " int vprefix=0, svfd; /* runtime option -pN */", "#endif", "char *tprefix = \"trail\"; /* runtime option -tsuffix */", "short boq = -1; /* blocked_on_queue status */", "int _; /* predefined write-only variable */", "#ifdef PEG", " long peg[NTRANS];", "#endif", 0, }; static const char *Preamble[] = { "#ifdef RANDOMIZE", " #define T_RAND RANDOMIZE", "#endif", "#ifdef CNTRSTACK", " #define onstack_now() (LL[trpt->j6] && LL[trpt->j7])", " #define onstack_put() LL[trpt->j6]++; LL[trpt->j7]++", " #define onstack_zap() LL[trpt->j6]--; LL[trpt->j7]--", "#endif", "#if !defined(SAFETY) && !defined(NOCOMP)", /* * V_A identifies states in the current statespace * A_V identifies states in the 'other' statespace * S_A remembers how many leading bytes in the sv * are used for these markers + fairness bits */ " #define V_A (((now._a_t&1)?2:1) << (now._a_t&2))", " #define A_V (((now._a_t&1)?1:2) << (now._a_t&2))", " int S_A = 0;", "#else", " #define V_A 0", " #define A_V 0", " #define S_A 0", "#endif", "#ifdef MA", "#undef onstack_now", "#undef onstack_put", "#undef onstack_zap", "#define onstack_put() ;", "#define onstack_zap() g_store((char *) &now, vsize, 4)", "#else", "#if defined(FULLSTACK) && !defined(BITSTATE)", "#define onstack_put() trpt->ostate = Lstate", "#define onstack_zap() { \\", " if (trpt->ostate) \\", " trpt->ostate->tagged = \\", " (S_A)? (trpt->ostate->tagged&~V_A) : 0; \\", " }", "#endif", "#endif", "H_el **H_tab, **S_Tab;", "/* #ifndef BFS_PAR */", " H_el *Lstate;", "/* #endif */", "Trail *trail, *trpt;", "FILE *efd;", "uchar *this;", "long maxdepth=10000;", "long omaxdepth=10000;", "#ifdef BCS", " /* bitflags in trpt->bcs */", " #define B_PHASE1 1", " #define B_PHASE2 2", " #define B_FORCED 4", "int sched_max = 0;", "#endif", "", "double quota; /* time limit */", "#if NCORE>1", " long z_handoff = -1;", "#endif", "#ifdef SC", /* stack cycling */ " char *stackfile;", "#endif", "uchar *SS, *LL;", "", "uchar reversing = 0;", "uchar HASH_NR = 0;", "", "double memcnt = (double) 0;", "double memlim = (double) (1<<30); /* 1 GB */", "#if NCORE>1", "double mem_reserved = (double) 0;", "#endif", "", "/* for emalloc: */", "static char *have;", "static long left = 0L;", "static double fragment = (double) 0;", "static ulong grow;", "", #if 1 "unsigned int HASH_CONST[] = {", " /* generated by hashgen 421 -- assumes 4 bytes per int */", " 0x100d4e63, 0x0fc22f87, 0xa7155c77, 0x78f2c3b9,", " 0xde32d207, 0xc27d305b, 0x1bb3fb2b, 0x2798c7a5,", " 0x9c675ffd, 0x777d9081, 0x07aef2f1, 0xae08922f,", " 0x5bd365b7, 0xed51c47b, 0x9b5aeea1, 0xbcc9d431,", " 0x396d8fff, 0xa2fd1367, 0x08616521, 0x5e84991f,", " 0x87495bc5, 0x2930039b, 0xceb6a593, 0xfe522d63,", " 0x7ff60baf, 0xf89b1fbf, 0x74c01755, 0xe0c559bf,", " 0x3669fc47, 0x8756d3bf, 0x14f78445, 0x24c41779,", " 0x0af7b129, 0xde22368d, 0x3e1c01e3, 0xaf773e49,", " 0x5b762459, 0x86d12911, 0x0953a3af, 0xb66dc23d,", " 0x96b3bd4f, 0x19b1dd51, 0xd886fbc3, 0xa7f3a025,", " 0xccb48e63, 0x87d8f027, 0x2bea270d, 0xdb0e9379,", " 0x78c09f21, 0x0cbbfe07, 0xea4bc7c3, 0x5bfbc3c9,", " 0x3c6e53fd, 0xab320cdd, 0x31041409, 0x416e7485,", " 0xe41d75fd, 0xc3c5060f, 0x201a9dc1, 0x93dee72b,", " 0x6461305f, 0xc571dec5, 0xa1fd21c5, 0xfb421ce1,", " 0x7f024b05, 0xfa518819, 0x6c9777fb, 0x0d4d9351,", " 0x08b33861, 0xccb9d0f3, 0x34112791, 0xe962d7c9,", " 0x8d742211, 0xcd9c47a1, 0x64437b69, 0x5fe40feb,", " 0x806113cb, 0x10e1d593, 0x821851b3, 0x057a1ff3,", " 0x8ededc0b, 0x90dd5b31, 0x635ff359, 0x68dbcd35,", " 0x1050ff4f, 0xdbb07257, 0x486336db, 0x83af1e75,", " 0x432f1799, 0xc1d0e7e7, 0x21f4eb5b, 0x881ec2c1,", " 0x23f3b539, 0x6cdfb80d, 0x71d474cf, 0x97d5d4a9,", " 0xf721d2e5, 0xb5ff3711, 0x3f2e58cd, 0x4e06e3d9,", " 0x7d711739, 0x927887df, 0x7d57ad71, 0x232eb767,", " 0xe3f5cc51, 0x6576b443, 0xed17bf1f, 0x8828b637,", " 0xc940f6ab, 0xc7b830ef, 0x11ed8a13, 0xaff20949,", " 0xf28a8465, 0x0da10cf9, 0xb512497d, 0x44accae1,", " 0x95e0929f, 0xe08c8901, 0xfd22d6c9, 0xb6a5c029,", " 0xaadb428d, 0x6e8a453d, 0x3d5c0195, 0x8bf4ae39,", " 0xbf83ab19, 0x3e9dac33, 0xc4df075d, 0x39472d71,", " 0xb8647725, 0x1a6d4887, 0x78a03577, 0xafd76ef7,", " 0xc1a1d6b3, 0x1afb33c5, 0x87896299, 0x5cc992ef,", " 0x7f805d0d, 0x089a039b, 0xa353cc27, 0x57b296b3,", " 0x52badec9, 0xc916e431, 0x09171957, 0x14996d51,", " 0xe87e32c7, 0xb4fdbb5d, 0xdd216a03, 0x4ddd3fff,", " 0x767d5c57, 0x79c97509, 0xab70543b, 0xc5feca4f,", " 0x8eb37b89, 0x20a2cefd, 0xf4b00b91, 0xf166593d,", " 0x7bf50f65, 0x753e6c8b, 0xfb5b81dd, 0xf2d45ef5,", " 0x9741c04f, 0x300da48d, 0x01dc4121, 0xa112cd47,", " 0x0223b24b, 0xa89fbce7, 0x681e1f7b, 0xe7c6aedf,", " 0x1fd3d523, 0x561ba723, 0xf54042fb, 0x1a516751,", " 0xcd085bd5, 0xe74246d5, 0x8b170b5d, 0x249985e9,", " 0x5b4d9cf7, 0xe9912323, 0x5fc0f339, 0x41f8f051,", " 0x8a296fb1, 0x62909f51, 0x2c05d695, 0x095efccb,", " 0xa91574f1, 0x0f5cc6c3, 0x23a2ca2b, 0xc6053ec1,", " 0xeb19e081, 0x3d1b3997, 0xb0c5f3cd, 0xe5d85b35,", " 0x1cb1bdf1, 0x0c8f278f, 0x518249c3, 0x9f61b68d,", " 0xade0919d, 0x779e29c3, 0xdbac9485, 0x2ce149a9,", " 0x254c2409, 0x205b34fb, 0xc8ab1a89, 0x6b4a2585,", " 0x2303d94b, 0x8fa186b9, 0x49826da5, 0xd23a37ad,", " 0x680b18c9, 0xa46fbd7f, 0xe42c2cf9, 0xf7cfcb5f,", " 0xb4842b8b, 0xe483780d, 0x66cf756b, 0x3eb73781,", " 0x41ca17a5, 0x59f91b0f, 0x92fb67d9, 0x0a5c330f,", " 0x46013fdb, 0x3b0634af, 0x9024f533, 0x96a001a7,", " 0x15bcd793, 0x3a311fb1, 0x78913b8b, 0x9d4a5ddf,", " 0x33189b31, 0xa99e8283, 0xf7cb29e9, 0x12d64a27,", " 0xeda770ff, 0xa7320297, 0xbd3c14a5, 0x96d0156f,", " 0x0115db95, 0x7f79f52b, 0xa6d52521, 0xa063d4bd,", " 0x9cb5e039, 0x42cf8195, 0xcb716835, 0x1bc21273,", " 0x5a67ad27, 0x4b3b0545, 0x162cda67, 0x0489166b,", " 0x85fd06a9, 0x562b037d, 0x995bc1f3, 0xe144e78b,", " 0x1e749f69, 0xa36df057, 0xcfee1667, 0x8c4116b7,", " 0x94647fe3, 0xe6899df7, 0x6d218981, 0xf1069079,", " 0xd1851a33, 0xf424fc83, 0x24467005, 0xad8caf59,", " 0x1ae5da13, 0x497612f9, 0x10f6d1ef, 0xeaf4ff05,", " 0x405f030b, 0x693b041d, 0x2065a645, 0x9fec71b3,", " 0xc3bd1b0f, 0xf29217a3, 0x0f25e15d, 0xd48c2b97,", " 0xce8acf2d, 0x0629489b, 0x1a5b0e01, 0x32d0c059,", " 0x2d3664bf, 0xc45f3833, 0xd57f551b, 0xbdd991c5,", " 0x9f97da9f, 0xa029c2a9, 0x5dd0cbdf, 0xe237ba41,", " 0x62bb0b59, 0x93e7d037, 0x7e495619, 0x51b8282f,", " 0x853e8ef3, 0x9b8abbeb, 0x055f66f9, 0x2736f7e5,", " 0x8d7e6353, 0x143abb65, 0x4e2bb5b3, 0x872e1adf,", " 0x8fcac853, 0xb7cf6e57, 0x12177f3d, 0x1d2da641,", " 0x07856425, 0xc0ed53dd, 0x252271d9, 0x79874843,", " 0x0aa8c9b5, 0x7e804f93, 0x2d080e09, 0x3929ddfd,", " 0x36433dbd, 0xd6568c17, 0xe624e939, 0xb33189ef,", " 0x29e68bff, 0x8aae2433, 0xe6335499, 0xc5facd9d,", " 0xbd5afc65, 0x7a584fa7, 0xab191435, 0x64bbdeef,", " 0x9f5cd8e1, 0xb3a1be05, 0xbd0c1753, 0xb00e2c7f,", " 0x6a96e315, 0x96a31589, 0x660af5af, 0xc0438d43,", " 0x17637373, 0x6460e8df, 0x7d458de9, 0xd76b923f,", " 0x316f045f, 0x3ccbd035, 0x63f64d81, 0xd990d969,", " 0x7c860a93, 0x99269ff7, 0x6fbcac8f, 0xd8cc562b,", " 0x67141071, 0x09f85ea3, 0x1298f2dd, 0x41fa86e5,", " 0xce1d7cf5, 0x6b232c9d, 0x8f093d4b, 0x3203ad4b,", " 0x07d70d5f, 0x38c44c75, 0x0887c9ef, 0x1833acf5,", " 0xa3607f85, 0x7d367573, 0x0ea4ffc3, 0xad2d09c1,", " 0x7a1e664f, 0xef41dff5, 0x03563491, 0x67f30a1f,", " 0x5ce5f9ef, 0xa2487a27, 0xe5077957, 0x9beb36fd,", " 0x16e41251, 0x216799ef, 0x07181f8d, 0xc191c3cf,", " 0xba21cab5, 0x73944eb7, 0xdf9eb69d, 0x5fef6cfd,", " 0xd750a6f5, 0x04f3fa43, 0x7cb2d063, 0xd3bdb369,", " 0x35f35981, 0x9f294633, 0x5e293517, 0x70e51d05,", " 0xf8db618d, 0x66ee05db, 0x835eaa77, 0x166a02c3,", " 0xb516f283, 0x94102293, 0x1ace50a5, 0x64072651,", " 0x66df7b75, 0x02e1b261, 0x8e6a73b9, 0x19dddfe7,", " 0xd551cf39, 0x391c17cb, 0xf4304de5, 0xcd67b8d1,", " 0x25873e8d, 0x115b4c71, 0x36e062f3, 0xaec0c7c9,", " 0xd929f79d, 0x935a661b, 0xda762b47, 0x170bd76b,", " 0x1a955cb5, 0x341fb0ef, 0x7f366cef, 0xc98f60c7,", " 0xa4181af3, 0xa94a8837, 0x5fa3bc43, 0x11c638c1,", " 0x4e66fabb, 0x30ab85cf, 0x250704ef, 0x8bf3bc07,", " 0x6d2cd5ab, 0x613ef9c3, 0xb8e62149, 0x0404fd91,", " 0xa04fd9b1, 0xa5e389eb, 0x9543bd23, 0xad6ca1f9,", " 0x210c49ab, 0xf8e9532b, 0x854fba89, 0xdc7fc6bb,", " 0x48a051a7, 0x6b2f383b, 0x61a4b433, 0xd3af231b,", " 0xc5023fc7, 0xa5aa85df, 0xa0cd1157, 0x4206f64d,", " 0x3fea31c3, 0x62d510a1, 0x13988957, 0x6a11a033,", " 0x46f2a3b7, 0x2784ef85, 0x229eb9eb, 0x9c0c3053,", " 0x5b7ead39, 0x82ae9afb, 0xf99e9fb3, 0x914b6459,", " 0xaf05edd7, 0xc82710dd, 0x8fc1ea1f, 0x7e0d7a8d,", " 0x7c7592e9, 0x65321017, 0xea57553f, 0x4aeb49ff,", " 0x5239ae4d, 0x4b4b4585, 0x94091c21, 0x7eaaf4cb,", " 0x6b489d6f, 0xecb9c0c3, 0x29a7af63, 0xaf117a0d,", " 0x969ea6cd, 0x7658a34d, 0x5fc0bba9, 0x26e99b7f,", " 0x7a6f260f, 0xe37c34f1, 0x1a1569bb, 0xc3bc7371,", " 0x8567543d, 0xad0c46a9, 0xa1264fd9, 0x16f10b29,", " 0x5e00dd3b, 0xf85b6bcd, 0xa2d32d8b, 0x4a3c8d43,", " 0x6b33b959, 0x4fd1e6c9, 0x7938b8a9, 0x1ec795c7,", " 0xe2ef3409, 0x83c16b9d, 0x0d3fd9eb, 0xeb461ad7,", " 0xb09c831d, 0xaf052001, 0x7911164d, 0x1a9dc191,", " 0xb52a0815, 0x0f732157, 0xc68c4831, 0x12cf3cbb };", #else "unsigned int HASH_CONST[] = {", " /* asuming 4 bytes per int */", " 0x100d4e63, 0x0fc22f87,", " 0x3ff0c3ff, 0x38e84cd7,", " 0x02b148e9, 0x98b2e49d,", " 0xb616d379, 0xa5247fd9,", " 0xbae92a15, 0xb91c8bc5,", " 0x8e5880f3, 0xacd7c069,", " 0xb4c44bb3, 0x2ead1fb7,", " 0x8e428171, 0xdbebd459,", " 0x00400007, 0x04c11db7,", " 0x828ae611, 0x6cb25933,", " 0x86cdd651, 0x9e8f5f21,", " 0xd5f8d8e7, 0x9c4e956f,", " 0xb5cf2c71, 0x2e805a6d,", " 0x33fc3a55, 0xaf203ed1,", " 0xe31f5909, 0x5276db35,", " 0x0c565ef7, 0x273d1aa5,", " 0x8923b1dd, 0xa9acaac5,", " 0xd1f69207, 0xedfd944b,", " 0x9a68e46b, 0x5355e13f,", " 0x7eeb44f9, 0x932beea9,", " 0x330c4cd3, 0x87f34e5f,", " 0x1b5851b7, 0xb9ca6447,", " 0x58f96a8f, 0x1b3b5307,", " 0x31c387b3, 0xf35f0f35,", " 0xa0acc4df, 0xf3140303,", " 0x2446245d, 0xe4b8f4ef,", " 0x5c007383, 0x68e648af,", " 0x1814fba7, 0xcdf731b5,", " 0xd09ccb4b, 0xb92d0eff,", " 0xcc3c6b67, 0xd3af6a57,", " 0xf44fc3f5, 0x5bb67623,", " 0xaeb9c953, 0x5e0ac739,", " 0x3a7fda09, 0x5edf39eb,", " 0x661eefd9, 0x6423f0d1,", " 0x910fe413, 0x9ec92297,", " 0x4bd8159d, 0xa7b16ee1,", " 0x89d484e9, 0x7f305cb3,", " 0xc5f303e7, 0x415deeef,", " 0x09986f89, 0x7e9c4117,", " 0x0b7cbedb, 0xf9ed7561,", " 0x7a20ac99, 0xf05adef3,", " 0x5893d75b, 0x44d73327,", " 0xb583c873, 0x324d2145,", " 0x7fa3829b, 0xe4b47a23,", " 0xe256d94f, 0xb1fd8959,", " 0xe561a321, 0x1435ac09,", " 0xdd62408b, 0x02ec0bcb,", " 0x5469b785, 0x2f4f50bb,", " 0x20f19395, 0xf96ba085,", " 0x2381f937, 0x768e2a11 };", #endif "", "#if NCORE>1", "extern int core_id;", "#endif", "long mreached=0;", "int done=0, errors=0, Nrun=1;", "int c_init_done=0;", "char *c_stack_start = (char *) 0;", "double nstates=0, nlinks=0, truncs=0, truncs2=0;", "double nlost=0, nShadow=0, hcmp=0, ngrabs=0;", "#ifdef BFS_PAR", "extern ulong bfs_punt;", "#endif", "#ifdef PUTPID", "char *progname;", "#endif", "#if defined(ZAPH) && defined(BITSTATE)", "double zstates = 0;", "#endif", "/* int c_init_run; */", "#ifdef REVERSE", " #define P_REVERSE", "#endif", "#ifdef T_REVERSE", " int t_reverse = 1;", /* can be modified with a parameter */ "#else", " int t_reverse = 0;", "#endif", "#ifdef BFS", "double midrv=0, failedrv=0, revrv=0;", "#endif", "ulong nr_states=0; /* nodes in DFA */", "long Fa=0, Fh=0, Zh=0, Zn=0;", "long PUT=0, PROBE=0, ZAPS=0;", "long Ccheck=0, Cholds=0;", "int a_cycles=0, upto=1, strict=0, verbose = 0, signoff = 0;", "#ifdef HAS_CODE", "int gui = 0, coltrace = 0, readtrail = 0;", "int whichtrail = 0, whichclaim = -1, onlyproc = -1, silent = 0;", "char *claimname;", "#endif", "int state_tables=0, fairness=0, no_rck=0, Nr_Trails=0, dodot=0;", "char simvals[256];", "#ifndef INLINE", "int TstOnly=0;", "#endif", "ulong mask, nmask;", "#ifdef BITSTATE", "int ssize=27; /* 16 Mb */", "#else", "int ssize=24; /* 16M slots */", "#endif", "int hmax=0, svmax=0, smax=0;", "int Maxbody=0, XX;", "uchar *noptr, *noqptr; /* used by Pptr(x) and Qptr(x) */", "#ifdef VAR_RANGES", "void logval(char *, int);", "void dumpranges(void);", "#endif", "#ifdef MA", "#define INLINE_REV", "extern void dfa_init(unsigned short);", "extern int dfa_member(ulong);", "extern int dfa_store(uchar *);", "unsigned int maxgs = 0;", "#endif", "", "#ifdef ALIGNED", " State comp_now __attribute__ ((aligned (8)));", " /* gcc 64-bit aligned for Itanium2 systems */", " /* MAJOR runtime penalty if not used on those systems */", "#else", " State comp_now; /* compressed state vector */", "#endif", "", "#ifndef HC", " #ifdef BFS_PAR", " State tmp_msk;", " #endif", " State comp_msk;", " uchar *Mask = (uchar *) &comp_msk;", "#endif", "#ifdef COLLAPSE", " State comp_tmp;", " static char *scratch = (char *) &comp_tmp;", "#endif", "", "_Stack *stack; /* for queues, processes */", "Svtack *svtack; /* for old state vectors */", "#ifdef BITSTATE", "static unsigned int hfns = 3; /* new default */", "#endif", "static ulong j1_spin, j2_spin; /* 5.2.1: avoid nameclash with math.h */", "static ulong j3_spin, j4_spin;", "ulong K1, K2;", "#ifdef BITSTATE", "long udmem;", "#endif", "#ifndef BFS_PAR", "static long A_depth = 0;", "#endif", "long depth = 0;", "long depthfound = -1; /* loop detection */", /* depth: not static to support -S2, but possible clash with embedded code */ "#if NCORE>1", "long nr_handoffs = 0;", "#endif", "uchar warned = 0, iterative = 0, exclusive = 0, like_java = 0, every_error = 0;", "uchar noasserts = 0, noends = 0, bounded = 0;", "uint s_rand = 12345; /* default seed */", "#if SYNC>0 && ASYNC==0", "void set_recvs(void);", "int no_recvs(int);", "#endif", "#if SYNC", "#define IfNotBlocked if (boq != -1) continue;", "#define UnBlock boq = -1", "#else", "#define IfNotBlocked /* cannot block */", "#define UnBlock /* don't bother */", "#endif\n", "#ifdef BITSTATE", "int (*b_store)(char *, int);", "int bstore_reg(char *, int);", "int bstore_mod(char *, int);", "#endif", "", "void dfs_uerror(char *);", "void dfs_Uerror(char *);", "#ifdef BFS_PAR", "void bfs_uerror(char *);", "void bfs_Uerror(char *);", "#endif", "void (*uerror)(char *);", "void (*Uerror)(char *);", "void (*hasher)(uchar *, int);", "void (*o_hash)(uchar *, int, int);", "void d_hash(uchar *, int);", "void m_hash(uchar *, int);", "void d_sfh(uchar *, int);", "void o_hash32(uchar *, int, int);", "void o_hash64(uchar *, int, int);", "", "void active_procs(void);", "void cleanup(void);", "void do_the_search(void);", "void find_shorter(int);", "void iniglobals(int);", "void stopped(int);", "void wrapup(void);", "int *grab_ints(int);", "void ungrab_ints(int *, int);", 0, }; static const char *Tail[] = { "Trans *", "settr( int t_id, int a, int b, int c, int d,", " char *t, int g, int tpe0, int tpe1)", "{ Trans *tmp = (Trans *) emalloc(sizeof(Trans));\n", " tmp->atom = a&(6|32); /* only (2|8|32) have meaning */", " if (!g) tmp->atom |= 8; /* no global references */", " tmp->st = b;", " tmp->tpe[0] = tpe0;", " tmp->tpe[1] = tpe1;", " tmp->tp = t;", " tmp->t_id = t_id;", " tmp->forw = c;", " tmp->back = d;", " return tmp;", "}\n", "Trans *", "cpytr(Trans *a)", "{ Trans *tmp = (Trans *) emalloc(sizeof(Trans));\n", " int i;", " tmp->atom = a->atom;", " tmp->st = a->st;", "#ifdef HAS_UNLESS", " tmp->e_trans = a->e_trans;", " for (i = 0; i < HAS_UNLESS; i++)", " tmp->escp[i] = a->escp[i];", "#endif", " tmp->tpe[0] = a->tpe[0];", " tmp->tpe[1] = a->tpe[1];", " for (i = 0; i < 6; i++)", " { tmp->qu[i] = a->qu[i];", " tmp->ty[i] = a->ty[i];", " }", " tmp->tp = (char *) emalloc(strlen(a->tp)+1);", " strcpy(tmp->tp, a->tp);", " tmp->t_id = a->t_id;", " tmp->forw = a->forw;", " tmp->back = a->back;", " return tmp;", "}\n", "#ifndef NOREDUCE", "int", "srinc_set(int n)", "{ if (n <= 2) return LOCAL;", " if (n <= 2+ DELTA) return Q_FULL_F; /* 's' or nfull */", " if (n <= 2+2*DELTA) return Q_EMPT_F; /* 'r' or nempty */", " if (n <= 2+3*DELTA) return Q_EMPT_T; /* empty */", " if (n <= 2+4*DELTA) return Q_FULL_T; /* full */", " if (n == 5*DELTA) return GLOBAL;", " if (n == 6*DELTA) return TIMEOUT_F;", " if (n == 7*DELTA) return ALPHA_F;", " Uerror(\"cannot happen srinc_class\");", " return BAD;", "}", "int", "srunc(int n, int m)", "{ switch(m) {", " case Q_FULL_F: return n-2;", " case Q_EMPT_F: return n-2-DELTA;", " case Q_EMPT_T: return n-2-2*DELTA;", " case Q_FULL_T: return n-2-3*DELTA;", " case ALPHA_F:", " case TIMEOUT_F: return 257; /* non-zero, and > MAXQ */", " }", " Uerror(\"cannot happen srunc\");", " return 0;", "}", "#endif", "int cnt;", "#ifdef HAS_UNLESS", "int", "isthere(Trans *a, int b)", /* is b already in a's list? */ "{ Trans *t;", " for (t = a; t; t = t->nxt)", " if (t->t_id == b)", " return 1;", " return 0;", "}", "#endif", "#ifndef NOREDUCE", "int", "mark_safety(Trans *t) /* for conditional safety */", "{ int g = 0, i, j, k;", "", " if (!t) return 0;", " if (t->qu[0])", " return (t->qu[1])?2:1; /* marked */", "", " for (i = 0; i < 2; i++)", " { j = srinc_set(t->tpe[i]);", " if (j >= GLOBAL && j != ALPHA_F)", " return -1;", " if (j != LOCAL)", " { k = srunc(t->tpe[i], j);", " if (g == 0", " || t->qu[0] != k", " || t->ty[0] != j)", " { t->qu[g] = k;", " t->ty[g] = j;", " g++;", " } } }", " return g;", "}", "#endif", "void", "retrans(int n, int m, int is, short srcln[], uchar reach[], uchar lpstate[])", " /* process n, with m states, is=initial state */", "{ Trans *T0, *T1, *T2, *T3;", " Trans *T4, *T5; /* t_reverse or has_unless */", " int i;", "#if defined(HAS_UNLESS) || !defined(NOREDUCE)", " int k;", "#endif", "#ifndef NOREDUCE", " int g, h, j, aa;", "#endif", "#ifdef HAS_UNLESS", " int p;", "#endif", " if (state_tables >= 4)", " { printf(\"STEP 1 %%s\\n\", ", " procname[n]);", " for (i = 1; i < m; i++)", " for (T0 = trans[n][i]; T0; T0 = T0->nxt)", " crack(n, i, T0, srcln);", " return;", " }", " do {", " for (i = 1, cnt = 0; i < m; i++)", " { T2 = trans[n][i];", " T1 = T2?T2->nxt:(Trans *)0;", "/* prescan: */ for (T0 = T1; T0; T0 = T0->nxt)", "/* choice in choice */ { if (T0->st && trans[n][T0->st]", " && trans[n][T0->st]->nxt)", " break;", " }", "#if 0", " if (T0)", " printf(\"\\tstate %%d / %%d: choice in choice\\n\",", " i, T0->st);", "#endif", " if (T0)", " for (T0 = T1; T0; T0 = T0->nxt)", " { T3 = trans[n][T0->st];", " if (!T3->nxt)", " { T2->nxt = cpytr(T0);", " T2 = T2->nxt;", " imed(T2, T0->st, n, i);", " continue;", " }", " do { T3 = T3->nxt;", " T2->nxt = cpytr(T3);", " T2 = T2->nxt;", " imed(T2, T0->st, n, i);", " } while (T3->nxt);", " cnt++;", " }", " }", " } while (cnt);", " if (state_tables >= 3)", " { printf(\"STEP 2 %%s\\n\", ", " procname[n]);", " for (i = 1; i < m; i++)", " for (T0 = trans[n][i]; T0; T0 = T0->nxt)", " crack(n, i, T0, srcln);", " return;", " }", " for (i = 1; i < m; i++)", " { if (trans[n][i] && trans[n][i]->nxt) /* optimize */", " { T1 = trans[n][i]->nxt;", "#if 0", " printf(\"\\t\\tpull %%d (%%d) to %%d\\n\",", " T1->st, T1->forw, i);", "#endif", /* pull linenumber ref as well: */ " srcln[i] = srcln[T1->st]; /* Oyvind Teig, 5.2.0 */", "", " if (!trans[n][T1->st]) continue;", " T0 = cpytr(trans[n][T1->st]);", " trans[n][i] = T0;", " reach[T1->st] = 1;", " imed(T0, T1->st, n, i);", " for (T1 = T1->nxt; T1; T1 = T1->nxt)", " {", "#if 0", " printf(\"\\t\\tpull %%d (%%d) to %%d\\n\",", " T1->st, T1->forw, i);", "#endif", " /* srcln[i] = srcln[T1->st]; gh: not useful */", " if (!trans[n][T1->st]) continue;", " T0->nxt = cpytr(trans[n][T1->st]);", " T0 = T0->nxt;", " reach[T1->st] = 1;", " imed(T0, T1->st, n, i);", " } } }", " if (state_tables >= 2)", " { printf(\"STEP 3 %%s\\n\", ", " procname[n]);", " for (i = 1; i < m; i++)", " for (T0 = trans[n][i]; T0; T0 = T0->nxt)", " crack(n, i, T0, srcln);", " return;", " }", "#ifdef HAS_UNLESS", " for (i = 1; i < m; i++)", " { if (!trans[n][i]) continue;", " /* check for each state i if an", " * escape to some state p is defined", " * if so, copy and mark p's transitions", " * and prepend them to the transition-", " * list of state i", " */", " if (!like_java) /* the default */", " { for (T0 = trans[n][i]; T0; T0 = T0->nxt)", " for (k = HAS_UNLESS-1; k >= 0; k--)", " { if (p = T0->escp[k])", " for (T1 = trans[n][p]; T1; T1 = T1->nxt)", " { if (isthere(trans[n][i], T1->t_id))", " continue;", " T2 = cpytr(T1);", " T2->e_trans = p;", " T2->nxt = trans[n][i];", " trans[n][i] = T2;", " } }", " } else /* outermost unless checked first */", " { T4 = T3 = (Trans *) 0;", " for (T0 = trans[n][i]; T0; T0 = T0->nxt)", " for (k = HAS_UNLESS-1; k >= 0; k--)", " { if (p = T0->escp[k])", " for (T1 = trans[n][p]; T1; T1 = T1->nxt)", " { if (isthere(trans[n][i], T1->t_id))", " continue;", " T2 = cpytr(T1);", " T2->nxt = (Trans *) 0;", " T2->e_trans = p;", " if (T3) T3->nxt = T2;", " else T4 = T2;", " T3 = T2;", " } }", " if (T4)", " { T3->nxt = trans[n][i];", " trans[n][i] = T4;", " }", " }", " }", "#endif", "#ifndef NOREDUCE", " for (i = 1; i < m; i++)", " { if (a_cycles)", " { /* moves through these states are visible */", " #if PROG_LAB>0 && defined(HAS_NP)", " if (progstate[n][i])", " goto degrade;", " for (T1 = trans[n][i]; T1; T1 = T1->nxt)", " if (progstate[n][T1->st])", " goto degrade;", " #endif", " if (accpstate[n][i] || visstate[n][i])", " goto degrade;", " for (T1 = trans[n][i]; T1; T1 = T1->nxt)", " if (accpstate[n][T1->st])", " goto degrade;", " }", " T1 = trans[n][i];", " if (!T1) continue;", " g = mark_safety(T1); /* V3.3.1 */", " if (g < 0) goto degrade; /* global */", " /* check if mixing of guards preserves reduction */", " if (T1->nxt)", " { k = 0;", " for (T0 = T1; T0; T0 = T0->nxt)", " { if (!(T0->atom&8))", " goto degrade;", " for (aa = 0; aa < 2; aa++)", " { j = srinc_set(T0->tpe[aa]);", " if (j >= GLOBAL && j != ALPHA_F)", " goto degrade;", " if (T0->tpe[aa]", " && T0->tpe[aa]", " != T1->tpe[0])", " k = 1;", " } }", " /* g = 0; V3.3.1 */", " if (k) /* non-uniform selection */", " for (T0 = T1; T0; T0 = T0->nxt)", " for (aa = 0; aa < 2; aa++)", " { j = srinc_set(T0->tpe[aa]);", " if (j != LOCAL)", " { k = srunc(T0->tpe[aa], j);", " for (h = 0; h < 6; h++)", " if (T1->qu[h] == k", " && T1->ty[h] == j)", " break;", " if (h >= 6)", " { T1->qu[g%%6] = k;", " T1->ty[g%%6] = j;", " g++;", " } } }", " if (g > 6)", " { T1->qu[0] = 0; /* turn it off */", " printf(\"pan: warning, line %%d, \",", " srcln[i]);", " printf(\"too many stmnt types (%%d)\",", " g);", " printf(\" in selection\\n\");", " goto degrade;", " }", " }", " /* mark all options global if >=1 is global */", " for (T1 = trans[n][i]; T1; T1 = T1->nxt)", " if (!(T1->atom&8)) break;", " if (T1)", "degrade: for (T1 = trans[n][i]; T1; T1 = T1->nxt)", " T1->atom &= ~8; /* mark as unsafe */", " /* can only mix 'r's or 's's if on same chan */", " /* and not mixed with other local operations */", " T1 = trans[n][i];", " if (!T1 || T1->qu[0]) continue;", " j = T1->tpe[0];", " if (T1->nxt && T1->atom&8)", " { if (j == 5*DELTA)", " { printf(\"warning: line %%d \", srcln[i]);", " printf(\"mixed condition \");", " printf(\"(defeats reduction)\\n\");", " goto degrade;", " }", " for (T0 = T1; T0; T0 = T0->nxt)", " for (aa = 0; aa < 2; aa++)", " if (T0->tpe[aa] && T0->tpe[aa] != j)", " { printf(\"warning: line %%d \", srcln[i]);", " printf(\"[%%d-%%d] mixed %%stion \",", " T0->tpe[aa], j, ", " (j==5*DELTA)?\"condi\":\"selec\");", " printf(\"(defeats reduction)\\n\");", " printf(\" '%%s' <-> '%%s'\\n\",", " T1->tp, T0->tp);", " goto degrade;", " } }", " }", "#endif", " for (i = 1; i < m; i++)", /* R */ " { T2 = trans[n][i];", " if (!T2", " || T2->nxt", " || strncmp(T2->tp, \".(goto)\", 7)", " || !stopstate[n][i])", " continue;", " stopstate[n][T2->st] = 1;", " }", " if (state_tables && !verbose)", " { if (dodot)", " { char buf[256], *q = buf, *p = procname[n];", " while (*p != '\\0')", " { if (*p != ':')", " { *q++ = *p;", " }", " p++;", " }", " *q = '\\0';", " printf(\"digraph \");", " switch (Btypes[n]) {", " case I_PROC: printf(\"init {\\n\"); break;", " case N_CLAIM: printf(\"claim_%%s {\\n\", buf); break;", " case E_TRACE: printf(\"notrace {\\n\"); break;", " case N_TRACE: printf(\"trace {\\n\"); break;", " default: printf(\"p_%%s {\\n\", buf); break;", " }", " printf(\"size=\\\"8,10\\\";\\n\");", " printf(\" GT [shape=box,style=dotted,label=\\\"%%s\\\"];\\n\", buf);", " printf(\" GT -> S%%d;\\n\", is);", " } else", " { switch (Btypes[n]) {", " case I_PROC: printf(\"init\\n\"); break;", " case N_CLAIM: printf(\"claim %%s\\n\", procname[n]); break;", " case E_TRACE: printf(\"notrace assertion\\n\"); break;", " case N_TRACE: printf(\"trace assertion\\n\"); break;", " default: printf(\"proctype %%s\\n\", procname[n]); break;", " } }", " for (i = 1; i < m; i++)", " { reach[i] = 1;", " }", " tagtable(n, m, is, srcln, reach);", " if (dodot) printf(\"}\\n\");", " } else", " for (i = 1; i < m; i++)", " { int nrelse;", " if (Btypes[n] != N_CLAIM)", " { for (T0 = trans[n][i]; T0; T0 = T0->nxt)", " { if (T0->st == i", " && strcmp(T0->tp, \"(1)\") == 0)", " { printf(\"error: proctype '%%s' \",", " procname[n]);", " printf(\"line %%d, state %%d: has un\",", " srcln[i], i);", " printf(\"conditional self-loop\\n\");", " pan_exit(1);", " } } }", " nrelse = 0;", " for (T0 = trans[n][i]; T0; T0 = T0->nxt)", " { if (strcmp(T0->tp, \"else\") == 0)", " nrelse++;", " }", " if (nrelse > 1)", " { printf(\"error: proctype '%%s' state\",", " procname[n]);", " printf(\" %%d, inherits %%d\", i, nrelse);", " printf(\" 'else' stmnts\\n\");", " pan_exit(1);", " } }", "#if !defined(LOOPSTATE) && !defined(BFS_PAR)", " if (state_tables)", "#endif", " do_dfs(n, m, is, srcln, reach, lpstate);", "", " if (!t_reverse)", " { return;", " }", " /* process n, with m states, is=initial state -- reverse list */", " if (!state_tables && Btypes[n] != N_CLAIM)", " { for (i = 1; i < m; i++)", /* for each state */ " { Trans *Tx = (Trans *) 0; /* list of escapes */", " Trans *Ty = (Trans *) 0; /* its tail element */", " T1 = (Trans *) 0; /* reversed list */", " T2 = (Trans *) 0; /* its tail */", " T3 = (Trans *) 0; /* remembers possible 'else' */", "", " /* find unless-escapes, they should go first */", " T4 = T5 = T0 = trans[n][i];", " #ifdef HAS_UNLESS", " while (T4 && T4->e_trans) /* escapes are first in orig list */", " { T5 = T4; /* remember predecessor */", " T4 = T4->nxt;", " }", " #endif", " /* T4 points to first non-escape, T5 to its parent, T0 to original list */", " if (T4 != T0) /* there was at least one escape */", " { T3 = T5->nxt; /* start of non-escapes */", " T5->nxt = (Trans *) 0; /* separate */", " Tx = T0; /* start of the escapes */", " Ty = T5; /* its tail */", " T0 = T3; /* the rest, to be reversed */", " }", " /* T0 points to first non-escape, Tx to the list of escapes, Ty to its tail */", "", " /* first tail-add non-escape transitions, reversed */", " T3 = (Trans *) 0;", /* remember a possible 'else' */ " for (T5 = T0; T5; T5 = T4)", " { T4 = T5->nxt;", " #ifdef HAS_UNLESS", " if (T5->e_trans)", " { printf(\"error: cannot happen!\\n\");", " continue;", " }", " #endif", " if (strcmp(T5->tp, \"else\") == 0)", " { T3 = T5;", " T5->nxt = (Trans *) 0;", " } else", " { T5->nxt = T1;", " if (!T1) { T2 = T5; }", " T1 = T5;", " } }", " /* T3 points to a possible else, which is removed from the list */", " /* T1 points to the reversed list so far (without escapes) */", " /* T2 points to the tail element -- where the else should go */", " if (T2 && T3)", " { T2->nxt = T3; /* add else */", " } else", " { if (T3) /* there was an else, but there's no tail */", " { if (!T1) /* and no reversed list */", " { T1 = T3; /* odd, but possible */", " } else /* even stranger */", " { T1->nxt = T3;", " } } }", "", " /* add in the escapes, to that they appear at the front */", " if (Tx && Ty) { Ty->nxt = T1; T1 = Tx; }", "", " trans[n][i] = T1;", " /* reversed, with escapes first and else last */", " } }", " if (state_tables && verbose)", " { printf(\"FINAL proctype %%s\\n\", ", " procname[n]);", " for (i = 1; i < m; i++)", " for (T0 = trans[n][i]; T0; T0 = T0->nxt)", " crack(n, i, T0, srcln);", " }", "}", "void", "imed(Trans *T, int v, int n, int j) /* set intermediate state */", "{ progstate[n][T->st] |= progstate[n][v];", " accpstate[n][T->st] |= accpstate[n][v];", " stopstate[n][T->st] |= stopstate[n][v];", " mapstate[n][j] = T->st;", "}", "void", "tagtable(int n, int m, int is, short srcln[], uchar reach[])", "{ Trans *z;\n", " if (is >= m || !trans[n][is]", " || is <= 0 || reach[is] == 0)", " return;", " reach[is] = 0;", " if (state_tables)", " for (z = trans[n][is]; z; z = z->nxt)", " { if (dodot)", " dot_crack(n, is, z);", " else", " crack(n, is, z, srcln);", " }", "", " for (z = trans[n][is]; z; z = z->nxt)", " {", "#ifdef HAS_UNLESS", " int i, j;", "#endif", " tagtable(n, m, z->st, srcln, reach);", "#ifdef HAS_UNLESS", " for (i = 0; i < HAS_UNLESS; i++)", " { j = trans[n][is]->escp[i];", " if (!j) break;", " tagtable(n, m, j, srcln, reach);", " }", "#endif", " }", "}", "", "extern Trans *t_id_lkup[];", /* needed by BFS_PAR */ "", "void", "dfs_table(int n, int m, int is, short srcln[], uchar reach[], uchar lpstate[])", "{ Trans *z;\n", " if (is >= m || is <= 0 || !trans[n][is])", " return;", " if ((reach[is] & (4|8|16)) != 0)", " { if ((reach[is] & (8|16)) == 16) /* on stack, not yet recorded */", " { lpstate[is] = 1;", " reach[is] |= 8; /* recorded */", " if (state_tables && verbose)", " { printf(\"state %%d line %%d is a loopstate\\n\", is, srcln[is]);", " } }", " return;", " }", " reach[is] |= (4|16); /* visited | onstack */", " for (z = trans[n][is]; z; z = z->nxt)", " { t_id_lkup[z->t_id] = z;", /* needed by BFS_PAR */ "#ifdef HAS_UNLESS", " int i, j;", "#endif", " dfs_table(n, m, z->st, srcln, reach, lpstate);", "#ifdef HAS_UNLESS", " for (i = 0; i < HAS_UNLESS; i++)", " { j = trans[n][is]->escp[i];", " if (!j) break;", " dfs_table(n, m, j, srcln, reach, lpstate);", " }", "#endif", " }", " reach[is] &= ~16; /* no longer on stack */", "}", "void", "do_dfs(int n, int m, int is, short srcln[], uchar reach[], uchar lpstate[])", "{ int i;", " dfs_table(n, m, is, srcln, reach, lpstate);", " for (i = 0; i < m; i++)", " reach[i] &= ~(4|8|16);", "}", "void", "crack(int n, int j, Trans *z, short srcln[])", "{ int i;\n", " if (!z) return;", " printf(\"\tstate %%3d -(tr %%3d)-> state %%3d \",", " j, z->forw, z->st);", " printf(\"[id %%3d tp %%3d\", z->t_id, z->tpe[0]);", " if (z->tpe[1]) printf(\",%%d\", z->tpe[1]);", "#ifdef HAS_UNLESS", " if (z->e_trans)", " printf(\" org %%3d\", z->e_trans);", " else if (state_tables >= 2)", " for (i = 0; i < HAS_UNLESS; i++)", " { if (!z->escp[i]) break;", " printf(\" esc %%d\", z->escp[i]);", " }", "#endif", " printf(\"]\");", " printf(\" [%%s%%s%%s%%s%%s] %%s:%%d => \",", " z->atom&6?\"A\":z->atom&32?\"D\":\"-\",", " accpstate[n][j]?\"a\" :\"-\",", " stopstate[n][j]?\"e\" : \"-\",", " progstate[n][j]?\"p\" : \"-\",", " z->atom & 8 ?\"L\":\"G\",", " PanSource, srcln[j]);", " for (i = 0; z->tp[i]; i++)", " if (z->tp[i] == \'\\n\')", " printf(\"\\\\n\");", " else", " putchar(z->tp[i]);", " if (verbose && z->qu[0])", " { printf(\"\\t[\");", " for (i = 0; i < 6; i++)", " if (z->qu[i])", " printf(\"(%%d,%%d)\",", " z->qu[i], z->ty[i]);", " printf(\"]\");", " }", " printf(\"\\n\");", " fflush(stdout);", "}", "/* spin -a m.pml; cc -o pan pan.c; ./pan -D | dot -Tps > foo.ps; ps2pdf foo.ps */", "void", "dot_crack(int n, int j, Trans *z)", "{ int i;\n", " if (!z) return;", " printf(\"\tS%%d -> S%%d [color=black\", j, z->st);", "", " if (z->atom&6) printf(\",style=dashed\");", /* A */ " else if (z->atom&32) printf(\",style=dotted\");", /* D */ " else if (z->atom&8) printf(\",style=solid\");", /* L */ " else printf(\",style=bold\");", /* G */ /* other styles: filled dotted */ "", " printf(\",label=\\\"\");", " for (i = 0; z->tp[i]; i++)", " { if (z->tp[i] == \'\\\\\'", " && z->tp[i+1] == \'n\')", " { i++; printf(\" \");", " } else", " { putchar(z->tp[i]);", " } }", " printf(\"\\\"];\\n\");", " if (accpstate[n][j]) printf(\" S%%d [color=red,style=bold];\\n\", j);", " else if (progstate[n][j]) printf(\" S%%d [color=green,style=bold];\\n\", j);", " if (stopstate[n][j]) printf(\" S%%d [color=blue,style=bold,shape=box];\\n\", j);", "}", "", "#ifdef VAR_RANGES", "#define BYTESIZE 32 /* 2^8 : 2^3 = 256:8 = 32 */", "", "typedef struct Vr_Ptr {", " char *nm;", " uchar vals[BYTESIZE];", " struct Vr_Ptr *nxt;", "} Vr_Ptr;", "Vr_Ptr *ranges = (Vr_Ptr *) 0;", "", "void", "logval(char *s, int v)", "{ Vr_Ptr *tmp;", "", " if (v<0 || v > 255) return;", " for (tmp = ranges; tmp; tmp = tmp->nxt)", " if (!strcmp(tmp->nm, s))", " goto found;", " tmp = (Vr_Ptr *) emalloc(sizeof(Vr_Ptr));", " tmp->nxt = ranges;", " ranges = tmp;", " tmp->nm = s;", "found:", " tmp->vals[(v)/8] |= 1<<((v)%%8);", "}", "", "void", "dumpval(uchar X[], int range)", "{ int w, x, i, j = -1;", "", " for (w = i = 0; w < range; w++)", " for (x = 0; x < 8; x++, i++)", " {", "from: if ((X[w] & (1<= 0 && j != 255)", " printf(\"-255\");", "}", "", "void", "dumpranges(void)", "{ Vr_Ptr *tmp;", " printf(\"\\nValues assigned within \");", " printf(\"interval [0..255]:\\n\");", " for (tmp = ranges; tmp; tmp = tmp->nxt)", " { printf(\"\\t%%s\\t: \", tmp->nm);", " dumpval(tmp->vals, BYTESIZE);", " printf(\"\\n\");", " }", "}", "#endif", 0, }; Spin/Src6.4.5/spinlex.c0000664000175100017510000012176112641605057012537 0ustar ghgh/***** spin: spinlex.c *****/ /* * This file is part of the public release of Spin. It is subject to the * terms in the LICENSE file that is included in this source directory. * Tool documentation is available at http://spinroot.com */ #include #include #include #include #include "spin.h" #include "y.tab.h" #define MAXINL 16 /* max recursion depth inline fcts */ #define MAXPAR 32 /* max params to an inline call */ #define MAXLEN 512 /* max len of an actual parameter text */ typedef struct IType { Symbol *nm; /* name of the type */ Lextok *cn; /* contents */ Lextok *params; /* formal pars if any */ Lextok *rval; /* variable to assign return value, if any */ char **anms; /* literal text for actual pars */ char *prec; /* precondition for c_code or c_expr */ int uiid; /* unique inline id */ int is_expr; /* c_expr in an ltl formula */ int dln, cln; /* def and call linenr */ Symbol *dfn, *cfn; /* def and call filename */ struct IType *nxt; /* linked list */ } IType; typedef struct C_Added { Symbol *s; Symbol *t; Symbol *ival; Symbol *fnm; int lno; struct C_Added *nxt; } C_Added; extern RunList *X; extern ProcList *rdy; extern Symbol *Fname, *oFname; extern Symbol *context, *owner; extern YYSTYPE yylval; extern short has_last, has_code, has_priority; extern int verbose, IArgs, hastrack, separate, in_for; extern int implied_semis, ltl_mode, in_seq, par_cnt; short has_stack = 0; int lineno = 1; int scope_seq[128], scope_level = 0; char CurScope[MAXSCOPESZ]; char yytext[2048]; FILE *yyin, *yyout; static C_Added *c_added, *c_tracked; static IType *Inline_stub[MAXINL]; static char *ReDiRect; static char *Inliner[MAXINL], IArg_cont[MAXPAR][MAXLEN]; static unsigned char in_comment=0; static int IArgno = 0, Inlining = -1; static int check_name(char *); static int last_token = 0; #define ValToken(x, y) { if (in_comment) goto again; \ yylval = nn(ZN,0,ZN,ZN); \ yylval->val = x; \ last_token = y; \ return y; \ } #define SymToken(x, y) { if (in_comment) goto again; \ yylval = nn(ZN,0,ZN,ZN); \ yylval->sym = x; \ last_token = y; \ return y; \ } static int getinline(void); static void uninline(void); static int PushBack; static int PushedBack; static char pushedback[4096]; static void push_back(char *s) { if (PushedBack + strlen(s) > 4094) { fatal("select statement too large", 0); } strcat(pushedback, s); PushedBack += strlen(s); } static int Getchar(void) { int c; if (PushedBack > 0 && PushBack < PushedBack) { c = pushedback[PushBack++]; if (PushBack == PushedBack) { pushedback[0] = '\0'; PushBack = PushedBack = 0; } return c; /* expanded select statement */ } if (Inlining<0) { c = getc(yyin); } else { c = getinline(); } #if 0 if (0) { printf("<%c:%d>[%d] ", c, c, Inlining); } else { printf("%c", c); } #endif return c; } static void Ungetch(int c) { if (Inlining<0) ungetc(c,yyin); else uninline(); if (0) { printf("\n\n", c); } } static int notdollar(int c) { return (c != '$' && c != '\n'); } static int notquote(int c) { return (c != '\"' && c != '\n'); } int isalnum_(int c) { return (isalnum(c) || c == '_'); } static int isalpha_(int c) { return isalpha(c); /* could be macro */ } static int isdigit_(int c) { return isdigit(c); /* could be macro */ } static void getword(int first, int (*tst)(int)) { int i=0, c; yytext[i++]= (char) first; while (tst(c = Getchar())) { yytext[i++] = (char) c; if (c == '\\') { c = Getchar(); yytext[i++] = (char) c; /* no tst */ } } yytext[i] = '\0'; Ungetch(c); } static int follow(int tok, int ifyes, int ifno) { int c; if ((c = Getchar()) == tok) { return ifyes; } Ungetch(c); return ifno; } static IType *seqnames; static void def_inline(Symbol *s, int ln, char *ptr, char *prc, Lextok *nms) { IType *tmp; int cnt = 0; char *nw = (char *) emalloc(strlen(ptr)+1); strcpy(nw, ptr); for (tmp = seqnames; tmp; cnt++, tmp = tmp->nxt) if (!strcmp(s->name, tmp->nm->name)) { non_fatal("procedure name %s redefined", tmp->nm->name); tmp->cn = (Lextok *) nw; tmp->params = nms; tmp->dln = ln; tmp->dfn = Fname; return; } tmp = (IType *) emalloc(sizeof(IType)); tmp->nm = s; tmp->cn = (Lextok *) nw; tmp->params = nms; if (strlen(prc) > 0) { tmp->prec = (char *) emalloc(strlen(prc)+1); strcpy(tmp->prec, prc); } tmp->dln = ln; tmp->dfn = Fname; tmp->uiid = cnt+1; /* so that 0 means: not an inline */ tmp->nxt = seqnames; seqnames = tmp; } void gencodetable(FILE *fd) { IType *tmp; char *q; int cnt; if (separate == 2) return; fprintf(fd, "struct {\n"); fprintf(fd, " char *c; char *t;\n"); fprintf(fd, "} code_lookup[] = {\n"); if (has_code) for (tmp = seqnames; tmp; tmp = tmp->nxt) if (tmp->nm->type == CODE_FRAG || tmp->nm->type == CODE_DECL) { fprintf(fd, "\t{ \"%s\", ", tmp->nm->name); q = (char *) tmp->cn; while (*q == '\n' || *q == '\r' || *q == '\\') q++; fprintf(fd, "\""); cnt = 0; while (*q && cnt < 1024) /* pangen1.h allows 2048 */ { switch (*q) { case '"': fprintf(fd, "\\\""); break; case '%': fprintf(fd, "%%"); break; case '\n': fprintf(fd, "\\n"); break; default: putc(*q, fd); break; } q++; cnt++; } if (*q) fprintf(fd, "..."); fprintf(fd, "\""); fprintf(fd, " },\n"); } fprintf(fd, " { (char *) 0, \"\" }\n"); fprintf(fd, "};\n"); } static int iseqname(char *t) { IType *tmp; for (tmp = seqnames; tmp; tmp = tmp->nxt) { if (!strcmp(t, tmp->nm->name)) return 1; } return 0; } Lextok * return_statement(Lextok *n) { if (Inline_stub[Inlining]->rval) { Lextok *g = nn(ZN, NAME, ZN, ZN); Lextok *h = Inline_stub[Inlining]->rval; g->sym = lookup("rv_"); return nn(h, ASGN, h, n); } else { fatal("return statement outside inline", (char *) 0); } return ZN; } static int getinline(void) { int c; if (ReDiRect) { c = *ReDiRect++; if (c == '\0') { ReDiRect = (char *) 0; c = *Inliner[Inlining]++; } } else { c = *Inliner[Inlining]++; } if (c == '\0') { lineno = Inline_stub[Inlining]->cln; Fname = Inline_stub[Inlining]->cfn; Inlining--; #if 0 if (verbose&32) printf("spin: %s:%d, done inlining %s\n", Fname, lineno, Inline_stub[Inlining+1]->nm->name); #endif return Getchar(); } return c; } static void uninline(void) { if (ReDiRect) ReDiRect--; else Inliner[Inlining]--; } int is_inline(void) { if (Inlining < 0) return 0; /* i.e., not an inline */ if (Inline_stub[Inlining] == NULL) fatal("unexpected, inline_stub not set", 0); return Inline_stub[Inlining]->uiid; } IType * find_inline(char *s) { IType *tmp; for (tmp = seqnames; tmp; tmp = tmp->nxt) if (!strcmp(s, tmp->nm->name)) break; if (!tmp) fatal("cannot happen, missing inline def %s", s); return tmp; } void c_state(Symbol *s, Symbol *t, Symbol *ival) /* name, scope, ival */ { C_Added *r; r = (C_Added *) emalloc(sizeof(C_Added)); r->s = s; /* pointer to a data object */ r->t = t; /* size of object, or "global", or "local proctype_name" */ r->ival = ival; r->lno = lineno; r->fnm = Fname; r->nxt = c_added; if(strncmp(r->s->name, "\"unsigned unsigned", 18) == 0) { int i; for (i = 10; i < 18; i++) { r->s->name[i] = ' '; } /* printf("corrected <%s>\n", r->s->name); */ } c_added = r; } void c_track(Symbol *s, Symbol *t, Symbol *stackonly) /* name, size */ { C_Added *r; r = (C_Added *) emalloc(sizeof(C_Added)); r->s = s; r->t = t; r->ival = stackonly; /* abuse of name */ r->nxt = c_tracked; r->fnm = Fname; r->lno = lineno; c_tracked = r; if (stackonly != ZS) { if (strcmp(stackonly->name, "\"Matched\"") == 0) r->ival = ZS; /* the default */ else if (strcmp(stackonly->name, "\"UnMatched\"") != 0 && strcmp(stackonly->name, "\"unMatched\"") != 0 && strcmp(stackonly->name, "\"StackOnly\"") != 0) non_fatal("expecting '[Un]Matched', saw %s", stackonly->name); else has_stack = 1; /* unmatched stack */ } } char * skip_white(char *p) { if (p != NULL) { while (*p == ' ' || *p == '\t') p++; } else { fatal("bad format - 1", (char *) 0); } return p; } char * skip_nonwhite(char *p) { if (p != NULL) { while (*p != ' ' && *p != '\t') p++; } else { fatal("bad format - 2", (char *) 0); } return p; } static char * jump_etc(C_Added *r) { char *op = r->s->name; char *p = op; char *q = (char *) 0; int oln = lineno; Symbol *ofnm = Fname; /* try to get the type separated from the name */ lineno = r->lno; Fname = r->fnm; p = skip_white(p); /* initial white space */ if (strncmp(p, "enum", strlen("enum")) == 0) /* special case: a two-part typename */ { p += strlen("enum")+1; p = skip_white(p); } if (strncmp(p, "unsigned", strlen("unsigned")) == 0) /* possibly a two-part typename */ { p += strlen("unsigned")+1; q = p = skip_white(p); } p = skip_nonwhite(p); /* type name */ p = skip_white(p); /* white space */ while (*p == '*') p++; /* decorations */ p = skip_white(p); /* white space */ if (*p == '\0') { if (q) { p = q; /* unsigned with implied 'int' */ } else { fatal("c_state format (%s)", op); } } if (strchr(p, '[') && !strchr(p, '{')) { non_fatal("array initialization error, c_state (%s)", p); p = (char *) 0; } lineno = oln; Fname = ofnm; return p; } void c_add_globinit(FILE *fd) { C_Added *r; char *p, *q; fprintf(fd, "void\nglobinit(void)\n{\n"); for (r = c_added; r; r = r->nxt) { if (r->ival == ZS) continue; if (strncmp(r->t->name, " Global ", strlen(" Global ")) == 0) { for (q = r->ival->name; *q; q++) { if (*q == '\"') *q = ' '; if (*q == '\\') *q++ = ' '; /* skip over the next */ } p = jump_etc(r); /* e.g., "int **q" */ if (p) fprintf(fd, " now.%s = %s;\n", p, r->ival->name); } else if (strncmp(r->t->name, " Hidden ", strlen(" Hidden ")) == 0) { for (q = r->ival->name; *q; q++) { if (*q == '\"') *q = ' '; if (*q == '\\') *q++ = ' '; /* skip over the next */ } p = jump_etc(r); /* e.g., "int **q" */ if (p) fprintf(fd, " %s = %s;\n", p, r->ival->name); /* no now. prefix */ } } fprintf(fd, "}\n"); } void c_add_locinit(FILE *fd, int tpnr, char *pnm) { C_Added *r; char *p, *q, *s; int frst = 1; fprintf(fd, "void\nlocinit%d(int h)\n{\n", tpnr); for (r = c_added; r; r = r->nxt) if (r->ival != ZS && strncmp(r->t->name, " Local", strlen(" Local")) == 0) { for (q = r->ival->name; *q; q++) if (*q == '\"') *q = ' '; p = jump_etc(r); /* e.g., "int **q" */ q = r->t->name + strlen(" Local"); while (*q == ' ' || *q == '\t') q++; /* process name */ s = (char *) emalloc(strlen(q)+1); strcpy(s, q); q = &s[strlen(s)-1]; while (*q == ' ' || *q == '\t') *q-- = '\0'; if (strcmp(pnm, s) != 0) continue; if (frst) { fprintf(fd, "\tuchar *this = pptr(h);\n"); frst = 0; } if (p) { fprintf(fd, "\t\t((P%d *)this)->%s = %s;\n", tpnr, p, r->ival->name); } } fprintf(fd, "}\n"); } /* tracking: 1. for non-global and non-local c_state decls: add up all the sizes in c_added 2. add a global char array of that size into now 3. generate a routine that memcpy's the required values into that array 4. generate a call to that routine */ void c_preview(void) { C_Added *r; hastrack = 0; if (c_tracked) hastrack = 1; else for (r = c_added; r; r = r->nxt) if (strncmp(r->t->name, " Global ", strlen(" Global ")) != 0 && strncmp(r->t->name, " Hidden ", strlen(" Hidden ")) != 0 && strncmp(r->t->name, " Local", strlen(" Local")) != 0) { hastrack = 1; /* c_state variant now obsolete */ break; } } int c_add_sv(FILE *fd) /* 1+2 -- called in pangen1.c */ { C_Added *r; int cnt = 0; if (!c_added && !c_tracked) return 0; for (r = c_added; r; r = r->nxt) /* pickup global decls */ if (strncmp(r->t->name, " Global ", strlen(" Global ")) == 0) fprintf(fd, " %s;\n", r->s->name); for (r = c_added; r; r = r->nxt) if (strncmp(r->t->name, " Global ", strlen(" Global ")) != 0 && strncmp(r->t->name, " Hidden ", strlen(" Hidden ")) != 0 && strncmp(r->t->name, " Local", strlen(" Local")) != 0) { cnt++; /* obsolete use */ } for (r = c_tracked; r; r = r->nxt) cnt++; /* preferred use */ if (cnt == 0) return 0; cnt = 0; fprintf(fd, " uchar c_state["); for (r = c_added; r; r = r->nxt) if (strncmp(r->t->name, " Global ", strlen(" Global ")) != 0 && strncmp(r->t->name, " Hidden ", strlen(" Hidden ")) != 0 && strncmp(r->t->name, " Local", strlen(" Local")) != 0) { fprintf(fd, "%ssizeof(%s)", (cnt==0)?"":"+", r->t->name); cnt++; } for (r = c_tracked; r; r = r->nxt) { if (r->ival != ZS) continue; fprintf(fd, "%s%s", (cnt==0)?"":"+", r->t->name); cnt++; } if (cnt == 0) fprintf(fd, "4"); /* now redundant */ fprintf(fd, "];\n"); return 1; } void c_stack_size(FILE *fd) { C_Added *r; int cnt = 0; for (r = c_tracked; r; r = r->nxt) if (r->ival != ZS) { fprintf(fd, "%s%s", (cnt==0)?"":"+", r->t->name); cnt++; } if (cnt == 0) { fprintf(fd, "WS"); } } void c_add_stack(FILE *fd) { C_Added *r; int cnt = 0; if ((!c_added && !c_tracked) || !has_stack) { return; } for (r = c_tracked; r; r = r->nxt) if (r->ival != ZS) { cnt++; } if (cnt > 0) { fprintf(fd, " uchar c_stack[StackSize];\n"); } } void c_add_hidden(FILE *fd) { C_Added *r; for (r = c_added; r; r = r->nxt) /* pickup hidden decls */ if (strncmp(r->t->name, "\"Hidden\"", strlen("\"Hidden\"")) == 0) { r->s->name[strlen(r->s->name)-1] = ' '; fprintf(fd, "%s; /* Hidden */\n", &r->s->name[1]); r->s->name[strlen(r->s->name)-1] = '"'; } /* called before c_add_def - quotes are still there */ } void c_add_loc(FILE *fd, char *s) /* state vector entries for proctype s */ { C_Added *r; static char buf[1024]; char *p; if (!c_added) return; strcpy(buf, s); strcat(buf, " "); for (r = c_added; r; r = r->nxt) /* pickup local decls */ if (strncmp(r->t->name, " Local", strlen(" Local")) == 0) { p = r->t->name + strlen(" Local"); fprintf(fd, "/* XXX p=<%s>, s=<%s>, buf=<%s> r->s->name=<%s>XXX */\n", p, s, buf, r->s->name); while (*p == ' ' || *p == '\t') p++; if (strcmp(p, buf) == 0) fprintf(fd, " %s;\n", r->s->name); } } void c_add_def(FILE *fd) /* 3 - called in plunk_c_fcts() */ { C_Added *r; fprintf(fd, "#if defined(C_States) && (HAS_TRACK==1)\n"); for (r = c_added; r; r = r->nxt) { r->s->name[strlen(r->s->name)-1] = ' '; r->s->name[0] = ' '; /* remove the "s */ r->t->name[strlen(r->t->name)-1] = ' '; r->t->name[0] = ' '; if (strncmp(r->t->name, " Global ", strlen(" Global ")) == 0 || strncmp(r->t->name, " Hidden ", strlen(" Hidden ")) == 0 || strncmp(r->t->name, " Local", strlen(" Local")) == 0) continue; if (strchr(r->s->name, '&')) fatal("dereferencing state object: %s", r->s->name); fprintf(fd, "extern %s %s;\n", r->t->name, r->s->name); } for (r = c_tracked; r; r = r->nxt) { r->s->name[strlen(r->s->name)-1] = ' '; r->s->name[0] = ' '; /* remove " */ r->t->name[strlen(r->t->name)-1] = ' '; r->t->name[0] = ' '; } if (separate == 2) { fprintf(fd, "#endif\n"); return; } if (has_stack) { fprintf(fd, "int cpu_printf(const char *, ...);\n"); fprintf(fd, "void\nc_stack(uchar *p_t_r)\n{\n"); fprintf(fd, "#ifdef VERBOSE\n"); fprintf(fd, " cpu_printf(\"c_stack %%u\\n\", p_t_r);\n"); fprintf(fd, "#endif\n"); for (r = c_tracked; r; r = r->nxt) { if (r->ival == ZS) continue; fprintf(fd, "\tif(%s)\n", r->s->name); fprintf(fd, "\t\tmemcpy(p_t_r, %s, %s);\n", r->s->name, r->t->name); fprintf(fd, "\telse\n"); fprintf(fd, "\t\tmemset(p_t_r, 0, %s);\n", r->t->name); fprintf(fd, "\tp_t_r += %s;\n", r->t->name); } fprintf(fd, "}\n\n"); } fprintf(fd, "void\nc_update(uchar *p_t_r)\n{\n"); fprintf(fd, "#ifdef VERBOSE\n"); fprintf(fd, " printf(\"c_update %%p\\n\", p_t_r);\n"); fprintf(fd, "#endif\n"); for (r = c_added; r; r = r->nxt) { if (strncmp(r->t->name, " Global ", strlen(" Global ")) == 0 || strncmp(r->t->name, " Hidden ", strlen(" Hidden ")) == 0 || strncmp(r->t->name, " Local", strlen(" Local")) == 0) continue; fprintf(fd, "\tmemcpy(p_t_r, &%s, sizeof(%s));\n", r->s->name, r->t->name); fprintf(fd, "\tp_t_r += sizeof(%s);\n", r->t->name); } for (r = c_tracked; r; r = r->nxt) { if (r->ival) continue; fprintf(fd, "\tif(%s)\n", r->s->name); fprintf(fd, "\t\tmemcpy(p_t_r, %s, %s);\n", r->s->name, r->t->name); fprintf(fd, "\telse\n"); fprintf(fd, "\t\tmemset(p_t_r, 0, %s);\n", r->t->name); fprintf(fd, "\tp_t_r += %s;\n", r->t->name); } fprintf(fd, "}\n"); if (has_stack) { fprintf(fd, "void\nc_unstack(uchar *p_t_r)\n{\n"); fprintf(fd, "#ifdef VERBOSE\n"); fprintf(fd, " cpu_printf(\"c_unstack %%u\\n\", p_t_r);\n"); fprintf(fd, "#endif\n"); for (r = c_tracked; r; r = r->nxt) { if (r->ival == ZS) continue; fprintf(fd, "\tif(%s)\n", r->s->name); fprintf(fd, "\t\tmemcpy(%s, p_t_r, %s);\n", r->s->name, r->t->name); fprintf(fd, "\tp_t_r += %s;\n", r->t->name); } fprintf(fd, "}\n"); } fprintf(fd, "void\nc_revert(uchar *p_t_r)\n{\n"); fprintf(fd, "#ifdef VERBOSE\n"); fprintf(fd, " printf(\"c_revert %%p\\n\", p_t_r);\n"); fprintf(fd, "#endif\n"); for (r = c_added; r; r = r->nxt) { if (strncmp(r->t->name, " Global ", strlen(" Global ")) == 0 || strncmp(r->t->name, " Hidden ", strlen(" Hidden ")) == 0 || strncmp(r->t->name, " Local", strlen(" Local")) == 0) continue; fprintf(fd, "\tmemcpy(&%s, p_t_r, sizeof(%s));\n", r->s->name, r->t->name); fprintf(fd, "\tp_t_r += sizeof(%s);\n", r->t->name); } for (r = c_tracked; r; r = r->nxt) { if (r->ival != ZS) continue; fprintf(fd, "\tif(%s)\n", r->s->name); fprintf(fd, "\t\tmemcpy(%s, p_t_r, %s);\n", r->s->name, r->t->name); fprintf(fd, "\tp_t_r += %s;\n", r->t->name); } fprintf(fd, "}\n"); fprintf(fd, "#endif\n"); } void plunk_reverse(FILE *fd, IType *p, int matchthis) { char *y, *z; if (!p) return; plunk_reverse(fd, p->nxt, matchthis); if (!p->nm->context && p->nm->type == matchthis && p->is_expr == 0) { fprintf(fd, "\n/* start of %s */\n", p->nm->name); z = (char *) p->cn; while (*z == '\n' || *z == '\r' || *z == '\\') { z++; } /* e.g.: \#include "..." */ y = z; while ((y = strstr(y, "\\#")) != NULL) { *y = '\n'; y++; } fprintf(fd, "%s\n", z); fprintf(fd, "\n/* end of %s */\n", p->nm->name); } } void plunk_c_decls(FILE *fd) { plunk_reverse(fd, seqnames, CODE_DECL); } void plunk_c_fcts(FILE *fd) { if (separate == 2 && hastrack) { c_add_def(fd); return; } c_add_hidden(fd); plunk_reverse(fd, seqnames, CODE_FRAG); if (c_added || c_tracked) /* enables calls to c_revert and c_update */ fprintf(fd, "#define C_States 1\n"); else fprintf(fd, "#undef C_States\n"); if (hastrack) c_add_def(fd); c_add_globinit(fd); do_locinits(fd); } static void check_inline(IType *tmp) { char buf[128]; ProcList *p; if (!X) return; for (p = rdy; p; p = p->nxt) { if (strcmp(p->n->name, X->n->name) == 0) continue; sprintf(buf, "P%s->", p->n->name); if (strstr((char *)tmp->cn, buf)) { printf("spin: in proctype %s, ref to object in proctype %s\n", X->n->name, p->n->name); fatal("invalid variable ref in '%s'", tmp->nm->name); } } } extern short terse; extern short nocast; void plunk_expr(FILE *fd, char *s) { IType *tmp; char *q; tmp = find_inline(s); check_inline(tmp); if (terse && nocast) { for (q = (char *) tmp->cn; q && *q != '\0'; q++) { fflush(fd); if (*q == '"') { fprintf(fd, "\\"); } fprintf(fd, "%c", *q); } } else { fprintf(fd, "%s", (char *) tmp->cn); } } void preruse(FILE *fd, Lextok *n) /* check a condition for c_expr with preconditions */ { IType *tmp; if (!n) return; if (n->ntyp == C_EXPR) { tmp = find_inline(n->sym->name); if (tmp->prec) { fprintf(fd, "if (!(%s)) { if (!readtrail) { depth++; ", tmp->prec); fprintf(fd, "trpt++; trpt->pr = II; trpt->o_t = t; trpt->st = tt; "); fprintf(fd, "uerror(\"c_expr line %d precondition false: %s\"); continue;", tmp->dln, tmp->prec); fprintf(fd, " } else { printf(\"pan: precondition false: %s\\n\"); ", tmp->prec); fprintf(fd, "_m = 3; goto P999; } } \n\t\t"); } } else { preruse(fd, n->rgt); preruse(fd, n->lft); } } int glob_inline(char *s) { IType *tmp; char *bdy; tmp = find_inline(s); bdy = (char *) tmp->cn; return (strstr(bdy, "now.") /* global ref or */ || strchr(bdy, '(') > bdy); /* possible C-function call */ } char * put_inline(FILE *fd, char *s) { IType *tmp; tmp = find_inline(s); check_inline(tmp); return (char *) tmp->cn; } void mark_last(void) { if (seqnames) { seqnames->is_expr = 1; } } void plunk_inline(FILE *fd, char *s, int how, int gencode) /* c_code with precondition */ { IType *tmp; tmp = find_inline(s); check_inline(tmp); fprintf(fd, "{ "); if (how && tmp->prec) { fprintf(fd, "if (!(%s)) { if (!readtrail) {", tmp->prec); fprintf(fd, " uerror(\"c_code line %d precondition false: %s\"); continue; ", tmp->dln, tmp->prec); fprintf(fd, "} else { "); fprintf(fd, "printf(\"pan: precondition false: %s\\n\"); _m = 3; goto P999; } } ", tmp->prec); } if (!gencode) /* not in d_step */ { fprintf(fd, "\n\t\tsv_save();"); } fprintf(fd, "%s", (char *) tmp->cn); fprintf(fd, " }\n"); } int side_scan(char *t, char *pat) { char *r = strstr(t, pat); return (r && *(r-1) != '"' && *(r-1) != '\''); } void no_side_effects(char *s) { IType *tmp; char *t; /* could still defeat this check via hidden * side effects in function calls, * but this will catch at least some cases */ tmp = find_inline(s); t = (char *) tmp->cn; if (side_scan(t, ";") || side_scan(t, "++") || side_scan(t, "--")) { bad: lineno = tmp->dln; Fname = tmp->dfn; non_fatal("c_expr %s has side-effects", s); return; } while ((t = strchr(t, '=')) != NULL) { if (*(t-1) == '!' || *(t-1) == '>' || *(t-1) == '<' || *(t-1) == '"' || *(t-1) == '\'') { t += 2; continue; } t++; if (*t != '=') goto bad; t++; } } void pickup_inline(Symbol *t, Lextok *apars, Lextok *rval) { IType *tmp; Lextok *p, *q; int j; tmp = find_inline(t->name); if (++Inlining >= MAXINL) fatal("inlines nested too deeply", 0); tmp->cln = lineno; /* remember calling point */ tmp->cfn = Fname; /* and filename */ tmp->rval = rval; for (p = apars, q = tmp->params, j = 0; p && q; p = p->rgt, q = q->rgt) j++; /* count them */ if (p || q) fatal("wrong nr of params on call of '%s'", t->name); tmp->anms = (char **) emalloc(j * sizeof(char *)); for (p = apars, j = 0; p; p = p->rgt, j++) { tmp->anms[j] = (char *) emalloc(strlen(IArg_cont[j])+1); strcpy(tmp->anms[j], IArg_cont[j]); } lineno = tmp->dln; /* linenr of def */ Fname = tmp->dfn; /* filename of same */ Inliner[Inlining] = (char *)tmp->cn; Inline_stub[Inlining] = tmp; #if 0 if (verbose&32) printf("spin: %s:%d, inlining '%s' (from %s:%d)\n", tmp->cfn->name, tmp->cln, t->name, tmp->dfn->name, tmp->dln); #endif for (j = 0; j < Inlining; j++) { if (Inline_stub[j] == Inline_stub[Inlining]) { fatal("cyclic inline attempt on: %s", t->name); } } last_token = SEMI; /* avoid insertion of extra semi */ } extern int pp_mode; static void do_directive(int first) { int c = first; /* handles lines starting with pound */ getword(c, isalpha_); if (strcmp(yytext, "#ident") == 0) goto done; if ((c = Getchar()) != ' ') fatal("malformed preprocessor directive - # .", 0); if (!isdigit_(c = Getchar())) fatal("malformed preprocessor directive - # .lineno", 0); getword(c, isdigit_); lineno = atoi(yytext); /* pickup the line number */ if ((c = Getchar()) == '\n') return; /* no filename */ if (c != ' ') fatal("malformed preprocessor directive - .fname", 0); if ((c = Getchar()) != '\"') { printf("got %c, expected \" -- lineno %d\n", c, lineno); fatal("malformed preprocessor directive - .fname (%s)", yytext); } getword(Getchar(), notquote); /* was getword(c, notquote); */ if (Getchar() != '\"') fatal("malformed preprocessor directive - fname.", 0); /* strcat(yytext, "\""); */ Fname = lookup(yytext); done: while (Getchar() != '\n') ; } void precondition(char *q) { int c, nest = 1; for (;;) { c = Getchar(); *q++ = c; switch (c) { case '\n': lineno++; break; case '[': nest++; break; case ']': if (--nest <= 0) { *--q = '\0'; return; } break; } } fatal("cannot happen", (char *) 0); /* unreachable */ } Symbol * prep_inline(Symbol *s, Lextok *nms) { int c, nest = 1, dln, firstchar, cnr; char *p; Lextok *t; static char Buf1[SOMETHINGBIG], Buf2[RATHERSMALL]; static int c_code = 1; for (t = nms; t; t = t->rgt) if (t->lft) { if (t->lft->ntyp != NAME) fatal("bad param to inline %s", s?s->name:"--"); t->lft->sym->hidden |= 32; } if (!s) /* C_Code fragment */ { s = (Symbol *) emalloc(sizeof(Symbol)); s->name = (char *) emalloc(strlen("c_code")+26); sprintf(s->name, "c_code%d", c_code++); s->context = context; s->type = CODE_FRAG; } else { s->type = PREDEF; } p = &Buf1[0]; Buf2[0] = '\0'; for (;;) { c = Getchar(); switch (c) { case '[': if (s->type != CODE_FRAG) goto bad; precondition(&Buf2[0]); /* e.g., c_code [p] { r = p-r; } */ continue; case '{': break; case '\n': lineno++; /* fall through */ case ' ': case '\t': case '\f': case '\r': continue; default : printf("spin: saw char '%c'\n", c); bad: fatal("bad inline: %s", s->name); } break; } dln = lineno; if (s->type == CODE_FRAG) { if (verbose&32) { sprintf(Buf1, "\t/* line %d %s */\n\t\t", lineno, Fname->name); } else { strcpy(Buf1, ""); } } else { sprintf(Buf1, "\n#line %d \"%s\"\n{", lineno, Fname->name); } p += strlen(Buf1); firstchar = 1; cnr = 1; /* not zero */ more: c = Getchar(); *p++ = (char) c; if (p - Buf1 >= SOMETHINGBIG) fatal("inline text too long", 0); switch (c) { case '\n': lineno++; cnr = 0; break; case '{': cnr++; nest++; break; case '}': cnr++; if (--nest <= 0) { *p = '\0'; if (s->type == CODE_FRAG) { *--p = '\0'; /* remove trailing '}' */ } def_inline(s, dln, &Buf1[0], &Buf2[0], nms); if (firstchar) { printf("%3d: %s, warning: empty inline definition (%s)\n", dln, Fname->name, s->name); } return s; /* normal return */ } break; case '#': if (cnr == 0) { p--; do_directive(c); /* reads to newline */ } else { firstchar = 0; cnr++; } break; case '\t': case ' ': case '\f': cnr++; break; case '"': do { c = Getchar(); *p++ = (char) c; if (c == '\\') { *p++ = (char) Getchar(); } if (p - Buf1 >= SOMETHINGBIG) { fatal("inline text too long", 0); } } while (c != '"'); /* end of string */ /* *p = '\0'; */ break; case '\'': c = Getchar(); *p++ = (char) c; if (c == '\\') { *p++ = (char) Getchar(); } c = Getchar(); *p++ = (char) c; assert(c == '\''); break; default: firstchar = 0; cnr++; break; } goto more; } static void set_cur_scope(void) { int i; char tmpbuf[256]; strcpy(CurScope, "_"); if (context) for (i = 0; i < scope_level; i++) { sprintf(tmpbuf, "%d_", scope_seq[i]); strcat(CurScope, tmpbuf); } } static int pre_proc(void) { char b[512]; int c, i = 0; b[i++] = '#'; while ((c = Getchar()) != '\n' && c != EOF) { b[i++] = (char) c; } b[i] = '\0'; yylval = nn(ZN, 0, ZN, ZN); yylval->sym = lookup(b); return PREPROC; } static int specials[] = { '}', ')', ']', OD, FI, ELSE, BREAK, C_CODE, C_EXPR, C_DECL, NAME, CONST, INCR, DECR, 0 }; int follows_token(int c) { int i; for (i = 0; specials[i]; i++) { if (c == specials[i]) { return 1; } } return 0; } #define DEFER_LTL #ifdef DEFER_LTL /* defer ltl formula to the end of the spec * no matter where they appear in the original */ static int deferred = 0; static FILE *defer_fd; int get_deferred(void) { if (!defer_fd) { return 0; /* nothing was deferred */ } fclose(defer_fd); defer_fd = fopen(TMP_FILE2, "r"); if (!defer_fd) { non_fatal("cannot retrieve deferred ltl formula", (char *) 0); return 0; } fclose(yyin); yyin = defer_fd; return 1; } void zap_deferred(void) { (void) unlink(TMP_FILE2); } int put_deferred(void) { int c, cnt; if (!defer_fd) { defer_fd = fopen(TMP_FILE2, "w+"); if (!defer_fd) { non_fatal("cannot defer ltl expansion", (char *) 0); return 0; } } fprintf(defer_fd, "ltl "); cnt = 0; while ((c = getc(yyin)) != EOF) { if (c == '{') { cnt++; } if (c == '}') { cnt--; if (cnt == 0) { break; } } fprintf(defer_fd, "%c", c); } fprintf(defer_fd, "}\n"); fflush(defer_fd); return 1; } #endif #define EXPAND_SELECT #ifdef EXPAND_SELECT static char tmp_hold[256]; static int tmp_has; void new_select(void) { tmp_hold[0] = '\0'; tmp_has = 0; } int scan_to(int stop, int (*tst)(int), char *buf) { int c, i = 0; do { c = Getchar(); if (tmp_has < sizeof(tmp_hold)) { tmp_hold[tmp_has++] = c; } if (c == '\n') { lineno++; } else if (buf) { buf[i++] = c; } if (tst && !tst(c) && c != ' ' && c != '\t') { break; } } while (c != stop && c != EOF); if (buf) { buf[i-1] = '\0'; } if (c != stop) { if (0) { printf("saw: '%c', expected '%c'\n", c, stop); } if (tmp_has < sizeof(tmp_hold)) { tmp_hold[tmp_has] = '\0'; push_back(tmp_hold); if (0) { printf("pushed back: <'%s'>\n", tmp_hold); } return 0; /* internal expansion fails */ } else { fatal("expecting select ( name : constant .. constant )", 0); } } return 1; /* success */ } #endif int lex(void) { int c; again: c = Getchar(); yytext[0] = (char) c; yytext[1] = '\0'; switch (c) { case EOF: #ifdef DEFER_LTL if (!deferred) { deferred = 1; if (get_deferred()) { goto again; } } else { zap_deferred(); } #endif return c; case '\n': /* newline */ lineno++; /* make most semi-colons optional */ if (implied_semis /* && context */ && in_seq && par_cnt == 0 && follows_token(last_token)) { if (0) { printf("insert ; line %d, last_token %d in_seq %d\n", lineno-1, last_token, in_seq); } ValToken(1, SEMI); } /* else fall thru */ case '\r': /* carriage return */ goto again; case ' ': case '\t': case '\f': /* white space */ goto again; case '#': /* preprocessor directive */ if (in_comment) goto again; if (pp_mode) { last_token = PREPROC; return pre_proc(); } do_directive(c); goto again; case '\"': getword(c, notquote); if (Getchar() != '\"') fatal("string not terminated", yytext); strcat(yytext, "\""); SymToken(lookup(yytext), STRING) case '$': getword('\"', notdollar); if (Getchar() != '$') fatal("ltl definition not terminated", yytext); strcat(yytext, "\""); SymToken(lookup(yytext), STRING) case '\'': /* new 3.0.9 */ c = Getchar(); if (c == '\\') { c = Getchar(); if (c == 'n') c = '\n'; else if (c == 'r') c = '\r'; else if (c == 't') c = '\t'; else if (c == 'f') c = '\f'; } if (Getchar() != '\'' && !in_comment) fatal("character quote missing: %s", yytext); ValToken(c, CONST) default: break; } if (isdigit_(c)) { long int nr; getword(c, isdigit_); errno = 0; nr = strtol(yytext, NULL, 10); if (errno != 0) { fprintf(stderr, "spin: value out of range: '%s' read as '%d'\n", yytext, (int) nr); } ValToken((int)nr, CONST) } if (isalpha_(c) || c == '_') { getword(c, isalnum_); if (!in_comment) { c = check_name(yytext); #ifdef EXPAND_SELECT if (c == SELECT) { char name[64], from[32], upto[32]; int i, a, b; new_select(); if (!scan_to('(', 0, 0) || !scan_to(':', isalnum, name) || !scan_to('.', isdigit, from) || !scan_to('.', 0, 0) || !scan_to(')', isdigit, upto)) { goto not_expanded; } a = atoi(from); b = atoi(upto); if (0) { printf("Select %s from %d to %d\n", name, a, b); } if (a > b) { non_fatal("bad range in select statement", 0); goto again; } if (b - a <= 32) { push_back("if "); for (i = a; i <= b; i++) { char buf[128]; push_back(":: "); sprintf(buf, "%s = %d ", name, i); push_back(buf); } push_back("fi "); } else { char buf[128]; sprintf(buf, "%s = %d; do :: ", name, a); push_back(buf); sprintf(buf, "(%s < %d) -> %s++ ", name, b, name); push_back(buf); push_back(":: break od "); } goto again; } not_expanded: #endif #ifdef DEFER_LTL if (c == LTL && !deferred) { if (put_deferred()) { goto again; } } #endif if (c) { last_token = c; return c; } /* else fall through */ } goto again; } if (ltl_mode) { switch (c) { case '-': c = follow('>', IMPLIES, '-'); break; case '[': c = follow(']', ALWAYS, '['); break; case '<': c = follow('>', EVENTUALLY, '<'); if (c == '<') { c = Getchar(); if (c == '-') { c = follow('>', EQUIV, '-'); if (c == '-') { Ungetch(c); c = '<'; } } else { Ungetch(c); c = '<'; } } default: break; } } switch (c) { case '/': c = follow('*', 0, '/'); if (!c) { in_comment = 1; goto again; } break; case '*': c = follow('/', 0, '*'); if (!c) { in_comment = 0; goto again; } break; case ':': c = follow(':', SEP, ':'); break; case '-': c = follow('>', ARROW, follow('-', DECR, '-')); break; case '+': c = follow('+', INCR, '+'); break; case '<': c = follow('<', LSHIFT, follow('=', LE, LT)); break; case '>': c = follow('>', RSHIFT, follow('=', GE, GT)); break; case '=': c = follow('=', EQ, ASGN); break; case '!': c = follow('=', NE, follow('!', O_SND, SND)); break; case '?': c = follow('?', R_RCV, RCV); break; case '&': c = follow('&', AND, '&'); break; case '|': c = follow('|', OR, '|'); break; case ';': c = SEMI; break; case '.': c = follow('.', DOTDOT, '.'); break; case '{': scope_seq[scope_level++]++; set_cur_scope(); break; case '}': scope_level--; set_cur_scope(); break; default : break; } ValToken(0, c) } static struct { char *s; int tok; } LTL_syms[] = { /* [], <>, ->, and <-> are intercepted in lex() */ { "U", UNTIL }, { "V", RELEASE }, { "W", WEAK_UNTIL }, { "X", NEXT }, { "always", ALWAYS }, { "eventually", EVENTUALLY }, { "until", UNTIL }, { "stronguntil",UNTIL }, { "weakuntil", WEAK_UNTIL }, { "release", RELEASE }, { "next", NEXT }, { "implies", IMPLIES }, { "equivalent", EQUIV }, { 0, 0 }, }; static struct { char *s; int tok; int val; char *sym; } Names[] = { {"active", ACTIVE, 0, 0}, {"assert", ASSERT, 0, 0}, {"atomic", ATOMIC, 0, 0}, {"bit", TYPE, BIT, 0}, {"bool", TYPE, BIT, 0}, {"break", BREAK, 0, 0}, {"byte", TYPE, BYTE, 0}, {"c_code", C_CODE, 0, 0}, {"c_decl", C_DECL, 0, 0}, {"c_expr", C_EXPR, 0, 0}, {"c_state", C_STATE, 0, 0}, {"c_track", C_TRACK, 0, 0}, {"D_proctype", D_PROCTYPE, 0, 0}, {"do", DO, 0, 0}, {"chan", TYPE, CHAN, 0}, {"else", ELSE, 0, 0}, {"empty", EMPTY, 0, 0}, {"enabled", ENABLED, 0, 0}, {"eval", EVAL, 0, 0}, {"false", CONST, 0, 0}, {"fi", FI, 0, 0}, {"for", FOR, 0, 0}, {"full", FULL, 0, 0}, {"get_priority", GET_P, 0, 0}, {"goto", GOTO, 0, 0}, {"hidden", HIDDEN, 0, ":hide:"}, {"if", IF, 0, 0}, {"in", IN, 0, 0}, {"init", INIT, 0, ":init:"}, {"inline", INLINE, 0, 0}, {"int", TYPE, INT, 0}, {"len", LEN, 0, 0}, {"local", ISLOCAL, 0, ":local:"}, {"ltl", LTL, 0, ":ltl:"}, {"mtype", TYPE, MTYPE, 0}, {"nempty", NEMPTY, 0, 0}, {"never", CLAIM, 0, ":never:"}, {"nfull", NFULL, 0, 0}, {"notrace", TRACE, 0, ":notrace:"}, {"np_", NONPROGRESS, 0, 0}, {"od", OD, 0, 0}, {"of", OF, 0, 0}, {"pc_value", PC_VAL, 0, 0}, {"pid", TYPE, BYTE, 0}, {"printf", PRINT, 0, 0}, {"printm", PRINTM, 0, 0}, {"priority", PRIORITY, 0, 0}, {"proctype", PROCTYPE, 0, 0}, {"provided", PROVIDED, 0, 0}, {"return", RETURN, 0, 0}, {"run", RUN, 0, 0}, {"d_step", D_STEP, 0, 0}, {"select", SELECT, 0, 0}, {"set_priority", SET_P, 0, 0}, {"short", TYPE, SHORT, 0}, {"skip", CONST, 1, 0}, {"timeout", TIMEOUT, 0, 0}, {"trace", TRACE, 0, ":trace:"}, {"true", CONST, 1, 0}, {"show", SHOW, 0, ":show:"}, {"typedef", TYPEDEF, 0, 0}, {"unless", UNLESS, 0, 0}, {"unsigned", TYPE, UNSIGNED, 0}, {"xr", XU, XR, 0}, {"xs", XU, XS, 0}, {0, 0, 0, 0}, }; static int check_name(char *s) { int i; yylval = nn(ZN, 0, ZN, ZN); if (ltl_mode) { for (i = 0; LTL_syms[i].s; i++) { if (strcmp(s, LTL_syms[i].s) == 0) { return LTL_syms[i].tok; } } } for (i = 0; Names[i].s; i++) { if (strcmp(s, Names[i].s) == 0) { yylval->val = Names[i].val; if (Names[i].sym) yylval->sym = lookup(Names[i].sym); if (Names[i].tok == IN && !in_for) { continue; } return Names[i].tok; } } if ((yylval->val = ismtype(s)) != 0) { yylval->ismtyp = 1; return CONST; } if (strcmp(s, "_last") == 0) has_last++; if (strcmp(s, "_priority") == 0) has_priority++; if (Inlining >= 0 && !ReDiRect) { Lextok *tt, *t = Inline_stub[Inlining]->params; for (i = 0; t; t = t->rgt, i++) /* formal pars */ if (!strcmp(s, t->lft->sym->name) /* varname matches formal */ && strcmp(s, Inline_stub[Inlining]->anms[i]) != 0) /* actual pars */ { #if 0 if (verbose&32) printf("\tline %d, replace %s in call of '%s' with %s\n", lineno, s, Inline_stub[Inlining]->nm->name, Inline_stub[Inlining]->anms[i]); #endif for (tt = Inline_stub[Inlining]->params; tt; tt = tt->rgt) if (!strcmp(Inline_stub[Inlining]->anms[i], tt->lft->sym->name)) { /* would be cyclic if not caught */ printf("spin: %s:%d replacement value: %s\n", oFname->name?oFname->name:"--", lineno, tt->lft->sym->name); fatal("formal par of %s contains replacement value", Inline_stub[Inlining]->nm->name); yylval->ntyp = tt->lft->ntyp; yylval->sym = lookup(tt->lft->sym->name); return NAME; } /* check for occurrence of param as field of struct */ { char *ptr = Inline_stub[Inlining]->anms[i]; while ((ptr = strstr(ptr, s)) != NULL) { if (*(ptr-1) == '.' || *(ptr+strlen(s)) == '.') { fatal("formal par of %s used in structure name", Inline_stub[Inlining]->nm->name); } ptr++; } } ReDiRect = Inline_stub[Inlining]->anms[i]; return 0; } } yylval->sym = lookup(s); /* symbol table */ if (isutype(s)) return UNAME; if (isproctype(s)) return PNAME; if (iseqname(s)) return INAME; return NAME; } int yylex(void) { static int last = 0; static int hold = 0; int c; /* * repair two common syntax mistakes with * semi-colons before or after a '}' */ if (hold) { c = hold; hold = 0; last_token = c; } else { c = lex(); if (last == ELSE && c != SEMI && c != ARROW && c != FI) { hold = c; last = 0; last_token = SEMI; return SEMI; } if (last == '}' && c != PROCTYPE && c != INIT && c != CLAIM && c != SEP && c != FI && c != OD && c != '}' && c != UNLESS && c != SEMI && c != ARROW && c != EOF) { hold = c; last = 0; last_token = SEMI; return SEMI; /* insert ';' */ } if (c == SEMI || c == ARROW) { /* if context, we're not in a typedef * because they're global. * if owner, we're at the end of a ref * to a struct field -- prevent that the * lookahead is interpreted as a field of * the same struct... */ if (context) owner = ZS; hold = lex(); /* look ahead */ if (hold == '}' || hold == ARROW || hold == SEMI) { c = hold; /* omit ';' */ hold = 0; } } } last = c; if (IArgs) { static int IArg_nst = 0; if (strcmp(yytext, ",") == 0) { IArg_cont[++IArgno][0] = '\0'; } else if (strcmp(yytext, "(") == 0) { if (IArg_nst++ == 0) { IArgno = 0; IArg_cont[0][0] = '\0'; } else { assert(strlen(IArg_cont[IArgno])+strlen(yytext) < sizeof(IArg_cont)); strcat(IArg_cont[IArgno], yytext); } } else if (strcmp(yytext, ")") == 0) { if (--IArg_nst > 0) { assert(strlen(IArg_cont[IArgno])+strlen(yytext) < sizeof(IArg_cont)); strcat(IArg_cont[IArgno], yytext); } } else if (c == CONST && yytext[0] == '\'') { sprintf(yytext, "'%c'", yylval->val); assert(strlen(IArg_cont[IArgno])+strlen(yytext) < sizeof(IArg_cont)); strcat(IArg_cont[IArgno], yytext); } else if (c == CONST) { sprintf(yytext, "%d", yylval->val); assert(strlen(IArg_cont[IArgno])+strlen(yytext) < sizeof(IArg_cont)); strcat(IArg_cont[IArgno], yytext); } else { switch (c) { case ARROW: strcpy(yytext, "->"); break; /* NEW */ case SEP: strcpy(yytext, "::"); break; case SEMI: strcpy(yytext, ";"); break; case DECR: strcpy(yytext, "--"); break; case INCR: strcpy(yytext, "++"); break; case LSHIFT: strcpy(yytext, "<<"); break; case RSHIFT: strcpy(yytext, ">>"); break; case LE: strcpy(yytext, "<="); break; case LT: strcpy(yytext, "<"); break; case GE: strcpy(yytext, ">="); break; case GT: strcpy(yytext, ">"); break; case EQ: strcpy(yytext, "=="); break; case ASGN: strcpy(yytext, "="); break; case NE: strcpy(yytext, "!="); break; case R_RCV: strcpy(yytext, "??"); break; case RCV: strcpy(yytext, "?"); break; case O_SND: strcpy(yytext, "!!"); break; case SND: strcpy(yytext, "!"); break; case AND: strcpy(yytext, "&&"); break; case OR: strcpy(yytext, "||"); break; } assert(strlen(IArg_cont[IArgno])+strlen(yytext) < sizeof(IArg_cont)); strcat(IArg_cont[IArgno], yytext); } } return c; } Spin/Src6.4.5/tl_parse.c0000664000175100017510000002002412641605057012654 0ustar ghgh/***** tl_spin: tl_parse.c *****/ /* * This file is part of the public release of Spin. It is subject to the * terms in the LICENSE file that is included in this source directory. * Tool documentation is available at http://spinroot.com * * Based on the translation algorithm by Gerth, Peled, Vardi, and Wolper, * presented at the PSTV Conference, held in 1995, Warsaw, Poland 1995. */ #include "tl.h" extern int tl_yylex(void); extern int tl_verbose, tl_errs; int tl_yychar = 0; YYSTYPE tl_yylval; static Node *tl_formula(void); static Node *tl_factor(void); static Node *tl_level(int); static int prec[2][4] = { { U_OPER, V_OPER, 0, 0 }, /* left associative */ { OR, AND, IMPLIES, EQUIV, }, /* left associative */ }; static Node * tl_factor(void) { Node *ptr = ZN; switch (tl_yychar) { case '(': ptr = tl_formula(); if (tl_yychar != ')') tl_yyerror("expected ')'"); tl_yychar = tl_yylex(); break; case NOT: ptr = tl_yylval; tl_yychar = tl_yylex(); ptr->lft = tl_factor(); if (!ptr->lft) { fatal("malformed expression", (char *) 0); } ptr = push_negation(ptr); break; case ALWAYS: tl_yychar = tl_yylex(); ptr = tl_factor(); #ifndef NO_OPT if (ptr->ntyp == FALSE || ptr->ntyp == TRUE) break; /* [] false == false */ if (ptr->ntyp == V_OPER) { if (ptr->lft->ntyp == FALSE) break; /* [][]p = []p */ ptr = ptr->rgt; /* [] (p V q) = [] q */ } #endif ptr = tl_nn(V_OPER, False, ptr); break; #ifdef NXT case NEXT: tl_yychar = tl_yylex(); ptr = tl_factor(); if (ptr->ntyp == TRUE) break; /* X true = true */ ptr = tl_nn(NEXT, ptr, ZN); break; #endif case CEXPR: tl_yychar = tl_yylex(); ptr = tl_factor(); if (ptr->ntyp != PREDICATE) { tl_yyerror("expected {...} after c_expr"); } ptr = tl_nn(CEXPR, ptr, ZN); break; case EVENTUALLY: tl_yychar = tl_yylex(); ptr = tl_factor(); #ifndef NO_OPT if (ptr->ntyp == TRUE || ptr->ntyp == FALSE) break; /* <> true == true */ if (ptr->ntyp == U_OPER && ptr->lft->ntyp == TRUE) break; /* <><>p = <>p */ if (ptr->ntyp == U_OPER) { /* <> (p U q) = <> q */ ptr = ptr->rgt; /* fall thru */ } #endif ptr = tl_nn(U_OPER, True, ptr); break; case PREDICATE: ptr = tl_yylval; tl_yychar = tl_yylex(); break; case TRUE: case FALSE: ptr = tl_yylval; tl_yychar = tl_yylex(); break; } if (!ptr) tl_yyerror("expected predicate"); #if 0 printf("factor: "); tl_explain(ptr->ntyp); printf("\n"); #endif return ptr; } static Node * bin_simpler(Node *ptr) { Node *a, *b; if (ptr) switch (ptr->ntyp) { case U_OPER: #ifndef NO_OPT if (ptr->rgt->ntyp == TRUE || ptr->rgt->ntyp == FALSE || ptr->lft->ntyp == FALSE) { ptr = ptr->rgt; break; } if (isequal(ptr->lft, ptr->rgt)) { /* p U p = p */ ptr = ptr->rgt; break; } if (ptr->lft->ntyp == U_OPER && isequal(ptr->lft->lft, ptr->rgt)) { /* (p U q) U p = (q U p) */ ptr->lft = ptr->lft->rgt; break; } if (ptr->rgt->ntyp == U_OPER && ptr->rgt->lft->ntyp == TRUE) { /* p U (T U q) = (T U q) */ ptr = ptr->rgt; break; } #ifdef NXT /* X p U X q == X (p U q) */ if (ptr->rgt->ntyp == NEXT && ptr->lft->ntyp == NEXT) { ptr = tl_nn(NEXT, tl_nn(U_OPER, ptr->lft->lft, ptr->rgt->lft), ZN); } #endif #endif break; case V_OPER: #ifndef NO_OPT if (ptr->rgt->ntyp == FALSE || ptr->rgt->ntyp == TRUE || ptr->lft->ntyp == TRUE) { ptr = ptr->rgt; break; } if (isequal(ptr->lft, ptr->rgt)) { /* p V p = p */ ptr = ptr->rgt; break; } /* F V (p V q) == F V q */ if (ptr->lft->ntyp == FALSE && ptr->rgt->ntyp == V_OPER) { ptr->rgt = ptr->rgt->rgt; break; } /* p V (F V q) == F V q */ if (ptr->rgt->ntyp == V_OPER && ptr->rgt->lft->ntyp == FALSE) { ptr->lft = False; ptr->rgt = ptr->rgt->rgt; break; } #endif break; case IMPLIES: #ifndef NO_OPT if (isequal(ptr->lft, ptr->rgt)) { ptr = True; break; } #endif ptr = tl_nn(OR, Not(ptr->lft), ptr->rgt); ptr = rewrite(ptr); break; case EQUIV: #ifndef NO_OPT if (isequal(ptr->lft, ptr->rgt)) { ptr = True; break; } #endif a = rewrite(tl_nn(AND, dupnode(ptr->lft), dupnode(ptr->rgt))); b = rewrite(tl_nn(AND, Not(ptr->lft), Not(ptr->rgt))); ptr = tl_nn(OR, a, b); ptr = rewrite(ptr); break; case AND: #ifndef NO_OPT /* p && (q U p) = p */ if (ptr->rgt->ntyp == U_OPER && isequal(ptr->rgt->rgt, ptr->lft)) { ptr = ptr->lft; break; } if (ptr->lft->ntyp == U_OPER && isequal(ptr->lft->rgt, ptr->rgt)) { ptr = ptr->rgt; break; } /* p && (q V p) == q V p */ if (ptr->rgt->ntyp == V_OPER && isequal(ptr->rgt->rgt, ptr->lft)) { ptr = ptr->rgt; break; } if (ptr->lft->ntyp == V_OPER && isequal(ptr->lft->rgt, ptr->rgt)) { ptr = ptr->lft; break; } /* (p U q) && (r U q) = (p && r) U q*/ if (ptr->rgt->ntyp == U_OPER && ptr->lft->ntyp == U_OPER && isequal(ptr->rgt->rgt, ptr->lft->rgt)) { ptr = tl_nn(U_OPER, tl_nn(AND, ptr->lft->lft, ptr->rgt->lft), ptr->lft->rgt); break; } /* (p V q) && (p V r) = p V (q && r) */ if (ptr->rgt->ntyp == V_OPER && ptr->lft->ntyp == V_OPER && isequal(ptr->rgt->lft, ptr->lft->lft)) { ptr = tl_nn(V_OPER, ptr->rgt->lft, tl_nn(AND, ptr->lft->rgt, ptr->rgt->rgt)); break; } #ifdef NXT /* X p && X q == X (p && q) */ if (ptr->rgt->ntyp == NEXT && ptr->lft->ntyp == NEXT) { ptr = tl_nn(NEXT, tl_nn(AND, ptr->rgt->lft, ptr->lft->lft), ZN); break; } #endif if (isequal(ptr->lft, ptr->rgt) /* (p && p) == p */ || ptr->rgt->ntyp == FALSE /* (p && F) == F */ || ptr->lft->ntyp == TRUE) /* (T && p) == p */ { ptr = ptr->rgt; break; } if (ptr->rgt->ntyp == TRUE /* (p && T) == p */ || ptr->lft->ntyp == FALSE) /* (F && p) == F */ { ptr = ptr->lft; break; } /* (p V q) && (r U q) == p V q */ if (ptr->rgt->ntyp == U_OPER && ptr->lft->ntyp == V_OPER && isequal(ptr->lft->rgt, ptr->rgt->rgt)) { ptr = ptr->lft; break; } #endif break; case OR: #ifndef NO_OPT /* p || (q U p) == q U p */ if (ptr->rgt->ntyp == U_OPER && isequal(ptr->rgt->rgt, ptr->lft)) { ptr = ptr->rgt; break; } /* p || (q V p) == p */ if (ptr->rgt->ntyp == V_OPER && isequal(ptr->rgt->rgt, ptr->lft)) { ptr = ptr->lft; break; } /* (p U q) || (p U r) = p U (q || r) */ if (ptr->rgt->ntyp == U_OPER && ptr->lft->ntyp == U_OPER && isequal(ptr->rgt->lft, ptr->lft->lft)) { ptr = tl_nn(U_OPER, ptr->rgt->lft, tl_nn(OR, ptr->lft->rgt, ptr->rgt->rgt)); break; } if (isequal(ptr->lft, ptr->rgt) /* (p || p) == p */ || ptr->rgt->ntyp == FALSE /* (p || F) == p */ || ptr->lft->ntyp == TRUE) /* (T || p) == T */ { ptr = ptr->lft; break; } if (ptr->rgt->ntyp == TRUE /* (p || T) == T */ || ptr->lft->ntyp == FALSE) /* (F || p) == p */ { ptr = ptr->rgt; break; } /* (p V q) || (r V q) = (p || r) V q */ if (ptr->rgt->ntyp == V_OPER && ptr->lft->ntyp == V_OPER && isequal(ptr->lft->rgt, ptr->rgt->rgt)) { ptr = tl_nn(V_OPER, tl_nn(OR, ptr->lft->lft, ptr->rgt->lft), ptr->rgt->rgt); break; } /* (p V q) || (r U q) == r U q */ if (ptr->rgt->ntyp == U_OPER && ptr->lft->ntyp == V_OPER && isequal(ptr->lft->rgt, ptr->rgt->rgt)) { ptr = ptr->rgt; break; } #endif break; } return ptr; } static Node * tl_level(int nr) { int i; Node *ptr = ZN; if (nr < 0) return tl_factor(); ptr = tl_level(nr-1); again: for (i = 0; i < 4; i++) if (tl_yychar == prec[nr][i]) { tl_yychar = tl_yylex(); ptr = tl_nn(prec[nr][i], ptr, tl_level(nr-1)); ptr = bin_simpler(ptr); goto again; } if (!ptr) tl_yyerror("syntax error"); #if 0 printf("level %d: ", nr); tl_explain(ptr->ntyp); printf("\n"); #endif return ptr; } static Node * tl_formula(void) { tl_yychar = tl_yylex(); return tl_level(1); /* 2 precedence levels, 1 and 0 */ } void tl_parse(void) { Node *n; /* tl_verbose = 1; */ n = tl_formula(); if (tl_verbose) { printf("formula: "); dump(n); printf("\n"); } if (tl_Getchar() != -1) { tl_yyerror("syntax error"); tl_errs++; return; } trans(n); } Spin/Src6.4.5/run.c0000664000175100017510000004105612641605057011657 0ustar ghgh/***** spin: run.c *****/ /* * This file is part of the public release of Spin. It is subject to the * terms in the LICENSE file that is included in this source directory. * Tool documentation is available at http://spinroot.com */ #include #include "spin.h" #include "y.tab.h" extern RunList *X, *run; extern Symbol *Fname; extern Element *LastStep; extern int Rvous, lineno, Tval, interactive, MadeChoice, Priority_Sum; extern int TstOnly, verbose, s_trail, xspin, jumpsteps, depth; extern int analyze, nproc, nstop, no_print, like_java, old_priority_rules; extern short Have_claim; static long Seed = 1; static int E_Check = 0, Escape_Check = 0; static int eval_sync(Element *); static int pc_enabled(Lextok *n); static int get_priority(Lextok *n); static void set_priority(Lextok *n, Lextok *m); extern void sr_buf(int, int); void Srand(unsigned int s) { Seed = s; } long Rand(void) { /* CACM 31(10), Oct 1988 */ Seed = 16807*(Seed%127773) - 2836*(Seed/127773); if (Seed <= 0) Seed += 2147483647; return Seed; } Element * rev_escape(SeqList *e) { Element *r = (Element *) 0; if (e) { if ((r = rev_escape(e->nxt)) == ZE) /* reversed order */ { r = eval_sub(e->this->frst); } } return r; } Element * eval_sub(Element *e) { Element *f, *g; SeqList *z; int i, j, k, only_pos; if (!e || !e->n) return ZE; #ifdef DEBUG printf("\n\teval_sub(%d %s: line %d) ", e->Seqno, e->esc?"+esc":"", e->n?e->n->ln:0); comment(stdout, e->n, 0); printf("\n"); #endif if (e->n->ntyp == GOTO) { if (Rvous) return ZE; LastStep = e; f = get_lab(e->n, 1); f = huntele(f, e->status, -1); /* 5.2.3: was missing */ cross_dsteps(e->n, f->n); #ifdef DEBUG printf("GOTO leads to %d\n", f->seqno); #endif return f; } if (e->n->ntyp == UNLESS) { /* escapes were distributed into sequence */ return eval_sub(e->sub->this->frst); } else if (e->sub) /* true for IF, DO, and UNLESS */ { Element *has_else = ZE; Element *bas_else = ZE; int nr_else = 0, nr_choices = 0; only_pos = -1; if (interactive && !MadeChoice && !E_Check && !Escape_Check && !(e->status&(D_ATOM)) && depth >= jumpsteps) { printf("Select stmnt ("); whoruns(0); printf(")\n"); if (nproc-nstop > 1) { printf("\tchoice 0: other process\n"); nr_choices++; only_pos = 0; } } for (z = e->sub, j=0; z; z = z->nxt) { j++; if (interactive && !MadeChoice && !E_Check && !Escape_Check && !(e->status&(D_ATOM)) && depth >= jumpsteps && z->this->frst && (xspin || (verbose&32) || Enabled0(z->this->frst))) { if (z->this->frst->n->ntyp == ELSE) { has_else = (Rvous)?ZE:z->this->frst->nxt; nr_else = j; continue; } printf("\tchoice %d: ", j); #if 0 if (z->this->frst->n) printf("line %d, ", z->this->frst->n->ln); #endif if (!Enabled0(z->this->frst)) printf("unexecutable, "); else { nr_choices++; only_pos = j; } comment(stdout, z->this->frst->n, 0); printf("\n"); } } if (nr_choices == 0 && has_else) { printf("\tchoice %d: (else)\n", nr_else); only_pos = nr_else; } if (nr_choices <= 1 && only_pos != -1 && !MadeChoice) { MadeChoice = only_pos; } if (interactive && depth >= jumpsteps && !Escape_Check && !(e->status&(D_ATOM)) && !E_Check) { if (!MadeChoice) { char buf[256]; if (xspin) printf("Make Selection %d\n\n", j); else printf("Select [0-%d]: ", j); fflush(stdout); if (scanf("%64s", buf) <= 0) { printf("no input\n"); return ZE; } if (isdigit((int)buf[0])) k = atoi(buf); else { if (buf[0] == 'q') alldone(0); k = -1; } } else { k = MadeChoice; MadeChoice = 0; } if (k < 1 || k > j) { if (k != 0) printf("\tchoice outside range\n"); return ZE; } k--; } else { if (e->n && e->n->indstep >= 0) k = 0; /* select 1st executable guard */ else k = Rand()%j; /* nondeterminism */ } has_else = ZE; bas_else = ZE; for (i = 0, z = e->sub; i < j+k; i++) { if (z->this->frst && z->this->frst->n->ntyp == ELSE) { bas_else = z->this->frst; has_else = (Rvous)?ZE:bas_else->nxt; if (!interactive || depth < jumpsteps || Escape_Check || (e->status&(D_ATOM))) { z = (z->nxt)?z->nxt:e->sub; continue; } } if (z->this->frst && ((z->this->frst->n->ntyp == ATOMIC || z->this->frst->n->ntyp == D_STEP) && z->this->frst->n->sl->this->frst->n->ntyp == ELSE)) { bas_else = z->this->frst->n->sl->this->frst; has_else = (Rvous)?ZE:bas_else->nxt; if (!interactive || depth < jumpsteps || Escape_Check || (e->status&(D_ATOM))) { z = (z->nxt)?z->nxt:e->sub; continue; } } if (i >= k) { if ((f = eval_sub(z->this->frst)) != ZE) return f; else if (interactive && depth >= jumpsteps && !(e->status&(D_ATOM))) { if (!E_Check && !Escape_Check) printf("\tunexecutable\n"); return ZE; } } z = (z->nxt)?z->nxt:e->sub; } LastStep = bas_else; return has_else; } else { if (e->n->ntyp == ATOMIC || e->n->ntyp == D_STEP) { f = e->n->sl->this->frst; g = e->n->sl->this->last; g->nxt = e->nxt; if (!(g = eval_sub(f))) /* atomic guard */ return ZE; return g; } else if (e->n->ntyp == NON_ATOMIC) { f = e->n->sl->this->frst; g = e->n->sl->this->last; g->nxt = e->nxt; /* close it */ return eval_sub(f); } else if (e->n->ntyp == '.') { if (!Rvous) return e->nxt; return eval_sub(e->nxt); } else { SeqList *x; if (!(e->status & (D_ATOM)) && e->esc && verbose&32) { printf("Stmnt ["); comment(stdout, e->n, 0); printf("] has escape(s): "); for (x = e->esc; x; x = x->nxt) { printf("["); g = x->this->frst; if (g->n->ntyp == ATOMIC || g->n->ntyp == NON_ATOMIC) g = g->n->sl->this->frst; comment(stdout, g->n, 0); printf("] "); } printf("\n"); } #if 0 if (!(e->status & D_ATOM)) /* escapes don't reach inside d_steps */ /* 4.2.4: only the guard of a d_step can have an escape */ #endif #if 1 if (!s_trail) /* trail determines selections, new 5.2.5 */ #endif { Escape_Check++; if (like_java) { if ((g = rev_escape(e->esc)) != ZE) { if (verbose&4) { printf("\tEscape taken (-J) "); if (g->n && g->n->fn) printf("%s:%d", g->n->fn->name, g->n->ln); printf("\n"); } Escape_Check--; return g; } } else { for (x = e->esc; x; x = x->nxt) { if ((g = eval_sub(x->this->frst)) != ZE) { if (verbose&4) { printf("\tEscape taken "); if (g->n && g->n->fn) printf("%s:%d", g->n->fn->name, g->n->ln); printf("\n"); } Escape_Check--; return g; } } } Escape_Check--; } switch (e->n->ntyp) { case ASGN: if (check_track(e->n) == STRUCT) { break; } /* else fall thru */ case TIMEOUT: case RUN: case PRINT: case PRINTM: case C_CODE: case C_EXPR: case ASSERT: case 's': case 'r': case 'c': /* toplevel statements only */ LastStep = e; default: break; } if (Rvous) { return (eval_sync(e))?e->nxt:ZE; } return (eval(e->n))?e->nxt:ZE; } } return ZE; /* not reached */ } static int eval_sync(Element *e) { /* allow only synchronous receives and related node types */ Lextok *now = (e)?e->n:ZN; if (!now || now->ntyp != 'r' || now->val >= 2 /* no rv with a poll */ || !q_is_sync(now)) { return 0; } LastStep = e; return eval(now); } static int assign(Lextok *now) { int t; if (TstOnly) return 1; switch (now->rgt->ntyp) { case FULL: case NFULL: case EMPTY: case NEMPTY: case RUN: case LEN: t = BYTE; break; default: t = Sym_typ(now->rgt); break; } typ_ck(Sym_typ(now->lft), t, "assignment"); return setval(now->lft, eval(now->rgt)); } static int nonprogress(void) /* np_ */ { RunList *r; for (r = run; r; r = r->nxt) { if (has_lab(r->pc, 4)) /* 4=progress */ return 0; } return 1; } int eval(Lextok *now) { if (now) { lineno = now->ln; Fname = now->fn; #ifdef DEBUG printf("eval "); comment(stdout, now, 0); printf("\n"); #endif switch (now->ntyp) { case CONST: return now->val; case '!': return !eval(now->lft); case UMIN: return -eval(now->lft); case '~': return ~eval(now->lft); case '/': return (eval(now->lft) / eval(now->rgt)); case '*': return (eval(now->lft) * eval(now->rgt)); case '-': return (eval(now->lft) - eval(now->rgt)); case '+': return (eval(now->lft) + eval(now->rgt)); case '%': return (eval(now->lft) % eval(now->rgt)); case LT: return (eval(now->lft) < eval(now->rgt)); case GT: return (eval(now->lft) > eval(now->rgt)); case '&': return (eval(now->lft) & eval(now->rgt)); case '^': return (eval(now->lft) ^ eval(now->rgt)); case '|': return (eval(now->lft) | eval(now->rgt)); case LE: return (eval(now->lft) <= eval(now->rgt)); case GE: return (eval(now->lft) >= eval(now->rgt)); case NE: return (eval(now->lft) != eval(now->rgt)); case EQ: return (eval(now->lft) == eval(now->rgt)); case OR: return (eval(now->lft) || eval(now->rgt)); case AND: return (eval(now->lft) && eval(now->rgt)); case LSHIFT: return (eval(now->lft) << eval(now->rgt)); case RSHIFT: return (eval(now->lft) >> eval(now->rgt)); case '?': return (eval(now->lft) ? eval(now->rgt->lft) : eval(now->rgt->rgt)); case 'p': return remotevar(now); /* _p for remote reference */ case 'q': return remotelab(now); case 'R': return qrecv(now, 0); /* test only */ case LEN: return qlen(now); case FULL: return (qfull(now)); case EMPTY: return (qlen(now)==0); case NFULL: return (!qfull(now)); case NEMPTY: return (qlen(now)>0); case ENABLED: if (s_trail) return 1; return pc_enabled(now->lft); case GET_P: return get_priority(now->lft); case SET_P: set_priority(now->lft->lft, now->lft->rgt); return 1; case EVAL: return eval(now->lft); case PC_VAL: return pc_value(now->lft); case NONPROGRESS: return nonprogress(); case NAME: return getval(now); case TIMEOUT: return Tval; case RUN: return TstOnly?1:enable(now); case 's': return qsend(now); /* send */ case 'r': return qrecv(now, 1); /* receive or poll */ case 'c': return eval(now->lft); /* condition */ case PRINT: return TstOnly?1:interprint(stdout, now); case PRINTM: return TstOnly?1:printm(stdout, now); case ASGN: if (check_track(now) == STRUCT) { return 1; } return assign(now); case C_CODE: if (!analyze) { printf("%s:\t", now->sym->name); plunk_inline(stdout, now->sym->name, 0, 1); } return 1; /* uninterpreted */ case C_EXPR: if (!analyze) { printf("%s:\t", now->sym->name); plunk_expr(stdout, now->sym->name); printf("\n"); } return 1; /* uninterpreted */ case ASSERT: if (TstOnly || eval(now->lft)) return 1; non_fatal("assertion violated", (char *) 0); printf("spin: text of failed assertion: assert("); comment(stdout, now->lft, 0); printf(")\n"); if (s_trail && !xspin) return 1; wrapup(1); /* doesn't return */ case IF: case DO: case BREAK: case UNLESS: /* compound */ case '.': return 1; /* return label for compound */ case '@': return 0; /* stop state */ case ELSE: return 1; /* only hit here in guided trails */ case ',': /* reached through option -A with array initializer */ case 0: return 0; /* not great, but safe */ default : printf("spin: bad node type %d (run)\n", now->ntyp); if (s_trail) printf("spin: trail file doesn't match spec?\n"); fatal("aborting", 0); }} return 0; } int printm(FILE *fd, Lextok *n) { extern char Buf[]; int j; Buf[0] = '\0'; if (!no_print) if (!s_trail || depth >= jumpsteps) { if (n->lft->ismtyp) j = n->lft->val; else j = eval(n->lft); sr_buf(j, 1); dotag(fd, Buf); } return 1; } int interprint(FILE *fd, Lextok *n) { Lextok *tmp = n->lft; char c, *s = n->sym->name; int i, j; char lbuf[512]; /* matches value in sr_buf() */ extern char Buf[]; /* global, size 4096 */ char tBuf[4096]; /* match size of global Buf[] */ Buf[0] = '\0'; if (!no_print) if (!s_trail || depth >= jumpsteps) { for (i = 0; i < (int) strlen(s); i++) switch (s[i]) { case '\"': break; /* ignore */ case '\\': switch(s[++i]) { case 't': strcat(Buf, "\t"); break; case 'n': strcat(Buf, "\n"); break; default: goto onechar; } break; case '%': if ((c = s[++i]) == '%') { strcat(Buf, "%"); /* literal */ break; } if (!tmp) { non_fatal("too few print args %s", s); break; } j = eval(tmp->lft); tmp = tmp->rgt; switch(c) { case 'c': sprintf(lbuf, "%c", j); break; case 'd': sprintf(lbuf, "%d", j); break; case 'e': strcpy(tBuf, Buf); /* event name */ Buf[0] = '\0'; sr_buf(j, 1); strcpy(lbuf, Buf); strcpy(Buf, tBuf); break; case 'o': sprintf(lbuf, "%o", j); break; case 'u': sprintf(lbuf, "%u", (unsigned) j); break; case 'x': sprintf(lbuf, "%x", j); break; default: non_fatal("bad print cmd: '%s'", &s[i-1]); lbuf[0] = '\0'; break; } goto append; default: onechar: lbuf[0] = s[i]; lbuf[1] = '\0'; append: strcat(Buf, lbuf); break; } dotag(fd, Buf); } if (strlen(Buf) >= 4096) fatal("printf string too long", 0); return 1; } static int Enabled1(Lextok *n) { int i; int v = verbose; if (n) switch (n->ntyp) { case 'c': if (has_typ(n->lft, RUN)) return 1; /* conservative */ /* else fall through */ default: /* side-effect free */ verbose = 0; E_Check++; i = eval(n); E_Check--; verbose = v; return i; case SET_P: case C_CODE: case C_EXPR: case PRINT: case PRINTM: case ASGN: case ASSERT: return 1; case 's': if (q_is_sync(n)) { if (Rvous) return 0; TstOnly = 1; verbose = 0; E_Check++; i = eval(n); E_Check--; TstOnly = 0; verbose = v; return i; } return (!qfull(n)); case 'r': if (q_is_sync(n)) return 0; /* it's never a user-choice */ n->ntyp = 'R'; verbose = 0; E_Check++; i = eval(n); E_Check--; n->ntyp = 'r'; verbose = v; return i; } return 0; } int Enabled0(Element *e) { SeqList *z; if (!e || !e->n) return 0; switch (e->n->ntyp) { case '@': return X->pid == (nproc-nstop-1); case '.': case SET_P: return 1; case GOTO: if (Rvous) return 0; return 1; case UNLESS: return Enabled0(e->sub->this->frst); case ATOMIC: case D_STEP: case NON_ATOMIC: return Enabled0(e->n->sl->this->frst); } if (e->sub) /* true for IF, DO, and UNLESS */ { for (z = e->sub; z; z = z->nxt) if (Enabled0(z->this->frst)) return 1; return 0; } for (z = e->esc; z; z = z->nxt) { if (Enabled0(z->this->frst)) return 1; } #if 0 printf("enabled1 "); comment(stdout, e->n, 0); printf(" ==> %s\n", Enabled1(e->n)?"yes":"nope"); #endif return Enabled1(e->n); } int pc_enabled(Lextok *n) { int i = nproc - nstop; int pid = eval(n); int result = 0; RunList *Y, *oX; if (pid == X->pid) fatal("used: enabled(pid=thisproc) [%s]", X->n->name); for (Y = run; Y; Y = Y->nxt) if (--i == pid) { oX = X; X = Y; result = Enabled0(X->pc); X = oX; break; } return result; } int pc_highest(Lextok *n) { int i = nproc - nstop; int pid = eval(n); int target = 0, result = 1; RunList *Y, *oX; if (X->prov && !eval(X->prov)) return 0; /* can't be highest unless fully enabled */ for (Y = run; Y; Y = Y->nxt) { if (--i == pid) { target = Y->priority; break; } } if (0) printf("highest for pid %d @ priority = %d\n", pid, target); oX = X; i = nproc - nstop; for (Y = run; Y; Y = Y->nxt) { i--; if (0) printf(" pid %d @ priority %d\t", Y->pid, Y->priority); if (Y->priority > target) { X = Y; if (0) printf("enabled: %s\n", Enabled0(X->pc)?"yes":"nope"); if (0) printf("provided: %s\n", eval(X->prov)?"yes":"nope"); if (Enabled0(X->pc) && (!X->prov || eval(X->prov))) { result = 0; break; } } else if (0) printf("\n"); } X = oX; return result; } int get_priority(Lextok *n) { int i = nproc - nstop; int pid = eval(n); RunList *Y; if (old_priority_rules) { return 1; } for (Y = run; Y; Y = Y->nxt) { if (--i == pid) { return Y->priority; } } return 0; } void set_priority(Lextok *n, Lextok *p) { int i = nproc - nstop - Have_claim; int pid = eval(n); RunList *Y; if (old_priority_rules) { return; } for (Y = run; Y; Y = Y->nxt) { if (--i == pid) { Priority_Sum -= Y->priority; Y->priority = eval(p); Priority_Sum += Y->priority; if (1) { printf("%3d: setting priority of proc %d (%s) to %d\n", depth, pid, Y->n->name, Y->priority); } } } if (verbose&32) { printf("\tPid\tName\tPriority\n"); for (Y = run; Y; Y = Y->nxt) { printf("\t%d\t%s\t%d\n", Y->pid, Y->n->name, Y->priority); } } } Spin/Src6.4.5/structs.c0000664000175100017510000003350112641605057012556 0ustar ghgh/***** spin: structs.c *****/ /* * This file is part of the public release of Spin. It is subject to the * terms in the LICENSE file that is included in this source directory. * Tool documentation is available at http://spinroot.com */ #include "spin.h" #include "y.tab.h" typedef struct UType { Symbol *nm; /* name of the type */ Lextok *cn; /* contents */ struct UType *nxt; /* linked list */ } UType; extern Symbol *Fname; extern int lineno, depth, Expand_Ok, has_hidden, in_for; Symbol *owner; static UType *Unames = 0; static UType *Pnames = 0; static Lextok *cpnn(Lextok *, int, int, int); extern void sr_mesg(FILE *, int, int); void setuname(Lextok *n) { UType *tmp; if (!owner) fatal("illegal reference inside typedef", (char *) 0); for (tmp = Unames; tmp; tmp = tmp->nxt) if (!strcmp(owner->name, tmp->nm->name)) { non_fatal("typename %s was defined before", tmp->nm->name); return; } tmp = (UType *) emalloc(sizeof(UType)); tmp->nm = owner; tmp->cn = n; tmp->nxt = Unames; Unames = tmp; } static void putUname(FILE *fd, UType *tmp) { Lextok *fp, *tl; if (!tmp) return; putUname(fd, tmp->nxt); /* postorder */ fprintf(fd, "struct %s { /* user defined type */\n", tmp->nm->name); for (fp = tmp->cn; fp; fp = fp->rgt) for (tl = fp->lft; tl; tl = tl->rgt) typ2c(tl->sym); fprintf(fd, "};\n"); } void putunames(FILE *fd) { putUname(fd, Unames); } int isutype(char *t) { UType *tmp; for (tmp = Unames; tmp; tmp = tmp->nxt) { if (!strcmp(t, tmp->nm->name)) return 1; } return 0; } Lextok * getuname(Symbol *t) { UType *tmp; for (tmp = Unames; tmp; tmp = tmp->nxt) { if (!strcmp(t->name, tmp->nm->name)) return tmp->cn; } fatal("%s is not a typename", t->name); return (Lextok *)0; } void setutype(Lextok *p, Symbol *t, Lextok *vis) /* user-defined types */ { int oln = lineno; Symbol *ofn = Fname; Lextok *m, *n; m = getuname(t); for (n = p; n; n = n->rgt) { lineno = n->ln; Fname = n->fn; if (n->sym->type) fatal("redeclaration of '%s'", n->sym->name); if (n->sym->nbits > 0) non_fatal("(%s) only an unsigned can have width-field", n->sym->name); if (Expand_Ok) n->sym->hidden |= (4|8|16); /* formal par */ if (vis) { if (strncmp(vis->sym->name, ":hide:", (size_t) 6) == 0) { n->sym->hidden |= 1; has_hidden++; } else if (strncmp(vis->sym->name, ":show:", (size_t) 6) == 0) n->sym->hidden |= 2; else if (strncmp(vis->sym->name, ":local:", (size_t) 7) == 0) n->sym->hidden |= 64; } n->sym->type = STRUCT; /* classification */ n->sym->Slst = m; /* structure itself */ n->sym->Snm = t; /* name of typedef */ n->sym->Nid = 0; /* this is no chan */ n->sym->hidden |= 4; if (n->sym->nel <= 0) non_fatal("bad array size for '%s'", n->sym->name); } lineno = oln; Fname = ofn; } static Symbol * do_same(Lextok *n, Symbol *v, int xinit) { Lextok *tmp, *fp, *tl; int ix = eval(n->lft); int oln = lineno; Symbol *ofn = Fname; lineno = n->ln; Fname = n->fn; /* n->sym->type == STRUCT * index: n->lft * subfields: n->rgt * structure template: n->sym->Slst * runtime values: n->sym->Sval */ if (xinit) ini_struct(v); /* once, at top level */ if (ix >= v->nel || ix < 0) { printf("spin: indexing %s[%d] - size is %d\n", v->name, ix, v->nel); fatal("indexing error \'%s\'", v->name); } if (!n->rgt || !n->rgt->lft) { non_fatal("no subfields %s", v->name); /* i.e., wants all */ lineno = oln; Fname = ofn; return ZS; } if (n->rgt->ntyp != '.') { printf("bad subfield type %d\n", n->rgt->ntyp); alldone(1); } tmp = n->rgt->lft; if (tmp->ntyp != NAME && tmp->ntyp != TYPE) { printf("bad subfield entry %d\n", tmp->ntyp); alldone(1); } for (fp = v->Sval[ix]; fp; fp = fp->rgt) for (tl = fp->lft; tl; tl = tl->rgt) if (!strcmp(tl->sym->name, tmp->sym->name)) { lineno = oln; Fname = ofn; return tl->sym; } fatal("cannot locate subfield %s", tmp->sym->name); return ZS; } int Rval_struct(Lextok *n, Symbol *v, int xinit) /* n varref, v valref */ { Symbol *tl; Lextok *tmp; int ix; if (!n || !(tl = do_same(n, v, xinit))) return 0; tmp = n->rgt->lft; if (tmp->sym->type == STRUCT) { return Rval_struct(tmp, tl, 0); } else if (tmp->rgt) fatal("non-zero 'rgt' on non-structure", 0); ix = eval(tmp->lft); /* printf("%d: ix: %d (%d) %d\n", depth, ix, tl->nel, tl->val[ix]); */ if (ix >= tl->nel || ix < 0) fatal("indexing error \'%s\'", tl->name); return cast_val(tl->type, tl->val[ix], tl->nbits); } int Lval_struct(Lextok *n, Symbol *v, int xinit, int a) /* a = assigned value */ { Symbol *tl; Lextok *tmp; int ix; if (!(tl = do_same(n, v, xinit))) return 1; tmp = n->rgt->lft; if (tmp->sym->type == STRUCT) return Lval_struct(tmp, tl, 0, a); else if (tmp->rgt) fatal("non-zero 'rgt' on non-structure", 0); ix = eval(tmp->lft); if (ix >= tl->nel || ix < 0) fatal("indexing error \'%s\'", tl->name); if (tl->nbits > 0) a = (a & ((1<nbits)-1)); if (a != tl->val[ix]) { tl->val[ix] = a; tl->setat = depth; } return 1; } int Cnt_flds(Lextok *m) { Lextok *fp, *tl, *n; int cnt = 0; if (m->ntyp == ',') { n = m; goto is_lst; } if (!m->sym || m->ntyp != STRUCT) return 1; n = getuname(m->sym); is_lst: for (fp = n; fp; fp = fp->rgt) for (tl = fp->lft; tl; tl = tl->rgt) { if (tl->sym->type == STRUCT) { if (tl->sym->nel > 1 || tl->sym->isarray) fatal("array of structures in param list, %s", tl->sym->name); cnt += Cnt_flds(tl->sym->Slst); } else cnt += tl->sym->nel; } return cnt; } int Sym_typ(Lextok *t) { Symbol *s = t->sym; if (!s) return 0; if (s->type != STRUCT) return s->type; if (!t->rgt || t->rgt->ntyp != '.' /* gh: had ! in wrong place */ || !t->rgt->lft) return STRUCT; /* not a field reference */ return Sym_typ(t->rgt->lft); } int Width_set(int *wdth, int i, Lextok *n) { Lextok *fp, *tl; int j = i, k; for (fp = n; fp; fp = fp->rgt) for (tl = fp->lft; tl; tl = tl->rgt) { if (tl->sym->type == STRUCT) j = Width_set(wdth, j, tl->sym->Slst); else { for (k = 0; k < tl->sym->nel; k++, j++) wdth[j] = tl->sym->type; } } return j; } void ini_struct(Symbol *s) { int i; Lextok *fp, *tl; if (s->type != STRUCT) /* last step */ { (void) checkvar(s, 0); return; } if (s->Sval == (Lextok **) 0) { s->Sval = (Lextok **) emalloc(s->nel * sizeof(Lextok *)); for (i = 0; i < s->nel; i++) { s->Sval[i] = cpnn(s->Slst, 1, 1, 1); for (fp = s->Sval[i]; fp; fp = fp->rgt) for (tl = fp->lft; tl; tl = tl->rgt) ini_struct(tl->sym); } } } static Lextok * cpnn(Lextok *s, int L, int R, int S) { Lextok *d; extern int Nid; if (!s) return ZN; d = (Lextok *) emalloc(sizeof(Lextok)); d->uiid = s->uiid; d->ntyp = s->ntyp; d->val = s->val; d->ln = s->ln; d->fn = s->fn; d->sym = s->sym; if (L) d->lft = cpnn(s->lft, 1, 1, S); if (R) d->rgt = cpnn(s->rgt, 1, 1, S); if (S && s->sym) { d->sym = (Symbol *) emalloc(sizeof(Symbol)); memcpy(d->sym, s->sym, sizeof(Symbol)); if (d->sym->type == CHAN) d->sym->Nid = ++Nid; } if (s->sq || s->sl) fatal("cannot happen cpnn", (char *) 0); return d; } int full_name(FILE *fd, Lextok *n, Symbol *v, int xinit) { Symbol *tl; Lextok *tmp; int hiddenarrays = 0; fprintf(fd, "%s", v->name); if (!n || !(tl = do_same(n, v, xinit))) return 0; tmp = n->rgt->lft; if (tmp->sym->type == STRUCT) { fprintf(fd, "."); hiddenarrays = full_name(fd, tmp, tl, 0); goto out; } fprintf(fd, ".%s", tl->name); out: if (tmp->sym->nel > 1 || tmp->sym->isarray == 1) { fprintf(fd, "[%d]", eval(tmp->lft)); hiddenarrays = 1; } return hiddenarrays; } void validref(Lextok *p, Lextok *c) { Lextok *fp, *tl; char lbuf[512]; for (fp = p->sym->Slst; fp; fp = fp->rgt) for (tl = fp->lft; tl; tl = tl->rgt) if (strcmp(tl->sym->name, c->sym->name) == 0) return; sprintf(lbuf, "no field '%s' defined in structure '%s'\n", c->sym->name, p->sym->name); non_fatal(lbuf, (char *) 0); } void struct_name(Lextok *n, Symbol *v, int xinit, char *buf) { Symbol *tl; Lextok *tmp; char lbuf[512]; if (!n || !(tl = do_same(n, v, xinit))) return; tmp = n->rgt->lft; if (tmp->sym->type == STRUCT) { strcat(buf, "."); struct_name(tmp, tl, 0, buf); return; } sprintf(lbuf, ".%s", tl->name); strcat(buf, lbuf); if (tmp->sym->nel > 1 || tmp->sym->isarray == 1) { sprintf(lbuf, "[%d]", eval(tmp->lft)); strcat(buf, lbuf); } } void walk2_struct(char *s, Symbol *z) { Lextok *fp, *tl; char eprefix[128]; int ix; extern void Done_case(char *, Symbol *); ini_struct(z); if (z->nel == 1 && z->isarray == 0) sprintf(eprefix, "%s%s.", s, z->name); for (ix = 0; ix < z->nel; ix++) { if (z->nel > 1 || z->isarray == 1) sprintf(eprefix, "%s%s[%d].", s, z->name, ix); for (fp = z->Sval[ix]; fp; fp = fp->rgt) for (tl = fp->lft; tl; tl = tl->rgt) { if (tl->sym->type == STRUCT) walk2_struct(eprefix, tl->sym); else if (tl->sym->type == CHAN) Done_case(eprefix, tl->sym); } } } void walk_struct(FILE *ofd, int dowhat, char *s, Symbol *z, char *a, char *b, char *c) { Lextok *fp, *tl; char eprefix[128]; int ix; ini_struct(z); if (z->nel == 1 && z->isarray == 0) sprintf(eprefix, "%s%s.", s, z->name); for (ix = 0; ix < z->nel; ix++) { if (z->nel > 1 || z->isarray == 1) sprintf(eprefix, "%s%s[%d].", s, z->name, ix); for (fp = z->Sval[ix]; fp; fp = fp->rgt) for (tl = fp->lft; tl; tl = tl->rgt) { if (tl->sym->type == STRUCT) walk_struct(ofd, dowhat, eprefix, tl->sym, a,b,c); else do_var(ofd, dowhat, eprefix, tl->sym, a,b,c); } } } void c_struct(FILE *fd, char *ipref, Symbol *z) { Lextok *fp, *tl; char pref[256], eprefix[300]; int ix; ini_struct(z); for (ix = 0; ix < z->nel; ix++) for (fp = z->Sval[ix]; fp; fp = fp->rgt) for (tl = fp->lft; tl; tl = tl->rgt) { strcpy(eprefix, ipref); if (z->nel > 1 || z->isarray == 1) { /* insert index before last '.' */ eprefix[strlen(eprefix)-1] = '\0'; sprintf(pref, "[ %d ].", ix); strcat(eprefix, pref); } if (tl->sym->type == STRUCT) { strcat(eprefix, tl->sym->name); strcat(eprefix, "."); c_struct(fd, eprefix, tl->sym); } else c_var(fd, eprefix, tl->sym); } } void dump_struct(Symbol *z, char *prefix, RunList *r) { Lextok *fp, *tl; char eprefix[256]; int ix, jx; ini_struct(z); for (ix = 0; ix < z->nel; ix++) { if (z->nel > 1 || z->isarray == 1) sprintf(eprefix, "%s[%d]", prefix, ix); else strcpy(eprefix, prefix); for (fp = z->Sval[ix]; fp; fp = fp->rgt) for (tl = fp->lft; tl; tl = tl->rgt) { if (tl->sym->type == STRUCT) { char pref[300]; strcpy(pref, eprefix); strcat(pref, "."); strcat(pref, tl->sym->name); dump_struct(tl->sym, pref, r); } else for (jx = 0; jx < tl->sym->nel; jx++) { if (tl->sym->type == CHAN) doq(tl->sym, jx, r); else { printf("\t\t"); if (r) printf("%s(%d):", r->n->name, r->pid); printf("%s.%s", eprefix, tl->sym->name); if (tl->sym->nel > 1 || tl->sym->isarray == 1) printf("[%d]", jx); printf(" = "); sr_mesg(stdout, tl->sym->val[jx], tl->sym->type == MTYPE); printf("\n"); } } } } } static int retrieve(Lextok **targ, int i, int want, Lextok *n, int Ntyp) { Lextok *fp, *tl; int j = i, k; for (fp = n; fp; fp = fp->rgt) for (tl = fp->lft; tl; tl = tl->rgt) { if (tl->sym->type == STRUCT) { j = retrieve(targ, j, want, tl->sym->Slst, Ntyp); if (j < 0) { Lextok *x = cpnn(tl, 1, 0, 0); x->rgt = nn(ZN, '.', (*targ), ZN); (*targ) = x; return -1; } } else { for (k = 0; k < tl->sym->nel; k++, j++) { if (j == want) { *targ = cpnn(tl, 1, 0, 0); (*targ)->lft = nn(ZN, CONST, ZN, ZN); (*targ)->lft->val = k; if (Ntyp) (*targ)->ntyp = (short) Ntyp; return -1; } } } } return j; } static int is_explicit(Lextok *n) { if (!n) return 0; if (!n->sym) fatal("unexpected - no symbol", 0); if (n->sym->type != STRUCT) return 1; if (!n->rgt) return 0; if (n->rgt->ntyp != '.') { lineno = n->ln; Fname = n->fn; printf("ntyp %d\n", n->rgt->ntyp); fatal("unexpected %s, no '.'", n->sym->name); } return is_explicit(n->rgt->lft); } Lextok * expand(Lextok *n, int Ok) /* turn rgt-lnked list of struct nms, into ',' list of flds */ { Lextok *x = ZN, *y; if (!Ok) return n; while (n) { y = mk_explicit(n, 1, 0); if (x) (void) tail_add(x, y); else x = y; n = n->rgt; } return x; } Lextok * mk_explicit(Lextok *n, int Ok, int Ntyp) /* produce a single ',' list of fields */ { Lextok *bld = ZN, *x; int i, cnt; extern int IArgs; if (n->sym->type != STRUCT || in_for || is_explicit(n)) return n; if (n->rgt && n->rgt->ntyp == '.' && n->rgt->lft && n->rgt->lft->sym && n->rgt->lft->sym->type == STRUCT) { Lextok *y; bld = mk_explicit(n->rgt->lft, Ok, Ntyp); for (x = bld; x; x = x->rgt) { y = cpnn(n, 1, 0, 0); y->rgt = nn(ZN, '.', x->lft, ZN); x->lft = y; } return bld; } if (!Ok || !n->sym->Slst) { if (IArgs) return n; printf("spin: saw '"); comment(stdout, n, 0); printf("'\n"); fatal("incomplete structure ref '%s'", n->sym->name); } cnt = Cnt_flds(n->sym->Slst); for (i = cnt-1; i >= 0; i--) { bld = nn(ZN, ',', ZN, bld); if (retrieve(&(bld->lft), 0, i, n->sym->Slst, Ntyp) >= 0) { printf("cannot retrieve field %d\n", i); fatal("bad structure %s", n->sym->name); } x = cpnn(n, 1, 0, 0); x->rgt = nn(ZN, '.', bld->lft, ZN); bld->lft = x; } return bld; } Lextok * tail_add(Lextok *a, Lextok *b) { Lextok *t; for (t = a; t->rgt; t = t->rgt) if (t->ntyp != ',') fatal("unexpected type - tail_add", 0); t->rgt = b; return a; } void setpname(Lextok *n) { UType *tmp; for (tmp = Pnames; tmp; tmp = tmp->nxt) if (!strcmp(n->sym->name, tmp->nm->name)) { non_fatal("proctype %s redefined", n->sym->name); return; } tmp = (UType *) emalloc(sizeof(UType)); tmp->nm = n->sym; tmp->nxt = Pnames; Pnames = tmp; } int isproctype(char *t) { UType *tmp; for (tmp = Pnames; tmp; tmp = tmp->nxt) { if (!strcmp(t, tmp->nm->name)) return 1; } return 0; } Spin/Src6.4.5/main.c0000664000175100017510000012370112641605057011775 0ustar ghgh/***** spin: main.c *****/ /* * This file is part of the public release of Spin. It is subject to the * terms in the LICENSE file that is included in this source directory. * Tool documentation is available at http://spinroot.com */ #include #include #include "spin.h" #include "version.h" #include #include #include #include #ifdef PC #include #else #include #endif #include "y.tab.h" extern int DstepStart, lineno, tl_terse; extern FILE *yyin, *yyout, *tl_out; extern Symbol *context; extern char *claimproc; extern void repro_src(void); extern void qhide(int); extern char CurScope[MAXSCOPESZ]; extern short has_provided, has_code, has_ltl, has_accept; extern int realread, buzzed; static void add_comptime(char *); static void add_runtime(char *); Symbol *Fname, *oFname; int Etimeouts; /* nr timeouts in program */ int Ntimeouts; /* nr timeouts in never claim */ int analyze, columns, dumptab, has_remote, has_remvar; int interactive, jumpsteps, m_loss, nr_errs, cutoff; int s_trail, ntrail, verbose, xspin, notabs, rvopt; int no_print, no_wrapup, Caccess, limited_vis, like_java; int separate; /* separate compilation */ int export_ast; /* pangen5.c */ int old_scope_rules; /* use pre 5.3.0 rules */ int old_priority_rules; /* use pre 6.2.0 rules */ int product, Strict; short replay; int merger = 1, deadvar = 1, implied_semis = 1; int ccache = 0; /* oyvind teig: 5.2.0 case caching off by default */ static int preprocessonly, SeedUsed, itsr, itsr_n; static int seedy; /* be verbose about chosen seed */ static int inlineonly; /* show inlined code */ static int dataflow = 1; #if 0 meaning of flags on verbose: 1 -g global variable values 2 -l local variable values 4 -p all process actions 8 -r receives 16 -s sends 32 -v verbose 64 -w very verbose #endif static char Operator[] = "operator: "; static char Keyword[] = "keyword: "; static char Function[] = "function-name: "; static char **add_ltl = (char **) 0; static char **ltl_file = (char **) 0; static char **nvr_file = (char **) 0; static char *ltl_claims = (char *) 0; static char *pan_runtime = ""; static char *pan_comptime = ""; static char formula[4096]; static FILE *fd_ltl = (FILE *) 0; static char *PreArg[64]; static int PreCnt = 0; static char out1[64]; char **trailfilename; /* new option 'k' */ void explain(int); #ifndef CPP /* to use visual C++: #define CPP "cl -E/E" or call spin as: spin -P"CL -E/E" on OS2: #define CPP "icc -E/Pd+ -E/Q+" or call spin as: spin -P"icc -E/Pd+ -E/Q+" make sure the -E arg is always at the end, in each case, because the command line can later be truncated at that point */ #if 1 #define CPP "gcc -std=gnu99 -E -x c" /* 6.4.0 new default on all systems */ /* if gcc-4 is available, this setting is modified below */ #else #if defined(PC) || defined(MAC) #define CPP "gcc -std=gnu99 -E -x c" #else #ifdef SOLARIS #define CPP "/usr/ccs/lib/cpp" #else #define CPP "cpp" /* sometimes: "/lib/cpp" */ #endif #endif #endif #endif static char PreProc[512]; extern int depth; /* at least some steps were made */ int WhatSeed(void) { return SeedUsed; } void final_fiddle(void) { char *has_a, *has_l, *has_f; /* no -a or -l but has_accept: add -a */ /* no -a or -l in pan_runtime: add -DSAFETY to pan_comptime */ /* -a or -l but no -f then add -DNOFAIR */ has_a = strstr(pan_runtime, "-a"); has_l = strstr(pan_runtime, "-l"); has_f = strstr(pan_runtime, "-f"); if (!has_l && !has_a && strstr(pan_comptime, "-DNP")) { add_runtime("-l"); has_l = strstr(pan_runtime, "-l"); } if (!has_a && !has_l && !strstr(pan_comptime, "-DSAFETY")) { if (has_accept && !strstr(pan_comptime, "-DBFS") && !strstr(pan_comptime, "-DNOCLAIM")) { add_runtime("-a"); has_a = pan_runtime; } else { add_comptime("-DSAFETY"); } } if ((has_a || has_l) && !has_f && !strstr(pan_comptime, "-DNOFAIR")) { add_comptime("-DNOFAIR"); } } static int change_param(char *t, char *what, int range) { char *ptr; int v; assert(range < 1000 && range > 0); if ((ptr = strstr(t, what)) != NULL) { ptr += strlen(what); if (!isdigit((int) *ptr)) { return 0; } v = (atoi(ptr) + 1)%range; if (v >= 100) { *ptr++ = '0' + (v/100); v %= 100; *ptr++ = '0' + (v/10); *ptr = '0' + (v%10); } else if (v >= 10) { *ptr++ = '0' + (v/10); *ptr++ = '0' + (v%10); *ptr = ' '; } else { *ptr++ = '0' + v; *ptr++ = ' '; *ptr = ' '; } } return 1; } static void change_rs(char *t) { char *ptr; int cnt = 0; long v; if ((ptr = strstr(t, "-RS")) != NULL) { ptr += 3; /* room for at least 10 digits */ v = Rand()%1000000000L; while (v/10 > 0) { *ptr++ = '0' + v%10; v /= 10; cnt++; } *ptr++ = '0' + v; cnt++; while (cnt++ < 10) { *ptr++ = ' '; } } } int omit_str(char *in, char *s) { char *ptr = strstr(in, s); int i, nr = -1; if (ptr) { for (i = 0; i < (int) strlen(s); i++) { *ptr++ = ' '; } if (isdigit((int) *ptr)) { nr = atoi(ptr); while (isdigit((int) *ptr)) { *ptr++ = ' '; } } } return nr; } void string_trim(char *t) { int n = strlen(t) - 1; while (n > 0 && t[n] == ' ') { t[n--] = '\0'; } } int e_system(int v, const char *s) { static int count = 1; /* v == 0 : checks to find non-linked version of gcc */ /* v == 1 : all other commands */ /* v == 2 : preprocessing the promela input */ if (v == 1) { if (verbose&(32|64)) /* -v or -w */ { printf("cmd%02d: %s\n", count++, s); fflush(stdout); } if (verbose&64) /* only -w */ { return 0; /* suppress the call to system(s) */ } } return system(s); } void alldone(int estatus) { char *ptr; #if defined(WIN32) || defined(WIN64) struct _stat x; #else struct stat x; #endif if (preprocessonly == 0 && strlen(out1) > 0) { (void) unlink((const char *) out1); } (void) unlink(TMP_FILE1); (void) unlink(TMP_FILE2); if (!buzzed && seedy && !analyze && !export_ast && !s_trail && !preprocessonly && depth > 0) { printf("seed used: %d\n", SeedUsed); } if (!buzzed && xspin && (analyze || s_trail)) { if (estatus) { printf("spin: %d error(s) - aborting\n", estatus); } else { printf("Exit-Status 0\n"); } } if (buzzed && replay && !has_code && !estatus) { extern QH *qh; QH *j; int i; char *tmp = (char *) emalloc(strlen("spin -t") + strlen(pan_runtime) + strlen(Fname->name) + 8); pan_runtime = (char *) emalloc(2048); /* more than enough */ sprintf(pan_runtime, "-n%d ", SeedUsed); if (jumpsteps) { sprintf(&pan_runtime[strlen(pan_runtime)], "-j%d ", jumpsteps); } if (trailfilename) { sprintf(&pan_runtime[strlen(pan_runtime)], "-k%s ", *trailfilename); } if (cutoff) { sprintf(&pan_runtime[strlen(pan_runtime)], "-u%d ", cutoff); } for (i = 1; i <= PreCnt; i++) { strcat(pan_runtime, PreArg[i]); strcat(pan_runtime, " "); } for (j = qh; j; j = j->nxt) { sprintf(&pan_runtime[strlen(pan_runtime)], "-q%d ", j->n); } if (strcmp(PreProc, CPP) != 0) { sprintf(&pan_runtime[strlen(pan_runtime)], "\"-P%s\" ", PreProc); } /* -oN options 1..5 are ignored in simulations */ if (old_priority_rules) strcat(pan_runtime, "-o6 "); if (!implied_semis) strcat(pan_runtime, "-o7 "); if (no_print) strcat(pan_runtime, "-b "); if (no_wrapup) strcat(pan_runtime, "-B "); if (columns == 1) strcat(pan_runtime, "-c "); if (columns == 2) strcat(pan_runtime, "-M "); if (seedy == 1) strcat(pan_runtime, "-h "); if (like_java == 1) strcat(pan_runtime, "-J "); if (old_scope_rules) strcat(pan_runtime, "-O "); if (notabs) strcat(pan_runtime, "-T "); if (verbose&1) strcat(pan_runtime, "-g "); if (verbose&2) strcat(pan_runtime, "-l "); if (verbose&4) strcat(pan_runtime, "-p "); if (verbose&8) strcat(pan_runtime, "-r "); if (verbose&16) strcat(pan_runtime, "-s "); if (verbose&32) strcat(pan_runtime, "-v "); if (verbose&64) strcat(pan_runtime, "-w "); if (m_loss) strcat(pan_runtime, "-m "); sprintf(tmp, "spin -t %s %s", pan_runtime, Fname->name); estatus = e_system(1, tmp); /* replay */ exit(estatus); /* replay without c_code */ } if (buzzed && (!replay || has_code) && !estatus) { char *tmp, *tmp2 = NULL, *P_X; char *C_X = (buzzed == 2) ? "-O" : ""; if (replay && strlen(pan_comptime) == 0) { #if defined(WIN32) || defined(WIN64) P_X = "pan"; #else P_X = "./pan"; #endif if (stat(P_X, (struct stat *)&x) < 0) { goto recompile; /* no executable pan for replay */ } tmp = (char *) emalloc(8 + strlen(P_X) + strlen(pan_runtime) +4); /* the final +4 is too allow adding " &" in some cases */ sprintf(tmp, "%s %s", P_X, pan_runtime); goto runit; } #if defined(WIN32) || defined(WIN64) P_X = "-o pan pan.c && pan"; #else P_X = "-o pan pan.c && ./pan"; #endif /* swarm and biterate randomization additions */ if (!replay && itsr) /* iterative search refinement */ { if (!strstr(pan_comptime, "-DBITSTATE")) { add_comptime("-DBITSTATE"); } if (!strstr(pan_comptime, "-DPUTPID")) { add_comptime("-DPUTPID"); } if (!strstr(pan_comptime, "-DT_RAND") && !strstr(pan_comptime, "-DT_REVERSE")) { add_runtime("-T0 "); /* controls t_reverse */ } if (!strstr(pan_runtime, "-P") /* runtime flag */ || pan_runtime[2] < '0' || pan_runtime[2] > '1') /* no -P0 or -P1 */ { add_runtime("-P0 "); /* controls p_reverse */ } if (!strstr(pan_runtime, "-w")) { add_runtime("-w18 "); /* -w18 = 256K */ } else { char nv[32]; int x; x = omit_str(pan_runtime, "-w"); if (x >= 0) { sprintf(nv, "-w%d ", x); add_runtime(nv); /* added spaces */ } } if (!strstr(pan_runtime, "-h")) { add_runtime("-h0 "); /* 0..499 */ /* leave 2 spaces for increments up to -h499 */ } else if (!strstr(pan_runtime, "-hash")) { char nv[32]; int x; x = omit_str(pan_runtime, "-h"); if (x >= 0) { sprintf(nv, "-h%d ", x%500); add_runtime(nv); /* added spaces */ } } if (!strstr(pan_runtime, "-k")) { add_runtime("-k1 "); /* 1..3 */ } else { char nv[32]; int x; x = omit_str(pan_runtime, "-k"); if (x >= 0) { sprintf(nv, "-k%d ", x%4); add_runtime(nv); /* added spaces */ } } if (strstr(pan_runtime, "-p_rotate")) { char nv[32]; int x; x = omit_str(pan_runtime, "-p_rotate"); if (x < 0) { x = 0; } sprintf(nv, "-p_rotate%d ", x%256); add_runtime(nv); /* added spaces */ } else if (strstr(pan_runtime, "-p_permute") == 0) { add_runtime("-p_rotate0 "); } if (strstr(pan_runtime, "-RS")) { (void) omit_str(pan_runtime, "-RS"); } /* need room for at least 10 digits */ add_runtime("-RS1234567890 "); change_rs(pan_runtime); } recompile: if (strstr(PreProc, "cpp")) /* unix/linux */ { strcpy(PreProc, "gcc"); /* need compiler */ } else if ((tmp = strstr(PreProc, "-E")) != NULL) { *tmp = '\0'; /* strip preprocessing flags */ } final_fiddle(); tmp = (char *) emalloc(8 + /* account for alignment */ strlen(PreProc) + strlen(C_X) + strlen(pan_comptime) + strlen(P_X) + strlen(pan_runtime) + strlen(" -p_reverse & ")); tmp2 = tmp; /* P_X ends with " && ./pan " */ sprintf(tmp, "%s %s %s %s %s", PreProc, C_X, pan_comptime, P_X, pan_runtime); if (!replay) { if (itsr < 0) /* swarm only */ { strcat(tmp, " &"); /* after ./pan */ itsr = -itsr; /* now same as biterate */ } /* do compilation first * split cc command from run command * leave cc in tmp, and set tmp2 to run */ if ((ptr = strstr(tmp, " && ")) != NULL) { tmp2 = ptr + 4; /* first run */ *ptr = '\0'; } } if (has_ltl) { (void) unlink("_spin_nvr.tmp"); } #ifdef PC /* make sure that if compilation fails we do not continue */ (void) unlink("./pan.exe"); #else (void) unlink("./pan"); #endif runit: estatus = e_system(1, tmp); /* compile */ if (replay || estatus < 0) { goto skipahead; } /* !replay */ if (itsr == 0) /* single run */ { estatus = e_system(1, tmp2); } else if (itsr > 0) /* iterative search refinement */ { int is_swarm = 0; if (tmp2 != tmp) /* swarm: did only compilation so far */ { tmp = tmp2; /* now we point to the run command */ estatus = e_system(1, tmp); /* first run */ } itsr--; /* count down */ /* the following are added back randomly later */ (void) omit_str(tmp, "-p_reverse"); /* replaced by spaces */ (void) omit_str(tmp, "-p_normal"); if (strstr(tmp, " &") != NULL) { (void) omit_str(tmp, " &"); is_swarm = 1; } /* increase -w every itsr_n-th run */ if ((itsr_n > 0 && (itsr == 0 || (itsr%itsr_n) != 0)) || (change_param(tmp, "-w", 36) >= 0)) /* max 4G bit statespace */ { (void) change_param(tmp, "-h", 500); /* hash function 0.499 */ (void) change_param(tmp, "-p_rotate", 256); /* if defined */ (void) change_param(tmp, "-k", 4); /* nr bits per state 0->1,1,2,3 */ (void) change_param(tmp, "-T", 2); /* with or without t_reverse*/ (void) change_param(tmp, "-P", 2); /* -P 0..1 != p_reverse */ change_rs(tmp); /* change random seed */ string_trim(tmp); if (rand()%5 == 0) /* 20% of all runs */ { strcat(tmp, " -p_reverse "); /* at end, so this overrides -p_rotateN, if there */ /* but -P0..1 disable this in 50% of the cases */ /* so its really activated in 10% of all runs */ } else if (rand()%6 == 0) /* override p_rotate and p_reverse */ { strcat(tmp, " -p_normal "); } if (is_swarm) { strcat(tmp, " &"); } goto runit; } } skipahead: (void) unlink("pan.b"); (void) unlink("pan.c"); (void) unlink("pan.h"); (void) unlink("pan.m"); (void) unlink("pan.p"); (void) unlink("pan.t"); } exit(estatus); } #if 0 -P0 normal active process creation -P1 reversed order for *active* process creation != p_reverse -T0 normal transition exploration -T1 reversed order of transition exploration -DP_RAND (random starting point +- -DP_REVERSE) -DPERMUTED (also enables -p_rotateN and -p_reverse) -DP_REVERSE (same as -DPERMUTED with -p_reverse, but 7% faster) -DT_RAND (random starting point -- optionally with -T0..1) -DT_REVERSE (superseded by -T0..1 options) -hash generates new hash polynomial for -h0 permutation modes: -permuted (adds -DPERMUTED) -- this is also the default with -swarm -t_reverse (same as -T1) -p_reverse (similar to -P1) -p_rotateN -p_normal less useful would be (since there is less non-determinism in transitions): -t_rotateN -- a controlled version of -DT_RAND compiling with -DPERMUTED enables a number of new runtime options, that -swarmN,M will also exploit: -p_permute (default) -p_rotateN -p_reverse #endif void preprocess(char *a, char *b, int a_tmp) { char precmd[1024], cmd[2048]; int i; #ifdef PC /* gcc is sometimes a symbolic link to gcc-4 that does not work well in cygwin, so we try to use the actual executable that is used. the code below assumes we are on a cygwin-like system */ if (strncmp(PreProc, "gcc ", strlen("gcc ")) == 0) { if (e_system(0, "gcc-4 --version > pan.pre") == 0) { strcpy(PreProc, "gcc-4 -std=gnu99 -E -x c"); } else if (e_system(0, "gcc-3 --version > pan.pre") == 0) { strcpy(PreProc, "gcc-3 -std=gnu99 -E -x c"); } } #endif assert(strlen(PreProc) < sizeof(precmd)); strcpy(precmd, PreProc); for (i = 1; i <= PreCnt; i++) { strcat(precmd, " "); strcat(precmd, PreArg[i]); } if (strlen(precmd) > sizeof(precmd)) { fprintf(stdout, "spin: too many -D args, aborting\n"); alldone(1); } sprintf(cmd, "%s %s > %s", precmd, a, b); if (e_system(2, (const char *)cmd)) /* preprocessing */ { (void) unlink((const char *) b); if (a_tmp) (void) unlink((const char *) a); fprintf(stdout, "spin: preprocessing failed\n"); /* 4.1.2 was stderr */ alldone(1); /* no return, error exit */ } if (a_tmp) (void) unlink((const char *) a); } void usage(void) { printf("use: spin [-option] ... [-option] file\n"); printf("\tNote: file must always be the last argument\n"); printf("\t-A apply slicing algorithm\n"); printf("\t-a generate a verifier in pan.c\n"); printf("\t-B no final state details in simulations\n"); printf("\t-b don't execute printfs in simulation\n"); printf("\t-C print channel access info (combine with -g etc.)\n"); printf("\t-c columnated -s -r simulation output\n"); printf("\t-d produce symbol-table information\n"); printf("\t-Dyyy pass -Dyyy to the preprocessor\n"); printf("\t-Eyyy pass yyy to the preprocessor\n"); printf("\t-e compute synchronous product of multiple never claims (modified by -L)\n"); printf("\t-f \"..formula..\" translate LTL "); printf("into never claim\n"); printf("\t-F file like -f, but with the LTL formula stored in a 1-line file\n"); printf("\t-g print all global variables\n"); printf("\t-h at end of run, print value of seed for random nr generator used\n"); printf("\t-i interactive (random simulation)\n"); printf("\t-I show result of inlining and preprocessing\n"); printf("\t-J reverse eval order of nested unlesses\n"); printf("\t-jN skip the first N steps "); printf("in simulation trail\n"); printf("\t-k fname use the trailfile stored in file fname, see also -t\n"); printf("\t-L when using -e, use strict language intersection\n"); printf("\t-l print all local variables\n"); printf("\t-M generate msc-flow in tcl/tk format\n"); printf("\t-m lose msgs sent to full queues\n"); printf("\t-N fname use never claim stored in file fname\n"); printf("\t-nN seed for random nr generator\n"); printf("\t-O use old scope rules (pre 5.3.0)\n"); printf("\t-o1 turn off dataflow-optimizations in verifier\n"); printf("\t-o2 don't hide write-only variables in verifier\n"); printf("\t-o3 turn off statement merging in verifier\n"); printf("\t-o4 turn on rendezvous optiomizations in verifier\n"); printf("\t-o5 turn on case caching (reduces size of pan.m, but affects reachability reports)\n"); printf("\t-o6 revert to the old rules for interpreting priority tags (pre version 6.2)\n"); printf("\t-o7 revert to the old rules for semi-colon usage (pre version 6.3)\n"); printf("\t-Pxxx use xxx for preprocessing\n"); printf("\t-p print all statements\n"); printf("\t-pp pretty-print (reformat) stdin, write stdout\n"); printf("\t-qN suppress io for queue N in printouts\n"); printf("\t-r print receive events\n"); printf("\t-replay replay an error trail-file found earlier\n"); printf("\t if the model contains embedded c-code, the ./pan executable is used\n"); printf("\t otherwise spin itself is used to replay the trailfile\n"); printf("\t note that pan recognizes different runtime options than spin itself\n"); printf("\t-search (or -run) generate a verifier, and compile and run it\n"); printf("\t options before -search are interpreted by spin to parse the input\n"); printf("\t options following a -search are used to compile and run the verifier pan\n"); printf("\t valid options that can follow a -search argument include:\n"); printf("\t -bfs perform a breadth-first search\n"); printf("\t -bfspar perform a parallel breadth-first search\n"); printf("\t -bcs use the bounded-context-switching algorithm\n"); printf("\t -bitstate or -bit, use bitstate storage\n"); printf("\t -biterate use bitstate with iterative search refinement (-w18..-w35)\n"); printf("\t -swarmN,M like -biterate, but running all iterations in parallel\n"); printf("\t perform N parallel runs and increment -w every M runs\n"); printf("\t default value for N is 10, default for M is 1\n"); printf("\t -link file.c link executable pan to file.c\n"); printf("\t -collapse use collapse state compression\n"); printf("\t -hc use hash-compact storage\n"); printf("\t -noclaim ignore all ltl and never claims\n"); printf("\t -p_permute use process scheduling order random permutation\n"); printf("\t -p_rotateN use process scheduling order rotation by N\n"); printf("\t -p_reverse use process scheduling order reversal\n"); printf("\t -ltl p verify the ltl property named p\n"); printf("\t -safety compile for safety properties only\n"); printf("\t -i use the dfs iterative shortening algorithm\n"); printf("\t -a search for acceptance cycles\n"); printf("\t -l search for non-progress cycles\n"); printf("\t similarly, a -D... parameter can be specified to modify the compilation\n"); printf("\t and any valid runtime pan argument can be specified for the verification\n"); printf("\t-S1 and -S2 separate pan source for claim and model\n"); printf("\t-s print send events\n"); printf("\t-T do not indent printf output\n"); printf("\t-t[N] follow [Nth] simulation trail, see also -k\n"); printf("\t-Uyyy pass -Uyyy to the preprocessor\n"); printf("\t-uN stop a simulation run after N steps\n"); printf("\t-v verbose, more warnings\n"); printf("\t-w very verbose (when combined with -l or -g)\n"); printf("\t-[XYZ] reserved for use by xspin interface\n"); printf("\t-V print version number and exit\n"); alldone(1); } int optimizations(int nr) { switch (nr) { case '1': dataflow = 1 - dataflow; /* dataflow */ if (verbose&32) printf("spin: dataflow optimizations turned %s\n", dataflow?"on":"off"); break; case '2': /* dead variable elimination */ deadvar = 1 - deadvar; if (verbose&32) printf("spin: dead variable elimination turned %s\n", deadvar?"on":"off"); break; case '3': /* statement merging */ merger = 1 - merger; if (verbose&32) printf("spin: statement merging turned %s\n", merger?"on":"off"); break; case '4': /* rv optimization */ rvopt = 1 - rvopt; if (verbose&32) printf("spin: rendezvous optimization turned %s\n", rvopt?"on":"off"); break; case '5': /* case caching */ ccache = 1 - ccache; if (verbose&32) printf("spin: case caching turned %s\n", ccache?"on":"off"); break; case '6': old_priority_rules = 1; if (verbose&32) printf("spin: using old priority rules (pre version 6.2)\n"); return 0; /* no break */ case '7': implied_semis = 0; if (verbose&32) printf("spin: no implied semi-colons (pre version 6.3)\n"); return 0; /* no break */ default: printf("spin: bad or missing parameter on -o\n"); usage(); break; } return 1; } static void add_comptime(char *s) { char *tmp; if (!s || strstr(pan_comptime, s)) { return; } tmp = (char *) emalloc(strlen(pan_comptime)+strlen(s)+2); sprintf(tmp, "%s %s", pan_comptime, s); pan_comptime = tmp; } static struct { char *ifsee, *thendo; int keeparg; } pats[] = { { "-bfspar", "-DBFS_PAR", 0 }, { "-bfs", "-DBFS", 0 }, { "-bcs", "-DBCS", 0 }, { "-bitstate", "-DBITSTATE", 0 }, { "-bit", "-DBITSTATE", 0 }, { "-hc", "-DHC4", 0 }, { "-collapse", "-DCOLLAPSE", 0 }, { "-noclaim", "-DNOCLAIM", 0 }, { "-permuted", "-DPERMUTED", 0 }, { "-p_permute", "-DPERMUTED", 1 }, { "-p_rotate", "-DPERMUTED", 1 }, { "-p_reverse", "-DPERMUTED", 1 }, { "-safety", "-DSAFETY", 0 }, { "-i", "-DREACH", 1 }, { "-l", "-DNP", 1 }, { 0, 0 } }; static void set_itsr_n(char *s) /* e.g., -swarm12,3 */ { char *tmp; if ((tmp = strchr(s, ',')) != NULL) { tmp++; if (*tmp != '\0' && isdigit((int) *tmp)) { itsr_n = atoi(tmp); if (itsr_n < 2) { itsr_n = 0; } } } } static void add_runtime(char *s) { char *tmp; int i; if (strncmp(s, "-biterate", strlen("-biterate")) == 0) { itsr = 10; /* default nr of sequential iterations */ if (isdigit((int) s[9])) { itsr = atoi(&s[9]); if (itsr < 1) { itsr = 1; } set_itsr_n(s); } return; } if (strncmp(s, "-swarm", strlen("-swarm")) == 0) { itsr = -10; /* parallel iterations */ if (isdigit((int) s[6])) { itsr = atoi(&s[6]); if (itsr < 1) { itsr = 1; } itsr = -itsr; set_itsr_n(s); } return; } for (i = 0; pats[i].ifsee; i++) { if (strncmp(s, pats[i].ifsee, strlen(pats[i].ifsee)) == 0) { add_comptime(pats[i].thendo); if (pats[i].keeparg) { break; } return; } } tmp = (char *) emalloc(strlen(pan_runtime)+strlen(s)+2); sprintf(tmp, "%s %s", pan_runtime, s); pan_runtime = tmp; } int main(int argc, char *argv[]) { Symbol *s; int T = (int) time((time_t *)0); int usedopts = 0; extern void ana_src(int, int); yyin = stdin; yyout = stdout; tl_out = stdout; strcpy(CurScope, "_"); assert(strlen(CPP) < sizeof(PreProc)); strcpy(PreProc, CPP); /* unused flags: y, z, G, L, Q, R, W */ while (argc > 1 && argv[1][0] == '-') { switch (argv[1][1]) { case 'A': export_ast = 1; break; case 'a': analyze = 1; break; case 'B': no_wrapup = 1; break; case 'b': no_print = 1; break; case 'C': Caccess = 1; break; case 'c': columns = 1; break; case 'D': PreArg[++PreCnt] = (char *) &argv[1][0]; break; /* define */ case 'd': dumptab = 1; break; case 'E': PreArg[++PreCnt] = (char *) &argv[1][2]; break; case 'e': product++; break; /* see also 'L' */ case 'F': ltl_file = (char **) (argv+2); argc--; argv++; break; case 'f': add_ltl = (char **) argv; argc--; argv++; break; case 'g': verbose += 1; break; case 'h': seedy = 1; break; case 'i': interactive = 1; break; case 'I': inlineonly = 1; break; case 'J': like_java = 1; break; case 'j': jumpsteps = atoi(&argv[1][2]); break; case 'k': s_trail = 1; trailfilename = (char **) (argv+2); argc--; argv++; break; case 'L': Strict++; break; /* modified -e */ case 'l': verbose += 2; break; case 'M': columns = 2; break; case 'm': m_loss = 1; break; case 'N': nvr_file = (char **) (argv+2); argc--; argv++; break; case 'n': T = atoi(&argv[1][2]); tl_terse = 1; break; case 'O': old_scope_rules = 1; break; case 'o': usedopts += optimizations(argv[1][2]); break; case 'P': assert(strlen((const char *) &argv[1][2]) < sizeof(PreProc)); strcpy(PreProc, (const char *) &argv[1][2]); break; case 'p': if (argv[1][2] == 'p') { pretty_print(); alldone(0); } verbose += 4; break; case 'q': if (isdigit((int) argv[1][2])) qhide(atoi(&argv[1][2])); break; case 'r': if (strcmp(&argv[1][1], "run") == 0) { Srand((unsigned int) T); samecase: if (buzzed != 0) { fatal("cannot combine -x with -run -replay or -search", (char *)0); } buzzed = 2; analyze = 1; argc--; argv++; /* process all remaining arguments as relating to pan: */ while (argc > 1 && argv[1][0] == '-') { switch (argv[1][1]) { case 'D': /* eg -DNP */ /* case 'E': conflicts with runtime arg */ case 'O': /* eg -O2 */ case 'U': /* to undefine a macro */ add_comptime(argv[1]); break; case 'l': if (strcmp(&argv[1][1], "ltl") == 0) { add_runtime("-N"); argc--; argv++; add_runtime(argv[1]); /* prop name */ break; } if (strcmp(&argv[1][1], "link") == 0) { argc--; argv++; add_comptime(argv[1]); break; } /* else fall through */ default: add_runtime(argv[1]); /* -bfs etc. */ break; } argc--; argv++; } argc++; argv--; } else if (strcmp(&argv[1][1], "replay") == 0) { replay = 1; add_runtime("-r"); goto samecase; } else { verbose += 8; } break; case 'S': separate = atoi(&argv[1][2]); /* S1 or S2 */ /* generate code for separate compilation */ analyze = 1; break; case 's': if (strcmp(&argv[1][1], "simulate") == 0) { break; /* ignore */ } if (strcmp(&argv[1][1], "search") == 0) { goto samecase; } verbose += 16; break; case 'T': notabs = 1; break; case 't': s_trail = 1; if (isdigit((int)argv[1][2])) { ntrail = atoi(&argv[1][2]); } break; case 'U': PreArg[++PreCnt] = (char *) &argv[1][0]; break; /* undefine */ case 'u': cutoff = atoi(&argv[1][2]); break; case 'v': verbose += 32; break; case 'V': printf("%s\n", SpinVersion); alldone(0); break; case 'w': verbose += 64; break; case 'x': /* internal - reserved use */ if (buzzed != 0) { fatal("cannot combine -x with -run -search or -replay", (char *)0); } buzzed = 1; /* implies also -a -o3 */ pan_runtime = "-d"; analyze = 1; usedopts += optimizations('3'); break; case 'X': xspin = notabs = 1; #ifndef PC signal(SIGPIPE, alldone); /* not posix... */ #endif break; case 'Y': limited_vis = 1; break; /* used by xspin */ case 'Z': preprocessonly = 1; break; /* used by xspin */ default : usage(); break; } argc--; argv++; } if (columns == 2 && !cutoff) { cutoff = 1024; } if (usedopts && !analyze) printf("spin: warning -o[1..5] option ignored in simulations\n"); if (ltl_file) { add_ltl = ltl_file-2; add_ltl[1][1] = 'f'; if (!(tl_out = fopen(*ltl_file, "r"))) { printf("spin: cannot open %s\n", *ltl_file); alldone(1); } if (!fgets(formula, 4096, tl_out)) { printf("spin: cannot read %s\n", *ltl_file); } fclose(tl_out); tl_out = stdout; *ltl_file = (char *) formula; } if (argc > 1) { FILE *fd = stdout; char cmd[512], out2[512]; /* must remain in current dir */ strcpy(out1, "pan.pre"); if (add_ltl || nvr_file) { assert(strlen(argv[1]) < sizeof(out2)); sprintf(out2, "%s.nvr", argv[1]); if ((fd = fopen(out2, MFLAGS)) == NULL) { printf("spin: cannot create tmp file %s\n", out2); alldone(1); } fprintf(fd, "#include \"%s\"\n", argv[1]); } if (add_ltl) { tl_out = fd; nr_errs = tl_main(2, add_ltl); fclose(fd); preprocess(out2, out1, 1); } else if (nvr_file) { fprintf(fd, "#include \"%s\"\n", *nvr_file); fclose(fd); preprocess(out2, out1, 1); } else { preprocess(argv[1], out1, 0); } if (preprocessonly) { alldone(0); } if (!(yyin = fopen(out1, "r"))) { printf("spin: cannot open %s\n", out1); alldone(1); } assert(strlen(argv[1])+1 < sizeof(cmd)); if (strncmp(argv[1], "progress", (size_t) 8) == 0 || strncmp(argv[1], "accept", (size_t) 6) == 0) { sprintf(cmd, "_%s", argv[1]); } else { strcpy(cmd, argv[1]); } oFname = Fname = lookup(cmd); if (oFname->name[0] == '\"') { int i = (int) strlen(oFname->name); oFname->name[i-1] = '\0'; oFname = lookup(&oFname->name[1]); } } else { oFname = Fname = lookup(""); if (add_ltl) { if (argc > 0) exit(tl_main(2, add_ltl)); printf("spin: missing argument to -f\n"); alldone(1); } printf("%s\n", SpinVersion); fprintf(stderr, "spin: error, no filename specified\n"); fflush(stdout); alldone(1); } if (columns == 2) { extern void putprelude(void); if (xspin || verbose&(1|4|8|16|32)) { printf("spin: -c precludes all flags except -t\n"); alldone(1); } putprelude(); } if (columns && !(verbose&8) && !(verbose&16)) { verbose += (8+16); } if (columns == 2 && limited_vis) { verbose += (1+4); } Srand((unsigned int) T); /* defined in run.c */ SeedUsed = T; s = lookup("_"); s->type = PREDEF; /* write-only global var */ s = lookup("_p"); s->type = PREDEF; s = lookup("_pid"); s->type = PREDEF; s = lookup("_last"); s->type = PREDEF; s = lookup("_nr_pr"); s->type = PREDEF; /* new 3.3.10 */ s = lookup("_priority"); s->type = PREDEF; /* new 6.2.0 */ yyparse(); fclose(yyin); if (ltl_claims) { Symbol *r; fclose(fd_ltl); if (!(yyin = fopen(ltl_claims, "r"))) { fatal("cannot open %s", ltl_claims); } r = oFname; oFname = Fname = lookup(ltl_claims); lineno = 0; yyparse(); fclose(yyin); oFname = Fname = r; if (0) { (void) unlink(ltl_claims); } } loose_ends(); if (inlineonly) { repro_src(); return 0; } chanaccess(); if (!Caccess) { if (has_provided && merger) { merger = 0; /* cannot use statement merging in this case */ } if (!s_trail && (dataflow || merger) && (!replay || has_code)) { ana_src(dataflow, merger); } sched(); alldone(nr_errs); } return 0; } void ltl_list(char *nm, char *fm) { if (s_trail || analyze || dumptab) /* when generating pan.c or replaying a trace */ { if (!ltl_claims) { ltl_claims = "_spin_nvr.tmp"; if ((fd_ltl = fopen(ltl_claims, MFLAGS)) == NULL) { fatal("cannot open tmp file %s", ltl_claims); } tl_out = fd_ltl; } add_ltl = (char **) emalloc(5 * sizeof(char *)); add_ltl[1] = "-c"; add_ltl[2] = nm; add_ltl[3] = "-f"; add_ltl[4] = (char *) emalloc(strlen(fm)+4); strcpy(add_ltl[4], "!("); strcat(add_ltl[4], fm); strcat(add_ltl[4], ")"); /* add_ltl[4] = fm; */ nr_errs += tl_main(4, add_ltl); fflush(tl_out); /* should read this file after the main file is read */ } } void non_fatal(char *s1, char *s2) { extern int yychar; extern char yytext[]; printf("spin: %s:%d, Error: ", Fname?Fname->name:(oFname?oFname->name:"nofilename"), lineno); #if 1 printf(s1, s2); /* avoids a gcc warning */ #else if (s2) printf(s1, s2); else printf(s1); #endif if (yychar > 0) { if (yychar == SEMI) { printf(" statement separator"); } else { printf(" saw '"); explain(yychar); printf("'"); } } if (strlen(yytext)>1) printf(" near '%s'", yytext); printf("\n"); nr_errs++; } void fatal(char *s1, char *s2) { non_fatal(s1, s2); (void) unlink("pan.b"); (void) unlink("pan.c"); (void) unlink("pan.h"); (void) unlink("pan.m"); (void) unlink("pan.t"); (void) unlink("pan.p"); (void) unlink("pan.pre"); if (!(verbose&32)) { (void) unlink("_spin_nvr.tmp"); } alldone(1); } char * emalloc(size_t n) { char *tmp; static unsigned long cnt = 0; if (n == 0) return NULL; /* robert shelton 10/20/06 */ if (!(tmp = (char *) malloc(n))) { printf("spin: allocated %ld Gb, wanted %d bytes more\n", cnt/(1024*1024*1024), (int) n); fatal("not enough memory", (char *)0); } cnt += (unsigned long) n; memset(tmp, 0, n); return tmp; } void trapwonly(Lextok *n /* , char *unused */) { short i = (n->sym)?n->sym->type:0; /* printf("%s realread %d type %d\n", n->sym?n->sym->name:"--", realread, i); */ if (realread && (i == MTYPE || i == BIT || i == BYTE || i == SHORT || i == INT || i == UNSIGNED)) { n->sym->hidden |= 128; /* var is read at least once */ } } void setaccess(Symbol *sp, Symbol *what, int cnt, int t) { Access *a; for (a = sp->access; a; a = a->lnk) if (a->who == context && a->what == what && a->cnt == cnt && a->typ == t) return; a = (Access *) emalloc(sizeof(Access)); a->who = context; a->what = what; a->cnt = cnt; a->typ = t; a->lnk = sp->access; sp->access = a; } Lextok * nn(Lextok *s, int t, Lextok *ll, Lextok *rl) { Lextok *n = (Lextok *) emalloc(sizeof(Lextok)); static int warn_nn = 0; n->uiid = is_inline(); /* record origin of the statement */ n->ntyp = (unsigned short) t; if (s && s->fn) { n->ln = s->ln; n->fn = s->fn; } else if (rl && rl->fn) { n->ln = rl->ln; n->fn = rl->fn; } else if (ll && ll->fn) { n->ln = ll->ln; n->fn = ll->fn; } else { n->ln = lineno; n->fn = Fname; } if (s) n->sym = s->sym; n->lft = ll; n->rgt = rl; n->indstep = DstepStart; if (t == TIMEOUT) Etimeouts++; if (!context) return n; if (t == 'r' || t == 's') setaccess(n->sym, ZS, 0, t); if (t == 'R') setaccess(n->sym, ZS, 0, 'P'); if (context->name == claimproc) { int forbidden = separate; switch (t) { case ASGN: printf("spin: Warning, never claim has side-effect\n"); break; case 'r': case 's': non_fatal("never claim contains i/o stmnts",(char *)0); break; case TIMEOUT: /* never claim polls timeout */ if (Ntimeouts && Etimeouts) forbidden = 0; Ntimeouts++; Etimeouts--; break; case LEN: case EMPTY: case FULL: case 'R': case NFULL: case NEMPTY: /* status becomes non-exclusive */ if (n->sym && !(n->sym->xu&XX)) { n->sym->xu |= XX; if (separate == 2) { printf("spin: warning, make sure that the S1 model\n"); printf(" also polls channel '%s' in its claim\n", n->sym->name); } } forbidden = 0; break; case 'c': AST_track(n, 0); /* register as a slice criterion */ /* fall thru */ default: forbidden = 0; break; } if (forbidden) { printf("spin: never, saw "); explain(t); printf("\n"); fatal("incompatible with separate compilation",(char *)0); } } else if ((t == ENABLED || t == PC_VAL) && !(warn_nn&t)) { printf("spin: Warning, using %s outside never claim\n", (t == ENABLED)?"enabled()":"pc_value()"); warn_nn |= t; } else if (t == NONPROGRESS) { fatal("spin: Error, using np_ outside never claim\n", (char *)0); } return n; } Lextok * rem_lab(Symbol *a, Lextok *b, Symbol *c) /* proctype name, pid, label name */ { Lextok *tmp1, *tmp2, *tmp3; has_remote++; c->type = LABEL; /* refered to in global context here */ fix_dest(c, a); /* in case target of rem_lab is jump */ tmp1 = nn(ZN, '?', b, ZN); tmp1->sym = a; tmp1 = nn(ZN, 'p', tmp1, ZN); tmp1->sym = lookup("_p"); tmp2 = nn(ZN, NAME, ZN, ZN); tmp2->sym = a; tmp3 = nn(ZN, 'q', tmp2, ZN); tmp3->sym = c; return nn(ZN, EQ, tmp1, tmp3); #if 0 .---------------EQ-------. / \ 'p' -sym-> _p 'q' -sym-> c (label name) / / '?' -sym-> a (proctype) NAME -sym-> a (proctype name) / b (pid expr) #endif } Lextok * rem_var(Symbol *a, Lextok *b, Symbol *c, Lextok *ndx) { Lextok *tmp1; has_remote++; has_remvar++; dataflow = 0; /* turn off dead variable resets 4.2.5 */ tmp1 = nn(ZN, '?', b, ZN); tmp1->sym = a; tmp1 = nn(ZN, 'p', tmp1, ndx); tmp1->sym = c; return tmp1; #if 0 cannot refer to struct elements only to scalars and arrays 'p' -sym-> c (variable name) / \______ possible arrayindex on c / '?' -sym-> a (proctype) / b (pid expr) #endif } void explain(int n) { FILE *fd = stdout; switch (n) { default: if (n > 0 && n < 256) fprintf(fd, "'%c' = ", n); fprintf(fd, "%d", n); break; case '\b': fprintf(fd, "\\b"); break; case '\t': fprintf(fd, "\\t"); break; case '\f': fprintf(fd, "\\f"); break; case '\n': fprintf(fd, "\\n"); break; case '\r': fprintf(fd, "\\r"); break; case 'c': fprintf(fd, "condition"); break; case 's': fprintf(fd, "send"); break; case 'r': fprintf(fd, "recv"); break; case 'R': fprintf(fd, "recv poll %s", Operator); break; case '@': fprintf(fd, "@"); break; case '?': fprintf(fd, "(x->y:z)"); break; #if 1 case NEXT: fprintf(fd, "X"); break; case ALWAYS: fprintf(fd, "[]"); break; case EVENTUALLY: fprintf(fd, "<>"); break; case IMPLIES: fprintf(fd, "->"); break; case EQUIV: fprintf(fd, "<->"); break; case UNTIL: fprintf(fd, "U"); break; case WEAK_UNTIL: fprintf(fd, "W"); break; case IN: fprintf(fd, "%sin", Keyword); break; #endif case ACTIVE: fprintf(fd, "%sactive", Keyword); break; case AND: fprintf(fd, "%s&&", Operator); break; case ASGN: fprintf(fd, "%s=", Operator); break; case ASSERT: fprintf(fd, "%sassert", Function); break; case ATOMIC: fprintf(fd, "%satomic", Keyword); break; case BREAK: fprintf(fd, "%sbreak", Keyword); break; case C_CODE: fprintf(fd, "%sc_code", Keyword); break; case C_DECL: fprintf(fd, "%sc_decl", Keyword); break; case C_EXPR: fprintf(fd, "%sc_expr", Keyword); break; case C_STATE: fprintf(fd, "%sc_state",Keyword); break; case C_TRACK: fprintf(fd, "%sc_track",Keyword); break; case CLAIM: fprintf(fd, "%snever", Keyword); break; case CONST: fprintf(fd, "a constant"); break; case DECR: fprintf(fd, "%s--", Operator); break; case D_STEP: fprintf(fd, "%sd_step", Keyword); break; case D_PROCTYPE: fprintf(fd, "%sd_proctype", Keyword); break; case DO: fprintf(fd, "%sdo", Keyword); break; case DOT: fprintf(fd, "."); break; case ELSE: fprintf(fd, "%selse", Keyword); break; case EMPTY: fprintf(fd, "%sempty", Function); break; case ENABLED: fprintf(fd, "%senabled",Function); break; case EQ: fprintf(fd, "%s==", Operator); break; case EVAL: fprintf(fd, "%seval", Function); break; case FI: fprintf(fd, "%sfi", Keyword); break; case FULL: fprintf(fd, "%sfull", Function); break; case GE: fprintf(fd, "%s>=", Operator); break; case GET_P: fprintf(fd, "%sget_priority",Function); break; case GOTO: fprintf(fd, "%sgoto", Keyword); break; case GT: fprintf(fd, "%s>", Operator); break; case HIDDEN: fprintf(fd, "%shidden", Keyword); break; case IF: fprintf(fd, "%sif", Keyword); break; case INCR: fprintf(fd, "%s++", Operator); break; case INAME: fprintf(fd, "inline name"); break; case INLINE: fprintf(fd, "%sinline", Keyword); break; case INIT: fprintf(fd, "%sinit", Keyword); break; case ISLOCAL: fprintf(fd, "%slocal", Keyword); break; case LABEL: fprintf(fd, "a label-name"); break; case LE: fprintf(fd, "%s<=", Operator); break; case LEN: fprintf(fd, "%slen", Function); break; case LSHIFT: fprintf(fd, "%s<<", Operator); break; case LT: fprintf(fd, "%s<", Operator); break; case MTYPE: fprintf(fd, "%smtype", Keyword); break; case NAME: fprintf(fd, "an identifier"); break; case NE: fprintf(fd, "%s!=", Operator); break; case NEG: fprintf(fd, "%s! (not)",Operator); break; case NEMPTY: fprintf(fd, "%snempty", Function); break; case NFULL: fprintf(fd, "%snfull", Function); break; case NON_ATOMIC: fprintf(fd, "sub-sequence"); break; case NONPROGRESS: fprintf(fd, "%snp_", Function); break; case OD: fprintf(fd, "%sod", Keyword); break; case OF: fprintf(fd, "%sof", Keyword); break; case OR: fprintf(fd, "%s||", Operator); break; case O_SND: fprintf(fd, "%s!!", Operator); break; case PC_VAL: fprintf(fd, "%spc_value",Function); break; case PNAME: fprintf(fd, "process name"); break; case PRINT: fprintf(fd, "%sprintf", Function); break; case PRINTM: fprintf(fd, "%sprintm", Function); break; case PRIORITY: fprintf(fd, "%spriority", Keyword); break; case PROCTYPE: fprintf(fd, "%sproctype",Keyword); break; case PROVIDED: fprintf(fd, "%sprovided",Keyword); break; case RCV: fprintf(fd, "%s?", Operator); break; case R_RCV: fprintf(fd, "%s??", Operator); break; case RSHIFT: fprintf(fd, "%s>>", Operator); break; case RUN: fprintf(fd, "%srun", Operator); break; case SEP: fprintf(fd, "token: ::"); break; case SEMI: fprintf(fd, ";"); break; case ARROW: fprintf(fd, "->"); break; case SET_P: fprintf(fd, "%sset_priority",Function); break; case SHOW: fprintf(fd, "%sshow", Keyword); break; case SND: fprintf(fd, "%s!", Operator); break; case STRING: fprintf(fd, "a string"); break; case TRACE: fprintf(fd, "%strace", Keyword); break; case TIMEOUT: fprintf(fd, "%stimeout",Keyword); break; case TYPE: fprintf(fd, "data typename"); break; case TYPEDEF: fprintf(fd, "%stypedef",Keyword); break; case XU: fprintf(fd, "%sx[rs]", Keyword); break; case UMIN: fprintf(fd, "%s- (unary minus)", Operator); break; case UNAME: fprintf(fd, "a typename"); break; case UNLESS: fprintf(fd, "%sunless", Keyword); break; } } Spin/Src6.4.5/mesg.c0000664000175100017510000004206612641605057012010 0ustar ghgh/***** spin: mesg.c *****/ /* * This file is part of the public release of Spin. It is subject to the * terms in the LICENSE file that is included in this source directory. * Tool documentation is available at http://spinroot.com */ #include #include "spin.h" #include "y.tab.h" #ifndef MAXQ #define MAXQ 2500 /* default max # queues */ #endif extern RunList *X; extern Symbol *Fname; extern Lextok *Mtype; extern int verbose, TstOnly, s_trail, analyze, columns; extern int lineno, depth, xspin, m_loss, jumpsteps; extern int nproc, nstop; extern short Have_claim; QH *qh; Queue *qtab = (Queue *) 0; /* linked list of queues */ Queue *ltab[MAXQ]; /* linear list of queues */ int nqs = 0, firstrow = 1, has_stdin = 0; char Buf[4096]; static Lextok *n_rem = (Lextok *) 0; static Queue *q_rem = (Queue *) 0; static int a_rcv(Queue *, Lextok *, int); static int a_snd(Queue *, Lextok *); static int sa_snd(Queue *, Lextok *); static int s_snd(Queue *, Lextok *); extern void sr_buf(int, int); extern void sr_mesg(FILE *, int, int); extern void putarrow(int, int); static void sr_talk(Lextok *, int, char *, char *, int, Queue *); int cnt_mpars(Lextok *n) { Lextok *m; int i=0; for (m = n; m; m = m->rgt) i += Cnt_flds(m); return i; } int qmake(Symbol *s) { Lextok *m; Queue *q; int i; if (!s->ini) return 0; if (nqs >= MAXQ) { lineno = s->ini->ln; Fname = s->ini->fn; fatal("too many queues (%s)", s->name); } if (analyze && nqs >= 255) { fatal("too many channel types", (char *)0); } if (s->ini->ntyp != CHAN) return eval(s->ini); q = (Queue *) emalloc(sizeof(Queue)); q->qid = (short) ++nqs; q->nslots = s->ini->val; q->nflds = cnt_mpars(s->ini->rgt); q->setat = depth; i = max(1, q->nslots); /* 0-slot qs get 1 slot minimum */ q->contents = (int *) emalloc(q->nflds*i*sizeof(int)); q->fld_width = (int *) emalloc(q->nflds*sizeof(int)); q->stepnr = (int *) emalloc(i*sizeof(int)); for (m = s->ini->rgt, i = 0; m; m = m->rgt) { if (m->sym && m->ntyp == STRUCT) i = Width_set(q->fld_width, i, getuname(m->sym)); else q->fld_width[i++] = m->ntyp; } q->nxt = qtab; qtab = q; ltab[q->qid-1] = q; return q->qid; } int qfull(Lextok *n) { int whichq = eval(n->lft)-1; if (whichq < MAXQ && whichq >= 0 && ltab[whichq]) return (ltab[whichq]->qlen >= ltab[whichq]->nslots); return 0; } int qlen(Lextok *n) { int whichq = eval(n->lft)-1; if (whichq < MAXQ && whichq >= 0 && ltab[whichq]) return ltab[whichq]->qlen; return 0; } int q_is_sync(Lextok *n) { int whichq = eval(n->lft)-1; if (whichq < MAXQ && whichq >= 0 && ltab[whichq]) return (ltab[whichq]->nslots == 0); return 0; } int qsend(Lextok *n) { int whichq = eval(n->lft)-1; if (whichq == -1) { printf("Error: sending to an uninitialized chan\n"); /* whichq = 0; */ return 0; } if (whichq < MAXQ && whichq >= 0 && ltab[whichq]) { ltab[whichq]->setat = depth; if (ltab[whichq]->nslots > 0) return a_snd(ltab[whichq], n); else return s_snd(ltab[whichq], n); } return 0; } #ifndef PC #include static struct termios initial_settings, new_settings; void peek_ch_init(void) { tcgetattr(0,&initial_settings); new_settings = initial_settings; new_settings.c_lflag &= ~ICANON; new_settings.c_lflag &= ~ECHO; new_settings.c_lflag &= ~ISIG; new_settings.c_cc[VMIN] = 0; new_settings.c_cc[VTIME] = 0; } int peek_ch(void) { int n; has_stdin = 1; tcsetattr(0, TCSANOW, &new_settings); n = getchar(); tcsetattr(0, TCSANOW, &initial_settings); return n; } #endif int qrecv(Lextok *n, int full) { int whichq = eval(n->lft)-1; if (whichq == -1) { if (n->sym && !strcmp(n->sym->name, "STDIN")) { Lextok *m; #ifndef PC static int did_once = 0; if (!did_once) /* 6.2.4 */ { peek_ch_init(); did_once = 1; } #endif if (TstOnly) return 1; for (m = n->rgt; m; m = m->rgt) if (m->lft->ntyp != CONST && m->lft->ntyp != EVAL) { #ifdef PC int c = getchar(); #else int c = peek_ch(); /* 6.2.4, was getchar(); */ #endif if (c == 27 || c == 3) /* escape or control-c */ { printf("quit\n"); exit(0); } /* else: non-blocking */ if (c == EOF) return 0; /* no char available */ (void) setval(m->lft, c); } else { fatal("invalid use of STDIN", (char *)0); } return 1; } printf("Error: receiving from an uninitialized chan %s\n", n->sym?n->sym->name:""); /* whichq = 0; */ return 0; } if (whichq < MAXQ && whichq >= 0 && ltab[whichq]) { ltab[whichq]->setat = depth; return a_rcv(ltab[whichq], n, full); } return 0; } static int sa_snd(Queue *q, Lextok *n) /* sorted asynchronous */ { Lextok *m; int i, j, k; int New, Old; for (i = 0; i < q->qlen; i++) for (j = 0, m = n->rgt; m && j < q->nflds; m = m->rgt, j++) { New = cast_val(q->fld_width[j], eval(m->lft), 0); Old = q->contents[i*q->nflds+j]; if (New == Old) continue; if (New > Old) break; /* inner loop */ goto found; /* New < Old */ } found: for (j = q->qlen-1; j >= i; j--) for (k = 0; k < q->nflds; k++) { q->contents[(j+1)*q->nflds+k] = q->contents[j*q->nflds+k]; /* shift up */ if (k == 0) q->stepnr[j+1] = q->stepnr[j]; } return i*q->nflds; /* new q offset */ } void typ_ck(int ft, int at, char *s) { if ((verbose&32) && ft != at && (ft == CHAN || at == CHAN) && (at != PREDEF || strcmp(s, "recv") != 0)) { char buf[128], tag1[64], tag2[64]; (void) sputtype(tag1, ft); (void) sputtype(tag2, at); sprintf(buf, "type-clash in %s, (%s<-> %s)", s, tag1, tag2); non_fatal("%s", buf); } } static int a_snd(Queue *q, Lextok *n) { Lextok *m; int i = q->qlen*q->nflds; /* q offset */ int j = 0; /* q field# */ if (q->nslots > 0 && q->qlen >= q->nslots) return m_loss; /* q is full */ if (TstOnly) return 1; if (n->val) i = sa_snd(q, n); /* sorted insert */ q->stepnr[i/q->nflds] = depth; for (m = n->rgt; m && j < q->nflds; m = m->rgt, j++) { int New = eval(m->lft); q->contents[i+j] = cast_val(q->fld_width[j], New, 0); if ((verbose&16) && depth >= jumpsteps) sr_talk(n, New, "Send ", "->", j, q); typ_ck(q->fld_width[j], Sym_typ(m->lft), "send"); } if ((verbose&16) && depth >= jumpsteps) { for (i = j; i < q->nflds; i++) sr_talk(n, 0, "Send ", "->", i, q); if (j < q->nflds) printf("%3d: warning: missing params in send\n", depth); if (m) printf("%3d: warning: too many params in send\n", depth); } q->qlen++; return 1; } static int a_rcv(Queue *q, Lextok *n, int full) { Lextok *m; int i=0, oi, j, k; extern int Rvous; if (q->qlen == 0) return 0; /* q is empty */ try_slot: /* test executability */ for (m = n->rgt, j=0; m && j < q->nflds; m = m->rgt, j++) if ((m->lft->ntyp == CONST && q->contents[i*q->nflds+j] != m->lft->val) || (m->lft->ntyp == EVAL && q->contents[i*q->nflds+j] != eval(m->lft->lft))) { if (n->val == 0 /* fifo recv */ || n->val == 2 /* fifo poll */ || ++i >= q->qlen) /* last slot */ return 0; /* no match */ goto try_slot; } if (TstOnly) return 1; if (verbose&8) { if (j < q->nflds) printf("%3d: warning: missing params in next recv\n", depth); else if (m) printf("%3d: warning: too many params in next recv\n", depth); } /* set the fields */ if (Rvous) { n_rem = n; q_rem = q; } oi = q->stepnr[i]; for (m = n->rgt, j = 0; m && j < q->nflds; m = m->rgt, j++) { if (columns && !full) /* was columns == 1 */ continue; if ((verbose&8) && !Rvous && depth >= jumpsteps) { sr_talk(n, q->contents[i*q->nflds+j], (full && n->val < 2)?"Recv ":"[Recv] ", "<-", j, q); } if (!full) continue; /* test */ if (m && m->lft->ntyp != CONST && m->lft->ntyp != EVAL) { (void) setval(m->lft, q->contents[i*q->nflds+j]); typ_ck(q->fld_width[j], Sym_typ(m->lft), "recv"); } if (n->val < 2) /* not a poll */ for (k = i; k < q->qlen-1; k++) { q->contents[k*q->nflds+j] = q->contents[(k+1)*q->nflds+j]; if (j == 0) q->stepnr[k] = q->stepnr[k+1]; } } if ((!columns || full) && (verbose&8) && !Rvous && depth >= jumpsteps) for (i = j; i < q->nflds; i++) { sr_talk(n, 0, (full && n->val < 2)?"Recv ":"[Recv] ", "<-", i, q); } if (columns == 2 && full && !Rvous && depth >= jumpsteps) putarrow(oi, depth); if (full && n->val < 2) q->qlen--; return 1; } static int s_snd(Queue *q, Lextok *n) { Lextok *m; RunList *rX, *sX = X; /* rX=recvr, sX=sendr */ int i, j = 0; /* q field# */ for (m = n->rgt; m && j < q->nflds; m = m->rgt, j++) { q->contents[j] = cast_val(q->fld_width[j], eval(m->lft), 0); typ_ck(q->fld_width[j], Sym_typ(m->lft), "rv-send"); } q->qlen = 1; if (!complete_rendez()) { q->qlen = 0; return 0; } if (TstOnly) { q->qlen = 0; return 1; } q->stepnr[0] = depth; if ((verbose&16) && depth >= jumpsteps) { m = n->rgt; rX = X; X = sX; for (j = 0; m && j < q->nflds; m = m->rgt, j++) sr_talk(n, eval(m->lft), "Sent ", "->", j, q); for (i = j; i < q->nflds; i++) sr_talk(n, 0, "Sent ", "->", i, q); if (j < q->nflds) printf("%3d: warning: missing params in rv-send\n", depth); else if (m) printf("%3d: warning: too many params in rv-send\n", depth); X = rX; /* restore receiver's context */ if (!s_trail) { if (!n_rem || !q_rem) fatal("cannot happen, s_snd", (char *) 0); m = n_rem->rgt; for (j = 0; m && j < q->nflds; m = m->rgt, j++) { if (m->lft->ntyp != NAME || strcmp(m->lft->sym->name, "_") != 0) i = eval(m->lft); else i = 0; if (verbose&8) sr_talk(n_rem,i,"Recv ","<-",j,q_rem); } if (verbose&8) for (i = j; i < q->nflds; i++) sr_talk(n_rem, 0, "Recv ", "<-", j, q_rem); if (columns == 2) putarrow(depth, depth); } n_rem = (Lextok *) 0; q_rem = (Queue *) 0; } return 1; } static void channm(Lextok *n) { char lbuf[512]; if (n->sym->type == CHAN) strcat(Buf, n->sym->name); else if (n->sym->type == NAME) strcat(Buf, lookup(n->sym->name)->name); else if (n->sym->type == STRUCT) { Symbol *r = n->sym; if (r->context) { r = findloc(r); if (!r) { strcat(Buf, "*?*"); return; } } ini_struct(r); printf("%s", r->name); strcpy(lbuf, ""); struct_name(n->lft, r, 1, lbuf); strcat(Buf, lbuf); } else strcat(Buf, "-"); if (n->lft->lft) { sprintf(lbuf, "[%d]", eval(n->lft->lft)); strcat(Buf, lbuf); } } static void difcolumns(Lextok *n, char *tr, int v, int j, Queue *q) { extern int pno; if (j == 0) { Buf[0] = '\0'; channm(n); strcat(Buf, (strncmp(tr, "Sen", 3))?"?":"!"); } else strcat(Buf, ","); if (tr[0] == '[') strcat(Buf, "["); sr_buf(v, q->fld_width[j] == MTYPE); if (j == q->nflds - 1) { int cnr; if (s_trail) { cnr = pno; } else { cnr = X?X->pid - Have_claim:0; } if (tr[0] == '[') strcat(Buf, "]"); pstext(cnr, Buf); } } static void docolumns(Lextok *n, char *tr, int v, int j, Queue *q) { int i; if (firstrow) { printf("q\\p"); for (i = 0; i < nproc-nstop - Have_claim; i++) printf(" %3d", i); printf("\n"); firstrow = 0; } if (j == 0) { printf("%3d", q->qid); if (X) for (i = 0; i < X->pid - Have_claim; i++) printf(" ."); printf(" "); Buf[0] = '\0'; channm(n); printf("%s%c", Buf, (strncmp(tr, "Sen", 3))?'?':'!'); } else printf(","); if (tr[0] == '[') printf("["); sr_mesg(stdout, v, q->fld_width[j] == MTYPE); if (j == q->nflds - 1) { if (tr[0] == '[') printf("]"); printf("\n"); } } void qhide(int q) { QH *p = (QH *) emalloc(sizeof(QH)); p->n = q; p->nxt = qh; qh = p; } int qishidden(int q) { QH *p; for (p = qh; p; p = p->nxt) if (p->n == q) return 1; return 0; } static void sr_talk(Lextok *n, int v, char *tr, char *a, int j, Queue *q) { char s[128]; if (qishidden(eval(n->lft))) return; if (columns) { if (columns == 2) difcolumns(n, tr, v, j, q); else docolumns(n, tr, v, j, q); return; } if (xspin) { if ((verbose&4) && tr[0] != '[') sprintf(s, "(state -)\t[values: %d", eval(n->lft)); else sprintf(s, "(state -)\t[%d", eval(n->lft)); if (strncmp(tr, "Sen", 3) == 0) strcat(s, "!"); else strcat(s, "?"); } else { strcpy(s, tr); } if (j == 0) { char snm[128]; whoruns(1); { char *ptr = n->fn->name; char *qtr = snm; while (*ptr != '\0') { if (*ptr != '\"') { *qtr++ = *ptr; } ptr++; } *qtr = '\0'; printf("%s:%d %s", snm, n->ln, s); } } else printf(","); sr_mesg(stdout, v, q->fld_width[j] == MTYPE); if (j == q->nflds - 1) { if (xspin) { printf("]\n"); if (!(verbose&4)) printf("\n"); return; } printf("\t%s queue %d (", a, eval(n->lft)); Buf[0] = '\0'; channm(n); printf("%s)\n", Buf); } fflush(stdout); } void sr_buf(int v, int j) { int cnt = 1; Lextok *n; char lbuf[512]; for (n = Mtype; n && j; n = n->rgt, cnt++) if (cnt == v) { if(strlen(n->lft->sym->name) >= sizeof(lbuf)) { non_fatal("mtype name %s too long", n->lft->sym->name); break; } sprintf(lbuf, "%s", n->lft->sym->name); strcat(Buf, lbuf); return; } sprintf(lbuf, "%d", v); strcat(Buf, lbuf); } void sr_mesg(FILE *fd, int v, int j) { Buf[0] ='\0'; sr_buf(v, j); #if 1 fprintf(fd, Buf, (char *) 0); /* prevent compiler warning */ #else fprintf(fd, Buf); #endif } void doq(Symbol *s, int n, RunList *r) { Queue *q; int j, k; if (!s->val) /* uninitialized queue */ return; for (q = qtab; q; q = q->nxt) if (q->qid == s->val[n]) { if (xspin > 0 && (verbose&4) && q->setat < depth) continue; if (q->nslots == 0) continue; /* rv q always empty */ #if 0 if (q->qlen == 0) /* new 7/10 -- dont show if queue is empty */ { continue; } #endif printf("\t\tqueue %d (", q->qid); if (r) printf("%s(%d):", r->n->name, r->pid - Have_claim); if (s->nel > 1 || s->isarray) printf("%s[%d]): ", s->name, n); else printf("%s): ", s->name); for (k = 0; k < q->qlen; k++) { printf("["); for (j = 0; j < q->nflds; j++) { if (j > 0) printf(","); sr_mesg(stdout, q->contents[k*q->nflds+j], q->fld_width[j] == MTYPE); } printf("]"); } printf("\n"); break; } } void nochan_manip(Lextok *p, Lextok *n, int d) { int e = 1; if (d == 0 && p->sym && p->sym->type == CHAN) { setaccess(p->sym, ZS, 0, 'L'); if (n && n->ntyp == CONST) fatal("invalid asgn to chan", (char *) 0); if (n && n->sym && n->sym->type == CHAN) { setaccess(n->sym, ZS, 0, 'V'); return; } } /* ok on the rhs of an assignment: */ if (!n || n->ntyp == LEN || n->ntyp == RUN || n->ntyp == FULL || n->ntyp == NFULL || n->ntyp == EMPTY || n->ntyp == NEMPTY) return; if (n->sym && n->sym->type == CHAN) { if (d == 1) fatal("invalid use of chan name", (char *) 0); else setaccess(n->sym, ZS, 0, 'V'); } if (n->ntyp == NAME || n->ntyp == '.') e = 0; /* array index or struct element */ nochan_manip(p, n->lft, e); nochan_manip(p, n->rgt, 1); } typedef struct BaseName { char *str; int cnt; struct BaseName *nxt; } BaseName; static BaseName *bsn; void newbasename(char *s) { BaseName *b; /* printf("+++++++++%s\n", s); */ for (b = bsn; b; b = b->nxt) if (strcmp(b->str, s) == 0) { b->cnt++; return; } b = (BaseName *) emalloc(sizeof(BaseName)); b->str = emalloc(strlen(s)+1); b->cnt = 1; strcpy(b->str, s); b->nxt = bsn; bsn = b; } void delbasename(char *s) { BaseName *b, *prv = (BaseName *) 0; for (b = bsn; b; prv = b, b = b->nxt) { if (strcmp(b->str, s) == 0) { b->cnt--; if (b->cnt == 0) { if (prv) { prv->nxt = b->nxt; } else { bsn = b->nxt; } } /* printf("---------%s\n", s); */ break; } } } void checkindex(char *s, char *t) { BaseName *b; /* printf("xxx Check %s (%s)\n", s, t); */ for (b = bsn; b; b = b->nxt) { /* printf(" %s\n", b->str); */ if (strcmp(b->str, s) == 0) { non_fatal("do not index an array with itself (%s)", t); break; } } } void scan_tree(Lextok *t, char *mn, char *mx) { char sv[512]; char tmp[32]; int oln = lineno; if (!t) return; lineno = t->ln; if (t->ntyp == NAME) { strcat(mn, t->sym->name); strcat(mx, t->sym->name); if (t->lft) /* array index */ { strcat(mn, "[]"); newbasename(mn); strcpy(sv, mn); /* save */ strcpy(mn, ""); /* clear */ strcat(mx, "["); scan_tree(t->lft, mn, mx); /* index */ strcat(mx, "]"); checkindex(mn, mx); /* match against basenames */ strcpy(mn, sv); /* restore */ delbasename(mn); } if (t->rgt) /* structure element */ { scan_tree(t->rgt, mn, mx); } } else if (t->ntyp == CONST) { strcat(mn, "1"); /* really: t->val */ sprintf(tmp, "%d", t->val); strcat(mx, tmp); } else if (t->ntyp == '.') { strcat(mn, "."); strcat(mx, "."); scan_tree(t->lft, mn, mx); } else { strcat(mn, "??"); strcat(mx, "??"); } lineno = oln; } void no_nested_array_refs(Lextok *n) /* a [ a[1] ] with a[1] = 1, causes trouble in pan.b */ { char mn[512]; char mx[512]; /* printf("==================================ZAP\n"); */ bsn = (BaseName *) 0; /* start new list */ strcpy(mn, ""); strcpy(mx, ""); scan_tree(n, mn, mx); /* printf("==> %s\n", mn); */ } void no_internals(Lextok *n) { char *sp; if (!n->sym || !n->sym->name) return; sp = n->sym->name; if ((strlen(sp) == strlen("_nr_pr") && strcmp(sp, "_nr_pr") == 0) || (strlen(sp) == strlen("_pid") && strcmp(sp, "_pid") == 0) || (strlen(sp) == strlen("_p") && strcmp(sp, "_p") == 0)) { fatal("invalid assignment to %s", sp); } no_nested_array_refs(n); } Spin/Src6.4.5/pangen4.h0000664000175100017510000004426412641605057012420 0ustar ghgh/***** spin: pangen4.h *****/ /* * This file is part of the public release of Spin. It is subject to the * terms in the LICENSE file that is included in this source directory. * Tool documentation is available at http://spinroot.com * * The DFA code below was written by Anuj Puri and Gerard J. Holzmann in * May 1997, and was inspired by earlier work on data compression using * sharing tree data structures and graph-encoded sets by J-Ch. Gregoire * (INRS Telecom, Quebec, Canada) and D.Zampunieris (Univ.Namur, Belgium) * The splay routine code included here is based on the public domain * version written by D. Sleator in 1992. */ static const char *Dfa[] = { "#ifdef MA", #if 0 "/*", "#include ", "#define uchar unsigned char", "*/", "#define ulong unsigned long", "#define ushort unsigned short", "", #endif "#define TWIDTH 256", "#define HASH(y,n) (n)*(((long)y))", "#define INRANGE(e,h) ((h>=e->From && h<=e->To)||(e->s==1 && e->S==h))", "", "extern char *emalloc(unsigned long); /* imported routine */", "extern void dfa_init(ushort); /* 4 exported routines */", "extern int dfa_member(ulong);", "extern int dfa_store(uchar *);", "extern void dfa_stats(void);", "", "typedef struct Edge {", " uchar From, To; /* max range 0..255 */", " uchar s, S; /* if s=1, S is singleton */", " struct Vertex *Dst;", " struct Edge *Nxt;", "} Edge;", "", "typedef struct Vertex {", " ulong key, num; /* key for splay tree, nr incoming edges */", " uchar from[2], to[2]; /* in-node predefined edge info */", " struct Vertex *dst[2];/* most nodes have 2 or more edges */", " struct Edge *Succ; /* in case there are more edges */", " struct Vertex *lnk, *left, *right; /* splay tree plumbing */", "} Vertex;", "", "static Edge *free_edges;", "static Vertex *free_vertices;", "static Vertex **layers; /* one splay tree of nodes per layer */", "static Vertex **path; /* run of word in the DFA */", "static Vertex *R, *F, *NF; /* Root, Final, Not-Final */", "static uchar *word, *lastword;/* string, and last string inserted */", "static int dfa_depth, iv=0, nv=0, pfrst=0, Tally;", "", "static void insert_it(Vertex *, int); /* splay-tree code */", "static void delete_it(Vertex *, int);", "static Vertex *find_it(Vertex *, Vertex *, uchar, int);", "", "static void", "recyc_edges(Edge *e)", "{", " if (!e) return;", " recyc_edges(e->Nxt);", " e->Nxt = free_edges;", " free_edges = e;", "}", "", "static Edge *", "new_edge(Vertex *dst)", "{ Edge *e;", "", " if (free_edges)", " { e = free_edges;", " free_edges = e->Nxt;", " e->From = e->To = e->s = e->S = 0;", " e->Nxt = (Edge *) 0;", " } else", " e = (Edge *) emalloc(sizeof(Edge));", " e->Dst = dst;", "", " return e;", "}", "", "static void", "recyc_vertex(Vertex *v)", "{", " recyc_edges(v->Succ);", " v->Succ = (Edge *) free_vertices;", " free_vertices = v;", " nr_states--;", "}", "", "static Vertex *", "new_vertex(void)", "{ Vertex *v;", "", " if (free_vertices)", " { v = free_vertices;", " free_vertices = (Vertex *) v->Succ;", " v->Succ = (Edge *) 0;", " v->num = 0;", " } else", " v = (Vertex *) emalloc(sizeof(Vertex));", "", " nr_states++;", " return v; ", "}", "", "static Vertex *", "allDelta(Vertex *v, int n)", "{ Vertex *dst = new_vertex();", "", " v->from[0] = 0;", " v->to[0] = 255;", " v->dst[0] = dst;", " dst->num = 256;", " insert_it(v, n);", " return dst;", "}", "", "static void", "insert_edge(Vertex *v, Edge *e)", "{ /* put new edge first */", " if (!v->dst[0])", " { v->dst[0] = e->Dst;", " v->from[0] = e->From;", " v->to[0] = e->To;", " recyc_edges(e);", " return;", " }", " if (!v->dst[1])", " { v->from[1] = v->from[0]; v->from[0] = e->From;", " v->to[1] = v->to[0]; v->to[0] = e->To;", " v->dst[1] = v->dst[0]; v->dst[0] = e->Dst;", " recyc_edges(e);", " return;", " } /* shift */", " { int f = v->from[1];", " int t = v->to[1];", " Vertex *d = v->dst[1];", " v->from[1] = v->from[0]; v->from[0] = e->From;", " v->to[1] = v->to[0]; v->to[0] = e->To;", " v->dst[1] = v->dst[0]; v->dst[0] = e->Dst;", " e->From = f;", " e->To = t;", " e->Dst = d;", " }", " e->Nxt = v->Succ;", " v->Succ = e;", "}", "", "static void", "copyRecursive(Vertex *v, Edge *e)", "{ Edge *f;", " if (e->Nxt) copyRecursive(v, e->Nxt);", " f = new_edge(e->Dst);", " f->From = e->From;", " f->To = e->To;", " f->s = e->s;", " f->S = e->S;", " f->Nxt = v->Succ;", " v->Succ = f;", "}", "", "static void", "copyEdges(Vertex *to, Vertex *from)", "{ int i;", " for (i = 0; i < 2; i++)", " { to->from[i] = from->from[i];", " to->to[i] = from->to[i];", " to->dst[i] = from->dst[i];", " }", " if (from->Succ) copyRecursive(to, from->Succ);", "}", "", "static Edge *", "cacheDelta(Vertex *v, int h, int first)", "{ static Edge *ov, tmp; int i;", "", " if (!first && INRANGE(ov,h))", " return ov; /* intercepts about 10%% */", " for (i = 0; i < 2; i++)", " if (v->dst[i] && h >= v->from[i] && h <= v->to[i])", " { tmp.From = v->from[i];", " tmp.To = v->to[i];", " tmp.Dst = v->dst[i];", " tmp.s = tmp.S = 0;", " ov = &tmp;", " return ov;", " }", " for (ov = v->Succ; ov; ov = ov->Nxt)", " if (INRANGE(ov,h)) return ov;", "", " Uerror(\"cannot get here, cacheDelta\");", " return (Edge *) 0;", "}", "", "static Vertex *", "Delta(Vertex *v, int h) /* v->delta[h] */", "{ Edge *e;", "", " if (v->dst[0] && h >= v->from[0] && h <= v->to[0])", " return v->dst[0]; /* oldest edge */", " if (v->dst[1] && h >= v->from[1] && h <= v->to[1])", " return v->dst[1];", " for (e = v->Succ; e; e = e->Nxt)", " if (INRANGE(e,h))", " return e->Dst;", " Uerror(\"cannot happen Delta\");", " return (Vertex *) 0;", "}", "", "static void", "numDelta(Vertex *v, int d)", "{ Edge *e;", " ulong cnt;", " int i;", "", " for (i = 0; i < 2; i++)", " if (v->dst[i])", " { cnt = v->dst[i]->num + d*(1 + v->to[i] - v->from[i]);", " if (d == 1 && cnt < v->dst[i]->num) goto bad;", " v->dst[i]->num = cnt;", " }", " for (e = v->Succ; e; e = e->Nxt)", " { cnt = e->Dst->num + d*(1 + e->To - e->From + e->s);", " if (d == 1 && cnt < e->Dst->num)", "bad: Uerror(\"too many incoming edges\");", " e->Dst->num = cnt;", " }", "}", "", "static void", "setDelta(Vertex *v, int h, Vertex *newdst) /* v->delta[h] = newdst; */", "{ Edge *e, *f = (Edge *) 0, *g;", " int i;", "", " /* remove the old entry, if there */", " for (i = 0; i < 2; i++)", " if (v->dst[i] && h >= v->from[i] && h <= v->to[i])", " { if (h == v->from[i])", " { if (h == v->to[i])", " { v->dst[i] = (Vertex *) 0;", " v->from[i] = v->to[i] = 0;", " } else", " v->from[i]++;", " } else if (h == v->to[i])", " { v->to[i]--;", " } else", " { g = new_edge(v->dst[i]);/* same dst */", " g->From = v->from[i];", " g->To = h-1; /* left half */", " v->from[i] = h+1; /* right half */", " insert_edge(v, g);", " }", " goto part2;", " }", " for (e = v->Succ; e; f = e, e = e->Nxt)", " { if (e->s == 1 && e->S == h)", " { e->s = e->S = 0;", " goto rem_tst;", " }", " if (h >= e->From && h <= e->To)", " { if (h == e->From)", " { if (h == e->To)", " { if (e->s)", " { e->From = e->To = e->S;", " e->s = 0;", " break;", " } else", " goto rem_do;", " } else", " e->From++;", " } else if (h == e->To)", " { e->To--;", " } else /* split */", " { g = new_edge(e->Dst); /* same dst */", " g->From = e->From;", " g->To = h-1; /* g=left half */", " e->From = h+1; /* e=right half */", " g->Nxt = e->Nxt; /* insert g */", " e->Nxt = g; /* behind e */", " break; /* done */", " }", "", "rem_tst: if (e->From > e->To)", " { if (e->s == 0) {", "rem_do: if (f)", " f->Nxt = e->Nxt;", " else", " v->Succ = e->Nxt;", " e->Nxt = (Edge *) 0;", " recyc_edges(e);", " } else", " { e->From = e->To = e->S;", " e->s = 0;", " } }", " break;", " } }", "part2:", " /* check if newdst is already there */", " for (i = 0; i < 2; i++)", " if (v->dst[i] == newdst)", " { if (h+1 == (int) v->from[i])", " { v->from[i] = h;", " return;", " }", " if (h == (int) v->to[i]+1)", " { v->to[i] = h;", " return;", " } }", " for (e = v->Succ; e; e = e->Nxt)", " { if (e->Dst == newdst)", " { if (h+1 == (int) e->From)", " { e->From = h;", " if (e->s == 1 && e->S+1 == e->From)", " { e->From = e->S;", " e->s = e->S = 0;", " }", " return;", " }", " if (h == (int) e->To+1)", " { e->To = h;", " if (e->s == 1 && e->S == e->To+1)", " { e->To = e->S;", " e->s = e->S = 0;", " }", " return;", " }", " if (e->s == 0)", " { e->s = 1;", " e->S = h;", " return;", " } } }", " /* add as a new edge */", " e = new_edge(newdst);", " e->From = e->To = h;", " insert_edge(v, e);", "}", "", "static ulong", "cheap_key(Vertex *v)", "{ ulong vk2 = 0;", "", " if (v->dst[0])", " { vk2 = (ulong) v->dst[0];", " if ((ulong) v->dst[1] > vk2)", " vk2 = (ulong) v->dst[1];", " } else if (v->dst[1])", " vk2 = (ulong) v->dst[1]; ", " if (v->Succ)", " { Edge *e;", " for (e = v->Succ; e; e = e->Nxt)", " if ((ulong) e->Dst > vk2)", " vk2 = (ulong) e->Dst;", " }", " Tally = (vk2>>2)&(TWIDTH-1);", " return v->key;", "}", "", "static ulong", "mk_key(Vertex *v) /* not sensitive to order */", "{ ulong m = 0, vk2 = 0;", " Edge *e;", "", " if (v->dst[0])", " { m += HASH(v->dst[0], v->to[0] - v->from[0] + 1);", " vk2 = (ulong) v->dst[0]; ", " }", " if (v->dst[1])", " { m += HASH(v->dst[1], v->to[1] - v->from[1] + 1);", " if ((ulong) v->dst[1] > vk2) vk2 = (ulong) v->dst[1]; ", " }", " for (e = v->Succ; e; e = e->Nxt)", " { m += HASH(e->Dst, e->To - e->From + 1 + e->s);", " if ((ulong) e->Dst > vk2) vk2 = (ulong) e->Dst; ", " }", " Tally = (vk2>>2)&(TWIDTH-1);", " return m;", "}", "", "static ulong", "mk_special(int sigma, Vertex *n, Vertex *v)", "{ ulong m = 0, vk2 = 0;", " Edge *f;", " int i;", "", " for (i = 0; i < 2; i++)", " if (v->dst[i])", " { if (sigma >= v->from[i] && sigma <= v->to[i])", " { m += HASH(v->dst[i], v->to[i]-v->from[i]);", " if ((ulong) v->dst[i] > vk2", " && v->to[i] > v->from[i])", " vk2 = (ulong) v->dst[i]; ", " } else", " { m += HASH(v->dst[i], v->to[i]-v->from[i]+1);", " if ((ulong) v->dst[i] > vk2)", " vk2 = (ulong) v->dst[i]; ", " } }", " for (f = v->Succ; f; f = f->Nxt)", " { if (sigma >= f->From && sigma <= f->To)", " { m += HASH(f->Dst, f->To - f->From + f->s);", " if ((ulong) f->Dst > vk2", " && f->To - f->From + f->s > 0)", " vk2 = (ulong) f->Dst; ", " } else if (f->s == 1 && sigma == f->S)", " { m += HASH(f->Dst, f->To - f->From + 1);", " if ((ulong) f->Dst > vk2) vk2 = (ulong) f->Dst; ", " } else", " { m += HASH(f->Dst, f->To - f->From + 1 + f->s);", " if ((ulong) f->Dst > vk2) vk2 = (ulong) f->Dst; ", " } }", "", " if ((ulong) n > vk2) vk2 = (ulong) n; ", " Tally = (vk2>>2)&(TWIDTH-1);", " m += HASH(n, 1);", " return m;", "}", "", "void ", "dfa_init(ushort nr_layers)", "{ int i; Vertex *r, *t;", "", " dfa_depth = nr_layers; /* one byte per layer */", " path = (Vertex **) emalloc((dfa_depth+1)*sizeof(Vertex *));", " layers = (Vertex **) emalloc(TWIDTH*(dfa_depth+1)*sizeof(Vertex *));", " lastword = (uchar *) emalloc((dfa_depth+1)*sizeof(uchar));", " lastword[dfa_depth] = lastword[0] = 255;", " path[0] = R = new_vertex(); F = new_vertex();", "", " for (i = 1, r = R; i < dfa_depth; i++, r = t)", " t = allDelta(r, i-1);", " NF = allDelta(r, i-1);", "}", "", "#if 0", "static void complement_dfa(void) { Vertex *tmp = F; F = NF; NF = tmp; }", "#endif", "", "double", "tree_stats(Vertex *t)", "{ Edge *e; double cnt=0.0;", " if (!t) return 0;", " if (!t->key) return 0;", " t->key = 0; /* precaution */", " if (t->dst[0]) cnt++;", " if (t->dst[1]) cnt++;", " for (e = t->Succ; e; e = e->Nxt)", " cnt++;", " cnt += tree_stats(t->lnk);", " cnt += tree_stats(t->left);", " cnt += tree_stats(t->right);", " return cnt;", "}", "", "void", "dfa_stats(void)", "{ int i, j; double cnt = 0.0;", " for (j = 0; j < TWIDTH; j++)", " for (i = 0; i < dfa_depth+1; i++)", " cnt += tree_stats(layers[i*TWIDTH+j]);", " printf(\"Minimized Automaton:\t%%6lu nodes and %%6g edges\\n\",", " nr_states, cnt);", "}", "", "int", "dfa_member(ulong n)", "{ Vertex **p, **q;", " uchar *w = &word[n];", " int i;", "", " p = &path[n]; q = (p+1);", " for (i = n; i < dfa_depth; i++)", " *q++ = Delta(*p++, *w++);", " return (*p == F);", "}", "", "int", "dfa_store(uchar *sv)", "{ Vertex **p, **q, *s, *y, *old, *new = F;", " uchar *w, *u = lastword;", " int i, j, k;", "", " w = word = sv;", " while (*w++ == *u++) /* find first byte that differs */", " ;", " pfrst = (int) (u - lastword) - 1;", " memcpy(&lastword[pfrst], &sv[pfrst], dfa_depth-pfrst);", " if (pfrst > iv) pfrst = iv;", " if (pfrst > nv) pfrst = nv;", "/* phase1: */", " p = &path[pfrst]; q = (p+1); w = &word[pfrst];", " for (i = pfrst; i < dfa_depth; i++)", " *q++ = Delta(*p++, *w++); /* (*p)->delta[*w++]; */", "", " if (*p == F) return 1; /* it's already there */", "/* phase2: */", " iv = dfa_depth;", " do { iv--;", " old = new;", " new = find_it(path[iv], old, word[iv], iv);", " } while (new && iv > 0);", "", "/* phase3: */", " nv = k = 0; s = path[0];", " for (j = 1; j <= iv; ++j) ", " if (path[j]->num > 1)", " { y = new_vertex();", " copyEdges(y, path[j]);", " insert_it(y, j);", " numDelta(y, 1);", " delete_it(s, j-1);", " setDelta(s, word[j-1], y);", " insert_it(s, j-1);", " y->num = 1; /* initial value 1 */", " s = y;", " path[j]->num--; /* only 1 moved from j to y */", " k = 1;", " } else", " { s = path[j];", " if (!k) nv = j;", " }", " y = Delta(s, word[iv]);", " y->num--;", " delete_it(s, iv); ", " setDelta(s, word[iv], old);", " insert_it(s, iv); ", " old->num++;", "", " for (j = iv+1; j < dfa_depth; j++)", " if (path[j]->num == 0)", " { numDelta(path[j], -1);", " delete_it(path[j], j);", " recyc_vertex(path[j]);", " } else", " break;", " return 0;", "}", "", "static Vertex *", "splay(ulong i, Vertex *t)", "{ Vertex N, *l, *r, *y;", "", " if (!t) return t;", " N.left = N.right = (Vertex *) 0;", " l = r = &N;", " for (;;)", " { if (i < t->key)", " { if (!t->left) break;", " if (i < t->left->key)", " { y = t->left;", " t->left = y->right;", " y->right = t;", " t = y;", " if (!t->left) break;", " }", " r->left = t;", " r = t;", " t = t->left;", " } else if (i > t->key)", " { if (!t->right) break;", " if (i > t->right->key)", " { y = t->right;", " t->right = y->left;", " y->left = t;", " t = y;", " if (!t->right) break;", " }", " l->right = t;", " l = t;", " t = t->right;", " } else", " break;", " }", " l->right = t->left;", " r->left = t->right;", " t->left = N.right;", " t->right = N.left;", " return t;", "}", "", "static void", "insert_it(Vertex *v, int L)", "{ Vertex *new, *t;", " ulong i; int nr;", "", " i = mk_key(v);", " nr = ((L*TWIDTH)+Tally);", " t = layers[nr];", "", " v->key = i; ", " if (!t)", " { layers[nr] = v;", " return;", " }", " t = splay(i, t);", " if (i < t->key)", " { new = v;", " new->left = t->left;", " new->right = t;", " t->left = (Vertex *) 0;", " } else if (i > t->key)", " { new = v;", " new->right = t->right;", " new->left = t;", " t->right = (Vertex *) 0;", " } else /* it's already there */", " { v->lnk = t->lnk; /* put in linked list off v */", " t->lnk = v;", " new = t;", " }", " layers[nr] = new;", "}", "", "static int", "checkit(Vertex *h, Vertex *v, Vertex *n, uchar sigma)", "{ Edge *g, *f;", " int i, k, j = 1;", "", " for (k = 0; k < 2; k++)", " if (h->dst[k])", " { if (sigma >= h->from[k] && sigma <= h->to[k])", " { if (h->dst[k] != n) goto no_match;", " }", " for (i = h->from[k]; i <= h->to[k]; i++)", " { if (i == sigma) continue;", " g = cacheDelta(v, i, j); j = 0;", " if (h->dst[k] != g->Dst)", " goto no_match;", " if (g->s == 0 || g->S != i)", " i = g->To;", " } }", " for (f = h->Succ; f; f = f->Nxt)", " { if (INRANGE(f,sigma))", " { if (f->Dst != n) goto no_match;", " }", " for (i = f->From; i <= f->To; i++)", " { if (i == sigma) continue;", " g = cacheDelta(v, i, j); j = 0;", " if (f->Dst != g->Dst)", " goto no_match;", " if (g->s == 1 && i == g->S)", " continue;", " i = g->To;", " }", " if (f->s && f->S != sigma)", " { g = cacheDelta(v, f->S, 1);", " if (f->Dst != g->Dst)", " goto no_match;", " }", " }", " if (h->Succ || h->dst[0] || h->dst[1]) return 1;", "no_match:", " return 0;", "}", "", "static Vertex *", "find_it(Vertex *v, Vertex *n, uchar sigma, int L)", "{ Vertex *z, *t;", " ulong i; int nr;", "", " i = mk_special(sigma,n,v);", " nr = ((L*TWIDTH)+Tally);", " t = layers[nr];", "", " if (!t) return (Vertex *) 0;", " layers[nr] = t = splay(i, t);", " if (i == t->key)", " for (z = t; z; z = z->lnk)", " if (checkit(z, v, n, sigma))", " return z;", "", " return (Vertex *) 0;", "}", "", "static void", "delete_it(Vertex *v, int L)", "{ Vertex *x, *t;", " ulong i; int nr;", "", " i = cheap_key(v);", " nr = ((L*TWIDTH)+Tally);", " t = layers[nr];", " if (!t) return;", "", " t = splay(i, t);", " if (i == t->key)", " { Vertex *z, *y = (Vertex *) 0;", " for (z = t; z && z != v; y = z, z = z->lnk)", " ;", " if (z != v) goto bad;", " if (y)", " { y->lnk = z->lnk;", " z->lnk = (Vertex *) 0;", " layers[nr] = t;", " return;", " } else if (z->lnk) /* z == t == v */", " { y = z->lnk;", " y->left = t->left;", " y->right = t->right;", " t->left = t->right = t->lnk = (Vertex *) 0;", " layers[nr] = y;", " return;", " }", " /* delete the node itself */", " if (!t->left)", " { x = t->right;", " } else", " { x = splay(i, t->left);", " x->right = t->right;", " }", " t->left = t->right = t->lnk = (Vertex *) 0;", " layers[nr] = x;", " return;", " }", "bad: Uerror(\"cannot happen delete\");", "}", "#endif", /* MA */ 0, }; Spin/Src6.4.5/pangen2.c0000664000175100017510000025672012641605057012413 0ustar ghgh/***** spin: pangen2.c *****/ /* * This file is part of the public release of Spin. It is subject to the * terms in the LICENSE file that is included in this source directory. * Tool documentation is available at http://spinroot.com */ #include "spin.h" #include "version.h" #include "y.tab.h" #include "pangen2.h" #include "pangen4.h" #include "pangen5.h" #include "pangen7.h" #define DELTA 500 /* sets an upperbound on nr of chan names */ #define blurb(fd, e) { fprintf(fd, "\n"); if (!merger) fprintf(fd, "\t\t/* %s:%d */\n", \ e->n->fn->name, e->n->ln); } #define tr_map(m, e) { if (!merger) fprintf(tt, "\t\ttr_2_src(%d, \"%s\", %d);\n", \ m, e->n->fn->name, e->n->ln); } extern ProcList *rdy; extern RunList *run; extern Lextok *runstmnts; extern Symbol *Fname, *oFname, *context; extern char *claimproc, *eventmap; extern int lineno, verbose, Npars, Mpars, nclaims; extern int m_loss, has_remote, has_remvar, merger, rvopt, separate; extern int Ntimeouts, Etimeouts, deadvar, old_scope_rules, old_priority_rules; extern int u_sync, u_async, nrRdy, Unique; extern int GenCode, IsGuard, Level, TestOnly; extern int globmin, globmax, ltl_mode, dont_simplify; extern short has_stack; extern char *NextLab[64]; /* must match value in dstep.c:18 */ int buzzed; FILE *tc, *th, *tt, *tb; static FILE *tm; int OkBreak = -1, has_hidden = 0; /* has_hidden set in sym.c and structs.c */ short nocast=0; /* to turn off casts in lvalues */ short terse=0; /* terse printing of varnames */ short no_arrays=0; short has_last=0; /* spec refers to _last */ short has_priority=0; /* spec refers to _priority */ short has_badelse=0; /* spec contains else combined with chan refs */ short has_enabled=0; /* spec contains enabled() */ short has_pcvalue=0; /* spec contains pc_value() */ short has_np=0; /* spec contains np_ */ short has_sorted=0; /* spec contains `!!' (sorted-send) operator */ short has_random=0; /* spec contains `??' (random-recv) operator */ short has_xu=0; /* spec contains xr or xs assertions */ short has_unless=0; /* spec contains unless statements */ short has_provided=0; /* spec contains PROVIDED clauses on procs */ short has_code=0; /* spec contains c_code, c_expr, c_state */ short has_ltl=0; /* has inline ltl formulae */ int mst=0; /* max nr of state/process */ int claimnr = -1; /* claim process, if any */ int eventmapnr = -1; /* event trace, if any */ int Pid; /* proc currently processed */ int multi_oval; /* set in merges, used also in pangen4.c */ #define MAXMERGE 256 /* max nr of bups per merge sequence */ static short CnT[MAXMERGE]; static Lextok XZ, YZ[MAXMERGE]; static int didcase, YZmax, YZcnt; static Lextok *Nn[2]; static int Det; /* set if deterministic */ static int T_sum, T_mus, t_cyc; static int TPE[2], EPT[2]; static int uniq=1; static int multi_needed, multi_undo; static short AllGlobal=0; /* set if process has provided clause */ static short withprocname=0; /* prefix local varnames with procname */ static short _isok=0; /* checks usage of predefined variable _ */ static short evalindex=0; /* evaluate index of var names */ int has_global(Lextok *); static int getweight(Lextok *); static int scan_seq(Sequence *); static void genconditionals(void); static void mark_seq(Sequence *); static void patch_atomic(Sequence *); static void put_seq(Sequence *, int, int); static void putproc(ProcList *); static void Tpe(Lextok *); extern void spit_recvs(FILE *, FILE*); static L_List *keep_track; void keep_track_off(Lextok *n) { L_List *p; p = (L_List *) emalloc(sizeof(L_List)); p->n = n; p->nxt = keep_track; keep_track = p; } int check_track(Lextok *n) { L_List *p; for (p = keep_track; p; p = p->nxt) { if (p->n == n) { return n->sym?n->sym->type:0; } } return 0; } static int fproc(char *s) { ProcList *p; for (p = rdy; p; p = p->nxt) if (strcmp(p->n->name, s) == 0) return p->tn; fatal("proctype %s not found", s); return -1; } int pid_is_claim(int p) /* Pid (p->tn) to type (p->b) */ { ProcList *r; for (r = rdy; r; r = r->nxt) { if (r->tn == p) return (r->b == N_CLAIM); } printf("spin: error, cannot find pid %d\n", p); return 0; } static void reverse_procs(RunList *q) { if (!q) return; reverse_procs(q->nxt); fprintf(tc, " Addproc(%d, %d);\n", q->tn, q->priority < 1 ? 1 : q->priority); } static void forward_procs(RunList *q) { if (!q) return; fprintf(tc, " Addproc(%d, %d);\n", q->tn, q->priority < 1 ? 1 : q->priority); forward_procs(q->nxt); } static void tm_predef_np(void) { fprintf(th, "#define _T5 %d\n", uniq++); fprintf(th, "#define _T2 %d\n", uniq++); fprintf(tm, "\tcase _T5:\t/* np_ */\n"); if (separate == 2) { fprintf(tm, "\t\tif (!((!(o_pm&4) && !(tau&128))))\n"); } else { fprintf(tm, "\t\tif (!((!(trpt->o_pm&4) && !(trpt->tau&128))))\n"); } fprintf(tm, "\t\t\tcontinue;\n"); fprintf(tm, "\t\t/* else fall through */\n"); fprintf(tm, "\tcase _T2:\t/* true */\n"); fprintf(tm, "\t\t_m = 3; goto P999;\n"); } static void tt_predef_np(void) { fprintf(tt, "\t/* np_ demon: */\n"); fprintf(tt, "\ttrans[_NP_] = "); fprintf(tt, "(Trans **) emalloc(2*sizeof(Trans *));\n"); fprintf(tt, "\tT = trans[_NP_][0] = "); fprintf(tt, "settr(9997,0,1,_T5,0,\"(np_)\", 1,2,0);\n"); fprintf(tt, "\t T->nxt = "); fprintf(tt, "settr(9998,0,0,_T2,0,\"(1)\", 0,2,0);\n"); fprintf(tt, "\tT = trans[_NP_][1] = "); fprintf(tt, "settr(9999,0,1,_T5,0,\"(np_)\", 1,2,0);\n"); } static struct { char *nm[3]; } Cfile[] = { { { "pan.c", "pan_s.c", "pan_t.c" } }, { { "pan.h", "pan_s.h", "pan_t.h" } }, { { "pan.t", "pan_s.t", "pan_t.t" } }, { { "pan.m", "pan_s.m", "pan_t.m" } }, { { "pan.b", "pan_s.b", "pan_t.b" } } }; void gensrc(void) { ProcList *p; int i; disambiguate(); /* avoid name-clashes between scopes */ if (!(tc = fopen(Cfile[0].nm[separate], MFLAGS)) /* main routines */ || !(th = fopen(Cfile[1].nm[separate], MFLAGS)) /* header file */ || !(tt = fopen(Cfile[2].nm[separate], MFLAGS)) /* transition matrix */ || !(tm = fopen(Cfile[3].nm[separate], MFLAGS)) /* forward moves */ || !(tb = fopen(Cfile[4].nm[separate], MFLAGS))) /* backward moves */ { printf("spin: cannot create pan.[chtmfb]\n"); alldone(1); } fprintf(th, "#ifndef PAN_H\n"); fprintf(th, "#define PAN_H\n\n"); fprintf(th, "#define SpinVersion \"%s\"\n", SpinVersion); fprintf(th, "#define PanSource \""); for (i = 0; oFname->name[i] != '\0'; i++) { char c = oFname->name[i]; if (c == '\\' || c == ' ') /* Windows path */ { fprintf(th, "\\"); } fprintf(th, "%c", c); } fprintf(th, "\"\n\n"); fprintf(th, "#define G_long %d\n", (int) sizeof(long)); fprintf(th, "#define G_int %d\n\n", (int) sizeof(int)); fprintf(th, "#define ulong unsigned long\n"); fprintf(th, "#define ushort unsigned short\n"); fprintf(th, "#ifdef WIN64\n"); fprintf(th, " #define ONE_L (1L)\n"); fprintf(th, "/* #define long long long */\n"); fprintf(th, "#else\n"); fprintf(th, " #define ONE_L (1L)\n"); fprintf(th, "#endif\n\n"); fprintf(th, "#ifdef BFS_PAR\n"); fprintf(th, " #define NRUNS %d\n", (runstmnts)?1:0); fprintf(th, " #ifndef BFS\n"); fprintf(th, " #define BFS\n"); fprintf(th, " #endif\n"); fprintf(th, " #ifndef PUTPID\n"); fprintf(th, " #define PUTPID\n"); fprintf(th, " #endif\n\n"); fprintf(th, " #if !defined(USE_TDH) && !defined(NO_TDH)\n"); fprintf(th, " #define USE_TDH\n"); fprintf(th, " #endif\n"); fprintf(th, " #if defined(USE_TDH) && !defined(NO_HC)\n"); fprintf(th, " #define HC /* default for USE_TDH */\n"); fprintf(th, " #endif\n"); fprintf(th, " #ifndef BFS_MAXPROCS\n"); fprintf(th, " #define BFS_MAXPROCS 64 /* max nr of cores to use */\n"); fprintf(th, " #endif\n"); fprintf(th, " #define BFS_GLOB 0 /* global lock */\n"); fprintf(th, " #define BFS_ORD 1 /* used with -DCOLLAPSE */\n"); fprintf(th, " #define BFS_MEM 2 /* malloc from shared heap */\n"); fprintf(th, " #define BFS_PRINT 3 /* protect printfs */\n"); fprintf(th, " #define BFS_STATE 4 /* hashtable */\n\n"); fprintf(th, " #define BFS_INQ 2 /* state is in q */\n\n"); fprintf(th, " #ifdef BFS_FIFO\n"); /* queue access */ fprintf(th, " #define BFS_ID(a,b) (BFS_STATE + (int) ((a)*BFS_MAXPROCS+(b)))\n"); fprintf(th, " #define BFS_MAXLOCKS (BFS_STATE + (BFS_MAXPROCS*BFS_MAXPROCS))\n"); fprintf(th, " #else\n"); /* h_store access (not needed for o_store) */ fprintf(th, " #ifndef BFS_W\n"); fprintf(th, " #define BFS_W 10\n"); /* 1<minel = -1; claimproc = n->name = "_:never_template:_"; ready(n, ZN, s, 0, ZN, N_CLAIM); } if (separate == 2) { if (has_remote) { printf("spin: warning, make sure that the S1 model\n"); printf(" includes the same remote references\n"); } fprintf(th, "#ifndef NFAIR\n"); fprintf(th, "#define NFAIR 2 /* must be >= 2 */\n"); fprintf(th, "#endif\n"); if (has_last) fprintf(th, "#define HAS_LAST %d\n", has_last); if (has_priority && !old_priority_rules) fprintf(th, "#define HAS_PRIORITY %d\n", has_priority); goto doless; } fprintf(th, "#define DELTA %d\n", DELTA); fprintf(th, "#ifdef MA\n"); fprintf(th, " #if NCORE>1 && !defined(SEP_STATE)\n"); fprintf(th, " #define SEP_STATE\n"); fprintf(th, " #endif\n"); fprintf(th, " #if MA==1\n"); /* user typed -DMA without size */ fprintf(th, " #undef MA\n"); fprintf(th, " #define MA 100\n"); fprintf(th, " #endif\n"); fprintf(th, "#endif\n"); fprintf(th, "#ifdef W_XPT\n"); fprintf(th, " #if W_XPT==1\n"); /* user typed -DW_XPT without size */ fprintf(th, " #undef W_XPT\n"); fprintf(th, " #define W_XPT 1000000\n"); fprintf(th, " #endif\n"); fprintf(th, "#endif\n"); fprintf(th, "#ifndef NFAIR\n"); fprintf(th, " #define NFAIR 2 /* must be >= 2 */\n"); fprintf(th, "#endif\n"); if (Ntimeouts) fprintf(th, "#define NTIM %d\n", Ntimeouts); if (Etimeouts) fprintf(th, "#define ETIM %d\n", Etimeouts); if (has_remvar) fprintf(th, "#define REM_VARS 1\n"); if (has_remote) fprintf(th, "#define REM_REFS %d\n", has_remote); /* not yet used */ if (has_hidden) { fprintf(th, "#define HAS_HIDDEN %d\n", has_hidden); fprintf(th, "#if defined(BFS_PAR) || defined(BFS)\n"); fprintf(th, " #error cannot use BFS on models with variables declared hidden\n"); fprintf(th, "#endif\n"); } if (has_last) fprintf(th, "#define HAS_LAST %d\n", has_last); if (has_priority && !old_priority_rules) fprintf(th, "#define HAS_PRIORITY %d\n", has_priority); if (has_sorted) fprintf(th, "#define HAS_SORTED %d\n", has_sorted); if (m_loss) fprintf(th, "#define M_LOSS\n"); if (has_random) fprintf(th, "#define HAS_RANDOM %d\n", has_random); if (has_ltl) fprintf(th, "#define HAS_LTL 1\n"); fprintf(th, "#define HAS_CODE 1\n"); /* could also be set to has_code */ /* always defining it doesn't seem to cause measurable overhead though */ /* and allows for pan -r etc to work for non-embedded code as well */ fprintf(th, "#if defined(RANDSTORE) && !defined(RANDSTOR)\n"); fprintf(th, " #define RANDSTOR RANDSTORE\n"); /* xspin uses RANDSTORE... */ fprintf(th, "#endif\n"); if (has_stack) fprintf(th, "#define HAS_STACK %d\n", has_stack); if (has_enabled || (has_priority && !old_priority_rules)) fprintf(th, "#define HAS_ENABLED 1\n"); if (has_unless) fprintf(th, "#define HAS_UNLESS %d\n", has_unless); if (has_provided) fprintf(th, "#define HAS_PROVIDED %d\n", has_provided); if (has_pcvalue) fprintf(th, "#define HAS_PCVALUE %d\n", has_pcvalue); if (has_badelse) fprintf(th, "#define HAS_BADELSE %d\n", has_badelse); if (has_enabled || (has_priority && !old_priority_rules) || has_pcvalue || has_badelse || has_last) { fprintf(th, "#ifndef NOREDUCE\n"); fprintf(th, " #define NOREDUCE 1\n"); fprintf(th, "#endif\n"); } if (has_np) fprintf(th, "#define HAS_NP %d\n", has_np); if (merger) fprintf(th, "#define MERGED 1\n"); doless: fprintf(th, "#if !defined(HAS_LAST) && defined(BCS)\n"); fprintf(th, " #define HAS_LAST 1 /* use it, but */\n"); fprintf(th, " #ifndef STORE_LAST\n"); /* unless the user insists */ fprintf(th, " #define NO_LAST 1 /* dont store it */\n"); fprintf(th, " #endif\n"); fprintf(th, "#endif\n"); fprintf(th, "#if defined(BCS) && defined(BITSTATE)\n"); fprintf(th, " #ifndef NO_CTX\n"); fprintf(th, " #define STORE_CTX 1\n"); fprintf(th, " #endif\n"); fprintf(th, "#endif\n"); fprintf(th, "#ifdef NP\n"); if (!has_np) fprintf(th, " #define HAS_NP 2\n"); fprintf(th, " #define VERI %d /* np_ */\n", nrRdy); fprintf(th, "#endif\n"); if (claimproc) { claimnr = fproc(claimproc); /* the default claim */ fprintf(th, "#ifndef NOCLAIM\n"); fprintf(th, " #define NCLAIMS %d\n", nclaims); fprintf(th, " #ifndef NP\n"); fprintf(th, " #define VERI %d\n", claimnr); fprintf(th, " #endif\n"); fprintf(th, "#endif\n"); } if (eventmap) { eventmapnr = fproc(eventmap); fprintf(th, "#define EVENT_TRACE %d\n", eventmapnr); fprintf(th, "#define endevent endstate%d\n", eventmapnr); if (eventmap[2] == 'o') /* ":notrace:" */ fprintf(th, "#define NEGATED_TRACE 1\n"); } fprintf(th, "\ntypedef struct S_F_MAP {\n"); fprintf(th, " char *fnm;\n\tint from;\n\tint upto;\n"); fprintf(th, "} S_F_MAP;\n"); fprintf(tc, "/*** Generated by %s ***/\n", SpinVersion); fprintf(tc, "/*** From source: %s ***/\n\n", oFname->name); ntimes(tc, 0, 1, Pre0); plunk_c_decls(tc); /* types can be refered to in State */ switch (separate) { case 0: fprintf(tc, "#include \"pan.h\"\n"); break; case 1: fprintf(tc, "#include \"pan_s.h\"\n"); break; case 2: fprintf(tc, "#include \"pan_t.h\"\n"); break; } if (separate != 2) { fprintf(tc, "char *TrailFile = PanSource; /* default */\n"); fprintf(tc, "char *trailfilename;\n"); } fprintf(tc, "#ifdef LOOPSTATE\n"); fprintf(tc, "double cnt_loops;\n"); fprintf(tc, "#endif\n"); fprintf(tc, "State A_Root; /* seed-state for cycles */\n"); fprintf(tc, "State now; /* the full state-vector */\n"); fprintf(tc, "#if NQS > 0\n"); fprintf(tc, "short q_flds[NQS+1];\n"); fprintf(tc, "short q_max[NQS+1];\n"); fprintf(tc, "#endif\n"); plunk_c_fcts(tc); /* State can be used in fcts */ if (separate != 2) { ntimes(tc, 0, 1, Preamble); ntimes(tc, 0, 1, Separate); /* things that moved out of pan.h */ } else { fprintf(tc, "extern int verbose;\n"); fprintf(tc, "extern long depth, depthfound;\n"); } fprintf(tc, "#ifndef NOBOUNDCHECK\n"); fprintf(tc, " #define Index(x, y)\tBoundcheck(x, y, II, tt, t)\n"); fprintf(tc, "#else\n"); fprintf(tc, " #define Index(x, y)\tx\n"); fprintf(tc, "#endif\n"); c_preview(); /* sets hastrack */ for (p = rdy; p; p = p->nxt) mst = max(p->s->maxel, mst); if (separate != 2) { fprintf(tt, "#ifdef PEG\n"); fprintf(tt, "struct T_SRC {\n"); fprintf(tt, " char *fl; int ln;\n"); fprintf(tt, "} T_SRC[NTRANS];\n\n"); fprintf(tt, "void\ntr_2_src(int m, char *file, int ln)\n"); fprintf(tt, "{ T_SRC[m].fl = file;\n"); fprintf(tt, " T_SRC[m].ln = ln;\n"); fprintf(tt, "}\n\n"); fprintf(tt, "void\nputpeg(int n, int m)\n"); fprintf(tt, "{ printf(\"%%5d\ttrans %%4d \", m, n);\n"); fprintf(tt, " printf(\"%%s:%%d\\n\",\n"); fprintf(tt, " T_SRC[n].fl, T_SRC[n].ln);\n"); fprintf(tt, "}\n"); if (!merger) { fprintf(tt, "#else\n"); fprintf(tt, "#define tr_2_src(m,f,l)\n"); } fprintf(tt, "#endif\n\n"); fprintf(tt, "void\nsettable(void)\n{\tTrans *T;\n"); fprintf(tt, "\tTrans *settr(int, int, int, int, int,"); fprintf(tt, " char *, int, int, int);\n\n"); fprintf(tt, "\ttrans = (Trans ***) "); fprintf(tt, "emalloc(%d*sizeof(Trans **));\n", nrRdy+1); /* +1 for np_ automaton */ if (separate == 1) { fprintf(tm, " if (II == 0)\n"); fprintf(tm, " { _m = step_claim(trpt->o_pm, trpt->tau, tt, ot, t);\n"); fprintf(tm, " if (_m) goto P999; else continue;\n"); fprintf(tm, " } else\n"); } fprintf(tm, "#define rand pan_rand\n"); fprintf(tm, "#define pthread_equal(a,b) ((a)==(b))\n"); fprintf(tm, "#if defined(HAS_CODE) && defined(VERBOSE)\n"); fprintf(tm, " #ifdef BFS_PAR\n"); fprintf(tm, " bfs_printf(\"Pr: %%d Tr: %%d\\n\", II, t->forw);\n"); fprintf(tm, " #else\n"); fprintf(tm, " cpu_printf(\"Pr: %%d Tr: %%d\\n\", II, t->forw);\n"); fprintf(tm, " #endif\n"); fprintf(tm, "#endif\n"); fprintf(tm, " switch (t->forw) {\n"); } else { fprintf(tt, "#ifndef PEG\n"); fprintf(tt, " #define tr_2_src(m,f,l)\n"); fprintf(tt, "#endif\n"); fprintf(tt, "void\nset_claim(void)\n{\tTrans *T;\n"); fprintf(tt, "\textern Trans ***trans;\n"); fprintf(tt, "\textern Trans *settr(int, int, int, int, int,"); fprintf(tt, " char *, int, int, int);\n\n"); fprintf(tm, "#define rand pan_rand\n"); fprintf(tm, "#define pthread_equal(a,b) ((a)==(b))\n"); fprintf(tm, "#if defined(HAS_CODE) && defined(VERBOSE)\n"); fprintf(tm, " cpu_printf(\"Pr: %%d Tr: %%d\\n\", II, forw);\n"); fprintf(tm, "#endif\n"); fprintf(tm, " switch (forw) {\n"); } fprintf(tm, " default: Uerror(\"bad forward move\");\n"); fprintf(tm, " case 0: /* if without executable clauses */\n"); fprintf(tm, " continue;\n"); fprintf(tm, " case 1: /* generic 'goto' or 'skip' */\n"); if (separate != 2) fprintf(tm, " IfNotBlocked\n"); fprintf(tm, " _m = 3; goto P999;\n"); fprintf(tm, " case 2: /* generic 'else' */\n"); if (separate == 2) fprintf(tm, " if (o_pm&1) continue;\n"); else { fprintf(tm, " IfNotBlocked\n"); fprintf(tm, " if (trpt->o_pm&1) continue;\n"); } fprintf(tm, " _m = 3; goto P999;\n"); uniq = 3; if (separate == 1) fprintf(tb, " if (II == 0) goto R999;\n"); fprintf(tb, " switch (t->back) {\n"); fprintf(tb, " default: Uerror(\"bad return move\");\n"); fprintf(tb, " case 0: goto R999; /* nothing to undo */\n"); for (p = rdy; p; p = p->nxt) { putproc(p); } if (separate != 2) { fprintf(th, "\n"); for (p = rdy; p; p = p->nxt) fprintf(th, "extern short src_ln%d[];\n", p->tn); for (p = rdy; p; p = p->nxt) fprintf(th, "extern S_F_MAP src_file%d[];\n", p->tn); fprintf(th, "\n"); fprintf(tc, "uchar reached%d[3]; /* np_ */\n", nrRdy); fprintf(tc, "uchar *loopstate%d; /* np_ */\n", nrRdy); fprintf(tc, "struct {\n"); fprintf(tc, " int tp; short *src;\n"); fprintf(tc, "} src_all[] = {\n"); for (p = rdy; p; p = p->nxt) fprintf(tc, " { %d, &src_ln%d[0] },\n", p->tn, p->tn); fprintf(tc, " { 0, (short *) 0 }\n"); fprintf(tc, "};\n"); fprintf(tc, "S_F_MAP *flref[] = {\n"); /* 5.3.0 */ for (p = rdy; p; p = p->nxt) { fprintf(tc, " src_file%d%c\n", p->tn, p->nxt?',':' '); } fprintf(tc, "};\n\n"); } else { fprintf(tc, "extern uchar reached%d[3]; /* np_ */\n", nrRdy); } gencodetable(tc); /* was th */ if (Unique < (1 << (8*sizeof(unsigned char)) )) /* was uniq before */ { fprintf(th, "#define T_ID unsigned char\n"); } else if (Unique < (1 << (8*sizeof(unsigned short)) )) { fprintf(th, "#define T_ID unsigned short\n"); } else { fprintf(th, "#define T_ID unsigned int\n"); } if (separate != 1) { tm_predef_np(); tt_predef_np(); } fprintf(tt, "}\n\n"); /* end of settable() */ fprintf(tm, "#undef rand\n"); fprintf(tm, " }\n\n"); fprintf(tb, " }\n\n"); if (separate != 2) { ntimes(tt, 0, 1, Tail); genheader(); if (separate == 1) { fprintf(th, "#define FORWARD_MOVES\t\"pan_s.m\"\n"); fprintf(th, "#define BACKWARD_MOVES\t\"pan_s.b\"\n"); fprintf(th, "#define SEPARATE\n"); fprintf(th, "#define TRANSITIONS\t\"pan_s.t\"\n"); fprintf(th, "extern void ini_claim(int, int);\n"); } else { fprintf(th, "#define FORWARD_MOVES\t\"pan.m\"\n"); fprintf(th, "#define BACKWARD_MOVES\t\"pan.b\"\n"); fprintf(th, "#define TRANSITIONS\t\"pan.t\"\n"); } genaddproc(); genother(); genaddqueue(); genunio(); genconditionals(); gensvmap(); if (!run) fatal("no runable process", (char *)0); fprintf(tc, "void\n"); fprintf(tc, "active_procs(void)\n{\n"); fprintf(tc, " if (reversing == 0) {\n"); reverse_procs(run); fprintf(tc, " } else {\n"); forward_procs(run); fprintf(tc, " }\n"); fprintf(tc, "}\n"); ntimes(tc, 0, 1, Dfa); ntimes(tc, 0, 1, Xpt); fprintf(th, "#define NTRANS %d\n", uniq); if (u_sync && !u_async) { spit_recvs(th, tc); } } else { genheader(); fprintf(th, "#define FORWARD_MOVES\t\"pan_t.m\"\n"); fprintf(th, "#define BACKWARD_MOVES\t\"pan_t.b\"\n"); fprintf(th, "#define TRANSITIONS\t\"pan_t.t\"\n"); fprintf(tc, "extern int Maxbody;\n"); fprintf(tc, "#if VECTORSZ>32000\n"); fprintf(tc, " extern int *proc_offset;\n"); fprintf(tc, "#else\n"); fprintf(tc, " extern short *proc_offset;\n"); fprintf(tc, "#endif\n"); fprintf(tc, "extern uchar *proc_skip;\n"); fprintf(tc, "extern uchar *reached[];\n"); fprintf(tc, "extern uchar *accpstate[];\n"); fprintf(tc, "extern uchar *progstate[];\n"); fprintf(tc, "extern uchar *loopstate[];\n"); fprintf(tc, "extern uchar *stopstate[];\n"); fprintf(tc, "extern uchar *visstate[];\n\n"); fprintf(tc, "extern short *mapstate[];\n"); fprintf(tc, "void\nini_claim(int n, int h)\n{"); fprintf(tc, "\textern State now;\n"); fprintf(tc, "\textern void set_claim(void);\n\n"); fprintf(tc, "#ifdef PROV\n"); fprintf(tc, " #include PROV\n"); fprintf(tc, "#endif\n"); fprintf(tc, "\tset_claim();\n"); genother(); fprintf(tc, "\n\tswitch (n) {\n"); genaddproc(); fprintf(tc, "\t}\n"); fprintf(tc, "\n}\n"); fprintf(tc, "int\nstep_claim(int o_pm, int tau, int tt, int ot, Trans *t)\n"); fprintf(tc, "{ int forw = t->forw; int _m = 0; extern char *noptr; int II=0;\n"); fprintf(tc, " extern State now;\n"); fprintf(tc, "#define continue return 0\n"); fprintf(tc, "#include \"pan_t.m\"\n"); fprintf(tc, "P999:\n\treturn _m;\n}\n"); fprintf(tc, "#undef continue\n"); fprintf(tc, "int\nrev_claim(int backw)\n{ return 0; }\n"); fprintf(tc, "#include TRANSITIONS\n"); } if (separate != 2) { c_wrapper(tc); c_chandump(tc); } fprintf(th, "#if defined(BFS_PAR) || NCORE>1\n"); fprintf(th, " void e_critical(int);\n"); fprintf(th, " void x_critical(int);\n"); fprintf(th, " #ifdef BFS_PAR\n"); fprintf(th, " void bfs_main(int, int);\n"); fprintf(th, " void bfs_report_mem(void);\n"); fprintf(th, " #endif\n"); fprintf(th, "#endif\n"); fprintf(th, "\n\n/* end of PAN_H */\n#endif\n"); fclose(th); fclose(tt); fclose(tm); fclose(tb); if (!(th = fopen("pan.p", MFLAGS))) { printf("spin: cannot create pan.p for -DBFS_PAR\n"); return; /* we're done anyway */ } ntimes(th, 0, 1, pan_par); /* BFS_PAR */ fclose(th); fprintf(tc, "\nTrans *t_id_lkup[%d];\n\n", globmax+1); if (separate != 2) { fprintf(tc, "\n#ifdef BFS_PAR\n\t#include \"pan.p\"\n#endif\n"); } fprintf(tc, "\n/* end of pan.c */\n"); fclose(tc); } static int find_id(Symbol *s) { ProcList *p; if (s) for (p = rdy; p; p = p->nxt) if (s == p->n) return p->tn; return 0; } static void dolen(Symbol *s, char *pre, int pid, int ai, int qln) { if (ai > 0) fprintf(tc, "\n\t\t\t || "); fprintf(tc, "%s(", pre); if (!(s->hidden&1)) { if (s->context) fprintf(tc, "(int) ( ((P%d *)this)->", pid); else fprintf(tc, "(int) ( now."); } fprintf(tc, "%s", s->name); if (qln > 1 || s->isarray) fprintf(tc, "[%d]", ai); fprintf(tc, ") )"); } struct AA { char TT[9]; char CC[8]; }; static struct AA BB[4] = { { "Q_FULL_F", " q_full" }, { "Q_FULL_T", "!q_full" }, { "Q_EMPT_F", " !q_len" }, { "Q_EMPT_T", " q_len" } }; static struct AA DD[4] = { { "Q_FULL_F", " q_e_f" }, /* empty or full */ { "Q_FULL_T", "!q_full" }, { "Q_EMPT_F", " q_e_f" }, { "Q_EMPT_T", " q_len" } }; /* this reduces the number of cases where 's' and 'r' are considered conditionally safe under the partial order reduction rules; as a price for this simple implementation, it also affects the cases where nfull and nempty can be considered safe -- since these are labeled the same way as 's' and 'r' respectively it only affects reduction, not functionality */ void bb_or_dd(int j, int which) { if (which) { if (has_unless) fprintf(tc, "%s", DD[j].CC); else fprintf(tc, "%s", BB[j].CC); } else { if (has_unless) fprintf(tc, "%s", DD[j].TT); else fprintf(tc, "%s", BB[j].TT); } } void Done_case(char *nm, Symbol *z) { int j, k; int nid = z->Nid; int qln = z->nel; fprintf(tc, "\t\tcase %d: if (", nid); for (j = 0; j < 4; j++) { fprintf(tc, "\t(t->ty[i] == "); bb_or_dd(j, 0); fprintf(tc, " && ("); for (k = 0; k < qln; k++) { if (k > 0) fprintf(tc, "\n\t\t\t || "); bb_or_dd(j, 1); fprintf(tc, "(%s%s", nm, z->name); if (qln > 1) fprintf(tc, "[%d]", k); fprintf(tc, ")"); } fprintf(tc, "))\n\t\t\t "); if (j < 3) fprintf(tc, "|| "); else fprintf(tc, " "); } fprintf(tc, ") return 0; break;\n"); } static void Docase(Symbol *s, int pid, int nid) { int i, j; fprintf(tc, "\t\tcase %d: if (", nid); for (j = 0; j < 4; j++) { fprintf(tc, "\t(t->ty[i] == "); bb_or_dd(j, 0); fprintf(tc, " && ("); if (has_unless) { for (i = 0; i < s->nel; i++) dolen(s, DD[j].CC, pid, i, s->nel); } else { for (i = 0; i < s->nel; i++) dolen(s, BB[j].CC, pid, i, s->nel); } fprintf(tc, "))\n\t\t\t "); if (j < 3) fprintf(tc, "|| "); else fprintf(tc, " "); } fprintf(tc, ") return 0; break;\n"); } static void genconditionals(void) { Symbol *s; int last=0, j; extern Ordered *all_names; Ordered *walk; fprintf(th, "#define LOCAL 1\n"); fprintf(th, "#define Q_FULL_F 2\n"); fprintf(th, "#define Q_EMPT_F 3\n"); fprintf(th, "#define Q_EMPT_T 4\n"); fprintf(th, "#define Q_FULL_T 5\n"); fprintf(th, "#define TIMEOUT_F 6\n"); fprintf(th, "#define GLOBAL 7\n"); fprintf(th, "#define BAD 8\n"); fprintf(th, "#define ALPHA_F 9\n"); fprintf(tc, "int\n"); fprintf(tc, "q_cond(short II, Trans *t)\n"); fprintf(tc, "{ int i = 0;\n"); fprintf(tc, " for (i = 0; i < 6; i++)\n"); fprintf(tc, " { if (t->ty[i] == TIMEOUT_F) return %s;\n", (Etimeouts)?"(!(trpt->tau&1))":"1"); fprintf(tc, " if (t->ty[i] == ALPHA_F)\n"); fprintf(tc, "#ifdef GLOB_ALPHA\n"); fprintf(tc, " return 0;\n"); fprintf(tc, "#else\n\t\t\treturn "); fprintf(tc, "(II+1 == (short) now._nr_pr && II+1 < MAXPROC);\n"); fprintf(tc, "#endif\n"); /* we switch on the chan name from the spec (as identified by * the corresponding Nid number) rather than the actual qid * because we cannot predict at compile time which specific qid * will be accessed by the statement at runtime. that is: * we do not know which qid to pass to q_cond at runtime * but we do know which name is used. if it's a chan array, we * must check all elements of the array for compliance (bummer) */ fprintf(tc, " switch (t->qu[i]) {\n"); fprintf(tc, " case 0: break;\n"); for (walk = all_names; walk; walk = walk->next) { s = walk->entry; if (s->owner) continue; j = find_id(s->context); if (s->type == CHAN) { if (last == s->Nid) continue; /* chan array */ last = s->Nid; Docase(s, j, last); } else if (s->type == STRUCT) { /* struct may contain a chan */ char pregat[128]; extern void walk2_struct(char *, Symbol *); strcpy(pregat, ""); if (!(s->hidden&1)) { if (s->context) sprintf(pregat, "((P%d *)this)->",j); else sprintf(pregat, "now."); } walk2_struct(pregat, s); } } fprintf(tc, " \tdefault: Uerror(\"unknown qid - q_cond\");\n"); fprintf(tc, " \t\t\treturn 0;\n"); fprintf(tc, " \t}\n"); fprintf(tc, " }\n"); fprintf(tc, " return 1;\n"); fprintf(tc, "}\n"); } extern int find_min(Sequence *); extern int find_max(Sequence *); static void putproc(ProcList *p) { Pid = p->tn; Det = p->det; if (pid_is_claim(Pid) && separate == 1) { fprintf(th, "extern uchar reached%d[];\n", Pid); #if 0 fprintf(th, "extern short nstates%d;\n", Pid); #else fprintf(th, "\n#define nstates%d %d\t/* %s */\n", Pid, p->s->maxel, p->n->name); #endif fprintf(th, "extern short src_ln%d[];\n", Pid); fprintf(th, "extern uchar *loopstate%d;\n", Pid); fprintf(th, "extern S_F_MAP src_file%d[];\n", Pid); fprintf(th, "#define endstate%d %d\n", Pid, p->s->last?p->s->last->seqno:0); return; } if (!pid_is_claim(Pid) && separate == 2) { fprintf(th, "extern short src_ln%d[];\n", Pid); fprintf(th, "extern uchar *loopstate%d;\n", Pid); return; } AllGlobal = (p->prov)?1:0; /* process has provided clause */ fprintf(th, "\n#define nstates%d %d\t/* %s */\n", Pid, p->s->maxel, p->n->name); /* new */ fprintf(th, "#define minseq%d %d\n", Pid, find_min(p->s)); fprintf(th, "#define maxseq%d %d\n", Pid, find_max(p->s)); /* end */ if (Pid == eventmapnr) fprintf(th, "#define nstates_event nstates%d\n", Pid); fprintf(th, "#define endstate%d %d\n", Pid, p->s->last?p->s->last->seqno:0); if (p->b == N_CLAIM || p->b == E_TRACE || p->b == N_TRACE) { fprintf(tm, "\n /* CLAIM %s */\n", p->n->name); fprintf(tb, "\n /* CLAIM %s */\n", p->n->name); } else { fprintf(tm, "\n /* PROC %s */\n", p->n->name); fprintf(tb, "\n /* PROC %s */\n", p->n->name); } fprintf(tt, "\n /* proctype %d: %s */\n", Pid, p->n->name); fprintf(tt, "\n trans[%d] = (Trans **)", Pid); fprintf(tt, " emalloc(%d*sizeof(Trans *));\n\n", p->s->maxel); if (Pid == eventmapnr) { fprintf(th, "\n#define in_s_scope(x_y3_) 0"); fprintf(tc, "\n#define in_r_scope(x_y3_) 0"); } put_seq(p->s, 2, 0); if (Pid == eventmapnr) { fprintf(th, "\n\n"); fprintf(tc, "\n\n"); } dumpsrc(p->s->maxel, Pid); } static void addTpe(int x) { int i; if (x <= 2) return; for (i = 0; i < T_sum; i++) if (TPE[i] == x) return; TPE[(T_sum++)%2] = x; } static void cnt_seq(Sequence *s) { Element *f; SeqList *h; if (s) for (f = s->frst; f; f = f->nxt) { Tpe(f->n); /* sets EPT */ addTpe(EPT[0]); addTpe(EPT[1]); for (h = f->sub; h; h = h->nxt) cnt_seq(h->this); if (f == s->last) break; } } static void typ_seq(Sequence *s) { T_sum = 0; TPE[0] = 2; TPE[1] = 0; cnt_seq(s); if (T_sum > 2) /* more than one type */ { TPE[0] = 5*DELTA; /* non-mixing */ TPE[1] = 0; } } static int hidden(Lextok *n) { if (n) switch (n->ntyp) { case FULL: case EMPTY: case NFULL: case NEMPTY: case TIMEOUT: Nn[(T_mus++)%2] = n; break; case '!': case UMIN: case '~': case ASSERT: case 'c': (void) hidden(n->lft); break; case '/': case '*': case '-': case '+': case '%': case LT: case GT: case '&': case '^': case '|': case LE: case GE: case NE: case '?': case EQ: case OR: case AND: case LSHIFT: case RSHIFT: (void) hidden(n->lft); (void) hidden(n->rgt); break; } return T_mus; } static int getNid(Lextok *n) { if (n->sym && n->sym->type == STRUCT && n->rgt && n->rgt->lft) return getNid(n->rgt->lft); if (!n->sym || n->sym->Nid == 0) { fatal("bad channel name '%s'", (n->sym)?n->sym->name:"no name"); } return n->sym->Nid; } static int valTpe(Lextok *n) { int res = 2; /* 2 = local 2+1 .. 2+1*DELTA = nfull, 's' - require q_full==false 2+1+1*DELTA .. 2+2*DELTA = nempty, 'r' - require q_len!=0 2+1+2*DELTA .. 2+3*DELTA = empty - require q_len==0 2+1+3*DELTA .. 2+4*DELTA = full - require q_full==true 5*DELTA = non-mixing (i.e., always makes the selection global) 6*DELTA = timeout (conditionally safe) 7*DELTA = @, process deletion (conditionally safe) */ switch (n->ntyp) { /* a series of fall-thru cases: */ case FULL: res += DELTA; /* add 3*DELTA + chan nr */ case EMPTY: res += DELTA; /* add 2*DELTA + chan nr */ case 'r': case NEMPTY: res += DELTA; /* add 1*DELTA + chan nr */ case 's': case NFULL: res += getNid(n->lft); /* add channel nr */ break; case TIMEOUT: res = 6*DELTA; break; case '@': res = 7*DELTA; break; default: break; } return res; } static void Tpe(Lextok *n) /* mixing in selections */ { EPT[0] = 2; EPT[1] = 0; if (!n) return; T_mus = 0; Nn[0] = Nn[1] = ZN; if (n->ntyp == 'c') { if (hidden(n->lft) > 2) { EPT[0] = 5*DELTA; /* non-mixing */ EPT[1] = 0; return; } } else Nn[0] = n; if (Nn[0]) EPT[0] = valTpe(Nn[0]); if (Nn[1]) EPT[1] = valTpe(Nn[1]); } static void put_escp(Element *e) { int n; SeqList *x; if (e->esc /* && e->n->ntyp != GOTO */ && e->n->ntyp != '.') { for (x = e->esc, n = 0; x; x = x->nxt, n++) { int i = huntele(x->this->frst, e->status, -1)->seqno; fprintf(tt, "\ttrans[%d][%d]->escp[%d] = %d;\n", Pid, e->seqno, n, i); fprintf(tt, "\treached%d[%d] = 1;\n", Pid, i); } for (x = e->esc, n=0; x; x = x->nxt, n++) { fprintf(tt, " /* escape #%d: %d */\n", n, huntele(x->this->frst, e->status, -1)->seqno); put_seq(x->this, 2, 0); /* args?? */ } fprintf(tt, " /* end-escapes */\n"); } } static void put_sub(Element *e, int Tt0, int Tt1) { Sequence *s = e->n->sl->this; Element *g = ZE; int a; patch_atomic(s); putskip(s->frst->seqno); g = huntstart(s->frst); a = g->seqno; if (0) printf("put_sub %d -> %d -> %d\n", e->seqno, s->frst->seqno, a); if ((e->n->ntyp == ATOMIC || e->n->ntyp == D_STEP) && scan_seq(s)) mark_seq(s); s->last->nxt = e->nxt; typ_seq(s); /* sets TPE */ if (e->n->ntyp == D_STEP) { int inherit = (e->status&(ATOM|L_ATOM)); fprintf(tm, "\tcase %d: ", uniq++); fprintf(tm, "// STATE %d - %s:%d - [", e->seqno, e->n->fn->name, e->n->ln); comment(tm, e->n, 0); fprintf(tm, "]\n\t\t"); if (s->last->n->ntyp == BREAK) OkBreak = target(huntele(s->last->nxt, s->last->status, -1))->Seqno; else OkBreak = -1; if (!putcode(tm, s, e->nxt, 0, e->n->ln, e->seqno)) { fprintf(tm, "\n#if defined(C_States) && (HAS_TRACK==1)\n"); fprintf(tm, "\t\tc_update((uchar *) &(now.c_state[0]));\n"); fprintf(tm, "#endif\n"); fprintf(tm, "\t\t_m = %d", getweight(s->frst->n)); if (m_loss && s->frst->n->ntyp == 's') fprintf(tm, "+delta_m; delta_m = 0"); fprintf(tm, "; goto P999;\n\n"); } fprintf(tb, "\tcase %d: ", uniq-1); fprintf(tb, "// STATE %d\n", e->seqno); fprintf(tb, "\t\tsv_restor();\n"); fprintf(tb, "\t\tgoto R999;\n"); if (e->nxt) a = huntele(e->nxt, e->status, -1)->seqno; else a = 0; tr_map(uniq-1, e); fprintf(tt, "/*->*/\ttrans[%d][%d]\t= ", Pid, e->seqno); fprintf(tt, "settr(%d,%d,%d,%d,%d,\"", e->Seqno, D_ATOM|inherit, a, uniq-1, uniq-1); comment(tt, e->n, e->seqno); fprintf(tt, "\", %d, ", (s->frst->status&I_GLOB)?1:0); fprintf(tt, "%d, %d);\n", TPE[0], TPE[1]); put_escp(e); } else { /* ATOMIC or NON_ATOMIC */ fprintf(tt, "\tT = trans[ %d][%d] = ", Pid, e->seqno); fprintf(tt, "settr(%d,%d,0,0,0,\"", e->Seqno, (e->n->ntyp == ATOMIC)?ATOM:0); comment(tt, e->n, e->seqno); if ((e->status&CHECK2) || (g->status&CHECK2)) s->frst->status |= I_GLOB; fprintf(tt, "\", %d, %d, %d);", (s->frst->status&I_GLOB)?1:0, Tt0, Tt1); blurb(tt, e); fprintf(tt, "\tT->nxt\t= "); fprintf(tt, "settr(%d,%d,%d,0,0,\"", e->Seqno, (e->n->ntyp == ATOMIC)?ATOM:0, a); comment(tt, e->n, e->seqno); fprintf(tt, "\", %d, ", (s->frst->status&I_GLOB)?1:0); if (e->n->ntyp == NON_ATOMIC) { fprintf(tt, "%d, %d);", Tt0, Tt1); blurb(tt, e); put_seq(s, Tt0, Tt1); } else { fprintf(tt, "%d, %d);", TPE[0], TPE[1]); blurb(tt, e); put_seq(s, TPE[0], TPE[1]); } } } typedef struct CaseCache { int m, b, owner; Element *e; Lextok *n; FSM_use *u; struct CaseCache *nxt; } CaseCache; static CaseCache *casing[6]; static int identical(Lextok *p, Lextok *q) { if ((!p && q) || (p && !q)) return 0; if (!p) return 1; if (p->ntyp != q->ntyp || p->ismtyp != q->ismtyp || p->val != q->val || p->indstep != q->indstep || p->sym != q->sym || p->sq != q->sq || p->sl != q->sl) return 0; return identical(p->lft, q->lft) && identical(p->rgt, q->rgt); } static int samedeads(FSM_use *a, FSM_use *b) { FSM_use *p, *q; for (p = a, q = b; p && q; p = p->nxt, q = q->nxt) if (p->var != q->var || p->special != q->special) return 0; return (!p && !q); } static Element * findnext(Element *f) { Element *g; if (f->n->ntyp == GOTO) { g = get_lab(f->n, 1); return huntele(g, f->status, -1); } return f->nxt; } static Element * advance(Element *e, int stopat) { Element *f = e; if (stopat) while (f && f->seqno != stopat) { f = findnext(f); if (!f) { break; } switch (f->n->ntyp) { case GOTO: case '.': case PRINT: case PRINTM: break; default: return f; } } return (Element *) 0; } static int equiv_merges(Element *a, Element *b) { Element *f, *g; int stopat_a, stopat_b; if (a->merge_start) stopat_a = a->merge_start; else stopat_a = a->merge; if (b->merge_start) stopat_b = b->merge_start; else stopat_b = b->merge; if (!stopat_a && !stopat_b) return 1; f = advance(a, stopat_a); g = advance(b, stopat_b); if (!f && !g) return 1; if (f && g) return identical(f->n, g->n); return 0; } static CaseCache * prev_case(Element *e, int owner) { int j; CaseCache *nc; switch (e->n->ntyp) { case 'r': j = 0; break; case 's': j = 1; break; case 'c': j = 2; break; case ASGN: j = 3; break; case ASSERT: j = 4; break; default: j = 5; break; } for (nc = casing[j]; nc; nc = nc->nxt) if (identical(nc->n, e->n) && samedeads(nc->u, e->dead) && equiv_merges(nc->e, e) && nc->owner == owner) return nc; return (CaseCache *) 0; } static void new_case(Element *e, int m, int b, int owner) { int j; CaseCache *nc; switch (e->n->ntyp) { case 'r': j = 0; break; case 's': j = 1; break; case 'c': j = 2; break; case ASGN: j = 3; break; case ASSERT: j = 4; break; default: j = 5; break; } nc = (CaseCache *) emalloc(sizeof(CaseCache)); nc->owner = owner; nc->m = m; nc->b = b; nc->e = e; nc->n = e->n; nc->u = e->dead; nc->nxt = casing[j]; casing[j] = nc; } static int nr_bup(Element *e) { FSM_use *u; Lextok *v; int nr = 0; switch (e->n->ntyp) { case ASGN: if (check_track(e->n) == STRUCT) { break; } nr++; break; case 'r': if (e->n->val >= 1) nr++; /* random recv */ for (v = e->n->rgt; v; v = v->rgt) { if ((v->lft->ntyp == CONST || v->lft->ntyp == EVAL)) continue; nr++; } break; default: break; } for (u = e->dead; u; u = u->nxt) { switch (u->special) { case 2: /* dead after write */ if (e->n->ntyp == ASGN && e->n->rgt->ntyp == CONST && e->n->rgt->val == 0) break; nr++; break; case 1: /* dead after read */ nr++; break; } } return nr; } static int nrhops(Element *e) { Element *f = e, *g; int cnt = 0; int stopat; if (e->merge_start) stopat = e->merge_start; else stopat = e->merge; #if 0 printf("merge: %d merge_start %d - seqno %d\n", e->merge, e->merge_start, e->seqno); #endif do { cnt += nr_bup(f); if (f->n->ntyp == GOTO) { g = get_lab(f->n, 1); if (g->seqno == stopat) f = g; else f = huntele(g, f->status, stopat); } else { f = f->nxt; } if (f && !f->merge && !f->merge_single && f->seqno != stopat) { fprintf(tm, "\n\t\t// bad hop %s:%d -- at %d, <", f->n->fn->name,f->n->ln, f->seqno); comment(tm, f->n, 0); fprintf(tm, "> looking for %d -- merge %d:%d:%d ", stopat, f->merge, f->merge_start, f->merge_single); break; } } while (f && f->seqno != stopat); return cnt; } static void check_needed(void) { if (multi_needed) { fprintf(tm, "(trpt+1)->bup.ovals = grab_ints(%d);\n\t\t", multi_needed); multi_undo = multi_needed; multi_needed = 0; } } static void doforward(FILE *tm_fd, Element *e) { FSM_use *u; putstmnt(tm_fd, e->n, e->seqno); if (e->n->ntyp != ELSE && Det) { fprintf(tm_fd, ";\n\t\tif (trpt->o_pm&1)\n\t\t"); fprintf(tm_fd, "\tuerror(\"non-determinism in D_proctype\")"); } if (deadvar && !has_code) for (u = e->dead; u; u = u->nxt) { fprintf(tm_fd, ";\n\t\t"); fprintf(tm_fd, "if (TstOnly) return 1; /* TT */\n"); fprintf(tm_fd, "\t\t/* dead %d: %s */ ", u->special, u->var->name); switch (u->special) { case 2: /* dead after write -- lval already bupped */ if (e->n->ntyp == ASGN) /* could be recv or asgn */ { if (e->n->rgt->ntyp == CONST && e->n->rgt->val == 0) continue; /* already set to 0 */ } if (e->n->ntyp != 'r') { XZ.sym = u->var; fprintf(tm_fd, "\n#ifdef HAS_CODE\n"); fprintf(tm_fd, "\t\tif (!readtrail)\n"); fprintf(tm_fd, "#endif\n\t\t\t"); putname(tm_fd, "", &XZ, 0, " = 0"); break; } /* else fall through */ case 1: /* dead after read -- add asgn of rval -- needs bup */ YZ[YZmax].sym = u->var; /* store for pan.b */ CnT[YZcnt]++; /* this step added bups */ if (multi_oval) { check_needed(); fprintf(tm_fd, "(trpt+1)->bup.ovals[%d] = ", multi_oval-1); multi_oval++; } else fprintf(tm_fd, "(trpt+1)->bup.oval = "); putname(tm_fd, "", &YZ[YZmax], 0, ";\n"); fprintf(tm_fd, "#ifdef HAS_CODE\n"); fprintf(tm_fd, "\t\tif (!readtrail)\n"); fprintf(tm_fd, "#endif\n\t\t\t"); putname(tm_fd, "", &YZ[YZmax], 0, " = 0"); YZmax++; break; } } fprintf(tm_fd, ";\n\t\t"); } static int dobackward(Element *e, int casenr) { if (!any_undo(e->n) && CnT[YZcnt] == 0) { YZcnt--; return 0; } if (!didcase) { fprintf(tb, "\n\tcase %d: ", casenr); fprintf(tb, "// STATE %d\n\t\t", e->seqno); didcase++; } _isok++; while (CnT[YZcnt] > 0) /* undo dead variable resets */ { CnT[YZcnt]--; YZmax--; if (YZmax < 0) fatal("cannot happen, dobackward", (char *)0); fprintf(tb, ";\n\t/* %d */\t", YZmax); putname(tb, "", &YZ[YZmax], 0, " = trpt->bup.oval"); if (multi_oval > 0) { multi_oval--; fprintf(tb, "s[%d]", multi_oval-1); } } if (e->n->ntyp != '.') { fprintf(tb, ";\n\t\t"); undostmnt(e->n, e->seqno); } _isok--; YZcnt--; return 1; } static void lastfirst(int stopat, Element *fin, int casenr) { Element *f = fin, *g; if (f->n->ntyp == GOTO) { g = get_lab(f->n, 1); if (g->seqno == stopat) f = g; else f = huntele(g, f->status, stopat); } else f = f->nxt; if (!f || f->seqno == stopat || (!f->merge && !f->merge_single)) return; lastfirst(stopat, f, casenr); #if 0 fprintf(tb, "\n\t/* merge %d -- %d:%d %d:%d:%d (casenr %d) ", YZcnt, f->merge_start, f->merge, f->seqno, f?f->seqno:-1, stopat, casenr); comment(tb, f->n, 0); fprintf(tb, " */\n"); fflush(tb); #endif dobackward(f, casenr); } static int modifier; static void lab_transfer(Element *to, Element *from) { Symbol *ns, *s = has_lab(from, (1|2|4)); Symbol *oc; int ltp, usedit=0; if (!s) return; /* "from" could have all three labels -- rename * to prevent jumps to the transfered copies */ oc = context; /* remember */ for (ltp = 1; ltp < 8; ltp *= 2) /* 1, 2, and 4 */ if ((s = has_lab(from, ltp)) != (Symbol *) 0) { ns = (Symbol *) emalloc(sizeof(Symbol)); ns->name = (char *) emalloc((int) strlen(s->name) + 4); sprintf(ns->name, "%s%d", s->name, modifier); context = s->context; set_lab(ns, to); usedit++; } context = oc; /* restore */ if (usedit) { if (modifier++ > 990) fatal("modifier overflow error", (char *) 0); } } static int case_cache(Element *e, int a) { int bupcase = 0, casenr = uniq, fromcache = 0; CaseCache *Cached = (CaseCache *) 0; Element *f, *g; int j, nrbups, mark, ntarget; extern int ccache; mark = (e->status&ATOM); /* could lose atomicity in a merge chain */ if (e->merge_mark > 0 || (merger && e->merge_in == 0)) { /* state nominally unreachable (part of merge chains) */ if (e->n->ntyp != '.' && e->n->ntyp != GOTO) { fprintf(tt, "\ttrans[%d][%d]\t= ", Pid, e->seqno); fprintf(tt, "settr(0,0,0,0,0,\""); comment(tt, e->n, e->seqno); fprintf(tt, "\",0,0,0);\n"); } else { fprintf(tt, "\ttrans[%d][%d]\t= ", Pid, e->seqno); casenr = 1; /* mhs example */ j = a; goto haveit; /* pakula's example */ } return -1; } fprintf(tt, "\ttrans[%d][%d]\t= ", Pid, e->seqno); if (ccache && !pid_is_claim(Pid) && Pid != eventmapnr && (Cached = prev_case(e, Pid))) { bupcase = Cached->b; casenr = Cached->m; fromcache = 1; fprintf(tm, "// STATE %d - %s:%d - [", e->seqno, e->n->fn->name, e->n->ln); comment(tm, e->n, 0); fprintf(tm, "] (%d:%d - %d) same as %d (%d:%d - %d)\n", e->merge_start, e->merge, e->merge_in, casenr, Cached->e->merge_start, Cached->e->merge, Cached->e->merge_in); goto gotit; } fprintf(tm, "\tcase %d: // STATE %d - %s:%d - [", uniq++, e->seqno, e->n->fn->name, e->n->ln); comment(tm, e->n, 0); nrbups = (e->merge || e->merge_start) ? nrhops(e) : nr_bup(e); fprintf(tm, "] (%d:%d:%d - %d)\n\t\t", e->merge_start, e->merge, nrbups, e->merge_in); if (nrbups > MAXMERGE-1) fatal("merge requires more than 256 bups", (char *)0); if (e->n->ntyp != 'r' && !pid_is_claim(Pid) && Pid != eventmapnr) fprintf(tm, "IfNotBlocked\n\t\t"); if (multi_needed != 0 || multi_undo != 0) fatal("cannot happen, case_cache", (char *) 0); if (nrbups > 1) { multi_oval = 1; multi_needed = nrbups; /* allocated after edge condition */ } else multi_oval = 0; memset(CnT, 0, sizeof(CnT)); YZmax = YZcnt = 0; /* new 4.2.6, revised 6.0.0 */ if (pid_is_claim(Pid)) { fprintf(tm, "\n#if defined(VERI) && !defined(NP)\n"); fprintf(tm, "#if NCLAIMS>1\n\t\t"); fprintf(tm, "{ static int reported%d = 0;\n\t\t", e->seqno); fprintf(tm, " if (verbose && !reported%d)\n\t\t", e->seqno); fprintf(tm, " { int nn = (int) ((Pclaim *)pptr(0))->_n;\n\t\t"); fprintf(tm, " printf(\"depth %%ld: Claim %%s (%%d), state %%d (line %%d)\\n\",\n\t\t"); fprintf(tm, " depth, procname[spin_c_typ[nn]], nn, "); fprintf(tm, "(int) ((Pclaim *)pptr(0))->_p, src_claim[ (int) ((Pclaim *)pptr(0))->_p ]);\n\t\t"); fprintf(tm, " reported%d = 1;\n\t\t", e->seqno); fprintf(tm, " fflush(stdout);\n\t\t"); fprintf(tm, "} }\n"); fprintf(tm, "#else\n\t\t"); fprintf(tm, "{ static int reported%d = 0;\n\t\t", e->seqno); fprintf(tm, " if (verbose && !reported%d)\n\t\t", e->seqno); fprintf(tm, " { printf(\"depth %%d: Claim, state %%d (line %%d)\\n\",\n\t\t"); fprintf(tm, " (int) depth, (int) ((Pclaim *)pptr(0))->_p, "); fprintf(tm, "src_claim[ (int) ((Pclaim *)pptr(0))->_p ]);\n\t\t"); fprintf(tm, " reported%d = 1;\n\t\t", e->seqno); fprintf(tm, " fflush(stdout);\n\t\t"); fprintf(tm, "} }\n"); fprintf(tm, "#endif\n"); fprintf(tm, "#endif\n\t\t"); } /* end */ /* the src xrefs have the numbers in e->seqno builtin */ fprintf(tm, "reached[%d][%d] = 1;\n\t\t", Pid, e->seqno); doforward(tm, e); if (e->merge_start) ntarget = e->merge_start; else ntarget = e->merge; if (ntarget) { f = e; more: if (f->n->ntyp == GOTO) { g = get_lab(f->n, 1); if (g->seqno == ntarget) f = g; else f = huntele(g, f->status, ntarget); } else f = f->nxt; if (f && f->seqno != ntarget) { if (!f->merge && !f->merge_single) { fprintf(tm, "/* stop at bad hop %d, %d */\n\t\t", f->seqno, ntarget); goto out; } fprintf(tm, "/* merge: "); comment(tm, f->n, 0); fprintf(tm, "(%d, %d, %d) */\n\t\t", f->merge, f->seqno, ntarget); fprintf(tm, "reached[%d][%d] = 1;\n\t\t", Pid, f->seqno); YZcnt++; lab_transfer(e, f); mark = f->status&(ATOM|L_ATOM); /* last step wins */ doforward(tm, f); if (f->merge_in == 1) f->merge_mark++; goto more; } } out: fprintf(tm, "_m = %d", getweight(e->n)); if (m_loss && e->n->ntyp == 's') fprintf(tm, "+delta_m; delta_m = 0"); fprintf(tm, "; goto P999; /* %d */\n", YZcnt); multi_needed = 0; didcase = 0; if (ntarget) lastfirst(ntarget, e, casenr); /* mergesteps only */ dobackward(e, casenr); /* the original step */ fprintf(tb, ";\n\t\t"); if (e->merge || e->merge_start) { if (!didcase) { fprintf(tb, "\n\tcase %d: ", casenr); fprintf(tb, "// STATE %d", e->seqno); didcase++; } else fprintf(tb, ";"); } else fprintf(tb, ";"); fprintf(tb, "\n\t\t"); if (multi_undo) { fprintf(tb, "ungrab_ints(trpt->bup.ovals, %d);\n\t\t", multi_undo); multi_undo = 0; } if (didcase) { fprintf(tb, "goto R999;\n"); bupcase = casenr; } if (!e->merge && !e->merge_start) new_case(e, casenr, bupcase, Pid); gotit: j = a; if (e->merge_start) j = e->merge_start; else if (e->merge) j = e->merge; haveit: fprintf(tt, "%ssettr(%d,%d,%d,%d,%d,\"", fromcache?"/* c */ ":"", e->Seqno, mark, j, casenr, bupcase); return (fromcache)?0:casenr; } static void put_el(Element *e, int Tt0, int Tt1) { int a, casenr, Global_ref; Element *g = ZE; if (e->n->ntyp == GOTO) { g = get_lab(e->n, 1); g = huntele(g, e->status, -1); cross_dsteps(e->n, g->n); a = g->seqno; } else if (e->nxt) { g = huntele(e->nxt, e->status, -1); a = g->seqno; } else a = 0; if (g && (g->status&CHECK2 /* entering remotely ref'd state */ || e->status&CHECK2)) /* leaving remotely ref'd state */ e->status |= I_GLOB; /* don't remove dead edges in here, to preserve structure of fsm */ if (e->merge_start || e->merge) goto non_generic; /*** avoid duplicate or redundant cases in pan.m ***/ switch (e->n->ntyp) { case ELSE: casenr = 2; /* standard else */ putskip(e->seqno); goto generic_case; /* break; */ case '.': case GOTO: case BREAK: putskip(e->seqno); casenr = 1; /* standard goto */ generic_case: fprintf(tt, "\ttrans[%d][%d]\t= ", Pid, e->seqno); fprintf(tt, "settr(%d,%d,%d,%d,0,\"", e->Seqno, e->status&ATOM, a, casenr); break; #ifndef PRINTF case PRINT: goto non_generic; case PRINTM: goto non_generic; #endif case 'c': if (e->n->lft->ntyp == CONST && e->n->lft->val == 1) /* skip or true */ { casenr = 1; putskip(e->seqno); goto generic_case; } goto non_generic; default: non_generic: casenr = case_cache(e, a); if (casenr < 0) return; /* unreachable state */ break; } /* tailend of settr(...); */ Global_ref = (e->status&I_GLOB)?1:has_global(e->n); comment(tt, e->n, e->seqno); fprintf(tt, "\", %d, ", Global_ref); if (Tt0 != 2) { fprintf(tt, "%d, %d);", Tt0, Tt1); } else { Tpe(e->n); /* sets EPT */ fprintf(tt, "%d, %d);", EPT[0], EPT[1]); } if ((e->merge_start && e->merge_start != a) || (e->merge && e->merge != a)) { fprintf(tt, " /* m: %d -> %d,%d */\n", a, e->merge_start, e->merge); fprintf(tt, " reached%d[%d] = 1;", Pid, a); /* Sheinman's example */ } fprintf(tt, "\n"); if (casenr > 2) tr_map(casenr, e); put_escp(e); } static void nested_unless(Element *e, Element *g) { struct SeqList *y = e->esc, *z = g->esc; for ( ; y && z; y = y->nxt, z = z->nxt) if (z->this != y->this) break; if (!y && !z) return; if (g->n->ntyp != GOTO && g->n->ntyp != '.' && e->sub->nxt) { printf("error: (%s:%d) saw 'unless' on a guard:\n", (e->n)?e->n->fn->name:"-", (e->n)?e->n->ln:0); printf("=====>instead of\n"); printf(" do (or if)\n"); printf(" :: ...\n"); printf(" :: stmnt1 unless stmnt2\n"); printf(" od (of fi)\n"); printf("=====>use\n"); printf(" do (or if)\n"); printf(" :: ...\n"); printf(" :: stmnt1\n"); printf(" od (or fi) unless stmnt2\n"); printf("=====>or rewrite\n"); } } static void put_seq(Sequence *s, int Tt0, int Tt1) { SeqList *h; Element *e, *g; int a, deadlink; if (0) printf("put_seq %d\n", s->frst->seqno); for (e = s->frst; e; e = e->nxt) { if (0) printf(" step %d\n", e->seqno); if (e->status & DONE) { if (0) printf(" done before\n"); goto checklast; } e->status |= DONE; if (e->n->ln) putsrc(e); if (e->n->ntyp == UNLESS) { if (0) printf(" an unless\n"); put_seq(e->sub->this, Tt0, Tt1); } else if (e->sub) { if (0) printf(" has sub\n"); fprintf(tt, "\tT = trans[%d][%d] = ", Pid, e->seqno); fprintf(tt, "settr(%d,%d,0,0,0,\"", e->Seqno, e->status&ATOM); comment(tt, e->n, e->seqno); if (e->status&CHECK2) e->status |= I_GLOB; fprintf(tt, "\", %d, %d, %d);", (e->status&I_GLOB)?1:0, Tt0, Tt1); blurb(tt, e); for (h = e->sub; h; h = h->nxt) { putskip(h->this->frst->seqno); g = huntstart(h->this->frst); if (g->esc) nested_unless(e, g); a = g->seqno; if (g->n->ntyp == 'c' && g->n->lft->ntyp == CONST && g->n->lft->val == 0 /* 0 or false */ && !g->esc) { fprintf(tt, "#if 0\n\t/* dead link: */\n"); deadlink = 1; if (verbose&32) printf("spin: %s:%d, warning, condition is always false\n", g->n->fn?g->n->fn->name:"", g->n->ln); } else deadlink = 0; if (0) printf(" settr %d %d\n", a, 0); if (h->nxt) fprintf(tt, "\tT = T->nxt\t= "); else fprintf(tt, "\t T->nxt\t= "); fprintf(tt, "settr(%d,%d,%d,0,0,\"", e->Seqno, e->status&ATOM, a); comment(tt, e->n, e->seqno); if (g->status&CHECK2) h->this->frst->status |= I_GLOB; fprintf(tt, "\", %d, %d, %d);", (h->this->frst->status&I_GLOB)?1:0, Tt0, Tt1); blurb(tt, e); if (deadlink) fprintf(tt, "#endif\n"); } for (h = e->sub; h; h = h->nxt) put_seq(h->this, Tt0, Tt1); } else { if (0) printf(" [non]atomic %d\n", e->n->ntyp); if (e->n->ntyp == ATOMIC || e->n->ntyp == D_STEP || e->n->ntyp == NON_ATOMIC) put_sub(e, Tt0, Tt1); else { if (0) printf(" put_el %d\n", e->seqno); put_el(e, Tt0, Tt1); } } checklast: if (e == s->last) break; } if (0) printf("put_seq done\n"); } static void patch_atomic(Sequence *s) /* catch goto's that break the chain */ { Element *f, *g; SeqList *h; for (f = s->frst; f ; f = f->nxt) { if (f->n && f->n->ntyp == GOTO) { g = get_lab(f->n,1); cross_dsteps(f->n, g->n); if ((f->status & (ATOM|L_ATOM)) && !(g->status & (ATOM|L_ATOM))) { f->status &= ~ATOM; f->status |= L_ATOM; } /* bridge atomics */ if ((f->status & L_ATOM) && (g->status & (ATOM|L_ATOM))) { f->status &= ~L_ATOM; f->status |= ATOM; } } else for (h = f->sub; h; h = h->nxt) patch_atomic(h->this); if (f == s->extent) break; } } static void mark_seq(Sequence *s) { Element *f; SeqList *h; for (f = s->frst; f; f = f->nxt) { f->status |= I_GLOB; if (f->n->ntyp == ATOMIC || f->n->ntyp == NON_ATOMIC || f->n->ntyp == D_STEP) mark_seq(f->n->sl->this); for (h = f->sub; h; h = h->nxt) mark_seq(h->this); if (f == s->last) return; } } static Element * find_target(Element *e) { Element *f; if (!e) return e; if (t_cyc++ > 32) { fatal("cycle of goto jumps", (char *) 0); } switch (e->n->ntyp) { case GOTO: f = get_lab(e->n,1); cross_dsteps(e->n, f->n); f = find_target(f); break; case BREAK: if (e->nxt) { f = find_target(huntele(e->nxt, e->status, -1)); break; /* new 5.0 -- was missing */ } /* else fall through */ default: f = e; break; } return f; } Element * target(Element *e) { if (!e) return e; lineno = e->n->ln; Fname = e->n->fn; t_cyc = 0; return find_target(e); } static int seq_has_el(Sequence *s, Element *g) /* new to version 5.0 */ { Element *f; SeqList *h; for (f = s->frst; f; f = f->nxt) /* g in same atomic? */ { if (f == g) { return 1; } if (f->status & CHECK3) { continue; } f->status |= CHECK3; /* protect against cycles */ for (h = f->sub; h; h = h->nxt) { if (h->this && seq_has_el(h->this, g)) { return 1; } } } return 0; } static int scan_seq(Sequence *s) { Element *f, *g; SeqList *h; for (f = s->frst; f; f = f->nxt) { if ((f->status&CHECK2) || has_global(f->n)) return 1; if (f->n->ntyp == GOTO /* may exit or reach other atomic */ && !(f->status & D_ATOM)) /* cannot jump from d_step */ { /* consider jump from an atomic without globals into * an atomic with globals * example by Claus Traulsen, 22 June 2007 */ g = target(f); #if 1 if (g && !seq_has_el(s, g)) /* not internal to this atomic/dstep */ #else if (g && !(f->status & L_ATOM) && !(g->status & (ATOM|L_ATOM))) #endif { fprintf(tt, "\t/* mark-down line %d status %d = %d */\n", f->n->ln, f->status, (f->status & D_ATOM)); return 1; /* assume worst case */ } } for (h = f->sub; h; h = h->nxt) if (scan_seq(h->this)) return 1; if (f == s->last) break; } return 0; } static int glob_args(Lextok *n) { int result = 0; Lextok *v; for (v = n->rgt; v; v = v->rgt) { if (v->lft->ntyp == CONST) continue; if (v->lft->ntyp == EVAL) result += has_global(v->lft->lft); else result += has_global(v->lft); } return result; } static int proc_is_safe(const Lextok *n) { ProcList *p; /* not safe unless no local var inits are used */ /* note that a local variable init could refer to a global */ for (p = rdy; p; p = p->nxt) { if (strcmp(n->sym->name, p->n->name) == 0) { /* printf("proc %s safety: %d\n", p->n->name, p->unsafe); */ return (p->unsafe != 0); } } /* non_fatal("bad call to proc_is_safe", (char *) 0); */ /* cannot happen */ return 0; } int has_global(Lextok *n) { Lextok *v; static Symbol *n_seen = (Symbol *) 0; if (!n) return 0; if (AllGlobal) return 1; /* global provided clause */ switch (n->ntyp) { case ATOMIC: case D_STEP: case NON_ATOMIC: return scan_seq(n->sl->this); case '.': case BREAK: case GOTO: case CONST: return 0; case ELSE: return n->val; /* true if combined with chan refs */ case 's': return glob_args(n)!=0 || ((n->sym->xu&(XS|XX)) != XS); case 'r': return glob_args(n)!=0 || ((n->sym->xu&(XR|XX)) != XR); case 'R': return glob_args(n)!=0 || (((n->sym->xu)&(XR|XS|XX)) != (XR|XS)); case NEMPTY: return ((n->sym->xu&(XR|XX)) != XR); case NFULL: return ((n->sym->xu&(XS|XX)) != XS); case FULL: return ((n->sym->xu&(XR|XX)) != XR); case EMPTY: return ((n->sym->xu&(XS|XX)) != XS); case LEN: return (((n->sym->xu)&(XR|XS|XX)) != (XR|XS)); case NAME: if (strcmp(n->sym->name, "_priority") == 0) { if (old_priority_rules) { if (n_seen != n->sym) fatal("cannot refer to _priority with -o6", (char *) 0); n_seen = n->sym; } return 0; } if (n->sym->context || (n->sym->hidden&64) || strcmp(n->sym->name, "_pid") == 0 || strcmp(n->sym->name, "_") == 0) return 0; return 1; case RUN: return proc_is_safe(n); case C_CODE: case C_EXPR: return glob_inline(n->sym->name); case ENABLED: case PC_VAL: case NONPROGRESS: case 'p': case 'q': case TIMEOUT: case SET_P: case GET_P: return 1; /* @ was 1 (global) since 2.8.5 in 3.0 it is considered local and conditionally safe, provided: II is the youngest process and nrprocs < MAXPROCS */ case '@': return 0; case '!': case UMIN: case '~': case ASSERT: return has_global(n->lft); case '/': case '*': case '-': case '+': case '%': case LT: case GT: case '&': case '^': case '|': case LE: case GE: case NE: case '?': case EQ: case OR: case AND: case LSHIFT: case RSHIFT: case 'c': case ASGN: return has_global(n->lft) || has_global(n->rgt); case PRINT: for (v = n->lft; v; v = v->rgt) if (has_global(v->lft)) return 1; return 0; case PRINTM: return has_global(n->lft); } return 0; } static void Bailout(FILE *fd, char *str) { if (!GenCode) { fprintf(fd, "continue%s", str); } else if (IsGuard) { fprintf(fd, "%s%s", NextLab[Level], str); } else { fprintf(fd, "Uerror(\"block in d_step seq\")%s", str); } } #define cat0(x) putstmnt(fd,now->lft,m); fprintf(fd, x); \ putstmnt(fd,now->rgt,m) #define cat1(x) fprintf(fd,"("); cat0(x); fprintf(fd,")") #define cat2(x,y) fprintf(fd,x); putstmnt(fd,y,m) #define cat3(x,y,z) fprintf(fd,x); putstmnt(fd,y,m); fprintf(fd,z) #define cat30(x,y,z) fprintf(fd,x,0); putstmnt(fd,y,m); fprintf(fd,z) void putstmnt(FILE *fd, Lextok *now, int m) { Lextok *v; int i, j; if (!now) { fprintf(fd, "0"); return; } lineno = now->ln; Fname = now->fn; switch (now->ntyp) { case CONST: fprintf(fd, "%d", now->val); break; case '!': cat3(" !(", now->lft, ")"); break; case UMIN: cat3(" -(", now->lft, ")"); break; case '~': cat3(" ~(", now->lft, ")"); break; case '/': cat1("/"); break; case '*': cat1("*"); break; case '-': cat1("-"); break; case '+': cat1("+"); break; case '%': cat1("%%"); break; case '&': cat1("&"); break; case '^': cat1("^"); break; case '|': cat1("|"); break; case LT: cat1("<"); break; case GT: cat1(">"); break; case LE: cat1("<="); break; case GE: cat1(">="); break; case NE: cat1("!="); break; case EQ: cat1("=="); break; case OR: cat1("||"); break; case AND: cat1("&&"); break; case LSHIFT: cat1("<<"); break; case RSHIFT: cat1(">>"); break; case TIMEOUT: if (separate == 2) fprintf(fd, "((tau)&1)"); else fprintf(fd, "((trpt->tau)&1)"); if (GenCode) printf("spin: %s:%d, warning, 'timeout' in d_step sequence\n", Fname->name, lineno); /* is okay as a guard */ break; case RUN: if (now->sym == NULL) fatal("internal error pangen2.c", (char *) 0); if (claimproc && strcmp(now->sym->name, claimproc) == 0) fatal("claim %s, (not runnable)", claimproc); if (eventmap && strcmp(now->sym->name, eventmap) == 0) fatal("eventmap %s, (not runnable)", eventmap); if (GenCode) fatal("'run' in d_step sequence (use atomic)", (char *)0); fprintf(fd,"addproc(II, %d, %d", (now->val > 0 && !old_priority_rules) ? now->val : 1, fproc(now->sym->name)); for (v = now->lft, i = 0; v; v = v->rgt, i++) { cat2(", ", v->lft); } check_param_count(i, now); if (i > Npars) { /* printf("\t%d parameters used, max %d expected\n", i, Npars); */ fatal("too many parameters in run %s(...)", now->sym->name); } for ( ; i < Npars; i++) fprintf(fd, ", 0"); fprintf(fd, ")"); #if 0 /* process now->sym->name has run priority now->val */ if (now->val > 0 && now->val < 256 && !old_priority_rules) { fprintf(fd, " && (((P0 *)pptr(now._nr_pr - 1))->_priority = %d)", now->val); } #endif if (now->val < 0 || now->val > 255) /* 0 itself is allowed */ { fatal("bad process in run %s, valid range: 1..255", now->sym->name); } break; case ENABLED: cat3("enabled(II, ", now->lft, ")"); break; case GET_P: if (old_priority_rules) { fprintf(fd, "1"); } else { cat3("get_priority(", now->lft, ")"); } break; case SET_P: if (!old_priority_rules) { fprintf(fd, "if (TstOnly) return 1; /* T30 */\n\t\t"); fprintf(fd, "set_priority("); putstmnt(fd, now->lft->lft, m); fprintf(fd, ", "); putstmnt(fd, now->lft->rgt, m); fprintf(fd, ")"); } break; case NONPROGRESS: /* o_pm&4=progress, tau&128=claim stutter */ if (separate == 2) fprintf(fd, "(!(o_pm&4) && !(tau&128))"); else fprintf(fd, "(!(trpt->o_pm&4) && !(trpt->tau&128))"); break; case PC_VAL: cat3("((P0 *) Pptr(", now->lft, "+BASE))->_p"); break; case LEN: if (!terse && !TestOnly && has_xu) { fprintf(fd, "\n#ifndef XUSAFE\n\t\t"); putname(fd, "(!(q_claim[", now->lft, m, "]&1) || "); putname(fd, "q_R_check(", now->lft, m, ""); fprintf(fd, ", II)) &&\n\t\t"); putname(fd, "(!(q_claim[", now->lft, m, "]&2) || "); putname(fd, "q_S_check(", now->lft, m, ", II)) &&"); fprintf(fd, "\n#endif\n\t\t"); } putname(fd, "q_len(", now->lft, m, ")"); break; case FULL: if (!terse && !TestOnly && has_xu) { fprintf(fd, "\n#ifndef XUSAFE\n\t\t"); putname(fd, "(!(q_claim[", now->lft, m, "]&1) || "); putname(fd, "q_R_check(", now->lft, m, ""); fprintf(fd, ", II)) &&\n\t\t"); putname(fd, "(!(q_claim[", now->lft, m, "]&2) || "); putname(fd, "q_S_check(", now->lft, m, ", II)) &&"); fprintf(fd, "\n#endif\n\t\t"); } putname(fd, "q_full(", now->lft, m, ")"); break; case EMPTY: if (!terse && !TestOnly && has_xu) { fprintf(fd, "\n#ifndef XUSAFE\n\t\t"); putname(fd, "(!(q_claim[", now->lft, m, "]&1) || "); putname(fd, "q_R_check(", now->lft, m, ""); fprintf(fd, ", II)) &&\n\t\t"); putname(fd, "(!(q_claim[", now->lft, m, "]&2) || "); putname(fd, "q_S_check(", now->lft, m, ", II)) &&"); fprintf(fd, "\n#endif\n\t\t"); } putname(fd, "(q_len(", now->lft, m, ")==0)"); break; case NFULL: if (!terse && !TestOnly && has_xu) { fprintf(fd, "\n#ifndef XUSAFE\n\t\t"); putname(fd, "(!(q_claim[", now->lft, m, "]&2) || "); putname(fd, "q_S_check(", now->lft, m, ", II)) &&"); fprintf(fd, "\n#endif\n\t\t"); } putname(fd, "(!q_full(", now->lft, m, "))"); break; case NEMPTY: if (!terse && !TestOnly && has_xu) { fprintf(fd, "\n#ifndef XUSAFE\n\t\t"); putname(fd, "(!(q_claim[", now->lft, m, "]&1) || "); putname(fd, "q_R_check(", now->lft, m, ", II)) &&"); fprintf(fd, "\n#endif\n\t\t"); } putname(fd, "(q_len(", now->lft, m, ")>0)"); break; case 's': if (Pid == eventmapnr) { fprintf(fd, "if ((II == -EVENT_TRACE && _tp != 's') "); putname(fd, "|| _qid+1 != ", now->lft, m, ""); for (v = now->rgt, i=0; v; v = v->rgt, i++) { if (v->lft->ntyp != CONST && v->lft->ntyp != EVAL) continue; fprintf(fd, " \\\n\t\t|| qrecv("); putname(fd, "", now->lft, m, ", "); putname(fd, "q_len(", now->lft, m, ")-1, "); fprintf(fd, "%d, 0) != ", i); if (v->lft->ntyp == CONST) putstmnt(fd, v->lft, m); else /* EVAL */ putstmnt(fd, v->lft->lft, m); } fprintf(fd, ")\n"); fprintf(fd, "\t\t continue"); putname(th, " || (x_y3_ == ", now->lft, m, ")"); break; } if (TestOnly) { if (m_loss) fprintf(fd, "1"); else putname(fd, "!q_full(", now->lft, m, ")"); break; } if (has_xu) { fprintf(fd, "\n#if !defined(XUSAFE) && !defined(NOREDUCE)\n\t\t"); putname(fd, "if (q_claim[", now->lft, m, "]&2)\n\t\t"); putname(fd, "{ q_S_check(", now->lft, m, ", II);\n\t\t"); fprintf(fd, "}\n"); if (has_sorted && now->val == 1) { putname(fd, "\t\tif (q_claim[", now->lft, m, "]&1)\n\t\t"); /* &1 iso &2 */ fprintf(fd, "{ uerror(\"sorted send on xr channel violates po reduction\");\n\t\t"); fprintf(fd, "}\n"); } fprintf(fd, "#endif\n\t\t"); } fprintf(fd, "if (q_%s", (u_sync > 0 && u_async == 0)?"len":"full"); putname(fd, "(", now->lft, m, "))\n"); if (m_loss) { fprintf(fd, "\t\t{ nlost++; delta_m = 1; } else {"); } else { fprintf(fd, "\t\t\t"); Bailout(fd, ";"); } if (has_enabled || has_priority) fprintf(fd, "\n\t\tif (TstOnly) return 1; /* T1 */"); if (u_sync && !u_async && rvopt) fprintf(fd, "\n\n\t\tif (no_recvs(II)) continue;\n"); fprintf(fd, "\n#ifdef HAS_CODE\n"); fprintf(fd, "\t\tif (readtrail && gui) {\n"); fprintf(fd, "\t\t\tchar simtmp[64];\n"); putname(fd, "\t\t\tsprintf(simvals, \"%%d!\", ", now->lft, m, ");\n"); _isok++; for (v = now->rgt, i = 0; v; v = v->rgt, i++) { cat3("\t\tsprintf(simtmp, \"%%d\", ", v->lft, "); strcat(simvals, simtmp);"); if (v->rgt) fprintf(fd, "\t\tstrcat(simvals, \",\");\n"); } _isok--; fprintf(fd, "\t\t}\n"); fprintf(fd, "#endif\n\t\t"); putname(fd, "\n\t\tqsend(", now->lft, m, ""); fprintf(fd, ", %d", now->val); for (v = now->rgt, i = 0; v; v = v->rgt, i++) { cat2(", ", v->lft); } if (i > Mpars) { terse++; putname(stdout, "channel name: ", now->lft, m, "\n"); terse--; printf(" %d msg parameters sent, %d expected\n", i, Mpars); fatal("too many pars in send", ""); } for (j = i; i < Mpars; i++) fprintf(fd, ", 0"); fprintf(fd, ", %d)", j); if (u_sync) { fprintf(fd, ";\n\t\t"); if (u_async) putname(fd, "if (q_zero(", now->lft, m, ")) "); putname(fd, "{ boq = ", now->lft, m, ""); if (GenCode) fprintf(fd, "; Uerror(\"rv-attempt in d_step\")"); fprintf(fd, "; }"); } if (m_loss) fprintf(fd, ";\n\t\t}\n\t\t"); /* end of m_loss else */ break; case 'r': if (Pid == eventmapnr) { fprintf(fd, "if ((II == -EVENT_TRACE && _tp != 'r') "); putname(fd, "|| _qid+1 != ", now->lft, m, ""); for (v = now->rgt, i=0; v; v = v->rgt, i++) { if (v->lft->ntyp != CONST && v->lft->ntyp != EVAL) continue; fprintf(fd, " \\\n\t\t|| qrecv("); putname(fd, "", now->lft, m, ", "); fprintf(fd, "0, %d, 0) != ", i); if (v->lft->ntyp == CONST) putstmnt(fd, v->lft, m); else /* EVAL */ putstmnt(fd, v->lft->lft, m); } fprintf(fd, ")\n"); fprintf(fd, "\t\t continue"); putname(tc, " || (x_y3_ == ", now->lft, m, ")"); break; } if (TestOnly) { fprintf(fd, "(("); if (u_sync) fprintf(fd, "(boq == -1 && "); putname(fd, "q_len(", now->lft, m, ")"); if (u_sync && now->val <= 1) { putname(fd, ") || (boq == ", now->lft,m," && "); putname(fd, "q_zero(", now->lft,m,"))"); } fprintf(fd, ")"); if (now->val == 0 || now->val == 2) { for (v = now->rgt, i=j=0; v; v = v->rgt, i++) { if (v->lft->ntyp == CONST) { cat3("\n\t\t&& (", v->lft, " == "); putname(fd, "qrecv(", now->lft, m, ", "); fprintf(fd, "0, %d, 0))", i); } else if (v->lft->ntyp == EVAL) { cat3("\n\t\t&& (", v->lft->lft, " == "); putname(fd, "qrecv(", now->lft, m, ", "); fprintf(fd, "0, %d, 0))", i); } else { j++; continue; } } } else { fprintf(fd, "\n\t\t&& Q_has("); putname(fd, "", now->lft, m, ""); for (v = now->rgt, i=0; v; v = v->rgt, i++) { if (v->lft->ntyp == CONST) { fprintf(fd, ", 1, "); putstmnt(fd, v->lft, m); } else if (v->lft->ntyp == EVAL) { fprintf(fd, ", 1, "); putstmnt(fd, v->lft->lft, m); } else { fprintf(fd, ", 0, 0"); } } for ( ; i < Mpars; i++) fprintf(fd, ", 0, 0"); fprintf(fd, ")"); } fprintf(fd, ")"); break; } if (has_xu) { fprintf(fd, "\n#if !defined(XUSAFE) && !defined(NOREDUCE)\n\t\t"); putname(fd, "if (q_claim[", now->lft, m, "]&1)\n\t\t"); putname(fd, "{ q_R_check(", now->lft, m, ", II);\n\t\t"); if (has_random && now->val != 0) fprintf(fd, " uerror(\"rand receive on xr channel violates po reduction\");\n\t\t"); fprintf(fd, "}\n"); fprintf(fd, "#endif\n\t\t"); } if (u_sync) { if (now->val >= 2) { if (u_async) { fprintf(fd, "if ("); putname(fd, "q_zero(", now->lft,m,"))"); fprintf(fd, "\n\t\t{\t"); } fprintf(fd, "uerror(\"polling "); fprintf(fd, "rv chan\");\n\t\t"); if (u_async) fprintf(fd, " continue;\n\t\t}\n\t\t"); fprintf(fd, "IfNotBlocked\n\t\t"); } else { fprintf(fd, "if ("); if (u_async == 0) putname(fd, "boq != ", now->lft,m,") "); else { putname(fd, "q_zero(", now->lft,m,"))"); fprintf(fd, "\n\t\t{\tif (boq != "); putname(fd, "", now->lft,m,") "); Bailout(fd, ";\n\t\t} else\n\t\t"); fprintf(fd, "{\tif (boq != -1) "); } Bailout(fd, ";\n\t\t"); if (u_async) fprintf(fd, "}\n\t\t"); } } putname(fd, "if (q_len(", now->lft, m, ") == 0) "); Bailout(fd, ""); for (v = now->rgt, j=0; v; v = v->rgt) { if (v->lft->ntyp != CONST && v->lft->ntyp != EVAL) j++; /* count settables */ } fprintf(fd, ";\n\n\t\tXX=1"); /* test */ if (now->val == 0 || now->val == 2) { for (v = now->rgt, i=0; v; v = v->rgt, i++) { if (v->lft->ntyp == CONST) { fprintf(fd, ";\n\t\t"); cat3("if (", v->lft, " != "); putname(fd, "qrecv(", now->lft, m, ", "); fprintf(fd, "0, %d, 0)) ", i); Bailout(fd, ""); } else if (v->lft->ntyp == EVAL) { fprintf(fd, ";\n\t\t"); cat3("if (", v->lft->lft, " != "); putname(fd, "qrecv(", now->lft, m, ", "); fprintf(fd, "0, %d, 0)) ", i); Bailout(fd, ""); } } if (has_enabled || has_priority) fprintf(fd, ";\n\t\tif (TstOnly) return 1 /* T2 */"); } else /* random receive: val 1 or 3 */ { fprintf(fd, ";\n\t\tif (!(XX = Q_has("); putname(fd, "", now->lft, m, ""); for (v = now->rgt, i=0; v; v = v->rgt, i++) { if (v->lft->ntyp == CONST) { fprintf(fd, ", 1, "); putstmnt(fd, v->lft, m); } else if (v->lft->ntyp == EVAL) { fprintf(fd, ", 1, "); putstmnt(fd, v->lft->lft, m); } else { fprintf(fd, ", 0, 0"); } } for ( ; i < Mpars; i++) fprintf(fd, ", 0, 0"); fprintf(fd, "))) "); Bailout(fd, ""); if (has_enabled || has_priority) fprintf(fd, ";\n\t\tif (TstOnly) return 1 /* T2 */"); if (!GenCode) { fprintf(fd, ";\n\t\t"); if (multi_oval) { check_needed(); fprintf(fd, "(trpt+1)->bup.ovals[%d] = ", multi_oval-1); multi_oval++; } else { fprintf(fd, "(trpt+1)->bup.oval = "); } fprintf(fd, "XX"); } } if (j == 0 && now->val >= 2) { fprintf(fd, ";\n\t\t"); break; /* poll without side-effect */ } if (!GenCode) { int jj = 0; fprintf(fd, ";\n\t\t"); /* no variables modified */ if (j == 0 && now->val == 0) { fprintf(fd, "if (q_flds[((Q0 *)qptr("); putname(fd, "", now->lft, m, "-1))->_t]"); fprintf(fd, " != %d)\n\t", i); fprintf(fd, "\t\tUerror(\"wrong nr of msg fields in rcv\");\n\t\t"); } for (v = now->rgt; v; v = v->rgt) if ((v->lft->ntyp != CONST && v->lft->ntyp != EVAL)) jj++; /* nr of vars needing bup */ if (jj) for (v = now->rgt, i = 0; v; v = v->rgt, i++) { char tempbuf[64]; if ((v->lft->ntyp == CONST || v->lft->ntyp == EVAL)) continue; if (multi_oval) { check_needed(); sprintf(tempbuf, "(trpt+1)->bup.ovals[%d] = ", multi_oval-1); multi_oval++; } else sprintf(tempbuf, "(trpt+1)->bup.oval = "); if (v->lft->sym && !strcmp(v->lft->sym->name, "_")) { fprintf(fd, tempbuf, (char *) 0); putname(fd, "qrecv(", now->lft, m, ""); fprintf(fd, ", XX-1, %d, 0);\n\t\t", i); } else { _isok++; cat30(tempbuf, v->lft, ";\n\t\t"); _isok--; } } if (jj) /* check for double entries q?x,x */ { Lextok *w; for (v = now->rgt; v; v = v->rgt) { if (v->lft->ntyp != CONST && v->lft->ntyp != EVAL && v->lft->sym && v->lft->sym->type != STRUCT /* not a struct */ && (v->lft->sym->nel == 1 && v->lft->sym->isarray == 0) /* not array */ && strcmp(v->lft->sym->name, "_") != 0) for (w = v->rgt; w; w = w->rgt) if (v->lft->sym == w->lft->sym) { fatal("cannot use var ('%s') in multiple msg fields", v->lft->sym->name); } } } } /* set */ for (v = now->rgt, i = 0; v; v = v->rgt, i++) { if ((v->lft->ntyp == CONST || v->lft->ntyp == EVAL) && v->rgt) continue; fprintf(fd, ";\n\t\t"); if (v->lft->ntyp != CONST && v->lft->ntyp != EVAL && v->lft->sym != NULL && strcmp(v->lft->sym->name, "_") != 0) { nocast=1; _isok++; putstmnt(fd, v->lft, m); _isok--; nocast=0; fprintf(fd, " = "); } putname(fd, "qrecv(", now->lft, m, ", "); fprintf(fd, "XX-1, %d, ", i); fprintf(fd, "%d)", (v->rgt || now->val >= 2)?0:1); if (v->lft->ntyp != CONST && v->lft->ntyp != EVAL && v->lft->sym != NULL && strcmp(v->lft->sym->name, "_") != 0 && (v->lft->ntyp != NAME || v->lft->sym->type != CHAN)) { fprintf(fd, ";\n#ifdef VAR_RANGES"); fprintf(fd, "\n\t\tlogval(\""); withprocname = terse = nocast = 1; _isok++; putstmnt(fd,v->lft,m); withprocname = terse = nocast = 0; fprintf(fd, "\", "); putstmnt(fd,v->lft,m); _isok--; fprintf(fd, ");\n#endif\n"); fprintf(fd, "\t\t"); } } fprintf(fd, ";\n\t\t"); fprintf(fd, "\n#ifdef HAS_CODE\n"); fprintf(fd, "\t\tif (readtrail && gui) {\n"); fprintf(fd, "\t\t\tchar simtmp[32];\n"); putname(fd, "\t\t\tsprintf(simvals, \"%%d?\", ", now->lft, m, ");\n"); _isok++; for (v = now->rgt, i = 0; v; v = v->rgt, i++) { if (v->lft->ntyp != EVAL) { cat3("\t\tsprintf(simtmp, \"%%d\", ", v->lft, "); strcat(simvals, simtmp);"); } else { cat3("\t\tsprintf(simtmp, \"%%d\", ", v->lft->lft, "); strcat(simvals, simtmp);"); } if (v->rgt) fprintf(fd, "\t\tstrcat(simvals, \",\");\n"); } _isok--; fprintf(fd, "\t\t}\n"); fprintf(fd, "#endif\n\t\t"); if (u_sync) { putname(fd, "if (q_zero(", now->lft, m, "))"); fprintf(fd, "\n\t\t{ boq = -1;\n"); fprintf(fd, "#ifndef NOFAIR\n"); /* NEW 3.0.8 */ fprintf(fd, "\t\t\tif (fairness\n"); fprintf(fd, "\t\t\t&& !(trpt->o_pm&32)\n"); fprintf(fd, "\t\t\t&& (now._a_t&2)\n"); fprintf(fd, "\t\t\t&& now._cnt[now._a_t&1] == II+2)\n"); fprintf(fd, "\t\t\t{ now._cnt[now._a_t&1] -= 1;\n"); fprintf(fd, "#ifdef VERI\n"); fprintf(fd, "\t\t\t if (II == 1)\n"); fprintf(fd, "\t\t\t now._cnt[now._a_t&1] = 1;\n"); fprintf(fd, "#endif\n"); fprintf(fd, "#ifdef DEBUG\n"); fprintf(fd, "\t\t\tprintf(\"%%3d: proc %%d fairness \", depth, II);\n"); fprintf(fd, "\t\t\tprintf(\"Rule 2: --cnt to %%d (%%d)\\n\",\n"); fprintf(fd, "\t\t\t now._cnt[now._a_t&1], now._a_t);\n"); fprintf(fd, "#endif\n"); fprintf(fd, "\t\t\t trpt->o_pm |= (32|64);\n"); fprintf(fd, "\t\t\t}\n"); fprintf(fd, "#endif\n"); fprintf(fd, "\n\t\t}"); } break; case 'R': if (!terse && !TestOnly && has_xu) { fprintf(fd, "\n#ifndef XUSAFE\n\t\t"); putname(fd, "(!(q_claim[", now->lft, m, "]&1) || "); fprintf(fd, "q_R_check("); putname(fd, "", now->lft, m, ", II)) &&\n\t\t"); putname(fd, "(!(q_claim[", now->lft, m, "]&2) || "); putname(fd, "q_S_check(", now->lft, m, ", II)) &&"); fprintf(fd, "\n#endif\n\t\t"); } if (u_sync>0) putname(fd, "not_RV(", now->lft, m, ") && \\\n\t\t"); for (v = now->rgt, i=j=0; v; v = v->rgt, i++) if (v->lft->ntyp != CONST && v->lft->ntyp != EVAL) { j++; continue; } if (now->val == 0 || i == j) { putname(fd, "(q_len(", now->lft, m, ") > 0"); for (v = now->rgt, i=0; v; v = v->rgt, i++) { if (v->lft->ntyp != CONST && v->lft->ntyp != EVAL) continue; fprintf(fd, " \\\n\t\t&& qrecv("); putname(fd, "", now->lft, m, ", "); fprintf(fd, "0, %d, 0) == ", i); if (v->lft->ntyp == CONST) putstmnt(fd, v->lft, m); else /* EVAL */ putstmnt(fd, v->lft->lft, m); } fprintf(fd, ")"); } else { putname(fd, "Q_has(", now->lft, m, ""); for (v = now->rgt, i=0; v; v = v->rgt, i++) { if (v->lft->ntyp == CONST) { fprintf(fd, ", 1, "); putstmnt(fd, v->lft, m); } else if (v->lft->ntyp == EVAL) { fprintf(fd, ", 1, "); putstmnt(fd, v->lft->lft, m); } else fprintf(fd, ", 0, 0"); } for ( ; i < Mpars; i++) fprintf(fd, ", 0, 0"); fprintf(fd, ")"); } break; case 'c': preruse(fd, now->lft); /* preconditions */ cat3("if (!(", now->lft, "))\n\t\t\t"); Bailout(fd, ""); break; case ELSE: if (!GenCode) { if (separate == 2) fprintf(fd, "if (o_pm&1)\n\t\t\t"); else fprintf(fd, "if (trpt->o_pm&1)\n\t\t\t"); Bailout(fd, ""); } else { fprintf(fd, "/* else */"); } break; case '?': if (now->lft) { cat3("( (", now->lft, ") ? "); } if (now->rgt) { cat3("(", now->rgt->lft, ") : "); cat3("(", now->rgt->rgt, ") )"); } break; case ASGN: if (check_track(now) == STRUCT) { break; } if (has_enabled || has_priority) fprintf(fd, "if (TstOnly) return 1; /* T3 */\n\t\t"); _isok++; if (!GenCode) { if (multi_oval) { char tempbuf[64]; check_needed(); sprintf(tempbuf, "(trpt+1)->bup.ovals[%d] = ", multi_oval-1); multi_oval++; cat30(tempbuf, now->lft, ";\n\t\t"); } else { cat3("(trpt+1)->bup.oval = ", now->lft, ";\n\t\t"); } } if (now->lft->sym && now->lft->sym->type == PREDEF && strcmp(now->lft->sym->name, "_") != 0 && strcmp(now->lft->sym->name, "_priority") != 0) { fatal("invalid assignment to %s", now->lft->sym->name); } nocast = 1; putstmnt(fd,now->lft,m); nocast = 0; fprintf(fd," = "); _isok--; if (now->lft->sym->isarray && now->rgt->ntyp == ',') /* array initializer */ { putstmnt(fd, now->rgt->lft, m); non_fatal("cannot use an array list initializer here", (char *) 0); } else { putstmnt(fd, now->rgt, m); } if (now->sym->type != CHAN || verbose > 0) { fprintf(fd, ";\n#ifdef VAR_RANGES"); fprintf(fd, "\n\t\tlogval(\""); withprocname = terse = nocast = 1; _isok++; putstmnt(fd,now->lft,m); withprocname = terse = nocast = 0; fprintf(fd, "\", "); putstmnt(fd,now->lft,m); _isok--; fprintf(fd, ");\n#endif\n"); fprintf(fd, "\t\t"); } break; case PRINT: if (has_enabled || has_priority) fprintf(fd, "if (TstOnly) return 1; /* T4 */\n\t\t"); #ifdef PRINTF fprintf(fd, "printf(%s", now->sym->name); #else fprintf(fd, "Printf(%s", now->sym->name); #endif for (v = now->lft; v; v = v->rgt) { cat2(", ", v->lft); } fprintf(fd, ")"); break; case PRINTM: if (has_enabled || has_priority) fprintf(fd, "if (TstOnly) return 1; /* T5 */\n\t\t"); fprintf(fd, "printm("); if (now->lft && now->lft->ismtyp) fprintf(fd, "%d", now->lft->val); else putstmnt(fd, now->lft, m); fprintf(fd, ")"); break; case NAME: if (!nocast && now->sym && Sym_typ(now) < SHORT) putname(fd, "((int)", now, m, ")"); else putname(fd, "", now, m, ""); break; case 'p': putremote(fd, now, m); break; case 'q': if (terse) fprintf(fd, "%s", now->sym?now->sym->name:"?"); else fprintf(fd, "%d", remotelab(now)); break; case C_EXPR: fprintf(fd, "("); plunk_expr(fd, now->sym->name); #if 1 fprintf(fd, ")"); #else fprintf(fd, ") /* %s */ ", now->sym->name); #endif break; case C_CODE: if (now->sym) fprintf(fd, "/* %s */\n\t\t", now->sym->name); if (has_enabled || has_priority) fprintf(fd, "if (TstOnly) return 1; /* T6 */\n\t\t"); if (now->sym) plunk_inline(fd, now->sym->name, 1, GenCode); else fatal("internal error pangen2.c", (char *) 0); if (!GenCode) { fprintf(fd, "\n"); /* state changed, capture it */ fprintf(fd, "#if defined(C_States) && (HAS_TRACK==1)\n"); fprintf(fd, "\t\tc_update((uchar *) &(now.c_state[0]));\n"); fprintf(fd, "#endif\n"); } break; case ASSERT: if (has_enabled || has_priority) fprintf(fd, "if (TstOnly) return 1; /* T7 */\n\t\t"); cat3("spin_assert(", now->lft, ", "); terse = nocast = 1; cat3("\"", now->lft, "\", II, tt, t)"); terse = nocast = 0; break; case '.': case BREAK: case GOTO: if (Pid == eventmapnr) fprintf(fd, "Uerror(\"cannot get here\")"); putskip(m); break; case '@': if (Pid == eventmapnr) { fprintf(fd, "return 0"); break; } if (has_enabled || has_priority) { fprintf(fd, "if (TstOnly)\n\t\t\t"); fprintf(fd, "return (II+1 == now._nr_pr);\n\t\t"); } fprintf(fd, "if (!delproc(1, II)) "); Bailout(fd, ""); break; default: printf("spin: error, %s:%d, bad node type %d (.m)\n", now->fn->name, now->ln, now->ntyp); fflush(fd); alldone(1); } } char * simplify_name(char *s) { char *t = s; if (!old_scope_rules) { while (*t == '_' || isdigit((int)*t)) { t++; } } return t; } void putname(FILE *fd, char *pre, Lextok *n, int m, char *suff) /* varref */ { Symbol *s = n->sym; char *ptr; lineno = n->ln; Fname = n->fn; if (!s) fatal("no name - putname", (char *) 0); if (s->context && context && s->type) s = findloc(s); /* it's a local var */ if (!s) { fprintf(fd, "%s%s%s", pre, n->sym->name, suff); return; } if (!s->type) /* not a local name */ s = lookup(s->name); /* must be a global */ if (!s->type) { if (strcmp(pre, ".") != 0) fatal("undeclared variable '%s'", s->name); s->type = INT; } if (s->type == PROCTYPE) fatal("proctype-name '%s' used as array-name", s->name); fprintf(fd, pre, 0); if (!terse && !s->owner && evalindex != 1) { if (old_priority_rules && strcmp(s->name, "_priority") == 0) { fprintf(fd, "1"); goto shortcut; } else { if (s->context || strcmp(s->name, "_p") == 0 || strcmp(s->name, "_pid") == 0 || strcmp(s->name, "_priority") == 0) { fprintf(fd, "((P%d *)this)->", Pid); } else { int x = strcmp(s->name, "_"); if (!(s->hidden&1) && x != 0) fprintf(fd, "now."); if (x == 0 && _isok == 0) fatal("attempt to read value of '_'", 0); } } } if (terse && buzzed == 1) { fprintf(fd, "B_state.%s", (s->context)?"local[B_pid].":""); } ptr = s->name; if (!dont_simplify /* new 6.4.3 */ && s->type != PREDEF) /* new 6.0.2 */ { if (withprocname && s->context && strcmp(pre, ".")) { fprintf(fd, "%s:", s->context->name); ptr = simplify_name(ptr); } else { if (terse) { ptr = simplify_name(ptr); } } } if (evalindex != 1) fprintf(fd, "%s", ptr); if (s->nel > 1 || s->isarray == 1) { if (no_arrays) { non_fatal("ref to array element invalid in this context", (char *)0); printf("\thint: instead of, e.g., x[rs] qu[3], use\n"); printf("\tchan nm_3 = qu[3]; x[rs] nm_3;\n"); printf("\tand use nm_3 in sends/recvs instead of qu[3]\n"); } /* an xr or xs reference to an array element * becomes an exclusion tag on the array itself - * which could result in invalidly labeling * operations on other elements of this array to * be also safe under the partial order reduction * (see procedure has_global()) */ if (evalindex == 2) { fprintf(fd, "[%%d]"); } else if (evalindex == 1) { evalindex = 0; /* no good if index is indexed array */ fprintf(fd, ", "); putstmnt(fd, n->lft, m); evalindex = 1; } else { if (terse || (n->lft && n->lft->ntyp == CONST && n->lft->val < s->nel) || (!n->lft && s->nel > 0)) { cat3("[", n->lft, "]"); } else { /* attempt to catch arrays that are indexed with an array element in the same array * this causes trouble in the verifier in the backtracking * e.g., restoring a[?] in the assignment: a [a[1]] = x where a[1] == 1 * but it is hard when the array is inside a structure, so the names dont match */ #if 0 if (n->lft->ntyp == NAME) { printf("%4d: Basename %s index %s\n", n->lft->ln, s->name, n->lft->sym->name); } #endif cat3("[ Index(", n->lft, ", "); fprintf(fd, "%d) ]", s->nel); } } } else { if (n->lft /* effectively a scalar, but with an index */ && (n->lft->ntyp != CONST || n->lft->val != 0)) { fatal("ref to scalar '%s' using array index", (char *) ptr); } } if (s->type == STRUCT && n->rgt && n->rgt->lft) { putname(fd, ".", n->rgt->lft, m, ""); } shortcut: fprintf(fd, suff, 0); } void putremote(FILE *fd, Lextok *n, int m) /* remote reference */ { int promoted = 0; int pt; if (terse) { fprintf(fd, "%s", n->lft->sym->name); /* proctype name */ if (n->lft->lft) { fprintf(fd, "["); putstmnt(fd, n->lft->lft, m); /* pid */ fprintf(fd, "]"); } if (ltl_mode) { fprintf(fd, ":%s", n->sym->name); } else { fprintf(fd, ".%s", n->sym->name); } } else { if (Sym_typ(n) < SHORT) { promoted = 1; fprintf(fd, "((int)"); } pt = fproc(n->lft->sym->name); fprintf(fd, "((P%d *)Pptr(", pt); if (n->lft->lft) { fprintf(fd, "BASE+"); putstmnt(fd, n->lft->lft, m); } else fprintf(fd, "f_pid(%d)", pt); fprintf(fd, "))->%s", n->sym->name); } if (n->rgt) { fprintf(fd, "["); putstmnt(fd, n->rgt, m); /* array var ref */ fprintf(fd, "]"); } if (promoted) fprintf(fd, ")"); } static int getweight(Lextok *n) { /* this piece of code is a remnant of early versions * of the verifier -- in the current version of Spin * only non-zero values matter - so this could probably * simply return 1 in all cases. */ switch (n->ntyp) { case 'r': return 4; case 's': return 2; case TIMEOUT: return 1; case 'c': if (has_typ(n->lft, TIMEOUT)) return 1; } return 3; } int has_typ(Lextok *n, int m) { if (!n) return 0; if (n->ntyp == m) return 1; return (has_typ(n->lft, m) || has_typ(n->rgt, m)); } static int runcount, opcount; static void do_count(Lextok *n, int checkop) { if (!n) return; switch (n->ntyp) { case RUN: runcount++; break; default: if (checkop) opcount++; break; } do_count(n->lft, checkop && (n->ntyp != RUN)); do_count(n->rgt, checkop); } void count_runs(Lextok *n) { runcount = opcount = 0; do_count(n, 1); if (runcount > 1) fatal("more than one run operator in expression", ""); if (runcount == 1 && opcount > 1) fatal("use of run operator in compound expression", ""); } void any_runs(Lextok *n) { runcount = opcount = 0; do_count(n, 0); if (runcount >= 1) fatal("run operator used in invalid context", ""); } Spin/Src6.4.5/tl_trans.c0000664000175100017510000004121512641605057012676 0ustar ghgh/***** tl_spin: tl_trans.c *****/ /* * This file is part of the public release of Spin. It is subject to the * terms in the LICENSE file that is included in this source directory. * Tool documentation is available at http://spinroot.com * * Based on the translation algorithm by Gerth, Peled, Vardi, and Wolper, * presented at the PSTV Conference, held in 1995, Warsaw, Poland 1995. */ #include "tl.h" extern FILE *tl_out; extern int tl_errs, tl_verbose, tl_terse, newstates, state_cnt; int Stack_mx=0, Max_Red=0, Total=0; static Mapping *Mapped = (Mapping *) 0; static Graph *Nodes_Set = (Graph *) 0; static Graph *Nodes_Stack = (Graph *) 0; static char dumpbuf[4096]; static int Red_cnt = 0; static int Lab_cnt = 0; static int Base = 0; static int Stack_sz = 0; static Graph *findgraph(char *); static Graph *pop_stack(void); static Node *Duplicate(Node *); static Node *flatten(Node *); static Symbol *catSlist(Symbol *, Symbol *); static Symbol *dupSlist(Symbol *); static char *newname(void); static int choueka(Graph *, int); static int not_new(Graph *); static int set_prefix(char *, int, Graph *); static void Addout(char *, char *); static void fsm_trans(Graph *, int, char *); static void mkbuchi(void); static void expand_g(Graph *); static void fixinit(Node *); static void liveness(Node *); static void mk_grn(Node *); static void mk_red(Node *); static void ng(Symbol *, Symbol *, Node *, Node *, Node *); static void push_stack(Graph *); static void sdump(Node *); void ini_trans(void) { Stack_mx = 0; Max_Red = 0; Total = 0; Mapped = (Mapping *) 0; Nodes_Set = (Graph *) 0; Nodes_Stack = (Graph *) 0; memset(dumpbuf, 0, sizeof(dumpbuf)); Red_cnt = 0; Lab_cnt = 0; Base = 0; Stack_sz = 0; } static void dump_graph(Graph *g) { Node *n1; printf("\n\tnew:\t"); for (n1 = g->New; n1; n1 = n1->nxt) { dump(n1); printf(", "); } printf("\n\told:\t"); for (n1 = g->Old; n1; n1 = n1->nxt) { dump(n1); printf(", "); } printf("\n\tnxt:\t"); for (n1 = g->Next; n1; n1 = n1->nxt) { dump(n1); printf(", "); } printf("\n\tother:\t"); for (n1 = g->Other; n1; n1 = n1->nxt) { dump(n1); printf(", "); } printf("\n"); } static void push_stack(Graph *g) { if (!g) return; g->nxt = Nodes_Stack; Nodes_Stack = g; if (tl_verbose) { Symbol *z; printf("\nPush %s, from ", g->name->name); for (z = g->incoming; z; z = z->next) printf("%s, ", z->name); dump_graph(g); } Stack_sz++; if (Stack_sz > Stack_mx) Stack_mx = Stack_sz; } static Graph * pop_stack(void) { Graph *g = Nodes_Stack; if (g) Nodes_Stack = g->nxt; Stack_sz--; return g; } static char * newname(void) { static char buf[32]; sprintf(buf, "S%d", state_cnt++); return buf; } static int has_clause(int tok, Graph *p, Node *n) { Node *q, *qq; switch (n->ntyp) { case AND: return has_clause(tok, p, n->lft) && has_clause(tok, p, n->rgt); case OR: return has_clause(tok, p, n->lft) || has_clause(tok, p, n->rgt); } for (q = p->Other; q; q = q->nxt) { qq = right_linked(q); if (anywhere(tok, n, qq)) return 1; } return 0; } static void mk_grn(Node *n) { Graph *p; if (!n) return; n = right_linked(n); more: for (p = Nodes_Set; p; p = p->nxt) if (p->outgoing && has_clause(AND, p, n)) { p->isgrn[p->grncnt++] = (unsigned char) Red_cnt; Lab_cnt++; } if (n->ntyp == U_OPER) /* 3.4.0 */ { n = n->rgt; goto more; } } static void mk_red(Node *n) { Graph *p; if (!n) return; n = right_linked(n); for (p = Nodes_Set; p; p = p->nxt) { if (p->outgoing && has_clause(0, p, n)) { if (p->redcnt >= 63) Fatal("too many Untils", (char *)0); p->isred[p->redcnt++] = (unsigned char) Red_cnt; Lab_cnt++; Max_Red = Red_cnt; } } } static void liveness(Node *n) { if (n) switch (n->ntyp) { #ifdef NXT case NEXT: liveness(n->lft); break; #endif case U_OPER: Red_cnt++; mk_red(n); mk_grn(n->rgt); /* fall through */ case V_OPER: case OR: case AND: liveness(n->lft); liveness(n->rgt); break; } } static Graph * findgraph(char *nm) { Graph *p; Mapping *m; for (p = Nodes_Set; p; p = p->nxt) if (!strcmp(p->name->name, nm)) return p; for (m = Mapped; m; m = m->nxt) if (strcmp(m->from, nm) == 0) return m->to; printf("warning: node %s not found\n", nm); return (Graph *) 0; } static void Addout(char *to, char *from) { Graph *p = findgraph(from); Symbol *s; if (!p) return; s = getsym(tl_lookup(to)); s->next = p->outgoing; p->outgoing = s; } #ifdef NXT int only_nxt(Node *n) { switch (n->ntyp) { case NEXT: return 1; case OR: case AND: return only_nxt(n->rgt) && only_nxt(n->lft); default: return 0; } } #endif int dump_cond(Node *pp, Node *r, int first) { Node *q; int frst = first; if (!pp) return frst; q = dupnode(pp); q = rewrite(q); if (q->ntyp == CEXPR) { if (!frst) fprintf(tl_out, " && "); fprintf(tl_out, "c_expr { "); dump_cond(q->lft, r, 1); fprintf(tl_out, " } "); frst = 0; return frst; } if (q->ntyp == PREDICATE || q->ntyp == NOT #ifndef NXT || q->ntyp == OR #endif || q->ntyp == FALSE) { if (!frst) fprintf(tl_out, " && "); dump(q); frst = 0; #ifdef NXT } else if (q->ntyp == OR) { if (!frst) fprintf(tl_out, " && "); fprintf(tl_out, "(("); frst = dump_cond(q->lft, r, 1); if (!frst) fprintf(tl_out, ") || ("); else { if (only_nxt(q->lft)) { fprintf(tl_out, "1))"); return 0; } } frst = dump_cond(q->rgt, r, 1); if (frst) { if (only_nxt(q->rgt)) fprintf(tl_out, "1"); else fprintf(tl_out, "0"); frst = 0; } fprintf(tl_out, "))"); #endif } else if (q->ntyp == V_OPER && !anywhere(AND, q->rgt, r)) { frst = dump_cond(q->rgt, r, frst); } else if (q->ntyp == AND) { frst = dump_cond(q->lft, r, frst); frst = dump_cond(q->rgt, r, frst); } return frst; } static int choueka(Graph *p, int count) { int j, k, incr_cnt = 0; for (j = count; j <= Max_Red; j++) /* for each acceptance class */ { int delta = 0; /* is state p labeled Grn-j OR not Red-j ? */ for (k = 0; k < (int) p->grncnt; k++) if (p->isgrn[k] == j) { delta = 1; break; } if (delta) { incr_cnt++; continue; } for (k = 0; k < (int) p->redcnt; k++) if (p->isred[k] == j) { delta = 1; break; } if (delta) break; incr_cnt++; } return incr_cnt; } static int set_prefix(char *pref, int count, Graph *r2) { int incr_cnt = 0; /* acceptance class 'count' */ if (Lab_cnt == 0 || Max_Red == 0) sprintf(pref, "accept"); /* new */ else if (count >= Max_Red) sprintf(pref, "T0"); /* cycle */ else { incr_cnt = choueka(r2, count+1); if (incr_cnt + count >= Max_Red) sprintf(pref, "accept"); /* last hop */ else sprintf(pref, "T%d", count+incr_cnt); } return incr_cnt; } static void fsm_trans(Graph *p, int count, char *curnm) { Graph *r; Symbol *s; char prefix[128], nwnm[256]; if (!p->outgoing) addtrans(p, curnm, False, "accept_all"); for (s = p->outgoing; s; s = s->next) { r = findgraph(s->name); if (!r) continue; if (r->outgoing) { (void) set_prefix(prefix, count, r); sprintf(nwnm, "%s_%s", prefix, s->name); } else strcpy(nwnm, "accept_all"); if (tl_verbose) { printf("maxred=%d, count=%d, curnm=%s, nwnm=%s ", Max_Red, count, curnm, nwnm); printf("(greencnt=%d,%d, redcnt=%d,%d)\n", r->grncnt, r->isgrn[0], r->redcnt, r->isred[0]); } addtrans(p, curnm, r->Old, nwnm); } } static void mkbuchi(void) { Graph *p; int k; char curnm[64]; for (k = 0; k <= Max_Red; k++) for (p = Nodes_Set; p; p = p->nxt) { if (!p->outgoing) continue; if (k != 0 && !strcmp(p->name->name, "init") && Max_Red != 0) continue; if (k == Max_Red && strcmp(p->name->name, "init") != 0) strcpy(curnm, "accept_"); else sprintf(curnm, "T%d_", k); strcat(curnm, p->name->name); fsm_trans(p, k, curnm); } fsm_print(); } static Symbol * dupSlist(Symbol *s) { Symbol *p1, *p2, *p3, *d = ZS; for (p1 = s; p1; p1 = p1->next) { for (p3 = d; p3; p3 = p3->next) { if (!strcmp(p3->name, p1->name)) break; } if (p3) continue; /* a duplicate */ p2 = getsym(p1); p2->next = d; d = p2; } return d; } static Symbol * catSlist(Symbol *a, Symbol *b) { Symbol *p1, *p2, *p3, *tmp; /* remove duplicates from b */ for (p1 = a; p1; p1 = p1->next) { p3 = ZS; for (p2 = b; p2; p2 = p2->next) { if (strcmp(p1->name, p2->name)) { p3 = p2; continue; } tmp = p2->next; tfree((void *) p2); if (p3) p3->next = tmp; else b = tmp; } } if (!a) return b; if (!b) return a; if (!b->next) { b->next = a; return b; } /* find end of list */ for (p1 = a; p1->next; p1 = p1->next) ; p1->next = b; return a; } static void fixinit(Node *orig) { Graph *p1, *g; Symbol *q1, *q2 = ZS; ng(tl_lookup("init"), ZS, ZN, ZN, ZN); p1 = pop_stack(); if (p1) { p1->nxt = Nodes_Set; p1->Other = p1->Old = orig; Nodes_Set = p1; } for (g = Nodes_Set; g; g = g->nxt) { for (q1 = g->incoming; q1; q1 = q2) { q2 = q1->next; Addout(g->name->name, q1->name); tfree((void *) q1); } g->incoming = ZS; } } static Node * flatten(Node *p) { Node *q, *r, *z = ZN; for (q = p; q; q = q->nxt) { r = dupnode(q); if (z) z = tl_nn(AND, r, z); else z = r; } if (!z) return z; z = rewrite(z); return z; } static Node * Duplicate(Node *n) { Node *n1, *n2, *lst = ZN, *d = ZN; for (n1 = n; n1; n1 = n1->nxt) { n2 = dupnode(n1); if (lst) { lst->nxt = n2; lst = n2; } else d = lst = n2; } return d; } static void ng(Symbol *s, Symbol *in, Node *isnew, Node *isold, Node *next) { Graph *g = (Graph *) tl_emalloc(sizeof(Graph)); if (s) g->name = s; else g->name = tl_lookup(newname()); if (in) g->incoming = dupSlist(in); if (isnew) g->New = flatten(isnew); if (isold) g->Old = Duplicate(isold); if (next) g->Next = flatten(next); push_stack(g); } static void sdump(Node *n) { switch (n->ntyp) { case PREDICATE: strcat(dumpbuf, n->sym->name); break; case U_OPER: strcat(dumpbuf, "U"); goto common2; case V_OPER: strcat(dumpbuf, "V"); goto common2; case OR: strcat(dumpbuf, "|"); goto common2; case AND: strcat(dumpbuf, "&"); common2: sdump(n->rgt); common1: sdump(n->lft); break; #ifdef NXT case NEXT: strcat(dumpbuf, "X"); goto common1; #endif case CEXPR: strcat(dumpbuf, "c_expr {"); sdump(n->lft); strcat(dumpbuf, "}"); break; case NOT: strcat(dumpbuf, "!"); goto common1; case TRUE: strcat(dumpbuf, "T"); break; case FALSE: strcat(dumpbuf, "F"); break; default: strcat(dumpbuf, "?"); break; } } Symbol * DoDump(Node *n) { if (!n) return ZS; if (n->ntyp == PREDICATE) return n->sym; dumpbuf[0] = '\0'; sdump(n); return tl_lookup(dumpbuf); } static int not_new(Graph *g) { Graph *q1; Node *tmp, *n1, *n2; Mapping *map; tmp = flatten(g->Old); /* duplicate, collapse, normalize */ g->Other = g->Old; /* non normalized full version */ g->Old = tmp; g->oldstring = DoDump(g->Old); tmp = flatten(g->Next); g->nxtstring = DoDump(tmp); if (tl_verbose) dump_graph(g); Debug2("\tformula-old: [%s]\n", g->oldstring?g->oldstring->name:"true"); Debug2("\tformula-nxt: [%s]\n", g->nxtstring?g->nxtstring->name:"true"); for (q1 = Nodes_Set; q1; q1 = q1->nxt) { Debug2(" compare old to: %s", q1->name->name); Debug2(" [%s]", q1->oldstring?q1->oldstring->name:"true"); Debug2(" compare nxt to: %s", q1->name->name); Debug2(" [%s]", q1->nxtstring?q1->nxtstring->name:"true"); if (q1->oldstring != g->oldstring || q1->nxtstring != g->nxtstring) { Debug(" => different\n"); continue; } Debug(" => match\n"); if (g->incoming) q1->incoming = catSlist(g->incoming, q1->incoming); /* check if there's anything in g->Other that needs adding to q1->Other */ for (n2 = g->Other; n2; n2 = n2->nxt) { for (n1 = q1->Other; n1; n1 = n1->nxt) if (isequal(n1, n2)) break; if (!n1) { Node *n3 = dupnode(n2); /* don't mess up n2->nxt */ n3->nxt = q1->Other; q1->Other = n3; } } map = (Mapping *) tl_emalloc(sizeof(Mapping)); map->from = g->name->name; map->to = q1; map->nxt = Mapped; Mapped = map; for (n1 = g->Other; n1; n1 = n2) { n2 = n1->nxt; releasenode(1, n1); } for (n1 = g->Old; n1; n1 = n2) { n2 = n1->nxt; releasenode(1, n1); } for (n1 = g->Next; n1; n1 = n2) { n2 = n1->nxt; releasenode(1, n1); } return 1; } if (newstates) tl_verbose=1; Debug2(" New Node %s [", g->name->name); for (n1 = g->Old; n1; n1 = n1->nxt) { Dump(n1); Debug(", "); } Debug2("] nr %d\n", Base); if (newstates) tl_verbose=0; Base++; g->nxt = Nodes_Set; Nodes_Set = g; return 0; } static void expand_g(Graph *g) { Node *now, *n1, *n2, *nx; int can_release; if (!g->New) { Debug2("\nDone with %s", g->name->name); if (tl_verbose) dump_graph(g); if (not_new(g)) { if (tl_verbose) printf("\tIs Not New\n"); return; } if (g->Next) { Debug(" Has Next ["); for (n1 = g->Next; n1; n1 = n1->nxt) { Dump(n1); Debug(", "); } Debug("]\n"); ng(ZS, getsym(g->name), g->Next, ZN, ZN); } return; } if (tl_verbose) { Symbol *z; printf("\nExpand %s, from ", g->name->name); for (z = g->incoming; z; z = z->next) printf("%s, ", z->name); printf("\n\thandle:\t"); Explain(g->New->ntyp); dump_graph(g); } if (g->New->ntyp == AND) { if (g->New->nxt) { n2 = g->New->rgt; while (n2->nxt) n2 = n2->nxt; n2->nxt = g->New->nxt; } n1 = n2 = g->New->lft; while (n2->nxt) n2 = n2->nxt; n2->nxt = g->New->rgt; releasenode(0, g->New); g->New = n1; push_stack(g); return; } can_release = 0; /* unless it need not go into Old */ now = g->New; g->New = g->New->nxt; now->nxt = ZN; if (now->ntyp != TRUE) { if (g->Old) { for (n1 = g->Old; n1->nxt; n1 = n1->nxt) if (isequal(now, n1)) { can_release = 1; goto out; } n1->nxt = now; } else g->Old = now; } out: switch (now->ntyp) { case FALSE: push_stack(g); break; case TRUE: releasenode(1, now); push_stack(g); break; case PREDICATE: case NOT: case CEXPR: if (can_release) releasenode(1, now); push_stack(g); break; case V_OPER: Assert(now->rgt != ZN, now->ntyp); Assert(now->lft != ZN, now->ntyp); Assert(now->rgt->nxt == ZN, now->ntyp); Assert(now->lft->nxt == ZN, now->ntyp); n1 = now->rgt; n1->nxt = g->New; if (can_release) nx = now; else nx = getnode(now); /* now also appears in Old */ nx->nxt = g->Next; n2 = now->lft; n2->nxt = getnode(now->rgt); n2->nxt->nxt = g->New; g->New = flatten(n2); push_stack(g); ng(ZS, g->incoming, n1, g->Old, nx); break; case U_OPER: Assert(now->rgt->nxt == ZN, now->ntyp); Assert(now->lft->nxt == ZN, now->ntyp); n1 = now->lft; if (can_release) nx = now; else nx = getnode(now); /* now also appears in Old */ nx->nxt = g->Next; n2 = now->rgt; n2->nxt = g->New; goto common; #ifdef NXT case NEXT: Assert(now->lft != ZN, now->ntyp); nx = dupnode(now->lft); nx->nxt = g->Next; g->Next = nx; if (can_release) releasenode(0, now); push_stack(g); break; #endif case OR: Assert(now->rgt->nxt == ZN, now->ntyp); Assert(now->lft->nxt == ZN, now->ntyp); n1 = now->lft; nx = g->Next; n2 = now->rgt; n2->nxt = g->New; common: n1->nxt = g->New; ng(ZS, g->incoming, n1, g->Old, nx); g->New = flatten(n2); if (can_release) releasenode(1, now); push_stack(g); break; } } Node * twocases(Node *p) { Node *q; /* 1: ([]p1 && []p2) == [](p1 && p2) */ /* 2: (<>p1 || <>p2) == <>(p1 || p2) */ if (!p) return p; switch(p->ntyp) { case AND: case OR: case U_OPER: case V_OPER: p->lft = twocases(p->lft); p->rgt = twocases(p->rgt); break; #ifdef NXT case NEXT: #endif case NOT: p->lft = twocases(p->lft); break; default: break; } if (p->ntyp == AND /* 1 */ && p->lft->ntyp == V_OPER && p->lft->lft->ntyp == FALSE && p->rgt->ntyp == V_OPER && p->rgt->lft->ntyp == FALSE) { q = tl_nn(V_OPER, False, tl_nn(AND, p->lft->rgt, p->rgt->rgt)); } else if (p->ntyp == OR /* 2 */ && p->lft->ntyp == U_OPER && p->lft->lft->ntyp == TRUE && p->rgt->ntyp == U_OPER && p->rgt->lft->ntyp == TRUE) { q = tl_nn(U_OPER, True, tl_nn(OR, p->lft->rgt, p->rgt->rgt)); } else q = p; return q; } void trans(Node *p) { Node *op; Graph *g; if (!p || tl_errs) return; p = twocases(p); if (tl_verbose || tl_terse) { fprintf(tl_out, "\t/* Normlzd: "); dump(p); fprintf(tl_out, " */\n"); } if (tl_terse) return; op = dupnode(p); ng(ZS, getsym(tl_lookup("init")), p, ZN, ZN); while ((g = Nodes_Stack) != (Graph *) 0) { Nodes_Stack = g->nxt; expand_g(g); } if (newstates) return; fixinit(p); liveness(flatten(op)); /* was: liveness(op); */ mkbuchi(); if (tl_verbose) { printf("/*\n"); printf(" * %d states in Streett automaton\n", Base); printf(" * %d Streett acceptance conditions\n", Max_Red); printf(" * %d Buchi states\n", Total); printf(" */\n"); } } Spin/Src6.4.5/tl_mem.c0000664000175100017510000000432212641605057012323 0ustar ghgh/***** tl_spin: tl_mem.c *****/ /* * This file is part of the public release of Spin. It is subject to the * terms in the LICENSE file that is included in this source directory. * Tool documentation is available at http://spinroot.com * * Based on the translation algorithm by Gerth, Peled, Vardi, and Wolper, * presented at the PSTV Conference, held in 1995, Warsaw, Poland 1995. */ #include "tl.h" #if 1 #define log(e, u, d) event[e][(int) u] += (long) d; #else #define log(e, u, d) #endif #define A_LARGE 80 #define A_USER 0x55000000 #define NOTOOBIG 32768 #define POOL 0 #define ALLOC 1 #define FREE 2 #define NREVENT 3 extern unsigned long All_Mem; extern int tl_verbose; union M { long size; union M *link; }; static union M *freelist[A_LARGE]; static long req[A_LARGE]; static long event[NREVENT][A_LARGE]; void * tl_emalloc(int U) { union M *m; long r, u; void *rp; u = (long) ((U-1)/sizeof(union M) + 2); if (u >= A_LARGE) { log(ALLOC, 0, 1); if (tl_verbose) printf("tl_spin: memalloc %ld bytes\n", u); m = (union M *) emalloc((int) u*sizeof(union M)); All_Mem += (unsigned long) u*sizeof(union M); } else { if (!freelist[u]) { r = req[u] += req[u] ? req[u] : 1; if (r >= NOTOOBIG) r = req[u] = NOTOOBIG; log(POOL, u, r); freelist[u] = (union M *) emalloc((int) r*u*sizeof(union M)); All_Mem += (unsigned long) r*u*sizeof(union M); m = freelist[u] + (r-2)*u; for ( ; m >= freelist[u]; m -= u) m->link = m+u; } log(ALLOC, u, 1); m = freelist[u]; freelist[u] = m->link; } m->size = (u|A_USER); for (r = 1; r < u; ) (&m->size)[r++] = 0; rp = (void *) (m+1); memset(rp, 0, U); return rp; } void tfree(void *v) { union M *m = (union M *) v; long u; --m; if ((m->size&0xFF000000) != A_USER) Fatal("releasing a free block", (char *)0); u = (m->size &= 0xFFFFFF); if (u >= A_LARGE) { log(FREE, 0, 1); /* free(m); */ } else { log(FREE, u, 1); m->link = freelist[u]; freelist[u] = m; } } void a_stats(void) { long p, a, f; int i; printf(" size\t pool\tallocs\t frees\n"); for (i = 0; i < A_LARGE; i++) { p = event[POOL][i]; a = event[ALLOC][i]; f = event[FREE][i]; if(p|a|f) printf("%5d\t%6ld\t%6ld\t%6ld\n", i, p, a, f); } } Spin/Src6.4.5/dstep.c0000664000175100017510000002356112641605057012173 0ustar ghgh/***** spin: dstep.c *****/ /* * This file is part of the public release of Spin. It is subject to the * terms in the LICENSE file that is included in this source directory. * Tool documentation is available at http://spinroot.com */ #include #include "spin.h" #include "y.tab.h" #define MAXDSTEP 2048 /* was 512 */ char *NextLab[64]; /* must match value in pangen2.c:41 */ int Level=0, GenCode=0, IsGuard=0, TestOnly=0; static int Tj=0, Jt=0, LastGoto=0; static int Tojump[MAXDSTEP], Jumpto[MAXDSTEP], Special[MAXDSTEP]; static void putCode(FILE *, Element *, Element *, Element *, int); extern int Pid, separate, OkBreak; static void Sourced(int n, int special) { int i; for (i = 0; i < Tj; i++) if (Tojump[i] == n) return; if (Tj >= MAXDSTEP) fatal("d_step sequence too long", (char *)0); Special[Tj] = special; Tojump[Tj++] = n; } static void Dested(int n) { int i; for (i = 0; i < Tj; i++) if (Tojump[i] == n) return; for (i = 0; i < Jt; i++) if (Jumpto[i] == n) return; if (Jt >= MAXDSTEP) fatal("d_step sequence too long", (char *)0); Jumpto[Jt++] = n; LastGoto = 1; } static void Mopup(FILE *fd) { int i, j; for (i = 0; i < Jt; i++) { for (j = 0; j < Tj; j++) if (Tojump[j] == Jumpto[i]) break; if (j == Tj) { char buf[16]; if (Jumpto[i] == OkBreak) { if (!LastGoto) fprintf(fd, "S_%.3d_0: /* break-dest */\n", OkBreak); } else { sprintf(buf, "S_%.3d_0", Jumpto[i]); non_fatal("goto %s breaks from d_step seq", buf); } } } for (j = 0; j < Tj; j++) { for (i = 0; i < Jt; i++) if (Tojump[j] == Jumpto[i]) break; #ifdef DEBUG if (i == Jt && !Special[i]) fprintf(fd, "\t\t/* no goto's to S_%.3d_0 */\n", Tojump[j]); #endif } for (j = i = 0; j < Tj; j++) if (Special[j]) { if (i >= MAXDSTEP) { fatal("cannot happen (dstep.c)", (char *)0); } Tojump[i] = Tojump[j]; Special[i] = 2; i++; } Tj = i; /* keep only the global exit-labels */ Jt = 0; } static int FirstTime(int n) { int i; for (i = 0; i < Tj; i++) if (Tojump[i] == n) return (Special[i] <= 1); return 1; } static void illegal(Element *e, char *str) { printf("illegal operator in 'd_step:' '"); comment(stdout, e->n, 0); printf("'\n"); fatal("'%s'", str); } static void filterbad(Element *e) { switch (e->n->ntyp) { case ASSERT: case PRINT: case 'c': /* run cannot be completely undone * with sv_save-sv_restor */ if (any_oper(e->n->lft, RUN)) illegal(e, "run operator in d_step"); /* remote refs inside d_step sequences * would be okay, but they cannot always * be interpreted by the simulator the * same as by the verifier (e.g., for an * error trail) */ if (any_oper(e->n->lft, 'p')) illegal(e, "remote reference in d_step"); break; case '@': illegal(e, "process termination"); break; case D_STEP: illegal(e, "nested d_step sequence"); break; case ATOMIC: illegal(e, "nested atomic sequence"); break; default: break; } } static int CollectGuards(FILE *fd, Element *e, int inh) { SeqList *h; Element *ee; for (h = e->sub; h; h = h->nxt) { ee = huntstart(h->this->frst); filterbad(ee); switch (ee->n->ntyp) { case NON_ATOMIC: inh += CollectGuards(fd, ee->n->sl->this->frst, inh); break; case IF: inh += CollectGuards(fd, ee, inh); break; case '.': if (ee->nxt->n->ntyp == DO) inh += CollectGuards(fd, ee->nxt, inh); break; case ELSE: if (inh++ > 0) fprintf(fd, " || "); /* 4.2.5 */ if (!pid_is_claim(Pid)) fprintf(fd, "(boq == -1 /* else */)"); else fprintf(fd, "(1 /* else */)"); break; case 'R': if (inh++ > 0) fprintf(fd, " || "); fprintf(fd, "("); TestOnly=1; putstmnt(fd, ee->n, ee->seqno); fprintf(fd, ")"); TestOnly=0; break; case 'r': if (inh++ > 0) fprintf(fd, " || "); fprintf(fd, "("); TestOnly=1; putstmnt(fd, ee->n, ee->seqno); fprintf(fd, ")"); TestOnly=0; break; case 's': if (inh++ > 0) fprintf(fd, " || "); fprintf(fd, "("); TestOnly=1; /* 4.2.1 */ if (!pid_is_claim(Pid)) fprintf(fd, "(boq == -1) && "); putstmnt(fd, ee->n, ee->seqno); fprintf(fd, ")"); TestOnly=0; break; case 'c': if (inh++ > 0) fprintf(fd, " || "); fprintf(fd, "("); TestOnly=1; if (!pid_is_claim(Pid)) fprintf(fd, "(boq == -1 && "); putstmnt(fd, ee->n->lft, e->seqno); if (!pid_is_claim(Pid)) fprintf(fd, ")"); fprintf(fd, ")"); TestOnly=0; break; } } return inh; } int putcode(FILE *fd, Sequence *s, Element *nxt, int justguards, int ln, int seqno) { int isg=0; static char buf[64]; NextLab[0] = "continue"; filterbad(s->frst); switch (s->frst->n->ntyp) { case UNLESS: non_fatal("'unless' inside d_step - ignored", (char *) 0); return putcode(fd, s->frst->n->sl->this, nxt, 0, ln, seqno); case NON_ATOMIC: (void) putcode(fd, s->frst->n->sl->this, ZE, 1, ln, seqno); if (justguards) return 0; /* 6.2.5 */ break; case IF: fprintf(fd, "if (!("); if (!CollectGuards(fd, s->frst, 0)) /* what about boq? */ fprintf(fd, "1"); fprintf(fd, "))\n\t\t\tcontinue;"); isg = 1; break; case '.': if (s->frst->nxt->n->ntyp == DO) { fprintf(fd, "if (!("); if (!CollectGuards(fd, s->frst->nxt, 0)) fprintf(fd, "1"); fprintf(fd, "))\n\t\t\tcontinue;"); isg = 1; } break; case 'R': /* <- can't really happen (it's part of a 'c') */ fprintf(fd, "if (!("); TestOnly=1; putstmnt(fd, s->frst->n, s->frst->seqno); fprintf(fd, "))\n\t\t\tcontinue;"); TestOnly=0; break; case 'r': fprintf(fd, "if (!("); TestOnly=1; putstmnt(fd, s->frst->n, s->frst->seqno); fprintf(fd, "))\n\t\t\tcontinue;"); TestOnly=0; break; case 's': fprintf(fd, "if ("); #if 1 /* 4.2.1 */ if (!pid_is_claim(Pid)) fprintf(fd, "(boq != -1) || "); #endif fprintf(fd, "!("); TestOnly=1; putstmnt(fd, s->frst->n, s->frst->seqno); fprintf(fd, "))\n\t\t\tcontinue;"); TestOnly=0; break; case 'c': fprintf(fd, "if (!("); if (!pid_is_claim(Pid)) fprintf(fd, "boq == -1 && "); TestOnly=1; putstmnt(fd, s->frst->n->lft, s->frst->seqno); fprintf(fd, "))\n\t\t\tcontinue;"); TestOnly=0; break; case ELSE: fprintf(fd, "if (boq != -1 || ("); if (separate != 2) fprintf(fd, "trpt->"); fprintf(fd, "o_pm&1))\n\t\t\tcontinue;"); { extern FILE *th; fprintf(th, "#ifndef ELSE_IN_GUARD\n"); fprintf(th, " #define ELSE_IN_GUARD\n"); fprintf(th, "#endif\n"); } break; case ASGN: /* new 3.0.8 */ fprintf(fd, "IfNotBlocked"); break; default: fprintf(fd, "/* default %d */\n\t\t", s->frst->n->ntyp); } /* 6.2.5 : before TstOnly */ fprintf(fd, "\n\n\t\treached[%d][%d] = 1;\n\t\t", Pid, seqno); fprintf(fd, "reached[%d][t->st] = 1;\n\t\t", Pid); /* next state */ fprintf(fd, "reached[%d][tt] = 1;\n", Pid); /* current state */ /* 6.2.5 : before sv_save() */ if (s->frst->n->ntyp != NON_ATOMIC) fprintf(fd, "\n\t\tif (TstOnly) return 1;\n"); /* if called from enabled() */ if (justguards) return 0; fprintf(fd, "\n\t\tsv_save();\n\t\t"); sprintf(buf, "Uerror(\"block in d_step seq, line %d\")", ln); NextLab[0] = buf; putCode(fd, s->frst, s->extent, nxt, isg); if (nxt) { extern Symbol *Fname; extern int lineno; if (FirstTime(nxt->Seqno) && (!(nxt->status & DONE2) || !(nxt->status & D_ATOM))) { fprintf(fd, "S_%.3d_0: /* 1 */\n", nxt->Seqno); nxt->status |= DONE2; LastGoto = 0; } Sourced(nxt->Seqno, 1); lineno = ln; Fname = nxt->n->fn; Mopup(fd); } unskip(s->frst->seqno); return LastGoto; } static void putCode(FILE *fd, Element *f, Element *last, Element *next, int isguard) { Element *e, *N; SeqList *h; int i; char NextOpt[64]; static int bno = 0; for (e = f; e; e = e->nxt) { if (e->status & DONE2) continue; e->status |= DONE2; if (!(e->status & D_ATOM)) { if (!LastGoto) { fprintf(fd, "\t\tgoto S_%.3d_0;\n", e->Seqno); Dested(e->Seqno); } break; } fprintf(fd, "S_%.3d_0: /* 2 */\n", e->Seqno); LastGoto = 0; Sourced(e->Seqno, 0); if (!e->sub) { filterbad(e); switch (e->n->ntyp) { case NON_ATOMIC: h = e->n->sl; putCode(fd, h->this->frst, h->this->extent, e->nxt, 0); break; case BREAK: if (LastGoto) break; if (e->nxt) { i = target( huntele(e->nxt, e->status, -1))->Seqno; fprintf(fd, "\t\tgoto S_%.3d_0; ", i); fprintf(fd, "/* 'break' */\n"); Dested(i); } else { if (next) { fprintf(fd, "\t\tgoto S_%.3d_0;", next->Seqno); fprintf(fd, " /* NEXT */\n"); Dested(next->Seqno); } else fatal("cannot interpret d_step", 0); } break; case GOTO: if (LastGoto) break; i = huntele( get_lab(e->n,1), e->status, -1)->Seqno; fprintf(fd, "\t\tgoto S_%.3d_0; ", i); fprintf(fd, "/* 'goto' */\n"); Dested(i); break; case '.': if (LastGoto) break; if (e->nxt && (e->nxt->status & DONE2)) { i = e->nxt->Seqno; fprintf(fd, "\t\tgoto S_%.3d_0;", i); fprintf(fd, " /* '.' */\n"); Dested(i); } break; default: putskip(e->seqno); GenCode = 1; IsGuard = isguard; fprintf(fd, "\t\t"); putstmnt(fd, e->n, e->seqno); fprintf(fd, ";\n"); GenCode = IsGuard = isguard = LastGoto = 0; break; } i = e->nxt?e->nxt->Seqno:0; if (e->nxt && e->nxt->status & DONE2 && !LastGoto) { fprintf(fd, "\t\tgoto S_%.3d_0; ", i); fprintf(fd, "/* ';' */\n"); Dested(i); break; } } else { for (h = e->sub, i=1; h; h = h->nxt, i++) { sprintf(NextOpt, "goto S_%.3d_%d", e->Seqno, i); NextLab[++Level] = NextOpt; N = (e->n && e->n->ntyp == DO) ? e : e->nxt; putCode(fd, h->this->frst, h->this->extent, N, 1); Level--; fprintf(fd, "%s: /* 3 */\n", &NextOpt[5]); LastGoto = 0; } if (!LastGoto) { fprintf(fd, "\t\tUerror(\"blocking sel "); fprintf(fd, "in d_step (nr.%d, near line %d)\");\n", bno++, (e->n)?e->n->ln:0); LastGoto = 0; } } if (e == last) { if (!LastGoto && next) { fprintf(fd, "\t\tgoto S_%.3d_0;\n", next->Seqno); Dested(next->Seqno); } break; } } } Spin/Src6.4.5/pangen3.h0000664000175100017510000011473212641605057012415 0ustar ghgh/***** spin: pangen3.h *****/ /* * This file is part of the public release of Spin. It is subject to the * terms in the LICENSE file that is included in this source directory. * Tool documentation is available at http://spinroot.com */ static const char *Head0[] = { "#if defined(BFS) && defined(REACH)", " #undef REACH", /* redundant with bfs */ "#endif", "#ifdef VERI", " #define BASE 1", "#else", " #define BASE 0", "#endif", "typedef struct Trans {", " short atom; /* if &2 = atomic trans; if &8 local */", "#ifdef HAS_UNLESS", " short escp[HAS_UNLESS]; /* lists the escape states */", " short e_trans; /* if set, this is an escp-trans */", "#endif", " short tpe[2]; /* class of operation (for reduction) */", " short qu[6]; /* for conditional selections: qid's */", " uchar ty[6]; /* ditto: type's */", "#ifdef NIBIS", " short om; /* completion status of preselects */", "#endif", " char *tp; /* src txt of statement */", " int st; /* the nextstate */", " int t_id; /* transition id, unique within proc */", " int forw; /* index forward transition */", " int back; /* index return transition */", " struct Trans *nxt;", "} Trans;\n", "#ifdef TRIX", " #define qptr(x) (channels[x]->body)", " #define pptr(x) (processes[x]->body)", "#else", " #define qptr(x) (((uchar *)&now)+(int)q_offset[x])", " #define pptr(x) (((uchar *)&now)+(int)proc_offset[x])", /* " #define Pptr(x) ((proc_offset[x])?pptr(x):noptr)", */ "#endif", "extern uchar *Pptr(int);", "extern uchar *Qptr(int);", "#define q_sz(x) (((Q0 *)qptr(x))->Qlen)", "", "#ifdef TRIX", " #ifdef VECTORSZ", " #undef VECTORSZ", /* backward compatibility */ " #endif", " #if WS==4", " #define VECTORSZ 2056 /* ((MAXPROC+MAXQ+4)*sizeof(uchar *)) */", " #else", " #define VECTORSZ 4112 /* the formula causes probs in preprocessing */", " #endif", "#else", " #ifndef VECTORSZ", " #define VECTORSZ 1024 /* sv size in bytes */", " #endif", "#endif\n", "#define MAXQ 255", "#define MAXPROC 255", "", 0, }; static const char *Header[] = { "#ifdef VERBOSE", " #ifndef CHECK", " #define CHECK", " #endif", " #ifndef DEBUG", " #define DEBUG", " #endif", "#endif", "#ifdef SAFETY", " #ifndef NOFAIR", " #define NOFAIR", " #endif", "#endif", #if 0 NOREDUCE BITSTATE SAFETY MA WS>4 CNTRSTACK: - + + d - FULLSTACK: + d - - d - + d d d - + + d + - - d d d Neither: + d + d d + d d + d #endif "#ifdef NOREDUCE", " #ifndef XUSAFE", " #define XUSAFE", " #endif", " #if !defined(SAFETY) && !defined(MA)", " #define FULLSTACK", /* => NOREDUCE && !SAFETY && !MA */ " #endif", "#else", " #ifdef BITSTATE", " #if defined(SAFETY) && WS<=4", " #define CNTRSTACK", /* => !NOREDUCE && BITSTATE && SAFETY && WS<=4 */ " #else", " #define FULLSTACK", /* => !NOREDUCE && BITSTATE && (!SAFETY || WS>4) */ " #endif", " #else", " #define FULLSTACK", /* => !NOREDUCE && !BITSTATE */ " #endif", "#endif", "#ifdef BITSTATE", " #ifndef NOCOMP", " #define NOCOMP", " #endif", " #if !defined(LC) && defined(SC)", " #define LC", " #endif", "#endif", "#if defined(COLLAPSE2) || defined(COLLAPSE3) || defined(COLLAPSE4)", " /* accept the above for backward compatibility */", " #define COLLAPSE", "#endif", "#ifdef HC", " #undef HC", " #define HC4", "#endif", "#if defined(HC0) || defined(HC1) || defined(HC2) || defined(HC3) || defined(HC4)", " #define HC 4", /* 2x32 bits */ "#endif", /* really only one hashcompact mode, not 5 */ "", "typedef struct _Stack { /* for queues and processes */", "#if VECTORSZ>32000", " int o_delta;", " #ifndef TRIX", " int o_offset;", " int o_skip;", " #endif", " int o_delqs;", "#else", " short o_delta;", " #ifndef TRIX", " short o_offset;", " short o_skip;", " #endif", " short o_delqs;", "#endif", " short o_boq;", "#ifdef TRIX", " short parent;", " char *b_ptr;", /* used in delq/q_restor and delproc/p_restor */ "#else", " char *body;", /* full copy of state vector in non-trix mode */ "#endif", "#ifndef XUSAFE", " char *o_name;", "#endif", " struct _Stack *nxt;", " struct _Stack *lst;", "} _Stack;\n", "typedef struct Svtack { /* for complete state vector */", "#if VECTORSZ>32000", " int o_delta;", " int m_delta;", "#else", " short o_delta; /* current size of frame */", " short m_delta; /* maximum size of frame */", "#endif", "#if SYNC", " short o_boq;", "#endif", 0, }; static const char *Header0[] = { " char *body;", " struct Svtack *nxt;", " struct Svtack *lst;", "} Svtack;\n", 0, }; static const char *Head1[] = { "typedef struct State {", " uchar _nr_pr;", " uchar _nr_qs;", " uchar _a_t; /* cycle detection */", #if 0 in _a_t: bits 0,4, and 5 =(1|16|32) are set during a 2nd dfs bit 1 is used as the A-bit for fairness bit 7 (128) is the proviso bit, for reduced 2nd dfs (acceptance) #endif "#ifndef NOFAIR", " uchar _cnt[NFAIR]; /* counters, weak fairness */", "#endif", "#ifndef NOVSZ", #ifdef SOLARIS "#if 0", /* v3.4 * noticed alignment problems with some Solaris * compilers, if widest field isn't wordsized */ #else "#if VECTORSZ<65536", #endif " unsigned short _vsz;", "#else", " ulong _vsz;", "#endif", "#endif", "#ifdef HAS_LAST", /* cannot go before _cnt - see h_store() */ " uchar _last; /* pid executed in last step */", "#endif", "#if defined(BITSTATE) && defined(BCS) && defined(STORE_CTX)", " uchar _ctx; /* nr of context switches so far */", "#endif", "#if defined(BFS_PAR) && defined(L_BOUND)", " uchar _l_bnd; /* bounded liveness */", " uchar *_l_sds; /* seed state */", "#endif", "#ifdef EVENT_TRACE", " #if nstates_event<256", " uchar _event;", " #else", " unsigned short _event;", " #endif", "#endif", 0, }; static const char *Addp0[] = { /* addproc(....parlist... */ ")", "{ int j, h = now._nr_pr;", "#ifndef NOCOMP", " int k;", "#endif", " uchar *o_this = this;\n", "#ifndef INLINE", " if (TstOnly) return (h < MAXPROC);", "#endif", "#ifndef NOBOUNDCHECK", " /* redefine Index only within this procedure */", " #undef Index", " #define Index(x, y) Boundcheck(x, y, 0, 0, 0)", "#endif", " if (h >= MAXPROC)", " Uerror(\"too many processes\");", "#ifdef V_TRIX", " printf(\"%%4d: add process %%d\\n\", depth, h);", "#endif", " switch (n) {", " case 0: j = sizeof(P0); break;", 0, }; static const char *Addp1[] = { " default: Uerror(\"bad proc - addproc\");", " }", " #ifdef BFS_PAR", " bfs_prepmask(1); /* addproc */", " #endif", "#ifdef TRIX", " vsize += sizeof(H_el *);", "#else", " if (vsize%%WS)", " proc_skip[h] = WS-(vsize%%WS);", " else", " proc_skip[h] = 0;", " #if !defined(NOCOMP) && !defined(HC)", " for (k = vsize + (int) proc_skip[h]; k > vsize; k--)", " Mask[k-1] = 1; /* align */", " #endif", " vsize += (int) proc_skip[h];", " proc_offset[h] = vsize;", " vsize += j;", " #if defined(SVDUMP) && defined(VERBOSE)", " if (vprefix > 0)", " { int dummy = 0;", " write(svfd, (uchar *) &dummy, sizeof(int)); /* mark */", " write(svfd, (uchar *) &h, sizeof(int));", " write(svfd, (uchar *) &n, sizeof(int));", " #if VECTORSZ>32000", " write(svfd, (uchar *) &proc_offset[h], sizeof(int));", " write(svfd, (uchar *) &now, vprefix-4*sizeof(int)); /* padd */", " #else", " write(svfd, (uchar *) &proc_offset[h], sizeof(short));", " write(svfd, (uchar *) &now, vprefix-3*sizeof(int)-sizeof(short)); /* padd */", " #endif", " }", " #endif", "#endif", " now._nr_pr += 1;", "#if defined(BCS) && defined(CONSERVATIVE)", " if (now._nr_pr >= CONSERVATIVE*8)", " { printf(\"pan: error: too many processes -- recompile with \");", " printf(\"-DCONSERVATIVE=%%d\\n\", CONSERVATIVE+1);", " pan_exit(1);", " }", "#endif", " if (fairness && ((int) now._nr_pr + 1 >= (8*NFAIR)/2))", " { printf(\"pan: error: too many processes -- current\");", " printf(\" max is %%d procs (-DNFAIR=%%d)\\n\",", " (8*NFAIR)/2 - 2, NFAIR);", " printf(\"\\trecompile with -DNFAIR=%%d\\n\",", " NFAIR+1);", " pan_exit(1);", " }", "#ifndef NOVSZ", " now._vsz = vsize;", "#endif", " hmax = max(hmax, vsize);", "#ifdef TRIX", " #ifndef BFS", " if (freebodies)", " { processes[h] = freebodies;", " freebodies = freebodies->nxt;", " } else", " { processes[h] = (TRIX_v6 *) emalloc(sizeof(TRIX_v6));", " processes[h]->body = (uchar *) emalloc(Maxbody * sizeof(char));", " }", " processes[h]->modified = 1; /* addproc */", " #endif", " processes[h]->psize = j;", " processes[h]->parent_pid = calling_pid;", " processes[h]->nxt = (TRIX_v6 *) 0;", "#else", " #if !defined(NOCOMP) && !defined(HC)", " for (k = 1; k <= Air[n]; k++)", " Mask[vsize - k] = 1; /* pad */", " Mask[vsize-j] = 1; /* _pid */", " #endif", " #ifdef BFS_PAR", " bfs_fixmask(1); /* addproc */", " #endif", " if (vsize >= VECTORSZ)", " { printf(\"pan: error, VECTORSZ too small, recompile pan.c\");", " printf(\" with -DVECTORSZ=N with N>%%d\\n\", (int) vsize);", " Uerror(\"aborting\");", " }", "#endif", " memset((char *)pptr(h), 0, j);", " this = pptr(h);", " if (BASE > 0 && h > 0)", " { ((P0 *)this)->_pid = h-BASE;", " } else", " { ((P0 *)this)->_pid = h;", " }", " switch (n) {", 0, }; static const char *Addq0[] = { "", "int", "addqueue(int calling_pid, int n, int is_rv)", "{ int j=0, i = now._nr_qs;", "#if !defined(NOCOMP) && !defined(TRIX)", " int k;", "#endif", " if (i >= MAXQ)", " Uerror(\"too many queues\");", "#ifdef V_TRIX", " printf(\"%%4d: add queue %%d\\n\", depth, i);", "#endif", " switch (n) {", 0, }; static const char *Addq1[] = { " default: Uerror(\"bad queue - addqueue\");", " }", " #ifdef BFS_PAR", " bfs_prepmask(2); /* addqueue */", " #endif", "#ifdef TRIX", " vsize += sizeof(H_el *);", "#else", " if (vsize%%WS)", " q_skip[i] = WS-(vsize%%WS);", " else", " q_skip[i] = 0;", " #if !defined(NOCOMP) && !defined(HC)", " k = vsize;", " #ifndef BFS", " if (is_rv) k += j;", " #endif", " for (k += (int) q_skip[i]; k > vsize; k--)", " Mask[k-1] = 1;", " #endif", " vsize += (int) q_skip[i];", " q_offset[i] = vsize;", " vsize += j;", " #ifdef BFS_PAR", " bfs_fixmask(2); /* addqueue */", " #endif", "#endif", " now._nr_qs += 1;", "#ifndef NOVSZ", " now._vsz = vsize;", "#endif", " hmax = max(hmax, vsize);", "#ifdef TRIX", " #ifndef BFS", " if (freebodies)", " { channels[i] = freebodies;", " freebodies = freebodies->nxt;", " } else", " { channels[i] = (TRIX_v6 *) emalloc(sizeof(TRIX_v6));", " channels[i]->body = (uchar *) emalloc(Maxbody * sizeof(char));", " }", " channels[i]->modified = 1; /* addq */", " #endif", " channels[i]->psize = j;", " channels[i]->parent_pid = calling_pid;", " channels[i]->nxt = (TRIX_v6 *) 0;", "#else", " if (vsize >= VECTORSZ)", " Uerror(\"VECTORSZ is too small, edit pan.h\");", "#endif", " if (j > 0)", /* zero if there are no queues */ " { memset((char *)qptr(i), 0, j);", " }", " ((Q0 *)qptr(i))->_t = n;", " return i+1;", "}\n", 0, }; static const char *Addq11[] = { "{ int j; uchar *z;\n", "#ifdef HAS_SORTED", " int k;", "#endif", " if (!into--)", " uerror(\"ref to uninitialized chan name (sending)\");", " if (into >= (int) now._nr_qs || into < 0)", " Uerror(\"qsend bad queue#\");", "#if defined(TRIX) && !defined(BFS)", " #ifndef TRIX_ORIG", " (trpt+1)->q_bup = now._ids_[now._nr_pr+into];", " #ifdef V_TRIX", " printf(\"%%4d: channel %%d s save %%p from %%d\\n\",", " depth, into, (trpt+1)->q_bup, now._nr_pr+into);", " #endif", " #endif", " channels[into]->modified = 1; /* qsend */", " #ifdef V_TRIX", " printf(\"%%4d: channel %%d modified\\n\", depth, into);", " #endif", "#endif", " z = qptr(into);", " j = ((Q0 *)qptr(into))->Qlen;", " switch (((Q0 *)qptr(into))->_t) {", 0, }; static const char *Addq2[] = { " case 0: printf(\"queue %%d was deleted\\n\", into+1);", " default: Uerror(\"bad queue - qsend\");", " }", "#ifdef EVENT_TRACE", " if (in_s_scope(into+1))", " require('s', into);", "#endif", "}", "#endif\n", "#if SYNC", "int", "q_zero(int from)", "{ if (!from--)", " { uerror(\"ref to uninitialized chan name (q_zero)\");", " return 0;", " }", " switch(((Q0 *)qptr(from))->_t) {", 0, }; static const char *Addq3[] = { " case 0: printf(\"queue %%d was deleted\\n\", from+1);", " }", " Uerror(\"bad queue q-zero\");", " return -1;", "}", "int", "not_RV(int from)", "{ if (q_zero(from))", " { printf(\"==>> a test of the contents of a rv \");", " printf(\"channel always returns FALSE\\n\");", " uerror(\"error to poll rendezvous channel\");", " }", " return 1;", "}", "#endif", "#ifndef XUSAFE", "void", "setq_claim(int x, int m, char *s, int y, char *p)", "{ if (x == 0)", " uerror(\"x[rs] claim on uninitialized channel\");", " if (x < 0 || x > MAXQ)", " Uerror(\"cannot happen setq_claim\");", " q_claim[x] |= m;", " p_name[y] = p;", " q_name[x] = s;", " if (m&2) q_S_check(x, y);", " if (m&1) q_R_check(x, y);", "}", "short q_sender[MAXQ+1];", "int", "q_S_check(int x, int who)", "{ if (!q_sender[x])", " { q_sender[x] = who+1;", "#if SYNC", " if (q_zero(x))", " { printf(\"chan %%s (%%d), \",", " q_name[x], x-1);", " printf(\"sndr proc %%s (%%d)\\n\",", " p_name[who], who);", " uerror(\"xs chans cannot be used for rv\");", " }", "#endif", " } else", " if (q_sender[x] != who+1)", " { printf(\"pan: xs assertion violated: \");", " printf(\"access to chan <%%s> (%%d)\\npan: by \",", " q_name[x], x-1);", " if (q_sender[x] > 0 && p_name[q_sender[x]-1])", " printf(\"%%s (proc %%d) and by \",", " p_name[q_sender[x]-1], q_sender[x]-1);", " printf(\"%%s (proc %%d)\\n\",", " p_name[who], who);", " uerror(\"error, partial order reduction invalid\");", " }", " return 1;", "}", "short q_recver[MAXQ+1];", "int", "q_R_check(int x, int who)", "{", "#ifdef VERBOSE", " printf(\"q_R_check x=%%d who=%%d\\n\", x, who);", "#endif", " if (!q_recver[x])", " { q_recver[x] = who+1;", "#if SYNC", " if (q_zero(x))", " { printf(\"chan %%s (%%d), \",", " q_name[x], x-1);", " printf(\"recv proc %%s (%%d)\\n\",", " p_name[who], who);", " uerror(\"xr chans cannot be used for rv\");", " }", "#endif", " } else", " if (q_recver[x] != who+1)", " { printf(\"pan: xr assertion violated: \");", " printf(\"access to chan %%s (%%d)\\npan: \",", " q_name[x], x-1);", " if (q_recver[x] > 0 && p_name[q_recver[x]-1])", " printf(\"by %%s (proc %%d) and \",", " p_name[q_recver[x]-1], q_recver[x]-1);", " printf(\"by %%s (proc %%d)\\n\",", " p_name[who], who);", " uerror(\"error, partial order reduction invalid\");", " }", " return 1;", "}", "#endif", "int", "q_len(int x)", "{ if (!x--)", " uerror(\"ref to uninitialized chan name (len)\");", " return ((Q0 *)qptr(x))->Qlen;", "}\n", "int", "q_full(int from)", "{ if (!from--)", " uerror(\"ref to uninitialized chan name (qfull)\");", " switch(((Q0 *)qptr(from))->_t) {", 0, }; static const char *Addq4[] = { " case 0: printf(\"queue %%d was deleted\\n\", from+1);", " }", " Uerror(\"bad queue - q_full\");", " return 0;", "}\n", "#ifdef HAS_UNLESS", "int", "q_e_f(int from)", "{ /* empty or full */", " return !q_len(from) || q_full(from);", "}", "#endif", "#if NQS>0", "int", "qrecv(int from, int slot, int fld, int done)", "{ uchar *z;", " int j, k, r=0;\n", " if (!from--)", " uerror(\"ref to uninitialized chan name (receiving)\");", "#if defined(TRIX) && !defined(BFS)", " #ifndef TRIX_ORIG", " (trpt+1)->q_bup = now._ids_[now._nr_pr+from];", " #ifdef V_TRIX", " printf(\"%%4d: channel %%d r save %%p from %%d\\n\",", " depth, from, (trpt+1)->q_bup, now._nr_pr+from);", " #endif", " #endif", " channels[from]->modified = 1; /* qrecv */", " #ifdef V_TRIX", " printf(\"%%4d: channel %%d modified\\n\", depth, from);", " #endif", "#endif", " if (from >= (int) now._nr_qs || from < 0)", " Uerror(\"qrecv bad queue#\");", " z = qptr(from);", "#ifdef EVENT_TRACE", " if (done && (in_r_scope(from+1)))", " require('r', from);", "#endif", " switch (((Q0 *)qptr(from))->_t) {", 0, }; static const char *Addq5[] = { " case 0: printf(\"queue %%d was deleted\\n\", from+1);", " default: Uerror(\"bad queue - qrecv\");", " }", " return r;", "}", "#endif\n", "#ifndef BITSTATE", " #ifdef COLLAPSE", "long", "col_q(int i, char *z)", "{ int j=0, k;", " char *x, *y;", " Q0 *ptr = (Q0 *) qptr(i);", " switch (ptr->_t) {", 0, }; static const char *Code0[] = { "void", "run(void)", "{ /* int i; */", " memset((char *)&now, 0, sizeof(State));", " vsize = (ulong) (sizeof(State) - VECTORSZ);", "#ifndef NOVSZ", " now._vsz = vsize;", "#endif", "#ifdef TRIX", " if (VECTORSZ != sizeof(now._ids_))", " { printf(\"VECTORSZ is %%d, but should be %%d in this mode\\n\",", " VECTORSZ, (int) sizeof(now._ids_));", " Uerror(\"VECTORSZ set incorrectly, recompile Spin (not pan.c)\");", " }", "#endif", "/* optional provisioning statements, e.g. to */", "/* set hidden variables, used as constants */", "#ifdef PROV", "#include PROV", "#endif", " settable();", 0, }; static const char *R0[] = { " Maxbody = max(Maxbody, ((int) sizeof(P%d)));", " reached[%d] = reached%d;", " accpstate[%d] = (uchar *) emalloc(nstates%d);", " progstate[%d] = (uchar *) emalloc(nstates%d);", " loopstate%d = loopstate[%d] = (uchar *) emalloc(nstates%d);", " stopstate[%d] = (uchar *) emalloc(nstates%d);", " visstate[%d] = (uchar *) emalloc(nstates%d);", " mapstate[%d] = (short *) emalloc(nstates%d * sizeof(short));", " stopstate[%d][endstate%d] = 1;", 0, }; static const char *R00[] = { " NrStates[%d] = nstates%d;", 0, }; static const char *R0a[] = { " retrans(%d, nstates%d, start%d, src_ln%d, reached%d, loopstate%d);", 0, }; static const char *Code1[] = { "#ifdef NP", " #define ACCEPT_LAB 1 /* at least 1 in np_ */", "#else", " #define ACCEPT_LAB %d /* user-defined accept labels */", "#endif", "#ifdef MEMCNT", " #ifdef MEMLIM", " #warning -DMEMLIM takes precedence over -DMEMCNT", " #undef MEMCNT", " #else", " #if MEMCNT<20", " #warning using minimal value -DMEMCNT=20 (=1MB)", " #define MEMLIM (1)", " #undef MEMCNT", " #else", " #if MEMCNT==20", " #define MEMLIM (1)", " #undef MEMCNT", " #else", " #if MEMCNT>=50", " #error excessive value for MEMCNT", " #else", " #define MEMLIM (1<<(MEMCNT-20))", " #endif", " #endif", " #endif", " #endif", "#endif", "#if NCORE>1 && !defined(MEMLIM)", " #define MEMLIM (2048) /* need a default, using 2 GB */", "#endif", 0, }; static const char *Code3[] = { "#define PROG_LAB %d /* progress labels */", 0, }; static const char *R2[] = { "uchar *accpstate[%d];", "uchar *progstate[%d];", "uchar *loopstate[%d];", "uchar *reached[%d];", "uchar *stopstate[%d];", "uchar *visstate[%d];", "short *mapstate[%d];", "#ifdef HAS_CODE", " int NrStates[%d];", "#endif", 0, }; static const char *R3[] = { " Maxbody = max(Maxbody, ((int) sizeof(Q%d)));", 0, }; static const char *R4[] = { " r_ck(reached%d, nstates%d, %d, src_ln%d, src_file%d);", 0, }; static const char *R5[] = { " case %d: j = sizeof(P%d); break;", 0, }; static const char *R6[] = { " }", " this = o_this;", "#ifdef TRIX", " re_mark_all(1); /* addproc */", "#endif", " return h-BASE;", "#ifndef NOBOUNDCHECK", " #undef Index", " #define Index(x, y) Boundcheck(x, y, II, tt, t)", "#endif", "}\n", "#if defined(BITSTATE) && defined(COLLAPSE)", " /* just to allow compilation, to generate the error */", " long col_p(int i, char *z) { return 0; }", " long col_q(int i, char *z) { return 0; }", "#endif", "#ifndef BITSTATE", " #ifdef COLLAPSE", "long", "col_p(int i, char *z)", "{ int j, k; ulong ordinal(char *, long, short);", " char *x, *y;", " P0 *ptr = (P0 *) pptr(i);", " switch (ptr->_t) {", " case 0: j = sizeof(P0); break;", 0, }; static const char *R7a[] = { "void\nre_mark_all(int whichway)", "{ int j;", " #ifdef V_TRIX", " printf(\"%%d: re_mark_all channels %%d\\n\", depth, whichway);", " #endif", " #ifndef BFS", " for (j = 0; j < now._nr_qs; j++)", " channels[j]->modified = 1; /* channel index moved */", " #endif", " #ifndef TRIX_ORIG", " if (whichway > 0)", " { for (j = now._nr_pr + now._nr_qs - 1; j >= now._nr_pr; j--)", " now._ids_[j] = now._ids_[j-1];", " } else", " { for (j = now._nr_pr; j < now._nr_pr + now._nr_qs; j++)", " now._ids_[j] = now._ids_[j+1];", " }", " #endif", "}", 0, }; static const char *R7b[] = { "#ifdef BFS_PAR", "inline void", "bfs_prepmask(int caller)", "{", "#if !defined(NOCOMP) && !defined(HC)", " memcpy((char *) &tmp_msk, (const char *) Mask, sizeof(State));", " Mask = (uchar *) &tmp_msk;", "#endif", " switch (caller) {", " case 1: /* addproc */", "#if VECTORSZ>32000", " memcpy((char *) P_o_tmp, (const char *) proc_offset, MAXPROC*sizeof(int));", "#else", " memcpy((char *) P_o_tmp, (const char *) proc_offset, MAXPROC*sizeof(short));", "#endif", " memcpy((char *) P_s_tmp, (const char *) proc_skip, MAXPROC*sizeof(uchar));", " proc_offset = P_o_tmp;", " proc_skip = (uchar *) &P_s_tmp[0];", " break;", " case 2: /* addqueue */", "#if VECTORSZ>32000", " memcpy((char *) Q_o_tmp, (const char *) q_offset, MAXQ*sizeof(int));", "#else", " memcpy((char *) Q_o_tmp, (const char *) q_offset, MAXQ*sizeof(short));", "#endif", " memcpy((char *) Q_s_tmp, (const char *) q_skip, MAXQ*sizeof(uchar));", " q_offset = Q_o_tmp;", " q_skip = (uchar *) &Q_s_tmp[0];", " break;", " case 3: /* no nothing */", " break;", " default: /* cannot happen */", " Uerror(\"no good\");", " break;", " }", "}", "", "typedef struct BFS_saves BFS_saves;", "struct BFS_saves {", " char *m;", " BFS_saves *nxt;", "} *bfs_save_po,", " *bfs_save_ps,", "#if !defined(NOCOMP) && !defined(HC)", " *bfs_save_mask,", "#endif", " *bfs_save_qo,", " *bfs_save_qs;", "", "extern volatile uchar *sh_malloc(ulong);", "static int bfs_runs; /* 0 before local heaps are initialized */", "", "void", "bfs_swoosh(BFS_saves **where, char **what, int howmuch)", "{ BFS_saves *m;", " for (m = *where; m; m = m->nxt)", " { if (memcmp(m->m, *what, howmuch) == 0)", " { *what = m->m;", " return;", " } }", " m = (BFS_saves *) emalloc(sizeof(BFS_saves));", " if (bfs_runs)", " { m->m = (char *) sh_malloc(howmuch);", " } else", " { m->m = (char *) sh_pre_malloc(howmuch);", " }", " memcpy(m->m, *what, howmuch);", " m->nxt = *where;", " *where = m;", " *what = m->m;", "}", "", "void", "bfs_fixmask(int caller)", /* 1=addproc, 2=addqueue */ "{", "#if !defined(NOCOMP) && !defined(HC)", " bfs_swoosh(&bfs_save_mask, (char **) &Mask, sizeof(State));", "#endif", "#ifndef TRIX", " switch (caller) {", " case 1: /* addproc */", " #if VECTORSZ>32000", " bfs_swoosh(&bfs_save_po, (char **) &proc_offset, MAXPROC*sizeof(int));", " #else", " bfs_swoosh(&bfs_save_po, (char **) &proc_offset, MAXPROC*sizeof(short));", " #endif", " bfs_swoosh(&bfs_save_ps, (char **) &proc_skip, MAXPROC*sizeof(uchar));", " break;", " case 2: /* addqueue */", " #if VECTORSZ>32000", " bfs_swoosh(&bfs_save_qo, (char **) &q_offset, MAXQ*sizeof(int));", " #else", " bfs_swoosh(&bfs_save_qo, (char **) &q_offset, MAXQ*sizeof(short));", " #endif", " bfs_swoosh(&bfs_save_qs, (char **) &q_skip, MAXQ*sizeof(uchar));", " break;", " case 3: /* do nothing */", " break;", " default:", " Uerror(\"double plus ungood\");", " break;", " }", "#endif", "}", "#endif", 0, }; static const char *R8a[] = { " default: Uerror(\"bad proctype - collapse\");", " }", " if (z) x = z; else x = scratch;", " y = (char *) ptr; k = proc_offset[i];", "", "#if !defined(NOCOMP) && !defined(HC)", " for ( ; j > 0; j--, y++)", " if (!Mask[k++]) *x++ = *y;", "#else", " memcpy(x, y, j);", " x += j;", "#endif", " for (j = 0; j < WS-1; j++)", " *x++ = 0;", " x -= j;", " if (z) return (long) (x - z);", " return ordinal(scratch, x-scratch, (short) (2+ptr->_t));", "}", " #endif", "#endif", 0, }; static const char *R8b[] = { " default: Uerror(\"bad qtype - collapse\");", " }", " if (z) x = z; else x = scratch;", " y = (char *) ptr; k = q_offset[i];", "#if NQS > 0", " /* no need to store the empty slots at the end */", " j -= (q_max[ptr->_t] - ptr->Qlen) * ((j - 2)/q_max[ptr->_t]);", "#endif", "", "#if !defined(NOCOMP) && !defined(HC)", " for ( ; j > 0; j--, y++)", " if (!Mask[k++]) *x++ = *y;", "#else", " memcpy(x, y, j);", " x += j;", "#endif", " for (j = 0; j < WS-1; j++)", " *x++ = 0;", " x -= j;", " if (z) return (long) (x - z);", " return ordinal(scratch, x-scratch, 1); /* chan */", "}", " #endif", "#endif", 0, }; static const char *R12[] = { "\t\tcase %d: r = ((Q%d *)z)->contents[slot].fld%d; break;", 0, }; const char *R13[] = { "int ", "unsend(int into)", "{ int _m=0, j; uchar *z;\n", "#ifdef HAS_SORTED", " int k;", "#endif", " if (!into--)", " uerror(\"ref to uninitialized chan (unsend)\");", "#if defined(TRIX) && !defined(BFS)", " #ifndef TRIX_ORIG", " now._ids_[now._nr_pr+into] = trpt->q_bup;", " #ifdef V_TRIX", " printf(\"%%4d: channel %%d s restore %%p into %%d\\n\",", " depth, into, trpt->q_bup, now._nr_pr+into);", " #endif", " #else", " channels[into]->modified = 1; /* unsend */", " #ifdef V_TRIX", " printf(\"%%4d: channel %%d unmodify\\n\", depth, into);", " #endif", " #endif", "#endif", " z = qptr(into);", " j = ((Q0 *)z)->Qlen;", " ((Q0 *)z)->Qlen = --j;", " switch (((Q0 *)qptr(into))->_t) {", 0, }; const char *R14[] = { " default: Uerror(\"bad queue - unsend\");", " }", " return _m;", "}\n", "void", "unrecv(int from, int slot, int fld, int fldvar, int strt)", "{ int j; uchar *z;\n", " if (!from--)", " uerror(\"ref to uninitialized chan (unrecv)\");", "#if defined(TRIX) && !defined(BFS)", " #ifndef TRIX_ORIG", " now._ids_[now._nr_pr+from] = trpt->q_bup;", " #ifdef V_TRIX", " printf(\"%%4d: channel %%d r restore %%p into %%d\\n\",", " depth, from, trpt->q_bup, now._nr_pr+from);", " #endif", " #else", " channels[from]->modified = 1; /* unrecv */", " #ifdef V_TRIX", " printf(\"%%4d: channel %%d unmodify\\n\", depth, from);", " #endif", " #endif", "#endif", " z = qptr(from);", " j = ((Q0 *)z)->Qlen;", " if (strt) ((Q0 *)z)->Qlen = j+1;", " switch (((Q0 *)qptr(from))->_t) {", 0, }; const char *R15[] = { " default: Uerror(\"bad queue - qrecv\");", " }", "}", 0, }; static const char *Proto[] = { "", "/** function prototypes **/", "char *emalloc(ulong);", "char *Malloc(ulong);", "int Boundcheck(int, int, int, int, Trans *);", "int addqueue(int, int, int);", "/* int atoi(char *); */", "/* int abort(void); */", "int close(int);", /* should probably remove this */ #if 0 "#ifndef SC", " int creat(char *, unsigned short);", " int write(int, void *, unsigned);", "#endif", #endif "int delproc(int, int);", "int endstate(void);", "int find_claim(char *);", "int h_store(char *, int);", "int pan_rand(void);", "int q_cond(short, Trans *);", "int q_full(int);", "int q_len(int);", "int q_zero(int);", "int qrecv(int, int, int, int);", "int unsend(int);", "/* void *sbrk(int); */", "void spin_assert(int, char *, int, int, Trans *);", "#ifdef BFS_PAR", "void bfs_printf(const char *, ...);", "volatile uchar *sh_pre_malloc(ulong);", "#endif", "void c_chandump(int);", "void c_globals(void);", "void c_locals(int, int);", "void checkcycles(void);", "void crack(int, int, Trans *, short *);", "void d_sfh(uchar *, int);", "void d_hash(uchar *, int);", "void m_hash(uchar *, int);", "void s_hash(uchar *, int);", "void delq(int);", "void dot_crack(int, int, Trans *);", "void do_reach(void);", "void pan_exit(int);", "void exit(int);", "#ifdef BFS_PAR", " void bfs_setup_mem(void);", "#endif", "#ifdef BITSTATE", " void sinit(void);", "#else", " void hinit(void);", "#endif", "void imed(Trans *, int, int, int);", "void new_state(void);", "void p_restor(int);", "void putpeg(int, int);", "void putrail(void);", "void q_restor(void);", "void retrans(int, int, int, short *, uchar *, uchar *);", "void select_claim(int);", "void settable(void);", "void setq_claim(int, int, char *, int, char *);", "void sv_restor(void);", "void sv_save(void);", "void tagtable(int, int, int, short *, uchar *);", "void do_dfs(int, int, int, short *, uchar *, uchar *);", "void unrecv(int, int, int, int, int);", "void usage(FILE *);", "void wrap_stats(void);\n", "#ifdef MA", " int g_store(char *, int, uchar);", "#endif", "#if defined(FULLSTACK) && defined(BITSTATE)", " int onstack_now(void);", " void onstack_init(void);", " void onstack_put(void);", " void onstack_zap(void);", "#endif", "#ifndef XUSAFE", " int q_S_check(int, int);", " int q_R_check(int, int);", " uchar q_claim[MAXQ+1];", " char *q_name[MAXQ+1];", " char *p_name[MAXPROC+1];", "#endif", "", "#ifndef NO_V_PROVISO", " #define V_PROVISO", "#endif", "#if !defined(NO_RESIZE) && !defined(AUTO_RESIZE) && !defined(BITSTATE) && !defined(SPACE) && !defined(USE_TDH) && NCORE==1", " #define AUTO_RESIZE", "#endif", "", "typedef struct Trail Trail;", "typedef struct H_el H_el;", "", "struct H_el {", " H_el *nxt;", " #ifdef FULLSTACK", " unsigned int tagged;", " #if defined(BITSTATE) && !defined(NOREDUCE) && !defined(SAFETY)", " unsigned int proviso;", /* uses just 1 bit 0/1 */ " #endif", " #endif", " #if defined(CHECK) || (defined(COLLAPSE) && !defined(FULLSTACK))", " ulong st_id;", " #endif", " #if !defined(SAFETY) || defined(REACH)", " uint D;", " #endif", " #ifdef BCS", " #ifndef CONSERVATIVE", " #define CONSERVATIVE 1 /* good for up to 8 processes */", " #endif", " #ifdef CONSERVATIVE", " #if CONSERVATIVE <= 0 || CONSERVATIVE>32", " #error sensible values for CONSERVATIVE are 1..32 (256/8 = 32)", " #endif", " uchar ctx_pid[CONSERVATIVE];", /* pids setting lowest value */ " #endif", " uchar ctx_low;", /* lowest nr of context switches seen so far */ " #endif", " #if NCORE>1", " /* could cost 1 extra word: 4 bytes if 32-bit and 8 bytes if 64-bit */", " #ifdef V_PROVISO", " uchar cpu_id; /* id of cpu that created the state */", " #endif", " #endif", " #ifdef COLLAPSE", " #if VECTORSZ<65536", " ushort ln;", /* length of vector */ " #else", " ulong ln;", /* length of vector */ " #endif", " #endif", " #if defined(AUTO_RESIZE) && !defined(BITSTATE)", " ulong m_K1;", " #endif", " ulong state;", "};", "", "#ifdef BFS_PAR", "typedef struct BFS_Trail BFS_Trail;", "struct BFS_Trail {", " H_el *ostate;", " int st;", " int o_tt;", " T_ID t_id;", /* could be uint, ushort, or uchar */ " uchar pr;", " uchar o_pm;", " uchar tau;", "};", " #if SYNC>0", " #undef BFS_NOTRAIL", /* just in case it was used */ " #endif", "#endif", "", "#ifdef RHASH", " #ifndef PERMUTED", " #define PERMUTED", " #endif", "#endif", "", "struct Trail {", " int st; /* current state */", " int o_tt;", "#ifdef PERMUTED", " uint seed;", " uchar oII;", "#endif", " uchar pr; /* process id */", " uchar tau; /* 8 bit-flags */", " uchar o_pm; /* 8 more bit-flags */", "", " #if 0", " Meaning of bit-flags on tau and o_pm:", " tau&1 -> timeout enabled", " tau&2 -> request to enable timeout 1 level up (in claim)", " tau&4 -> current transition is a claim move", " tau&8 -> current transition is an atomic move", " tau&16 -> last move was truncated on stack", " tau&32 -> current transition is a preselected move", " tau&64 -> at least one next state is not on the stack", " tau&128 -> current transition is a stutter move", " o_pm&1 -> the current pid moved -- implements else", " o_pm&2 -> this is an acceptance state", " o_pm&4 -> this is a progress state", " o_pm&8 -> fairness alg rule 1 undo mark", " o_pm&16 -> fairness alg rule 3 undo mark", " o_pm&32 -> fairness alg rule 2 undo mark", " o_pm&64 -> the current proc applied rule2", " o_pm&128 -> a fairness, dummy move - all procs blocked", " #endif", "", " #ifdef NSUCC", " uchar n_succ; /* nr of successor states */", " #endif", " #if defined(FULLSTACK) && defined(MA) && !defined(BFS)", " uchar proviso;", " #endif", " #ifndef BFS", " uchar o_n, o_ot; /* to save locals */", " #endif", " uchar o_m;", " #ifdef EVENT_TRACE", " #if nstates_event<256", " uchar o_event;", " #else", " unsigned short o_event;", " #endif", " #endif", " #ifndef BFS", " short o_To;", " #if defined(T_RAND) || defined(RANDOMIZE)", " short oo_i;", " #endif", " #endif", " #if defined(HAS_UNLESS) && !defined(BFS)", " int e_state; /* if escape trans - state of origin */", " #endif", " #if (defined(FULLSTACK) && !defined(MA)) || defined(BFS) || (NCORE>1)", " H_el *ostate; /* pointer to stored state */", " #endif", /* CNTRSTACK when !NOREDUCE && BITSTATE && SAFETY && WS<=4, uses LL[] */ " #if defined(CNTRSTACK) && !defined(BFS)", " long j6, j7;", " #endif", " Trans *o_t;", /* transition fct, next state */ " #if !defined(BFS) && !defined(TRIX_ORIG)", " char *p_bup;", " char *q_bup;", " #endif", " #ifdef BCS", " unsigned short sched_limit;", " unsigned char bcs; /* phase 1 or 2, or forced 4 */", " unsigned char b_pno; /* preferred pid */", " #endif", " #ifdef P_RAND", /* process scheduling randomization */ " unsigned char p_left; /* nr of procs left to explore */", " short p_skip; /* to find starting point in list */", " #endif", " #ifdef HAS_SORTED", " short ipt;", /* insertion slot in q */ " #endif", " #ifdef HAS_PRIORITY", " short o_priority;", " #endif", " union {", " int oval;", /* single backup value of variable */ " int *ovals;", /* ptr to multiple values */ " } bup;", "}; /* end of struct Trail */", "", "#ifdef BFS", /* breadth-first search */ " #define Q_PROVISO", " #ifndef INLINE_REV", " #define INLINE_REV", " #endif", "", "typedef struct SV_Hold {", " State *sv;", " #ifndef BFS_PAR", " int sz;", " #endif", " struct SV_Hold *nxt;", "} SV_Hold;", "#if !defined(BFS_PAR) || NRUNS>0", " typedef struct EV_Hold {", " #if !defined(BFS_PAR) || (!defined(NOCOMP) && !defined(HC) && NRUNS>0)", " char *sv; /* Mask */", " #endif", " #if VECTORSZ<65536", " ushort sz; /* vsize */", " #else", " ulong sz;", " #endif", " #ifdef BFS_PAR", " uchar owner;", " #endif", " uchar nrpr;", " uchar nrqs;", " #if !defined(BFS_PAR) || (!defined(TRIX) && NRUNS>0)", " char *po, *qo;", " char *ps, *qs;", " #endif", " struct EV_Hold *nxt;", " } EV_Hold;", "#endif", "typedef struct BFS_State {", " #ifdef BFS_PAR", " BFS_Trail *t_info;", " State *osv;", " #else", " Trail *frame;", " SV_Hold *onow;", " #endif", " #if !defined(BFS_PAR) || NRUNS>0", " EV_Hold *omask;", " #endif", " #if defined(Q_PROVISO) && !defined(NOREDUCE)", " H_el *lstate;", " #endif", " #if !defined(BFS_PAR) || SYNC>0", " short boq;", " #endif", " #ifdef VERBOSE", " ulong nr;", " #endif", " #ifndef BFS_PAR", /* new 6.2.4, 3 dec 2012 */ " struct BFS_State *nxt;", " #endif", "} BFS_State;", "#endif\n", 0, }; static const char *SvMap[] = { "void", "to_compile(void)", "{ char ctd[2048], carg[128];", "#ifdef BITSTATE", " strcpy(ctd, \"-DBITSTATE \");", "#else", " strcpy(ctd, \"\");", "#endif", "#ifdef BFS_PAR", " strcat(ctd, \"-DBFS_PAR \");", "#endif", "#ifdef NOVSZ", " strcat(ctd, \"-DNOVSZ \");", "#endif", "#ifdef RHASH", " strcat(ctd, \"-DRHASH \");", "#else", " #ifdef PERMUTED", " strcat(ctd, \"-DPERMUTED \");", " #endif", "#endif", "#ifdef P_REVERSE", " strcat(ctd, \"-DP_REVERSE \");", "#endif", "#ifdef T_REVERSE", " strcat(ctd, \"-DT_REVERSE \");", "#endif", "#ifdef T_RAND", " #if T_RAND>0", " sprintf(carg, \"-DT_RAND=%%d \", T_RAND);", " strcat(ctd, carg);", " #else", " strcat(ctd, \"-DT_RAND \");", " #endif", "#endif", "#ifdef P_RAND", " #if P_RAND>0", " sprintf(carg, \"-DP_RAND=%%d \", P_RAND);", " strcat(ctd, carg);", " #else", " strcat(ctd, \"-DP_RAND \");", " #endif", "#endif", "#ifdef BCS", " sprintf(carg, \"-DBCS=%%d \", BCS);", " strcat(ctd, carg);", "#endif", "#ifdef BFS", " strcat(ctd, \"-DBFS \");", "#endif", "#ifdef MEMLIM", " sprintf(carg, \"-DMEMLIM=%%d \", MEMLIM);", " strcat(ctd, carg);", "#else", "#ifdef MEMCNT", " sprintf(carg, \"-DMEMCNT=%%d \", MEMCNT);", " strcat(ctd, carg);", "#endif", "#endif", "#ifdef NOCLAIM", " strcat(ctd, \"-DNOCLAIM \");", "#endif", "#ifdef SAFETY", " strcat(ctd, \"-DSAFETY \");", "#else", "#ifdef NOFAIR", " strcat(ctd, \"-DNOFAIR \");", "#else", "#ifdef NFAIR", " if (NFAIR != 2)", " { sprintf(carg, \"-DNFAIR=%%d \", NFAIR);", " strcat(ctd, carg);", " }", "#endif", "#endif", "#endif", "#ifdef NOREDUCE", " strcat(ctd, \"-DNOREDUCE \");", "#else", "#ifdef XUSAFE", " strcat(ctd, \"-DXUSAFE \");", "#endif", "#endif", "#ifdef NP", " strcat(ctd, \"-DNP \");", "#endif", "#ifdef PEG", " strcat(ctd, \"-DPEG \");", "#endif", "#ifdef VAR_RANGES", " strcat(ctd, \"-DVAR_RANGES \");", "#endif", "#ifdef HC", " strcat(ctd, \"-DHC \");", "#endif", "#ifdef CHECK", " strcat(ctd, \"-DCHECK \");", "#endif", "#ifdef CTL", " strcat(ctd, \"-DCTL \");", "#endif", "#ifdef TRIX", " strcat(ctd, \"-DTRIX \");", "#endif", "#ifdef NIBIS", " strcat(ctd, \"-DNIBIS \");", "#endif", "#ifdef NOBOUNDCHECK", " strcat(ctd, \"-DNOBOUNDCHECK \");", "#endif", "#ifdef NOSTUTTER", " strcat(ctd, \"-DNOSTUTTER \");", "#endif", "#ifdef REACH", " strcat(ctd, \"-DREACH \");", "#endif", "#ifdef PRINTF", " strcat(ctd, \"-DPRINTF \");", "#endif", "#ifdef COLLAPSE", " strcat(ctd, \"-DCOLLAPSE \");", "#endif", "#ifdef MA", " sprintf(carg, \"-DMA=%%d \", MA);", " strcat(ctd, carg);", "#endif", "#ifdef SVDUMP", " strcat(ctd, \"-DSVDUMP \");", "#endif", "#if defined(VECTORSZ) && !defined(TRIX)", " if (VECTORSZ != 1024)", " { sprintf(carg, \"-DVECTORSZ=%%d \", VECTORSZ);", " strcat(ctd, carg);", " }", "#endif", "#ifdef VERBOSE", " strcat(ctd, \"-DVERBOSE \");", "#endif", "#ifdef CHECK", " strcat(ctd, \"-DCHECK \");", "#endif", "#ifdef SDUMP", " strcat(ctd, \"-DSDUMP \");", "#endif", "#if NCORE>1", " sprintf(carg, \"-DNCORE=%%d \", NCORE);", " strcat(ctd, carg);", "#endif", "#ifdef VMAX", " if (VMAX != 256)", " { sprintf(carg, \"-DVMAX=%%d \", VMAX);", " strcat(ctd, carg);", " }", "#endif", "#ifdef PMAX", " if (PMAX != 16)", " { sprintf(carg, \"-DPMAX=%%d \", PMAX);", " strcat(ctd, carg);", " }", "#endif", "#ifdef QMAX", " if (QMAX != 16)", " { sprintf(carg, \"-DQMAX=%%d \", QMAX);", " strcat(ctd, carg);", " }", "#endif", "#ifdef SET_WQ_SIZE", " sprintf(carg, \"-DSET_WQ_SIZE=%%d \", SET_WQ_SIZE);", " strcat(ctd, carg);", "#endif", " printf(\"Compiled as: cc -o pan %%span.c\\n\", ctd);", "}", 0, }; Spin/Src6.4.5/spin.y0000664000175100017510000007100712641605057012051 0ustar ghgh/***** spin: spin.y *****/ /* * This file is part of the public release of Spin. It is subject to the * terms in the LICENSE file that is included in this source directory. * Tool documentation is available at http://spinroot.com */ %{ #include "spin.h" #include #ifndef PC #include #endif #include #define YYMAXDEPTH 20000 /* default is 10000 */ #define YYDEBUG 0 #define Stop nn(ZN,'@',ZN,ZN) #define PART0 "place initialized declaration of " #define PART1 "place initialized chan decl of " #define PART2 " at start of proctype " static Lextok *ltl_to_string(Lextok *); extern Symbol *context, *owner; extern Lextok *for_body(Lextok *, int); extern void for_setup(Lextok *, Lextok *, Lextok *); extern Lextok *for_index(Lextok *, Lextok *); extern Lextok *sel_index(Lextok *, Lextok *, Lextok *); extern void keep_track_off(Lextok *); extern void safe_break(void); extern void restore_break(void); extern int u_sync, u_async, dumptab, scope_level; extern int initialization_ok; extern short has_sorted, has_random, has_enabled, has_pcvalue, has_np, has_priority; extern short has_code, has_state, has_ltl, has_io; extern void count_runs(Lextok *); extern void no_internals(Lextok *); extern void any_runs(Lextok *); extern void explain(int); extern void ltl_list(char *, char *); extern void validref(Lextok *, Lextok *); extern void sanity_check(Lextok *); extern char yytext[]; int Mpars = 0; /* max nr of message parameters */ int nclaims = 0; /* nr of never claims */ int ltl_mode = 0; /* set when parsing an ltl formula */ int Expand_Ok = 0, realread = 1, IArgs = 0, NamesNotAdded = 0; int in_for = 0, in_seq = 0, par_cnt = 0; int dont_simplify = 0; char *claimproc = (char *) 0; char *eventmap = (char *) 0; static char *ltl_name; static int Embedded = 0, inEventMap = 0, has_ini = 0; %} %token ASSERT PRINT PRINTM PREPROC %token C_CODE C_DECL C_EXPR C_STATE C_TRACK %token RUN LEN ENABLED SET_P GET_P EVAL PC_VAL %token TYPEDEF MTYPE INLINE RETURN LABEL OF %token GOTO BREAK ELSE SEMI ARROW %token IF FI DO OD FOR SELECT IN SEP DOTDOT %token ATOMIC NON_ATOMIC D_STEP UNLESS %token TIMEOUT NONPROGRESS %token ACTIVE PROCTYPE D_PROCTYPE %token HIDDEN SHOW ISLOCAL %token PRIORITY PROVIDED %token FULL EMPTY NFULL NEMPTY %token CONST TYPE XU /* val */ %token NAME UNAME PNAME INAME /* sym */ %token STRING CLAIM TRACE INIT LTL /* sym */ %right ASGN %left SND O_SND RCV R_RCV /* SND doubles as boolean negation */ %left IMPLIES EQUIV /* ltl */ %left OR %left AND %left ALWAYS EVENTUALLY /* ltl */ %left UNTIL WEAK_UNTIL RELEASE /* ltl */ %right NEXT /* ltl */ %left '|' %left '^' %left '&' %left EQ NE %left GT LT GE LE %left LSHIFT RSHIFT %left '+' '-' %left '*' '/' '%' %left INCR DECR %right '~' UMIN NEG %left DOT %% /** PROMELA Grammar Rules **/ program : units { yytext[0] = '\0'; } ; units : unit | units unit ; unit : proc /* proctype { } */ | init /* init { } */ | claim /* never claim */ | ltl /* ltl formula */ | events /* event assertions */ | one_decl /* variables, chans */ | utype /* user defined types */ | c_fcts /* c functions etc. */ | ns /* named sequence */ | semi /* optional separator */ | error ; l_par : '(' { par_cnt++; } ; r_par : ')' { par_cnt--; } ; proc : inst /* optional instantiator */ proctype NAME { setptype($3, PROCTYPE, ZN); setpname($3); context = $3->sym; context->ini = $2; /* linenr and file */ Expand_Ok++; /* expand struct names in decl */ has_ini = 0; } l_par decl r_par { Expand_Ok--; if (has_ini) fatal("initializer in parameter list", (char *) 0); } Opt_priority Opt_enabler body { ProcList *rl; if ($1 != ZN && $1->val > 0) { int j; rl = ready($3->sym, $6, $11->sq, $2->val, $10, A_PROC); for (j = 0; j < $1->val; j++) { runnable(rl, $9?$9->val:1, 1); announce(":root:"); } if (dumptab) $3->sym->ini = $1; } else { rl = ready($3->sym, $6, $11->sq, $2->val, $10, P_PROC); } if (rl && has_ini == 1) /* global initializations, unsafe */ { /* printf("proctype %s has initialized data\n", $3->sym->name); */ rl->unsafe = 1; } context = ZS; } ; proctype: PROCTYPE { $$ = nn(ZN,CONST,ZN,ZN); $$->val = 0; } | D_PROCTYPE { $$ = nn(ZN,CONST,ZN,ZN); $$->val = 1; } ; inst : /* empty */ { $$ = ZN; } | ACTIVE { $$ = nn(ZN,CONST,ZN,ZN); $$->val = 1; } | ACTIVE '[' const_expr ']' { $$ = nn(ZN,CONST,ZN,ZN); $$->val = $3->val; if ($3->val > 255) non_fatal("max nr of processes is 255\n", ""); } | ACTIVE '[' NAME ']' { $$ = nn(ZN,CONST,ZN,ZN); $$->val = 0; if (!$3->sym->type) fatal("undeclared variable %s", $3->sym->name); else if ($3->sym->ini->ntyp != CONST) fatal("need constant initializer for %s\n", $3->sym->name); else $$->val = $3->sym->ini->val; } ; init : INIT { context = $1->sym; } Opt_priority body { ProcList *rl; rl = ready(context, ZN, $4->sq, 0, ZN, I_PROC); runnable(rl, $3?$3->val:1, 1); announce(":root:"); context = ZS; } ; ltl : LTL optname2 { ltl_mode = 1; ltl_name = $2->sym->name; } ltl_body { if ($4) ltl_list($2->sym->name, $4->sym->name); ltl_mode = 0; has_ltl = 1; } ; ltl_body: '{' full_expr OS '}' { $$ = ltl_to_string($2); } | error { $$ = NULL; } ; claim : CLAIM optname { if ($2 != ZN) { $1->sym = $2->sym; /* new 5.3.0 */ } nclaims++; context = $1->sym; if (claimproc && !strcmp(claimproc, $1->sym->name)) { fatal("claim %s redefined", claimproc); } claimproc = $1->sym->name; } body { (void) ready($1->sym, ZN, $4->sq, 0, ZN, N_CLAIM); context = ZS; } ; optname : /* empty */ { char tb[32]; memset(tb, 0, 32); sprintf(tb, "never_%d", nclaims); $$ = nn(ZN, NAME, ZN, ZN); $$->sym = lookup(tb); } | NAME { $$ = $1; } ; optname2 : /* empty */ { char tb[32]; static int nltl = 0; memset(tb, 0, 32); sprintf(tb, "ltl_%d", nltl++); $$ = nn(ZN, NAME, ZN, ZN); $$->sym = lookup(tb); } | NAME { $$ = $1; } ; events : TRACE { context = $1->sym; if (eventmap) non_fatal("trace %s redefined", eventmap); eventmap = $1->sym->name; inEventMap++; } body { if (strcmp($1->sym->name, ":trace:") == 0) { (void) ready($1->sym, ZN, $3->sq, 0, ZN, E_TRACE); } else { (void) ready($1->sym, ZN, $3->sq, 0, ZN, N_TRACE); } context = ZS; inEventMap--; } ; utype : TYPEDEF NAME '{' { if (context) { fatal("typedef %s must be global", $2->sym->name); } owner = $2->sym; in_seq = $1->ln; } decl_lst '}' { setuname($5); owner = ZS; in_seq = 0; } ; nm : NAME { $$ = $1; } | INAME { $$ = $1; if (IArgs) fatal("invalid use of '%s'", $1->sym->name); } ; ns : INLINE nm l_par { NamesNotAdded++; } args r_par { prep_inline($2->sym, $5); NamesNotAdded--; } ; c_fcts : ccode { /* leaves pseudo-inlines with sym of * type CODE_FRAG or CODE_DECL in global context */ } | cstate ; cstate : C_STATE STRING STRING { c_state($2->sym, $3->sym, ZS); has_code = has_state = 1; } | C_TRACK STRING STRING { c_track($2->sym, $3->sym, ZS); has_code = has_state = 1; } | C_STATE STRING STRING STRING { c_state($2->sym, $3->sym, $4->sym); has_code = has_state = 1; } | C_TRACK STRING STRING STRING { c_track($2->sym, $3->sym, $4->sym); has_code = has_state = 1; } ; ccode : C_CODE { Symbol *s; NamesNotAdded++; s = prep_inline(ZS, ZN); NamesNotAdded--; $$ = nn(ZN, C_CODE, ZN, ZN); $$->sym = s; $$->ln = $1->ln; $$->fn = $1->fn; has_code = 1; } | C_DECL { Symbol *s; NamesNotAdded++; s = prep_inline(ZS, ZN); NamesNotAdded--; s->type = CODE_DECL; $$ = nn(ZN, C_CODE, ZN, ZN); $$->sym = s; $$->ln = $1->ln; $$->fn = $1->fn; has_code = 1; } ; cexpr : C_EXPR { Symbol *s; NamesNotAdded++; s = prep_inline(ZS, ZN); /* if context is 0 this was inside an ltl formula mark the last inline added to seqnames */ if (!context) { mark_last(); } NamesNotAdded--; $$ = nn(ZN, C_EXPR, ZN, ZN); $$->sym = s; $$->ln = $1->ln; $$->fn = $1->fn; no_side_effects(s->name); has_code = 1; } ; body : '{' { open_seq(1); in_seq = $1->ln; } sequence OS { add_seq(Stop); } '}' { $$->sq = close_seq(0); in_seq = 0; if (scope_level != 0) { non_fatal("missing '}' ?", 0); scope_level = 0; } } ; sequence: step { if ($1) add_seq($1); } | sequence MS step { if ($3) add_seq($3); } ; step : one_decl { $$ = ZN; } | XU vref_lst { setxus($2, $1->val); $$ = ZN; } | NAME ':' one_decl { fatal("label preceding declaration,", (char *)0); } | NAME ':' XU { fatal("label predecing xr/xs claim,", 0); } | stmnt { $$ = $1; } | stmnt UNLESS { if ($1->ntyp == DO) { safe_break(); } } stmnt { if ($1->ntyp == DO) { restore_break(); } $$ = do_unless($1, $4); } ; vis : /* empty */ { $$ = ZN; } | HIDDEN { $$ = $1; } | SHOW { $$ = $1; } | ISLOCAL { $$ = $1; } ; asgn: /* empty */ | ASGN ; one_decl: vis TYPE var_list { setptype($3, $2->val, $1); $$ = $3; } | vis UNAME var_list { setutype($3, $2->sym, $1); $$ = expand($3, Expand_Ok); } | vis TYPE asgn '{' nlst '}' { if ($2->val != MTYPE) fatal("malformed declaration", 0); setmtype($5); if ($1) non_fatal("cannot %s mtype (ignored)", $1->sym->name); if (context != ZS) fatal("mtype declaration must be global", 0); } ; decl_lst: one_decl { $$ = nn(ZN, ',', $1, ZN); } | one_decl SEMI decl_lst { $$ = nn(ZN, ',', $1, $3); } ; decl : /* empty */ { $$ = ZN; } | decl_lst { $$ = $1; } ; vref_lst: varref { $$ = nn($1, XU, $1, ZN); } | varref ',' vref_lst { $$ = nn($1, XU, $1, $3); } ; var_list: ivar { $$ = nn($1, TYPE, ZN, ZN); } | ivar ',' var_list { $$ = nn($1, TYPE, ZN, $3); } ; c_list : CONST { $1->ntyp = CONST; $$ = $1; } | CONST ',' c_list { $1->ntyp = CONST; $$ = nn($1, ',', $1, $3); } ; ivar : vardcl { $$ = $1; $1->sym->ini = nn(ZN,CONST,ZN,ZN); $1->sym->ini->val = 0; if (!initialization_ok) { Lextok *zx, *xz; zx = nn(ZN, NAME, ZN, ZN); zx->sym = $1->sym; xz = nn(zx, ASGN, zx, $1->sym->ini); keep_track_off(xz); /* make sure zx doesnt turn out to be a STRUCT later */ add_seq(xz); } } | vardcl ASGN '{' c_list '}' { if (!$1->sym->isarray) fatal("%s must be an array", $1->sym->name); $$ = $1; $1->sym->ini = $4; has_ini = 1; $1->sym->hidden |= (4|8); /* conservative */ if (!initialization_ok) { Lextok *zx = nn(ZN, NAME, ZN, ZN); zx->sym = $1->sym; add_seq(nn(zx, ASGN, zx, $4)); } } | vardcl ASGN expr { $$ = $1; $1->sym->ini = $3; if ($3->ntyp == CONST || ($3->ntyp == NAME && $3->sym->context)) { has_ini = 2; /* local init */ } else { has_ini = 1; /* possibly global */ } trackvar($1, $3); nochan_manip($1, $3, 0); no_internals($1); if (!initialization_ok) { Lextok *zx = nn(ZN, NAME, ZN, ZN); zx->sym = $1->sym; add_seq(nn(zx, ASGN, zx, $3)); } } | vardcl ASGN ch_init { $1->sym->ini = $3; $$ = $1; has_ini = 1; if (!initialization_ok) { non_fatal(PART1 "'%s'" PART2, $1->sym->name); } } ; ch_init : '[' const_expr ']' OF '{' typ_list '}' { if ($2->val) u_async++; else u_sync++; { int i = cnt_mpars($6); Mpars = max(Mpars, i); } $$ = nn(ZN, CHAN, ZN, $6); $$->val = $2->val; $$->ln = $1->ln; $$->fn = $1->fn; } ; vardcl : NAME { $1->sym->nel = 1; $$ = $1; } | NAME ':' CONST { $1->sym->nbits = $3->val; if ($3->val >= 8*sizeof(long)) { non_fatal("width-field %s too large", $1->sym->name); $3->val = 8*sizeof(long)-1; } $1->sym->nel = 1; $$ = $1; } | NAME '[' const_expr ']' { $1->sym->nel = $3->val; $1->sym->isarray = 1; $$ = $1; } | NAME '[' NAME ']' { /* make an exception for an initialized scalars */ $$ = nn(ZN, CONST, ZN, ZN); fprintf(stderr, "spin: %s:%d, warning: '%s' in array bound ", $1->fn->name, $1->ln, $1->sym->name); if ($3->sym->ini->val > 0) { fprintf(stderr, "evaluated as %d\n", $3->sym->ini->val); $$->val = $3->sym->ini->val; } else { fprintf(stderr, "evaluated as 8 by default (to avoid zero)\n"); $$->val = 8; } $1->sym->nel = $$->val; $1->sym->isarray = 1; $$ = $1; } ; varref : cmpnd { $$ = mk_explicit($1, Expand_Ok, NAME); } ; pfld : NAME { $$ = nn($1, NAME, ZN, ZN); if ($1->sym->isarray && !in_for) { non_fatal("missing array index for '%s'", $1->sym->name); } } | NAME { owner = ZS; } '[' expr ']' { $$ = nn($1, NAME, $4, ZN); } ; cmpnd : pfld { Embedded++; if ($1->sym->type == STRUCT) owner = $1->sym->Snm; } sfld { $$ = $1; $$->rgt = $3; if ($3 && $1->sym->type != STRUCT) $1->sym->type = STRUCT; Embedded--; if (!Embedded && !NamesNotAdded && !$1->sym->type) fatal("undeclared variable: %s", $1->sym->name); if ($3) validref($1, $3->lft); owner = ZS; } ; sfld : /* empty */ { $$ = ZN; } | '.' cmpnd %prec DOT { $$ = nn(ZN, '.', $2, ZN); } ; stmnt : Special { $$ = $1; initialization_ok = 0; } | Stmnt { $$ = $1; initialization_ok = 0; if (inEventMap) non_fatal("not an event", (char *)0); } ; for_pre : FOR l_par { in_for = 1; } varref { trapwonly($4 /*, "for" */); pushbreak(); /* moved up */ $$ = $4; } ; for_post: '{' sequence OS '}' ; Special : varref RCV { Expand_Ok++; } rargs { Expand_Ok--; has_io++; $$ = nn($1, 'r', $1, $4); trackchanuse($4, ZN, 'R'); } | varref SND { Expand_Ok++; } margs { Expand_Ok--; has_io++; $$ = nn($1, 's', $1, $4); $$->val=0; trackchanuse($4, ZN, 'S'); any_runs($4); } | for_pre ':' expr DOTDOT expr r_par { for_setup($1, $3, $5); in_for = 0; } for_post { $$ = for_body($1, 1); } | for_pre IN varref r_par { $$ = for_index($1, $3); in_for = 0; } for_post { $$ = for_body($5, 1); } | SELECT l_par varref ':' expr DOTDOT expr r_par { trapwonly($3 /*, "select" */); $$ = sel_index($3, $5, $7); } | IF options FI { $$ = nn($1, IF, ZN, ZN); $$->sl = $2->sl; $$->ln = $1->ln; $$->fn = $1->fn; prune_opts($$); } | DO { pushbreak(); } options OD { $$ = nn($1, DO, ZN, ZN); $$->sl = $3->sl; $$->ln = $1->ln; $$->fn = $1->fn; prune_opts($$); } | BREAK { $$ = nn(ZN, GOTO, ZN, ZN); $$->sym = break_dest(); } | GOTO NAME { $$ = nn($2, GOTO, ZN, ZN); if ($2->sym->type != 0 && $2->sym->type != LABEL) { non_fatal("bad label-name %s", $2->sym->name); } $2->sym->type = LABEL; } | NAME ':' stmnt { $$ = nn($1, ':',$3, ZN); if ($1->sym->type != 0 && $1->sym->type != LABEL) { non_fatal("bad label-name %s", $1->sym->name); } $1->sym->type = LABEL; } | NAME ':' { $$ = nn($1, ':',ZN,ZN); if ($1->sym->type != 0 && $1->sym->type != LABEL) { non_fatal("bad label-name %s", $1->sym->name); } $$->lft = nn(ZN, 'c', nn(ZN,CONST,ZN,ZN), ZN); $$->lft->lft->val = 1; /* skip */ $1->sym->type = LABEL; } | error { $$ = nn(ZN, 'c', nn(ZN,CONST,ZN,ZN), ZN); $$->lft->val = 1; /* skip */ } ; Stmnt : varref ASGN full_expr { $$ = nn($1, ASGN, $1, $3); trackvar($1, $3); nochan_manip($1, $3, 0); no_internals($1); } | varref INCR { $$ = nn(ZN,CONST, ZN, ZN); $$->val = 1; $$ = nn(ZN, '+', $1, $$); $$ = nn($1, ASGN, $1, $$); trackvar($1, $1); no_internals($1); if ($1->sym->type == CHAN) fatal("arithmetic on chan", (char *)0); } | varref DECR { $$ = nn(ZN,CONST, ZN, ZN); $$->val = 1; $$ = nn(ZN, '-', $1, $$); $$ = nn($1, ASGN, $1, $$); trackvar($1, $1); no_internals($1); if ($1->sym->type == CHAN) fatal("arithmetic on chan id's", (char *)0); } | SET_P l_par two_args r_par { $$ = nn(ZN, SET_P, $3, ZN); has_priority++; } | PRINT l_par STRING { realread = 0; } prargs r_par { $$ = nn($3, PRINT, $5, ZN); realread = 1; } | PRINTM l_par varref r_par { $$ = nn(ZN, PRINTM, $3, ZN); } | PRINTM l_par CONST r_par { $$ = nn(ZN, PRINTM, $3, ZN); } | ASSERT full_expr { $$ = nn(ZN, ASSERT, $2, ZN); AST_track($2, 0); } | ccode { $$ = $1; } | varref R_RCV { Expand_Ok++; } rargs { Expand_Ok--; has_io++; $$ = nn($1, 'r', $1, $4); $$->val = has_random = 1; trackchanuse($4, ZN, 'R'); } | varref RCV { Expand_Ok++; } LT rargs GT { Expand_Ok--; has_io++; $$ = nn($1, 'r', $1, $5); $$->val = 2; /* fifo poll */ trackchanuse($5, ZN, 'R'); } | varref R_RCV { Expand_Ok++; } LT rargs GT { Expand_Ok--; has_io++; /* rrcv poll */ $$ = nn($1, 'r', $1, $5); $$->val = 3; has_random = 1; trackchanuse($5, ZN, 'R'); } | varref O_SND { Expand_Ok++; } margs { Expand_Ok--; has_io++; $$ = nn($1, 's', $1, $4); $$->val = has_sorted = 1; trackchanuse($4, ZN, 'S'); any_runs($4); } | full_expr { $$ = nn(ZN, 'c', $1, ZN); count_runs($$); } | ELSE { $$ = nn(ZN,ELSE,ZN,ZN); } | ATOMIC '{' { open_seq(0); } sequence OS '}' { $$ = nn($1, ATOMIC, ZN, ZN); $$->sl = seqlist(close_seq(3), 0); $$->ln = $1->ln; $$->fn = $1->fn; make_atomic($$->sl->this, 0); } | D_STEP '{' { open_seq(0); rem_Seq(); } sequence OS '}' { $$ = nn($1, D_STEP, ZN, ZN); $$->sl = seqlist(close_seq(4), 0); $$->ln = $1->ln; $$->fn = $1->fn; make_atomic($$->sl->this, D_ATOM); unrem_Seq(); } | '{' { open_seq(0); } sequence OS '}' { $$ = nn(ZN, NON_ATOMIC, ZN, ZN); $$->sl = seqlist(close_seq(5), 0); $$->ln = $1->ln; $$->fn = $1->fn; } | INAME { IArgs++; } l_par args r_par { initialization_ok = 0; pickup_inline($1->sym, $4, ZN); IArgs--; } Stmnt { $$ = $7; } | varref ASGN INAME { IArgs++; } l_par args r_par { initialization_ok = 0; pickup_inline($3->sym, $6, $1); IArgs--; } Stmnt { $$ = $9; } | RETURN full_expr { $$ = return_statement($2); } ; options : option { $$->sl = seqlist($1->sq, 0); } | option options { $$->sl = seqlist($1->sq, $2->sl); } ; option : SEP { open_seq(0); } sequence OS { $$ = nn(ZN,0,ZN,ZN); $$->sq = close_seq(6); $$->ln = $1->ln; $$->fn = $1->fn; } ; OS : /* empty */ | semi { /* redundant semi at end of sequence */ } ; semi : SEMI | ARROW ; MS : semi { /* at least one semi-colon */ } | MS semi { /* but more are okay too */ } ; aname : NAME { $$ = $1; } | PNAME { $$ = $1; } ; const_expr: CONST { $$ = $1; } | '-' const_expr %prec UMIN { $$ = $2; $$->val = -($2->val); } | l_par const_expr r_par { $$ = $2; } | const_expr '+' const_expr { $$ = $1; $$->val = $1->val + $3->val; } | const_expr '-' const_expr { $$ = $1; $$->val = $1->val - $3->val; } | const_expr '*' const_expr { $$ = $1; $$->val = $1->val * $3->val; } | const_expr '/' const_expr { $$ = $1; $$->val = $1->val / $3->val; } | const_expr '%' const_expr { $$ = $1; $$->val = $1->val % $3->val; } ; expr : l_par expr r_par { $$ = $2; } | expr '+' expr { $$ = nn(ZN, '+', $1, $3); } | expr '-' expr { $$ = nn(ZN, '-', $1, $3); } | expr '*' expr { $$ = nn(ZN, '*', $1, $3); } | expr '/' expr { $$ = nn(ZN, '/', $1, $3); } | expr '%' expr { $$ = nn(ZN, '%', $1, $3); } | expr '&' expr { $$ = nn(ZN, '&', $1, $3); } | expr '^' expr { $$ = nn(ZN, '^', $1, $3); } | expr '|' expr { $$ = nn(ZN, '|', $1, $3); } | expr GT expr { $$ = nn(ZN, GT, $1, $3); } | expr LT expr { $$ = nn(ZN, LT, $1, $3); } | expr GE expr { $$ = nn(ZN, GE, $1, $3); } | expr LE expr { $$ = nn(ZN, LE, $1, $3); } | expr EQ expr { $$ = nn(ZN, EQ, $1, $3); } | expr NE expr { $$ = nn(ZN, NE, $1, $3); } | expr AND expr { $$ = nn(ZN, AND, $1, $3); } | expr OR expr { $$ = nn(ZN, OR, $1, $3); } | expr LSHIFT expr { $$ = nn(ZN, LSHIFT,$1, $3); } | expr RSHIFT expr { $$ = nn(ZN, RSHIFT,$1, $3); } | '~' expr { $$ = nn(ZN, '~', $2, ZN); } | '-' expr %prec UMIN { $$ = nn(ZN, UMIN, $2, ZN); } | SND expr %prec NEG { $$ = nn(ZN, '!', $2, ZN); } | l_par expr ARROW expr ':' expr r_par { $$ = nn(ZN, OR, $4, $6); $$ = nn(ZN, '?', $2, $$); } | RUN aname { Expand_Ok++; if (!context) fatal("used 'run' outside proctype", (char *) 0); } l_par args r_par Opt_priority { Expand_Ok--; $$ = nn($2, RUN, $5, ZN); $$->val = ($7) ? $7->val : 0; trackchanuse($5, $2, 'A'); trackrun($$); } | LEN l_par varref r_par { $$ = nn($3, LEN, $3, ZN); } | ENABLED l_par expr r_par { $$ = nn(ZN, ENABLED, $3, ZN); has_enabled++; } | GET_P l_par expr r_par { $$ = nn(ZN, GET_P, $3, ZN); has_priority++; } | varref RCV { Expand_Ok++; } '[' rargs ']' { Expand_Ok--; has_io++; $$ = nn($1, 'R', $1, $5); } | varref R_RCV { Expand_Ok++; } '[' rargs ']' { Expand_Ok--; has_io++; $$ = nn($1, 'R', $1, $5); $$->val = has_random = 1; } | varref { $$ = $1; trapwonly($1 /*, "varref" */); } | cexpr { $$ = $1; } | CONST { $$ = nn(ZN,CONST,ZN,ZN); $$->ismtyp = $1->ismtyp; $$->val = $1->val; } | TIMEOUT { $$ = nn(ZN,TIMEOUT, ZN, ZN); } | NONPROGRESS { $$ = nn(ZN,NONPROGRESS, ZN, ZN); has_np++; } | PC_VAL l_par expr r_par { $$ = nn(ZN, PC_VAL, $3, ZN); has_pcvalue++; } | PNAME '[' expr ']' '@' NAME { $$ = rem_lab($1->sym, $3, $6->sym); } | PNAME '[' expr ']' ':' pfld { $$ = rem_var($1->sym, $3, $6->sym, $6->lft); } | PNAME '@' NAME { $$ = rem_lab($1->sym, ZN, $3->sym); } | PNAME ':' pfld { $$ = rem_var($1->sym, ZN, $3->sym, $3->lft); } | ltl_expr { $$ = $1; /* sanity_check($1); */ } ; Opt_priority: /* none */ { $$ = ZN; } | PRIORITY CONST { $$ = $2; has_priority++; } ; full_expr: expr { $$ = $1; } | Expr { $$ = $1; } ; ltl_expr: expr UNTIL expr { $$ = nn(ZN, UNTIL, $1, $3); } | expr RELEASE expr { $$ = nn(ZN, RELEASE, $1, $3); } | expr WEAK_UNTIL expr { $$ = nn(ZN, ALWAYS, $1, ZN); $$ = nn(ZN, OR, $$, nn(ZN, UNTIL, $1, $3)); } | expr IMPLIES expr { $$ = nn(ZN, '!', $1, ZN); $$ = nn(ZN, OR, $$, $3); } | expr EQUIV expr { $$ = nn(ZN, EQUIV, $1, $3); } | NEXT expr %prec NEG { $$ = nn(ZN, NEXT, $2, ZN); } | ALWAYS expr %prec NEG { $$ = nn(ZN, ALWAYS,$2, ZN); } | EVENTUALLY expr %prec NEG { $$ = nn(ZN, EVENTUALLY, $2, ZN); } ; /* an Expr cannot be negated - to protect Probe expressions */ Expr : Probe { $$ = $1; } | l_par Expr r_par { $$ = $2; } | Expr AND Expr { $$ = nn(ZN, AND, $1, $3); } | Expr AND expr { $$ = nn(ZN, AND, $1, $3); } | expr AND Expr { $$ = nn(ZN, AND, $1, $3); } | Expr OR Expr { $$ = nn(ZN, OR, $1, $3); } | Expr OR expr { $$ = nn(ZN, OR, $1, $3); } | expr OR Expr { $$ = nn(ZN, OR, $1, $3); } ; Probe : FULL l_par varref r_par { $$ = nn($3, FULL, $3, ZN); } | NFULL l_par varref r_par { $$ = nn($3, NFULL, $3, ZN); } | EMPTY l_par varref r_par { $$ = nn($3, EMPTY, $3, ZN); } | NEMPTY l_par varref r_par { $$ = nn($3,NEMPTY, $3, ZN); } ; Opt_enabler: /* none */ { $$ = ZN; } | PROVIDED l_par full_expr r_par { if (!proper_enabler($3)) { non_fatal("invalid PROVIDED clause", (char *)0); $$ = ZN; } else $$ = $3; } | PROVIDED error { $$ = ZN; non_fatal("usage: provided ( ..expr.. )", (char *)0); } ; basetype: TYPE { $$->sym = ZS; $$->val = $1->val; if ($$->val == UNSIGNED) fatal("unsigned cannot be used as mesg type", 0); } | UNAME { $$->sym = $1->sym; $$->val = STRUCT; } | error /* e.g., unsigned ':' const */ ; typ_list: basetype { $$ = nn($1, $1->val, ZN, ZN); } | basetype ',' typ_list { $$ = nn($1, $1->val, ZN, $3); } ; two_args: expr ',' expr { $$ = nn(ZN, ',', $1, $3); } ; args : /* empty */ { $$ = ZN; } | arg { $$ = $1; } ; prargs : /* empty */ { $$ = ZN; } | ',' arg { $$ = $2; } ; margs : arg { $$ = $1; } | expr l_par arg r_par { if ($1->ntyp == ',') $$ = tail_add($1, $3); else $$ = nn(ZN, ',', $1, $3); } ; arg : expr { if ($1->ntyp == ',') $$ = $1; else $$ = nn(ZN, ',', $1, ZN); } | expr ',' arg { if ($1->ntyp == ',') $$ = tail_add($1, $3); else $$ = nn(ZN, ',', $1, $3); } ; rarg : varref { $$ = $1; trackvar($1, $1); trapwonly($1 /*, "rarg" */); } | EVAL l_par expr r_par { $$ = nn(ZN,EVAL,$3,ZN); trapwonly($1 /*, "eval rarg" */); } | CONST { $$ = nn(ZN,CONST,ZN,ZN); $$->ismtyp = $1->ismtyp; $$->val = $1->val; } | '-' CONST %prec UMIN { $$ = nn(ZN,CONST,ZN,ZN); $$->val = - ($2->val); } ; rargs : rarg { if ($1->ntyp == ',') $$ = $1; else $$ = nn(ZN, ',', $1, ZN); } | rarg ',' rargs { if ($1->ntyp == ',') $$ = tail_add($1, $3); else $$ = nn(ZN, ',', $1, $3); } | rarg l_par rargs r_par { if ($1->ntyp == ',') $$ = tail_add($1, $3); else $$ = nn(ZN, ',', $1, $3); } | l_par rargs r_par { $$ = $2; } ; nlst : NAME { $$ = nn($1, NAME, ZN, ZN); $$ = nn(ZN, ',', $$, ZN); } | nlst NAME { $$ = nn($2, NAME, ZN, ZN); $$ = nn(ZN, ',', $$, $1); } | nlst ',' { $$ = $1; /* commas optional */ } ; %% #define binop(n, sop) fprintf(fd, "("); recursive(fd, n->lft); \ fprintf(fd, ") %s (", sop); recursive(fd, n->rgt); \ fprintf(fd, ")"); #define unop(n, sop) fprintf(fd, "%s (", sop); recursive(fd, n->lft); \ fprintf(fd, ")"); static void recursive(FILE *fd, Lextok *n) { if (n) switch (n->ntyp) { case NEXT: unop(n, "X"); break; case ALWAYS: unop(n, "[]"); break; case EVENTUALLY: unop(n, "<>"); break; case '!': unop(n, "!"); break; case UNTIL: binop(n, "U"); break; case WEAK_UNTIL: binop(n, "W"); break; case RELEASE: /* see http://en.wikipedia.org/wiki/Linear_temporal_logic */ binop(n, "V"); break; case OR: binop(n, "||"); break; case AND: binop(n, "&&"); break; case IMPLIES: binop(n, "->"); break; case EQUIV: binop(n, "<->"); break; case C_EXPR: fprintf(fd, "c_expr { %s }", put_inline(fd, n->sym->name)); break; default: comment(fd, n, 0); break; } } static Lextok * ltl_to_string(Lextok *n) { Lextok *m = nn(ZN, 0, ZN, ZN); char *retval; char ltl_formula[2048]; FILE *tf = fopen(TMP_FILE1, "w+"); /* tmpfile() fails on Windows 7 */ /* convert the parsed ltl to a string by writing into a file, using existing functions, and then passing it to the existing interface for conversion into a never claim (this means parsing everything twice, which is a little redundant, but adds only miniscule overhead) */ if (!tf) { fatal("cannot create temporary file", (char *) 0); } dont_simplify = 1; recursive(tf, n); dont_simplify = 0; (void) fseek(tf, 0L, SEEK_SET); memset(ltl_formula, 0, sizeof(ltl_formula)); retval = fgets(ltl_formula, sizeof(ltl_formula), tf); fclose(tf); (void) unlink(TMP_FILE1); if (!retval) { printf("%p\n", retval); fatal("could not translate ltl ltl_formula", 0); } if (1) printf("ltl %s: %s\n", ltl_name, ltl_formula); m->sym = lookup(ltl_formula); return m; } int is_temporal(int t) { return (t == EVENTUALLY || t == ALWAYS || t == UNTIL || t == WEAK_UNTIL || t == RELEASE); } int is_boolean(int t) { return (t == AND || t == OR || t == IMPLIES || t == EQUIV); } #if 0 /* flags correct formula like: ltl { true U (true U true) } */ void sanity_check(Lextok *t) /* check proper embedding of ltl_expr */ { if (!t) return; sanity_check(t->lft); sanity_check(t->rgt); if (t->lft && t->rgt) { if (!is_boolean(t->ntyp) && (is_temporal(t->lft->ntyp) || is_temporal(t->rgt->ntyp))) { printf("spin: attempt to apply '"); explain(t->ntyp); printf("' to '"); explain(t->lft->ntyp); printf("' and '"); explain(t->rgt->ntyp); printf("'\n"); /* non_fatal("missing parentheses?", (char *)0); */ } } } #endif void yyerror(char *fmt, ...) { non_fatal(fmt, (char *) 0); } Spin/Src6.4.5/pangen7.h0000664000175100017510000020460012641605057012413 0ustar ghgh/***** spin: pangen7.h *****/ /* * This file is part of the public release of Spin. It is subject to the * terms in the LICENSE file that is included in this source directory. * Tool documentation is available at http://spinroot.com */ static const char *pan_par[] = { /* generates pan.p */ "#include ", "#include ", "#include ", /* for nanosleep */ "#include ", "#include ", "#ifdef BFS_DISK", "#include ", /* for rmdir */ "#include ", /* for mkdir */ "#include ", "#include ", /* for open */ "#endif", "", "#define Max(a,b) (((a)>(b))?(a):(b))", "#ifndef WAIT_MAX", " #define WAIT_MAX 2 /* seconds */", "#endif", "#define BFS_GEN 2 /* current and next generation */", "", "typedef struct BFS_Slot BFS_Slot;", "typedef struct BFS_shared BFS_shared;", "typedef struct BFS_data BFS_data;", "", "struct BFS_Slot {", " #ifdef BFS_FIFO", " enum bfs_types type; /* message type */", " #endif", " BFS_State *s_data; /* state data */", " #ifndef BFS_QSZ", " BFS_Slot *nxt; /* linked list */", " #endif", "};", "", "struct BFS_data {", " double memcnt;", " double nstates;", " double nlinks;", " double truncs;", " ulong mreached;", " ulong vsize;", " ulong memory_left;", " ulong punted;", " ulong errors;", " int override; /* after crash, if another proc clears locks */", "};", "", "struct BFS_shared { /* about 13K for BFS_MAXPROCS=16 and BFS_MAXLOCKS=1028 */", " volatile ulong quit; /* set to signal termination -- one word */", " volatile ulong started;", "", " volatile uchar sh_owner[BFS_MAXLOCKS]; /* optional */", "#ifdef BFS_CHECK", " volatile uchar in_count[BFS_MAXLOCKS]; /* optional */", "#endif", " volatile int sh_locks[BFS_MAXLOCKS];", " volatile ulong wait_count[BFS_MAXLOCKS]; /* optional */", "", " volatile BFS_data bfs_data[BFS_MAXPROCS];", " volatile uchar bfs_flag[BFS_MAXPROCS]; /* running 0, normal exit 1, abnormal 2 */", " volatile uchar bfs_idle[BFS_MAXPROCS]; /* set when all input queues are empty */", "#ifdef BFS_DISK", " volatile uchar bfs_out_cnt[BFS_MAXPROCS]; /* set when core writes a state */", "#endif", "", "#ifdef BFS_QSZ", " #define BFS_NORECYCLE", " #if BFS_QSZ<=0", " #error BFS_QSZ must be positive", " #endif", " #ifdef BFS_FIFO", " #error BFS_QSZ cannot be combined with BFS_FIFO", " #endif", " #ifdef BFS_DISK", " #error BFS_QSZ cannot be combined with BFS_DISK", " #endif", " volatile BFS_Slot bfsq[BFS_GEN][BFS_MAXPROCS][BFS_MAXPROCS][BFS_QSZ];", " volatile uint bfs_ix[BFS_GEN][BFS_MAXPROCS][BFS_MAXPROCS];", "#else", " volatile BFS_Slot *head[BFS_GEN][BFS_MAXPROCS][BFS_MAXPROCS];", "#endif", "", "#ifdef BFS_FIFO", " volatile BFS_Slot *tail[BFS_GEN][BFS_MAXPROCS][BFS_MAXPROCS];", " volatile BFS_Slot *dels[BFS_GEN][BFS_MAXPROCS][BFS_MAXPROCS];", "#endif", "#ifdef BFS_LOGMEM", " volatile ulong logmem[1024];", "#endif", " volatile ulong mem_left;", " volatile uchar *allocator; /* start of shared heap, must be last */", "};", "", "enum bfs_types { EMPTY = 0, STATE, DELETED };", "", "extern volatile uchar *bfs_get_shared_mem(key_t, size_t);", "extern BFS_Slot * bfs_new_slot(BFS_Trail *);", "extern BFS_Slot * bfs_prep_slot(BFS_Trail *, BFS_Slot *);", "extern BFS_Slot * bfs_next(void);", "extern BFS_Slot * bfs_pack_state(Trail *, BFS_Trail *, int, BFS_Slot *);", "extern SV_Hold * bfs_new_sv(int);", "#if NRUNS>0", "extern EV_Hold * bfs_new_sv_mask(int);", "#endif", "extern BFS_Trail * bfs_grab_trail(void);", "extern BFS_Trail * bfs_unpack_state(BFS_Slot *);", "extern int bfs_all_empty(void);", "extern int bfs_all_idle(void);", "extern int bfs_all_running(void);", "extern int bfs_idle_and_empty(void);", "extern size_t bfs_find_largest(key_t);", "", "extern void bfs_clear_locks(void);", "extern void bfs_drop_shared_memory(void);", "extern void bfs_explore_state(BFS_Slot *);", "extern void bfs_initial_state(void);", "extern void bfs_mark_done(int);", "extern void bfs_printf(const char *fmt, ...);", "extern void bfs_push_state(Trail *, BFS_Trail *, int);", "extern void bfs_recycle(BFS_Slot *);", "extern void bfs_release_trail(BFS_Trail *);", "extern void bfs_run(void);", "extern void bfs_setup_mem(void);", "extern void bfs_setup(void);", "extern void bfs_shutdown(const char *);", "extern void bfs_statistics(void);", "extern void bfs_store_state(Trail *, short);", "extern void bfs_set_toggle(void);", "extern void bfs_update(void);", "", "#ifdef MA", " #error cannot combine -DMA with -DBFS_PAR", " /* would require us to parallize g_store */", "#endif", "#ifdef BCS", " #error cannot combine -DBCS with -DBFS_PAR", "#endif", "#ifdef BFS_DISK", " #ifdef BFS_FIFO", " #error cannot combine BFS_DISK and BFS_FIFO", " #endif", " extern void bfs_disk_start(void);", " extern void bfs_disk_stop(void);", " extern void bfs_disk_out(void);", " extern void bfs_disk_inp(void);", " extern void bfs_disk_iclose(void);", " extern void bfs_disk_oclose(void);", " int bfs_out_fd[BFS_MAXPROCS];", " int bfs_inp_fd[BFS_MAXPROCS];", "#endif", "", "static BFS_shared *shared_memory;", "#ifndef BFS_QSZ", "static BFS_Slot *bfs_free_slot; /* local free list */", "#endif", "static BFS_Slot bfs_null;", "static SV_Hold *bfs_svfree[VECTORSZ];", "static uchar *bfs_heap; /* local pointer into heap */", "static ulong bfs_left; /* local part of shared heap */", "#if NRUNS>0", "static void bfs_keep(EV_Hold *);", "#endif", "static long bfs_sent; /* nr msgs sent -- local to each process */", "static long bfs_rcvd; /* nr msgs rcvd */", "static long bfs_sleep_cnt; /* stats */", "static long bfs_wcount;", "static long bfs_gcount;", "static ulong bfs_total_shared;", "#ifdef BFS_STAGGER", " static int bfs_stage_cnt = 0;", " static void bfs_stagger_flush(void);", "#endif", "static int bfs_toggle; /* local variable, 0 or 1 */", "static int bfs_qscan; /* scan input queues in order */", "static ulong bfs_snapped;", "static int shared_mem_id;", "#ifndef NOREDUCE", "static int bfs_nps; /* no preselection */", "#endif", "ulong bfs_punt; /* states dropped for lack of memory */", "#if defined(VERBOSE) || defined(BFS_CHECK)", "static const char *bfs_sname[] = {", " \"EMPTY\", /* 0 */", " \"STATE\", /* 1 */", " \"STATE\", /* 2 = DELETED */", " 0", "};", "#endif", "static const char *bfs_lname[] = { /* match values defined in pangen2.c */", " \"global lock\", /* BFS_GLOB */", " \"ordinal\", /* BFS_ORD */", " \"shared memory\", /* BFS_MEM */", " \"print to stdout\", /* BFS_PRINT */", " \"hashtable\", /* BFS_STATE */", " 0", "};", "", "static ulong bfs_count[DELETED+1]; /* indexed with bfs_types: EMPTY=0, STATE=1, DELETED=2 */", "", "static int bfs_keep_state;", "", "int Cores = 1;", "int who_am_i = 0; /* root */", "", "#ifdef L_BOUND", " int L_bound = L_BOUND;", "#endif", "", "#ifdef BFS_CHECK", "void", "bfs_dump_now(char *s)", "{ int i; char *p = (char *) &now;", "", " e_critical(BFS_PRINT);", " printf(\"%%s\\t\", s);", " printf(\"%%3lu: \", vsize);", " for (i = 0; i < vsize; i++)", " { printf(\"%%3d \", *p++);", " }", " printf(\" %%s\\noffsets:\\t\", s);", " for (i = 0; i < now._nr_pr; i++)", " { printf(\"%%3d \", proc_offset[i]);", " }", " printf(\"\\n\");", " x_critical(BFS_PRINT);", "}", "", "void", "view_state(char *s) /* debugging */", "{ int i;", " char *p;", " e_critical(BFS_PRINT);", " printf(\"cpu%%02d %%s: \", who_am_i, s);", " p = (char *)&now;", " for (i = 0; i < vsize; i++)", " printf(\"%%3d, \", *p++);", " printf(\"\\n\"); fflush(stdout);", " x_critical(BFS_PRINT);", "}", "#endif", "", "void", "bfs_main(int ncores, int cycles)", "{", " if (cycles)", " { fprintf(stderr, \"pan: cycle detection is not supported in this mode\\n\");", " exit(1);", " }", "", " if (ncores == 0) /* i.e., find out */", " { FILE *fd;", " char buf[512];", " if ((fd = fopen(\"/proc/cpuinfo\", \"r\")) == NULL)", " { /* cannot tell */", " ncores = Cores; /* use the default */", " } else", " { while (fgets(buf, sizeof(buf), fd))", " { if (strncmp(buf, \"processor\", strlen(\"processor\")) == 0)", " { ncores++;", " } }", " fclose(fd);", " ncores--;", " if (verbose)", " { printf(\"pan: %%d available cores\\n\", ncores+1);", " } } }", " if (ncores >= BFS_MAXPROCS)", " { Cores = BFS_MAXPROCS-1; /* why -1? */", " } else if (ncores < 1)", " { Cores = 1;", " } else", " { Cores = ncores;", " }", " printf(\"pan: using %%d core%%s\\n\", Cores, (Cores>1)?\"s\":\"\");", " fflush(stdout);", "#ifdef BFS_DISK", " bfs_disk_start();", /* create .spin */ "#endif", " bfs_setup(); /* shared memory segments and fork */", " bfs_run();", " if (who_am_i == 0)", " { stop_timer(0);", " }", " bfs_statistics();", " bfs_mark_done(1);", " if (who_am_i == 0)", " { report_time();", "#ifdef BFS_DISK", " bfs_disk_stop();", "#endif", " }", "#ifdef C_EXIT", " C_EXIT; /* trust that it defines a fct */", "#endif", " bfs_drop_shared_memory();", " exit(0);", "}", "", "void", "bfs_setup_mem(void)", "{ size_t n;", " key_t key;", "#ifdef BFS_FIFO", " bfs_null.type = EMPTY;", "#endif", " ntrpt = (Trail *) emalloc(sizeof(Trail));", /* just once */ "", " if ((key = ftok(\".\", (int) 'L')) == -1)", " { perror(\"ftok shared memory\");", " exit(1);", " }", " n = bfs_find_largest(key);", " bfs_total_shared = (ulong) n;", "", " shared_memory = (BFS_shared *) bfs_get_shared_mem(key, n); /* root */", " shared_memory->allocator = (uchar *) shared_memory + sizeof(BFS_shared);", " shared_memory->mem_left = (ulong) (n - sizeof(BFS_shared));", "}", "", "ulong bfs_LowLim;", "#ifndef BFS_RESERVE", " #define BFS_RESERVE 5", /* keep memory on global heap in reserve for first few cores */ /* that run out of their local allocation of shared mem */ /* 1~50 percent, 2~30 percent, 5~20 percent, >Cores=none */ "#else", " #if BFS_RESERVE<1", " #error BFS_RESERVE must be at least 1", " #endif", "#endif", "", "void", "bfs_setup(void) /* executed by root */", "{ int i, j;", " ulong n; /* share of shared memory allocated to each core */", "", " n = shared_memory->mem_left / (Cores + Cores/(BFS_RESERVE)); /* keep some reserve */", "", " if ((n%%sizeof(void *)) != 0)", " { n -= (n%%sizeof(void *)); /* align, without exceeding total */", " }", " for (i = 0; i < Cores-1; i++)", " { j = fork();", " if (j == -1)", " { bfs_printf(\"fork failed\\n\");", " exit(1);", " }", " if (j == 0)", " { who_am_i = i+1; /* 1..Cores-1 */", " break;", " } }", "", " e_critical(BFS_MEM);", " bfs_heap = (uchar *) shared_memory->allocator;", " shared_memory->allocator += n;", " shared_memory->mem_left -= n;", " x_critical(BFS_MEM);", "", " bfs_left = n;", " bfs_runs = 1;", " bfs_LowLim = n / (2 * (ulong) Cores);", /* 50% */ "}", "", "void", "bfs_run(void)", "{ BFS_Slot *v;", "", "#ifdef BFS_DISK", " bfs_disk_out();", /* create outqs */ "#endif", " if (who_am_i == 0)", " { bfs_initial_state();", " }", "#ifdef BFS_DISK", " #ifdef BFS_STAGGER", " bfs_stagger_flush();", " #endif", " bfs_disk_oclose();", /* sync and close outqs */ "#endif", "#ifdef BFS_FIFO", " static int i_count;", "#endif", "", " srand(s_rand+HASH_NR);", " bfs_qscan = 0;", " bfs_toggle = 1 - bfs_toggle; /* after initial state */", " e_critical(BFS_GLOB);", " shared_memory->started++;", " x_critical(BFS_GLOB);", "", " while (shared_memory->started != Cores) /* wait for all cores to connect */", " { usleep(1);", " }", "", "#ifdef BFS_DISK", " bfs_disk_out();", " bfs_disk_inp();", "#endif", "", " start_timer();", " while (shared_memory->quit == 0)", " { v = bfs_next(); /* get next message from current generation */", " if (v->s_data) /* v->type == STATE || v->type == DELETED */", " { bfs_count[STATE]++;", "#ifdef VERBOSE", " bfs_printf(\"GOT STATE (depth %%d, nr %%u)\\n\",", " v->s_data->t_info->o_tt, v->s_data->nr);", "#endif", " /* last resort: start dropping states when out of memory */", " if (bfs_left > 1024 || shared_memory->mem_left > 1024)", " { bfs_explore_state(v);", " } else", " { static int warned_loss = 0;", " if (warned_loss == 0 && who_am_i == 0)", " { warned_loss++;", " bfs_printf(\"out of shared memory - losing states\\n\");", " }", " bfs_punt++;", " }", "#if !defined(BFS_FIFO) && !defined(BFS_NORECYCLE)", " bfs_recycle(v);", "#endif", "#ifdef BFS_FIFO", " i_count = 0;", "#endif", " } else", " { bfs_count[EMPTY]++;", "#if defined(BFS_FIFO) && defined(BFS_CHECK)", " assert(v->type == EMPTY);", "#endif", "#ifdef BFS_FIFO", " if (who_am_i == 0)", " { if (bfs_idle_and_empty())", " { if (i_count++ > 10)", " { shared_memory->quit = 1;", " }", " else usleep(1);", " }", " } else if (!bfs_all_running())", " { bfs_shutdown(\"early termination\");", " }", "#else", " if (who_am_i == 0)", " { if (bfs_all_idle()) /* wait for it */", " { if (!bfs_all_empty()) /* more states to process */", " { bfs_set_toggle();", " goto do_toggle;", " } else /* done */", " { shared_memory->quit = 1; /* step 4 */", " }", " } else", " { bfs_sleep_cnt++;", " }", " } else", " { /* wait for quit or idle bit to be reset by root */", " while (shared_memory->bfs_idle[who_am_i] == 1", " && shared_memory->quit == 0)", " { if (bfs_all_running())", " { bfs_sleep_cnt++;", " usleep(10); /* new 6.2.3 */", " } else", " { bfs_shutdown(\"early termination\");", " /* no return */", " } }", "do_toggle: bfs_qscan = 0;", "#ifdef BFS_DISK", " bfs_disk_iclose();", " bfs_disk_oclose();", "#endif", " bfs_toggle = 1 - bfs_toggle;", "#ifdef BFS_DISK", " bfs_disk_out();", " bfs_disk_inp();", "#endif", " #ifdef BFS_CHECK", " bfs_printf(\"toggle: recv from %%d, send to %%d\\n\",", " bfs_toggle, 1 - bfs_toggle);", " #endif", " }", "#endif", " } }", "#ifdef BFS_CHECK", " bfs_printf(\"done, sent %%5ld recvd %%5ld punt %%5lu sleep: %%ld\\n\",", " bfs_sent, bfs_rcvd, bfs_punt, bfs_sleep_cnt);", "#endif", "}", "", "void", "bfs_report_mem(void) /* called from within wrapup() */", "{", " printf(\"%%9.3f total shared memory usage\\n\\n\",", " ((double) bfs_total_shared - (double) bfs_left)/(1024.*1024.));", "}", "", "void", "bfs_statistics(void)", "{", " #ifdef VERBOSE", " enum bfs_types i;", " #endif", " if (verbose)", " bfs_printf(\"states sent %%7ld recvd %%7ld stored %%8g sleeps: %%4ld, %%4ld, %%ld\\n\",", " bfs_sent, bfs_rcvd, nstates, bfs_wcount, bfs_gcount, bfs_sleep_cnt);", " if (0) bfs_printf(\"states punted %%7lu\\n\", bfs_punt);", " #ifdef VERBOSE", " for (i = EMPTY; i <= DELETED; i++)", " { if (bfs_count[i] > 0)", " { bfs_printf(\"%%6s %%8lu\\n\",", " bfs_sname[i], bfs_count[i]);", " } }", " #endif", " bfs_update();", "", " if (who_am_i == 0 && shared_memory)", " { int i; ulong count = 0L;", " done = 1;", "", " e_critical(BFS_PRINT);", " wrapup();", " if (verbose)", " { printf(\"\\nlock-wait counts:\\n\");", " for (i = 0; i < BFS_STATE; i++)", " printf(\"%%16s %%9lu\\n\",", " bfs_lname[i], shared_memory->wait_count[i]);", "#ifndef BITSTATE", " for (i = BFS_STATE; i < BFS_MAXLOCKS; i++)", " { if (0)", " printf(\" [%%6d] %%9lu\\n\",", " i, shared_memory->wait_count[i]);", " count += shared_memory->wait_count[i];", " }", " printf(\"%%16s %%9lu (avg per region)\\n\",", " bfs_lname[BFS_STATE], count/(BFS_MAXLOCKS - BFS_STATE));", "#endif", " }", " fflush(stdout);", " x_critical(BFS_PRINT);", " }", "}", "", "void", "bfs_snapshot(void)", "{ clock_t stop_time;", " double delta_time;", " struct tms stop_tm;", " volatile BFS_data *s;", "", " e_critical(BFS_PRINT);", " printf(\"cpu%%02d Depth= %%7lu States= %%8.3g Transitions= %%8.3g \",", " who_am_i, mreached, nstates, nstates+truncs);", " printf(\"Memory= %%9.3f\\t\", memcnt/1048576.);", " printf(\"SharedMLeft= %%4lu \", bfs_left/1048576);", " stop_time = times(&stop_tm);", " delta_time = ((double) (stop_time - start_time))/((double) sysconf(_SC_CLK_TCK));", " if (delta_time > 0.01)", " { printf(\"t= %%6.3g R= %%6.0g\\n\", delta_time, nstates/delta_time);", " } else", " { printf(\"t= %%6.3g R= %%6.0g\\n\", 0., 0.);", " }", " fflush(stdout);", " x_critical(BFS_PRINT);", "", " s = &shared_memory->bfs_data[who_am_i];", " s->mreached = (ulong) mreached;", " s->vsize = (ulong) vsize;", " s->errors = (int) errors;", " s->memcnt = (double) memcnt;", " s->nstates = (double) nstates;", " s->nlinks = (double) nlinks;", " s->truncs = (double) truncs;", " s->memory_left = (ulong) bfs_left;", " s->punted = (ulong) bfs_punt;", " bfs_snapped++; /* for bfs_best */", "}", "", "void", "bfs_shutdown(const char *s)", "{", " bfs_clear_locks(); /* in case we interrupted at a bad point */", " if (!strstr(s, \"early \") || verbose)", " { bfs_printf(\"stop (%%s)\\n\", s);", " }", " bfs_update();", " if (who_am_i == 0)", " { wrapup();", "#ifdef BFS_DISK", " bfs_disk_stop();", "#endif", " }", " bfs_mark_done(2);", " pan_exit(2);", "}", "", "SV_Hold *bfs_free_hold;", "", "SV_Hold *", "bfs_get_hold(void)", "{ SV_Hold *x;", " if (bfs_free_hold)", " { x = bfs_free_hold;", " bfs_free_hold = bfs_free_hold->nxt;", " } else", " { x = (SV_Hold *) sh_malloc((ulong) sizeof(SV_Hold));", " }", " return x;", "}", "", "BFS_Trail *", "bfs_unpack_state(BFS_Slot *n) /* called in bfs_explore_state */", "{ BFS_Trail *otrpt;", " BFS_State *bfs_t;", " int vecsz;", "", " if (!n || !n->s_data || !n->s_data->t_info)", " { bfs_Uerror(\"internal error\");", " }", " otrpt = (BFS_Trail *) ((BFS_State *) n->s_data)->t_info;", "", " trpt->ostate = otrpt->ostate;", " trpt->st = otrpt->st;", " trpt->o_tt = otrpt->o_tt;", " trpt->pr = otrpt->pr;", " trpt->tau = otrpt->tau;", " trpt->o_pm = otrpt->o_pm;", " if (trpt->ostate)", " trpt->o_t = t_id_lkup[otrpt->t_id];", "#if defined(C_States) && (HAS_TRACK==1)", " c_revert((uchar *) &(now.c_state[0]));", "#endif", " if (trpt->o_pm & 4) /* rv succeeded */", " { return (BFS_Trail *) 0; /* revisit not needed */", " }", "#ifndef NOREDUCE", " bfs_nps = 0;", "#endif", " if (trpt->o_pm & 8) /* rv attempt failed */", " { revrv++;", " if (trpt->tau&8)", " { trpt->tau &= ~8; /* break atomic */", "#ifndef NOREDUCE", " } else if (trpt->tau&32) /* void preselection */", " { trpt->tau &= ~32;", " bfs_nps = 1; /* no preselection in repeat */", "#endif", " } }", " trpt->o_pm &= ~(4|8);", " if (trpt->o_tt > mreached)", " { static ulong nr = 0L, nc;", " mreached = trpt->o_tt;", " nc = (long) nstates/FREQ;", " if (nc > nr)", " { nr = nc;", " bfs_snapshot();", " } }", " depth = trpt->o_tt;", " if (depth >= maxdepth)", " {", "#if SYNC", " if (boq != -1)", " { BFS_Trail *x = (BFS_Trail *) trpt->ostate;", " if (x) x->o_pm |= 4; /* rv not failing */", " }", "#endif", " truncs++;", " if (!warned)", " { warned = 1;", " bfs_printf(\"error: max search depth too small\\n\");", " }", " if (bounded)", " { bfs_uerror(\"depth limit reached\");", " }", " return (BFS_Trail *) 0;", " }", "", " bfs_t = n->s_data;", "#if NRUNS>0", " vsize = bfs_t->omask->sz;", "#else", " vsize = ((State *) (bfs_t->osv))->_vsz;", "#endif", "#if SYNC", " boq = bfs_t->boq;", "#endif", "", "#if defined(Q_PROVISO) && !defined(BITSTATE) && defined(FULLSTACK)", " #ifdef USE_TDH", " if (((uchar *)(bfs_t->lstate))) /* if BFS_INQ is set */", " { *((uchar *) bfs_t->lstate) = 0; /* turn it off */", " }", " #else", " if (bfs_t->lstate) /* bfs_par */", " { bfs_t->lstate->tagged = 0; /* bfs_par state removed from q */", " }", " #endif", "#endif", " memcpy((char *) &now, (uchar *) bfs_t->osv, vsize);", "#if !defined(NOCOMP) && !defined(HC) && NRUNS>0", " Mask = (uchar *) bfs_t->omask->sv; /* in shared memory */", "#endif", "#ifdef BFS_CHECK", " if (0) bfs_dump_now(\"got1\");", "#endif", "#ifdef TRIX", " re_populate();", "#else", " #if NRUNS>0", " if (now._nr_pr > 0)", " {", " #if VECTORSZ>32000", " proc_offset = (int *) bfs_t->omask->po;", " #else", " proc_offset = (short *) bfs_t->omask->po;", " #endif", " proc_skip = (uchar *) bfs_t->omask->ps;", " }", " if (now._nr_qs > 0)", " {", " #if VECTORSZ>32000", " q_offset = (int *) bfs_t->omask->qo;", " #else", " q_offset = (short *) bfs_t->omask->qo;", " #endif", " q_skip = (uchar *) bfs_t->omask->qs;", " }", " #endif", "#endif", " vecsz = ((State *) bfs_t->osv)->_vsz;", "#ifdef BFS_CHECK", " assert(vecsz > 0 && vecsz < VECTORSZ);", "#endif", " { SV_Hold *x = bfs_get_hold();", " x->sv = bfs_t->osv;", " x->nxt = bfs_svfree[vecsz];", " bfs_svfree[vecsz] = x;", " bfs_t->osv = (State *) 0;", " }", "#if NRUNS>0", " bfs_keep(bfs_t->omask);", "#endif", "", "#ifdef BFS_CHECK", " if (0) bfs_dump_now(\"got2\");", " if (0) view_state(\"after\");", "#endif", " return (BFS_Trail *) bfs_t->t_info;", "}", "void", "bfs_initial_state(void)", "{", "#ifdef BFS_CHECK", " assert(trpt != NULL);", "#endif", " trpt->ostate = (H_el *) 0;", " trpt->o_tt = -1;", " trpt->tau = 0;", "#ifdef VERI", " trpt->tau |= 4; /* claim moves first */", "#endif", " bfs_store_state(trpt, boq); /* initial state : bfs_lib.c */", "}", "", "#ifdef BITSTATE", " #define bfs_do_store(v, n) b_store(v, n)", "#else", " #ifdef USE_TDH", " #define bfs_do_store(v, n) o_store(v, n)", " #else", " #define bfs_do_store(v, n) h_store(v, n)", " #endif", "#endif", "", "#ifdef BFS_SEP_HASH", "int", "bfs_seen_before(void)", "{ /* cannot set trpt->tau |= 64 to mark successors outside stack */", " /* since the check is done remotely and the trpt value is gone */", " #ifdef VERI", " if (!trpt->ostate /* initial state */", " || ((trpt->tau&4) /* starting claim moves(s) */", " && !(((BFS_Trail *)trpt->ostate)->tau&4))) /* prev move: prog */", " { return 0; /* claim move: mid-state not stored */", " } /* else */", " #endif", " if (!bfs_do_store((char *)&now, vsize)) /* sep_hash */", " { nstates++; /* local count */", " return 0; /* new state */", " }", " #ifdef BFS_CHECK", " bfs_printf(\"seen before\\n\");", " #endif", " truncs++;", " return 1; /* old state */", "}", "#endif", "", "void", "bfs_explore_state(BFS_Slot *v) /* generate all successors of v */", "{ BFS_Trail *otrpt;", " Trans *t;", "#ifdef HAS_UNLESS", " int E_state;", "#endif", " int tt;", " short II, To = BASE, From = (short) (now._nr_pr-1);", " short oboq = boq;", " uchar _n, _m, ot;", "", " memset(ntrpt, 0, sizeof(Trail));", " otrpt = bfs_unpack_state(v); /* BFS_Trail */", "", " if (!otrpt) { return; } /* e.g., depth limit reached */", "#ifdef L_BOUND", " #if defined(VERBOSE)", " bfs_printf(\"Unpacked state with l_bound %%d -- sds %%p\\n\",", " now._l_bnd, now._l_sds);", " #endif", "#endif", "", "#if defined(C_States) && (HAS_TRACK==1)", " c_revert((uchar *) &(now.c_state[0]));", "#endif", "", "#ifdef BFS_SEP_HASH", " if (bfs_seen_before()) return;", "#endif", "", "#ifdef VERI", /* could move to just before store_state */ " if (now._nr_pr == 0 /* claim terminated */", " || stopstate[((Pclaim *)pptr(0))->_t][((Pclaim *)pptr(0))->_p])", " { bfs_uerror(\"end state in claim reached\");", " }", "#endif", " trpt->tau &= ~1; /* timeout off */", "#ifdef VERI", " if (trpt->tau&4) /* claim move */", " { trpt->tau |= (otrpt->tau)&1; /* inherit from prog move */", " From = To = 0; /* claim */", " goto Repeat_two;", " }", "#endif", "#ifndef NOREDUCE", " if (boq == -1 && !(trpt->tau&8) && bfs_nps == 0)", " for (II = now._nr_pr-1; II >= BASE; II -= 1)", " {", "Pickup: this = pptr(II);", " tt = (int) ((P0 *)this)->_p;", " ot = (uchar) ((P0 *)this)->_t;", " if (trans[ot][tt]->atom & 8)", " { t = trans[ot][tt];", " if (t->qu[0] != 0)", " { if (!q_cond(II, t))", " continue;", " }", " From = To = II;", " trpt->tau |= 32; /* preselect marker */", " #ifdef VERBOSE", " bfs_printf(\"%%3ld: proc %%d PreSelected (tau=%%d)\\n\", ", " depth, II, trpt->tau);", " #endif", " goto Repeat_two;", " } }", " trpt->tau &= ~32;", "#endif", "", "Repeat_one:", " if (trpt->tau&8)", " { From = To = (short ) trpt->pr; /* atomic */", " } else", " { From = now._nr_pr-1;", " To = BASE;", " }", "#if defined(VERI) || !defined(NOREDUCE) || defined(ETIM)", "Repeat_two: /* MainLoop */", "#endif", " _n = _m = 0;", " for (II = From; II >= To; II -= 1) /* all processes */", " {", "#ifdef BFS_CHECK", " bfs_printf(\"proc %%d (%%d - %%d)\\n\", II, From, To);", "#endif", "#if SYNC ", " if (boq != -1 && trpt->pr == II)", " { continue; /* no rendezvous with same proc */", " }", "#endif", " this = pptr(II);", " tt = (int) ((P0 *)this)->_p;", " ot = (uchar) ((P0 *)this)->_t;", " ntrpt->pr = (uchar) II;", " ntrpt->st = tt; ", " trpt->o_pm &= ~1; /* no move yet */", "#ifdef EVENT_TRACE", " trpt->o_event = now._event;", "#endif", "#ifdef HAS_PRIORITY", " if (!highest_priority(((P0 *)this)->_pid, II, t))", " { continue;", " }", "#else", " #ifdef HAS_PROVIDED", " if (!provided(II, ot, tt, t))", " { continue;", " }", " #endif", "#endif", "#ifdef HAS_UNLESS", " E_state = 0;", "#endif", " for (t = trans[ot][tt]; t; t = t->nxt) /* all process transitions */", " {", "#ifdef BFS_CHECK", " assert(t_id_lkup[t->t_id] == t); /* for reverse lookup in bfs_unpack_state */", "#endif", "#ifdef VERBOSE", " if (0) bfs_printf(\"\\tproc %%d tr %%d\\n\", II, t->forw);", "#endif", "#ifdef HAS_UNLESS", " if (E_state > 0", " && E_state != t->e_trans)", " break;", "#endif", " /* trpt->o_t = */ ntrpt->o_t = t;", " oboq = boq;", "", " if (!(_m = do_transit(t, II)))", " continue;", "", " trpt->o_pm |= 1; /* we moved */", " (trpt+1)->o_m = _m; /* for unsend */", "#ifdef PEG", " peg[t->forw]++;", "#endif", "#ifdef VERBOSE", " e_critical(BFS_PRINT);", " printf(\"%%3ld: proc %%d exec %%d, \",", " depth, II, t->forw);", " printf(\"%%d to %%d, %%s %%s %%s\",", " tt, t->st, t->tp,", " (t->atom&2)?\"atomic\":\"\",", " (boq != -1)?\"rendez-vous\":\"\");", " #ifdef HAS_UNLESS", " if (t->e_trans)", " printf(\" (escapes to state %%d)\", t->st);", " #endif", " printf(\" %%saccepting [tau=%%d]\\n\",", " (trpt->o_pm&2)?\"\":\"non-\", trpt->tau);", " x_critical(BFS_PRINT);", "#endif", "#ifdef HAS_UNLESS", " E_state = t->e_trans;", " #if SYNC>0", " if (t->e_trans > 0 && boq != -1)", " { fprintf(efd, \"error: rendezvous stmnt in the escape clause\\n\");", " fprintf(efd, \" of unless stmnt not compatible with -DBFS\\n\");", " pan_exit(1);", " }", " #endif", "#endif", " if (t->st > 0)", " { ((P0 *)this)->_p = t->st;", " }", " /* use the ostate ptr, with type *H_el, to temporarily store *BFS_Trail */", "#ifdef BFS_NOTRAIL", " ntrpt->ostate = (H_el *) 0; /* no error-traces in this mode */", "#else", " ntrpt->ostate = (H_el *) otrpt; /* parent stackframe */", "#endif", " /* ntrpt->st = tt; * was already set above */", "", " if (boq == -1 && (t->atom&2)) /* atomic */", " { ntrpt->tau = 8; /* record for next move */", " } else", " { ntrpt->tau = 0; /* no timeout or preselect etc */", " }", "#ifdef VERI", " ntrpt->tau |= trpt->tau&4; /* if claim, inherit */", " if (boq == -1 && !(ntrpt->tau&8)) /* unless rv or atomic */", " { if (ntrpt->tau&4) /* claim */", " { ntrpt->tau &= ~4; /* switch to prog */", " } else", " { ntrpt->tau |= 4; /* switch to claim */", " } }", "#endif", "#ifdef L_BOUND", " { uchar obnd = now._l_bnd;", " uchar *os = now._l_sds;", " #ifdef VERBOSE", " bfs_printf(\"saving bound %%d -- sds %%p\\n\", obnd, (void *) os);", " #endif", "#endif", "", " bfs_store_state(ntrpt, oboq);", "#ifdef EVENT_TRACE", " now._event = trpt->o_event;", "#endif", " /* undo move and generate other successor states */", " trpt++; /* this is where ovals and ipt are set */", " do_reverse(t, II, _m); /* restore now. */", "#ifdef L_BOUND", " #ifdef VERBOSE", " bfs_printf(\"restoring bound %%d -- sds %%p\\n\", obnd, (void *) os);", " #endif", " now._l_bnd = obnd;", " now._l_sds = os;", " }", "#endif", " trpt--;", "#ifdef VERBOSE", " e_critical(BFS_PRINT);", " printf(\"%%3ld: proc %%d \", depth, II);", " printf(\"reverses %%d, %%d to %%d,\", t->forw, tt, t->st);", " printf(\" %%s [abit=%%d,adepth=%%d,\", t->tp, now._a_t, 0);", " printf(\"tau=%%d,%%d]\\n\", trpt->tau, (trpt-1)->tau);", " x_critical(BFS_PRINT);", "#endif", " reached[ot][t->st] = 1;", " reached[ot][tt] = 1;", "", " ((P0 *)this)->_p = tt;", " _n |= _m;", " } }", "#ifdef VERBOSE", " bfs_printf(\"done _n = %%d\\n\", _n);", "#endif", "", "#ifndef NOREDUCE", " /* preselected - no succ definitely outside stack */", " if ((trpt->tau&32) && !(trpt->tau&64))", " { From = now._nr_pr-1; To = BASE;", " #ifdef VERBOSE", " bfs_printf(\"%%3ld: proc %%d UnSelected (_n=%%d, tau=%%d)\\n\", ", " depth, II+1, (int) _n, trpt->tau);", " #endif", " _n = 0; trpt->tau &= ~32;", " if (II >= BASE)", " { goto Pickup;", " }", " goto Repeat_two;", " }", " trpt->tau &= ~(32|64);", "#endif", " if (_n == 0", "#ifdef VERI", " && !(trpt->tau&4)", "#endif", " )", " { /* no successor states generated */", " if (boq != -1) /* was rv move */", " { BFS_Trail *x = (BFS_Trail *) trpt->ostate; /* pre-rv state */", " if (x && ((x->tau&8) || (x->tau&32))) /* break atomic or preselect */", " { x->o_pm |= 8; /* mark failure */", " this = pptr(otrpt->pr);", " ((P0 *) this)->_p = otrpt->st; /* reset state */", " unsend(boq); /* retract rv offer */", " boq = -1;", "#ifdef VERBOSE", " printf(\"repush state\\n\");", "#endif", " bfs_push_state(NULL, x, x->o_tt); /* repush rv fail */", " } /* else the rv need not be retried */", " } else if (now._nr_pr > BASE) /* possible deadlock */", " { if ((trpt->tau&8)) /* atomic step blocked */", " { trpt->tau &= ~(1|8); /* 1=timeout, 8=atomic */", " goto Repeat_one;", " }", "#ifdef ETIM", " /* if timeouts were used in the model */", " if (!(trpt->tau&1))", " { trpt->tau |= 1; /* enable timeout */", " goto Repeat_two;", " }", "#endif", " if (!noends && !endstate())", " { bfs_uerror(\"invalid end state.\");", " }", " }", "#ifdef VERI", " else /* boq == -1 && now._nr_pr == BASE && trpt->tau != 4 */", " { trpt->tau |= 4; /* switch to claim for stutter moves */", " #ifdef VERBOSE", " printf(\"%%3ld: proc -1 exec -1, (stutter move)\\n\", depth, II);", " #endif", " bfs_store_state(trpt, boq);", /* doesn't store it but queues it */ " #ifdef VERBOSE", " printf(\"%%3ld: proc -1 reverses -1, (stutter move)\\n\", depth, II);", " #endif", " trpt->tau &= ~4; /* undo, probably not needed */", " }", "#endif", " }", "#ifdef BFS_NOTRAIL", " bfs_release_trail(otrpt);", "#endif", "}", "#if !defined(BFS_FIFO) && !defined(BFS_NORECYCLE)", "void", "bfs_recycle(BFS_Slot *n)", "{", " #ifdef BFS_CHECK", " assert(n != &bfs_null);", " #endif", " n->nxt = bfs_free_slot;", " bfs_free_slot = n;", "", " #ifdef BFS_CHECK", " bfs_printf(\"recycles %%s -- %%p\\n\",", " n->s_data?\"STATE\":\"EMPTY\", (void *) n);", " #endif", "}", "#endif", "#ifdef BFS_FIFO", "int", "bfs_empty(int p)", /* return Cores if all empty or index of first non-empty q of p */ "{ int i;", " const int dst = 0;", " for (i = 0; i < Cores; i++)", " { if (shared_memory->head[dst][p][i] != (BFS_Slot *) 0)", " {", " volatile BFS_Slot *x = shared_memory->head[dst][p][i];", " while (x && x->type == DELETED)", " { x = x->nxt;", " }", " if (!x)", " { continue;", " }", " if (p == who_am_i)", " { shared_memory->head[dst][p][i] = x;", " }", " #ifdef BFS_CHECK", " bfs_printf(\"input q [%%d][%%d][%%d] !empty\\n\",", " dst, p, i);", " #endif", " return i;", " } }", " #ifdef BFS_CHECK", " bfs_printf(\"all input qs [%%d][%%d][0..max] empty\\n\",", " dst, p);", " #endif ", " return Cores;", "}", "#endif", "#ifdef BFS_DISK", "void", "bfs_ewrite(int fd, const void *p, size_t count)", "{", " if (write(fd, p, count) != count)", " { perror(\"diskwrite\");", " Uerror(\"aborting\");", " }", "}", "", "void", "bfs_eread(int fd, void *p, size_t count)", "{", " if (read(fd, p, count) != count)", " { perror(\"diskread\");", " Uerror(\"aborting\");", " }", "}", "", "void", "bfs_sink_disk(int who_are_you, BFS_Slot *n)", "{ SV_Hold *x;", "#ifdef VERBOSE", " bfs_printf(\"sink_disk -> %%d\\n\", who_are_you);", "#endif", " bfs_ewrite(bfs_out_fd[who_are_you], (const void *) n->s_data->t_info, sizeof(BFS_Trail));", " bfs_ewrite(bfs_out_fd[who_are_you], (const void *) &vsize, sizeof(ulong));", " bfs_ewrite(bfs_out_fd[who_are_you], &now, vsize);", "", " bfs_release_trail(n->s_data->t_info);", " n->s_data->t_info = (BFS_Trail *) 0;", "", "#if NRUNS>0", " bfs_ewrite(bfs_out_fd[who_are_you], (const void *) &(n->s_data->omask), sizeof(EV_Hold *));", "#endif", "#ifdef Q_PROVISO", " bfs_ewrite(bfs_out_fd[who_are_you], (const void *) &(n->s_data->lstate), sizeof(H_el *));", "#endif", "#if SYNC>0", " bfs_ewrite(bfs_out_fd[who_are_you], (const void *) &(n->s_data->boq), sizeof(short));", "#endif", "#if VERBOSE", " bfs_ewrite(bfs_out_fd[who_are_you], (const void *) &(n->s_data->nr), sizeof(ulong));", "#endif", " shared_memory->bfs_out_cnt[who_am_i] = 1;", /* wrote at least one state */ "}", "void", "bfs_source_disk(int fd, volatile BFS_Slot *n)", "{ ulong nb; /* local temporary */", " SV_Hold *x;", "#ifdef VERBOSE", " bfs_printf(\"source_disk <- %%d\\n\", who_am_i);", "#endif", " n->s_data->t_info = bfs_grab_trail();", " bfs_eread(fd, (void *) n->s_data->t_info, sizeof(BFS_Trail));", " bfs_eread(fd, (void *) &nb, sizeof(ulong));", "", " x = bfs_new_sv(nb); /* space for osv isn't already allocated */", " n->s_data->osv = x->sv;", " x->sv = (State *) 0;", " x->nxt = bfs_free_hold;", " bfs_free_hold = x;", "", " bfs_eread(fd, (void *) n->s_data->osv, (size_t) nb);", "#if NRUNS>0", " bfs_eread(fd, (void *) &(n->s_data->omask), sizeof(EV_Hold *));", "#endif", "#ifdef Q_PROVISO", " bfs_eread(fd, (void *) &(n->s_data->lstate), sizeof(H_el *));", "#endif", "#if SYNC>0", " bfs_eread(fd, (void *) &(n->s_data->boq), sizeof(short));", "#endif", "#if VERBOSE", " bfs_eread(fd, (void *) &(n->s_data->nr), sizeof(ulong));", "#endif", "}", "#endif", "", "#ifndef BFS_QSZ", " #ifdef BFS_STAGGER", "static BFS_Slot *bfs_stage[BFS_STAGGER];", "", "static void", "bfs_stagger_flush(void)", "{ int i, who_are_you;", " int dst = 1 - bfs_toggle;", " BFS_Slot *n;", " who_are_you = (rand()%%Cores);", /* important: all to the same cpu, but reversed */ " for (i = bfs_stage_cnt-1; i >= 0; i--)", " { n = bfs_stage[i];", " #ifdef BFS_DISK", " bfs_sink_disk(who_are_you, n);", " bfs_stage[i] = (BFS_Slot *) 0;", " #endif", " n->nxt = (BFS_Slot *) shared_memory->head[dst][who_are_you][who_am_i];", " shared_memory->head[dst][who_are_you][who_am_i] = n;", " /* bfs_sent++; */", " }", " #ifdef VERBOSE", " bfs_printf(\"stagger flush %%d states to %%d\\n\",", " bfs_stage_cnt, who_are_you);", " #endif", " bfs_stage_cnt = 0;", "}", "", "void", "bfs_stagger_add(BFS_Slot *n)", "{", " if (bfs_stage_cnt == BFS_STAGGER)", " { bfs_stagger_flush();", " }", " bfs_stage[bfs_stage_cnt++] = n;", "}", " #endif", "#endif", "", "void", "bfs_push_state(Trail *x, BFS_Trail *y, int tt)", "{ int who_are_you;", "#ifdef BFS_FIFO", " const int dst = 0;", "#else", " int dst = 1 - bfs_toggle;", "#endif", "#ifdef BFS_QSZ", " uint z;", " if (bfs_keep_state > 0)", " { who_are_you = bfs_keep_state - 1;", " } else", " { who_are_you = (rand()%%Cores);", " }", " z = shared_memory->bfs_ix[dst][who_are_you][who_am_i];", " if (z >= BFS_QSZ)", " { static int warned_qloss = 0;", " if (warned_qloss == 0 && who_am_i == 0)", " { warned_qloss++;", " bfs_printf(\"BFS_QSZ too small - losing states\\n\");", " }", " bfs_punt++;", " return;", " }", " shared_memory->bfs_ix[dst][who_are_you][who_am_i] = z+1;", " BFS_Slot *n = bfs_pack_state(x, y, tt, bfs_prep_slot(y, ", " (BFS_Slot *) &(shared_memory->bfsq[dst][who_are_you][who_am_i][z])));", "#else", " BFS_Slot *n = bfs_pack_state(x, y, tt, bfs_new_slot(y));", "", " #ifdef BFS_GREEDY", " who_are_you = who_am_i; /* for testing only */", " #else", " if (bfs_keep_state > 0)", " { who_are_you = bfs_keep_state - 1;", " } else", " {", " #ifdef BFS_STAGGER", " who_are_you = -1;", " bfs_stagger_add(n);", " goto done;", " #else", " who_are_you = (rand()%%Cores);", " #endif", " }", " #endif", " #ifdef BFS_FIFO", " if (!shared_memory->tail[dst][who_are_you][who_am_i])", " { shared_memory->dels[dst][who_are_you][who_am_i] =", " shared_memory->tail[dst][who_are_you][who_am_i] =", " shared_memory->head[dst][who_are_you][who_am_i] = n;", " } else", " { shared_memory->tail[dst][who_are_you][who_am_i]->nxt = n;", " shared_memory->tail[dst][who_are_you][who_am_i] = n;", " }", " shared_memory->bfs_idle[who_are_you] = 0;", " #else", " #ifdef BFS_DISK", " bfs_sink_disk(who_are_you, n);", " #endif", " n->nxt = (BFS_Slot *) shared_memory->head[dst][who_are_you][who_am_i];", " shared_memory->head[dst][who_are_you][who_am_i] = n;", " #endif", " #ifdef BFS_STAGGER", "done:", " #endif", "#endif", /* BFS_QSZ */ "#ifdef VERBOSE", " bfs_printf(\"PUT STATE (depth %%ld, nr %%u) to %%d -- s_data: %%p\\n\",", " tt, n->s_data->nr, who_are_you, n->s_data);", "#endif", " bfs_sent++;", "}", "", "BFS_Slot *", "bfs_next(void)", "{ volatile BFS_Slot *n = &bfs_null;", " #ifdef BFS_FIFO", " const int src = 0;", " bfs_qscan = bfs_empty(who_am_i);", " #else", " const int src = bfs_toggle;", " #ifdef BFS_QSZ", " while (bfs_qscan < Cores", " && shared_memory->bfs_ix[src][who_am_i][bfs_qscan] == 0)", " { bfs_qscan++;", " }", " #else", " while (bfs_qscan < Cores", " && shared_memory->head[src][who_am_i][bfs_qscan] == (BFS_Slot *) 0)", " { bfs_qscan++;", " }", " #endif", " #endif", " if (bfs_qscan < Cores)", " {", " #ifdef BFS_FIFO", /* no wait for toggles */ " shared_memory->bfs_idle[who_am_i] = 0;", " for (n = shared_memory->head[src][who_am_i][bfs_qscan]; n; n = n->nxt)", " { if (n->type != DELETED)", " { break;", " } }", " #ifdef BFS_CHECK", " assert(n && n->type == STATE); /* q cannot be empty */", " #endif", " if (n->nxt)", " { shared_memory->head[src][who_am_i][bfs_qscan] = n->nxt;", " }", /* else, do not remove it - yet - avoid empty queues */ " n->type = DELETED;", " #else", " #ifdef BFS_QSZ", " uint x = --shared_memory->bfs_ix[src][who_am_i][bfs_qscan];", " n = &(shared_memory->bfsq[src][who_am_i][bfs_qscan][x]);", " #else", " n = shared_memory->head[src][who_am_i][bfs_qscan];", " shared_memory->head[src][who_am_i][bfs_qscan] = n->nxt;", " #if defined(BFS_FIFO) && defined(BFS_CHECK)", " assert(n->type == STATE);", " #endif", " n->nxt = (BFS_Slot *) 0;", " #endif", " #ifdef BFS_DISK", " /* the states actually show up in reverse order (FIFO iso LIFO) here */", " /* but that doesnt really matter as long as the count is right */", " bfs_source_disk(bfs_inp_fd[bfs_qscan], n); /* get the data */", " #endif", " #endif", " #ifdef BFS_CHECK", " bfs_printf(\"rcv STATE from [%%d][%%d][%%d]\\n\",", " src, who_am_i, bfs_qscan);", " #endif", " bfs_rcvd++;", " } else", " {", " #if defined(BFS_STAGGER) && !defined(BFS_QSZ)", " if (bfs_stage_cnt > 0)", " { bfs_stagger_flush();", " }", " #endif", " shared_memory->bfs_idle[who_am_i] = 1;", " #if defined(BFS_FIFO) && defined(BFS_CHECK)", " assert(n->type == EMPTY);", " #endif", " }", " return (BFS_Slot *) n;", "}", "", "int", "bfs_all_empty(void)", "{ int i;", "#ifdef BFS_DISK", " for (i = 0; i < Cores; i++)", " { if (shared_memory->bfs_out_cnt[i] != 0)", " {", " #ifdef VERBOSE", " bfs_printf(\"bfs_all_empty %%d not empty\\n\", i);", " #endif", " return 0;", " } }", "#else", " int p;", " #ifdef BFS_FIFO", " const int dst = 0;", " #else", " int dst = 1 - bfs_toggle; /* next generation */", " #endif", " for (p = 0; p < Cores; p++)", " for (i = 0; i < Cores; i++)", " #ifdef BFS_QSZ", " { if (shared_memory->bfs_ix[dst][p][i] > 0)", " #else", " { if (shared_memory->head[dst][p][i] != (BFS_Slot *) 0)", " #endif", " { return 0;", " } }", "#endif", "#ifdef VERBOSE", " bfs_printf(\"bfs_all_empty\\n\");", "#endif", " return 1;", "}", "", "#ifdef BFS_FIFO", "BFS_Slot *", "bfs_sweep(void)", "{ BFS_Slot *n;", " int i;", " for (i = 0; i < Cores; i++)", " for (n = (BFS_Slot *) shared_memory->dels[0][who_am_i][i];", " n && n != shared_memory->head[0][who_am_i][i];", " n = n->nxt)", " { if (n->type == DELETED && n->nxt)", " { shared_memory->dels[0][who_am_i][i] = n->nxt;", " n->nxt = (BFS_Slot *) 0;", " return n;", " } }", " return (BFS_Slot *) sh_malloc((ulong) sizeof(BFS_Slot));", "}", "#endif", "", "typedef struct BFS_T_Hold BFS_T_Hold;", "struct BFS_T_Hold {", " volatile BFS_Trail *t;", " BFS_T_Hold *nxt;", "};", "BFS_T_Hold *bfs_t_held, *bfs_t_free;", "", "BFS_Trail *", "bfs_grab_trail(void)", /* call in bfs_source_disk and bfs_new_slot */ "{ BFS_Trail *t;", " BFS_T_Hold *h;", "", "#ifdef VERBOSE", " bfs_printf(\"grab trail - bfs_t_held %%p\\n\", (void *) bfs_t_held);", "#endif", " if (bfs_t_held)", " { h = bfs_t_held;", " bfs_t_held = bfs_t_held->nxt;", " t = (BFS_Trail *) h->t;", " h->t = (BFS_Trail *) 0; /* make sure it cannot be reused */", " h->nxt = bfs_t_free;", " bfs_t_free = h;", "", " } else", " { t = (BFS_Trail *) sh_malloc((ulong) sizeof(BFS_Trail));", " }", "#ifdef BFS_CHECK", " assert(t);", "#endif", " t->ostate = (H_el *) 0;", "#ifdef VERBOSE", " bfs_printf(\"grab trail %%p\\n\", (void *) t);", "#endif", " return t;", "}", "", "#if defined(BFS_DISK) || defined(BFS_NOTRAIL)", "void", "bfs_release_trail(BFS_Trail *t)", /* call in bfs_sink_disk (not bfs_recycle) */ "{ BFS_T_Hold *h;", " #ifdef BFS_CHECK", " assert(t);", " #endif", " #ifdef VERBOSE", " bfs_printf(\"release trail %%p\\n\", (void *) t);", " #endif", " if (bfs_t_free)", " { h = bfs_t_free;", " bfs_t_free = bfs_t_free->nxt;", " } else", " { h = (BFS_T_Hold *) emalloc(sizeof(BFS_T_Hold));", " }", " h->t = t;", " h->nxt = bfs_t_held;", " bfs_t_held = h;", " #ifdef VERBOSE", " bfs_printf(\"release trail - bfs_t_held %%p\\n\", (void *) bfs_t_held);", " #endif", "}", "#endif", "", "#ifndef BFS_QSZ", "BFS_Slot *", "bfs_new_slot(BFS_Trail *f)", "{ BFS_Slot *t;", "", "#ifdef BFS_FIFO", " t = bfs_sweep();", "#else", " if (bfs_free_slot) /* local */", " { t = bfs_free_slot;", " bfs_free_slot = bfs_free_slot->nxt;", " t->nxt = (BFS_Slot *) 0;", " } else", " { t = (BFS_Slot *) sh_malloc((ulong) sizeof(BFS_Slot));", " }", "#endif", " if (t->s_data)", " { memset(t->s_data, 0, sizeof(BFS_State));", " } else", " { t->s_data = (BFS_State *) sh_malloc((ulong) sizeof(BFS_State));", " }", "", " /* we keep a ptr to the frame of parent states, which is */", " /* used for reconstructing path and recovering failed rvs etc */", " /* we should not overwrite the data at this address with a memset */", "", " if (f)", " { t->s_data->t_info = f;", " } else", " { t->s_data->t_info = bfs_grab_trail();", " }", " return t;", "}", "#else", "BFS_Slot *", "bfs_prep_slot(BFS_Trail *f, BFS_Slot *t)", "{", " if (t->s_data)", " { memset(t->s_data, 0, sizeof(BFS_State));", " } else", " { t->s_data = (BFS_State *) sh_malloc((ulong) sizeof(BFS_State));", " }", " if (f)", " { t->s_data->t_info = f;", " } else", " { t->s_data->t_info = bfs_grab_trail();", " }", " return t;", "}", "#endif", "", "SV_Hold *", "bfs_new_sv(int n)", "{ SV_Hold *h;", "", " if (bfs_svfree[n])", " { h = bfs_svfree[n];", " bfs_svfree[n] = h->nxt;", " h->nxt = (SV_Hold *) 0;", " } else", " { h = (SV_Hold *) sh_malloc((ulong) sizeof(SV_Hold));", "#if 0", " h->sz = n;", "#endif", " h->sv = (State *) sh_malloc((ulong)(sizeof(State) - VECTORSZ + n));", " }", " memcpy((char *)h->sv, (char *)&now, n);", " return h;", "}", "#if NRUNS>0", "static EV_Hold *kept[VECTORSZ]; /* local */", "", "static void", "bfs_keep(EV_Hold *v)", "{ EV_Hold *h;", "", " for (h = kept[v->sz]; h; h = h->nxt) /* check local list */", " { if (v->nrpr == h->nrpr", " && v->nrqs == h->nrqs", "#if !defined(NOCOMP) && !defined(HC)", " && (v->sv == h->sv || memcmp((char *) v->sv, (char *) h->sv, v->sz) == 0)", "#endif", "#ifdef TRIX", " )", "#else", " #if NRUNS>0", " #if VECTORSZ>32000", " && (memcmp((char *) v->po, (char *) h->po, v->nrpr * sizeof(int)) == 0)", " && (memcmp((char *) v->qo, (char *) h->qo, v->nrqs * sizeof(int)) == 0)", " #else", " && (memcmp((char *) v->po, (char *) h->po, v->nrpr * sizeof(short)) == 0)", " && (memcmp((char *) v->qo, (char *) h->qo, v->nrqs * sizeof(short)) == 0)", " #endif", " && (memcmp((char *) v->ps, (char *) h->ps, v->nrpr * sizeof(uchar)) == 0)", " && (memcmp((char *) v->qs, (char *) h->qs, v->nrqs * sizeof(uchar)) == 0))", " #else", " )", " #endif", "#endif", " { break;", " } }", "", " if (!h) /* we don't have one like it yet */", " { v->nxt = kept[v->sz]; /* keep the original owner field */", " kept[v->sz] = v;", " /* all ptrs inside are to shared memory, but nxt is local */", " }", "}", "", "EV_Hold *", "bfs_new_sv_mask(int n)", "{ EV_Hold *h;", "", " for (h = kept[n]; h; h = h->nxt)", " { if ((now._nr_pr == h->nrpr)", " && (now._nr_qs == h->nrqs)", "#if !defined(NOCOMP) && !defined(HC) && NRUNS>0", " && ((char *) Mask == h->sv || (memcmp((char *) Mask, h->sv, n) == 0))", "#endif", "#ifdef TRIX", " )", "#else", " #if NRUNS>0", " #if VECTORSZ>32000", " && (memcmp((char *) proc_offset, (char *) h->po, now._nr_pr * sizeof(int)) == 0)", " && (memcmp((char *) q_offset, (char *) h->qo, now._nr_qs * sizeof(int)) == 0)", " #else", " && (memcmp((char *) proc_offset, (char *) h->po, now._nr_pr * sizeof(short)) == 0)", " && (memcmp((char *) q_offset, (char *) h->qo, now._nr_qs * sizeof(short)) == 0)", " #endif", " && (memcmp((char *) proc_skip, (char *) h->ps, now._nr_pr * sizeof(uchar)) == 0)", " && (memcmp((char *) q_skip, (char *) h->qs, now._nr_qs * sizeof(uchar)) == 0))", " #else", " )", " #endif", "#endif", " { break;", " } }", "", " if (!h)", " { /* once created, the contents are never modified */", " h = (EV_Hold *) sh_malloc((ulong)sizeof(EV_Hold));", " h->owner = who_am_i;", " h->sz = n;", " h->nrpr = now._nr_pr;", " h->nrqs = now._nr_qs;", "#if !defined(NOCOMP) && !defined(HC) && NRUNS>0", " h->sv = (char *) Mask; /* in shared memory, and never modified */", "#endif", "#if NRUNS>0 && !defined(TRIX)", " if (now._nr_pr > 0)", " { h->ps = (char *) proc_skip;", " h->po = (char *) proc_offset;", " }", " if (now._nr_qs > 0)", " { h->qs = (char *) q_skip;", " h->qo = (char *) q_offset;", " }", "#endif", " h->nxt = kept[n];", " kept[n] = h;", " }", " return h;", "}", "#endif", /* NRUNS>0 */ "BFS_Slot *", "bfs_pack_state(Trail *f, BFS_Trail *g, int search_depth, BFS_Slot *t)", "{", "#ifdef BFS_CHECK", " assert(t->s_data != NULL);", " assert(t->s_data->t_info != NULL);", " assert(f || g);", "#endif", " if (!g)", " { t->s_data->t_info->ostate = f->ostate;", " t->s_data->t_info->st = f->st;", " t->s_data->t_info->o_tt = search_depth;", " t->s_data->t_info->pr = f->pr;", " t->s_data->t_info->tau = f->tau;", " t->s_data->t_info->o_pm = f->o_pm;", " if (f->o_t)", " { t->s_data->t_info->t_id = f->o_t->t_id;", " } else", " { t->s_data->t_info->t_id = -1;", " t->s_data->t_info->ostate = NULL;", " }", " } /* else t->s_data->t_info == g */", "#if SYNC", " t->s_data->boq = boq;", "#endif", "#ifdef VERBOSE", " { static ulong u_cnt;", " t->s_data->nr = u_cnt++;", " }", "#endif", "#ifdef TRIX", " sv_populate(); /* make sure now is up to date */", "#endif", "#ifndef BFS_DISK", " { SV_Hold *x = bfs_new_sv(vsize);", " t->s_data->osv = x->sv;", " x->sv = (State *) 0;", " x->nxt = bfs_free_hold;", " bfs_free_hold = x;", " }", "#endif", "#if NRUNS>0", " t->s_data->omask = bfs_new_sv_mask(vsize);", "#endif", "", "#if defined(Q_PROVISO) && !defined(BITSTATE) && !defined(NOREDUCE)", " t->s_data->lstate = Lstate; /* Lstate is set in o_store or h_store */", "#endif", "#ifdef BFS_FIFO", " t->type = STATE;", "#endif", " return t;", "}", "", "void", "bfs_store_state(Trail *t, short oboq)", "{", "#ifdef TRIX", " sv_populate();", "#endif", "#if defined(VERI) && defined(Q_PROVISO) && !defined(BITSTATE) && defined(FULLSTACK)", " if (!(t->tau&4)", /* prog move */ " && t->ostate)", /* not initial state */ " { t->tau |= ((BFS_Trail *) t->ostate)->tau&64;", " } /* lift 64 across claim moves */", "#endif", "", "#ifdef BFS_SEP_HASH", " #if SYNC", " if (boq == -1 && oboq != -1) /* post-rv */", " { BFS_Trail *x = (BFS_Trail *) trpt->ostate; /* pre-rv state */", " if (x)", " { x->o_pm |= 4; /* rv complete */", " } }", " #endif", " d_sfh((uchar *)&now, (int) vsize); /* sep-hash -- sets K1 -- overkill */", " bfs_keep_state = K1%%Cores + 1;", " bfs_push_state(t, NULL, trpt->o_tt+1); /* bfs_store_state - sep_hash */", " bfs_keep_state = 0;", "#else", " #ifdef VERI", #if 0 in VERI mode store the state when (!t->ostate || (t->tau&4)) in initial state and after each program move i.e., dont store when !(!t->ostate || (t->tau&4)) = (t->ostate && !(t->tau&4)) the *first* time that the tau flag is not set: possibly after a series of claim moves in an atomic sequence #endif " if (!(t->tau&4) && t->ostate && (((BFS_Trail *)t->ostate)->tau&4))", " { /* do not store intermediate state */", " #if defined(VERBOSE) && defined(L_BOUND)", " bfs_printf(\"Un-Stored state bnd %%d -- sds %%p\\n\",", " now._l_bnd, now._l_sds);", " #endif", " bfs_push_state(t, NULL, trpt->o_tt+1); /* claim move */", " } else", " #endif", " if (!bfs_do_store((char *)&now, vsize)) /* includes bfs_visited */", " { nstates++; /* local count */", " trpt->tau |= 64; /* bfs: succ outside stack */", " #if SYNC", " if (boq == -1 && oboq != -1) /* post-rv */", " { BFS_Trail *x = ", " (BFS_Trail *) trpt->ostate; /* pre-rv state */", " if (x)", " { x->o_pm |= 4; /* rv complete */", " } }", " #endif", " bfs_push_state(t, NULL, trpt->o_tt+1); /* successor */", " } else", " { truncs++;", " #ifdef BFS_CHECK", " bfs_printf(\"seen before\\n\");", " #endif", " #if defined(Q_PROVISO) && !defined(BITSTATE) && defined(FULLSTACK)", " #ifdef USE_TDH", " if (Lstate)", /* if BFS_INQ is set */ " { trpt->tau |= 64;", " }", " #else", " if (Lstate && Lstate->tagged) /* bfs_store_state */", " { trpt->tau |= 64;", " }", " #endif", " #endif", " }", "#endif", "}", "", "/*** support routines ***/", "", "void", "bfs_clear_locks(void)", "{ int i;", "", " /* clear any locks held by this process only */", " if (shared_memory)", " for (i = 0; i < BFS_MAXLOCKS; i++)", " { if (shared_memory->sh_owner[i] == who_am_i + 1)", " { shared_memory->sh_locks[i] = 0;", "#ifdef BFS_CHECK", " shared_memory->in_count[i] = 0;", "#endif", " shared_memory->sh_owner[i] = 0;", " } }", "}", "", "void", "e_critical(int which)", "{ int w;", "#ifdef BFS_CHECK", " assert(which >= 0 && which < BFS_MAXLOCKS);", "#endif", " if (shared_memory == NULL) return;", " while (tas(&(shared_memory->sh_locks[which])) != 0)", " { w = shared_memory->sh_owner[which]; /* sh_locks[which] could be 0 by now */", " assert(w >= 0 && w <= BFS_MAXPROCS);", " if (w > 0 && shared_memory->bfs_flag[w-1] == 2)", " { /* multiple processes can get here; only one should do this: */", " if (tas(&(shared_memory->bfs_data[w - 1].override)) == 0)", " { fprintf(stderr, \"cpu%%02d: override lock %%d - held by %%d\\n\",", " who_am_i, which, shared_memory->sh_owner[which]);", "#ifdef BFS_CHECK", " shared_memory->in_count[which] = 0;", "#endif", " shared_memory->sh_locks[which] = 0;", " shared_memory->sh_owner[which] = 0;", " } }", " shared_memory->wait_count[which]++; /* not atomic of course */", " }", "#ifdef BFS_CHECK", " if (shared_memory->in_count[which] != 0)", " { fprintf(stderr, \"cpu%%02d: cannot happen lock %%d count %%d\\n\", who_am_i,", " which, shared_memory->in_count[which]);", " }", " shared_memory->in_count[which]++;", "#endif", " shared_memory->sh_owner[which] = who_am_i+1;", "}", "", "void", "x_critical(int which)", "{", " if (shared_memory == NULL) return;", "#ifdef BFS_CHECK", " assert(shared_memory->in_count[which] == 1);", " shared_memory->in_count[which] = 0;", "#endif", " shared_memory->sh_locks[which] = 0;", " shared_memory->sh_owner[which] = 0;", "}", "", "void", "bfs_printf(const char *fmt, ...)", "{ va_list args;", "", " e_critical(BFS_PRINT);", "#ifdef BFS_CHECK", " if (1) { int i=who_am_i; while (i-- > 0) printf(\" \"); }", "#endif", " printf(\"cpu%%02d: \", who_am_i);", " va_start(args, fmt);", " vprintf(fmt, args);", " va_end(args);", " fflush(stdout);", " x_critical(BFS_PRINT);", "}", "", "int", "bfs_all_idle(void)", "{ int i;", "", " if (shared_memory)", " for (i = 0; i < Cores; i++)", " { if (shared_memory->bfs_flag[i] == 0", " && shared_memory->bfs_idle[i] == 0)", " { return 0;", " } }", " return 1;", "}", "", "#ifdef BFS_FIFO", "int", "bfs_idle_and_empty(void)", "{ int p; /* read-only */", " for (p = 0; p < Cores; p++)", " { if (shared_memory->bfs_flag[p] == 0", " && shared_memory->bfs_idle[p] == 0)", " { return 0;", " } }", " for (p = 0; p < Cores; p++)", " { if (bfs_empty(p) < Cores)", " { return 0;", " } }", " return 1;", "}", "#endif", "", "void", "bfs_set_toggle(void) /* executed by root */", "{ int i;", "", " if (shared_memory)", " for (i = 0; i < Cores; i++)", " { shared_memory->bfs_idle[i] = 0;", " }", "}", "", "int", "bfs_all_running(void) /* crash detection */", "{ int i;", " for (i = 0; i < Cores; i++)", " { if (!shared_memory || shared_memory->bfs_flag[i] > 1)", " { return 0;", " } }", " return 1;", "}", "", "void", "bfs_mark_done(int code)", "{", " if (shared_memory)", " { shared_memory->bfs_flag[who_am_i] = (int) code;", " shared_memory->quit = 1;", " }", "}", "", "static uchar *", "bfs_offset(int c)", "{ int p, N;", "#ifdef COLLAPSE", " uchar *q = (uchar *) ncomps; /* it is the first object allocated */", " q += (256+2) * sizeof(ulong); /* preserve contents of ncomps */", "#else", " uchar *q = (uchar *) &(shared_memory->allocator);", "#endif", " /* _NP_+1 proctypes, reachability info:", " * reached[x : 0 .. _NP_+1][ 0 .. NrStates[x] ]", " */", " for (p = N = 0; p <= _NP_; p++)", " { N += NrStates[p]; /* sum for all proctypes */", " }", "", " /* space needed per proctype: N bytes */", " /* rounded up to a multiple of the word size */", " if ((N%%sizeof(void *)) != 0) /* aligned */", " { N += sizeof(void *) - (N%%sizeof(void *));", " }", "", " q += ((c - 1) * (_NP_ + 1) * N);", " return q;", "}", "", "static void", "bfs_putreached(void)", "{ uchar *q;", " int p;", "", " assert(who_am_i > 0);", "", " q = bfs_offset(who_am_i);", " for (p = 0; p <= _NP_; p++)", " { memcpy((void *) q, (const void *) reached[p], (size_t) NrStates[p]);", " q += NrStates[p];", " }", "}", "", "static void", "bfs_getreached(int c)", "{ uchar *q;", " int p, i;", "", " assert(who_am_i == 0 && c >= 1 && c < Cores);", "", " q = (uchar *) bfs_offset(c);", " for (p = 0; p <= _NP_; p++)", " for (i = 0; i < NrStates[p]; i++)", " { reached[p][i] += *q++; /* update local copy */", " }", "}", "", "void", "bfs_update(void)", "{ int i;", " volatile BFS_data *s;", "", " if (!shared_memory) return;", "", " s = &shared_memory->bfs_data[who_am_i];", " if (who_am_i == 0)", " { shared_memory->bfs_flag[who_am_i] = 3; /* or else others dont stop */", " bfs_gcount = 0;", " for (i = 1; i < Cores; i++) /* start at 1 not 0 */", " { while (shared_memory->bfs_flag[i] == 0)", " { sleep(1);", " if (bfs_gcount++ > WAIT_MAX) /* excessively long wait */", " { printf(\"cpu00: give up waiting for cpu%%2d (%%d cores)\\n\", i, Cores);", " bfs_gcount = 0;", " break;", " } }", " s = &shared_memory->bfs_data[i];", " mreached = Max(mreached, s->mreached);", " hmax = vsize = Max(vsize, s->vsize);", " errors += s->errors;", " memcnt += s->memcnt;", " nstates += s->nstates;", " nlinks += s->nlinks;", " truncs += s->truncs;", " bfs_left += s->memory_left;", " bfs_punt += s->punted;", " bfs_getreached(i);", " }", " } else", " { s->mreached = (ulong) mreached;", " s->vsize = (ulong) vsize;", " s->errors = (int) errors;", " s->memcnt = (double) memcnt;", " s->nstates = (double) nstates;", " s->nlinks = (double) nlinks;", " s->truncs = (double) truncs;", " s->memory_left = (ulong) bfs_left;", " s->punted = (ulong) bfs_punt;", " bfs_putreached();", " }", "}", "", "volatile uchar *", "sh_pre_malloc(ulong n) /* used before the local heaps are populated */", "{ volatile uchar *ptr = NULL;", "", " assert(!bfs_runs);", " if ((n%%sizeof(void *)) != 0)", " { n += sizeof(void *) - (n%%sizeof(void *));", " assert((n%%sizeof(void *)) == 0);", " }", "", " e_critical(BFS_MEM); /* needed? */", " if (shared_memory->mem_left < n + 7)", /* 7 for possible alignment */ " { x_critical(BFS_MEM);", " bfs_printf(\"want %%lu, have %%lu\\n\",", " n, shared_memory->mem_left);", " bfs_shutdown(\"out of shared memory\");", " assert(0); /* should be unreachable */", " }", " ptr = shared_memory->allocator;", "#if WS>4", /* align to 8 byte boundary */ " { int b = (int) ((uint64_t) ptr)&7;", " if (b != 0)", " { ptr += (8-b);", " shared_memory->allocator = ptr;", " } }", "#endif", " shared_memory->allocator += n;", " shared_memory->mem_left -= n;", " x_critical(BFS_MEM);", "", " bfs_pre_allocated += n;", "", " return ptr;", "}", "", "volatile uchar *", "sh_malloc(ulong n)", "{ volatile uchar *ptr = NULL;", "#ifdef BFS_CHECK", " assert(bfs_runs);", "#endif", " if ((n%%sizeof(void *)) != 0)", " { n += sizeof(void *) - (n%%sizeof(void *));", "#ifdef BFS_CHECK", " assert((n%%sizeof(void *)) == 0);", "#endif", " }", "", " /* local heap -- no locks needed */", " if (bfs_left < n)", " { e_critical(BFS_MEM);", " if (shared_memory->mem_left >= n)", " { ptr = (uchar *) shared_memory->allocator;", " shared_memory->allocator += n;", " shared_memory->mem_left -= n;", " x_critical(BFS_MEM);", " return ptr;", " }", " x_critical(BFS_MEM);", "#ifdef BFS_LOGMEM", " int i;", " e_critical(BFS_MEM);", " for (i = 0; i < 1024; i++)", " { if (shared_memory->logmem[i] > 0)", " { bfs_printf(\"\tlog[%%d]\t%%d\\n\", i, shared_memory->logmem[i]);", " } }", " x_critical(BFS_MEM);", "#endif", " bfs_shutdown(\"out of shared memory\"); /* no return */", " }", "#ifdef BFS_LOGMEM", " e_critical(BFS_MEM);", " if (n < 1023)", " { shared_memory->logmem[n]++;", " } else", " { shared_memory->logmem[1023]++;", " }", " x_critical(BFS_MEM);", "#endif", " ptr = (uchar *) bfs_heap;", " bfs_heap += n;", " bfs_left -= n;", "", " if (0) printf(\"sh_malloc %%ld\\n\", n);", " return ptr;", "}", "", "volatile uchar *", "bfs_get_shared_mem(key_t key, size_t n)", "{ char *rval;", "", " assert(who_am_i == 0);", "", " shared_mem_id = shmget(key, n, 0600 | IPC_CREAT | IPC_EXCL); /* create */", " if (shared_mem_id == -1)", " { fprintf(stderr, \"cpu%%02d: tried to get %%d MB of shared memory\\n\",", " who_am_i, (int) n/(1024*1024));", " perror(\"shmget\");", " exit(1);", " }", " if ((rval = (char *) shmat(shared_mem_id, (void *) 0, 0)) == (char *) -1) /* attach */", " { perror(\"shmat\");", " exit(1);", " }", " return (uchar *) rval;", "}", "", "void", "bfs_drop_shared_memory(void)", "{", " if (who_am_i == 0)", " { printf(\"pan: releasing shared memory...\");", " fflush(stdout);", " }", " if (shared_memory)", " { shmdt(shared_memory); /* detach */", " if (who_am_i == 0)", " { shmctl(shared_mem_id, IPC_RMID, (void *) 0); /* remove */", " } }", " if (who_am_i == 0)", " { printf(\"done\\n\");", " fflush(stdout);", " }", "}", "", "size_t", "bfs_find_largest(key_t key)", "{ size_t n;", " const size_t delta = 32*1024*1024;", " int temp_id = -1;", " int atleastonce = 0;", "", " for (n = delta; ; n += delta)", " { if (WS <= 4 && n >= 1024*1024*1024)", /* was n >= INT_MAX */ " { n = 1024*1024*1024;", " break;", " }", "#ifdef MEMLIM", " if ((double) n > memlim)", " { n = (size_t) memlim;", " break;", " }", "#endif", " temp_id = shmget(key, n, 0600); /* check for stale copy */", " if (temp_id != -1)", " { if (shmctl(temp_id, IPC_RMID, ((void *) 0)) < 0) /* remove */", " { perror(\"remove_segment_fails 2\");", " exit(1);", " } }", "", " temp_id = shmget(key, n, 0600 | IPC_CREAT | IPC_EXCL); /* create new */", " if (temp_id == -1)", " { n -= delta;", " break;", " } else", " { atleastonce++;", " if (shmctl(temp_id, IPC_RMID, ((void *) 0)) < 0)", " { perror(\"remove_segment_fails 0\");", " exit(1);", " } } }", "", " if (!atleastonce)", " { printf(\"cpu%%02d: no shared memory n=%%d\\n\", who_am_i, (int) n);", " exit(1);", " }", "", " printf(\"cpu%%02d: largest shared memory segment: %%lu MB\\n\",", " who_am_i, (ulong) n/(1024*1024));", "#if 0", " #ifdef BFS_SEP_HASH", " n /= 2; /* not n /= Cores because the queues take most memory */", " printf(\"cpu%%02d: using %%lu MB\\n\", who_am_i, (ulong) n/(1024*1024));", " #endif", "#endif", " fflush(stdout);", "", " if ((n/(1024*1024)) == 32)", " { if (sizeof(void *) == 4) /* a 32 bit machine */", " { fprintf(stderr, \"\\t32MB is the default; increase it to 1 GB with:\\n\");", " fprintf(stderr, \"\\tsudo /sbin/sysctl kernel.shmmax=%%d\\n\", (1<<30));", " fprintf(stderr, \"\\tsudo /sbin/sysctl kernel.shmall=%%d\\n\", (1<<30)/8192);", " } else if (sizeof(void *) == 8) /* a 64 bit machine */", " { fprintf(stderr, \"\\t32MB is the default; increase it to 30 GB with:\\n\");", " fprintf(stderr, \"\\tsudo /sbin/sysctl kernel.shmmax=32212254720\\n\");", " fprintf(stderr, \"\\tsudo /sbin/sysctl kernel.shmall=7864320\\n\");", " fprintf(stderr, \"\\tor for 60 GB:\\n\");", " fprintf(stderr, \"\\tsudo /sbin/sysctl kernel.shmmax=60000000000\\n\");", " fprintf(stderr, \"\\tsudo /sbin/sysctl kernel.shmall=30000000\\n\");", " } else", " { fprintf(stderr, \"\\tweird wordsize %%d\\n\", (int) sizeof(void *));", " } }", "", " return n;", "}", "#ifdef BFS_DISK", "void", "bfs_disk_start(void)", /* setup .spin*/ "{ int unused = system(\"rm -fr .spin\");", " if (mkdir(\".spin\", 0777) != 0)", " { perror(\"mkdir\");", " Uerror(\"aborting\");", " }", "}", "void", "bfs_disk_stop(void)", /* remove .spin */ "{", " if (system(\"rm -fr .spin\") < 0)", " { perror(\"rm -fr .spin/\");", " }", "}", "void", "bfs_disk_inp(void)", /* this core only */ "{ int i; char fnm[16];", "#ifdef VERBOSE", " bfs_printf(\"inp %%d %%d 0..%%d\\n\", bfs_toggle, who_am_i, Cores);", "#endif", " for (i = 0; i < Cores; i++)", " { sprintf(fnm, \".spin/q%%d_%%d_%%d\", bfs_toggle, who_am_i, i);", " if ((bfs_inp_fd[i] = open(fnm, 0444)) < 0)", " { perror(\"open\");", " Uerror(fnm);", " } }", "}", "void", "bfs_disk_out(void)", /* this core only */ "{ int i; char fnm[16];", "#ifdef VERBOSE", " bfs_printf(\"out %%d 0..%%d %%d\\n\", 1-bfs_toggle, Cores, who_am_i);", "#endif", " shared_memory->bfs_out_cnt[who_am_i] = 0;", " for (i = 0; i < Cores; i++)", " { sprintf(fnm, \".spin/q%%d_%%d_%%d\", 1-bfs_toggle, i, who_am_i);", " if ((bfs_out_fd[i] = creat(fnm, 0666)) < 0)", " { perror(\"creat\");", " Uerror(fnm);", " } }", "}", "void", "bfs_disk_iclose(void)", "{ int i;", "#ifdef VERBOSE", " bfs_printf(\"close_inp\\n\");", "#endif", " for (i = 0; i < Cores; i++)", " { if (close(bfs_inp_fd[i]) < 0)", " { perror(\"iclose\");", " } }", "}", "void", "bfs_disk_oclose(void)", "{ int i;", "#ifdef VERBOSE", " bfs_printf(\"close_out\\n\");", "#endif", " for (i = 0; i < Cores; i++)", " { if (fsync(bfs_out_fd[i]) < 0)", " { perror(\"fsync\");", " }", " if (close(bfs_out_fd[i]) < 0)", " { perror(\"oclose\");", " } }", "}", "#endif", "void", "bfs_write_snap(int fd)", "{ if (write(fd, snap, strlen(snap)) != strlen(snap))", " { printf(\"pan: error writing %%s\\n\", fnm);", " bfs_shutdown(\"file system error\");", " }", "}", "", "void", "bfs_one_step(BFS_Trail *t, int fd)", "{ if (t && t->t_id != (T_ID) -1)", " { sprintf(snap, \"%%d:%%d:%%d\\n\",", " trcnt++, t->pr, t->t_id);", " bfs_write_snap(fd);", " }", "}", "", "void", "bfs_putter(BFS_Trail *t, int fd)", "{ if (t && t != (BFS_Trail *) t->ostate)", " bfs_putter((BFS_Trail *) t->ostate, fd);", "#ifdef L_BOUND", " if (depthfound == trcnt)", " { strcpy(snap, \"-1:-1:-1\\n\");", " bfs_write_snap(fd);", " depthfound = -1;", " }", "#endif", " bfs_one_step(t, fd);", "}", "", "void", "bfs_nuerror(char *str)", "{ int fd = make_trail();", "", " if (fd < 0) return;", "#ifdef VERI", " sprintf(snap, \"-2:%%d:-2\\n\", (uchar) ((P0 *)pptr(0))->_t);", " bfs_write_snap(fd);", "#endif", "#ifdef MERGED", " sprintf(snap, \"-4:-4:-4\\n\");", " bfs_write_snap(fd);", "#endif", " trcnt = 1;", " if (strstr(str, \"invalid\"))", " { bfs_putter((BFS_Trail *) trpt->ostate, fd);", " } else", " { BFS_Trail x;", " memset((char *) &x, 0, sizeof(BFS_Trail));", " x.pr = trpt->pr;", " x.t_id = (trpt->o_t)?trpt->o_t->t_id:0;", " x.ostate = trpt->ostate;", " bfs_putter(&x, fd);", " }", " close(fd);", " if (errors >= upto && upto != 0)", " { bfs_shutdown(str);", " }", "}", "", "void", "bfs_uerror(char *str)", "{ static char laststr[256];", "", " errors++;", " if (strncmp(str, laststr, 254) != 0)", " { bfs_printf(\"pan:%%d: %%s (at depth %%ld)\\n\",", " errors, str, ((depthfound == -1)?depth:depthfound));", " strncpy(laststr, str, 254);", " }", "#ifdef HAS_CODE", " if (readtrail) { wrap_trail(); return; }", "#endif", " if (every_error != 0 || errors == upto)", " { bfs_nuerror(str);", " }", " if (errors >= upto && upto != 0)", " { bfs_shutdown(\"bfs_uerror\");", " }", " depthfound = -1;", "}\n", "void", "bfs_Uerror(char *str)", "{ /* bfs_uerror(str); */", " bfs_printf(\"pan:%%d: %%s (at depth %%ld)\\n\", ++errors, str,", " ((depthfound == -1)?depth:depthfound));", " bfs_shutdown(\"bfs_Uerror\");", "}", 0, }; Spin/Src6.4.5/make_pc0000775000175100017510000000126012641605057012225 0ustar ghgh#!/bin/sh # SPIN - Verification Software - Version 6.4 - January 2016 # # This file is part of the public release of Spin. It is subject to the # terms in the LICENSE file that is included in this source directory. # Tool documentation is available at http://spinroot.com # # This script is for compiling Spin on a PC with a Unix command shell # It requires cygwin to be installed on your system, with support for: # gcc, sh, yacc, echo, mv, and rm # See also makefile for compiling Spin on a standard Unix/Linux system. yacc -v -d spin.y gcc -O2 -DPC -DNXT -Wall -ansi -o spin.exe *.c rm -f *.o *.obj y?tab.? y.output # installation: echo "mv spin.exe /usr/bin" mv spin.exe /usr/bin Spin/Src6.4.5/version.h0000664000175100017510000000045512641605057012543 0ustar ghgh/***** spin: version.h *****/ /* * This file is part of the public release of Spin. It is subject to the * terms in the LICENSE file that is included in this source directory. * Tool documentation is available at http://spinroot.com */ #define SpinVersion "Spin Version 6.4.5 -- 1 January 2016" Spin/Src6.4.5/pangen4.c0000664000175100017510000001767012641605057012414 0ustar ghgh/***** spin: pangen4.c *****/ /* * This file is part of the public release of Spin. It is subject to the * terms in the LICENSE file that is included in this source directory. * Tool documentation is available at http://spinroot.com */ #include "spin.h" #include "y.tab.h" extern FILE *tc, *tb; extern Queue *qtab; extern Symbol *Fname; extern int lineno, m_loss, Pid, eventmapnr, multi_oval; extern short nocast, has_provided, has_sorted; extern const char *R13[], *R14[], *R15[]; static void check_proc(Lextok *, int); void undostmnt(Lextok *now, int m) { Lextok *v; int i, j; if (!now) { fprintf(tb, "0"); return; } lineno = now->ln; Fname = now->fn; switch (now->ntyp) { case CONST: case '!': case UMIN: case '~': case '/': case '*': case '-': case '+': case '%': case LT: case GT: case '&': case '|': case LE: case GE: case NE: case EQ: case OR: case AND: case LSHIFT: case RSHIFT: case TIMEOUT: case LEN: case NAME: case FULL: case EMPTY: case 'R': case NFULL: case NEMPTY: case ENABLED: case '?': case PC_VAL: case '^': case C_EXPR: case GET_P: case NONPROGRESS: putstmnt(tb, now, m); break; case RUN: fprintf(tb, "delproc(0, now._nr_pr-1)"); break; case 's': if (Pid == eventmapnr) break; if (m_loss) fprintf(tb, "if (_m == 2) "); putname(tb, "_m = unsend(", now->lft, m, ")"); break; case 'r': if (Pid == eventmapnr) break; for (v = now->rgt, i=j=0; v; v = v->rgt, i++) if (v->lft->ntyp != CONST && v->lft->ntyp != EVAL) j++; if (j == 0 && now->val >= 2) break; /* poll without side-effect */ { int ii = 0, jj; for (v = now->rgt; v; v = v->rgt) if ((v->lft->ntyp != CONST && v->lft->ntyp != EVAL)) ii++; /* nr of things bupped */ if (now->val == 1) { ii++; jj = multi_oval - ii - 1; fprintf(tb, "XX = trpt->bup.oval"); if (multi_oval > 0) { fprintf(tb, "s[%d]", jj); jj++; } fprintf(tb, ";\n\t\t"); } else { fprintf(tb, "XX = 1;\n\t\t"); jj = multi_oval - ii - 1; } if (now->val < 2) /* not for channel poll */ for (v = now->rgt, i = 0; v; v = v->rgt, i++) { switch(v->lft->ntyp) { case CONST: case EVAL: fprintf(tb, "unrecv"); putname(tb, "(", now->lft, m, ", XX-1, "); fprintf(tb, "%d, ", i); if (v->lft->ntyp == EVAL) undostmnt(v->lft->lft, m); else undostmnt(v->lft, m); fprintf(tb, ", %d);\n\t\t", (i==0)?1:0); break; default: fprintf(tb, "unrecv"); putname(tb, "(", now->lft, m, ", XX-1, "); fprintf(tb, "%d, ", i); if (v->lft->sym && !strcmp(v->lft->sym->name, "_")) { fprintf(tb, "trpt->bup.oval"); if (multi_oval > 0) fprintf(tb, "s[%d]", jj); } else putstmnt(tb, v->lft, m); fprintf(tb, ", %d);\n\t\t", (i==0)?1:0); if (multi_oval > 0) jj++; break; } } jj = multi_oval - ii - 1; if (now->val == 1 && multi_oval > 0) jj++; /* new 3.4.0 */ for (v = now->rgt, i = 0; v; v = v->rgt, i++) { switch(v->lft->ntyp) { case CONST: case EVAL: break; default: if (!v->lft->sym || strcmp(v->lft->sym->name, "_") != 0) { nocast=1; putstmnt(tb,v->lft,m); nocast=0; fprintf(tb, " = trpt->bup.oval"); if (multi_oval > 0) fprintf(tb, "s[%d]", jj); fprintf(tb, ";\n\t\t"); } if (multi_oval > 0) jj++; break; } } multi_oval -= ii; } break; case '@': fprintf(tb, "p_restor(II);\n\t\t"); break; case SET_P: fprintf(tb, "((P0 *)pptr((trpt->o_priority >> 8)))"); fprintf(tb, "->_priority = trpt->o_priority & 255"); break; case ASGN: if (check_track(now) == STRUCT) { break; } nocast=1; putstmnt(tb,now->lft,m); nocast=0; fprintf(tb, " = trpt->bup.oval"); if (multi_oval > 0) { multi_oval--; fprintf(tb, "s[%d]", multi_oval-1); } check_proc(now->rgt, m); break; case 'c': check_proc(now->lft, m); break; case '.': case GOTO: case ELSE: case BREAK: break; case C_CODE: fprintf(tb, "sv_restor();\n"); break; case ASSERT: case PRINT: check_proc(now, m); break; case PRINTM: break; default: printf("spin: bad node type %d (.b)\n", now->ntyp); alldone(1); } } int any_undo(Lextok *now) { /* is there anything to undo on a return move? */ if (!now) return 1; switch (now->ntyp) { case 'c': return any_oper(now->lft, RUN); case ASSERT: case PRINT: return any_oper(now, RUN); case PRINTM: case '.': case GOTO: case ELSE: case BREAK: return 0; default: return 1; } } int any_oper(Lextok *now, int oper) { /* check if an expression contains oper operator */ if (!now) return 0; if (now->ntyp == oper) return 1; return (any_oper(now->lft, oper) || any_oper(now->rgt, oper)); } static void check_proc(Lextok *now, int m) { if (!now) return; if (now->ntyp == '@' || now->ntyp == RUN) { fprintf(tb, ";\n\t\t"); undostmnt(now, m); } check_proc(now->lft, m); check_proc(now->rgt, m); } void genunio(void) { char buf1[256]; Queue *q; int i; ntimes(tc, 0, 1, R13); for (q = qtab; q; q = q->nxt) { fprintf(tc, "\tcase %d:\n", q->qid); if (has_sorted) { sprintf(buf1, "((Q%d *)z)->contents", q->qid); fprintf(tc, "#ifdef HAS_SORTED\n"); fprintf(tc, "\t\tj = trpt->ipt;\n"); /* ipt was bup.oval */ fprintf(tc, "#endif\n"); fprintf(tc, "\t\tfor (k = j; k < ((Q%d *)z)->Qlen; k++)\n", q->qid); fprintf(tc, "\t\t{\n"); for (i = 0; i < q->nflds; i++) fprintf(tc, "\t\t\t%s[k].fld%d = %s[k+1].fld%d;\n", buf1, i, buf1, i); fprintf(tc, "\t\t}\n"); fprintf(tc, "\t\tj = ((Q0 *)z)->Qlen;\n"); } sprintf(buf1, "((Q%d *)z)->contents[j].fld", q->qid); for (i = 0; i < q->nflds; i++) fprintf(tc, "\t\t%s%d = 0;\n", buf1, i); if (q->nslots==0) { /* check if rendezvous succeeded, 1 level down */ fprintf(tc, "\t\t_m = (trpt+1)->o_m;\n"); fprintf(tc, "\t\tif (_m) (trpt-1)->o_pm |= 1;\n"); fprintf(tc, "\t\tUnBlock;\n"); } else fprintf(tc, "\t\t_m = trpt->o_m;\n"); fprintf(tc, "\t\tbreak;\n"); } ntimes(tc, 0, 1, R14); for (q = qtab; q; q = q->nxt) { sprintf(buf1, "((Q%d *)z)->contents", q->qid); fprintf(tc, " case %d:\n", q->qid); if (q->nslots == 0) fprintf(tc, "\t\tif (strt) boq = from+1;\n"); else if (q->nslots > 1) /* shift */ { fprintf(tc, "\t\tif (strt && slot<%d)\n", q->nslots-1); fprintf(tc, "\t\t{\tfor (j--; j>=slot; j--)\n"); fprintf(tc, "\t\t\t{"); for (i = 0; i < q->nflds; i++) { fprintf(tc, "\t%s[j+1].fld%d =\n\t\t\t", buf1, i); fprintf(tc, "\t%s[j].fld%d;\n\t\t\t", buf1, i); } fprintf(tc, "}\n\t\t}\n"); } strcat(buf1, "[slot].fld"); fprintf(tc, "\t\tif (strt) {\n"); for (i = 0; i < q->nflds; i++) fprintf(tc, "\t\t\t%s%d = 0;\n", buf1, i); fprintf(tc, "\t\t}\n"); if (q->nflds == 1) /* set */ fprintf(tc, "\t\tif (fld == 0) %s0 = fldvar;\n", buf1); else { fprintf(tc, "\t\tswitch (fld) {\n"); for (i = 0; i < q->nflds; i++) { fprintf(tc, "\t\tcase %d:\t%s", i, buf1); fprintf(tc, "%d = fldvar; break;\n", i); } fprintf(tc, "\t\t}\n"); } fprintf(tc, "\t\tbreak;\n"); } ntimes(tc, 0, 1, R15); } extern void explain(int); int proper_enabler(Lextok *n) { if (!n) return 1; switch (n->ntyp) { case NEMPTY: case FULL: case NFULL: case EMPTY: case LEN: case 'R': case NAME: has_provided = 1; if (strcmp(n->sym->name, "_pid") == 0 || strcmp(n->sym->name, "_priority") == 0) return 1; return (!(n->sym->context)); case C_EXPR: case CONST: case TIMEOUT: has_provided = 1; return 1; case ENABLED: case PC_VAL: case GET_P: /* not SET_P */ return proper_enabler(n->lft); case '!': case UMIN: case '~': return proper_enabler(n->lft); case '/': case '*': case '-': case '+': case '%': case LT: case GT: case '&': case '^': case '|': case LE: case GE: case NE: case '?': case EQ: case OR: case AND: case LSHIFT: case RSHIFT: case 'c': /* case ',': */ return proper_enabler(n->lft) && proper_enabler(n->rgt); default: break; } printf("spin: saw "); explain(n->ntyp); printf("\n"); return 0; } Spin/Src6.4.5/reprosrc.c0000664000175100017510000002265212641605057012713 0ustar ghgh/***** spin: reprosrc.c *****/ /* * This file is part of the public release of Spin. It is subject to the * terms in the LICENSE file that is included in this source directory. * Tool documentation is available at http://spinroot.com */ #include #include #include "spin.h" #include "y.tab.h" static int indent = 1; extern YYSTYPE yylval; extern ProcList *rdy; static void repro_seq(Sequence *); void doindent(void) { int i; for (i = 0; i < indent; i++) printf(" "); } void repro_sub(Element *e) { doindent(); switch (e->n->ntyp) { case D_STEP: printf("d_step {\n"); break; case ATOMIC: printf("atomic {\n"); break; case NON_ATOMIC: printf(" {\n"); break; } indent++; repro_seq(e->n->sl->this); indent--; doindent(); printf(" };\n"); } static void repro_seq(Sequence *s) { Element *e; Symbol *v; SeqList *h; for (e = s->frst; e; e = e->nxt) { v = has_lab(e, 0); if (v) printf("%s:\n", v->name); if (e->n->ntyp == UNLESS) { printf("/* normal */ {\n"); repro_seq(e->n->sl->this); doindent(); printf("} unless {\n"); repro_seq(e->n->sl->nxt->this); doindent(); printf("}; /* end unless */\n"); } else if (e->sub) { switch (e->n->ntyp) { case DO: doindent(); printf("do\n"); indent++; break; case IF: doindent(); printf("if\n"); indent++; break; } for (h = e->sub; h; h = h->nxt) { indent--; doindent(); indent++; printf("::\n"); repro_seq(h->this); printf("\n"); } switch (e->n->ntyp) { case DO: indent--; doindent(); printf("od;\n"); break; case IF: indent--; doindent(); printf("fi;\n"); break; } } else { if (e->n->ntyp == ATOMIC || e->n->ntyp == D_STEP || e->n->ntyp == NON_ATOMIC) repro_sub(e); else if (e->n->ntyp != '.' && e->n->ntyp != '@' && e->n->ntyp != BREAK) { doindent(); if (e->n->ntyp == C_CODE) { printf("c_code "); plunk_inline(stdout, e->n->sym->name, 1, 1); } else if (e->n->ntyp == 'c' && e->n->lft->ntyp == C_EXPR) { printf("c_expr { "); plunk_expr(stdout, e->n->lft->sym->name); printf("} ->\n"); } else { comment(stdout, e->n, 0); printf(";\n"); } } } if (e == s->last) break; } } void repro_proc(ProcList *p) { if (!p) return; if (p->nxt) repro_proc(p->nxt); if (p->det) printf("D"); /* deterministic */ printf("proctype %s()", p->n->name); if (p->prov) { printf(" provided "); comment(stdout, p->prov, 0); } printf("\n{\n"); repro_seq(p->s); printf("}\n"); } void repro_src(void) { repro_proc(rdy); } static int in_decl; static int in_c_decl; static int in_c_code; void blip(int n, char *b) { char mtxt[1024]; strcpy(mtxt, ""); switch (n) { default: if (n > 0 && n < 256) sprintf(mtxt, "%c", n); else sprintf(mtxt, "<%d?>", n); break; case '(': strcpy(mtxt, "("); in_decl++; break; case ')': strcpy(mtxt, ")"); in_decl--; break; case '{': strcpy(mtxt, "{"); break; case '}': strcpy(mtxt, "}"); break; case '\t': sprintf(mtxt, "\\t"); break; case '\f': sprintf(mtxt, "\\f"); break; case '\n': sprintf(mtxt, "\\n"); break; case '\r': sprintf(mtxt, "\\r"); break; case 'c': sprintf(mtxt, "condition"); break; case 's': sprintf(mtxt, "send"); break; case 'r': sprintf(mtxt, "recv"); break; case 'R': sprintf(mtxt, "recv poll"); break; case '@': sprintf(mtxt, "@"); break; case '?': sprintf(mtxt, "(x->y:z)"); break; case NEXT: sprintf(mtxt, "X"); break; case ALWAYS: sprintf(mtxt, "[]"); break; case EVENTUALLY: sprintf(mtxt, "<>"); break; case IMPLIES: sprintf(mtxt, "->"); break; case EQUIV: sprintf(mtxt, "<->"); break; case UNTIL: sprintf(mtxt, "U"); break; case WEAK_UNTIL: sprintf(mtxt, "W"); break; case IN: sprintf(mtxt, "in"); break; case ACTIVE: sprintf(mtxt, "active"); break; case AND: sprintf(mtxt, "&&"); break; case ARROW: sprintf(mtxt, "->"); break; case ASGN: sprintf(mtxt, "="); break; case ASSERT: sprintf(mtxt, "assert"); break; case ATOMIC: sprintf(mtxt, "atomic"); break; case BREAK: sprintf(mtxt, "break"); break; case C_CODE: sprintf(mtxt, "c_code"); in_c_code++; break; case C_DECL: sprintf(mtxt, "c_decl"); in_c_decl++; break; case C_EXPR: sprintf(mtxt, "c_expr"); break; case C_STATE: sprintf(mtxt, "c_state"); break; case C_TRACK: sprintf(mtxt, "c_track"); break; case CLAIM: sprintf(mtxt, "never"); break; case CONST: sprintf(mtxt, "%d", yylval->val); break; case DECR: sprintf(mtxt, "--"); break; case D_STEP: sprintf(mtxt, "d_step"); break; case D_PROCTYPE: sprintf(mtxt, "d_proctype"); break; case DO: sprintf(mtxt, "do"); break; case DOT: sprintf(mtxt, "."); break; case ELSE: sprintf(mtxt, "else"); break; case EMPTY: sprintf(mtxt, "empty"); break; case ENABLED: sprintf(mtxt, "enabled"); break; case EQ: sprintf(mtxt, "=="); break; case EVAL: sprintf(mtxt, "eval"); break; case FI: sprintf(mtxt, "fi"); break; case FULL: sprintf(mtxt, "full"); break; case GE: sprintf(mtxt, ">="); break; case GET_P: sprintf(mtxt, "get_priority"); break; case GOTO: sprintf(mtxt, "goto"); break; case GT: sprintf(mtxt, ">"); break; case HIDDEN: sprintf(mtxt, "hidden"); break; case IF: sprintf(mtxt, "if"); break; case INCR: sprintf(mtxt, "++"); break; case INLINE: sprintf(mtxt, "inline"); break; case INIT: sprintf(mtxt, "init"); break; case ISLOCAL: sprintf(mtxt, "local"); break; case LABEL: sprintf(mtxt, ""); break; case LE: sprintf(mtxt, "<="); break; case LEN: sprintf(mtxt, "len"); break; case LSHIFT: sprintf(mtxt, "<<"); break; case LT: sprintf(mtxt, "<"); break; case LTL: sprintf(mtxt, "ltl"); break; case NAME: sprintf(mtxt, "%s", yylval->sym->name); break; case XU: switch (yylval->val) { case XR: sprintf(mtxt, "xr"); break; case XS: sprintf(mtxt, "xs"); break; default: sprintf(mtxt, ""); break; } break; case TYPE: switch (yylval->val) { case BIT: sprintf(mtxt, "bit"); break; case BYTE: sprintf(mtxt, "byte"); break; case CHAN: sprintf(mtxt, "chan"); in_decl++; break; case INT: sprintf(mtxt, "int"); break; case MTYPE: sprintf(mtxt, "mtype"); break; case SHORT: sprintf(mtxt, "short"); break; case UNSIGNED: sprintf(mtxt, "unsigned"); break; default: sprintf(mtxt, ""); break; } break; case NE: sprintf(mtxt, "!="); break; case NEG: sprintf(mtxt, "!"); break; case NEMPTY: sprintf(mtxt, "nempty"); break; case NFULL: sprintf(mtxt, "nfull"); break; case NON_ATOMIC: sprintf(mtxt, ""); break; case NONPROGRESS: sprintf(mtxt, "np_"); break; case OD: sprintf(mtxt, "od"); break; case OF: sprintf(mtxt, "of"); break; case OR: sprintf(mtxt, "||"); break; case O_SND: sprintf(mtxt, "!!"); break; case PC_VAL: sprintf(mtxt, "pc_value"); break; case PRINT: sprintf(mtxt, "printf"); break; case PRINTM: sprintf(mtxt, "printm"); break; case PRIORITY: sprintf(mtxt, "priority"); break; case PROCTYPE: sprintf(mtxt, "proctype"); break; case PROVIDED: sprintf(mtxt, "provided"); break; case RCV: sprintf(mtxt, "?"); break; case R_RCV: sprintf(mtxt, "??"); break; case RSHIFT: sprintf(mtxt, ">>"); break; case RUN: sprintf(mtxt, "run"); break; case SEP: sprintf(mtxt, "::"); break; case SEMI: sprintf(mtxt, ";"); break; case SET_P: sprintf(mtxt, "set_priority"); break; case SHOW: sprintf(mtxt, "show"); break; case SND: sprintf(mtxt, "!"); break; case INAME: case UNAME: case PNAME: case STRING: sprintf(mtxt, "%s", yylval->sym->name); break; case TRACE: sprintf(mtxt, "trace"); break; case TIMEOUT: sprintf(mtxt, "timeout"); break; case TYPEDEF: sprintf(mtxt, "typedef"); break; case UMIN: sprintf(mtxt, "-"); break; case UNLESS: sprintf(mtxt, "unless"); break; } strcat(b, mtxt); } void purge(char *b) { if (strlen(b) == 0) return; if (b[strlen(b)-1] != ':') /* label? */ { if (b[0] == ':' && b[1] == ':') { indent--; doindent(); indent++; } else { doindent(); } } printf("%s\n", b); strcpy(b, ""); in_decl = 0; in_c_code = 0; in_c_decl = 0; } int pp_mode; extern int lex(void); void pretty_print(void) { int c, lastc = 0; char buf[1024]; pp_mode = 1; indent = 0; strcpy(buf, ""); while ((c = lex()) != EOF) { if ((lastc == IF || lastc == DO) && c != SEP) { indent--; /* c_code if */ } if (c == C_DECL || c == C_STATE || c == C_TRACK || c == SEP || c == DO || c == IF || (c == TYPE && !in_decl)) { purge(buf); /* start on new line */ } if (c == '{' && lastc != OF && lastc != IN && lastc != ATOMIC && lastc != D_STEP && lastc != C_CODE && lastc != C_DECL && lastc != C_EXPR) { purge(buf); } if (c == PREPROC) { int oi = indent; purge(buf); assert(strlen(yylval->sym->name) < sizeof(buf)); strcpy(buf, yylval->sym->name); indent = 0; purge(buf); indent = oi; continue; } if (c != ':' && c != SEMI && c != ',' && c != '(' && c != '#' && lastc != '#' && c != ARROW && lastc != ARROW && c != '.' && lastc != '.' && c != '!' && lastc != '!' && c != SND && lastc != SND && c != RCV && lastc != RCV && c != O_SND && lastc != O_SND && c != R_RCV && lastc != R_RCV && (c != ']' || lastc != '[') && (c != '>' || lastc != '<') && (c != GT || lastc != LT) && c != '@' && lastc != '@' && c != DO && c != OD && c != IF && c != FI && c != SEP && strlen(buf) > 0) strcat(buf, " "); if (c == '}' || c == OD || c == FI) { purge(buf); indent--; } blip(c, buf); if (c == '{' || c == DO || c == IF) { purge(buf); indent++; } if (c == '}' || c == BREAK || c == SEMI || (c == ':' && lastc == NAME)) { purge(buf); } lastc = c; } purge(buf); } Spin/Src6.4.5/tl_buchi.c0000664000175100017510000003155312641605057012645 0ustar ghgh/***** tl_spin: tl_buchi.c *****/ /* * This file is part of the public release of Spin. It is subject to the * terms in the LICENSE file that is included in this source directory. * Tool documentation is available at http://spinroot.com * * Based on the translation algorithm by Gerth, Peled, Vardi, and Wolper, * presented at the PSTV Conference, held in 1995, Warsaw, Poland 1995. */ #include "tl.h" extern int tl_verbose, tl_clutter, Total, Max_Red; extern char *claim_name; FILE *tl_out; /* if standalone: = stdout; */ typedef struct Transition { Symbol *name; Node *cond; int redundant, merged, marked; struct Transition *nxt; } Transition; typedef struct State { Symbol *name; Transition *trans; Graph *colors; unsigned char redundant; unsigned char accepting; unsigned char reachable; struct State *nxt; } State; static State *never = (State *) 0; static int hitsall; void ini_buchi(void) { never = (State *) 0; hitsall = 0; } static int sametrans(Transition *s, Transition *t) { if (strcmp(s->name->name, t->name->name) != 0) return 0; return isequal(s->cond, t->cond); } static Node * Prune(Node *p) { if (p) switch (p->ntyp) { case PREDICATE: case NOT: case FALSE: case TRUE: #ifdef NXT case NEXT: #endif case CEXPR: return p; case OR: p->lft = Prune(p->lft); if (!p->lft) { releasenode(1, p->rgt); return ZN; } p->rgt = Prune(p->rgt); if (!p->rgt) { releasenode(1, p->lft); return ZN; } return p; case AND: p->lft = Prune(p->lft); if (!p->lft) return Prune(p->rgt); p->rgt = Prune(p->rgt); if (!p->rgt) return p->lft; return p; } releasenode(1, p); return ZN; } static State * findstate(char *nm) { State *b; for (b = never; b; b = b->nxt) if (!strcmp(b->name->name, nm)) return b; if (strcmp(nm, "accept_all")) { if (strncmp(nm, "accept", 6)) { int i; char altnm[64]; for (i = 0; i < 64; i++) if (nm[i] == '_') break; if (i >= 64) Fatal("name too long %s", nm); sprintf(altnm, "accept%s", &nm[i]); return findstate(altnm); } /* Fatal("buchi: no state %s", nm); */ } return (State *) 0; } static void Dfs(State *b) { Transition *t; if (!b || b->reachable) return; b->reachable = 1; if (b->redundant) printf("/* redundant state %s */\n", b->name->name); for (t = b->trans; t; t = t->nxt) { if (!t->redundant) { Dfs(findstate(t->name->name)); if (!hitsall && strcmp(t->name->name, "accept_all") == 0) hitsall = 1; } } } void retarget(char *from, char *to) { State *b; Transition *t; Symbol *To = tl_lookup(to); if (tl_verbose) printf("replace %s with %s\n", from, to); for (b = never; b; b = b->nxt) { if (!strcmp(b->name->name, from)) b->redundant = 1; else for (t = b->trans; t; t = t->nxt) { if (!strcmp(t->name->name, from)) t->name = To; } } } #ifdef NXT static Node * nonxt(Node *n) { switch (n->ntyp) { case U_OPER: case V_OPER: case NEXT: return ZN; case OR: n->lft = nonxt(n->lft); n->rgt = nonxt(n->rgt); if (!n->lft || !n->rgt) return True; return n; case AND: n->lft = nonxt(n->lft); n->rgt = nonxt(n->rgt); if (!n->lft) { if (!n->rgt) n = ZN; else n = n->rgt; } else if (!n->rgt) n = n->lft; return n; } return n; } #endif static Node * combination(Node *s, Node *t) { Node *nc; #ifdef NXT Node *a = nonxt(s); Node *b = nonxt(t); if (tl_verbose) { printf("\tnonxtA: "); dump(a); printf("\n\tnonxtB: "); dump(b); printf("\n"); } /* if there's only a X(f), its equivalent to true */ if (!a || !b) nc = True; else nc = tl_nn(OR, a, b); #else nc = tl_nn(OR, s, t); #endif if (tl_verbose) { printf("\tcombo: "); dump(nc); printf("\n"); } return nc; } Node * unclutter(Node *n, char *snm) { Node *t, *s, *v, *u; Symbol *w; /* check only simple cases like !q && q */ for (t = n; t; t = t->rgt) { if (t->rgt) { if (t->ntyp != AND || !t->lft) return n; if (t->lft->ntyp != PREDICATE #ifdef NXT && t->lft->ntyp != NEXT #endif && t->lft->ntyp != NOT) return n; } else { if (t->ntyp != PREDICATE #ifdef NXT && t->ntyp != NEXT #endif && t->ntyp != NOT) return n; } } for (t = n; t; t = t->rgt) { if (t->rgt) v = t->lft; else v = t; if (v->ntyp == NOT && v->lft->ntyp == PREDICATE) { w = v->lft->sym; for (s = n; s; s = s->rgt) { if (s == t) continue; if (s->rgt) u = s->lft; else u = s; if (u->ntyp == PREDICATE && strcmp(u->sym->name, w->name) == 0) { if (tl_verbose) { printf("BINGO %s:\t", snm); dump(n); printf("\n"); } return False; } } } } return n; } static void clutter(void) { State *p; Transition *s; for (p = never; p; p = p->nxt) for (s = p->trans; s; s = s->nxt) { s->cond = unclutter(s->cond, p->name->name); if (s->cond && s->cond->ntyp == FALSE) { if (s != p->trans || s->nxt) s->redundant = 1; } } } static void showtrans(State *a) { Transition *s; for (s = a->trans; s; s = s->nxt) { printf("%s ", s->name?s->name->name:"-"); dump(s->cond); printf(" %d %d %d\n", s->redundant, s->merged, s->marked); } } static int mergetrans(void) { State *b; Transition *s, *t; Node *nc; int cnt = 0; for (b = never; b; b = b->nxt) { if (!b->reachable) continue; for (s = b->trans; s; s = s->nxt) { if (s->redundant) continue; for (t = s->nxt; t; t = t->nxt) if (!t->redundant && !strcmp(s->name->name, t->name->name)) { if (tl_verbose) { printf("===\nstate %s, trans to %s redundant\n", b->name->name, s->name->name); showtrans(b); printf(" conditions "); dump(s->cond); printf(" <-> "); dump(t->cond); printf("\n"); } if (!s->cond) /* same as T */ { releasenode(1, t->cond); /* T or t */ nc = True; } else if (!t->cond) { releasenode(1, s->cond); nc = True; } else { nc = combination(s->cond, t->cond); } t->cond = rewrite(nc); t->merged = 1; s->redundant = 1; cnt++; break; } } } return cnt; } static int all_trans_match(State *a, State *b) { Transition *s, *t; int found, result = 0; if (a->accepting != b->accepting) goto done; for (s = a->trans; s; s = s->nxt) { if (s->redundant) continue; found = 0; for (t = b->trans; t; t = t->nxt) { if (t->redundant) continue; if (sametrans(s, t)) { found = 1; t->marked = 1; break; } } if (!found) goto done; } for (s = b->trans; s; s = s->nxt) { if (s->redundant || s->marked) continue; found = 0; for (t = a->trans; t; t = t->nxt) { if (t->redundant) continue; if (sametrans(s, t)) { found = 1; break; } } if (!found) goto done; } result = 1; done: for (s = b->trans; s; s = s->nxt) s->marked = 0; return result; } #ifndef NO_OPT #define BUCKY #endif #ifdef BUCKY static int all_bucky(State *a, State *b) { Transition *s, *t; int found, result = 0; for (s = a->trans; s; s = s->nxt) { if (s->redundant) continue; found = 0; for (t = b->trans; t; t = t->nxt) { if (t->redundant) continue; if (isequal(s->cond, t->cond)) { if (strcmp(s->name->name, b->name->name) == 0 && strcmp(t->name->name, a->name->name) == 0) { found = 1; /* they point to each other */ t->marked = 1; break; } if (strcmp(s->name->name, t->name->name) == 0 && strcmp(s->name->name, "accept_all") == 0) { found = 1; t->marked = 1; break; /* same exit from which there is no return */ } } } if (!found) goto done; } for (s = b->trans; s; s = s->nxt) { if (s->redundant || s->marked) continue; found = 0; for (t = a->trans; t; t = t->nxt) { if (t->redundant) continue; if (isequal(s->cond, t->cond)) { if (strcmp(s->name->name, a->name->name) == 0 && strcmp(t->name->name, b->name->name) == 0) { found = 1; t->marked = 1; break; } if (strcmp(s->name->name, t->name->name) == 0 && strcmp(s->name->name, "accept_all") == 0) { found = 1; t->marked = 1; break; } } } if (!found) goto done; } result = 1; done: for (s = b->trans; s; s = s->nxt) s->marked = 0; return result; } static int buckyballs(void) { State *a, *b, *c, *d; int m, cnt=0; do { m = 0; cnt++; for (a = never; a; a = a->nxt) { if (!a->reachable) continue; if (a->redundant) continue; for (b = a->nxt; b; b = b->nxt) { if (!b->reachable) continue; if (b->redundant) continue; if (all_bucky(a, b)) { m++; if (tl_verbose) { printf("%s bucky match %s\n", a->name->name, b->name->name); } if (a->accepting && !b->accepting) { if (strcmp(b->name->name, "T0_init") == 0) { c = a; d = b; b->accepting = 1; } else { c = b; d = a; } } else { c = a; d = b; } retarget(c->name->name, d->name->name); if (!strncmp(c->name->name, "accept", 6) && Max_Red == 0) { char buf[64]; sprintf(buf, "T0%s", &(c->name->name[6])); retarget(buf, d->name->name); } break; } } } } while (m && cnt < 10); return cnt-1; } #endif static int mergestates(int v) { State *a, *b; int m, cnt=0; if (tl_verbose) return 0; do { m = 0; cnt++; for (a = never; a; a = a->nxt) { if (v && !a->reachable) continue; if (a->redundant) continue; /* 3.3.10 */ for (b = a->nxt; b; b = b->nxt) { if (v && !b->reachable) continue; if (b->redundant) continue; /* 3.3.10 */ if (all_trans_match(a, b)) { m++; if (tl_verbose) { printf("%d: state %s equals state %s\n", cnt, a->name->name, b->name->name); showtrans(a); printf("==\n"); showtrans(b); } retarget(a->name->name, b->name->name); if (!strncmp(a->name->name, "accept", 6) && Max_Red == 0) { char buf[64]; sprintf(buf, "T0%s", &(a->name->name[6])); retarget(buf, b->name->name); } break; } #if 0 else if (tl_verbose) { printf("\n%d: state %s differs from state %s [%d,%d]\n", cnt, a->name->name, b->name->name, a->accepting, b->accepting); showtrans(a); printf("==\n"); showtrans(b); printf("\n"); } #endif } } } while (m && cnt < 10); return cnt-1; } static int tcnt; static void rev_trans(Transition *t) /* print transitions in reverse order... */ { if (!t) return; rev_trans(t->nxt); if (t->redundant && !tl_verbose) return; if (strcmp(t->name->name, "accept_all") == 0) /* 6.2.4 */ { /* not d_step because there may be remote refs */ fprintf(tl_out, "\t:: atomic { ("); if (dump_cond(t->cond, t->cond, 1)) fprintf(tl_out, "1"); fprintf(tl_out, ") -> assert(!("); if (dump_cond(t->cond, t->cond, 1)) fprintf(tl_out, "1"); fprintf(tl_out, ")) }\n"); } else { fprintf(tl_out, "\t:: ("); if (dump_cond(t->cond, t->cond, 1)) fprintf(tl_out, "1"); fprintf(tl_out, ") -> goto %s\n", t->name->name); } tcnt++; } static void printstate(State *b) { if (!b || (!tl_verbose && !b->reachable)) return; b->reachable = 0; /* print only once */ fprintf(tl_out, "%s:\n", b->name->name); if (tl_verbose) { fprintf(tl_out, " /* "); dump(b->colors->Other); fprintf(tl_out, " */\n"); } if (strncmp(b->name->name, "accept", 6) == 0 && Max_Red == 0) fprintf(tl_out, "T0%s:\n", &(b->name->name[6])); fprintf(tl_out, "\tdo\n"); tcnt = 0; rev_trans(b->trans); if (!tcnt) fprintf(tl_out, "\t:: false\n"); fprintf(tl_out, "\tod;\n"); Total++; } void addtrans(Graph *col, char *from, Node *op, char *to) { State *b; Transition *t; t = (Transition *) tl_emalloc(sizeof(Transition)); t->name = tl_lookup(to); t->cond = Prune(dupnode(op)); if (tl_verbose) { printf("\n%s <<\t", from); dump(op); printf("\n\t"); dump(t->cond); printf(">> %s\n", t->name->name); } if (t->cond) t->cond = rewrite(t->cond); for (b = never; b; b = b->nxt) if (!strcmp(b->name->name, from)) { t->nxt = b->trans; b->trans = t; return; } b = (State *) tl_emalloc(sizeof(State)); b->name = tl_lookup(from); b->colors = col; b->trans = t; if (!strncmp(from, "accept", 6)) b->accepting = 1; b->nxt = never; never = b; } static void clr_reach(void) { State *p; for (p = never; p; p = p->nxt) p->reachable = 0; hitsall = 0; } void fsm_print(void) { State *b; int cnt1, cnt2=0; extern void put_uform(void); if (tl_clutter) clutter(); b = findstate("T0_init"); if (b && (Max_Red == 0)) b->accepting = 1; mergestates(0); b = findstate("T0_init"); fprintf(tl_out, "never %s { /* ", claim_name?claim_name:""); put_uform(); fprintf(tl_out, " */\n"); do { clr_reach(); Dfs(b); cnt1 = mergetrans(); cnt2 = mergestates(1); if (tl_verbose) printf("/* >>%d,%d<< */\n", cnt1, cnt2); } while (cnt2 > 0); #ifdef BUCKY buckyballs(); clr_reach(); Dfs(b); #endif if (b && b->accepting) fprintf(tl_out, "accept_init:\n"); if (!b && !never) { fprintf(tl_out, " 0 /* false */;\n"); } else { printstate(b); /* init state must be first */ for (b = never; b; b = b->nxt) printstate(b); } if (hitsall) fprintf(tl_out, "accept_all:\n skip\n"); fprintf(tl_out, "}\n"); } Spin/Src6.4.5/sched.c0000664000175100017510000006062312641605057012142 0ustar ghgh/***** spin: sched.c *****/ /* * This file is part of the public release of Spin. It is subject to the * terms in the LICENSE file that is included in this source directory. * Tool documentation is available at http://spinroot.com */ #include #include "spin.h" #include "y.tab.h" extern int verbose, s_trail, analyze, no_wrapup; extern char *claimproc, *eventmap, Buf[]; extern Ordered *all_names; extern Symbol *Fname, *context; extern int lineno, nr_errs, dumptab, xspin, jumpsteps, columns; extern int u_sync, Elcnt, interactive, TstOnly, cutoff; extern short has_enabled, has_priority, has_code, replay; extern int limited_vis, product, nclaims, old_priority_rules; extern int old_scope_rules, scope_seq[128], scope_level, has_stdin; extern int pc_highest(Lextok *n); RunList *X = (RunList *) 0; RunList *run = (RunList *) 0; RunList *LastX = (RunList *) 0; /* previous executing proc */ ProcList *rdy = (ProcList *) 0; Element *LastStep = ZE; int nproc=0, nstop=0, Tval=0, Priority_Sum = 0; int Rvous=0, depth=0, nrRdy=0, MadeChoice; short Have_claim=0, Skip_claim=0; static void setlocals(RunList *); static void setparams(RunList *, ProcList *, Lextok *); static void talk(RunList *); void runnable(ProcList *p, int weight, int noparams) { RunList *r = (RunList *) emalloc(sizeof(RunList)); r->n = p->n; r->tn = p->tn; r->b = p->b; r->pid = nproc++ - nstop + Skip_claim; r->priority = weight; p->priority = (unsigned char) weight; /* not quite the best place of course */ if (!noparams && ((verbose&4) || (verbose&32))) { printf("Starting %s with pid %d", p->n?p->n->name:"--", r->pid); if (has_priority) printf(" priority %d", r->priority); printf("\n"); } if (!p->s) fatal("parsing error, no sequence %s", p->n?p->n->name:"--"); r->pc = huntele(p->s->frst, p->s->frst->status, -1); r->ps = p->s; if (p->s->last) p->s->last->status |= ENDSTATE; /* normal end state */ r->nxt = run; r->prov = p->prov; if (weight < 1 || weight > 255) { fatal("bad process priority, valid range: 1..255", (char *) 0); } if (noparams) setlocals(r); Priority_Sum += weight; run = r; } ProcList * ready(Symbol *n, Lextok *p, Sequence *s, int det, Lextok *prov, enum btypes b) /* n=name, p=formals, s=body det=deterministic prov=provided */ { ProcList *r = (ProcList *) emalloc(sizeof(ProcList)); Lextok *fp, *fpt; int j; extern int Npars; r->n = n; r->p = p; r->s = s; r->b = b; r->prov = prov; r->tn = (short) nrRdy++; n->sc = scope_seq[scope_level]; /* scope_level should be 0 */ if (det != 0 && det != 1) { fprintf(stderr, "spin: bad value for det (cannot happen)\n"); } r->det = (unsigned char) det; r->nxt = rdy; rdy = r; for (fp = p, j = 0; fp; fp = fp->rgt) for (fpt = fp->lft; fpt; fpt = fpt->rgt) j++; /* count # of parameters */ Npars = max(Npars, j); return rdy; } int find_maxel(Symbol *s) { ProcList *p; for (p = rdy; p; p = p->nxt) if (p->n == s) return p->s->maxel++; return Elcnt++; } static void formdump(void) { ProcList *p; Lextok *f, *t; int cnt; for (p = rdy; p; p = p->nxt) { if (!p->p) continue; cnt = -1; for (f = p->p; f; f = f->rgt) /* types */ for (t = f->lft; t; t = t->rgt) /* formals */ { if (t->ntyp != ',') t->sym->Nid = cnt--; /* overload Nid */ else t->lft->sym->Nid = cnt--; } } } void announce(char *w) { if (columns) { extern char Buf[]; extern int firstrow; firstrow = 1; if (columns == 2) { sprintf(Buf, "%d:%s", run->pid - Have_claim, run->n->name); pstext(run->pid - Have_claim, Buf); } else { printf("proc %d = %s\n", run->pid - Have_claim, run->n->name); } return; } if (dumptab || analyze || product || s_trail || !(verbose&4)) return; if (w) printf(" 0: proc - (%s) ", w); else whoruns(1); printf("creates proc %2d (%s)", run->pid - Have_claim, run->n->name); if (run->priority > 1) printf(" priority %d", run->priority); printf("\n"); } #ifndef MAXP #define MAXP 255 /* matches max nr of processes in verifier */ #endif int enable(Lextok *m) { ProcList *p; Symbol *s = m->sym; /* proctype name */ Lextok *n = m->lft; /* actual parameters */ if (m->val < 1) { m->val = 1; /* minimum priority */ } for (p = rdy; p; p = p->nxt) { if (strcmp(s->name, p->n->name) == 0) { if (nproc-nstop >= MAXP) { printf("spin: too many processes (%d max)\n", MAXP); break; } runnable(p, m->val, 0); announce((char *) 0); setparams(run, p, n); setlocals(run); /* after setparams */ return run->pid - Have_claim + Skip_claim; /* effective simu pid */ } } return 0; /* process not found */ } void check_param_count(int i, Lextok *m) { ProcList *p; Symbol *s = m->sym; /* proctype name */ Lextok *f, *t; /* formal pars */ int cnt = 0; for (p = rdy; p; p = p->nxt) { if (strcmp(s->name, p->n->name) == 0) { if (m->lft) /* actual param list */ { lineno = m->lft->ln; Fname = m->lft->fn; } for (f = p->p; f; f = f->rgt) /* one type at a time */ for (t = f->lft; t; t = t->rgt) /* count formal params */ { cnt++; } if (i != cnt) { printf("spin: saw %d parameters, expected %d\n", i, cnt); non_fatal("wrong number of parameters", ""); } break; } } } void start_claim(int n) { ProcList *p; RunList *r, *q = (RunList *) 0; for (p = rdy; p; p = p->nxt) if (p->tn == n && p->b == N_CLAIM) { runnable(p, 1, 1); goto found; } printf("spin: couldn't find claim %d (ignored)\n", n); if (verbose&32) for (p = rdy; p; p = p->nxt) printf("\t%d = %s\n", p->tn, p->n->name); Skip_claim = 1; goto done; found: /* move claim to far end of runlist, and reassign it pid 0 */ if (columns == 2) { extern char Buf[]; depth = 0; sprintf(Buf, "%d:%s", 0, p->n->name); pstext(0, Buf); for (r = run; r; r = r->nxt) { if (r->b != N_CLAIM) { sprintf(Buf, "%d:%s", r->pid+1, r->n->name); pstext(r->pid+1, Buf); } } } if (run->pid == 0) return; /* it is the first process started */ q = run; run = run->nxt; q->pid = 0; q->nxt = (RunList *) 0; /* remove */ done: Have_claim = 1; for (r = run; r; r = r->nxt) { r->pid = r->pid+Have_claim; /* adjust */ if (!r->nxt) { r->nxt = q; break; } } } int f_pid(char *n) { RunList *r; int rval = -1; for (r = run; r; r = r->nxt) if (strcmp(n, r->n->name) == 0) { if (rval >= 0) { printf("spin: remote ref to proctype %s, ", n); printf("has more than one match: %d and %d\n", rval, r->pid); } else rval = r->pid; } return rval; } void wrapup(int fini) { limited_vis = 0; if (columns) { extern void putpostlude(void); if (columns == 2) putpostlude(); if (!no_wrapup) printf("-------------\nfinal state:\n-------------\n"); } if (no_wrapup) goto short_cut; if (nproc != nstop) { int ov = verbose; printf("#processes: %d\n", nproc-nstop - Have_claim + Skip_claim); verbose &= ~4; dumpglobals(); verbose = ov; verbose &= ~1; /* no more globals */ verbose |= 32; /* add process states */ for (X = run; X; X = X->nxt) talk(X); verbose = ov; /* restore */ } printf("%d process%s created\n", nproc - Have_claim + Skip_claim, (xspin || nproc!=1)?"es":""); short_cut: if (s_trail || xspin) alldone(0); /* avoid an abort from xspin */ if (fini) alldone(1); } static char is_blocked[256]; static int p_blocked(int p) { int i, j; is_blocked[p%256] = 1; for (i = j = 0; i < nproc - nstop; i++) j += is_blocked[i]; if (j >= nproc - nstop) { memset(is_blocked, 0, 256); return 1; } return 0; } static Element * silent_moves(Element *e) { Element *f; if (e->n) switch (e->n->ntyp) { case GOTO: if (Rvous) break; f = get_lab(e->n, 1); cross_dsteps(e->n, f->n); return f; /* guard against goto cycles */ case UNLESS: return silent_moves(e->sub->this->frst); case NON_ATOMIC: case ATOMIC: case D_STEP: e->n->sl->this->last->nxt = e->nxt; return silent_moves(e->n->sl->this->frst); case '.': return silent_moves(e->nxt); } return e; } static int x_can_run(void) /* the currently selected process in X can run */ { if (X->prov && !eval(X->prov)) { if (0) printf("pid %d cannot run: not provided\n", X->pid); return 0; } if (has_priority && !old_priority_rules) { Lextok *n = nn(ZN, CONST, ZN, ZN); n->val = X->pid; if (0) printf("pid %d %s run (priority)\n", X->pid, pc_highest(n)?"can":"cannot"); return pc_highest(n); } if (0) printf("pid %d can run\n", X->pid); return 1; } static RunList * pickproc(RunList *Y) { SeqList *z; Element *has_else; short Choices[256]; int j, k, nr_else = 0; if (nproc <= nstop+1) { X = run; return NULL; } if (!interactive || depth < jumpsteps) { if (has_priority && !old_priority_rules) /* new 6.3.2 */ { j = Rand()%(nproc-nstop); for (X = run; X; X = X->nxt) { if (j-- <= 0) break; } if (X == NULL) { fatal("unexpected, pickproc", (char *)0); } j = nproc - nstop; while (j-- > 0) { if (x_can_run()) { Y = X; break; } X = (X->nxt)?X->nxt:run; } return Y; } if (Priority_Sum < nproc-nstop) fatal("cannot happen - weights", (char *)0); j = (int) Rand()%Priority_Sum; while (j - X->priority >= 0) { j -= X->priority; Y = X; X = X->nxt; if (!X) { Y = NULL; X = run; } } } else { int only_choice = -1; int no_choice = 0, proc_no_ch, proc_k; Tval = 0; /* new 4.2.6 */ try_again: printf("Select a statement\n"); try_more: for (X = run, k = 1; X; X = X->nxt) { if (X->pid > 255) break; Choices[X->pid] = (short) k; if (!X->pc || !x_can_run()) { if (X == run) Choices[X->pid] = 0; continue; } X->pc = silent_moves(X->pc); if (!X->pc->sub && X->pc->n) { int unex; unex = !Enabled0(X->pc); if (unex) no_choice++; else only_choice = k; if (!xspin && unex && !(verbose&32)) { k++; continue; } printf("\tchoice %d: ", k++); p_talk(X->pc, 0); if (unex) printf(" unexecutable,"); printf(" ["); comment(stdout, X->pc->n, 0); if (X->pc->esc) printf(" + Escape"); printf("]\n"); } else { has_else = ZE; proc_no_ch = no_choice; proc_k = k; for (z = X->pc->sub, j=0; z; z = z->nxt) { Element *y = silent_moves(z->this->frst); int unex; if (!y) continue; if (y->n->ntyp == ELSE) { has_else = (Rvous)?ZE:y; nr_else = k++; continue; } unex = !Enabled0(y); if (unex) no_choice++; else only_choice = k; if (!xspin && unex && !(verbose&32)) { k++; continue; } printf("\tchoice %d: ", k++); p_talk(X->pc, 0); if (unex) printf(" unexecutable,"); printf(" ["); comment(stdout, y->n, 0); printf("]\n"); } if (has_else) { if (no_choice-proc_no_ch >= (k-proc_k)-1) { only_choice = nr_else; printf("\tchoice %d: ", nr_else); p_talk(X->pc, 0); printf(" [else]\n"); } else { no_choice++; printf("\tchoice %d: ", nr_else); p_talk(X->pc, 0); printf(" unexecutable, [else]\n"); } } } } X = run; if (k - no_choice < 2 && Tval == 0) { Tval = 1; no_choice = 0; only_choice = -1; goto try_more; } if (xspin) printf("Make Selection %d\n\n", k-1); else { if (k - no_choice < 2) { printf("no executable choices\n"); alldone(0); } printf("Select [1-%d]: ", k-1); } if (!xspin && k - no_choice == 2) { printf("%d\n", only_choice); j = only_choice; } else { char buf[256]; fflush(stdout); if (scanf("%64s", buf) == 0) { printf("\tno input\n"); goto try_again; } j = -1; if (isdigit((int) buf[0])) j = atoi(buf); else { if (buf[0] == 'q') alldone(0); } if (j < 1 || j >= k) { printf("\tchoice is outside range\n"); goto try_again; } } MadeChoice = 0; Y = NULL; for (X = run; X; Y = X, X = X->nxt) { if (!X->nxt || X->nxt->pid > 255 || j < Choices[X->nxt->pid]) { MadeChoice = 1+j-Choices[X->pid]; break; } } } return Y; } void multi_claims(void) { ProcList *p, *q = NULL; if (nclaims > 1) { printf(" the model contains %d never claims:", nclaims); for (p = rdy; p; p = p->nxt) { if (p->b == N_CLAIM) { printf("%s%s", q?", ":" ", p->n->name); q = p; } } printf("\n"); printf(" only one claim is used in a verification run\n"); printf(" choose which one with ./pan -a -N name (defaults to -N %s)\n", q?q->n->name:"--"); printf(" or use e.g.: spin -search -ltl %s %s\n", q?q->n->name:"--", Fname?Fname->name:"filename"); } } void sched(void) { Element *e; RunList *Y = NULL; /* previous process in run queue */ RunList *oX; int go, notbeyond = 0; #ifdef PC int bufmax = 100; #endif if (dumptab) { formdump(); symdump(); dumplabels(); return; } if (has_code && !analyze) { printf("spin: warning: c_code fragments remain uninterpreted\n"); printf(" in random simulations with spin; use ./pan -r instead\n"); } if (has_enabled && u_sync > 0) { printf("spin: error, cannot use 'enabled()' in "); printf("models with synchronous channels.\n"); nr_errs++; } if (product) { sync_product(); alldone(0); } if (analyze && (!replay || has_code)) { gensrc(); multi_claims(); return; } if (replay && !has_code) { return; } if (s_trail) { match_trail(); return; } if (claimproc) printf("warning: never claim not used in random simulation\n"); if (eventmap) printf("warning: trace assertion not used in random simulation\n"); X = run; Y = pickproc(Y); while (X) { context = X->n; if (X->pc && X->pc->n) { lineno = X->pc->n->ln; Fname = X->pc->n->fn; } if (cutoff > 0 && depth >= cutoff) { printf("-------------\n"); printf("depth-limit (-u%d steps) reached\n", cutoff); break; } #ifdef PC if (xspin && !interactive && --bufmax <= 0) { int c; /* avoid buffer overflow on pc's */ printf("spin: type return to proceed\n"); fflush(stdout); c = getc(stdin); if (c == 'q') wrapup(0); bufmax = 100; } #endif depth++; LastStep = ZE; oX = X; /* a rendezvous could change it */ go = 1; if (X->pc && !(X->pc->status & D_ATOM) && !x_can_run()) { if (!xspin && ((verbose&32) || (verbose&4))) { p_talk(X->pc, 1); printf("\t<>\n"); } go = 0; } if (go && (e = eval_sub(X->pc))) { if (depth >= jumpsteps && ((verbose&32) || (verbose&4))) { if (X == oX) if (!(e->status & D_ATOM) || (verbose&32)) /* no talking in d_steps */ { if (!LastStep) LastStep = X->pc; /* A. Tanaka, changed order */ p_talk(LastStep, 1); printf(" ["); comment(stdout, LastStep->n, 0); printf("]\n"); } if (verbose&1) dumpglobals(); if (verbose&2) dumplocal(X); if (!(e->status & D_ATOM)) if (xspin) printf("\n"); } if (oX != X || (X->pc->status & (ATOM|D_ATOM))) /* new 5.0 */ { e = silent_moves(e); notbeyond = 0; } oX->pc = e; LastX = X; if (!interactive) Tval = 0; memset(is_blocked, 0, 256); if (X->pc && (X->pc->status & (ATOM|L_ATOM)) && (notbeyond == 0 || oX != X)) { if ((X->pc->status & L_ATOM)) notbeyond = 1; continue; /* no process switch */ } } else { depth--; if (oX->pc && (oX->pc->status & D_ATOM)) { non_fatal("stmnt in d_step blocks", (char *)0); } if (X->pc && X->pc->n && X->pc->n->ntyp == '@' && X->pid == (nproc-nstop-1)) { if (X != run && Y != NULL) Y->nxt = X->nxt; else run = X->nxt; nstop++; Priority_Sum -= X->priority; if (verbose&4) { whoruns(1); dotag(stdout, "terminates\n"); } LastX = X; if (!interactive) Tval = 0; if (nproc == nstop) break; memset(is_blocked, 0, 256); /* proc X is no longer in runlist */ X = (X->nxt) ? X->nxt : run; } else { if (p_blocked(X->pid)) { if (Tval && !has_stdin) { break; } if (!Tval && depth >= jumpsteps) { oX = X; X = (RunList *) 0; /* to suppress indent */ dotag(stdout, "timeout\n"); X = oX; Tval = 1; } } } } if (!run || !X) break; /* new 5.0 */ Y = pickproc(X); notbeyond = 0; } context = ZS; wrapup(0); } int complete_rendez(void) { RunList *orun = X, *tmp; Element *s_was = LastStep; Element *e; int j, ointer = interactive; if (s_trail) return 1; if (orun->pc->status & D_ATOM) fatal("rv-attempt in d_step sequence", (char *)0); Rvous = 1; interactive = 0; j = (int) Rand()%Priority_Sum; /* randomize start point */ X = run; while (j - X->priority >= 0) { j -= X->priority; X = X->nxt; if (!X) X = run; } for (j = nproc - nstop; j > 0; j--) { if (X != orun && (!X->prov || eval(X->prov)) && (e = eval_sub(X->pc))) { if (TstOnly) { X = orun; Rvous = 0; goto out; } if ((verbose&32) || (verbose&4)) { tmp = orun; orun = X; X = tmp; if (!s_was) s_was = X->pc; p_talk(s_was, 1); printf(" ["); comment(stdout, s_was->n, 0); printf("]\n"); tmp = orun; /* orun = X; */ X = tmp; if (!LastStep) LastStep = X->pc; p_talk(LastStep, 1); printf(" ["); comment(stdout, LastStep->n, 0); printf("]\n"); } Rvous = 0; /* before silent_moves */ X->pc = silent_moves(e); out: interactive = ointer; return 1; } X = X->nxt; if (!X) X = run; } Rvous = 0; X = orun; interactive = ointer; return 0; } /***** Runtime - Local Variables *****/ static void addsymbol(RunList *r, Symbol *s) { Symbol *t; int i; for (t = r->symtab; t; t = t->next) if (strcmp(t->name, s->name) == 0 && (old_scope_rules || strcmp((const char *)t->bscp, (const char *)s->bscp) == 0)) return; /* it's already there */ t = (Symbol *) emalloc(sizeof(Symbol)); t->name = s->name; t->type = s->type; t->hidden = s->hidden; t->isarray = s->isarray; t->nbits = s->nbits; t->nel = s->nel; t->ini = s->ini; t->setat = depth; t->context = r->n; t->bscp = (unsigned char *) emalloc(strlen((const char *)s->bscp)+1); strcpy((char *)t->bscp, (const char *)s->bscp); if (s->type != STRUCT) { if (s->val) /* if already initialized, copy info */ { t->val = (int *) emalloc(s->nel*sizeof(int)); for (i = 0; i < s->nel; i++) t->val[i] = s->val[i]; } else { (void) checkvar(t, 0); /* initialize it */ } } else { if (s->Sval) fatal("saw preinitialized struct %s", s->name); t->Slst = s->Slst; t->Snm = s->Snm; t->owner = s->owner; /* t->context = r->n; */ } t->next = r->symtab; /* add it */ r->symtab = t; } static void setlocals(RunList *r) { Ordered *walk; Symbol *sp; RunList *oX = X; X = r; for (walk = all_names; walk; walk = walk->next) { sp = walk->entry; if (sp && sp->context && strcmp(sp->context->name, r->n->name) == 0 && sp->Nid >= 0 && (sp->type == UNSIGNED || sp->type == BIT || sp->type == MTYPE || sp->type == BYTE || sp->type == CHAN || sp->type == SHORT || sp->type == INT || sp->type == STRUCT)) { if (!findloc(sp)) non_fatal("setlocals: cannot happen '%s'", sp->name); } } X = oX; } static void oneparam(RunList *r, Lextok *t, Lextok *a, ProcList *p) { int k; int at, ft; RunList *oX = X; if (!a) fatal("missing actual parameters: '%s'", p->n->name); if (t->sym->nel > 1 || t->sym->isarray) fatal("array in parameter list, %s", t->sym->name); k = eval(a->lft); at = Sym_typ(a->lft); X = r; /* switch context */ ft = Sym_typ(t); if (at != ft && (at == CHAN || ft == CHAN)) { char buf[256], tag1[64], tag2[64]; (void) sputtype(tag1, ft); (void) sputtype(tag2, at); sprintf(buf, "type-clash in params of %s(..), (%s<-> %s)", p->n->name, tag1, tag2); non_fatal("%s", buf); } t->ntyp = NAME; addsymbol(r, t->sym); (void) setval(t, k); X = oX; } static void setparams(RunList *r, ProcList *p, Lextok *q) { Lextok *f, *a; /* formal and actual pars */ Lextok *t; /* list of pars of 1 type */ if (q) { lineno = q->ln; Fname = q->fn; } for (f = p->p, a = q; f; f = f->rgt) /* one type at a time */ for (t = f->lft; t; t = t->rgt, a = (a)?a->rgt:a) { if (t->ntyp != ',') oneparam(r, t, a, p); /* plain var */ else oneparam(r, t->lft, a, p); /* expanded struct */ } } Symbol * findloc(Symbol *s) { Symbol *r; if (!X) { /* fatal("error, cannot eval '%s' (no proc)", s->name); */ return ZS; } for (r = X->symtab; r; r = r->next) { if (strcmp(r->name, s->name) == 0 && (old_scope_rules || strcmp((const char *)r->bscp, (const char *)s->bscp) == 0)) { break; } } if (!r) { addsymbol(X, s); r = X->symtab; } return r; } int in_bound(Symbol *r, int n) { if (!r) return 0; if (n >= r->nel || n < 0) { printf("spin: indexing %s[%d] - size is %d\n", r->name, n, r->nel); non_fatal("indexing array \'%s\'", r->name); return 0; } return 1; } int getlocal(Lextok *sn) { Symbol *r, *s = sn->sym; int n = eval(sn->lft); r = findloc(s); if (r && r->type == STRUCT) return Rval_struct(sn, r, 1); /* 1 = check init */ if (in_bound(r, n)) return cast_val(r->type, r->val[n], r->nbits); return 0; } int setlocal(Lextok *p, int m) { Symbol *r = findloc(p->sym); int n = eval(p->lft); if (in_bound(r, n)) { if (r->type == STRUCT) (void) Lval_struct(p, r, 1, m); /* 1 = check init */ else { #if 0 if (r->nbits > 0) m = (m & ((1<nbits)-1)); r->val[n] = m; #else r->val[n] = cast_val(r->type, m, r->nbits); #endif r->setat = depth; } } return 1; } void whoruns(int lnr) { if (!X) return; if (lnr) printf("%3d: ", depth); printf("proc "); if (Have_claim && X->pid == 0) printf(" -"); else printf("%2d", X->pid - Have_claim); if (old_priority_rules) { printf(" (%s) ", X->n->name); } else { printf(" (%s:%d) ", X->n->name, X->priority); } } static void talk(RunList *r) { if ((verbose&32) || (verbose&4)) { p_talk(r->pc, 1); printf("\n"); if (verbose&1) dumpglobals(); if (verbose&2) dumplocal(r); } } void p_talk(Element *e, int lnr) { static int lastnever = -1; static char nbuf[128]; int newnever = -1; if (e && e->n) newnever = e->n->ln; if (Have_claim && X && X->pid == 0 && lastnever != newnever && e) { if (xspin) { printf("MSC: ~G line %d\n", newnever); #if 0 printf("%3d: proc - (NEVER) line %d \"never\" ", depth, newnever); printf("(state 0)\t[printf('MSC: never\\\\n')]\n"); } else { printf("%3d: proc - (NEVER) line %d \"never\"\n", depth, newnever); #endif } lastnever = newnever; } whoruns(lnr); if (e) { if (e->n) { char *ptr = e->n->fn->name; char *qtr = nbuf; while (*ptr != '\0') { if (*ptr != '"') { *qtr++ = *ptr; } ptr++; } *qtr = '\0'; } else { strcpy(nbuf, "-"); } printf("%s:%d (state %d)", nbuf, e->n?e->n->ln:-1, e->seqno); if (!xspin && ((e->status&ENDSTATE) || has_lab(e, 2))) /* 2=end */ { printf(" "); } } } int remotelab(Lextok *n) { int i; lineno = n->ln; Fname = n->fn; if (n->sym->type != 0 && n->sym->type != LABEL) { printf("spin: error, type: %d\n", n->sym->type); fatal("not a labelname: '%s'", n->sym->name); } if (n->indstep >= 0) { fatal("remote ref to label '%s' inside d_step", n->sym->name); } if ((i = find_lab(n->sym, n->lft->sym, 1)) == 0) /* remotelab */ { fatal("unknown labelname: %s", n->sym->name); } return i; } int remotevar(Lextok *n) { int prno, i, added=0; RunList *Y, *oX; Lextok *onl; Symbol *os; lineno = n->ln; Fname = n->fn; if (!n->lft->lft) prno = f_pid(n->lft->sym->name); else { prno = eval(n->lft->lft); /* pid - can cause recursive call */ #if 0 if (n->lft->lft->ntyp == CONST) /* user-guessed pid */ #endif { prno += Have_claim; added = Have_claim; } } if (prno < 0) { return 0; /* non-existing process */ } #if 0 i = nproc - nstop; for (Y = run; Y; Y = Y->nxt) { --i; printf(" %s: i=%d, prno=%d, ->pid=%d\n", Y->n->name, i, prno, Y->pid); } #endif i = nproc - nstop + Skip_claim; /* 6.0: added Skip_claim */ for (Y = run; Y; Y = Y->nxt) if (--i == prno) { if (strcmp(Y->n->name, n->lft->sym->name) != 0) { printf("spin: remote reference error on '%s[%d]'\n", n->lft->sym->name, prno-added); non_fatal("refers to wrong proctype '%s'", Y->n->name); } if (strcmp(n->sym->name, "_p") == 0) { if (Y->pc) { return Y->pc->seqno; } /* harmless, can only happen with -t */ return 0; } /* check remote variables */ oX = X; X = Y; onl = n->lft; n->lft = n->rgt; os = n->sym; if (!n->sym->context) { n->sym->context = Y->n; } { int rs = old_scope_rules; old_scope_rules = 1; /* 6.4.0 */ n->sym = findloc(n->sym); old_scope_rules = rs; } i = getval(n); n->sym = os; n->lft = onl; X = oX; return i; } printf("remote ref: %s[%d] ", n->lft->sym->name, prno-added); non_fatal("%s not found", n->sym->name); printf("have only:\n"); i = nproc - nstop - 1; for (Y = run; Y; Y = Y->nxt, i--) if (!strcmp(Y->n->name, n->lft->sym->name)) printf("\t%d\t%s\n", i, Y->n->name); return 0; } Spin/Src6.4.5/guided.c0000664000175100017510000002177312641605057012320 0ustar ghgh/***** spin: guided.c *****/ /* * This file is part of the public release of Spin. It is subject to the * terms in the LICENSE file that is included in this source directory. * Tool documentation is available at http://spinroot.com */ #include "spin.h" #include #include #include #include "y.tab.h" extern RunList *run, *X; extern Element *Al_El; extern Symbol *Fname, *oFname; extern int verbose, lineno, xspin, jumpsteps, depth, merger, cutoff; extern int nproc, nstop, Tval, ntrail, columns; extern short Have_claim, Skip_claim, has_code; extern void ana_src(int, int); extern char **trailfilename; int TstOnly = 0, pno; static int lastclaim = -1; static FILE *fd; static void lost_trail(void); static void whichproc(int p) { RunList *oX; for (oX = run; oX; oX = oX->nxt) if (oX->pid == p) { printf("(%s) ", oX->n->name); break; } } static int newer(char *f1, char *f2) { #if defined(WIN32) || defined(WIN64) struct _stat x, y; #else struct stat x, y; #endif if (stat(f1, (struct stat *)&x) < 0) return 0; if (stat(f2, (struct stat *)&y) < 0) return 1; if (x.st_mtime < y.st_mtime) return 0; return 1; } void hookup(void) { Element *e; for (e = Al_El; e; e = e->Nxt) if (e->n && (e->n->ntyp == ATOMIC || e->n->ntyp == NON_ATOMIC || e->n->ntyp == D_STEP)) (void) huntstart(e); } int not_claim(void) { return (!Have_claim || !X || X->pid != 0); } int globmin = INT_MAX; int globmax = 0; int find_min(Sequence *s) { SeqList *l; Element *e; if (s->minel < 0) { s->minel = INT_MAX; for (e = s->frst; e; e = e->nxt) { if (e->status & 512) { continue; } e->status |= 512; if (e->n->ntyp == ATOMIC || e->n->ntyp == NON_ATOMIC || e->n->ntyp == D_STEP) { int n = find_min(e->n->sl->this); if (n < s->minel) { s->minel = n; } } else if (e->Seqno < s->minel) { s->minel = e->Seqno; } for (l = e->sub; l; l = l->nxt) { int n = find_min(l->this); if (n < s->minel) { s->minel = n; } } } } if (s->minel < globmin) { globmin = s->minel; } return s->minel; } int find_max(Sequence *s) { if (s->last->Seqno > globmax) { globmax = s->last->Seqno; } return s->last->Seqno; } void match_trail(void) { int i, a, nst; Element *dothis; char snap[512], *q; if (has_code) { printf("spin: important:\n"); printf(" =======================================warning====\n"); printf(" this model contains embedded c code statements\n"); printf(" these statements will not be executed when the trail\n"); printf(" is replayed in this way -- they are just printed,\n"); printf(" which will likely lead to inaccurate variable values.\n"); printf(" for an accurate replay use: ./pan -r\n"); printf(" =======================================warning====\n\n"); } /* * if source model name is leader.pml * look for the trail file under these names: * leader.pml.trail * leader.pml.tra * leader.trail * leader.tra */ if (trailfilename) { if (strlen(*trailfilename) < sizeof(snap)) { strcpy(snap, (const char *) *trailfilename); } else { fatal("filename %s too long", *trailfilename); } } else { if (ntrail) sprintf(snap, "%s%d.trail", oFname->name, ntrail); else sprintf(snap, "%s.trail", oFname->name); } if ((fd = fopen(snap, "r")) == NULL) { snap[strlen(snap)-2] = '\0'; /* .tra */ if ((fd = fopen(snap, "r")) == NULL) { if ((q = strchr(oFname->name, '.')) != NULL) { *q = '\0'; if (ntrail) sprintf(snap, "%s%d.trail", oFname->name, ntrail); else sprintf(snap, "%s.trail", oFname->name); *q = '.'; if ((fd = fopen(snap, "r")) != NULL) goto okay; snap[strlen(snap)-2] = '\0'; /* last try */ if ((fd = fopen(snap, "r")) != NULL) goto okay; } printf("spin: cannot find trail file\n"); alldone(1); } } okay: if (xspin == 0 && newer(oFname->name, snap)) { printf("spin: warning, \"%s\" is newer than %s\n", oFname->name, snap); } Tval = 1; /* * sets Tval because timeouts may be part of trail * this used to also set m_loss to 1, but that is * better handled with the runtime -m flag */ hookup(); while (fscanf(fd, "%d:%d:%d\n", &depth, &pno, &nst) == 3) { if (depth == -2) { if (verbose) { printf("starting claim %d\n", pno); } start_claim(pno); continue; } if (depth == -4) { if (verbose) { printf("using statement merging\n"); } merger = 1; ana_src(0, 1); continue; } if (depth == -1) { if (1 || verbose) { if (columns == 2) dotag(stdout, " CYCLE>\n"); else dotag(stdout, "<<<<>>>>\n"); } continue; } if (cutoff > 0 && depth >= cutoff) { printf("-------------\n"); printf("depth-limit (-u%d steps) reached\n", cutoff); break; } if (Skip_claim && pno == 0) continue; for (dothis = Al_El; dothis; dothis = dothis->Nxt) { if (dothis->Seqno == nst) break; } if (!dothis) { printf("%3d: proc %d, no matching stmnt %d\n", depth, pno - Have_claim, nst); lost_trail(); } i = nproc - nstop + Skip_claim; if (dothis->n->ntyp == '@') { if (pno == i-1) { run = run->nxt; nstop++; if (verbose&4) { if (columns == 2) { dotag(stdout, "\n"); continue; } if (Have_claim && pno == 0) printf("%3d: claim terminates\n", depth); else printf("%3d: proc %d terminates\n", depth, pno - Have_claim); } continue; } if (pno <= 1) continue; /* init dies before never */ printf("%3d: stop error, ", depth); printf("proc %d (i=%d) trans %d, %c\n", pno - Have_claim, i, nst, dothis->n->ntyp); lost_trail(); } if (0 && !xspin && (verbose&32)) { printf("step %d i=%d pno %d stmnt %d\n", depth, i, pno, nst); } for (X = run; X; X = X->nxt) { if (--i == pno) break; } if (!X) { if (verbose&32) { printf("%3d: no process %d (stmnt %d)\n", depth, pno - Have_claim, nst); printf(" max %d (%d - %d + %d) claim %d ", nproc - nstop + Skip_claim, nproc, nstop, Skip_claim, Have_claim); printf("active processes:\n"); for (X = run; X; X = X->nxt) { printf("\tpid %d\tproctype %s\n", X->pid, X->n->name); } printf("\n"); continue; } else { printf("%3d:\tproc %d (?) ", depth, pno); lost_trail(); } } else { int min_seq = find_min(X->ps); int max_seq = find_max(X->ps); if (nst < min_seq || nst > max_seq) { printf("%3d: error: invalid statement", depth); if (verbose&32) { printf(": pid %d:%d (%s:%d:%d) stmnt %d (valid range %d .. %d)", pno, X->pid, X->n->name, X->tn, X->b, nst, min_seq, max_seq); } printf("\n"); continue; /* lost_trail(); */ } X->pc = dothis; } lineno = dothis->n->ln; Fname = dothis->n->fn; if (dothis->n->ntyp == D_STEP) { Element *g, *og = dothis; do { g = eval_sub(og); if (g && depth >= jumpsteps && ((verbose&32) || ((verbose&4) && not_claim()))) { if (columns != 2) { p_talk(og, 1); if (og->n->ntyp == D_STEP) og = og->n->sl->this->frst; printf("\t["); comment(stdout, og->n, 0); printf("]\n"); } if (verbose&1) dumpglobals(); if (verbose&2) dumplocal(X); if (xspin) printf("\n"); } og = g; } while (g && g != dothis->nxt); if (X != NULL) { X->pc = g?huntele(g, 0, -1):g; } } else { keepgoing: if (dothis->merge_start) a = dothis->merge_start; else a = dothis->merge; if (X != NULL) { X->pc = eval_sub(dothis); if (X->pc) X->pc = huntele(X->pc, 0, a); } if (depth >= jumpsteps && ((verbose&32) || ((verbose&4) && not_claim()))) /* -v or -p */ { if (columns != 2) { p_talk(dothis, 1); if (dothis->n->ntyp == D_STEP) dothis = dothis->n->sl->this->frst; printf("\t["); comment(stdout, dothis->n, 0); printf("]"); if (a && (verbose&32)) printf("\t", dothis->merge, (X && X->pc)?X->pc->seqno:-1); printf("\n"); } if (verbose&1) dumpglobals(); if (verbose&2) dumplocal(X); if (xspin) printf("\n"); if (X && !X->pc) { X->pc = dothis; printf("\ttransition failed\n"); a = 0; /* avoid inf loop */ } } if (a && X && X->pc && X->pc->seqno != a) { dothis = X->pc; goto keepgoing; } } if (Have_claim && X && X->pid == 0 && dothis->n && lastclaim != dothis->n->ln) { lastclaim = dothis->n->ln; if (columns == 2) { char t[128]; sprintf(t, "#%d", lastclaim); pstext(0, t); } else { printf("Never claim moves to line %d\t[", lastclaim); comment(stdout, dothis->n, 0); printf("]\n"); } } } printf("spin: trail ends after %d steps\n", depth); wrapup(0); } static void lost_trail(void) { int d, p, n, l; while (fscanf(fd, "%d:%d:%d:%d\n", &d, &p, &n, &l) == 4) { printf("step %d: proc %d ", d, p); whichproc(p); printf("(state %d) - d %d\n", n, l); } wrapup(1); /* no return */ } int pc_value(Lextok *n) { int i = nproc - nstop; int pid = eval(n); RunList *Y; for (Y = run; Y; Y = Y->nxt) { if (--i == pid) return Y->pc->seqno; } return 0; } Spin/Src6.4.5/pangen7.c0000664000175100017510000004432112641605057012410 0ustar ghgh/***** spin: pangen7.c *****/ /* * This file is part of the public release of Spin. It is subject to the * terms in the LICENSE file that is included in this source directory. * Tool documentation is available at http://spinroot.com */ #include #include #include "spin.h" #include "y.tab.h" #include #ifndef PC #include #endif extern ProcList *rdy; extern Element *Al_El; extern int nclaims, verbose, Strict; extern short has_accept; typedef struct Succ_List Succ_List; typedef struct SQueue SQueue; typedef struct OneState OneState; typedef struct State_Stack State_Stack; typedef struct Guard Guard; struct Succ_List { SQueue *s; Succ_List *nxt; }; struct OneState { int *combo; /* the combination of claim states */ Succ_List *succ; /* list of ptrs to immediate successor states */ }; struct SQueue { OneState state; SQueue *nxt; }; struct State_Stack { int *n; State_Stack *nxt; }; struct Guard { Lextok *t; Guard *nxt; }; static SQueue *sq, *sd, *render; /* states move from sq to sd to render to holding */ static SQueue *holding, *lasthold; static State_Stack *dsts; static int nst; /* max nr of states in claims */ static int *Ist; /* initial states */ static int *Nacc; /* number of accept states in claim */ static int *Nst; /* next states */ static int **reached; /* n claims x states */ static int unfolding; /* to make sure all accept states are reached */ static int is_accept; /* remember if the current state is accepting in any claim */ static int not_printing; /* set during explore_product */ static Element ****matrix; /* n x two-dimensional arrays state x state */ static Element **Selfs; /* self-loop states at end of claims */ static void get_seq(int, Sequence *); static void set_el(int n, Element *e); static void gen_product(void); static void print_state_nm(char *, int *, char *); static SQueue *find_state(int *); static SQueue *retrieve_state(int *); static int same_state(int *a, int *b) { int i; for (i = 0; i < nclaims; i++) { if (a[i] != b[i]) { return 0; } } return 1; } static int in_stack(SQueue *s, SQueue *in) { SQueue *q; for (q = in; q; q = q->nxt) { if (same_state(q->state.combo, s->state.combo)) { return 1; } } return 0; } static void to_render(SQueue *s) { SQueue *a, *q, *last; /* find in sd/sq and move to render, if not already there */ int n; for (n = 0; n < nclaims; n++) { reached[n][ s->state.combo[n] ] |= 2; } for (q = render; q; q = q->nxt) { if (same_state(q->state.combo, s->state.combo)) { return; } } for (q = holding; q; q = q->nxt) { if (same_state(q->state.combo, s->state.combo)) { return; } } a = sd; more: for (q = a, last = 0; q; last = q, q = q->nxt) { if (same_state(q->state.combo, s->state.combo)) { if (!last) { if (a == sd) { sd = q->nxt; } else if (a == sq) { sq = q->nxt; } else { holding = q->nxt; } } else { last->nxt = q->nxt; } q->nxt = render; render = q; return; } } if (verbose) { print_state_nm("looking for: ", s->state.combo, "\n"); } (void) find_state(s->state.combo); /* creates it in sq */ if (a != sq) { a = sq; goto more; } fatal("cannot happen, to_render", 0); } static void wrap_text(char *pre, Lextok *t, char *post) { printf(pre, (char *) 0); comment(stdout, t, 0); printf(post, (char *) 0); } static State_Stack * push_dsts(int *n) { State_Stack *s; int i; for (s = dsts; s; s = s->nxt) { if (same_state(s->n, n)) { if (verbose&64) { printf("\n"); for (s = dsts; s; s = s->nxt) { print_state_nm("\t", s->n, "\n"); } print_state_nm("\t", n, "\n"); } return s; } } s = (State_Stack *) emalloc(sizeof(State_Stack)); s->n = (int *) emalloc(nclaims * sizeof(int)); for (i = 0; i < nclaims; i++) s->n[i] = n[i]; s->nxt = dsts; dsts = s; return 0; } static void pop_dsts(void) { assert(dsts != NULL); dsts = dsts->nxt; } static void complete_transition(Succ_List *sl, Guard *g) { Guard *w; int cnt = 0; printf(" :: "); for (w = g; w; w = w->nxt) { if (w->t->ntyp == CONST && w->t->val == 1) { continue; } else if (w->t->ntyp == 'c' && w->t->lft->ntyp == CONST && w->t->lft->val == 1) { continue; /* 'true' */ } if (cnt > 0) { printf(" && "); } wrap_text("", w->t, ""); cnt++; } if (cnt == 0) { printf("true"); } print_state_nm(" -> goto ", sl->s->state.combo, ""); if (is_accept > 0) { printf("_U%d\n", (unfolding+1)%nclaims); } else { printf("_U%d\n", unfolding); } } static void state_body(OneState *s, Guard *guard) { Succ_List *sl; State_Stack *y; Guard *g; int i, once; for (sl = s->succ; sl; sl = sl->nxt) { once = 0; for (i = 0; i < nclaims; i++) { Element *e; e = matrix[i][s->combo[i]][sl->s->state.combo[i]]; /* if one of the claims has a DO or IF move then pull its target state forward, once */ if (!e || e->n->ntyp == NON_ATOMIC || e->n->ntyp == DO || e->n->ntyp == IF) { s = &(sl->s->state); y = push_dsts(s->combo); if (!y) { if (once++ == 0) { assert(s->succ != NULL); state_body(s, guard); } pop_dsts(); } else if (!y->nxt) /* self-loop transition */ { if (!not_printing) printf(" /* self-loop */\n"); } else { /* non_fatal("loop in state body", 0); ** maybe ok */ } continue; } else { g = (Guard *) emalloc(sizeof(Guard)); g->t = e->n; g->nxt = guard; guard = g; } } if (guard && !once) { if (!not_printing) complete_transition(sl, guard); to_render(sl->s); } } } static struct X { char *s; int n; } spl[] = { {"end", 3 }, {"accept", 6 }, {0, 0 }, }; static int slcnt; extern Label *labtab; static ProcList * locate_claim(int n) { ProcList *p; int i; for (p = rdy, i = 0; p; p = p->nxt, i++) /* find claim name */ { if (i == n) { break; } } assert(p && p->b == N_CLAIM); return p; } static void elim_lab(Element *e) { Label *l, *lst; for (l = labtab, lst = NULL; l; lst = l, l = l->nxt) { if (l->e == e) { if (lst) { lst->nxt = l->nxt; } else { labtab = l->nxt; } break; } } } static int claim_has_accept(ProcList *p) { Label *l; for (l = labtab; l; l = l->nxt) { if (strcmp(l->c->name, p->n->name) == 0 && strncmp(l->s->name, "accept", 6) == 0) { return 1; } } return 0; } static void prune_accept(void) { int n; for (n = 0; n < nclaims; n++) { if ((reached[n][Selfs[n]->seqno] & 2) == 0) { if (verbose) { printf("claim %d: selfloop not reachable\n", n); } elim_lab(Selfs[n]); Nacc[n] = claim_has_accept(locate_claim(n)); } } } static void mk_accepting(int n, Element *e) { ProcList *p; Label *l; int i; assert(!Selfs[n]); Selfs[n] = e; l = (Label *) emalloc(sizeof(Label)); l->s = (Symbol *) emalloc(sizeof(Symbol)); l->s->name = "accept00"; l->c = (Symbol *) emalloc(sizeof(Symbol)); l->uiid = 0; /* this is not in an inline */ for (p = rdy, i = 0; p; p = p->nxt, i++) /* find claim name */ { if (i == n) { l->c->name = p->n->name; break; } } assert(p && p->b == N_CLAIM); Nacc[n] = 1; has_accept = 1; l->e = e; l->nxt = labtab; labtab = l; } static void check_special(int *nrs) { ProcList *p; Label *l; int i, j, nmatches; int any_accepts = 0; for (i = 0; i < nclaims; i++) { any_accepts += Nacc[i]; } is_accept = 0; for (j = 0; spl[j].n; j++) /* 2 special label prefixes */ { nmatches = 0; for (p = rdy, i = 0; p; p = p->nxt, i++) /* check each claim */ { if (p->b != N_CLAIM) { continue; } /* claim i in state nrs[i], type p->tn, name p->n->name * either the state has an accept label, or the claim has none, * so that all its states should be considered accepting * --- but only if other claims do have accept states! */ if (Strict == 0 && j == 1 && Nacc[i] == 0 && any_accepts > 0) { if ((verbose&32) && i == unfolding) { printf(" /* claim %d pseudo-accept */\n", i); } goto is_accepting; } for (l = labtab; l; l = l->nxt) /* check its labels */ { if (strcmp(l->c->name, p->n->name) == 0 /* right claim */ && l->e->seqno == nrs[i] /* right state */ && strncmp(l->s->name, spl[j].s, spl[j].n) == 0) { if (j == 1) /* accept state */ { char buf[32]; is_accepting: if (strchr(p->n->name, ':')) { sprintf(buf, "N%d", i); } else { assert(strlen(p->n->name) < sizeof(buf)); strcpy(buf, p->n->name); } if (unfolding == 0 && i == 0) { if (!not_printing) printf("%s_%s_%d:\n", /* true accept */ spl[j].s, buf, slcnt++); } else if (verbose&32) { if (!not_printing) printf("%s_%s%d:\n", buf, spl[j].s, slcnt++); } if (i == unfolding) { is_accept++; /* move to next unfolding */ } } else { nmatches++; } break; } } } if (j == 0 && nmatches == nclaims) /* end-state */ { if (!not_printing) { printf("%s%d:\n", spl[j].s, slcnt++); } } } } static int render_state(SQueue *q) { if (!q || !q->state.succ) { if (verbose&64) { printf(" no exit\n"); } return 0; } check_special(q->state.combo); /* accept or end-state labels */ dsts = (State_Stack *) 0; push_dsts(q->state.combo); /* to detect loops */ if (!not_printing) { print_state_nm("", q->state.combo, ""); /* the name */ printf("_U%d:\n\tdo\n", unfolding); } state_body(&(q->state), (Guard *) 0); if (!not_printing) { printf("\tod;\n"); } pop_dsts(); return 1; } static void explore_product(void) { SQueue *q; /* all states are in the sd queue */ q = retrieve_state(Ist); /* retrieve from the sd q */ q->nxt = render; /* put in render q */ render = q; do { q = render; render = render->nxt; q->nxt = 0; /* remove from render q */ if (verbose&64) { print_state_nm("explore: ", q->state.combo, "\n"); } not_printing = 1; render_state(q); /* may add new states */ not_printing = 0; if (lasthold) { lasthold->nxt = q; lasthold = q; } else { holding = lasthold = q; } } while (render); assert(!dsts); } static void print_product(void) { SQueue *q; int cnt; if (unfolding == 0) { printf("never Product {\n"); /* name expected by iSpin */ q = find_state(Ist); /* should find it in the holding q */ assert(q != NULL); q->nxt = holding; /* put it at the front */ holding = q; } render = holding; holding = lasthold = 0; printf("/* ============= U%d ============= */\n", unfolding); cnt = 0; do { q = render; render = render->nxt; q->nxt = 0; if (verbose&64) { print_state_nm("print: ", q->state.combo, "\n"); } cnt += render_state(q); if (lasthold) { lasthold->nxt = q; lasthold = q; } else { holding = lasthold = q; } } while (render); assert(!dsts); if (cnt == 0) { printf(" 0;\n"); } if (unfolding == nclaims-1) { printf("}\n"); } } static void prune_dead(void) { Succ_List *sl, *last; SQueue *q; int cnt; do { cnt = 0; for (q = sd; q; q = q->nxt) { /* if successor is deadend, remove it * unless it's a move to the end-state of the claim */ last = (Succ_List *) 0; for (sl = q->state.succ; sl; last = sl, sl = sl->nxt) { if (!sl->s->state.succ) /* no successor */ { if (!last) { q->state.succ = sl->nxt; } else { last->nxt = sl->nxt; } cnt++; } } } } while (cnt > 0); } static void print_raw(void) { int i, j, n; printf("#if 0\n"); for (n = 0; n < nclaims; n++) { printf("C%d:\n", n); for (i = 0; i < nst; i++) { if (reached[n][i]) for (j = 0; j < nst; j++) { if (matrix[n][i][j]) { if (reached[n][i] & 2) printf("+"); if (i == Ist[n]) printf("*"); printf("\t%d", i); wrap_text(" -[", matrix[n][i][j]->n, "]->\t"); printf("%d\n", j); } } } } printf("#endif\n\n"); fflush(stdout); } void sync_product(void) { ProcList *p; Element *e; int n, i; if (nclaims <= 1) return; (void) unlink("pan.pre"); Ist = (int *) emalloc(sizeof(int) * nclaims); Nacc = (int *) emalloc(sizeof(int) * nclaims); Nst = (int *) emalloc(sizeof(int) * nclaims); reached = (int **) emalloc(sizeof(int *) * nclaims); Selfs = (Element **) emalloc(sizeof(Element *) * nclaims); matrix = (Element ****) emalloc(sizeof(Element ***) * nclaims); /* claims */ for (p = rdy, i = 0; p; p = p->nxt, i++) { if (p->b == N_CLAIM) { nst = max(p->s->maxel, nst); Nacc[i] = claim_has_accept(p); } } for (n = 0; n < nclaims; n++) { reached[n] = (int *) emalloc(sizeof(int) * nst); matrix[n] = (Element ***) emalloc(sizeof(Element **) * nst); /* rows */ for (i = 0; i < nst; i++) /* cols */ { matrix[n][i] = (Element **) emalloc(sizeof(Element *) * nst); } } for (e = Al_El; e; e = e->Nxt) { e->status &= ~DONE; } for (p = rdy, n=0; p; p = p->nxt, n++) { if (p->b == N_CLAIM) { /* fill in matrix[n] */ e = p->s->frst; Ist[n] = huntele(e, e->status, -1)->seqno; reached[n][Ist[n]] = 1|2; get_seq(n, p->s); } } if (verbose) /* show only the input automata */ { print_raw(); } gen_product(); /* create product automaton */ } static int nxt_trans(int n, int cs, int frst) { int j; for (j = frst; j < nst; j++) { if (reached[n][cs] && matrix[n][cs][j]) { return j; } } return -1; } static void print_state_nm(char *p, int *s, char *a) { int i; printf("%sP", p); for (i = 0; i < nclaims; i++) { printf("_%d", s[i]); } printf("%s", a); } static void create_transition(OneState *s, SQueue *it) { int n, from, upto; int *F = s->combo; int *T = it->state.combo; Succ_List *sl; Lextok *t; if (verbose&64) { print_state_nm("", F, " "); print_state_nm("-> ", T, "\t"); } /* check if any of the claims is blocked */ /* which makes the state a dead-end */ for (n = 0; n < nclaims; n++) { from = F[n]; upto = T[n]; t = matrix[n][from][upto]->n; if (verbose&64) { wrap_text("", t, " "); } if (t->ntyp == 'c' && t->lft->ntyp == CONST) { if (t->lft->val == 0) /* i.e., false */ { goto done; } } } sl = (Succ_List *) emalloc(sizeof(Succ_List)); sl->s = it; sl->nxt = s->succ; s->succ = sl; done: if (verbose&64) { printf("\n"); } } static SQueue * find_state(int *cs) { SQueue *nq, *a = sq; int i; again: /* check in nq, sq, and then in the render q */ for (nq = a; nq; nq = nq->nxt) { if (same_state(nq->state.combo, cs)) { return nq; /* found */ } } if (a == sq && sd) { a = sd; goto again; /* check the other stack too */ } else if (a == sd && render) { a = render; goto again; } nq = (SQueue *) emalloc(sizeof(SQueue)); nq->state.combo = (int *) emalloc(nclaims * sizeof(int)); for (i = 0; i < nclaims; i++) { nq->state.combo[i] = cs[i]; } nq->nxt = sq; /* add to sq stack */ sq = nq; return nq; } static SQueue * retrieve_state(int *s) { SQueue *nq, *last = NULL; for (nq = sd; nq; last = nq, nq = nq->nxt) { if (same_state(nq->state.combo, s)) { if (last) { last->nxt = nq->nxt; } else { sd = nq->nxt; /* 6.4.0: was sd = nq */ } return nq; /* found */ } } fatal("cannot happen: retrieve_state", 0); return (SQueue *) 0; } static void all_successors(int n, OneState *cur) { int i, j = 0; if (n >= nclaims) { create_transition(cur, find_state(Nst)); } else { i = cur->combo[n]; for (;;) { j = nxt_trans(n, i, j); if (j < 0) break; Nst[n] = j; all_successors(n+1, cur); j++; } } } static void gen_product(void) { OneState *cur_st; SQueue *q; find_state(Ist); /* create initial state */ while (sq) { if (in_stack(sq, sd)) { sq = sq->nxt; continue; } cur_st = &(sq->state); q = sq; sq = sq->nxt; /* delete from sq stack */ q->nxt = sd; /* and move to done stack */ sd = q; all_successors(0, cur_st); } /* all states are in the sd queue now */ prune_dead(); explore_product(); /* check if added accept-self-loops are reachable */ prune_accept(); if (verbose) { print_raw(); } /* PM: merge states with identical successor lists */ /* all outgoing transitions from accept-states from claim n in copy n connect to states in copy (n+1)%nclaims only accept states from claim 0 in copy 0 are true accept states in the product PM: what about claims that have no accept states (e.g., restrictions) */ for (unfolding = 0; unfolding < nclaims; unfolding++) { print_product(); } } static void t_record(int n, Element *e, Element *g) { int from = e->seqno, upto = g?g->seqno:0; assert(from >= 0 && from < nst); assert(upto >= 0 && upto < nst); matrix[n][from][upto] = e; reached[n][upto] |= 1; } static void get_sub(int n, Element *e) { if (e->n->ntyp == D_STEP || e->n->ntyp == ATOMIC) { fatal("atomic or d_step in never claim product", 0); } /* NON_ATOMIC */ e->n->sl->this->last->nxt = e->nxt; get_seq(n, e->n->sl->this); t_record(n, e, e->n->sl->this->frst); } static void set_el(int n, Element *e) { Element *g; if (e->n->ntyp == '@') /* change to self-loop */ { e->n->ntyp = CONST; e->n->val = 1; /* true */ e->nxt = e; g = e; mk_accepting(n, e); } else if (e->n->ntyp == GOTO) { g = get_lab(e->n, 1); g = huntele(g, e->status, -1); } else if (e->nxt) { g = huntele(e->nxt, e->status, -1); } else { g = NULL; } t_record(n, e, g); } static void get_seq(int n, Sequence *s) { SeqList *h; Element *e; e = huntele(s->frst, s->frst->status, -1); for ( ; e; e = e->nxt) { if (e->status & DONE) { goto checklast; } e->status |= DONE; if (e->n->ntyp == UNLESS) { fatal("unless stmnt in never claim product", 0); } if (e->sub) /* IF or DO */ { Lextok *x = NULL; Lextok *y = NULL; Lextok *haselse = NULL; for (h = e->sub; h; h = h->nxt) { Lextok *t = h->this->frst->n; if (t->ntyp == ELSE) { if (verbose&64) printf("else at line %d\n", t->ln); haselse = t; continue; } if (t->ntyp != 'c') { fatal("product, 'else' combined with non-condition", 0); } if (t->lft->ntyp == CONST /* true */ && t->lft->val == 1 && y == NULL) { y = nn(ZN, CONST, ZN, ZN); y->val = 0; } else { if (!x) x = t; else x = nn(ZN, OR, x, t); if (verbose&64) { wrap_text(" [", x, "]\n"); } } } if (haselse) { if (!y) { y = nn(ZN, '!', x, ZN); } if (verbose&64) { wrap_text(" [else: ", y, "]\n"); } haselse->ntyp = 'c'; /* replace else */ haselse->lft = y; } for (h = e->sub; h; h = h->nxt) { t_record(n, e, h->this->frst); get_seq(n, h->this); } } else { if (e->n->ntyp == ATOMIC || e->n->ntyp == D_STEP || e->n->ntyp == NON_ATOMIC) { get_sub(n, e); } else { set_el(n, e); } } checklast: if (e == s->last) break; } } Spin/Src6.4.5/pangen1.h0000664000175100017510000072131712641605057012416 0ustar ghgh/***** spin: pangen1.h *****/ /* * This file is part of the public release of Spin. It is subject to the * terms in the LICENSE file that is included in this source directory. * Tool documentation is available at http://spinroot.com */ static const char *Code2a[] = { /* the tail of procedure run() */ " if (state_tables)", " { if (dodot) exit(0);", " printf(\"\\nTransition Type: \");", " printf(\"A=atomic; D=d_step; L=local; G=global\\n\");", " printf(\"Source-State Labels: \");", " printf(\"p=progress; e=end; a=accept;\\n\");", "#ifdef MERGED", " printf(\"Note: statement merging was used. Only the first\\n\");", " printf(\" stmnt executed in each merge sequence is shown\\n\");", " printf(\" (use spin -a -o3 to disable statement merging)\\n\");", "#endif", " pan_exit(0);", " }", "#if defined(BFS) && defined(TRIX)", /* before iniglobals */ " { int i;", " for (i = 0; i < MAXPROC+1; i++)", " { processes[i] = (TRIX_v6 *) emalloc(sizeof(TRIX_v6));", " processes[i]->body = (uchar *) emalloc(Maxbody * sizeof(char));", " }", " for (i = 0; i < MAXQ+1; i++)", " { channels[i] = (TRIX_v6 *) emalloc(sizeof(TRIX_v6));", " channels[i]->body = (uchar *) emalloc(Maxbody * sizeof(char));", " } }", "#endif", "#ifdef BFS_PAR", " bfs_setup_mem();", " #ifdef COLLAPSE", " /* this must be the very first allocation from the shared heap */", " #ifdef BFS_SEP_HASH", " ncomps = (ulong *) emalloc((ulong)((256+2) * sizeof(ulong)));", " #else", " ncomps = (ulong *) sh_pre_malloc((ulong)((256+2) * sizeof(ulong)));", " #endif", " #endif", "#endif", " iniglobals(258); /* arg outside range of pids */", "#if defined(VERI) && !defined(NOREDUCE) && !defined(NP) && !defined(BFS) && !defined(HAS_LTL)", " if (!state_tables", " #ifdef HAS_CODE", " && !readtrail", " #endif", " #if NCORE>1", " && core_id == 0", " #endif", " )", " { printf(\"warning: for p.o. reduction to be valid \");", " printf(\"the never claim must be stutter-invariant\\n\");", " printf(\"(never claims generated from LTL \");", " printf(\"formulae are stutter-invariant)\\n\");", " }", "#endif", " UnBlock; /* disable rendez-vous */", "#ifdef BITSTATE", " sinit();", "#else", " hinit();", "#endif", "#if defined(FULLSTACK) && defined(BITSTATE)", " onstack_init();", "#endif", "#if defined(CNTRSTACK) && !defined(BFS)", " LL = (uchar *) emalloc(ONE_L<<(ssize-3));", "#endif", " stack = (_Stack *) emalloc(sizeof(_Stack));", " svtack = (Svtack *) emalloc(sizeof(Svtack));", " /* a place to point for Pptr of non-running procs: */", " noqptr = noptr = (uchar *) emalloc(Maxbody * sizeof(char));", "#if defined(SVDUMP) && defined(VERBOSE)", " if (vprefix > 0)", " (void) write(svfd, (uchar *) &vprefix, sizeof(int));", "#endif", "#ifdef VERI", " Addproc(VERI,1); /* pid = 0, priority 1 */", " #if NCLAIMS>1", " if (claimname != NULL)", " { whichclaim = find_claim(claimname);", " select_claim(whichclaim);", " }", " #endif", "#endif", " active_procs(); /* started after never */", "#ifdef EVENT_TRACE", " now._event = start_event;", " reached[EVENT_TRACE][start_event] = 1;", "#endif", "#ifdef HAS_CODE", " globinit();", "#endif", "#ifdef BITSTATE", "go_again:", "#endif", " do_the_search();", "#ifdef BITSTATE", " if (--Nrun > 0 && HASH_CONST[++HASH_NR])", /* last entry is 0 */ " { printf(\"Run %%d:\\n\", HASH_NR);", " wrap_stats();", " printf(\"\\n\");", " if (udmem) /* Dillinger 3/2/09 */", " { memset(SS, 0, udmem);", " } else", " { memset(SS, 0, ONE_L<<(ssize-3));", " }", "#ifdef CNTRSTACK", " memset(LL, 0, ONE_L<<(ssize-3));", "#endif", "#ifdef FULLSTACK", " memset((uchar *) S_Tab, 0, ", " maxdepth*sizeof(H_el *));", "#endif", " nstates=nlinks=truncs=truncs2=ngrabs = 0;", " nlost=nShadow=hcmp = 0;", " Fa=Fh=Zh=Zn = 0;", " PUT=PROBE=ZAPS=Ccheck=Cholds = 0;", " goto go_again;", " }", "#endif", "}", "#ifdef HAS_PRIORITY", "extern int highest_priority(int, short, Trans *);", "extern int get_priority(int);", "extern int set_priority(int, int);", "#endif", "#ifdef SPIN_HEAP", "void *", "spin_malloc(int n) /* reserved for use by Modex generated models */", "{ char *spin_heap_ptr = &(now.spin_heap[now.spin_heap_n]);", " if (now.spin_heap_n + n >= sizeof(now.spin_heap))", " { Uerror(\"spin_heap limit reached\");", " }", " now.spin_heap_n += n;", " return spin_heap_ptr;", "}", "void", "spin_free(void *unused)", "{ unused; /* ignore */", "}", "#endif", "int", "spin_join(int p, int unused)", "{ /* fprintf(stderr, \"join %%d when %%d\\n \", p, now._nr_pr); */", " return (now._nr_pr <= p); /* process *p has stopped */", "}", "", "int", "spin_mutex_free(int *m)", "{ return (*m == 0);", "}", "", "int", "spin_mutex_lock(int *m)", "{ *m = 1;", " return 1;", "}", "void", "spin_mutex_unlock(int *m)", "{ *m = 0;", "}", "void", "spin_mutex_init(int *m, void *val)", "{", " if (!val)", /* the 2nd arg must be NULL, for now */ " { *m = 0;", " } else", " { Uerror(\"pthread_mutex_init: unsupported non-default init\");", " }", "}", "", "int", "spin_cond_wait(int *cond, int *lck)", /*release and re-acquire lock *lck */ "{ /* this version does not scale very far alas */", " if (((P0 *)this)->_pid + 1 >= WS*8)", /* 32 or 64 */ " { Uerror(\"pid exceeds range supported by pthread_cond_wait\");", " }", " if (((*cond)&1) == 0)", /* repeatedly tested, so: */ " { spin_mutex_unlock(lck);", /* avoid double counting */ " *cond |= (1<<(((P0 *)this)->_pid + 1));", " return 0;", /* blocked, must test again */ " } else", " { /* if other processes are already waiting */", " /* while our wait flag is 0, then they should go first */", " if (((*cond)&(~(1 | (1<<(((P0 *)this)->_pid + 1))))) != 0)", " { spin_mutex_unlock(lck);", " return 0;", /* wait for the others to go first */ " }", " *cond &= ~1;", /* clear the 'go' bit andy wait flag */ " *cond &= ~(1<<(((P0 *)this)->_pid + 1));", " return 1;", /* okay to proceed */ " }", "}", "void", "spin_cond_signal(int *cond)", "{", " if ( ((*cond)&(~1)) != 0 )", /* procs are waiting */ " { *cond |= 1;", /* set the 'go' bit */ " }", "}", "", "#ifdef HAS_PROVIDED", " int provided(int, uchar, int, Trans *);", "#endif", "#ifdef BFS_PAR", " extern void bfs_shutdown(const char *);", "#endif", "", "#if NCORE>1", " #define GLOBAL_LOCK (0)", " #ifndef CS_N", " #define CS_N (256*NCORE)", /* must be a power of 2 */ " #endif", " #ifdef NGQ", /* no global queue */ " #define NR_QS (NCORE)", " #define CS_NR (CS_N+1) /* 2^N + 1, nr critical sections */", " #define GQ_RD GLOBAL_LOCK", /* not really used in this mode */ " #define GQ_WR GLOBAL_LOCK", /* but just in case... */ " #define CS_ID (1 + (int) (j1_spin & (CS_N-1))) /* mask: 2^N - 1, zero reserved */", " #define QLOCK(n) (1+n)", /* overlaps first n zones of hashtable */ " #else", " #define NR_QS (NCORE+1)", /* add a global queue */ " #define CS_NR (CS_N+3)", /* 2 extra locks for global q */ " #define GQ_RD (1)", /* read access to global q */ " #define GQ_WR (2)", /* write access to global q */ " #define CS_ID (3 + (int) (j1_spin & (CS_N-1)))", " #define QLOCK(n) (3+n)",/* overlaps first n zones of hashtable */ " #endif", "", " #ifndef SEP_STATE", " #define enter_critical(w) e_critical(w)", " #define leave_critical(w) x_critical(w)", " #else", " #ifdef NGQ", " #define enter_critical(w) { if (w < 1+NCORE) e_critical(w); }", " #define leave_critical(w) { if (w < 1+NCORE) x_critical(w); }", " #else", " #define enter_critical(w) { if (w < 3+NCORE) e_critical(w); }", " #define leave_critical(w) { if (w < 3+NCORE) x_critical(w); }", " #endif", " #endif", "", " int", " cpu_printf(const char *fmt, ...)", /* only used with VERBOSE/CHECK/DEBUG */ " { va_list args;", " enter_critical(GLOBAL_LOCK); /* printing */", " printf(\"cpu%%d: \", core_id);", " fflush(stdout);", " va_start(args, fmt);", " vprintf(fmt, args);", " va_end(args);", " fflush(stdout);", " leave_critical(GLOBAL_LOCK);", " return 1;", " }", "#else", " #define enter_critical(w) /* none */", " #define leave_critical(w) /* none */", "", " int", " cpu_printf(const char *fmt, ...)", " { va_list args;", " va_start(args, fmt);", " vprintf(fmt, args);", " va_end(args);", " return 1;", " }", "#endif", #ifndef PRINTF "int", "Printf(const char *fmt, ...)", "{ /* Make sure the args to Printf", " * are always evaluated (e.g., they", " * could contain a run stmnt)", " * but do not generate the output", " * during verification runs", " * unless explicitly wanted", " * If this fails on your system", " * compile SPIN itself -DPRINTF", " * and this code is not generated", " */", "#ifdef HAS_CODE", " if (readtrail)", " { va_list args;", " va_start(args, fmt);", " vprintf(fmt, args);", " va_end(args);", " return 1;", " }", "#endif", "#ifdef PRINTF", " va_list args;", " va_start(args, fmt);", " vprintf(fmt, args);", " va_end(args);", "#endif", " return 1;", "}", #endif "extern void printm(int);", "#ifndef SC", "#define getframe(i) &trail[i];", "#else", "static long HHH, DDD, hiwater;", "static long CNT1, CNT2;", "static int stackwrite;", "static int stackread;", "static Trail frameptr;", "Trail *", "getframe(long d)", "{", " if (CNT1 == CNT2)", " return &trail[d];", "", " if (d >= (CNT1-CNT2)*DDD)", " return &trail[d - (CNT1-CNT2)*DDD];", "", " if (!stackread", " && (stackread = open(stackfile, 0)) < 0)", " { printf(\"getframe: cannot open %%s\\n\", stackfile);", " wrapup();", " }", " if (lseek(stackread, d* (off_t) sizeof(Trail), SEEK_SET) == -1", " || read(stackread, &frameptr, sizeof(Trail)) != sizeof(Trail))", " { printf(\"getframe: frame read error\\n\");", " wrapup();", " }", " return &frameptr;", "}", "#endif", "#if NCORE>1", "extern void cleanup_shm(int);", "volatile uint *search_terminated; /* to signal early termination */", /* * Meaning of bitflags in search_terminated: * 1 set by pan_exit * 2 set by wrapup * 4 set by uerror * 8 set by sudden_stop -- called after someone_crashed and [Uu]error * 16 set by cleanup_shm * 32 set by give_up -- called on signal * 64 set by proxy_exit * 128 set by proxy on write port failure * 256 set by proxy on someone_crashed * * Flags 8|32|128|256 indicate abnormal termination * * The flags are checked in 4 functions in the code: * sudden_stop() * someone_crashed() (proxy and pan version) * mem_hand_off() */ "#endif", "void", "pan_exit(int val)", "{ void stop_timer(int);", "#ifdef BFS_PAR", " extern void bfs_mark_done(int);", " extern void bfs_drop_shared_memory(void);", "#endif", " if (signoff)", " { printf(\"--end of output--\\n\");", " }", "#if NCORE>1", " if (search_terminated != NULL)", " { *search_terminated |= 1; /* pan_exit */", " }", "#ifdef USE_DISK", " { void dsk_stats(void);", " dsk_stats();", " }", "#endif", " if (!state_tables && !readtrail)", " { cleanup_shm(1);", " }", "#endif", "#ifdef BFS_PAR", " if (who_am_i != 0)", " { bfs_mark_done(3); /* stopped */", " }", " bfs_drop_shared_memory();", "#endif", " if (val == 2)", " { val = 0;", " }", "#ifdef BFS_PAR", " if (who_am_i == 0)", "#endif", " stop_timer(1);", "", "#ifdef C_EXIT", " C_EXIT; /* trust that it defines a fct */", "#endif", " exit(val);", "}", "#ifdef HAS_CODE", "static char tbuf[2][2048];", "", "char *", "transmognify(char *s)", "{ char *v, *w;", " int i, toggle = 0;", " if (!s || strlen(s) > 2047) return s;", " memset(tbuf[0], 0, 2048);", " memset(tbuf[1], 0, 2048);", " strcpy(tbuf[toggle], s);", " while ((v = strstr(tbuf[toggle], \"{c_code\")))", /* assign v */ " { *v = '\\0'; v++;", " strcpy(tbuf[1-toggle], tbuf[toggle]);", " for (w = v; *w != '}' && *w != '\\0'; w++) /* skip */;", " if (*w != '}') return s;", " *w = '\\0'; w++;", " for (i = 0; code_lookup[i].c; i++)", " if (strcmp(v, code_lookup[i].c) == 0", " && strlen(v) == strlen(code_lookup[i].c))", " { if (strlen(tbuf[1-toggle])", " + strlen(code_lookup[i].t)", " + strlen(w) > 2047)", " return s;", " strcat(tbuf[1-toggle], code_lookup[i].t);", " break;", " }", " strcat(tbuf[1-toggle], w);", " toggle = 1 - toggle;", " }", " tbuf[toggle][2047] = '\\0';", " return tbuf[toggle];", "}", "#else", "char * transmognify(char *s) { return s; }", "#endif", "#ifdef HAS_CODE", "void", "add_src_txt(int ot, int tt)", "{ Trans *t;", " char *q;", "", " for (t = trans[ot][tt]; t; t = t->nxt)", " { printf(\"\\t\\t\");", " q = transmognify(t->tp);", " for ( ; q && *q; q++)", " if (*q == '\\n')", " printf(\"\\\\n\");", " else", " putchar(*q);", " printf(\"\\n\");", " }", "}", "", "char *", "find_source(int tp, int s)", "{", " if (s >= flref[tp]->from", " && s <= flref[tp]->upto)", " { return flref[tp]->fnm;", " }", " return PanSource; /* i.e., don't know */", "}", "", "void", "wrap_trail(void)", "{ static int wrap_in_progress = 0;", " int i; short II;", " P0 *z;", "", " if (wrap_in_progress++) return;", "", " printf(\"spin: trail ends after %%ld steps\\n\", depth);", " if (onlyproc >= 0)", " { if (onlyproc >= now._nr_pr) { pan_exit(0); }", " II = onlyproc;", " z = (P0 *)pptr(II);", " printf(\"%%3ld:\tproc %%d (%%s) \",", " depth, II, procname[z->_t]);", " for (i = 0; src_all[i].src; i++)", " if (src_all[i].tp == (int) z->_t)", " { printf(\" %%s:%%d\",", " find_source((int) z->_t, (int) z->_p),", " src_all[i].src[z->_p]);", " break;", " }", " printf(\" (state %%2d)\", z->_p);", " if (!stopstate[z->_t][z->_p])", " printf(\" (invalid end state)\");", " printf(\"\\n\");", " add_src_txt(z->_t, z->_p);", " pan_exit(0);", " }", " printf(\"#processes %%d:\\n\", now._nr_pr);", " if (depth < 0) depth = 0;", " for (II = 0; II < now._nr_pr; II++)", " { z = (P0 *)pptr(II);", " printf(\"%%3ld:\tproc %%d (%%s) \",", " depth, II, procname[z->_t]);", " for (i = 0; src_all[i].src; i++)", " if (src_all[i].tp == (int) z->_t)", " { printf(\" %%s:%%d\",", " find_source((int) z->_t, (int) z->_p),", " src_all[i].src[z->_p]);", " break;", " }", " printf(\" (state %%2d)\", z->_p);", " if (!stopstate[z->_t][z->_p])", " printf(\" (invalid end state)\");", " printf(\"\\n\");", " add_src_txt(z->_t, z->_p);", " }", " c_globals();", " for (II = 0; II < now._nr_pr; II++)", " { z = (P0 *)pptr(II);", " c_locals(II, z->_t);", " }", "#ifdef ON_EXIT", " ON_EXIT;", "#endif", " pan_exit(0);", "}", "FILE *", "findtrail(void)", "{ FILE *fd;", " char fnm[512], *q;", " char MyFile[512];", /* avoid using a non-writable string */ " char MySuffix[16];", " int try_core;", " int candidate_files;", "", " if (trailfilename != NULL)", " { fd = fopen(trailfilename, \"r\");", " if (fd == NULL)", " { printf(\"pan: cannot find %%s\\n\", trailfilename);", " pan_exit(1);", " } /* else */", " goto success;", " }", "talk:", " try_core = 1;", " candidate_files = 0;", " tprefix = \"trail\";", " strcpy(MyFile, TrailFile);", " do { /* see if there's more than one possible trailfile */", " if (whichtrail)", " { sprintf(fnm, \"%%s%%d.%%s\",", " MyFile, whichtrail, tprefix);", " fd = fopen(fnm, \"r\");", " if (fd != NULL)", " { candidate_files++;", " if (verbose==100)", " printf(\"trail%%d: %%s\\n\",", " candidate_files, fnm);", " fclose(fd);", " }", " if ((q = strchr(MyFile, \'.\')) != NULL)", " { *q = \'\\0\';", /* e.g., strip .pml */ " sprintf(fnm, \"%%s%%d.%%s\",", " MyFile, whichtrail, tprefix);", " *q = \'.\';", " fd = fopen(fnm, \"r\");", " if (fd != NULL)", " { candidate_files++;", " if (verbose==100)", " printf(\"trail%%d: %%s\\n\",", " candidate_files, fnm);", " fclose(fd);", " } }", " } else", " { sprintf(fnm, \"%%s.%%s\", MyFile, tprefix);", " fd = fopen(fnm, \"r\");", " if (fd != NULL)", " { candidate_files++;", " if (verbose==100)", " printf(\"trail%%d: %%s\\n\",", " candidate_files, fnm);", " fclose(fd);", " }", " if ((q = strchr(MyFile, \'.\')) != NULL)", " { *q = \'\\0\';", /* e.g., strip .pml */ " sprintf(fnm, \"%%s.%%s\", MyFile, tprefix);", " *q = \'.\';", " fd = fopen(fnm, \"r\");", " if (fd != NULL)", " { candidate_files++;", " if (verbose==100)", " printf(\"trail%%d: %%s\\n\",", " candidate_files, fnm);", " fclose(fd);", " } } }", " tprefix = MySuffix;", " sprintf(tprefix, \"cpu%%d_trail\", try_core++);", " } while (try_core <= NCORE);", "", " if (candidate_files != 1)", " { if (verbose != 100)", " { printf(\"error: there are %%d trail files:\\n\",", " candidate_files);", " verbose = 100;", " goto talk;", " } else", " { printf(\"pan: rm or mv all except one\\n\");", " exit(1);", " } }", " try_core = 1;", " strcpy(MyFile, TrailFile); /* restore */", " tprefix = \"trail\";", "try_again:", " if (whichtrail)", " { sprintf(fnm, \"%%s%%d.%%s\", MyFile, whichtrail, tprefix);", " fd = fopen(fnm, \"r\");", " if (fd == NULL && (q = strchr(MyFile, \'.\')))", " { *q = \'\\0\';", /* e.g., strip .pml on original file */ " sprintf(fnm, \"%%s%%d.%%s\",", " MyFile, whichtrail, tprefix);", " *q = \'.\';", " fd = fopen(fnm, \"r\");", " }", " } else", " { sprintf(fnm, \"%%s.%%s\", MyFile, tprefix);", " fd = fopen(fnm, \"r\");", " if (fd == NULL && (q = strchr(MyFile, \'.\')))", " { *q = \'\\0\';", /* e.g., strip .pml on original file */ " sprintf(fnm, \"%%s.%%s\", MyFile, tprefix);", " *q = \'.\';", " fd = fopen(fnm, \"r\");", " } }", " if (fd == NULL)", " { if (try_core < NCORE)", " { tprefix = MySuffix;", " sprintf(tprefix, \"cpu%%d_trail\", try_core++);", " goto try_again;", " }", " printf(\"pan: cannot find trailfile %%s\\n\", fnm);", " pan_exit(1);", " }", "success:", "#if NCORE>1 && defined(SEP_STATE)", " { void set_root(void); /* for partial traces from local root */", " set_root();", " }", "#endif", " return fd;", "}", "", "uchar do_transit(Trans *, short);", "#ifdef PERMUTED", "void set_permuted(int);", "void set_reversed(int);", "void set_rotated(int);", "void set_randrot(int);", "void (*p_reorder)(int) = set_permuted;", "short p_rotate;", "#endif", "", "void", "getrail(void)", "{ FILE *fd;", " char *q, *pnm;", " int i, t_id, lastnever = -1; short II;", " Trans *t;", " P0 *z;", "#ifdef PERMUTED", " char sbuf[128];", " memset(sbuf, 0, sizeof(sbuf));", "#endif", " fd = findtrail(); /* exits if unsuccessful */", " while (fscanf(fd, \"%%ld:%%d:%%d\\n\", &depth, &i, &t_id) == 3)", " { if (depth == -1)", " { printf(\"<<<<>>>>\\n\");", " }", "#ifdef PERMUTED", " if (depth < 0)", " { switch (depth) {", " case -5:", " if (i && !t_reverse)", " { strcat(sbuf, \"-t_reverse \");", " }", " break;", " case -6:", " if (i && p_reorder != set_permuted)", " { strcat(sbuf, \"-p_permute \");", " } else", " if (t_id && p_reorder != set_reversed)", " { strcat(sbuf, \"-p_reverse \");", " }", " break;", " case -7:", " if (i", " && (p_reorder != set_rotated || p_rotate != t_id))", " { char tmp[32];", " sprintf(tmp, \"-p_rotate%%d \", t_id);", " strcat(sbuf, tmp);", " }", " break;", " case -8:", " if (i && p_reorder != set_randrot)", " { strcat(sbuf, \"-p_randrot \");", " }", " if (s_rand != ++t_id)", " { char tmp[32];", " sprintf(tmp, \"-RS%%u \", (uint) t_id-1);", " strcat(sbuf, tmp);", " }", " break;", " default:", " continue;", " }", " }", "#endif", " if (depth < 0)", " { continue;", " }", "#ifdef PERMUTED", " if (strlen(sbuf) > 0)", " { fprintf(efd, \"add: %%s\\n\", sbuf);", " exit(1);", " }", "#endif", " if (i > now._nr_pr)", " { printf(\"pan: Error, proc %%d invalid pid \", i);", " printf(\"transition %%d\\n\", t_id);", " break;", " }", " II = i;", " z = (P0 *)pptr(II);", " for (t = trans[z->_t][z->_p]; t; t = t->nxt)", " if (t->t_id == (T_ID) t_id)", " break;", " if (!t)", " { for (i = 0; i < NrStates[z->_t]; i++)", " { t = trans[z->_t][i];", " if (t && t->t_id == (T_ID) t_id)", " { printf(\"\\tRecovered at state %%d\\n\", i);", " z->_p = i;", " goto recovered;", " } }", " printf(\"pan: Error, proc %%d type %%d state %%d: \",", " II, z->_t, z->_p);", " printf(\"transition %%d not found\\n\", t_id);", " printf(\"pan: list of possible transitions in this process:\\n\");", " if (z->_t >= 0 && z->_t <= _NP_)", " for (t = trans[z->_t][z->_p]; t; t = t->nxt)", " printf(\" t_id %%d -- case %%d, [%%s]\\n\",", " t->t_id, t->forw, t->tp);", " break; /* pan_exit(1); */", " }", "recovered:", " q = transmognify(t->tp);", " if (gui) simvals[0] = \'\\0\';", " pnm = procname[z->_t];", " this = pptr(II);", " trpt->tau |= 1;", /* timeout always possible */ " if (!do_transit(t, II))", " { if (onlyproc >= 0 && II != onlyproc)", " goto moveon;", " if (!verbose) break;", " printf(\"pan: error, next transition UNEXECUTABLE on replay\\n\");", " printf(\" most likely causes: missing c_track statements\\n\");", " printf(\" or illegal side-effects in c_expr statements\\n\");", " }", " if (onlyproc >= 0 && II != onlyproc)", " goto moveon;", " if (verbose)", " { printf(\"%%3ld: proc %%2d (%%s) \", depth, II, pnm);", " for (i = 0; src_all[i].src; i++)", " if (src_all[i].tp == (int) z->_t)", " { printf(\" %%s:%%d \",", " find_source((int) z->_t, (int) z->_p),", " src_all[i].src[z->_p]);", " break;", " }", " printf(\"(state %%d) trans {%%d,%%d} [%%s]\\n\",", " z->_p, t_id, t->forw, q?q:\"\");", " c_globals();", " for (i = 0; i < now._nr_pr; i++)", " { c_locals(i, ((P0 *)pptr(i))->_t);", " }", " } else if (Btypes[z->_t] == N_CLAIM)", " { if (lastnever != (int) z->_p)", " { for (i = 0; src_all[i].src; i++)", " if (src_all[i].tp == (int) z->_t)", " { printf(\"MSC: ~G %%d\\n\",", " src_all[i].src[z->_p]);", " break;", " }", " if (!src_all[i].src)", " printf(\"MSC: ~R %%d\\n\", z->_p);", " }", " lastnever = z->_p;", " goto sameas;", " } else if (Btypes[z->_t] != 0) /* not :np_: */", " {", "sameas: if (no_rck) goto moveon;", " if (coltrace)", " { printf(\"%%ld: \", depth);", " for (i = 0; i < II; i++)", " printf(\"\\t\\t\");", " printf(\"%%s(%%d):\", pnm, II);", " printf(\"[%%s]\\n\", q?q:\"\");", " } else if (!silent)", " { if (strlen(simvals) > 0) {", " printf(\"%%3ld: proc %%2d (%%s)\", ", " depth, II, pnm);", " for (i = 0; src_all[i].src; i++)", " if (src_all[i].tp == (int) z->_t)", " { printf(\" %%s:%%d \",", " find_source((int) z->_t, (int) z->_p),", " src_all[i].src[z->_p]);", " break;", " }", " printf(\"(state %%d)\t[values: %%s]\\n\", z->_p, simvals);", " }", " printf(\"%%3ld: proc %%2d (%%s)\", ", " depth, II, pnm);", " for (i = 0; src_all[i].src; i++)", " if (src_all[i].tp == (int) z->_t)", " { printf(\" %%s:%%d \",", " find_source((int) z->_t, (int) z->_p),", " src_all[i].src[z->_p]);", " break;", " }", " printf(\"(state %%d)\t[%%s]\\n\", z->_p, q?q:\"\");", " /* printf(\"\\n\"); */", " } }", "moveon: z->_p = t->st;", " }", " wrap_trail();", "}", "#endif", "int", "f_pid(int pt)", "{ int i;", " P0 *z;", " for (i = 0; i < now._nr_pr; i++)", " { z = (P0 *)pptr(i);", " if (z->_t == (unsigned) pt)", " return BASE+z->_pid;", " }", " return -1;", "}", "", "#if NCORE>1 && !defined(GLOB_HEAP)", " #define SEP_HEAP /* version 5.1.2 */", "#endif", "", "#ifdef BITSTATE", "int", "bstore_mod(char *v, int n) /* hasharray size not a power of two */", "{ ulong x, y;", " uint i = 1;", "#if defined(MURMUR) && (WS==8)", " m_hash((uchar *) v, n); /* bstore_mod - sets j3_spin, j4_spin, K1, K2 */", "#else", " d_hash((uchar *) v, n); /* bstore_mod - sets j3_spin, j4_spin, K1, K2 */", "#endif", " x = K1; y = j3_spin;", /* was K2 before 5.1.1 */ " for (;;)", " { if (!(SS[x%%udmem]&(1< RANDSTOR) return 0;", "#endif", " for (;;)", " { SS[x%%udmem] |= (1< RANDSTOR) return 0;", "#endif", " for (;;)", " { SS[x] |= (1< 0)", " {", "#ifdef PUTPID", " sprintf(fnm, \"%%s_%%s_%%d_%%d.%%s\",", " MyFile, progname, getpid(), Nr_Trails-1, tprefix);", "#else", " sprintf(fnm, \"%%s%%d.%%s\",", " MyFile, Nr_Trails-1, tprefix);", "#endif", " } else", " {", "#ifdef PUTPID", " sprintf(fnm, \"%%s_%%s_%%d.%%s\", MyFile, progname, getpid(), tprefix);", "#else", " sprintf(fnm, \"%%s.%%s\", MyFile, tprefix);", "#endif", " }", " if ((fd = open(fnm, w_flags, TMODE)) < 0)", " { if ((q = strchr(MyFile, \'.\')))", " { *q = \'\\0\';", /* strip .pml */ " if (iterative == 0 && Nr_Trails-1 > 0)", " sprintf(fnm, \"%%s%%d.%%s\",", " MyFile, Nr_Trails-1, tprefix);", " else", " sprintf(fnm, \"%%s.%%s\", MyFile, tprefix);", " *q = \'.\';", " fd = open(fnm, w_flags, TMODE);", " } }", " if (fd < 0)", " { printf(\"pan: cannot create %%s\\n\", fnm);", " perror(\"cause\");", " } else", " {", "#if NCORE>1 && (defined(SEP_STATE) || !defined(FULL_TRAIL))", " void write_root(void); ", " write_root();", "#else", " printf(\"pan: wrote %%s\\n\", fnm);", "#endif", " }", " return fd;", "}", "", "#ifndef FREQ", "#define FREQ (1000000)", "#endif", "double freq = (double) FREQ;\n", "#ifdef TRIX", "void sv_populate(void);", "", "void", "re_populate(void) /* restore procs and chans from now._ids_ */", "{ int i, cnt = 0;", " char *b;", "#ifdef V_TRIX", " printf(\"%%4d: re_populate\\n\", depth);", "#endif", " for (i = 0; i < now._nr_pr; i++, cnt++)", " { b = now._ids_[cnt];", " processes[i]->psize = what_p_size( ((P0 *)b)->_t );", " memcpy(processes[i]->body, b, processes[i]->psize);", "#ifdef TRIX_RIX", " ((P0 *)pptr(i))->_pid = i;", " if (BASE > 0 && h > 0)", " { ((P0 *)pptr(i))->_pid -= BASE;", " }", "#endif", "#ifndef BFS", " processes[i]->modified = 1; /* re-populate */", "#endif", " }", " for (i = 0; i < now._nr_qs; i++, cnt++)", " { b = now._ids_[cnt];", " channels[i]->psize = what_q_size( ((Q0 *)b)->_t );", " memcpy(channels[i]->body, b, channels[i]->psize);", "#ifndef BFS", " channels[i]->modified = 1; /* re-populate */", "#endif", " }", "}", "#endif\n", "#ifdef BFS", /* breadth-first search */ " #ifndef BFS_PAR", " BFS_State *bfs_trail, *bfs_bot, *bfs_free;", " SV_Hold *svfree;", " #else", " static ulong bfs_pre_allocated;", " #endif", " #ifdef BFS_DISK", " #ifndef BFS_LIMIT", " #define BFS_LIMIT 100000", " #endif", " #ifndef BFS_DSK_LIMIT", " #define BFS_DSK_LIMIT 1000000", " #endif", " #if defined(WIN32) || defined(WIN64)", " #define RFLAGS (O_RDONLY|O_BINARY)", " #define WFLAGS (O_CREAT|O_WRONLY|O_TRUNC|O_BINARY)", " #define RWFLAGS (O_RDWR|O_BINARY)", " #else", " #define RFLAGS (O_RDONLY)", " #define WFLAGS (O_CREAT|O_WRONLY|O_TRUNC)", " #define RWFLAGS (O_RDWR)", " #endif", "", " long bfs_size_limit;", " int bfs_dsk_write = -1;", " int bfs_dsk_read = -1;", " long bfs_dsk_writes, bfs_dsk_reads;", " int bfs_dsk_seqno_w, bfs_dsk_seqno_r;", " #endif", "", "uchar do_reverse(Trans *, short, uchar);", "void snapshot(void);", "#if 0", "void", "select_claim(int x) /* ignored in BFS mode */", "{ if (verbose)", " { printf(\"select %%d (ignored)\\n\", x);", " }", "}", "#endif", "Trail *ntrpt;", "", "#ifndef BFS_PAR", "SV_Hold *", "getsv(int n)", "{ SV_Hold *h;", "", " if (svfree && n <= svfree->sz)", " { h = svfree;", " svfree = h->nxt;", " h->nxt = (SV_Hold *) 0;", " } else", " { h = (SV_Hold *) emalloc(sizeof(SV_Hold));", " h->sz = n;", " #ifdef BFS_DISK", " if (bfs_size_limit >= BFS_LIMIT)", " { h->sv = (State *) 0; /* means: read disk */", " bfs_dsk_writes++; /* count */", " if (bfs_dsk_write < 0 /* file descriptor */", " || bfs_dsk_writes%%BFS_DSK_LIMIT == 0)", " { char dsk_nm[32];", " if (bfs_dsk_write >= 0)", " { (void) close(bfs_dsk_write);", " }", " sprintf(dsk_nm, \"pan_bfs_%%d.tmp\", bfs_dsk_seqno_w++);", " bfs_dsk_write = open(dsk_nm, WFLAGS, 0644);", " if (bfs_dsk_write < 0)", " { Uerror(\"could not create tmp disk file\");", " }", " printf(\"pan: created disk file %%s\\n\", dsk_nm);", " }", " if (write(bfs_dsk_write, (char *) &now, n) != n)", " { Uerror(\"aborting -- disk write failed (disk full?)\");", " }", " return h; /* no memcpy */", " }", /* else */ " bfs_size_limit++;", " #endif", " h->sv = (State *) emalloc(sizeof(State) - VECTORSZ + n);", " }", "", " memcpy((char *)h->sv, (char *)&now, n);", " return h;", "}", "", "EV_Hold *", "getsv_mask(int n)", "{ EV_Hold *h;", " static EV_Hold *kept = (EV_Hold *) 0;", "", " for (h = kept; h; h = h->nxt)", " if (n == h->sz", "#if !defined(NOCOMP) && !defined(HC)", " && (memcmp((char *) Mask, (char *) h->sv, n) == 0)", "#endif", " && (now._nr_pr == h->nrpr)", " && (now._nr_qs == h->nrqs)", " #ifdef TRIX", " )", " #else", " #if VECTORSZ>32000", " && (memcmp((char *) proc_offset, (char *) h->po, now._nr_pr * sizeof(int)) == 0)", " && (memcmp((char *) q_offset, (char *) h->qo, now._nr_qs * sizeof(int)) == 0)", " #else", " && (memcmp((char *) proc_offset, (char *) h->po, now._nr_pr * sizeof(short)) == 0)", " && (memcmp((char *) q_offset, (char *) h->qo, now._nr_qs * sizeof(short)) == 0)", " #endif", " && (memcmp((char *) proc_skip, (char *) h->ps, now._nr_pr * sizeof(uchar)) == 0)", " && (memcmp((char *) q_skip, (char *) h->qs, now._nr_qs * sizeof(uchar)) == 0))", " #endif", " break;", " if (!h)", " { h = (EV_Hold *) emalloc(sizeof(EV_Hold));", " h->sz = n;", " h->nrpr = now._nr_pr;", " h->nrqs = now._nr_qs;", "", " h->sv = (char *) emalloc(n * sizeof(char));", "#if !defined(NOCOMP) && !defined(HC)", " memcpy((char *) h->sv, (char *) Mask, n);", "#endif", " #ifndef TRIX", " if (now._nr_pr > 0)", " { h->ps = (char *) emalloc(now._nr_pr * sizeof(int));", " memcpy((char *) h->ps, (char *) proc_skip, now._nr_pr * sizeof(uchar));", " #if VECTORSZ>32000", " h->po = (char *) emalloc(now._nr_pr * sizeof(int));", " memcpy((char *) h->po, (char *) proc_offset, now._nr_pr * sizeof(int));", " #else", " h->po = (char *) emalloc(now._nr_pr * sizeof(short));", " memcpy((char *) h->po, (char *) proc_offset, now._nr_pr * sizeof(short));", " #endif", " }", " if (now._nr_qs > 0)", " { h->qs = (char *) emalloc(now._nr_qs * sizeof(int));", " memcpy((char *) h->qs, (char *) q_skip, now._nr_qs * sizeof(uchar));", " #if VECTORSZ>32000", " h->qo = (char *) emalloc(now._nr_qs * sizeof(int));", " memcpy((char *) h->qo, (char *) q_offset, now._nr_qs * sizeof(int));", " #else", " h->qo = (char *) emalloc(now._nr_qs * sizeof(short));", " memcpy((char *) h->qo, (char *) q_offset, now._nr_qs * sizeof(short));", " #endif", " }", " #endif", " h->nxt = kept;", " kept = h;", " }", " return h;", "}", "", "void", "freesv(SV_Hold *p)", "{ SV_Hold *h, *oh;", "", " oh = (SV_Hold *) 0;", " for (h = svfree; h; oh = h, h = h->nxt)", " { if (p->sz >= h->sz)", " break;", " }", " if (!oh)", " { p->nxt = svfree;", " svfree = p;", " } else", " { p->nxt = h;", " oh->nxt = p;", " }", "}", "", "BFS_State *", "get_bfs_frame(void)", "{ BFS_State *t;", "", " if (bfs_free)", " { t = bfs_free;", " bfs_free = bfs_free->nxt;", " t->nxt = (BFS_State *) 0;", " } else", " { t = (BFS_State *) emalloc(sizeof(BFS_State));", " }", " t->frame = (Trail *) emalloc(sizeof(Trail));", /* always new */ " /* new because we keep a ptr to the frame of parent states */", " /* used for reconstructing path and recovering failed rvs etc */", " return t;", "}", "", "void", "push_bfs(Trail *f, int d)", "{ BFS_State *t;", "", " t = get_bfs_frame();", " memcpy((char *)t->frame, (char *)f, sizeof(Trail));", " t->frame->o_tt = d; /* depth */", "", " t->boq = boq;", " #ifdef TRIX", " sv_populate();", " #endif", " t->onow = getsv(vsize);", " t->omask = getsv_mask(vsize);", " #if defined(FULLSTACK) && defined(Q_PROVISO)", " t->lstate = Lstate; /* bfs */", " #endif", " if (!bfs_bot)", " { bfs_bot = bfs_trail = t;", " } else", " { bfs_bot->nxt = t;", " bfs_bot = t;", " }", " #ifdef VERBOSE", " t->nr = nstates;", " #endif", " #ifdef CHECK", " #ifdef VERBOSE", " printf(\"PUSH %%lu (depth %%d, nr %%lu)\\n\", (ulong) t->frame, d, t->nr);", " #else", " printf(\"PUSH %%lu (depth %%d)\\n\", (ulong) t->frame, d);", " #endif", " #endif", "}", "", "Trail *", "pop_bfs(void)", "{ BFS_State *t;", "", " if (!bfs_trail)", " { return (Trail *) 0;", " }", " t = bfs_trail;", " bfs_trail = t->nxt;", " if (!bfs_trail)", " { bfs_bot = (BFS_State *) 0;", " }", " #if defined(Q_PROVISO) && !defined(BITSTATE) && !defined(NOREDUCE)", " if (t->lstate) /* bfs */", " { t->lstate->tagged = 0; /* bfs */", " }", " #endif", " t->nxt = bfs_free;", " bfs_free = t;", "", " vsize = t->onow->sz;", " boq = t->boq;", " #ifdef BFS_DISK", " if (t->onow->sv == (State *) 0)", " { char dsk_nm[32];", " bfs_dsk_reads++; /* count */", " if (bfs_dsk_read >= 0 /* file descriptor */", " && bfs_dsk_reads%%BFS_DSK_LIMIT == 0)", " { (void) close(bfs_dsk_read);", " sprintf(dsk_nm, \"pan_bfs_%%d.tmp\", bfs_dsk_seqno_r-1);", " (void) unlink(dsk_nm);", " bfs_dsk_read = -1;", " }", " if (bfs_dsk_read < 0)", " { sprintf(dsk_nm, \"pan_bfs_%%d.tmp\", bfs_dsk_seqno_r++);", " bfs_dsk_read = open(dsk_nm, RFLAGS);", " if (bfs_dsk_read < 0)", " { Uerror(\"could not open temp disk file\");", " } }", " if (read(bfs_dsk_read, (char *) &now, vsize) != vsize)", " { Uerror(\"bad bfs disk file read\");", " }", " #ifndef NOVSZ", " if (now._vsz != vsize)", " { Uerror(\"disk read vsz mismatch\");", " }", " #endif", " } else", " #endif", " { memcpy((uchar *) &now, (uchar *) t->onow->sv, vsize);", " #ifndef NOVSZ", " vsize = now._vsz;", " #endif", " }", "#if !defined(NOCOMP) && !defined(HC)", " memcpy((uchar *) Mask, (uchar *) t->omask->sv, vsize);", "#endif", " #ifdef TRIX", " re_populate();", " #else", " if (now._nr_pr > 0)", " #if VECTORSZ>32000", " { memcpy((char *)proc_offset, (char *)t->omask->po, now._nr_pr * sizeof(int));", " #else", " { memcpy((char *)proc_offset, (char *)t->omask->po, now._nr_pr * sizeof(short));", " #endif", " memcpy((char *)proc_skip, (char *)t->omask->ps, now._nr_pr * sizeof(uchar));", " }", " if (now._nr_qs > 0)", " #if VECTORSZ>32000", " { memcpy((uchar *)q_offset, (uchar *)t->omask->qo, now._nr_qs * sizeof(int));", " #else", " { memcpy((uchar *)q_offset, (uchar *)t->omask->qo, now._nr_qs * sizeof(short));", " #endif", " memcpy((uchar *)q_skip, (uchar *)t->omask->qs, now._nr_qs * sizeof(uchar));", " }", " #endif", " #ifdef BFS_DISK", " if (t->onow->sv != (State *) 0)", " #endif", " { freesv(t->onow); /* omask not freed */", " }", " #ifdef CHECK", " #ifdef VERBOSE", " printf(\"POP %%lu (depth %%d, nr %%lu)\\n\", (ulong) t->frame, t->frame->o_tt, t->nr);", " #else", " printf(\"POP %%lu (depth %%d)\\n\", (ulong) t->frame, t->frame->o_tt);", " #endif", " #endif", " return t->frame;", "}", "", "void", "store_state(Trail *ntrpt, int shortcut, short oboq)", "{", " #ifdef VERI", " Trans *t2 = (Trans *) 0;", " uchar ot; int tt, E_state;", " uchar o_opm = trpt->o_pm, *othis = this;", "", " if (shortcut)", " {", " #ifdef VERBOSE", " printf(\"claim: shortcut\\n\");", " #endif", " goto store_it; /* no claim move */", " }", "", " this = pptr(0); /* 0 = never claim */", " trpt->o_pm = 0;", /* to interpret else in never claim */ "", " tt = (int) ((P0 *)this)->_p;", " ot = (uchar) ((P0 *)this)->_t;", "", " #ifdef HAS_UNLESS", " E_state = 0;", " #endif", " for (t2 = trans[ot][tt]; t2; t2 = t2?t2->nxt:(Trans *)0)", " {", " #ifdef HAS_UNLESS", " if (E_state > 0 && E_state != t2->e_trans)", " { break;", " }", " #endif", " if (do_transit(t2, 0))", " {", " #ifdef VERBOSE", " if (!reached[ot][t2->st])", " printf(\"depth: %%d -- claim move from %%d -> %%d\\n\",", " trpt->o_tt, ((P0 *)this)->_p, t2->st);", " #endif", " #ifdef HAS_UNLESS", " E_state = t2->e_trans;", " #endif", " if (t2->st > 0)", " { ((P0 *)this)->_p = t2->st;", " reached[ot][t2->st] = 1;", " #ifndef NOCLAIM", " if (stopstate[ot][t2->st])", " { uerror(\"end state in claim reached\");", " }", " #endif", " }", " if (now._nr_pr == 0) /* claim terminated */", " uerror(\"end state in claim reached\");", "", " #ifdef PEG", " peg[t2->forw]++;", " #endif", " trpt->o_pm |= 1;", " if (t2->atom&2)", " { Uerror(\"atomic in claim not supported in BFS\");", " }", "store_it:", "", " #endif", /* VERI */ "", " #if defined(BITSTATE)", " if (!b_store((char *)&now, vsize))", " #elif defined(MA)", " if (!g_store((char *)&now, vsize, 0))", " #else", " if (!h_store((char *)&now, vsize))", " #endif", " { static long sdone = (long) 0; long ndone;", " nstates++;", " #ifndef NOREDUCE", " trpt->tau |= 64;", /* bfs: succ definitely outside stack */ " #endif", " ndone = (ulong) (nstates/(freq));", " if (ndone != sdone && mreached%%10 != 0)", " { snapshot();", " sdone = ndone;", " #if defined(AUTO_RESIZE) && !defined(BITSTATE) && !defined(MA)", " if (nstates > ((double)(1<<(ssize+1))))", " { void resize_hashtable(void);", " resize_hashtable();", " }", " #endif", " }", " #if SYNC", " if (boq != -1)", " midrv++;", " else if (oboq != -1)", " { Trail *x;", " x = (Trail *) trpt->ostate; /* pre-rv state */", " if (x) x->o_pm |= 4; /* mark success */", " }", " #endif", " push_bfs(ntrpt, trpt->o_tt+1);", " } else", " { truncs++;", " #if defined(Q_PROVISO) && !defined(NOREDUCE) && defined(FULLSTACK)", " #if !defined(BITSTATE)", " if (Lstate && Lstate->tagged)", " { trpt->tau |= 64;", " }", " #else", " if (trpt->tau&32)", " { BFS_State *tprov;", " for (tprov = bfs_trail; tprov; tprov = tprov->nxt)", " if (tprov->onow->sv != (State *) 0", " && memcmp((uchar *)&now, (uchar *)tprov->onow->sv, vsize) == 0)", " { trpt->tau |= 64;", " break; /* state is in queue */", " } }", " #endif", " #endif", " }", " #ifdef VERI", " ((P0 *)this)->_p = tt; /* reset claim */", " if (t2)", " do_reverse(t2, 0, 0);", " else", " break;", " } }", " this = othis;", " trpt->o_pm = o_opm;", " #endif", "}", "", "void", "bfs(void)", "{ Trans *t; Trail *otrpt, *x;", " uchar _n, _m, ot, nps = 0;", " int tt, E_state;", " short II, From = (short) (now._nr_pr-1), To = BASE;", " short oboq = boq;", "", " ntrpt = (Trail *) emalloc(sizeof(Trail));", " trpt->ostate = (H_el *) 0;", " trpt->tau = 0;", "", " trpt->o_tt = -1;", " store_state(ntrpt, 0, oboq); /* initial state */", "", " while ((otrpt = pop_bfs())) /* also restores now */", " { memcpy((char *) trpt, (char *) otrpt, sizeof(Trail));", " #if defined(C_States) && (HAS_TRACK==1)", " c_revert((uchar *) &(now.c_state[0]));", " #endif", " if (trpt->o_pm & 4)", " {", " #ifdef VERBOSE", " printf(\"Revisit of atomic not needed (%%d)\\n\",", " trpt->o_pm);", /* at least 1 rv succeeded */ " #endif", " continue;", " }", " #ifndef NOREDUCE", " nps = 0;", " #endif", " if (trpt->o_pm == 8)", " { revrv++;", " if (trpt->tau&8)", " {", " #ifdef VERBOSE", " printf(\"Break atomic (pm:%%d,tau:%%d)\\n\",", " trpt->o_pm, trpt->tau);", " #endif", " trpt->tau &= ~8;", " }", " #ifndef NOREDUCE", " else if (trpt->tau&32)", /* was a preselected move */ " {", " #ifdef VERBOSE", " printf(\"Void preselection (pm:%%d,tau:%%d)\\n\",", " trpt->o_pm, trpt->tau);", " #endif", " trpt->tau &= ~32;", " nps = 1; /* no preselection in repeat */", " }", " #endif", " }", " trpt->o_pm &= ~(4|8);", " if (trpt->o_tt > mreached)", " { mreached = trpt->o_tt;", " if (mreached%%10 == 0)", " { snapshot();", " } }", " depth = trpt->o_tt;", " if (depth >= maxdepth)", " {", " #if SYNC", " Trail *x;", " if (boq != -1)", " { x = (Trail *) trpt->ostate;", " if (x) x->o_pm |= 4; /* not failing */", " }", " #endif", " truncs++;", " if (!warned)", " { warned = 1;", " printf(\"error: max search depth too small\\n\");", " }", " if (bounded)", " { uerror(\"depth limit reached\");", " }", " continue;", " }", " #ifndef NOREDUCE", " if (boq == -1 && !(trpt->tau&8) && nps == 0)", " for (II = now._nr_pr-1; II >= BASE; II -= 1)", " {", "Pickup: this = pptr(II);", " tt = (int) ((P0 *)this)->_p;", " ot = (uchar) ((P0 *)this)->_t;", " if (trans[ot][tt]->atom & 8)", /* safe */ " { t = trans[ot][tt];", " if (t->qu[0] != 0)", " { Ccheck++;", " if (!q_cond(II, t))", " continue;", " Cholds++;", " }", " From = To = II;", " trpt->tau |= 32; /* preselect marker */", " #ifdef DEBUG", " printf(\"%%3ld: proc %%d PreSelected (tau=%%d)\\n\", ", " depth, II, trpt->tau);", " #endif", " goto MainLoop;", " } }", " trpt->tau &= ~32;", /* not preselected */ " #endif", /* if !NOREDUCE */ "Repeat:", " if (trpt->tau&8) /* atomic */", " { From = To = (short ) trpt->pr;", " nlinks++;", " } else", " { From = now._nr_pr-1;", " To = BASE;", " }", "MainLoop:", " _n = _m = 0;", " for (II = From; II >= To; II -= 1)", " {", " this = pptr(II);", " tt = (int) ((P0 *)this)->_p;", " ot = (uchar) ((P0 *)this)->_t;", " #if SYNC", " /* no rendezvous with same proc */", " if (boq != -1 && trpt->pr == II)", " { continue;", " }", " #endif", " ntrpt->pr = (uchar) II;", " ntrpt->st = tt; ", " trpt->o_pm &= ~1; /* no move yet */", " #ifdef EVENT_TRACE", " trpt->o_event = now._event;", " #endif", " #ifdef HAS_PRIORITY", " if (!highest_priority(((P0 *)this)->_pid, II, t))", " { continue;", " }", " #else", " #ifdef HAS_PROVIDED", " if (!provided(II, ot, tt, t))", " { continue;", " }", " #endif", " #endif", " #ifdef HAS_UNLESS", " E_state = 0;", " #endif", " for (t = trans[ot][tt]; t; t = t->nxt)", " {", " #ifdef HAS_UNLESS", " if (E_state > 0", " && E_state != t->e_trans)", " break;", " #endif", " ntrpt->o_t = t;", "", " oboq = boq;", "", " if (!(_m = do_transit(t, II)))", " continue;", "", " trpt->o_pm |= 1; /* we moved */", " (trpt+1)->o_m = _m; /* for unsend */", " #ifdef PEG", " peg[t->forw]++;", " #endif", " #ifdef CHECK", " printf(\"%%3ld: proc %%d exec %%d, \",", " depth, II, t->forw);", " printf(\"%%d to %%d, %%s %%s %%s\",", " tt, t->st, t->tp,", " (t->atom&2)?\"atomic\":\"\",", " (boq != -1)?\"rendez-vous\":\"\");", " #ifdef HAS_UNLESS", " if (t->e_trans)", " printf(\" (escapes to state %%d)\", t->st);", " #endif", " printf(\" %%saccepting [tau=%%d]\\n\",", " (trpt->o_pm&2)?\"\":\"non-\", trpt->tau);", " #endif", " #ifdef HAS_UNLESS", " E_state = t->e_trans;", " #if SYNC>0", " if (t->e_trans > 0 && (boq != -1 /* || oboq != -1 */))", " { fprintf(efd, \"error:\ta rendezvous stmnt in the escape clause\\n\");", " fprintf(efd, \"\tof an unless stmnt is not compatible with -DBFS\\n\");", " pan_exit(1);", " }", " #endif", " #endif", " if (t->st > 0)", " { ((P0 *)this)->_p = t->st;", " }", "", " /* ptr to pred: */ ntrpt->ostate = (H_el *) otrpt;", " ntrpt->st = tt;", " if (boq == -1 && (t->atom&2)) /* atomic */", " ntrpt->tau = 8; /* record for next move */", " else", " ntrpt->tau = 0;", " store_state(ntrpt, (boq != -1 || (t->atom&2)), oboq);", " #ifdef EVENT_TRACE", " now._event = trpt->o_event;", " #endif", " /* undo move and continue */", " trpt++; /* this is where ovals and ipt are set */", " do_reverse(t, II, _m); /* restore now. */", " trpt--;", " #ifdef CHECK", " enter_critical(GLOBAL_LOCK); /* verbose mode */", " #if NCORE>1", " printf(\"cpu%%d: \", core_id);", " #endif", " printf(\"%%3lu: proc %%d \", depth, II);", " printf(\"reverses %%d, %%d to %%d,\",", " t->forw, tt, t->st);", " printf(\" %%s [abit=%%d,adepth=%%ld,\",", " t->tp, now._a_t, A_depth);", " printf(\"tau=%%d,%%d]\\n\",", " trpt->tau, (trpt-1)->tau);", " leave_critical(GLOBAL_LOCK);", " #endif", " reached[ot][t->st] = 1;", " reached[ot][tt] = 1;", "", " ((P0 *)this)->_p = tt;", " _n |= _m;", " } }", " #ifndef NOREDUCE", /* with PO */ " /* preselected - no succ definitely outside stack */", " if ((trpt->tau&32) && !(trpt->tau&64))", " { From = now._nr_pr-1; To = BASE;", " #ifdef DEBUG", " cpu_printf(\"%%3ld: proc %%d UnSelected (_n=%%d, tau=%%d)\\n\", ", " depth, II+1, (int) _n, trpt->tau);", " #endif", " _n = 0; trpt->tau &= ~32;", " if (II >= BASE)", " { goto Pickup;", " }", " goto MainLoop;", " }", " trpt->tau &= ~(32|64);", " #endif", /* PO */ " if (_n != 0)", " { continue;", " }", " #ifdef DEBUG", " printf(\"%%3ld: no move [II=%%d, tau=%%d, boq=%%d, _nr_pr=%%d]\\n\",", " depth, II, trpt->tau, boq, now._nr_pr);", " #endif", " if (boq != -1)", " { failedrv++;", " x = (Trail *) trpt->ostate; /* pre-rv state */", " if (!x)", " { continue; /* root state */", " }", " if ((x->tau&8) || (x->tau&32)) /* break atomic or preselect at parent */", " { x->o_pm |= 8; /* mark failure */", " this = pptr(otrpt->pr);", " #ifdef VERBOSE", " printf(\"\\treset state of %%d from %%d to %%d\\n\",", " otrpt->pr, ((P0 *)this)->_p, otrpt->st);", " #endif", " ((P0 *)this)->_p = otrpt->st;", " unsend(boq); /* retract rv offer */", " boq = -1;", " push_bfs(x, x->o_tt);", " #ifdef VERBOSE", " printf(\"failed rv, repush with %%d\\n\", x->o_pm);", " #endif", " }", " #ifdef VERBOSE", " else", " { printf(\"failed rv, tau at parent: %%d\\n\", x->tau);", " }", " #endif", " } else if (now._nr_pr > 0)", " {", " if ((trpt->tau&8)) /* atomic */", " { trpt->tau &= ~(1|8); /* 1=timeout, 8=atomic */", " #ifdef DEBUG", " printf(\"%%3ld: atomic step proc %%d blocks\\n\",", " depth, II+1);", " #endif", " goto Repeat;", " }", "", " if (!(trpt->tau&1)) /* didn't try timeout yet */", " { trpt->tau |= 1;", " #ifdef DEBUG", " printf(\"%%ld: timeout\\n\", depth);", " #endif", " goto MainLoop;", " }", " #ifndef VERI", " if (!noends && !a_cycles && !endstate())", " { uerror(\"invalid end state\");", " }", " #endif", " } }", "}", "#endif", /* !BFS_PAR */ "", "void", "putter(Trail *trpt, int fd)", "{ long j;", "", " if (!trpt) return;", "", " if (trpt != (Trail *) trpt->ostate)", " putter((Trail *) trpt->ostate, fd);", "", " if (trpt->o_t)", " { sprintf(snap, \"%%d:%%d:%%d\\n\",", " trcnt++, trpt->pr, trpt->o_t->t_id);", " j = strlen(snap);", " if (write(fd, snap, j) != j)", " { printf(\"pan: error writing %%s\\n\", fnm);", " pan_exit(1);", " } }", "}", "", "void", "n_ewrite(int fd, char *s, int n)", "{ if (write(fd, s, strlen(s)) != strlen(s))", " { printf(\"pan: error writing %%s\\n\", fnm);", " pan_exit(1);", " }", "}", "", "void", "nuerror(void)", "{ int fd = make_trail();", " int j;", "", " if (fd < 0) return;", " #ifdef VERI", " sprintf(snap, \"-2:%%d:-2\\n\", (uchar) ((P0 *)pptr(0))->_t);", " n_ewrite(fd, snap, strlen(snap));", " #endif", " #ifdef MERGED", " sprintf(snap, \"-4:-4:-4\\n\");", " n_ewrite(fd, snap, strlen(snap));", " #endif", " trcnt = 1;", " putter(trpt, fd);", " if (ntrpt->o_t)", /* 4.2.8 -- Alex example, missing last transition */ " { sprintf(snap, \"%%d:%%d:%%d\\n\",", " trcnt++, ntrpt->pr, ntrpt->o_t->t_id);", " j = strlen(snap);", " n_ewrite(fd, snap, j);", " }", " close(fd);", " if (errors >= upto && upto != 0)", " { wrapup();", " }", "}", "#endif", /* BFS */ 0, }; static const char *Code2d[] = { "clock_t start_time;", "#if NCORE>1", "clock_t crash_stamp;", "#endif", "#if !defined(WIN32) && !defined(WIN64)", "struct tms start_tm;", "#endif", "", "#if SYNC", "extern int q_zero(int);", "extern int not_RV(int);", "#endif", "", "void", "start_timer(void)", "{", "#if defined(WIN32) || defined(WIN64)", " start_time = clock();", "#else", " start_time = times(&start_tm);", "#endif", "}", "", "double delta_time;", "", "void", "report_time(void)", "{", " printf(\"\\npan: elapsed time %%.3g seconds\\n\", delta_time);", " if (delta_time > 0.01)", " { printf(\"pan: rate %%9.8g states/second\\n\", nstates/delta_time);", " if (verbose)", " { printf(\"pan: avg transition delay %%.5g usec\\n\",", " delta_time/(nstates+truncs));", " } }", "}", "", "void", "stop_timer(int report)", "{ clock_t stop_time;", "#if !defined(WIN32) && !defined(WIN64)", " struct tms stop_tm;", " stop_time = times(&stop_tm);", " delta_time = ((double) (stop_time - start_time)) / ((double) sysconf(_SC_CLK_TCK));", "#else", " stop_time = clock();", " delta_time = ((double) (stop_time - start_time)) / ((double) CLOCKS_PER_SEC);", "#endif", " if (readtrail || delta_time < 0.00) return;", "#if NCORE>1", " if (core_id == 0 && nstates > (double) 0)", " { printf(\"\\ncpu%%d: elapsed time %%.3g seconds (%%g states visited)\\n\",", " core_id, delta_time, nstates);", " if (delta_time > 0.01)", " { printf(\"cpu%%d: rate %%g states/second\\n\", core_id, nstates/delta_time);", " }", " { void check_overkill(void);", " check_overkill();", " } }", "#else", " if (report)", " { report_time();", " }", "#endif", "}", "", "#if NCORE>1", "#ifdef T_ALERT", "double t_alerts[17];", "", "void", "crash_report(void)", "{ int i;", " printf(\"crash alert intervals:\\n\");", " for (i = 0; i < 17; i++)", " { printf(\"%%d\\t%%g\\n\", i, t_alerts[i]);", "} }", "#endif", "", "void", "crash_reset(void)", "{ /* false alarm */", " if (crash_stamp != (clock_t) 0)", " {", "#ifdef T_ALERT", " double delta_time;", " int i;", "#if defined(WIN32) || defined(WIN64)", " delta_time = ((double) (clock() - crash_stamp)) / ((double) CLOCKS_PER_SEC);", "#else", " delta_time = ((double) (times(&start_tm) - crash_stamp)) / ((double) sysconf(_SC_CLK_TCK));", "#endif", " for (i = 0; i < 16; i++)", " { if (delta_time <= (i*30))", " { t_alerts[i] = delta_time;", " break;", " } }", " if (i == 16) t_alerts[i] = delta_time;", "#endif", " if (verbose)", " printf(\"cpu%%d: crash alert off\\n\", core_id);", " }", " crash_stamp = (clock_t) 0;", "}", "", "int", "crash_test(double maxtime)", "{ double delta_time;", " if (crash_stamp == (clock_t) 0)", " { /* start timing */", "#if defined(WIN32) || defined(WIN64)", " crash_stamp = clock();", "#else", " crash_stamp = times(&start_tm);", "#endif", " if (verbose)", " { printf(\"cpu%%d: crash detection\\n\", core_id);", " }", " return 0;", " }", "#if defined(WIN32) || defined(WIN64)", " delta_time = ((double) (clock() - crash_stamp)) / ((double) CLOCKS_PER_SEC);", "#else", " delta_time = ((double) (times(&start_tm) - crash_stamp)) / ((double) sysconf(_SC_CLK_TCK));", "#endif", " return (delta_time >= maxtime);", "}", "#endif", "", "#ifdef BFS_PAR", "int ncores = 0;", "#endif", "", "void", "do_the_search(void)", "{ int i;", " depth = mreached = 0;", " trpt = &trail[0];", "#ifdef VERI", " trpt->tau |= 4; /* the claim moves first */", "#endif", " for (i = 0; i < (int) now._nr_pr; i++)", " { P0 *ptr = (P0 *) pptr(i);", "#ifndef NP", " if (!(trpt->o_pm&2)", " && accpstate[ptr->_t][ptr->_p])", " { trpt->o_pm |= 2;", " break;", " }", "#else", " if (!(trpt->o_pm&4)", " && progstate[ptr->_t][ptr->_p])", " { trpt->o_pm |= 4;", " break;", " }", "#endif", " }", "#ifdef EVENT_TRACE", "#ifndef NP", " if (accpstate[EVENT_TRACE][now._event])", " { trpt->o_pm |= 2;", " }", "#else", " if (progstate[EVENT_TRACE][now._event])", " { trpt->o_pm |= 4;", " }", "#endif", "#endif", "#if !defined(NOCOMP) && !defined(HC)", " Mask[0] = Mask[1] = 1; /* _nr_pr, _nr_qs */", " if (!a_cycles)", " { i = &(now._a_t) - (uchar *) &now;", " Mask[i] = 1; /* _a_t */", " }", " #ifndef NOFAIR", " if (!fairness)", " { int j = 0;", " i = &(now._cnt[0]) - (uchar *) &now;", " while (j++ < NFAIR)", " Mask[i++] = 1; /* _cnt[] */", " }", " #endif", "#endif", "#ifndef NOFAIR", " if (fairness", " && (a_cycles && (trpt->o_pm&2)))", " { now._a_t = 2; /* set the A-bit */", " now._cnt[0] = now._nr_pr + 1;", /* NEW: +1 */ "#ifdef VERBOSE", " printf(\"%%3ld: fairness Rule 1, cnt=%%d, _a_t=%%d\\n\",", " depth, now._cnt[now._a_t&1], now._a_t);", "#endif", " }", "#endif", " c_stack_start = (char *) &i; /* meant to be read-only */", "#if defined(HAS_CODE) && defined (C_INIT)", " C_INIT; /* initialization of data that must precede fork() */", " c_init_done++;", "#endif", "#if defined(C_States) && (HAS_TRACK==1)", " /* capture initial state of tracked C objects */", " c_update((uchar *) &(now.c_state[0]));", "#endif", "#ifdef HAS_CODE", " if (readtrail) getrail(); /* no return */", "#endif", "#ifndef BFS_PAR", " start_timer();", "#endif", "#ifdef BFS", " #ifdef BFS_PAR", " bfs_main(ncores,0);", " #else", " bfs();", " #endif", "#else", " #if defined(C_States) && defined(HAS_STACK) && (HAS_TRACK==1)", " /* initial state of tracked & unmatched objects */", " c_stack((uchar *) &(svtack->c_stack[0]));", " #endif", " #if defined(P_RAND) || defined(T_RAND)", " srand(s_rand+HASH_NR);", /* do_the_search */ " #endif", " #if NCORE>1", " mem_get();", " #else", " new_state(); /* start 1st DFS */", " #endif", "#endif", "}", "#ifdef INLINE_REV", "uchar", "do_reverse(Trans *t, short II, uchar M)", "{ uchar _m = M;", " int tt = (int) ((P0 *)this)->_p;", "#include BACKWARD_MOVES", "R999: return _m;", "}", "#endif", "#ifndef INLINE", " #ifdef EVENT_TRACE", "static char _tp = 'n'; static int _qid = 0;", " #endif", "uchar", "do_transit(Trans *t, short II)", "{ uchar _m = 0;", " int tt = (int) ((P0 *)this)->_p;", " #ifdef M_LOSS", " uchar delta_m = 0;", " #endif", " #ifdef EVENT_TRACE", " short oboq = boq;", " uchar ot = (uchar) ((P0 *)this)->_t;", " if (II == -EVENT_TRACE) boq = -1;", "#define continue { boq = oboq; return 0; }", " #else", "#define continue return 0", "#ifdef SEPARATE", " uchar ot = (uchar) ((P0 *)this)->_t;", "#endif", " #endif", "#include FORWARD_MOVES", "P999:", " #ifdef EVENT_TRACE", " if (II == -EVENT_TRACE) boq = oboq;", " #endif", " return _m;", " #undef continue", "}", "#ifdef EVENT_TRACE", "void", "require(char tp, int qid)", "{ Trans *t;", " _tp = tp; _qid = qid;", "", " if (now._event != endevent)", " for (t = trans[EVENT_TRACE][now._event]; t; t = t->nxt)", " { if (do_transit(t, -EVENT_TRACE))", " { now._event = t->st;", " reached[EVENT_TRACE][t->st] = 1;", " #ifdef VERBOSE", " printf(\" event_trace move to -> %%d\\n\", t->st);", " #endif", " #ifndef BFS", " #ifndef NP", " if (accpstate[EVENT_TRACE][now._event])", " (trpt+1)->o_pm |= 2;", " #else", " if (progstate[EVENT_TRACE][now._event])", " (trpt+1)->o_pm |= 4;", " #endif", " #endif", " #ifdef NEGATED_TRACE", " if (now._event == endevent)", " {", " #ifndef BFS", " depth++; trpt++;", " #endif", " uerror(\"event_trace error (all events matched)\");", " #ifndef BFS", " trpt--; depth--;", " #endif", " break;", " }", " #endif", " for (t = t->nxt; t; t = t->nxt)", " { if (do_transit(t, -EVENT_TRACE))", " Uerror(\"non-determinism in event-trace\");", " }", " return;", " }", " #ifdef VERBOSE", " else", " printf(\" event_trace miss '%%c' -- %%d, %%d, %%d\\n\",", " tp, qid, now._event, t->forw);", " #endif", " }", " #ifdef NEGATED_TRACE", " now._event = endevent; /* only 1st try will count -- fixed 4.2.6 */", " #else", " #ifndef BFS", " depth++; trpt++;", " #endif", " uerror(\"event_trace error (no matching event)\");", " #ifndef BFS", " trpt--; depth--;", " #endif", " #endif", "}", "#endif", "int", "enabled(int iam, int pid)", "{ Trans *t; uchar *othis = this;", " int res = 0; int tt; uchar ot;", "", " pid += BASE;", " if (pid == iam)", " Uerror(\"used: enabled(pid=thisproc)\");", " if (pid < 0 || pid >= (int) now._nr_pr)", " return 0;", " this = pptr(pid);", " TstOnly = 1;", " tt = (int) ((P0 *)this)->_p;", " ot = (uchar) ((P0 *)this)->_t;", " for (t = trans[ot][tt]; t; t = t->nxt)", " if (do_transit(t, (short) pid))", " { res = 1;", " break;", " }", " TstOnly = 0;", " this = othis;", " return res;", "}", "#endif", "", "#ifdef HAS_PRIORITY", "int", "highest_priority(int pid, short nII, Trans *t)", "{ int i = pid; uchar *othis = this;", "", "#ifdef VERI", " if (nII == 0)", " { return 1;", /* never claim */ " }", "#endif", "#ifdef HAS_PROVIDED", " i = pid+BASE;", /* uncorrected process number */ "#endif", " if (i < 0", " || i >= (int) now._nr_pr", "#ifdef HAS_PROVIDED", " || !provided(i, (uchar) ((P0 *)this)->_t, (int) ((P0 *)this)->_p, t)", "#endif", " )", " { return 0;", " }", "", " for (i = BASE; i < now._nr_pr; i++)", /* all except never, if present */ " { this = pptr(i);", " if (i != pid+BASE", " && ((P0 *)this)->_priority > ((P0 *)pptr(pid+BASE))->_priority", "#ifdef HAS_PROVIDED", " && provided(i, (uchar) ((P0 *)this)->_t, (int) ((P0 *)this)->_p, 0)", "#endif", " && enabled(i+1, i-BASE))", /* enabled adds back BASE in 2nd arg */ " { this = othis;", " return 0;", " } }", " this = othis;", " return 1;", "}", "int", "get_priority(int pid)", "{ pid += BASE; /* 6.2.7 */", " if (pid < 0 || pid >= (int) now._nr_pr)", " return 0;", " return ((P0 *)pptr(pid))->_priority;", "}", "int", "set_priority(int pid, int pr)", "{ pid += BASE; /* 6.2.7 */", " if (pid < 0 || pid >= (int) now._nr_pr)", " {", " #ifdef VERBOSE", " printf(\"warning: bad pid %%d, no such process (set_priority)\\n\", pid);", " #endif", " return 1;", " }", " if (pr < 1 || pr > 255)", " { Uerror(\"priority is out of range\");", " }", " if (!TstOnly)", " { (trpt+1)->o_priority = ", " (((P0 *)pptr(pid))->_priority & 255) | (pid << 8);", " ((P0 *)pptr(pid))->_priority = pr;", " }", " return 1;", /* always executable */ "}", "#endif", "", "void", "snap_time(void)", "{ clock_t stop_time;", " double delta_time;", "#if !defined(WIN32) && !defined(WIN64)", " struct tms stop_tm;", " stop_time = times(&stop_tm);", " delta_time = ((double) (stop_time - start_time)) / ((double) sysconf(_SC_CLK_TCK));", "#else", " stop_time = clock();", " delta_time = ((double) (stop_time - start_time)) / ((double) CLOCKS_PER_SEC);", "#endif", " if (delta_time > 0.01)", " { printf(\"t= %%8.3g \", delta_time);", " printf(\"R= %%7.0g\", nstates/delta_time);", " }", " printf(\"\\n\");", " if (quota > 0.1 && delta_time > quota)", " { printf(\"Time limit of %%6.3g minutes exceeded\\n\", quota/60.0);", "#if NCORE>1", " fflush(stdout);", " leave_critical(GLOBAL_LOCK);", " sudden_stop(\"time-limit\");", " exit(1);", "#endif", " wrapup();", " }", "}", "void", "snapshot(void)", "{", "#ifdef BFS_PAR", " e_critical(BFS_GLOB); /* bfs_par / snapshot */", " printf(\"cpu%%d: \", who_am_i);", "#endif", "#if NCORE>1", " enter_critical(GLOBAL_LOCK); /* ncore / snapshot */", " printf(\"cpu%%d: \", core_id);", "#endif", " printf(\"Depth= %%7ld States= %%8.3g \",", "#if NCORE>1", " (long) (nr_handoffs * z_handoff) +", "#endif", " mreached, nstates);", " printf(\"Transitions= %%8.3g \", nstates+truncs);", "#ifdef MA", " printf(\"Nodes= %%7lu \", nr_states);", "#endif", " printf(\"Memory= %%9.3f\\t\", memcnt/1048576.);", " snap_time();", " fflush(stdout);", "#if NCORE>1", " leave_critical(GLOBAL_LOCK);", "#endif", "#ifdef BFS_PAR", " x_critical(BFS_GLOB);", "#endif", "}", "#ifdef SC", "void", "stack2disk(void)", "{", " if (!stackwrite", " && (stackwrite = creat(stackfile, TMODE)) < 0)", " Uerror(\"cannot create stackfile\");", "", " if (write(stackwrite, trail, DDD*sizeof(Trail))", " != DDD*sizeof(Trail))", " Uerror(\"stackfile write error -- disk is full?\");", "", " memmove(trail, &trail[DDD], (HHH-DDD+2)*sizeof(Trail));", " memset(&trail[HHH-DDD+2], 0, (omaxdepth - HHH + DDD - 2)*sizeof(Trail));", " CNT1++;", "}", "void", "disk2stack(void)", "{ long have;", "", " CNT2++;", " memmove(&trail[DDD], trail, (HHH-DDD+2)*sizeof(Trail));", "", " if (!stackwrite", " || lseek(stackwrite, -DDD* (off_t) sizeof(Trail), SEEK_CUR) == -1)", " Uerror(\"disk2stack lseek error\");", "", " if (!stackread", " && (stackread = open(stackfile, 0)) < 0)", " Uerror(\"cannot open stackfile\");", "", " if (lseek(stackread, (CNT1-CNT2)*DDD* (off_t) sizeof(Trail), SEEK_SET) == -1)", " Uerror(\"disk2stack lseek error\");", "", " have = read(stackread, trail, DDD*sizeof(Trail));", " if (have != DDD*sizeof(Trail))", " Uerror(\"stackfile read error\");", "}", "#endif", "uchar *", "Pptr(int x)", "{ if (x < 0 || x >= MAXPROC", /* does not exist */ "#ifdef TRIX", " || !processes[x])", "#else", " || !proc_offset[x])", "#endif", " return noptr;", " else", " return (uchar *) pptr(x);", "}\n", "uchar *", "Qptr(int x)", "{ if (x < 0 || x >= MAXQ", "#ifdef TRIX", " || !channels[x])", "#else", " || !q_offset[x])", "#endif", " return noqptr;", " else", " return (uchar *) qptr(x);", "}\n", "", "#if NCLAIMS>1", "void", "select_claim(int n)", "{ int m, i;", " if (n < 0 || n >= NCLAIMS)", " { uerror(\"non-existing claim\");", " } else", " { m = ((Pclaim *)pptr(0))->_n;", " if (verbose)", " { printf(\"%%d: Claim %%s (%%d), from state %%d\\n\",", " (int) depth, procname[spin_c_typ[n]],", " n, ((Pclaim *)pptr(0))->c_cur[n]);", " } else", " { printf(\"pan: ltl formula %%s\\n\",", " procname[spin_c_typ[n]]);", " }", " ((Pclaim *)pptr(0))->c_cur[m] = ((Pclaim *)pptr(0))->_p;", " ((Pclaim *)pptr(0))->_t = spin_c_typ[n];", " ((Pclaim *)pptr(0))->_p = ((Pclaim *)pptr(0))->c_cur[n];", " ((Pclaim *)pptr(0))->_n = n;", " for (i = 0; src_all[i].src != (short *) 0; i++)", " { if (src_all[i].tp == spin_c_typ[n])", " { src_claim = src_all[i].src;", " break;", " } }", " if (src_all[i].src == (short *) 0)", " { uerror(\"cannot happen: src_ln ref\");", " } }", "}", "#else", "void", "select_claim(int n)", "{ if (n != 0) uerror(\"non-existing claim\");", "}", "#endif", "int qs_empty(void);", "#if !defined(BFS) && (!defined(BITSTATE) || !defined(MA))", "#ifdef NSUCC", "int N_succ[512];", "void", "tally_succ(int cnt)", "{ if (cnt < 512) N_succ[cnt]++;", " else printf(\"tally_succ: cnt %%d exceeds range\\n\", cnt);", "}", "", "void", "dump_succ(void)", "{ int i; double sum = 0.0;", " double w_avg = 0.0;", " printf(\"Successor counts:\\n\");", " for (i = 0; i < 512; i++)", " { sum += (double) N_succ[i];", " }", " for (i = 0; i < 512; i++)", " { if (N_succ[i] > 0)", " { printf(\"%%3d\t%%10d\t(%%.4g %%%% of total)\\n\",", " i, N_succ[i], (100.0 * (double) N_succ[i])/sum);", " w_avg += (double) i * (double) N_succ[i];", " } }", " if (sum > N_succ[0])", " printf(\"mean %%.4g (without 0: %%.4g)\\n\", w_avg / sum, w_avg / (sum - (double) N_succ[0]));", "}", "#endif", "", "#ifdef P_REVERSE", " #define FROM_P (BASE)", " #define UPTO_P (now._nr_pr-1)", " #define MORE_P (II <= To)", /* p.o. only */ " #define INI_P (From-1)", /* fairness only */ " #define CNT_P (1 + (To - From))", /* P_RAND start */ " #define NDONE_P (From <= To)", /* P_RAND continue */ " #define ALL_P (II = From; II <= To; II++)", "#else", " #define FROM_P (now._nr_pr-1)", " #define UPTO_P (BASE)", " #define MORE_P (II >= BASE)", " #define INI_P (From+1)", " #define CNT_P (1 + (From - To))", " #define NDONE_P (From >= To)", " #define ALL_P (II = From; II >= To; II--)", "#endif", "", "#ifdef PERMUTED", " #define CONTINUE0 { if (reversing&2) { II = oII; } continue; }", " #define CONTINUE { if (reversing&2) { p_reorder(seed); II = oII; } continue; }", "#else", " #define CONTINUE0 { continue; }", " #define CONTINUE { continue; }", "#endif", "#ifdef PERMUTED", "uchar _permutation_[256];", "void", "set_reversed(int unused)", "{ int i, n = now._nr_pr;", " #ifdef VERBOSE", " printf(\"%%ld: Set_reversed\\n\", depth);", " #endif", " #if defined(VERI) && !defined(NOCLAIM)", " for (i = 1; i < n; i++)", " { _permutation_[i] = n-i;", " }", " #else", " for (i = 0; i < n; i++)", " { _permutation_[i] = n-1-i;", " }", " #endif", "}", "void", "set_rotated(int unused)", "{ int i, n = now._nr_pr;", " #ifdef VERBOSE", " printf(\"%%ld: Set_rotated %%d\\n\", depth, p_rotate);", " #endif", " #if defined(VERI) && !defined(NOCLAIM)", " for (i = 1; i < n; i++)", " { _permutation_[i] = 1+(i-1+p_rotate)%%(n-1);", " }", " #else", " for (i = 0; i < n; i++)", " { _permutation_[i] = (i+p_rotate)%%n;", " }", " #endif", "}", "void", "set_randrot(int unused)", "{", " if (now._nr_pr > 1)", " { p_rotate = 1+rand()%%(now._nr_pr-1);", " } else", " { p_rotate = 0;", " }", " set_rotated(0);", "}", "void", "set_permuted(int T)", "{ /* permute nrs 1..n-1, leave 0 in place */", " int i, j, k, n = now._nr_pr;", " char tmp, *in = &(_permutation_[0]);", " #ifdef VERBOSE", " printf(\"%%ld: Set_permuted %%d\\n\", depth, T);", " #endif", " srand(T);", /* set_permuted */ " for (i = 0; i < n; i++)", " { in[i] = i;", " }", " if (n > 1)", " { for (i = 0; i < n; i++)", " {", " #if defined(VERI) && !defined(NOCLAIM)", " j = 1 + rand()%%(n-1);", " k = 1 + rand()%%(n-1);", " #else", " j = rand()%%(n);", " k = rand()%%(n);", " #endif", " tmp = in[j];", " in[j] = in[k];", " in[k] = tmp;", " } }", "}", "", " #ifdef VERBOSE", " short", " get_permuted(int x)", " { printf(\"%%ld: Get_permuted %%d -> %%d\\n\",", " depth, x, _permutation_[x]);", " return (short) _permutation_[x];", " }", " #else", " #define get_permuted(x) (short) _permutation_[x]", " #endif", "", "#endif", "/*", " * new_state() is the main DFS search routine in the verifier", " * it has a lot of code ifdef-ed together to support", " * different search modes, which makes it quite unreadable.", " * if you are studying the code, use the C preprocessor", " * to generate a specific version from the pan.c source,", " * e.g. by saying:", " * gcc -E -DNOREDUCE -DBITSTATE pan.c > ppan.c", " * and then study the resulting file, instead of this version", " */", "", "void", "new_state(void)", "{ Trans *t;", " uchar _n, _m, ot;", "#ifdef T_RAND", " short ooi, eoi;", "#endif", "#ifdef PERMUTED", " short oII; uint seed;", "#endif", "#ifdef M_LOSS", " uchar delta_m = 0;", "#endif", " short II, JJ = 0, kk;", " int tt;", " short From = FROM_P, To = UPTO_P;", "#ifdef BCS", " trpt->sched_limit = 0; /* at depth=0 only */", "#endif", "Down:", "#ifdef CHECK", " cpu_printf(\"%%d: Down - %%s %%saccepting [pids %%d-%%d]\\n\",", " depth, (trpt->tau&4)?\"claim\":\"program\",", " (trpt->o_pm&2)?\"\":\"non-\", From, To);", "#endif", "#ifdef P_RAND", " trpt->p_skip = -1;", "#endif", "#ifdef SC", " if (depth > hiwater)", " { stack2disk();", " maxdepth += DDD;", " hiwater += DDD;", " trpt -= DDD;", " if(verbose)", " printf(\"zap %%ld: %%ld (maxdepth now %%ld)\\n\",", " CNT1, hiwater, maxdepth);", " }", "#endif", " trpt->tau &= ~(16|32|64); /* make sure these are off */", "#if defined(FULLSTACK) && defined(MA)", " trpt->proviso = 0;", "#endif", "#ifdef NSUCC", " trpt->n_succ = 0;", "#endif", "#if NCORE>1", " if (mem_hand_off())", " {", "#if SYNC", " (trpt+1)->o_n = 1; /* not a deadlock: as below */", "#endif", "#ifndef LOOPSTATE", " (trpt-1)->tau |= 16; /* worstcase guess: as below */", "#endif", "#if NCORE>1 && defined(FULL_TRAIL)", " if (upto > 0)", " { Pop_Stack_Tree();", " }", "#endif", " goto Up;", " }", "#endif", " if (depth >= maxdepth)", " { if (!warned)", " { warned = 1;", " printf(\"error: max search depth too small\\n\");", " }", " if (bounded)", " { uerror(\"depth limit reached\");", " }", " truncs++;", "#if SYNC", " (trpt+1)->o_n = 1; /* not a deadlock */", "#endif", "#ifndef LOOPSTATE", " (trpt-1)->tau |= 16; /* worstcase guess */", "#endif", "#if NCORE>1 && defined(FULL_TRAIL)", " if (upto > 0)", " { Pop_Stack_Tree();", " }", "#endif", " goto Up;", " }", "AllOver:", "#if (defined(FULLSTACK) && !defined(MA)) || NCORE>1", " /* if atomic or rv move, carry forward previous state */", " trpt->ostate = (trpt-1)->ostate;", "#endif", "#ifdef VERI", " if ((trpt->tau&4) || ((trpt-1)->tau&128))", "#endif", " if (boq == -1) { /* if not mid-rv */", "#ifndef SAFETY", #if 0 we want to skip nrpr, nrqs, _a_t and cnt[NFAIR] (in the case of fairness) this is calculated in S_A, but S_A subtracts 2 bytes, because nrpr and nrqs are masked in the default state comparisons so we add those two bytes back here -- in default comparisons (h_store) we skip _a_t and cnt in the -- first comparison to find a match on the base-state -- the _a_t and cnt fields are then separately updated if there was -- a match on the base state #endif " if ((now._a_t&1) && depth > A_depth)", " { int delta = S_A + 2;", " if (!memcmp((char *)&A_Root + delta, ", " (char *)&now + delta, vsize - delta))", " {", "#ifndef NOFAIR", " if (fairness && now._cnt[1] != 1) /* was > 1 */", " {", " #ifdef CHECK", " printf(\"\tfairness count non-zero\\n\");", " #endif", " /* treat as new state */", " } else", "#endif", " { depthfound = A_depth;", " #ifdef CHECK", " printf(\"matches seed\\n\");", " #endif", " #ifdef NP", " uerror(\"non-progress cycle\");", " #else", " uerror(\"acceptance cycle\");", " #endif", " #if NCORE>1 && defined(FULL_TRAIL)", " if (upto > 0)", " { Pop_Stack_Tree();", " }", " #endif", " goto Up;", " } }", " #ifdef CHECK", " else", " {", " printf(\"not seed\\n\");", " }", " #endif", " }", "#endif", " if (!(trpt->tau&8)) /* if no atomic move */", " {", "#if defined(BCS) && defined(NO_LAST) && defined(HAS_LAST)", " uchar was_last = now._last;", " now._last = 0; /* value not stored */", "#endif", "#ifdef BITSTATE", "#ifdef CNTRSTACK", /* -> bitstate, reduced, safety */ " #if defined(BCS) && defined(STORE_CTX)", " { int xj;", " for (xj = trpt->sched_limit; xj <= sched_max; xj++)", " { now._ctx = xj;", " II = b_store((char *)&now, vsize);", " trpt->j6 = j1_spin; trpt->j7 = j2_spin;", " JJ = LL[j1_spin] && LL[j2_spin];", " if (II != 0) { break; }", " }", " now._ctx = 0; /* just in case */", " }", " #else", " II = b_store((char *)&now, vsize);", " trpt->j6 = j1_spin; trpt->j7 = j2_spin;", " JJ = LL[j1_spin] && LL[j2_spin];", " #endif", "#else", " #ifdef FULLSTACK", /* b_store after onstack_now, to preserve j1-j4 */ " #if defined(BCS) && defined(STORE_CTX)", " { int xj;", " now._ctx = 0;", " JJ = onstack_now();", /* mangles j1 */ " for (xj = trpt->sched_limit; xj <= sched_max; xj++)", " { now._ctx = xj;", " II = b_store((char *)&now, vsize);", /* sets j1-j4 */ " if (II != 0) { break; }", " }", " now._ctx = 0;", " }", " #else", " JJ = onstack_now();", /* mangles j1 */ " II = b_store((char *)&now, vsize);", /* sets j1-j4 */ " #endif", " #else", " #if defined(BCS) && defined(STORE_CTX)", " { int xj;", " for (xj = trpt->sched_limit; xj <= sched_max; xj++)", " { now._ctx = xj;", " II = b_store((char *)&now, vsize);", /* sets j1-j4 */ " JJ = II; /* worstcase guess for p.o. - order corrected in 5.2.1 */", " if (II != 0) { break; }", " }", " now._ctx = 0;", " }", " #else", " II = b_store((char *)&now, vsize);", /* sets j1-j4 */ " JJ = II; /* worstcase guess for p.o. - order corrected in 5.2.1 */", " #endif", " #endif", "#endif", "#else", "#ifdef MA", " II = g_store((char *)&now, vsize, 0);", "#ifndef FULLSTACK", " JJ = II;", "#else", " JJ = (II == 2)?1:0;", "#endif", "#else", " II = h_store((char *)&now, vsize);", " /* @hash j1_spin II */", "#ifdef FULLSTACK", " JJ = (II == 2)?1:0;", "#endif", "#endif", "#endif", " kk = (II == 1 || II == 2);", /* actually, BCS implies HAS_LAST */ "#if defined(BCS) && defined(NO_LAST) && defined(HAS_LAST)", " now._last = was_last; /* restore value */", "#endif", /* II==0 new state */ /* II==1 old state */ /* II==2 on current dfs stack */ /* II==3 on 1st dfs stack */ "#ifndef SAFETY", /* with multicore we don't know which stack its on */ /* with HC there's a small chance of a false match - example fifoq 2012 */ "#if !defined(HC) && (NCORE==1 || defined (SEP_STATE))", " if (II == 2 && ((trpt->o_pm&2) || ((trpt-1)->o_pm&2)))", " #ifndef NOFAIR", " if (a_cycles && !fairness) /* 5.1.6 -- example by Hirofumi Watanabe */", " #endif", " if (depth > A_depth) /* forum example by adl */", " {", " II = 3; /* Schwoon & Esparza 2005, Gastin&Moro 2004 */", "#ifdef VERBOSE", " printf(\"state match on dfs stack\\n\");", "#endif", " goto same_case;", " }", "#endif", "#if defined(FULLSTACK) && defined(BITSTATE)", " if (!JJ && (now._a_t&1) && depth > A_depth)", " { int oj1 = j1_spin;", " uchar o_a_t = now._a_t;", " now._a_t &= ~(1|16|32);", /* 1st stack */ " if (onstack_now())", /* changes j1_spin */ " { II = 3;", "#ifdef VERBOSE", " printf(\"state match on 1st dfs stack\\n\");", "#endif", " }", " now._a_t = o_a_t;", /* restore */ " j1_spin = oj1;", " }", "#endif", " if (II == 3 && a_cycles && (now._a_t&1))", " {", "#ifndef NOFAIR", " if (fairness && now._cnt[1] != 1) /* was > 1 */", " {", " #ifdef CHECK", " printf(\"\tfairness count non-zero\\n\");", " #endif", " II = 0;", /* treat as new state */ " } else", "#endif", " {", "#ifndef BITSTATE", " nShadow--;", "#endif", "same_case: if (Lstate) depthfound = Lstate->D;", "#ifdef NP", " uerror(\"non-progress cycle\");", "#else", " uerror(\"acceptance cycle\");", "#endif", "#if NCORE>1 && defined(FULL_TRAIL)", " if (upto > 0)", " { Pop_Stack_Tree();", " }", "#endif", " goto Up;", " }", " }", "#endif", "#ifndef NOREDUCE", " #ifndef SAFETY", " #if NCORE>1 && !defined(SEP_STATE) && defined(V_PROVISO)", " if (II != 0 && (!Lstate || Lstate->cpu_id < core_id))", " { (trpt-1)->tau |= 16;", /* treat as a stack state */ " }", " #endif", " if ((II && JJ) || (II == 3))", " { /* marker for liveness proviso */", " #ifndef LOOPSTATE", " (trpt-1)->tau |= 16;", /* truncated on stack */ " #endif", " truncs2++;", " }", "#else", " #if NCORE>1 && !defined(SEP_STATE) && defined(V_PROVISO)", " if (!(II != 0 && (!Lstate || Lstate->cpu_id < core_id)))", " { /* treat as stack state */", " (trpt-1)->tau |= 16;", " } else", " { /* treat as non-stack state */", " (trpt-1)->tau |= 64;", " }", " #endif", " if (!II || !JJ)", " { /* successor outside stack */", " (trpt-1)->tau |= 64;", " }", " #endif", "#endif", "#if defined(BCS) && (defined(NOREDUCE) || !defined(SAFETY))", /* needed for BCS - cover cases where it would not otherwise be set */ " if (!II || !JJ)", " { (trpt-1)->tau |= 64;", " }", "#endif", " if (II)", " { truncs++;", "#if NCORE>1 && defined(FULL_TRAIL)", " if (upto > 0)", " { Pop_Stack_Tree();", " if (depth == 0)", " { return;", " } }", "#endif", " goto Up;", " }", " if (!kk)", " { static long sdone = (long) 0; long ndone;", " nstates++;", "#if defined(ZAPH) && defined(BITSTATE)", " zstates += (double) hfns;", "#endif", " ndone = (ulong) (nstates/(freq));", " if (ndone != sdone)", " { snapshot();", " sdone = ndone;", "#if defined(AUTO_RESIZE) && !defined(BITSTATE) && !defined(MA)", " if (nstates > ((double)(ONE_L<<(ssize+1))))", " { void resize_hashtable(void);", " resize_hashtable();", " }", "#endif", "#if defined(ZAPH) && defined(BITSTATE)", " if (zstates > ((double)(ONE_L<<(ssize-2))))", " { /* more than half the bits set */", " void zap_hashtable(void);", " zap_hashtable();", " zstates = 0;", " }", "#endif", " }", "#ifdef SVDUMP", " if (vprefix > 0)", " #ifdef SHO", /* Store Hash Only */ " /* always use the same hashfunction, for consistency across runs */", " if (HASH_NR != 0)", " { int oh = HASH_NR;", " HASH_NR = 0;", " d_hash((uchar *) &now, vsize); /* SHO - set K1 */", " HASH_NR = oh;", " }", " if (write(svfd, (uchar *) &K1, sizeof(ulong)) != sizeof(ulong))", " #else", " if (write(svfd, (uchar *) &now, vprefix) != vprefix)", " #endif", " { fprintf(efd, \"writing %%s.svd failed\\n\", PanSource);", " wrapup();", " }", "#endif", "#if defined(MA) && defined(W_XPT)", " if ((ulong) nstates%%W_XPT == 0)", " { void w_xpoint(void);", " w_xpoint();", " }", "#endif", " }", "#if defined(FULLSTACK) || defined(CNTRSTACK)", " onstack_put();", "#ifdef DEBUG2", "#if defined(FULLSTACK) && !defined(MA)", " printf(\"%%d: putting %%u (%%d)\\n\", depth,", " trpt->ostate, ", " (trpt->ostate)?trpt->ostate->tagged:0);", "#else", " printf(\"%%d: putting\\n\", depth);", "#endif", "#endif", "#else", " #if NCORE>1", " trpt->ostate = Lstate;", " #endif", "#endif", " } }", " if (depth > mreached)", " mreached = depth;", "#ifdef VERI", " if (trpt->tau&4)", "#endif", " trpt->tau &= ~(1|2); /* timeout and -request off */", " _n = 0;", "#if SYNC", " (trpt+1)->o_n = 0;", "#endif", "#ifdef VERI", " if (now._nr_pr == 0) /* claim terminated */", " { uerror(\"end state in claim reached\");", " }", " if (stopstate[((Pclaim *)pptr(0))->_t][((Pclaim *)pptr(0))->_p])", " { uerror(\"end state in claim reached\");", " }", "Stutter:", " if (trpt->tau&4) /* must make a claimmove */", " {", " #ifndef NOFAIR", " if ((now._a_t&2) /* A-bit set */", " && now._cnt[now._a_t&1] == 1)", " { now._a_t &= ~2;", " now._cnt[now._a_t&1] = 0;", " trpt->o_pm |= 16;", "#ifdef DEBUG", " printf(\"%%3d: fairness Rule 3.: _a_t = %%d\\n\",", " (int) depth, now._a_t);", "#endif", " }", " #endif", " II = 0; /* never */", " goto Veri0;", " }", "#endif", "#ifdef PERMUTED", " if (reversing&2)", " { seed = rand();", " p_reorder(seed);", " }", "#endif", "#ifndef NOREDUCE", " /* Look for a process with only safe transitions */", " /* (special rules apply in the 2nd dfs) */", " if (boq == -1 && From != To", "", "#ifdef SAFETY", " #if NCORE>1", " && (depth < z_handoff)", /* not for border states */ " #endif", " )", "#else", " #if NCORE>1", " && ((a_cycles) || (!a_cycles && depth < z_handoff))", " #endif", " #ifdef BCS", " && (sched_max > 0 || depth > BASE)", /* no po in initial state if -L0 */ " #endif", " && (!(now._a_t&1)", " || (a_cycles &&", " #ifndef BITSTATE", "#ifdef MA", "#ifdef VERI", " !((trpt-1)->proviso))", "#else", " !(trpt->proviso))", "#endif", "#else", "#ifdef VERI", " (trpt-1)->ostate &&", " !(((char *)&((trpt-1)->ostate->state))[0] & 128))", /* proviso bit in _a_t */ "#else", " !(((char *)&(trpt->ostate->state))[0] & 128))", "#endif", "#endif", " #else", "#ifdef VERI", " (trpt-1)->ostate &&", " (trpt-1)->ostate->proviso == 0)", "#else", " trpt->ostate->proviso == 0)", "#endif", " #endif", " ))", "#endif", /* SAFETY */ " /* attempt Partial Order Reduction as preselect moves */", "#ifdef BCS", " if (trpt->sched_limit < sched_max)", /* po only if we can switch */ "#endif", " { for ALL_P {", /* PO preselect */ "Resume: /* pick up here if preselect fails */", " this = pptr(II);", " tt = (int) ((P0 *)this)->_p;", " ot = (uchar) ((P0 *)this)->_t;", " if (trans[ot][tt]->atom & 8)", " { t = trans[ot][tt];", " if (t->qu[0] != 0)", " { Ccheck++;", " if (!q_cond(II, t))", " { continue;", " }", " Cholds++;", " }", " From = To = II; /* preselect process */", "#ifdef NIBIS", " t->om = 0;", "#endif", " trpt->tau |= 32; /* preselect marker */", "#ifdef DEBUG", " printf(\"%%3ld: proc %%d PreSelected (tau=%%d)\\n\", ", " depth, II, trpt->tau);", "#endif", " goto Again;", " } else", " { continue;", " } } }", " trpt->tau &= ~32;", "#endif", "#if !defined(NOREDUCE) || (defined(ETIM) && !defined(VERI))", "Again:", "#endif", " trpt->o_pm &= ~(8|16|32|64); /* clear fairness-marks */", "#ifndef NOFAIR", " if (fairness && boq == -1", "#ifdef VERI", " && (!(trpt->tau&4) && !((trpt-1)->tau&128))", "#endif", " && !(trpt->tau&8))", " { /* A_bit = 1; Cnt = N in acc states with A_bit 0 */", " if (!(now._a_t&2))", /* A-bit not set */ " { if (a_cycles && (trpt->o_pm&2))", " { /* Accepting state */", " now._a_t |= 2;", " now._cnt[now._a_t&1] = now._nr_pr + 1;", " trpt->o_pm |= 8;", "#ifdef DEBUG", " printf(\"%%3ld: fairness Rule 1: cnt=%%d, _a_t=%%d\\n\",", " depth, now._cnt[now._a_t&1], now._a_t);", "#endif", " }", " } else", /* A-bit set */ " { /* A_bit = 0 when Cnt 0 */", " if (now._cnt[now._a_t&1] == 1)", " { now._a_t &= ~2;", /* reset a-bit */ " now._cnt[now._a_t&1] = 0;", " trpt->o_pm |= 16;", "#ifdef DEBUG", " printf(\"%%3ld: fairness Rule 3: _a_t = %%d\\n\",", " depth, now._a_t);", "#endif", " } } }", "#endif", "#ifdef BCS", /* bounded context switching */ " trpt->bcs = trpt->b_pno = 0; /* initial */", " if (From != To /* not a PO or atomic move */", " && depth > BASE) /* there is a prior move */", " { trpt->b_pno = now._last + BASE;", " trpt->bcs = B_PHASE1;", " #ifdef VERBOSE", " printf(\"%%3ld: BCS phase 1 proc %%d limit %%d\\n\",", " depth, trpt->b_pno, trpt->sched_limit);", " #endif", " /* allow only process b_pno to move in this phase */", " }", "c_switch: /* jumps here with bcs == B_PHASE2 with or wo B_FORCED added */", " #ifdef VERBOSE", " printf(\"%%3ld: BCS c_switch phase=%%d pno=%%d [forced %%d]\\n\",", " depth, trpt->bcs, trpt->b_pno, (trpt->bcs&B_FORCED)?1:0);", " #endif", "#endif", "#ifdef P_RAND", " trpt->p_left = CNT_P;", " if (trpt->p_left > 1)", " { trpt->p_skip = rand() %% (trpt->p_left);", " } else", " { trpt->p_skip = -1;", " }", "r_switch:", " #ifdef VERBOSE", " printf(\"%%3ld: P_RAND r_switch p_skip=%%d p_left=%%d\\n\",", " depth, trpt->p_skip, trpt->p_left);", " #endif", "#endif", " for ALL_P {", /* Main Loop */ "#ifdef PERMUTED", " if (reversing&2)", " { oII = II;", " if (From != To)", /* not atomic or preselected */ " { II = get_permuted(II);", " } }", "#endif", "#ifdef P_RAND", " if (trpt->p_skip >= 0)", " { trpt->p_skip--; /* skip random nr of procs */", " #ifdef VERBOSE", " printf(\"%%3ld: P_RAND skipping %%d [new p_skip=%%d p_left=%%d]\\n\",", " depth, II, trpt->p_skip, trpt->p_left);", " #endif", " CONTINUE0;", " }", " if (trpt->p_left == 0)", " {", " #ifdef VERBOSE", " printf(\"%%3ld: P_RAND done at %%d\\n\", depth, II);", " #endif", " break; /* done */", " }", " #ifdef VERBOSE", " printf(\"%%3ld: P_RAND explore %%d [p_left=%%d]\\n\",", " depth, II, trpt->p_left);", " #endif", " trpt->p_left--;", "#endif", "#if SYNC", " /* no rendezvous with same proc */", " if (boq != -1 && trpt->pr == II)", " { CONTINUE0;", " }", "#endif", "#ifdef BCS", /* never claim with II==0 cannot get here */ " if ((trpt->bcs & B_PHASE1)", " && trpt->b_pno != II)", " {", " #ifdef VERBOSE", " printf(\"%%3ld: BCS NotPre II=%%d bcs=%%d pno=%%d [forced %%d]\\n\",", " depth, II, trpt->bcs, trpt->b_pno, (trpt->bcs&B_FORCED)?1:0);", " #endif", " CONTINUE0;", /* avoid context switch */ " }", " #ifdef VERBOSE", " else if ((trpt->bcs & B_PHASE1) && trpt->b_pno == II)", " printf(\"%%3ld: BCS IsPre II=%%d bcs=%%d pno=%%d [forced %%d]\\n\",", " depth, II, trpt->bcs, trpt->b_pno, (trpt->bcs&B_FORCED)?1:0);", " #endif", " if (trpt->bcs & B_PHASE2) /* 2nd phase */", " { if (trpt->b_pno == II) /* was already done in phase 1 */", " {", " #ifdef VERBOSE", " printf(\"%%3ld: BCS NoRepeat II=%%d bcs=%%d pno=%%d [forced %%d]\\n\",", " depth, II, trpt->bcs, trpt->b_pno, (trpt->bcs&B_FORCED)?1:0);", " #endif", " CONTINUE0;", " }", " if (!(trpt->bcs & B_FORCED) /* unless forced */", " && trpt->sched_limit >= sched_max)", " {", " #ifdef VERBOSE", " printf(\"%%3ld: BCS Bound II=%%d bcs=%%d pno=%%d [forced %%d]\\n\",", " depth, II, trpt->bcs, trpt->b_pno, (trpt->bcs&B_FORCED)?1:0);", " #endif", " CONTINUE0; /* enforce bound */", " } }", "#endif", "#ifdef VERI", "Veri0:", "#endif", " this = pptr(II);", " tt = (int) ((P0 *)this)->_p;", " ot = (uchar) ((P0 *)this)->_t;", "#ifdef NIBIS", " /* don't repeat a previous preselected expansion */", " /* could hit this if reduction proviso was false */", " t = trans[ot][tt];", " if (!(trpt->tau&4)", /* not claim */ " && !(trpt->tau&1)", /* not timeout */ " && !(trpt->tau&32)", /* not preselected */ " && (t->atom & 8)", /* local */ " && boq == -1", /* not inside rendezvous */ " && From != To)", /* not inside atomic seq */ " { if (t->qu[0] == 0", /* unconditional */ " || q_cond(II, t))", /* true condition */ " { _m = t->om;", " if (_m>_n||(_n>3&&_m!=0))", " { _n=_m;", " }", " CONTINUE0; /* did it before */", " } }", "#endif", " trpt->o_pm &= ~1; /* no move in this pid yet */", "#ifdef EVENT_TRACE", " (trpt+1)->o_event = now._event;", "#endif", " /* Fairness: Cnt++ when Cnt == II */", "#ifndef NOFAIR", " trpt->o_pm &= ~64; /* didn't apply rule 2 */", " if (fairness", " && boq == -1", /* not mid rv - except rcv - NEW 3.0.8 */ " && !(trpt->o_pm&32)", /* Rule 2 not in effect */ " && (now._a_t&2)", /* A-bit is set */ " && now._cnt[now._a_t&1] == II+2)", " { now._cnt[now._a_t&1] -= 1;", "#ifdef VERI", " /* claim need not participate */", " if (II == 1)", " now._cnt[now._a_t&1] = 1;", "#endif", "#ifdef DEBUG", " printf(\"%%3ld: proc %%d fairness \", depth, II);", " printf(\"Rule 2: --cnt to %%d (%%d)\\n\",", " now._cnt[now._a_t&1], now._a_t);", "#endif", " trpt->o_pm |= (32|64);", " }", "#endif", "#ifdef HAS_PRIORITY", " if (!highest_priority(((P0 *)this)->_pid, II, t))", " { CONTINUE0;", " }", "#else", " #ifdef HAS_PROVIDED", " if (!provided(II, ot, tt, t))", " { CONTINUE0;", " }", " #endif", "#endif", " /* check all trans of proc II - escapes first */", "#ifdef HAS_UNLESS", " trpt->e_state = 0;", "#endif", " (trpt+1)->pr = (uchar) II;", /* for uerror */ " (trpt+1)->st = tt;", "#ifdef T_RAND", " for (ooi = eoi = 0, t = trans[ot][tt]; t; t = t->nxt, ooi++)", " { if (strcmp(t->tp, \"else\") == 0", " #ifdef HAS_UNLESS", " || t->e_trans != 0", " #endif", " )", " { eoi++;", /* no break, must count ooi */ " } }", " if (eoi > 0)", " { t = trans[ot][tt];", " #ifdef VERBOSE", " printf(\"randomizer: suppressed, saw else or escape\\n\");", " #endif", " } else if (ooi > 0)", " { eoi = rand()%%ooi;", " #ifdef VERBOSE", " printf(\"randomizer: skip %%d in %%d\\n\", eoi, ooi);", " #endif", " for (t = trans[ot][tt]; t; t = t->nxt)", " if (eoi-- <= 0) break;", " }", "domore:", " for ( ; t && ooi > 0; t = t->nxt, ooi--)", "#else", /* ie dont randomize */ " for (t = trans[ot][tt]; t; t = t->nxt)", "#endif", " {", "#ifdef HAS_UNLESS", " /* exploring all transitions from", " * a single escape state suffices", " */", " if (trpt->e_state > 0", " && trpt->e_state != t->e_trans)", " {", "#ifdef DEBUG", " printf(\"skip 2nd escape %%d (did %%d before)\\n\",", " t->e_trans, trpt->e_state);", "#endif", " break;", " }", "#endif", " #if defined(TRIX) && !defined(TRIX_ORIG) && !defined(BFS)", " (trpt+1)->p_bup = now._ids_[II];", " #endif", " (trpt+1)->o_t = t;", /* for uerror */ "#ifdef INLINE", "#include FORWARD_MOVES", "P999: /* jumps here when move succeeds */", "#else", " if (!(_m = do_transit(t, II)))", " { continue;", " }", "#endif", "#ifdef BCS", " if (depth > BASE", /* has prior move */ " && II >= BASE", /* not claim */ " && From != To", /* not atomic or po */ " #ifndef BCS_NOFIX", " /* added 5.2.5: prior move was not po */", " && !((trpt-(BASE+1))->tau & 32)", " #endif", " && boq == -1", /* not rv */ " && (trpt->bcs & B_PHASE2)", " && trpt->b_pno != II /* context switch */", /* redundant */ " && !(trpt->bcs & B_FORCED)) /* unless forced */", " { (trpt+1)->sched_limit = 1 + trpt->sched_limit;", " #ifdef VERBOSE", " printf(\"%%3ld: up sched count to %%d\\n\", depth, (trpt+1)->sched_limit);", " #endif", " } else", " { (trpt+1)->sched_limit = trpt->sched_limit;", " #ifdef VERBOSE", " printf(\"%%3ld: keep sched count at %%d\\n\", depth, (trpt+1)->sched_limit);", " #endif", " }", "#endif", " if (boq == -1)", "#ifdef CTL", " /* for branching-time, can accept reduction only if */", " /* the persistent set contains just 1 transition */", " { if ((trpt->tau&32) && (trpt->o_pm&1))", " trpt->tau |= 16;", /* CTL */ " trpt->o_pm |= 1; /* we moved */", " }", "#else", " trpt->o_pm |= 1; /* we moved */", "#endif", "#ifdef LOOPSTATE", " if (loopstate[ot][tt])", " {", "#ifdef VERBOSE", " printf(\"exiting from loopstate:\\n\");", "#endif", " trpt->tau |= 16;", /* exiting loopstate */ " cnt_loops++;", " }", "#endif", "#ifdef PEG", " peg[t->forw]++;", "#endif", "#if defined(VERBOSE) || defined(CHECK)", "#if defined(SVDUMP)", " cpu_printf(\"%%3ld: proc %%d exec %%d \\n\", depth, II, t->t_id);", "#else", " cpu_printf(\"%%3ld: proc %%d exec %%d, %%d to %%d, %%s %%s %%s %%saccepting [tau=%%d]\\n\", ", " depth, II, t->forw, tt, t->st, t->tp,", " (t->atom&2)?\"atomic\":\"\",", " (boq != -1)?\"rendez-vous\":\"\",", " (trpt->o_pm&2)?\"\":\"non-\", trpt->tau);", "#ifdef HAS_UNLESS", " if (t->e_trans)", " cpu_printf(\"\\t(escape to state %%d)\\n\", t->st);", "#endif", "#endif", "#ifdef T_RAND", " cpu_printf(\"\\t(randomizer %%d)\\n\", ooi);", "#endif", "#endif", "#ifdef HAS_LAST", "#ifdef VERI", " if (II != 0)", "#endif", " now._last = II - BASE;", "#endif", "#ifdef HAS_UNLESS", " trpt->e_state = t->e_trans;", "#endif", " depth++; trpt++;", " trpt->pr = (uchar) II;", " trpt->st = tt;", " trpt->o_pm &= ~(2|4);", " if (t->st > 0)", " { ((P0 *)this)->_p = t->st;", "/* moved down reached[ot][t->st] = 1; */", " }", "#ifndef SAFETY", " if (a_cycles)", " {", "#if (ACCEPT_LAB>0 && !defined(NP)) || (PROG_LAB>0 && defined(HAS_NP))", " int ii;", "#endif", "#define P__Q ((P0 *)pptr(ii))", "#if ACCEPT_LAB>0", "#ifdef NP", " /* state 1 of np_ claim is accepting */", " if (((P0 *)pptr(0))->_p == 1)", " trpt->o_pm |= 2;", "#else", " for (ii = 0; ii < (int) now._nr_pr; ii++)", " { if (accpstate[P__Q->_t][P__Q->_p])", " { trpt->o_pm |= 2;", " break;", " } }", "#endif", "#endif", "#if defined(HAS_NP) && PROG_LAB>0", " for (ii = 0; ii < (int) now._nr_pr; ii++)", " { if (progstate[P__Q->_t][P__Q->_p])", " { trpt->o_pm |= 4;", " break;", " } }", "#endif", "#undef P__Q", " }", "#endif", " trpt->o_t = t; trpt->o_n = _n;", " trpt->o_ot = ot; trpt->o_tt = tt;", " trpt->o_To = To; trpt->o_m = _m;", " trpt->tau = 0;", "#ifdef PERMUTED", " if (reversing&2)", " { trpt->seed = seed;", " trpt->oII = oII;", " }", "#endif", "#if defined(T_RAND) && !defined(BFS)", " trpt->oo_i = ooi;", "#endif", " if (boq != -1 || (t->atom&2))", " { trpt->tau |= 8;", "#ifdef VERI", " /* atomic sequence in claim */", " if((trpt-1)->tau&4)", " trpt->tau |= 4;", " else", " trpt->tau &= ~4;", " } else", " { if ((trpt-1)->tau&4)", " trpt->tau &= ~4;", " else", " trpt->tau |= 4;", " }", " /* if claim allowed timeout, so */", " /* does the next program-step: */", " if (((trpt-1)->tau&1) && !(trpt->tau&4))", " trpt->tau |= 1;", "#else", " } else", " trpt->tau &= ~8;", "#endif", " if (boq == -1 && (t->atom&2))", " { From = To = II; nlinks++;", " } else", " { From = FROM_P; To = UPTO_P;", " }", "#if NCORE>1 && defined(FULL_TRAIL)", " if (upto > 0)", " { Push_Stack_Tree(II, t->t_id);", " }", "#endif", "#ifdef TRIX", " if (processes[II])", /* last move could have been a delproc */ " { processes[II]->modified = 1; /* transition in II */", " #ifdef V_TRIX", " printf(\"%%4d: process %%d modified\\n\", depth, II);", " } else", " { printf(\"%%4d: process %%d modified but gone (%%p)\\n\",", " depth, II, trpt);", " #endif", " }", "#endif", " goto Down; /* pseudo-recursion */", "Up:", "#ifdef TRIX", " #ifndef TRIX_ORIG", " #ifndef BFS", " now._ids_[trpt->pr] = trpt->p_bup;", " #endif", " #else", " if (processes[trpt->pr])", " {", " processes[trpt->pr]->modified = 1; /* reverse move */", " #ifdef V_TRIX", " printf(\"%%4d: unmodify pr %%d (%%p)\\n\",", " depth, trpt->pr, trpt);", " } else", " { printf(\"%%4d: unmodify pr %%d (gone) (%%p)\\n\",", " depth, trpt->pr, trpt);", " #endif", " }", " #endif", "#endif", "#ifdef CHECK", " cpu_printf(\"%%d: Up - %%s\\n\", depth,", " (trpt->tau&4)?\"claim\":\"program\");", "#endif", "#if NCORE>1", " iam_alive();", " #ifdef USE_DISK", " mem_drain();", " #endif", "#endif", "#if defined(MA) || NCORE>1", " if (depth <= 0) return;", " /* e.g., if first state is old, after a restart */", "#endif", "#ifdef SC", " if (CNT1 > CNT2", " && depth < hiwater - (HHH-DDD) - 2)", /* 5.1.6: was + 2 */ " {", " trpt += DDD;", " disk2stack();", " maxdepth -= DDD;", " hiwater -= DDD;", " if(verbose)", " printf(\"unzap %%ld: %%ld\\n\", CNT2, hiwater);", " }", "#endif", "#ifndef SAFETY", /* moved earlier in version 5.2.5 */ " if ((now._a_t&1) && depth <= A_depth)", " return; /* to checkcycles() */", "#endif", "#ifndef NOFAIR", " if (trpt->o_pm&128) /* fairness alg */", " { now._cnt[now._a_t&1] = trpt->bup.oval;", " _n = 1; trpt->o_pm &= ~128;", " depth--; trpt--;", "#if defined(VERBOSE) || defined(CHECK)", " printf(\"%%3ld: reversed fairness default move\\n\", depth);", "#endif", " goto Q999;", " }", "#endif", "#ifdef HAS_LAST", "#ifdef VERI", " { long d; Trail *trl;", " now._last = 0;", " for (d = 1; d < depth; d++)", " { trl = getframe(depth-d); /* was (trpt-d) */", " if (trl->pr != 0)", " { now._last = trl->pr - BASE;", " break;", " } } }", "#else", " now._last = (depth<1)?0:(trpt-1)->pr;", "#endif", "#endif", "#ifdef EVENT_TRACE", " now._event = trpt->o_event;", "#endif", " t = trpt->o_t; _n = trpt->o_n;", " ot = trpt->o_ot; II = trpt->pr;", " tt = trpt->o_tt; this = Pptr(II);", " To = trpt->o_To; _m = trpt->o_m;", "#ifdef PERMUTED", " if (reversing&2)", " { seed = trpt->seed;", " oII = trpt->oII;", " }", "#endif", "#if defined(T_RAND) && !defined(BFS)", " ooi = trpt->oo_i;", "#endif", "#ifdef INLINE_REV", " _m = do_reverse(t, II, _m);", "#else", "#include BACKWARD_MOVES", "R999: /* jumps here when done */", "#endif", "#ifdef VERBOSE", " cpu_printf(\"%%3ld: proc %%d reverses %%d, %%d to %%d\\n\",", " depth, II, t->forw, tt, t->st);", " cpu_printf(\"\\t%%s [abit=%%d,adepth=%%ld,tau=%%d,%%d]\\n\", ", " t->tp, now._a_t, A_depth, trpt->tau, (trpt-1)->tau);", "#endif", "#ifndef NOREDUCE", " /* pass the proviso tags */", " if ((trpt->tau&8) /* rv or atomic */", " && (trpt->tau&16))", " (trpt-1)->tau |= 16;", /* pass upward */ " #ifdef SAFETY", " if ((trpt->tau&8) /* rv or atomic */", " && (trpt->tau&64))", " (trpt-1)->tau |= 64;", " #endif", "#endif", "#if defined(BCS) && (defined(NOREDUCE) || !defined(SAFETY))", /* for BCS, cover cases where 64 is otherwise not handled */ " if ((trpt->tau&8)", " && (trpt->tau&64))", " (trpt-1)->tau |= 64;", "#endif", " depth--; trpt--;", "", "#ifdef NSUCC", " trpt->n_succ++;", "#endif", "#ifdef NIBIS", " (trans[ot][tt])->om = _m; /* head of list */", "#endif", " /* i.e., not set if rv fails */", " if (_m)", " { reached[ot][t->st] = 1;", " reached[ot][tt] = 1;", " }", "#ifdef HAS_UNLESS", " else trpt->e_state = 0; /* undo */", "#endif", " if (_m>_n||(_n>3&&_m!=0)) _n=_m;", " ((P0 *)this)->_p = tt;", " } /* all options */", "#ifdef T_RAND", " if (!t && ooi > 0)", /* means we skipped some initial options */ " { t = trans[ot][tt];", " #ifdef VERBOSE", " printf(\"randomizer: continue for %%d more\\n\", ooi);", " #endif", " goto domore;", " }", " #ifdef VERBOSE", " else", " printf(\"randomizer: done\\n\");", " #endif", "#endif", "#ifndef NOFAIR", " /* Fairness: undo Rule 2 */", " if ((trpt->o_pm&32)",/* rule 2 was applied */ " && (trpt->o_pm&64))",/* by this process II */ " { if (trpt->o_pm&1)",/* it didn't block */ " {", "#ifdef VERI", " if (now._cnt[now._a_t&1] == 1)", " now._cnt[now._a_t&1] = 2;", "#endif", " now._cnt[now._a_t&1] += 1;", "#ifdef VERBOSE", " printf(\"%%3ld: proc %%d fairness \", depth, II);", " printf(\"undo Rule 2, cnt=%%d, _a_t=%%d\\n\",", " now._cnt[now._a_t&1], now._a_t);", "#endif", " trpt->o_pm &= ~(32|64);", " } else", /* process blocked */ " { if (_n > 0)", /* a prev proc didn't */ " {", /* start over */ " trpt->o_pm &= ~64;", " II = INI_P;", /* after loop incr II == From */ " } } }", "#endif", "#ifdef VERI", " if (II == 0)", " { break; /* never claim */", " }", "#endif", " CONTINUE;", " } /* ALL_P */", "#ifdef NSUCC", " tally_succ(trpt->n_succ);", "#endif", "#ifdef P_RAND", " if (trpt->p_left > 0 && NDONE_P)", " { trpt->p_skip = -1; /* probably rendundant */", " #ifdef VERBOSE", " printf(\"%%3ld: P_RAND -- explore remainder\\n\", depth);", " #endif", " goto r_switch; /* explore the remaining procs */", " } else", " {", " #ifdef VERBOSE", " printf(\"%%3ld: P_RAND -- none left\\n\", depth);", " #endif", " }", "#endif", "#ifdef BCS", " if (trpt->bcs & B_PHASE1)", " { trpt->bcs = B_PHASE2; /* start 2nd phase */", " if (_n == 0 || !(trpt->tau&64)) /* pre-move unexecutable or led to stackstate */", " { trpt->bcs |= B_FORCED; /* forced switch */", " }", " #ifdef VERBOSE", " printf(\"%%3ld: BCS move to phase 2, _n=%%d %%s\\n\", depth, _n,", " (trpt->bcs & B_FORCED)?\"forced\":\"free\");", " #endif", " From = FROM_P; To = UPTO_P;", " goto c_switch;", " }", "", " if (_n == 0 /* no process could move */", " && II >= BASE /* not the never claim */", " && trpt->sched_limit >= sched_max)", " { _n = 1;", " #ifdef VERBOSE", " printf(\"%%3ld: BCS not a deadlock\\n\", depth);", " #endif", " }", "#endif", "#ifndef NOFAIR", " /* Fairness: undo Rule 2 */", " if (trpt->o_pm&32) /* remains if proc blocked */", " {", "#ifdef VERI", " if (now._cnt[now._a_t&1] == 1)", " now._cnt[now._a_t&1] = 2;", "#endif", " now._cnt[now._a_t&1] += 1;", "#ifdef VERBOSE", " printf(\"%%3ld: proc -- fairness \", depth);", " printf(\"undo Rule 2, cnt=%%d, _a_t=%%d\\n\",", " now._cnt[now._a_t&1], now._a_t);", "#endif", " trpt->o_pm &= ~32;", " }", "#ifndef NP", /* 12/97 non-progress cycles cannot be created * by stuttering extension, here or elsewhere */ " if (fairness", " && _n == 0 /* nobody moved */", "#ifdef VERI", " && !(trpt->tau&4) /* in program move */", "#endif", " && !(trpt->tau&8) /* not an atomic one */", "#ifdef ETIM", " && (trpt->tau&1) /* already tried timeout */", "#endif", "#ifndef NOREDUCE", " /* see below */", " && !((trpt->tau&32) && (_n == 0 || (trpt->tau&16)))", "#endif", " && now._cnt[now._a_t&1] > 0) /* needed more procs */", " { depth++; trpt++;", " trpt->o_pm |= 128 | ((trpt-1)->o_pm&(2|4));", " trpt->bup.oval = now._cnt[now._a_t&1];", " now._cnt[now._a_t&1] = 1;", "#ifdef VERI", " trpt->tau = 4;", "#else", " trpt->tau = 0;", "#endif", " From = FROM_P; To = UPTO_P;", "#if defined(VERBOSE) || defined(CHECK)", " printf(\"%%3ld: fairness default move \", depth);", " printf(\"(all procs block)\\n\");", "#endif", " goto Down;", " }", "#endif", "Q999: /* returns here with _n>0 when done */;", " if (trpt->o_pm&8)", " { now._a_t &= ~2;", " now._cnt[now._a_t&1] = 0;", " trpt->o_pm &= ~8;", "#ifdef VERBOSE", " printf(\"%%3ld: fairness undo Rule 1, _a_t=%%d\\n\",", " depth, now._a_t);", "#endif", " }", " if (trpt->o_pm&16)", " { now._a_t |= 2;", /* restore a-bit */ " now._cnt[now._a_t&1] = 1;", /* NEW: restore cnt */ " trpt->o_pm &= ~16;", "#ifdef VERBOSE", " printf(\"%%3ld: fairness undo Rule 3, _a_t=%%d\\n\",", " depth, now._a_t);", "#endif", " }", "#endif", "#ifndef NOREDUCE", "#ifdef SAFETY", " #ifdef LOOPSTATE", " /* at least one move that was preselected at this */", " /* level, blocked or was a loop control flow point */", " if ((trpt->tau&32) && (_n == 0 || (trpt->tau&16)))", " #else", " /* preselected move - no successors outside stack */", " if ((trpt->tau&32) && !(trpt->tau&64))", " #endif", " { From = FROM_P; To = UPTO_P; /* undo From == To */", " #ifdef DEBUG", " printf(\"%%3ld: proc %%d UnSelected (_n=%%d, tau=%%d)\\n\", ", " depth, II+1, _n, trpt->tau);", " #endif", " _n = 0; trpt->tau &= ~(16|32|64);", " if (MORE_P) /* II already restored and updated */", " { goto Resume;", " } else", " { goto Again;", " } }", "#else", " /* at least one move that was preselected at this */", " /* level, blocked or truncated at the next level */", " if ((trpt->tau&32) && (_n == 0 || (trpt->tau&16)))", " {", " #ifdef DEBUG", " printf(\"%%3ld: proc %%d UnSelected (_n=%%d, tau=%%d)\\n\", ", " depth, II+1, (int) _n, trpt->tau);", " #endif", " if (a_cycles && (trpt->tau&16))", " { if (!(now._a_t&1))", " {", " #ifdef DEBUG", " printf(\"%%3ld: setting proviso bit\\n\", depth);", " #endif", "#ifndef BITSTATE", "#ifdef MA", "#ifdef VERI", " (trpt-1)->proviso = 1;", "#else", " trpt->proviso = 1;", "#endif", "#else", "#ifdef VERI", " if ((trpt-1)->ostate)", " ((char *)&((trpt-1)->ostate->state))[0] |= 128;", "#else", " ((char *)&(trpt->ostate->state))[0] |= 128;", "#endif", "#endif", "#else", "#ifdef VERI", " if ((trpt-1)->ostate)", " (trpt-1)->ostate->proviso = 1;", "#else", " trpt->ostate->proviso = 1;", "#endif", "#endif", " From = FROM_P; To = UPTO_P;", " _n = 0; trpt->tau &= ~(16|32|64);", " goto Again; /* do full search */", " } /* else accept reduction */", " } else", " { From = FROM_P; To = UPTO_P;", " _n = 0; trpt->tau &= ~(16|32|64);", " if (MORE_P) /* II already updated */", " { goto Resume;", " } else", " { goto Again;", " } } }", "#endif", "#endif", " if (_n == 0 || ((trpt->tau&4) && (trpt->tau&2)))", " {", "#ifdef DEBUG", " cpu_printf(\"%%3ld: no move [II=%%d, tau=%%d, boq=%%d]\\n\",", " depth, II, trpt->tau, boq);", "#endif", "#if SYNC", " /* ok if a rendez-vous fails: */", " if (boq != -1) goto Done;", "#endif", " /* ok if no procs or we're at maxdepth */", " if ((now._nr_pr == 0 && (!strict || qs_empty()))", " || depth >= maxdepth-1) goto Done; /* undo change from 5.2.3 */", " if ((trpt->tau&8) && !(trpt->tau&4))", " { trpt->tau &= ~(1|8);", " /* 1=timeout, 8=atomic */", " From = FROM_P; To = UPTO_P;", "#ifdef DEBUG", " cpu_printf(\"%%3ld: atomic step proc %%d unexecutable\\n\", depth, II+1);", "#endif", "#ifdef VERI", " trpt->tau |= 4; /* switch to claim */", "#endif", " goto AllOver;", " }", "#ifdef ETIM", " if (!(trpt->tau&1)) /* didn't try timeout yet */", " {", "#ifdef VERI", " if (trpt->tau&4)", " {", "#ifndef NTIM", " if (trpt->tau&2) /* requested */", "#endif", " { trpt->tau |= 1;", " trpt->tau &= ~2;", " #ifdef DEBUG", " cpu_printf(\"%%d: timeout\\n\", depth);", " #endif", " goto Stutter;", " } }", " else", " { /* only claim can enable timeout */", " if ((trpt->tau&8)", " && !((trpt-1)->tau&4))", "/* blocks inside an atomic */ goto BreakOut;", " #ifdef DEBUG", " cpu_printf(\"%%d: req timeout\\n\",", " depth);", " #endif", " (trpt-1)->tau |= 2; /* request */", " #if NCORE>1 && defined(FULL_TRAIL)", " if (upto > 0)", " { Pop_Stack_Tree();", " }", " #endif", " goto Up;", " }", "#else", " #ifdef DEBUG", " cpu_printf(\"%%d: timeout\\n\", depth);", " #endif", " trpt->tau |= 1;", " goto Again;", "#endif", " }", "#endif", /* old location of atomic block code */ "#ifdef VERI", "BreakOut:", "#ifndef NOSTUTTER", " if (!(trpt->tau&4))", " { trpt->tau |= 4; /* claim stuttering */", " trpt->tau |= 128; /* stutter mark */", "#ifdef DEBUG", " cpu_printf(\"%%d: claim stutter\\n\", depth);", "#endif", " goto Stutter;", " }", "#else", " ;", "#endif", "#else", " if (!noends && !a_cycles && !endstate())", " { depth--; trpt--; /* new 4.2.3 */", " uerror(\"invalid end state\");", " depth++; trpt++;", " }", "#ifndef NOSTUTTER", " else if (a_cycles && (trpt->o_pm&2)) /* new 4.2.4 */", " { depth--; trpt--;", " uerror(\"accept stutter\");", " depth++; trpt++;", " }", "#endif", "#endif", " }", "Done:", " if (!(trpt->tau&8)) /* not in atomic seqs */", " {", "#ifndef MA", "#if defined(FULLSTACK) || defined(CNTRSTACK)", "#ifdef VERI", " if (boq == -1", " && (((trpt->tau&4) && !(trpt->tau&128))", " || ( (trpt-1)->tau&128)))", "#else", " if (boq == -1)", "#endif", " {", "#ifdef DEBUG2", "#if defined(FULLSTACK)", " printf(\"%%ld: zapping %%u (%%d)\\n\",", " depth, trpt->ostate,", " (trpt->ostate)?trpt->ostate->tagged:0);", "#endif", "#endif", " onstack_zap();", " }", "#endif", "#else", "#ifdef VERI", " if (boq == -1", " && (((trpt->tau&4) && !(trpt->tau&128))", " || ( (trpt-1)->tau&128)))", "#else", " if (boq == -1)", "#endif", " {", "#ifdef DEBUG", " printf(\"%%ld: zapping\\n\", depth);", "#endif", " onstack_zap();", "#ifndef NOREDUCE", " if (trpt->proviso)", " g_store((char *) &now, vsize, 1);", "#endif", " }", "#endif", "#ifndef SAFETY", " if (_n != 0", /* we made a move */ "#ifdef VERI", " /* --after-- a program-step, i.e., */", " /* after backtracking a claim-step */", " && (trpt->tau&4)", " /* with at least one running process */", " /* unless in a stuttered accept state */", " && ((now._nr_pr > 1) || (trpt->o_pm&2))", "#endif", " && !(now._a_t&1))", /* not in 2nd DFS */ " {", "#ifndef NOFAIR", " if (fairness)", /* implies a_cycles */ " {", "#ifdef VERBOSE", " cpu_printf(\"Consider check %%d %%d...\\n\",", " now._a_t, now._cnt[0]);", "#endif", #if 0 the a-bit is set, which means that the fairness counter is running -- it was started in an accepting state. we check that the counter reached 1, which means that all processes moved least once. this means we can start the search for cycles - to be able to return to this state, we should be able to run down the counter to 1 again -- which implies a visit to the accepting state -- even though the Seed state for this search is itself not necessarily accepting #endif " if ((now._a_t&2) /* A-bit */", " && (now._cnt[0] == 1))", " checkcycles();", " } else", "#endif", " if (a_cycles && (trpt->o_pm&2))", " checkcycles();", " }", "#endif", " }", " if (depth > 0)", " {", "#if NCORE>1 && defined(FULL_TRAIL)", " if (upto > 0)", " { Pop_Stack_Tree();", " }", "#endif", " goto Up;", " }", "}\n", "#else", "void new_state(void) { /* place holder */ }", "#endif", /* BFS */ "", "void", "spin_assert(int a, char *s, int ii, int tt, Trans *t)", "{", " if (!a && !noasserts)", " { char bad[1024];", " strcpy(bad, \"assertion violated \");", " if (strlen(s) > 1000)", " { strncpy(&bad[19], (const char *) s, 1000);", " bad[1019] = '\\0';", " } else", " strcpy(&bad[19], s);", " uerror(bad);", " }", "}", "#ifndef NOBOUNDCHECK", "int", "Boundcheck(int x, int y, int a1, int a2, Trans *a3)", "{", " spin_assert((x >= 0 && x < y), \"- invalid array index\",", " a1, a2, a3);", " return x;", "}", "#endif", "int do_hashgen = 0;", "void", "wrap_stats(void)", "{", " if (nShadow>0)", " printf(\"%%9.8g states, stored (%%g visited)\\n\",", " nstates - nShadow, nstates);", " else", " printf(\"%%9.8g states, stored\\n\", nstates);", "#ifdef BFS_PAR", " if (bfs_punt > 0)", " printf(\"%%9.8g states lost (lack of queue memory)\\n\", (double) bfs_punt);", "#endif", "#ifdef BFS", " #if SYNC", " printf(\" %%8g nominal states (- rv and atomic)\\n\", nstates-midrv-nlinks+revrv);", " printf(\" %%8g rvs succeeded\\n\", midrv-failedrv);", " #else", " printf(\" %%8g nominal states (stored-atomic)\\n\", nstates-nlinks);", " #endif", " #ifdef DEBUG", " printf(\" %%8g midrv\\n\", midrv);", " printf(\" %%8g failedrv\\n\", failedrv);", " printf(\" %%8g revrv\\n\", revrv);", " #endif", "#endif", " printf(\"%%9.8g states, matched\\n\", truncs);", "#ifdef CHECK", " printf(\"%%9.8g matches within stack\\n\",truncs2);", "#endif", " if (nShadow>0)", " printf(\"%%9.8g transitions (= visited+matched)\\n\",", " nstates+truncs);", " else", " printf(\"%%9.8g transitions (= stored+matched)\\n\",", " nstates+truncs);", " printf(\"%%9.8g atomic steps\\n\", nlinks);", " if (nlost) printf(\"%%g lost messages\\n\", (double) nlost);", "", "#ifndef BITSTATE", " #ifndef MA", " printf(\"hash conflicts: %%9.8g (resolved)\\n\", hcmp);", " #if !defined(AUTO_RESIZE) && !defined(BFS_PAR)", " if (hcmp > (double) (1< 1.0)", " { fp = 100. / fp;", " while (fp > 2.) { fi++; fp /= 2.; }", " if (fi > 0)", " { printf(\" (hint: rerun with -w%%d to reduce runtime)\",", " ssize-fi);", " } }", " printf(\"\\n\");", " }", " #endif", " #endif", "#else", "#ifdef CHECK", " printf(\"%%8g states allocated for dfs stack\\n\", ngrabs);", "#endif", " if (udmem)", " printf(\"\\nhash factor: %%4g (best if > 100.)\\n\\n\",", " (double)(((double) udmem) * 8.0) / (double) nstates);", " else", " printf(\"\\nhash factor: %%4g (best if > 100.)\\n\\n\",", " ((double)(((ulong)1)<<(ssize-10)) / (double) nstates) * 1024.0);", /* the -10 and *1024 stuff is to avoid overflow */ " printf(\"bits set per state: %%u (-k%%u)\\n\", hfns, hfns);", " if (do_hashgen)", " printf(\"hash polynomial used: 0x%%.8x\\n\", HASH_CONST[HASH_NR]);", " if (s_rand != 12345)", " printf(\"random seed used: %u\\n\", (uint) (s_rand-1));", "#endif", "#if defined(BFS_DISK) && !defined(BFS_PAR)", " printf(\"bfs disk reads: %%ld writes %%ld -- diff %%ld\\n\",", " bfs_dsk_reads, bfs_dsk_writes, bfs_dsk_writes-bfs_dsk_reads);", " if (bfs_dsk_read >= 0) (void) close(bfs_dsk_read);", " if (bfs_dsk_write >= 0) (void) close(bfs_dsk_write);", " (void) unlink(\"pan_bfs_dsk.tmp\");", "#endif", "}", "", "void", "wrapup(void)", "{ double nr1, nr2, nr3 = 0.0, nr4, nr5 = 0.0;", "#ifdef BFS_PAR", " if (who_am_i != 0)", " { pan_exit(0);", " }", "#endif", "#if NCORE>1", " if (verbose) cpu_printf(\"wrapup -- %%d error(s)\\n\", errors);", " if (core_id != 0)", " {", " #ifdef USE_DISK", " void dsk_stats(void);", " dsk_stats();", " #endif", " if (search_terminated != NULL)", " { *search_terminated |= 2; /* wrapup */", " }", " exit(0); /* normal termination, not an error */", " }", "#endif", "#if !defined(WIN32) && !defined(WIN64)", " signal(SIGINT, SIG_DFL);", "#endif", " printf(\"\\n(%%s)\\n\", SpinVersion);", " if (!done) printf(\"Warning: Search not completed\\n\");", "#if defined(BFS_PAR) && !defined(BITSTATE)", " if (bfs_punt > 0) printf(\"Warning: Search incomplete\\n\");", "#endif", "#ifdef SC", " (void) unlink((const char *)stackfile);", "#endif", "#ifdef BFS_PAR", " printf(\" + Multi-Core (using %%d cores)\\n\", Cores);", " #ifdef BFS_SEP_HASH", " printf(\" + Seperate Hash Tables\\n\");", " #endif", " #ifdef BFS_DISK", " printf(\" + Disk storage\\n\");", " #endif", "#endif", "#if NCORE>1", " if (a_cycles)", " { printf(\" + Multi-Core (NCORE=%%d)\\n\", NCORE);", " } else", " { printf(\" + Multi-Core (NCORE=%%d -z%%ld)\\n\", NCORE, z_handoff);", " }", "#endif", "#ifdef BFS", " printf(\" + Breadth-First Search\\n\");", "#endif", "#ifndef NOREDUCE", " printf(\" + Partial Order Reduction\\n\");", "#endif", "#ifdef PERMUTED", " printf(\" + Process Scheduling Permutation\\n\");", "#endif", "#ifdef P_REVERSE", " printf(\" + Reverse Depth-First Search Order\\n\");", "#endif", " if (t_reverse)", " printf(\" + Reverse Transition Ordering\\n\");", "#ifdef T_RAND", " printf(\" + Randomized Transition Ordering\\n\");", "#endif", "#ifdef P_RAND", " printf(\" + Randomized Process Ordering\\n\");", "#endif", "#ifdef BCS", " printf(\" + Scheduling Restriction (-L%%d)\\n\", sched_max);", "#endif", "#ifdef TRIX", " printf(\" + Tree Index Compression\\n\");", "#endif", "#ifdef COLLAPSE", " printf(\" + Compression\\n\");", "#endif", "#ifdef MA", " printf(\" + Graph Encoding (-DMA=%%d)\\n\", MA);", " #ifdef R_XPT", " printf(\" Restarted from checkpoint %%s.xpt\\n\", PanSource);", " #endif", "#endif", "#ifdef CHECK", " #ifdef FULLSTACK", " printf(\" + FullStack Matching\\n\");", " #endif", " #ifdef CNTRSTACK", " printf(\" + CntrStack Matching\\n\");", " #endif", "#endif", "#ifdef PERMUTED", " if (reversing & 2)", " { if (p_reorder == set_permuted)", " { printf(\" + Permuted\\n\");", " }", " if (p_reorder == set_reversed)", " { printf(\" + Reversed\\n\");", " }", " if (p_reorder == set_rotated)", " { printf(\" + Rotated %%d\\n\", p_rotate);", " }", " if (p_reorder == set_randrot)", " { printf(\" + RandRotated\\n\");", " } }", "#endif", "#ifdef BITSTATE", " printf(\"\\nBit statespace search for:\\n\");", "#else", " #ifdef HC", " printf(\"\\nHash-Compact %%d search for:\\n\", HC);", " #else", " printf(\"\\nFull statespace search for:\\n\");", " #endif", "#endif", "#ifdef EVENT_TRACE", "#ifdef NEGATED_TRACE", " printf(\"\tnotrace assertion \t+\\n\");", "#else", " printf(\"\ttrace assertion \t+\\n\");", "#endif", "#endif", "#ifdef VERI", " printf(\"\tnever claim \t+\");", " printf(\" (%%s)\\n\", procname[((Pclaim *)pptr(0))->_t]);", " printf(\"\tassertion violations\t\");", " if (noasserts)", " printf(\"- (disabled by -A flag)\\n\");", " else", " printf(\"+ (if within scope of claim)\\n\");", "#else", "#ifdef NOCLAIM", " printf(\"\tnever claim \t- (not selected)\\n\");", "#else", " printf(\"\tnever claim \t- (none specified)\\n\");", "#endif", " printf(\"\tassertion violations\t\");", " if (noasserts)", " printf(\"- (disabled by -A flag)\\n\");", " else", " printf(\"+\\n\");", "#endif", "#ifndef SAFETY", "#ifdef NP", " printf(\"\tnon-progress cycles \t\");", "#else", " printf(\"\tacceptance cycles \t\");", "#endif", " if (a_cycles)", " printf(\"+ (fairness %%sabled)\\n\",", " fairness?\"en\":\"dis\");", " else printf(\"- (not selected)\\n\");", "#else", " #if !defined(BFS_PAR) || !defined(L_BOUND)", " printf(\"\tcycle checks \t- (disabled by -DSAFETY)\\n\");", " #else", " printf(\"\tcycle checks \t+ (bound %%d)\\n\", L_bound);", " #endif", "#endif", "#ifdef VERI", " printf(\"\tinvalid end states\t- \");", " printf(\"(disabled by \");", " if (noends)", " printf(\"-E flag)\\n\\n\");", " else", " printf(\"never claim)\\n\\n\");", "#else", " printf(\"\tinvalid end states\t\");", " if (noends)", " printf(\"- (disabled by -E flag)\\n\\n\");", " else", " printf(\"+\\n\\n\");", "#endif", " printf(\"State-vector %%d byte, depth reached %%ld\", hmax,", "#if NCORE>1", " (nr_handoffs * z_handoff) +", "#endif", " mreached);", " printf(\", errors: %%d\\n\", errors);", " fflush(stdout);", "#ifdef MA", " if (done)", " { extern void dfa_stats(void);", " if (maxgs+a_cycles+2 < MA)", " printf(\"MA stats: -DMA=%%d is sufficient\\n\",", " maxgs+a_cycles+2);", " dfa_stats();", " }", "#endif", " wrap_stats();", "#ifdef CHECK", " printf(\"stackframes: %%d/%%d\\n\\n\", smax, svmax);", " printf(\"stats: fa %%ld, fh %%ld, zh %%ld, zn %%ld - \",", " Fa, Fh, Zh, Zn);", " printf(\"check %%ld holds %%ld\\n\", Ccheck, Cholds);", " printf(\"stack stats: puts %%ld, probes %%ld, zaps %%ld\\n\",", " PUT, PROBE, ZAPS);", "#else", " printf(\"\\n\");", "#endif", "", "#if !defined(BITSTATE) && defined(NOCOMP)", " if (!verbose) { goto jump_here; }", /* added 5.2.0 */ "#endif", "", "#if 1", /* omitted 5.2.0: defined(BITSTATE) || !defined(NOCOMP) */ " nr1 = (nstates-nShadow)*", " (double)(hmax+sizeof(H_el)-sizeof(unsigned));", " #ifdef BFS", " nr2 = 0.0;", " #else", " nr2 = (double) ((maxdepth+3)*sizeof(Trail));", " #endif", " #ifndef BITSTATE", "#if !defined(MA) || defined(COLLAPSE)", " nr3 = (double) (ONE_L<1 && !defined(SEP_STATE)", " tmp_nr -= ((double) NCORE * LWQ_SIZE) + GWQ_SIZE;", " #endif", " if (tmp_nr < 0.0) tmp_nr = 0.;", " printf(\"Stats on memory usage (in Megabytes):\\n\");", " printf(\"%%9.3f\tequivalent memory usage for states\",", " nr1/1048576.); /* 1024*1024=1048576 */", " printf(\" (stored*(State-vector + overhead))\\n\");", " #if NCORE>1 && !defined(WIN32) && !defined(WIN64)", " printf(\"%%9.3f\tshared memory reserved for state storage\\n\",", " mem_reserved/1048576.);", " #ifdef SEP_HEAP", " printf(\"\t\tin %%d local heaps of %%7.3f MB each\\n\",", " NCORE, mem_reserved/(NCORE*1048576.));", " #endif", " printf(\"\\n\");", " #endif", " #ifdef BITSTATE", " if (udmem)", " printf(\"%%9.3f\tmemory used for hash array (-M%%ld)\\n\",", " nr3/1048576., udmem/(1024L*1024L));", " else", " printf(\"%%9.3f\tmemory used for hash array (-w%%d)\\n\",", " nr3/1048576., ssize);", " if (nr5 > 0.0)", " printf(\"%%9.3f\tmemory used for bit stack\\n\",", " nr5/1048576.);", " remainder = remainder - nr3 - nr5;", " #else", " #ifndef USE_TDH", " printf(\"%%9.3f\tactual memory usage for states\",", " tmp_nr/1048576.);", " remainder -= tmp_nr;", " if (tmp_nr > 0.)", " { if (tmp_nr < nr1) ", " { printf(\" (compression: %%.2f%%%%)\\n\",", " (100.0*tmp_nr)/nr1);", " } else", " { printf(\"\\n\");", " }", " } else", " { printf(\" (less than 1k)\\n\");", " }", " #ifndef MA", " if (tmp_nr > 0. && tmp_nr < nr1)", " { printf(\" \tstate-vector as stored = %%.0f byte\",", " (tmp_nr)/(nstates-nShadow) -", " (double) (sizeof(H_el) - sizeof(unsigned)));", " printf(\" + %%ld byte overhead\\n\",", " (long int) sizeof(H_el)-sizeof(unsigned));", " }", " #endif", " #endif", " #if !defined(MA) || defined(COLLAPSE)", " #ifdef BFS_PAR", " printf(\"%%9.3f\tshared memory used for hash table (-w%%d)\\n\",", " ((double) bfs_pre_allocated)/1048576., ssize);", " #else", " printf(\"%%9.3f\tmemory used for hash table (-w%%d)\\n\",", " nr3/1048576., ssize);", " remainder -= nr3;", " #endif", " #endif", " #endif", " #ifndef BFS", " printf(\"%%9.3f\tmemory used for DFS stack (-m%%ld)\\n\",", " nr2/1048576., maxdepth);", " remainder -= nr2;", " #endif", " #if NCORE>1", " remainder -= ((double) NCORE * LWQ_SIZE) + GWQ_SIZE;", " printf(\"%%9.3f\tshared memory used for work-queues\\n\",", " (GWQ_SIZE + (double) NCORE * LWQ_SIZE) /1048576.);", " printf(\"\t\tin %%d queues of %%7.3f MB each\",", " NCORE, (double) LWQ_SIZE /1048576.);", " #ifndef NGQ", " printf(\" + a global q of %%7.3f MB\\n\",", " (double) GWQ_SIZE / 1048576.);", " #else", " printf(\"\\n\");", " #endif", " #endif", " if (remainder - fragment > 1048576.)", " { printf(\"%%9.3f\tother (proc and chan stacks)\\n\",", " (remainder-fragment)/1048576.);", " }", " if (fragment > 1048576.)", " { printf(\"%%9.3f\tmemory lost to fragmentation\\n\",", " fragment/1048576.);", " }", " #ifdef BFS_PAR", " printf(\"%%9.3f\ttotal non-shared memory usage\\n\\n\",", " memcnt/1048576.);", " #else", " printf(\"%%9.3f\ttotal actual memory usage\\n\\n\",", " memcnt/1048576.);", " #endif", " }", " #ifndef MA", " else", " #endif", "#endif", "#if !defined(BITSTATE) && defined(NOCOMP)", "jump_here:", "#endif", "#ifndef MA", " printf(\"%%9.3f\tmemory usage (Mbyte)\\n\",", " memcnt/1048576.);", "#endif", "#ifdef BFS_PAR", " bfs_report_mem();", "#else", " printf(\"\\n\");", "#endif", "#ifdef COLLAPSE", " printf(\"nr of templates: [ 0:globals 1:chans 2:procs ]\\n\");", " printf(\"collapse counts: [ \");", " { int i; for (i = 0; i < 256+2; i++)", " if (ncomps[i] != 0)", " printf(\"%%d:%%lu \", i, ncomps[i]);", " printf(\"]\\n\");", " }", "#endif", " #ifdef TRIX", " if (verbose)", " { int i;", " printf(\"TRIX counts:\\n\");", " printf(\" processes: \");", " for (i = 0; i < MAXPROC; i++)", " if (_p_count[i] != 0)", " { printf(\"%%3d:%%ld \",", " i, _p_count[i]);", " }", " printf(\"\\n channels : \");", " for (i = 0; i < MAXQ; i++)", " if (_c_count[i] != 0)", " { printf(\"%%3d:%%ld \",", " i, _c_count[i]);", " }", " printf(\"\\n\\n\");", " }", " #endif", " if ((done || verbose) && !no_rck) do_reach();", "#ifdef PEG", " { int i;", " printf(\"\\nPeg Counts (transitions executed):\\n\");", " for (i = 1; i < NTRANS; i++)", " { if (peg[i]) putpeg(i, peg[i]);", " } }", "#endif", "#ifdef VAR_RANGES", " dumpranges();", "#endif", "#ifdef SVDUMP", " if (vprefix > 0) close(svfd);", "#endif", "#ifdef LOOPSTATE", " printf(\"%%g loopstates hit\\n\", cnt_loops);", "#endif", "#ifdef NSUCC", " dump_succ();", "#endif", "#if NCORE>1 && defined(T_ALERT)", " crash_report();", "#endif", "#ifndef BFS_PAR", " pan_exit(0);", "#endif", "}\n", "void", "stopped(int arg)", "{", "#ifdef BFS_PAR", " bfs_shutdown(\"interrupted\");", "#endif", " printf(\"Interrupted\\n\");", "#if NCORE>1", " was_interrupted = 1;", "#endif", " wrapup();", " pan_exit(0);", "}", "", "/*", " * super fast hash, based on Paul Hsieh's function", " * http://www.azillionmonkeys.com/qed/hash.html", " */", "#include ", /* for uint32_t etc */ " #undef get16bits", " #if defined(__GNUC__) && defined(__i386__)", " #define get16bits(d) (*((const uint16_t *) (d)))", " #else", " #define get16bits(d) ((((uint32_t)(((const uint8_t *)(d))[1])) << 8)\\", " +(uint32_t)(((const uint8_t *)(d))[0]) )", " #endif", "", "void", "d_sfh(uchar *s, int len)", /* sets one 32-bit number, in K1 */ "{ uint32_t h = len, tmp;", " int rem;", "", " rem = len & 3;", " len >>= 2;", "", " for ( ; len > 0; len--)", " { h += get16bits(s);", " tmp = (get16bits(s+2) << 11) ^ h;", " h = (h << 16) ^ tmp;", " s += 2*sizeof(uint16_t);", " h += h >> 11;", " }", " switch (rem) {", " case 3: h += get16bits(s);", " h ^= h << 16;", " h ^= s[sizeof(uint16_t)] << 18;", " h += h >> 11;", " break;", " case 2: h += get16bits(s);", " h ^= h << 11;", " h += h >> 17;", " break;", " case 1: h += *s;", " h ^= h << 10;", " h += h >> 1;", " break;", " }", " h ^= h << 3;", " h += h >> 5;", " h ^= h << 4;", " h += h >> 17;", " h ^= h << 25;", " h += h >> 6;", "", " K1 = h;", "}", "", "#if WS>4", "/* 64-bit Jenkins hash, 1997", " * http://burtleburtle.net/bob/c/lookup8.c", " */", "#define mix(a,b,c) \\", "{ a -= b; a -= c; a ^= (c>>43); \\", " b -= c; b -= a; b ^= (a<<9); \\", " c -= a; c -= b; c ^= (b>>8); \\", " a -= b; a -= c; a ^= (c>>38); \\", " b -= c; b -= a; b ^= (a<<23); \\", " c -= a; c -= b; c ^= (b>>5); \\", " a -= b; a -= c; a ^= (c>>35); \\", " b -= c; b -= a; b ^= (a<<49); \\", " c -= a; c -= b; c ^= (b>>11); \\", " a -= b; a -= c; a ^= (c>>12); \\", " b -= c; b -= a; b ^= (a<<18); \\", " c -= a; c -= b; c ^= (b>>22); \\", "}", "#else", "/* 32-bit Jenkins hash, 2006", " * http://burtleburtle.net/bob/c/lookup3.c", " */", "#define rot(x,k) (((x)<<(k))|((x)>>(32-(k))))", "", "#define mix(a,b,c) \\", "{ a -= c; a ^= rot(c, 4); c += b; \\", " b -= a; b ^= rot(a, 6); a += c; \\", " c -= b; c ^= rot(b, 8); b += a; \\", " a -= c; a ^= rot(c,16); c += b; \\", " b -= a; b ^= rot(a,19); a += c; \\", " c -= b; c ^= rot(b, 4); b += a; \\", "}", "", "#define final(a,b,c) \\", "{ c ^= b; c -= rot(b,14); \\", " a ^= c; a -= rot(c,11); \\", " b ^= a; b -= rot(a,25); \\", " c ^= b; c -= rot(b,16); \\", " a ^= c; a -= rot(c,4); \\", " b ^= a; b -= rot(a,14); \\", " c ^= b; c -= rot(b,24); \\", "}", "#endif", "", "void", "d_hash(uchar *kb, int nbytes)", /* sets two 64-bit or 32-bit nrs, depending on WS */ "{ uint8_t *bp;", "#if WS>4", " uint64_t a = 0, b, c, n;", " const uint64_t *k = (uint64_t *) kb;", "#else", " uint32_t a = 0, b, c, n;", " const uint32_t *k = (uint32_t *) kb;", "#endif", " n = nbytes/WS; /* nr of words */", " /* extend to multiple of words, if needed */", " a = WS - (nbytes %% WS);", " if (a > 0 && a < WS)", " { n++;", " bp = kb + nbytes;", " switch (a) {", "#if WS>4", " case 7: *bp++ = 0; /* fall thru */", " case 6: *bp++ = 0; /* fall thru */", " case 5: *bp++ = 0; /* fall thru */", " case 4: *bp++ = 0; /* fall thru */", "#endif", " case 3: *bp++ = 0; /* fall thru */", " case 2: *bp++ = 0; /* fall thru */", " case 1: *bp = 0;", " case 0: break;", " } }", "#if WS>4", " b = HASH_CONST[HASH_NR];", " c = 0x9e3779b97f4a7c13LL; /* arbitrary value */", " while (n >= 3)", " { a += k[0];", " b += k[1];", " c += k[2];", " mix(a,b,c);", " n -= 3;", " k += 3;", " }", " c += (((uint64_t) nbytes)<<3);", " switch (n) {", " case 2: b += k[1];", " case 1: a += k[0];", " case 0: break;", " }", " mix(a,b,c);", "#else", /* 32 bit version: */ " a = c = 0xdeadbeef + (n<<2);", " b = HASH_CONST[HASH_NR];", " while (n > 3)", " { a += k[0];", " b += k[1];", " c += k[2];", " mix(a,b,c);", " n -= 3;", " k += 3;", " }", " switch (n) { ", " case 3: c += k[2];", " case 2: b += k[1];", " case 1: a += k[0];", " final(a,b,c);", " case 0: break;", " }", "#endif", " j1_spin = c&nmask; j3_spin = a&7; /* 1st bit */", " j2_spin = b&nmask; j4_spin = (a>>3)&7; /* 2nd bit */", " K1 = c; K2 = b;", "}", "", "#if defined(MURMUR) && (WS==8)", "/* public-domain, 64-bit MurmurHash3, by Austin Appleby */", "/* https://code.google.com/p/smhasher/wiki/MurmurHash3 */", "void", "m_hash(uchar *v, int len)", "{ uint8_t *bp, *data = (uint8_t*) v;", " int i, nblocks = len / 16;", "", " uint64_t h1 = HASH_CONST[HASH_NR];", " uint64_t h2 = 0x9e3779b97f4a7c13LL;", "", " uint64_t c1 = 0x87c37b91114253d5;", " uint64_t c2 = 0x4cf5ad432745937f;", "", " uint64_t *blocks = (uint64_t *)(data);", "", " /* guarantee a multiple of 16 bytes */", " i = 16 - (len %% 16);", " if (i > 0 && i < 16)", " { nblocks++;", " bp = v + len;", " switch (i) {", " case 15: *bp++ = 0; /* fall thru */", " case 14: *bp++ = 0;", " case 13: *bp++ = 0;", " case 12: *bp++ = 0;", " case 11: *bp++ = 0;", " case 10: *bp++ = 0;", " case 9: *bp++ = 0;", " case 8: *bp++ = 0;", " case 7: *bp++ = 0;", " case 6: *bp++ = 0;", " case 5: *bp++ = 0;", " case 4: *bp++ = 0;", " case 3: *bp++ = 0;", " case 2: *bp++ = 0;", " case 1: *bp = 0;", " case 0: break;", " } }", "", " for (i = 0; i < nblocks; i++)", " { uint64_t k1 = blocks[i*2];", " uint64_t k2 = blocks[i*2+1];", "", " k1 *= c1;", " k1 = (k1 << 31) | (k1 >> 33);", " k1 *= c2;", " h1 ^= k1;", "", " h1 = (h1 << 27) | (h1 >> 37);", " h1 += h2;", " h1 = h1 * 5 + 0x52dce729;", "", " k2 *= c2;", " k2 = (k2 << 33) | (k2 >> 31);", " k2 *= c1;", " h2 ^= k2;", "", " h2 = (h2 << 31) | (h2 >> 33);", " h2 += h1;", " h2 = h2 * 5 + 0x38495ab5;", " }", "", " uint8_t *tail = (uint8_t*)(data + (nblocks * 16));", "", " uint64_t k1 = 0;", " uint64_t k2 = 0;", "", " switch(len & 15) {", " case 15: k2 ^= ((uint64_t) tail[14]) << 48; break;", " case 14: k2 ^= ((uint64_t) tail[13]) << 40; break;", " case 13: k2 ^= ((uint64_t) tail[12]) << 32; break;", " case 12: k2 ^= ((uint64_t) tail[11]) << 24; break;", " case 11: k2 ^= ((uint64_t) tail[10]) << 16; break;", " case 10: k2 ^= ((uint64_t) tail[ 9]) << 8; break;", " case 9: k2 ^= ((uint64_t) tail[ 8]) << 0; break;", " k2 *= c2;", " k2 = (k2 << 33) | (k2 >> 31);", " k2 *= c1;", " h2 ^= k2; break;", " case 8: k1 ^= ((uint64_t) tail[7]) << 56; break;", " case 7: k1 ^= ((uint64_t) tail[6]) << 48; break;", " case 6: k1 ^= ((uint64_t) tail[5]) << 40; break;", " case 5: k1 ^= ((uint64_t) tail[4]) << 32; break;", " case 4: k1 ^= ((uint64_t) tail[3]) << 24; break;", " case 3: k1 ^= ((uint64_t) tail[2]) << 16; break;", " case 2: k1 ^= ((uint64_t) tail[1]) << 8; break;", " case 1: k1 ^= ((uint64_t) tail[0]) << 0; break;", " k1 *= c1;", " k1 = (k1 << 31) | (k1 >> 33);", " k1 *= c2;", " h1 ^= k1;", " };", "", " h1 ^= len; h2 ^= len;", " h1 += h2;", " h2 += h1;", " h1 ^= h1 >> 33;", " h1 *= 0xff51afd7ed558ccd;", " h1 ^= h1 >> 33;", " h1 *= 0xc4ceb9fe1a85ec53;", " h1 ^= h1 >> 33;", " h2 ^= h2 >> 33;", " h2 *= 0xff51afd7ed558ccd;", " h2 ^= h2 >> 33;", " h2 *= 0xc4ceb9fe1a85ec53;", " h2 ^= h2 >> 33;", " h1 += h2;", " h2 += h1;", "", " j1_spin = h1&nmask; j3_spin = (h1>>48)&7;", " j2_spin = h2&nmask; j4_spin = (h2>>48)&7;", " K1 = h1; K2 = h2;", "}", "#endif", "", "void", "s_hash(uchar *cp, int om)", /* uses either d_sfh (1x32bit), or d_hash (2x64bit) */ "{", /* depending on ssize ie the -w parameter */ " hasher(cp, om); /* sets K1 */", "#ifdef BITSTATE", " if (S_Tab == H_tab)", /* state stack in bitstate search */ " j1_spin = K1 %% omaxdepth;", " else", "#endif", " if (ssize < 8*WS)", " j1_spin = K1&mask;", " else", " j1_spin = K1;", "}", "#ifndef RANDSTOR", "int *prerand;", "void", "inirand(void)", "{ int i;", " srand(s_rand+HASH_NR);", /* inirand */ " prerand = (int *) emalloc((omaxdepth+3)*sizeof(int));", " for (i = 0; i < omaxdepth+3; i++)", " { prerand[i] = rand();", " }", "}", "int", "pan_rand(void)", "{ if (!prerand) inirand();", " return prerand[depth];", "}", "#endif", "", "void", "set_masks(void)", "{", " if (WS == 4 && ssize >= 32)", " { mask = 0xffffffff;", "#ifdef BITSTATE", " switch (ssize) {", " case 34: nmask = (mask>>1); break;", " case 33: nmask = (mask>>2); break;", " default: nmask = (mask>>3); break;", " }", "#else", " nmask = mask;", "#endif", " } else if (WS == 8)", " { mask = ((ONE_L<>3;", "#else", " nmask = mask;", "#endif", " } else if (WS != 4)", " { fprintf(stderr, \"pan: wordsize %%ld not supported\\n\", (long int) WS);", " exit(1);", " } else /* WS == 4 and ssize < 32 */", " { mask = ((ONE_L<>3);", " }", "}", "", "#if defined(AUTO_RESIZE) && !defined(BITSTATE) && !defined(MA)", "#if NCORE>1", " #error cannot combine AUTO_RESIZE with NCORE>1", "#endif", "static long reclaim_size;", "static char *reclaim_mem;", "static H_el **N_tab;", "void", "reverse_capture(H_el *p)", "{ if (!p) return;", " reverse_capture(p->nxt);", " /* last element of list moves first */", " /* to preserve list-order */", " j2_spin = p->m_K1;", " if (ssize < 8*WS) /* probably always true */", " { j2_spin &= mask;", " }", " p->nxt = N_tab[j2_spin];", " N_tab[j2_spin] = p;", "}", "void", "resize_hashtable(void)", "{", "#ifndef BFS_PAR", /* ssize and mask/nmask are not in shared mem */ " if (WS == 4 && ssize >= 27 - 1)", "#endif", " { return; /* cannot increase further */", " }", "", " ssize += 2; /* 4x size @htable ssize */", "", " printf(\"pan: resizing hashtable to -w%%d.. \", ssize);", "", " N_tab = (H_el **) emalloc((ONE_L<1", "int", "find_claim(char *s)", "{ int i, j;", " for (i = 0; strncmp(procname[i], \":np_:\", 5) != 0; i++)", " { if (strcmp(s, procname[i]) == 0)", " { for (j = 0; j < NCLAIMS; j++)", " { if (spin_c_typ[j] == i)", " { return j;", " } }", " break;", " } }", " printf(\"pan: error: cannot find claim '%%s'\\n\", s);", " exit(1);", " return -1; /* unreachable */", "}", "#endif", "", "#if defined(BFS_PAR) && defined(BFS_SEP_HASH)", "int /* to avoid having to include and compile with -lm */", "blog2(int n) /* n >= 1 */", "{ int m=1, r=2;", " if (n == 1) { return 0; }", " if (n == 2) { return 1; }", " while (n > r) { m++; r *= 2; }", " return m;", "}", "#endif", "", "uint pp[33];", "", "uint ", "mul(uint a, uint b, uint p)", "{ int c = 0;", " while (a)", " { if (a&1)", " { a ^= 1;", " c ^= b;", " }", " a = (a>>1);", " if (b & 0x80000000)", " { b += b;", " b ^= p;", " } else", " { b += b;", " } }", " return c;", "}", "", "uint", "ppow(int n, uint p)", "{ uint t = 1; int i;", " for (i = 0; i < 32; i++)", " { if (n & (1<0)", " s_rand = T_RAND;", /* so that -RS can override */ "#elif defined(P_RAND) && (P_RAND>0)", " s_rand = P_RAND;", "#endif", "", "#ifdef PUTPID", " { char *ptr = strrchr(argv[0], '/');", " if (ptr == NULL)", " { ptr = argv[0];", " } else", " { ptr++;", " }", " progname = emalloc(strlen(ptr));", " strcpy(progname, ptr);", " /* printf(\"progname: %%s\\n\", progname); */", " }", "#endif", "", "#ifdef BITSTATE", " b_store = bstore_reg; /* default */", "#endif", "#if NCORE>1", " { int i, j;", " strcpy(o_cmdline, \"\");", " for (j = 1; j < argc; j++)", " { strcat(o_cmdline, argv[j]);", " strcat(o_cmdline, \" \");", " }", " /* printf(\"Command Line: %%s\\n\", o_cmdline); */", " if (strlen(o_cmdline) >= sizeof(o_cmdline))", " { Uerror(\"option list too long\");", " } }", "#endif", " while (argc > 1 && argv[1][0] == '-')", " { switch (argv[1][1]) {", "#ifndef SAFETY", " #ifdef NP", " case 'a': fprintf(efd, \"warning: -a is disabled by -DNP, ignored\");", " break;", " #else", " case 'a': a_cycles = 1; break;", " #endif", "#else", " #if defined(BFS_PAR) && defined(L_BOUND)", " case 'a': if (isdigit(argv[1][2]))", " { L_bound = atoi(&argv[1][2]);", " if (L_bound < 1 || L_bound > 255)", " { printf(\"usage: -aN with 00", " case 'C': coltrace = 1; goto samething;", " #endif", "#endif", " case 'c': upto = atoi(&argv[1][2]); break;", " case 'D': dodot++; state_tables++; break;", " case 'd': state_tables++; break;", " case 'e': every_error = 1; upto = 0; Nr_Trails = 1; break;", " case 'E': noends = 1; break;", "#ifdef SC", " case 'F': if (strlen(argv[1]) > 2)", " stackfile = &argv[1][2];", " break;", "#endif", "#if !defined(SAFETY) && !defined(NOFAIR)", " case 'f': fairness = 1; break;", "#endif", "#ifdef HAS_CODE", " #if HAS_CODE>0", " case 'g': gui = 1; goto samething;", " #endif", "#endif", " case 'h':", " if (strncmp(&argv[1][1], \"hash\", strlen(\"hash\")) == 0)", " { do_hashgen = 1;", " break;", " }", " if (!argv[1][2] || !isdigit((int) argv[1][2]))", " { usage(efd); /* exits */", " }", " HASH_NR = atoi(&argv[1][2])%%(sizeof(HASH_CONST)/sizeof(uint));", " break;", " case 'I': iterative = 2; every_error = 1; break;", " case 'i':", " if (strncmp(&argv[1][1], \"i_reverse\", strlen(\"i_reverse\")) == 0)", " { reversing |= 1;", " } else", " { iterative = 1;", " every_error = 1;", " }", " break;", " case 'J': like_java = 1; break; /* Klaus Havelund */", "#ifdef BITSTATE", " case 'k': hfns = atoi(&argv[1][2]); break;", "#endif", "#ifdef BCS", " case 'L':", " sched_max = atoi(&argv[1][2]);", " if (sched_max > 255) /* stored as one byte */", " { fprintf(efd, \"warning: using max bound (255)\\n\");", " sched_max = 255;", " }", " #ifndef NOREDUCE", " if (sched_max == 0)", " { fprintf(efd, \"warning: with (default) bound -L0, \");", " fprintf(efd, \"using -DNOREDUCE performs better\\n\");", " }", " #endif", " break;", "#endif", "#ifndef SAFETY", "#ifdef NP", " case 'l': a_cycles = 1; break;", "#else", " case 'l': fprintf(efd, \"error: -l not available (compile with -DNP)\");", " usage(efd); break;", "#endif", "#endif", "#ifdef BITSTATE", " case 'M': udmem = atoi(&argv[1][2]); break;", " case 'G': udmem = atoi(&argv[1][2]); udmem *= 1024; break;", "#else", " case 'M': case 'G':", " fprintf(stderr, \"-M and -G affect only -DBITSTATE\\n\");", " break;", "#endif", " case 'm': maxdepth = atoi(&argv[1][2]); break;", "#ifndef NOCLAIM", " case 'N':", " #if NCLAIMS>1", " if (isdigit((int)argv[1][2]))", " { whichclaim = atoi(&argv[1][2]);", " } else if (isalpha((int)argv[1][2]))", " { claimname = &argv[1][2];", " } else if (argc > 2 && argv[2][0] != '-') /* check next arg */", " { claimname = argv[2];", " argc--; argv++; /* skip next arg */", " }", " #else", " #if NCLAIMS==1", " fprintf(stderr, \"warning: only one claim defined, -N ignored\\n\");", " #else", " fprintf(stderr, \"warning: no claims defined, -N ignored\\n\");", " #endif", " if (!isdigit((int)argv[1][2]) && argc > 2 && argv[2][0] != '-')", " { argc--; argv++;", " }", " #endif", "#endif", " break;\n", " case 'n': no_rck = 1; break;", "", " case 'P':", " if (!readtrail", " && isdigit((int) argv[1][2]))", /* was argv[1][2] == '_' */ " { int x = atoi(&argv[1][2]);", " if (x != 0 && x != 1)", " { fprintf(efd, \"pan: bad option -P[01], ignored\\n\");", " }", " if (x == 0)", " { reversing &= ~1;", " break;", " }", " if (x == 1)", " { reversing |= 1;", " break;", " }", " if (verbose)", " fprintf(efd, \"pan: reversed *active* process creation %%s\\n\",", " reversing&1?\"on\":\"off\");", " break;", " } /* else */", "#ifdef HAS_CODE", " #if HAS_CODE>0", " readtrail = 1; onlyproc = atoi(&argv[1][2]);", " if (argc > 2 && argv[2][0] != '-') /* check next arg */", " { trailfilename = argv[2];", " argc--; argv++; /* skip next arg */", " }", " #else", " fprintf(efd, \"pan: option -P not recognized, ignored\\n\");", " #endif", "#else", " fprintf(efd, \"pan: option -P not recognized, ignored\\n\");", "#endif", " break;", "", " case 'p':", " #if !defined(BFS) && !defined(BFS_PAR)", " #ifdef PERMUTED", " if (strncmp(&argv[1][1], \"p_normal\", strlen(\"p_normal\")) == 0)", " { reversing &= ~2;", " break;", " }", " reversing |=2;", " if (strncmp(&argv[1][1], \"p_permute\", strlen(\"p_permute\")) == 0)", " { p_reorder = set_permuted;", " break;", " }", " if (strncmp(&argv[1][1], \"p_rotate\", strlen(\"p_rotate\")) == 0)", " { p_reorder = set_rotated;", " if (isdigit((int) argv[1][9]))", " { p_rotate = atoi(&argv[1][9]);", " } else", " { p_rotate = 1;", " }", " break;", " }", " if (strncmp(&argv[1][1], \"p_randrot\", strlen(\"p_randrot\")) == 0)", " { p_reorder = set_randrot;", " break;", " }", " if (strncmp(&argv[1][1], \"p_reverse\", strlen(\"p_reverse\")) == 0)", " { p_reorder = set_reversed;", " break;", " }", " #else", " if (strncmp(&argv[1][1], \"p_permute\", strlen(\"p_permute\")) == 0", " || strncmp(&argv[1][1], \"p_rotate\", strlen(\"p_rotate\")) == 0", " || strncmp(&argv[1][1], \"p_randrot\", strlen(\"p_randrot\")) == 0", " || strncmp(&argv[1][1], \"p_reverse\", strlen(\"p_reverse\")) == 0)", " { fprintf(efd, \"option %%s required compilation with -DPERMUTED\\n\",", " argv[1]);", " exit(1);", " }", " #endif", " #endif", "#ifdef SVDUMP", " vprefix = atoi(&argv[1][2]);", "#else", " fprintf(efd, \"invalid option '%%s' -- ignored\\n\", argv[1]);", "#endif", " break;", "#if NCORE==1", " case 'Q': quota = (double) 60.0 * (double) atoi(&argv[1][2]);", " #ifndef FREQ", " freq /= 10.; /* for better resolution */", " #endif", " break;", "#endif", " case 'q': strict = 1; break;", " case 'R':", " if (argv[1][2] == 'S') /* e.g., -RS76842 */", " { s_rand = atoi(&argv[1][3]);", /* RS */ " break;", " }", "#ifdef BITSTATE", " Nrun = atoi(&argv[1][2]);", " if (Nrun > 100)", " { Nrun = 100;", " } else if (Nrun < 1)", " { Nrun = 1;", " }", "#else", " usage(efd);", " break;", "#endif", " case 'r':", " if (strncmp(&argv[1][1], \"rhash\", strlen(\"rhash\")) == 0)", " { if (s_rand == 12345) /* default seed */", " {", "#if defined(WIN32) || defined(WIN64)", " s_rand = (uint) clock();", "#else", " struct tms dummy_tm;", " s_rand = (uint) times(&dummy_tm);", "#endif", " }", " srand(s_rand++);", " #ifdef PERMUTED", " do_hashgen = 1;", /* + randomize p_rotate, p_reverse, p_permute */ " switch (rand()%%5) {", " case 0: p_reorder = set_permuted;", " reversing |=2;", " break;", " case 1: p_reorder = set_reversed;", " reversing |=2;", " break;", " /* fully randomize p_rotate: */", " case 2: p_reorder = set_randrot;", " reversing |=2;", " break;", " /* choose once, then keep p_rotate fixed: */", " case 3: p_reorder = set_rotated;", " p_rotate = rand()%%3;", " reversing |=2;", " break;", " default: /* standard search */ break;", " }", " if (rand()%%2 == 0)", " { t_reverse = 1;", " }", " break;", " #else", " fprintf(efd, \"option -rhash requires compilation with -DPERMUTED\\n\");", " exit(1);", " #endif", " }", "#if defined(HAS_CODE) && HAS_CODE>0", "samething: readtrail = 1;", " if (isdigit((int)argv[1][2]))", " whichtrail = atoi(&argv[1][2]);", " else if (argc > 2 && argv[2][0] != '-') /* check next arg */", " { trailfilename = argv[2];", " argc--; argv++; /* skip next arg */", " }", " break;", " case 'S': silent = 1; goto samething;", "#else", " fprintf(efd, \"options -r is for models with embedded C code\\n\");", " break;", "#endif", " case 'T':", " if (isdigit((int) argv[1][2]))", /* was argv[1][2] == '_' */ " { t_reverse = atoi(&argv[1][2]);", " if (verbose)", " printf(\"pan: reverse transition ordering %%s\\n\",", " t_reverse?\"on\":\"off\");", " break;", " }", " TMODE = 0444;", " break;", " case 't':", " if (strncmp(&argv[1][1], \"t_reverse\", strlen(\"t_reverse\")) == 0)", " { t_reverse = 1;", " break;", " }", /* i.e., a trail prefix cannot be '_reverse' */ " if (argv[1][2])", " { tprefix = &argv[1][2];", " }", " break;", " case 'u':", " #ifdef BFS_PAR", " ncores = atoi(&argv[1][2]);", " #endif", " break;", " case 'V': start_timer(); printf(\"Generated by %%s\\n\", SpinVersion);", " to_compile(); pan_exit(2); break;", " case 'v': verbose++; break;", " case 'w': ssize = atoi(&argv[1][2]);", " #if defined(BFS_PAR) && defined(BFS_SEP_HASH)", " used_w = 1;", " #endif", " break;", " case 'Y': signoff = 1; break;", " case 'X': efd = stdout; break;", " case 'x': exclusive = 1; break;", " #if NCORE>1", " /* -B ip is passthru to proxy of remote ip address: */", " case 'B': argc--; argv++; break;", " case 'Q': worker_pids[0] = atoi(&argv[1][2]); break;", " /* -Un means that the nth worker should be instantiated as a proxy */", " case 'U': proxy_pid = atoi(&argv[1][2]); break;", " /* -W means this copy is started by a cluster-server as a remote */", " /* this flag is passed to ./pan_proxy, which interprets it */", " case 'W': remote_party++; break;", " case 'Z': core_id = atoi(&argv[1][2]);", " if (verbose)", " { printf(\"cpu%%d: pid %%d parent %%d\\n\",", " core_id, getpid(), worker_pids[0]);", " }", " break;", " case 'z': z_handoff = atoi(&argv[1][2]); break;", " #else", " case 'z': break; /* ignored for single-core */", " #endif", " default : fprintf(efd, \"saw option -%%c\\n\",", " argv[1][1]); usage(efd); break;", " }", " argc--; argv++;", " }", "#if defined(BFS_PAR) && defined(BFS_SEP_HASH)", " if (used_w == 0)", " { if (ncores == 0) /* all cores used, by default */", " { ssize -= blog2(BFS_MAXPROCS - 1);", " } else", " { ssize -= blog2(ncores);", " } }", "#endif", " if (do_hashgen)", " { hashgen();", /* placed here so that -RSn can appear after -hash */ " }", "#ifndef SAFETY", " if (fairness && !a_cycles)", " { fprintf(efd, \"error: -f requires the use of -a or -l\\n\");", " usage(efd);", " }", " #if ACCEPT_LAB==0", " if (a_cycles)", " { fprintf(efd, \"warning: no accept labels are defined, \");", " fprintf(efd, \"so option -a has no effect (ignored)\\n\");", " a_cycles = 0;", " }", " #endif", "#endif", "", "#ifdef BFS_PAR", " uerror = bfs_uerror;", " Uerror = bfs_Uerror;", "#else", " uerror = dfs_uerror;", " Uerror = dfs_Uerror;", "#endif", " if (ssize <= 32) /* 6.2.0 */", " { hasher = d_sfh;", "#if !defined(BITSTATE) && defined(USE_TDH)", " o_hash = o_hash32;", "#endif", " } else", " { hasher = d_hash;", "#if !defined(BITSTATE) && defined(USE_TDH)", " o_hash = o_hash64;", "#endif", " }", " if (iterative && TMODE != 0666)", " { TMODE = 0666;", " fprintf(efd, \"warning: -T ignored when -i or -I is used\\n\");", " }", "#if defined(WIN32) || defined(WIN64)", " #ifndef _S_IWRITE", " #define S_IWRITE 0000200 /* write permission, owner */", " #endif", " #ifndef _S_IREAD", " #define S_IREAD 0000400 /* read permission, owner */", " #endif", " if (TMODE == 0666)", " TMODE = S_IWRITE | S_IREAD;", " else", " TMODE = S_IREAD;", "#endif", "#if NCORE>1", " store_proxy_pid = proxy_pid; /* for checks in mem_file() and someone_crashed() */", " if (core_id != 0) { proxy_pid = 0; }", " #ifndef SEP_STATE", " if (core_id == 0 && a_cycles)", " { fprintf(efd, \"hint: this search may be more efficient \");", " fprintf(efd, \"if pan.c is compiled -DSEP_STATE\\n\");", " }", " #endif", " if (z_handoff < 0)", " { z_handoff = 20; /* conservative default - for non-liveness checks */", " }", "#if defined(NGQ) || defined(LWQ_FIXED)", " LWQ_SIZE = (double) (128.*1048576.);", "#else", " LWQ_SIZE = (double) ( z_handoff + 2.) * (double) sizeof(SM_frame);", /* the added margin of +2 is not really necessary */ "#endif", " #if NCORE>2", " if (a_cycles)", " { fprintf(efd, \"warning: the intended nr of cores to be used in liveness mode is 2\\n\");", " #ifndef SEP_STATE", " fprintf(efd, \"warning: without -DSEP_STATE there is no guarantee that all liveness violations are found\\n\");", " #endif", " }", /* it still works though, the later cores get states from the global q */ " #endif", " #ifdef HAS_HIDDEN", " #error cannot use hidden variables when compiling multi-core", " #endif", "#endif", "#if defined(T_RAND) && defined(ELSE_IN_GUARD)", " #error cannot hide 'else' as guard in d_step, when using -DT_RAND", "#endif", "#ifdef BITSTATE", " if (hfns <= 0)", " { hfns = 1;", " fprintf(efd, \"warning: using -k%%d as minimal usable value\\n\", hfns);", " }", "#endif", " omaxdepth = maxdepth;", "#ifdef BITSTATE", " if (WS == 4 && ssize > 34)", /* 32-bit word size */ " { ssize = 34;", " fprintf(efd, \"warning: using -w%%d as max usable value\\n\", ssize);", "/*", " * -w35 would not work: 35-3 = 32 but 1^31 is the largest", " * power of 2 that can be represented in an ulong", " */", " }", "#else", " if (WS == 4 && ssize > 27)", " { ssize = 27;", " fprintf(efd, \"warning: using -w%%d as max usable value\\n\", ssize);", "/*", " * for emalloc, the lookup table size multiplies by 4 for the pointers", " * the largest power of 2 that can be represented in a ulong is 1^31", " * hence the largest number of lookup table slots is 31-4 = 27", " */", " }", "#endif", "#ifdef SC", " hiwater = HHH = maxdepth-10;", " DDD = HHH/2;", " if (!stackfile)", " { stackfile = (char *) emalloc(strlen(PanSource)+4+1);", " sprintf(stackfile, \"%%s._s_\", PanSource);", " }", " if (iterative)", " { fprintf(efd, \"error: cannot use -i or -I with -DSC\\n\");", " pan_exit(1);", " }", "#endif", "#if (defined(R_XPT) || defined(W_XPT)) && !defined(MA)", " #warning -DR_XPT and -DW_XPT assume -DMA (ignored)", "#endif", " if (iterative && a_cycles)", " fprintf(efd, \"warning: -i or -I work for safety properties only\\n\");", "#ifdef BFS", " #ifdef SC", " #error -DBFS not compatible with -DSC", " #endif", " #ifdef HAS_LAST", " #error -DBFS not compatible with _last", " #endif", " #ifdef HAS_STACK", " #error cannot use c_track UnMatched with BFS", " #endif", " #ifdef BCS", " #error -DBFS not compatible with -DBCS", " #endif", " #ifdef REACH", " #warning -DREACH is redundant when -DBFS is used", " #endif", "#endif", "#ifdef TRIX", " #ifdef BITSTATE", " #error cannot combine -DTRIX and -DBITSTATE", " #endif", " #ifdef COLLAPSE", " #error cannot combine -DTRIX and -DCOLLAPSE", " #endif", " #ifdef MA", " #error cannot combine -DTRIX and -DMA", " #endif", " #if defined(BFS_PAR) && defined(BFS_SEP_HEAP)", " #error cannot combined -DBFS_SEP_HEAP with -DTRIX", " #endif", "#endif", "#ifdef BFS_PAR", " #ifdef NP", " #error cannot combine -DBFS_PAR and -DNP", " #undef NP", " #endif", "#endif", "#ifdef BCS", " #ifdef P_RAND", " #error cannot combine -DBCS and -DP_RAND", " #endif", " #ifdef BFS", " #error cannot combine -DBCS and -DBFS", " #endif", "#endif", "#if defined(MERGED) && defined(PEG)", " #error to use -DPEG use: spin -o3 -a", "#endif", "#if defined(HC) && !defined(BFS_PAR)", " #ifdef NOCOMP", " #error cannot combine -DHC and -DNOCOMP", " #endif", " #ifdef BITSTATE", " #error cannot combine -DHC and -DBITSTATE", " #endif", "#endif", "#if defined(SAFETY) && defined(NP)", " #error cannot combine -DNP and -DBFS or -DSAFETY", "#endif", "#ifdef MA", " #ifdef BITSTATE", " #error cannot combine -DMA and -DBITSTATE", " #endif", " #if MA <= 0", " #error usage: -DMA=N with N > 0 and N < VECTORSZ", " #endif", "#endif", "#ifdef COLLAPSE", " #ifdef BITSTATE", " #error cannot combine -DBITSTATE and -DCOLLAPSE", " #endif", " #ifdef NOCOMP", " #error cannot combine -DCOLLAPSE and -DNOCOMP", " #endif", "#endif", " if (maxdepth <= 0 || ssize <= 1) usage(efd);", "#if SYNC>0 && !defined(NOREDUCE)", " if (a_cycles && fairness)", " { fprintf(efd, \"error: p.o. reduction not compatible with \");", " fprintf(efd, \"fairness (-f) in models\\n\");", " fprintf(efd, \" with rendezvous operations: \");", " fprintf(efd, \"recompile with -DNOREDUCE\\n\");", " pan_exit(1);", " }", "#endif", "#if defined(REM_VARS) && !defined(NOREDUCE)", " #warning p.o. reduction not compatible with remote varrefs (use -DNOREDUCE)", "#endif", "#if defined(NOCOMP) && !defined(BITSTATE)", " if (a_cycles)", " { fprintf(efd, \"error: use of -DNOCOMP voids -l and -a\\n\");", " pan_exit(1);", " }", "#endif", "#ifdef MEMLIM", " memlim = ((double) MEMLIM) * (double) (1<<20); /* size in Mbyte */", "#endif", "#if SYNC>0", " #ifdef HAS_PRIORITY", " #error use of priorities cannot be combined with rendezvous", " #elif HAS_ENABLED", " #error use of enabled() cannot be combined with rendezvous", " #endif", "#endif", "#ifndef NOREDUCE", " #ifdef HAS_PRIORITY", " #warning use of priorities requires -DNOREDUCE", " #elif HAS_ENABLED", " #error use of enabled() requires -DNOREDUCE", " #endif", " #ifdef HAS_PCVALUE", " #error use of pcvalue() requires -DNOREDUCE", " #endif", " #ifdef HAS_BADELSE", " #error use of 'else' combined with i/o stmnts requires -DNOREDUCE", " #endif", " #if defined(HAS_LAST) && !defined(BCS)", " #error use of _last requires -DNOREDUCE", " #endif", "#endif", "#if SYNC>0 && !defined(NOREDUCE)", " #ifdef HAS_UNLESS", " fprintf(efd, \"warning: use of a rendezvous stmnts in the escape\\n\");", " fprintf(efd, \"\tof an unless clause, if present, could make p.o. reduction\\n\");", " fprintf(efd, \"\tinvalid (use -DNOREDUCE to avoid this)\\n\");", " #ifdef BFS", " fprintf(efd, \"\t(this type of rv is also not compatible with -DBFS)\\n\");", " #endif", " #endif", "#endif", "#if SYNC>0 && defined(BFS)", " if (!noends)", " fprintf(efd, \"warning: use of rendezvous with BFS does not preserve all invalid endstates\\n\");", "#endif", "#if !defined(REACH) && !defined(BITSTATE)", " if (iterative != 0 && a_cycles == 0)", " { fprintf(efd, \"warning: -i and -I need -DREACH to work accurately\\n\");", " }", "#endif", "#if defined(BITSTATE) && defined(REACH)", " #warning -DREACH is voided by -DBITSTATE", "#endif", "#if defined(MA) && defined(REACH)", " #warning -DREACH is voided by -DMA", "#endif", "#if defined(FULLSTACK) && defined(CNTRSTACK)", " #error cannot combine -DFULLSTACK and -DCNTRSTACK", "#endif", "#if defined(VERI)", " #if ACCEPT_LAB>0", " #ifndef BFS", " if (!a_cycles", " #ifdef HAS_CODE", " && !readtrail", " #endif", " #if NCORE>1", " && core_id == 0", " #endif", " && !state_tables)", " { fprintf(efd, \"warning: never claim + accept labels \");", " fprintf(efd, \"requires -a flag to fully verify\\n\");", " }", " #else", " if (verbose && !state_tables", " #ifdef HAS_CODE", " && !readtrail", " #endif", " )", " { fprintf(efd, \"warning: verification in BFS mode \");", " fprintf(efd, \"is restricted to safety properties\\n\");", " }", " #endif", " #endif", "#endif", "#ifndef SAFETY", " #if 0", " if (!a_cycles", " #ifdef HAS_CODE", " && !readtrail", " #endif", " #if NCORE>1", " && core_id == 0", " #endif", " && !state_tables)", " { fprintf(efd, \"hint: this search is more efficient \");", " fprintf(efd, \"if pan.c is compiled -DSAFETY\\n\");", " }", " #endif", " #ifndef NOCOMP", " if (!a_cycles)", " { S_A = 0;", " } else", " { if (!fairness)", " { S_A = 1; /* _a_t */", " #ifndef NOFAIR", " } else /* _a_t and _cnt[NFAIR] */", " { S_A = (&(now._cnt[0]) - (uchar *) &now) + NFAIR - 2;", " /* -2 because first two uchars in now are masked */", " #endif", " } }", " #endif", "#endif", " signal(SIGINT, stopped);", " set_masks();", "#if defined(BFS) || defined(BFS_PAR)", " trail = (Trail *) emalloc(6*sizeof(Trail));", " trail += 3;", "#else", " trail = (Trail *) emalloc((maxdepth+3)*sizeof(Trail));", " trail++; /* protect trpt-1 refs at depth 0 */", "#endif", " trpt = &trail[0]; /* precaution -- in case uerror is called early */", "#ifdef BFS", " ntrpt = trpt;", "#endif", "#ifdef SVDUMP", " if (vprefix > 0)", " { char nm[64];", " sprintf(nm, \"%%s.svd\", PanSource);", " if ((svfd = creat(nm, TMODE)) < 0)", " { fprintf(efd, \"couldn't create %%s\\n\", nm);", " vprefix = 0;", " } }", "#endif", "#ifdef RANDSTOR", " srand(s_rand+HASH_NR);", /* main - RANDSTOR */ "#endif", "#if SYNC>0 && ASYNC==0", " set_recvs();", "#endif", " run();", " done = 1;", " wrapup();", " return 0;", "}", /* end of main() */ "", "void", "usage(FILE *fd)", "{", " fprintf(fd, \"%%s\\n\", SpinVersion);", " fprintf(fd, \"Valid Options are:\\n\");", "#ifndef SAFETY", "#ifdef NP", " fprintf(fd, \"\t-a -> is disabled by -DNP \");", " fprintf(fd, \"(-DNP compiles for -l only)\\n\");", "#else", " fprintf(fd, \"\t-a find acceptance cycles\\n\");", "#endif", "#else", " fprintf(fd, \"\t-a,-l,-f -> are disabled by -DSAFETY\\n\");", "#endif", " fprintf(fd, \"\t-A ignore assert() violations\\n\");", " fprintf(fd, \"\t-b consider it an error to exceed the depth-limit\\n\");", " fprintf(fd, \"\t-cN stop at Nth error \");", " fprintf(fd, \"(defaults to -c1)\\n\");", " fprintf(fd, \"\t-D print state tables in dot-format and stop\\n\");", " fprintf(fd, \"\t-d print state tables and stop\\n\");", " fprintf(fd, \"\t-e create trails for all errors\\n\");", " fprintf(fd, \"\t-E ignore invalid end states\\n\");", "#ifdef SC", " fprintf(fd, \"\t-Ffile use 'file' to store disk-stack\\n\");", "#endif", "#ifndef NOFAIR", " fprintf(fd, \"\t-f add weak fairness (to -a or -l)\\n\");", "#endif", " fprintf(fd, \"\t-hN use different hash-seed N:0..499 (defaults to -h0)\\n\");", " fprintf(fd, \"\t-hash generate a random hash-polynomial for -h0 (see also -rhash)\\n\");", " fprintf(fd, \"\t using a seed set with -RSn (default %%u)\\n\", s_rand);", " fprintf(fd, \"\t-i search for shortest path to error\\n\");", " fprintf(fd, \"\t-I like -i, but approximate and faster\\n\");", " fprintf(fd, \"\t-J reverse eval order of nested unlesses\\n\");", "#ifdef BITSTATE", " fprintf(fd, \"\t-kN set N bits per state (defaults to 3)\\n\");", "#endif", "#ifdef BCS", " fprintf(fd, \"\t-LN set scheduling restriction to N (default 0)\\n\");", "#endif", "#ifndef SAFETY", "#ifdef NP", " fprintf(fd, \"\t-l find non-progress cycles\\n\");", "#else", " fprintf(fd, \"\t-l find non-progress cycles -> \");", " fprintf(fd, \"disabled, requires \");", " fprintf(fd, \"compilation with -DNP\\n\");", "#endif", "#endif", "#ifdef BITSTATE", " fprintf(fd, \"\t-MN use N Megabytes for bitstate hash array\\n\");", " fprintf(fd, \"\t-GN use N Gigabytes for bitstate hash array\\n\");", "#endif", " fprintf(fd, \"\t-mN max depth N steps (default=10k)\\n\");", "#if NCLAIMS>1", " fprintf(fd, \"\t-N cn -- use the claim named cn\\n\");", " fprintf(fd, \"\t-Nn -- use claim number n\\n\");", "#endif", " fprintf(fd, \"\t-n no listing of unreached states\\n\");", "#ifdef PERMUTED", " fprintf(fd, \"\t-p_permute randomize order in which processes are scheduled (see also -rhash)\\n\");", " fprintf(fd, \"\t-p_reverse reverse order in which processes are scheduled (see also -rhash)\\n\");", " fprintf(fd, \"\t-p_rotateN rotate by N the process scheduling order (see also -rhash)\\n\");", "#endif", "#ifdef SVDUMP", " fprintf(fd, \"\t-pN create svfile (save N bytes per state)\\n\");", "#endif", " fprintf(fd, \"\t-QN set time-limit on execution of N minutes\\n\");", " fprintf(fd, \"\t-q require empty chans in valid end states\\n\");", "#ifdef HAS_CODE", " fprintf(fd, \"\t-r read and execute trail - can add -v,-n,-PN,-g,-C\\n\");", " fprintf(fd, \"\t-r trailfilename read and execute trail in file\\n\");", " fprintf(fd, \"\t-rN read and execute N-th error trail\\n\");", " fprintf(fd, \"\t-C read and execute trail - columnated output (can add -v,-n)\\n\");", " fprintf(fd, \"\t-r -PN read and execute trail - restrict trail output to proc N\\n\");", " fprintf(fd, \"\t-g read and execute trail + msc gui support\\n\");", " fprintf(fd, \"\t-S silent replay: only user defined printfs show\\n\");", "#endif", " fprintf(fd, \"\t-RSn use randomization seed n\\n\");", " fprintf(fd, \"\t-rhash use random hash-polynomial and randomly choose -p_rotateN, -p_permute, or p_reverse\\n\");", "#ifdef BITSTATE", " fprintf(fd, \"\t-Rn run n times n: [1..100] using n \");", " fprintf(fd, \" different hash functions\\n\");", "#endif", " fprintf(fd, \"\t-T create trail files in read-only mode\\n\");", " fprintf(fd, \"\t-t_reverse reverse order in which transitions are explored\\n\");", " fprintf(fd, \"\t-tsuf replace .trail with .suf on trailfiles\\n\");", " fprintf(fd, \"\t-V print SPIN version number\\n\");", " fprintf(fd, \"\t-v verbose -- filenames in unreached state listing\\n\");", " fprintf(fd, \"\t-wN hashtable of 2^N entries \");", " fprintf(fd, \"(defaults to -w%%d)\\n\", ssize);", " fprintf(fd, \"\t-x do not overwrite an existing trail file\\n\");", "#if NCORE>1", " fprintf(fd, \"\t-zN handoff states below depth N to 2nd cpu (multi_core)\\n\");", "#endif", "#ifdef HAS_CODE", " fprintf(fd, \"\\n\toptions -r, -C, -PN, -g, and -S can optionally be followed by\\n\");", " fprintf(fd, \"\ta filename argument, as in \'-r filename\', naming the trailfile\\n\");", "#endif", "#if NCORE>1", " multi_usage(fd);", "#endif", " exit(1);", "}", "", "char *", "Malloc(ulong n)", "{ char *tmp;", "#ifdef MEMLIM", " if (memcnt + (double) n > memlim)", " { printf(\"pan: reached -DMEMLIM bound\\n\");", " goto err;", " }", "#endif", " tmp = (char *) malloc(n);", " if (!tmp)", " {", "#ifdef BFS_PAR", " Uerror(\"out of non-shared memory\");", "#endif", " printf(\"pan: out of memory\\n\");", "#ifdef MEMLIM", "err:", " printf(\"\t%%g bytes used\\n\", memcnt);", " printf(\"\t%%g bytes more needed\\n\", (double) n);", " printf(\"\t%%g bytes limit\\n\", memlim);", "#endif", "#ifdef COLLAPSE", " printf(\"hint: to reduce memory, recompile with\\n\");", "#ifndef MA", " printf(\" -DMA=%%d # better/slower compression, or\\n\", hmax);", "#endif", " printf(\" -DBITSTATE # supertrace, approximation\\n\");", "#else", "#ifndef BITSTATE", " printf(\"hint: to reduce memory, recompile with\\n\");", "#ifndef HC", " printf(\" -DCOLLAPSE # good, fast compression, or\\n\");", "#ifndef MA", " printf(\" -DMA=%%d # better/slower compression, or\\n\", hmax);", "#endif", " printf(\" -DHC # hash-compaction, approximation\\n\");", "#endif", " printf(\" -DBITSTATE # supertrace, approximation\\n\");", "#endif", "#endif", "#if NCORE>1", " #ifdef FULL_TRAIL", " printf(\" omit -DFULL_TRAIL or use pan -c0 to reduce memory\\n\");", " #endif", " #ifdef SEP_STATE", " printf(\"hint: to reduce memory, recompile without\\n\");", " printf(\" -DSEP_STATE # may be faster, but uses more memory\\n\");", " #endif", "#endif", " wrapup();", " }", " memcnt += (double) n;", " return tmp;", "}", "", "#define CHUNK (100*VECTORSZ)", "", "char *", "emalloc(ulong n) /* never released or reallocated */", "{ char *tmp;", " if (n == 0)", " return (char *) NULL;", " if (n&(sizeof(void *)-1)) /* for proper alignment */", " n += sizeof(void *)-(n&(sizeof(void *)-1));", " if ((ulong) left < n)", /* was: (left < (long)n) */ " { grow = (n < CHUNK) ? CHUNK : n;", #if 1 " have = Malloc(grow);", #else " /* gcc's sbrk can give non-aligned result */", " grow += sizeof(void *); /* allow realignment */", " have = Malloc(grow);", " if (((unsigned) have)&(sizeof(void *)-1))", " { have += (long) (sizeof(void *) ", " - (((unsigned) have)&(sizeof(void *)-1)));", " grow -= sizeof(void *);", " }", #endif " fragment += (double) left;", " left = grow;", " }", " tmp = have;", " have += (long) n;", " left -= (long) n;", " memset(tmp, 0, n);", " return tmp;", "}", "void", "dfs_Uerror(char *str)", "{ /* always fatal */", " uerror(str);", "#if NCORE>1", " sudden_stop(\"Uerror\");", "#endif", "#ifdef BFS_PAR", " bfs_shutdown(\"Uerror\");", "#endif", " wrapup();", "}\n", "#if defined(MA) && !defined(SAFETY)", "int", "Unwind(void)", "{ Trans *t; uchar ot, _m; int tt; short II;", "#ifdef VERBOSE", " int i;", "#endif", " uchar oat = now._a_t;", " now._a_t &= ~(1|16|32);", " memcpy((char *) &comp_now, (char *) &now, vsize);", " now._a_t = oat;", "Up:", "#ifdef SC", " trpt = getframe(depth);", "#endif", "#ifdef VERBOSE", " printf(\"%%ld State: \", depth);", "#if !defined(NOCOMP) && !defined(HC)", " for (i = 0; i < vsize; i++) printf(\"%%d%%s,\",", " ((char *)&now)[i], Mask[i]?\"*\":\"\");", "#else", " for (i = 0; i < vsize; i++)", " printf(\"%%d,\", ((char *)&now)[i]);", "#endif", " printf(\"\\n\");", "#endif", "#ifndef NOFAIR", " if (trpt->o_pm&128) /* fairness alg */", " { now._cnt[now._a_t&1] = trpt->bup.oval;", " depth--;", "#ifdef SC", " trpt = getframe(depth);", "#else", " trpt--;", "#endif", " goto Q999;", " }", "#endif", "#ifdef HAS_LAST", "#ifdef VERI", " { long d; Trail *trl;", " now._last = 0;", " for (d = 1; d < depth; d++)", " { trl = getframe(depth-d); /* was trl = (trpt-d); */", " if (trl->pr != 0)", " { now._last = trl->pr - BASE;", " break;", " } } }", "#else", " now._last = (depth<1)?0:(trpt-1)->pr;", "#endif", "#endif", "#ifdef EVENT_TRACE", " now._event = trpt->o_event;", "#endif", " if ((now._a_t&1) && depth <= A_depth)", " { now._a_t &= ~(1|16|32);", " if (fairness) now._a_t |= 2; /* ? */", " A_depth = 0;", " goto CameFromHere; /* checkcycles() */", " }", " t = trpt->o_t;", " ot = trpt->o_ot; II = trpt->pr;", " tt = trpt->o_tt; this = pptr(II);", " _m = do_reverse(t, II, trpt->o_m);", "#ifdef VERBOSE", " printf(\"%%3ld: proc %%d \", depth, II);", " printf(\"reverses %%d, %%d to %%d,\",", " t->forw, tt, t->st);", " printf(\" %%s [abit=%%d,adepth=%%ld,\", ", " t->tp, now._a_t, A_depth);", " printf(\"tau=%%d,%%d] \\n\", ", " trpt->tau, (trpt-1)->tau);", "#endif", " depth--;", "#ifdef SC", " trpt = getframe(depth);", "#else", " trpt--;", "#endif", " /* reached[ot][t->st] = 1; 3.4.13 */", " ((P0 *)this)->_p = tt;", "#ifndef NOFAIR", " if ((trpt->o_pm&32))", " {", "#ifdef VERI", " if (now._cnt[now._a_t&1] == 0)", " now._cnt[now._a_t&1] = 1;", "#endif", " now._cnt[now._a_t&1] += 1;", " }", "Q999:", " if (trpt->o_pm&8)", " { now._a_t &= ~2;", " now._cnt[now._a_t&1] = 0;", " }", " if (trpt->o_pm&16)", " now._a_t |= 2;", "#endif", "CameFromHere:", " if (memcmp((char *) &now, (char *) &comp_now, vsize) == 0)", " return depth;", " if (depth > 0) goto Up;", " return 0;", "}", "#endif", "static char unwinding;", "void", "dfs_uerror(char *str)", "{ static char laststr[256];", " int is_cycle;", "", " if (unwinding) return; /* 1.4.2 */", " if (strncmp(str, laststr, 254))", "#if NCORE>1", " cpu_printf(\"pan:%%d: %%s (at depth %%ld)\\n\", errors+1, str,", "#else", " printf(\"pan:%%d: %%s (at depth %%ld)\\n\", errors+1, str,", "#endif", "#if NCORE>1", " (nr_handoffs * z_handoff) + ", "#endif", " ((depthfound == -1)?depth:depthfound));", " strncpy(laststr, str, 254);", " errors++;", "#ifdef HAS_CODE", " if (readtrail) { wrap_trail(); return; }", "#endif", " is_cycle = (strstr(str, \" cycle\") != (char *) 0);", " if (!is_cycle)", " { depth++; trpt++;", /* include failed step */ " }", " if ((every_error != 0)", " || errors == upto)", " {", "#if defined(MA) && !defined(SAFETY)", " if (is_cycle)", " { int od = depth;", " unwinding = 1;", " depthfound = Unwind();", " unwinding = 0;", " depth = od;", " }", "#endif", "#if NCORE>1", " writing_trail = 1;", "#endif", "#ifdef BFS", " if (depth > 1) trpt--;", " nuerror();", " if (depth > 1) trpt++;", "#else", " putrail();", "#endif", "#if defined(MA) && !defined(SAFETY)", " if (strstr(str, \" cycle\"))", " { if (every_error)", " printf(\"sorry: MA writes 1 trail max\\n\");", " wrapup(); /* no recovery from unwind */", " }", "#endif", "#if NCORE>1", " if (search_terminated != NULL)", " { *search_terminated |= 4; /* uerror */", " }", " writing_trail = 0;", "#endif", " }", " if (!is_cycle)", " { depth--; trpt--; /* undo */", " }", "#ifndef BFS", " if (iterative != 0 && maxdepth > 0)", " { if (maxdepth > depth)", " { maxdepth = (iterative == 1)?(depth+1):(depth/2);", " }", " warned = 1;", " printf(\"pan: reducing search depth to %%ld\\n\",", " maxdepth);", " } else", "#endif", " if (errors >= upto && upto != 0)", " {", "#ifdef BFS_PAR", " bfs_shutdown(\"uerror\"); /* no return */", "#endif", "#if NCORE>1", " sudden_stop(\"uerror\");", "#endif", " wrapup();", " }", " depthfound = -1;", "}\n", "int", "xrefsrc(int lno, S_F_MAP *mp, int M, int i)", "{ Trans *T; int j, retval=1;", " for (T = trans[M][i]; T; T = T->nxt)", " if (T && T->tp)", " { if (strcmp(T->tp, \".(goto)\") == 0", " || strncmp(T->tp, \"goto :\", 6) == 0)", " return 1; /* not reported */", "", " for (j = 0; j < sizeof(mp); j++)", " if (i >= mp[j].from && i <= mp[j].upto)", " { printf(\"\\t%%s:%%d\", mp[j].fnm, lno);", " break;", " }", " if (j >= sizeof(mp)) /* fnm not found in list */", " { printf(\"\\t%%s:%%d\", PanSource, lno); /* use default */", " }", " printf(\", state %%d\", i);", " if (strcmp(T->tp, \"\") != 0)", " { char *q;", " q = transmognify(T->tp);", " printf(\", \\\"%%s\\\"\", q?q:\"\");", " } else if (stopstate[M][i])", " printf(\", -end state-\");", " printf(\"\\n\");", " retval = 0; /* reported */", " }", " return retval;", "}\n", "void", "r_ck(uchar *which, int N, int M, short *src, S_F_MAP *mp)", "{ int i, m=0;", "", " if ((enum btypes) Btypes[M] == N_CLAIM", " && claimname != NULL && strcmp(claimname, procname[M]) != 0)", " { return;", " }", "", " switch ((enum btypes) Btypes[M]) {", " case P_PROC:", " case A_PROC:", " printf(\"unreached in proctype %%s\\n\", procname[M]);", " break;", " case I_PROC:", " printf(\"unreached in init\\n\");", " break;", " case E_TRACE:", " case N_TRACE:", " case N_CLAIM:", " default:", " printf(\"unreached in claim %%s\\n\", procname[M]);", " break;", " }", " for (i = 1; i < N; i++)", " { if (which[i] == 0", " && (mapstate[M][i] == 0", " || which[mapstate[M][i]] == 0))", " { m += xrefsrc((int) src[i], mp, M, i);", " } else", " { m++;", " } }", " printf(\"\t(%%d of %%d states)\\n\", N-1-m, N-1);", "}", "#if NCORE>1 && !defined(SEP_STATE)", "static long rev_trail_cnt;", "", "#ifdef FULL_TRAIL", "void", "rev_trail(int fd, volatile Stack_Tree *st_tr)", "{ long j; char snap[64];", "", " if (!st_tr)", " { return;", " }", " rev_trail(fd, st_tr->prv);", "#ifdef VERBOSE", " printf(\"%%d (%%d) LRT [%%d,%%d] -- %%9u (root %%9u)\\n\",", " depth, rev_trail_cnt, st_tr->pr, st_tr->t_id, st_tr, stack_last[core_id]);", "#endif", " if (st_tr->pr != 255)", /* still needed? */ " { sprintf(snap, \"%%ld:%%d:%%d\\n\", ", " rev_trail_cnt++, st_tr->pr, st_tr->t_id);", " j = strlen(snap);", " if (write(fd, snap, j) != j)", " { printf(\"pan: error writing trailfile\\n\");", " close(fd);", " wrapup();", " return;", " }", " } else /* handoff point */", " { if (a_cycles)", " { (void) write(fd, \"-1:-1:-1\\n\", 9);", " } }", "}", "#endif", /* FULL_TRAIL */ "#endif", /* NCORE>1 */ "", "void", "putrail(void)", "{ int fd;", "#if defined VERI || defined(MERGED)", " char snap[64];", "#endif", "#if NCORE==1 || defined(SEP_STATE) || !defined(FULL_TRAIL)", " long i, j;", " Trail *trl;", "#endif", " fd = make_trail();", " if (fd < 0) return;", "#ifdef VERI", " sprintf(snap, \"-2:%%d:-2\\n\", (uchar) ((P0 *)pptr(0))->_t);", " if (write(fd, snap, strlen(snap)) < 0) return;", "#endif", "#ifdef MERGED", " sprintf(snap, \"-4:-4:-4\\n\");", " if (write(fd, snap, strlen(snap)) < 0) return;", "#endif", "#ifdef PERMUTED", " sprintf(snap, \"-5:%%d:%%d\\n\", t_reverse, reversing&2);", " if (write(fd, snap, strlen(snap)) < 0) return;", "", " sprintf(snap, \"-6:%%d:%%d\\n\", p_reorder==set_permuted, p_reorder==set_reversed);", " if (write(fd, snap, strlen(snap)) < 0) return;", "", " sprintf(snap, \"-7:%%d:%%d\\n\", p_reorder==set_rotated, p_rotate);", " if (write(fd, snap, strlen(snap)) < 0) return;", "", " sprintf(snap, \"-8:%%d:%%d\\n\", p_reorder==set_randrot, --s_rand);", " if (write(fd, snap, strlen(snap)) < 0) return;", "#endif", "#if NCORE>1 && !defined(SEP_STATE) && defined(FULL_TRAIL)", " rev_trail_cnt = 1;", " enter_critical(GLOBAL_LOCK);", " rev_trail(fd, stack_last[core_id]);", " leave_critical(GLOBAL_LOCK);", "#else", " i = 1; /* trail starts at position 1 */", " #if NCORE>1 && defined(SEP_STATE)", " if (cur_Root.m_vsize > 0) { i++; depth++; }", " #endif", " for ( ; i <= depth; i++)", " { if (i == depthfound+1)", " { if (write(fd, \"-1:-1:-1\\n\", 9) != 9)", " { goto notgood;", " } }", " trl = getframe(i);", " if (!trl->o_t) continue;", " if (trl->o_pm&128) continue;", " sprintf(snap, \"%%ld:%%d:%%d\\n\", ", " i, trl->pr, trl->o_t->t_id);", " j = strlen(snap);", " if (write(fd, snap, j) != j)", " {", "notgood: printf(\"pan: error writing trailfile\\n\");", " close(fd);", " wrapup();", " } }", "#endif", " close(fd);", "#if NCORE>1", " cpu_printf(\"pan: wrote trailfile\\n\");", "#endif", "}\n", "void", "sv_save(void) /* push state vector onto save stack */", "{ if (!svtack->nxt)", " { svtack->nxt = (Svtack *) emalloc(sizeof(Svtack));", " svtack->nxt->body = emalloc(vsize*sizeof(char));", " svtack->nxt->lst = svtack;", " svtack->nxt->m_delta = vsize;", " svmax++;", " } else if (vsize > svtack->nxt->m_delta)", " { svtack->nxt->body = emalloc(vsize*sizeof(char));", " svtack->nxt->lst = svtack;", " svtack->nxt->m_delta = vsize;", " svmax++;", " }", " svtack = svtack->nxt;", "#if SYNC", " svtack->o_boq = boq;", "#endif", "#ifdef TRIX", " sv_populate();", "#endif", " svtack->o_delta = vsize; /* don't compress */", " memcpy((char *)(svtack->body), (char *) &now, vsize);", "#if defined(C_States) && defined(HAS_STACK) && (HAS_TRACK==1)", " c_stack((uchar *) &(svtack->c_stack[0]));", "#endif", "#ifdef DEBUG", " cpu_printf(\"%%d: sv_save\\n\", depth);", "#endif", "}\n", "void", "sv_restor(void) /* pop state vector from save stack */", "{", " memcpy((char *)&now, svtack->body, svtack->o_delta);", "#if SYNC", " boq = svtack->o_boq;", "#endif", "#ifdef TRIX", " re_populate();", "#endif", "#if defined(C_States) && (HAS_TRACK==1)", "#ifdef HAS_STACK", " c_unstack((uchar *) &(svtack->c_stack[0]));", "#endif", " c_revert((uchar *) &(now.c_state[0]));", "#endif", " if (vsize != svtack->o_delta)", " Uerror(\"sv_restor\");", " if (!svtack->lst)", " Uerror(\"error: sv_restor\");", " svtack = svtack->lst;", "#ifdef DEBUG", " cpu_printf(\" sv_restor\\n\");", "#endif", "}", "", "void", "p_restor(int h)", "{ int i;", " char *z = (char *) &now;\n", "", "#ifdef BFS_PAR", " bfs_prepmask(1); /* p_restor */", "#endif", "#ifndef TRIX", " proc_offset[h] = stack->o_offset;", " proc_skip[h] = (uchar) stack->o_skip;", "#else", " char *oi;", " #ifdef V_TRIX", " printf(\"%%4d: p_restor %%d\\n\", depth, h);", " #endif", "#endif", "#ifndef XUSAFE", " p_name[h] = stack->o_name;", "#endif", "#ifdef TRIX", " vsize += sizeof(char *);", " #ifndef BFS", " if (processes[h] != NULL || freebodies == NULL)", " { Uerror(\"processes error\");", " }", " processes[h] = freebodies;", " freebodies = freebodies->nxt;", " processes[h]->nxt = (TRIX_v6 *) 0;", " processes[h]->modified = 1; /* p_restor */", " #endif", " processes[h]->parent_pid = stack->parent;", " processes[h]->psize = stack->o_delta;", " memcpy((char *)pptr(h), stack->b_ptr, stack->o_delta);", " oi = stack->b_ptr;", "#else", " #if !defined(NOCOMP) && !defined(HC)", " for (i = vsize + stack->o_skip; i > vsize; i--)", " Mask[i-1] = 1; /* align */", " #endif", " vsize += stack->o_skip;", " memcpy(z+vsize, stack->body, stack->o_delta);", " vsize += stack->o_delta;", " #if !defined(NOCOMP) && !defined(HC)", " for (i = 1; i <= Air[((P0 *)pptr(h))->_t]; i++)", " Mask[vsize - i] = 1; /* pad */", " Mask[proc_offset[h]] = 1; /* _pid */", " #endif", " if (BASE > 0 && h > 0)", " ((P0 *)pptr(h))->_pid = h-BASE;", " else", " ((P0 *)pptr(h))->_pid = h;", " #ifdef BFS_PAR", " bfs_fixmask(1); /* p_restor */", " #endif", "#endif", " now._nr_pr += 1;", "#ifndef NOVSZ", " now._vsz = vsize;", "#endif", " i = stack->o_delqs;", " if (!stack->lst)", " Uerror(\"error: p_restor\");", " stack = stack->lst;", " this = pptr(h);", " while (i-- > 0)", " q_restor();", "#ifdef TRIX", " re_mark_all(1); /* p_restor - all chans move up in _ids_ */", " now._ids_[h] = oi; /* restor the original contents */", "#endif", "}\n", "void", "q_restor(void)", "{ int h = now._nr_qs;", "#ifdef TRIX", " #ifdef V_TRIX", " printf(\"%%4d: q_restor %%d\\n\", depth, h);", " #endif", " vsize += sizeof(char *);", " #ifndef BFS", " if (channels[h] != NULL || freebodies == NULL)", " { Uerror(\"channels error\");", " }", " channels[h] = freebodies;", " freebodies = freebodies->nxt;", " channels[h]->nxt = (TRIX_v6 *) 0;", " channels[h]->modified = 1; /* q_restor */", " #endif", " channels[h]->parent_pid = stack->parent;", " channels[h]->psize = stack->o_delta;", " memcpy((char *)qptr(h), stack->b_ptr, stack->o_delta);", " now._ids_[now._nr_pr + h] = stack->b_ptr;", "#else", " char *z = (char *) &now;", " #ifndef NOCOMP", " int k, k_end;", " #endif", " #ifdef BFS_PAR", " bfs_prepmask(2); /* q_restor */", " #endif", " q_offset[h] = stack->o_offset;", " q_skip[h] = (uchar) stack->o_skip;", " vsize += stack->o_skip;", " memcpy(z+vsize, stack->body, stack->o_delta);", " vsize += stack->o_delta;", "#endif", "#ifndef XUSAFE", " q_name[h] = stack->o_name;", "#endif", "#ifndef NOVSZ", " now._vsz = vsize;", "#endif", " now._nr_qs += 1;", "#ifndef TRIX", " #if !defined(NOCOMP) && !defined(HC)", " k_end = stack->o_offset;", " k = k_end - stack->o_skip;", " #if SYNC", " #ifndef BFS", " if (q_zero(now._nr_qs)) k_end += stack->o_delta;", " #endif", " #endif", " for ( ; k < k_end; k++)", " Mask[k] = 1;", " #endif", " #ifdef BFS_PAR", " bfs_fixmask(2); /* q_restor */", " #endif", "#endif", " if (!stack->lst)", " Uerror(\"error: q_restor\");", " stack = stack->lst;", "}", "typedef struct IntChunks {", " int *ptr;", " struct IntChunks *nxt;", "} IntChunks;", "IntChunks *filled_chunks[512];", "IntChunks *empty_chunks[512];", "int *", "grab_ints(int nr)", "{ IntChunks *z;", " if (nr >= 512) Uerror(\"cannot happen grab_int\");", " if (filled_chunks[nr])", " { z = filled_chunks[nr];", " filled_chunks[nr] = filled_chunks[nr]->nxt;", " } else ", " { z = (IntChunks *) emalloc(sizeof(IntChunks));", " z->ptr = (int *) emalloc(nr * sizeof(int));", " }", " z->nxt = empty_chunks[nr];", " empty_chunks[nr] = z;", " return z->ptr;", "}", "void", "ungrab_ints(int *p, int nr)", "{ IntChunks *z;", " if (!empty_chunks[nr]) Uerror(\"cannot happen ungrab_int\");", " z = empty_chunks[nr];", " empty_chunks[nr] = empty_chunks[nr]->nxt;", " z->ptr = p;", " z->nxt = filled_chunks[nr];", " filled_chunks[nr] = z;", "}", "int", "delproc(int sav, int h)", "{ int d, i=0;", "#ifndef NOCOMP", " int o_vsize = vsize;", "#endif", " if (h+1 != (int) now._nr_pr)", " { return 0;", " }", "#ifdef TRIX", " #ifdef V_TRIX", " printf(\"%%4d: delproc %%d -- parent %%d\\n\", depth, h, processes[h]->parent_pid);", " if (now._nr_qs > 0)", " printf(\" top channel: %%d -- parent %%d\\n\", now._nr_qs-1, channels[now._nr_qs-1]->parent_pid);", " #endif", " while (now._nr_qs > 0", " && channels[now._nr_qs-1]->parent_pid == processes[h]->parent_pid)", " { delq(sav);", " i++;", " }", " d = processes[h]->psize;", " if (sav)", " { if (!stack->nxt)", " { stack->nxt = (_Stack *) emalloc(sizeof(_Stack));", " stack->nxt->lst = stack;", " smax++;", " }", " stack = stack->nxt;", " #ifndef XUSAFE", " stack->o_name = p_name[h];", " #endif", " stack->parent = processes[h]->parent_pid;", " stack->o_delta = d;", " stack->o_delqs = i;", " stack->b_ptr = now._ids_[h];", /* new 6.1 */ " }", " memset((char *)pptr(h), 0, d);", " #ifndef BFS", " processes[h]->nxt = freebodies;", " freebodies = processes[h];", " processes[h] = (TRIX_v6 *) 0;", " #endif", " vsize -= sizeof(char *);", " now._nr_pr -= 1;", " re_mark_all(-1); /* delproc - all chans move down in _ids_ */", "#else", " while (now._nr_qs", " && q_offset[now._nr_qs-1] > proc_offset[h])", " { delq(sav);", " i++;", " }", " d = vsize - proc_offset[h];", " if (sav)", " { if (!stack->nxt)", " { stack->nxt = (_Stack *) emalloc(sizeof(_Stack));", " stack->nxt->body = emalloc(Maxbody * sizeof(char));", " stack->nxt->lst = stack;", " smax++;", " }", " stack = stack->nxt;", " stack->o_offset = proc_offset[h];", " #if VECTORSZ>32000", " stack->o_skip = (int) proc_skip[h];", " #else", " stack->o_skip = (short) proc_skip[h];", " #endif", " #ifndef XUSAFE", " stack->o_name = p_name[h];", " #endif", " stack->o_delta = d;", " stack->o_delqs = i;", " memcpy(stack->body, (char *)pptr(h), d);", " }", " vsize = proc_offset[h];", " now._nr_pr -= 1;", " memset((char *)pptr(h), 0, d);", " vsize -= (int) proc_skip[h];", " #if !defined(NOCOMP) && !defined(HC)", " #ifdef BFS_PAR", " bfs_prepmask(3); /* delproc - no chance in proc_offset or proc_skip */", " #endif", " for (i = vsize; i < o_vsize; i++)", " Mask[i] = 0; /* reset */", " #ifdef BFS_PAR", " bfs_fixmask(3); /* delproc */", " #endif", " #endif", "#endif", "#ifndef NOVSZ", " now._vsz = vsize;", "#endif", " return 1;", "}\n", "void", "delq(int sav)", "{ int h = now._nr_qs - 1;", "#ifdef TRIX", " int d = channels[now._nr_qs - 1]->psize;", "#else", " int d = vsize - q_offset[now._nr_qs - 1];", "#endif", "#ifndef NOCOMP", " int k, o_vsize = vsize;", "#endif", " if (sav)", " { if (!stack->nxt)", " { stack->nxt = (_Stack *) emalloc(sizeof(_Stack));", "#ifndef TRIX", " stack->nxt->body = emalloc(Maxbody * sizeof(char));", "#endif", " stack->nxt->lst = stack;", " smax++;", " }", " stack = stack->nxt;", "#ifdef TRIX", " stack->parent = channels[h]->parent_pid;", " stack->b_ptr = now._ids_[h];", /* new 6.1 */ "#else", " stack->o_offset = q_offset[h];", " #if VECTORSZ>32000", " stack->o_skip = (int) q_skip[h];", " #else", " stack->o_skip = (short) q_skip[h];", " #endif", "#endif", " #ifndef XUSAFE", " stack->o_name = q_name[h];", " #endif", " stack->o_delta = d;", "#ifndef TRIX", " memcpy(stack->body, (char *)qptr(h), d);", "#endif", " }", "#ifdef TRIX", " vsize -= sizeof(char *);", " #ifdef V_TRIX", " printf(\"%%4d: delq %%d parent %%d\\n\", depth, h, channels[h]->parent_pid);", " #endif", "#else", " vsize = q_offset[h];", " vsize -= (int) q_skip[h];", " #if !defined(NOCOMP) && !defined(HC)", " #ifdef BFS_PAR", " bfs_prepmask(3); /* delq - no change in q_offset or q_skip */", " #endif", " for (k = vsize; k < o_vsize; k++)", " Mask[k] = 0; /* reset */", " #ifdef BFS_PAR", " bfs_fixmask(3); /* delq */", " #endif", " #endif", "#endif", " now._nr_qs -= 1;", " memset((char *)qptr(h), 0, d);", "#ifdef TRIX", " #ifndef BFS", " channels[h]->nxt = freebodies;", " freebodies = channels[h];", " channels[h] = (TRIX_v6 *) 0;", " #endif", "#endif", "#ifndef NOVSZ", " now._vsz = vsize;", "#endif", "}\n", "int", "qs_empty(void)", "{ int i;", " for (i = 0; i < (int) now._nr_qs; i++)", " { if (q_sz(i) > 0)", " return 0;", " }", " return 1;", "}\n", "int", "endstate(void)", "{ int i; P0 *ptr;", " for (i = BASE; i < (int) now._nr_pr; i++)", " { ptr = (P0 *) pptr(i);", " if (!stopstate[ptr->_t][ptr->_p])", " return 0;", " }", " if (strict) return qs_empty();", "#if defined(EVENT_TRACE)", " if (!stopstate[EVENT_TRACE][now._event] && !a_cycles)", " { printf(\"pan: event_trace not completed\\n\");", " return 0;", " }", "#endif", " return 1;", "}\n", "#if !defined(SAFETY) && !defined(BFS)", "void", "checkcycles(void)", "{ uchar o_a_t = now._a_t;", " #ifndef NOFAIR", " uchar o_cnt = now._cnt[1];", " #endif", " #ifdef FULLSTACK", " #ifndef MA", " H_el *sv = trpt->ostate; /* save */", " #else", " uchar prov = trpt->proviso; /* save */", " #endif", " #endif", " #ifdef DEBUG", " { int i; uchar *v = (uchar *) &now;", " printf(\" set Seed state \");", " #ifndef NOFAIR", " if (fairness)", " printf(\"(cnt = %%d:%%d, nrpr=%%d) \",", " now._cnt[0], now._cnt[1], now._nr_pr);", " #endif", " /* for (i = 0; i < n; i++) printf(\"%%d,\", v[i]); */", " printf(\"\\n\");", " }", " printf(\"%%ld: cycle check starts\\n\", depth);", " #endif", " now._a_t |= (1|16|32);", " /* 1 = 2nd DFS; (16|32) to improve hashing */", " #ifndef NOFAIR", " now._cnt[1] = now._cnt[0];", " #endif", " memcpy((char *)&A_Root, (char *)&now, vsize);", " A_depth = depthfound = depth;", " #if NCORE>1", " mem_put_acc();", /* handoff accept states */ " #else", " new_state(); /* start 2nd DFS */", " #endif", " now._a_t = o_a_t;", " #ifndef NOFAIR", " now._cnt[1] = o_cnt;", " #endif", " A_depth = 0; depthfound = -1;", "#ifdef DEBUG", " printf(\"%%ld: cycle check returns\\n\", depth);", "#endif", "#ifdef FULLSTACK", "#ifndef MA", " trpt->ostate = sv; /* restore */", "#else", " trpt->proviso = prov;", "#endif", "#endif", "}", "#endif", "", "#if defined(FULLSTACK) && defined(BITSTATE)", "H_el *Free_list = (H_el *) 0;", "void", "onstack_init(void) /* to store stack states in a bitstate search */", "{ S_Tab = (H_el **) emalloc(maxdepth*sizeof(H_el *));", "}", "#endif", "#if !defined(BFS_PAR)", " #if defined(FULLSTACK) && defined(BITSTATE)", "H_el *", "grab_state(int n)", "{ H_el *v, *last = 0;", " if (H_tab == S_Tab)", " { for (v = Free_list; v && ((int) v->tagged >= n); v=v->nxt)", " { if ((int) v->tagged == n)", " { if (last)", " last->nxt = v->nxt;", " else", "gotcha: Free_list = v->nxt;", " v->tagged = 0;", " v->nxt = 0;", " #ifdef COLLAPSE", " v->ln = 0;", " #endif", " return v;", " }", " Fh++; last=v;", " }", " /* new: second try */", " v = Free_list;", /* try to avoid emalloc */ " if (v && ((int) v->tagged >= n))", " goto gotcha;", " ngrabs++;", " }", " return (H_el *) emalloc(sizeof(H_el)+n-sizeof(unsigned));", "}", " #else", /* !FULLSTACK || !BITSTATE */ "#if NCORE>1", "H_el *", "grab_state(int n)", "{ H_el *grab_shared(int);", " return grab_shared(sizeof(H_el)+n-sizeof(unsigned));", "}", "#else", /* ! NCORE>1 */ "#ifndef AUTO_RESIZE", " #define grab_state(n) (H_el *) \\", " emalloc(sizeof(H_el)+n-sizeof(ulong));", "#else", /* AUTO_RESIZE */ "H_el *", "grab_state(int n)", "{ H_el *p;", " int cnt = sizeof(H_el)+n-sizeof(ulong);", "#ifndef MA", " if (reclaim_size >= cnt+WS)", " { if ((cnt & (WS-1)) != 0) /* alignment */", " { cnt += WS - (cnt & (WS-1));", " }", " p = (H_el *) reclaim_mem;", " reclaim_mem += cnt;", " reclaim_size -= cnt;", " memset(p, 0, cnt);", " } else", "#endif", " { p = (H_el *) emalloc(cnt);", " }", " return p;", "}", "#endif", /* AUTO_RESIZE */ "#endif", /* NCORE>1 */ " #endif", /* FULLSTACK && !BITSTATE */ "#else", /* BFS_PAR */ " extern volatile uchar *sh_pre_malloc(ulong);", " extern volatile uchar *sh_malloc(ulong);", " H_el *", " grab_state(int n) /* bfs_par */", " { volatile uchar *rval = NULL;", " int m = sizeof(H_el) + n - sizeof(unsigned);", "", " if (n == 0) m = m/n;", " #ifdef BFS_SEP_HASH", " rval = emalloc((ulong) m);", " #else", " rval = sh_malloc((ulong) m);", " #endif", " memset((void *) rval, 0, (size_t) m);", "", " return (H_el *) rval;", " }", "#endif", /* BFS_PAR */ "#ifdef COLLAPSE", "ulong", "ordinal(char *v, long n, short tp)", "{ H_el *tmp, *ntmp; long m;", " H_el *olst = (H_el *) 0;", " s_hash((uchar *)v, n);", "#if defined(BFS_PAR) && !defined(BFS_SEP_HASH)", " e_critical(BFS_ID); /* bfs_par / collapse */", "#endif", "#if NCORE>1 && !defined(SEP_STATE)", " enter_critical(CS_ID); /* uses spinlock - 1..128 */", "#endif", " tmp = H_tab[j1_spin];", " if (!tmp)", " { tmp = grab_state(n);", " H_tab[j1_spin] = tmp;", " } else", " for ( ;; olst = tmp, tmp = tmp->nxt)", " { if (n == tmp->ln)", " { m = memcmp(((char *)&(tmp->state)), v, n);", " if (m == 0)", " goto done;", " if (m < 0)", " {", "Insert: ntmp = grab_state(n);", " ntmp->nxt = tmp;", " if (!olst)", " H_tab[j1_spin] = ntmp;", " else", " olst->nxt = ntmp;", " tmp = ntmp;", " break;", " } else if (!tmp->nxt)", " {", "Append: tmp->nxt = grab_state(n);", " tmp = tmp->nxt;", " break;", " }", " continue;", " }", " if (n < tmp->ln)", " goto Insert;", " else if (!tmp->nxt)", " goto Append;", " }", "#if NCORE>1 && !defined(SEP_STATE)", " enter_critical(GLOBAL_LOCK);", "#endif", "#ifdef BFS_PAR", " e_critical(BFS_ORD); /* bfs_par */", "#endif", " m = ++ncomps[tp];", "#ifdef BFS_PAR", " x_critical(BFS_ORD);", "#endif", "#if NCORE>1 && !defined(SEP_STATE)", " leave_critical(GLOBAL_LOCK);", "#endif", "#ifdef FULLSTACK", " tmp->tagged = m;", "#else", " tmp->st_id = m;", "#endif", "#if defined(AUTO_RESIZE) && !defined(BITSTATE)", " tmp->m_K1 = K1;", "#endif", " memcpy(((char *)&(tmp->state)), v, n);", " tmp->ln = n;", "done:", "#if NCORE>1 && !defined(SEP_STATE)", " leave_critical(CS_ID);", "#endif", "#if defined(BFS_PAR) && !defined(BFS_SEP_HASH)", " x_critical(BFS_ID);", "#endif", "#ifdef FULLSTACK", " return tmp->tagged;", "#else", " return tmp->st_id;", "#endif", "}", "", "int", "compress(char *vin, int nin) /* collapse compression */", "{ char *w, *v = (char *) &comp_now;", " int i, j;", " ulong n;", " static char *x;", " static uchar nbytes[513]; /* 1 + 256 + 256 */", " static unsigned short nbytelen;", " long col_q(int, char *);", " long col_p(int, char *);", "#ifndef SAFETY", " if (a_cycles)", " *v++ = now._a_t;", "#ifndef NOFAIR", " if (fairness)", " for (i = 0; i < NFAIR; i++)", " *v++ = now._cnt[i];", "#endif", "#endif", " nbytelen = 0;", "#ifndef JOINPROCS", " for (i = 0; i < (int) now._nr_pr; i++)", " { n = col_p(i, (char *) 0);", "#ifdef NOFIX", " nbytes[nbytelen] = 0;", "#else", " nbytes[nbytelen] = 1;", " *v++ = ((P0 *) pptr(i))->_t;", "#endif", " *v++ = n&255;", " if (n >= (1<<8))", " { nbytes[nbytelen]++;", " *v++ = (n>>8)&255;", " }", " if (n >= (1<<16))", " { nbytes[nbytelen]++;", " *v++ = (n>>16)&255;", " }", " if (n >= (1<<24))", " { nbytes[nbytelen]++;", " *v++ = (n>>24)&255;", " }", " nbytelen++;", " }", "#else", " x = scratch;", " for (i = 0; i < (int) now._nr_pr; i++)", " x += col_p(i, x);", " n = ordinal(scratch, x-scratch, 2); /* procs */", " *v++ = n&255;", " nbytes[nbytelen] = 0;", " if (n >= (1<<8))", " { nbytes[nbytelen]++;", " *v++ = (n>>8)&255;", " }", " if (n >= (1<<16))", " { nbytes[nbytelen]++;", " *v++ = (n>>16)&255;", " }", " if (n >= (1<<24))", " { nbytes[nbytelen]++;", " *v++ = (n>>24)&255;", " }", " nbytelen++;", "#endif", "#ifdef SEPQS", " for (i = 0; i < (int) now._nr_qs; i++)", " { n = col_q(i, (char *) 0);", " nbytes[nbytelen] = 0;", " *v++ = n&255;", " if (n >= (1<<8))", " { nbytes[nbytelen]++;", " *v++ = (n>>8)&255;", " }", " if (n >= (1<<16))", " { nbytes[nbytelen]++;", " *v++ = (n>>16)&255;", " }", " if (n >= (1<<24))", " { nbytes[nbytelen]++;", " *v++ = (n>>24)&255;", " }", " nbytelen++;", " }", "#endif", "#ifdef NOVSZ", " /* 3 = _a_t, _nr_pr, _nr_qs */", " w = (char *) &now + 3 * sizeof(uchar);", "#ifndef NOFAIR", " w += NFAIR;", "#endif", "#else", "#if VECTORSZ<65536", " w = (char *) &(now._vsz) + sizeof(unsigned short);", "#else", " w = (char *) &(now._vsz) + sizeof(ulong);", "#endif", "#endif", " x = scratch;", " *x++ = now._nr_pr;", " *x++ = now._nr_qs;", " if (now._nr_qs > 0 && qptr(0) < pptr(0))", " n = qptr(0) - (uchar *) w;", " else", " n = pptr(0) - (uchar *) w;", " j = w - (char *) &now;", "", "#if !defined(NOCOMP) && !defined(HC)", " for (i = 0; i < (int) n; i++, w++)", " if (!Mask[j++]) *x++ = *w;", "#else", " memcpy(x, w, n); x += n;", "#endif", "", "#ifndef SEPQS", " for (i = 0; i < (int) now._nr_qs; i++)", " x += col_q(i, x);", "#endif", " x--;", " for (i = 0, j = 6; i < nbytelen; i++)", " { if (j == 6)", " { j = 0;", " *(++x) = 0;", " } else", " j += 2;", " *x |= (nbytes[i] << j);", " }", " x++;", " for (j = 0; j < WS-1; j++)", " *x++ = 0;", " x -= j; j = 0;", " n = ordinal(scratch, x-scratch, 0); /* globals */", " *v++ = n&255;", " if (n >= (1<< 8)) { *v++ = (n>> 8)&255; j++; }", " if (n >= (1<<16)) { *v++ = (n>>16)&255; j++; }", " if (n >= (1<<24)) { *v++ = (n>>24)&255; j++; }", " *v++ = j; /* add last count as a byte */", " for (i = 0; i < WS-1; i++)", " *v++ = 0;", " v -= i;", "#if 0", " printf(\"collapse %%d -> %%d\\n\",", " vsize, v - (char *)&comp_now);", "#endif", " return v - (char *)&comp_now;", "}", "#else", /* !COLLAPSE */ "#if !defined(NOCOMP)", "int", "compress(char *vin, int n) /* default compression */", "{", "#ifdef HC", " int delta = 0;", " s_hash((uchar *)vin, n); /* sets K1 and K2 */", "#ifndef SAFETY", " if (S_A)", " { delta++; /* _a_t */", "#ifndef NOFAIR", " if (S_A > NFAIR)", " delta += NFAIR; /* _cnt[] */", "#endif", " }", "#endif", " memcpy((char *) &comp_now + delta, (char *) &K1, WS);", " delta += WS;", "#if HC>0", " memcpy((char *) &comp_now + delta, (char *) &K2, HC);", " delta += HC;", "#endif", " return delta;", "#else", " char *vv = vin;", " char *v = (char *) &comp_now;", " int i;", " #ifndef NO_FAST_C", /* disable faster compress */ " int r = 0, unroll = n/8;", /* most sv are much longer */ " if (unroll > 0)", " { i = 0;", " while (r++ < unroll)", " { /* unroll 8 times, avoid ifs */", " /* 1 */ *v = *vv++; v += 1 - Mask[i++];", " /* 2 */ *v = *vv++; v += 1 - Mask[i++];", " /* 3 */ *v = *vv++; v += 1 - Mask[i++];", " /* 4 */ *v = *vv++; v += 1 - Mask[i++];", " /* 5 */ *v = *vv++; v += 1 - Mask[i++];", " /* 6 */ *v = *vv++; v += 1 - Mask[i++];", " /* 7 */ *v = *vv++; v += 1 - Mask[i++];", " /* 8 */ *v = *vv++; v += 1 - Mask[i++];", " }", " r = n - i; /* the rest, at most 7 */", " switch (r) {", " case 7: *v = *vv++; v += 1 - Mask[i++];", " case 6: *v = *vv++; v += 1 - Mask[i++];", " case 5: *v = *vv++; v += 1 - Mask[i++];", " case 4: *v = *vv++; v += 1 - Mask[i++];", " case 3: *v = *vv++; v += 1 - Mask[i++];", " case 2: *v = *vv++; v += 1 - Mask[i++];", " case 1: *v = *vv++; v += 1 - Mask[i++];", " case 0: break;", " }", " n = i = v - (char *)&comp_now; /* bytes written so far */", " r = (n+WS-1)/WS; /* in words, rounded up */", " r *= WS; /* total bytes to fill */", " i = r - i; /* remaining bytes */", " switch (i) {", /* fill word */ " case 7: *v++ = 0; /* fall thru */", " case 6: *v++ = 0;", " case 5: *v++ = 0;", " case 4: *v++ = 0;", " case 3: *v++ = 0;", " case 2: *v++ = 0;", " case 1: *v++ = 0;", " case 0: break;", " default: Uerror(\"unexpected wordsize\");", " }", " v -= i;", " } else", " #endif", " { for (i = 0; i < n; i++, vv++)", " if (!Mask[i]) *v++ = *vv;", " for (i = 0; i < WS-1; i++)", " *v++ = 0;", " v -= i;", " }", "#if 0", " printf(\"compress %%d -> %%d\\n\",", " n, v - (char *)&comp_now);", "#endif", " return v - (char *)&comp_now;", "#endif", "}", "#endif", "#endif", /* COLLAPSE */ "#if defined(FULLSTACK) && defined(BITSTATE)", "#if defined(MA)", "#if !defined(onstack_now)", "int onstack_now(void) {}", /* to suppress compiler errors */ "#endif", "#if !defined(onstack_put)", "void onstack_put(void) {}", /* for this invalid combination */ "#endif", "#if !defined(onstack_zap)", "void onstack_zap(void) {}", /* of directives */ "#endif", "#else", "void", "onstack_zap(void)", "{ H_el *v, *w, *last = 0;", " H_el **tmp = H_tab;", " char *nv; int n, m;", " static char warned = 0;", "#if defined(BCS) && defined(NO_LAST) && defined(HAS_LAST)", " uchar was_last = now._last;", " now._last = 0;", "#endif", "", " H_tab = S_Tab;", "#ifndef NOCOMP", " nv = (char *) &comp_now;", " n = compress((char *)&now, vsize);", "#else", "#if defined(BITSTATE) && defined(LC)", " nv = (char *) &comp_now;", " n = compact_stack((char *)&now, vsize);", "#else", " nv = (char *) &now;", " n = vsize;", "#endif", "#endif", "#if !defined(HC) && !(defined(BITSTATE) && defined(LC))", " s_hash((uchar *)nv, n);", "#endif", " H_tab = tmp;", " for (v = S_Tab[j1_spin]; v; Zh++, last=v, v=v->nxt)", " { m = memcmp(&(v->state), nv, n);", " if (m == 0)", " goto Found;", " if (m < 0)", " break;", " }", "/* NotFound: */", "#ifndef ZAPH", " /* seen this happen, likely harmless in multicore */", " if (warned == 0)", " { /* Uerror(\"stack out of wack - zap\"); */", " cpu_printf(\"pan: warning, stack incomplete\\n\");", " warned = 1;", " }", "#endif", " goto done;", "Found:", " ZAPS++;", " if (last)", " last->nxt = v->nxt;", " else", " S_Tab[j1_spin] = v->nxt;", " v->tagged = (unsigned) n;", "#if !defined(NOREDUCE) && !defined(SAFETY)", " v->proviso = 0;", "#endif", " v->nxt = last = (H_el *) 0;", " for (w = Free_list; w; Fa++, last=w, w = w->nxt)", " { if ((int) w->tagged <= n)", " { if (last)", " { v->nxt = w;", " last->nxt = v;", " } else", " { v->nxt = Free_list;", " Free_list = v;", " }", " goto done;", " }", " if (!w->nxt)", " { w->nxt = v;", " goto done;", " } }", " Free_list = v;", "done:", "#if defined(BCS) && defined(NO_LAST) && defined(HAS_LAST)", " now._last = was_last;", "#endif", " return;", "}", "", "#ifndef BFS_PAR", " void", " onstack_put(void)", " { H_el **tmp = H_tab;", " #if defined(BCS) && defined(NO_LAST) && defined(HAS_LAST)", " uchar was_last = now._last;", " now._last = 0;", " #endif", " H_tab = S_Tab;", " if (h_store((char *)&now, vsize) != 0)", " #if defined(BITSTATE) && defined(LC)", " printf(\"pan: warning, double stack entry\\n\");", " #else", " #ifndef ZAPH", " Uerror(\"cannot happen - unstack_put\");", " #endif", " #endif", " H_tab = tmp;", " trpt->ostate = Lstate;", " PUT++;", " #if defined(BCS) && defined(NO_LAST) && defined(HAS_LAST)", " now._last = was_last;", " #endif", " }", " int", " onstack_now(void)", " { H_el *tmp;", " H_el **tmp2 = H_tab;", " char *v; int n, m = 1;\n", " #if defined(BCS) && defined(NO_LAST) && defined(HAS_LAST)", " uchar was_last = now._last;", " now._last = 0;", " #endif", " H_tab = S_Tab;", " #ifdef NOCOMP", " #if defined(BITSTATE) && defined(LC)", " v = (char *) &comp_now;", " n = compact_stack((char *)&now, vsize);", " #else", " v = (char *) &now;", " n = vsize;", " #endif", " #else", " v = (char *) &comp_now;", " n = compress((char *)&now, vsize);", " #endif", " #if !defined(HC) && !(defined(BITSTATE) && defined(LC))", " s_hash((uchar *)v, n);", " #endif", " H_tab = tmp2;", " for (tmp = S_Tab[j1_spin]; tmp; Zn++, tmp = tmp->nxt)", " { m = memcmp(((char *)&(tmp->state)),v,n);", " if (m <= 0)", " { Lstate = (H_el *) tmp; /* onstack_now */", " break;", " } }", " PROBE++;", " #if defined(BCS) && defined(NO_LAST) && defined(HAS_LAST)", " now._last = was_last;", " #endif", " return (m == 0);", " }", "#endif", /* !BFS_PAR */ "#endif", /* !MA */ "#endif", /* FULLSTACK && BITSTATE */ "#ifdef BITSTATE", "void init_SS(ulong);", "", "void", "sinit(void)", "{", " if (udmem)", " { udmem *= 1024L*1024L;", " #if NCORE>1", " if (!readtrail)", " { init_SS((ulong) udmem);", " } else", " #endif", " #if defined(BFS_PAR) && !defined(BFS_SEP_HASH)", " SS = (uchar *) sh_pre_malloc((ulong) udmem);", " #else", " SS = (uchar *) emalloc(udmem);", " #endif", " b_store = bstore_mod;", " } else", " {", " #if NCORE>1", " init_SS(ONE_L<<(ssize-3));", " #else", " #if defined(BFS_PAR) && !defined(BFS_SEP_HASH)", " SS = (uchar *) sh_pre_malloc((ulong)(ONE_L<<(ssize-3)));", " #else", " SS = (uchar *) emalloc(ONE_L<<(ssize-3));", " #endif", " #endif", " }", "}", "#else", " #if !defined(MA) || defined(COLLAPSE)", " void", " set_H_tab(void)", " {", " #if defined(BFS_PAR) && !defined(BFS_SEP_HASH)", " H_tab = (H_el **) sh_pre_malloc((ulong)((ONE_L<1 && !defined(COLLAPSE)", " if (!readtrail)", " { void init_HT(ulong);", " init_HT(0L);", " }", " #endif", " #endif", " #endif", " #if !defined(MA) || defined(COLLAPSE)", " #if NCORE>1 || (defined(BFS_PAR) && defined(USE_TDH) && !defined(WIN32) && !defined(WIN64))", " if (!readtrail)", " { void init_HT(ulong);", " init_HT((ulong) (ONE_L<= MA)", " { printf(\"pan: error, MA too small, recompile pan.c\");", " printf(\" with -DMA=N with N>%%d\\n\", n);", " Uerror(\"aborting\");", " }", " if (n > (int) maxgs)", " { maxgs = (uint) n;", " }", " for (i = 0; i < n; i++)", " { Info[i] = v[i];", " }", " for ( ; i < MA-1; i++)", " { Info[i] = 0;", " }", " Info[MA-1] = pbit;", " if (a_cycles) /* place _a_t at the end */", " { Info[MA] = Info[0];", " Info[0] = 0;", " }", "", "#ifdef BFS_PAR", " e_critical(BFS_STATE); /* bfs_par / g_store */", "#endif", "#if NCORE>1 && !defined(SEP_STATE)", " enter_critical(GLOBAL_LOCK); /* crude, but necessary */", " /* to make this mode work, also replace emalloc with grab_shared inside store MA routines */", "#endif", "", " if (!dfa_store(Info))", " { if (pbit == 0", " && (now._a_t&1)", " && depth > A_depth)", " { Info[MA] &= ~(1|16|32); /* _a_t */", " if (dfa_member(MA))", /* was !dfa_member(MA) */ " { Info[MA-1] = 4; /* off-stack bit */", " nShadow++;", " if (!dfa_member(MA-1))", " { ret_val = 3;", " #ifdef VERBOSE", " printf(\"intersected 1st dfs stack\\n\");", " #endif", " goto done;", " } } }", " ret_val = 0;", " #ifdef VERBOSE", " printf(\"new state\\n\");", " #endif", " goto done;", " }", "#ifdef FULLSTACK", " if (pbit == 0)", " { Info[MA-1] = 1; /* proviso bit */", "#ifndef BFS", " trpt->proviso = dfa_member(MA-1);", "#endif", " Info[MA-1] = 4; /* off-stack bit */", " if (dfa_member(MA-1))", " { ret_val = 1; /* off-stack */", " #ifdef VERBOSE", " printf(\"old state\\n\");", " #endif", " } else", " { ret_val = 2; /* on-stack */", " #ifdef VERBOSE", " printf(\"on-stack\\n\");", " #endif", " }", " goto done;", " }", "#endif", " ret_val = 1;", "#ifdef VERBOSE", " printf(\"old state\\n\");", "#endif", "done:", "#ifdef BFS_PAR", " x_critical(BFS_STATE);", "#endif", "#if NCORE>1 && !defined(SEP_STATE)", " leave_critical(GLOBAL_LOCK);", "#endif", " return ret_val; /* old state */", "}", "#endif", "#if defined(BITSTATE) && defined(LC)", "int", "compact_stack(char *vin, int n)", /* special case of HC4 */ "{ int delta = 0;", " s_hash((uchar *)vin, n); /* sets K1 and K2 */", "#ifndef SAFETY", " delta++; /* room for state[0] |= 128 */", "#endif", " memcpy((char *) &comp_now + delta, (char *) &K1, WS);", " delta += WS;", " memcpy((char *) &comp_now + delta, (char *) &K2, WS);", " delta += WS; /* use all available bits */", " return delta;", "}", "#endif", "#ifdef TRIX", "void", "sv_populate(void)", "{ int i, cnt = 0;", " TRIX_v6 **base = processes;", " int bound = now._nr_pr; /* MAXPROC+1; */", "#ifdef V_TRIX", " printf(\"%%4d: sv_populate\\n\", depth);", "#endif", "again:", " for (i = 0; i < bound; i++)", " { if (base[i] != NULL)", " { H_el *tmp;", " int m, n; uchar *v;", "#ifndef BFS", " if (base[i]->modified == 0)", " { cnt++;", " #ifdef V_TRIX", " printf(\"%%4d: %%s %%d not modified\\n\",", " depth, (base == processes)?\"proc\":\"chan\", i);", " #endif", " continue;", " }", " #ifndef V_MOD", " base[i]->modified = 0;", " #endif", "#endif", "#ifdef TRIX_RIX", " if (base == processes)", " { ((P0 *)pptr(i))->_pid = 0;", " }", "#endif", " n = base[i]->psize;", " v = base[i]->body;", " s_hash(v, n); /* sets j1_spin */", " tmp = H_tab[j1_spin];", " if (!tmp) /* new */", " { tmp = grab_state(n);", " H_tab[j1_spin] = tmp;", " m = 1; /* non-zero */", " } else", " { H_el *ntmp, *olst = (H_el *) 0;", " for (;; hcmp++, olst = tmp, tmp = tmp->nxt)", " { m = memcmp(((char *)&(tmp->state)), v, n);", " if (m == 0) /* match */", " { break;", " } else if (m < 0) /* insert */", " { ntmp = grab_state(n);", " ntmp->nxt = tmp;", " if (!olst)", " H_tab[j1_spin] = ntmp;", " else", " olst->nxt = ntmp;", " tmp = ntmp;", " break;", " } else if (!tmp->nxt) /* append */", " { tmp->nxt = grab_state(n);", " tmp = tmp->nxt;", " break;", " } } }", " if (m != 0)", " { memcpy((char *)&(tmp->state), v, n);", "#if defined(AUTO_RESIZE) && !defined(BITSTATE)", " tmp->m_K1 = K1; /* set via s_hash */", "#endif", " if (verbose)", " { if (base == processes)", " { _p_count[i]++;", " } else", " { _c_count[i]++;", " } } }", " now._ids_[cnt++] = (char *)&(tmp->state);", "#ifdef TRIX_RIX", " if (base == processes)", " { ((P0 *)pptr(i))->_pid = i;", " if (BASE > 0 && i > 0)", " { ((P0 *)pptr(i))->_pid -= BASE;", " } }", "#endif", " } }", #if 0 if a process appears or disappears: always secure a full sv_populate (channels come and go only with a process) only one process can disappear per step but any nr of channels can be removed at the same time if a process disappears, all subsequent entries are then in the wrong place in the _ids_ list and need to be recomputed but we do not need to fill out with zeros because vsize prevents them being used #endif " /* do the same for all channels */", " if (base == processes)", " { base = channels;", " bound = now._nr_qs; /* MAXQ+1; */", " goto again;", " }", "}", "#endif\n", "#if !defined(BFS_PAR) || (!defined(BITSTATE) && !defined(USE_TDH))", "int", "h_store(char *vin, int nin) /* hash table storage */", "{ H_el *ntmp;", " H_el *tmp, *olst = (H_el *) 0;", " char *v; int n, m=0;", " #ifdef HC", " uchar rem_a;", " #endif", " #ifdef TRIX", " sv_populate(); /* update proc and chan ids */", " #endif", " #ifdef NOCOMP", /* defined by BITSTATE */ " #if defined(BITSTATE) && defined(LC)", " if (S_Tab == H_tab)", " { v = (char *) &comp_now;", " n = compact_stack(vin, nin);", " } else", " { v = vin; n = nin;", " }", " #else", " v = vin; n = nin;", " #endif", " #else", " v = (char *) &comp_now;", " #ifdef HC", " rem_a = now._a_t;", /* new 5.0 */ " now._a_t = 0;", /* for hashing/state matching to work right */ " #endif", " n = compress(vin, nin);", /* with HC, this calls s_hash -- but on vin, not on v... */ " #ifdef HC", " now._a_t = rem_a;", /* new 5.0 */ " #endif", /* with HC4 -a, compress copies K1 and K2 into v[], leaving v[0] free for the a-bit */ "#ifndef SAFETY", " if (S_A)", " { v[0] = 0; /* _a_t */", "#ifndef NOFAIR", " if (S_A > NFAIR)", " for (m = 0; m < NFAIR; m++)", " v[m+1] = 0; /* _cnt[] */", "#endif", " m = 0;", " }", " #endif", " #endif", " #if !defined(HC) && !(defined(BITSTATE) && defined(LC))", " s_hash((uchar *)v, n);", " #endif", " /* for BFS_PAR we can only get here in BITSTATE mode */", " /* and in that case we don't use locks */", " #if defined(BFS_PAR) && !defined(BFS_SEP_HASH)", " e_critical(BFS_ID); /* bfs_par / h_store */", " #endif", " #if NCORE>1 && !defined(SEP_STATE) && !defined(BITSTATE)", " enter_critical(CS_ID);", " #endif", " tmp = H_tab[j1_spin];", " if (!tmp)", " { tmp = grab_state(n);", /* no zero-returns with bfs_par */ " #if NCORE>1", " if (!tmp)", " { /* if we get here -- we've already issued a warning */", " /* but we want to allow the normal distributed termination */", " /* to collect the stats on all cpus in the wrapup */", " #if !defined(SEP_STATE) && !defined(BITSTATE)", " leave_critical(CS_ID);", " #endif", " return 1; /* allow normal termination */", " }", " #endif", " H_tab[j1_spin] = tmp;", " } else", " { for (;; hcmp++, olst = tmp, tmp = tmp->nxt)", " { /* skip the _a_t and the _cnt bytes */", " #ifdef COLLAPSE", " if (tmp->ln != 0)", " { if (!tmp->nxt) goto Append;", " continue;", " }", " #endif", " m = memcmp(((char *)&(tmp->state)) + S_A, ", " v + S_A, n - S_A);", " if (m == 0) {", " #ifdef SAFETY", "#define wasnew 0", " #else", " int wasnew = 0;", " #endif", " #if !defined(SAFETY) && !defined(NOCOMP)", " if (S_A)", " { if ((((char *)&(tmp->state))[0] & V_A) != V_A)", " { wasnew = 1; nShadow++;", " ((char *)&(tmp->state))[0] |= V_A;", " }", "#ifndef NOFAIR", " if (S_A > NFAIR)", " { /* 0 <= now._cnt[now._a_t&1] < MAXPROC */", " uint ci, bp; /* index, bit pos */", " ci = (now._cnt[now._a_t&1] / 8);", " bp = (now._cnt[now._a_t&1] - 8*ci);", " if (now._a_t&1) /* use tail-bits in _cnt */", " { ci = (NFAIR - 1) - ci;", " bp = 7 - bp; /* bp = 0..7 */", " }", " ci++; /* skip over _a_t */", " bp = 1 << bp; /* the bit mask */", " if ((((char *)&(tmp->state))[ci] & bp)==0)", " { if (!wasnew)", " { wasnew = 1;", " nShadow++;", " }", " ((char *)&(tmp->state))[ci] |= bp;", " }", " }", " /* else: wasnew == 0, i.e., old state */", "#endif", " }", " #endif", " #if NCORE>1", " Lstate = (H_el *) tmp; /* h_store */", " #endif", "#ifdef FULLSTACK", "#ifndef SAFETY", /* or else wasnew == 0 */ " if (wasnew)", " { Lstate = (H_el *) tmp; /* h_store */", " tmp->tagged |= V_A;", " if ((now._a_t&1)", " && (tmp->tagged&A_V)", " && depth > A_depth)", " {", "intersect:", "#ifdef CHECK", " #if NCORE>1", " printf(\"cpu%%d: \", core_id);", " #endif", " printf(\"1st dfs-stack intersected on state %%d+\\n\",", " (int) tmp->st_id);", "#endif", " #if defined(BFS_PAR) && !defined(BFS_SEP_HASH)", " x_critical(BFS_ID);", " #endif", " #if NCORE>1 && !defined(SEP_STATE) && !defined(BITSTATE)", " leave_critical(CS_ID);", " #endif", " return 3;", " }", "#ifdef CHECK", " #if NCORE>1", " printf(\"cpu%%d: \", core_id);", " #endif", " printf(\"\tNew state %%d+\\n\", (int) tmp->st_id);", "#endif", "#ifdef DEBUG", " dumpstate(1, (char *)&(tmp->state),n,tmp->tagged);", "#endif", " #if defined(BFS_PAR) && !defined(BFS_SEP_HASH)", " x_critical(BFS_ID);", " #endif", " #if NCORE>1 && !defined(SEP_STATE) && !defined(BITSTATE)", " leave_critical(CS_ID);", " #endif", " return 0;", " } else", "#endif", " if ((S_A)?(tmp->tagged&V_A):tmp->tagged)", " { Lstate = (H_el *) tmp; /* h_store */", "#ifndef SAFETY", " /* already on current dfs stack */", " /* but may also be on 1st dfs stack */", " if ((now._a_t&1)", " && (tmp->tagged&A_V)", " && depth > A_depth", /* new (Zhang's example) */ "#ifndef NOFAIR", " && (!fairness || now._cnt[1] <= 1)", "#endif", " )", " goto intersect;", "#endif", "#ifdef CHECK", " #if NCORE>1", " printf(\"cpu%%d: \", core_id);", " #endif", " printf(\"\tStack state %%d\\n\", (int) tmp->st_id);", "#endif", "#ifdef DEBUG", " dumpstate(0, (char *)&(tmp->state),n,tmp->tagged);", "#endif", " #if defined(BFS_PAR) && !defined(BFS_SEP_HASH)", " x_critical(BFS_ID);", " #endif", " #if NCORE>1 && !defined(SEP_STATE) && !defined(BITSTATE)", " leave_critical(CS_ID);", " #endif", " return 2; /* match on stack */", " }", "#else", " if (wasnew)", " {", "#ifdef CHECK", " #if NCORE>1", " printf(\"cpu%%d: \", core_id);", " #endif", " printf(\"\tNew state %%d+\\n\", (int) tmp->st_id);", "#endif", "#ifdef DEBUG", " dumpstate(1, (char *)&(tmp->state), n, 0);", "#endif", " #if defined(BFS_PAR) && !defined(BFS_SEP_HASH)", " x_critical(BFS_ID);", " #endif", " #if NCORE>1 && !defined(SEP_STATE) && !defined(BITSTATE)", " leave_critical(CS_ID);", " #endif", " return 0;", " }", "#endif", "#ifdef CHECK", "#if NCORE>1", " printf(\"cpu%%d: \", core_id);", "#endif", " printf(\"\tOld state %%d\\n\", (int) tmp->st_id);", "#endif", "#ifdef DEBUG", " dumpstate(0, (char *)&(tmp->state), n, 0);", "#endif", "#if defined(BCS)", " #ifdef CONSERVATIVE", " if (tmp->ctx_low > trpt->sched_limit)", " { tmp->ctx_low = trpt->sched_limit;", " tmp->ctx_pid[(now._last)/8] = 1 << ((now._last)%%8); /* new */", " #ifdef CHECK", " #if NCORE>1", " printf(\"cpu%%d: \", core_id);", " #endif", " printf(\"\t\tRevisit with fewer context switches\\n\");", " #endif", " nstates--;", " #if defined(BFS_PAR) && !defined(BFS_SEP_HASH)", " x_critical(BFS_ID);", " #endif", " #if NCORE>1 && !defined(SEP_STATE) && !defined(BITSTATE)", " leave_critical(CS_ID);", " #endif", " return 0;", " } else if ((tmp->ctx_low == trpt->sched_limit", " && (tmp->ctx_pid[(now._last)/8] & ( 1 << ((now._last)%%8) )) == 0 ))", " { tmp->ctx_pid[(now._last)/8] |= 1 << ((now._last)%%8); /* add */", " #ifdef CHECK", " #if NCORE>1", " printf(\"cpu%%d: \", core_id);", " #endif", " printf(\"\t\tRevisit with same nr of context switches\\n\");", " #endif", " nstates--;", " #if defined(BFS_PAR) && !defined(BFS_SEP_HASH)", " x_critical(BFS_ID);", " #endif", " #if NCORE>1 && !defined(SEP_STATE) && !defined(BITSTATE)", " leave_critical(CS_ID);", " #endif", " return 0;", " }", " #endif", "#endif", " #ifdef REACH", " if (tmp->D > depth)", " { tmp->D = depth;", " #ifdef CHECK", " #if NCORE>1", " printf(\"cpu%%d: \", core_id);", " #endif", " printf(\"\t\tReVisiting (from smaller depth)\\n\");", " #endif", " nstates--;", " #if defined(BFS_PAR) && !defined(BFS_SEP_HASH)", " x_critical(BFS_ID);", " #endif", " #if NCORE>1 && !defined(SEP_STATE) && !defined(BITSTATE)", " leave_critical(CS_ID);", " #endif", #if 0 a possible variation of iterative search for shortest counter-example (pan -i and pan -I) suggested by Pierre Moro (for safety properties): state revisits on shorter depths do not start until after the first counter-example is found. this assumes that the max search depth is set large enough that a first (possibly long) counter-example can be found if set too short, this variant can miss the counter-example, even if it would otherwise be shorter than the depth-limit. (p.m. unsure if this preserves the guarantee of finding the shortest counter-example - so not enabled by default) " if (errors > 0 && iterative)", /* Moro */ #endif " return 0;", " }", " #endif", " #if (defined(BFS) && defined(Q_PROVISO)) || NCORE>1", " Lstate = (H_el *) tmp; /* h_store */", " #endif", " #if defined(BFS_PAR) && !defined(BFS_SEP_HASH)", " x_critical(BFS_ID);", " #endif", " #if NCORE>1 && !defined(SEP_STATE) && !defined(BITSTATE)", " leave_critical(CS_ID);", " #endif", " return 1; /* match outside stack */", " } else if (m < 0)", " { /* insert state before tmp */", " ntmp = grab_state(n);", " #if NCORE>1", " if (!ntmp)", " {", " #if !defined(SEP_STATE) && !defined(BITSTATE)", " leave_critical(CS_ID);", " #endif", " return 1; /* allow normal termination */", " }", " #endif", " ntmp->nxt = tmp;", " if (!olst)", " H_tab[j1_spin] = ntmp;", " else", " olst->nxt = ntmp;", " tmp = ntmp;", " break;", " } else if (!tmp->nxt)", " { /* append after tmp */", " #ifdef COLLAPSE", "Append:", " #endif", " tmp->nxt = grab_state(n);", " #if NCORE>1", " if (!tmp->nxt)", " {", " #if !defined(SEP_STATE) && !defined(BITSTATE)", " leave_critical(CS_ID);", " #endif", " return 1; /* allow normal termination */", " }", " #endif", " tmp = tmp->nxt;", " break;", " } }", " }", " #ifdef CHECK", " tmp->st_id = (unsigned) nstates;", " #if NCORE>1", " printf(\"cpu%%d: \", core_id);", " #endif", "#ifdef BITSTATE", " printf(\" Push state %%d\\n\", ((int) nstates) - 1);", "#else", " printf(\" New state %%d\\n\", (int) nstates);", "#endif", "#endif", " #if defined(BCS)", " tmp->ctx_low = trpt->sched_limit;", " #ifdef CONSERVATIVE", " tmp->ctx_pid[(now._last)/8] = 1 << ((now._last)%%8); /* new limit */", " #endif", " #endif", " #if !defined(SAFETY) || defined(REACH)", " tmp->D = depth;", " #endif", " #if !defined(SAFETY) && !defined(NOCOMP)", " if (S_A)", " { v[0] = V_A;", "#ifndef NOFAIR", " if (S_A > NFAIR)", " { uint ci, bp; /* as above */", " ci = (now._cnt[now._a_t&1] / 8);", " bp = (now._cnt[now._a_t&1] - 8*ci);", " if (now._a_t&1)", " { ci = (NFAIR - 1) - ci;", " bp = 7 - bp; /* bp = 0..7 */", " }", " v[1+ci] = 1 << bp;", " }", "#endif", " }", " #endif", " #if defined(AUTO_RESIZE) && !defined(BITSTATE)", " tmp->m_K1 = K1;", " #endif", " memcpy(((char *)&(tmp->state)), v, n);", " #ifdef FULLSTACK", " tmp->tagged = (S_A)?V_A:(depth+1);", "#ifdef DEBUG", " dumpstate(-1, v, n, tmp->tagged);", "#endif", " Lstate = (H_el *) tmp; /* end of h_store */", " #else", " #ifdef DEBUG", " dumpstate(-1, v, n, 0);", " #endif", " #if NCORE>1", " Lstate = (H_el *) tmp; /* end of h_store */", " #endif", " #endif", " #if defined(BFS_PAR) && !defined(BFS_SEP_HASH)", " x_critical(BFS_ID);", " #endif", " #if NCORE>1", " #ifdef V_PROVISO", " tmp->cpu_id = core_id;", " #endif", " #if !defined(SEP_STATE) && !defined(BITSTATE)", " leave_critical(CS_ID);", " #endif", " #endif", " return 0;", "}", /* end of h_store */ "#endif", /* !BFS_PAR || !USE_TDH */ "", "void", "o_hash32(uchar *s, int len, int h) /* 32-bit, like d_sfh, but with seed */", "{ uint32_t tmp;", " int rem;", "", " rem = len & 3;", " len >>= 2;", "", " for ( ; len > 0; len--)", " { h += get16bits(s);", " tmp = (get16bits(s+2) << 11) ^ h;", " h = (h << 16) ^ tmp;", " s += 2*sizeof(uint16_t);", " h += h >> 11;", " }", " switch (rem) {", " case 3: h += get16bits(s);", " h ^= h << 16;", " h ^= s[sizeof(uint16_t)] << 18;", " h += h >> 11;", " break;", " case 2: h += get16bits(s);", " h ^= h << 11;", " h += h >> 17;", " break;", " case 1: h += *s;", " h ^= h << 10;", " h += h >> 1;", " break;", " }", " h ^= h << 3;", " h += h >> 5;", " h ^= h << 4;", " h += h >> 17;", " h ^= h << 25;", " h += h >> 6;", "", " K1 = h;", "}", "void", "o_hash64(uchar *kb, int nbytes, int seed)", /* 64-bit hash */ "{ uint8_t *bp;", " uint64_t a, b, c, n;", " const uint64_t *k = (uint64_t *) kb;", " n = nbytes/WS; /* nr of 8-byte chunks */", " /* extend to multiple of words, if needed */", " a = WS - (nbytes %% WS);", " if (a > 0 && a < WS)", " { n++;", " bp = kb + nbytes;", " switch (a) {", " case 7: *bp++ = 0; /* fall thru */", " case 6: *bp++ = 0; /* fall thru */", " case 5: *bp++ = 0; /* fall thru */", " case 4: *bp++ = 0; /* fall thru */", " case 3: *bp++ = 0; /* fall thru */", " case 2: *bp++ = 0; /* fall thru */", " case 1: *bp = 0;", " case 0: break;", " } }", " a = (uint64_t) seed;", " b = HASH_CONST[HASH_NR];", " c = 0x9e3779b97f4a7c13LL; /* arbitrary */", " while (n >= 3)", " { a += k[0];", " b += k[1];", " c += k[2];", " mix(a,b,c);", " n -= 3;", " k += 3;", " }", " c += (((uint64_t) nbytes)<<3);", " switch (n) {", " case 2: b += k[1];", " case 1: a += k[0];", " case 0: break;", " }", " mix(a,b,c);", "", " K1 = a;", "}", "", "#if defined(USE_TDH) && !defined(WIN32) && !defined(WIN64)", #if 0 some problems with this storage mode: 0. pre-allocates full hash-table with slots equal to max statevector size e.g. with -w26 we allocate 2^26 (64 M) slots of VECTORSZ large which can accomodate up to 64 M states once you get close to or exceed the max, the search aborts with a 'hashtable full' message in HC mode the max storage needed per state is more modest and independent of the maximum vectorsize; which makes this mode attractive as a default 1. does not support PO reduction through the Lstate->ostate->tagged to distinguish open from closed states - this can reduce states by 50% could add this as another bit from the hash value e.g., could add it in HC mode to the first hash? 2. the same state may be stored multiple times #endif "#ifdef HC", " #ifndef T_HC", " #ifdef BFS_HC", " #define T_HC BFS_HC", " #else", " #define T_HC 2", " #endif", " #endif", " #if T_HC<1 || T_HC>4", " #error \"BFS_HC must be 1, 2, 3, or 4 (default is 2)\"", " #endif", "#endif", "", "#define T_ROW 6", /* related to cache line size */ "#define T_ROW_SIZE (1< x))", " { Uerror(\"assertion x * (ulong) T_VSZ > x fails\");", " }", " #ifdef BFS_SEP_HASH", " ohash_sd = (char *) emalloc(x * (ulong) T_VSZ);", " #else", " ohash_sd = (volatile char *) sh_pre_malloc(x * (ulong) T_VSZ);", " #endif", "#else", /* assume T_HC >= 1, and normally 2 */ " ohash_hc_sz = (ulong) (T_HC * (ulong) sizeof(uint32_t));", " if (!(x * ohash_hc_sz > x))", /* watch for overflow */ " { Uerror(\"assertion x * ohash_hc_sz > x fails\");", " }", " #ifdef BFS_SEP_HASH", " ohash_sd = (char *) emalloc(x * ohash_hc_sz);", " #else", " ohash_sd = (volatile char *) sh_pre_malloc(x * ohash_hc_sz);", " #endif", "#endif", "#ifdef BFS_SEP_HASH", " ohash_hv = (uint32_t *) emalloc(x * (ulong) sizeof(uint32_t));", "#else", " ohash_hv = (volatile uint32_t *) sh_pre_malloc(x * (ulong) sizeof(uint32_t));", "#endif", " ohash_mask = (((ulong)1)<o_pm &= ~2;", "#ifdef VERBOSE", " bfs_printf(\"check to mark\\n\");", "#endif", " for (i = 0; i < (int) now._nr_pr; i++)", " { P0 *ptr = (P0 *) pptr(i);", " if (accpstate[ptr->_t][ptr->_p])", " { trpt->o_pm |= 2;", " now._l_bnd = L_bound;", " now._l_sds = (uchar *) 0;", "#ifdef VERBOSE", " bfs_printf(\"mark state live\\n\");", "#endif", " break;", " } }", "}", "void", "bfs_check_live(uchar b, uchar *s)", "{ /* assert(b>0); */", " now._l_bnd = b-1; /* decrease bound */", "#ifdef VERBOSE", " bfs_printf(\"check live %%d\\n\", b);", "#endif", " if (b == L_bound && boq == -1)", /* never mid rv */ " { now._l_sds = (uchar *) Lstate; /* new target */", " } else", " { now._l_sds = s; /* restore target */", " if (s == (uchar *) Lstate)", " { depthfound = depth - (BASE+1)*(L_bound - now._l_bnd - 1);", " uerror(\"accept cycle found\");", " depthfound = -1;", " now._l_bnd = 0;", " now._l_sds = (uchar *) 0;", " } }", "#ifdef VERBOSE", " bfs_printf(\"set l_bound to %%d -- sds %%p\\n\", b-1, (void *) now._l_sds);", "#endif", "}", "#endif", "/* closed hashing with locality - similar to ltsmin */", "int", "o_store(const char *vin, int nin)", "{ int i, seed = 0;", " ulong hash_v, ix, ex;", " uint32_t T_BUSY, T_DONE;", " volatile uint32_t *t_entry;", "#ifdef HC", " ulong vs = ohash_hc_sz;", "#else", " ulong vs = (ulong) T_VSZ;", "#endif", "#ifdef L_BOUND", " uchar o_bnd, *o_sds;", "#endif", "#ifndef STOP_ON_FULL", " if (h_table_full)", " { goto done;", " }", "#endif", "#ifdef L_BOUND", " if (now._l_bnd == 0)", " { bfs_mark_live();", " }", " #ifdef VERBOSE", " else", " { bfs_printf(\"non-markable state %%d\\n\", now._l_bnd);", " }", " #endif", " o_bnd = now._l_bnd;", " o_sds = now._l_sds;", " now._l_bnd = (o_bnd)?1:0; /* mark nested phase of bounded search */", " now._l_sds = (uchar *) 0;", "#endif", "#if !defined(HC) && !defined(T_NOCOMP)", " nin = compress((char *)vin, nin);", " vin = (char *) &comp_now;", "#endif", " do { o_hash((uchar *)vin, nin, seed++);", " hash_v = K1;", " } while (hash_v == T_FREE || hash_v == T_STAT); /* unlikely, hash_v 0 or 1 */", "", " T_BUSY = ((uint32_t) hash_v & ~((uint32_t) T_STAT)); /* hash with status bit 0 */", " T_DONE = ((uint32_t) hash_v | ((uint32_t) T_STAT)); /* hash with status bit 1 */", "#ifdef HC", " d_hash((uchar *)vin, nin);", /* HC */ " ohash_hc[0] = (uint32_t) K1;", " #if T_HC>1", " ohash_hc[1] = (uint32_t) (K1>>32);", /* assumes ulong = 64 bits */ " #endif", " #if T_HC>2", " ohash_hc[2] = (uint32_t) K2;", " #endif", " #if T_HC>3", " ohash_hc[3] = (uint32_t) (K2>>32);", " #endif", "#endif", " while (seed < ohash_max)", " { ix = hash_v & ohash_mask;", " ex = (ix & T_ROW_MASK) + T_ROW_SIZE;", " for (i = 0; i < T_ROW_SIZE; i++)", " { t_entry = (uint32_t *) &ohash_hv[ix];", " if (*t_entry == T_FREE && cas(t_entry, T_FREE, T_BUSY))", " {", "#ifndef HC", " memcpy((char *) &ohash_sd[ix * vs], vin, nin);", "#else", " memcpy((char *) &ohash_sd[ix * vs], (char *) ohash_hc, vs);", "#endif", "#if defined(USE_TDH) && defined(Q_PROVISO)", " ohash_inq[ix] = (uchar) BFS_INQ;", " Lstate = (H_el *) &ohash_inq[ix];", "#endif", " *t_entry = T_DONE;", "#ifdef VERBOSE", " #ifdef L_BOUND", " bfs_printf(\"New state %%p [%%p]\\n\",", " (void *) Lstate, (void *) o_sds);", " #else", " bfs_printf(\"New state %%p\\n\", (void *) Lstate);", " #endif", "#endif", "#ifdef L_BOUND", " if (o_bnd) { bfs_check_live(o_bnd, o_sds); }", "#endif", " return 0; /* New State */", " }", " while (*t_entry == T_BUSY)", " { usleep(2); /* wait */", " }", " if (*t_entry == T_DONE /* (first) hash matches, check data */", "#ifndef HC", " && memcmp((char *) &ohash_sd[ix * vs], vin, nin) == 0)", "#else", " && memcmp((char *) &ohash_sd[ix * vs], (char *) ohash_hc, vs) == 0)", "#endif", " {", "#if defined(USE_TDH) && defined(Q_PROVISO)", " Lstate = (H_el *) &ohash_inq[ix];", "#endif", "#ifdef VERBOSE", " #ifdef L_BOUND", " bfs_printf(\"Old state %%p [%%p]\\n\",", " (void *) Lstate, (void *) o_sds);", " #else", " bfs_printf(\"Old state %%p\\n\", (void *) Lstate);", " #endif", "#endif", "#ifdef L_BOUND", " if (o_bnd) { bfs_check_live(o_bnd, o_sds); }", "#endif", " return 1; /* Old State */", " }", " hcmp++; ix++;", " ix = (ix==ex) ? ex - T_ROW_SIZE : ix;", " }", " /* find a new slot: */", " do { o_hash((uchar *)vin, nin, (int) (hash_v + seed++));", " hash_v = K1;", " } while (hash_v == T_FREE || hash_v == T_STAT);", " T_BUSY = ((uint32_t) hash_v & ~((uint32_t) T_STAT));", " T_DONE = ((uint32_t) hash_v | ((uint32_t) T_STAT));", " }", "#ifdef STOP_ON_FULL", " Uerror(\"hash table full\");", " /* no return from Uerror */", "#else", " if (!h_table_full)", " { h_table_full++;", " if (who_am_i == 0)", " { bfs_printf(\"hash table is full\\n\");", " } }", "done:", " bfs_punt++; /* counts this as a lost state */", "#endif", "#ifdef L_BOUND", " now._l_bnd = 0; /* no more checking */", " now._l_sds = (uchar *) 0;", "#endif", " return 1; /* technically should be 0, but we want to throttle down */", "}", "#endif", /* USE_TDH && !WIN32 && !WIN64 */ "#endif", /* !BITSTATE || FULLSTACK */ "#include TRANSITIONS", 0, }; Spin/Src6.4.5/tl_main.c0000664000175100017510000001244612641605057012477 0ustar ghgh/***** tl_spin: tl_main.c *****/ /* * This file is part of the public release of Spin. It is subject to the * terms in the LICENSE file that is included in this source directory. * Tool documentation is available at http://spinroot.com * * Based on the translation algorithm by Gerth, Peled, Vardi, and Wolper, * presented at the PSTV Conference, held in 1995, Warsaw, Poland 1995. */ #include "tl.h" extern FILE *tl_out; int newstates = 0; /* debugging only */ int tl_errs = 0; int tl_verbose = 0; int tl_terse = 0; int tl_clutter = 0; int state_cnt = 0; unsigned long All_Mem = 0; char *claim_name; static char uform[4096]; static int hasuform=0, cnt=0; extern void cache_stats(void); extern void a_stats(void); int tl_Getchar(void) { if (cnt < hasuform) return uform[cnt++]; cnt++; return -1; } int tl_peek(int n) { if (cnt+n < hasuform) { return uform[cnt+n]; } return -1; } void tl_balanced(void) { int i; int k = 0; for (i = 0; i < hasuform; i++) { if (uform[i] == '(') { if (i > 0 && ((uform[i-1] == '"' && uform[i+1] == '"') || (uform[i-1] == '\'' && uform[i+1] == '\''))) { continue; } k++; } else if (uform[i] == ')') { if (i > 0 && ((uform[i-1] == '"' && uform[i+1] == '"') || (uform[i-1] == '\'' && uform[i+1] == '\''))) { continue; } k--; } } if (k != 0) { tl_errs++; tl_yyerror("parentheses not balanced"); } } void put_uform(void) { fprintf(tl_out, "%s", uform); } void tl_UnGetchar(void) { if (cnt > 0) cnt--; } static void tl_stats(void) { extern int Stack_mx; printf("total memory used: %9ld\n", All_Mem); printf("largest stack sze: %9d\n", Stack_mx); cache_stats(); a_stats(); } int tl_main(int argc, char *argv[]) { int i; extern int xspin, s_trail; tl_verbose = 0; /* was: tl_verbose = verbose; */ if (xspin && s_trail) { tl_clutter = 1; /* generating claims for a replay should be done the same as when generating the pan.c that produced the error-trail */ } else { tl_clutter = 1-xspin; /* use -X -f to turn off uncluttering */ } newstates = 0; state_cnt = 0; tl_errs = 0; tl_terse = 0; All_Mem = 0; memset(uform, 0, sizeof(uform)); hasuform=0; cnt=0; claim_name = (char *) 0; ini_buchi(); ini_cache(); ini_rewrt(); ini_trans(); while (argc > 1 && argv[1][0] == '-') { switch (argv[1][1]) { case 'd': newstates = 1; /* debugging mode */ break; case 'f': argc--; argv++; for (i = 0; argv[1][i]; i++) { if (argv[1][i] == '\t' || argv[1][i] == '\n') argv[1][i] = ' '; } strcpy(uform, argv[1]); hasuform = (int) strlen(uform); break; case 'v': tl_verbose++; break; case 'n': tl_terse = 1; break; case 'c': argc--; argv++; claim_name = (char *) emalloc(strlen(argv[1])+1); strcpy(claim_name, argv[1]); break; default : printf("spin -f: saw '-%c'\n", argv[1][1]); goto nogood; } argc--; argv++; } if (hasuform == 0) { nogood: printf("usage:\tspin [-v] [-n] -f formula\n"); printf(" -v verbose translation\n"); printf(" -n normalize tl formula and exit\n"); exit(1); } tl_balanced(); if (tl_errs == 0) tl_parse(); if (tl_verbose) tl_stats(); return tl_errs; } #define Binop(a) \ fprintf(tl_out, "("); \ dump(n->lft); \ fprintf(tl_out, a); \ dump(n->rgt); \ fprintf(tl_out, ")") void dump(Node *n) { if (!n) return; switch(n->ntyp) { case OR: Binop(" || "); break; case AND: Binop(" && "); break; case U_OPER: Binop(" U "); break; case V_OPER: Binop(" V "); break; #ifdef NXT case NEXT: fprintf(tl_out, "X"); fprintf(tl_out, " ("); dump(n->lft); fprintf(tl_out, ")"); break; #endif case NOT: fprintf(tl_out, "!"); fprintf(tl_out, " ("); dump(n->lft); fprintf(tl_out, ")"); break; case FALSE: fprintf(tl_out, "false"); break; case TRUE: fprintf(tl_out, "true"); break; case PREDICATE: fprintf(tl_out, "(%s)", n->sym->name); break; case CEXPR: fprintf(tl_out, "c_expr"); fprintf(tl_out, " {"); dump(n->lft); fprintf(tl_out, "}"); break; case -1: fprintf(tl_out, " D "); break; default: printf("Unknown token: "); tl_explain(n->ntyp); break; } } void tl_explain(int n) { switch (n) { case ALWAYS: printf("[]"); break; case EVENTUALLY: printf("<>"); break; case IMPLIES: printf("->"); break; case EQUIV: printf("<->"); break; case PREDICATE: printf("predicate"); break; case OR: printf("||"); break; case AND: printf("&&"); break; case NOT: printf("!"); break; case U_OPER: printf("U"); break; case V_OPER: printf("V"); break; #ifdef NXT case NEXT: printf("X"); break; #endif case CEXPR: printf("c_expr"); break; case TRUE: printf("true"); break; case FALSE: printf("false"); break; case ';': printf("end of formula"); break; default: printf("%c", n); break; } } static void tl_non_fatal(char *s1, char *s2) { extern int tl_yychar; int i; printf("tl_spin: "); #if 1 printf(s1, s2); /* prevent a compiler warning */ #else if (s2) printf(s1, s2); else printf(s1); #endif if (tl_yychar != -1 && tl_yychar != 0) { printf(", saw '"); tl_explain(tl_yychar); printf("'"); } printf("\ntl_spin: %s\n---------", uform); for (i = 0; i < cnt; i++) printf("-"); printf("^\n"); fflush(stdout); tl_errs++; } void tl_yyerror(char *s1) { Fatal(s1, (char *) 0); } void Fatal(char *s1, char *s2) { tl_non_fatal(s1, s2); /* tl_stats(); */ exit(1); } Spin/Src6.4.5/sym.c0000664000175100017510000003304412641605057011661 0ustar ghgh/***** spin: sym.c *****/ /* * This file is part of the public release of Spin. It is subject to the * terms in the LICENSE file that is included in this source directory. * Tool documentation is available at http://spinroot.com */ #include "spin.h" #include "y.tab.h" extern Symbol *Fname, *owner; extern int lineno, depth, verbose, NamesNotAdded, deadvar; extern int has_hidden, m_loss, old_scope_rules; extern short has_xu; extern char CurScope[MAXSCOPESZ]; Symbol *context = ZS; Ordered *all_names = (Ordered *)0; int Nid = 0; Lextok *Mtype = (Lextok *) 0; Lextok *runstmnts = ZN; static Ordered *last_name = (Ordered *)0; static Symbol *symtab[Nhash+1]; static int samename(Symbol *a, Symbol *b) { if (!a && !b) return 1; if (!a || !b) return 0; return !strcmp(a->name, b->name); } int hash(char *s) { int h=0; while (*s) { h += *s++; h <<= 1; if (h&(Nhash+1)) h |= 1; } return h&Nhash; } void disambiguate(void) { Ordered *walk; Symbol *sp; char *n, *m; if (old_scope_rules) return; /* prepend the scope_prefix to the names */ for (walk = all_names; walk; walk = walk->next) { sp = walk->entry; if (sp->type != 0 && sp->type != LABEL && strlen((const char *)sp->bscp) > 1) { if (sp->context) { m = (char *) emalloc(strlen((const char *)sp->bscp) + 1); sprintf(m, "_%d_", sp->context->sc); if (strcmp((const char *) m, (const char *) sp->bscp) == 0) { continue; /* 6.2.0: only prepend scope for inner-blocks, not for top-level locals within a proctype this means that you can no longer use the same name for a global and a (top-level) local variable */ } } n = (char *) emalloc(strlen((const char *)sp->name) + strlen((const char *)sp->bscp) + 1); sprintf(n, "%s%s", sp->bscp, sp->name); sp->name = n; /* discard the old memory */ } } } Symbol * lookup(char *s) { Symbol *sp; Ordered *no; int h = hash(s); if (old_scope_rules) { /* same scope - global refering to global or local to local */ for (sp = symtab[h]; sp; sp = sp->next) { if (strcmp(sp->name, s) == 0 && samename(sp->context, context) && samename(sp->owner, owner)) { return sp; /* found */ } } } else { /* added 6.0.0: more traditional, scope rule */ for (sp = symtab[h]; sp; sp = sp->next) { if (strcmp(sp->name, s) == 0 && samename(sp->context, context) && (strcmp((const char *)sp->bscp, CurScope) == 0 || strncmp((const char *)sp->bscp, CurScope, strlen((const char *)sp->bscp)) == 0) && samename(sp->owner, owner)) { if (!samename(sp->owner, owner)) { printf("spin: different container %s\n", sp->name); printf(" old: %s\n", sp->owner?sp->owner->name:"--"); printf(" new: %s\n", owner?owner->name:"--"); /* alldone(1); */ } return sp; /* found */ } } } if (context) /* in proctype, refers to global */ for (sp = symtab[h]; sp; sp = sp->next) { if (strcmp(sp->name, s) == 0 && !sp->context && samename(sp->owner, owner)) { return sp; /* global */ } } sp = (Symbol *) emalloc(sizeof(Symbol)); sp->name = (char *) emalloc(strlen(s) + 1); strcpy(sp->name, s); sp->nel = 1; sp->setat = depth; sp->context = context; sp->owner = owner; /* if fld in struct */ sp->bscp = (unsigned char *) emalloc(strlen((const char *)CurScope)+1); strcpy((char *)sp->bscp, CurScope); if (NamesNotAdded == 0) { sp->next = symtab[h]; symtab[h] = sp; no = (Ordered *) emalloc(sizeof(Ordered)); no->entry = sp; if (!last_name) last_name = all_names = no; else { last_name->next = no; last_name = no; } } return sp; } void trackvar(Lextok *n, Lextok *m) { Symbol *sp = n->sym; if (!sp) return; /* a structure list */ switch (m->ntyp) { case NAME: if (m->sym->type != BIT) { sp->hidden |= 4; if (m->sym->type != BYTE) sp->hidden |= 8; } break; case CONST: if (m->val != 0 && m->val != 1) sp->hidden |= 4; if (m->val < 0 || m->val > 256) sp->hidden |= 8; /* ditto byte-equiv */ break; default: /* unknown */ sp->hidden |= (4|8); /* not known bit-equiv */ } } void trackrun(Lextok *n) { runstmnts = nn(ZN, 0, n, runstmnts); } void checkrun(Symbol *parnm, int posno) { Lextok *n, *now, *v; int i, m; int res = 0; char buf[16], buf2[16]; for (n = runstmnts; n; n = n->rgt) { now = n->lft; if (now->sym != parnm->context) continue; for (v = now->lft, i = 0; v; v = v->rgt, i++) if (i == posno) { m = v->lft->ntyp; if (m == CONST) { m = v->lft->val; if (m != 0 && m != 1) res |= 4; if (m < 0 || m > 256) res |= 8; } else if (m == NAME) { m = v->lft->sym->type; if (m != BIT) { res |= 4; if (m != BYTE) res |= 8; } } else res |= (4|8); /* unknown */ break; } } if (!(res&4) || !(res&8)) { if (!(verbose&32)) return; strcpy(buf2, (!(res&4))?"bit":"byte"); sputtype(buf, parnm->type); i = (int) strlen(buf); while (i > 0 && buf[--i] == ' ') buf[i] = '\0'; if (i == 0 || strcmp(buf, buf2) == 0) return; prehint(parnm); printf("proctype %s, '%s %s' could be declared", parnm->context?parnm->context->name:"", buf, parnm->name); printf(" '%s %s'\n", buf2, parnm->name); } } void trackchanuse(Lextok *m, Lextok *w, int t) { Lextok *n = m; int cnt = 1; while (n) { if (n->lft && n->lft->sym && n->lft->sym->type == CHAN) setaccess(n->lft->sym, w?w->sym:ZS, cnt, t); n = n->rgt; cnt++; } } void setptype(Lextok *n, int t, Lextok *vis) /* predefined types */ { int oln = lineno, cnt = 1; extern int Expand_Ok; while (n) { if (n->sym->type && !(n->sym->hidden&32)) { lineno = n->ln; Fname = n->fn; fatal("redeclaration of '%s'", n->sym->name); lineno = oln; } n->sym->type = (short) t; if (Expand_Ok) { n->sym->hidden |= (4|8|16); /* formal par */ if (t == CHAN) setaccess(n->sym, ZS, cnt, 'F'); } if (t == UNSIGNED) { if (n->sym->nbits < 0 || n->sym->nbits >= 32) fatal("(%s) has invalid width-field", n->sym->name); if (n->sym->nbits == 0) { n->sym->nbits = 16; non_fatal("unsigned without width-field", 0); } } else if (n->sym->nbits > 0) { non_fatal("(%s) only an unsigned can have width-field", n->sym->name); } if (vis) { if (strncmp(vis->sym->name, ":hide:", (size_t) 6) == 0) { n->sym->hidden |= 1; has_hidden++; if (t == BIT) fatal("bit variable (%s) cannot be hidden", n->sym->name); } else if (strncmp(vis->sym->name, ":show:", (size_t) 6) == 0) { n->sym->hidden |= 2; } else if (strncmp(vis->sym->name, ":local:", (size_t) 7) == 0) { n->sym->hidden |= 64; } } if (t == CHAN) n->sym->Nid = ++Nid; else { n->sym->Nid = 0; if (n->sym->ini && n->sym->ini->ntyp == CHAN) { Fname = n->fn; lineno = n->ln; fatal("chan initializer for non-channel %s", n->sym->name); } } if (n->sym->nel <= 0) { lineno = n->ln; Fname = n->fn; non_fatal("bad array size for '%s'", n->sym->name); lineno = oln; } n = n->rgt; cnt++; } } static void setonexu(Symbol *sp, int t) { sp->xu |= t; if (t == XR || t == XS) { if (sp->xup[t-1] && strcmp(sp->xup[t-1]->name, context->name)) { printf("error: x[rs] claims from %s and %s\n", sp->xup[t-1]->name, context->name); non_fatal("conflicting claims on chan '%s'", sp->name); } sp->xup[t-1] = context; } } static void setallxu(Lextok *n, int t) { Lextok *fp, *tl; for (fp = n; fp; fp = fp->rgt) for (tl = fp->lft; tl; tl = tl->rgt) { if (tl->sym->type == STRUCT) setallxu(tl->sym->Slst, t); else if (tl->sym->type == CHAN) setonexu(tl->sym, t); } } Lextok *Xu_List = (Lextok *) 0; void setxus(Lextok *p, int t) { Lextok *m, *n; has_xu = 1; if (m_loss && t == XS) { printf("spin: %s:%d, warning, xs tag not compatible with -m (message loss)\n", (p->fn != NULL) ? p->fn->name : "stdin", p->ln); } if (!context) { lineno = p->ln; Fname = p->fn; fatal("non-local x[rs] assertion", (char *)0); } for (m = p; m; m = m->rgt) { Lextok *Xu_new = (Lextok *) emalloc(sizeof(Lextok)); Xu_new->uiid = p->uiid; Xu_new->val = t; Xu_new->lft = m->lft; Xu_new->sym = context; Xu_new->rgt = Xu_List; Xu_List = Xu_new; n = m->lft; if (n->sym->type == STRUCT) setallxu(n->sym->Slst, t); else if (n->sym->type == CHAN) setonexu(n->sym, t); else { int oln = lineno; lineno = n->ln; Fname = n->fn; non_fatal("xr or xs of non-chan '%s'", n->sym->name); lineno = oln; } } } void setmtype(Lextok *m) { Lextok *n; int cnt, oln = lineno; if (m) { lineno = m->ln; Fname = m->fn; } if (!Mtype) Mtype = m; else { for (n = Mtype; n->rgt; n = n->rgt) ; n->rgt = m; /* concatenate */ } for (n = Mtype, cnt = 1; n; n = n->rgt, cnt++) /* syntax check */ { if (!n->lft || !n->lft->sym || n->lft->ntyp != NAME || n->lft->lft) /* indexed variable */ fatal("bad mtype definition", (char *)0); /* label the name */ if (n->lft->sym->type != MTYPE) { n->lft->sym->hidden |= 128; /* is used */ n->lft->sym->type = MTYPE; n->lft->sym->ini = nn(ZN,CONST,ZN,ZN); n->lft->sym->ini->val = cnt; } else if (n->lft->sym->ini->val != cnt) non_fatal("name %s appears twice in mtype declaration", n->lft->sym->name); } lineno = oln; if (cnt > 256) fatal("too many mtype elements (>255)", (char *)0); } int ismtype(char *str) /* name to number */ { Lextok *n; int cnt = 1; for (n = Mtype; n; n = n->rgt) { if (strcmp(str, n->lft->sym->name) == 0) return cnt; cnt++; } return 0; } int sputtype(char *foo, int m) { switch (m) { case UNSIGNED: strcpy(foo, "unsigned "); break; case BIT: strcpy(foo, "bit "); break; case BYTE: strcpy(foo, "byte "); break; case CHAN: strcpy(foo, "chan "); break; case SHORT: strcpy(foo, "short "); break; case INT: strcpy(foo, "int "); break; case MTYPE: strcpy(foo, "mtype "); break; case STRUCT: strcpy(foo, "struct"); break; case PROCTYPE: strcpy(foo, "proctype"); break; case LABEL: strcpy(foo, "label "); return 0; default: strcpy(foo, "value "); return 0; } return 1; } static int puttype(int m) { char buf[128]; if (sputtype(buf, m)) { printf("%s", buf); return 1; } return 0; } void symvar(Symbol *sp) { Lextok *m; if (!puttype(sp->type)) return; printf("\t"); if (sp->owner) printf("%s.", sp->owner->name); printf("%s", sp->name); if (sp->nel > 1 || sp->isarray == 1) printf("[%d]", sp->nel); if (sp->type == CHAN) printf("\t%d", (sp->ini)?sp->ini->val:0); else if (sp->type == STRUCT && sp->Snm != NULL) /* Frank Weil, 2.9.8 */ printf("\t%s", sp->Snm->name); else printf("\t%d", eval(sp->ini)); if (sp->owner) printf("\t<:struct-field:>"); else if (!sp->context) printf("\t<:global:>"); else printf("\t<%s>", sp->context->name); if (sp->Nid < 0) /* formal parameter */ printf("\t", -(sp->Nid)); else if (sp->type == MTYPE) printf("\t"); else if (sp->isarray) printf("\t"); else printf("\t"); if (sp->type == CHAN && sp->ini) { int i; for (m = sp->ini->rgt, i = 0; m; m = m->rgt) i++; printf("\t%d\t", i); for (m = sp->ini->rgt; m; m = m->rgt) { if (m->ntyp == STRUCT) printf("struct %s", m->sym->name); else (void) puttype(m->ntyp); if (m->rgt) printf("\t"); } } if (!old_scope_rules) { printf("\t{scope %s}", sp->bscp); } printf("\n"); } void symdump(void) { Ordered *walk; for (walk = all_names; walk; walk = walk->next) symvar(walk->entry); } void chname(Symbol *sp) { printf("chan "); if (sp->context) printf("%s-", sp->context->name); if (sp->owner) printf("%s.", sp->owner->name); printf("%s", sp->name); if (sp->nel > 1 || sp->isarray == 1) printf("[%d]", sp->nel); printf("\t"); } static struct X { int typ; char *nm; } xx[] = { { 'A', "exported as run parameter" }, { 'F', "imported as proctype parameter" }, { 'L', "used as l-value in asgnmnt" }, { 'V', "used as r-value in asgnmnt" }, { 'P', "polled in receive stmnt" }, { 'R', "used as parameter in receive stmnt" }, { 'S', "used as parameter in send stmnt" }, { 'r', "received from" }, { 's', "sent to" }, }; static void chan_check(Symbol *sp) { Access *a; int i, b=0, d; if (verbose&1) goto report; /* -C -g */ for (a = sp->access; a; a = a->lnk) if (a->typ == 'r') b |= 1; else if (a->typ == 's') b |= 2; if (b == 3 || (sp->hidden&16)) /* balanced or formal par */ return; report: chname(sp); for (i = d = 0; i < (int) (sizeof(xx)/sizeof(struct X)); i++) { b = 0; for (a = sp->access; a; a = a->lnk) if (a->typ == xx[i].typ) b++; if (b == 0) continue; d++; printf("\n\t%s by: ", xx[i].nm); for (a = sp->access; a; a = a->lnk) if (a->typ == xx[i].typ) { printf("%s", a->who->name); if (a->what) printf(" to %s", a->what->name); if (a->cnt) printf(" par %d", a->cnt); if (--b > 0) printf(", "); } } printf("%s\n", (!d)?"\n\tnever used under this name":""); } void chanaccess(void) { Ordered *walk; char buf[128]; extern int Caccess, separate; extern short has_code; for (walk = all_names; walk; walk = walk->next) { if (!walk->entry->owner) switch (walk->entry->type) { case CHAN: if (Caccess) chan_check(walk->entry); break; case MTYPE: case BIT: case BYTE: case SHORT: case INT: case UNSIGNED: if ((walk->entry->hidden&128)) /* was: 32 */ continue; if (!separate && !walk->entry->context && !has_code && deadvar) walk->entry->hidden |= 1; /* auto-hide */ if (!(verbose&32) || has_code) continue; printf("spin: %s:0, warning, ", Fname->name); sputtype(buf, walk->entry->type); if (walk->entry->context) printf("proctype %s", walk->entry->context->name); else printf("global"); printf(", '%s%s' variable is never used (other than in print stmnts)\n", buf, walk->entry->name); } } } Spin/Src6.4.5/pangen6.h0000664000175100017510000026302712641605057012422 0ustar ghgh/***** spin: pangen6.h *****/ /* * This file is part of the public release of Spin. It is subject to the * terms in the LICENSE file that is included in this source directory. * Tool documentation is available at http://spinroot.com */ static const char *Code2e[] = { "#if (NCORE>1 || defined(BFS_PAR)) && !defined(WIN32) && !defined(WIN64)", " /* Test and Set assembly code */", " #if defined(i386) || defined(__i386__) || defined(__x86_64__)", " int", " tas(volatile int *s) /* tested */", " { int r;", " __asm__ __volatile__(", " \"xchgl %%0, %%1 \\n\\t\"", " : \"=r\"(r), \"=m\"(*s)", " : \"0\"(1), \"m\"(*s)", " : \"memory\");", " ", " return r;", " }", " #elif defined(__arm__)", " int", " tas(volatile int *s) /* not tested */", " { int r = 1;", " __asm__ __volatile__(", " \"swpb %%0, %%0, [%%3] \\n\"", " : \"=r\"(r), \"=m\"(*s)", " : \"0\"(r), \"r\"(s));", "", " return r;", " }", " #elif defined(sparc) || defined(__sparc__)", " int", " tas(volatile int *s) /* not tested */", " { int r = 1;", " __asm__ __volatile__(", " \" ldstub [%%2], %%0 \\n\"", " : \"=r\"(r), \"=m\"(*s)", " : \"r\"(s));", "", " return r;", " }", " #elif defined(ia64) || defined(__ia64__)", " /* Intel Itanium */", " int", " tas(volatile int *s) /* tested */", " { long int r;", " __asm__ __volatile__(", " \" xchg4 %%0=%%1,%%2 \\n\"", " : \"=r\"(r), \"+m\"(*s)", " : \"r\"(1)", " : \"memory\");", " return (int) r;", " }", " #elif defined(__powerpc64__)", " int", " tas(volatile int *s) /* courtesy srirajpaul */", " { int r;", " #if 1", " r = __sync_lock_test_and_set();", " #else", " /* xlc compiler only */", " r = __fetch_and_or(s, 1);", " __isync();", " #endif", " return r;", " }", " #else", " #error missing definition of test and set operation for this platform", " #endif", "", " #ifndef NO_CAS", /* linux, windows */ " #define cas(a,b,c) __sync_bool_compare_and_swap(a,b,c)", " #else", " int", /* workaround if the above is not available */ " cas(volatile uint32_t *a, uint32_t b, uint32_t c)", " { static volatile int cas_lock;", " while (tas(&cas_lock) != 0) { ; }", " if (*a == b)", " { *a = c;", " cas_lock = 0;", " return 1;", " }", " cas_lock = 0;", " return 0;", " }", " #endif", "#endif", 0, }; static const char *Code2c[] = { /* multi-core option - Spin 5.0 and later */ "#if NCORE>1", "#if defined(WIN32) || defined(WIN64)", " #ifndef _CONSOLE", " #define _CONSOLE", " #endif", " #ifdef WIN64", " #undef long", " #endif", " #include ", "/*", " #ifdef WIN64", " #define long long long", " #endif", "*/", "#else", " #include ", " #include ", " #include ", "#endif", "", "/* code common to cygwin/linux and win32/win64: */", "", "#ifdef VERBOSE", " #define VVERBOSE (1)", "#else", " #define VVERBOSE (0)", "#endif", "", "/* the following values must be larger than 256 and must fit in an int */", "#define QUIT 1024 /* terminate now command */", "#define QUERY 512 /* termination status query message */", "#define QUERY_F 513 /* query failed, cannot quit */", "", "#define GN_FRAMES (int) (GWQ_SIZE / (double) sizeof(SM_frame))", "#define LN_FRAMES (int) (LWQ_SIZE / (double) sizeof(SM_frame))", "", "#ifndef VMAX", " #define VMAX VECTORSZ", "#endif", "#ifndef PMAX", " #define PMAX 64", "#endif", "#ifndef QMAX", " #define QMAX 64", "#endif", "", "#if VECTORSZ>32000", " #define OFFT int", "#else", " #define OFFT short", "#endif", "", "#ifdef SET_SEG_SIZE", " /* no longer usefule -- being recomputed for local heap size anyway */", " double SEG_SIZE = (((double) SET_SEG_SIZE) * 1048576.);", "#else", " double SEG_SIZE = (1048576.*1024.); /* 1GB default shared memory pool segments */", "#endif", "", "double LWQ_SIZE = 0.; /* initialized in main */", "", "#ifdef SET_WQ_SIZE", " #ifdef NGQ", " #warning SET_WQ_SIZE applies to global queue -- ignored", " double GWQ_SIZE = 0.;", " #else", " double GWQ_SIZE = (((double) SET_WQ_SIZE) * 1048576.);", " /* must match the value in pan_proxy.c, if used */", " #endif", "#else", " #ifdef NGQ", " double GWQ_SIZE = 0.;", " #else", " double GWQ_SIZE = (128.*1048576.); /* 128 MB default queue sizes */", " #endif", "#endif", "", "/* Crash Detection Parameters */", "#ifndef ONESECOND", " #define ONESECOND (1<<25)", /* name is somewhat of a misnomer */ "#endif", "#ifndef SHORT_T", " #define SHORT_T (0.1)", "#endif", "#ifndef LONG_T", " #define LONG_T (600)", "#endif", "", "double OneSecond = (double) (ONESECOND); /* waiting for a free slot -- checks crash */", "double TenSeconds = 10. * (ONESECOND); /* waiting for a lock -- check for a crash */", "", "/* Termination Detection Params -- waiting for new state input in Get_Full_Frame */", "double Delay = ((double) SHORT_T) * (ONESECOND); /* termination detection trigger */", "double OneHour = ((double) LONG_T) * (ONESECOND); /* timeout termination detection */", "", "typedef struct SM_frame SM_frame;", "typedef struct SM_results SM_results;", "typedef struct sh_Allocater sh_Allocater;", "", "struct SM_frame { /* about 6K per slot */", " volatile int m_vsize; /* 0 means free slot */", " volatile int m_boq; /* >500 is a control message */", "#ifdef FULL_TRAIL", " volatile struct Stack_Tree *m_stack; /* ptr to previous state */", "#endif", " volatile uchar m_tau;", " volatile uchar m_o_pm;", " volatile int nr_handoffs; /* to compute real_depth */", " volatile char m_now [VMAX];", "#if !defined(NOCOMP) && !defined(HC)", " volatile char m_mask [(VMAX + 7)/8];", "#endif", " volatile OFFT m_p_offset[PMAX];", " volatile OFFT m_q_offset[QMAX];", " volatile uchar m_p_skip [PMAX];", " volatile uchar m_q_skip [QMAX];", "#if defined(C_States) && (HAS_TRACK==1) && (HAS_STACK==1)", " volatile uchar m_c_stack [StackSize];", /* captures contents of c_stack[] for unmatched objects */ "#endif", "};", "", "int proxy_pid; /* id of proxy if nonzero -- receive half */", "int store_proxy_pid;", "short remote_party;", "int proxy_pid_snd; /* id of proxy if nonzero -- send half */", "char o_cmdline[512]; /* to pass options to children */", "", "int iamin[CS_NR+NCORE]; /* non-shared */", "", "#if defined(WIN32) || defined(WIN64)", "int tas(volatile LONG *);", "", "HANDLE proxy_handle_snd; /* for Windows Create and Terminate */", "", "struct sh_Allocater { /* shared memory for states */", " volatile char *dc_arena; /* to allocate states from */", " volatile long pattern; /* to detect overruns */", " volatile long dc_size; /* nr of bytes left */", " volatile void *dc_start; /* where memory segment starts */", " volatile void *dc_id; /* to attach, detach, remove shared memory segments */", " volatile sh_Allocater *nxt; /* linked list of pools */", "};", "DWORD worker_pids[NCORE]; /* root mem of pids of all workers created */", "HANDLE worker_handles[NCORE]; /* for windows Create and Terminate */", "void * shmid [NR_QS]; /* return value from CreateFileMapping */", "void * shmid_M; /* shared mem for state allocation in hashtable */", "", "#ifdef SEP_STATE", " void *shmid_X;", "#else", " void *shmid_S; /* shared bitstate arena or hashtable */", "#endif", "#else", "int tas(volatile int *);", "", "struct sh_Allocater { /* shared memory for states */", " volatile char *dc_arena; /* to allocate states from */", " volatile long pattern; /* to detect overruns */", " volatile long dc_size; /* nr of bytes left */", " volatile char *dc_start; /* where memory segment starts */", " volatile int dc_id; /* to attach, detach, remove shared memory segments */", " volatile sh_Allocater *nxt; /* linked list of pools */", "};", "", "int worker_pids[NCORE]; /* root mem of pids of all workers created */", "int shmid [NR_QS]; /* return value from shmget */", "int nibis = 0; /* set after shared mem has been released */", "int shmid_M; /* shared mem for state allocation in hashtable */", "#ifdef SEP_STATE", " long shmid_X;", "#else", " int shmid_S; /* shared bitstate arena or hashtable */", " volatile sh_Allocater *first_pool; /* of shared state memory */", " volatile sh_Allocater *last_pool;", "#endif", /* SEP_STATE */ "#endif", /* WIN32 || WIN64 */ "", "struct SM_results { /* for shuttling back final stats */", " volatile int m_vsize; /* avoid conflicts with frames */", " volatile int m_boq; /* these 2 fields are not written in record_info */", " /* probably not all fields really need to be volatile */", " volatile double m_memcnt;", " volatile double m_nstates;", " volatile double m_truncs;", " volatile double m_truncs2;", " volatile double m_nShadow;", " volatile double m_nlinks;", " volatile double m_ngrabs;", " volatile double m_nlost;", " volatile double m_hcmp;", " volatile double m_frame_wait;", " volatile int m_hmax;", " volatile int m_svmax;", " volatile int m_smax;", " volatile int m_mreached;", " volatile int m_errors;", " volatile int m_VMAX;", " volatile short m_PMAX;", " volatile short m_QMAX;", " volatile uchar m_R; /* reached info for all proctypes */", "};", "", "int core_id = 0; /* internal process nr, to know which q to use */", "unsigned long nstates_put = 0; /* statistics */", "unsigned long nstates_get = 0;", "int query_in_progress = 0; /* termination detection */", "", "double free_wait = 0.; /* waiting for a free frame */", "double frame_wait = 0.; /* waiting for a full frame */", "double lock_wait = 0.; /* waiting for access to cs */", "double glock_wait[3]; /* waiting for access to global lock */", "", "char *sprefix = \"rst\";", "uchar was_interrupted, issued_kill, writing_trail;", "", "static SM_frame cur_Root; /* current root, to be safe with error trails */", "", "SM_frame *m_workq [NR_QS]; /* per cpu work queues + global q */", "char *shared_mem[NR_QS]; /* return value from shmat */", "#ifdef SEP_HEAP", "char *my_heap;", "long my_size;", "#endif", "volatile sh_Allocater *dc_shared; /* assigned at initialization */", "", "static int vmax_seen, pmax_seen, qmax_seen;", "static double gq_tries, gq_hasroom, gq_hasnoroom;", "", "volatile int *prfree;", /* [NCORE] */ "volatile int *prfull;", /* [NCORE] */ "volatile int *prcnt;", /* [NCORE] */ "volatile int *prmax;", /* [NCORE] */ "", "volatile int *sh_lock; /* mutual exclusion locks - in shared memory */", "volatile double *is_alive; /* to detect when processes crash */", "volatile int *grfree, *grfull, *grcnt, *grmax; /* access to shared global q */", "volatile double *gr_readmiss, *gr_writemiss;", "static int lrfree; /* used for temporary recording of slot */", "static int dfs_phase2;", "", "void mem_put(int); /* handoff state to other cpu */", "void mem_put_acc(void); /* liveness mode */", "void mem_get(void); /* get state from work queue */", "void sudden_stop(char *);", "", "void", "record_info(SM_results *r)", "{ int i;", " uchar *ptr;", "", "#ifdef SEP_STATE", " if (0)", " { cpu_printf(\"nstates %%g nshadow %%g -- memory %%-6.3f Mb\\n\",", " nstates, nShadow, memcnt/(1048576.));", " }", " r->m_memcnt = 0;", "#else", " #ifdef BITSTATE", " r->m_memcnt = 0; /* it's shared */", " #endif", " r->m_memcnt = memcnt;", "#endif", " if (a_cycles && core_id == 1)", " { r->m_nstates = nstates;", " r->m_nShadow = nstates;", " } else", " { r->m_nstates = nstates;", " r->m_nShadow = nShadow;", " }", " r->m_truncs = truncs;", " r->m_truncs2 = truncs2;", " r->m_nlinks = nlinks;", " r->m_ngrabs = ngrabs;", " r->m_nlost = nlost;", " r->m_hcmp = hcmp;", " r->m_frame_wait = frame_wait;", " r->m_hmax = hmax;", " r->m_svmax = svmax;", " r->m_smax = smax;", " r->m_mreached = mreached;", " r->m_errors = errors;", " r->m_VMAX = vmax_seen;", " r->m_PMAX = (short) pmax_seen;", " r->m_QMAX = (short) qmax_seen;", " ptr = (uchar *) &(r->m_R);", " for (i = 0; i <= _NP_; i++) /* all proctypes */", " { memcpy(ptr, reached[i], NrStates[i]*sizeof(uchar));", " ptr += NrStates[i]*sizeof(uchar);", " }", " if (verbose>1)", " { cpu_printf(\"Put Results nstates %%g (sz %%d)\\n\", nstates, ptr - &(r->m_R));", " }", "}", "", "void snapshot(void);", "", "void", "retrieve_info(SM_results *r)", "{ int i, j;", " volatile uchar *ptr;", "", " snapshot(); /* for a final report */", "", " enter_critical(GLOBAL_LOCK);", "#ifdef SEP_HEAP", " if (verbose)", " { printf(\"cpu%%d: local heap-left %%ld KB (%%d MB)\\n\",", " core_id, (long) (my_size/1024), (int) (my_size/1048576));", " }", "#endif", " if (verbose && core_id == 0)", " { printf(\"qmax: \");", " for (i = 0; i < NCORE; i++)", " { printf(\"%%d \", prmax[i]);", " }", "#ifndef NGQ", " printf(\"G: %%d\", *grmax);", "#endif", " printf(\"\\n\");", " }", " leave_critical(GLOBAL_LOCK);", "", " memcnt += r->m_memcnt;", " nstates += r->m_nstates;", " nShadow += r->m_nShadow;", " truncs += r->m_truncs;", " truncs2 += r->m_truncs2;", " nlinks += r->m_nlinks;", " ngrabs += r->m_ngrabs;", " nlost += r->m_nlost;", " hcmp += r->m_hcmp;", " /* frame_wait += r->m_frame_wait; */", " errors += r->m_errors;", "", " if (hmax < r->m_hmax) hmax = r->m_hmax;", " if (svmax < r->m_svmax) svmax = r->m_svmax;", " if (smax < r->m_smax) smax = r->m_smax;", " if (mreached < r->m_mreached) mreached = r->m_mreached;", "", " if (vmax_seen < r->m_VMAX) vmax_seen = r->m_VMAX;", " if (pmax_seen < (int) r->m_PMAX) pmax_seen = (int) r->m_PMAX;", " if (qmax_seen < (int) r->m_QMAX) qmax_seen = (int) r->m_QMAX;", "", " ptr = &(r->m_R);", " for (i = 0; i <= _NP_; i++) /* all proctypes */", " { for (j = 0; j < NrStates[i]; j++)", " { if (*(ptr + j) != 0)", " { reached[i][j] = 1;", " } }", " ptr += NrStates[i]*sizeof(uchar);", " }", " if (verbose>1)", " { cpu_printf(\"Got Results (%%d)\\n\", (int) (ptr - &(r->m_R)));", " snapshot();", " }", "}", "", "#if !defined(WIN32) && !defined(WIN64)", "static void", "rm_shared_segments(void)", "{ int m;", " volatile sh_Allocater *nxt_pool;", " /*", " * mark all shared memory segments for removal ", " * the actual removes wont happen intil last process dies or detaches", " * the shmctl calls can return -1 if not all procs have detached yet", " */", " for (m = 0; m < NR_QS; m++) /* +1 for global q */", " { if (shmid[m] != -1)", " { (void) shmctl(shmid[m], IPC_RMID, NULL);", " } }", "#ifdef SEP_STATE", " if (shmid_M != -1)", " { (void) shmctl(shmid_M, IPC_RMID, NULL);", " }", "#else", " if (shmid_S != -1)", " { (void) shmctl(shmid_S, IPC_RMID, NULL);", " }", " for (last_pool = first_pool; last_pool != NULL; last_pool = nxt_pool)", " { shmid_M = (int) (last_pool->dc_id);", " nxt_pool = last_pool->nxt; /* as a pre-caution only */", " if (shmid_M != -1)", " { (void) shmctl(shmid_M, IPC_RMID, NULL);", " } }", "#endif", "}", "#endif", "", "void", "sudden_stop(char *s)", "{ char b[64];", " int i;", "", " printf(\"cpu%%d: stop - %%s\\n\", core_id, s);", "#if !defined(WIN32) && !defined(WIN64)", " if (proxy_pid != 0)", " { rm_shared_segments();", " }", "#endif", " if (search_terminated != NULL)", " { if (*search_terminated != 0)", " { if (verbose)", " { printf(\"cpu%%d: termination initiated (%%d)\\n\",", " core_id, (int) *search_terminated);", " }", " } else", " { if (verbose)", " { printf(\"cpu%%d: initiated termination\\n\", core_id);", " }", " *search_terminated |= 8; /* sudden_stop */", " }", " if (core_id == 0)", " { if (((*search_terminated) & 4) /* uerror in one of the cpus */", " && !((*search_terminated) & (8|32|128|256))) /* abnormal stop */", " { if (errors == 0) errors++; /* we know there is at least 1 */", " }", " wrapup(); /* incomplete stats, but at least something */", " }", " return;", " } /* else: should rarely happen, take more drastic measures */", "", " if (core_id == 0) /* local root process */", " { for (i = 1; i < NCORE; i++) /* not for 0 of course */", " { int ignore;", "#if defined(WIN32) || defined(WIN64)", " DWORD dwExitCode = 0;", " GetExitCodeProcess(worker_handles[i], &dwExitCode);", " if (dwExitCode == STILL_ACTIVE)", " { TerminateProcess(worker_handles[i], 0);", " }", " printf(\"cpu0: terminate %%d %%d\\n\",", " (int) worker_pids[i], (dwExitCode == STILL_ACTIVE));", "#else", " sprintf(b, \"kill -%%d %%d\", (int) SIGKILL, (int) worker_pids[i]);", " ignore = system(b); /* if this is a proxy: receive half */", " printf(\"cpu0: %%s\\n\", b);", "#endif", " }", " issued_kill++;", " } else", " { /* on WIN32/WIN64 -- these merely kills the root process... */", " if (was_interrupted == 0)", /* 2=SIGINT to root to trigger stop */ " { int ignore;", " sprintf(b, \"kill -%%d %%d\", (int) SIGINT, (int) worker_pids[0]);", " ignore = system(b); /* warn the root process */", " printf(\"cpu%%d: %%s\\n\", core_id, b);", " issued_kill++;", " } }", "}", "", "#define iam_alive() is_alive[core_id]++", /* for crash detection */ "", "extern int crash_test(double);", "extern void crash_reset(void);", "", "int", "someone_crashed(int wait_type)", "{ static double last_value = 0.0;", " static int count = 0;", "", " if (search_terminated == NULL", " || *search_terminated != 0)", " {", " if (!(*search_terminated & (8|32|128|256)))", " { if (count++ < 100*NCORE)", " { return 0;", " } }", " return 1;", " }", " /* check left neighbor only */", " if (last_value == is_alive[(core_id + NCORE - 1) %% NCORE])", " { if (count++ >= 100) /* to avoid unnecessary checks */", " { return 1;", " }", " return 0;", " }", " last_value = is_alive[(core_id + NCORE - 1) %% NCORE];", " count = 0;", " crash_reset();", " return 0;", "}", "", "void", "sleep_report(void)", "{", " enter_critical(GLOBAL_LOCK);", " if (verbose)", " {", "#ifdef NGQ", " printf(\"cpu%%d: locks: global %%g\\tother %%g\\t\",", " core_id, glock_wait[0], lock_wait - glock_wait[0]);", "#else", " printf(\"cpu%%d: locks: GL %%g, RQ %%g, WQ %%g, HT %%g\\t\",", " core_id, glock_wait[0], glock_wait[1], glock_wait[2],", " lock_wait - glock_wait[0] - glock_wait[1] - glock_wait[2]);", "#endif", " printf(\"waits: states %%g slots %%g\\n\", frame_wait, free_wait);", "#ifndef NGQ", " printf(\"cpu%%d: gq [tries %%g, room %%g, noroom %%g]\\n\", core_id, gq_tries, gq_hasroom, gq_hasnoroom);", " if (core_id == 0 && (*gr_readmiss >= 1.0 || *gr_readmiss >= 1.0 || *grcnt != 0))", " printf(\"cpu0: gq [readmiss: %%g, writemiss: %%g cnt %%d]\\n\", *gr_readmiss, *gr_writemiss, *grcnt);", "#endif", " }", " if (free_wait > 1000000.)", " #ifndef NGQ", " if (!a_cycles)", " { printf(\"hint: this search may be faster with a larger work-queue\\n\");", " printf(\" (-DSET_WQ_SIZE=N with N>%%g), and/or with -DUSE_DISK\\n\",", " GWQ_SIZE/sizeof(SM_frame));", " printf(\" or with a larger value for -zN (N>%%ld)\\n\", z_handoff);", " #else", " { printf(\"hint: this search may be faster if compiled without -DNGQ, with -DUSE_DISK, \");", " printf(\"or with a larger -zN (N>%%d)\\n\", z_handoff);", " #endif", " }", " leave_critical(GLOBAL_LOCK);", "}", "", "#ifndef MAX_DSK_FILE", " #define MAX_DSK_FILE 1000000 /* default is max 1M states per file */", "#endif", "", "void", "multi_usage(FILE *fd)", "{ static int warned = 0;", " if (warned > 0) { return; } else { warned++; }", " fprintf(fd, \"\\n\");", " fprintf(fd, \"Defining multi-core mode:\\n\\n\");", " fprintf(fd, \" -DDUAL_CORE --> same as -DNCORE=2\\n\");", " fprintf(fd, \" -DQUAD_CORE --> same as -DNCORE=4\\n\");", " fprintf(fd, \" -DNCORE=N --> enables multi_core verification if N>1\\n\");", " fprintf(fd, \"\\n\");", " fprintf(fd, \"Additional directives supported in multi-core mode:\\n\\n\");", " fprintf(fd, \" -DSEP_STATE --> forces separate statespaces instead of a single shared state space\\n\");", " fprintf(fd, \" -DNUSE_DISK --> use disk for storing states when a work queue overflows\\n\");", " fprintf(fd, \" -DMAX_DSK_FILE --> max nr of states per diskfile (%%d)\\n\", MAX_DSK_FILE);", " fprintf(fd, \" -DFULL_TRAIL --> support full error trails (increases memory use)\\n\");", " fprintf(fd, \"\\n\");", " fprintf(fd, \"More advanced use (should rarely need changing):\\n\\n\");", " fprintf(fd, \" To change the nr of states that can be stored in the global queue\\n\");", " fprintf(fd, \" (lower numbers allow for more states to be stored, prefer multiples of 8):\\n\");", " fprintf(fd, \" -DVMAX=N --> upperbound on statevector for handoffs (N=%%d)\\n\", VMAX);", " fprintf(fd, \" -DPMAX=N --> upperbound on nr of procs (default: N=%%d)\\n\", PMAX);", " fprintf(fd, \" -DQMAX=N --> upperbound on nr of channels (default: N=%%d)\\n\", QMAX);", " fprintf(fd, \"\\n\");", #if 0 "#if !defined(WIN32) && !defined(WIN64)", " fprintf(fd, \" To change the size of spin's individual shared memory segments for cygwin/linux:\\n\");", " fprintf(fd, \" -DSET_SEG_SIZE=N --> default %%g (Mbytes)\\n\", SEG_SIZE/(1048576.));", " fprintf(fd, \"\\n\");", "#endif", #endif " fprintf(fd, \" To set the total amount of memory reserved for the global workqueue:\\n\");", " fprintf(fd, \" -DSET_WQ_SIZE=N --> default: N=128 (defined in MBytes)\\n\\n\");", #if 0 " fprintf(fd, \" To omit the global workqueue completely (bad idea):\\n\");", " fprintf(fd, \" -DNGQ\\n\\n\");", #endif " fprintf(fd, \" To force the use of a single global heap, instead of separate heaps:\\n\");", " fprintf(fd, \" -DGLOB_HEAP\\n\");", " fprintf(fd, \"\\n\");", " fprintf(fd, \" To define a fct to initialize data before spawning processes (use quotes):\\n\");", " fprintf(fd, \" \\\"-DC_INIT=fct()\\\"\\n\");", " fprintf(fd, \"\\n\");", " fprintf(fd, \" Timer settings for termination and crash detection:\\n\");", " fprintf(fd, \" -DSHORT_T=N --> timeout for termination detection trigger (N=%%g)\\n\", (double) SHORT_T);", " fprintf(fd, \" -DLONG_T=N --> timeout for giving up on termination detection (N=%%g)\\n\", (double) LONG_T);", " fprintf(fd, \" -DONESECOND --> (1<<29) --> timeout waiting for a free slot -- to check for crash\\n\");", " fprintf(fd, \" -DT_ALERT --> collect stats on crash alert timeouts\\n\\n\");", " fprintf(fd, \"Help with Linux/Windows/Cygwin configuration for multi-core:\\n\");", " fprintf(fd, \" http://spinroot.com/spin/multicore/V5_Readme.html\\n\");", " fprintf(fd, \"\\n\");", "}", "#if NCORE>1 && defined(FULL_TRAIL)", "typedef struct Stack_Tree {", " uchar pr; /* process that made transition */", " T_ID t_id; /* id of transition */", " volatile struct Stack_Tree *prv; /* backward link towards root */", "} Stack_Tree;", "", "H_el *grab_shared(int);", "volatile Stack_Tree **stack_last; /* in shared memory */", "char *stack_cache = NULL; /* local */", "int nr_cached = 0; /* local */", "", "#ifndef CACHE_NR", " #define CACHE_NR 1024", "#endif", "", "volatile Stack_Tree *", "stack_prefetch(void)", "{ volatile Stack_Tree *st;", "", " if (nr_cached == 0)", " { stack_cache = (char *) grab_shared(CACHE_NR * sizeof(Stack_Tree));", " nr_cached = CACHE_NR;", " }", " st = (volatile Stack_Tree *) stack_cache;", " stack_cache += sizeof(Stack_Tree);", " nr_cached--;", " return st;", "}", "", "void", "Push_Stack_Tree(short II, T_ID t_id)", "{ volatile Stack_Tree *st;", "", " st = (volatile Stack_Tree *) stack_prefetch();", " st->pr = II;", " st->t_id = t_id;", " st->prv = (Stack_Tree *) stack_last[core_id];", " stack_last[core_id] = st;", "}", "", "void", "Pop_Stack_Tree(void)", "{ volatile Stack_Tree *cf = stack_last[core_id];", "", " if (cf)", " { stack_last[core_id] = cf->prv;", " } else if (nr_handoffs * z_handoff + depth > 0)", " { printf(\"cpu%%d: error pop_stack_tree (depth %%ld)\\n\",", " core_id, depth);", " }", "}", "#endif", /* NCORE>1 && FULL_TRAIL */ "", "void", "e_critical(int which)", "{ double cnt_start;", "", " if (readtrail || iamin[which] > 0)", " { if (!readtrail && verbose)", " { printf(\"cpu%%d: Double Lock on %%d (now %%d)\\n\",", " core_id, which, iamin[which]+1);", " fflush(stdout);", " }", " iamin[which]++; /* local variable */", " return;", " }", "", " cnt_start = lock_wait;", "", " while (sh_lock != NULL) /* as long as we have shared memory */", " { int r = tas(&sh_lock[which]);", " if (r == 0)", " { iamin[which] = 1;", " return; /* locked */", " }", "", " lock_wait++;", "#ifndef NGQ", " if (which < 3) { glock_wait[which]++; }", "#else", " if (which == 0) { glock_wait[which]++; }", "#endif", " iam_alive();", "", " if (lock_wait - cnt_start > TenSeconds)", " { printf(\"cpu%%d: lock timeout on %%d\\n\", core_id, which);", " cnt_start = lock_wait;", " if (someone_crashed(1))", " { sudden_stop(\"lock timeout\");", " pan_exit(1);", " } } }", "}", "", "void", "x_critical(int which)", "{", " if (iamin[which] != 1)", " { if (iamin[which] > 1)", " { iamin[which]--; /* this is thread-local - no races on this one */", " if (!readtrail && verbose)", " { printf(\"cpu%%d: Partial Unlock on %%d (%%d more needed)\\n\",", " core_id, which, iamin[which]);", " fflush(stdout);", " }", " return;", " } else /* iamin[which] <= 0 */", " { if (!readtrail)", " { printf(\"cpu%%d: Invalid Unlock iamin[%%d] = %%d\\n\",", " core_id, which, iamin[which]);", " fflush(stdout);", " }", " return;", " } }", "", " if (sh_lock != NULL)", " { iamin[which] = 0;", "#if defined(__powerpc64__)", " #if 1", " __sync_synchronize(); /* srirajpaul */", " #else", " __lwsync(); /* xlc compiler only */", " #endif", "#endif", " sh_lock[which] = 0; /* unlock */", " }", "}", "", "void", "#if defined(WIN32) || defined(WIN64)", "start_proxy(char *s, DWORD r_pid)", "#else", "start_proxy(char *s, int r_pid)", "#endif", "{ char Q_arg[16], Z_arg[16], Y_arg[16];", " char *args[32], *ptr;", " int argcnt = 0;", "", " sprintf(Q_arg, \"-Q%%d\", getpid());", " sprintf(Y_arg, \"-Y%%d\", r_pid);", " sprintf(Z_arg, \"-Z%%d\", proxy_pid /* core_id */);", "", " args[argcnt++] = \"proxy\";", " args[argcnt++] = s; /* -r or -s */", " args[argcnt++] = Q_arg;", " args[argcnt++] = Z_arg;", " args[argcnt++] = Y_arg;", "", " if (strlen(o_cmdline) > 0)", " { ptr = o_cmdline; /* assume args separated by spaces */", " do { args[argcnt++] = ptr++;", " if ((ptr = strchr(ptr, ' ')) != NULL)", " { while (*ptr == ' ')", " { *ptr++ = '\\0';", " }", " } else", " { break;", " }", " } while (argcnt < 31);", " }", " args[argcnt] = NULL;", "#if defined(WIN32) || defined(WIN64)", " execvp(\"pan_proxy\", args); /* no return */", "#else", " execvp(\"./pan_proxy\", args); /* no return */", "#endif", " Uerror(\"pan_proxy exec failed\");", "}", "/*** end of common code fragment ***/", "", "#if !defined(WIN32) && !defined(WIN64)", "void", "init_shm(void) /* initialize shared work-queues - linux/cygwin */", "{ key_t key[NR_QS];", " int n, m;", " int must_exit = 0;", "", " if (core_id == 0 && verbose)", " { printf(\"cpu0: step 3: allocate shared workqueues %%g MB\\n\",", " ((double) NCORE * LWQ_SIZE + GWQ_SIZE) / (1048576.) );", " }", " for (m = 0; m < NR_QS; m++) /* last q is the global q */", " { double qsize = (m == NCORE) ? GWQ_SIZE : LWQ_SIZE;", " key[m] = ftok(PanSource, m+1);", /* m must be nonzero, 1..NCORE */ " if (key[m] == -1)", " { perror(\"ftok shared queues\"); must_exit = 1; break;", " }", "", " if (core_id == 0) /* root creates */", " { /* check for stale copy */", " shmid[m] = shmget(key[m], (size_t) qsize, 0600);", " if (shmid[m] != -1) /* yes there is one; remove it */", " { printf(\"cpu0: removing stale q%%d, status: %%d\\n\",", " m, shmctl(shmid[m], IPC_RMID, NULL));", " }", " shmid[m] = shmget(key[m], (size_t) qsize, 0600|IPC_CREAT|IPC_EXCL);", " memcnt += qsize;", " } else /* workers attach */", " { shmid[m] = shmget(key[m], (size_t) qsize, 0600);", " /* never called, since we create shm *before* we fork */", " }", " if (shmid[m] == -1)", " { perror(\"shmget shared queues\"); must_exit = 1; break;", " }", "", " shared_mem[m] = (char *) shmat(shmid[m], (void *) 0, 0); /* attach */", " if (shared_mem[m] == (char *) -1)", " { fprintf(stderr, \"error: cannot attach shared wq %%d (%%d Mb)\\n\",", " m+1, (int) (qsize/(1048576.)));", " perror(\"shmat shared queues\"); must_exit = 1; break;", " }", "", " m_workq[m] = (SM_frame *) shared_mem[m];", " if (core_id == 0)", " { int nframes = (m == NCORE) ? GN_FRAMES : LN_FRAMES;", " for (n = 0; n < nframes; n++)", " { m_workq[m][n].m_vsize = 0;", " m_workq[m][n].m_boq = 0;", " } } }", "", " if (must_exit)", " { rm_shared_segments();", " fprintf(stderr, \"pan: check './pan --' for usage details\\n\");", " pan_exit(1); /* calls cleanup_shm */", " }", "}", "", "static uchar *", "prep_shmid_S(size_t n) /* either sets SS or H_tab, linux/cygwin */", "{ char *rval;", "#ifndef SEP_STATE", " key_t key;", "", " if (verbose && core_id == 0)", " {", " #ifdef BITSTATE", " printf(\"cpu0: step 1: allocate shared bitstate %%g Mb\\n\",", " (double) n / (1048576.));", " #else", " printf(\"cpu0: step 1: allocate shared hastable %%g Mb\\n\",", " (double) n / (1048576.));", " #endif", " }", " #ifdef MEMLIM", /* memlim has a value */ " if (memcnt + (double) n > memlim)", " { printf(\"cpu0: S %%8g + %%d Kb exceeds memory limit of %%8g Mb\\n\",", " memcnt/1024., (int) (n/1024), memlim/(1048576.));", " printf(\"cpu0: insufficient memory -- aborting\\n\");", " exit(1);", " }", " #endif", "", " key = ftok(PanSource, NCORE+2); /* different from queues */", " if (key == -1)", " { perror(\"ftok shared bitstate or hashtable\");", " fprintf(stderr, \"pan: check './pan --' for usage details\\n\");", " pan_exit(1);", " }", "", " if (core_id == 0) /* root */", " { shmid_S = shmget(key, n, 0600);", " if (shmid_S != -1)", " { printf(\"cpu0: removing stale segment, status: %%d\\n\",", " (int) shmctl(shmid_S, IPC_RMID, NULL));", " }", " shmid_S = shmget(key, n, 0600 | IPC_CREAT | IPC_EXCL);", " memcnt += (double) n;", " } else /* worker */", " { shmid_S = shmget(key, n, 0600);", " }", " if (shmid_S == -1)", " { perror(\"shmget shared bitstate or hashtable too large?\");", " fprintf(stderr, \"pan: check './pan --' for usage details\\n\");", " pan_exit(1);", " }", "", " rval = (char *) shmat(shmid_S, (void *) 0, 0); /* attach */", " if ((char *) rval == (char *) -1)", " { perror(\"shmat shared bitstate or hashtable\");", " fprintf(stderr, \"pan: check './pan --' for usage details\\n\");", " pan_exit(1);", " }", "#else", " rval = (char *) emalloc(n);", "#endif", " return (uchar *) rval;", "}", "", "#define TRY_AGAIN 1", "#define NOT_AGAIN 0", "", "static char shm_prep_result;", "", "static uchar *", "prep_state_mem(size_t n) /* sets memory arena for states linux/cygwin */", "{ char *rval;", " key_t key;", " static int cnt = 3; /* start larger than earlier ftok calls */", "", " shm_prep_result = NOT_AGAIN; /* default */", " if (verbose && core_id == 0)", " { printf(\"cpu0: step 2+: pre-allocate memory arena %%d of %%6.2g Mb\\n\",", " cnt-3, (double) n / (1048576.));", " }", " #ifdef MEMLIM", " if (memcnt + (double) n > memlim)", " { printf(\"cpu0: error: M %%.0f + %%.0f Kb exceeds memory limit of %%.0f Mb\\n\",", " memcnt/1024.0, (double) n/1024.0, memlim/(1048576.));", " return NULL;", " }", " #endif", "", " key = ftok(PanSource, NCORE+cnt); cnt++;", /* starts at NCORE+3 */ " if (key == -1)", " { perror(\"ftok T\");", " printf(\"pan: check './pan --' for usage details\\n\");", " pan_exit(1);", " }", "", " if (core_id == 0)", " { shmid_M = shmget(key, n, 0600);", " if (shmid_M != -1)", " { printf(\"cpu0: removing stale memory segment %%d, status: %%d\\n\",", " cnt-3, shmctl(shmid_M, IPC_RMID, NULL));", " }", " shmid_M = shmget(key, n, 0600 | IPC_CREAT | IPC_EXCL);", " /* memcnt += (double) n; -- only amount actually used is counted */", " } else", " { shmid_M = shmget(key, n, 0600);", " ", " }", " if (shmid_M == -1)", " { if (verbose)", " { printf(\"error: failed to get pool of shared memory %%d of %%.0f Mb\\n\",", " cnt-3, ((double)n)/(1048576.));", " perror(\"state mem\");", " printf(\"pan: check './pan --' for usage details\\n\");", " }", " shm_prep_result = TRY_AGAIN;", " return NULL;", " }", " rval = (char *) shmat(shmid_M, (void *) 0, 0); /* attach */", "", " if ((char *) rval == (char *) -1)", " { printf(\"cpu%%d error: failed to attach pool of shared memory %%d of %%.0f Mb\\n\",", " core_id, cnt-3, ((double)n)/(1048576.));", " perror(\"state mem\");", " return NULL;", " }", " return (uchar *) rval;", "}", "", "void", "init_HT(unsigned long n) /* cygwin/linux version */", "{ volatile char *x;", " double get_mem;", "#ifndef SEP_STATE", " volatile char *dc_mem_start;", " double need_mem, got_mem = 0.;", "#endif", "", "#ifdef SEP_STATE", " #ifndef MEMLIM", " if (verbose)", " { printf(\"cpu0: steps 0,1: no -DMEMLIM set\\n\");", /* cannot happen */ " }", " #else", " if (verbose)", " { printf(\"cpu0: steps 0,1: -DMEMLIM=%%d Mb - (hashtable %%g Mb + workqueues %%g Mb)\\n\",", " MEMLIM, ((double)n/(1048576.)), (((double) NCORE * LWQ_SIZE) + GWQ_SIZE) /(1048576.) );", " }", " #endif", " get_mem = NCORE * sizeof(double) + (1 + CS_NR) * sizeof(void *) + 4*sizeof(void *) + 2*sizeof(double);", " /* NCORE * is_alive + search_terminated + CS_NR * sh_lock + 6 gr vars */", " get_mem += 4 * NCORE * sizeof(void *); /* prfree, prfull, prcnt, prmax */", " #ifdef FULL_TRAIL", " get_mem += (NCORE) * sizeof(Stack_Tree *); /* NCORE * stack_last */", " #endif", " x = (volatile char *) prep_state_mem((size_t) get_mem); /* work queues and basic structs */", " shmid_X = (long) x;", " if (x == NULL)", /* do not repeat for smaller sizes */ " { printf(\"cpu0: could not allocate shared memory, see ./pan --\\n\");", " exit(1);", " }", " search_terminated = (volatile unsigned int *) x; /* comes first */", " x += sizeof(void *); /* maintain alignment */", "", " is_alive = (volatile double *) x;", " x += NCORE * sizeof(double);", "", " sh_lock = (volatile int *) x;", " x += CS_NR * sizeof(void *);", /* allow 1 word per entry */ "", " grfree = (volatile int *) x;", " x += sizeof(void *);", " grfull = (volatile int *) x;", " x += sizeof(void *);", " grcnt = (volatile int *) x;", " x += sizeof(void *);", " grmax = (volatile int *) x;", " x += sizeof(void *);", " prfree = (volatile int *) x;", " x += NCORE * sizeof(void *);", " prfull = (volatile int *) x;", " x += NCORE * sizeof(void *);", " prcnt = (volatile int *) x;", " x += NCORE * sizeof(void *);", " prmax = (volatile int *) x;", " x += NCORE * sizeof(void *);", " gr_readmiss = (volatile double *) x;", " x += sizeof(double);", " gr_writemiss = (volatile double *) x;", " x += sizeof(double);", "", " #ifdef FULL_TRAIL", " stack_last = (volatile Stack_Tree **) x;", " x += NCORE * sizeof(Stack_Tree *);", " #endif", "", " #ifndef BITSTATE", " H_tab = (H_el **) emalloc(n);", " #endif", "#else", " #ifndef MEMLIM", " #warning MEMLIM not set", /* cannot happen */ " #define MEMLIM (2048)", " #endif", "", " if (core_id == 0 && verbose)", " { printf(\"cpu0: step 0: -DMEMLIM=%%d Mb minus hashtable+workqs (%%g + %%g Mb) leaves %%g Mb\\n\",", " MEMLIM, ((double)n/(1048576.)), (NCORE * LWQ_SIZE + GWQ_SIZE)/(1048576.),", " (memlim - memcnt - (double) n - (NCORE * LWQ_SIZE + GWQ_SIZE))/(1048576.));", " }", " #ifndef BITSTATE", " H_tab = (H_el **) prep_shmid_S((size_t) n); /* hash_table */", " #endif", " need_mem = memlim - memcnt - ((double) NCORE * LWQ_SIZE) - GWQ_SIZE;", " if (need_mem <= 0.)", " { Uerror(\"internal error -- shared state memory\");", " }", "", " if (core_id == 0 && verbose)", " { printf(\"cpu0: step 2: pre-allocate shared state memory %%g Mb\\n\",", " need_mem/(1048576.));", " }", "#ifdef SEP_HEAP", " SEG_SIZE = need_mem / NCORE;", " if (verbose && core_id == 0)", " { printf(\"cpu0: setting segsize to %%6g MB\\n\",", " SEG_SIZE/(1048576.));", " }", " #if defined(CYGWIN) || defined(__CYGWIN__)", " if (SEG_SIZE > 512.*1024.*1024.)", " { printf(\"warning: reducing SEG_SIZE of %%g MB to 512MB (exceeds max for Cygwin)\\n\",", " SEG_SIZE/(1024.*1024.));", " SEG_SIZE = 512.*1024.*1024.;", " }", " #endif", "#endif", " mem_reserved = need_mem;", " while (need_mem > 1024.)", " { get_mem = need_mem;", "shm_more:", " if (get_mem > (double) SEG_SIZE)", " { get_mem = (double) SEG_SIZE;", " }", " if (get_mem <= 0.0) break;", "", " /* for allocating states: */", " x = dc_mem_start = (volatile char *) prep_state_mem((size_t) get_mem);", " if (x == NULL)", " { if (shm_prep_result == NOT_AGAIN", " || first_pool != NULL", " || SEG_SIZE < (16. * 1048576.))", " { break;", " }", " SEG_SIZE /= 2.;", " if (verbose)", " { printf(\"pan: lowered segsize to %f\\n\", SEG_SIZE);", " }", " if (SEG_SIZE >= 1024.)", " { goto shm_more;", /* always terminates */ " }", " break;", " }", "", " need_mem -= get_mem;", " got_mem += get_mem;", " if (first_pool == NULL)", " { search_terminated = (volatile unsigned int *) x; /* comes first */", " x += sizeof(void *); /* maintain alignment */", "", " is_alive = (volatile double *) x;", " x += NCORE * sizeof(double);", "", " sh_lock = (volatile int *) x;", " x += CS_NR * sizeof(void *);", /* allow 1 word per entry */ "", " grfree = (volatile int *) x;", " x += sizeof(void *);", " grfull = (volatile int *) x;", " x += sizeof(void *);", " grcnt = (volatile int *) x;", " x += sizeof(void *);", " grmax = (volatile int *) x;", " x += sizeof(void *);", " prfree = (volatile int *) x;", " x += NCORE * sizeof(void *);", " prfull = (volatile int *) x;", " x += NCORE * sizeof(void *);", " prcnt = (volatile int *) x;", " x += NCORE * sizeof(void *);", " prmax = (volatile int *) x;", " x += NCORE * sizeof(void *);", " gr_readmiss = (volatile double *) x;", " x += sizeof(double);", " gr_writemiss = (volatile double *) x;", " x += sizeof(double);", " #ifdef FULL_TRAIL", " stack_last = (volatile Stack_Tree **) x;", " x += NCORE * sizeof(Stack_Tree *);", " #endif", " if (((long)x)&(sizeof(void *)-1)) /* 64-bit word alignment */", " { x += sizeof(void *)-(((long)x)&(sizeof(void *)-1));", " }", "", " #ifdef COLLAPSE", " ncomps = (unsigned long *) x;", " x += (256+2) * sizeof(unsigned long);", " #endif", " }", "", " dc_shared = (sh_Allocater *) x; /* must be in shared memory */", " x += sizeof(sh_Allocater);", "", " if (core_id == 0) /* root only */", " { dc_shared->dc_id = shmid_M;", " dc_shared->dc_start = dc_mem_start;", " dc_shared->dc_arena = x;", " dc_shared->pattern = 1234567; /* protection */", " dc_shared->dc_size = (long) get_mem - (long) (x - dc_mem_start);", " dc_shared->nxt = (long) 0;", "", " if (last_pool == NULL)", " { first_pool = last_pool = dc_shared;", " } else", " { last_pool->nxt = dc_shared;", " last_pool = dc_shared;", " }", " } else if (first_pool == NULL)", " { first_pool = dc_shared;", " } }", "", " if (need_mem > 1024.)", " { printf(\"cpu0: could allocate only %%g Mb of shared memory (wanted %%g more)\\n\",", " got_mem/(1048576.), need_mem/(1048576.));", " }", "", " if (!first_pool)", " { printf(\"cpu0: insufficient memory -- aborting.\\n\");", " exit(1);", " }", " /* we are still single-threaded at this point, with core_id 0 */", " dc_shared = first_pool;", "", "#endif", /* !SEP_STATE */ "}", "", "void", "cleanup_shm(int val)", "{ volatile sh_Allocater *nxt_pool;", " unsigned long cnt = 0;", " int m;", "", " if (nibis != 0)", " { printf(\"cpu%%d: Redundant call to cleanup_shm(%%d)\\n\", core_id, val);", " return;", " } else", " { nibis = 1;", " }", " if (search_terminated != NULL)", " { *search_terminated |= 16; /* cleanup_shm */", " }", "", " for (m = 0; m < NR_QS; m++)", " { if (shmdt((void *) shared_mem[m]) > 0)", " { perror(\"shmdt detaching from shared queues\");", " } }", "", "#ifdef SEP_STATE", " if (shmdt((void *) shmid_X) != 0)", " { perror(\"shmdt detaching from shared state memory\");", " }", "#else", " #ifdef BITSTATE", " if (SS > 0 && shmdt((void *) SS) != 0)", " { if (verbose)", " { perror(\"shmdt detaching from shared bitstate arena\");", " } }", " #else", " if (core_id == 0)", " { /* before detaching: */", " for (nxt_pool = dc_shared; nxt_pool != NULL; nxt_pool = nxt_pool->nxt)", " { cnt += nxt_pool->dc_size;", " }", " if (verbose)", " { printf(\"cpu0: done, %%ld Mb of shared state memory left\\n\",", " cnt / (long)(1048576));", " } }", "", " if (shmdt((void *) H_tab) != 0)", " { perror(\"shmdt detaching from shared hashtable\");", " }", "", " for (last_pool = first_pool; last_pool != NULL; last_pool = nxt_pool)", " { nxt_pool = last_pool->nxt;", " if (shmdt((void *) last_pool->dc_start) != 0)", " { perror(\"shmdt detaching from shared state memory\");", " } }", " first_pool = last_pool = NULL; /* precaution */", " #endif", "#endif", " /* detached from shared memory - so cannot use cpu_printf */", " if (verbose)", " { printf(\"cpu%%d: done -- got %%ld states from queue\\n\",", " core_id, nstates_get);", " }", "}", "", "extern void give_up(int);", "extern void Read_Queue(int);", "", "void", "mem_get(void)", "{ SM_frame *f;", " int is_parent;", "", "#if defined(MA) && !defined(SEP_STATE)", " #error MA without SEP_STATE is not supported with multi-core", "#endif", "#ifdef BFS", " #error instead of -DNCORE -DBFS use -DBFS_PAR", "#endif", "#ifdef SC", " #error SC is not supported with multi-core", "#endif", " init_shm(); /* we are single threaded when this starts */", "", " if (core_id == 0 && verbose)", " { printf(\"cpu0: step 4: calling fork()\\n\");", " }", " fflush(stdout);", "", "/* if NCORE > 1 the child or the parent should fork N-1 more times", " * the parent is the only process with core_id == 0 and is_parent > 0", " * the workers have is_parent = 0 and core_id = 1..NCORE-1", " */", " if (core_id == 0)", " { worker_pids[0] = getpid(); /* for completeness */", " while (++core_id < NCORE) /* first worker sees core_id = 1 */", " { is_parent = fork();", " if (is_parent == -1)", " { Uerror(\"fork failed\");", " }", " if (is_parent == 0) /* this is a worker process */", " { if (proxy_pid == core_id) /* always non-zero */", " { start_proxy(\"-r\", 0); /* no return */", " }", " goto adapt; /* root process continues spawning */", " }", " worker_pids[core_id] = is_parent;", " }", " /* note that core_id is now NCORE */", " if (proxy_pid > 0 && proxy_pid < NCORE)", /* add send-half of proxy */ " { proxy_pid_snd = fork();", " if (proxy_pid_snd == -1)", " { Uerror(\"proxy fork failed\");", " }", " if (proxy_pid_snd == 0)", " { start_proxy(\"-s\", worker_pids[proxy_pid]); /* no return */", " } } /* else continue */", " if (is_parent > 0)", " { core_id = 0; /* reset core_id for root process */", " }", " } else /* worker */", " { static char db0[16]; /* good for up to 10^6 cores */", " static char db1[16];", "adapt: tprefix = db0; sprefix = db1;", " sprintf(tprefix, \"cpu%%d_trail\", core_id);", " sprintf(sprefix, \"cpu%%d_rst\", core_id);", " memcnt = 0; /* count only additionally allocated memory */", " }", " signal(SIGINT, give_up);", "", " if (proxy_pid == 0) /* not in a cluster setup, pan_proxy must attach */", " { rm_shared_segments(); /* mark all shared segments for removal on exit */", " }", /* doing it early means less chance of being unable to do this */ " if (verbose)", " { cpu_printf(\"starting core_id %%d -- pid %%d\\n\", core_id, getpid());", " }", "#if defined(SEP_HEAP) && !defined(SEP_STATE)", /* set my_heap and adjust dc_shared */ " { int i;", " volatile sh_Allocater *ptr;", " ptr = first_pool;", " for (i = 0; i < NCORE && ptr != NULL; i++)", " { if (i == core_id)", " { my_heap = (char *) ptr->dc_arena;", " my_size = (long) ptr->dc_size;", " if (verbose)", " cpu_printf(\"local heap %%ld MB\\n\", my_size/(1048576));", " break;", " }", " ptr = ptr->nxt; /* local */", " }", " if (my_heap == NULL)", " { printf(\"cpu%%d: no local heap\\n\", core_id);", " pan_exit(1);", " } /* else */", " #if defined(CYGWIN) || defined(__CYGWIN__)", " ptr = first_pool;", " for (i = 0; i < NCORE && ptr != NULL; i++)", " { ptr = ptr->nxt; /* local */", " }", " dc_shared = ptr; /* any remainder */", " #else", " dc_shared = NULL; /* used all mem for local heaps */", " #endif", " }", "#endif", " if (core_id == 0 && !remote_party)", " { new_state(); /* cpu0 explores root */", " if (verbose)", " cpu_printf(\"done with 1st dfs, nstates %%g (put %%d states), read q\\n\",", " nstates, nstates_put);", " dfs_phase2 = 1;", " }", " Read_Queue(core_id); /* all cores */", "", " if (verbose)", " { cpu_printf(\"put %%6d states into queue -- got %%6d\\n\",", " nstates_put, nstates_get);", " }", " if (proxy_pid != 0)", " { rm_shared_segments();", " }", " done = 1;", " wrapup();", " exit(0);", "}", "", "#else", "int unpack_state(SM_frame *, int);", "#endif", "", "H_el *", "grab_shared(int n)", "{", "#ifndef SEP_STATE", " char *rval = (char *) 0;", "", " if (n == 0)", " { printf(\"cpu%%d: grab shared zero\\n\", core_id); fflush(stdout);", " return (H_el *) rval;", " } else if (n&(sizeof(void *)-1))", " { n += sizeof(void *)-(n&(sizeof(void *)-1)); /* alignment */", " }", "", "#ifdef SEP_HEAP", " /* no locking */", " if (my_heap != NULL && my_size > n)", " { rval = my_heap;", " my_heap += n;", " my_size -= n;", " goto done;", " }", "#endif", "", " if (!dc_shared)", " { sudden_stop(\"pan: out of memory\");", " }", "", " /* another lock is always already in effect when this is called */", " /* but not always the same lock -- i.e., on different parts of the hashtable */", " enter_critical(GLOBAL_LOCK); /* this must be independently mutex */", "#if defined(SEP_HEAP) && !defined(WIN32) && !defined(WIN64)", " { static int noted = 0;", " if (!noted)", " { noted = 1;", " printf(\"cpu%%d: global heap has %%ld bytes left, needed %%d\\n\",", " core_id, dc_shared?dc_shared->dc_size:0, n);", " } }", "#endif", "#if 0", /* for debugging */ " if (dc_shared->pattern != 1234567)", " { leave_critical(GLOBAL_LOCK);", " Uerror(\"overrun -- memory corruption\");", " }", "#endif", " if (dc_shared->dc_size < n)", " { if (verbose)", " { printf(\"Next Pool %%g Mb + %%d\\n\", memcnt/(1048576.), n);", " }", " if (dc_shared->nxt == NULL", " || dc_shared->nxt->dc_arena == NULL", " || dc_shared->nxt->dc_size < n)", " { printf(\"cpu%%d: memcnt %%g Mb + wanted %%d bytes more\\n\",", " core_id, memcnt / (1048576.), n);", " leave_critical(GLOBAL_LOCK);", " sudden_stop(\"out of memory -- aborting\");", " wrapup(); /* exits */", " } else", " { dc_shared = (sh_Allocater *) dc_shared->nxt;", " } }", "", " rval = (char *) dc_shared->dc_arena;", " dc_shared->dc_arena += n;", " dc_shared->dc_size -= (long) n;", "#if 0", " if (VVERBOSE)", " printf(\"cpu%%d grab shared (%%d bytes) -- %%ld left\\n\",", " core_id, n, dc_shared->dc_size);", "#endif", " leave_critical(GLOBAL_LOCK);", "done:", " memset(rval, 0, n);", " memcnt += (double) n;", "", " return (H_el *) rval;", "#else", " return (H_el *) emalloc(n);", "#endif", "}", "", "SM_frame *", "Get_Full_Frame(int n)", "{ SM_frame *f;", " double cnt_start = frame_wait;", "", " f = &m_workq[n][prfull[n]];", " while (f->m_vsize == 0) /* await full slot LOCK : full frame */", " { iam_alive();", "#ifndef NGQ", " #ifndef SAFETY", " if (!a_cycles || core_id != 0)", " #endif", " if (*grcnt > 0) /* accessed outside lock, but safe even if wrong */", " { enter_critical(GQ_RD); /* gq - read access */", " if (*grcnt > 0) /* could have changed */", " { f = &m_workq[NCORE][*grfull]; /* global q */", " if (f->m_vsize == 0)", " { /* writer is still filling the slot */", " *gr_writemiss++;", " f = &m_workq[n][prfull[n]]; /* reset */", " } else", " { *grfull = (*grfull+1) %% (GN_FRAMES);", " enter_critical(GQ_WR);", " *grcnt = *grcnt - 1;", " leave_critical(GQ_WR);", " leave_critical(GQ_RD);", " return f;", " } }", " leave_critical(GQ_RD);", " }", "#endif", " if (frame_wait++ - cnt_start > Delay)", " { if (0)", /* too frequent to enable this one */ " { cpu_printf(\"timeout on q%%d -- %%u -- query %%d\\n\",", " n, f, query_in_progress);", " }", " return (SM_frame *) 0; /* timeout */", " } }", " iam_alive();", " if (VVERBOSE) cpu_printf(\"got frame from q%%d\\n\", n);", " prfull[n] = (prfull[n] + 1) %% (LN_FRAMES);", " enter_critical(QLOCK(n));", " prcnt[n]--; /* lock out increments */", " leave_critical(QLOCK(n));", " return f;", "}", "", "SM_frame *", "Get_Free_Frame(int n)", "{ SM_frame *f;", " double cnt_start = free_wait;", "", " if (VVERBOSE) { cpu_printf(\"get free frame from q%%d\\n\", n); }", "", " if (n == NCORE) /* global q */", " { f = &(m_workq[n][lrfree]);", " } else", " { f = &(m_workq[n][prfree[n]]);", " }", " while (f->m_vsize != 0) /* await free slot LOCK : free slot */", " { iam_alive();", " if (free_wait++ - cnt_start > OneSecond)", " { if (verbose)", " { cpu_printf(\"timeout waiting for free slot q%%d\\n\", n);", " }", " cnt_start = free_wait;", " if (someone_crashed(1))", " { printf(\"cpu%%d: search terminated\\n\", core_id);", " sudden_stop(\"get free frame\");", " pan_exit(1);", " } } }", " if (n != NCORE)", " { prfree[n] = (prfree[n] + 1) %% (LN_FRAMES);", " enter_critical(QLOCK(n));", " prcnt[n]++; /* lock out decrements */", " if (prmax[n] < prcnt[n])", " { prmax[n] = prcnt[n];", " }", " leave_critical(QLOCK(n));", " }", " return f;", "}", "", "#ifndef NGQ", "int", "GlobalQ_HasRoom(void)", "{ int rval = 0;", "", " gq_tries++;", " if (*grcnt < GN_FRAMES) /* there seems to be room */", " { enter_critical(GQ_WR); /* gq write access */", " if (*grcnt < GN_FRAMES)", " { if (m_workq[NCORE][*grfree].m_vsize != 0)", " { /* can happen if reader is slow emptying slot */", " *gr_readmiss++;", " goto out; /* dont wait: release lock and return */", " }", " lrfree = *grfree; /* Get_Free_Frame use lrfree in this mode */", " *grfree = (*grfree + 1) %% GN_FRAMES;", /* next process looks at next slot */ " *grcnt = *grcnt + 1; /* count nr of slots filled -- no additional lock needed */", " if (*grmax < *grcnt) *grmax = *grcnt;", " leave_critical(GQ_WR); /* for short lock duration */", " gq_hasroom++;", " mem_put(NCORE); /* copy state into reserved slot */", " rval = 1; /* successfull handoff */", " } else", " { gq_hasnoroom++;", "out: leave_critical(GQ_WR);", /* should be rare */ " } }", " return rval;", "}", "#endif", "", "int", "unpack_state(SM_frame *f, int from_q)", "{ int i, j;", " static H_el D_State;", "", " if (f->m_vsize > 0)", " { boq = f->m_boq;", " if (boq > 256)", " { cpu_printf(\"saw control %%d, expected state\\n\", boq);", " return 0;", " }", " vsize = f->m_vsize;", "correct:", " memcpy((uchar *) &now, (uchar *) f->m_now, vsize);", " #if !defined(NOCOMP) && !defined(HC)", " for (i = j = 0; i < VMAX; i++, j = (j+1)%%8)", " { Mask[i] = (f->m_mask[i/8] & (1< 0)", " { memcpy((uchar *) proc_offset, (uchar *) f->m_p_offset, now._nr_pr * sizeof(OFFT));", " memcpy((uchar *) proc_skip, (uchar *) f->m_p_skip, now._nr_pr * sizeof(uchar));", " }", " if (now._nr_qs > 0)", " { memcpy((uchar *) q_offset, (uchar *) f->m_q_offset, now._nr_qs * sizeof(OFFT));", " memcpy((uchar *) q_skip, (uchar *) f->m_q_skip, now._nr_qs * sizeof(uchar));", " }", "#ifndef NOVSZ", " if (vsize != now._vsz)", " { cpu_printf(\"vsize %%d != now._vsz %%d (type %%d) %%d\\n\",", " vsize, now._vsz, f->m_boq, f->m_vsize);", " vsize = now._vsz;", " goto correct; /* rare event: a race */", " }", "#endif", " hmax = max(hmax, vsize);", "", " if (f != &cur_Root)", " { memcpy((uchar *) &cur_Root, (uchar *) f, sizeof(SM_frame));", " }", "", " if (((now._a_t) & 1) == 1) /* i.e., when starting nested DFS */", " { A_depth = depthfound = 0;", " memcpy((uchar *)&A_Root, (uchar *)&now, vsize);", " }", " nr_handoffs = f->nr_handoffs;", " } else", " { cpu_printf(\"pan: state empty\\n\");", " }", "", " depth = 0;", " trpt = &trail[1];", " trpt->tau = f->m_tau;", " trpt->o_pm = f->m_o_pm;", "", " (trpt-1)->ostate = &D_State; /* stub */", " trpt->ostate = &D_State;", "", "#ifdef FULL_TRAIL", " if (upto > 0)", " { stack_last[core_id] = (Stack_Tree *) f->m_stack;", " }", " #if defined(VERBOSE)", " if (stack_last[core_id])", " { cpu_printf(\"%%d: UNPACK -- SET m_stack %%u (%%d,%%d)\\n\",", " depth, stack_last[core_id], stack_last[core_id]->pr,", " stack_last[core_id]->t_id);", " }", " #endif", "#endif", "", " if (!trpt->o_t)", " { static Trans D_Trans;", " trpt->o_t = &D_Trans;", " }", "", " #ifdef VERI", " if ((trpt->tau & 4) != 4)", " { trpt->tau |= 4; /* the claim moves first */", " cpu_printf(\"warning: trpt was not up to date\\n\");", " }", " #endif", "", " for (i = 0; i < (int) now._nr_pr; i++)", " { P0 *ptr = (P0 *) pptr(i);", " #ifndef NP", " if (accpstate[ptr->_t][ptr->_p])", " { trpt->o_pm |= 2;", " }", " #else", " if (progstate[ptr->_t][ptr->_p])", " { trpt->o_pm |= 4;", " }", " #endif", " }", "", " #ifdef EVENT_TRACE", " #ifndef NP", " if (accpstate[EVENT_TRACE][now._event])", " { trpt->o_pm |= 2;", " }", " #else", " if (progstate[EVENT_TRACE][now._event])", " { trpt->o_pm |= 4;", " }", " #endif", " #endif", "", " #if defined(C_States) && (HAS_TRACK==1)", " /* restore state of tracked C objects */", " c_revert((uchar *) &(now.c_state[0]));", " #if (HAS_STACK==1)", " c_unstack((uchar *) f->m_c_stack); /* unmatched tracked data */", " #endif", " #endif", " return 1;", "}", "", "void", "write_root(void) /* for trail file */", "{ int fd;", "", " if (iterative == 0 && Nr_Trails > 1)", " sprintf(fnm, \"%%s%%d.%%s\", TrailFile, Nr_Trails-1, sprefix);", " else", " sprintf(fnm, \"%%s.%%s\", TrailFile, sprefix);", "", " if (cur_Root.m_vsize == 0)", " { (void) unlink(fnm); /* remove possible old copy */", " return; /* its the default initial state */", " }", "", " if ((fd = creat(fnm, TMODE)) < 0)", " { char *q;", " if ((q = strchr(TrailFile, \'.\')))", " { *q = \'\\0\'; /* strip .pml */", " if (iterative == 0 && Nr_Trails-1 > 0)", " sprintf(fnm, \"%%s%%d.%%s\", TrailFile, Nr_Trails-1, sprefix);", " else", " sprintf(fnm, \"%%s.%%s\", TrailFile, sprefix);", " *q = \'.\';", " fd = creat(fnm, TMODE);", " }", " if (fd < 0)", " { cpu_printf(\"pan: cannot create %%s\\n\", fnm);", " perror(\"cause\");", " return;", " } }", "", " if (write(fd, &cur_Root, sizeof(SM_frame)) != sizeof(SM_frame))", " { cpu_printf(\"pan: error writing %%s\\n\", fnm);", " } else", " { cpu_printf(\"pan: wrote %%s\\n\", fnm);", " }", " close(fd);", "}", "", "void", "set_root(void)", "{ int fd;", " char *q;", " char MyFile[512];", /* enough to hold a reasonable pathname */ " char MySuffix[16];", " char *ssuffix = \"rst\";", " int try_core = 1;", "", " strcpy(MyFile, TrailFile);", "try_again:", " if (whichtrail > 0)", " { sprintf(fnm, \"%%s%%d.%%s\", MyFile, whichtrail, ssuffix);", " fd = open(fnm, O_RDONLY, 0);", " if (fd < 0 && (q = strchr(MyFile, \'.\')))", " { *q = \'\\0\'; /* strip .pml */", " sprintf(fnm, \"%%s%%d.%%s\", MyFile, whichtrail, ssuffix);", " *q = \'.\';", " fd = open(fnm, O_RDONLY, 0);", " }", " } else", " { sprintf(fnm, \"%%s.%%s\", MyFile, ssuffix);", " fd = open(fnm, O_RDONLY, 0);", " if (fd < 0 && (q = strchr(MyFile, \'.\')))", " { *q = \'\\0\'; /* strip .pml */", " sprintf(fnm, \"%%s.%%s\", MyFile, ssuffix);", " *q = \'.\';", " fd = open(fnm, O_RDONLY, 0);", " } }", "", " if (fd < 0)", " { if (try_core < NCORE)", " { ssuffix = MySuffix;", " sprintf(ssuffix, \"cpu%%d_rst\", try_core++);", " goto try_again;", " }", " cpu_printf(\"no file '%%s.rst' or '%%s' (not an error)\\n\", MyFile, fnm);", " } else", " { if (read(fd, &cur_Root, sizeof(SM_frame)) != sizeof(SM_frame))", " { cpu_printf(\"read error %%s\\n\", fnm);", " close(fd);", " pan_exit(1);", " }", " close(fd);", " (void) unpack_state(&cur_Root, -2);", "#ifdef SEP_STATE", " cpu_printf(\"partial trail -- last few steps only\\n\");", "#endif", " cpu_printf(\"restored root from '%%s'\\n\", fnm);", " printf(\"=====State:=====\\n\");", " { int i, j; P0 *z;", " for (i = 0; i < now._nr_pr; i++)", " { z = (P0 *)pptr(i);", " printf(\"proc %%2d (%%s) \", i, procname[z->_t]);", " for (j = 0; src_all[j].src; j++)", " if (src_all[j].tp == (int) z->_t)", " { printf(\" %%s:%%d \",", " PanSource, src_all[j].src[z->_p]);", " break;", " }", " printf(\"(state %%d)\\n\", z->_p);", " c_locals(i, z->_t);", " }", " c_globals();", " }", " printf(\"================\\n\");", " }", "}", "", "#ifdef USE_DISK", "unsigned long dsk_written, dsk_drained;", "void mem_drain(void);", "#endif", "", "void", "m_clear_frame(SM_frame *f)", /* clear room for stats */ "{ int i, clr_sz = sizeof(SM_results);", "", " for (i = 0; i <= _NP_; i++) /* all proctypes */", " { clr_sz += NrStates[i]*sizeof(uchar);", " }", " memset(f, 0, clr_sz);", " /* caution if sizeof(SM_results) > sizeof(SM_frame) */", "}", "", "#define TargetQ_Full(n) (m_workq[n][prfree[n]].m_vsize != 0)", /* no free slot */ "#define TargetQ_NotFull(n) (m_workq[n][prfree[n]].m_vsize == 0)", /* avoiding prcnt */ "", "int", "AllQueuesEmpty(void)", "{ int q;", "#ifndef NGQ", " if (*grcnt != 0)", " { return 0;", " }", "#endif", " for (q = 0; q < NCORE; q++)", " { if (prcnt[q] != 0)", /* not locked, ok if race */ " { return 0;", " } }", " return 1;", "}", "", "void", "Read_Queue(int q)", "{ SM_frame *f, *of;", " int remember, target_q;", " SM_results *r;", " double patience = 0.0;", "", " target_q = (q + 1) %% NCORE;", "", " for (;;)", " { f = Get_Full_Frame(q);", " if (!f) /* 1 second timeout -- and trigger for Query */", " { if (someone_crashed(2))", " { printf(\"cpu%%d: search terminated [code %%d]\\n\",", " core_id, search_terminated?*search_terminated:-1);", " sudden_stop(\"\");", " pan_exit(1);", " }", "#ifdef TESTING", " /* to profile with cc -pg and gprof pan.exe -- set handoff depth beyond maxdepth */", " exit(0);", "#endif", " remember = *grfree;", " if (core_id == 0 /* root can initiate termination */", " && remote_party == 0 /* and only the original root */", " && query_in_progress == 0 /* unless its already in progress */", " && AllQueuesEmpty())", " { f = Get_Free_Frame(target_q);", " query_in_progress = 1; /* only root process can do this */", " if (!f) { Uerror(\"Fatal1: no free slot\"); }", " f->m_boq = QUERY; /* initiate Query */", " if (verbose)", " { cpu_printf(\"snd QUERY to q%%d (%%d) into slot %%d\\n\",", " target_q, nstates_get + 1, prfree[target_q]-1);", " }", " f->m_vsize = remember + 1;", " /* number will not change unless we receive more states */", " } else if (patience++ > OneHour) /* one hour watchdog timer */", " { cpu_printf(\"timeout -- giving up\\n\");", " sudden_stop(\"queue timeout\");", " pan_exit(1);", " }", " if (0) cpu_printf(\"timed out -- try again\\n\");", " continue; ", " }", " patience = 0.0; /* reset watchdog */", "", " if (f->m_boq == QUERY)", " { if (verbose)", " { cpu_printf(\"got QUERY on q%%d (%%d <> %%d) from slot %%d\\n\",", " q, f->m_vsize, nstates_put + 1, prfull[q]-1);", " snapshot();", " }", " remember = f->m_vsize;", " f->m_vsize = 0; /* release slot */", "", " if (core_id == 0 && remote_party == 0) /* original root cpu0 */", " { if (query_in_progress == 1 /* didn't send more states in the interim */", " && *grfree + 1 == remember) /* no action on global queue meanwhile */", " { if (verbose) cpu_printf(\"Termination detected\\n\");", " if (TargetQ_Full(target_q))", " { if (verbose)", " cpu_printf(\"warning: target q is full\\n\");", " }", " f = Get_Free_Frame(target_q);", " if (!f) { Uerror(\"Fatal2: no free slot\"); }", " m_clear_frame(f);", " f->m_boq = QUIT; /* send final Quit, collect stats */", " f->m_vsize = 111; /* anything non-zero will do */", " if (verbose)", " cpu_printf(\"put QUIT on q%%d\\n\", target_q);", " } else", " { if (verbose) cpu_printf(\"Stale Query\\n\");", "#ifdef USE_DISK", " mem_drain();", "#endif", " }", " query_in_progress = 0;", " } else", " { if (TargetQ_Full(target_q))", " { if (verbose)", " cpu_printf(\"warning: forward query - target q full\\n\");", " }", " f = Get_Free_Frame(target_q);", " if (verbose)", " cpu_printf(\"snd QUERY response to q%%d (%%d <> %%d) in slot %%d\\n\",", " target_q, remember, *grfree + 1, prfree[target_q]-1);", " if (!f) { Uerror(\"Fatal4: no free slot\"); }", "", " if (*grfree + 1 == remember) /* no action on global queue */", " { f->m_boq = QUERY; /* forward query, to root */", " f->m_vsize = remember;", " } else", " { f->m_boq = QUERY_F; /* no match -- busy */", " f->m_vsize = 112; /* anything non-zero */", "#ifdef USE_DISK", " if (dsk_written != dsk_drained)", " { mem_drain();", " }", "#endif", " } }", " continue;", " }", "", " if (f->m_boq == QUERY_F)", " { if (verbose)", " { cpu_printf(\"got QUERY_F on q%%d from slot %%d\\n\", q, prfull[q]-1);", " }", " f->m_vsize = 0; /* release slot */", "", " if (core_id == 0 && remote_party == 0) /* original root cpu0 */", " { if (verbose) cpu_printf(\"No Match on Query\\n\");", " query_in_progress = 0;", " } else", " { if (TargetQ_Full(target_q))", " { if (verbose) cpu_printf(\"warning: forwarding query_f, target queue full\\n\");", " }", " f = Get_Free_Frame(target_q);", " if (verbose) cpu_printf(\"forward QUERY_F to q%%d into slot %%d\\n\",", " target_q, prfree[target_q]-1);", " if (!f) { Uerror(\"Fatal5: no free slot\"); }", " f->m_boq = QUERY_F; /* cannot terminate yet */", " f->m_vsize = 113; /* anything non-zero */", " }", "#ifdef USE_DISK", " if (dsk_written != dsk_drained)", " { mem_drain();", " }", "#endif", " continue;", " }", "", " if (f->m_boq == QUIT)", " { if (0) cpu_printf(\"done -- local memcnt %%g Mb\\n\", memcnt/(1048576.));", " retrieve_info((SM_results *) f); /* collect and combine stats */", " if (verbose)", " { cpu_printf(\"received Quit\\n\");", " snapshot();", " }", " f->m_vsize = 0; /* release incoming slot */", " if (core_id != 0)", " { f = Get_Free_Frame(target_q); /* new outgoing slot */", " if (!f) { Uerror(\"Fatal6: no free slot\"); }", " m_clear_frame(f); /* start with zeroed stats */", " record_info((SM_results *) f);", " f->m_boq = QUIT; /* forward combined results */", " f->m_vsize = 114; /* anything non-zero */", " if (verbose>1)", " cpu_printf(\"fwd Results to q%%d\\n\", target_q);", " }", " break; /* successful termination */", " }", "", " /* else: 0<= boq <= 255, means STATE transfer */", " if (unpack_state(f, q) != 0)", " { nstates_get++;", " f->m_vsize = 0; /* release slot */", " if (VVERBOSE) cpu_printf(\"Got state\\n\");", "", " if (search_terminated != NULL", " && *search_terminated == 0)", " { new_state(); /* explore successors */", " memset((uchar *) &cur_Root, 0, sizeof(SM_frame)); /* avoid confusion */", " } else", " { pan_exit(0);", " }", " } else", " { pan_exit(0);", " } }", " if (verbose) cpu_printf(\"done got %%d put %%d\\n\", nstates_get, nstates_put);", " sleep_report();", "}", "", "void", "give_up(int unused_x)", "{", " if (search_terminated != NULL)", " { *search_terminated |= 32; /* give_up */", " }", " if (!writing_trail)", " { was_interrupted = 1;", " snapshot();", " cpu_printf(\"Give Up\\n\");", " sleep_report();", " pan_exit(1);", " } else /* we are already terminating */", " { cpu_printf(\"SIGINT\\n\");", " }", "}", "", "void", "check_overkill(void)", "{", " vmax_seen = (vmax_seen + 7)/ 8;", " vmax_seen *= 8; /* round up to a multiple of 8 */", "", " if (core_id == 0", " && !remote_party", " && nstates_put > 0", " && VMAX - vmax_seen > 8)", " {", "#ifdef BITSTATE", " printf(\"cpu0: max VMAX value seen in this run: \");", "#else", " printf(\"cpu0: recommend recompiling with \");", "#endif", " printf(\"-DVMAX=%%d\\n\", vmax_seen);", " }", "}", "", "void", "mem_put(int q) /* handoff state to other cpu, workq q */", "{ SM_frame *f;", " int i, j;", "", " if (vsize > VMAX)", " { vsize = (vsize + 7)/8; vsize *= 8; /* round up */", " printf(\"pan: recompile with -DVMAX=N with N >= %%d\\n\", (int) vsize);", " Uerror(\"aborting\");", " }", " if (now._nr_pr > PMAX)", " { printf(\"pan: recompile with -DPMAX=N with N >= %%d\\n\", now._nr_pr);", " Uerror(\"aborting\");", " }", " if (now._nr_qs > QMAX)", " { printf(\"pan: recompile with -DQMAX=N with N >= %%d\\n\", now._nr_qs);", " Uerror(\"aborting\");", " }", " if (vsize > vmax_seen) vmax_seen = vsize;", " if (now._nr_pr > pmax_seen) pmax_seen = now._nr_pr;", " if (now._nr_qs > qmax_seen) qmax_seen = now._nr_qs;", "", " f = Get_Free_Frame(q); /* not called in likely deadlock states */", " if (!f) { Uerror(\"Fatal3: no free slot\"); }", "", " if (VVERBOSE) cpu_printf(\"putting state into q%%d\\n\", q);", "", " memcpy((uchar *) f->m_now, (uchar *) &now, vsize);", "#if !defined(NOCOMP) && !defined(HC)", " memset((uchar *) f->m_mask, 0, (VMAX+7)/8 * sizeof(char));", " for (i = j = 0; i < VMAX; i++, j = (j+1)%%8)", " { if (Mask[i])", " { f->m_mask[i/8] |= (1< 0)", " { memcpy((uchar *) f->m_p_offset, (uchar *) proc_offset, now._nr_pr * sizeof(OFFT));", " memcpy((uchar *) f->m_p_skip, (uchar *) proc_skip, now._nr_pr * sizeof(uchar));", " }", " if (now._nr_qs > 0)", " { memcpy((uchar *) f->m_q_offset, (uchar *) q_offset, now._nr_qs * sizeof(OFFT));", " memcpy((uchar *) f->m_q_skip, (uchar *) q_skip, now._nr_qs * sizeof(uchar));", " }", "#if defined(C_States) && (HAS_TRACK==1) && (HAS_STACK==1)", " c_stack((uchar *) f->m_c_stack); /* save unmatched tracked data */", "#endif", "#ifdef FULL_TRAIL", " f->m_stack = stack_last[core_id];", "#endif", " f->nr_handoffs = nr_handoffs+1;", " f->m_tau = trpt->tau;", " f->m_o_pm = trpt->o_pm;", " f->m_boq = boq;", " f->m_vsize = vsize; /* must come last - now the other cpu can see it */", "", " if (query_in_progress == 1)", " query_in_progress = 2; /* make sure we know, if a query makes the rounds */", " nstates_put++;", "}", "", "#ifdef USE_DISK", "int Dsk_W_Nr, Dsk_R_Nr;", "int dsk_file = -1, dsk_read = -1;", "unsigned long dsk_written, dsk_drained;", "char dsk_name[512];", "", "#ifndef BFS_DISK", "#if defined(WIN32) || defined(WIN64)", " #define RFLAGS (O_RDONLY|O_BINARY)", " #define WFLAGS (O_CREAT|O_WRONLY|O_TRUNC|O_BINARY)", "#else", " #define RFLAGS (O_RDONLY)", " #define WFLAGS (O_CREAT|O_WRONLY|O_TRUNC)", "#endif", "#endif", "", "void", "dsk_stats(void)", "{ int i;", "", " if (dsk_written > 0)", " { cpu_printf(\"dsk_written %%d states in %%d files\\ncpu%%d: dsk_drained %%6d states\\n\",", " dsk_written, Dsk_W_Nr, core_id, dsk_drained);", " close(dsk_read);", " close(dsk_file);", " for (i = 0; i < Dsk_W_Nr; i++)", " { sprintf(dsk_name, \"Q%%.3d_%%.3d.tmp\", i, core_id);", " unlink(dsk_name);", " } }", "}", "", "void", "mem_drain(void)", "{ SM_frame *f, g;", " int q = (core_id + 1) %% NCORE; /* target q */", " int sz;", "", " if (dsk_read < 0", " || dsk_written <= dsk_drained)", " { return;", " }", "", " while (dsk_written > dsk_drained", " && TargetQ_NotFull(q))", " { f = Get_Free_Frame(q);", " if (!f) { Uerror(\"Fatal: unhandled condition\"); }", "", " if ((dsk_drained+1)%%MAX_DSK_FILE == 0) /* 100K states max per file */", " { (void) close(dsk_read); /* close current read handle */", " sprintf(dsk_name, \"Q%%.3d_%%.3d.tmp\", Dsk_R_Nr++, core_id);", " (void) unlink(dsk_name); /* remove current file */", " sprintf(dsk_name, \"Q%%.3d_%%.3d.tmp\", Dsk_R_Nr, core_id);", " cpu_printf(\"reading %%s\\n\", dsk_name);", " dsk_read = open(dsk_name, RFLAGS); /* open next file */", " if (dsk_read < 0)", " { Uerror(\"could not open dsk file\");", " } }", " if (read(dsk_read, &g, sizeof(SM_frame)) != sizeof(SM_frame))", " { Uerror(\"bad dsk file read\");", " }", " sz = g.m_vsize;", " g.m_vsize = 0;", " memcpy(f, &g, sizeof(SM_frame));", " f->m_vsize = sz; /* last */", "", " dsk_drained++;", " }", "}", "", "void", "mem_file(void)", "{ SM_frame f;", " int i, j, q = (core_id + 1) %% NCORE; /* target q */", "", " if (vsize > VMAX)", " { printf(\"pan: recompile with -DVMAX=N with N >= %%d\\n\", vsize);", " Uerror(\"aborting\");", " }", " if (now._nr_pr > PMAX)", " { printf(\"pan: recompile with -DPMAX=N with N >= %%d\\n\", now._nr_pr);", " Uerror(\"aborting\");", " }", " if (now._nr_qs > QMAX)", " { printf(\"pan: recompile with -DQMAX=N with N >= %%d\\n\", now._nr_qs);", " Uerror(\"aborting\");", " }", "", " if (VVERBOSE) cpu_printf(\"filing state for q%%d\\n\", q);", "", " memcpy((uchar *) f.m_now, (uchar *) &now, vsize);", "#if !defined(NOCOMP) && !defined(HC)", " memset((uchar *) f.m_mask, 0, (VMAX+7)/8 * sizeof(char));", " for (i = j = 0; i < VMAX; i++, j = (j+1)%%8)", " { if (Mask[i])", " { f.m_mask[i/8] |= (1< 0)", " { memcpy((uchar *)f.m_p_offset, (uchar *)proc_offset, now._nr_pr*sizeof(OFFT));", " memcpy((uchar *)f.m_p_skip, (uchar *)proc_skip, now._nr_pr*sizeof(uchar));", " }", " if (now._nr_qs > 0)", " { memcpy((uchar *) f.m_q_offset, (uchar *) q_offset, now._nr_qs*sizeof(OFFT));", " memcpy((uchar *) f.m_q_skip, (uchar *) q_skip, now._nr_qs*sizeof(uchar));", " }", "#if defined(C_States) && (HAS_TRACK==1) && (HAS_STACK==1)", " c_stack((uchar *) f.m_c_stack); /* save unmatched tracked data */", "#endif", "#ifdef FULL_TRAIL", " f.m_stack = stack_last[core_id];", "#endif", " f.nr_handoffs = nr_handoffs+1;", " f.m_tau = trpt->tau;", " f.m_o_pm = trpt->o_pm;", " f.m_boq = boq;", " f.m_vsize = vsize;", "", " if (query_in_progress == 1)", " { query_in_progress = 2;", " }", " if (dsk_file < 0)", " { sprintf(dsk_name, \"Q%%.3d_%%.3d.tmp\", Dsk_W_Nr, core_id);", " dsk_file = open(dsk_name, WFLAGS, 0644);", " dsk_read = open(dsk_name, RFLAGS);", " if (dsk_file < 0 || dsk_read < 0)", " { cpu_printf(\"File: <%%s>\\n\", dsk_name);", " Uerror(\"cannot open diskfile\");", " }", " Dsk_W_Nr++; /* nr of next file to open */", " cpu_printf(\"created temporary diskfile %%s\\n\", dsk_name);", " } else if ((dsk_written+1)%%MAX_DSK_FILE == 0)", " { close(dsk_file); /* close write handle */", " sprintf(dsk_name, \"Q%%.3d_%%.3d.tmp\", Dsk_W_Nr++, core_id);", " dsk_file = open(dsk_name, WFLAGS, 0644);", " if (dsk_file < 0)", " { cpu_printf(\"File: <%%s>\\n\", dsk_name);", " Uerror(\"aborting: cannot open new diskfile\");", " }", " cpu_printf(\"created temporary diskfile %%s\\n\", dsk_name);", " }", " if (write(dsk_file, &f, sizeof(SM_frame)) != sizeof(SM_frame))", " { Uerror(\"aborting -- disk write failed (disk full?)\");", " }", " nstates_put++;", " dsk_written++;", "}", "#endif", "", "int", "mem_hand_off(void)", "{", " if (search_terminated == NULL", " || *search_terminated != 0) /* not a full crash check */", " { pan_exit(0);", " }", " iam_alive(); /* on every transition of Down */", "#ifdef USE_DISK", " mem_drain(); /* maybe call this also on every Up */", "#endif", " if (depth > z_handoff /* above handoff limit */", "#ifndef SAFETY", " && !a_cycles /* not in liveness mode */", "#endif", "#if SYNC", " && boq == -1 /* not mid-rv */", "#endif", "#ifdef VERI", " && (trpt->tau&4) /* claim moves first */", " && !((trpt-1)->tau&128) /* not a stutter move */", "#endif", " && !(trpt->tau&8)) /* not an atomic move */", " { int q = (core_id + 1) %% NCORE; /* circular handoff */", " #ifdef GENEROUS", " if (prcnt[q] < LN_FRAMES)", /* not the best strategy */ " #else", " if (TargetQ_NotFull(q)", " && (dfs_phase2 == 0 || prcnt[core_id] > 0))", /* not locked, ok if race */ " #endif", " { mem_put(q);", /* only 1 writer: lock-free */ " return 1;", " }", " { int rval;", " #ifndef NGQ", " rval = GlobalQ_HasRoom();", " #else", " rval = 0;", " #endif", " #ifdef USE_DISK", " if (rval == 0)", " { void mem_file(void);", " mem_file();", " rval = 1;", " }", " #endif", " return rval;", " }", " }", " return 0; /* i.e., no handoff */", "}", "", "void", "mem_put_acc(void) /* liveness mode */", "{ int q = (core_id + 1) %% NCORE;", "", " if (search_terminated == NULL", " || *search_terminated != 0)", " { pan_exit(0);", " }", "#ifdef USE_DISK", " mem_drain();", "#endif", " /* some tortured use of preprocessing: */", "#if !defined(NGQ) || defined(USE_DISK)", " if (TargetQ_Full(q))", " {", "#endif", "#ifndef NGQ", " if (GlobalQ_HasRoom())", " { return;", " }", "#endif", "#ifdef USE_DISK", " mem_file();", " } else", "#else", " #if !defined(NGQ) || defined(USE_DISK)", " }", " #endif", "#endif", " { mem_put(q);", " }", "}", "", "#if defined(WIN32) || defined(WIN64)", /* visual studio */ "void", "init_shm(void) /* initialize shared work-queues */", "{ char key[512];", " int n, m;", " int must_exit = 0;", "", " if (core_id == 0 && verbose)", " { printf(\"cpu0: step 3: allocate shared work-queues %%g Mb\\n\",", " ((double) NCORE * LWQ_SIZE + GWQ_SIZE) / (1048576.));", " }", " for (m = 0; m < NR_QS; m++) /* last q is global 1 */", " { double qsize = (m == NCORE) ? GWQ_SIZE : LWQ_SIZE;", " sprintf(key, \"Global\\\\pan_%%s_%%.3d\", PanSource, m);", " if (core_id == 0)", /* root process creates shared memory segments */ " { shmid[m] = CreateFileMapping(", " INVALID_HANDLE_VALUE, /* use paging file */", " NULL, /* default security */", " PAGE_READWRITE, /* access permissions */", " 0, /* high-order 4 bytes */", " qsize, /* low-order bytes, size in bytes */", " key); /* name */", " } else /* worker nodes just open these segments */", " { shmid[m] = OpenFileMapping(", " FILE_MAP_ALL_ACCESS, /* read/write access */", " FALSE, /* children do not inherit handle */", " key);", " }", " if (shmid[m] == NULL)", " { fprintf(stderr, \"cpu%%d: could not create or open shared queues\\n\",", " core_id);", " must_exit = 1;", " break;", " }", " /* attach: */", " shared_mem[m] = (char *) MapViewOfFile(shmid[m], FILE_MAP_ALL_ACCESS, 0, 0, 0);", " if (shared_mem[m] == NULL)", " { fprintf(stderr, \"cpu%%d: cannot attach shared q%%d (%%d Mb)\\n\",", " core_id, m+1, (int) (qsize/(1048576.)));", " must_exit = 1;", " break;", " }", "", " memcnt += qsize;", "", " m_workq[m] = (SM_frame *) shared_mem[m];", " if (core_id == 0)", " { int nframes = (m == NCORE) ? GN_FRAMES : LN_FRAMES;", " for (n = 0; n < nframes; n++)", " { m_workq[m][n].m_vsize = 0;", " m_workq[m][n].m_boq = 0;", " } } }", "", " if (must_exit)", " { fprintf(stderr, \"pan: check './pan --' for usage details\\n\");", " pan_exit(1); /* calls cleanup_shm */", " }", "}", "", "static uchar *", "prep_shmid_S(size_t n) /* either sets SS or H_tab, WIN32/WIN64 */", "{ char *rval;", "#ifndef SEP_STATE", " char key[512];", "", " if (verbose && core_id == 0)", " {", " #ifdef BITSTATE", " printf(\"cpu0: step 1: allocate shared bitstate %%g Mb\\n\",", " (double) n / (1048576.));", " #else", " printf(\"cpu0: step 1: allocate shared hastable %%g Mb\\n\",", " (double) n / (1048576.));", " #endif", " }", " #ifdef MEMLIM", " if (memcnt + (double) n > memlim)", " { printf(\"cpu%%d: S %%8g + %%d Kb exceeds memory limit of %%8g Mb\\n\",", " core_id, memcnt/1024., n/1024, memlim/(1048576.));", " printf(\"cpu%%d: insufficient memory -- aborting\\n\", core_id);", " exit(1);", " }", " #endif", "", " /* make key different from queues: */", " sprintf(key, \"Global\\\\pan_%%s_%%.3d\", PanSource, NCORE+2); /* different from qs */", "", " if (core_id == 0) /* root */", " { shmid_S = CreateFileMapping(INVALID_HANDLE_VALUE, NULL,", "#ifdef WIN64", " PAGE_READWRITE, (n>>32), (n & 0xffffffff), key);", "#else", " PAGE_READWRITE, 0, n, key);", "#endif", " memcnt += (double) n;", " } else /* worker */", " { shmid_S = OpenFileMapping(FILE_MAP_ALL_ACCESS, FALSE, key);", " }", " if (shmid_S == NULL)", " {", " #ifdef BITSTATE", " fprintf(stderr, \"cpu%%d: cannot %%s shared bitstate\",", " core_id, core_id?\"open\":\"create\");", " #else", " fprintf(stderr, \"cpu%%d: cannot %%s shared hashtable\",", " core_id, core_id?\"open\":\"create\");", " #endif", " fprintf(stderr, \"pan: check './pan --' for usage details\\n\");", " pan_exit(1);", " }", "", " rval = (char *) MapViewOfFile(shmid_S, FILE_MAP_ALL_ACCESS, 0, 0, 0); /* attach */", " if ((char *) rval == NULL)", " { fprintf(stderr, \"cpu%%d: cannot attach shared bitstate or hashtable\\n\", core_id);", " fprintf(stderr, \"pan: check './pan --' for usage details\\n\");", " pan_exit(1);", " }", "#else", " rval = (char *) emalloc(n);", "#endif", " return (uchar *) rval;", "}", "", "static uchar *", "prep_state_mem(size_t n) /* WIN32/WIN64 sets memory arena for states */", "{ char *rval;", " char key[512];", " static int cnt = 3; /* start larger than earlier ftok calls */", "", " if (verbose && core_id == 0)", " { printf(\"cpu0: step 2+: pre-allocate memory arena %%d of %%g Mb\\n\",", " cnt-3, (double) n / (1048576.));", " }", " #ifdef MEMLIM", " if (memcnt + (double) n > memlim)", " { printf(\"cpu%%d: error: M %%.0f + %%.0f exceeds memory limit of %%.0f Kb\\n\",", " core_id, memcnt/1024.0, (double) n/1024.0, memlim/1024.0);", " return NULL;", " }", " #endif", "", " sprintf(key, \"Global\\\\pan_%%s_%%.3d\", PanSource, NCORE+cnt); cnt++;", "", " if (core_id == 0)", " { shmid_M = CreateFileMapping(INVALID_HANDLE_VALUE, NULL,", "#ifdef WIN64", " PAGE_READWRITE, (n>>32), (n & 0xffffffff), key);", "#else", " PAGE_READWRITE, 0, n, key);", "#endif", " } else", " { shmid_M = OpenFileMapping(FILE_MAP_ALL_ACCESS, FALSE, key);", " }", " if (shmid_M == NULL)", " { printf(\"cpu%%d: failed to get pool of shared memory nr %%d of size %%d\\n\",", " core_id, cnt-3, n);", " printf(\"pan: check './pan --' for usage details\\n\");", " return NULL;", " }", " rval = (char *) MapViewOfFile(shmid_M, FILE_MAP_ALL_ACCESS, 0, 0, 0); /* attach */", "", " if (rval == NULL)", " { printf(\"cpu%%d: failed to attach pool of shared memory nr %%d of size %%d\\n\",", " core_id, cnt-3, n);", " return NULL;", " }", " return (uchar *) rval;", "}", "", "void", "init_HT(unsigned long n) /* WIN32/WIN64 version */", "{ volatile char *x;", " double get_mem;", "#ifndef SEP_STATE", " char *dc_mem_start;", "#endif", " if (verbose) printf(\"cpu%%d: initialization for Windows\\n\", core_id);", "", "#ifdef SEP_STATE", " #ifndef MEMLIM", " if (verbose)", " { printf(\"cpu0: steps 0,1: no -DMEMLIM set\\n\");", " }", " #else", " if (verbose)", " printf(\"cpu0: steps 0,1: -DMEMLIM=%%d Mb - (hashtable %%g Mb + workqueues %%g Mb)\\n\",", " MEMLIM, ((double)n/(1048576.)), ((double) NCORE * LWQ_SIZE + GWQ_SIZE)/(1048576.));", "#endif", " get_mem = NCORE * sizeof(double) + (1 + CS_NR) * sizeof(void *)+ 4*sizeof(void *) + 2*sizeof(double);", " /* NCORE * is_alive + search_terminated + CS_NR * sh_lock + 6 gr vars */", " get_mem += 4 * NCORE * sizeof(void *);", /* prfree, prfull, prcnt, prmax */ " #ifdef FULL_TRAIL", " get_mem += (NCORE) * sizeof(Stack_Tree *);", " /* NCORE * stack_last */", " #endif", " x = (volatile char *) prep_state_mem((size_t) get_mem);", " shmid_X = (void *) x;", " if (x == NULL)", " { printf(\"cpu0: could not allocate shared memory, see ./pan --\\n\");", " exit(1);", " }", " search_terminated = (volatile unsigned int *) x; /* comes first */", " x += sizeof(void *); /* maintain alignment */", "", " is_alive = (volatile double *) x;", " x += NCORE * sizeof(double);", "", " sh_lock = (volatile int *) x;", " x += CS_NR * sizeof(void *); /* allow 1 word per entry */", "", " grfree = (volatile int *) x;", " x += sizeof(void *);", " grfull = (volatile int *) x;", " x += sizeof(void *);", " grcnt = (volatile int *) x;", " x += sizeof(void *);", " grmax = (volatile int *) x;", " x += sizeof(void *);", " prfree = (volatile int *) x;", " x += NCORE * sizeof(void *);", " prfull = (volatile int *) x;", " x += NCORE * sizeof(void *);", " prcnt = (volatile int *) x;", " x += NCORE * sizeof(void *);", " prmax = (volatile int *) x;", " x += NCORE * sizeof(void *);", " gr_readmiss = (volatile double *) x;", " x += sizeof(double);", " gr_writemiss = (volatile double *) x;", " x += sizeof(double);", "", " #ifdef FULL_TRAIL", " stack_last = (volatile Stack_Tree **) x;", " x += NCORE * sizeof(Stack_Tree *);", " #endif", "", " #ifndef BITSTATE", " H_tab = (H_el **) emalloc(n);", " #endif", "#else", " #ifndef MEMLIM", " #warning MEMLIM not set", /* cannot happen */ " #define MEMLIM (2048)", " #endif", "", " if (core_id == 0 && verbose)", " printf(\"cpu0: step 0: -DMEMLIM=%%d Mb - (hashtable %%g Mb + workqueues %%g Mb) = %%g Mb for state storage\\n\",", " MEMLIM, ((double)n/(1048576.)), ((double) NCORE * LWQ_SIZE + GWQ_SIZE)/(1048576.),", " (memlim - memcnt - (double) n - ((double) NCORE * LWQ_SIZE + GWQ_SIZE))/(1048576.));", " #ifndef BITSTATE", " H_tab = (H_el **) prep_shmid_S((size_t) n); /* hash_table */", " #endif", " get_mem = memlim - memcnt - ((double) NCORE) * LWQ_SIZE - GWQ_SIZE;", " if (get_mem <= 0)", " { Uerror(\"internal error -- shared state memory\");", " }", "", " if (core_id == 0 && verbose)", " { printf(\"cpu0: step 2: shared state memory %%g Mb\\n\",", " get_mem/(1048576.));", " }", " x = dc_mem_start = (char *) prep_state_mem((size_t) get_mem); /* for states */", " if (x == NULL)", " { printf(\"cpu%%d: insufficient memory -- aborting\\n\", core_id);", " exit(1);", " }", "", " search_terminated = (volatile unsigned int *) x; /* comes first */", " x += sizeof(void *); /* maintain alignment */", "", " is_alive = (volatile double *) x;", " x += NCORE * sizeof(double);", "", " sh_lock = (volatile int *) x;", " x += CS_NR * sizeof(int);", "", " grfree = (volatile int *) x;", " x += sizeof(void *);", " grfull = (volatile int *) x;", " x += sizeof(void *);", " grcnt = (volatile int *) x;", " x += sizeof(void *);", " grmax = (volatile int *) x;", " x += sizeof(void *);", " prfree = (volatile int *) x;", " x += NCORE * sizeof(void *);", " prfull = (volatile int *) x;", " x += NCORE * sizeof(void *);", " prcnt = (volatile int *) x;", " x += NCORE * sizeof(void *);", " prmax = (volatile int *) x;", " x += NCORE * sizeof(void *);", " gr_readmiss = (volatile double *) x;", " x += sizeof(double);", " gr_writemiss = (volatile double *) x;", " x += sizeof(double);", "", " #ifdef FULL_TRAIL", " stack_last = (volatile Stack_Tree **) x;", " x += NCORE * sizeof(Stack_Tree *);", " #endif", " if (((long)x)&(sizeof(void *)-1)) /* word alignment */", " { x += sizeof(void *)-(((long)x)&(sizeof(void *)-1)); /* 64-bit align */", " }", "", " #ifdef COLLAPSE", " ncomps = (unsigned long *) x;", " x += (256+2) * sizeof(unsigned long);", " #endif", "", " dc_shared = (sh_Allocater *) x; /* in shared memory */", " x += sizeof(sh_Allocater);", "", " if (core_id == 0) /* root only */", " { dc_shared->dc_id = shmid_M;", " dc_shared->dc_start = (void *) dc_mem_start;", " dc_shared->dc_arena = x;", " dc_shared->pattern = 1234567;", " dc_shared->dc_size = (long) get_mem - (long) (x - dc_mem_start);", " dc_shared->nxt = NULL;", " }", "#endif", "}", "", "#if defined(WIN32) || defined(WIN64) || defined(__i386__) || defined(__x86_64__)", "extern BOOLEAN InterlockedBitTestAndSet(LONG volatile* Base, LONG Bit);", "int", "tas(volatile LONG *s)", /* atomic test and set */ "{ return InterlockedBitTestAndSet(s, 1);", "}", "#else", " #error missing definition of test and set operation for this platform", "#endif", "", "void", "cleanup_shm(int val)", "{ int m;", " static int nibis = 0;", "", " if (nibis != 0)", " { printf(\"cpu%%d: Redundant call to cleanup_shm(%%d)\\n\", core_id, val);", " return;", " } else", " { nibis = 1;", " }", " if (search_terminated != NULL)", " { *search_terminated |= 16; /* cleanup_shm */", " }", "", " for (m = 0; m < NR_QS; m++)", " { if (shmid[m] != NULL)", " { UnmapViewOfFile((char *) shared_mem[m]);", " CloseHandle(shmid[m]);", " } }", "#ifdef SEP_STATE", " UnmapViewOfFile((void *) shmid_X);", " CloseHandle((void *) shmid_M);", "#else", " #ifdef BITSTATE", " if (shmid_S != NULL)", " { UnmapViewOfFile(SS);", " CloseHandle(shmid_S);", " }", " #else", " if (core_id == 0 && verbose)", " { printf(\"cpu0: done, %%ld Mb of shared state memory left\\n\",", " dc_shared->dc_size / (long)(1048576));", " }", " if (shmid_S != NULL)", " { UnmapViewOfFile(H_tab);", " CloseHandle(shmid_S);", " }", " shmid_M = (void *) (dc_shared->dc_id);", " UnmapViewOfFile((char *) dc_shared->dc_start);", " CloseHandle(shmid_M);", " #endif", "#endif", " /* detached from shared memory - so cannot use cpu_printf */", " if (verbose)", " { printf(\"cpu%%d: done -- got %%d states from queue\\n\",", " core_id, nstates_get);", " }", "}", "", "void", "mem_get(void)", "{ SM_frame *f;", " int is_parent;", "", "#if defined(MA) && !defined(SEP_STATE)", " #error MA requires SEP_STATE in multi-core mode", "#endif", "#ifdef BFS", " #error instead of -DNCORE -DBFS use -DBFS_PAR", "#endif", "#ifdef SC", " #error SC is not supported in multi-core mode", "#endif", " init_shm(); /* we are single threaded when this starts */", " signal(SIGINT, give_up); /* windows control-c interrupt */", "", " if (core_id == 0 && verbose)", " { printf(\"cpu0: step 4: creating additional workers (proxy %%d)\\n\",", " proxy_pid);", " }", "#if 0", " if NCORE > 1 the child or the parent should fork N-1 more times", " the parent is the only process with core_id == 0 and is_parent > 0", " the others (workers) have is_parent = 0 and core_id = 1..NCORE-1", "#endif", " if (core_id == 0) /* root starts up the workers */", " { worker_pids[0] = (DWORD) getpid(); /* for completeness */", " while (++core_id < NCORE) /* first worker sees core_id = 1 */", " { char cmdline[64];", " STARTUPINFO si = { sizeof(si) };", " PROCESS_INFORMATION pi;", "", " if (proxy_pid == core_id) /* always non-zero */", " { sprintf(cmdline, \"pan_proxy.exe -r %%s-Q%%d -Z%%d\",", " o_cmdline, getpid(), core_id);", " } else", " { sprintf(cmdline, \"pan.exe %%s-Q%%d -Z%%d\",", " o_cmdline, getpid(), core_id);", " }", " if (verbose) printf(\"cpu%%d: spawn %%s\\n\", core_id, cmdline);", "", " is_parent = CreateProcess(0, cmdline, 0, 0, FALSE, 0, 0, 0, &si, &pi);", " if (is_parent == 0)", " { Uerror(\"fork failed\");", " }", " worker_pids[core_id] = pi.dwProcessId;", " worker_handles[core_id] = pi.hProcess;", " if (verbose)", " { cpu_printf(\"created core %%d, pid %%d\\n\",", " core_id, pi.dwProcessId);", " }", " if (proxy_pid == core_id) /* we just created the receive half */", " { /* add proxy send, store pid in proxy_pid_snd */", " sprintf(cmdline, \"pan_proxy.exe -s %%s-Q%%d -Z%%d -Y%%d\",", " o_cmdline, getpid(), core_id, worker_pids[proxy_pid]);", " if (verbose) printf(\"cpu%%d: spawn %%s\\n\", core_id, cmdline);", " is_parent = CreateProcess(0, cmdline, 0,0, FALSE, 0,0,0, &si, &pi);", " if (is_parent == 0)", " { Uerror(\"fork failed\");", " }", " proxy_pid_snd = pi.dwProcessId;", " proxy_handle_snd = pi.hProcess;", " if (verbose)", " { cpu_printf(\"created core %%d, pid %%d (send proxy)\\n\",", " core_id, pi.dwProcessId);", " } } }", " core_id = 0; /* reset core_id for root process */", " } else /* worker */", " { static char db0[16]; /* good for up to 10^6 cores */", " static char db1[16];", " tprefix = db0; sprefix = db1;", " sprintf(tprefix, \"cpu%%d_trail\", core_id); /* avoid conflicts on file access */", " sprintf(sprefix, \"cpu%%d_rst\", core_id);", " memcnt = 0; /* count only additionally allocated memory */", " }", " if (verbose)", " { cpu_printf(\"starting core_id %%d -- pid %%d\\n\", core_id, getpid());", " }", " if (core_id == 0 && !remote_party)", " { new_state(); /* root starts the search */", " if (verbose)", " cpu_printf(\"done with 1st dfs, nstates %%g (put %%d states), start reading q\\n\",", " nstates, nstates_put);", " dfs_phase2 = 1;", " }", " Read_Queue(core_id); /* all cores */", "", " if (verbose)", " { cpu_printf(\"put %%6d states into queue -- got %%6d\\n\",", " nstates_put, nstates_get);", " }", " done = 1;", " wrapup();", " exit(0);", "}", "#endif", /* WIN32 || WIN64 */ "", "#ifdef BITSTATE", "void", "init_SS(unsigned long n)", "{", " SS = (uchar *) prep_shmid_S((size_t) n);", " init_HT(0L);", /* locks and shared memory for Stack_Tree allocations */ "}", "#endif", /* BITSTATE */ "", "#endif", /* NCORE>1 */ 0, };