/*
    This is our first concurrency test. It is deliberately simplistic to show
    testing approaches, introduce JCStress APIs, etc.

    Suppose we want to see if the field increment is atomic. We can make test
    with two actors, both actors incrementing the field and recording what
    value they observed into the result object. As JCStress runs, it will
    invoke these methods on the objects holding the field once per each actor
    and instance, and record what results are coming from there.

    Done enough times, we will get the history of observed results, and that
    would tell us something about the concurrent behavior.

    How to run this test:
       $ java -jar jcstress-samples/target/jcstress.jar -t API_01_Simple

       ...

        .......... [OK] org.openjdk.jcstress.samples.api.API_01_Simple

          Scheduling class:
            actor1: package group 0, core group 0
            actor2: package group 0, core group 0

          CPU allocation:
            actor1: CPU #3, package #0, core #3
            actor2: CPU #35, package #0, core #3

          Compilation: split
            actor1: C2
            actor2: C2

          JVM args: []

          RESULT      SAMPLES    FREQ       EXPECT  DESCRIPTION
            1, 1   46,946,789   10.1%  Interesting  Both actors came up with the same value: atomicity failure.
            1, 2  110,240,149   23.8%   Acceptable  actor1 incremented, then actor2.
            2, 1  306,529,420   66.1%   Acceptable  actor2 incremented, then actor1.
 */

// Mark the class as JCStress test.
@JCStressTest

// These are the test outcomes.
@Outcome(id = "1, 1", expect = ACCEPTABLE_INTERESTING, desc = "Both actors came up with the same value: atomicity failure.")
@Outcome(id = "1, 2", expect = ACCEPTABLE, desc = "actor1 incremented, then actor2.")
@Outcome(id = "2, 1", expect = ACCEPTABLE, desc = "actor2 incremented, then actor1.")

// This is a state object
@State
public class API_01_Simple {

    int v;

    @Actor
    public void actor1(II_Result r) {
        r.r1 = ++v; // record result from actor1 to field r1
    }

    @Actor
    public void actor2(II_Result r) {
        r.r2 = ++v; // record result from actor2 to field r2
    }

}

@JCStressTest
@Outcome(id = {"1, 2", "2, 1"}, expect = ACCEPTABLE, desc = "Mutex works")
@Outcome(id = "1, 1",           expect = FORBIDDEN,  desc = "Mutex failure")
@State
public class Mutex_06_Semaphore {

    /*
        How to run this test:
            $ java -jar jcstress-samples/target/jcstress.jar -t Mutex_06_Semaphore
    */

    /*
      ----------------------------------------------------------------------------------------------------------

        Single-permit Semaphore can be used as a crude mutex too. Of course, this primitive
        is much more flexible, it can admit a few threads at once with more permits.

        On x86_64, AArch64, PPC64:
          RESULT      SAMPLES     FREQ      EXPECT  DESCRIPTION
            1, 1            0    0.00%   Forbidden  Mutex failure
            1, 2  254,394,919   50.23%  Acceptable  Mutex works
            2, 1  252,081,625   49.77%  Acceptable  Mutex works
     */

    private final Semaphore semaphore = new Semaphore(1);
    private int v;

    @Actor
    public void actor1(II_Result r) {
        try {
            semaphore.acquire();
            // critical section
            r.r1 = ++v;
            semaphore.release();
        } catch (InterruptedException e) {
            throw new IllegalStateException(e);
        }
    }

    @Actor
    public void actor2(II_Result r) {
        try {
            semaphore.acquire();
            // critical section
            r.r2 = ++v;
            semaphore.release();
        } catch (InterruptedException e) {
            throw new IllegalStateException(e);
        }
    }
}