ELF4s 4 (44444444/ / `((/ (/ HHHDDQtdRtd/ / /lib/ld-linux.so.2GNUGNUg[N'G!dϔ5b-+"-.)K8gUaIi 7?#hqz+)Z0GNFpu1*[`QDK__gmon_start__libc.so.6_IO_stdin_usedfflushstrcpy__printf_chkexitsprintf_IO_putcfopenstrncmpstrncpytime__stack_chk_failunlinkstdin__assert_failstrtolfgetsstrlenungetcmemsetstrstrfseek__fprintf_chkstdoutfputcmemcpyfclosemallocstrcat__ctype_b_locsscanfstderrsystemfscanf__sysv_signalstrchrfprintf__strcpy_chk__sprintf_chk__xstat_IO_getc__strcat_chkstrcmp__libc_start_mainfreeGLIBC_2.4GLIBC_2.1GLIBC_2.3GLIBC_2.3.4GLIBC_2.0ii ii ii ti ii / /0-0 0 0  0 0 0 0 0  0  $0  (0  ,0  00  40 80 <0 @0 D0 H0 L0 P0 T0 X0 \0 `0 d0 h0 l0 p0 t0 x0 |0  0 !0 "0 #0 $0 %0 &0 '0 (0 )0 *0 +0 ,US[tNqX[5/ %/ %0 h%0 h%0 h% 0 h%0 h %0 h(%0 h0%0 h8p% 0 h@`%$0 hHP%(0 hP@%,0 hX0%00 h` %40 hh%80 hp%<0 hx%@0 h%D0 h%H0 h%L0 h%P0 h%T0 h%X0 h%\0 hp%`0 h`%d0 hP%h0 h@%l0 h0%p0 h %t0 h%x0 h%|0 h%0 h%0 h%0 h%0 h%0 h %0 h(%0 h0%0 h8p%0 h@`%0 hHP%0 hP@%0 hX01^PTRhJhJQVhpNUS=u? / / 9s/ 9r[]Ít&'U$/ tt $$/ ÐU}uE6q]UVS`eE1EEEȍEEEEEȉEċEEEEЉ‹EfEE;EUċEȉ)E}'$7e}'vE'EȉEU$E}6EET$UȉT$$EEȋEEEEEET$UT$$EEEEEE;Et E$EEȉEċEEEEE;E6}. 6EQE}u nEE%=ZwKEEE}xz}IqEb;Eu`E VE}}94}G,4]I}tmEEЃEEEOE}3ENE+EEE}3Et2ED$D$($识E$RE@JJUP8282D$$?qˮV2E(E(@E0E$XEHEE @D$t$\$ L$T$$e4EE9Et E@D$D$E$4EE(@;E$]q0ttkE @U(P8TE0E$XEHEE @D$t$\$ L$T$$3E}tuE@J0D$ D$D$3$ծEE@0D$ D$D$3$蟮EE@}0Eq0D$ D$D$3$]EE@;0D$ D$D$3$'EEPEPE@=/D$dq$eq9/D$ D$D$3$EE@E@@fu"E@D$$qm/E@@8f=3t"E@D$$q詫4/E@@8PEP/E@J/EPJD$D$D$ T$D$$M1EEt E@D$D$E$1$]q-Jz.E@\.Et#E@E@T$$P!.E$5E .E-EtEURPE@Jt7E@T$$uD$$qE@m-EPE @D$D$D$ T$D$$/J-D$ D$Eԉ$ qT$D$Eԉ$^D$ D$D$6$ҪEEԉ$dUB,EE,D$ D$Eԉ$ƒqT$D$Eԉ$D$ D$D$6$FEEԉ$؂UB,EE,E@JtD$$qEE@+E@D$q$uAEPE@D$D$D$ T$D$$-?EPE@D$D$D$ T$D$$-J+JtE@D$$qTE@L*E$RL*EE*EE`*E@D$$rr*`*EE@T$$!i/*EPE@D$T$$=fRRf^R)EPE@D$T$$=fRRf^R)EHEPE@L$T$$<fRRf^Rb)EHEPE@L$T$$<fRRf^R)D$$gED$ D$D$$ԦEEUPf^R(D$$ig||f@D$ D$D$$VEE|Pf^R)(D$$fxD$ D$D$$EExPx$;f^R'$8'D$ D$D$@$$ b'$VUB'D$$&r菡 'E&E$ 'E&E$g &E&EPET$$xE&D$$4r &D$$Qr|&EEo&EET$$EN&EB&EE5&EE(&EE&EEPEL$T$$yEE%EEPEL$T$$ET$$wE%E@=tD$$nrE$tEtE@D$$r蠟J%D$$r菡%ED$ D$D$,$E$EET$ D$D$,$ԢE$E$EE$EED$ T$D$5$荢Eu$EEEL$ T$D$5$XE@$ED$ D$D$4$+E$EET$ D$D$4$E#EEEXD$ D$D$3$辡C8E@@8@#EEE@UP8EET$$gEf=3tEf=6uE@@Ht  2 "0 "EED$T$$E$E@D$$r"E@UP8EE2 ^"0 T"E@D$$s谜K"E@tRR R RE$tt9M£ED$ D$D$@$ܟEEPEP!E@@EE!E@URPE@v)E@D$$:s跛E@E@@EE)!E @URPE @@ E E ED$6T$$E ED$ D$D$6$赞EE@@ x n E@D$$Ssǚb LS EED$ T$D$6$7E E@@f=E@@@LEEEEP(Et&E@@f=tE@f@u:u1E@@fuE@D$$ps›EtEP$ET$$mLEED$ D$D$.$EEE2 EE2 D$$sEEzhRfREE E L$ T$D$r$.EED$RD$$nqRfREE E L$ T$D$s$譛EE@ED$SD$$pE$膺aEE EL$T$$ *ED$$ E EE T$$nEED$$t EEE EL$T$$$ EED$ D$D$$tEEP EP E$@;6E D$ D$D$$EEP EP E$D$ D$D$$֙EUBED$ D$D$$螙EE@@ft,E@@f=tE@D$$s讕E@f@;EED$ T$D$:$"EE@@ft2E@@f=tE@D$$s)E@f@EEEL$ T$D$?$薘EEET$$^EED$T$$iE$4D$ D$D$3$ EE@EUT$ D$D$+$EEEML$ T$D$?$辗EEET$$]E$?E@@f@\D$$s•MD$ D$D$3$9EE@EUT$ D$D$-$EEEML$ T$D$?$זEEET$$]E$XE@@f@xD$$s۔f0 WEE D$ T$D$$;E0 ED$ D$D$$EED$ D$D$$ѕEED$ D$D$$褕EED$$wEEjXRfREE E L$ T$D$r$EfVRE@ED$RD$$KjRfREEEL$ T$D$r$臔EE@ED$RD$$iE3RfREEEL$ T$D$r$EE@fVRED$RD$$ iRfREE E L$ T$D$s$_EfTRE@ED$SD$$hE$/ ED$ D$D$c$EE$GD$ D$D$$辒E$:ED$ D$D$!$}E$^D$$UB E@ D$$0+$ED$ D$D$#$E$D$$^UB E@ D$ ${$:D$ D$D$"$聑E$bD$$UB G5EE@T$$6$EEE@D$$oUB EP E@T$$EUB $>D$ D$D$$腐E$fUB[EENEEAEE1EET$ D$D$+$EEET$ D$D$-$EEET$ D$D$*$趏EEET$ D$D$/$腏EmEET$ D$D$%$TE<EET$ D$D$&$#E EET$ D$D$^$EEET$ D$D$|$EEET$ D$D$S$萎ExEET$ D$D$R$_EGEET$ D$D$Q$.EEET$ D$D$P$EEET$ D$D$O$̍EEET$ D$D$N$蛍EEET$ D$D$G$jEREET$ D$D$F$9E!EET$ D$D$U$EEET$ D$D$T$׌EED$ D$D$~$誌EED$ D$D$Y$}EeED$ D$D$!$PE8EE T$ D$D$F$EEUT$ D$D$?$E J D$$s EED$ T$D$ $~EEt E@UBEED$AT$$`E$n\ EED$ T$D$ $E ED$ D$D$ $͊ENRfNR  RfREEEL$ T$D$R$VE> , RfREEEL$ T$D$R$EfVRE@ EEE$Ox EE D$ D$D$3$艉EEPEfPEPEPS D$ D$D$%$?E' D$ D$D$&$ERRfRR ED$ D$D$$ӈEPRfPR EHE E@L$T$$谌Ex EX$EHE E@\$ L$T$$E9 EPE@T$D$$BE EH$EPE@L$ T$D$$藋E EE E EE EE EE EET$ D$D$L$vE^ EET$ D$D$J$EE- ED$ D$D$I$EEET$ D$D$L$D$ ED$D$F$ʆEED$ D$D$!$蚆EED$ ED$D$F$sE[EET$ D$D$D$BE*ED$ D$D$M$EED$ D$D$I$EED$ D$D$H$軅EEEEEEET$ D$D$G$mEUEET$ D$D$G$<E$EET$ D$D$G$ EEET$ D$D$F$ڄEEET$ D$D$F$詄EEET$ D$D$F$xE`EED$ T$D$/$DE,EED$ T$D$1$EEED$ T$D$0$܃EEED$ T$D$2$訃EEE$du D$$sEPEE@ED$$t E@EPEPE@D$$$tUEPEPE@EPED$ D$T$$誂EEEPEL$ D$T$$rEZENEEAE5EE(EEE f,u$EE T$$EEE T$ D$D$,$ʁEEf,u EEED$ D$D$,$肁EjEf,u!EET$$PE8EET$ D$D$,$EEEEET$$YGE$|oED$ D$D$ $迀EE $u/D$ED$$VtEEQE}tSE}xI}I@Ebfu/E VE}~EEEEE;EtHE`oUT$D$$htGmmEERE$E$wtLEtD$ED$$tEEEE0E`oUT$D$$tmmE;Euȍ;Et Eȉ$EUe3t`[^]U} E =H=HF=E=E!E=D)=F=G,w=K=K=Ito=J!N=L/=M8xD$xD$E$E @$D$E$ED$$) xD$xD$E$E @$D$E$ED$$)xD$xD$E$PE @$D$E$ED$$)xwxD$xD$E$E @$D$E$DED$$)/.ED$$(E @$D$E$xD$xD$E$E @(D$E$ED$$)ED$$(E @$D$E$xD$xD$E$%E @(D$E$bED$$)MLED$$(5E @$D$E$"xD$xD$E$E @(D$E$ED$$)ED$$(E @$D$E$xD$xD$E$CE @(D$E$ED$$)kjED$$(SE @$D$E$@xD$xD$E$E @(D$E$ED$$)ED$$(E @$D$E$xD$xD$E$aE @(D$E$ED$$)ED$$(qE @$D$E$^xD$xD$E$E @(D$E$-ED$$)D$E D$E$DVU8EeE1D$ D$D$$1vxxT$$uD$$xRtD$$dD$D$$dD$D$$薾D$D$$f$"$xVu+xT$$VD$$xsyL$T$$!$MBUe3tSUD$E$qÐUE] ƒ$!Í&UE] ƒ"!Í&UVS0 5  @  tt5 [^]Í11uBp@$50 8yԡ  0 $[^] 0 둍UVS]]tC 0 0 x[uԃ㍴& ${ސu[^]f UVSIuu )[(t!4$D$u[^]Ít&1ۉt$$ yNq[^]Ðt&U10 x@ t @ÍD$$Hyq0 @ ӍUWVS,U!fÉ$Ut0\tQ0 yס $RÉ$UuЋ0 Ƈx\ tC ,[^_]Ít& 0 xiv $, ,[^_]á $D$뢍&'U(]á0 u։}υx: 9t0 xG t. ]u}]Ðt& $S뼐, Ѝt& $T$\fU蝺UP%Ðt&U}UP%Ðt&UW~V$n 0 $ tD$$hyn0 Ɖ4$n^D$ D$$膹0 0 \  tD$$yUn=0 _r"t60 D$D$y$T$ cD$$zn50 A$0 0  "$G0 ң8x t!0 y $: u߃^_]Ð $jD$$yDm& $^t& $˷D$$@zl&& $蓷 ${" $cUS]ɷX_ƒ Ѓ[]Í&UWVSTeE1 P,Pd[ P24$D$贸t؉t$D$ ~D$D$<$\T|$B$跷tD$ PD$lz$D$T$~D$k[Xt&Ee3u [^_]tUWVS,U$á0 0 j0 u C8EC$C}}1ɋu nމM t&tR(@(EÅuM؉ $k}C t[U 1]EH <$Mߵ$jM܉1M|$A 0$[(u]CS0 C 80  @ ~D1}t&9~1@ 9@ u$~D$i0 9ҍv,[^_]D$$~i}&UM܋$zD$iMu1'U$iUU PUP P Í'U(]]uu}} $li$ P xp$ t+~ th~ uf]u}]f~ tؿ tȉU ]Ezu}]]ft&@ U(}}]u<$pD$;4$yt-C0 C |$$8e]u}]D$f4$ȳuD$ 4$贳uD$=4$tP>t#!tuߋF$Ƌ@D$ D$t{D$$9D${D$$!FD${D$$D$ FD${D$$D$ D$tD$$˭[^]ÍUSE $CD$D$D$ E$}[] U(]] uu}}tt$C(<$D$PHt]u}]ÍvP9uD$D$<$D$ st&< t< t<\tt& D$$芮ut$ D$D$<$蚬D$D$<$D$ zE'UID$D$E$ÍU tIf=t<$ t31ҍt&x@ utD$D$E$Ð $ uÍUWVS,$ }tZ1St7C gDD$ D$ T$D$<$r[ ut,[^_]Í&<$D$D$@,[^_]UWVSCы}0uD$D$D$ E$U5[ U؅u¡ $ EU܍P}8t<ֹ8t ֿ(Ƀ]@ uU܅vR uD$ʀD$E$v EEfC}tuƹ8tYƿ8t=ugD$D$ڀD$ DΉL$ M $؟Et&[ m$ tc g&[ tISuCED$ D$T$DljD$ E$h[ Eut&]tYD$R D$M $6<[^_]Ë$ tEp}w<1[^_]ÍD$٢ D$U$ݞ늍v$ UWVS3 t3 [^_]á t&Pt ֿtu@ u[^_]Í&UWVSLEE؋E EԋEE܋ED$D$D$ E؉$ HEC%S2uvt"u u$ECp@< ut&< t< t4$ڞ$St$lj$<$蹞D ut& t t|$E܉$趟uRMu{UEt=CD$ED$ED$D$D$ E؉$ۜEt&[ EEHE EL[^_]饜t&D$D$E؉$腜e&UWVS#Mԃ-M/1Ҹ*c50 [. .3-V->+W+*1Ҹ/p50 &G&CCB!N=x|F|]MԃMA@?SQ=T>?O=u<H><H50 -0   RP=]U<L::'MD$ D$D$$FMԣ\f [I]`+ufJR0 Ex = $C$Fl7$k8Iu [(ty$D$͐u9 $Žh-D>-0  d O6&@ zU EEv(EF$@$D$uՋUB U܋ $L$MMԅtu (G$Mԋ@ $T$UUЋMԅuѡH T$0 D$}$DT$ D$0 @ $~D$BG$@f$6C,  $T$W,  $-D$0+~.vtP1р|1.t>}N@ UD$ $uUB U܋ U$,~D$A0 E롐t&UVS t89u6:u' ƀ  [^]Í&`9:a P   [^]Íơ=~5 [^]T 9:T   D$  $蔌 [^]Ív(t`}u[;tS=t&tFt>t6}t1vt&$tҍt&t't&9fu Jt L=ã}v3|@ $f++f--f<<f>>f>f<f>=f<=kf==Vf!=Af&&,f||f! f!!f?f??f=f::f;='t5@D$ D$D$D$$Ga@D$ D$D$D$$,t&UWVSL] tB] ufC$t,f86t tD$$1O=C$@H [(uƋMxEf@ 0 x,D 4 } t fu60 0 yԡ $蘇 ~̃[{t2 tD$D$Q$U$fD$<U0 fzE8U܋T$D$ D$D$D$$ Lj  !%tDZE0 Exf+Sс #g t&tp. vt`| v &t@E0 y $.v{tk}u΃vtnˍ&EԉUD$$6;EԋUЃ#Nu#ډ뇍v0 1tgvEfx !%t¾DQE$ ;D$ E؉$.ItdUf1U&[(tC8E|$$u߉|$$'8U؋E SU܉C8SC N$,|:U؉ËESE C= 8U܉sC ISC(I]t/UD$8D$T~$D$ E܉D$߃EL[^_]  tb8D$ uD$D$D$E$ D$ŅUfz$ B  ! t€DЍAE҃-$C9CD$ $h$P9$ E9U0 D$ HD$D$P0 UD$$܄UJfBBH$U1UE u%]Í'USEU @t f3t=f6tH []Í&RfztH ˃fzX tك H []fRvH ˃X v H ׍t&US]D$?$誁CHtD$0$D$艁CDtD$$D$hD$$D$NC~6D$D$]$.D$ $[]Ít&{ uf&'UU E f~Dn@v€&valuf@e @1]Í~]ftvvushorf@t @]Í&(uproc@type@]Ít&ubit f@ @]bytef@ @]Ðstruf@ct@]Ðchanf@ @]Ðmtypf@e @]Ðlabef@l @1]Ít&unsi@gnedf@ ]Íint f@ @]ÐUWVSJeE1uf[3~DuFft"ftfftffuƍF fx=du NH  tf=^Ru8D$j$D$~d@ $D$@HD$7 $D$p~D$,$D$ dD$J~t&Me3 U[^_]Ðt&f@t"f=f t&fv l uCF4t21׃sD׋@t H ruhF ^4$v1DžPHTvTA4t 4@1f19p @˅uuC uˋP HD$$ҺMD‰D$}vDPDD$D$4$|TDx4zL t&tq9w uD$$D$|GtD$>$D$o|Gu3~D$p $M|uLD$D$E$|f=^R,0 F D$~${k}&'USteU1҉D$$1t\$D$${Ue3u Ĥ[]1}'UVS]C|u[^]ÐD$ $${CDtD$$D${D$$D$zCD$D$]$zCf@fC8$D$D$$zSDD$$kzCf{{ D$ɋ$6zf{@CD$ދ$D$zD$ $y[^]Ðt&C@8D$$D$y<{ Cf@S81BvD$ҋ$|yf{@FC8;@(1҅tt&@(uT$D$ $6yC8p(f=t;OF(D$ $xv(f=uŋFD$l$D$x뮐t&CHtaD$$D$x/f؉D$D$$~xCD$$dx)&D$$Dx&USJt&$[u[]ÐUWVS J}t: v[(t)C$@<$D$*zuރ[^_]Ít&1[^_]Ít&Ut!u&$T$yÍvɸu1ÍvUJD$$D$ ED$.J UWVS,M0 ɉEtA0 A8 Jۉu&‹B(uJ(Rt&H C$xfGD$ D$D$3$-G8C$@@8p[(t_S$tBtf:6tvD$$,C$@fxxP89rt$PD$)[(uE0 ~D$$|+,[^_]ËJ$u뛅ɉˉ JE0 Ս'U8ur]É} P(v]u}]Í&D(t^=J $MT$UwUMu |,븍t&T$ L$D$$Du$D$(=JfUWVS tPƍ&^$u7&f@t:[(t#CPfu@<[(ut&v(u [^_]Ð UWVS<} ufXRu J@t& 0 MԋJRD$$ 0 8'Eԣ0 [(t[$,@*VPS$xP$JPJP(S$JBHftYf@w[(u<[^_]ÐVNtL$ D$D$$s@[u,[^_]Í&UW1VSl JEeU1ҋ] ɉEtlpHI(tQA$9pu@$t1҅tt&@(tك9uP$=3Y=6oI( ut&   !EuĉD$]ԉ4$smUB$D$ڋ !%tDJD)څ~B| u8vH u!uEe3l[^_]ftt$$mtҋE$U  RHtL$\$ D$D$$6kUt$D$$D$ knB\=CGB@7E$lUWVS<JK}uۉEuJf[(=Ct$$luE D$E D$<$K jJu[(Ct$$luD$ D$ C$fHRD$<$D$CfHRD$F D$D$ <$iD$D$ C$fFRD$ <$D$fFRt$ D$D$<$Ci[(3D$HD$<$ iE䣨K<[^_]Ð&U]]eE1U }}u tu(֋Ue3]u}]Í&@tӃt|tuV‰9t\$]D$T$D$ D$@D$$j\$$d$q&t#t.111럍ʉȉ됍&Ѓ{ft )!Љ\UD$$UifUWVS,] uu;VHt$T$)jtMt&C$4$D$[(tbf;6u{EUT$$iuƋGHuFHuC0 C$8ED$f3C,[^_]Ð&U8]E ]u58}=0 D$$胔1tf{t,C tE=0 58]u}]Í&$ɏD$ffC 뺍C$KɉC ~11҉u։}2C8$D$S C8U܉$辽U܉9s~.f{@uNjTuS $U-YU܉͍u}(t&U8uƉ]}X@$$QCfu/ Pt,D$U$D$yUusCftQT$1U$pUu]u}]fCD$C D$C$;΍&D$\$4$|Y믋D$$D$6e듍UWVS<$NUJt gffff3FftNHt[u<[^_]Í&VDuf=(tftftfvtf=f=N1҅~]"DP9F}/;t'9^Ff@ Dtǡ$NP$pZ.ED$$D$)d~~ t\$D$]$dD$ $c1f~D$ED$$RD$ $cD,F "L;u7=2D$ FD$D$D$$;e1Uf~D$$LN u50 EUV EE)U)‰Ѓ0 4PɃ=T LD$;D$$bD$ 0 D$ĒD$4$VWD$6D$4$9WD$̂D$4$WD$΂D$4$VD$|D$4$VD$D$4$VD$ 0 D$D$4$VcD$ 0 D$D$4${V>D$MD$4$^V!D$D$4$AVD$ 0 D${D$4$VD$ 0 D$D$4$UD$ 0 D$VD$4$UD$ 0 D$ZD$4$UpD$ 0 D$D$4$UKD$ 0 D$~D$4$cU&D$ 0 D$D$4$>UD$ 0 D$D$4$UD$D$4$TD$iD$4$TD$D$4$TD$B D$4$ThD$D$4$TKD$ 0 D$D$4$cT&D$D$4$FT D$D$4$)TD$ 0 D$ӒD$4$TD$ 0 D$ܒD$4$SD$ 0 D$ D$4$S}D$ 0 D$CD$4$SXD$ 0 D$KD$4$pS3D$ 0 D$5D$4$KSD$ 0 D$D$4$&SD$ 0 D$tD$4$SD$ 0 D$VD$4$RD$ 0 D$D$4$RzD$ 0 D$@D$4$RUD$ 0 D$D$4$mR0D$ 0 D$D$4$HR D$ 0 D$D$4$#RD$ 0 D$̓D$4$QD$ 0 D$D$4$QD$D$4$QD$ 0 D$D$4$QZD$jD$4$zQ=D$ 0 D$D$4$UQD$ 0 D$D$4$0QD$ 0 D$D$4$ QD$ 0 D$>D$4$PD$ 0 D$_D$4$PD$P D$4$PgD$ 0 D$D$4$PBD$ 0 D$D$4$ZPD$ 0 D$OD$4$5PD$ 0 D$D$4$PD$D$4$OD$ 0 D$uD$4$OD$ 0 D$D$4$OlD$ 0 D$D$4$OGD$ 0 D$ D$4$_O"D$ 0 D$7D$4$:OD$ 0 D$(D$4$OD$ 0 D$D$4$ND$ 0 D$dD$4$ND$ 0 D$ܑD$4$NiD$ 0 D$ґD$4$NDD$ 0 D$ɑD$4$\ND$ 0 D$D$4$7ND$ 0 D$D$4$ND$ 0 D$,D$4$MD$ 0 D$#D$4$MD$ 0 D$D$4$MfD$ D$4$MID$ D$4$iM,D$ZD$4$LMD$ 0 D$dD$4$'MD$qD$4$ MD$sD$4$LD$WD$4$LD$TD$4$LvD$ÁD$4$LYD$QD$4$yL2f/t&%t&?<4<4D${$F4$D$ $FD$$Jt&D$ PD$D$C$U*JU>t&t$ fEEH@CACt&cR7fC*P(P(D$($ECD$T$D$Et&?D$ܜ$xEvD$$HXv0 C8CvtD$$@41ɅE&'UE D$ D$?$D$px1 UPUD$D$p$T$ UPfUWVS]upfCt$$hYE D$ D$?$D$pD$ D$D$p$r$ GD$ D$D$6$=pD$ D$D$q$X|$D$ D$O$[^_]ÍvU(uu }}]Tu tLN$yxãTN@Ȕ@ ˔4$aD$NCTN@f!(@t$TN@$DTNX$Df)TN$D$K\,M]u}E]Ct&]u}]ÍvLND$y$CPNt ,MLN$D$PNڍt&'UD$$.BD$,$BD$Δ$BD$\$AD$$AD$$AD$؞$AD$$AD$8$AD$`$zAD$$fAD$$RAD$$>AD$$*AD$ $AD$h$AD$$@D$Р$@D$$@D$($@D$$@D$$@D$T$v@D$$b@D$̡$N@D$$:@D$$&@D$4$@D$d$?D$$?D$$?D$$?D$$?D$H$?D$|$?D$ԣ$r?D$/$^?D$$J?D$I$6?D$$$"?D$c$?D$\$>D$$>D$$>D$ܤ$>D$z$>D$$>D$8$>D$h$n>$Ð&UE1vD$0$3>t&$+  t'( EЉT$D$$=Í+@N  @Nt߅( EЉT$D$$=Í+1   1 t( EЉT$D$$P=Í+0   0 K( EЉT$D$$=f+0   0 ( EЉT$D$$;T$$,M \$ !t*$<D$D$ D$D$$_:$8H;"T$,$D$,$ hNf@$ f@$%f@$+f@$*f@: $8=LNttPN$t8LND$X$8 -LNH$'0 8Hd: $88HG5pNj}lu? u#1 w0 t T$$\$T1$<e3D[^_]Ð$Л u  ODB 6fXNփXN NvT$$D$ D$$6T$$dTw&$_&dNG&D/&T$$`LD$ >$ L7T$$T$$D$|D$$05$T$$  fT$$D$ D$$5T$$֣yT$$ 5T$$YIDHDt& 2f "fT$$g5K[T$$DXt $D$ D$4${!T$$ fCT$$$T$$D$(t&T$$D$ D$$4T$$։D$,hW& Bf h%t&T$$D$ D$$4T$$֣X&։1 t&&lN& rfTNbf@Rf`?& @*fl&,&(&&`N&&0fw&pN_&\NG&֡XNXN N cLu  =t D$ $I1$0*$18HTNt)D$9$0$D$|D$$0D$D$$w0$z1$Fw `NzD$D$O$$t&v$<D$D$$1T$$D$$0T$$D$ D$$0T$$֣Pw&`NL$T$$D$D$ D$o/T$$$0D$D$O$$0DH$OH;0 D$OD$ߕ$&/$LN$WD$\ND$ߕ$D$.$,MT$$\$D$ئ$D$$.$RT$$g\ND$$D$r.T$$40D$$̠$0UOUM  Of P]ÐUVS ] ,1 D$HD$ЉO$)-OD$pD$$-OD$OD$$~-OD$D$$a-Ot$D$ D$bD$$8-OD$kD$D$ O$-OD$D$$,Ot$D$ D$D$$,Ot$XD$D$k2D$ O$,OD$D$${,OD$D$$^,OD$D$$A, [^]fUWVS|E }MUEơOEE)E )Ӊt$\$ D$D$$]]]MU+UOt$D$<:|$ D$$+MOM|$ D$L$D$$M+MO\$ D$L$D$$X+Ot$\$ D$D$$3+OE\$E\$E\$ D$D$$+E§E OE|[^_]*&UWVS|EUEEE,1 UE ʋ}$É+]+u D$H)¡O9D$Lډ$]]]w*t$kE2D$D$D$ O$N*\$kE2D$D$D$ O$%*O|$ D$ҧD$$*OD$D$$)OD$D$$)OE\$E\$E\$ D$D$$)EE OE|[^_]v)&'US$]y`x[O<fu,1 \$$D$D$ D$?D$>D$>D$.Oy$[]Ív'U(OD$HD$$(OD$8D$$(OD$OD$$(OD$D$$n(OD$D$ D$bD$$A(H  OtD$OL$D$ |D$\D$$'OD$D$$'ÍUWVS|} eE1u]P$k2)1ҋ ,1 D$ 1t$Eٽ߭ xt$t$ f$٭\$٭ٝ)щL$;~مD$!ٝ$%'م?‰ٽ ,1 D$T$t$D$  f٭\$٭$)щL$5OD$HD$$P&OD$8D$$3&OD$OD$$&OD$D$$% ,1 D$bD$D$ O$)щL$%O\$ D$D$$%OD$D$${%Ee3|[^_]ËE$]4$CB<w%40H`Ot&L>?fD$?ٝ$2%مt?t&t?1D$ ٝD$D$$&مux; 1 }O24$ٝ%$%9مw3ٝ$yOم44$ٝ\$%?1م%1эAfUWS OD$4D$OD$D$ O$#= 1 x>&OtD$ D$D$d<$pyСOD$ID$$##OD$ D$ED$$"OD$D$ XD$D$$"OD$dD$ XD$D$$"OD$ dD$SD$$"OD$aD$$b"OD$yD$$|T$\$ 7"=Ou}uh1tft(1 zu ؃ [_]ÍvOT$D$\$ D$$! [_]fftUWVSLkO2= 1 Ãx>4fO0tD$ D$D$$hyС 1 $1 9| P$1 pE1E'vEԍEܡO,1 ;EwO 8fUɍ4=,1 U,1 ))ơOU H8f99u҉T$VT$UD$D$D$D$?t$ P$c;5,1 |O8f POUԋt$D$ O\$D$8$]ЃE9$1 4O<f1Cޅt+Ë|$$uCCu tCF[^_]ËCKv'UWVSKu} u5t&[t)t$$3u} E[^_]a[^_]Ð&UVS0U eE1] Jt$t usv9Ӎvtf@(u\$D$ D$D$4$eD$t$$;Ee30[^]Ív@$@04$ =vt$$6ut&t$D$ D$D$$D$\$$;lTUVSKuu )[t!t$$uC[^]Ít&$ T4$R$?Ct$$bKCK[^]Ðt&Ux]]eE10 uu }}ۉtPC0 f=6f=3tf.tND$\4$~D$\<$n0 Ee3|]u}]ÍD$4$0D$<$ |$t$C$$%띍vC4$D$C<$D$K$4$f[]@4$G$D$t$<$f[|$t$C$$<$f]|$4$Y4$T$4$C(|$t$$D&4$Hf1CuD$ D$ D$D$4$t$<$iv'U$UOPOÉ'UWVS}u] uKFtDfx@u=&f.f=6 ƒ҉T$C$4$D$[(f= f= f=/f=1ff=0f=2SҐzfz@oD$ VD$D$$v>D$ LD$D$$NtBf;3t_CAfx@v3D$ VD$D$$ f[^_]D$$bD$$M닍&'USE];D$E $-E;E ][]fUWVS,E uUEF UOM=L DPE [ {9u~ tE9C|ދCt׉T$D${$'}t/MLPA)ЉD$ D$$D$~ED$ D$$D$s1D$Ľ1$C T~D$$C S<ljT$SD$$R9s D$ $.9{mE  E,[^_] ~ D$$D$,[^_]fUH]E] eU1҉uu}9t  t @t@tEe3us]u}]Ð}D$<$y\$d$g\$|$t$D$ D$D$$]\$$&'UE@$$Le= wtP1Ív1Ít&UE@$$ e= wt@f1ÍUE@$$d= wtP;PÐ1Ít&UV1S]t&$@[(ƅu[^]Í&'U1WVS]S87=O O5TuC8f8@tDE[^_]dt&=O~D$$ҳPC8f8@uÍ&$$ǡOOfC8P@(W$ ODPOwG W$SGG $BG4$7GC8X(t21"f=t?W[(t SuOG =O<|[^_]É$Pt$D$G$-뮐B0 B8$D$&U(eE1 KD$D$E$0Ee3uf t&'U8U]u}B$U UttAU]u}]=t&*u׉\$$U5U: uC: uC: t뚍v]u}]Ít&'UHuƉ]^eE1}Cf@(f=6>fD$D$$;h F$@$tJ$aD$ ]D$D$$D$ D$\$$; Ee3]u}]Í&{Ht$;$!D$$D$ F$ƅ|$ D$\$$D$|$$;u D$$;D$V $讘D$$;D$, &D$D$$; : fUWVSÁ\EUeE1C$$~_Ou *fRt!;uUe3~\[^_]f=2 u )D$$8[BU <D$D$$rB 9E H8[D$ $2 t& L :[C$$K^dD$ D$D$$D$KD$D$ $U $3Ctf<"tuD$Ct$D$($D$ BU <D$D$$B ;E 7LD$,$ Wt&D$$D$w PtBLP@)Ѕ~21t&D$$A PLP@)9|D$ $;D$;D$$(?D$ D$$4PLP+8P)…~;1t$D$$m4PLP+8P)9|D$ $A2 ffC$$}[dD$ D$D$$D$%-C$$=[D$1$D$ D$;}D$;D$1$$lz&D$$lN&D$D$]$dD$$D$U D$D$$;{:[BU <D$$ B 9E  K8[D$;$rXؿ; D$$;8ʺ]E‰D$(D$Ľ$\ P1ۅbLPX)QD$D$Ľ$;ND$ $ZD$D$ $;JfUWVSlUB$$X= SDP҉CEEp(:K /1#t&f= tbv(K 9V$f=3uMC;BtʋUBtt EM;K|1l[^_]ÍMCEB$$W9E{믍vMAWOF &}_(u9&f=3t3$D$C$$[(C$f= uD$$@蓵1& t*9{ tDPD$8$D$=@Pt}O=OMCUy(EC u ME1MЋM M̍vt } tQ @PuGDP;|9U 6[E0C\$t$$cE]t&}ubG$f3tHf tAMK S $T$袝G$$D$ D$C$My8(t C 9M ҉tOuKl[^_]ø D$D$ܱ$l1[^_]Ít& t@PuDP;|;s }t&tEUx~[t$1҃\$$cE;s |ƋHvN @PuDP;|D$Mĉ $Uzkt&EЋM̉}ȉE܋EMBt&K S}؉ϋM<3t&]u}]Ë$D$^f>3uf?3uӋF;G~ˋCu]}ExE ]&UVSOu -t&[,t" tC0tf!fv[,uރ[^]Ë@0tf:.tQ qV0t:2f>t)tR;PtD$$"聢뇍&QxF0t&kvUVSp$ueE1辤D$ 9D$@D$4$áPPPD$4$R~ PCEe3 Pup[^]v'U$>UU PÐUWVS,8E}_(1t79tff;2t\Rut&[uG(D$4$yG(f-f w$B qEU9Pt z0r,[^_]ËG$FԋB 8S_$t'[u뮍&'U$.PT$$MɣPtP2 Ív'UWVSP} tD$V1fUWVS9tLtHƋtf8t@^$u%t&[tPu[^_]Ðv09tuD$$t @;2 }P@0 81믐&UWVS,PEU ۉEU}E78v4$D$uC<$D$t_[uЉ|$ t$D$$|U$QD$}9=Ju=E E,[^_]BfCtItCf:tXH@&u,[^_]Í&UEE ,[^_]靝t&t$$d蘟Cf:u$4ƋCPxEU؉}܉$FC@0F0PFPOF,{5OD$ D$D$3$诠D$ D$c$D$菠Kq0}؋B$xz}@xCz0:h&UWVSP]U M ]UU MU萋M9HuRU ta}t*2t;ut2t"]t!2t @u1҃[^_]Ív[^_]ÍUWVS,E11!t&fcC01}Ë3fw҉UD$$Uuƒtxf=tof=ti  uuE9tdEH9tZEH9tPC0уKB0u,[^_]ËF$_f83TxJivC0ٍv6tC$&D$蜔CfxFx xD$ D$D$3$@D$ D$D$3$ĕVRP|$߉D$$fUe3~L[^_]Ð$iD$֓\Vfz@t$D$贓Vz8tO~G(f8u @(tf$BD$~VT$C$D$ D$D$3$@D$ t$D$ 4$跔$D$D$ ]D$D$U$m1fBD$ D$D$6$,PljL$ D$D$?$$k$|$D$R<$T$ ѓD$ D$c$D$豓$D$$Ot$D$r4$D$ w$D$$t$D$s4$D$ G$C$D${U8Puu]}u:2 @PPC CCJ؋u]}]Ív~D$$T81ɺtH@|$L$ T$D$$ wN$&D$ $D$0$D$X$t&$dtP t&SuD$$0.͍t&D$v$\fD$$DD$M$0D$ $D$$D$($D$5$D$G$D$ $D$Z$D$i$vD$z$tD$$`D$$LD$۶$8{vD$z$D$$D$$D$ $#vD$z$D$$D$$D$ĺ$vD$z$lD$$XD$$DD$|$0svD$$T̍&UWVS]D$ D$D$3$0@\$D$ D$+$ \$$D$?D$ $]D$ D$D$$Ď$G$7] t,D$ D$D$$|$D$ D$D$$PIC$D$ D$D$$$ FD$ D$D$$D$ËG$PD$F$AC D$ D$D$$蚍S P [^_]ÍU(]]uu}} D$ q$t$|$|$ \$$D$?8$$t$ \$$D$R D$ D$c$D$$Tu]}E ]]i'UWVS,]} D$ D$D$$$荌fZRf?"ƋCFCF<$<$$f밍UWV1S Ptcs tHE8&|$$u#u4MFQ$T$otvLuċU" Pp f[^_]Í&'UWVS,}GW$0 G8B$$#LPЅNP 4P58Pf]$Pt.)u419u&9[$u)ЉD$ G$@D$$D$ G$ D$D$$$P54P8Ptb)Ɖ}[$tIU0B$@4$D$ u׉t$ |$D$$[$ut&1,[^_]ÍG$@L$$UMUM܅uxw: uP:  PG( P_$G$4$UG<$%kUw_$ PkB$17t&)։t$ L$D$L$$vD$F~Q@: `C@,[^_]Ív'U(uu]}F$ËF$$!$ljD$t3Cf=tBS{ $T$U T$`DPC]u}]Í&E D$\$4$D$ -ʍt&'U(uu}]F$^$ $&tfxt@|$$1tCD$C D$C$`]u}]fD$D$4$TfUWVS,J P= PۉE3t{FHtt$T$Au^NxWFftUWVS,=tt|=,PtavwtPt&F$t9Qt&X@(Kуtf8,JuX$@([Kуuv(uu6,[^_]f=NRt8= R~/D$h$D$$ޮ\5@TT]= t=tD$$葮=tD$$t$P P1 PEۉEIJCttJR 0 8 DP9_DPS0Ptt @ U$a)DP;|1 $t( P9}A'G 5 P945 PENj X{5(Pu D$ $艧 t Lt $9I$(D$ $ȥA$M$MI(A$M$gMNjA($WA$M$4MNjA($$9A$M$MHA(H$9A$M$MNjA($)DA$M$MI( $nA$M$MNjA($v!A$M$\MNjA($L1A$M$2MNjA($"A$$pA$M$MNjA($DA$M$MNjA($9A$M$MNjA($v9A$M$VMNjA($F9A$M$&MNjA($9A$M$MNjA($9TA$M$M;A(މ$E$A$M$Mtԍ=zQ(f= M$9MNjA$M$&D$|$$MA($$MD$A$$B $C{ $ӕ $[=$Pu=t&$.D$G$Zt!5tjf=tqwFf.t/f@t&tv^$uf[t9$t[^_]Ít&f=!rf=#w\G 0u1[^_]Í1 @P[^_]Ív4P P+8P9B[^_]Ívf=$XF$0똋^(u "t&[t$tK> df=wOf=(frtXfsfc R<$-R f=f=?uōt&<$KfR R<$-Rfr D$ G$$sjW<$vtM@Pp R<$ -R  <$ UWVSLEeU1҉E x$@0$; "4$1PF\"t&t+ƅD$$;4$ 9}l%u%[{G$$(cD3D$$PƅqfD$;$J$;v=vD$$%QUe3L[^_]ÍvDP;룐t&nt$D$ $4P+8P1Ƀ1X$XD$t$T$輓{f=#f=!f="f.cA uQ(t    R=RY(u _v[tP$t ?-RB$$`RRf=f=sfctvrPfw 0P5@P fr{ $t&K$ 0PS0t$D$$$ pD$D$$(D$ $虑8@P($D$ 0PD$S$T$:#‹D$$  @PP0f= df=YfFB K0@H0$Ee$S듉$,D$e$YpB($o\ tD$$-Rf=%cf=?eNKD$$轏D$D$$&D$$舏X(u7hD$D$$&D$ $K[t3D$Ľ$0f!fw@ D$ $B0$ot$D$$Ȏ0D$$诎t(Pt!@D$ D$$D$聎D$ $mfD$ D$$ D$K1$0!D$$1$BD$p$ٍ1v'U1S]tC$t []ÍvE[]U1(Mtdt&tf.tAf=$tȅtE=ɍt&Í&A$9t܃tщ붍A0u뻍D$$8EBEÍUS]KD$ D$$葌~i~AKD$aD$$dKD$fD$$G[]ÐKD$ZD$$#뽐KD$TD$$띉'UWVS<OeE1}D$D$<$踋D$D$<$蠋D$D$<$舋D$ĥ D$<$pD$ D$<$XD$D$<$@D$GD$<$(D$D$<$D$D$<$5OUfD$ D$<$D$ ɊD$ D$D$D$$D$ D$ D$<$zD$&D$<$bF ~s15&\$D$ D$l D$<$'9^ ~:F<uƍ\$D$ D$H D$<$9^ D$9D$<$ЉD$ D$<$踉D$JD$<$蠉v D$GD$<$}D$KD$<$eEe3u=<[^_]D${D$<$6D$ D$<$ UWVSL}uEtxWUǍ] 9}T\$ \$\$\$\$\$ UD$4$D$褈D$ D$4$茈9ߋUUEuL[^_]Ð&UKD$ : D$D$$5ÍvUWVS\eE1KD$ 3 D$D$$f=ROD$ KD$]D$$O1D$mD$D$ K$蕇OD$D$D$ K$l5Ot&P@ 9LuKD$D$\$\$ $ F \$ D$D$D$K$NOF\$ D$D$KD$$ņKD$r D$$訆K\$ D$D$$臆<$KD$D$$bKD$D$$EV 16 6 D$ $j;V 9~XF1 ~@ = uK\$ D$\D$$豅V 9fVOFD$ D$D$ K$yD$D$D$ K$Uv KD$ D$$-<$mKD${D$$KD$D$$KD$ 4 D$D$$KD$D$$詄KD$ D$$茄KD$D$$oHPD$ 4 D$D$K$>KD$ D$$)KD$D$$ KD$0 D$$KD$D$$҃=Ox81ۍK\$\$ D$T D$$蘃9O}СKD$x D$$sKD$D$$VKD$D$$9f=VR8KD$D$$KD$0 D$$5~31ېt&K\$ D$D$$輂9ԡKD$D$$藂KD$ 5 D$D$$j5Of vD$ D$D$D$$胄^REljD$D$D$D$ K$N f=TR KD$D$$踁KD$D$$蛁KD$HD$$~KD$D$T$T$ $SD$ D$D$D$$膃F ~@1ېt&K\$\$T$ D$D$$F 9ljD$ KD$ D$$辀F D$%D$D$ K$蚀KD$P D$$}KD$?D$$`KD$ D$$CKD$FD$$&KD$HD$$ v KD$ 5 D$D$$Ot@&1sD$D$D$D$ K$[ uǡKD$ 5 D$D$$bOtBv{OCD$D$ D$D$ K$%[ uơKD$ 7 D$D$$OTfD$ D$D$D$$RZ E‹D$D$D$D$ K$_~x  K$8 D$K D$$-~ $8 5K@ Dž(8 1ۅ~]t&\$\$ |$D$4$D$}D$ D$4$}9u5KD$qD$4$V}KD$D$$9}KD$FD$$}KD$!D$$|@KD$D$T$ $|D$D$D$ K$|D$ D$D$D$$~B ~?1ۉ֍K\$|$ D$KD$$(|F 9щD$ KD$.D$$|KD$ D$${KD$FD$${KD$HD$${@ KD$ @8 D$D$$eOt2vD$T D$D$D$ K$8{[ uѡKD$ 8 D$D$$KD$ 8 D$D$$KD$]D$$z5~01ۍKD$D$$z9ءKD$qD$$szKD$ԩ D$$VzR~,1fKD$] D$$(z9RءKD$ D$$zUe3 \[^_]áK\$ D$<D$$yfK\$ D$LD$$yftKD$$D$$vyK\$ D$/D$$UyFKD$D$T$ $)yD$D$D$ K$yKD$D$$xKD$D$$xD$ D$D$D$$zz ~b1ۉ׍K\$t$ D$"D$$SxK\$t$ D$3D$$+x9_ KD$ED$$ xKD$^D$$wf=TRD$ D$D$ K$wKD$ب D$T$ $wKD$ D$$qwD$ D$D$D$$yV 1ۍ&K\$\$ T$D$ D$$w\$\$ D$tD$KD$$vD$D$D$ K$v9^ rKD$FD$$vD$D$D$ K$avD$ D$D$$D$xD$8 D$D$ K$ vKD$D$$uF ~g1ۍ&K\$D$T$ D$$u\$D$D$D$ K$u9^ KD$FD$$euD$` D$D$ K$AugKD$FD$T$ $uKD$[D$$tKD$D$$t=~*1ۡKD$D$$t9ءKD$ D$$tKD$D$$it=~21ۡK\$\$ D$D$$6t9СKD$ D$$tKD$ D$$sKD$D$$sKD$'D$$sKD$ED$$sKD$ D$$sKD$ D$$csKD$ D$$FsKD$ D$$)sKD$D$$ s=~p1ۡK\$ D$VD$$rK\$\$ D$ D$$rKD$gD$$r9KD$uD$$vrKD$GD$$YrKD$v D$$$C@US]D$$Znt2CHt7@8t$PT$ @D$$D$$n[]ÍC8Ǎt&'UWV1S,]}E Etv9{tqft&wf.,[^_]fff$u|$E D$C$$|Ut@tÁut~D$$8",[^_]fD$$T$$E|E댋C0uGt&'USÃ4B8tfz@t!D$D$$L4[]Í&$U_U~.R8f:@t-D$ D$D$$Yl뺍&B8뚍v|JD$ D$!D$1҅‰T$$luv'UWVSLE]u} EEۉE܋EE؋E E;J4f{C8Kft f8@D$bD$4$pkCD$P D$4$D$ QkD$D$4$9kE؉D$D$ED$ED$pD$4$D$ k}D$C84$D$KE4$D$D$D$ j4$D$FD$jEGE uL[^_]jfC L[^_]ÍUkUЋt&<_tDAuf{v{ t&&E؉D$D$ED$ED$?D$4$D$ iډEEE uEL[^_]iv]L[^_]Y1}ԉ9t&ډED$D$<$D$ ]i9sE؉t$D$D$ED$ED$JD$<$D$ i}ut$D$ED$YD$<$D$ hj>&MvD$$ fE]} uE E؉EE܉EEEL[^_]SvD$ED$D$4$D$ [hpE؉T$D$ED$ED$?D$4$D$ %hD$ED$ D$4$D$ h%vUWVS,UBt{tvJu jf[ta3FHt~ft U $L$*jUuˋNDuF ufu$Uu &1,[^_]Í&'UWVS\E}U eE1m5u$#h &<_tDBuGft*f"f@f=t&/f D$4$u  D$bD$$mfGD$P D$D$ $HfD$D$$*f\$t$ D$T$D$ D$$eD$FD$$eD$GD$$evffffuyt&D$D$D$ $aeD$ D$D$D$$D$g|$\$$3NUe3\[^_]ËG~1t$\$ D$Ъ $D$dt$ t$D$D$T$T$ D$D$$dt$D$D$T$ D$$Od9w^& t&B\$ D$ D$$dD$D$D$D$T$T$ $cD$'D$D$T$ $cD$ $vw\$t$ D$D$x D$$D$Sc3IeUWVSEU EeE1BtWtRtMJtCt&3FHt/~ft& U $L$qeUu FDt#v[uEe3uzČ[^_]fF uftIBUD$ ;D$@D$ED$$dED$Et$$U늋$xUu렍v;dvUWVS,uD$$ D$4$bD$PD$4$aJu @[t9;OHuWDuG uf|$D$2 4$kD$HD$4$aD$L D$4$aD$lD$4$ha,PuQD$| D$4$D$ 8a\$4$D$HD$4$a[tMCD${D$4$D$ `$uD$D$4$`뛍&D$D$4$`D$D$4$`D$D$4$x` Jt8C$@|$ D$ D$D$4$=`[(uΉ4$D$D$`4$D$GD$`4$D$HD$_,[^_]Ë$&UWVSu eE1}tGfft&t"f tEe3[^_]ÐW t7,Ptѐt&tD$4$a[u맍vt&  vtdD$$9ڋ !%tDJD)څ~)d uH uu<$RWHt$D$$^\$D$̫ $D$D$ ^t&  dD$$Pڋ !%tDJD)ڍBd uP t<$qGHt$D$$]\$D$ $D$D$ ]&[ۉT1TX$t%Ct$T$_t%[(uۋT@(Tuvt$<$TkD$~$]gD$~$\/^&UщW1VS PD$KT$$HPD$ > PD$KT$$KD$ `> D$D$$|KD$ X D$D$$WKD$ D$D$$2KD$D$$THPD$ D$D$K$KD$ D$$SKD$H D$$S RRD$ D$D$K$KD$l D$$qSKD$D$$TSKD$ D$$7S1Ҹ s~IKD$D$$ S CKD$HD$$RKD$ D$$REe3w[^_]ÍB@D$)D$D$PD$CD$ K$hR@C  RC$RB@ E=d@t$D$ RD$D$$bT@BH@ 0 8t0d@D$t$ L$D$ $Q@t&dt$D$ ;D$D$ $S@oHPD$ x= D$D$K$=%KD$ = D$D$$HPD$ < D$D$K$=,PuK=,PukCD$ < PD$KT$$[{uCD$ x= PD$KT$$W[{uɋ,Pt3f{t$CD$ x= PD$KT$$[uϡKD$D$$O D$D$D$ K$O R RKD$ = D$D$$y,P9v{t$CD$ < PD$KT$$>[uHf3Qt&'UVS,Put"vD$C4$D$蠰[u[^]fUWVSL=dEKD$D$$NKD$D$$NKD$D$$tNKD$Ȭ D$$WNKD$-D$$:NKD$7D$$NKD$ D$$NKD$GD$$MKD$PD$$MKD$( D$$MKD$L D$$MKD$GD$$oMKD$^D$$RMKD$rD$$5MKD$ D$$MKD$ĭ D$$LKD$D$$LKD$ D$$LKD$$ D$$LKD$GD$$LKD$GD$$jLKD$HD$$MLKD$D$$0LKD$H D$$L=RE~11ۡK\$ D$D$$K9Rԉ]ԡKD$ D$D$$HPD$ 4 D$D$K$|=~bKD$2D$$^KHPD$ 4 PD$KT$$.KD$HD$$KKD$ D$D$$f=\R EK1=HPD$2D$$JK|$ D$D$$J,P}[{uCD$P$T$pxD$Ct$ D$ D$D$K$JUࡴK|$t$T$ D$ D$$I|$CD$D$D$ K$Im=CD$D$D$ED$ K$IUࡴK|$D$T$ D$$aIt$D$ D$D$ED$ K$1ICD$-D$D$ K$ IKD$QD$$HKD$ D$$H|$CD$D$< D$D$ K$HKD$HD$$HKD$FD$$bHKD$p D$$EHKD$FD$$(HKD$_D$$ HKD$HD$$GHPKD$jD$\$ $GK\$ D$ D$$GK\$ D$ D$$GK\$ D$Я D$$dGK\$ D$ D$$CGK\$ D${D$$"GK\$ D$D$$G=dK\$\$ D$D$$FK\$ D$D$$FK\$ D$D$$FK\$ D$D$$lFKD$HD$$OF,P҉UEX‹@K0R$E؉U%t =d$p%u =dD$F4$D$pK\$ D$!t$D$$E; [U؋\$ D$ D$D$K$rEK\$\$ D$D$$MEKt$\$ D$D$$(EKt$\$ D$D$$EE܃xf=\RKD$cD$$DuL1]ÐUz$t&Fxx t%F0 F8F$$D$TED$tD$D$ K$HDFfxteD$D$D$ K$DK\$ D$D$$C(tgf?,Cw$;vD$KD$ t$$36tF0 F8F$D$zst&UR(҉U]䡴KD$D$$WCU1ɋBU؉D$ $D$K~dKD$D$$CUܹBU؉D$ $D$KKD$HD$$BKD$ D$$BK\$ D$D$$BKD$HD$$mBU؋\$D$K$KD$HD$$6BE܋@E=df=\RKt:KD$ D$$AKD$D$$AEԋUD$ D$KT$$蜸=d(HPD$ 4 D$KD$$fKD$ D$D$$AL[^_]ËU؋\$ D$MD$D$K$AE܋@ tYKD$ D$$@UD$B D$K$ KD$ D$$@KD$ D$$@E܋x KD$HD$$l@K\$ D$-D$$F@KKt$ D$5D$$ @U؋\$ D$ D$D$K$?K\$ D$D$$?xKD$l D$$?KD$D$$?KD$D$$t?D$ 4 HPK\$ D$D$$KD$` D$$>~v9JKL$ D$ D$$s>~&9JKL$ D$ D$$+>R ~t&9J ~t&9E RD$U䡴K$T$ ƋED$K$胚K\$ D$D$$z=Rf=R‰tK\$\$ D$5D$$)=4RPfHt4L$\$ D$԰ D$D$K$<RPf,f@Lf@f "KD$D$$<K\$ D$$D$$O<<[^_]Í&KT$ D$D$$<fT$ED$D$D$ K$;RPHD$ KD$D$$;KD$ D$$;<[^_]fftftm$aD$T뱡KD$SD$$M;f5H/KD$ZD$$;XxuRRBIt&UWVS,=d K1D$ D$ D$$: RD$vD$D$ K$p:RD$D$D$ K$J:KD$D$$-:KD$D$$:KD$D$$9KD$D$$9KD$D$$9KD$D$$9KD$D$$9KD$GD$$b9KD$HD$$E9K$KD$D$$9,P u?f9,P EljD$ Kt$D$ D$$8[uáKt$ D$DD$$8=~^KD$1D$$8Kt$ D$CD$$`8KD$TD$$C8KD$^D$$&8KD$cD$$ 8,P'KD$yD$$7KD$D$$7KD$D$ D$ D$$7KD$D$ D$D$$k7KD$D$D$ D$D D$$67KD$D$$7,PwKD$D$$6KD$D$$6,Pt0vKSL$ HP $ dRz[uӋHP dRD$B$O= dR~ 9ZKD$ D$$"6KD$2D$$6KD$D$$5HPD$ D$D$ K$5HPD$D$D$ K$5HPD$D$D$ K$m5KD$l D$$P5 HP~v9}rKt$ D$ D$$5K\$ D$ı D$$4 ~ 9rKt$ D$ D$$4tKD$| D$$n4HPD$D$D$ K$E4KD$ D$$(4HPD$D$D$ K$3KD$HD$$3KD$ @ D$D$$赪=dKD$ D$D$$胪KD$ND$$n3K$虇KD$ D$$D3K$KD$ D$D$$ KD$ D$D$$ RK$/D$D$3 K$2KD$ز D$$2KD$ D$$k2KD$D$$N2KD$bD$$12KD$HD$$2KD$xD$$1KD$RD$$1KD$D$$1KD$D$$1KD$D$$1KD$QD$$f1KD$D$$I1KD$HD$$,1KD$D$$1KD$D$$0KD$D$$0KD$D$$0KD$D$$0KD$0 D$$~0KD$%D$$a0KD$BD$$D0KD$[D$$'0KD$D$$ 03 D$tD$D$ K$/=d1t&Ju |t&[tq3F tF;` uNH$D$lFf@KD$D$$Y/4$ [uflKD$P D$$/,[^_]áKD$P D$$.t&VDOf@ev$D$KK$KD$$ D$$.KD$D$$p.KD$)D$$S.KD$:D$$6.KD$HD$$.KD$ D$$-USÃtKf|~vLf=2f=/f=f=%f~ff܀[]Ðt&f+vjf?t$t&f-tf/fuƍC$t&[C(S멐f=U~f=Nfsf-Ffwt&ƍf*t&sf!ftXb%fvRf뎍܀)ʉ̀܀[]Ðf=YC$܀[]Ívf^6fct&Ѝ&'U$҉t$u۸u$t$]fu;t1$t$]ÐC;BuC ;B uC;BuڋC;BuҋC ;B uʋR$C$tV(C(v돍UWVS0frt]1f?W u ft#R tJuR u[^_]Ðt&f?uN(f93uڋItăfV(1Nt&J$ f t f3ȋR(uofUWVS 0tA&Nf!fv4^$tt&[u9wtv0uƃ [^_]Í@ t&UWVS 0tT9tCFu+^$Ftt u[uv0t9ut& [^_]à 1[^_]ÐU1]]uu t9tt$C$$t]u]Í&t$C($]u]Í&UVSu"?t)C$[(tf; uڃC$1[(u[^]Í&'U1҉E|~D$ $t\ Í'UE)~D$ $\ t Í&=~D$ $\ É'UVS f%tNv-f0fvFf1tVf2u(Ffrt&tfst0f@f t[^]ff/u t&Y$fzu@K(t9I$t2ˋSuḀ D$$ C@[^]Ðt&Buѐt&녉'UtFf8c܀Ѐ̀t&̀Ѐt f@$@̀tfō fUWVS 0v9~C ؀~1;u -;t$9|)؉ ؀~E ؀~1;u /f;t$9|)؉ ؀^$tt&)[u9wt v02 [^_]Ív'UVS,Pu *f[t!t$$Y(uC[^]ft$$ [^]Ít&Uu Í&D$ D$\ D$pR$_%ÐU( ātX ȁuT$ D$] D$$%ÉT$KD$ D$$T$ $ÐT$ D$ D$$$Ív'UU Etf=ZRtN) f=ZRuF D$ KD$D$$Y$Í& f 븍v'UWV1S<} GEGD$ D$D$ K$#KD$ D$$#D$4$ KD$ D$$#M~aD$4$D$ D$D$ED$ K$e#}KD$T D$$>#KD$ D$$!#t,KD$) D$$"KD$ D$$"KD$ D$$"<[^_]1YfKD$ D$$"D$4$D$ D$D$ED$ K$Q"K\$ D$]D$$-"KD$T D$$"9]_v'UWVSÃ,}M~KD$ D$$!Kt$ D$ D$$!C u/sHED$ D$D$ K$n!D$D$D$ K$K!} ~MK|$ D$]D$$$!KD$7 D$$!,[^_]Í&{ u̡KD$* D$$ `USÃt,@$CD$; D$D$ K$ []ÐU,PMu $t&@tP9uxÐt&L$D$<] $h 1ÍUS]҉u'-! &_tDQu[]Í'UWVSu eE1]}@F0 F8Bf=8vd҉T$FD$ FD$ha $D$pR$l $8Ue3~3Ĭ[^_]Ðt&$ D$K D$$|$F$D$$#D$T D$$D$`D$$|$F$$D$D$D$$|$F(D$`D$$w|$F$$D$D$W D$`D$$B|$F$$D$WD$;zD$`D$$ |$F$$D$D$gBD$`D$$|$F$$D$D$ K; 4%<$qDD$`D$$||$F$$D$D$N$tCD$ D$$=|$F$$D$RD$# D$$V(D$`D$$|$F(@$$D$D$( D$$D$`D$$|$F(@($D$D$7 D$${&K; ,f=NRt0D$ D$$CD$Ha D$$+D$ D$$ f=FRúuf=XR>. R~#D$ |$ F$D$ $D$ 5F(11ɅtA]Ӎt&P$f t f3Ӌ@(u܉ڋ]9t VD$ |$ F$D$ $D$4V(?1ɉuΉ}t&f=3t(G$f= uD$ D$$MUD$p L$ B$D$ $D$4t$ D$ D$$G$f83UT$@$$D$`D$`D$$j|$F$$D$D$W |$t$$R1f=FRFD$D$$D$ K; %'́Bf=XR" Rtm~.Rd*D$t D$$D$ D$$R*D$ D$$^D$ |$ F$D$ $D$2غ F(Et-1ɍ&P$f t f3ы@(u߉MD$ D$$F N(EWuΉ}1ff= v(F$f=3uD$FD$$tD$ D$$\UT$F$$D$nD$ D$$.MD$p L$ UB$D$ $D$]1|$ D$ D$$ 2K; r#́VD$ D$$?F$$D$hD$ D$$h|$F$$D$}D$ %D$`D$$0|$F$$D$ED$hD$S f=NRtD$- D$$D$` D$$|$F$$D$D$p D$$fDRfFRD$ D$$t|$F$$D$D$m D$$IfDRfFRf=NRFD$G D$$D$ v$D$p D$$|$F$$D$v(uf=NR2D$Q D$$F$t fx|$D$$xf=FŔf=XRtvD$ D$$6D$F |$ F$D$- $D$k.D$O |$ F$D$ $D$H.D$Y D$$D$JQ |$ F$D$j $D$ .`f=FR ́f=XRtvD$ D$$rD$$ |$ F$D$- $D$-D$O |$ F$D$c $D$-D$Y D$$D$t |$ F$D$ $D$I-FD$ D$D$$xf=DRuFt4$xD$ |$ t$D$ $,0D$`D$$h|$F$$D$}D$4t&D$$8|$F($D$M%D$`D$$|$F$$D$D$D$`D$$|$F$$D$D$LkD$`D$$|$F$$D$D$ D$`D$$c|$F$$D$xD$ND$`D$$+|$F$$D$@D$acD$`D$$|$F$$D$D$D$O f=NRUāfhR KKU$UD$ + D$D$@D$UKT$D$$@|$F$$D$UD$FD$$|$F$fDR$D$!fDRD$ D$$|$F(f-hR$D$Ffx@u UD$ D$$D$ D$$u|$F$fhR$D$fDRfFRfjRgD$o D$$fDRfFRfjR |$F$$D$!f-hRD$ D$$D$ D$$lD$`D$$|$F$$D$D$V  D$ D$;D$$V$f= t;f=3t5Rt. M :  MI:  &v(u}D$FD$$D$ D$$gD$& D$$OD$A D$$7D$ |$ F$D$ $D$lhRV(fhRuމfC$f8 D$s D$4$|$C$D$4$D$ D$4$K(t D$ D$4$[(uhRufhRD$FD$$KD$Z D$$3 RD$JQ |$ F$D$ $D$ZD$  D$$D$ D$$D$+ D$$D$< D$$D$T D$$D$_ D$$rD$$` D$$ZD$h D$$BD$u D$$*D$H` D$$D$HD$$D$ D$$D$h` D$$D$` D$$D$` D$$D$HD$$D$ D$$jD$ED$$RD$HD$$:D$ D$$"t&D$s D$4$|$C$@$.D$FD$$D$ D$$ML$F$@$$D$D$ D$$ED$p D$ ]D$ |$ V$ED$M $T$V(1E}})&D$Z D$$ (taG$f=3tbf= uD$T D$$ED$G$@$$D$뱐D$Z D$$95D$T D$$ML$G$$D$U4$0t&zf=XR R~RtߒD$ D$ D$$D$ |$ F$D$`$D$PD$^ D$$f=NR RtRu D$ D$$D$& D$$tD$A D$$\D$ |$ F$D$V $D$hRV(fhRuމӍ&D$s D$4$|$C$4$D$ D$ D$4$K(t&D$ D$4$[(u&hRufhRD$FD$$sD$Z D$$[D$ |$ F$D$ $D$FD$ D$$D$ V(EtVu։}1ۍ&D$p D$<$ML$F$<$D$v(uȉ]u};E= ;E~D$ $ ID$ D$$D$0^ D$$D$ |$ F$D$ $D$ D$ |$ F$D$ $D$ D$HD$$]f=TRt ~D$Z D$$1D$FD$$RD$ |$ F$D$ $D$< āD$!3 D$$D$FD$$LMD$<$L$MD$4$L$sD$f=jRt&CHt : R:f=FRvf=`Rtt$ D$D$M ${Kf=HR`Rfff=FRUB$f83cD$ D$U$M؉L$UB$D$M $$D$p D$E$CD$ D$D$ U$f{U܋ME UML[^_]t&sDf=`RzKH$KD$ D$D$ E$UEU@t&CD$ĽD$M $E؉D$UB$D$M $D$ D$E$f{UB(@$D$ M؉D$D$L$ E$v$UsỦ@f7:tf$ D$U1UfC v{ MA$af83u xOt$$lb :B:ufC D$$a 褖D$a $D$b $D$KD$8m D$$!KD$ D$$KD$`m D$$KD$ D$$ʗpRD$ D$$譗pRD$ D$$萗KD$ D$$s=dV KD$ @ D$D$$9d\=dOKD$n D$$KD$4n D$$KD$ D$$ؖG?1KD$  D$$視KD$ D$$艖KD$0 D$$lKD$D D$$OKD$X D$$2KD$l D$$KD$ D$$KD$ D$$ەKD$ D$$辕KD$ D$$衕KD$ D$$脕KD$ D$$gKD$ D$$J4  D$Tn D$E‰D$ K$KD$  D$$KD$& D$$ڔKD$t D$$轔KD$9 D$$蠔KD$n D$$胔KD$HD$$fKD$J D$$IKD$a D$$,J31ҋNDtv׋[3NDuNH,Pu&@;vuHFf@fuƅdF uAFHCdDL$D$  D$D$$ƕDdDt$$[Dۉ2t&KD$n D$$KD$s D$$KD$FD$$ْKD$GD$$輒KD$ D$$蟒KD$HD$$肒 =$PSKD$ D$$RKD$ D$$5KD$ D$$$PFqKD$ D$$$Pt2&CD$; D$D$ K$輑[$uաKD$GD$$蘑KD$HD$${KD$ D$D$$NKD$ D$D$$)0 D$ D$D$ K$ KD$/ D$$KD$ D$$ѐKD$HD$$贐KD$ D$$藐5 RtR=dtK$1.K$dMe3 I[^_]ÐKD$ D$D$ K$D$C@ D$(l D$D$KD$ K$KD$3 D$D$ K$輏KD$M D$D$ K$薏KD$i D$D$ K$pCP1tBD$KD$ D$D$ K$7ZfF1f@l~9K|$ DD$ D$$DLDžPHϡKD$ D$$賎PD$ $iKD$ D$$耎f=ZRj F~CP1ۋP Tt&TD$$7lF9|ࡴKD$ D$$ PN KD$) D$$PPLH5 t&KD$3 D$D$ K$蒍KD$M D$D$ K$l&KD$ D$$CpRD$ D$$3RKD$n D$$KD$o D$$ьKD$(o D$$贌KD$ D$$藌KD$0 D$$zKD$D D$$]KD$D$$@KD$` D$$#KD$HD$$KD$~ D$$KD$ D$$̋KD$ D$$诋KD$ D$$蒋KD$ D$$uKD$ D$$XKD$# D$$;KD$Ho D$$KD$> D$$KD$ho D$$KD$R D$$NJKD$_ D$$誊KD$HD$$荊KD$o D$$pC3KD$~ D$$Na;KD$GD$$,KD$YD$$KD$o D$$KD$o D$$ՉKD$> D$$踉KD$ D$$蛉KD$ D$$~KD$ D$$aKD$ D$$DKD$ p D$$'KD$ D$$ t&KD$X D$$KD$e D$$ƈKD$HD$$詈KD$j D$$茈KD$ D$$oKD$j D$$RKD$ D$$5pRD$, D$$pRD$0j D$$pRD$j D$$އpRD$HD$$pRD$ D$$複&KD$h D$${+KD$ D$$S3KD$ D$$+ KD$D$$KD$f D$$KD$m D$$ÆKD$m D$$覆KD$ D$$艆KD$m D$$lKD$m D$$OrfKD$ D$$+f=LR f=JRT&D$ KD$ D$$ׅxo&D$ KD$ D$$蟅@RdD$ KD$ D$$qJRfC7&KD$ D$$;piD$ KD$ D$$TRfD$ KD$ D$$ԄKD$ D$$誄VRfD$ KD$, D$$xvD$ KD$r D$$Nf=NRKD$ D$$#ZRfD$ KD$ D$$\RfD$ KD$ D$$迃PRf=t&D$ KD$ D$$臃4$}t&D$ KD$ D$$NLRfD$ KD$ D$$f=NRFP1ۋP) T&TD$$`F9|vKLHD$ D$$臂KD$ D$$jWt&KD$ D$$CD$ KD$& D$$qD$ KD$ D$$D$($D$f $>vKD$ D$$蛁IKD$K$b+t&pRD$l D$$SpRD$ D$$1pRD$i D$$pRD$j D$$pRD$D$$ڀKD$, D$$踀$P6$6  D$D$D$ D$D$$UddDD$ 2 D$D$ $臂DD$$ 5US(Mt9Kډu )t&9Ht‹B u[]Í&9t @ B []Ë@ (ߐUSfzt( JtZu 9tI(u1[]fQ$RD$D$$T$ D[]ÐUSÃ,P,t,K\$ D$ D$$~[]Ðt&KD$ D$$~, UWVS9tHVT$MT$D$ D$D$ K${ME50t+C G 0C F C ѐ1F (D$ KD$O D$$z9KT$ D$ D$$zKD$< D$$z$K1D$_D$$zE 0@D$ D$ KD$$Iz0,'US(]u v@ t9Xu[]Í$D0(XP ([]Í'UWVS,utXtR z^u I@ tA9Xu9uf@;Bt&L$|$ \$D$D$ $y,[^_]$/R8XP P ,[^_]Ð@띍t&'UWVSӁLeE1 Bf=8v_yҋDP@T$ D$D$4$xfEe3L[^_]Ðt&$T  =C$@D$D$4$D$ LxC$P$tJD$ĽD$4$*xD$C$@$4$D$8XD$ D$4$wD$q D$4$wCD$D$4$D$ wD$]L$ C$D$ 4$D$CuD$]D$4$ewC(T ߉ËS$t6[(/ 9_(tD$D$4$wS$huʋS$븋S L$ ҺE‰D$C$D$ 4$D$!C(߉ËS$t6[(9_(tD$D$4$~vS$uʋS$HD$`D$4$FvS$"D$D$4$"vS(&D$T D$4$uJD$T D$4$uS$D$e D$4$uS$D$CD$$uC1҉1ɉ"<"H   <\u̓Ƅ\D$Q D$4$0uS$CD$ D$4$D$ uZCD$ D$4$D$ tC$߉fG$9tD$D$4$tS$[(u~D$T L$ C$D$ 4$D$D$ nD$ D$4$@tS$D$T D$4$toD$  CD$ D$4$D$ s ~!=K1t&tB9utUS[ uE}~vt]܋[$ۉ]P=(KE܃}U܋ztlW}U]CtF14vɋP Q p_tgtBs p C ȅtЋPuȋP uEE9Euu]܋[$]r3f>?uv(f>3uvuf36frtfct딋]Sn}uW=(t,D$]ԋC$D$/@D$E؉$}DKUKRUy5Ktq^teCtWH VfPuIfrt>fct8fst2t'KtBSB[uv$닋5K^t-CtP u8frt"fctfst [ېuӋv$뿃= RuKɉt봃x(u@xuu<$lhS KL@A@6H CӉHLD$UԋB$D$f@DoD$KD$$F*OCu   uC[,u=(uy<[^_]D$y $'FPT$ @D$ $D$FD$D$$D$ $ECq=]E<[^_]j@tKA'Kf=LPUt Pt@]Ðt&]ÐUVSE54P8P$葜$Pt)9u t&9tR$u1[^]ÐB@[^]ÍvUWVS<}܍u]䍶E؉D$|$t$ \$D$ $FED$ $D$ ED$D$PUu/&@$t!;PuD$$D$PDED$ $D$ E܉D$.DI$腒<[^_]Í'USOu.t&[,t"tf-!fw$F[,uރ[]É'UWVSleE1hu 04$D=t$d$ !D$X$D =LB D$ $> [v Q P$ =LDD$ $b>+t&߉<$֤DP;  u*f=LPt PtRv=teD$<$~f8#_D$ý$=D$D$$D$,$=  LtD$ $d=t&;s0= Pt!t4$D$D$'Ɖwf=LP PP@;l=luD$D$< $t<^ut&.[ۍvtKtVt&1]u}]Ð  u?VfT$|$ D$ D$$>ViD$ $D$냍USXu2t&Su  uAS[tX  tϋD$ CD$ $D$fD$ CD$ $D$u뚍v[]fUWVSKtiGHtb$T$SuJxDftEXt'St<$ U[uߋUR$҉Uu‹vuX][(]`U}MIM}][ۉ]EXurt&[ tf$Ͼ@uCtfUBfrtcf=?tPD$D$ $QD$$ 듋MIɉMq][$]HB(\glZ]1ɋx(tN@(ur(1҅&@(u9t$[U1ɋBx(u븋KMt&G$I;HufG$9Ht (u1ҋMt%N$x;yuN$9yt v(u19rEO`U]kE@Eh1U}tMy dtQht>u[ tA0t[utfW S[ ƅu u][ ]뎋uE@E1  d9 `tJ@t;t6t1Jt*AXtt f;ufH@uI$ҋRx|=p =x pxE}U  fBtFD$ $MP]$谻D$ $D$`EE5$耻@  Et?UD$ $D$MQpD$ $Tu )[t"Ct&uEڋM$5 Y׋Xu 'v[tCuU> M$&܋5`tg@tVtQtL~tD_u4t&[t(Ct&uڋM $M[u؋$uvu][]K`BHTE…tcGtKwtD@fxt1@Ht*L$xt$xtt8v uu9UCt]P fzuMRu@$f  t6L$D$x $%PD$ $K[5`tW~tK_u ;[ۍvt0Ct0tڹE $1[uЋ$uv륋ptFf{t?5t{u ,fvtt̡tCt1=|p`CtK`@$uK~!K19}4u CtP HPH @$uCtP HPH @$u[i5`B  ~G_u$frs/fct#[t~Cttfsvf=uݡ|fK  fCtD${ $D$CD$$qD$ ${$=vFK@@$u^u{u vt&tkGvt  fGtD$ $GttD$D$$qD$ $뎋[$d~_Ct-t'ff сb_uv[tr|fK  fCtD$ $(CttD$D$$*pD$ $뉋[*$^5Cut&@vt@t[$̋D$p $D$"X  t&xD$ $D$ |D$G|M`CC1ҋ KS@S@$u<qS9А|  S \C @@$uS1ɉRCP HPPH @P@$uKSUxtCs(~F  =K1ҋ@ Qu{9MKEBUNUB}1҉]]@ Qu]~^~tXUEM  EAMEEtCtXM@tL;u;Pu;{f$v$CP HPH @$uEC[x$ xMPSPCMxED$ED$U $L$ ML$x CD$ D$K $D$OCD$ ƒT$S D$D$ $T$KT$ =|t   `1CK@@$u  t%CD$ D$ $D$SعC[Ef=3G8f86qD$ D$D$$菋xG8J35hD$ $PYD$ $^;P(D$ $C!PtJf@tkfu@(t@$u۸ D$D$ $KD$N$7{ D$p $[ 7R8 f:@tD$ $WD$ $C3D$ $CD$ $D$ $v dD$ $g   t@RBuutD$ $J1tx3~ t[Fftft f tf=uޅu,D$8 f$D$ $D$ $4$E䍶CUT$$u*0t[uσ,1[^_]Ðt&,[^_]ÍvUWVSӃD$D$  $ ~/1&D$M $D$95ډ|$D$$[^_]fUWVSÃMtO=0~"1; t. ; u 9׍v @ux[^_]Ðt&@t0$1ơ$=~1 & 9MF15M[^_]D$ $5Mt&  vuڸ  o1[^_]Ðt&UD$]Ӊu$8\$D$$Gat$$]u]Í'UWVS,9U~|]4M 1ۋ<Et&9| ,[^_]Ít&M0 8t/L08txϡMU0EM뭐t&M @E܋EU܋:E5~o1vf;ctD;5}W]L @ t͹ ڸ f;cuC$f83uXt*;5|f$~U܋MQPA @D$ $¹  |  kU(]1ۅɉu}rtYxA M9}7xW9}S=L <4M ]u}]D$ \ D$'D$ $ TD$ \ D$(D$ $2 0&UWVSÃ<@U؅Et&=1E>vftfft&t[$r}}؉xE؃95~z U M LUЋM ɋ8vU܋U19t&;u9Kt&}}U:D$d 1$*u?t&fctD$ $ vtf=3uzuvucU i 5L MD$s $=T$vB$f83MxCfM]܉E̋Eԋ]̅5}Ef~ 1;t P ; uH9v|M]܅GUB MGE= M@EHvWt}뒋 uf3M9U}ЉŰJ MD$s $D$r}Ћ7D$$O ¸y AMЋ낋U9MtXM; MtZGL ]D$$ xD$ D$D$ $U OGMGMD$ D$D$ $J 'UWVSD$$`xuMUԉsPCPpD$ e D$[D$ $ ̾t&UWVS,D$ $+uEED$ $D$M-uEvMM}2 1y&LM9 0ED$$D$|L U08 \$D$ $BM9~nUL2:tܡM08_D$g$LM9 0KD$;$μ2E9EEM9 D$$蔼$g,[^_]Í&UWVSEueE1UZEE҉E~ M11f9u]LEE5,PEEt&vE~u}Eu) 0uMUuEUt&Ptuu8 f[C|$$輽uCU@;uҋEUD$Մ D$$iu}uvE1L8D$ $PD$ D$D$ $BT$UՄ D$ EĉD$軸 MD$& $蝸#ED$ |$$D$ $BT$UĉT$ UՄ D$A M;E[_D$ D$D$ $U 腸'UWVS,=]$a&$mL$mM$mM$mM$mL$m,PۣLtG1 [t9{uC=M@ 9MMMM[ۉuǃ=ME}M$mML$lM~11ۍL44:$lM9׃EU9Ot `@,u,Ptj1 [t_{uC<=LD$P$T$ H@LMSg[u= LYMMEUMtZ}C5E~'t&1;tv;9|URUMMu}D$1$, j MC M?LLLXL MC @ MCt J 떋=M/u M9x; M8,[^_]Ðt&tUBMEB1MTMMUEv}1&Ct11t&Pt!ЋRutxPQPuߋ[uu]=L5E ~ 1;t7&;u(9|}CUBJPS놋C ]막LL_=M=vL4 MQ Pt$9Juv9Ht&L‹Bu,P=Mt1҅u :f9t1@uD$ D$'D$ $ xu7;3= p= M1L M M1LLD$4 D$$ M)ơLtBXL MC @ MCt k 묉LL빋@BD$Z $LLP\$D$ $GL 0+D$s $&rD$H$ MjBPt&vMD$ r D$D$ $T ,D$ D$D$ $ϵD$ D$D$ $T USp~'1ۍD$ $)9p[]ÍvUWVS}7fD$4$tD$w $D$үf=$3^$f=f=fuvCD$" $臯^$pKv-ppD$ $Q$/D$ $3[uf=tAf=u -pD$' $9wt v0[^_]Ív-p|D$9 $Í[D$) $蟮^$p`D$ $|@ $UD$ $T@ @$*D$ $))t&f=#f=!ft~f="ftvf@f.f=ftTfcuP$f:D$D$$DD$ $薭4$D$ $oD$ D$@D$$?GD$ $.@$@D$$+D$ $fUS]Ct${D$ $D$豬S t0D$& $薬D$C D$$CD$$fC$CD$H$G[]ÐD$($,Z U,P$ Ít&'US]f"t}f#t^f!t?@ p$-pWD$^$蛫[]Ðt&D$; $|D$1 $dD$] $LvUX]Éu}xkE UTƉ؋   9t?9]t:9t69t2]u}]Ív]u}] &UԉM]EP$t$D$pjUԋMЅt f-f vo$ $E $ms f= >f=4Cf8 &t$$UԉMdUԋMЅCf8C f8 t@f8fD$D$$UԉMiUԋMЉCC @ C fs f=f= Cf8wt$$UԉMcUԋMЅdCf8 s f= ef= Cf8 ^\$@$ D$UԉMhD$$ D$hUԋMЉt&C 0f qf 5f sf> D$4$UԉMcUԋMЅLs f=fE8CEf= fE'f} Kf}?f} f} Cf8 v t$@ $UԉMbUԋMЅ}s C D$C$UԉMTbUԋMЅfs D$C$D$UԉMg$\t$D$$fg$T$v\UԋMЉhC D$C$UԉMaUԋMЅC $UԉMRfƋC$Eft$$D$f$9T$\ED$C $D$f$;\D$ƋC$D$f$\t$$D$f$S$[D$u܉t$C f8 sf> urf8 3uf> 0f fuhf} f} uuf> VD$Eĉ$UԉM`UԋMЅs uf=fEsf= fEf} f}f} -f} !Eċ@ D$F $UԉM_UԋMЅsf&D$D$$ $eUԋMЉ6[]ċu(s~[ ]uf> vt$@$UԉMs_UԋMЅ C 0fu܋suuf> v t$@ $UԉM*_UԋMЅC 0fu܋suOst$@ $UԉM^UԋMЅC 0st$@ $UԉM^UԋMЅ_\$$ D$*_v$Mv$Mt&Cf8x[ 닐t&Cf8 `[ v'UStáu9 t$E  []Í$%[]fD$r $d$ D$ $H땐U$IUÐt&UWVSu4$|Džu-t&[t!t$$;u[^_]Ðt&$DI4$$/It$$C؉[^_]ÍU)WVSleE1}{$DЈ8=<5Džt&Dx~5G:$WủƄ=Ђׂ 111;$:)a8<t&$"F<vj]l[a1Ue3l[^_]fƄ5L$$ Pt&҈$7u$!f끋 k<Y蛜vUx]Éu։}eE19tAE=E\$]D$  D$ D$$薜$F Ue3u ]u}]UWVS\&&Awm+>-tt&$# >tAf$: D$D$$U$MD$fD$$ZU$M1qD$ D$$ (U$MD$fD$$T$MD$ D$$ T$Mc;U}]Ðt&]Ð&UU;}]Í&'U~]Ív'UE=t~J= &~~= "f= t&uDD$6$ړ=t&^;v:=t&D$D$$蒓=t&~VD$h $j=t&~D$1$BD$$,fD$ $fD$̂$fD$$fD$;$̒fD$V $贒fD$M$蜒fD$|$脒fD$ $lfD$$TfD$$St1t<>vD$$$ F땋G $3Ƌ$tMCt6ڸ+t$ ,ЃLd0uf> v 뙉'UWVSU} uu0t&f=~t$|$C$S ƅtb$D$2$:f=tWf= tQf=tKf=tef= u|$C $D$GBtf=tf[^_]ÍS 녍v$t&1[^_]Ð,MD$ D$$ÄD$|$C$,MD$4 D$$臄D$|$C $D$JQ ,MD$$K1[^_]Ð,MD$ D$$#C$tD$N` 륡,MD$ D$$C $t",MD$ D$$跃J,MD$/ D$$蕃(&USÃf-f v"D$D$]$@[]$ D$D$6$@t&[뜍vD$D$;$@較C lfD$D$̂$@蔃fD$D$* $@t[]ÍD$C$@D$K[]Ðt&D$D$$@$c&D$D$ $@&D$D$ $@Ԃ[]ÍD$D$W $@謂 U1҉Et$f8 t@.E@PÉ'UVSD$; $誁^t&v$D$p $脁[uD$C $i^t%f$D$p $D[uD$K $)^ t%f$D$p $[uD$S $^t%f$PD$p $Ā[uD$ $詀[^]Ív'UVSt5 ɉ5u' ; ~[^]ÍD$] $D$,^t&t&D$y$D$[u߉0뇍&'UWVSӃLEU MԉE܉U$H+E01Et[t:f; t&vt)|$$u[ut$uu΍$(ƋEF[u܋Ur}ԅtEUBu܅t=E܉$\>}܋ƉÅt<$@>t6CËuEp]؅tE[UB EL[^_]6ƉɋD$ m D$ D$BT$$€$nUt&UVS$u*ftt$$覀u[^]Ð(u51ۉt$D$q $~[^]Ðt&[tыt$$Ku[[^]ÍvUWVSeE1DžDž;n $ɉp\qx 0[0ED$  D$@D$L$$MMD$@ $D$}@_t&[Hs0 ɉ 9 9 Džt&ɉtsd19u 9td9t/9|tC$9t51 t$9t'9|9 }f9 $D$D$  D$D$ $}$L$D$  D$D$$D$$}$T$ CML$D$$O$R҉@ɉyF$D$ *D$D$$|$MT$L$D$ D$4 $D$zC$D$D$CdD$ D$\ $D$PzDž$acceDž(pt_afDž,llƅ.$D$ *D$D$$,|Q;x 0EacceEpt_$D$  D$D$ ${D$D$$b9UD$  T$ $D$a"@MPEe3u [^_]z&'UWVS+Ff> CF;{u# &|$4$2LGuw1f-fd$ f,MD$ D$$swE܉$,MD$ D$$Kw=<[^_]ËF Ht $D$$ NQt"$D$$ NS F USEPSEQSD$C$1EPCtt$$6"R$x {11D$$҉U - $E܉$BBUZuHt&U{EtE$$VPF$ uUBEuE=h=D$ $uD$| $D$|uD$ $D$_uD$ $D$BuD$ $.uKN  VҐF @t$D$$ FHt$D$$ F SEPu 4$3F S vQ$M3FSPCM̋SL$C$M1qF Pt $ D$$ NAt"$D$$ NuS EPV CUBt$$3)TFg$2S PC t$$3vD$g $D$dsst&t&D$y$D$>svuD$y $#sFsf>VtF @uQs~t&‹@uF BC$D$2؉{?&5CSSC$aC C $N҉C=$u2W ;S 5tϋD$ $D$q tW tD$D$ $qD$ $D$qWtD$D$ $Vq!D$ $D$6 $D$psuJt&vt?t4$H=D$p $pvu5t s $$1tfvt4$=cD$p $p뻍vW;SCEHwE}ԉ]Љ1uv߉[t:ƋU$T$ru܋C$EEtˉG[uƋUR҉U떍C$"@D$[ $Aos tD$,$os $D$$1 s11}ԋ]t pMu t&ыQuAEGCtD]fwut&v\$4$)t[uƋ]$ x(P(Cu &pD$$3.uCu pD$$ .uC u ؋XD$$-u AD$N $m(D$ $D$tm S tD$D$ $ m=StD$D$ $l]D$+ $l$U- E$BBf$+WPG%D$E $D$el4$MM+M̉EW$ D$$ Fq$D$$ $ D$$ H01&1l1ft&'U@W1_($,0 ]ÐU@D]Í&UWVSÃ|5@eE1u>vt1\$$)muUe3|[^_]Ív  u1Ͽ*t1@t:8_u]D$D$  D$@D$$ql2n\$$ C@kUVSÃt ff v\$1$ *[^]Ít&੨ u@utˋCCu@[ ufCCtAC yC uC1$D$)뎋C SC {[sC 1$D$k)YUSÃf=tN~1fv؃[]Íf=uCCC ‰C CtSuɐt&Ct&CC S҉C tuD$D$$ (뀍t&uU]Éu֋$T$j1uFD$C$"]u]Ð&US$XtbftD$D$ $hC$pCD$C D$ CD$ $D$g[u$[]Ív'UWVSÃtxux @uY[uIf[^_]Ëw Du   0uDt&[tsu븋D$ $D$$g[u닍vUWVS,E<EP t:ff8%@f= tf= t f=ЋP uf= ]}䐍t&{ ؅tCf8u@f8 uًP}E t&t9p …tPf: uߋBT$$huȋ=t:E D$ $D$ fE$xD$ $eD$D$$%Et&E,[^_]Ðt&f= f=t&֍u䐍t&#vUSÃt}@Kt td,MD$ D$$eCD$D$$6u2D$ D$D$ ,M$dH[]á,MD$ D$$d믐U(]Éu}u {CD$w D$D$ ,M$Sd=*u5,MD$( D$$dCHH,MD$8 D$$c]u}]Ðt&,MD$ D$$cC@$-,MD$ D$$hcv,MD$- D$$CcXD$ ,MD$! D$$c&UWVS,] u$ ҉Euc=@u OG tDt$$Met_tft$$0euE[uu,[^_]É\$ t$D$> $b|&UWVSEeE1=Ea=@U}UGE]t Ext]Uz uTZtZߍMtt1 u+UB :G tSG1 f@@uu}}uM} EEDEptKt&Vu9_ut&[tCuډtCvuwt]fNu9Vu2UZu2v[$Cuډ}tᐋvuG15EUD$$}*lj=ET$D$ p D$@D$$bU$D$}D$D$R $D$ ED$ `D$" $`(Ue3Eu Ĝ[^_]afUWVSeE1=tj5@t`^uCt&[ۍvt4D$C$kCtf8u;^tC[űv뫃{u獴&u D$E<$D$,[^_]Ëuڃ D$M<$L$iU܉ UWVS,]t3tt ,[^_]Ívډ\$$-Qta=Et&1ۅut&G f?uw |$$Ps А[Ef=dfjf (f=ۉ ۉ9uftgftWff=mT$U<$ UT$|$$ f=ʉfv ۉYۋCt?ftfu.fPSP S PSD$$n]D$1$ t&SfڸD$D$$ Ef=s&[ 2\=sEf=f ff=f"ޅ9}ftgftWff=uT$U<$UT$|$$ f=fvWf &[D$D$$ o Ef=& @ sv Fڸ0&[ -fڸ&[ S~oSt&v~t&j$D$~ D$D$$2 ã$D$A D$D$$  ã'US]t$Z tÉ؃[]Ít&C $C C$C][]? UVS]f=t$3D$$ Cff w_$` f*fP @ D$$T$ $sC Cf$`C$%E[^]& tD$% $ICf f$ C뫡tD$ $sIKL$$ Cf j&5tD$ $*IKqL$$< C\$$# 5f5f uVf t&tD$ $HKL$$CfD$ $LHC둍&D$ $,HCZt&D$F $ HC"t&D$/ $GCU]Í'Uu…]tuf;t+1]u]Í&Ҹt]u]Ðt&CtVt$T$IuVCtV C t둍v'UWVS,u] *>f;;Vt%Ct $D$UIUf v@|$D$#$FD$$ )1,[^_]Í&$ v[Qt&tzt&,[^_]Ív\$t$<$U,[^_]Ðt&tlCte$D$EH,[^_]Ðt&CD$F$u ,1[^_]ËC D$F $"D$$ 4CV|'Uuu]] tf;t1]u]Ðu\1f> FtSt$T$bGuCD$F$t(C D$F $ntf]u]Ð] ]uu]t&1f; ^U1]] uutQf;tu u]]]t&C4$D$¸uC 4$D$]u]Í'U1]] uutQf;tu u]]]}t&C4$D$¸uC 4$D$]u]Í'U]] uut5f>t] ]uu]O&\$F$u 1]u]Ð\$F $ UUEM tI=tF=tu#U M&U M?@ABCDEFGHIJKLMNRSTUVWXY_`bcdopqqrrrrrrrrrrrtusvvwwwwyx{z||~} 34BCD!%# .- ')*"$E/0+6&VFGPRH12A AJ5Z]YrpZ}9;?abdžѕAWQTSA(ί_,|scZ=tҕ:u@ت崵`{zqdO8gil\yAmjUnkeV2+@U;)-*7&Lo=PAD]EFGpqr1GJcEHFI34-?tuvz{2 jeR4E7a.tr~.. $m&@g--z~JVqqqquu,!ZtFd9-z- t. &Pt .  #y!SY#j~H:OR =@)Sjuj jHK r#!~^_`a'bBv?fHCJ"s(cdf\jk,efwgjxWh$.X%ij5kTOQSUl6m,3n4q2015678=9<:D+8f\> L\As  !"#$%&'(sB[I/0hJKQ<MMNPRT^NZ_`aybyY]_}fcdyyefgy *hy.yij>sk9WVXYZdl`aeglmyyitsmn|o~sJ/pbCswxy^_`abz{|B}~cd eghijkwxy^_`albmz{|}~cd eghijkwxy^_`albmz{|}~cd e:;ghijkwxy^_`albmz{|}~cde;ghijkwxy^_`albm|cdefg^_`abhijkcdlm efghij klmn      ^[\;TP?+,- 4GH7>7@ABCw@ABCD;VV g74Yf7Zg@g_`;gL_`k7n&'fj-lK[534874k7[9jhijklmnegD7k:IJ;eeNilZ[\]^g[;kIJa5ge8gk)*q4i74e7.kn7@+,-ABXYZ[\]^f\]^jk779GH@;-1;34i4h9hl EGie447jg eGf77eeee &'e`aeeiie01234`a7e9qe%4hgx7;D|~IJe>xNml|f~jheIJff[ggffakejYffVfVfHljfei4fiW7hPQRSTUVWXYZ[\]^hffjW/jfifgjlfj9J "$&'+,-01234679:DIJN [aei"$&'+,-01234679:DIJN [aei"$&'+,-01234679:DIJN [aei"$&'0123479:DIJN [aei"$&'0123479: DIJN&'[ae4i79DIJNTUVWXYZ[\]^[EFGHaKLMeOPQRSTUVWXYZ[\]^EFGHfKLMOPQRSTUVWXYZ[\]^f QRSTUVWXYZ[\]^()*+,-58 <=>?!()*+,-5!8<=>?EFGHKLMOPQRSTUVWXYZ[\]^EFGHKLMOPQRSTUVWXYZ[\]^EFGHKLMOPQRSTUVWXYZ[\]^eEFGHlKLMOPQRSTUVWXYZ[\]^EFGHKLMlOPQRSTUVWXYZ[\]^EFGHKLMkOPQRSTUVWXYZ[\]^EFGHKLMhOPQRSTUVWXYZ[\]^EFGHKLMhOPQRSTUVWXYZ[\]^EFGHfKLMOPQRSTUVWXYZ[\]^EFGHfKLMOPQRSTUVWXYZ[\]^EFGHfKLMOPQRSTUVWXYZ[\]^EFGHfKLMOPQRSTUVWXYZ[\]^EFGHfKLMOPQRSTUVWXYZ[\]^EFGHfKLMOPQRSTUVWXYZ[\]^EFGHKLMOPQRSTUVWXYZ[\]^EFHKLMOPQRSTUVWXYZ[\]^EFKLMOPQRSTUVWXYZ[\]^GHKLMOPQRSTUVWXYZ[\]^HKLMOPQRSTUVWXYZ[\]^HKLMOPQRSTUVWXYZ[\]^KLMOPQRSTUVWXYZ[\]^OPQRSTUVWXYZ[\]^RSTUVWXYZ[\]^ (+,-<=>?pqrswxz};;77:g7y7r)*v58;;e47~i.{77@;;ihh4i|tgkil@ &'479DIJN[ae"$012367:eie447Ηgj79eeegknABEFGHKLMOPQRSTUVWXYZ[\]^lfee7 eeiieeeekó@ABCD_`%kGHGHh7jl4g7fm;4l67efüüüjfhefffhggffkffffkȹj4[eVVf!uhknklɹfje4eleif7hhf!jjfWWif/58ffffeljfBjfDeletinginitializer in parameter list:root:max nr of processes is 255 undeclared variable %sneed constant initializer for %s claim %s redefinednever_%dltl_%dtrace %s redefined:trace:typedef %s must be globalinvalid use of '%s'missing '}' ?label preceding declaration,label predecing xr/xs claim,malformed declarationcannot %s mtype (ignored)mtype declaration must be globalplace initialized var decl of '%s' at start of proctype place initialized chan decl of '%s' at start of proctype width-field %s too largemissing array index for '%s'undeclared variable: %snot an eventbad label-name %sarithmetic on chanarithmetic on chan id'sused 'run' outside proctypeinvalid PROVIDED clauseusage: provided ( ..expr.. )unsigned cannot be used as mesg typesyntax errorError: discardingError: poppingmemory exhaustedCleanup: discarding lookaheadCleanup: poppingď'ZǑ3?uܒ6TCޗ >PØN NΛڛ4Abn{ʜÝ ;pΞeN]ɢˣ)6HɤOԥ$pzƦu|cJYǪ9FXګk}ޭ  i{ܯUboCtֱ8i˲-^Kxִ ˵ r]ŷ8w!RU *[P ,pнVbo{FٿcLl%s (X[]<>!) %s (UWV||&&-><->w+_S_p_I_n_.tmpcannot create temporary file%p could not translate ltl formulaltl %s: %s cannot happen, missing inline def %sunexpected, inline_stub not setmalformed preprocessor directive - # .malformed preprocessor directive - # .linenomalformed preprocessor directive - .fnamegot %c, expected " -- lineno %d malformed preprocessor directive - .fname (%s)malformed preprocessor directive - fname.spin: in proctype %s, ref to object in proctype %s wrong nr of params on call of '%s'expecting '[Un]Matched', saw %sarray initialization error, c_state (%s)if (!(%s)) { if (!readtrail) {printf("pan: precondition false: %s\n"); _m = 3; goto P999; } } if (!(%s)) { if (!readtrail) { depth++; trpt++; trpt->pr = II; trpt->o_t = t;trpt->st = tt; uerror("%s"); continue; } else { printf("pan: precondition false: %s\n"); #if defined(C_States) && defined(HAS_TRACK) dereferencing state object: %sint cpu_printf(const char *, ...); cpu_printf("c_stack %%u\n", p_t_r); void c_update(uchar *p_t_r) { printf("c_update %%u\n", p_t_r); memcpy(p_t_r, &%s, sizeof(%s)); void c_unstack(uchar *p_t_r) { cpu_printf("c_unstack %%u\n", p_t_r); void c_revert(uchar *p_t_r) { printf("c_revert %%u\n", p_t_r); memcpy(&%s, p_t_r, sizeof(%s)); spin: %s:%d replacement value: %s formal par of %s contains replacement valueformal par of %s used in structure name%3d: %s, warning: empty inline definition (%s) #identP%s->invalid variable ref in '%s'inlines nested too deeplycyclic inline attempt on: %s"Matched""UnMatched""unMatched""StackOnly"c_expr %s has side-effectsc_state format (%s) uerror("%s"); continue; } else { sv_save();_m = 3; goto P999; } } /* start of %s */ \# /* end of %s */ uchar c_stack[StackSize]; WS Global Hidden Localextern %s %s; #ifdef VERBOSE void c_stack(uchar *p_t_r) { if(%s) memcpy(p_t_r, %s, %s); memset(p_t_r, 0, %s); p_t_r += %s; p_t_r += sizeof(%s); memcpy(%s, p_t_r, %s); %s; "Hidden"%s; /* Hidden */ uchar c_state[%ssizeof(%s)void locinit%d(int h) { uchar *this = pptr(h); ((P%d *)this)->%s = %s; void globinit(void) { now.%s = %s; %s = %s; #define C_States 1 #undef C_States char *c; char *t; } code_lookup[] = { { "%s", \"%%\n { (char *) 0, "" } string not terminatedltl definition not terminatedcharacter quote missing: %s_lastbad param to inline %sc_code%dspin: saw char '%c' bad inline: %s /* line %d %s */ #line %d "%s" {inline text too longprocedure name %s redefinedUWalwayseventuallystronguntilweakuntilreleasenextimpliesequivalentbitboolbyteD_proctypefalse:hide::init::local:ltl:ltl::never:notrace:notrace:selectskip:trace:true:show:xrxs\\\\\\\\\\\\\\\\\\\\\\\\\\\\\ X\\h; 6  vaL7"̂L;J΂K6MЂIׂHLLKJME D'b!44!4‘ˑԑޑ &)]4@ ֒0  9 13@Yߒ/QX*7x =>w_( 4  ,EM>Q4Ւ2;Wޒ1_<g& &4%.7-((M.f K#qs 4x3%a<}3v+Γ$&455%s- %s by: to %s par %d never used under this namespin: warning, %s, global %d <:struct-field:> <:global:> <%s> {scope %s}bad mtype definitionstdinnon-local x[rs] assertionxr or xs of non-chan '%s'redeclaration of '%s'(%s) has invalid width-fieldunsigned without width-fieldbad array size for '%s' '%s %s' exported as run parameterused as l-value in asgnmntused as r-value in asgnmntpolled in receive stmntreceived fromsent to, '%s%s' variable is never used name %s appears twice in mtype declarationtoo many mtype elements (>255)error: x[rs] claims from %s and %s conflicting claims on chan '%s'spin: warning, %s:%d, xs tag not compatible with -m (message loss) (%s) only an unsigned can have width-fieldbit variable (%s) cannot be hiddenchan initializer for non-channel %sproctype %s, '%s %s' could be declaredimported as proctype parameterused as parameter in receive stmntused as parameter in send stmntAFLŌVPRSrs! setq_claim(", h, "%s"); cannot happen, cast_val%d->%d (%d)undecl var %s (assuming int) %s~G%s = %s MSC: ~G %s %s attempt to read value of '_'_pid_nr_pr %s(%d):%s~G%s(%d):%s = MSC: ~G %s(%d):%s %s value (%s) truncated in assignmentself-reference initializing '%s'findlab through getglobal on %s %3d: proc %3d (TRACK) line 1 "var" (state 0) [printf('MSC: globvar\\n')] (state 0) [printf('MSC: locvar\\n')] '%c' = \b\t\f\rconditionrecv poll %s@(x->y:z)[]<><->%sin%sactive%s&&%s=%sassert%satomic%sbreak%sc_code%sc_decl%sc_expr%sc_state%sc_track%snevera constant%s--%sd_step%sd_proctype%sdo%selse%sempty%senabled%s==%seval%sfi%sfull%s>=%sgoto%shidden%sif%s++inline name%sinline%sinit%slocala label-name%s<=%slen%s<<%s<%smtypean identifier%s!=%s! (not)%snempty%snfullsub-sequence%snp_%sod%sof%s||%s!!%spc_valueprocess name%sprintf%sprintm%spriority%sproctype%sprovided%s?%s??%s>>%sruntoken: ::%sshow%s!a string%strace%stimeoutdata typename%stypedef%sx[rs]%s- (unary minus)%sunlessnofilenamespin: %s:%d, Error: saw ' near '%s'seed used: %d spin: %d error(s) - aborting Exit-Status 0 pan.bpan.cpan.hpan.mpan.tpan.prenot enough memoryspin: never, saw enabled()pc_value()_spin_nvr.tmpcannot open tmp file %s-c-f -A apply slicing algorithm into never claim -jN skip the first N steps in simulation trail -p print all statements -r print receive events -s print send events -v verbose, more warnings offspin: case caching turned %s %s %s > %sspin: preprocessing failed spin: cannot open %s spin: cannot read %s %s.nvr#include "%s" progressacceptspin: missing argument to -f cannot open %s/lib/cpp<<</m<P</////////////////////////////////////////////////3<</////////////////;////////////////;//////////////;;//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////u;P;+;;:::r:M:(::999o9J9-99888|8W828 87//77/7d7?776666a6<665555^59554444{4^4A4$4333/3k3F3!32222x2[2>2/!22111x1S1.1 1000u0S0100K LhLHKKWVV8SWWNNWWNpWXW@W(W0VNNXSV8STNSSSNNNNNNSSXV@VVVVpVVUUUUhU@U0UTTTT`TPTVspin: allocated %ld Gb, wanted %d bytes more spin: Warning, never claim has side-effect never claim contains i/o stmntsspin: warning, make sure that the S1 model also polls channel '%s' in its claim incompatible with separate compilationspin: Warning, using %s outside never claim spin: Error, using np_ outside never claim use: spin [-option] ... [-option] file Note: file must always be the last argument -a generate a verifier in pan.c -B no final state details in simulations -b don't execute printfs in simulation -C print channel access info (combine with -g etc.) -c columnated -s -r simulation output -d produce symbol-table information -Dyyy pass -Dyyy to the preprocessor -Eyyy pass yyy to the preprocessor -e compute synchronous product of multiple never claims (modified by -L) -f "..formula.." translate LTL -F file like -f, but with the LTL formula stored in a 1-line file -g print all global variables -h at end of run, print value of seed for random nr generator used -i interactive (random simulation) -I show result of inlining and preprocessing -J reverse eval order of nested unlesses -k fname use the trailfile stored in file fname, see also -t -L when using -e, use strict language intersection -l print all local variables -M print msc-flow in Postscript -m lose msgs sent to full queues -N fname use never claim stored in file fname -nN seed for random nr generator -O use old scope rules (pre 5.3.0) -o1 turn off dataflow-optimizations in verifier -o2 don't hide write-only variables in verifier -o3 turn off statement merging in verifier -o4 turn on rendezvous optiomizations in verifier -o5 turn on case caching (reduces size of pan.m, but affects reachability reports) -Pxxx use xxx for preprocessing -qN suppress io for queue N in printouts -S1 and -S2 separate pan source for claim and model -T do not indent printf output -t[N] follow [Nth] simulation trail, see also -k -Uyyy pass -Uyyy to the preprocessor -uN stop a simulation run after N steps -w very verbose (when combined with -l or -g) -[XYZ] reserved for use by xspin interface -V print version number and exit spin: dataflow optimizations turned %s spin: dead variable elimination turned %s spin: statement merging turned %s spin: rendezvous optimization turned %s spin: bad or missing parameter on -o spin: too many -D args, aborting Spin Version 6.1.0 -- 2 May 2011spin: warning -o[123] option ignored in simulations spin: cannot create tmp file %s spin: error, no filename specifiedspin: -c precludes all flags except -t gsave ISOEncode setfont %d %d [ (%d) ] 10 -0.5 0.5 0 false DrawText grestore %d %d moveto %d %d lineto stroke closepath fill %d setlinewidth 0 setlinecap 1 setlinejoin stroke grestore %d:%250s (%s) ] 10 -0.5 0.5 0 %%%%Page: %d %d 10 %d moveto 10 %d lineto closepath clip newpath %f %f translate %f %f scale showpage restore %%%%Trailer end %%%%Pages: %d %%%%EOF mscmax nr of %d steps exceeded abortingMSC: %s.pscannot create file '%s'%%!PS-Adobe-2.0 %%%%Creator: %s %%%%Title: MSC %s %s%d.trail%s.trailcannot open trail file%%%%Pages: (atend)%%%%PageOrder: Ascend%%%%DocumentData: Clean7Bit%%%%Orientation: Portrait%%%%EndComments%%%%BeginProlog50 dict begin/baseline 0 def/height 0 def/justify 0 def/spacing 0 def/stipple 0 def/strings 0 def/xoffset 0 def/yoffset 0 def/ISOEncode { dup length dict begin currentdict end} bind def/AdjustColor { CL 2 lt { currentgray CL 0 eq { .5 lt {0} {1} ifelse } if setgray } if/DrawText { /stipple exch def /justify exch def /yoffset exch def /xoffset exch def /spacing exch def /strings exch def /lineLength 0 def strings { stringwidth pop newpath newpath translate lineLength xoffset mul dup stringwidth pop justify neg mul 0 moveto stipple { gsave /char (X) def { char 0 3 -1 roll put currentpoint gsave grestore char stringwidth translate moveto } forall grestore } {show} ifelse 0 spacing neg translate%%%%EndProlog%%%%BeginSetup/CL 2 def%%%%EndSetup/Courier-Bold findfont 6 scalefont 0.000 0.000 0.000 setrgbcolor AdjustColor 1 setlinewidth 0 setlinecap 1 setlinejoin 0.92 0.92 0.92 setrgbcolor AdjustColor %f %f %f setrgbcolor AdjustColor /Courier-Bold findfont 8 scalefont (%s -- %s -- MSC -- %d) ] 10 -0.5 0.5 0 spin: wrote %d pages into '%s.ps' max length of %d steps exceeded - ps file truncated %%%%BoundingBox: 119 154 494 638 %%%%DocumentNeededResources: font Courier-Bold {1 index /FID ne {def} {pop pop} ifelse} forall /Encoding ISOLatin1Encoding def /Temporary exch definefont dup lineLength gt {/lineLength exch def} {pop} ifelse 0 0 moveto (TXygqPZ) false charpath pathbbox dup /baseline exch def exch pop exch sub /height exch def pop strings length 1 sub spacing mul height add yoffset mul translate justify lineLength mul baseline neg translate char true charpath clip StippleText%%%%IncludeResource: font Courier-BoldL>????L>L>L>L>L>L>??L>L>L>L>L>,@BCdo not index an array with itself (%s)attempt to assign value to system variable %sError: receiving from an uninitialized chan %s %3d: warning: missing params in next recv %3d: warning: too many params in next recv Error: sending to an uninitialized chan %3d: warning: missing params in send %3d: warning: too many params in send %3d: warning: missing params in rv-send %3d: warning: too many params in rv-send mtype name %s too longinvalid asgn to chaninvalid use of chan name queue %d (%s(%d):%s[%d]): %s): type-clash in %s, (%s<-> %s)too many queues (%s)too many channel types*?*Senq\p %3d .%s%c(state -) [values: %d(state -) [%d%s:%d %s %s queue %d (invalid use of STDINRecv [Recv] <-Send rv-sendSent cannot happen, s_sndlabel %s %d <%s> <%s i%d> d_step (ignored) atomic label %s misplaced break statementjump into d_step sequencebad index in for-construct %sunexpected: loose ends:b%dundefined label %sunknown label '%s'fix_dest error (%s)spin: %s:%d, redundant skip label %s redeclaredduplicate `else'cannot happen - if_sequnexpected unless structurecannot happen - mov_lab %sfor ( .name in name ) { ... }for ( %s in .name ) { ... }bad channel type %s in for_f0r_t3mp%sbad arrayname %s=====> instead of "Label: stmnt unless stmnt" =====> always use "{ Label: statement ... }" "Label: { statement ... }" =====>instead of :: ... :: Label: statement od (of fi) =====>always use Label: do (or if) :: statement od (or fi) cannot happen - labels spin: warning, %s:%d, atomic inside %s (ignored) spin: warning, %s:%d, d_step inside spin: error, %s:%d, unless in d_step (ignored) chan %s in for should have only one field (a typedef)%s ( .name : from .. to ) { ... }start value for %s exceeds end-valuespin: label '%s' (proctype %s) spin: cannot remote ref a label inside the same proctype cannot reference label inside atomic or d_step (%s)invalid use of 'else' combined with i/o and xr/xs assertions,dubious use of 'else' combined with i/o,for ( %s in .channel_name ) { ... }type of %s does not match chanerror: (%s:%d) label %s placed incorrectly =====> stmnt unless Label: stmnt sorry, cannot jump to the guard of an escape (it is not a unique state) "Label: { stmnt unless stmnt }" "atomic { Label: statement ... }" "Label: atomic { statement ... }" "d_step { Label: statement ... }" "Label: d_step { statement ... }" non_local jump in d_step sequencesequence must have at least one statement((p8%3d: proc -%2dindexing array '%s'wrong number of parametersspin: error, type: %d not a labelname: '%s'unknown labelname: %ssaw preinitialized struct %srefers to wrong proctype '%s'remote ref: %s[%d] have only: %d %s setlocals: cannot happen '%s'%d:%sproc %d = %s 0: proc - (%s) creates proc %2d (%s) priority %darray in parameter list, %sStarting %s with pid %d parsing error, no sequence %s %d = %s MSC: ~G line %d rv-attempt in d_step sequence [cannot happen - weightsSelect a statement choice %d: unexecutable, + Escape unexecutable, [else] Make Selection %d no executable choices Select [1-%d]: %64s no input choice is outside range #processes: %d %d process%s created ------------- <> stmnt in d_step blockstimeout spin: indexing %s[%d] - size is %d the model contains %d never claims: only one claim is used in a verification run choose which one with ./pan -N name (defaults to -N %s) spin: remote ref to proctype %s, has more than one match: %d and %d spin: saw %d parameters, expected %d remote ref to label '%s' inside d_stepspin: remote reference error on '%s[%d]' missing actual parameters: '%s'type-clash in params of %s(..), (%s<-> %s)spin: bad value for det (cannot happen) spin: couldn't find claim %d (ignored) spin: too many processes (%d max) ------------- final state: ------------- spin: error, cannot use 'enabled()' in models with synchronous channels. warning: never claim not used in random simulation warning: trace assertion not used in random simulation depth-limit (-u%d steps) reached used: enabled(pid=thisproc) [%s]spin: text of failed assertion: assert(spin: trail file doesn't match spec? assignmentassertion violatedspin: bad node type %d (run) too few print args %s%o%u%xbad print cmd: '%s'printf string too longSelect stmnt ( choice 0: other process unexecutable, choice %d: (else) Select [0-%d]: choice outside range unexecutable Stmnt [] has escape(s): Escape taken Escape taken %s:%d,2K@VbKZ";)G-a9\~,lXHconfusing control structureucharushortuint Qlen; /* q_size */ void c_chandump(int unused) void c_chandump(int from) { uchar *z; int slot; from--; return; z = qptr(from); switch (((Q0 *)z)->_t) { case %d: ((Q%d *)z)->{ printf(" ["); printf("],"); printf("\n"); } #define NQS %d short q_flds[%d]; short q_max[%d]; case %d: j = sizeof(Q%d); q_flds[%d] = %d; q_max[%d] = %d;typedef struct Q%d { uchar _t; /* q_type */ struct { } contents[%d]; } Q%d; unsigned fld%d : 1; uchar fld%d; short fld%d; int fld%d; bad channel spec uchar _t; } Q0; switch (t) { } return j; } } return j; } #endif int Q_has(int, int, intint Q_has(int into, int want%d, int fld%d{ int i; if (!into--) uerror("ref to unknown chan (recv-poll)"); if (want%d && continue; return i+1; #if NQS>0 , int args_given) case %d:%s #ifdef HAS_SORTED (trpt+1)->ipt = j; %sQlen = %sQlen + 1; ((Q%d *)z)->contents[j].fld if (args_given != %d) { if (args_given > %d) else break; /* =rv= */ (trpt+2)->o_m = 0; if (fld%d < %s%d) goto found%d; found%d: { /* shift up */ %scontents[k+1].fld%d = %scontents[k].fld%d; %s%d = fld%d; case %d: return %d; case %d:%s if (done) if (fld+1 != %d) if (fld == 0) r = %scontents[slot].fld0; default: Uerror("too many fields in recv"); { j = %sQlen - 1; %sQlen = 0; ((Q%d *)z)->contents { j = %sQlen; %sQlen = --j; for (k=slot; k printf("global vars:\n"); switch(tp) { case %d: /* none */ } } void printm(int x) { switch (x) { default: Printf("%%d", x); proctype %s:", now.%s%s:", ((P%d *)pptr(h))->error: %s defines local %s %s[%d][%d] = 1; %s label inside d_step%s label inside atomic visstate[%d][%d] = 1; if (state_tables) ini_claim(%d, 0); void do_reach(void) { if ((Maxbody %% WS) != 0) #ifdef VAR_RANGES #ifdef TRIX int what_p_size(int); int what_q_size(int); { int j; #ifdef V_TRIX #endif #ifndef BFS #ifndef TRIX_ORIG if (whichway > 0) } else , int par%dint tt, Trans *t) { switch(ot) { case %d: /* claim select */ reached%d[%d]=1; ((P%d *)pptr(h))->_t = %d; ((P%d *)pptr(h))->_p = %d; src_claim = src_ln%d; if (whichclaim != -1) break; #define _NP_ %d #define start%d 0 /* np_ */ case %d: /* np_ */ ini_claim(%d, h); ((P%d *)pptr(h))->_p = 0; reached%d[0] = 1; accpstate[%d][1] = 1; case %d: /* %s */ #define start%d %d #define start_event %d case %d: /* %s */ /* params: */ ((P%d *)pptr(h))-> = par%d; hidden array in parameter %s /* locals: */ locinit%d(h); } return 0; } #define Pinit ((P%d *)this) #define P%s ((P%d *)this) } P%d; #define Air%d 0 #define Air%d (sizeof(P%d) - uchar)short)cannot happen Air %s#define SYNC %d #define ASYNC %d #ifndef NCORE #ifdef DUAL_CORE #define NCORE 2 #elif QUAD_CORE #define NCORE 4 #else #define NCORE 1 short Air[] = { %s (short) Air%d #ifndef NOCLAIM , (short) Air%d #endif }; char *procname[] = { ":np_:", }; I_PROC=%d, A_PROC=%d,int Btypes[] = { 0 /* :np_: */ #undef VERI #define Pclaim P%d typedef struct P%d { #define Air%d (0) #define Pclaim P0 #ifndef NCLAIMS #define NCLAIMS 1 #define StackSize ( uchar sv[VECTORSZ]; } Statetypedef struct TRIX_v6 { uchar *body; /* aligned */ short modified; short psize; short parent_pid; struct TRIX_v6 *nxt; } TRIX_v6; TRIX_v6 *freebodies; TRIX_v6 *channels[MAXQ+1]; long _p_count[MAXPROC]; long _c_count[MAXPROC]; #define HAS_TRACK %d cannot hide non-globals (%s)cannot hide channels (%s)/* hidden variable: */int unsend(int into){ int _m=0, j; uchar *z; #ifdef HAS_SORTED int k; if (!into--) #ifndef TRIX_ORIG #ifdef V_TRIX z = qptr(into); j = ((Q0 *)z)->Qlen; ((Q0 *)z)->Qlen = --j;{ int j; uchar *z; z = qptr(from);{ int j=0, i = now._nr_qs; if (i >= MAXQ) Uerror("too many queues"); switch (n) { if (vsize%%WS) q_skip[i] = WS-(vsize%%WS); q_skip[i] = 0; #ifndef NOCOMP k = vsize; #ifndef BFS if (is_rv) k += j; Mask[k-1] = 1; vsize += (int) q_skip[i]; q_offset[i] = vsize; vsize += j; now._nr_qs += 1; now._vsz = vsize; if (freebodies) { channels[i] = freebodies; channels[i]->psize = j; if (vsize >= VECTORSZ) if (j > 0) ((Q0 *)qptr(i))->_t = n; return i+1; Uerror("qsend bad queue#"); if (in_s_scope(into+1)) require('s', into);q_zero(int from){ if (!from--) Uerror("bad queue q-zero");not_RV(int from){ if (q_zero(from)){ if (x == 0) if (x < 0 || x > MAXQ) 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];q_S_check(int x, int who){ if (!q_sender[x]) { q_sender[x] = who+1; if (q_zero(x)) q_name[x], x-1); p_name[who], who); if (q_sender[x] != who+1) printf("%%s (proc %%d)\n",short q_recver[MAXQ+1];q_R_check(int x, int who){ if (!q_recver[x]) { q_recver[x] = who+1; if (q_recver[x] != who+1)q_len(int x){ if (!x--)q_full(int from)q_e_f(int from){ /* empty or full */#if NQS>0{ uchar *z; int j, k, r=0; Uerror("qrecv bad queue#"); require('r', from);col_q(int i, char *z){ int j=0, k; char *x, *y; Q0 *ptr = (Q0 *) qptr(i); switch (ptr->_t) { for ( ; j > 0; j--, y++) if (!Mask[k++]) *x++ = *y; for (j = 0; j < WS-1; j++) *x++ = 0; x -= j;/** function prototypes **/char *emalloc(unsigned long);char *Malloc(unsigned long);int addqueue(int, int, int);/* int atoi(char *); *//* int abort(void); */int close(int);int delproc(int, int);int endstate(void);int hstore(char *, int);int q_cond(short, Trans *);int q_full(int);int q_len(int);int q_zero(int);int unsend(int);/* void *sbrk(int); */void Uerror(char *);void c_chandump(int);void c_globals(void);void c_locals(int, int);void checkcycles(void);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 new_state(void);void p_restor(int);void putpeg(int, int);void putrail(void);void q_restor(void);void settable(void);void sv_restor(void);void sv_save(void);void uerror(char *);void usage(FILE *);void wrap_stats(void); int onstack_now(void); void onstack_init(void); void onstack_put(void); void onstack_zap(void); 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];to_compile(void){ char ctd[1024], carg[64]; strcpy(ctd, "-DBITSTATE "); strcpy(ctd, "");#ifdef NOVSZ strcat(ctd, "-DNOVSZ "); strcat(ctd, "-DREVERSE ");#ifdef T_REVERSE strcat(ctd, "-DT_REVERSE "); #if T_RAND>0 strcat(ctd, "-DT_RAND "); #if P_RAND>0 strcat(ctd, "-DP_RAND "); strcat(ctd, "-DBFS ");#ifdef MEMCNT#ifdef NOCLAIM strcat(ctd, "-DNOCLAIM "); strcat(ctd, "-DSAFETY ");#ifdef NOFAIR strcat(ctd, "-DNOFAIR ");#ifdef NFAIR if (NFAIR != 2) strcat(ctd, carg);#ifdef NOREDUCE strcat(ctd, "-DNOREDUCE ");#ifdef XUSAFE strcat(ctd, "-DXUSAFE ");#ifdef NP strcat(ctd, "-DNP "); strcat(ctd, "-DPEG ");#ifdef HC0 strcat(ctd, "-DHC0 ");#ifdef HC1 strcat(ctd, "-DHC1 ");#ifdef HC2 strcat(ctd, "-DHC2 ");#ifdef HC3 strcat(ctd, "-DHC3 ");#ifdef HC4 strcat(ctd, "-DHC4 "); strcat(ctd, "-DCHECK ");#ifdef CTL strcat(ctd, "-DCTL "); strcat(ctd, "-DTRIX ");#ifdef NIBIS strcat(ctd, "-DNIBIS ");#ifdef NOBOUNDCHECK#ifdef NOSTUTTER strcat(ctd, "-DNOSTUTTER "); strcat(ctd, "-DREACH ");#ifdef PRINTF strcat(ctd, "-DPRINTF ");#ifdef OTIM strcat(ctd, "-DOTIM "); strcat(ctd, "-DCOLLAPSE ");#ifdef SVDUMP strcat(ctd, "-DSVDUMP "); if (VECTORSZ != 1024) strcat(ctd, "-DVERBOSE ");#ifdef SDUMP strcat(ctd, "-DSDUMP "); sprintf(carg, "-DSFH ");#ifdef VMAX if (VMAX != 256)#ifdef PMAX if (PMAX != 16)#ifdef QMAX if (QMAX != 16)#ifdef SET_WQ_SIZE reached[%d] = reached%d; NrStates[%d] = nstates%d;run(void){ /* int i; */#ifdef PROV#include PROV settable(); #ifdef MEMLIM #if MEMCNT<20 #if MEMCNT==20 #define MEMLIM (1) #undef MEMCNT #else #if MEMCNT>=50 #else #endif #endifuchar *accpstate[%d];uchar *progstate[%d];uchar *loopstate[%d];uchar *reached[%d];uchar *stopstate[%d];uchar *visstate[%d];short *mapstate[%d]; int NrStates[%d]; if (state_tables) { if (dodot) exit(0);#ifdef MERGED pan_exit(0); { int i; { udmem *= 1024L*1024L; if (!readtrail) bstore = bstore_mod; hinit(); onstack_init(); Addproc(VERI); /* pid = 0 */ #if NCLAIMS>1 if (claimname != NULL) select_claim(whichclaim); now._event = start_event; globinit();go_again: do_the_search(); wrap_stats(); printf("\n"); { memset(SS, 0, udmem); memset((uchar *) S_Tab, 0, nlost=nShadow=hcmp = 0; Fa=Fh=Zh=Zn = 0; goto go_again;#ifdef HAS_PROVIDED#define GLOBAL_LOCK (0)#ifndef CS_N#define CS_N (256*NCORE)#define NR_QS (NCORE)#define GQ_RD GLOBAL_LOCK#define GQ_WR GLOBAL_LOCK#define QLOCK(n) (1+n)#define NR_QS (NCORE+1)#define CS_NR (CS_N+3)#define GQ_RD (1)#define GQ_WR (2)#define QLOCK(n) (3+n)void e_critical(int);void x_critical(int); #ifdef NGQ printf("cpu%%d: ", core_id); leave_critical(GLOBAL_LOCK);Printf(const char *fmt, ...) * during verification runs * unless explicitly wanted if (readtrail) { va_list args; va_start(args, fmt); vprintf(fmt, args); va_end(args);extern void printm(int);#ifndef SCstatic long CNT1, CNT2;static int stackwrite;static int stackread;static Trail frameptr;getframe(int d) if (CNT1 == CNT2) return &trail[d]; if (d >= (CNT1-CNT2)*DDD) if (!stackread return &frameptr;depth_of(struct H_el *s){ Trail *t; int d; { t = getframe(d); if (s == t->ostate) return d; return depthfound;extern void cleanup_shm(int);pan_exit(int val){ void stop_timer(void); if (signoff) { void dsk_stats(void); dsk_stats(); { cleanup_shm(1); if (val == 2) { val = 0; { stop_timer();#ifdef C_EXIT exit(val);static char tbuf[2][2048];transmognify(char *s){ char *v, *w; int i, toggle = 0; memset(tbuf[0], 0, 2048); memset(tbuf[1], 0, 2048); strcpy(tbuf[toggle], s); { *v = '\0'; v++; if (*w != '}') return s; *w = '\0'; w++; + strlen(w) > 2047) return s; strcat(tbuf[1-toggle], w); toggle = 1 - toggle; tbuf[toggle][2047] = '\0'; return tbuf[toggle];add_src_txt(int ot, int tt){ Trans *t; { printf("\t\t"); q = transmognify(t->tp); for ( ; q && *q; q++) if (*q == '\n') printf("\\n"); putchar(*q);find_source(int tp, int s) if (s >= flref[tp]->from && s <= flref[tp]->upto) { return flref[tp]->fnm;wrap_trail(void) int i; short II; P0 *z; if (onlyproc >= 0) II = onlyproc; z = (P0 *)pptr(II); { printf(" %%s:%%d", add_src_txt(z->_t, z->_p); pan_exit(0); if (depth < 0) depth = 0; { z = (P0 *)pptr(II); c_locals(II, z->_t);#ifdef ON_EXIT ON_EXIT;FILE *findtrail(void){ FILE *fd; char fnm[512], *q; char MyFile[512]; char MySuffix[16]; int try_core; int candidate_files; if (trailfilename != NULL) if (fd == NULL) } /* else */ goto success;talk: try_core = 1; candidate_files = 0; tprefix = "trail"; strcpy(MyFile, TrailFile); if (whichtrail) { *q = '\0'; *q = '.'; fd = fopen(fnm, "r"); if (fd != NULL) { candidate_files++; if (verbose==100) candidate_files, fnm); fclose(fd); tprefix = MySuffix; } while (try_core <= NCORE); if (candidate_files != 1) { if (verbose != 100) candidate_files); verbose = 100; goto talk; exit(1);try_again: sprintf(fnm, "%%s%%d.%%s", { if (try_core < NCORE) { tprefix = MySuffix; goto try_again;success: set_root(); return fd;getrail(void) { if (depth == -1) if (depth < 0) if (i > now._nr_pr) II = i; if (!t) { t = trans[z->_t][i]; z->_p = i; goto recovered; II, z->_t, z->_p); break; /* pan_exit(1); */recovered: if (gui) simvals[0] = '\0'; if (!do_transit(t, II)) goto moveon; src_all[i].src[z->_p]); c_globals(); } if (!src_all[i].src) lastnever = z->_p; goto sameas; if (coltrace) { printf("%%ld: ", depth); for (i = 0; i < II; i++) printf("\t\t"); } else if (!silent) { printf(" %%s:%%d ", /* printf("\n"); */moveon: z->_p = t->st; wrap_trail();f_pid(int pt) if (z->_t == (unsigned) pt) return BASE+z->_pid; #if WS>4 #define HASH64 #define HASH32 #define SFH #undef SFH{ unsigned long x, y; unsigned int i = 1; x = K1; y = j3; for (;;) if (i == hfns) { printf("Old bitstate\n"); return 1; x = (x + K2 + i); y = (y + j4) & 7; i++;#ifdef RANDSTOR { SS[x%%udmem] |= (1<_pid = i;#define Q_PROVISO #ifndef INLINE_REV #define INLINE_REVtypedef struct SV_Hold { State *sv; int sz; struct SV_Hold *nxt;} SV_Hold;typedef struct EV_Hold { char *sv; int nrpr; int nrqs; char *po, *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; short boq; unsigned long nr; struct BFS_Trail *nxt;} BFS_Trail;SV_Hold *svhold, *svfree;#ifdef BFS_DISK #ifndef BFS_LIMIT #define BFS_LIMIT 100000 #ifndef BFS_DSK_LIMIT #define RFLAGS (O_RDONLY)long bfs_size_limit;int bfs_dsk_write = -1;int bfs_dsk_read = -1;void snapshot(void);SV_Hold *getsv(int n) oh = (SV_Hold *) 0; { if (n == h->sz) { if (!oh) svfree = h->nxt; oh->nxt = h->nxt; h->nxt = (SV_Hold *) 0; if (n < h->sz) { h = (SV_Hold *) 0; /* else continue */ if (!h) h->sz = n; { char dsk_nm[32]; if (bfs_dsk_write >= 0) if (bfs_dsk_write < 0) return h; /* no memcpy */ bfs_size_limit++; return h;EV_Hold *getsv_mask(int n){ EV_Hold *h; if (n == h->sz && (now._nr_pr == h->nrpr) && (now._nr_qs == h->nrqs) #if VECTORSZ>32000 h->nrpr = now._nr_pr; h->nrqs = now._nr_qs; if (now._nr_pr > 0) if (now._nr_qs > 0) h->nxt = kept; kept = h;freesv(SV_Hold *p){ SV_Hold *h, *oh; { if (h->sz >= p->sz) { p->nxt = svfree; svfree = p; { 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;push_bfs(Trail *f, int d) t = get_bfs_frame(); t->boq = boq; sv_populate(); t->onow = getsv(vsize); t->lstate = Lstate; if (!bfs_bot) { bfs_bot = bfs_trail = t; { bfs_bot->nxt = t; bfs_bot = t; t->nr = nstates;pop_bfs(void) if (!bfs_trail) { return (Trail *) 0; t = bfs_trail; bfs_trail = t->nxt; { bfs_bot = (BFS_Trail *) 0; if (t->lstate) { t->lstate->tagged = 0; t->nxt = bfs_free; bfs_free = t; vsize = t->onow->sz; boq = t->boq; (void) unlink(dsk_nm); bfs_dsk_read = -1; if (bfs_dsk_read < 0) #ifndef NOVSZ if (now._vsz != vsize) re_populate(); return t->frame; Trans *t2 = (Trans *) 0; uchar ot; int tt, E_state; if (shortcut) trpt->o_pm = 0; #ifdef HAS_UNLESS if (do_transit(t2, 0)) if (!reached[ot][t2->st]) E_state = t2->e_trans; if (t2->st > 0) reached[ot][t2->st] = 1; #ifndef NOCLAIM #ifdef PEG peg[t2->forw]++; trpt->o_pm |= 1; if (t2->atom&2)store_it:#if defined(BITSTATE)#elif defined(MA) nstates++; trpt->tau |= 64; { snapshot(); sdone = ndone; resize_hashtable(); if (boq != -1) midrv++; else if (oboq != -1) { Trail *x; { truncs++; #if !defined(BITSTATE) { trpt->tau |= 64; if (trpt->tau&32) { BFS_Trail *tprov; { trpt->tau |= 64; } } if (t2) do_reverse(t2, 0, 0); this = othis; trpt->o_pm = o_opm;Trail *ntrpt;{ Trans *t; Trail *otrpt, *x; uchar _n, _m, ot, nps = 0; int tt, E_state; short oboq = boq; trpt->o_tt = -1; if (trpt->o_pm & 4) trpt->o_pm); nps = 0; if (trpt->o_pm == 8) { revrv++; if (trpt->tau&8) trpt->o_pm, trpt->tau); trpt->tau &= ~8; else if (trpt->tau&32) trpt->tau &= ~32; trpt->o_pm &= ~(4|8); if (trpt->o_tt > mreached) { mreached = trpt->o_tt; if (mreached%%10 == 0) depth = trpt->o_tt; if (depth >= maxdepth) Trail *x; truncs++; if (!warned) { warned = 1; if (bounded)Pickup: this = pptr(II); { t = trans[ot][tt]; if (t->qu[0] != 0) { Ccheck++; if (!q_cond(II, t)) continue; Cholds++; From = To = II; #ifdef DEBUG depth, II, trpt->tau); goto MainLoop;Repeat: nlinks++; { From = now._nr_pr-1; To = BASE;MainLoop: _n = _m = 0; this = pptr(II); { continue; ntrpt->pr = (uchar) II; ntrpt->st = tt; E_state = 0; if (E_state > 0 ntrpt->o_t = t; oboq = boq; peg[t->forw]++; depth, II, t->forw); tt, t->st, t->tp, (t->atom&2)?"atomic":"", if (t->e_trans) E_state = t->e_trans; #if SYNC>0 pan_exit(1); if (t->st > 0) ntrpt->st = tt; ntrpt->tau = 0; trpt--; t->forw, tt, t->st); printf("tau=%%d,%%d]\n", reached[ot][t->st] = 1; reached[ot][tt] = 1; ((P0 *)this)->_p = tt; _n |= _m; _n = 0; trpt->tau &= ~32; if (II >= BASE) { goto Pickup; trpt->tau &= ~(32|64); if (_n != 0) { failedrv++; if (!x) this = pptr(otrpt->pr); boq = -1; push_bfs(x, x->o_tt); } else if (now._nr_pr > 0) depth, II+1); goto Repeat;#ifndef VERIputter(Trail *trpt, int fd){ long j; if (!trpt) return; if (trpt->o_t) j = strlen(snap);nuerror(char *str){ int fd = make_trail(); int j; if (fd < 0) return; sprintf(snap, "-4:-4:-4\n"); trcnt = 1; putter(trpt, fd); if (ntrpt->o_t) { wrapup(); #ifndef _CONSOLE #define _CONSOLE #ifdef WIN64 #undef long #include #define long long long #include #include #include #define VVERBOSE (1) #define VVERBOSE (0)#ifndef VMAX #define VMAX VECTORSZ#ifndef PMAX #define PMAX 64#ifndef QMAX #define QMAX 64 #define OFFT int #define OFFT short#ifdef SET_SEG_SIZE double GWQ_SIZE = 0.;#ifndef ONESECOND #define ONESECOND (1<<25)#ifndef SHORT_T #define SHORT_T (0.1)#ifndef LONG_T #define LONG_T (600) volatile uchar m_tau; volatile uchar m_o_pm;};int store_proxy_pid;short remote_party;int tas(volatile LONG *); void *shmid_X;int tas(volatile int *); long shmid_X; 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 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;char *sprefix = "rst";char *my_heap;long my_size;volatile int *prfree;volatile int *prfull;volatile int *prcnt;volatile int *prmax;static int dfs_phase2;void sudden_stop(char *);void enter_critical(int);void leave_critical(int);record_info(SM_results *r) uchar *ptr; r->m_memcnt = 0; #ifdef BITSTATE r->m_memcnt = memcnt; { r->m_nstates = nstates; r->m_nShadow = 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_hmax = hmax; r->m_svmax = svmax; r->m_smax = smax; r->m_mreached = mreached; r->m_errors = errors; r->m_VMAX = vmax_seen; ptr = (uchar *) &(r->m_R);retrieve_info(SM_results *r) volatile uchar *ptr; enter_critical(GLOBAL_LOCK); if (verbose && core_id == 0) { printf("qmax: "); for (i = 0; i < NCORE; i++) { printf("%%d ", prmax[i]); printf("G: %%d", *grmax); 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; errors += r->m_errors; ptr = &(r->m_R); { if (*(ptr + j) != 0) { reached[i][j] = 1;static voidrm_shared_segments(void){ int m; /* { if (shmid[m] != -1) if (shmid_M != -1)sudden_stop(char *s){ char b[64]; if (proxy_pid != 0) { rm_shared_segments(); if (core_id == 0) DWORD dwExitCode = 0; printf("cpu0: %%s\n", b); if (was_interrupted == 0) issued_kill++; static int count = 0; || *search_terminated != 0) { if (count++ < 100*NCORE) { return 0; { return 1; count = 0; crash_reset();sleep_report(void) if (free_wait > 1000000.) if (!a_cycles)#ifndef MAX_DSK_FILEmulti_usage(FILE *fd){ static int warned = 0; fprintf(fd, "\n");typedef struct Stack_Tree {} Stack_Tree;#ifndef CACHE_NR #define CACHE_NR 1024volatile Stack_Tree *stack_prefetch(void){ volatile Stack_Tree *st; if (nr_cached == 0) nr_cached = CACHE_NR; nr_cached--; return st; st->pr = II; st->t_id = t_id; stack_last[core_id] = st;Pop_Stack_Tree(void) if (cf) core_id, depth);e_critical(int which){ double cnt_start; { if (!readtrail && verbose) if (r == 0) { iamin[which] = 1; return; /* locked */ lock_wait++; cnt_start = lock_wait; if (someone_crashed(1))x_critical(int which) if (iamin[which] != 1) { if (iamin[which] > 1) if (!readtrail && verbose) fflush(stdout); { if (!readtrail) if (sh_lock != NULL) { iamin[which] = 0; char *args[32], *ptr; int argcnt = 0; args[argcnt++] = "proxy"; args[argcnt++] = Q_arg; args[argcnt++] = Z_arg; args[argcnt++] = Y_arg; if (strlen(o_cmdline) > 0) { while (*ptr == ' ') { *ptr++ = '\0'; } while (argcnt < 31); args[argcnt] = NULL;{ key_t key[NR_QS]; int n, m; int must_exit = 0; if (core_id == 0 && verbose) if (key[m] == -1) memcnt += qsize; if (shmid[m] == -1) m_workq[m][n].m_boq = 0; if (must_exit)static uchar *{ char *rval; key_t key; (double) n / (1048576.)); if (key == -1) if (core_id == 0) /* root */ if (shmid_S != -1) memcnt += (double) n; } else /* worker */ if (shmid_S == -1) rval = (char *) emalloc(n); return (uchar *) rval;#define TRY_AGAIN 1#define NOT_AGAIN 0static char shm_prep_result; return NULL; { perror("ftok T"); if (shmid_M == -1) perror("state mem");{ volatile char *x; double get_mem; volatile char *dc_mem_start; #ifndef MEMLIM #ifdef FULL_TRAIL shmid_X = (long) x; x += NCORE * sizeof(double); x += CS_NR * sizeof(void *); prfree = (volatile int *) x; x += NCORE * sizeof(void *); prfull = (volatile int *) x; prcnt = (volatile int *) x; prmax = (volatile int *) x; #ifdef FULL_TRAIL #ifndef BITSTATE #ifndef MEMLIM #warning MEMLIM not set #define MEMLIM (2048) if (need_mem <= 0.) need_mem/(1048576.)); SEG_SIZE = need_mem / NCORE; SEG_SIZE/(1048576.)); SEG_SIZE/(1024.*1024.)); mem_reserved = need_mem; while (need_mem > 1024.) { get_mem = need_mem;shm_more: if (get_mem <= 0.0) break; if (x == NULL) || first_pool != NULL SEG_SIZE /= 2.; if (SEG_SIZE >= 1024.) { goto shm_more; need_mem -= get_mem; got_mem += get_mem; if (first_pool == NULL) x += sizeof(void *); x += sizeof(double); #ifdef COLLAPSE x += sizeof(sh_Allocater); dc_shared->dc_arena = x; if (last_pool == NULL) last_pool = dc_shared; { first_pool = dc_shared; if (need_mem > 1024.) if (!first_pool) dc_shared = first_pool; int { int r; __asm__ __volatile__( "xchgl %%0, %%1 \n\t" : "0"(1), "m"(*s) : "memory"); return r; #elif defined(__arm__) { int r = 1; "swpb %%0, %%0, [%%3] \n" : "=r"(r), "=m"(*s) : "0"(r), "r"(s)); " ldstub [%%2], %%0 \n" : "r"(s)); /* Intel Itanium */ { long int r; " xchg4 %%0=%%1,%%2 \n" : "=r"(r), "+m"(*s) : "r"(1) : "memory"); return (int) r;cleanup_shm(int val) unsigned long cnt = 0; if (nibis != 0) { nibis = 1; for (m = 0; m < NR_QS; m++) { /* before detaching: */ cnt / (long)(1048576)); core_id, nstates_get);extern void give_up(int);extern void Read_Queue(int);mem_get(void){ SM_frame *f; int is_parent; { is_parent = fork(); if (is_parent == -1) { proxy_pid_snd = fork(); if (proxy_pid_snd == -1) if (proxy_pid_snd == 0) } } /* else continue */ if (is_parent > 0) } else /* worker */ static char db1[16]; signal(SIGINT, give_up); { int i; volatile sh_Allocater *ptr; ptr = first_pool; { if (i == core_id) if (my_heap == NULL) nstates, nstates_put); dfs_phase2 = 1; nstates_put, nstates_get); done = 1;grab_shared(int n) char *rval = (char *) 0; if (n == 0) /* no locking */ { rval = my_heap; my_heap += n; my_size -= n; if (!dc_shared) { static int noted = 0; if (!noted) { noted = 1; if (dc_shared->dc_size < n) if (dc_shared->nxt == NULL wrapup(); /* exits */ dc_shared->dc_arena += n; if (VVERBOSE)done: memset(rval, 0, n); return (struct H_el *) rval;SM_frame *Get_Full_Frame(int n){ SM_frame *f; f = &m_workq[n][prfull[n]]; { iam_alive(); #ifndef SAFETY if (f->m_vsize == 0) *gr_writemiss++; enter_critical(GQ_WR); *grcnt = *grcnt - 1; leave_critical(GQ_WR); leave_critical(GQ_RD); return f; { if (0)Get_Free_Frame(int n) { f = &(m_workq[n][lrfree]); cnt_start = free_wait; if (n != NCORE) enter_critical(QLOCK(n)); if (prmax[n] < prcnt[n]) { prmax[n] = prcnt[n]; leave_critical(QLOCK(n));GlobalQ_HasRoom(void){ int rval = 0; gq_tries++; if (*grcnt < GN_FRAMES) *gr_readmiss++; gq_hasroom++; { gq_hasnoroom++;out: leave_critical(GQ_WR); static struct H_el D_State; if (f->m_vsize > 0) { boq = f->m_boq; if (boq > 256) return 0; vsize = f->m_vsize;correct: if (vsize != now._vsz) vsize = now._vsz; hmax = max(hmax, vsize); if (f != &cur_Root) { A_depth = depthfound = 0; trpt = &trail[1]; trpt->tau = f->m_tau; trpt->o_pm = f->m_o_pm; trpt->ostate = &D_State; #if defined(VERBOSE) if (stack_last[core_id]) if (!trpt->o_t) { static Trans D_Trans; trpt->o_t = &D_Trans; #ifdef VERI if ((trpt->tau & 4) != 4) { P0 *ptr = (P0 *) pptr(i); #ifdef EVENT_TRACE #ifndef NP { trpt->o_pm |= 2; { trpt->o_pm |= 4; #if (HAS_STACK==1) if (cur_Root.m_vsize == 0) fd = creat(fnm, TMODE); if (fd < 0) perror("cause");set_root(void) char *ssuffix = "rst"; int try_core = 1; if (whichtrail > 0) { ssuffix = MySuffix; close(fd); { int i, j; P0 *z; { z = (P0 *)pptr(i); c_locals(i, z->_t);void mem_drain(void);m_clear_frame(SM_frame *f) memset(f, 0, clr_sz);AllQueuesEmpty(void){ int q; if (*grcnt != 0) for (q = 0; q < NCORE; q++) { if (prcnt[q] != 0)Read_Queue(int q){ SM_frame *f, *of; int remember, target_q; SM_results *r; double patience = 0.0; target_q = (q + 1) %% NCORE; { f = Get_Full_Frame(q); { if (someone_crashed(2)) sudden_stop("");#ifdef TESTING exit(0); remember = *grfree; && AllQueuesEmpty()) continue; if (f->m_boq == QUERY) snapshot(); remember = f->m_vsize; { if (verbose) m_clear_frame(f); if (verbose) mem_drain(); query_in_progress = 0; f->m_vsize = remember; { mem_drain(); if (f->m_boq == QUERY_F) if (f->m_boq == QUIT) if (core_id != 0) if (verbose>1) { nstates_get++; { pan_exit(0);give_up(int unused_x) if (!writing_trail) { was_interrupted = 1; cpu_printf("Give Up\n"); sleep_report(); { cpu_printf("SIGINT\n");check_overkill(void) if (core_id == 0 && !remote_party && nstates_put > 0 && VMAX - vmax_seen > 8) if (vsize > VMAX) Uerror("aborting"); if (now._nr_pr > PMAX) if (now._nr_qs > QMAX) { if (Mask[i]) { f->m_Mask[i/8] |= (1<m_tau = trpt->tau; f->m_o_pm = trpt->o_pm; f->m_boq = boq; if (query_in_progress == 1) nstates_put++;int Dsk_W_Nr, Dsk_R_Nr;char dsk_name[512];#ifndef BFS_DISKdsk_stats(void) if (dsk_written > 0) close(dsk_read); close(dsk_file); unlink(dsk_name);mem_drain(void){ SM_frame *f, g; int sz; if (dsk_read < 0 && TargetQ_NotFull(q)) { f = Get_Free_Frame(q); if (dsk_read < 0) sz = g.m_vsize; g.m_vsize = 0; f->m_vsize = sz; /* last */ dsk_drained++;mem_file(void){ SM_frame f; { f.m_Mask[i/8] |= (1<tau; f.m_o_pm = trpt->o_pm; f.m_boq = boq; f.m_vsize = vsize; { query_in_progress = 2; if (dsk_file < 0) dsk_written++;mem_hand_off(void) #ifdef GENEROUS if (prcnt[q] < LN_FRAMES) if (TargetQ_NotFull(q) { mem_put(q); { int rval; rval = GlobalQ_HasRoom(); rval = 0; #ifdef USE_DISK if (rval == 0) { void mem_file(void); mem_file(); rval = 1; return rval; || *search_terminated != 0) if (TargetQ_Full(q)) if (GlobalQ_HasRoom()){ char key[512]; key); /* name */ key); if (shmid[m] == NULL) core_id); must_exit = 1; /* attach: */ if (shared_mem[m] == NULL) must_exit = 1; if (shmid_S == NULL) if ((char *) rval == NULL) if (shmid_M == NULL) core_id, cnt-3, n); if (rval == NULL) return NULL; char *dc_mem_start; /* NCORE * stack_last */ shmid_X = (void *) x; if (get_mem <= 0) get_mem/(1048576.)); x += CS_NR * sizeof(int);tas(volatile LONG *s) static int nibis = 0; { if (shmid[m] != NULL) CloseHandle(shmid[m]); if (shmid_S != NULL) { UnmapViewOfFile(SS); CloseHandle(shmid_S); { UnmapViewOfFile(H_tab); CloseHandle(shmid_M); proxy_pid); { char cmdline[64]; PROCESS_INFORMATION pi; if (is_parent == 0) { Uerror("fork failed");init_SS(unsigned long n)clock_t start_time;clock_t crash_stamp;struct tms start_tm;start_timer(void) start_time = clock();stop_timer(void){ clock_t stop_time; struct tms stop_tm; stop_time = times(&stop_tm); stop_time = clock(); if (delta_time > 0.01) check_overkill();#ifdef T_ALERTdouble t_alerts[17];crash_report(void) for (i = 0; i < 17; i++)crash_reset(void){ /* false alarm */ double delta_time; int i; for (i = 0; i < 16; i++) { if (delta_time <= (i*30)) crash_stamp = (clock_t) 0;crash_test(double maxtime){ double delta_time; { /* start timing */ crash_stamp = clock();do_the_search(void) depth = mreached = 0; trpt = &trail[0]; if (!(trpt->o_pm&2) if (!(trpt->o_pm&4) Mask[i] = 1; /* _a_t */ { int j = 0; while (j++ < NFAIR) c_init_done++; start_timer(); bfs(); srand(s_rand); mem_get();#ifdef INLINE_REV{ uchar _m = M;#include REVERSE_MOVESR999: return _m;#ifndef INLINE{ uchar _m = 0;#ifdef M_LOSS uchar delta_m = 0;#define continue return 0#ifdef SEPARATE#include FORWARD_MOVESP999:#undef continuerequire(char tp, int qid) _tp = tp; _qid = qid; if (now._event != endevent) { now._event = t->st; (trpt+1)->o_pm |= 2; (trpt+1)->o_pm |= 4;#ifdef NEGATED_TRACE depth++; trpt++; trpt--; depth--; elseenabled(int iam, int pid) /* if (pid > 0) */ pid++; if (pid == iam) this = pptr(pid); TstOnly = 1; tt = (int) ((P0 *)this)->_p; { res = 1; TstOnly = 0; return res;snap_time(void) stop_time = clock(); sudden_stop("time-limit");snapshot(void) mreached, nstates); snap_time();stack2disk(void) if (!stackwrite != DDD*sizeof(Trail)) CNT1++;disk2stack(void){ long have; CNT2++;Pptr(int x){ if (x < 0 || x >= MAXPROC || !processes[x]) || !proc_offset[x]) return noptr; return (uchar *) pptr(x);Qptr(int x){ if (x < 0 || x >= MAXQ || !channels[x]) || !q_offset[x]) return noqptr; return (uchar *) qptr(x);int qs_empty(void);#ifdef NSUCCint N_succ[512];tally_succ(int cnt)dump_succ(void){ int i; double sum = 0.0; double w_avg = 0.0; for (i = 0; i < 512; i++) { sum += (double) N_succ[i]; { if (N_succ[i] > 0) if (sum > N_succ[0])select_claim(int n){ int m, i; if (n < 0 || n >= NCLAIMS) #define FROM_P (BASE) #define MORE_P (II <= To) #define INI_P (From-1) #define UPTO_P (BASE) #define MORE_P (II >= BASE) #define INI_P (From+1) * e.g. by saying:new_state(void) uchar _n, _m, ot; short ooi, eoi; short II, JJ = 0, kk; int tt;Down: if (depth > hiwater) { stack2disk(); maxdepth += DDD; hiwater += DDD; trpt -= DDD; CNT1, hiwater, maxdepth); trpt->proviso = 0; trpt->n_succ = 0; if (mem_hand_off()) { if (!warned) { warned = 1;AllOver: * matched in hstore below (char *)&now, vsize)) depthfound = A_depth; goto Up; printf("not seed\n"); { int xj; { now._ctx = xj; if (II != 0) { break; } #ifdef FULLSTACK { int xj; now._ctx = 0; JJ = onstack_now(); #else #endif#ifndef FULLSTACK JJ = II; JJ = (II == 2)?1:0; /* @hash j1_spin II */ kk = (II == 1 || II == 2); #ifndef NOFAIR goto same_case; { int oj1 = j1_spin; uchar o_a_t = now._a_t; now._a_t &= ~(1|16|32); if (onstack_now()) { II = 3; now._a_t = o_a_t; j1_spin = oj1; { II = 0; } else nShadow--; if (upto > 0) { Pop_Stack_Tree(); goto Up; } { (trpt-1)->tau |= 16; #ifndef LOOPSTATE (trpt-1)->tau |= 16; truncs2++; (trpt-1)->tau |= 64; if (!II || !JJ) { (trpt-1)->tau |= 64; if (II) if (depth == 0) { return; if (!kk) zstates += (double) hfns; if (ndone != sdone) zap_hashtable(); zstates = 0; if (vprefix > 0) #ifdef SHO if (HASH_NR != 0) { int oh = HASH_NR; HASH_NR = 0; HASH_NR = oh; wrapup(); { void w_xpoint(void); w_xpoint(); onstack_put();#ifdef DEBUG2 trpt->ostate, trpt->ostate = Lstate; if (depth > mreached) mreached = depth; _n = 0; (trpt+1)->o_n = 0;Stutter: II = 0; /* never */ goto Veri0; if (boq == -1 && From != To #if NCORE>1 && (depth < z_handoff) #ifdef BCS && (!(now._a_t&1) || (a_cycles && #ifndef BITSTATE !((trpt-1)->proviso)) !(trpt->proviso)) (trpt-1)->ostate && (trpt-1)->ostate && trpt->ostate->proviso == 0) )) { for ALL_P t->om = 0; goto Again;Again: if (fairness && boq == -1 && !(trpt->tau&8)) if (!(now._a_t&2)) { /* Accepting state */ now._a_t |= 2; trpt->o_pm |= 8; { now._a_t &= ~2; now._cnt[now._a_t&1] = 0; trpt->o_pm |= 16; trpt->bcs = B_PHASE1; #ifdef REVERSE if (trpt->p_left > 1) { trpt->p_skip = -1;r_switch: if (trpt->p_skip >= 0) if (trpt->p_left == 0) break; /* done */ depth, II, trpt->p_left); trpt->p_left--; if ((trpt->bcs & B_PHASE1) && trpt->b_pno != II)Veri0: t = trans[ot][tt]; if (!(trpt->tau&4) && !(trpt->tau&1) && !(trpt->tau&32) && (t->atom & 8) && From != To) { if (t->qu[0] == 0 || q_cond(II, t)) { _m = t->om; if (fairness && !(trpt->o_pm&32) && (now._a_t&2) if (II == 1) now._cnt[now._a_t&1] = 1; trpt->o_pm |= (32|64); trpt->e_state = 0; (trpt+1)->pr = (uchar) II; (trpt+1)->st = tt; || t->e_trans != 0 ) { eoi++; if (eoi > 0) { eoi = rand()%%ooi; if (eoi-- <= 0) break;domore: */ if (trpt->e_state > 0 (trpt+1)->o_t = t;#ifdef INLINE if (depth > BASE && II >= BASE && From != To #ifndef BCS_NOFIX && boq == -1 && (trpt->bcs & B_PHASE2) if (boq == -1) trpt->tau |= 16; if (loopstate[ot][tt]) cnt_loops++;#if defined(SVDUMP) if (II != 0) now._last = II - BASE; trpt->pr = (uchar) II; trpt->st = tt; trpt->o_pm &= ~(2|4); if (a_cycles) int ii;#define P__Q ((P0 *)pptr(ii)) trpt->o_pm |= 2; { trpt->o_pm |= 2; } } { trpt->o_pm |= 4;#undef P__Q trpt->tau = 0; trpt->oo_i = ooi; { trpt->tau |= 8; if((trpt-1)->tau&4) trpt->tau |= 4; trpt->tau &= ~4; { if ((trpt-1)->tau&4) trpt->tau |= 1; if (processes[II]) depth, II, trpt);Up: if (processes[trpt->pr]) depth, trpt->pr, trpt); iam_alive();#if defined(MA) || NCORE>1 if (depth <= 0) return; if (CNT1 > CNT2 trpt += DDD; disk2stack(); maxdepth -= DDD; hiwater -= DDD; if(verbose) depth--; trpt--; goto Q999; { int d; Trail *trl; now._last = 0; if (trl->pr != 0) break; } } } ooi = trpt->oo_i; && (trpt->tau&16)) #ifdef SAFETY && (trpt->tau&64)) trpt->n_succ++; if (_m) { reached[ot][t->st] = 1; reached[ot][tt] = 1; } /* all options */ if (!t && ooi > 0) goto domore; else /* Fairness: undo Rule 2 */ if ((trpt->o_pm&32) && (trpt->o_pm&64)) { if (trpt->o_pm&1) trpt->o_pm &= ~(32|64); { if (_n > 0) { trpt->o_pm &= ~64; II = INI_P; } /* all processes */ tally_succ(trpt->n_succ); if (trpt->p_left > 0) if (trpt->bcs & B_PHASE1) From = FROM_P; To = UPTO_P; goto c_switch; { _n = 1; now._cnt[now._a_t&1] = 2; now._cnt[now._a_t&1] += 1; trpt->o_pm &= ~32;#ifdef ETIM /* see below */ { depth++; trpt++; trpt->tau = 4; goto Down; if (trpt->o_pm&8) trpt->o_pm &= ~8; depth, now._a_t); if (trpt->o_pm&16) { now._a_t |= 2; trpt->o_pm &= ~16; #ifdef LOOPSTATE { if (!(now._a_t&1)) (trpt-1)->proviso = 1; trpt->proviso = 1; if ((trpt-1)->ostate) trpt->ostate->proviso = 1; goto Resume; if (boq != -1) goto Done; || endstate() { trpt->tau &= ~(1|8); /* 1=timeout, 8=atomic */ goto AllOver; if (trpt->tau&4)#ifndef NTIM { trpt->tau |= 1; trpt->tau &= ~2; goto Stutter; if ((trpt->tau&8) && !((trpt-1)->tau&4)) depth); trpt->tau |= 1;BreakOut:#ifndef NOSTUTTER if (!(trpt->tau&4)) { depth--; trpt--; uerror("accept stutter");Done: if (boq == -1 || ( (trpt-1)->tau&128)))#if defined(FULLSTACK) depth, trpt->ostate, onstack_zap(); if (trpt->proviso) if (_n != 0 && (trpt->tau&4) && !(now._a_t&1)) if (fairness) now._a_t, now._cnt[0]); && (now._cnt[0] == 1)) checkcycles(); if (depth > 0) if (!a && !noasserts) { char bad[1024]; if (strlen(s) > 1000) bad[1019] = '\0'; strcpy(&bad[19], s); uerror(bad);#ifndef NOBOUNDCHECK a1, a2, a3); return x;wrap_stats(void) if (nShadow>0) nstates+truncs); #ifndef MA #ifndef AUTO_RESIZE #if 0wrapup(void) int mverbose = 1; int mverbose = verbose; void dsk_stats(void); signal(SIGINT, SIG_DFL); printf(" + Compression\n"); #ifdef R_XPT #ifdef FULLSTACK #ifdef CNTRSTACK #ifdef HC if (noasserts) printf("+\n"); fairness?"en":"dis"); printf("(disabled by "); if (noends) printf("-E flag)\n\n"); printf("never claim)\n\n"); printf("+\n\n"); mreached); if (done) if (maxgs+a_cycles+2 < MA) maxgs+a_cycles+2); dfa_stats(); Fa, Fh, Zh, Zn); PUT, PROBE, ZAPS);#if 1 nr1 = (nstates-nShadow)* nr2 = 0.0; nr3 = (double) (udmem); { double remainder = memcnt; mem_reserved/1048576.); #ifdef SEP_HEAP if (udmem) nr3/1048576., ssize); if (nr5 > 0.0) nr5/1048576.); tmp_nr/1048576.); remainder -= tmp_nr; printf(" ("); if (tmp_nr > 0.) (100.0*tmp_nr)/nr1); printf("less than 1k)\n"); remainder -= nr3; nr2/1048576., maxdepth); remainder -= nr2; #ifndef NGQ if (fragment > 1048576.) fragment/1048576.); memcnt/1048576.);jump_here: if (ncomps[i] != 0) printf("]\n"); #ifdef TRIX if (mverbose) printf("TRIX counts:\n"); printf(" processes: "); if (_p_count[i] != 0) { printf("%%3d:%%ld ", i, _p_count[i]); printf("\n channels : "); for (i = 0; i < MAXQ; i++) if (_c_count[i] != 0) i, _c_count[i]); printf("\n\n"); dumpranges(); dump_succ(); crash_report();stopped(int arg){ printf("Interrupted\n");#include #undef get16bits #ifndef get16bitsd_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); h += h >> 11; switch (rem) { case 3: h += get16bits(s); h ^= h << 16; h += h >> 11; case 2: h += get16bits(s); h ^= h << 11; h += h >> 17; case 1: h += *s; h ^= h << 10; h += h >> 1; h ^= h << 3; h += h >> 5; h ^= h << 4; h ^= h << 25; h += h >> 6; K1 = h;/* 64-bit Jenkins hash, 1997#define mix(a,b,c) \/* 32-bit Jenkins hash, 2006#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); \d_hash(uchar *kb, int nbytes){ uint8_t *bp; uint64_t a = 0, b, c, n; uint32_t a = 0, b, c, n; a = WS - (nbytes %% WS); if (a > 0 && a < WS) { n++; bp = kb + nbytes; switch (a) { case 1: *bp = 0; case 0: break; 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; case 2: b += k[1]; case 1: a += k[0]; a = c = 0xdeadbeef + (n<<2); while (n > 3) switch (n) { case 3: c += k[2]; final(a,b,c); K1 = c; K2 = b;s_hash(uchar *cp, int om)#if defined(SFH) if (S_Tab == H_tab) j1_spin = K1 %% omaxdepth; if (ssize < 8*WS) j1_spin = K1&mask; j1_spin = K1;#ifndef RANDSTORint *prerand;inirand(void) prerand[i] = rand();pan_rand(void){ if (!prerand) inirand(); return prerand[depth];set_masks(void) /* 4.2.5 */ if (WS == 4 && ssize >= 32) { mask = 0xffffffff; switch (ssize) { nmask = mask; } else if (WS == 8) nmask = mask>>3; } else if (WS != 4) nmask = (mask>>3);static long reclaim_size;static char *reclaim_mem;static struct H_el **N_tab;{ if (!p) return; reverse_capture(p->nxt); /* to preserve list-order */ j2 = p->m_K1; { j2 &= mask; p->nxt = N_tab[j2]; N_tab[j2] = p;resize_hashtable(void) N_tab = (struct H_el **) H_tab = N_tab; printf(" done\n");zap_hashtable(void)find_claim(char *s) { if (spin_c_typ[j] == i) { return j; return -1; /* unreachable */main(int argc, char *argv[]){ void to_compile(void); efd = stderr; /* default */ if (G_long != sizeof(long) || G_int != sizeof(int)) s_rand = T_RAND; s_rand = P_RAND; if (ptr == NULL) { ptr = argv[0]; { ptr++; strcpy(progname, ptr); { int i, j; strcpy(o_cmdline, ""); for (j = 1; j < argc; j++) strcat(o_cmdline, " "); { switch (argv[1][1]) { usage(efd); break; stackfile = &argv[1][2]; case 'L': sched_max = 255; #ifndef NOREDUCE if (sched_max == 0) case 'M': case 'G': case 'N': if (isdigit(argv[1][2])) { claimname = argv[2]; } #if NCLAIMS==1 { argc--; argv++; break; #if NCORE==1 #ifndef FREQ case 'R': case 'r':samething: readtrail = 1; case 's': hfns = 1; break; case 'v': verbose++; break; if (verbose) argc--; argv++; { TMODE = 0666; if (WS > 4) if (TMODE == 0666) TMODE = _S_IREAD; if (z_handoff < 0) #if NCORE>2 #ifndef SEP_STATE #ifdef HAS_HIDDEN if (hfns <= 0) { hfns = 1; omaxdepth = maxdepth; if (WS == 4 && ssize > 34) { ssize = 34; if (WS == 4 && ssize > 27) { ssize = 27; hiwater = HHH = maxdepth-10; DDD = HHH/2; if (!stackfile) if (iterative) if (iterative && a_cycles) #ifdef SC #ifdef HAS_LAST #ifdef HAS_STACK #ifdef BCS #ifdef REACH #ifdef MA #ifdef P_RAND #ifdef SFH #ifdef NOCOMP #if MA <= 0 if (a_cycles && fairness) if (Nrun < 1 || Nrun > 32) usage(efd); if (fairness && !a_cycles) #if ACCEPT_LAB==0 #ifdef HAS_ENABLED #ifdef HAS_PCVALUE #ifdef HAS_BADELSE #ifdef BFS#if SYNC>0 && defined(BFS)#if defined(VERI) #if ACCEPT_LAB>0 if (!a_cycles #ifdef HAS_CODE && !readtrail #if NCORE>1 && core_id == 0 && !state_tables) if (!state_tables { S_A = 0; { if (!fairness) { S_A = 1; /* _a_t */ signal(SIGINT, stopped); set_masks(); trail += 3; { char nm[64]; vprefix = 0;#if SYNC>0 && ASYNC==0 set_recvs(); run(); multi_usage(fd);Malloc(unsigned long n){ char *tmp; goto err; tmp = (char *) malloc(n); if (!tmp)err:#ifndef HC #ifdef SEP_STATE return tmp;#define CHUNK (100*VECTORSZ) have = Malloc(grow); left = grow; tmp = have; have += (long) n; left -= (long) n; memset(tmp, 0, n);Uerror(char *str){ /* always fatal */ uerror(str); sudden_stop("Uerror");Unwind(void) uchar oat = now._a_t; now._a_t = oat; depth--; trpt = getframe(depth); now._event = trpt->o_event; { now._a_t &= ~(1|16|32); A_depth = 0; t = trpt->o_t; t->tp, now._a_t, A_depth); trpt->tau, (trpt-1)->tau); if ((trpt->o_pm&32))Q999:CameFromHere: return depth; if (depth > 0) goto Up;static char unwinding;{ static char laststr[256]; int is_cycle; strncpy(laststr, str, 254); errors++; if (!is_cycle) if ((every_error != 0) || errors == upto) if (is_cycle) { int od = depth; unwinding = 1; depthfound = Unwind(); unwinding = 0; depth = od; writing_trail = 1; if (depth > 1) trpt--; nuerror(str); if (depth > 1) trpt++; putrail(); if (strstr(str, " cycle")) { if (every_error) writing_trail = 0; { if (maxdepth > depth) warned = 1; maxdepth); sudden_stop("uerror"); depthfound = -1;{ Trans *T; int j, retval=1; if (T && T->tp) printf(", state %%d", i); if (strcmp(T->tp, "") != 0) { char *q; q = transmognify(T->tp); } else if (stopstate[M][i]) printf(", -end state-"); retval = 0; /* reported */ return retval;{ int i, m=0; case P_PROC: case A_PROC: case I_PROC: case E_TRACE: case N_TRACE: case N_CLAIM: default: for (i = 1; i < N; i++) { if (which[i] == 0 && (mapstate[M][i] == 0 { m++;static long rev_trail_cnt;{ long j; char snap[64]; if (!st_tr) rev_trail(fd, st_tr->prv); if (st_tr->pr != 255) } else /* handoff point */ { if (a_cycles)putrail(void) char snap[64]; long i, j; Trail *trl; fd = make_trail(); rev_trail_cnt = 1; for ( ; i <= depth; i++) { if (i == depthfound+1) { goto notgood; trl = getframe(i); if (!trl->o_t) continue;{ if (!svtack->nxt) svmax++; svtack = svtack->nxt; svtack->o_boq = boq; boq = svtack->o_boq; Uerror("sv_restor"); if (!svtack->lst) Uerror("error: sv_restor"); svtack = svtack->lst; cpu_printf(" sv_restor\n");p_restor(int h) char *z = (char *) &now; char *oi; p_name[h] = stack->o_name; vsize += sizeof(char *); processes[h] = freebodies; oi = stack->b_ptr; Mask[i-1] = 1; /* align */ vsize += stack->o_skip; vsize += stack->o_delta; if (BASE > 0 && h > 0) ((P0 *)pptr(h))->_pid = h; now._nr_pr += 1; i = stack->o_delqs; if (!stack->lst) Uerror("error: p_restor"); stack = stack->lst; this = pptr(h); while (i-- > 0) q_restor();q_restor(void){ int h = now._nr_qs; { Uerror("channels error"); channels[h] = freebodies; char *z = (char *) &now; int k, k_end; q_name[h] = stack->o_name; k_end = stack->o_offset; k = k_end - stack->o_skip; #if SYNC for ( ; k < k_end; k++) Mask[k] = 1; Uerror("error: q_restor");typedef struct IntChunks { int *ptr; struct IntChunks *nxt;} IntChunks;IntChunks *empty_chunks[512];int *grab_ints(int nr){ IntChunks *z; if (filled_chunks[nr]) { z = filled_chunks[nr]; } else z->nxt = empty_chunks[nr]; empty_chunks[nr] = z; return z->ptr;ungrab_ints(int *p, int nr) z = empty_chunks[nr]; z->ptr = p; z->nxt = filled_chunks[nr]; filled_chunks[nr] = z;delproc(int sav, int h){ int d, i=0; int o_vsize = vsize; if (h+1 != (int) now._nr_pr) while (now._nr_qs > 0 { delq(sav); d = processes[h]->psize; if (sav) { if (!stack->nxt) stack->nxt->lst = stack; smax++; stack = stack->nxt; #ifndef XUSAFE stack->o_delta = d; stack->o_delqs = i; freebodies = processes[h]; vsize -= sizeof(char *); now._nr_pr -= 1; while (now._nr_qs d = vsize - proc_offset[h]; vsize = proc_offset[h]; vsize -= (int) proc_skip[h]; Mask[i] = 0; /* reset */delq(int sav){ int h = now._nr_qs - 1; int k, o_vsize = vsize; vsize = q_offset[h]; vsize -= (int) q_skip[h]; Mask[k] = 0; /* reset */ now._nr_qs -= 1; freebodies = channels[h];qs_empty(void) { if (q_sz(i) > 0)endstate(void){ int i; P0 *ptr; { ptr = (P0 *) pptr(i);checkcycles(void){ uchar o_a_t = now._a_t; uchar o_cnt = now._cnt[1]; printf("\n"); now._a_t |= (1|16|32); now._cnt[1] = now._cnt[0]; mem_put_acc(); now._cnt[1] = o_cnt; trpt->proviso = prov;{ struct H_el *v, *last = 0; if (H_tab == S_Tab) { if ((int) v->tagged == n) { if (last) last->nxt = v->nxt; v->tagged = 0; v->nxt = 0; v->ln = 0; return v; Fh++; last=v; /* new: second try */ v = Free_list; goto gotcha; ngrabs++; return (struct H_el *) #ifndef AUTO_RESIZE struct H_el * grab_state(int n) { struct H_el *p; if (reclaim_size >= cnt+WS) reclaim_mem += cnt; reclaim_size -= cnt; memset(p, 0, cnt); return p; s_hash((uchar *)v, n); { if (n == tmp->ln) if (m == 0) if (m < 0) } else if (!tmp->nxt) if (n < tmp->ln) goto Insert; else if (!tmp->nxt) goto Append; m = ++ncomps[tp]; tmp->tagged = m; tmp->st_id = m; tmp->m_K1 = K1; tmp->ln = n; return tmp->tagged; return tmp->st_id; int i, j; unsigned long n; static char *x; long col_q(int, char *); long col_p(int, char *); *v++ = now._a_t; for (i = 0; i < NFAIR; i++) *v++ = now._cnt[i]; nbytelen = 0;#ifndef JOINPROCS { n = col_p(i, (char *) 0);#ifdef NOFIX nbytes[nbytelen] = 0; nbytes[nbytelen] = 1; *v++ = n&255; if (n >= (1<<8)) { nbytes[nbytelen]++; *v++ = (n>>8)&255; if (n >= (1<<16)) *v++ = (n>>16)&255; if (n >= (1<<24)) *v++ = (n>>24)&255; nbytelen++; x = scratch; x += col_p(i, x);#ifdef SEPQS { n = col_q(i, (char *) 0); w += NFAIR; *x++ = now._nr_pr; *x++ = now._nr_qs; n = qptr(0) - (uchar *) w; n = pptr(0) - (uchar *) w; j = w - (char *) &now; if (!Mask[j++]) *x++ = *w;#ifndef SEPQS x += col_q(i, x); x--; { if (j == 6) { j = 0; *(++x) = 0; j += 2; *x |= (nbytes[i] << j); x++; x -= j; j = 0;#if !defined(NOCOMP) { delta++; /* _a_t */ if (S_A > NFAIR) delta += WS;#if HC>0 delta += HC; return delta; char *vv = vin; #ifndef NO_FAST_C int r = 0, unroll = n/8; if (unroll > 0) { i = 0; while (r++ < unroll) switch (r) { switch (i) { case 6: *v++ = 0; case 5: *v++ = 0; case 4: *v++ = 0; case 3: *v++ = 0; case 2: *v++ = 0; case 1: *v++ = 0; v -= i; if (!Mask[i]) *v++ = *vv; for (i = 0; i < WS-1; i++) *v++ = 0; n, v - (char *)&comp_now);#if defined(MA)#if !defined(onstack_now)int onstack_now(void) {}#if !defined(onstack_put)void onstack_put(void) {}#if !defined(onstack_zap)void onstack_zap(void) {}onstack_zap(void) char *nv; int n, m; static char warned = 0; uchar was_last = now._last; now._last = 0; H_tab = S_Tab; nv = (char *) &comp_now; nv = (char *) &now; n = vsize; s_hash((uchar *)nv, n); H_tab = tmp; goto Found;/* NotFound: */ if (warned == 0)Found: ZAPS++; S_Tab[j1_spin] = v->nxt; v->tagged = (unsigned) n; v->proviso = 0; { if ((int) w->tagged <= n) { v->nxt = w; last->nxt = v; { v->nxt = Free_list; Free_list = v; if (!w->nxt) { w->nxt = v; now._last = was_last;onstack_put(void){ struct H_el **tmp = H_tab; #ifndef ZAPH PUT++;onstack_now(void) struct H_el **tmp2 = H_tab; char *v; int n, m = 1; v = (char *) &now; H_tab = tmp2; if (m <= 0) PROBE++; return (m == 0);hinit(void) #ifdef MA { void r_xpoint(void); r_xpoint(); init_HT(0L); H_tab = (struct H_el **) /* @htable ssize */ V_A, wasnew, v[0]); printf(" %%d ", tag); printf(" State: "); printf("\n Vector: ");{ int n, i; int ret_val = 1; uchar *v; static uchar Info[MA+1]; n = compress(vin, nin); v = (uchar *) &comp_now; n = nin; v = (uchar *) vin; if (n >= MA) 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; { Info[MA] = Info[0]; Info[0] = 0; if (!dfa_store(Info)) { if (pbit == 0 && (now._a_t&1) && depth > A_depth) if (dfa_member(MA)) if (!dfa_member(MA-1)) { ret_val = 3; #ifdef VERBOSE goto done; ret_val = 0; printf("new state\n"); if (pbit == 0) if (dfa_member(MA-1)) printf("old state\n"); printf("on-stack\n"); ret_val = 1;{ int delta = 0;sv_populate(void) TRIX_v6 **base = processes; for (i = 0; i < bound; i++) { if (base[i] != NULL) { struct H_el *tmp; int m, n; uchar *v; { cnt++; #ifndef V_MOD base[i]->modified = 0; n = base[i]->psize; v = base[i]->body; tmp = H_tab[j1_spin]; if (!tmp) /* new */ { tmp = grab_state(n); H_tab[j1_spin] = tmp; m = 1; /* non-zero */ if (m == 0) /* match */ { break; { ntmp = grab_state(n); ntmp->nxt = tmp; if (!olst) H_tab[j1_spin] = ntmp; else olst->nxt = ntmp; tmp = ntmp; tmp = tmp->nxt; } } } if (m != 0) if (base == processes) { _p_count[i]++; { _c_count[i]++; { base = channels; goto again;{ struct H_el *ntmp; char *v; int n, m=0; uchar rem_a; { v = (char *) &comp_now; { v = vin; n = nin; #ifdef HC rem_a = now._a_t; now._a_t = 0; now._a_t = rem_a; { v[0] = 0; /* _a_t */ for (m = 0; m < NFAIR; m++) v[m+1] = 0; /* _cnt[] */ m = 0; { tmp = grab_state(n); if (!tmp) H_tab[j1_spin] = tmp; if (tmp->ln != 0) v + S_A, n - S_A); if (m == 0) {#define wasnew 0 int wasnew = 0; if (S_A) { wasnew = 1; nShadow++; if (S_A > NFAIR) { ci = (NFAIR - 1) - ci; ci++; /* skip over _a_t */ { if (!wasnew) { wasnew = 1; nShadow++; if (wasnew) tmp->tagged |= V_A; if ((now._a_t&1) && (tmp->tagged&A_V) && depth > A_depth)intersect: (int) tmp->st_id); leave_critical(CS_ID); return 3; && depth > A_depth goto intersect;#if defined(BCS) #ifdef CONSERVATIVE #ifdef CHECK nstates--; if (tmp->D > depth) { tmp->D = depth; } else if (m < 0) ntmp = grab_state(n); if (!ntmp) } else if (!tmp->nxt)Append: tmp->nxt = grab_state(n); if (!tmp->nxt) } } #ifdef CONSERVATIVE { v[0] = V_A; if (now._a_t&1) v[1+ci] = 1 << bp; dumpstate(-1, v, n, 0); #ifdef V_PROVISO tmp->cpu_id = core_id;#include TRANSITIONSstopstateprogstateaccpstate{ int j, h = now._nr_pr; uchar *o_this = this; #undef Index if (h >= MAXPROC) proc_skip[h] = 0; Mask[k-1] = 1; /* align */ vsize += (int) proc_skip[h]; proc_offset[h] = vsize; { int dummy = 0; (8*NFAIR)/2 - 2, NFAIR); NFAIR+1); processes[h]->psize = j; ((P0 *)this)->_pid = h; this = o_this; return h-BASE;col_p(int i, char *z) #undef REACH #define BASE 1 #define BASE 0typedef struct Trans { int st; /* the nextstate */ struct Trans *nxt;} Trans; extern uchar *Pptr(int);extern uchar *Qptr(int); #ifdef VECTORSZ #undef VECTORSZ #if WS==4 #ifndef VECTORSZ #ifndef CHECK #define CHECK #ifndef DEBUG #define DEBUG #define NOFAIR #define XUSAFE #define CNTRSTACK #define FULLSTACK #define NOCOMP #define LC #define COLLAPSE #undef HC #define HC4 #define HC 0 #define HC 1 #define HC 2 #define HC 3 #define HC 4#define MAXQ 255#define MAXPROC 255 int o_delta; #ifndef TRIX int o_offset; int o_skip; int o_delqs; short o_delta; short o_offset; short o_skip; short o_delqs; short o_boq; short parent; char *b_ptr; char *body; char *o_name; struct _Stack *nxt; struct _Stack *lst;} _Stack; int m_delta; struct Svtack *nxt; struct Svtack *lst;} Svtack; struct H_el *Lstate; int proc_offset[MAXPROC]; int q_offset[MAXQ]; short proc_offset[MAXPROC]; short q_offset[MAXQ]; uchar proc_skip[MAXPROC]; uchar q_skip[MAXQ];typedef struct State { uchar _nr_pr; uchar _nr_qs; unsigned short _vsz; unsigned long _vsz; #if nstates_event<256 uchar _event; unsigned short _event;{ unused++; /* avoid complaints */ } if (from >= (int) now._nr_qs || from < 0) { printf("pan: bad qid %%d\n", from+1); for (slot = 0; slot < %sQlen; slot++) printm(%scontents[slot].fld%d); printf("%%d,", %scontents[slot].fld%d); #define NQS 1 /* nqs=%d, but has_io */ typedef struct Q0 { /* generic q */ int what_p_size(int t) { int j; default: Uerror("bad proctype"); int what_q_size(int t) { int j; case %d: j = sizeof(Q%d); break; default: Uerror("bad qtype"); if (into >= now._nr_qs || into < 0) Uerror("qrecv bad queue#"); for (i = 0; i < ((Q0 *)qptr(into))->Qlen;qrecv(into+1, i, %d, 0) != fld%d) void qsend(int into, int sorted uerror("too many parameters in send stmnt"); uerror("too few parameters in send stmnt"); if (!sorted) goto append%d; for (j = 0; j < %sQlen; j++) { /* find insertion point */ if (fld%d > %s%d) continue; for (k = %sQlen - 1; k >= j; k--) append%d: /* insert in slot j */ case %d: return (q_sz(from) == %d); uerror("missing pars in receive"); #define Addproc(x) addproc(256, xspin: warning: bit-array %s[%d] mapped to byte-array undeclared structure element %s for (l_in = 0; l_in < %d; l_in++) printf(" %s %s: %%d\n", %s%s); printf(" %s %s[%%d]: %%d\n", l_in, %s%s[l_in]); printf(" chan %s[%d] (=%%d): len %%d:\t", printf(" chan %s (=%%d): len %%d:\t", void c_globals(void) { /* int i; */ void c_locals(int pid, int tp) { /* int i; */ printf("local vars proc %%d (%s):\n", pid); case %d: Printf("%s"); break; '%s %s' could be declared 'bit %s' '%s %s' could be declared 'byte %s' spin: %3d:%s, warning, %s - is invisible void iniglobals(int calling_pid) { Maxbody = max(Maxbody, sizeof(State)-VECTORSZ); Maxbody += WS - (Maxbody %% WS); void re_mark_all(int whichway) printf("%%d: re_mark_all channels %%d\n", depth, whichway); for (j = 0; j < now._nr_qs; j++) channels[j]->modified = 1; /* channel index moved */ { for (j = now._nr_pr + now._nr_qs - 1; j >= now._nr_pr; j--) now._ids_[j] = now._ids_[j-1]; { for (j = now._nr_pr; j < now._nr_pr + now._nr_qs; j++) now._ids_[j] = now._ids_[j+1]; int addproc(int calling_pid, int n int provided(int II, unsigned char ot, spin_c_typ[%d] = %d; /* %s */ ((P%d *)pptr(h))->c_cur[%d] = %d; ((P%d *)pptr(h))->_n = %d; /* %s */ if (whichclaim == -1 && claimname == NULL) printf("0: Claim %s (%d), from state %d\n"); { select_claim(whichclaim); uchar reached%d[3]; /* np_ */ uchar *loopstate%d; /* np_ */ #define nstates%d 3 /* np_ */ #define endstate%d 2 /* np_ */ default: return 1; /* e.g., a claim */ typedef struct P%d { /* %s */ unsigned _pid : 8; /* 0..255 */ unsigned _t : %d; /* proctype */ unsigned _p : %d; /* state */ Offsetof(P%d, %s) - %d*sizeof(#define WS %d /* word size in bytes */ enum btypes { NONE=%d, N_CLAIM=%d, P_PROC=%d, E_TRACE=%d, N_TRACE=%d }; unsigned _pid : 8; /* always zero */ unsigned _t : %d; /* active-claim type */ unsigned _p : %d; /* active-claim state */ unsigned _n : %d; /* active-claim index */ uchar c_cur[NCLAIMS]; /* claim-states */ ushort c_cur[NCLAIMS]; /* claim-states */ uint c_cur[NCLAIMS]; /* claim-states */ uchar spin_c_typ[NCLAIMS]; /* claim-types */ /* room for 512 proc+chan ptrs, + safety margin */ char *_ids_[MAXPROC+MAXQ+4]; TRIX_v6 *processes[MAXPROC+1]; int _; /* a predefined write-only variable */ uerror("ref to uninitialized chan (unsend)");#if defined(TRIX) && !defined(BFS) now._ids_[now._nr_pr+into] = trpt->q_bup; printf("%%4d: channel %%d s restore %%p into %%d\n", depth, into, trpt->q_bup, now._nr_pr+into); channels[into]->modified = 1; /* unsend */ printf("%%4d: channel %%d unmodify\n", depth, into); switch (((Q0 *)qptr(into))->_t) { default: Uerror("bad queue - unsend");unrecv(int from, int slot, int fld, int fldvar, int strt) uerror("ref to uninitialized chan (unrecv)"); now._ids_[now._nr_pr+from] = trpt->q_bup; printf("%%4d: channel %%d r restore %%p into %%d\n", depth, from, trpt->q_bup, now._nr_pr+from); channels[from]->modified = 1; /* unrecv */ printf("%%4d: channel %%d unmodify\n", depth, from); if (strt) ((Q0 *)z)->Qlen = j+1; switch (((Q0 *)qptr(from))->_t) { default: Uerror("bad queue - qrecv");addqueue(int calling_pid, int n, int is_rv)#if !defined(NOCOMP) && !defined(TRIX) printf("%%4d: add queue %%d\n", depth, i); default: Uerror("bad queue - addqueue"); vsize += sizeof(struct H_el *); for (k += (int) q_skip[i]; k > vsize; k--) freebodies = freebodies->nxt; { channels[i] = (TRIX_v6 *) emalloc(sizeof(TRIX_v6)); channels[i]->body = (uchar *) emalloc(Maxbody * sizeof(char)); channels[i]->modified = 1; /* addq */ channels[i]->parent_pid = calling_pid; channels[i]->nxt = (TRIX_v6 *) 0; Uerror("VECTORSZ is too small, edit pan.h"); { memset((char *)qptr(i), 0, j); case %d: j = sizeof(P%d); break; uerror("ref to uninitialized chan name (sending)"); if (into >= (int) now._nr_qs || into < 0) (trpt+1)->q_bup = now._ids_[now._nr_pr+into]; printf("%%4d: channel %%d s save %%p from %%d\n", depth, into, (trpt+1)->q_bup, now._nr_pr+into); channels[into]->modified = 1; /* qsend */ printf("%%4d: channel %%d modified\n", depth, into); j = ((Q0 *)qptr(into))->Qlen; case 0: printf("queue %%d was deleted\n", into+1); default: Uerror("bad queue - qsend"); { uerror("ref to uninitialized chan name (q_zero)"); switch(((Q0 *)qptr(from))->_t) { case 0: printf("queue %%d was deleted\n", from+1); { printf("==>> a test of the contents of a rv "); printf("channel always returns FALSE\n"); uerror("error to poll rendezvous channel");setq_claim(int x, int m, char *s, int y, char *p) uerror("x[rs] claim on uninitialized channel"); Uerror("cannot happen setq_claim"); { printf("chan %%s (%%d), ", printf("sndr proc %%s (%%d)\n", uerror("xs chans cannot be used for rv"); { printf("pan: xs assertion violated: "); printf("access to chan <%%s> (%%d)\npan: by ", 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); uerror("error, partial order reduction invalid"); printf("recv proc %%s (%%d)\n", uerror("xr chans cannot be used for rv"); { printf("pan: xr assertion violated: "); printf("access to chan %%s (%%d)\npan: ", 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", uerror("ref to uninitialized chan name (len)"); return ((Q0 *)qptr(x))->Qlen; uerror("ref to uninitialized chan name (qfull)"); Uerror("bad queue - q_full"); return !q_len(from) || q_full(from);qrecv(int from, int slot, int fld, int done) uerror("ref to uninitialized chan name (receiving)"); (trpt+1)->q_bup = now._ids_[now._nr_pr+from]; printf("%%4d: channel %%d r save %%p from %%d\n", depth, from, (trpt+1)->q_bup, now._nr_pr+from); channels[from]->modified = 1; /* qrecv */ printf("%%4d: channel %%d modified\n", depth, from); if (from >= (int) now._nr_qs || from < 0) if (done && (in_r_scope(from+1))) case %d: r = ((Q%d *)z)->contents[slot].fld%d; break; 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]); if (z) return (long) (x - z); return ordinal(scratch, x-scratch, 1); /* chan */int Boundcheck(int, int, int, int, Trans *);int gstore(char *, int, uchar);int qrecv(int, int, int, int);void spin_assert(int, char *, int, int, Trans *);void crack(int, int, Trans *, short *);void d_sfh(const char *, int);void dot_crack(int, int, Trans *);void imed(Trans *, int, int, int);void retrans(int, int, int, short *, uchar *, uchar *);void setq_claim(int, int, char *, int, char *);void tagtable(int, int, int, short *, uchar *);void do_dfs(int, int, int, short *, uchar *, uchar *);void unrecv(int, int, int, int, int);#if defined(FULLSTACK) && defined(BITSTATE) sprintf(carg, "-DT_RAND=%%d ", T_RAND); sprintf(carg, "-DP_RAND=%%d ", P_RAND); sprintf(carg, "-DBCS=%%d ", BCS); sprintf(carg, "-DMEMLIM=%%d ", MEMLIM); sprintf(carg, "-DMEMCNT=%%d ", MEMCNT); { sprintf(carg, "-DNFAIR=%%d ", NFAIR); strcat(ctd, "-DVAR_RANGES "); strcat(ctd, "-DNOBOUNDCHECK "); sprintf(carg, "-DMA=%%d ", MA);#if defined(VECTORSZ) && !defined(TRIX) { sprintf(carg, "-DVECTORSZ=%%d ", VECTORSZ); sprintf(carg, "-DNCORE=%%d ", NCORE); { sprintf(carg, "-DVMAX=%%d ", VMAX); { sprintf(carg, "-DPMAX=%%d ", PMAX); { sprintf(carg, "-DQMAX=%%d ", QMAX); sprintf(carg, "-DSET_WQ_SIZE=%%d ", SET_WQ_SIZE); printf("Compiled as: cc -o pan %%span.c\n", ctd); Maxbody = max(Maxbody, ((int) sizeof(P%d))); accpstate[%d] = (uchar *) emalloc(nstates%d); progstate[%d] = (uchar *) emalloc(nstates%d); loopstate%d = loopstate[%d] = (uchar *) emalloc(nstates%d); stopstate[%d] = (uchar *) emalloc(nstates%d); visstate[%d] = (uchar *) emalloc(nstates%d); mapstate[%d] = (short *) emalloc(nstates%d * sizeof(short)); stopstate[%d][endstate%d] = 1; memset((char *)&now, 0, sizeof(State)); vsize = (unsigned long) (sizeof(State) - VECTORSZ); if (VECTORSZ != sizeof(now._ids_)) { printf("VECTORSZ is %%d, but should be %%d in this mode\n", VECTORSZ, sizeof(now._ids_)); Uerror("VECTORSZ set incorrectly, recompile Spin (not pan.c)");/* optional provisioning statements, e.g. to *//* set hidden variables, used as constants */ retrans(%d, nstates%d, start%d, src_ln%d, reached%d, loopstate%d); #define ACCEPT_LAB 1 /* at least 1 in np_ */ #define ACCEPT_LAB %d /* user-defined accept labels */ #warning -DMEMLIM takes precedence over -DMEMCNT #warning using minimal value -DMEMCNT=20 (=1MB) #error excessive value for MEMCNT #define MEMLIM (1<<(MEMCNT-20))#if NCORE>1 && !defined(MEMLIM) #define MEMLIM (2048) /* need a default, using 2 GB */#define PROG_LAB %d /* progress labels */ 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"); 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");#if defined(BFS) && defined(TRIX) for (i = 0; i < MAXPROC+1; i++) { processes[i] = (TRIX_v6 *) emalloc(sizeof(TRIX_v6)); processes[i]->body = (uchar *) emalloc(Maxbody * sizeof(char)); for (i = 0; i < MAXQ+1; i++) { channels[i] = (TRIX_v6 *) emalloc(sizeof(TRIX_v6)); channels[i]->body = (uchar *) emalloc(Maxbody * sizeof(char)); iniglobals(258); /* arg outside range of pids */#if defined(VERI) && !defined(NOREDUCE) && !defined(NP) { 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"); UnBlock; /* disable rendez-vous */ { void init_SS(unsigned long); init_SS((unsigned long) udmem); SS = (uchar *) emalloc(udmem); { void init_SS(unsigned long); init_SS(ONE_L<<(ssize-3)); SS = (uchar *) emalloc(ONE_L<<(ssize-3));#if defined(CNTRSTACK) && !defined(BFS) LL = (uchar *) emalloc(ONE_L<<(ssize-3)); stack = (_Stack *) emalloc(sizeof(_Stack)); svtack = (Svtack *) emalloc(sizeof(Svtack)); /* a place to point for Pptr of non-running procs: */ noqptr = noptr = (uchar *) emalloc(Maxbody * sizeof(char));#if defined(SVDUMP) && defined(VERBOSE) (void) write(svfd, (uchar *) &vprefix, sizeof(int)); { whichclaim = find_claim(claimname); active_procs(); /* started after never */ reached[EVENT_TRACE][start_event] = 1; if (--Nrun > 0 && HASH_CONST[++HASH_NR]) { printf("Run %%d:\n", HASH_NR); if (udmem) /* Dillinger 3/2/09 */ { memset(SS, 0, ONE_L<<(ssize-3)); memset(LL, 0, ONE_L<<(ssize-3)); maxdepth*sizeof(struct H_el *)); nstates=nlinks=truncs=truncs2=ngrabs = 0; PUT=PROBE=ZAPS=Ccheck=Cholds = 0;int provided(int, uchar, int, Trans *);#define CS_NR (CS_N+1) /* 2^N + 1, nr critical sections */#define CS_ID (1 + (int) (j1_spin & (CS_N-1))) /* mask: 2^N - 1, zero reserved */#define CS_ID (3 + (int) (j1_spin & (CS_N-1))) #define enter_critical(w) e_critical(w) #define leave_critical(w) x_critical(w) #define enter_critical(w) { if (w < 1+NCORE) e_critical(w); } #define leave_critical(w) { if (w < 1+NCORE) x_critical(w); } #define enter_critical(w) { if (w < 3+NCORE) e_critical(w); } #define leave_critical(w) { if (w < 3+NCORE) x_critical(w); }cpu_printf(const char *fmt, ...) enter_critical(GLOBAL_LOCK); /* printing */{ /* Make sure the args to Printf * are always evaluated (e.g., they * could contain a run stmnt) * but do not generate the output * If this fails on your system * compile SPIN itself -DPRINTF * and this code is not generated#define getframe(i) &trail[i];static long HHH, DDD, hiwater; return &trail[d - (CNT1-CNT2)*DDD]; && (stackread = open(stackfile, 0)) < 0) { printf("getframe: cannot open %%s\n", stackfile); if (lseek(stackread, d* (off_t) sizeof(Trail), SEEK_SET) == -1 || read(stackread, &frameptr, sizeof(Trail)) != sizeof(Trail)) { printf("getframe: frame read error\n");#if !defined(SAFETY) && !defined(BITSTATE)#if !defined(FULLSTACK) || defined(MA)#define depth_of(x) A_depth /* an estimate */ for (d = 0; d <= A_depth; d++) printf("pan: cannot happen, depth_of\n");volatile unsigned int *search_terminated; /* to signal early termination */ { printf("--end of output--\n"); if (search_terminated != NULL) { *search_terminated |= 1; /* pan_exit */ if (!state_tables && !readtrail) C_EXIT; /* trust that it defines a fct */ if (!s || strlen(s) > 2047) return s; while ((v = strstr(tbuf[toggle], "{c_code"))) strcpy(tbuf[1-toggle], tbuf[toggle]); for (w = v; *w != '}' && *w != '\0'; w++) /* skip */; for (i = 0; code_lookup[i].c; i++) if (strcmp(v, code_lookup[i].c) == 0 && strlen(v) == strlen(code_lookup[i].c)) { if (strlen(tbuf[1-toggle]) + strlen(code_lookup[i].t) strcat(tbuf[1-toggle], code_lookup[i].t);char * transmognify(char *s) { return s; } for (t = trans[ot][tt]; t; t = t->nxt) return PanSource; /* i.e., don't know */{ static int wrap_in_progress = 0; if (wrap_in_progress++) return; printf("spin: trail ends after %%ld steps\n", depth); { if (onlyproc >= now._nr_pr) { pan_exit(0); } 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) find_source((int) z->_t, (int) z->_p), printf(" (state %%2d)", z->_p); if (!stopstate[z->_t][z->_p]) printf(" (invalid end state)"); printf("#processes %%d:\n", now._nr_pr); for (II = 0; II < now._nr_pr; II++) { fd = fopen(trailfilename, "r"); { printf("pan: cannot find %%s\n", trailfilename); do { /* see if there's more than one possible trailfile */ { sprintf(fnm, "%%s%%d.%%s", MyFile, whichtrail, tprefix); printf("trail%%d: %%s\n", if ((q = strchr(MyFile, '.')) != NULL) sprintf(fnm, "%%s%%d.%%s", MyFile, whichtrail, tprefix); printf("trail%%d: %%s\n", { sprintf(fnm, "%%s.%%s", MyFile, tprefix); sprintf(fnm, "%%s.%%s", MyFile, tprefix); sprintf(tprefix, "cpu%%d_trail", try_core++); { printf("error: there are %%d trail files:\n", { printf("pan: rm or mv all except one\n"); strcpy(MyFile, TrailFile); /* restore */ { sprintf(fnm, "%%s%%d.%%s", MyFile, whichtrail, tprefix); if (fd == NULL && (q = strchr(MyFile, '.'))) { sprintf(fnm, "%%s.%%s", MyFile, tprefix); sprintf(fnm, "%%s.%%s", MyFile, tprefix); sprintf(tprefix, "cpu%%d_trail", try_core++); printf("pan: cannot find trailfile %%s\n", fnm);#if NCORE>1 && defined(SEP_STATE) { void set_root(void); /* for partial traces from local root */uchar do_transit(Trans *, short); int i, t_id, lastnever=-1; short II; fd = findtrail(); /* exits if unsuccessful */ while (fscanf(fd, "%%ld:%%d:%%d\n", &depth, &i, &t_id) == 3) printf("<<<<>>>>\n"); { printf("pan: Error, proc %%d invalid pid ", i); printf("transition %%d\n", t_id); for (t = trans[z->_t][z->_p]; t; t = t->nxt) if (t->t_id == (T_ID) t_id) { for (i = 0; i < NrStates[z->_t]; i++) if (t && t->t_id == (T_ID) t_id) { printf("\tRecovered at state %%d\n", i); printf("pan: Error, proc %%d type %%d state %%d: ", 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); { if (onlyproc >= 0 && II != onlyproc) 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) { 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) find_source((int) z->_t, (int) z->_p), printf("(state %%d) trans {%%d,%%d} [%%s]\n", z->_p, t_id, t->forw, q?q:""); for (i = 0; i < now._nr_pr; i++) { c_locals(i, ((P0 *)pptr(i))->_t); } else if (Btypes[z->_t] == N_CLAIM) { if (lastnever != (int) z->_p) { for (i = 0; src_all[i].src; i++) if (src_all[i].tp == (int) z->_t) { printf("MSC: ~G %%d\n", src_all[i].src[z->_p]); printf("MSC: ~R %%d\n", z->_p); } else if (Btypes[z->_t] != 0) /* not :np_: */sameas: if (no_rck) goto moveon; printf("%%s(%%d):", procname[z->_t], II); printf("[%%s]\n", q?q:""); { if (strlen(simvals) > 0) { printf("%%3ld: proc %%2d (%%s)", depth, II, procname[z->_t]); for (i = 0; src_all[i].src; i++) find_source((int) z->_t, (int) z->_p), printf("(state %%d) [values: %%s]\n", z->_p, simvals); printf("(state %%d) [%%s]\n", z->_p, q?q:""); for (i = 0; i < now._nr_pr; i++)#if !defined(HASH64) && !defined(HASH32)#if defined(HASH32) && defined(SAFETY) && !defined(SFH) && !defined(SPACE)#if defined(SFH) && (defined(BITSTATE) || defined(COLLAPSE) || defined(HC) || defined(HASH64) || defined(MA))#if defined(SFH) && !defined(NOCOMP) #define NOCOMP /* go for speed */#if NCORE>1 && !defined(GLOB_HEAP) #define SEP_HEAP /* version 5.1.2 */bstore_mod(char *v, int n) /* hasharray size not a power of two */ d_hash((uchar *) v, n); /* sets j3, j4, K1, K2 */ { if (!(SS[x%%udmem]&(1< RANDSTOR) return 0;bstore_reg(char *v, int n) /* extended hashing, Peter Dillinger, 2004 */ d_hash((uchar *) v, n); /* sets j1-j4 */ { if (!(SS[x]&(1< 0) MyFile, Nr_Trails-1, tprefix); sprintf(fnm, "%%s_%%s_%%d.%%s", MyFile, progname, getpid(), tprefix); sprintf(fnm, "%%s.%%s", MyFile, tprefix); if ((fd = open(fnm, w_flags, TMODE)) < 0) { if ((q = strchr(MyFile, '.'))) if (iterative == 0 && Nr_Trails-1 > 0) MyFile, Nr_Trails-1, tprefix); fd = open(fnm, w_flags, TMODE); { printf("pan: cannot create %%s\n", fnm);#if NCORE>1 && (defined(SEP_STATE) || !defined(FULL_TRAIL)) printf("pan: wrote %%s\n", fnm);re_populate(void) /* restore procs and chans from now._ids_ */ printf("%%4d: re_populate\n", depth); for (i = 0; i < now._nr_pr; i++, cnt++) processes[i]->psize = what_p_size( ((P0 *)b)->_t ); memcpy(processes[i]->body, b, processes[i]->psize); processes[i]->modified = 1; /* re-populate */ for (i = 0; i < now._nr_qs; i++, cnt++) channels[i]->psize = what_q_size( ((Q0 *)b)->_t ); memcpy(channels[i]->body, b, channels[i]->psize); channels[i]->modified = 1; /* re-populate */BFS_Trail *bfs_trail, *bfs_bot, *bfs_free; #define BFS_DSK_LIMIT 1000000 #if defined(WIN32) || defined(WIN64) #define RFLAGS (O_RDONLY|O_BINARY) #define WFLAGS (O_CREAT|O_WRONLY|O_TRUNC|O_BINARY) #define WFLAGS (O_CREAT|O_WRONLY|O_TRUNC)long bfs_dsk_writes, bfs_dsk_reads;int bfs_dsk_seqno_w, bfs_dsk_seqno_r;uchar do_reverse(Trans *, short, uchar);select_claim(int x) /* ignored in BFS mode */ { printf("select %%d (ignored)\n", x);{ SV_Hold *h = (SV_Hold *) 0, *oh; for (h = svfree; h; oh = h, h = h->nxt) { h = (SV_Hold *) emalloc(sizeof(SV_Hold)); 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) { (void) close(bfs_dsk_write); sprintf(dsk_nm, "pan_bfs_%%d.tmp", bfs_dsk_seqno_w++); bfs_dsk_write = open(dsk_nm, WFLAGS, 0644); { 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?)"); h->sv = (State *) emalloc(sizeof(State) - VECTORSZ + n); memcpy((char *)h->sv, (char *)&now, n); static EV_Hold *kept = (EV_Hold *) 0; for (h = kept; h; h = h->nxt) && (memcmp((char *) Mask, (char *) h->sv, n) == 0) && (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) && (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) && (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)) { h = (EV_Hold *) emalloc(sizeof(EV_Hold)); h->sv = (char *) emalloc(n * sizeof(char)); memcpy((char *) h->sv, (char *) Mask, n); { h->ps = (char *) emalloc(now._nr_pr * sizeof(int)); memcpy((char *) h->ps, (char *) proc_skip, now._nr_pr * sizeof(uchar)); h->po = (char *) emalloc(now._nr_pr * sizeof(int)); memcpy((char *) h->po, (char *) proc_offset, now._nr_pr * sizeof(int)); h->po = (char *) emalloc(now._nr_pr * sizeof(short)); memcpy((char *) h->po, (char *) proc_offset, now._nr_pr * sizeof(short)); { h->qs = (char *) emalloc(now._nr_qs * sizeof(int)); memcpy((char *) h->qs, (char *) q_skip, now._nr_qs * sizeof(uchar)); h->qo = (char *) emalloc(now._nr_qs * sizeof(int)); memcpy((char *) h->qo, (char *) q_offset, now._nr_qs * sizeof(int)); h->qo = (char *) emalloc(now._nr_qs * sizeof(short)); memcpy((char *) h->qo, (char *) q_offset, now._nr_qs * sizeof(short)); { t = (BFS_Trail *) emalloc(sizeof(BFS_Trail)); t->frame = (Trail *) emalloc(sizeof(Trail)); /* new because we keep a ptr to the frame of parent states */ /* used for reconstructing path and recovering failed rvs etc */ memcpy((char *)t->frame, (char *)f, sizeof(Trail)); t->frame->o_tt = d; /* depth */ t->omask = getsv_mask(vsize);#if defined(FULLSTACK) && defined(Q_PROVISO) printf("PUSH %%u (depth %%d, nr %%d)\n", t->frame, d, t->nr);#if defined(Q_PROVISO) && !defined(BITSTATE) && !defined(NOREDUCE) if (t->onow->sv == (State *) 0) 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); { sprintf(dsk_nm, "pan_bfs_%%d.tmp", bfs_dsk_seqno_r++); bfs_dsk_read = open(dsk_nm, RFLAGS); { Uerror("could not open temp disk file"); if (read(bfs_dsk_read, (char *) &now, vsize) != vsize) { Uerror("bad bfs disk file read"); { Uerror("disk read vsz mismatch"); { memcpy((uchar *) &now, (uchar *) t->onow->sv, vsize); memcpy((uchar *) Mask, (uchar *) t->omask->sv, vsize); { memcpy((char *)proc_offset, (char *)t->omask->po, now._nr_pr * sizeof(int)); { memcpy((char *)proc_offset, (char *)t->omask->po, now._nr_pr * sizeof(short)); memcpy((char *)proc_skip, (char *)t->omask->ps, now._nr_pr * sizeof(uchar)); { memcpy((uchar *)q_offset, (uchar *)t->omask->qo, now._nr_qs * sizeof(int)); { memcpy((uchar *)q_offset, (uchar *)t->omask->qo, now._nr_qs * sizeof(short)); memcpy((uchar *)q_skip, (uchar *)t->omask->qs, now._nr_qs * sizeof(uchar)); if (t->onow->sv != (State *) 0) { freesv(t->onow); /* omask not freed */ printf("POP %%u (depth %%d, nr %%d)\n", t->frame, t->frame->o_tt, t->nr);store_state(Trail *ntrpt, int shortcut, short oboq) uchar o_opm = trpt->o_pm, *othis = this; printf("claim: shortcut\n"); goto store_it; /* no claim move */ this = pptr(0); /* 0 = never claim */ tt = (int) ((P0 *)this)->_p; ot = (uchar) ((P0 *)this)->_t; for (t2 = trans[ot][tt]; t2; t2 = t2?t2->nxt:(Trans *)0) if (E_state > 0 && E_state != t2->e_trans) printf("depth: %%d -- claim move from %%d -> %%d\n", trpt->o_tt, ((P0 *)this)->_p, t2->st); { ((P0 *)this)->_p = t2->st; if (stopstate[ot][t2->st]) { uerror("end state in claim reached"); if (now._nr_pr == 0) /* claim terminated */ uerror("end state in claim reached"); { Uerror("atomic in claim not supported in BFS"); if (!bstore((char *)&now, vsize)) if (!gstore((char *)&now, vsize, 0)) if (!hstore((char *)&now, vsize)) { static long sdone = (long) 0; long ndone; ndone = (unsigned long) (nstates/(freq)); if (ndone != sdone && mreached%%10 != 0)#if defined(AUTO_RESIZE) && !defined(BITSTATE) && !defined(MA) if (nstates > ((double)(1<<(ssize+1)))) { void resize_hashtable(void); x = (Trail *) trpt->ostate; /* pre-rv state */ if (x) x->o_pm |= 4; /* mark success */ push_bfs(ntrpt, trpt->o_tt+1);#if !defined(NOREDUCE) && defined(FULLSTACK) && defined(Q_PROVISO) if (Lstate && Lstate->tagged) for (tprov = bfs_trail; tprov; tprov = tprov->nxt) if (tprov->onow->sv != (State *) 0 && memcmp((uchar *)&now, (uchar *)tprov->onow->sv, vsize) == 0) break; /* state is in queue */ ((P0 *)this)->_p = tt; /* reset claim */ short II, From = (short) (now._nr_pr-1), To = BASE; ntrpt = (Trail *) emalloc(sizeof(Trail)); trpt->ostate = (struct H_el *) 0; 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])); printf("Revisit of atomic not needed (%%d)\n", printf("Break atomic (pm:%%d,tau:%%d)\n", printf("Void preselection (pm:%%d,tau:%%d)\n", nps = 1; /* no preselection in repeat */ { x = (Trail *) trpt->ostate; if (x) x->o_pm |= 4; /* not failing */ printf("error: max search depth too small\n"); { uerror("depth limit reached"); if (boq == -1 && !(trpt->tau&8) && nps == 0) for (II = now._nr_pr-1; II >= BASE; II -= 1) tt = (int) ((P0 *)this)->_p; ot = (uchar) ((P0 *)this)->_t; if (trans[ot][tt]->atom & 8) trpt->tau |= 32; /* preselect marker */ printf("%%3ld: proc %%d PreSelected (tau=%%d)\n", if (trpt->tau&8) /* atomic */ { From = To = (short ) trpt->pr; for (II = From; II >= To; II -= 1) /* no rendezvous with same proc */ if (boq != -1 && trpt->pr == II) trpt->o_pm &= ~1; /* no move yet */ trpt->o_event = now._event; if (!provided(II, ot, tt, t)) for (t = trans[ot][tt]; t; t = t->nxt) && E_state != t->e_trans) if (!(_m = do_transit(t, II))) trpt->o_pm |= 1; /* we moved */ (trpt+1)->o_m = _m; /* for unsend */ printf("%%3ld: proc %%d exec %%d, ", printf("%%d to %%d, %%s %%s %%s", (boq != -1)?"rendez-vous":""); printf(" (escapes to state %%d)", t->st); printf(" %%saccepting [tau=%%d]\n", (trpt->o_pm&2)?"":"non-", trpt->tau); if (t->e_trans > 0 && (boq != -1 /* || oboq != -1 */)) { fprintf(efd, "error: a rendezvous stmnt in the escape clause\n"); fprintf(efd, " of an unless stmnt is not compatible with -DBFS\n"); { ((P0 *)this)->_p = t->st; /* ptr to pred: */ ntrpt->ostate = (struct H_el *) otrpt; if (boq == -1 && (t->atom&2)) /* atomic */ ntrpt->tau = 8; /* record for next move */ store_state(ntrpt, (boq != -1 || (t->atom&2)), oboq); now._event = trpt->o_event; /* undo move and continue */ trpt++; /* this is where ovals and ipt are set */ do_reverse(t, II, _m); /* restore now. */ enter_critical(GLOBAL_LOCK); /* verbose mode */ printf("cpu%%d: ", core_id); printf("%%3d: proc %%d ", depth, II); printf("reverses %%d, %%d to %%d,", printf(" %%s [abit=%%d,adepth=%%d,", t->tp, now._a_t, A_depth); trpt->tau, (trpt-1)->tau); leave_critical(GLOBAL_LOCK); /* preselected - no succ definitely outside stack */ if ((trpt->tau&32) && !(trpt->tau&64)) { From = now._nr_pr-1; To = BASE; cpu_printf("%%3ld: proc %%d UnSelected (_n=%%d, tau=%%d)\n", depth, II+1, (int) _n, trpt->tau); printf("%%3ld: no move [II=%%d, tau=%%d, boq=%%d, _nr_pr=%%d]\n", depth, II, trpt->tau, boq, now._nr_pr); x = (Trail *) trpt->ostate; /* pre-rv state */ { continue; /* root state */ if ((x->tau&8) || (x->tau&32)) /* break atomic or preselect at parent */ { x->o_pm |= 8; /* mark failure */ printf("\treset state of %%d from %%d to %%d\n", otrpt->pr, ((P0 *)this)->_p, otrpt->st); ((P0 *)this)->_p = otrpt->st; unsend(boq); /* retract rv offer */ printf("failed rv, repush with %%d\n", x->o_pm); { printf("failed rv, tau at parent: %%d\n", x->tau); if ((trpt->tau&8)) /* atomic */ { trpt->tau &= ~(1|8); /* 1=timeout, 8=atomic */ printf("%%3ld: atomic step proc %%d blocks\n", if (!(trpt->tau&1)) /* didn't try timeout yet */ printf("%%d: timeout\n", depth); if (!noends && !a_cycles && !endstate()) { uerror("invalid end state"); if (trpt != (Trail *) trpt->ostate) putter((Trail *) trpt->ostate, fd); { sprintf(snap, "%%d:%%d:%%d\n", trcnt++, trpt->pr, trpt->o_t->t_id); if (write(fd, snap, j) != j) { printf("pan: error writing %%s\n", fnm); sprintf(snap, "-2:%%d:-2\n", (uchar) ((P0 *)pptr(0))->_t); (void) write(fd, snap, strlen(snap)); trcnt++, ntrpt->pr, ntrpt->o_t->t_id); if (errors >= upto && upto != 0)#if defined(WIN32) || defined(WIN64)/* code common to cygwin/linux and win32/win64: *//* 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)) /* no longer usefule -- being recomputed for local heap size anyway */ double SEG_SIZE = (((double) SET_SEG_SIZE) * 1048576.); double SEG_SIZE = (1048576.*1024.); /* 1GB default shared memory pool segments */double LWQ_SIZE = 0.; /* initialized in main */ #warning SET_WQ_SIZE applies to global queue -- ignored double GWQ_SIZE = (((double) SET_WQ_SIZE) * 1048576.); /* must match the value in pan_proxy.c, if used */ double GWQ_SIZE = (128.*1048576.); /* 128 MB default queue sizes *//* Crash Detection Parameters */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 */ volatile struct Stack_Tree *m_stack; /* ptr to previous state */ 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];int proxy_pid; /* id of proxy if nonzero -- receive half */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 */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 */ void *shmid_S; /* shared bitstate arena or hashtable */ volatile char *dc_start; /* where memory segment starts */ volatile int dc_id; /* to attach, detach, remove shared memory segments */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 */ int shmid_S; /* shared bitstate arena or hashtable */ volatile sh_Allocater *first_pool; /* of shared state memory */ volatile sh_Allocater *last_pool;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_frame_wait; 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 */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 */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 *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 */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 */ { cpu_printf("nstates %%g nshadow %%g -- memory %%-6.3f Mb\n", nstates, nShadow, memcnt/(1048576.)); r->m_memcnt = 0; /* it's shared */ if (a_cycles && core_id == 1) r->m_frame_wait = frame_wait; r->m_PMAX = (short) pmax_seen; r->m_QMAX = (short) qmax_seen; for (i = 0; i <= _NP_; i++) /* all proctypes */ { memcpy(ptr, reached[i], NrStates[i]*sizeof(uchar)); ptr += NrStates[i]*sizeof(uchar); { cpu_printf("Put Results nstates %%g (sz %%d)\n", nstates, ptr - &(r->m_R)); snapshot(); /* for a final report */ { printf("cpu%%d: local heap-left %%ld KB (%%d MB)\n", core_id, (long) (my_size/1024), (int) (my_size/1048576)); /* frame_wait += r->m_frame_wait; */ 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; { for (j = 0; j < NrStates[i]; j++) { cpu_printf("Got Results (%%d)\n", (int) (ptr - &(r->m_R)));#if !defined(WIN32) && !defined(WIN64) 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 */ { (void) shmctl(shmid[m], IPC_RMID, NULL); { (void) shmctl(shmid_M, IPC_RMID, NULL); { (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 */ { (void) shmctl(shmid_M, IPC_RMID, NULL); printf("cpu%%d: stop - %%s\n", core_id, s); { if (*search_terminated != 0) { printf("cpu%%d: termination initiated (%%d)\n", core_id, *search_terminated); { printf("cpu%%d: initiated termination\n", core_id); *search_terminated |= 8; /* sudden_stop */ { 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 */ } /* 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 */ 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)); sprintf(b, "kill -%%d %%d", SIGKILL, worker_pids[i]); system(b); /* if this is a proxy: receive half */ { /* on WIN32/WIN64 -- these merely kills the root process... */ { sprintf(b, "kill -%%d %%d", SIGINT, worker_pids[0]); system(b); /* warn the root process */ printf("cpu%%d: %%s\n", core_id, b);#define iam_alive() is_alive[core_id]++extern int crash_test(double);extern void crash_reset(void);someone_crashed(int wait_type){ static double last_value = 0.0; if (search_terminated == NULL if (!(*search_terminated & (8|32|128|256))) /* check left neighbor only */ if (last_value == is_alive[(core_id + NCORE - 1) %% NCORE]) { if (count++ >= 100) /* to avoid unnecessary checks */ last_value = is_alive[(core_id + NCORE - 1) %% NCORE]; printf("cpu%%d: locks: global %%g\tother %%g\t", core_id, glock_wait[0], lock_wait - glock_wait[0]); 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]); printf("waits: states %%g slots %%g\n", frame_wait, free_wait); 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); { printf("hint: this search may be faster with a larger work-queue\n"); printf(" (-DSET_WQ_SIZE=N with N>%%g), and/or with -DUSE_DISK\n", GWQ_SIZE/sizeof(SM_frame)); printf(" or with a larger value for -zN (N>%%ld)\n", z_handoff); { 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); #define MAX_DSK_FILE 1000000 /* default is max 1M states per file */ if (warned > 0) { return; } else { warned++; } 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, "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, "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, " 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, " To define a fct to initialize data before spawning processes (use quotes):\n"); fprintf(fd, " \"-DC_INIT=fct()\"\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");#if NCORE>1 && defined(FULL_TRAIL) uchar pr; /* process that made transition */ T_ID t_id; /* id of transition */ volatile struct Stack_Tree *prv; /* backward link towards root */struct H_el *grab_shared(int);volatile Stack_Tree **stack_last; /* in shared memory */char *stack_cache = NULL; /* local */int nr_cached = 0; /* local */ { stack_cache = (char *) grab_shared(CACHE_NR * sizeof(Stack_Tree)); st = (volatile Stack_Tree *) stack_cache; stack_cache += sizeof(Stack_Tree);Push_Stack_Tree(short II, T_ID t_id) st = (volatile Stack_Tree *) stack_prefetch(); st->prv = (Stack_Tree *) stack_last[core_id];{ volatile Stack_Tree *cf = stack_last[core_id]; { stack_last[core_id] = cf->prv; } else if (nr_handoffs * z_handoff + depth > 0) { printf("cpu%%d: error pop_stack_tree (depth %%d)\n", if (readtrail || iamin[which] > 0) { printf("cpu%%d: Double Lock on %%d (now %%d)\n", core_id, which, iamin[which]+1); iamin[which]++; /* local variable */ while (sh_lock != NULL) /* as long as we have shared memory */ { int r = tas(&sh_lock[which]); if (which < 3) { glock_wait[which]++; } if (which == 0) { glock_wait[which]++; } if (lock_wait - cnt_start > TenSeconds) { printf("cpu%%d: lock timeout on %%d\n", core_id, which); { sudden_stop("lock timeout"); { iamin[which]--; /* this is thread-local - no races on this one */ { printf("cpu%%d: Partial Unlock on %%d (%%d more needed)\n", core_id, which, iamin[which]); } else /* iamin[which] <= 0 */ { printf("cpu%%d: Invalid Unlock iamin[%%d] = %%d\n", sh_lock[which] = 0; /* unlock */start_proxy(char *s, DWORD r_pid)start_proxy(char *s, int r_pid){ char Q_arg[16], Z_arg[16], Y_arg[16]; sprintf(Q_arg, "-Q%%d", getpid()); sprintf(Y_arg, "-Y%%d", r_pid); sprintf(Z_arg, "-Z%%d", proxy_pid /* core_id */); args[argcnt++] = s; /* -r or -s */ { ptr = o_cmdline; /* assume args separated by spaces */ do { args[argcnt++] = ptr++; if ((ptr = strchr(ptr, ' ')) != NULL) execvp("pan_proxy", args); /* no return */ execvp("./pan_proxy", args); /* no return */ Uerror("pan_proxy exec failed");/*** end of common code fragment ***/init_shm(void) /* initialize shared work-queues - linux/cygwin */ { 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); { 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); } else /* workers attach */ { shmid[m] = shmget(key[m], (size_t) qsize, 0600); /* never called, since we create shm *before* we fork */ { 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]; { int nframes = (m == NCORE) ? GN_FRAMES : LN_FRAMES; for (n = 0; n < nframes; n++) { m_workq[m][n].m_vsize = 0; fprintf(stderr, "pan: check './pan --' for usage details\n"); pan_exit(1); /* calls cleanup_shm */prep_shmid_S(size_t n) /* either sets SS or H_tab, linux/cygwin */ printf("cpu0: step 1: allocate shared bitstate %%g Mb\n", printf("cpu0: step 1: allocate shared hastable %%g Mb\n", if (memcnt + (double) n > memlim) { printf("cpu0: S %%8g + %%d Kb exceeds memory limit of %%8g Mb\n", memcnt/1024., (int) (n/1024), memlim/(1048576.)); printf("cpu0: insufficient memory -- aborting\n"); key = ftok(PanSource, NCORE+2); /* different from queues */ { perror("ftok shared bitstate or hashtable"); { shmid_S = shmget(key, n, 0600); { printf("cpu0: removing stale segment, status: %%d\n", (int) shmctl(shmid_S, IPC_RMID, NULL)); shmid_S = shmget(key, n, 0600 | IPC_CREAT | IPC_EXCL); { perror("shmget shared bitstate or hashtable too large?"); rval = (char *) shmat(shmid_S, (void *) 0, 0); /* attach */ if ((char *) rval == (char *) -1) { perror("shmat shared bitstate or hashtable");prep_state_mem(size_t n) /* sets memory arena for states linux/cygwin */ static int cnt = 3; /* start larger than earlier ftok calls */ shm_prep_result = NOT_AGAIN; /* default */ { printf("cpu0: step 2+: pre-allocate memory arena %%d of %%6.2g Mb\n", cnt-3, (double) n / (1048576.)); { printf("cpu0: error: M %%.0f + %%.0f Kb exceeds memory limit of %%.0f Mb\n", memcnt/1024.0, (double) n/1024.0, memlim/(1048576.)); key = ftok(PanSource, NCORE+cnt); cnt++; printf("pan: check './pan --' for usage details\n"); { shmid_M = shmget(key, n, 0600); { 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 */ { printf("error: failed to get pool of shared memory %%d of %%.0f Mb\n", cnt-3, ((double)n)/(1048576.)); printf("pan: check './pan --' for usage details\n"); shm_prep_result = TRY_AGAIN; rval = (char *) shmat(shmid_M, (void *) 0, 0); /* attach */ { printf("cpu%%d error: failed to attach pool of shared memory %%d of %%.0f Mb\n", core_id, cnt-3, ((double)n)/(1048576.));init_HT(unsigned long n) /* cygwin/linux version */ double need_mem, got_mem = 0.; { printf("cpu0: steps 0,1: no -DMEMLIM set\n"); { 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.) ); 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 */ get_mem += (NCORE) * sizeof(Stack_Tree *); /* NCORE * stack_last */ x = (volatile char *) prep_state_mem((size_t) get_mem); /* work queues and basic structs */ { printf("cpu0: could not allocate shared memory, see ./pan --\n"); search_terminated = (volatile unsigned int *) x; /* comes first */ x += sizeof(void *); /* maintain alignment */ is_alive = (volatile double *) x; sh_lock = (volatile int *) x; grfree = (volatile int *) x; grfull = (volatile int *) x; grcnt = (volatile int *) x; grmax = (volatile int *) x; gr_readmiss = (volatile double *) x; gr_writemiss = (volatile double *) x; stack_last = (volatile Stack_Tree **) x; x += NCORE * sizeof(Stack_Tree *); H_tab = (struct H_el **) emalloc(n); { 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.)); H_tab = (struct H_el **) prep_shmid_S((size_t) n); /* hash_table */ need_mem = memlim - memcnt - ((double) NCORE * LWQ_SIZE) - GWQ_SIZE; { Uerror("internal error -- shared state memory"); { printf("cpu0: step 2: pre-allocate shared state memory %%g Mb\n", { printf("cpu0: setting segsize to %%6g MB\n", #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 = 512.*1024.*1024.; if (get_mem > (double) SEG_SIZE) { get_mem = (double) SEG_SIZE; /* for allocating states: */ x = dc_mem_start = (volatile char *) prep_state_mem((size_t) get_mem); { if (shm_prep_result == NOT_AGAIN || SEG_SIZE < (16. * 1048576.)) { printf("pan: lowered segsize to %f\n", SEG_SIZE); { 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; grfull = (volatile int *) x; grcnt = (volatile int *) x; grmax = (volatile int *) x; prfree = (volatile int *) x; x += NCORE * sizeof(void *); prfull = (volatile int *) x; prcnt = (volatile int *) x; prmax = (volatile int *) x; gr_readmiss = (volatile double *) x; gr_writemiss = (volatile double *) x; stack_last = (volatile Stack_Tree **) x; x += NCORE * sizeof(Stack_Tree *); if (((long)x)&(sizeof(void *)-1)) /* 64-bit word alignment */ { x += sizeof(void *)-(((long)x)&(sizeof(void *)-1)); ncomps = (unsigned long *) x; x += (256+2) * sizeof(unsigned long); dc_shared = (sh_Allocater *) x; /* must be in shared memory */ if (core_id == 0) /* root only */ { dc_shared->dc_id = shmid_M; dc_shared->dc_start = dc_mem_start; dc_shared->pattern = 1234567; /* protection */ dc_shared->dc_size = (long) get_mem - (long) (x - dc_mem_start); dc_shared->nxt = (long) 0; { first_pool = last_pool = dc_shared; { last_pool->nxt = dc_shared; } else if (first_pool == NULL) { printf("cpu0: could allocate only %%g Mb of shared memory (wanted %%g more)\n", got_mem/(1048576.), need_mem/(1048576.)); { printf("cpu0: insufficient memory -- aborting.\n"); /* we are still single-threaded at this point, with core_id 0 */ /* Test and Set assembly code */ #if defined(i386) || defined(__i386__) || defined(__x86_64__) tas(volatile int *s) /* tested */ : "=r"(r), "=m"(*s) tas(volatile int *s) /* not tested */ #elif defined(sparc) || defined(__sparc__) #elif defined(ia64) || defined(__ia64__) #error missing definition of test and set operation for this platform{ volatile sh_Allocater *nxt_pool; { printf("cpu%%d: Redundant call to cleanup_shm(%%d)\n", core_id, val); { *search_terminated |= 16; /* cleanup_shm */ { if (shmdt((void *) shared_mem[m]) > 0) { perror("shmdt detaching from shared queues"); if (shmdt((void *) shmid_X) != 0) { perror("shmdt detaching from shared state memory"); if (SS > 0 && shmdt((void *) SS) != 0) { perror("shmdt detaching from shared bitstate arena"); for (nxt_pool = dc_shared; nxt_pool != NULL; nxt_pool = nxt_pool->nxt) { cnt += nxt_pool->dc_size; { printf("cpu0: done, %%ld Mb of shared state memory left\n", 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 */ /* detached from shared memory - so cannot use cpu_printf */ { printf("cpu%%d: done -- got %%ld states from queue\n",#if defined(MA) && !defined(SEP_STATE) #error MA without SEP_STATE is not supported with multi-core #error BFS is not supported with multi-core #error SC is not supported with multi-core init_shm(); /* we are single threaded when this starts */ { printf("cpu0: step 4: calling fork()\n");/* 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 { worker_pids[0] = getpid(); /* for completeness */ while (++core_id < NCORE) /* first worker sees core_id = 1 */ 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) { Uerror("proxy fork failed"); { start_proxy("-s", worker_pids[proxy_pid]); /* no return */ { core_id = 0; /* reset core_id for root process */ { static char db0[16]; /* good for up to 10^6 cores */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 */ if (proxy_pid == 0) /* not in a cluster setup, pan_proxy must attach */ { rm_shared_segments(); /* mark all shared segments for removal on exit */ { cpu_printf("starting core_id %%d -- pid %%d\n", core_id, getpid());#if defined(SEP_HEAP) && !defined(SEP_STATE) for (i = 0; i < NCORE && ptr != NULL; i++) { my_heap = (char *) ptr->dc_arena; my_size = (long) ptr->dc_size; cpu_printf("local heap %%ld MB\n", my_size/(1048576)); ptr = ptr->nxt; /* local */ { printf("cpu%%d: no local heap\n", core_id); { ptr = ptr->nxt; /* local */ dc_shared = ptr; /* any remainder */ dc_shared = NULL; /* used all mem for local heaps */ if (core_id == 0 && !remote_party) { new_state(); /* cpu0 explores root */ cpu_printf("done with 1st dfs, nstates %%g (put %%d states), read q\n", Read_Queue(core_id); /* all cores */ { cpu_printf("put %%6d states into queue -- got %%6d\n",int unpack_state(SM_frame *, int); { 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 */ if (my_heap != NULL && my_size > n) { 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) printf("cpu%%d: global heap has %%ld bytes left, needed %%d\n", core_id, dc_shared?dc_shared->dc_size:0, n); if (dc_shared->pattern != 1234567) { leave_critical(GLOBAL_LOCK); Uerror("overrun -- memory corruption"); { printf("Next Pool %%g Mb + %%d\n", memcnt/(1048576.), n); || 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); sudden_stop("out of memory -- aborting"); { dc_shared = (sh_Allocater *) dc_shared->nxt; rval = (char *) dc_shared->dc_arena; dc_shared->dc_size -= (long) n; printf("cpu%%d grab shared (%%d bytes) -- %%ld left\n", core_id, n, dc_shared->dc_size); return (struct H_el *) emalloc(n); double cnt_start = frame_wait; while (f->m_vsize == 0) /* await full slot LOCK : full frame */ if (!a_cycles || core_id != 0) 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 */ { /* writer is still filling the slot */ f = &m_workq[n][prfull[n]]; /* reset */ { *grfull = (*grfull+1) %% (GN_FRAMES); if (frame_wait++ - cnt_start > Delay) { cpu_printf("timeout on q%%d -- %%u -- query %%d\n", n, f, query_in_progress); return (SM_frame *) 0; /* timeout */ if (VVERBOSE) cpu_printf("got frame from q%%d\n", n); prfull[n] = (prfull[n] + 1) %% (LN_FRAMES); prcnt[n]--; /* lock out increments */ 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][prfree[n]]); while (f->m_vsize != 0) /* await free slot LOCK : free slot */ if (free_wait++ - cnt_start > OneSecond) { cpu_printf("timeout waiting for free slot q%%d\n", n); { printf("cpu%%d: search terminated\n", core_id); sudden_stop("get free frame"); { prfree[n] = (prfree[n] + 1) %% (LN_FRAMES); prcnt[n]++; /* lock out decrements */ if (*grcnt < GN_FRAMES) /* there seems to be room */ { enter_critical(GQ_WR); /* gq write access */ { if (m_workq[NCORE][*grfree].m_vsize != 0) { /* can happen if reader is slow emptying slot */ 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 */ mem_put(NCORE); /* copy state into reserved slot */ rval = 1; /* successfull handoff */unpack_state(SM_frame *f, int from_q) { cpu_printf("saw control %%d, expected state\n", boq); 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<m_p_offset, now._nr_pr * sizeof(OFFT)); memcpy((uchar *) proc_skip, (uchar *) f->m_p_skip, now._nr_pr * sizeof(uchar)); { 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)); { cpu_printf("vsize %%d != now._vsz %%d (type %%d) %%d\n", vsize, now._vsz, f->m_boq, f->m_vsize); goto correct; /* rare event: a race */ { memcpy((uchar *) &cur_Root, (uchar *) f, sizeof(SM_frame)); if (((now._a_t) & 1) == 1) /* i.e., when starting nested DFS */ memcpy((uchar *)&A_Root, (uchar *)&now, vsize); nr_handoffs = f->nr_handoffs; { cpu_printf("pan: state empty\n"); (trpt-1)->ostate = &D_State; /* stub */ { stack_last[core_id] = (Stack_Tree *) f->m_stack; { 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); { trpt->tau |= 4; /* the claim moves first */ cpu_printf("warning: trpt was not up to date\n"); for (i = 0; i < (int) now._nr_pr; i++) if (accpstate[ptr->_t][ptr->_p]) if (progstate[ptr->_t][ptr->_p]) if (accpstate[EVENT_TRACE][now._event]) if (progstate[EVENT_TRACE][now._event]) #if defined(C_States) && (HAS_TRACK==1) /* restore state of tracked C objects */ c_unstack((uchar *) f->m_c_stack); /* unmatched tracked data */write_root(void) /* for trail file */ if (iterative == 0 && Nr_Trails > 1) sprintf(fnm, "%%s%%d.%%s", TrailFile, Nr_Trails-1, sprefix); sprintf(fnm, "%%s.%%s", TrailFile, sprefix); { (void) unlink(fnm); /* remove possible old copy */ return; /* its the default initial state */ if ((fd = creat(fnm, TMODE)) < 0) if ((q = strchr(TrailFile, '.'))) { *q = '\0'; /* strip .pml */ sprintf(fnm, "%%s%%d.%%s", TrailFile, Nr_Trails-1, sprefix); sprintf(fnm, "%%s.%%s", TrailFile, sprefix); { cpu_printf("pan: cannot create %%s\n", fnm); if (write(fd, &cur_Root, sizeof(SM_frame)) != sizeof(SM_frame)) { cpu_printf("pan: error writing %%s\n", fnm); { cpu_printf("pan: wrote %%s\n", fnm); { 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); fd = open(fnm, O_RDONLY, 0); { sprintf(fnm, "%%s.%%s", MyFile, ssuffix); sprintf(fnm, "%%s.%%s", MyFile, ssuffix); sprintf(ssuffix, "cpu%%d_rst", try_core++); cpu_printf("no file '%%s.rst' or '%%s' (not an error)\n", MyFile, fnm); { if (read(fd, &cur_Root, sizeof(SM_frame)) != sizeof(SM_frame)) { cpu_printf("read error %%s\n", fnm); (void) unpack_state(&cur_Root, -2); cpu_printf("partial trail -- last few steps only\n"); cpu_printf("restored root from '%%s'\n", fnm); printf("=====State:=====\n"); printf("proc %%2d (%%s) ", i, procname[z->_t]); for (j = 0; src_all[j].src; j++) if (src_all[j].tp == (int) z->_t) PanSource, src_all[j].src[z->_p]); printf("(state %%d)\n", z->_p); printf("================\n");unsigned long dsk_written, dsk_drained;{ int i, clr_sz = sizeof(SM_results); { clr_sz += NrStates[i]*sizeof(uchar); /* 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) if (!f) /* 1 second timeout -- and trigger for Query */ { printf("cpu%%d: search terminated [code %%d]\n", core_id, search_terminated?*search_terminated:-1); /* to profile with cc -pg and gprof pan.exe -- set handoff depth beyond maxdepth */ 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 */ { 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 */ { 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"); if (0) cpu_printf("timed out -- try again\n"); patience = 0.0; /* reset watchdog */ { cpu_printf("got QUERY on q%%d (%%d <> %%d) from slot %%d\n", q, f->m_vsize, nstates_put + 1, prfull[q]-1); 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)) cpu_printf("warning: target q is full\n"); f = Get_Free_Frame(target_q); if (!f) { Uerror("Fatal2: no free slot"); } f->m_boq = QUIT; /* send final Quit, collect stats */ f->m_vsize = 111; /* anything non-zero will do */ cpu_printf("put QUIT on q%%d\n", target_q); { if (verbose) cpu_printf("Stale Query\n"); { if (TargetQ_Full(target_q)) cpu_printf("warning: forward query - target q full\n"); f = Get_Free_Frame(target_q); 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_boq = QUERY_F; /* no match -- busy */ f->m_vsize = 112; /* anything non-zero */ if (dsk_written != dsk_drained) { cpu_printf("got QUERY_F on q%%d from slot %%d\n", q, prfull[q]-1); if (core_id == 0 && remote_party == 0) /* original root cpu0 */ { if (verbose) cpu_printf("No Match on Query\n"); { if (verbose) cpu_printf("warning: forwarding query_f, target queue full\n"); 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 */ if (dsk_written != dsk_drained) { if (0) cpu_printf("done -- local memcnt %%g Mb\n", memcnt/(1048576.)); retrieve_info((SM_results *) f); /* collect and combine stats */ { cpu_printf("received Quit\n"); f->m_vsize = 0; /* release incoming slot */ { 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 */ 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) 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 */ if (verbose) cpu_printf("done got %%d put %%d\n", nstates_get, nstates_put); { *search_terminated |= 32; /* give_up */ } else /* we are already terminating */ vmax_seen = (vmax_seen + 7)/ 8; vmax_seen *= 8; /* round up to a multiple of 8 */ printf("cpu0: max VMAX value seen in this run: "); printf("cpu0: recommend recompiling with "); printf("-DVMAX=%%d\n", vmax_seen);mem_put(int q) /* handoff state to other cpu, workq q */ { vsize = (vsize + 7)/8; vsize *= 8; /* round up */ printf("pan: recompile with -DVMAX=N with N >= %%d\n", (int) vsize); { printf("pan: recompile with -DPMAX=N with N >= %%d\n", now._nr_pr); { printf("pan: recompile with -DQMAX=N with N >= %%d\n", now._nr_qs); 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) { 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)); { 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)); c_stack((uchar *) f->m_c_stack); /* save unmatched tracked data */ f->m_stack = stack_last[core_id]; f->nr_handoffs = nr_handoffs+1; f->m_vsize = vsize; /* must come last - now the other cpu can see it */ query_in_progress = 2; /* make sure we know, if a query makes the rounds */int dsk_file = -1, dsk_read = -1; { 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); for (i = 0; i < Dsk_W_Nr; i++) { sprintf(dsk_name, "Q%%.3d_%%.3d.tmp", i, core_id); int q = (core_id + 1) %% NCORE; /* target q */ || dsk_written <= dsk_drained) while (dsk_written > dsk_drained 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 */ { Uerror("could not open dsk file"); if (read(dsk_read, &g, sizeof(SM_frame)) != sizeof(SM_frame)) { Uerror("bad dsk file read"); memcpy(f, &g, sizeof(SM_frame)); int i, j, q = (core_id + 1) %% NCORE; /* target q */ { printf("pan: recompile with -DVMAX=N with N >= %%d\n", vsize); 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)); { 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)); { 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)); c_stack((uchar *) f.m_c_stack); /* save unmatched tracked data */ f.m_stack = stack_last[core_id]; f.nr_handoffs = nr_handoffs+1; { 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); Uerror("aborting: cannot open new diskfile"); if (write(dsk_file, &f, sizeof(SM_frame)) != sizeof(SM_frame)) { Uerror("aborting -- disk write failed (disk full?)"); || *search_terminated != 0) /* not a full crash check */ iam_alive(); /* on every transition of Down */ mem_drain(); /* maybe call this also on every Up */ if (depth > z_handoff /* above handoff limit */ && !a_cycles /* not in liveness mode */ && boq == -1 /* not mid-rv */ && (trpt->tau&4) /* claim moves first */ && !((trpt-1)->tau&128) /* not a stutter move */ && !(trpt->tau&8)) /* not an atomic move */ { int q = (core_id + 1) %% NCORE; /* circular handoff */ && (dfs_phase2 == 0 || prcnt[core_id] > 0)) return 0; /* i.e., no handoff */mem_put_acc(void) /* liveness mode */{ int q = (core_id + 1) %% NCORE; /* some tortured use of preprocessing: */#if !defined(NGQ) || defined(USE_DISK) #if !defined(NGQ) || defined(USE_DISK)init_shm(void) /* initialize shared work-queues */ { 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 */ sprintf(key, "Global\\pan_%%s_%%.3d", PanSource, m); { 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 */ } else /* worker nodes just open these segments */ { shmid[m] = OpenFileMapping( FILE_MAP_ALL_ACCESS, /* read/write access */ FALSE, /* children do not inherit handle */ { fprintf(stderr, "cpu%%d: could not create or open shared queues\n", shared_mem[m] = (char *) MapViewOfFile(shmid[m], FILE_MAP_ALL_ACCESS, 0, 0, 0); { fprintf(stderr, "cpu%%d: cannot attach shared q%%d (%%d Mb)\n", core_id, m+1, (int) (qsize/(1048576.))); { fprintf(stderr, "pan: check './pan --' for usage details\n");prep_shmid_S(size_t n) /* either sets SS or H_tab, WIN32/WIN64 */ { 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); /* make key different from queues: */ sprintf(key, "Global\\pan_%%s_%%.3d", PanSource, NCORE+2); /* different from qs */ { shmid_S = CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, (n>>32), (n & 0xffffffff), key); PAGE_READWRITE, 0, n, key); { shmid_S = OpenFileMapping(FILE_MAP_ALL_ACCESS, FALSE, key); fprintf(stderr, "cpu%%d: cannot %%s shared bitstate", core_id, core_id?"open":"create"); fprintf(stderr, "cpu%%d: cannot %%s shared hashtable", rval = (char *) MapViewOfFile(shmid_S, FILE_MAP_ALL_ACCESS, 0, 0, 0); /* attach */ { fprintf(stderr, "cpu%%d: cannot attach shared bitstate or hashtable\n", core_id); fprintf(stderr, "pan: check './pan --' for usage details\n");prep_state_mem(size_t n) /* WIN32/WIN64 sets memory arena for states */ { printf("cpu0: step 2+: pre-allocate memory arena %%d of %%g Mb\n", { 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); sprintf(key, "Global\\pan_%%s_%%.3d", PanSource, NCORE+cnt); cnt++; { shmid_M = CreateFileMapping(INVALID_HANDLE_VALUE, NULL, { shmid_M = OpenFileMapping(FILE_MAP_ALL_ACCESS, FALSE, key); { printf("cpu%%d: failed to get pool of shared memory nr %%d of size %%d\n", rval = (char *) MapViewOfFile(shmid_M, FILE_MAP_ALL_ACCESS, 0, 0, 0); /* attach */ { printf("cpu%%d: failed to attach pool of shared memory nr %%d of size %%d\n",init_HT(unsigned long n) /* WIN32/WIN64 version */ if (verbose) printf("cpu%%d: initialization for Windows\n", core_id); 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.)); get_mem = NCORE * sizeof(double) + (1 + CS_NR) * sizeof(void *)+ 4*sizeof(void *) + 2*sizeof(double); get_mem += 4 * NCORE * sizeof(void *); get_mem += (NCORE) * sizeof(Stack_Tree *); x = (volatile char *) prep_state_mem((size_t) get_mem); x += CS_NR * sizeof(void *); /* allow 1 word per entry */ 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.)); get_mem = memlim - memcnt - ((double) NCORE) * LWQ_SIZE - GWQ_SIZE; { printf("cpu0: step 2: shared state memory %%g Mb\n", x = dc_mem_start = (char *) prep_state_mem((size_t) get_mem); /* for states */ { printf("cpu%%d: insufficient memory -- aborting\n", core_id); gr_readmiss = (volatile double *) x; gr_writemiss = (volatile double *) x; stack_last = (volatile Stack_Tree **) x; x += NCORE * sizeof(Stack_Tree *); if (((long)x)&(sizeof(void *)-1)) /* word alignment */ { x += sizeof(void *)-(((long)x)&(sizeof(void *)-1)); /* 64-bit align */ ncomps = (unsigned long *) x; x += (256+2) * sizeof(unsigned long); dc_shared = (sh_Allocater *) x; /* in shared memory */ if (core_id == 0) /* root only */ { dc_shared->dc_id = shmid_M; dc_shared->dc_start = (void *) dc_mem_start; dc_shared->pattern = 1234567; dc_shared->dc_size = (long) get_mem - (long) (x - dc_mem_start); dc_shared->nxt = NULL;#if defined(WIN32) || defined(WIN64) || defined(__i386__) || defined(__x86_64__)extern BOOLEAN InterlockedBitTestAndSet(LONG volatile* Base, LONG Bit);{ return InterlockedBitTestAndSet(s, 1); #error missing definition of test and set operation for this platform { UnmapViewOfFile((char *) shared_mem[m]); UnmapViewOfFile((void *) shmid_X); CloseHandle((void *) shmid_M); if (core_id == 0 && verbose) { printf("cpu0: done, %%ld Mb of shared state memory left\n", dc_shared->dc_size / (long)(1048576)); shmid_M = (void *) (dc_shared->dc_id); UnmapViewOfFile((char *) dc_shared->dc_start); { printf("cpu%%d: done -- got %%d states from queue\n", #error MA requires SEP_STATE in multi-core mode #error BFS is not supported in multi-core mode #error SC is not supported in multi-core mode signal(SIGINT, give_up); /* windows control-c interrupt */ { printf("cpu0: step 4: creating additional workers (proxy %%d)\n", 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 if (core_id == 0) /* root starts up the workers */ { worker_pids[0] = (DWORD) getpid(); /* for completeness */ STARTUPINFO si = { sizeof(si) }; if (proxy_pid == core_id) /* always non-zero */ { sprintf(cmdline, "pan_proxy.exe -r %%s-Q%%d -Z%%d", o_cmdline, getpid(), core_id); { sprintf(cmdline, "pan.exe %%s-Q%%d -Z%%d", if (verbose) printf("cpu%%d: spawn %%s\n", core_id, cmdline); is_parent = CreateProcess(0, cmdline, 0, 0, FALSE, 0, 0, 0, &si, &pi); worker_pids[core_id] = pi.dwProcessId; worker_handles[core_id] = pi.hProcess; { 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); proxy_pid_snd = pi.dwProcessId; proxy_handle_snd = pi.hProcess; { cpu_printf("created core %%d, pid %%d (send proxy)\n", core_id, pi.dwProcessId); core_id = 0; /* reset core_id for root process */ tprefix = db0; sprefix = db1; sprintf(tprefix, "cpu%%d_trail", core_id); /* avoid conflicts on file access */ { new_state(); /* root starts the search */ cpu_printf("done with 1st dfs, nstates %%g (put %%d states), start reading q\n", SS = (uchar *) prep_shmid_S((size_t) n); start_time = times(&start_tm); delta_time = ((double) (stop_time - start_time)) / ((double) sysconf(_SC_CLK_TCK)); delta_time = ((double) (stop_time - start_time)) / ((double) CLOCKS_PER_SEC); if (readtrail || delta_time < 0.00) return; if (core_id == 0 && nstates > (double) 0) { printf("\ncpu%%d: elapsed time %%.3g seconds (%%g states visited)\n", core_id, delta_time, nstates); { printf("cpu%%d: rate %%g states/second\n", core_id, nstates/delta_time); { void check_overkill(void); printf("\npan: elapsed time %%.3g seconds\n", delta_time); { printf("pan: rate %%9.8g states/second\n", nstates/delta_time); { printf("pan: avg transition delay %%.5g usec\n", delta_time/(nstates+truncs)); printf("crash alert intervals:\n"); { printf("%%d\t%%g\n", i, t_alerts[i]); if (crash_stamp != (clock_t) 0) delta_time = ((double) (clock() - crash_stamp)) / ((double) CLOCKS_PER_SEC); delta_time = ((double) (times(&start_tm) - crash_stamp)) / ((double) sysconf(_SC_CLK_TCK)); { t_alerts[i] = delta_time; if (i == 16) t_alerts[i] = delta_time; printf("cpu%%d: crash alert off\n", core_id); if (crash_stamp == (clock_t) 0) crash_stamp = times(&start_tm); { printf("cpu%%d: crash detection\n", core_id); delta_time = ((double) (clock() - crash_stamp)) / ((double) CLOCKS_PER_SEC); delta_time = ((double) (times(&start_tm) - crash_stamp)) / ((double) sysconf(_SC_CLK_TCK)); return (delta_time >= maxtime); trpt->tau |= 4; /* the claim moves first */ && accpstate[ptr->_t][ptr->_p]) && progstate[ptr->_t][ptr->_p]) if (accpstate[EVENT_TRACE][now._event]) if (progstate[EVENT_TRACE][now._event]) Mask[0] = Mask[1] = 1; /* _nr_pr, _nr_qs */ { i = &(now._a_t) - (uchar *) &now; i = &(now._cnt[0]) - (uchar *) &now; Mask[i++] = 1; /* _cnt[] */ && (a_cycles && (trpt->o_pm&2))) { now._a_t = 2; /* set the A-bit */ now._cnt[0] = now._nr_pr + 1; printf("%%3ld: fairness Rule 1, cnt=%%d, _a_t=%%d\n", depth, now._cnt[now._a_t&1], now._a_t); 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() */ /* capture initial state of tracked C objects */ c_update((uchar *) &(now.c_state[0])); if (readtrail) getrail(); /* no return */#if defined(C_States) && defined(HAS_STACK) && (HAS_TRACK==1) /* initial state of tracked & unmatched objects */ c_stack((uchar *) &(svtack->c_stack[0]));#if defined(P_RAND) || defined(T_RAND) new_state(); /* start 1st DFS */do_reverse(Trans *t, short II, uchar M) int tt = (int) ((P0 *)this)->_p;static char _tp = 'n'; static int _qid = 0;do_transit(Trans *t, short II) uchar ot = (uchar) ((P0 *)this)->_t; if (II == -EVENT_TRACE) boq = -1;#define continue { boq = oboq; return 0; } if (II == -EVENT_TRACE) boq = oboq; for (t = trans[EVENT_TRACE][now._event]; t; t = t->nxt) { if (do_transit(t, -EVENT_TRACE)) reached[EVENT_TRACE][t->st] = 1; printf(" event_trace move to -> %%d\n", t->st); if (now._event == endevent) uerror("event_trace error (all events matched)"); for (t = t->nxt; t; t = t->nxt) { if (do_transit(t, -EVENT_TRACE)) Uerror("non-determinism in event-trace"); printf(" event_trace miss '%%c' -- %%d, %%d, %%d\n", tp, qid, now._event, t->forw); now._event = endevent; /* only 1st try will count -- fixed 4.2.6 */ uerror("event_trace error (no matching event)");{ Trans *t; uchar *othis = this; int res = 0; int tt; uchar ot; Uerror("used: enabled(pid=thisproc)"); if (pid < 0 || pid >= (int) now._nr_pr) ot = (uchar) ((P0 *)this)->_t; if (do_transit(t, (short) pid)) stop_time = times(&stop_tm); { printf("t= %%8.3g ", delta_time); printf("R= %%7.0g", nstates/delta_time); if (quota > 0.1 && delta_time > quota) { printf("Time limit of %%6.3g minutes exceeded\n", quota/60.0); leave_critical(GLOBAL_LOCK); enter_critical(GLOBAL_LOCK); /* snapshot */ printf("Depth= %%7ld States= %%8.3g ", (long) (nr_handoffs * z_handoff) + printf("Transitions= %%8.3g ", nstates+truncs); printf("Nodes= %%7d ", nr_states); printf("Memory= %%9.3f\t", memcnt/1048576.); && (stackwrite = creat(stackfile, TMODE)) < 0) Uerror("cannot create stackfile"); if (write(stackwrite, 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)); memmove(&trail[DDD], trail, (HHH-DDD+2)*sizeof(Trail)); || lseek(stackwrite, -DDD* (off_t) sizeof(Trail), SEEK_CUR) == -1) Uerror("disk2stack lseek error"); Uerror("cannot open stackfile"); if (lseek(stackread, (CNT1-CNT2)*DDD* (off_t) sizeof(Trail), SEEK_SET) == -1) have = read(stackread, trail, DDD*sizeof(Trail)); if (have != DDD*sizeof(Trail)) Uerror("stackfile read error");#if !defined(BFS) && (!defined(BITSTATE) || !defined(MA)){ if (cnt < 512) N_succ[cnt]++; else printf("tally_succ: cnt %%d exceeds range\n", cnt); printf("Successor counts:\n"); { 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]; printf("mean %%.4g (without 0: %%.4g)\n", w_avg / sum, w_avg / (sum - (double) N_succ[0])); { uerror("non-existing claim"); { m = ((Pclaim *)pptr(0))->_n; { printf("%%d: Claim %%s (%%d), from state %%d\n", (int) depth, procname[spin_c_typ[n]], n, ((Pclaim *)pptr(0))->c_cur[n]); ((Pclaim *)pptr(0))->c_cur[m] = ((Pclaim *)pptr(0))->_p; ((Pclaim *)pptr(0))->_t = spin_c_typ[n]; ((Pclaim *)pptr(0))->_p = ((Pclaim *)pptr(0))->c_cur[n]; ((Pclaim *)pptr(0))->_n = n; for (i = 0; src_all[i].src != (short *) 0; i++) { if (src_all[i].tp == spin_c_typ[n]) { src_claim = src_all[i].src; if (src_all[i].src == (short *) 0) { uerror("cannot happen: src_ln ref");{ if (n != 0) uerror("non-existing claim"); #define UPTO_P (now._nr_pr-1) #define ALL_P (II = From; II <= To; II++) #define FROM_P (now._nr_pr-1) #define ALL_P (II = From; II >= To; II--) * new_state() is the main DFS search routine in the verifier * it has a lot of code ifdef-ed together to support * different search modes, which makes it quite unreadable. * if you are studying the code, use the C preprocessor * to generate a specific version from the pan.c source, * gcc -E -DNOREDUCE -DBITSTATE pan.c > ppan.c * and then study the resulting file, instead of this version short From = FROM_P, To = UPTO_P; trpt->sched_limit = 0; /* at depth=0 only */ cpu_printf("%%d: Down - %%s %%saccepting [pids %%d-%%d]\n", depth, (trpt->tau&4)?"claim":"program", (trpt->o_pm&2)?"":"non-", From, To); printf("zap %%d: %%d (maxdepth now %%d)\n", trpt->tau &= ~(16|32|64); /* make sure these are off */#if defined(FULLSTACK) && defined(MA) (trpt+1)->o_n = 1; /* not a deadlock: as below */ (trpt-1)->tau |= 16; /* worstcase guess: as below */ printf("error: max search depth too small\n"); { uerror("depth limit reached"); (trpt+1)->o_n = 1; /* not a deadlock */ (trpt-1)->tau |= 16; /* worstcase guess */#if (defined(FULLSTACK) && !defined(MA)) || NCORE>1 /* if atomic or rv move, carry forward previous state */ trpt->ostate = (trpt-1)->ostate; if ((trpt->tau&4) || ((trpt-1)->tau&128)) if (boq == -1) { /* if not mid-rv */ /* this check should now be redundant * because the seed state also appears * on the 1st dfs stack and would be if ((now._a_t&1) && depth > A_depth) { if (!memcmp((char *)&A_Root, printf("matches seed\n"); uerror("non-progress cycle"); uerror("acceptance cycle"); if (!(trpt->tau&8)) /* if no atomic move */#if defined(BCS) && defined(NO_LAST) && defined(HAS_LAST) uchar was_last = now._last; now._last = 0; /* value not stored */ #if defined(BCS) && defined(STORE_CTX) for (xj = trpt->sched_limit; xj <= sched_max; xj++) II = bstore((char *)&now, vsize); trpt->j6 = j1_spin; trpt->j7 = j2; JJ = LL[j1_spin] && LL[j2]; now._ctx = 0; /* just in case */ II = bstore((char *)&now, vsize); trpt->j6 = j1_spin; trpt->j7 = j2; JJ = LL[j1_spin] && LL[j2]; #if defined(BCS) && defined(STORE_CTX) JJ = II; /* worstcase guess for p.o. - order corrected in 5.2.1 */ JJ = II; /* worstcase guess for p.o. - order corrected in 5.2.1 */ II = gstore((char *)&now, vsize, 0); II = hstore((char *)&now, vsize); now._last = was_last; /* restore value */#if NCORE==1 || defined (SEP_STATE) if (II == 2 && ((trpt->o_pm&2) || ((trpt-1)->o_pm&2))) if (!fairness || ((now._a_t&1) && now._cnt[1] == 1)) /* 5.1.4 */ if (a_cycles && !fairness) /* 5.1.6 -- example by Hirofumi Watanabe */ II = 3; /* Schwoon & Esparza 2005, Gastin&Moro 2004 */ printf("state match on dfs stack\n"); if (!JJ && (now._a_t&1) && depth > A_depth) printf("state match on 1st dfs stack\n"); if (II == 3 && a_cycles && (now._a_t&1)) if (fairness && now._cnt[1] > 1) /* was != 0 */ printf(" fairness count non-zero\n");same_case: if (Lstate) depthfound = Lstate->D; uerror("non-progress cycle"); uerror("acceptance cycle"); #if NCORE>1 && !defined(SEP_STATE) && defined(V_PROVISO) if (II != 0 && (!Lstate || Lstate->cpu_id < core_id)) if ((II && JJ) || (II == 3)) { /* marker for liveness proviso */ if (!(II != 0 && (!Lstate || Lstate->cpu_id < core_id))) { /* treat as stack state */ { /* treat as non-stack state */ { /* successor outside stack */#if defined(BCS) && (defined(NOREDUCE) || !defined(SAFETY))#if defined(ZAPH) && defined(BITSTATE) if (nstates > ((double)(ONE_L<<(ssize+1)))) if (zstates > ((double)(ONE_L<<(ssize-2)))) { /* more than half the bits set */ void zap_hashtable(void); /* always use the same hashfunction, for consistency across runs */ d_hash((char *) &now, vsize); /* set K1 */ if (write(svfd, (uchar *) &K1, sizeof(unsigned long)) != sizeof(unsigned long)) if (write(svfd, (uchar *) &now, vprefix) != vprefix) { fprintf(efd, "writing %%s.svd failed\n", PanSource);#if defined(MA) && defined(W_XPT) if ((unsigned long) nstates%%W_XPT == 0)#if defined(FULLSTACK) || defined(CNTRSTACK)#if defined(FULLSTACK) && !defined(MA) printf("%%d: putting %%u (%%d)\n", depth, (trpt->ostate)?trpt->ostate->tagged:0); printf("%%d: putting\n", depth); trpt->tau &= ~(1|2); /* timeout and -request off */ if (now._nr_pr == 0) /* claim terminated */ uerror("end state in claim reached"); if (stopstate[((Pclaim *)pptr(0))->_t][((Pclaim *)pptr(0))->_p]) { uerror("end state in claim reached"); if (trpt->tau&4) /* must make a claimmove */ if ((now._a_t&2) /* A-bit set */ && now._cnt[now._a_t&1] == 1) printf("%%3d: fairness Rule 3.: _a_t = %%d\n", /* Look for a process with only safe transitions */ /* (special rules apply in the 2nd dfs) */ && ((a_cycles) || (!a_cycles && depth < z_handoff)) && (sched_max > 0 || depth > BASE) !(((char *)&((trpt-1)->ostate->state))[0] & 128)) !(((char *)&(trpt->ostate->state))[0] & 128)) (trpt-1)->ostate->proviso == 0) /* attempt Partial Order Reduction as preselect moves */ if (trpt->sched_limit < sched_max)Resume: /* pick up here if preselect fails */SelectIt: From = To = II; /* preselect process */#if !defined(NOREDUCE) || (defined(ETIM) && !defined(VERI)) trpt->o_pm &= ~(8|16|32|64); /* clear fairness-marks */ && (!(trpt->tau&4) && !((trpt-1)->tau&128)) { /* A_bit = 1; Cnt = N in acc states with A_bit 0 */ { if (a_cycles && (trpt->o_pm&2)) now._cnt[now._a_t&1] = now._nr_pr + 1; printf("%%3ld: fairness Rule 1: cnt=%%d, _a_t=%%d\n", depth, now._cnt[now._a_t&1], now._a_t); { /* A_bit = 0 when Cnt 0 */ if (now._cnt[now._a_t&1] == 1) printf("%%3ld: fairness Rule 3: _a_t = %%d\n", trpt->bcs = trpt->b_pno = 0; /* initial */ if (From != To /* not a PO or atomic move */ && depth > BASE) /* there is a prior move */ { trpt->b_pno = now._last + BASE; printf("%%3ld: BCS phase 1 proc %%d limit %%d\n", depth, trpt->b_pno, trpt->sched_limit); /* allow only process b_pno to move in this phase */c_switch: /* jumps here with bcs == B_PHASE2 with or wo B_FORCED added */ printf("%%3ld: BCS c_switch phase=%%d pno=%%d [forced %%d]\n", depth, trpt->bcs, trpt->b_pno, (trpt->bcs&B_FORCED)?1:0); trpt->p_left = 1 + (To - From); trpt->p_left = 1 + (From - To); { trpt->p_skip = rand() %% (trpt->p_left); printf("%%3ld: P_RAND r_switch p_skip=%%d p_left=%%d\n", depth, trpt->p_skip, trpt->p_left); /* Main Expansion Loop over Processes */ { trpt->p_skip--; /* skip random nr of procs */ printf("%%3ld: P_RAND skipping %%d [new p_skip=%%d p_left=%%d]\n", depth, II, trpt->p_skip, trpt->p_left); printf("%%3ld: P_RAND done at %%d\n", depth, II); printf("%%3ld: P_RAND explore %%d [p_left=%%d]\n", /* no rendezvous with same proc */ if (boq != -1 && trpt->pr == II) continue; printf("%%3ld: BCS NotPre II=%%d bcs=%%d pno=%%d [forced %%d]\n", depth, II, trpt->bcs, trpt->b_pno, (trpt->bcs&B_FORCED)?1:0); else if ((trpt->bcs & B_PHASE1) && trpt->b_pno == II) printf("%%3ld: BCS IsPre II=%%d bcs=%%d pno=%%d [forced %%d]\n", if (trpt->bcs & B_PHASE2) /* 2nd phase */ { if (trpt->b_pno == II) /* was already done in phase 1 */ printf("%%3ld: BCS NoRepeat II=%%d bcs=%%d pno=%%d [forced %%d]\n", if (!(trpt->bcs & B_FORCED) /* unless forced */ && trpt->sched_limit >= sched_max) printf("%%3ld: BCS Bound II=%%d bcs=%%d pno=%%d [forced %%d]\n", continue; /* enforce bound */ tt = (int) ((P0 *)this)->_p; ot = (uchar) ((P0 *)this)->_t; /* don't repeat a previous preselected expansion */ /* could hit this if reduction proviso was false */ if (_m>_n||(_n>3&&_m!=0)) _n=_m; continue; /* did it before */ trpt->o_pm &= ~1; /* no move in this pid yet */ (trpt+1)->o_event = now._event; /* Fairness: Cnt++ when Cnt == II */ trpt->o_pm &= ~64; /* didn't apply rule 2 */ && now._cnt[now._a_t&1] == II+2) { now._cnt[now._a_t&1] -= 1; /* claim need not participate */ printf("%%3ld: proc %%d fairness ", depth, II); printf("Rule 2: --cnt to %%d (%%d)\n", now._cnt[now._a_t&1], now._a_t); if (!provided(II, ot, tt, t)) continue; /* check all trans of proc II - escapes first */ for (ooi = eoi = 0, t = trans[ot][tt]; t; t = t->nxt, ooi++) { if (strcmp(t->tp, "else") == 0 printf("randomizer: suppressed, saw else or escape\n"); printf("randomizer: skip %%d in %%d\n", eoi, ooi); for ( ; t && ooi > 0; t = t->nxt, ooi--) for (t = trans[ot][tt]; t; t = t->nxt) /* exploring all transitions from * a single escape state suffices && trpt->e_state != t->e_trans) printf("skip 2nd escape %%d (did %%d before)\n", t->e_trans, trpt->e_state); #if defined(TRIX) && !defined(TRIX_ORIG) && !defined(BFS) (trpt+1)->p_bup = now._ids_[II];P999: /* jumps here when move succeeds */ if (!(_m = do_transit(t, II))) continue; /* added 5.2.5: prior move was not po */ && !((trpt-(BASE+1))->tau & 32) && trpt->b_pno != II /* context switch */ && !(trpt->bcs & B_FORCED)) /* unless forced */ { (trpt+1)->sched_limit = 1 + trpt->sched_limit; printf("%%3ld: up sched count to %%d\n", depth, (trpt+1)->sched_limit); { (trpt+1)->sched_limit = trpt->sched_limit; printf("%%3ld: keep sched count at %%d\n", depth, (trpt+1)->sched_limit); /* for branching-time, can accept reduction only if */ /* the persistent set contains just 1 transition */ { if ((trpt->tau&32) && (trpt->o_pm&1)) trpt->o_pm |= 1; /* we moved */ printf("exiting from loopstate:\n");#if defined(VERBOSE) || defined(CHECK) cpu_printf("%%3ld: proc %%d exec %%d \n", depth, II, t->t_id); cpu_printf("%%3ld: proc %%d exec %%d, %%d to %%d, %%s %%s %%s %%saccepting [tau=%%d]\n", depth, II, t->forw, tt, t->st, t->tp, (boq != -1)?"rendez-vous":"", (trpt->o_pm&2)?"":"non-", trpt->tau); cpu_printf("\t(escape to state %%d)\n", t->st); cpu_printf("\t(randomizer %%d)\n", ooi); trpt->e_state = t->e_trans; { ((P0 *)this)->_p = t->st;/* moved down reached[ot][t->st] = 1; */#if (ACCEPT_LAB>0 && !defined(NP)) || (PROG_LAB>0 && defined(HAS_NP)) /* state 1 of np_ claim is accepting */ if (((P0 *)pptr(0))->_p == 1) for (ii = 0; ii < (int) now._nr_pr; ii++) { if (accpstate[P__Q->_t][P__Q->_p])#if defined(HAS_NP) && PROG_LAB>0 { if (progstate[P__Q->_t][P__Q->_p]) trpt->o_t = t; trpt->o_n = _n; trpt->o_ot = ot; trpt->o_tt = tt; trpt->o_To = To; trpt->o_m = _m; if (boq != -1 || (t->atom&2)) /* atomic sequence in claim */ /* if claim allowed timeout, so */ /* does the next program-step: */ if (((trpt-1)->tau&1) && !(trpt->tau&4)) if (boq == -1 && (t->atom&2)) { From = To = II; nlinks++; { From = FROM_P; To = UPTO_P; { Push_Stack_Tree(II, t->t_id); { processes[II]->modified = 1; /* transition in II */ printf("%%4d: process %%d modified\n", depth, II); { printf("%%4d: process %%d modified but gone (%%p)\n", goto Down; /* pseudo-recursion */ now._ids_[trpt->pr] = trpt->p_bup; processes[trpt->pr]->modified = 1; /* reverse move */ printf("%%4d: unmodify pr %%d (%%p)\n", { printf("%%4d: unmodify pr %%d (gone) (%%p)\n", cpu_printf("%%d: Up - %%s\n", depth, (trpt->tau&4)?"claim":"program"); /* e.g., if first state is old, after a restart */ && depth < hiwater - (HHH-DDD) - 2) printf("unzap %%d: %%d\n", CNT2, hiwater); if ((now._a_t&1) && depth <= A_depth) return; /* to checkcycles() */ if (trpt->o_pm&128) /* fairness alg */ { now._cnt[now._a_t&1] = trpt->bup.oval; _n = 1; trpt->o_pm &= ~128; printf("%%3ld: reversed fairness default move\n", depth); for (d = 1; d < depth; d++) { trl = getframe(depth-d); /* was (trpt-d) */ { now._last = trl->pr - BASE; now._last = (depth<1)?0:(trpt-1)->pr; now._event = trpt->o_event; 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; _m = do_reverse(t, II, _m);R999: /* jumps here when done */ cpu_printf("%%3ld: proc %%d reverses %%d, %%d to %%d\n", depth, II, t->forw, tt, t->st); cpu_printf("\t%%s [abit=%%d,adepth=%%d,tau=%%d,%%d]\n", t->tp, now._a_t, A_depth, trpt->tau, (trpt-1)->tau); /* pass the proviso tags */ if ((trpt->tau&8) /* rv or atomic */ (trans[ot][tt])->om = _m; /* head of list */ /* i.e., not set if rv fails */ else trpt->e_state = 0; /* undo */ if (_m>_n||(_n>3&&_m!=0)) _n=_m; printf("randomizer: continue for %%d more\n", ooi); printf("randomizer: done\n"); if (now._cnt[now._a_t&1] == 1) now._cnt[now._a_t&1] = 2; now._cnt[now._a_t&1] += 1; printf("undo Rule 2, cnt=%%d, _a_t=%%d\n", if (II == 0) break; /* never claim */ { trpt->p_skip = -1; /* probably rendundant */ printf("%%3ld: P_RAND -- explore remainder\n", depth); goto r_switch; /* explore the remaining procs */ printf("%%3ld: P_RAND -- none left\n", depth); { trpt->bcs = B_PHASE2; /* start 2nd phase */ if (_n == 0 || !(trpt->tau&64)) /* pre-move unexecutable or led to stackstate */ { trpt->bcs |= B_FORCED; /* forced switch */ printf("%%3ld: BCS move to phase 2, _n=%%d %%s\n", depth, _n, (trpt->bcs & B_FORCED)?"forced":"free"); if (_n == 0 /* no process could move */ && II >= BASE /* not the never claim */ && trpt->sched_limit >= sched_max) printf("%%3ld: BCS not a deadlock\n", depth); if (trpt->o_pm&32) /* remains if proc blocked */ if (now._cnt[now._a_t&1] == 1) printf("%%3ld: proc -- fairness ", depth); && _n == 0 /* nobody moved */ && !(trpt->tau&4) /* in program move */ && !(trpt->tau&8) /* not an atomic one */ && ((trpt->tau&1) || endstate()) && (trpt->tau&1) /* already tried timeout */ && !((trpt->tau&32) && (_n == 0 || (trpt->tau&16))) && now._cnt[now._a_t&1] > 0) /* needed more procs */ trpt->o_pm |= 128 | ((trpt-1)->o_pm&(2|4)); trpt->bup.oval = now._cnt[now._a_t&1]; printf("%%3ld: fairness default move ", depth); printf("(all procs block)\n");Q999: /* returns here with _n>0 when done */; printf("%%3ld: fairness undo Rule 1, _a_t=%%d\n", printf("%%3ld: fairness undo Rule 3, _a_t=%%d\n", /* 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))) /* preselected move - no successors outside stack */ if ((trpt->tau&32) && !(trpt->tau&64)) { From = FROM_P; To = UPTO_P; printf("%%3ld: proc %%d UnSelected (_n=%%d, tau=%%d)\n", depth, II+1, _n, trpt->tau); _n = 0; trpt->tau &= ~(16|32|64); if (MORE_P) /* II already decremented */ /* level, blocked or truncated at the next level */ depth, II+1, (int) _n, trpt->tau); if (a_cycles && (trpt->tau&16)) printf("%%3ld: setting proviso bit\n", depth); ((char *)&((trpt-1)->ostate->state))[0] |= 128; ((char *)&(trpt->ostate->state))[0] |= 128; (trpt-1)->ostate->proviso = 1; From = FROM_P; To = UPTO_P; _n = 0; trpt->tau &= ~(16|32|64); goto Again; /* do full search */ } /* else accept reduction */ { From = FROM_P; To = UPTO_P; _n = 0; trpt->tau &= ~(16|32|64); if (MORE_P) /* II already decremented */ if (_n == 0 || ((trpt->tau&4) && (trpt->tau&2))) cpu_printf("%%3ld: no move [II=%%d, tau=%%d, boq=%%d]\n", depth, II, trpt->tau, boq); /* ok if a rendez-vous fails: */ /* ok if no procs or we're at maxdepth */ if ((now._nr_pr == 0 && (!strict || qs_empty())) || depth >= maxdepth-1) goto Done; /* undo change from 5.2.3 */ if ((trpt->tau&8) && !(trpt->tau&4)) From = FROM_P; To = UPTO_P; cpu_printf("%%3ld: atomic step proc %%d unexecutable\n", depth, II+1); trpt->tau |= 4; /* switch to claim */ if (!(trpt->tau&1)) /* didn't try timeout yet */ if (trpt->tau&2) /* requested */ cpu_printf("%%d: timeout\n", depth); { /* only claim can enable timeout *//* blocks inside an atomic */ goto BreakOut; cpu_printf("%%d: req timeout\n", (trpt-1)->tau |= 2; /* request */ cpu_printf("%%d: timeout\n", depth); { trpt->tau |= 4; /* claim stuttering */ trpt->tau |= 128; /* stutter mark */ cpu_printf("%%d: claim stutter\n", depth); if (!noends && !a_cycles && !endstate()) { depth--; trpt--; /* new 4.2.3 */ uerror("invalid end state"); else if (a_cycles && (trpt->o_pm&2)) /* new 4.2.4 */ if (!(trpt->tau&8)) /* not in atomic seqs */ && (((trpt->tau&4) && !(trpt->tau&128)) printf("%%d: zapping %%u (%%d)\n", (trpt->ostate)?trpt->ostate->tagged:0); printf("%%d: zapping\n", depth); gstore((char *) &now, vsize, 1); /* --after-- a program-step, i.e., */ /* after backtracking a claim-step */ /* with at least one running process */ /* unless in a stuttered accept state */ && ((now._nr_pr > 1) || (trpt->o_pm&2)) cpu_printf("Consider check %%d %%d...\n", if ((now._a_t&2) /* A-bit */ if (a_cycles && (trpt->o_pm&2))void new_state(void) { /* place holder */ }spin_assert(int a, char *s, int ii, int tt, Trans *t) strcpy(bad, "assertion violated "); { strncpy(&bad[19], (const char *) s, 1000);Boundcheck(int x, int y, int a1, int a2, Trans *a3) spin_assert((x >= 0 && x < y), "- invalid array index", printf("%%9.8g states, stored (%%g visited)\n", nstates - nShadow, nstates); printf("%%9.8g states, stored\n", nstates); printf(" %%8g nominal states (- rv and atomic)\n", nstates-midrv-nlinks+revrv); printf(" %%8g rvs succeeded\n", midrv-failedrv); printf(" %%8g nominal states (stored-atomic)\n", nstates-nlinks); printf(" %%8g midrv\n", midrv); printf(" %%8g failedrv\n", failedrv); printf(" %%8g revrv\n", revrv); printf("%%9.8g states, matched\n", truncs); printf("%%9.8g matches within stack\n",truncs2); printf("%%9.8g transitions (= visited+matched)\n", printf("%%9.8g transitions (= stored+matched)\n", printf("%%9.8g atomic steps\n", nlinks); if (nlost) printf("%%g lost messages\n", (double) nlost); printf("hash conflicts: %%9.8g (resolved)\n", hcmp); if (hcmp > (double) (1< 100.)\n\n", (double)(((double) udmem) * 8.0) / (double) nstates); (double)(1<<(ssize-8)) / (double) nstates * 256.0); printf("bits set per state: %%u (-k%%u)\n", hfns, hfns); { printf("total bits available: %%8g (-M%%ld)\n", ((double) udmem) * 8.0, udmem/(1024L*1024L)); { printf("total bits available: %%8g (-w%%d)\n", ((double) (ONE_L << (ssize-4)) * 16.0), ssize); 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");{ double nr1, nr2, nr3 = 0.0, nr4, nr5 = 0.0;#if !defined(MA) && (defined(MEMCNT) || defined(MEMLIM)) if (verbose) cpu_printf("wrapup -- %%d error(s)\n", errors); if (search_terminated != NULL) { *search_terminated |= 2; /* wrapup */ exit(0); /* normal termination, not an error */ printf("\n(%%s)\n", SpinVersion); if (!done) printf("Warning: Search not completed\n"); (void) unlink((const char *)stackfile); { printf(" + Multi-Core (NCORE=%%d)\n", NCORE); { printf(" + Multi-Core (NCORE=%%d -z%%ld)\n", NCORE, z_handoff); printf(" + Using Breadth-First Search\n"); printf(" + Partial Order Reduction\n"); printf(" + Reverse Depth-First Search Order\n"); printf(" + Reverse Transition Ordering\n"); printf(" + Randomized Transition Ordering\n"); printf(" + Randomized Process Ordering\n"); printf(" + Scheduling Restriction (-L%%d)\n", sched_max); printf(" + Tree Index Compression\n"); printf(" + Graph Encoding (-DMA=%%d)\n", MA); printf(" Restarted from checkpoint %%s.xpt\n", PanSource); printf(" + FullStack Matching\n"); printf(" + CntrStack Matching\n"); printf("\nBit statespace search for:\n"); printf("\nHash-Compact %%d search for:\n", HC); printf("\nFull statespace search for:\n"); printf(" notrace assertion +\n"); printf(" trace assertion +\n"); printf(" never claim +"); printf(" (%%s)\n", procname[((Pclaim *)pptr(0))->_t]); printf(" assertion violations "); printf("- (disabled by -A flag)\n"); printf("+ (if within scope of claim)\n"); printf(" never claim - (not selected)\n"); printf(" never claim - (none specified)\n"); printf(" non-progress cycles "); printf(" acceptance cycles "); printf("+ (fairness %%sabled)\n", else printf("- (not selected)\n"); printf(" cycle checks - (disabled by -DSAFETY)\n"); printf(" invalid end states - "); printf(" invalid end states "); printf("- (disabled by -E flag)\n\n"); printf("State-vector %%d byte, depth reached %%ld", hmax, (nr_handoffs * z_handoff) + printf(", errors: %%d\n", errors); { extern void dfa_stats(void); printf("MA stats: -DMA=%%d is sufficient\n", printf("stackframes: %%d/%%d\n\n", smax, svmax); printf("stats: fa %%ld, fh %%ld, zh %%ld, zn %%ld - ", printf("check %%ld holds %%ld\n", Ccheck, Cholds); printf("stack stats: puts %%ld, probes %%ld, zaps %%ld\n",#if !defined(BITSTATE) && defined(NOCOMP) if (!verbose) { goto jump_here; } (double)(hmax+sizeof(struct H_el)-sizeof(unsigned)); nr2 = (double) ((maxdepth+3)*sizeof(Trail));#if !defined(MA) || defined(COLLAPSE) nr3 = (double) (ONE_L<1 && !defined(SEP_STATE) tmp_nr -= ((double) NCORE * LWQ_SIZE) + GWQ_SIZE; 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", printf(" in %%d local heaps of %%7.3f MB each\n", NCORE, mem_reserved/(NCORE*1048576.)); printf("%%9.3f memory used for hash array (-M%%ld)\n", nr3/1048576., udmem/(1024L*1024L)); printf("%%9.3f memory used for hash array (-w%%d)\n", printf("%%9.3f memory used for bit stack\n", remainder = remainder - nr3 - nr5; printf("%%9.3f actual memory usage for states", { if (tmp_nr > nr1) printf("unsuccessful "); printf("compression: %%.2f%%%%)\n", { 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)); printf("%%9.3f memory used for hash table (-w%%d)\n", printf("%%9.3f memory used for DFS stack (-m%%ld)\n", 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.); printf(" + a global q of %%7.3f MB\n", (double) GWQ_SIZE / 1048576.); if (remainder - fragment > 1048576.) printf("%%9.3f other (proc and chan stacks)\n", (remainder-fragment)/1048576.); printf("%%9.3f memory lost to fragmentation\n", printf("%%9.3f total actual memory usage\n\n", printf("%%9.3f memory usage (Mbyte)\n\n", printf("nr of templates: [ globals chans procs ]\n"); printf("collapse counts: [ "); { int i; for (i = 0; i < 256+2; i++) printf("%%d ", (int) ncomps[i]); for (i = 0; i < MAXPROC; i++) if ((done || verbose) && !no_rck) do_reach(); printf("\nPeg Counts (transitions executed):\n"); for (i = 1; i < NTRANS; i++) { if (peg[i]) putpeg(i, peg[i]); if (vprefix > 0) close(svfd); printf("%%g loopstates hit\n", cnt_loops);#if NCORE>1 && defined(T_ALERT) * super fast hash, based on Paul Hsieh's function * http://www.azillionmonkeys.com/qed/hash.html #if (defined(__GNUC__) && defined(__i386__)) || defined(__WATCOMC__) \ || defined(_MSC_VER) || defined (__BORLANDC__) || defined (__TURBOC__) #define get16bits(d) (*((const uint16_t *) (d))) #define get16bits(d) ((((uint32_t)(((const uint8_t *)(d))[1])) << 8)\ +(uint32_t)(((const uint8_t *)(d))[0]) ) tmp = (get16bits(s+2) << 11) ^ h; h = (h << 16) ^ tmp; s += 2*sizeof(uint16_t); h ^= s[sizeof(uint16_t)] << 18;#if defined(HASH64) || defined(WIN64) * http://burtleburtle.net/bob/c/lookup8.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); \ * http://burtleburtle.net/bob/c/lookup3.c#define rot(x,k) (((x)<<(k))|((x)>>(32-(k)))){ 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; \ uint64_t *k = (uint64_t *) kb; uint32_t *k = (uint32_t *) kb; n = nbytes/WS; /* nr of words */ /* extend to multiple of words, if needed */ case 7: *bp++ = 0; /* fall thru */ case 6: *bp++ = 0; /* fall thru */ case 5: *bp++ = 0; /* fall thru */ case 4: *bp++ = 0; /* fall thru */ case 3: *bp++ = 0; /* fall thru */ case 2: *bp++ = 0; /* fall thru */ c = 0x9e3779b97f4a7c13LL; /* arbitrary value */ c += (((uint64_t) nbytes)<<3); j1_spin = c&nmask; j3 = a&7; /* 1st bit */ j2 = b&nmask; j4 = (a>>3)&7; /* 2nd bit */ d_sfh((const char *) cp, om); /* sets K1 */ d_hash(cp, om); /* sets K1 etc */ srand(123); /* fixed startpoint */ prerand = (int *) emalloc((omaxdepth+3)*sizeof(int)); for (i = 0; i < omaxdepth+3; i++) case 34: nmask = (mask>>1); break; case 33: nmask = (mask>>2); break; default: nmask = (mask>>3); break; { mask = ((ONE_L<1 yetreverse_capture(struct H_el *p) /* last element of list moves first */ if (ssize < 8*WS) /* probably always true */ if (WS == 4 && ssize >= 27 - 1) { return; /* cannot increase further */ ssize += 2; /* 4x size @htable ssize */ printf("pan: resizing hashtable to -w%%d.. ", ssize); emalloc((ONE_L<0)#elif defined(P_RAND) && (P_RAND>0) { char *ptr = strrchr(argv[0], '/'); progname = emalloc(strlen(ptr)); /* printf("progname: %%s\n", progname); */ bstore = bstore_reg; /* default */ { strcat(o_cmdline, argv[j]); /* printf("Command Line: %%s\n", o_cmdline); */ if (strlen(o_cmdline) >= sizeof(o_cmdline)) { Uerror("option list too long"); while (argc > 1 && argv[1][0] == '-') case 'a': fprintf(efd, "error: -a disabled"); case 'a': a_cycles = 1; break; case 'A': noasserts = 1; break; case 'b': bounded = 1; break; case 'C': coltrace = 1; goto samething; case 'c': upto = atoi(&argv[1][2]); break; case 'D': dodot++; state_tables++; break; case 'd': state_tables++; break; case 'e': every_error = 1; upto = 0; Nr_Trails = 1; break; case 'E': noends = 1; break; case 'F': if (strlen(argv[1]) > 2)#if !defined(SAFETY) && !defined(NOFAIR) case 'f': fairness = 1; break; case 'g': gui = 1; goto samething; case 'h': if (!argv[1][2]) usage(efd); else HASH_NR = atoi(&argv[1][2])%%100; 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 */ case 'k': hfns = atoi(&argv[1][2]); break; sched_max = atoi(&argv[1][2]); if (sched_max > 255) /* stored as one byte */ { fprintf(efd, "warning: using max bound (255)\n"); { fprintf(efd, "warning: with (default) bound -L0, "); fprintf(efd, "using -DNOREDUCE performs better\n"); case 'l': a_cycles = 1; break; case 'l': fprintf(efd, "error: -l disabled"); case 'M': udmem = atoi(&argv[1][2]); break; case 'G': udmem = atoi(&argv[1][2]); udmem *= 1024; break; fprintf(stderr, "-M and -G affect only -DBITSTATE\n"); case 'm': maxdepth = atoi(&argv[1][2]); break; whichclaim = atoi(&argv[1][2]); else if (isalpha(argv[1][2])) { claimname = &argv[1][2]; } else if (argc > 2 && argv[2][0] != '-') /* check next arg */ argc--; argv++; /* skip next arg */ fprintf(stderr, "warning: only one claim defined, -N ignored\n"); fprintf(stderr, "warning: no claims defined, -N ignored\n"); if (!isdigit(argv[1][2]) && argc > 2 && argv[2][0] != '-') 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]; case 'p': vprefix = atoi(&argv[1][2]); break; case 'Q': quota = (double) 60.0 * (double) atoi(&argv[1][2]); freq /= 10.; /* for better resolution */ case 'q': strict = 1; break;#if defined(T_RAND) || defined(P_RAND) || defined(RANDSTOR) if (argv[1][2] == 'S') /* e.g., -RS76842 */ { s_rand = atoi(&argv[1][3]); { Nrun = atoi(&argv[1][2]); whichtrail = atoi(&argv[1][2]); else if (argc > 2 && argv[2][0] != '-') /* check next arg */ case 'S': silent = 1; goto samething; 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 'w': ssize = atoi(&argv[1][2]); break; case 'Y': signoff = 1; break; case 'X': efd = stdout; break; case 'x': exclusive = 1; break; /* -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]); { printf("cpu%%d: pid %%d parent %%d\n", core_id, getpid(), worker_pids[0]); case 'z': z_handoff = atoi(&argv[1][2]); break; case 'z': break; /* ignored for single-core */ default : fprintf(efd, "saw option -%%c\n", argv[1][1]); usage(efd); break; if (iterative && TMODE != 0666) fprintf(efd, "warning: -T ignored when -i or -I is used\n");#if defined(HASH32) && !defined(SFH) { fprintf(efd, "strong warning: compiling -DHASH32 on a 64-bit machine\n"); fprintf(efd, " without -DSFH can slow down performance a lot\n"); TMODE = _S_IWRITE | _S_IREAD; store_proxy_pid = proxy_pid; /* for checks in mem_file() and someone_crashed() */ if (core_id != 0) { proxy_pid = 0; } 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"); { z_handoff = 20; /* conservative default - for non-liveness checks */#if defined(NGQ) || defined(LWQ_FIXED) LWQ_SIZE = (double) (128.*1048576.); LWQ_SIZE = (double) ( z_handoff + 2.) * (double) sizeof(SM_frame); { fprintf(efd, "warning: the intended nr of cores to be used in liveness mode is 2\n"); fprintf(efd, "warning: without -DSEP_STATE there is no guarantee that all liveness violations are found\n"); #error cannot use hidden variables when compiling multi-core fprintf(efd, "warning: using -k%%d as minimal usable value\n", hfns); 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 * 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 { stackfile = (char *) emalloc(strlen(PanSource)+4+1); sprintf(stackfile, "%%s._s_", PanSource); { fprintf(efd, "error: cannot use -i or -I with -DSC\n");#if (defined(R_XPT) || defined(W_XPT)) && !defined(MA) #warning -DR_XPT and -DW_XPT assume -DMA (ignored) fprintf(efd, "warning: -i or -I work for safety properties only\n"); #error -DBFS not compatible with -DSC #error -DBFS not compatible with _last #error cannot use c_track UnMatched with BFS #error -DBFS not compatible with -DBCS #warning -DREACH is redundant when -DBFS is used #error cannot combine -DTRIX and -DBITSTATE #error cannot combine -DTRIX and -DCOLLAPSE #error cannot combine -DTRIX and -DMA #error cannot combine -DBCS and -DP_RAND #error cannot combine -DBCS and -DBFS#if defined(MERGED) && defined(PEG) #error to use -DPEG use: spin -o3 -a #error cannot combine -DHC and -DSFH /* use of NOCOMP is the real reason */ #error cannot combine -DHC and -DNOCOMP #error cannot combine -DHC and -DBITSTATE#if defined(SAFETY) && defined(NP) #error cannot combine -DNP and -DBFS or -DSAFETY #error cannot combine -DMA and -DBITSTATE #error usage: -DMA=N with N > 0 and N < VECTORSZ #error cannot combine -DBITSTATE and -DCOLLAPSE #error cannot combine -DCOLLAPSE and -DSFH #error cannot combine -DCOLLAPSE and -DNOCOMP if (maxdepth <= 0 || ssize <= 1) usage(efd);#if SYNC>0 && !defined(NOREDUCE) { 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");#if defined(REM_VARS) && !defined(NOREDUCE) #warning p.o. reduction not compatible with remote varrefs (use -DNOREDUCE)#if defined(NOCOMP) && !defined(BITSTATE) { fprintf(efd, "error: use of -DNOCOMP voids -l and -a\n"); memlim = ((double) MEMLIM) * (double) (1<<20); /* size in Mbyte */ if (Nrun > 1) HASH_NR = Nrun - 1; { fprintf(efd, "error: invalid arg for -R\n"); { fprintf(efd, "error: -f requires -a or -l\n"); { fprintf(efd, "error: no accept labels defined "); fprintf(efd, "in model (for option -a)\n"); #error use of enabled() requires -DNOREDUCE #error use of pcvalue() requires -DNOREDUCE #error use of 'else' combined with i/o stmnts requires -DNOREDUCE #if defined(HAS_LAST) && !defined(BCS) #error use of _last requires -DNOREDUCE 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"); fprintf(efd, " (this type of rv is also not compatible with -DBFS)\n"); #warning use of rendezvous with BFS does not preserve all invalid endstates#if !defined(REACH) && !defined(BITSTATE) if (iterative != 0 && a_cycles == 0) { fprintf(efd, "warning: -i and -I need -DREACH to work accurately\n");#if defined(BITSTATE) && defined(REACH) #warning -DREACH is voided by -DBITSTATE#if defined(MA) && defined(REACH) #warning -DREACH is voided by -DMA#if defined(FULLSTACK) && defined(CNTRSTACK) #error cannot combine -DFULLSTACK and -DCNTRSTACK { fprintf(efd, "warning: never claim + accept labels "); fprintf(efd, "requires -a flag to fully verify\n"); { fprintf(efd, "warning: verification in BFS mode "); fprintf(efd, "is restricted to safety properties\n"); { fprintf(efd, "hint: this search is more efficient "); fprintf(efd, "if pan.c is compiled -DSAFETY\n"); } else /* _a_t and _cnt[NFAIR] */ { S_A = (&(now._cnt[0]) - (uchar *) &now) + NFAIR - 2; /* -2 because first two uchars in now are masked */ trail = (Trail *) emalloc(6*sizeof(Trail)); trail = (Trail *) emalloc((maxdepth+3)*sizeof(Trail)); trail++; /* protect trpt-1 refs at depth 0 */ sprintf(nm, "%%s.svd", PanSource); if ((svfd = creat(nm, TMODE)) < 0) { fprintf(efd, "couldn't create %%s\n", nm); fprintf(fd, "%%s\n", SpinVersion); fprintf(fd, "Valid Options are:\n"); fprintf(fd, " -a -> is disabled by -DNP "); fprintf(fd, "(-DNP compiles for -l only)\n"); fprintf(fd, " -a find acceptance cycles\n"); fprintf(fd, " -a,-l,-f -> are disabled by -DSAFETY\n"); fprintf(fd, " -A ignore assert() violations\n"); fprintf(fd, " -b consider it an error to exceed the depth-limit\n"); fprintf(fd, " -cN stop at Nth error "); fprintf(fd, "(defaults to -c1)\n"); fprintf(fd, " -D print state tables in dot-format and stop\n"); fprintf(fd, " -d print state tables and stop\n"); fprintf(fd, " -e create trails for all errors\n"); fprintf(fd, " -E ignore invalid end states\n"); fprintf(fd, " -Ffile use 'file' to store disk-stack\n"); fprintf(fd, " -f add weak fairness (to -a or -l)\n"); 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"); fprintf(fd, " -kN set N bits per state (defaults to 3)\n"); fprintf(fd, " -LN set scheduling restriction to N (default 0)\n"); fprintf(fd, " -l find non-progress cycles\n"); fprintf(fd, " -l find non-progress cycles -> "); fprintf(fd, "disabled, requires "); fprintf(fd, "compilation with -DNP\n"); fprintf(fd, " -MN use N Megabytes for bitstate hash array\n"); fprintf(fd, " -GN use N Gigabytes for bitstate hash array\n"); fprintf(fd, " -mN max depth N steps (default=10k)\n"); fprintf(fd, " -N cn -- use the claim named cn\n"); fprintf(fd, " -Nn -- use claim number n\n"); fprintf(fd, " -n no listing of unreached states\n"); fprintf(fd, " -pN create svfile (save N bytes per state)\n"); fprintf(fd, " -QN set time-limit on execution of N minutes\n"); fprintf(fd, " -q require empty chans in valid end states\n"); 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"); fprintf(fd, " -RSN use randomization seed N\n"); 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"); 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"); fprintf(fd, " -zN handoff states below depth N to 2nd cpu (multi_core)\n"); 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"); { printf("pan: reached -DMEMLIM bound\n"); { printf("pan: out of memory\n"); printf(" %%g bytes used\n", memcnt); printf(" %%g bytes more needed\n", (double) n); printf(" %%g bytes limit\n", memlim); printf("hint: to reduce memory, recompile with\n"); printf(" -DMA=%%d # better/slower compression, or\n", hmax); printf(" -DBITSTATE # supertrace, approximation\n"); printf(" -DCOLLAPSE # good, fast compression, or\n"); printf(" -DHC # hash-compaction, approximation\n"); printf(" omit -DFULL_TRAIL or use pan -c0 to reduce memory\n"); printf("hint: to reduce memory, recompile without\n"); printf(" -DSEP_STATE # may be faster, but uses more memory\n");emalloc(unsigned long n) /* never released or reallocated */ 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; fragment += (double) left;#if defined(MA) && !defined(SAFETY){ Trans *t; uchar ot, _m; int tt; short II; memcpy((char *) &comp_now, (char *) &now, vsize); printf("%%d State: ", depth); for (i = 0; i < vsize; i++) printf("%%d%%s,", ((char *)&now)[i], Mask[i]?"*":""); if (trpt->o_pm&128) /* fairness alg */ { now._cnt[now._a_t&1] = trpt->bup.oval; for (d = 1; d < depth; d++) { trl = getframe(depth-d); /* was trl = (trpt-d); */ { now._last = trl->pr - BASE; now._last = (depth<1)?0:(trpt-1)->pr; if ((now._a_t&1) && depth <= A_depth) if (fairness) now._a_t |= 2; /* ? */ goto CameFromHere; /* checkcycles() */ ot = trpt->o_ot; II = trpt->pr; tt = trpt->o_tt; this = pptr(II); _m = do_reverse(t, II, trpt->o_m); printf("%%3ld: proc %%d ", depth, II); printf("reverses %%d, %%d to %%d,", printf(" %%s [abit=%%d,adepth=%%d,", printf("tau=%%d,%%d] \n", /* reached[ot][t->st] = 1; 3.4.13 */ if (now._cnt[now._a_t&1] == 0) if (memcmp((char *) &now, (char *) &comp_now, vsize) == 0) if (unwinding) return; /* 1.4.2 */ if (strncmp(str, laststr, 254)) cpu_printf("pan:%%d: %%s (at depth %%ld)\n", errors+1, str, printf("pan:%%d: %%s (at depth %%ld)\n", errors+1, str, (nr_handoffs * z_handoff) + ((depthfound==-1)?depth:depthfound)); if (readtrail) { wrap_trail(); return; } is_cycle = (strstr(str, " cycle") != (char *) 0); printf("sorry: MA writes 1 trail max\n"); wrapup(); /* no recovery from unwind */ { *search_terminated |= 4; /* uerror */ { depth--; trpt--; /* undo */ if (iterative != 0 && maxdepth > 0) { maxdepth = (iterative == 1)?(depth+1):(depth/2); printf("pan: reducing search depth to %%ld\n",xrefsrc(int lno, S_F_MAP *mp, int M, int i) for (T = trans[M][i]; T; T = T->nxt) { if (strcmp(T->tp, ".(goto)") == 0 || strncmp(T->tp, "goto :", 6) == 0) return 1; /* not reported */ for (j = 0; j < sizeof(mp); j++) if (i >= mp[j].from && i <= mp[j].upto) { printf("\t%%s:%%d", mp[j].fnm, lno); if (j >= sizeof(mp)) /* fnm not found in list */ { printf("\t%%s:%%d", PanSource, lno); /* use default */ printf(", \"%%s\"", q?q:"");r_ck(uchar *which, int N, int M, short *src, S_F_MAP *mp) if ((enum btypes) Btypes[M] == N_CLAIM && claimname != NULL && strcmp(claimname, procname[M]) != 0) switch ((enum btypes) Btypes[M]) { printf("unreached in proctype %%s\n", procname[M]); printf("unreached in init\n"); printf("unreached in claim %%s\n", procname[M]); || which[mapstate[M][i]] == 0)) { m += xrefsrc((int) src[i], mp, M, i); printf(" (%%d of %%d states)\n", N-1-m, N-1);#if NCORE>1 && !defined(SEP_STATE)rev_trail(int fd, volatile Stack_Tree *st_tr) 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]); { sprintf(snap, "%%ld:%%d:%%d\n", rev_trail_cnt++, st_tr->pr, st_tr->t_id); { printf("pan: error writing trailfile\n"); { (void) write(fd, "-1:-1:-1\n", 9);#if defined VERI || defined(MERGED)#if NCORE==1 || defined(SEP_STATE) || !defined(FULL_TRAIL) if (write(fd, snap, strlen(snap)) < 0) return;#if NCORE>1 && !defined(SEP_STATE) && defined(FULL_TRAIL) rev_trail(fd, stack_last[core_id]); i = 1; /* trail starts at position 1 */ #if NCORE>1 && defined(SEP_STATE) if (cur_Root.m_vsize > 0) { i++; depth++; } { if (write(fd, "-1:-1:-1\n", 9) != 9) if (trl->o_pm&128) continue; sprintf(snap, "%%ld:%%d:%%d\n", i, trl->pr, trl->o_t->t_id);notgood: printf("pan: error writing trailfile\n"); cpu_printf("pan: wrote trailfile\n");sv_save(void) /* push state vector onto save stack */ { svtack->nxt = (Svtack *) emalloc(sizeof(Svtack)); svtack->nxt->body = emalloc(vsize*sizeof(char)); svtack->nxt->lst = svtack; svtack->nxt->m_delta = vsize; } else if (vsize > svtack->nxt->m_delta) { svtack->nxt->body = emalloc(vsize*sizeof(char)); svtack->o_delta = vsize; /* don't compress */ memcpy((char *)(svtack->body), (char *) &now, vsize); cpu_printf("%%d: sv_save\n", depth);sv_restor(void) /* pop state vector from save stack */ memcpy((char *)&now, svtack->body, svtack->o_delta); c_unstack((uchar *) &(svtack->c_stack[0])); c_revert((uchar *) &(now.c_state[0])); if (vsize != svtack->o_delta) proc_offset[h] = stack->o_offset; proc_skip[h] = (uchar) stack->o_skip; printf("%%4d: p_restor %%d\n", depth, h); if (processes[h] != NULL || freebodies == NULL) { Uerror("processes error"); freebodies = freebodies->nxt; processes[h]->nxt = (TRIX_v6 *) 0; processes[h]->modified = 1; /* p_restor */ processes[h]->parent_pid = stack->parent; processes[h]->psize = stack->o_delta; memcpy((char *)pptr(h), stack->b_ptr, stack->o_delta); for (i = vsize + stack->o_skip; i > vsize; i--) memcpy(z+vsize, stack->body, stack->o_delta); for (i = 1; i <= Air[((P0 *)pptr(h))->_t]; i++) Mask[vsize - i] = 1; /* pad */ Mask[proc_offset[h]] = 1; /* _pid */ ((P0 *)pptr(h))->_pid = h-BASE; re_mark_all(1); /* p_restor - all chans move up in _ids_ */ now._ids_[h] = oi; /* restor the original contents */ printf("%%4d: q_restor %%d\n", depth, h); if (channels[h] != NULL || freebodies == NULL) channels[h]->nxt = (TRIX_v6 *) 0; channels[h]->modified = 1; /* q_restor */ channels[h]->parent_pid = stack->parent; channels[h]->psize = stack->o_delta; memcpy((char *)qptr(h), stack->b_ptr, stack->o_delta); now._ids_[now._nr_pr + h] = stack->b_ptr; q_offset[h] = stack->o_offset; q_skip[h] = (uchar) stack->o_skip; if (q_zero(now._nr_qs)) k_end += stack->o_delta;IntChunks *filled_chunks[512]; if (nr >= 512) Uerror("cannot happen grab_int"); filled_chunks[nr] = filled_chunks[nr]->nxt; { z = (IntChunks *) emalloc(sizeof(IntChunks)); z->ptr = (int *) emalloc(nr * sizeof(int)); if (!empty_chunks[nr]) Uerror("cannot happen ungrab_int"); empty_chunks[nr] = empty_chunks[nr]->nxt; printf("%%4d: delproc %%d -- parent %%d\n", depth, h, processes[h]->parent_pid); printf(" top channel: %%d -- parent %%d\n", now._nr_qs-1, channels[now._nr_qs-1]->parent_pid); && channels[now._nr_qs-1]->parent_pid == processes[h]->parent_pid) { stack->nxt = (_Stack *) emalloc(sizeof(_Stack)); stack->o_name = p_name[h]; stack->parent = processes[h]->parent_pid; stack->b_ptr = now._ids_[h]; memset((char *)pptr(h), 0, d); processes[h]->nxt = freebodies; processes[h] = (TRIX_v6 *) 0; re_mark_all(-1); /* delproc - all chans move down in _ids_ */ && q_offset[now._nr_qs-1] > proc_offset[h]) stack->nxt->body = emalloc(Maxbody * sizeof(char)); stack->o_offset = proc_offset[h]; stack->o_skip = (int) proc_skip[h]; stack->o_skip = (short) proc_skip[h]; memcpy(stack->body, (char *)pptr(h), d); for (i = vsize; i < o_vsize; i++) int d = channels[now._nr_qs - 1]->psize; int d = vsize - q_offset[now._nr_qs - 1]; stack->parent = channels[h]->parent_pid; stack->o_offset = q_offset[h]; stack->o_skip = (int) q_skip[h]; stack->o_skip = (short) q_skip[h]; stack->o_name = q_name[h]; memcpy(stack->body, (char *)qptr(h), d); printf("%%4d: delq %%d parent %%d\n", depth, h, channels[h]->parent_pid); for (k = vsize; k < o_vsize; k++) memset((char *)qptr(h), 0, d); channels[h]->nxt = freebodies; channels[h] = (TRIX_v6 *) 0; for (i = 0; i < (int) now._nr_qs; i++) for (i = BASE; i < (int) now._nr_pr; i++) if (!stopstate[ptr->_t][ptr->_p]) 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"); struct H_el *sv = trpt->ostate; /* save */ uchar prov = trpt->proviso; /* save */ { int i; uchar *v = (uchar *) &now; printf(" set Seed state "); if (fairness) printf("(cnt = %%d:%%d, nrpr=%%d) ", now._cnt[0], now._cnt[1], now._nr_pr); /* for (i = 0; i < n; i++) printf("%%d,", v[i]); */ printf("%%ld: cycle check starts\n", depth); /* 1 = 2nd DFS; (16|32) to help hasher */ memcpy((char *)&A_Root, (char *)&now, vsize); A_depth = depthfound = depth; new_state(); /* start 2nd DFS */ A_depth = 0; depthfound = -1; printf("%%ld: cycle check returns\n", depth); trpt->ostate = sv; /* restore */struct H_el *Free_list = (struct H_el *) 0;onstack_init(void) /* to store stack states in a bitstate search */{ S_Tab = (struct H_el **) emalloc(maxdepth*sizeof(struct H_el *)); { for (v = Free_list; v && ((int) v->tagged >= n); v=v->nxt)gotcha: Free_list = v->nxt; if (v && ((int) v->tagged >= n)) emalloc(sizeof(struct H_el)+n-sizeof(unsigned));{ struct H_el *grab_shared(int); return grab_shared(sizeof(struct H_el)+n-sizeof(unsigned)); #define grab_state(n) (struct H_el *) \ emalloc(sizeof(struct H_el)+n-sizeof(unsigned long)); int cnt = sizeof(struct H_el)+n-sizeof(unsigned long); { if ((cnt & (WS-1)) != 0) /* alignment */ { cnt += WS - (cnt & (WS-1)); p = (struct H_el *) reclaim_mem; { p = (struct H_el *) emalloc(cnt);ordinal(char *v, long n, short tp){ struct H_el *tmp, *ntmp; long m; struct H_el *olst = (struct H_el *) 0; enter_critical(CS_ID); /* uses spinlock - 1..128 */ for ( ;; olst = tmp, tmp = tmp->nxt) { m = memcmp(((char *)&(tmp->state)), v, n);Insert: ntmp = grab_state(n);Append: tmp->nxt = grab_state(n);#if defined(AUTO_RESIZE) && !defined(BITSTATE) memcpy(((char *)&(tmp->state)), v, n); leave_critical(CS_ID); /* uses spinlock */compress(char *vin, int nin) /* collapse compression */{ char *w, *v = (char *) &comp_now; static uchar nbytes[513]; /* 1 + 256 + 256 */ static unsigned short nbytelen; *v++ = ((P0 *) pptr(i))->_t; n = ordinal(scratch, x-scratch, 2); /* procs */ /* 3 = _a_t, _nr_pr, _nr_qs */ w = (char *) &now + 3 * sizeof(uchar); w = (char *) &(now._vsz) + sizeof(unsigned short); w = (char *) &(now._vsz) + sizeof(unsigned long); if (now._nr_qs > 0 && qptr(0) < pptr(0)) for (i = 0; i < (int) n; i++, w++) for (i = 0, j = 6; i < nbytelen; i++) n = ordinal(scratch, x-scratch, 0); /* globals */ 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 */ printf("collapse %%d -> %%d\n", vsize, v - (char *)&comp_now); return v - (char *)&comp_now;compress(char *vin, int n) /* default compression */ s_hash((uchar *)vin, n); /* sets K1 and K2 */ delta += NFAIR; /* _cnt[] */ memcpy((char *) &comp_now + delta, (char *) &K1, WS); memcpy((char *) &comp_now + delta, (char *) &K2, HC); char *v = (char *) &comp_now; { /* 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 */ 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++]; n = i = v - (char *)&comp_now; /* bytes written so far */ r = (n+WS-1)/WS; /* in words, rounded up */ r *= WS; /* total bytes to fill */ i = r - i; /* remaining bytes */ case 7: *v++ = 0; /* fall thru */ default: Uerror("unexpected wordsize"); { for (i = 0; i < n; i++, vv++) printf("compress %%d -> %%d\n",{ struct H_el *v, *w, *last = 0; n = compress((char *)&now, vsize);#if defined(BITSTATE) && defined(LC) n = compact_stack((char *)&now, vsize);#if !defined(HC) && !(defined(BITSTATE) && defined(LC)) for (v = S_Tab[j1_spin]; v; Zh++, last=v, v=v->nxt) { m = memcmp(&(v->state), nv, n); /* seen this happen, likely harmless in multicore */ { /* Uerror("stack out of wack - zap"); */ cpu_printf("pan: warning, stack incomplete\n");#if !defined(NOREDUCE) && !defined(SAFETY) v->nxt = last = (struct H_el *) 0; for (w = Free_list; w; Fa++, last=w, w = w->nxt) if (hstore((char *)&now, vsize) != 0) printf("pan: warning, double stack entry\n"); Uerror("cannot happen - unstack_put"); for (tmp = S_Tab[j1_spin]; tmp; Zn++, tmp = tmp->nxt) { m = memcmp(((char *)&(tmp->state)),v,n); { Lstate = (struct H_el *) tmp; dfa_init((unsigned short) (MA+a_cycles));#if NCORE>1 && !defined(COLLAPSE) { void init_HT(unsigned long); #if !defined(MA) || defined(COLLAPSE) init_HT((unsigned long) (ONE_L<%%d\n", n); if (a_cycles) /* place _a_t at the end */ enter_critical(GLOBAL_LOCK); /* crude, but necessary */ /* to make this mode work, also replace emalloc with grab_shared inside store MA routines */ { Info[MA] &= ~(1|16|32); /* _a_t */ { Info[MA-1] = 4; /* off-stack bit */ printf("intersected 1st dfs stack\n"); { Info[MA-1] = 1; /* proviso bit */ trpt->proviso = dfa_member(MA-1); Info[MA-1] = 4; /* off-stack bit */ { ret_val = 1; /* off-stack */ { ret_val = 2; /* on-stack */ return ret_val; /* old state */compact_stack(char *vin, int n) delta++; /* room for state[0] |= 128 */ memcpy((char *) &comp_now + delta, (char *) &K2, WS); delta += WS; /* use all available bits */ int bound = now._nr_pr; /* MAXPROC+1; */ printf("%%4d: sv_populate\n", depth); if (base[i]->modified == 0) printf("%%4d: %%s %%d not modified\n", depth, (base == processes)?"proc":"chan", i); { ((P0 *)pptr(i))->_pid = 0; s_hash(v, n); /* sets j1_spin */ { struct H_el *ntmp, *olst = (struct H_el *) 0; for (;; hcmp++, olst = tmp, tmp = tmp->nxt) { m = memcmp(((char *)&(tmp->state)), v, n); } else if (m < 0) /* insert */ } else if (!tmp->nxt) /* append */ { tmp->nxt = grab_state(n); { memcpy((char *)&(tmp->state), v, n); tmp->m_K1 = K1; /* set via s_hash */ now._ids_[cnt++] = (char *)&(tmp->state); { ((P0 *)pptr(i))->_pid = i; /* do the same for all channels */ bound = now._nr_qs; /* MAXQ+1; */hstore(char *vin, int nin) /* hash table storage */ struct H_el *tmp, *olst = (struct H_el *) 0; sv_populate(); /* update proc and chan ids */ #if defined(BITSTATE) && defined(LC) n = compact_stack(vin, nin);#if NCORE>1 && !defined(SEP_STATE) && !defined(BITSTATE) enter_critical(CS_ID); /* uses spinlock */ { /* 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) return 1; /* allow normal termination */ { for (;; hcmp++, olst = tmp, tmp = tmp->nxt) { /* skip the _a_t and the _cnt bytes */ { if (!tmp->nxt) goto Append; m = memcmp(((char *)&(tmp->state)) + S_A, { if ((((char *)&(tmp->state))[0] & V_A) != V_A) ((char *)&(tmp->state))[0] |= V_A; { /* 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 */ bp = 7 - bp; /* bp = 0..7 */ bp = 1 << bp; /* the bit mask */ if ((((char *)&(tmp->state))[ci] & bp)==0) ((char *)&(tmp->state))[ci] |= bp; /* else: wasnew == 0, i.e., old state */ Lstate = (struct H_el *) tmp; printf("1st dfs-stack intersected on state %%d+\n", printf(" New state %%d+\n", (int) tmp->st_id); dumpstate(1, (char *)&(tmp->state),n,tmp->tagged); if ((S_A)?(tmp->tagged&V_A):tmp->tagged) /* already on current dfs stack */ /* but may also be on 1st dfs stack */ && (!fairness || now._cnt[1] <= 1) printf(" Stack state %%d\n", (int) tmp->st_id); dumpstate(0, (char *)&(tmp->state),n,tmp->tagged); return 2; /* match on stack */ dumpstate(1, (char *)&(tmp->state), n, 0); printf(" Old state %%d\n", (int) tmp->st_id); dumpstate(0, (char *)&(tmp->state), n, 0); if (tmp->ctx_low > trpt->sched_limit) { tmp->ctx_low = trpt->sched_limit; tmp->ctx_pid[(now._last)/8] = 1 << ((now._last)%8); /* new */ printf("cpu%%d: ", core_id); printf(" Revisit with fewer context switches\n"); #if NCORE>1 && !defined(SEP_STATE) && !defined(BITSTATE) } else if ((tmp->ctx_low == trpt->sched_limit && (tmp->ctx_pid[(now._last)/8] & ( 1 << ((now._last)%8) )) == 0 )) { tmp->ctx_pid[(now._last)/8] |= 1 << ((now._last)%8); /* add */ printf(" Revisit with same nr of context switches\n"); printf(" ReVisiting (from smaller depth)\n"); #if NCORE>1 && !defined(SEP_STATE) && !defined(BITSTATE)#if (defined(BFS) && defined(Q_PROVISO)) || NCORE>1 return 1; /* match outside stack */ { /* insert state before tmp */ return 1; /* allow normal termination */ { /* append after tmp */ tmp->st_id = (unsigned) nstates; printf(" Push state %%d\n", ((int) nstates) - 1); printf(" New state %%d\n", (int) nstates); tmp->ctx_low = trpt->sched_limit; tmp->ctx_pid[(now._last)/8] = 1 << ((now._last)%8); /* new limit */#if !defined(SAFETY) || defined(REACH) { unsigned ci, bp; /* as above */ tmp->tagged = (S_A)?V_A:(depth+1); dumpstate(-1, v, n, tmp->tagged); Lstate = (struct H_el *) tmp;/* #if NCORE>1 && !defined(SEP_STATE) */ r_ck(reached%d, nstates%d, %d, src_ln%d, src_file%d); Maxbody = max(Maxbody, ((int) sizeof(Q%d))); if (TstOnly) return (h < MAXPROC); /* redefine Index only within this procedure */ #define Index(x, y) Boundcheck(x, y, 0, 0, 0) Uerror("too many processes"); printf("%%4d: add process %%d\n", depth, h); case 0: j = sizeof(P0); break; default: Uerror("bad proc - addproc"); proc_skip[h] = WS-(vsize%%WS); for (k = vsize + (int) proc_skip[h]; k > vsize; k--) #if defined(SVDUMP) && defined(VERBOSE) write(svfd, (uchar *) &dummy, sizeof(int)); /* mark */ write(svfd, (uchar *) &h, sizeof(int)); write(svfd, (uchar *) &n, sizeof(int)); write(svfd, (uchar *) &proc_offset[h], sizeof(int)); write(svfd, (uchar *) &now, vprefix-4*sizeof(int)); /* padd */ write(svfd, (uchar *) &proc_offset[h], sizeof(short)); write(svfd, (uchar *) &now, vprefix-3*sizeof(int)-sizeof(short)); /* padd */#if defined(BCS) && defined(CONSERVATIVE) if (now._nr_pr >= CONSERVATIVE*8) { printf("pan: error: too many processes -- recompile with "); printf("-DCONSERVATIVE=%%d\n", CONSERVATIVE+1); 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", printf("\trecompile with -DNFAIR=%%d\n", { processes[h] = freebodies; { processes[h] = (TRIX_v6 *) emalloc(sizeof(TRIX_v6)); processes[h]->body = (uchar *) emalloc(Maxbody * sizeof(char)); processes[h]->modified = 1; /* addproc */ processes[h]->parent_pid = calling_pid; processes[h]->nxt = (TRIX_v6 *) 0; for (k = 1; k <= Air[n]; k++) Mask[vsize - k] = 1; /* pad */ Mask[vsize-j] = 1; /* _pid */ { printf("pan: error, VECTORSZ too small, recompile pan.c"); printf(" with -DVECTORSZ=N with N>%%d\n", (int) vsize); memset((char *)pptr(h), 0, j); ((P0 *)this)->_pid = h-BASE; re_mark_all(1); /* addproc */ #define Index(x, y) Boundcheck(x, y, II, tt, t)#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; }{ int j, k; unsigned long ordinal(char *, long, short); default: Uerror("bad proctype - collapse"); y = (char *) ptr; k = proc_offset[i]; return ordinal(scratch, x-scratch, (short) (2+ptr->_t));#if defined(BFS) && defined(REACH) short atom; /* if &2 = atomic trans; if &8 local */ short escp[HAS_UNLESS]; /* lists the escape states */ short e_trans; /* if set, this is an escp-trans */ short tpe[2]; /* class of operation (for reduction) */ short qu[6]; /* for conditional selections: qid's */ uchar ty[6]; /* ditto: type's */ short om; /* completion status of preselects */ char *tp; /* src txt of statement */ int t_id; /* transition id, unique within proc */ int forw; /* index forward transition */ int back; /* index return transition */ #define qptr(x) (channels[x]->body) #define pptr(x) (processes[x]->body) #define qptr(x) (((uchar *)&now)+(int)q_offset[x]) #define pptr(x) (((uchar *)&now)+(int)proc_offset[x])#define q_sz(x) (((Q0 *)qptr(x))->Qlen) #define VECTORSZ 2056 /* ((MAXPROC+MAXQ+4)*sizeof(uchar *)) */ #define VECTORSZ 4112 /* the formula causes probs in preprocessing */ #define VECTORSZ 1024 /* sv size in bytes */ #if !defined(SAFETY) && !defined(MA) #if defined(SAFETY) && !defined(HASH64) #if !defined(LC) && defined(SC)#if defined(COLLAPSE2) || defined(COLLAPSE3) || defined(COLLAPSE4) /* accept the above for backward compatibility */ unsigned long *ncomps; /* in shared memory */ unsigned long ncomps[256+2];typedef struct _Stack { /* for queues and processes */typedef struct Svtack { /* for complete state vector */ short o_delta; /* current size of frame */ short m_delta; /* maximum size of frame */Trans ***trans; /* 1 ptr per state per proctype */ int depthfound = -1; /* loop detection */unsigned long vsize; /* vector size in bytes */ int vprefix=0, svfd; /* runtime option -pN */char *tprefix = "trail"; /* runtime option -tsuffix */short boq = -1; /* blocked_on_queue status */ uchar _a_t; /* cycle detection */ uchar _cnt[NFAIR]; /* counters, weak fairness */ uchar _last; /* pid executed in last step */#if defined(BITSTATE) && defined(BCS) && defined(STORE_CTX) uchar _ctx; /* nr of context switches so far */R !\ *f @ no namebad channel name '%s'proctype %s not foundcontinue%s case %d: if ( (t->ty[i] == && ()) (%s%s || ) return 0; break; (int) ( ((P%d *)this)->(int) ( now.) ) Addproc(%d); !( -( ~(^((tau)&1)((trpt->tau)&1)internal error pangen2.cclaim %s, (not runnable)eventmap %s, (not runnable)addproc(II, %denabled(II, (!(o_pm&4) && !(tau&128))((P0 *) Pptr(+BASE))->_p #ifndef XUSAFE ]&1) || (!(q_claim[, II)) && ]&2) || , II)) && #endif )==0)(!q_full()>0)|| _qid+1 != \ || qrecv()-1, continue || (x_y3_ == ]&2) , II); { q_S_check(]&1) if (q_claim[if (q_%s)) if (TstOnly) return 1; #ifdef HAS_CODE if (readtrail && gui) { char simtmp[32]; sprintf(simvals, "%%d!", sprintf(simtmp, "%%d", ); strcat(simvals, simtmp); strcat(simvals, ","); qsend(channel name: too many pars in sendif (q_zero({ boq = 0, %d, 0) != (((boq == -1 && ) || (boq == && (0, %d, 0)) && Q_has(, 1, , 0, 0{ q_R_check( { uerror("polling rv chan"); continue; } IfNotBlocked { if (boq != ; } else { if (boq != -1) ) == 0) if (q_len(; XX=10, %d, 0)) ; if (!(XX = Q_has())) (trpt+1)->bup.ovals[%d] = (trpt+1)->bup.oval = XX; if (TstOnly) return 1if (q_flds[((Q0 *)qptr(-1))->_t] != %d) , XX-1, %d, 0); XX-1, %d, ; #ifdef VAR_RANGES logval("); #endif sprintf(simvals, "%%d?", { boq = -1; #ifndef NOFAIR if (fairness && !(trpt->o_pm&32) && (now._a_t&2) #ifdef VERI if (II == 1) #ifdef DEBUG trpt->o_pm |= (32|64); }) && \ not_RV() > 0 \ && qrecv(0, %d, 0) == if (!()) if (o_pm&1) if (trpt->o_pm&1) ( () ? ) : if (TstOnly) return 1; Printf(%sprintm(((int)spin_assert(", II, tt, t)Uerror("cannot get here")if (TstOnly) if (!delproc(1, II)) ((P%d *)Pptr(BASE+f_pid(%d)))->%sno name - putnameundeclared variable '%s'[%%d][ Index(%d) ]; if (trpt->o_pm&1) ; /* dead %d: %s */ if (!readtrail) #endif cycle of goto jumps case %d: /* STATE %d */ cannot happen, dobackward; /* %d */ T = trans[%d][%d] = settr(%d,%d,0,0,0,"", %d, %d, %d); /* %s:%d */ settr(%d,%d,%d,0,0," :: stmnt1 unless stmnt2 =====>use :: stmnt1 od (or fi) unless stmnt2 =====>or rewrite #if 0 /* dead link: */ T = T->nxt = T->nxt = settr(%d,%d,%d,%d,0,"settr(0,0,0,0,0,"",0,0,0); %ssettr(%d,%d,%d,%d,%d,"/* STATE %d - %s:%d - [ bad hop %s:%d -- at %d, <] (%d:%d:%d - %d) */ cannot happen, case_cache#if NCLAIMS>1 reported%d = 1; fflush(stdout); } } reached[%d][%d] = 1; /* merge: (%d, %d, %d) */ %s%dmodifier overflow error+delta_m; delta_m = 0; goto P999; /* %d */ /* STATE %d *//* c */ ", %d, /* m: %d -> %d,%d */ reached%d[%d] = 1; tr_2_src(%d, "%s", %d); reached%d[%d] = 1; /* escape #%d: %d */ /* end-escapes */ ] */ _m = %d; goto P999; /* STATE %d */ sv_restor(); goto R999; /*->*/ trans[%d][%d] = %d, %d); T = trans[ %d][%d] = T->nxt = #define SpinVersion "%s" #define PanSource "" #define G_long %d #define G_int %d #ifdef WIN64 #define long long long #define ONE_L (1L) char *trailfilename; #if defined(BFS) #ifndef SAFETY #define SAFETY #ifndef XUSAFE #define XUSAFE #ifndef uchar #define uchar unsigned char #ifndef uint #define uint unsigned int _:never_template:_#ifndef NFAIR #define HAS_LAST %d #define DELTA %d #ifdef MA #define SEP_STATE #if MA==1 #undef MA #define MA 100 #endif #endif #ifdef W_XPT #if W_XPT==1 #undef W_XPT #define W_XPT 1000000 #define NTIM %d #define ETIM %d #define REM_VARS 1 #define REM_REFS %d #define HAS_HIDDEN %d #define HAS_SORTED %d #define M_LOSS #define HAS_RANDOM %d #define HAS_CODE #define RANDSTOR RANDSTORE #define HAS_STACK %d #define HAS_ENABLED 1 #define HAS_UNLESS %d #define HAS_PROVIDED %d #define HAS_PCVALUE %d #define HAS_BADELSE %d #ifndef NOREDUCE #define NOREDUCE 1 #define HAS_NP %d #define MERGED 1 #ifndef STORE_LAST #ifndef NO_CTX #define STORE_CTX 1 #ifdef NP #define HAS_NP 2 #define VERI %d /* np_ */ #define NCLAIMS %d #ifndef NP #define VERI %d #define EVENT_TRACE %d #define endevent endstate%d #define NEGATED_TRACE 1 typedef struct S_F_MAP { } S_F_MAP; /*** Generated by %s ***/ /*** From source: %s ***/ #include "pan.h" #include "pan_s.h" #include "pan_t.h" #ifdef LOOPSTATE double cnt_loops; #ifndef NOBOUNDCHECK #define Index(x, y) x #ifdef PEG struct T_SRC { char *fl; int ln; } T_SRC[NTRANS]; { T_SRC[m].fl = file; T_SRC[m].ln = ln; void putpeg(int n, int m) printf("%%s:%%d\n", T_SRC[n].fl, T_SRC[n].ln); char *, int, int, int); trans = (Trans ***) if (II == 0) #define rand pan_rand switch (t->forw) { #ifndef PEG #define tr_2_src(m,f,l) extern Trans ***trans; switch (forw) { IfNotBlocked _m = 3; goto P999; if (o_pm&1) continue; if (II == 0) goto R999; switch (t->back) { extern uchar reached%d[]; extern short src_ln%d[]; extern uchar *loopstate%d; extern S_F_MAP src_file%d[]; #define endstate%d %d /* CLAIM %s */ /* PROC %s */ /* proctype %d: %s */ trans[%d] = (Trans **) #define in_s_scope(x_y3_) 0 #define in_r_scope(x_y3_) 0 int tp; short *src; } src_all[] = { { %d, &src_ln%d[0] }, { 0, (short *) 0 } S_F_MAP *flref[] = { src_file%d%c #define _T5 %d #define _T2 %d #define T_ID unsigned char #define T_ID unsigned short #define T_ID unsigned int case _T5: /* np_ */ /* else fall through */ case _T2: /* true */ /* np_ demon: */ trans[_NP_] = T = trans[_NP_][0] = T->nxt = T = trans[_NP_][1] = #undef rand } #define SEPARATE #define TRANSITIONS "pan.t" #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 q_cond(short II, Trans *t) { int i = 0; for (i = 0; i < 6; i++) (!(trpt->tau&1)) if (t->ty[i] == ALPHA_F) #ifdef GLOB_ALPHA #else return switch (t->qu[i]) { case 0: break; return 0; return 1; no runable processvoid active_procs(void) { if (!permuted) { } else { #define NTRANS %d long peg[NTRANS]; void select_claim(int); extern int Maxbody; #if VECTORSZ>32000 extern int proc_offset[]; extern short proc_offset[]; extern uchar proc_skip[]; extern uchar *reached[]; extern uchar *accpstate[]; extern uchar *progstate[]; extern uchar *stopstate[]; extern uchar *visstate[]; extern short *mapstate[]; extern State now; #ifdef PROV #include PROV set_claim(); switch (n) { #define continue return 0 #include "pan_t.m" P999: return _m; } #undef continue #include TRANSITIONS pan_s.cpan_t.cpan_s.hpan_t.hpan_s.tpan_t.tpan_s.mpan_t.mpan_s.bpan_t.b#define _FILE_OFFSET_BITS 64#include #include #include #include #include #include #include #include #include #include #include #include #include #ifndef max#ifndef PRINTF#ifdef RANDOMIZE #define T_RAND RANDOMIZE int S_A = 0; #define V_A 0 #define A_V 0 #define S_A 0#undef onstack_now#undef onstack_put#undef onstack_zap#define onstack_put() ;#define onstack_zap() { \ if (trpt->ostate) \ trpt->ostate->tagged = \#ifndef NO_V_PROVISO#define V_PROVISO #define AUTO_RESIZEstruct H_el { struct H_el *nxt; unsigned int tagged; unsigned int proviso; unsigned long st_id; unsigned int D; #ifndef CONSERVATIVE uchar ctx_pid[CONSERVATIVE]; uchar ctx_low; #if VECTORSZ<65536 unsigned short ln; unsigned long ln; unsigned long m_K1; unsigned long state;} **H_tab, **S_Tab; typedef struct Trail { int o_tt; uchar pr; /* process id */ uchar tau; /* 8 bit-flags */ Meaning of bit-flags: tau&1 -> timeout enabled uchar proviso; uchar o_m; uchar o_event; unsigned short o_event; short o_To; #ifdef T_RAND short oo_i; long j6, j7; Trans *o_t; char *p_bup; char *q_bup; unsigned short sched_limit; short ipt; union { int oval; int *ovals; } bup;} Trail;Trail *trail, *trpt;FILE *efd;uchar *this;long maxdepth=10000;long omaxdepth=10000; /* bitflags in trpt->bcs */ #define B_PHASE1 1 #define B_PHASE2 2 #define B_FORCED 4int sched_max = 0;#ifdef PERMUTED uchar permuted = 1; uchar permuted = 0;long z_handoff = -1;char *stackfile;uchar *SS, *LL;uchar HASH_NR = 0;double memcnt = (double) 0;/* for emalloc: */static char *have;static long left = 0L;static unsigned long grow;unsigned int HASH_CONST[] = { 0x100d4e63, 0x0fc22f87, 0x3ff0c3ff, 0x38e84cd7, 0x02b148e9, 0x98b2e49d, 0xb616d379, 0xa5247fd9, 0xbae92a15, 0xb91c8bc5, 0x8e5880f3, 0xacd7c069, 0xb4c44bb3, 0x2ead1fb7, 0x8e428171, 0xdbebd459, 0x00400007, 0x04c11db7, 0x828ae611, 0x6cb25933, 0x86cdd651, 0x9e8f5f21, 0xd5f8d8e7, 0x9c4e956f, 0xb5cf2c71, 0x2e805a6d, 0x33fc3a55, 0xaf203ed1, 0xe31f5909, 0x5276db35, 0x0c565ef7, 0x273d1aa5, 0x8923b1dd, 0xa9acaac5, 0xd1f69207, 0xedfd944b, 0x9a68e46b, 0x5355e13f, 0x7eeb44f9, 0x932beea9, 0x330c4cd3, 0x87f34e5f, 0x1b5851b7, 0xb9ca6447, 0x58f96a8f, 0x1b3b5307, 0x31c387b3, 0xf35f0f35, 0xa0acc4df, 0xf3140303, 0x2446245d, 0xe4b8f4ef, 0x5c007383, 0x68e648af, 0x1814fba7, 0xcdf731b5, 0xd09ccb4b, 0xb92d0eff, 0xcc3c6b67, 0xd3af6a57, 0xf44fc3f5, 0x5bb67623, 0xaeb9c953, 0x5e0ac739, 0x3a7fda09, 0x5edf39eb, 0x661eefd9, 0x6423f0d1, 0x910fe413, 0x9ec92297, 0x4bd8159d, 0xa7b16ee1, 0x89d484e9, 0x7f305cb3, 0xc5f303e7, 0x415deeef, 0x09986f89, 0x7e9c4117, 0x0b7cbedb, 0xf9ed7561, 0x7a20ac99, 0xf05adef3, 0x5893d75b, 0x44d73327, 0xb583c873, 0x324d2145, 0x7fa3829b, 0xe4b47a23, 0xe256d94f, 0xb1fd8959, 0xe561a321, 0x1435ac09, 0xdd62408b, 0x02ec0bcb, 0x5469b785, 0x2f4f50bb, 0x20f19395, 0xf96ba085, 0x2381f937, 0x768e2a11,extern int core_id;long mreached=0;int done=0, errors=0, Nrun=1;int c_init_done=0;char *progname;double zstates = 0;int c_init_run;long Fa=0, Fh=0, Zh=0, Zn=0;long PUT=0, PROBE=0, ZAPS=0;long Ccheck=0, Cholds=0;char *claimname;char simvals[128];int TstOnly=0;unsigned long mask, nmask;int ssize=23; /* 1 Mb */int hmax=0, svmax=0, smax=0;int Maxbody=0, XX;void logval(char *, int);void dumpranges(void);unsigned int maxgs = 0;#ifdef ALIGNEDState comp_msk;State comp_tmp;static unsigned long K1, K2;static long udmem;static long A_depth = 0;long depth = 0;long nr_handoffs = 0;void set_recvs(void);int no_recvs(int);#define UnBlock boq = -1int (*bstore)(char *, int);int bstore_reg(char *, int);int bstore_mod(char *, int);void active_procs(void);void cleanup(void);void do_the_search(void);void find_shorter(int);void iniglobals(int);void stopped(int);void wrapup(void);int *grab_ints(int);void ungrab_ints(int *, int);Trans * 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;cpytr(Trans *a) tmp->atom = a->atom; tmp->st = a->st; tmp->e_trans = a->e_trans; tmp->escp[i] = a->escp[i]; tmp->tpe[0] = a->tpe[0]; tmp->tpe[1] = a->tpe[1]; { tmp->qu[i] = a->qu[i]; tmp->ty[i] = a->ty[i]; strcpy(tmp->tp, a->tp); tmp->t_id = a->t_id; tmp->forw = a->forw; tmp->back = a->back;srinc_set(int n){ if (n <= 2) return LOCAL; return BAD;srunc(int n, int m){ switch(m) { case Q_FULL_F: return n-2; case ALPHA_F:int cnt;isthere(Trans *a, int b) for (t = a; t; t = t->nxt) if (t->t_id == b){ int g = 0, i, j, k; if (!t) return 0; if (t->qu[0]) for (i = 0; i < 2; i++) { j = srinc_set(t->tpe[i]); return -1; { 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; return g; int i, k; int g, h, j, aa; int p; if (state_tables >= 4) { printf("STEP 1 %%s\n", for (i = 1; i < m; i++) crack(n, i, T0, srcln); do { { T2 = trans[n][i]; i, T0->st); if (T0) { T3 = trans[n][T0->st]; if (!T3->nxt) { T2->nxt = cpytr(T0); T2 = T2->nxt; imed(T2, T0->st, n, i); do { T3 = T3->nxt; T2->nxt = cpytr(T3); } while (T3->nxt); cnt++; } while (cnt); if (state_tables >= 3) { printf("STEP 2 %%s\n", { T1 = trans[n][i]->nxt; trans[n][i] = T0; T1->st, T1->forw, i); T0 = T0->nxt; reach[T1->st] = 1; imed(T0, T1->st, n, i); if (state_tables >= 2) { printf("STEP 3 %%s\n", * list of state i { if (p = T0->escp[k]) T2 = cpytr(T1); T2->e_trans = p; T2->nxt = trans[n][i]; trans[n][i] = T2; { T4 = T3 = (Trans *) 0; T2->nxt = (Trans *) 0; if (T3) T3->nxt = T2; else T4 = T2; T3 = T2; if (T4) { T3->nxt = trans[n][i]; trans[n][i] = T4; } if (progstate[n][i]) if (progstate[n][T1->st]) if (accpstate[n][T1->st]) T1 = trans[n][i]; if (!T1) continue; if (T1->nxt) { k = 0; { if (!(T0->atom&8)) goto degrade; if (T0->tpe[aa] && T0->tpe[aa] != T1->tpe[0]) k = 1; /* g = 0; V3.3.1 */ for (aa = 0; aa < 2; aa++) if (j != LOCAL) 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) srcln[i]); g); goto degrade; if (!(T1->atom&8)) break; if (T1) j = T1->tpe[0]; if (T1->nxt && T1->atom&8) { if (j == 5*DELTA) T0->tpe[aa], j, T1->tp, T0->tp); } } if (!T2 || T2->nxt || !stopstate[n][i]) stopstate[n][T2->st] = 1; { if (dodot) while (*p != '\0') { if (*p != ':') { *q++ = *p; p++; *q = '\0'; printf("digraph "); switch (Btypes[n]) { { switch (Btypes[n]) { { reach[i] = 1; if (dodot) printf("}\n"); { int nrelse; if (Btypes[n] != N_CLAIM) { if (T0->st == i procname[n]); srcln[i], i); pan_exit(1); nrelse = 0; nrelse++; if (nrelse > 1) { for (i = 1; i < m; i++) T4 = T4->nxt; Ty = T5; /* its tail */ T3 = (Trans *) 0; for (T5 = T0; T5; T5 = T4) { T4 = T5->nxt; if (T5->e_trans) { T3 = T5; T5->nxt = (Trans *) 0; { T5->nxt = T1; if (!T1) { T2 = T5; } T1 = T5; trans[n][i] = T1; if (state_tables && verbose) mapstate[n][j] = T->st;{ Trans *z; if (is >= m || !trans[n][is] reach[is] = 0; dot_crack(n, is, z); crack(n, is, z, srcln); int i, j; if (!j) break; { lstate[is] = 1; for (i = 0; i < m; i++) reach[i] &= ~(4|8|16);{ int i; if (!z) return; j, z->forw, z->st); if (z->e_trans) else if (state_tables >= 2) { if (!z->escp[i]) break; accpstate[n][j]?"a" :"-", stopstate[n][j]?"e" : "-", progstate[n][j]?"p" : "-", z->atom & 8 ?"L":"G", PanSource, srcln[j]); for (i = 0; z->tp[i]; i++) if (z->tp[i] == '\n') putchar(z->tp[i]); if (verbose && z->qu[0]) { printf("\t["); for (i = 0; i < 6; i++) if (z->qu[i]) printf("(%%d,%%d)", z->qu[i], z->ty[i]); printf("]"); else printf(",style=bold"); printf(",label=\""); { if (z->tp[i] == '\\' && z->tp[i+1] == 'n') { i++; printf(" "); { putchar(z->tp[i]); printf("\"];\n");typedef struct Vr_Ptr { char *nm; uchar vals[BYTESIZE]; struct Vr_Ptr *nxt;} Vr_Ptr;logval(char *s, int v){ Vr_Ptr *tmp; if (v<0 || v > 255) return; if (!strcmp(tmp->nm, s)) goto found; tmp->nxt = ranges; ranges = tmp; tmp->nm = s;found:dumpval(uchar X[], int range){ int w, x, i, j = -1; for (x = 0; x < 8; x++, i++)from: if ((X[w] & (1<= 0 && j != 255) printf("-255");dumpranges(void)#define uchar unsigned char#define ulong unsigned long#define ushort unsigned short#define TWIDTH 256extern int dfa_member(ulong);extern void dfa_stats(void);typedef struct Edge { struct Vertex *Dst; struct Edge *Nxt;} Edge;typedef struct Vertex {} Vertex;static Edge *free_edges;static Vertex *free_vertices;recyc_edges(Edge *e) if (!e) return; recyc_edges(e->Nxt); e->Nxt = free_edges; free_edges = e;static Edge *new_edge(Vertex *dst) if (free_edges) { e = free_edges; free_edges = e->Nxt; e->Dst = dst; return e;recyc_vertex(Vertex *v) recyc_edges(v->Succ); free_vertices = v; nr_states--;static Vertex *new_vertex(void){ Vertex *v; if (free_vertices) { v = free_vertices; v->Succ = (Edge *) 0; v->num = 0; nr_states++; return v; 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;{ /* put new edge first */ if (!v->dst[0]) { v->dst[0] = e->Dst; v->from[0] = e->From; v->to[0] = e->To; if (!v->dst[1]) } /* shift */ { int f = v->from[1]; int t = v->to[1]; Vertex *d = v->dst[1]; e->From = f; e->To = t; e->Dst = d; e->Nxt = v->Succ; v->Succ = e;{ Edge *f; f = new_edge(e->Dst); f->To = e->To; f->s = e->s; f->S = e->S; f->Nxt = v->Succ; v->Succ = f; to->to[i] = from->to[i]; to->dst[i] = from->dst[i]; if (!first && INRANGE(ov,h)) { tmp.From = v->from[i]; tmp.To = v->to[i]; tmp.Dst = v->dst[i]; tmp.s = tmp.S = 0; ov = &tmp; return ov; return (Edge *) 0; return v->dst[1]; if (INRANGE(e,h)) return e->Dst; return (Vertex *) 0;numDelta(Vertex *v, int d) ulong cnt; v->dst[i]->num = cnt; e->Dst->num = cnt; { if (h == v->from[i]) { if (h == v->to[i]) v->from[i]++; } else if (h == v->to[i]) { v->to[i]--; g->From = v->from[i]; insert_edge(v, g); goto part2; { e->s = e->S = 0; goto rem_tst; { if (h == e->From) { if (h == e->To) { if (e->s) e->s = 0; } else goto rem_do; e->From++; } else if (h == e->To) { e->To--; } else /* split */ g->From = e->From; break; /* done */ { if (e->s == 0) {rem_do: if (f) f->Nxt = e->Nxt; v->Succ = e->Nxt; e->Nxt = (Edge *) 0; recyc_edges(e); { e->From = e->To = e->S;part2: if (v->dst[i] == newdst) { v->from[i] = h; return; if (h == (int) v->to[i]+1) { v->to[i] = h; { if (e->Dst == newdst) { if (h+1 == (int) e->From) { e->From = h; { e->From = e->S; e->s = e->S = 0; if (h == (int) e->To+1) { e->To = h; { e->To = e->S; if (e->s == 0) { e->s = 1; e->S = h; /* add as a new edge */ e = new_edge(newdst); e->From = e->To = h;static ulongcheap_key(Vertex *v){ ulong vk2 = 0; if (v->dst[0]) { vk2 = (ulong) v->dst[0]; vk2 = (ulong) v->dst[1]; } else if (v->dst[1]) vk2 = (ulong) v->dst[1]; if (v->Succ) { Edge *e; if ((ulong) e->Dst > vk2) vk2 = (ulong) e->Dst; Tally = (vk2>>2)&(TWIDTH-1); return v->key;{ ulong m = 0, vk2 = 0; vk2 = (ulong) v->dst[0]; if (v->dst[1]) return m; if (v->dst[i]) if ((ulong) f->Dst > vk2 vk2 = (ulong) f->Dst; m += HASH(n, 1);void dfa_init(ushort nr_layers){ int i; Vertex *r, *t; t = allDelta(r, i-1); NF = allDelta(r, i-1);doubletree_stats(Vertex *t){ Edge *e; double cnt=0.0; if (!t->key) return 0; t->key = 0; /* precaution */ if (t->dst[0]) cnt++; if (t->dst[1]) cnt++; cnt += tree_stats(t->lnk); cnt += tree_stats(t->left); cnt += tree_stats(t->right); return cnt;dfa_stats(void){ int i, j; double cnt = 0.0; for (j = 0; j < TWIDTH; j++) nr_states, cnt);dfa_member(ulong n){ Vertex **p, **q; uchar *w = &word[n]; p = &path[n]; q = (p+1); *q++ = Delta(*p++, *w++); return (*p == F);dfa_store(uchar *sv) uchar *w, *u = lastword; int i, j, k; w = word = sv; if (pfrst > iv) pfrst = iv; if (pfrst > nv) pfrst = nv;/* phase1: *//* phase2: */ iv = dfa_depth; do { iv--; old = new; } 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); s = y; { 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++; if (path[j]->num == 0) { numDelta(path[j], -1); delete_it(path[j], j); recyc_vertex(path[j]);splay(ulong i, Vertex *t){ Vertex N, *l, *r, *y; if (!t) return t; l = r = &N; { 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; if (!t->right) break; l->right = t; l = t; t = t->right; l->right = t->left; r->left = t->right; t->left = N.right; t->right = N.left;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; { layers[nr] = v; t = splay(i, t); { new = v; new->left = t->left; new->right = t; t->left = (Vertex *) 0; new->right = t->right; new->left = t; t->right = (Vertex *) 0; t->lnk = v; layers[nr] = new;static int{ Edge *g, *f; int i, k, j = 1; for (k = 0; k < 2; k++) if (h->dst[k]) if (h->dst[k] != g->Dst) goto no_match; i = g->To; { if (INRANGE(f,sigma)) { if (i == sigma) continue; if (f->Dst != g->Dst) if (f->s && f->S != sigma)no_match:{ Vertex *z, *t; i = mk_special(sigma,n,v); if (!t) return (Vertex *) 0; if (i == t->key) for (z = t; z; z = z->lnk) return z;delete_it(Vertex *v, int L){ Vertex *x, *t; i = cheap_key(v); if (!t) return; ; if (z != v) goto bad; if (y) { y->lnk = z->lnk; z->lnk = (Vertex *) 0; layers[nr] = t; { y = z->lnk; y->left = t->left; y->right = t->right; layers[nr] = y; if (!t->left) { x = t->right; { x = splay(i, t->left); x->right = t->right; layers[nr] = x;static Vertex **temptree;static char wbuf[4096];static uchar stacker[MA+1];static ulong stackcnt = 0; if (wcnt+n >= 4096) { write(fd, wbuf, wcnt); wcnt = 0; memcpy(&wbuf[wcnt], b, n); wcnt += n;wclose(fd) if (wcnt > 0) write(fd, wbuf, wcnt);w_vertex(int fd, Vertex *v){ char t[3]; int i; Edge *e; t[0] = 0; xwrite(fd, t, 3); if (e->s) { t[1] = t[2] = e->S;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);w_xpoint(void){ int fd; char nm[64]; int i, j; uchar c; static uchar xwarned = 0; if (!xwarned) { xwarned = 1; wclose(fd);xread(int fd, char *b, int n) if (m < n) delta = m; if (wcnt < n-m) n -= m; wcnt -= n;x_cleanup(Vertex *c) if (!c) return; x_cleanup(e->Dst); recyc_vertex(c);x_remove(void){ Vertex *tmp; int i, s; int r, j; /* double-check: */ if (r != 1 || j != 0) { printf("%%d: ", stackcnt); stacker[dfa_depth-1] = 1; s = dfa_member(dfa_depth-1); if (s) dfa_store(stacker); stacker[dfa_depth-1] = 0; dfa_store(stacker); stackcnt++;x_rm_stack(Vertex *t, int k){ int j; Edge *e; if (k == 0) { x_remove(); if (t) { stacker[k] = (uchar) j; x_rm_stack(e->Dst, k-1); { stacker[k] = e->S; t = splay(v->key, t); if (v->key < t->key) } else if (v->key > t->key) { recyc_vertex(v); new = t; temptree[L] = new; return new;{ Vertex *t = temptree[L]; if (t->key == (ulong) v) return t;r_layer(int fd, int n) char c, t[2]; { xread(fd, &c, 1); if (c == 2) break; if (c == 1) { v = new_vertex(); v = insert_withkey(v, n); } else /* c == 0 */ xread(fd, t, 2); e->From = t[0]; e->To = t[1]; insert_edge(v, e);v_fix(Vertex *t, int nr){ int i; Edge *e; v_fix(t->left, nr); v_fix(t->right, nr);v_insert(Vertex *t, int nr){ Edge *e; int i; v_insert(t->left, nr); v_insert(t->right, nr); if (t->dst[i])x_fixup(void) v_fix(temptree[i], (i+1)); v_insert(temptree[i], i);x_tail(Vertex *t, ulong want) if (!t) return v; yes = no = 0; if (t->from[i] == 0) yes = 1; no = 1; if ((ulong) e->Dst == want) else if (INRANGE(e, 4)) if (yes && !no) return t; f = new_edge(v); f->From = t->from[i]; f->To = t->to[i]; f->Nxt = c->Succ; c->Succ = f; if (nr > 0) f->From = e->From; f->To = e->To; f->s = e->s; f->S = e->S; x_anytail(t->left, c, nr); x_anytail(t->right, c, nr);x_cpy_rev(void) if (!v) return (Vertex *) 0; return c;r_xpoint(void) path[0] = R = new_vertex(); R = insert_withkey(R, 0); F = new_vertex(); NF = new_vertex(); r_layer(fd, i); d = x_cpy_rev(); x_fixup(); x_rm_stack(d, dfa_depth-2); x_cleanup(d);run operator used in invalid contextmore than one run operator in expressionuse of run operator in compound expression(trpt+1)->bup.ovals = grab_ints(%d); Uerror("block in d_step seq")%sspin: error, cannot find pid %d spin: warning, %s:%d, 'timeout' in d_step sequence 'run' in d_step sequence (use atomic)too many parameters in run %s(...)(!(trpt->o_pm&4) && !(trpt->tau&128))if ((II == -EVENT_TRACE && _tp != 's') #if !defined(XUSAFE) && !defined(NOREDUCE) { uerror("sorted send on xr channel violates po reduction"); { nlost++; delta_m = 1; } else { if (no_recvs(II)) continue; %d msg parameters sent, %d expected ; Uerror("rv-attempt in d_step")if ((II == -EVENT_TRACE && _tp != 'r') uerror("rand receive on xr channel violates po reduction"); Uerror("wrong nr of msg fields in rcv"); cannot use var ('%s') in multiple msg fields && now._cnt[now._a_t&1] == II+2) { now._cnt[now._a_t&1] -= 1; now._cnt[now._a_t&1] = 1; printf("%%3d: proc %%d fairness ", depth, II); printf("Rule 2: --cnt to %%d (%%d)\n", now._cnt[now._a_t&1], now._a_t); #if defined(C_States) && (HAS_TRACK==1) c_update((uchar *) &(now.c_state[0])); return (II+1 == now._nr_pr); spin: error, %s:%d, bad node type %d (.m) proctype-name '%s' used as array-nameref to array element invalid in this context hint: instead of, e.g., x[rs] qu[3], use chan nm_3 = qu[3]; x[rs] nm_3; and use nm_3 in sends/recvs instead of qu[3] ref to scalar '%s' using array index uerror("non-determinism in D_proctype") /* mark-down line %d status %d = %d */ error: (%s:%d) saw 'unless' on a guard: spin: warning, %s:%d: condition is always false ] (%d:%d - %d) same as %d (%d:%d - %d) */ case %d: /* STATE %d - %s:%d - [> looking for %d -- merge %d:%d:%d merge requires more than 256 bups #if defined(VERI) && !defined(NP) { static int reported%d = 0; int nn = (int) ((Pclaim *)this)->_n; if (verbose && !reported%d) { printf("depth %%ld: Claim %%s (%%d), state %%d (line %%d)\n", depth, procname[spin_c_typ[nn]], nn, (int) ((Pclaim *)this)->_p, src_claim[ (int) ((Pclaim *)this)->_p ]); { static int reported%d = 0; { printf("depth %%d: Claim, state %%d (line %%d)\n", (int) depth, (int) ((Pclaim *)this)->_p, /* stop at bad hop %d, %d */ ungrab_ints(trpt->bup.ovals, %d); trans[%d][%d]->escp[%d] = %d; #if defined(C_States) && (HAS_TRACK==1) spin: cannot create pan.[chtmfb] #define ONE_L ((unsigned long) 1) char *TrailFile = PanSource; /* default */ includes the same remote references #define NFAIR 2 /* must be >= 2 */ #if NCORE>1 && !defined(SEP_STATE) #define NFAIR 2 /* must be >= 2 */ #if defined(RANDSTORE) && !defined(RANDSTOR) #if !defined(HAS_LAST) && defined(BCS) #define HAS_LAST 1 /* use it, but */ #define NO_LAST 1 /* dont store it */ #if defined(BCS) && defined(BITSTATE) char *fnm; int from; int upto; State A_Root; /* seed-state for cycles */ State now; /* the full state-vector */ extern int verbose; extern long depth; #define Index(x, y) Boundcheck(x, y, II, tt, t) void tr_2_src(int m, char *file, int ln) { printf("%%5d trans %%4d ", m, n); void settable(void) { Trans *T; Trans *settr(int, int, int, int, int,emalloc(%d*sizeof(Trans **)); { _m = step_claim(trpt->o_pm, trpt->tau, tt, ot, t); if (_m) goto P999; else continue; #if defined(HAS_CODE) && defined(VERBOSE) cpu_printf("Pr: %%d Tr: %%d\n", II, t->forw); void set_claim(void) { Trans *T; extern Trans *settr(int, int, int, int, int, cpu_printf("Pr: %%d Tr: %%d\n", II, forw); default: Uerror("bad forward move"); case 0: /* if without executable clauses */ case 1: /* generic 'goto' or 'skip' */ case 2: /* generic 'else' */ if (trpt->o_pm&1) continue; default: Uerror("bad return move"); case 0: goto R999; /* nothing to undo */ #define nstates%d %d /* %s */ #define nstates_event nstates%d emalloc(%d*sizeof(Trans *)); if (!((!(o_pm&4) && !(tau&128)))) if (!((!(trpt->o_pm&4) && !(trpt->tau&128)))) (Trans **) emalloc(2*sizeof(Trans *)); settr(9997,0,1,_T5,0,"(np_)", 1,2,0); settr(9998,0,0,_T2,0,"(1)", 0,2,0); settr(9999,0,1,_T5,0,"(np_)", 1,2,0); #define FORWARD_MOVES "pan_s.m" #define REVERSE_MOVES "pan_s.b" #define TRANSITIONS "pan_s.t" extern void ini_claim(int, int); #define FORWARD_MOVES "pan.m" #define REVERSE_MOVES "pan.b" { if (t->ty[i] == TIMEOUT_F) return %s; (II+1 == (short) now._nr_pr && II+1 < MAXPROC); default: Uerror("unknown qid - q_cond"); #define FORWARD_MOVES "pan_t.m" #define REVERSE_MOVES "pan_t.b" #define TRANSITIONS "pan_t.t" void ini_claim(int n, int h) { extern void set_claim(void); int step_claim(int o_pm, int tau, int tt, int ot, Trans *t) { int forw = t->forw; int _m = 0; extern char *noptr; int II=0; int rev_claim(int backw) { return 0; } #define Offsetof(X, Y) ((unsigned long)(&(((X *)0)->Y)))#define max(a,b) (((a)<(b)) ? (b) : (a))int Printf(const char *fmt, ...); /* prototype only */ #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]--#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))#define onstack_zap() gstore((char *) &now, vsize, 4)#if defined(FULLSTACK) && !defined(BITSTATE)#define onstack_put() trpt->ostate = Lstate (S_A)? (trpt->ostate->tagged&~V_A) : 0; \#if !defined(NO_RESIZE) && !defined(AUTO_RESIZE) && !defined(BITSTATE) && !defined(SPACE) && NCORE==1 #if defined(BITSTATE) && !defined(NOREDUCE) && !defined(SAFETY)#if defined(CHECK) || (defined(COLLAPSE) && !defined(FULLSTACK)) #define CONSERVATIVE 1 /* good for up to 8 processes */ #if CONSERVATIVE <= 0 || CONSERVATIVE>32 #error sensible values for CONSERVATIVE are 1..32 (256/8 = 32) /* could cost 1 extra word: 4 bytes if 32-bit and 8 bytes if 64-bit */ uchar cpu_id; /* id of cpu that created the state */ int st; /* current state */ uchar o_pm; /* 8 more bit-flags */ 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 uchar n_succ; /* nr of successor states */#if defined(FULLSTACK) && defined(MA) && !defined(BFS) uchar o_n, o_ot; /* to save locals */#if defined(HAS_UNLESS) && !defined(BFS) int e_state; /* if escape trans - state of origin */#if (defined(FULLSTACK) && !defined(MA)) || defined(BFS) || (NCORE>1) struct H_el *ostate; /* pointer to stored state */#if !defined(BFS) && !defined(TRIX_ORIG) unsigned char bcs; /* phase 1 or 2, or forced 4 */ unsigned char b_pno; /* preferred pid */ unsigned char p_left; /* nr of procs left to explore */ short p_skip; /* to find starting point in list */double quota; /* time limit */double memlim = (double) (1<<30); /* 1 GB */double mem_reserved = (double) 0;static double fragment = (double) 0; /* asuming 4 bytes per int */char *c_stack_start = (char *) 0;double nstates=0, nlinks=0, truncs=0, truncs2=0;double nlost=0, nShadow=0, hcmp=0, ngrabs=0;double midrv=0, failedrv=0, revrv=0;unsigned long nr_states=0; /* nodes in DFA */int a_cycles=0, upto=1, strict=0, verbose = 0, signoff = 0;int gui = 0, coltrace = 0, readtrail = 0;int whichtrail = 0, whichclaim = -1, onlyproc = -1, silent = 0;int state_tables=0, fairness=0, no_rck=0, Nr_Trails=0, dodot=0;int ssize=19; /* 512K slots */uchar *noptr, *noqptr; /* used by Pptr(x) and Qptr(x) */extern void dfa_init(unsigned short);extern int dfa_member(unsigned long);extern int dfa_store(uchar *); State comp_now __attribute__ ((aligned (8))); /* gcc 64-bit aligned for Itanium2 systems */ /* MAJOR runtime penalty if not used on those systems */ State comp_now; /* compressed state vector */uchar *Mask = (uchar *) &comp_msk;static char *scratch = (char *) &comp_tmp;_Stack *stack; /* for queues, processes */Svtack *svtack; /* for old state vectors */static unsigned int hfns = 3; /* new default */static unsigned long j1_spin; /* 5.2.1: avoid nameclash with math.h */static unsigned long j2, j3, j4;static uchar warned = 0, iterative = 0, exclusive = 0, like_java = 0, every_error = 0;static uchar noasserts = 0, noends = 0, bounded = 0;unsigned int s_rand = 123; /* default seed */#define IfNotBlocked if (boq != -1) continue;#define IfNotBlocked /* cannot block */#define UnBlock /* don't bother */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 */ for (i = 0; i < HAS_UNLESS; i++) tmp->tp = (char *) emalloc(strlen(a->tp)+1); 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"); 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 TIMEOUT_F: return 257; /* non-zero, and > MAXQ */ Uerror("cannot happen srunc");mark_safety(Trans *t) /* for conditional safety */ return (t->qu[1])?2:1; /* marked */ if (j >= GLOBAL && j != ALPHA_F)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, *T4, *T5; for (T0 = trans[n][i]; T0; T0 = T0->nxt) for (i = 1, cnt = 0; i < m; 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) printf("\tstate %%d / %%d: choice in choice\n", for (T0 = T1; T0; T0 = T0->nxt) { if (trans[n][i] && trans[n][i]->nxt) /* optimize */ printf("\t\tpull %%d (%%d) to %%d\n", srcln[i] = srcln[T1->st]; /* Oyvind Teig, 5.2.0 */ if (!trans[n][T1->st]) continue; T0 = cpytr(trans[n][T1->st]); for (T1 = T1->nxt; T1; T1 = T1->nxt) /* srcln[i] = srcln[T1->st]; gh: not useful */ if (!trans[n][T1->st]) continue; T0->nxt = cpytr(trans[n][T1->st]); { 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- if (!like_java) /* the default */ { for (T0 = trans[n][i]; T0; T0 = T0->nxt) for (k = HAS_UNLESS-1; k >= 0; k--) for (T1 = trans[n][p]; T1; T1 = T1->nxt) { if (isthere(trans[n][i], T1->t_id)) } else /* outermost unless checked first */ { /* moves through these states are visible */ #if PROG_LAB>0 && defined(HAS_NP) for (T1 = trans[n][i]; T1; T1 = T1->nxt) if (accpstate[n][i] || visstate[n][i]) g = mark_safety(T1); /* V3.3.1 */ if (g < 0) goto degrade; /* global */ /* check if mixing of guards preserves reduction */ for (aa = 0; aa < 2; aa++) { j = srinc_set(T0->tpe[aa]); if (j >= GLOBAL && j != ALPHA_F) if (k) /* non-uniform selection */ { j = srinc_set(T0->tpe[aa]); { k = srunc(T0->tpe[aa], j); { T1->qu[0] = 0; /* turn it off */ printf("pan: warning, line %%d, ", printf("too many stmnt types (%%d)", printf(" in selection\n"); /* mark all options global if >=1 is global */ for (T1 = trans[n][i]; T1; T1 = T1->nxt)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 */ if (!T1 || T1->qu[0]) continue; { printf("warning: line %%d ", srcln[i]); printf("mixed condition "); printf("(defeats reduction)\n"); for (T0 = T1; T0; T0 = T0->nxt) for (aa = 0; aa < 2; aa++) if (T0->tpe[aa] && T0->tpe[aa] != j) printf("[%%d-%%d] mixed %%stion ", (j==5*DELTA)?"condi":"selec"); printf(" '%%s' <-> '%%s'\n", || strncmp(T2->tp, ".(goto)", 7) if (state_tables && !verbose) { char buf[256], *q = buf, *p = procname[n]; case I_PROC: printf("init {\n"); break; case N_CLAIM: printf("claim_%%s {\n", buf); break; case E_TRACE: printf("notrace {\n"); break; case N_TRACE: printf("trace {\n"); break; default: printf("p_%%s {\n", buf); break; printf("size=\"8,10\";\n"); printf(" GT [shape=box,style=dotted,label=\"%%s\"];\n", buf); case I_PROC: printf("init\n"); break; case N_CLAIM: printf("claim %%s\n", procname[n]); break; case E_TRACE: printf("notrace assertion\n"); break; case N_TRACE: printf("trace assertion\n"); break; default: printf("proctype %%s\n", procname[n]); break; tagtable(n, m, is, srcln, reach); { for (T0 = trans[n][i]; T0; T0 = T0->nxt) && strcmp(T0->tp, "(1)") == 0) { printf("error: proctype '%%s' ", printf("line %%d, state %%d: has un", printf("conditional self-loop\n"); { if (strcmp(T0->tp, "else") == 0) { printf("error: proctype '%%s' state", printf(" %%d, inherits %%d", i, nrelse); printf(" 'else' stmnts\n"); do_dfs(n, m, is, srcln, reach, lstate); /* process n, with m states, is=initial state -- reverse list */ if (!state_tables && Btypes[n] != N_CLAIM) { Trans *Tx = (Trans *) 0; /* list of escapes */ Trans *Ty = (Trans *) 0; /* its tail element */ T1 = (Trans *) 0; /* reversed list */ T2 = (Trans *) 0; /* its tail */ T3 = (Trans *) 0; /* remembers possible 'else' */ /* find unless-escapes, they should go first */ T4 = T5 = T0 = trans[n][i]; while (T4 && T4->e_trans) /* escapes are first in orig list */ { T5 = T4; /* remember predecessor */ /* T4 points to first non-escape, T5 to its parent, T0 to original list */ if (T4 != T0) /* there was at least one escape */ { T3 = T5->nxt; /* start of non-escapes */ T5->nxt = (Trans *) 0; /* separate */ Tx = T0; /* start of the escapes */ T0 = T3; /* the rest, to be reversed */ /* T0 points to first non-escape, Tx to the list of escapes, Ty to its tail */ /* first tail-add non-escape transitions, reversed */ { printf("error: cannot happen!\n"); if (strcmp(T5->tp, "else") == 0) /* T3 points to a possible else, which is removed from the list */ /* T1 points to the reversed list so far (without escapes) */ /* T2 points to the tail element -- where the else should go */ if (T2 && T3) { T2->nxt = T3; } /* add else */ /* add in the escapes, to that they appear at the front */ if (Tx && Ty) { Ty->nxt = T1; T1 = Tx; } /* reversed, with escapes first and else last */ { printf("FINAL proctype %%s\n", 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];tagtable(int n, int m, int is, short srcln[], uchar reach[]) || is <= 0 || reach[is] == 0) for (z = trans[n][is]; z; z = z->nxt) tagtable(n, m, z->st, srcln, reach); for (i = 0; i < HAS_UNLESS; i++) { j = trans[n][is]->escp[i]; tagtable(n, m, j, srcln, reach);dfs_table(int n, int m, int is, short srcln[], uchar reach[], uchar lstate[]) if (is >= m || is <= 0 || !trans[n][is]) if ((reach[is] & (4|8|16)) != 0) { if ((reach[is] & (8|16)) == 16) /* on stack, not yet recorded */ reach[is] |= 8; /* recorded */ if (state_tables && verbose) { printf("state %%d line %%d is a loopstate\n", is, srcln[is]); reach[is] |= (4|16); /* visited | onstack */ dfs_table(n, m, z->st, srcln, reach, lstate); dfs_table(n, m, j, srcln, reach, lstate); reach[is] &= ~16; /* no longer on stack */do_dfs(int n, int m, int is, short srcln[], uchar reach[], uchar lstate[]) dfs_table(n, m, is, srcln, reach, lstate);crack(int n, int j, Trans *z, short srcln[]) printf(" state %%3d -(tr %%3d)-> state %%3d ", printf("[id %%3d tp %%3d", z->t_id, z->tpe[0]); if (z->tpe[1]) printf(",%%d", z->tpe[1]); printf(" org %%3d", z->e_trans); printf(" esc %%d", z->escp[i]); printf(" [%%s%%s%%s%%s%%s] %%s:%%d => ", z->atom&6?"A":z->atom&32?"D":"-",/* spin -a m.pml; cc -o pan pan.c; ./pan -D | dot -Tps > foo.ps; ps2pdf foo.ps */dot_crack(int n, int j, Trans *z) printf(" S%%d -> S%%d [color=black", j, z->st); if (z->atom&6) printf(",style=dashed"); else if (z->atom&32) printf(",style=dotted"); else if (z->atom&8) printf(",style=solid"); if (accpstate[n][j]) printf(" S%%d [color=red,style=bold];\n", j); else if (progstate[n][j]) printf(" S%%d [color=green,style=bold];\n", j); if (stopstate[n][j]) printf(" S%%d [color=blue,style=bold,shape=box];\n", j);#define BYTESIZE 32 /* 2^8 : 2^3 = 256:8 = 32 */Vr_Ptr *ranges = (Vr_Ptr *) 0; for (tmp = ranges; tmp; tmp = tmp->nxt) tmp = (Vr_Ptr *) emalloc(sizeof(Vr_Ptr)); tmp->vals[(v)/8] |= 1<<((v)%%8); for (w = i = 0; w < range; w++) printf("\nValues assigned within "); printf("interval [0..255]:\n"); { printf("\t%%s\t: ", tmp->nm); dumpval(tmp->vals, BYTESIZE);#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_store(uchar *); uchar From, To; /* max range 0..255 */ uchar s, S; /* if s=1, S is singleton */ 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 */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); e->From = e->To = e->s = e->S = 0; e = (Edge *) emalloc(sizeof(Edge)); v->Succ = (Edge *) free_vertices; free_vertices = (Vertex *) v->Succ; v = (Vertex *) emalloc(sizeof(Vertex));insert_edge(Vertex *v, Edge *e) { 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; v->from[1] = v->from[0]; v->from[0] = e->From;copyRecursive(Vertex *v, Edge *e) if (e->Nxt) copyRecursive(v, e->Nxt);copyEdges(Vertex *to, Vertex *from) { to->from[i] = from->from[i]; if (from->Succ) copyRecursive(to, from->Succ);cacheDelta(Vertex *v, int h, int first){ static Edge *ov, tmp; int i; return ov; /* intercepts about 10%% */ if (v->dst[i] && h >= v->from[i] && h <= v->to[i]) for (ov = v->Succ; ov; ov = ov->Nxt) if (INRANGE(ov,h)) return ov; Uerror("cannot get here, cacheDelta");Delta(Vertex *v, int h) /* v->delta[h] */ 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]) for (e = v->Succ; e; e = e->Nxt) Uerror("cannot happen Delta"); { cnt = v->dst[i]->num + d*(1 + v->to[i] - v->from[i]); if (d == 1 && cnt < v->dst[i]->num) goto bad; { 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");setDelta(Vertex *v, int h, Vertex *newdst) /* v->delta[h] = newdst; */{ Edge *e, *f = (Edge *) 0, *g; /* remove the old entry, if there */ { v->dst[i] = (Vertex *) 0; v->from[i] = v->to[i] = 0; { g = new_edge(v->dst[i]);/* same dst */ g->To = h-1; /* left half */ v->from[i] = h+1; /* right half */ for (e = v->Succ; e; f = e, e = e->Nxt) { if (e->s == 1 && e->S == h) if (h >= e->From && h <= e->To) { e->From = e->To = e->S; { g = new_edge(e->Dst); /* same dst */ 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 */rem_tst: if (e->From > e->To) /* check if newdst is already there */ { if (h+1 == (int) v->from[i]) if (e->s == 1 && e->S+1 == e->From) if (e->s == 1 && e->S == e->To+1) if ((ulong) v->dst[1] > vk2) for (e = v->Succ; e; e = e->Nxt)mk_key(Vertex *v) /* not sensitive to order */ { m += HASH(v->dst[0], v->to[0] - v->from[0] + 1); { m += HASH(v->dst[1], v->to[1] - v->from[1] + 1); if ((ulong) v->dst[1] > vk2) vk2 = (ulong) v->dst[1]; { m += HASH(e->Dst, e->To - e->From + 1 + e->s); if ((ulong) e->Dst > vk2) vk2 = (ulong) e->Dst; mk_special(int sigma, Vertex *n, Vertex *v) { 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]; { m += HASH(v->dst[i], v->to[i]-v->from[i]+1); if ((ulong) v->dst[i] > vk2) 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); && f->To - f->From + f->s > 0) } 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; { m += HASH(f->Dst, f->To - f->From + 1 + f->s); if ((ulong) n > vk2) vk2 = (ulong) n; 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)static void complement_dfa(void) { Vertex *tmp = F; F = NF; NF = tmp; } for (e = t->Succ; e; e = e->Nxt) for (i = 0; i < dfa_depth+1; i++) cnt += tree_stats(layers[i*TWIDTH+j]); printf("Minimized Automaton: %%6d nodes and %%6g edges\n", for (i = n; i < dfa_depth; i++){ Vertex **p, **q, *s, *y, *old, *new = F; while (*w++ == *u++) /* find first byte that differs */ pfrst = (int) (u - lastword) - 1; memcpy(&lastword[pfrst], &sv[pfrst], dfa_depth-pfrst); 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 */ new = find_it(path[iv], old, word[iv], iv); y->num = 1; /* initial value 1 */ path[j]->num--; /* only 1 moved from j to y */ for (j = iv+1; j < dfa_depth; j++) N.left = N.right = (Vertex *) 0; } else /* it's already there */ { v->lnk = t->lnk; /* put in linked list off v */checkit(Vertex *h, Vertex *v, Vertex *n, uchar sigma) { 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 (g->s == 0 || g->S != i) for (f = h->Succ; f; f = f->Nxt) { if (f->Dst != n) goto no_match; for (i = f->From; i <= f->To; i++) g = cacheDelta(v, i, j); j = 0; if (g->s == 1 && i == g->S) { g = cacheDelta(v, f->S, 1); if (h->Succ || h->dst[0] || h->dst[1]) return 1;find_it(Vertex *v, Vertex *n, uchar sigma, int L) layers[nr] = t = splay(i, t); if (checkit(z, v, n, sigma)) { Vertex *z, *y = (Vertex *) 0; for (z = t; z && z != v; y = z, z = z->lnk) } else if (z->lnk) /* z == t == v */ t->left = t->right = t->lnk = (Vertex *) 0; /* delete the node itself */ t->left = t->right = t->lnk = (Vertex *) 0;bad: Uerror("cannot happen delete");#if defined(MA) && (defined(W_XPT) || defined(R_XPT))static int WCNT = 4096, wcnt=0;extern double nstates, nlinks, truncs, truncs2;xwrite(int fd, char *b, int n) xwrite(fd, (char *) &v, sizeof(Vertex *)); { t[1] = v->from[i], t[2] = v->to[i]; xwrite(fd, (char *) &(v->dst[i]), sizeof(Vertex *)); { t[1] = e->From, t[2] = e->To; xwrite(fd, (char *) &(e->Dst), sizeof(Vertex *)); xwrite(fd, (char *) &(e->Dst), sizeof(Vertex *)); sprintf(nm, "%%s.xpt", PanSource); if ((fd = creat(nm, 0666)) <= 0) printf("cannot creat checkpoint file\n"); 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 *)); { w_layer(fd, layers[i*TWIDTH+j]); c = 2; xwrite(fd, (char *) &c, 1);{ int m = wcnt; int delta = 0; { if (m > 0) memcpy(b, &wbuf[WCNT-m], m); WCNT = wcnt = read(fd, wbuf, 4096); Uerror("xread failed -- insufficient data"); memcpy(&b[delta], &wbuf[WCNT-wcnt], n);{ Edge *e; /* remove the tree and edges from c */ for (e = c->Succ; e; e = e->Nxt) stacker[dfa_depth-1] = 0; r = dfa_store(stacker); stacker[dfa_depth-1] = 4; j = dfa_member(dfa_depth-1); for (i = 0; i < dfa_depth; i++) printf("%%d,", stacker[i]); printf(" -- not a stackstate \n", r, j); { tmp = F; F = NF; NF = tmp; } /* complement */ { tmp = F; F = NF; NF = tmp; } { for (j = e->From; j <= (int) e->To; j++)insert_withkey(Vertex *v, int L){ Vertex *new, *t = temptree[L]; if (!t) { temptree[L] = v; return v; } { if (t != R && t != F && t != NF) Uerror("double insert, bad checkpoint data");find_withkey(Vertex *v, int L) { temptree[L] = t = splay((ulong) v, t); Uerror("not found error, bad checkpoint data"); xread(fd, (char *) &(v->key), sizeof(Vertex *)); { e = new_edge((Vertex *) 0); xread(fd, (char *) &(e->Dst), sizeof(Vertex *)); t->dst[i] = find_withkey(t->dst[i], nr); e->Dst = find_withkey(e->Dst, nr); /* remove only leafs from temptree */ t->left = t->right = t->lnk = (Vertex *) 0; insert_it(t, nr); /* into layers */ t->dst[i]->num += (t->to[i] - t->from[i] + 1); e->Dst->num += (e->To - e->From + 1 + e->s); for (i = 0; i < dfa_depth; i++) for (i = dfa_depth; i >= 0; i--){ int i, yes, no; Edge *e; Vertex *v = (Vertex *) 0; 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] <= 4 && t->to[i] >= 4) { /* was INRANGE(e,0) but From and To are uchar */ if ((e->From == 0) || (e->s==1 && e->S==0)) v = x_tail(t->left, want); if (v) return v; v = x_tail(t->right, want); if (v) return v;x_anytail(Vertex *t, Vertex *c, int nr){ int i; Edge *e, *f; Vertex *v; if ((ulong) t->dst[i] == c->key) { v = new_vertex(); v->key = t->key; x_anytail(temptree[nr-1], v, nr-1); if ((ulong) e->Dst == c->key){ Vertex *c, *v; /* find 0 and !4 predecessor of F */ v = x_tail(temptree[dfa_depth-1], F->key); 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);{ int fd; char nm[64]; Vertex *d; 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; xread(fd, (char *) &R->key, sizeof(Vertex *)); xread(fd, (char *) &F->key, sizeof(Vertex *)); F = insert_withkey(F, dfa_depth); xread(fd, (char *) &NF->key, sizeof(Vertex *)); NF = insert_withkey(NF, dfa_depth); if (wcnt != 0) Uerror("bad count in checkpoint file"); printf("pan: removed %%d stackstates\n", stackcnt); nstates -= (double) stackcnt;jiiiWjjiiijkiNkkkiiiiiiiiiiiiiiikliiiiiiiiiiiiiiiii6miiiiiiiiiiiniiiiqiiiiiiiiiiiino7o`qiiiiiiiiqi(riiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii5rsws~i`|ii$zI{iV{iiiiikk{iiiiiiiiiiiiii{6|iiiiiiii|}stLuiipuiiiiiiiirwiiiiiiy|yiiiiiiyuvMvvvv-wiiiew0Ȯȯ?ӮӮXI  O   [ ! U) 1 C9 A %3d, short src_ln%d [] = { S_F_MAP src_file%d [] = { { "%s", %d, %d }, { "%s", %d, %d } short *src_claim; #define src_event src_ln%d uchar reached%d [] = { run %s(nfull(nempty(?<??[enabled(eval(pc_value() -> annotate{%s}.(goto)goto %s-end-D_STEPATOMICIFDO#define reached_event reached%d putsrc mismatch seqno %d, line %d - %d, file %s QQQQQQ#gQ QQQQQQQQQQQQQQQP!QQQQQQQQQQQQQQQQQ>QQQQQQQQQQQQQQQQQQQQQQQQQQQX~>QQQQQQQQQFQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQcQQQ6!QQQQQ.TqQQQQQQQQ )FcQQQQQQQQ QQ<QQQQQQQQaQQQQQQQQQQQQ M/s>QQQspin: saw j = trpt->ipt; j = ((Q0 *)z)->Qlen; _m = (trpt+1)->o_m; UnBlock; _m = trpt->o_m; [slot].fld if (strt) { if (strt) boq = from+1; if (strt && slot<%d) { for (j--; j>=slot; j--) %s[j+1].fld%d = %s[j].fld%d; } } %s%d = 0; switch (fld) { case %d: %s%d = fldvar; break; delproc(0, now._nr_pr-1)if (_m == 2) _m = unsend(XX = trpt->bup.ovalXX = 1; unrecv, XX-1, , %d); p_restor(II); spin: bad node type %d (.b) for (k = j; k < ((Q%d *)z)->Qlen; k++) %s[k].fld%d = %s[k+1].fld%d; if (_m) (trpt-1)->o_pm |= 1; if (fld == 0) %s0 = fldvar; (.***(.(.***(.(.*(.8+(.***************(.+*****************(.***********(.**** .**************h,,********(.*(.***********************************************************************************************************************************,,8+`+*(.**@+(.(.*(.*****8+8+8+**************(.(.********(.(.(.(.(.**(.********+******(.(.******(.(.(.(.(.(.(.(.***(.unsigned char Is_Recv[%d]; void set_recvs(void) { Is_Recv[%d] = 1; int no_recvs(int me) { int h; uchar ot; short tt; Trans *t; { if (h == me) continue; cannot happen, popbuildcannot find state %d fsm_dfs: cannot happen unreachable code: %s:%3d unexpected: do at start of d_step for (h = BASE; h < (int) now._nr_pr; h++) tt = (short) ((P0 *)pptr(h))->_p; ot = (uchar) ((P0 *)pptr(h))->_t; for (t = trans[ot][tt]; t; t = t->nxt) if (Is_Recv[t->t_id]) return 0; spin: %s:%d, bad node type %d (ana_stmnt) 9j8j8j899j8j8j899j8989j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8(98j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8X9j8j8j8j8j8j8j8j8j8j8j89j8j8j8j89j8j8j8j8j8j8j8j8j8j8j8j898X98j8j8j8j8j8j8j8j89j89j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j899:8j88j8j8999j89j8j8j8j8j8888j88j88j8j8j8j8j8j8888j888j8j8j8j8j8j8j8j899998j8j88:j8j8j8j8j8j8j8j88j8j8j8j8j8j899j8j8j8j8j8j899999999j8j8j89%d:%d:%d:%d step %d: proc %d (state %d) - d %d filename %s too longspin: cannot find trail file CYCLE> <<<<>>>> %3d: claim terminates %3d: proc %d terminates %3d: stop error, proc %d (i=%d) trans %d, %c i=%d pno %d %3d: no process %d (step %d) active processes: pid %d proctype %s %3d: proc %d (?) transition failed #%d max %d (%d - %d + %d) claim %dNever claim moves to line %d [spin: trail ends after %d steps spin: warning, "%s" is newer than %s %3d: proc %d, no matching stmnt %d d_step sequence too longrun operator in d_stepremote reference in d_stepprocess terminationnested d_step sequencenested atomic sequence(boq == -1 /* else */)(1 /* else */)(boq == -1) && goto S_%.3d_0; S_%.3d_0: /* 2 */ goto S_%.3d_0; /* 'break' */ goto S_%.3d_0; /* NEXT */ cannot interpret d_step/* 'goto' */ /* '.' */ goto S_%.3d_0; /* ';' */ goto S_%.3d_%d%s: /* 3 */ Uerror("blocking sel (boq != -1) || if (boq != -1 || (trpt->o_pm&1)) continue;IfNotBlocked sv_save(); reached[%d][t->st] = 1; reached[%d][tt] = 1; S_%.3d_0: /* 1 */ S_%.3d_0: /* break-dest */ S_%.3d_0cannot happen (dstep.c)illegal operator in 'd_step:' 'in d_step (nr.%d, near line %d)"); 'unless' inside d_step - ignoredUerror("block in d_step seq, line %d")goto %s breaks from d_step seqproctype %s redefinedunexpected type - tail_add%s is not a typenamecannot happen cpnn%s.%s[ %d ].%s%s[%d].indexing error '%s'no subfields %sbad subfield type %d bad subfield entry %d cannot locate subfield %sunexpected - no symbolntyp %d unexpected %s, no '.'spin: saw 'incomplete structure ref '%s'cannot retrieve field %d bad structure %sarray of structures in param list, %sillegal reference inside typedeftypename %s was defined beforeno field '%s' defined in structure '%s' struct %s { /* user defined type */ non-zero 'rgt' on non-structurecannot happen, missing proc in astspin: redundant in proctype %s (for given property): spin: error: DEF and USE of same var in rcv stmnt: AST_track, NOT EXPECTED ntyp: %d spin: possibly redundant parameters in: spin: warning: no slice criteria found (no assertions and no claim) proctype %s relevant, due to symbol states=%d (max %d), words = %d, bpw %d, overflow %d spin: redundant vars (for given property): spin: no redundancies found (for given property) spin: consider using predicatespin: proctype %s defines a %s process spin: proctype %s mimics a buffer to reduce complexity, consider merging the code of each source process into the code of its target each sink process into the code of its source to reduce complexity, avoid buffer processes Curtail %s: scratch %d -- %d %d %d %d X[%d:%d:%d] bad scratch: %d inspect pair %d %d subgraph: %d .. %d critical(%d) :%s:L:G: *%3d +%3d #%3d %d -> %d Unless:%d> %s:%d (state %d) DR %s [[ ]] fully relevant %s due to uses(%d): (exact match)(alias match)type = %d unexpected chan def type possible aliases of no valid name RUN ASGN RCV InitzdNamespin: slice criterion type=%d <, == End cannot find proctype %s PВ@Pȑȑؑyyyyyyyyyyyyyyyyyyyyyy0yyyyyyyyyyyyyyyyypyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy`yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy%sPpangen7.cfrom >= 0 && from < nstupto >= 0 && upto < nsts->succ /* self-loop */ :: -> goto _U%d looking for: cannot happen, to_renderelse at line %d [else: !Selfs[n]accept00p && p->b == N_CLAIM#if 0 C%d: ]-> -[ no exit N%d%s_%s_%d: %s_%s%d: _U%d: do od; cannot happen: retrieve_stateexplore: !dstsnever Product { print: 0; unless stmnt in never claim productproduct, 'else' combined with non-conditionatomic or d_step in never claim product /* claim %d pseudo-accept */ claim %d: selfloop not reachable /* ============= U%d ============= */ t_recordmk_acceptingexplore_product*state_bodypop_dstslocate_claimprint_product/* normal */ { } unless { }; /* end unless */ :: c_code c_expr { } -> proctype %s() provided d_step { atomic { syntax errorexpected ')'expected predicateformula:      1  name '%s' in ltl formula too longexpected '%c'unexpected '}'notexpected '<>' or '<->'expected '<->'fK0 end of formulatl_spin: , saw ' tl_spin: %s ---------^ parentheses not balanced U V D Unknown token: spin -f: saw '-%c' -v verbose translation total memory used: %9ld largest stack sze: %9d usage: spin [-v] [-n] -f formula -n normalize tl formula and exit 8 xhtoo many Untils) || ( new: old: nxt: other: Push %s, from S%dwarning: node %s not found T%d_accept_allT0T%d%s_%s /* Normlzd: Done with %s formula-old: [%s] formula-nxt: [%s] compare old to: %s [%s] compare nxt to: %s => different => match New Node %s [] nr %d Is Not New Has Next [ Expand %s, from handle: : assertion failed /* * %d Buchi states H,,,,,H,,dH_0hH ?maxred=%d, count=%d, curnm=%s, nwnm=%s (greencnt=%d,%d, redcnt=%d,%d) * %d states in Streett automaton * %d Streett acceptance conditions accept%sname too long %s%s /* redundant state %s */ BINGO %s: :: () -> goto %s /* T0%s: if :: false fi; replace %s with %s %d: state %s equals state %s T0%sT0_initnever %s { /* conditions <-> nonxtA: nonxtB: combo: /* >>%d,%d<< */ %s bucky match %s accept_init: 0 /* false */; accept_all: skip %s << >> %s === state %s, trans to %s redundant size pool allocs frees %5d %6ld %6ld %6ld releasing a free blocktl_spin: memalloc %ld bytes cannot happen, Canonical!true => false !false => true !!p => p !(p V q) => (!p U !q) !(p U q) => (!p V !q) !X -> X! !(p && q) => !p || !q !(p || q) => !p && !q 0????? @x@?@@@?sameform...cannot happen, sameformcannot happen, anywherecache stores : %9ld cache hits : %9ld HCBB8CBCHChC8CCCC  \Kō  / `h ooo(/ .>N^n~Ήމ.>N^n~Ίފ.>N^n~΋ދoperator: keyword: function-name: f ?XƩ   ,ȫ;JYhw <pª ͪܪ"+ª 4@Vlīګ8dګ7Lfq|ĬϬ"ª;IXb|"  0Գ C 8 zJh C z{|Sdzд  C H  X  0 C  zJ CL z{|d  ̶ _(   |EH |t e  K  ;L\iwzķ {|+ |1 e j ;A  P  {2  KK |c8 oH\ |"   0 C L z{ D {|S д  8  3 |H _( ` G1   ) _(  1 $ P |_   E S k}_(  1 B0 WT | ||L[|Y wKK |||K)||DN|o e| 8 |}|||| |ɝ ,|FQ|e i||X ||t ||/;|' T|t | |q|  | |ɝ ,|| v  |t | |,8H |IUp |f |  y0 `    0 u |p    + |e   X | |  | Dd K |> 8J  7I 6HQ4 d\ nyz{|  | u |,? ( `  V  @ |d t   q P p  V0 | $ Cv u u | v v |T \    |0   d ~ v T x ;A { T|(?U|d} K  =[  <  6d  JO   H JO F|t   K_( Yr  || v D |   v   < '@| O|bq|L    XMX|  8M 8 h f z   %/ z0 ` $/      < l    4  (V3 X QT k   L l6 t   i |#/ 4 h     $ L t  "/   ;[  <4 d Q    L h  "/ H    L h  "/   |_( , M P4 )   J{| 0|T =|  | 4 |  _( \ I_  t A | | &A >|ў YH1 _( $ I_ p g A |  |x& A >|ў YH1 |   _( X| m(  T  |      |W  A X  |M f  v    l     |      H |   | ;[   A   |  D S^ A x |j    |    /  9     M @ d ]   1    q     2   |V  |   @ D ]   1  -4 p  | v   ' {: H {V : l {K   |     K |   / \> > > (? B d?  ? ? ;[  C  @ D@ h@ @ @ K@ 0A ] |   x   K)# |F#  ]"  l" C= d    Xe da P  # {   0 ( ;  K |  4> 4f #   K> H 5> ^> F#    # $ 6s n> |  w 7$ 6 pi g6  p | j 0 G$ X > q > & l Ll l  l o$  l    m O' 0m O' Tm O' tm O' $ $ $ $ % $ "% $ m g' m g'  ?% m n { R% @n {Kd% t% % { !  l  R% lo { > o  ! d >  &   Ll l  l o$  l >   m O' 0m O' Tm O' tm O' $ $ $ $ % $ "% $ 0 g' X g'  G$   q   ' T t {  '     ' L p  |  , _( > t K |  )  ?  ** z B  |^ KP |K@> l> > 0E ^ > _ ,_ 0E ||I_ > <[ Xa  2 O_ ? __ KV |;[ O |_ H? _ p? ||_ |K2 O_ ? __ KV |;[ A ? |_ _q _ ? ||. _ 2 ?  @ _ 4@ `@ @ |_ ;[ lL  ` :[  @ ` |@ 6` R` :A | A S` |f` <[ R _M qM |M HK0A |  \A =[ v` ` A ` A ` ;A ` ` ` _( A =[  B  a a | #a =[ 4a \B B  B u  B 4C KhC |A C C C ||D ɝ LD |4a D Da  D Da D E  S% Wa PE ca E E E {{Kɝ j ` Nj d Khj 8d |Xd |d j j j j j ` d d d $e |Le te j j  ` k e k -k ;k Hk Uk ck mk e wk k j Vk Kk k k -k ;k Hk Uk ck mk k k wk k k j |e f k   l =[ *l Hf Kxf | ;l Pl  |ml l  l l l  l , f f f l _( l l m |  .m =[ Jm gm  }m g Dg lg Km |m g  m Km |m g h g m  m  n ,  v 8h |&n  lh Bn Tn h nn n h n n n  n =[ h i  4i  `i  n i  i  i 0j Tj tj o  o |  $o j  d x Px ex  v sx |KO H _( x   A |x L @ x RX Ot x | t  ģ |lL   x Ot x KZ |\Y |Zt 2 kY Y @ ` Y  Y Y K || 3 x | y  y 0 ,y \    ȥ  g  =y @ Zy |x Ot x K[ |d  lL wy <[ 2  ^T |#\ y \  R R \ Q |y  y y H1 |y  r y y     v 4 Kt | v  |Ч  z )z u  |$ 4z s\ Dz \z <[  qz z z z z z | v z |u z {  { K9{ | F{ c{ X  | v I  x{ |4z  k { ( { ` {  :[  N {T |o     ԙ %/ L  ' j |r  v  :[  N {T | %/  ɝ   v s|  K || ,  P {|  |. M  lL Ԏ    Ϟ X   |||  |4 K  A  |, K@  { v  {|L  v  $ { P {|H1 |= x  T p M| C  |`   8 | h E |  e  K   Ÿ L$ ֟ {  \ N +      T J  {{|! $ P t  1 |  X =  Y 1 + |1 e j  ;A   T {f   KL   {K4 t 8 |       e  | `   |HD p   |S% ' g9   2  8  h +Eb~  {| Р |2 ޠ K |   ( ` |   ( |\     3 G e  8 K`  |Q j   e   {  J8 {K  {H á ҡ {  {|Y kL  {|^  { 9 {K  # I8 zJ9 {| LM { ^ {|( l k | }  |} | | | | ͢ |' 8U  J {|ۢ        / {= KK  [ m {} | e   K |_ ţ |ԣ   ,    Kd  |  |  , A  L    a } J  {ɤ  |$ qX |      lL  |+  . KD ||Zt L ||  | 3 Z q J {|Q_FULL_F q_e_fQ_FULL_T!q_fullQ_EMPT_F q_e_fQ_EMPT_T q_lenQ_FULL_F q_fullQ_FULL_T!q_fullQ_EMPT_F !q_lenQ_EMPT_T q_lenOt I |f y        K  |, C Y 4p l pp |x p |  |,b p  q Dq ||q q q  K   |t    ' r KHr xr ? Y n r ||  |r  |   K  8s  {||s  | ) |}t : s { s (t zP {n | v lt  t {|' ~  J {|  |   t   9  u za W n 0u lu u u v 8v pv v v w (w Tw w w w |G x | W p      ! ! 8! Q! j! ! ! ! ! ! " " 2" . L  v K" |_" p" " 8{ \{ { " | " |" u { |{ " " # | u T| | (# || 9# C L# |[#  v# K} |# #  }  # # |t *\} } } # | $ } } ,~ Kh~ | $ ~ ' '$ ~ |~   @ |p 7$   T$ |g$ $  v $ | 4 v l |v $ $ |  $ K̀  H $  % '% |D% ]% q% % % % % % % &  L t   & +& @& U& f& z& & w H& & t A & &  &  & |' +' 5 E' _' < x' ' ' ' w H_q _( ' ' p    P t  ă ( _( ( $( 2(   4 N( X  H1 |](  _( f( 7( ( H1 |_q _(  (  ( (   ( )  ) . +) H) V) k) ) ) s/ ~/ ) | 0 |  ) _q ) | ) |) ) 1  * ؅ #* B >*  D* ( H x  #/ za i* І Z* |h*  s* * * * *  * + * * + 4+ ?+ O+ g+ 1  * ؅ #* B  * ( + za ` + |  ć  + + +  :[ za ` + |4 h  + + + ~/ , ), 1  * ؅ #* B   *  ؈  $ P D, NU |  Љ Y,  $  r, , , ,  P , ؅ Љ Y,  $  r, , , - - .-  ;- E- `- u- |_q  * 7~   y- *. ؊ - ). { *. ؊ - ). - - 0 T | - .  . ).  ԋ  (. <. Q. f. {.  .   . H . l . . / !/ // @/ Y/ q/ |/ /   /  /  / 0 d / /  č   - T / / 0 x  Ȏ +. q   0 x \ +0  Ȏ  @0 +. U0 | * E* [0 e0 ȏ s0  0  0  0 0 0 0 0 1 1 < h  А  4 T ;A 61  đ  8 p   * O1  a1 < Y<  w< < < < < <   ( < < = = 6= KB B J= H |  KB B [= j= = = ܩ |  = = = = =    > 4 > Z )> ;> L> ]> q>   \ , (  > >   : Ъ   >  ( D > >  ? $? >? L? |   ī Z?  ;  D   L t n?  ? ? ̬ ?   ? D ? A  ( E  ( ?  X   ?    ( A  H ( D @ +@ p  9A C@ V@ s@ :A  @ ܮ  @ @ , X @ @ x @ A A  (A "/ 8A DA 9A WA gA A A  A   8 ` A   A A A  B .B HB 9A ]B )A  %/  {B  ( B ̰ B B B B B   B C &C  8C NC B dC C  C NC B C C C B ~/ C C D X  D %D :D  KD [D @ wD D D D D ` D D E 5E  D  EE D  KD  ]E yE    X  E E  D  EE > A  ( E   P p  :A      , X E  E  ش  ;A 8    l E E E  E E F   ȵ  P     'F ?F  za  | WF ^F tF ( F F F F ` 6+ F G ,G JG   WG gG G   Է G  _( G G G A  G   H )H  _(   Q#2 (R0R=G: M3 4S 4 Y4 \5 dc5 Hi5 o7 u$8 y@8 <8 D8 `@ G RRp , `   .  P R= $R>  > ,`> TX +  T  x=  = X< 4! X' X- h0 <4JK >@ D K dS pYcP[r j܀p̀s\ }p]  ^l ^o p_R ` a @b ؀@c\ cO pRc  D  D@g* ph? #hR)jR6 @ԀDĀJT,MȀSRWT,Z gm vlRY    @ k 0 0H  < l` @     l(  o  q ,  %0-@P5>$M g U_1o jt2M ~28 `5 5T P6 @7 @8 < P: : >   pD   l( 0 `R 7 ؁:  A ܁D  K ЁT Sm \ pS f pT t 0X |   ԁ    l 0m `x `~C   P P | u  D  Єh  @ % `)  7 H? LI o U N b Ј o  w ` `   } d  F h h p P     \ 0 % Д + e 3  B J pQ ? ^ xj H w { `q t T X l (   m p~  S p   ! \  :  E  ^  w <  e    s     r    p ! 0  *  / @V 9  D M  Z  d n r {   p P W , $ 0  @ &    l    (  %0@6D>` HP N0  T H ^0!v h! l# vH{$ & `@@075 p7 A / / / 2(/ ;C0  N! Tp8 ^ e0 m eQ L ,M [  k OfI  pE  W  39   'P`  1'6) ?E`a MW,P[0& dJ t`m zd W NRHG p  W LLJ\Rp V d A @N2 /L3@g <HPB H  RKV _q l s2 ~e  `w B p gK  PRpDn s 0, ,@!r 5 D X_C agy jKq`4 w@  hT 4PP" T   `$3 D  P\KL/BLK2 lOv \0 b́kVRv}Eq iC K P` a R | P: 'i  `H< K$ -`N  7R>LFt P@ Yv0 } f L J    8P8 "  |2  #pe0 -P  :KB` Hp UJ \ȁdH o! ~%    Fe XR`W  0 P ha  2S K,6{ @0 GY0/ a0G jv' pp! |dR K?  2 p ` Rd > $= P *> 8?MD0 Q0g ZX apz: m;q{ {    L Kp  `i6 `I&  D  JR'^R07@S @4 KKSe@ h JnP2; v~e& 3 J(MJ0 @3 p) ,0 Pr 04 JM*{4 /P 9K]  fC/ ple 0J `W @i ` [ FR`  `rX  `| 8K  ! M+0 8fI Cd LRR| Y<ch l@ w`y  *8 `  / KJZ PFl P/S   p  J2 RRLR&P 1`  7B ?q FA OD] Xz _NPj@r`EG yA @  Hk `tC 5 0 j   D= HP~e 2/R  :0 @) ILO` Zi cS k(Mvp~  J  $PPEs to2 @$4 P   &K*p) 4q < A > IQ Iv OTX \  1 " G ( : A S 0 \ w _i  m ZR ` {<  HB     LP 0 > !0 !!d!Pn *! 7!?!| K!W!`+ ]!pm d! l! Rs!v !8 !!DP!EE !t!`R!`B !P9 !3} !h!l! ! !f !@R"@! " ?m " "pO %"7":> C"0PL"pl S"0= `"p"`" }"t "p"px> "qf "t""*H "`7 "*K "K"M"x"p "`nF #9 #- ###@ .#$M8#pN  =# C#@ M#(PS#]#r$ d#0^a l#0  s# Mz#P crtstuff.c__CTOR_LIST____DTOR_LIST____JCR_LIST____do_global_dtors_auxcompleted.7065dtor_idx.7067frame_dummy__CTOR_END____FRAME_END____JCR_END____do_global_ctors_auxy.tab.cltl_nameEmbeddedinEventMaphas_iniyytranslateyyr1yyr2yydefactyydefgotoyypactyypgotoyytableyycheckyystosyydestructltl_to_stringnltl.3609recursivespinlex.cnotdollarnotquotegetinlineInliningReDiRectInline_stubInlinerseqnamesgetwordfollowisalpha_isdigit_do_directivecheck_inlineIArg_contc_addedc_trackedbuf.3991set_cur_scopelexin_commentNamesLTL_symshold.5155last.5154IArgnoIArg_nst.5157Buf2.4642Buf1.4641c_code.4643sym.cxxputtypesamenamerunstmntssetonexusetallxusymtablast_namevars.cgetglobaldummy.3283maxcolnrdummy.3393main.cOperatorKeywordFunctionpreprocessonlyout1seedySeedUsedcnt.4418warn_nn.4493dataflowltl_claimsadd_ltlfd_ltlPreProcPreCntPreArgltl_fileinlineonlynvr_fileps_msc.cDTMHpfdRMProcLinepspnoCSWTCH.130CSWTCH.131CSWTCH.132TotStepsIScalermaxxldepthLPsPremesg.cqhchannmsr_talkq_remn_remflow.chas_chanrefwalk_atomicbreakstackbreak_idattach_escapecur_sRjumpslocalnew_eladd_elcolonsinnermostsched.caddsymbolsetlocalssilent_movesoneparamPriority_Sumlastnever.4277nbuf.4278pickprocis_blockedrun.cSeedE_CheckEscape_Checkpangen1.cSvMapAddq0Addq1R5Addq11Addq2Addq3Addq4R12Addq5R8bProtoreverse_namesreverse_typesLstSetnBitsdo_initdoglobalTypesdolocallnacceptorsCode1progressorsCode3R2Code2aCode2cCode2dR4R3R0aCode0R0Addp0Addp1R6R8aput_ptypeHead0HeaderHeader0Head1pangen2.chiddenT_musNnidenticalnr_bupmark_seqseq_has_eldo_countopcountruncountvalTpeTpeEPTcnt_seqT_sumTPEfproccheck_neededmulti_neededtmmulti_undoBailoutDDBBdolenreverse_procs_isokwithprocnamedoforwardDetYZmaxYZYZcntCnTXZpatch_atomict_cycscan_seqAllGlobalglob_argsadvancedobackwarddidcaselastfirstput_seqput_subuniqput_escpcasingmodifierCfilePre0PreambleTailDfaXptpangen3.cskipsymbolicputnrcolfrstlastfnmlastdeflastfromdid_claim.2847comworkpangen4.ccheck_procpangen5.crel_transtrans_freerel_statefsm_freemkstatemax_st_idget_transeligiblebuild_stepbsbfana_stmntana_varFSM_EDGEana_seqFSM_DFScur_st_idguided.clost_trailfdlastclaimdstep.cDestedTjTojumpJtJumptoLastGotoillegalfilterbadCollectGuardsputCodeSpecialbno.3018structs.cPnamesUnamesputUnameT.72do_sameretrievepc_zpp.cpangen6.cAST_alwaysAST_blockableAST_RoundAST_spreadmark_subgraphsee_elseis_guardastdom_perculateon.5385ndom.5384dom_forwardAST_withchanAST_scoutruncurtailbad_scratchAST_checkpairsFSM_criticalT.134AST_add_aliaschalcurAST_run_aliasAST_haschanAST_setcurchaliasname_def_usecur_tdef_useAST_add_explicitexplicitAST_fp1T.135AST_dfsname_AST_trackin_recvslicerAST_indirectAST_Changesdef_relevantrpnAST_shouldconsiderrel_varsexpl_parexpl_varchanlistno_state.5470pangen7.cfind_stateclaim_has_acceptprint_state_nmpush_dstswrap_textall_successorst_record__PRETTY_FUNCTION__.4609state_body__PRETTY_FUNCTION__.3760__PRETTY_FUNCTION__.3818get_seq__PRETTY_FUNCTION__.3991print_rawrender_statesplslcnt__PRETTY_FUNCTION__.3893__PRETTY_FUNCTION__.4178__PRETTY_FUNCTION__.4200reprosrc.cindenttl_parse.ctl_levelprectl_factortl_formulatl_lex.cis_predicatetl_followtl_main.ccnthasuformuformtl_trans.cflattenhas_clauselivenessRed_cntNodes_SetLab_cntsdumpdumpbufdump_graphpush_stackNodes_StackStack_szngbuf.2163findgraphMappedmkbuchiBasetl_buchi.cneverhitsallfindstatePrunenonxtsametransshowtransDfsrev_transtcntprintstatemergestatestl_mem.ceventfreelistreqtl_rewrt.ccanmarknodeaddcantl_cache.cstoredCachesCacheHitsismatch_GLOBAL_OFFSET_TABLE___init_array_end__init_array_start_DYNAMICnclaimsdata_startc_vardump_condwrapupdeadvarcheck_param_countSym_typold_scope_rulessprintf@@GLIBC_2.0ownerc_add_globinittl_outputarrowputpostludeqtabtl_yycharisutypeno_side_effectstransgenaddqueuespit_recvsget_labputlegendltabrunnablervoptspitboxnewstatesrdyretarget__libc_csu_finidotagin_boundmk_skiphas_enableddupnodefix_dest_startmake_atomicis_acceptSelfsstate_cntNidhas_providedrepro_proccutoffglob_inlinebb_or_ddshow_labccacheinitialization_okIstsetpnamenrRdytyp2cc_add_defPidsetptypepreconditionchnameDstepStartExpand_Okinterprintcount_runsprep_inlinec_stack_size__fprintf_chk@@GLIBC_2.3.4tail_addsymvarhas_pcvalue__xstat@@GLIBC_2.0rem_varAll_Memnewbasenamecheck_sequenceany_undo__gmon_start___Jv_RegisterClassesany_runsputpages_fp_hwtfreesel_indexOkBreakclaimprocpid_is_claimnprocunclutter__printf_chk@@GLIBC_2.3.4only_nxtdisambiguateverbosegenunioisequalstrchr@@GLIBC_2.0Elcnt_finimatrixsystem@@GLIBC_2.0strncpy@@GLIBC_2.0lastholdR13walk2_structFatalTestOnlyhas_randomm_lossany_andsimplify_nametbfgets@@GLIBC_2.0Xhuntelelike_javamemset@@GLIBC_2.0qsendhas_statetrackvargenaddprocc_wrappercomplete_rendezyyoutgetnodeMadeChoiceannouncegenheaderhas_ioholdingscan_treetwocases__libc_start_main@@GLIBC_2.0getsymqrecv_IO_getc@@GLIBC_2.0remotevarnot_printingloose_endscross_dstepschanaccessclose_seqnstoptl_Getchartl_peekcnt_mparsmk_explicit__assert_fail@@GLIBC_2.0startpagemulti_claimsfsm_tblf_pidsync_productcachedIsGuardfind_maxelproper_enablerc_splurgeAST_sliceone_lfthas_xumatch_struct__strcat_chk@@GLIBC_2.3.4unrem_Seqlinenoungetc@@GLIBC_2.0repro_seqgetunamepickup_inlineaddtranscolumns_IO_stdin_usedjumpstepsini_transntimesstrtol@@GLIBC_2.0symdumpall_lftsqhiderm_selfrefsmstfree@@GLIBC_2.0Mparss_trailo_maxemallocplunk_reverseStack_mxfirstrowputsrcplunk_c_fctsu_asyncc_add_stackscanf@@GLIBC_2.0ana_srcno_printnon_fataltl_lookuppush_negationyytextNacc__data_starttl_yylexsetxusstruct_nameBuffull_namehas_stackfflush@@GLIBC_2.0start_claimc_add_locpreprocessmulti_ovalrepro_subschedputstmnttl_nn__ctype_b_loc@@GLIBC_2.3fseek@@GLIBC_2.0rem_labdo_unlesshas_lasthas_codeyycharsetmtypetl_emallocNextLabfclose@@GLIBC_2.1nnMtyperel_useTstOnlyDone_casec_stateall_namesexport_astsdXu_Listfor_indextl_verboseR14fsm_printno_wrapupsplit_declc_structStrictEtimeoutshuntstartcontextNststderr@@GLIBC_2.0qlenrepro_srcmemcpy@@GLIBC_2.0strlen@@GLIBC_2.0eval_subnot_claimfopen@@GLIBC_2.1putboxadd_seqprune_optssetunameunlink@@GLIBC_2.0for_bodyfind_inlineterselookuptl_parsecheckindexpushbreakqmakeFnameoptimizationseventmapnrTotalunfolding__dso_handleisproctypeEnabled0NparsenableNtimeoutsCnt_fldsdumplabelsc_previewstrcpy@@GLIBC_2.0tl_UnGetcharundostmntprintm__DTOR_END__bsn__libc_csu_initanywheretrapwonlyset_labtrackchanuseprintf@@GLIBC_2.0gensrchas_nphas_badelsevalid_nameSrandis_skipexpandjump_etcpc_valuetyp_ckSkip_claimproducthookupplunk_exprseqlistprerusein_cachewalk_structbreak_destLeveltl_explainsetutypetl_mainfor_setuplimited_visdoindentoFname__strcpy_chk@@GLIBC_2.3.4labtabno_nested_array_refsexplainreadyisalnum_xspinhas_globalvalidrefputskipclaim_namefprintf@@GLIBC_2.0strstr@@GLIBC_2.0time@@GLIBC_2.0no_internalsremotelabis_inlineevalrunany_term__bss_startmalloc@@GLIBC_2.0dump_structdumpglobalsAST_trackyyerrorpnochecktypeputnameyyinalldoneTvalstepnumber__stack_chk_fail@@GLIBC_2.4dumpclaimsc_trackUniqueplunk_c_declshastrackR15setaccesssputtypepslineMax_Redhashqishiddeneventmapgenothernocastfputc@@GLIBC_2.0ltl_modeunskipini_cachehas_sortedreachedini_rewrtdststl_balancedopen_seqstdin@@GLIBC_2.0GenCodegetlocalany_operrem_Seqntrail__sysv_signal@@GLIBC_2.0IArgsright_linkedsqsametreesdumpsrcputgridismtypetcttgetvaltargetc_add_svRval_structRvousmatch_trailthsetvaluse_freestrcat@@GLIBC_2.0tl_terseprehintno_arraysput_uform_endstdout@@GLIBC_2.0checkruncommentyywrapCanonicalAST_storecheckvarq_is_synccolboxnqsany_lordoqcanonicalreleasenodeAl_Elanalyzeinteractivenr_errsNamesNotAddedtrackrunusagesscanf@@GLIBC_2.0yylvalfscanf@@GLIBC_2.0realread__sprintf_chk@@GLIBC_2.3.4has_typputunameshas_unlessnotabsqfullstrncmp@@GLIBC_2.0cache_statswhorunsqlen_type_IO_putc@@GLIBC_2.0c_add_locinitHave_claimcast_valmergerin_forseparateini_structc_add_hiddenyynerrsLval_structscope_levelyylexp_talkfindlocu_syncnochan_manipyyparsetl_errsdepthltl_list_edataevalindexsameformputremotea_statstrailfilenameCaccessclaimnrdumpWidth_sethas_hiddenc_splurge_anyfatalsetlocalRandstrcmp@@GLIBC_2.0do_locinitsLastSteppstextgencodetableexit@@GLIBC_2.0plunk_inlinefind_labhas_remotesr_mesgdelbasenamedumptabCurScopedumplocalDoDump__i686.get_pc_thunk.bxfsmnsthas_remvarhas_labputpreluderev_escapegensvmaptl_clutterc_chandumptl_yylvalmain_initini_buchiLastXscope_seqsr_bufputcodedo_varrendertl_yyerror