From 38f21d7d70c1dd6274e4c04f217ec8214676a816 Mon Sep 17 00:00:00 2001 From: compudj Date: Wed, 15 Oct 2008 16:22:32 +0000 Subject: [PATCH] update git-svn-id: http://ltt.polymtl.ca/svn@3112 04897980-b3bd-0310-b5e0-8ef037075253 --- trunk/verif/examples/buffer.spin.trail | 103 - trunk/verif/examples/pan | Bin 108893 -> 0 bytes trunk/verif/examples/pan.b | 433 - trunk/verif/examples/pan.c | 11503 ---------------- trunk/verif/examples/pan.h | 610 - trunk/verif/examples/pan.m | 987 -- trunk/verif/examples/pan.t | 919 -- .../verif/examples/spin-increment.spin.trail | 22 - 8 files changed, 14577 deletions(-) delete mode 100644 trunk/verif/examples/buffer.spin.trail delete mode 100755 trunk/verif/examples/pan delete mode 100644 trunk/verif/examples/pan.b delete mode 100644 trunk/verif/examples/pan.c delete mode 100644 trunk/verif/examples/pan.h delete mode 100644 trunk/verif/examples/pan.m delete mode 100644 trunk/verif/examples/pan.t delete mode 100644 trunk/verif/examples/spin-increment.spin.trail diff --git a/trunk/verif/examples/buffer.spin.trail b/trunk/verif/examples/buffer.spin.trail deleted file mode 100644 index bc2446c0..00000000 --- a/trunk/verif/examples/buffer.spin.trail +++ /dev/null @@ -1,103 +0,0 @@ --4:-4:-4 -1:0:118 -2:0:119 -3:0:119 -4:0:122 -5:0:128 -6:0:128 -7:0:128 -8:0:128 -9:0:131 -10:0:136 -11:0:137 -12:0:139 -13:0:141 -14:0:139 -15:0:141 -16:0:139 -17:0:141 -18:0:139 -19:0:141 -20:0:143 -21:0:149 -22:0:151 -23:0:153 -24:0:157 -25:7:0 -26:7:3 -27:7:28 -28:7:29 -29:6:30 -30:6:35 -31:6:36 -32:6:42 -33:6:43 -34:6:47 -35:6:51 -36:6:55 -37:6:57 -38:6:58 -39:6:61 -40:6:68 -41:6:75 -42:6:77 -43:6:79 -44:5:30 -45:5:35 -46:5:36 -47:5:42 -48:5:43 -49:5:47 -50:5:51 -51:5:55 -52:5:57 -53:5:58 -54:5:61 -55:5:70 -56:5:71 -57:5:75 -58:5:77 -59:5:79 -60:4:30 -61:4:35 -62:4:36 -63:4:42 -64:4:43 -65:4:47 -66:4:51 -67:4:55 -68:4:57 -69:4:58 -70:4:61 -71:4:68 -72:4:75 -73:4:77 -74:4:79 -75:3:30 -76:3:35 -77:3:36 -78:3:42 -79:3:43 -80:3:47 -81:3:51 -82:3:55 -83:3:57 -84:3:58 -85:3:61 -86:3:70 -87:3:71 -88:3:75 -89:3:77 -90:3:79 -91:2:109 -92:2:111 -93:2:115 -94:3:0 -95:3:3 -96:3:28 -97:3:29 -98:2:117 -99:0:159 -100:0:162 -101:0:162 -102:0:165 diff --git a/trunk/verif/examples/pan b/trunk/verif/examples/pan deleted file mode 100755 index c6cf6e59a21d2725bdfe70da538248ea6d9755b0..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 108893 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%0AF$opJ2;OY3Jy1DxmUobq*MQrCz_?H0rkUd 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 If;x)-4F&{O+yDRo diff --git a/trunk/verif/examples/pan.b b/trunk/verif/examples/pan.b deleted file mode 100644 index 1ae73245..00000000 --- a/trunk/verif/examples/pan.b +++ /dev/null @@ -1,433 +0,0 @@ - switch (t->back) { - default: Uerror("bad return move"); - case 0: goto R999; /* nothing to undo */ - - /* PROC :init: */ - - case 3: /* STATE 1 */ - ; - ((P4 *)this)->i = trpt->bup.oval; - ; - goto R999; - - case 4: /* STATE 4 */ - ; - ((P4 *)this)->i = trpt->bup.ovals[1]; - now.commit_count[ Index(((P4 *)this)->i, 2) ] = trpt->bup.ovals[0]; - ; - ungrab_ints(trpt->bup.ovals, 2); - goto R999; - - case 5: /* STATE 10 */ - ; - ((P4 *)this)->i = trpt->bup.ovals[1]; - /* 0 */ ((P4 *)this)->i = trpt->bup.ovals[0]; - ; - ; - ungrab_ints(trpt->bup.ovals, 2); - goto R999; - - case 6: /* STATE 10 */ - ; - ((P4 *)this)->i = trpt->bup.oval; - ; - goto R999; - - case 7: /* STATE 13 */ - ; - ((P4 *)this)->i = trpt->bup.ovals[1]; - now.buffer_use[ Index(((P4 *)this)->i, 4) ] = trpt->bup.ovals[0]; - ; - ungrab_ints(trpt->bup.ovals, 2); - goto R999; - - case 8: /* STATE 14 */ - ; - /* 0 */ ((P4 *)this)->i = trpt->bup.oval; - ; - ; - goto R999; - - case 9: /* STATE 19 */ - ; - ; - delproc(0, now._nr_pr-1); - ; - goto R999; - - case 10: /* STATE 21 */ - ; - ((P4 *)this)->i = trpt->bup.oval; - ; - delproc(0, now._nr_pr-1); - ; - goto R999; - - case 11: /* STATE 23 */ - ; - now.refcount = trpt->bup.oval; - ; - goto R999; - - case 12: /* STATE 25 */ - ; - ((P4 *)this)->i = trpt->bup.oval; - ; - delproc(0, now._nr_pr-1); - ; - goto R999; - - case 13: /* STATE 31 */ - ; - ((P4 *)this)->i = trpt->bup.ovals[1]; - /* 0 */ ((P4 *)this)->i = trpt->bup.ovals[0]; - ; - ; - ungrab_ints(trpt->bup.ovals, 2); - goto R999; - - case 14: /* STATE 31 */ - ; - ((P4 *)this)->i = trpt->bup.oval; - ; - goto R999; - - case 15: /* STATE 33 */ - ; - now.refcount = trpt->bup.oval; - ; - goto R999; - - case 16: /* STATE 35 */ - ; - ((P4 *)this)->i = trpt->bup.oval; - ; - delproc(0, now._nr_pr-1); - ; - goto R999; - - case 17: /* STATE 36 */ - ; - /* 0 */ ((P4 *)this)->i = trpt->bup.oval; - ; - ; - goto R999; - - case 18: /* STATE 44 */ - ; - ((P4 *)this)->commit_sum = trpt->bup.ovals[1]; - ((P4 *)this)->j = trpt->bup.ovals[0]; - ; - ungrab_ints(trpt->bup.ovals, 2); - goto R999; - - case 19: /* STATE 47 */ - ; - ((P4 *)this)->j = trpt->bup.ovals[1]; - ((P4 *)this)->commit_sum = trpt->bup.ovals[0]; - ; - ungrab_ints(trpt->bup.ovals, 2); - goto R999; - - case 20: /* STATE 48 */ - ; - /* 0 */ ((P4 *)this)->j = trpt->bup.oval; - ; - ; - goto R999; -; - - case 21: /* STATE 53 */ - goto R999; - - case 22: /* STATE 56 */ - ; - p_restor(II); - ; - ; - goto R999; - - /* PROC cleaner */ - - case 23: /* STATE 2 */ - ; - now.refcount = trpt->bup.oval; - ; - goto R999; - - case 24: /* STATE 3 */ - ; - ; - delproc(0, now._nr_pr-1); - ; - goto R999; - - case 25: /* STATE 9 */ - ; - p_restor(II); - ; - ; - goto R999; - - /* PROC reader */ -; - ; - - case 27: /* STATE 2 */ - ; - ((P2 *)this)->i = trpt->bup.oval; - ; - goto R999; - - case 28: /* STATE 6 */ - ; - ((P2 *)this)->i = trpt->bup.ovals[1]; - now.buffer_use[ Index(((now.read_off+((P2 *)this)->i)%4), 4) ] = trpt->bup.ovals[0]; - ; - ungrab_ints(trpt->bup.ovals, 2); - goto R999; - - case 29: /* STATE 7 */ - ; - /* 0 */ ((P2 *)this)->i = trpt->bup.oval; - ; - ; - goto R999; - - case 30: /* STATE 16 */ - ; - ((P2 *)this)->i = trpt->bup.ovals[1]; - now.buffer_use[ Index(((now.read_off+((P2 *)this)->i)%4), 4) ] = trpt->bup.ovals[0]; - ; - ungrab_ints(trpt->bup.ovals, 2); - goto R999; - - case 31: /* STATE 17 */ - ; - /* 0 */ ((P2 *)this)->i = trpt->bup.oval; - ; - ; - goto R999; - - case 32: /* STATE 22 */ - ; - now.read_off = trpt->bup.oval; - ; - goto R999; -; - ; - - case 34: /* STATE 29 */ - ; - p_restor(II); - ; - ; - goto R999; - - /* PROC tracer */ - - case 35: /* STATE 2 */ - ; - ((P1 *)this)->new_off = trpt->bup.ovals[1]; - ((P1 *)this)->prev_off = trpt->bup.ovals[0]; - ; - ungrab_ints(trpt->bup.ovals, 2); - goto R999; - - case 36: /* STATE 4 */ - ; - /* 0 */ ((P1 *)this)->new_off = trpt->bup.oval; - ; - ; - goto R999; -; - - case 37: /* STATE 7 */ - goto R999; - - case 38: /* STATE 11 */ - ; - /* 0 */ ((P1 *)this)->prev_off = trpt->bup.oval; - ; - ; - goto R999; - - case 39: /* STATE 17 */ - ; - ((P1 *)this)->i = trpt->bup.ovals[1]; - now.write_off = trpt->bup.ovals[0]; - ; - ungrab_ints(trpt->bup.ovals, 2); - goto R999; - - case 40: /* STATE 17 */ - ; - ((P1 *)this)->i = trpt->bup.oval; - ; - goto R999; - - case 41: /* STATE 21 */ - ; - ((P1 *)this)->i = trpt->bup.ovals[1]; - now.buffer_use[ Index(((((P1 *)this)->prev_off+((P1 *)this)->i)%4), 4) ] = trpt->bup.ovals[0]; - ; - ungrab_ints(trpt->bup.ovals, 2); - goto R999; - - case 42: /* STATE 22 */ - ; - /* 0 */ ((P1 *)this)->i = trpt->bup.oval; - ; - ; - goto R999; - - case 43: /* STATE 28 */ - ; - ((P1 *)this)->i = trpt->bup.oval; - ; - goto R999; - - case 44: /* STATE 31 */ - ; - ((P1 *)this)->i = trpt->bup.ovals[1]; - now.buffer_use[ Index(((((P1 *)this)->prev_off+((P1 *)this)->i)%4), 4) ] = trpt->bup.ovals[0]; - ; - ungrab_ints(trpt->bup.ovals, 2); - goto R999; - - case 45: /* STATE 38 */ - ; - now.commit_count[ Index(((((P1 *)this)->prev_off%4)/(4/2)), 2) ] = trpt->bup.ovals[2]; - ((P1 *)this)->tmp_commit = trpt->bup.ovals[1]; - /* 0 */ ((P1 *)this)->i = trpt->bup.ovals[0]; - ; - ; - ungrab_ints(trpt->bup.ovals, 3); - goto R999; - - case 46: /* STATE 38 */ - ; - now.commit_count[ Index(((((P1 *)this)->prev_off%4)/(4/2)), 2) ] = trpt->bup.ovals[1]; - ((P1 *)this)->tmp_commit = trpt->bup.ovals[0]; - ; - ungrab_ints(trpt->bup.ovals, 2); - goto R999; - - case 47: /* STATE 40 */ - ; - deliver = trpt->bup.ovals[2]; - /* 1 */ ((P1 *)this)->tmp_commit = trpt->bup.ovals[1]; - /* 0 */ ((P1 *)this)->prev_off = trpt->bup.ovals[0]; - ; - ; - ungrab_ints(trpt->bup.ovals, 3); - goto R999; -; - - case 48: /* STATE 44 */ - goto R999; -; - - case 49: /* STATE 42 */ - goto R999; - - case 50: /* STATE 47 */ - ; - now.events_lost = trpt->bup.oval; - ; - goto R999; - - case 51: /* STATE 48 */ - ; - now.refcount = trpt->bup.oval; - ; - goto R999; - - case 52: /* STATE 50 */ - ; - p_restor(II); - ; - ; - goto R999; - - /* PROC switcher */ - - case 53: /* STATE 3 */ - ; - ((P0 *)this)->new_off = trpt->bup.ovals[2]; - ((P0 *)this)->size = trpt->bup.ovals[1]; - ((P0 *)this)->prev_off = trpt->bup.ovals[0]; - ; - ungrab_ints(trpt->bup.ovals, 3); - goto R999; - - case 54: /* STATE 5 */ - ; - now.refcount = trpt->bup.ovals[2]; - /* 1 */ ((P0 *)this)->size = trpt->bup.ovals[1]; - /* 0 */ ((P0 *)this)->new_off = trpt->bup.ovals[0]; - ; - ; - ungrab_ints(trpt->bup.ovals, 3); - goto R999; -; - - case 55: /* STATE 8 */ - goto R999; - - case 56: /* STATE 12 */ - ; - /* 0 */ ((P0 *)this)->prev_off = trpt->bup.oval; - ; - ; - goto R999; -; - - case 57: /* STATE 17 */ - goto R999; - - case 58: /* STATE 15 */ - ; - now.write_off = trpt->bup.oval; - ; - goto R999; - - case 59: /* STATE 20 */ - ; - now.commit_count[ Index(((((P0 *)this)->prev_off%4)/(4/2)), 2) ] = trpt->bup.ovals[1]; - ((P0 *)this)->tmp_commit = trpt->bup.ovals[0]; - ; - ungrab_ints(trpt->bup.ovals, 2); - goto R999; - - case 60: /* STATE 27 */ - ; - now.refcount = trpt->bup.ovals[3]; - deliver = trpt->bup.ovals[2]; - /* 1 */ ((P0 *)this)->tmp_commit = trpt->bup.ovals[1]; - /* 0 */ ((P0 *)this)->prev_off = trpt->bup.ovals[0]; - ; - ; - ungrab_ints(trpt->bup.ovals, 4); - goto R999; - - case 61: /* STATE 27 */ - ; - now.refcount = trpt->bup.oval; - ; - goto R999; - - case 62: /* STATE 27 */ - ; - now.refcount = trpt->bup.oval; - ; - goto R999; - - case 63: /* STATE 30 */ - ; - p_restor(II); - ; - ; - goto R999; - } - diff --git a/trunk/verif/examples/pan.c b/trunk/verif/examples/pan.c deleted file mode 100644 index 2c12633e..00000000 --- a/trunk/verif/examples/pan.c +++ /dev/null @@ -1,11503 +0,0 @@ -/*** Generated by Spin Version 5.1.6 -- 9 May 2008 ***/ -/*** From source: buffer.spin ***/ - -#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 -#define Offsetof(X, Y) ((unsigned long)(&(((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" -#ifdef LOOPSTATE -double cnt_loops; -#endif -State A_Root; /* seed-state for cycles */ -State now; /* the full state-vector */ -#undef C_States -#if defined(C_States) && defined(HAS_TRACK) -void -c_update(uchar *p_t_r) -{ -#ifdef VERBOSE - printf("c_update %u\n", p_t_r); -#endif -} -void -c_revert(uchar *p_t_r) -{ -#ifdef VERBOSE - printf("c_revert %u\n", p_t_r); -#endif -} -#endif -void -globinit(void) -{ -} -void -locinit4(int h) -{ -} -void -locinit3(int h) -{ -} -void -locinit2(int h) -{ -} -void -locinit1(int h) -{ -} -void -locinit0(int h) -{ -} -#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() gstore((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 -#ifndef NO_V_PROVISO -#define V_PROVISO -#endif -#if !defined(NO_RESIZE) && !defined(AUTO_RESIZE) && !defined(BITSTATE) && !defined(SPACE) && NCORE==1 - #define AUTO_RESIZE -#endif - -struct H_el { - struct 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)) - unsigned long st_id; -#endif -#if !defined(SAFETY) || defined(REACH) - unsigned int D; -#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 - unsigned short ln; - #else - unsigned long ln; - #endif -#endif -#if defined(AUTO_RESIZE) && !defined(BITSTATE) - unsigned long m_K1; -#endif - unsigned long state; -} **H_tab, **S_Tab; - -typedef struct Trail { - int st; /* current state */ - uchar pr; /* process id */ - uchar tau; /* 8 bit-flags */ - uchar o_pm; /* 8 more bit-flags */ -#if 0 - Meaning of bit-flags: - 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 - int o_tt; -#ifndef BFS - short o_To; -#ifdef 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) - struct H_el *ostate; /* pointer to stored state */ -#endif -#if defined(CNTRSTACK) && !defined(BFS) - long j6, j7; -#endif - Trans *o_t; -#ifdef SCHED - /* based on Qadeer&Rehof, Tacas 2005, LNCS 3440, pp. 93-107 */ - #if NCORE>1 - #error "-DSCHED cannot be combined with -DNCORE (yet)" - #endif - int sched_limit; -#endif -#ifdef HAS_SORTED - short ipt; -#endif - union { - int oval; - int *ovals; - } bup; -} Trail; -Trail *trail, *trpt; -FILE *efd; -uchar *this; -long maxdepth=10000; -long omaxdepth=10000; -#ifdef SCHED -int sched_max = 10; -#endif -#ifdef PERMUTED - uchar permuted = 1; -#else - uchar permuted = 0; -#endif -double quota; /* time limit */ -#if NCORE>1 -long z_handoff = -1; -#endif -#ifdef SC -char *stackfile; -#endif -uchar *SS, *LL; -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 unsigned long grow; - -unsigned int HASH_CONST[] = { - /* asuming 4 bytes per int */ - 0x88888EEF, 0x00400007, - 0x04c11db7, 0x100d4e63, - 0x0fc22f87, 0x3ff0c3ff, - 0x38e84cd7, 0x02b148e9, - 0x98b2e49d, 0xb616d379, - 0xa5247fd9, 0xbae92a15, - 0xb91c8bc5, 0x8e5880f3, - 0xacd7c069, 0xb4c44bb3, - 0x2ead1fb7, 0x8e428171, - 0xdbebd459, 0x828ae611, - 0x6cb25933, 0x86cdd651, - 0x9e8f5f21, 0xd5f8d8e7, - 0x9c4e956f, 0xb5cf2c71, - 0x2e805a6d, 0x33fc3a55, - 0xaf203ed1, 0xe31f5909, - 0x5276db35, 0x0c565ef7, - 0x273d1aa5, 0x8923b1dd, - 0 -}; -#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; -#if defined(ZAPH) && defined(BITSTATE) -double zstates = 0; -#endif -int c_init_run; -#ifdef BFS -double midrv=0, failedrv=0, revrv=0; -#endif -unsigned long 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, onlyproc = -1, silent = 0; -#endif -int state_tables=0, fairness=0, no_rck=0, Nr_Trails=0; -char simvals[128]; -#ifndef INLINE -int TstOnly=0; -#endif -unsigned long mask, nmask; -#ifdef BITSTATE -int ssize=23; /* 1 Mb */ -#else -int ssize=19; /* 512K slots */ -#endif -int hmax=0, svmax=0, smax=0; -int Maxbody=0, XX; -uchar *noptr; /* used by macro Pptr(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(unsigned long); -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 - -State comp_msk; -uchar *Mask = (uchar *) &comp_msk; -#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 unsigned long j1; -static unsigned long K1, K2; -static unsigned long j2, j3, j4; -#ifdef BITSTATE -static long udmem; -#endif -static long A_depth = 0; -long depth = 0; -#if NCORE>1 -long nr_handoffs = 0; -#endif -static uchar warned = 0, iterative = 0, exclusive = 0, like_java = 0, every_error = 0; -static uchar noasserts = 0, noends = 0, bounded = 0; -#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 (*bstore)(char *, int); -int bstore_reg(char *, int); -int bstore_mod(char *, int); -#endif -void active_procs(void); -void cleanup(void); -void do_the_search(void); -void find_shorter(int); -void iniglobals(void); -void stopped(int); -void wrapup(void); -int *grab_ints(int); -void ungrab_ints(int *, int); -#ifndef NOBOUNDCHECK -#define Index(x, y) Boundcheck(x, y, II, tt, t) -#else -#define Index(x, y) x -#endif -short Air[] = { (short) Air0, (short) Air1, (short) Air2, (short) Air3, (short) Air4, (short) Air5 }; -int -addproc(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"); - switch (n) { - case 0: j = sizeof(P0); break; - case 1: j = sizeof(P1); break; - case 2: j = sizeof(P2); break; - case 3: j = sizeof(P3); break; - case 4: j = sizeof(P4); break; - case 5: j = sizeof(P5); break; - default: Uerror("bad proc - addproc"); - } - if (vsize%WS) - proc_skip[h] = WS-(vsize%WS); - else - proc_skip[h] = 0; -#ifndef NOCOMP - 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; -#ifdef SVDUMP - 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)); -#else - write(svfd, (uchar *) &proc_offset[h], sizeof(short)); -#endif - write(svfd, (uchar *) &now, vprefix-4*sizeof(int)); /* padd */ - } -#endif - now._nr_pr += 1; - 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); - } - vsize += j; -#ifndef NOVSZ - now._vsz = vsize; -#endif -#ifndef NOCOMP - for (k = 1; k <= Air[n]; k++) - Mask[vsize - k] = 1; /* pad */ - Mask[vsize-j] = 1; /* _pid */ -#endif - hmax = max(hmax, vsize); - if (vsize >= VECTORSZ) - { printf("pan: error, VECTORSZ too small, recompile pan.c"); - printf(" with -DVECTORSZ=N with N>%d\n", (int) vsize); - Uerror("aborting"); - } - 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 5: /* np_ */ - ((P5 *)pptr(h))->_t = 5; - ((P5 *)pptr(h))->_p = 0; - reached5[0] = 1; - accpstate[5][1] = 1; - break; - case 4: /* :init: */ - ((P4 *)pptr(h))->_t = 4; - ((P4 *)pptr(h))->_p = 41; reached4[41]=1; - /* params: */ - /* locals: */ - ((P4 *)pptr(h))->i = 0; - ((P4 *)pptr(h))->j = 0; - ((P4 *)pptr(h))->sum = 0; - ((P4 *)pptr(h))->commit_sum = 0; -#ifdef VAR_RANGES - logval(":init::i", ((P4 *)pptr(h))->i); - logval(":init::j", ((P4 *)pptr(h))->j); - logval(":init::sum", ((P4 *)pptr(h))->sum); - logval(":init::commit_sum", ((P4 *)pptr(h))->commit_sum); -#endif -#ifdef HAS_CODE - locinit4(h); -#endif - break; - case 3: /* cleaner */ - ((P3 *)pptr(h))->_t = 3; - ((P3 *)pptr(h))->_p = 8; reached3[8]=1; - /* params: */ - /* locals: */ -#ifdef VAR_RANGES -#endif -#ifdef HAS_CODE - locinit3(h); -#endif - break; - case 2: /* reader */ - ((P2 *)pptr(h))->_t = 2; - ((P2 *)pptr(h))->_p = 26; reached2[26]=1; - /* params: */ - /* locals: */ - ((P2 *)pptr(h))->i = 0; - ((P2 *)pptr(h))->j = 0; -#ifdef VAR_RANGES - logval("reader:i", ((P2 *)pptr(h))->i); - logval("reader:j", ((P2 *)pptr(h))->j); -#endif -#ifdef HAS_CODE - locinit2(h); -#endif - break; - case 1: /* tracer */ - ((P1 *)pptr(h))->_t = 1; - ((P1 *)pptr(h))->_p = 3; reached1[3]=1; - /* params: */ - /* locals: */ - ((P1 *)pptr(h))->size = 1; - ((P1 *)pptr(h))->prev_off = 0; - ((P1 *)pptr(h))->new_off = 0; - ((P1 *)pptr(h))->tmp_commit = 0; - ((P1 *)pptr(h))->i = 0; - ((P1 *)pptr(h))->j = 0; -#ifdef VAR_RANGES - logval("tracer:size", ((P1 *)pptr(h))->size); - logval("tracer:prev_off", ((P1 *)pptr(h))->prev_off); - logval("tracer:new_off", ((P1 *)pptr(h))->new_off); - logval("tracer:tmp_commit", ((P1 *)pptr(h))->tmp_commit); - logval("tracer:i", ((P1 *)pptr(h))->i); - logval("tracer:j", ((P1 *)pptr(h))->j); -#endif -#ifdef HAS_CODE - locinit1(h); -#endif - break; - case 0: /* switcher */ - ((P0 *)pptr(h))->_t = 0; - ((P0 *)pptr(h))->_p = 11; reached0[11]=1; - /* params: */ - /* locals: */ - ((P0 *)pptr(h))->prev_off = 0; - ((P0 *)pptr(h))->new_off = 0; - ((P0 *)pptr(h))->tmp_commit = 0; - ((P0 *)pptr(h))->size = 0; -#ifdef VAR_RANGES - logval("switcher:prev_off", ((P0 *)pptr(h))->prev_off); - logval("switcher:new_off", ((P0 *)pptr(h))->new_off); - logval("switcher:tmp_commit", ((P0 *)pptr(h))->tmp_commit); - logval("switcher:size", ((P0 *)pptr(h))->size); -#endif -#ifdef HAS_CODE - locinit0(h); -#endif - break; - } - this = o_this; - 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; unsigned long 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; - case 2: j = sizeof(P2); break; - case 3: j = sizeof(P3); break; - case 4: j = sizeof(P4); break; - case 5: j = sizeof(P5); break; - default: Uerror("bad proctype - collapse"); - } - if (z) x = z; else x = scratch; - y = (char *) ptr; k = proc_offset[i]; - for ( ; j > 0; j--, y++) - if (!Mask[k++]) *x++ = *y; - 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 = (unsigned long) (sizeof(State) - VECTORSZ); -#ifndef NOVSZ - now._vsz = vsize; -#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))); - Maxbody = max(Maxbody, ((int) sizeof(P2))); - Maxbody = max(Maxbody, ((int) sizeof(P3))); - Maxbody = max(Maxbody, ((int) sizeof(P4))); - Maxbody = max(Maxbody, ((int) sizeof(P5))); - reached[0] = reached0; - reached[1] = reached1; - reached[2] = reached2; - reached[3] = reached3; - reached[4] = reached4; - reached[5] = reached5; - accpstate[0] = (uchar *) emalloc(nstates0); - accpstate[1] = (uchar *) emalloc(nstates1); - accpstate[2] = (uchar *) emalloc(nstates2); - accpstate[3] = (uchar *) emalloc(nstates3); - accpstate[4] = (uchar *) emalloc(nstates4); - accpstate[5] = (uchar *) emalloc(nstates5); - progstate[0] = (uchar *) emalloc(nstates0); - progstate[1] = (uchar *) emalloc(nstates1); - progstate[2] = (uchar *) emalloc(nstates2); - progstate[3] = (uchar *) emalloc(nstates3); - progstate[4] = (uchar *) emalloc(nstates4); - progstate[5] = (uchar *) emalloc(nstates5); - loopstate0 = loopstate[0] = (uchar *) emalloc(nstates0); - loopstate1 = loopstate[1] = (uchar *) emalloc(nstates1); - loopstate2 = loopstate[2] = (uchar *) emalloc(nstates2); - loopstate3 = loopstate[3] = (uchar *) emalloc(nstates3); - loopstate4 = loopstate[4] = (uchar *) emalloc(nstates4); - loopstate5 = loopstate[5] = (uchar *) emalloc(nstates5); - stopstate[0] = (uchar *) emalloc(nstates0); - stopstate[1] = (uchar *) emalloc(nstates1); - stopstate[2] = (uchar *) emalloc(nstates2); - stopstate[3] = (uchar *) emalloc(nstates3); - stopstate[4] = (uchar *) emalloc(nstates4); - stopstate[5] = (uchar *) emalloc(nstates5); - visstate[0] = (uchar *) emalloc(nstates0); - visstate[1] = (uchar *) emalloc(nstates1); - visstate[2] = (uchar *) emalloc(nstates2); - visstate[3] = (uchar *) emalloc(nstates3); - visstate[4] = (uchar *) emalloc(nstates4); - visstate[5] = (uchar *) emalloc(nstates5); - mapstate[0] = (short *) emalloc(nstates0 * sizeof(short)); - mapstate[1] = (short *) emalloc(nstates1 * sizeof(short)); - mapstate[2] = (short *) emalloc(nstates2 * sizeof(short)); - mapstate[3] = (short *) emalloc(nstates3 * sizeof(short)); - mapstate[4] = (short *) emalloc(nstates4 * sizeof(short)); - mapstate[5] = (short *) emalloc(nstates5 * sizeof(short)); -#ifdef HAS_CODE -#ifdef HAS_CODE -#ifdef HAS_CODE -#ifdef HAS_CODE -#ifdef HAS_CODE -#ifdef HAS_CODE - NrStates[0] = nstates0; - NrStates[1] = nstates1; - NrStates[2] = nstates2; - NrStates[3] = nstates3; - NrStates[4] = nstates4; - NrStates[5] = nstates5; -#endif -#endif -#endif -#endif -#endif -#endif - stopstate[0][endstate0] = 1; - stopstate[1][endstate1] = 1; - stopstate[2][endstate2] = 1; - stopstate[3][endstate3] = 1; - stopstate[4][endstate4] = 1; - stopstate[5][endstate5] = 1; - stopstate[1][48] = 1; - retrans(0, nstates0, start0, src_ln0, reached0, loopstate0); - retrans(1, nstates1, start1, src_ln1, reached1, loopstate1); - retrans(2, nstates2, start2, src_ln2, reached2, loopstate2); - retrans(3, nstates3, start3, src_ln3, reached3, loopstate3); - retrans(4, nstates4, start4, src_ln4, reached4, loopstate4); - if (state_tables) - { 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); - } - iniglobals(); -#if defined(VERI) && !defined(NOREDUCE) && !defined(NP) - 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 - if (udmem) - { udmem *= 1024L*1024L; - #if NCORE>1 - if (!readtrail) - { void init_SS(unsigned long); - init_SS((unsigned long) udmem); - } else - #endif - SS = (uchar *) emalloc(udmem); - bstore = bstore_mod; - } else - #if NCORE>1 - { void init_SS(unsigned long); - init_SS(ONE_L<<(ssize-3)); - } - #else - SS = (uchar *) emalloc(ONE_L<<(ssize-3)); - #endif -#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: */ - noptr = (uchar *) emalloc(Maxbody * sizeof(char)); -#ifdef SVDUMP - if (vprefix > 0) - write(svfd, (uchar *) &vprefix, sizeof(int)); -#endif -#ifdef VERI - Addproc(VERI); /* never - pid = 0 */ -#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"); - 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(struct 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_PROVIDED -int provided(int, uchar, int, Trans *); -#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 & (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 & (CS_N-1))) -#define QLOCK(n) (3+n) -#endif - -void e_critical(int); -void x_critical(int); - -#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 -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(int 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 !defined(SAFETY) && !defined(BITSTATE) -#if !defined(FULLSTACK) || defined(MA) -#define depth_of(x) A_depth /* an estimate */ -#else -int -depth_of(struct H_el *s) -{ Trail *t; int d; - for (d = 0; d <= A_depth; d++) - { t = getframe(d); - if (s == t->ostate) - return d; - } - printf("pan: cannot happen, depth_of\n"); - return depthfound; -} -#endif -#endif -#if NCORE>1 -extern void cleanup_shm(int); -volatile unsigned int *search_terminated; /* to signal early termination */ -#endif -void -pan_exit(int val) -{ void stop_timer(void); - 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 - if (val == 2) - { val = 0; - } else - { stop_timer(); - } - exit(val); -} -#ifdef HAS_CODE -char * -transmognify(char *s) -{ char *v, *w; - static char buf[2][2048]; - int i, toggle = 0; - if (!s || strlen(s) > 2047) return s; - memset(buf[0], 0, 2048); - memset(buf[1], 0, 2048); - strcpy(buf[toggle], s); - while ((v = strstr(buf[toggle], "{c_code"))) - { *v = '\0'; v++; - strcpy(buf[1-toggle], buf[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(buf[1-toggle]) - + strlen(code_lookup[i].t) - + strlen(w) > 2047) - return s; - strcat(buf[1-toggle], code_lookup[i].t); - break; - } - strcat(buf[1-toggle], w); - toggle = 1 - toggle; - } - buf[toggle][2047] = '\0'; - return buf[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"); - } -} -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(" line %3d", - 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(" line %3d", - 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); - -void -getrail(void) -{ FILE *fd; - char *q; - int i, t_id, lastnever=-1; short II; - Trans *t; - P0 *z; - - fd = findtrail(); /* exits if unsuccessful */ - while (fscanf(fd, "%ld:%d:%d\n", &depth, &i, &t_id) == 3) - { if (depth == -1) - printf("<<<<>>>>\n"); - if (depth < 0) - continue; - 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'; - this = pptr(II); - trpt->tau |= 1; - if (!do_transit(t, II)) - { if (onlyproc >= 0 && II != onlyproc) - goto moveon; - 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, procname[z->_t]); - for (i = 0; src_all[i].src; i++) - if (src_all[i].tp == (int) z->_t) - { printf(" line %3d \"%s\" ", - src_all[i].src[z->_p], PanSource); - 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 (strcmp(procname[z->_t], ":never:") == 0) - { 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 (strcmp(procname[z->_t], ":np_:") != 0) - { -sameas: if (no_rck) goto moveon; - if (coltrace) - { printf("%ld: ", depth); - for (i = 0; i < II; i++) - printf("\t\t"); - printf("%s(%d):", procname[z->_t], II); - printf("[%s]\n", q?q:""); - } else if (!silent) - { if (strlen(simvals) > 0) { - printf("%3ld: proc %2d (%s)", - depth, II, procname[z->_t]); - for (i = 0; src_all[i].src; i++) - if (src_all[i].tp == (int) z->_t) - { printf(" line %3d \"%s\" ", - src_all[i].src[z->_p], PanSource); - break; - } - printf("(state %d) [values: %s]\n", z->_p, simvals); - } - printf("%3ld: proc %2d (%s)", - depth, II, procname[z->_t]); - for (i = 0; src_all[i].src; i++) - if (src_all[i].tp == (int) z->_t) - { printf(" line %3d \"%s\" ", - src_all[i].src[z->_p], PanSource); - 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; -} -#ifdef VERI -void check_claim(int); -#endif - -#if !defined(HASH64) && !defined(HASH32) - #define HASH32 -#endif -#if defined(HASH32) && defined(SAFETY) && !defined(SFH) && !defined(SPACE) - #define SFH -#endif -#if defined(SFH) && (defined(BITSTATE) || defined(COLLAPSE) || defined(HC) || defined(HASH64)) - #undef SFH -#endif -#if defined(SFH) && !defined(NOCOMP) - #define NOCOMP /* go for speed */ -#endif -#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 */ -{ unsigned long x, y; - unsigned int i = 1; - - d_hash((uchar *) v, n); /* sets j3, j4, K1, K2 */ - x = K1; y = j3; - for (;;) - { if (!(SS[x%udmem]&(1< RANDSTOR) return 0; -#endif - for (;;) - { SS[x%udmem] |= (1< RANDSTOR) return 0; -#endif - for (;;) - { SS[x] |= (1< 0) - { sprintf(fnm, "%s%d.%s", - MyFile, Nr_Trails-1, tprefix); - } else - { -#ifdef PUTPID - sprintf(fnm, "%s%d.%s", MyFile, 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 -#ifdef BFS -#define Q_PROVISO -#ifndef INLINE_REV -#define INLINE_REV -#endif - -typedef struct SV_Hold { - State *sv; - int sz; - struct SV_Hold *nxt; -} SV_Hold; - -typedef struct EV_Hold { - char *sv; - int sz; - int nrpr; - int nrqs; - char *po; - char *qo; - char *ps, *qs; - struct EV_Hold *nxt; -} EV_Hold; - -typedef struct BFS_Trail { - Trail *frame; - SV_Hold *onow; - EV_Hold *omask; -#ifdef Q_PROVISO - struct H_el *lstate; -#endif - short boq; - struct BFS_Trail *nxt; -} BFS_Trail; - -BFS_Trail *bfs_trail, *bfs_bot, *bfs_free; - -SV_Hold *svhold, *svfree; - -#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) -#else - #define RFLAGS (O_RDONLY) - #define WFLAGS (O_CREAT|O_WRONLY|O_TRUNC) -#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); - -SV_Hold * -getsv(int n) -{ SV_Hold *h = (SV_Hold *) 0, *oh; - - oh = (SV_Hold *) 0; - for (h = svfree; h; oh = h, h = h->nxt) - { if (n == h->sz) - { if (!oh) - svfree = h->nxt; - else - oh->nxt = h->nxt; - h->nxt = (SV_Hold *) 0; - break; - } - if (n < h->sz) - { h = (SV_Hold *) 0; - break; - } - /* else continue */ - } - - if (!h) - { 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 - && (memcmp((char *) Mask, (char *) h->sv, n) == 0) - && (now._nr_pr == h->nrpr) - && (now._nr_qs == h->nrqs) -#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)) - 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)); - memcpy((char *) h->sv, (char *) Mask, n); - - 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 - } - - 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 (h->sz >= p->sz) - break; - - if (!oh) - { p->nxt = svfree; - svfree = p; - } else - { p->nxt = h; - oh->nxt = p; - } -} - -BFS_Trail * -get_bfs_frame(void) -{ BFS_Trail *t; - - if (bfs_free) - { t = bfs_free; - bfs_free = bfs_free->nxt; - t->nxt = (BFS_Trail *) 0; - } else - { t = (BFS_Trail *) emalloc(sizeof(BFS_Trail)); - } - t->frame = (Trail *) emalloc(sizeof(Trail)); - return t; -} - -void -push_bfs(Trail *f, int d) -{ BFS_Trail *t; - - t = get_bfs_frame(); - memcpy((char *)t->frame, (char *)f, sizeof(Trail)); - t->frame->o_tt = d; /* depth */ - - t->boq = boq; - t->onow = getsv(vsize); - t->omask = getsv_mask(vsize); -#if defined(FULLSTACK) && defined(Q_PROVISO) - t->lstate = Lstate; -#endif - if (!bfs_bot) - { bfs_bot = bfs_trail = t; - } else - { bfs_bot->nxt = t; - bfs_bot = t; - } -#ifdef CHECK - printf("PUSH %u (%d)\n", t->frame, d); -#endif -} - -Trail * -pop_bfs(void) -{ BFS_Trail *t; - - if (!bfs_trail) - return (Trail *) 0; - - t = bfs_trail; - bfs_trail = t->nxt; - if (!bfs_trail) - bfs_bot = (BFS_Trail *) 0; -#if defined(Q_PROVISO) && !defined(BITSTATE) && !defined(NOREDUCE) - if (t->lstate) t->lstate->tagged = 0; -#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); - memcpy((uchar *) Mask, (uchar *) t->omask->sv, vsize); - 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)); - } -#ifdef BFS_DISK - if (t->onow->sv != (State *) 0) -#endif - freesv(t->onow); /* omask not freed */ -#ifdef CHECK - printf("POP %u (%d)\n", t->frame, t->frame->o_tt); -#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 = (((uchar *)&now)+proc_offset[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 - check_claim(t2->st); -#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 mode"); -store_it: - -#endif - -#ifdef BITSTATE - if (!bstore((char *)&now, vsize)) -#else -#ifdef MA - if (!gstore((char *)&now, vsize, 0)) -#else - if (!hstore((char *)&now, vsize)) -#endif -#endif - { static long sdone = (long) 0; long ndone; - nstates++; -#ifndef NOREDUCE - trpt->tau |= 64; -#endif - ndone = (unsigned long) (nstates/((double) 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(NOREDUCE) && defined(FULLSTACK) && defined(Q_PROVISO) -#if !defined(BITSTATE) - if (Lstate && Lstate->tagged) trpt->tau |= 64; -#else - if (trpt->tau&32) - { BFS_Trail *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 -} - -Trail *ntrpt; - -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 = (struct 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("%3d: 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 = (((uchar *)&now)+proc_offset[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_PROVIDED - if (!provided(II, ot, tt, t)) continue; -#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("%3d: 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: the use of 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 = (struct 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 - #if NCORE>1 - enter_critical(GLOBAL_LOCK); /* in verbose mode only */ - printf("cpu%d: ", core_id); - #endif - printf("%3d: 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, A_depth); - printf("tau=%d,%d]\n", - trpt->tau, (trpt-1)->tau); - #if NCORE>1 - leave_critical(GLOBAL_LOCK); - #endif -#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("%3d: 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("%3d: 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 = (((uchar *)&now)+proc_offset[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("%3d: 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("%d: timeout\n", depth); -#endif - goto MainLoop; - } -#ifndef VERI - if (!noends && !a_cycles && !endstate()) - uerror("invalid end state"); -#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 -nuerror(char *str) -{ int fd = make_trail(); - int j; - - if (fd < 0) return; -#ifdef VERI - sprintf(snap, "-2:%d:-2\n", VERI); - write(fd, snap, strlen(snap)); -#endif -#ifdef MERGED - sprintf(snap, "-4:-4:-4\n"); - write(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); - if (write(fd, snap, j) != j) - { printf("pan: error writing %s\n", fnm); - pan_exit(1); - } } - close(fd); - if (errors >= upto && upto != 0) - { wrapup(); - } -} -#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]; - volatile char m_Mask [(VMAX + 7)/8]; - 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 *); -#if 0 -void enter_critical(int); -void leave_critical(int); -#endif - -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, (int) (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", 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, *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 */ - { -#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", - worker_pids[i], (dwExitCode == STILL_ACTIVE)); -#else - sprintf(b, "kill -%d %d", SIGKILL, worker_pids[i]); - 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) - { sprintf(b, "kill -%d %d", SIGINT, worker_pids[0]); - 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>%d)\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; - -struct 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 %d)\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; - 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., 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", - 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 = (struct 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 = (struct 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 -} - - /* 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; - } - #else - #error missing definition of test and set operation for this platform - #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 %d 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 BFS is not supported with multi-core -#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 - -struct 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 (struct 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 (struct H_el *) rval; -#else - return (struct 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 struct 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); - 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(" line %3d \"%s\" ", - src_all[j].src[z->_p], PanSource); - 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", 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); - 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); - 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 = (struct 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 = (struct 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 BFS is not supported in multi-core mode -#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 - -void -start_timer(void) -{ -#if defined(WIN32) || defined(WIN64) - start_time = clock(); -#else - start_time = times(&start_tm); -#endif -} - -void -stop_timer(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 (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 - 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)); - } } -#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 - -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; - } -#else - if (!(trpt->o_pm&4) - && 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 -#ifndef NOCOMP - 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("%3d: 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 - start_timer(); -#ifdef BFS - bfs(); -#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 -#ifdef RANDOMIZE - #if RANDOMIZE>0 - srand(RANDOMIZE); - #else - srand(123); - #endif -#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 REVERSE_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 (ot == 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 (ot == 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; -#ifdef VERI - /* if (pid > 0) */ pid++; -#endif - 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 -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= %6.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) -{ -#if NCORE>1 - enter_critical(GLOBAL_LOCK); /* 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= %7d ", nr_states); -#endif - printf("Memory= %9.3f\t", memcnt/1048576.); - snap_time(); - fflush(stdout); -#if NCORE>1 - leave_critical(GLOBAL_LOCK); -#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 || !proc_offset[x]) - return noptr; - else - return (uchar *) pptr(x); -} -int qs_empty(void); -/* - * 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, first 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, rather than this one - */ -#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 - -void -new_state(void) -{ Trans *t; - uchar _n, _m, ot; -#ifdef RANDOMIZE - short ooi, eoi; -#endif -#ifdef M_LOSS - uchar delta_m = 0; -#endif - short II, JJ = 0, kk; - int tt; -#ifdef REVERSE - short From = BASE, To = now._nr_pr-1; -#else - short From = now._nr_pr-1, To = BASE; -#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 SCHED - if (depth > 0) - { trpt->sched_limit = (trpt-1)->sched_limit; - } else - { trpt->sched_limit = 0; - } -#endif -#ifdef SC - if (depth > hiwater) - { stack2disk(); - maxdepth += DDD; - hiwater += DDD; - trpt -= DDD; - if(verbose) - printf("zap %d: %d (maxdepth now %d)\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 - /* this check should now be redundant - * because the seed state also appears - * on the 1st dfs stack and would be - * matched in hstore below - */ - if ((now._a_t&1) && depth > A_depth) - { if (!memcmp((char *)&A_Root, - (char *)&now, vsize)) - { - 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 - printf("not seed\n"); -#endif - } -#endif - if (!(trpt->tau&8)) /* if no atomic move */ - { -#ifdef BITSTATE -#ifdef CNTRSTACK - II = bstore((char *)&now, vsize); - trpt->j6 = j1; trpt->j7 = j2; - JJ = LL[j1] && LL[j2]; -#else -#ifdef FULLSTACK - JJ = onstack_now(); -#else -#ifndef NOREDUCE - JJ = II; /* worstcase guess for p.o. */ -#endif -#endif - II = bstore((char *)&now, vsize); -#endif -#else -#ifdef MA - II = gstore((char *)&now, vsize, 0); -#ifndef FULLSTACK - JJ = II; -#else - JJ = (II == 2)?1:0; -#endif -#else - II = hstore((char *)&now, vsize); -#ifdef FULLSTACK - JJ = (II == 2)?1:0; -#endif -#endif -#endif - kk = (II == 1 || II == 2); -#ifndef SAFETY -#if NCORE==1 || defined (SEP_STATE) - if (II == 2 && ((trpt->o_pm&2) || ((trpt-1)->o_pm&2))) - #ifndef NOFAIR -#if 0 - if (!fairness || ((now._a_t&1) && now._cnt[1] == 1)) /* 5.1.4 */ -#else - if (a_cycles && !fairness) /* 5.1.6 -- example by Hirofumi Watanabe */ -#endif - #endif - { - 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; - 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 = oj1; - } -#endif - if (II == 3 && a_cycles && (now._a_t&1)) - { -#ifndef NOFAIR - if (fairness && now._cnt[1] > 1) /* was != 0 */ - { -#ifdef VERBOSE - 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 (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 = (unsigned long) (nstates/((double) 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) - if (write(svfd, (uchar *) &now, vprefix) != vprefix) - { fprintf(efd, "writing %s.svd failed\n", PanSource); - wrapup(); - } -#endif -#if defined(MA) && defined(W_XPT) - if ((unsigned long) 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"); - check_claim(((P0 *)pptr(0))->_p); -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", - depth, now._a_t); -#endif - } -#endif - II = 0; /* never */ - goto Veri0; - } -#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 - && (!(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 - -#ifdef REVERSE - for (II = From; II <= To; II++) -#else - for (II = From; II >= To; II--) -#endif - { -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; /* the process preselected */ -#ifdef NIBIS - t->om = 0; -#endif - trpt->tau |= 32; /* preselect marker */ -#ifdef DEBUG -#ifdef NIBIS - printf("%3d: proc %d Pre", depth, II); - printf("Selected (om=%d, tau=%d)\n", - t->om, trpt->tau); -#else - printf("%3d: proc %d PreSelected (tau=%d)\n", - depth, II, trpt->tau); -#endif -#endif - goto Again; - } - } - trpt->tau &= ~32; -#endif -#if !defined(NOREDUCE) || (defined(ETIM) && !defined(VERI)) -Again: -#endif - /* The Main Expansion Loop over Processes */ - trpt->o_pm &= ~(8|16|32|64); /* 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("%3d: 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("%3d: fairness Rule 3: _a_t = %d\n", - depth, now._a_t); -#endif - } } } -#endif - -#ifdef REVERSE - for (II = From; II <= To; II++) -#else - for (II = From; II >= To; II--) -#endif - { -#if SYNC - /* no rendezvous with same proc */ - if (boq != -1 && trpt->pr == II) continue; -#endif -#ifdef SCHED - /* limit max nr of interleavings */ - if (From != To - && depth > 0 - #ifdef VERI - && II != 0 - #endif - && (trpt-1)->pr != II - && trpt->sched_limit >= sched_max) - { continue; - } -#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; - continue; /* 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("%3d: 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_PROVIDED - if (!provided(II, ot, tt, t)) continue; -#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 RANDOMIZE - for (ooi = eoi = 0, t = trans[ot][tt]; t; t = t->nxt, ooi++) - { if (strcmp(t->tp, "else") == 0) - { eoi++; - break; - } } - if (eoi > 0) - { t = trans[ot][tt]; - #ifdef VERBOSE - printf("randomizer: suppressed, saw else\n"); - #endif - } else - { 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 - (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 SCHED - if (depth > 0 - #ifdef VERI - && II != 0 - #endif - && (trpt-1)->pr != II) - { trpt->sched_limit = 1 + (trpt-1)->sched_limit; - } -#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("%3d: proc %d exec %d \n", depth, II, t->t_id); -#else - cpu_printf("%3d: 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 RANDOMIZE - 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 RANDOMIZE - 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 -#ifdef REVERSE - { From = BASE; To = now._nr_pr-1; -#else - { From = now._nr_pr-1; To = BASE; -#endif - } -#if NCORE>1 && defined(FULL_TRAIL) - if (upto > 0) - { Push_Stack_Tree(II, t->t_id); - } -#endif - goto Down; /* pseudo-recursion */ -Up: -#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 %d: %d\n", CNT2, hiwater); - } -#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("%3d: reversed fairness default move\n", depth); -#endif - goto Q999; - } -#endif -#ifdef HAS_LAST -#ifdef VERI - { int 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 -#ifndef SAFETY - if ((now._a_t&1) && depth <= A_depth) - return; /* to checkcycles() */ -#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 RANDOMIZE - ooi = trpt->oo_i; -#endif -#ifdef INLINE_REV - _m = do_reverse(t, II, _m); -#else -#include REVERSE_MOVES -R999: /* jumps here when done */ -#endif -#ifdef VERBOSE - cpu_printf("%3d: proc %d reverses %d, %d to %d\n", - depth, II, t->forw, tt, t->st); - cpu_printf("\t%s [abit=%d,adepth=%d,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 - 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) - { -#if defined(VERI) && !defined(NP) - if (II == 0 && verbose && !reached[ot][t->st]) - { - printf("depth %d: Claim reached state %d (line %d)\n", - depth, t->st, src_claim [t->st]); - fflush(stdout); - } -#endif - 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 RANDOMIZE - 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("%3d: 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; -#ifdef REVERSE - II = From-1; -#else - II = From+1; -#endif - } } } -#endif -#ifdef VERI - if (II == 0) break; /* never claim */ -#endif - } /* all processes */ -#ifdef NSUCC - tally_succ(trpt->n_succ); -#endif -#ifdef SCHED - if (_n == 0 /* no process could move */ - #ifdef VERI - && II != 0 - #endif - && depth > 0 - && trpt->sched_limit >= sched_max) - { _n = 1; /* not a deadlock */ - } -#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("%3d: 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 OTIM - && ((trpt->tau&1) || endstate()) -#else -#ifdef ETIM - && (trpt->tau&1) /* already tried timeout */ -#endif -#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 -#ifdef REVERSE - From = BASE; To = now._nr_pr-1; -#else - From = now._nr_pr-1; To = BASE; -#endif -#if defined(VERBOSE) || defined(CHECK) - printf("%3d: 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("%3d: 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("%3d: 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 -#ifdef REVERSE - { From = BASE; To = now._nr_pr-1; -#else - { From = now._nr_pr-1; To = BASE; -#endif -#ifdef DEBUG - printf("%3d: proc %d UnSelected (_n=%d, tau=%d)\n", - depth, II+1, _n, trpt->tau); -#endif - _n = 0; trpt->tau &= ~(16|32|64); -#ifdef REVERSE - if (II <= To) /* II already decremented */ -#else - if (II >= BASE) /* II already decremented */ -#endif - goto Resume; - else - goto Again; - } -#else - /* at least one move that was preselected at this */ - /* level, blocked or truncated at the next level */ -/* implied: #ifdef FULLSTACK */ - if ((trpt->tau&32) && (_n == 0 || (trpt->tau&16))) - { -#ifdef DEBUG - printf("%3d: 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("%3d: 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 -#ifdef REVERSE - From = BASE; To = now._nr_pr-1; -#else - From = now._nr_pr-1; To = BASE; -#endif - _n = 0; trpt->tau &= ~(16|32|64); - goto Again; /* do full search */ - } /* else accept reduction */ - } else -#ifdef REVERSE - { From = BASE; To = now._nr_pr-1; -#else - { From = now._nr_pr-1; To = BASE; -#endif - _n = 0; trpt->tau &= ~(16|32|64); -#ifdef REVERSE - if (II <= To) /* already decremented */ -#else - if (II >= BASE) /* already decremented */ -#endif - goto Resume; - else - goto Again; - } } -/* #endif */ -#endif -#endif - if (_n == 0 || ((trpt->tau&4) && (trpt->tau&2))) - { -#ifdef DEBUG - cpu_printf("%3d: 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())) -#ifdef OTIM - || endstate() -#endif - || depth >= maxdepth-1) goto Done; - if ((trpt->tau&8) && !(trpt->tau&4)) - { trpt->tau &= ~(1|8); - /* 1=timeout, 8=atomic */ -#ifdef REVERSE - From = BASE; To = now._nr_pr-1; -#else - From = now._nr_pr-1; To = BASE; -#endif -#ifdef DEBUG - cpu_printf("%3d: 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 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 -#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("%d: 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("%d: zapping\n", depth); -#endif - onstack_zap(); -#ifndef NOREDUCE - if (trpt->proviso) - gstore((char *) &now, vsize, 1); -#endif - } -#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 -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) -{ - assert((x >= 0 && x < y), "- invalid array index", - a1, a2, a3); - return x; -} -#endif -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 -#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 - printf("hash conflicts: %9.8g (resolved)\n", hcmp); - #ifndef AUTO_RESIZE - if (hcmp > (double) (1< 100.)\n\n", - (double)(((double) udmem) * 8.0) / (double) nstates); - else - printf("\nhash factor: %4g (best if > 100.)\n\n", - (double)(1<<(ssize-8)) / (double) nstates * 256.0); - printf("bits set per state: %u (-k%u)\n", hfns, hfns); - #if 0 - if (udmem) - { printf("total bits available: %8g (-M%ld)\n", - ((double) udmem) * 8.0, udmem/(1024L*1024L)); - } else - printf("total bits available: %8g (-w%d)\n", - ((double) (ONE_L << (ssize-4)) * 16.0), ssize); - #endif -#endif -#ifdef BFS_DISK - 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) -{ -#if defined(BITSTATE) || !defined(NOCOMP) - double nr1, nr2, nr3 = 0.0, nr4, nr5 = 0.0; - #if !defined(MA) && (defined(MEMCNT) || defined(MEMLIM)) - int mverbose = 1; - #else - int mverbose = verbose; - #endif -#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"); -#ifdef SC - (void) unlink((const char *)stackfile); -#endif -#if NCORE>1 - if (a_cycles) - { printf(" + Multi-Core (NCORE=%d)\n", NCORE); - } else - { printf(" + Multi-Core (NCORE=%d -z%d)\n", NCORE, z_handoff); - } -#endif -#ifdef BFS - printf(" + Using Breadth-First Search\n"); -#endif -#ifndef NOREDUCE - printf(" + Partial Order Reduction\n"); -#endif -#ifdef REVERSE - printf(" + Reverse Depth-First Search Order\n"); -#endif -#ifdef T_REVERSE - printf(" + Reverse Transition Ordering\n"); -#endif -#ifdef RANDOMIZE - printf(" + Randomized Transition Ordering\n"); -#endif -#ifdef SCHED - printf(" + Scheduling Restriction (-DSCHED=%d)\n", sched_max); -#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 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 +\n"); - 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 - printf(" cycle checks - (disabled by -DSAFETY)\n"); -#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 %d, fh %d, zh %d, zn %d - ", - Fa, Fh, Zh, Zn); - printf("check %d holds %d\n", Ccheck, Cholds); - printf("stack stats: puts %d, probes %d, zaps %d\n", - PUT, PROBE, ZAPS); -#else - printf("\n"); -#endif - -#if defined(BITSTATE) || !defined(NOCOMP) - nr1 = (nstates-nShadow)* - (double)(hmax+sizeof(struct 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 - printf("%9.3f actual memory usage for states", - tmp_nr/1048576.); - remainder -= tmp_nr; - printf(" ("); - if (tmp_nr > 0.) - { if (tmp_nr > nr1) printf("unsuccessful "); - printf("compression: %.2f%%)\n", - (100.0*tmp_nr)/nr1); - } else - printf("less than 1k)\n"); -#ifndef MA - if (tmp_nr > 0.) - { printf(" state-vector as stored = %.0f byte", - (tmp_nr)/(nstates-nShadow) - - (double) (sizeof(struct H_el) - sizeof(unsigned))); - printf(" + %ld byte overhead\n", - (long int) sizeof(struct H_el)-sizeof(unsigned)); - } -#endif -#if !defined(MA) || defined(COLLAPSE) - printf("%9.3f memory used for hash table (-w%d)\n", - nr3/1048576., ssize); - remainder -= nr3; -#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.); - printf("%9.3f total actual memory usage\n\n", - memcnt/1048576.); - } -#ifndef MA - else -#endif -#endif -#ifndef MA - printf("%9.3f memory usage (Mbyte)\n\n", - memcnt/1048576.); -#endif -#ifdef COLLAPSE - printf("nr of templates: [ globals chans procs ]\n"); - printf("collapse counts: [ "); - { int i; for (i = 0; i < 256+2; i++) - if (ncomps[i] != 0) - printf("%d ", ncomps[i]); - printf("]\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 - pan_exit(0); -} - -void -stopped(int arg) -{ printf("Interrupted\n"); -#if NCORE>1 - was_interrupted = 1; -#endif - wrapup(); - pan_exit(0); -} - -#ifdef SFH -/* - * super fast hash, based on Paul Hsieh's function - * http://www.azillionmonkeys.com/qed/hash.html - */ -#include - #undef get16bits - #if (defined(__GNUC__) && defined(__i386__)) || defined(__WATCOMC__) \ - || defined(_MSC_VER) || defined (__BORLANDC__) || defined (__TURBOC__) - #define get16bits(d) (*((const uint16_t *) (d))) - #endif - - #ifndef get16bits - #define get16bits(d) ((((uint32_t)(((const uint8_t *)(d))[1])) << 8)\ - +(uint32_t)(((const uint8_t *)(d))[0]) ) - #endif - -void -d_sfh(const char *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; -} -#endif - -#include -#if defined(HASH64) || defined(WIN64) -/* 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 defined(HASH64) || defined(WIN64) - uint64_t a = 0, b, c, n; - uint64_t *k = (uint64_t *) kb; -#else - uint32_t a, b, c, n; - uint32_t *k = (uint32_t *) kb; -#endif - /* extend to multiple of words, if needed */ - n = nbytes/WS; /* nr of words */ - a = nbytes - (n*WS); - if (a > 0) - { n++; - bp = kb + nbytes; - switch (a) { - case 3: *bp++ = 0; /* fall thru */ - case 2: *bp++ = 0; /* fall thru */ - case 1: *bp = 0; - case 0: break; - } } -#if defined(HASH64) || defined(WIN64) - 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]; - case 0: break; - } - final(a,b,c); -#endif - j1 = c&nmask; j3 = a&7; /* 1st bit */ - j2 = b&nmask; j4 = (a>>3)&7; /* 2nd bit */ - K1 = c; K2 = b; -} - -void -s_hash(uchar *cp, int om) -{ -#if defined(SFH) - d_sfh((const char *) cp, om); /* sets K1 */ -#else - d_hash(cp, om); /* sets K1 etc */ -#endif -#ifdef BITSTATE - if (S_Tab == H_tab) - j1 = K1 % omaxdepth; - else -#endif - if (ssize < 8*WS) - j1 = K1&mask; - else - j1 = K1; -} -#ifndef RANDSTOR -int *prerand; -void -inirand(void) -{ int i; - srand(123); /* fixed startpoint */ - 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) /* 4.2.5 */ -{ - 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); - } -} - -static long reclaim_size; -static char *reclaim_mem; -#if defined(AUTO_RESIZE) && !defined(BITSTATE) && !defined(MA) -#if NCORE>1 - #error cannot combine AUTO_RESIZE with NCORE>1 yet -#endif -static struct H_el **N_tab; -void -reverse_capture(struct H_el *p) -{ if (!p) return; - reverse_capture(p->nxt); - /* last element of list moves first */ - /* to preserve list-order */ - j2 = p->m_K1; - if (ssize < 8*WS) /* probably always true */ - { j2 &= mask; - } - p->nxt = N_tab[j2]; - N_tab[j2] = p; -} -void -resize_hashtable(void) -{ - if (WS == 4 && ssize >= 27 - 1) - { return; /* canot increase further */ - } - - ssize += 2; /* 4x size */ - - printf("pan: resizing hashtable to -w%d.. ", ssize); - - N_tab = (struct H_el **) - emalloc((ONE_L<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, "error: -a disabled"); - usage(efd); break; -#else - case 'a': a_cycles = 1; break; -#endif -#endif - case 'A': noasserts = 1; break; - case 'b': bounded = 1; break; -#ifdef HAS_CODE - case 'C': coltrace = 1; goto samething; -#endif - case 'c': upto = atoi(&argv[1][2]); break; - case 'd': state_tables++; break; - case 'e': every_error = 1; 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 - case 'g': gui = 1; goto samething; -#endif - case 'h': if (!argv[1][2]) usage(efd); else - HASH_NR = atoi(&argv[1][2])%33; break; - case 'I': iterative = 2; every_error = 1; break; - case 'i': 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 SCHED - case 'L': sched_max = atoi(&argv[1][2]); break; -#endif -#ifndef SAFETY -#ifdef NP - case 'l': a_cycles = 1; break; -#else - case 'l': fprintf(efd, "error: -l disabled"); - 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; - case 'n': no_rck = 1; break; - case 'P': readtrail = 1; onlyproc = atoi(&argv[1][2]); - if (argv[2][0] != '-') /* check next arg */ - { trailfilename = argv[2]; - argc--; argv++; /* skip next arg */ - } - break; -#ifdef SVDUMP - case 'p': vprefix = atoi(&argv[1][2]); break; -#endif -#if NCORE==1 - case 'Q': quota = (double) 60.0 * (double) atoi(&argv[1][2]); break; -#endif - case 'q': strict = 1; break; - case 'R': Nrun = atoi(&argv[1][2]); break; -#ifdef HAS_CODE - case 'r': -samething: readtrail = 1; - if (isdigit(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; -#endif -#ifdef BITSTATE - case 's': hfns = 1; break; -#endif - case 'T': TMODE = 0444; break; - case 't': if (argv[1][2]) tprefix = &argv[1][2]; 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]); 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 that 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 (iterative && TMODE != 0666) - { TMODE = 0666; - fprintf(efd, "warning: -T ignored when -i or -I is used\n"); - } -#if defined(HASH32) && !defined(SFH) - if (WS > 4) - { fprintf(efd, "strong warning: compiling -DHASH32 on a 64-bit machine\n"); - fprintf(efd, " without -DSFH can slow down performance a lot\n"); - } -#endif -#if defined(WIN32) || defined(WIN64) - 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 -#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 unsigned long - */ - } -#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 REACH - #warning -DREACH is redundant when -DBFS is used - #endif -#endif -#if defined(MERGED) && defined(PEG) - #error to use -DPEG use: spin -o3 -a -#endif -#ifdef HC - #ifdef SFH - #error cannot combine -DHC and -DSFH - /* use of NOCOMP is the real reason */ - #else - #ifdef NOCOMP - #error cannot combine -DHC and -DNOCOMP - #endif - #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 SFH - #error cannot combine -DCOLLAPSE and -DSFH - /* use of NOCOMP is the real reason */ - #else - #ifdef NOCOMP - #error cannot combine -DCOLLAPSE and -DNOCOMP - #endif - #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 -#ifndef BITSTATE - if (Nrun > 1) HASH_NR = Nrun - 1; -#endif - if (Nrun < 1 || Nrun > 32) - { fprintf(efd, "error: invalid arg for -R\n"); - usage(efd); - } -#ifndef SAFETY - if (fairness && !a_cycles) - { fprintf(efd, "error: -f requires -a or -l\n"); - usage(efd); - } - #if ACCEPT_LAB==0 - if (a_cycles) - { fprintf(efd, "error: no accept labels defined "); - fprintf(efd, "in model (for option -a)\n"); - usage(efd); - } - #endif -#endif -#ifndef NOREDUCE - #ifdef 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 - #ifdef HAS_LAST - #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) - #warning use of rendezvous with BFS does not preserve all invalid endstates -#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 (!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 (!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"); - } - #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(); -#ifdef BFS - 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 -#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(123); -#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 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:1..32\n"); - 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 SCHED - fprintf(fd, " -LN set scheduling restriction to N (default 10)\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"); - fprintf(fd, " -n no listing of unreached states\n"); -#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, " -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, " -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 -#ifdef BITSTATE - fprintf(fd, " -RN repeat run Nx with N "); - fprintf(fd, "[1..32] independent hash functions\n"); - fprintf(fd, " -s same as -k1 (single bit per state)\n"); -#endif - fprintf(fd, " -T create trail files in read-only mode\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(unsigned long n) -{ char *tmp; -#ifdef MEMLIM - if (memcnt+ (double) n > memlim) goto err; -#endif -#if 1 - tmp = (char *) malloc(n); - if (!tmp) -#else - tmp = (char *) sbrk(n); - if (tmp == (char *) -ONE_L) -#endif - { -#ifdef MEMLIM -err: -#endif - printf("pan: out of memory\n"); -#ifdef MEMLIM - 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(unsigned long 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 ((unsigned long) 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 -Uerror(char *str) -{ /* always fatal */ - uerror(str); -#if NCORE>1 - sudden_stop("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("%d State: ", depth); - for (i = 0; i < vsize; i++) printf("%d%s,", - ((char *)&now)[i], Mask[i]?"*":""); - 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 - { int 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("%3d: 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, 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 -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: %s (at depth %ld)\n", str, -#else - printf("pan: %s (at depth %ld)\n", 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(str); - 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) - { 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) - { -#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 */ - - printf("\tline %d", lno); - if (verbose) - for (j = 0; j < sizeof(mp); j++) - if (i >= mp[j].from && i <= mp[j].upto) - { printf(", \"%s\"", mp[j].fnm); - break; - } - 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; - -#ifdef VERI - if (M == VERI && !verbose) return; -#endif - printf("unreached in proctype %s\n", procname[M]); - 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) - { 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", VERI); - write(fd, snap, strlen(snap)); -#endif -#ifdef MERGED - sprintf(snap, "-4:-4:-4\n"); - write(fd, snap, strlen(snap)); -#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) - write(fd, "-1:-1:-1\n", 9); - 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) - { 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 - 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 -#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: v_restor"); - svtack = svtack->lst; -#ifdef DEBUG - cpu_printf(" sv_restor\n"); -#endif -} - -void -p_restor(int h) -{ int i; char *z = (char *) &now; - - proc_offset[h] = stack->o_offset; - proc_skip[h] = (uchar) stack->o_skip; -#ifndef XUSAFE - p_name[h] = stack->o_name; -#endif -#ifndef NOCOMP - 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; -#ifndef NOVSZ - now._vsz = vsize; -#endif -#ifndef NOCOMP - 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; - i = stack->o_delqs; - now._nr_pr += 1; - if (!stack->lst) /* debugging */ - Uerror("error: p_restor"); - stack = stack->lst; - this = pptr(h); - while (i-- > 0) - q_restor(); -} - -void -q_restor(void) -{ char *z = (char *) &now; -#ifndef NOCOMP - int k, k_end; -#endif - q_offset[now._nr_qs] = stack->o_offset; - q_skip[now._nr_qs] = (uchar) stack->o_skip; -#ifndef XUSAFE - q_name[now._nr_qs] = stack->o_name; -#endif - vsize += stack->o_skip; - memcpy(z+vsize, stack->body, stack->o_delta); - vsize += stack->o_delta; -#ifndef NOVSZ - now._vsz = vsize; -#endif - now._nr_qs += 1; -#ifndef NOCOMP - 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 - if (!stack->lst) /* debugging */ - 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; - - 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 = now._nr_pr - 1; - memset((char *)pptr(h), 0, d); - vsize -= (int) proc_skip[h]; -#ifndef NOVSZ - now._vsz = vsize; -#endif -#ifndef NOCOMP - for (i = vsize; i < o_vsize; i++) - Mask[i] = 0; /* reset */ -#endif - return 1; -} - -void -delq(int sav) -{ int h = now._nr_qs - 1; - int d = vsize - q_offset[now._nr_qs - 1]; -#ifndef NOCOMP - int k, o_vsize = vsize; -#endif - 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 = q_offset[h]; -#if VECTORSZ>32000 - stack->o_skip = (int) q_skip[h]; -#else - stack->o_skip = (short) q_skip[h]; -#endif -#ifndef XUSAFE - stack->o_name = q_name[h]; -#endif - stack->o_delta = d; - memcpy(stack->body, (char *)qptr(h), d); - } - vsize = q_offset[h]; - now._nr_qs = now._nr_qs - 1; - memset((char *)qptr(h), 0, d); - vsize -= (int) q_skip[h]; -#ifndef NOVSZ - now._vsz = vsize; -#endif -#ifndef NOCOMP - for (k = vsize; k < o_vsize; k++) - Mask[k] = 0; /* reset */ -#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) && !defined(OTIM) - if (!stopstate[EVENT_TRACE][now._event] && !a_cycles) - { printf("pan: event_trace not completed\n"); - return 0; - } -#endif - return 1; -} - -#ifndef SAFETY -void -checkcycles(void) -{ uchar o_a_t = now._a_t; -#ifdef SCHED - int o_limit; -#endif -#ifndef NOFAIR - uchar o_cnt = now._cnt[1]; -#endif -#ifdef FULLSTACK -#ifndef MA - struct 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("%d: cycle check starts\n", depth); -#endif - now._a_t |= (1|16|32); - /* 1 = 2nd DFS; (16|32) to help hasher */ -#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 - #ifdef SCHED - o_limit = trpt->sched_limit; - trpt->sched_limit = 0; - #endif - new_state(); /* start 2nd DFS */ - #ifdef SCHED - trpt->sched_limit = o_limit; - #endif -#endif - now._a_t = o_a_t; -#ifndef NOFAIR - now._cnt[1] = o_cnt; -#endif - A_depth = 0; depthfound = -1; -#ifdef DEBUG - printf("%d: 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) -struct H_el *Free_list = (struct H_el *) 0; -void -onstack_init(void) /* to store stack states in a bitstate search */ -{ S_Tab = (struct H_el **) emalloc(maxdepth*sizeof(struct H_el *)); -} -struct H_el * -grab_state(int n) -{ struct 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 (struct H_el *) - emalloc(sizeof(struct H_el)+n-sizeof(unsigned)); -} - -#else -#if NCORE>1 -struct H_el * -grab_state(int n) -{ struct H_el *grab_shared(int); - return grab_shared(sizeof(struct H_el)+n-sizeof(unsigned)); -} -#else - #ifndef AUTO_RESIZE - #define grab_state(n) (struct H_el *) \ - emalloc(sizeof(struct H_el)+n-sizeof(unsigned long)); - #else - struct H_el * - grab_state(int n) - { struct H_el *p; - int cnt = sizeof(struct H_el)+n-sizeof(unsigned long); - - if (reclaim_size >= cnt+WS) - { if ((cnt & (WS-1)) != 0) /* alignment */ - { cnt += WS - (cnt & (WS-1)); - } - p = (struct H_el *) reclaim_mem; - reclaim_mem += cnt; - reclaim_size -= cnt; - memset(p, 0, cnt); - } else - { p = (struct H_el *) emalloc(cnt); - } - return p; - } - #endif -#endif -#endif -#ifdef COLLAPSE -unsigned long -ordinal(char *v, long n, short tp) -{ struct H_el *tmp, *ntmp; long m; - struct H_el *olst = (struct H_el *) 0; - s_hash((uchar *)v, n); -#if NCORE>1 && !defined(SEP_STATE) - enter_critical(CS_ID); /* uses spinlock - 1..128 */ -#endif - tmp = H_tab[j1]; - if (!tmp) - { tmp = grab_state(n); - H_tab[j1] = tmp; - } else - for ( ;; olst = tmp, tmp = tmp->nxt) - { m = memcmp(((char *)&(tmp->state)), v, n); - if (n == tmp->ln) - { - if (m == 0) - goto done; - if (m < 0) - { -Insert: ntmp = grab_state(n); - ntmp->nxt = tmp; - if (!olst) - H_tab[j1] = 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; - } - m = ++ncomps[tp]; -#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); /* uses spinlock */ -#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; - unsigned long 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(unsigned long); -#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; - for (i = 0; i < (int) n; i++, w++) - if (!Mask[j++]) *x++ = *w; -#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; - } - r = (n+WS-1)/WS; /* words rounded up */ - r *= WS; /* bytes */ - i = r - i; /* remainder */ - 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) -{ struct H_el *v, *w, *last = 0; - struct H_el **tmp = H_tab; - char *nv; int n, m; - - static char warned = 0; - - 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]; 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 - #if defined(BITSTATE) && NCORE>1 - /* seen this happen, likely harmless, but not yet understood */ - if (warned == 0) - #endif - { /* Uerror("stack out of wack - zap"); */ - cpu_printf("pan: warning, stack incomplete\n"); - warned = 1; - } -#endif - return; -Found: - ZAPS++; - if (last) - last->nxt = v->nxt; - else - S_Tab[j1] = v->nxt; - v->tagged = (unsigned) n; -#if !defined(NOREDUCE) && !defined(SAFETY) - v->proviso = 0; -#endif - v->nxt = last = (struct 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; - } - return; - } - if (!w->nxt) - { w->nxt = v; - return; - } } - Free_list = v; -} -void -onstack_put(void) -{ struct H_el **tmp = H_tab; - H_tab = S_Tab; - if (hstore((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++; -} -int -onstack_now(void) -{ struct H_el *tmp; - struct H_el **tmp2 = H_tab; - char *v; int n, m = 1; - - 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]; tmp; Zn++, tmp = tmp->nxt) - { m = memcmp(((char *)&(tmp->state)),v,n); - if (m <= 0) - { Lstate = (struct H_el *) tmp; - break; - } } - PROBE++; - return (m == 0); -} -#endif -#endif -#ifndef BITSTATE -void -hinit(void) -{ - #ifdef MA -#ifdef R_XPT - { void r_xpoint(void); - r_xpoint(); - } -#else - dfa_init((unsigned short) (MA+a_cycles)); -#if NCORE>1 && !defined(COLLAPSE) - if (!readtrail) - { void init_HT(unsigned long); - init_HT(0L); - } -#endif -#endif - #endif - #if !defined(MA) || defined(COLLAPSE) -#if NCORE>1 - if (!readtrail) - { void init_HT(unsigned long); - init_HT((unsigned long) (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 = (unsigned int) 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; - } - -#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: -#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 -int -hstore(char *vin, int nin) /* hash table storage */ -{ struct H_el *ntmp; - struct H_el *tmp, *olst = (struct H_el *) 0; - char *v; int n, m=0; -#ifdef HC - uchar rem_a; -#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 -#if NCORE>1 && !defined(SEP_STATE) && !defined(BITSTATE) - enter_critical(CS_ID); /* uses spinlock */ -#endif - tmp = H_tab[j1]; - 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] = 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 -#ifndef SAFETY -#ifndef 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 */ - unsigned 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 -#endif -#if NCORE>1 - Lstate = (struct H_el *) tmp; -#endif -#ifdef FULLSTACK -#ifndef SAFETY - if (wasnew) - { Lstate = (struct H_el *) tmp; - 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 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 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 = (struct H_el *) tmp; -#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 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 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 -#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 NCORE>1 && !defined(SEP_STATE) && !defined(BITSTATE) - leave_critical(CS_ID); -#endif - return 0; - } -#endif -#if (defined(BFS) && defined(Q_PROVISO)) || NCORE>1 - Lstate = (struct H_el *) tmp; -#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] = 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(SAFETY) || defined(REACH) - tmp->D = depth; -#endif -#ifndef SAFETY -#ifndef NOCOMP - if (S_A) - { v[0] = V_A; -#ifndef NOFAIR - if (S_A > NFAIR) - { unsigned 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 -#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 = (struct H_el *) tmp; -#else - #ifdef DEBUG - dumpstate(-1, v, n, 0); - #endif - #if NCORE>1 - Lstate = (struct H_el *) tmp; - #endif -#endif -/* #if NCORE>1 && !defined(SEP_STATE) */ -#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 -#include TRANSITIONS -void -do_reach(void) -{ - r_ck(reached0, nstates0, 0, src_ln0, src_file0); - r_ck(reached1, nstates1, 1, src_ln1, src_file1); - r_ck(reached2, nstates2, 2, src_ln2, src_file2); - r_ck(reached3, nstates3, 3, src_ln3, src_file3); - r_ck(reached4, nstates4, 4, src_ln4, src_file4); -} - -void -iniglobals(void) -{ - deliver = 0; - { int l_in; - for (l_in = 0; l_in < 4; l_in++) - { - now.buffer_use[l_in] = 0; - } - } - now.write_off = 0; - { int l_in; - for (l_in = 0; l_in < 2; l_in++) - { - now.commit_count[l_in] = 0; - } - } - now.read_off = 0; - now.events_lost = 0; - now.refcount = 0; -#ifdef VAR_RANGES - { int l_in; - for (l_in = 0; l_in < 4; l_in++) - { - logval("buffer_use[l_in]", now.buffer_use[l_in]); - } - } - logval("write_off", now.write_off); - { int l_in; - for (l_in = 0; l_in < 2; l_in++) - { - logval("commit_count[l_in]", now.commit_count[l_in]); - } - } - logval("read_off", now.read_off); - logval("events_lost", now.events_lost); - logval("refcount", now.refcount); -#endif - Maxbody = max(Maxbody, sizeof(State)-VECTORSZ); -} - -int -addqueue(int n, int is_rv) -{ int j=0, i = now._nr_qs; -#ifndef NOCOMP - int k; -#endif - if (i >= MAXQ) - Uerror("too many queues"); - switch (n) { - default: Uerror("bad queue - addqueue"); - } - if (vsize%WS) - q_skip[i] = WS-(vsize%WS); - else - q_skip[i] = 0; -#ifndef NOCOMP - 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; - now._nr_qs += 1; - vsize += j; -#ifndef NOVSZ - now._vsz = vsize; -#endif - hmax = max(hmax, vsize); - if (vsize >= VECTORSZ) - Uerror("VECTORSZ is too small, edit pan.h"); - memset((char *)qptr(i), 0, j); - ((Q0 *)qptr(i))->_t = n; - return i+1; -} - -#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#"); - 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) -{ 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 (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]; - /* no need to store the empty slots at the end */ - j -= (q_max[ptr->_t] - ptr->Qlen) * ((j - 2)/q_max[ptr->_t]); - for ( ; j > 0; j--, y++) - if (!Mask[k++]) *x++ = *y; - 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)"); - 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)"); - 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[1024], carg[64]; -#ifdef BITSTATE - strcpy(ctd, "-DBITSTATE "); -#else - strcpy(ctd, ""); -#endif -#ifdef NOVSZ - strcat(ctd, "-DNOVSZ "); -#endif -#ifdef REVERSE - strcat(ctd, "-DREVERSE "); -#endif -#ifdef T_REVERSE - strcat(ctd, "-DT_REVERSE "); -#endif -#ifdef RANDOMIZE - #if RANDOMIZE>0 - sprintf(carg, "-DRANDOMIZE=%d ", RANDOMIZE); - strcat(ctd, carg); - #else - strcat(ctd, "-DRANDOMIZE "); - #endif -#endif -#ifdef SCHED - sprintf(carg, "-DSCHED=%d ", SCHED); - 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 HC0 - strcat(ctd, "-DHC0 "); -#endif -#ifdef HC1 - strcat(ctd, "-DHC1 "); -#endif -#ifdef HC2 - strcat(ctd, "-DHC2 "); -#endif -#ifdef HC3 - strcat(ctd, "-DHC3 "); -#endif -#ifdef HC4 - strcat(ctd, "-DHC4 "); -#endif -#ifdef CHECK - strcat(ctd, "-DCHECK "); -#endif -#ifdef CTL - strcat(ctd, "-DCTL "); -#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 OTIM - strcat(ctd, "-DOTIM "); -#endif -#ifdef COLLAPSE - strcat(ctd, "-DCOLLAPSE "); -#endif -#ifdef MA - sprintf(carg, "-DMA=%d ", MA); - strcat(ctd, carg); -#endif -#ifdef SVDUMP - strcat(ctd, "-DSVDUMP "); -#endif -#ifdef VECTORSZ - 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 SFH - sprintf(carg, "-DSFH "); - 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 (!permuted) { - Addproc(4); - } else { - Addproc(4); - } -} -#ifdef MA -/* -#include -#define uchar unsigned char -*/ -#define ulong unsigned long -#define ushort unsigned short - -#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: %6d 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("%d: ", 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 %d stackstates\n", stackcnt); - nstates -= (double) stackcnt; -} -#endif -#ifdef VERI -void -check_claim(int st) -{ - if (st == endclaim) - uerror("claim violated!"); - if (stopstate[VERI][st]) - uerror("end state in claim reached"); -} -#endif -void -c_globals(void) -{ /* int i; */ - printf("global vars:\n"); - printf(" byte write_off: %d\n", now.write_off); - { int l_in; - for (l_in = 0; l_in < 2; l_in++) - { - printf(" byte commit_count[%d]: %d\n", l_in, now.commit_count[l_in]); - } - } - printf(" byte read_off: %d\n", now.read_off); - printf(" byte events_lost: %d\n", now.events_lost); - printf(" byte refcount: %d\n", now.refcount); - { int l_in; - for (l_in = 0; l_in < 4; l_in++) - { - printf(" bit buffer_use[%d]: %d\n", l_in, now.buffer_use[l_in]); - } - } -} -void -c_locals(int pid, int tp) -{ /* int i; */ - switch(tp) { - case 4: - printf("local vars proc %d (:init:):\n", pid); - printf(" byte i: %d\n", ((P4 *)pptr(pid))->i); - printf(" byte j: %d\n", ((P4 *)pptr(pid))->j); - printf(" byte sum: %d\n", ((P4 *)pptr(pid))->sum); - printf(" byte commit_sum: %d\n", ((P4 *)pptr(pid))->commit_sum); - break; - case 3: - /* none */ - break; - case 2: - printf("local vars proc %d (reader):\n", pid); - printf(" byte i: %d\n", ((P2 *)pptr(pid))->i); - printf(" byte j: %d\n", ((P2 *)pptr(pid))->j); - break; - case 1: - printf("local vars proc %d (tracer):\n", pid); - printf(" byte size: %d\n", ((P1 *)pptr(pid))->size); - printf(" byte prev_off: %d\n", ((P1 *)pptr(pid))->prev_off); - printf(" byte new_off: %d\n", ((P1 *)pptr(pid))->new_off); - printf(" byte tmp_commit: %d\n", ((P1 *)pptr(pid))->tmp_commit); - printf(" byte i: %d\n", ((P1 *)pptr(pid))->i); - printf(" byte j: %d\n", ((P1 *)pptr(pid))->j); - break; - case 0: - printf("local vars proc %d (switcher):\n", pid); - printf(" byte prev_off: %d\n", ((P0 *)pptr(pid))->prev_off); - printf(" byte new_off: %d\n", ((P0 *)pptr(pid))->new_off); - printf(" byte tmp_commit: %d\n", ((P0 *)pptr(pid))->tmp_commit); - printf(" byte size: %d\n", ((P0 *)pptr(pid))->size); - break; - } -} -void -printm(int x) -{ - switch (x) { - default: Printf("%d", x); - } -} -void -c_chandump(int unused) { unused++; /* avoid complaints */ } diff --git a/trunk/verif/examples/pan.h b/trunk/verif/examples/pan.h deleted file mode 100644 index e4ec3cd1..00000000 --- a/trunk/verif/examples/pan.h +++ /dev/null @@ -1,610 +0,0 @@ -#define SpinVersion "Spin Version 5.1.6 -- 9 May 2008" -#define PanSource "buffer.spin" - -#ifdef WIN64 -#define ONE_L ((unsigned long) 1) -#define long long long -#else -#define ONE_L (1L) -#endif -char *TrailFile = PanSource; /* default */ -char *trailfilename; -#if defined(BFS) -#ifndef SAFETY -#define SAFETY -#endif -#ifndef XUSAFE -#define XUSAFE -#endif -#endif -#ifndef uchar -#define uchar unsigned char -#endif -#ifndef uint -#define uint unsigned int -#endif -#ifndef HASH32 -#define HASH64 -#endif -#define DELTA 500 -#ifdef MA - #if NCORE>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 -#define MERGED 1 -#ifdef NP /* includes np_ demon */ -#define HAS_NP 2 -#define VERI 5 -#define endclaim 3 /* none */ -#endif -typedef struct S_F_MAP { - char *fnm; int from; int upto; -} S_F_MAP; - -#define nstates4 57 /* :init: */ -#define endstate4 56 -short src_ln4 [] = { - 0, 226, 228, 229, 230, 231, 231, 227, - 233, 227, 233, 235, 236, 237, 238, 238, - 234, 240, 234, 240, 241, 242, 244, 245, - 246, 247, 248, 248, 243, 250, 243, 250, - 252, 253, 254, 255, 256, 256, 251, 258, - 251, 225, 262, 263, 264, 266, 267, 272, - 273, 273, 265, 278, 265, 278, 282, 260, - 284, 0, }; -S_F_MAP src_file4 [] = { - { "-", 0, 0 }, - { "buffer.spin", 1, 56 }, - { "-", 57, 58 } -}; -uchar reached4 [] = { - 0, 1, 1, 0, 0, 1, 1, 0, - 1, 1, 0, 1, 0, 0, 1, 1, - 0, 1, 1, 0, 0, 0, 1, 0, - 0, 0, 1, 1, 0, 1, 1, 0, - 1, 0, 0, 0, 1, 1, 0, 1, - 1, 0, 1, 0, 0, 1, 0, 0, - 1, 1, 0, 1, 1, 0, 0, 0, - 0, 0, }; -uchar *loopstate4; - -#define nstates3 10 /* cleaner */ -#define endstate3 9 -short src_ln3 [] = { - 0, 211, 212, 213, 214, 210, 216, 210, - 209, 217, 0, }; -S_F_MAP src_file3 [] = { - { "-", 0, 0 }, - { "buffer.spin", 1, 9 }, - { "-", 10, 11 } -}; -uchar reached3 [] = { - 0, 1, 0, 0, 1, 0, 1, 1, - 0, 0, 0, }; -uchar *loopstate3; - -#define nstates2 30 /* reader */ -#define endstate2 29 -short src_ln2 [] = { - 0, 177, 179, 181, 182, 183, 184, 185, - 185, 180, 187, 180, 178, 191, 193, 194, - 195, 196, 196, 192, 198, 192, 198, 190, - 200, 200, 172, 202, 172, 202, 0, }; -S_F_MAP src_file2 [] = { - { "-", 0, 0 }, - { "buffer.spin", 1, 29 }, - { "-", 30, 31 } -}; -uchar reached2 [] = { - 0, 1, 1, 1, 0, 0, 0, 1, - 1, 0, 1, 1, 0, 1, 1, 0, - 0, 1, 1, 0, 1, 1, 0, 0, - 1, 1, 0, 1, 1, 0, 0, }; -uchar *loopstate2; - -#define nstates1 51 /* tracer */ -#define endstate1 50 -short src_ln1 [] = { - 0, 106, 107, 105, 111, 112, 113, 113, - 110, 115, 109, 118, 118, 119, 119, 117, - 121, 121, 123, 124, 125, 126, 127, 127, - 122, 129, 122, 116, 134, 136, 137, 138, - 139, 139, 135, 141, 135, 141, 142, 145, - 146, 147, 148, 143, 150, 133, 152, 154, - 156, 151, 158, 0, }; -S_F_MAP src_file1 [] = { - { "-", 0, 0 }, - { "buffer.spin", 1, 50 }, - { "-", 51, 52 } -}; -uchar reached1 [] = { - 0, 1, 0, 0, 1, 1, 1, 0, - 1, 1, 0, 1, 1, 1, 0, 1, - 1, 0, 1, 0, 0, 0, 1, 1, - 0, 1, 1, 0, 1, 1, 0, 0, - 1, 1, 0, 1, 1, 0, 0, 1, - 0, 1, 0, 0, 1, 0, 1, 0, - 0, 0, 0, 0, }; -uchar *loopstate1; - -#define nstates0 31 /* switcher */ -#define endstate0 30 -short src_ln0 [] = { - 0, 60, 61, 62, 65, 66, 67, 68, - 68, 63, 70, 59, 73, 73, 74, 74, - 72, 76, 71, 79, 80, 83, 84, 85, - 86, 81, 88, 88, 78, 91, 92, 0, }; -S_F_MAP src_file0 [] = { - { "-", 0, 0 }, - { "buffer.spin", 1, 30 }, - { "-", 31, 32 } -}; -uchar reached0 [] = { - 0, 1, 0, 0, 1, 0, 1, 1, - 0, 0, 1, 0, 1, 1, 1, 0, - 1, 1, 0, 1, 0, 1, 0, 1, - 0, 0, 1, 0, 0, 1, 0, 0, }; -uchar *loopstate0; -struct { - int tp; short *src; -} src_all[] = { - { 4, &src_ln4[0] }, - { 3, &src_ln3[0] }, - { 2, &src_ln2[0] }, - { 1, &src_ln1[0] }, - { 0, &src_ln0[0] }, - { 0, (short *) 0 } -}; -short *frm_st0; -struct { - char *c; char *t; -} code_lookup[] = { - { (char *) 0, "" } -}; -#define _T5 64 -#define _T2 65 -#define T_ID unsigned char -#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 -char *procname[] = { - "switcher", - "tracer", - "reader", - "cleaner", - ":init:", - ":np_:", -}; - -#define Pinit ((P4 *)this) -typedef struct P4 { /* :init: */ - unsigned _pid : 8; /* 0..255 */ - unsigned _t : 4; /* proctype */ - unsigned _p : 7; /* state */ - uchar i; - uchar j; - uchar sum; - uchar commit_sum; -} P4; -#define Air4 (sizeof(P4) - Offsetof(P4, commit_sum) - 1*sizeof(uchar)) -#define Pcleaner ((P3 *)this) -typedef struct P3 { /* cleaner */ - unsigned _pid : 8; /* 0..255 */ - unsigned _t : 4; /* proctype */ - unsigned _p : 7; /* state */ -} P3; -#define Air3 (sizeof(P3) - 3) -#define Preader ((P2 *)this) -typedef struct P2 { /* reader */ - unsigned _pid : 8; /* 0..255 */ - unsigned _t : 4; /* proctype */ - unsigned _p : 7; /* state */ - uchar i; - uchar j; -} P2; -#define Air2 (sizeof(P2) - Offsetof(P2, j) - 1*sizeof(uchar)) -#define Ptracer ((P1 *)this) -typedef struct P1 { /* tracer */ - unsigned _pid : 8; /* 0..255 */ - unsigned _t : 4; /* proctype */ - unsigned _p : 7; /* state */ - uchar size; - uchar prev_off; - uchar new_off; - uchar tmp_commit; - uchar i; - uchar j; -} P1; -#define Air1 (sizeof(P1) - Offsetof(P1, j) - 1*sizeof(uchar)) -#define Pswitcher ((P0 *)this) -typedef struct P0 { /* switcher */ - unsigned _pid : 8; /* 0..255 */ - unsigned _t : 4; /* proctype */ - unsigned _p : 7; /* state */ - uchar prev_off; - uchar new_off; - uchar tmp_commit; - uchar size; -} P0; -#define Air0 (sizeof(P0) - Offsetof(P0, size) - 1*sizeof(uchar)) -typedef struct P5 { /* np_ */ - unsigned _pid : 8; /* 0..255 */ - unsigned _t : 4; /* proctype */ - unsigned _p : 7; /* state */ -} P5; -#define Air5 (sizeof(P5) - 3) -#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; - -#define qptr(x) (((uchar *)&now)+(int)q_offset[x]) -#define pptr(x) (((uchar *)&now)+(int)proc_offset[x]) -extern uchar *Pptr(int); -#define q_sz(x) (((Q0 *)qptr(x))->Qlen) - -#ifndef VECTORSZ -#define VECTORSZ 1024 /* sv size in bytes */ -#endif - -#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) && !defined(HASH64) -#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 -#ifdef HC0 -#define HC 0 -#endif -#ifdef HC1 -#define HC 1 -#endif -#ifdef HC2 -#define HC 2 -#endif -#ifdef HC3 -#define HC 3 -#endif -#ifdef HC4 -#define HC 4 -#endif -#ifdef COLLAPSE -#if NCORE>1 && !defined(SEP_STATE) -unsigned long *ncomps; /* in shared memory */ -#else -unsigned long ncomps[256+2]; -#endif -#endif -#define MAXQ 255 -#define MAXPROC 255 -#define WS sizeof(void *) /* word size in bytes */ -typedef struct Stack { /* for queues and processes */ -#if VECTORSZ>32000 - int o_delta; - int o_offset; - int o_skip; - int o_delqs; -#else - short o_delta; - short o_offset; - short o_skip; - short o_delqs; -#endif - short o_boq; -#ifndef XUSAFE - char *o_name; -#endif - char *body; - 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; - -Trans ***trans; /* 1 ptr per state per proctype */ - -struct H_el *Lstate; -int depthfound = -1; /* loop detection */ -#if VECTORSZ>32000 -int proc_offset[MAXPROC]; -int q_offset[MAXQ]; -#else -short proc_offset[MAXPROC]; -short q_offset[MAXQ]; -#endif -uchar proc_skip[MAXPROC]; -uchar q_skip[MAXQ]; -unsigned long 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 */ -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 - unsigned long _vsz; -#endif -#endif -#ifdef HAS_LAST - uchar _last; /* pid executed in last step */ -#endif -#ifdef EVENT_TRACE -#if nstates_event<256 - uchar _event; -#else - unsigned short _event; -#endif -#endif - uchar buffer_use[4]; - uchar write_off; - uchar commit_count[2]; - uchar read_off; - uchar events_lost; - uchar refcount; - uchar sv[VECTORSZ]; -} State; - -#define HAS_TRACK 0 -/* hidden variable: */ uchar deliver; -int _; /* a predefined write-only variable */ - -#define FORWARD_MOVES "pan.m" -#define REVERSE_MOVES "pan.b" -#define TRANSITIONS "pan.t" -#define _NP_ 5 -uchar reached5[3]; /* np_ */ -uchar *loopstate5; /* np_ */ -#define nstates5 3 /* np_ */ -#define endstate5 2 /* np_ */ - -#define start5 0 /* np_ */ -#define start4 41 -#define start3 8 -#define start2 26 -#define start1 3 -#define start0 11 -#ifdef NP - #define ACCEPT_LAB 1 /* at least 1 in np_ */ -#else - #define ACCEPT_LAB 0 /* 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 0 /* progress labels */ -uchar *accpstate[6]; -uchar *progstate[6]; -uchar *loopstate[6]; -uchar *reached[6]; -uchar *stopstate[6]; -uchar *visstate[6]; -short *mapstate[6]; -#ifdef HAS_CODE -int NrStates[6]; -#endif -#define NQS 0 -short q_flds[1]; -short q_max[1]; -typedef struct Q0 { /* generic q */ - uchar Qlen; /* q_size */ - uchar _t; -} Q0; - -/** function prototypes **/ -char *emalloc(unsigned long); -char *Malloc(unsigned long); -int Boundcheck(int, int, int, int, Trans *); -int addqueue(int, int); -/* int atoi(char *); */ -/* int abort(void); */ -int close(int); -int delproc(int, int); -int endstate(void); -int hstore(char *, int); -#ifdef MA -int gstore(char *, int, uchar); -#endif -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 Uerror(char *); -void assert(int, char *, int, int, Trans *); -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(const char *, int); -void sfh(const char *, int); -void d_hash(uchar *, int); -void s_hash(uchar *, int); -void r_hash(uchar *, int); -void delq(int); -void do_reach(void); -void pan_exit(int); -void exit(int); -void hinit(void); -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 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 uerror(char *); -void unrecv(int, int, int, int, int); -void usage(FILE *); -void wrap_stats(void); -#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 -void qsend(int, int, int); -#define Addproc(x) addproc(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 66 -#ifdef PEG -long peg[NTRANS]; -#endif diff --git a/trunk/verif/examples/pan.m b/trunk/verif/examples/pan.m deleted file mode 100644 index 357708ae..00000000 --- a/trunk/verif/examples/pan.m +++ /dev/null @@ -1,987 +0,0 @@ -#define rand pan_rand -#if defined(HAS_CODE) && defined(VERBOSE) - cpu_printf("Pr: %d Tr: %d\n", II, t->forw); -#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 :init: */ - case 3: /* STATE 1 - line 226 "buffer.spin" - [i = 0] (0:0:1 - 1) */ - IfNotBlocked - reached[4][1] = 1; - (trpt+1)->bup.oval = ((int)((P4 *)this)->i); - ((P4 *)this)->i = 0; -#ifdef VAR_RANGES - logval(":init::i", ((int)((P4 *)this)->i)); -#endif - ; - _m = 3; goto P999; /* 0 */ - case 4: /* STATE 2 - line 228 "buffer.spin" - [((i<2))] (7:0:2 - 1) */ - IfNotBlocked - reached[4][2] = 1; - if (!((((int)((P4 *)this)->i)<2))) - continue; - /* merge: commit_count[i] = 0(7, 3, 7) */ - reached[4][3] = 1; - (trpt+1)->bup.ovals = grab_ints(2); - (trpt+1)->bup.ovals[0] = ((int)now.commit_count[ Index(((int)((P4 *)this)->i), 2) ]); - now.commit_count[ Index(((P4 *)this)->i, 2) ] = 0; -#ifdef VAR_RANGES - logval("commit_count[:init::i]", ((int)now.commit_count[ Index(((int)((P4 *)this)->i), 2) ])); -#endif - ; - /* merge: i = (i+1)(7, 4, 7) */ - reached[4][4] = 1; - (trpt+1)->bup.ovals[1] = ((int)((P4 *)this)->i); - ((P4 *)this)->i = (((int)((P4 *)this)->i)+1); -#ifdef VAR_RANGES - logval(":init::i", ((int)((P4 *)this)->i)); -#endif - ; - /* merge: .(goto)(0, 8, 7) */ - reached[4][8] = 1; - ; - _m = 3; goto P999; /* 3 */ - case 5: /* STATE 5 - line 231 "buffer.spin" - [((i>=2))] (16:0:2 - 1) */ - IfNotBlocked - reached[4][5] = 1; - if (!((((int)((P4 *)this)->i)>=2))) - continue; - /* dead 1: i */ (trpt+1)->bup.ovals = grab_ints(2); - (trpt+1)->bup.ovals[0] = ((P4 *)this)->i; -#ifdef HAS_CODE - if (!readtrail) -#endif - ((P4 *)this)->i = 0; - /* merge: goto :b6(16, 6, 16) */ - reached[4][6] = 1; - ; - /* merge: i = 0(16, 10, 16) */ - reached[4][10] = 1; - (trpt+1)->bup.ovals[1] = ((int)((P4 *)this)->i); - ((P4 *)this)->i = 0; -#ifdef VAR_RANGES - logval(":init::i", ((int)((P4 *)this)->i)); -#endif - ; - /* merge: .(goto)(0, 17, 16) */ - reached[4][17] = 1; - ; - _m = 3; goto P999; /* 3 */ - case 6: /* STATE 10 - line 233 "buffer.spin" - [i = 0] (0:16:1 - 3) */ - IfNotBlocked - reached[4][10] = 1; - (trpt+1)->bup.oval = ((int)((P4 *)this)->i); - ((P4 *)this)->i = 0; -#ifdef VAR_RANGES - logval(":init::i", ((int)((P4 *)this)->i)); -#endif - ; - /* merge: .(goto)(0, 17, 16) */ - reached[4][17] = 1; - ; - _m = 3; goto P999; /* 1 */ - case 7: /* STATE 11 - line 235 "buffer.spin" - [((i<4))] (16:0:2 - 1) */ - IfNotBlocked - reached[4][11] = 1; - if (!((((int)((P4 *)this)->i)<4))) - continue; - /* merge: buffer_use[i] = 0(16, 12, 16) */ - reached[4][12] = 1; - (trpt+1)->bup.ovals = grab_ints(2); - (trpt+1)->bup.ovals[0] = ((int)now.buffer_use[ Index(((int)((P4 *)this)->i), 4) ]); - now.buffer_use[ Index(((P4 *)this)->i, 4) ] = 0; -#ifdef VAR_RANGES - logval("buffer_use[:init::i]", ((int)now.buffer_use[ Index(((int)((P4 *)this)->i), 4) ])); -#endif - ; - /* merge: i = (i+1)(16, 13, 16) */ - reached[4][13] = 1; - (trpt+1)->bup.ovals[1] = ((int)((P4 *)this)->i); - ((P4 *)this)->i = (((int)((P4 *)this)->i)+1); -#ifdef VAR_RANGES - logval(":init::i", ((int)((P4 *)this)->i)); -#endif - ; - /* merge: .(goto)(0, 17, 16) */ - reached[4][17] = 1; - ; - _m = 3; goto P999; /* 3 */ - case 8: /* STATE 14 - line 238 "buffer.spin" - [((i>=4))] (0:0:1 - 1) */ - IfNotBlocked - reached[4][14] = 1; - if (!((((int)((P4 *)this)->i)>=4))) - continue; - /* dead 1: i */ (trpt+1)->bup.oval = ((P4 *)this)->i; -#ifdef HAS_CODE - if (!readtrail) -#endif - ((P4 *)this)->i = 0; - _m = 3; goto P999; /* 0 */ - case 9: /* STATE 19 - line 240 "buffer.spin" - [(run reader())] (0:0:0 - 3) */ - IfNotBlocked - reached[4][19] = 1; - if (!(addproc(2))) - continue; - _m = 3; goto P999; /* 0 */ - case 10: /* STATE 20 - line 241 "buffer.spin" - [(run cleaner())] (28:0:1 - 1) */ - IfNotBlocked - reached[4][20] = 1; - if (!(addproc(3))) - continue; - /* merge: i = 0(0, 21, 28) */ - reached[4][21] = 1; - (trpt+1)->bup.oval = ((int)((P4 *)this)->i); - ((P4 *)this)->i = 0; -#ifdef VAR_RANGES - logval(":init::i", ((int)((P4 *)this)->i)); -#endif - ; - /* merge: .(goto)(0, 29, 28) */ - reached[4][29] = 1; - ; - _m = 3; goto P999; /* 2 */ - case 11: /* STATE 22 - line 244 "buffer.spin" - [((i<4))] (24:0:1 - 1) */ - IfNotBlocked - reached[4][22] = 1; - if (!((((int)((P4 *)this)->i)<4))) - continue; - /* merge: refcount = (refcount+1)(0, 23, 24) */ - reached[4][23] = 1; - (trpt+1)->bup.oval = ((int)now.refcount); - now.refcount = (((int)now.refcount)+1); -#ifdef VAR_RANGES - logval("refcount", ((int)now.refcount)); -#endif - ; - _m = 3; goto P999; /* 1 */ - case 12: /* STATE 24 - line 246 "buffer.spin" - [(run tracer())] (28:0:1 - 1) */ - IfNotBlocked - reached[4][24] = 1; - if (!(addproc(1))) - continue; - /* merge: i = (i+1)(0, 25, 28) */ - reached[4][25] = 1; - (trpt+1)->bup.oval = ((int)((P4 *)this)->i); - ((P4 *)this)->i = (((int)((P4 *)this)->i)+1); -#ifdef VAR_RANGES - logval(":init::i", ((int)((P4 *)this)->i)); -#endif - ; - /* merge: .(goto)(0, 29, 28) */ - reached[4][29] = 1; - ; - _m = 3; goto P999; /* 2 */ - case 13: /* STATE 26 - line 248 "buffer.spin" - [((i>=4))] (38:0:2 - 1) */ - IfNotBlocked - reached[4][26] = 1; - if (!((((int)((P4 *)this)->i)>=4))) - continue; - /* dead 1: i */ (trpt+1)->bup.ovals = grab_ints(2); - (trpt+1)->bup.ovals[0] = ((P4 *)this)->i; -#ifdef HAS_CODE - if (!readtrail) -#endif - ((P4 *)this)->i = 0; - /* merge: goto :b8(38, 27, 38) */ - reached[4][27] = 1; - ; - /* merge: i = 0(38, 31, 38) */ - reached[4][31] = 1; - (trpt+1)->bup.ovals[1] = ((int)((P4 *)this)->i); - ((P4 *)this)->i = 0; -#ifdef VAR_RANGES - logval(":init::i", ((int)((P4 *)this)->i)); -#endif - ; - /* merge: .(goto)(0, 39, 38) */ - reached[4][39] = 1; - ; - _m = 3; goto P999; /* 3 */ - case 14: /* STATE 31 - line 250 "buffer.spin" - [i = 0] (0:38:1 - 3) */ - IfNotBlocked - reached[4][31] = 1; - (trpt+1)->bup.oval = ((int)((P4 *)this)->i); - ((P4 *)this)->i = 0; -#ifdef VAR_RANGES - logval(":init::i", ((int)((P4 *)this)->i)); -#endif - ; - /* merge: .(goto)(0, 39, 38) */ - reached[4][39] = 1; - ; - _m = 3; goto P999; /* 1 */ - case 15: /* STATE 32 - line 252 "buffer.spin" - [((i<1))] (34:0:1 - 1) */ - IfNotBlocked - reached[4][32] = 1; - if (!((((int)((P4 *)this)->i)<1))) - continue; - /* merge: refcount = (refcount+1)(0, 33, 34) */ - reached[4][33] = 1; - (trpt+1)->bup.oval = ((int)now.refcount); - now.refcount = (((int)now.refcount)+1); -#ifdef VAR_RANGES - logval("refcount", ((int)now.refcount)); -#endif - ; - _m = 3; goto P999; /* 1 */ - case 16: /* STATE 34 - line 254 "buffer.spin" - [(run switcher())] (38:0:1 - 1) */ - IfNotBlocked - reached[4][34] = 1; - if (!(addproc(0))) - continue; - /* merge: i = (i+1)(0, 35, 38) */ - reached[4][35] = 1; - (trpt+1)->bup.oval = ((int)((P4 *)this)->i); - ((P4 *)this)->i = (((int)((P4 *)this)->i)+1); -#ifdef VAR_RANGES - logval(":init::i", ((int)((P4 *)this)->i)); -#endif - ; - /* merge: .(goto)(0, 39, 38) */ - reached[4][39] = 1; - ; - _m = 3; goto P999; /* 2 */ - case 17: /* STATE 36 - line 256 "buffer.spin" - [((i>=1))] (40:0:1 - 1) */ - IfNotBlocked - reached[4][36] = 1; - if (!((((int)((P4 *)this)->i)>=1))) - continue; - /* dead 1: i */ (trpt+1)->bup.oval = ((P4 *)this)->i; -#ifdef HAS_CODE - if (!readtrail) -#endif - ((P4 *)this)->i = 0; - /* merge: goto :b9(0, 37, 40) */ - reached[4][37] = 1; - ; - _m = 3; goto P999; /* 1 */ - case 18: /* STATE 42 - line 262 "buffer.spin" - [assert((((write_off-read_off)>=0)&&((write_off-read_off)<(255/2))))] (0:50:2 - 1) */ - IfNotBlocked - reached[4][42] = 1; - assert((((((int)now.write_off)-((int)now.read_off))>=0)&&((((int)now.write_off)-((int)now.read_off))<(255/2))), "(((write_off-read_off)>=0)&&((write_off-read_off)<(255/2)))", II, tt, t); - /* merge: j = 0(50, 43, 50) */ - reached[4][43] = 1; - (trpt+1)->bup.ovals = grab_ints(2); - (trpt+1)->bup.ovals[0] = ((int)((P4 *)this)->j); - ((P4 *)this)->j = 0; -#ifdef VAR_RANGES - logval(":init::j", ((int)((P4 *)this)->j)); -#endif - ; - /* merge: commit_sum = 0(50, 44, 50) */ - reached[4][44] = 1; - (trpt+1)->bup.ovals[1] = ((int)((P4 *)this)->commit_sum); - ((P4 *)this)->commit_sum = 0; -#ifdef VAR_RANGES - logval(":init::commit_sum", ((int)((P4 *)this)->commit_sum)); -#endif - ; - /* merge: .(goto)(0, 51, 50) */ - reached[4][51] = 1; - ; - _m = 3; goto P999; /* 3 */ - case 19: /* STATE 45 - line 266 "buffer.spin" - [((j<2))] (50:0:2 - 1) */ - IfNotBlocked - reached[4][45] = 1; - if (!((((int)((P4 *)this)->j)<2))) - continue; - /* merge: commit_sum = (commit_sum+commit_count[j])(50, 46, 50) */ - reached[4][46] = 1; - (trpt+1)->bup.ovals = grab_ints(2); - (trpt+1)->bup.ovals[0] = ((int)((P4 *)this)->commit_sum); - ((P4 *)this)->commit_sum = (((int)((P4 *)this)->commit_sum)+((int)now.commit_count[ Index(((int)((P4 *)this)->j), 2) ])); -#ifdef VAR_RANGES - logval(":init::commit_sum", ((int)((P4 *)this)->commit_sum)); -#endif - ; - /* merge: j = (j+1)(50, 47, 50) */ - reached[4][47] = 1; - (trpt+1)->bup.ovals[1] = ((int)((P4 *)this)->j); - ((P4 *)this)->j = (((int)((P4 *)this)->j)+1); -#ifdef VAR_RANGES - logval(":init::j", ((int)((P4 *)this)->j)); -#endif - ; - /* merge: .(goto)(0, 51, 50) */ - reached[4][51] = 1; - ; - _m = 3; goto P999; /* 3 */ - case 20: /* STATE 48 - line 273 "buffer.spin" - [((j>=2))] (56:0:1 - 1) */ - IfNotBlocked - reached[4][48] = 1; - if (!((((int)((P4 *)this)->j)>=2))) - continue; - /* dead 1: j */ (trpt+1)->bup.oval = ((P4 *)this)->j; -#ifdef HAS_CODE - if (!readtrail) -#endif - ((P4 *)this)->j = 0; - /* merge: goto :b10(56, 49, 56) */ - reached[4][49] = 1; - ; - /* merge: assert((((write_off-commit_sum)>=0)&&((write_off-commit_sum)<(255/2))))(56, 53, 56) */ - reached[4][53] = 1; - assert((((((int)now.write_off)-((int)((P4 *)this)->commit_sum))>=0)&&((((int)now.write_off)-((int)((P4 *)this)->commit_sum))<(255/2))), "(((write_off-commit_sum)>=0)&&((write_off-commit_sum)<(255/2)))", II, tt, t); - /* merge: assert((((4+1)>4)||(events_lost==0)))(56, 54, 56) */ - reached[4][54] = 1; - assert((((4+1)>4)||(((int)now.events_lost)==0)), "(((4+1)>4)||(events_lost==0))", II, tt, t); - _m = 3; goto P999; /* 3 */ - case 21: /* STATE 53 - line 278 "buffer.spin" - [assert((((write_off-commit_sum)>=0)&&((write_off-commit_sum)<(255/2))))] (0:56:0 - 3) */ - IfNotBlocked - reached[4][53] = 1; - assert((((((int)now.write_off)-((int)((P4 *)this)->commit_sum))>=0)&&((((int)now.write_off)-((int)((P4 *)this)->commit_sum))<(255/2))), "(((write_off-commit_sum)>=0)&&((write_off-commit_sum)<(255/2)))", II, tt, t); - /* merge: assert((((4+1)>4)||(events_lost==0)))(56, 54, 56) */ - reached[4][54] = 1; - assert((((4+1)>4)||(((int)now.events_lost)==0)), "(((4+1)>4)||(events_lost==0))", II, tt, t); - _m = 3; goto P999; /* 1 */ - case 22: /* STATE 56 - line 284 "buffer.spin" - [-end-] (0:0:0 - 1) */ - IfNotBlocked - reached[4][56] = 1; - if (!delproc(1, II)) continue; - _m = 3; goto P999; /* 0 */ - - /* PROC cleaner */ - case 23: /* STATE 1 - line 211 "buffer.spin" - [((refcount==0))] (3:0:1 - 1) */ - IfNotBlocked - reached[3][1] = 1; - if (!((((int)now.refcount)==0))) - continue; - /* merge: refcount = (refcount+1)(0, 2, 3) */ - reached[3][2] = 1; - (trpt+1)->bup.oval = ((int)now.refcount); - now.refcount = (((int)now.refcount)+1); -#ifdef VAR_RANGES - logval("refcount", ((int)now.refcount)); -#endif - ; - _m = 3; goto P999; /* 1 */ - case 24: /* STATE 3 - line 213 "buffer.spin" - [(run switcher())] (7:0:0 - 1) */ - IfNotBlocked - reached[3][3] = 1; - if (!(addproc(0))) - continue; - /* merge: goto :b5(0, 4, 7) */ - reached[3][4] = 1; - ; - _m = 3; goto P999; /* 1 */ - case 25: /* STATE 9 - line 217 "buffer.spin" - [-end-] (0:0:0 - 1) */ - IfNotBlocked - reached[3][9] = 1; - if (!delproc(1, II)) continue; - _m = 3; goto P999; /* 0 */ - - /* PROC reader */ - case 26: /* STATE 1 - line 177 "buffer.spin" - [((((((write_off/(4/2))-(read_off/(4/2)))>0)&&(((write_off/(4/2))-(read_off/(4/2)))<(255/2)))&&(((commit_count[((read_off%4)/(4/2))]-(4/2))-(((read_off/4)*4)/2))==0)))] (0:0:0 - 1) */ - IfNotBlocked - reached[2][1] = 1; - if (!((((((((int)now.write_off)/(4/2))-(((int)now.read_off)/(4/2)))>0)&&(((((int)now.write_off)/(4/2))-(((int)now.read_off)/(4/2)))<(255/2)))&&(((((int)now.commit_count[ Index(((((int)now.read_off)%4)/(4/2)), 2) ])-(4/2))-(((((int)now.read_off)/4)*4)/2))==0)))) - continue; - _m = 3; goto P999; /* 0 */ - case 27: /* STATE 2 - line 179 "buffer.spin" - [i = 0] (0:0:1 - 1) */ - IfNotBlocked - reached[2][2] = 1; - (trpt+1)->bup.oval = ((int)((P2 *)this)->i); - ((P2 *)this)->i = 0; -#ifdef VAR_RANGES - logval("reader:i", ((int)((P2 *)this)->i)); -#endif - ; - _m = 3; goto P999; /* 0 */ - case 28: /* STATE 3 - line 181 "buffer.spin" - [((i<(4/2)))] (9:0:2 - 1) */ - IfNotBlocked - reached[2][3] = 1; - if (!((((int)((P2 *)this)->i)<(4/2)))) - continue; - /* merge: assert((buffer_use[((read_off+i)%4)]==0))(9, 4, 9) */ - reached[2][4] = 1; - assert((((int)now.buffer_use[ Index(((((int)now.read_off)+((int)((P2 *)this)->i))%4), 4) ])==0), "(buffer_use[((read_off+i)%4)]==0)", II, tt, t); - /* merge: buffer_use[((read_off+i)%4)] = 1(9, 5, 9) */ - reached[2][5] = 1; - (trpt+1)->bup.ovals = grab_ints(2); - (trpt+1)->bup.ovals[0] = ((int)now.buffer_use[ Index(((((int)now.read_off)+((int)((P2 *)this)->i))%4), 4) ]); - now.buffer_use[ Index(((now.read_off+((P2 *)this)->i)%4), 4) ] = 1; -#ifdef VAR_RANGES - logval("buffer_use[((read_off+reader:i)%4)]", ((int)now.buffer_use[ Index(((((int)now.read_off)+((int)((P2 *)this)->i))%4), 4) ])); -#endif - ; - /* merge: i = (i+1)(9, 6, 9) */ - reached[2][6] = 1; - (trpt+1)->bup.ovals[1] = ((int)((P2 *)this)->i); - ((P2 *)this)->i = (((int)((P2 *)this)->i)+1); -#ifdef VAR_RANGES - logval("reader:i", ((int)((P2 *)this)->i)); -#endif - ; - /* merge: .(goto)(0, 10, 9) */ - reached[2][10] = 1; - ; - _m = 3; goto P999; /* 4 */ - case 29: /* STATE 7 - line 185 "buffer.spin" - [((i>=(4/2)))] (11:0:1 - 1) */ - IfNotBlocked - reached[2][7] = 1; - if (!((((int)((P2 *)this)->i)>=(4/2)))) - continue; - /* dead 1: i */ (trpt+1)->bup.oval = ((P2 *)this)->i; -#ifdef HAS_CODE - if (!readtrail) -#endif - ((P2 *)this)->i = 0; - /* merge: goto :b3(0, 8, 11) */ - reached[2][8] = 1; - ; - _m = 3; goto P999; /* 1 */ -/* STATE 13 - line 191 "buffer.spin" - [i = 0] (0:0 - 1) same as 27 (0:0 - 1) */ - case 30: /* STATE 14 - line 193 "buffer.spin" - [((i<(4/2)))] (19:0:2 - 1) */ - IfNotBlocked - reached[2][14] = 1; - if (!((((int)((P2 *)this)->i)<(4/2)))) - continue; - /* merge: buffer_use[((read_off+i)%4)] = 0(19, 15, 19) */ - reached[2][15] = 1; - (trpt+1)->bup.ovals = grab_ints(2); - (trpt+1)->bup.ovals[0] = ((int)now.buffer_use[ Index(((((int)now.read_off)+((int)((P2 *)this)->i))%4), 4) ]); - now.buffer_use[ Index(((now.read_off+((P2 *)this)->i)%4), 4) ] = 0; -#ifdef VAR_RANGES - logval("buffer_use[((read_off+reader:i)%4)]", ((int)now.buffer_use[ Index(((((int)now.read_off)+((int)((P2 *)this)->i))%4), 4) ])); -#endif - ; - /* merge: i = (i+1)(19, 16, 19) */ - reached[2][16] = 1; - (trpt+1)->bup.ovals[1] = ((int)((P2 *)this)->i); - ((P2 *)this)->i = (((int)((P2 *)this)->i)+1); -#ifdef VAR_RANGES - logval("reader:i", ((int)((P2 *)this)->i)); -#endif - ; - /* merge: .(goto)(0, 20, 19) */ - reached[2][20] = 1; - ; - _m = 3; goto P999; /* 3 */ - case 31: /* STATE 17 - line 196 "buffer.spin" - [((i>=(4/2)))] (0:0:1 - 1) */ - IfNotBlocked - reached[2][17] = 1; - if (!((((int)((P2 *)this)->i)>=(4/2)))) - continue; - /* dead 1: i */ (trpt+1)->bup.oval = ((P2 *)this)->i; -#ifdef HAS_CODE - if (!readtrail) -#endif - ((P2 *)this)->i = 0; - _m = 3; goto P999; /* 0 */ - case 32: /* STATE 22 - line 198 "buffer.spin" - [read_off = (read_off+(4/2))] (0:0:1 - 1) */ - IfNotBlocked - reached[2][22] = 1; - (trpt+1)->bup.oval = ((int)now.read_off); - now.read_off = (((int)now.read_off)+(4/2)); -#ifdef VAR_RANGES - logval("read_off", ((int)now.read_off)); -#endif - ; - _m = 3; goto P999; /* 0 */ - case 33: /* STATE 24 - line 200 "buffer.spin" - [((read_off>=(4-events_lost)))] (0:0:0 - 1) */ - IfNotBlocked - reached[2][24] = 1; - if (!((((int)now.read_off)>=(4-((int)now.events_lost))))) - continue; - _m = 3; goto P999; /* 0 */ - case 34: /* STATE 29 - line 202 "buffer.spin" - [-end-] (0:0:0 - 3) */ - IfNotBlocked - reached[2][29] = 1; - if (!delproc(1, II)) continue; - _m = 3; goto P999; /* 0 */ - - /* PROC tracer */ - case 35: /* STATE 1 - line 106 "buffer.spin" - [prev_off = write_off] (0:10:2 - 1) */ - IfNotBlocked - reached[1][1] = 1; - (trpt+1)->bup.ovals = grab_ints(2); - (trpt+1)->bup.ovals[0] = ((int)((P1 *)this)->prev_off); - ((P1 *)this)->prev_off = ((int)now.write_off); -#ifdef VAR_RANGES - logval("tracer:prev_off", ((int)((P1 *)this)->prev_off)); -#endif - ; - /* merge: new_off = (prev_off+size)(10, 2, 10) */ - reached[1][2] = 1; - (trpt+1)->bup.ovals[1] = ((int)((P1 *)this)->new_off); - ((P1 *)this)->new_off = (((int)((P1 *)this)->prev_off)+((int)((P1 *)this)->size)); -#ifdef VAR_RANGES - logval("tracer:new_off", ((int)((P1 *)this)->new_off)); -#endif - ; - _m = 3; goto P999; /* 1 */ - case 36: /* STATE 4 - line 111 "buffer.spin" - [((((new_off-read_off)>4)&&((new_off-read_off)<(255/2))))] (0:0:1 - 1) */ - IfNotBlocked - reached[1][4] = 1; - if (!((((((int)((P1 *)this)->new_off)-((int)now.read_off))>4)&&((((int)((P1 *)this)->new_off)-((int)now.read_off))<(255/2))))) - continue; - /* dead 1: new_off */ (trpt+1)->bup.oval = ((P1 *)this)->new_off; -#ifdef HAS_CODE - if (!readtrail) -#endif - ((P1 *)this)->new_off = 0; - _m = 3; goto P999; /* 0 */ - case 37: /* STATE 7 - line 113 "buffer.spin" - [(1)] (27:0:0 - 1) */ - IfNotBlocked - reached[1][7] = 1; - if (!(1)) - continue; - /* merge: .(goto)(0, 9, 27) */ - reached[1][9] = 1; - ; - _m = 3; goto P999; /* 1 */ - case 38: /* STATE 11 - line 118 "buffer.spin" - [((prev_off!=write_off))] (3:0:1 - 1) */ - IfNotBlocked - reached[1][11] = 1; - if (!((((int)((P1 *)this)->prev_off)!=((int)now.write_off)))) - continue; - /* dead 1: prev_off */ (trpt+1)->bup.oval = ((P1 *)this)->prev_off; -#ifdef HAS_CODE - if (!readtrail) -#endif - ((P1 *)this)->prev_off = 0; - /* merge: goto cmpxchg_loop(0, 12, 3) */ - reached[1][12] = 1; - ; - _m = 3; goto P999; /* 1 */ - case 39: /* STATE 14 - line 119 "buffer.spin" - [write_off = new_off] (0:24:2 - 1) */ - IfNotBlocked - reached[1][14] = 1; - (trpt+1)->bup.ovals = grab_ints(2); - (trpt+1)->bup.ovals[0] = ((int)now.write_off); - now.write_off = ((int)((P1 *)this)->new_off); -#ifdef VAR_RANGES - logval("write_off", ((int)now.write_off)); -#endif - ; - /* merge: .(goto)(24, 16, 24) */ - reached[1][16] = 1; - ; - /* merge: i = 0(24, 17, 24) */ - reached[1][17] = 1; - (trpt+1)->bup.ovals[1] = ((int)((P1 *)this)->i); - ((P1 *)this)->i = 0; -#ifdef VAR_RANGES - logval("tracer:i", ((int)((P1 *)this)->i)); -#endif - ; - /* merge: .(goto)(0, 25, 24) */ - reached[1][25] = 1; - ; - _m = 3; goto P999; /* 3 */ - case 40: /* STATE 17 - line 121 "buffer.spin" - [i = 0] (0:24:1 - 2) */ - IfNotBlocked - reached[1][17] = 1; - (trpt+1)->bup.oval = ((int)((P1 *)this)->i); - ((P1 *)this)->i = 0; -#ifdef VAR_RANGES - logval("tracer:i", ((int)((P1 *)this)->i)); -#endif - ; - /* merge: .(goto)(0, 25, 24) */ - reached[1][25] = 1; - ; - _m = 3; goto P999; /* 1 */ - case 41: /* STATE 18 - line 123 "buffer.spin" - [((ii)<((int)((P1 *)this)->size)))) - continue; - /* merge: assert((buffer_use[((prev_off+i)%4)]==0))(24, 19, 24) */ - reached[1][19] = 1; - assert((((int)now.buffer_use[ Index(((((int)((P1 *)this)->prev_off)+((int)((P1 *)this)->i))%4), 4) ])==0), "(buffer_use[((prev_off+i)%4)]==0)", II, tt, t); - /* merge: buffer_use[((prev_off+i)%4)] = 1(24, 20, 24) */ - reached[1][20] = 1; - (trpt+1)->bup.ovals = grab_ints(2); - (trpt+1)->bup.ovals[0] = ((int)now.buffer_use[ Index(((((int)((P1 *)this)->prev_off)+((int)((P1 *)this)->i))%4), 4) ]); - now.buffer_use[ Index(((((P1 *)this)->prev_off+((P1 *)this)->i)%4), 4) ] = 1; -#ifdef VAR_RANGES - logval("buffer_use[((tracer:prev_off+tracer:i)%4)]", ((int)now.buffer_use[ Index(((((int)((P1 *)this)->prev_off)+((int)((P1 *)this)->i))%4), 4) ])); -#endif - ; - /* merge: i = (i+1)(24, 21, 24) */ - reached[1][21] = 1; - (trpt+1)->bup.ovals[1] = ((int)((P1 *)this)->i); - ((P1 *)this)->i = (((int)((P1 *)this)->i)+1); -#ifdef VAR_RANGES - logval("tracer:i", ((int)((P1 *)this)->i)); -#endif - ; - /* merge: .(goto)(0, 25, 24) */ - reached[1][25] = 1; - ; - _m = 3; goto P999; /* 4 */ - case 42: /* STATE 22 - line 127 "buffer.spin" - [((i>=size))] (26:0:1 - 1) */ - IfNotBlocked - reached[1][22] = 1; - if (!((((int)((P1 *)this)->i)>=((int)((P1 *)this)->size)))) - continue; - /* dead 1: i */ (trpt+1)->bup.oval = ((P1 *)this)->i; -#ifdef HAS_CODE - if (!readtrail) -#endif - ((P1 *)this)->i = 0; - /* merge: goto :b0(0, 23, 26) */ - reached[1][23] = 1; - ; - _m = 3; goto P999; /* 1 */ - case 43: /* STATE 28 - line 134 "buffer.spin" - [i = 0] (0:0:1 - 1) */ - IfNotBlocked - reached[1][28] = 1; - (trpt+1)->bup.oval = ((int)((P1 *)this)->i); - ((P1 *)this)->i = 0; -#ifdef VAR_RANGES - logval("tracer:i", ((int)((P1 *)this)->i)); -#endif - ; - _m = 3; goto P999; /* 0 */ - case 44: /* STATE 29 - line 136 "buffer.spin" - [((ii)<((int)((P1 *)this)->size)))) - continue; - /* merge: buffer_use[((prev_off+i)%4)] = 0(34, 30, 34) */ - reached[1][30] = 1; - (trpt+1)->bup.ovals = grab_ints(2); - (trpt+1)->bup.ovals[0] = ((int)now.buffer_use[ Index(((((int)((P1 *)this)->prev_off)+((int)((P1 *)this)->i))%4), 4) ]); - now.buffer_use[ Index(((((P1 *)this)->prev_off+((P1 *)this)->i)%4), 4) ] = 0; -#ifdef VAR_RANGES - logval("buffer_use[((tracer:prev_off+tracer:i)%4)]", ((int)now.buffer_use[ Index(((((int)((P1 *)this)->prev_off)+((int)((P1 *)this)->i))%4), 4) ])); -#endif - ; - /* merge: i = (i+1)(34, 31, 34) */ - reached[1][31] = 1; - (trpt+1)->bup.ovals[1] = ((int)((P1 *)this)->i); - ((P1 *)this)->i = (((int)((P1 *)this)->i)+1); -#ifdef VAR_RANGES - logval("tracer:i", ((int)((P1 *)this)->i)); -#endif - ; - /* merge: .(goto)(0, 35, 34) */ - reached[1][35] = 1; - ; - _m = 3; goto P999; /* 3 */ - case 45: /* STATE 32 - line 139 "buffer.spin" - [((i>=size))] (43:0:3 - 1) */ - IfNotBlocked - reached[1][32] = 1; - if (!((((int)((P1 *)this)->i)>=((int)((P1 *)this)->size)))) - continue; - /* dead 1: i */ (trpt+1)->bup.ovals = grab_ints(3); - (trpt+1)->bup.ovals[0] = ((P1 *)this)->i; -#ifdef HAS_CODE - if (!readtrail) -#endif - ((P1 *)this)->i = 0; - /* merge: goto :b1(43, 33, 43) */ - reached[1][33] = 1; - ; - /* merge: tmp_commit = (commit_count[((prev_off%4)/(4/2))]+size)(43, 37, 43) */ - reached[1][37] = 1; - (trpt+1)->bup.ovals[1] = ((int)((P1 *)this)->tmp_commit); - ((P1 *)this)->tmp_commit = (((int)now.commit_count[ Index(((((int)((P1 *)this)->prev_off)%4)/(4/2)), 2) ])+((int)((P1 *)this)->size)); -#ifdef VAR_RANGES - logval("tracer:tmp_commit", ((int)((P1 *)this)->tmp_commit)); -#endif - ; - /* merge: commit_count[((prev_off%4)/(4/2))] = tmp_commit(43, 38, 43) */ - reached[1][38] = 1; - (trpt+1)->bup.ovals[2] = ((int)now.commit_count[ Index(((((int)((P1 *)this)->prev_off)%4)/(4/2)), 2) ]); - now.commit_count[ Index(((((P1 *)this)->prev_off%4)/(4/2)), 2) ] = ((int)((P1 *)this)->tmp_commit); -#ifdef VAR_RANGES - logval("commit_count[((tracer:prev_off%4)/(4/2))]", ((int)now.commit_count[ Index(((((int)((P1 *)this)->prev_off)%4)/(4/2)), 2) ])); -#endif - ; - _m = 3; goto P999; /* 3 */ - case 46: /* STATE 37 - line 141 "buffer.spin" - [tmp_commit = (commit_count[((prev_off%4)/(4/2))]+size)] (0:43:2 - 3) */ - IfNotBlocked - reached[1][37] = 1; - (trpt+1)->bup.ovals = grab_ints(2); - (trpt+1)->bup.ovals[0] = ((int)((P1 *)this)->tmp_commit); - ((P1 *)this)->tmp_commit = (((int)now.commit_count[ Index(((((int)((P1 *)this)->prev_off)%4)/(4/2)), 2) ])+((int)((P1 *)this)->size)); -#ifdef VAR_RANGES - logval("tracer:tmp_commit", ((int)((P1 *)this)->tmp_commit)); -#endif - ; - /* merge: commit_count[((prev_off%4)/(4/2))] = tmp_commit(43, 38, 43) */ - reached[1][38] = 1; - (trpt+1)->bup.ovals[1] = ((int)now.commit_count[ Index(((((int)((P1 *)this)->prev_off)%4)/(4/2)), 2) ]); - now.commit_count[ Index(((((P1 *)this)->prev_off%4)/(4/2)), 2) ] = ((int)((P1 *)this)->tmp_commit); -#ifdef VAR_RANGES - logval("commit_count[((tracer:prev_off%4)/(4/2))]", ((int)now.commit_count[ Index(((((int)((P1 *)this)->prev_off)%4)/(4/2)), 2) ])); -#endif - ; - _m = 3; goto P999; /* 1 */ - case 47: /* STATE 39 - line 145 "buffer.spin" - [((((((prev_off/4)*4)/2)+(4/2))-tmp_commit))] (49:0:3 - 1) */ - IfNotBlocked - reached[1][39] = 1; - if (!((((((((int)((P1 *)this)->prev_off)/4)*4)/2)+(4/2))-((int)((P1 *)this)->tmp_commit)))) - continue; - /* dead 1: prev_off */ (trpt+1)->bup.ovals = grab_ints(3); - (trpt+1)->bup.ovals[0] = ((P1 *)this)->prev_off; -#ifdef HAS_CODE - if (!readtrail) -#endif - ((P1 *)this)->prev_off = 0; - /* dead 1: tmp_commit */ (trpt+1)->bup.ovals[1] = ((P1 *)this)->tmp_commit; -#ifdef HAS_CODE - if (!readtrail) -#endif - ((P1 *)this)->tmp_commit = 0; - /* merge: deliver = 1(49, 40, 49) */ - reached[1][40] = 1; - (trpt+1)->bup.ovals[2] = ((int)deliver); - deliver = 1; -#ifdef VAR_RANGES - logval("deliver", ((int)deliver)); -#endif - ; - /* merge: .(goto)(49, 44, 49) */ - reached[1][44] = 1; - ; - _m = 3; goto P999; /* 2 */ - case 48: /* STATE 44 - line 150 "buffer.spin" - [.(goto)] (0:49:0 - 2) */ - IfNotBlocked - reached[1][44] = 1; - ; - _m = 3; goto P999; /* 0 */ - case 49: /* STATE 42 - line 148 "buffer.spin" - [(1)] (49:0:0 - 1) */ - IfNotBlocked - reached[1][42] = 1; - if (!(1)) - continue; - /* merge: .(goto)(49, 44, 49) */ - reached[1][44] = 1; - ; - _m = 3; goto P999; /* 1 */ - case 50: /* STATE 47 - line 154 "buffer.spin" - [events_lost = (events_lost+1)] (0:0:1 - 2) */ - IfNotBlocked - reached[1][47] = 1; - (trpt+1)->bup.oval = ((int)now.events_lost); - now.events_lost = (((int)now.events_lost)+1); -#ifdef VAR_RANGES - logval("events_lost", ((int)now.events_lost)); -#endif - ; - _m = 3; goto P999; /* 0 */ - case 51: /* STATE 48 - line 156 "buffer.spin" - [refcount = (refcount-1)] (0:0:1 - 2) */ - IfNotBlocked - reached[1][48] = 1; - (trpt+1)->bup.oval = ((int)now.refcount); - now.refcount = (((int)now.refcount)-1); -#ifdef VAR_RANGES - logval("refcount", ((int)now.refcount)); -#endif - ; - _m = 3; goto P999; /* 0 */ - case 52: /* STATE 50 - line 158 "buffer.spin" - [-end-] (0:0:0 - 1) */ - IfNotBlocked - reached[1][50] = 1; - if (!delproc(1, II)) continue; - _m = 3; goto P999; /* 0 */ - - /* PROC switcher */ - case 53: /* STATE 1 - line 60 "buffer.spin" - [prev_off = write_off] (0:9:3 - 1) */ - IfNotBlocked - reached[0][1] = 1; - (trpt+1)->bup.ovals = grab_ints(3); - (trpt+1)->bup.ovals[0] = ((int)((P0 *)this)->prev_off); - ((P0 *)this)->prev_off = ((int)now.write_off); -#ifdef VAR_RANGES - logval("switcher:prev_off", ((int)((P0 *)this)->prev_off)); -#endif - ; - /* merge: size = ((4/2)-(prev_off%(4/2)))(9, 2, 9) */ - reached[0][2] = 1; - (trpt+1)->bup.ovals[1] = ((int)((P0 *)this)->size); - ((P0 *)this)->size = ((4/2)-(((int)((P0 *)this)->prev_off)%(4/2))); -#ifdef VAR_RANGES - logval("switcher:size", ((int)((P0 *)this)->size)); -#endif - ; - /* merge: new_off = (prev_off+size)(9, 3, 9) */ - reached[0][3] = 1; - (trpt+1)->bup.ovals[2] = ((int)((P0 *)this)->new_off); - ((P0 *)this)->new_off = (((int)((P0 *)this)->prev_off)+((int)((P0 *)this)->size)); -#ifdef VAR_RANGES - logval("switcher:new_off", ((int)((P0 *)this)->new_off)); -#endif - ; - _m = 3; goto P999; /* 2 */ - case 54: /* STATE 4 - line 65 "buffer.spin" - [(((((new_off-read_off)>4)&&((new_off-read_off)<(255/2)))||(size==(4/2))))] (29:0:3 - 1) */ - IfNotBlocked - reached[0][4] = 1; - if (!(((((((int)((P0 *)this)->new_off)-((int)now.read_off))>4)&&((((int)((P0 *)this)->new_off)-((int)now.read_off))<(255/2)))||(((int)((P0 *)this)->size)==(4/2))))) - continue; - /* dead 1: new_off */ (trpt+1)->bup.ovals = grab_ints(3); - (trpt+1)->bup.ovals[0] = ((P0 *)this)->new_off; -#ifdef HAS_CODE - if (!readtrail) -#endif - ((P0 *)this)->new_off = 0; - /* dead 1: size */ (trpt+1)->bup.ovals[1] = ((P0 *)this)->size; -#ifdef HAS_CODE - if (!readtrail) -#endif - ((P0 *)this)->size = 0; - /* merge: refcount = (refcount-1)(29, 5, 29) */ - reached[0][5] = 1; - (trpt+1)->bup.ovals[2] = ((int)now.refcount); - now.refcount = (((int)now.refcount)-1); -#ifdef VAR_RANGES - logval("refcount", ((int)now.refcount)); -#endif - ; - /* merge: goto not_needed(29, 6, 29) */ - reached[0][6] = 1; - ; - _m = 3; goto P999; /* 2 */ - case 55: /* STATE 8 - line 68 "buffer.spin" - [(1)] (18:0:0 - 1) */ - IfNotBlocked - reached[0][8] = 1; - if (!(1)) - continue; - /* merge: .(goto)(0, 10, 18) */ - reached[0][10] = 1; - ; - _m = 3; goto P999; /* 1 */ - case 56: /* STATE 12 - line 73 "buffer.spin" - [((prev_off!=write_off))] (11:0:1 - 1) */ - IfNotBlocked - reached[0][12] = 1; - if (!((((int)((P0 *)this)->prev_off)!=((int)now.write_off)))) - continue; - /* dead 1: prev_off */ (trpt+1)->bup.oval = ((P0 *)this)->prev_off; -#ifdef HAS_CODE - if (!readtrail) -#endif - ((P0 *)this)->prev_off = 0; - /* merge: goto cmpxchg_loop(0, 13, 11) */ - reached[0][13] = 1; - ; - _m = 3; goto P999; /* 1 */ - case 57: /* STATE 17 - line 76 "buffer.spin" - [.(goto)] (0:28:0 - 1) */ - IfNotBlocked - reached[0][17] = 1; - ; - _m = 3; goto P999; /* 0 */ - case 58: /* STATE 15 - line 74 "buffer.spin" - [write_off = new_off] (0:28:1 - 1) */ - IfNotBlocked - reached[0][15] = 1; - (trpt+1)->bup.oval = ((int)now.write_off); - now.write_off = ((int)((P0 *)this)->new_off); -#ifdef VAR_RANGES - logval("write_off", ((int)now.write_off)); -#endif - ; - /* merge: .(goto)(28, 17, 28) */ - reached[0][17] = 1; - ; - _m = 3; goto P999; /* 1 */ - case 59: /* STATE 19 - line 79 "buffer.spin" - [tmp_commit = (commit_count[((prev_off%4)/(4/2))]+size)] (0:25:2 - 1) */ - IfNotBlocked - reached[0][19] = 1; - (trpt+1)->bup.ovals = grab_ints(2); - (trpt+1)->bup.ovals[0] = ((int)((P0 *)this)->tmp_commit); - ((P0 *)this)->tmp_commit = (((int)now.commit_count[ Index(((((int)((P0 *)this)->prev_off)%4)/(4/2)), 2) ])+((int)((P0 *)this)->size)); -#ifdef VAR_RANGES - logval("switcher:tmp_commit", ((int)((P0 *)this)->tmp_commit)); -#endif - ; - /* merge: commit_count[((prev_off%4)/(4/2))] = tmp_commit(25, 20, 25) */ - reached[0][20] = 1; - (trpt+1)->bup.ovals[1] = ((int)now.commit_count[ Index(((((int)((P0 *)this)->prev_off)%4)/(4/2)), 2) ]); - now.commit_count[ Index(((((P0 *)this)->prev_off%4)/(4/2)), 2) ] = ((int)((P0 *)this)->tmp_commit); -#ifdef VAR_RANGES - logval("commit_count[((switcher:prev_off%4)/(4/2))]", ((int)now.commit_count[ Index(((((int)((P0 *)this)->prev_off)%4)/(4/2)), 2) ])); -#endif - ; - _m = 3; goto P999; /* 1 */ - case 60: /* STATE 21 - line 83 "buffer.spin" - [((((((prev_off/4)*4)/2)+(4/2))-tmp_commit))] (29:0:4 - 1) */ - IfNotBlocked - reached[0][21] = 1; - if (!((((((((int)((P0 *)this)->prev_off)/4)*4)/2)+(4/2))-((int)((P0 *)this)->tmp_commit)))) - continue; - /* dead 1: prev_off */ (trpt+1)->bup.ovals = grab_ints(4); - (trpt+1)->bup.ovals[0] = ((P0 *)this)->prev_off; -#ifdef HAS_CODE - if (!readtrail) -#endif - ((P0 *)this)->prev_off = 0; - /* dead 1: tmp_commit */ (trpt+1)->bup.ovals[1] = ((P0 *)this)->tmp_commit; -#ifdef HAS_CODE - if (!readtrail) -#endif - ((P0 *)this)->tmp_commit = 0; - /* merge: deliver = 1(29, 22, 29) */ - reached[0][22] = 1; - (trpt+1)->bup.ovals[2] = ((int)deliver); - deliver = 1; -#ifdef VAR_RANGES - logval("deliver", ((int)deliver)); -#endif - ; - /* merge: .(goto)(29, 26, 29) */ - reached[0][26] = 1; - ; - /* merge: refcount = (refcount-1)(29, 27, 29) */ - reached[0][27] = 1; - (trpt+1)->bup.ovals[3] = ((int)now.refcount); - now.refcount = (((int)now.refcount)-1); -#ifdef VAR_RANGES - logval("refcount", ((int)now.refcount)); -#endif - ; - _m = 3; goto P999; /* 3 */ - case 61: /* STATE 26 - line 88 "buffer.spin" - [.(goto)] (0:29:1 - 2) */ - IfNotBlocked - reached[0][26] = 1; - ; - /* merge: refcount = (refcount-1)(29, 27, 29) */ - reached[0][27] = 1; - (trpt+1)->bup.oval = ((int)now.refcount); - now.refcount = (((int)now.refcount)-1); -#ifdef VAR_RANGES - logval("refcount", ((int)now.refcount)); -#endif - ; - _m = 3; goto P999; /* 1 */ - case 62: /* STATE 24 - line 86 "buffer.spin" - [(1)] (29:0:1 - 1) */ - IfNotBlocked - reached[0][24] = 1; - if (!(1)) - continue; - /* merge: .(goto)(29, 26, 29) */ - reached[0][26] = 1; - ; - /* merge: refcount = (refcount-1)(29, 27, 29) */ - reached[0][27] = 1; - (trpt+1)->bup.oval = ((int)now.refcount); - now.refcount = (((int)now.refcount)-1); -#ifdef VAR_RANGES - logval("refcount", ((int)now.refcount)); -#endif - ; - _m = 3; goto P999; /* 2 */ - case 63: /* STATE 30 - line 92 "buffer.spin" - [-end-] (0:0:0 - 1) */ - IfNotBlocked - reached[0][30] = 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 - } - diff --git a/trunk/verif/examples/pan.t b/trunk/verif/examples/pan.t deleted file mode 100644 index 217eaf43..00000000 --- a/trunk/verif/examples/pan.t +++ /dev/null @@ -1,919 +0,0 @@ -#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("file %s line %3d\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(6*sizeof(Trans **)); - - /* proctype 4: :init: */ - - trans[4] = (Trans **) emalloc(57*sizeof(Trans *)); - - T = trans[ 4][41] = settr(158,2,0,0,0,"ATOMIC", 1, 2, 0); - T->nxt = settr(158,2,1,0,0,"ATOMIC", 1, 2, 0); - trans[4][1] = settr(118,2,7,3,3,"i = 0", 1, 2, 0); - trans[4][8] = settr(125,2,7,1,0,".(goto)", 1, 2, 0); - T = trans[4][7] = settr(124,2,0,0,0,"DO", 1, 2, 0); - T = T->nxt = settr(124,2,2,0,0,"DO", 1, 2, 0); - T->nxt = settr(124,2,5,0,0,"DO", 1, 2, 0); - trans[4][2] = settr(119,2,7,4,4,"((i<2))", 1, 2, 0); /* m: 3 -> 7,0 */ - reached4[3] = 1; - trans[4][3] = settr(0,0,0,0,0,"commit_count[i] = 0",0,0,0); - trans[4][4] = settr(0,0,0,0,0,"i = (i+1)",0,0,0); - trans[4][5] = settr(122,2,16,5,5,"((i>=2))", 1, 2, 0); /* m: 10 -> 16,0 */ - reached4[10] = 1; - trans[4][6] = settr(123,2,10,1,0,"goto :b6", 1, 2, 0); /* m: 10 -> 0,16 */ - reached4[10] = 1; - trans[4][9] = settr(126,2,10,1,0,"break", 1, 2, 0); - trans[4][10] = settr(127,2,16,6,6,"i = 0", 1, 2, 0); - trans[4][17] = settr(134,2,16,1,0,".(goto)", 1, 2, 0); - T = trans[4][16] = settr(133,2,0,0,0,"DO", 1, 2, 0); - T = T->nxt = settr(133,2,11,0,0,"DO", 1, 2, 0); - T->nxt = settr(133,2,14,0,0,"DO", 1, 2, 0); - trans[4][11] = settr(128,2,16,7,7,"((i<4))", 1, 2, 0); /* m: 12 -> 16,0 */ - reached4[12] = 1; - trans[4][12] = settr(0,0,0,0,0,"buffer_use[i] = 0",0,0,0); - trans[4][13] = settr(0,0,0,0,0,"i = (i+1)",0,0,0); - trans[4][14] = settr(131,2,19,8,8,"((i>=4))", 1, 2, 0); - trans[4][15] = settr(132,2,19,1,0,"goto :b7", 1, 2, 0); - trans[4][18] = settr(135,2,19,1,0,"break", 1, 2, 0); - trans[4][19] = settr(136,2,20,9,9,"(run reader())", 1, 2, 0); - trans[4][20] = settr(137,2,28,10,10,"(run cleaner())", 1, 2, 0); /* m: 21 -> 28,0 */ - reached4[21] = 1; - trans[4][21] = settr(0,0,0,0,0,"i = 0",0,0,0); - trans[4][29] = settr(146,2,28,1,0,".(goto)", 1, 2, 0); - T = trans[4][28] = settr(145,2,0,0,0,"DO", 1, 2, 0); - T = T->nxt = settr(145,2,22,0,0,"DO", 1, 2, 0); - T->nxt = settr(145,2,26,0,0,"DO", 1, 2, 0); - trans[4][22] = settr(139,2,24,11,11,"((i<4))", 1, 2, 0); /* m: 23 -> 24,0 */ - reached4[23] = 1; - trans[4][23] = settr(0,0,0,0,0,"refcount = (refcount+1)",0,0,0); - trans[4][24] = settr(141,2,28,12,12,"(run tracer())", 1, 2, 0); /* m: 25 -> 28,0 */ - reached4[25] = 1; - trans[4][25] = settr(0,0,0,0,0,"i = (i+1)",0,0,0); - trans[4][26] = settr(143,2,38,13,13,"((i>=4))", 1, 2, 0); /* m: 31 -> 38,0 */ - reached4[31] = 1; - trans[4][27] = settr(144,2,31,1,0,"goto :b8", 1, 2, 0); /* m: 31 -> 0,38 */ - reached4[31] = 1; - trans[4][30] = settr(147,2,31,1,0,"break", 1, 2, 0); - trans[4][31] = settr(148,2,38,14,14,"i = 0", 1, 2, 0); - trans[4][39] = settr(156,2,38,1,0,".(goto)", 1, 2, 0); - T = trans[4][38] = settr(155,2,0,0,0,"DO", 1, 2, 0); - T = T->nxt = settr(155,2,32,0,0,"DO", 1, 2, 0); - T->nxt = settr(155,2,36,0,0,"DO", 1, 2, 0); - trans[4][32] = settr(149,2,34,15,15,"((i<1))", 1, 2, 0); /* m: 33 -> 34,0 */ - reached4[33] = 1; - trans[4][33] = settr(0,0,0,0,0,"refcount = (refcount+1)",0,0,0); - trans[4][34] = settr(151,2,38,16,16,"(run switcher())", 1, 2, 0); /* m: 35 -> 38,0 */ - reached4[35] = 1; - trans[4][35] = settr(0,0,0,0,0,"i = (i+1)",0,0,0); - trans[4][36] = settr(153,2,40,17,17,"((i>=1))", 1, 2, 0); /* m: 37 -> 40,0 */ - reached4[37] = 1; - trans[4][37] = settr(154,2,40,1,0,"goto :b9", 1, 2, 0); - trans[4][40] = settr(157,0,55,1,0,"break", 1, 2, 0); - T = trans[ 4][55] = settr(172,2,0,0,0,"ATOMIC", 1, 2, 0); - T->nxt = settr(172,2,42,0,0,"ATOMIC", 1, 2, 0); - trans[4][42] = settr(159,2,50,18,18,"assert((((write_off-read_off)>=0)&&((write_off-read_off)<(255/2))))", 1, 2, 0); /* m: 43 -> 0,50 */ - reached4[43] = 1; - trans[4][43] = settr(0,0,0,0,0,"j = 0",0,0,0); - trans[4][44] = settr(0,0,0,0,0,"commit_sum = 0",0,0,0); - trans[4][51] = settr(168,2,50,1,0,".(goto)", 1, 2, 0); - T = trans[4][50] = settr(167,2,0,0,0,"DO", 1, 2, 0); - T = T->nxt = settr(167,2,45,0,0,"DO", 1, 2, 0); - T->nxt = settr(167,2,48,0,0,"DO", 1, 2, 0); - trans[4][45] = settr(162,2,50,19,19,"((j<2))", 1, 2, 0); /* m: 46 -> 50,0 */ - reached4[46] = 1; - trans[4][46] = settr(0,0,0,0,0,"commit_sum = (commit_sum+commit_count[j])",0,0,0); - trans[4][47] = settr(0,0,0,0,0,"j = (j+1)",0,0,0); - trans[4][48] = settr(165,4,56,20,20,"((j>=2))", 1, 2, 0); /* m: 53 -> 56,0 */ - reached4[53] = 1; - trans[4][49] = settr(166,2,53,1,0,"goto :b10", 1, 2, 0); /* m: 53 -> 0,56 */ - reached4[53] = 1; - trans[4][52] = settr(169,2,53,1,0,"break", 1, 2, 0); - trans[4][53] = settr(170,4,56,21,21,"assert((((write_off-commit_sum)>=0)&&((write_off-commit_sum)<(255/2))))", 1, 2, 0); /* m: 54 -> 0,56 */ - reached4[54] = 1; - trans[4][54] = settr(0,0,0,0,0,"assert((((4+1)>4)||(events_lost==0)))",0,0,0); - trans[4][56] = settr(173,0,0,22,22,"-end-", 0, 3500, 0); - - /* proctype 3: cleaner */ - - trans[3] = (Trans **) emalloc(10*sizeof(Trans *)); - - T = trans[ 3][8] = settr(116,2,0,0,0,"ATOMIC", 1, 2, 0); - T->nxt = settr(116,2,5,0,0,"ATOMIC", 1, 2, 0); - trans[3][6] = settr(114,2,5,1,0,".(goto)", 1, 2, 0); - T = trans[3][5] = settr(113,2,0,0,0,"DO", 1, 2, 0); - T->nxt = settr(113,2,1,0,0,"DO", 1, 2, 0); - trans[3][1] = settr(109,2,3,23,23,"((refcount==0))", 1, 2, 0); /* m: 2 -> 3,0 */ - reached3[2] = 1; - trans[3][2] = settr(0,0,0,0,0,"refcount = (refcount+1)",0,0,0); - trans[3][3] = settr(111,2,7,24,24,"(run switcher())", 1, 2, 0); /* m: 4 -> 7,0 */ - reached3[4] = 1; - trans[3][4] = settr(112,2,7,1,0,"goto :b5", 1, 2, 0); - trans[3][7] = settr(115,0,9,1,0,"break", 1, 2, 0); - trans[3][9] = settr(117,0,0,25,25,"-end-", 0, 3500, 0); - - /* proctype 2: reader */ - - trans[2] = (Trans **) emalloc(30*sizeof(Trans *)); - - trans[2][27] = settr(106,0,26,1,0,".(goto)", 0, 2, 0); - T = trans[2][26] = settr(105,0,0,0,0,"DO", 0, 2, 0); - T = T->nxt = settr(105,0,1,0,0,"DO", 0, 2, 0); - T->nxt = settr(105,0,24,0,0,"DO", 0, 2, 0); - trans[2][1] = settr(80,0,12,26,0,"((((((write_off/(4/2))-(read_off/(4/2)))>0)&&(((write_off/(4/2))-(read_off/(4/2)))<(255/2)))&&(((commit_count[((read_off%4)/(4/2))]-(4/2))-(((read_off/4)*4)/2))==0)))", 1, 2, 0); - T = trans[ 2][12] = settr(91,2,0,0,0,"ATOMIC", 1, 2, 0); - T->nxt = settr(91,2,2,0,0,"ATOMIC", 1, 2, 0); - trans[2][2] = settr(81,2,9,27,27,"i = 0", 1, 2, 0); - trans[2][10] = settr(89,2,9,1,0,".(goto)", 1, 2, 0); - T = trans[2][9] = settr(88,2,0,0,0,"DO", 1, 2, 0); - T = T->nxt = settr(88,2,3,0,0,"DO", 1, 2, 0); - T->nxt = settr(88,2,7,0,0,"DO", 1, 2, 0); - trans[2][3] = settr(82,2,9,28,28,"((i<(4/2)))", 1, 2, 0); /* m: 4 -> 9,0 */ - reached2[4] = 1; - trans[2][4] = settr(0,0,0,0,0,"assert((buffer_use[((read_off+i)%4)]==0))",0,0,0); - trans[2][5] = settr(0,0,0,0,0,"buffer_use[((read_off+i)%4)] = 1",0,0,0); - trans[2][6] = settr(0,0,0,0,0,"i = (i+1)",0,0,0); - trans[2][7] = settr(86,2,11,29,29,"((i>=(4/2)))", 1, 2, 0); /* m: 8 -> 11,0 */ - reached2[8] = 1; - trans[2][8] = settr(87,2,11,1,0,"goto :b3", 1, 2, 0); - trans[2][11] = settr(90,0,23,1,0,"break", 1, 2, 0); - T = trans[ 2][23] = settr(102,2,0,0,0,"ATOMIC", 1, 2, 0); - T->nxt = settr(102,2,13,0,0,"ATOMIC", 1, 2, 0); - trans[2][13] = /* c */ settr(92,2,19,27,27,"i = 0", 1, 2, 0); - trans[2][20] = settr(99,2,19,1,0,".(goto)", 1, 2, 0); - T = trans[2][19] = settr(98,2,0,0,0,"DO", 1, 2, 0); - T = T->nxt = settr(98,2,14,0,0,"DO", 1, 2, 0); - T->nxt = settr(98,2,17,0,0,"DO", 1, 2, 0); - trans[2][14] = settr(93,2,19,30,30,"((i<(4/2)))", 1, 2, 0); /* m: 15 -> 19,0 */ - reached2[15] = 1; - trans[2][15] = settr(0,0,0,0,0,"buffer_use[((read_off+i)%4)] = 0",0,0,0); - trans[2][16] = settr(0,0,0,0,0,"i = (i+1)",0,0,0); - trans[2][17] = settr(96,2,21,31,31,"((i>=(4/2)))", 1, 2, 0); - trans[2][18] = settr(97,2,21,1,0,"goto :b4", 1, 2, 0); - trans[2][21] = settr(100,2,22,1,0,"break", 1, 2, 0); - trans[2][22] = settr(101,0,26,32,32,"read_off = (read_off+(4/2))", 1, 2, 0); - trans[2][24] = settr(103,0,29,33,0,"((read_off>=(4-events_lost)))", 1, 2, 0); - trans[2][25] = settr(104,0,29,1,0,"goto :b2", 0, 2, 0); - trans[2][28] = settr(107,0,29,1,0,"break", 0, 2, 0); - trans[2][29] = settr(108,0,0,34,34,"-end-", 0, 3500, 0); - - /* proctype 1: tracer */ - - trans[1] = (Trans **) emalloc(51*sizeof(Trans *)); - - T = trans[ 1][3] = settr(32,2,0,0,0,"ATOMIC", 1, 2, 0); - T->nxt = settr(32,2,1,0,0,"ATOMIC", 1, 2, 0); - trans[1][1] = settr(30,4,10,35,35,"prev_off = write_off", 1, 2, 0); /* m: 2 -> 0,10 */ - reached1[2] = 1; - trans[1][2] = settr(0,0,0,0,0,"new_off = (prev_off+size)",0,0,0); - T = trans[ 1][10] = settr(39,2,0,0,0,"ATOMIC", 1, 2, 0); - T->nxt = settr(39,2,8,0,0,"ATOMIC", 1, 2, 0); - T = trans[1][8] = settr(37,2,0,0,0,"IF", 1, 2, 0); - T = T->nxt = settr(37,2,4,0,0,"IF", 1, 2, 0); - T->nxt = settr(37,2,6,0,0,"IF", 1, 2, 0); - trans[1][4] = settr(33,2,47,36,36,"((((new_off-read_off)>4)&&((new_off-read_off)<(255/2))))", 1, 2, 0); - trans[1][5] = settr(34,2,47,1,0,"goto lost", 1, 2, 0); - trans[1][9] = settr(38,0,27,1,0,".(goto)", 1, 2, 0); - trans[1][6] = settr(35,2,7,2,0,"else", 1, 2, 0); - trans[1][7] = settr(36,4,27,37,37,"(1)", 1, 2, 0); /* m: 9 -> 27,0 */ - reached1[9] = 1; - T = trans[ 1][27] = settr(56,2,0,0,0,"ATOMIC", 1, 2, 0); - T->nxt = settr(56,2,15,0,0,"ATOMIC", 1, 2, 0); - T = trans[1][15] = settr(44,2,0,0,0,"IF", 1, 2, 0); - T = T->nxt = settr(44,2,11,0,0,"IF", 1, 2, 0); - T->nxt = settr(44,2,13,0,0,"IF", 1, 2, 0); - trans[1][11] = settr(40,4,3,38,38,"((prev_off!=write_off))", 1, 2, 0); /* m: 12 -> 3,0 */ - reached1[12] = 1; - trans[1][12] = settr(41,0,3,1,0,"goto cmpxchg_loop", 1, 2, 0); - trans[1][16] = settr(45,2,17,1,0,".(goto)", 1, 2, 0); /* m: 17 -> 0,24 */ - reached1[17] = 1; - trans[1][13] = settr(42,2,14,2,0,"else", 1, 2, 0); - trans[1][14] = settr(43,2,24,39,39,"write_off = new_off", 1, 2, 0); /* m: 17 -> 0,24 */ - reached1[17] = 1; - trans[1][17] = settr(46,2,24,40,40,"i = 0", 1, 2, 0); - trans[1][25] = settr(54,2,24,1,0,".(goto)", 1, 2, 0); - T = trans[1][24] = settr(53,2,0,0,0,"DO", 1, 2, 0); - T = T->nxt = settr(53,2,18,0,0,"DO", 1, 2, 0); - T->nxt = settr(53,2,22,0,0,"DO", 1, 2, 0); - trans[1][18] = settr(47,2,24,41,41,"((i 24,0 */ - reached1[19] = 1; - trans[1][19] = settr(0,0,0,0,0,"assert((buffer_use[((prev_off+i)%4)]==0))",0,0,0); - trans[1][20] = settr(0,0,0,0,0,"buffer_use[((prev_off+i)%4)] = 1",0,0,0); - trans[1][21] = settr(0,0,0,0,0,"i = (i+1)",0,0,0); - trans[1][22] = settr(51,2,26,42,42,"((i>=size))", 1, 2, 0); /* m: 23 -> 26,0 */ - reached1[23] = 1; - trans[1][23] = settr(52,2,26,1,0,"goto :b0", 1, 2, 0); - trans[1][26] = settr(55,0,45,1,0,"break", 1, 2, 0); - T = trans[ 1][45] = settr(74,2,0,0,0,"ATOMIC", 1, 2, 0); - T->nxt = settr(74,2,28,0,0,"ATOMIC", 1, 2, 0); - trans[1][28] = settr(57,2,34,43,43,"i = 0", 1, 2, 0); - trans[1][35] = settr(64,2,34,1,0,".(goto)", 1, 2, 0); - T = trans[1][34] = settr(63,2,0,0,0,"DO", 1, 2, 0); - T = T->nxt = settr(63,2,29,0,0,"DO", 1, 2, 0); - T->nxt = settr(63,2,32,0,0,"DO", 1, 2, 0); - trans[1][29] = settr(58,2,34,44,44,"((i 34,0 */ - reached1[30] = 1; - trans[1][30] = settr(0,0,0,0,0,"buffer_use[((prev_off+i)%4)] = 0",0,0,0); - trans[1][31] = settr(0,0,0,0,0,"i = (i+1)",0,0,0); - trans[1][32] = settr(61,2,43,45,45,"((i>=size))", 1, 2, 0); /* m: 37 -> 43,0 */ - reached1[37] = 1; - trans[1][33] = settr(62,2,37,1,0,"goto :b1", 1, 2, 0); /* m: 37 -> 0,43 */ - reached1[37] = 1; - trans[1][36] = settr(65,2,37,1,0,"break", 1, 2, 0); - trans[1][37] = settr(66,2,43,46,46,"tmp_commit = (commit_count[((prev_off%4)/(4/2))]+size)", 1, 2, 0); /* m: 38 -> 0,43 */ - reached1[38] = 1; - trans[1][38] = settr(0,0,0,0,0,"commit_count[((prev_off%4)/(4/2))] = tmp_commit",0,0,0); - T = trans[1][43] = settr(72,2,0,0,0,"IF", 1, 2, 0); - T = T->nxt = settr(72,2,39,0,0,"IF", 1, 2, 0); - T->nxt = settr(72,2,41,0,0,"IF", 1, 2, 0); - trans[1][39] = settr(68,4,49,47,47,"((((((prev_off/4)*4)/2)+(4/2))-tmp_commit))", 1, 2, 0); /* m: 40 -> 49,0 */ - reached1[40] = 1; - trans[1][40] = settr(0,0,0,0,0,"deliver = 1",0,0,0); - trans[1][44] = settr(73,0,49,48,48,".(goto)", 1, 2, 0); - trans[1][41] = settr(70,2,42,2,0,"else", 1, 2, 0); - trans[1][42] = settr(71,4,49,49,49,"(1)", 1, 2, 0); /* m: 44 -> 49,0 */ - reached1[44] = 1; - T = trans[ 1][49] = settr(78,2,0,0,0,"ATOMIC", 1, 2, 0); - T->nxt = settr(78,2,46,0,0,"ATOMIC", 1, 2, 0); - trans[1][46] = settr(75,2,48,1,0,"goto end", 1, 2, 0); - trans[1][47] = settr(76,2,48,50,50,"events_lost = (events_lost+1)", 1, 2, 0); - trans[1][48] = settr(77,0,50,51,51,"refcount = (refcount-1)", 1, 2, 0); - trans[1][50] = settr(79,0,0,52,52,"-end-", 0, 3500, 0); - - /* proctype 0: switcher */ - - trans[0] = (Trans **) emalloc(31*sizeof(Trans *)); - - T = trans[ 0][11] = settr(10,2,0,0,0,"ATOMIC", 1, 2, 0); - T->nxt = settr(10,2,1,0,0,"ATOMIC", 1, 2, 0); - trans[0][1] = settr(0,2,9,53,53,"prev_off = write_off", 1, 2, 0); /* m: 2 -> 0,9 */ - reached0[2] = 1; - trans[0][2] = settr(0,0,0,0,0,"size = ((4/2)-(prev_off%(4/2)))",0,0,0); - trans[0][3] = settr(0,0,0,0,0,"new_off = (prev_off+size)",0,0,0); - T = trans[0][9] = settr(8,2,0,0,0,"IF", 1, 2, 0); - T = T->nxt = settr(8,2,4,0,0,"IF", 1, 2, 0); - T->nxt = settr(8,2,7,0,0,"IF", 1, 2, 0); - trans[0][4] = settr(3,4,29,54,54,"(((((new_off-read_off)>4)&&((new_off-read_off)<(255/2)))||(size==(4/2))))", 1, 2, 0); /* m: 5 -> 29,0 */ - reached0[5] = 1; - trans[0][5] = settr(0,0,0,0,0,"refcount = (refcount-1)",0,0,0); - trans[0][6] = settr(5,0,29,1,0,"goto not_needed", 1, 2, 0); - trans[0][10] = settr(9,0,18,1,0,".(goto)", 1, 2, 0); - trans[0][7] = settr(6,2,8,2,0,"else", 1, 2, 0); - trans[0][8] = settr(7,4,18,55,55,"(1)", 1, 2, 0); /* m: 10 -> 18,0 */ - reached0[10] = 1; - T = trans[ 0][18] = settr(17,2,0,0,0,"ATOMIC", 1, 2, 0); - T->nxt = settr(17,2,16,0,0,"ATOMIC", 1, 2, 0); - T = trans[0][16] = settr(15,2,0,0,0,"IF", 1, 2, 0); - T = T->nxt = settr(15,2,12,0,0,"IF", 1, 2, 0); - T->nxt = settr(15,2,14,0,0,"IF", 1, 2, 0); - trans[0][12] = settr(11,4,11,56,56,"((prev_off!=write_off))", 1, 2, 0); /* m: 13 -> 11,0 */ - reached0[13] = 1; - trans[0][13] = settr(12,0,11,1,0,"goto cmpxchg_loop", 1, 2, 0); - trans[0][17] = settr(16,0,28,57,57,".(goto)", 1, 2, 0); - trans[0][14] = settr(13,2,15,2,0,"else", 1, 2, 0); - trans[0][15] = settr(14,4,28,58,58,"write_off = new_off", 1, 2, 0); /* m: 17 -> 0,28 */ - reached0[17] = 1; - T = trans[ 0][28] = settr(27,2,0,0,0,"ATOMIC", 1, 2, 0); - T->nxt = settr(27,2,19,0,0,"ATOMIC", 1, 2, 0); - trans[0][19] = settr(18,2,25,59,59,"tmp_commit = (commit_count[((prev_off%4)/(4/2))]+size)", 1, 2, 0); /* m: 20 -> 0,25 */ - reached0[20] = 1; - trans[0][20] = settr(0,0,0,0,0,"commit_count[((prev_off%4)/(4/2))] = tmp_commit",0,0,0); - T = trans[0][25] = settr(24,2,0,0,0,"IF", 1, 2, 0); - T = T->nxt = settr(24,2,21,0,0,"IF", 1, 2, 0); - T->nxt = settr(24,2,23,0,0,"IF", 1, 2, 0); - trans[0][21] = settr(20,4,29,60,60,"((((((prev_off/4)*4)/2)+(4/2))-tmp_commit))", 1, 2, 0); /* m: 22 -> 29,0 */ - reached0[22] = 1; - trans[0][22] = settr(0,0,0,0,0,"deliver = 1",0,0,0); - trans[0][26] = settr(25,4,29,61,61,".(goto)", 1, 2, 0); /* m: 27 -> 0,29 */ - reached0[27] = 1; - trans[0][23] = settr(22,2,24,2,0,"else", 1, 2, 0); - trans[0][24] = settr(23,4,29,62,62,"(1)", 1, 2, 0); /* m: 26 -> 29,0 */ - reached0[26] = 1; - trans[0][27] = settr(0,0,0,0,0,"refcount = (refcount-1)",0,0,0); - trans[0][29] = settr(28,0,30,1,0,"(1)", 0, 2, 0); - trans[0][30] = settr(29,0,0,63,63,"-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 lstate[]) - /* process n, with m states, is=initial state */ -{ Trans *T0, *T1, *T2, *T3; - int i, k; -#ifndef NOREDUCE - int g, h, j, aa; -#endif -#ifdef HAS_UNLESS - int p; -#endif - if (state_tables >= 4) - { printf("STEP 1 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); - 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 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); - 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 - 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 - 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 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); - 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 */ - { Trans *T4; - 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) - { printf("proctype "); - if (!strcmp(procname[n], ":init:")) - printf("init\n"); - else - printf("%s\n", procname[n]); - for (i = 1; i < m; i++) - reach[i] = 1; - tagtable(n, m, is, srcln, reach); - } else - for (i = 1; i < m; i++) - { int nrelse; - if (strcmp(procname[n], ":never:") != 0) - { 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 (!state_tables && strcmp(procname[n], ":never:") == 0) - { int h = 0; - for (i = 1; i < m; i++) - for (T0 = trans[n][i]; T0; T0 = T0->nxt) - if (T0->forw > h) h = T0->forw; - h++; - frm_st0 = (short *) emalloc(h * sizeof(short)); - for (i = 1; i < m; i++) - for (T0 = trans[n][i]; T0; T0 = T0->nxt) - frm_st0[T0->forw] = i; - } -#ifndef LOOPSTATE - if (state_tables) -#endif - do_dfs(n, m, is, srcln, reach, lstate); -#ifdef T_REVERSE - /* process n, with m states, is=initial state -- reverse list */ - if (!state_tables && strcmp(procname[n], ":never:") != 0) - { for (i = 1; i < m; i++) - { Trans *T4 = (Trans *) 0; - T1 = (Trans *) 0; - T2 = (Trans *) 0; - T3 = (Trans *) 0; - for (T0 = trans[n][i]; T0; T0 = T4) - { T4 = T0->nxt; - if (strcmp(T0->tp, "else") == 0) - { T3 = T0; - T0->nxt = (Trans *) 0; - } else - { T0->nxt = T1; - if (!T1) { T2 = T0; } - T1 = T0; - } } - if (T2 && T3) { T2->nxt = T3; } - trans[n][i] = T1; /* reversed -- else at end */ - } } -#endif -} -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) - 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 - } -} -void -dfs_table(int n, int m, int is, short srcln[], uchar reach[], uchar lstate[]) -{ 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 */ - { lstate[is] = 1; - reach[is] |= 8; /* recorded */ - if (state_tables) - { 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) - { -#ifdef HAS_UNLESS - int i, j; -#endif - dfs_table(n, m, z->st, srcln, reach, lstate); -#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, lstate); - } -#endif - } - reach[is] &= ~16; /* no longer on stack */ -} -void -do_dfs(int n, int m, int is, short srcln[], uchar reach[], uchar lstate[]) -{ int i; - dfs_table(n, m, is, srcln, reach, lstate); - 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] line %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", - srcln[j]); - for (i = 0; z->tp[i]; i++) - if (z->tp[i] == '\n') - printf("\\n"); - else - putchar(z->tp[i]); - if (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); -} - -#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 diff --git a/trunk/verif/examples/spin-increment.spin.trail b/trunk/verif/examples/spin-increment.spin.trail deleted file mode 100644 index aff3eba3..00000000 --- a/trunk/verif/examples/spin-increment.spin.trail +++ /dev/null @@ -1,22 +0,0 @@ --4:-4:-4 -1:0:4 -2:0:5 -3:0:7 -4:0:5 -5:0:7 -6:0:9 -7:0:13 -8:2:0 -9:1:0 -10:2:1 -11:2:2 -12:2:3 -13:1:1 -14:1:2 -15:1:3 -16:0:15 -17:0:17 -18:0:17 -19:0:20 -20:0:24 -21:0:25 -- 2.34.1