diff --git a/cat/c11-partialsc.cat b/cat/c11-partialsc.cat new file mode 100644 index 0000000000..2fad1a1f91 --- /dev/null +++ b/cat/c11-partialsc.cat @@ -0,0 +1,109 @@ +C "C++11" + +(* +* Overhauling SC atomics in C11 and OpenCL. +* M. Batty, A. Donaldson, J. Wickerson. In Proc. +* 43rd ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (POPL), 2016. +*) + +(* +* This model is based on: +* https://multicore.doc.ic.ac.uk/overhauling/c11_base.cat +* https://multicore.doc.ic.ac.uk/overhauling/c11_partialSC.cat +*) + +include "basic.cat" +include "c11_cos.cat" +include "c11_los.cat" + +let asw = IW * (M \ IW) +let sb = po +let mo = co & (~NAL * ~NAL) + +let cacq = ACQ | (SC & (R | F)) | ACQ_REL | (F & CON) +let crel = REL | (SC & (W | F)) | ACQ_REL +let ccon = R & CON + +// To be compatible with reads from uninit memory, we use our default definition of fr +//let fr = rf^-1 ; mo + +let dd = (data | addr)+ + +let fsb = [F] ; sb +let sbf = sb ; [F] + +(* release_acquire_fenced_synchronizes_with, hypothetical_release_sequence_set, release_sequence_set *) + +(* OLD: let rs = [crel] ; fsb? ; [A & W] ; (((mo ; [rmw]) | coi) & ~(coe ; [!rmw] ; mo))? *) +let rs_prime = int | (_ * (R & W)) +let rs = mo & rs_prime \ ((mo \ rs_prime) ; mo) + +(* OLD: let swra = ext & (rs ; rf ; [A] ; sbf? ; [cacq]) *) +let swra = ext & ([crel] ; fsb? ; [A & W] ; rs? ; rf ; [R & A] ; sbf? ; [cacq]) + +//let swul = ext & ([UL] ; lo ; [LK]) +let pp_asw = asw \ (asw ; sb) +//let sw = pp_asw | swul | swra +let sw = pp_asw | swra + +(* with_consume_cad_set, dependency_ordered_before *) +let cad = ((rf & sb) | dd)+ +let dob = (ext & ([W & crel] ; fsb? ; [A & W] ; rs?; rf; [ccon])); cad? + +(* happens_before, inter_thread_happens_before, consistent_hb *) +let ithbr = sw | dob | (sw ; sb) +let ithb = (ithbr | (sb ; ithbr))+ +let hb = sb | ithb +acyclic hb as Hb + +(* coherent_memory_use *) +let hbl = hb & loc + +irreflexive ((rf^-1)? ; mo ; rf? ; hb) as Coh + +(* visible_side_effect_set *) +let vis = ([W] ; hbl ; [R]) & ~(hbl; [W]; hbl) + +(* consistent_atomic_rf *) +irreflexive (rf ; hb) as Rf + +(* consistent_non_atomic_rf *) +empty ((rf ; [NAL]) \ vis) as NaRf + +(* Consistency of RMWs *) +empty rmw & (fre; coe) as atomic +// The original model was tested with Herd, which treats RMW as a single atomic operation. +// We have modified the model to handle RMW as a sequence of atomic operations. +// irreflexive (rf | (mo ; mo ; rf^-1) | (mo ; rf)) as Rmw + + +(* locks_only_consistent_lo *) +// irreflexive (lo ; hb) as Lo1 + +(* locks_only_consistent_locks *) +// irreflexive ([LS] ; lo^-1 ; [LS] ; ~(lo ; [UL] ; lo)) as Lo2 + +(* data_races *) +let cnf = ((W * _) | (_ * W)) & loc +let dr = ext & (cnf \ hb \ (hb^-1) \ (A * A)) + +(* unsequenced_races *) +let ur = int & ((W * M) | (M * W)) & loc & ~id & ~(sb+) & ~((sb+)^-1) + +(* locks_only_good_mutex_use, locks_only_bad_mutexes *) +// let bl = ([LS]; (sb & lo); [LK]) & ~(lo; [UL]; lo) +// let losbwoul = (sb & lo & ~(lo; [UL]; lo)) +// let lu = [UL] & ~([UL] ; losbwoul^-1 ; [LS] ; losbwoul ; [UL]) + +(* Partial SC axioms *) +let r1 = hb +let r2 = fsb? ; mo ; sbf? +let r3 = rf^-1; [SC] ; mo +let r4 = rf^-1 ; hbl ; [W] +let r5 = fsb ; fr +let r6 = fr ; sbf +let r7 = fsb ; fr ; sbf + +let scp = r1|r2|r3|r4|r5|r6|r7 + +acyclic (((SC * SC) & scp) \ id) as Spartial \ No newline at end of file diff --git a/cat/c11.cat b/cat/c11.cat index 31c032c097..e951b27575 100644 --- a/cat/c11.cat +++ b/cat/c11.cat @@ -1,17 +1,15 @@ C "C++11" -(* All c11_*.cat files are C11 models -Overhauling SC atomics in C11 and OpenCL. -M. Batty, A. Donaldson, J. Wickerson. In Proc. -43rd ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (POPL), 2016. - -Rewritten by Luc Maranget for herd7 - +(* +* Overhauling SC atomics in C11 and OpenCL. +* M. Batty, A. Donaldson, J. Wickerson. In Proc. +* 43rd ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (POPL), 2016. *) (* - This is an adapted version of C11 that supports an execution model where explicit init events - may be missing. As a consequence, reads may have no rf-edge if they read from initial memory. +* This model is based on: +* https://multicore.doc.ic.ac.uk/overhauling/c11_base.cat +* https://multicore.doc.ic.ac.uk/overhauling/c11_simp.cat *) include "basic.cat" @@ -20,7 +18,7 @@ include "c11_los.cat" let asw = IW * (M \ IW) let sb = po -let mo = co +let mo = co & (~NAL * ~NAL) let cacq = ACQ | (SC & (R | F)) | ACQ_REL | (F & CON) let crel = REL | (SC & (W | F)) | ACQ_REL @@ -31,42 +29,28 @@ let ccon = R & CON let dd = (data | addr)+ -let fsb = sb & (F * _) -let sbf = sb & (_ * F) +let fsb = [F] ; sb +let sbf = sb ; [F] -(* release_acquire_fenced_synchronizes_with, - hypothetical_release_sequence_set, - release_sequence_set *) - -(* OLD: let rs = [crel] ; fsb? ; [A & W] ; - (((mo ; [rmw]) | coi) & ~(coe ; [!rmw] ; mo))? *) +(* release_acquire_fenced_synchronizes_with, hypothetical_release_sequence_set, release_sequence_set *) +(* OLD: let rs = [crel] ; fsb? ; [A & W] ; (((mo ; [rmw]) | coi) & ~(coe ; [!rmw] ; mo))? *) let rs_prime = int | (_ * (R & W)) let rs = mo & rs_prime \ ((mo \ rs_prime) ; mo) -(* OLD: let swra = ext (rs ; rf ; [A] ; sbf? ; [cacq]) *) -let swra = - ext & - ([crel] ; fsb? ; [A & W] ; rs? ; rf ; - [R & A] ; sbf? ; [cacq]) +(* OLD: let swra = ext & (rs ; rf ; [A] ; sbf? ; [cacq]) *) +let swra = ext & ([crel] ; fsb? ; [A & W] ; rs? ; rf ; [R & A] ; sbf? ; [cacq]) //let swul = ext & ([UL] ; lo ; [LK]) let pp_asw = asw \ (asw ; sb) //let sw = pp_asw | swul | swra let sw = pp_asw | swra -(* with_consume_cad_set, - dependency_ordered_before *) +(* with_consume_cad_set, dependency_ordered_before *) let cad = ((rf & sb) | dd)+ -let dob = - (ext & - ([W & crel] ; fsb? ; [A & W] ; - rs?; rf; [ccon])); - cad? - -(* happens_before, - inter_thread_happens_before, - consistent_hb *) +let dob = (ext & ([W & crel] ; fsb? ; [A & W] ; rs?; rf; [ccon])); cad? + +(* happens_before, inter_thread_happens_before, consistent_hb *) let ithbr = sw | dob | (sw ; sb) let ithb = (ithbr | (sb ; ithbr))+ let hb = sb | ithb @@ -75,63 +59,44 @@ acyclic hb as Hb (* coherent_memory_use *) let hbl = hb & loc -// irreflexive ((rf^-1)? ; mo ; rf? ; hb) as Coh // To support reads from uninitialized memory -irreflexive ((fr | mo) ; rf? ; hb) as Coh +irreflexive ((fr | mo); rf?; hb) as Coh (* visible_side_effect_set *) -let vis = (hbl & (W * R)) \ (hbl; [W] ; hbl) +let vis = ([W] ; hbl ; [R]) & ~(hbl; [W]; hbl) (* consistent_atomic_rf *) irreflexive (rf ; hb) as Rf (* consistent_non_atomic_rf *) -empty ((rf ; [R\A]) \ vis) as NaRf -// NOTE FW is a dynamic tag which we don't yet support -//empty [FW\A];hbl;[W] as NaRf (* implicit read of Na final writes.. *) - -irreflexive (rf | (mo ; mo ; rf^-1) | (mo ; rf)) as Rmw +empty ((rf ; [NAL]) \ vis) as NaRf +(* Consistency of RMWs *) +empty rmw & (fre; coe) as atomic +// The original model was tested with Herd, which treats RMW as a single atomic operation. +// We have modified the model to handle RMW as a sequence of atomic operations. +// irreflexive (rf | (mo ; mo ; rf^-1) | (mo ; rf)) as Rmw (* locks_only_consistent_lo *) -//irreflexive (lo ; hb) as Lo1 +// irreflexive (lo ; hb) as Lo1 (* locks_only_consistent_locks *) -//irreflexive ([LS] ; lo^-1 ; [LS] ; ~(lo ; [UL] ; lo)) as Lo2 - +// irreflexive ([LS] ; lo^-1 ; [LS] ; ~(lo ; [UL] ; lo)) as Lo2 (* data_races *) -//let Mutex = UL|LS -//let cnf = (((W * _) | (_ * W)) & loc) \ ((Mutex * _) | (_ * Mutex)) -//let dr = ext & (cnf \ hb \ (hb^-1) \ (A * A)) +let cnf = ((W * _) | (_ * W)) & loc +let dr = ext & (cnf \ hb \ (hb^-1) \ (A * A)) (* unsequenced_races *) -//let ur = int & ((W * M) | (M * W)) & loc & ~id & ~(sb+) & ~((sb+)^-1) - -(* locks_only_good_mutex_use, locks_only_bad_mutexes *) - -//let bl = ([LS]; (sb & lo); [LK]) & ~(lo; [UL]; lo) - -//let losbwoul = (sb & lo & ~(lo; [UL]; lo)) - -//let lu = [UL] & ~([UL] ; losbwoul^-1 ; [LS] ; losbwoul ; [UL]) - -let r1 = hb -let r2 = fsb? ; mo ; sbf? -let r3 = rf^-1; [SC] ; mo -let r4 = rf^-1 ; hbl ; [W] -let r5 = fsb ; fr -let r6 = fr ; sbf -let r7 = fsb ; fr ; sbf - -let scp = r1|r2|r3|r4|r5|r6|r7 - -acyclic (((SC * SC) & scp) \ id) as Spartial - -//undefined_unless empty dr as Dr -//undefined_unless empty ur as unsequencedRace -//undefined_unless empty bl as badLock -//undefined_unless empty lu as badUnlock - -// Atomicity -empty rmw & (fre; coe) as atomic +let ur = int & ((W * M) | (M * W)) & loc & ~id & ~(sb+) & ~((sb+)^-1) + +(* locks_only_good_mutex_use, locks_only_bad_mutexes *) +// let bl = ([ls]; (sb & lo); [lk]) & ~(lo; [ul]; lo) +// let losbwoul = (sb & lo & ~(lo; [UL]; lo)) +// let lu = [UL] & ~([UL] ; losbwoul^-1 ; [LS] ; losbwoul ; [UL]) + +(* Simplified SC axioms *) +// This SC semantics is proposed in the paper "Overhauling SC atomics in C11 and OpenCL" section 3.2 +// The proposal simplifies the Spartial and provide stronger guarantees +let scp = ((SC * SC) & (fsb?; (mo | fr | hb); sbf?)) \ id +acyclic scp as Ssimp \ No newline at end of file diff --git a/cat/opencl-herd.cat b/cat/opencl-herd.cat new file mode 100644 index 0000000000..69b4dd6e1d --- /dev/null +++ b/cat/opencl-herd.cat @@ -0,0 +1,153 @@ +OpenCL +(* OpenCL Memory Model *) + +(* +* This model is based on: +* https://github.com/herd/herdtools7/blob/master/herd-www/cat_includes/opencl_base.cat +* https://github.com/herd/herdtools7/blob/master/herd-www/cat_includes/opencl.cat +*) + +// Base relations: +// int: same work-item +// swg: same work-group +// sdv: same device +// syncbar: same barrier id + +// Tags: +// WI: work-item scope +// WG: work-group scope +// DV: device scope +// ALL: all-svm-devices scope +// GLOBAL: global memory +// LOCAL: local memory +// EF: entry fence of barrier +// XF: exit fence of barrier + +include "basic.cat" + +let symm(r) = r | r^-1 +let wi = int + +(* Inclusive scopes *) +let incl = (wi & (WI * WI)) | + (swg & (WG * WG)) | + (sdv & (DV * DV)) | + (ALL * ALL) + +(*******************) +(* Synchronisation *) +(*******************) + +let Acq = (ACQ | SC | ACQ_REL) & (R | F | RMW) +let Rel = (REL | SC | ACQ_REL) & (W | F | RMW) + +(* Release sequence *) +let rs = (_ * RMW) | wi +let max_co = co? & rs & ~((co & ~rs) ; co) + +(* Including release-acquire fences *) +let relf = [Rel]; ([F]; po)?; [A & W] +let acqf = [A & R]; (po; [F])?; [Acq] + +(* Release-acquire synchronisation *) +let ra_sw(r) = incl & ~wi & ([r]; relf; max_co; [r]; rf; acqf; [r]) + +(* Barrier synchronisation *) +// in OpenCL a barrier results in two fence operations: entry and exit fences: +// https://registry.khronos.org/OpenCL/specs/3.0-unified/html/OpenCL_API.html#_work_group_functions +let bar_sw(r) = (EF * XF) & syncbar & ~wi & swg & (r * r) + +(* Synchronisation on a region *) +let region_sw(r) = ra_sw(r) | bar_sw(r) + +(* Allowed to synchronise on the other region *) +let scf = (SC * SC) | ((GLOBAL & LOCAL & F) * (GLOBAL & LOCAL & F)) + +(* Global and local synchronises-with *) +let gsw = region_sw(GLOBAL) | (scf & region_sw(LOCAL)) +let lsw = region_sw(LOCAL) | (scf & region_sw(GLOBAL)) + +(******************) +(* Happens-before *) +(******************) + +(* Global and local happens-before *) +let ghb = (((GLOBAL * GLOBAL) & (po | (IW * ~IW))) | gsw)+ +let lhb = (((LOCAL * LOCAL) & (po | (IW * ~IW))) | lsw)+ + +acyclic ghb as global_hb_acyclic +acyclic lhb as local_hb_acyclic + +(* Per-location happens-before *) +let ghbl = ghb & loc +let lhbl = lhb & loc + +(*************) +(* Coherence *) +(*************) + +let coh_hb_g = (rf^-1)?; co; rf?; ghb +let coh_hb_l = (rf^-1)?; co; rf?; lhb +irreflexive coh_hb_g as global_coherence +irreflexive coh_hb_l as local_coherence + +(************************) +(* Consistency of reads *) +(************************) + +(* Visible side effects *) +let vse(hbl) = (W * R) & hbl & ~(hbl; [W]; hbl) +let gvse = [GLOBAL]; vse(ghbl) +let lvse = [LOCAL]; vse(lhbl) + +(* A non-atomic load can only read from a store that is visible. *) +irreflexive rf; [NAL & GLOBAL]; ~(gvse^-1) as global_nonatomic_rf_consistent +irreflexive rf; [NAL & LOCAL]; ~(lvse^-1) as local_nonatomic_rf_consistent + +(* An atomic load can only read from a store that already happened. *) +irreflexive (ghb | lhb); rf; [A] as atomic_rf_consistent + +(* Consistency of RMWs *) +irreflexive rf | (fr;co) | (co;rf) as rmw_consistent + +// Atomicity +empty rmw & (fre; coe) as atomic + +(**************************) +(* Sequential consistency *) +(**************************) + +let sc1 = rf^-1; [SC]; co +let sc2 = [F]; po; co; po; [F] +let sc3 = [F]; po; fr; po; [F] +let sc4 = fr; po; [F] +let sc5 = [F]; po; fr + +let scp = (SC * SC) & (ghb | lhb | co | sc1 | sc2 | sc3 | sc4 | sc5) + +let sc6 = rf^-1; (ghb | lhb); [W] + +let unv = _ * _ +let ifexists(s) = unv; [s]; unv + +(* BEGIN PARTIAL SC STUFF *) +let scp_prime = scp & sc6 +acyclic scp_prime & ifexists(SC & ~ALL) as s_exists +(* END PARTIAL SC STUFF *) + +(***************) +(* Races *) +(***************) + +let conflict = (((W * _) | (_ * W)) \ ((IW * _) | (_ * IW))) & loc + +let gl_hb = ghb | lhb +let dr = conflict & ~symm(ghb | lhb) & ~incl +flag ~empty dr as data_race + +let ur = (wi & conflict & ~symm(po)) \ id +flag ~empty ur as unsequenced_race + +let bsw = bar_sw(GLOBAL) | bar_sw(LOCAL) +let bd = [EF] & ((~wi & swg); unv) \ (bsw ; unv) +flag ~empty bd as barrier_divergence \ No newline at end of file diff --git a/cat/opencl.cat b/cat/opencl.cat new file mode 100644 index 0000000000..c48f3f0a13 --- /dev/null +++ b/cat/opencl.cat @@ -0,0 +1,124 @@ +OpenCL +(* OpenCL Memory Model *) +include "basic.cat" + +(* +* This model is based on: +* https://multicore.doc.ic.ac.uk/overhauling/opencl_base.cat +* https://multicore.doc.ic.ac.uk/overhauling/opencl_scopedsc.cat +*) + +// Base relations: +// int: same work-item +// swg: same work-group +// sdv: same device +// syncbar: same barrier id + +// Tags: +// WI: work-item scope +// WG: work-group scope +// DV: device scope +// ALL: all-svm-devices scope +// GLOBAL: global memory +// LOCAL: local memory +// EF: entry fence of barrier +// XF: exit fence of barrier + +let mo = co & ((~NAL) * (~NAL)) +let sb = po +let rb = (rf^-1; mo) \ id +let unv = _ * _ +let wi = int + +(* Inclusive scopes *) +let incl = (swg & (WG * WG)) | (sdv & (DV * DV)) | (ALL * ALL) + +(*******************) +(* Synchronisation *) +(*******************) + +let Acq = (ACQ | SC | ACQ_REL) & (R | F) +let Rel = (REL | SC | ACQ_REL) & (W | F) + +(* Fences sequenced before or after *) +let Fsb = [F]; sb +let sbF = sb; [F] + +(* Release sequence *) +let rs_prime = wi | (unv; [R & W]) +let rs = mo & rs_prime & ~((mo & ~rs_prime) ; mo) + +(* Release-acquire synchronisation *) +let ra_sw(r) = ([r & Rel]; Fsb?; [W \ WI]; rs?; [r]; rf; [R \ WI]; sbF?; [Acq & r]) & incl & ~wi + +(* Barrier synchronisation *) +// in OpenCL a barrier results in two fence operations: entry and exit fences: +// https://registry.khronos.org/OpenCL/specs/3.0-unified/html/OpenCL_API.html#_work_group_functions +let bar_sw(r) = (EF * XF) & syncbar & ~wi & swg & (r * r) + +(* Allowed to synchronise on the other region *) +let scf = (SC * SC) | ((GLOBAL & LOCAL & F) * (GLOBAL & LOCAL & F)) + +(* Global and local synchronises-with *) +let gsw = ra_sw(GLOBAL) | bar_sw(GLOBAL) | (scf & ra_sw(LOCAL)) +let lsw = ra_sw(LOCAL) | bar_sw(LOCAL) | (scf & ra_sw(GLOBAL)) + +(******************) +(* Happens-before *) +(******************) + +(* Global and local happens-before *) +let ghb = (((GLOBAL * GLOBAL) & (sb | (IW * ~IW))) | gsw)+ +let lhb = (((LOCAL * LOCAL) & (sb | (IW * ~IW))) | lsw)+ +irreflexive ghb as O-HbG +irreflexive lhb as O-HbL + +(*************) +(* Coherence *) +(*************) + +let coh(hb) = (rf^-1)?; mo; rf?; hb +irreflexive coh(ghb) as O-CohG +irreflexive coh(lhb) as O-CohL + +(************************) +(* Consistency of reads *) +(************************) + +(* A load can only read from a store that already happened. *) +irreflexive rf; (ghb | lhb) as O-Rf + +(* Visible side effects *) +let vis(hb) = (W * R) & hb & loc & ~((hb & loc); [W]; hb) + +(* A non-atomic load can only read from a store that is visible. *) +empty (rf; [NAL & GLOBAL])\vis(ghb) as O-NaRfG +empty (rf; [NAL & LOCAL])\vis(lhb) as O-NaRfL + +(* Consistency of RMWs *) +empty rmw & (fre; coe) as atomic +// The original model was tested with Herd, which treats RMW as a single atomic operation. +// We have modified the model to handle RMW as a sequence of atomic operations. +// irreflexive rf | (mo;mo;rf^-1) | (mo;rf) as O-Rmw + +(****************************************) +(* Sequential consistency, simplified, *) +(* with scoped SC axioms *) +(****************************************) + +let scp = Fsb?; (rb | mo | (ghb | lhb)); sbF? +acyclic (SC*SC) & scp & incl as O-Sscoped + +(***************) +(* Races *) +(***************) + +let cnf = ((W * W) | (W * R) | (R * W)) & loc + +let dr = cnf & ~(ghb | lhb) & ~(ghb | lhb)^-1 & ~wi & ~incl +flag ~empty dr as data_race + +(* Barrier divergence *) +let bsw = bar_sw(GLOBAL) | bar_sw(LOCAL) +let bd = [EF] & ((~wi & swg); unv) \ (bsw ; unv) +flag ~empty bd as barrier_divergence \ No newline at end of file diff --git a/dartagnan/src/main/antlr4/C11Lexer.g4 b/dartagnan/src/main/antlr4/C11Lexer.g4 index b825e063ef..9286970606 100644 --- a/dartagnan/src/main/antlr4/C11Lexer.g4 +++ b/dartagnan/src/main/antlr4/C11Lexer.g4 @@ -1,13 +1,23 @@ lexer grammar C11Lexer; -C11AtomicLoad : 'atomic_load_explicit'; -C11AtomicStore : 'atomic_store_explicit'; +C11AtomicLoadExplicit : 'atomic_load_explicit'; +C11AtomicLoad : 'atomic_load'; +C11AtomicStoreExplicit : 'atomic_store_explicit'; +C11AtomicStore : 'atomic_store'; +C11AtomicXchgExplicit : 'atomic_exchange_explicit_explicit'; C11AtomicXchg : 'atomic_exchange_explicit'; -C11AtomicSCAS : 'atomic_compare_exchange_strong_explicit'; -C11AtomicWCAS : 'atomic_compare_exchange_weak_explicit'; +C11AtomicSCASExplicit : 'atomic_compare_exchange_strong_explicit'; +C11AtomicSCAS : 'atomic_compare_exchange_strong'; +C11AtomicWCASExplicit : 'atomic_compare_exchange_weak_explicit'; +C11AtomicWCAS : 'atomic_compare_exchange_weak'; C11AtomicFence : 'atomic_thread_fence'; -C11AtomicAdd : 'atomic_fetch_add_explicit'; -C11AtomicSub : 'atomic_fetch_sub_explicit'; -C11AtomicOr : 'atomic_fetch_or_explicit'; -C11AtomicXor : 'atomic_fetch_xor_explicit'; -C11AtomicAnd : 'atomic_fetch_and_explicit'; +C11AtomicAddExplicit : 'atomic_fetch_add_explicit'; +C11AtomicAdd : 'atomic_fetch_add'; +C11AtomicSubExplicit : 'atomic_fetch_sub_explicit'; +C11AtomicSub : 'atomic_fetch_sub'; +C11AtomicOrExplicit : 'atomic_fetch_or_explicit'; +C11AtomicOr : 'atomic_fetch_or'; +C11AtomicXorExplicit : 'atomic_fetch_xor_explicit'; +C11AtomicXor : 'atomic_fetch_xor'; +C11AtomicAndExplicit : 'atomic_fetch_and_explicit'; +C11AtomicAnd : 'atomic_fetch_and'; diff --git a/dartagnan/src/main/antlr4/LitmusC.g4 b/dartagnan/src/main/antlr4/LitmusC.g4 index 644c7abcca..22ff4b962e 100644 --- a/dartagnan/src/main/antlr4/LitmusC.g4 +++ b/dartagnan/src/main/antlr4/LitmusC.g4 @@ -1,6 +1,6 @@ grammar LitmusC; -import LinuxLexer, C11Lexer, LitmusAssertions; +import LinuxLexer, C11Lexer, OpenCLLexer, LitmusAssertions; @header{ import com.dat3m.dartagnan.expression.integers.*; @@ -18,10 +18,10 @@ variableDeclaratorList globalDeclarator : typeSpecifier? LBracket? varName RBracket? (Equals initConstantValue)? # globalDeclaratorLocation - | typeSpecifier? t = threadId Colon n = varName (Equals initConstantValue)? # globalDeclaratorRegister - | typeSpecifier? varName (Equals Ast? (Amp? varName | LPar Amp? varName RPar))? # globalDeclaratorLocationLocation - | typeSpecifier? t = threadId Colon n = varName (Equals Ast? (Amp? varName | LPar Amp? varName RPar))? # globalDeclaratorRegisterLocation - | typeSpecifier? varName LBracket DigitSequence? RBracket (Equals initArray)? # globalDeclaratorArray + | typeSpecifier? t = threadId Colon n = varName (Equals initConstantValue)? # globalDeclaratorRegister + | typeSpecifier? varName (Equals Ast? (Amp? varName | LPar Amp? varName RPar))? # globalDeclaratorLocationLocation + | typeSpecifier? t = threadId Colon n = varName (Equals Ast? (Amp? varName | LPar Amp? varName RPar))? # globalDeclaratorRegisterLocation + | typeSpecifier? varName LBracket DigitSequence? RBracket (Equals initArray)? # globalDeclaratorArray ; program @@ -29,11 +29,19 @@ program ; thread - : threadId LPar threadArguments? RPar LBrace expression* RBrace + : threadId (At threadScope)? LPar threadArguments? RPar LBrace expression* RBrace + ; + +threadScope + : OpenCLWG scopeID Comma OpenCLDEV scopeID # OpenCLThreadScope ; threadArguments - : pointerTypeSpecifier varName (Comma pointerTypeSpecifier varName)* + : threadArgument (Comma threadArgument)* + ; + +threadArgument + : pointerTypeSpecifier varName ; expression @@ -73,13 +81,18 @@ re locals [IntBinaryOp op, String mo] | AtomicDecReturn LPar address = re RPar {$op = IntBinaryOp.SUB; $mo = Linux.MO_MB;} | AtomicDecReturnRelaxed LPar address = re RPar {$op = IntBinaryOp.SUB; $mo = Linux.MO_RELAXED;} | AtomicDecReturnAcquire LPar address = re RPar {$op = IntBinaryOp.SUB; $mo = Linux.MO_ACQUIRE;} - | AtomicDecReturnRelease LPar address = re RPar {$op = IntBinaryOp.SUB; $mo = Linux.MO_RELEASE;}) # reAtomicOpReturn + | AtomicDecReturnRelease LPar address = re RPar {$op = IntBinaryOp.SUB; $mo = Linux.MO_RELEASE;}) # reAtomicOpReturn - | ( C11AtomicAdd LPar address = re Comma value = re Comma c11Mo RPar {$op = IntBinaryOp.ADD;} - | C11AtomicSub LPar address = re Comma value = re Comma c11Mo RPar {$op = IntBinaryOp.SUB;} - | C11AtomicOr LPar address = re Comma value = re Comma c11Mo RPar {$op = IntBinaryOp.OR;} - | C11AtomicXor LPar address = re Comma value = re Comma c11Mo RPar {$op = IntBinaryOp.XOR;} - | C11AtomicAnd LPar address = re Comma value = re Comma c11Mo RPar {$op = IntBinaryOp.AND;}) # C11AtomicOp + | ( C11AtomicAddExplicit LPar address = re Comma value = re Comma c11Mo (Comma openCLScope)? RPar {$op = IntBinaryOp.ADD;} + | C11AtomicAdd LPar address = re Comma value = re RPar {$op = IntBinaryOp.ADD;} + | C11AtomicSubExplicit LPar address = re Comma value = re Comma c11Mo (Comma openCLScope)? RPar {$op = IntBinaryOp.SUB;} + | C11AtomicSub LPar address = re Comma value = re RPar {$op = IntBinaryOp.SUB;} + | C11AtomicOrExplicit LPar address = re Comma value = re Comma c11Mo (Comma openCLScope)? RPar {$op = IntBinaryOp.OR;} + | C11AtomicOr LPar address = re Comma value = re RPar {$op = IntBinaryOp.OR;} + | C11AtomicXorExplicit LPar address = re Comma value = re Comma c11Mo (Comma openCLScope)? RPar {$op = IntBinaryOp.XOR;} + | C11AtomicXor LPar address = re Comma value = re RPar {$op = IntBinaryOp.XOR;} + | C11AtomicAndExplicit LPar address = re Comma value = re Comma c11Mo (Comma openCLScope)? RPar {$op = IntBinaryOp.AND;} + | C11AtomicAnd LPar address = re Comma value = re RPar {$op = IntBinaryOp.AND;}) # C11AtomicOp | ( AtomicFetchAdd LPar value = re Comma address = re RPar {$op = IntBinaryOp.ADD; $mo = Linux.MO_MB;} | AtomicFetchAddRelaxed LPar value = re Comma address = re RPar {$op = IntBinaryOp.ADD; $mo = Linux.MO_RELAXED;} @@ -96,71 +109,75 @@ re locals [IntBinaryOp op, String mo] | AtomicFetchDec LPar address = re RPar {$op = IntBinaryOp.SUB; $mo = Linux.MO_MB;} | AtomicFetchDecRelaxed LPar address = re RPar {$op = IntBinaryOp.SUB; $mo = Linux.MO_RELAXED;} | AtomicFetchDecAcquire LPar address = re RPar {$op = IntBinaryOp.SUB; $mo = Linux.MO_ACQUIRE;} - | AtomicFetchDecRelease LPar address = re RPar {$op = IntBinaryOp.SUB; $mo = Linux.MO_RELEASE;}) # reAtomicFetchOp + | AtomicFetchDecRelease LPar address = re RPar {$op = IntBinaryOp.SUB; $mo = Linux.MO_RELEASE;}) # reAtomicFetchOp | ( AtomicXchg LPar address = re Comma value = re RPar {$mo = Linux.MO_MB;} | AtomicXchgRelaxed LPar address = re Comma value = re RPar {$mo = Linux.MO_RELAXED;} | AtomicXchgAcquire LPar address = re Comma value = re RPar {$mo = Linux.MO_ACQUIRE;} - | AtomicXchgRelease LPar address = re Comma value = re RPar {$mo = Linux.MO_RELEASE;}) # reXchg + | AtomicXchgRelease LPar address = re Comma value = re RPar {$mo = Linux.MO_RELEASE;}) # reXchg | ( Xchg LPar address = re Comma value = re RPar {$mo = Linux.MO_MB;} | XchgRelaxed LPar address = re Comma value = re RPar {$mo = Linux.MO_RELAXED;} | XchgAcquire LPar address = re Comma value = re RPar {$mo = Linux.MO_ACQUIRE;} - | XchgRelease LPar address = re Comma value = re RPar {$mo = Linux.MO_RELEASE;}) # reXchg + | XchgRelease LPar address = re Comma value = re RPar {$mo = Linux.MO_RELEASE;}) # reXchg - | C11AtomicXchg LPar address = re Comma value = re Comma c11Mo RPar # reC11AtomicXchg + | C11AtomicXchg LPar address = re Comma value = re Comma c11Mo RPar # reC11AtomicXchg + | C11AtomicXchgExplicit LPar address = re Comma value = re Comma c11Mo (Comma openCLScope)? RPar # reC11AtomicXchgExplicit | ( AtomicCmpXchg LPar address = re Comma cmp = re Comma value = re RPar {$mo = Linux.MO_MB;} | AtomicCmpXchgRelaxed LPar address = re Comma cmp = re Comma value = re RPar {$mo = Linux.MO_RELAXED;} | AtomicCmpXchgAcquire LPar address = re Comma cmp = re Comma value = re RPar {$mo = Linux.MO_ACQUIRE;} - | AtomicCmpXchgRelease LPar address = re Comma cmp = re Comma value = re RPar {$mo = Linux.MO_RELEASE;}) # reCmpXchg + | AtomicCmpXchgRelease LPar address = re Comma cmp = re Comma value = re RPar {$mo = Linux.MO_RELEASE;}) # reCmpXchg - | C11AtomicSCAS LPar address = re Comma expectedAdd = re Comma value = re Comma c11Mo Comma c11Mo RPar # reC11SCmpXchg - | C11AtomicWCAS LPar address = re Comma expectedAdd = re Comma value = re Comma c11Mo Comma c11Mo RPar # reC11WCmpXchg + | C11AtomicSCASExplicit LPar address = re Comma expectedAdd = re Comma value = re Comma c11Mo Comma c11Mo (Comma openCLScope)? RPar # reC11SCmpXchgExplicit + | C11AtomicSCAS LPar address = re Comma expectedAdd = re Comma value = re RPar # reC11SCmpXchg + | C11AtomicWCASExplicit LPar address = re Comma expectedAdd = re Comma value = re Comma c11Mo Comma c11Mo (Comma openCLScope)? RPar # reC11WCmpXchgExplicit + | C11AtomicWCAS LPar address = re Comma expectedAdd = re Comma value = re RPar # reC11WCmpXchg | ( CmpXchg LPar address = re Comma cmp = re Comma value = re RPar {$mo = Linux.MO_MB;} | CmpXchgRelaxed LPar address = re Comma cmp = re Comma value = re RPar {$mo = Linux.MO_RELAXED;} | CmpXchgAcquire LPar address = re Comma cmp = re Comma value = re RPar {$mo = Linux.MO_ACQUIRE;} - | CmpXchgRelease LPar address = re Comma cmp = re Comma value = re RPar {$mo = Linux.MO_RELEASE;}) # reCmpXchg + | CmpXchgRelease LPar address = re Comma cmp = re Comma value = re RPar {$mo = Linux.MO_RELEASE;}) # reCmpXchg | ( AtomicSubAndTest LPar value = re Comma address = re RPar {$op = IntBinaryOp.SUB; $mo = Linux.MO_MB;} | AtomicIncAndTest LPar address = re RPar {$op = IntBinaryOp.ADD; $mo = Linux.MO_MB;} - | AtomicDecAndTest LPar address = re RPar {$op = IntBinaryOp.SUB; $mo = Linux.MO_MB;}) # reAtomicOpAndTest + | AtomicDecAndTest LPar address = re RPar {$op = IntBinaryOp.SUB; $mo = Linux.MO_MB;}) # reAtomicOpAndTest - | AtomicAddUnless LPar address = re Comma value = re Comma cmp = re RPar # reAtomicAddUnless + | AtomicAddUnless LPar address = re Comma value = re Comma cmp = re RPar # reAtomicAddUnless - | C11AtomicLoad LPar address = re Comma c11Mo RPar # reC11Load + | C11AtomicLoadExplicit LPar address = re Comma c11Mo (Comma openCLScope)? RPar # reC11LoadExplicit + | C11AtomicLoad LPar address = re RPar # reC11Load | ( AtomicReadAcquire LPar address = re RPar {$mo = Linux.MO_ACQUIRE;} | AtomicRead LPar address = re RPar {$mo = Linux.MO_ONCE;} | RcuDereference LPar Ast? address = re RPar {$mo = Linux.MO_ONCE;} | SrcuReadLock LPar address = re RPar {$mo = Linux.SRCU_LOCK;} | SrcuDownRead LPar address = re RPar {$mo = Linux.SRCU_LOCK;} - | SmpLoadAcquire LPar address = re RPar {$mo = Linux.MO_ACQUIRE;}) # reLoad + | SmpLoadAcquire LPar address = re RPar {$mo = Linux.MO_ACQUIRE;}) # reLoad - | ReadOnce LPar Ast address = re RPar {$mo = Linux.MO_ONCE;} # reReadOnce - | Ast address = re {$mo = "NA";} # reReadNa + | ReadOnce LPar Ast address = re RPar {$mo = Linux.MO_ONCE;} # reReadOnce + | Ast address = re {$mo = "NA";} # reReadNa -// | SpinTrylock LPar address = re RPar # reSpinTryLock -// | SpiIsLocked LPar address = re RPar # reSpinIsLocked +// | SpinTrylock LPar address = re RPar # reSpinTryLock +// | SpiIsLocked LPar address = re RPar # reSpinIsLocked - | boolConst # reBoolConst - | Excl re # reOpBoolNot - | re opBool re # reOpBool - | re opCompare re # reOpCompare - | re opArith re # reOpArith + | boolConst # reBoolConst + | Excl re # reOpBoolNot + | re opBool re # reOpBool + | re opCompare re # reOpCompare + | re opArith re # reOpArith - | LPar re RPar # reParenthesis - | cast re # reCast - | varName # reVarName - | constant # reConst + | LPar re RPar # reParenthesis + | cast re # reCast + | varName # reVarName + | constant # reConst ; nre locals [IntBinaryOp op, String mo, String name] : ( AtomicAdd LPar value = re Comma address = re RPar {$op = IntBinaryOp.ADD;} | AtomicSub LPar value = re Comma address = re RPar {$op = IntBinaryOp.SUB;} | AtomicInc LPar address = re RPar {$op = IntBinaryOp.ADD;} - | AtomicDec LPar address = re RPar {$op = IntBinaryOp.SUB;}) # nreAtomicOp + | AtomicDec LPar address = re RPar {$op = IntBinaryOp.SUB;}) # nreAtomicOp | ( AtomicSet LPar address = re Comma value = re RPar {$mo = Linux.MO_ONCE;} | AtomicSetRelease LPar address = re Comma value = re RPar {$mo = Linux.MO_RELEASE;} @@ -168,20 +185,21 @@ nre locals [IntBinaryOp op, String mo, String name] | SmpStoreMb LPar address = re Comma value = re RPar {$mo = Linux.MO_MB;} | SrcuReadUnlock LPar address = re Comma value = re RPar {$mo = Linux.SRCU_UNLOCK;} | SrcuUpRead LPar address = re Comma value = re RPar {$mo = Linux.SRCU_UNLOCK;} - | RcuAssignPointer LPar Ast? address = re Comma value = re RPar {$mo = Linux.MO_RELEASE;}) # nreStore + | RcuAssignPointer LPar Ast? address = re Comma value = re RPar {$mo = Linux.MO_RELEASE;}) # nreStore - | WriteOnce LPar Ast address = re Comma value = re RPar {$mo = Linux.MO_ONCE;} # nreWriteOnce + | WriteOnce LPar Ast address = re Comma value = re RPar {$mo = Linux.MO_ONCE;} # nreWriteOnce - | C11AtomicStore LPar address = re Comma value = re Comma c11Mo RPar # nreC11Store + | C11AtomicStoreExplicit LPar address = re Comma value = re Comma c11Mo (Comma openCLScope)? RPar # nreC11StoreExplicit + | C11AtomicStore LPar address = re Comma value = re RPar # nreC11Store - | Ast? varName Equals re # nreAssignment - | typeSpecifier varName (Equals re)? # nreRegDeclaration + | Ast? varName Equals re # nreAssignment + | typeSpecifier varName (Equals re)? # nreRegDeclaration - | SpinLock LPar address = re RPar # nreSpinLock - | SpinUnlock LPar address = re RPar # nreSpinUnlock -// | SpinUnlockWait LPar address = re RPar # nreSpinUnlockWait + | SpinLock LPar address = re RPar # nreSpinLock + | SpinUnlock LPar address = re RPar # nreSpinUnlock +// | SpinUnlockWait LPar address = re RPar # nreSpinUnlockWait - | SrcuSync LPar address = re RPar # nreSrcuSync + | SrcuSync LPar address = re RPar # nreSrcuSync | ( FenceSmpMb LPar RPar {$name = Linux.MO_MB;} | FenceSmpWMb LPar RPar {$name = Linux.MO_WMB;} @@ -193,9 +211,13 @@ nre locals [IntBinaryOp op, String mo, String name] | FenceSmpMbAfterSrcuReadUnlock LPar RPar {$name = Linux.AFTER_SRCU_READ_UNLOCK;} | RcuReadLock LPar RPar {$name = Linux.RCU_LOCK;} | RcuReadUnlock LPar RPar {$name = Linux.RCU_UNLOCK;} - | (RcuSync | RcuSyncExpedited) LPar RPar {$name = Linux.RCU_SYNC;}) # nreFence + | (RcuSync | RcuSyncExpedited) LPar RPar {$name = Linux.RCU_SYNC;}) # nreFence + + | C11AtomicFence LPar c11Mo RPar # nreC11Fence - | C11AtomicFence LPar c11Mo RPar # nreC11Fence + | OpenCLAtomicFenceWI LPar openCLFenceFlags Comma c11Mo Comma openCLScope RPar # nreOpenCLFence + + | barrierId Colon OpenCLBarrier LPar openCLFenceFlags (Comma openCLScope)? RPar # nreOpenCLBarrier ; @@ -239,6 +261,28 @@ c11Mo returns [String mo] | MoSeqCst {$mo = C11.MO_SC;} ; +openCLSpace returns [String space] + : OpenCLGlobalSpace {$space = OpenCL.GLOBAL_SPACE;} + | OpenCLLocalSpace {$space = OpenCL.LOCAL_SPACE;} + ; + +openCLScope returns [String scope] + : OpenCLMemoryScopeWI {$scope = OpenCL.WORK_ITEM;} + | OpenCLMemoryScopeWG {$scope = OpenCL.WORK_GROUP;} + | OpenCLMemoryScopeDEV {$scope = OpenCL.DEVICE;} + | OpenCLMemoryScopeALL {$scope = OpenCL.ALL;} + ; + +openCLFenceFlags + : openCLFenceFlag Bar openCLFenceFlag + | openCLFenceFlag + ; + +openCLFenceFlag returns [String flag] + : OpenCLFenceFlagGL {$flag = OpenCL.GLOBAL_SPACE;} + | OpenCLFenceFlagLC {$flag = OpenCL.LOCAL_SPACE;} + ; + threadVariable returns [int tid, String name] : t = threadId Colon n = varName {$tid = $t.id; $name = $n.text;} ; @@ -262,8 +306,8 @@ cast ; pointerTypeSpecifier - : (Volatile)? basicTypeSpecifier Ast - | (Volatile)? atomicTypeSpecifier Ast + : (Volatile)? openCLSpace? basicTypeSpecifier Ast + | (Volatile)? openCLSpace? atomicTypeSpecifier Ast ; typeSpecifier @@ -292,11 +336,23 @@ varName : Underscore* Identifier (Underscore (Identifier | DigitSequence)*)* ; +scopeID returns [int id] + : t = DigitSequence {$id = Integer.parseInt($t.text);} + ; + // Allowed outside of thread body (otherwise might conflict with pointer cast) comment : LPar Ast .*? Ast RPar ; +barrierId returns [int id] + : t = BarrierIdentifier {$id = Integer.parseInt($t.text.replace("B", ""));} + ; + +BarrierIdentifier + : 'B' DigitSequence + ; + MoRelaxed : 'memory_order_relaxed' ; @@ -387,6 +443,7 @@ BarBar LitmusLanguage : 'C' + | 'OPENCL' ; AssertionNot diff --git a/dartagnan/src/main/antlr4/OpenCLLexer.g4 b/dartagnan/src/main/antlr4/OpenCLLexer.g4 new file mode 100644 index 0000000000..af0707d9a0 --- /dev/null +++ b/dartagnan/src/main/antlr4/OpenCLLexer.g4 @@ -0,0 +1,18 @@ +lexer grammar OpenCLLexer; + +OpenCLGlobalSpace : 'global'; +OpenCLLocalSpace : 'local'; + +OpenCLWG : 'wg'; +OpenCLDEV : 'dev'; + +OpenCLAtomicFenceWI : 'atomic_work_item_fence'; +OpenCLBarrier : 'barrier'; + +OpenCLMemoryScopeWI : 'memory_scope_work_item'; +OpenCLMemoryScopeWG : 'memory_scope_work_group'; +OpenCLMemoryScopeDEV : 'memory_scope_device'; +OpenCLMemoryScopeALL : 'memory_scope_all_svm_devices'; + +OpenCLFenceFlagGL : 'CLK_GLOBAL_MEM_FENCE'; +OpenCLFenceFlagLC : 'CLK_LOCAL_MEM_FENCE'; diff --git a/dartagnan/src/main/java/com/dat3m/dartagnan/configuration/Arch.java b/dartagnan/src/main/java/com/dat3m/dartagnan/configuration/Arch.java index d62603b1a1..871129f4ef 100644 --- a/dartagnan/src/main/java/com/dat3m/dartagnan/configuration/Arch.java +++ b/dartagnan/src/main/java/com/dat3m/dartagnan/configuration/Arch.java @@ -3,7 +3,7 @@ import java.util.Arrays; public enum Arch implements OptionInterface { - C11, ARM8, POWER, PTX, TSO, IMM, LKMM, RISCV, VULKAN; + C11, ARM8, POWER, PTX, TSO, IMM, LKMM, RISCV, VULKAN, OPENCL; // Used to display in UI @Override @@ -27,6 +27,8 @@ public String toString() { return "RISCV"; case VULKAN: return "VULKAN"; + case OPENCL: + return "OpenCL"; } throw new UnsupportedOperationException("Unrecognized architecture " + this); } @@ -37,7 +39,7 @@ public static Arch getDefault() { // Used to decide the order shown by the selector in the UI public static Arch[] orderedValues() { - Arch[] order = { C11, ARM8, IMM, LKMM, POWER, PTX, RISCV, TSO, VULKAN }; + Arch[] order = { C11, ARM8, IMM, LKMM, OPENCL, POWER, PTX, RISCV, TSO, VULKAN }; // Be sure no element is missing assert(Arrays.asList(order).containsAll(Arrays.asList(values()))); return order; diff --git a/dartagnan/src/main/java/com/dat3m/dartagnan/parsers/program/ProgramParser.java b/dartagnan/src/main/java/com/dat3m/dartagnan/parsers/program/ProgramParser.java index 43cec38698..942e8dab88 100644 --- a/dartagnan/src/main/java/com/dat3m/dartagnan/parsers/program/ProgramParser.java +++ b/dartagnan/src/main/java/com/dat3m/dartagnan/parsers/program/ProgramParser.java @@ -19,6 +19,7 @@ public class ProgramParser { private static final String TYPE_LITMUS_PTX = "PTX"; private static final String TYPE_LITMUS_VULKAN = "VULKAN"; private static final String TYPE_LITMUS_C = "C"; + private static final String TYPE_LITMUS_OPENCL = "OPENCL"; public Program parse(File file) throws Exception { if (needsClang(file)) { @@ -88,7 +89,7 @@ private ParserInterface getConcreteParser(File file) throws IOException { private ParserInterface getConcreteLitmusParser(String programText) { if (programText.indexOf(TYPE_LITMUS_AARCH64) == 0) { return new ParserLitmusAArch64(); - } else if (programText.indexOf(TYPE_LITMUS_C) == 0) { + } else if (programText.indexOf(TYPE_LITMUS_C) == 0 || programText.indexOf(TYPE_LITMUS_OPENCL) == 0) { return new ParserLitmusC(); } else if (programText.indexOf(TYPE_LITMUS_PPC) == 0) { return new ParserLitmusPPC(); diff --git a/dartagnan/src/main/java/com/dat3m/dartagnan/parsers/program/utils/ProgramBuilder.java b/dartagnan/src/main/java/com/dat3m/dartagnan/parsers/program/utils/ProgramBuilder.java index b0bff0d508..a0cf8dd9ca 100644 --- a/dartagnan/src/main/java/com/dat3m/dartagnan/parsers/program/utils/ProgramBuilder.java +++ b/dartagnan/src/main/java/com/dat3m/dartagnan/parsers/program/utils/ProgramBuilder.java @@ -44,6 +44,7 @@ public class ProgramBuilder { private final Map id2FunctionsMap = new HashMap<>(); private final Map> fid2LabelsMap = new HashMap<>(); private final Map locations = new HashMap<>(); + private final Map reg2LocMap = new HashMap<>(); private final Program program; @@ -274,29 +275,33 @@ public Label getEndOfThreadLabel(int tid) { } // ---------------------------------------------------------------------------------------------------------------- - // PTX + // GPU + public void setOrCreateScopedThread(Arch arch, String name, int id, int ...scopeIds) { + ScopeHierarchy scopeHierarchy = switch (arch) { + case PTX -> ScopeHierarchy.ScopeHierarchyForPTX(scopeIds[0], scopeIds[1]); + case VULKAN -> ScopeHierarchy.ScopeHierarchyForVulkan(scopeIds[0], scopeIds[1], scopeIds[2]); + case OPENCL -> ScopeHierarchy.ScopeHierarchyForOpenCL(scopeIds[0], scopeIds[1]); + default -> throw new UnsupportedOperationException("Unsupported architecture: " + arch); + }; - public void newScopedThread(Arch arch, String name, int id, int ...scopeIds) { if(id2FunctionsMap.containsKey(id)) { - throw new MalformedProgramException("Function or thread with id " + id + " already exists."); + Thread thread = (Thread) id2FunctionsMap.get(id); + thread.setScopeHierarchy(scopeHierarchy); + } else { + // Litmus threads run unconditionally (have no creator) and have no parameters/return types. + ThreadStart threadEntry = EventFactory.newThreadStart(null); + Thread scopedThread = new Thread(name, DEFAULT_THREAD_TYPE, List.of(), id, threadEntry, scopeHierarchy, new HashSet<>()); + id2FunctionsMap.put(id, scopedThread); + program.addThread(scopedThread); } - // Litmus threads run unconditionally (have no creator) and have no parameters/return types. - ThreadStart threadEntry = EventFactory.newThreadStart(null); - Thread scopedThread = switch (arch) { - case PTX -> new Thread(name, DEFAULT_THREAD_TYPE, List.of(), id, threadEntry, - ScopeHierarchy.ScopeHierarchyForPTX(scopeIds[0], scopeIds[1]), new HashSet<>()); - case VULKAN -> new Thread(name, DEFAULT_THREAD_TYPE, List.of(), id, threadEntry, - ScopeHierarchy.ScopeHierarchyForVulkan(scopeIds[0], scopeIds[1], scopeIds[2]), new HashSet<>()); - default -> throw new UnsupportedOperationException("Unsupported architecture: " + arch); - }; - id2FunctionsMap.put(id, scopedThread); - program.addThread(scopedThread); } - public void newScopedThread(Arch arch, int id, int ...ids) { - newScopedThread(arch, String.valueOf(id), id, ids); + public void setOrCreateScopedThread(Arch arch, int id, int ...ids) { + setOrCreateScopedThread(arch, String.valueOf(id), id, ids); } + // ---------------------------------------------------------------------------------------------------------------- + // PTX public void initVirLocEqCon(String leftName, IntLiteral iValue){ MemoryObject object = locations.computeIfAbsent( leftName, k->program.getMemory().allocateVirtual(ARCH_SIZE, true, null)); @@ -346,4 +351,14 @@ public void addSwwPairThreads(int threadId0, int threadId1) { thread0.getSyncSet().add(thread1); } } + + // ---------------------------------------------------------------------------------------------------------------- + // OpenCL + public void setReg2LocMap(Register reg, MemoryObject loc) { + reg2LocMap.put(reg, loc); + } + + public MemoryObject getLocFromReg(Register reg) { + return reg2LocMap.get(reg); + } } diff --git a/dartagnan/src/main/java/com/dat3m/dartagnan/parsers/program/visitors/VisitorLitmusC.java b/dartagnan/src/main/java/com/dat3m/dartagnan/parsers/program/visitors/VisitorLitmusC.java index 7f73d7e15f..4318db650c 100644 --- a/dartagnan/src/main/java/com/dat3m/dartagnan/parsers/program/visitors/VisitorLitmusC.java +++ b/dartagnan/src/main/java/com/dat3m/dartagnan/parsers/program/visitors/VisitorLitmusC.java @@ -1,5 +1,6 @@ package com.dat3m.dartagnan.parsers.program.visitors; +import com.dat3m.dartagnan.configuration.Arch; import com.dat3m.dartagnan.exception.ParsingException; import com.dat3m.dartagnan.expression.Expression; import com.dat3m.dartagnan.expression.ExpressionFactory; @@ -14,9 +15,8 @@ import com.dat3m.dartagnan.program.event.Event; import com.dat3m.dartagnan.program.event.EventFactory; import com.dat3m.dartagnan.program.event.Tag; -import com.dat3m.dartagnan.program.event.core.CondJump; -import com.dat3m.dartagnan.program.event.core.IfAsJump; -import com.dat3m.dartagnan.program.event.core.Label; +import com.dat3m.dartagnan.program.event.core.*; +import com.dat3m.dartagnan.program.event.lang.catomic.*; import com.dat3m.dartagnan.program.memory.MemoryObject; import java.util.ArrayList; @@ -35,6 +35,7 @@ public class VisitorLitmusC extends LitmusCBaseVisitor { private int ifId = 0; private int whileId = 0; private Register returnRegister; + private boolean isOpenCL = false; public VisitorLitmusC(){ } @@ -46,6 +47,9 @@ public VisitorLitmusC(){ public Program visitMain(LitmusCParser.MainContext ctx) { //FIXME: We should visit thread declarations before variable declarations // because variable declaration refer to threads. + if (ctx.LitmusLanguage().getText().equals("OPENCL")) { + isOpenCL = true; + } visitVariableDeclaratorList(ctx.variableDeclaratorList()); visitProgram(ctx.program()); VisitorLitmusAssertions.parseAssertions(programBuilder, ctx.assertionList(), ctx.assertionFilter()); @@ -155,7 +159,11 @@ public Object visitGlobalDeclaratorArray(LitmusCParser.GlobalDeclaratorArrayCont public Object visitThread(LitmusCParser.ThreadContext ctx) { scope = currentThread = ctx.threadId().id; // Declarations in the preamble may have created the thread already - programBuilder.getOrNewThread(currentThread); + if (isOpenCL && ctx.threadScope() != null) { + ctx.threadScope().accept(this); + } else { + programBuilder.getOrNewThread(currentThread); + } visitThreadArguments(ctx.threadArguments()); for(LitmusCParser.ExpressionContext expressionContext : ctx.expression()) @@ -165,21 +173,44 @@ public Object visitThread(LitmusCParser.ThreadContext ctx) { return null; } + @Override + public Object visitOpenCLThreadScope(LitmusCParser.OpenCLThreadScopeContext ctx) { + int wgID = ctx.scopeID(0).id; + int devID = ctx.scopeID(1).id; + programBuilder.setOrCreateScopedThread(Arch.OPENCL, currentThread, devID, wgID); + return null; + } + @Override public Object visitThreadArguments(LitmusCParser.ThreadArgumentsContext ctx){ if(ctx != null){ - for(LitmusCParser.VarNameContext varName : ctx.varName()){ - // TODO: Possibly parse attributes/type modifiers (const, atomic, ...) - // For now, herd7 also seems to ignore most modifiers, in particular the atomic one. - String name = varName.getText(); - MemoryObject object = programBuilder.getOrNewMemoryObject(name); - Register register = programBuilder.getOrNewRegister(scope, name, archType); - programBuilder.addChild(currentThread, EventFactory.newLocal(register, object)); + for(LitmusCParser.ThreadArgumentContext threadArgumentContext : ctx.threadArgument()){ + threadArgumentContext.accept(this); } } return null; } + @Override + public Object visitThreadArgument(LitmusCParser.ThreadArgumentContext ctx) { + // TODO: Possibly parse attributes/type modifiers (const, ...) + // For now, herd7 also seems to ignore most modifiers, in particular the atomic one. + String name = ctx.varName().getText(); + MemoryObject object = programBuilder.getOrNewMemoryObject(name); + Register register = programBuilder.getOrNewRegister(scope, name, archType); + boolean atomicity = ctx.pointerTypeSpecifier().atomicTypeSpecifier() != null + || ctx.pointerTypeSpecifier().basicTypeSpecifier().AtomicInt() != null; + if (!atomicity) { + object.addFeatureTag(C11.NON_ATOMIC_LOCATION); + } + if (isOpenCL && ctx.pointerTypeSpecifier().openCLSpace() != null) { + object.addFeatureTag(ctx.pointerTypeSpecifier().openCLSpace().space); + } + programBuilder.setReg2LocMap(register, object); + programBuilder.addChild(currentThread, EventFactory.newLocal(register, object)); + return null; + } + @Override public Object visitIfExpression(LitmusCParser.IfExpressionContext ctx) { Expression expr = (Expression) ctx.re().accept(this); @@ -252,7 +283,10 @@ public Expression visitReAtomicFetchOp(LitmusCParser.ReAtomicFetchOpContext ctx) public Expression visitC11AtomicOp(LitmusCParser.C11AtomicOpContext ctx) { Register register = getReturnRegister(true); Expression value = returnExpressionOrOne(ctx.value); - Event event = EventFactory.Atomic.newFetchOp(register, getAddress(ctx.address), value, ctx.op, ctx.c11Mo().mo); + Expression address = getAddress(ctx.address); + Event event = EventFactory.Atomic.newFetchOp(register, address, value, ctx.op, ctx.c11Mo().mo); + addMemoryObjectTags(event, address); + addScopeTag(event, ctx.openCLScope()); programBuilder.addChild(currentThread, event); return register; } @@ -281,7 +315,21 @@ public Expression visitReAtomicAddUnless(LitmusCParser.ReAtomicAddUnlessContext public Expression visitReC11AtomicXchg(LitmusCParser.ReC11AtomicXchgContext ctx) { Register register = getReturnRegister(true); Expression value = (Expression) ctx.value.accept(this); - Event event = EventFactory.Atomic.newExchange(register, getAddress(ctx.address), value, ctx.c11Mo().mo); + Expression address = getAddress(ctx.address); + Event event = EventFactory.Atomic.newExchange(register, address, value, ctx.c11Mo().mo); + addMemoryObjectTags(event, address); + programBuilder.addChild(currentThread, event); + return register; + } + + @Override + public Expression visitReC11AtomicXchgExplicit(LitmusCParser.ReC11AtomicXchgExplicitContext ctx) { + Register register = getReturnRegister(true); + Expression value = (Expression) ctx.value.accept(this); + Expression address = getAddress(ctx.address); + Event event = EventFactory.Atomic.newExchange(register, address, value, ctx.c11Mo().mo); + addMemoryObjectTags(event, address); + addScopeTag(event, ctx.openCLScope()); programBuilder.addChild(currentThread, event); return register; } @@ -295,11 +343,44 @@ public Expression visitReXchg(LitmusCParser.ReXchgContext ctx){ return register; } + @Override + public Expression visitReC11SCmpXchgExplicit(LitmusCParser.ReC11SCmpXchgExplicitContext ctx) { + Register register = getReturnRegister(true); + Expression value = (Expression)ctx.value.accept(this); + Expression address = getAddress(ctx.address); + Expression expectedAdd = getAddress(ctx.expectedAdd); + String mo = ctx.c11Mo(0).mo; + Event event = EventFactory.Atomic.newCompareExchange(register, address, expectedAdd, value, mo, true); + addMemoryObjectTags(event, address); + addScopeTag(event, ctx.openCLScope()); + programBuilder.addChild(currentThread, event); + return register; + } + @Override public Expression visitReC11SCmpXchg(LitmusCParser.ReC11SCmpXchgContext ctx) { Register register = getReturnRegister(true); Expression value = (Expression)ctx.value.accept(this); - Event event = EventFactory.Atomic.newCompareExchange(register, getAddress(ctx.address), getAddress(ctx.expectedAdd), value, ctx.c11Mo(0).mo, true); + Expression address = getAddress(ctx.address); + Expression expectedAdd = getAddress(ctx.expectedAdd); + Event event = EventFactory.Atomic.newCompareExchange(register, address, expectedAdd, value, + C11.DEFAULT_MO, true); + addMemoryObjectTags(event, address); + addScopeTag(event, null); + programBuilder.addChild(currentThread, event); + return register; + } + + @Override + public Expression visitReC11WCmpXchgExplicit(LitmusCParser.ReC11WCmpXchgExplicitContext ctx) { + Register register = getReturnRegister(true); + Expression value = (Expression)ctx.value.accept(this); + Expression address = getAddress(ctx.address); + Expression expectedAdd = getAddress(ctx.expectedAdd); + String mo = ctx.c11Mo(0).mo; + Event event = EventFactory.Atomic.newCompareExchange(register, address, expectedAdd, value, mo, false); + addMemoryObjectTags(event, address); + addScopeTag(event, ctx.openCLScope()); programBuilder.addChild(currentThread, event); return register; } @@ -308,7 +389,12 @@ public Expression visitReC11SCmpXchg(LitmusCParser.ReC11SCmpXchgContext ctx) { public Expression visitReC11WCmpXchg(LitmusCParser.ReC11WCmpXchgContext ctx) { Register register = getReturnRegister(true); Expression value = (Expression)ctx.value.accept(this); - Event event = EventFactory.Atomic.newCompareExchange(register, getAddress(ctx.address), getAddress(ctx.expectedAdd), value, ctx.c11Mo(0).mo, false); + Expression address = getAddress(ctx.address); + Expression expectedAdd = getAddress(ctx.expectedAdd); + Event event = EventFactory.Atomic.newCompareExchange(register, address, expectedAdd, value, + C11.DEFAULT_MO, false); + addMemoryObjectTags(event, address); + addScopeTag(event, null); programBuilder.addChild(currentThread, event); return register; } @@ -323,9 +409,22 @@ public Expression visitReCmpXchg(LitmusCParser.ReCmpXchgContext ctx){ return register; } + @Override public Expression visitReC11LoadExplicit(LitmusCParser.ReC11LoadExplicitContext ctx) { + Register register = getReturnRegister(true); + Expression address = getAddress(ctx.address); + AtomicLoad event = EventFactory.Atomic.newLoad(register, address, ctx.c11Mo().mo); + addMemoryObjectTags(event, address); + addScopeTag(event, ctx.openCLScope()); + programBuilder.addChild(currentThread, event); + return register; + } + @Override public Expression visitReC11Load(LitmusCParser.ReC11LoadContext ctx) { Register register = getReturnRegister(true); - Event event = EventFactory.Atomic.newLoad(register, getAddress(ctx.address), ctx.c11Mo().mo); + Expression address = getAddress(ctx.address); + AtomicLoad event = EventFactory.Atomic.newLoad(register, address, C11.DEFAULT_MO); + addMemoryObjectTags(event, address); + addScopeTag(event, null); programBuilder.addChild(currentThread, event); return register; } @@ -349,7 +448,9 @@ public Expression visitReReadOnce(LitmusCParser.ReReadOnceContext ctx){ @Override public Expression visitReReadNa(LitmusCParser.ReReadNaContext ctx){ Register register = getReturnRegister(true); - Event event = EventFactory.newLoadWithMo(register, getAddress(ctx.address), C11.NONATOMIC); + Expression address = getAddress(ctx.address); + Load event = EventFactory.newLoadWithMo(register, address, C11.NONATOMIC); + addMemoryObjectTags(event, address); programBuilder.addChild(currentThread, event); return register; } @@ -459,10 +560,23 @@ public Object visitNreWriteOnce(LitmusCParser.NreWriteOnceContext ctx){ return programBuilder.addChild(currentThread, event); } + @Override + public Object visitNreC11StoreExplicit(LitmusCParser.NreC11StoreExplicitContext ctx) { + Expression value = (Expression)ctx.value.accept(this); + Expression address = getAddress(ctx.address); + AtomicStore event = EventFactory.Atomic.newStore(address, value, ctx.c11Mo().mo); + addMemoryObjectTags(event, address); + addScopeTag(event, ctx.openCLScope()); + return programBuilder.addChild(currentThread, event); + } + @Override public Object visitNreC11Store(LitmusCParser.NreC11StoreContext ctx) { Expression value = (Expression)ctx.value.accept(this); - Event event = EventFactory.Atomic.newStore(getAddress(ctx.address), value, ctx.c11Mo().mo); + Expression address = getAddress(ctx.address); + AtomicStore event = EventFactory.Atomic.newStore(address, value, C11.DEFAULT_MO); + addMemoryObjectTags(event, address); + addScopeTag(event, null); return programBuilder.addChild(currentThread, event); } @@ -470,8 +584,8 @@ public Object visitNreC11Store(LitmusCParser.NreC11StoreContext ctx) { public Object visitNreAssignment(LitmusCParser.NreAssignmentContext ctx){ Expression variable = (Expression)ctx.varName().accept(this); if(ctx.Ast() == null){ - if(variable instanceof Register){ - returnRegister = (Register)variable; + if(variable instanceof Register reg){ + returnRegister = reg; ctx.re().accept(this); return null; } @@ -481,6 +595,12 @@ public Object visitNreAssignment(LitmusCParser.NreAssignmentContext ctx){ Expression value = (Expression)ctx.re().accept(this); if(variable instanceof MemoryObject || variable instanceof Register){ Event event = EventFactory.newStoreWithMo(variable, value, C11.NONATOMIC); + if (variable instanceof Register reg) { + addMemoryObjectTags(event, reg); + if (isOpenCL) { + event.addTags(Tag.OpenCL.DEFAULT_WEAK_SCOPE); + } + } return programBuilder.addChild(currentThread, event); } throw new ParsingException("Invalid syntax near " + ctx.getText()); @@ -502,7 +622,8 @@ public Object visitNreRegDeclaration(LitmusCParser.NreRegDeclarationContext ctx) @Override public Object visitNreC11Fence(LitmusCParser.NreC11FenceContext ctx) { - return programBuilder.addChild(currentThread, EventFactory.Atomic.newFence(ctx.c11Mo().mo)); + AtomicThreadFence fence = EventFactory.Atomic.newFence(ctx.c11Mo().mo); + return programBuilder.addChild(currentThread, fence); } @Override @@ -510,6 +631,32 @@ public Object visitNreFence(LitmusCParser.NreFenceContext ctx){ return programBuilder.addChild(currentThread, EventFactory.Linux.newLKMMFence(ctx.name)); } + @Override + public Object visitNreOpenCLFence(LitmusCParser.NreOpenCLFenceContext ctx){ + AtomicThreadFence fence = EventFactory.Atomic.newFence(ctx.c11Mo().mo); + if (ctx.openCLScope() != null) { + fence.addTags(ctx.openCLScope().scope); + } + if (ctx.openCLFenceFlags() != null) { + for (LitmusCParser.OpenCLFenceFlagContext flagCtx : ctx.openCLFenceFlags().openCLFenceFlag()) { + fence.addTags(flagCtx.flag); + } + } + return programBuilder.addChild(currentThread, fence); + } + + @Override + public Object visitNreOpenCLBarrier(LitmusCParser.NreOpenCLBarrierContext ctx){ + Expression barrierId = expressions.makeValue(ctx.barrierId().id, archType); + List flags = ctx.openCLFenceFlags().openCLFenceFlag().stream().map(f -> f.flag).toList(); + Event fence = EventFactory.newControlBarrier(ctx.getText().toLowerCase(), barrierId); + fence.addTags(flags); + if (ctx.openCLScope() != null) { + fence.addTags(ctx.openCLScope().scope); + } + return programBuilder.addChild(currentThread, fence); + } + @Override public Object visitNreSpinLock(LitmusCParser.NreSpinLockContext ctx) { return programBuilder.addChild(currentThread, EventFactory.Linux.newLock(getAddress(ctx.address))); @@ -577,4 +724,27 @@ private Expression assignToReturnRegister(Register register, Expression value) { } return value; } + + private void addMemoryObjectTags(Event event, Expression address) { + if (address instanceof Register reg) { + MemoryObject object = programBuilder.getLocFromReg(reg); + if (object != null) { + event.addTags(object.getFeatureTags()); + } + } else { + for (Expression add : address.getOperands()) { + addMemoryObjectTags(event, add); + } + } + } + + private void addScopeTag(Event event, LitmusCParser.OpenCLScopeContext ctx) { + if (isOpenCL) { + if (ctx != null) { + event.addTags(ctx.scope); + } else { + event.addTags(Tag.OpenCL.DEFAULT_SCOPE); + } + } + } } diff --git a/dartagnan/src/main/java/com/dat3m/dartagnan/parsers/program/visitors/VisitorLitmusPTX.java b/dartagnan/src/main/java/com/dat3m/dartagnan/parsers/program/visitors/VisitorLitmusPTX.java index cf99a696e1..520741b3b1 100644 --- a/dartagnan/src/main/java/com/dat3m/dartagnan/parsers/program/visitors/VisitorLitmusPTX.java +++ b/dartagnan/src/main/java/com/dat3m/dartagnan/parsers/program/visitors/VisitorLitmusPTX.java @@ -100,7 +100,7 @@ public Object visitThreadDeclaratorList(LitmusPTXParser.ThreadDeclaratorListCont int ctaID = threadScopeContext.scopeID().ctaID().id; int gpuID = threadScopeContext.scopeID().gpuID().id; // NB: the order of scopeIDs is important - programBuilder.newScopedThread(Arch.PTX, threadScopeContext.threadId().id, gpuID, ctaID); + programBuilder.setOrCreateScopedThread(Arch.PTX, threadScopeContext.threadId().id, gpuID, ctaID); threadCount++; } return null; diff --git a/dartagnan/src/main/java/com/dat3m/dartagnan/parsers/program/visitors/VisitorLitmusVulkan.java b/dartagnan/src/main/java/com/dat3m/dartagnan/parsers/program/visitors/VisitorLitmusVulkan.java index cb50070057..9314d52b63 100644 --- a/dartagnan/src/main/java/com/dat3m/dartagnan/parsers/program/visitors/VisitorLitmusVulkan.java +++ b/dartagnan/src/main/java/com/dat3m/dartagnan/parsers/program/visitors/VisitorLitmusVulkan.java @@ -117,7 +117,7 @@ public Object visitThreadDeclaratorList(LitmusVulkanParser.ThreadDeclaratorListC int workgroupID = threadScopeContext.workgroupScope().scopeID().id; int queuefamilyID = threadScopeContext.queuefamilyScope().scopeID().id; // NB: the order of scopeIDs is important - programBuilder.newScopedThread(Arch.VULKAN, threadScopeContext.threadId().id, + programBuilder.setOrCreateScopedThread(Arch.VULKAN, threadScopeContext.threadId().id, queuefamilyID, workgroupID, subgroupID); threadCount++; } diff --git a/dartagnan/src/main/java/com/dat3m/dartagnan/program/ScopeHierarchy.java b/dartagnan/src/main/java/com/dat3m/dartagnan/program/ScopeHierarchy.java index 3bffa27557..cf02ddd93f 100644 --- a/dartagnan/src/main/java/com/dat3m/dartagnan/program/ScopeHierarchy.java +++ b/dartagnan/src/main/java/com/dat3m/dartagnan/program/ScopeHierarchy.java @@ -32,6 +32,14 @@ public static ScopeHierarchy ScopeHierarchyForPTX(int gpu, int cta) { return scopeHierarchy; } + public static ScopeHierarchy ScopeHierarchyForOpenCL(int dev, int wg) { + ScopeHierarchy scopeHierarchy = new ScopeHierarchy(); + scopeHierarchy.scopeIds.put(Tag.OpenCL.ALL, 0); + scopeHierarchy.scopeIds.put(Tag.OpenCL.DEVICE, dev); + scopeHierarchy.scopeIds.put(Tag.OpenCL.WORK_GROUP, wg); + return scopeHierarchy; + } + public List getScopes() { return new ArrayList<>(scopeIds.keySet()); } diff --git a/dartagnan/src/main/java/com/dat3m/dartagnan/program/Thread.java b/dartagnan/src/main/java/com/dat3m/dartagnan/program/Thread.java index a4280b0b1b..aa3c718d7a 100644 --- a/dartagnan/src/main/java/com/dat3m/dartagnan/program/Thread.java +++ b/dartagnan/src/main/java/com/dat3m/dartagnan/program/Thread.java @@ -15,7 +15,7 @@ public class Thread extends Function { // Scope hierarchy of the thread - private final Optional scopeHierarchy; + private Optional scopeHierarchy; // Threads that are system-synchronized-with this thread private final Optional> syncSet; @@ -56,6 +56,10 @@ public Set getSyncSet() { return syncSet.get(); } + public void setScopeHierarchy(ScopeHierarchy scopeHierarchy) { + this.scopeHierarchy = Optional.of(scopeHierarchy); + } + @Override public ThreadStart getEntry() { return (ThreadStart) entry; diff --git a/dartagnan/src/main/java/com/dat3m/dartagnan/program/event/EventFactory.java b/dartagnan/src/main/java/com/dat3m/dartagnan/program/event/EventFactory.java index add6cc5009..fb8fba082e 100644 --- a/dartagnan/src/main/java/com/dat3m/dartagnan/program/event/EventFactory.java +++ b/dartagnan/src/main/java/com/dat3m/dartagnan/program/event/EventFactory.java @@ -135,7 +135,9 @@ public static Init newInit(MemoryObject base, int offset) { // meaning that and are treated differently. final Expression address = offset == 0 ? base : expressions.makeAdd(base, expressions.makeValue(offset, (IntegerType) base.getType())); - return new Init(base, offset, address); + Init init = new Init(base, offset, address); + init.addTags(base.getFeatureTags()); + return init; } public static ValueFunctionCall newValueFunctionCall(Register resultRegister, Function function, List arguments) { @@ -801,5 +803,4 @@ public static SpirvRmwExtremum newSpirvRmwExtremum(Register register, Expression return new SpirvRmwExtremum(register, address, op, value, scope, tags); } } - } \ No newline at end of file diff --git a/dartagnan/src/main/java/com/dat3m/dartagnan/program/event/EventVisitor.java b/dartagnan/src/main/java/com/dat3m/dartagnan/program/event/EventVisitor.java index 698fd8c12b..20d5a5eb67 100644 --- a/dartagnan/src/main/java/com/dat3m/dartagnan/program/event/EventVisitor.java +++ b/dartagnan/src/main/java/com/dat3m/dartagnan/program/event/EventVisitor.java @@ -117,4 +117,4 @@ public interface EventVisitor { default T visitSpirvXchg(SpirvXchg e) { return visitMemEvent(e); } default T visitSpirvCmpXchg(SpirvCmpXchg e) { return visitMemEvent(e); } default T visitSpirvRmwExtremum(SpirvRmwExtremum e) { return visitMemEvent(e); } -} +} \ No newline at end of file diff --git a/dartagnan/src/main/java/com/dat3m/dartagnan/program/event/Tag.java b/dartagnan/src/main/java/com/dat3m/dartagnan/program/event/Tag.java index fbd983e3a5..843083fe63 100644 --- a/dartagnan/src/main/java/com/dat3m/dartagnan/program/event/Tag.java +++ b/dartagnan/src/main/java/com/dat3m/dartagnan/program/event/Tag.java @@ -119,13 +119,16 @@ private C11() { public static final String ATOMIC = "A"; public static final String NONATOMIC = "NA"; + public static final String NON_ATOMIC_LOCATION = "NAL"; public static final String MO_RELAXED = "RLX"; public static final String MO_CONSUME = "CON"; public static final String MO_ACQUIRE = "ACQ"; public static final String MO_RELEASE = "REL"; public static final String MO_ACQUIRE_RELEASE = "ACQ_REL"; - public static final String MO_SC = "SC"; + public static final String MO_SC = "SC"; + + public static final String DEFAULT_MO = MO_SC; public static String intToMo(int i) { switch (i) { @@ -366,6 +369,37 @@ public static String storeMO(String mo) { } } + // ============================================================================================= + // ========================================= OpenCL ============================================ + // ============================================================================================= + public static final class OpenCL { + // Scopes + public static final String WORK_ITEM = "WI"; + public static final String WORK_GROUP = "WG"; + public static final String DEVICE = "DV"; + public static final String ALL = "ALL"; + // Space + public static final String GLOBAL_SPACE = "GLOBAL"; + public static final String LOCAL_SPACE = "LOCAL"; + // Barrier + public static final String ENTRY_FENCE = "EF"; + public static final String EXIT_FENCE = "XF"; + // Default Tags + public static final String DEFAULT_SCOPE = DEVICE; + public static final String DEFAULT_WEAK_SCOPE = WORK_ITEM; + + public static List getScopeTags() { + return List.of(WORK_GROUP, DEVICE, ALL); + } + + public static List getSpaceTags() { + return List.of(GLOBAL_SPACE, LOCAL_SPACE); + } + + public static List getSpaceTags(Event e) { + return getSpaceTags().stream().filter(e::hasTag).toList(); + } + } // ============================================================================================= // ========================================= Spir-V ============================================ // ============================================================================================= @@ -487,6 +521,7 @@ public static String getScopeTag(Event e, Arch arch) { return switch (arch) { case PTX -> PTX.getScopeTags().stream().filter(e::hasTag).findFirst().orElse(""); case VULKAN -> Vulkan.getScopeTags().stream().filter(e::hasTag).findFirst().orElse(""); + case OPENCL -> OpenCL.getScopeTags().stream().filter(e::hasTag).findFirst().orElse(""); default -> throw new UnsupportedOperationException("Scope tags not implemented for architecture " + arch); }; } diff --git a/dartagnan/src/main/java/com/dat3m/dartagnan/program/event/core/ControlBarrier.java b/dartagnan/src/main/java/com/dat3m/dartagnan/program/event/core/ControlBarrier.java index c705209e0d..148bd59802 100644 --- a/dartagnan/src/main/java/com/dat3m/dartagnan/program/event/core/ControlBarrier.java +++ b/dartagnan/src/main/java/com/dat3m/dartagnan/program/event/core/ControlBarrier.java @@ -20,7 +20,7 @@ public ControlBarrier(String name, Expression id) { this.id = id; } - private ControlBarrier(ControlBarrier other) { + protected ControlBarrier(ControlBarrier other) { super(other); this.id = other.id; } diff --git a/dartagnan/src/main/java/com/dat3m/dartagnan/program/memory/MemoryObject.java b/dartagnan/src/main/java/com/dat3m/dartagnan/program/memory/MemoryObject.java index cc0de95fbe..9bf8443a36 100644 --- a/dartagnan/src/main/java/com/dat3m/dartagnan/program/memory/MemoryObject.java +++ b/dartagnan/src/main/java/com/dat3m/dartagnan/program/memory/MemoryObject.java @@ -9,10 +9,7 @@ import com.dat3m.dartagnan.expression.type.*; import com.dat3m.dartagnan.program.event.core.Alloc; -import java.util.List; -import java.util.Map; -import java.util.Set; -import java.util.TreeMap; +import java.util.*; import static com.google.common.base.Preconditions.checkArgument; import static com.google.common.base.Preconditions.checkState; @@ -33,6 +30,7 @@ public class MemoryObject extends LeafExpressionBase { private String name = null; private boolean isThreadLocal = false; + private final Set featureTags = new HashSet<>(); private final Map initialValues = new TreeMap<>(); @@ -54,6 +52,9 @@ public class MemoryObject extends LeafExpressionBase { public boolean isThreadLocal() { return this.isThreadLocal; } public void setIsThreadLocal(boolean value) { this.isThreadLocal = value;} + public void addFeatureTag(String tag) { featureTags.add(tag); } + public Set getFeatureTags() { return featureTags; } + /** * @return Number of fields in this array. */ diff --git a/dartagnan/src/main/java/com/dat3m/dartagnan/program/processing/MemoryAllocation.java b/dartagnan/src/main/java/com/dat3m/dartagnan/program/processing/MemoryAllocation.java index 141e35a7d8..398fb4da26 100644 --- a/dartagnan/src/main/java/com/dat3m/dartagnan/program/processing/MemoryAllocation.java +++ b/dartagnan/src/main/java/com/dat3m/dartagnan/program/processing/MemoryAllocation.java @@ -1,5 +1,6 @@ package com.dat3m.dartagnan.program.processing; +import com.dat3m.dartagnan.configuration.Arch; import com.dat3m.dartagnan.configuration.OptionNames; import com.dat3m.dartagnan.expression.Expression; import com.dat3m.dartagnan.expression.ExpressionFactory; diff --git a/dartagnan/src/main/java/com/dat3m/dartagnan/program/processing/compilation/Compilation.java b/dartagnan/src/main/java/com/dat3m/dartagnan/program/processing/compilation/Compilation.java index 4892f50c49..670752812f 100644 --- a/dartagnan/src/main/java/com/dat3m/dartagnan/program/processing/compilation/Compilation.java +++ b/dartagnan/src/main/java/com/dat3m/dartagnan/program/processing/compilation/Compilation.java @@ -121,7 +121,7 @@ public List getCompilationResult(Event toBeCompiled) { private VisitorBase getCompiler() { return switch (target) { - case C11 -> new VisitorC11(); + case C11, OPENCL -> new VisitorC11(); case LKMM -> new VisitorLKMM(); case TSO -> new VisitorTso(); case POWER -> new VisitorPower(useRC11Scheme, cToPowerScheme); diff --git a/dartagnan/src/main/java/com/dat3m/dartagnan/program/processing/compilation/VisitorC11.java b/dartagnan/src/main/java/com/dat3m/dartagnan/program/processing/compilation/VisitorC11.java index e121819601..edeee5240b 100644 --- a/dartagnan/src/main/java/com/dat3m/dartagnan/program/processing/compilation/VisitorC11.java +++ b/dartagnan/src/main/java/com/dat3m/dartagnan/program/processing/compilation/VisitorC11.java @@ -1,10 +1,12 @@ package com.dat3m.dartagnan.program.processing.compilation; +import com.dat3m.dartagnan.configuration.Arch; import com.dat3m.dartagnan.expression.Expression; import com.dat3m.dartagnan.expression.Type; import com.dat3m.dartagnan.expression.type.BooleanType; import com.dat3m.dartagnan.program.Register; import com.dat3m.dartagnan.program.event.Event; +import com.dat3m.dartagnan.program.event.EventFactory; import com.dat3m.dartagnan.program.event.MemoryEvent; import com.dat3m.dartagnan.program.event.Tag; import com.dat3m.dartagnan.program.event.Tag.C11; @@ -57,7 +59,7 @@ public List visitAtomicCmpXchg(AtomicCmpXchg e) { Load loadValue = newRMWLoadWithMo(regValue, address, Tag.C11.loadMO(mo)); Store storeValue = newRMWStoreWithMo(loadValue, address, e.getStoreValue(), Tag.C11.storeMO(mo)); - return tagList(eventSequence( + return tagList(e, eventSequence( loadExpected, loadValue, casCmpResult, @@ -82,7 +84,7 @@ public List visitAtomicFetchOp(AtomicFetchOp e) { Local localOp = newLocal(dummyReg, expressions.makeIntBinary(resultRegister, e.getOperator(), e.getOperand())); RMWStore store = newRMWStoreWithMo(load, address, dummyReg, mo); - return tagList(eventSequence( + return tagList(e, eventSequence( load, localOp, store @@ -91,21 +93,21 @@ public List visitAtomicFetchOp(AtomicFetchOp e) { @Override public List visitAtomicLoad(AtomicLoad e) { - return tagList(eventSequence( + return tagList(e, eventSequence( newLoadWithMo(e.getResultRegister(), e.getAddress(), Tag.C11.loadMO(e.getMo())) )); } @Override public List visitAtomicStore(AtomicStore e) { - return tagList(eventSequence( + return tagList(e, eventSequence( newStoreWithMo(e.getAddress(), e.getMemValue(), Tag.C11.storeMO(e.getMo())) )); } @Override public List visitAtomicThreadFence(AtomicThreadFence e) { - return tagList(eventSequence( + return tagList(e, eventSequence( newFence(e.getMo()) )); } @@ -118,12 +120,24 @@ public List visitAtomicXchg(AtomicXchg e) { Load load = newRMWLoadWithMo(e.getResultRegister(), address, Tag.C11.loadMO(mo)); RMWStore store = newRMWStoreWithMo(load, address, e.getValue(), Tag.C11.storeMO(mo)); - return tagList(eventSequence( + return tagList(e, eventSequence( load, store )); } + @Override + public List visitControlBarrier(ControlBarrier e) { + Event entryFence = EventFactory.newControlBarrier(e.getName() + "_entry", e.getId()); + entryFence.addTags(Tag.OpenCL.ENTRY_FENCE, C11.MO_RELEASE); + Event exitFence = EventFactory.newControlBarrier(e.getName() + "_exit", e.getId()); + exitFence.addTags(Tag.OpenCL.EXIT_FENCE, C11.MO_ACQUIRE); + return tagList(e, eventSequence( + entryFence, + exitFence + )); + } + // ============================================================================================= // =========================================== LLVM ============================================ // ============================================================================================= @@ -210,16 +224,30 @@ public List visitLlvmFence(LlvmFence e) { } private List tagList(List in) { - in.forEach(this::tagEvent); + in.forEach(e -> tagEvent(null, e)); return in; } - private void tagEvent(Event e) { + private List tagList(Event originalEvent, List in) { + in.forEach(e -> tagEvent(originalEvent, e)); + return in; + } + + private void tagEvent(Event originalEvent, Event e) { + if (originalEvent != null) { + String scope = Tag.getScopeTag(originalEvent, Arch.OPENCL); + List spaces = Tag.OpenCL.getSpaceTags(originalEvent); + if (e instanceof MemoryEvent || e instanceof GenericVisibleEvent) { + if (!scope.isEmpty()) { + e.addTags(scope); + } + e.addTags(spaces); + } + } if (e instanceof MemoryEvent) { - final MemoryOrder mo = e.getMetadata(MemoryOrder.class); - final boolean canRace = mo == null || mo.value().equals(C11.NONATOMIC); + MemoryOrder mo = e.getMetadata(MemoryOrder.class); + boolean canRace = mo == null || mo.value().equals(C11.NONATOMIC); e.addTags(canRace ? C11.NONATOMIC : C11.ATOMIC); } } - } \ No newline at end of file diff --git a/dartagnan/src/main/java/com/dat3m/dartagnan/wmm/RelationNameRepository.java b/dartagnan/src/main/java/com/dat3m/dartagnan/wmm/RelationNameRepository.java index 72b4f3e1e6..a06c0bfa2a 100644 --- a/dartagnan/src/main/java/com/dat3m/dartagnan/wmm/RelationNameRepository.java +++ b/dartagnan/src/main/java/com/dat3m/dartagnan/wmm/RelationNameRepository.java @@ -25,6 +25,7 @@ public class RelationNameRepository { public static final String SSG = "ssg"; public static final String SWG = "swg"; public static final String SQF = "sqf"; + public static final String SDV = "sdv"; public static final String SSW = "ssw"; public static final String SYNC_FENCE = "sync_fence"; public static final String SYNCBAR = "syncbar"; diff --git a/dartagnan/src/main/java/com/dat3m/dartagnan/wmm/Wmm.java b/dartagnan/src/main/java/com/dat3m/dartagnan/wmm/Wmm.java index 3cd185fd67..61127ea495 100755 --- a/dartagnan/src/main/java/com/dat3m/dartagnan/wmm/Wmm.java +++ b/dartagnan/src/main/java/com/dat3m/dartagnan/wmm/Wmm.java @@ -225,6 +225,7 @@ private Relation makePredefinedRelation(String name) { case SSG -> new SameScope(r, Tag.Vulkan.SUB_GROUP); case SWG -> new SameScope(r, Tag.Vulkan.WORK_GROUP); case SQF -> new SameScope(r, Tag.Vulkan.QUEUE_FAMILY); + case SDV -> new SameScope(r, Tag.Vulkan.DEVICE); case SSW -> new SyncWith(r); case SYNCBAR -> new SyncBar(r); case SYNC_FENCE -> new SyncFence(r); diff --git a/dartagnan/src/test/java/com/dat3m/dartagnan/comparison/AbstractComparisonTest.java b/dartagnan/src/test/java/com/dat3m/dartagnan/comparison/AbstractComparisonTest.java new file mode 100644 index 0000000000..8aac26f105 --- /dev/null +++ b/dartagnan/src/test/java/com/dat3m/dartagnan/comparison/AbstractComparisonTest.java @@ -0,0 +1,133 @@ +package com.dat3m.dartagnan.comparison; + +import com.dat3m.dartagnan.configuration.Arch; +import com.dat3m.dartagnan.configuration.ProgressModel; +import com.dat3m.dartagnan.configuration.Property; +import com.dat3m.dartagnan.encoding.ProverWithTracker; +import com.dat3m.dartagnan.program.Program; +import com.dat3m.dartagnan.utils.ResourceHelper; +import com.dat3m.dartagnan.utils.rules.Provider; +import com.dat3m.dartagnan.utils.rules.Providers; +import com.dat3m.dartagnan.utils.rules.RequestShutdownOnError; +import com.dat3m.dartagnan.verification.VerificationTask; +import com.dat3m.dartagnan.verification.solving.AssumeSolver; +import com.dat3m.dartagnan.wmm.Wmm; +import org.junit.Rule; +import org.junit.Test; +import org.junit.rules.RuleChain; +import org.junit.rules.Timeout; +import org.sosy_lab.common.ShutdownManager; +import org.sosy_lab.common.configuration.Configuration; +import org.sosy_lab.java_smt.SolverContextFactory.Solvers; +import org.sosy_lab.java_smt.api.ProverEnvironment; +import org.sosy_lab.java_smt.api.SolverContext; +import org.sosy_lab.java_smt.api.SolverContext.ProverOptions; + +import java.io.IOException; +import java.nio.file.Files; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.util.ArrayList; +import java.util.EnumSet; +import java.util.List; +import java.util.Set; +import java.util.stream.Stream; + +import static com.dat3m.dartagnan.configuration.OptionNames.INITIALIZE_REGISTERS; +import static com.dat3m.dartagnan.configuration.OptionNames.USE_INTEGERS; +import static com.dat3m.dartagnan.utils.ResourceHelper.getRootPath; +import static java.util.Collections.emptyList; +import static org.junit.Assert.assertEquals; + +public abstract class AbstractComparisonTest { + + private String path; + + AbstractComparisonTest(String path) { + this.path = path; + } + + static Iterable buildLitmusTests(String litmusPath) throws IOException { + Set skip = ResourceHelper.getSkipSet(); + try (Stream fileStream = Files.walk(Paths.get(getRootPath(litmusPath)))) { + return fileStream + .filter(Files::isRegularFile) + .map(Path::toString) + .filter(f -> f.endsWith("litmus")) + .filter(f -> !skip.contains(f)) + .collect(ArrayList::new, + (l, f) -> l.add(new Object[]{f}), ArrayList::addAll); + } + } + + + // =================== Modifiable behavior ==================== + + protected abstract Provider getSourceProvider(); + protected Provider getSourceWmmProvider() { + return Providers.createWmmFromArch(getSourceProvider()); + } + protected abstract Provider getTargetProvider(); + protected Provider getTargetWmmProvider() { + return Providers.createWmmFromArch(getTargetProvider()); + } + protected Provider> getPropertyProvider() { + return Provider.fromSupplier(() -> EnumSet.of(Property.PROGRAM_SPEC)); + } + protected long getTimeout() { return 10000; } + // List of tests that are known to show bugs in the compilation scheme and thus the expected result should be FAIL instead of PASS + protected List getCompilationBreakers() { return emptyList(); } + protected Provider getConfigurationProvider() { + return Provider.fromSupplier(() -> Configuration.builder() + .setOption(INITIALIZE_REGISTERS, "true") + .setOption(USE_INTEGERS, "true") + .build()); + } + // ============================================================ + + protected final Provider shutdownManagerProvider = Provider.fromSupplier(ShutdownManager::create); + protected final Provider sourceProvider = getSourceProvider(); + protected final Provider targetProvider = getTargetProvider(); + protected final Provider filePathProvider = () -> path; + protected final Provider program1Provider = Providers.createProgramFromPath(filePathProvider); + protected final Provider program2Provider = Providers.createProgramFromPath(filePathProvider); + protected final Provider wmm1Provider = getSourceWmmProvider(); + protected final Provider wmm2Provider = getTargetWmmProvider(); + protected final Provider> propertyProvider = getPropertyProvider(); + protected final Provider configProvider = getConfigurationProvider(); + protected final Provider task1Provider = Providers.createTask(program1Provider, wmm1Provider, propertyProvider, sourceProvider, () -> ProgressModel.FAIR, () -> 1, configProvider); + protected final Provider task2Provider = Providers.createTask(program2Provider, wmm2Provider, propertyProvider, targetProvider, () -> ProgressModel.FAIR, () -> 1, configProvider); + protected final Provider context1Provider = Providers.createSolverContextFromManager(shutdownManagerProvider, () -> Solvers.Z3); + protected final Provider context2Provider = Providers.createSolverContextFromManager(shutdownManagerProvider, () -> Solvers.Z3); + protected final Provider prover1Provider = Providers.createProverWithFixedOptions(context1Provider, ProverOptions.GENERATE_MODELS); + protected final Provider prover2Provider = Providers.createProverWithFixedOptions(context2Provider, ProverOptions.GENERATE_MODELS); + + private final Timeout timeout = Timeout.millis(getTimeout()); + private final RequestShutdownOnError shutdownOnError = RequestShutdownOnError.create(shutdownManagerProvider); + + @Rule + public RuleChain ruleChain = RuleChain.outerRule(shutdownManagerProvider) + .around(shutdownOnError) + .around(filePathProvider) + .around(program1Provider) + .around(program2Provider) + .around(wmm1Provider) + .around(wmm2Provider) + .around(propertyProvider) + .around(configProvider) + .around(task1Provider) + .around(task2Provider) + .around(timeout) + // Context/Prover need to be created inside test-thread spawned by + .around(context1Provider) + .around(context2Provider) + .around(prover1Provider) + .around(prover2Provider); + + @Test + public void testAssume() throws Exception { + AssumeSolver s1 = AssumeSolver.run(context1Provider.get(), prover1Provider.get(), task1Provider.get()); + AssumeSolver s2 = AssumeSolver.run(context2Provider.get(), prover2Provider.get(), task2Provider.get()); + assertEquals(s1.hasModel(), s2.hasModel()); + } +} diff --git a/dartagnan/src/test/java/com/dat3m/dartagnan/comparison/C11AndOpenCLTest.java b/dartagnan/src/test/java/com/dat3m/dartagnan/comparison/C11AndOpenCLTest.java new file mode 100644 index 0000000000..98e3522a9e --- /dev/null +++ b/dartagnan/src/test/java/com/dat3m/dartagnan/comparison/C11AndOpenCLTest.java @@ -0,0 +1,43 @@ +package com.dat3m.dartagnan.comparison; + +import com.dat3m.dartagnan.configuration.Arch; +import com.dat3m.dartagnan.utils.rules.Provider; +import com.dat3m.dartagnan.utils.rules.Providers; +import com.dat3m.dartagnan.wmm.Wmm; +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + +import java.io.IOException; + +@RunWith(Parameterized.class) +public class C11AndOpenCLTest extends AbstractComparisonTest { + + @Parameterized.Parameters(name = "{index}: {0}") + public static Iterable data() throws IOException { + return buildLitmusTests("litmus/C11/"); + } + + public C11AndOpenCLTest(String path) { + super(path); + } + + @Override + protected Provider getSourceProvider() { + return () -> Arch.C11; + } + + @Override + protected Provider getTargetProvider() { + return () -> Arch.OPENCL; + } + + @Override + protected Provider getSourceWmmProvider() { + return Providers.createWmmFromName(() -> "c11"); + } + + @Override + protected Provider getTargetWmmProvider() { + return Providers.createWmmFromName(() -> "opencl"); + } +} diff --git a/dartagnan/src/test/java/com/dat3m/dartagnan/litmus/LitmusOpenClRacesTest.java b/dartagnan/src/test/java/com/dat3m/dartagnan/litmus/LitmusOpenClRacesTest.java new file mode 100644 index 0000000000..f4a985b6e2 --- /dev/null +++ b/dartagnan/src/test/java/com/dat3m/dartagnan/litmus/LitmusOpenClRacesTest.java @@ -0,0 +1,42 @@ +package com.dat3m.dartagnan.litmus; + +import java.io.IOException; +import java.util.EnumSet; + +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + +import com.dat3m.dartagnan.configuration.Arch; +import com.dat3m.dartagnan.configuration.Property; +import com.dat3m.dartagnan.utils.Result; +import com.dat3m.dartagnan.utils.rules.Provider; +import com.dat3m.dartagnan.utils.rules.Providers; +import com.dat3m.dartagnan.wmm.Wmm; + +@RunWith(Parameterized.class) +public class LitmusOpenClRacesTest extends AbstractLitmusTest { + + @Parameterized.Parameters(name = "{index}: {0}, {1}") + public static Iterable data() throws IOException { + return buildLitmusTests("litmus/OPENCL/", "OPENCL", "-DR"); + } + + @Override + protected Provider getTargetProvider() { + return () -> Arch.OPENCL; + } + + @Override + protected Provider> getPropertyProvider() { + return Provider.fromSupplier(() -> EnumSet.of(Property.CAT_SPEC)); + } + + @Override + protected Provider getWmmProvider() { + return Providers.createWmmFromName(() -> "opencl"); + } + + public LitmusOpenClRacesTest(String path, Result expected) { + super(path, expected); + } +} diff --git a/dartagnan/src/test/java/com/dat3m/dartagnan/litmus/LitmusOpenClTest.java b/dartagnan/src/test/java/com/dat3m/dartagnan/litmus/LitmusOpenClTest.java new file mode 100644 index 0000000000..ef686b6bb2 --- /dev/null +++ b/dartagnan/src/test/java/com/dat3m/dartagnan/litmus/LitmusOpenClTest.java @@ -0,0 +1,36 @@ +package com.dat3m.dartagnan.litmus; + +import com.dat3m.dartagnan.configuration.Arch; +import com.dat3m.dartagnan.configuration.Property; +import com.dat3m.dartagnan.utils.Result; +import com.dat3m.dartagnan.utils.rules.Provider; +import com.dat3m.dartagnan.utils.rules.Providers; +import com.dat3m.dartagnan.wmm.Wmm; +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + +import java.io.IOException; +import java.util.EnumSet; + +@RunWith(Parameterized.class) +public class LitmusOpenClTest extends AbstractLitmusTest { + + @Parameterized.Parameters(name = "{index}: {0}, {1}") + public static Iterable data() throws IOException { + return buildLitmusTests("litmus/OPENCL/", "OPENCL"); + } + + @Override + protected Provider getTargetProvider() { + return () -> Arch.OPENCL; + } + + @Override + protected Provider getWmmProvider() { + return Providers.createWmmFromName(() -> "opencl"); + } + + public LitmusOpenClTest(String path, Result expected) { + super(path, expected); + } +} diff --git a/dartagnan/src/test/java/com/dat3m/dartagnan/spirv/header/ConfigTest.java b/dartagnan/src/test/java/com/dat3m/dartagnan/spirv/header/ConfigTest.java index 9b9bddc347..9676f1addb 100644 --- a/dartagnan/src/test/java/com/dat3m/dartagnan/spirv/header/ConfigTest.java +++ b/dartagnan/src/test/java/com/dat3m/dartagnan/spirv/header/ConfigTest.java @@ -4,11 +4,11 @@ import com.dat3m.dartagnan.program.Program; import com.dat3m.dartagnan.program.ScopeHierarchy; import com.dat3m.dartagnan.program.Thread; +import com.dat3m.dartagnan.program.event.Tag; import org.junit.Test; import java.util.List; -import static com.dat3m.dartagnan.program.event.Tag.Vulkan.*; import static org.junit.Assert.assertEquals; import static org.junit.Assert.fail; @@ -37,10 +37,10 @@ private void doTestLegalConfig(String input, List scopes) { for (int i = 0; i < size; i++) { ScopeHierarchy hierarchy = threads.get(i).getScopeHierarchy(); assertEquals(i, threads.get(i).getId()); - assertEquals(((i % qf_size) % wg_size) / sg_size, hierarchy.getScopeId(SUB_GROUP)); - assertEquals((i % qf_size) / wg_size, hierarchy.getScopeId(WORK_GROUP)); - assertEquals(i / qf_size, hierarchy.getScopeId(QUEUE_FAMILY)); - assertEquals(0, hierarchy.getScopeId(DEVICE)); + assertEquals(((i % qf_size) % wg_size) / sg_size, hierarchy.getScopeId(Tag.Vulkan.SUB_GROUP)); + assertEquals((i % qf_size) / wg_size, hierarchy.getScopeId(Tag.Vulkan.WORK_GROUP)); + assertEquals(i / qf_size, hierarchy.getScopeId(Tag.Vulkan.QUEUE_FAMILY)); + assertEquals(0, hierarchy.getScopeId(Tag.Vulkan.DEVICE)); } } diff --git a/dartagnan/src/test/resources/C11-expected.csv b/dartagnan/src/test/resources/C11-expected.csv index 943b7f206c..02281568d3 100644 --- a/dartagnan/src/test/resources/C11-expected.csv +++ b/dartagnan/src/test/resources/C11-expected.csv @@ -129,7 +129,7 @@ litmus/C11/manual/cppmem_iriw_relacq.litmus,1 litmus/C11/manual/imm-E3.5.litmus,1 litmus/C11/manual/imm-E3.9.litmus,0 litmus/C11/manual/imm-R2.litmus,0 -litmus/C11/manual/example1.litmus,1 +litmus/C11/manual/example1.litmus,0 litmus/C11/manual/imm-R2-alt.litmus,1 litmus/C11/manual/mp_relaxed.litmus,1 litmus/C11/manual/IRIW-sc-sc-acq-sc-acq-sc.litmus,0 diff --git a/dartagnan/src/test/resources/OPENCL-DR-expected.csv b/dartagnan/src/test/resources/OPENCL-DR-expected.csv new file mode 100644 index 0000000000..90b90623fc --- /dev/null +++ b/dartagnan/src/test/resources/OPENCL-DR-expected.csv @@ -0,0 +1,40 @@ +litmus/OPENCL/herd/2+2W.litmus,1 +litmus/OPENCL/herd/3.2W.litmus,0 +litmus/OPENCL/herd/3LB.litmus,1 +litmus/OPENCL/herd/CT_wsq1.litmus,1 +litmus/OPENCL/herd/IRIW.litmus,1 +litmus/OPENCL/herd/ISA2.litmus,0 +litmus/OPENCL/herd/ISA3.litmus,1 +litmus/OPENCL/herd/LB.litmus,0 +litmus/OPENCL/herd/MP.litmus,0 +litmus/OPENCL/herd/R.litmus,1 +litmus/OPENCL/herd/RWC.litmus,0 +litmus/OPENCL/herd/S.litmus,0 +litmus/OPENCL/herd/SB.litmus,0 +litmus/OPENCL/herd/SB1.litmus,0 +litmus/OPENCL/herd/WRC.litmus,0 +litmus/OPENCL/herd/barrier_example.litmus,1 +litmus/OPENCL/herd/global_barrier.litmus,0 +litmus/OPENCL/herd/global_barrier_mo.litmus,1 +litmus/OPENCL/herd/thinair.litmus,1 +litmus/OPENCL/herd/old/MP_dr.litmus,0 +litmus/OPENCL/herd/old/MP_relacq.litmus,0 +litmus/OPENCL/herd/old/MP_relaxed.litmus,0 +litmus/OPENCL/herd/old/MP_relseq.litmus,0 +litmus/OPENCL/overhauling/example4.litmus,1 +litmus/OPENCL/overhauling/example5.litmus,0 +litmus/OPENCL/overhauling/example6.litmus,1 +litmus/OPENCL/overhauling/example7a.litmus,1 +litmus/OPENCL/overhauling/example7b.litmus,0 +litmus/OPENCL/overhauling/example8.litmus,0 +litmus/OPENCL/overhauling/example9a.litmus,1 +litmus/OPENCL/overhauling/example9b.litmus,1 +litmus/OPENCL/overhauling/example10.litmus,1 +litmus/OPENCL/overhauling/IRIW_sc_dev.litmus,1 +litmus/OPENCL/overhauling/IRIW_sc_wg.litmus,1 +litmus/OPENCL/overhauling/ISA2.litmus,1 +litmus/OPENCL/overhauling/ISA2_broken.litmus,0 +litmus/OPENCL/overhauling/MP_ra_dev.litmus,1 +litmus/OPENCL/overhauling/MP_ra_dev_broken.litmus,0 +litmus/OPENCL/overhauling/MP_ra_wg.litmus,0 +litmus/OPENCL/overhauling/MP_ra_dev.litmus,1 diff --git a/dartagnan/src/test/resources/OPENCL-expected.csv b/dartagnan/src/test/resources/OPENCL-expected.csv new file mode 100644 index 0000000000..dbe3bce17a --- /dev/null +++ b/dartagnan/src/test/resources/OPENCL-expected.csv @@ -0,0 +1,177 @@ +litmus/OPENCL/herd/2+2W.litmus,0 +litmus/OPENCL/herd/3.2W.litmus,1 +litmus/OPENCL/herd/3LB.litmus,0 +litmus/OPENCL/herd/CT_wsq1.litmus,0 +litmus/OPENCL/herd/CT_wsq2.litmus,0 +litmus/OPENCL/herd/IRIW.litmus,0 +litmus/OPENCL/herd/ISA2.litmus,1 +litmus/OPENCL/herd/ISA3.litmus,0 +litmus/OPENCL/herd/LB.litmus,1 +litmus/OPENCL/herd/MP.litmus,1 +litmus/OPENCL/herd/R.litmus,1 +litmus/OPENCL/herd/RWC.litmus,1 +litmus/OPENCL/herd/S.litmus,1 +litmus/OPENCL/herd/SB.litmus,1 +litmus/OPENCL/herd/SB1.litmus,1 +litmus/OPENCL/herd/WRC.litmus,0 +litmus/OPENCL/herd/barrier_example.litmus,0 +litmus/OPENCL/herd/global_barrier.litmus,1 +litmus/OPENCL/herd/global_barrier_mo.litmus,1 +litmus/OPENCL/herd/thinair.litmus,1 +litmus/OPENCL/herd/old/MP_dr.litmus,1 +litmus/OPENCL/herd/old/MP_relacq.litmus,1 +litmus/OPENCL/herd/old/MP_relaxed.litmus,1 +litmus/OPENCL/herd/old/MP_relseq.litmus,1 +litmus/OPENCL/overhauling/example4.litmus,0 +litmus/OPENCL/overhauling/example5.litmus,1 +litmus/OPENCL/overhauling/example6.litmus,0 +litmus/OPENCL/overhauling/example7a.litmus,0 +litmus/OPENCL/overhauling/example7b.litmus,1 +litmus/OPENCL/overhauling/example8.litmus,1 +litmus/OPENCL/overhauling/example9a.litmus,0 +litmus/OPENCL/overhauling/example9b.litmus,0 +litmus/OPENCL/overhauling/example10.litmus,1 +litmus/OPENCL/overhauling/IRIW_sc_dev.litmus,0 +litmus/OPENCL/overhauling/IRIW_sc_wg.litmus,0 +litmus/OPENCL/overhauling/ISA2.litmus,0 +litmus/OPENCL/overhauling/ISA2_broken.litmus,1 +litmus/OPENCL/overhauling/MP_ra_dev.litmus,0 +litmus/OPENCL/overhauling/MP_ra_dev_broken.litmus,1 +litmus/OPENCL/overhauling/MP_ra_wg.litmus,1 +litmus/OPENCL/overhauling/MP_ra_dev.litmus,0 +litmus/OPENCL/portedFromC11/auto/a3+sc+Racq.litmus,1 +litmus/OPENCL/portedFromC11/auto/linearisation.litmus,0 +litmus/OPENCL/portedFromC11/auto/a3+sc+Rrlx.litmus,1 +litmus/OPENCL/portedFromC11/auto/roachmotel2.litmus,1 +litmus/OPENCL/portedFromC11/auto/a1_reorder+sc+Rna.litmus,1 +litmus/OPENCL/portedFromC11/auto/a3+sc+Rna.litmus,1 +litmus/OPENCL/portedFromC11/auto/b+rlx+rel.litmus,1 +litmus/OPENCL/portedFromC11/auto/a1+Wrel+sc.litmus,1 +litmus/OPENCL/portedFromC11/auto/a1_reorder.litmus,1 +litmus/OPENCL/portedFromC11/auto/b+rlx+rlx.litmus,1 +litmus/OPENCL/portedFromC11/auto/a3_reorder+Wna+sc.litmus,1 +litmus/OPENCL/portedFromC11/auto/c_pq_reorder.litmus,0 +litmus/OPENCL/portedFromC11/auto/a3_reorder+Rrlx+acq.litmus,1 +litmus/OPENCL/portedFromC11/auto/seq2.litmus,1 +litmus/OPENCL/portedFromC11/auto/a3+sc+Rsc.litmus,1 +litmus/OPENCL/portedFromC11/auto/a1_reorder+sc+Rsc.litmus,1 +litmus/OPENCL/portedFromC11/auto/b+rlx+sc.litmus,1 +litmus/OPENCL/portedFromC11/auto/a3+acq+Wsc.litmus,1 +litmus/OPENCL/portedFromC11/auto/a1+Rrlx+sc.litmus,1 +litmus/OPENCL/portedFromC11/auto/a3+acq+Racq.litmus,1 +litmus/OPENCL/portedFromC11/auto/a3+acq+Rrlx.litmus,1 +litmus/OPENCL/portedFromC11/auto/a3_reorder+Rna+sc.litmus,1 +litmus/OPENCL/portedFromC11/auto/a1+Racq+rel.litmus,1 +litmus/OPENCL/portedFromC11/auto/a1+Wsc+rel.litmus,1 +litmus/OPENCL/portedFromC11/auto/a3+acq+Wna.litmus,1 +litmus/OPENCL/portedFromC11/auto/a3_reorder+Wna+acq.litmus,1 +litmus/OPENCL/portedFromC11/auto/b_reorder+rlx+rlx.litmus,1 +litmus/OPENCL/portedFromC11/auto/a1+Wrel+rel.litmus,1 +litmus/OPENCL/portedFromC11/auto/b_reorder+rlx+acq.litmus,1 +litmus/OPENCL/portedFromC11/auto/arfna.litmus,0 +litmus/OPENCL/portedFromC11/auto/b_reorder+sc+rlx.litmus,1 +litmus/OPENCL/portedFromC11/auto/rseq_weak.litmus,1 +litmus/OPENCL/portedFromC11/auto/a1_reorder+rel+Wrlx.litmus,1 +litmus/OPENCL/portedFromC11/auto/b_reorder+sc+acq.litmus,1 +litmus/OPENCL/portedFromC11/auto/a3_reorder+Rsc+sc.litmus,1 +litmus/OPENCL/portedFromC11/auto/a1_reorder+sc+Wrlx.litmus,1 +litmus/OPENCL/portedFromC11/auto/b_reorder+rel+acq.litmus,1 +litmus/OPENCL/portedFromC11/auto/b_reorder+rel+rlx.litmus,1 +litmus/OPENCL/portedFromC11/auto/a1+Wrlx+rel.litmus,1 +litmus/OPENCL/portedFromC11/auto/a3_reorder+Wrlx+sc.litmus,1 +litmus/OPENCL/portedFromC11/auto/a1+Rna+rel.litmus,1 +litmus/OPENCL/portedFromC11/auto/rseq_weak2.litmus,1 +litmus/OPENCL/portedFromC11/auto/a1_reorder+sc+Wrel.litmus,1 +litmus/OPENCL/portedFromC11/auto/a1_reorder+rel+Wrel.litmus,1 +litmus/OPENCL/portedFromC11/auto/a3_reorder+Rsc+acq.litmus,1 +litmus/OPENCL/portedFromC11/auto/a3v2.litmus,1 +litmus/OPENCL/portedFromC11/auto/b_reorder+rel+sc.litmus,1 +litmus/OPENCL/portedFromC11/auto/a1_reorder+rel+Wsc.litmus,1 +litmus/OPENCL/portedFromC11/auto/a3_reorder.litmus,1 +litmus/OPENCL/portedFromC11/auto/a3_reorder+Wsc+sc.litmus,1 +litmus/OPENCL/portedFromC11/auto/cyc.litmus,1 +litmus/OPENCL/portedFromC11/auto/a1_reorder+rel+Wna.litmus,1 +litmus/OPENCL/portedFromC11/auto/a4_reorder.litmus,1 +litmus/OPENCL/portedFromC11/auto/a3_reorder+Racq+sc.litmus,1 +litmus/OPENCL/portedFromC11/auto/c_q.litmus,0 +litmus/OPENCL/portedFromC11/auto/c.litmus,0 +litmus/OPENCL/portedFromC11/auto/a4.litmus,0 +litmus/OPENCL/portedFromC11/auto/b_reorder+sc+sc.litmus,1 +litmus/OPENCL/portedFromC11/auto/a3_reorder+Racq+acq.litmus,1 +litmus/OPENCL/portedFromC11/auto/a1+Wsc+sc.litmus,1 +litmus/OPENCL/portedFromC11/auto/c_pq.litmus,0 +litmus/OPENCL/portedFromC11/auto/a1.litmus,1 +litmus/OPENCL/portedFromC11/auto/b+acq+rlx.litmus,1 +litmus/OPENCL/portedFromC11/auto/a3_reorder+Wrel+acq.litmus,1 +litmus/OPENCL/portedFromC11/auto/roachmotel.litmus,0 +litmus/OPENCL/portedFromC11/auto/b+acq+rel.litmus,1 +litmus/OPENCL/portedFromC11/auto/a3_reorder+Wrel+sc.litmus,1 +litmus/OPENCL/portedFromC11/auto/fig1.litmus,1 +litmus/OPENCL/portedFromC11/auto/a1_reorder+rel+Rrlx.litmus,1 +litmus/OPENCL/portedFromC11/auto/a1_reorder+rel+Rna.litmus,1 +litmus/OPENCL/portedFromC11/auto/a1_reorder+rel+Racq.litmus,1 +litmus/OPENCL/portedFromC11/auto/b_reorder+rlx+sc.litmus,1 +litmus/OPENCL/portedFromC11/auto/a1_reorder+sc+Racq.litmus,1 +litmus/OPENCL/portedFromC11/auto/a1+Rrlx+rel.litmus,1 +litmus/OPENCL/portedFromC11/auto/cyc_na.litmus,0 +litmus/OPENCL/portedFromC11/auto/strengthen2.litmus,1 +litmus/OPENCL/portedFromC11/auto/a1_reorder+sc+Rrlx.litmus,1 +litmus/OPENCL/portedFromC11/auto/a1+Rsc+sc.litmus,1 +litmus/OPENCL/portedFromC11/auto/a1+Wna+rel.litmus,1 +litmus/OPENCL/portedFromC11/auto/a3_reorder+Rrlx+sc.litmus,1 +litmus/OPENCL/portedFromC11/auto/a1_reorder+rel+Rsc.litmus,1 +litmus/OPENCL/portedFromC11/auto/strengthen.litmus,0 +litmus/OPENCL/portedFromC11/auto/linearisation2.litmus,1 +litmus/OPENCL/portedFromC11/auto/a3.litmus,1 +litmus/OPENCL/portedFromC11/auto/a3_reorder+Wsc+acq.litmus,1 +litmus/OPENCL/portedFromC11/auto/c_reorder.litmus,0 +litmus/OPENCL/portedFromC11/auto/a3+acq+Wrlx.litmus,1 +litmus/OPENCL/portedFromC11/auto/a1+Wrlx+sc.litmus,1 +litmus/OPENCL/portedFromC11/auto/b+sc+rlx.litmus,1 +litmus/OPENCL/portedFromC11/auto/arfna2.litmus,0 +litmus/OPENCL/portedFromC11/auto/a1_reorder+sc+Wsc.litmus,1 +litmus/OPENCL/portedFromC11/auto/a3+sc+Wsc.litmus,1 +litmus/OPENCL/portedFromC11/auto/seq.litmus,0 +litmus/OPENCL/portedFromC11/auto/b+sc+rel.litmus,1 +litmus/OPENCL/portedFromC11/auto/a1+Rsc+rel.litmus,1 +litmus/OPENCL/portedFromC11/auto/lb.litmus,1 +litmus/OPENCL/portedFromC11/auto/a3+sc+Wna.litmus,1 +litmus/OPENCL/portedFromC11/auto/a1_reorder+sc+Wna.litmus,1 +litmus/OPENCL/portedFromC11/auto/a1+Rna+sc.litmus,1 +litmus/OPENCL/portedFromC11/auto/a3+acq+Wrel.litmus,1 +litmus/OPENCL/portedFromC11/auto/a3_reorder+Rna+acq.litmus,1 +litmus/OPENCL/portedFromC11/auto/c_p_reorder.litmus,0 +litmus/OPENCL/portedFromC11/auto/a3+sc+Wrlx.litmus,1 +litmus/OPENCL/portedFromC11/auto/a1+Racq+sc.litmus,1 +litmus/OPENCL/portedFromC11/auto/b+acq+sc.litmus,1 +litmus/OPENCL/portedFromC11/auto/c_q_reorder.litmus,0 +litmus/OPENCL/portedFromC11/auto/a3+acq+Rna.litmus,1 +litmus/OPENCL/portedFromC11/auto/a1+Wna+sc.litmus,1 +litmus/OPENCL/portedFromC11/auto/b.litmus,1 +litmus/OPENCL/portedFromC11/auto/c_p.litmus,0 +litmus/OPENCL/portedFromC11/auto/a3+acq+Rsc.litmus,1 +litmus/OPENCL/portedFromC11/auto/b_reorder.litmus,1 +litmus/OPENCL/portedFromC11/auto/b+sc+sc.litmus,1 +litmus/OPENCL/portedFromC11/auto/a3_reorder+Wrlx+acq.litmus,1 +litmus/OPENCL/portedFromC11/auto/a3+sc+Wrel.litmus,1 +litmus/OPENCL/portedFromC11/manual/imm-E3.2.litmus,0 +litmus/OPENCL/portedFromC11/manual/mp_fences.litmus,0 +litmus/OPENCL/portedFromC11/manual/imm-E3.10.litmus,0 +litmus/OPENCL/portedFromC11/manual/imm-E3.4.litmus,0 +litmus/OPENCL/portedFromC11/manual/RWC-sc-acq-sc-sc-sc.litmus,0 +litmus/OPENCL/portedFromC11/manual/imm-E3.8.litmus,1 +litmus/OPENCL/portedFromC11/manual/imm-E3.8-alt.litmus,1 +litmus/OPENCL/portedFromC11/manual/imm-E3.6.litmus,1 +litmus/OPENCL/portedFromC11/manual/mp_relacq.litmus,0 +litmus/OPENCL/portedFromC11/manual/iriw_sc.litmus,0 +litmus/OPENCL/portedFromC11/manual/imm-E3.3.litmus,1 +litmus/OPENCL/portedFromC11/manual/imm-E3.1.litmus,0 +litmus/OPENCL/portedFromC11/manual/cppmem_iriw_relacq.litmus,1 +litmus/OPENCL/portedFromC11/manual/imm-E3.5.litmus,1 +litmus/OPENCL/portedFromC11/manual/imm-E3.9.litmus,0 +litmus/OPENCL/portedFromC11/manual/imm-R2.litmus,0 +litmus/OPENCL/portedFromC11/manual/example1.litmus,0 +litmus/OPENCL/portedFromC11/manual/imm-R2-alt.litmus,1 +litmus/OPENCL/portedFromC11/manual/mp_relaxed.litmus,1 +litmus/OPENCL/portedFromC11/manual/IRIW-sc-sc-acq-sc-acq-sc.litmus,0 +litmus/OPENCL/portedFromC11/manual/imm-E3.7.litmus,0 diff --git a/litmus/OPENCL/herd/2+2W.litmus b/litmus/OPENCL/herd/2+2W.litmus new file mode 100644 index 0000000000..0594f64583 --- /dev/null +++ b/litmus/OPENCL/herd/2+2W.litmus @@ -0,0 +1,22 @@ +OPENCL 2+2W_xaG_yaG_sc--sc_sc--sc_0||1 + +(* + * https://github.com/herd/legacy/blob/master/herdtools/herd/testsuite/OpenCLTests/2%2B2W/2%2B2W_xaG_yaG_sc--sc_sc--sc_0%7C%7C1.litmus + *) + +{ + [x]=0; + [y]=0; +} + +P0@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + atomic_store(x,2); + atomic_store(y,1); +} + +P1@wg 1, dev 0 (global atomic_int* x, global atomic_int* y) { + atomic_store(y,2); + atomic_store(x,1); +} + +exists (x=1 /\ y=0) \ No newline at end of file diff --git a/litmus/OPENCL/herd/3.2W.litmus b/litmus/OPENCL/herd/3.2W.litmus new file mode 100644 index 0000000000..32fdadf497 --- /dev/null +++ b/litmus/OPENCL/herd/3.2W.litmus @@ -0,0 +1,30 @@ +OPENCL 3.2W_xaG_yaG_zaG_sc--sc_rel[wg]-LFsc-rel_rel-GFrel[dev]-acq[wg]_0||1|2 + +(* + * https://github.com/herd/legacy/blob/master/herdtools/herd/testsuite/OpenCLTests/3.2W/3.2W_xaG_yaG_zaG_sc--sc_rel%5Bwg%5D-LFsc-rel_rel-GFrel%5Bdev%5D-acq%5Bwg%5D_0%7C%7C1%7C2.litmus + *) + +{ + [x]=0; + [y]=0; + [z]=0; +} + +P0@wg 0, dev 0 (global atomic_int* x, global atomic_int* y, global atomic_int* z) { + atomic_store(x,2); + atomic_store(y,1); +} + +P1@wg 1, dev 0 (global atomic_int* x, global atomic_int* y, global atomic_int* z) { + atomic_store_explicit(y,2,memory_order_release,memory_scope_work_group); + atomic_work_item_fence(CLK_LOCAL_MEM_FENCE,memory_order_seq_cst,memory_scope_work_group); + atomic_store_explicit(z,1,memory_order_release); +} + +P2@wg 1, dev 0 (global atomic_int* x, global atomic_int* y, global atomic_int* z) { + atomic_store_explicit(z,2,memory_order_release); + atomic_work_item_fence(CLK_GLOBAL_MEM_FENCE,memory_order_release,memory_scope_device); + atomic_store_explicit(x,1,memory_order_release,memory_scope_work_group); // original mo: acq +} + +exists (x=2 /\ y=2 /\ z=2) \ No newline at end of file diff --git a/litmus/OPENCL/herd/3LB.litmus b/litmus/OPENCL/herd/3LB.litmus new file mode 100644 index 0000000000..12d6c5dfc0 --- /dev/null +++ b/litmus/OPENCL/herd/3LB.litmus @@ -0,0 +1,28 @@ +OPENCL 3LB_xaG_yaG_zaG_sc--sc_na--sc_sc--sc_0|1||2 + +(* + * https://github.com/herd/legacy/blob/master/herdtools/herd/testsuite/OpenCLTests/3LB/3LB_xaG_yaG_zaG_sc--sc_na--sc_sc--sc_0%7C1%7C%7C2.litmus + *) + +{ + [x]=0; + [y]=0; + [z]=0; +} + +P0@wg 0, dev 0 (global atomic_int* x, global atomic_int* y, global atomic_int* z) { + int r0 = atomic_load(x); + atomic_store(y,1); +} + +P1@wg 0, dev 0 (global atomic_int* x, global atomic_int* y, global atomic_int* z) { + int r1 = atomic_load(y); + atomic_store(z,1); +} + +P2@wg 1, dev 0 (global atomic_int* x, global atomic_int* y, global atomic_int* z) { + int r2 = atomic_load(z); + atomic_store(x,1); +} + +exists (0:r0=1 /\ 1:r1=1 /\ 2:r2=1) \ No newline at end of file diff --git a/litmus/OPENCL/herd/CT_wsq1.litmus b/litmus/OPENCL/herd/CT_wsq1.litmus new file mode 100644 index 0000000000..d1055833db --- /dev/null +++ b/litmus/OPENCL/herd/CT_wsq1.litmus @@ -0,0 +1,31 @@ +OPENCL CT_wsq1 + +(* + * https://github.com/herd/legacy/blob/master/herdtools/herd/testsuite/OpenCLTests/CT_wsq/CT_wsq1.litmus + *) + +{ + [tail_p]=0; + [head_p]=0; + [d]=0; + [val]=0; +} + +P0@wg 0, dev 0 (global atomic_int* tail_p, global atomic_int* head_p, global int* d, global int* val) { + int tmp_tail = atomic_load_explicit(tail_p, memory_order_acquire, memory_scope_device); + *d = 1; + tmp_tail = 1; //tmp_tail++; + atomic_store_explicit(tail_p, tmp_tail, memory_order_release, memory_scope_device); +} + +P1@wg 0, dev 0 (global atomic_int* tail_p, global atomic_int* head_p, global int* d, global int* val) { + int localTail; + int oldHead; + oldHead = atomic_load_explicit(head_p, memory_order_acquire, memory_scope_device); + localTail = atomic_load_explicit(tail_p, memory_order_acquire, memory_scope_device); + if (localTail == 1) { + *val = *d; + } +} + +exists (1:localTail=1 /\ val=0) \ No newline at end of file diff --git a/litmus/OPENCL/herd/CT_wsq2.litmus b/litmus/OPENCL/herd/CT_wsq2.litmus new file mode 100644 index 0000000000..8909925e8a --- /dev/null +++ b/litmus/OPENCL/herd/CT_wsq2.litmus @@ -0,0 +1,41 @@ +OPENCL CT_wsq2 + +(* + * https://github.com/herd/legacy/blob/master/herdtools/herd/testsuite/OpenCLTests/CT_wsq/CT_wsq2.litmus + *) + +{ + [tail_p]=0; + [head_p]=0; + [oldHead_p]=0; + [d]=0; +} + +P0@wg 0, dev 0 (global atomic_int* head_p, global atomic_int* tail_p, int* oldHead_p, global int* d) { + + // POP: + int newHead = 1; + + int tmp = atomic_compare_exchange_strong_explicit(head_p, oldHead_p, newHead, memory_order_release, memory_order_release, memory_scope_device); + if (tmp) { + // return + } else { + atomic_store_explicit(head_p, newHead, memory_order_release, memory_scope_device); + } + + // PUSH: + int tmp_tail = atomic_load_explicit(tail_p, memory_order_acquire, memory_scope_device); +} + +P1@wg 0, dev 0 (global atomic_int* head_p, global atomic_int* tail_p, int* oldHead_p, global int* d) { + + // STEAL: + int localTail; + localTail = atomic_load_explicit(tail_p, memory_order_acquire, memory_scope_device); + if (localTail != *oldHead_p) { + int val = *d; + int tmp1 = atomic_compare_exchange_strong_explicit(head_p, oldHead_p, 1, memory_order_release, memory_order_release, memory_scope_device); // original: without tmp1 + } +} + +exists (0:tmp=1 /\ 1:localTail=1) \ No newline at end of file diff --git a/litmus/OPENCL/herd/IRIW.litmus b/litmus/OPENCL/herd/IRIW.litmus new file mode 100644 index 0000000000..4420180cb1 --- /dev/null +++ b/litmus/OPENCL/herd/IRIW.litmus @@ -0,0 +1,30 @@ +OPENCL IRIW_sc_sc_sc-sc_sc-sc_xaG_yaG_P0_P1_P2_P3 + +(* + * https://github.com/herd/legacy/blob/master/herdtools/herd/testsuite/OpenCLTests/IRIW/IRIW_sc_sc_sc-sc_sc-sc_xaG_yaG_P0_P1_P2_P3.litmus + *) + +{ + [x]=0; + [y]=0; +} + +P0@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + atomic_store(x,1); +} + +P1@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + atomic_store(y,1); +} + +P2@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + int r0 = atomic_load(x); + int r1 = atomic_load(y); +} + +P3@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + int r2 = atomic_load(y); + int r3 = atomic_load(x); +} + +exists (2:r0=1 /\ 2:r1=0 /\ 3:r2=1 /\ 3:r3=0) \ No newline at end of file diff --git a/litmus/OPENCL/herd/ISA2.litmus b/litmus/OPENCL/herd/ISA2.litmus new file mode 100644 index 0000000000..6fe2058cdb --- /dev/null +++ b/litmus/OPENCL/herd/ISA2.litmus @@ -0,0 +1,29 @@ +OPENCL ISA2 + +(* + * PodWW Rfe PodRR Fre + * https://github.com/herd/legacy/blob/master/herdtools/herd/testsuite/OpenCLTests/ISA2/ISA2.litmus + *) + +{ +[x] = 0; +[y] = 0; +[z] = 0; +} + +P0@wg 0, dev 0 (volatile int* y, volatile int* x) { + *x = 1; + *y = 1; +} + +P1@wg 1, dev 0 (volatile int* y, volatile int* z) { + int r0 = *y; + *z = 1; +} + +P2@wg 2, dev 0 (volatile int* z, volatile int* x) { + int r1 = *z; + int r2 = *x; +} + +exists (1:r0=1 /\ 2:r1=1 /\ 2:r2=0) \ No newline at end of file diff --git a/litmus/OPENCL/herd/ISA3.litmus b/litmus/OPENCL/herd/ISA3.litmus new file mode 100644 index 0000000000..c297481cab --- /dev/null +++ b/litmus/OPENCL/herd/ISA3.litmus @@ -0,0 +1,28 @@ +OPENCL ISA2_sc-sc_sc-sc_sc-sc_xaG_yaG_zaG_P0_P1_P2 + +(* + * https://github.com/herd/legacy/blob/master/herdtools/herd/testsuite/OpenCLTests/ISA2/ISA2_sc-sc_sc-sc_sc-sc_xaG_yaG_zaG_P0_P1_P2.litmus + *) + +{ + [x]=0; + [y]=0; + [z]=0; +} + +P0@wg 0, dev 0 (global atomic_int* x, global atomic_int* y, global atomic_int* z) { + atomic_store(x,1); + atomic_store(y,1); +} + +P1@wg 0, dev 0 (global atomic_int* x, global atomic_int* y, global atomic_int* z) { + int r0 = atomic_load(y); + atomic_store(z,1); +} + +P2@wg 0, dev 0 (global atomic_int* x, global atomic_int* y, global atomic_int* z) { + int r1 = atomic_load(z); + int r2 = atomic_load(x); +} + +exists (1:r0=1 /\ 2:r1=1 /\ 2:r2=0) \ No newline at end of file diff --git a/litmus/OPENCL/herd/LB.litmus b/litmus/OPENCL/herd/LB.litmus new file mode 100644 index 0000000000..8bd152acf0 --- /dev/null +++ b/litmus/OPENCL/herd/LB.litmus @@ -0,0 +1,23 @@ +OPENCL LB + +(* + * PodWW Rfe PodRR Fre + * https://github.com/herd/legacy/blob/master/herdtools/herd/testsuite/OpenCLTests/LB/LB.litmus + *) + +{ +[x] = 0; +[y] = 0; +} + +P0@wg 0, dev 0 (volatile int* y, volatile int* x) { + int r0 = *x; + *y = 1; +} + +P1@wg 1, dev 0 (volatile int* y, volatile int* x) { + int r1 = *y; + *x = 1; +} + +exists (0:r0=1 /\ 1:r1=1) \ No newline at end of file diff --git a/litmus/OPENCL/herd/MP.litmus b/litmus/OPENCL/herd/MP.litmus new file mode 100644 index 0000000000..fd715f2e62 --- /dev/null +++ b/litmus/OPENCL/herd/MP.litmus @@ -0,0 +1,23 @@ +OPENCL MP_rlx_1FG-sc-all_rlx_xaG_yaG_P0_P1 + +(* + * https://github.com/herd/legacy/blob/master/herdtools/herd/testsuite/OpenCLTests/MP/MP_rlx_1FG-sc-all_rlx_xaG_yaG_P0_P1.litmus + *) + +{ + [x]=0; + [y]=0; +} + +P0@wg 0, dev 0 (global int* x, global atomic_int* y) { + *x = 1; + atomic_work_item_fence(CLK_GLOBAL_MEM_FENCE,memory_order_seq_cst,memory_scope_all_svm_devices); + atomic_store_explicit(y,1,memory_order_relaxed); +} + +P1@wg 0, dev 0 (global int* x, global atomic_int* y) { + int r0 = atomic_load_explicit(y,memory_order_relaxed); + int r1 = *x; +} + +exists (1:r0=1 /\ 1:r1=0) \ No newline at end of file diff --git a/litmus/OPENCL/herd/R.litmus b/litmus/OPENCL/herd/R.litmus new file mode 100644 index 0000000000..b690b74068 --- /dev/null +++ b/litmus/OPENCL/herd/R.litmus @@ -0,0 +1,22 @@ +OPENCL R_xaG_yaG_sc--sc_sc--sc_0||1 + +(* + * https://github.com/herd/legacy/blob/master/herdtools/herd/testsuite/OpenCLTests/R/R_xaG_yaG_sc--sc_sc--sc_0%7C%7C1.litmus + *) + +{ + [x]=0; + [y]=0; +} + +P0@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + atomic_store(x,1); + atomic_store(y,1); +} + +P1@wg 1, dev 0 (global atomic_int* x, global atomic_int* y) { + atomic_store(y,2); + int r0 = atomic_load(x); +} + +exists (1:r0=0) \ No newline at end of file diff --git a/litmus/OPENCL/herd/README.md b/litmus/OPENCL/herd/README.md new file mode 100644 index 0000000000..db92cf254f --- /dev/null +++ b/litmus/OPENCL/herd/README.md @@ -0,0 +1 @@ +The tests in this folder were manually written using the tests from the [herd](https://github.com/herd/legacy/tree/master/herdtools/herd/testsuite/OpenCLTests) repository as a guide. \ No newline at end of file diff --git a/litmus/OPENCL/herd/RWC.litmus b/litmus/OPENCL/herd/RWC.litmus new file mode 100644 index 0000000000..3695404550 --- /dev/null +++ b/litmus/OPENCL/herd/RWC.litmus @@ -0,0 +1,29 @@ +OPENCL RWC_xaG_yaG_sc-_rel[wg]-LFsc-rel_rel-GFrel[dev]-acq[wg]_0||1|2 + +(* + * https://github.com/herd/legacy/blob/master/herdtools/herd/testsuite/OpenCLTests/RWC/RWC_xaG_yaG_sc-_rel%5Bwg%5D-LFsc-rel_rel-GFrel%5Bdev%5D-acq%5Bwg%5D_0%7C%7C1%7C2.litmus + *) + +{ + [x]=0; + [y]=0; +} + +P0@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + atomic_store(x,1); + +} + +P1@wg 1, dev 0 (global atomic_int* x, global atomic_int* y) { + int r0 = atomic_load_explicit(x,memory_order_acquire,memory_scope_work_group); // original: release + atomic_work_item_fence(CLK_LOCAL_MEM_FENCE,memory_order_seq_cst,memory_scope_work_group); + int r1 = atomic_load_explicit(y,memory_order_acquire); // original: release +} + +P2@wg 1, dev 0 (global atomic_int* x, global atomic_int* y) { + atomic_store_explicit(y,1,memory_order_release); + atomic_work_item_fence(CLK_GLOBAL_MEM_FENCE,memory_order_release,memory_scope_device); + int r2 = atomic_load_explicit(x,memory_order_acquire,memory_scope_work_group); +} + +exists (1:r0=1 /\ 1:r1=0 /\ 2:r2=0) \ No newline at end of file diff --git a/litmus/OPENCL/herd/S.litmus b/litmus/OPENCL/herd/S.litmus new file mode 100644 index 0000000000..a457037514 --- /dev/null +++ b/litmus/OPENCL/herd/S.litmus @@ -0,0 +1,24 @@ +OPENCL S_xaG_yaG_rel[wg]-LFsc-rel_rel-GFrel[dev]-acq[wg]_0||1 + +(* + * https://github.com/herd/legacy/blob/master/herdtools/herd/testsuite/OpenCLTests/S/S_xaG_yaG_rel%5Bwg%5D-LFsc-rel_rel-GFrel%5Bdev%5D-acq%5Bwg%5D_0%7C%7C1.litmus + *) + +{ + [x]=0; + [y]=0; +} + +P0@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + atomic_store_explicit(x,2,memory_order_release,memory_scope_work_group); + atomic_work_item_fence(CLK_LOCAL_MEM_FENCE,memory_order_seq_cst,memory_scope_work_group); + atomic_store_explicit(y,1,memory_order_release); +} + +P1@wg 1, dev 0 (global atomic_int* x, global atomic_int* y) { + int r0 = atomic_load_explicit(y,memory_order_acquire); // original: release + atomic_work_item_fence(CLK_GLOBAL_MEM_FENCE,memory_order_release,memory_scope_device); + atomic_store_explicit(x,1,memory_order_release,memory_scope_work_group); // original: acquire +} + +exists (1:r0=1) \ No newline at end of file diff --git a/litmus/OPENCL/herd/SB.litmus b/litmus/OPENCL/herd/SB.litmus new file mode 100644 index 0000000000..d879bfdccf --- /dev/null +++ b/litmus/OPENCL/herd/SB.litmus @@ -0,0 +1,23 @@ +OPENCL SB + +(* + * PodWW Rfe PodRR Fre + * https://github.com/herd/legacy/blob/master/herdtools/herd/testsuite/OpenCLTests/SB/SB.litmus + *) + +{ +[x] = 0; +[y] = 0; +} + +P0@wg 0, dev 0 (volatile int* x, volatile int* y) { + *x = 1; + int r0 = *y; +} + +P1@wg 1, dev 0 (volatile int* x, volatile int* y) { + *y = 1; + int r1 = *x; +} + +exists (0:r0=0 /\ 1:r1=0) \ No newline at end of file diff --git a/litmus/OPENCL/herd/SB1.litmus b/litmus/OPENCL/herd/SB1.litmus new file mode 100644 index 0000000000..6eb863b30a --- /dev/null +++ b/litmus/OPENCL/herd/SB1.litmus @@ -0,0 +1,24 @@ +OPENCL SB_xaG_yaG_rel[wg]-LFsc-rel_rel-GFrel[dev]-acq[wg]_0||1 + +(* + * https://github.com/herd/legacy/blob/master/herdtools/herd/testsuite/OpenCLTests/SB/SB_xaG_yaG_rel%5Bwg%5D-LFsc-rel_rel-GFrel%5Bdev%5D-acq%5Bwg%5D_0%7C%7C1.litmus + *) + +{ + [x]=0; + [y]=0; +} + +P0@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + atomic_store_explicit(x,1,memory_order_release,memory_scope_work_group); + atomic_work_item_fence(CLK_LOCAL_MEM_FENCE,memory_order_seq_cst,memory_scope_work_group); + int r0 = atomic_load_explicit(y,memory_order_acquire); // original: release +} + +P1@wg 1, dev 0 (global atomic_int* x, global atomic_int* y) { + atomic_store_explicit(y,1,memory_order_release); + atomic_work_item_fence(CLK_GLOBAL_MEM_FENCE,memory_order_release,memory_scope_device); + int r1 = atomic_load_explicit(x,memory_order_acquire,memory_scope_work_group); +} + +exists (0:r0=0 /\ 1:r1=0) \ No newline at end of file diff --git a/litmus/OPENCL/herd/WRC.litmus b/litmus/OPENCL/herd/WRC.litmus new file mode 100644 index 0000000000..c6980218de --- /dev/null +++ b/litmus/OPENCL/herd/WRC.litmus @@ -0,0 +1,29 @@ +OPENCL WRC_xaG_yaG_sc-_rel[wg]-LFsc-rel_rel-GFrel[dev]-acq[wg]_0||1|2 + +(* + * https://github.com/herd/legacy/blob/master/herdtools/herd/testsuite/OpenCLTests/WRC/WRC_xaG_yaG_sc-_rel%5Bwg%5D-LFsc-rel_rel-GFrel%5Bdev%5D-acq%5Bwg%5D_0%7C%7C1%7C2.litmus + *) + +{ + [x]=0; + [y]=0; +} + +P0@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + atomic_store(x,1); + +} + +P1@wg 1, dev 0 (global atomic_int* x, global atomic_int* y) { + int r0 = atomic_load_explicit(x,memory_order_acquire,memory_scope_work_group); // original: release + atomic_work_item_fence(CLK_LOCAL_MEM_FENCE,memory_order_seq_cst,memory_scope_work_group); + atomic_store_explicit(y,1,memory_order_release); +} + +P2@wg 1, dev 0 (global atomic_int* x, global atomic_int* y) { + int r1 = atomic_load_explicit(y,memory_order_acquire); // original: release + atomic_work_item_fence(CLK_GLOBAL_MEM_FENCE,memory_order_release,memory_scope_device); + int r2 = atomic_load_explicit(x,memory_order_acquire,memory_scope_work_group); +} + +exists (1:r0=1 /\ 2:r1=1 /\ 2:r2=0) \ No newline at end of file diff --git a/litmus/OPENCL/herd/barrier_example.litmus b/litmus/OPENCL/herd/barrier_example.litmus new file mode 100644 index 0000000000..e9e38f2fda --- /dev/null +++ b/litmus/OPENCL/herd/barrier_example.litmus @@ -0,0 +1,24 @@ +OPENCL barrier_example + +(* + * https://github.com/herd/legacy/blob/master/herdtools/herd/testsuite/OpenCLTests/barrier_example.litmus + *) + +{ + [x]=0; + [y]=0; +} + +P0@wg 0, dev 0 (global int* x, global int* y) { + atomic_store_explicit(x, 1, memory_order_release); + B1: barrier(CLK_GLOBAL_MEM_FENCE); + int x1 = atomic_load_explicit(y, memory_order_acquire); // original: without x1 +} + +P1@wg 0, dev 0 (global int* x, global int* y) { + atomic_store_explicit(y, 1, memory_order_release); + B1: barrier(CLK_GLOBAL_MEM_FENCE); + int y1 = atomic_load_explicit(x, memory_order_acquire); // original: without y1 +} + +exists (0:x=0 /\ 1:y=0) \ No newline at end of file diff --git a/litmus/OPENCL/herd/global_barrier.litmus b/litmus/OPENCL/herd/global_barrier.litmus new file mode 100644 index 0000000000..b21f526140 --- /dev/null +++ b/litmus/OPENCL/herd/global_barrier.litmus @@ -0,0 +1,120 @@ +OPENCL global_barrier + +(* + * https://github.com/herd/legacy/blob/master/herdtools/herd/testsuite/OpenCLTests/global_barrier.litmus + *) + +{ + [f0] = 0; + [f1] = 0; + [tyler] = 0; +} + +P0@wg 0, dev 0 (global atomic_int* f0, global atomic_int* f1) { // slave wg0, wi0 + B1: barrier(CLK_GLOBAL_MEM_FENCE); + + atomic_store_explicit(f0, 1, memory_order_release); + + atomic_work_item_fence(CLK_LOCAL_MEM_FENCE, memory_order_relaxed, memory_scope_work_group); + + atomic_work_item_fence(CLK_LOCAL_MEM_FENCE, memory_order_relaxed, memory_scope_work_group); + + atomic_work_item_fence(CLK_LOCAL_MEM_FENCE, memory_order_relaxed, memory_scope_work_group); + + atomic_work_item_fence(CLK_LOCAL_MEM_FENCE, memory_order_relaxed, memory_scope_work_group); + + int r2 = atomic_load_explicit(f0, memory_order_acquire); + + B3: barrier(CLK_GLOBAL_MEM_FENCE); +} + +P1@wg 0, dev 0 (global atomic_int* f0, global atomic_int* f1, global int* tyler) { // slave wg0, wi1 + + *tyler = 1; + + B1: barrier(CLK_GLOBAL_MEM_FENCE); + + atomic_work_item_fence(CLK_LOCAL_MEM_FENCE, memory_order_relaxed, memory_scope_work_group); + + atomic_work_item_fence(CLK_LOCAL_MEM_FENCE, memory_order_relaxed, memory_scope_work_group); + + atomic_work_item_fence(CLK_LOCAL_MEM_FENCE, memory_order_relaxed, memory_scope_work_group); + + atomic_work_item_fence(CLK_LOCAL_MEM_FENCE, memory_order_relaxed, memory_scope_work_group); + + atomic_work_item_fence(CLK_LOCAL_MEM_FENCE, memory_order_relaxed, memory_scope_work_group); + + atomic_work_item_fence(CLK_LOCAL_MEM_FENCE, memory_order_relaxed, memory_scope_work_group); + + B3: barrier(CLK_GLOBAL_MEM_FENCE); + +} + +P2@wg 1, dev 0 (global atomic_int* f0, global atomic_int* f1) { // master wg, wi0 + + atomic_work_item_fence(CLK_LOCAL_MEM_FENCE, memory_order_relaxed, memory_scope_work_group); + + atomic_work_item_fence(CLK_LOCAL_MEM_FENCE, memory_order_relaxed, memory_scope_work_group); + + int r0 = atomic_load_explicit(f0, memory_order_acquire); + + B2: barrier(CLK_GLOBAL_MEM_FENCE); + + atomic_store_explicit(f0, 0, memory_order_release); +} + +P3@wg 1, dev 0 (global atomic_int* f0, global atomic_int* f1) { // master wg, wi1 + + atomic_work_item_fence(CLK_LOCAL_MEM_FENCE, memory_order_relaxed, memory_scope_work_group); + + atomic_work_item_fence(CLK_LOCAL_MEM_FENCE, memory_order_relaxed, memory_scope_work_group); + + int r1 = atomic_load_explicit(f1, memory_order_acquire); + + B2: barrier(CLK_GLOBAL_MEM_FENCE); + + atomic_store_explicit(f1, 0, memory_order_release); +} + + + +P4@wg 2, dev 0 (global atomic_int* f0, global atomic_int* f1) { // slave wg1, wi0 + B11: barrier(CLK_GLOBAL_MEM_FENCE); + + atomic_store_explicit(f1, 1, memory_order_release); + + atomic_work_item_fence(CLK_LOCAL_MEM_FENCE, memory_order_relaxed, memory_scope_work_group); + + atomic_work_item_fence(CLK_LOCAL_MEM_FENCE, memory_order_relaxed, memory_scope_work_group); + + atomic_work_item_fence(CLK_LOCAL_MEM_FENCE, memory_order_relaxed, memory_scope_work_group); + + atomic_work_item_fence(CLK_LOCAL_MEM_FENCE, memory_order_relaxed, memory_scope_work_group); + + int r4 = atomic_load_explicit(f1, memory_order_acquire); + + B31: barrier(CLK_GLOBAL_MEM_FENCE); +} + +P5@wg 2, dev 0 (global atomic_int* f0, global atomic_int* f1, global int* tyler) { // slave wg1, wi1 + B11: barrier(CLK_GLOBAL_MEM_FENCE); + + atomic_work_item_fence(CLK_LOCAL_MEM_FENCE, memory_order_relaxed, memory_scope_work_group); + + atomic_work_item_fence(CLK_LOCAL_MEM_FENCE, memory_order_relaxed, memory_scope_work_group); + + atomic_work_item_fence(CLK_LOCAL_MEM_FENCE, memory_order_relaxed, memory_scope_work_group); + + atomic_work_item_fence(CLK_LOCAL_MEM_FENCE, memory_order_relaxed, memory_scope_work_group); + + atomic_work_item_fence(CLK_LOCAL_MEM_FENCE, memory_order_relaxed, memory_scope_work_group); + + atomic_work_item_fence(CLK_LOCAL_MEM_FENCE, memory_order_relaxed, memory_scope_work_group); + + B31: barrier(CLK_GLOBAL_MEM_FENCE); + + int r5 = *tyler; + +} + +exists (2:r0=1 /\ 3:r1=1 /\ 0:r2=0 /\ 4:r4=0) \ No newline at end of file diff --git a/litmus/OPENCL/herd/global_barrier_mo.litmus b/litmus/OPENCL/herd/global_barrier_mo.litmus new file mode 100644 index 0000000000..d43c1aa014 --- /dev/null +++ b/litmus/OPENCL/herd/global_barrier_mo.litmus @@ -0,0 +1,116 @@ +OPENCL global_barrier + +(* + * https://github.com/herd/legacy/blob/master/herdtools/herd/testsuite/OpenCLTests/global_barrier_mo.litmus + *) + +{ + [f0] = 0; + [f1] = 0; + [g0] = 0; + [g1] = 0; +} + +P0@wg 0, dev 0 (global int* f0, global int* f1, global int* g0, global int* g1) { // slave wg0, wi0 + B1: barrier(CLK_GLOBAL_MEM_FENCE); + + atomic_store_explicit(f0, 1, memory_order_release); + + atomic_work_item_fence(CLK_LOCAL_MEM_FENCE, memory_order_relaxed, memory_scope_work_group); + + atomic_work_item_fence(CLK_LOCAL_MEM_FENCE, memory_order_relaxed, memory_scope_work_group); + + atomic_work_item_fence(CLK_LOCAL_MEM_FENCE, memory_order_relaxed, memory_scope_work_group); + + atomic_work_item_fence(CLK_LOCAL_MEM_FENCE, memory_order_relaxed, memory_scope_work_group); + + int r2 = atomic_load_explicit(g0, memory_order_acquire); + + B3: barrier(CLK_GLOBAL_MEM_FENCE); +} + +P1@wg 0, dev 0 (global int* f0, global int* f1, global int* g0, global int* g1) { // slave wg0, wi1 + B1: barrier(CLK_GLOBAL_MEM_FENCE); + + atomic_work_item_fence(CLK_LOCAL_MEM_FENCE, memory_order_relaxed, memory_scope_work_group); + + atomic_work_item_fence(CLK_LOCAL_MEM_FENCE, memory_order_relaxed, memory_scope_work_group); + + atomic_work_item_fence(CLK_LOCAL_MEM_FENCE, memory_order_relaxed, memory_scope_work_group); + + atomic_work_item_fence(CLK_LOCAL_MEM_FENCE, memory_order_relaxed, memory_scope_work_group); + + atomic_work_item_fence(CLK_LOCAL_MEM_FENCE, memory_order_relaxed, memory_scope_work_group); + + atomic_work_item_fence(CLK_LOCAL_MEM_FENCE, memory_order_relaxed, memory_scope_work_group); + + B3: barrier(CLK_GLOBAL_MEM_FENCE); + +} + +P2@wg 1, dev 0 (global int* f0, global int* f1, global int* g0, global int* g1) { // master wg, wi0 + + atomic_work_item_fence(CLK_LOCAL_MEM_FENCE, memory_order_relaxed, memory_scope_work_group); + + atomic_work_item_fence(CLK_LOCAL_MEM_FENCE, memory_order_relaxed, memory_scope_work_group); + + int r0 = atomic_load_explicit(f0, memory_order_acquire); + + B2: barrier(CLK_GLOBAL_MEM_FENCE); + + atomic_store_explicit(g0, 1, memory_order_release); +} + +P3@wg 1, dev 0 (global int* f0, global int* f1, global int* g0, global int* g1) { // master wg, wi1 + + atomic_work_item_fence(CLK_LOCAL_MEM_FENCE, memory_order_relaxed, memory_scope_work_group); + + atomic_work_item_fence(CLK_LOCAL_MEM_FENCE, memory_order_relaxed, memory_scope_work_group); + + int r1 = atomic_load_explicit(f1, memory_order_acquire); + + B2: barrier(CLK_GLOBAL_MEM_FENCE); + + atomic_store_explicit(g1, 1, memory_order_release); +} + + + +P4@wg 2, dev 0 (global int* f0, global int* f1, global int* g0, global int* g1) { // slave wg1, wi0 + B11: barrier(CLK_GLOBAL_MEM_FENCE); + + atomic_store_explicit(f1, 1, memory_order_release); + + atomic_work_item_fence(CLK_LOCAL_MEM_FENCE, memory_order_relaxed, memory_scope_work_group); + + atomic_work_item_fence(CLK_LOCAL_MEM_FENCE, memory_order_relaxed, memory_scope_work_group); + + atomic_work_item_fence(CLK_LOCAL_MEM_FENCE, memory_order_relaxed, memory_scope_work_group); + + atomic_work_item_fence(CLK_LOCAL_MEM_FENCE, memory_order_relaxed, memory_scope_work_group); + + int r4 = atomic_load_explicit(g1, memory_order_acquire); + + B31: barrier(CLK_GLOBAL_MEM_FENCE); +} + +P5@wg 2, dev 0 (global int* f0, global int* f1, global int* g0, global int* g1) { // slave wg1, wi1 + B11: barrier(CLK_GLOBAL_MEM_FENCE); + + atomic_work_item_fence(CLK_LOCAL_MEM_FENCE, memory_order_relaxed, memory_scope_work_group); + + atomic_work_item_fence(CLK_LOCAL_MEM_FENCE, memory_order_relaxed, memory_scope_work_group); + + atomic_work_item_fence(CLK_LOCAL_MEM_FENCE, memory_order_relaxed, memory_scope_work_group); + + atomic_work_item_fence(CLK_LOCAL_MEM_FENCE, memory_order_relaxed, memory_scope_work_group); + + atomic_work_item_fence(CLK_LOCAL_MEM_FENCE, memory_order_relaxed, memory_scope_work_group); + + atomic_work_item_fence(CLK_LOCAL_MEM_FENCE, memory_order_relaxed, memory_scope_work_group); + + B31: barrier(CLK_GLOBAL_MEM_FENCE); + +} + +exists (2:r0=1 /\ 3:r1=1 /\ 0:r2=1 /\ 4:r4=1 ) \ No newline at end of file diff --git a/litmus/OPENCL/herd/old/MP_dr.litmus b/litmus/OPENCL/herd/old/MP_dr.litmus new file mode 100644 index 0000000000..95bea74a0b --- /dev/null +++ b/litmus/OPENCL/herd/old/MP_dr.litmus @@ -0,0 +1,22 @@ +OPENCL MP_dr + +(* + * https://github.com/herd/legacy/blob/master/herdtools/herd/testsuite/oldOpenCLTests/MP_dr.litmus + *) + +{ +[x] = 0; +[y] = 0; +} + +P0@wg 0, dev 0 (local int* x, global atomic_int* y) { + *x = 1; + atomic_store_explicit(y, 1, memory_order_release, memory_scope_work_group); +} + +P1@wg 1, dev 0 (local int* x, global atomic_int* y) { + int r1 = atomic_load_explicit(y, memory_order_acquire, memory_scope_work_group); // original: release + int r2 = *x; +} + +exists (1:r1=1 /\ 1:r2=0) \ No newline at end of file diff --git a/litmus/OPENCL/herd/old/MP_relacq.litmus b/litmus/OPENCL/herd/old/MP_relacq.litmus new file mode 100644 index 0000000000..2a9b7c4c85 --- /dev/null +++ b/litmus/OPENCL/herd/old/MP_relacq.litmus @@ -0,0 +1,23 @@ +OPENCL MP_relacq + +(* + * Fre PodWR Fre PodWR + * https://github.com/herd/legacy/blob/master/herdtools/herd/testsuite/oldOpenCLTests/MP_relacq.litmus + *) + +{ +[x] = 0; +[y] = 0; +} + +P0@wg 0, dev 0 (global int* x, local atomic_int* y) { + *x = 1; + atomic_store_explicit(y, 1, memory_order_release, memory_scope_work_group); +} + +P1@wg 1, dev 0 (global int* x, local atomic_int* y) { + int r1 = atomic_load_explicit(y, memory_order_acquire, memory_scope_work_group); + int r2 = *x; +} + +exists (1:r1=1 /\ 1:r2=0) \ No newline at end of file diff --git a/litmus/OPENCL/herd/old/MP_relaxed.litmus b/litmus/OPENCL/herd/old/MP_relaxed.litmus new file mode 100644 index 0000000000..259ba8d471 --- /dev/null +++ b/litmus/OPENCL/herd/old/MP_relaxed.litmus @@ -0,0 +1,23 @@ +OPENCL MP_relaxed + +(* + * Fre PodWR Fre PodWR + * https://github.com/herd/legacy/blob/master/herdtools/herd/testsuite/oldOpenCLTests/MP_relaxed.litmus + *) + +{ +[x] = 0; +[y] = 0; +} + +P0@wg 0, dev 0 (global atomic_int* x, local atomic_int* y) { + atomic_store_explicit(x, 1, memory_order_relaxed, memory_scope_work_group); + atomic_store_explicit(y, 1, memory_order_relaxed, memory_scope_work_group); +} + +P1@wg 1, dev 0 (global atomic_int* x, local atomic_int* y) { + int r1 = atomic_load_explicit(y, memory_order_relaxed, memory_scope_work_group); + int r2 = atomic_load_explicit(x, memory_order_relaxed, memory_scope_work_group); +} + +exists (1:r1=1 /\ 1:r2=0) \ No newline at end of file diff --git a/litmus/OPENCL/herd/old/MP_relseq.litmus b/litmus/OPENCL/herd/old/MP_relseq.litmus new file mode 100644 index 0000000000..71d99556b9 --- /dev/null +++ b/litmus/OPENCL/herd/old/MP_relseq.litmus @@ -0,0 +1,24 @@ +OPENCL MP_relseq + +(* + * Fre PodWR Fre PodWR + * https://github.com/herd/legacy/blob/master/herdtools/herd/testsuite/oldOpenCLTests/MP_relseq.litmus + *) + +{ +[x] = 0; +[y] = 0; +} + +P0@wg 0, dev 0 (local int* x, global atomic_int* y) { + *x = 1; + atomic_store_explicit(y, 1, memory_order_release, memory_scope_work_group); + atomic_store_explicit(y, 2, memory_order_relaxed, memory_scope_work_group); +} + +P1@wg 1, dev 0 (local int* x, global atomic_int* y) { + int r1 = atomic_load_explicit(y, memory_order_relaxed, memory_scope_work_group); + int r2 = *x; +} + +exists (1:r1=2 /\ 1:r2=0) \ No newline at end of file diff --git a/litmus/OPENCL/herd/thinair.litmus b/litmus/OPENCL/herd/thinair.litmus new file mode 100644 index 0000000000..7ddb68b6c4 --- /dev/null +++ b/litmus/OPENCL/herd/thinair.litmus @@ -0,0 +1,22 @@ +OPENCL thinair + +(* + * https://github.com/herd/legacy/blob/master/herdtools/herd/testsuite/OpenCLTests/thinair.litmus + *) + +{ + [x]=0; + [y]=0; +} + +P0@wg 0, dev 0 (global atomic_int* x, local atomic_int* y) { + int t = atomic_load_explicit(y, memory_order_acquire); + atomic_store_explicit(x, t, memory_order_release); +} + +P1@wg 1, dev 0 (global atomic_int* x, local atomic_int* y) { + int t = atomic_load_explicit(x, memory_order_acquire); + atomic_store_explicit(y, t, memory_order_release); +} + +exists (x=42 /\ y=42) \ No newline at end of file diff --git a/litmus/OPENCL/overhauling/IRIW_sc_dev.litmus b/litmus/OPENCL/overhauling/IRIW_sc_dev.litmus new file mode 100644 index 0000000000..7a5428ef6a --- /dev/null +++ b/litmus/OPENCL/overhauling/IRIW_sc_dev.litmus @@ -0,0 +1,30 @@ +OPENCL IRIW_sc_dev + +(* + * https://multicore.doc.ic.ac.uk/overhauling/OpenCL/IRIW_sc_dev.litmus + *) + +{ +[x] = 0; +[y] = 0; +} + +P0@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + atomic_store_explicit(x, 1, memory_order_seq_cst, memory_scope_device); +} + +P1@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + atomic_store_explicit(y, 1, memory_order_seq_cst, memory_scope_device); +} + +P2@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + int r0 = atomic_load_explicit(x, memory_order_seq_cst, memory_scope_device); + int r1 = atomic_load_explicit(y, memory_order_seq_cst, memory_scope_device); +} + +P3@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + int r2 = atomic_load_explicit(y, memory_order_seq_cst, memory_scope_device); + int r3 = atomic_load_explicit(x, memory_order_seq_cst, memory_scope_device); +} + +exists (2:r0=1 /\ 2:r1=0 /\ 3:r2=1 /\ 3:r3=0) \ No newline at end of file diff --git a/litmus/OPENCL/overhauling/IRIW_sc_wg.litmus b/litmus/OPENCL/overhauling/IRIW_sc_wg.litmus new file mode 100644 index 0000000000..62e5784a48 --- /dev/null +++ b/litmus/OPENCL/overhauling/IRIW_sc_wg.litmus @@ -0,0 +1,30 @@ +OPENCL IRIW_sc_wg + +(* + * https://multicore.doc.ic.ac.uk/overhauling/OpenCL/IRIW_sc_wg.litmus + *) + +{ +[x] = 0; +[y] = 0; +} + +P0@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + atomic_store_explicit(x, 1, memory_order_seq_cst, memory_scope_work_group); +} + +P1@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + atomic_store_explicit(y, 1, memory_order_seq_cst, memory_scope_work_group); +} + +P2@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + int r0 = atomic_load_explicit(x, memory_order_seq_cst, memory_scope_work_group); + int r1 = atomic_load_explicit(y, memory_order_seq_cst, memory_scope_work_group); +} + +P3@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + int r2 = atomic_load_explicit(y, memory_order_seq_cst, memory_scope_work_group); + int r3 = atomic_load_explicit(x, memory_order_seq_cst, memory_scope_work_group); +} + +exists (2:r0=1 /\ 2:r1=0 /\ 3:r2=1 /\ 3:r3=0) \ No newline at end of file diff --git a/litmus/OPENCL/overhauling/ISA2.litmus b/litmus/OPENCL/overhauling/ISA2.litmus new file mode 100644 index 0000000000..3f1f4f3fc8 --- /dev/null +++ b/litmus/OPENCL/overhauling/ISA2.litmus @@ -0,0 +1,33 @@ +OPENCL ISA2 + +(* + * https://multicore.doc.ic.ac.uk/overhauling/OpenCL/ISA2.litmus + *) + +{ +[x] = 0; +[y] = 0; +[z] = 0; +} + +P0@wg 0, dev 0 (global int* x, global atomic_int* y, global atomic_int* z) { + *x = 1; + atomic_store_explicit(y, 1, memory_order_release, memory_scope_work_group); +} + +P1@wg 0, dev 0 (global int* x, global atomic_int* y, global atomic_int* z) { + int r0 = atomic_load_explicit(y, memory_order_acquire, memory_scope_work_group); + if (1 == r0) { + atomic_store_explicit(z, 1, memory_order_release, memory_scope_device); + } +} + +P2@wg 1, dev 0 (global int* x, global atomic_int* y, global atomic_int* z) { + int r1 = atomic_load_explicit(z, memory_order_acquire, memory_scope_device); + int r2 = -1; + if (1 == r1) { + r2 = *x; + } +} + +exists (1:r0=1 /\ 2:r1=1 /\ 2:r2=0) \ No newline at end of file diff --git a/litmus/OPENCL/overhauling/ISA2_broken.litmus b/litmus/OPENCL/overhauling/ISA2_broken.litmus new file mode 100644 index 0000000000..9ee905ce74 --- /dev/null +++ b/litmus/OPENCL/overhauling/ISA2_broken.litmus @@ -0,0 +1,33 @@ +OPENCL ISA2_broken + +(* + * https://multicore.doc.ic.ac.uk/overhauling/OpenCL/ISA2_broken.litmus + *) + +{ +[x] = 0; +[y] = 0; +[z] = 0; +} + +P0@wg 0, dev 0 (global int* x, local atomic_int* y, global atomic_int* z) { + *x = 1; + atomic_store_explicit(y, 1, memory_order_release, memory_scope_work_group); +} + +P1@wg 0, dev 0 (global int* x, local atomic_int* y, global atomic_int* z) { + int r0 = atomic_load_explicit(y, memory_order_acquire, memory_scope_work_group); + if (1 == r0) { + atomic_store_explicit(z, 1, memory_order_release, memory_scope_device); + } +} + +P2@wg 1, dev 0 (global int* x, local atomic_int* y, global atomic_int* z) { + int r1 = atomic_load_explicit(z, memory_order_acquire, memory_scope_device); + int r2 = -1; + if (1 == r1) { + r2 = *x; + } +} + +exists (1:r0=1 /\ 2:r1=1 /\ 2:r2=0) \ No newline at end of file diff --git a/litmus/OPENCL/overhauling/MP_ra_dev.litmus b/litmus/OPENCL/overhauling/MP_ra_dev.litmus new file mode 100644 index 0000000000..6ff6728ad2 --- /dev/null +++ b/litmus/OPENCL/overhauling/MP_ra_dev.litmus @@ -0,0 +1,25 @@ +OPENCL MP_ra_dev + +(* + * https://multicore.doc.ic.ac.uk/overhauling/OpenCL/MP_ra_dev.litmus + *) + +{ +[x] = 0; +[y] = 0; +} + +P0@wg 0, dev 0 (global int* x, global atomic_int* y) { + *x = 1; + atomic_store_explicit(y, 1, memory_order_release, memory_scope_device); +} + +P1@wg 1, dev 0 (global int* x, global atomic_int* y) { + int r0 = atomic_load_explicit(y, memory_order_acquire, memory_scope_device); + int r1 = -1; + if (1 == r0) { + r1 = *x; + } +} + +exists (1:r0=1 /\ 1:r1=0) \ No newline at end of file diff --git a/litmus/OPENCL/overhauling/MP_ra_dev_broken.litmus b/litmus/OPENCL/overhauling/MP_ra_dev_broken.litmus new file mode 100644 index 0000000000..4b5920b4e3 --- /dev/null +++ b/litmus/OPENCL/overhauling/MP_ra_dev_broken.litmus @@ -0,0 +1,25 @@ +OPENCL MP_ra_dev_broken + +(* + * https://multicore.doc.ic.ac.uk/overhauling/OpenCL/MP_ra_dev_broken.litmus + *) + +{ +[x] = 0; +[y] = 0; +} + +P0@wg 0, dev 0 (global int* x, global atomic_int* y) { + *x = 1; + atomic_store_explicit(y, 1, memory_order_release, memory_scope_device); +} + +P1@wg 0, dev 1 (global int* x, global atomic_int* y) { + int r0 = atomic_load_explicit(y, memory_order_acquire, memory_scope_device); + int r1 = -1; + if (1 == r0) { + r1 = *x; + } +} + +exists (1:r0=1 /\ 1:r1=0) \ No newline at end of file diff --git a/litmus/OPENCL/overhauling/MP_ra_wg.litmus b/litmus/OPENCL/overhauling/MP_ra_wg.litmus new file mode 100644 index 0000000000..919952ee8f --- /dev/null +++ b/litmus/OPENCL/overhauling/MP_ra_wg.litmus @@ -0,0 +1,25 @@ +OPENCL MP_ra_wg + +(* + * https://multicore.doc.ic.ac.uk/overhauling/OpenCL/MP_ra_wg.litmus + *) + +{ +[x] = 0; +[y] = 0; +} + +P0@wg 0, dev 0 (global int* x, global atomic_int* y) { + *x = 1; + atomic_store_explicit(y, 1, memory_order_release, memory_scope_work_group); +} + +P1@wg 1, dev 0 (global int* x, global atomic_int* y) { + int r0 = atomic_load_explicit(y, memory_order_acquire, memory_scope_work_group); + int r1 = -1; + if (1 == r0) { + r1 = *x; + } +} + +exists (1:r0=1 /\ 1:r1=0) \ No newline at end of file diff --git a/litmus/OPENCL/overhauling/MP_sc_dev.litmus b/litmus/OPENCL/overhauling/MP_sc_dev.litmus new file mode 100644 index 0000000000..7b81af2674 --- /dev/null +++ b/litmus/OPENCL/overhauling/MP_sc_dev.litmus @@ -0,0 +1,25 @@ +OPENCL MP_sc_dev + +(* + * https://multicore.doc.ic.ac.uk/overhauling/OpenCL/MP_sc_dev.litmus + *) + +{ +[x] = 0; +[y] = 0; +} + +P0@wg 0, dev 0 (global int* x, global atomic_int* y) { + *x = 1; + atomic_store_explicit(y, 1, memory_order_seq_cst, memory_scope_device); +} + +P1@wg 1, dev 0 (global int* x, global atomic_int* y) { + int r0 = atomic_load_explicit(y, memory_order_seq_cst, memory_scope_device); + int r1 = -1; + if (1 == r0) { + r1 = *x; + } +} + +exists (1:r0=1 /\ 1:r1=0) \ No newline at end of file diff --git a/litmus/OPENCL/overhauling/example10.litmus b/litmus/OPENCL/overhauling/example10.litmus new file mode 100644 index 0000000000..c805967393 --- /dev/null +++ b/litmus/OPENCL/overhauling/example10.litmus @@ -0,0 +1,39 @@ +OPENCL example10 + +(* + * https://multicore.doc.ic.ac.uk/overhauling/examples/example10.litmus + * global_fga -> global + *) + +{ +[x] = 0; +[y] = 0; +[z1] = 0; +[z2] = 0; +} + +P0@wg 0, dev 0 (global atomic_int* x, global atomic_int* y, global atomic_int* z1, global atomic_int* z2) { + atomic_store_explicit(x, 1, memory_order_seq_cst, memory_scope_device); + //int r = atomic_load_explicit(x, memory_order_seq_cst, memory_scope_device); + atomic_store_explicit(z1, 1, memory_order_release, memory_scope_all_svm_devices); +} + +P1@wg 0, dev 0 (global atomic_int* x, global atomic_int* y, global atomic_int* z1, global atomic_int* z2) { + int r = -1; + if (atomic_load_explicit(z2, memory_order_acquire, memory_scope_all_svm_devices) == 1) + r = atomic_load_explicit(x, memory_order_seq_cst, memory_scope_device); +} + +P2@wg 0, dev 1 (global atomic_int* x, global atomic_int* y, global atomic_int* z1, global atomic_int* z2) { + atomic_store_explicit(y, 1, memory_order_seq_cst, memory_scope_device); + //int r = atomic_load_explicit(y, memory_order_seq_cst, memory_scope_device); + atomic_store_explicit(z2, 1, memory_order_release, memory_scope_all_svm_devices); +} + +P3@wg 0, dev 1 (global atomic_int* x, global atomic_int* y, global atomic_int* z1, global atomic_int* z2) { + int r = -1; + if (atomic_load_explicit(z1, memory_order_acquire, memory_scope_all_svm_devices) == 1) + r = atomic_load_explicit(y, memory_order_seq_cst, memory_scope_device); +} + +exists (1:r = 0 /\ 3:r = 0) \ No newline at end of file diff --git a/litmus/OPENCL/overhauling/example4.litmus b/litmus/OPENCL/overhauling/example4.litmus new file mode 100644 index 0000000000..4c589f6315 --- /dev/null +++ b/litmus/OPENCL/overhauling/example4.litmus @@ -0,0 +1,24 @@ +OPENCL example4 + +(* + * https://multicore.doc.ic.ac.uk/overhauling/examples/example4.litmus + *) + +{ +[x] = 0; +[y] = 0; +} + +P0@wg 0, dev 0 (global int* x, global atomic_int* y) { + *x = 42; + atomic_store_explicit(y, 1, memory_order_release, memory_scope_work_group); +} + +P1@wg 0, dev 0 (global int* x, global atomic_int* y) { + int r = -1; + if (atomic_load_explicit(y, memory_order_acquire, memory_scope_work_group) == 1) { + r = *x; + } +} + +exists (1:r=0) \ No newline at end of file diff --git a/litmus/OPENCL/overhauling/example5.litmus b/litmus/OPENCL/overhauling/example5.litmus new file mode 100644 index 0000000000..06781ff029 --- /dev/null +++ b/litmus/OPENCL/overhauling/example5.litmus @@ -0,0 +1,24 @@ +OPENCL example5 + +(* + * https://multicore.doc.ic.ac.uk/overhauling/examples/example5.litmus + *) + +{ +[x] = 0; +[y] = 0; +} + +P0@wg 0, dev 0 (global int* x, local atomic_int* y) { + *x = 42; + atomic_store_explicit(y, 1, memory_order_release, memory_scope_work_group); +} + +P1@wg 0, dev 0 (global int* x, local atomic_int* y) { + int r = -1; + if (atomic_load_explicit(y, memory_order_acquire, memory_scope_work_group) == 1) { + r = *x; + } +} + +exists (1:r=0) \ No newline at end of file diff --git a/litmus/OPENCL/overhauling/example6.litmus b/litmus/OPENCL/overhauling/example6.litmus new file mode 100644 index 0000000000..738fd1da7c --- /dev/null +++ b/litmus/OPENCL/overhauling/example6.litmus @@ -0,0 +1,26 @@ +OPENCL example6 + +(* + * https://multicore.doc.ic.ac.uk/overhauling/examples/example6.litmus + *) + +{ +[x] = 0; +[y] = 0; +} + +P0@wg 0, dev 0 (global int* x, local atomic_int* y) { + *x = 42; + atomic_work_item_fence(CLK_GLOBAL_MEM_FENCE | CLK_LOCAL_MEM_FENCE, memory_order_release, memory_scope_work_group); + atomic_store_explicit(y, 1, memory_order_relaxed, memory_scope_work_group); +} + +P1@wg 0, dev 0 (global int* x, local atomic_int* y) { + int r = -1; + if (atomic_load_explicit(y, memory_order_relaxed, memory_scope_work_group) == 1) { + atomic_work_item_fence(CLK_GLOBAL_MEM_FENCE | CLK_LOCAL_MEM_FENCE, memory_order_acquire, memory_scope_work_group); + r = *x; + } +} + +exists (1:r=0) \ No newline at end of file diff --git a/litmus/OPENCL/overhauling/example7a.litmus b/litmus/OPENCL/overhauling/example7a.litmus new file mode 100644 index 0000000000..ad8a90c534 --- /dev/null +++ b/litmus/OPENCL/overhauling/example7a.litmus @@ -0,0 +1,24 @@ +OPENCL example7a + +(* + * https://multicore.doc.ic.ac.uk/overhauling/examples/example7a.litmus + *) + +{ +[x] = 0; +[y] = 0; +} + +P0@wg 0, dev 0 (global int* x, global int* y) { + if (*x == 1) { + *y = 1; + } +} + +P1@wg 0, dev 0 (global int* x, local atomic_int* y) { + if (*y == 1) { + *x = 1; + } +} + +exists (x = 1 /\ y = 1) \ No newline at end of file diff --git a/litmus/OPENCL/overhauling/example7b.litmus b/litmus/OPENCL/overhauling/example7b.litmus new file mode 100644 index 0000000000..b38fb1f93f --- /dev/null +++ b/litmus/OPENCL/overhauling/example7b.litmus @@ -0,0 +1,24 @@ +OPENCL example7b + +(* + * https://multicore.doc.ic.ac.uk/overhauling/examples/example7b.litmus + *) + +{ +[x] = 0; +[y] = 0; +} + +P0@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + if (atomic_load_explicit(x, memory_order_relaxed, memory_scope_work_item) == 1) { + atomic_store_explicit(y, 1, memory_order_relaxed, memory_scope_work_item); + } +} + +P1@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + if (atomic_load_explicit(y, memory_order_relaxed, memory_scope_work_item) == 1) { + atomic_store_explicit(x, 1, memory_order_relaxed, memory_scope_work_item); + } +} + +exists (x = 1 /\ y = 1) \ No newline at end of file diff --git a/litmus/OPENCL/overhauling/example8.litmus b/litmus/OPENCL/overhauling/example8.litmus new file mode 100644 index 0000000000..f2e75d6b50 --- /dev/null +++ b/litmus/OPENCL/overhauling/example8.litmus @@ -0,0 +1,24 @@ +OPENCL example8 + +(* + * https://multicore.doc.ic.ac.uk/overhauling/examples/example8.litmus + *) + +{ +[x] = 0; +[y] = 0; +} + +P0@wg 0, dev 0 (global int* x, local atomic_int* y) { + *x = 42; + atomic_store_explicit(y, 1, memory_order_release, memory_scope_device); +} + +P1@wg 0, dev 0 (global int* x, local atomic_int* y) { + int r = -1; + if (atomic_load_explicit(y, memory_order_acquire, memory_scope_work_group) == 1) { + r = *x; + } +} + +exists (1:r=0) \ No newline at end of file diff --git a/litmus/OPENCL/overhauling/example9a.litmus b/litmus/OPENCL/overhauling/example9a.litmus new file mode 100644 index 0000000000..ad4cd54d01 --- /dev/null +++ b/litmus/OPENCL/overhauling/example9a.litmus @@ -0,0 +1,22 @@ +OPENCL example9a + +(* + * https://multicore.doc.ic.ac.uk/overhauling/examples/example9a.litmus + *) + +{ +[x] = 0; +[y] = 0; +} + +P0@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + atomic_store_explicit(x, 1, memory_order_seq_cst, memory_scope_device); + int r0 = atomic_load_explicit(y, memory_order_seq_cst, memory_scope_device); +} + +P1@wg 1, dev 0 (global atomic_int* x, global atomic_int* y) { + atomic_store_explicit(y, 1, memory_order_seq_cst, memory_scope_device); + int r1 = atomic_load_explicit(x, memory_order_seq_cst, memory_scope_device); +} + +exists (0:r0 = 0 /\ 1:r1 = 0) \ No newline at end of file diff --git a/litmus/OPENCL/overhauling/example9b.litmus b/litmus/OPENCL/overhauling/example9b.litmus new file mode 100644 index 0000000000..b16bfac8c3 --- /dev/null +++ b/litmus/OPENCL/overhauling/example9b.litmus @@ -0,0 +1,23 @@ +OPENCL example9b + +(* + * https://multicore.doc.ic.ac.uk/overhauling/examples/example9b.litmus + * global_fga -> global + *) + +{ +[x] = 0; +[y] = 0; +} + +P0@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + atomic_store_explicit(x, 1, memory_order_seq_cst, memory_scope_device); + int r0 = atomic_load_explicit(y, memory_order_seq_cst, memory_scope_device); +} + +P1@wg 1, dev 0 (global atomic_int* x, global atomic_int* y) { + atomic_store_explicit(y, 1, memory_order_seq_cst, memory_scope_device); + int r1 = atomic_load_explicit(x, memory_order_seq_cst, memory_scope_device); +} + +exists (0:r0 = 0 /\ 1:r1 = 0) \ No newline at end of file diff --git a/litmus/OPENCL/portedFromC11/auto/a1+Racq+rel.litmus b/litmus/OPENCL/portedFromC11/auto/a1+Racq+rel.litmus new file mode 100644 index 0000000000..744622b88d --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/a1+Racq+rel.litmus @@ -0,0 +1,16 @@ +OPENCL a1+Racq+rel +{ [x] = 0; [y] = 0; [zero] = 0; } + +P0@wg 0, dev 0 (global atomic_int* x, global atomic_int* y, global atomic_int* zero) { + int t2 = atomic_load_explicit(y, memory_order_acquire); + atomic_store_explicit(x, 1, memory_order_release); +} + +P1@wg 0, dev 0 (global atomic_int* x, volatile global int* y) { + int r1 = atomic_load_explicit(x, memory_order_acquire); + if (r1) { + *y = 1; + } +} + +exists(x=1 /\ y=1) diff --git a/litmus/OPENCL/portedFromC11/auto/a1+Racq+sc.litmus b/litmus/OPENCL/portedFromC11/auto/a1+Racq+sc.litmus new file mode 100644 index 0000000000..837195d1d8 --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/a1+Racq+sc.litmus @@ -0,0 +1,16 @@ +OPENCL a1+Racq+sc +{ [x] = 0; [y] = 0; [zero] = 0; } + +P0@wg 0, dev 0 (global atomic_int* x, global atomic_int* y, global atomic_int* zero) { + int t2 = atomic_load_explicit(y, memory_order_acquire); + atomic_store_explicit(x, 1, memory_order_seq_cst); +} + +P1@wg 0, dev 0 (global atomic_int* x, volatile global int* y) { + int r1 = atomic_load_explicit(x, memory_order_acquire); + if (r1) { + *y = 1; + } +} + +exists(x=1 /\ y=1) diff --git a/litmus/OPENCL/portedFromC11/auto/a1+Rna+rel.litmus b/litmus/OPENCL/portedFromC11/auto/a1+Rna+rel.litmus new file mode 100644 index 0000000000..67c5d589f9 --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/a1+Rna+rel.litmus @@ -0,0 +1,16 @@ +OPENCL a1+Rna+rel +{ [x] = 0; [y] = 0; [zero] = 0; } + +P0@wg 0, dev 0 (global atomic_int* x, global atomic_int* y, global atomic_int* zero) { + int t0 = *y; + atomic_store_explicit(x, 1, memory_order_release); +} + +P1@wg 0, dev 0 (global atomic_int* x, volatile global int* y) { + int r1 = atomic_load_explicit(x, memory_order_acquire); + if (r1) { + *y = 1; + } +} + +exists(x=1 /\ y=1) diff --git a/litmus/OPENCL/portedFromC11/auto/a1+Rna+sc.litmus b/litmus/OPENCL/portedFromC11/auto/a1+Rna+sc.litmus new file mode 100644 index 0000000000..616ac6b73f --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/a1+Rna+sc.litmus @@ -0,0 +1,16 @@ +OPENCL a1+Rna+sc +{ [x] = 0; [y] = 0; [zero] = 0; } + +P0@wg 0, dev 0 (global atomic_int* x, global atomic_int* y, global atomic_int* zero) { + int t0 = *y; + atomic_store_explicit(x, 1, memory_order_seq_cst); +} + +P1@wg 0, dev 0 (global atomic_int* x, volatile global int* y) { + int r1 = atomic_load_explicit(x, memory_order_acquire); + if (r1) { + *y = 1; + } +} + +exists(x=1 /\ y=1) diff --git a/litmus/OPENCL/portedFromC11/auto/a1+Rrlx+rel.litmus b/litmus/OPENCL/portedFromC11/auto/a1+Rrlx+rel.litmus new file mode 100644 index 0000000000..3d71e5055f --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/a1+Rrlx+rel.litmus @@ -0,0 +1,16 @@ +OPENCL a1+Rrlx+rel +{ [x] = 0; [y] = 0; [zero] = 0; } + +P0@wg 0, dev 0 (global atomic_int* x, global atomic_int* y, global atomic_int* zero) { + int t4 = atomic_load_explicit(y, memory_order_relaxed); + atomic_store_explicit(x, 1, memory_order_release); +} + +P1@wg 0, dev 0 (global atomic_int* x, volatile global int* y) { + int r1 = atomic_load_explicit(x, memory_order_acquire); + if (r1) { + *y = 1; + } +} + +exists(x=1 /\ y=1) diff --git a/litmus/OPENCL/portedFromC11/auto/a1+Rrlx+sc.litmus b/litmus/OPENCL/portedFromC11/auto/a1+Rrlx+sc.litmus new file mode 100644 index 0000000000..866e8c6327 --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/a1+Rrlx+sc.litmus @@ -0,0 +1,16 @@ +OPENCL a1+Rrlx+sc +{ [x] = 0; [y] = 0; [zero] = 0; } + +P0@wg 0, dev 0 (global atomic_int* x, global atomic_int* y, global atomic_int* zero) { + int t4 = atomic_load_explicit(y, memory_order_relaxed); + atomic_store_explicit(x, 1, memory_order_seq_cst); +} + +P1@wg 0, dev 0 (global atomic_int* x, volatile global int* y) { + int r1 = atomic_load_explicit(x, memory_order_acquire); + if (r1) { + *y = 1; + } +} + +exists(x=1 /\ y=1) diff --git a/litmus/OPENCL/portedFromC11/auto/a1+Rsc+rel.litmus b/litmus/OPENCL/portedFromC11/auto/a1+Rsc+rel.litmus new file mode 100644 index 0000000000..9b9449a01b --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/a1+Rsc+rel.litmus @@ -0,0 +1,16 @@ +OPENCL a1+Rsc+rel +{ [x] = 0; [y] = 0; [zero] = 0; } + +P0@wg 0, dev 0 (global atomic_int* x, global atomic_int* y, global atomic_int* zero) { + int t1 = atomic_load_explicit(y, memory_order_seq_cst); + atomic_store_explicit(x, 1, memory_order_release); +} + +P1@wg 0, dev 0 (global atomic_int* x, volatile global int* y) { + int r1 = atomic_load_explicit(x, memory_order_acquire); + if (r1) { + *y = 1; + } +} + +exists(x=1 /\ y=1) diff --git a/litmus/OPENCL/portedFromC11/auto/a1+Rsc+sc.litmus b/litmus/OPENCL/portedFromC11/auto/a1+Rsc+sc.litmus new file mode 100644 index 0000000000..f23db024d8 --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/a1+Rsc+sc.litmus @@ -0,0 +1,16 @@ +OPENCL a1+Rsc+sc +{ [x] = 0; [y] = 0; [zero] = 0; } + +P0@wg 0, dev 0 (global atomic_int* x, global atomic_int* y, global atomic_int* zero) { + int t1 = atomic_load_explicit(y, memory_order_seq_cst); + atomic_store_explicit(x, 1, memory_order_seq_cst); +} + +P1@wg 0, dev 0 (global atomic_int* x, volatile global int* y) { + int r1 = atomic_load_explicit(x, memory_order_acquire); + if (r1) { + *y = 1; + } +} + +exists(x=1 /\ y=1) diff --git a/litmus/OPENCL/portedFromC11/auto/a1+Wna+rel.litmus b/litmus/OPENCL/portedFromC11/auto/a1+Wna+rel.litmus new file mode 100644 index 0000000000..78a0462956 --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/a1+Wna+rel.litmus @@ -0,0 +1,16 @@ +OPENCL a1+Wna+rel +{ [x] = 0; [y] = 0; [zero] = 0; } + +P0@wg 0, dev 0 (global atomic_int* x, global atomic_int* y, global atomic_int* zero) { + *y = 0; + atomic_store_explicit(x, 1, memory_order_release); +} + +P1@wg 0, dev 0 (global atomic_int* x, volatile global int* y) { + int r1 = atomic_load_explicit(x, memory_order_acquire); + if (r1) { + *y = 1; + } +} + +exists(x=1 /\ y=1) diff --git a/litmus/OPENCL/portedFromC11/auto/a1+Wna+sc.litmus b/litmus/OPENCL/portedFromC11/auto/a1+Wna+sc.litmus new file mode 100644 index 0000000000..42840f249e --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/a1+Wna+sc.litmus @@ -0,0 +1,16 @@ +OPENCL a1+Wna+sc +{ [x] = 0; [y] = 0; [zero] = 0; } + +P0@wg 0, dev 0 (global atomic_int* x, global atomic_int* y, global atomic_int* zero) { + *y = 0; + atomic_store_explicit(x, 1, memory_order_seq_cst); +} + +P1@wg 0, dev 0 (global atomic_int* x, volatile global int* y) { + int r1 = atomic_load_explicit(x, memory_order_acquire); + if (r1) { + *y = 1; + } +} + +exists(x=1 /\ y=1) diff --git a/litmus/OPENCL/portedFromC11/auto/a1+Wrel+rel.litmus b/litmus/OPENCL/portedFromC11/auto/a1+Wrel+rel.litmus new file mode 100644 index 0000000000..6797b2c87c --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/a1+Wrel+rel.litmus @@ -0,0 +1,16 @@ +OPENCL a1+Wrel+rel +{ [x] = 0; [y] = 0; [zero] = 0; } + +P0@wg 0, dev 0 (global atomic_int* x, global atomic_int* y, global atomic_int* zero) { + atomic_store_explicit(y, 0, memory_order_release); + atomic_store_explicit(x, 1, memory_order_release); +} + +P1@wg 0, dev 0 (global atomic_int* x, volatile global int* y) { + int r1 = atomic_load_explicit(x, memory_order_acquire); + if (r1) { + *y = 1; + } +} + +exists(x=1 /\ y=1) diff --git a/litmus/OPENCL/portedFromC11/auto/a1+Wrel+sc.litmus b/litmus/OPENCL/portedFromC11/auto/a1+Wrel+sc.litmus new file mode 100644 index 0000000000..1e9f436cd9 --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/a1+Wrel+sc.litmus @@ -0,0 +1,16 @@ +OPENCL a1+Wrel+sc +{ [x] = 0; [y] = 0; [zero] = 0; } + +P0@wg 0, dev 0 (global atomic_int* x, global atomic_int* y, global atomic_int* zero) { + atomic_store_explicit(y, 0, memory_order_release); + atomic_store_explicit(x, 1, memory_order_seq_cst); +} + +P1@wg 0, dev 0 (global atomic_int* x, volatile global int* y) { + int r1 = atomic_load_explicit(x, memory_order_acquire); + if (r1) { + *y = 1; + } +} + +exists(x=1 /\ y=1) diff --git a/litmus/OPENCL/portedFromC11/auto/a1+Wrlx+rel.litmus b/litmus/OPENCL/portedFromC11/auto/a1+Wrlx+rel.litmus new file mode 100644 index 0000000000..40b61e5e63 --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/a1+Wrlx+rel.litmus @@ -0,0 +1,16 @@ +OPENCL a1+Wrlx+rel +{ [x] = 0; [y] = 0; [zero] = 0; } + +P0@wg 0, dev 0 (global atomic_int* x, global atomic_int* y, global atomic_int* zero) { + atomic_store_explicit(y, 0, memory_order_relaxed); + atomic_store_explicit(x, 1, memory_order_release); +} + +P1@wg 0, dev 0 (global atomic_int* x, volatile global int* y) { + int r1 = atomic_load_explicit(x, memory_order_acquire); + if (r1) { + *y = 1; + } +} + +exists(x=1 /\ y=1) diff --git a/litmus/OPENCL/portedFromC11/auto/a1+Wrlx+sc.litmus b/litmus/OPENCL/portedFromC11/auto/a1+Wrlx+sc.litmus new file mode 100644 index 0000000000..b9c9394c1a --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/a1+Wrlx+sc.litmus @@ -0,0 +1,16 @@ +OPENCL a1+Wrlx+sc +{ [x] = 0; [y] = 0; [zero] = 0; } + +P0@wg 0, dev 0 (global atomic_int* x, global atomic_int* y, global atomic_int* zero) { + atomic_store_explicit(y, 0, memory_order_relaxed); + atomic_store_explicit(x, 1, memory_order_seq_cst); +} + +P1@wg 0, dev 0 (global atomic_int* x, volatile global int* y) { + int r1 = atomic_load_explicit(x, memory_order_acquire); + if (r1) { + *y = 1; + } +} + +exists(x=1 /\ y=1) diff --git a/litmus/OPENCL/portedFromC11/auto/a1+Wsc+rel.litmus b/litmus/OPENCL/portedFromC11/auto/a1+Wsc+rel.litmus new file mode 100644 index 0000000000..15bf42b79a --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/a1+Wsc+rel.litmus @@ -0,0 +1,16 @@ +OPENCL a1+Wsc+rel +{ [x] = 0; [y] = 0; [zero] = 0; } + +P0@wg 0, dev 0 (global atomic_int* x, global atomic_int* y, global atomic_int* zero) { + atomic_store_explicit(y, 0, memory_order_seq_cst); + atomic_store_explicit(x, 1, memory_order_release); +} + +P1@wg 0, dev 0 (global atomic_int* x, volatile global int* y) { + int r1 = atomic_load_explicit(x, memory_order_acquire); + if (r1) { + *y = 1; + } +} + +exists(x=1 /\ y=1) diff --git a/litmus/OPENCL/portedFromC11/auto/a1+Wsc+sc.litmus b/litmus/OPENCL/portedFromC11/auto/a1+Wsc+sc.litmus new file mode 100644 index 0000000000..346d458249 --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/a1+Wsc+sc.litmus @@ -0,0 +1,16 @@ +OPENCL a1+Wsc+sc +{ [x] = 0; [y] = 0; [zero] = 0; } + +P0@wg 0, dev 0 (global atomic_int* x, global atomic_int* y, global atomic_int* zero) { + atomic_store_explicit(y, 0, memory_order_seq_cst); + atomic_store_explicit(x, 1, memory_order_seq_cst); +} + +P1@wg 0, dev 0 (global atomic_int* x, volatile global int* y) { + int r1 = atomic_load_explicit(x, memory_order_acquire); + if (r1) { + *y = 1; + } +} + +exists(x=1 /\ y=1) diff --git a/litmus/OPENCL/portedFromC11/auto/a1.litmus b/litmus/OPENCL/portedFromC11/auto/a1.litmus new file mode 100644 index 0000000000..272c7ba6f2 --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/a1.litmus @@ -0,0 +1,16 @@ +OPENCL a1 +{ [x] = 0; [y] = 0; } + +P0@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + int r0 = atomic_load_explicit(y, memory_order_relaxed); + atomic_store_explicit(x, 1, memory_order_release); +} + +P1@wg 0, dev 0 (global atomic_int* x, volatile global int* y) { + int r1 = atomic_load_explicit(x, memory_order_acquire); + if (r1) { + *y = 1; + } +} + +exists(x=1 /\ y=1) diff --git a/litmus/OPENCL/portedFromC11/auto/a1_reorder+rel+Racq.litmus b/litmus/OPENCL/portedFromC11/auto/a1_reorder+rel+Racq.litmus new file mode 100644 index 0000000000..0cc589ec78 --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/a1_reorder+rel+Racq.litmus @@ -0,0 +1,16 @@ +OPENCL a1_reorder+rel+Racq +{ [x] = 0; [y] = 0; [zero] = 0; } + +P0@wg 0, dev 0 (global atomic_int* x, global atomic_int* y, global atomic_int* zero) { + atomic_store_explicit(x, 1, memory_order_release); + int t2 = atomic_load_explicit(y, memory_order_acquire); +} + +P1@wg 0, dev 0 (global atomic_int* x, volatile global int* y) { + int r1 = atomic_load_explicit(x, memory_order_acquire); + if (r1) { + *y = 1; + } +} + +exists(x=1 /\ y=1) diff --git a/litmus/OPENCL/portedFromC11/auto/a1_reorder+rel+Rna.litmus b/litmus/OPENCL/portedFromC11/auto/a1_reorder+rel+Rna.litmus new file mode 100644 index 0000000000..677ba042ee --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/a1_reorder+rel+Rna.litmus @@ -0,0 +1,16 @@ +OPENCL a1_reorder+rel+Rna +{ [x] = 0; [y] = 0; [zero] = 0; } + +P0@wg 0, dev 0 (global atomic_int* x, global atomic_int* y, global atomic_int* zero) { + atomic_store_explicit(x, 1, memory_order_release); + int t0 = *y; +} + +P1@wg 0, dev 0 (global atomic_int* x, volatile global int* y) { + int r1 = atomic_load_explicit(x, memory_order_acquire); + if (r1) { + *y = 1; + } +} + +exists(x=1 /\ y=1) diff --git a/litmus/OPENCL/portedFromC11/auto/a1_reorder+rel+Rrlx.litmus b/litmus/OPENCL/portedFromC11/auto/a1_reorder+rel+Rrlx.litmus new file mode 100644 index 0000000000..94d3153231 --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/a1_reorder+rel+Rrlx.litmus @@ -0,0 +1,16 @@ +OPENCL a1_reorder+rel+Rrlx +{ [x] = 0; [y] = 0; [zero] = 0; } + +P0@wg 0, dev 0 (global atomic_int* x, global atomic_int* y, global atomic_int* zero) { + atomic_store_explicit(x, 1, memory_order_release); + int t4 = atomic_load_explicit(y, memory_order_relaxed); +} + +P1@wg 0, dev 0 (global atomic_int* x, volatile global int* y) { + int r1 = atomic_load_explicit(x, memory_order_acquire); + if (r1) { + *y = 1; + } +} + +exists(x=1 /\ y=1) diff --git a/litmus/OPENCL/portedFromC11/auto/a1_reorder+rel+Rsc.litmus b/litmus/OPENCL/portedFromC11/auto/a1_reorder+rel+Rsc.litmus new file mode 100644 index 0000000000..76047490c8 --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/a1_reorder+rel+Rsc.litmus @@ -0,0 +1,16 @@ +OPENCL a1_reorder+rel+Rsc +{ [x] = 0; [y] = 0; [zero] = 0; } + +P0@wg 0, dev 0 (global atomic_int* x, global atomic_int* y, global atomic_int* zero) { + atomic_store_explicit(x, 1, memory_order_release); + int t1 = atomic_load_explicit(y, memory_order_seq_cst); +} + +P1@wg 0, dev 0 (global atomic_int* x, volatile global int* y) { + int r1 = atomic_load_explicit(x, memory_order_acquire); + if (r1) { + *y = 1; + } +} + +exists(x=1 /\ y=1) diff --git a/litmus/OPENCL/portedFromC11/auto/a1_reorder+rel+Wna.litmus b/litmus/OPENCL/portedFromC11/auto/a1_reorder+rel+Wna.litmus new file mode 100644 index 0000000000..b02e47e99b --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/a1_reorder+rel+Wna.litmus @@ -0,0 +1,16 @@ +OPENCL a1_reorder+rel+Wna +{ [x] = 0; [y] = 0; [zero] = 0; } + +P0@wg 0, dev 0 (global atomic_int* x, global atomic_int* y, global atomic_int* zero) { + atomic_store_explicit(x, 1, memory_order_release); + *y = 0; +} + +P1@wg 0, dev 0 (global atomic_int* x, volatile global int* y) { + int r1 = atomic_load_explicit(x, memory_order_acquire); + if (r1) { + *y = 1; + } +} + +exists(x=1 /\ y=1) diff --git a/litmus/OPENCL/portedFromC11/auto/a1_reorder+rel+Wrel.litmus b/litmus/OPENCL/portedFromC11/auto/a1_reorder+rel+Wrel.litmus new file mode 100644 index 0000000000..5c88f3bf00 --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/a1_reorder+rel+Wrel.litmus @@ -0,0 +1,16 @@ +OPENCL a1_reorder+rel+Wrel +{ [x] = 0; [y] = 0; [zero] = 0; } + +P0@wg 0, dev 0 (global atomic_int* x, global atomic_int* y, global atomic_int* zero) { + atomic_store_explicit(x, 1, memory_order_release); + atomic_store_explicit(y, 0, memory_order_release); +} + +P1@wg 0, dev 0 (global atomic_int* x, volatile global int* y) { + int r1 = atomic_load_explicit(x, memory_order_acquire); + if (r1) { + *y = 1; + } +} + +exists(x=1 /\ y=1) diff --git a/litmus/OPENCL/portedFromC11/auto/a1_reorder+rel+Wrlx.litmus b/litmus/OPENCL/portedFromC11/auto/a1_reorder+rel+Wrlx.litmus new file mode 100644 index 0000000000..2a93ce0492 --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/a1_reorder+rel+Wrlx.litmus @@ -0,0 +1,16 @@ +OPENCL a1_reorder+rel+Wrlx +{ [x] = 0; [y] = 0; [zero] = 0; } + +P0@wg 0, dev 0 (global atomic_int* x, global atomic_int* y, global atomic_int* zero) { + atomic_store_explicit(x, 1, memory_order_release); + atomic_store_explicit(y, 0, memory_order_relaxed); +} + +P1@wg 0, dev 0 (global atomic_int* x, volatile global int* y) { + int r1 = atomic_load_explicit(x, memory_order_acquire); + if (r1) { + *y = 1; + } +} + +exists(x=1 /\ y=1) diff --git a/litmus/OPENCL/portedFromC11/auto/a1_reorder+rel+Wsc.litmus b/litmus/OPENCL/portedFromC11/auto/a1_reorder+rel+Wsc.litmus new file mode 100644 index 0000000000..7fc79dbbaa --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/a1_reorder+rel+Wsc.litmus @@ -0,0 +1,16 @@ +OPENCL a1_reorder+rel+Wsc +{ [x] = 0; [y] = 0; [zero] = 0; } + +P0@wg 0, dev 0 (global atomic_int* x, global atomic_int* y, global atomic_int* zero) { + atomic_store_explicit(x, 1, memory_order_release); + atomic_store_explicit(y, 0, memory_order_seq_cst); +} + +P1@wg 0, dev 0 (global atomic_int* x, volatile global int* y) { + int r1 = atomic_load_explicit(x, memory_order_acquire); + if (r1) { + *y = 1; + } +} + +exists(x=1 /\ y=1) diff --git a/litmus/OPENCL/portedFromC11/auto/a1_reorder+sc+Racq.litmus b/litmus/OPENCL/portedFromC11/auto/a1_reorder+sc+Racq.litmus new file mode 100644 index 0000000000..980a9b725d --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/a1_reorder+sc+Racq.litmus @@ -0,0 +1,16 @@ +OPENCL a1_reorder+sc+Racq +{ [x] = 0; [y] = 0; [zero] = 0; } + +P0@wg 0, dev 0 (global atomic_int* x, global atomic_int* y, global atomic_int* zero) { + atomic_store_explicit(x, 1, memory_order_seq_cst); + int t7 = atomic_load_explicit(y, memory_order_acquire); +} + +P1@wg 0, dev 0 (global atomic_int* x, volatile global int* y) { + int r1 = atomic_load_explicit(x, memory_order_acquire); + if (r1) { + *y = 1; + } +} + +exists(x=1 /\ y=1) diff --git a/litmus/OPENCL/portedFromC11/auto/a1_reorder+sc+Rna.litmus b/litmus/OPENCL/portedFromC11/auto/a1_reorder+sc+Rna.litmus new file mode 100644 index 0000000000..1c2dd67261 --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/a1_reorder+sc+Rna.litmus @@ -0,0 +1,16 @@ +OPENCL a1_reorder+sc+Rna +{ [x] = 0; [y] = 0; [zero] = 0; } + +P0@wg 0, dev 0 (global atomic_int* x, global atomic_int* y, global atomic_int* zero) { + atomic_store_explicit(x, 1, memory_order_seq_cst); + int t5 = *y; +} + +P1@wg 0, dev 0 (global atomic_int* x, volatile global int* y) { + int r1 = atomic_load_explicit(x, memory_order_acquire); + if (r1) { + *y = 1; + } +} + +exists(x=1 /\ y=1) diff --git a/litmus/OPENCL/portedFromC11/auto/a1_reorder+sc+Rrlx.litmus b/litmus/OPENCL/portedFromC11/auto/a1_reorder+sc+Rrlx.litmus new file mode 100644 index 0000000000..989f0be926 --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/a1_reorder+sc+Rrlx.litmus @@ -0,0 +1,16 @@ +OPENCL a1_reorder+sc+Rrlx +{ [x] = 0; [y] = 0; [zero] = 0; } + +P0@wg 0, dev 0 (global atomic_int* x, global atomic_int* y, global atomic_int* zero) { + atomic_store_explicit(x, 1, memory_order_seq_cst); + int t9 = atomic_load_explicit(y, memory_order_relaxed); +} + +P1@wg 0, dev 0 (global atomic_int* x, volatile global int* y) { + int r1 = atomic_load_explicit(x, memory_order_acquire); + if (r1) { + *y = 1; + } +} + +exists(x=1 /\ y=1) diff --git a/litmus/OPENCL/portedFromC11/auto/a1_reorder+sc+Rsc.litmus b/litmus/OPENCL/portedFromC11/auto/a1_reorder+sc+Rsc.litmus new file mode 100644 index 0000000000..3449ad49c4 --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/a1_reorder+sc+Rsc.litmus @@ -0,0 +1,16 @@ +OPENCL a1_reorder+sc+Rsc +{ [x] = 0; [y] = 0; [zero] = 0; } + +P0@wg 0, dev 0 (global atomic_int* x, global atomic_int* y, global atomic_int* zero) { + atomic_store_explicit(x, 1, memory_order_seq_cst); + int t6 = atomic_load_explicit(y, memory_order_seq_cst); +} + +P1@wg 0, dev 0 (global atomic_int* x, volatile global int* y) { + int r1 = atomic_load_explicit(x, memory_order_acquire); + if (r1) { + *y = 1; + } +} + +exists(x=1 /\ y=1) diff --git a/litmus/OPENCL/portedFromC11/auto/a1_reorder+sc+Wna.litmus b/litmus/OPENCL/portedFromC11/auto/a1_reorder+sc+Wna.litmus new file mode 100644 index 0000000000..a0884f1813 --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/a1_reorder+sc+Wna.litmus @@ -0,0 +1,16 @@ +OPENCL a1_reorder+sc+Wna +{ [x] = 0; [y] = 0; [zero] = 0; } + +P0@wg 0, dev 0 (global atomic_int* x, global atomic_int* y, global atomic_int* zero) { + atomic_store_explicit(x, 1, memory_order_seq_cst); + *y = 0; +} + +P1@wg 0, dev 0 (global atomic_int* x, volatile global int* y) { + int r1 = atomic_load_explicit(x, memory_order_acquire); + if (r1) { + *y = 1; + } +} + +exists(x=1 /\ y=1) diff --git a/litmus/OPENCL/portedFromC11/auto/a1_reorder+sc+Wrel.litmus b/litmus/OPENCL/portedFromC11/auto/a1_reorder+sc+Wrel.litmus new file mode 100644 index 0000000000..bc8ab3eae6 --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/a1_reorder+sc+Wrel.litmus @@ -0,0 +1,16 @@ +OPENCL a1_reorder+sc+Wrel +{ [x] = 0; [y] = 0; [zero] = 0; } + +P0@wg 0, dev 0 (global atomic_int* x, global atomic_int* y, global atomic_int* zero) { + atomic_store_explicit(x, 1, memory_order_seq_cst); + atomic_store_explicit(y, 0, memory_order_release); +} + +P1@wg 0, dev 0 (global atomic_int* x, volatile global int* y) { + int r1 = atomic_load_explicit(x, memory_order_acquire); + if (r1) { + *y = 1; + } +} + +exists(x=1 /\ y=1) diff --git a/litmus/OPENCL/portedFromC11/auto/a1_reorder+sc+Wrlx.litmus b/litmus/OPENCL/portedFromC11/auto/a1_reorder+sc+Wrlx.litmus new file mode 100644 index 0000000000..b341ca3db4 --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/a1_reorder+sc+Wrlx.litmus @@ -0,0 +1,16 @@ +OPENCL a1_reorder+sc+Wrlx +{ [x] = 0; [y] = 0; [zero] = 0; } + +P0@wg 0, dev 0 (global atomic_int* x, global atomic_int* y, global atomic_int* zero) { + atomic_store_explicit(x, 1, memory_order_seq_cst); + atomic_store_explicit(y, 0, memory_order_relaxed); +} + +P1@wg 0, dev 0 (global atomic_int* x, volatile global int* y) { + int r1 = atomic_load_explicit(x, memory_order_acquire); + if (r1) { + *y = 1; + } +} + +exists(x=1 /\ y=1) diff --git a/litmus/OPENCL/portedFromC11/auto/a1_reorder+sc+Wsc.litmus b/litmus/OPENCL/portedFromC11/auto/a1_reorder+sc+Wsc.litmus new file mode 100644 index 0000000000..6d2d7b479b --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/a1_reorder+sc+Wsc.litmus @@ -0,0 +1,16 @@ +OPENCL a1_reorder+sc+Wsc +{ [x] = 0; [y] = 0; [zero] = 0; } + +P0@wg 0, dev 0 (global atomic_int* x, global atomic_int* y, global atomic_int* zero) { + atomic_store_explicit(x, 1, memory_order_seq_cst); + atomic_store_explicit(y, 0, memory_order_seq_cst); +} + +P1@wg 0, dev 0 (global atomic_int* x, volatile global int* y) { + int r1 = atomic_load_explicit(x, memory_order_acquire); + if (r1) { + *y = 1; + } +} + +exists(x=1 /\ y=1) diff --git a/litmus/OPENCL/portedFromC11/auto/a1_reorder.litmus b/litmus/OPENCL/portedFromC11/auto/a1_reorder.litmus new file mode 100644 index 0000000000..250f0ca725 --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/a1_reorder.litmus @@ -0,0 +1,16 @@ +OPENCL a1_reorder +{ [x] = 0; [y] = 0; } + +P0@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + atomic_store_explicit(x, 1, memory_order_release); + int r0 = atomic_load_explicit(y, memory_order_relaxed); +} + +P1@wg 0, dev 0 (global atomic_int* x, volatile global int* y) { + int r1 = atomic_load_explicit(x, memory_order_acquire); + if (r1) { + *y = 1; + } +} + +exists(x=1 /\ y=1) diff --git a/litmus/OPENCL/portedFromC11/auto/a3+acq+Racq.litmus b/litmus/OPENCL/portedFromC11/auto/a3+acq+Racq.litmus new file mode 100644 index 0000000000..98e810e19c --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/a3+acq+Racq.litmus @@ -0,0 +1,16 @@ +OPENCL a3+acq+Racq +{ [x] = 0; [y] = 0; [zero] = 0; } + +P0@wg 0, dev 0 (global atomic_int* x, volatile global int* y) { + *y = 1; + atomic_store_explicit(x, 1, memory_order_release); +} + +P1@wg 0, dev 0 (global atomic_int* x, global atomic_int* y, global atomic_int* zero) { + int r1 = atomic_load_explicit(x, memory_order_acquire); + if (r1) { + int t2 = atomic_load_explicit(y, memory_order_acquire); + } +} + +exists(1:r1=1) diff --git a/litmus/OPENCL/portedFromC11/auto/a3+acq+Rna.litmus b/litmus/OPENCL/portedFromC11/auto/a3+acq+Rna.litmus new file mode 100644 index 0000000000..ee4a96fc21 --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/a3+acq+Rna.litmus @@ -0,0 +1,16 @@ +OPENCL a3+acq+Rna +{ [x] = 0; [y] = 0; [zero] = 0; } + +P0@wg 0, dev 0 (global atomic_int* x, volatile global int* y) { + *y = 1; + atomic_store_explicit(x, 1, memory_order_release); +} + +P1@wg 0, dev 0 (global atomic_int* x, global atomic_int* y, global atomic_int* zero) { + int r1 = atomic_load_explicit(x, memory_order_acquire); + if (r1) { + int t0 = *y; + } +} + +exists(1:r1=1) diff --git a/litmus/OPENCL/portedFromC11/auto/a3+acq+Rrlx.litmus b/litmus/OPENCL/portedFromC11/auto/a3+acq+Rrlx.litmus new file mode 100644 index 0000000000..078c0733a1 --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/a3+acq+Rrlx.litmus @@ -0,0 +1,16 @@ +OPENCL a3+acq+Rrlx +{ [x] = 0; [y] = 0; [zero] = 0; } + +P0@wg 0, dev 0 (global atomic_int* x, volatile global int* y) { + *y = 1; + atomic_store_explicit(x, 1, memory_order_release); +} + +P1@wg 0, dev 0 (global atomic_int* x, global atomic_int* y, global atomic_int* zero) { + int r1 = atomic_load_explicit(x, memory_order_acquire); + if (r1) { + int t4 = atomic_load_explicit(y, memory_order_relaxed); + } +} + +exists(1:r1=1) diff --git a/litmus/OPENCL/portedFromC11/auto/a3+acq+Rsc.litmus b/litmus/OPENCL/portedFromC11/auto/a3+acq+Rsc.litmus new file mode 100644 index 0000000000..966971da12 --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/a3+acq+Rsc.litmus @@ -0,0 +1,16 @@ +OPENCL a3+acq+Rsc +{ [x] = 0; [y] = 0; [zero] = 0; } + +P0@wg 0, dev 0 (global atomic_int* x, volatile global int* y) { + *y = 1; + atomic_store_explicit(x, 1, memory_order_release); +} + +P1@wg 0, dev 0 (global atomic_int* x, global atomic_int* y, global atomic_int* zero) { + int r1 = atomic_load_explicit(x, memory_order_acquire); + if (r1) { + int t1 = atomic_load_explicit(y, memory_order_seq_cst); + } +} + +exists(1:r1=1) diff --git a/litmus/OPENCL/portedFromC11/auto/a3+acq+Wna.litmus b/litmus/OPENCL/portedFromC11/auto/a3+acq+Wna.litmus new file mode 100644 index 0000000000..1f439151bd --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/a3+acq+Wna.litmus @@ -0,0 +1,16 @@ +OPENCL a3+acq+Wna +{ [x] = 0; [y] = 0; [zero] = 0; } + +P0@wg 0, dev 0 (global atomic_int* x, volatile global int* y) { + *y = 1; + atomic_store_explicit(x, 1, memory_order_release); +} + +P1@wg 0, dev 0 (global atomic_int* x, global atomic_int* y, global atomic_int* zero) { + int r1 = atomic_load_explicit(x, memory_order_acquire); + if (r1) { + *y = 1; + } +} + +exists(1:r1=1) diff --git a/litmus/OPENCL/portedFromC11/auto/a3+acq+Wrel.litmus b/litmus/OPENCL/portedFromC11/auto/a3+acq+Wrel.litmus new file mode 100644 index 0000000000..e098915534 --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/a3+acq+Wrel.litmus @@ -0,0 +1,16 @@ +OPENCL a3+acq+Wrel +{ [x] = 0; [y] = 0; [zero] = 0; } + +P0@wg 0, dev 0 (global atomic_int* x, volatile global int* y) { + *y = 1; + atomic_store_explicit(x, 1, memory_order_release); +} + +P1@wg 0, dev 0 (global atomic_int* x, global atomic_int* y, global atomic_int* zero) { + int r1 = atomic_load_explicit(x, memory_order_acquire); + if (r1) { + atomic_store_explicit(y, 1, memory_order_release); + } +} + +exists(1:r1=1) diff --git a/litmus/OPENCL/portedFromC11/auto/a3+acq+Wrlx.litmus b/litmus/OPENCL/portedFromC11/auto/a3+acq+Wrlx.litmus new file mode 100644 index 0000000000..02d8b716fc --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/a3+acq+Wrlx.litmus @@ -0,0 +1,16 @@ +OPENCL a3+acq+Wrlx +{ [x] = 0; [y] = 0; [zero] = 0; } + +P0@wg 0, dev 0 (global atomic_int* x, volatile global int* y) { + *y = 1; + atomic_store_explicit(x, 1, memory_order_release); +} + +P1@wg 0, dev 0 (global atomic_int* x, global atomic_int* y, global atomic_int* zero) { + int r1 = atomic_load_explicit(x, memory_order_acquire); + if (r1) { + atomic_store_explicit(y, 1, memory_order_relaxed); + } +} + +exists(1:r1=1) diff --git a/litmus/OPENCL/portedFromC11/auto/a3+acq+Wsc.litmus b/litmus/OPENCL/portedFromC11/auto/a3+acq+Wsc.litmus new file mode 100644 index 0000000000..a09b720458 --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/a3+acq+Wsc.litmus @@ -0,0 +1,16 @@ +OPENCL a3+acq+Wsc +{ [x] = 0; [y] = 0; [zero] = 0; } + +P0@wg 0, dev 0 (global atomic_int* x, volatile global int* y) { + *y = 1; + atomic_store_explicit(x, 1, memory_order_release); +} + +P1@wg 0, dev 0 (global atomic_int* x, global atomic_int* y, global atomic_int* zero) { + int r1 = atomic_load_explicit(x, memory_order_acquire); + if (r1) { + atomic_store_explicit(y, 1, memory_order_seq_cst); + } +} + +exists(1:r1=1) diff --git a/litmus/OPENCL/portedFromC11/auto/a3+sc+Racq.litmus b/litmus/OPENCL/portedFromC11/auto/a3+sc+Racq.litmus new file mode 100644 index 0000000000..ca739cf590 --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/a3+sc+Racq.litmus @@ -0,0 +1,16 @@ +OPENCL a3+sc+Racq +{ [x] = 0; [y] = 0; [zero] = 0; } + +P0@wg 0, dev 0 (global atomic_int* x, volatile global int* y) { + *y = 1; + atomic_store_explicit(x, 1, memory_order_release); +} + +P1@wg 0, dev 0 (global atomic_int* x, global atomic_int* y, global atomic_int* zero) { + int r1 = atomic_load_explicit(x, memory_order_seq_cst); + if (r1) { + int t7 = atomic_load_explicit(y, memory_order_acquire); + } +} + +exists(1:r1=1) diff --git a/litmus/OPENCL/portedFromC11/auto/a3+sc+Rna.litmus b/litmus/OPENCL/portedFromC11/auto/a3+sc+Rna.litmus new file mode 100644 index 0000000000..70d42d5e43 --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/a3+sc+Rna.litmus @@ -0,0 +1,16 @@ +OPENCL a3+sc+Rna +{ [x] = 0; [y] = 0; [zero] = 0; } + +P0@wg 0, dev 0 (global atomic_int* x, volatile global int* y) { + *y = 1; + atomic_store_explicit(x, 1, memory_order_release); +} + +P1@wg 0, dev 0 (global atomic_int* x, global atomic_int* y, global atomic_int* zero) { + int r1 = atomic_load_explicit(x, memory_order_seq_cst); + if (r1) { + int t5 = *y; + } +} + +exists(1:r1=1) diff --git a/litmus/OPENCL/portedFromC11/auto/a3+sc+Rrlx.litmus b/litmus/OPENCL/portedFromC11/auto/a3+sc+Rrlx.litmus new file mode 100644 index 0000000000..c018778c6f --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/a3+sc+Rrlx.litmus @@ -0,0 +1,16 @@ +OPENCL a3+sc+Rrlx +{ [x] = 0; [y] = 0; [zero] = 0; } + +P0@wg 0, dev 0 (global atomic_int* x, volatile global int* y) { + *y = 1; + atomic_store_explicit(x, 1, memory_order_release); +} + +P1@wg 0, dev 0 (global atomic_int* x, global atomic_int* y, global atomic_int* zero) { + int r1 = atomic_load_explicit(x, memory_order_seq_cst); + if (r1) { + int t9 = atomic_load_explicit(y, memory_order_relaxed); + } +} + +exists(1:r1=1) diff --git a/litmus/OPENCL/portedFromC11/auto/a3+sc+Rsc.litmus b/litmus/OPENCL/portedFromC11/auto/a3+sc+Rsc.litmus new file mode 100644 index 0000000000..c3381460b8 --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/a3+sc+Rsc.litmus @@ -0,0 +1,16 @@ +OPENCL a3+sc+Rsc +{ [x] = 0; [y] = 0; [zero] = 0; } + +P0@wg 0, dev 0 (global atomic_int* x, volatile global int* y) { + *y = 1; + atomic_store_explicit(x, 1, memory_order_release); +} + +P1@wg 0, dev 0 (global atomic_int* x, global atomic_int* y, global atomic_int* zero) { + int r1 = atomic_load_explicit(x, memory_order_seq_cst); + if (r1) { + int t6 = atomic_load_explicit(y, memory_order_seq_cst); + } +} + +exists(1:r1=1) diff --git a/litmus/OPENCL/portedFromC11/auto/a3+sc+Wna.litmus b/litmus/OPENCL/portedFromC11/auto/a3+sc+Wna.litmus new file mode 100644 index 0000000000..b751341f7b --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/a3+sc+Wna.litmus @@ -0,0 +1,16 @@ +OPENCL a3+sc+Wna +{ [x] = 0; [y] = 0; [zero] = 0; } + +P0@wg 0, dev 0 (global atomic_int* x, volatile global int* y) { + *y = 1; + atomic_store_explicit(x, 1, memory_order_release); +} + +P1@wg 0, dev 0 (global atomic_int* x, global atomic_int* y, global atomic_int* zero) { + int r1 = atomic_load_explicit(x, memory_order_seq_cst); + if (r1) { + *y = 1; + } +} + +exists(1:r1=1) diff --git a/litmus/OPENCL/portedFromC11/auto/a3+sc+Wrel.litmus b/litmus/OPENCL/portedFromC11/auto/a3+sc+Wrel.litmus new file mode 100644 index 0000000000..9a3d05199c --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/a3+sc+Wrel.litmus @@ -0,0 +1,16 @@ +OPENCL a3+sc+Wrel +{ [x] = 0; [y] = 0; [zero] = 0; } + +P0@wg 0, dev 0 (global atomic_int* x, volatile global int* y) { + *y = 1; + atomic_store_explicit(x, 1, memory_order_release); +} + +P1@wg 0, dev 0 (global atomic_int* x, global atomic_int* y, global atomic_int* zero) { + int r1 = atomic_load_explicit(x, memory_order_seq_cst); + if (r1) { + atomic_store_explicit(y, 1, memory_order_release); + } +} + +exists(1:r1=1) diff --git a/litmus/OPENCL/portedFromC11/auto/a3+sc+Wrlx.litmus b/litmus/OPENCL/portedFromC11/auto/a3+sc+Wrlx.litmus new file mode 100644 index 0000000000..4e2cc5694b --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/a3+sc+Wrlx.litmus @@ -0,0 +1,16 @@ +OPENCL a3+sc+Wrlx +{ [x] = 0; [y] = 0; [zero] = 0; } + +P0@wg 0, dev 0 (global atomic_int* x, volatile global int* y) { + *y = 1; + atomic_store_explicit(x, 1, memory_order_release); +} + +P1@wg 0, dev 0 (global atomic_int* x, global atomic_int* y, global atomic_int* zero) { + int r1 = atomic_load_explicit(x, memory_order_seq_cst); + if (r1) { + atomic_store_explicit(y, 1, memory_order_relaxed); + } +} + +exists(1:r1=1) diff --git a/litmus/OPENCL/portedFromC11/auto/a3+sc+Wsc.litmus b/litmus/OPENCL/portedFromC11/auto/a3+sc+Wsc.litmus new file mode 100644 index 0000000000..6181e26971 --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/a3+sc+Wsc.litmus @@ -0,0 +1,16 @@ +OPENCL a3+sc+Wsc +{ [x] = 0; [y] = 0; [zero] = 0; } + +P0@wg 0, dev 0 (global atomic_int* x, volatile global int* y) { + *y = 1; + atomic_store_explicit(x, 1, memory_order_release); +} + +P1@wg 0, dev 0 (global atomic_int* x, global atomic_int* y, global atomic_int* zero) { + int r1 = atomic_load_explicit(x, memory_order_seq_cst); + if (r1) { + atomic_store_explicit(y, 1, memory_order_seq_cst); + } +} + +exists(1:r1=1) diff --git a/litmus/OPENCL/portedFromC11/auto/a3.litmus b/litmus/OPENCL/portedFromC11/auto/a3.litmus new file mode 100644 index 0000000000..fd4b5daf5b --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/a3.litmus @@ -0,0 +1,16 @@ +OPENCL a3 +{ [x] = 0; [y] = 0; } + +P0@wg 0, dev 0 (global atomic_int* x, volatile global int* y) { + *y = 1; + atomic_store_explicit(x, 1, memory_order_release); +} + +P1@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + int r1 = atomic_load_explicit(x, memory_order_acquire); + if (r1) { + int r2 = atomic_load_explicit(y, memory_order_relaxed); + } +} + +exists (1:r1=1) diff --git a/litmus/OPENCL/portedFromC11/auto/a3_reorder+Racq+acq.litmus b/litmus/OPENCL/portedFromC11/auto/a3_reorder+Racq+acq.litmus new file mode 100644 index 0000000000..eedd6d7eed --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/a3_reorder+Racq+acq.litmus @@ -0,0 +1,14 @@ +OPENCL a3_reorder+Racq+acq +{ [x] = 0; [y] = 0; [zero] = 0; } + +P0@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + *y = 1; + atomic_store_explicit(x, 1, memory_order_release); +} + +P1@wg 0, dev 0 (global atomic_int* x, global atomic_int* y, global atomic_int* zero) { + int t2 = atomic_load_explicit(y, memory_order_acquire); + int r1 = atomic_load_explicit(x, memory_order_acquire); +} + +exists (1:r1=1) diff --git a/litmus/OPENCL/portedFromC11/auto/a3_reorder+Racq+sc.litmus b/litmus/OPENCL/portedFromC11/auto/a3_reorder+Racq+sc.litmus new file mode 100644 index 0000000000..c0e29d195e --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/a3_reorder+Racq+sc.litmus @@ -0,0 +1,14 @@ +OPENCL a3_reorder+Racq+sc +{ [x] = 0; [y] = 0; [zero] = 0; } + +P0@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + *y = 1; + atomic_store_explicit(x, 1, memory_order_release); +} + +P1@wg 0, dev 0 (global atomic_int* x, global atomic_int* y, global atomic_int* zero) { + int t2 = atomic_load_explicit(y, memory_order_acquire); + int r1 = atomic_load_explicit(x, memory_order_seq_cst); +} + +exists (1:r1=1) diff --git a/litmus/OPENCL/portedFromC11/auto/a3_reorder+Rna+acq.litmus b/litmus/OPENCL/portedFromC11/auto/a3_reorder+Rna+acq.litmus new file mode 100644 index 0000000000..dab9b34c44 --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/a3_reorder+Rna+acq.litmus @@ -0,0 +1,14 @@ +OPENCL a3_reorder+Rna+acq +{ [x] = 0; [y] = 0; [zero] = 0; } + +P0@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + *y = 1; + atomic_store_explicit(x, 1, memory_order_release); +} + +P1@wg 0, dev 0 (global atomic_int* x, global atomic_int* y, global atomic_int* zero) { + int t0 = *y; + int r1 = atomic_load_explicit(x, memory_order_acquire); +} + +exists (1:r1=1) diff --git a/litmus/OPENCL/portedFromC11/auto/a3_reorder+Rna+sc.litmus b/litmus/OPENCL/portedFromC11/auto/a3_reorder+Rna+sc.litmus new file mode 100644 index 0000000000..817e754880 --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/a3_reorder+Rna+sc.litmus @@ -0,0 +1,14 @@ +OPENCL a3_reorder+Rna+sc +{ [x] = 0; [y] = 0; [zero] = 0; } + +P0@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + *y = 1; + atomic_store_explicit(x, 1, memory_order_release); +} + +P1@wg 0, dev 0 (global atomic_int* x, global atomic_int* y, global atomic_int* zero) { + int t0 = *y; + int r1 = atomic_load_explicit(x, memory_order_seq_cst); +} + +exists (1:r1=1) diff --git a/litmus/OPENCL/portedFromC11/auto/a3_reorder+Rrlx+acq.litmus b/litmus/OPENCL/portedFromC11/auto/a3_reorder+Rrlx+acq.litmus new file mode 100644 index 0000000000..7b5c4c37ff --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/a3_reorder+Rrlx+acq.litmus @@ -0,0 +1,14 @@ +OPENCL a3_reorder+Rrlx+acq +{ [x] = 0; [y] = 0; [zero] = 0; } + +P0@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + *y = 1; + atomic_store_explicit(x, 1, memory_order_release); +} + +P1@wg 0, dev 0 (global atomic_int* x, global atomic_int* y, global atomic_int* zero) { + int t4 = atomic_load_explicit(y, memory_order_relaxed); + int r1 = atomic_load_explicit(x, memory_order_acquire); +} + +exists (1:r1=1) diff --git a/litmus/OPENCL/portedFromC11/auto/a3_reorder+Rrlx+sc.litmus b/litmus/OPENCL/portedFromC11/auto/a3_reorder+Rrlx+sc.litmus new file mode 100644 index 0000000000..c7fd025186 --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/a3_reorder+Rrlx+sc.litmus @@ -0,0 +1,14 @@ +OPENCL a3_reorder+Rrlx+sc +{ [x] = 0; [y] = 0; [zero] = 0; } + +P0@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + *y = 1; + atomic_store_explicit(x, 1, memory_order_release); +} + +P1@wg 0, dev 0 (global atomic_int* x, global atomic_int* y, global atomic_int* zero) { + int t4 = atomic_load_explicit(y, memory_order_relaxed); + int r1 = atomic_load_explicit(x, memory_order_seq_cst); +} + +exists (1:r1=1) diff --git a/litmus/OPENCL/portedFromC11/auto/a3_reorder+Rsc+acq.litmus b/litmus/OPENCL/portedFromC11/auto/a3_reorder+Rsc+acq.litmus new file mode 100644 index 0000000000..0db4a58002 --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/a3_reorder+Rsc+acq.litmus @@ -0,0 +1,14 @@ +OPENCL a3_reorder+Rsc+acq +{ [x] = 0; [y] = 0; [zero] = 0; } + +P0@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + *y = 1; + atomic_store_explicit(x, 1, memory_order_release); +} + +P1@wg 0, dev 0 (global atomic_int* x, global atomic_int* y, global atomic_int* zero) { + int t1 = atomic_load_explicit(y, memory_order_seq_cst); + int r1 = atomic_load_explicit(x, memory_order_acquire); +} + +exists (1:r1=1) diff --git a/litmus/OPENCL/portedFromC11/auto/a3_reorder+Rsc+sc.litmus b/litmus/OPENCL/portedFromC11/auto/a3_reorder+Rsc+sc.litmus new file mode 100644 index 0000000000..3f3ba3e7ad --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/a3_reorder+Rsc+sc.litmus @@ -0,0 +1,14 @@ +OPENCL a3_reorder+Rsc+sc +{ [x] = 0; [y] = 0; [zero] = 0; } + +P0@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + *y = 1; + atomic_store_explicit(x, 1, memory_order_release); +} + +P1@wg 0, dev 0 (global atomic_int* x, global atomic_int* y, global atomic_int* zero) { + int t1 = atomic_load_explicit(y, memory_order_seq_cst); + int r1 = atomic_load_explicit(x, memory_order_seq_cst); +} + +exists (1:r1=1) diff --git a/litmus/OPENCL/portedFromC11/auto/a3_reorder+Wna+acq.litmus b/litmus/OPENCL/portedFromC11/auto/a3_reorder+Wna+acq.litmus new file mode 100644 index 0000000000..36dd1f4e9e --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/a3_reorder+Wna+acq.litmus @@ -0,0 +1,14 @@ +OPENCL a3_reorder+Wna+acq +{ [x] = 0; [y] = 0; [zero] = 0; } + +P0@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + *y = 1; + atomic_store_explicit(x, 1, memory_order_release); +} + +P1@wg 0, dev 0 (global atomic_int* x, global atomic_int* y, global atomic_int* zero) { + *y = 1; + int r1 = atomic_load_explicit(x, memory_order_acquire); +} + +exists (1:r1=1) diff --git a/litmus/OPENCL/portedFromC11/auto/a3_reorder+Wna+sc.litmus b/litmus/OPENCL/portedFromC11/auto/a3_reorder+Wna+sc.litmus new file mode 100644 index 0000000000..c5e02d2b34 --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/a3_reorder+Wna+sc.litmus @@ -0,0 +1,14 @@ +OPENCL a3_reorder+Wna+sc +{ [x] = 0; [y] = 0; [zero] = 0; } + +P0@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + *y = 1; + atomic_store_explicit(x, 1, memory_order_release); +} + +P1@wg 0, dev 0 (global atomic_int* x, global atomic_int* y, global atomic_int* zero) { + *y = 1; + int r1 = atomic_load_explicit(x, memory_order_seq_cst); +} + +exists (1:r1=1) diff --git a/litmus/OPENCL/portedFromC11/auto/a3_reorder+Wrel+acq.litmus b/litmus/OPENCL/portedFromC11/auto/a3_reorder+Wrel+acq.litmus new file mode 100644 index 0000000000..4a1c4f9c6c --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/a3_reorder+Wrel+acq.litmus @@ -0,0 +1,14 @@ +OPENCL a3_reorder+Wrel+acq +{ [x] = 0; [y] = 0; [zero] = 0; } + +P0@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + *y = 1; + atomic_store_explicit(x, 1, memory_order_release); +} + +P1@wg 0, dev 0 (global atomic_int* x, global atomic_int* y, global atomic_int* zero) { + atomic_store_explicit(y, 1, memory_order_release); + int r1 = atomic_load_explicit(x, memory_order_acquire); +} + +exists (1:r1=1) diff --git a/litmus/OPENCL/portedFromC11/auto/a3_reorder+Wrel+sc.litmus b/litmus/OPENCL/portedFromC11/auto/a3_reorder+Wrel+sc.litmus new file mode 100644 index 0000000000..e34b8258e6 --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/a3_reorder+Wrel+sc.litmus @@ -0,0 +1,14 @@ +OPENCL a3_reorder+Wrel+sc +{ [x] = 0; [y] = 0; [zero] = 0; } + +P0@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + *y = 1; + atomic_store_explicit(x, 1, memory_order_release); +} + +P1@wg 0, dev 0 (global atomic_int* x, global atomic_int* y, global atomic_int* zero) { + atomic_store_explicit(y, 1, memory_order_release); + int r1 = atomic_load_explicit(x, memory_order_seq_cst); +} + +exists (1:r1=1) diff --git a/litmus/OPENCL/portedFromC11/auto/a3_reorder+Wrlx+acq.litmus b/litmus/OPENCL/portedFromC11/auto/a3_reorder+Wrlx+acq.litmus new file mode 100644 index 0000000000..bfb8cf6641 --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/a3_reorder+Wrlx+acq.litmus @@ -0,0 +1,14 @@ +OPENCL a3_reorder+Wrlx+acq +{ [x] = 0; [y] = 0; [zero] = 0; } + +P0@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + *y = 1; + atomic_store_explicit(x, 1, memory_order_release); +} + +P1@wg 0, dev 0 (global atomic_int* x, global atomic_int* y, global atomic_int* zero) { + atomic_store_explicit(y, 1, memory_order_relaxed); + int r1 = atomic_load_explicit(x, memory_order_acquire); +} + +exists (1:r1=1) diff --git a/litmus/OPENCL/portedFromC11/auto/a3_reorder+Wrlx+sc.litmus b/litmus/OPENCL/portedFromC11/auto/a3_reorder+Wrlx+sc.litmus new file mode 100644 index 0000000000..84fb3f1c90 --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/a3_reorder+Wrlx+sc.litmus @@ -0,0 +1,14 @@ +OPENCL a3_reorder+Wrlx+sc +{ [x] = 0; [y] = 0; [zero] = 0; } + +P0@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + *y = 1; + atomic_store_explicit(x, 1, memory_order_release); +} + +P1@wg 0, dev 0 (global atomic_int* x, global atomic_int* y, global atomic_int* zero) { + atomic_store_explicit(y, 1, memory_order_relaxed); + int r1 = atomic_load_explicit(x, memory_order_seq_cst); +} + +exists (1:r1=1) diff --git a/litmus/OPENCL/portedFromC11/auto/a3_reorder+Wsc+acq.litmus b/litmus/OPENCL/portedFromC11/auto/a3_reorder+Wsc+acq.litmus new file mode 100644 index 0000000000..54628b9cbc --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/a3_reorder+Wsc+acq.litmus @@ -0,0 +1,14 @@ +OPENCL a3_reorder+Wsc+acq +{ [x] = 0; [y] = 0; [zero] = 0; } + +P0@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + *y = 1; + atomic_store_explicit(x, 1, memory_order_release); +} + +P1@wg 0, dev 0 (global atomic_int* x, global atomic_int* y, global atomic_int* zero) { + atomic_store_explicit(y, 1, memory_order_seq_cst); + int r1 = atomic_load_explicit(x, memory_order_acquire); +} + +exists (1:r1=1) diff --git a/litmus/OPENCL/portedFromC11/auto/a3_reorder+Wsc+sc.litmus b/litmus/OPENCL/portedFromC11/auto/a3_reorder+Wsc+sc.litmus new file mode 100644 index 0000000000..66b762ae8a --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/a3_reorder+Wsc+sc.litmus @@ -0,0 +1,14 @@ +OPENCL a3_reorder+Wsc+sc +{ [x] = 0; [y] = 0; [zero] = 0; } + +P0@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + *y = 1; + atomic_store_explicit(x, 1, memory_order_release); +} + +P1@wg 0, dev 0 (global atomic_int* x, global atomic_int* y, global atomic_int* zero) { + atomic_store_explicit(y, 1, memory_order_seq_cst); + int r1 = atomic_load_explicit(x, memory_order_seq_cst); +} + +exists (1:r1=1) diff --git a/litmus/OPENCL/portedFromC11/auto/a3_reorder.litmus b/litmus/OPENCL/portedFromC11/auto/a3_reorder.litmus new file mode 100644 index 0000000000..f97927cbdc --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/a3_reorder.litmus @@ -0,0 +1,14 @@ +OPENCL a3_reorder +{ [x] = 0; [y] = 0; } + +P0@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + *y = 1; + atomic_store_explicit(x, 1, memory_order_release); +} + +P1@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + int r2 = atomic_load_explicit(y, memory_order_relaxed); + int r1 = atomic_load_explicit(x, memory_order_acquire); +} + +exists (1:r1=1) diff --git a/litmus/OPENCL/portedFromC11/auto/a3v2.litmus b/litmus/OPENCL/portedFromC11/auto/a3v2.litmus new file mode 100644 index 0000000000..b99a5c68c0 --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/a3v2.litmus @@ -0,0 +1,17 @@ +OPENCL a3v2 +{ [x] = 0; [y] = 0; [one] = 1; } + +P0@wg 0, dev 0 (global atomic_int* x, volatile global int* y) { + *y = 1; + atomic_store_explicit(x, 1, memory_order_release); +} + +P1@wg 0, dev 0 (global atomic_int* x, volatile global int* y, global atomic_int* one) { + int r0 = atomic_compare_exchange_strong_explicit(x, one, 2, memory_order_acquire, memory_order_relaxed); + int r1 = -1; + if (r0) { // cas must have returned true to exit elided while loop + r1 = *y; + } +} + +exists (1:r1=1) diff --git a/litmus/OPENCL/portedFromC11/auto/a4.litmus b/litmus/OPENCL/portedFromC11/auto/a4.litmus new file mode 100644 index 0000000000..d7b3e82b77 --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/a4.litmus @@ -0,0 +1,14 @@ +OPENCL a4 +{ [x] = 0; [y] = 0; } + +P0@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + atomic_store_explicit(x, 1, memory_order_seq_cst); + int r1 = atomic_load_explicit(y, memory_order_seq_cst); +} + +P1@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + atomic_store_explicit(y, 1, memory_order_seq_cst); + int r2 = atomic_load_explicit(x, memory_order_seq_cst); +} + +exists (0:r1=0 /\ 1:r2=0) diff --git a/litmus/OPENCL/portedFromC11/auto/a4_reorder.litmus b/litmus/OPENCL/portedFromC11/auto/a4_reorder.litmus new file mode 100644 index 0000000000..e853d0ebec --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/a4_reorder.litmus @@ -0,0 +1,14 @@ +OPENCL a4_reorder +{ [x] = 0; [y] = 0; } + +P0@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + int r1 = atomic_load_explicit(y, memory_order_seq_cst); + atomic_store_explicit(x, 1, memory_order_seq_cst); +} + +P1@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + atomic_store_explicit(y, 1, memory_order_seq_cst); + int r2 = atomic_load_explicit(x, memory_order_seq_cst); +} + +exists (0:r1=0 /\ 1:r2=0) diff --git a/litmus/OPENCL/portedFromC11/auto/arfna.litmus b/litmus/OPENCL/portedFromC11/auto/arfna.litmus new file mode 100644 index 0000000000..e7754681a5 --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/arfna.litmus @@ -0,0 +1,25 @@ +OPENCL arfna +{ [a] = 0; [b] = 0; [x] = 0; [y] = 0; } + +P0@wg 0, dev 0 (volatile global int* a, volatile global int* b, global atomic_int* x, global atomic_int* y) { + int r0 = atomic_load_explicit(x, memory_order_relaxed); + if (r0) { + int t = *a; + *b = 1; + if (t) { + atomic_store_explicit(y, 1, memory_order_relaxed); + } + } +} + +P1@wg 0, dev 0 (volatile global int* a, volatile global int* b, global atomic_int* x, global atomic_int* y) { + int r1 = atomic_load_explicit(y, memory_order_relaxed); + if (r1) { + if (*b) { + *a = 1; + atomic_store_explicit(x, 1, memory_order_relaxed); + } + } +} + +exists (x=1 /\ y=1) diff --git a/litmus/OPENCL/portedFromC11/auto/arfna2.litmus b/litmus/OPENCL/portedFromC11/auto/arfna2.litmus new file mode 100644 index 0000000000..24fc604221 --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/arfna2.litmus @@ -0,0 +1,25 @@ +OPENCL arfna_transformed +{ [a] = 0; [b] = 0; [x] = 0; [y] = 0; } + +P0@wg 0, dev 0 (volatile global int* a, volatile global int* b, global atomic_int* x, global atomic_int* y) { + int r0 = atomic_load_explicit(x, memory_order_relaxed); + if (r0) { + *b = 1; + int t = *a; + if (t) { + atomic_store_explicit(y, 1, memory_order_relaxed); + } + } +} + +P1@wg 0, dev 0 (volatile global int* a, volatile global int* b, global atomic_int* x, global atomic_int* y) { + int r1 = atomic_load_explicit(y, memory_order_relaxed); + if (r1) { + if (*b) { + *a = 1; + atomic_store_explicit(x, 1, memory_order_relaxed); + } + } +} + +exists (x=1 /\ y=1) diff --git a/litmus/OPENCL/portedFromC11/auto/b+acq+rel.litmus b/litmus/OPENCL/portedFromC11/auto/b+acq+rel.litmus new file mode 100644 index 0000000000..86ac5074f4 --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/b+acq+rel.litmus @@ -0,0 +1,14 @@ +OPENCL b+acq+rel +{ [x] = 0; [y] = 0; } + +P0@wg 0, dev 0 (volatile global int* x, volatile global int* y) { + int r0 = atomic_load_explicit(x, memory_order_acquire); + atomic_store_explicit(y, 1, memory_order_release); +} + +P1@wg 0, dev 0 (volatile global int* x, volatile global int* y) { + int r1 = atomic_load_explicit(y, memory_order_relaxed); + atomic_store_explicit(x, 1, memory_order_relaxed); +} + +exists (0:r0=1 /\ 1:r1=1) diff --git a/litmus/OPENCL/portedFromC11/auto/b+acq+rlx.litmus b/litmus/OPENCL/portedFromC11/auto/b+acq+rlx.litmus new file mode 100644 index 0000000000..5e559923bb --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/b+acq+rlx.litmus @@ -0,0 +1,14 @@ +OPENCL b+acq+rlx +{ [x] = 0; [y] = 0; } + +P0@wg 0, dev 0 (volatile global int* x, volatile global int* y) { + int r0 = atomic_load_explicit(x, memory_order_acquire); + atomic_store_explicit(y, 1, memory_order_relaxed); +} + +P1@wg 0, dev 0 (volatile global int* x, volatile global int* y) { + int r1 = atomic_load_explicit(y, memory_order_relaxed); + atomic_store_explicit(x, 1, memory_order_relaxed); +} + +exists (0:r0=1 /\ 1:r1=1) diff --git a/litmus/OPENCL/portedFromC11/auto/b+acq+sc.litmus b/litmus/OPENCL/portedFromC11/auto/b+acq+sc.litmus new file mode 100644 index 0000000000..94cace2446 --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/b+acq+sc.litmus @@ -0,0 +1,14 @@ +OPENCL b+acq+sc +{ [x] = 0; [y] = 0; } + +P0@wg 0, dev 0 (volatile global int* x, volatile global int* y) { + int r0 = atomic_load_explicit(x, memory_order_acquire); + atomic_store_explicit(y, 1, memory_order_seq_cst); +} + +P1@wg 0, dev 0 (volatile global int* x, volatile global int* y) { + int r1 = atomic_load_explicit(y, memory_order_relaxed); + atomic_store_explicit(x, 1, memory_order_relaxed); +} + +exists (0:r0=1 /\ 1:r1=1) diff --git a/litmus/OPENCL/portedFromC11/auto/b+rlx+rel.litmus b/litmus/OPENCL/portedFromC11/auto/b+rlx+rel.litmus new file mode 100644 index 0000000000..dfe5f74111 --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/b+rlx+rel.litmus @@ -0,0 +1,14 @@ +OPENCL b+rlx+rel +{ [x] = 0; [y] = 0; } + +P0@wg 0, dev 0 (volatile global int* x, volatile global int* y) { + int r0 = atomic_load_explicit(x, memory_order_relaxed); + atomic_store_explicit(y, 1, memory_order_release); +} + +P1@wg 0, dev 0 (volatile global int* x, volatile global int* y) { + int r1 = atomic_load_explicit(y, memory_order_relaxed); + atomic_store_explicit(x, 1, memory_order_relaxed); +} + +exists (0:r0=1 /\ 1:r1=1) diff --git a/litmus/OPENCL/portedFromC11/auto/b+rlx+rlx.litmus b/litmus/OPENCL/portedFromC11/auto/b+rlx+rlx.litmus new file mode 100644 index 0000000000..487fee3e33 --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/b+rlx+rlx.litmus @@ -0,0 +1,14 @@ +OPENCL b+rlx+rlx +{ [x] = 0; [y] = 0; } + +P0@wg 0, dev 0 (volatile global int* x, volatile global int* y) { + int r0 = atomic_load_explicit(x, memory_order_relaxed); + atomic_store_explicit(y, 1, memory_order_relaxed); +} + +P1@wg 0, dev 0 (volatile global int* x, volatile global int* y) { + int r1 = atomic_load_explicit(y, memory_order_relaxed); + atomic_store_explicit(x, 1, memory_order_relaxed); +} + +exists (0:r0=1 /\ 1:r1=1) diff --git a/litmus/OPENCL/portedFromC11/auto/b+rlx+sc.litmus b/litmus/OPENCL/portedFromC11/auto/b+rlx+sc.litmus new file mode 100644 index 0000000000..da4f31b28f --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/b+rlx+sc.litmus @@ -0,0 +1,14 @@ +OPENCL b+rlx+sc +{ [x] = 0; [y] = 0; } + +P0@wg 0, dev 0 (volatile global int* x, volatile global int* y) { + int r0 = atomic_load_explicit(x, memory_order_relaxed); + atomic_store_explicit(y, 1, memory_order_seq_cst); +} + +P1@wg 0, dev 0 (volatile global int* x, volatile global int* y) { + int r1 = atomic_load_explicit(y, memory_order_relaxed); + atomic_store_explicit(x, 1, memory_order_relaxed); +} + +exists (0:r0=1 /\ 1:r1=1) diff --git a/litmus/OPENCL/portedFromC11/auto/b+sc+rel.litmus b/litmus/OPENCL/portedFromC11/auto/b+sc+rel.litmus new file mode 100644 index 0000000000..cd475f6e0b --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/b+sc+rel.litmus @@ -0,0 +1,14 @@ +OPENCL b+sc+rel +{ [x] = 0; [y] = 0; } + +P0@wg 0, dev 0 (volatile global int* x, volatile global int* y) { + int r0 = atomic_load_explicit(x, memory_order_seq_cst); + atomic_store_explicit(y, 1, memory_order_release); +} + +P1@wg 0, dev 0 (volatile global int* x, volatile global int* y) { + int r1 = atomic_load_explicit(y, memory_order_relaxed); + atomic_store_explicit(x, 1, memory_order_relaxed); +} + +exists (0:r0=1 /\ 1:r1=1) diff --git a/litmus/OPENCL/portedFromC11/auto/b+sc+rlx.litmus b/litmus/OPENCL/portedFromC11/auto/b+sc+rlx.litmus new file mode 100644 index 0000000000..f93745a078 --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/b+sc+rlx.litmus @@ -0,0 +1,14 @@ +OPENCL b+sc+rlx +{ [x] = 0; [y] = 0; } + +P0@wg 0, dev 0 (volatile global int* x, volatile global int* y) { + int r0 = atomic_load_explicit(x, memory_order_seq_cst); + atomic_store_explicit(y, 1, memory_order_relaxed); +} + +P1@wg 0, dev 0 (volatile global int* x, volatile global int* y) { + int r1 = atomic_load_explicit(y, memory_order_relaxed); + atomic_store_explicit(x, 1, memory_order_relaxed); +} + +exists (0:r0=1 /\ 1:r1=1) diff --git a/litmus/OPENCL/portedFromC11/auto/b+sc+sc.litmus b/litmus/OPENCL/portedFromC11/auto/b+sc+sc.litmus new file mode 100644 index 0000000000..1dce52abcf --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/b+sc+sc.litmus @@ -0,0 +1,14 @@ +OPENCL b+sc+sc +{ [x] = 0; [y] = 0; } + +P0@wg 0, dev 0 (volatile global int* x, volatile global int* y) { + int r0 = atomic_load_explicit(x, memory_order_seq_cst); + atomic_store_explicit(y, 1, memory_order_seq_cst); +} + +P1@wg 0, dev 0 (volatile global int* x, volatile global int* y) { + int r1 = atomic_load_explicit(y, memory_order_relaxed); + atomic_store_explicit(x, 1, memory_order_relaxed); +} + +exists (0:r0=1 /\ 1:r1=1) diff --git a/litmus/OPENCL/portedFromC11/auto/b.litmus b/litmus/OPENCL/portedFromC11/auto/b.litmus new file mode 100644 index 0000000000..60520ebe19 --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/b.litmus @@ -0,0 +1,14 @@ +OPENCL b +{ [x] = 0; [y] = 0; } + +P0@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + int r0 = atomic_load_explicit(x, memory_order_relaxed); + atomic_store_explicit(y, 1, memory_order_relaxed); +} + +P1@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + int r1 = atomic_load_explicit(y, memory_order_relaxed); + atomic_store_explicit(x, 1, memory_order_relaxed); +} + +exists (0:r0=1 /\ 1:r1=1) diff --git a/litmus/OPENCL/portedFromC11/auto/b_reorder+rel+acq.litmus b/litmus/OPENCL/portedFromC11/auto/b_reorder+rel+acq.litmus new file mode 100644 index 0000000000..abd6ceab5c --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/b_reorder+rel+acq.litmus @@ -0,0 +1,14 @@ +OPENCL b_reorder+rel+acq +{ [x] = 0; [y] = 0; } + +P0@wg 0, dev 0 (volatile global int* x, volatile global int* y) { + atomic_store_explicit(y, 1, memory_order_release); + int r0 = atomic_load_explicit(x, memory_order_acquire); +} + +P1@wg 0, dev 0 (volatile global int* x, volatile global int* y) { + int r1 = atomic_load_explicit(y, memory_order_relaxed); + atomic_store_explicit(x, 1, memory_order_relaxed); +} + +exists (0:r0=1 /\ 1:r1=1) diff --git a/litmus/OPENCL/portedFromC11/auto/b_reorder+rel+rlx.litmus b/litmus/OPENCL/portedFromC11/auto/b_reorder+rel+rlx.litmus new file mode 100644 index 0000000000..ddc9700a6c --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/b_reorder+rel+rlx.litmus @@ -0,0 +1,14 @@ +OPENCL b_reorder+rel+rlx +{ [x] = 0; [y] = 0; } + +P0@wg 0, dev 0 (volatile global int* x, volatile global int* y) { + atomic_store_explicit(y, 1, memory_order_release); + int r0 = atomic_load_explicit(x, memory_order_relaxed); +} + +P1@wg 0, dev 0 (volatile global int* x, volatile global int* y) { + int r1 = atomic_load_explicit(y, memory_order_relaxed); + atomic_store_explicit(x, 1, memory_order_relaxed); +} + +exists (0:r0=1 /\ 1:r1=1) diff --git a/litmus/OPENCL/portedFromC11/auto/b_reorder+rel+sc.litmus b/litmus/OPENCL/portedFromC11/auto/b_reorder+rel+sc.litmus new file mode 100644 index 0000000000..8bc460d91b --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/b_reorder+rel+sc.litmus @@ -0,0 +1,14 @@ +OPENCL b_reorder+rel+sc +{ [x] = 0; [y] = 0; } + +P0@wg 0, dev 0 (volatile global int* x, volatile global int* y) { + atomic_store_explicit(y, 1, memory_order_release); + int r0 = atomic_load_explicit(x, memory_order_seq_cst); +} + +P1@wg 0, dev 0 (volatile global int* x, volatile global int* y) { + int r1 = atomic_load_explicit(y, memory_order_relaxed); + atomic_store_explicit(x, 1, memory_order_relaxed); +} + +exists (0:r0=1 /\ 1:r1=1) diff --git a/litmus/OPENCL/portedFromC11/auto/b_reorder+rlx+acq.litmus b/litmus/OPENCL/portedFromC11/auto/b_reorder+rlx+acq.litmus new file mode 100644 index 0000000000..570cacef45 --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/b_reorder+rlx+acq.litmus @@ -0,0 +1,14 @@ +OPENCL b_reorder+rlx+acq +{ [x] = 0; [y] = 0; } + +P0@wg 0, dev 0 (volatile global int* x, volatile global int* y) { + atomic_store_explicit(y, 1, memory_order_relaxed); + int r0 = atomic_load_explicit(x, memory_order_acquire); +} + +P1@wg 0, dev 0 (volatile global int* x, volatile global int* y) { + int r1 = atomic_load_explicit(y, memory_order_relaxed); + atomic_store_explicit(x, 1, memory_order_relaxed); +} + +exists (0:r0=1 /\ 1:r1=1) diff --git a/litmus/OPENCL/portedFromC11/auto/b_reorder+rlx+rlx.litmus b/litmus/OPENCL/portedFromC11/auto/b_reorder+rlx+rlx.litmus new file mode 100644 index 0000000000..ec4e702da4 --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/b_reorder+rlx+rlx.litmus @@ -0,0 +1,14 @@ +OPENCL b_reorder+rlx+rlx +{ [x] = 0; [y] = 0; } + +P0@wg 0, dev 0 (volatile global int* x, volatile global int* y) { + atomic_store_explicit(y, 1, memory_order_relaxed); + int r0 = atomic_load_explicit(x, memory_order_relaxed); +} + +P1@wg 0, dev 0 (volatile global int* x, volatile global int* y) { + int r1 = atomic_load_explicit(y, memory_order_relaxed); + atomic_store_explicit(x, 1, memory_order_relaxed); +} + +exists (0:r0=1 /\ 1:r1=1) diff --git a/litmus/OPENCL/portedFromC11/auto/b_reorder+rlx+sc.litmus b/litmus/OPENCL/portedFromC11/auto/b_reorder+rlx+sc.litmus new file mode 100644 index 0000000000..1078534a40 --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/b_reorder+rlx+sc.litmus @@ -0,0 +1,14 @@ +OPENCL b_reorder+rlx+sc +{ [x] = 0; [y] = 0; } + +P0@wg 0, dev 0 (volatile global int* x, volatile global int* y) { + atomic_store_explicit(y, 1, memory_order_relaxed); + int r0 = atomic_load_explicit(x, memory_order_seq_cst); +} + +P1@wg 0, dev 0 (volatile global int* x, volatile global int* y) { + int r1 = atomic_load_explicit(y, memory_order_relaxed); + atomic_store_explicit(x, 1, memory_order_relaxed); +} + +exists (0:r0=1 /\ 1:r1=1) diff --git a/litmus/OPENCL/portedFromC11/auto/b_reorder+sc+acq.litmus b/litmus/OPENCL/portedFromC11/auto/b_reorder+sc+acq.litmus new file mode 100644 index 0000000000..0c70f88802 --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/b_reorder+sc+acq.litmus @@ -0,0 +1,14 @@ +OPENCL b_reorder+sc+acq +{ [x] = 0; [y] = 0; } + +P0@wg 0, dev 0 (volatile global int* x, volatile global int* y) { + atomic_store_explicit(y, 1, memory_order_seq_cst); + int r0 = atomic_load_explicit(x, memory_order_acquire); +} + +P1@wg 0, dev 0 (volatile global int* x, volatile global int* y) { + int r1 = atomic_load_explicit(y, memory_order_relaxed); + atomic_store_explicit(x, 1, memory_order_relaxed); +} + +exists (0:r0=1 /\ 1:r1=1) diff --git a/litmus/OPENCL/portedFromC11/auto/b_reorder+sc+rlx.litmus b/litmus/OPENCL/portedFromC11/auto/b_reorder+sc+rlx.litmus new file mode 100644 index 0000000000..aaf149652b --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/b_reorder+sc+rlx.litmus @@ -0,0 +1,14 @@ +OPENCL b_reorder+sc+rlx +{ [x] = 0; [y] = 0; } + +P0@wg 0, dev 0 (volatile global int* x, volatile global int* y) { + atomic_store_explicit(y, 1, memory_order_seq_cst); + int r0 = atomic_load_explicit(x, memory_order_relaxed); +} + +P1@wg 0, dev 0 (volatile global int* x, volatile global int* y) { + int r1 = atomic_load_explicit(y, memory_order_relaxed); + atomic_store_explicit(x, 1, memory_order_relaxed); +} + +exists (0:r0=1 /\ 1:r1=1) diff --git a/litmus/OPENCL/portedFromC11/auto/b_reorder+sc+sc.litmus b/litmus/OPENCL/portedFromC11/auto/b_reorder+sc+sc.litmus new file mode 100644 index 0000000000..58d7151591 --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/b_reorder+sc+sc.litmus @@ -0,0 +1,14 @@ +OPENCL b_reorder+sc+sc +{ [x] = 0; [y] = 0; } + +P0@wg 0, dev 0 (volatile global int* x, volatile global int* y) { + atomic_store_explicit(y, 1, memory_order_seq_cst); + int r0 = atomic_load_explicit(x, memory_order_seq_cst); +} + +P1@wg 0, dev 0 (volatile global int* x, volatile global int* y) { + int r1 = atomic_load_explicit(y, memory_order_relaxed); + atomic_store_explicit(x, 1, memory_order_relaxed); +} + +exists (0:r0=1 /\ 1:r1=1) diff --git a/litmus/OPENCL/portedFromC11/auto/b_reorder.litmus b/litmus/OPENCL/portedFromC11/auto/b_reorder.litmus new file mode 100644 index 0000000000..8a06c8e63c --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/b_reorder.litmus @@ -0,0 +1,14 @@ +OPENCL b_reorder +{ [x] = 0; [y] = 0; } + +P0@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + atomic_store_explicit(y, 1, memory_order_relaxed); + int r0 = atomic_load_explicit(x, memory_order_relaxed); +} + +P1@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + int r1 = atomic_load_explicit(y, memory_order_relaxed); + atomic_store_explicit(x, 1, memory_order_relaxed); +} + +exists (0:r0=1 /\ 1:r1=1) diff --git a/litmus/OPENCL/portedFromC11/auto/c.litmus b/litmus/OPENCL/portedFromC11/auto/c.litmus new file mode 100644 index 0000000000..c2bb366fcc --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/c.litmus @@ -0,0 +1,26 @@ +OPENCL c +{ [x] = 0; [y] = 0; [p] = 0; [q] = 0; } + +P0@wg 0, dev 0 (atomic_int *x, atomic_int *y, volatile global int* p, volatile global int* q) { + int r0 = atomic_load_explicit(x, memory_order_relaxed); + if (r0) { + int t = *p; + *q = 1; + if (t) { + atomic_store_explicit(y, 1, memory_order_relaxed); + } + } +} + +P1@wg 0, dev 0 (atomic_int *x, atomic_int *y, volatile global int* p, volatile global int* q) { + int r1 = atomic_load_explicit(y, memory_order_relaxed); + if (r1) { + int r2 = *q; + if (r2) { + *p = 1; + atomic_store_explicit(x, 1, memory_order_relaxed); + } + } +} + +exists (p=1 /\ q=1) diff --git a/litmus/OPENCL/portedFromC11/auto/c_p.litmus b/litmus/OPENCL/portedFromC11/auto/c_p.litmus new file mode 100644 index 0000000000..c651755f0b --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/c_p.litmus @@ -0,0 +1,26 @@ +OPENCL c_p +{ [x] = 0; [y] = 0; [p] = 0; [q] = 0; [zero] = 0; [one] = 1; } + +P0@wg 0, dev 0 (atomic_int *x, atomic_int *y, volatile global int* p, volatile global int* q, global atomic_int* zero, global atomic_int* one) { + int r0 = atomic_load_explicit(x, memory_order_relaxed); + if (r0) { + int t = atomic_compare_exchange_strong_explicit(p, one, 2, memory_order_acquire, memory_order_relaxed); + *q = 1; + if (t) { + atomic_store_explicit(y, 1, memory_order_relaxed); + } + } +} + +P1@wg 0, dev 0 (atomic_int *x, atomic_int *y, volatile global int* p, volatile global int* q) { + int r1 = atomic_load_explicit(y, memory_order_relaxed); + if (r1) { + int r2 = *q; + if (r2) { + *p = 1; + atomic_store_explicit(x, 1, memory_order_relaxed); + } + } +} + +exists (p=1 /\ q=1) diff --git a/litmus/OPENCL/portedFromC11/auto/c_p_reorder.litmus b/litmus/OPENCL/portedFromC11/auto/c_p_reorder.litmus new file mode 100644 index 0000000000..22ac4a24c1 --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/c_p_reorder.litmus @@ -0,0 +1,26 @@ +OPENCL c_p_reorder +{ [x] = 0; [y] = 0; [p] = 0; [q] = 0; [zero] = 0; [one] = 1; } + +P0@wg 0, dev 0 (atomic_int *x, atomic_int *y, volatile global int* p, volatile global int* q, global atomic_int* zero, global atomic_int* one) { + int r0 = atomic_load_explicit(x, memory_order_relaxed); + if (r0) { + *q = 1; + int t = atomic_compare_exchange_strong_explicit(p, one, 2, memory_order_acquire, memory_order_relaxed); + if (t) { + atomic_store_explicit(y, 1, memory_order_relaxed); + } + } +} + +P1@wg 0, dev 0 (atomic_int *x, atomic_int *y, volatile global int* p, volatile global int* q) { + int r1 = atomic_load_explicit(y, memory_order_relaxed); + if (r1) { + int r2 = *q; + if (r2) { + *p = 1; + atomic_store_explicit(x, 1, memory_order_relaxed); + } + } +} + +exists (p=1 /\ q=1) diff --git a/litmus/OPENCL/portedFromC11/auto/c_pq.litmus b/litmus/OPENCL/portedFromC11/auto/c_pq.litmus new file mode 100644 index 0000000000..518f2d34be --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/c_pq.litmus @@ -0,0 +1,26 @@ +OPENCL c_pq +{ [x] = 0; [y] = 0; [p] = 0; [q] = 0; [zero] = 0; [one] = 1; } + +P0@wg 0, dev 0 (atomic_int *x, atomic_int *y, volatile global int* p, volatile global int* q, global atomic_int* zero, global atomic_int* one) { + int r0 = atomic_load_explicit(x, memory_order_relaxed); + if (r0) { + int t = atomic_compare_exchange_strong_explicit(p, one, 2, memory_order_acquire, memory_order_relaxed); + int u = atomic_compare_exchange_strong_explicit(q, zero, 1, memory_order_acquire, memory_order_relaxed); + if (t) { + atomic_store_explicit(y, 1, memory_order_relaxed); + } + } +} + +P1@wg 0, dev 0 (atomic_int *x, atomic_int *y, volatile global int* p, volatile global int* q) { + int r1 = atomic_load_explicit(y, memory_order_relaxed); + if (r1) { + int r2 = *q; + if (r2) { + *p = 1; + atomic_store_explicit(x, 1, memory_order_relaxed); + } + } +} + +exists (p=1 /\ q=1) diff --git a/litmus/OPENCL/portedFromC11/auto/c_pq_reorder.litmus b/litmus/OPENCL/portedFromC11/auto/c_pq_reorder.litmus new file mode 100644 index 0000000000..02cd4dde99 --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/c_pq_reorder.litmus @@ -0,0 +1,26 @@ +OPENCL c_pq_reorder +{ [x] = 0; [y] = 0; [p] = 0; [q] = 0; [zero] = 0; [one] = 1; } + +P0@wg 0, dev 0 (atomic_int *x, atomic_int *y, volatile global int* p, volatile global int* q, global atomic_int* zero, global atomic_int* one) { + int r0 = atomic_load_explicit(x, memory_order_relaxed); + if (r0) { + int u = atomic_compare_exchange_strong_explicit(q, zero, 1, memory_order_acquire, memory_order_relaxed); + int t = atomic_compare_exchange_strong_explicit(p, one, 2, memory_order_acquire, memory_order_relaxed); + if (t) { + atomic_store_explicit(y, 1, memory_order_relaxed); + } + } +} + +P1@wg 0, dev 0 (atomic_int *x, atomic_int *y, volatile global int* p, volatile global int* q) { + int r1 = atomic_load_explicit(y, memory_order_relaxed); + if (r1) { + int r2 = *q; + if (r2) { + *p = 1; + atomic_store_explicit(x, 1, memory_order_relaxed); + } + } +} + +exists (p=1 /\ q=1) diff --git a/litmus/OPENCL/portedFromC11/auto/c_q.litmus b/litmus/OPENCL/portedFromC11/auto/c_q.litmus new file mode 100644 index 0000000000..99d99caa7b --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/c_q.litmus @@ -0,0 +1,26 @@ +OPENCL c_q +{ [x] = 0; [y] = 0; [p] = 0; [q] = 0; [zero] = 0; [one] = 1; } + +P0@wg 0, dev 0 (atomic_int *x, atomic_int *y, volatile global int* p, volatile global int* q, global atomic_int* zero, global atomic_int* one) { + int r0 = atomic_load_explicit(x, memory_order_relaxed); + if (r0) { + int t = *p; + int u = atomic_compare_exchange_strong_explicit(q, zero, 1, memory_order_acquire, memory_order_relaxed); + if (t) { + atomic_store_explicit(y, 1, memory_order_relaxed); + } + } +} + +P1@wg 0, dev 0 (atomic_int *x, atomic_int *y, volatile global int* p, volatile global int* q) { + int r1 = atomic_load_explicit(y, memory_order_relaxed); + if (r1) { + int r2 = *q; + if (r2) { + *p = 1; + atomic_store_explicit(x, 1, memory_order_relaxed); + } + } +} + +exists (p=1 /\ q=1) diff --git a/litmus/OPENCL/portedFromC11/auto/c_q_reorder.litmus b/litmus/OPENCL/portedFromC11/auto/c_q_reorder.litmus new file mode 100644 index 0000000000..40b2bfc3fc --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/c_q_reorder.litmus @@ -0,0 +1,26 @@ +OPENCL c_q_reorder +{ [x] = 0; [y] = 0; [p] = 0; [q] = 0; [zero] = 0; [one] = 1; } + +P0@wg 0, dev 0 (atomic_int *x, atomic_int *y, volatile global int* p, volatile global int* q, global atomic_int* zero, global atomic_int* one) { + int r0 = atomic_load_explicit(x, memory_order_relaxed); + if (r0) { + int u = atomic_compare_exchange_strong_explicit(q, zero, 1, memory_order_acquire, memory_order_relaxed); + int t = *p; + if (t) { + atomic_store_explicit(y, 1, memory_order_relaxed); + } + } +} + +P1@wg 0, dev 0 (atomic_int *x, atomic_int *y, volatile global int* p, volatile global int* q) { + int r1 = atomic_load_explicit(y, memory_order_relaxed); + if (r1) { + int r2 = *q; + if (r2) { + *p = 1; + atomic_store_explicit(x, 1, memory_order_relaxed); + } + } +} + +exists (p=1 /\ q=1) diff --git a/litmus/OPENCL/portedFromC11/auto/c_reorder.litmus b/litmus/OPENCL/portedFromC11/auto/c_reorder.litmus new file mode 100644 index 0000000000..48ebe4cba1 --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/c_reorder.litmus @@ -0,0 +1,26 @@ +OPENCL c_reorder +{ [x] = 0; [y] = 0; [p] = 0; [q] = 0; } + +P0@wg 0, dev 0 (atomic_int *x, atomic_int *y, volatile global int* p, volatile global int* q) { + int r0 = atomic_load_explicit(x, memory_order_relaxed); + if (r0) { + *q = 1; + int t = *p; + if (t) { + atomic_store_explicit(y, 1, memory_order_relaxed); + } + } +} + +P1@wg 0, dev 0 (atomic_int *x, atomic_int *y, volatile global int* p, volatile global int* q) { + int r1 = atomic_load_explicit(y, memory_order_relaxed); + if (r1) { + int r2 = *q; + if (r2) { + *p = 1; + atomic_store_explicit(x, 1, memory_order_relaxed); + } + } +} + +exists (p=1 /\ q=1) diff --git a/litmus/OPENCL/portedFromC11/auto/cyc.litmus b/litmus/OPENCL/portedFromC11/auto/cyc.litmus new file mode 100644 index 0000000000..5991867ece --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/cyc.litmus @@ -0,0 +1,18 @@ +OPENCL cyc +{ [x] = 0; [y] = 0; } + +P0@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + int r0 = atomic_load_explicit(x, memory_order_relaxed); + if (r0) { + atomic_store_explicit(y, 1, memory_order_relaxed); + } +} + +P1@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + int r1 = atomic_load_explicit(y, memory_order_relaxed); + if (r1) { + atomic_store_explicit(x, 1, memory_order_relaxed); + } +} + +exists (0:r0=1 /\ 1:r1=1) diff --git a/litmus/OPENCL/portedFromC11/auto/cyc_na.litmus b/litmus/OPENCL/portedFromC11/auto/cyc_na.litmus new file mode 100644 index 0000000000..ff7eb17e74 --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/cyc_na.litmus @@ -0,0 +1,18 @@ +OPENCL cyc_na +{ [x] = 0; [y] = 0; } + +P0@wg 0, dev 0 (volatile global int* x, volatile global int* y) { + int r0 = *x; + if (r0) { + *y = 1; + } +} + +P1@wg 0, dev 0 (volatile global int* x, volatile global int* y) { + int r1 = *y; + if (r1) { + *x = 1; + } +} + +exists (0:r0=1 /\ 1:r1=1) diff --git a/litmus/OPENCL/portedFromC11/auto/fig1.litmus b/litmus/OPENCL/portedFromC11/auto/fig1.litmus new file mode 100644 index 0000000000..5b3d3549ff --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/fig1.litmus @@ -0,0 +1,16 @@ +OPENCL fig1 +{ [a] = 0; [x] = 0; [y] = 0; } + +P0@wg 0, dev 0 (volatile global int* a, global atomic_int* x, global atomic_int* y) { + *a = 1; + int r0 = atomic_load_explicit(x, memory_order_relaxed); + int r1 = *a; + atomic_store_explicit(y, 1, memory_order_relaxed); +} + +P1@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + int r2 = atomic_load_explicit(y, memory_order_relaxed); + atomic_store_explicit(x, 1, memory_order_relaxed); +} + +exists (a=1 /\ x=1 /\ y=1) diff --git a/litmus/OPENCL/portedFromC11/auto/lb.litmus b/litmus/OPENCL/portedFromC11/auto/lb.litmus new file mode 100644 index 0000000000..338277e8cd --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/lb.litmus @@ -0,0 +1,14 @@ +OPENCL lb +{ [x] = 0; [y] = 0; } + +P0@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + int r1 = atomic_load_explicit(x, memory_order_relaxed); + atomic_store_explicit(y, 1, memory_order_relaxed); +} + +P1@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + int r2 = atomic_load_explicit(y, memory_order_relaxed); + atomic_store_explicit(x, 1, memory_order_relaxed); +} + +exists (0:r1=1 /\ 1:r2=1) diff --git a/litmus/OPENCL/portedFromC11/auto/linearisation.litmus b/litmus/OPENCL/portedFromC11/auto/linearisation.litmus new file mode 100644 index 0000000000..bc14cef284 --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/linearisation.litmus @@ -0,0 +1,27 @@ +OPENCL linearisation +{ [x] = 0; [y] = 0; [w] = 0; [z] = 0; } + +P0@wg 0, dev 0 (global atomic_int* w, global atomic_int* x, volatile global int* y) { + int t = atomic_load_explicit(x, memory_order_acquire) + *y; + + if (t == 2) { + atomic_store_explicit(w, 1, memory_order_release); + } +} + +P1@wg 0, dev 0 (global atomic_int* w, global atomic_int* z) { + int r0 = atomic_load_explicit(w, memory_order_relaxed); + if (r0) { + atomic_store_explicit(z, 1, memory_order_relaxed); + } +} + +P2@wg 0, dev 0 (global atomic_int* x, volatile global int* y, global atomic_int* z) { + int r1 = atomic_load_explicit(z, memory_order_relaxed); + if (r1) { + *y = 1; + atomic_store_explicit(x, 1, memory_order_release); + } +} + +exists (0:t=2 /\ w=1 /\ x=1 /\ y=1 /\ z=1) diff --git a/litmus/OPENCL/portedFromC11/auto/linearisation2.litmus b/litmus/OPENCL/portedFromC11/auto/linearisation2.litmus new file mode 100644 index 0000000000..3a9bae1771 --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/linearisation2.litmus @@ -0,0 +1,27 @@ +OPENCL linearisation2 +{ [x] = 0; [y] = 0; [w] = 0; [z] = 0; } + +P0@wg 0, dev 0 (global atomic_int* w, global atomic_int* x, volatile global int* y) { + int t = atomic_load_explicit(x, memory_order_acquire); + t = t + *y; + if (t == 2) { + atomic_store_explicit(w, 1, memory_order_release); + } +} + +P1@wg 0, dev 0 (global atomic_int* w, global atomic_int* z) { + int r0 = atomic_load_explicit(w, memory_order_relaxed); + if (r0) { + atomic_store_explicit(z, 1, memory_order_relaxed); + } +} + +P2@wg 0, dev 0 (global atomic_int* x, volatile global int* y, global atomic_int* z) { + int r1 = atomic_load_explicit(z, memory_order_relaxed); + if (r1) { + *y = 1; + atomic_store_explicit(x, 1, memory_order_release); + } +} + +exists (0:t=2 /\ w=1 /\ x=1 /\ y=1 /\ z=1) diff --git a/litmus/OPENCL/portedFromC11/auto/roachmotel.litmus b/litmus/OPENCL/portedFromC11/auto/roachmotel.litmus new file mode 100644 index 0000000000..ac689003a6 --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/roachmotel.litmus @@ -0,0 +1,27 @@ +OPENCL roachmotel +{ [a] = 0; [x] = 0; [y] = 0; [z] = 0; } + +P0@wg 0, dev 0 (volatile global int* a, global atomic_int* z) { + atomic_store_explicit(z, 1, memory_order_release); + *a = 1; +} + +P1@wg 0, dev 0 (volatile global int* a, global atomic_int* x, global atomic_int* y, global atomic_int* z) { + int r0 = atomic_load_explicit(x, memory_order_relaxed); + if (r0) { + int r1 = atomic_load_explicit(z, memory_order_acquire); + int r2 = *a; + if (r2) { + atomic_store_explicit(y, 1, memory_order_relaxed); + } + } +} + +P2@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + int r3 = atomic_load_explicit(y, memory_order_relaxed); + if (r3) { + atomic_store_explicit(x, 1, memory_order_relaxed); + } +} + +exists (a=1 /\ z=1 /\ x=1 /\ y=1) diff --git a/litmus/OPENCL/portedFromC11/auto/roachmotel2.litmus b/litmus/OPENCL/portedFromC11/auto/roachmotel2.litmus new file mode 100644 index 0000000000..5e150f8770 --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/roachmotel2.litmus @@ -0,0 +1,27 @@ +OPENCL roachmotel2 +{ [a] = 0; [x] = 0; [y] = 0; [z] = 0; } + +P0@wg 0, dev 0 (volatile global int* a, global atomic_int* z) { + *a = 1; + atomic_store_explicit(z, 1, memory_order_release); +} + +P1@wg 0, dev 0 (volatile global int* a, global atomic_int* x, global atomic_int* y, global atomic_int* z) { + int r0 = atomic_load_explicit(x, memory_order_relaxed); + if (r0) { + int r1 = atomic_load_explicit(z, memory_order_acquire); + int r2 = *a; + if (r2) { + atomic_store_explicit(y, 1, memory_order_relaxed); + } + } +} + +P2@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + int r3 = atomic_load_explicit(y, memory_order_relaxed); + if (r3) { + atomic_store_explicit(x, 1, memory_order_relaxed); + } +} + +exists (a=1 /\ z=1 /\ x=1 /\ y=1) diff --git a/litmus/OPENCL/portedFromC11/auto/rseq_weak.litmus b/litmus/OPENCL/portedFromC11/auto/rseq_weak.litmus new file mode 100644 index 0000000000..c904f05cb7 --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/rseq_weak.litmus @@ -0,0 +1,21 @@ +OPENCL rseq_weak +{ [x] = 0; [y] = 0; } + +P0@wg 0, dev 0 (global atomic_int* x) { + atomic_store_explicit(x, 2, memory_order_relaxed); +} + +P1@wg 0, dev 0 (global atomic_int* x, volatile global int* y) { + *y = 1; + atomic_store_explicit(x, 1, memory_order_release); + atomic_store_explicit(x, 3, memory_order_relaxed); +} + +P2@wg 0, dev 0 (global atomic_int* x, volatile global int* y) { + int r0 = atomic_load_explicit(x, memory_order_acquire); + if (r0 == 3) { + int r1 = *y; + } +} + +exists (x=3 /\ y=1) diff --git a/litmus/OPENCL/portedFromC11/auto/rseq_weak2.litmus b/litmus/OPENCL/portedFromC11/auto/rseq_weak2.litmus new file mode 100644 index 0000000000..e7d05a90ee --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/rseq_weak2.litmus @@ -0,0 +1,17 @@ +OPENCL rseq_weak2 +{ [x] = 0; [y] = 0; } + +P0@wg 0, dev 0 (global atomic_int* x, volatile global int* y) { + *y = 1; + atomic_store_explicit(x, 1, memory_order_release); + atomic_store_explicit(x, 3, memory_order_relaxed); +} + +P1@wg 0, dev 0 (global atomic_int* x, volatile global int* y) { + int r0 = atomic_load_explicit(x, memory_order_acquire); + if (r0 == 3) { + int r1 = *y; + } +} + +exists (x=3 /\ y=1) diff --git a/litmus/OPENCL/portedFromC11/auto/seq.litmus b/litmus/OPENCL/portedFromC11/auto/seq.litmus new file mode 100644 index 0000000000..dbaddbd13f --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/seq.litmus @@ -0,0 +1,25 @@ +OPENCL seq +{ [a] = 0; [x] = 0; [y] = 0; } + +P0@wg 0, dev 0 (volatile global int* a) { + *a = 1; +} + +P1@wg 0, dev 0 (volatile global int* a, global atomic_int* x, global atomic_int* y) { + int r0 = atomic_load_explicit(x, memory_order_relaxed); + if (r0) { + int r1 = *a; + if (r1) { + atomic_store_explicit(y, 1, memory_order_relaxed); + } + } +} + +P2@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + int r2 = atomic_load_explicit(y, memory_order_relaxed); + if (r2) { + atomic_store_explicit(x, 1, memory_order_relaxed); + } +} + +exists (a=1 /\ x=1 /\ y=1) diff --git a/litmus/OPENCL/portedFromC11/auto/seq2.litmus b/litmus/OPENCL/portedFromC11/auto/seq2.litmus new file mode 100644 index 0000000000..f5f6cd72fe --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/seq2.litmus @@ -0,0 +1,22 @@ +OPENCL seq2 +{ [a] = 0; [x] = 0; [y] = 0; } + +P0@wg 0, dev 0 (volatile global int* a, global atomic_int* x, global atomic_int* y) { + *a = 1; + int r0 = atomic_load_explicit(x, memory_order_relaxed); + if (r0) { + int r1 = *a; + if (r1) { + atomic_store_explicit(y, 1, memory_order_relaxed); + } + } +} + +P1@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + int r2 = atomic_load_explicit(y, memory_order_relaxed); + if (r2) { + atomic_store_explicit(x, 1, memory_order_relaxed); + } +} + +exists (a=1 /\ x=1 /\ y=1) diff --git a/litmus/OPENCL/portedFromC11/auto/strengthen.litmus b/litmus/OPENCL/portedFromC11/auto/strengthen.litmus new file mode 100644 index 0000000000..aaf50370fa --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/strengthen.litmus @@ -0,0 +1,27 @@ +OPENCL strengthen +{ [a] = 0; [x] = 0; [y] = 0; [z] = 0; } + +P0@wg 0, dev 0 (volatile global int* a, global atomic_int* z) { + *a = 1; + atomic_store_explicit(z, 1, memory_order_relaxed); +} + +P1@wg 0, dev 0 (volatile global int* a, global atomic_int* x, global atomic_int* y, global atomic_int* z) { + int r0 = atomic_load_explicit(x, memory_order_relaxed); + if (r0) { + int r1 = atomic_load_explicit(z, memory_order_acquire); + int r2 = *a; + if (r2) { + atomic_store_explicit(y, 1, memory_order_relaxed); + } + } +} + +P2@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + int r3 = atomic_load_explicit(y, memory_order_relaxed); + if (r3) { + atomic_store_explicit(x, 1, memory_order_relaxed); + } +} + +exists (a=1 /\ z=1 /\ x=1 /\ y=1) diff --git a/litmus/OPENCL/portedFromC11/auto/strengthen2.litmus b/litmus/OPENCL/portedFromC11/auto/strengthen2.litmus new file mode 100644 index 0000000000..6410bc02df --- /dev/null +++ b/litmus/OPENCL/portedFromC11/auto/strengthen2.litmus @@ -0,0 +1,27 @@ +OPENCL strengthen2 +{ [a] = 0; [x] = 0; [y] = 0; [z] = 0; } + +P0@wg 0, dev 0 (volatile global int* a, global atomic_int* z) { + *a = 1; + atomic_store_explicit(z, 1, memory_order_release); +} + +P1@wg 0, dev 0 (volatile global int* a, global atomic_int* x, global atomic_int* y, global atomic_int* z) { + int r0 = atomic_load_explicit(x, memory_order_relaxed); + if (r0) { + int r1 = atomic_load_explicit(z, memory_order_acquire); + int r2 = *a; + if (r2) { + atomic_store_explicit(y, 1, memory_order_relaxed); + } + } +} + +P2@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + int r3 = atomic_load_explicit(y, memory_order_relaxed); + if (r3) { + atomic_store_explicit(x, 1, memory_order_relaxed); + } +} + +exists (a=1 /\ z=1 /\ x=1 /\ y=1) diff --git a/litmus/OPENCL/portedFromC11/manual/IRIW-sc-sc-acq-sc-acq-sc.litmus b/litmus/OPENCL/portedFromC11/manual/IRIW-sc-sc-acq-sc-acq-sc.litmus new file mode 100644 index 0000000000..7bd3d5a75a --- /dev/null +++ b/litmus/OPENCL/portedFromC11/manual/IRIW-sc-sc-acq-sc-acq-sc.litmus @@ -0,0 +1,27 @@ +OPENCL IRIW-sc-sc-acq-sc-acq-sc + +(* + * Taken from Counterexamples and Proof Loophole for the C/C++ to POWER and ARMv7 Trailing-Sync Compiler Mappings + *) + +{ [x] = 0; [y] = 0; } + +P0@wg 0, dev 0 (global atomic_int* x) { + atomic_store_explicit(x, 1, memory_order_seq_cst); +} + +P1@wg 0, dev 0 (global atomic_int* y) { + atomic_store_explicit(y, 1, memory_order_seq_cst); +} + +P2@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + int r1 = atomic_load_explicit(x, memory_order_acquire); + int r2 = atomic_load_explicit(y, memory_order_seq_cst); +} + +P3@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + int r3 = atomic_load_explicit(y, memory_order_acquire); + int r4 = atomic_load_explicit(x, memory_order_seq_cst); +} + +exists(2:r1=1 /\ 2:r2=0 /\ 3:r3=1 /\ 3:r4=0) diff --git a/litmus/OPENCL/portedFromC11/manual/RWC-sc-acq-sc-sc-sc.litmus b/litmus/OPENCL/portedFromC11/manual/RWC-sc-acq-sc-sc-sc.litmus new file mode 100644 index 0000000000..76bad7ca65 --- /dev/null +++ b/litmus/OPENCL/portedFromC11/manual/RWC-sc-acq-sc-sc-sc.litmus @@ -0,0 +1,23 @@ +OPENCL RWC-sc-acq-sc-sc-sc + +(* + * Taken from Counterexamples and Proof Loophole for the C/C++ to POWER and ARMv7 Trailing-Sync Compiler Mappings + *) + +{ [x] = 0; [y] = 0; } + +P0@wg 0, dev 0 (global atomic_int* x) { + atomic_store_explicit(x, 1, memory_order_seq_cst); +} + +P1@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + int r1 = atomic_load_explicit(x, memory_order_acquire); + int r2 = atomic_load_explicit(y, memory_order_seq_cst); +} + +P2@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + atomic_store_explicit(y, 1, memory_order_seq_cst); + int r3 = atomic_load_explicit(x, memory_order_seq_cst); +} + +exists(1:r1=1 /\ 1:r2=0 /\ 2:r3=0) diff --git a/litmus/OPENCL/portedFromC11/manual/TSan.litmus b/litmus/OPENCL/portedFromC11/manual/TSan.litmus new file mode 100644 index 0000000000..41bfa34e63 --- /dev/null +++ b/litmus/OPENCL/portedFromC11/manual/TSan.litmus @@ -0,0 +1,22 @@ +OPENCL TSan + +{} + +P0@wg 0, dev 0 (global atomic_int* x) { + int r0 = atomic_load_explicit(x, memory_order_relaxed); + int r1 = atomic_load_explicit(x, memory_order_relaxed); +} + +P1@wg 0, dev 0 (global atomic_int* x, global int* y) { + *y = atomic_load_explicit(x, memory_order_relaxed); + while(atomic_compare_exchange_strong_explicit(x, y, *y, memory_order_relaxed, memory_order_relaxed) == 0) {} + atomic_store_explicit(x, 1, memory_order_relaxed); +} + +P2@wg 0, dev 0 (global atomic_int* x, global int* a) { + *a = atomic_load_explicit(x, memory_order_relaxed); + while(atomic_compare_exchange_strong_explicit(x, a, *a, memory_order_relaxed, memory_order_relaxed) == 0) {} + atomic_store_explicit(x, 2, memory_order_relaxed); +} + +exists (0:r0=2 /\ 0:r1=0) diff --git a/litmus/OPENCL/portedFromC11/manual/cppmem_iriw_relacq.litmus b/litmus/OPENCL/portedFromC11/manual/cppmem_iriw_relacq.litmus new file mode 100644 index 0000000000..5069ec4d26 --- /dev/null +++ b/litmus/OPENCL/portedFromC11/manual/cppmem_iriw_relacq.litmus @@ -0,0 +1,35 @@ +OPENCL cppmem_iriw_relacq + +(* + * Taken from Overhauling SOPENCL Atomics in C11 and OpenCL + *) + +{ +[x] = 0; +[y] = 0; +} + +// This litmus test is ported from an example distributed +// with the CppMem tool. Original is available online at: +// http://svr-pes20-cppmem.cl.cam.ac.uk/cppmem/index.html + +P0@wg 0, dev 0 (global atomic_int* x) { + atomic_store_explicit(x, 1, memory_order_release); +} + +P1@wg 0, dev 0 (global atomic_int* y) { + atomic_store_explicit(y, 1, memory_order_release); +} + +P2@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + int r1 = atomic_load_explicit(x, memory_order_acquire); + int r2 = atomic_load_explicit(y, memory_order_acquire); +} + +P3@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + int r3 = atomic_load_explicit(y, memory_order_acquire); + int r4 = atomic_load_explicit(x, memory_order_acquire); +} + +exists +(2:r1 = 1 /\ 2:r2 = 0 /\ 3:r3 = 1 /\ 3:r4 = 0) diff --git a/litmus/OPENCL/portedFromC11/manual/example1.litmus b/litmus/OPENCL/portedFromC11/manual/example1.litmus new file mode 100644 index 0000000000..56aa099de9 --- /dev/null +++ b/litmus/OPENCL/portedFromC11/manual/example1.litmus @@ -0,0 +1,28 @@ +OPENCL example1 + +(* + * Taken from Overhauling SOPENCL Atomics in C11 and OpenCL + *) + +{ [x] = 0; [y] = 0; } + +P0@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + atomic_store_explicit(x, 1, memory_order_relaxed); +} + +P1@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + int r1 = atomic_load_explicit(x, memory_order_relaxed); + int r2 = atomic_load_explicit(x, memory_order_relaxed); +} + +P2@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + atomic_store_explicit(x, 2, memory_order_seq_cst); + int r3 = atomic_load_explicit(y, memory_order_seq_cst); +} + +P3@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + atomic_store_explicit(y, 1, memory_order_seq_cst); + int r4 = atomic_load_explicit(x, memory_order_seq_cst); +} + +exists (1:r1 = 1 /\ 1:r2 = 2 /\ 2:r3=0 /\ 3:r4=1) diff --git a/litmus/OPENCL/portedFromC11/manual/imm-E3.1.litmus b/litmus/OPENCL/portedFromC11/manual/imm-E3.1.litmus new file mode 100644 index 0000000000..cfe20d4f70 --- /dev/null +++ b/litmus/OPENCL/portedFromC11/manual/imm-E3.1.litmus @@ -0,0 +1,19 @@ +OPENCL imm-E3.1 + +(* + * Bridging the Gap between Programming Languages and Hardware Weak Memory Models + *) + +{} + +P0@wg 0, dev 0 (global atomic_int* y, global atomic_int* x) { + atomic_store_explicit(x, 1, memory_order_relaxed); + atomic_store_explicit(y, 1, memory_order_release); +} + +P1@wg 0, dev 0 (global atomic_int* y, global atomic_int* x) { + int r0 = atomic_load_explicit(y, memory_order_acquire); + int r1 = atomic_load_explicit(x, memory_order_relaxed); +} + +exists (1:r0=1 /\ 1:r1=0) diff --git a/litmus/OPENCL/portedFromC11/manual/imm-E3.10.litmus b/litmus/OPENCL/portedFromC11/manual/imm-E3.10.litmus new file mode 100644 index 0000000000..7d9ae28651 --- /dev/null +++ b/litmus/OPENCL/portedFromC11/manual/imm-E3.10.litmus @@ -0,0 +1,20 @@ +OPENCL imm-E3.10 + +(* + * Bridging the Gap between Programming Languages and Hardware Weak Memory Models + *) + +{} + +P0@wg 0, dev 0 (global atomic_int* y, global atomic_int* z) { + int r0 = atomic_load_explicit(y, memory_order_relaxed); + atomic_store_explicit(z, r0, memory_order_relaxed); +} + +P1@wg 0, dev 0 (global atomic_int* x, global atomic_int* y, global atomic_int* z) { + int r0 = atomic_load_explicit(z, memory_order_relaxed); + int r1 = atomic_fetch_add_explicit(x, 1, memory_order_release); + atomic_store_explicit(y, r1+1, memory_order_relaxed); +} + +exists (0:r0=1 /\ 1:r0=1 /\ 1:r1=1) diff --git a/litmus/OPENCL/portedFromC11/manual/imm-E3.2.litmus b/litmus/OPENCL/portedFromC11/manual/imm-E3.2.litmus new file mode 100644 index 0000000000..8196048648 --- /dev/null +++ b/litmus/OPENCL/portedFromC11/manual/imm-E3.2.litmus @@ -0,0 +1,18 @@ +OPENCL imm-E3.2 + +(* + * Bridging the Gap between Programming Languages and Hardware Weak Memory Models + *) + +{} + +P0@wg 0, dev 0 (global atomic_int* x) { + int r0 = atomic_fetch_add_explicit(x, 1, memory_order_relaxed); +} + +P1@wg 0, dev 0 (global atomic_int* x) { + atomic_store_explicit(x, 2, memory_order_relaxed); + int r0 = atomic_load_explicit(x, memory_order_relaxed); +} + +exists (0:r0=0 /\ 1:r0=1) diff --git a/litmus/OPENCL/portedFromC11/manual/imm-E3.3.litmus b/litmus/OPENCL/portedFromC11/manual/imm-E3.3.litmus new file mode 100644 index 0000000000..2eeb1218a2 --- /dev/null +++ b/litmus/OPENCL/portedFromC11/manual/imm-E3.3.litmus @@ -0,0 +1,19 @@ +OPENCL imm-E3.3 + +(* + * Bridging the Gap between Programming Languages and Hardware Weak Memory Models + *) + +{} + +P0@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + int r0 = atomic_load_explicit(x, memory_order_relaxed); + atomic_store_explicit(y, 1, memory_order_release); +} + +P1@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + int r0 = atomic_load_explicit(y, memory_order_relaxed); + atomic_store_explicit(x, 1, memory_order_release); +} + +exists (0:r0=1 /\ 1:r0=1) diff --git a/litmus/OPENCL/portedFromC11/manual/imm-E3.4.litmus b/litmus/OPENCL/portedFromC11/manual/imm-E3.4.litmus new file mode 100644 index 0000000000..dee68c79b9 --- /dev/null +++ b/litmus/OPENCL/portedFromC11/manual/imm-E3.4.litmus @@ -0,0 +1,19 @@ +OPENCL imm-E3.4 + +(* + * Bridging the Gap between Programming Languages and Hardware Weak Memory Models + *) + +{} + +P0@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + int r0 = atomic_load_explicit(x, memory_order_acquire); + atomic_store_explicit(y, 1, memory_order_release); +} + +P1@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + int r0 = atomic_load_explicit(y, memory_order_acquire); + atomic_store_explicit(x, 1, memory_order_release); +} + +exists (0:r0=1 /\ 1:r0=1) diff --git a/litmus/OPENCL/portedFromC11/manual/imm-E3.5.litmus b/litmus/OPENCL/portedFromC11/manual/imm-E3.5.litmus new file mode 100644 index 0000000000..06750d3623 --- /dev/null +++ b/litmus/OPENCL/portedFromC11/manual/imm-E3.5.litmus @@ -0,0 +1,22 @@ +OPENCL imm-E3.5 + +(* + * Bridging the Gap between Programming Languages and Hardware Weak Memory Models + *) + +{ + atomic_int y[2] = {0, 0}; +} + +P0@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + int r0 = atomic_load_explicit(x, memory_order_relaxed); + int r1 = atomic_load_explicit(y+r0, memory_order_relaxed); + atomic_store_explicit(y, 1, memory_order_relaxed); +} + +P1@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + int r0 = atomic_load_explicit(y, memory_order_relaxed); + atomic_store_explicit(x, 1, memory_order_release); +} + +exists (0:r0=1 /\ 1:r0=1) diff --git a/litmus/OPENCL/portedFromC11/manual/imm-E3.6.litmus b/litmus/OPENCL/portedFromC11/manual/imm-E3.6.litmus new file mode 100644 index 0000000000..35e35bc885 --- /dev/null +++ b/litmus/OPENCL/portedFromC11/manual/imm-E3.6.litmus @@ -0,0 +1,21 @@ +OPENCL imm-E3.6 + +(* + * Bridging the Gap between Programming Languages and Hardware Weak Memory Models + *) + +{} + +P0@wg 0, dev 0 (global atomic_int* x, global atomic_int* y, global atomic_int* z) { + int r0 = atomic_load_explicit(x, memory_order_relaxed); + atomic_store_explicit(y, 1, memory_order_release); + int r1 = atomic_load_explicit(y, memory_order_relaxed); + atomic_store_explicit(z, r1, memory_order_relaxed); +} + +P1@wg 0, dev 0 (global atomic_int* x, global atomic_int* z) { + int r0 = atomic_load_explicit(z, memory_order_relaxed); + atomic_store_explicit(x, r0, memory_order_relaxed); +} + +exists (0:r0=1 /\ 0:r1=1 /\ 1:r0=1) diff --git a/litmus/OPENCL/portedFromC11/manual/imm-E3.7.litmus b/litmus/OPENCL/portedFromC11/manual/imm-E3.7.litmus new file mode 100644 index 0000000000..1605968686 --- /dev/null +++ b/litmus/OPENCL/portedFromC11/manual/imm-E3.7.litmus @@ -0,0 +1,21 @@ +OPENCL imm-E3.7 + +(* + * Bridging the Gap between Programming Languages and Hardware Weak Memory Models + *) + +{} + +P0@wg 0, dev 0 (global atomic_int* x, global atomic_int* y, global atomic_int* z) { + int r0 = atomic_load_explicit(z, memory_order_relaxed); + atomic_store_explicit(x, r0 - 1, memory_order_relaxed); + int r1 = atomic_load_explicit(x, memory_order_relaxed); + atomic_store_explicit(y, r1, memory_order_relaxed); +} + +P1@wg 0, dev 0 (global atomic_int* y, global atomic_int* z) { + int r0 = atomic_load_explicit(y, memory_order_relaxed); + atomic_store_explicit(z, r0, memory_order_relaxed); +} + +exists (0:r0=1 /\ 0:r1=1 /\ 1:r0=1) diff --git a/litmus/OPENCL/portedFromC11/manual/imm-E3.8-alt.litmus b/litmus/OPENCL/portedFromC11/manual/imm-E3.8-alt.litmus new file mode 100644 index 0000000000..50fe59aabe --- /dev/null +++ b/litmus/OPENCL/portedFromC11/manual/imm-E3.8-alt.litmus @@ -0,0 +1,27 @@ +OPENCL imm-E3.8 + +(* + * Bridging the Gap between Programming Languages and Hardware Weak Memory Models + *) + +{} + +P0@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + int r0 = atomic_load_explicit(x, memory_order_acquire); + int r1 = atomic_load_explicit(y, memory_order_acquire); +} + +P1@wg 0, dev 0 (global atomic_int* x) { + atomic_store_explicit(x, 1, memory_order_release); +} + +P2@wg 0, dev 0 (global atomic_int* y) { + atomic_store_explicit(y, 1, memory_order_release); +} + +P3@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + int r0 = atomic_load_explicit(y, memory_order_acquire); + int r1 = atomic_load_explicit(x, memory_order_acquire); +} + +exists (0:r0=1 /\ 0:r1=0 /\ 3:r0=1 /\ 3:r1=0) diff --git a/litmus/OPENCL/portedFromC11/manual/imm-E3.8.litmus b/litmus/OPENCL/portedFromC11/manual/imm-E3.8.litmus new file mode 100644 index 0000000000..435efbaf22 --- /dev/null +++ b/litmus/OPENCL/portedFromC11/manual/imm-E3.8.litmus @@ -0,0 +1,29 @@ +OPENCL imm-E3.8 + +(* + * Bridging the Gap between Programming Languages and Hardware Weak Memory Models + *) + +{} + +P0@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + int r0 = atomic_load_explicit(x, memory_order_acquire); + atomic_work_item_fence(CLK_GLOBAL_MEM_FENCE,memory_order_seq_cst,memory_scope_all_svm_devices); + int r1 = atomic_load_explicit(y, memory_order_acquire); +} + +P1@wg 0, dev 0 (global atomic_int* x) { + atomic_store_explicit(x, 1, memory_order_release); +} + +P2@wg 0, dev 0 (global atomic_int* y) { + atomic_store_explicit(y, 1, memory_order_release); +} + +P3@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + int r0 = atomic_load_explicit(y, memory_order_acquire); + atomic_work_item_fence(CLK_GLOBAL_MEM_FENCE,memory_order_seq_cst,memory_scope_all_svm_devices); + int r1 = atomic_load_explicit(x, memory_order_acquire); +} + +exists (0:r0=1 /\ 0:r1=0 /\ 3:r0=1 /\ 3:r1=0) diff --git a/litmus/OPENCL/portedFromC11/manual/imm-E3.9.litmus b/litmus/OPENCL/portedFromC11/manual/imm-E3.9.litmus new file mode 100644 index 0000000000..c3580d66fd --- /dev/null +++ b/litmus/OPENCL/portedFromC11/manual/imm-E3.9.litmus @@ -0,0 +1,28 @@ +OPENCL imm-E3.9 + +(* + * Bridging the Gap between Programming Languages and Hardware Weak Memory Models + *) + +{} + +P0@wg 0, dev 0 (global atomic_int* y, global atomic_int* z) { + int r0 = atomic_load_explicit(y, memory_order_relaxed); + atomic_work_item_fence(CLK_GLOBAL_MEM_FENCE,memory_order_seq_cst,memory_scope_all_svm_devices); + int r1 = atomic_load_explicit(z, memory_order_relaxed); +} + +P1@wg 0, dev 0 (global atomic_int* x, global atomic_int* z) { + atomic_store_explicit(z, 1, memory_order_relaxed); + atomic_work_item_fence(CLK_GLOBAL_MEM_FENCE,memory_order_seq_cst,memory_scope_all_svm_devices); + atomic_store_explicit(x, 1, memory_order_relaxed); +} + +P2@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + int r0 = atomic_load_explicit(x, memory_order_relaxed); + if (r0 != 0) { + atomic_store_explicit(y, 1, memory_order_relaxed); + } +} + +exists (0:r0=1 /\ 0:r1=0 /\ 2:r0=10) diff --git a/litmus/OPENCL/portedFromC11/manual/imm-R2-alt.litmus b/litmus/OPENCL/portedFromC11/manual/imm-R2-alt.litmus new file mode 100644 index 0000000000..6917fd5f9f --- /dev/null +++ b/litmus/OPENCL/portedFromC11/manual/imm-R2-alt.litmus @@ -0,0 +1,25 @@ +OPENCL imm-R2 + +(* + * Bridging the Gap between Programming Languages and Hardware Weak Memory Models + *) + +{} + +P0@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + atomic_store_explicit(y, 1, memory_order_relaxed); + atomic_store_explicit(x, 1, memory_order_release); +} + +P1@wg 0, dev 0 (global atomic_int* x) { + atomic_work_item_fence(CLK_GLOBAL_MEM_FENCE,memory_order_release,memory_scope_all_svm_devices); + int r0 = atomic_fetch_add_explicit(x, 1, memory_order_acquire); + atomic_store_explicit(x, 3, memory_order_relaxed); +} + +P2@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + int r0 = atomic_load_explicit(x, memory_order_acquire); + int r1 = atomic_load_explicit(y, memory_order_relaxed); +} + +exists (1:r0=1 /\ 2:r0=3 /\ 2:r1=0) diff --git a/litmus/OPENCL/portedFromC11/manual/imm-R2.litmus b/litmus/OPENCL/portedFromC11/manual/imm-R2.litmus new file mode 100644 index 0000000000..1d479d1980 --- /dev/null +++ b/litmus/OPENCL/portedFromC11/manual/imm-R2.litmus @@ -0,0 +1,24 @@ +OPENCL imm-R2 + +(* + * Bridging the Gap between Programming Languages and Hardware Weak Memory Models + *) + +{} + +P0@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + atomic_store_explicit(y, 1, memory_order_relaxed); + atomic_store_explicit(x, 1, memory_order_release); +} + +P1@wg 0, dev 0 (global atomic_int* x) { + int r0 = atomic_fetch_add_explicit(x, 1, memory_order_acq_rel); + atomic_store_explicit(x, 3, memory_order_relaxed); +} + +P2@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + int r0 = atomic_load_explicit(x, memory_order_acquire); + int r1 = atomic_load_explicit(y, memory_order_relaxed); +} + +exists (1:r0=1 /\ 2:r0=3 /\ 2:r1=0) diff --git a/litmus/OPENCL/portedFromC11/manual/iriw_sc.litmus b/litmus/OPENCL/portedFromC11/manual/iriw_sc.litmus new file mode 100644 index 0000000000..0d27544a94 --- /dev/null +++ b/litmus/OPENCL/portedFromC11/manual/iriw_sc.litmus @@ -0,0 +1,34 @@ +OPENCL iriw_sc + +(* + * Taken from Overhauling SOPENCL Atomics in C11 and OpenCL + *) + +{ +[x] = 0; +[y] = 0; +} + +// IRIW with SOPENCL atomics + + +P0@wg 0, dev 0 (global atomic_int* x) { + atomic_store_explicit(x, 1, memory_order_seq_cst); +} + +P1@wg 0, dev 0 (global atomic_int* y) { + atomic_store_explicit(y, 1, memory_order_seq_cst); +} + +P2@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + int r1 = atomic_load_explicit(x, memory_order_seq_cst); + int r2 = atomic_load_explicit(y, memory_order_seq_cst); +} + +P3@wg 0, dev 0 (global atomic_int* x, global atomic_int* y) { + int r3 = atomic_load_explicit(y, memory_order_seq_cst); + int r4 = atomic_load_explicit(x, memory_order_seq_cst); +} + +exists +(2:r1 = 1 /\ 2:r2 = 0 /\ 3:r3 = 1 /\ 3:r4 = 0) diff --git a/litmus/OPENCL/portedFromC11/manual/mp_fences.litmus b/litmus/OPENCL/portedFromC11/manual/mp_fences.litmus new file mode 100644 index 0000000000..8413ba241b --- /dev/null +++ b/litmus/OPENCL/portedFromC11/manual/mp_fences.litmus @@ -0,0 +1,27 @@ +OPENCL mp_fences + +(* + * Taken from Overhauling SOPENCL Atomics in C11 and OpenCL + *) + +{ +[x] = 0; +[y] = 0; +} + +P0@wg 0, dev 0 (global atomic_int* y, global int* x) { + *x = 1; + atomic_work_item_fence(CLK_GLOBAL_MEM_FENCE,memory_order_release,memory_scope_all_svm_devices); + atomic_store_explicit(y,1,memory_order_relaxed); +} + +P1@wg 0, dev 0 (global atomic_int* y, global int* x) { + int r0 = atomic_load_explicit(y,memory_order_relaxed); + atomic_work_item_fence(CLK_GLOBAL_MEM_FENCE,memory_order_acquire,memory_scope_all_svm_devices); + int r1 = -1; + if (1 == r0) { + r1 = *x; + } +} + +exists (1:r0=1 /\ 1:r1=0) diff --git a/litmus/OPENCL/portedFromC11/manual/mp_relacq.litmus b/litmus/OPENCL/portedFromC11/manual/mp_relacq.litmus new file mode 100644 index 0000000000..d81eed2583 --- /dev/null +++ b/litmus/OPENCL/portedFromC11/manual/mp_relacq.litmus @@ -0,0 +1,25 @@ +OPENCL mp_relacq + +(* + * Taken from Overhauling SOPENCL Atomics in C11 and OpenCL + *) + +{ +[x] = 0; +[y] = 0; +} + +P0@wg 0, dev 0 (global atomic_int* y, global int* x) { + *x = 1; + atomic_store_explicit(y,1,memory_order_release); +} + +P1@wg 0, dev 0 (global atomic_int* y, global int* x) { + int r0 = atomic_load_explicit(y,memory_order_acquire); + int r1 = -1; + if (1 == r0) { + r1 = *x; + } +} + +exists (1:r0=1 /\ 1:r1=0) diff --git a/litmus/OPENCL/portedFromC11/manual/mp_relaxed.litmus b/litmus/OPENCL/portedFromC11/manual/mp_relaxed.litmus new file mode 100644 index 0000000000..bf70c6f5ab --- /dev/null +++ b/litmus/OPENCL/portedFromC11/manual/mp_relaxed.litmus @@ -0,0 +1,25 @@ +OPENCL mp_relaxed + +(* + * Taken from Overhauling SOPENCL Atomics in C11 and OpenCL + *) + +{ +[x] = 0; +[y] = 0; +} + +P0@wg 0, dev 0 (global atomic_int* y, global int* x) { + *x = 1; + atomic_store_explicit(y,1,memory_order_relaxed); +} + +P1@wg 0, dev 0 (global atomic_int* y, global int* x) { + int r0 = atomic_load_explicit(y,memory_order_relaxed); + int r1 = -1; + if (1 == r0) { + r1 = *x; + } +} + +exists (1:r0=1 /\ 1:r1=0)