From f5ddde7d8fc2de16dc144d82d51be2f8587aab2d Mon Sep 17 00:00:00 2001 From: haining Date: Thu, 12 Sep 2024 18:51:20 +0300 Subject: [PATCH 01/23] add OpenCl mm --- cat/opencl.cat | 149 ++++++++++++++ dartagnan/src/main/antlr4/C11Lexer.g4 | 27 ++- dartagnan/src/main/antlr4/LitmusC.g4 | 153 +++++++++----- dartagnan/src/main/antlr4/OpenCLLexer.g4 | 18 ++ .../java/com/dat3m/dartagnan/Dartagnan.java | 2 +- .../dat3m/dartagnan/configuration/Arch.java | 6 +- .../dartagnan/encoding/ProgramEncoder.java | 4 +- .../parsers/program/ProgramParser.java | 9 +- .../parsers/program/utils/Compilation.java | 28 ++- .../parsers/program/utils/ProgramBuilder.java | 22 ++- .../program/visitors/VisitorLitmusC.java | 187 ++++++++++++++++-- .../program/visitors/VisitorLitmusVulkan.java | 6 +- .../dartagnan/program/ScopeHierarchy.java | 22 ++- .../com/dat3m/dartagnan/program/Thread.java | 7 +- .../dartagnan/program/event/EventFactory.java | 15 ++ .../dartagnan/program/event/EventVisitor.java | 2 +- .../dat3m/dartagnan/program/event/Tag.java | 56 ++++-- .../program/event/arch/opencl/OpenCLInit.java | 19 ++ .../program/memory/MemoryObject.java | 8 + .../processing/CoreCodeVerification.java | 4 +- .../program/processing/MemoryAllocation.java | 7 +- .../processing/compilation/Compilation.java | 1 + .../processing/compilation/VisitorOpenCL.java | 120 +++++++++++ .../processing/compilation/VisitorPTX.java | 2 +- .../compilation/VisitorSpirvVulkan.java | 12 +- .../processing/compilation/VisitorVulkan.java | 4 +- .../dartagnan/wmm/RelationNameRepository.java | 1 + .../java/com/dat3m/dartagnan/wmm/Wmm.java | 9 +- .../com/dat3m/dartagnan/wmm/axiom/Axiom.java | 12 ++ .../comparison/AbstractComparisonTest.java | 133 +++++++++++++ .../comparison/C11AndOpenCLTest.java | 43 ++++ .../litmus/LitmusOpenClRacesTest.java | 42 ++++ .../dartagnan/litmus/LitmusOpenClTest.java | 36 ++++ .../compilation/VisitorSpirvVulkanTest.java | 140 ++++++------- .../dartagnan/spirv/header/ConfigTest.java | 2 +- .../src/test/resources/OPENCL-DR-expected.csv | 41 ++++ .../src/test/resources/OPENCL-expected.csv | 41 ++++ litmus/OPENCL/herd/2+2W.litmus | 22 +++ litmus/OPENCL/herd/3.2W.litmus | 30 +++ litmus/OPENCL/herd/3LB.litmus | 28 +++ litmus/OPENCL/herd/CT_wsq1.litmus | 31 +++ litmus/OPENCL/herd/CT_wsq2.litmus | 41 ++++ litmus/OPENCL/herd/IRIW.litmus | 30 +++ litmus/OPENCL/herd/ISA2.litmus | 29 +++ litmus/OPENCL/herd/ISA3.litmus | 28 +++ litmus/OPENCL/herd/LB.litmus | 23 +++ litmus/OPENCL/herd/MP.litmus | 23 +++ litmus/OPENCL/herd/R.litmus | 22 +++ litmus/OPENCL/herd/README.md | 1 + litmus/OPENCL/herd/RWC.litmus | 29 +++ litmus/OPENCL/herd/S.litmus | 24 +++ litmus/OPENCL/herd/SB.litmus | 23 +++ litmus/OPENCL/herd/SB1.litmus | 24 +++ litmus/OPENCL/herd/WRC.litmus | 29 +++ litmus/OPENCL/herd/barrier_example.litmus | 24 +++ litmus/OPENCL/herd/global_barrier.litmus | 120 +++++++++++ litmus/OPENCL/herd/global_barrier_mo.litmus | 116 +++++++++++ litmus/OPENCL/herd/old/MP_dr.litmus | 22 +++ litmus/OPENCL/herd/old/MP_relacq.litmus | 23 +++ litmus/OPENCL/herd/old/MP_relaxed.litmus | 23 +++ litmus/OPENCL/herd/old/MP_relseq.litmus | 24 +++ litmus/OPENCL/herd/thinair.litmus | 22 +++ litmus/OPENCL/overhauling/IRIW_sc_dev.litmus | 30 +++ litmus/OPENCL/overhauling/IRIW_sc_wg.litmus | 30 +++ litmus/OPENCL/overhauling/ISA2.litmus | 33 ++++ litmus/OPENCL/overhauling/ISA2_broken.litmus | 33 ++++ litmus/OPENCL/overhauling/MP_ra_dev.litmus | 25 +++ .../overhauling/MP_ra_dev_broken.litmus | 25 +++ litmus/OPENCL/overhauling/MP_ra_wg.litmus | 25 +++ litmus/OPENCL/overhauling/MP_sc_dev.litmus | 25 +++ litmus/OPENCL/overhauling/example10.litmus | 38 ++++ litmus/OPENCL/overhauling/example4.litmus | 24 +++ litmus/OPENCL/overhauling/example5.litmus | 24 +++ litmus/OPENCL/overhauling/example6.litmus | 26 +++ litmus/OPENCL/overhauling/example7a.litmus | 24 +++ litmus/OPENCL/overhauling/example7b.litmus | 24 +++ litmus/OPENCL/overhauling/example8.litmus | 24 +++ litmus/OPENCL/overhauling/example9a.litmus | 22 +++ litmus/OPENCL/overhauling/example9b.litmus | 22 +++ 79 files changed, 2460 insertions(+), 195 deletions(-) create mode 100644 cat/opencl.cat create mode 100644 dartagnan/src/main/antlr4/OpenCLLexer.g4 create mode 100644 dartagnan/src/main/java/com/dat3m/dartagnan/program/event/arch/opencl/OpenCLInit.java create mode 100644 dartagnan/src/main/java/com/dat3m/dartagnan/program/processing/compilation/VisitorOpenCL.java create mode 100644 dartagnan/src/test/java/com/dat3m/dartagnan/comparison/AbstractComparisonTest.java create mode 100644 dartagnan/src/test/java/com/dat3m/dartagnan/comparison/C11AndOpenCLTest.java create mode 100644 dartagnan/src/test/java/com/dat3m/dartagnan/litmus/LitmusOpenClRacesTest.java create mode 100644 dartagnan/src/test/java/com/dat3m/dartagnan/litmus/LitmusOpenClTest.java create mode 100644 dartagnan/src/test/resources/OPENCL-DR-expected.csv create mode 100644 dartagnan/src/test/resources/OPENCL-expected.csv create mode 100644 litmus/OPENCL/herd/2+2W.litmus create mode 100644 litmus/OPENCL/herd/3.2W.litmus create mode 100644 litmus/OPENCL/herd/3LB.litmus create mode 100644 litmus/OPENCL/herd/CT_wsq1.litmus create mode 100644 litmus/OPENCL/herd/CT_wsq2.litmus create mode 100644 litmus/OPENCL/herd/IRIW.litmus create mode 100644 litmus/OPENCL/herd/ISA2.litmus create mode 100644 litmus/OPENCL/herd/ISA3.litmus create mode 100644 litmus/OPENCL/herd/LB.litmus create mode 100644 litmus/OPENCL/herd/MP.litmus create mode 100644 litmus/OPENCL/herd/R.litmus create mode 100644 litmus/OPENCL/herd/README.md create mode 100644 litmus/OPENCL/herd/RWC.litmus create mode 100644 litmus/OPENCL/herd/S.litmus create mode 100644 litmus/OPENCL/herd/SB.litmus create mode 100644 litmus/OPENCL/herd/SB1.litmus create mode 100644 litmus/OPENCL/herd/WRC.litmus create mode 100644 litmus/OPENCL/herd/barrier_example.litmus create mode 100644 litmus/OPENCL/herd/global_barrier.litmus create mode 100644 litmus/OPENCL/herd/global_barrier_mo.litmus create mode 100644 litmus/OPENCL/herd/old/MP_dr.litmus create mode 100644 litmus/OPENCL/herd/old/MP_relacq.litmus create mode 100644 litmus/OPENCL/herd/old/MP_relaxed.litmus create mode 100644 litmus/OPENCL/herd/old/MP_relseq.litmus create mode 100644 litmus/OPENCL/herd/thinair.litmus create mode 100644 litmus/OPENCL/overhauling/IRIW_sc_dev.litmus create mode 100644 litmus/OPENCL/overhauling/IRIW_sc_wg.litmus create mode 100644 litmus/OPENCL/overhauling/ISA2.litmus create mode 100644 litmus/OPENCL/overhauling/ISA2_broken.litmus create mode 100644 litmus/OPENCL/overhauling/MP_ra_dev.litmus create mode 100644 litmus/OPENCL/overhauling/MP_ra_dev_broken.litmus create mode 100644 litmus/OPENCL/overhauling/MP_ra_wg.litmus create mode 100644 litmus/OPENCL/overhauling/MP_sc_dev.litmus create mode 100644 litmus/OPENCL/overhauling/example10.litmus create mode 100644 litmus/OPENCL/overhauling/example4.litmus create mode 100644 litmus/OPENCL/overhauling/example5.litmus create mode 100644 litmus/OPENCL/overhauling/example6.litmus create mode 100644 litmus/OPENCL/overhauling/example7a.litmus create mode 100644 litmus/OPENCL/overhauling/example7b.litmus create mode 100644 litmus/OPENCL/overhauling/example8.litmus create mode 100644 litmus/OPENCL/overhauling/example9a.litmus create mode 100644 litmus/OPENCL/overhauling/example9b.litmus diff --git a/cat/opencl.cat b/cat/opencl.cat new file mode 100644 index 0000000000..3f7ac541e4 --- /dev/null +++ b/cat/opencl.cat @@ -0,0 +1,149 @@ +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 + +(* Inclusive scopes *) +let incl = (int & (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) | int +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_g = incl & ~int & ([GLOBAL]; relf; max_co; [GLOBAL]; rf; acqf; [GLOBAL]) +let ra_sw_l = incl & ~int & ([LOCAL]; relf; max_co; [LOCAL]; rf; acqf; [LOCAL]) + +(* 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_g = (EF * XF) & syncbar & ~int & swg & (GLOBAL * GLOBAL) +let bar_sw_l = (EF * XF) & syncbar & ~int & swg & (LOCAL * LOCAL) + +(* Synchronisation on a region *) +let region_sw_g = ra_sw_g | bar_sw_g +let region_sw_l = ra_sw_l | bar_sw_l + +(* 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_g | (scf & region_sw_l) +let lsw = region_sw_l | (scf & region_sw_g) + +(******************) +(* 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_g = (W * R) & ghbl & ~(ghbl; [W]; ghbl) +let vse_hbl_l = (W * R) & lhbl & ~(lhbl; [W]; lhbl) +let gvse = [GLOBAL]; vse_hbl_g +let lvse = [LOCAL]; vse_hbl_l + +(* A non-atomic load can only read from a store that is visible. *) +irreflexive rf; [NA & GLOBAL]; ~(gvse^-1) as global_nonatomic_rf_consistent +irreflexive rf; [NA & 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 + +(**************************) +(* 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] + +(* BEGIN PARTIAL SC STUFF *) +let scp_prime = scp & sc6 +let unv = ~0 +let sc_existance = unv; [SC & ~ALL]; unv +acyclic scp_prime & sc_existance as s_exists +(* END PARTIAL SC STUFF *) + +(***************) +(* Races *) +(***************) + +let conflict = (((W * _) | (_ * W)) \ ((IW * _) | (_ * IW))) & loc + +let gl_hb = ghb | lhb +let dr = conflict & ~(gl_hb | gl_hb^-1) & ~incl \ id +flag ~empty dr as data_race + +let ur = (int & conflict & ~(po | po^-1)) \ id +flag ~empty ur as unsequenced_race + +let bsw = bar_sw_g | bar_sw_l +// let bd = [EF] & ((~int & swg & ~(bar_sw_g | bar_sw_l)); [_]) // opencl_total +let bd = [EF] & (~int & swg) \ bsw +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..6c7fb3df09 100644 --- a/dartagnan/src/main/antlr4/C11Lexer.g4 +++ b/dartagnan/src/main/antlr4/C11Lexer.g4 @@ -1,13 +1,22 @@ 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'; 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..f1772bab49 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 + : openCLSpace? 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,74 @@ 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 | ( 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 +184,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 +210,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 +260,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 = GPU_SCOPES.WORK_ITEM;} + | OpenCLMemoryScopeWG {$scope = GPU_SCOPES.WORK_GROUP;} + | OpenCLMemoryScopeDEV {$scope = GPU_SCOPES.DEVICE;} + | OpenCLMemoryScopeALL {$scope = GPU_SCOPES.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;} ; @@ -292,11 +335,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' ; 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/Dartagnan.java b/dartagnan/src/main/java/com/dat3m/dartagnan/Dartagnan.java index 6709bdb8df..6179b95daf 100644 --- a/dartagnan/src/main/java/com/dat3m/dartagnan/Dartagnan.java +++ b/dartagnan/src/main/java/com/dat3m/dartagnan/Dartagnan.java @@ -76,7 +76,7 @@ public class Dartagnan extends BaseOptions { private static final Logger logger = LogManager.getLogger(Dartagnan.class); private static final Set supportedFormats = - ImmutableSet.copyOf(Arrays.asList(".litmus", ".c", ".i", ".ll", ".spv.dis")); + ImmutableSet.copyOf(Arrays.asList(".litmus", ".c", ".i", ".ll", ".spv.dis", ".cl")); private Dartagnan(Configuration config) throws InvalidConfigurationException { config.recursiveInject(this); 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/encoding/ProgramEncoder.java b/dartagnan/src/main/java/com/dat3m/dartagnan/encoding/ProgramEncoder.java index a7fbbad893..213a7f1037 100644 --- a/dartagnan/src/main/java/com/dat3m/dartagnan/encoding/ProgramEncoder.java +++ b/dartagnan/src/main/java/com/dat3m/dartagnan/encoding/ProgramEncoder.java @@ -173,9 +173,9 @@ private BooleanFormula threadIsStuckInBarrier(Thread thread) { private int getWorkgroupId(Thread thread) { ScopeHierarchy hierarchy = thread.getScopeHierarchy(); if (hierarchy != null) { - int id = hierarchy.getScopeId(Tag.Vulkan.WORK_GROUP); + int id = hierarchy.getScopeId(Tag.GPU_SCOPES.WORK_GROUP); if (id < 0) { - id = hierarchy.getScopeId(Tag.PTX.CTA); + id = hierarchy.getScopeId(Tag.GPU_SCOPES.CTA); } return id; } 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..f934161849 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 @@ -9,6 +9,7 @@ import static com.dat3m.dartagnan.parsers.program.utils.Compilation.applyLlvmPasses; import static com.dat3m.dartagnan.parsers.program.utils.Compilation.compileWithClang; +import static com.dat3m.dartagnan.parsers.program.utils.Compilation.applyDemangling;; public class ProgramParser { @@ -24,6 +25,7 @@ public Program parse(File file) throws Exception { if (needsClang(file)) { file = compileWithClang(file, ""); file = applyLlvmPasses(file); + file = applyDemangling(file); return new ProgramParser().parse(file); } @@ -38,15 +40,15 @@ public Program parse(File file) throws Exception { } private boolean needsClang(File f) { - return f.getPath().endsWith(".c") || f.getPath().endsWith(".i"); + return f.getPath().endsWith(".c") || f.getPath().endsWith(".i") || f.getPath().endsWith(".cl"); } public Program parse(String raw, String path, String format, String cflags) throws Exception { switch (format) { - case "c", "i" -> { + case "c", "i", "cl" -> { File file = path.isEmpty() ? // This is for the case where the user fully typed the program instead of loading it - File.createTempFile("dat3m", ".c") : + File.createTempFile("dat3m", format) : // This is for the case where the user loaded the program new File(path, "dat3m.c"); try (FileWriter writer = new FileWriter(file)) { @@ -54,6 +56,7 @@ public Program parse(String raw, String path, String format, String cflags) thro } file = compileWithClang(file, cflags); file = applyLlvmPasses(file); + file = applyDemangling(file); Program p = new ProgramParser().parse(file); file.delete(); return p; diff --git a/dartagnan/src/main/java/com/dat3m/dartagnan/parsers/program/utils/Compilation.java b/dartagnan/src/main/java/com/dat3m/dartagnan/parsers/program/utils/Compilation.java index 256c4a507d..5b2c89f199 100644 --- a/dartagnan/src/main/java/com/dat3m/dartagnan/parsers/program/utils/Compilation.java +++ b/dartagnan/src/main/java/com/dat3m/dartagnan/parsers/program/utils/Compilation.java @@ -54,25 +54,47 @@ public static File applyLlvmPasses(File file) throws IOException { return new File(outputFileName); } + public static File applyDemangling(File file) throws IOException { + final File outputFile = new File(getOutputName(file, "-dmg.ll")); + ArrayList cmd = new ArrayList<>(); + cmd.add("llvm-cxxfilt"); + try { + runCmd(cmd, file, outputFile); + } catch (Exception e) { + logger.warn("Failed to run llvm-cxxfilt (llvm symbol name demangler). Continuing without demangling."); + return file; + } + return outputFile; + } + private static String getOutputName(File file, String postfix) throws IOException { return getOrCreateOutputDirectory() + "/" + file.getName().substring(0, file.getName().lastIndexOf('.')) + postfix; } private static void runCmd(ArrayList cmd) throws Exception { + runCmd(cmd, null, null); + } + + private static void runCmd(ArrayList cmd, File inputFile, File outputFile) throws Exception { logger.debug(String.join(" ", cmd)); ProcessBuilder processBuilder = new ProcessBuilder(cmd); + if(inputFile != null) { + processBuilder.redirectInput(inputFile); + } // "Unless the standard input and output streams are promptly written and read respectively // of the sub process, it may block or deadlock the sub process." // https://www.developer.com/design/understanding-java-process-and-java-processbuilder/ // The lines below take care of this. - File log = File.createTempFile("log", null); + if(outputFile == null) { + outputFile = File.createTempFile("log", null); + } processBuilder.redirectErrorStream(true); - processBuilder.redirectOutput(log); + processBuilder.redirectOutput(outputFile); Process proc = processBuilder.start(); proc.waitFor(); if(proc.exitValue() != 0) { - String errorString = Files.asCharSource(log, Charsets.UTF_8).read(); + String errorString = Files.asCharSource(outputFile, Charsets.UTF_8).read(); throw new IOException("'" + String.join("' '", cmd) + "': " + errorString); } } 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..b70e81d528 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> addressSpaces = new HashMap<>(); private final Program program; @@ -274,7 +275,10 @@ public Label getEndOfThreadLabel(int tid) { } // ---------------------------------------------------------------------------------------------------------------- - // PTX + // GPU + public void setThreadScopeHierarchy(int tid, ScopeHierarchy scopeHierarchy) { + getOrNewThread(tid).setScopeHierarchy(scopeHierarchy); + } public void newScopedThread(Arch arch, String name, int id, int ...scopeIds) { if(id2FunctionsMap.containsKey(id)) { @@ -297,6 +301,8 @@ public void newScopedThread(Arch arch, int id, int ...ids) { newScopedThread(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 +352,18 @@ public void addSwwPairThreads(int threadId0, int threadId1) { thread0.getSyncSet().add(thread1); } } + + // ---------------------------------------------------------------------------------------------------------------- + // OpenCL + public void setAddressSpace(int threadId, String name, String spaceValue) { + addressSpaces + .computeIfAbsent(threadId, k -> new HashMap<>()) + .put(name, spaceValue); + } + + public String getAddressSpace(int threadId, String name) { + return addressSpaces + .getOrDefault(threadId, new HashMap<>()) + .get(name); + } } 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..7740a50f88 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 @@ -11,12 +11,12 @@ import com.dat3m.dartagnan.parsers.program.utils.ProgramBuilder; import com.dat3m.dartagnan.program.Program; import com.dat3m.dartagnan.program.Register; +import com.dat3m.dartagnan.program.ScopeHierarchy; 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(){ } @@ -156,6 +157,14 @@ 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 (ctx.threadScope() != null) { + ctx.threadScope().accept(this); + this.isOpenCL = true; + } else { + // Set dummy scope hierarchy for CPU threads + programBuilder.setThreadScopeHierarchy(currentThread, + ScopeHierarchy.ScopeHierarchyForOpenCL(-2, -2)); + } visitThreadArguments(ctx.threadArguments()); for(LitmusCParser.ExpressionContext expressionContext : ctx.expression()) @@ -165,18 +174,48 @@ 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; + ScopeHierarchy scopeHierarchy = ScopeHierarchy.ScopeHierarchyForOpenCL(devID, wgID); + programBuilder.setThreadScopeHierarchy(currentThread, scopeHierarchy); + 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, atomic, ...) + // 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); + if (this.isOpenCL) { + if (ctx.openCLSpace() != null) { + programBuilder.setAddressSpace(currentThread, name, ctx.openCLSpace().space); + boolean atomicity = ctx.pointerTypeSpecifier().atomicTypeSpecifier() != null; + object.setIsAtomic(atomicity); + object.setMemorySpace(ctx.openCLSpace().space); } + } else { + // Using GLOBAL_SPACE as default memory space for CPU threads + programBuilder.setAddressSpace(currentThread, name, Tag.OpenCL.GLOBAL_SPACE); + boolean atomicity = ctx.pointerTypeSpecifier().atomicTypeSpecifier() != null + || ctx.pointerTypeSpecifier().basicTypeSpecifier().AtomicInt() != null; + object.setIsAtomic(atomicity); + object.setMemorySpace(Tag.OpenCL.GLOBAL_SPACE); } + programBuilder.addChild(currentThread, EventFactory.newLocal(register, object)); return null; } @@ -253,6 +292,12 @@ 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); + addOpenCLMemorySpaceTag(event, ctx.address.getText()); + if (ctx.openCLScope() != null) { + event.addTags(ctx.openCLScope().scope); + } else { + event.addTags(Tag.GPU_SCOPES.DEVICE); // default memory_scope for OpenCL + } programBuilder.addChild(currentThread, event); return register; } @@ -295,11 +340,51 @@ 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); + addOpenCLMemorySpaceTag(event, ctx.address.getText()); + if (ctx.openCLScope() != null) { + event.addTags(ctx.openCLScope().scope); + } else { + event.addTags(Tag.GPU_SCOPES.DEVICE); // default memory_scope for OpenCL + } + 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.MO_SC, true); // default memory_order for OpenCL + addOpenCLMemorySpaceTag(event, ctx.address.getText()); + event.addTags(Tag.GPU_SCOPES.DEVICE); // default memory_scope for OpenCL + 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); + addOpenCLMemorySpaceTag(event, ctx.address.getText()); + if (ctx.openCLScope() != null) { + event.addTags(ctx.openCLScope().scope); + } else { + event.addTags(Tag.GPU_SCOPES.DEVICE); // default memory_scope for OpenCL + } programBuilder.addChild(currentThread, event); return register; } @@ -308,7 +393,11 @@ 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.MO_SC, false); // default memory_order for OpenCL + addOpenCLMemorySpaceTag(event, ctx.address.getText()); + event.addTags(Tag.GPU_SCOPES.DEVICE); // default memory_scope for OpenCL programBuilder.addChild(currentThread, event); return register; } @@ -323,9 +412,24 @@ public Expression visitReCmpXchg(LitmusCParser.ReCmpXchgContext ctx){ return register; } + @Override public Expression visitReC11LoadExplicit(LitmusCParser.ReC11LoadExplicitContext ctx) { + Register register = getReturnRegister(true); + AtomicLoad event = EventFactory.Atomic.newLoad(register, getAddress(ctx.address), ctx.c11Mo().mo); + addOpenCLMemorySpaceTag(event, ctx.address.getText()); + if (ctx.openCLScope() != null) { + event.addTags(ctx.openCLScope().scope); + } else { + event.addTags(Tag.GPU_SCOPES.DEVICE); // default memory_scope for OpenCL + } + 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); + AtomicLoad event = EventFactory.Atomic.newLoad(register, getAddress(ctx.address), C11.MO_SC); // default memory_order for OpenCL + addOpenCLMemorySpaceTag(event, ctx.address.getText()); + event.addTags(Tag.GPU_SCOPES.DEVICE); // default memory_scope for OpenCL programBuilder.addChild(currentThread, event); return register; } @@ -349,7 +453,8 @@ 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); + Load event = EventFactory.newLoadWithMo(register, getAddress(ctx.address), C11.NONATOMIC); + addOpenCLMemorySpaceTag(event, ctx.address.getText()); programBuilder.addChild(currentThread, event); return register; } @@ -459,10 +564,25 @@ 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); + AtomicStore event = EventFactory.Atomic.newStore(getAddress(ctx.address), value, ctx.c11Mo().mo); + addOpenCLMemorySpaceTag(event, ctx.address.getText()); + if (ctx.openCLScope() != null) { + event.addTags(ctx.openCLScope().scope); + } else { + event.addTags(Tag.GPU_SCOPES.DEVICE); // default memory_scope for OpenCL + } + 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); + AtomicStore event = EventFactory.Atomic.newStore(getAddress(ctx.address), value, C11.MO_SC); // default memory_order for OpenCL + addOpenCLMemorySpaceTag(event, ctx.address.getText()); + event.addTags(Tag.GPU_SCOPES.DEVICE); // default memory_scope for OpenCL return programBuilder.addChild(currentThread, event); } @@ -481,6 +601,10 @@ 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) { + addOpenCLMemorySpaceTag(event, reg.getName()); + event.addTags(Tag.GPU_SCOPES.WORK_ITEM); // default memory_scope for OpenCL weak access + } return programBuilder.addChild(currentThread, event); } throw new ParsingException("Invalid syntax near " + ctx.getText()); @@ -510,6 +634,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 +727,11 @@ private Expression assignToReturnRegister(Register register, Expression value) { } return value; } + + private void addOpenCLMemorySpaceTag(Event event, String addressString) { + String space = programBuilder.getAddressSpace(currentThread, addressString); + if (space != null) { + event.addTags(space); + } + } } 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..661af4a984 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 @@ -407,17 +407,17 @@ private void tagControl(Event e, Boolean atomic, String mo, String avvis, String // AV, VIS, and atomics M are all implicitly nonpriv if ((avvis.equals(Tag.Vulkan.AVAILABLE) || avvis.equals(Tag.Vulkan.VISIBLE) || atomic) && (e instanceof MemoryEvent)) { - e.addTags(Tag.Vulkan.NON_PRIVATE); + e.addTags(Tag.GPU_SCOPES.NON_PRIVATE); } // Atomics implicitly have AV/VIS ops, hence they are implicitly nonpriv if (atomic && e instanceof Store) { e.addTags(Tag.Vulkan.AVAILABLE); - e.addTags(Tag.Vulkan.NON_PRIVATE); + e.addTags(Tag.GPU_SCOPES.NON_PRIVATE); } if (atomic && e instanceof Load) { e.addTags(Tag.Vulkan.VISIBLE); - e.addTags(Tag.Vulkan.NON_PRIVATE); + e.addTags(Tag.GPU_SCOPES.NON_PRIVATE); } } } \ No newline at end of file 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..e373349e86 100644 --- a/dartagnan/src/main/java/com/dat3m/dartagnan/program/ScopeHierarchy.java +++ b/dartagnan/src/main/java/com/dat3m/dartagnan/program/ScopeHierarchy.java @@ -17,18 +17,26 @@ private ScopeHierarchy() {} public static ScopeHierarchy ScopeHierarchyForVulkan(int queueFamily, int workGroup, int subGroup) { ScopeHierarchy scopeHierarchy = new ScopeHierarchy(); - scopeHierarchy.scopeIds.put(Tag.Vulkan.DEVICE, 0); - scopeHierarchy.scopeIds.put(Tag.Vulkan.QUEUE_FAMILY, queueFamily); - scopeHierarchy.scopeIds.put(Tag.Vulkan.WORK_GROUP, workGroup); - scopeHierarchy.scopeIds.put(Tag.Vulkan.SUB_GROUP, subGroup); + scopeHierarchy.scopeIds.put(Tag.GPU_SCOPES.DEVICE, 0); + scopeHierarchy.scopeIds.put(Tag.GPU_SCOPES.QUEUE_FAMILY, queueFamily); + scopeHierarchy.scopeIds.put(Tag.GPU_SCOPES.WORK_GROUP, workGroup); + scopeHierarchy.scopeIds.put(Tag.GPU_SCOPES.SUB_GROUP, subGroup); return scopeHierarchy; } public static ScopeHierarchy ScopeHierarchyForPTX(int gpu, int cta) { ScopeHierarchy scopeHierarchy = new ScopeHierarchy(); - scopeHierarchy.scopeIds.put(Tag.PTX.SYS, 0); - scopeHierarchy.scopeIds.put(Tag.PTX.GPU, gpu); - scopeHierarchy.scopeIds.put(Tag.PTX.CTA, cta); + scopeHierarchy.scopeIds.put(Tag.GPU_SCOPES.SYS, 0); + scopeHierarchy.scopeIds.put(Tag.GPU_SCOPES.GPU, gpu); + scopeHierarchy.scopeIds.put(Tag.GPU_SCOPES.CTA, cta); + return scopeHierarchy; + } + + public static ScopeHierarchy ScopeHierarchyForOpenCL(int dev, int wg) { + ScopeHierarchy scopeHierarchy = new ScopeHierarchy(); + scopeHierarchy.scopeIds.put(Tag.GPU_SCOPES.ALL, 0); + scopeHierarchy.scopeIds.put(Tag.GPU_SCOPES.DEVICE, dev); + scopeHierarchy.scopeIds.put(Tag.GPU_SCOPES.WORK_GROUP, wg); return scopeHierarchy; } 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..4f8e948a52 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,11 @@ public Set getSyncSet() { return syncSet.get(); } + // TODO: remove ScopeHierarchy setter and make field final after the thread creation of C fixed + 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..5cc82b6668 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 @@ -12,6 +12,7 @@ import com.dat3m.dartagnan.program.Function; import com.dat3m.dartagnan.program.Register; import com.dat3m.dartagnan.program.event.arch.StoreExclusive; +import com.dat3m.dartagnan.program.event.arch.opencl.OpenCLInit; import com.dat3m.dartagnan.program.event.arch.ptx.PTXAtomCAS; import com.dat3m.dartagnan.program.event.arch.ptx.PTXAtomExch; import com.dat3m.dartagnan.program.event.arch.ptx.PTXAtomOp; @@ -802,4 +803,18 @@ public static SpirvRmwExtremum newSpirvRmwExtremum(Register register, Expression } } + // ============================================================================================= + // =========================================== OpenCL ========================================== + // ============================================================================================= + public static class OpenCL { + private OpenCL() {} + + public static OpenCLInit newOpenCLInit(MemoryObject base, int offset) { + final Expression address = offset == 0 ? base : + expressions.makeAdd(base, expressions.makeValue(offset, (IntegerType) base.getType())); + return new OpenCLInit(base, offset, address); + } + + } + } \ 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..e9c597b26d 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 @@ -125,7 +125,7 @@ private C11() { 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 String intToMo(int i) { switch (i) { @@ -271,13 +271,27 @@ public static String extractLoadMo(String cMo) { } // ============================================================================================= - // =========================================== PTX ============================================= + // ======================================= GPU Scopes ========================================== // ============================================================================================= - public static final class PTX { - // Scopes + public static final class GPU_SCOPES { + // PTX public static final String CTA = "CTA"; public static final String GPU = "GPU"; public static final String SYS = "SYS"; + // Vulkan, OpenCL + public static final String WORK_ITEM = "WI"; + public static final String SUB_GROUP = "SG"; + public static final String WORK_GROUP = "WG"; + public static final String QUEUE_FAMILY = "QF"; + public static final String DEVICE = "DV"; + public static final String ALL = "ALL"; + public static final String NON_PRIVATE = "NONPRIV"; + } + + // ============================================================================================= + // =========================================== PTX ============================================= + // ============================================================================================= + public static final class PTX { // Memory orders public static final String WEAK = "WEAK"; public static final String RLX = "RLX"; // RELAXED @@ -314,7 +328,7 @@ public static String storeMO(String mo) { } public static List getScopeTags() { - return List.of(CTA, GPU, SYS); + return List.of(GPU_SCOPES.CTA, GPU_SCOPES.GPU, GPU_SCOPES.SYS); } } @@ -325,12 +339,6 @@ public static final class Vulkan { public static final String CBAR = "CBAR"; public static final String AVDEVICE = "AVDEVICE"; public static final String VISDEVICE = "VISDEVICE"; - // Scopes - public static final String SUB_GROUP = "SG"; - public static final String WORK_GROUP = "WG"; - public static final String QUEUE_FAMILY = "QF"; - public static final String DEVICE = "DV"; - public static final String NON_PRIVATE = "NONPRIV"; // Memory orders public static final String ATOM = "ATOM"; public static final String ACQUIRE = "ACQ"; @@ -348,7 +356,7 @@ public static final class Vulkan { public static final String SEMSC1 = "SEMSC1"; public static List getScopeTags() { - return List.of(SUB_GROUP, WORK_GROUP, QUEUE_FAMILY, DEVICE); + return List.of(GPU_SCOPES.SUB_GROUP, GPU_SCOPES.WORK_GROUP, GPU_SCOPES.QUEUE_FAMILY, GPU_SCOPES.DEVICE); } public static String loadMO(String mo) { @@ -366,6 +374,29 @@ public static String storeMO(String mo) { } } + // ============================================================================================= + // ========================================= OpenCL ============================================ + // ============================================================================================= + public static final class OpenCL { + // 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"; + + public static List getScopeTags() { + return List.of(GPU_SCOPES.WORK_GROUP, GPU_SCOPES.DEVICE, GPU_SCOPES.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 +518,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/arch/opencl/OpenCLInit.java b/dartagnan/src/main/java/com/dat3m/dartagnan/program/event/arch/opencl/OpenCLInit.java new file mode 100644 index 0000000000..47b149210e --- /dev/null +++ b/dartagnan/src/main/java/com/dat3m/dartagnan/program/event/arch/opencl/OpenCLInit.java @@ -0,0 +1,19 @@ +package com.dat3m.dartagnan.program.event.arch.opencl; + +import com.dat3m.dartagnan.expression.Expression; +import com.dat3m.dartagnan.program.event.Tag; +import com.dat3m.dartagnan.program.event.core.Init; +import com.dat3m.dartagnan.program.memory.MemoryObject; + +public class OpenCLInit extends Init { + public OpenCLInit(MemoryObject b, int o, Expression address) { + super(b, o, address); + if (b.getMemorySpace() != null) { + addTags(b.getMemorySpace()); + if (b.isAtomic()) { + addTags(Tag.C11.ATOMIC); + } + } + } + +} 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..ec312f6bd9 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 @@ -33,6 +33,8 @@ public class MemoryObject extends LeafExpressionBase { private String name = null; private boolean isThreadLocal = false; + private boolean isAtomic = false; + private String memorySpace = null; private final Map initialValues = new TreeMap<>(); @@ -54,6 +56,12 @@ public class MemoryObject extends LeafExpressionBase { public boolean isThreadLocal() { return this.isThreadLocal; } public void setIsThreadLocal(boolean value) { this.isThreadLocal = value;} + public boolean isAtomic() { return this.isAtomic; } + public void setIsAtomic(boolean value) { this.isAtomic = value;} + + public String getMemorySpace() { return this.memorySpace; } + public void setMemorySpace(String value) { this.memorySpace = value; } + /** * @return Number of fields in this array. */ diff --git a/dartagnan/src/main/java/com/dat3m/dartagnan/program/processing/CoreCodeVerification.java b/dartagnan/src/main/java/com/dat3m/dartagnan/program/processing/CoreCodeVerification.java index bf5d1605fc..1cd9f970d5 100644 --- a/dartagnan/src/main/java/com/dat3m/dartagnan/program/processing/CoreCodeVerification.java +++ b/dartagnan/src/main/java/com/dat3m/dartagnan/program/processing/CoreCodeVerification.java @@ -3,6 +3,7 @@ import com.dat3m.dartagnan.exception.MalformedProgramException; import com.dat3m.dartagnan.program.Function; import com.dat3m.dartagnan.program.event.Event; +import com.dat3m.dartagnan.program.event.arch.opencl.OpenCLInit; import com.dat3m.dartagnan.program.event.core.*; import com.dat3m.dartagnan.program.event.core.annotations.CodeAnnotation; import com.dat3m.dartagnan.program.event.core.threading.ThreadArgument; @@ -38,7 +39,8 @@ public static CoreCodeVerification fromConfig(Configuration config) { Assume.class, Assert.class, ThreadCreate.class, ThreadArgument.class, ThreadStart.class, ControlBarrier.class, // For PTX and Vulkan - BeginAtomic.class, EndAtomic.class + BeginAtomic.class, EndAtomic.class, + OpenCLInit.class // For OpenCL // We add SVCOMP atomic blocks here as well, despite them not being part of the core package. // TODO: We might want to find a more systematic way to extend the core with these custom events. )); 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..f8d65930a4 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; @@ -85,7 +86,11 @@ private void createInitEvents(Program program) { final String threadName = "Init_" + nextThreadId; final Thread thread = new Thread(threadName, initThreadType, paramNames, nextThreadId, EventFactory.newThreadStart(null)); - thread.append(EventFactory.newInit(memObj, field)); + if (program.getArch().equals(Arch.OPENCL)) { + thread.append(EventFactory.OpenCL.newOpenCLInit(memObj, field)); + } else { + thread.append(EventFactory.newInit(memObj, field)); + } thread.append(EventFactory.newLabel("END_OF_T" + thread.getId())); program.addThread(thread); nextThreadId++; 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..5f027ce2ab 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 @@ -123,6 +123,7 @@ private VisitorBase getCompiler() { return switch (target) { case C11 -> new VisitorC11(); case LKMM -> new VisitorLKMM(); + case OPENCL -> new VisitorOpenCL(); case TSO -> new VisitorTso(); case POWER -> new VisitorPower(useRC11Scheme, cToPowerScheme); case ARM8 -> new VisitorArm8(useRC11Scheme); diff --git a/dartagnan/src/main/java/com/dat3m/dartagnan/program/processing/compilation/VisitorOpenCL.java b/dartagnan/src/main/java/com/dat3m/dartagnan/program/processing/compilation/VisitorOpenCL.java new file mode 100644 index 0000000000..d4ef645a5b --- /dev/null +++ b/dartagnan/src/main/java/com/dat3m/dartagnan/program/processing/compilation/VisitorOpenCL.java @@ -0,0 +1,120 @@ +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.BooleanType; +import com.dat3m.dartagnan.expression.Type; +import com.dat3m.dartagnan.program.Register; +import com.dat3m.dartagnan.program.event.Tag; +import com.dat3m.dartagnan.program.event.Tag.C11; +import com.dat3m.dartagnan.program.event.Event; +import com.dat3m.dartagnan.program.event.MemoryEvent; +import com.dat3m.dartagnan.program.event.core.*; +import com.dat3m.dartagnan.program.event.core.RMWStore; +import com.dat3m.dartagnan.program.event.lang.catomic.*; +import com.dat3m.dartagnan.program.event.metadata.MemoryOrder; + +import java.util.List; + +import static com.dat3m.dartagnan.program.event.EventFactory.*; + +public class VisitorOpenCL extends VisitorBase { + + @Override + public List visitAtomicCmpXchg(AtomicCmpXchg e) { + Register resultRegister = e.getResultRegister(); + Expression address = e.getAddress(); + String mo = e.getMo(); + Expression expectedAddr = e.getAddressOfExpected(); + Type type = resultRegister.getType(); + Register booleanResultRegister = type instanceof BooleanType ? resultRegister : + e.getFunction().newRegister(types.getBooleanType()); + Local castResult = type instanceof BooleanType ? null : + newLocal(resultRegister, expressions.makeCast(booleanResultRegister, type)); + Register regExpected = e.getFunction().newRegister(type); + Register regValue = e.getFunction().newRegister(type); + Load loadExpected = newLoad(regExpected, expectedAddr); + Store storeExpected = newStore(expectedAddr, regValue); + Label casFail = newLabel("CAS_fail"); + Label casEnd = newLabel("CAS_end"); + Local casCmpResult = newLocal(booleanResultRegister, expressions.makeEQ(regValue, regExpected)); + CondJump branchOnCasCmpResult = newJumpUnless(booleanResultRegister, casFail); + CondJump gotoCasEnd = newGoto(casEnd); + Load loadValue = newRMWLoadWithMo(regValue, address, mo); + Store storeValue = newRMWStoreWithMo(loadValue, address, e.getStoreValue(), mo); + + return tagList(e, eventSequence( + loadExpected, + loadValue, + casCmpResult, + branchOnCasCmpResult, + storeValue, + gotoCasEnd, + casFail, + storeExpected, + casEnd, + castResult + )); + } + + @Override + public List visitAtomicFetchOp(AtomicFetchOp e) { + Register resultRegister = e.getResultRegister(); + Expression address = e.getAddress(); + String mo = e.getMo(); + + Register dummyReg = e.getFunction().newRegister(resultRegister.getType()); + Load load = newRMWLoadWithMo(resultRegister, address, mo); + Local localOp = newLocal(dummyReg, expressions.makeBinary(resultRegister, e.getOperator(), e.getOperand())); + RMWStore store = newRMWStoreWithMo(load, address, dummyReg, mo); + + return tagList(e, eventSequence( + load, + localOp, + store + )); + } + + @Override + public List visitAtomicLoad(AtomicLoad e) { + return tagList(e, eventSequence( + newLoadWithMo(e.getResultRegister(), e.getAddress(), e.getMo()) + )); + } + + @Override + public List visitAtomicStore(AtomicStore e) { + return tagList(e, eventSequence( + newStoreWithMo(e.getAddress(), e.getMemValue(), e.getMo()) + )); + } + + @Override + public List visitAtomicThreadFence(AtomicThreadFence e) { + return tagList(e, eventSequence( + newFence(e.getMo()) + )); + } + + private List tagList(Event originalEvent, List in) { + in.forEach(this::tagEvent); + String scope = Tag.getScopeTag(originalEvent, Arch.OPENCL); + if (!scope.isEmpty()) { + in.forEach(e -> e.addTags(scope)); + } + List spaces = Tag.OpenCL.getSpaceTags(originalEvent); + if (!spaces.isEmpty()) { + in.forEach(e -> e.addTags(spaces)); + } + + return in; + } + + private void tagEvent(Event e) { + if (e instanceof MemoryEvent) { + final MemoryOrder mo = e.getMetadata(MemoryOrder.class); + final boolean canRace = mo == null || mo.value().equals(C11.NONATOMIC); + e.addTags(canRace ? C11.NONATOMIC : C11.ATOMIC); + } + } +} diff --git a/dartagnan/src/main/java/com/dat3m/dartagnan/program/processing/compilation/VisitorPTX.java b/dartagnan/src/main/java/com/dat3m/dartagnan/program/processing/compilation/VisitorPTX.java index 162118d376..b62d0e2b65 100644 --- a/dartagnan/src/main/java/com/dat3m/dartagnan/program/processing/compilation/VisitorPTX.java +++ b/dartagnan/src/main/java/com/dat3m/dartagnan/program/processing/compilation/VisitorPTX.java @@ -93,7 +93,7 @@ public List visitPtxRedOp(PTXRedOp e) { } private void propagateTags(Event source, Event target) { - for (String tag : List.of(Tag.PTX.CTA, Tag.PTX.GPU, Tag.PTX.SYS, Tag.PTX.GEN, Tag.PTX.TEX, Tag.PTX.SUR, Tag.PTX.CON)) { + for (String tag : List.of(Tag.GPU_SCOPES.CTA, Tag.GPU_SCOPES.GPU, Tag.GPU_SCOPES.SYS, Tag.PTX.GEN, Tag.PTX.TEX, Tag.PTX.SUR, Tag.PTX.CON)) { if (source.hasTag(tag)) { target.addTags(tag); } diff --git a/dartagnan/src/main/java/com/dat3m/dartagnan/program/processing/compilation/VisitorSpirvVulkan.java b/dartagnan/src/main/java/com/dat3m/dartagnan/program/processing/compilation/VisitorSpirvVulkan.java index 80c84f028e..9dd3cb5acf 100644 --- a/dartagnan/src/main/java/com/dat3m/dartagnan/program/processing/compilation/VisitorSpirvVulkan.java +++ b/dartagnan/src/main/java/com/dat3m/dartagnan/program/processing/compilation/VisitorSpirvVulkan.java @@ -156,7 +156,7 @@ private Set toVulkanTags(Set tags) { private Set adjustVulkanTags(Set tags, Set vTags) { if (tags.contains(Tag.MEMORY) && toVulkanTag(Tag.Spirv.getStorageClassTag(tags)) != null) { - vTags.add(Tag.Vulkan.NON_PRIVATE); + vTags.add(Tag.GPU_SCOPES.NON_PRIVATE); if (vTags.contains(Tag.READ)) { vTags.add(Tag.Vulkan.VISIBLE); } @@ -206,21 +206,21 @@ private String toVulkanTag(String tag) { Tag.Spirv.SEQ_CST -> Tag.Vulkan.ACQ_REL; // Scope - case Tag.Spirv.SUBGROUP -> Tag.Vulkan.SUB_GROUP; - case Tag.Spirv.WORKGROUP -> Tag.Vulkan.WORK_GROUP; - case Tag.Spirv.QUEUE_FAMILY -> Tag.Vulkan.QUEUE_FAMILY; + case Tag.Spirv.SUBGROUP -> Tag.GPU_SCOPES.SUB_GROUP; + case Tag.Spirv.WORKGROUP -> Tag.GPU_SCOPES.WORK_GROUP; + case Tag.Spirv.QUEUE_FAMILY -> Tag.GPU_SCOPES.QUEUE_FAMILY; // TODO: Refactoring of the cat model // In the cat file AV/VISSHADER uses device domain, // and device domain is mapped to AV/VISDEVICE case Tag.Spirv.INVOCATION, Tag.Spirv.SHADER_CALL, Tag.Spirv.DEVICE, - Tag.Spirv.CROSS_DEVICE -> Tag.Vulkan.DEVICE; + Tag.Spirv.CROSS_DEVICE -> Tag.GPU_SCOPES.DEVICE; // Memory access (non-atomic) case Tag.Spirv.MEM_VOLATILE, Tag.Spirv.MEM_NONTEMPORAL -> null; - case Tag.Spirv.MEM_NON_PRIVATE -> Tag.Vulkan.NON_PRIVATE; + case Tag.Spirv.MEM_NON_PRIVATE -> Tag.GPU_SCOPES.NON_PRIVATE; case Tag.Spirv.MEM_AVAILABLE -> Tag.Vulkan.AVAILABLE; case Tag.Spirv.MEM_VISIBLE -> Tag.Vulkan.VISIBLE; diff --git a/dartagnan/src/main/java/com/dat3m/dartagnan/program/processing/compilation/VisitorVulkan.java b/dartagnan/src/main/java/com/dat3m/dartagnan/program/processing/compilation/VisitorVulkan.java index 1ee857bbb8..2be02b290d 100644 --- a/dartagnan/src/main/java/com/dat3m/dartagnan/program/processing/compilation/VisitorVulkan.java +++ b/dartagnan/src/main/java/com/dat3m/dartagnan/program/processing/compilation/VisitorVulkan.java @@ -95,8 +95,8 @@ public List visitVulkanCmpXchg(VulkanCmpXchg e) { } private void propagateTags(Event source, Event target) { - for (String tag : List.of(Tag.Vulkan.SUB_GROUP, Tag.Vulkan.WORK_GROUP, Tag.Vulkan.QUEUE_FAMILY, Tag.Vulkan.DEVICE, - Tag.Vulkan.NON_PRIVATE, Tag.Vulkan.ATOM, Tag.Vulkan.SC0, Tag.Vulkan.SC1, Tag.Vulkan.SEMSC0, Tag.Vulkan.SEMSC1)) { + for (String tag : List.of(Tag.GPU_SCOPES.SUB_GROUP, Tag.GPU_SCOPES.WORK_GROUP, Tag.GPU_SCOPES.QUEUE_FAMILY, Tag.GPU_SCOPES.DEVICE, + Tag.GPU_SCOPES.NON_PRIVATE, Tag.Vulkan.ATOM, Tag.Vulkan.SC0, Tag.Vulkan.SC1, Tag.Vulkan.SEMSC0, Tag.Vulkan.SEMSC1)) { if (source.hasTag(tag)) { target.addTags(tag); } 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..604ee928ff 100755 --- a/dartagnan/src/main/java/com/dat3m/dartagnan/wmm/Wmm.java +++ b/dartagnan/src/main/java/com/dat3m/dartagnan/wmm/Wmm.java @@ -221,10 +221,11 @@ private Relation makePredefinedRelation(String name) { yield intersection(r, comp, mv); } case SR -> new SameScope(r); - case SCTA -> new SameScope(r, Tag.PTX.CTA); - 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 SCTA -> new SameScope(r, Tag.GPU_SCOPES.CTA); + case SSG -> new SameScope(r, Tag.GPU_SCOPES.SUB_GROUP); + case SWG -> new SameScope(r, Tag.GPU_SCOPES.WORK_GROUP); + case SQF -> new SameScope(r, Tag.GPU_SCOPES.QUEUE_FAMILY); + case SDV -> new SameScope(r, Tag.GPU_SCOPES.DEVICE); case SSW -> new SyncWith(r); case SYNCBAR -> new SyncBar(r); case SYNC_FENCE -> new SyncFence(r); diff --git a/dartagnan/src/main/java/com/dat3m/dartagnan/wmm/axiom/Axiom.java b/dartagnan/src/main/java/com/dat3m/dartagnan/wmm/axiom/Axiom.java index ca6ae71730..ae80360ec4 100755 --- a/dartagnan/src/main/java/com/dat3m/dartagnan/wmm/axiom/Axiom.java +++ b/dartagnan/src/main/java/com/dat3m/dartagnan/wmm/axiom/Axiom.java @@ -105,4 +105,16 @@ public boolean isAcyclicity() { public boolean isIrreflexivity() { return this instanceof Irreflexivity; } + + public Axiom copy(Relation rel) { + if(isEmptiness()) { + return new Emptiness(rel, negated, flag); + } else if(isAcyclicity()) { + return new Acyclicity(rel, negated, flag); + } else if(isIrreflexivity()) { + return new Irreflexivity(rel, negated, flag); + } else { + throw new UnsupportedOperationException("Unsupported axiom type"); + } + } } \ No newline at end of file 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/program/processing/compilation/VisitorSpirvVulkanTest.java b/dartagnan/src/test/java/com/dat3m/dartagnan/program/processing/compilation/VisitorSpirvVulkanTest.java index 20461a6ad8..d2c4853c93 100644 --- a/dartagnan/src/test/java/com/dat3m/dartagnan/program/processing/compilation/VisitorSpirvVulkanTest.java +++ b/dartagnan/src/test/java/com/dat3m/dartagnan/program/processing/compilation/VisitorSpirvVulkanTest.java @@ -40,15 +40,15 @@ public void testLoad() { ); doTestLoad( Set.of(Tag.Spirv.SC_WORKGROUP), - Set.of(Tag.Vulkan.SC1, Tag.Vulkan.NON_PRIVATE, Tag.Vulkan.VISIBLE) + Set.of(Tag.Vulkan.SC1, Tag.GPU_SCOPES.NON_PRIVATE, Tag.Vulkan.VISIBLE) ); doTestLoad( Set.of(Tag.Spirv.MEM_VISIBLE, Tag.Spirv.SC_UNIFORM), - Set.of(Tag.Vulkan.VISIBLE, Tag.Vulkan.SC0, Tag.Vulkan.NON_PRIVATE) + Set.of(Tag.Vulkan.VISIBLE, Tag.Vulkan.SC0, Tag.GPU_SCOPES.NON_PRIVATE) ); doTestLoad( Set.of(Tag.Spirv.MEM_VISIBLE, Tag.Spirv.DEVICE, Tag.Spirv.SC_UNIFORM), - Set.of(Tag.Vulkan.VISIBLE, Tag.Vulkan.DEVICE, Tag.Vulkan.VISDEVICE, Tag.Vulkan.SC0, Tag.Vulkan.NON_PRIVATE) + Set.of(Tag.Vulkan.VISIBLE, Tag.GPU_SCOPES.DEVICE, Tag.Vulkan.VISDEVICE, Tag.Vulkan.SC0, Tag.GPU_SCOPES.NON_PRIVATE) ); } @@ -77,15 +77,15 @@ public void testStore() { ); doTestStore( Set.of(Tag.Spirv.SC_WORKGROUP), - Set.of(Tag.Vulkan.SC1, Tag.Vulkan.NON_PRIVATE, Tag.Vulkan.AVAILABLE) + Set.of(Tag.Vulkan.SC1, Tag.GPU_SCOPES.NON_PRIVATE, Tag.Vulkan.AVAILABLE) ); doTestStore( Set.of(Tag.Spirv.MEM_AVAILABLE, Tag.Spirv.SC_UNIFORM), - Set.of(Tag.Vulkan.AVAILABLE, Tag.Vulkan.SC0, Tag.Vulkan.NON_PRIVATE) + Set.of(Tag.Vulkan.AVAILABLE, Tag.Vulkan.SC0, Tag.GPU_SCOPES.NON_PRIVATE) ); doTestStore( Set.of(Tag.Spirv.MEM_AVAILABLE, Tag.Spirv.DEVICE, Tag.Spirv.SC_UNIFORM), - Set.of(Tag.Vulkan.AVAILABLE, Tag.Vulkan.DEVICE, Tag.Vulkan.AVDEVICE, Tag.Vulkan.SC0, Tag.Vulkan.NON_PRIVATE) + Set.of(Tag.Vulkan.AVAILABLE, Tag.GPU_SCOPES.DEVICE, Tag.Vulkan.AVDEVICE, Tag.Vulkan.SC0, Tag.GPU_SCOPES.NON_PRIVATE) ); } @@ -110,23 +110,23 @@ private void doTestStore(Set spvTags, Set vulTags) { public void testSpirvLoad() { doTestSpirvLoad( Set.of(Tag.Spirv.RELAXED, Tag.Spirv.SUBGROUP, Tag.Spirv.SC_WORKGROUP), - Set.of(Tag.Vulkan.SUB_GROUP, Tag.Vulkan.SC1, Tag.Vulkan.NON_PRIVATE) + Set.of(Tag.GPU_SCOPES.SUB_GROUP, Tag.Vulkan.SC1, Tag.GPU_SCOPES.NON_PRIVATE) ); doTestSpirvLoad( Set.of(Tag.Spirv.SEQ_CST, Tag.Spirv.SUBGROUP, Tag.Spirv.SC_WORKGROUP), - Set.of(Tag.Vulkan.ACQUIRE, Tag.Vulkan.SUB_GROUP, Tag.Vulkan.SC1, Tag.Vulkan.NON_PRIVATE) + Set.of(Tag.Vulkan.ACQUIRE, Tag.GPU_SCOPES.SUB_GROUP, Tag.Vulkan.SC1, Tag.GPU_SCOPES.NON_PRIVATE) ); doTestSpirvLoad( Set.of(Tag.Spirv.ACQUIRE, Tag.Spirv.WORKGROUP, Tag.Spirv.SC_WORKGROUP), - Set.of(Tag.Vulkan.ACQUIRE, Tag.Vulkan.WORK_GROUP, Tag.Vulkan.SC1, Tag.Vulkan.NON_PRIVATE) + Set.of(Tag.Vulkan.ACQUIRE, Tag.GPU_SCOPES.WORK_GROUP, Tag.Vulkan.SC1, Tag.GPU_SCOPES.NON_PRIVATE) ); doTestSpirvLoad( Set.of(Tag.Spirv.ACQUIRE, Tag.Spirv.WORKGROUP, Tag.Spirv.SEM_UNIFORM, Tag.Spirv.SEM_VISIBLE, Tag.Spirv.SC_UNIFORM), - Set.of(Tag.Vulkan.ACQUIRE, Tag.Vulkan.WORK_GROUP, Tag.Vulkan.SEMSC0, Tag.Vulkan.SEM_VISIBLE, Tag.Vulkan.SC0, Tag.Vulkan.NON_PRIVATE) + Set.of(Tag.Vulkan.ACQUIRE, Tag.GPU_SCOPES.WORK_GROUP, Tag.Vulkan.SEMSC0, Tag.Vulkan.SEM_VISIBLE, Tag.Vulkan.SC0, Tag.GPU_SCOPES.NON_PRIVATE) ); doTestSpirvLoad( Set.of(Tag.Spirv.RELAXED, Tag.Spirv.DEVICE, Tag.Spirv.SC_UNIFORM), - Set.of(Tag.Vulkan.DEVICE, Tag.Vulkan.VISDEVICE, Tag.Vulkan.SC0, Tag.Vulkan.NON_PRIVATE) + Set.of(Tag.GPU_SCOPES.DEVICE, Tag.Vulkan.VISDEVICE, Tag.Vulkan.SC0, Tag.GPU_SCOPES.NON_PRIVATE) ); } @@ -145,7 +145,7 @@ private void doTestSpirvLoad(Set spvTags, Set vulTags) { assertEquals(1, seq.size()); Load load = (Load) seq.get(0); Set baseTags = Set.of(Tag.VISIBLE, Tag.MEMORY, Tag.READ, Tag.Vulkan.ATOM, - Tag.Vulkan.VISIBLE, Tag.Vulkan.NON_PRIVATE); + Tag.Vulkan.VISIBLE, Tag.GPU_SCOPES.NON_PRIVATE); assertEquals(Sets.union(baseTags, vulTags), load.getTags()); } @@ -153,23 +153,23 @@ private void doTestSpirvLoad(Set spvTags, Set vulTags) { public void testSpirvStore() { doTestSpirvStore( Set.of(Tag.Spirv.RELAXED, Tag.Spirv.SUBGROUP, Tag.Spirv.SC_WORKGROUP), - Set.of(Tag.Vulkan.SUB_GROUP, Tag.Vulkan.SC1, Tag.Vulkan.NON_PRIVATE) + Set.of(Tag.GPU_SCOPES.SUB_GROUP, Tag.Vulkan.SC1, Tag.GPU_SCOPES.NON_PRIVATE) ); doTestSpirvStore( Set.of(Tag.Spirv.SEQ_CST, Tag.Spirv.SUBGROUP, Tag.Spirv.SC_WORKGROUP), - Set.of(Tag.Vulkan.RELEASE, Tag.Vulkan.SUB_GROUP, Tag.Vulkan.SC1, Tag.Vulkan.NON_PRIVATE) + Set.of(Tag.Vulkan.RELEASE, Tag.GPU_SCOPES.SUB_GROUP, Tag.Vulkan.SC1, Tag.GPU_SCOPES.NON_PRIVATE) ); doTestSpirvStore( Set.of(Tag.Spirv.RELEASE, Tag.Spirv.WORKGROUP, Tag.Spirv.SC_WORKGROUP), - Set.of(Tag.Vulkan.RELEASE, Tag.Vulkan.WORK_GROUP, Tag.Vulkan.SC1, Tag.Vulkan.NON_PRIVATE) + Set.of(Tag.Vulkan.RELEASE, Tag.GPU_SCOPES.WORK_GROUP, Tag.Vulkan.SC1, Tag.GPU_SCOPES.NON_PRIVATE) ); doTestSpirvStore( Set.of(Tag.Spirv.RELEASE, Tag.Spirv.WORKGROUP, Tag.Spirv.SEM_UNIFORM, Tag.Spirv.SEM_AVAILABLE, Tag.Spirv.SC_UNIFORM), - Set.of(Tag.Vulkan.RELEASE, Tag.Vulkan.WORK_GROUP, Tag.Vulkan.SEMSC0, Tag.Vulkan.SEM_AVAILABLE, Tag.Vulkan.SC0, Tag.Vulkan.NON_PRIVATE) + Set.of(Tag.Vulkan.RELEASE, Tag.GPU_SCOPES.WORK_GROUP, Tag.Vulkan.SEMSC0, Tag.Vulkan.SEM_AVAILABLE, Tag.Vulkan.SC0, Tag.GPU_SCOPES.NON_PRIVATE) ); doTestSpirvStore( Set.of(Tag.Spirv.RELAXED, Tag.Spirv.DEVICE, Tag.Spirv.SC_UNIFORM), - Set.of(Tag.Vulkan.DEVICE, Tag.Vulkan.AVDEVICE, Tag.Vulkan.SC0, Tag.Vulkan.NON_PRIVATE) + Set.of(Tag.GPU_SCOPES.DEVICE, Tag.Vulkan.AVDEVICE, Tag.Vulkan.SC0, Tag.GPU_SCOPES.NON_PRIVATE) ); } @@ -188,7 +188,7 @@ private void doTestSpirvStore(Set spvTags, Set vulTags) { assertEquals(1, seq.size()); Store store = (Store) seq.get(0); Set baseTags = Set.of(Tag.VISIBLE, Tag.MEMORY, Tag.WRITE, Tag.Vulkan.ATOM, - Tag.Vulkan.AVAILABLE, Tag.Vulkan.NON_PRIVATE); + Tag.Vulkan.AVAILABLE, Tag.GPU_SCOPES.NON_PRIVATE); assertEquals(Sets.union(baseTags, vulTags), store.getTags()); } @@ -196,33 +196,33 @@ private void doTestSpirvStore(Set spvTags, Set vulTags) { public void testSpirvXchg() { doTestSpirvXchg( Set.of(Tag.Spirv.RELAXED, Tag.Spirv.SUBGROUP, Tag.Spirv.SC_WORKGROUP), - Set.of(Tag.Vulkan.SUB_GROUP, Tag.Vulkan.SC1, Tag.Vulkan.NON_PRIVATE), - Set.of(Tag.Vulkan.SUB_GROUP, Tag.Vulkan.SC1, Tag.Vulkan.NON_PRIVATE) + Set.of(Tag.GPU_SCOPES.SUB_GROUP, Tag.Vulkan.SC1, Tag.GPU_SCOPES.NON_PRIVATE), + Set.of(Tag.GPU_SCOPES.SUB_GROUP, Tag.Vulkan.SC1, Tag.GPU_SCOPES.NON_PRIVATE) ); doTestSpirvXchg( Set.of(Tag.Spirv.ACQUIRE, Tag.Spirv.WORKGROUP, Tag.Spirv.SC_WORKGROUP), - Set.of(Tag.Vulkan.ACQUIRE, Tag.Vulkan.WORK_GROUP, Tag.Vulkan.SC1, Tag.Vulkan.NON_PRIVATE), - Set.of(Tag.Vulkan.WORK_GROUP, Tag.Vulkan.SC1, Tag.Vulkan.NON_PRIVATE) + Set.of(Tag.Vulkan.ACQUIRE, Tag.GPU_SCOPES.WORK_GROUP, Tag.Vulkan.SC1, Tag.GPU_SCOPES.NON_PRIVATE), + Set.of(Tag.GPU_SCOPES.WORK_GROUP, Tag.Vulkan.SC1, Tag.GPU_SCOPES.NON_PRIVATE) ); doTestSpirvXchg( Set.of(Tag.Spirv.RELEASE, Tag.Spirv.WORKGROUP, Tag.Spirv.SC_WORKGROUP), - Set.of(Tag.Vulkan.WORK_GROUP, Tag.Vulkan.SC1, Tag.Vulkan.NON_PRIVATE), - Set.of(Tag.Vulkan.RELEASE, Tag.Vulkan.WORK_GROUP, Tag.Vulkan.SC1, Tag.Vulkan.NON_PRIVATE) + Set.of(Tag.GPU_SCOPES.WORK_GROUP, Tag.Vulkan.SC1, Tag.GPU_SCOPES.NON_PRIVATE), + Set.of(Tag.Vulkan.RELEASE, Tag.GPU_SCOPES.WORK_GROUP, Tag.Vulkan.SC1, Tag.GPU_SCOPES.NON_PRIVATE) ); doTestSpirvXchg( Set.of(Tag.Spirv.ACQ_REL, Tag.Spirv.WORKGROUP, Tag.Spirv.SC_WORKGROUP), - Set.of(Tag.Vulkan.ACQUIRE, Tag.Vulkan.WORK_GROUP, Tag.Vulkan.SC1, Tag.Vulkan.NON_PRIVATE), - Set.of(Tag.Vulkan.RELEASE, Tag.Vulkan.WORK_GROUP, Tag.Vulkan.SC1, Tag.Vulkan.NON_PRIVATE) + Set.of(Tag.Vulkan.ACQUIRE, Tag.GPU_SCOPES.WORK_GROUP, Tag.Vulkan.SC1, Tag.GPU_SCOPES.NON_PRIVATE), + Set.of(Tag.Vulkan.RELEASE, Tag.GPU_SCOPES.WORK_GROUP, Tag.Vulkan.SC1, Tag.GPU_SCOPES.NON_PRIVATE) ); doTestSpirvXchg( Set.of(Tag.Spirv.SEQ_CST, Tag.Spirv.WORKGROUP, Tag.Spirv.SC_WORKGROUP), - Set.of(Tag.Vulkan.ACQUIRE, Tag.Vulkan.WORK_GROUP, Tag.Vulkan.SC1, Tag.Vulkan.NON_PRIVATE), - Set.of(Tag.Vulkan.RELEASE, Tag.Vulkan.WORK_GROUP, Tag.Vulkan.SC1, Tag.Vulkan.NON_PRIVATE) + Set.of(Tag.Vulkan.ACQUIRE, Tag.GPU_SCOPES.WORK_GROUP, Tag.Vulkan.SC1, Tag.GPU_SCOPES.NON_PRIVATE), + Set.of(Tag.Vulkan.RELEASE, Tag.GPU_SCOPES.WORK_GROUP, Tag.Vulkan.SC1, Tag.GPU_SCOPES.NON_PRIVATE) ); doTestSpirvXchg( Set.of(Tag.Spirv.RELAXED, Tag.Spirv.DEVICE, Tag.Spirv.SC_WORKGROUP), - Set.of(Tag.Vulkan.DEVICE, Tag.Vulkan.VISDEVICE, Tag.Vulkan.SC1, Tag.Vulkan.NON_PRIVATE), - Set.of(Tag.Vulkan.DEVICE, Tag.Vulkan.AVDEVICE, Tag.Vulkan.SC1, Tag.Vulkan.NON_PRIVATE) + Set.of(Tag.GPU_SCOPES.DEVICE, Tag.Vulkan.VISDEVICE, Tag.Vulkan.SC1, Tag.GPU_SCOPES.NON_PRIVATE), + Set.of(Tag.GPU_SCOPES.DEVICE, Tag.Vulkan.AVDEVICE, Tag.Vulkan.SC1, Tag.GPU_SCOPES.NON_PRIVATE) ); } @@ -243,11 +243,11 @@ private void doTestSpirvXchg(Set spvTags, Set loadTags, Set baseLoadTags = Set.of(Tag.VISIBLE, Tag.MEMORY, Tag.READ, Tag.RMW, Tag.Vulkan.ATOM, - Tag.Vulkan.VISIBLE, Tag.Vulkan.NON_PRIVATE); + Tag.Vulkan.VISIBLE, Tag.GPU_SCOPES.NON_PRIVATE); assertEquals(Sets.union(baseLoadTags, loadTags), load.getTags()); Store store = (Store) seq.get(1); Set baseStoreTags = Set.of(Tag.VISIBLE, Tag.MEMORY, Tag.WRITE, Tag.RMW, Tag.Vulkan.ATOM, - Tag.Vulkan.AVAILABLE, Tag.Vulkan.NON_PRIVATE); + Tag.Vulkan.AVAILABLE, Tag.GPU_SCOPES.NON_PRIVATE); assertEquals(Sets.union(baseStoreTags, storeTags), store.getTags()); Local local = (Local) seq.get(2); assertEquals(register, local.getResultRegister()); @@ -257,33 +257,33 @@ private void doTestSpirvXchg(Set spvTags, Set loadTags, Set spvTags, Set loadTags, Set baseLoadTags = Set.of(Tag.VISIBLE, Tag.MEMORY, Tag.READ, Tag.RMW, Tag.Vulkan.ATOM, - Tag.Vulkan.VISIBLE, Tag.Vulkan.NON_PRIVATE); + Tag.Vulkan.VISIBLE, Tag.GPU_SCOPES.NON_PRIVATE); assertEquals(Sets.union(baseLoadTags, loadTags), load.getTags()); Store store = (Store) seq.get(1); Set baseStoreTags = Set.of(Tag.VISIBLE, Tag.MEMORY, Tag.WRITE, Tag.RMW, Tag.Vulkan.ATOM, - Tag.Vulkan.AVAILABLE, Tag.Vulkan.NON_PRIVATE); + Tag.Vulkan.AVAILABLE, Tag.GPU_SCOPES.NON_PRIVATE); assertEquals(Sets.union(baseStoreTags, storeTags), store.getTags()); Local local = (Local) seq.get(2); assertEquals(register, local.getResultRegister()); @@ -320,38 +320,38 @@ public void testSpirvCmpXchg() { Tag.Spirv.WORKGROUP, Set.of(Tag.Spirv.RELAXED, Tag.Spirv.SC_WORKGROUP), Set.of(Tag.Spirv.RELAXED, Tag.Spirv.SC_WORKGROUP), - Set.of(Tag.Vulkan.WORK_GROUP, Tag.Vulkan.SC1, Tag.Vulkan.NON_PRIVATE), - Set.of(Tag.Vulkan.WORK_GROUP, Tag.Vulkan.SC1, Tag.Vulkan.NON_PRIVATE)); + Set.of(Tag.GPU_SCOPES.WORK_GROUP, Tag.Vulkan.SC1, Tag.GPU_SCOPES.NON_PRIVATE), + Set.of(Tag.GPU_SCOPES.WORK_GROUP, Tag.Vulkan.SC1, Tag.GPU_SCOPES.NON_PRIVATE)); doTestSpirvCmpXchg( Tag.Spirv.WORKGROUP, Set.of(Tag.Spirv.ACQUIRE, Tag.Spirv.SC_WORKGROUP), Set.of(Tag.Spirv.ACQUIRE, Tag.Spirv.SC_WORKGROUP), - Set.of(Tag.Vulkan.ACQUIRE, Tag.Vulkan.WORK_GROUP, Tag.Vulkan.SC1, Tag.Vulkan.NON_PRIVATE), - Set.of(Tag.Vulkan.WORK_GROUP, Tag.Vulkan.SC1, Tag.Vulkan.NON_PRIVATE)); + Set.of(Tag.Vulkan.ACQUIRE, Tag.GPU_SCOPES.WORK_GROUP, Tag.Vulkan.SC1, Tag.GPU_SCOPES.NON_PRIVATE), + Set.of(Tag.GPU_SCOPES.WORK_GROUP, Tag.Vulkan.SC1, Tag.GPU_SCOPES.NON_PRIVATE)); doTestSpirvCmpXchg( Tag.Spirv.WORKGROUP, Set.of(Tag.Spirv.RELEASE, Tag.Spirv.SC_WORKGROUP), Set.of(Tag.Spirv.RELAXED, Tag.Spirv.SC_WORKGROUP), - Set.of(Tag.Vulkan.WORK_GROUP, Tag.Vulkan.SC1, Tag.Vulkan.NON_PRIVATE), - Set.of(Tag.Vulkan.RELEASE, Tag.Vulkan.WORK_GROUP, Tag.Vulkan.SC1, Tag.Vulkan.NON_PRIVATE)); + Set.of(Tag.GPU_SCOPES.WORK_GROUP, Tag.Vulkan.SC1, Tag.GPU_SCOPES.NON_PRIVATE), + Set.of(Tag.Vulkan.RELEASE, Tag.GPU_SCOPES.WORK_GROUP, Tag.Vulkan.SC1, Tag.GPU_SCOPES.NON_PRIVATE)); doTestSpirvCmpXchg( Tag.Spirv.WORKGROUP, Set.of(Tag.Spirv.ACQ_REL, Tag.Spirv.SC_WORKGROUP), Set.of(Tag.Spirv.ACQUIRE, Tag.Spirv.SC_WORKGROUP), - Set.of(Tag.Vulkan.ACQUIRE, Tag.Vulkan.WORK_GROUP, Tag.Vulkan.SC1, Tag.Vulkan.NON_PRIVATE), - Set.of(Tag.Vulkan.RELEASE, Tag.Vulkan.WORK_GROUP, Tag.Vulkan.SC1, Tag.Vulkan.NON_PRIVATE)); + Set.of(Tag.Vulkan.ACQUIRE, Tag.GPU_SCOPES.WORK_GROUP, Tag.Vulkan.SC1, Tag.GPU_SCOPES.NON_PRIVATE), + Set.of(Tag.Vulkan.RELEASE, Tag.GPU_SCOPES.WORK_GROUP, Tag.Vulkan.SC1, Tag.GPU_SCOPES.NON_PRIVATE)); doTestSpirvCmpXchg( Tag.Spirv.WORKGROUP, Set.of(Tag.Spirv.SEQ_CST, Tag.Spirv.SC_WORKGROUP), Set.of(Tag.Spirv.ACQUIRE, Tag.Spirv.SC_WORKGROUP), - Set.of(Tag.Vulkan.ACQUIRE, Tag.Vulkan.WORK_GROUP, Tag.Vulkan.SC1, Tag.Vulkan.NON_PRIVATE), - Set.of(Tag.Vulkan.RELEASE, Tag.Vulkan.WORK_GROUP, Tag.Vulkan.SC1, Tag.Vulkan.NON_PRIVATE)); + Set.of(Tag.Vulkan.ACQUIRE, Tag.GPU_SCOPES.WORK_GROUP, Tag.Vulkan.SC1, Tag.GPU_SCOPES.NON_PRIVATE), + Set.of(Tag.Vulkan.RELEASE, Tag.GPU_SCOPES.WORK_GROUP, Tag.Vulkan.SC1, Tag.GPU_SCOPES.NON_PRIVATE)); doTestSpirvCmpXchg( Tag.Spirv.DEVICE, Set.of(Tag.Spirv.RELAXED, Tag.Spirv.SC_WORKGROUP), Set.of(Tag.Spirv.RELAXED, Tag.Spirv.SC_WORKGROUP), - Set.of(Tag.Vulkan.DEVICE, Tag.Vulkan.VISDEVICE, Tag.Vulkan.SC1, Tag.Vulkan.NON_PRIVATE), - Set.of(Tag.Vulkan.DEVICE, Tag.Vulkan.AVDEVICE, Tag.Vulkan.SC1, Tag.Vulkan.NON_PRIVATE)); + Set.of(Tag.GPU_SCOPES.DEVICE, Tag.Vulkan.VISDEVICE, Tag.Vulkan.SC1, Tag.GPU_SCOPES.NON_PRIVATE), + Set.of(Tag.GPU_SCOPES.DEVICE, Tag.Vulkan.AVDEVICE, Tag.Vulkan.SC1, Tag.GPU_SCOPES.NON_PRIVATE)); } private void doTestSpirvCmpXchg(String scope, Set eqTags, Set neqTags, Set loadTags, Set storeTags) { @@ -371,11 +371,11 @@ private void doTestSpirvCmpXchg(String scope, Set eqTags, Set ne assertEquals(5, seq.size()); Load load = (Load) seq.get(0); Set baseLoadTags = Set.of(Tag.VISIBLE, Tag.MEMORY, Tag.READ, Tag.RMW, - Tag.Vulkan.ATOM, Tag.Vulkan.VISIBLE, Tag.Vulkan.NON_PRIVATE); + Tag.Vulkan.ATOM, Tag.Vulkan.VISIBLE, Tag.GPU_SCOPES.NON_PRIVATE); assertEquals(Sets.union(baseLoadTags, loadTags), load.getTags()); Store store = (Store) seq.get(3); Set baseStoreTags = Set.of(Tag.VISIBLE, Tag.MEMORY, Tag.WRITE, Tag.RMW, - Tag.Vulkan.ATOM, Tag.Vulkan.AVAILABLE, Tag.Vulkan.NON_PRIVATE); + Tag.Vulkan.ATOM, Tag.Vulkan.AVAILABLE, Tag.GPU_SCOPES.NON_PRIVATE); assertEquals(Sets.union(baseStoreTags, storeTags), store.getTags()); } @@ -424,23 +424,23 @@ private void doTestSpirvCmpXchgIllegal(Set eqTags, Set neqTags, public void testSpirvMemoryBarrier() { doTestSpirvMemoryBarrier( Set.of(Tag.Spirv.RELAXED, Tag.Spirv.SUBGROUP), - Set.of(Tag.Vulkan.SUB_GROUP) + Set.of(Tag.GPU_SCOPES.SUB_GROUP) ); doTestSpirvMemoryBarrier( Set.of(Tag.Spirv.ACQUIRE, Tag.Spirv.SUBGROUP), - Set.of(Tag.Vulkan.ACQUIRE, Tag.Vulkan.SUB_GROUP) + Set.of(Tag.Vulkan.ACQUIRE, Tag.GPU_SCOPES.SUB_GROUP) ); doTestSpirvMemoryBarrier( Set.of(Tag.Spirv.RELEASE, Tag.Spirv.SUBGROUP), - Set.of(Tag.Vulkan.RELEASE, Tag.Vulkan.SUB_GROUP) + Set.of(Tag.Vulkan.RELEASE, Tag.GPU_SCOPES.SUB_GROUP) ); doTestSpirvMemoryBarrier( Set.of(Tag.Spirv.ACQ_REL, Tag.Spirv.SUBGROUP), - Set.of(Tag.Vulkan.ACQUIRE, Tag.Vulkan.RELEASE, Tag.Vulkan.SUB_GROUP) + Set.of(Tag.Vulkan.ACQUIRE, Tag.Vulkan.RELEASE, Tag.GPU_SCOPES.SUB_GROUP) ); doTestSpirvMemoryBarrier( Set.of(Tag.Spirv.SEQ_CST, Tag.Spirv.SUBGROUP), - Set.of(Tag.Vulkan.ACQUIRE, Tag.Vulkan.RELEASE, Tag.Vulkan.SUB_GROUP) + Set.of(Tag.Vulkan.ACQUIRE, Tag.Vulkan.RELEASE, Tag.GPU_SCOPES.SUB_GROUP) ); } @@ -467,23 +467,23 @@ public void testSpirvControlBarrier() { ); doTestSpirvControlBarrier( Set.of(Tag.Spirv.RELAXED, Tag.Spirv.SUBGROUP), - Set.of(Tag.FENCE, Tag.Vulkan.SUB_GROUP) + Set.of(Tag.FENCE, Tag.GPU_SCOPES.SUB_GROUP) ); doTestSpirvControlBarrier( Set.of(Tag.Spirv.ACQUIRE, Tag.Spirv.SUBGROUP), - Set.of(Tag.FENCE, Tag.Vulkan.ACQUIRE, Tag.Vulkan.SUB_GROUP) + Set.of(Tag.FENCE, Tag.Vulkan.ACQUIRE, Tag.GPU_SCOPES.SUB_GROUP) ); doTestSpirvControlBarrier( Set.of(Tag.Spirv.RELEASE, Tag.Spirv.SUBGROUP), - Set.of(Tag.FENCE, Tag.Vulkan.RELEASE, Tag.Vulkan.SUB_GROUP) + Set.of(Tag.FENCE, Tag.Vulkan.RELEASE, Tag.GPU_SCOPES.SUB_GROUP) ); doTestSpirvControlBarrier( Set.of(Tag.Spirv.ACQ_REL, Tag.Spirv.SUBGROUP), - Set.of(Tag.FENCE, Tag.Vulkan.ACQUIRE, Tag.Vulkan.RELEASE, Tag.Vulkan.SUB_GROUP) + Set.of(Tag.FENCE, Tag.Vulkan.ACQUIRE, Tag.Vulkan.RELEASE, Tag.GPU_SCOPES.SUB_GROUP) ); doTestSpirvControlBarrier( Set.of(Tag.Spirv.SEQ_CST, Tag.Spirv.SUBGROUP), - Set.of(Tag.FENCE, Tag.Vulkan.ACQUIRE, Tag.Vulkan.RELEASE, Tag.Vulkan.SUB_GROUP) + Set.of(Tag.FENCE, Tag.Vulkan.ACQUIRE, Tag.Vulkan.RELEASE, Tag.GPU_SCOPES.SUB_GROUP) ); } 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..965fbc9cfa 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 @@ -8,7 +8,7 @@ import java.util.List; -import static com.dat3m.dartagnan.program.event.Tag.Vulkan.*; +import static com.dat3m.dartagnan.program.event.Tag.GPU_SCOPES.*; import static org.junit.Assert.assertEquals; import static org.junit.Assert.fail; 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..4e1b72c3f5 --- /dev/null +++ b/dartagnan/src/test/resources/OPENCL-DR-expected.csv @@ -0,0 +1,41 @@ +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/CT_wsq2.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..393d961c24 --- /dev/null +++ b/dartagnan/src/test/resources/OPENCL-expected.csv @@ -0,0 +1,41 @@ +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,1 +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,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,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 diff --git a/litmus/OPENCL/herd/2+2W.litmus b/litmus/OPENCL/herd/2+2W.litmus new file mode 100644 index 0000000000..8c9996e60e --- /dev/null +++ b/litmus/OPENCL/herd/2+2W.litmus @@ -0,0 +1,22 @@ +C 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..c2860dc6c8 --- /dev/null +++ b/litmus/OPENCL/herd/3.2W.litmus @@ -0,0 +1,30 @@ +C 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..57c0a50c7c --- /dev/null +++ b/litmus/OPENCL/herd/3LB.litmus @@ -0,0 +1,28 @@ +C 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..6ae5f31e68 --- /dev/null +++ b/litmus/OPENCL/herd/CT_wsq1.litmus @@ -0,0 +1,31 @@ +C 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..280ad56867 --- /dev/null +++ b/litmus/OPENCL/herd/CT_wsq2.litmus @@ -0,0 +1,41 @@ +C 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..db724bb1ea --- /dev/null +++ b/litmus/OPENCL/herd/IRIW.litmus @@ -0,0 +1,30 @@ +C 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..28ff8ac569 --- /dev/null +++ b/litmus/OPENCL/herd/ISA2.litmus @@ -0,0 +1,29 @@ +C 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..f27e7f1d3a --- /dev/null +++ b/litmus/OPENCL/herd/ISA3.litmus @@ -0,0 +1,28 @@ +C 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..7bf82e23a2 --- /dev/null +++ b/litmus/OPENCL/herd/LB.litmus @@ -0,0 +1,23 @@ +C 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..1779ae2ff0 --- /dev/null +++ b/litmus/OPENCL/herd/MP.litmus @@ -0,0 +1,23 @@ +C 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..d6a96622c1 --- /dev/null +++ b/litmus/OPENCL/herd/R.litmus @@ -0,0 +1,22 @@ +C 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..36f505933b --- /dev/null +++ b/litmus/OPENCL/herd/RWC.litmus @@ -0,0 +1,29 @@ +C 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..9ac8ea9dbc --- /dev/null +++ b/litmus/OPENCL/herd/S.litmus @@ -0,0 +1,24 @@ +C 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..6ea17b24c4 --- /dev/null +++ b/litmus/OPENCL/herd/SB.litmus @@ -0,0 +1,23 @@ +C 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..0c7d476949 --- /dev/null +++ b/litmus/OPENCL/herd/SB1.litmus @@ -0,0 +1,24 @@ +C 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..52729aa9f1 --- /dev/null +++ b/litmus/OPENCL/herd/WRC.litmus @@ -0,0 +1,29 @@ +C 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..760a01788f --- /dev/null +++ b/litmus/OPENCL/herd/barrier_example.litmus @@ -0,0 +1,24 @@ +C 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..98a633dada --- /dev/null +++ b/litmus/OPENCL/herd/global_barrier.litmus @@ -0,0 +1,120 @@ +C 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..a84a93024b --- /dev/null +++ b/litmus/OPENCL/herd/global_barrier_mo.litmus @@ -0,0 +1,116 @@ +C 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..b94f53f7e0 --- /dev/null +++ b/litmus/OPENCL/herd/old/MP_dr.litmus @@ -0,0 +1,22 @@ +C 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..6e0d9b252a --- /dev/null +++ b/litmus/OPENCL/herd/old/MP_relacq.litmus @@ -0,0 +1,23 @@ +C 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..a4308e8418 --- /dev/null +++ b/litmus/OPENCL/herd/old/MP_relaxed.litmus @@ -0,0 +1,23 @@ +C 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..12143c76ae --- /dev/null +++ b/litmus/OPENCL/herd/old/MP_relseq.litmus @@ -0,0 +1,24 @@ +C 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..d4a03a7226 --- /dev/null +++ b/litmus/OPENCL/herd/thinair.litmus @@ -0,0 +1,22 @@ +C 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..85962e927f --- /dev/null +++ b/litmus/OPENCL/overhauling/IRIW_sc_dev.litmus @@ -0,0 +1,30 @@ +C 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..680284cec1 --- /dev/null +++ b/litmus/OPENCL/overhauling/IRIW_sc_wg.litmus @@ -0,0 +1,30 @@ +C 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..777a95ed91 --- /dev/null +++ b/litmus/OPENCL/overhauling/ISA2.litmus @@ -0,0 +1,33 @@ +C 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..bbefe40040 --- /dev/null +++ b/litmus/OPENCL/overhauling/ISA2_broken.litmus @@ -0,0 +1,33 @@ +C 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..e4073083ac --- /dev/null +++ b/litmus/OPENCL/overhauling/MP_ra_dev.litmus @@ -0,0 +1,25 @@ +C 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..d73c0f2392 --- /dev/null +++ b/litmus/OPENCL/overhauling/MP_ra_dev_broken.litmus @@ -0,0 +1,25 @@ +C 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..b58997b90c --- /dev/null +++ b/litmus/OPENCL/overhauling/MP_ra_wg.litmus @@ -0,0 +1,25 @@ +C 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..48ce68a733 --- /dev/null +++ b/litmus/OPENCL/overhauling/MP_sc_dev.litmus @@ -0,0 +1,25 @@ +C 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..69c2ff081e --- /dev/null +++ b/litmus/OPENCL/overhauling/example10.litmus @@ -0,0 +1,38 @@ +C example10 + +(* + * https://multicore.doc.ic.ac.uk/overhauling/examples/example10.litmus + *) + +{ +[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 1, dev 0 (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 1, 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(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..ea1623408f --- /dev/null +++ b/litmus/OPENCL/overhauling/example4.litmus @@ -0,0 +1,24 @@ +C 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..dc355eb915 --- /dev/null +++ b/litmus/OPENCL/overhauling/example5.litmus @@ -0,0 +1,24 @@ +C 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..91b3c0eedb --- /dev/null +++ b/litmus/OPENCL/overhauling/example6.litmus @@ -0,0 +1,26 @@ +C 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..f50ba20172 --- /dev/null +++ b/litmus/OPENCL/overhauling/example7a.litmus @@ -0,0 +1,24 @@ +C 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..34b60b1ce2 --- /dev/null +++ b/litmus/OPENCL/overhauling/example7b.litmus @@ -0,0 +1,24 @@ +C 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..187641f8a7 --- /dev/null +++ b/litmus/OPENCL/overhauling/example8.litmus @@ -0,0 +1,24 @@ +C 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..9c44e5e903 --- /dev/null +++ b/litmus/OPENCL/overhauling/example9a.litmus @@ -0,0 +1,22 @@ +C 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..1f2a8dd93d --- /dev/null +++ b/litmus/OPENCL/overhauling/example9b.litmus @@ -0,0 +1,22 @@ +C example9b + +(* + * https://multicore.doc.ic.ac.uk/overhauling/examples/example9b.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 From d91d2bac768bd0e9ddd93b4c9549cad6c02ee573 Mon Sep 17 00:00:00 2001 From: haining Date: Sat, 14 Sep 2024 11:59:47 +0300 Subject: [PATCH 02/23] add NAL tag --- cat/opencl.cat | 4 +- .../parsers/program/utils/ProgramBuilder.java | 14 ++-- .../program/visitors/VisitorLitmusC.java | 72 +++++++++++-------- .../dat3m/dartagnan/program/event/Tag.java | 2 + .../program/event/arch/opencl/OpenCLInit.java | 5 +- 5 files changed, 56 insertions(+), 41 deletions(-) diff --git a/cat/opencl.cat b/cat/opencl.cat index 3f7ac541e4..69cb707a16 100644 --- a/cat/opencl.cat +++ b/cat/opencl.cat @@ -100,8 +100,8 @@ let gvse = [GLOBAL]; vse_hbl_g let lvse = [LOCAL]; vse_hbl_l (* A non-atomic load can only read from a store that is visible. *) -irreflexive rf; [NA & GLOBAL]; ~(gvse^-1) as global_nonatomic_rf_consistent -irreflexive rf; [NA & LOCAL]; ~(lvse^-1) as local_nonatomic_rf_consistent +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 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 b70e81d528..567d61c7bc 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,7 +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> addressSpaces = new HashMap<>(); + private final Map reg2LocMap = new HashMap<>(); private final Program program; @@ -355,15 +355,11 @@ public void addSwwPairThreads(int threadId0, int threadId1) { // ---------------------------------------------------------------------------------------------------------------- // OpenCL - public void setAddressSpace(int threadId, String name, String spaceValue) { - addressSpaces - .computeIfAbsent(threadId, k -> new HashMap<>()) - .put(name, spaceValue); + public void setReg2LocMap(Register reg, MemoryObject loc) { + reg2LocMap.put(reg, loc); } - public String getAddressSpace(int threadId, String name) { - return addressSpaces - .getOrDefault(threadId, new HashMap<>()) - .get(name); + 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 7740a50f88..9ed5d01b9e 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 @@ -3,6 +3,7 @@ import com.dat3m.dartagnan.exception.ParsingException; import com.dat3m.dartagnan.expression.Expression; import com.dat3m.dartagnan.expression.ExpressionFactory; +import com.dat3m.dartagnan.expression.base.BinaryExpressionBase; import com.dat3m.dartagnan.expression.integers.IntLiteral; import com.dat3m.dartagnan.expression.type.IntegerType; import com.dat3m.dartagnan.expression.type.TypeFactory; @@ -200,21 +201,21 @@ public Object visitThreadArgument(LitmusCParser.ThreadArgumentContext ctx) { 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; + object.setIsAtomic(atomicity); if (this.isOpenCL) { if (ctx.openCLSpace() != null) { - programBuilder.setAddressSpace(currentThread, name, ctx.openCLSpace().space); - boolean atomicity = ctx.pointerTypeSpecifier().atomicTypeSpecifier() != null; - object.setIsAtomic(atomicity); object.setMemorySpace(ctx.openCLSpace().space); + } else { + // Using GENERIC_SPACE as default memory space for OpenCL threads + object.setMemorySpace(Tag.OpenCL.GENERIC_SPACE); } } else { // Using GLOBAL_SPACE as default memory space for CPU threads - programBuilder.setAddressSpace(currentThread, name, Tag.OpenCL.GLOBAL_SPACE); - boolean atomicity = ctx.pointerTypeSpecifier().atomicTypeSpecifier() != null - || ctx.pointerTypeSpecifier().basicTypeSpecifier().AtomicInt() != null; - object.setIsAtomic(atomicity); object.setMemorySpace(Tag.OpenCL.GLOBAL_SPACE); } + programBuilder.setReg2LocMap(register, object); programBuilder.addChild(currentThread, EventFactory.newLocal(register, object)); return null; } @@ -291,8 +292,9 @@ 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); - addOpenCLMemorySpaceTag(event, ctx.address.getText()); + Expression address = getAddress(ctx.address); + Event event = EventFactory.Atomic.newFetchOp(register, address, value, ctx.op, ctx.c11Mo().mo); + addOpenCLMemorySpaceTag(event, address); if (ctx.openCLScope() != null) { event.addTags(ctx.openCLScope().scope); } else { @@ -348,7 +350,7 @@ public Expression visitReC11SCmpXchgExplicit(LitmusCParser.ReC11SCmpXchgExplicit Expression expectedAdd = getAddress(ctx.expectedAdd); String mo = ctx.c11Mo(0).mo; Event event = EventFactory.Atomic.newCompareExchange(register, address, expectedAdd, value, mo, true); - addOpenCLMemorySpaceTag(event, ctx.address.getText()); + addOpenCLMemorySpaceTag(event, address); if (ctx.openCLScope() != null) { event.addTags(ctx.openCLScope().scope); } else { @@ -365,7 +367,7 @@ public Expression visitReC11SCmpXchg(LitmusCParser.ReC11SCmpXchgContext ctx) { Expression address = getAddress(ctx.address); Expression expectedAdd = getAddress(ctx.expectedAdd); Event event = EventFactory.Atomic.newCompareExchange(register, address, expectedAdd, value, C11.MO_SC, true); // default memory_order for OpenCL - addOpenCLMemorySpaceTag(event, ctx.address.getText()); + addOpenCLMemorySpaceTag(event, address); event.addTags(Tag.GPU_SCOPES.DEVICE); // default memory_scope for OpenCL programBuilder.addChild(currentThread, event); return register; @@ -379,7 +381,7 @@ public Expression visitReC11WCmpXchgExplicit(LitmusCParser.ReC11WCmpXchgExplicit Expression expectedAdd = getAddress(ctx.expectedAdd); String mo = ctx.c11Mo(0).mo; Event event = EventFactory.Atomic.newCompareExchange(register, address, expectedAdd, value, mo, false); - addOpenCLMemorySpaceTag(event, ctx.address.getText()); + addOpenCLMemorySpaceTag(event, address); if (ctx.openCLScope() != null) { event.addTags(ctx.openCLScope().scope); } else { @@ -396,7 +398,7 @@ public Expression visitReC11WCmpXchg(LitmusCParser.ReC11WCmpXchgContext ctx) { Expression address = getAddress(ctx.address); Expression expectedAdd = getAddress(ctx.expectedAdd); Event event = EventFactory.Atomic.newCompareExchange(register, address, expectedAdd, value, C11.MO_SC, false); // default memory_order for OpenCL - addOpenCLMemorySpaceTag(event, ctx.address.getText()); + addOpenCLMemorySpaceTag(event, address); event.addTags(Tag.GPU_SCOPES.DEVICE); // default memory_scope for OpenCL programBuilder.addChild(currentThread, event); return register; @@ -414,8 +416,9 @@ public Expression visitReCmpXchg(LitmusCParser.ReCmpXchgContext ctx){ @Override public Expression visitReC11LoadExplicit(LitmusCParser.ReC11LoadExplicitContext ctx) { Register register = getReturnRegister(true); - AtomicLoad event = EventFactory.Atomic.newLoad(register, getAddress(ctx.address), ctx.c11Mo().mo); - addOpenCLMemorySpaceTag(event, ctx.address.getText()); + Expression address = getAddress(ctx.address); + AtomicLoad event = EventFactory.Atomic.newLoad(register, address, ctx.c11Mo().mo); + addOpenCLMemorySpaceTag(event, address); if (ctx.openCLScope() != null) { event.addTags(ctx.openCLScope().scope); } else { @@ -427,8 +430,9 @@ public Expression visitReCmpXchg(LitmusCParser.ReCmpXchgContext ctx){ @Override public Expression visitReC11Load(LitmusCParser.ReC11LoadContext ctx) { Register register = getReturnRegister(true); - AtomicLoad event = EventFactory.Atomic.newLoad(register, getAddress(ctx.address), C11.MO_SC); // default memory_order for OpenCL - addOpenCLMemorySpaceTag(event, ctx.address.getText()); + Expression address = getAddress(ctx.address); + AtomicLoad event = EventFactory.Atomic.newLoad(register, address, C11.MO_SC); // default memory_order for OpenCL + addOpenCLMemorySpaceTag(event, address); event.addTags(Tag.GPU_SCOPES.DEVICE); // default memory_scope for OpenCL programBuilder.addChild(currentThread, event); return register; @@ -453,8 +457,9 @@ public Expression visitReReadOnce(LitmusCParser.ReReadOnceContext ctx){ @Override public Expression visitReReadNa(LitmusCParser.ReReadNaContext ctx){ Register register = getReturnRegister(true); - Load event = EventFactory.newLoadWithMo(register, getAddress(ctx.address), C11.NONATOMIC); - addOpenCLMemorySpaceTag(event, ctx.address.getText()); + Expression address = getAddress(ctx.address); + Load event = EventFactory.newLoadWithMo(register, address, C11.NONATOMIC); + addOpenCLMemorySpaceTag(event, address); programBuilder.addChild(currentThread, event); return register; } @@ -567,8 +572,9 @@ public Object visitNreWriteOnce(LitmusCParser.NreWriteOnceContext ctx){ @Override public Object visitNreC11StoreExplicit(LitmusCParser.NreC11StoreExplicitContext ctx) { Expression value = (Expression)ctx.value.accept(this); - AtomicStore event = EventFactory.Atomic.newStore(getAddress(ctx.address), value, ctx.c11Mo().mo); - addOpenCLMemorySpaceTag(event, ctx.address.getText()); + Expression address = getAddress(ctx.address); + AtomicStore event = EventFactory.Atomic.newStore(address, value, ctx.c11Mo().mo); + addOpenCLMemorySpaceTag(event, address); if (ctx.openCLScope() != null) { event.addTags(ctx.openCLScope().scope); } else { @@ -580,8 +586,9 @@ public Object visitNreC11StoreExplicit(LitmusCParser.NreC11StoreExplicitContext @Override public Object visitNreC11Store(LitmusCParser.NreC11StoreContext ctx) { Expression value = (Expression)ctx.value.accept(this); - AtomicStore event = EventFactory.Atomic.newStore(getAddress(ctx.address), value, C11.MO_SC); // default memory_order for OpenCL - addOpenCLMemorySpaceTag(event, ctx.address.getText()); + Expression address = getAddress(ctx.address); + AtomicStore event = EventFactory.Atomic.newStore(address, value, C11.MO_SC); // default memory_order for OpenCL + addOpenCLMemorySpaceTag(event, address); event.addTags(Tag.GPU_SCOPES.DEVICE); // default memory_scope for OpenCL return programBuilder.addChild(currentThread, event); } @@ -602,7 +609,7 @@ public Object visitNreAssignment(LitmusCParser.NreAssignmentContext ctx){ if(variable instanceof MemoryObject || variable instanceof Register){ Event event = EventFactory.newStoreWithMo(variable, value, C11.NONATOMIC); if (variable instanceof Register reg) { - addOpenCLMemorySpaceTag(event, reg.getName()); + addOpenCLMemorySpaceTag(event, reg); event.addTags(Tag.GPU_SCOPES.WORK_ITEM); // default memory_scope for OpenCL weak access } return programBuilder.addChild(currentThread, event); @@ -728,10 +735,19 @@ private Expression assignToReturnRegister(Register register, Expression value) { return value; } - private void addOpenCLMemorySpaceTag(Event event, String addressString) { - String space = programBuilder.getAddressSpace(currentThread, addressString); - if (space != null) { - event.addTags(space); + private void addOpenCLMemorySpaceTag(Event event, Expression address) { + if (address instanceof Register reg) { + MemoryObject object = programBuilder.getLocFromReg(reg); + if (object != null) { + event.addTags(object.getMemorySpace()); + if (!object.isAtomic()) { + event.addTags(Tag.OpenCL.NON_ATOMIC_LOCATION); + } + } + } else if (address instanceof BinaryExpressionBase binExpr) { + // TODO: Convert memory space tags for binary expressions + addOpenCLMemorySpaceTag(event, binExpr.getLeft()); + addOpenCLMemorySpaceTag(event, binExpr.getRight()); } } } 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 e9c597b26d..0889ed9043 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 @@ -378,9 +378,11 @@ public static String storeMO(String mo) { // ========================================= OpenCL ============================================ // ============================================================================================= public static final class OpenCL { + public static final String NON_ATOMIC_LOCATION = "NAL"; // Space public static final String GLOBAL_SPACE = "GLOBAL"; public static final String LOCAL_SPACE = "LOCAL"; + public static final String GENERIC_SPACE = "GENERIC"; // Barrier public static final String ENTRY_FENCE = "EF"; public static final String EXIT_FENCE = "XF"; diff --git a/dartagnan/src/main/java/com/dat3m/dartagnan/program/event/arch/opencl/OpenCLInit.java b/dartagnan/src/main/java/com/dat3m/dartagnan/program/event/arch/opencl/OpenCLInit.java index 47b149210e..1ad98ffc76 100644 --- a/dartagnan/src/main/java/com/dat3m/dartagnan/program/event/arch/opencl/OpenCLInit.java +++ b/dartagnan/src/main/java/com/dat3m/dartagnan/program/event/arch/opencl/OpenCLInit.java @@ -10,8 +10,9 @@ public OpenCLInit(MemoryObject b, int o, Expression address) { super(b, o, address); if (b.getMemorySpace() != null) { addTags(b.getMemorySpace()); - if (b.isAtomic()) { - addTags(Tag.C11.ATOMIC); + addTags(Tag.C11.NONATOMIC); // Every initial event is a nonatomic write of zero + if (!b.isAtomic()) { + addTags(Tag.OpenCL.NON_ATOMIC_LOCATION); } } } From 70492020a600f5cecf6af4a4e1055804e5a81534 Mon Sep 17 00:00:00 2001 From: Haining Date: Sat, 14 Sep 2024 16:53:24 +0300 Subject: [PATCH 03/23] add default tags --- .../program/visitors/VisitorLitmusC.java | 40 ++++++++++--------- .../dat3m/dartagnan/program/event/Tag.java | 9 +++++ 2 files changed, 30 insertions(+), 19 deletions(-) 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 9ed5d01b9e..7acd1fcca2 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 @@ -208,12 +208,10 @@ public Object visitThreadArgument(LitmusCParser.ThreadArgumentContext ctx) { if (ctx.openCLSpace() != null) { object.setMemorySpace(ctx.openCLSpace().space); } else { - // Using GENERIC_SPACE as default memory space for OpenCL threads - object.setMemorySpace(Tag.OpenCL.GENERIC_SPACE); + object.setMemorySpace(Tag.OpenCL.DEFAULT_GPU_SPACE); } } else { - // Using GLOBAL_SPACE as default memory space for CPU threads - object.setMemorySpace(Tag.OpenCL.GLOBAL_SPACE); + object.setMemorySpace(Tag.OpenCL.DEFAULT_CPU_SPACE); } programBuilder.setReg2LocMap(register, object); programBuilder.addChild(currentThread, EventFactory.newLocal(register, object)); @@ -298,7 +296,7 @@ public Expression visitC11AtomicOp(LitmusCParser.C11AtomicOpContext ctx) { if (ctx.openCLScope() != null) { event.addTags(ctx.openCLScope().scope); } else { - event.addTags(Tag.GPU_SCOPES.DEVICE); // default memory_scope for OpenCL + event.addTags(Tag.OpenCL.DEFAULT_SCOPE); } programBuilder.addChild(currentThread, event); return register; @@ -354,7 +352,7 @@ public Expression visitReC11SCmpXchgExplicit(LitmusCParser.ReC11SCmpXchgExplicit if (ctx.openCLScope() != null) { event.addTags(ctx.openCLScope().scope); } else { - event.addTags(Tag.GPU_SCOPES.DEVICE); // default memory_scope for OpenCL + event.addTags(Tag.OpenCL.DEFAULT_SCOPE); } programBuilder.addChild(currentThread, event); return register; @@ -366,9 +364,10 @@ public Expression visitReC11SCmpXchg(LitmusCParser.ReC11SCmpXchgContext ctx) { Expression value = (Expression)ctx.value.accept(this); Expression address = getAddress(ctx.address); Expression expectedAdd = getAddress(ctx.expectedAdd); - Event event = EventFactory.Atomic.newCompareExchange(register, address, expectedAdd, value, C11.MO_SC, true); // default memory_order for OpenCL + Event event = EventFactory.Atomic.newCompareExchange(register, address, expectedAdd, value, + Tag.OpenCL.DEFAULT_MO, true); addOpenCLMemorySpaceTag(event, address); - event.addTags(Tag.GPU_SCOPES.DEVICE); // default memory_scope for OpenCL + event.addTags(Tag.OpenCL.DEFAULT_SCOPE); programBuilder.addChild(currentThread, event); return register; } @@ -385,7 +384,7 @@ public Expression visitReC11WCmpXchgExplicit(LitmusCParser.ReC11WCmpXchgExplicit if (ctx.openCLScope() != null) { event.addTags(ctx.openCLScope().scope); } else { - event.addTags(Tag.GPU_SCOPES.DEVICE); // default memory_scope for OpenCL + event.addTags(Tag.OpenCL.DEFAULT_SCOPE); } programBuilder.addChild(currentThread, event); return register; @@ -397,9 +396,10 @@ public Expression visitReC11WCmpXchg(LitmusCParser.ReC11WCmpXchgContext ctx) { Expression value = (Expression)ctx.value.accept(this); Expression address = getAddress(ctx.address); Expression expectedAdd = getAddress(ctx.expectedAdd); - Event event = EventFactory.Atomic.newCompareExchange(register, address, expectedAdd, value, C11.MO_SC, false); // default memory_order for OpenCL + Event event = EventFactory.Atomic.newCompareExchange(register, address, expectedAdd, value, + Tag.OpenCL.DEFAULT_MO, false); addOpenCLMemorySpaceTag(event, address); - event.addTags(Tag.GPU_SCOPES.DEVICE); // default memory_scope for OpenCL + event.addTags(Tag.OpenCL.DEFAULT_SCOPE); programBuilder.addChild(currentThread, event); return register; } @@ -422,7 +422,7 @@ public Expression visitReCmpXchg(LitmusCParser.ReCmpXchgContext ctx){ if (ctx.openCLScope() != null) { event.addTags(ctx.openCLScope().scope); } else { - event.addTags(Tag.GPU_SCOPES.DEVICE); // default memory_scope for OpenCL + event.addTags(Tag.OpenCL.DEFAULT_SCOPE); } programBuilder.addChild(currentThread, event); return register; @@ -431,9 +431,9 @@ public Expression visitReCmpXchg(LitmusCParser.ReCmpXchgContext ctx){ @Override public Expression visitReC11Load(LitmusCParser.ReC11LoadContext ctx) { Register register = getReturnRegister(true); Expression address = getAddress(ctx.address); - AtomicLoad event = EventFactory.Atomic.newLoad(register, address, C11.MO_SC); // default memory_order for OpenCL + AtomicLoad event = EventFactory.Atomic.newLoad(register, address, Tag.OpenCL.DEFAULT_MO); addOpenCLMemorySpaceTag(event, address); - event.addTags(Tag.GPU_SCOPES.DEVICE); // default memory_scope for OpenCL + event.addTags(Tag.OpenCL.DEFAULT_SCOPE); programBuilder.addChild(currentThread, event); return register; } @@ -578,7 +578,7 @@ public Object visitNreC11StoreExplicit(LitmusCParser.NreC11StoreExplicitContext if (ctx.openCLScope() != null) { event.addTags(ctx.openCLScope().scope); } else { - event.addTags(Tag.GPU_SCOPES.DEVICE); // default memory_scope for OpenCL + event.addTags(Tag.OpenCL.DEFAULT_SCOPE); } return programBuilder.addChild(currentThread, event); } @@ -587,9 +587,9 @@ public Object visitNreC11StoreExplicit(LitmusCParser.NreC11StoreExplicitContext public Object visitNreC11Store(LitmusCParser.NreC11StoreContext ctx) { Expression value = (Expression)ctx.value.accept(this); Expression address = getAddress(ctx.address); - AtomicStore event = EventFactory.Atomic.newStore(address, value, C11.MO_SC); // default memory_order for OpenCL + AtomicStore event = EventFactory.Atomic.newStore(address, value, Tag.OpenCL.DEFAULT_MO); addOpenCLMemorySpaceTag(event, address); - event.addTags(Tag.GPU_SCOPES.DEVICE); // default memory_scope for OpenCL + event.addTags(Tag.OpenCL.DEFAULT_SCOPE); return programBuilder.addChild(currentThread, event); } @@ -610,7 +610,7 @@ public Object visitNreAssignment(LitmusCParser.NreAssignmentContext ctx){ Event event = EventFactory.newStoreWithMo(variable, value, C11.NONATOMIC); if (variable instanceof Register reg) { addOpenCLMemorySpaceTag(event, reg); - event.addTags(Tag.GPU_SCOPES.WORK_ITEM); // default memory_scope for OpenCL weak access + event.addTags(Tag.OpenCL.DEFAULT_WEAK_SCOPE); } return programBuilder.addChild(currentThread, event); } @@ -633,7 +633,9 @@ 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); + fence.addTags(Tag.OpenCL.DEFAULT_SCOPE, Tag.OpenCL.DEFAULT_CPU_SPACE); + return programBuilder.addChild(currentThread, fence); } @Override 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 0889ed9043..dbebbeb75f 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 @@ -378,6 +378,7 @@ public static String storeMO(String mo) { // ========================================= OpenCL ============================================ // ============================================================================================= public static final class OpenCL { + // Atomicity of location public static final String NON_ATOMIC_LOCATION = "NAL"; // Space public static final String GLOBAL_SPACE = "GLOBAL"; @@ -387,6 +388,14 @@ public static final class OpenCL { public static final String ENTRY_FENCE = "EF"; public static final String EXIT_FENCE = "XF"; + // Default Tags + public static final String DEFAULT_SCOPE = GPU_SCOPES.DEVICE; + public static final String DEFAULT_WEAK_SCOPE = GPU_SCOPES.WORK_ITEM; + public static final String DEFAULT_MO = C11.MO_SC; + public static final String DEFAULT_CPU_SPACE = GLOBAL_SPACE; + public static final String DEFAULT_GPU_SPACE = GENERIC_SPACE; + + public static List getScopeTags() { return List.of(GPU_SCOPES.WORK_GROUP, GPU_SCOPES.DEVICE, GPU_SCOPES.ALL); } From 8cd51edc71c9304535459c785b12a10ac2129dbf Mon Sep 17 00:00:00 2001 From: Haining Date: Sun, 15 Sep 2024 15:20:51 +0300 Subject: [PATCH 04/23] update tag --- cat/opencl.cat | 2 +- .../dat3m/dartagnan/program/event/Tag.java | 2 +- .../processing/compilation/VisitorOpenCL.java | 34 +++++++++++-------- 3 files changed, 21 insertions(+), 17 deletions(-) diff --git a/cat/opencl.cat b/cat/opencl.cat index 69cb707a16..0e79ea63d3 100644 --- a/cat/opencl.cat +++ b/cat/opencl.cat @@ -134,7 +134,7 @@ acyclic scp_prime & sc_existance as s_exists (* Races *) (***************) -let conflict = (((W * _) | (_ * W)) \ ((IW * _) | (_ * IW))) & loc +let conflict = ((W * _) | (_ * W)) & loc let gl_hb = ghb | lhb let dr = conflict & ~(gl_hb | gl_hb^-1) & ~incl \ id 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 dbebbeb75f..7855cb82b4 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 @@ -401,7 +401,7 @@ public static List getScopeTags() { } public static List getSpaceTags() { - return List.of(GLOBAL_SPACE, LOCAL_SPACE); + return List.of(GLOBAL_SPACE, LOCAL_SPACE, GENERIC_SPACE); } public static List getSpaceTags(Event e) { diff --git a/dartagnan/src/main/java/com/dat3m/dartagnan/program/processing/compilation/VisitorOpenCL.java b/dartagnan/src/main/java/com/dat3m/dartagnan/program/processing/compilation/VisitorOpenCL.java index d4ef645a5b..8a5efb3770 100644 --- a/dartagnan/src/main/java/com/dat3m/dartagnan/program/processing/compilation/VisitorOpenCL.java +++ b/dartagnan/src/main/java/com/dat3m/dartagnan/program/processing/compilation/VisitorOpenCL.java @@ -97,24 +97,28 @@ public List visitAtomicThreadFence(AtomicThreadFence e) { } private List tagList(Event originalEvent, List in) { - in.forEach(this::tagEvent); - String scope = Tag.getScopeTag(originalEvent, Arch.OPENCL); - if (!scope.isEmpty()) { - in.forEach(e -> e.addTags(scope)); - } - List spaces = Tag.OpenCL.getSpaceTags(originalEvent); - if (!spaces.isEmpty()) { - in.forEach(e -> e.addTags(spaces)); - } - + in.forEach(e -> tagEvent(originalEvent, e)); return in; } - private void tagEvent(Event e) { - if (e instanceof MemoryEvent) { - final MemoryOrder mo = e.getMetadata(MemoryOrder.class); - final boolean canRace = mo == null || mo.value().equals(C11.NONATOMIC); - e.addTags(canRace ? C11.NONATOMIC : C11.ATOMIC); + private void tagEvent(Event originalEvent, Event e) { + 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); + } + if (!spaces.isEmpty()) { + e.addTags(spaces); + } + if (e instanceof MemoryEvent) { + final MemoryOrder mo = e.getMetadata(MemoryOrder.class); + final boolean canRace = mo == null || mo.value().equals(C11.NONATOMIC); + e.addTags(canRace ? C11.NONATOMIC : C11.ATOMIC); + if (e.hasTag(Tag.OpenCL.NON_ATOMIC_LOCATION)) { + e.addTags(Tag.OpenCL.NON_ATOMIC_LOCATION); + } + } } } } From d2160eb1b1e549bac0c106bef6a642f45f2357b8 Mon Sep 17 00:00:00 2001 From: haining Date: Tue, 17 Sep 2024 19:40:29 +0300 Subject: [PATCH 05/23] add overhauling models --- cat/opencl-overhauling-scopedsc.cat | 126 +++++++++++++++++ cat/opencl-overhauling.cat | 127 ++++++++++++++++++ .../com/dat3m/dartagnan/wmm/axiom/Axiom.java | 12 -- 3 files changed, 253 insertions(+), 12 deletions(-) create mode 100644 cat/opencl-overhauling-scopedsc.cat create mode 100644 cat/opencl-overhauling.cat diff --git a/cat/opencl-overhauling-scopedsc.cat b/cat/opencl-overhauling-scopedsc.cat new file mode 100644 index 0000000000..c885769ccb --- /dev/null +++ b/cat/opencl-overhauling-scopedsc.cat @@ -0,0 +1,126 @@ +OpenCL +(* OpenCL Memory Model *) + +(* +* 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 = ~0 + +(* Inclusive scopes *) +let incl = (int & (WI * WI)) | + (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 = int | (unv; [R & W]) +let rs = mo & rs_prime & ~((mo & ~rs_prime) ; mo) + +(* Release-acquire synchronisation *) +let ra_sw_g = ([GLOBAL & Rel]; Fsb?; [W \ WI]; rs?; [GLOBAL]; rf; [R \ WI]; sbF?; [Acq & GLOBAL]) & incl & ~int +let ra_sw_l = ([LOCAL & Rel]; Fsb?; [W \ WI]; rs?; [LOCAL]; rf; [R \ WI]; sbF?; [Acq & LOCAL]) & incl & ~int + +(* 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_g = (EF * XF) & syncbar & ~int & swg & (GLOBAL * GLOBAL) +let bar_sw_l = (EF * XF) & syncbar & ~int & swg & (LOCAL * LOCAL) + +(* 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_g | bar_sw_g | (scf & ra_sw_l) +let lsw = ra_sw_l | bar_sw_l | (scf & ra_sw_g) + +(******************) +(* 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 global_hb_acyclic +irreflexive lhb as local_hb_acyclic + +(*************) +(* Coherence *) +(*************) + +let coh_hb_g = (rf^-1)?; mo; rf?; ghb +let coh_hb_l = (rf^-1)?; mo; rf?; lhb +irreflexive coh_hb_g as global_coherence +irreflexive coh_hb_l as local_coherence + +(************************) +(* 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 vse_ghb = (W * R) & ghb & loc & ~((ghb & loc); [W]; ghb) +let vse_lhb = (W * R) & lhb & loc & ~((lhb & loc); [W]; lhb) + +(* A non-atomic load can only read from a store that is visible. *) +empty (rf; [NAL & GLOBAL]) \ vse_ghb as O-NaRfG +empty (rf; [NAL & LOCAL]) \ vse_lhb as O-NaRfL + +(* Consistency of RMWs *) +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 conflict = ((W * _) | (_ * W)) & loc + +let gl_hb = ghb | lhb +let dr = conflict & ~(gl_hb) & ~(gl_hb)^-1 & ~int & ~incl +flag ~empty dr as data_race + +(* Barrier divergence *) +let bsw = bar_sw_g | bar_sw_l +let bd = [EF] & ((~int & swg);unv) \ (bsw;unv) +flag ~empty bd as barrier_divergence \ No newline at end of file diff --git a/cat/opencl-overhauling.cat b/cat/opencl-overhauling.cat new file mode 100644 index 0000000000..cd7de31f62 --- /dev/null +++ b/cat/opencl-overhauling.cat @@ -0,0 +1,127 @@ +OpenCL +(* OpenCL Memory Model *) + +(* +* This model is based on: +* https://multicore.doc.ic.ac.uk/overhauling/opencl_base.cat +* https://multicore.doc.ic.ac.uk/overhauling/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 + +let mo = co & ((~NAL) * (~NAL)) +let sb = po +let rb = (rf^-1; mo) \ id +let unv = ~0 + +(* Inclusive scopes *) +let incl = (int & (WI * WI)) | + (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 = int | (unv; [R & W]) +let rs = mo & rs_prime & ~((mo & ~rs_prime) ; mo) + +(* Release-acquire synchronisation *) +let ra_sw_g = ([GLOBAL & Rel]; Fsb?; [W \ WI]; rs?; [GLOBAL]; rf; [R \ WI]; sbF?; [Acq & GLOBAL]) & incl & ~int +let ra_sw_l = ([LOCAL & Rel]; Fsb?; [W \ WI]; rs?; [LOCAL]; rf; [R \ WI]; sbF?; [Acq & LOCAL]) & incl & ~int + +(* 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_g = (EF * XF) & syncbar & ~int & swg & (GLOBAL * GLOBAL) +let bar_sw_l = (EF * XF) & syncbar & ~int & swg & (LOCAL * LOCAL) + +(* 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_g | bar_sw_g | (scf & ra_sw_l) +let lsw = ra_sw_l | bar_sw_l | (scf & ra_sw_g) + +(******************) +(* 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 global_hb_acyclic +irreflexive lhb as local_hb_acyclic + +(*************) +(* Coherence *) +(*************) + +let coh_hb_g = (rf^-1)?; mo; rf?; ghb +let coh_hb_l = (rf^-1)?; mo; rf?; lhb +irreflexive coh_hb_g as global_coherence +irreflexive coh_hb_l as local_coherence + +(************************) +(* 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 vse_ghb = (W * R) & ghb & loc & ~((ghb & loc); [W]; ghb) +let vse_lhb = (W * R) & lhb & loc & ~((lhb & loc); [W]; lhb) + +(* A non-atomic load can only read from a store that is visible. *) +empty (rf; [NAL & GLOBAL]) \ vse_ghb as O-NaRfG +empty (rf; [NAL & LOCAL]) \ vse_lhb as O-NaRfL + +(* Consistency of RMWs *) +irreflexive rf | (mo;mo;rf^-1) | (mo;rf) as O-Rmw + +(**************************************) +(* Sequential consistency, simplified *) +(**************************************) +let scp = Fsb?; (rb | mo | (ghb | lhb)); sbF? +let S_cond1 = ~(unv; [SC \ ALL]; unv) +let S_cond2 = ~(unv; [SC \ DV]; unv) +acyclic (SC*SC) & scp & (S_cond1|S_cond2) as O-Ssimp + +(***************) +(* Races *) +(***************) + +let conflict = ((W * _) | (_ * W)) & loc + +let gl_hb = ghb | lhb +let dr = conflict & ~(gl_hb) & ~(gl_hb)^-1 & ~int & ~incl +flag ~empty dr as data_race + +(* Barrier divergence *) +let bsw = bar_sw_g | bar_sw_l +let bd = [EF] & ((~int & swg);unv) \ (bsw;unv) +flag ~empty bd as barrier_divergence \ No newline at end of file diff --git a/dartagnan/src/main/java/com/dat3m/dartagnan/wmm/axiom/Axiom.java b/dartagnan/src/main/java/com/dat3m/dartagnan/wmm/axiom/Axiom.java index ae80360ec4..ca6ae71730 100755 --- a/dartagnan/src/main/java/com/dat3m/dartagnan/wmm/axiom/Axiom.java +++ b/dartagnan/src/main/java/com/dat3m/dartagnan/wmm/axiom/Axiom.java @@ -105,16 +105,4 @@ public boolean isAcyclicity() { public boolean isIrreflexivity() { return this instanceof Irreflexivity; } - - public Axiom copy(Relation rel) { - if(isEmptiness()) { - return new Emptiness(rel, negated, flag); - } else if(isAcyclicity()) { - return new Acyclicity(rel, negated, flag); - } else if(isIrreflexivity()) { - return new Irreflexivity(rel, negated, flag); - } else { - throw new UnsupportedOperationException("Unsupported axiom type"); - } - } } \ No newline at end of file From 4cf481ac07e228c86387a906c34cae7d6bd544fa Mon Sep 17 00:00:00 2001 From: haining Date: Wed, 18 Sep 2024 22:32:04 +0300 Subject: [PATCH 06/23] update opencl models --- cat/opencl-overhauling-scopedsc.cat | 47 ++++++++++++----------------- cat/opencl-overhauling.cat | 45 ++++++++++++--------------- cat/opencl.cat | 47 +++++++++++++++-------------- 3 files changed, 63 insertions(+), 76 deletions(-) diff --git a/cat/opencl-overhauling-scopedsc.cat b/cat/opencl-overhauling-scopedsc.cat index c885769ccb..39bc43c63d 100644 --- a/cat/opencl-overhauling-scopedsc.cat +++ b/cat/opencl-overhauling-scopedsc.cat @@ -4,7 +4,7 @@ OpenCL (* * 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 +* https://multicore.doc.ic.ac.uk/overhauling/opencl.cat *) // Base relations: @@ -27,12 +27,10 @@ let mo = co & ((~NAL) * (~NAL)) let sb = po let rb = (rf^-1; mo) \ id let unv = ~0 +let wi = int (* Inclusive scopes *) -let incl = (int & (WI * WI)) | - (swg & (WG * WG)) | - (sdv & (DV * DV)) | - (ALL * ALL) +let incl = (swg & (WG * WG)) | (sdv & (DV * DV)) | (ALL * ALL) (*******************) (* Synchronisation *) @@ -46,25 +44,23 @@ let Fsb = [F]; sb let sbF = sb; [F] (* Release sequence *) -let rs_prime = int | (unv; [R & W]) +let rs_prime = wi | (unv; [R & W]) let rs = mo & rs_prime & ~((mo & ~rs_prime) ; mo) (* Release-acquire synchronisation *) -let ra_sw_g = ([GLOBAL & Rel]; Fsb?; [W \ WI]; rs?; [GLOBAL]; rf; [R \ WI]; sbF?; [Acq & GLOBAL]) & incl & ~int -let ra_sw_l = ([LOCAL & Rel]; Fsb?; [W \ WI]; rs?; [LOCAL]; rf; [R \ WI]; sbF?; [Acq & LOCAL]) & incl & ~int +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_g = (EF * XF) & syncbar & ~int & swg & (GLOBAL * GLOBAL) -let bar_sw_l = (EF * XF) & syncbar & ~int & swg & (LOCAL * LOCAL) +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_g | bar_sw_g | (scf & ra_sw_l) -let lsw = ra_sw_l | bar_sw_l | (scf & ra_sw_g) +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 *) @@ -73,17 +69,16 @@ let lsw = ra_sw_l | bar_sw_l | (scf & ra_sw_g) (* Global and local happens-before *) let ghb = (((GLOBAL * GLOBAL) & (sb | (IW * ~IW))) | gsw)+ let lhb = (((LOCAL * LOCAL) & (sb | (IW * ~IW))) | lsw)+ -irreflexive ghb as global_hb_acyclic -irreflexive lhb as local_hb_acyclic +irreflexive ghb as O-HbG +irreflexive lhb as O-HbL (*************) (* Coherence *) (*************) -let coh_hb_g = (rf^-1)?; mo; rf?; ghb -let coh_hb_l = (rf^-1)?; mo; rf?; lhb -irreflexive coh_hb_g as global_coherence -irreflexive coh_hb_l as local_coherence +let coh(hb) = (rf^-1)?; mo; rf?; hb +irreflexive coh(ghb) as O-CohG +irreflexive coh(lhb) as O-CohL (************************) (* Consistency of reads *) @@ -93,12 +88,11 @@ irreflexive coh_hb_l as local_coherence irreflexive rf; (ghb | lhb) as O-Rf (* Visible side effects *) -let vse_ghb = (W * R) & ghb & loc & ~((ghb & loc); [W]; ghb) -let vse_lhb = (W * R) & lhb & loc & ~((lhb & loc); [W]; lhb) +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]) \ vse_ghb as O-NaRfG -empty (rf; [NAL & LOCAL]) \ vse_lhb as O-NaRfL +empty (rf; [NAL & GLOBAL])\vis(ghb) as O-NaRfG +empty (rf; [NAL & LOCAL])\vis(lhb) as O-NaRfL (* Consistency of RMWs *) irreflexive rf | (mo;mo;rf^-1) | (mo;rf) as O-Rmw @@ -114,13 +108,12 @@ acyclic (SC*SC) & scp & incl as O-Sscoped (* Races *) (***************) -let conflict = ((W * _) | (_ * W)) & loc +let cnf = ((W * W) | (W * R) | (R * W)) & loc -let gl_hb = ghb | lhb -let dr = conflict & ~(gl_hb) & ~(gl_hb)^-1 & ~int & ~incl +let dr = cnf & ~(ghb | lhb) & ~(ghb | lhb)^-1 & ~wi & ~incl flag ~empty dr as data_race (* Barrier divergence *) -let bsw = bar_sw_g | bar_sw_l -let bd = [EF] & ((~int & swg);unv) \ (bsw;unv) +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-overhauling.cat b/cat/opencl-overhauling.cat index cd7de31f62..4b0b604ed1 100644 --- a/cat/opencl-overhauling.cat +++ b/cat/opencl-overhauling.cat @@ -27,12 +27,10 @@ let mo = co & ((~NAL) * (~NAL)) let sb = po let rb = (rf^-1; mo) \ id let unv = ~0 +let wi = int (* Inclusive scopes *) -let incl = (int & (WI * WI)) | - (swg & (WG * WG)) | - (sdv & (DV * DV)) | - (ALL * ALL) +let incl = (swg & (WG * WG)) | (sdv & (DV * DV)) | (ALL * ALL) (*******************) (* Synchronisation *) @@ -46,25 +44,23 @@ let Fsb = [F]; sb let sbF = sb; [F] (* Release sequence *) -let rs_prime = int | (unv; [R & W]) +let rs_prime = wi | (unv; [R & W]) let rs = mo & rs_prime & ~((mo & ~rs_prime) ; mo) (* Release-acquire synchronisation *) -let ra_sw_g = ([GLOBAL & Rel]; Fsb?; [W \ WI]; rs?; [GLOBAL]; rf; [R \ WI]; sbF?; [Acq & GLOBAL]) & incl & ~int -let ra_sw_l = ([LOCAL & Rel]; Fsb?; [W \ WI]; rs?; [LOCAL]; rf; [R \ WI]; sbF?; [Acq & LOCAL]) & incl & ~int +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_g = (EF * XF) & syncbar & ~int & swg & (GLOBAL * GLOBAL) -let bar_sw_l = (EF * XF) & syncbar & ~int & swg & (LOCAL * LOCAL) +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_g | bar_sw_g | (scf & ra_sw_l) -let lsw = ra_sw_l | bar_sw_l | (scf & ra_sw_g) +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 *) @@ -73,17 +69,16 @@ let lsw = ra_sw_l | bar_sw_l | (scf & ra_sw_g) (* Global and local happens-before *) let ghb = (((GLOBAL * GLOBAL) & (sb | (IW * ~IW))) | gsw)+ let lhb = (((LOCAL * LOCAL) & (sb | (IW * ~IW))) | lsw)+ -irreflexive ghb as global_hb_acyclic -irreflexive lhb as local_hb_acyclic +irreflexive ghb as O-HbG +irreflexive lhb as O-HbL (*************) (* Coherence *) (*************) -let coh_hb_g = (rf^-1)?; mo; rf?; ghb -let coh_hb_l = (rf^-1)?; mo; rf?; lhb -irreflexive coh_hb_g as global_coherence -irreflexive coh_hb_l as local_coherence +let coh(hb) = (rf^-1)?; mo; rf?; hb +irreflexive coh(ghb) as O-CohG +irreflexive coh(lhb) as O-CohL (************************) (* Consistency of reads *) @@ -93,12 +88,11 @@ irreflexive coh_hb_l as local_coherence irreflexive rf; (ghb | lhb) as O-Rf (* Visible side effects *) -let vse_ghb = (W * R) & ghb & loc & ~((ghb & loc); [W]; ghb) -let vse_lhb = (W * R) & lhb & loc & ~((lhb & loc); [W]; lhb) +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]) \ vse_ghb as O-NaRfG -empty (rf; [NAL & LOCAL]) \ vse_lhb as O-NaRfL +empty (rf; [NAL & GLOBAL])\vis(ghb) as O-NaRfG +empty (rf; [NAL & LOCAL])\vis(lhb) as O-NaRfL (* Consistency of RMWs *) irreflexive rf | (mo;mo;rf^-1) | (mo;rf) as O-Rmw @@ -115,13 +109,12 @@ acyclic (SC*SC) & scp & (S_cond1|S_cond2) as O-Ssimp (* Races *) (***************) -let conflict = ((W * _) | (_ * W)) & loc +let cnf = ((W * W) | (W * R) | (R * W)) & loc -let gl_hb = ghb | lhb -let dr = conflict & ~(gl_hb) & ~(gl_hb)^-1 & ~int & ~incl +let dr = cnf & ~(ghb | lhb) & ~(ghb | lhb)^-1 & ~wi & ~incl flag ~empty dr as data_race (* Barrier divergence *) -let bsw = bar_sw_g | bar_sw_l -let bd = [EF] & ((~int & swg);unv) \ (bsw;unv) +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 index 0e79ea63d3..2197f16268 100644 --- a/cat/opencl.cat +++ b/cat/opencl.cat @@ -23,8 +23,13 @@ OpenCL // 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 = (int & (WI * WI)) | +let incl = (wi & (WI * WI)) | (swg & (WG * WG)) | (sdv & (DV * DV)) | (ALL * ALL) @@ -37,7 +42,7 @@ let Acq = (ACQ | SC | ACQ_REL) & (R | F | RMW) let Rel = (REL | SC | ACQ_REL) & (W | F | RMW) (* Release sequence *) -let rs = (_ * RMW) | int +let rs = (_ * RMW) | wi let max_co = co? & rs & ~((co & ~rs) ; co) (* Including release-acquire fences *) @@ -45,25 +50,22 @@ let relf = [Rel]; ([F]; po)?; [A & W] let acqf = [A & R]; (po; [F])?; [Acq] (* Release-acquire synchronisation *) -let ra_sw_g = incl & ~int & ([GLOBAL]; relf; max_co; [GLOBAL]; rf; acqf; [GLOBAL]) -let ra_sw_l = incl & ~int & ([LOCAL]; relf; max_co; [LOCAL]; rf; acqf; [LOCAL]) +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_g = (EF * XF) & syncbar & ~int & swg & (GLOBAL * GLOBAL) -let bar_sw_l = (EF * XF) & syncbar & ~int & swg & (LOCAL * LOCAL) +let bar_sw(r) = (EF * XF) & syncbar & ~wi & swg & (r * r) (* Synchronisation on a region *) -let region_sw_g = ra_sw_g | bar_sw_g -let region_sw_l = ra_sw_l | bar_sw_l +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_g | (scf & region_sw_l) -let lsw = region_sw_l | (scf & region_sw_g) +let gsw = region_sw(GLOBAL) | (scf & region_sw(LOCAL)) +let lsw = region_sw(LOCAL) | (scf & region_sw(GLOBAL)) (******************) (* Happens-before *) @@ -94,10 +96,9 @@ irreflexive coh_hb_l as local_coherence (************************) (* Visible side effects *) -let vse_hbl_g = (W * R) & ghbl & ~(ghbl; [W]; ghbl) -let vse_hbl_l = (W * R) & lhbl & ~(lhbl; [W]; lhbl) -let gvse = [GLOBAL]; vse_hbl_g -let lvse = [LOCAL]; vse_hbl_l +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 @@ -123,27 +124,27 @@ let scp = (SC * SC) & (ghb | lhb | co | sc1 | sc2 | sc3 | sc4 | sc5) let sc6 = rf^-1; (ghb | lhb); [W] +let unv = ~0 +let ifexists(s) = unv; [s]; unv + (* BEGIN PARTIAL SC STUFF *) let scp_prime = scp & sc6 -let unv = ~0 -let sc_existance = unv; [SC & ~ALL]; unv -acyclic scp_prime & sc_existance as s_exists +acyclic scp_prime & ifexists(SC & ~ALL) as s_exists (* END PARTIAL SC STUFF *) (***************) (* Races *) (***************) -let conflict = ((W * _) | (_ * W)) & loc +let conflict = (((W * _) | (_ * W)) \ ((IW * _) | (_ * IW))) & loc let gl_hb = ghb | lhb -let dr = conflict & ~(gl_hb | gl_hb^-1) & ~incl \ id +let dr = conflict & ~symm(ghb | lhb) & ~incl flag ~empty dr as data_race -let ur = (int & conflict & ~(po | po^-1)) \ id +let ur = (wi & conflict & ~symm(po)) \ id flag ~empty ur as unsequenced_race -let bsw = bar_sw_g | bar_sw_l -// let bd = [EF] & ((~int & swg & ~(bar_sw_g | bar_sw_l)); [_]) // opencl_total -let bd = [EF] & (~int & swg) \ bsw +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 From 11de6f932edfb1cb8c1b6041c14d58078248309c Mon Sep 17 00:00:00 2001 From: haining Date: Sun, 22 Sep 2024 23:11:14 +0300 Subject: [PATCH 07/23] add rmw axiom --- cat/opencl-overhauling-scopedsc.cat | 6 +++++- cat/opencl-overhauling.cat | 4 ++++ cat/opencl.cat | 4 ++++ 3 files changed, 13 insertions(+), 1 deletion(-) diff --git a/cat/opencl-overhauling-scopedsc.cat b/cat/opencl-overhauling-scopedsc.cat index 39bc43c63d..1071aacb65 100644 --- a/cat/opencl-overhauling-scopedsc.cat +++ b/cat/opencl-overhauling-scopedsc.cat @@ -1,10 +1,11 @@ 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.cat +* https://multicore.doc.ic.ac.uk/overhauling/opencl_scopedsc.cat *) // Base relations: @@ -97,6 +98,9 @@ empty (rf; [NAL & LOCAL])\vis(lhb) as O-NaRfL (* Consistency of RMWs *) irreflexive rf | (mo;mo;rf^-1) | (mo;rf) as O-Rmw +// Atomicity +empty rmw & (fre; coe) as atomic + (****************************************) (* Sequential consistency, simplified, *) (* with scoped SC axioms *) diff --git a/cat/opencl-overhauling.cat b/cat/opencl-overhauling.cat index 4b0b604ed1..15f67291b0 100644 --- a/cat/opencl-overhauling.cat +++ b/cat/opencl-overhauling.cat @@ -1,5 +1,6 @@ OpenCL (* OpenCL Memory Model *) +include "basic.cat" (* * This model is based on: @@ -97,6 +98,9 @@ empty (rf; [NAL & LOCAL])\vis(lhb) as O-NaRfL (* Consistency of RMWs *) irreflexive rf | (mo;mo;rf^-1) | (mo;rf) as O-Rmw +// Atomicity +empty rmw & (fre; coe) as atomic + (**************************************) (* Sequential consistency, simplified *) (**************************************) diff --git a/cat/opencl.cat b/cat/opencl.cat index 2197f16268..ba0c789668 100644 --- a/cat/opencl.cat +++ b/cat/opencl.cat @@ -1,5 +1,6 @@ OpenCL (* OpenCL Memory Model *) +include "basic.cat" (* * This model is based on: @@ -110,6 +111,9 @@ 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 *) (**************************) From fbfead98cb33fadf4f6d05dd0714f11aabb17fac Mon Sep 17 00:00:00 2001 From: haining Date: Sun, 22 Sep 2024 23:32:20 +0300 Subject: [PATCH 08/23] rename opencl models --- cat/{opencl.cat => opencl-herd-basic.cat} | 43 +----- cat/opencl-herd-partialsc.cat | 48 +++++++ ...pedsc.cat => opencl-overhauling-basic.cat} | 24 +--- cat/opencl-overhauling-partialsc.cat | 31 +++++ cat/opencl-overhauling.cat | 124 ------------------ .../litmus/LitmusOpenClRacesTest.java | 2 +- .../dartagnan/litmus/LitmusOpenClTest.java | 2 +- 7 files changed, 83 insertions(+), 191 deletions(-) rename cat/{opencl.cat => opencl-herd-basic.cat} (73%) create mode 100644 cat/opencl-herd-partialsc.cat rename cat/{opencl-overhauling-scopedsc.cat => opencl-overhauling-basic.cat} (78%) create mode 100644 cat/opencl-overhauling-partialsc.cat delete mode 100644 cat/opencl-overhauling.cat diff --git a/cat/opencl.cat b/cat/opencl-herd-basic.cat similarity index 73% rename from cat/opencl.cat rename to cat/opencl-herd-basic.cat index ba0c789668..0cb483fe21 100644 --- a/cat/opencl.cat +++ b/cat/opencl-herd-basic.cat @@ -1,11 +1,9 @@ OpenCL (* OpenCL Memory Model *) -include "basic.cat" (* * 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: @@ -112,43 +110,4 @@ irreflexive (ghb | lhb); rf; [A] as atomic_rf_consistent 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 = ~0 -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 +empty rmw & (fre; coe) as atomic \ No newline at end of file diff --git a/cat/opencl-herd-partialsc.cat b/cat/opencl-herd-partialsc.cat new file mode 100644 index 0000000000..bc7000a96c --- /dev/null +++ b/cat/opencl-herd-partialsc.cat @@ -0,0 +1,48 @@ +OpenCL +(* OpenCL Memory Model *) + +(* +* This model is based on: +* https://github.com/herd/herdtools7/blob/master/herd-www/cat_includes/opencl.cat +*) + +include "opencl-herd-basic.cat" + +(**************************) +(* 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 = ~0 +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-overhauling-scopedsc.cat b/cat/opencl-overhauling-basic.cat similarity index 78% rename from cat/opencl-overhauling-scopedsc.cat rename to cat/opencl-overhauling-basic.cat index 1071aacb65..93c6d89926 100644 --- a/cat/opencl-overhauling-scopedsc.cat +++ b/cat/opencl-overhauling-basic.cat @@ -5,7 +5,6 @@ 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: @@ -99,25 +98,4 @@ empty (rf; [NAL & LOCAL])\vis(lhb) as O-NaRfL irreflexive rf | (mo;mo;rf^-1) | (mo;rf) as O-Rmw // Atomicity -empty rmw & (fre; coe) as atomic - -(****************************************) -(* 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 +empty rmw & (fre; coe) as atomic \ No newline at end of file diff --git a/cat/opencl-overhauling-partialsc.cat b/cat/opencl-overhauling-partialsc.cat new file mode 100644 index 0000000000..16eb3e3742 --- /dev/null +++ b/cat/opencl-overhauling-partialsc.cat @@ -0,0 +1,31 @@ +OpenCL +(* OpenCL Memory Model *) + +(* +* This model is based on: +* https://multicore.doc.ic.ac.uk/overhauling/opencl_scopedsc.cat +*) + +include "opencl-overhauling-basic.cat" + +(****************************************) +(* 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/cat/opencl-overhauling.cat b/cat/opencl-overhauling.cat deleted file mode 100644 index 15f67291b0..0000000000 --- a/cat/opencl-overhauling.cat +++ /dev/null @@ -1,124 +0,0 @@ -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.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 = ~0 -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 *) -irreflexive rf | (mo;mo;rf^-1) | (mo;rf) as O-Rmw - -// Atomicity -empty rmw & (fre; coe) as atomic - -(**************************************) -(* Sequential consistency, simplified *) -(**************************************) -let scp = Fsb?; (rb | mo | (ghb | lhb)); sbF? -let S_cond1 = ~(unv; [SC \ ALL]; unv) -let S_cond2 = ~(unv; [SC \ DV]; unv) -acyclic (SC*SC) & scp & (S_cond1|S_cond2) as O-Ssimp - -(***************) -(* 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/test/java/com/dat3m/dartagnan/litmus/LitmusOpenClRacesTest.java b/dartagnan/src/test/java/com/dat3m/dartagnan/litmus/LitmusOpenClRacesTest.java index f4a985b6e2..82f9adf98c 100644 --- a/dartagnan/src/test/java/com/dat3m/dartagnan/litmus/LitmusOpenClRacesTest.java +++ b/dartagnan/src/test/java/com/dat3m/dartagnan/litmus/LitmusOpenClRacesTest.java @@ -33,7 +33,7 @@ protected Provider> getPropertyProvider() { @Override protected Provider getWmmProvider() { - return Providers.createWmmFromName(() -> "opencl"); + return Providers.createWmmFromName(() -> "opencl-herd-partialsc"); } public LitmusOpenClRacesTest(String path, Result 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 index ef686b6bb2..75ce638098 100644 --- a/dartagnan/src/test/java/com/dat3m/dartagnan/litmus/LitmusOpenClTest.java +++ b/dartagnan/src/test/java/com/dat3m/dartagnan/litmus/LitmusOpenClTest.java @@ -27,7 +27,7 @@ protected Provider getTargetProvider() { @Override protected Provider getWmmProvider() { - return Providers.createWmmFromName(() -> "opencl"); + return Providers.createWmmFromName(() -> "opencl-herd-partialsc"); } public LitmusOpenClTest(String path, Result expected) { From 9e12f573b1564b5655334f4fb73ccfd69e4222e9 Mon Sep 17 00:00:00 2001 From: Haining Date: Mon, 23 Sep 2024 16:25:03 +0300 Subject: [PATCH 09/23] use overhauling models --- cat/opencl-herd-partialsc.cat | 48 ------------------- ...{opencl-herd-basic.cat => opencl-herd.cat} | 42 +++++++++++++++- cat/opencl-overhauling-partialsc.cat | 31 ------------ ...uling-basic.cat => opencl-overhauling.cat} | 25 +++++++++- .../comparison/C11AndOpenCLTest.java | 2 +- .../litmus/LitmusOpenClRacesTest.java | 2 +- .../dartagnan/litmus/LitmusOpenClTest.java | 2 +- .../src/test/resources/OPENCL-DR-expected.csv | 1 - .../src/test/resources/OPENCL-expected.csv | 10 ++-- litmus/OPENCL/overhauling/example10.litmus | 5 +- litmus/OPENCL/overhauling/example9b.litmus | 1 + 11 files changed, 77 insertions(+), 92 deletions(-) delete mode 100644 cat/opencl-herd-partialsc.cat rename cat/{opencl-herd-basic.cat => opencl-herd.cat} (73%) delete mode 100644 cat/opencl-overhauling-partialsc.cat rename cat/{opencl-overhauling-basic.cat => opencl-overhauling.cat} (78%) diff --git a/cat/opencl-herd-partialsc.cat b/cat/opencl-herd-partialsc.cat deleted file mode 100644 index bc7000a96c..0000000000 --- a/cat/opencl-herd-partialsc.cat +++ /dev/null @@ -1,48 +0,0 @@ -OpenCL -(* OpenCL Memory Model *) - -(* -* This model is based on: -* https://github.com/herd/herdtools7/blob/master/herd-www/cat_includes/opencl.cat -*) - -include "opencl-herd-basic.cat" - -(**************************) -(* 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 = ~0 -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-herd-basic.cat b/cat/opencl-herd.cat similarity index 73% rename from cat/opencl-herd-basic.cat rename to cat/opencl-herd.cat index 0cb483fe21..c21a1bd0cf 100644 --- a/cat/opencl-herd-basic.cat +++ b/cat/opencl-herd.cat @@ -4,6 +4,7 @@ OpenCL (* * 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: @@ -110,4 +111,43 @@ irreflexive (ghb | lhb); rf; [A] as atomic_rf_consistent irreflexive rf | (fr;co) | (co;rf) as rmw_consistent // Atomicity -empty rmw & (fre; coe) as atomic \ No newline at end of file +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 = ~0 +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-overhauling-partialsc.cat b/cat/opencl-overhauling-partialsc.cat deleted file mode 100644 index 16eb3e3742..0000000000 --- a/cat/opencl-overhauling-partialsc.cat +++ /dev/null @@ -1,31 +0,0 @@ -OpenCL -(* OpenCL Memory Model *) - -(* -* This model is based on: -* https://multicore.doc.ic.ac.uk/overhauling/opencl_scopedsc.cat -*) - -include "opencl-overhauling-basic.cat" - -(****************************************) -(* 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/cat/opencl-overhauling-basic.cat b/cat/opencl-overhauling.cat similarity index 78% rename from cat/opencl-overhauling-basic.cat rename to cat/opencl-overhauling.cat index 93c6d89926..85f4e804f8 100644 --- a/cat/opencl-overhauling-basic.cat +++ b/cat/opencl-overhauling.cat @@ -5,6 +5,7 @@ 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: @@ -98,4 +99,26 @@ empty (rf; [NAL & LOCAL])\vis(lhb) as O-NaRfL irreflexive rf | (mo;mo;rf^-1) | (mo;rf) as O-Rmw // Atomicity -empty rmw & (fre; coe) as atomic \ No newline at end of file +empty rmw & (fre; coe) as atomic + +(****************************************) +(* 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/test/java/com/dat3m/dartagnan/comparison/C11AndOpenCLTest.java b/dartagnan/src/test/java/com/dat3m/dartagnan/comparison/C11AndOpenCLTest.java index 98e3522a9e..65502d11f8 100644 --- a/dartagnan/src/test/java/com/dat3m/dartagnan/comparison/C11AndOpenCLTest.java +++ b/dartagnan/src/test/java/com/dat3m/dartagnan/comparison/C11AndOpenCLTest.java @@ -38,6 +38,6 @@ protected Provider getSourceWmmProvider() { @Override protected Provider getTargetWmmProvider() { - return Providers.createWmmFromName(() -> "opencl"); + return Providers.createWmmFromName(() -> "opencl-overhauling"); } } diff --git a/dartagnan/src/test/java/com/dat3m/dartagnan/litmus/LitmusOpenClRacesTest.java b/dartagnan/src/test/java/com/dat3m/dartagnan/litmus/LitmusOpenClRacesTest.java index 82f9adf98c..31e309be0e 100644 --- a/dartagnan/src/test/java/com/dat3m/dartagnan/litmus/LitmusOpenClRacesTest.java +++ b/dartagnan/src/test/java/com/dat3m/dartagnan/litmus/LitmusOpenClRacesTest.java @@ -33,7 +33,7 @@ protected Provider> getPropertyProvider() { @Override protected Provider getWmmProvider() { - return Providers.createWmmFromName(() -> "opencl-herd-partialsc"); + return Providers.createWmmFromName(() -> "opencl-overhauling"); } public LitmusOpenClRacesTest(String path, Result 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 index 75ce638098..9e334150c8 100644 --- a/dartagnan/src/test/java/com/dat3m/dartagnan/litmus/LitmusOpenClTest.java +++ b/dartagnan/src/test/java/com/dat3m/dartagnan/litmus/LitmusOpenClTest.java @@ -27,7 +27,7 @@ protected Provider getTargetProvider() { @Override protected Provider getWmmProvider() { - return Providers.createWmmFromName(() -> "opencl-herd-partialsc"); + return Providers.createWmmFromName(() -> "opencl-overhauling"); } public LitmusOpenClTest(String path, Result expected) { diff --git a/dartagnan/src/test/resources/OPENCL-DR-expected.csv b/dartagnan/src/test/resources/OPENCL-DR-expected.csv index 4e1b72c3f5..90b90623fc 100644 --- a/dartagnan/src/test/resources/OPENCL-DR-expected.csv +++ b/dartagnan/src/test/resources/OPENCL-DR-expected.csv @@ -2,7 +2,6 @@ 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/CT_wsq2.litmus,1 litmus/OPENCL/herd/IRIW.litmus,1 litmus/OPENCL/herd/ISA2.litmus,0 litmus/OPENCL/herd/ISA3.litmus,1 diff --git a/dartagnan/src/test/resources/OPENCL-expected.csv b/dartagnan/src/test/resources/OPENCL-expected.csv index 393d961c24..cbd7987696 100644 --- a/dartagnan/src/test/resources/OPENCL-expected.csv +++ b/dartagnan/src/test/resources/OPENCL-expected.csv @@ -3,7 +3,7 @@ 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,1 +litmus/OPENCL/herd/IRIW.litmus,0 litmus/OPENCL/herd/ISA2.litmus,1 litmus/OPENCL/herd/ISA3.litmus,0 litmus/OPENCL/herd/LB.litmus,1 @@ -28,11 +28,11 @@ 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,1 -litmus/OPENCL/overhauling/example9b.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,1 -litmus/OPENCL/overhauling/IRIW_sc_wg.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 diff --git a/litmus/OPENCL/overhauling/example10.litmus b/litmus/OPENCL/overhauling/example10.litmus index 69c2ff081e..d9707eb1ba 100644 --- a/litmus/OPENCL/overhauling/example10.litmus +++ b/litmus/OPENCL/overhauling/example10.litmus @@ -2,6 +2,7 @@ C example10 (* * https://multicore.doc.ic.ac.uk/overhauling/examples/example10.litmus + * global_fga -> global *) { @@ -23,13 +24,13 @@ P1@wg 0, dev 0 (global atomic_int* x, global atomic_int* y, global atomic_int* z r = atomic_load_explicit(x, memory_order_seq_cst, memory_scope_device); } -P2@wg 1, dev 0 (global atomic_int* x, global atomic_int* y, global atomic_int* z1, global atomic_int* z2) { +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 1, dev 0 (global atomic_int* x, global atomic_int* y, global atomic_int* z1, global atomic_int* z2) { +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); diff --git a/litmus/OPENCL/overhauling/example9b.litmus b/litmus/OPENCL/overhauling/example9b.litmus index 1f2a8dd93d..c4d3093dcc 100644 --- a/litmus/OPENCL/overhauling/example9b.litmus +++ b/litmus/OPENCL/overhauling/example9b.litmus @@ -2,6 +2,7 @@ C example9b (* * https://multicore.doc.ic.ac.uk/overhauling/examples/example9b.litmus + * global_fga -> global *) { From b2641a5da089e773a887c408539d0919c3a09fae Mon Sep 17 00:00:00 2001 From: haining Date: Wed, 25 Sep 2024 22:39:30 +0300 Subject: [PATCH 10/23] add c11 partialsc and simp --- cat/c11-partialsc.cat | 115 ++++++++++++++++++++++++++++++++++++++++++ cat/c11-simp.cat | 106 ++++++++++++++++++++++++++++++++++++++ 2 files changed, 221 insertions(+) create mode 100644 cat/c11-partialsc.cat create mode 100644 cat/c11-simp.cat diff --git a/cat/c11-partialsc.cat b/cat/c11-partialsc.cat new file mode 100644 index 0000000000..6317eb4876 --- /dev/null +++ b/cat/c11-partialsc.cat @@ -0,0 +1,115 @@ +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" + +let asw = IW * (M \ IW) +let sb = po +let mo = co & (~NA * ~NA) + +let cacq = ACQ | (SC & (R | F)) | ACQ_REL + | (F & CON) +let crel = REL | (SC & (W | F)) | ACQ_REL +let ccon = R & CON + +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 ; [NA]) \ vis) as NaRf + +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 & ~[_] & ~(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) \ [_]) as Spartial + +// Atomicity +empty rmw & (fre; coe) as atomic diff --git a/cat/c11-simp.cat b/cat/c11-simp.cat new file mode 100644 index 0000000000..66a321521d --- /dev/null +++ b/cat/c11-simp.cat @@ -0,0 +1,106 @@ +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_simp.cat +*) + +include "basic.cat" + +let asw = IW * (M \ IW) +let sb = po +let mo = co & (~NA * ~NA) + +let cacq = ACQ | (SC & (R | F)) | ACQ_REL + | (F & CON) +let crel = REL | (SC & (W | F)) | ACQ_REL +let ccon = R & CON + +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 ; [NA]) \ vis) as NaRf + +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 & ~[_] & ~(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 *) +let scp = ((SC * SC) & (fsb?; (mo | fr | hb); sbf?)) \ [_] +acyclic scp as Ssimp + +// Atomicity +empty rmw & (fre; coe) as atomic From bcd197836eae1dd83e9d107ad48eecbf3ecbea19 Mon Sep 17 00:00:00 2001 From: haining Date: Wed, 25 Sep 2024 22:50:05 +0300 Subject: [PATCH 11/23] replace NA with NAL --- cat/c11-partialsc.cat | 4 ++-- cat/c11-simp.cat | 4 ++-- .../program/visitors/VisitorLitmusC.java | 23 ++++++++++++++++--- 3 files changed, 24 insertions(+), 7 deletions(-) diff --git a/cat/c11-partialsc.cat b/cat/c11-partialsc.cat index 6317eb4876..51dc45ade2 100644 --- a/cat/c11-partialsc.cat +++ b/cat/c11-partialsc.cat @@ -16,7 +16,7 @@ include "basic.cat" let asw = IW * (M \ IW) let sb = po -let mo = co & (~NA * ~NA) +let mo = co & (~NAL * ~NAL) let cacq = ACQ | (SC & (R | F)) | ACQ_REL | (F & CON) @@ -73,7 +73,7 @@ let vis = ([W] ; hbl ; [R]) & ~(hbl; [W]; hbl) irreflexive (rf ; hb) as Rf (* consistent_non_atomic_rf *) -empty ((rf ; [NA]) \ vis) as NaRf +empty ((rf ; [NAL]) \ vis) as NaRf irreflexive (rf | (mo ; mo ; rf^-1) | (mo ; rf)) as Rmw diff --git a/cat/c11-simp.cat b/cat/c11-simp.cat index 66a321521d..6544428154 100644 --- a/cat/c11-simp.cat +++ b/cat/c11-simp.cat @@ -16,7 +16,7 @@ include "basic.cat" let asw = IW * (M \ IW) let sb = po -let mo = co & (~NA * ~NA) +let mo = co & (~NAL * ~NAL) let cacq = ACQ | (SC & (R | F)) | ACQ_REL | (F & CON) @@ -73,7 +73,7 @@ let vis = ([W] ; hbl ; [R]) & ~(hbl; [W]; hbl) irreflexive (rf ; hb) as Rf (* consistent_non_atomic_rf *) -empty ((rf ; [NA]) \ vis) as NaRf +empty ((rf ; [NAL]) \ vis) as NaRf irreflexive (rf | (mo ; mo ; rf^-1) | (mo ; rf)) as Rmw 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 7acd1fcca2..45762fae60 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 @@ -292,6 +292,7 @@ public Expression visitC11AtomicOp(LitmusCParser.C11AtomicOpContext ctx) { Expression value = returnExpressionOrOne(ctx.value); Expression address = getAddress(ctx.address); Event event = EventFactory.Atomic.newFetchOp(register, address, value, ctx.op, ctx.c11Mo().mo); + addLocationAtomicityTag(event, address); addOpenCLMemorySpaceTag(event, address); if (ctx.openCLScope() != null) { event.addTags(ctx.openCLScope().scope); @@ -348,6 +349,7 @@ public Expression visitReC11SCmpXchgExplicit(LitmusCParser.ReC11SCmpXchgExplicit Expression expectedAdd = getAddress(ctx.expectedAdd); String mo = ctx.c11Mo(0).mo; Event event = EventFactory.Atomic.newCompareExchange(register, address, expectedAdd, value, mo, true); + addLocationAtomicityTag(event, address); addOpenCLMemorySpaceTag(event, address); if (ctx.openCLScope() != null) { event.addTags(ctx.openCLScope().scope); @@ -366,6 +368,7 @@ public Expression visitReC11SCmpXchg(LitmusCParser.ReC11SCmpXchgContext ctx) { Expression expectedAdd = getAddress(ctx.expectedAdd); Event event = EventFactory.Atomic.newCompareExchange(register, address, expectedAdd, value, Tag.OpenCL.DEFAULT_MO, true); + addLocationAtomicityTag(event, address); addOpenCLMemorySpaceTag(event, address); event.addTags(Tag.OpenCL.DEFAULT_SCOPE); programBuilder.addChild(currentThread, event); @@ -380,6 +383,7 @@ public Expression visitReC11WCmpXchgExplicit(LitmusCParser.ReC11WCmpXchgExplicit Expression expectedAdd = getAddress(ctx.expectedAdd); String mo = ctx.c11Mo(0).mo; Event event = EventFactory.Atomic.newCompareExchange(register, address, expectedAdd, value, mo, false); + addLocationAtomicityTag(event, address); addOpenCLMemorySpaceTag(event, address); if (ctx.openCLScope() != null) { event.addTags(ctx.openCLScope().scope); @@ -398,6 +402,7 @@ public Expression visitReC11WCmpXchg(LitmusCParser.ReC11WCmpXchgContext ctx) { Expression expectedAdd = getAddress(ctx.expectedAdd); Event event = EventFactory.Atomic.newCompareExchange(register, address, expectedAdd, value, Tag.OpenCL.DEFAULT_MO, false); + addLocationAtomicityTag(event, address); addOpenCLMemorySpaceTag(event, address); event.addTags(Tag.OpenCL.DEFAULT_SCOPE); programBuilder.addChild(currentThread, event); @@ -418,6 +423,7 @@ public Expression visitReCmpXchg(LitmusCParser.ReCmpXchgContext ctx){ Register register = getReturnRegister(true); Expression address = getAddress(ctx.address); AtomicLoad event = EventFactory.Atomic.newLoad(register, address, ctx.c11Mo().mo); + addLocationAtomicityTag(event, address); addOpenCLMemorySpaceTag(event, address); if (ctx.openCLScope() != null) { event.addTags(ctx.openCLScope().scope); @@ -432,6 +438,7 @@ public Expression visitReCmpXchg(LitmusCParser.ReCmpXchgContext ctx){ Register register = getReturnRegister(true); Expression address = getAddress(ctx.address); AtomicLoad event = EventFactory.Atomic.newLoad(register, address, Tag.OpenCL.DEFAULT_MO); + addLocationAtomicityTag(event, address); addOpenCLMemorySpaceTag(event, address); event.addTags(Tag.OpenCL.DEFAULT_SCOPE); programBuilder.addChild(currentThread, event); @@ -459,6 +466,7 @@ public Expression visitReReadNa(LitmusCParser.ReReadNaContext ctx){ Register register = getReturnRegister(true); Expression address = getAddress(ctx.address); Load event = EventFactory.newLoadWithMo(register, address, C11.NONATOMIC); + addLocationAtomicityTag(event, address); addOpenCLMemorySpaceTag(event, address); programBuilder.addChild(currentThread, event); return register; @@ -574,6 +582,7 @@ public Object visitNreC11StoreExplicit(LitmusCParser.NreC11StoreExplicitContext Expression value = (Expression)ctx.value.accept(this); Expression address = getAddress(ctx.address); AtomicStore event = EventFactory.Atomic.newStore(address, value, ctx.c11Mo().mo); + addLocationAtomicityTag(event, address); addOpenCLMemorySpaceTag(event, address); if (ctx.openCLScope() != null) { event.addTags(ctx.openCLScope().scope); @@ -588,6 +597,7 @@ public Object visitNreC11Store(LitmusCParser.NreC11StoreContext ctx) { Expression value = (Expression)ctx.value.accept(this); Expression address = getAddress(ctx.address); AtomicStore event = EventFactory.Atomic.newStore(address, value, Tag.OpenCL.DEFAULT_MO); + addLocationAtomicityTag(event, address); addOpenCLMemorySpaceTag(event, address); event.addTags(Tag.OpenCL.DEFAULT_SCOPE); return programBuilder.addChild(currentThread, event); @@ -609,6 +619,7 @@ public Object visitNreAssignment(LitmusCParser.NreAssignmentContext ctx){ if(variable instanceof MemoryObject || variable instanceof Register){ Event event = EventFactory.newStoreWithMo(variable, value, C11.NONATOMIC); if (variable instanceof Register reg) { + addLocationAtomicityTag(event, reg); addOpenCLMemorySpaceTag(event, reg); event.addTags(Tag.OpenCL.DEFAULT_WEAK_SCOPE); } @@ -742,9 +753,6 @@ private void addOpenCLMemorySpaceTag(Event event, Expression address) { MemoryObject object = programBuilder.getLocFromReg(reg); if (object != null) { event.addTags(object.getMemorySpace()); - if (!object.isAtomic()) { - event.addTags(Tag.OpenCL.NON_ATOMIC_LOCATION); - } } } else if (address instanceof BinaryExpressionBase binExpr) { // TODO: Convert memory space tags for binary expressions @@ -752,4 +760,13 @@ private void addOpenCLMemorySpaceTag(Event event, Expression address) { addOpenCLMemorySpaceTag(event, binExpr.getRight()); } } + + private void addLocationAtomicityTag(Event event, Expression address) { + if (address instanceof Register reg) { + MemoryObject object = programBuilder.getLocFromReg(reg); + if (object != null && !object.isAtomic()) { + event.addTags(Tag.OpenCL.NON_ATOMIC_LOCATION); + } + } + } } From 2b96310e994971f145a733b97257acdae9f8b961 Mon Sep 17 00:00:00 2001 From: Haining Date: Thu, 26 Sep 2024 11:54:26 +0300 Subject: [PATCH 12/23] add NAL to c11 Init --- .../program/visitors/VisitorLitmusC.java | 2 +- .../dartagnan/program/event/EventFactory.java | 9 ++++++++- .../dat3m/dartagnan/program/event/Tag.java | 1 + .../program/event/arch/c11/C11Init.java | 17 ++++++++++++++++ .../program/event/arch/c11/OpenCLInit.java | 14 +++++++++++++ .../program/event/arch/opencl/OpenCLInit.java | 20 ------------------- .../processing/CoreCodeVerification.java | 5 +++-- .../program/processing/MemoryAllocation.java | 2 ++ .../processing/compilation/VisitorOpenCL.java | 3 --- 9 files changed, 46 insertions(+), 27 deletions(-) create mode 100644 dartagnan/src/main/java/com/dat3m/dartagnan/program/event/arch/c11/C11Init.java create mode 100644 dartagnan/src/main/java/com/dat3m/dartagnan/program/event/arch/c11/OpenCLInit.java delete mode 100644 dartagnan/src/main/java/com/dat3m/dartagnan/program/event/arch/opencl/OpenCLInit.java 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 45762fae60..28cf4702e3 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 @@ -765,7 +765,7 @@ private void addLocationAtomicityTag(Event event, Expression address) { if (address instanceof Register reg) { MemoryObject object = programBuilder.getLocFromReg(reg); if (object != null && !object.isAtomic()) { - event.addTags(Tag.OpenCL.NON_ATOMIC_LOCATION); + event.addTags(Tag.C11.NON_ATOMIC_LOCATION); } } } 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 5cc82b6668..83cff7b63d 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 @@ -12,7 +12,8 @@ import com.dat3m.dartagnan.program.Function; import com.dat3m.dartagnan.program.Register; import com.dat3m.dartagnan.program.event.arch.StoreExclusive; -import com.dat3m.dartagnan.program.event.arch.opencl.OpenCLInit; +import com.dat3m.dartagnan.program.event.arch.c11.C11Init; +import com.dat3m.dartagnan.program.event.arch.c11.OpenCLInit; import com.dat3m.dartagnan.program.event.arch.ptx.PTXAtomCAS; import com.dat3m.dartagnan.program.event.arch.ptx.PTXAtomExch; import com.dat3m.dartagnan.program.event.arch.ptx.PTXAtomOp; @@ -379,6 +380,12 @@ public static AtomicThreadFence newFence(String mo) { public static AtomicXchg newExchange(Register register, Expression address, Expression value, String mo) { return new AtomicXchg(register, address, value, mo); } + + public static C11Init newC11Init(MemoryObject base, int offset) { + final Expression address = offset == 0 ? base : + expressions.makeAdd(base, expressions.makeValue(offset, (IntegerType) base.getType())); + return new C11Init(base, offset, address); + } } // ============================================================================================= // =========================================== LLVM ============================================ 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 7855cb82b4..70b20ab424 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,6 +119,7 @@ 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"; diff --git a/dartagnan/src/main/java/com/dat3m/dartagnan/program/event/arch/c11/C11Init.java b/dartagnan/src/main/java/com/dat3m/dartagnan/program/event/arch/c11/C11Init.java new file mode 100644 index 0000000000..149862e75c --- /dev/null +++ b/dartagnan/src/main/java/com/dat3m/dartagnan/program/event/arch/c11/C11Init.java @@ -0,0 +1,17 @@ +package com.dat3m.dartagnan.program.event.arch.c11; + +import com.dat3m.dartagnan.expression.Expression; +import com.dat3m.dartagnan.program.event.Tag; +import com.dat3m.dartagnan.program.event.core.Init; +import com.dat3m.dartagnan.program.memory.MemoryObject; + +public class C11Init extends Init { + public C11Init(MemoryObject b, int o, Expression address) { + super(b, o, address); + addTags(Tag.C11.NONATOMIC); // Every initial event is a nonatomic write of zero + if (!b.isAtomic()) { + addTags(Tag.C11.NON_ATOMIC_LOCATION); + } + } + +} diff --git a/dartagnan/src/main/java/com/dat3m/dartagnan/program/event/arch/c11/OpenCLInit.java b/dartagnan/src/main/java/com/dat3m/dartagnan/program/event/arch/c11/OpenCLInit.java new file mode 100644 index 0000000000..2a1175e21a --- /dev/null +++ b/dartagnan/src/main/java/com/dat3m/dartagnan/program/event/arch/c11/OpenCLInit.java @@ -0,0 +1,14 @@ +package com.dat3m.dartagnan.program.event.arch.c11; + +import com.dat3m.dartagnan.expression.Expression; +import com.dat3m.dartagnan.program.memory.MemoryObject; + +public class OpenCLInit extends C11Init { + public OpenCLInit(MemoryObject b, int o, Expression address) { + super(b, o, address); + if (b.getMemorySpace() != null) { + addTags(b.getMemorySpace()); + } + } + +} diff --git a/dartagnan/src/main/java/com/dat3m/dartagnan/program/event/arch/opencl/OpenCLInit.java b/dartagnan/src/main/java/com/dat3m/dartagnan/program/event/arch/opencl/OpenCLInit.java deleted file mode 100644 index 1ad98ffc76..0000000000 --- a/dartagnan/src/main/java/com/dat3m/dartagnan/program/event/arch/opencl/OpenCLInit.java +++ /dev/null @@ -1,20 +0,0 @@ -package com.dat3m.dartagnan.program.event.arch.opencl; - -import com.dat3m.dartagnan.expression.Expression; -import com.dat3m.dartagnan.program.event.Tag; -import com.dat3m.dartagnan.program.event.core.Init; -import com.dat3m.dartagnan.program.memory.MemoryObject; - -public class OpenCLInit extends Init { - public OpenCLInit(MemoryObject b, int o, Expression address) { - super(b, o, address); - if (b.getMemorySpace() != null) { - addTags(b.getMemorySpace()); - addTags(Tag.C11.NONATOMIC); // Every initial event is a nonatomic write of zero - if (!b.isAtomic()) { - addTags(Tag.OpenCL.NON_ATOMIC_LOCATION); - } - } - } - -} diff --git a/dartagnan/src/main/java/com/dat3m/dartagnan/program/processing/CoreCodeVerification.java b/dartagnan/src/main/java/com/dat3m/dartagnan/program/processing/CoreCodeVerification.java index 1cd9f970d5..d3234b3889 100644 --- a/dartagnan/src/main/java/com/dat3m/dartagnan/program/processing/CoreCodeVerification.java +++ b/dartagnan/src/main/java/com/dat3m/dartagnan/program/processing/CoreCodeVerification.java @@ -3,7 +3,8 @@ import com.dat3m.dartagnan.exception.MalformedProgramException; import com.dat3m.dartagnan.program.Function; import com.dat3m.dartagnan.program.event.Event; -import com.dat3m.dartagnan.program.event.arch.opencl.OpenCLInit; +import com.dat3m.dartagnan.program.event.arch.c11.C11Init; +import com.dat3m.dartagnan.program.event.arch.c11.OpenCLInit; import com.dat3m.dartagnan.program.event.core.*; import com.dat3m.dartagnan.program.event.core.annotations.CodeAnnotation; import com.dat3m.dartagnan.program.event.core.threading.ThreadArgument; @@ -40,7 +41,7 @@ public static CoreCodeVerification fromConfig(Configuration config) { ThreadCreate.class, ThreadArgument.class, ThreadStart.class, ControlBarrier.class, // For PTX and Vulkan BeginAtomic.class, EndAtomic.class, - OpenCLInit.class // For OpenCL + C11Init.class, OpenCLInit.class // For OpenCL // We add SVCOMP atomic blocks here as well, despite them not being part of the core package. // TODO: We might want to find a more systematic way to extend the core with these custom events. )); 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 f8d65930a4..222f4bd0bf 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 @@ -88,6 +88,8 @@ private void createInitEvents(Program program) { EventFactory.newThreadStart(null)); if (program.getArch().equals(Arch.OPENCL)) { thread.append(EventFactory.OpenCL.newOpenCLInit(memObj, field)); + } else if (program.getArch().equals(Arch.C11)) { + thread.append(EventFactory.Atomic.newC11Init(memObj, field)); } else { thread.append(EventFactory.newInit(memObj, field)); } diff --git a/dartagnan/src/main/java/com/dat3m/dartagnan/program/processing/compilation/VisitorOpenCL.java b/dartagnan/src/main/java/com/dat3m/dartagnan/program/processing/compilation/VisitorOpenCL.java index 8a5efb3770..cc3e42ee90 100644 --- a/dartagnan/src/main/java/com/dat3m/dartagnan/program/processing/compilation/VisitorOpenCL.java +++ b/dartagnan/src/main/java/com/dat3m/dartagnan/program/processing/compilation/VisitorOpenCL.java @@ -115,9 +115,6 @@ private void tagEvent(Event originalEvent, Event e) { final MemoryOrder mo = e.getMetadata(MemoryOrder.class); final boolean canRace = mo == null || mo.value().equals(C11.NONATOMIC); e.addTags(canRace ? C11.NONATOMIC : C11.ATOMIC); - if (e.hasTag(Tag.OpenCL.NON_ATOMIC_LOCATION)) { - e.addTags(Tag.OpenCL.NON_ATOMIC_LOCATION); - } } } } From b4644b468e2954182e26cde36682766ad502eb6d Mon Sep 17 00:00:00 2001 From: Haining Date: Thu, 26 Sep 2024 14:04:05 +0300 Subject: [PATCH 13/23] update c11&opencl model names --- cat/c11-partialsc.cat | 48 +++---- cat/c11-simp.cat | 106 ---------------- cat/c11.cat | 120 ++++++------------ cat/{opencl-overhauling.cat => opencl.cat} | 6 +- .../litmus/LitmusOpenClRacesTest.java | 2 +- .../dartagnan/litmus/LitmusOpenClTest.java | 2 +- dartagnan/src/test/resources/C11-expected.csv | 2 +- 7 files changed, 69 insertions(+), 217 deletions(-) delete mode 100644 cat/c11-simp.cat rename cat/{opencl-overhauling.cat => opencl.cat} (93%) diff --git a/cat/c11-partialsc.cat b/cat/c11-partialsc.cat index 51dc45ade2..2fad1a1f91 100644 --- a/cat/c11-partialsc.cat +++ b/cat/c11-partialsc.cat @@ -13,29 +13,28 @@ C "C++11" *) 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 cacq = ACQ | (SC & (R | F)) | ACQ_REL | (F & CON) let crel = REL | (SC & (W | F)) | ACQ_REL let ccon = R & CON -let fr = rf^-1 ; mo +// 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 *) +(* 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))? *) +(* 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) @@ -47,20 +46,16 @@ 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 *) +(* 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 @@ -75,33 +70,35 @@ irreflexive (rf ; hb) as Rf (* consistent_non_atomic_rf *) empty ((rf ; [NAL]) \ vis) as NaRf -irreflexive (rf | (mo ; mo ; rf^-1) | (mo ; rf)) as Rmw +(* 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 +// 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 & ~[_] & ~(sb+) & ~((sb+)^-1) +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 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 r3 = rf^-1; [SC] ; mo let r4 = rf^-1 ; hbl ; [W] let r5 = fsb ; fr let r6 = fr ; sbf @@ -109,7 +106,4 @@ let r7 = fsb ; fr ; sbf let scp = r1|r2|r3|r4|r5|r6|r7 -acyclic (((SC * SC) & scp) \ [_]) as Spartial - -// Atomicity -empty rmw & (fre; coe) as atomic +acyclic (((SC * SC) & scp) \ id) as Spartial \ No newline at end of file diff --git a/cat/c11-simp.cat b/cat/c11-simp.cat deleted file mode 100644 index 6544428154..0000000000 --- a/cat/c11-simp.cat +++ /dev/null @@ -1,106 +0,0 @@ -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_simp.cat -*) - -include "basic.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 - -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 - -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 & ~[_] & ~(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 *) -let scp = ((SC * SC) & (fsb?; (mo | fr | hb); sbf?)) \ [_] -acyclic scp as Ssimp - -// Atomicity -empty rmw & (fre; coe) as atomic diff --git a/cat/c11.cat b/cat/c11.cat index 31c032c097..e8faf38140 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,43 @@ 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 ((rf^-1)? ; 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-overhauling.cat b/cat/opencl.cat similarity index 93% rename from cat/opencl-overhauling.cat rename to cat/opencl.cat index 85f4e804f8..df9ede5f73 100644 --- a/cat/opencl-overhauling.cat +++ b/cat/opencl.cat @@ -96,10 +96,10 @@ empty (rf; [NAL & GLOBAL])\vis(ghb) as O-NaRfG empty (rf; [NAL & LOCAL])\vis(lhb) as O-NaRfL (* Consistency of RMWs *) -irreflexive rf | (mo;mo;rf^-1) | (mo;rf) as O-Rmw - -// Atomicity 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, *) diff --git a/dartagnan/src/test/java/com/dat3m/dartagnan/litmus/LitmusOpenClRacesTest.java b/dartagnan/src/test/java/com/dat3m/dartagnan/litmus/LitmusOpenClRacesTest.java index 31e309be0e..f4a985b6e2 100644 --- a/dartagnan/src/test/java/com/dat3m/dartagnan/litmus/LitmusOpenClRacesTest.java +++ b/dartagnan/src/test/java/com/dat3m/dartagnan/litmus/LitmusOpenClRacesTest.java @@ -33,7 +33,7 @@ protected Provider> getPropertyProvider() { @Override protected Provider getWmmProvider() { - return Providers.createWmmFromName(() -> "opencl-overhauling"); + return Providers.createWmmFromName(() -> "opencl"); } public LitmusOpenClRacesTest(String path, Result 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 index 9e334150c8..ef686b6bb2 100644 --- a/dartagnan/src/test/java/com/dat3m/dartagnan/litmus/LitmusOpenClTest.java +++ b/dartagnan/src/test/java/com/dat3m/dartagnan/litmus/LitmusOpenClTest.java @@ -27,7 +27,7 @@ protected Provider getTargetProvider() { @Override protected Provider getWmmProvider() { - return Providers.createWmmFromName(() -> "opencl-overhauling"); + return Providers.createWmmFromName(() -> "opencl"); } public LitmusOpenClTest(String path, Result expected) { 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 From c7c1fb1b379de26eb82fa2c4e35c6322094a4cb6 Mon Sep 17 00:00:00 2001 From: Haining Date: Thu, 26 Sep 2024 15:20:21 +0300 Subject: [PATCH 14/23] add openclBarrier --- .../program/visitors/VisitorLitmusC.java | 2 +- .../dartagnan/program/event/EventFactory.java | 5 ++++ .../dartagnan/program/event/EventVisitor.java | 2 ++ .../dat3m/dartagnan/program/event/Tag.java | 2 -- .../program/event/arch/c11/OpenCLBarrier.java | 26 +++++++++++++++++++ .../program/event/core/ControlBarrier.java | 2 +- .../processing/CoreCodeVerification.java | 3 ++- .../processing/compilation/VisitorOpenCL.java | 16 ++++++++++++ .../comparison/C11AndOpenCLTest.java | 2 +- 9 files changed, 54 insertions(+), 6 deletions(-) create mode 100644 dartagnan/src/main/java/com/dat3m/dartagnan/program/event/arch/c11/OpenCLBarrier.java 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 28cf4702e3..d590ee3b83 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 @@ -672,7 +672,7 @@ public Object visitNreOpenCLFence(LitmusCParser.NreOpenCLFenceContext ctx){ 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); + Event fence = EventFactory.OpenCL.newOpenCLBarrier(ctx.getText().toLowerCase(), barrierId); fence.addTags(flags); if (ctx.openCLScope() != null) { fence.addTags(ctx.openCLScope().scope); 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 83cff7b63d..073efe8e2e 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 @@ -13,6 +13,7 @@ import com.dat3m.dartagnan.program.Register; import com.dat3m.dartagnan.program.event.arch.StoreExclusive; import com.dat3m.dartagnan.program.event.arch.c11.C11Init; +import com.dat3m.dartagnan.program.event.arch.c11.OpenCLBarrier; import com.dat3m.dartagnan.program.event.arch.c11.OpenCLInit; import com.dat3m.dartagnan.program.event.arch.ptx.PTXAtomCAS; import com.dat3m.dartagnan.program.event.arch.ptx.PTXAtomExch; @@ -822,6 +823,10 @@ public static OpenCLInit newOpenCLInit(MemoryObject base, int offset) { return new OpenCLInit(base, offset, address); } + public static OpenCLBarrier newOpenCLBarrier(String name, Expression fenceId) { + return new OpenCLBarrier(name, fenceId); + } + } } \ 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 20d5a5eb67..48f4f7ab73 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 @@ -1,6 +1,7 @@ package com.dat3m.dartagnan.program.event; import com.dat3m.dartagnan.program.event.arch.StoreExclusive; +import com.dat3m.dartagnan.program.event.arch.c11.OpenCLBarrier; import com.dat3m.dartagnan.program.event.arch.ptx.PTXAtomCAS; import com.dat3m.dartagnan.program.event.arch.ptx.PTXAtomExch; import com.dat3m.dartagnan.program.event.arch.ptx.PTXAtomOp; @@ -101,6 +102,7 @@ public interface EventVisitor { // ------------------ GPU Events ------------------ default T visitControlBarrier(ControlBarrier e) { return visitEvent(e); } + default T visitOpenCLBarrier(OpenCLBarrier e) { return visitEvent(e); } default T visitPtxRedOp(PTXRedOp e) { return visitMemEvent(e); } default T visitPtxAtomOp(PTXAtomOp e) { return visitMemEvent(e); } default T visitPtxAtomCAS(PTXAtomCAS e) { return visitMemEvent(e); } 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 70b20ab424..765b2437d2 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 @@ -379,8 +379,6 @@ public static String storeMO(String mo) { // ========================================= OpenCL ============================================ // ============================================================================================= public static final class OpenCL { - // Atomicity of location - public static final String NON_ATOMIC_LOCATION = "NAL"; // Space public static final String GLOBAL_SPACE = "GLOBAL"; public static final String LOCAL_SPACE = "LOCAL"; diff --git a/dartagnan/src/main/java/com/dat3m/dartagnan/program/event/arch/c11/OpenCLBarrier.java b/dartagnan/src/main/java/com/dat3m/dartagnan/program/event/arch/c11/OpenCLBarrier.java new file mode 100644 index 0000000000..c4f354c462 --- /dev/null +++ b/dartagnan/src/main/java/com/dat3m/dartagnan/program/event/arch/c11/OpenCLBarrier.java @@ -0,0 +1,26 @@ +package com.dat3m.dartagnan.program.event.arch.c11; + +import com.dat3m.dartagnan.program.event.EventVisitor; +import com.dat3m.dartagnan.program.event.core.ControlBarrier; +import com.dat3m.dartagnan.expression.Expression; + +public class OpenCLBarrier extends ControlBarrier { + + public OpenCLBarrier(String name, Expression id) { + super(name, id); + } + + private OpenCLBarrier(OpenCLBarrier other) { + super(other); + } + + @Override + public OpenCLBarrier getCopy() { + return new OpenCLBarrier(this); + } + + @Override + public T accept(EventVisitor visitor) { + return visitor.visitOpenCLBarrier(this); + } +} 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/processing/CoreCodeVerification.java b/dartagnan/src/main/java/com/dat3m/dartagnan/program/processing/CoreCodeVerification.java index d3234b3889..b8e4b52e40 100644 --- a/dartagnan/src/main/java/com/dat3m/dartagnan/program/processing/CoreCodeVerification.java +++ b/dartagnan/src/main/java/com/dat3m/dartagnan/program/processing/CoreCodeVerification.java @@ -4,6 +4,7 @@ import com.dat3m.dartagnan.program.Function; import com.dat3m.dartagnan.program.event.Event; import com.dat3m.dartagnan.program.event.arch.c11.C11Init; +import com.dat3m.dartagnan.program.event.arch.c11.OpenCLBarrier; import com.dat3m.dartagnan.program.event.arch.c11.OpenCLInit; import com.dat3m.dartagnan.program.event.core.*; import com.dat3m.dartagnan.program.event.core.annotations.CodeAnnotation; @@ -41,7 +42,7 @@ public static CoreCodeVerification fromConfig(Configuration config) { ThreadCreate.class, ThreadArgument.class, ThreadStart.class, ControlBarrier.class, // For PTX and Vulkan BeginAtomic.class, EndAtomic.class, - C11Init.class, OpenCLInit.class // For OpenCL + C11Init.class, OpenCLInit.class, OpenCLBarrier.class // For OpenCL // We add SVCOMP atomic blocks here as well, despite them not being part of the core package. // TODO: We might want to find a more systematic way to extend the core with these custom events. )); diff --git a/dartagnan/src/main/java/com/dat3m/dartagnan/program/processing/compilation/VisitorOpenCL.java b/dartagnan/src/main/java/com/dat3m/dartagnan/program/processing/compilation/VisitorOpenCL.java index cc3e42ee90..5d013cdb93 100644 --- a/dartagnan/src/main/java/com/dat3m/dartagnan/program/processing/compilation/VisitorOpenCL.java +++ b/dartagnan/src/main/java/com/dat3m/dartagnan/program/processing/compilation/VisitorOpenCL.java @@ -5,10 +5,12 @@ import com.dat3m.dartagnan.expression.type.BooleanType; import com.dat3m.dartagnan.expression.Type; import com.dat3m.dartagnan.program.Register; +import com.dat3m.dartagnan.program.event.EventFactory; import com.dat3m.dartagnan.program.event.Tag; import com.dat3m.dartagnan.program.event.Tag.C11; import com.dat3m.dartagnan.program.event.Event; import com.dat3m.dartagnan.program.event.MemoryEvent; +import com.dat3m.dartagnan.program.event.arch.c11.OpenCLBarrier; import com.dat3m.dartagnan.program.event.core.*; import com.dat3m.dartagnan.program.event.core.RMWStore; import com.dat3m.dartagnan.program.event.lang.catomic.*; @@ -17,6 +19,7 @@ import java.util.List; import static com.dat3m.dartagnan.program.event.EventFactory.*; +import static com.dat3m.dartagnan.program.event.EventFactory.OpenCL.newOpenCLBarrier; public class VisitorOpenCL extends VisitorBase { @@ -96,6 +99,19 @@ public List visitAtomicThreadFence(AtomicThreadFence e) { )); } + @Override + public List visitOpenCLBarrier(OpenCLBarrier e) { + Event entryFence = EventFactory.newControlBarrier(e.getName() + "_entry", e.getId()); + entryFence.addTags(Tag.OpenCL.ENTRY_FENCE); + Event exitFence = EventFactory.newControlBarrier(e.getName() + "_exit", e.getId()); + exitFence.addTags(Tag.OpenCL.EXIT_FENCE); + return tagList(e, eventSequence( + entryFence, + newOpenCLBarrier(e.getName(), e.getId()), + exitFence + )); + } + private List tagList(Event originalEvent, List in) { in.forEach(e -> tagEvent(originalEvent, e)); return in; diff --git a/dartagnan/src/test/java/com/dat3m/dartagnan/comparison/C11AndOpenCLTest.java b/dartagnan/src/test/java/com/dat3m/dartagnan/comparison/C11AndOpenCLTest.java index 65502d11f8..98e3522a9e 100644 --- a/dartagnan/src/test/java/com/dat3m/dartagnan/comparison/C11AndOpenCLTest.java +++ b/dartagnan/src/test/java/com/dat3m/dartagnan/comparison/C11AndOpenCLTest.java @@ -38,6 +38,6 @@ protected Provider getSourceWmmProvider() { @Override protected Provider getTargetWmmProvider() { - return Providers.createWmmFromName(() -> "opencl-overhauling"); + return Providers.createWmmFromName(() -> "opencl"); } } From 68adc510ef8a1a9fd3abc386adb233ecf7be8d78 Mon Sep 17 00:00:00 2001 From: Haining Date: Thu, 26 Sep 2024 16:21:53 +0300 Subject: [PATCH 15/23] clean code --- .../parsers/program/utils/ProgramBuilder.java | 6 ++---- .../parsers/program/visitors/VisitorLitmusC.java | 16 +++++++--------- .../java/com/dat3m/dartagnan/program/Thread.java | 7 +------ .../program/processing/MemoryAllocation.java | 6 +++--- 4 files changed, 13 insertions(+), 22 deletions(-) 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 567d61c7bc..1766a685f5 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 @@ -276,10 +276,6 @@ public Label getEndOfThreadLabel(int tid) { // ---------------------------------------------------------------------------------------------------------------- // GPU - public void setThreadScopeHierarchy(int tid, ScopeHierarchy scopeHierarchy) { - getOrNewThread(tid).setScopeHierarchy(scopeHierarchy); - } - 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."); @@ -291,6 +287,8 @@ public void newScopedThread(Arch arch, String name, int id, int ...scopeIds) { 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<>()); + case OPENCL -> new Thread(name, DEFAULT_THREAD_TYPE, List.of(), id, threadEntry, + ScopeHierarchy.ScopeHierarchyForOpenCL(scopeIds[0], scopeIds[1]), new HashSet<>()); default -> throw new UnsupportedOperationException("Unsupported architecture: " + arch); }; id2FunctionsMap.put(id, scopedThread); 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 d590ee3b83..558a696a7e 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; @@ -157,14 +158,12 @@ 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 (ctx.threadScope() != null) { + if (ctx.threadScope() == null) { + // Set dummy scope for C11 threads + programBuilder.newScopedThread(Arch.OPENCL, currentThread, 0, 0); + } else { ctx.threadScope().accept(this); this.isOpenCL = true; - } else { - // Set dummy scope hierarchy for CPU threads - programBuilder.setThreadScopeHierarchy(currentThread, - ScopeHierarchy.ScopeHierarchyForOpenCL(-2, -2)); } visitThreadArguments(ctx.threadArguments()); @@ -179,8 +178,7 @@ public Object visitThread(LitmusCParser.ThreadContext ctx) { public Object visitOpenCLThreadScope(LitmusCParser.OpenCLThreadScopeContext ctx) { int wgID = ctx.scopeID(0).id; int devID = ctx.scopeID(1).id; - ScopeHierarchy scopeHierarchy = ScopeHierarchy.ScopeHierarchyForOpenCL(devID, wgID); - programBuilder.setThreadScopeHierarchy(currentThread, scopeHierarchy); + programBuilder.newScopedThread(Arch.OPENCL, currentThread, devID, wgID); return null; } @@ -196,7 +194,7 @@ public Object visitThreadArguments(LitmusCParser.ThreadArgumentsContext ctx){ @Override public Object visitThreadArgument(LitmusCParser.ThreadArgumentContext ctx) { - // TODO: Possibly parse attributes/type modifiers (const, atomic, ...) + // 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); 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 4f8e948a52..a4280b0b1b 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 Optional scopeHierarchy; + private final Optional scopeHierarchy; // Threads that are system-synchronized-with this thread private final Optional> syncSet; @@ -56,11 +56,6 @@ public Set getSyncSet() { return syncSet.get(); } - // TODO: remove ScopeHierarchy setter and make field final after the thread creation of C fixed - 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/processing/MemoryAllocation.java b/dartagnan/src/main/java/com/dat3m/dartagnan/program/processing/MemoryAllocation.java index 222f4bd0bf..5d7d2911d0 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 @@ -86,10 +86,10 @@ private void createInitEvents(Program program) { final String threadName = "Init_" + nextThreadId; final Thread thread = new Thread(threadName, initThreadType, paramNames, nextThreadId, EventFactory.newThreadStart(null)); - if (program.getArch().equals(Arch.OPENCL)) { - thread.append(EventFactory.OpenCL.newOpenCLInit(memObj, field)); - } else if (program.getArch().equals(Arch.C11)) { + if (program.getArch().equals(Arch.C11)) { thread.append(EventFactory.Atomic.newC11Init(memObj, field)); + } else if (program.getArch().equals(Arch.OPENCL)) { + thread.append(EventFactory.OpenCL.newOpenCLInit(memObj, field)); } else { thread.append(EventFactory.newInit(memObj, field)); } From 07052987c722b3d190e0b06d2ca274d34385e8ea Mon Sep 17 00:00:00 2001 From: haining Date: Fri, 27 Sep 2024 08:45:38 +0300 Subject: [PATCH 16/23] add REL/ACQ to EF and XF --- .../program/processing/compilation/VisitorOpenCL.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/dartagnan/src/main/java/com/dat3m/dartagnan/program/processing/compilation/VisitorOpenCL.java b/dartagnan/src/main/java/com/dat3m/dartagnan/program/processing/compilation/VisitorOpenCL.java index 5d013cdb93..bef7e43bb2 100644 --- a/dartagnan/src/main/java/com/dat3m/dartagnan/program/processing/compilation/VisitorOpenCL.java +++ b/dartagnan/src/main/java/com/dat3m/dartagnan/program/processing/compilation/VisitorOpenCL.java @@ -102,9 +102,9 @@ public List visitAtomicThreadFence(AtomicThreadFence e) { @Override public List visitOpenCLBarrier(OpenCLBarrier e) { Event entryFence = EventFactory.newControlBarrier(e.getName() + "_entry", e.getId()); - entryFence.addTags(Tag.OpenCL.ENTRY_FENCE); + entryFence.addTags(Tag.OpenCL.ENTRY_FENCE, C11.MO_RELEASE); Event exitFence = EventFactory.newControlBarrier(e.getName() + "_exit", e.getId()); - exitFence.addTags(Tag.OpenCL.EXIT_FENCE); + exitFence.addTags(Tag.OpenCL.EXIT_FENCE, C11.MO_ACQUIRE); return tagList(e, eventSequence( entryFence, newOpenCLBarrier(e.getName(), e.getId()), From 2ec066e5d9bc420da6154a4cd9557587d004a049 Mon Sep 17 00:00:00 2001 From: Haining Date: Fri, 27 Sep 2024 18:49:00 +0300 Subject: [PATCH 17/23] initialize Reg after thread created --- .../parsers/program/utils/ProgramBuilder.java | 53 ++++++++++++++++--- .../program/visitors/VisitorLitmusC.java | 20 ++++--- 2 files changed, 54 insertions(+), 19 deletions(-) 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 1766a685f5..9f1189ba44 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 @@ -7,6 +7,7 @@ import com.dat3m.dartagnan.expression.Type; import com.dat3m.dartagnan.expression.integers.IntLiteral; import com.dat3m.dartagnan.expression.type.FunctionType; +import com.dat3m.dartagnan.expression.type.IntegerType; import com.dat3m.dartagnan.expression.type.TypeFactory; import com.dat3m.dartagnan.program.*; import com.dat3m.dartagnan.program.Thread; @@ -45,6 +46,10 @@ public class ProgramBuilder { private final Map> fid2LabelsMap = new HashMap<>(); private final Map locations = new HashMap<>(); private final Map reg2LocMap = new HashMap<>(); + private final Map> id2RegTypeMap = new HashMap<>(); + private final Map> id2RegConstMap = new HashMap<>(); + private final Map> id2RegLocPtrMap = new HashMap<>(); + private final Map> id2RegLocValMap = new HashMap<>(); private final Program program; @@ -114,13 +119,19 @@ public void setAssertFilter(Expression ass) { // This method creates a "default" thread that has no parameters, no return value, and runs unconditionally. // It is only useful for creating threads of Litmus code. - public Thread newThread(String name, int tid) { - if(id2FunctionsMap.containsKey(tid)) { - throw new MalformedProgramException("Function or thread with id " + tid + " already exists."); - } - final Thread thread = new Thread(name, DEFAULT_THREAD_TYPE, List.of(), tid, EventFactory.newThreadStart(null)); + public Thread newThread(int tid, Thread thread) { id2FunctionsMap.put(tid, thread); program.addThread(thread); + if (id2RegConstMap.containsKey(tid)) { + id2RegConstMap.get(tid).forEach((regName, value) -> + initRegEqConst(tid, regName, value)); + } else if (id2RegLocPtrMap.containsKey(tid)) { + id2RegLocPtrMap.get(tid).forEach((regName, value) -> + initRegEqLocPtr(tid, regName, value, getRegType(tid, regName))); + } else if (id2RegLocValMap.containsKey(tid)) { + id2RegLocValMap.get(tid).forEach((regName, value) -> + initRegEqLocVal(tid, regName, value, getRegType(tid, regName))); + } return thread; } @@ -135,8 +146,12 @@ public Function newFunction(String name, int fid, FunctionType type, List new HashMap<>()).put(regName, type); + } + + public IntegerType getRegType(int tid, String regName) { + if (id2RegTypeMap.containsKey(tid) && id2RegTypeMap.get(tid).containsKey(regName)) { + return id2RegTypeMap.get(tid).get(regName); + } + throw new IllegalStateException("Register " + tid + ":" + regName + " is not initialised"); + } + + public void addRegToConstMap(int tid, String regName, Expression value) { + id2RegConstMap.computeIfAbsent(tid, k -> new HashMap<>()).put(regName, value); + } + + public void addRegToLocPtrMap(int tid, String regName, String locName) { + id2RegLocPtrMap.computeIfAbsent(tid, k -> new HashMap<>()).put(regName, locName); + } + + public void addRegToLocValMap(int tid, String regName, String locName) { + id2RegLocValMap.computeIfAbsent(tid, k -> new HashMap<>()).put(regName, locName); + } + private Expression getInitialValue(String name) { return getOrNewMemoryObject(name).getInitialValue(0); } @@ -291,8 +329,7 @@ public void newScopedThread(Arch arch, String name, int id, int ...scopeIds) { ScopeHierarchy.ScopeHierarchyForOpenCL(scopeIds[0], scopeIds[1]), new HashSet<>()); default -> throw new UnsupportedOperationException("Unsupported architecture: " + arch); }; - id2FunctionsMap.put(id, scopedThread); - program.addThread(scopedThread); + newThread(id, scopedThread); } public void newScopedThread(Arch arch, int id, int ...ids) { 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 558a696a7e..c16ce56a6a 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 @@ -13,7 +13,6 @@ import com.dat3m.dartagnan.parsers.program.utils.ProgramBuilder; import com.dat3m.dartagnan.program.Program; import com.dat3m.dartagnan.program.Register; -import com.dat3m.dartagnan.program.ScopeHierarchy; import com.dat3m.dartagnan.program.event.Event; import com.dat3m.dartagnan.program.event.EventFactory; import com.dat3m.dartagnan.program.event.Tag; @@ -47,8 +46,6 @@ public VisitorLitmusC(){ @Override public Program visitMain(LitmusCParser.MainContext ctx) { - //FIXME: We should visit thread declarations before variable declarations - // because variable declaration refer to threads. visitVariableDeclaratorList(ctx.variableDeclaratorList()); visitProgram(ctx.program()); VisitorLitmusAssertions.parseAssertions(programBuilder, ctx.assertionList(), ctx.assertionFilter()); @@ -71,10 +68,9 @@ public Object visitGlobalDeclaratorLocation(LitmusCParser.GlobalDeclaratorLocati @Override public Object visitGlobalDeclaratorRegister(LitmusCParser.GlobalDeclaratorRegisterContext ctx) { if (ctx.initConstantValue() != null) { - // FIXME: We visit declarators before threads, so we need to create threads early - programBuilder.getOrNewThread(ctx.threadId().id); IntLiteral value = expressions.parseValue(ctx.initConstantValue().constant().getText(), archType); - programBuilder.initRegEqConst(ctx.threadId().id,ctx.varName().getText(), value); + programBuilder.addRegType(ctx.threadId().id, ctx.varName().getText(), archType); + programBuilder.addRegToConstMap(ctx.threadId().id, ctx.varName().getText(), value); } return null; } @@ -97,17 +93,19 @@ public Object visitGlobalDeclaratorLocationLocation(LitmusCParser.GlobalDeclarat @Override public Object visitGlobalDeclaratorRegisterLocation(LitmusCParser.GlobalDeclaratorRegisterLocationContext ctx) { - // FIXME: We visit declarators before threads, so we need to create threads early - programBuilder.getOrNewThread(ctx.threadId().id); + int threadId = ctx.threadId().id; + String regName = ctx.varName(0).getText(); + String locName = ctx.varName(1).getText(); + programBuilder.addRegType(threadId, regName, archType); if(ctx.Ast() == null){ - programBuilder.initRegEqLocPtr(ctx.threadId().id, ctx.varName(0).getText(), ctx.varName(1).getText(), archType); + programBuilder.addRegToLocPtrMap(threadId, regName, locName); } else { String rightName = ctx.varName(1).getText(); MemoryObject object = programBuilder.getMemoryObject(rightName); if(object != null){ - programBuilder.initRegEqConst(ctx.threadId().id, ctx.varName(0).getText(), object); + programBuilder.addRegToConstMap(threadId, regName, object); } else { - programBuilder.initRegEqLocVal(ctx.threadId().id, ctx.varName(0).getText(), ctx.varName(1).getText(), archType); + programBuilder.addRegToLocValMap(threadId, regName, locName); } } return null; From bd48d297b677bad7822993ff6a3c7353fac1d95e Mon Sep 17 00:00:00 2001 From: haining Date: Fri, 27 Sep 2024 20:32:46 +0300 Subject: [PATCH 18/23] update coh axiom --- cat/c11.cat | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/cat/c11.cat b/cat/c11.cat index e8faf38140..e951b27575 100644 --- a/cat/c11.cat +++ b/cat/c11.cat @@ -59,7 +59,8 @@ 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 (* visible_side_effect_set *) let vis = ([W] ; hbl ; [R]) & ~(hbl; [W]; hbl) From a63dd9cf0100f519554c6585907da4e610c41e0c Mon Sep 17 00:00:00 2001 From: Haining Date: Mon, 30 Sep 2024 13:35:52 +0300 Subject: [PATCH 19/23] update visitors and tags --- cat/opencl-herd.cat | 2 +- cat/opencl.cat | 2 +- dartagnan/src/main/antlr4/LitmusC.g4 | 8 +- .../java/com/dat3m/dartagnan/Dartagnan.java | 2 +- .../dartagnan/encoding/ProgramEncoder.java | 4 +- .../parsers/program/ProgramParser.java | 1 - .../program/visitors/VisitorLitmusC.java | 62 +++----- .../program/visitors/VisitorLitmusVulkan.java | 6 +- .../dartagnan/program/ScopeHierarchy.java | 20 +-- .../dartagnan/program/event/EventFactory.java | 32 +--- .../dartagnan/program/event/EventVisitor.java | 2 - .../dat3m/dartagnan/program/event/Tag.java | 43 +++--- .../program/event/arch/c11/C11Init.java | 17 --- .../program/event/arch/c11/OpenCLBarrier.java | 26 ---- .../program/event/arch/c11/OpenCLInit.java | 14 -- .../program/memory/MemoryObject.java | 15 +- .../processing/CoreCodeVerification.java | 6 +- .../program/processing/MemoryAllocation.java | 8 +- .../processing/compilation/Compilation.java | 3 +- .../processing/compilation/VisitorC11.java | 50 +++++-- .../processing/compilation/VisitorOpenCL.java | 137 ----------------- .../processing/compilation/VisitorPTX.java | 2 +- .../compilation/VisitorSpirvVulkan.java | 12 +- .../processing/compilation/VisitorVulkan.java | 4 +- .../java/com/dat3m/dartagnan/wmm/Wmm.java | 10 +- .../compilation/VisitorSpirvVulkanTest.java | 140 +++++++++--------- .../dartagnan/spirv/header/ConfigTest.java | 10 +- 27 files changed, 201 insertions(+), 437 deletions(-) delete mode 100644 dartagnan/src/main/java/com/dat3m/dartagnan/program/event/arch/c11/C11Init.java delete mode 100644 dartagnan/src/main/java/com/dat3m/dartagnan/program/event/arch/c11/OpenCLBarrier.java delete mode 100644 dartagnan/src/main/java/com/dat3m/dartagnan/program/event/arch/c11/OpenCLInit.java delete mode 100644 dartagnan/src/main/java/com/dat3m/dartagnan/program/processing/compilation/VisitorOpenCL.java diff --git a/cat/opencl-herd.cat b/cat/opencl-herd.cat index c21a1bd0cf..69b4dd6e1d 100644 --- a/cat/opencl-herd.cat +++ b/cat/opencl-herd.cat @@ -127,7 +127,7 @@ let scp = (SC * SC) & (ghb | lhb | co | sc1 | sc2 | sc3 | sc4 | sc5) let sc6 = rf^-1; (ghb | lhb); [W] -let unv = ~0 +let unv = _ * _ let ifexists(s) = unv; [s]; unv (* BEGIN PARTIAL SC STUFF *) diff --git a/cat/opencl.cat b/cat/opencl.cat index df9ede5f73..c48f3f0a13 100644 --- a/cat/opencl.cat +++ b/cat/opencl.cat @@ -27,7 +27,7 @@ include "basic.cat" let mo = co & ((~NAL) * (~NAL)) let sb = po let rb = (rf^-1; mo) \ id -let unv = ~0 +let unv = _ * _ let wi = int (* Inclusive scopes *) diff --git a/dartagnan/src/main/antlr4/LitmusC.g4 b/dartagnan/src/main/antlr4/LitmusC.g4 index f1772bab49..10227ec621 100644 --- a/dartagnan/src/main/antlr4/LitmusC.g4 +++ b/dartagnan/src/main/antlr4/LitmusC.g4 @@ -266,10 +266,10 @@ openCLSpace returns [String space] ; openCLScope returns [String scope] - : OpenCLMemoryScopeWI {$scope = GPU_SCOPES.WORK_ITEM;} - | OpenCLMemoryScopeWG {$scope = GPU_SCOPES.WORK_GROUP;} - | OpenCLMemoryScopeDEV {$scope = GPU_SCOPES.DEVICE;} - | OpenCLMemoryScopeALL {$scope = GPU_SCOPES.ALL;} + : OpenCLMemoryScopeWI {$scope = OpenCL.WORK_ITEM;} + | OpenCLMemoryScopeWG {$scope = OpenCL.WORK_GROUP;} + | OpenCLMemoryScopeDEV {$scope = OpenCL.DEVICE;} + | OpenCLMemoryScopeALL {$scope = OpenCL.ALL;} ; openCLFenceFlags diff --git a/dartagnan/src/main/java/com/dat3m/dartagnan/Dartagnan.java b/dartagnan/src/main/java/com/dat3m/dartagnan/Dartagnan.java index 6179b95daf..6709bdb8df 100644 --- a/dartagnan/src/main/java/com/dat3m/dartagnan/Dartagnan.java +++ b/dartagnan/src/main/java/com/dat3m/dartagnan/Dartagnan.java @@ -76,7 +76,7 @@ public class Dartagnan extends BaseOptions { private static final Logger logger = LogManager.getLogger(Dartagnan.class); private static final Set supportedFormats = - ImmutableSet.copyOf(Arrays.asList(".litmus", ".c", ".i", ".ll", ".spv.dis", ".cl")); + ImmutableSet.copyOf(Arrays.asList(".litmus", ".c", ".i", ".ll", ".spv.dis")); private Dartagnan(Configuration config) throws InvalidConfigurationException { config.recursiveInject(this); diff --git a/dartagnan/src/main/java/com/dat3m/dartagnan/encoding/ProgramEncoder.java b/dartagnan/src/main/java/com/dat3m/dartagnan/encoding/ProgramEncoder.java index 213a7f1037..a7fbbad893 100644 --- a/dartagnan/src/main/java/com/dat3m/dartagnan/encoding/ProgramEncoder.java +++ b/dartagnan/src/main/java/com/dat3m/dartagnan/encoding/ProgramEncoder.java @@ -173,9 +173,9 @@ private BooleanFormula threadIsStuckInBarrier(Thread thread) { private int getWorkgroupId(Thread thread) { ScopeHierarchy hierarchy = thread.getScopeHierarchy(); if (hierarchy != null) { - int id = hierarchy.getScopeId(Tag.GPU_SCOPES.WORK_GROUP); + int id = hierarchy.getScopeId(Tag.Vulkan.WORK_GROUP); if (id < 0) { - id = hierarchy.getScopeId(Tag.GPU_SCOPES.CTA); + id = hierarchy.getScopeId(Tag.PTX.CTA); } return id; } 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 f934161849..d98cca549e 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 @@ -56,7 +56,6 @@ public Program parse(String raw, String path, String format, String cflags) thro } file = compileWithClang(file, cflags); file = applyLlvmPasses(file); - file = applyDemangling(file); Program p = new ProgramParser().parse(file); file.delete(); return p; 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 c16ce56a6a..ccf0c6c0a7 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 @@ -199,15 +199,17 @@ public Object visitThreadArgument(LitmusCParser.ThreadArgumentContext ctx) { Register register = programBuilder.getOrNewRegister(scope, name, archType); boolean atomicity = ctx.pointerTypeSpecifier().atomicTypeSpecifier() != null || ctx.pointerTypeSpecifier().basicTypeSpecifier().AtomicInt() != null; - object.setIsAtomic(atomicity); + if (!atomicity) { + object.addFeatureTag(C11.NON_ATOMIC_LOCATION); + } if (this.isOpenCL) { if (ctx.openCLSpace() != null) { - object.setMemorySpace(ctx.openCLSpace().space); + object.addFeatureTag(ctx.openCLSpace().space); } else { - object.setMemorySpace(Tag.OpenCL.DEFAULT_GPU_SPACE); + object.addFeatureTag(Tag.OpenCL.DEFAULT_GPU_SPACE); } } else { - object.setMemorySpace(Tag.OpenCL.DEFAULT_CPU_SPACE); + object.addFeatureTag(Tag.OpenCL.DEFAULT_CPU_SPACE); } programBuilder.setReg2LocMap(register, object); programBuilder.addChild(currentThread, EventFactory.newLocal(register, object)); @@ -288,8 +290,7 @@ public Expression visitC11AtomicOp(LitmusCParser.C11AtomicOpContext ctx) { Expression value = returnExpressionOrOne(ctx.value); Expression address = getAddress(ctx.address); Event event = EventFactory.Atomic.newFetchOp(register, address, value, ctx.op, ctx.c11Mo().mo); - addLocationAtomicityTag(event, address); - addOpenCLMemorySpaceTag(event, address); + addMemoryObjectTags(event, address); if (ctx.openCLScope() != null) { event.addTags(ctx.openCLScope().scope); } else { @@ -345,8 +346,7 @@ public Expression visitReC11SCmpXchgExplicit(LitmusCParser.ReC11SCmpXchgExplicit Expression expectedAdd = getAddress(ctx.expectedAdd); String mo = ctx.c11Mo(0).mo; Event event = EventFactory.Atomic.newCompareExchange(register, address, expectedAdd, value, mo, true); - addLocationAtomicityTag(event, address); - addOpenCLMemorySpaceTag(event, address); + addMemoryObjectTags(event, address); if (ctx.openCLScope() != null) { event.addTags(ctx.openCLScope().scope); } else { @@ -364,8 +364,7 @@ public Expression visitReC11SCmpXchg(LitmusCParser.ReC11SCmpXchgContext ctx) { Expression expectedAdd = getAddress(ctx.expectedAdd); Event event = EventFactory.Atomic.newCompareExchange(register, address, expectedAdd, value, Tag.OpenCL.DEFAULT_MO, true); - addLocationAtomicityTag(event, address); - addOpenCLMemorySpaceTag(event, address); + addMemoryObjectTags(event, address); event.addTags(Tag.OpenCL.DEFAULT_SCOPE); programBuilder.addChild(currentThread, event); return register; @@ -379,8 +378,7 @@ public Expression visitReC11WCmpXchgExplicit(LitmusCParser.ReC11WCmpXchgExplicit Expression expectedAdd = getAddress(ctx.expectedAdd); String mo = ctx.c11Mo(0).mo; Event event = EventFactory.Atomic.newCompareExchange(register, address, expectedAdd, value, mo, false); - addLocationAtomicityTag(event, address); - addOpenCLMemorySpaceTag(event, address); + addMemoryObjectTags(event, address); if (ctx.openCLScope() != null) { event.addTags(ctx.openCLScope().scope); } else { @@ -398,8 +396,7 @@ public Expression visitReC11WCmpXchg(LitmusCParser.ReC11WCmpXchgContext ctx) { Expression expectedAdd = getAddress(ctx.expectedAdd); Event event = EventFactory.Atomic.newCompareExchange(register, address, expectedAdd, value, Tag.OpenCL.DEFAULT_MO, false); - addLocationAtomicityTag(event, address); - addOpenCLMemorySpaceTag(event, address); + addMemoryObjectTags(event, address); event.addTags(Tag.OpenCL.DEFAULT_SCOPE); programBuilder.addChild(currentThread, event); return register; @@ -419,8 +416,7 @@ public Expression visitReCmpXchg(LitmusCParser.ReCmpXchgContext ctx){ Register register = getReturnRegister(true); Expression address = getAddress(ctx.address); AtomicLoad event = EventFactory.Atomic.newLoad(register, address, ctx.c11Mo().mo); - addLocationAtomicityTag(event, address); - addOpenCLMemorySpaceTag(event, address); + addMemoryObjectTags(event, address); if (ctx.openCLScope() != null) { event.addTags(ctx.openCLScope().scope); } else { @@ -434,8 +430,7 @@ public Expression visitReCmpXchg(LitmusCParser.ReCmpXchgContext ctx){ Register register = getReturnRegister(true); Expression address = getAddress(ctx.address); AtomicLoad event = EventFactory.Atomic.newLoad(register, address, Tag.OpenCL.DEFAULT_MO); - addLocationAtomicityTag(event, address); - addOpenCLMemorySpaceTag(event, address); + addMemoryObjectTags(event, address); event.addTags(Tag.OpenCL.DEFAULT_SCOPE); programBuilder.addChild(currentThread, event); return register; @@ -462,8 +457,7 @@ public Expression visitReReadNa(LitmusCParser.ReReadNaContext ctx){ Register register = getReturnRegister(true); Expression address = getAddress(ctx.address); Load event = EventFactory.newLoadWithMo(register, address, C11.NONATOMIC); - addLocationAtomicityTag(event, address); - addOpenCLMemorySpaceTag(event, address); + addMemoryObjectTags(event, address); programBuilder.addChild(currentThread, event); return register; } @@ -578,8 +572,7 @@ public Object visitNreC11StoreExplicit(LitmusCParser.NreC11StoreExplicitContext Expression value = (Expression)ctx.value.accept(this); Expression address = getAddress(ctx.address); AtomicStore event = EventFactory.Atomic.newStore(address, value, ctx.c11Mo().mo); - addLocationAtomicityTag(event, address); - addOpenCLMemorySpaceTag(event, address); + addMemoryObjectTags(event, address); if (ctx.openCLScope() != null) { event.addTags(ctx.openCLScope().scope); } else { @@ -593,8 +586,7 @@ public Object visitNreC11Store(LitmusCParser.NreC11StoreContext ctx) { Expression value = (Expression)ctx.value.accept(this); Expression address = getAddress(ctx.address); AtomicStore event = EventFactory.Atomic.newStore(address, value, Tag.OpenCL.DEFAULT_MO); - addLocationAtomicityTag(event, address); - addOpenCLMemorySpaceTag(event, address); + addMemoryObjectTags(event, address); event.addTags(Tag.OpenCL.DEFAULT_SCOPE); return programBuilder.addChild(currentThread, event); } @@ -615,8 +607,7 @@ public Object visitNreAssignment(LitmusCParser.NreAssignmentContext ctx){ if(variable instanceof MemoryObject || variable instanceof Register){ Event event = EventFactory.newStoreWithMo(variable, value, C11.NONATOMIC); if (variable instanceof Register reg) { - addLocationAtomicityTag(event, reg); - addOpenCLMemorySpaceTag(event, reg); + addMemoryObjectTags(event, reg); event.addTags(Tag.OpenCL.DEFAULT_WEAK_SCOPE); } return programBuilder.addChild(currentThread, event); @@ -668,7 +659,7 @@ public Object visitNreOpenCLFence(LitmusCParser.NreOpenCLFenceContext ctx){ 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.OpenCL.newOpenCLBarrier(ctx.getText().toLowerCase(), barrierId); + Event fence = EventFactory.newControlBarrier(ctx.getText().toLowerCase(), barrierId); fence.addTags(flags); if (ctx.openCLScope() != null) { fence.addTags(ctx.openCLScope().scope); @@ -744,25 +735,16 @@ private Expression assignToReturnRegister(Register register, Expression value) { return value; } - private void addOpenCLMemorySpaceTag(Event event, Expression address) { + private void addMemoryObjectTags(Event event, Expression address) { if (address instanceof Register reg) { MemoryObject object = programBuilder.getLocFromReg(reg); if (object != null) { - event.addTags(object.getMemorySpace()); + event.addTags(object.getFeatureTags()); } } else if (address instanceof BinaryExpressionBase binExpr) { // TODO: Convert memory space tags for binary expressions - addOpenCLMemorySpaceTag(event, binExpr.getLeft()); - addOpenCLMemorySpaceTag(event, binExpr.getRight()); - } - } - - private void addLocationAtomicityTag(Event event, Expression address) { - if (address instanceof Register reg) { - MemoryObject object = programBuilder.getLocFromReg(reg); - if (object != null && !object.isAtomic()) { - event.addTags(Tag.C11.NON_ATOMIC_LOCATION); - } + addMemoryObjectTags(event, binExpr.getLeft()); + addMemoryObjectTags(event, binExpr.getRight()); } } } 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 661af4a984..cb50070057 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 @@ -407,17 +407,17 @@ private void tagControl(Event e, Boolean atomic, String mo, String avvis, String // AV, VIS, and atomics M are all implicitly nonpriv if ((avvis.equals(Tag.Vulkan.AVAILABLE) || avvis.equals(Tag.Vulkan.VISIBLE) || atomic) && (e instanceof MemoryEvent)) { - e.addTags(Tag.GPU_SCOPES.NON_PRIVATE); + e.addTags(Tag.Vulkan.NON_PRIVATE); } // Atomics implicitly have AV/VIS ops, hence they are implicitly nonpriv if (atomic && e instanceof Store) { e.addTags(Tag.Vulkan.AVAILABLE); - e.addTags(Tag.GPU_SCOPES.NON_PRIVATE); + e.addTags(Tag.Vulkan.NON_PRIVATE); } if (atomic && e instanceof Load) { e.addTags(Tag.Vulkan.VISIBLE); - e.addTags(Tag.GPU_SCOPES.NON_PRIVATE); + e.addTags(Tag.Vulkan.NON_PRIVATE); } } } \ No newline at end of file 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 e373349e86..cf02ddd93f 100644 --- a/dartagnan/src/main/java/com/dat3m/dartagnan/program/ScopeHierarchy.java +++ b/dartagnan/src/main/java/com/dat3m/dartagnan/program/ScopeHierarchy.java @@ -17,26 +17,26 @@ private ScopeHierarchy() {} public static ScopeHierarchy ScopeHierarchyForVulkan(int queueFamily, int workGroup, int subGroup) { ScopeHierarchy scopeHierarchy = new ScopeHierarchy(); - scopeHierarchy.scopeIds.put(Tag.GPU_SCOPES.DEVICE, 0); - scopeHierarchy.scopeIds.put(Tag.GPU_SCOPES.QUEUE_FAMILY, queueFamily); - scopeHierarchy.scopeIds.put(Tag.GPU_SCOPES.WORK_GROUP, workGroup); - scopeHierarchy.scopeIds.put(Tag.GPU_SCOPES.SUB_GROUP, subGroup); + scopeHierarchy.scopeIds.put(Tag.Vulkan.DEVICE, 0); + scopeHierarchy.scopeIds.put(Tag.Vulkan.QUEUE_FAMILY, queueFamily); + scopeHierarchy.scopeIds.put(Tag.Vulkan.WORK_GROUP, workGroup); + scopeHierarchy.scopeIds.put(Tag.Vulkan.SUB_GROUP, subGroup); return scopeHierarchy; } public static ScopeHierarchy ScopeHierarchyForPTX(int gpu, int cta) { ScopeHierarchy scopeHierarchy = new ScopeHierarchy(); - scopeHierarchy.scopeIds.put(Tag.GPU_SCOPES.SYS, 0); - scopeHierarchy.scopeIds.put(Tag.GPU_SCOPES.GPU, gpu); - scopeHierarchy.scopeIds.put(Tag.GPU_SCOPES.CTA, cta); + scopeHierarchy.scopeIds.put(Tag.PTX.SYS, 0); + scopeHierarchy.scopeIds.put(Tag.PTX.GPU, gpu); + scopeHierarchy.scopeIds.put(Tag.PTX.CTA, cta); return scopeHierarchy; } public static ScopeHierarchy ScopeHierarchyForOpenCL(int dev, int wg) { ScopeHierarchy scopeHierarchy = new ScopeHierarchy(); - scopeHierarchy.scopeIds.put(Tag.GPU_SCOPES.ALL, 0); - scopeHierarchy.scopeIds.put(Tag.GPU_SCOPES.DEVICE, dev); - scopeHierarchy.scopeIds.put(Tag.GPU_SCOPES.WORK_GROUP, wg); + scopeHierarchy.scopeIds.put(Tag.OpenCL.ALL, 0); + scopeHierarchy.scopeIds.put(Tag.OpenCL.DEVICE, dev); + scopeHierarchy.scopeIds.put(Tag.OpenCL.WORK_GROUP, wg); return scopeHierarchy; } 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 073efe8e2e..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 @@ -12,9 +12,6 @@ import com.dat3m.dartagnan.program.Function; import com.dat3m.dartagnan.program.Register; import com.dat3m.dartagnan.program.event.arch.StoreExclusive; -import com.dat3m.dartagnan.program.event.arch.c11.C11Init; -import com.dat3m.dartagnan.program.event.arch.c11.OpenCLBarrier; -import com.dat3m.dartagnan.program.event.arch.c11.OpenCLInit; import com.dat3m.dartagnan.program.event.arch.ptx.PTXAtomCAS; import com.dat3m.dartagnan.program.event.arch.ptx.PTXAtomExch; import com.dat3m.dartagnan.program.event.arch.ptx.PTXAtomOp; @@ -138,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) { @@ -381,12 +380,6 @@ public static AtomicThreadFence newFence(String mo) { public static AtomicXchg newExchange(Register register, Expression address, Expression value, String mo) { return new AtomicXchg(register, address, value, mo); } - - public static C11Init newC11Init(MemoryObject base, int offset) { - final Expression address = offset == 0 ? base : - expressions.makeAdd(base, expressions.makeValue(offset, (IntegerType) base.getType())); - return new C11Init(base, offset, address); - } } // ============================================================================================= // =========================================== LLVM ============================================ @@ -810,23 +803,4 @@ public static SpirvRmwExtremum newSpirvRmwExtremum(Register register, Expression return new SpirvRmwExtremum(register, address, op, value, scope, tags); } } - - // ============================================================================================= - // =========================================== OpenCL ========================================== - // ============================================================================================= - public static class OpenCL { - private OpenCL() {} - - public static OpenCLInit newOpenCLInit(MemoryObject base, int offset) { - final Expression address = offset == 0 ? base : - expressions.makeAdd(base, expressions.makeValue(offset, (IntegerType) base.getType())); - return new OpenCLInit(base, offset, address); - } - - public static OpenCLBarrier newOpenCLBarrier(String name, Expression fenceId) { - return new OpenCLBarrier(name, fenceId); - } - - } - } \ 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 48f4f7ab73..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 @@ -1,7 +1,6 @@ package com.dat3m.dartagnan.program.event; import com.dat3m.dartagnan.program.event.arch.StoreExclusive; -import com.dat3m.dartagnan.program.event.arch.c11.OpenCLBarrier; import com.dat3m.dartagnan.program.event.arch.ptx.PTXAtomCAS; import com.dat3m.dartagnan.program.event.arch.ptx.PTXAtomExch; import com.dat3m.dartagnan.program.event.arch.ptx.PTXAtomOp; @@ -102,7 +101,6 @@ public interface EventVisitor { // ------------------ GPU Events ------------------ default T visitControlBarrier(ControlBarrier e) { return visitEvent(e); } - default T visitOpenCLBarrier(OpenCLBarrier e) { return visitEvent(e); } default T visitPtxRedOp(PTXRedOp e) { return visitMemEvent(e); } default T visitPtxAtomOp(PTXAtomOp e) { return visitMemEvent(e); } default T visitPtxAtomCAS(PTXAtomCAS e) { return visitMemEvent(e); } 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 765b2437d2..97c4b67d33 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 @@ -272,27 +272,13 @@ public static String extractLoadMo(String cMo) { } // ============================================================================================= - // ======================================= GPU Scopes ========================================== + // =========================================== PTX ============================================= // ============================================================================================= - public static final class GPU_SCOPES { - // PTX + public static final class PTX { + // Scopes public static final String CTA = "CTA"; public static final String GPU = "GPU"; public static final String SYS = "SYS"; - // Vulkan, OpenCL - public static final String WORK_ITEM = "WI"; - public static final String SUB_GROUP = "SG"; - public static final String WORK_GROUP = "WG"; - public static final String QUEUE_FAMILY = "QF"; - public static final String DEVICE = "DV"; - public static final String ALL = "ALL"; - public static final String NON_PRIVATE = "NONPRIV"; - } - - // ============================================================================================= - // =========================================== PTX ============================================= - // ============================================================================================= - public static final class PTX { // Memory orders public static final String WEAK = "WEAK"; public static final String RLX = "RLX"; // RELAXED @@ -329,7 +315,7 @@ public static String storeMO(String mo) { } public static List getScopeTags() { - return List.of(GPU_SCOPES.CTA, GPU_SCOPES.GPU, GPU_SCOPES.SYS); + return List.of(CTA, GPU, SYS); } } @@ -340,6 +326,12 @@ public static final class Vulkan { public static final String CBAR = "CBAR"; public static final String AVDEVICE = "AVDEVICE"; public static final String VISDEVICE = "VISDEVICE"; + // Scopes + public static final String SUB_GROUP = "SG"; + public static final String WORK_GROUP = "WG"; + public static final String QUEUE_FAMILY = "QF"; + public static final String DEVICE = "DV"; + public static final String NON_PRIVATE = "NONPRIV"; // Memory orders public static final String ATOM = "ATOM"; public static final String ACQUIRE = "ACQ"; @@ -357,7 +349,7 @@ public static final class Vulkan { public static final String SEMSC1 = "SEMSC1"; public static List getScopeTags() { - return List.of(GPU_SCOPES.SUB_GROUP, GPU_SCOPES.WORK_GROUP, GPU_SCOPES.QUEUE_FAMILY, GPU_SCOPES.DEVICE); + return List.of(SUB_GROUP, WORK_GROUP, QUEUE_FAMILY, DEVICE); } public static String loadMO(String mo) { @@ -379,6 +371,11 @@ 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"; @@ -386,17 +383,15 @@ public static final class OpenCL { // Barrier public static final String ENTRY_FENCE = "EF"; public static final String EXIT_FENCE = "XF"; - // Default Tags - public static final String DEFAULT_SCOPE = GPU_SCOPES.DEVICE; - public static final String DEFAULT_WEAK_SCOPE = GPU_SCOPES.WORK_ITEM; + public static final String DEFAULT_SCOPE = DEVICE; + public static final String DEFAULT_WEAK_SCOPE = WORK_ITEM; public static final String DEFAULT_MO = C11.MO_SC; public static final String DEFAULT_CPU_SPACE = GLOBAL_SPACE; public static final String DEFAULT_GPU_SPACE = GENERIC_SPACE; - public static List getScopeTags() { - return List.of(GPU_SCOPES.WORK_GROUP, GPU_SCOPES.DEVICE, GPU_SCOPES.ALL); + return List.of(WORK_GROUP, DEVICE, ALL); } public static List getSpaceTags() { diff --git a/dartagnan/src/main/java/com/dat3m/dartagnan/program/event/arch/c11/C11Init.java b/dartagnan/src/main/java/com/dat3m/dartagnan/program/event/arch/c11/C11Init.java deleted file mode 100644 index 149862e75c..0000000000 --- a/dartagnan/src/main/java/com/dat3m/dartagnan/program/event/arch/c11/C11Init.java +++ /dev/null @@ -1,17 +0,0 @@ -package com.dat3m.dartagnan.program.event.arch.c11; - -import com.dat3m.dartagnan.expression.Expression; -import com.dat3m.dartagnan.program.event.Tag; -import com.dat3m.dartagnan.program.event.core.Init; -import com.dat3m.dartagnan.program.memory.MemoryObject; - -public class C11Init extends Init { - public C11Init(MemoryObject b, int o, Expression address) { - super(b, o, address); - addTags(Tag.C11.NONATOMIC); // Every initial event is a nonatomic write of zero - if (!b.isAtomic()) { - addTags(Tag.C11.NON_ATOMIC_LOCATION); - } - } - -} diff --git a/dartagnan/src/main/java/com/dat3m/dartagnan/program/event/arch/c11/OpenCLBarrier.java b/dartagnan/src/main/java/com/dat3m/dartagnan/program/event/arch/c11/OpenCLBarrier.java deleted file mode 100644 index c4f354c462..0000000000 --- a/dartagnan/src/main/java/com/dat3m/dartagnan/program/event/arch/c11/OpenCLBarrier.java +++ /dev/null @@ -1,26 +0,0 @@ -package com.dat3m.dartagnan.program.event.arch.c11; - -import com.dat3m.dartagnan.program.event.EventVisitor; -import com.dat3m.dartagnan.program.event.core.ControlBarrier; -import com.dat3m.dartagnan.expression.Expression; - -public class OpenCLBarrier extends ControlBarrier { - - public OpenCLBarrier(String name, Expression id) { - super(name, id); - } - - private OpenCLBarrier(OpenCLBarrier other) { - super(other); - } - - @Override - public OpenCLBarrier getCopy() { - return new OpenCLBarrier(this); - } - - @Override - public T accept(EventVisitor visitor) { - return visitor.visitOpenCLBarrier(this); - } -} diff --git a/dartagnan/src/main/java/com/dat3m/dartagnan/program/event/arch/c11/OpenCLInit.java b/dartagnan/src/main/java/com/dat3m/dartagnan/program/event/arch/c11/OpenCLInit.java deleted file mode 100644 index 2a1175e21a..0000000000 --- a/dartagnan/src/main/java/com/dat3m/dartagnan/program/event/arch/c11/OpenCLInit.java +++ /dev/null @@ -1,14 +0,0 @@ -package com.dat3m.dartagnan.program.event.arch.c11; - -import com.dat3m.dartagnan.expression.Expression; -import com.dat3m.dartagnan.program.memory.MemoryObject; - -public class OpenCLInit extends C11Init { - public OpenCLInit(MemoryObject b, int o, Expression address) { - super(b, o, address); - if (b.getMemorySpace() != null) { - addTags(b.getMemorySpace()); - } - } - -} 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 ec312f6bd9..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,8 +30,7 @@ public class MemoryObject extends LeafExpressionBase { private String name = null; private boolean isThreadLocal = false; - private boolean isAtomic = false; - private String memorySpace = null; + private final Set featureTags = new HashSet<>(); private final Map initialValues = new TreeMap<>(); @@ -56,11 +52,8 @@ public class MemoryObject extends LeafExpressionBase { public boolean isThreadLocal() { return this.isThreadLocal; } public void setIsThreadLocal(boolean value) { this.isThreadLocal = value;} - public boolean isAtomic() { return this.isAtomic; } - public void setIsAtomic(boolean value) { this.isAtomic = value;} - - public String getMemorySpace() { return this.memorySpace; } - public void setMemorySpace(String value) { this.memorySpace = 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/CoreCodeVerification.java b/dartagnan/src/main/java/com/dat3m/dartagnan/program/processing/CoreCodeVerification.java index b8e4b52e40..bf5d1605fc 100644 --- a/dartagnan/src/main/java/com/dat3m/dartagnan/program/processing/CoreCodeVerification.java +++ b/dartagnan/src/main/java/com/dat3m/dartagnan/program/processing/CoreCodeVerification.java @@ -3,9 +3,6 @@ import com.dat3m.dartagnan.exception.MalformedProgramException; import com.dat3m.dartagnan.program.Function; import com.dat3m.dartagnan.program.event.Event; -import com.dat3m.dartagnan.program.event.arch.c11.C11Init; -import com.dat3m.dartagnan.program.event.arch.c11.OpenCLBarrier; -import com.dat3m.dartagnan.program.event.arch.c11.OpenCLInit; import com.dat3m.dartagnan.program.event.core.*; import com.dat3m.dartagnan.program.event.core.annotations.CodeAnnotation; import com.dat3m.dartagnan.program.event.core.threading.ThreadArgument; @@ -41,8 +38,7 @@ public static CoreCodeVerification fromConfig(Configuration config) { Assume.class, Assert.class, ThreadCreate.class, ThreadArgument.class, ThreadStart.class, ControlBarrier.class, // For PTX and Vulkan - BeginAtomic.class, EndAtomic.class, - C11Init.class, OpenCLInit.class, OpenCLBarrier.class // For OpenCL + BeginAtomic.class, EndAtomic.class // We add SVCOMP atomic blocks here as well, despite them not being part of the core package. // TODO: We might want to find a more systematic way to extend the core with these custom events. )); 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 5d7d2911d0..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 @@ -86,13 +86,7 @@ private void createInitEvents(Program program) { final String threadName = "Init_" + nextThreadId; final Thread thread = new Thread(threadName, initThreadType, paramNames, nextThreadId, EventFactory.newThreadStart(null)); - if (program.getArch().equals(Arch.C11)) { - thread.append(EventFactory.Atomic.newC11Init(memObj, field)); - } else if (program.getArch().equals(Arch.OPENCL)) { - thread.append(EventFactory.OpenCL.newOpenCLInit(memObj, field)); - } else { - thread.append(EventFactory.newInit(memObj, field)); - } + thread.append(EventFactory.newInit(memObj, field)); thread.append(EventFactory.newLabel("END_OF_T" + thread.getId())); program.addThread(thread); nextThreadId++; 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 5f027ce2ab..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,9 +121,8 @@ 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 OPENCL -> new VisitorOpenCL(); case TSO -> new VisitorTso(); case POWER -> new VisitorPower(useRC11Scheme, cToPowerScheme); case ARM8 -> new VisitorArm8(useRC11Scheme); 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/program/processing/compilation/VisitorOpenCL.java b/dartagnan/src/main/java/com/dat3m/dartagnan/program/processing/compilation/VisitorOpenCL.java deleted file mode 100644 index bef7e43bb2..0000000000 --- a/dartagnan/src/main/java/com/dat3m/dartagnan/program/processing/compilation/VisitorOpenCL.java +++ /dev/null @@ -1,137 +0,0 @@ -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.BooleanType; -import com.dat3m.dartagnan.expression.Type; -import com.dat3m.dartagnan.program.Register; -import com.dat3m.dartagnan.program.event.EventFactory; -import com.dat3m.dartagnan.program.event.Tag; -import com.dat3m.dartagnan.program.event.Tag.C11; -import com.dat3m.dartagnan.program.event.Event; -import com.dat3m.dartagnan.program.event.MemoryEvent; -import com.dat3m.dartagnan.program.event.arch.c11.OpenCLBarrier; -import com.dat3m.dartagnan.program.event.core.*; -import com.dat3m.dartagnan.program.event.core.RMWStore; -import com.dat3m.dartagnan.program.event.lang.catomic.*; -import com.dat3m.dartagnan.program.event.metadata.MemoryOrder; - -import java.util.List; - -import static com.dat3m.dartagnan.program.event.EventFactory.*; -import static com.dat3m.dartagnan.program.event.EventFactory.OpenCL.newOpenCLBarrier; - -public class VisitorOpenCL extends VisitorBase { - - @Override - public List visitAtomicCmpXchg(AtomicCmpXchg e) { - Register resultRegister = e.getResultRegister(); - Expression address = e.getAddress(); - String mo = e.getMo(); - Expression expectedAddr = e.getAddressOfExpected(); - Type type = resultRegister.getType(); - Register booleanResultRegister = type instanceof BooleanType ? resultRegister : - e.getFunction().newRegister(types.getBooleanType()); - Local castResult = type instanceof BooleanType ? null : - newLocal(resultRegister, expressions.makeCast(booleanResultRegister, type)); - Register regExpected = e.getFunction().newRegister(type); - Register regValue = e.getFunction().newRegister(type); - Load loadExpected = newLoad(regExpected, expectedAddr); - Store storeExpected = newStore(expectedAddr, regValue); - Label casFail = newLabel("CAS_fail"); - Label casEnd = newLabel("CAS_end"); - Local casCmpResult = newLocal(booleanResultRegister, expressions.makeEQ(regValue, regExpected)); - CondJump branchOnCasCmpResult = newJumpUnless(booleanResultRegister, casFail); - CondJump gotoCasEnd = newGoto(casEnd); - Load loadValue = newRMWLoadWithMo(regValue, address, mo); - Store storeValue = newRMWStoreWithMo(loadValue, address, e.getStoreValue(), mo); - - return tagList(e, eventSequence( - loadExpected, - loadValue, - casCmpResult, - branchOnCasCmpResult, - storeValue, - gotoCasEnd, - casFail, - storeExpected, - casEnd, - castResult - )); - } - - @Override - public List visitAtomicFetchOp(AtomicFetchOp e) { - Register resultRegister = e.getResultRegister(); - Expression address = e.getAddress(); - String mo = e.getMo(); - - Register dummyReg = e.getFunction().newRegister(resultRegister.getType()); - Load load = newRMWLoadWithMo(resultRegister, address, mo); - Local localOp = newLocal(dummyReg, expressions.makeBinary(resultRegister, e.getOperator(), e.getOperand())); - RMWStore store = newRMWStoreWithMo(load, address, dummyReg, mo); - - return tagList(e, eventSequence( - load, - localOp, - store - )); - } - - @Override - public List visitAtomicLoad(AtomicLoad e) { - return tagList(e, eventSequence( - newLoadWithMo(e.getResultRegister(), e.getAddress(), e.getMo()) - )); - } - - @Override - public List visitAtomicStore(AtomicStore e) { - return tagList(e, eventSequence( - newStoreWithMo(e.getAddress(), e.getMemValue(), e.getMo()) - )); - } - - @Override - public List visitAtomicThreadFence(AtomicThreadFence e) { - return tagList(e, eventSequence( - newFence(e.getMo()) - )); - } - - @Override - public List visitOpenCLBarrier(OpenCLBarrier 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, - newOpenCLBarrier(e.getName(), e.getId()), - exitFence - )); - } - - private List tagList(Event originalEvent, List in) { - in.forEach(e -> tagEvent(originalEvent, e)); - return in; - } - - private void tagEvent(Event originalEvent, Event e) { - 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); - } - if (!spaces.isEmpty()) { - e.addTags(spaces); - } - if (e instanceof MemoryEvent) { - final MemoryOrder mo = e.getMetadata(MemoryOrder.class); - final boolean canRace = mo == null || mo.value().equals(C11.NONATOMIC); - e.addTags(canRace ? C11.NONATOMIC : C11.ATOMIC); - } - } - } -} diff --git a/dartagnan/src/main/java/com/dat3m/dartagnan/program/processing/compilation/VisitorPTX.java b/dartagnan/src/main/java/com/dat3m/dartagnan/program/processing/compilation/VisitorPTX.java index b62d0e2b65..162118d376 100644 --- a/dartagnan/src/main/java/com/dat3m/dartagnan/program/processing/compilation/VisitorPTX.java +++ b/dartagnan/src/main/java/com/dat3m/dartagnan/program/processing/compilation/VisitorPTX.java @@ -93,7 +93,7 @@ public List visitPtxRedOp(PTXRedOp e) { } private void propagateTags(Event source, Event target) { - for (String tag : List.of(Tag.GPU_SCOPES.CTA, Tag.GPU_SCOPES.GPU, Tag.GPU_SCOPES.SYS, Tag.PTX.GEN, Tag.PTX.TEX, Tag.PTX.SUR, Tag.PTX.CON)) { + for (String tag : List.of(Tag.PTX.CTA, Tag.PTX.GPU, Tag.PTX.SYS, Tag.PTX.GEN, Tag.PTX.TEX, Tag.PTX.SUR, Tag.PTX.CON)) { if (source.hasTag(tag)) { target.addTags(tag); } diff --git a/dartagnan/src/main/java/com/dat3m/dartagnan/program/processing/compilation/VisitorSpirvVulkan.java b/dartagnan/src/main/java/com/dat3m/dartagnan/program/processing/compilation/VisitorSpirvVulkan.java index 9dd3cb5acf..80c84f028e 100644 --- a/dartagnan/src/main/java/com/dat3m/dartagnan/program/processing/compilation/VisitorSpirvVulkan.java +++ b/dartagnan/src/main/java/com/dat3m/dartagnan/program/processing/compilation/VisitorSpirvVulkan.java @@ -156,7 +156,7 @@ private Set toVulkanTags(Set tags) { private Set adjustVulkanTags(Set tags, Set vTags) { if (tags.contains(Tag.MEMORY) && toVulkanTag(Tag.Spirv.getStorageClassTag(tags)) != null) { - vTags.add(Tag.GPU_SCOPES.NON_PRIVATE); + vTags.add(Tag.Vulkan.NON_PRIVATE); if (vTags.contains(Tag.READ)) { vTags.add(Tag.Vulkan.VISIBLE); } @@ -206,21 +206,21 @@ private String toVulkanTag(String tag) { Tag.Spirv.SEQ_CST -> Tag.Vulkan.ACQ_REL; // Scope - case Tag.Spirv.SUBGROUP -> Tag.GPU_SCOPES.SUB_GROUP; - case Tag.Spirv.WORKGROUP -> Tag.GPU_SCOPES.WORK_GROUP; - case Tag.Spirv.QUEUE_FAMILY -> Tag.GPU_SCOPES.QUEUE_FAMILY; + case Tag.Spirv.SUBGROUP -> Tag.Vulkan.SUB_GROUP; + case Tag.Spirv.WORKGROUP -> Tag.Vulkan.WORK_GROUP; + case Tag.Spirv.QUEUE_FAMILY -> Tag.Vulkan.QUEUE_FAMILY; // TODO: Refactoring of the cat model // In the cat file AV/VISSHADER uses device domain, // and device domain is mapped to AV/VISDEVICE case Tag.Spirv.INVOCATION, Tag.Spirv.SHADER_CALL, Tag.Spirv.DEVICE, - Tag.Spirv.CROSS_DEVICE -> Tag.GPU_SCOPES.DEVICE; + Tag.Spirv.CROSS_DEVICE -> Tag.Vulkan.DEVICE; // Memory access (non-atomic) case Tag.Spirv.MEM_VOLATILE, Tag.Spirv.MEM_NONTEMPORAL -> null; - case Tag.Spirv.MEM_NON_PRIVATE -> Tag.GPU_SCOPES.NON_PRIVATE; + case Tag.Spirv.MEM_NON_PRIVATE -> Tag.Vulkan.NON_PRIVATE; case Tag.Spirv.MEM_AVAILABLE -> Tag.Vulkan.AVAILABLE; case Tag.Spirv.MEM_VISIBLE -> Tag.Vulkan.VISIBLE; diff --git a/dartagnan/src/main/java/com/dat3m/dartagnan/program/processing/compilation/VisitorVulkan.java b/dartagnan/src/main/java/com/dat3m/dartagnan/program/processing/compilation/VisitorVulkan.java index 2be02b290d..1ee857bbb8 100644 --- a/dartagnan/src/main/java/com/dat3m/dartagnan/program/processing/compilation/VisitorVulkan.java +++ b/dartagnan/src/main/java/com/dat3m/dartagnan/program/processing/compilation/VisitorVulkan.java @@ -95,8 +95,8 @@ public List visitVulkanCmpXchg(VulkanCmpXchg e) { } private void propagateTags(Event source, Event target) { - for (String tag : List.of(Tag.GPU_SCOPES.SUB_GROUP, Tag.GPU_SCOPES.WORK_GROUP, Tag.GPU_SCOPES.QUEUE_FAMILY, Tag.GPU_SCOPES.DEVICE, - Tag.GPU_SCOPES.NON_PRIVATE, Tag.Vulkan.ATOM, Tag.Vulkan.SC0, Tag.Vulkan.SC1, Tag.Vulkan.SEMSC0, Tag.Vulkan.SEMSC1)) { + for (String tag : List.of(Tag.Vulkan.SUB_GROUP, Tag.Vulkan.WORK_GROUP, Tag.Vulkan.QUEUE_FAMILY, Tag.Vulkan.DEVICE, + Tag.Vulkan.NON_PRIVATE, Tag.Vulkan.ATOM, Tag.Vulkan.SC0, Tag.Vulkan.SC1, Tag.Vulkan.SEMSC0, Tag.Vulkan.SEMSC1)) { if (source.hasTag(tag)) { target.addTags(tag); } 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 604ee928ff..61127ea495 100755 --- a/dartagnan/src/main/java/com/dat3m/dartagnan/wmm/Wmm.java +++ b/dartagnan/src/main/java/com/dat3m/dartagnan/wmm/Wmm.java @@ -221,11 +221,11 @@ private Relation makePredefinedRelation(String name) { yield intersection(r, comp, mv); } case SR -> new SameScope(r); - case SCTA -> new SameScope(r, Tag.GPU_SCOPES.CTA); - case SSG -> new SameScope(r, Tag.GPU_SCOPES.SUB_GROUP); - case SWG -> new SameScope(r, Tag.GPU_SCOPES.WORK_GROUP); - case SQF -> new SameScope(r, Tag.GPU_SCOPES.QUEUE_FAMILY); - case SDV -> new SameScope(r, Tag.GPU_SCOPES.DEVICE); + case SCTA -> new SameScope(r, Tag.PTX.CTA); + 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/program/processing/compilation/VisitorSpirvVulkanTest.java b/dartagnan/src/test/java/com/dat3m/dartagnan/program/processing/compilation/VisitorSpirvVulkanTest.java index d2c4853c93..20461a6ad8 100644 --- a/dartagnan/src/test/java/com/dat3m/dartagnan/program/processing/compilation/VisitorSpirvVulkanTest.java +++ b/dartagnan/src/test/java/com/dat3m/dartagnan/program/processing/compilation/VisitorSpirvVulkanTest.java @@ -40,15 +40,15 @@ public void testLoad() { ); doTestLoad( Set.of(Tag.Spirv.SC_WORKGROUP), - Set.of(Tag.Vulkan.SC1, Tag.GPU_SCOPES.NON_PRIVATE, Tag.Vulkan.VISIBLE) + Set.of(Tag.Vulkan.SC1, Tag.Vulkan.NON_PRIVATE, Tag.Vulkan.VISIBLE) ); doTestLoad( Set.of(Tag.Spirv.MEM_VISIBLE, Tag.Spirv.SC_UNIFORM), - Set.of(Tag.Vulkan.VISIBLE, Tag.Vulkan.SC0, Tag.GPU_SCOPES.NON_PRIVATE) + Set.of(Tag.Vulkan.VISIBLE, Tag.Vulkan.SC0, Tag.Vulkan.NON_PRIVATE) ); doTestLoad( Set.of(Tag.Spirv.MEM_VISIBLE, Tag.Spirv.DEVICE, Tag.Spirv.SC_UNIFORM), - Set.of(Tag.Vulkan.VISIBLE, Tag.GPU_SCOPES.DEVICE, Tag.Vulkan.VISDEVICE, Tag.Vulkan.SC0, Tag.GPU_SCOPES.NON_PRIVATE) + Set.of(Tag.Vulkan.VISIBLE, Tag.Vulkan.DEVICE, Tag.Vulkan.VISDEVICE, Tag.Vulkan.SC0, Tag.Vulkan.NON_PRIVATE) ); } @@ -77,15 +77,15 @@ public void testStore() { ); doTestStore( Set.of(Tag.Spirv.SC_WORKGROUP), - Set.of(Tag.Vulkan.SC1, Tag.GPU_SCOPES.NON_PRIVATE, Tag.Vulkan.AVAILABLE) + Set.of(Tag.Vulkan.SC1, Tag.Vulkan.NON_PRIVATE, Tag.Vulkan.AVAILABLE) ); doTestStore( Set.of(Tag.Spirv.MEM_AVAILABLE, Tag.Spirv.SC_UNIFORM), - Set.of(Tag.Vulkan.AVAILABLE, Tag.Vulkan.SC0, Tag.GPU_SCOPES.NON_PRIVATE) + Set.of(Tag.Vulkan.AVAILABLE, Tag.Vulkan.SC0, Tag.Vulkan.NON_PRIVATE) ); doTestStore( Set.of(Tag.Spirv.MEM_AVAILABLE, Tag.Spirv.DEVICE, Tag.Spirv.SC_UNIFORM), - Set.of(Tag.Vulkan.AVAILABLE, Tag.GPU_SCOPES.DEVICE, Tag.Vulkan.AVDEVICE, Tag.Vulkan.SC0, Tag.GPU_SCOPES.NON_PRIVATE) + Set.of(Tag.Vulkan.AVAILABLE, Tag.Vulkan.DEVICE, Tag.Vulkan.AVDEVICE, Tag.Vulkan.SC0, Tag.Vulkan.NON_PRIVATE) ); } @@ -110,23 +110,23 @@ private void doTestStore(Set spvTags, Set vulTags) { public void testSpirvLoad() { doTestSpirvLoad( Set.of(Tag.Spirv.RELAXED, Tag.Spirv.SUBGROUP, Tag.Spirv.SC_WORKGROUP), - Set.of(Tag.GPU_SCOPES.SUB_GROUP, Tag.Vulkan.SC1, Tag.GPU_SCOPES.NON_PRIVATE) + Set.of(Tag.Vulkan.SUB_GROUP, Tag.Vulkan.SC1, Tag.Vulkan.NON_PRIVATE) ); doTestSpirvLoad( Set.of(Tag.Spirv.SEQ_CST, Tag.Spirv.SUBGROUP, Tag.Spirv.SC_WORKGROUP), - Set.of(Tag.Vulkan.ACQUIRE, Tag.GPU_SCOPES.SUB_GROUP, Tag.Vulkan.SC1, Tag.GPU_SCOPES.NON_PRIVATE) + Set.of(Tag.Vulkan.ACQUIRE, Tag.Vulkan.SUB_GROUP, Tag.Vulkan.SC1, Tag.Vulkan.NON_PRIVATE) ); doTestSpirvLoad( Set.of(Tag.Spirv.ACQUIRE, Tag.Spirv.WORKGROUP, Tag.Spirv.SC_WORKGROUP), - Set.of(Tag.Vulkan.ACQUIRE, Tag.GPU_SCOPES.WORK_GROUP, Tag.Vulkan.SC1, Tag.GPU_SCOPES.NON_PRIVATE) + Set.of(Tag.Vulkan.ACQUIRE, Tag.Vulkan.WORK_GROUP, Tag.Vulkan.SC1, Tag.Vulkan.NON_PRIVATE) ); doTestSpirvLoad( Set.of(Tag.Spirv.ACQUIRE, Tag.Spirv.WORKGROUP, Tag.Spirv.SEM_UNIFORM, Tag.Spirv.SEM_VISIBLE, Tag.Spirv.SC_UNIFORM), - Set.of(Tag.Vulkan.ACQUIRE, Tag.GPU_SCOPES.WORK_GROUP, Tag.Vulkan.SEMSC0, Tag.Vulkan.SEM_VISIBLE, Tag.Vulkan.SC0, Tag.GPU_SCOPES.NON_PRIVATE) + Set.of(Tag.Vulkan.ACQUIRE, Tag.Vulkan.WORK_GROUP, Tag.Vulkan.SEMSC0, Tag.Vulkan.SEM_VISIBLE, Tag.Vulkan.SC0, Tag.Vulkan.NON_PRIVATE) ); doTestSpirvLoad( Set.of(Tag.Spirv.RELAXED, Tag.Spirv.DEVICE, Tag.Spirv.SC_UNIFORM), - Set.of(Tag.GPU_SCOPES.DEVICE, Tag.Vulkan.VISDEVICE, Tag.Vulkan.SC0, Tag.GPU_SCOPES.NON_PRIVATE) + Set.of(Tag.Vulkan.DEVICE, Tag.Vulkan.VISDEVICE, Tag.Vulkan.SC0, Tag.Vulkan.NON_PRIVATE) ); } @@ -145,7 +145,7 @@ private void doTestSpirvLoad(Set spvTags, Set vulTags) { assertEquals(1, seq.size()); Load load = (Load) seq.get(0); Set baseTags = Set.of(Tag.VISIBLE, Tag.MEMORY, Tag.READ, Tag.Vulkan.ATOM, - Tag.Vulkan.VISIBLE, Tag.GPU_SCOPES.NON_PRIVATE); + Tag.Vulkan.VISIBLE, Tag.Vulkan.NON_PRIVATE); assertEquals(Sets.union(baseTags, vulTags), load.getTags()); } @@ -153,23 +153,23 @@ private void doTestSpirvLoad(Set spvTags, Set vulTags) { public void testSpirvStore() { doTestSpirvStore( Set.of(Tag.Spirv.RELAXED, Tag.Spirv.SUBGROUP, Tag.Spirv.SC_WORKGROUP), - Set.of(Tag.GPU_SCOPES.SUB_GROUP, Tag.Vulkan.SC1, Tag.GPU_SCOPES.NON_PRIVATE) + Set.of(Tag.Vulkan.SUB_GROUP, Tag.Vulkan.SC1, Tag.Vulkan.NON_PRIVATE) ); doTestSpirvStore( Set.of(Tag.Spirv.SEQ_CST, Tag.Spirv.SUBGROUP, Tag.Spirv.SC_WORKGROUP), - Set.of(Tag.Vulkan.RELEASE, Tag.GPU_SCOPES.SUB_GROUP, Tag.Vulkan.SC1, Tag.GPU_SCOPES.NON_PRIVATE) + Set.of(Tag.Vulkan.RELEASE, Tag.Vulkan.SUB_GROUP, Tag.Vulkan.SC1, Tag.Vulkan.NON_PRIVATE) ); doTestSpirvStore( Set.of(Tag.Spirv.RELEASE, Tag.Spirv.WORKGROUP, Tag.Spirv.SC_WORKGROUP), - Set.of(Tag.Vulkan.RELEASE, Tag.GPU_SCOPES.WORK_GROUP, Tag.Vulkan.SC1, Tag.GPU_SCOPES.NON_PRIVATE) + Set.of(Tag.Vulkan.RELEASE, Tag.Vulkan.WORK_GROUP, Tag.Vulkan.SC1, Tag.Vulkan.NON_PRIVATE) ); doTestSpirvStore( Set.of(Tag.Spirv.RELEASE, Tag.Spirv.WORKGROUP, Tag.Spirv.SEM_UNIFORM, Tag.Spirv.SEM_AVAILABLE, Tag.Spirv.SC_UNIFORM), - Set.of(Tag.Vulkan.RELEASE, Tag.GPU_SCOPES.WORK_GROUP, Tag.Vulkan.SEMSC0, Tag.Vulkan.SEM_AVAILABLE, Tag.Vulkan.SC0, Tag.GPU_SCOPES.NON_PRIVATE) + Set.of(Tag.Vulkan.RELEASE, Tag.Vulkan.WORK_GROUP, Tag.Vulkan.SEMSC0, Tag.Vulkan.SEM_AVAILABLE, Tag.Vulkan.SC0, Tag.Vulkan.NON_PRIVATE) ); doTestSpirvStore( Set.of(Tag.Spirv.RELAXED, Tag.Spirv.DEVICE, Tag.Spirv.SC_UNIFORM), - Set.of(Tag.GPU_SCOPES.DEVICE, Tag.Vulkan.AVDEVICE, Tag.Vulkan.SC0, Tag.GPU_SCOPES.NON_PRIVATE) + Set.of(Tag.Vulkan.DEVICE, Tag.Vulkan.AVDEVICE, Tag.Vulkan.SC0, Tag.Vulkan.NON_PRIVATE) ); } @@ -188,7 +188,7 @@ private void doTestSpirvStore(Set spvTags, Set vulTags) { assertEquals(1, seq.size()); Store store = (Store) seq.get(0); Set baseTags = Set.of(Tag.VISIBLE, Tag.MEMORY, Tag.WRITE, Tag.Vulkan.ATOM, - Tag.Vulkan.AVAILABLE, Tag.GPU_SCOPES.NON_PRIVATE); + Tag.Vulkan.AVAILABLE, Tag.Vulkan.NON_PRIVATE); assertEquals(Sets.union(baseTags, vulTags), store.getTags()); } @@ -196,33 +196,33 @@ private void doTestSpirvStore(Set spvTags, Set vulTags) { public void testSpirvXchg() { doTestSpirvXchg( Set.of(Tag.Spirv.RELAXED, Tag.Spirv.SUBGROUP, Tag.Spirv.SC_WORKGROUP), - Set.of(Tag.GPU_SCOPES.SUB_GROUP, Tag.Vulkan.SC1, Tag.GPU_SCOPES.NON_PRIVATE), - Set.of(Tag.GPU_SCOPES.SUB_GROUP, Tag.Vulkan.SC1, Tag.GPU_SCOPES.NON_PRIVATE) + Set.of(Tag.Vulkan.SUB_GROUP, Tag.Vulkan.SC1, Tag.Vulkan.NON_PRIVATE), + Set.of(Tag.Vulkan.SUB_GROUP, Tag.Vulkan.SC1, Tag.Vulkan.NON_PRIVATE) ); doTestSpirvXchg( Set.of(Tag.Spirv.ACQUIRE, Tag.Spirv.WORKGROUP, Tag.Spirv.SC_WORKGROUP), - Set.of(Tag.Vulkan.ACQUIRE, Tag.GPU_SCOPES.WORK_GROUP, Tag.Vulkan.SC1, Tag.GPU_SCOPES.NON_PRIVATE), - Set.of(Tag.GPU_SCOPES.WORK_GROUP, Tag.Vulkan.SC1, Tag.GPU_SCOPES.NON_PRIVATE) + Set.of(Tag.Vulkan.ACQUIRE, Tag.Vulkan.WORK_GROUP, Tag.Vulkan.SC1, Tag.Vulkan.NON_PRIVATE), + Set.of(Tag.Vulkan.WORK_GROUP, Tag.Vulkan.SC1, Tag.Vulkan.NON_PRIVATE) ); doTestSpirvXchg( Set.of(Tag.Spirv.RELEASE, Tag.Spirv.WORKGROUP, Tag.Spirv.SC_WORKGROUP), - Set.of(Tag.GPU_SCOPES.WORK_GROUP, Tag.Vulkan.SC1, Tag.GPU_SCOPES.NON_PRIVATE), - Set.of(Tag.Vulkan.RELEASE, Tag.GPU_SCOPES.WORK_GROUP, Tag.Vulkan.SC1, Tag.GPU_SCOPES.NON_PRIVATE) + Set.of(Tag.Vulkan.WORK_GROUP, Tag.Vulkan.SC1, Tag.Vulkan.NON_PRIVATE), + Set.of(Tag.Vulkan.RELEASE, Tag.Vulkan.WORK_GROUP, Tag.Vulkan.SC1, Tag.Vulkan.NON_PRIVATE) ); doTestSpirvXchg( Set.of(Tag.Spirv.ACQ_REL, Tag.Spirv.WORKGROUP, Tag.Spirv.SC_WORKGROUP), - Set.of(Tag.Vulkan.ACQUIRE, Tag.GPU_SCOPES.WORK_GROUP, Tag.Vulkan.SC1, Tag.GPU_SCOPES.NON_PRIVATE), - Set.of(Tag.Vulkan.RELEASE, Tag.GPU_SCOPES.WORK_GROUP, Tag.Vulkan.SC1, Tag.GPU_SCOPES.NON_PRIVATE) + Set.of(Tag.Vulkan.ACQUIRE, Tag.Vulkan.WORK_GROUP, Tag.Vulkan.SC1, Tag.Vulkan.NON_PRIVATE), + Set.of(Tag.Vulkan.RELEASE, Tag.Vulkan.WORK_GROUP, Tag.Vulkan.SC1, Tag.Vulkan.NON_PRIVATE) ); doTestSpirvXchg( Set.of(Tag.Spirv.SEQ_CST, Tag.Spirv.WORKGROUP, Tag.Spirv.SC_WORKGROUP), - Set.of(Tag.Vulkan.ACQUIRE, Tag.GPU_SCOPES.WORK_GROUP, Tag.Vulkan.SC1, Tag.GPU_SCOPES.NON_PRIVATE), - Set.of(Tag.Vulkan.RELEASE, Tag.GPU_SCOPES.WORK_GROUP, Tag.Vulkan.SC1, Tag.GPU_SCOPES.NON_PRIVATE) + Set.of(Tag.Vulkan.ACQUIRE, Tag.Vulkan.WORK_GROUP, Tag.Vulkan.SC1, Tag.Vulkan.NON_PRIVATE), + Set.of(Tag.Vulkan.RELEASE, Tag.Vulkan.WORK_GROUP, Tag.Vulkan.SC1, Tag.Vulkan.NON_PRIVATE) ); doTestSpirvXchg( Set.of(Tag.Spirv.RELAXED, Tag.Spirv.DEVICE, Tag.Spirv.SC_WORKGROUP), - Set.of(Tag.GPU_SCOPES.DEVICE, Tag.Vulkan.VISDEVICE, Tag.Vulkan.SC1, Tag.GPU_SCOPES.NON_PRIVATE), - Set.of(Tag.GPU_SCOPES.DEVICE, Tag.Vulkan.AVDEVICE, Tag.Vulkan.SC1, Tag.GPU_SCOPES.NON_PRIVATE) + Set.of(Tag.Vulkan.DEVICE, Tag.Vulkan.VISDEVICE, Tag.Vulkan.SC1, Tag.Vulkan.NON_PRIVATE), + Set.of(Tag.Vulkan.DEVICE, Tag.Vulkan.AVDEVICE, Tag.Vulkan.SC1, Tag.Vulkan.NON_PRIVATE) ); } @@ -243,11 +243,11 @@ private void doTestSpirvXchg(Set spvTags, Set loadTags, Set baseLoadTags = Set.of(Tag.VISIBLE, Tag.MEMORY, Tag.READ, Tag.RMW, Tag.Vulkan.ATOM, - Tag.Vulkan.VISIBLE, Tag.GPU_SCOPES.NON_PRIVATE); + Tag.Vulkan.VISIBLE, Tag.Vulkan.NON_PRIVATE); assertEquals(Sets.union(baseLoadTags, loadTags), load.getTags()); Store store = (Store) seq.get(1); Set baseStoreTags = Set.of(Tag.VISIBLE, Tag.MEMORY, Tag.WRITE, Tag.RMW, Tag.Vulkan.ATOM, - Tag.Vulkan.AVAILABLE, Tag.GPU_SCOPES.NON_PRIVATE); + Tag.Vulkan.AVAILABLE, Tag.Vulkan.NON_PRIVATE); assertEquals(Sets.union(baseStoreTags, storeTags), store.getTags()); Local local = (Local) seq.get(2); assertEquals(register, local.getResultRegister()); @@ -257,33 +257,33 @@ private void doTestSpirvXchg(Set spvTags, Set loadTags, Set spvTags, Set loadTags, Set baseLoadTags = Set.of(Tag.VISIBLE, Tag.MEMORY, Tag.READ, Tag.RMW, Tag.Vulkan.ATOM, - Tag.Vulkan.VISIBLE, Tag.GPU_SCOPES.NON_PRIVATE); + Tag.Vulkan.VISIBLE, Tag.Vulkan.NON_PRIVATE); assertEquals(Sets.union(baseLoadTags, loadTags), load.getTags()); Store store = (Store) seq.get(1); Set baseStoreTags = Set.of(Tag.VISIBLE, Tag.MEMORY, Tag.WRITE, Tag.RMW, Tag.Vulkan.ATOM, - Tag.Vulkan.AVAILABLE, Tag.GPU_SCOPES.NON_PRIVATE); + Tag.Vulkan.AVAILABLE, Tag.Vulkan.NON_PRIVATE); assertEquals(Sets.union(baseStoreTags, storeTags), store.getTags()); Local local = (Local) seq.get(2); assertEquals(register, local.getResultRegister()); @@ -320,38 +320,38 @@ public void testSpirvCmpXchg() { Tag.Spirv.WORKGROUP, Set.of(Tag.Spirv.RELAXED, Tag.Spirv.SC_WORKGROUP), Set.of(Tag.Spirv.RELAXED, Tag.Spirv.SC_WORKGROUP), - Set.of(Tag.GPU_SCOPES.WORK_GROUP, Tag.Vulkan.SC1, Tag.GPU_SCOPES.NON_PRIVATE), - Set.of(Tag.GPU_SCOPES.WORK_GROUP, Tag.Vulkan.SC1, Tag.GPU_SCOPES.NON_PRIVATE)); + Set.of(Tag.Vulkan.WORK_GROUP, Tag.Vulkan.SC1, Tag.Vulkan.NON_PRIVATE), + Set.of(Tag.Vulkan.WORK_GROUP, Tag.Vulkan.SC1, Tag.Vulkan.NON_PRIVATE)); doTestSpirvCmpXchg( Tag.Spirv.WORKGROUP, Set.of(Tag.Spirv.ACQUIRE, Tag.Spirv.SC_WORKGROUP), Set.of(Tag.Spirv.ACQUIRE, Tag.Spirv.SC_WORKGROUP), - Set.of(Tag.Vulkan.ACQUIRE, Tag.GPU_SCOPES.WORK_GROUP, Tag.Vulkan.SC1, Tag.GPU_SCOPES.NON_PRIVATE), - Set.of(Tag.GPU_SCOPES.WORK_GROUP, Tag.Vulkan.SC1, Tag.GPU_SCOPES.NON_PRIVATE)); + Set.of(Tag.Vulkan.ACQUIRE, Tag.Vulkan.WORK_GROUP, Tag.Vulkan.SC1, Tag.Vulkan.NON_PRIVATE), + Set.of(Tag.Vulkan.WORK_GROUP, Tag.Vulkan.SC1, Tag.Vulkan.NON_PRIVATE)); doTestSpirvCmpXchg( Tag.Spirv.WORKGROUP, Set.of(Tag.Spirv.RELEASE, Tag.Spirv.SC_WORKGROUP), Set.of(Tag.Spirv.RELAXED, Tag.Spirv.SC_WORKGROUP), - Set.of(Tag.GPU_SCOPES.WORK_GROUP, Tag.Vulkan.SC1, Tag.GPU_SCOPES.NON_PRIVATE), - Set.of(Tag.Vulkan.RELEASE, Tag.GPU_SCOPES.WORK_GROUP, Tag.Vulkan.SC1, Tag.GPU_SCOPES.NON_PRIVATE)); + Set.of(Tag.Vulkan.WORK_GROUP, Tag.Vulkan.SC1, Tag.Vulkan.NON_PRIVATE), + Set.of(Tag.Vulkan.RELEASE, Tag.Vulkan.WORK_GROUP, Tag.Vulkan.SC1, Tag.Vulkan.NON_PRIVATE)); doTestSpirvCmpXchg( Tag.Spirv.WORKGROUP, Set.of(Tag.Spirv.ACQ_REL, Tag.Spirv.SC_WORKGROUP), Set.of(Tag.Spirv.ACQUIRE, Tag.Spirv.SC_WORKGROUP), - Set.of(Tag.Vulkan.ACQUIRE, Tag.GPU_SCOPES.WORK_GROUP, Tag.Vulkan.SC1, Tag.GPU_SCOPES.NON_PRIVATE), - Set.of(Tag.Vulkan.RELEASE, Tag.GPU_SCOPES.WORK_GROUP, Tag.Vulkan.SC1, Tag.GPU_SCOPES.NON_PRIVATE)); + Set.of(Tag.Vulkan.ACQUIRE, Tag.Vulkan.WORK_GROUP, Tag.Vulkan.SC1, Tag.Vulkan.NON_PRIVATE), + Set.of(Tag.Vulkan.RELEASE, Tag.Vulkan.WORK_GROUP, Tag.Vulkan.SC1, Tag.Vulkan.NON_PRIVATE)); doTestSpirvCmpXchg( Tag.Spirv.WORKGROUP, Set.of(Tag.Spirv.SEQ_CST, Tag.Spirv.SC_WORKGROUP), Set.of(Tag.Spirv.ACQUIRE, Tag.Spirv.SC_WORKGROUP), - Set.of(Tag.Vulkan.ACQUIRE, Tag.GPU_SCOPES.WORK_GROUP, Tag.Vulkan.SC1, Tag.GPU_SCOPES.NON_PRIVATE), - Set.of(Tag.Vulkan.RELEASE, Tag.GPU_SCOPES.WORK_GROUP, Tag.Vulkan.SC1, Tag.GPU_SCOPES.NON_PRIVATE)); + Set.of(Tag.Vulkan.ACQUIRE, Tag.Vulkan.WORK_GROUP, Tag.Vulkan.SC1, Tag.Vulkan.NON_PRIVATE), + Set.of(Tag.Vulkan.RELEASE, Tag.Vulkan.WORK_GROUP, Tag.Vulkan.SC1, Tag.Vulkan.NON_PRIVATE)); doTestSpirvCmpXchg( Tag.Spirv.DEVICE, Set.of(Tag.Spirv.RELAXED, Tag.Spirv.SC_WORKGROUP), Set.of(Tag.Spirv.RELAXED, Tag.Spirv.SC_WORKGROUP), - Set.of(Tag.GPU_SCOPES.DEVICE, Tag.Vulkan.VISDEVICE, Tag.Vulkan.SC1, Tag.GPU_SCOPES.NON_PRIVATE), - Set.of(Tag.GPU_SCOPES.DEVICE, Tag.Vulkan.AVDEVICE, Tag.Vulkan.SC1, Tag.GPU_SCOPES.NON_PRIVATE)); + Set.of(Tag.Vulkan.DEVICE, Tag.Vulkan.VISDEVICE, Tag.Vulkan.SC1, Tag.Vulkan.NON_PRIVATE), + Set.of(Tag.Vulkan.DEVICE, Tag.Vulkan.AVDEVICE, Tag.Vulkan.SC1, Tag.Vulkan.NON_PRIVATE)); } private void doTestSpirvCmpXchg(String scope, Set eqTags, Set neqTags, Set loadTags, Set storeTags) { @@ -371,11 +371,11 @@ private void doTestSpirvCmpXchg(String scope, Set eqTags, Set ne assertEquals(5, seq.size()); Load load = (Load) seq.get(0); Set baseLoadTags = Set.of(Tag.VISIBLE, Tag.MEMORY, Tag.READ, Tag.RMW, - Tag.Vulkan.ATOM, Tag.Vulkan.VISIBLE, Tag.GPU_SCOPES.NON_PRIVATE); + Tag.Vulkan.ATOM, Tag.Vulkan.VISIBLE, Tag.Vulkan.NON_PRIVATE); assertEquals(Sets.union(baseLoadTags, loadTags), load.getTags()); Store store = (Store) seq.get(3); Set baseStoreTags = Set.of(Tag.VISIBLE, Tag.MEMORY, Tag.WRITE, Tag.RMW, - Tag.Vulkan.ATOM, Tag.Vulkan.AVAILABLE, Tag.GPU_SCOPES.NON_PRIVATE); + Tag.Vulkan.ATOM, Tag.Vulkan.AVAILABLE, Tag.Vulkan.NON_PRIVATE); assertEquals(Sets.union(baseStoreTags, storeTags), store.getTags()); } @@ -424,23 +424,23 @@ private void doTestSpirvCmpXchgIllegal(Set eqTags, Set neqTags, public void testSpirvMemoryBarrier() { doTestSpirvMemoryBarrier( Set.of(Tag.Spirv.RELAXED, Tag.Spirv.SUBGROUP), - Set.of(Tag.GPU_SCOPES.SUB_GROUP) + Set.of(Tag.Vulkan.SUB_GROUP) ); doTestSpirvMemoryBarrier( Set.of(Tag.Spirv.ACQUIRE, Tag.Spirv.SUBGROUP), - Set.of(Tag.Vulkan.ACQUIRE, Tag.GPU_SCOPES.SUB_GROUP) + Set.of(Tag.Vulkan.ACQUIRE, Tag.Vulkan.SUB_GROUP) ); doTestSpirvMemoryBarrier( Set.of(Tag.Spirv.RELEASE, Tag.Spirv.SUBGROUP), - Set.of(Tag.Vulkan.RELEASE, Tag.GPU_SCOPES.SUB_GROUP) + Set.of(Tag.Vulkan.RELEASE, Tag.Vulkan.SUB_GROUP) ); doTestSpirvMemoryBarrier( Set.of(Tag.Spirv.ACQ_REL, Tag.Spirv.SUBGROUP), - Set.of(Tag.Vulkan.ACQUIRE, Tag.Vulkan.RELEASE, Tag.GPU_SCOPES.SUB_GROUP) + Set.of(Tag.Vulkan.ACQUIRE, Tag.Vulkan.RELEASE, Tag.Vulkan.SUB_GROUP) ); doTestSpirvMemoryBarrier( Set.of(Tag.Spirv.SEQ_CST, Tag.Spirv.SUBGROUP), - Set.of(Tag.Vulkan.ACQUIRE, Tag.Vulkan.RELEASE, Tag.GPU_SCOPES.SUB_GROUP) + Set.of(Tag.Vulkan.ACQUIRE, Tag.Vulkan.RELEASE, Tag.Vulkan.SUB_GROUP) ); } @@ -467,23 +467,23 @@ public void testSpirvControlBarrier() { ); doTestSpirvControlBarrier( Set.of(Tag.Spirv.RELAXED, Tag.Spirv.SUBGROUP), - Set.of(Tag.FENCE, Tag.GPU_SCOPES.SUB_GROUP) + Set.of(Tag.FENCE, Tag.Vulkan.SUB_GROUP) ); doTestSpirvControlBarrier( Set.of(Tag.Spirv.ACQUIRE, Tag.Spirv.SUBGROUP), - Set.of(Tag.FENCE, Tag.Vulkan.ACQUIRE, Tag.GPU_SCOPES.SUB_GROUP) + Set.of(Tag.FENCE, Tag.Vulkan.ACQUIRE, Tag.Vulkan.SUB_GROUP) ); doTestSpirvControlBarrier( Set.of(Tag.Spirv.RELEASE, Tag.Spirv.SUBGROUP), - Set.of(Tag.FENCE, Tag.Vulkan.RELEASE, Tag.GPU_SCOPES.SUB_GROUP) + Set.of(Tag.FENCE, Tag.Vulkan.RELEASE, Tag.Vulkan.SUB_GROUP) ); doTestSpirvControlBarrier( Set.of(Tag.Spirv.ACQ_REL, Tag.Spirv.SUBGROUP), - Set.of(Tag.FENCE, Tag.Vulkan.ACQUIRE, Tag.Vulkan.RELEASE, Tag.GPU_SCOPES.SUB_GROUP) + Set.of(Tag.FENCE, Tag.Vulkan.ACQUIRE, Tag.Vulkan.RELEASE, Tag.Vulkan.SUB_GROUP) ); doTestSpirvControlBarrier( Set.of(Tag.Spirv.SEQ_CST, Tag.Spirv.SUBGROUP), - Set.of(Tag.FENCE, Tag.Vulkan.ACQUIRE, Tag.Vulkan.RELEASE, Tag.GPU_SCOPES.SUB_GROUP) + Set.of(Tag.FENCE, Tag.Vulkan.ACQUIRE, Tag.Vulkan.RELEASE, Tag.Vulkan.SUB_GROUP) ); } 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 965fbc9cfa..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.GPU_SCOPES.*; 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)); } } From 533d214b27c51d0a275de31c3d6eb962eb523d88 Mon Sep 17 00:00:00 2001 From: haining Date: Tue, 1 Oct 2024 16:57:41 +0300 Subject: [PATCH 20/23] update tag to expressions --- .../parsers/program/visitors/VisitorLitmusC.java | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) 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 ccf0c6c0a7..83862cf514 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 @@ -2,9 +2,9 @@ import com.dat3m.dartagnan.configuration.Arch; import com.dat3m.dartagnan.exception.ParsingException; +import com.dat3m.dartagnan.expression.BinaryExpression; import com.dat3m.dartagnan.expression.Expression; import com.dat3m.dartagnan.expression.ExpressionFactory; -import com.dat3m.dartagnan.expression.base.BinaryExpressionBase; import com.dat3m.dartagnan.expression.integers.IntLiteral; import com.dat3m.dartagnan.expression.type.IntegerType; import com.dat3m.dartagnan.expression.type.TypeFactory; @@ -741,10 +741,10 @@ private void addMemoryObjectTags(Event event, Expression address) { if (object != null) { event.addTags(object.getFeatureTags()); } - } else if (address instanceof BinaryExpressionBase binExpr) { - // TODO: Convert memory space tags for binary expressions - addMemoryObjectTags(event, binExpr.getLeft()); - addMemoryObjectTags(event, binExpr.getRight()); + } else { + for (Expression add : address.getOperands()) { + addMemoryObjectTags(event, add); + } } } } From a02dbd274c368611a28b11e999b69f1bf67e76af Mon Sep 17 00:00:00 2001 From: Haining Date: Wed, 2 Oct 2024 10:28:49 +0300 Subject: [PATCH 21/23] remove .cl --- .../parsers/program/ProgramParser.java | 8 ++---- .../parsers/program/utils/Compilation.java | 28 ++----------------- 2 files changed, 6 insertions(+), 30 deletions(-) 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 d98cca549e..43cec38698 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 @@ -9,7 +9,6 @@ import static com.dat3m.dartagnan.parsers.program.utils.Compilation.applyLlvmPasses; import static com.dat3m.dartagnan.parsers.program.utils.Compilation.compileWithClang; -import static com.dat3m.dartagnan.parsers.program.utils.Compilation.applyDemangling;; public class ProgramParser { @@ -25,7 +24,6 @@ public Program parse(File file) throws Exception { if (needsClang(file)) { file = compileWithClang(file, ""); file = applyLlvmPasses(file); - file = applyDemangling(file); return new ProgramParser().parse(file); } @@ -40,15 +38,15 @@ public Program parse(File file) throws Exception { } private boolean needsClang(File f) { - return f.getPath().endsWith(".c") || f.getPath().endsWith(".i") || f.getPath().endsWith(".cl"); + return f.getPath().endsWith(".c") || f.getPath().endsWith(".i"); } public Program parse(String raw, String path, String format, String cflags) throws Exception { switch (format) { - case "c", "i", "cl" -> { + case "c", "i" -> { File file = path.isEmpty() ? // This is for the case where the user fully typed the program instead of loading it - File.createTempFile("dat3m", format) : + File.createTempFile("dat3m", ".c") : // This is for the case where the user loaded the program new File(path, "dat3m.c"); try (FileWriter writer = new FileWriter(file)) { diff --git a/dartagnan/src/main/java/com/dat3m/dartagnan/parsers/program/utils/Compilation.java b/dartagnan/src/main/java/com/dat3m/dartagnan/parsers/program/utils/Compilation.java index 5b2c89f199..256c4a507d 100644 --- a/dartagnan/src/main/java/com/dat3m/dartagnan/parsers/program/utils/Compilation.java +++ b/dartagnan/src/main/java/com/dat3m/dartagnan/parsers/program/utils/Compilation.java @@ -54,47 +54,25 @@ public static File applyLlvmPasses(File file) throws IOException { return new File(outputFileName); } - public static File applyDemangling(File file) throws IOException { - final File outputFile = new File(getOutputName(file, "-dmg.ll")); - ArrayList cmd = new ArrayList<>(); - cmd.add("llvm-cxxfilt"); - try { - runCmd(cmd, file, outputFile); - } catch (Exception e) { - logger.warn("Failed to run llvm-cxxfilt (llvm symbol name demangler). Continuing without demangling."); - return file; - } - return outputFile; - } - private static String getOutputName(File file, String postfix) throws IOException { return getOrCreateOutputDirectory() + "/" + file.getName().substring(0, file.getName().lastIndexOf('.')) + postfix; } private static void runCmd(ArrayList cmd) throws Exception { - runCmd(cmd, null, null); - } - - private static void runCmd(ArrayList cmd, File inputFile, File outputFile) throws Exception { logger.debug(String.join(" ", cmd)); ProcessBuilder processBuilder = new ProcessBuilder(cmd); - if(inputFile != null) { - processBuilder.redirectInput(inputFile); - } // "Unless the standard input and output streams are promptly written and read respectively // of the sub process, it may block or deadlock the sub process." // https://www.developer.com/design/understanding-java-process-and-java-processbuilder/ // The lines below take care of this. - if(outputFile == null) { - outputFile = File.createTempFile("log", null); - } + File log = File.createTempFile("log", null); processBuilder.redirectErrorStream(true); - processBuilder.redirectOutput(outputFile); + processBuilder.redirectOutput(log); Process proc = processBuilder.start(); proc.waitFor(); if(proc.exitValue() != 0) { - String errorString = Files.asCharSource(outputFile, Charsets.UTF_8).read(); + String errorString = Files.asCharSource(log, Charsets.UTF_8).read(); throw new IOException("'" + String.join("' '", cmd) + "': " + errorString); } } From 7821c1d4262537cdd78d7a8f18a178e63262a947 Mon Sep 17 00:00:00 2001 From: Haining Date: Wed, 2 Oct 2024 17:23:27 +0300 Subject: [PATCH 22/23] add thread scope setter --- .../parsers/program/utils/ProgramBuilder.java | 84 ++++++------------- .../program/visitors/VisitorLitmusC.java | 24 +++--- .../program/visitors/VisitorLitmusPTX.java | 2 +- .../program/visitors/VisitorLitmusVulkan.java | 2 +- .../com/dat3m/dartagnan/program/Thread.java | 6 +- 5 files changed, 43 insertions(+), 75 deletions(-) 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 9f1189ba44..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 @@ -7,7 +7,6 @@ import com.dat3m.dartagnan.expression.Type; import com.dat3m.dartagnan.expression.integers.IntLiteral; import com.dat3m.dartagnan.expression.type.FunctionType; -import com.dat3m.dartagnan.expression.type.IntegerType; import com.dat3m.dartagnan.expression.type.TypeFactory; import com.dat3m.dartagnan.program.*; import com.dat3m.dartagnan.program.Thread; @@ -46,10 +45,6 @@ public class ProgramBuilder { private final Map> fid2LabelsMap = new HashMap<>(); private final Map locations = new HashMap<>(); private final Map reg2LocMap = new HashMap<>(); - private final Map> id2RegTypeMap = new HashMap<>(); - private final Map> id2RegConstMap = new HashMap<>(); - private final Map> id2RegLocPtrMap = new HashMap<>(); - private final Map> id2RegLocValMap = new HashMap<>(); private final Program program; @@ -119,19 +114,13 @@ public void setAssertFilter(Expression ass) { // This method creates a "default" thread that has no parameters, no return value, and runs unconditionally. // It is only useful for creating threads of Litmus code. - public Thread newThread(int tid, Thread thread) { + public Thread newThread(String name, int tid) { + if(id2FunctionsMap.containsKey(tid)) { + throw new MalformedProgramException("Function or thread with id " + tid + " already exists."); + } + final Thread thread = new Thread(name, DEFAULT_THREAD_TYPE, List.of(), tid, EventFactory.newThreadStart(null)); id2FunctionsMap.put(tid, thread); program.addThread(thread); - if (id2RegConstMap.containsKey(tid)) { - id2RegConstMap.get(tid).forEach((regName, value) -> - initRegEqConst(tid, regName, value)); - } else if (id2RegLocPtrMap.containsKey(tid)) { - id2RegLocPtrMap.get(tid).forEach((regName, value) -> - initRegEqLocPtr(tid, regName, value, getRegType(tid, regName))); - } else if (id2RegLocValMap.containsKey(tid)) { - id2RegLocValMap.get(tid).forEach((regName, value) -> - initRegEqLocVal(tid, regName, value, getRegType(tid, regName))); - } return thread; } @@ -146,12 +135,8 @@ public Function newFunction(String name, int fid, FunctionType type, List new HashMap<>()).put(regName, type); - } - - public IntegerType getRegType(int tid, String regName) { - if (id2RegTypeMap.containsKey(tid) && id2RegTypeMap.get(tid).containsKey(regName)) { - return id2RegTypeMap.get(tid).get(regName); - } - throw new IllegalStateException("Register " + tid + ":" + regName + " is not initialised"); - } - - public void addRegToConstMap(int tid, String regName, Expression value) { - id2RegConstMap.computeIfAbsent(tid, k -> new HashMap<>()).put(regName, value); - } - - public void addRegToLocPtrMap(int tid, String regName, String locName) { - id2RegLocPtrMap.computeIfAbsent(tid, k -> new HashMap<>()).put(regName, locName); - } - - public void addRegToLocValMap(int tid, String regName, String locName) { - id2RegLocValMap.computeIfAbsent(tid, k -> new HashMap<>()).put(regName, locName); - } - private Expression getInitialValue(String name) { return getOrNewMemoryObject(name).getInitialValue(0); } @@ -314,26 +276,28 @@ public Label getEndOfThreadLabel(int tid) { // ---------------------------------------------------------------------------------------------------------------- // GPU - 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."); - } - // 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<>()); - case OPENCL -> new Thread(name, DEFAULT_THREAD_TYPE, List.of(), id, threadEntry, - ScopeHierarchy.ScopeHierarchyForOpenCL(scopeIds[0], scopeIds[1]), new HashSet<>()); + 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); }; - newThread(id, scopedThread); + + if(id2FunctionsMap.containsKey(id)) { + 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); + } } - 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); } // ---------------------------------------------------------------------------------------------------------------- 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 83862cf514..711c308356 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 @@ -2,7 +2,6 @@ import com.dat3m.dartagnan.configuration.Arch; import com.dat3m.dartagnan.exception.ParsingException; -import com.dat3m.dartagnan.expression.BinaryExpression; import com.dat3m.dartagnan.expression.Expression; import com.dat3m.dartagnan.expression.ExpressionFactory; import com.dat3m.dartagnan.expression.integers.IntLiteral; @@ -46,6 +45,8 @@ public VisitorLitmusC(){ @Override public Program visitMain(LitmusCParser.MainContext ctx) { + //FIXME: We should visit thread declarations before variable declarations + // because variable declaration refer to threads. visitVariableDeclaratorList(ctx.variableDeclaratorList()); visitProgram(ctx.program()); VisitorLitmusAssertions.parseAssertions(programBuilder, ctx.assertionList(), ctx.assertionFilter()); @@ -68,9 +69,10 @@ public Object visitGlobalDeclaratorLocation(LitmusCParser.GlobalDeclaratorLocati @Override public Object visitGlobalDeclaratorRegister(LitmusCParser.GlobalDeclaratorRegisterContext ctx) { if (ctx.initConstantValue() != null) { + // FIXME: We visit declarators before threads, so we need to create threads early + programBuilder.getOrNewThread(ctx.threadId().id); IntLiteral value = expressions.parseValue(ctx.initConstantValue().constant().getText(), archType); - programBuilder.addRegType(ctx.threadId().id, ctx.varName().getText(), archType); - programBuilder.addRegToConstMap(ctx.threadId().id, ctx.varName().getText(), value); + programBuilder.initRegEqConst(ctx.threadId().id,ctx.varName().getText(), value); } return null; } @@ -93,19 +95,17 @@ public Object visitGlobalDeclaratorLocationLocation(LitmusCParser.GlobalDeclarat @Override public Object visitGlobalDeclaratorRegisterLocation(LitmusCParser.GlobalDeclaratorRegisterLocationContext ctx) { - int threadId = ctx.threadId().id; - String regName = ctx.varName(0).getText(); - String locName = ctx.varName(1).getText(); - programBuilder.addRegType(threadId, regName, archType); + // FIXME: We visit declarators before threads, so we need to create threads early + programBuilder.getOrNewThread(ctx.threadId().id); if(ctx.Ast() == null){ - programBuilder.addRegToLocPtrMap(threadId, regName, locName); + programBuilder.initRegEqLocPtr(ctx.threadId().id, ctx.varName(0).getText(), ctx.varName(1).getText(), archType); } else { String rightName = ctx.varName(1).getText(); MemoryObject object = programBuilder.getMemoryObject(rightName); if(object != null){ - programBuilder.addRegToConstMap(threadId, regName, object); + programBuilder.initRegEqConst(ctx.threadId().id, ctx.varName(0).getText(), object); } else { - programBuilder.addRegToLocValMap(threadId, regName, locName); + programBuilder.initRegEqLocVal(ctx.threadId().id, ctx.varName(0).getText(), ctx.varName(1).getText(), archType); } } return null; @@ -158,7 +158,7 @@ public Object visitThread(LitmusCParser.ThreadContext ctx) { // Declarations in the preamble may have created the thread already if (ctx.threadScope() == null) { // Set dummy scope for C11 threads - programBuilder.newScopedThread(Arch.OPENCL, currentThread, 0, 0); + programBuilder.setOrCreateScopedThread(Arch.OPENCL, currentThread, 0, 0); } else { ctx.threadScope().accept(this); this.isOpenCL = true; @@ -176,7 +176,7 @@ public Object visitThread(LitmusCParser.ThreadContext ctx) { public Object visitOpenCLThreadScope(LitmusCParser.OpenCLThreadScopeContext ctx) { int wgID = ctx.scopeID(0).id; int devID = ctx.scopeID(1).id; - programBuilder.newScopedThread(Arch.OPENCL, currentThread, devID, wgID); + programBuilder.setOrCreateScopedThread(Arch.OPENCL, currentThread, devID, wgID); return null; } 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/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; From fa74eb7d5b14f9a4a5e24352a821a23d81934d6e Mon Sep 17 00:00:00 2001 From: Haining Date: Fri, 4 Oct 2024 18:23:31 +0300 Subject: [PATCH 23/23] change opencl litmus format --- dartagnan/src/main/antlr4/C11Lexer.g4 | 1 + dartagnan/src/main/antlr4/LitmusC.g4 | 10 +- .../parsers/program/ProgramParser.java | 3 +- .../program/visitors/VisitorLitmusC.java | 102 ++++++------- .../dat3m/dartagnan/program/event/Tag.java | 8 +- .../src/test/resources/OPENCL-expected.csv | 136 ++++++++++++++++++ litmus/OPENCL/herd/2+2W.litmus | 2 +- litmus/OPENCL/herd/3.2W.litmus | 2 +- litmus/OPENCL/herd/3LB.litmus | 2 +- litmus/OPENCL/herd/CT_wsq1.litmus | 2 +- litmus/OPENCL/herd/CT_wsq2.litmus | 2 +- litmus/OPENCL/herd/IRIW.litmus | 2 +- litmus/OPENCL/herd/ISA2.litmus | 2 +- litmus/OPENCL/herd/ISA3.litmus | 2 +- litmus/OPENCL/herd/LB.litmus | 2 +- litmus/OPENCL/herd/MP.litmus | 2 +- litmus/OPENCL/herd/R.litmus | 2 +- litmus/OPENCL/herd/RWC.litmus | 2 +- litmus/OPENCL/herd/S.litmus | 2 +- litmus/OPENCL/herd/SB.litmus | 2 +- litmus/OPENCL/herd/SB1.litmus | 2 +- litmus/OPENCL/herd/WRC.litmus | 2 +- litmus/OPENCL/herd/barrier_example.litmus | 2 +- litmus/OPENCL/herd/global_barrier.litmus | 2 +- litmus/OPENCL/herd/global_barrier_mo.litmus | 2 +- litmus/OPENCL/herd/old/MP_dr.litmus | 2 +- litmus/OPENCL/herd/old/MP_relacq.litmus | 2 +- litmus/OPENCL/herd/old/MP_relaxed.litmus | 2 +- litmus/OPENCL/herd/old/MP_relseq.litmus | 2 +- litmus/OPENCL/herd/thinair.litmus | 2 +- litmus/OPENCL/overhauling/IRIW_sc_dev.litmus | 2 +- litmus/OPENCL/overhauling/IRIW_sc_wg.litmus | 2 +- litmus/OPENCL/overhauling/ISA2.litmus | 2 +- litmus/OPENCL/overhauling/ISA2_broken.litmus | 2 +- litmus/OPENCL/overhauling/MP_ra_dev.litmus | 2 +- .../overhauling/MP_ra_dev_broken.litmus | 2 +- litmus/OPENCL/overhauling/MP_ra_wg.litmus | 2 +- litmus/OPENCL/overhauling/MP_sc_dev.litmus | 2 +- litmus/OPENCL/overhauling/example10.litmus | 2 +- litmus/OPENCL/overhauling/example4.litmus | 2 +- litmus/OPENCL/overhauling/example5.litmus | 2 +- litmus/OPENCL/overhauling/example6.litmus | 2 +- litmus/OPENCL/overhauling/example7a.litmus | 2 +- litmus/OPENCL/overhauling/example7b.litmus | 2 +- litmus/OPENCL/overhauling/example8.litmus | 2 +- litmus/OPENCL/overhauling/example9a.litmus | 2 +- litmus/OPENCL/overhauling/example9b.litmus | 2 +- .../portedFromC11/auto/a1+Racq+rel.litmus | 16 +++ .../portedFromC11/auto/a1+Racq+sc.litmus | 16 +++ .../portedFromC11/auto/a1+Rna+rel.litmus | 16 +++ .../portedFromC11/auto/a1+Rna+sc.litmus | 16 +++ .../portedFromC11/auto/a1+Rrlx+rel.litmus | 16 +++ .../portedFromC11/auto/a1+Rrlx+sc.litmus | 16 +++ .../portedFromC11/auto/a1+Rsc+rel.litmus | 16 +++ .../portedFromC11/auto/a1+Rsc+sc.litmus | 16 +++ .../portedFromC11/auto/a1+Wna+rel.litmus | 16 +++ .../portedFromC11/auto/a1+Wna+sc.litmus | 16 +++ .../portedFromC11/auto/a1+Wrel+rel.litmus | 16 +++ .../portedFromC11/auto/a1+Wrel+sc.litmus | 16 +++ .../portedFromC11/auto/a1+Wrlx+rel.litmus | 16 +++ .../portedFromC11/auto/a1+Wrlx+sc.litmus | 16 +++ .../portedFromC11/auto/a1+Wsc+rel.litmus | 16 +++ .../portedFromC11/auto/a1+Wsc+sc.litmus | 16 +++ litmus/OPENCL/portedFromC11/auto/a1.litmus | 16 +++ .../auto/a1_reorder+rel+Racq.litmus | 16 +++ .../auto/a1_reorder+rel+Rna.litmus | 16 +++ .../auto/a1_reorder+rel+Rrlx.litmus | 16 +++ .../auto/a1_reorder+rel+Rsc.litmus | 16 +++ .../auto/a1_reorder+rel+Wna.litmus | 16 +++ .../auto/a1_reorder+rel+Wrel.litmus | 16 +++ .../auto/a1_reorder+rel+Wrlx.litmus | 16 +++ .../auto/a1_reorder+rel+Wsc.litmus | 16 +++ .../auto/a1_reorder+sc+Racq.litmus | 16 +++ .../auto/a1_reorder+sc+Rna.litmus | 16 +++ .../auto/a1_reorder+sc+Rrlx.litmus | 16 +++ .../auto/a1_reorder+sc+Rsc.litmus | 16 +++ .../auto/a1_reorder+sc+Wna.litmus | 16 +++ .../auto/a1_reorder+sc+Wrel.litmus | 16 +++ .../auto/a1_reorder+sc+Wrlx.litmus | 16 +++ .../auto/a1_reorder+sc+Wsc.litmus | 16 +++ .../portedFromC11/auto/a1_reorder.litmus | 16 +++ .../portedFromC11/auto/a3+acq+Racq.litmus | 16 +++ .../portedFromC11/auto/a3+acq+Rna.litmus | 16 +++ .../portedFromC11/auto/a3+acq+Rrlx.litmus | 16 +++ .../portedFromC11/auto/a3+acq+Rsc.litmus | 16 +++ .../portedFromC11/auto/a3+acq+Wna.litmus | 16 +++ .../portedFromC11/auto/a3+acq+Wrel.litmus | 16 +++ .../portedFromC11/auto/a3+acq+Wrlx.litmus | 16 +++ .../portedFromC11/auto/a3+acq+Wsc.litmus | 16 +++ .../portedFromC11/auto/a3+sc+Racq.litmus | 16 +++ .../portedFromC11/auto/a3+sc+Rna.litmus | 16 +++ .../portedFromC11/auto/a3+sc+Rrlx.litmus | 16 +++ .../portedFromC11/auto/a3+sc+Rsc.litmus | 16 +++ .../portedFromC11/auto/a3+sc+Wna.litmus | 16 +++ .../portedFromC11/auto/a3+sc+Wrel.litmus | 16 +++ .../portedFromC11/auto/a3+sc+Wrlx.litmus | 16 +++ .../portedFromC11/auto/a3+sc+Wsc.litmus | 16 +++ litmus/OPENCL/portedFromC11/auto/a3.litmus | 16 +++ .../auto/a3_reorder+Racq+acq.litmus | 14 ++ .../auto/a3_reorder+Racq+sc.litmus | 14 ++ .../auto/a3_reorder+Rna+acq.litmus | 14 ++ .../auto/a3_reorder+Rna+sc.litmus | 14 ++ .../auto/a3_reorder+Rrlx+acq.litmus | 14 ++ .../auto/a3_reorder+Rrlx+sc.litmus | 14 ++ .../auto/a3_reorder+Rsc+acq.litmus | 14 ++ .../auto/a3_reorder+Rsc+sc.litmus | 14 ++ .../auto/a3_reorder+Wna+acq.litmus | 14 ++ .../auto/a3_reorder+Wna+sc.litmus | 14 ++ .../auto/a3_reorder+Wrel+acq.litmus | 14 ++ .../auto/a3_reorder+Wrel+sc.litmus | 14 ++ .../auto/a3_reorder+Wrlx+acq.litmus | 14 ++ .../auto/a3_reorder+Wrlx+sc.litmus | 14 ++ .../auto/a3_reorder+Wsc+acq.litmus | 14 ++ .../auto/a3_reorder+Wsc+sc.litmus | 14 ++ .../portedFromC11/auto/a3_reorder.litmus | 14 ++ litmus/OPENCL/portedFromC11/auto/a3v2.litmus | 17 +++ litmus/OPENCL/portedFromC11/auto/a4.litmus | 14 ++ .../portedFromC11/auto/a4_reorder.litmus | 14 ++ litmus/OPENCL/portedFromC11/auto/arfna.litmus | 25 ++++ .../OPENCL/portedFromC11/auto/arfna2.litmus | 25 ++++ .../portedFromC11/auto/b+acq+rel.litmus | 14 ++ .../portedFromC11/auto/b+acq+rlx.litmus | 14 ++ .../OPENCL/portedFromC11/auto/b+acq+sc.litmus | 14 ++ .../portedFromC11/auto/b+rlx+rel.litmus | 14 ++ .../portedFromC11/auto/b+rlx+rlx.litmus | 14 ++ .../OPENCL/portedFromC11/auto/b+rlx+sc.litmus | 14 ++ .../OPENCL/portedFromC11/auto/b+sc+rel.litmus | 14 ++ .../OPENCL/portedFromC11/auto/b+sc+rlx.litmus | 14 ++ .../OPENCL/portedFromC11/auto/b+sc+sc.litmus | 14 ++ litmus/OPENCL/portedFromC11/auto/b.litmus | 14 ++ .../auto/b_reorder+rel+acq.litmus | 14 ++ .../auto/b_reorder+rel+rlx.litmus | 14 ++ .../auto/b_reorder+rel+sc.litmus | 14 ++ .../auto/b_reorder+rlx+acq.litmus | 14 ++ .../auto/b_reorder+rlx+rlx.litmus | 14 ++ .../auto/b_reorder+rlx+sc.litmus | 14 ++ .../auto/b_reorder+sc+acq.litmus | 14 ++ .../auto/b_reorder+sc+rlx.litmus | 14 ++ .../portedFromC11/auto/b_reorder+sc+sc.litmus | 14 ++ .../portedFromC11/auto/b_reorder.litmus | 14 ++ litmus/OPENCL/portedFromC11/auto/c.litmus | 26 ++++ litmus/OPENCL/portedFromC11/auto/c_p.litmus | 26 ++++ .../portedFromC11/auto/c_p_reorder.litmus | 26 ++++ litmus/OPENCL/portedFromC11/auto/c_pq.litmus | 26 ++++ .../portedFromC11/auto/c_pq_reorder.litmus | 26 ++++ litmus/OPENCL/portedFromC11/auto/c_q.litmus | 26 ++++ .../portedFromC11/auto/c_q_reorder.litmus | 26 ++++ .../portedFromC11/auto/c_reorder.litmus | 26 ++++ litmus/OPENCL/portedFromC11/auto/cyc.litmus | 18 +++ .../OPENCL/portedFromC11/auto/cyc_na.litmus | 18 +++ litmus/OPENCL/portedFromC11/auto/fig1.litmus | 16 +++ litmus/OPENCL/portedFromC11/auto/lb.litmus | 14 ++ .../portedFromC11/auto/linearisation.litmus | 27 ++++ .../portedFromC11/auto/linearisation2.litmus | 27 ++++ .../portedFromC11/auto/roachmotel.litmus | 27 ++++ .../portedFromC11/auto/roachmotel2.litmus | 27 ++++ .../portedFromC11/auto/rseq_weak.litmus | 21 +++ .../portedFromC11/auto/rseq_weak2.litmus | 17 +++ litmus/OPENCL/portedFromC11/auto/seq.litmus | 25 ++++ litmus/OPENCL/portedFromC11/auto/seq2.litmus | 22 +++ .../portedFromC11/auto/strengthen.litmus | 27 ++++ .../portedFromC11/auto/strengthen2.litmus | 27 ++++ .../manual/IRIW-sc-sc-acq-sc-acq-sc.litmus | 27 ++++ .../manual/RWC-sc-acq-sc-sc-sc.litmus | 23 +++ .../OPENCL/portedFromC11/manual/TSan.litmus | 22 +++ .../manual/cppmem_iriw_relacq.litmus | 35 +++++ .../portedFromC11/manual/example1.litmus | 28 ++++ .../portedFromC11/manual/imm-E3.1.litmus | 19 +++ .../portedFromC11/manual/imm-E3.10.litmus | 20 +++ .../portedFromC11/manual/imm-E3.2.litmus | 18 +++ .../portedFromC11/manual/imm-E3.3.litmus | 19 +++ .../portedFromC11/manual/imm-E3.4.litmus | 19 +++ .../portedFromC11/manual/imm-E3.5.litmus | 22 +++ .../portedFromC11/manual/imm-E3.6.litmus | 21 +++ .../portedFromC11/manual/imm-E3.7.litmus | 21 +++ .../portedFromC11/manual/imm-E3.8-alt.litmus | 27 ++++ .../portedFromC11/manual/imm-E3.8.litmus | 29 ++++ .../portedFromC11/manual/imm-E3.9.litmus | 28 ++++ .../portedFromC11/manual/imm-R2-alt.litmus | 25 ++++ .../OPENCL/portedFromC11/manual/imm-R2.litmus | 24 ++++ .../portedFromC11/manual/iriw_sc.litmus | 34 +++++ .../portedFromC11/manual/mp_fences.litmus | 27 ++++ .../portedFromC11/manual/mp_relacq.litmus | 25 ++++ .../portedFromC11/manual/mp_relaxed.litmus | 25 ++++ 184 files changed, 2728 insertions(+), 102 deletions(-) create mode 100644 litmus/OPENCL/portedFromC11/auto/a1+Racq+rel.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/a1+Racq+sc.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/a1+Rna+rel.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/a1+Rna+sc.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/a1+Rrlx+rel.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/a1+Rrlx+sc.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/a1+Rsc+rel.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/a1+Rsc+sc.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/a1+Wna+rel.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/a1+Wna+sc.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/a1+Wrel+rel.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/a1+Wrel+sc.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/a1+Wrlx+rel.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/a1+Wrlx+sc.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/a1+Wsc+rel.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/a1+Wsc+sc.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/a1.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/a1_reorder+rel+Racq.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/a1_reorder+rel+Rna.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/a1_reorder+rel+Rrlx.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/a1_reorder+rel+Rsc.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/a1_reorder+rel+Wna.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/a1_reorder+rel+Wrel.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/a1_reorder+rel+Wrlx.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/a1_reorder+rel+Wsc.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/a1_reorder+sc+Racq.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/a1_reorder+sc+Rna.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/a1_reorder+sc+Rrlx.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/a1_reorder+sc+Rsc.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/a1_reorder+sc+Wna.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/a1_reorder+sc+Wrel.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/a1_reorder+sc+Wrlx.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/a1_reorder+sc+Wsc.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/a1_reorder.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/a3+acq+Racq.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/a3+acq+Rna.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/a3+acq+Rrlx.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/a3+acq+Rsc.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/a3+acq+Wna.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/a3+acq+Wrel.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/a3+acq+Wrlx.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/a3+acq+Wsc.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/a3+sc+Racq.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/a3+sc+Rna.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/a3+sc+Rrlx.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/a3+sc+Rsc.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/a3+sc+Wna.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/a3+sc+Wrel.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/a3+sc+Wrlx.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/a3+sc+Wsc.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/a3.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/a3_reorder+Racq+acq.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/a3_reorder+Racq+sc.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/a3_reorder+Rna+acq.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/a3_reorder+Rna+sc.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/a3_reorder+Rrlx+acq.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/a3_reorder+Rrlx+sc.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/a3_reorder+Rsc+acq.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/a3_reorder+Rsc+sc.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/a3_reorder+Wna+acq.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/a3_reorder+Wna+sc.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/a3_reorder+Wrel+acq.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/a3_reorder+Wrel+sc.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/a3_reorder+Wrlx+acq.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/a3_reorder+Wrlx+sc.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/a3_reorder+Wsc+acq.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/a3_reorder+Wsc+sc.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/a3_reorder.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/a3v2.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/a4.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/a4_reorder.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/arfna.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/arfna2.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/b+acq+rel.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/b+acq+rlx.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/b+acq+sc.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/b+rlx+rel.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/b+rlx+rlx.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/b+rlx+sc.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/b+sc+rel.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/b+sc+rlx.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/b+sc+sc.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/b.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/b_reorder+rel+acq.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/b_reorder+rel+rlx.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/b_reorder+rel+sc.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/b_reorder+rlx+acq.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/b_reorder+rlx+rlx.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/b_reorder+rlx+sc.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/b_reorder+sc+acq.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/b_reorder+sc+rlx.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/b_reorder+sc+sc.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/b_reorder.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/c.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/c_p.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/c_p_reorder.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/c_pq.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/c_pq_reorder.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/c_q.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/c_q_reorder.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/c_reorder.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/cyc.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/cyc_na.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/fig1.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/lb.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/linearisation.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/linearisation2.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/roachmotel.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/roachmotel2.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/rseq_weak.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/rseq_weak2.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/seq.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/seq2.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/strengthen.litmus create mode 100644 litmus/OPENCL/portedFromC11/auto/strengthen2.litmus create mode 100644 litmus/OPENCL/portedFromC11/manual/IRIW-sc-sc-acq-sc-acq-sc.litmus create mode 100644 litmus/OPENCL/portedFromC11/manual/RWC-sc-acq-sc-sc-sc.litmus create mode 100644 litmus/OPENCL/portedFromC11/manual/TSan.litmus create mode 100644 litmus/OPENCL/portedFromC11/manual/cppmem_iriw_relacq.litmus create mode 100644 litmus/OPENCL/portedFromC11/manual/example1.litmus create mode 100644 litmus/OPENCL/portedFromC11/manual/imm-E3.1.litmus create mode 100644 litmus/OPENCL/portedFromC11/manual/imm-E3.10.litmus create mode 100644 litmus/OPENCL/portedFromC11/manual/imm-E3.2.litmus create mode 100644 litmus/OPENCL/portedFromC11/manual/imm-E3.3.litmus create mode 100644 litmus/OPENCL/portedFromC11/manual/imm-E3.4.litmus create mode 100644 litmus/OPENCL/portedFromC11/manual/imm-E3.5.litmus create mode 100644 litmus/OPENCL/portedFromC11/manual/imm-E3.6.litmus create mode 100644 litmus/OPENCL/portedFromC11/manual/imm-E3.7.litmus create mode 100644 litmus/OPENCL/portedFromC11/manual/imm-E3.8-alt.litmus create mode 100644 litmus/OPENCL/portedFromC11/manual/imm-E3.8.litmus create mode 100644 litmus/OPENCL/portedFromC11/manual/imm-E3.9.litmus create mode 100644 litmus/OPENCL/portedFromC11/manual/imm-R2-alt.litmus create mode 100644 litmus/OPENCL/portedFromC11/manual/imm-R2.litmus create mode 100644 litmus/OPENCL/portedFromC11/manual/iriw_sc.litmus create mode 100644 litmus/OPENCL/portedFromC11/manual/mp_fences.litmus create mode 100644 litmus/OPENCL/portedFromC11/manual/mp_relacq.litmus create mode 100644 litmus/OPENCL/portedFromC11/manual/mp_relaxed.litmus diff --git a/dartagnan/src/main/antlr4/C11Lexer.g4 b/dartagnan/src/main/antlr4/C11Lexer.g4 index 6c7fb3df09..9286970606 100644 --- a/dartagnan/src/main/antlr4/C11Lexer.g4 +++ b/dartagnan/src/main/antlr4/C11Lexer.g4 @@ -4,6 +4,7 @@ C11AtomicLoadExplicit : 'atomic_load_explicit'; C11AtomicLoad : 'atomic_load'; C11AtomicStoreExplicit : 'atomic_store_explicit'; C11AtomicStore : 'atomic_store'; +C11AtomicXchgExplicit : 'atomic_exchange_explicit_explicit'; C11AtomicXchg : 'atomic_exchange_explicit'; C11AtomicSCASExplicit : 'atomic_compare_exchange_strong_explicit'; C11AtomicSCAS : 'atomic_compare_exchange_strong'; diff --git a/dartagnan/src/main/antlr4/LitmusC.g4 b/dartagnan/src/main/antlr4/LitmusC.g4 index 10227ec621..22ff4b962e 100644 --- a/dartagnan/src/main/antlr4/LitmusC.g4 +++ b/dartagnan/src/main/antlr4/LitmusC.g4 @@ -41,7 +41,7 @@ threadArguments ; threadArgument - : openCLSpace? pointerTypeSpecifier varName + : pointerTypeSpecifier varName ; expression @@ -121,7 +121,8 @@ re locals [IntBinaryOp op, String mo] | 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 - | 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;} @@ -305,8 +306,8 @@ cast ; pointerTypeSpecifier - : (Volatile)? basicTypeSpecifier Ast - | (Volatile)? atomicTypeSpecifier Ast + : (Volatile)? openCLSpace? basicTypeSpecifier Ast + | (Volatile)? openCLSpace? atomicTypeSpecifier Ast ; typeSpecifier @@ -442,6 +443,7 @@ BarBar LitmusLanguage : 'C' + | 'OPENCL' ; AssertionNot 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/visitors/VisitorLitmusC.java b/dartagnan/src/main/java/com/dat3m/dartagnan/parsers/program/visitors/VisitorLitmusC.java index 711c308356..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 @@ -47,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()); @@ -156,12 +159,10 @@ 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 - if (ctx.threadScope() == null) { - // Set dummy scope for C11 threads - programBuilder.setOrCreateScopedThread(Arch.OPENCL, currentThread, 0, 0); - } else { + if (isOpenCL && ctx.threadScope() != null) { ctx.threadScope().accept(this); - this.isOpenCL = true; + } else { + programBuilder.getOrNewThread(currentThread); } visitThreadArguments(ctx.threadArguments()); @@ -202,14 +203,8 @@ public Object visitThreadArgument(LitmusCParser.ThreadArgumentContext ctx) { if (!atomicity) { object.addFeatureTag(C11.NON_ATOMIC_LOCATION); } - if (this.isOpenCL) { - if (ctx.openCLSpace() != null) { - object.addFeatureTag(ctx.openCLSpace().space); - } else { - object.addFeatureTag(Tag.OpenCL.DEFAULT_GPU_SPACE); - } - } else { - object.addFeatureTag(Tag.OpenCL.DEFAULT_CPU_SPACE); + if (isOpenCL && ctx.pointerTypeSpecifier().openCLSpace() != null) { + object.addFeatureTag(ctx.pointerTypeSpecifier().openCLSpace().space); } programBuilder.setReg2LocMap(register, object); programBuilder.addChild(currentThread, EventFactory.newLocal(register, object)); @@ -291,11 +286,7 @@ public Expression visitC11AtomicOp(LitmusCParser.C11AtomicOpContext ctx) { Expression address = getAddress(ctx.address); Event event = EventFactory.Atomic.newFetchOp(register, address, value, ctx.op, ctx.c11Mo().mo); addMemoryObjectTags(event, address); - if (ctx.openCLScope() != null) { - event.addTags(ctx.openCLScope().scope); - } else { - event.addTags(Tag.OpenCL.DEFAULT_SCOPE); - } + addScopeTag(event, ctx.openCLScope()); programBuilder.addChild(currentThread, event); return register; } @@ -324,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; } @@ -347,11 +352,7 @@ public Expression visitReC11SCmpXchgExplicit(LitmusCParser.ReC11SCmpXchgExplicit String mo = ctx.c11Mo(0).mo; Event event = EventFactory.Atomic.newCompareExchange(register, address, expectedAdd, value, mo, true); addMemoryObjectTags(event, address); - if (ctx.openCLScope() != null) { - event.addTags(ctx.openCLScope().scope); - } else { - event.addTags(Tag.OpenCL.DEFAULT_SCOPE); - } + addScopeTag(event, ctx.openCLScope()); programBuilder.addChild(currentThread, event); return register; } @@ -363,9 +364,9 @@ public Expression visitReC11SCmpXchg(LitmusCParser.ReC11SCmpXchgContext ctx) { Expression address = getAddress(ctx.address); Expression expectedAdd = getAddress(ctx.expectedAdd); Event event = EventFactory.Atomic.newCompareExchange(register, address, expectedAdd, value, - Tag.OpenCL.DEFAULT_MO, true); + C11.DEFAULT_MO, true); addMemoryObjectTags(event, address); - event.addTags(Tag.OpenCL.DEFAULT_SCOPE); + addScopeTag(event, null); programBuilder.addChild(currentThread, event); return register; } @@ -379,11 +380,7 @@ public Expression visitReC11WCmpXchgExplicit(LitmusCParser.ReC11WCmpXchgExplicit String mo = ctx.c11Mo(0).mo; Event event = EventFactory.Atomic.newCompareExchange(register, address, expectedAdd, value, mo, false); addMemoryObjectTags(event, address); - if (ctx.openCLScope() != null) { - event.addTags(ctx.openCLScope().scope); - } else { - event.addTags(Tag.OpenCL.DEFAULT_SCOPE); - } + addScopeTag(event, ctx.openCLScope()); programBuilder.addChild(currentThread, event); return register; } @@ -395,9 +392,9 @@ public Expression visitReC11WCmpXchg(LitmusCParser.ReC11WCmpXchgContext ctx) { Expression address = getAddress(ctx.address); Expression expectedAdd = getAddress(ctx.expectedAdd); Event event = EventFactory.Atomic.newCompareExchange(register, address, expectedAdd, value, - Tag.OpenCL.DEFAULT_MO, false); + C11.DEFAULT_MO, false); addMemoryObjectTags(event, address); - event.addTags(Tag.OpenCL.DEFAULT_SCOPE); + addScopeTag(event, null); programBuilder.addChild(currentThread, event); return register; } @@ -417,11 +414,7 @@ public Expression visitReCmpXchg(LitmusCParser.ReCmpXchgContext ctx){ Expression address = getAddress(ctx.address); AtomicLoad event = EventFactory.Atomic.newLoad(register, address, ctx.c11Mo().mo); addMemoryObjectTags(event, address); - if (ctx.openCLScope() != null) { - event.addTags(ctx.openCLScope().scope); - } else { - event.addTags(Tag.OpenCL.DEFAULT_SCOPE); - } + addScopeTag(event, ctx.openCLScope()); programBuilder.addChild(currentThread, event); return register; } @@ -429,9 +422,9 @@ public Expression visitReCmpXchg(LitmusCParser.ReCmpXchgContext ctx){ @Override public Expression visitReC11Load(LitmusCParser.ReC11LoadContext ctx) { Register register = getReturnRegister(true); Expression address = getAddress(ctx.address); - AtomicLoad event = EventFactory.Atomic.newLoad(register, address, Tag.OpenCL.DEFAULT_MO); + AtomicLoad event = EventFactory.Atomic.newLoad(register, address, C11.DEFAULT_MO); addMemoryObjectTags(event, address); - event.addTags(Tag.OpenCL.DEFAULT_SCOPE); + addScopeTag(event, null); programBuilder.addChild(currentThread, event); return register; } @@ -573,11 +566,7 @@ public Object visitNreC11StoreExplicit(LitmusCParser.NreC11StoreExplicitContext Expression address = getAddress(ctx.address); AtomicStore event = EventFactory.Atomic.newStore(address, value, ctx.c11Mo().mo); addMemoryObjectTags(event, address); - if (ctx.openCLScope() != null) { - event.addTags(ctx.openCLScope().scope); - } else { - event.addTags(Tag.OpenCL.DEFAULT_SCOPE); - } + addScopeTag(event, ctx.openCLScope()); return programBuilder.addChild(currentThread, event); } @@ -585,9 +574,9 @@ public Object visitNreC11StoreExplicit(LitmusCParser.NreC11StoreExplicitContext public Object visitNreC11Store(LitmusCParser.NreC11StoreContext ctx) { Expression value = (Expression)ctx.value.accept(this); Expression address = getAddress(ctx.address); - AtomicStore event = EventFactory.Atomic.newStore(address, value, Tag.OpenCL.DEFAULT_MO); + AtomicStore event = EventFactory.Atomic.newStore(address, value, C11.DEFAULT_MO); addMemoryObjectTags(event, address); - event.addTags(Tag.OpenCL.DEFAULT_SCOPE); + addScopeTag(event, null); return programBuilder.addChild(currentThread, event); } @@ -595,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; } @@ -608,7 +597,9 @@ public Object visitNreAssignment(LitmusCParser.NreAssignmentContext ctx){ Event event = EventFactory.newStoreWithMo(variable, value, C11.NONATOMIC); if (variable instanceof Register reg) { addMemoryObjectTags(event, reg); - event.addTags(Tag.OpenCL.DEFAULT_WEAK_SCOPE); + if (isOpenCL) { + event.addTags(Tag.OpenCL.DEFAULT_WEAK_SCOPE); + } } return programBuilder.addChild(currentThread, event); } @@ -632,7 +623,6 @@ public Object visitNreRegDeclaration(LitmusCParser.NreRegDeclarationContext ctx) @Override public Object visitNreC11Fence(LitmusCParser.NreC11FenceContext ctx) { AtomicThreadFence fence = EventFactory.Atomic.newFence(ctx.c11Mo().mo); - fence.addTags(Tag.OpenCL.DEFAULT_SCOPE, Tag.OpenCL.DEFAULT_CPU_SPACE); return programBuilder.addChild(currentThread, fence); } @@ -747,4 +737,14 @@ private void addMemoryObjectTags(Event event, Expression address) { } } } + + 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/program/event/Tag.java b/dartagnan/src/main/java/com/dat3m/dartagnan/program/event/Tag.java index 97c4b67d33..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 @@ -128,6 +128,8 @@ private C11() { public static final String MO_ACQUIRE_RELEASE = "ACQ_REL"; public static final String MO_SC = "SC"; + public static final String DEFAULT_MO = MO_SC; + public static String intToMo(int i) { switch (i) { case 0: return MO_RELAXED; @@ -379,23 +381,19 @@ public static final class OpenCL { // Space public static final String GLOBAL_SPACE = "GLOBAL"; public static final String LOCAL_SPACE = "LOCAL"; - public static final String GENERIC_SPACE = "GENERIC"; // 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 final String DEFAULT_MO = C11.MO_SC; - public static final String DEFAULT_CPU_SPACE = GLOBAL_SPACE; - public static final String DEFAULT_GPU_SPACE = GENERIC_SPACE; public static List getScopeTags() { return List.of(WORK_GROUP, DEVICE, ALL); } public static List getSpaceTags() { - return List.of(GLOBAL_SPACE, LOCAL_SPACE, GENERIC_SPACE); + return List.of(GLOBAL_SPACE, LOCAL_SPACE); } public static List getSpaceTags(Event e) { diff --git a/dartagnan/src/test/resources/OPENCL-expected.csv b/dartagnan/src/test/resources/OPENCL-expected.csv index cbd7987696..dbe3bce17a 100644 --- a/dartagnan/src/test/resources/OPENCL-expected.csv +++ b/dartagnan/src/test/resources/OPENCL-expected.csv @@ -39,3 +39,139 @@ 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 index 8c9996e60e..0594f64583 100644 --- a/litmus/OPENCL/herd/2+2W.litmus +++ b/litmus/OPENCL/herd/2+2W.litmus @@ -1,4 +1,4 @@ -C 2+2W_xaG_yaG_sc--sc_sc--sc_0||1 +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 diff --git a/litmus/OPENCL/herd/3.2W.litmus b/litmus/OPENCL/herd/3.2W.litmus index c2860dc6c8..32fdadf497 100644 --- a/litmus/OPENCL/herd/3.2W.litmus +++ b/litmus/OPENCL/herd/3.2W.litmus @@ -1,4 +1,4 @@ -C 3.2W_xaG_yaG_zaG_sc--sc_rel[wg]-LFsc-rel_rel-GFrel[dev]-acq[wg]_0||1|2 +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 diff --git a/litmus/OPENCL/herd/3LB.litmus b/litmus/OPENCL/herd/3LB.litmus index 57c0a50c7c..12d6c5dfc0 100644 --- a/litmus/OPENCL/herd/3LB.litmus +++ b/litmus/OPENCL/herd/3LB.litmus @@ -1,4 +1,4 @@ -C 3LB_xaG_yaG_zaG_sc--sc_na--sc_sc--sc_0|1||2 +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 diff --git a/litmus/OPENCL/herd/CT_wsq1.litmus b/litmus/OPENCL/herd/CT_wsq1.litmus index 6ae5f31e68..d1055833db 100644 --- a/litmus/OPENCL/herd/CT_wsq1.litmus +++ b/litmus/OPENCL/herd/CT_wsq1.litmus @@ -1,4 +1,4 @@ -C CT_wsq1 +OPENCL CT_wsq1 (* * https://github.com/herd/legacy/blob/master/herdtools/herd/testsuite/OpenCLTests/CT_wsq/CT_wsq1.litmus diff --git a/litmus/OPENCL/herd/CT_wsq2.litmus b/litmus/OPENCL/herd/CT_wsq2.litmus index 280ad56867..8909925e8a 100644 --- a/litmus/OPENCL/herd/CT_wsq2.litmus +++ b/litmus/OPENCL/herd/CT_wsq2.litmus @@ -1,4 +1,4 @@ -C CT_wsq2 +OPENCL CT_wsq2 (* * https://github.com/herd/legacy/blob/master/herdtools/herd/testsuite/OpenCLTests/CT_wsq/CT_wsq2.litmus diff --git a/litmus/OPENCL/herd/IRIW.litmus b/litmus/OPENCL/herd/IRIW.litmus index db724bb1ea..4420180cb1 100644 --- a/litmus/OPENCL/herd/IRIW.litmus +++ b/litmus/OPENCL/herd/IRIW.litmus @@ -1,4 +1,4 @@ -C IRIW_sc_sc_sc-sc_sc-sc_xaG_yaG_P0_P1_P2_P3 +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 diff --git a/litmus/OPENCL/herd/ISA2.litmus b/litmus/OPENCL/herd/ISA2.litmus index 28ff8ac569..6fe2058cdb 100644 --- a/litmus/OPENCL/herd/ISA2.litmus +++ b/litmus/OPENCL/herd/ISA2.litmus @@ -1,4 +1,4 @@ -C ISA2 +OPENCL ISA2 (* * PodWW Rfe PodRR Fre diff --git a/litmus/OPENCL/herd/ISA3.litmus b/litmus/OPENCL/herd/ISA3.litmus index f27e7f1d3a..c297481cab 100644 --- a/litmus/OPENCL/herd/ISA3.litmus +++ b/litmus/OPENCL/herd/ISA3.litmus @@ -1,4 +1,4 @@ -C ISA2_sc-sc_sc-sc_sc-sc_xaG_yaG_zaG_P0_P1_P2 +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 diff --git a/litmus/OPENCL/herd/LB.litmus b/litmus/OPENCL/herd/LB.litmus index 7bf82e23a2..8bd152acf0 100644 --- a/litmus/OPENCL/herd/LB.litmus +++ b/litmus/OPENCL/herd/LB.litmus @@ -1,4 +1,4 @@ -C LB +OPENCL LB (* * PodWW Rfe PodRR Fre diff --git a/litmus/OPENCL/herd/MP.litmus b/litmus/OPENCL/herd/MP.litmus index 1779ae2ff0..fd715f2e62 100644 --- a/litmus/OPENCL/herd/MP.litmus +++ b/litmus/OPENCL/herd/MP.litmus @@ -1,4 +1,4 @@ -C MP_rlx_1FG-sc-all_rlx_xaG_yaG_P0_P1 +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 diff --git a/litmus/OPENCL/herd/R.litmus b/litmus/OPENCL/herd/R.litmus index d6a96622c1..b690b74068 100644 --- a/litmus/OPENCL/herd/R.litmus +++ b/litmus/OPENCL/herd/R.litmus @@ -1,4 +1,4 @@ -C R_xaG_yaG_sc--sc_sc--sc_0||1 +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 diff --git a/litmus/OPENCL/herd/RWC.litmus b/litmus/OPENCL/herd/RWC.litmus index 36f505933b..3695404550 100644 --- a/litmus/OPENCL/herd/RWC.litmus +++ b/litmus/OPENCL/herd/RWC.litmus @@ -1,4 +1,4 @@ -C RWC_xaG_yaG_sc-_rel[wg]-LFsc-rel_rel-GFrel[dev]-acq[wg]_0||1|2 +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 diff --git a/litmus/OPENCL/herd/S.litmus b/litmus/OPENCL/herd/S.litmus index 9ac8ea9dbc..a457037514 100644 --- a/litmus/OPENCL/herd/S.litmus +++ b/litmus/OPENCL/herd/S.litmus @@ -1,4 +1,4 @@ -C S_xaG_yaG_rel[wg]-LFsc-rel_rel-GFrel[dev]-acq[wg]_0||1 +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 diff --git a/litmus/OPENCL/herd/SB.litmus b/litmus/OPENCL/herd/SB.litmus index 6ea17b24c4..d879bfdccf 100644 --- a/litmus/OPENCL/herd/SB.litmus +++ b/litmus/OPENCL/herd/SB.litmus @@ -1,4 +1,4 @@ -C SB +OPENCL SB (* * PodWW Rfe PodRR Fre diff --git a/litmus/OPENCL/herd/SB1.litmus b/litmus/OPENCL/herd/SB1.litmus index 0c7d476949..6eb863b30a 100644 --- a/litmus/OPENCL/herd/SB1.litmus +++ b/litmus/OPENCL/herd/SB1.litmus @@ -1,4 +1,4 @@ -C SB_xaG_yaG_rel[wg]-LFsc-rel_rel-GFrel[dev]-acq[wg]_0||1 +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 diff --git a/litmus/OPENCL/herd/WRC.litmus b/litmus/OPENCL/herd/WRC.litmus index 52729aa9f1..c6980218de 100644 --- a/litmus/OPENCL/herd/WRC.litmus +++ b/litmus/OPENCL/herd/WRC.litmus @@ -1,4 +1,4 @@ -C WRC_xaG_yaG_sc-_rel[wg]-LFsc-rel_rel-GFrel[dev]-acq[wg]_0||1|2 +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 diff --git a/litmus/OPENCL/herd/barrier_example.litmus b/litmus/OPENCL/herd/barrier_example.litmus index 760a01788f..e9e38f2fda 100644 --- a/litmus/OPENCL/herd/barrier_example.litmus +++ b/litmus/OPENCL/herd/barrier_example.litmus @@ -1,4 +1,4 @@ -C barrier_example +OPENCL barrier_example (* * https://github.com/herd/legacy/blob/master/herdtools/herd/testsuite/OpenCLTests/barrier_example.litmus diff --git a/litmus/OPENCL/herd/global_barrier.litmus b/litmus/OPENCL/herd/global_barrier.litmus index 98a633dada..b21f526140 100644 --- a/litmus/OPENCL/herd/global_barrier.litmus +++ b/litmus/OPENCL/herd/global_barrier.litmus @@ -1,4 +1,4 @@ -C global_barrier +OPENCL global_barrier (* * https://github.com/herd/legacy/blob/master/herdtools/herd/testsuite/OpenCLTests/global_barrier.litmus diff --git a/litmus/OPENCL/herd/global_barrier_mo.litmus b/litmus/OPENCL/herd/global_barrier_mo.litmus index a84a93024b..d43c1aa014 100644 --- a/litmus/OPENCL/herd/global_barrier_mo.litmus +++ b/litmus/OPENCL/herd/global_barrier_mo.litmus @@ -1,4 +1,4 @@ -C global_barrier +OPENCL global_barrier (* * https://github.com/herd/legacy/blob/master/herdtools/herd/testsuite/OpenCLTests/global_barrier_mo.litmus diff --git a/litmus/OPENCL/herd/old/MP_dr.litmus b/litmus/OPENCL/herd/old/MP_dr.litmus index b94f53f7e0..95bea74a0b 100644 --- a/litmus/OPENCL/herd/old/MP_dr.litmus +++ b/litmus/OPENCL/herd/old/MP_dr.litmus @@ -1,4 +1,4 @@ -C MP_dr +OPENCL MP_dr (* * https://github.com/herd/legacy/blob/master/herdtools/herd/testsuite/oldOpenCLTests/MP_dr.litmus diff --git a/litmus/OPENCL/herd/old/MP_relacq.litmus b/litmus/OPENCL/herd/old/MP_relacq.litmus index 6e0d9b252a..2a9b7c4c85 100644 --- a/litmus/OPENCL/herd/old/MP_relacq.litmus +++ b/litmus/OPENCL/herd/old/MP_relacq.litmus @@ -1,4 +1,4 @@ -C MP_relacq +OPENCL MP_relacq (* * Fre PodWR Fre PodWR diff --git a/litmus/OPENCL/herd/old/MP_relaxed.litmus b/litmus/OPENCL/herd/old/MP_relaxed.litmus index a4308e8418..259ba8d471 100644 --- a/litmus/OPENCL/herd/old/MP_relaxed.litmus +++ b/litmus/OPENCL/herd/old/MP_relaxed.litmus @@ -1,4 +1,4 @@ -C MP_relaxed +OPENCL MP_relaxed (* * Fre PodWR Fre PodWR diff --git a/litmus/OPENCL/herd/old/MP_relseq.litmus b/litmus/OPENCL/herd/old/MP_relseq.litmus index 12143c76ae..71d99556b9 100644 --- a/litmus/OPENCL/herd/old/MP_relseq.litmus +++ b/litmus/OPENCL/herd/old/MP_relseq.litmus @@ -1,4 +1,4 @@ -C MP_relseq +OPENCL MP_relseq (* * Fre PodWR Fre PodWR diff --git a/litmus/OPENCL/herd/thinair.litmus b/litmus/OPENCL/herd/thinair.litmus index d4a03a7226..7ddb68b6c4 100644 --- a/litmus/OPENCL/herd/thinair.litmus +++ b/litmus/OPENCL/herd/thinair.litmus @@ -1,4 +1,4 @@ -C thinair +OPENCL thinair (* * https://github.com/herd/legacy/blob/master/herdtools/herd/testsuite/OpenCLTests/thinair.litmus diff --git a/litmus/OPENCL/overhauling/IRIW_sc_dev.litmus b/litmus/OPENCL/overhauling/IRIW_sc_dev.litmus index 85962e927f..7a5428ef6a 100644 --- a/litmus/OPENCL/overhauling/IRIW_sc_dev.litmus +++ b/litmus/OPENCL/overhauling/IRIW_sc_dev.litmus @@ -1,4 +1,4 @@ -C IRIW_sc_dev +OPENCL IRIW_sc_dev (* * https://multicore.doc.ic.ac.uk/overhauling/OpenCL/IRIW_sc_dev.litmus diff --git a/litmus/OPENCL/overhauling/IRIW_sc_wg.litmus b/litmus/OPENCL/overhauling/IRIW_sc_wg.litmus index 680284cec1..62e5784a48 100644 --- a/litmus/OPENCL/overhauling/IRIW_sc_wg.litmus +++ b/litmus/OPENCL/overhauling/IRIW_sc_wg.litmus @@ -1,4 +1,4 @@ -C IRIW_sc_wg +OPENCL IRIW_sc_wg (* * https://multicore.doc.ic.ac.uk/overhauling/OpenCL/IRIW_sc_wg.litmus diff --git a/litmus/OPENCL/overhauling/ISA2.litmus b/litmus/OPENCL/overhauling/ISA2.litmus index 777a95ed91..3f1f4f3fc8 100644 --- a/litmus/OPENCL/overhauling/ISA2.litmus +++ b/litmus/OPENCL/overhauling/ISA2.litmus @@ -1,4 +1,4 @@ -C ISA2 +OPENCL ISA2 (* * https://multicore.doc.ic.ac.uk/overhauling/OpenCL/ISA2.litmus diff --git a/litmus/OPENCL/overhauling/ISA2_broken.litmus b/litmus/OPENCL/overhauling/ISA2_broken.litmus index bbefe40040..9ee905ce74 100644 --- a/litmus/OPENCL/overhauling/ISA2_broken.litmus +++ b/litmus/OPENCL/overhauling/ISA2_broken.litmus @@ -1,4 +1,4 @@ -C ISA2_broken +OPENCL ISA2_broken (* * https://multicore.doc.ic.ac.uk/overhauling/OpenCL/ISA2_broken.litmus diff --git a/litmus/OPENCL/overhauling/MP_ra_dev.litmus b/litmus/OPENCL/overhauling/MP_ra_dev.litmus index e4073083ac..6ff6728ad2 100644 --- a/litmus/OPENCL/overhauling/MP_ra_dev.litmus +++ b/litmus/OPENCL/overhauling/MP_ra_dev.litmus @@ -1,4 +1,4 @@ -C MP_ra_dev +OPENCL MP_ra_dev (* * https://multicore.doc.ic.ac.uk/overhauling/OpenCL/MP_ra_dev.litmus diff --git a/litmus/OPENCL/overhauling/MP_ra_dev_broken.litmus b/litmus/OPENCL/overhauling/MP_ra_dev_broken.litmus index d73c0f2392..4b5920b4e3 100644 --- a/litmus/OPENCL/overhauling/MP_ra_dev_broken.litmus +++ b/litmus/OPENCL/overhauling/MP_ra_dev_broken.litmus @@ -1,4 +1,4 @@ -C MP_ra_dev_broken +OPENCL MP_ra_dev_broken (* * https://multicore.doc.ic.ac.uk/overhauling/OpenCL/MP_ra_dev_broken.litmus diff --git a/litmus/OPENCL/overhauling/MP_ra_wg.litmus b/litmus/OPENCL/overhauling/MP_ra_wg.litmus index b58997b90c..919952ee8f 100644 --- a/litmus/OPENCL/overhauling/MP_ra_wg.litmus +++ b/litmus/OPENCL/overhauling/MP_ra_wg.litmus @@ -1,4 +1,4 @@ -C MP_ra_wg +OPENCL MP_ra_wg (* * https://multicore.doc.ic.ac.uk/overhauling/OpenCL/MP_ra_wg.litmus diff --git a/litmus/OPENCL/overhauling/MP_sc_dev.litmus b/litmus/OPENCL/overhauling/MP_sc_dev.litmus index 48ce68a733..7b81af2674 100644 --- a/litmus/OPENCL/overhauling/MP_sc_dev.litmus +++ b/litmus/OPENCL/overhauling/MP_sc_dev.litmus @@ -1,4 +1,4 @@ -C MP_sc_dev +OPENCL MP_sc_dev (* * https://multicore.doc.ic.ac.uk/overhauling/OpenCL/MP_sc_dev.litmus diff --git a/litmus/OPENCL/overhauling/example10.litmus b/litmus/OPENCL/overhauling/example10.litmus index d9707eb1ba..c805967393 100644 --- a/litmus/OPENCL/overhauling/example10.litmus +++ b/litmus/OPENCL/overhauling/example10.litmus @@ -1,4 +1,4 @@ -C example10 +OPENCL example10 (* * https://multicore.doc.ic.ac.uk/overhauling/examples/example10.litmus diff --git a/litmus/OPENCL/overhauling/example4.litmus b/litmus/OPENCL/overhauling/example4.litmus index ea1623408f..4c589f6315 100644 --- a/litmus/OPENCL/overhauling/example4.litmus +++ b/litmus/OPENCL/overhauling/example4.litmus @@ -1,4 +1,4 @@ -C example4 +OPENCL example4 (* * https://multicore.doc.ic.ac.uk/overhauling/examples/example4.litmus diff --git a/litmus/OPENCL/overhauling/example5.litmus b/litmus/OPENCL/overhauling/example5.litmus index dc355eb915..06781ff029 100644 --- a/litmus/OPENCL/overhauling/example5.litmus +++ b/litmus/OPENCL/overhauling/example5.litmus @@ -1,4 +1,4 @@ -C example5 +OPENCL example5 (* * https://multicore.doc.ic.ac.uk/overhauling/examples/example5.litmus diff --git a/litmus/OPENCL/overhauling/example6.litmus b/litmus/OPENCL/overhauling/example6.litmus index 91b3c0eedb..738fd1da7c 100644 --- a/litmus/OPENCL/overhauling/example6.litmus +++ b/litmus/OPENCL/overhauling/example6.litmus @@ -1,4 +1,4 @@ -C example6 +OPENCL example6 (* * https://multicore.doc.ic.ac.uk/overhauling/examples/example6.litmus diff --git a/litmus/OPENCL/overhauling/example7a.litmus b/litmus/OPENCL/overhauling/example7a.litmus index f50ba20172..ad8a90c534 100644 --- a/litmus/OPENCL/overhauling/example7a.litmus +++ b/litmus/OPENCL/overhauling/example7a.litmus @@ -1,4 +1,4 @@ -C example7a +OPENCL example7a (* * https://multicore.doc.ic.ac.uk/overhauling/examples/example7a.litmus diff --git a/litmus/OPENCL/overhauling/example7b.litmus b/litmus/OPENCL/overhauling/example7b.litmus index 34b60b1ce2..b38fb1f93f 100644 --- a/litmus/OPENCL/overhauling/example7b.litmus +++ b/litmus/OPENCL/overhauling/example7b.litmus @@ -1,4 +1,4 @@ -C example7b +OPENCL example7b (* * https://multicore.doc.ic.ac.uk/overhauling/examples/example7b.litmus diff --git a/litmus/OPENCL/overhauling/example8.litmus b/litmus/OPENCL/overhauling/example8.litmus index 187641f8a7..f2e75d6b50 100644 --- a/litmus/OPENCL/overhauling/example8.litmus +++ b/litmus/OPENCL/overhauling/example8.litmus @@ -1,4 +1,4 @@ -C example8 +OPENCL example8 (* * https://multicore.doc.ic.ac.uk/overhauling/examples/example8.litmus diff --git a/litmus/OPENCL/overhauling/example9a.litmus b/litmus/OPENCL/overhauling/example9a.litmus index 9c44e5e903..ad4cd54d01 100644 --- a/litmus/OPENCL/overhauling/example9a.litmus +++ b/litmus/OPENCL/overhauling/example9a.litmus @@ -1,4 +1,4 @@ -C example9a +OPENCL example9a (* * https://multicore.doc.ic.ac.uk/overhauling/examples/example9a.litmus diff --git a/litmus/OPENCL/overhauling/example9b.litmus b/litmus/OPENCL/overhauling/example9b.litmus index c4d3093dcc..b16bfac8c3 100644 --- a/litmus/OPENCL/overhauling/example9b.litmus +++ b/litmus/OPENCL/overhauling/example9b.litmus @@ -1,4 +1,4 @@ -C example9b +OPENCL example9b (* * https://multicore.doc.ic.ac.uk/overhauling/examples/example9b.litmus 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)