I'm not able to run many of the testbenches which worked just fine with any version of

Thanks for reporting these issues. Could you please set <code class=

output with EnableDebug=true <div class="snippet-clipboard-content notr

Frequent crash on macOS with the threaded Verilator backend ,about ucb-bar/chiseltest

Comments (6)

ekiwi commented on September 25, 2024

Thanks for reporting these issues.

Could you please set EnableDebug in the Scheduler class to true and then post the output of the problems you are observing? That might make it possible for me to debug them.

from chiseltest.

kammoh commented on September 25, 2024

output with EnableDebug=true

0@0: forkThread(chiseltest_thread_1 (1) P0) from 0
0@0: yieldForFork()
0@0:   --> 1: P(0), [0]: R
0@0:   --> nextThreadId = 1
1@0: forkThread(chiseltest_thread_2 (2) P1) from 1
1@0: yieldForFork()
1@0:   --> [1]: R, 0: P(0), 2: P(0)
1@0:   --> nextThreadId = 1
1@0: joinThreads(ids = List(2))
1@0:   --> nextThreadId = 0
0@0: forkThread(chiseltest_thread_3 (3) P0) from 0
0@0: yieldForFork()
0@0:   --> 1: J(2), 3: P(0), [0]: R, 2: P(0)
0@0:   --> nextThreadId = 3
3@0: forkThread(chiseltest_thread_4 (4) P1) from 3
3@0: yieldForFork()
3@0:   --> 1: J(2), [3]: R, 0: P(0), 2: P(0), 4: P(0)
3@0:   --> nextThreadId = 3
3@0: joinThreads(ids = List(4))
3@0:   --> nextThreadId = 0
0@0: forkThread(chiseltest_thread_5 (5) P0) from 0
0@0: yieldForFork()
0@0:   --> 1: J(2), 3: J(4), 5: P(0), [0]: R, 2: P(0), 4: P(0)
0@0:   --> nextThreadId = 5
5@0: forkThread(chiseltest_thread_6 (6) P1) from 5
5@0: yieldForFork()
5@0:   --> 1: J(2), 3: J(4), [5]: R, 0: P(0), 2: P(0), 4: P(0), 6: P(0)
5@0:   --> nextThreadId = 5
5@0: joinThreads(ids = List(6))
5@0:   --> nextThreadId = 0
0@0: joinThreads(ids = List(1, 3, 5))
0@0:   --> nextThreadId = 2
2@0: finishThread(id=2 (chiseltest_thread_2))
2@0:   --> 1: J(2), 3: J(4), 5: J(6), 0: J(1), 4: P(0), 6: P(0)
1@0: stepThread(cycles = 1): minPause = 0
1@0:   --> [1]: R, 3: J(4), 5: J(6), 0: J(1), 4: P(0), 6: P(0)
1@0: yieldForStep(cycles = 1)
1@0:   --> [1]: P(1), 3: J(4), 5: J(6), 0: J(1), 4: P(0), 6: P(0)
1@0:   --> nextThreadId = 4
4@0: stepThread(cycles = 1): minPause = 0
4@0:   --> 1: P(1), 3: J(4), 5: J(6), 0: J(1), [4]: R, 6: P(0)
4@0: yieldForStep(cycles = 1)
4@0:   --> 1: P(1), 3: J(4), 5: J(6), 0: J(1), [4]: P(1), 6: P(0)
4@0:   --> nextThreadId = 6
6@0: stepThread(cycles = 1): minPause = 1
6@0:   --> 1: P(1), 3: J(4), 5: J(6), 0: J(1), 4: P(1), [6]: R
6@0: doStep(cycles = 1)
6@1: yieldForStep(cycles = 0)
6@1:   --> 1: P(0), 3: J(4), 5: J(6), 0: J(1), 4: P(0), [6]: P(0)
6@1:   --> nextThreadId = 1
1@1: finishThread(id=1 (chiseltest_thread_1))
1@1:   --> 3: J(4), 5: J(6), 0: J(1), 4: P(0), 6: P(0)
0@1:   --> nextThreadId = 4
4@1: finishThread(id=4 (chiseltest_thread_4))
4@1:   --> 3: J(4), 5: J(6), 0: J(3), 6: P(0)
3@1: stepThread(cycles = 1): minPause = 0
3@1:   --> [3]: R, 5: J(6), 0: J(3), 6: P(0)
3@1: yieldForStep(cycles = 1)
3@1:   --> [3]: P(1), 5: J(6), 0: J(3), 6: P(0)
3@1:   --> nextThreadId = 6
6@1: stepThread(cycles = 1): minPause = 1
6@1:   --> 3: P(1), 5: J(6), 0: J(3), [6]: R
6@1: doStep(cycles = 1)
6@2: yieldForStep(cycles = 0)
6@2:   --> 3: P(0), 5: J(6), 0: J(3), [6]: P(0)
6@2:   --> nextThreadId = 3
3@2: forkThread(chiseltest_thread_7 (7) P1) from 3
3@2: yieldForFork()
3@2:   --> [3]: R, 5: J(6), 0: J(3), 7: P(0), 6: P(0)
3@2:   --> nextThreadId = 3
3@2: joinThreads(ids = List(7))
3@2:   --> nextThreadId = 7
7@2: finishThread(id=7 (chiseltest_thread_7))
7@2:   --> 3: J(7), 5: J(6), 0: J(3), 6: P(0)
3@2: stepThread(cycles = 1): minPause = 0
3@2:   --> [3]: R, 5: J(6), 0: J(3), 6: P(0)
3@2: yieldForStep(cycles = 1)
3@2:   --> [3]: P(1), 5: J(6), 0: J(3), 6: P(0)
3@2:   --> nextThreadId = 6
6@2: stepThread(cycles = 1): minPause = 1
6@2:   --> 3: P(1), 5: J(6), 0: J(3), [6]: R
6@2: doStep(cycles = 1)
6@3: yieldForStep(cycles = 0)
6@3:   --> 3: P(0), 5: J(6), 0: J(3), [6]: P(0)
6@3:   --> nextThreadId = 3
3@3: finishThread(id=3 (chiseltest_thread_3))
3@3:   --> 5: J(6), 0: J(3), 6: P(0)
0@3:   --> nextThreadId = 6
6@3: doStep(cycles = 1)
6@4: doStep(cycles = 1)
6@5: doStep(cycles = 1)
6@6: doStep(cycles = 1)
6@7: doStep(cycles = 1)
6@8: doStep(cycles = 1)
6@9: doStep(cycles = 1)
6@10: doStep(cycles = 1)
6@11: doStep(cycles = 1)
6@12: doStep(cycles = 1)
6@13: doStep(cycles = 1)
6@14: doStep(cycles = 1)
6@15: doStep(cycles = 1)
6@16: doStep(cycles = 1)
6@17: doStep(cycles = 1)
6@18: doStep(cycles = 1)
6@19: doStep(cycles = 1)
6@20: doStep(cycles = 1)
6@21: doStep(cycles = 1)
6@22: doStep(cycles = 1)
6@23: doStep(cycles = 1)
6@24: doStep(cycles = 1)
6@25: doStep(cycles = 1)
6@26: doStep(cycles = 1)
6@27: finishThread(id=6 (chiseltest_thread_6))
6@27:   --> 5: J(6), 0: J(5)
5@27: doStep(cycles = 1)
5@28: forkThread(chiseltest_thread_8 (8) P1) from 5
5@28: yieldForFork()
5@28:   --> [5]: R, 0: J(5), 8: P(0)
5@28:   --> nextThreadId = 5
5@28: joinThreads(ids = List(8))
5@28:   --> nextThreadId = 8
8@28: finishThread(id=8 (chiseltest_thread_8))
8@28:   --> 5: J(8), 0: J(5)
5@28: doStep(cycles = 1)
5@29: forkThread(chiseltest_thread_9 (9) P1) from 5
5@29: yieldForFork()
5@29:   --> [5]: R, 0: J(5), 9: P(0)
5@29:   --> nextThreadId = 5
5@29: joinThreads(ids = List(9))
5@29:   --> nextThreadId = 9
9@29: finishThread(id=9 (chiseltest_thread_9))
9@29:   --> 5: J(9), 0: J(5)
5@29: doStep(cycles = 1)
5@30: forkThread(chiseltest_thread_10 (10) P1) from 5
5@30: yieldForFork()
5@30:   --> [5]: R, 0: J(5), 10: P(0)
5@30:   --> nextThreadId = 5
5@30: joinThreads(ids = List(10))
5@30:   --> nextThreadId = 10
10@30: finishThread(id=10 (chiseltest_thread_10))
10@30:   --> 5: J(10), 0: J(5)
5@30: doStep(cycles = 1)
5@31: finishThread(id=5 (chiseltest_thread_5))
5@31:   --> 0: J(5)

0@31: forkThread(chiseltest_thread_11 (11) P0) from 0
0@31: yieldForFork()
0@31:   --> 11: P(0), [0]: R
0@31:   --> nextThreadId = 11
11@31: forkThread(chiseltest_thread_12 (12) P1) from 11
11@31: yieldForFork()
11@31:   --> [11]: R, 0: P(0), 12: P(0)
11@31:   --> nextThreadId = 11
11@31: joinThreads(ids = List(12))
11@31:   --> nextThreadId = 0
0@31: forkThread(chiseltest_thread_13 (13) P0) from 0
0@31: yieldForFork()
0@31:   --> 11: J(12), 13: P(0), [0]: R, 12: P(0)
0@31:   --> nextThreadId = 13
13@31: forkThread(chiseltest_thread_14 (14) P1) from 13
13@31: yieldForFork()
13@31:   --> 11: J(12), [13]: R, 0: P(0), 12: P(0), 14: P(0)
13@31:   --> nextThreadId = 13
13@31: joinThreads(ids = List(14))
13@31:   --> nextThreadId = 0
0@31: forkThread(chiseltest_thread_15 (15) P0) from 0
0@31: yieldForFork()
0@31:   --> 11: J(12), 13: J(14), 15: P(0), [0]: R, 12: P(0), 14: P(0)
0@31:   --> nextThreadId = 15
15@31: Caught exception (chiseltest.ThreadOrderDependentException). Shutting down and propagating exception to parent.
15@31: finishThread(id=15 (chiseltest_thread_15))
15@31:   --> 11: J(12), 13: J(14), 0: P(0), 12: P(0), 14: P(0)
15@31:   --> nextThreadId = 0
0@31: terminating: chiseltest_thread_11 (11), chiseltest_thread_13 (13), chiseltest_thread_14 (14), chiseltest_thread_12 (12)
- should work *** FAILED ***
  java.lang.AssertionError: assertion failed: Cannot terminate thread waiting for join chiseltest_thread_11 (11)
  at scala.Predef$.assert(Predef.scala:279)
  at chiseltest.internal.Scheduler.chiseltest$internal$Scheduler$$terminateAllChildThreads(Scheduler.scala:427)
  at chiseltest.internal.Scheduler.finishMainThread(Scheduler.scala:446)
  at chiseltest.internal.SimController.run(SimController.scala:127)
  at chiseltest.internal.Context$.$anonfun$runTest$2(Context.scala:30)
  at scala.util.DynamicVariable.withValue(DynamicVariable.scala:59)
  at chiseltest.internal.Context$.runTest(Context.scala:30)
  at chiseltest.ChiselScalatestTester.chiseltest$ChiselScalatestTester$$runTest(ChiselScalatestTester.scala:96)
  at chiseltest.ChiselScalatestTester$TestBuilder.apply(ChiselScalatestTester.scala:30)
  at MyCoreSpec.$anonfun$new$1(MyCoreSpec.scala:36)
  ...
Execution took 2.15s
1 tests, 1 failed

from chiseltest.

kammoh commented on September 25, 2024

Here's a minimal testcase which shows the issue:

Minimal working example code

import chisel3._
import chisel3.util._
import chiseltest._
import org.scalatest.flatspec.AnyFlatSpec

class Dut extends Module {
  val io = IO(new Bundle {
    val din = Flipped(Decoupled(UInt(8.W)))
    val dout = Decoupled(UInt(256.W))
  })

  object State extends ChiselEnum {
    val Idle, Receive, Send = Value
  }
  val state = RegInit(State.Idle)

  val counter = Counter(100)
  val accumulator = Reg(io.dout.bits.cloneType)

  io.din.ready := state === State.Receive
  io.dout.valid := state === State.Send
  io.dout.bits := accumulator

  when(state === State.Idle) {
    state := State.Receive
    accumulator := 0.U
  }
  when(io.din.fire) {
    accumulator := accumulator + io.din.bits
    when(counter.inc()) {
      state := State.Send
    }
  }
  when(io.dout.fire) {
    state := State.Idle
  }

}

class MWE extends AnyFlatSpec with ChiselScalatestTester {

  val annos = Seq(
    VerilatorBackendAnnotation,
  )
  
  it should "work" in {
    test(new Dut()).withAnnotations(annos) { dut =>
      val dw = dut.io.din.bits.getWidth
      def randData = BigInt(dw, scala.util.Random).U(dw.W)
      
      for (
        input <- Seq(
          Seq.fill(100)(randData),
          Seq.fill(100)(randData),
        )
      ) {
        val expected = input.map(_.litValue).sum
        fork {
          dut.io.din.enqueueSeq(input)
        }.fork {
          dut.io.dout.expectDequeue(expected.U)
        }.join()
      }
    }
  }
}

output

MWE:
0@0: forkThread(chiseltest_thread_1 (1) P0) from 0
0@0: yieldForFork()
0@0:   --> 1: P(0), [0]: R
0@0:   --> nextThreadId = 1
@0: [0]: P(0) -> 1: P(0) fork
0@0:   --> 1: P(0), [0]: P(0)
1@0: forkThread(chiseltest_thread_2 (2) P1) from 1
1@0: yieldForFork()
1@0:   --> [1]: R, 0: P(0), 2: P(0)
1@0:   --> nextThreadId = 1
1@0: joinThreads(ids = List(2))
1@0:   --> nextThreadId = 0
@0: [1]: J(2) -> 0: P(0) waiting for 2
1@0:   --> [1]: J(2), 0: P(0), 2: P(0)
0@0: forkThread(chiseltest_thread_3 (3) P0) from 0
0@0: yieldForFork()
0@0:   --> 1: J(2), 3: P(0), [0]: R, 2: P(0)
0@0:   --> nextThreadId = 3
@0: [0]: P(0) -> 3: P(0) fork
0@0:   --> 1: J(2), 3: P(0), [0]: P(0), 2: P(0)
3@0: forkThread(chiseltest_thread_4 (4) P1) from 3
3@0: yieldForFork()
3@0:   --> 1: J(2), [3]: R, 0: P(0), 2: P(0), 4: P(0)
3@0:   --> nextThreadId = 3
3@0: joinThreads(ids = List(4))
3@0:   --> nextThreadId = 0
@0: [3]: J(4) -> 0: P(0) waiting for 4
3@0:   --> 1: J(2), [3]: J(4), 0: P(0), 2: P(0), 4: P(0)
0@0: joinThreads(ids = List(1, 3))
0@0:   --> nextThreadId = 2
@0: [0]: J(1) -> 2: P(0) waiting for 1
0@0:   --> 1: J(2), 3: J(4), [0]: J(1), 2: P(0), 4: P(0)
2@0: finishThread(id=2 (chiseltest_thread_2))
2@0:   --> 1: J(2), 3: J(4), 0: J(1), 4: P(0)
@0: [2]: F -> 1: J(2) finish unblocks join
2@0:   --> 1: J(2), 3: J(4), 0: J(1), 4: P(0)
1@0: stepThread(cycles = 1): minPause = 0
1@0:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@0: yieldForStep(cycles = 1)
1@0:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@0:   --> nextThreadId = 4
@0: [1]: P(1) -> 4: P(0) yield for step (1)
1@0:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@0: stepThread(cycles = 1): minPause = 1
4@0:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@0: doStep(cycles = 1)
4@1: yieldForStep(cycles = 0)
4@1:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@1:   --> nextThreadId = 1
@1: [4]: P(0) -> 1: P(0) yield for step (0)
4@1:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@1: forkThread(chiseltest_thread_5 (5) P1) from 1
1@1: yieldForFork()
1@1:   --> [1]: R, 3: J(4), 0: J(1), 5: P(0), 4: P(0)
1@1:   --> nextThreadId = 1
1@1: joinThreads(ids = List(5))
1@1:   --> nextThreadId = 5
@1: [1]: J(5) -> 5: P(0) waiting for 5
1@1:   --> [1]: J(5), 3: J(4), 0: J(1), 5: P(0), 4: P(0)
5@1: finishThread(id=5 (chiseltest_thread_5))
5@1:   --> 1: J(5), 3: J(4), 0: J(1), 4: P(0)
@1: [5]: F -> 1: J(5) finish unblocks join
5@1:   --> 1: J(5), 3: J(4), 0: J(1), 4: P(0)
1@1: stepThread(cycles = 1): minPause = 0
1@1:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@1: yieldForStep(cycles = 1)
1@1:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@1:   --> nextThreadId = 4
@1: [1]: P(1) -> 4: P(0) yield for step (1)
1@1:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@1: stepThread(cycles = 1): minPause = 1
4@1:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@1: doStep(cycles = 1)
4@2: yieldForStep(cycles = 0)
4@2:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@2:   --> nextThreadId = 1
@2: [4]: P(0) -> 1: P(0) yield for step (0)
4@2:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@2: forkThread(chiseltest_thread_6 (6) P1) from 1
1@2: yieldForFork()
1@2:   --> [1]: R, 3: J(4), 0: J(1), 6: P(0), 4: P(0)
1@2:   --> nextThreadId = 1
1@2: joinThreads(ids = List(6))
1@2:   --> nextThreadId = 6
@2: [1]: J(6) -> 6: P(0) waiting for 6
1@2:   --> [1]: J(6), 3: J(4), 0: J(1), 6: P(0), 4: P(0)
6@2: finishThread(id=6 (chiseltest_thread_6))
6@2:   --> 1: J(6), 3: J(4), 0: J(1), 4: P(0)
@2: [6]: F -> 1: J(6) finish unblocks join
6@2:   --> 1: J(6), 3: J(4), 0: J(1), 4: P(0)
1@2: stepThread(cycles = 1): minPause = 0
1@2:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@2: yieldForStep(cycles = 1)
1@2:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@2:   --> nextThreadId = 4
@2: [1]: P(1) -> 4: P(0) yield for step (1)
1@2:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@2: stepThread(cycles = 1): minPause = 1
4@2:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@2: doStep(cycles = 1)
4@3: yieldForStep(cycles = 0)
4@3:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@3:   --> nextThreadId = 1
@3: [4]: P(0) -> 1: P(0) yield for step (0)
4@3:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@3: forkThread(chiseltest_thread_7 (7) P1) from 1
1@3: yieldForFork()
1@3:   --> [1]: R, 3: J(4), 0: J(1), 7: P(0), 4: P(0)
1@3:   --> nextThreadId = 1
1@3: joinThreads(ids = List(7))
1@3:   --> nextThreadId = 7
@3: [1]: J(7) -> 7: P(0) waiting for 7
1@3:   --> [1]: J(7), 3: J(4), 0: J(1), 7: P(0), 4: P(0)
7@3: finishThread(id=7 (chiseltest_thread_7))
7@3:   --> 1: J(7), 3: J(4), 0: J(1), 4: P(0)
@3: [7]: F -> 1: J(7) finish unblocks join
7@3:   --> 1: J(7), 3: J(4), 0: J(1), 4: P(0)
1@3: stepThread(cycles = 1): minPause = 0
1@3:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@3: yieldForStep(cycles = 1)
1@3:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@3:   --> nextThreadId = 4
@3: [1]: P(1) -> 4: P(0) yield for step (1)
1@3:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@3: stepThread(cycles = 1): minPause = 1
4@3:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@3: doStep(cycles = 1)
4@4: yieldForStep(cycles = 0)
4@4:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@4:   --> nextThreadId = 1
@4: [4]: P(0) -> 1: P(0) yield for step (0)
4@4:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@4: forkThread(chiseltest_thread_8 (8) P1) from 1
1@4: yieldForFork()
1@4:   --> [1]: R, 3: J(4), 0: J(1), 8: P(0), 4: P(0)
1@4:   --> nextThreadId = 1
1@4: joinThreads(ids = List(8))
1@4:   --> nextThreadId = 8
@4: [1]: J(8) -> 8: P(0) waiting for 8
1@4:   --> [1]: J(8), 3: J(4), 0: J(1), 8: P(0), 4: P(0)
8@4: finishThread(id=8 (chiseltest_thread_8))
8@4:   --> 1: J(8), 3: J(4), 0: J(1), 4: P(0)
@4: [8]: F -> 1: J(8) finish unblocks join
8@4:   --> 1: J(8), 3: J(4), 0: J(1), 4: P(0)
1@4: stepThread(cycles = 1): minPause = 0
1@4:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@4: yieldForStep(cycles = 1)
1@4:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@4:   --> nextThreadId = 4
@4: [1]: P(1) -> 4: P(0) yield for step (1)
1@4:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@4: stepThread(cycles = 1): minPause = 1
4@4:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@4: doStep(cycles = 1)
4@5: yieldForStep(cycles = 0)
4@5:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@5:   --> nextThreadId = 1
@5: [4]: P(0) -> 1: P(0) yield for step (0)
4@5:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@5: forkThread(chiseltest_thread_9 (9) P1) from 1
1@5: yieldForFork()
1@5:   --> [1]: R, 3: J(4), 0: J(1), 9: P(0), 4: P(0)
1@5:   --> nextThreadId = 1
1@5: joinThreads(ids = List(9))
1@5:   --> nextThreadId = 9
@5: [1]: J(9) -> 9: P(0) waiting for 9
1@5:   --> [1]: J(9), 3: J(4), 0: J(1), 9: P(0), 4: P(0)
9@5: finishThread(id=9 (chiseltest_thread_9))
9@5:   --> 1: J(9), 3: J(4), 0: J(1), 4: P(0)
@5: [9]: F -> 1: J(9) finish unblocks join
9@5:   --> 1: J(9), 3: J(4), 0: J(1), 4: P(0)
1@5: stepThread(cycles = 1): minPause = 0
1@5:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@5: yieldForStep(cycles = 1)
1@5:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@5:   --> nextThreadId = 4
@5: [1]: P(1) -> 4: P(0) yield for step (1)
1@5:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@5: stepThread(cycles = 1): minPause = 1
4@5:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@5: doStep(cycles = 1)
4@6: yieldForStep(cycles = 0)
4@6:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@6:   --> nextThreadId = 1
@6: [4]: P(0) -> 1: P(0) yield for step (0)
4@6:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@6: forkThread(chiseltest_thread_10 (10) P1) from 1
1@6: yieldForFork()
1@6:   --> [1]: R, 3: J(4), 0: J(1), 10: P(0), 4: P(0)
1@6:   --> nextThreadId = 1
1@6: joinThreads(ids = List(10))
1@6:   --> nextThreadId = 10
@6: [1]: J(10) -> 10: P(0) waiting for 10
1@6:   --> [1]: J(10), 3: J(4), 0: J(1), 10: P(0), 4: P(0)
10@6: finishThread(id=10 (chiseltest_thread_10))
10@6:   --> 1: J(10), 3: J(4), 0: J(1), 4: P(0)
@6: [10]: F -> 1: J(10) finish unblocks join
10@6:   --> 1: J(10), 3: J(4), 0: J(1), 4: P(0)
1@6: stepThread(cycles = 1): minPause = 0
1@6:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@6: yieldForStep(cycles = 1)
1@6:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@6:   --> nextThreadId = 4
@6: [1]: P(1) -> 4: P(0) yield for step (1)
1@6:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@6: stepThread(cycles = 1): minPause = 1
4@6:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@6: doStep(cycles = 1)
4@7: yieldForStep(cycles = 0)
4@7:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@7:   --> nextThreadId = 1
@7: [4]: P(0) -> 1: P(0) yield for step (0)
4@7:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@7: forkThread(chiseltest_thread_11 (11) P1) from 1
1@7: yieldForFork()
1@7:   --> [1]: R, 3: J(4), 0: J(1), 11: P(0), 4: P(0)
1@7:   --> nextThreadId = 1
1@7: joinThreads(ids = List(11))
1@7:   --> nextThreadId = 11
@7: [1]: J(11) -> 11: P(0) waiting for 11
1@7:   --> [1]: J(11), 3: J(4), 0: J(1), 11: P(0), 4: P(0)
11@7: finishThread(id=11 (chiseltest_thread_11))
11@7:   --> 1: J(11), 3: J(4), 0: J(1), 4: P(0)
@7: [11]: F -> 1: J(11) finish unblocks join
11@7:   --> 1: J(11), 3: J(4), 0: J(1), 4: P(0)
1@7: stepThread(cycles = 1): minPause = 0
1@7:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@7: yieldForStep(cycles = 1)
1@7:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@7:   --> nextThreadId = 4
@7: [1]: P(1) -> 4: P(0) yield for step (1)
1@7:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@7: stepThread(cycles = 1): minPause = 1
4@7:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@7: doStep(cycles = 1)
4@8: yieldForStep(cycles = 0)
4@8:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@8:   --> nextThreadId = 1
@8: [4]: P(0) -> 1: P(0) yield for step (0)
4@8:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@8: forkThread(chiseltest_thread_12 (12) P1) from 1
1@8: yieldForFork()
1@8:   --> [1]: R, 3: J(4), 0: J(1), 12: P(0), 4: P(0)
1@8:   --> nextThreadId = 1
1@8: joinThreads(ids = List(12))
1@8:   --> nextThreadId = 12
@8: [1]: J(12) -> 12: P(0) waiting for 12
1@8:   --> [1]: J(12), 3: J(4), 0: J(1), 12: P(0), 4: P(0)
12@8: finishThread(id=12 (chiseltest_thread_12))
12@8:   --> 1: J(12), 3: J(4), 0: J(1), 4: P(0)
@8: [12]: F -> 1: J(12) finish unblocks join
12@8:   --> 1: J(12), 3: J(4), 0: J(1), 4: P(0)
1@8: stepThread(cycles = 1): minPause = 0
1@8:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@8: yieldForStep(cycles = 1)
1@8:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@8:   --> nextThreadId = 4
@8: [1]: P(1) -> 4: P(0) yield for step (1)
1@8:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@8: stepThread(cycles = 1): minPause = 1
4@8:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@8: doStep(cycles = 1)
4@9: yieldForStep(cycles = 0)
4@9:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@9:   --> nextThreadId = 1
@9: [4]: P(0) -> 1: P(0) yield for step (0)
4@9:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@9: forkThread(chiseltest_thread_13 (13) P1) from 1
1@9: yieldForFork()
1@9:   --> [1]: R, 3: J(4), 0: J(1), 13: P(0), 4: P(0)
1@9:   --> nextThreadId = 1
1@9: joinThreads(ids = List(13))
1@9:   --> nextThreadId = 13
@9: [1]: J(13) -> 13: P(0) waiting for 13
1@9:   --> [1]: J(13), 3: J(4), 0: J(1), 13: P(0), 4: P(0)
13@9: finishThread(id=13 (chiseltest_thread_13))
13@9:   --> 1: J(13), 3: J(4), 0: J(1), 4: P(0)
@9: [13]: F -> 1: J(13) finish unblocks join
13@9:   --> 1: J(13), 3: J(4), 0: J(1), 4: P(0)
1@9: stepThread(cycles = 1): minPause = 0
1@9:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@9: yieldForStep(cycles = 1)
1@9:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@9:   --> nextThreadId = 4
@9: [1]: P(1) -> 4: P(0) yield for step (1)
1@9:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@9: stepThread(cycles = 1): minPause = 1
4@9:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@9: doStep(cycles = 1)
4@10: yieldForStep(cycles = 0)
4@10:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@10:   --> nextThreadId = 1
@10: [4]: P(0) -> 1: P(0) yield for step (0)
4@10:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@10: forkThread(chiseltest_thread_14 (14) P1) from 1
1@10: yieldForFork()
1@10:   --> [1]: R, 3: J(4), 0: J(1), 14: P(0), 4: P(0)
1@10:   --> nextThreadId = 1
1@10: joinThreads(ids = List(14))
1@10:   --> nextThreadId = 14
@10: [1]: J(14) -> 14: P(0) waiting for 14
1@10:   --> [1]: J(14), 3: J(4), 0: J(1), 14: P(0), 4: P(0)
14@10: finishThread(id=14 (chiseltest_thread_14))
14@10:   --> 1: J(14), 3: J(4), 0: J(1), 4: P(0)
@10: [14]: F -> 1: J(14) finish unblocks join
14@10:   --> 1: J(14), 3: J(4), 0: J(1), 4: P(0)
1@10: stepThread(cycles = 1): minPause = 0
1@10:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@10: yieldForStep(cycles = 1)
1@10:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@10:   --> nextThreadId = 4
@10: [1]: P(1) -> 4: P(0) yield for step (1)
1@10:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@10: stepThread(cycles = 1): minPause = 1
4@10:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@10: doStep(cycles = 1)
4@11: yieldForStep(cycles = 0)
4@11:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@11:   --> nextThreadId = 1
@11: [4]: P(0) -> 1: P(0) yield for step (0)
4@11:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@11: forkThread(chiseltest_thread_15 (15) P1) from 1
1@11: yieldForFork()
1@11:   --> [1]: R, 3: J(4), 0: J(1), 15: P(0), 4: P(0)
1@11:   --> nextThreadId = 1
1@11: joinThreads(ids = List(15))
1@11:   --> nextThreadId = 15
@11: [1]: J(15) -> 15: P(0) waiting for 15
1@11:   --> [1]: J(15), 3: J(4), 0: J(1), 15: P(0), 4: P(0)
15@11: finishThread(id=15 (chiseltest_thread_15))
15@11:   --> 1: J(15), 3: J(4), 0: J(1), 4: P(0)
@11: [15]: F -> 1: J(15) finish unblocks join
15@11:   --> 1: J(15), 3: J(4), 0: J(1), 4: P(0)
1@11: stepThread(cycles = 1): minPause = 0
1@11:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@11: yieldForStep(cycles = 1)
1@11:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@11:   --> nextThreadId = 4
@11: [1]: P(1) -> 4: P(0) yield for step (1)
1@11:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@11: stepThread(cycles = 1): minPause = 1
4@11:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@11: doStep(cycles = 1)
4@12: yieldForStep(cycles = 0)
4@12:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@12:   --> nextThreadId = 1
@12: [4]: P(0) -> 1: P(0) yield for step (0)
4@12:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@12: forkThread(chiseltest_thread_16 (16) P1) from 1
1@12: yieldForFork()
1@12:   --> [1]: R, 3: J(4), 0: J(1), 16: P(0), 4: P(0)
1@12:   --> nextThreadId = 1
1@12: joinThreads(ids = List(16))
1@12:   --> nextThreadId = 16
@12: [1]: J(16) -> 16: P(0) waiting for 16
1@12:   --> [1]: J(16), 3: J(4), 0: J(1), 16: P(0), 4: P(0)
16@12: finishThread(id=16 (chiseltest_thread_16))
16@12:   --> 1: J(16), 3: J(4), 0: J(1), 4: P(0)
@12: [16]: F -> 1: J(16) finish unblocks join
16@12:   --> 1: J(16), 3: J(4), 0: J(1), 4: P(0)
1@12: stepThread(cycles = 1): minPause = 0
1@12:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@12: yieldForStep(cycles = 1)
1@12:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@12:   --> nextThreadId = 4
@12: [1]: P(1) -> 4: P(0) yield for step (1)
1@12:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@12: stepThread(cycles = 1): minPause = 1
4@12:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@12: doStep(cycles = 1)
4@13: yieldForStep(cycles = 0)
4@13:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@13:   --> nextThreadId = 1
@13: [4]: P(0) -> 1: P(0) yield for step (0)
4@13:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@13: forkThread(chiseltest_thread_17 (17) P1) from 1
1@13: yieldForFork()
1@13:   --> [1]: R, 3: J(4), 0: J(1), 17: P(0), 4: P(0)
1@13:   --> nextThreadId = 1
1@13: joinThreads(ids = List(17))
1@13:   --> nextThreadId = 17
@13: [1]: J(17) -> 17: P(0) waiting for 17
1@13:   --> [1]: J(17), 3: J(4), 0: J(1), 17: P(0), 4: P(0)
17@13: finishThread(id=17 (chiseltest_thread_17))
17@13:   --> 1: J(17), 3: J(4), 0: J(1), 4: P(0)
@13: [17]: F -> 1: J(17) finish unblocks join
17@13:   --> 1: J(17), 3: J(4), 0: J(1), 4: P(0)
1@13: stepThread(cycles = 1): minPause = 0
1@13:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@13: yieldForStep(cycles = 1)
1@13:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@13:   --> nextThreadId = 4
@13: [1]: P(1) -> 4: P(0) yield for step (1)
1@13:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@13: stepThread(cycles = 1): minPause = 1
4@13:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@13: doStep(cycles = 1)
4@14: yieldForStep(cycles = 0)
4@14:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@14:   --> nextThreadId = 1
@14: [4]: P(0) -> 1: P(0) yield for step (0)
4@14:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@14: forkThread(chiseltest_thread_18 (18) P1) from 1
1@14: yieldForFork()
1@14:   --> [1]: R, 3: J(4), 0: J(1), 18: P(0), 4: P(0)
1@14:   --> nextThreadId = 1
1@14: joinThreads(ids = List(18))
1@14:   --> nextThreadId = 18
@14: [1]: J(18) -> 18: P(0) waiting for 18
1@14:   --> [1]: J(18), 3: J(4), 0: J(1), 18: P(0), 4: P(0)
18@14: finishThread(id=18 (chiseltest_thread_18))
18@14:   --> 1: J(18), 3: J(4), 0: J(1), 4: P(0)
@14: [18]: F -> 1: J(18) finish unblocks join
18@14:   --> 1: J(18), 3: J(4), 0: J(1), 4: P(0)
1@14: stepThread(cycles = 1): minPause = 0
1@14:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@14: yieldForStep(cycles = 1)
1@14:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@14:   --> nextThreadId = 4
@14: [1]: P(1) -> 4: P(0) yield for step (1)
1@14:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@14: stepThread(cycles = 1): minPause = 1
4@14:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@14: doStep(cycles = 1)
4@15: yieldForStep(cycles = 0)
4@15:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@15:   --> nextThreadId = 1
@15: [4]: P(0) -> 1: P(0) yield for step (0)
4@15:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@15: forkThread(chiseltest_thread_19 (19) P1) from 1
1@15: yieldForFork()
1@15:   --> [1]: R, 3: J(4), 0: J(1), 19: P(0), 4: P(0)
1@15:   --> nextThreadId = 1
1@15: joinThreads(ids = List(19))
1@15:   --> nextThreadId = 19
@15: [1]: J(19) -> 19: P(0) waiting for 19
1@15:   --> [1]: J(19), 3: J(4), 0: J(1), 19: P(0), 4: P(0)
19@15: finishThread(id=19 (chiseltest_thread_19))
19@15:   --> 1: J(19), 3: J(4), 0: J(1), 4: P(0)
@15: [19]: F -> 1: J(19) finish unblocks join
19@15:   --> 1: J(19), 3: J(4), 0: J(1), 4: P(0)
1@15: stepThread(cycles = 1): minPause = 0
1@15:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@15: yieldForStep(cycles = 1)
1@15:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@15:   --> nextThreadId = 4
@15: [1]: P(1) -> 4: P(0) yield for step (1)
1@15:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@15: stepThread(cycles = 1): minPause = 1
4@15:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@15: doStep(cycles = 1)
4@16: yieldForStep(cycles = 0)
4@16:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@16:   --> nextThreadId = 1
@16: [4]: P(0) -> 1: P(0) yield for step (0)
4@16:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@16: forkThread(chiseltest_thread_20 (20) P1) from 1
1@16: yieldForFork()
1@16:   --> [1]: R, 3: J(4), 0: J(1), 20: P(0), 4: P(0)
1@16:   --> nextThreadId = 1
1@16: joinThreads(ids = List(20))
1@16:   --> nextThreadId = 20
@16: [1]: J(20) -> 20: P(0) waiting for 20
1@16:   --> [1]: J(20), 3: J(4), 0: J(1), 20: P(0), 4: P(0)
20@16: finishThread(id=20 (chiseltest_thread_20))
20@16:   --> 1: J(20), 3: J(4), 0: J(1), 4: P(0)
@16: [20]: F -> 1: J(20) finish unblocks join
20@16:   --> 1: J(20), 3: J(4), 0: J(1), 4: P(0)
1@16: stepThread(cycles = 1): minPause = 0
1@16:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@16: yieldForStep(cycles = 1)
1@16:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@16:   --> nextThreadId = 4
@16: [1]: P(1) -> 4: P(0) yield for step (1)
1@16:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@16: stepThread(cycles = 1): minPause = 1
4@16:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@16: doStep(cycles = 1)
4@17: yieldForStep(cycles = 0)
4@17:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@17:   --> nextThreadId = 1
@17: [4]: P(0) -> 1: P(0) yield for step (0)
4@17:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@17: forkThread(chiseltest_thread_21 (21) P1) from 1
1@17: yieldForFork()
1@17:   --> [1]: R, 3: J(4), 0: J(1), 21: P(0), 4: P(0)
1@17:   --> nextThreadId = 1
1@17: joinThreads(ids = List(21))
1@17:   --> nextThreadId = 21
@17: [1]: J(21) -> 21: P(0) waiting for 21
1@17:   --> [1]: J(21), 3: J(4), 0: J(1), 21: P(0), 4: P(0)
21@17: finishThread(id=21 (chiseltest_thread_21))
21@17:   --> 1: J(21), 3: J(4), 0: J(1), 4: P(0)
@17: [21]: F -> 1: J(21) finish unblocks join
21@17:   --> 1: J(21), 3: J(4), 0: J(1), 4: P(0)
1@17: stepThread(cycles = 1): minPause = 0
1@17:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@17: yieldForStep(cycles = 1)
1@17:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@17:   --> nextThreadId = 4
@17: [1]: P(1) -> 4: P(0) yield for step (1)
1@17:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@17: stepThread(cycles = 1): minPause = 1
4@17:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@17: doStep(cycles = 1)
4@18: yieldForStep(cycles = 0)
4@18:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@18:   --> nextThreadId = 1
@18: [4]: P(0) -> 1: P(0) yield for step (0)
4@18:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@18: forkThread(chiseltest_thread_22 (22) P1) from 1
1@18: yieldForFork()
1@18:   --> [1]: R, 3: J(4), 0: J(1), 22: P(0), 4: P(0)
1@18:   --> nextThreadId = 1
1@18: joinThreads(ids = List(22))
1@18:   --> nextThreadId = 22
@18: [1]: J(22) -> 22: P(0) waiting for 22
1@18:   --> [1]: J(22), 3: J(4), 0: J(1), 22: P(0), 4: P(0)
22@18: finishThread(id=22 (chiseltest_thread_22))
22@18:   --> 1: J(22), 3: J(4), 0: J(1), 4: P(0)
@18: [22]: F -> 1: J(22) finish unblocks join
22@18:   --> 1: J(22), 3: J(4), 0: J(1), 4: P(0)
1@18: stepThread(cycles = 1): minPause = 0
1@18:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@18: yieldForStep(cycles = 1)
1@18:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@18:   --> nextThreadId = 4
@18: [1]: P(1) -> 4: P(0) yield for step (1)
1@18:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@18: stepThread(cycles = 1): minPause = 1
4@18:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@18: doStep(cycles = 1)
4@19: yieldForStep(cycles = 0)
4@19:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@19:   --> nextThreadId = 1
@19: [4]: P(0) -> 1: P(0) yield for step (0)
4@19:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@19: forkThread(chiseltest_thread_23 (23) P1) from 1
1@19: yieldForFork()
1@19:   --> [1]: R, 3: J(4), 0: J(1), 23: P(0), 4: P(0)
1@19:   --> nextThreadId = 1
1@19: joinThreads(ids = List(23))
1@19:   --> nextThreadId = 23
@19: [1]: J(23) -> 23: P(0) waiting for 23
1@19:   --> [1]: J(23), 3: J(4), 0: J(1), 23: P(0), 4: P(0)
23@19: finishThread(id=23 (chiseltest_thread_23))
23@19:   --> 1: J(23), 3: J(4), 0: J(1), 4: P(0)
@19: [23]: F -> 1: J(23) finish unblocks join
23@19:   --> 1: J(23), 3: J(4), 0: J(1), 4: P(0)
1@19: stepThread(cycles = 1): minPause = 0
1@19:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@19: yieldForStep(cycles = 1)
1@19:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@19:   --> nextThreadId = 4
@19: [1]: P(1) -> 4: P(0) yield for step (1)
1@19:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@19: stepThread(cycles = 1): minPause = 1
4@19:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@19: doStep(cycles = 1)
4@20: yieldForStep(cycles = 0)
4@20:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@20:   --> nextThreadId = 1
@20: [4]: P(0) -> 1: P(0) yield for step (0)
4@20:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@20: forkThread(chiseltest_thread_24 (24) P1) from 1
1@20: yieldForFork()
1@20:   --> [1]: R, 3: J(4), 0: J(1), 24: P(0), 4: P(0)
1@20:   --> nextThreadId = 1
1@20: joinThreads(ids = List(24))
1@20:   --> nextThreadId = 24
@20: [1]: J(24) -> 24: P(0) waiting for 24
1@20:   --> [1]: J(24), 3: J(4), 0: J(1), 24: P(0), 4: P(0)
24@20: finishThread(id=24 (chiseltest_thread_24))
24@20:   --> 1: J(24), 3: J(4), 0: J(1), 4: P(0)
@20: [24]: F -> 1: J(24) finish unblocks join
24@20:   --> 1: J(24), 3: J(4), 0: J(1), 4: P(0)
1@20: stepThread(cycles = 1): minPause = 0
1@20:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@20: yieldForStep(cycles = 1)
1@20:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@20:   --> nextThreadId = 4
@20: [1]: P(1) -> 4: P(0) yield for step (1)
1@20:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@20: stepThread(cycles = 1): minPause = 1
4@20:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@20: doStep(cycles = 1)
4@21: yieldForStep(cycles = 0)
4@21:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@21:   --> nextThreadId = 1
@21: [4]: P(0) -> 1: P(0) yield for step (0)
4@21:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@21: forkThread(chiseltest_thread_25 (25) P1) from 1
1@21: yieldForFork()
1@21:   --> [1]: R, 3: J(4), 0: J(1), 25: P(0), 4: P(0)
1@21:   --> nextThreadId = 1
1@21: joinThreads(ids = List(25))
1@21:   --> nextThreadId = 25
@21: [1]: J(25) -> 25: P(0) waiting for 25
1@21:   --> [1]: J(25), 3: J(4), 0: J(1), 25: P(0), 4: P(0)
25@21: finishThread(id=25 (chiseltest_thread_25))
25@21:   --> 1: J(25), 3: J(4), 0: J(1), 4: P(0)
@21: [25]: F -> 1: J(25) finish unblocks join
25@21:   --> 1: J(25), 3: J(4), 0: J(1), 4: P(0)
1@21: stepThread(cycles = 1): minPause = 0
1@21:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@21: yieldForStep(cycles = 1)
1@21:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@21:   --> nextThreadId = 4
@21: [1]: P(1) -> 4: P(0) yield for step (1)
1@21:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@21: stepThread(cycles = 1): minPause = 1
4@21:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@21: doStep(cycles = 1)
4@22: yieldForStep(cycles = 0)
4@22:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@22:   --> nextThreadId = 1
@22: [4]: P(0) -> 1: P(0) yield for step (0)
4@22:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@22: forkThread(chiseltest_thread_26 (26) P1) from 1
1@22: yieldForFork()
1@22:   --> [1]: R, 3: J(4), 0: J(1), 26: P(0), 4: P(0)
1@22:   --> nextThreadId = 1
1@22: joinThreads(ids = List(26))
1@22:   --> nextThreadId = 26
@22: [1]: J(26) -> 26: P(0) waiting for 26
1@22:   --> [1]: J(26), 3: J(4), 0: J(1), 26: P(0), 4: P(0)
26@22: finishThread(id=26 (chiseltest_thread_26))
26@22:   --> 1: J(26), 3: J(4), 0: J(1), 4: P(0)
@22: [26]: F -> 1: J(26) finish unblocks join
26@22:   --> 1: J(26), 3: J(4), 0: J(1), 4: P(0)
1@22: stepThread(cycles = 1): minPause = 0
1@22:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@22: yieldForStep(cycles = 1)
1@22:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@22:   --> nextThreadId = 4
@22: [1]: P(1) -> 4: P(0) yield for step (1)
1@22:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@22: stepThread(cycles = 1): minPause = 1
4@22:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@22: doStep(cycles = 1)
4@23: yieldForStep(cycles = 0)
4@23:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@23:   --> nextThreadId = 1
@23: [4]: P(0) -> 1: P(0) yield for step (0)
4@23:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@23: forkThread(chiseltest_thread_27 (27) P1) from 1
1@23: yieldForFork()
1@23:   --> [1]: R, 3: J(4), 0: J(1), 27: P(0), 4: P(0)
1@23:   --> nextThreadId = 1
1@23: joinThreads(ids = List(27))
1@23:   --> nextThreadId = 27
@23: [1]: J(27) -> 27: P(0) waiting for 27
1@23:   --> [1]: J(27), 3: J(4), 0: J(1), 27: P(0), 4: P(0)
27@23: finishThread(id=27 (chiseltest_thread_27))
27@23:   --> 1: J(27), 3: J(4), 0: J(1), 4: P(0)
@23: [27]: F -> 1: J(27) finish unblocks join
27@23:   --> 1: J(27), 3: J(4), 0: J(1), 4: P(0)
1@23: stepThread(cycles = 1): minPause = 0
1@23:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@23: yieldForStep(cycles = 1)
1@23:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@23:   --> nextThreadId = 4
@23: [1]: P(1) -> 4: P(0) yield for step (1)
1@23:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@23: stepThread(cycles = 1): minPause = 1
4@23:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@23: doStep(cycles = 1)
4@24: yieldForStep(cycles = 0)
4@24:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@24:   --> nextThreadId = 1
@24: [4]: P(0) -> 1: P(0) yield for step (0)
4@24:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@24: forkThread(chiseltest_thread_28 (28) P1) from 1
1@24: yieldForFork()
1@24:   --> [1]: R, 3: J(4), 0: J(1), 28: P(0), 4: P(0)
1@24:   --> nextThreadId = 1
1@24: joinThreads(ids = List(28))
1@24:   --> nextThreadId = 28
@24: [1]: J(28) -> 28: P(0) waiting for 28
1@24:   --> [1]: J(28), 3: J(4), 0: J(1), 28: P(0), 4: P(0)
28@24: finishThread(id=28 (chiseltest_thread_28))
28@24:   --> 1: J(28), 3: J(4), 0: J(1), 4: P(0)
@24: [28]: F -> 1: J(28) finish unblocks join
28@24:   --> 1: J(28), 3: J(4), 0: J(1), 4: P(0)
1@24: stepThread(cycles = 1): minPause = 0
1@24:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@24: yieldForStep(cycles = 1)
1@24:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@24:   --> nextThreadId = 4
@24: [1]: P(1) -> 4: P(0) yield for step (1)
1@24:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@24: stepThread(cycles = 1): minPause = 1
4@24:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@24: doStep(cycles = 1)
4@25: yieldForStep(cycles = 0)
4@25:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@25:   --> nextThreadId = 1
@25: [4]: P(0) -> 1: P(0) yield for step (0)
4@25:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@25: forkThread(chiseltest_thread_29 (29) P1) from 1
1@25: yieldForFork()
1@25:   --> [1]: R, 3: J(4), 0: J(1), 29: P(0), 4: P(0)
1@25:   --> nextThreadId = 1
1@25: joinThreads(ids = List(29))
1@25:   --> nextThreadId = 29
@25: [1]: J(29) -> 29: P(0) waiting for 29
1@25:   --> [1]: J(29), 3: J(4), 0: J(1), 29: P(0), 4: P(0)
29@25: finishThread(id=29 (chiseltest_thread_29))
29@25:   --> 1: J(29), 3: J(4), 0: J(1), 4: P(0)
@25: [29]: F -> 1: J(29) finish unblocks join
29@25:   --> 1: J(29), 3: J(4), 0: J(1), 4: P(0)
1@25: stepThread(cycles = 1): minPause = 0
1@25:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@25: yieldForStep(cycles = 1)
1@25:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@25:   --> nextThreadId = 4
@25: [1]: P(1) -> 4: P(0) yield for step (1)
1@25:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@25: stepThread(cycles = 1): minPause = 1
4@25:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@25: doStep(cycles = 1)
4@26: yieldForStep(cycles = 0)
4@26:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@26:   --> nextThreadId = 1
@26: [4]: P(0) -> 1: P(0) yield for step (0)
4@26:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@26: forkThread(chiseltest_thread_30 (30) P1) from 1
1@26: yieldForFork()
1@26:   --> [1]: R, 3: J(4), 0: J(1), 30: P(0), 4: P(0)
1@26:   --> nextThreadId = 1
1@26: joinThreads(ids = List(30))
1@26:   --> nextThreadId = 30
@26: [1]: J(30) -> 30: P(0) waiting for 30
1@26:   --> [1]: J(30), 3: J(4), 0: J(1), 30: P(0), 4: P(0)
30@26: finishThread(id=30 (chiseltest_thread_30))
30@26:   --> 1: J(30), 3: J(4), 0: J(1), 4: P(0)
@26: [30]: F -> 1: J(30) finish unblocks join
30@26:   --> 1: J(30), 3: J(4), 0: J(1), 4: P(0)
1@26: stepThread(cycles = 1): minPause = 0
1@26:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@26: yieldForStep(cycles = 1)
1@26:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@26:   --> nextThreadId = 4
@26: [1]: P(1) -> 4: P(0) yield for step (1)
1@26:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@26: stepThread(cycles = 1): minPause = 1
4@26:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@26: doStep(cycles = 1)
4@27: yieldForStep(cycles = 0)
4@27:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@27:   --> nextThreadId = 1
@27: [4]: P(0) -> 1: P(0) yield for step (0)
4@27:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@27: forkThread(chiseltest_thread_31 (31) P1) from 1
1@27: yieldForFork()
1@27:   --> [1]: R, 3: J(4), 0: J(1), 31: P(0), 4: P(0)
1@27:   --> nextThreadId = 1
1@27: joinThreads(ids = List(31))
1@27:   --> nextThreadId = 31
@27: [1]: J(31) -> 31: P(0) waiting for 31
1@27:   --> [1]: J(31), 3: J(4), 0: J(1), 31: P(0), 4: P(0)
31@27: finishThread(id=31 (chiseltest_thread_31))
31@27:   --> 1: J(31), 3: J(4), 0: J(1), 4: P(0)
@27: [31]: F -> 1: J(31) finish unblocks join
31@27:   --> 1: J(31), 3: J(4), 0: J(1), 4: P(0)
1@27: stepThread(cycles = 1): minPause = 0
1@27:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@27: yieldForStep(cycles = 1)
1@27:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@27:   --> nextThreadId = 4
@27: [1]: P(1) -> 4: P(0) yield for step (1)
1@27:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@27: stepThread(cycles = 1): minPause = 1
4@27:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@27: doStep(cycles = 1)
4@28: yieldForStep(cycles = 0)
4@28:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@28:   --> nextThreadId = 1
@28: [4]: P(0) -> 1: P(0) yield for step (0)
4@28:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@28: forkThread(chiseltest_thread_32 (32) P1) from 1
1@28: yieldForFork()
1@28:   --> [1]: R, 3: J(4), 0: J(1), 32: P(0), 4: P(0)
1@28:   --> nextThreadId = 1
1@28: joinThreads(ids = List(32))
1@28:   --> nextThreadId = 32
@28: [1]: J(32) -> 32: P(0) waiting for 32
1@28:   --> [1]: J(32), 3: J(4), 0: J(1), 32: P(0), 4: P(0)
32@28: finishThread(id=32 (chiseltest_thread_32))
32@28:   --> 1: J(32), 3: J(4), 0: J(1), 4: P(0)
@28: [32]: F -> 1: J(32) finish unblocks join
32@28:   --> 1: J(32), 3: J(4), 0: J(1), 4: P(0)
1@28: stepThread(cycles = 1): minPause = 0
1@28:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@28: yieldForStep(cycles = 1)
1@28:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@28:   --> nextThreadId = 4
@28: [1]: P(1) -> 4: P(0) yield for step (1)
1@28:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@28: stepThread(cycles = 1): minPause = 1
4@28:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@28: doStep(cycles = 1)
4@29: yieldForStep(cycles = 0)
4@29:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@29:   --> nextThreadId = 1
@29: [4]: P(0) -> 1: P(0) yield for step (0)
4@29:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@29: forkThread(chiseltest_thread_33 (33) P1) from 1
1@29: yieldForFork()
1@29:   --> [1]: R, 3: J(4), 0: J(1), 33: P(0), 4: P(0)
1@29:   --> nextThreadId = 1
1@29: joinThreads(ids = List(33))
1@29:   --> nextThreadId = 33
@29: [1]: J(33) -> 33: P(0) waiting for 33
1@29:   --> [1]: J(33), 3: J(4), 0: J(1), 33: P(0), 4: P(0)
33@29: finishThread(id=33 (chiseltest_thread_33))
33@29:   --> 1: J(33), 3: J(4), 0: J(1), 4: P(0)
@29: [33]: F -> 1: J(33) finish unblocks join
33@29:   --> 1: J(33), 3: J(4), 0: J(1), 4: P(0)
1@29: stepThread(cycles = 1): minPause = 0
1@29:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@29: yieldForStep(cycles = 1)
1@29:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@29:   --> nextThreadId = 4
@29: [1]: P(1) -> 4: P(0) yield for step (1)
1@29:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@29: stepThread(cycles = 1): minPause = 1
4@29:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@29: doStep(cycles = 1)
4@30: yieldForStep(cycles = 0)
4@30:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@30:   --> nextThreadId = 1
@30: [4]: P(0) -> 1: P(0) yield for step (0)
4@30:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@30: forkThread(chiseltest_thread_34 (34) P1) from 1
1@30: yieldForFork()
1@30:   --> [1]: R, 3: J(4), 0: J(1), 34: P(0), 4: P(0)
1@30:   --> nextThreadId = 1
1@30: joinThreads(ids = List(34))
1@30:   --> nextThreadId = 34
@30: [1]: J(34) -> 34: P(0) waiting for 34
1@30:   --> [1]: J(34), 3: J(4), 0: J(1), 34: P(0), 4: P(0)
34@30: finishThread(id=34 (chiseltest_thread_34))
34@30:   --> 1: J(34), 3: J(4), 0: J(1), 4: P(0)
@30: [34]: F -> 1: J(34) finish unblocks join
34@30:   --> 1: J(34), 3: J(4), 0: J(1), 4: P(0)
1@30: stepThread(cycles = 1): minPause = 0
1@30:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@30: yieldForStep(cycles = 1)
1@30:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@30:   --> nextThreadId = 4
@30: [1]: P(1) -> 4: P(0) yield for step (1)
1@30:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@30: stepThread(cycles = 1): minPause = 1
4@30:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@30: doStep(cycles = 1)
4@31: yieldForStep(cycles = 0)
4@31:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@31:   --> nextThreadId = 1
@31: [4]: P(0) -> 1: P(0) yield for step (0)
4@31:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@31: forkThread(chiseltest_thread_35 (35) P1) from 1
1@31: yieldForFork()
1@31:   --> [1]: R, 3: J(4), 0: J(1), 35: P(0), 4: P(0)
1@31:   --> nextThreadId = 1
1@31: joinThreads(ids = List(35))
1@31:   --> nextThreadId = 35
@31: [1]: J(35) -> 35: P(0) waiting for 35
1@31:   --> [1]: J(35), 3: J(4), 0: J(1), 35: P(0), 4: P(0)
35@31: finishThread(id=35 (chiseltest_thread_35))
35@31:   --> 1: J(35), 3: J(4), 0: J(1), 4: P(0)
@31: [35]: F -> 1: J(35) finish unblocks join
35@31:   --> 1: J(35), 3: J(4), 0: J(1), 4: P(0)
1@31: stepThread(cycles = 1): minPause = 0
1@31:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@31: yieldForStep(cycles = 1)
1@31:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@31:   --> nextThreadId = 4
@31: [1]: P(1) -> 4: P(0) yield for step (1)
1@31:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@31: stepThread(cycles = 1): minPause = 1
4@31:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@31: doStep(cycles = 1)
4@32: yieldForStep(cycles = 0)
4@32:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@32:   --> nextThreadId = 1
@32: [4]: P(0) -> 1: P(0) yield for step (0)
4@32:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@32: forkThread(chiseltest_thread_36 (36) P1) from 1
1@32: yieldForFork()
1@32:   --> [1]: R, 3: J(4), 0: J(1), 36: P(0), 4: P(0)
1@32:   --> nextThreadId = 1
1@32: joinThreads(ids = List(36))
1@32:   --> nextThreadId = 36
@32: [1]: J(36) -> 36: P(0) waiting for 36
1@32:   --> [1]: J(36), 3: J(4), 0: J(1), 36: P(0), 4: P(0)
36@32: finishThread(id=36 (chiseltest_thread_36))
36@32:   --> 1: J(36), 3: J(4), 0: J(1), 4: P(0)
@32: [36]: F -> 1: J(36) finish unblocks join
36@32:   --> 1: J(36), 3: J(4), 0: J(1), 4: P(0)
1@32: stepThread(cycles = 1): minPause = 0
1@32:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@32: yieldForStep(cycles = 1)
1@32:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@32:   --> nextThreadId = 4
@32: [1]: P(1) -> 4: P(0) yield for step (1)
1@32:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@32: stepThread(cycles = 1): minPause = 1
4@32:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@32: doStep(cycles = 1)
4@33: yieldForStep(cycles = 0)
4@33:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@33:   --> nextThreadId = 1
@33: [4]: P(0) -> 1: P(0) yield for step (0)
4@33:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@33: forkThread(chiseltest_thread_37 (37) P1) from 1
1@33: yieldForFork()
1@33:   --> [1]: R, 3: J(4), 0: J(1), 37: P(0), 4: P(0)
1@33:   --> nextThreadId = 1
1@33: joinThreads(ids = List(37))
1@33:   --> nextThreadId = 37
@33: [1]: J(37) -> 37: P(0) waiting for 37
1@33:   --> [1]: J(37), 3: J(4), 0: J(1), 37: P(0), 4: P(0)
37@33: finishThread(id=37 (chiseltest_thread_37))
37@33:   --> 1: J(37), 3: J(4), 0: J(1), 4: P(0)
@33: [37]: F -> 1: J(37) finish unblocks join
37@33:   --> 1: J(37), 3: J(4), 0: J(1), 4: P(0)
1@33: stepThread(cycles = 1): minPause = 0
1@33:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@33: yieldForStep(cycles = 1)
1@33:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@33:   --> nextThreadId = 4
@33: [1]: P(1) -> 4: P(0) yield for step (1)
1@33:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@33: stepThread(cycles = 1): minPause = 1
4@33:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@33: doStep(cycles = 1)
4@34: yieldForStep(cycles = 0)
4@34:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@34:   --> nextThreadId = 1
@34: [4]: P(0) -> 1: P(0) yield for step (0)
4@34:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@34: forkThread(chiseltest_thread_38 (38) P1) from 1
1@34: yieldForFork()
1@34:   --> [1]: R, 3: J(4), 0: J(1), 38: P(0), 4: P(0)
1@34:   --> nextThreadId = 1
1@34: joinThreads(ids = List(38))
1@34:   --> nextThreadId = 38
@34: [1]: J(38) -> 38: P(0) waiting for 38
1@34:   --> [1]: J(38), 3: J(4), 0: J(1), 38: P(0), 4: P(0)
38@34: finishThread(id=38 (chiseltest_thread_38))
38@34:   --> 1: J(38), 3: J(4), 0: J(1), 4: P(0)
@34: [38]: F -> 1: J(38) finish unblocks join
38@34:   --> 1: J(38), 3: J(4), 0: J(1), 4: P(0)
1@34: stepThread(cycles = 1): minPause = 0
1@34:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@34: yieldForStep(cycles = 1)
1@34:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@34:   --> nextThreadId = 4
@34: [1]: P(1) -> 4: P(0) yield for step (1)
1@34:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@34: stepThread(cycles = 1): minPause = 1
4@34:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@34: doStep(cycles = 1)
4@35: yieldForStep(cycles = 0)
4@35:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@35:   --> nextThreadId = 1
@35: [4]: P(0) -> 1: P(0) yield for step (0)
4@35:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@35: forkThread(chiseltest_thread_39 (39) P1) from 1
1@35: yieldForFork()
1@35:   --> [1]: R, 3: J(4), 0: J(1), 39: P(0), 4: P(0)
1@35:   --> nextThreadId = 1
1@35: joinThreads(ids = List(39))
1@35:   --> nextThreadId = 39
@35: [1]: J(39) -> 39: P(0) waiting for 39
1@35:   --> [1]: J(39), 3: J(4), 0: J(1), 39: P(0), 4: P(0)
39@35: finishThread(id=39 (chiseltest_thread_39))
39@35:   --> 1: J(39), 3: J(4), 0: J(1), 4: P(0)
@35: [39]: F -> 1: J(39) finish unblocks join
39@35:   --> 1: J(39), 3: J(4), 0: J(1), 4: P(0)
1@35: stepThread(cycles = 1): minPause = 0
1@35:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@35: yieldForStep(cycles = 1)
1@35:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@35:   --> nextThreadId = 4
@35: [1]: P(1) -> 4: P(0) yield for step (1)
1@35:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@35: stepThread(cycles = 1): minPause = 1
4@35:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@35: doStep(cycles = 1)
4@36: yieldForStep(cycles = 0)
4@36:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@36:   --> nextThreadId = 1
@36: [4]: P(0) -> 1: P(0) yield for step (0)
4@36:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@36: forkThread(chiseltest_thread_40 (40) P1) from 1
1@36: yieldForFork()
1@36:   --> [1]: R, 3: J(4), 0: J(1), 40: P(0), 4: P(0)
1@36:   --> nextThreadId = 1
1@36: joinThreads(ids = List(40))
1@36:   --> nextThreadId = 40
@36: [1]: J(40) -> 40: P(0) waiting for 40
1@36:   --> [1]: J(40), 3: J(4), 0: J(1), 40: P(0), 4: P(0)
40@36: finishThread(id=40 (chiseltest_thread_40))
40@36:   --> 1: J(40), 3: J(4), 0: J(1), 4: P(0)
@36: [40]: F -> 1: J(40) finish unblocks join
40@36:   --> 1: J(40), 3: J(4), 0: J(1), 4: P(0)
1@36: stepThread(cycles = 1): minPause = 0
1@36:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@36: yieldForStep(cycles = 1)
1@36:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@36:   --> nextThreadId = 4
@36: [1]: P(1) -> 4: P(0) yield for step (1)
1@36:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@36: stepThread(cycles = 1): minPause = 1
4@36:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@36: doStep(cycles = 1)
4@37: yieldForStep(cycles = 0)
4@37:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@37:   --> nextThreadId = 1
@37: [4]: P(0) -> 1: P(0) yield for step (0)
4@37:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@37: forkThread(chiseltest_thread_41 (41) P1) from 1
1@37: yieldForFork()
1@37:   --> [1]: R, 3: J(4), 0: J(1), 41: P(0), 4: P(0)
1@37:   --> nextThreadId = 1
1@37: joinThreads(ids = List(41))
1@37:   --> nextThreadId = 41
@37: [1]: J(41) -> 41: P(0) waiting for 41
1@37:   --> [1]: J(41), 3: J(4), 0: J(1), 41: P(0), 4: P(0)
41@37: finishThread(id=41 (chiseltest_thread_41))
41@37:   --> 1: J(41), 3: J(4), 0: J(1), 4: P(0)
@37: [41]: F -> 1: J(41) finish unblocks join
41@37:   --> 1: J(41), 3: J(4), 0: J(1), 4: P(0)
1@37: stepThread(cycles = 1): minPause = 0
1@37:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@37: yieldForStep(cycles = 1)
1@37:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@37:   --> nextThreadId = 4
@37: [1]: P(1) -> 4: P(0) yield for step (1)
1@37:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@37: stepThread(cycles = 1): minPause = 1
4@37:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@37: doStep(cycles = 1)
4@38: yieldForStep(cycles = 0)
4@38:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@38:   --> nextThreadId = 1
@38: [4]: P(0) -> 1: P(0) yield for step (0)
4@38:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@38: forkThread(chiseltest_thread_42 (42) P1) from 1
1@38: yieldForFork()
1@38:   --> [1]: R, 3: J(4), 0: J(1), 42: P(0), 4: P(0)
1@38:   --> nextThreadId = 1
1@38: joinThreads(ids = List(42))
1@38:   --> nextThreadId = 42
@38: [1]: J(42) -> 42: P(0) waiting for 42
1@38:   --> [1]: J(42), 3: J(4), 0: J(1), 42: P(0), 4: P(0)
42@38: finishThread(id=42 (chiseltest_thread_42))
42@38:   --> 1: J(42), 3: J(4), 0: J(1), 4: P(0)
@38: [42]: F -> 1: J(42) finish unblocks join
42@38:   --> 1: J(42), 3: J(4), 0: J(1), 4: P(0)
1@38: stepThread(cycles = 1): minPause = 0
1@38:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@38: yieldForStep(cycles = 1)
1@38:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@38:   --> nextThreadId = 4
@38: [1]: P(1) -> 4: P(0) yield for step (1)
1@38:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@38: stepThread(cycles = 1): minPause = 1
4@38:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@38: doStep(cycles = 1)
4@39: yieldForStep(cycles = 0)
4@39:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@39:   --> nextThreadId = 1
@39: [4]: P(0) -> 1: P(0) yield for step (0)
4@39:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@39: forkThread(chiseltest_thread_43 (43) P1) from 1
1@39: yieldForFork()
1@39:   --> [1]: R, 3: J(4), 0: J(1), 43: P(0), 4: P(0)
1@39:   --> nextThreadId = 1
1@39: joinThreads(ids = List(43))
1@39:   --> nextThreadId = 43
@39: [1]: J(43) -> 43: P(0) waiting for 43
1@39:   --> [1]: J(43), 3: J(4), 0: J(1), 43: P(0), 4: P(0)
43@39: finishThread(id=43 (chiseltest_thread_43))
43@39:   --> 1: J(43), 3: J(4), 0: J(1), 4: P(0)
@39: [43]: F -> 1: J(43) finish unblocks join
43@39:   --> 1: J(43), 3: J(4), 0: J(1), 4: P(0)
1@39: stepThread(cycles = 1): minPause = 0
1@39:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@39: yieldForStep(cycles = 1)
1@39:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@39:   --> nextThreadId = 4
@39: [1]: P(1) -> 4: P(0) yield for step (1)
1@39:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@39: stepThread(cycles = 1): minPause = 1
4@39:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@39: doStep(cycles = 1)
4@40: yieldForStep(cycles = 0)
4@40:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@40:   --> nextThreadId = 1
@40: [4]: P(0) -> 1: P(0) yield for step (0)
4@40:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@40: forkThread(chiseltest_thread_44 (44) P1) from 1
1@40: yieldForFork()
1@40:   --> [1]: R, 3: J(4), 0: J(1), 44: P(0), 4: P(0)
1@40:   --> nextThreadId = 1
1@40: joinThreads(ids = List(44))
1@40:   --> nextThreadId = 44
@40: [1]: J(44) -> 44: P(0) waiting for 44
1@40:   --> [1]: J(44), 3: J(4), 0: J(1), 44: P(0), 4: P(0)
44@40: finishThread(id=44 (chiseltest_thread_44))
44@40:   --> 1: J(44), 3: J(4), 0: J(1), 4: P(0)
@40: [44]: F -> 1: J(44) finish unblocks join
44@40:   --> 1: J(44), 3: J(4), 0: J(1), 4: P(0)
1@40: stepThread(cycles = 1): minPause = 0
1@40:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@40: yieldForStep(cycles = 1)
1@40:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@40:   --> nextThreadId = 4
@40: [1]: P(1) -> 4: P(0) yield for step (1)
1@40:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@40: stepThread(cycles = 1): minPause = 1
4@40:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@40: doStep(cycles = 1)
4@41: yieldForStep(cycles = 0)
4@41:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@41:   --> nextThreadId = 1
@41: [4]: P(0) -> 1: P(0) yield for step (0)
4@41:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@41: forkThread(chiseltest_thread_45 (45) P1) from 1
1@41: yieldForFork()
1@41:   --> [1]: R, 3: J(4), 0: J(1), 45: P(0), 4: P(0)
1@41:   --> nextThreadId = 1
1@41: joinThreads(ids = List(45))
1@41:   --> nextThreadId = 45
@41: [1]: J(45) -> 45: P(0) waiting for 45
1@41:   --> [1]: J(45), 3: J(4), 0: J(1), 45: P(0), 4: P(0)
45@41: finishThread(id=45 (chiseltest_thread_45))
45@41:   --> 1: J(45), 3: J(4), 0: J(1), 4: P(0)
@41: [45]: F -> 1: J(45) finish unblocks join
45@41:   --> 1: J(45), 3: J(4), 0: J(1), 4: P(0)
1@41: stepThread(cycles = 1): minPause = 0
1@41:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@41: yieldForStep(cycles = 1)
1@41:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@41:   --> nextThreadId = 4
@41: [1]: P(1) -> 4: P(0) yield for step (1)
1@41:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@41: stepThread(cycles = 1): minPause = 1
4@41:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@41: doStep(cycles = 1)
4@42: yieldForStep(cycles = 0)
4@42:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@42:   --> nextThreadId = 1
@42: [4]: P(0) -> 1: P(0) yield for step (0)
4@42:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@42: forkThread(chiseltest_thread_46 (46) P1) from 1
1@42: yieldForFork()
1@42:   --> [1]: R, 3: J(4), 0: J(1), 46: P(0), 4: P(0)
1@42:   --> nextThreadId = 1
1@42: joinThreads(ids = List(46))
1@42:   --> nextThreadId = 46
@42: [1]: J(46) -> 46: P(0) waiting for 46
1@42:   --> [1]: J(46), 3: J(4), 0: J(1), 46: P(0), 4: P(0)
46@42: finishThread(id=46 (chiseltest_thread_46))
46@42:   --> 1: J(46), 3: J(4), 0: J(1), 4: P(0)
@42: [46]: F -> 1: J(46) finish unblocks join
46@42:   --> 1: J(46), 3: J(4), 0: J(1), 4: P(0)
1@42: stepThread(cycles = 1): minPause = 0
1@42:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@42: yieldForStep(cycles = 1)
1@42:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@42:   --> nextThreadId = 4
@42: [1]: P(1) -> 4: P(0) yield for step (1)
1@42:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@42: stepThread(cycles = 1): minPause = 1
4@42:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@42: doStep(cycles = 1)
4@43: yieldForStep(cycles = 0)
4@43:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@43:   --> nextThreadId = 1
@43: [4]: P(0) -> 1: P(0) yield for step (0)
4@43:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@43: forkThread(chiseltest_thread_47 (47) P1) from 1
1@43: yieldForFork()
1@43:   --> [1]: R, 3: J(4), 0: J(1), 47: P(0), 4: P(0)
1@43:   --> nextThreadId = 1
1@43: joinThreads(ids = List(47))
1@43:   --> nextThreadId = 47
@43: [1]: J(47) -> 47: P(0) waiting for 47
1@43:   --> [1]: J(47), 3: J(4), 0: J(1), 47: P(0), 4: P(0)
47@43: finishThread(id=47 (chiseltest_thread_47))
47@43:   --> 1: J(47), 3: J(4), 0: J(1), 4: P(0)
@43: [47]: F -> 1: J(47) finish unblocks join
47@43:   --> 1: J(47), 3: J(4), 0: J(1), 4: P(0)
1@43: stepThread(cycles = 1): minPause = 0
1@43:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@43: yieldForStep(cycles = 1)
1@43:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@43:   --> nextThreadId = 4
@43: [1]: P(1) -> 4: P(0) yield for step (1)
1@43:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@43: stepThread(cycles = 1): minPause = 1
4@43:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@43: doStep(cycles = 1)
4@44: yieldForStep(cycles = 0)
4@44:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@44:   --> nextThreadId = 1
@44: [4]: P(0) -> 1: P(0) yield for step (0)
4@44:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@44: forkThread(chiseltest_thread_48 (48) P1) from 1
1@44: yieldForFork()
1@44:   --> [1]: R, 3: J(4), 0: J(1), 48: P(0), 4: P(0)
1@44:   --> nextThreadId = 1
1@44: joinThreads(ids = List(48))
1@44:   --> nextThreadId = 48
@44: [1]: J(48) -> 48: P(0) waiting for 48
1@44:   --> [1]: J(48), 3: J(4), 0: J(1), 48: P(0), 4: P(0)
48@44: finishThread(id=48 (chiseltest_thread_48))
48@44:   --> 1: J(48), 3: J(4), 0: J(1), 4: P(0)
@44: [48]: F -> 1: J(48) finish unblocks join
48@44:   --> 1: J(48), 3: J(4), 0: J(1), 4: P(0)
1@44: stepThread(cycles = 1): minPause = 0
1@44:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@44: yieldForStep(cycles = 1)
1@44:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@44:   --> nextThreadId = 4
@44: [1]: P(1) -> 4: P(0) yield for step (1)
1@44:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@44: stepThread(cycles = 1): minPause = 1
4@44:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@44: doStep(cycles = 1)
4@45: yieldForStep(cycles = 0)
4@45:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@45:   --> nextThreadId = 1
@45: [4]: P(0) -> 1: P(0) yield for step (0)
4@45:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@45: forkThread(chiseltest_thread_49 (49) P1) from 1
1@45: yieldForFork()
1@45:   --> [1]: R, 3: J(4), 0: J(1), 49: P(0), 4: P(0)
1@45:   --> nextThreadId = 1
1@45: joinThreads(ids = List(49))
1@45:   --> nextThreadId = 49
@45: [1]: J(49) -> 49: P(0) waiting for 49
1@45:   --> [1]: J(49), 3: J(4), 0: J(1), 49: P(0), 4: P(0)
49@45: finishThread(id=49 (chiseltest_thread_49))
49@45:   --> 1: J(49), 3: J(4), 0: J(1), 4: P(0)
@45: [49]: F -> 1: J(49) finish unblocks join
49@45:   --> 1: J(49), 3: J(4), 0: J(1), 4: P(0)
1@45: stepThread(cycles = 1): minPause = 0
1@45:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@45: yieldForStep(cycles = 1)
1@45:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@45:   --> nextThreadId = 4
@45: [1]: P(1) -> 4: P(0) yield for step (1)
1@45:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@45: stepThread(cycles = 1): minPause = 1
4@45:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@45: doStep(cycles = 1)
4@46: yieldForStep(cycles = 0)
4@46:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@46:   --> nextThreadId = 1
@46: [4]: P(0) -> 1: P(0) yield for step (0)
4@46:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@46: forkThread(chiseltest_thread_50 (50) P1) from 1
1@46: yieldForFork()
1@46:   --> [1]: R, 3: J(4), 0: J(1), 50: P(0), 4: P(0)
1@46:   --> nextThreadId = 1
1@46: joinThreads(ids = List(50))
1@46:   --> nextThreadId = 50
@46: [1]: J(50) -> 50: P(0) waiting for 50
1@46:   --> [1]: J(50), 3: J(4), 0: J(1), 50: P(0), 4: P(0)
50@46: finishThread(id=50 (chiseltest_thread_50))
50@46:   --> 1: J(50), 3: J(4), 0: J(1), 4: P(0)
@46: [50]: F -> 1: J(50) finish unblocks join
50@46:   --> 1: J(50), 3: J(4), 0: J(1), 4: P(0)
1@46: stepThread(cycles = 1): minPause = 0
1@46:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@46: yieldForStep(cycles = 1)
1@46:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@46:   --> nextThreadId = 4
@46: [1]: P(1) -> 4: P(0) yield for step (1)
1@46:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@46: stepThread(cycles = 1): minPause = 1
4@46:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@46: doStep(cycles = 1)
4@47: yieldForStep(cycles = 0)
4@47:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@47:   --> nextThreadId = 1
@47: [4]: P(0) -> 1: P(0) yield for step (0)
4@47:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@47: forkThread(chiseltest_thread_51 (51) P1) from 1
1@47: yieldForFork()
1@47:   --> [1]: R, 3: J(4), 0: J(1), 51: P(0), 4: P(0)
1@47:   --> nextThreadId = 1
1@47: joinThreads(ids = List(51))
1@47:   --> nextThreadId = 51
@47: [1]: J(51) -> 51: P(0) waiting for 51
1@47:   --> [1]: J(51), 3: J(4), 0: J(1), 51: P(0), 4: P(0)
51@47: finishThread(id=51 (chiseltest_thread_51))
51@47:   --> 1: J(51), 3: J(4), 0: J(1), 4: P(0)
@47: [51]: F -> 1: J(51) finish unblocks join
51@47:   --> 1: J(51), 3: J(4), 0: J(1), 4: P(0)
1@47: stepThread(cycles = 1): minPause = 0
1@47:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@47: yieldForStep(cycles = 1)
1@47:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@47:   --> nextThreadId = 4
@47: [1]: P(1) -> 4: P(0) yield for step (1)
1@47:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@47: stepThread(cycles = 1): minPause = 1
4@47:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@47: doStep(cycles = 1)
4@48: yieldForStep(cycles = 0)
4@48:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@48:   --> nextThreadId = 1
@48: [4]: P(0) -> 1: P(0) yield for step (0)
4@48:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@48: forkThread(chiseltest_thread_52 (52) P1) from 1
1@48: yieldForFork()
1@48:   --> [1]: R, 3: J(4), 0: J(1), 52: P(0), 4: P(0)
1@48:   --> nextThreadId = 1
1@48: joinThreads(ids = List(52))
1@48:   --> nextThreadId = 52
@48: [1]: J(52) -> 52: P(0) waiting for 52
1@48:   --> [1]: J(52), 3: J(4), 0: J(1), 52: P(0), 4: P(0)
52@48: finishThread(id=52 (chiseltest_thread_52))
52@48:   --> 1: J(52), 3: J(4), 0: J(1), 4: P(0)
@48: [52]: F -> 1: J(52) finish unblocks join
52@48:   --> 1: J(52), 3: J(4), 0: J(1), 4: P(0)
1@48: stepThread(cycles = 1): minPause = 0
1@48:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@48: yieldForStep(cycles = 1)
1@48:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@48:   --> nextThreadId = 4
@48: [1]: P(1) -> 4: P(0) yield for step (1)
1@48:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@48: stepThread(cycles = 1): minPause = 1
4@48:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@48: doStep(cycles = 1)
4@49: yieldForStep(cycles = 0)
4@49:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@49:   --> nextThreadId = 1
@49: [4]: P(0) -> 1: P(0) yield for step (0)
4@49:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@49: forkThread(chiseltest_thread_53 (53) P1) from 1
1@49: yieldForFork()
1@49:   --> [1]: R, 3: J(4), 0: J(1), 53: P(0), 4: P(0)
1@49:   --> nextThreadId = 1
1@49: joinThreads(ids = List(53))
1@49:   --> nextThreadId = 53
@49: [1]: J(53) -> 53: P(0) waiting for 53
1@49:   --> [1]: J(53), 3: J(4), 0: J(1), 53: P(0), 4: P(0)
53@49: finishThread(id=53 (chiseltest_thread_53))
53@49:   --> 1: J(53), 3: J(4), 0: J(1), 4: P(0)
@49: [53]: F -> 1: J(53) finish unblocks join
53@49:   --> 1: J(53), 3: J(4), 0: J(1), 4: P(0)
1@49: stepThread(cycles = 1): minPause = 0
1@49:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@49: yieldForStep(cycles = 1)
1@49:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@49:   --> nextThreadId = 4
@49: [1]: P(1) -> 4: P(0) yield for step (1)
1@49:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@49: stepThread(cycles = 1): minPause = 1
4@49:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@49: doStep(cycles = 1)
4@50: yieldForStep(cycles = 0)
4@50:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@50:   --> nextThreadId = 1
@50: [4]: P(0) -> 1: P(0) yield for step (0)
4@50:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@50: forkThread(chiseltest_thread_54 (54) P1) from 1
1@50: yieldForFork()
1@50:   --> [1]: R, 3: J(4), 0: J(1), 54: P(0), 4: P(0)
1@50:   --> nextThreadId = 1
1@50: joinThreads(ids = List(54))
1@50:   --> nextThreadId = 54
@50: [1]: J(54) -> 54: P(0) waiting for 54
1@50:   --> [1]: J(54), 3: J(4), 0: J(1), 54: P(0), 4: P(0)
54@50: finishThread(id=54 (chiseltest_thread_54))
54@50:   --> 1: J(54), 3: J(4), 0: J(1), 4: P(0)
@50: [54]: F -> 1: J(54) finish unblocks join
54@50:   --> 1: J(54), 3: J(4), 0: J(1), 4: P(0)
1@50: stepThread(cycles = 1): minPause = 0
1@50:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@50: yieldForStep(cycles = 1)
1@50:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@50:   --> nextThreadId = 4
@50: [1]: P(1) -> 4: P(0) yield for step (1)
1@50:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@50: stepThread(cycles = 1): minPause = 1
4@50:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@50: doStep(cycles = 1)
4@51: yieldForStep(cycles = 0)
4@51:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@51:   --> nextThreadId = 1
@51: [4]: P(0) -> 1: P(0) yield for step (0)
4@51:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@51: forkThread(chiseltest_thread_55 (55) P1) from 1
1@51: yieldForFork()
1@51:   --> [1]: R, 3: J(4), 0: J(1), 55: P(0), 4: P(0)
1@51:   --> nextThreadId = 1
1@51: joinThreads(ids = List(55))
1@51:   --> nextThreadId = 55
@51: [1]: J(55) -> 55: P(0) waiting for 55
1@51:   --> [1]: J(55), 3: J(4), 0: J(1), 55: P(0), 4: P(0)
55@51: finishThread(id=55 (chiseltest_thread_55))
55@51:   --> 1: J(55), 3: J(4), 0: J(1), 4: P(0)
@51: [55]: F -> 1: J(55) finish unblocks join
55@51:   --> 1: J(55), 3: J(4), 0: J(1), 4: P(0)
1@51: stepThread(cycles = 1): minPause = 0
1@51:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@51: yieldForStep(cycles = 1)
1@51:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@51:   --> nextThreadId = 4
@51: [1]: P(1) -> 4: P(0) yield for step (1)
1@51:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@51: stepThread(cycles = 1): minPause = 1
4@51:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@51: doStep(cycles = 1)
4@52: yieldForStep(cycles = 0)
4@52:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@52:   --> nextThreadId = 1
@52: [4]: P(0) -> 1: P(0) yield for step (0)
4@52:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@52: forkThread(chiseltest_thread_56 (56) P1) from 1
1@52: yieldForFork()
1@52:   --> [1]: R, 3: J(4), 0: J(1), 56: P(0), 4: P(0)
1@52:   --> nextThreadId = 1
1@52: joinThreads(ids = List(56))
1@52:   --> nextThreadId = 56
@52: [1]: J(56) -> 56: P(0) waiting for 56
1@52:   --> [1]: J(56), 3: J(4), 0: J(1), 56: P(0), 4: P(0)
56@52: finishThread(id=56 (chiseltest_thread_56))
56@52:   --> 1: J(56), 3: J(4), 0: J(1), 4: P(0)
@52: [56]: F -> 1: J(56) finish unblocks join
56@52:   --> 1: J(56), 3: J(4), 0: J(1), 4: P(0)
1@52: stepThread(cycles = 1): minPause = 0
1@52:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@52: yieldForStep(cycles = 1)
1@52:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@52:   --> nextThreadId = 4
@52: [1]: P(1) -> 4: P(0) yield for step (1)
1@52:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@52: stepThread(cycles = 1): minPause = 1
4@52:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@52: doStep(cycles = 1)
4@53: yieldForStep(cycles = 0)
4@53:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@53:   --> nextThreadId = 1
@53: [4]: P(0) -> 1: P(0) yield for step (0)
4@53:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@53: forkThread(chiseltest_thread_57 (57) P1) from 1
1@53: yieldForFork()
1@53:   --> [1]: R, 3: J(4), 0: J(1), 57: P(0), 4: P(0)
1@53:   --> nextThreadId = 1
1@53: joinThreads(ids = List(57))
1@53:   --> nextThreadId = 57
@53: [1]: J(57) -> 57: P(0) waiting for 57
1@53:   --> [1]: J(57), 3: J(4), 0: J(1), 57: P(0), 4: P(0)
57@53: finishThread(id=57 (chiseltest_thread_57))
57@53:   --> 1: J(57), 3: J(4), 0: J(1), 4: P(0)
@53: [57]: F -> 1: J(57) finish unblocks join
57@53:   --> 1: J(57), 3: J(4), 0: J(1), 4: P(0)
1@53: stepThread(cycles = 1): minPause = 0
1@53:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@53: yieldForStep(cycles = 1)
1@53:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@53:   --> nextThreadId = 4
@53: [1]: P(1) -> 4: P(0) yield for step (1)
1@53:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@53: stepThread(cycles = 1): minPause = 1
4@53:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@53: doStep(cycles = 1)
4@54: yieldForStep(cycles = 0)
4@54:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@54:   --> nextThreadId = 1
@54: [4]: P(0) -> 1: P(0) yield for step (0)
4@54:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@54: forkThread(chiseltest_thread_58 (58) P1) from 1
1@54: yieldForFork()
1@54:   --> [1]: R, 3: J(4), 0: J(1), 58: P(0), 4: P(0)
1@54:   --> nextThreadId = 1
1@54: joinThreads(ids = List(58))
1@54:   --> nextThreadId = 58
@54: [1]: J(58) -> 58: P(0) waiting for 58
1@54:   --> [1]: J(58), 3: J(4), 0: J(1), 58: P(0), 4: P(0)
58@54: finishThread(id=58 (chiseltest_thread_58))
58@54:   --> 1: J(58), 3: J(4), 0: J(1), 4: P(0)
@54: [58]: F -> 1: J(58) finish unblocks join
58@54:   --> 1: J(58), 3: J(4), 0: J(1), 4: P(0)
1@54: stepThread(cycles = 1): minPause = 0
1@54:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@54: yieldForStep(cycles = 1)
1@54:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@54:   --> nextThreadId = 4
@54: [1]: P(1) -> 4: P(0) yield for step (1)
1@54:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@54: stepThread(cycles = 1): minPause = 1
4@54:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@54: doStep(cycles = 1)
4@55: yieldForStep(cycles = 0)
4@55:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@55:   --> nextThreadId = 1
@55: [4]: P(0) -> 1: P(0) yield for step (0)
4@55:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@55: forkThread(chiseltest_thread_59 (59) P1) from 1
1@55: yieldForFork()
1@55:   --> [1]: R, 3: J(4), 0: J(1), 59: P(0), 4: P(0)
1@55:   --> nextThreadId = 1
1@55: joinThreads(ids = List(59))
1@55:   --> nextThreadId = 59
@55: [1]: J(59) -> 59: P(0) waiting for 59
1@55:   --> [1]: J(59), 3: J(4), 0: J(1), 59: P(0), 4: P(0)
59@55: finishThread(id=59 (chiseltest_thread_59))
59@55:   --> 1: J(59), 3: J(4), 0: J(1), 4: P(0)
@55: [59]: F -> 1: J(59) finish unblocks join
59@55:   --> 1: J(59), 3: J(4), 0: J(1), 4: P(0)
1@55: stepThread(cycles = 1): minPause = 0
1@55:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@55: yieldForStep(cycles = 1)
1@55:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@55:   --> nextThreadId = 4
@55: [1]: P(1) -> 4: P(0) yield for step (1)
1@55:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@55: stepThread(cycles = 1): minPause = 1
4@55:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@55: doStep(cycles = 1)
4@56: yieldForStep(cycles = 0)
4@56:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@56:   --> nextThreadId = 1
@56: [4]: P(0) -> 1: P(0) yield for step (0)
4@56:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@56: forkThread(chiseltest_thread_60 (60) P1) from 1
1@56: yieldForFork()
1@56:   --> [1]: R, 3: J(4), 0: J(1), 60: P(0), 4: P(0)
1@56:   --> nextThreadId = 1
1@56: joinThreads(ids = List(60))
1@56:   --> nextThreadId = 60
@56: [1]: J(60) -> 60: P(0) waiting for 60
1@56:   --> [1]: J(60), 3: J(4), 0: J(1), 60: P(0), 4: P(0)
60@56: finishThread(id=60 (chiseltest_thread_60))
60@56:   --> 1: J(60), 3: J(4), 0: J(1), 4: P(0)
@56: [60]: F -> 1: J(60) finish unblocks join
60@56:   --> 1: J(60), 3: J(4), 0: J(1), 4: P(0)
1@56: stepThread(cycles = 1): minPause = 0
1@56:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@56: yieldForStep(cycles = 1)
1@56:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@56:   --> nextThreadId = 4
@56: [1]: P(1) -> 4: P(0) yield for step (1)
1@56:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@56: stepThread(cycles = 1): minPause = 1
4@56:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@56: doStep(cycles = 1)
4@57: yieldForStep(cycles = 0)
4@57:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@57:   --> nextThreadId = 1
@57: [4]: P(0) -> 1: P(0) yield for step (0)
4@57:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@57: forkThread(chiseltest_thread_61 (61) P1) from 1
1@57: yieldForFork()
1@57:   --> [1]: R, 3: J(4), 0: J(1), 61: P(0), 4: P(0)
1@57:   --> nextThreadId = 1
1@57: joinThreads(ids = List(61))
1@57:   --> nextThreadId = 61
@57: [1]: J(61) -> 61: P(0) waiting for 61
1@57:   --> [1]: J(61), 3: J(4), 0: J(1), 61: P(0), 4: P(0)
61@57: finishThread(id=61 (chiseltest_thread_61))
61@57:   --> 1: J(61), 3: J(4), 0: J(1), 4: P(0)
@57: [61]: F -> 1: J(61) finish unblocks join
61@57:   --> 1: J(61), 3: J(4), 0: J(1), 4: P(0)
1@57: stepThread(cycles = 1): minPause = 0
1@57:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@57: yieldForStep(cycles = 1)
1@57:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@57:   --> nextThreadId = 4
@57: [1]: P(1) -> 4: P(0) yield for step (1)
1@57:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@57: stepThread(cycles = 1): minPause = 1
4@57:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@57: doStep(cycles = 1)
4@58: yieldForStep(cycles = 0)
4@58:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@58:   --> nextThreadId = 1
@58: [4]: P(0) -> 1: P(0) yield for step (0)
4@58:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@58: forkThread(chiseltest_thread_62 (62) P1) from 1
1@58: yieldForFork()
1@58:   --> [1]: R, 3: J(4), 0: J(1), 62: P(0), 4: P(0)
1@58:   --> nextThreadId = 1
1@58: joinThreads(ids = List(62))
1@58:   --> nextThreadId = 62
@58: [1]: J(62) -> 62: P(0) waiting for 62
1@58:   --> [1]: J(62), 3: J(4), 0: J(1), 62: P(0), 4: P(0)
62@58: finishThread(id=62 (chiseltest_thread_62))
62@58:   --> 1: J(62), 3: J(4), 0: J(1), 4: P(0)
@58: [62]: F -> 1: J(62) finish unblocks join
62@58:   --> 1: J(62), 3: J(4), 0: J(1), 4: P(0)
1@58: stepThread(cycles = 1): minPause = 0
1@58:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@58: yieldForStep(cycles = 1)
1@58:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@58:   --> nextThreadId = 4
@58: [1]: P(1) -> 4: P(0) yield for step (1)
1@58:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@58: stepThread(cycles = 1): minPause = 1
4@58:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@58: doStep(cycles = 1)
4@59: yieldForStep(cycles = 0)
4@59:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@59:   --> nextThreadId = 1
@59: [4]: P(0) -> 1: P(0) yield for step (0)
4@59:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@59: forkThread(chiseltest_thread_63 (63) P1) from 1
1@59: yieldForFork()
1@59:   --> [1]: R, 3: J(4), 0: J(1), 63: P(0), 4: P(0)
1@59:   --> nextThreadId = 1
1@59: joinThreads(ids = List(63))
1@59:   --> nextThreadId = 63
@59: [1]: J(63) -> 63: P(0) waiting for 63
1@59:   --> [1]: J(63), 3: J(4), 0: J(1), 63: P(0), 4: P(0)
63@59: finishThread(id=63 (chiseltest_thread_63))
63@59:   --> 1: J(63), 3: J(4), 0: J(1), 4: P(0)
@59: [63]: F -> 1: J(63) finish unblocks join
63@59:   --> 1: J(63), 3: J(4), 0: J(1), 4: P(0)
1@59: stepThread(cycles = 1): minPause = 0
1@59:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@59: yieldForStep(cycles = 1)
1@59:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@59:   --> nextThreadId = 4
@59: [1]: P(1) -> 4: P(0) yield for step (1)
1@59:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@59: stepThread(cycles = 1): minPause = 1
4@59:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@59: doStep(cycles = 1)
4@60: yieldForStep(cycles = 0)
4@60:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@60:   --> nextThreadId = 1
@60: [4]: P(0) -> 1: P(0) yield for step (0)
4@60:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@60: forkThread(chiseltest_thread_64 (64) P1) from 1
1@60: yieldForFork()
1@60:   --> [1]: R, 3: J(4), 0: J(1), 64: P(0), 4: P(0)
1@60:   --> nextThreadId = 1
1@60: joinThreads(ids = List(64))
1@60:   --> nextThreadId = 64
@60: [1]: J(64) -> 64: P(0) waiting for 64
1@60:   --> [1]: J(64), 3: J(4), 0: J(1), 64: P(0), 4: P(0)
64@60: finishThread(id=64 (chiseltest_thread_64))
64@60:   --> 1: J(64), 3: J(4), 0: J(1), 4: P(0)
@60: [64]: F -> 1: J(64) finish unblocks join
64@60:   --> 1: J(64), 3: J(4), 0: J(1), 4: P(0)
1@60: stepThread(cycles = 1): minPause = 0
1@60:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@60: yieldForStep(cycles = 1)
1@60:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@60:   --> nextThreadId = 4
@60: [1]: P(1) -> 4: P(0) yield for step (1)
1@60:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@60: stepThread(cycles = 1): minPause = 1
4@60:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@60: doStep(cycles = 1)
4@61: yieldForStep(cycles = 0)
4@61:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@61:   --> nextThreadId = 1
@61: [4]: P(0) -> 1: P(0) yield for step (0)
4@61:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@61: forkThread(chiseltest_thread_65 (65) P1) from 1
1@61: yieldForFork()
1@61:   --> [1]: R, 3: J(4), 0: J(1), 65: P(0), 4: P(0)
1@61:   --> nextThreadId = 1
1@61: joinThreads(ids = List(65))
1@61:   --> nextThreadId = 65
@61: [1]: J(65) -> 65: P(0) waiting for 65
1@61:   --> [1]: J(65), 3: J(4), 0: J(1), 65: P(0), 4: P(0)
65@61: finishThread(id=65 (chiseltest_thread_65))
65@61:   --> 1: J(65), 3: J(4), 0: J(1), 4: P(0)
@61: [65]: F -> 1: J(65) finish unblocks join
65@61:   --> 1: J(65), 3: J(4), 0: J(1), 4: P(0)
1@61: stepThread(cycles = 1): minPause = 0
1@61:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@61: yieldForStep(cycles = 1)
1@61:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@61:   --> nextThreadId = 4
@61: [1]: P(1) -> 4: P(0) yield for step (1)
1@61:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@61: stepThread(cycles = 1): minPause = 1
4@61:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@61: doStep(cycles = 1)
4@62: yieldForStep(cycles = 0)
4@62:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@62:   --> nextThreadId = 1
@62: [4]: P(0) -> 1: P(0) yield for step (0)
4@62:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@62: forkThread(chiseltest_thread_66 (66) P1) from 1
1@62: yieldForFork()
1@62:   --> [1]: R, 3: J(4), 0: J(1), 66: P(0), 4: P(0)
1@62:   --> nextThreadId = 1
1@62: joinThreads(ids = List(66))
1@62:   --> nextThreadId = 66
@62: [1]: J(66) -> 66: P(0) waiting for 66
1@62:   --> [1]: J(66), 3: J(4), 0: J(1), 66: P(0), 4: P(0)
66@62: finishThread(id=66 (chiseltest_thread_66))
66@62:   --> 1: J(66), 3: J(4), 0: J(1), 4: P(0)
@62: [66]: F -> 1: J(66) finish unblocks join
66@62:   --> 1: J(66), 3: J(4), 0: J(1), 4: P(0)
1@62: stepThread(cycles = 1): minPause = 0
1@62:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@62: yieldForStep(cycles = 1)
1@62:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@62:   --> nextThreadId = 4
@62: [1]: P(1) -> 4: P(0) yield for step (1)
1@62:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@62: stepThread(cycles = 1): minPause = 1
4@62:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@62: doStep(cycles = 1)
4@63: yieldForStep(cycles = 0)
4@63:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@63:   --> nextThreadId = 1
@63: [4]: P(0) -> 1: P(0) yield for step (0)
4@63:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@63: forkThread(chiseltest_thread_67 (67) P1) from 1
1@63: yieldForFork()
1@63:   --> [1]: R, 3: J(4), 0: J(1), 67: P(0), 4: P(0)
1@63:   --> nextThreadId = 1
1@63: joinThreads(ids = List(67))
1@63:   --> nextThreadId = 67
@63: [1]: J(67) -> 67: P(0) waiting for 67
1@63:   --> [1]: J(67), 3: J(4), 0: J(1), 67: P(0), 4: P(0)
67@63: finishThread(id=67 (chiseltest_thread_67))
67@63:   --> 1: J(67), 3: J(4), 0: J(1), 4: P(0)
@63: [67]: F -> 1: J(67) finish unblocks join
67@63:   --> 1: J(67), 3: J(4), 0: J(1), 4: P(0)
1@63: stepThread(cycles = 1): minPause = 0
1@63:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@63: yieldForStep(cycles = 1)
1@63:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@63:   --> nextThreadId = 4
@63: [1]: P(1) -> 4: P(0) yield for step (1)
1@63:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@63: stepThread(cycles = 1): minPause = 1
4@63:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@63: doStep(cycles = 1)
4@64: yieldForStep(cycles = 0)
4@64:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@64:   --> nextThreadId = 1
@64: [4]: P(0) -> 1: P(0) yield for step (0)
4@64:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@64: forkThread(chiseltest_thread_68 (68) P1) from 1
1@64: yieldForFork()
1@64:   --> [1]: R, 3: J(4), 0: J(1), 68: P(0), 4: P(0)
1@64:   --> nextThreadId = 1
1@64: joinThreads(ids = List(68))
1@64:   --> nextThreadId = 68
@64: [1]: J(68) -> 68: P(0) waiting for 68
1@64:   --> [1]: J(68), 3: J(4), 0: J(1), 68: P(0), 4: P(0)
68@64: finishThread(id=68 (chiseltest_thread_68))
68@64:   --> 1: J(68), 3: J(4), 0: J(1), 4: P(0)
@64: [68]: F -> 1: J(68) finish unblocks join
68@64:   --> 1: J(68), 3: J(4), 0: J(1), 4: P(0)
1@64: stepThread(cycles = 1): minPause = 0
1@64:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@64: yieldForStep(cycles = 1)
1@64:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@64:   --> nextThreadId = 4
@64: [1]: P(1) -> 4: P(0) yield for step (1)
1@64:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@64: stepThread(cycles = 1): minPause = 1
4@64:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@64: doStep(cycles = 1)
4@65: yieldForStep(cycles = 0)
4@65:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@65:   --> nextThreadId = 1
@65: [4]: P(0) -> 1: P(0) yield for step (0)
4@65:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@65: forkThread(chiseltest_thread_69 (69) P1) from 1
1@65: yieldForFork()
1@65:   --> [1]: R, 3: J(4), 0: J(1), 69: P(0), 4: P(0)
1@65:   --> nextThreadId = 1
1@65: joinThreads(ids = List(69))
1@65:   --> nextThreadId = 69
@65: [1]: J(69) -> 69: P(0) waiting for 69
1@65:   --> [1]: J(69), 3: J(4), 0: J(1), 69: P(0), 4: P(0)
69@65: finishThread(id=69 (chiseltest_thread_69))
69@65:   --> 1: J(69), 3: J(4), 0: J(1), 4: P(0)
@65: [69]: F -> 1: J(69) finish unblocks join
69@65:   --> 1: J(69), 3: J(4), 0: J(1), 4: P(0)
1@65: stepThread(cycles = 1): minPause = 0
1@65:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@65: yieldForStep(cycles = 1)
1@65:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@65:   --> nextThreadId = 4
@65: [1]: P(1) -> 4: P(0) yield for step (1)
1@65:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@65: stepThread(cycles = 1): minPause = 1
4@65:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@65: doStep(cycles = 1)
4@66: yieldForStep(cycles = 0)
4@66:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@66:   --> nextThreadId = 1
@66: [4]: P(0) -> 1: P(0) yield for step (0)
4@66:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@66: forkThread(chiseltest_thread_70 (70) P1) from 1
1@66: yieldForFork()
1@66:   --> [1]: R, 3: J(4), 0: J(1), 70: P(0), 4: P(0)
1@66:   --> nextThreadId = 1
1@66: joinThreads(ids = List(70))
1@66:   --> nextThreadId = 70
@66: [1]: J(70) -> 70: P(0) waiting for 70
1@66:   --> [1]: J(70), 3: J(4), 0: J(1), 70: P(0), 4: P(0)
70@66: finishThread(id=70 (chiseltest_thread_70))
70@66:   --> 1: J(70), 3: J(4), 0: J(1), 4: P(0)
@66: [70]: F -> 1: J(70) finish unblocks join
70@66:   --> 1: J(70), 3: J(4), 0: J(1), 4: P(0)
1@66: stepThread(cycles = 1): minPause = 0
1@66:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@66: yieldForStep(cycles = 1)
1@66:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@66:   --> nextThreadId = 4
@66: [1]: P(1) -> 4: P(0) yield for step (1)
1@66:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@66: stepThread(cycles = 1): minPause = 1
4@66:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@66: doStep(cycles = 1)
4@67: yieldForStep(cycles = 0)
4@67:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@67:   --> nextThreadId = 1
@67: [4]: P(0) -> 1: P(0) yield for step (0)
4@67:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@67: forkThread(chiseltest_thread_71 (71) P1) from 1
1@67: yieldForFork()
1@67:   --> [1]: R, 3: J(4), 0: J(1), 71: P(0), 4: P(0)
1@67:   --> nextThreadId = 1
1@67: joinThreads(ids = List(71))
1@67:   --> nextThreadId = 71
@67: [1]: J(71) -> 71: P(0) waiting for 71
1@67:   --> [1]: J(71), 3: J(4), 0: J(1), 71: P(0), 4: P(0)
71@67: finishThread(id=71 (chiseltest_thread_71))
71@67:   --> 1: J(71), 3: J(4), 0: J(1), 4: P(0)
@67: [71]: F -> 1: J(71) finish unblocks join
71@67:   --> 1: J(71), 3: J(4), 0: J(1), 4: P(0)
1@67: stepThread(cycles = 1): minPause = 0
1@67:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@67: yieldForStep(cycles = 1)
1@67:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@67:   --> nextThreadId = 4
@67: [1]: P(1) -> 4: P(0) yield for step (1)
1@67:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@67: stepThread(cycles = 1): minPause = 1
4@67:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@67: doStep(cycles = 1)
4@68: yieldForStep(cycles = 0)
4@68:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@68:   --> nextThreadId = 1
@68: [4]: P(0) -> 1: P(0) yield for step (0)
4@68:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@68: forkThread(chiseltest_thread_72 (72) P1) from 1
1@68: yieldForFork()
1@68:   --> [1]: R, 3: J(4), 0: J(1), 72: P(0), 4: P(0)
1@68:   --> nextThreadId = 1
1@68: joinThreads(ids = List(72))
1@68:   --> nextThreadId = 72
@68: [1]: J(72) -> 72: P(0) waiting for 72
1@68:   --> [1]: J(72), 3: J(4), 0: J(1), 72: P(0), 4: P(0)
72@68: finishThread(id=72 (chiseltest_thread_72))
72@68:   --> 1: J(72), 3: J(4), 0: J(1), 4: P(0)
@68: [72]: F -> 1: J(72) finish unblocks join
72@68:   --> 1: J(72), 3: J(4), 0: J(1), 4: P(0)
1@68: stepThread(cycles = 1): minPause = 0
1@68:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@68: yieldForStep(cycles = 1)
1@68:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@68:   --> nextThreadId = 4
@68: [1]: P(1) -> 4: P(0) yield for step (1)
1@68:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@68: stepThread(cycles = 1): minPause = 1
4@68:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@68: doStep(cycles = 1)
4@69: yieldForStep(cycles = 0)
4@69:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@69:   --> nextThreadId = 1
@69: [4]: P(0) -> 1: P(0) yield for step (0)
4@69:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@69: forkThread(chiseltest_thread_73 (73) P1) from 1
1@69: yieldForFork()
1@69:   --> [1]: R, 3: J(4), 0: J(1), 73: P(0), 4: P(0)
1@69:   --> nextThreadId = 1
1@69: joinThreads(ids = List(73))
1@69:   --> nextThreadId = 73
@69: [1]: J(73) -> 73: P(0) waiting for 73
1@69:   --> [1]: J(73), 3: J(4), 0: J(1), 73: P(0), 4: P(0)
73@69: finishThread(id=73 (chiseltest_thread_73))
73@69:   --> 1: J(73), 3: J(4), 0: J(1), 4: P(0)
@69: [73]: F -> 1: J(73) finish unblocks join
73@69:   --> 1: J(73), 3: J(4), 0: J(1), 4: P(0)
1@69: stepThread(cycles = 1): minPause = 0
1@69:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@69: yieldForStep(cycles = 1)
1@69:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@69:   --> nextThreadId = 4
@69: [1]: P(1) -> 4: P(0) yield for step (1)
1@69:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@69: stepThread(cycles = 1): minPause = 1
4@69:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@69: doStep(cycles = 1)
4@70: yieldForStep(cycles = 0)
4@70:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@70:   --> nextThreadId = 1
@70: [4]: P(0) -> 1: P(0) yield for step (0)
4@70:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@70: forkThread(chiseltest_thread_74 (74) P1) from 1
1@70: yieldForFork()
1@70:   --> [1]: R, 3: J(4), 0: J(1), 74: P(0), 4: P(0)
1@70:   --> nextThreadId = 1
1@70: joinThreads(ids = List(74))
1@70:   --> nextThreadId = 74
@70: [1]: J(74) -> 74: P(0) waiting for 74
1@70:   --> [1]: J(74), 3: J(4), 0: J(1), 74: P(0), 4: P(0)
74@70: finishThread(id=74 (chiseltest_thread_74))
74@70:   --> 1: J(74), 3: J(4), 0: J(1), 4: P(0)
@70: [74]: F -> 1: J(74) finish unblocks join
74@70:   --> 1: J(74), 3: J(4), 0: J(1), 4: P(0)
1@70: stepThread(cycles = 1): minPause = 0
1@70:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@70: yieldForStep(cycles = 1)
1@70:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@70:   --> nextThreadId = 4
@70: [1]: P(1) -> 4: P(0) yield for step (1)
1@70:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@70: stepThread(cycles = 1): minPause = 1
4@70:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@70: doStep(cycles = 1)
4@71: yieldForStep(cycles = 0)
4@71:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@71:   --> nextThreadId = 1
@71: [4]: P(0) -> 1: P(0) yield for step (0)
4@71:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@71: forkThread(chiseltest_thread_75 (75) P1) from 1
1@71: yieldForFork()
1@71:   --> [1]: R, 3: J(4), 0: J(1), 75: P(0), 4: P(0)
1@71:   --> nextThreadId = 1
1@71: joinThreads(ids = List(75))
1@71:   --> nextThreadId = 75
@71: [1]: J(75) -> 75: P(0) waiting for 75
1@71:   --> [1]: J(75), 3: J(4), 0: J(1), 75: P(0), 4: P(0)
75@71: finishThread(id=75 (chiseltest_thread_75))
75@71:   --> 1: J(75), 3: J(4), 0: J(1), 4: P(0)
@71: [75]: F -> 1: J(75) finish unblocks join
75@71:   --> 1: J(75), 3: J(4), 0: J(1), 4: P(0)
1@71: stepThread(cycles = 1): minPause = 0
1@71:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@71: yieldForStep(cycles = 1)
1@71:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@71:   --> nextThreadId = 4
@71: [1]: P(1) -> 4: P(0) yield for step (1)
1@71:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@71: stepThread(cycles = 1): minPause = 1
4@71:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@71: doStep(cycles = 1)
4@72: yieldForStep(cycles = 0)
4@72:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@72:   --> nextThreadId = 1
@72: [4]: P(0) -> 1: P(0) yield for step (0)
4@72:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@72: forkThread(chiseltest_thread_76 (76) P1) from 1
1@72: yieldForFork()
1@72:   --> [1]: R, 3: J(4), 0: J(1), 76: P(0), 4: P(0)
1@72:   --> nextThreadId = 1
1@72: joinThreads(ids = List(76))
1@72:   --> nextThreadId = 76
@72: [1]: J(76) -> 76: P(0) waiting for 76
1@72:   --> [1]: J(76), 3: J(4), 0: J(1), 76: P(0), 4: P(0)
76@72: finishThread(id=76 (chiseltest_thread_76))
76@72:   --> 1: J(76), 3: J(4), 0: J(1), 4: P(0)
@72: [76]: F -> 1: J(76) finish unblocks join
76@72:   --> 1: J(76), 3: J(4), 0: J(1), 4: P(0)
1@72: stepThread(cycles = 1): minPause = 0
1@72:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@72: yieldForStep(cycles = 1)
1@72:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@72:   --> nextThreadId = 4
@72: [1]: P(1) -> 4: P(0) yield for step (1)
1@72:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@72: stepThread(cycles = 1): minPause = 1
4@72:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@72: doStep(cycles = 1)
4@73: yieldForStep(cycles = 0)
4@73:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@73:   --> nextThreadId = 1
@73: [4]: P(0) -> 1: P(0) yield for step (0)
4@73:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@73: forkThread(chiseltest_thread_77 (77) P1) from 1
1@73: yieldForFork()
1@73:   --> [1]: R, 3: J(4), 0: J(1), 77: P(0), 4: P(0)
1@73:   --> nextThreadId = 1
1@73: joinThreads(ids = List(77))
1@73:   --> nextThreadId = 77
@73: [1]: J(77) -> 77: P(0) waiting for 77
1@73:   --> [1]: J(77), 3: J(4), 0: J(1), 77: P(0), 4: P(0)
77@73: finishThread(id=77 (chiseltest_thread_77))
77@73:   --> 1: J(77), 3: J(4), 0: J(1), 4: P(0)
@73: [77]: F -> 1: J(77) finish unblocks join
77@73:   --> 1: J(77), 3: J(4), 0: J(1), 4: P(0)
1@73: stepThread(cycles = 1): minPause = 0
1@73:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@73: yieldForStep(cycles = 1)
1@73:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@73:   --> nextThreadId = 4
@73: [1]: P(1) -> 4: P(0) yield for step (1)
1@73:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@73: stepThread(cycles = 1): minPause = 1
4@73:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@73: doStep(cycles = 1)
4@74: yieldForStep(cycles = 0)
4@74:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@74:   --> nextThreadId = 1
@74: [4]: P(0) -> 1: P(0) yield for step (0)
4@74:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@74: forkThread(chiseltest_thread_78 (78) P1) from 1
1@74: yieldForFork()
1@74:   --> [1]: R, 3: J(4), 0: J(1), 78: P(0), 4: P(0)
1@74:   --> nextThreadId = 1
1@74: joinThreads(ids = List(78))
1@74:   --> nextThreadId = 78
@74: [1]: J(78) -> 78: P(0) waiting for 78
1@74:   --> [1]: J(78), 3: J(4), 0: J(1), 78: P(0), 4: P(0)
78@74: finishThread(id=78 (chiseltest_thread_78))
78@74:   --> 1: J(78), 3: J(4), 0: J(1), 4: P(0)
@74: [78]: F -> 1: J(78) finish unblocks join
78@74:   --> 1: J(78), 3: J(4), 0: J(1), 4: P(0)
1@74: stepThread(cycles = 1): minPause = 0
1@74:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@74: yieldForStep(cycles = 1)
1@74:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@74:   --> nextThreadId = 4
@74: [1]: P(1) -> 4: P(0) yield for step (1)
1@74:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@74: stepThread(cycles = 1): minPause = 1
4@74:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@74: doStep(cycles = 1)
4@75: yieldForStep(cycles = 0)
4@75:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@75:   --> nextThreadId = 1
@75: [4]: P(0) -> 1: P(0) yield for step (0)
4@75:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@75: forkThread(chiseltest_thread_79 (79) P1) from 1
1@75: yieldForFork()
1@75:   --> [1]: R, 3: J(4), 0: J(1), 79: P(0), 4: P(0)
1@75:   --> nextThreadId = 1
1@75: joinThreads(ids = List(79))
1@75:   --> nextThreadId = 79
@75: [1]: J(79) -> 79: P(0) waiting for 79
1@75:   --> [1]: J(79), 3: J(4), 0: J(1), 79: P(0), 4: P(0)
79@75: finishThread(id=79 (chiseltest_thread_79))
79@75:   --> 1: J(79), 3: J(4), 0: J(1), 4: P(0)
@75: [79]: F -> 1: J(79) finish unblocks join
79@75:   --> 1: J(79), 3: J(4), 0: J(1), 4: P(0)
1@75: stepThread(cycles = 1): minPause = 0
1@75:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@75: yieldForStep(cycles = 1)
1@75:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@75:   --> nextThreadId = 4
@75: [1]: P(1) -> 4: P(0) yield for step (1)
1@75:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@75: stepThread(cycles = 1): minPause = 1
4@75:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@75: doStep(cycles = 1)
4@76: yieldForStep(cycles = 0)
4@76:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@76:   --> nextThreadId = 1
@76: [4]: P(0) -> 1: P(0) yield for step (0)
4@76:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@76: forkThread(chiseltest_thread_80 (80) P1) from 1
1@76: yieldForFork()
1@76:   --> [1]: R, 3: J(4), 0: J(1), 80: P(0), 4: P(0)
1@76:   --> nextThreadId = 1
1@76: joinThreads(ids = List(80))
1@76:   --> nextThreadId = 80
@76: [1]: J(80) -> 80: P(0) waiting for 80
1@76:   --> [1]: J(80), 3: J(4), 0: J(1), 80: P(0), 4: P(0)
80@76: finishThread(id=80 (chiseltest_thread_80))
80@76:   --> 1: J(80), 3: J(4), 0: J(1), 4: P(0)
@76: [80]: F -> 1: J(80) finish unblocks join
80@76:   --> 1: J(80), 3: J(4), 0: J(1), 4: P(0)
1@76: stepThread(cycles = 1): minPause = 0
1@76:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@76: yieldForStep(cycles = 1)
1@76:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@76:   --> nextThreadId = 4
@76: [1]: P(1) -> 4: P(0) yield for step (1)
1@76:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@76: stepThread(cycles = 1): minPause = 1
4@76:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@76: doStep(cycles = 1)
4@77: yieldForStep(cycles = 0)
4@77:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@77:   --> nextThreadId = 1
@77: [4]: P(0) -> 1: P(0) yield for step (0)
4@77:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@77: forkThread(chiseltest_thread_81 (81) P1) from 1
1@77: yieldForFork()
1@77:   --> [1]: R, 3: J(4), 0: J(1), 81: P(0), 4: P(0)
1@77:   --> nextThreadId = 1
1@77: joinThreads(ids = List(81))
1@77:   --> nextThreadId = 81
@77: [1]: J(81) -> 81: P(0) waiting for 81
1@77:   --> [1]: J(81), 3: J(4), 0: J(1), 81: P(0), 4: P(0)
81@77: finishThread(id=81 (chiseltest_thread_81))
81@77:   --> 1: J(81), 3: J(4), 0: J(1), 4: P(0)
@77: [81]: F -> 1: J(81) finish unblocks join
81@77:   --> 1: J(81), 3: J(4), 0: J(1), 4: P(0)
1@77: stepThread(cycles = 1): minPause = 0
1@77:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@77: yieldForStep(cycles = 1)
1@77:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@77:   --> nextThreadId = 4
@77: [1]: P(1) -> 4: P(0) yield for step (1)
1@77:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@77: stepThread(cycles = 1): minPause = 1
4@77:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@77: doStep(cycles = 1)
4@78: yieldForStep(cycles = 0)
4@78:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@78:   --> nextThreadId = 1
@78: [4]: P(0) -> 1: P(0) yield for step (0)
4@78:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@78: forkThread(chiseltest_thread_82 (82) P1) from 1
1@78: yieldForFork()
1@78:   --> [1]: R, 3: J(4), 0: J(1), 82: P(0), 4: P(0)
1@78:   --> nextThreadId = 1
1@78: joinThreads(ids = List(82))
1@78:   --> nextThreadId = 82
@78: [1]: J(82) -> 82: P(0) waiting for 82
1@78:   --> [1]: J(82), 3: J(4), 0: J(1), 82: P(0), 4: P(0)
82@78: finishThread(id=82 (chiseltest_thread_82))
82@78:   --> 1: J(82), 3: J(4), 0: J(1), 4: P(0)
@78: [82]: F -> 1: J(82) finish unblocks join
82@78:   --> 1: J(82), 3: J(4), 0: J(1), 4: P(0)
1@78: stepThread(cycles = 1): minPause = 0
1@78:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@78: yieldForStep(cycles = 1)
1@78:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@78:   --> nextThreadId = 4
@78: [1]: P(1) -> 4: P(0) yield for step (1)
1@78:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@78: stepThread(cycles = 1): minPause = 1
4@78:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@78: doStep(cycles = 1)
4@79: yieldForStep(cycles = 0)
4@79:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@79:   --> nextThreadId = 1
@79: [4]: P(0) -> 1: P(0) yield for step (0)
4@79:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@79: forkThread(chiseltest_thread_83 (83) P1) from 1
1@79: yieldForFork()
1@79:   --> [1]: R, 3: J(4), 0: J(1), 83: P(0), 4: P(0)
1@79:   --> nextThreadId = 1
1@79: joinThreads(ids = List(83))
1@79:   --> nextThreadId = 83
@79: [1]: J(83) -> 83: P(0) waiting for 83
1@79:   --> [1]: J(83), 3: J(4), 0: J(1), 83: P(0), 4: P(0)
83@79: finishThread(id=83 (chiseltest_thread_83))
83@79:   --> 1: J(83), 3: J(4), 0: J(1), 4: P(0)
@79: [83]: F -> 1: J(83) finish unblocks join
83@79:   --> 1: J(83), 3: J(4), 0: J(1), 4: P(0)
1@79: stepThread(cycles = 1): minPause = 0
1@79:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@79: yieldForStep(cycles = 1)
1@79:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@79:   --> nextThreadId = 4
@79: [1]: P(1) -> 4: P(0) yield for step (1)
1@79:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@79: stepThread(cycles = 1): minPause = 1
4@79:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@79: doStep(cycles = 1)
4@80: yieldForStep(cycles = 0)
4@80:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@80:   --> nextThreadId = 1
@80: [4]: P(0) -> 1: P(0) yield for step (0)
4@80:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@80: forkThread(chiseltest_thread_84 (84) P1) from 1
1@80: yieldForFork()
1@80:   --> [1]: R, 3: J(4), 0: J(1), 84: P(0), 4: P(0)
1@80:   --> nextThreadId = 1
1@80: joinThreads(ids = List(84))
1@80:   --> nextThreadId = 84
@80: [1]: J(84) -> 84: P(0) waiting for 84
1@80:   --> [1]: J(84), 3: J(4), 0: J(1), 84: P(0), 4: P(0)
84@80: finishThread(id=84 (chiseltest_thread_84))
84@80:   --> 1: J(84), 3: J(4), 0: J(1), 4: P(0)
@80: [84]: F -> 1: J(84) finish unblocks join
84@80:   --> 1: J(84), 3: J(4), 0: J(1), 4: P(0)
1@80: stepThread(cycles = 1): minPause = 0
1@80:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@80: yieldForStep(cycles = 1)
1@80:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@80:   --> nextThreadId = 4
@80: [1]: P(1) -> 4: P(0) yield for step (1)
1@80:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@80: stepThread(cycles = 1): minPause = 1
4@80:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@80: doStep(cycles = 1)
4@81: yieldForStep(cycles = 0)
4@81:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@81:   --> nextThreadId = 1
@81: [4]: P(0) -> 1: P(0) yield for step (0)
4@81:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@81: forkThread(chiseltest_thread_85 (85) P1) from 1
1@81: yieldForFork()
1@81:   --> [1]: R, 3: J(4), 0: J(1), 85: P(0), 4: P(0)
1@81:   --> nextThreadId = 1
1@81: joinThreads(ids = List(85))
1@81:   --> nextThreadId = 85
@81: [1]: J(85) -> 85: P(0) waiting for 85
1@81:   --> [1]: J(85), 3: J(4), 0: J(1), 85: P(0), 4: P(0)
85@81: finishThread(id=85 (chiseltest_thread_85))
85@81:   --> 1: J(85), 3: J(4), 0: J(1), 4: P(0)
@81: [85]: F -> 1: J(85) finish unblocks join
85@81:   --> 1: J(85), 3: J(4), 0: J(1), 4: P(0)
1@81: stepThread(cycles = 1): minPause = 0
1@81:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@81: yieldForStep(cycles = 1)
1@81:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@81:   --> nextThreadId = 4
@81: [1]: P(1) -> 4: P(0) yield for step (1)
1@81:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@81: stepThread(cycles = 1): minPause = 1
4@81:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@81: doStep(cycles = 1)
4@82: yieldForStep(cycles = 0)
4@82:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@82:   --> nextThreadId = 1
@82: [4]: P(0) -> 1: P(0) yield for step (0)
4@82:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@82: forkThread(chiseltest_thread_86 (86) P1) from 1
1@82: yieldForFork()
1@82:   --> [1]: R, 3: J(4), 0: J(1), 86: P(0), 4: P(0)
1@82:   --> nextThreadId = 1
1@82: joinThreads(ids = List(86))
1@82:   --> nextThreadId = 86
@82: [1]: J(86) -> 86: P(0) waiting for 86
1@82:   --> [1]: J(86), 3: J(4), 0: J(1), 86: P(0), 4: P(0)
86@82: finishThread(id=86 (chiseltest_thread_86))
86@82:   --> 1: J(86), 3: J(4), 0: J(1), 4: P(0)
@82: [86]: F -> 1: J(86) finish unblocks join
86@82:   --> 1: J(86), 3: J(4), 0: J(1), 4: P(0)
1@82: stepThread(cycles = 1): minPause = 0
1@82:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@82: yieldForStep(cycles = 1)
1@82:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@82:   --> nextThreadId = 4
@82: [1]: P(1) -> 4: P(0) yield for step (1)
1@82:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@82: stepThread(cycles = 1): minPause = 1
4@82:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@82: doStep(cycles = 1)
4@83: yieldForStep(cycles = 0)
4@83:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@83:   --> nextThreadId = 1
@83: [4]: P(0) -> 1: P(0) yield for step (0)
4@83:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@83: forkThread(chiseltest_thread_87 (87) P1) from 1
1@83: yieldForFork()
1@83:   --> [1]: R, 3: J(4), 0: J(1), 87: P(0), 4: P(0)
1@83:   --> nextThreadId = 1
1@83: joinThreads(ids = List(87))
1@83:   --> nextThreadId = 87
@83: [1]: J(87) -> 87: P(0) waiting for 87
1@83:   --> [1]: J(87), 3: J(4), 0: J(1), 87: P(0), 4: P(0)
87@83: finishThread(id=87 (chiseltest_thread_87))
87@83:   --> 1: J(87), 3: J(4), 0: J(1), 4: P(0)
@83: [87]: F -> 1: J(87) finish unblocks join
87@83:   --> 1: J(87), 3: J(4), 0: J(1), 4: P(0)
1@83: stepThread(cycles = 1): minPause = 0
1@83:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@83: yieldForStep(cycles = 1)
1@83:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@83:   --> nextThreadId = 4
@83: [1]: P(1) -> 4: P(0) yield for step (1)
1@83:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@83: stepThread(cycles = 1): minPause = 1
4@83:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@83: doStep(cycles = 1)
4@84: yieldForStep(cycles = 0)
4@84:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@84:   --> nextThreadId = 1
@84: [4]: P(0) -> 1: P(0) yield for step (0)
4@84:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@84: forkThread(chiseltest_thread_88 (88) P1) from 1
1@84: yieldForFork()
1@84:   --> [1]: R, 3: J(4), 0: J(1), 88: P(0), 4: P(0)
1@84:   --> nextThreadId = 1
1@84: joinThreads(ids = List(88))
1@84:   --> nextThreadId = 88
@84: [1]: J(88) -> 88: P(0) waiting for 88
1@84:   --> [1]: J(88), 3: J(4), 0: J(1), 88: P(0), 4: P(0)
88@84: finishThread(id=88 (chiseltest_thread_88))
88@84:   --> 1: J(88), 3: J(4), 0: J(1), 4: P(0)
@84: [88]: F -> 1: J(88) finish unblocks join
88@84:   --> 1: J(88), 3: J(4), 0: J(1), 4: P(0)
1@84: stepThread(cycles = 1): minPause = 0
1@84:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@84: yieldForStep(cycles = 1)
1@84:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@84:   --> nextThreadId = 4
@84: [1]: P(1) -> 4: P(0) yield for step (1)
1@84:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@84: stepThread(cycles = 1): minPause = 1
4@84:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@84: doStep(cycles = 1)
4@85: yieldForStep(cycles = 0)
4@85:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@85:   --> nextThreadId = 1
@85: [4]: P(0) -> 1: P(0) yield for step (0)
4@85:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@85: forkThread(chiseltest_thread_89 (89) P1) from 1
1@85: yieldForFork()
1@85:   --> [1]: R, 3: J(4), 0: J(1), 89: P(0), 4: P(0)
1@85:   --> nextThreadId = 1
1@85: joinThreads(ids = List(89))
1@85:   --> nextThreadId = 89
@85: [1]: J(89) -> 89: P(0) waiting for 89
1@85:   --> [1]: J(89), 3: J(4), 0: J(1), 89: P(0), 4: P(0)
89@85: finishThread(id=89 (chiseltest_thread_89))
89@85:   --> 1: J(89), 3: J(4), 0: J(1), 4: P(0)
@85: [89]: F -> 1: J(89) finish unblocks join
89@85:   --> 1: J(89), 3: J(4), 0: J(1), 4: P(0)
1@85: stepThread(cycles = 1): minPause = 0
1@85:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@85: yieldForStep(cycles = 1)
1@85:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@85:   --> nextThreadId = 4
@85: [1]: P(1) -> 4: P(0) yield for step (1)
1@85:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@85: stepThread(cycles = 1): minPause = 1
4@85:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@85: doStep(cycles = 1)
4@86: yieldForStep(cycles = 0)
4@86:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@86:   --> nextThreadId = 1
@86: [4]: P(0) -> 1: P(0) yield for step (0)
4@86:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@86: forkThread(chiseltest_thread_90 (90) P1) from 1
1@86: yieldForFork()
1@86:   --> [1]: R, 3: J(4), 0: J(1), 90: P(0), 4: P(0)
1@86:   --> nextThreadId = 1
1@86: joinThreads(ids = List(90))
1@86:   --> nextThreadId = 90
@86: [1]: J(90) -> 90: P(0) waiting for 90
1@86:   --> [1]: J(90), 3: J(4), 0: J(1), 90: P(0), 4: P(0)
90@86: finishThread(id=90 (chiseltest_thread_90))
90@86:   --> 1: J(90), 3: J(4), 0: J(1), 4: P(0)
@86: [90]: F -> 1: J(90) finish unblocks join
90@86:   --> 1: J(90), 3: J(4), 0: J(1), 4: P(0)
1@86: stepThread(cycles = 1): minPause = 0
1@86:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@86: yieldForStep(cycles = 1)
1@86:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@86:   --> nextThreadId = 4
@86: [1]: P(1) -> 4: P(0) yield for step (1)
1@86:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@86: stepThread(cycles = 1): minPause = 1
4@86:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@86: doStep(cycles = 1)
4@87: yieldForStep(cycles = 0)
4@87:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@87:   --> nextThreadId = 1
@87: [4]: P(0) -> 1: P(0) yield for step (0)
4@87:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@87: forkThread(chiseltest_thread_91 (91) P1) from 1
1@87: yieldForFork()
1@87:   --> [1]: R, 3: J(4), 0: J(1), 91: P(0), 4: P(0)
1@87:   --> nextThreadId = 1
1@87: joinThreads(ids = List(91))
1@87:   --> nextThreadId = 91
@87: [1]: J(91) -> 91: P(0) waiting for 91
1@87:   --> [1]: J(91), 3: J(4), 0: J(1), 91: P(0), 4: P(0)
91@87: finishThread(id=91 (chiseltest_thread_91))
91@87:   --> 1: J(91), 3: J(4), 0: J(1), 4: P(0)
@87: [91]: F -> 1: J(91) finish unblocks join
91@87:   --> 1: J(91), 3: J(4), 0: J(1), 4: P(0)
1@87: stepThread(cycles = 1): minPause = 0
1@87:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@87: yieldForStep(cycles = 1)
1@87:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@87:   --> nextThreadId = 4
@87: [1]: P(1) -> 4: P(0) yield for step (1)
1@87:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@87: stepThread(cycles = 1): minPause = 1
4@87:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@87: doStep(cycles = 1)
4@88: yieldForStep(cycles = 0)
4@88:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@88:   --> nextThreadId = 1
@88: [4]: P(0) -> 1: P(0) yield for step (0)
4@88:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@88: forkThread(chiseltest_thread_92 (92) P1) from 1
1@88: yieldForFork()
1@88:   --> [1]: R, 3: J(4), 0: J(1), 92: P(0), 4: P(0)
1@88:   --> nextThreadId = 1
1@88: joinThreads(ids = List(92))
1@88:   --> nextThreadId = 92
@88: [1]: J(92) -> 92: P(0) waiting for 92
1@88:   --> [1]: J(92), 3: J(4), 0: J(1), 92: P(0), 4: P(0)
92@88: finishThread(id=92 (chiseltest_thread_92))
92@88:   --> 1: J(92), 3: J(4), 0: J(1), 4: P(0)
@88: [92]: F -> 1: J(92) finish unblocks join
92@88:   --> 1: J(92), 3: J(4), 0: J(1), 4: P(0)
1@88: stepThread(cycles = 1): minPause = 0
1@88:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@88: yieldForStep(cycles = 1)
1@88:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@88:   --> nextThreadId = 4
@88: [1]: P(1) -> 4: P(0) yield for step (1)
1@88:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@88: stepThread(cycles = 1): minPause = 1
4@88:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@88: doStep(cycles = 1)
4@89: yieldForStep(cycles = 0)
4@89:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@89:   --> nextThreadId = 1
@89: [4]: P(0) -> 1: P(0) yield for step (0)
4@89:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@89: forkThread(chiseltest_thread_93 (93) P1) from 1
1@89: yieldForFork()
1@89:   --> [1]: R, 3: J(4), 0: J(1), 93: P(0), 4: P(0)
1@89:   --> nextThreadId = 1
1@89: joinThreads(ids = List(93))
1@89:   --> nextThreadId = 93
@89: [1]: J(93) -> 93: P(0) waiting for 93
1@89:   --> [1]: J(93), 3: J(4), 0: J(1), 93: P(0), 4: P(0)
93@89: finishThread(id=93 (chiseltest_thread_93))
93@89:   --> 1: J(93), 3: J(4), 0: J(1), 4: P(0)
@89: [93]: F -> 1: J(93) finish unblocks join
93@89:   --> 1: J(93), 3: J(4), 0: J(1), 4: P(0)
1@89: stepThread(cycles = 1): minPause = 0
1@89:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@89: yieldForStep(cycles = 1)
1@89:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@89:   --> nextThreadId = 4
@89: [1]: P(1) -> 4: P(0) yield for step (1)
1@89:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@89: stepThread(cycles = 1): minPause = 1
4@89:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@89: doStep(cycles = 1)
4@90: yieldForStep(cycles = 0)
4@90:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@90:   --> nextThreadId = 1
@90: [4]: P(0) -> 1: P(0) yield for step (0)
4@90:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@90: forkThread(chiseltest_thread_94 (94) P1) from 1
1@90: yieldForFork()
1@90:   --> [1]: R, 3: J(4), 0: J(1), 94: P(0), 4: P(0)
1@90:   --> nextThreadId = 1
1@90: joinThreads(ids = List(94))
1@90:   --> nextThreadId = 94
@90: [1]: J(94) -> 94: P(0) waiting for 94
1@90:   --> [1]: J(94), 3: J(4), 0: J(1), 94: P(0), 4: P(0)
94@90: finishThread(id=94 (chiseltest_thread_94))
94@90:   --> 1: J(94), 3: J(4), 0: J(1), 4: P(0)
@90: [94]: F -> 1: J(94) finish unblocks join
94@90:   --> 1: J(94), 3: J(4), 0: J(1), 4: P(0)
1@90: stepThread(cycles = 1): minPause = 0
1@90:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@90: yieldForStep(cycles = 1)
1@90:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@90:   --> nextThreadId = 4
@90: [1]: P(1) -> 4: P(0) yield for step (1)
1@90:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@90: stepThread(cycles = 1): minPause = 1
4@90:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@90: doStep(cycles = 1)
4@91: yieldForStep(cycles = 0)
4@91:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@91:   --> nextThreadId = 1
@91: [4]: P(0) -> 1: P(0) yield for step (0)
4@91:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@91: forkThread(chiseltest_thread_95 (95) P1) from 1
1@91: yieldForFork()
1@91:   --> [1]: R, 3: J(4), 0: J(1), 95: P(0), 4: P(0)
1@91:   --> nextThreadId = 1
1@91: joinThreads(ids = List(95))
1@91:   --> nextThreadId = 95
@91: [1]: J(95) -> 95: P(0) waiting for 95
1@91:   --> [1]: J(95), 3: J(4), 0: J(1), 95: P(0), 4: P(0)
95@91: finishThread(id=95 (chiseltest_thread_95))
95@91:   --> 1: J(95), 3: J(4), 0: J(1), 4: P(0)
@91: [95]: F -> 1: J(95) finish unblocks join
95@91:   --> 1: J(95), 3: J(4), 0: J(1), 4: P(0)
1@91: stepThread(cycles = 1): minPause = 0
1@91:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@91: yieldForStep(cycles = 1)
1@91:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@91:   --> nextThreadId = 4
@91: [1]: P(1) -> 4: P(0) yield for step (1)
1@91:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@91: stepThread(cycles = 1): minPause = 1
4@91:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@91: doStep(cycles = 1)
4@92: yieldForStep(cycles = 0)
4@92:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@92:   --> nextThreadId = 1
@92: [4]: P(0) -> 1: P(0) yield for step (0)
4@92:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@92: forkThread(chiseltest_thread_96 (96) P1) from 1
1@92: yieldForFork()
1@92:   --> [1]: R, 3: J(4), 0: J(1), 96: P(0), 4: P(0)
1@92:   --> nextThreadId = 1
1@92: joinThreads(ids = List(96))
1@92:   --> nextThreadId = 96
@92: [1]: J(96) -> 96: P(0) waiting for 96
1@92:   --> [1]: J(96), 3: J(4), 0: J(1), 96: P(0), 4: P(0)
96@92: finishThread(id=96 (chiseltest_thread_96))
96@92:   --> 1: J(96), 3: J(4), 0: J(1), 4: P(0)
@92: [96]: F -> 1: J(96) finish unblocks join
96@92:   --> 1: J(96), 3: J(4), 0: J(1), 4: P(0)
1@92: stepThread(cycles = 1): minPause = 0
1@92:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@92: yieldForStep(cycles = 1)
1@92:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@92:   --> nextThreadId = 4
@92: [1]: P(1) -> 4: P(0) yield for step (1)
1@92:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@92: stepThread(cycles = 1): minPause = 1
4@92:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@92: doStep(cycles = 1)
4@93: yieldForStep(cycles = 0)
4@93:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@93:   --> nextThreadId = 1
@93: [4]: P(0) -> 1: P(0) yield for step (0)
4@93:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@93: forkThread(chiseltest_thread_97 (97) P1) from 1
1@93: yieldForFork()
1@93:   --> [1]: R, 3: J(4), 0: J(1), 97: P(0), 4: P(0)
1@93:   --> nextThreadId = 1
1@93: joinThreads(ids = List(97))
1@93:   --> nextThreadId = 97
@93: [1]: J(97) -> 97: P(0) waiting for 97
1@93:   --> [1]: J(97), 3: J(4), 0: J(1), 97: P(0), 4: P(0)
97@93: finishThread(id=97 (chiseltest_thread_97))
97@93:   --> 1: J(97), 3: J(4), 0: J(1), 4: P(0)
@93: [97]: F -> 1: J(97) finish unblocks join
97@93:   --> 1: J(97), 3: J(4), 0: J(1), 4: P(0)
1@93: stepThread(cycles = 1): minPause = 0
1@93:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@93: yieldForStep(cycles = 1)
1@93:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@93:   --> nextThreadId = 4
@93: [1]: P(1) -> 4: P(0) yield for step (1)
1@93:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@93: stepThread(cycles = 1): minPause = 1
4@93:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@93: doStep(cycles = 1)
4@94: yieldForStep(cycles = 0)
4@94:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@94:   --> nextThreadId = 1
@94: [4]: P(0) -> 1: P(0) yield for step (0)
4@94:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@94: forkThread(chiseltest_thread_98 (98) P1) from 1
1@94: yieldForFork()
1@94:   --> [1]: R, 3: J(4), 0: J(1), 98: P(0), 4: P(0)
1@94:   --> nextThreadId = 1
1@94: joinThreads(ids = List(98))
1@94:   --> nextThreadId = 98
@94: [1]: J(98) -> 98: P(0) waiting for 98
1@94:   --> [1]: J(98), 3: J(4), 0: J(1), 98: P(0), 4: P(0)
98@94: finishThread(id=98 (chiseltest_thread_98))
98@94:   --> 1: J(98), 3: J(4), 0: J(1), 4: P(0)
@94: [98]: F -> 1: J(98) finish unblocks join
98@94:   --> 1: J(98), 3: J(4), 0: J(1), 4: P(0)
1@94: stepThread(cycles = 1): minPause = 0
1@94:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@94: yieldForStep(cycles = 1)
1@94:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@94:   --> nextThreadId = 4
@94: [1]: P(1) -> 4: P(0) yield for step (1)
1@94:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@94: stepThread(cycles = 1): minPause = 1
4@94:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@94: doStep(cycles = 1)
4@95: yieldForStep(cycles = 0)
4@95:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@95:   --> nextThreadId = 1
@95: [4]: P(0) -> 1: P(0) yield for step (0)
4@95:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@95: forkThread(chiseltest_thread_99 (99) P1) from 1
1@95: yieldForFork()
1@95:   --> [1]: R, 3: J(4), 0: J(1), 99: P(0), 4: P(0)
1@95:   --> nextThreadId = 1
1@95: joinThreads(ids = List(99))
1@95:   --> nextThreadId = 99
@95: [1]: J(99) -> 99: P(0) waiting for 99
1@95:   --> [1]: J(99), 3: J(4), 0: J(1), 99: P(0), 4: P(0)
99@95: finishThread(id=99 (chiseltest_thread_99))
99@95:   --> 1: J(99), 3: J(4), 0: J(1), 4: P(0)
@95: [99]: F -> 1: J(99) finish unblocks join
99@95:   --> 1: J(99), 3: J(4), 0: J(1), 4: P(0)
1@95: stepThread(cycles = 1): minPause = 0
1@95:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@95: yieldForStep(cycles = 1)
1@95:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@95:   --> nextThreadId = 4
@95: [1]: P(1) -> 4: P(0) yield for step (1)
1@95:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@95: stepThread(cycles = 1): minPause = 1
4@95:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@95: doStep(cycles = 1)
4@96: yieldForStep(cycles = 0)
4@96:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@96:   --> nextThreadId = 1
@96: [4]: P(0) -> 1: P(0) yield for step (0)
4@96:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@96: forkThread(chiseltest_thread_100 (100) P1) from 1
1@96: yieldForFork()
1@96:   --> [1]: R, 3: J(4), 0: J(1), 100: P(0), 4: P(0)
1@96:   --> nextThreadId = 1
1@96: joinThreads(ids = List(100))
1@96:   --> nextThreadId = 100
@96: [1]: J(100) -> 100: P(0) waiting for 100
1@96:   --> [1]: J(100), 3: J(4), 0: J(1), 100: P(0), 4: P(0)
100@96: finishThread(id=100 (chiseltest_thread_100))
100@96:   --> 1: J(100), 3: J(4), 0: J(1), 4: P(0)
@96: [100]: F -> 1: J(100) finish unblocks join
100@96:   --> 1: J(100), 3: J(4), 0: J(1), 4: P(0)
1@96: stepThread(cycles = 1): minPause = 0
1@96:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@96: yieldForStep(cycles = 1)
1@96:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@96:   --> nextThreadId = 4
@96: [1]: P(1) -> 4: P(0) yield for step (1)
1@96:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@96: stepThread(cycles = 1): minPause = 1
4@96:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@96: doStep(cycles = 1)
4@97: yieldForStep(cycles = 0)
4@97:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@97:   --> nextThreadId = 1
@97: [4]: P(0) -> 1: P(0) yield for step (0)
4@97:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@97: forkThread(chiseltest_thread_101 (101) P1) from 1
1@97: yieldForFork()
1@97:   --> [1]: R, 3: J(4), 0: J(1), 101: P(0), 4: P(0)
1@97:   --> nextThreadId = 1
1@97: joinThreads(ids = List(101))
1@97:   --> nextThreadId = 101
@97: [1]: J(101) -> 101: P(0) waiting for 101
1@97:   --> [1]: J(101), 3: J(4), 0: J(1), 101: P(0), 4: P(0)
101@97: finishThread(id=101 (chiseltest_thread_101))
101@97:   --> 1: J(101), 3: J(4), 0: J(1), 4: P(0)
@97: [101]: F -> 1: J(101) finish unblocks join
101@97:   --> 1: J(101), 3: J(4), 0: J(1), 4: P(0)
1@97: stepThread(cycles = 1): minPause = 0
1@97:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@97: yieldForStep(cycles = 1)
1@97:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@97:   --> nextThreadId = 4
@97: [1]: P(1) -> 4: P(0) yield for step (1)
1@97:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@97: stepThread(cycles = 1): minPause = 1
4@97:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@97: doStep(cycles = 1)
4@98: yieldForStep(cycles = 0)
4@98:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@98:   --> nextThreadId = 1
@98: [4]: P(0) -> 1: P(0) yield for step (0)
4@98:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@98: forkThread(chiseltest_thread_102 (102) P1) from 1
1@98: yieldForFork()
1@98:   --> [1]: R, 3: J(4), 0: J(1), 102: P(0), 4: P(0)
1@98:   --> nextThreadId = 1
1@98: joinThreads(ids = List(102))
1@98:   --> nextThreadId = 102
@98: [1]: J(102) -> 102: P(0) waiting for 102
1@98:   --> [1]: J(102), 3: J(4), 0: J(1), 102: P(0), 4: P(0)
102@98: finishThread(id=102 (chiseltest_thread_102))
102@98:   --> 1: J(102), 3: J(4), 0: J(1), 4: P(0)
@98: [102]: F -> 1: J(102) finish unblocks join
102@98:   --> 1: J(102), 3: J(4), 0: J(1), 4: P(0)
1@98: stepThread(cycles = 1): minPause = 0
1@98:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@98: yieldForStep(cycles = 1)
1@98:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@98:   --> nextThreadId = 4
@98: [1]: P(1) -> 4: P(0) yield for step (1)
1@98:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@98: stepThread(cycles = 1): minPause = 1
4@98:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@98: doStep(cycles = 1)
4@99: yieldForStep(cycles = 0)
4@99:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@99:   --> nextThreadId = 1
@99: [4]: P(0) -> 1: P(0) yield for step (0)
4@99:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@99: forkThread(chiseltest_thread_103 (103) P1) from 1
1@99: yieldForFork()
1@99:   --> [1]: R, 3: J(4), 0: J(1), 103: P(0), 4: P(0)
1@99:   --> nextThreadId = 1
1@99: joinThreads(ids = List(103))
1@99:   --> nextThreadId = 103
@99: [1]: J(103) -> 103: P(0) waiting for 103
1@99:   --> [1]: J(103), 3: J(4), 0: J(1), 103: P(0), 4: P(0)
103@99: finishThread(id=103 (chiseltest_thread_103))
103@99:   --> 1: J(103), 3: J(4), 0: J(1), 4: P(0)
@99: [103]: F -> 1: J(103) finish unblocks join
103@99:   --> 1: J(103), 3: J(4), 0: J(1), 4: P(0)
1@99: stepThread(cycles = 1): minPause = 0
1@99:   --> [1]: R, 3: J(4), 0: J(1), 4: P(0)
1@99: yieldForStep(cycles = 1)
1@99:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
1@99:   --> nextThreadId = 4
@99: [1]: P(1) -> 4: P(0) yield for step (1)
1@99:   --> [1]: P(1), 3: J(4), 0: J(1), 4: P(0)
4@99: stepThread(cycles = 1): minPause = 1
4@99:   --> 1: P(1), 3: J(4), 0: J(1), [4]: R
4@99: doStep(cycles = 1)
4@100: yieldForStep(cycles = 0)
4@100:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
4@100:   --> nextThreadId = 1
@100: [4]: P(0) -> 1: P(0) yield for step (0)
4@100:   --> 1: P(0), 3: J(4), 0: J(1), [4]: P(0)
1@100: finishThread(id=1 (chiseltest_thread_1))
1@100:   --> 3: J(4), 0: J(1), 4: P(0)
@100: [1]: F -> 0: J(1) finish unblocks join
1@100:   --> 3: J(4), 0: J(1), 4: P(0)
0@100:   --> nextThreadId = 4
@100: [0]: J(3) -> 4: P(0) waiting for 3
0@100:   --> 3: J(4), [0]: J(3), 4: P(0)
4@100: finishThread(id=4 (chiseltest_thread_4))
4@100:   --> 3: J(4), 0: J(3)
@100: [4]: F -> 3: J(4) finish unblocks join
4@100:   --> 3: J(4), 0: J(3)
3@100: doStep(cycles = 1)
3@101: finishThread(id=3 (chiseltest_thread_3))
3@101:   --> 0: J(3)
@101: [3]: F -> 0: J(3) finish unblocks join
3@101:   --> 0: J(3)
0@101: forkThread(chiseltest_thread_104 (104) P0) from 0
0@101: yieldForFork()
0@101:   --> 104: P(0), [0]: R
0@101:   --> nextThreadId = 104
@101: [0]: P(0) -> 104: P(0) fork
0@101:   --> 104: P(0), [0]: P(0)
104@101: forkThread(chiseltest_thread_105 (105) P1) from 104
104@101: yieldForFork()
104@101:   --> [104]: R, 0: P(0), 105: P(0)
104@101:   --> nextThreadId = 104
104@101: joinThreads(ids = List(105))
104@101:   --> nextThreadId = 0
@101: [104]: J(105) -> 0: P(0) waiting for 105
104@101:   --> [104]: J(105), 0: P(0), 105: P(0)
0@101: forkThread(chiseltest_thread_106 (106) P0) from 0
0@101: yieldForFork()
0@101:   --> 104: J(105), 106: P(0), [0]: R, 105: P(0)
0@101:   --> nextThreadId = 106
@101: [0]: P(0) -> 106: P(0) fork
0@101:   --> 104: J(105), 106: P(0), [0]: P(0), 105: P(0)
106@101: Caught exception (chiseltest.ThreadOrderDependentException). Shutting down and propagating exception to parent.
106@101: finishThread(id=106 (chiseltest_thread_106))
106@101:   --> 104: J(105), 0: P(0), 105: P(0)
106@101:   --> nextThreadId = 0
@101: [106]: F -> 0: P(0) finish
106@101:   --> 104: J(105), 0: P(0), 105: P(0)
0@101: terminating: chiseltest_thread_104 (104), chiseltest_thread_105 (105)
- should work *** FAILED ***
  java.lang.AssertionError: assertion failed: Cannot terminate thread waiting for join chiseltest_thread_104 (104)
  at scala.Predef$.assert(Predef.scala:279)
  at chiseltest.internal.Scheduler.chiseltest$internal$Scheduler$$terminateAllChildThreads(Scheduler.scala:427)
  at chiseltest.internal.Scheduler.finishMainThread(Scheduler.scala:446)
  at chiseltest.internal.SimController.run(SimController.scala:127)
  at chiseltest.internal.Context$.$anonfun$runTest$2(Context.scala:30)
  at scala.util.DynamicVariable.withValue(DynamicVariable.scala:59)
  at chiseltest.internal.Context$.runTest(Context.scala:30)
  at chiseltest.ChiselScalatestTester.chiseltest$ChiselScalatestTester$$runTest(ChiselScalatestTester.scala:96)
  at chiseltest.ChiselScalatestTester$TestBuilder.apply(ChiselScalatestTester.scala:30)
  at MWE.$anonfun$new$17(mwe.scala:47)
  ...
1 targets failed
mwe.testOnly 1 tests failed: 
  MWE should work

from chiseltest.

kammoh commented on September 25, 2024

I fixed an issue with the minimal example and simplified it a bit. I also enabled DebugThreadSwitches in addition to EnableDebug in the generated output. Please let me know if there's anything else I can do to help with the debugging.
Thanks!

from chiseltest.

kammoh commented on September 25, 2024

I reinstalled JDK on my system and did a full clean of the project and _ miraculously_ everything has started to work again! I'm no longer able to reproduce the issue, neither with the minimal example or other testbenches!
I had already tried tried the same steps before without any luch so no idea what happened or what was the real cause of the exceptions.
I'm going to close this issue for now and will re-open if they show up again.

from chiseltest.

ekiwi commented on September 25, 2024

Glad it works for you! Let me know if this happens again.

from chiseltest.

Frequent crash on macOS with the threaded Verilator backend about chiseltest HOT 6 CLOSED

Comments (6)

Related Issues (20)

Recommend Projects

React

Vue.js

Typescript

TensorFlow

Django

Laravel

D3

Recommend Topics

javascript

web

server

Machine learning

Visualization

Game

Recommend Org

Facebook

Microsoft

Google

Alibaba

D3

Tencent