` to be incremented
- * @param delta the amount to increment
- */
- def increment(ref: Ref.View[java.lang.Long], delta: Long): Unit = ref.transform { v ⇒ v.longValue + delta }
-
- private def activeTxn = Txn.findCurrent match {
- case Some(txn) => txn
- case None => throw new IllegalStateException("not in a transaction")
- }
-
- /**
- * Add a task to run after the current transaction has committed.
- * @param task the `Runnable` task to run after transaction commit
- * @throws IllegalStateException if called from outside a transaction
- */
- def afterCommit(task: Runnable): Unit = Txn.afterCommit(status ⇒ task.run)(activeTxn)
-
- /**
- * Add a task to run after the current transaction has rolled back.
- * @param task the `Runnable` task to run after transaction rollback
- * @throws IllegalStateException if called from outside a transaction
- */
- def afterRollback(task: Runnable): Unit = Txn.afterRollback(status ⇒ task.run)(activeTxn)
-
- /**
- * Add a task to run after the current transaction has either rolled back
- * or committed.
- * @param task the `Runnable` task to run after transaction completion
- * @throws IllegalStateException if called from outside a transaction
- */
- def afterCompletion(task: Runnable): Unit = Txn.afterCompletion(status ⇒ task.run)(activeTxn)
-}
diff --git a/benchmarks/scala-stm/scala-stm-library/src/main/scala/scala/concurrent/stm/package.scala b/benchmarks/scala-stm/scala-stm-library/src/main/scala/scala/concurrent/stm/package.scala
deleted file mode 100644
index b118e3f1..00000000
--- a/benchmarks/scala-stm/scala-stm-library/src/main/scala/scala/concurrent/stm/package.scala
+++ /dev/null
@@ -1,24 +0,0 @@
-/* scala-stm - (c) 2009-2012, Stanford University, PPL */
-
-package scala.concurrent
-
-import java.util.concurrent.TimeUnit
-
-package object stm {
-
- /** Atomically executes atomic blocks using the default `TxnExecutor`. See
- * `TxnExecutor.apply`.
- */
- def atomic: scala.concurrent.stm.TxnExecutor = scala.concurrent.stm.TxnExecutor.defaultAtomic
-
- /** Equivalent to `Txn.retry`. */
- def retry(implicit txn: scala.concurrent.stm.InTxn): Nothing = scala.concurrent.stm.Txn.retry
-
- /** Equivalent to `Txn.retryFor(timeout, unit)`. */
- def retryFor(timeout: Long, unit: TimeUnit = TimeUnit.MILLISECONDS)(implicit txn: scala.concurrent.stm.InTxn) {
- scala.concurrent.stm.Txn.retryFor(timeout, unit)
- }
-
- /** This is the first half of the machinery for implementing `orAtomic`. */
- implicit def wrapChainedAtomic[A](lhs: => A) = new scala.concurrent.stm.PendingAtomicBlock(lhs)
-}
diff --git a/benchmarks/scala-stm/scala-stm-library/src/main/scala/scala/concurrent/stm/skel/AbstractInTxn.scala b/benchmarks/scala-stm/scala-stm-library/src/main/scala/scala/concurrent/stm/skel/AbstractInTxn.scala
deleted file mode 100644
index d3bcc27d..00000000
--- a/benchmarks/scala-stm/scala-stm-library/src/main/scala/scala/concurrent/stm/skel/AbstractInTxn.scala
+++ /dev/null
@@ -1,262 +0,0 @@
-/* scala-stm - (c) 2009-2012, Stanford University, PPL */
-
-package scala.concurrent.stm
-package skel
-
-import annotation.tailrec
-
-private[stm] trait AbstractInTxn extends InTxn {
- import Txn._
-
- /** This is different from `currentLevel` so that `InTxn` instances can
- * assume that the return value from `topLevel` is not exposed to the user.
- */
- protected def internalCurrentLevel: AbstractNestingLevel
-
- //////////// implementation of functionality for the InTxn implementer
-
- protected def requireActive() {
- internalCurrentLevel.status match {
- case Active =>
- case RolledBack(_) => throw RollbackError
- case s => throw new IllegalStateException(s.toString)
- }
- }
-
- protected def requireNotDecided() {
- internalCurrentLevel.status match {
- case s if !s.decided =>
- case RolledBack(_) => throw RollbackError
- case s => throw new IllegalStateException(s.toString)
- }
- }
-
- protected def requireNotCompleted() {
- internalCurrentLevel.status match {
- case s if !s.completed =>
- case RolledBack(_) => throw RollbackError
- case s => throw new IllegalStateException(s.toString)
- }
- }
-
- private var _decider: ExternalDecider = null
- protected def externalDecider = _decider
-
- /** Set to true if any callbacks are registered. */
- private var _callbacksPresent = false
-
- private val _beforeCommitList = new CallbackList[InTxn]
- private val _whileValidatingList = new CallbackList[NestingLevel]
- private val _whilePreparingList = new CallbackList[InTxnEnd]
- private val _whileCommittingList = new CallbackList[InTxnEnd]
- private val _afterCommitList = new CallbackList[Status]
- private val _afterRollbackList = new CallbackList[Status]
-
- /** Returns true if there are while-preparing handlers, while-committing
- * handlers, or an external decider.
- */
- protected def writeResourcesPresent: Boolean = _callbacksPresent && writeResourcesPresentImpl
-
- private def writeResourcesPresentImpl: Boolean = {
- !_whilePreparingList.isEmpty || !_whileCommittingList.isEmpty || externalDecider != null
- }
-
- protected def fireBeforeCommitCallbacks() {
- if (_callbacksPresent)
- _beforeCommitList.fire(internalCurrentLevel, this)
- }
-
- protected def fireWhilePreparingCallbacks() {
- if (_callbacksPresent && !_whilePreparingList.isEmpty)
- _whilePreparingList.fire(internalCurrentLevel, this)
- }
-
- protected def fireWhileCommittingCallbacks(exec: TxnExecutor): Throwable = {
- if (_callbacksPresent && !_whileCommittingList.isEmpty)
- fireWhileCommittingCallbacksImpl(exec)
- else
- null
- }
-
- private def fireWhileCommittingCallbacksImpl(exec: TxnExecutor): Throwable = {
- var failure: Throwable = null
- var i = 0
- while (i < _whileCommittingList.size) {
- failure = firePostDecision(_whileCommittingList(i), this, exec, Txn.Committing, failure)
- i += 1
- }
- failure
- }
-
- protected def fireAfterCompletionAndThrow(handlers: Array[Status => Unit], exec: TxnExecutor, s: Status, pendingFailure: Throwable) {
- val f = if (handlers != null) fireAfterCompletion(handlers, exec, s, pendingFailure) else pendingFailure
- if (f != null)
- throw f
- }
-
- protected def fireAfterCompletion(handlers: Array[Status => Unit], exec: TxnExecutor, s: Status, f0: Throwable): Throwable = {
- var failure = f0
- var i = 0
- val inOrder = s eq Committed
- var j = if (inOrder) 0 else handlers.length - 1
- var dj = if (inOrder) 1 else -1
- while (i < handlers.length) {
- failure = firePostDecision(handlers(j), s, exec, s, failure)
- i += 1
- j += dj
- }
- failure
- }
-
- private def firePostDecision[A](handler: A => Unit, arg: A, exec: TxnExecutor, s: Status, f: Throwable): Throwable = {
- try {
- handler(arg)
- f
- } catch {
- case x: Throwable => {
- try {
- exec.postDecisionFailureHandler(s, x)
- f
- } catch {
- case xx: Throwable => xx
- }
- }
- }
- }
-
- protected def checkpointCallbacks() {
- if (_callbacksPresent)
- checkpointCallbacksImpl()
- }
-
- private def checkpointCallbacksImpl() {
- val level = internalCurrentLevel
- level._beforeCommitSize = _beforeCommitList.size
- level._whileValidatingSize = _whileValidatingList.size
- level._whilePreparingSize = _whilePreparingList.size
- level._whileCommittingSize = _whileCommittingList.size
- level._afterCommitSize = _afterCommitList.size
- level._afterRollbackSize = _afterRollbackList.size
- }
-
- /** Returns the discarded `afterRollbackList` entries, or null if none */
- protected def rollbackCallbacks(): Array[Status => Unit] = {
- if (!_callbacksPresent) null else rollbackCallbacksImpl()
- }
-
- private def rollbackCallbacksImpl(): Array[Status => Unit] = {
- val level = internalCurrentLevel
- _beforeCommitList.size = level._beforeCommitSize
- _whileValidatingList.size = level._whileValidatingSize
- _whilePreparingList.size = level._whilePreparingSize
- _whileCommittingList.size = level._whileCommittingSize
- _afterCommitList.size = level._afterCommitSize
- _afterRollbackList.truncate(level._afterRollbackSize)
- }
-
- /** Returns the discarded `afterCommitList` entries, or null if none. */
- protected def resetCallbacks(): Array[Status => Unit] = {
- if (!_callbacksPresent) null else resetCallbacksImpl()
- }
-
- private def resetCallbacksImpl(): Array[Status => Unit] = {
- _beforeCommitList.size = 0
- _whileValidatingList.size = 0
- _whilePreparingList.size = 0
- _whileCommittingList.size = 0
- _afterRollbackList.size = 0
- _afterCommitList.truncate(0)
- }
-
- protected def fireWhileValidating() {
- val n = _whileValidatingList.size
- if (n > 0)
- fireWhileValidating(n - 1, internalCurrentLevel)
- }
-
- @tailrec private def fireWhileValidating(i: Int, level: AbstractNestingLevel) {
- if (i >= 0) {
- if (i < level._whileValidatingSize)
- fireWhileValidating(i, level.parLevel)
- else if (level.status.isInstanceOf[Txn.RolledBack])
- fireWhileValidating(level._whileValidatingSize - 1, level.parLevel) // skip the rest at this level
- else {
- try {
- _whileValidatingList(i)(level)
- } catch {
- case x: Throwable => level.requestRollback(UncaughtExceptionCause(x))
- }
- fireWhileValidating(i - 1, level)
- }
- }
- }
-
- //////////// implementation of functionality for the InTxn user
-
- override def rootLevel: AbstractNestingLevel = internalCurrentLevel.root
-
- def beforeCommit(handler: InTxn => Unit) {
- requireActive()
- _callbacksPresent = true
- _beforeCommitList += handler
- }
-
- def whileValidating(handler: NestingLevel => Unit) {
- requireActive()
- _callbacksPresent = true
- _whileValidatingList += handler
- }
-
- def whilePreparing(handler: InTxnEnd => Unit) {
- requireNotDecided()
- _callbacksPresent = true
- _whilePreparingList += handler
- }
-
- def whileCommitting(handler: InTxnEnd => Unit) {
- requireNotCompleted()
- _callbacksPresent = true
- _whileCommittingList += handler
- }
-
- def afterCommit(handler: Status => Unit) {
- requireNotCompleted()
- _callbacksPresent = true
- _afterCommitList += handler
- }
-
- def afterRollback(handler: Status => Unit) {
- try {
- requireNotCompleted()
- } catch {
- case RollbackError => {
- handler(internalCurrentLevel.status)
- throw RollbackError
- }
- }
- _callbacksPresent = true
- _afterRollbackList += handler
- }
-
- def afterCompletion(handler: Status => Unit) {
- afterRollback(handler)
- _afterCommitList += handler
- }
-
- def setExternalDecider(decider: ExternalDecider) {
- if (status.decided)
- throw new IllegalArgumentException("can't set ExternalDecider after decision, status = " + status)
-
- if (_decider != null) {
- if (_decider != decider)
- throw new IllegalArgumentException("can't set two different ExternalDecider-s in the same top-level atomic block")
- } else {
- _decider = decider
- // the decider should be unregistered after either rollback or commit
- afterCompletion { status =>
- assert(_decider eq decider)
- _decider = null
- }
- }
- }
-}
diff --git a/benchmarks/scala-stm/scala-stm-library/src/main/scala/scala/concurrent/stm/skel/AbstractNestingLevel.scala b/benchmarks/scala-stm/scala-stm-library/src/main/scala/scala/concurrent/stm/skel/AbstractNestingLevel.scala
deleted file mode 100644
index 85f0c5d4..00000000
--- a/benchmarks/scala-stm/scala-stm-library/src/main/scala/scala/concurrent/stm/skel/AbstractNestingLevel.scala
+++ /dev/null
@@ -1,21 +0,0 @@
-/* scala-stm - (c) 2009-2010, Stanford University, PPL */
-
-package scala.concurrent.stm
-package skel
-
-private[stm] trait AbstractNestingLevel extends NestingLevel {
- import Txn._
-
- def txn: AbstractInTxn
- def parLevel: AbstractNestingLevel
- override def root: AbstractNestingLevel
-
- def parent: Option[NestingLevel] = Option(parLevel)
-
- private[skel] var _beforeCommitSize = 0
- private[skel] var _whileValidatingSize = 0
- private[skel] var _whilePreparingSize = 0
- private[skel] var _whileCommittingSize = 0
- private[skel] var _afterCommitSize = 0
- private[skel] var _afterRollbackSize = 0
-}
diff --git a/benchmarks/scala-stm/scala-stm-library/src/main/scala/scala/concurrent/stm/skel/AtomicArray.scala b/benchmarks/scala-stm/scala-stm-library/src/main/scala/scala/concurrent/stm/skel/AtomicArray.scala
deleted file mode 100644
index d688afbe..00000000
--- a/benchmarks/scala-stm/scala-stm-library/src/main/scala/scala/concurrent/stm/skel/AtomicArray.scala
+++ /dev/null
@@ -1,272 +0,0 @@
-/* scala-stm - (c) 2009-2014, Stanford University, PPL */
-
-package scala.concurrent.stm.skel
-
-import scala.collection.generic.CanBuildFrom
-import scala.collection.mutable.{WrappedArray, Builder, ArrayLike, IndexedSeq}
-import java.util.concurrent.atomic._
-import annotation.tailrec
-
-
-/** `AtomicArray` implements a fixed-length indexed sequence where reads and
- * writes have volatile semantics. In addition, it adds an atomic swap
- * operation (`swap`) and an atomic compare-and-swap (`compareAndSet`).
- * The collection is backed by one of the Java atomic array classes, with the
- * best match chosen at construction time using a manifest.
- *
- * Instances of `AtomicArray[T]` are backed by `AtomicIntegerArray` if `T` is
- * a primitive of at most 32 bits (smaller values are padded rather than
- * packed). `AtomicArray[Long]` and `AtomicArray[Double]` are backed by
- * `AtomicLongArray`. All other instances of `AtomicArray[T]` are backed by
- * `AtomicReferenceArray` (except for `AtomicArray[Unit]`). Floats and
- * doubles are stored using their raw bit representation.
- *
- * This class is used in the implementation of the reference STM
- * implementation, but it is standalone and may be generally useful.
- *
- * @author Nathan Bronson
- */
-abstract class AtomicArray[T] extends IndexedSeq[T] with ArrayLike[T, AtomicArray[T]] {
-
- // We choose to store Boolean-s (and other small primitives) each in their
- // own Int. This wastes space. Another option would be to pack values into
- // the elements of the underlying AtomicIntegerArray. This would save space,
- // but would require a compareAndSet loop to implement update, which adds
- // complexity and would require some sort of back-off scheme to avoid
- // live-lock. A third option would be to use sun.misc.Unsafe directly, in
- // which case volatile reads and writes of byte-sized memory locations can be
- // performed directly. compareAndSet of bytes would have to be emulated by
- // integer-sized CAS.
-
- override protected[this] def thisCollection: AtomicArray[T] = this
- override protected[this] def toCollection(repr: AtomicArray[T]): AtomicArray[T] = repr
-
- /** The length of the array */
- def length: Int
-
- /** The element at given index, with volatile read semantics */
- def apply(index: Int): T
-
- /** Update element at given index, with volatile write semantics */
- def update(index: Int, elem: T)
-
- /** Atomic swap of the element at index */
- def swap(index: Int, elem: T): T
-
- /** Returns true iff previous value was expected, elem installed */
- def compareAndSet(index: Int, expected: T, elem: T): Boolean
-
- /** Retries compareAndSet until success, using f, then returns the old value */
- @tailrec
- final def getAndTransform(index: Int)(f: T => T): T = {
- val before = apply(index)
- if (compareAndSet(index, before, f(before))) before else getAndTransform(index)(f)
- }
-
- override def stringPrefix = "AtomicArray"
-
- /** Clones this object, including the underlying Array. */
- override def clone: AtomicArray[T] = {
- val b = newBuilder
- b.sizeHint(length)
- b ++= this
- b.result()
- }
-
- override def newBuilder: AtomicArrayBuilder[T] = throw new AbstractMethodError
-}
-
-object AtomicArray {
-
- def apply[T](size: Int)(implicit m: ClassManifest[T]): AtomicArray[T] = {
- (m.newArray(0).asInstanceOf[AnyRef] match {
- case x: Array[Boolean] => new ofBoolean(size)
- case x: Array[Byte] => new ofByte(size)
- case x: Array[Short] => new ofShort(size)
- case x: Array[Char] => new ofChar(size)
- case x: Array[Int] => new ofInt(size)
- case x: Array[Float] => new ofFloat(size)
- case x: Array[Long] => new ofLong(size)
- case x: Array[Double] => new ofDouble(size)
- case x: Array[Unit] => new ofUnit(size)
- case x: Array[AnyRef] => new ofRef[AnyRef](size)
- }).asInstanceOf[AtomicArray[T]]
- }
-
- def apply(elems: Array[Boolean]) = new ofBoolean(new AtomicIntegerArray(elems map {if(_) 1 else 0}))
- def apply(elems: Array[Byte]) = new ofByte( new AtomicIntegerArray(elems map {_.toInt}))
- def apply(elems: Array[Short]) = new ofShort( new AtomicIntegerArray(elems map {_.toInt}))
- def apply(elems: Array[Char]) = new ofChar( new AtomicIntegerArray(elems map {_.toInt}))
- def apply(elems: Array[Int]) = new ofInt( new AtomicIntegerArray(elems))
- def apply(elems: Array[Float]) = new ofFloat( new AtomicIntegerArray(elems map {java.lang.Float.floatToRawIntBits(_)}))
- def apply(elems: Array[Long]) = new ofLong( new AtomicLongArray(elems))
- def apply(elems: Array[Double]) = new ofDouble( new AtomicLongArray(elems map {java.lang.Double.doubleToRawLongBits(_)}))
- def apply(elems: Array[Unit]) = new ofUnit( elems.length)
- def apply[T <: AnyRef](elems: Array[T]) =
- new ofRef((new AtomicReferenceArray(elems.asInstanceOf[Array[AnyRef]])).asInstanceOf[AtomicReferenceArray[T]])
-
- def apply[T](elems: TraversableOnce[T])(implicit m: ClassManifest[T]): AtomicArray[T] = {
- val array: AnyRef = (elems match {
- case w: WrappedArray[_] => w.array // we're going to copy out regardless, no need to duplicate right now
- case _ => elems.toArray
- })
- val result = (array match {
- case x: Array[Boolean] => apply(x)
- case x: Array[Byte] => apply(x)
- case x: Array[Short] => apply(x)
- case x: Array[Char] => apply(x)
- case x: Array[Int] => apply(x)
- case x: Array[Float] => apply(x)
- case x: Array[Long] => apply(x)
- case x: Array[Double] => apply(x)
- case x: Array[Unit] => apply(x)
- case x: Array[AnyRef] => apply(x)
- })
- result.asInstanceOf[AtomicArray[T]]
- }
-
-
- implicit def canBuildFrom[T](implicit m: ClassManifest[T]): CanBuildFrom[AtomicArray[_], T, AtomicArray[T]] = {
- new CanBuildFrom[AtomicArray[_], T, AtomicArray[T]] {
- def apply(from: AtomicArray[_]): Builder[T, AtomicArray[T]] = {
- val b = AtomicArrayBuilder of m
- b.sizeHint(from.length)
- b
- }
- def apply(): Builder[T, AtomicArray[T]] = AtomicArrayBuilder of m
- }
- }
-
-
- final class ofBoolean(elems: AtomicIntegerArray) extends AtomicArray[Boolean] {
- def this(size: Int) = this(new AtomicIntegerArray(size))
-
- private def decode(v: Int) = v != 0
- private def encode(elem: Boolean) = if (elem) 1 else 0
-
- def length = elems.length
- def apply(index: Int) = decode(elems.get(index))
- def update(index: Int, elem: Boolean): Unit = elems.set(index, encode(elem))
- def swap(index: Int, elem: Boolean) = decode(elems.getAndSet(index, encode(elem)))
- def compareAndSet(index: Int, expected: Boolean, elem: Boolean) =
- elems.compareAndSet(index, encode(expected), encode(elem))
- override def newBuilder = new AtomicArrayBuilder.ofBoolean
- }
-
- final class ofByte(elems: AtomicIntegerArray) extends AtomicArray[Byte] {
- def this(size: Int) = this(new AtomicIntegerArray(size))
-
- def length = elems.length
- def apply(index: Int) = elems.get(index).toByte
- def update(index: Int, elem: Byte): Unit = elems.set(index, elem)
- def swap(index: Int, elem: Byte) = elems.getAndSet(index, elem).toByte
- def compareAndSet(index: Int, expected: Byte, elem: Byte) =
- elems.compareAndSet(index, expected, elem)
- override def newBuilder = new AtomicArrayBuilder.ofByte
- }
-
- final class ofShort(elems: AtomicIntegerArray) extends AtomicArray[Short] {
- def this(size: Int) = this(new AtomicIntegerArray(size))
-
- def length = elems.length
- def apply(index: Int) = elems.get(index).toShort
- def update(index: Int, elem: Short): Unit = elems.set(index, elem)
- def swap(index: Int, elem: Short) = elems.getAndSet(index, elem).toShort
- def compareAndSet(index: Int, expected: Short, elem: Short) =
- elems.compareAndSet(index, expected, elem)
- override def newBuilder = new AtomicArrayBuilder.ofShort
- }
-
- final class ofChar(elems: AtomicIntegerArray) extends AtomicArray[Char] {
- def this(size: Int) = this(new AtomicIntegerArray(size))
-
- def length = elems.length
- def apply(index: Int) = elems.get(index).toChar
- def update(index: Int, elem: Char): Unit = elems.set(index, elem)
- def swap(index: Int, elem: Char) = elems.getAndSet(index, elem).toChar
- def compareAndSet(index: Int, expected: Char, elem: Char) =
- elems.compareAndSet(index, expected, elem)
- override def newBuilder = new AtomicArrayBuilder.ofChar
- }
-
- final class ofInt(elems: AtomicIntegerArray) extends AtomicArray[Int] {
- def this(size: Int) = this(new AtomicIntegerArray(size))
-
- def length = elems.length
- def apply(index: Int) = elems.get(index)
- def update(index: Int, elem: Int): Unit = elems.set(index, elem)
- def swap(index: Int, elem: Int) = elems.getAndSet(index, elem)
- def compareAndSet(index: Int, expected: Int, elem: Int) =
- elems.compareAndSet(index, expected, elem)
- override def newBuilder = new AtomicArrayBuilder.ofInt
- }
-
- final class ofFloat(elems: AtomicIntegerArray) extends AtomicArray[Float] {
- def this(size: Int) = this(new AtomicIntegerArray(size))
-
- private def decode(v: Int) = java.lang.Float.intBitsToFloat(v)
- private def encode(elem: Float) = java.lang.Float.floatToRawIntBits(elem)
-
- def length = elems.length
- def apply(index: Int) = decode(elems.get(index))
- def update(index: Int, elem: Float): Unit = elems.set(index, encode(elem))
- def swap(index: Int, elem: Float) = decode(elems.getAndSet(index, encode(elem)))
- def compareAndSet(index: Int, expected: Float, elem: Float) =
- elems.compareAndSet(index, encode(expected), encode(elem))
- override def newBuilder = new AtomicArrayBuilder.ofFloat
- }
-
- final class ofLong(elems: AtomicLongArray) extends AtomicArray[Long] {
- def this(size: Int) = this(new AtomicLongArray(size))
-
- def length = elems.length
- def apply(index: Int) = elems.get(index)
- def update(index: Int, elem: Long): Unit = elems.set(index, elem)
- def swap(index: Int, elem: Long) = elems.getAndSet(index, elem)
- def compareAndSet(index: Int, expected: Long, elem: Long) =
- elems.compareAndSet(index, expected, elem)
- override def newBuilder = new AtomicArrayBuilder.ofLong
- }
-
- final class ofDouble(elems: AtomicLongArray) extends AtomicArray[Double] {
- def this(size: Int) = this(new AtomicLongArray(size))
-
- private def decode(v: Long) = java.lang.Double.longBitsToDouble(v)
- private def encode(elem: Double) = java.lang.Double.doubleToRawLongBits(elem)
-
- def length = elems.length
- def apply(index: Int) = decode(elems.get(index))
- def update(index: Int, elem: Double): Unit = elems.set(index, encode(elem))
- def swap(index: Int, elem: Double) = decode(elems.getAndSet(index, encode(elem)))
- def compareAndSet(index: Int, expected: Double, elem: Double) =
- elems.compareAndSet(index, encode(expected), encode(elem))
- override def newBuilder = new AtomicArrayBuilder.ofDouble
- }
-
- final class ofUnit(val length: Int) extends AtomicArray[Unit] {
- private val dummy = new AtomicReference[Unit](())
-
- private def ref(index: Int): AtomicReference[Unit] = {
- if (index < 0 || index >= length)
- throw new IndexOutOfBoundsException
- dummy
- }
-
- def apply(index: Int) = ref(index).get
- def update(index: Int, elem: Unit): Unit = ref(index).set(elem)
- def swap(index: Int, elem: Unit) = ref(index).getAndSet(elem)
- def compareAndSet(index: Int, expected: Unit, elem: Unit) = ref(index).compareAndSet(expected, elem)
- override def newBuilder = new AtomicArrayBuilder.ofUnit
- }
-
- final class ofRef[T <: AnyRef](elems: AtomicReferenceArray[T]) extends AtomicArray[T] {
- def this(size: Int) = this(new AtomicReferenceArray[T](size))
-
- def length = elems.length
- def apply(index: Int) = elems.get(index)
- def update(index: Int, elem: T): Unit = elems.set(index, elem)
- def swap(index: Int, elem: T) = elems.getAndSet(index, elem)
- def compareAndSet(index: Int, expected: T, elem: T) = elems.compareAndSet(index, expected, elem)
- override def newBuilder = new AtomicArrayBuilder.ofRef[T]
- }
-}
diff --git a/benchmarks/scala-stm/scala-stm-library/src/main/scala/scala/concurrent/stm/skel/AtomicArrayBuilder.scala b/benchmarks/scala-stm/scala-stm-library/src/main/scala/scala/concurrent/stm/skel/AtomicArrayBuilder.scala
deleted file mode 100644
index b3eedf1e..00000000
--- a/benchmarks/scala-stm/scala-stm-library/src/main/scala/scala/concurrent/stm/skel/AtomicArrayBuilder.scala
+++ /dev/null
@@ -1,240 +0,0 @@
-/* scala-stm - (c) 2009-2011, Stanford University, PPL */
-
-package scala.concurrent.stm.skel
-
-import scala.collection.mutable.Builder
-import java.util.concurrent.atomic.{AtomicReferenceArray, AtomicLongArray, AtomicIntegerArray}
-
-trait AtomicArrayBuilder[A] extends Builder[A, AtomicArray[A]]
-
-object AtomicArrayBuilder {
- def of[T](m: ClassManifest[T]): Builder[T, AtomicArray[T]] = {
- (m.newArray(0).asInstanceOf[AnyRef] match {
- case x: Array[Boolean] => new ofBoolean
- case x: Array[Byte] => new ofByte
- case x: Array[Short] => new ofShort
- case x: Array[Char] => new ofChar
- case x: Array[Int] => new ofInt
- case x: Array[Float] => new ofFloat
- case x: Array[Long] => new ofLong
- case x: Array[Double] => new ofDouble
- case x: Array[Unit] => new ofUnit
- case x: Array[AnyRef] => new ofRef[AnyRef]
- }).asInstanceOf[AtomicArrayBuilder[T]]
- }
-
- private val EmptyIntArray = new Array[Int](0)
- private val EmptyLongArray = new Array[Long](0)
- private val EmptyRefArray = new Array[AnyRef](0)
-
- abstract class IntBacked[T] extends AtomicArrayBuilder[T] {
- protected var elems = EmptyIntArray
- protected var size: Int = 0
-
- protected def setCapacity(newCap: Int) {
- if (newCap != elems.length) {
- val newElems = new Array[Int](newCap)
- if (size > 0) Array.copy(elems, 0, newElems, 0, size)
- elems = newElems
- }
- }
-
- override def sizeHint(sizeHint: Int) {
- if (elems.length < sizeHint) setCapacity(sizeHint)
- }
-
- protected def ensureSpace() {
- val cap = elems.length
- if (size == cap) setCapacity(if (cap == 0) 16 else cap * 2)
- }
-
- def clear() {
- size = 0
- }
- }
-
- abstract class LongBacked[T] extends AtomicArrayBuilder[T] {
- protected var elems = EmptyLongArray
- protected var size: Int = 0
-
- protected def setCapacity(newCap: Int) {
- if (newCap != elems.length) {
- val newElems = new Array[Long](newCap)
- if (size > 0) Array.copy(elems, 0, newElems, 0, size)
- elems = newElems
- }
- }
-
- override def sizeHint(sizeHint: Int) {
- if (elems.length < sizeHint) setCapacity(sizeHint)
- }
-
- protected def ensureSpace() {
- val cap = elems.length
- if (size == cap) setCapacity(if (cap == 0) 16 else cap * 2)
- }
-
- def clear() {
- size = 0
- }
- }
-
-
- class ofBoolean extends IntBacked[Boolean] {
- def +=(elem: Boolean): this.type = {
- ensureSpace()
- elems(size) = if (elem) 1 else 0
- size += 1
- this
- }
-
- def result(): AtomicArray[Boolean] = {
- setCapacity(size)
- new AtomicArray.ofBoolean(new AtomicIntegerArray(elems))
- }
- }
-
- class ofByte extends IntBacked[Byte] {
- def +=(elem: Byte): this.type = {
- ensureSpace()
- elems(size) = elem
- size += 1
- this
- }
-
- def result(): AtomicArray[Byte] = {
- setCapacity(size)
- new AtomicArray.ofByte(new AtomicIntegerArray(elems))
- }
- }
-
- class ofShort extends IntBacked[Short] {
- def +=(elem: Short): this.type = {
- ensureSpace()
- elems(size) = elem
- size += 1
- this
- }
-
- def result(): AtomicArray[Short] = {
- setCapacity(size)
- new AtomicArray.ofShort(new AtomicIntegerArray(elems))
- }
- }
-
- class ofChar extends IntBacked[Char] {
- def +=(elem: Char): this.type = {
- ensureSpace()
- elems(size) = elem
- size += 1
- this
- }
-
- def result(): AtomicArray[Char] = {
- setCapacity(size)
- new AtomicArray.ofChar(new AtomicIntegerArray(elems))
- }
- }
-
- class ofInt extends IntBacked[Int] {
- def +=(elem: Int): this.type = {
- ensureSpace()
- elems(size) = elem
- size += 1
- this
- }
-
- def result(): AtomicArray[Int] = {
- setCapacity(size)
- new AtomicArray.ofInt(new AtomicIntegerArray(elems))
- }
- }
-
- class ofFloat extends IntBacked[Float] {
- def +=(elem: Float): this.type = {
- ensureSpace()
- elems(size) = java.lang.Float.floatToRawIntBits(elem)
- size += 1
- this
- }
-
- def result(): AtomicArray[Float] = {
- setCapacity(size)
- new AtomicArray.ofFloat(new AtomicIntegerArray(elems))
- }
- }
-
- class ofLong extends LongBacked[Long] {
- def +=(elem: Long): this.type = {
- ensureSpace()
- elems(size) = elem
- size += 1
- this
- }
-
- def result(): AtomicArray[Long] = {
- setCapacity(size)
- new AtomicArray.ofLong(new AtomicLongArray(elems))
- }
- }
-
- class ofDouble extends LongBacked[Double] {
- def +=(elem: Double): this.type = {
- ensureSpace()
- elems(size) = java.lang.Double.doubleToRawLongBits(elem)
- size += 1
- this
- }
-
- def result(): AtomicArray[Double] = {
- setCapacity(size)
- new AtomicArray.ofDouble(new AtomicLongArray(elems))
- }
- }
-
- class ofUnit extends AtomicArrayBuilder[Unit] {
- protected var size = 0
-
- def clear(): Unit = { size = 0 }
- def +=(elem: Unit): this.type = { size += 1; this }
- def result(): AtomicArray[Unit] = new AtomicArray.ofUnit(size)
- }
-
- class ofRef[T <: AnyRef] extends AtomicArrayBuilder[T] {
- protected var elems = EmptyRefArray
- protected var size: Int = 0
-
- protected def setCapacity(newCap: Int) {
- if (newCap != elems.length) {
- val newElems = new Array[AnyRef](newCap)
- if (size > 0) Array.copy(elems, 0, newElems, 0, size)
- elems = newElems
- }
- }
-
- override def sizeHint(sizeHint: Int) {
- if (elems.length < sizeHint) setCapacity(sizeHint)
- }
-
- protected def ensureSpace() {
- val cap = elems.length
- if (size == cap) setCapacity(if (cap == 0) 16 else cap * 2)
- }
-
- def clear() {
- size = 0
- }
-
- def +=(elem: T): this.type = {
- ensureSpace()
- elems(size) = elem
- size += 1
- this
- }
-
- def result(): AtomicArray[T] = {
- setCapacity(size)
- new AtomicArray.ofRef(new AtomicReferenceArray[AnyRef](elems).asInstanceOf[AtomicReferenceArray[T]])
- }
- }
-}
diff --git a/benchmarks/scala-stm/scala-stm-library/src/main/scala/scala/concurrent/stm/skel/CallbackList.scala b/benchmarks/scala-stm/scala-stm-library/src/main/scala/scala/concurrent/stm/skel/CallbackList.scala
deleted file mode 100644
index 3bf48111..00000000
--- a/benchmarks/scala-stm/scala-stm-library/src/main/scala/scala/concurrent/stm/skel/CallbackList.scala
+++ /dev/null
@@ -1,96 +0,0 @@
-/* scala-stm - (c) 2009-2012, Stanford University, PPL */
-
-package scala.concurrent.stm
-package skel
-
-import annotation.tailrec
-
-
-private[stm] class CallbackList[A] {
-
- private final val InitialCapacity = 128
- private final val MaxEmptyCapacity = 8192
-
- private var _size = 0
- private var _data = new Array[A => Unit](InitialCapacity)
-
- def isEmpty: Boolean = _size == 0
-
- def size: Int = _size
-
- def size_= (newSize: Int) {
- if (newSize != _size)
- changeSize(newSize)
- }
-
- private def changeSize(newSize: Int) {
- if (newSize < 0 || newSize > _size)
- throw new IllegalArgumentException
-
- if (newSize == 0 && _data.length > MaxEmptyCapacity) {
- // reallocate if the array is too big, so that a single large txn doesn't
- // permanently increase the memory footprint of this thread
- reset()
- } else {
- java.util.Arrays.fill(_data.asInstanceOf[Array[AnyRef]], newSize, _size, null)
- _size = newSize
- }
- }
-
- private def reset() {
- _data = new Array[A => Unit](InitialCapacity)
- _size = 0
- }
-
- def += (handler: A => Unit) {
- if (_size == _data.length)
- grow
- _data(_size) = handler
- _size += 1
- }
-
- private def grow() {
- val a = new Array[A => Unit](_data.length * 2)
- System.arraycopy(_data, 0, a, 0, _data.length)
- _data = a
- }
-
- def apply(i: Int): (A => Unit) = _data(i)
-
- def fire(level: NestingLevel, arg: A) {
- if (_size > 0)
- fire(level, arg, 0)
- }
-
- @tailrec private def fire(level: NestingLevel, arg: A, i: Int) {
- if (i < _size && shouldFire(level)) {
- try {
- _data(i)(arg)
- } catch {
- case x: Throwable => {
- val s = level.requestRollback(Txn.UncaughtExceptionCause(x))
- assert(s.isInstanceOf[Txn.RolledBack])
- }
- }
- fire(level, arg, i + 1)
- }
- }
-
- private def shouldFire(level: NestingLevel): Boolean = !level.status.isInstanceOf[Txn.RolledBack]
-
- /** Sets the size of this callback list to `newSize`, and returns a the
- * discarded handlers.
- */
- def truncate(newSize: Int): Array[A => Unit] = {
- if (_size == newSize) {
- // nothing to do
- null
- } else {
- // copy
- val z = new Array[A => Unit](_size - newSize)
- System.arraycopy(_data, newSize, z, 0, z.length)
- size = newSize
- z
- }
- }
-}
diff --git a/benchmarks/scala-stm/scala-stm-library/src/main/scala/scala/concurrent/stm/skel/HashTrieTMap.scala b/benchmarks/scala-stm/scala-stm-library/src/main/scala/scala/concurrent/stm/skel/HashTrieTMap.scala
deleted file mode 100644
index b43ceac2..00000000
--- a/benchmarks/scala-stm/scala-stm-library/src/main/scala/scala/concurrent/stm/skel/HashTrieTMap.scala
+++ /dev/null
@@ -1,73 +0,0 @@
-/* scala-stm - (c) 2009-2011, Stanford University, PPL */
-
-package scala.concurrent.stm
-package skel
-
-import scala.collection.mutable.Builder
-
-private[stm] object HashTrieTMap {
-
- def empty[A, B]: TMap[A, B] = new HashTrieTMap(Ref(TxnHashTrie.emptyMapNode[A, B]).single)
-
- def newBuilder[A, B] = new Builder[(A, B), TMap[A, B]] {
- var root = TxnHashTrie.emptyMapBuildingNode[A, B]
-
- def clear() { root = TxnHashTrie.emptyMapBuildingNode[A, B] }
-
- def += (kv: (A, B)): this.type = { root = TxnHashTrie.buildingPut(root, kv._1, kv._2) ; this }
-
- def result(): TMap[A, B] = {
- val r = root
- root = null
- new HashTrieTMap(Ref(r.endBuild).single)
- }
- }
-}
-
-private[skel] class HashTrieTMap[A, B] private (root0: Ref.View[TxnHashTrie.Node[A, B]]
- ) extends TxnHashTrie[A, B](root0) with TMapViaClone[A, B] {
-
- //// construction
-
- override def empty: TMap.View[A, B] = new HashTrieTMap(Ref(TxnHashTrie.emptyMapNode[A, B]).single)
- override def clone(): HashTrieTMap[A, B] = new HashTrieTMap(cloneRoot)
-
- //// TMap.View aggregates
-
- override def isEmpty: Boolean = singleIsEmpty
- override def size: Int = singleSize
- override def iterator: Iterator[(A, B)] = mapIterator
- override def keysIterator: Iterator[A] = mapKeyIterator
- override def valuesIterator: Iterator[B] = mapValueIterator
- override def foreach[U](f: ((A, B)) => U) { singleMapForeach(f) }
-
- override def clear() { root() = TxnHashTrie.emptyMapNode[A, B] }
-
- //// TMap.View per-element
-
- override def contains(key: A): Boolean = singleContains(key)
- override def apply(key: A): B = singleGetOrThrow(key)
- def get(key: A): Option[B] = singleGet(key)
-
- override def put(key: A, value: B): Option[B] = singlePut(key, value)
- override def update(key: A, value: B) { singlePut(key, value) }
- override def += (kv: (A, B)): this.type = { singlePut(kv._1, kv._2) ; this }
-
- override def remove(key: A): Option[B] = singleRemove(key)
- override def -= (key: A): this.type = { singleRemove(key) ; this }
-
- //// optimized TMap versions
-
- def isEmpty(implicit txn: InTxn): Boolean = txnIsEmpty
- def size(implicit txn: InTxn): Int = singleSize
- def foreach[U](f: ((A, B)) => U)(implicit txn: InTxn) = txnMapForeach(f)
-
- def contains(key: A)(implicit txn: InTxn): Boolean = txnContains(key)
- def apply(key: A)(implicit txn: InTxn): B = txnGetOrThrow(key)
- def get(key: A)(implicit txn: InTxn): Option[B] = txnGet(key)
- def put(key: A, value: B)(implicit txn: InTxn): Option[B] = txnPut(key, value)
- def remove(key: A)(implicit txn: InTxn): Option[B] = txnRemove(key)
-
- def transform(f: (A, B) => B)(implicit txn: InTxn): this.type = { single transform f ; this }
- def retain(p: (A, B) => Boolean)(implicit txn: InTxn): this.type = { single retain p ; this }
-}
diff --git a/benchmarks/scala-stm/scala-stm-library/src/main/scala/scala/concurrent/stm/skel/HashTrieTSet.scala b/benchmarks/scala-stm/scala-stm-library/src/main/scala/scala/concurrent/stm/skel/HashTrieTSet.scala
deleted file mode 100644
index d54668b7..00000000
--- a/benchmarks/scala-stm/scala-stm-library/src/main/scala/scala/concurrent/stm/skel/HashTrieTSet.scala
+++ /dev/null
@@ -1,64 +0,0 @@
-/* scala-stm - (c) 2009-2010, Stanford University, PPL */
-
-package scala.concurrent.stm
-package skel
-
-import scala.collection.mutable.Builder
-
-private[stm] object HashTrieTSet {
-
- def empty[A]: TSet[A] = new HashTrieTSet(Ref(TxnHashTrie.emptySetNode[A]).single)
-
- def newBuilder[A] = new Builder[A, TSet[A]] {
- var root = TxnHashTrie.emptySetBuildingNode[A]
-
- def clear() { root = TxnHashTrie.emptySetBuildingNode[A] }
-
- def += (elem: A): this.type = { root = TxnHashTrie.buildingAdd(root, elem) ; this }
-
- def result(): TSet[A] = {
- val r = root
- root = null
- new HashTrieTSet(Ref(r.endBuild).single)
- }
- }
-}
-
-private[skel] class HashTrieTSet[A] private (root0: Ref.View[TxnHashTrie.SetNode[A]]
- ) extends TxnHashTrie[A, AnyRef](root0) with TSetViaClone[A] {
-
- //// construction
-
- override def empty: TSet.View[A] = new HashTrieTSet(Ref(TxnHashTrie.emptySetNode[A]).single)
- override def clone(): HashTrieTSet[A] = new HashTrieTSet(cloneRoot)
-
- //// TSet.View aggregates
-
- override def isEmpty: Boolean = singleIsEmpty
- override def size: Int = singleSize
- override def iterator: Iterator[A] = setIterator
- override def foreach[U](f: A => U) { singleSetForeach(f) }
- override def clear() { root() = TxnHashTrie.emptySetNode[A] }
-
- //// TSet.View per-element
-
- def contains(elem: A): Boolean = singleContains(elem)
-
- override def add(elem: A): Boolean = singlePut(elem, null).isEmpty
- def += (elem: A): this.type = { singlePut(elem, null) ; this }
-
- override def remove(elem: A): Boolean = !singleRemove(elem).isEmpty
- def -= (elem: A): this.type = { singleRemove(elem) ; this }
-
- //// optimized TSet versions
-
- def isEmpty(implicit txn: InTxn): Boolean = txnIsEmpty
- def size(implicit txn: InTxn): Int = singleSize
- def foreach[U](f: A => U)(implicit txn: InTxn) { txnSetForeach(f) }
-
- def contains(elem: A)(implicit txn: InTxn): Boolean = txnContains(elem)
- def add(elem: A)(implicit txn: InTxn): Boolean = txnPut(elem, null ).isEmpty
- def remove(elem: A)(implicit txn: InTxn): Boolean = !txnRemove(elem).isEmpty
-
- def retain(p: (A) => Boolean)(implicit txn: InTxn): this.type = { single retain p ; this }
-}
diff --git a/benchmarks/scala-stm/scala-stm-library/src/main/scala/scala/concurrent/stm/skel/RollbackError.scala b/benchmarks/scala-stm/scala-stm-library/src/main/scala/scala/concurrent/stm/skel/RollbackError.scala
deleted file mode 100644
index 91b70f1a..00000000
--- a/benchmarks/scala-stm/scala-stm-library/src/main/scala/scala/concurrent/stm/skel/RollbackError.scala
+++ /dev/null
@@ -1,16 +0,0 @@
-/* scala-stm - (c) 2009-2010, Stanford University, PPL */
-
-package scala.concurrent.stm.skel
-
-import util.control.ControlThrowable
-
-
-/** A reusable exception instance, thrown by CCSTM when a transaction is doomed
- * and should not continue executing. User code should either rethrow this
- * exception or not catch it.
- *
- * @author Nathan Bronson
- */
-private[stm] object RollbackError extends Error with ControlThrowable {
- override def fillInStackTrace(): Throwable = this
-}
diff --git a/benchmarks/scala-stm/scala-stm-library/src/main/scala/scala/concurrent/stm/skel/SimpleRandom.scala b/benchmarks/scala-stm/scala-stm-library/src/main/scala/scala/concurrent/stm/skel/SimpleRandom.scala
deleted file mode 100644
index 4c66d4c8..00000000
--- a/benchmarks/scala-stm/scala-stm-library/src/main/scala/scala/concurrent/stm/skel/SimpleRandom.scala
+++ /dev/null
@@ -1,120 +0,0 @@
-/* scala-stm - (c) 2009-2011, Stanford University, PPL */
-
-package scala.concurrent.stm.skel
-
-
-/** A random number generator that focuses on speed and lack of inter-thread
- * interference, rather than on the quality of the numbers returned. The
- * `object SimpleRandom` is striped internally to reduce
- * contention when accessed from multiple threads. The `class
- * SimpleRandom` should only be used by a single thread.
- *
- * The constants in this 64-bit linear congruential random number generator
- * are from http://nuclear.llnl.gov/CNP/rng/rngman/node4.html.
- *
- * @author Nathan Bronson
- */
-object SimpleRandom {
- // 64 byte cache lines are typical, so there are 8 slots per cache line.
- // This means that the probability that any two threads have false sharing is
- // p = 8 / #slots. If there are n processors, each of which is running 1
- // thread, then the probability that no other threads have false sharing with
- // the current thread is (1-p)^(n-1). If p is small, that is about
- // 1 - (n-1)p, which is pretty close to 1 - np. If we want the probability
- // of false conflict for a thread to be less than k, then we need np < k, or
- // p < k/n, or 8/Slots < k/n, or #slots > 8n/k. If we let k = 1/8, then we
- // get #slots=64*n.
- private val mask = {
- val min = 64 * Runtime.getRuntime.availableProcessors
- var slots = 1
- while (slots < min) slots *= 2
- slots - 1
- }
-
- private val states = Array.tabulate(mask + 1)({ _ * 0x123456789abcdefL })
-
- /** Returns a random value chosen from a uniform distribution of all valid
- * `Int`s.
- */
- def nextInt(): Int = {
- val id = (Thread.currentThread.getId.asInstanceOf[Int] * 13) & mask
-
- val next = step(states(id))
- states(id) = next
-
- extract(next)
- }
-
- /** Returns a random value chosen from a uniform distribution of the
- * non-negative integers less than `n`, or throws `IllegalArgumentException`
- * if `n` is negative or zero.
- */
- def nextInt(n: Int): Int = {
- if (n <= 0)
- throw new IllegalArgumentException
-
- var x = -1
- while (x == -1) x = tryClamp(nextInt(), n)
- x
- }
-
- private def step(x: Long) = x * 2862933555777941757L + 3037000493L
-
- private def extract(x: Long) = (x >> 30).asInstanceOf[Int]
-
- /** r is the random, returns -1 on failure. */
- private def tryClamp(r: Int, n: Int): Int = {
- // get a positive number
- val x = r & Int.MaxValue
-
- if ((n & -n) == n) {
- // for powers of two, we use high bits instead of low bits
- ((x.toLong * n) >> 31).toInt
- } else {
- val z = x % n
- if (x - z + (n - 1) < 0) {
- // x is bigger than floor(MAX_INT/n)*n, so we are not getting an even
- // distribution. Try again.
- -1
- } else {
- z
- }
- }
- }
-}
-
-/** An clonable unsynchronized random number generator that uses the same
- * algorithm as the concurrent `object SimpleRandom`. The caller must ensure
- * that each `SimpleRandom` instance is used from only one thread at a time.
- *
- * @author Nathan Bronson
- */
-class SimpleRandom private (private var _state: Long, dummy: Boolean) {
- import SimpleRandom._
-
- def this(seed: Int) = this(SimpleRandom.step(SimpleRandom.step(seed)), false)
- def this() = this(System.identityHashCode(Thread.currentThread))
-
- override def clone = new SimpleRandom(_state, false)
-
- /** Returns a random value chosen from a uniform distribution of all valid
- * `Int`s.
- */
- def nextInt(): Int = {
- _state = step(_state)
- extract(_state)
- }
-
- /** Returns a random value chosen from a uniform distribution of the
- * non-negative integers less than `n`, or throws `IllegalArgumentException`
- * if `n` is negative or zero.
- */
- def nextInt(n: Int): Int = {
- if (n <= 0)
- throw new IllegalArgumentException
-
- var x = -1
- while (x == -1) x = tryClamp(nextInt(), n)
- x
- }
-}
diff --git a/benchmarks/scala-stm/scala-stm-library/src/main/scala/scala/concurrent/stm/skel/StubInTxn.scala b/benchmarks/scala-stm/scala-stm-library/src/main/scala/scala/concurrent/stm/skel/StubInTxn.scala
deleted file mode 100644
index 5565ec24..00000000
--- a/benchmarks/scala-stm/scala-stm-library/src/main/scala/scala/concurrent/stm/skel/StubInTxn.scala
+++ /dev/null
@@ -1,23 +0,0 @@
-/* scala-stm - (c) 2009-2011, Stanford University, PPL */
-
-package scala.concurrent.stm
-package skel
-
-class StubInTxn extends InTxn {
- import concurrent.stm.Txn._
-
- def executor: TxnExecutor = throw new AbstractMethodError
- def status: Status = throw new AbstractMethodError
- def rootLevel: NestingLevel = throw new AbstractMethodError
- def currentLevel: NestingLevel = throw new AbstractMethodError
- def rollback(cause: RollbackCause): Nothing = throw new AbstractMethodError
- def retry(): Nothing = throw new AbstractMethodError
- def retryFor(timeoutNanos: Long) { throw new AbstractMethodError }
- def beforeCommit(handler: InTxn => Unit) = throw new AbstractMethodError
- def whilePreparing(handler: InTxnEnd => Unit) = throw new AbstractMethodError
- def whileCommitting(handler: InTxnEnd => Unit) = throw new AbstractMethodError
- def afterCommit(handler: Status => Unit) = throw new AbstractMethodError
- def afterRollback(handler: Status => Unit) = throw new AbstractMethodError
- def afterCompletion(handler: Status => Unit) = throw new AbstractMethodError
- def setExternalDecider(decider: ExternalDecider) = throw new AbstractMethodError
-}
diff --git a/benchmarks/scala-stm/scala-stm-library/src/main/scala/scala/concurrent/stm/skel/StubSTMImpl.scala b/benchmarks/scala-stm/scala-stm-library/src/main/scala/scala/concurrent/stm/skel/StubSTMImpl.scala
deleted file mode 100644
index 5683e95e..00000000
--- a/benchmarks/scala-stm/scala-stm-library/src/main/scala/scala/concurrent/stm/skel/StubSTMImpl.scala
+++ /dev/null
@@ -1,66 +0,0 @@
-/* scala-stm - (c) 2009-2012, Stanford University, PPL */
-
-package scala.concurrent.stm
-package skel
-
-import java.lang.Throwable
-import scala.collection.mutable.Builder
-import java.util.concurrent.TimeUnit
-
-class StubSTMImpl extends impl.STMImpl {
-
- //////// RefFactory
-
- def newRef(v0: Boolean): Ref[Boolean] = throw new AbstractMethodError
- def newRef(v0: Byte): Ref[Byte] = throw new AbstractMethodError
- def newRef(v0: Short): Ref[Short] = throw new AbstractMethodError
- def newRef(v0: Char): Ref[Char] = throw new AbstractMethodError
- def newRef(v0: Int): Ref[Int] = throw new AbstractMethodError
- def newRef(v0: Float): Ref[Float] = throw new AbstractMethodError
- def newRef(v0: Long): Ref[Long] = throw new AbstractMethodError
- def newRef(v0: Double): Ref[Double] = throw new AbstractMethodError
- def newRef(v0: Unit): Ref[Unit] = throw new AbstractMethodError
- def newRef[A : ClassManifest](v0: A): Ref[A] = throw new AbstractMethodError
-
- def newTxnLocal[A](init: => A,
- initialValue: InTxn => A,
- beforeCommit: InTxn => Unit,
- whilePreparing: InTxnEnd => Unit,
- whileCommitting: InTxnEnd => Unit,
- afterCommit: A => Unit,
- afterRollback: Txn.Status => Unit,
- afterCompletion: Txn.Status => Unit): TxnLocal[A] = throw new AbstractMethodError
-
- def newTArray[A : ClassManifest](length: Int): TArray[A] = throw new AbstractMethodError
- def newTArray[A : ClassManifest](xs: TraversableOnce[A]): TArray[A] = throw new AbstractMethodError
-
- def newTMap[A, B]: TMap[A, B] = throw new AbstractMethodError
- def newTMapBuilder[A, B]: Builder[(A, B), TMap[A, B]] = throw new AbstractMethodError
-
- def newTSet[A]: TSet[A] = throw new AbstractMethodError
- def newTSetBuilder[A]: Builder[A, TSet[A]] = throw new AbstractMethodError
-
- //////// TxnContext
-
- def findCurrent(implicit mt: MaybeTxn): Option[InTxn] = throw new AbstractMethodError
- def dynCurrentOrNull: InTxn = throw new AbstractMethodError
-
- //////// TxnExecutor
-
- def apply[Z](block: InTxn => Z)(implicit mt: MaybeTxn): Z = throw new AbstractMethodError
- def oneOf[Z](blocks: (InTxn => Z)*)(implicit mt: MaybeTxn): Z = throw new AbstractMethodError
- def unrecorded[Z](block: InTxn => Z, outerFailure: Txn.RollbackCause => Z)(implicit mt: MaybeTxn): Z = throw new AbstractMethodError
- def pushAlternative[Z](mt: MaybeTxn, block: InTxn => Z): Boolean = throw new AbstractMethodError
- def compareAndSet[A, B](a: Ref[A], a0: A, a1: A, b: Ref[B], b0: B, b1: B): Boolean = throw new AbstractMethodError
- def compareAndSetIdentity[A <: AnyRef, B <: AnyRef](a: Ref[A], a0: A, a1: A, b: Ref[B], b0: B, b1: B): Boolean = throw new AbstractMethodError
- def retryTimeoutNanos: Option[Long] = throw new AbstractMethodError
- def withRetryTimeoutNanos(timeout: Option[Long]): TxnExecutor = throw new AbstractMethodError
- def isControlFlow(x: Throwable): Boolean = throw new AbstractMethodError
- def withControlFlowRecognizer(pf: PartialFunction[Throwable, Boolean]): TxnExecutor = throw new AbstractMethodError
- def postDecisionFailureHandler: (Txn.Status, Throwable) => Unit = throw new AbstractMethodError
- def withPostDecisionFailureHandler(handler: (Txn.Status, Throwable) => Unit): TxnExecutor = throw new AbstractMethodError
-
- //////// STMImpl
-
- def newCommitBarrier(timeout: Long, unit: TimeUnit): CommitBarrier = throw new AbstractMethodError
-}
diff --git a/benchmarks/scala-stm/scala-stm-library/src/main/scala/scala/concurrent/stm/skel/TMapViaClone.scala b/benchmarks/scala-stm/scala-stm-library/src/main/scala/scala/concurrent/stm/skel/TMapViaClone.scala
deleted file mode 100644
index 63a15636..00000000
--- a/benchmarks/scala-stm/scala-stm-library/src/main/scala/scala/concurrent/stm/skel/TMapViaClone.scala
+++ /dev/null
@@ -1,87 +0,0 @@
-/* scala-stm - (c) 2009-2012, Stanford University, PPL */
-
-package scala.concurrent.stm
-package skel
-
-import scala.collection.{immutable, mutable}
-
-private[stm] object TMapViaClone {
- class FrozenMutableMap[A, B](self: mutable.Map[A, B]) extends immutable.Map[A, B] {
- override def isEmpty: Boolean = self.isEmpty
- override def size: Int = self.size
- def get(key: A): Option[B] = self.get(key)
- def iterator: Iterator[(A, B)] = self.iterator
- override def foreach[U](f: ((A, B)) => U) { self foreach f }
- def + [B1 >: B](kv: (A, B1)): immutable.Map[A, B1] =
- new FrozenMutableMap(self.clone().asInstanceOf[mutable.Map[A, B1]] += kv)
- def - (k: A): immutable.Map[A, B] = new FrozenMutableMap(self.clone() -= k)
- }
-}
-
-/** Provides an implementation for the bulk of the functionality of `TMap` and
- * `TMap.View` by making extensive use of `clone()`. Assumes that the
- * underlying implementation of `clone()` is O(1).
- *
- * @author Nathan Bronson
- */
-private[stm] trait TMapViaClone[A, B] extends TMap.View[A, B] with TMap[A, B] {
- import TMapViaClone._
-
- // Implementations may be able to do better.
- override def snapshot: immutable.Map[A, B] = new FrozenMutableMap(clone())
-
- def tmap: TMap[A, B] = this
- def single: TMap.View[A, B] = this
-
- /** Something like `"TMap[size=1]((1 -> 10))"`, stopping after 1K chars */
- def dbgStr: String = atomic.unrecorded({ txn =>
- mkStringPrefix("TMap", single.view.map { kv => kv._1 + " -> " + kv._2 })
- }, { _.toString })
-
- /** Returns an array of key/value pairs, since that is likely to be the
- * easiest to examine in a debugger. Also, this avoids problems with
- * relying on copy-on-write after discarding `Ref` writes.
- */
- def dbgValue: Any = atomic.unrecorded({ _ => toArray }, { x => x })
-
- //////////// builder functionality (from mutable.MapLike via TMap.View)
-
- override protected[this] def newBuilder: TMap.View[A, B] = empty
-
- override def result(): TMap.View[A, B] = this
-
-
- //////////// construction of new TMaps
-
- // A cheap clone means that mutable.MapLike's implementations of +, ++,
- // -, and -- are all pretty reasonable.
-
- override def clone: TMap.View[A, B]
-
- //////////// atomic compound ops
-
- override def getOrElseUpdate(key: A, op: => B): B = {
- single.get(key) getOrElse {
- atomic { implicit txn =>
- tmap.get(key) getOrElse { val v = op ; tmap.put(key, v) ; v }
- }
- }
- }
-
- override def transform(f: (A, B) => B): this.type = {
- atomic { implicit txn =>
- for (kv <- tmap)
- tmap.update(kv._1, f(kv._1, kv._2))
- }
- this
- }
-
- override def retain(p: (A, B) => Boolean): this.type = {
- atomic { implicit txn =>
- for (kv <- tmap)
- if (!p(kv._1, kv._2))
- tmap -= kv._1
- }
- this
- }
-}
diff --git a/benchmarks/scala-stm/scala-stm-library/src/main/scala/scala/concurrent/stm/skel/TSetViaClone.scala b/benchmarks/scala-stm/scala-stm-library/src/main/scala/scala/concurrent/stm/skel/TSetViaClone.scala
deleted file mode 100644
index 2178aaf0..00000000
--- a/benchmarks/scala-stm/scala-stm-library/src/main/scala/scala/concurrent/stm/skel/TSetViaClone.scala
+++ /dev/null
@@ -1,67 +0,0 @@
-/* scala-stm - (c) 2009-2012, Stanford University, PPL */
-
-package scala.concurrent.stm
-package skel
-
-import scala.collection.{immutable, mutable}
-
-private[stm] object TSetViaClone {
- class FrozenMutableSet[A](self: mutable.Set[A]) extends immutable.Set[A] {
- override def isEmpty: Boolean = self.isEmpty
- override def size: Int = self.size
- def contains(key: A): Boolean = self.contains(key)
- def iterator: Iterator[(A)] = self.iterator
- override def foreach[U](f: A => U) { self foreach f }
- def + (x: A): immutable.Set[A] = new FrozenMutableSet(self.clone() += x)
- def - (x: A): immutable.Set[A] = new FrozenMutableSet(self.clone() -= x)
- }
-}
-
-/** Provides an implementation for the bulk of the functionality of `TSet` and
- * `TSet.View` by making extensive use of `clone()`. Assumes that the
- * underlying implementation of `clone()` is O(1).
- *
- * @author Nathan Bronson
- */
-private[stm] trait TSetViaClone[A] extends TSet.View[A] with TSet[A] {
- import TSetViaClone._
-
- // Implementations may be able to do better.
- override def snapshot: immutable.Set[A] = new FrozenMutableSet(clone())
-
- def tset: TSet[A] = this
- def single: TSet.View[A] = this
-
- /** Something like `"TSet[size=3](3, 1, 10)"`, stopping after 1K chars */
- def dbgStr: String = atomic.unrecorded({ _ => mkStringPrefix("TSet", single) }, { _.toString })
-
- /** Returns an array of elements, since that is likely to be the
- * easiest to examine in a debugger. Also, this avoids problems with
- * relying on copy-on-write after discarding `Ref` writes.
- */
- def dbgValue: Any = atomic.unrecorded({ _ => toArray[Any] }, { x => x })
-
- //////////// builder functionality (from mutable.SetLike via TSet.View)
-
- override protected[this] def newBuilder: TSet.View[A] = empty
-
- override def result(): TSet.View[A] = this
-
-
- //////////// construction of new TSets
-
- // A cheap clone() means that mutable.SetLike's implementations of +, ++,
- // -, and -- are all pretty reasonable.
-
- override def clone: TSet.View[A]
-
- //////////// atomic compound ops
-
- override def retain(p: A => Boolean) {
- atomic { implicit txn =>
- for (x <- tset)
- if (!p(x))
- tset -= x
- }
- }
-}
diff --git a/benchmarks/scala-stm/scala-stm-library/src/main/scala/scala/concurrent/stm/skel/TxnHashTrie.scala b/benchmarks/scala-stm/scala-stm-library/src/main/scala/scala/concurrent/stm/skel/TxnHashTrie.scala
deleted file mode 100644
index 12fc7cf1..00000000
--- a/benchmarks/scala-stm/scala-stm-library/src/main/scala/scala/concurrent/stm/skel/TxnHashTrie.scala
+++ /dev/null
@@ -1,840 +0,0 @@
-/* scala-stm - (c) 2009-2011, Stanford University, PPL */
-
-package scala.concurrent.stm
-package skel
-
-import annotation.tailrec
-
-/** `TxnHashTrie` implements a transactional mutable hash trie using Ref-s,
- * with lazy cloning to allow efficient snapshots. Fundamental operations are
- * provided for hash tries representing either sets or maps, both of which are
- * represented as a Ref.View[Node[A, B]]. If the initial empty leaf is
- * `emptySetValue` then no values can be stored in the hash trie, and
- * operations that take or return values will expect and produce null.
- *
- * @author Nathan Bronson
- */
-private[skel] object TxnHashTrie {
-
- final val LogBF = 4
- final val BF = 16
-
- // It would seem that the leaf copying is inefficient when compared to a tree
- // that allows more sharing, but a back-of-the-envelope calculation indicates
- // that the crossover point for the total bytes allocates to construct an
- // immutable node holding N elements is about 12. Even at N=32 the total
- // bytes required by this Leaf implementation is only about 2/3 more than an
- // ideal balanced tree, and those bytes are accessed in a more cache friendly
- // fashion.
- final val MaxLeafCapacity = 14
-
- def keyHash[A](key: A): Int = if (key == null) 0 else mixBits(key.##)
-
- def mixBits(h: Int) = {
- // make sure any bit change results in a change in the bottom LogBF bits
- val s = LogBF
- val x = h ^ (h >>> (s * 3)) ^ (h >>> (s * 6))
- x ^ (x >>> s) ^ (x >>> (s * 2))
- }
-
- def indexFor(shift: Int, hash: Int) = (hash >>> shift) & (BF - 1)
-
- //////// shared instances
-
- val emptyLeaf = new Leaf[Any, Unit](Array.empty[Int], Array.empty[AnyRef])
-
- //////// publicly-visible stuff
-
- sealed abstract class Node[A, B] {
- def cappedSize(cap: Int): Int
- def txnIsEmpty(implicit txn: InTxn): Boolean
- def keyForeach[U](f: A => U)
- def mapForeach[U](f: ((A, B)) => U)
- def keyIterator: Iterator[A]
- def valueIterator: Iterator[B]
- def mapIterator: Iterator[(A, B)]
- }
-
- sealed trait BuildingNode[A, B] {
- def endBuild: Node[A, B]
- }
-
- type SetNode[A] = Node[A, AnyRef]
- type SetBuildingNode[A] = BuildingNode[A, AnyRef]
-
- /** If used by a Set, values will be null. */
- final class Leaf[A, B](val hashes: Array[Int],
- val kvs: Array[AnyRef]) extends Node[A, B] with BuildingNode[A, B] {
-
- def endBuild = this
-
- def cappedSize(cap: Int): Int = hashes.length
- def txnIsEmpty(implicit txn: InTxn) = hashes.length == 0
-
- def getKey(i: Int): A = kvs(2 * i).asInstanceOf[A]
- def setKey(i: Int, k: A) { kvs(2 * i) = k.asInstanceOf[AnyRef] }
-
- def getValue(i: Int): B = kvs(2 * i + 1).asInstanceOf[B]
- def setValue(i: Int, v: B) { kvs(2 * i + 1) = v.asInstanceOf[AnyRef] }
-
- def getKeyValue(i: Int): (A, B) = (getKey(i), getValue(i))
-
- def contains(hash: Int, key: A): Boolean = find(hash, key) >= 0
-
- def get(hash: Int, key: A): Option[B] = {
- val i = find(hash, key)
- if (i < 0)
- None
- else
- Some(getValue(i))
- }
-
- def get(i: Int): Option[B] = {
- if (i < 0)
- None
- else
- Some(getValue(i))
- }
-
- def find(hash: Int, key: A): Int = {
- var i = hashes.length
- while (i > 0) {
- i -= 1
- val h = hashes(i)
- if (h == hash && keyEqual(key.asInstanceOf[AnyRef], kvs(2 * i)))
- return i
- if (h < hash)
- return ~(i + 1)
- }
- return ~0
- }
-
- private def keyEqual(lhs: AnyRef, rhs: AnyRef): Boolean = {
- if (lhs eq rhs)
- true
- else if (lhs == null || rhs == null)
- false
- else if (lhs.getClass eq rhs.getClass) {
- if (lhs.isInstanceOf[java.lang.Integer])
- true // we know the hashes match, and hashCode() = value for ints
- else if (lhs.isInstanceOf[java.lang.Long])
- lhs.asInstanceOf[java.lang.Long].longValue == rhs.asInstanceOf[java.lang.Long].longValue
- else
- lhs.equals(rhs)
- } else
- runtime.BoxesRunTime.equals2(lhs, rhs)
- }
-
- def noChange[B](i: Int, value: B): Boolean = {
- i >= 0 && (kvs(2 * i + 1) eq value.asInstanceOf[AnyRef])
- }
-
- def withPut(gen: Long, shift: Int, hash: Int, key: A, value: B, i: Int, contended: Boolean): Node[A, B] = {
- if (i < 0)
- withInsert(~i, hash, key, value).splitIfNeeded(gen, shift, contended: Boolean)
- else
- withUpdate(i, value)
- }
-
- def withBuildingPut(shift: Int, hash: Int, key: A, value: B, i: Int): BuildingNode[A, B] = {
- if (i < 0)
- withInsert(~i, hash, key, value).buildingSplitIfNeeded(shift)
- else
- withUpdate(i, value)
- }
-
- private def withUpdate(i: Int, value: B): Leaf[A, B] = {
- // reuse hashes
- val nkvs = kvs.clone
- nkvs(2 * i + 1) = value.asInstanceOf[AnyRef]
- new Leaf[A, B](hashes, nkvs)
- }
-
- private def withInsert(i: Int, hash: Int, key: A, value: B): Leaf[A, B] = {
- val z = newLeaf(hashes.length + 1)
- val j = hashes.length - i
-
- System.arraycopy(hashes, 0, z.hashes, 0, i)
- System.arraycopy(hashes, i, z.hashes, i + 1, j)
- z.hashes(i) = hash
-
- System.arraycopy(kvs, 0, z.kvs, 0, 2 * i)
- System.arraycopy(kvs, 2 * i, z.kvs, 2 * i + 2, 2 * j)
- z.setKey(i, key)
- z.setValue(i, value)
-
- z
- }
-
- def withRemove(i: Int): Leaf[A, B] = {
- if (i < 0)
- this
- else {
- val z = newLeaf(hashes.length - 1)
- if (z.hashes.length > 0) {
- val j = z.hashes.length - i
-
- System.arraycopy(hashes, 0, z.hashes, 0, i)
- System.arraycopy(hashes, i + 1, z.hashes, i, j)
-
- System.arraycopy(kvs, 0, z.kvs, 0, 2 * i)
- System.arraycopy(kvs, 2 * i + 2, z.kvs, 2 * i, 2 * j)
- }
- z
- }
- }
-
- def splitIfNeeded(gen: Long, shift: Int, contended: Boolean): Node[A, B] = {
- if (!shouldSplit(contended)) this else split(gen, shift)
- }
-
- def buildingSplitIfNeeded(shift: Int): BuildingNode[A, B] = if (!shouldSplit(false)) this else buildingSplit(shift)
-
- def shouldSplit(contended: Boolean): Boolean = {
- // if the hash function is bad we might be oversize but unsplittable
- (contended || hashes.length > MaxLeafCapacity) && hashes(hashes.length - 1) != hashes(0)
- }
-
- def split(gen: Long, shift: Int): Branch[A, B] = {
- val children = new Array[Node[A, B]](BF)
- splitInto(shift, children)
-
- // class manifests for classes that have type parameters are a bit
- // convoluted to construct, so it is better to do it only once per split
- implicit val cm = implicitly[ClassManifest[Node[A, B]]]
-
- val refs = new Array[Ref.View[Node[A, B]]](BF)
- var i = 0
- while (i < BF) {
- refs(i) = Ref(children(i)).single
- i += 1
- }
- new Branch[A, B](gen, false, refs)
- }
-
- def buildingSplit(shift: Int): BuildingBranch[A, B] = {
- val children = new Array[BuildingNode[A, B]](BF)
- splitInto(shift, children)
- new BuildingBranch[A, B](children)
- }
-
- private def splitInto[L >: Leaf[A, B]](shift: Int, children: Array[L]) {
- val sizes = new Array[Int](BF)
- var i = 0
- while (i < hashes.length) {
- sizes(indexFor(shift, hashes(i))) += 1
- i += 1
- }
- i = 0
- while (i < BF) {
- children(i) = newLeaf(sizes(i))
- i += 1
- }
- i = hashes.length - 1
- while (i >= 0) {
- val slot = indexFor(shift, hashes(i))
- sizes(slot) -= 1
- val pos = sizes(slot)
- val dst = children(slot).asInstanceOf[Leaf[A, B]]
- dst.hashes(pos) = hashes(i)
- dst.setKey(pos, getKey(i))
- dst.setValue(pos, getValue(i))
-
- // If the hashes were very poorly distributed one leaf might get
- // everything. We could resplit now, but it doesn't seem to be worth
- // it. If we wait until the next insert we can never get more than
- // 32 / LogBF extra.
- //// if (pos == 0 && dst.shouldSplit)
- //// children(slot).value = dst.split(gen, shift + LogBF)
- i -= 1
- }
- }
-
- private def newLeaf(n: Int): Leaf[A, B] = {
- if (n == 0)
- emptyLeaf.asInstanceOf[Leaf[A, B]]
- else
- new Leaf[A, B](new Array[Int](n), new Array[AnyRef](2 * n))
- }
-
- def keyForeach[U](f: A => U) {
- var i = 0
- while (i < hashes.length) {
- f(getKey(i))
- i += 1
- }
- }
-
- def mapForeach[U](f: ((A, B)) => U) {
- var i = 0
- while (i < hashes.length) {
- f(getKeyValue(i))
- i += 1
- }
- }
-
- def keyIterator: Iterator[A] = new Iterator[A] {
- var pos = 0
- def hasNext = pos < hashes.length
- def next: A = { val z = getKey(pos) ; pos += 1 ; z }
- }
-
- def valueIterator: Iterator[B] = new Iterator[B] {
- var pos = 0
- def hasNext = pos < hashes.length
- def next: B = { val z = getValue(pos) ; pos += 1 ; z }
- }
-
- def mapIterator: Iterator[(A, B)] = new Iterator[(A,B)] {
- var pos = 0
- def hasNext = pos < hashes.length
- def next: (A, B) = { val z = getKeyValue(pos) ; pos += 1 ; z }
- }
- }
-
- class BuildingBranch[A, B](val children: Array[BuildingNode[A, B]]) extends BuildingNode[A, B] {
- def endBuild: Node[A, B] = {
- val refs = new Array[Ref.View[Node[A, B]]](BF)
- var i = 0
- while (i < BF) {
- refs(i) = Ref(children(i).endBuild).single
- i += 1
- }
- new Branch(0L, false, refs)
- }
- }
-
- class Branch[A, B](val gen: Long, val frozen: Boolean, val children: Array[Ref.View[Node[A, B]]]) extends Node[A, B] {
- // size may only be called on a frozen branch, so we can cache the result
- private var _cachedSize = -1
-
- def cappedSize(cap: Int): Int = {
- val n0 = _cachedSize
- if (n0 >= 0) {
- n0
- } else {
- var n = 0
- var i = 0
- while (i < BF && n < cap) {
- n += children(i)().cappedSize(cap - n)
- i += 1
- }
- if (n < cap)
- _cachedSize = n // everybody tried their hardest
- n
- }
- }
-
- def txnIsEmpty(implicit txn: InTxn): Boolean = {
- var i = 0
- while (i < BF) {
- val c = children(i).ref.get
- if (!c.txnIsEmpty)
- return false
- i += 1
- }
- return true
- }
-
- def withFreeze: Branch[A, B] = new Branch(gen, true, children)
-
- def clone(newGen: Long): Branch[A, B] = {
- val cc = children.clone
- var i = 0
- while (i < cc.length) {
- cc(i) = Ref(cc(i)()).single
- i += 1
- }
- new Branch[A, B](newGen, false, cc)
- }
-
- def keyForeach[U](f: A => U) {
- var i = 0
- while (i < BF) {
- children(i)().keyForeach(f)
- i += 1
- }
- }
-
- def mapForeach[U](f: ((A, B)) => U) {
- var i = 0
- while (i < BF) {
- children(i)().mapForeach(f)
- i += 1
- }
- }
-
- private abstract class Iter[Z] extends Iterator[Z] {
-
- def childIter(c: Node[A, B]): Iterator[Z]
-
- private var pos = -1
- private var iter: Iterator[Z] = null
- advance()
-
- @tailrec private def advance(): Boolean = {
- if (pos == BF - 1) {
- iter = null
- false
- } else {
- pos += 1
- val c = children(pos)()
- if (c eq emptyLeaf)
- advance() // keep looking, nothing is here
- else {
- iter = childIter(c)
- iter.hasNext || advance() // keep looking if we got a dud
- }
- }
- }
-
- def hasNext = iter != null && iter.hasNext
-
- def next: Z = {
- val z = iter.next
- if (!iter.hasNext)
- advance()
- z
- }
- }
-
- def keyIterator: Iterator[A] = new Iter[A] {
- def childIter(c: Node[A, B]) = c.keyIterator
- }
-
- def valueIterator: Iterator[B] = new Iter[B] {
- def childIter(c: Node[A, B]) = c.valueIterator
- }
-
- def mapIterator: Iterator[(A, B)] = new Iter[(A,B)] {
- def childIter(c: Node[A, B]) = c.mapIterator
- }
- }
-
- //////////////// construction
-
- def emptySetNode[A]: SetNode[A] = emptyLeaf.asInstanceOf[SetNode[A]]
- def emptyMapNode[A, B]: Node[A, B] = emptyLeaf.asInstanceOf[Node[A, B]]
-
- def emptySetBuildingNode[A]: SetBuildingNode[A] = emptyLeaf.asInstanceOf[SetBuildingNode[A]]
- def emptyMapBuildingNode[A, B]: BuildingNode[A, B] = emptyLeaf.asInstanceOf[BuildingNode[A, B]]
-
- def buildingAdd[A](root: SetBuildingNode[A], x: A): SetBuildingNode[A] = buildingPut(root, 0, keyHash(x), x, null)
- def buildingPut[A, B](root: BuildingNode[A, B], k: A, v: B): BuildingNode[A, B] = buildingPut(root, 0, keyHash(k), k, v)
-
- private def buildingPut[A, B](current: BuildingNode[A, B], shift: Int, hash: Int, key: A, value: B): BuildingNode[A, B] = {
- current match {
- case leaf: Leaf[A, B] => {
- val i = leaf.find(hash, key)
- if (leaf.noChange(i, value)) leaf else leaf.withBuildingPut(shift, hash, key, value, i)
- }
- case branch: BuildingBranch[A, B] => {
- val i = indexFor(shift, hash)
- branch.children(i) = buildingPut(branch.children(i), shift + LogBF, hash, key, value)
- branch
- }
- }
- }
-}
-
-private[skel] abstract class TxnHashTrie[A, B](protected var root: Ref.View[TxnHashTrie.Node[A, B]]) {
- import TxnHashTrie._
-
- //////////////// txn contention tracking
-
- private final val pct = 10000
- private final val contentionThreshold = 1 * pct
- private var contentionEstimate = 0
-
- private def recordNoContention() {
- if (SimpleRandom.nextInt(32) == 0) {
- val e = contentionEstimate
- contentionEstimate = e - (e >> 4) // this is 15/16, applied every 32nd time, so about 99.8%
- }
- }
-
- private def recordContention() {
- val e = contentionEstimate
- contentionEstimate = e + ((100 * pct - e) >> 9) // 100 * pct is the max
- }
-
- private def isContended = contentionEstimate > contentionThreshold
-
- //////////////// whole-trie operations
-
- protected def frozenRoot: Node[A, B] = {
- root() match {
- case leaf: Leaf[A, B] => leaf // leaf is already immutable
- case branch: Branch[A, B] if branch.frozen => branch
- case branch: Branch[A, B] => {
- // If this CAS fails it means someone else already installed a frozen
- // branch, and we can benefit from their work.
- val b = branch.withFreeze
- root.compareAndSetIdentity(branch, b)
- b
- }
- }
- }
-
- protected def cloneRoot: Ref.View[Node[A, B]] = Ref(frozenRoot).single
-
- protected def setIterator: Iterator[A] = frozenRoot.keyIterator
-
- protected def mapIterator: Iterator[(A, B)] = frozenRoot.mapIterator
- protected def mapKeyIterator: Iterator[A] = frozenRoot.keyIterator
- protected def mapValueIterator: Iterator[B] = frozenRoot.valueIterator
-
- //////////////// whole-trie operations on Ref.View
-
- protected def singleIsEmpty: Boolean = impl.STMImpl.instance.dynCurrentOrNull match {
- case null => frozenRoot.cappedSize(1) == 0
- case txn => txnIsEmpty(txn)
- }
-
- protected def singleSize: Int = frozenRoot.cappedSize(Int.MaxValue)
-
- protected def singleSetForeach[U](f: A => U) {
- // don't freeze the root if we use .single in a txn
- impl.STMImpl.instance.dynCurrentOrNull match {
- case null => frozenRoot.keyForeach(f)
- case txn => txnSetForeach(f)(txn)
- }
- }
-
- protected def singleMapForeach[U](f: ((A, B)) => U) {
- impl.STMImpl.instance.dynCurrentOrNull match {
- case null => frozenRoot.mapForeach(f)
- case txn => txnMapForeach(f)(txn)
- }
- }
-
- //////// single-key operations for Ref.View
-
- protected def singleContains(key: A): Boolean = singleContains(null, root, 0, keyHash(key), key)
-
- @tailrec private def singleContains(rootNode: Node[A, B], n: Ref.View[Node[A, B]], shift: Int, hash: Int, key: A): Boolean = {
- n() match {
- case leaf: Leaf[A, B] => {
- if (shift != 0 && (rootNode ne root()))
- singleContains(null, root, 0, hash, key)
- else
- leaf.contains(hash, key)
- }
- case branch: Branch[A, B] => {
- val rn = if (shift == 0) branch else rootNode
- singleContains(rn, branch.children(indexFor(shift, hash)), shift + LogBF, hash, key)
- }
- }
- }
-
- protected def singleGetOrThrow(key: A): B = singleGetOrThrow(null, root, 0, keyHash(key), key)
-
- @tailrec private def singleGetOrThrow(rootNode: Node[A, B], n: Ref.View[Node[A, B]], shift: Int, hash: Int, key: A): B = {
- n() match {
- case leaf: Leaf[A, B] => {
- if (shift != 0 && (rootNode ne root()))
- singleGetOrThrow(null, root, 0, hash, key)
- else {
- val i = leaf.find(hash, key)
- if (i < 0)
- throw new NoSuchElementException("key not found: " + key)
- leaf.getValue(i)
- }
- }
- case branch: Branch[A, B] => {
- val rn = if (shift == 0) branch else rootNode
- singleGetOrThrow(rn, branch.children(indexFor(shift, hash)), shift + LogBF, hash, key)
- }
- }
- }
-
- protected def singleGet(key: A): Option[B] = singleGet(null, root, 0, keyHash(key), key)
-
- @tailrec private def singleGet(rootNode: Node[A, B], n: Ref.View[Node[A, B]], shift: Int, hash: Int, key: A): Option[B] = {
- n() match {
- case leaf: Leaf[A, B] => {
- if (shift != 0 && (rootNode ne root()))
- singleGet(null, root, 0, hash, key)
- else
- leaf.get(hash, key)
- }
- case branch: Branch[A, B] => {
- val rn = if (shift == 0) branch else rootNode
- singleGet(rn, branch.children(indexFor(shift, hash)), shift + LogBF, hash, key)
- }
- }
- }
-
- protected def singlePut(key: A, value: B): Option[B] = singleRootPut(keyHash(key), key, value, 0)
-
- @tailrec private def singleRootPut(hash: Int, key: A, value: B, failures: Int): Option[B] = {
- if (failures < 10) {
- root() match {
- case leaf: Leaf[A, B] => {
- val i = leaf.find(hash, key)
- if (leaf.noChange(i, value) || root.compareAndSetIdentity(leaf, leaf.withPut(0L, 0, hash, key, value, i, false)))
- leaf.get(i) // success, read from old leaf
- else
- singleRootPut(hash, key, value, failures + 1)
- }
- case branch: Branch[A, B] => {
- val b = if (!branch.frozen) branch else singleUnshare(branch.gen + 1, root, branch)
- if (b != null)
- singleChildPut(b, b.children(indexFor(0, hash)), LogBF, hash, key, value, 0)
- else
- singleRootPut(hash, key, value, failures + 1)
- }
- }
- } else
- failingPut(hash, key, value)
- }
-
- private def singleUnshare(rootGen: Long, current: Ref.View[Node[A, B]], branch: Branch[A, B]): Branch[A, B] = {
- val b = branch.clone(rootGen)
- if (current.compareAndSetIdentity(branch, b)) b else null
- }
-
- private def failingPut(hash: Int, key: A, value: B): Option[B] = {
- // running in a transaction guarantees that CAS won't fail
- atomic { implicit txn => txnRootPut(hash, key, value) }
- }
-
- @tailrec private def singleChildPut(rootNode: Branch[A, B],
- current: Ref.View[Node[A, B]],
- shift: Int,
- hash: Int,
- key: A,
- value: B,
- failures: Int): Option[B] = {
- if (failures < 10) {
- current() match {
- case leaf: Leaf[A, B] => {
- val i = leaf.find(hash, key)
- if (leaf.noChange(i, value) || atomic.compareAndSetIdentity(
- root.ref, rootNode, rootNode, current.ref,
- leaf, leaf.withPut(rootNode.gen, shift, hash, key, value, i, failures > 0)))
- leaf.get(i) // success
- else if (root() ne rootNode)
- failingPut(hash, key, value) // root retry
- else
- singleChildPut(rootNode, current, shift, hash, key, value, failures + 1) // local retry
- }
- case branch: Branch[A, B] => {
- val b = if (branch.gen == rootNode.gen) branch else singleUnshare(rootNode.gen, current, branch)
- if (b != null)
- singleChildPut(rootNode, b.children(indexFor(shift, hash)), shift + LogBF, hash, key, value, failures)
- else
- singleChildPut(rootNode, current, shift, hash, key, value, failures + 1) // failure, try again
- }
- }
- } else
- failingPut(hash, key, value)
- }
-
- protected def singleRemove(key: A): Option[B] = singleRootRemove(keyHash(key), key, 0)
-
- @tailrec private def singleRootRemove(hash: Int, key: A, failures: Int): Option[B] = {
- if (failures < 10) {
- root() match {
- case leaf: Leaf[A, B] => {
- val i = leaf.find(hash, key)
- if (i < 0 || root.compareAndSetIdentity(leaf, leaf.withRemove(i)))
- leaf.get(i) // success, read from old leaf
- else
- singleRootRemove(hash, key, failures + 1)
- }
- case branch: Branch[A, B] => {
- val i = indexFor(0, hash)
- if (branch.frozen && !singleContains(branch, branch.children(i), LogBF, hash, key))
- None
- else {
- val b = if (!branch.frozen) branch else singleUnshare(branch.gen + 1, root, branch)
- if (b != null)
- singleChildRemove(b, b.children(i), LogBF, hash, key, (b ne branch), 0)
- else
- singleRootRemove(hash, key, failures + 1)
- }
- }
- }
- } else
- failingRemove(hash, key)
- }
-
- private def failingRemove(hash: Int, key: A): Option[B] = {
- // running in a transaction guarantees that CAS won't fail
- atomic { implicit txn => txnRootRemove(hash, key) }
- }
-
- @tailrec private def singleChildRemove(rootNode: Branch[A, B],
- current: Ref.View[Node[A, B]],
- shift: Int,
- hash: Int,
- key: A,
- checked: Boolean,
- failures: Int): Option[B] = {
- if (failures < 10) {
- current() match {
- case leaf: Leaf[A, B] => {
- val i = leaf.find(hash, key)
- if (i < 0)
- None // no change, key wasn't present
- else if (atomic.compareAndSetIdentity(root.ref, rootNode, rootNode, current.ref, leaf, leaf.withRemove(i)))
- leaf.get(i) // success
- else if (root() ne rootNode)
- failingRemove(hash, key) // root retry
- else
- singleChildRemove(rootNode, current, shift, hash, key, checked, failures + 1) // local retry
- }
- case branch: Branch[A, B] => {
- val i = indexFor(shift, hash)
- if (!checked && branch.gen != rootNode.gen && !singleContains(rootNode, branch.children(i), shift + LogBF, hash, key))
- None // child is absent
- else {
- val b = if (branch.gen == rootNode.gen) branch else singleUnshare(rootNode.gen, current, branch)
- if (b != null)
- singleChildRemove(rootNode, b.children(i), shift + LogBF, hash, key, checked || (b ne branch), failures)
- else
- singleChildRemove(rootNode, current, shift, hash, key, checked, failures + 1)
- }
- }
- }
- } else
- failingRemove(hash, key)
- }
-
-
- //////////////// whole-trie operations when an InTxn is available
-
- // visitation doesn't need to freeze the root, because we know that the
- // entire visit is part of an atomic block
-
- protected def txnIsEmpty(implicit txn: InTxn): Boolean = root().txnIsEmpty
-
- protected def txnSetForeach[U](f: A => U)(implicit txn: InTxn) { root().keyForeach(f) }
-
- protected def txnMapForeach[U](f: ((A, B)) => U)(implicit txn: InTxn) { root().mapForeach(f) }
-
- //////////////// per-key operations when an InTxn is available
-
- protected def txnContains(key: A)(implicit txn: InTxn): Boolean = txnContains(root.ref, 0, keyHash(key), key)(txn)
-
- @tailrec private def txnContains(n: Ref[Node[A, B]], shift: Int, hash: Int, key: A)(implicit txn: InTxn): Boolean = {
- n() match {
- case leaf: Leaf[A, B] => leaf.contains(hash, key)
- case branch: Branch[A, B] => txnContains(branch.children(indexFor(shift, hash)).ref, shift + LogBF, hash, key)(txn)
- }
- }
-
- protected def txnGetOrThrow(key: A)(implicit txn: InTxn): B = txnGetOrThrow(root.ref, 0, keyHash(key), key)(txn)
-
- @tailrec private def txnGetOrThrow(n: Ref[Node[A, B]], shift: Int, hash: Int, key: A)(implicit txn: InTxn): B = {
- n() match {
- case leaf: Leaf[A, B] => {
- val i = leaf.find(hash, key)
- if (i < 0)
- throw new NoSuchElementException("key not found: " + key)
- leaf.getValue(i)
- }
- case branch: Branch[A, B] => txnGetOrThrow(branch.children(indexFor(shift, hash)).ref, shift + LogBF, hash, key)(txn)
- }
- }
-
- protected def txnGet(key: A)(implicit txn: InTxn): Option[B] = txnGet(root.ref, 0, keyHash(key), key)(txn)
-
- @tailrec private def txnGet(n: Ref[Node[A, B]], shift: Int, hash: Int, key: A)(implicit txn: InTxn): Option[B] = {
- n() match {
- case leaf: Leaf[A, B] => leaf.get(hash, key)
- case branch: Branch[A, B] => txnGet(branch.children(indexFor(shift, hash)).ref, shift + LogBF, hash, key)(txn)
- }
- }
-
- protected def txnPut(key: A, value: B)(implicit txn: InTxn): Option[B] = txnRootPut(keyHash(key), key, value)(txn)
-
- private def txnRootPut(hash: Int, key: A, value: B)(implicit txn: InTxn): Option[B] = {
- root() match {
- case leaf: Leaf[A, B] => {
- val i = leaf.find(hash, key)
- if (!leaf.noChange(i, value))
- set(root.ref, leaf.withPut(0L, 0, hash, key, value, i, isContended))
- leaf.get(i)
- }
- case branch: Branch[A, B] => {
- val b = if (!branch.frozen) branch else txnUnshare(branch.gen + 1, root.ref, branch)
- txnChildPut(b.gen, b.children(indexFor(0, hash)).ref, LogBF, hash, key, value)(txn)
- }
- }
- }
-
- private def set(ref: Ref[Node[A, B]], node: Node[A, B])(implicit txn: InTxn) {
- if (!ref.trySet(node)) {
- recordContention()
- ref() = node
- } else
- recordNoContention()
- }
-
- private def txnUnshare(rootGen: Long, current: Ref[Node[A, B]], branch: Branch[A, B])(implicit txn: InTxn): Branch[A, B] = {
- val b = branch.clone(rootGen)
- current() = b
- b
- }
-
- @tailrec private def txnChildPut(rootGen: Long, current: Ref[Node[A, B]], shift: Int, hash: Int, key: A, value: B
- )(implicit txn: InTxn): Option[B] = {
- current() match {
- case leaf: Leaf[A, B] => {
- val i = leaf.find(hash, key)
- if (!leaf.noChange(i, value))
- set(current, leaf.withPut(rootGen, shift, hash, key, value, i, isContended))
- leaf.get(i)
- }
- case branch: Branch[A, B] => {
- val b = if (branch.gen == rootGen) branch else txnUnshare(rootGen, current, branch)
- txnChildPut(rootGen, b.children(indexFor(shift, hash)).ref, shift + LogBF, hash, key, value)(txn)
- }
- }
- }
-
- protected def txnRemove(key: A)(implicit txn: InTxn): Option[B] = txnRootRemove(keyHash(key), key)(txn)
-
- private def txnRootRemove(hash: Int, key: A)(implicit txn: InTxn): Option[B] = {
- root() match {
- case leaf: Leaf[A, B] => {
- val i = leaf.find(hash, key)
- if (i >= 0)
- set(root.ref, leaf.withRemove(i))
- leaf.get(i)
- }
- case branch: Branch[A, B] => {
- val i = indexFor(0, hash)
- if (branch.frozen && !txnContains(branch.children(i).ref, LogBF, hash, key))
- None
- else {
- val b = if (!branch.frozen) branch else txnUnshare(branch.gen + 1, root.ref, branch)
- txnChildRemove(b.gen, b.children(i).ref, LogBF, hash, key, (b ne branch))(txn)
- }
- }
- }
- }
-
- @tailrec private def txnChildRemove(rootGen: Long, current: Ref[Node[A, B]], shift: Int, hash: Int, key: A, checked: Boolean
- )(implicit txn: InTxn): Option[B] = {
- current() match {
- case leaf: Leaf[A, B] => {
- val i = leaf.find(hash, key)
- if (i >= 0)
- set(current, leaf.withRemove(i))
- leaf.get(i)
- }
- case branch: Branch[A, B] => {
- val i = indexFor(shift, hash)
- if (!checked && branch.gen != rootGen && !txnContains(branch.children(i).ref, shift + LogBF, hash, key))
- None // child is absent
- else {
- val b = if (branch.gen == rootGen) branch else txnUnshare(rootGen, current, branch)
- txnChildRemove(rootGen, b.children(i).ref, shift + LogBF, hash, key, checked || (b ne branch))(txn)
- }
- }
- }
- }
-}
diff --git a/benchmarks/scala-stm/scala-stm-library/src/test/java/scala/concurrent/stm/JavaAPITests.java b/benchmarks/scala-stm/scala-stm-library/src/test/java/scala/concurrent/stm/JavaAPITests.java
deleted file mode 100644
index 029deeed..00000000
--- a/benchmarks/scala-stm/scala-stm-library/src/test/java/scala/concurrent/stm/JavaAPITests.java
+++ /dev/null
@@ -1,176 +0,0 @@
-/* scala-stm - (c) 2009-2012, Stanford University, PPL */
-
-package scala.concurrent.stm;
-
-import static org.junit.Assert.*;
-import org.junit.Test;
-
-import static scala.concurrent.stm.japi.STM.*;
-
-import java.util.concurrent.Callable;
-
-import java.util.Map;
-import java.util.Set;
-import java.util.List;
-
-public class JavaAPITests {
- @Test
- public void createIntegerRef() {
- Ref.View ref = newRef(0);
- int unboxed = ref.get();
- assertEquals(0, unboxed);
- }
-
- @Test
- public void atomicWithRunnable() {
- final Ref.View ref = newRef(0);
- atomic(new Runnable() {
- public void run() {
- ref.set(10);
- }
- });
- int value = ref.get();
- assertEquals(10, value);
- }
-
- @Test
- public void atomicWithCallable() {
- final Ref.View ref = newRef(0);
- int oldValue = atomic(new Callable() {
- public Integer call() {
- return ref.swap(10);
- }
- });
- assertEquals(0, oldValue);
- int newValue = ref.get();
- assertEquals(10, newValue);
- }
-
- @Test(expected = TestException.class)
- public void failingTransaction() {
- final Ref.View ref = newRef(0);
- try {
- atomic(new Runnable() {
- public void run() {
- ref.set(10);
- throw new TestException();
- }
- });
- } catch (TestException e) {
- int value = ref.get();
- assertEquals(0, value);
- throw e;
- }
- }
-
- @Test
- public void transformInteger() {
- Ref.View ref = newRef(0);
- transform(ref, new Transformer() {
- public Integer apply(Integer i) {
- return i + 10;
- }
- });
- int value = ref.get();
- assertEquals(10, value);
- }
-
- @Test
- public void getAndTransformInteger() {
- Ref.View ref = newRef(0);
- int value = getAndTransform(ref, new Transformer() {
- public Integer apply(Integer i) {
- return i + 10;
- }
- });
- assertEquals(0, value);
- }
-
- @Test
- public void transformAndGetInteger() {
- Ref.View ref = newRef(0);
- int value = transformAndGet(ref, new Transformer() {
- public Integer apply(Integer i) {
- return i + 10;
- }
- });
- assertEquals(10, value);
- }
-
- @Test
- public void incrementInteger() {
- Ref.View ref = newRef(0);
- increment(ref, 10);
- int value = ref.get();
- assertEquals(10, value);
- }
-
- @Test
- public void incrementLong() {
- Ref.View ref = newRef(0L);
- increment(ref, 10L);
- long value = ref.get();
- assertEquals(10L, value);
- }
-
- @Test
- public void createAndUseTMap() {
- Map map = newMap();
- map.put(1, "one");
- map.put(2, "two");
- assertEquals("one", map.get(1));
- assertEquals("two", map.get(2));
- assertTrue(map.containsKey(2));
- map.remove(2);
- assertFalse(map.containsKey(2));
- }
-
- @Test(expected = TestException.class)
- public void failingTMapTransaction() {
- final Map map = newMap();
- try {
- atomic(new Runnable() {
- public void run() {
- map.put(1, "one");
- map.put(2, "two");
- assertTrue(map.containsKey(1));
- assertTrue(map.containsKey(2));
- throw new TestException();
- }
- });
- } catch (TestException e) {
- assertFalse(map.containsKey(1));
- assertFalse(map.containsKey(2));
- throw e;
- }
- }
-
- @Test
- public void createAndUseTSet() {
- Set set = newSet();
- set.add("one");
- set.add("two");
- assertTrue(set.contains("one"));
- assertTrue(set.contains("two"));
- assertEquals(2, set.size());
- set.add("one");
- assertEquals(2, set.size());
- set.remove("two");
- assertFalse(set.contains("two"));
- assertEquals(1, set.size());
- }
-
- @Test
- public void createAndUseTArray() {
- List list = newArrayAsList(3);
- assertEquals(null, list.get(0));
- assertEquals(null, list.get(1));
- assertEquals(null, list.get(2));
- list.set(0, "zero");
- list.set(1, "one");
- list.set(2, "two");
- assertEquals("zero", list.get(0));
- assertEquals("one", list.get(1));
- assertEquals("two", list.get(2));
- }
-}
diff --git a/benchmarks/scala-stm/scala-stm-library/src/test/java/scala/concurrent/stm/TestException.java b/benchmarks/scala-stm/scala-stm-library/src/test/java/scala/concurrent/stm/TestException.java
deleted file mode 100644
index 0b91928d..00000000
--- a/benchmarks/scala-stm/scala-stm-library/src/test/java/scala/concurrent/stm/TestException.java
+++ /dev/null
@@ -1,9 +0,0 @@
-/* scala-stm - (c) 2009-2012, Stanford University, PPL */
-
-package scala.concurrent.stm;
-
-public class TestException extends RuntimeException {
- public TestException() {
- super("Expected failure");
- }
-}
diff --git a/benchmarks/scala-stm/scala-stm-library/src/test/scala/scala/concurrent/stm/CallbackSuite.scala b/benchmarks/scala-stm/scala-stm-library/src/test/scala/scala/concurrent/stm/CallbackSuite.scala
deleted file mode 100644
index 5b0eef7d..00000000
--- a/benchmarks/scala-stm/scala-stm-library/src/test/scala/scala/concurrent/stm/CallbackSuite.scala
+++ /dev/null
@@ -1,582 +0,0 @@
-/* scala-stm - (c) 2009-2012, Stanford University, PPL */
-
-package scala.concurrent.stm
-
-import org.scalatest.FunSuite
-import java.util.concurrent.CountDownLatch
-
-
-class CallbackSuite extends FunSuite {
-
- class UserException extends Exception
-
- test("many callbacks") {
- var n = 0
- val x = Ref(0)
- atomic { implicit t =>
- x() = 1
- for (i <- 0 until 10000)
- Txn.afterCommit { _ => n += 1 }
- }
- assert(n === 10000)
- assert(x.single() === 1)
- }
-
- test("beforeCommit upgrade on read-only commit") {
- val x = Ref(0)
- var ran = false
- atomic { implicit t =>
- assert(x() === 0)
- Txn.beforeCommit { _ =>
- assert(!ran)
- x() = 1
- ran = true
- }
- }
- assert(ran)
- assert(x.single() === 1)
- }
-
- test("retry in beforeCommit") {
- val n = 50
- val x = Ref(0)
- val b = Array.tabulate(n) { _ => new CountDownLatch(1) }
- val t = new Thread("trigger") {
- override def run() {
- for (i <- 0 until n) {
- b(i).await()
- Thread.sleep(5)
- x.single() += 1
- }
- }
- }
- var tries = 0
- t.start()
- val y = Ref(0)
- atomic { implicit t =>
- tries += 1
- y() = 1
- Txn.beforeCommit { implicit t =>
- if (x() < n) {
- for (i <- 0 until math.min(n, tries))
- b(i).countDown()
- retry
- }
- }
- }
- assert(tries >= n)
- }
-
- test("exception in beforeCommit") {
- val x = Ref[Option[String]](Some("abc"))
- intercept[NoSuchElementException] {
- atomic { implicit t =>
- x() = None
- Txn.beforeCommit { _ => println(x().get) }
- }
- }
- }
-
- test("surviving beforeCommit") {
- val x = Ref(1)
- val y = Ref(2)
- val z = Ref(3)
- var a = false
- var aa = false
- var ab = false
- var b = false
- var ba = false
- var bb = false
- var bc = false
- atomic { implicit t =>
- Txn.beforeCommit { _ => assert(!a) ; a = true }
- atomic { implicit t =>
- Txn.beforeCommit { _ => assert(!aa) ; aa = true }
- x += 1
- if (x() != 0)
- retry
- } orAtomic { implicit t =>
- Txn.beforeCommit { _ => assert(!ab) ; ab = true }
- y += 1
- if (y() != 0)
- retry
- }
- z += 8
- } orAtomic { implicit t =>
- Txn.beforeCommit { _ => assert(!b && !ba && !bb && !bc) ; b = true }
- atomic { implicit t =>
- Txn.beforeCommit { _ => assert(!ba) ; ba = true }
- z += 1
- if (x() != 0)
- retry
- } orAtomic { implicit t =>
- Txn.beforeCommit { _ => assert(!bb) ; bb = true }
- x += 1
- if (x() != 0)
- retry
- } orAtomic { implicit t =>
- Txn.beforeCommit { _ => assert(b) ; assert(!bc) ; bc = true }
- if (x() + y() + z() == 0)
- retry
- }
- z += 16
- }
- assert(!a)
- assert(!aa)
- assert(!ab)
- assert(b)
- assert(!ba)
- assert(!bb)
- assert(bc)
- assert(x.single() == 1)
- assert(y.single() == 2)
- assert(z.single() == 19)
- }
-
- test("afterRollback on commit") {
- atomic { implicit t =>
- Txn.afterRollback { _ => assert(false) }
- }
- }
-
- test("afterRollback on rollback") {
- val x = Ref(10)
- var ran = false
- atomic { implicit t =>
- Txn.afterRollback { _ =>
- assert(!ran)
- ran = true
- }
- if (x() == 10) {
- val adversary = new Thread {
- override def run() {
- x.single.transform(_ + 1)
- }
- }
- adversary.start()
- adversary.join()
- x()
- assert(false)
- }
- }
- assert(ran)
- }
-
- test("afterCommit runs a txn") {
- var ran = false
- val x = Ref(0)
- atomic { implicit t =>
- x() = 1
- Txn.afterCommit { _ =>
- atomic { implicit t =>
- assert(!ran)
- ran = true
- assert(x() === 1)
- x() = 2
- }
- }
- }
- assert(ran)
- assert(x.single() === 2)
- }
-
- test("afterCommit doesn't access txn") {
- var ran = false
- val x = Ref(0)
- atomic { implicit t =>
- x() = 1
- Txn.afterCommit { _ =>
- intercept[IllegalStateException] {
- assert(!ran)
- ran = true
- x() = 2
- }
- }
- }
- assert(ran)
- assert(x.single() === 1)
- }
-
- test("beforeCommit during beforeCommit") {
- val handler = new Function1[InTxn, Unit] {
- var count = 0
-
- def apply(txn: InTxn) {
- if (txn eq null) {
- // this is the after-atomic check
- assert(count === 1000)
- } else {
- count += 1
- if (count < 1000)
- Txn.beforeCommit(this)(txn)
- }
- }
- }
- val x = Ref(0)
- atomic { implicit t =>
- x += 1
- Txn.beforeCommit(handler)
- }
- handler(null)
- }
-
- test("beforeCommit termination") {
- val x = Ref(0)
- var a = false
- intercept[UserException] {
- atomic { implicit t =>
- assert(x() === 0)
- Txn.beforeCommit { _ =>
- assert(!a)
- a = true
- throw new UserException
- }
- x += 2
- Txn.beforeCommit { _ =>
- assert(false)
- }
- }
- }
- assert(a)
- }
-
- test("manual optimistic retry") {
- var tries = 0
- val x = Ref(0)
- atomic { implicit t =>
- assert(x() === 0)
- x += tries
- tries += 1
- if (tries < 100)
- Txn.rollback(Txn.OptimisticFailureCause('manual_failure, None))
- }
- assert(x.single() === 99)
- assert(tries === 100)
- }
-
- test("manual optimistic retry during beforeCommit") {
- var tries = 0
- val x = Ref(0)
- atomic { implicit t =>
- assert(x() === 0)
- x += tries
- tries += 1
- Txn.beforeCommit { implicit t =>
- if (tries < 100)
- Txn.rollback(Txn.OptimisticFailureCause('manual_failure, None))
- }
- }
- assert(x.single() === 99)
- assert(tries === 100)
- }
-
- test("whilePreparing") {
- var i = 0
- var observed = -1
- val x = Ref(0)
- atomic { implicit txn =>
- i += 1
- x() = i
- Txn.whilePreparing { _ =>
- observed = i
- if (i < 4) Txn.rollback(Txn.OptimisticFailureCause('test, None))
- }
- }
- assert(x.single() == 4)
- assert(observed == 4)
- assert(i == 4)
- }
-
- test("whilePreparing throws exception") {
- intercept[UserException] {
- atomic { implicit txn =>
- Txn.whilePreparing { _ => throw new UserException }
- }
- }
- }
-
- test("whileCommitting") {
- var count = 0
- val x = Ref(0)
- atomic { implicit txn =>
- x() = 1
- Txn.whileCommitting { _ => count += 1 }
- }
- assert(x.single() == 1)
- assert(count == 1)
- }
-
- test("whileCommitting without any accesses") {
- var count = 0
- atomic { implicit txn =>
- Txn.whileCommitting { _ => count += 1 }
- }
- assert(count == 1)
- }
-
- test("whileCommitting ordering", Slow) {
- val numThreads = 10
- val numPutsPerThread = 100000
- val startingGate = new java.util.concurrent.CountDownLatch(1)
- val active = Ref(numThreads)
- val failure = Ref(null : Throwable)
-
- val x = Ref(0)
- val notifier = new scala.concurrent.forkjoin.LinkedTransferQueue[Int]()
- val EOF = -1
-
- for (i <- 1 to numThreads) {
- (new Thread {
- override def run() {
- try {
- startingGate.await()
- for (i <- 1 to numPutsPerThread) {
- atomic { implicit txn =>
- x() = x() + 1
- val y = x()
- Txn.whileCommitting { _ =>
- if ((i & 127) == 0) // try to perturb the timing
- Thread.`yield`()
- notifier.put(y)
- }
- }
- }
- } catch {
- case xx: Throwable => failure.single() = xx
- }
- if (active.single.transformAndGet( _ - 1 ) == 0)
- notifier.put(EOF)
- }
- }).start()
- }
-
- startingGate.countDown()
- for (expected <- 1 to numThreads * numPutsPerThread)
- assert(expected === notifier.take())
- assert(EOF === notifier.take())
-
- if (failure.single() != null)
- throw failure.single()
- }
-
- test("accepting external decider") {
- val x = Ref(0)
- atomic { implicit txn =>
- x() = 1
- Txn.setExternalDecider(new Txn.ExternalDecider {
- def shouldCommit(implicit txn: InTxnEnd): Boolean = {
- assert(txn.status == Txn.Prepared)
- true
- }
- })
- }
- assert(x.single() === 1)
- }
-
- test("valid duplicate external decider") {
- val x = Ref(0)
- atomic { implicit txn =>
- x() = 1
- val d = new Txn.ExternalDecider {
- def shouldCommit(implicit txn: InTxnEnd): Boolean = {
- assert(txn.status == Txn.Prepared)
- true
- }
- }
- assert(d == d)
- Txn.setExternalDecider(d)
- Txn.setExternalDecider(d)
- }
- assert(x.single() === 1)
- }
-
- test("invalid duplicate external decider") {
- val x = Ref(0)
- intercept[IllegalArgumentException] {
- atomic { implicit txn =>
- x() = 1
- val d1 = new Txn.ExternalDecider { def shouldCommit(implicit txn: InTxnEnd): Boolean = true }
- val d2 = new Txn.ExternalDecider { def shouldCommit(implicit txn: InTxnEnd): Boolean = true }
- assert(d1 != d2)
- Txn.setExternalDecider(d1)
- Txn.setExternalDecider(d2)
- }
- }
- assert(x.single() === 0)
- }
-
- test("transient reject external decider") {
- val x = Ref(0)
- var tries = 0
- atomic { implicit txn =>
- tries += 1
- x() = tries
- Txn.setExternalDecider(new Txn.ExternalDecider {
- def shouldCommit(implicit txn: InTxnEnd): Boolean = {
- assert(txn.status == Txn.Prepared)
- tries == 3
- }
- })
- }
- assert(tries === 3)
- assert(x.single() === 3)
- }
-
- test("nested external deciders") {
- val x = Ref(0)
- var which = 0
- atomic { implicit txn =>
- atomic { implicit txn =>
- Txn.setExternalDecider(new Txn.ExternalDecider {
- def shouldCommit(implicit txn: InTxnEnd): Boolean = { which = 1 ; true }
- })
- if (x.swap(1) == 0)
- retry
- } orAtomic { implicit txn =>
- Txn.setExternalDecider(new Txn.ExternalDecider {
- def shouldCommit(implicit txn: InTxnEnd): Boolean = { which = 2 ; true }
- })
- if (x.swap(2) == 0)
- retry
- } orAtomic { implicit txn =>
- Txn.setExternalDecider(new Txn.ExternalDecider {
- def shouldCommit(implicit txn: InTxnEnd): Boolean = { which = 3 ; true }
- })
- x.swap(3)
- }
- }
- assert(which === 3)
- assert(x.single() === 3)
- }
-
- test("external decider throws exception") {
- var tries = 0
- val x = Ref(0)
- intercept[UserException] {
- atomic { implicit txn =>
- tries += 1
- x() = 1
- Txn.setExternalDecider(new Txn.ExternalDecider {
- def shouldCommit(implicit txn: InTxnEnd): Boolean = throw new UserException
- })
- }
- }
- assert(tries === 1)
- assert(x.single() === 0)
- }
-
- test("rethrown exception from whileCommitting handler") {
- val x = Ref(0)
- intercept[UserException] {
- val customAtomic = atomic.withPostDecisionFailureHandler { (status, failure) => throw failure }
- customAtomic { implicit txn =>
- Txn.whileCommitting { _ => throw new UserException }
- x() = 1
- }
- }
- assert(x.single() === 1)
- }
-
- test("swallowed exception from whileCommitting handler") {
- var swallowed: Throwable = null
- val x = Ref(0)
- val customAtomic = atomic.withPostDecisionFailureHandler { (status, failure) =>
- assert(swallowed === null)
- assert(status == Txn.Committing)
- swallowed = failure
- }
- customAtomic { implicit txn =>
- Txn.whileCommitting { _ => throw new UserException }
- x() = 1
- }
- assert(x.single() === 1)
- assert(swallowed.isInstanceOf[UserException])
- }
-
- test("rethrown exception from afterCommit handler") {
- val x = Ref(0)
- intercept[UserException] {
- val customAtomic = atomic.withPostDecisionFailureHandler { (status, failure) => throw failure }
- customAtomic { implicit txn =>
- Txn.afterCommit { _ => throw new UserException }
- x() = 1
- }
- }
- assert(x.single() === 1)
- }
-
- test("swallowed exception from afterCommit handler") {
- var swallowed: Throwable = null
- val x = Ref(0)
- val customAtomic = atomic.withPostDecisionFailureHandler { (status, failure) =>
- assert(swallowed === null)
- assert(status == Txn.Committed)
- swallowed = failure
- }
- customAtomic { implicit txn =>
- Txn.afterCommit { _ => throw new UserException }
- x() = 1
- }
- assert(x.single() === 1)
- assert(swallowed.isInstanceOf[UserException])
- }
-
- test("rethrown exception from afterRollback handler") {
- val x = Ref(0)
- intercept[UserException] {
- val customAtomic = atomic.withPostDecisionFailureHandler { (status, failure) => throw failure }
- customAtomic { implicit txn =>
- Txn.afterRollback { _ => throw new UserException }
- x() = 1
- throw new InterruptedException
- }
- }
- assert(x.single() === 0)
- }
-
- test("swallowed exception from afterRollback handler") {
- var swallowed: Throwable = null
- val x = Ref(0)
- val customAtomic = atomic.withPostDecisionFailureHandler { (status, failure) =>
- assert(swallowed === null)
- assert(status.isInstanceOf[Txn.RolledBack])
- swallowed = failure
- }
- intercept[InterruptedException] {
- customAtomic { implicit txn =>
- Txn.afterRollback { _ => throw new UserException }
- x() = 1
- throw new InterruptedException
- }
- }
- assert(x.single() === 0)
- assert(swallowed.isInstanceOf[UserException])
- }
-
- test("rethrow afterRollback exception cancels retry") {
- val x = Ref(0)
- intercept[UserException] {
- val customAtomic = atomic.withPostDecisionFailureHandler { (status, failure) => throw failure }
- customAtomic { implicit txn =>
- Txn.afterRollback { _ => throw new UserException }
- if (x() == 0)
- retry
- }
- }
- assert(x.single() === 0)
- }
-
- test("UserException as control flow") {
- val x = Ref(0)
- intercept[UserException] {
- val customAtomic = atomic.withControlFlowRecognizer {
- case x: UserException => true
- }
- customAtomic { implicit txn =>
- x() = 1
- throw new UserException
- }
- }
- assert(x.single() === 1)
- }
-}
diff --git a/benchmarks/scala-stm/scala-stm-library/src/test/scala/scala/concurrent/stm/CommitBarrierSuite.scala b/benchmarks/scala-stm/scala-stm-library/src/test/scala/scala/concurrent/stm/CommitBarrierSuite.scala
deleted file mode 100644
index d28abaae..00000000
--- a/benchmarks/scala-stm/scala-stm-library/src/test/scala/scala/concurrent/stm/CommitBarrierSuite.scala
+++ /dev/null
@@ -1,447 +0,0 @@
-/* scala-stm - (c) 2009-2016, Stanford University, PPL */
-
-package scala.concurrent.stm
-
-import org.scalatest.FunSuite
-import skel.SimpleRandom
-import java.util.concurrent.TimeUnit
-import concurrent.forkjoin.LinkedTransferQueue
-import util.control.Breaks
-
-class CommitBarrierSuite extends FunSuite {
-
- test("single member commit") {
- val x = Ref(0)
- val cb = CommitBarrier(Long.MaxValue)
- val m = cb.addMember()
- val z = m.atomic { implicit t =>
- x() = x() + 1
- "result"
- }
- assert(z === Right("result"))
- assert(x.single() === 1)
- }
-
- test("single member cancel") {
- val x = Ref(0)
- val cb = CommitBarrier(60000)
- val m = cb.addMember()
- val z = m.atomic { implicit t =>
- m.cancel(CommitBarrier.UserCancel("cancel"))
- x() = x() + 1
- "result"
- }
- assert(z === Left(CommitBarrier.UserCancel("cancel")))
- assert(x.single() === 0)
-
- // commit barrier can still be used
- val m2 = cb.addMember()
- val z2 = m2.atomic { implicit t =>
- x() = x() + 1
- "result2"
- }
- assert(z2 === Right("result2"))
- assert(x.single() === 1)
- }
-
- test("single member failure") {
- val x = Ref(0)
- val cb = CommitBarrier(60000)
- val m = cb.addMember()
- intercept[Exception] {
- m.atomic { implicit t =>
- x() = x() + 1
- throw new Exception
- }
- }
- assert(x.single() === 0)
-
- // commit barrier is now dead
- intercept[IllegalStateException] {
- cb.addMember()
- }
- }
-
- test("override executor") {
- val x = Ref(0)
- val cb = CommitBarrier(60000)
- val m = cb.addMember()
- m.executor = m.executor.withRetryTimeout(10)
- intercept[InterruptedException] {
- m.atomic { implicit txn =>
- if (x() == 0)
- retry
- x() = 10
- }
- }
- assert(x.single() === 0)
-
- // commit barrier is now dead
- intercept[IllegalStateException] {
- cb.addMember()
- }
- }
-
- def parRun(n: Int)(body: Int => Unit) {
- // the CountDownLatch is not strictly necessary, but increases the chance
- // of truly concurrent execution
- val startingGate = new java.util.concurrent.CountDownLatch(1)
-
- val failure = Ref(null : Throwable)
-
- val threads = new Array[Thread](n)
- for (i <- 0 until n) {
- threads(i) = new Thread() {
- override def run() {
- startingGate.await()
- try {
- body(i)
- } catch {
- case x : Throwable => failure.single() = x
- }
- }
- }
- threads(i).start()
- }
-
- startingGate.countDown()
-
- for (t <- threads) {
- while (t.isAlive && failure.single() == null) {
- t.join(10)
- }
- }
-
- if (failure.single() != null) {
- throw failure.single()
- }
- }
-
- def runStress(barrierSize: Int,
- barrierCount: Int,
- check: Boolean = true,
- failurePct: Int = 0): Long = {
- val refs = Array.tabulate(barrierSize) { _ => Ref(0) }
- val cbs = Array.tabulate(barrierCount) { _ => CommitBarrier(60000) }
- val members = Array.tabulate(barrierCount, barrierSize) { (i, _) => cbs(i).addMember() }
- val t0 = System.nanoTime
- parRun(barrierSize + (if (check) 1 else 0)) { j =>
- val rand = new SimpleRandom()
- if (j == barrierSize) {
- // we are the cpu-hogging observer
- var prev = 0
- var samples = 0
- while (prev < barrierCount) {
- val x = refs(rand.nextInt(barrierSize)).single()
- assert(x >= prev)
- prev = x
- samples += 1
- if ((samples % 137) == 0) {
- // give single-threaded machines a fighting chance
- Thread.`yield`()
- }
- }
- } else {
- // we are a member
- for (m <- members) {
- // failurePct/2 out of 100% -> cancel before atomic
- // failurePct/2 out of 100% -> cancel inside atomic
- val p = rand.nextInt(200)
- if (p < failurePct)
- m(j).cancel(CommitBarrier.UserCancel("early"))
-
- m(j).atomic { implicit txn =>
- assert(p >= failurePct)
- if (p < failurePct * 2)
- m(j).cancel(CommitBarrier.UserCancel("late, inside"))
- refs(j) += 1
- }
- }
- }
- }
- System.nanoTime - t0
- }
-
- test("stress 2") {
- runStress(2, 10000)
- }
-
- test("stress 10") {
- runStress(10, 500)
- }
-
- test("stress 400") {
- runStress(400, 10)
- }
-
- test("partial success 2") {
- runStress(2, 10000, false, 25)
- }
-
- test("partial success 400") {
- runStress(400, 10, false, 75)
- }
-
- test("perf 2") {
- val count = 20000
- val elapsed = runStress(2, count, false)
- println("commit barrier, 2 threads, " + (elapsed / count) + " nanos/barrier")
- }
-
- test("perf 10") {
- val count = 2000
- val elapsed = runStress(10, count, false)
- println("commit barrier, 10 threads, " + (elapsed / count) + " nanos/barrier")
- }
-
- test("timeout") {
- val refs = Array.tabulate(2) { _ => Ref(0) }
- val cb = CommitBarrier(100, TimeUnit.MILLISECONDS)
- val members = Array.tabulate(2) { _ => cb.addMember() }
- val t0 = System.currentTimeMillis
- val elapsed = Array(0L, 0L)
- parRun(2) { i =>
- try {
- val z = members(i).atomic { implicit txn =>
- refs(i)() = 1
- if (i == 1) Thread.sleep(200)
- }
- assert(z === Left(CommitBarrier.Timeout))
- assert(refs(i).single() === 0)
- } finally {
- elapsed(i) = System.currentTimeMillis - t0
- }
- }
- assert(elapsed(0) >= 100 && elapsed(0) < 150, elapsed.toList)
- assert(elapsed(1) >= 200, elapsed.toList)
- }
-
- test("interrupt") {
- val refs = Array.tabulate(2) { _ => Ref(0) }
- val cb = CommitBarrier(60000)
- val members = Array.tabulate(2) { _ => cb.addMember() }
- val target = new LinkedTransferQueue[Thread]()
- parRun(3) { i =>
- if (i == 0) {
- // thread 0 is slow
- val z = members(i).atomic { implicit txn =>
- refs(i)() = 1
- Thread.sleep(100)
- "result"
- }
- assert(z.isLeft)
- assert(z.left.get.isInstanceOf[CommitBarrier.MemberUncaughtExceptionCause])
- assert(z.left.get.asInstanceOf[CommitBarrier.MemberUncaughtExceptionCause].x.isInstanceOf[InterruptedException])
- assert(refs(i).single() === 0)
- } else if (i == 1) {
- // thread 1 must wait and receives the interrupt
- intercept[InterruptedException] {
- members(i).atomic { implicit txn =>
- refs(i)() = 1
- target.put(Thread.currentThread())
- }
- }
- } else {
- target.take().interrupt()
- }
- }
- }
-
- test("control flow exception") {
- val slower = Ref(0)
- val ref = Ref(0)
- val cb = CommitBarrier(60000)
- val b = new Breaks()
-
- b.breakable {
- while (true) {
- val m = cb.addMember()
- new Thread() {
- override def run() {
- Thread.sleep(100)
- m.atomic { implicit txn =>
- slower() = slower() + 1
- }
- }
- }.start()
- cb.addMember().atomic { implicit txn =>
- ref() = ref() + 1
- b.break
- }
- }
- }
-
- assert(slower.single() === 1)
- assert(ref.single() === 1)
- }
-
- def doCycle(cycleSize: Int) {
- val refs = Array.tabulate(cycleSize) { _ => Ref(0) }
- val cb = CommitBarrier(60000)
- val members = Array.tabulate(cycleSize) { _ => cb.addMember() }
- parRun(cycleSize) { i =>
- val z = members(i).atomic { implicit txn =>
- refs(i) += 1
- refs((i + 1) % cycleSize) += 1
- }
- assert(z.isLeft)
- assert(z.left.get.isInstanceOf[CommitBarrier.MemberCycle])
- }
- }
-
- test("cycle 2 x 1000") {
- for (i <- 0 until 1000)
- doCycle(2)
- }
-
- test("cycle 3 x 1000") {
- for (i <- 0 until 1000)
- doCycle(3)
- }
-
- test("cycle 1000 x 3") {
- for (i <- 0 until 3)
- doCycle(1000)
- }
-
- test("auto-cancel") {
- for (reps <- 0 until 1000) {
- val cb = CommitBarrier(60000)
- var i = 0
- val commits = new java.util.concurrent.atomic.AtomicInteger(0)
- val x = Ref(0)
- val y = Ref(0)
- val z = cb.addMember().atomic { implicit txn =>
- x() = 1
- val m = cb.addMember()
- i += 1
- val t = new Thread() {
- override def run() {
- m.atomic { implicit txn =>
- y() = i
- txn.afterCommit { _ => commits.incrementAndGet() }
- }
- }
- }
- t.start()
- txn.afterCommit { _ => t.join() }
- if (i < 10)
- Txn.rollback(Txn.OptimisticFailureCause('test, None))
- "hello"
- }
- assert(z === Right("hello"))
- assert(commits.get() === 1)
- assert(x.single() === 1)
- assert(y.single() === 10)
- }
- }
-
- test("no auto-cancel") {
- val x = Ref(0)
- val cb = CommitBarrier(60000)
- var t: Thread = null
- val outer = cb.addMember()
- outer.atomic { implicit txn =>
- val inner = cb.addMember(false)
- t = new Thread() {
- override def run() {
- inner.atomic { implicit txn =>
- x() = x() + 1
- }
- }
- }
- t.start()
-
- outer.cancel(CommitBarrier.UserCancel("cancel outer"))
- }
- t.join()
- assert(x.single() === 1)
- }
-
- test("embedded orAtomic") {
- val x = Ref(0)
- val y = Ref(0)
- val z = CommitBarrier(60000).addMember().atomic { implicit txn =>
- atomic { implicit txn =>
- y() = 1
- if (x() == 0)
- retry
- "first"
- } orAtomic { implicit txn =>
- x() = 1
- if (y() == 1)
- retry
- "second"
- }
- }
- assert(z === Right("second"))
- assert(x.single() === 1)
- assert(y.single() === 0)
- }
-
- test("recursive") {
- val commits = Ref(0).single
- def body(m: CommitBarrier.Member, depth: Int)(implicit txn: InTxn) {
- if (depth < 8) {
- for (m <- Array.tabulate(2) { _ => m.commitBarrier.addMember() }) {
- new Thread() {
- override def run() {
- m.atomic { implicit txn =>
- body(m, depth + 1)
- Txn.afterCommit { _ => commits += 1 }
- }
- }
- }.start()
- }
- }
- }
- val m = CommitBarrier(60000).addMember()
- m.atomic { implicit txn => body(m, 0) }
-
- // by sleeping and then awaiting we can (probabilistically) catch both
- // too few and too many commits
- Thread.sleep(100)
- commits.await { _ == 510 }
- }
-
- test("multi-barrier deadlock cycle") {
- for (tries <- 0 to 100) {
- val a1 = Ref(0)
- val a2 = Ref(0)
-
- val cb1 = CommitBarrier(1000)
- val cb1m1 = cb1.addMember()
- val cb1m2 = cb1.addMember()
- val cb2 = CommitBarrier(1000)
- val cb2m1 = cb2.addMember()
- val cb2m2 = cb2.addMember()
-
- val t1 = new Thread() {
- override def run() {
- cb1m1.atomic { implicit txn => a1() = a1() + 1 }
- }
- }
- val t2 = new Thread() {
- override def run() {
- cb1m2.atomic { implicit txn => a2() = a2() + 1 }
- }
- }
- val t3 = new Thread() {
- override def run() {
- cb2m1.atomic { implicit txn => a1() = a1() + 1 }
- }
- }
- val t4 = new Thread() {
- override def run() {
- cb2m2.atomic { implicit txn => a2() = a2() + 1 }
- }
- }
-
- t1.start(); t2.start(); t3.start(); t4.start()
- t1.join(); t2.join(); t3.join(); t4.join()
-
- assert(a1.single() == 2);
- assert(a2.single() == 2);
- }
- }
-}
diff --git a/benchmarks/scala-stm/scala-stm-library/src/test/scala/scala/concurrent/stm/ContentionSuite.scala b/benchmarks/scala-stm/scala-stm-library/src/test/scala/scala/concurrent/stm/ContentionSuite.scala
deleted file mode 100644
index fd04b338..00000000
--- a/benchmarks/scala-stm/scala-stm-library/src/test/scala/scala/concurrent/stm/ContentionSuite.scala
+++ /dev/null
@@ -1,170 +0,0 @@
-/* scala-stm - (c) 2009-2011, Stanford University, PPL */
-
-package scala.concurrent.stm
-
-import org.scalatest.FunSuite
-import skel.SimpleRandom
-
-class ContentionSuite extends FunSuite {
- // probability that two txns of size M touch the same element out of N
- // (M substantially less than N) is about 1 - (1 - M/N)^M
-
- var count = 0
- for (numRefs <- List(1000, 100000)) {
- for (readPct <- List(80)) {
- for (numThreads <- List(4, 32)) {
- for (txnSize <- List(8, 64, 16)) {
- for (nested <- List(false, true)) {
- val opsPerThread = 20000000 / numThreads
- val numReads = opsPerThread * readPct / 100
- val numWrites = opsPerThread - numReads
- val name = "%d refs, %d %% read, %d threads, %d ops/txn, nested=%s".format(
- numRefs, readPct, numThreads, txnSize, nested)
- if (count < 4) {
- test("small " + name) {
- runTest(numRefs, numReads / 10, numWrites / 10, numThreads, txnSize, nested, "small " + name)
- }
- }
- test(name, Slow) {
- runTest(numRefs, numReads, numWrites, numThreads, txnSize, nested, name)
- }
- count += 1
- }
- }
- }
- }
- }
-
- /** Runs one thread per element of `txnSizes`. */
- def runTest(numRefs: Int, numReads: Int, numWrites: Int, numThreads: Int, txnSize: Int, nested: Boolean, name: String) {
- val values = (0 until 37) map { i => "foo" + i }
-
- val refs = Array.tabulate(numRefs) { _ => Ref(values(0)) }
-
- val threads = for (t <- 0 until numThreads) yield new Thread {
- override def run {
- var rand = new SimpleRandom(hashCode)
- var i = 0
- while (i < numReads + numWrites) {
- val body: (InTxn => SimpleRandom) = { implicit txn =>
- val r = rand.clone
- var j = 0
- while (j < txnSize) {
- val key = r.nextInt(numRefs)
- val pct = r.nextInt(numReads + numWrites)
- if (pct < numReads)
- refs(key)()
- else
- refs(key)() = values(r.nextInt(values.length))
- j += 1
- }
- if (r.nextInt(100) < 10) {
- Txn.whilePreparing { _ => }
- Txn.whileCommitting { _ => }
- Txn.setExternalDecider(new Txn.ExternalDecider { def shouldCommit(implicit txn: InTxnEnd) = true })
- }
- r
- }
- if (!nested)
- rand = atomic(body)
- else {
- rand = atomic { implicit txn =>
- atomic(body) orAtomic { implicit txn => throw new Error("execution should not reach here") }
- }
- }
- i += txnSize
- }
- }
- }
-
- val begin = System.currentTimeMillis
- for (t <- threads) t.start()
- for (t <- threads) t.join()
- val elapsed = System.currentTimeMillis - begin
-
- val nanosPerOp = elapsed * 1000000L / ((numReads + numWrites) * 1L * numThreads)
- printf("ContentionSuite: %s, %d nanos/op aggregate throughput\n", name, nanosPerOp)
- }
-
- test("starving elder small") { runElderTest(8, 10) }
- test("starving elder large", Slow) { runElderTest(32, 100) }
-
- def runElderTest(writerCount: Int, numElders: Int) {
- val writersStarted = Ref(0) // elder can't run until all writers are started
- val refs = Array.tabulate(1000) { i => Ref(i.toString) }
- val eldersLeft = Ref(numElders) // writers end after all elders are done
-
- val writers = for(i <- 0 until writerCount) yield new Thread("writer " + i) {
- override def run {
- writersStarted.single += 1
-
- val rand = new skel.SimpleRandom
- while (true) {
- val a = refs(rand.nextInt(refs.length))
- val b = refs(rand.nextInt(refs.length))
- val pct = rand.nextInt(100)
- if (pct < 70) {
- // swap in a txn
- atomic { implicit txn =>
- if (eldersLeft() == 0)
- return
-
- a() = b.swap(a())
- }
- } else {
- if (eldersLeft.single() == 0)
- return
-
- // swap using DCAS or DCASI
- var done = false
- while (!done) {
- val a0 = a.single()
- val b0 = b.single()
- if (pct < 85)
- done = atomic.compareAndSet(a, a0, b0, b, b0, a0)
- else
- done = atomic.compareAndSetIdentity(a, a0, b0, b, b0, a0)
- }
- }
- }
- }
- }
-
- for (w <- writers) w.start()
-
- while (eldersLeft.single() > 0) {
- var tries = 0
- val sum = atomic { implicit txn =>
- tries += 1
- if (writersStarted() < writerCount)
- retry
- refs.foldLeft(0) { _ + _.get.toInt }
- }
- val n = refs.length
- assert(sum === n * (n - 1) / 2)
- eldersLeft.single -= 1
- println("elder ran " + tries + " times")
- }
-
- for (w <- writers) w.join()
- }
-
- test("colliding trySet") {
- val x = Ref(0)
- val total = Ref(0)
- val threads = for (t <- 0 until 10) yield new Thread {
- override def run {
- var failures = 0
- for (i <- 0 until 1000000) {
- if (!x.single.trySet(t))
- failures += 1
- }
- total.single += failures
- }
- }
- for (t <- threads) t.start
- for (t <- threads) t.join
- assert(total.single() > 0)
- println(total.single() + " rejected trySet-s")
- }
-}
\ No newline at end of file
diff --git a/benchmarks/scala-stm/scala-stm-library/src/test/scala/scala/concurrent/stm/FlipperSuite.scala b/benchmarks/scala-stm/scala-stm-library/src/test/scala/scala/concurrent/stm/FlipperSuite.scala
deleted file mode 100644
index 3be9592f..00000000
--- a/benchmarks/scala-stm/scala-stm-library/src/test/scala/scala/concurrent/stm/FlipperSuite.scala
+++ /dev/null
@@ -1,282 +0,0 @@
-/* scala-stm - (c) 2009-2012, Stanford University, PPL */
-
-package scala.concurrent.stm
-
-import java.util.concurrent.CyclicBarrier
-import org.scalatest.FunSuite
-
-
-/** Flipper is derived from a test originally used for the ATLAS HTM prototype.
- *
- * @author Nathan Bronson
- */
-class FlipperSuite extends FunSuite {
- val DEFAULT_SYNC_COUNT = 3
- val DEFAULT_TRANS_COUNT = 100
- val DEFAULT_INSTR_COUNT = 100
- val DEFAULT_THREAD_COUNT = 4
- val DEFAULT_WORD_COUNT = 4096
- val DEFAULT_FLIP_PROB = 0.5f
- val DEFAULT_REF_ARRAY_FACTORY = { (n: Int) => (Array.tabulate[Ref[Int]](n) { _ => Ref(0) }) : IndexedSeq[Ref[Int]] }
- val DEFAULT_MASKED_READER = { (r: Ref[Int], m: Int) => r.single() & m }
-
- val TARRAY_REF_ARRAY_FACTORY = { (n: Int) => TArray.ofDim[Int](n).refs }
-
- val GET_WITH_MASKED_READER = { (r: Ref[Int], m: Int) => r.single.getWith( _ & m ) }
- val RELAXED_GET_MASKED_READER = { (r: Ref[Int], m: Int) =>
- r.single.relaxedGet({ (seen, correct) => (seen & m) == (correct & m) }) & m
- }
- val TRANSFORM_IF_DEFINED_MASKED_READER = { (r: Ref[Int], m: Int) =>
- val f = r.single.transformIfDefined { case v if (v & m) != 0 => v }
- if (f) m else 0
- }
-
- test("small flipper test") {
- Config(
- DEFAULT_SYNC_COUNT,
- DEFAULT_TRANS_COUNT / 2,
- DEFAULT_INSTR_COUNT / 2,
- DEFAULT_THREAD_COUNT,
- DEFAULT_WORD_COUNT / 2,
- DEFAULT_FLIP_PROB,
- 0,
- DEFAULT_REF_ARRAY_FACTORY,
- DEFAULT_MASKED_READER).runTest()
- }
-
- test("small flipper test using getWith") {
- Config(
- DEFAULT_SYNC_COUNT,
- DEFAULT_TRANS_COUNT / 2,
- DEFAULT_INSTR_COUNT / 2,
- DEFAULT_THREAD_COUNT,
- DEFAULT_WORD_COUNT / 2,
- DEFAULT_FLIP_PROB,
- 0,
- DEFAULT_REF_ARRAY_FACTORY,
- GET_WITH_MASKED_READER).runTest()
- }
-
- test("small flipper test using relaxedGet") {
- Config(
- DEFAULT_SYNC_COUNT,
- DEFAULT_TRANS_COUNT / 2,
- DEFAULT_INSTR_COUNT / 2,
- DEFAULT_THREAD_COUNT,
- DEFAULT_WORD_COUNT / 2,
- DEFAULT_FLIP_PROB,
- 0,
- DEFAULT_REF_ARRAY_FACTORY,
- RELAXED_GET_MASKED_READER).runTest()
- }
-
- test("small flipper test reading using transformIfDefined") {
- Config(
- DEFAULT_SYNC_COUNT,
- DEFAULT_TRANS_COUNT / 2,
- DEFAULT_INSTR_COUNT / 2,
- DEFAULT_THREAD_COUNT,
- DEFAULT_WORD_COUNT / 2,
- DEFAULT_FLIP_PROB,
- 0,
- DEFAULT_REF_ARRAY_FACTORY,
- TRANSFORM_IF_DEFINED_MASKED_READER).runTest()
- }
-
- test("default flipper test", Slow) {
- Config(
- DEFAULT_SYNC_COUNT,
- DEFAULT_TRANS_COUNT,
- DEFAULT_INSTR_COUNT,
- DEFAULT_THREAD_COUNT,
- DEFAULT_WORD_COUNT,
- DEFAULT_FLIP_PROB,
- 0,
- DEFAULT_REF_ARRAY_FACTORY,
- DEFAULT_MASKED_READER).runTest()
- }
-
- test("small flipper test w/TArray") {
- Config(
- DEFAULT_SYNC_COUNT,
- DEFAULT_TRANS_COUNT / 2,
- DEFAULT_INSTR_COUNT / 2,
- DEFAULT_THREAD_COUNT,
- DEFAULT_WORD_COUNT / 2,
- DEFAULT_FLIP_PROB,
- 0,
- TARRAY_REF_ARRAY_FACTORY,
- DEFAULT_MASKED_READER).runTest()
- }
-
- test("default flipper test w/TArray", Slow) {
- Config(
- DEFAULT_SYNC_COUNT,
- DEFAULT_TRANS_COUNT,
- DEFAULT_INSTR_COUNT,
- DEFAULT_THREAD_COUNT,
- DEFAULT_WORD_COUNT,
- DEFAULT_FLIP_PROB,
- 0,
- TARRAY_REF_ARRAY_FACTORY,
- DEFAULT_MASKED_READER).runTest()
- }
-
- test("random flipper test", Slow) {
- for (i <- 0 until 1) {
- Config(
- DEFAULT_SYNC_COUNT,
- DEFAULT_TRANS_COUNT,
- DEFAULT_INSTR_COUNT,
- DEFAULT_THREAD_COUNT,
- DEFAULT_WORD_COUNT,
- DEFAULT_FLIP_PROB,
- System.currentTimeMillis + System.nanoTime,
- DEFAULT_REF_ARRAY_FACTORY,
- DEFAULT_MASKED_READER).runTest()
- }
- }
-
- case class Config(syncCount: Int,
- transCount: Int,
- instrCount: Int,
- threadCount: Int,
- wordCount: Int,
- flipProb: Float,
- randSeed: Long,
- refArrayFactory: Int => IndexedSeq[Ref[Int]],
- maskedReader: (Ref[Int], Int) => Int) {
-
- private val len = syncCount*transCount*instrCount*threadCount
- private val rand = new java.util.Random(randSeed)
- val R = Array.tabulate(len)({ _ => rand.nextInt(wordCount) })
- val F = Array.tabulate(len)({ _ => rand.nextDouble() < flipProb })
-
- def index(id: Int, sync: Int, trans: Int, instr: Int) = {
- ((id*syncCount+sync)*transCount+trans)*instrCount+instr
- }
-
- def runTest() {
- println(this)
-
- print("computing sequentially...")
- Console.flush()
-
- val P = Array.tabulate[Ref[Boolean]](len)({ _ => Ref(false) })
- val expected = computeSequential(this, P)
-
- print("\ncomputing in parallel with transactions...")
- Console.flush()
-
- val actual = computeParallelTxn(this, P)
-
- println()
- for (i <- 0 until expected.length) {
- assert(expected(i).single.get === actual(i).single.get)
- }
- }
- }
-
- abstract class FlipperTask(val config: Config,
- val A: IndexedSeq[Ref[Int]],
- val P: Array[Ref[Boolean]],
- val computeP: Boolean,
- val id: Int,
- val sync: Int) extends (() => Unit) {
- def doWork(task: => Unit)
-
- def maskedRead(ref: Ref[Int], mask: Int): Int = config.maskedReader(ref, mask)
- def read[T](ref: Ref[T]): T
- def write[T](ref: Ref[T], v: T)
-
- def apply() {
- val mask = 1 << id
- for (trans <- 0 until config.transCount) {
- doWork {
- for (instr <- 0 until config.instrCount) {
- val i = config.index(id, sync, trans, instr)
- val target = config.R(i)
- val p = maskedRead(A(target), mask) != 0
- if (computeP) {
- write(P(i), p)
- }
- else {
- assert(read(P(i)) === p)
- }
- if (config.F(i)) {
- // do some work before storing to A, to increase probability of a conflict
- var h = i
- var j = 0
- while (j < 10000) {
- h |= 1+((h >>> 1)^(h*13))
- j += 1
- }
- if (h == i) println("?")
- write(A(target), read(A(target)) ^ mask)
- }
- }
- }
- //println("thread " + id + " transaction " + trans + " completed (" + computeP + ")")
- }
- }
- }
-
- def computeSequential(config: Config, P: Array[Ref[Boolean]]): Array[Ref[Int]] = {
- val A = Array.tabulate[Ref[Int]](config.wordCount) { _ => Ref(0) }
- for (sync <- 0 until config.syncCount) {
- for (thread <- 0 until config.threadCount) {
- (new FlipperTask(config, A, P, true, thread, sync) {
- def read[T](ref: Ref[T]): T = ref.single()
- def write[T](ref: Ref[T], v: T) { ref.single() = v }
- def doWork(task: => Unit) { task }
- })()
- }
- }
- A
- }
-
- def computeParallelTxn(config: Config, P: Array[Ref[Boolean]]): IndexedSeq[Ref[Int]] = {
- val A = config.refArrayFactory(config.wordCount)
- for (sync <- 0 until config.syncCount) {
- val tasks = (for (thread <- 0 until config.threadCount) yield {
- new FlipperTask(config, A, P, false, thread, sync) {
- implicit var txn: InTxn = null
-
- def read[T](ref: Ref[T]): T = ref()
- def write[T](ref: Ref[T], v: T) { ref() = v }
- def doWork(task: => Unit) {
- atomic { t =>
- txn = t
- task
- }
- txn = null
- }
- }
- })
- parallelRun(tasks)
- }
- A
- }
-
- private def parallelRun(tasks: Iterable[() => Unit]) {
- val barrier = new CyclicBarrier(tasks.size)
- var failure: Throwable = null
- val threads = for (task <- tasks.toList) yield new Thread {
- override def run() {
- barrier.await
- try {
- task()
- } catch {
- case x: Throwable => {
- x.printStackTrace()
- failure = x
- }
- }
- }
- }
- for (t <- threads) t.start()
- for (t <- threads) t.join()
- if (null != failure)
- throw failure
- }
-}
diff --git a/benchmarks/scala-stm/scala-stm-library/src/test/scala/scala/concurrent/stm/HistogramSuite.scala b/benchmarks/scala-stm/scala-stm-library/src/test/scala/scala/concurrent/stm/HistogramSuite.scala
deleted file mode 100644
index b3486f2d..00000000
--- a/benchmarks/scala-stm/scala-stm-library/src/test/scala/scala/concurrent/stm/HistogramSuite.scala
+++ /dev/null
@@ -1,120 +0,0 @@
-/* scala-stm - (c) 2009-2010, Stanford University, PPL */
-
-package scala.concurrent.stm
-
-import java.util.concurrent.CyclicBarrier
-import org.scalatest.{FunSuite, Tag}
-
-
-class HistogramSuite extends FunSuite {
-
- for ((opsPerTest, name, slow) <- List((10000, "10K", false),
- (1000000, "1M", true))) {
- for (buckets <- List(1, 30, 10000)) {
- for (threads <- List(1, 2, 4, 8, 16, 32, 64, 128, 256, 512) if (threads <= 2*Runtime.getRuntime.availableProcessors)) {
- for (useTArray <- List(false, true)) {
- val str = ("" + buckets + " buckets, " + threads + " threads, " +
- (if (useTArray) "TArray[Int]" else "Array[Ref[Int]]"))
- addTest("single-op-txn, " + str + ", " + name, Slow) {
- histogram(buckets, threads, opsPerTest / threads, useTArray, 100, 1)
- }
-
- for ((accesses, slow2) <- List((1, true), (3, false), (100, true))) {
- addTest("txn, " + str + ", " + accesses + " incr per txn, " + name, Slow) {
- histogram(buckets, threads, opsPerTest / threads, useTArray, 0, accesses)
- }
- val g = if (slow || slow2) List[Tag](Slow) else List.empty[Tag]
- addTest("mix, " + str + ", " + accesses + " incr per txn " + name, g:_*) {
- histogram(buckets, threads, opsPerTest / threads, useTArray, 50, accesses)
- }
- }
- }
- }
- }
- }
-
- private def addTest(name: String, tags: Tag*)(block: => Unit) { test(name, tags:_*)(block) }
-
- def histogram(bucketCount: Int,
- workerCount: Int,
- samplesPerWorker: Int,
- useTArray: Boolean,
- singlePct: Int,
- samplesPerTxn: Int) {
-
- val buckets: IndexedSeq[Ref[Int]] = (if (useTArray) {
- TArray.ofDim[Int](bucketCount).refs
- } else {
- Array.tabulate(bucketCount)({ _ => Ref(0)})
- })
- val threads = new Array[Thread](workerCount)
- val barrier = new CyclicBarrier(workerCount, new Runnable {
- var start = 0L
- def run {
- val now = System.nanoTime
- if (start == 0) {
- start = now
- } else {
- val elapsed = now - start
- println("hist(" + bucketCount + "," + workerCount + "," + samplesPerWorker + "," +
- useTArray + "," + singlePct +
- "," + samplesPerTxn + ") total_elapsed=" + elapsed + " nanos, throughput=" +
- (samplesPerWorker * workerCount * 1000000000L) / elapsed + " ops/sec, per_thread_latency=" +
- elapsed / samplesPerWorker + " nanos/op, avg_arrival=" +
- elapsed / (samplesPerWorker * workerCount) + " nanos/op")
- }
- }
- })
-
- for (worker <- 0 until workerCount) {
- val work = new Runnable {
- def run {
- barrier.await
- var i = 0
- while (i < samplesPerWorker) {
- if (math.abs(hash(i, worker) % 100) < singlePct) {
- if ((i % 2) == 0) {
- buckets(math.abs(hash(worker, i) % bucketCount)).single.transform(_ + 1)
- } else {
- val nt = buckets(math.abs(hash(worker, i) % bucketCount)).single
- var x = nt()
- while (!nt.compareAndSet(x, x + 1)) x = nt()
- }
- i += 1
- } else {
- atomic { implicit t =>
- var j = 0
- while (j < samplesPerTxn && i + j < samplesPerWorker) {
- val tv = buckets(math.abs(hash(worker, i + j) % bucketCount))
- //tv.getAndTransform(_ + 1)
- tv() = tv() + 1
- //tv() = tv.bind.readForWrite + 1
- j += 1
- }
- }
- i += samplesPerTxn
- }
- }
- barrier.await
- }
- }
- if (worker < workerCount - 1) {
- threads(worker) = new Thread(work, "worker " + worker)
- threads(worker).start
- } else {
- work.run
- }
- }
-
- for (worker <- 0 until workerCount - 1) threads(worker).join
-
- val sum = buckets.map(_.single.get).reduceLeft(_+_)
- assert(samplesPerWorker * workerCount === sum)
- }
-
- private def hash(i: Int, j: Int) = {
- var h = i * 37 + j * 101
- h ^= (h >>> 20) ^ (h >>> 12)
- h ^ (h >>> 7) ^ (h >>> 4)
- }
-}
diff --git a/benchmarks/scala-stm/scala-stm-library/src/test/scala/scala/concurrent/stm/InterruptSuite.scala b/benchmarks/scala-stm/scala-stm-library/src/test/scala/scala/concurrent/stm/InterruptSuite.scala
deleted file mode 100644
index 8ab8f320..00000000
--- a/benchmarks/scala-stm/scala-stm-library/src/test/scala/scala/concurrent/stm/InterruptSuite.scala
+++ /dev/null
@@ -1,133 +0,0 @@
-/* scala-stm - (c) 2009-2016, Stanford University, PPL */
-
-package scala.concurrent.stm
-
-import org.scalatest.{Tag, FunSuite}
-import skel.SimpleRandom
-import java.util.concurrent.atomic.AtomicInteger
-
-/** Verifies that blocking STM operations can be interrupted. */
-class InterruptSuite extends FunSuite {
-
-
- test("txn retry arriving interrupt") {
- delayedInterrupt(100)
- val x = Ref(0)
- intercept[InterruptedException] {
- atomic { implicit txn =>
- if (x() == 0) retry
- }
- }
- }
-
- test("txn retry pending interrupt") {
- Thread.currentThread.interrupt()
- val x = Ref(0)
- intercept[InterruptedException] {
- atomic { implicit txn =>
- if (x() == 0) retry
- }
- }
- }
-
- test("single await arriving interrupt") {
- delayedInterrupt(100)
- val x = Ref(0)
- intercept[InterruptedException] {
- x.single.await( _ != 0 )
- }
- }
-
- test("single await pending interrupt") {
- Thread.currentThread.interrupt()
- val x = Ref(0)
- intercept[InterruptedException] {
- x.single.await( _ != 0 )
- }
- }
-
- test("random interrupts during contention") {
- val refs = Array.tabulate(100)( _ => Ref(0) )
- val txnInterrupts = new AtomicInteger
- val nonTxnInterrupts = new AtomicInteger
- var failure = null : Throwable
- lazy val threads: Array[Thread] = Array.tabulate[Thread](10)( _ => new Thread {
- override def run() {
- try {
- for (i <- 0 until 10000) {
- try {
- atomic { implicit txn =>
- for (r <- refs) r() = r() + 1
- }
- } catch {
- case x: InterruptedException => txnInterrupts.incrementAndGet
- }
- for (r <- refs) {
- try {
- r.single += 1
- } catch {
- case x: InterruptedException => nonTxnInterrupts.incrementAndGet
- }
- }
- threads(SimpleRandom.nextInt(threads.length)).interrupt()
- }
- } catch {
- case x: Throwable => failure = x
- }
- }
- })
- for (t <- threads) t.start()
- for (t <- threads) t.join()
- if (failure != null)
- throw failure
- println(txnInterrupts.get + " txn rollbacks, " + nonTxnInterrupts.get + " non-txn interrupts")
- }
-
- //////// machinery for InterruptSuite
-
- private val pendingInterrupts = new ThreadLocal[List[Thread]] { override def initialValue = Nil }
-
- override protected def test(testName: String, testTags: Tag*)(f: => Any)(implicit pos: org.scalactic.source.Position): Unit = {
- super.test(testName, testTags: _*) {
- // we have to use another thread, because sbt overrides .interrupt() on
- // its worker threads
- var failure = null : Throwable
- val t = new Thread {
- override def run() {
- try {
- f
- } catch {
- case x: Throwable => failure = x
- } finally {
- while (!pendingInterrupts.get.isEmpty) {
- try {
- pendingInterrupts.get.head.join()
- pendingInterrupts.set(pendingInterrupts.get.tail)
- } catch {
- case _: Throwable =>
- }
- }
- Thread.interrupted
- }
- }
- }
- t.start()
- t.join()
- if (failure != null)
- throw failure
- }
- }
-
- private def delayedInterrupt(delay: Long) { delayedInterrupt(Thread.currentThread, delay) }
-
- private def delayedInterrupt(target: Thread, delay: Long) {
- val t = new Thread {
- override def run() {
- Thread.sleep(delay)
- target.interrupt()
- }
- }
- pendingInterrupts.set(t :: pendingInterrupts.get)
- t.start()
- }
-}
diff --git a/benchmarks/scala-stm/scala-stm-library/src/test/scala/scala/concurrent/stm/IsolatedRefSuite.scala b/benchmarks/scala-stm/scala-stm-library/src/test/scala/scala/concurrent/stm/IsolatedRefSuite.scala
deleted file mode 100644
index 69930e73..00000000
--- a/benchmarks/scala-stm/scala-stm-library/src/test/scala/scala/concurrent/stm/IsolatedRefSuite.scala
+++ /dev/null
@@ -1,644 +0,0 @@
-/* scala-stm - (c) 2009-2014, Stanford University, PPL */
-
-package scala.concurrent.stm
-
-import org.scalatest.FunSuite
-import java.util.concurrent.TimeUnit
-
-
-/** Performs single-threaded tests of `Ref`. */
-class IsolatedRefSuite extends FunSuite {
-
- // Ref factories produces Ref from an initial value
-
- object PrimitiveIntFactory extends (Int => Ref[Int]) {
- def apply(v0: Int) = Ref(v0)
- override def toString() = "Primitive"
- }
-
- class KnownGenericFactory[A : ClassManifest] extends (A => Ref[A]) {
- def apply(v0: A) = Ref(v0)
- override def toString() = "KnownGeneric"
- }
-
- class UnknownGenericFactory[A] extends (A => Ref[A]) {
- def apply(v0: A) = Ref(v0)
- override def toString() = "UnknownGeneric"
- }
-
- class ArrayElementFactory[A : ClassManifest] extends (A => Ref[A]) {
- def apply(v0: A) = {
- val ref = TArray.ofDim[A](10).refs(5)
- ref.single() = v0
- ref
- }
- override def toString() = "ArrayElement"
- }
-
-
- // This implements Ref.View, but requires a surrounding InTxn context and
- // forwards to Ref's methods.
- class DynamicView[A](val ref: Ref[A]) extends Ref.View[A] {
- implicit def txn = Txn.findCurrent.get
-
- def get: A = ref.get
- def getWith[Z](f: A => Z): Z = ref.getWith(f)
- def relaxedGet(equiv: (A, A) => Boolean): A = ref.relaxedGet(equiv)
- def await(f: A => Boolean) { if (!f(get)) retry }
- def tryAwait(timeout: Long, unit: TimeUnit)(f: A => Boolean): Boolean = f(get) || { retryFor(timeout, unit) ; false }
- def set(v: A) { ref.set(v) }
- def trySet(v: A) = ref.trySet(v)
- def swap(v: A): A = ref.swap(v)
- def compareAndSet(before: A, after: A): Boolean = {
- if (get == before) { set(after) ; true } else false
- }
- def compareAndSetIdentity[B <: A with AnyRef](before: B, after: A): Boolean = {
- if (before eq get.asInstanceOf[AnyRef]) { set(after) ; true } else false
- }
- def transform(f: A => A) { ref.transform(f) }
- def getAndTransform(f: A => A): A = ref.getAndTransform(f)
- def transformAndGet(f: A => A): A = ref.transformAndGet(f)
- override def transformAndExtract[B](f: A => (A,B)): B = ref.transformAndExtract(f)
- def transformIfDefined(pf: PartialFunction[A, A]): Boolean = ref.transformIfDefined(pf)
-
- override def +=(rhs: A)(implicit num: Numeric[A]) { ref += rhs }
- override def -=(rhs: A)(implicit num: Numeric[A]) { ref -= rhs }
- override def *=(rhs: A)(implicit num: Numeric[A]) { ref *= rhs }
- override def /=(rhs: A)(implicit num: Numeric[A]) { ref /= rhs }
-
- override def hashCode: Int = ref.hashCode
- override def equals(rhs: Any): Boolean = ref == rhs
- }
-
- abstract class TestingView[A](innerDepth: Int, val ref: Ref[A]) extends Ref.View[A] {
- private def wrap[Z](block: => Z): Z = nest(innerDepth, block)
- private def nest[Z](d: Int, block: => Z): Z = {
- if (d == 0)
- block
- else
- atomic { implicit txn => nest(d - 1, block) }
- }
-
- protected def view: Ref.View[A]
-
- def get: A = wrap { view.get }
- def getWith[Z](f: A => Z): Z = wrap { view.getWith(f) }
- def relaxedGet(equiv: (A, A) => Boolean): A = wrap { view.relaxedGet(equiv) }
- def await(f: (A) => Boolean) { wrap { view.await(f) } }
- def tryAwait(timeout: Long, unit: TimeUnit)(f: (A) => Boolean): Boolean = wrap { view.tryAwait(timeout, unit)(f) }
- def set(v: A) { wrap { view.set(v) } }
- def trySet(v: A) = wrap { view.trySet(v) }
- def swap(v: A): A = wrap { view.swap(v) }
- def compareAndSet(before: A, after: A): Boolean = wrap { view.compareAndSet(before, after) }
- def compareAndSetIdentity[B <: A with AnyRef](before: B, after: A): Boolean = wrap { view.compareAndSetIdentity(before, after) }
- def transform(f: A => A) { wrap { view.transform(f) } }
- def getAndTransform(f: A => A): A = wrap { view.getAndTransform(f) }
- def transformAndGet(f: A => A): A = wrap { view.transformAndGet(f) }
- override def transformAndExtract[B](f: A => (A,B)): B = wrap { view.transformAndExtract(f) }
- def transformIfDefined(pf: PartialFunction[A, A]): Boolean = wrap { view.transformIfDefined(pf) }
-
- override def +=(rhs: A)(implicit num: Numeric[A]) { wrap { view += rhs } }
- override def -=(rhs: A)(implicit num: Numeric[A]) { wrap { view -= rhs } }
- override def *=(rhs: A)(implicit num: Numeric[A]) { wrap { view *= rhs } }
- override def /=(rhs: A)(implicit num: Numeric[A]) { wrap { view /= rhs } }
-
- override def hashCode: Int = ref.hashCode
- override def equals(rhs: Any): Boolean = ref == rhs
- }
-
- trait ViewFactory {
- def apply[A](ref: Ref[A], innerDepth: Int): Ref.View[A]
- }
-
- object SingleAccess extends ViewFactory {
- def apply[A](ref: Ref[A], innerDepth: Int): Ref.View[A] = new TestingView[A](innerDepth, ref) {
- protected def view = ref.single
- }
- override def toString = "Single"
- }
-
- object RefAccess extends ViewFactory {
- def apply[A](ref: Ref[A], innerDepth: Int): Ref.View[A] = new TestingView[A](innerDepth, ref) {
- protected val view = new DynamicView[A](ref)
- }
- override def toString = "Ref"
- }
-
- // The test environment is determined by
- // outerLevels: the number of atomic block nesting levels that surround
- // the entire test;
- // innerLevels: the number of atomic block nesting levels that surround
- // the individual operations of the test;
- // refFactory: Ref[Int] can be created with or without the appropriate
- // manifest, or via the overloaded Ref.apply(Int); and
- // viewFactory: one of FreshSingleAccess, ReuseSingleAccess, or RefAccess
- // (which requires outerLevels + innerLevels > 0).
- //
- // Now we enumerate the environments, generating a set of tests for each
- // configuration.
-
- private def createTests[A : ClassManifest](name: String, v0: A)(block: (() => Ref.View[A]) => Unit) {
- test(name) {
- for (outerLevels <- 0 until 2;
- innerLevels <- 0 until 2;
- refFactory <- List(new KnownGenericFactory[A], new UnknownGenericFactory[A], new ArrayElementFactory[A]);
- viewFactory <- List(SingleAccess, RefAccess)
- if !(innerLevels + outerLevels == 0 && viewFactory == RefAccess)) {
- val current = "outer=" + outerLevels + ", inner=" + innerLevels + ", " + refFactory + ", " + viewFactory
- try {
- val ref = refFactory(v0)
- def getView = viewFactory(ref, innerLevels)
- nest(outerLevels) { block(getView _) }
- } catch {
- case x: Throwable => {
- println(name + " failed for " + current)
- fail(current + ": " + name + " failure", x)
- }
- }
- }
- }
- }
-
- test("primitive factory and ClassManifest generic produce same type") {
- // this cuts down on the proliferation of tests
- val g = new KnownGenericFactory[Int]
- assert(PrimitiveIntFactory(10).getClass === g(10).getClass)
- }
-
- private def nest(depth: Int)(block: => Unit) {
- if (depth == 0)
- block
- else
- atomic { implicit txn => nest(depth - 1)(block) }
- }
-
- createTests("get and set", 1) { view =>
- for (i <- 1 until 10) {
- assert(view()() === i)
- view()() = view()() + 1
- }
- assert(view()() === 10)
- }
-
- createTests("get and trySet", 1) { view =>
- for (i <- 1 until 10) {
- assert(view()() === i)
- val f = view().trySet(view()() + 1)
- assert(f) // trySet shouldn't fail in the absence of contention
- }
- assert(view()() === 10)
- }
-
- createTests("compareAndSet", 1) { view =>
- for (i <- 1 until 10) {
- assert(view()() === i)
- assert(!view().compareAndSet(0, -1))
- assert(view().compareAndSet(i, i + 1))
- assert(!view().compareAndSet(i, i + 1))
- }
- assert(view()() === 10)
- }
-
- createTests("swap", 1) { view =>
- for (i <- 1 until 10) {
- assert(view().swap(i + 1) === i)
- }
- assert(view()() === 10)
- }
-
- createTests("set + swap", 1) { view =>
- for (i <- 1 until 10) {
- view()() = -1
- assert(view().swap(i + 1) === -1)
- }
- assert(view()() === 10)
- }
-
- createTests("transform", 1) { view =>
- for (i <- 1 until 10) {
- assert(view()() === i)
- view().transform(_ + 1)
- }
- assert(view()() === 10)
- }
-
- createTests("getAndTransform", 1) { view =>
- for (i <- 1 until 10) {
- assert(view()() === i)
- assert(view().getAndTransform(_ + 1) === i)
- }
- assert(view()() === 10)
- }
-
- createTests("transformAndGet", 1) { view =>
- for (i <- 1 until 10) {
- assert(view()() === i)
- assert(view().transformAndGet(_ + 1) === i + 1)
- }
- assert(view()() === 10)
- }
-
- createTests("transformAndExtract", 1) { view =>
- for (i <- 1 until 10) {
- assert(view()() === i)
- assert(view().transformAndExtract { i => (i+1, ""+i) } === ""+i)
- }
- assert(view()() === 10)
- }
-
- createTests("transformIfDefined", 1) { view =>
- for (i <- 1 until 10) {
- assert(view()() === i)
- assert(!(view().transformIfDefined {
- case 0 => -1
- }))
- assert(view().transformIfDefined {
- case x if x > 0 => {
- assert(x === i)
- x + 1
- }
- })
- }
- assert(view()() === 10)
- }
-
- createTests("+= 1", 1) { view =>
- for (i <- 1 until 10) {
- assert(view()() === i)
- view() += 1
- }
- assert(view()() === 10)
- }
-
- createTests("-= -1", 1) { view =>
- for (i <- 1 until 10) {
- assert(view()() === i)
- view() -= -1
- }
- assert(view()() === 10)
- }
-
- createTests("*= 2", 1) { view =>
- for (i <- 1 until 10) {
- view() *= 2
- }
- assert(view()() === 512)
- }
-
- createTests("getWith", 1) { view =>
- assert(view().getWith(_ * 10) === 10)
- }
-
- createTests("write ; getWith", 1) { view =>
- view()() = 2
- assert(view().getWith(_ * 10) === 20)
- }
-
- createTests("getWith ; write", 1) { view =>
- assert(view().getWith(_ * 10) === 10)
- view()() = 2
- }
-
- createTests("relaxedGet", 10) { view =>
- assert(view().relaxedGet( _ == _ ) === 10)
- }
-
- createTests("write ; relaxedGet", 10) { view =>
- view()() = 20
- assert(view().relaxedGet( _ == _ ) === 20)
- }
-
- createTests("relaxedGet ; write", 10) { view =>
- assert(view().relaxedGet( _ == _ ) === 10)
- view()() = 20
- }
-
- createTests("initially true await", 10) { view =>
- view().await( _ == 10 )
- }
-
- createTests("initially true tryAwait", 10) { view =>
- assert(view().tryAwait(10000)( _ == 10 ))
- }
-
- createTests("false tryAwait with a zero timeout", 10) { view =>
- assert(!view().tryAwait(0)( _ == 20 ))
- }
-
- class UserException extends Exception
-
- createTests("excepting transform", 1) { view =>
- intercept[UserException] {
- view().transform(v => throw new UserException)
- }
- assert(view().get === 1)
- view().transform(_ + 1)
- assert(view().get === 2)
- }
-
- createTests("excepting transformIfDefined", 1) { view =>
- intercept[UserException] {
- view().transformIfDefined {
- case v if v > 0 => throw new UserException
- case v => v * 100
- }
- }
- assert(view().get === 1)
- view().transform(_ + 1)
- assert(view().get === 2)
- }
-
- class AngryEquals(val polarity: Boolean) {
- override def equals(rhs: Any): Boolean = {
- if (this eq rhs.asInstanceOf[AnyRef])
- true
- else {
- // equal polarities actively repel
- if (rhs.asInstanceOf[AngryEquals].polarity == polarity)
- throw new UserException
- false
- }
- }
- }
-
- createTests(".equals not involved in get and set", new AngryEquals(true)) { view =>
- assert(view().get ne null)
- view()() = new AngryEquals(true)
- }
-
- createTests("excepting compareAndSet", new AngryEquals(true)) { view =>
- val prev = view()()
- intercept[UserException] {
- view().compareAndSet(new AngryEquals(true), new AngryEquals(true))
- }
- assert(!view().compareAndSet(new AngryEquals(false), new AngryEquals(true)))
- val repl = new AngryEquals(false)
- assert(view().compareAndSet(prev, repl))
- assert(view().get === repl)
- }
-
- createTests("compareAndSetIdentity", "orig") { view =>
- assert(!view().compareAndSetIdentity(new String("orig"), "equal"))
- assert(view().compareAndSetIdentity("orig", "eq"))
- assert(view().get === "eq")
- }
-
- createTests("-= -1 long", Int.MaxValue + 1L) { view =>
- for (i <- 1L until 10L) {
- assert(view()() === Int.MaxValue + i)
- view() -= -1
- }
- assert(view()() === Int.MaxValue + 10L)
- }
-
- createTests("/=", 11) { view =>
- view() /= 2
- assert(view()() === 5)
- }
-
- createTests("/= double", 11.0) { view =>
- view() /= 2
- assert(view()() === 5.5)
- }
-
- createTests("/= float", 11.0f) { view =>
- view() /= 2
- assert(view()() === 5.5f)
- }
-
- createTests("BigInt ops", BigInt("1234")) { view =>
- view() += 1
- assert(view()().toString === "1235")
- view() -= 2
- assert(view()().toString === "1233")
- view() *= 3
- assert(view()().toString === "3699")
- view() /= 4
- assert(view()().toString === "924")
- }
-
- createTests("BigDecimal ops", BigDecimal("1234")) { view =>
- view() += 1
- assert(view()().toString === "1235")
- view() -= 2
- assert(view()().toString === "1233")
- view() *= 3
- assert(view()().toString === "3699")
- view() /= 4
- assert(view()().toString === "924.75")
- }
-
- createTests("TxnDebuggable", 10) { view =>
- assert(view().dbgStr === "Ref(10)")
- assert(view().dbgValue === 10)
- view()() = 11
- assert(view().dbgStr === "Ref(11)")
- assert(view().dbgValue === 11)
- }
-
- private def perTypeTests[A : ClassManifest](v0: A, v1: A) {
- val name = v0.asInstanceOf[AnyRef].getClass.getSimpleName
-
- createTests(name + " simple get+set", v0) { view =>
- assert(view()() === v0)
- view()() = v1
- assert(view()() === v1)
- }
-
- createTests(name + " Ref equality", v0) { view =>
- assert(view().asInstanceOf[Any] == view())
- assert(view().ref.asInstanceOf[Any] == view())
- assert(view().asInstanceOf[Any] == view().ref)
- assert(view().ref.asInstanceOf[Any] == view().ref)
- assert(view().ref.single.asInstanceOf[Any] == view())
- assert(view().asInstanceOf[Any] != Ref(v0))
- assert(view().asInstanceOf[Any] != "abc")
- }
-
- test(name + " TArray Ref equality") {
- val a = TArray(Seq(v0))
- assert(a.refs(0).asInstanceOf[Any] == a.refs(0))
- assert(a.single.refViews(0).asInstanceOf[Any] == a.refs(0))
- assert(a.single.refViews(0).ref.asInstanceOf[Any] == a.refs(0))
- assert(a.single.refViews(0).asInstanceOf[Any] == a.single.refViews(0))
- assert(a.refs(0).asInstanceOf[Any] == a.refs(0).single)
- assert(a.single.tarray.refs(0).asInstanceOf[Any] == a.refs(0).single)
- assert(a.refs(0).asInstanceOf[Any] != "abc")
- }
-
- test(name + " TArray Ref inequality between arrays") {
- val a = TArray(Seq(v0))
- val b = TArray(Seq(v1))
- assert(b.refs(0).asInstanceOf[Any] != a.refs(0))
- assert(b.single.refViews(0).asInstanceOf[Any] != a.refs(0))
- assert(b.single.refViews(0).ref.asInstanceOf[Any] != a.refs(0))
- assert(b.single.refViews(0).asInstanceOf[Any] != a.single.refViews(0))
- assert(b.refs(0).asInstanceOf[Any] != a.refs(0).single)
- assert(b.single.tarray.refs(0).asInstanceOf[Any] != a.refs(0).single)
- }
- }
-
- perTypeTests(false, true)
- perTypeTests(1 : Byte, 2 : Byte)
- perTypeTests(1 : Short, 2 : Short)
- perTypeTests('1', '2')
- perTypeTests(1, 2)
- perTypeTests(1.0f, 2.0f)
- perTypeTests(1L, 2L)
- perTypeTests(1.0, 2.0)
- perTypeTests((), ())
- perTypeTests("1", "2")
-
- test("TArray Ref inequality between indices") {
- val a = TArray.ofDim[Int](1000)
- println(a.refs(0))
- for (i <- 1 until 1000) {
- assert(a.refs(i).asInstanceOf[Any] != a.refs(0))
- assert(a.single.refViews(i).asInstanceOf[Any] != a.refs(0))
- assert(a.single.refViews(i).ref.asInstanceOf[Any] != a.refs(0))
- assert(a.single.refViews(i).asInstanceOf[Any] != a.single.refViews(0))
- assert(a.refs(i).asInstanceOf[Any] != a.refs(0).single)
- assert(a.single.tarray.refs(i).asInstanceOf[Any] != a.refs(0).single)
- }
- }
-
- test("TArray index checking") {
- val a = TArray.ofDim[String](10)
- for (i <- List(-1, 10, Int.MinValue, Int.MaxValue)) {
- intercept[ArrayIndexOutOfBoundsException] { a.single(i) }
- intercept[ArrayIndexOutOfBoundsException] { a.single(i) = "abc" }
- intercept[ArrayIndexOutOfBoundsException] { a.single.refViews(i) }
- intercept[ArrayIndexOutOfBoundsException] { a.refs(i) }
- intercept[ArrayIndexOutOfBoundsException] { atomic { implicit txn => a(i) } }
- intercept[ArrayIndexOutOfBoundsException] { atomic { implicit txn => a(i) = "abc" } }
- }
- }
-
- test("TArray length") {
- val a = TArray.ofDim[String](10)
- assert(a.length === 10)
- assert(a.single.length === 10)
- assert(a.refs.length === 10)
- assert(a.single.refViews.length === 10)
-
- val b = TArray.ofDim[String](0)
- assert(b.single.isEmpty)
- }
-
- test("TArray TxnDebuggable") {
- val a = TArray.ofDim[String](3)
- a.single(0) = "zero"
- a.refs(1).single() = "one"
- atomic { implicit txn => a(2) = "two" }
-
- assert(a.dbgStr === "TArray[size=3](zero, one, two)")
- val aa = a.dbgValue.asInstanceOf[Array[String]]
- assert(aa.length === 3)
- assert(aa(0) === "zero")
- assert(aa(1) === "one")
- assert(aa(2) === "two")
- }
-
- class ProxyRef[A](underlying: Ref[A]) extends Ref[A] {
- override def single = throw new AbstractMethodError
- def get(implicit txn: InTxn) = throw new AbstractMethodError
- def getWith[Z](f: (A) => Z)(implicit txn: InTxn) = throw new AbstractMethodError
- def relaxedGet(equiv: (A, A) => Boolean)(implicit txn: InTxn) = throw new AbstractMethodError
- def set(v: A)(implicit txn: InTxn) { throw new AbstractMethodError }
- def trySet(v: A)(implicit txn: InTxn) = throw new AbstractMethodError
- def swap(v: A)(implicit txn: InTxn) = throw new AbstractMethodError
- def transform(f: (A) => A)(implicit txn: InTxn) { throw new AbstractMethodError }
- def transformIfDefined(pf: PartialFunction[A, A])(implicit txn: InTxn) = throw new AbstractMethodError
-
- override def hashCode = underlying.hashCode
- override def equals(rhs: Any) = underlying.equals(rhs)
- }
-
- test("proxy Ref equality") {
- val lhs = Ref(10)
- val rhs = new ProxyRef(lhs)
- assert(lhs == rhs)
- assert(rhs == lhs)
- assert(rhs == rhs)
- assert(rhs != Ref(5))
- assert(Ref(5) != rhs)
- }
-
- test("TxnExecutor.compareAndSet") {
- val x = Ref("abc")
- val y = Ref("10")
- assert(!atomic.compareAndSet(x, "abc", "def", y, "11", "20"))
- assert(x.single() === "abc")
- assert(y.single() === "10")
- assert(!atomic.compareAndSet(x, "ABC", "def", y, "10", "20"))
- assert(x.single() === "abc")
- assert(y.single() === "10")
- assert(atomic.compareAndSet(x, "abc", "def", y, 10.toString, "20"))
- assert(x.single() === "def")
- assert(y.single() === "20")
- }
-
- test("TxnExecutor.compareAndSet non-txn exhaustive") {
- for (x0 <- List("abc", "ABC") ; x1 <- List("abc", "ABC") ; y0 <- List("def", "DEF") ; y1 <- List("def", "DEF")) {
- val x = Ref("abc")
- val y = Ref("def")
- val f = atomic.compareAndSet(x, x0, x1, y, y0, y1)
- if (f) {
- assert(x0 === "abc")
- assert(y0 === "def")
- assert(x.single() === x1)
- assert(y.single() === y1)
- } else {
- assert(x0 != "abc" || y0 != "def")
- }
- }
- }
-
- test("TxnExecutor.compareAndSet txn exhaustive") {
- for (x0 <- List("abc", "ABC") ; x1 <- List("abc", "ABC") ; y0 <- List("def", "DEF") ; y1 <- List("def", "DEF")) {
- val x = Ref("abc")
- val y = Ref("def")
- val f = atomic { implicit txn => atomic.compareAndSet(x, x0, x1, y, y0, y1) }
- if (f) {
- assert(x0 === "abc")
- assert(y0 === "def")
- assert(x.single() === x1)
- assert(y.single() === y1)
- } else {
- assert(x0 != "abc" || y0 != "def")
- }
- }
- }
-
- test("TxnExecutor.compareAndSetIdentity non-txn exhaustive") {
- for (x0 <- List("abc", "ABC") ; x1 <- List("abc", "ABC") ; y0 <- List("def", "DEF") ; y1 <- List("def", "DEF")) {
- val x = Ref("abc")
- val y = Ref("def")
- val f = atomic.compareAndSetIdentity(x, x0, x1, y, y0, y1)
- if (f) {
- assert(x0 === "abc")
- assert(y0 === "def")
- assert(x.single() === x1)
- assert(y.single() === y1)
- } else {
- assert(x0 != "abc" || y0 != "def")
- }
- }
- }
-
- test("TxnExecutor.compareAndSetIdentity txn exhaustive") {
- for (x0 <- List("abc", "ABC") ; x1 <- List("abc", "ABC") ; y0 <- List("def", "DEF") ; y1 <- List("def", "DEF")) {
- val x = Ref("abc")
- val y = Ref("def")
- val f = atomic { implicit txn => atomic.compareAndSetIdentity(x, x0, x1, y, y0, y1) }
- if (f) {
- assert(x0 === "abc")
- assert(y0 === "def")
- assert(x.single() === x1)
- assert(y.single() === y1)
- } else {
- assert(x0 != "abc" || y0 != "def")
- }
- }
- }
-}
diff --git a/benchmarks/scala-stm/scala-stm-library/src/test/scala/scala/concurrent/stm/JavaAPISuite.scala b/benchmarks/scala-stm/scala-stm-library/src/test/scala/scala/concurrent/stm/JavaAPISuite.scala
deleted file mode 100644
index ef53960d..00000000
--- a/benchmarks/scala-stm/scala-stm-library/src/test/scala/scala/concurrent/stm/JavaAPISuite.scala
+++ /dev/null
@@ -1,7 +0,0 @@
-/* scala-stm - (c) 2009-2012, Stanford University, PPL */
-
-package scala.concurrent.stm
-
-import org.scalatest.junit.JUnitWrapperSuite
-
-class JavaAPISuite extends JUnitWrapperSuite("scala.concurrent.stm.JavaAPITests", Thread.currentThread.getContextClassLoader)
diff --git a/benchmarks/scala-stm/scala-stm-library/src/test/scala/scala/concurrent/stm/MaybeTxnSuite.scala b/benchmarks/scala-stm/scala-stm-library/src/test/scala/scala/concurrent/stm/MaybeTxnSuite.scala
deleted file mode 100644
index a5a82a92..00000000
--- a/benchmarks/scala-stm/scala-stm-library/src/test/scala/scala/concurrent/stm/MaybeTxnSuite.scala
+++ /dev/null
@@ -1,90 +0,0 @@
-/* scala-stm - (c) 2009-2010, Stanford University, PPL */
-
-package scala.concurrent.stm
-
-import org.scalatest.FunSuite
-
-class MaybeTxnSuite extends FunSuite {
- test("implicit InTxn match") {
- implicit val txn: InTxn = new skel.StubInTxn
-
- assert(implicitly[MaybeTxn] eq txn)
- }
-
- test("implicit TxnUnknown match") {
- assert(implicitly[MaybeTxn] eq TxnUnknown)
- }
-
- test("TxnUnknown is found") {
- assert(context eq TxnUnknown)
- }
-
- test("InTxn is found") {
- atomic { t0 =>
- implicit val t = t0
- assert(context eq t)
- }
- atomic { implicit t =>
- assert(context eq t)
- }
- }
-
- private def context(implicit mt: MaybeTxn) = mt
-
- test("Static nesting lookup") {
- val x = Ref(10)
- atomic { implicit t =>
- assert(x() === 10)
- x() = 11
- atomic { implicit t =>
- assert(x() === 11)
- x() = 12
- atomic { implicit t =>
- assert(x() === 12)
- x() = 13
- }
- assert(x() === 13)
- }
- assert(x() === 13)
- }
- assert(x.single() === 13)
- }
-
- test("Dynamic nesting lookup") {
- val x = Ref(10)
- val xs = x.single
- def loop(expected: Int) {
- atomic { implicit t =>
- assert(x() === expected)
- assert(xs() === expected)
- x() = expected + 1
- if (expected < 100)
- loop(expected + 1)
- assert(x() === 101)
- }
- }
- loop(10)
- assert(xs() === 101)
- assert(x.single() === 101)
- }
-
- test("Static vs dynamic lookup") {
- implicit var t0: InTxn = null
- val n0 = atomic { t =>
- t0 = t
- assert(Txn.findCurrent === Some(t))
- assert(impl.STMImpl.instance.findCurrent === Some(t))
- NestingLevel.root
- }
- assert(n0.status === Txn.Committed)
- assert(Txn.findCurrent === None)
- assert(impl.STMImpl.instance.findCurrent === None)
- atomic { t =>
- assert(NestingLevel.current(t) != n0)
- assert(NestingLevel.root(t).status === Txn.Active)
- assert(Txn.status === Txn.Active)
- assert(Txn.findCurrent === Some(t))
- assert(impl.STMImpl.instance.findCurrent === Some(t))
- }
- }
-}
diff --git a/benchmarks/scala-stm/scala-stm-library/src/test/scala/scala/concurrent/stm/RelaxedValidationSuite.scala b/benchmarks/scala-stm/scala-stm-library/src/test/scala/scala/concurrent/stm/RelaxedValidationSuite.scala
deleted file mode 100644
index 5c321ffc..00000000
--- a/benchmarks/scala-stm/scala-stm-library/src/test/scala/scala/concurrent/stm/RelaxedValidationSuite.scala
+++ /dev/null
@@ -1,184 +0,0 @@
-/* scala-stm - (c) 2009-2011, Stanford University, PPL */
-
-package scala.concurrent.stm
-
-import org.scalatest.FunSuite
-import java.util.concurrent.CountDownLatch
-
-
-/** Tests of the relaxed validation methods `getWith` and `relaxedGet` in
- * multi-threaded contexts. Single-threaded tests are found in
- * `IsolatedRefSuite` and more multi-threaded tests are embedded in
- * `FlipperSuite`.
- */
-class RelaxedValidationSuite extends FunSuite {
-
- test("self-write vs getWith") {
- val x = Ref(0)
- atomic { implicit txn =>
- assert(x.getWith { _ & 1 } === 0)
- x() = 1
- }
- assert(x.single() === 1)
- }
-
- test("self-write vs getWith with interference") {
- val x = Ref(0)
- val b1 = new CountDownLatch(1)
- val b2 = new CountDownLatch(1)
-
- (new Thread { override def run {
- b1.await()
- x.single() = 2
- b2.countDown()
- } }).start
-
- atomic { implicit txn =>
- assert(x.getWith { _ & 1 } === 0)
- b1.countDown()
- b2.await()
- assert(x.swap(1) === 2)
- }
- assert(x.single() === 1)
- }
-
- test("getWith multiple revalidations") {
- val x = Ref("abc")
-
- // sleep is okay for this test because all interleavings should pass
-
- (new Thread {
- override def run {
- for (i <- 0 until 10) {
- Thread.sleep(10)
- x.single.transform { _ + "X" }
- }
- x.single() = ""
- }
- }).start
-
- assert(atomic { implicit txn =>
- for (i <- 0 until 10) {
- x.getWith { _.take(3) }
- Thread.sleep(15)
- }
- x.getWith { _.take(3) }
- } === "")
- }
-
- test("self-write vs failing transformIfDefined") {
- val x = Ref(0)
- atomic { implicit txn =>
- assert(!x.transformIfDefined {
- case 1 => 2
- })
- x() = 1
- }
- assert(x.single() === 1)
- }
-
- test("self-write vs failing transformIfDefined with interference") {
- val x = Ref(0)
- val b1 = new CountDownLatch(1)
- val b2 = new CountDownLatch(1)
-
- (new Thread { override def run {
- b1.await()
- x.single() = 2
- b2.countDown()
- } }).start
-
- atomic { implicit txn =>
- assert(!x.transformIfDefined {
- case v if (v & 1) != 0 => v
- })
- b1.countDown()
- b2.await()
- assert(x.swap(1) === 2)
- }
- assert(x.single() === 1)
- }
-
- test("self-write vs relaxedGet") {
- val x = Ref(0)
- atomic { implicit txn =>
- assert(x.relaxedGet( _ == _ ) === 0)
- x() = 1
- }
- assert(x.single() === 1)
- }
-
- test("self-write vs relaxedGet with interference") {
- val x = Ref(0)
- val b1 = new CountDownLatch(1)
- val b2 = new CountDownLatch(1)
-
- (new Thread { override def run {
- b1.await()
- x.single() = 2
- b2.countDown()
- } }).start
-
- atomic { implicit txn =>
- assert(x.relaxedGet({ (seen, correct) => (seen & 1) == (correct & 1) }) === 0)
- b1.countDown()
- b2.await()
- assert(x.swap(1) === 2)
- }
- assert(x.single() === 1)
- }
-
- test("relaxedGet multiple accepting revalidations") {
- val x = Ref("abc")
-
- // sleep is okay for this test because all interleavings should pass
-
- (new Thread {
- override def run {
- for (i <- 0 until 10) {
- Thread.sleep(10)
- x.single.transform { _ + "X" }
- }
- x.single() = ""
- }
- }).start
-
- val (first, last) = atomic { implicit txn =>
- val first = x.relaxedGet( (_, _) => true )
- for (i <- 0 until 10) {
- x.relaxedGet( (_, _) => true )
- Thread.sleep(15)
- }
- (first, x.relaxedGet( (_, _) => true ))
- }
- assert(first === "abc")
- assert(last === "")
- }
-
- test("relaxedGet multiple ending with equality check") {
- val x = Ref("abc")
-
- // sleep is okay for this test because all interleavings should pass
-
- (new Thread {
- override def run {
- for (i <- 0 until 10) {
- Thread.sleep(10)
- x.single.transform { _ + "X" }
- }
- x.single() = ""
- }
- }).start
-
- val (first, last) = atomic { implicit txn =>
- val first = x.relaxedGet( _.isEmpty == _.isEmpty )
- for (i <- 0 until 10) {
- x.relaxedGet( _.isEmpty == _.isEmpty )
- Thread.sleep(15)
- }
- (first, x.relaxedGet( _ == _ ))
- }
- assert(first === "")
- assert(last === "")
- }
-}
\ No newline at end of file
diff --git a/benchmarks/scala-stm/scala-stm-library/src/test/scala/scala/concurrent/stm/RetrySuite.scala b/benchmarks/scala-stm/scala-stm-library/src/test/scala/scala/concurrent/stm/RetrySuite.scala
deleted file mode 100644
index e464f536..00000000
--- a/benchmarks/scala-stm/scala-stm-library/src/test/scala/scala/concurrent/stm/RetrySuite.scala
+++ /dev/null
@@ -1,520 +0,0 @@
-/* scala-stm - (c) 2009-2012, Stanford University, PPL */
-
-package scala.concurrent.stm
-
-import org.scalatest.FunSuite
-import java.util.concurrent.{ CountDownLatch, TimeUnit }
-
-/** Contains extended tests of `retry`, `retryFor` and `tryAwait`. Some basic
- * tests are included in `TxnSuite`.
- */
-class RetrySuite extends FunSuite {
-
- def timingAssert(ok: Boolean) {
- if (!ok) {
- val x = new Exception("timing-sensitive check failed, continuing")
- x.printStackTrace()
- }
- }
-
- test("retry set accumulation across alternatives") {
- val x = Ref(false)
- val b = new CountDownLatch(1)
-
- // this prevents the test from deadlocking
- new Thread("trigger") {
- override def run {
- b.await()
- Thread.sleep(10)
- x.single() = true
- }
- } start
-
- atomic { implicit t =>
- // The following txn and its alternative decode the value of x that was
- // observed, without x being a part of the current read set.
- val f = atomic { implicit t =>
- atomic { implicit t =>
- // this txn encodes the read of x in its retry state
- if (!x()) retry
- }
- true
- } orAtomic { implicit t =>
- false
- }
- if (!f) {
- // we've correctly observed x() == false, now arrange for true
- b.countDown()
- retry
- }
- }
- }
-
- test("tryAwait is conservative") {
- val x = Ref(10)
- val t0 = System.currentTimeMillis
- assert(!x.single.tryAwait(100)( _ == 0 ))
- val elapsed = System.currentTimeMillis - t0
- assert(elapsed >= 100)
- println("tryAwait(.., 100) took " + elapsed + " millis")
- }
-
- test("tryAwait in atomic is conservative") {
- val x = Ref(10)
- val t0 = System.currentTimeMillis
- val f = atomic { implicit txn => x.single.tryAwait(100)( _ == 0 ) }
- assert(!f)
- val elapsed = System.currentTimeMillis - t0
- assert(elapsed >= 100)
- println("tryAwait(.., 100) inside atomic took " + elapsed + " millis")
- }
-
- test("retryFor is conservative") {
- val x = Ref(false)
- val t0 = System.currentTimeMillis
- val s = atomic { implicit txn =>
- if (!x()) retryFor(100)
- "timeout"
- }
- assert(s === "timeout")
- val elapsed = System.currentTimeMillis - t0
- assert(elapsed >= 100)
- println("retryFor(100) took " + elapsed + " millis")
- }
-
- test("retryFor earliest is first") {
- val x = Ref(false)
- val s = atomic { implicit txn =>
- if (!x()) retryFor(100)
- "first"
- } orAtomic { implicit txn =>
- if (!x()) retryFor(200)
- "second"
- }
- assert(s === "first")
- }
-
- test("retryFor earliest is second") {
- val x = Ref(false)
- val s = atomic { implicit txn =>
- if (!x()) retryFor(300)
- "first"
- } orAtomic { implicit txn =>
- if (!x()) retryFor(100)
- "second"
- }
- assert(s === "second")
- }
-
- test("retryFor earliest is first nested") {
- val x = Ref(false)
- val s = atomic { implicit txn =>
- atomic { implicit txn =>
- if (!x()) retryFor(100)
- "first"
- } orAtomic { implicit txn =>
- if (!x()) retryFor(200)
- "second"
- }
- }
- assert(s === "first")
- }
-
- test("retryFor earliest is second nested") {
- val x = Ref(false)
- val s = atomic { implicit txn =>
- atomic { implicit txn =>
- if (!x()) retryFor(300)
- "first"
- } orAtomic { implicit txn =>
- if (!x()) retryFor(100)
- "second"
- }
- }
- assert(s === "second")
- }
-
- test("retryFor only is first") {
- val x = Ref(false)
- val s = atomic { implicit txn =>
- if (!x()) retryFor(100)
- "first"
- } orAtomic { implicit txn =>
- if (!x()) retry
- "second"
- }
- assert(s === "first")
- }
-
- test("retryFor only is second") {
- val x = Ref(false)
- val s = atomic { implicit txn =>
- if (!x()) retry
- "first"
- } orAtomic { implicit txn =>
- if (!x()) retryFor(100)
- "second"
- }
- assert(s === "second")
- }
-
- test("retryFor ladder") {
- val buf = new StringBuilder
- val x = Ref(0)
- atomic { implicit txn =>
- buf += 'a'
- retryFor(1)
- buf += 'b'
- retryFor(1)
- buf += 'c'
- retryFor(0)
- buf += 'd'
- retryFor(1)
- buf += 'e'
- retryFor(1)
- buf += 'f'
- } orAtomic { implicit txn =>
- if (x() == 0) retry
- }
- assert(buf.toString === "aababcdabcdeabcdef")
- }
-
- test("late start retryFor") {
- val x = Ref(0)
- val b = new CountDownLatch(1)
- val begin = System.currentTimeMillis
- var lastRetryForElapsed = 0L
-
- (new Thread { override def run {
- b.await()
- x.single() = 1
- } }).start
-
- val buf = new StringBuilder
- atomic { implicit txn =>
- buf += 'a'
- b.countDown()
- if (x() == 0) retry
- buf += 'b'
- val t = System.currentTimeMillis
- retryFor(200)
- lastRetryForElapsed = System.currentTimeMillis - t
- buf += 'c'
- }
- val elapsed = System.currentTimeMillis - begin
- println("late start retryFor(200) inside atomic took " + elapsed + " millis")
- assert(elapsed >= 200)
- assert(lastRetryForElapsed < 100) // should be ~0
- assert(buf.toString === "aababc")
- }
-
- test("expired start retryFor") {
- val x = Ref(0)
- val begin = System.currentTimeMillis
- var totalRetryForElapsed = 0L
-
- (new Thread { override def run {
- Thread.sleep(200) ;
- x.single() = 1
- } }).start
-
- val buf = new StringBuilder
- atomic { implicit txn =>
- buf += 'a'
- if (x() == 0) retry
- buf += 'b'
- val t = System.currentTimeMillis
- retryFor(100)
- totalRetryForElapsed += System.currentTimeMillis - t
- buf += 'c'
- }
- val elapsed = System.currentTimeMillis - begin
- println("expired(200) start retryFor(100) inside atomic took " + elapsed + " millis")
- assert(elapsed >= 200)
- assert(totalRetryForElapsed < 100) // should be ~0
- assert(buf.toString === "aabc")
- }
-
- test("retryFor as sleep") {
- val begin = System.currentTimeMillis
- atomic { implicit txn => retryFor(100) }
- val elapsed = System.currentTimeMillis - begin
- println("retryFor(100) as sleep took " + elapsed + " millis")
- assert(elapsed >= 100)
- }
-
- ///////////// CURSOR
-
- test("second retryFor has shorter timeout") {
- val x = Ref(0)
- val b1 = new CountDownLatch(1)
- val b2 = new CountDownLatch(1)
-
- (new Thread {
- override def run {
- b1.await()
- Thread.sleep(10)
- x.single() = 1
- b2.await()
- Thread.sleep(100)
- x.single += 1
- }
- }).start
- atomic { implicit txn =>
- x() = x() + 10
- if (x() == 10) {
- b1.countDown()
- retryFor(200)
- } else if (x() == 11) {
- b2.countDown()
- retryFor(50)
- }
- }
- assert(x.single() === 11)
- x.single.await( _ == 12 )
- }
-
- test("retryFor via View await") {
- val x = Ref(0)
- (new Thread {
- override def run {
- Thread.sleep(50)
- x.single() = 1
- Thread.sleep(100)
- x.single += 1
- }
- }).start
- atomic { implicit txn =>
- x() = x() + 10
- x.single.await( _ == 11 )
- assert(!x.single.tryAwait(50)( _ == 12 ))
- }
- assert(x.single() === 11)
- x.single.await( _ == 12 )
- }
-
- test("skipped retryFor deadline is retained") {
- val begin = System.currentTimeMillis
- atomic { implicit txn =>
- val f = atomic { implicit txn =>
- retryFor(50)
- false
- } orAtomic { implicit txn =>
- true
- }
- if (f)
- retryFor(1000)
- }
- val elapsed = System.currentTimeMillis - begin
- assert(elapsed < 500)
- }
-
- test("concatenated failing tryAwait") {
- val begin = System.currentTimeMillis
- val x = Ref(0)
- atomic { implicit txn =>
- x.single.tryAwait(50)( _ != 0 )
- x.single.tryAwait(50)( _ != 0 )
- x.single.tryAwait(50)( _ != 0 )
- }
- val elapsed = System.currentTimeMillis - begin
- assert(elapsed > 150)
- timingAssert(elapsed < 200)
- }
-
- test("barging retry") {
- // the code to trigger barging is CCSTM-specific, but this test should pass regardless
- var tries = 0
- val x = Ref(0)
- val y = Ref(0)
- val z = Ref(0)
- val b = new CountDownLatch(1)
-
- (new Thread { override def run {
- b.await()
- Thread.sleep(10)
- x.single() = 1
- y.single() = 1
- } }).start
-
- atomic { implicit txn =>
- z() = 2
- atomic { implicit txn =>
- NestingLevel.current
- tries += 1
- if (tries < 50)
- Txn.rollback(Txn.OptimisticFailureCause('test, None))
- b.countDown()
-
- z() = 3
- x()
- if (y.swap(2) != 1)
- retry
- }
- }
- }
-
- test("retry with many pessimistic reads") {
- // the code to trigger barging is CCSTM-specific, but this test should pass regardless
- val b = new CountDownLatch(1)
- var tries = 0
- val refs = Array.tabulate(10000) { _ => Ref(0) }
-
- (new Thread { override def run {
- b.await()
- Thread.sleep(10)
- refs(500).single() = 1
- } }).start
-
- atomic { implicit txn =>
- tries += 1
- if (tries < 50)
- Txn.rollback(Txn.OptimisticFailureCause('test, None))
-
- val sum = refs.foldLeft(0)( _ + _.get )
- b.countDown()
- if (sum == 0)
- retry
- }
- }
-
- test("retry with many accesses to TArray") {
- // the code to trigger barging is CCSTM-specific, but this test should pass regardless
- val b = new CountDownLatch(1)
- var tries = 0
- val refs = TArray.ofDim[Int](10000).refs
-
- (new Thread { override def run {
- b.await()
- Thread.sleep(10)
- refs(500).single() = 1
- } }).start
-
- atomic { implicit txn =>
- tries += 1
- if (tries < 50)
- Txn.rollback(Txn.OptimisticFailureCause('test, None))
-
- for (r <- refs.take(500))
- r *= 2
- val sum = refs.foldLeft(0)( _ + _.get )
- b.countDown()
- if (sum == 0)
- retry
- }
- }
-
- test("futile retry should fail") {
- val x = true
- intercept[IllegalStateException] {
- atomic { implicit txn =>
- if (x)
- retry
- }
- }
- }
-
- test("withRetryTimeout") {
- val x = Ref(0)
- val t0 = System.currentTimeMillis
- intercept[InterruptedException] {
- atomic.withRetryTimeout(100000, TimeUnit.MICROSECONDS) { implicit txn =>
- if (x() == 0)
- retry
- }
- }
- val elapsed = System.currentTimeMillis - t0
- assert(elapsed >= 100)
- timingAssert(elapsed < 150)
- }
-
- test("retryFor wins over withRetryTimeout") {
- val x = Ref(0)
- val t0 = System.currentTimeMillis
- val f = atomic.withRetryTimeout(100) { implicit txn =>
- if (x() == 0) {
- retryFor(100)
- true
- } else
- false
- }
- assert(f)
- val elapsed = System.currentTimeMillis - t0
- assert(elapsed >= 100)
- timingAssert(elapsed < 150)
- }
-
- test("withRetryTimeout applies to retryFor") {
- val x = Ref(0)
- val t0 = System.currentTimeMillis
- intercept[InterruptedException] {
- atomic.withRetryTimeout(100) { implicit txn =>
- if (x() == 0)
- retryFor(101)
- assert(false)
- }
- }
- val elapsed = System.currentTimeMillis - t0
- assert(elapsed >= 100)
- timingAssert(elapsed < 150)
- }
-
- test("nested global withRetryTimeout") {
- val orig = TxnExecutor.defaultAtomic
- try {
- TxnExecutor.transformDefault( _.withRetryTimeout(100) )
- val x = Ref(0)
- val t0 = System.currentTimeMillis
- intercept[InterruptedException] {
- atomic { implicit txn =>
- atomic { implicit txn =>
- atomic { implicit txn =>
- if (x() == 0)
- retry
- assert(false)
- }
- }
- }
- }
- val elapsed = System.currentTimeMillis - t0
- println(elapsed)
- assert(elapsed >= 100)
- timingAssert(elapsed < 150)
- } finally {
- TxnExecutor.transformDefault( _ => orig )
- }
- }
-
- test("tighter timeout wins") {
- val t0 = System.currentTimeMillis
- intercept[InterruptedException] {
- atomic.withRetryTimeout(100) { implicit txn =>
- atomic.withRetryTimeout(1000) { implicit txn =>
- retry
- }
- }
- }
- val elapsed = System.currentTimeMillis - t0
- assert(elapsed >= 100)
- timingAssert(elapsed < 150)
- }
-
- test("non-timeout elapsed") {
- val x = Ref(0)
- (new Thread { override def run {
- Thread.sleep(100)
- x.single() = 1
- } }).start
- intercept[InterruptedException] {
- atomic { implicit txn =>
- atomic.withRetryTimeout(200) { implicit txn =>
- if (x() == 0)
- retry
- }
- atomic.withRetryTimeout(50) { implicit txn =>
- retryFor(51)
- }
- }
- }
- }
-}
diff --git a/benchmarks/scala-stm/scala-stm-library/src/test/scala/scala/concurrent/stm/Slow.scala b/benchmarks/scala-stm/scala-stm-library/src/test/scala/scala/concurrent/stm/Slow.scala
deleted file mode 100644
index 7b5e1b14..00000000
--- a/benchmarks/scala-stm/scala-stm-library/src/test/scala/scala/concurrent/stm/Slow.scala
+++ /dev/null
@@ -1,7 +0,0 @@
-/* scala-stm - (c) 2009-2010, Stanford University, PPL */
-
-package scala.concurrent.stm
-
-import org.scalatest.Tag
-
-object Slow extends Tag("slow")
diff --git a/benchmarks/scala-stm/scala-stm-library/src/test/scala/scala/concurrent/stm/TMapSuite.scala b/benchmarks/scala-stm/scala-stm-library/src/test/scala/scala/concurrent/stm/TMapSuite.scala
deleted file mode 100644
index 622f258e..00000000
--- a/benchmarks/scala-stm/scala-stm-library/src/test/scala/scala/concurrent/stm/TMapSuite.scala
+++ /dev/null
@@ -1,680 +0,0 @@
-/* scala-stm - (c) 2009-2012, Stanford University, PPL */
-
-package scala.concurrent.stm
-
-import org.scalatest.FunSuite
-import scala.util.Random
-import scala.collection.mutable
-import skel.SimpleRandom
-
-class TMapSuite extends FunSuite {
-
- private def value(k: Int) = "x" + k
- private def kvRange(b: Int, e: Int) = (b until e) map { i => (i -> value(i)) }
-
- test("number equality trickiness") {
- assert(TMap(10L -> "").single contains 10)
- //assert(TMap(10 -> "").single contains 10L)
- assert(TMap[Number, String]((10L: Number) -> "").single contains 10)
- assert(TMap[Number, String]((10: Number) -> "").single contains 10L)
- assert(TMap[Any, String](10L -> "").single contains 10)
- assert(TMap[Any, String](10 -> "").single contains 10L)
- assert(TMap[AnyRef, String](10L.asInstanceOf[AnyRef] -> "").single contains 10.asInstanceOf[AnyRef])
- assert(TMap[AnyRef, String](10.asInstanceOf[AnyRef] -> "").single contains 10L.asInstanceOf[AnyRef])
- }
-
- test("character equality trickiness") {
- assert(TMap('*' -> "").single contains 42)
- assert(TMap((42: Byte) -> "").single contains '*')
- assert(TMap[Any, String]('*' -> "").single contains (42: Short))
- assert(TMap[Any, String](42L -> "").single contains '*')
- assert(TMap[AnyRef, String]('*'.asInstanceOf[AnyRef] -> "").single contains 42.0.asInstanceOf[AnyRef])
- assert(TMap[AnyRef, String](42.0f.asInstanceOf[AnyRef] -> "").single contains '*'.asInstanceOf[AnyRef])
- }
-
- case class BadHash(k: Int) {
- override def hashCode = if (k > 500) k / 5 else 0
- }
-
- test("correct despite poor hash function") {
- val mut = TMap(((0 until 1000) map { i => (BadHash(i) -> i) }): _*).single
- for (i <- -500 until 1500)
- assert(mut.get(BadHash(i)) === (if (i >= 0 && i < 1000) Some(i) else None))
- }
-
- test("clone captures correct atomic writes") {
- val mut = TMap(kvRange(0, 100): _*)
- val z = atomic { implicit txn =>
- mut ++= kvRange(100, 200)
- val z = mut.clone.single
- mut ++= kvRange(200, 300)
- z
- }
- assert(z.size === 200)
- for (i <- 0 until 200)
- assert(z(i) === value(i))
- }
-
- test("clone doesn't include discarded writes") {
- val mut = TMap(kvRange(0, 100): _*)
- val z = atomic { implicit txn =>
- atomic { implicit txn =>
- mut ++= kvRange(100, 200)
- if ("likely".## != 0)
- retry
- } orAtomic { implicit txn =>
- mut ++= kvRange(200, 300)
- }
- val z = mut.clone.single
- atomic { implicit txn =>
- mut ++= kvRange(300, 400)
- if ("likely".## != 0)
- retry
- } orAtomic { implicit txn =>
- mut ++= kvRange(400, 500)
- }
- z
- }
- assert(z.size === 200)
- for (i <- 0 until 100)
- assert(z(i) === value(i))
- for (i <- 200 until 300)
- assert(z(i) === value(i))
- }
-
- test("clone is transactional") {
- val mut = TMap(kvRange(0, 100): _*)
- val z = atomic { implicit txn =>
- atomic { implicit txn =>
- mut ++= kvRange(100, 105)
- if ("likely".## != 0)
- retry
- } orAtomic { implicit txn =>
- mut ++= kvRange(200, 205)
- }
- val z = mut.clone.single
- atomic { implicit txn =>
- z ++= kvRange(300, 305)
- if ("likely".## != 0)
- retry
- } orAtomic { implicit txn =>
- z ++= kvRange(400, 405)
- }
- z
- }
- assert(z.size === 110)
- for (i <- 0 until 100)
- assert(z(i) === value(i))
- for (i <- 200 until 205)
- assert(z(i) === value(i))
- for (i <- 400 until 405)
- assert(z(i) === value(i))
- }
-
- test("random sequential") {
- randomTest(1500)
- }
-
- test("more random sequential", Slow) {
- randomTest(30000)
- }
-
- def randomTest(total: Int) {
- val rand = new Random()
-
- def nextKey(): String = "key" + (rand.nextInt() >>> rand.nextInt())
- def nextValue(): Int = if (rand.nextInt(10) == 0) 0 else rand.nextInt()
-
- var mut = TMap.empty[String, Int].single
- val base = mutable.Map.empty[String, Int]
-
- for (i <- 0 until total) {
- val pct = rand.nextInt(250)
- val k = nextKey()
- val v = nextValue()
- if (pct < 15) {
- assert(base.get(k) === mut.get(k))
- } else if (pct < 20) {
- val a = try { Some(base(k)) } catch { case _: NoSuchElementException => None }
- val b = try { Some(mut(k)) } catch { case _: NoSuchElementException => None }
- assert(a === b)
- } else if (pct < 35) {
- assert(base.put(k, v) === mut.put(k, v))
- } else if (pct < 40) {
- base(k) = v
- mut(k) = v
- } else if (pct < 45) {
- assert(base.contains(k) === mut.contains(k))
- } else if (pct < 55) {
- assert(base.remove(k) === mut.remove(k))
- } else if (pct < 60) {
- for (j <- 0 until (i / (total / 20))) {
- if (!base.isEmpty) {
- val k1 = base.iterator.next()._1
- assert(base.remove(k1) === mut.remove(k1))
- }
- }
- } else if (pct < 63) {
- mut = mut.clone
- } else if (pct < 66) {
- assert(base.toMap === mut.snapshot)
- } else if (pct < 69) {
- assert(base.isEmpty === mut.isEmpty)
- } else if (pct < 72) {
- assert(base.size === mut.size)
- } else if (pct < 77) {
- assert(base eq (base += (k -> v)))
- assert(mut eq (mut += (k -> v)))
- } else if (pct < 80) {
- val kv2 = (nextKey -> nextValue)
- val kv3 = (nextKey -> nextValue)
- assert(base eq (base += ((k -> v), kv2, kv3)))
- assert(mut eq (mut += ((k -> v), kv2, kv3)))
- } else if (pct < 82) {
- val kv2 = (nextKey -> nextValue)
- val kv3 = (nextKey -> nextValue)
- assert(base eq (base ++= Array((k -> v), kv2, kv3)))
- assert(mut eq (mut ++= Array((k -> v), kv2, kv3)))
- } else if (pct < 83) {
- assert(mut eq (mut ++= Nil))
- } else if (pct < 88) {
- assert(base eq (base -= k))
- assert(mut eq (mut -= k))
- } else if (pct < 91) {
- val k2 = nextKey()
- val k3 = nextKey()
- assert(base eq (base -= (k, k2, k3)))
- assert(mut eq (mut -= (k, k2, k3)))
- } else if (pct < 93) {
- val k2 = nextKey()
- val k3 = nextKey()
- assert(base eq (base --= Array(k, k2, k3)))
- assert(mut eq (mut --= Array(k, k2, k3)))
- } else if (pct < 94) {
- assert(mut eq (mut --= Nil))
- } else if (pct < 95) {
- mut = TMap(mut.toArray: _*).single
- } else if (pct < 96) {
- mut = TMap.empty[String, Int].single ++= mut
- } else if (pct < 97) {
- val m2 = mutable.Map.empty[String, Int]
- for (kv <- mut) { m2 += kv }
- assert(base === m2)
- } else if (pct < 98) {
- val m2 = mutable.Map.empty[String, Int]
- for (kv <- mut.iterator) { m2 += kv }
- assert(base === m2)
- } else if (pct < 115) {
- assert(base.get(k) === atomic { implicit t => mut.tmap.get(k) })
- } else if (pct < 120) {
- val a = try { Some(base(k)) } catch { case _: NoSuchElementException => None }
- val b = try { Some(atomic { implicit t => mut.tmap(k) }) } catch { case _: NoSuchElementException => None }
- assert(a === b)
- } else if (pct < 135) {
- assert(base.put(k, v) === atomic { implicit t => mut.tmap.put(k, v) })
- } else if (pct < 140) {
- base(k) = v
- atomic { implicit t => mut.tmap(k) = v }
- } else if (pct < 145) {
- assert(base.contains(k) === atomic { implicit t => mut.tmap.contains(k) })
- } else if (pct < 155) {
- assert(base.remove(k) === atomic { implicit t => mut.tmap.remove(k) })
- } else if (pct < 160) {
- for (j <- 0 until (i / (total / 20))) {
- if (!base.isEmpty) {
- val k1 = base.iterator.next()._1
- assert(base.remove(k1) === atomic { implicit t => mut.tmap.remove(k1) })
- }
- }
- } else if (pct < 163) {
- mut = atomic { implicit t => mut.tmap.clone.single }
- } else if (pct < 166) {
- assert(base.toMap === atomic { implicit t => mut.tmap.snapshot })
- } else if (pct < 169) {
- assert(base.isEmpty === atomic { implicit t => mut.tmap.isEmpty })
- } else if (pct < 172) {
- assert(base.size === atomic { implicit t => mut.tmap.size })
- } else if (pct < 177) {
- assert(base eq (base += (k -> v)))
- assert(mut.tmap eq atomic { implicit t => mut.tmap += (k -> v) })
- } else if (pct < 180) {
- val kv2 = (nextKey -> nextValue)
- val kv3 = (nextKey -> nextValue)
- assert(base eq (base += ((k -> v), kv2, kv3)))
- assert(mut.tmap eq atomic { implicit t => mut.tmap += ((k -> v), kv2, kv3) })
- } else if (pct < 182) {
- val kv2 = (nextKey -> nextValue)
- val kv3 = (nextKey -> nextValue)
- assert(base eq (base ++= Array((k -> v), kv2, kv3)))
- assert(mut.tmap eq atomic { implicit t => mut.tmap ++= Array((k -> v), kv2, kv3) })
- } else if (pct < 183) {
- assert(mut.tmap eq atomic { implicit t => mut.tmap ++= Nil })
- } else if (pct < 188) {
- assert(base eq (base -= k))
- assert(mut.tmap eq atomic { implicit t => mut.tmap -= k })
- } else if (pct < 191) {
- val k2 = nextKey()
- val k3 = nextKey()
- assert(base eq (base -= (k, k2, k3)))
- assert(mut.tmap eq atomic { implicit t => mut.tmap -= (k, k2, k3) })
- } else if (pct < 193) {
- val k2 = nextKey()
- val k3 = nextKey()
- assert(base eq (base --= Array(k, k2, k3)))
- assert(mut.tmap eq atomic { implicit t => mut.tmap --= Array(k, k2, k3) })
- } else if (pct < 194) {
- assert(mut.tmap eq atomic { implicit t => mut.tmap --= Nil })
- } else if (pct < 195) {
- mut = atomic { implicit t => TMap(mut.tmap.toArray: _*).single }
- } else if (pct < 196) {
- mut = atomic { implicit t => TMap.empty[String, Int] ++= mut.tmap }.single
- } else if (pct < 197) {
- atomic { implicit t =>
- val m2 = mutable.Map.empty[String, Int]
- for (kv <- mut.tmap) { m2 += kv }
- assert(base === m2)
- }
- } else if (pct < 198) {
- atomic { implicit t =>
- val m2 = mutable.Map.empty[String, Int]
- for (kv <- mut.tmap.iterator) { m2 += kv }
- assert(base === m2)
- }
- } else if (pct < 200) {
- var b = base.toMap
- var s = mut.snapshot
- assert(b.iterator.toMap === s.iterator.toMap)
- while (!b.isEmpty) {
- if (rand.nextInt(100) < 75) {
- val k = b.keysIterator.next()
- assert(b(k) === s(k))
- b -= k
- s -= k
- assert(b.size === s.size)
- } else {
- val kv = (nextKey -> nextValue)
- b += kv
- s += kv
- }
- }
- assert(b.isEmpty === s.isEmpty)
- val kv = (nextKey -> nextValue)
- b += kv
- s += kv
- assert(b === s)
- } else if (pct < 208) {
- val cutoff = rand.nextInt()
- assert(base eq (base.retain { (k, v) => v < cutoff }))
- assert(mut eq (mut.retain { (k, v) => v < cutoff }))
- } else if (pct < 211) {
- val cutoff = rand.nextInt()
- assert(base eq (base.retain { (k, v) => v < cutoff }))
- assert(mut.tmap eq atomic { implicit txn => mut.tmap.retain { (k, v) => v < cutoff } })
- } else if (pct < 214) {
- val k = nextKey()
- val v = nextValue()
- var bf = false
- var mf = false
- assert(base.getOrElseUpdate(k, { bf = true ; v }) === mut.getOrElseUpdate(k, { mf = true ; v }))
- assert(bf === mf)
- } else if (pct < 217) {
- val k = nextKey()
- val v = nextValue()
- var bf = false
- var mf = false
- assert(base.getOrElseUpdate(k, { bf = true ; v }) === atomic { implicit txn => mut.getOrElseUpdate(k, { mf = true ; v }) })
- assert(bf === mf)
- } else if (pct < 220) {
- assert(base eq (base.transform { (k, v) => v + 1 }))
- assert(mut eq (mut.transform { (k, v) => v + 1 }))
- } else if (pct < 223) {
- assert(base eq (base.transform { (k, v) => v + 1 }))
- assert(mut.tmap eq atomic { implicit txn => mut.tmap.transform { (k, v) => v + 1 } })
- } else if (pct < 225) {
- val b2 = base map { kv => (kv._1 -> kv._2 * 1L) }
- val m2 = mut map { kv => (kv._1 -> kv._2 * 1L) }
- assert(b2 === m2)
- assert(m2 eq m2.tmap.single)
- mut = m2 map { kv => (kv._1 -> kv._2.asInstanceOf[Int]) }
- } else if (pct < 227) {
- mut = TMap.View.empty[String, Int] ++ mut
- } else if (pct < 229) {
- mut = atomic { implicit txn => mut.tmap.empty ++ mut.tmap }
- } else if (pct < 231) {
- val b = TMap.View.newBuilder[String, Int]
- b ++= mut
- b.clear()
- b ++= mut
- mut = b.result()
- } else if (pct < 233) {
- mut = (atomic { implicit txn =>
- val b = TMap.newBuilder[String, Int]
- b ++= mut.tmap
- b.clear()
- b ++= mut.tmap
- b.result()
- }).single
- }
- }
- }
-
- test("tmap clear") {
- val m = TMap(1 -> "one", 2 -> "two")
- atomic { implicit txn => m.clear() }
- assert(m.single.size === 0)
- assert(!m.single.iterator.hasNext)
- for (e <- m.single) { assert(false) }
- }
-
- test("view clear") {
- val m = TMap(1 -> "one", 2 -> "two")
- m.single.clear()
- assert(m.single.size === 0)
- assert(!m.single.iterator.hasNext)
- for (e <- m.single) { assert(false) }
- }
-
- test("null key") {
- val m = TMap((null : AnyRef) -> "abc", "def" -> "ghi")
- assert(m.single.size === 2)
- assert(m.single(null) === "abc")
- assert(m.single.remove(null) === Some("abc"))
- assert(m.single.size === 1)
- assert(m.single.put(null, "jkl") === None)
- assert(m.single.size === 2)
- assert(m.single.get(null) === Some("jkl"))
- }
-
- test("null value") {
- val m = TMap("abc" -> null, "def" -> "ghi")
- assert(m.single.size === 2)
- assert(m.single.get("abc") === Some(null))
- assert(m.single.remove("abc") === Some(null))
- assert(m.single.size === 1)
- assert(m.single.put("jkl", null) === None)
- assert(m.single.size === 2)
- assert(m.single.contains("jkl"))
- }
-
- test("view builder magic") {
- val fwd = TMap.View(1 -> "one", 2 -> "two")
- val rev = fwd map { kv => (kv._2 -> kv._1) }
- val rev2: TMap.View[String, Int] = rev
- assert(rev === Map("one" -> 1, "two" -> 2))
- }
-
- test("iterator crossing a txn boundary") {
- val kvs = (0 until 100) map { i => ((i % 37) -> ("x" + i)) }
- val m = TMap(kvs: _*)
- val iter = atomic { implicit txn => m.iterator }
- assert(iter.toMap === kvs.toMap)
- }
-
- test("iterator after many removes") {
- val m = TMap.View.empty[Int, Int]
- for (i <- 0 until 100000)
- m(i) = i
- for (i <- 0 until 100000)
- m -= i
- assert(!m.iterator.hasNext)
- for (e <- m) { assert(false) }
- atomic { implicit txn => assert(m.tmap.isEmpty) }
- atomic { implicit txn => assert(m.tmap.size === 0) }
- assert(m.isEmpty)
- assert(m.size === 0)
- }
-
- test("view snapshot foreach") {
- val kvs = (0 until 100) map { i => (i -> ("x" + (i % 37))) }
- val m = TMap(kvs: _*)
- var n = 0
- for ((k, v) <- m.single.snapshot) n += k
- assert(n === 4950)
- }
-
- test("txn snapshot foreach") {
- val kvs = (0 until 100) map { i => (i -> ("x" + (i % 37))) }
- val m = TMap(kvs: _*)
- var n = 0
- for ((k, v) <- atomic { implicit txn => m.snapshot }) n += k
- assert(n === 4950)
- }
-
- test("contention") {
- val values = (0 until 37) map { i => "foo" + i }
- for (pass <- 0 until 2) {
- val numThreads = 8
- val m = TMap.empty[Int, String]
- val threads = for (t <- 0 until numThreads) yield new Thread {
- override def run() {
- var rand = new SimpleRandom(t)
- var i = 0
- while (i < 1000000) {
- if (rand.nextInt(2) == 0) {
- var j = 0
- while (j < 64) {
- val key = rand.nextInt(1 << 11)
- val pct = rand.nextInt(100)
- if (pct < 33)
- m.single.contains(key)
- else if (pct < 33)
- m.single.put(key, values(rand.nextInt(values.length)))
- else
- m.single.remove(key)
- j += 1
- }
- } else {
- rand = atomic { implicit txn =>
- val r = rand.clone
- var j = 0
- while (j < 64) {
- val key = r.nextInt(1 << 11)
- val pct = r.nextInt(100)
- if (pct < 33)
- m.contains(key)
- else if (pct < 33)
- m.put(key, values(r.nextInt(values.length)))
- else
- m.remove(key)
- j += 1
- }
- r
- }
- }
- i += 64
- }
- }
- }
-
- val begin = System.currentTimeMillis
- for (t <- threads) t.start()
- for (t <- threads) t.join()
- val elapsed = System.currentTimeMillis - begin
-
- println("TMap: contended: " + numThreads + " threads, total throughput was " + (elapsed / numThreads) + " nanos/op")
- }
- }
-
- test("atomicity violation") {
- // This test makes sure that the copy-on-write snapshot mechanism can't
- // expose the intermediate state of a txn to a non-txn get.
- val m = TMap(kvRange(0, 1000): _*).single
- m(0) = "okay"
- val failed = Ref(-1).single
- val threads = Array.tabulate(2) { _ =>
- new Thread {
- override def run() {
- val r = new SimpleRandom
- for (i <- 0 until 100000) {
- if (r.nextInt(2) == 0) {
- if (m(0) != "okay") {
- failed() = i
- return
- }
- } else {
- atomic { implicit txn =>
- m(0) = "should be isolated"
- m.snapshot
- m(0) = "okay"
- }
- }
- }
- }
- }
- }
- for (t <- threads) t.start()
- for (t <- threads) t.join()
- assert(failed() === -1)
- }
-
- //////// perf stuff
-
- private def now = System.currentTimeMillis
-
- test("sequential non-txn read performance", Slow) {
- for (pass <- 0 until 4) {
- for (size <- List(10, 100, 1000, 100000)) {
- val m = TMap(kvRange(0, size): _*).single
- val t0 = now
- var i = 0
- var k = 0
- while (i < 1000000) {
- assert(m.contains(k) == (k < size))
- i += 1
- k = if (k == 2 * size - 1) 0 else k + 1
- }
- val elapsed = now - t0
- println("TMap: non-txn read: " + size + " keys/map -> " + elapsed + " nanos/contain")
- }
- }
- }
-
- test("sequential non-txn append performance", Slow) {
- for (pass <- 0 until 2) {
- for (size <- List(10, 100, 1000, 100000)) {
- val src = kvRange(0, size).toArray
- val t0 = now
- var outer = 0
- while (outer < 1000000) {
- TMap.empty[Int, String].single ++= src
- outer += size
- }
- val elapsed = now - t0
- println("TMap: non-txn append: " + size + " keys/map -> " + elapsed + " nanos/added-key")
- }
- }
- }
-
- test("sequential non-txn update performance", Slow) {
- val values = (0 until 37) map { "x" + _ }
- for (pass <- 0 until 2) {
- for (size <- List(10, 100, 1000, 100000)) {
- val m = TMap(kvRange(0, size): _*).single
- val t0 = now
- var i = 0
- while (i < 1000000) {
- val prev = m.put(i % size, values(i % values.length))
- assert(!prev.isEmpty)
- i += 1
- }
- val elapsed = now - t0
- println("TMap: non-txn update: " + size + " keys/map -> " + elapsed + " nanos/put")
- }
- }
- }
-
- test("sequential non-txn put/remove mix performance", Slow) {
- val values = (0 until 37) map { "x" + _ }
- val rand = new skel.SimpleRandom
- for (pass <- 0 until 4) {
- for (size <- List(10, 100, 1000, 100000)) {
- val m = TMap(kvRange(0, size): _*).single
- val t0 = now
- var i = 0
- while (i < 1000000) {
- val r = rand.nextInt()
- val k = math.abs(r % size)
- if (r > 0)
- m.put(k, values(i % values.length))
- else
- m.remove(k)
- i += 1
- }
- val elapsed = now - t0
- println("TMap: non-txn put/remove: " + size + " keys/map -> " + elapsed + " nanos/op")
- }
- }
- }
-
- test("sequential txn read performance", Slow) {
- for (txnSize <- List(2, 10, 1000)) {
- for (pass <- 0 until 2) {
- for (size <- List(10, 100, 1000, 100000)) {
- val m = TMap(kvRange(0, size): _*).single
- val t0 = now
- for (ii <- 0 until 1000000 by txnSize) {
- atomic { implicit txn =>
- var i = ii
- while (i < ii + txnSize) {
- val k = i % (2 * size)
- assert(m.contains(k) == (k < size))
- i += 1
- }
- }
- }
- val elapsed = now - t0
- println("TMap: txn read: " + txnSize + " accesses/txn: " + size + " keys/map -> " + elapsed + " nanos/op")
- }
- }
- }
- }
-
- test("sequential txn put/remove mix performance", Slow) {
- val values = (0 until 37) map { "x" + _ }
- val rand = new skel.SimpleRandom
- for (txnSize <- List(2, 10, 1000)) {
- for (pass <- 0 until 2) {
- for (size <- List(10, 100, 1000, 100000)) {
- val m = TMap(kvRange(0, size): _*).single
- val t0 = now
- for (ii <- 0 until 1000000 by txnSize) {
- atomic { implicit txn =>
- var i = ii
- while (i < ii + txnSize) {
- val r = rand.nextInt()
- val k = math.abs(r % size)
- if (r > 0)
- m.put(k, values(i % values.length))
- else
- m.remove(k)
- i += 1
- }
- }
- }
- val elapsed = now - t0
- println("TMap: txn put/remove: " + txnSize + " accesses/txn: " + size + " keys/map -> " + elapsed + " nanos/op")
- }
- }
- }
- }
-
- test("TxnDebuggable") {
- val m1 = TMap[Int, Int]()
- val m2 = TMap(1 -> "one")
- val m3 = TMap(1 -> "one", 2 -> "two").single
- val m4 = TMap(kvRange(0, 10000): _*).single
-
- assert(m1.dbgStr === "TMap[size=0]()")
- assert(m2.dbgStr === "TMap[size=1](1 -> one)")
- assert(m3.dbgStr == "TMap[size=2](1 -> one, 2 -> two)" ||
- m3.dbgStr == "TMap[size=2](2 -> two, 1 -> one)")
- assert(m4.dbgStr.startsWith("TMap[size=10000]("))
- assert(m4.dbgStr.length >= 1000)
- assert(m4.dbgStr.length < 1100)
-
- assert(m1.dbgValue.asInstanceOf[Array[_]].length === 0)
- assert(m2.dbgValue.asInstanceOf[Array[_]].length === 1)
- assert(m3.dbgValue.asInstanceOf[Array[_]].length === 2)
- assert(m4.dbgValue.asInstanceOf[Array[_]].length === 10000)
- }
-}
diff --git a/benchmarks/scala-stm/scala-stm-library/src/test/scala/scala/concurrent/stm/TSetSuite.scala b/benchmarks/scala-stm/scala-stm-library/src/test/scala/scala/concurrent/stm/TSetSuite.scala
deleted file mode 100644
index e6a3e451..00000000
--- a/benchmarks/scala-stm/scala-stm-library/src/test/scala/scala/concurrent/stm/TSetSuite.scala
+++ /dev/null
@@ -1,421 +0,0 @@
-/* scala-stm - (c) 2009-2012, Stanford University, PPL */
-
-package scala.concurrent.stm
-
-import org.scalatest.FunSuite
-import scala.util.Random
-import scala.collection.mutable
-
-class TSetSuite extends FunSuite {
-
- test("number equality trickiness") {
- assert(TSet(10L).single contains 10)
- //assert(TSet(10).single contains 10L)
- assert(TSet[Number](10L).single contains 10)
- assert(TSet[Number](10).single contains 10L)
- assert(TSet[Any](10L).single contains 10)
- assert(TSet[Any](10).single contains 10L)
- assert(TSet[AnyRef](10L.asInstanceOf[AnyRef]).single contains 10.asInstanceOf[AnyRef])
- assert(TSet[AnyRef](10.asInstanceOf[AnyRef]).single contains 10L.asInstanceOf[AnyRef])
- }
-
- test("character equality trickiness") {
- assert(TSet('*').single contains 42)
- assert(TSet(42: Byte).single contains '*')
- assert(TSet[Any]('*').single contains (42: Short))
- assert(TSet[Any](42L).single contains '*')
- assert(TSet[AnyRef]('*'.asInstanceOf[AnyRef]).single contains 42.0.asInstanceOf[AnyRef])
- assert(TSet[AnyRef](42.0f.asInstanceOf[AnyRef]).single contains '*'.asInstanceOf[AnyRef])
- }
-
- case class BadHash(k: Int) {
- override def hashCode = if (k > 500) k / 5 else 0
- }
-
- test("correct despite poor hash function") {
- val mut = TSet(((0 until 1000) map { i => BadHash(i) }): _*).single
- for (i <- -500 until 1500)
- assert(mut(BadHash(i)) === (i >= 0 && i < 1000))
- }
-
- test("clone captures correct atomic writes") {
- val mut = TSet((0 until 100): _*)
- val z = atomic { implicit txn =>
- mut ++= (100 until 200)
- val z = mut.clone.single
- mut ++= (200 until 300)
- z
- }
- assert(z.size === 200)
- for (i <- 0 until 200)
- assert(z.contains(i))
- }
-
- test("clone doesn't include discarded writes") {
- val mut = TSet((0 until 100): _*)
- val z = atomic { implicit txn =>
- atomic { implicit txn =>
- mut ++= (100 until 200)
- if ("likely".## != 0)
- retry
- } orAtomic { implicit txn =>
- mut ++= (200 until 300)
- }
- val z = mut.clone.single
- atomic { implicit txn =>
- mut ++= (300 until 400)
- if ("likely".## != 0)
- retry
- } orAtomic { implicit txn =>
- mut ++= (400 until 500)
- }
- z
- }
- assert(z.size === 200)
- for (i <- 0 until 100)
- assert(z.contains(i))
- for (i <- 200 until 300)
- assert(z.contains(i))
- }
-
- test("clone is transactional") {
- val mut = TSet((0 until 100): _*)
- val z = atomic { implicit txn =>
- atomic { implicit txn =>
- mut ++= (100 until 105)
- if ("likely".## != 0)
- retry
- } orAtomic { implicit txn =>
- mut ++= (200 until 205)
- }
- val z = mut.clone.single
- atomic { implicit txn =>
- z ++= (300 until 305)
- if ("likely".## != 0)
- retry
- } orAtomic { implicit txn =>
- z ++= (400 until 405)
- }
- z
- }
- assert(z.size === 110)
- for (i <- 0 until 100)
- assert(z.contains(i))
- for (i <- 200 until 205)
- assert(z.contains(i))
- for (i <- 400 until 405)
- assert(z.contains(i))
- }
-
-
- test("random sequential") {
- randomTest(1500)
- }
-
- test("more random sequential", Slow) {
- randomTest(30000)
- }
-
- def randomTest(total: Int) {
- val rand = new Random()
-
- def nextKey(): String = "key" + (rand.nextInt() >>> rand.nextInt())
-
- var mut = TSet.empty[String].single
- val base = mutable.Set.empty[String]
-
- for (i <- 0 until total) {
- val pct = rand.nextInt(250)
- val k = nextKey
- if (pct < 15) {
- assert(base.contains(k) === mut.contains(k))
- } else if (pct < 20) {
- assert(base(k) === mut(k))
- } else if (pct < 35) {
- assert(base.add(k) === mut.add(k))
- } else if (pct < 40) {
- val v = rand.nextBoolean
- base(k) = v
- mut(k) = v
- } else if (pct < 55) {
- assert(base.remove(k) === mut.remove(k))
- } else if (pct < 60) {
- for (j <- 0 until (i / (total / 20))) {
- if (!base.isEmpty) {
- val k1 = base.iterator.next
- assert(base.remove(k1) === mut.remove(k1))
- }
- }
- } else if (pct < 63) {
- mut = mut.clone
- } else if (pct < 66) {
- assert(base.toSet === mut.snapshot)
- } else if (pct < 69) {
- assert(base.isEmpty === mut.isEmpty)
- } else if (pct < 72) {
- assert(base.size === mut.size)
- } else if (pct < 77) {
- assert(base eq (base += k))
- assert(mut eq (mut += k))
- } else if (pct < 80) {
- val k2 = nextKey
- val k3 = nextKey
- assert(base eq (base += (k, k2, k3)))
- assert(mut eq (mut += (k, k2, k3)))
- } else if (pct < 83) {
- val k2 = nextKey
- val k3 = nextKey
- assert(base eq (base ++= Array(k, k2, k3)))
- assert(mut eq (mut ++= Array(k, k2, k3)))
- } else if (pct < 82) {
- assert(mut eq (mut ++= Nil))
- } else if (pct < 88) {
- assert(base eq (base -= k))
- assert(mut eq (mut -= k))
- } else if (pct < 91) {
- val k2 = nextKey
- val k3 = nextKey
- assert(base eq (base -= (k, k2, k3)))
- assert(mut eq (mut -= (k, k2, k3)))
- } else if (pct < 93) {
- val k2 = nextKey
- val k3 = nextKey
- assert(base eq (base --= Array(k, k2, k3)))
- assert(mut eq (mut --= Array(k, k2, k3)))
- } else if (pct < 94) {
- assert(mut eq (mut --= Nil))
- } else if (pct < 95) {
- mut = TSet(mut.toArray: _*).single
- } else if (pct < 96) {
- mut = TSet.empty[String].single ++= mut
- } else if (pct < 97) {
- val s2 = mutable.Set.empty[String]
- for (k <- mut) { s2 += k }
- assert(base === s2)
- } else if (pct < 98) {
- val s2 = mutable.Set.empty[String]
- for (k <- mut.iterator) { s2 += k }
- assert(base === s2)
- } else if (pct < 115) {
- assert(base.contains(k) === atomic { implicit txn => mut.tset.contains(k) })
- } else if (pct < 120) {
- assert(base(k) === atomic { implicit txn => mut.tset(k) })
- } else if (pct < 135) {
- assert(base.add(k) === atomic { implicit txn => mut.tset.add(k) })
- } else if (pct < 140) {
- val v = rand.nextBoolean
- base(k) = v
- atomic { implicit txn => mut.tset(k) = v }
- } else if (pct < 155) {
- assert(base.remove(k) === atomic { implicit txn => mut.tset.remove(k) })
- } else if (pct < 160) {
- for (j <- 0 until (i / (total / 20))) {
- if (!base.isEmpty) {
- val k1 = base.iterator.next
- assert(base.remove(k1) === atomic { implicit txn => mut.tset.remove(k1) })
- }
- }
- } else if (pct < 163) {
- mut = atomic { implicit txn => mut.tset.clone.single }
- } else if (pct < 166) {
- assert(base.toSet === atomic { implicit txn => mut.tset.snapshot })
- } else if (pct < 169) {
- assert(base.isEmpty === atomic { implicit txn => mut.tset.isEmpty })
- } else if (pct < 172) {
- assert(base.size === atomic { implicit txn => mut.tset.size })
- } else if (pct < 177) {
- assert(base eq (base += k))
- assert(mut.tset eq atomic { implicit txn => mut.tset += k })
- } else if (pct < 180) {
- val k2 = nextKey
- val k3 = nextKey
- assert(base eq (base += (k, k2, k3)))
- assert(mut.tset eq atomic { implicit txn => mut.tset += (k, k2, k3) })
- } else if (pct < 182) {
- val k2 = nextKey
- val k3 = nextKey
- assert(base eq (base ++= Array(k, k2, k3)))
- assert(mut.tset eq atomic { implicit txn => mut.tset ++= Array(k, k2, k3) })
- } else if (pct < 183) {
- assert(mut.tset eq atomic { implicit txn => mut.tset ++= Nil })
- } else if (pct < 188) {
- assert(base eq (base -= k))
- assert(mut.tset eq atomic { implicit txn => mut.tset -= k })
- } else if (pct < 191) {
- val k2 = nextKey
- val k3 = nextKey
- assert(base eq (base -= (k, k2, k3)))
- assert(mut.tset eq atomic { implicit txn => mut.tset -= (k, k2, k3) })
- } else if (pct < 193) {
- val k2 = nextKey
- val k3 = nextKey
- assert(base eq (base --= Array(k, k2, k3)))
- assert(mut.tset eq atomic { implicit txn => mut.tset --= Array(k, k2, k3) })
- } else if (pct < 194) {
- assert(mut.tset eq atomic { implicit txn => mut.tset --= Nil })
- } else if (pct < 195) {
- mut = atomic { implicit txn => TSet(mut.tset.toArray: _*).single }
- } else if (pct < 196) {
- mut = atomic { implicit txn => TSet.empty[String] ++= mut.tset }.single
- } else if (pct < 197) {
- atomic { implicit txn =>
- val s2 = mutable.Set.empty[String]
- for (k <- mut.tset) { s2 += k }
- assert(base === s2)
- }
- } else if (pct < 198) {
- atomic { implicit txn =>
- val s2 = mutable.Set.empty[String]
- for (k <- mut.tset.iterator) { s2 += k }
- assert(base === s2)
- }
- } else if (pct < 200) {
- var b = base.toSet
- var s = mut.snapshot
- assert(b.iterator.toSet === s.iterator.toSet)
- while (!b.isEmpty) {
- if (rand.nextInt(100) < 75) {
- val k = b.iterator.next
- assert(b(k) === s(k))
- b -= k
- s -= k
- assert(b.size === s.size)
- } else {
- val k = nextKey
- b += k
- s += k
- }
- }
- assert(b.isEmpty === s.isEmpty)
- val k = nextKey
- b += k
- s += k
- assert(b === s)
- } else if (pct < 208) {
- val cutoff = nextKey
- base.retain { v => v < cutoff }
- mut.retain { v => v < cutoff }
- } else if (pct < 211) {
- val cutoff = nextKey
- base.retain { v => v < cutoff }
- atomic { implicit txn => mut.tset.retain { v => v < cutoff } }
- } else if (pct < 214) {
- val b2 = base map { v => v.substring(3).toInt }
- val m2 = mut map { v => v.substring(3).toInt }
- assert(b2 === m2)
- assert(m2 eq m2.tset.single)
- mut = m2 map { v => "key" + v }
- } else if (pct < 217) {
- mut = TSet.View.empty[String] ++ mut
- } else if (pct < 219) {
- mut = atomic { implicit txn => mut.tset.empty ++ mut.tset }
- } else if (pct < 221) {
- val b = TSet.View.newBuilder[String]
- b ++= mut
- b.clear()
- b ++= mut
- mut = b.result
- } else if (pct < 223) {
- mut = (atomic { implicit txn =>
- val b = TSet.newBuilder[String]
- b ++= mut.tset
- b.clear()
- b ++= mut.tset
- b.result
- }).single
- }
- }
- }
-
- test("tset clear") {
- val s = TSet(1, 2)
- atomic { implicit txn => s.clear() }
- assert(s.single.isEmpty)
- assert(s.single.size === 0)
- assert(!s.single.iterator.hasNext)
- for (e <- s.single) { assert(false) }
- }
-
- test("view clear") {
- val s = TSet(1, 2)
- s.single.clear()
- assert(s.single.size === 0)
- assert(!s.single.iterator.hasNext)
- for (e <- s.single) { assert(false) }
- }
-
- test("null entry") {
- val s = TSet("abc", "def", (null: AnyRef))
- assert(s.single.size === 3)
- assert(s.single(null))
- assert(s.single.remove(null))
- assert(s.single.size === 2)
- assert(!s.single(null))
- assert(s.single.add(null))
- assert(s.single.size === 3)
- }
-
- test("view builder magic") {
- val s0 = TSet.View(1, 2, 3)
- val s1 = s0 map { "x" + _ }
- val s2: TSet.View[String] = s1
- assert(s1 === Set("x1", "x2", "x3"))
- }
-
- test("iterator crossing a txn boundary") {
- val ks = (0 until 100) map { i => "x" + (i % 37) }
- val s = TSet(ks: _*)
- val iter = atomic { implicit txn => s.iterator }
- assert(iter.toSet === ks.toSet)
- }
-
- test("iterator after many removes") {
- val s = TSet.View.empty[Int]
- for (i <- 0 until 100000)
- s += i
- for (i <- 0 until 100000)
- s -= i
- assert(!s.iterator.hasNext)
- for (e <- s) { assert(false) }
- atomic { implicit txn => assert(s.tset.isEmpty) }
- atomic { implicit txn => assert(s.tset.size === 0) }
- assert(s.isEmpty)
- assert(s.size === 0)
- }
-
- test("view snapshot foreach") {
- val ks = (0 until 100)
- val s = TSet(ks: _*)
- var n = 0
- for (k <- s.single.snapshot) n += k
- assert(n === 4950)
- }
-
- test("txn snapshot foreach") {
- val ks = (0 until 100)
- val s = TSet(ks: _*)
- var n = 0
- for (k <- atomic { implicit txn => s.snapshot }) n += k
- assert(n === 4950)
- }
-
- test("TxnDebuggable") {
- val s1 = TSet[Int]()
- val s2 = TSet(1)
- val s3 = TSet(1, 2).single
- val s4 = TSet((0 until 10000): _*).single
-
- assert(s1.dbgStr === "TSet[size=0]()")
- assert(s2.dbgStr === "TSet[size=1](1)")
- assert(s3.dbgStr == "TSet[size=2](1, 2)" ||
- s3.dbgStr == "TSet[size=2](2, 1)")
- assert(s4.dbgStr.startsWith("TSet[size=10000]("))
- assert(s4.dbgStr.length >= 1000)
- assert(s4.dbgStr.length < 1100)
-
- assert(s1.dbgValue.asInstanceOf[Array[_]].length === 0)
- assert(s2.dbgValue.asInstanceOf[Array[_]].length === 1)
- assert(s3.dbgValue.asInstanceOf[Array[_]].length === 2)
- assert(s4.dbgValue.asInstanceOf[Array[_]].length === 10000)
- }
-}
diff --git a/benchmarks/scala-stm/scala-stm-library/src/test/scala/scala/concurrent/stm/TokenRingSuite.scala b/benchmarks/scala-stm/scala-stm-library/src/test/scala/scala/concurrent/stm/TokenRingSuite.scala
deleted file mode 100644
index 9ff7ce44..00000000
--- a/benchmarks/scala-stm/scala-stm-library/src/test/scala/scala/concurrent/stm/TokenRingSuite.scala
+++ /dev/null
@@ -1,85 +0,0 @@
-/* scala-stm - (c) 2009-2010, Stanford University, PPL */
-
-package scala.concurrent.stm
-
-import java.util.concurrent.CyclicBarrier
-import org.scalatest.FunSuite
-
-
-/** This test uses the transactional retry mechanism to pass a token around a
- * ring of threads. When there are two threads this is a ping-pong test. A
- * separate `Ref` is used for each handoff.
- *
- * @author Nathan Bronson
- */
-class TokenRingSuite extends FunSuite {
- test("small non-txn threesome") { tokenRing(3, 10000, false, false) }
- test("small txn threesome") { tokenRing(3, 1000, true, false) }
- test("small txn threesome reading via write") { tokenRing(3, 1000, true, true) }
-
- test("non-txn ping-pong", Slow) { tokenRing(2, 1000000, false, false) }
- test("non-txn threesome", Slow) { tokenRing(3, 1000000, false, false) }
- test("non-txn large ring", Slow) { tokenRing(32, 10000, false, false) }
- test("txn ping-pong", Slow) { tokenRing(2, 100000, true, false) }
- test("txn threesome", Slow) { tokenRing(3, 100000, true, false) }
- test("txn large ring", Slow) { tokenRing(32, 10000, true, false) }
- test("txn ping-pong reading via write", Slow) { tokenRing(2, 100000, true, true) }
- test("txn threesome reading via write", Slow) { tokenRing(3, 100000, true, true) }
- test("txn large ring reading via write", Slow) { tokenRing(32, 10000, true, true) }
-
- def tokenRing(ringSize: Int, handoffsPerThread: Int, useTxns: Boolean, useSwap: Boolean) {
- val ready = Array.tabulate(ringSize)(i => Ref(i == 0))
- val threads = new Array[Thread](ringSize - 1)
- val barrier = new CyclicBarrier(ringSize, new Runnable {
- var start = 0L
- def run {
- val now = System.currentTimeMillis
- if (start == 0) {
- start = now
- } else {
- val elapsed = now - start
- val handoffs = handoffsPerThread * ringSize
- println("tokenRing(" + ringSize + "," + handoffsPerThread + "," + useTxns +
- ") total_elapsed=" + elapsed + " msec, throughput=" +
- (handoffs * 1000L) / elapsed + " handoffs/sec, latency=" +
- (elapsed * 1000000L) / handoffs + " nanos/handoff")
- }
- }
- })
-
- for (index <- 0 until ringSize) {
- val work = new Runnable {
- def run {
- val next = (index + 1) % ringSize
- barrier.await
- for (h <- 0 until handoffsPerThread) {
- if (!useTxns) {
- ready(index).single await { _ == true }
- ready(index).single() = false
- ready(next).single() = true
- } else {
- atomic { implicit t =>
- if (!useSwap) {
- if (ready(index).get == false) retry
- ready(index)() = false
- } else {
- if (ready(index).swap(false) == false) retry
- }
- ready(next)() = true
- }
- }
- }
- barrier.await
- }
- }
- if (index < ringSize - 1) {
- threads(index) = new Thread(work, "worker " + index)
- threads(index).start
- } else {
- work.run
- }
- }
-
- for (t <- threads) t.join
- }
-}
diff --git a/benchmarks/scala-stm/scala-stm-library/src/test/scala/scala/concurrent/stm/TxnLocalSuite.scala b/benchmarks/scala-stm/scala-stm-library/src/test/scala/scala/concurrent/stm/TxnLocalSuite.scala
deleted file mode 100644
index 9cf14bb1..00000000
--- a/benchmarks/scala-stm/scala-stm-library/src/test/scala/scala/concurrent/stm/TxnLocalSuite.scala
+++ /dev/null
@@ -1,332 +0,0 @@
-/* scala-stm - (c) 2009-2012, Stanford University, PPL */
-
-package scala.concurrent.stm
-
-import org.scalatest.FunSuite
-
-
-class TxnLocalSuite extends FunSuite {
- test("default initial value") {
- val tl = TxnLocal[String]()
- atomic { implicit txn =>
- assert(tl() === null)
- tl() = "hello"
- }
- atomic { implicit txn =>
- assert(tl() === null)
- }
- atomic { implicit txn =>
- tl() = "transient"
- }
- atomic { implicit txn =>
- assert(tl() === null)
- tl() = "world"
- }
- }
-
- test("initialize with init") {
- val tl = TxnLocal("hello")
- for (i <- 0 until 100) {
- atomic { implicit txn =>
- assert(tl() === "hello")
- tl() = "goodbye"
- }
- }
- }
-
- test("initialize with initialValue") {
- val tl = TxnLocal[Int](
- initialValue = { txn => txn.rootLevel.## }
- )
- atomic { implicit txn =>
- assert(tl() === txn.rootLevel.##)
- }
- atomic { implicit txn =>
- assert(tl() === txn.rootLevel.##)
- }
- }
-
- test("initialValue overrides init") {
- val x = Ref("abc")
- val tl = TxnLocal("hello", initialValue = { implicit txn => x() })
- for (i <- 0 until 100) {
- atomic { implicit txn =>
- assert(tl() === "abc")
- tl() = "goodbye"
- }
- }
- }
-
- test("use in afterCompletion handler") {
- val tl = TxnLocal("default")
- atomic { implicit txn =>
- Txn.afterCompletion { status =>
- atomic { implicit txn =>
- assert(tl() === "default")
- }
- }
- tl() = "set once"
- Txn.afterCompletion { status =>
- atomic { implicit txn =>
- assert(tl() === "default")
- }
- }
- }
- }
-
- test("partial rollback restores previous value") {
- val tl = TxnLocal("default")
- atomic { implicit txn =>
- tl() = "outer"
- intercept[RuntimeException] {
- atomic { implicit txn =>
- assert(tl.swap("inner") === "outer")
- throw new RuntimeException
- }
- }
- assert(tl() === "outer")
- }
- }
-
- test("partial rollback triggers new initialization") {
- val x = Ref(0)
- val tl = TxnLocal( { x.single() } )
- atomic { implicit txn =>
- x() = 1
- assert(!tl.isInitialized)
- intercept[RuntimeException] {
- atomic { implicit txn =>
- assert(!tl.isInitialized)
- x() = 2
- assert(tl() === 2)
- assert(tl.isInitialized)
- throw new RuntimeException
- }
- }
- assert(!tl.isInitialized)
- assert(tl() === 1)
- assert(tl.isInitialized)
- }
- }
-
- test("all RefLike operations") {
- val tl = TxnLocal(init = 10)
- atomic { implicit txn =>
- assert(tl.get === 10)
- assert(tl() === 10)
- assert(tl.getWith( _ + 5 ) === 15)
- assert(tl.relaxedGet( _ == _ ) === 10)
- tl.set(15)
- assert(tl() === 15)
- tl() = 20
- assert(tl() === 20)
- assert(tl.trySet(25))
- assert(tl() === 25)
- assert(tl.swap(30) === 25)
- tl.transform( _ + 7 )
- assert(tl() === 37)
- assert(tl.transformIfDefined {
- case x if x > 20 => x + 1
- })
- assert(tl() === 38)
- assert(!tl.transformIfDefined {
- case x if x < 20 => x + 1
- })
- }
- }
-
- test("first init in whilePreparing handler") {
- val tl = TxnLocal(10)
- atomic { implicit txn =>
- Txn.whilePreparing { implicit txn =>
- assert(tl() == 10)
- tl() = 20
- }
- Txn.whilePreparing { implicit txn =>
- assert(tl() == 20)
- }
- }
- }
-
- test("first initialValue in beforeCommit handler") {
- val tl = TxnLocal(initialValue = { _ => 10 })
- atomic { implicit txn =>
- Txn.beforeCommit { implicit txn =>
- assert(tl() == 10)
- tl() = 20
- }
- Txn.beforeCommit { implicit txn =>
- assert(tl() == 20)
- }
- }
- }
-
- test("first initialValue in whilePreparing handler") {
- val tl = TxnLocal(initialValue = { _ => 10 })
- val x = Ref("abc")
- intercept[IllegalStateException] {
- atomic { implicit txn =>
- x() = "def"
- Txn.whilePreparing { implicit txn =>
- assert(tl() == 10)
- tl() = 20
- }
- }
- }
- assert(x.single() === "abc")
- }
-
- test("first initialValue in whileCommitting handler") {
- val tl = TxnLocal(initialValue = { _ => 10 })
- var failure: Throwable = null
- val handler = { (s: Txn.Status, x: Throwable) => failure = x }
- val x = Ref("abc")
- atomic.withPostDecisionFailureHandler(handler) { implicit txn =>
- x() = "def"
- Txn.whileCommitting { implicit txn =>
- assert(tl() == 10)
- tl() = 20
- }
- }
- assert(x.single() === "def")
- assert(failure != null && failure.isInstanceOf[IllegalStateException])
- }
-
- test("auto-register beforeCommit") {
- val x = Ref(0)
- lazy val tl: TxnLocal[Int] = TxnLocal(10, beforeCommit = { implicit txn =>
- assert(Txn.status === Txn.Active)
- x() = tl()
- })
- atomic { implicit txn =>
- tl() = 20
- }
- assert(x.single() === 20)
- }
-
- test("auto-register whilePreparing") {
- var result: Int = 0
- lazy val tl: TxnLocal[Int] = TxnLocal(10, whilePreparing = { implicit txn =>
- assert(Txn.status === Txn.Preparing)
- assert(result === 0)
- tl += 10
- result = tl()
- })
- atomic { implicit txn =>
- tl() = 20
- }
- assert(result === 30)
- }
-
- test("auto-register whileCommitting") {
- var result: Int = 0
- lazy val tl: TxnLocal[Int] = TxnLocal(10, whileCommitting = { implicit txn =>
- assert(Txn.status === Txn.Committing)
- assert(result === 0)
- tl += 10
- result = tl()
- })
- atomic { implicit txn =>
- tl() = 20
- }
- assert(result === 30)
- }
-
- test("auto-register afterCommit") {
- var result: Int = 0
- val tl = TxnLocal(10, afterCommit = { (v: Int) => result = v })
- atomic { implicit txn =>
- tl() = 20
- }
- assert(result === 20)
- }
-
- test("auto-register afterRollback") {
- var result: Txn.Status = null
- val tl = TxnLocal(10, afterRollback = { result = _ })
- intercept[ArrayIndexOutOfBoundsException] {
- atomic { implicit txn =>
- tl() = 20
- throw new ArrayIndexOutOfBoundsException(-1)
- }
- }
- assert(result != null && result.isInstanceOf[Txn.RolledBack])
- }
-
- test("auto-register afterCompletion - commit") {
- var result: Txn.Status = null
- val tl = TxnLocal(10, afterCompletion = { result = _ })
- atomic { implicit txn =>
- tl() = 20
- }
- assert(result === Txn.Committed)
- }
-
- test("auto-register afterCompletion - rollback") {
- var result: Txn.Status = null
- val tl = TxnLocal(10, afterCompletion = { result = _ })
- intercept[ArrayIndexOutOfBoundsException] {
- atomic { implicit txn =>
- tl() = 20
- throw new ArrayIndexOutOfBoundsException(-1)
- }
- }
- assert(result != null && result.isInstanceOf[Txn.RolledBack])
- }
-
- test("auto-register everything") {
- var ran = Set.empty[String]
- val tl = TxnLocal(
- init = "init",
- initialValue = { implicit txn => ran += "initialValue" ; "initialValue" },
- beforeCommit = { implicit txn => assert(txn.status === Txn.Active) ; ran += "beforeCommit" },
- whilePreparing = { implicit txn => assert(txn.status === Txn.Preparing) ; ran += "whilePreparing" },
- whileCommitting = { implicit txn => assert(txn.status === Txn.Committing) ; ran += "whileCommitting" },
- afterCommit = { (v: String) => assert(v === "initialValue") ; ran += "afterCommit" },
- afterRollback = { status => assert(false) },
- afterCompletion = { status => assert(status === Txn.Committed) ; ran += "afterCompletion" }
- )
- atomic { implicit txn =>
- assert(tl() === "initialValue")
- }
- assert(ran === Set("initialValue", "beforeCommit", "whilePreparing", "whileCommitting", "afterCommit", "afterCompletion"))
- }
-
- test("isolation") {
- val barrier = new java.util.concurrent.CyclicBarrier(2)
- val tl = TxnLocal("init")
- var failure: Throwable = null
- new Thread {
- override def run() {
- try {
- atomic { implicit txn =>
- barrier.await
- assert(tl() === "init")
- barrier.await
- tl() = "thread"
- barrier.await
- assert(tl() === "thread")
- barrier.await
- }
- } catch {
- case x: Throwable => failure = x
- }
- barrier.await
- }
- }.start()
-
- atomic { implicit txn =>
- barrier.await
- assert(tl() === "init")
- barrier.await
- tl() = "main"
- barrier.await
- assert(tl() === "main")
- barrier.await
- }
- barrier.await
-
- if (failure != null)
- throw failure
- }
-}
diff --git a/benchmarks/scala-stm/scala-stm-library/src/test/scala/scala/concurrent/stm/TxnSuite.scala b/benchmarks/scala-stm/scala-stm-library/src/test/scala/scala/concurrent/stm/TxnSuite.scala
deleted file mode 100644
index cab54dc4..00000000
--- a/benchmarks/scala-stm/scala-stm-library/src/test/scala/scala/concurrent/stm/TxnSuite.scala
+++ /dev/null
@@ -1,640 +0,0 @@
-/* scala-stm - (c) 2009-2012, Stanford University, PPL */
-
-package scala.concurrent.stm
-
-import org.scalatest.FunSuite
-import java.util.concurrent.CountDownLatch
-
-
-class TxnSuite extends FunSuite {
-
- test("empty transaction") {
- atomic { implicit t =>
- () // do nothing
- }
- }
-
- test("atomic function") {
- val answer = atomic { implicit t =>
- 42
- }
- assert(Integer.parseInt(answer.toString, 13) === 6*9)
- }
-
- test("large transaction") {
- val refs = Array.tabulate(10000) { i => Ref(i) }
- atomic { implicit txn =>
- for (r <- refs)
- r() = r() + 1
- }
- }
-
- test("duplicate view with old access") {
- val x = Ref(1)
- atomic { implicit t =>
- val b1 = x.single
- assert(b1.get === 1)
- val b2 = x.single
- assert(b2.get === 1)
- b1() = 2
- assert(b1.get === 2)
- assert(b2.get === 2)
- b2() = 3
- assert(b1.get === 3)
- assert(b2.get === 3)
- }
- assert(x.single.get === 3)
- }
-
- class UserException extends Exception
-
- test("failure atomicity") {
- val x = Ref(1)
- intercept[UserException] {
- atomic { implicit t =>
- x() = 2
- throw new UserException
- }
- }
- assert(x.single.get === 1)
- }
-
- test("non-local return") {
- val x = Ref(1)
- val y = nonLocalReturnHelper(x)
- assert(x.single.get === 2)
- assert(y === 2)
- }
-
- def nonLocalReturnHelper(x: Ref[Int]): Int = {
- atomic { implicit t =>
- x() = x() + 1
- return x()
- }
- -1
- }
-
- test("strings") {
- atomic.toString
- atomic.withRetryTimeout(100).toString
- atomic { implicit txn => txn.toString }
- atomic { implicit txn => NestingLevel.root.toString }
- }
-
- test("basic retry") {
- val x = Ref(0)
- val y = Ref(false)
- val b = new CountDownLatch(1)
- new Thread {
- override def run() {
- b.await()
- Thread.sleep(10)
- y.single() = true
- x.single() = 1
- }
- }.start()
-
- atomic { implicit txn =>
- b.countDown()
- if (x() == 0)
- retry
- }
- assert(y.single())
- }
-
- test("nested retry") {
- val x = Ref(0)
- val y = Ref(false)
- val b = new CountDownLatch(1)
- new Thread {
- override def run() {
- b.await()
- Thread.sleep(10)
- y.single() = true
- x.single() = 1
- }
- }.start()
-
- atomic { implicit txn =>
- atomic { implicit txn =>
- // this will cause the nesting to materialize
- NestingLevel.current
-
- b.countDown()
- if (x() == 0)
- retry
- }
- }
- assert(y.single())
- }
-
- test("simple orAtomic") {
- val x = Ref(0)
- val f = atomic { implicit txn =>
- if (x() == 0)
- retry
- false
- } orAtomic { implicit txn =>
- true
- }
- assert(f)
- }
-
- test("single atomic.oneOf") {
- val x = Ref("zero")
- atomic.oneOf({ implicit txn =>
- x() = "one"
- })
- assert(x.single() === "one")
- }
-
- test("atomic.oneOf") {
- val refs = Array(Ref(false), Ref(false), Ref(false))
- for (w <- 0 until 3) {
- new Thread("wakeup") {
- override def run() {
- Thread.sleep(200)
- refs(w).single() = true
- }
- }.start()
- oneOfExpect(refs, w, Array(0))
- }
- }
-
- test("nested atomic.oneOf") {
- val refs = Array(Ref(false), Ref(false), Ref(false))
- for (w <- 0 until 3) {
- new Thread("wakeup") {
- override def run() {
- Thread.sleep(200)
- refs(w).single() = true
- }
- }.start()
- val retries = Array(0)
- atomic { implicit txn => oneOfExpect(refs, w, retries) }
- }
- }
-
- test("alternative atomic.oneOf") {
- val a = Ref(0)
- val refs = Array(Ref(false), Ref(false), Ref(false))
- for (w <- 0 until 3) {
- new Thread("wakeup") {
- override def run() {
- Thread.sleep(200)
- refs(w).single() = true
- }
- }.start()
- val retries = Array(0)
- val f = atomic { implicit txn =>
- if (a() == 0)
- retry
- false
- } orAtomic { implicit txn =>
- oneOfExpect(refs, w, retries)
- true
- }
- assert(f)
- }
- }
-
- private def oneOfExpect(refs: Array[Ref[Boolean]], which: Int, sleeps: Array[Int]) {
- val result = Ref(-1)
- atomic.oneOf(
- { t: InTxn => implicit val txn = t; result() = 0 ; if (!refs(0)()) retry },
- { t: InTxn => implicit val txn = t; if (refs(1)()) result() = 1 else retry },
- { t: InTxn => implicit val txn = t; if (refs(2)()) result() = 2 else retry },
- { t: InTxn => implicit val txn = t; sleeps(0) += 1 ; retry }
- )
- refs(which).single() = false
- assert(result.single.get === which)
- if (sleeps(0) != 0)
- assert(sleeps(0) === 1)
- }
-
- test("orAtomic w/ exception") {
- intercept[UserException] {
- atomic { implicit t =>
- if ("likely".hashCode != 0)
- retry
- } orAtomic { implicit t =>
- throw new UserException
- }
- }
- }
-
- test("Atomic.orAtomic") {
- val x = Ref(1)
- def a() = {
- atomic { implicit t =>
- if (x() > 1) true else retry
- } orAtomic { implicit t =>
- false
- }
- }
- assert(a() === false)
- x.single() = 2
- assert(a() === true)
- }
-
- test("simple nesting") {
- val x = Ref(10)
- atomic { implicit t =>
- x += 1
- atomic { implicit t =>
- assert(x.get === 11)
- x += 2
- }
- assert(x.get === 13)
- }
- assert(x.single.get === 13)
- }
-
- test("partial rollback") {
- val x = Ref("none")
- atomic { implicit t =>
- x() = "outer"
- try {
- atomic { implicit t =>
- x() = "inner"
- throw new UserException
- }
- } catch {
- case _: UserException =>
- }
- }
- assert(x.single() === "outer")
- }
-
- test("partial rollback of transform") {
- val x = Ref("none")
- atomic { implicit t =>
- x() = "outer"
- try {
- atomic { implicit t =>
- x.transform { _ + "inner" }
- throw new UserException
- }
- } catch {
- case _: UserException =>
- }
- }
- assert(x.single() === "outer")
- }
-
- test("partial rollback due to invalid read") {
- val x = Ref(0)
- val y = Ref(0)
-
- (new Thread { override def run() { Thread.sleep(100) ; y.single() = 1 } }).start()
-
- atomic { implicit t =>
- x()
- atomic { implicit t =>
- y()
- Thread.sleep(200)
- y()
- } orAtomic { implicit t =>
- throw new Error("should not be run")
- }
- } orAtomic { implicit t =>
- throw new Error("should not be run")
- }
- }
-
- test("View in txn") {
- val x = Ref(10)
- val xs = x.single
- atomic { implicit t =>
- x += 1
- assert(x() === 11)
- assert(xs() === 11)
- xs += 1
- assert(x() === 12)
- assert(xs() === 12)
- x.single += 1
- assert(x() === 13)
- assert(xs() === 13)
- assert(x.single() === 13)
- x.single() = 14
- assert(x() === 14)
- }
- }
-
- test("currentLevel during nesting") {
- // this test is _tricky_, because an assertion failure inside the atomic
- // block might cause a restart that expands any subsumption
- val (n0, n1, n2) = atomic { implicit t =>
- val (n1, n2) = atomic { implicit t =>
- val n2 = atomic { implicit t =>
- NestingLevel.current
- }
- (NestingLevel.current, n2)
- }
- (NestingLevel.current, n1, n2)
- }
- assert(n2.parent.get eq n1)
- assert(n2.root eq n0)
- assert(n1.parent.get eq n0)
- assert(n1.root eq n0)
- assert(n0.parent.isEmpty)
- }
-
- test("persistent rollback") {
- val x = Ref(0)
- var okay = true
- intercept[UserException] {
- atomic { implicit txn =>
- x() = 1
- try {
- Txn.rollback(Txn.UncaughtExceptionCause(new UserException()))
- } catch {
- case _: Throwable => // swallow
- }
- x()
- okay = false
- }
- }
- assert(okay)
- }
-
- test("persistent rollback via exception") {
- val x = Ref(0)
- intercept[UserException] {
- atomic { implicit txn =>
- x() = 1
- try {
- Txn.rollback(Txn.UncaughtExceptionCause(new UserException()))
- } catch {
- case _: Throwable => // swallow
- }
- throw new InterruptedException // this should be swallowed
- }
- }
- }
-
- test("many multi-level reads") {
- val refs = Array.tabulate(10000) { _ => Ref(0) }
- atomic { implicit txn =>
- for (r <- refs) r() = 1
- val f = atomic { implicit txn =>
- for (r <- refs) r() = 2
- if (refs(0)() != 0)
- retry
- false
- } orAtomic { implicit txn =>
- true
- }
- assert(f)
- }
- for (r <- refs)
- assert(r.single() === 1)
- }
-
- test("partial rollback of invalid read") {
- val x = Ref(0)
- var xtries = 0
- val y = Ref(0)
- var ytries = 0
-
- (new Thread { override def run() { Thread.sleep(100) ; y.single() = 1 } }).start()
-
- atomic { implicit txn =>
- xtries += 1
- x += 1
- atomic { implicit txn =>
- ytries += 1
- y()
- Thread.sleep(200)
- y()
- } orAtomic { implicit txn =>
- throw new Error("should not be run")
- }
- }
-
- // We can't assert, because different STMs might do different things.
- // For CCSTM it should be 1, 2
- println("xtries = " + xtries + ", ytries = " + ytries)
- }
-
- test("await") {
- val x = Ref(0)
-
- new Thread {
- override def run() {
- Thread.sleep(50)
- x.single() = 1
- Thread.sleep(50)
- x.single() = 2
- }
- }.start()
-
- x.single.await( _ == 2 )
- assert(x.single() === 2)
- }
-
- test("remote cancel") {
- val x = Ref(0)
-
- val finished = atomic { implicit txn =>
- x += 1
- NestingLevel.current
- }
- assert(x.single() === 1)
-
- for (i <- 0 until 100) {
- intercept[UserException] {
- atomic { implicit txn =>
- val active = NestingLevel.current
- new Thread {
- override def run() {
- val cause = Txn.UncaughtExceptionCause(new UserException)
- assert(finished.requestRollback(cause) === Txn.Committed)
- assert(active.requestRollback(cause) == Txn.RolledBack(cause))
- }
- }.start()
-
- while (true)
- x() = x() + 1
- }
- }
- assert(x.single() === 1)
- }
- }
-
- test("remote cancel of root") {
- val x = Ref(0)
-
- val finished = atomic { implicit txn =>
- x += 1
- NestingLevel.current
- }
- assert(x.single() === 1)
-
- for (i <- 0 until 100) {
- intercept[UserException] {
- atomic { implicit txn =>
- // this is to force true nesting for CCSTM, but the test should pass for any STM
- atomic { implicit txn => NestingLevel.current }
-
- val active = NestingLevel.current
- new Thread {
- override def run() {
- Thread.`yield`()
- Thread.`yield`()
- val cause = Txn.UncaughtExceptionCause(new UserException)
- assert(finished.requestRollback(cause) === Txn.Committed)
- assert(active.requestRollback(cause) == Txn.RolledBack(cause))
- }
- }.start()
-
- while (true)
- atomic { implicit txn => x += 1 }
- }
- }
- assert(x.single() === 1)
- }
- }
-
- test("remote cancel of child") {
- val x = Ref(0)
-
- for (i <- 0 until 100) {
- intercept[UserException] {
- atomic { implicit txn =>
- atomic { implicit txn =>
- val active = NestingLevel.current
- new Thread {
- override def run() {
- Thread.`yield`()
- Thread.`yield`()
- val cause = Txn.UncaughtExceptionCause(new UserException)
- assert(active.requestRollback(cause) == Txn.RolledBack(cause))
- }
- }.start()
-
- while (true)
- x() = x() + 1
- }
- }
- }
- assert(x.single() === 0)
- }
- }
-
- test("toString") {
- (atomic { implicit txn =>
- txn.toString
- txn
- }).toString
- (atomic { implicit txn =>
- NestingLevel.current.toString
- NestingLevel.current
- }).toString
- }
-
- test("many simultaneous Txns", Slow) {
- // CCSTM supports 2046 simultaneous transactions
- val threads = Array.tabulate(2500) { _ => new Thread {
- override def run() { atomic { implicit txn => Thread.sleep(1000) } }
- }}
- val begin = System.currentTimeMillis
- for (t <- threads) t.start()
- for (t <- threads) t.join()
- val elapsed = System.currentTimeMillis - begin
- println(threads.length + " empty sleep(1000) txns took " + elapsed + " millis")
- }
-
- perfTest("uncontended R+W txn perf") { (x, y) =>
- var i = 0
- while (i < 5) {
- i += 1
- atomic { implicit t =>
- assert(x() == "abc")
- x() = "def"
- }
- atomic { implicit t =>
- assert(x() == "def")
- x() = "abc"
- }
- }
- }
-
- for (depth <- List(0, 1, 2, 8)) {
- perfTest("uncontended R+W txn perf: nesting depth " + depth) { (x, y) =>
- var i = 0
- while (i < 5) {
- i += 1
- nested(depth) { implicit t =>
- assert(x() == "abc")
- x() = "def"
- }
- nested(depth) { implicit t =>
- assert(x() == "def")
- x() = "abc"
- }
- }
- }
- }
-
- perfTest("uncontended R+R txn perf") { (x, y) =>
- var i = 0
- while (i < 10) {
- i += 1
- atomic { implicit t =>
- assert(x() == "abc")
- assert(y() == 10)
- }
- }
- }
-
- for (depth <- List(0, 1, 2, 8)) {
- perfTest("uncontended R+R txn perf: nesting depth " + depth) { (x, y) =>
- var i = 0
- while (i < 10) {
- i += 1
- nested(depth) { implicit t =>
- assert(x() == "abc")
- assert(y() == 10)
- }
- }
- }
- }
-
-// for (i <- 0 until 50) {
-// perfTest("uncontended R+R txn perf: nesting depth 8, take " + i) { (x, y) =>
-// var i = 0
-// while (i < 10) {
-// i += 1
-// nested(8) { implicit t =>
-// assert(x() == "abc")
-// assert(y() == 10)
-// }
-// }
-// }
-// }
-
- private def nested(depth: Int)(body: InTxn => Unit) {
- atomic { implicit txn =>
- if (depth == 0)
- body(txn)
- else
- nested(depth - 1)(body)
- }
- }
-
- private def perfTest(name: String)(runTen: (Ref[String], Ref[Int]) => Unit) {
- test(name, Slow) {
- val x = Ref("abc")
- val y = Ref(10)
- var best = java.lang.Long.MAX_VALUE
- for (pass <- 0 until 50000) {
- val begin = System.nanoTime
- runTen(x, y)
- val elapsed = System.nanoTime - begin
- best = best min elapsed
- }
- println(name + ": best was " + (best / 10.0) + " nanos/txn")
- }
- }
-}
diff --git a/benchmarks/scala-stm/scala-stm-library/src/test/scala/scala/concurrent/stm/UnrecordedTxnSuite.scala b/benchmarks/scala-stm/scala-stm-library/src/test/scala/scala/concurrent/stm/UnrecordedTxnSuite.scala
deleted file mode 100644
index 657f7a2e..00000000
--- a/benchmarks/scala-stm/scala-stm-library/src/test/scala/scala/concurrent/stm/UnrecordedTxnSuite.scala
+++ /dev/null
@@ -1,154 +0,0 @@
-/* scala-stm - (c) 2009-2012, Stanford University, PPL */
-
-package scala.concurrent.stm
-
-import org.scalatest.FunSuite
-import java.util.concurrent.CountDownLatch
-
-
-class UnrecordedTxnSuite extends FunSuite {
-
- test("fixed unrecorded txn") {
- val z = atomic.unrecorded { implicit txn => "foo" }
- assert(z === "foo")
- }
-
- test("nested fixed unrecorded txn") {
- val x = Ref(0)
- val z = atomic { implicit txn =>
- x() = 1
- atomic.unrecorded { implicit txn => "foo" }
- }
- assert(z === "foo")
- }
-
- test("writing unrecorded txn") {
- val x = Ref(0)
- val z = atomic.unrecorded { implicit txn =>
- x() = 1
- "foo"
- }
- assert(z === "foo")
- assert(x.single() === 0)
- }
-
- test("nested unrecorded txn") {
- val x = Ref(0)
- val z = atomic.unrecorded { implicit txn =>
- x += 1
- atomic.unrecorded { implicit txn =>
- x += 1
- atomic.unrecorded { implicit txn =>
- x += 1
- atomic.unrecorded { implicit txn =>
- x += 1
- atomic.unrecorded { implicit txn =>
- x += 1
- atomic.unrecorded { implicit txn =>
- x += 1
- atomic.unrecorded { implicit txn =>
- x()
- }
- }
- }
- }
- }
- }
- }
- assert(z === 6)
- assert(x.single() === 0)
- }
-
- test("nested new write unrecorded txn") {
- val x = Ref(0)
- val z = atomic { implicit txn =>
- atomic.unrecorded { implicit txn =>
- x() = 1
- "foo"
- }
- }
- assert(x.single() === 0)
- assert(z === "foo")
- }
-
- test("nested update unrecorded txn") {
- val x = Ref(0)
- val z = atomic { implicit txn =>
- x() = 1
- atomic.unrecorded { implicit txn =>
- x() = 2
- "foo"
- }
- }
- assert(x.single() === 1)
- assert(z === "foo")
- }
-
- test("nested preceding unrecorded txn") {
- val x = Ref(0)
- val z = atomic { implicit txn =>
- val z = atomic.unrecorded { implicit txn =>
- x() = 2
- "foo"
- }
- x() = 1
- z
- }
- assert(x.single() === 1)
- assert(z === "foo")
- }
-
- test("read set emptied") {
- val b = new CountDownLatch(1)
- val e = new CountDownLatch(1)
-
- val x = Ref(0)
-
- new Thread {
- override def run() {
- b.await()
- x.single() = 1
- e.countDown()
- }
- }.start()
-
- var tries = 0
- val (z1, z2) = atomic { implicit txn =>
- tries += 1
- val z1 = atomic.unrecorded { implicit txn => x() }
- b.countDown()
- e.await()
- (z1, x())
- }
-
- assert(z1 === 0)
- assert(z2 === 1)
- assert(tries === 1)
- }
-
- class TestException extends Exception
-
- test("outerFailure handler") {
-
- val x = Ref(0)
-
- var z: Any = null
- intercept[TestException] {
- atomic { implicit txn =>
- val level = NestingLevel.root
- val done = new CountDownLatch(1)
- new Thread {
- override def run() {
- level.requestRollback(Txn.UncaughtExceptionCause(new TestException))
- done.countDown()
- }
- }.start()
- done.await()
-
- z = atomic.unrecorded({ implicit txn => x() }, { cause => cause })
- }
- }
-
- assert(z.isInstanceOf[Txn.UncaughtExceptionCause])
- }
-}
\ No newline at end of file
diff --git a/benchmarks/scala-stm/scala-stm-library/src/test/scala/scala/concurrent/stm/WriteSkewSuite.scala b/benchmarks/scala-stm/scala-stm-library/src/test/scala/scala/concurrent/stm/WriteSkewSuite.scala
deleted file mode 100644
index 3ea13135..00000000
--- a/benchmarks/scala-stm/scala-stm-library/src/test/scala/scala/concurrent/stm/WriteSkewSuite.scala
+++ /dev/null
@@ -1,61 +0,0 @@
-/* scala-stm - (c) 2009-2016, Stanford University, PPL */
-
-package scala.concurrent.stm
-
-import org.scalatest.FunSuite
-
-
-class WriteSkewSuite extends FunSuite {
- val IncrCount = 1000000
-
- test("write skew test 1K") { runTest(1000) }
- test("write skew test 1M", Slow) { runTest(1000000) }
-
- def runTest(incrCount: Int) {
- // Two threads, each of which increments its own Ref if the other Ref is
- // even. Neither thread should ever observe that both Refs are odd.
- // MVCC STMs will require the addition of something like Clojure's "ensure"
- // or SQL's "select for update" to avoid the write skew.
- val refs = Array(Ref(0), Ref(0))
- val threads = new Array[Thread](2)
-
- @volatile var failure: Throwable = null
- for (id <- 0 to 1) {
- threads(id) = new Thread("write skew #" + id) {
- val self = refs(id)
- val other = refs(1 - id)
-
- override def run {
- try {
- for (i <- 0 until incrCount) {
- if (null != failure)
- return
- atomic { implicit t =>
- if ((other() % 2) != 0) {
- if ((self() % 2) != 0)
- fail("refs=" + refs.map(_.get))
- retry
- }
- self() = self() + 1
- }
- }
- } catch {
- case x: Throwable => {
- if (null == failure)
- failure = x
- }
- }
- }
- }
- }
-
- val begin = System.currentTimeMillis
- for (t <- threads) t.start
- for (t <- threads) t.join
-
- if (null != failure)
- throw failure
- val elapsed = System.currentTimeMillis - begin
- println("writeSkew(" + (2 * incrCount) + "): " + elapsed + " millis total")
- }
-}
diff --git a/benchmarks/scala-stm/scala-stm-library/src/test/scala/scala/concurrent/stm/examples/BasicSyntax.scala b/benchmarks/scala-stm/scala-stm-library/src/test/scala/scala/concurrent/stm/examples/BasicSyntax.scala
deleted file mode 100644
index 89380a42..00000000
--- a/benchmarks/scala-stm/scala-stm-library/src/test/scala/scala/concurrent/stm/examples/BasicSyntax.scala
+++ /dev/null
@@ -1,49 +0,0 @@
-/* scala-stm - (c) 2009-2010, Stanford University, PPL */
-
-package scala.concurrent.stm
-package examples
-
-object BasicSyntax {
- case class Point(x: Int, y: Int)
- val origin = Point(0, 0)
-
- val top = Ref(origin)
- val bottom = Ref(origin)
- val left = Ref(origin)
- val right = Ref(origin)
-
- def updateExtremes(p: Point) {
- atomic { implicit txn =>
- if (p.x < left().x)
- left() = p
- if (p.x > right().x)
- right() = p
- if (p.y < top().y)
- top() = p
- if (p.y > bottom().y)
- bottom() = p
- }
- }
-
- def alternatives {
- val z = atomic { implicit txn =>
- if (!(left().x < -100))
- retry
- "left"
- } orAtomic { implicit txn =>
- if (!(right().x > +100))
- retry
- "right"
- } orAtomic { implicit txn =>
- if (!(top().y < -100))
- retry
- "top"
- } orAtomic { implicit txn =>
- if (!(bottom().y > +100))
- retry
- "bottom"
- }
- println("first out was " + z)
- }
-
-}
diff --git a/benchmarks/scala-stm/scala-stm-library/src/test/scala/scala/concurrent/stm/examples/ConcurrentIntList.scala b/benchmarks/scala-stm/scala-stm-library/src/test/scala/scala/concurrent/stm/examples/ConcurrentIntList.scala
deleted file mode 100644
index 121c8203..00000000
--- a/benchmarks/scala-stm/scala-stm-library/src/test/scala/scala/concurrent/stm/examples/ConcurrentIntList.scala
+++ /dev/null
@@ -1,80 +0,0 @@
-/* scala-stm - (c) 2009-2010, Stanford University, PPL */
-
-package scala.concurrent.stm.examples
-
-import scala.concurrent.stm._
-
-class ConcurrentIntList {
- private class Node(val elem: Int, prev0: Node, next0: Node) {
- val isHeader = prev0 == null
- val prev = Ref(if (isHeader) this else prev0)
- val next = Ref(if (isHeader) this else next0)
- }
-
- private val header = new Node(-1, null, null)
-
- def addLast(elem: Int) {
- atomic { implicit txn =>
- val p = header.prev()
- val newNode = new Node(elem, p, header)
- p.next() = newNode
- header.prev() = newNode
- }
- }
-
- def addLast(e1: Int, e2: Int, elems: Int*) {
- atomic { implicit txn =>
- addLast(e1)
- addLast(e2)
- elems foreach { addLast(_) }
- }
- }
-
- //def isEmpty = atomic { implicit t => header.next() == header }
- def isEmpty = header.next.single() == header
-
- def removeFirst(): Int = atomic { implicit txn =>
- val n = header.next()
- if (n == header)
- retry
- val nn = n.next()
- header.next() = nn
- nn.prev() = header
- n.elem
- }
-
- def maybeRemoveFirst(): Option[Int] = {
- atomic { implicit txn =>
- Some(removeFirst())
- } orAtomic { implicit txn =>
- None
- }
- }
-
- override def toString: String = {
- atomic { implicit txn =>
- val buf = new StringBuilder("ConcurrentIntList(")
- var n = header.next()
- while (n != header) {
- buf ++= n.elem.toString
- n = n.next()
- if (n != header) buf ++= ","
- }
- buf ++= ")" toString
- }
- }
-}
-
-object ConcurrentIntList {
- def select(stacks: ConcurrentIntList*): (ConcurrentIntList, Int) = {
- atomic { implicit txn =>
- for (s <- stacks) {
- s.maybeRemoveFirst() match {
- case Some(e) => return (s, e)
- case None =>
- }
- }
- retry
- }
- }
-}
diff --git a/benchmarks/scala-stm/scala-stm-library/src/test/scala/scala/concurrent/stm/examples/DiningPhilosophers.scala b/benchmarks/scala-stm/scala-stm-library/src/test/scala/scala/concurrent/stm/examples/DiningPhilosophers.scala
deleted file mode 100644
index e4e6e777..00000000
--- a/benchmarks/scala-stm/scala-stm-library/src/test/scala/scala/concurrent/stm/examples/DiningPhilosophers.scala
+++ /dev/null
@@ -1,57 +0,0 @@
-/* scala-stm - (c) 2009-2010, Stanford University, PPL */
-
-package scala.concurrent.stm
-package examples
-
-/** See http://en.wikipedia.org/wiki/Dining_philosophers_problem
- * The STM solution is particularly straightforward because we can
- * simultaneously pick up two forks.
- */
-object DiningPhilosophers {
-
- class Fork {
- val inUse = Ref(false)
- }
-
- class PhilosopherThread(meals: Int, left: Fork, right: Fork) extends Thread {
- override def run() {
- for (m <- 0 until meals) {
- // THINK
- pickUpBothForks()
- // EAT
- putDown(left)
- putDown(right)
- }
- }
-
- def pickUpBothForks() {
- atomic { implicit txn =>
- if (left.inUse() || right.inUse())
- retry
- left.inUse() = true
- right.inUse() = true
- }
- }
-
- def putDown(f: Fork) {
- f.inUse.single() = false
- }
- }
-
- def time(tableSize: Int, meals: Int): Long = {
- val forks = Array.tabulate(tableSize) { _ => new Fork }
- val threads = Array.tabulate(tableSize) { i => new PhilosopherThread(meals, forks(i), forks((i + 1) % tableSize)) }
- val start = System.currentTimeMillis
- for (t <- threads) t.start()
- for (t <- threads) t.join()
- System.currentTimeMillis - start
- }
-
- def main(args: Array[String]) {
- val meals = 100000
- for (p <- 0 until 3) {
- val elapsed = time(5, meals)
- printf("%3.1f usec/meal\n", (elapsed * 1000.0) / meals)
- }
- }
-}
diff --git a/benchmarks/scala-stm/scala-stm-library/src/test/scala/scala/concurrent/stm/examples/IndexedMap.scala b/benchmarks/scala-stm/scala-stm-library/src/test/scala/scala/concurrent/stm/examples/IndexedMap.scala
deleted file mode 100644
index 329a4dbb..00000000
--- a/benchmarks/scala-stm/scala-stm-library/src/test/scala/scala/concurrent/stm/examples/IndexedMap.scala
+++ /dev/null
@@ -1,152 +0,0 @@
-/* scala-stm - (c) 2009-2010, Stanford University, PPL */
-
-package scala.concurrent.stm
-package examples
-
-import util.Random
-
-class IndexedMap[A, B] {
-
- private class Index[C](view: (A, B) => Iterable[C]) extends (C => Map[A, B]) {
- val mapping = TMap.empty[C, Map[A, B]]
-
- def apply(derived: C) = mapping.single.getOrElse(derived, Map.empty[A, B])
-
- def += (kv: (A, B))(implicit txn: InTxn) {
- for (c <- view(kv._1, kv._2))
- mapping(c) = apply(c) + kv
- }
-
- def -= (kv: (A, B))(implicit txn: InTxn) {
- for (c <- view(kv._1, kv._2)) {
- val after = mapping(c) - kv._1
- if (after.isEmpty)
- mapping -= c
- else
- mapping(c) = after
- }
- }
- }
-
- private val contents = TMap.empty[A, B]
- private val indices = Ref(List.empty[Index[_]])
-
- def addIndex[C](view: (A, B) => Iterable[C]): (C => Map[A, B]) = atomic { implicit txn =>
- val index = new Index(view)
- indices() = index :: indices()
- contents foreach { index += _ }
- index
- }
-
- def get(key: A): Option[B] = contents.single.get(key)
-
- def put(key: A, value: B): Option[B] = atomic { implicit txn =>
- val prev = contents.put(key, value)
- for (p <- prev; i <- indices())
- i -= (key -> p)
- for (i <- indices())
- i += (key -> value)
- prev
- }
-
- def remove(key: A): Option[B] = atomic { implicit txn =>
- val prev = contents.remove(key)
- for (p <- prev; i <- indices())
- i -= (key -> p)
- prev
- }
-}
-
-object IndexedMap {
-
- case class User(id: Int, name: String, likes: Set[String])
-
- val users = new IndexedMap[Int, User]
- val byName = users.addIndex { (id, u) => Some(u.name) }
- val byLike = users.addIndex { (id, u) => u.likes }
-
- //////// data
-
- val topBabyNames = Array(
- "Ethan", "Isabella", "Jacob", "Olivia", "Noah", "Sophia", "Logan", "Emma", "Liam", "Ava", "Aiden", "Abigail",
- "Mason", "Chloe", "Jackson", "Madison", "Jack", "Ella", "Jayden", "Addison", "Ryan", "Emily", "Matthew", "Lily",
- "Lucas", "Mia", "Michael", "Avery", "Alexander", "Grace", "Nathan", "Hannah")
-
- val languages = Array("scala", "java", "C++", "haskell", "clojure", "python", "ruby", "pascal", "perl")
- val sports = Array("climbing", "cycling", "hiking", "football", "baseball", "underwater hockey")
-
- val numIDs = 1000
-
- //////// operations
-
- def pick[A](a: Array[A])(implicit rand: Random) = a(rand.nextInt(a.length))
-
- def newName(id: Int)(implicit rand: Random) {
- atomic { implicit txn =>
- val before = users.get(id).getOrElse(User(id, "John Doe", Set.empty))
- val after = before copy (name = pick(topBabyNames))
- users.put(id, after)
- }
- }
-
- def newLikes(id: Int)(implicit rand: Random) {
- atomic { implicit txn =>
- val before = users.get(id).getOrElse(User(id, "John Doe", Set.empty))
- val after = before copy (likes = Set(pick(languages), pick(sports)))
- users.put(id, after)
- }
- }
-
- def randomOp(implicit rand: Random) {
- val pct = rand.nextInt(100)
- if (pct < 10) {
- // query by ID
- users.get(rand.nextInt(numIDs))
- } else if (pct < 50) {
- // query by name
- byName(pick(topBabyNames))
- } else if (pct < 70) {
- // query by sport
- byLike(pick(sports))
- } else if (pct < 90) {
- // query by language
- byLike(pick(languages))
- } else if (pct < 95) {
- newName(rand.nextInt(numIDs))
- } else {
- newLikes(rand.nextInt(numIDs))
- }
- }
-
- def populate() {
- implicit val rand = new Random
- for (id <- 0 until numIDs) {
- newName(id)
- newLikes(id)
- }
- }
-
- def run(numThreads: Int, opsPerThread: Int): Long = {
- val threads = Array.tabulate(numThreads) { _ =>
- new Thread() {
- override def run {
- implicit val rand = new Random
- for (i <- 0 until opsPerThread) randomOp
- }
- }
- }
- val begin = System.currentTimeMillis
- for (t <- threads) t.start
- for (t <- threads) t.join
- System.currentTimeMillis - begin
- }
-
- def main(args: Array[String]) {
- populate()
-
- for (pass <- 0 until 3; tc <- List(1, 2, 4, 8)) {
- val elapsed = run(tc, 1000000 / tc)
- printf("%d thread: %4.2f usec/op total throughput (90%% read)\n", tc, elapsed * 0.001)
- }
- }
-}
diff --git a/benchmarks/scala-stm/scala-stm-library/src/test/scala/scala/concurrent/stm/examples/RealityShowPhilosophers.scala b/benchmarks/scala-stm/scala-stm-library/src/test/scala/scala/concurrent/stm/examples/RealityShowPhilosophers.scala
deleted file mode 100644
index ddafb821..00000000
--- a/benchmarks/scala-stm/scala-stm-library/src/test/scala/scala/concurrent/stm/examples/RealityShowPhilosophers.scala
+++ /dev/null
@@ -1,92 +0,0 @@
-/* scala-stm - (c) 2009-2011, Stanford University, PPL */
-
-package scala.concurrent.stm
-package examples
-
-import annotation.tailrec
-
-/** This extends a solution to the dining philosopher's problem to include an
- * outside perspective that occasionally examines everything that is
- * happening.
- */
-object RealityShowPhilosophers {
-
- class Fork {
- val owner = Ref(None : Option[String])
- }
-
- class PhilosopherThread(val name: String, val meals: Int, left: Fork, right: Fork) extends Thread {
- val mealsEaten = Ref(0)
-
- override def run() {
- for (m <- 0 until meals) {
- // thinking
- atomic { implicit txn =>
- if (!(left.owner().isEmpty && right.owner().isEmpty))
- retry
- left.owner() = Some(name)
- right.owner() = Some(name)
- }
- // eating
- atomic { implicit txn =>
- mealsEaten += 1
- left.owner() = None
- right.owner() = None
- }
- }
- }
-
- def done = mealsEaten.single() == meals
-
- override def toString = {
- "%s is %5.2f%% done".format(name, mealsEaten.single() * 100.0 / meals)
- }
- }
-
- class CameraThread(intervalMilli: Int, forks: Seq[Fork], philosophers: Seq[PhilosopherThread]) extends Thread {
-
- @tailrec final override def run() {
- Thread.sleep(intervalMilli)
- val (str, done) = image
- println(str)
- if (!done)
- run()
- }
-
- /** We want to print exactly one image of the final state, so we check
- * completion at the same time as building the image.
- */
- def image: (String, Boolean) = atomic { implicit txn =>
- val buf = new StringBuilder
- for (i <- 0 until forks.length)
- buf ++= "fork %d is owned by %s\n".format(i, forks(i).owner.single())
- var done = true
- for (p <- philosophers) {
- buf ++= p.toString += '\n'
- done &&= p.done
- }
- (buf.toString, done)
- }
- }
-
- def time(names: Seq[String], meals: Int): Long = {
- val forks = Array.tabulate(names.size) { _ => new Fork }
- val pthreads = Array.tabulate(names.size) { i => new PhilosopherThread(names(i), meals, forks(i), forks((i + 1) % forks.length)) }
- val camera = new CameraThread(1000 / 60, forks, pthreads)
- val start = System.currentTimeMillis
- camera.start()
- for (t <- pthreads) t.start()
- for (t <- pthreads) t.join()
- val elapsed = System.currentTimeMillis - start
- camera.join()
- elapsed
- }
-
- def main(args: Array[String]) {
- val meals = 100000
- for (p <- 0 until 3) {
- val elapsed = time(List("Aristotle", "Hippocrates", "Plato", "Pythagoras", "Socrates"), meals)
- printf("%3.1f usec/meal\n", (elapsed * 1000.0) / meals)
- }
- }
-}
diff --git a/benchmarks/scala-stm/scala-stm-library/src/test/scala/scala/concurrent/stm/examples/SyntaxCheatSheet.scala b/benchmarks/scala-stm/scala-stm-library/src/test/scala/scala/concurrent/stm/examples/SyntaxCheatSheet.scala
deleted file mode 100644
index a82a618d..00000000
--- a/benchmarks/scala-stm/scala-stm-library/src/test/scala/scala/concurrent/stm/examples/SyntaxCheatSheet.scala
+++ /dev/null
@@ -1,39 +0,0 @@
-/* scala-stm - (c) 2009-2010, Stanford University, PPL */
-
-package scala.concurrent.stm.examples
-
-object SyntaxCheatSheet {
- import scala.concurrent.stm._
-
- val x = Ref(0) // allocate a Ref[Int]
- val y = Ref.make[String]() // type-specific default
- val z = x.single // Ref.View[Int]
-
- atomic { implicit txn =>
- val i = x() // read
- y() = "x was " + i // write
- val eq = atomic { implicit txn => // nested atomic
- x() == z() // both Ref and Ref.View can be used inside atomic
- }
- assert(eq)
- y.set(y.get + ", long-form access")
- }
-
- // only Ref.View can be used outside atomic
- println("y was '" + y.single() + "'")
- println("z was " + z())
-
- atomic { implicit txn =>
- y() = y() + ", first alternative"
- if (x getWith { _ > 0 }) // read via a function
- retry // try alternatives or block
- } orAtomic { implicit txn =>
- y() = y() + ", second alternative"
- }
-
- val prev = z.swap(10) // atomic swap
- val success = z.compareAndSet(10, 11) // atomic compare-and-set
- z.transform { _ max 20 } // atomic transformation
- val pre = y.single.getAndTransform { _.toUpperCase }
- val post = y.single.transformAndGet { _.filterNot { _ == ' ' } }
-}
diff --git a/benchmarks/scala-stm/scala-stm-library/src/test/scala/scala/concurrent/stm/impl/RefFactorySuite.scala b/benchmarks/scala-stm/scala-stm-library/src/test/scala/scala/concurrent/stm/impl/RefFactorySuite.scala
deleted file mode 100644
index 78ac392f..00000000
--- a/benchmarks/scala-stm/scala-stm-library/src/test/scala/scala/concurrent/stm/impl/RefFactorySuite.scala
+++ /dev/null
@@ -1,145 +0,0 @@
-/* scala-stm - (c) 2009-2010, Stanford University, PPL */
-
-package scala.concurrent.stm
-package impl
-
-import org.scalatest.FunSuite
-import java.lang.String
-
-class RefFactorySuite extends FunSuite {
-
- private case class Fact(expected: String) extends skel.StubSTMImpl with RefFactory {
-
- private def called(w: String) = {
- assert(w === expected)
- null
- }
-
- override def newRef(v0: Boolean): Ref[Boolean] = called("Boolean")
- override def newRef(v0: Byte): Ref[Byte] = called("Byte")
- override def newRef(v0: Short): Ref[Short] = called("Short")
- override def newRef(v0: Char): Ref[Char] = called("Char")
- override def newRef(v0: Int): Ref[Int] = called("Int")
- override def newRef(v0: Float): Ref[Float] = called("Float")
- override def newRef(v0: Long): Ref[Long] = called("Long")
- override def newRef(v0: Double): Ref[Double] = called("Double")
- override def newRef(v0: Unit): Ref[Unit] = called("Unit")
- override def newRef[T](v0: T)(implicit m: ClassManifest[T]): Ref[T] = called("Any")
- }
-
- object TestRef extends RefCompanion {
- var factory: RefFactory = null
- }
-
- test("signature specialization") {
- TestRef.factory = Fact("Boolean")
- TestRef(false)
-
- TestRef.factory = Fact("Byte")
- TestRef(0 : Byte)
-
- TestRef.factory = Fact("Short")
- TestRef(0 : Short)
-
- TestRef.factory = Fact("Char")
- TestRef(0 : Char)
-
- TestRef.factory = Fact("Int")
- TestRef(0 : Int)
-
- TestRef.factory = Fact("Float")
- TestRef(0 : Float)
-
- TestRef.factory = Fact("Long")
- TestRef(0 : Long)
-
- TestRef.factory = Fact("Double")
- TestRef(0 : Double)
-
- TestRef.factory = Fact("Unit")
- TestRef(())
-
- TestRef.factory = Fact("Any")
- TestRef("abc")
- TestRef(null)
- TestRef(0.asInstanceOf[AnyRef])
- val x: Any = 0
- TestRef(x)
- }
-
- test("missing manifest TestRef.apply") {
- TestRef.factory = Fact("Any")
-
- def go[T](x: T) = TestRef(x)
-
- go(123)
- go(1.23)
- go(null)
- go("abc")
- }
-
- test("dynamic specialization") {
- def go[T : ClassManifest](v0: T, which: String) {
- TestRef.factory = Fact(which)
- TestRef(v0)
- }
-
- go(false, "Boolean")
- go(0 : Byte, "Byte")
- go(0 : Short, "Short")
- go(0 : Char, "Char")
- go(0 : Int, "Int")
- go(0 : Float, "Float")
- go(0 : Long, "Long")
- go(0 : Double, "Double")
- go((), "Unit")
- go("abc", "Any")
- go(null, "Any")
- go(0.asInstanceOf[AnyRef], "Any")
- val x: Any = 0
- go(x, "Any")
- }
-
- test("default value specialization") {
- def go[T : ClassManifest](default: T, which: String) {
- TestRef.factory = Fact(which)
- TestRef.make[T]()
- //assert(x.single() == default)
- }
-
- go(false, "Boolean")
- go(0 : Byte, "Byte")
- go(0 : Short, "Short")
- go(0 : Char, "Char")
- go(0 : Int, "Int")
- go(0 : Float, "Float")
- go(0 : Long, "Long")
- go(0 : Double, "Double")
- go((), "Unit")
- go[String](null, "Any")
- go[AnyRef](null, "Any")
- go[Null](null, "Any")
- go[Any](null, "Any")
- }
-
- test("missing manifest TestRef.make") {
- TestRef.factory = Fact("Any")
-
- def go[T]() = TestRef.make[T]()
-
- go[Boolean]()
- go[Byte]()
- go[Short]()
- go[Char]()
- go[Int]()
- go[Float]()
- go[Long]()
- go[Double]()
- go[Unit]()
- go[String]()
- go[AnyRef]()
- go[Null]()
- go[Any]()
- }
-
-}
diff --git a/benchmarks/scala-stm/scala-stm-library/src/test/scala/scala/concurrent/stm/skel/AtomicArraySuite.scala b/benchmarks/scala-stm/scala-stm-library/src/test/scala/scala/concurrent/stm/skel/AtomicArraySuite.scala
deleted file mode 100644
index 130e4f09..00000000
--- a/benchmarks/scala-stm/scala-stm-library/src/test/scala/scala/concurrent/stm/skel/AtomicArraySuite.scala
+++ /dev/null
@@ -1,133 +0,0 @@
-/* scala-stm - (c) 2009-2014, Stanford University, PPL */
-
-package scala.concurrent.stm
-package skel
-
-import org.scalatest.FunSuite
-
-class AtomicArraySuite extends FunSuite {
-
- test("Unit") {
- runIsolatedTest(List((), (), ()))
- }
-
- test("Boolean") {
- runIsolatedTest(List(false, true, false, true))
- }
-
- test("Byte") {
- runIsolatedTest(Array(0 : Byte, 1 : Byte, 2 : Byte))
- }
-
- test("Short") {
- runIsolatedTest(List(0 : Short, 1 : Short, 2 : Short))
- }
-
- test("Char") {
- runIsolatedTest("abcdefg".toSeq)
- }
-
- test("Int") {
- runIsolatedTest(100 until 200)
- }
-
- test("Float") {
- runIsolatedTest((20 to 30) map { _ * 0.1f })
- }
-
- test("Long") {
- runIsolatedTest((100 until 200) map { _ - 100L * Int.MaxValue })
- }
-
- test("Double") {
- runIsolatedTest((10 until 20) map { math.exp(_) })
- }
-
- test("AnyRef") {
- runIsolatedTest((10 until 20) map { i => ("x" + i) : AnyRef })
- }
-
- test("Any") {
- runIsolatedTest[Any]((10 until 20) map { i => i : Any })
- }
-
- def runIsolatedTest[A](values: Seq[A])(implicit am: ClassManifest[A]) {
- val singleton = AtomicArray[A](1)
- if (am != implicitly[ClassManifest[Unit]])
- assert(singleton(0) === am.newArray(1)(0))
-
- val aa = AtomicArray(values)
- for (i <- 0 until aa.length)
- assert(values(i) === aa(i))
- for (i <- 0 until aa.length)
- aa(i) = values(aa.length - 1 - i)
- for (i <- 0 until aa.length)
- assert(aa(i) === values(aa.length - 1 - i))
- for (i <- 0 until aa.length) {
- if (aa(i) == values(0)) {
- assert(aa.compareAndSet(i, values(0), values(i)))
- assert(aa(i) === values(i))
- } else {
- assert(!aa.compareAndSet(i, values(0), values(i)))
- assert(aa(i) === values(aa.length - 1 - i))
- }
- }
- for (i <- 0 until aa.length)
- assert(aa(i) === aa.getAndTransform(i)( v => v ))
- for (i <- 0 until aa.length) {
- val prev = aa(i)
- assert(aa.swap(i, values(i)) === prev)
- }
-
- intercept[IndexOutOfBoundsException] {
- aa(-1)
- }
- intercept[IndexOutOfBoundsException] {
- aa(-1) = aa(0)
- }
- intercept[IndexOutOfBoundsException] {
- aa(aa.length)
- }
- intercept[IndexOutOfBoundsException] {
- aa(aa.length) = aa(0)
- }
- intercept[IndexOutOfBoundsException] {
- aa.compareAndSet(-1, aa(0), aa(0))
- }
- intercept[IndexOutOfBoundsException] {
- aa.compareAndSet(aa.length, aa(0), aa(0))
- }
- intercept[IndexOutOfBoundsException] {
- aa(Int.MinValue)
- }
- intercept[IndexOutOfBoundsException] {
- aa(Int.MaxValue)
- }
-
- val copy = aa.clone
- for (i <- 0 until aa.length)
- assert(copy(i) === aa(i))
-
- val str0 = aa map { _.toString }
- val str: AtomicArray[String] = str0
- for (i <- 0 until aa.length)
- assert(aa(i).toString === str(i))
-
- val seq0 = aa.toList
- for (i <- 0 until aa.length)
- assert(aa(i) == seq0(i))
-
- val seq1 = aa.iterator.toList
- for (i <- 0 until aa.length)
- assert(aa(i) == seq1(i))
-
- val bb = aa ++ seq0
- assert(bb.length === aa.length * 2)
- for (i <- 0 until aa.length) {
- assert(aa(i) === bb(i))
- assert(aa(i) === bb(i + aa.length))
- }
-
- assert(aa.toString.startsWith("AtomicArray"))
- }
-}
diff --git a/benchmarks/scala-stm/scala-stm-library/src/test/scala/scala/concurrent/stm/skel/SimpleRandomSuite.scala b/benchmarks/scala-stm/scala-stm-library/src/test/scala/scala/concurrent/stm/skel/SimpleRandomSuite.scala
deleted file mode 100644
index 91ceb5af..00000000
--- a/benchmarks/scala-stm/scala-stm-library/src/test/scala/scala/concurrent/stm/skel/SimpleRandomSuite.scala
+++ /dev/null
@@ -1,65 +0,0 @@
-/* scala-stm - (c) 2009-2011, Stanford University, PPL */
-
-package scala.concurrent.stm
-package skel
-
-import org.scalatest.FunSuite
-
-class SimpleRandomSuite extends FunSuite {
-
- test("nextInt") {
- val f = new SimpleRandom
- val rand = new scala.util.Random
- var s = 0
- for (i <- 0 until 100000) {
- s |= SimpleRandom.nextInt
- s |= f.nextInt
- }
- assert(s != 0)
- }
-
- test("nextInt(n) in range") {
- val f = new SimpleRandom
- val rand = new scala.util.Random
- for (i <- 0 until 100000) {
- val n = rand.nextInt(Int.MaxValue - 1) + 1
- val gr = SimpleRandom.nextInt(n)
- assert(gr >= 0 && gr < n)
- val lr = f.nextInt(n)
- assert(lr >= 0 && lr < n)
- }
- }
-
- test("clone") {
- val f1 = new SimpleRandom
- for (i <- 0 until 1000)
- f1.nextInt
- val f2 = f1.clone
- for (i <- 0 until 1000)
- assert(f1.nextInt(9999) === f2.nextInt(9999))
- }
-
- test("seeded") {
- val f1 = new SimpleRandom(100)
- val f2 = new SimpleRandom(100)
- for (i <- 0 until 1000)
- assert(f1.nextInt === f2.nextInt)
- }
-
- test("global SimpleRandom distribution") {
- val buckets = new Array[Int](100)
- for (i <- 0 until 100000)
- buckets(SimpleRandom.nextInt(buckets.length)) += 1
- for (b <- buckets)
- assert(b > 0)
- }
-
- test("local SimpleRandom distribution") {
- val f = new SimpleRandom
- val buckets = new Array[Int](100)
- for (i <- 0 until 100000)
- buckets(f.nextInt(buckets.length)) += 1
- for (b <- buckets)
- assert(b > 0)
- }
-}
\ No newline at end of file
diff --git a/benchmarks/scala-stm/scala-stm-library/src/test/scala/stmbench7/scalastm/AssemblyImpl.scala b/benchmarks/scala-stm/scala-stm-library/src/test/scala/stmbench7/scalastm/AssemblyImpl.scala
deleted file mode 100644
index d790edd4..00000000
--- a/benchmarks/scala-stm/scala-stm-library/src/test/scala/stmbench7/scalastm/AssemblyImpl.scala
+++ /dev/null
@@ -1,21 +0,0 @@
-/* scala-stm - (c) 2009-2011, Stanford University, PPL */
-
-package stmbench7.scalastm
-
-import scala.concurrent.stm._
-import stmbench7.core._
-
-abstract class AssemblyImpl(id: Int, typ: String, buildDate: Int, module0: Module, superAssembly0: ComplexAssembly
- ) extends DesignObjImpl(id, typ, buildDate) with Assembly {
-
- private val module = Ref(module0).single
- private val superAssembly = Ref(superAssembly0).single
-
- def getSuperAssembly = superAssembly()
- def getModule = module()
-
- def clearPointers() {
- superAssembly() = null
- module() = null
- }
-}
diff --git a/benchmarks/scala-stm/scala-stm-library/src/test/scala/stmbench7/scalastm/AtomicPartImpl.scala b/benchmarks/scala-stm/scala-stm-library/src/test/scala/stmbench7/scalastm/AtomicPartImpl.scala
deleted file mode 100644
index 24fa8cc5..00000000
--- a/benchmarks/scala-stm/scala-stm-library/src/test/scala/stmbench7/scalastm/AtomicPartImpl.scala
+++ /dev/null
@@ -1,46 +0,0 @@
-/* scala-stm - (c) 2009-2011, Stanford University, PPL */
-
-package stmbench7.scalastm
-
-import scala.concurrent.stm._
-import stmbench7.core._
-import stmbench7.impl.core.ConnectionImpl
-
-class AtomicPartImpl(id0: Int, typ0: String, bd0: Int, x0: Int, y0: Int) extends DesignObjImpl(id0, typ0, bd0) with AtomicPart {
- val x = Ref(x0)
- val y = Ref(y0)
- val partOf = Ref(null : CompositePart).single
- val from = TSet.empty[Connection].single // this is the equivant of SmallSetImpl
- val to = TSet.empty[Connection].single
-
- def connectTo(dest: AtomicPart, typ: String, length: Int) {
- val c = new ConnectionImpl(this, dest, typ, length)
- to += c
- dest.addConnectionFromOtherPart(c.getReversed)
- }
- def addConnectionFromOtherPart(c: Connection) { from += c }
- def setCompositePart(po: CompositePart) { partOf() = po }
- def getNumToConnections = to.size
- def getToConnections = new ImmutableSetImpl[Connection](to)
- def getFromConnections = new ImmutableSetImpl[Connection](from)
- def getPartOf = partOf()
- def swapXY() {
- atomic { implicit t =>
- y() = x.swap(y())
- }
- }
- def getX = x.single()
- def getY = y.single()
- def clearPointers() {
- atomic { implicit t =>
- x() = 0
- y() = 0
- to.clear()
- from.clear()
- partOf() = null
- }
- }
-
- // Comparable[AtomicPart]
- def compareTo(rhs: AtomicPart) = getId - rhs.getId // subtraction is faithful to reference impl
-}
diff --git a/benchmarks/scala-stm/scala-stm-library/src/test/scala/stmbench7/scalastm/BaseAssemblyImpl.scala b/benchmarks/scala-stm/scala-stm-library/src/test/scala/stmbench7/scalastm/BaseAssemblyImpl.scala
deleted file mode 100644
index 09330be6..00000000
--- a/benchmarks/scala-stm/scala-stm-library/src/test/scala/stmbench7/scalastm/BaseAssemblyImpl.scala
+++ /dev/null
@@ -1,32 +0,0 @@
-/* scala-stm - (c) 2009-2011, Stanford University, PPL */
-
-package stmbench7.scalastm
-
-import scala.concurrent.stm._
-import stmbench7.core._
-
-class BaseAssemblyImpl(id: Int, typ: String, buildDate: Int, module: Module, superAssembly: ComplexAssembly
- ) extends AssemblyImpl(id, typ, buildDate, module, superAssembly) with BaseAssembly {
-
- val components = Ref(List.empty[CompositePart]).single // the original BagImpl was just an ArrayList
-
- def addComponent(component: CompositePart) {
- components.transform(component :: _)
- component.addAssembly(this)
- }
-
- def removeComponent(component: CompositePart) = {
- val f = components transformIfDefined {
- case x if x contains component => x filterNot { _ == component }
- }
- if (f) component.removeAssembly(this)
- f
- }
-
- def getComponents = new ImmutableSeqImpl[CompositePart](components())
-
- override def clearPointers() {
- super.clearPointers()
- components() = null
- }
-}
diff --git a/benchmarks/scala-stm/scala-stm-library/src/test/scala/stmbench7/scalastm/ComplexAssemblyImpl.scala b/benchmarks/scala-stm/scala-stm-library/src/test/scala/stmbench7/scalastm/ComplexAssemblyImpl.scala
deleted file mode 100644
index ce6834eb..00000000
--- a/benchmarks/scala-stm/scala-stm-library/src/test/scala/stmbench7/scalastm/ComplexAssemblyImpl.scala
+++ /dev/null
@@ -1,32 +0,0 @@
-/* scala-stm - (c) 2009-2011, Stanford University, PPL */
-
-package stmbench7.scalastm
-
-import scala.concurrent.stm._
-import stmbench7.core._
-import stmbench7.Parameters
-
-class ComplexAssemblyImpl(id: Int, typ: String, buildDate: Int, module: Module, superAssembly: ComplexAssembly
- ) extends AssemblyImpl(id, typ, buildDate, module, superAssembly) with ComplexAssembly {
-
- val subAssemblies = TSet.empty[Assembly].single
- val level = if (superAssembly == null) Parameters.NumAssmLevels else superAssembly.getLevel - 1
-
- def addSubAssembly(assembly: Assembly) = {
- if(assembly.isInstanceOf[BaseAssembly] && level != 2)
- throw new RuntimeError("ComplexAssembly.addAssembly: BaseAssembly at wrong level!");
-
- subAssemblies.add(assembly)
- }
-
- def removeSubAssembly(assembly: Assembly) = subAssemblies.remove(assembly)
-
- def getSubAssemblies = new ImmutableSetImpl[Assembly](subAssemblies)
-
- def getLevel = level.asInstanceOf[Short]
-
- override def clearPointers() {
- super.clearPointers()
- subAssemblies.clear()
- }
-}
diff --git a/benchmarks/scala-stm/scala-stm-library/src/test/scala/stmbench7/scalastm/CompositePartImpl.scala b/benchmarks/scala-stm/scala-stm-library/src/test/scala/stmbench7/scalastm/CompositePartImpl.scala
deleted file mode 100644
index 9ee21881..00000000
--- a/benchmarks/scala-stm/scala-stm-library/src/test/scala/stmbench7/scalastm/CompositePartImpl.scala
+++ /dev/null
@@ -1,47 +0,0 @@
-/* scala-stm - (c) 2009-2011, Stanford University, PPL */
-
-package stmbench7.scalastm
-
-import scala.concurrent.stm._
-import stmbench7.core._
-import stmbench7.backend.BackendFactory
-
-class CompositePartImpl(id: Int, typ: String, buildDate: Int, documentation0: Document
- ) extends DesignObjImpl(id, typ, buildDate) with CompositePart {
- val documentation = Ref(documentation0).single
- val usedIn = Ref(List.empty[BaseAssembly]).single
- val parts = Ref(BackendFactory.instance.createLargeSet[AtomicPart]).single
- val rootPart = Ref(null : AtomicPart).single
- documentation0.setPart(this)
-
- def addAssembly(assembly: BaseAssembly) { usedIn.transform(assembly :: _) }
-
- def addPart(part: AtomicPart) = {
- val f = parts().add(part)
- if (f) {
- part.setCompositePart(this)
- if(rootPart() == null) rootPart() = part
- }
- f
- }
-
- def getRootPart = rootPart()
- def setRootPart(part: AtomicPart) { rootPart() = part }
-
- def getDocumentation = documentation()
-
- def getParts = parts()
-
- def removeAssembly(assembly: BaseAssembly ) {
- usedIn.transform { _.filterNot(_ == assembly) }
- }
-
- def getUsedIn = new ImmutableSeqImpl[BaseAssembly](usedIn())
-
- def clearPointers() {
- documentation() = null
- parts() = null
- usedIn() = null
- rootPart() = null
- }
-}
diff --git a/benchmarks/scala-stm/scala-stm-library/src/test/scala/stmbench7/scalastm/DesignObjImpl.scala b/benchmarks/scala-stm/scala-stm-library/src/test/scala/stmbench7/scalastm/DesignObjImpl.scala
deleted file mode 100644
index a8aff59c..00000000
--- a/benchmarks/scala-stm/scala-stm-library/src/test/scala/stmbench7/scalastm/DesignObjImpl.scala
+++ /dev/null
@@ -1,16 +0,0 @@
-/* scala-stm - (c) 2009-2011, Stanford University, PPL */
-
-package stmbench7.scalastm
-
-import scala.concurrent.stm._
-import stmbench7.core._
-
-class DesignObjImpl(id: Int, typ: String, buildDate0: Int) extends DesignObj {
- val bd = Ref(buildDate0).single
-
- def getId = id
- def getType = typ
- def getBuildDate = bd()
- def updateBuildDate() { if (bd() % 2 == 0) bd -= 1 else bd += 1 }
- def nullOperation() {}
-}
diff --git a/benchmarks/scala-stm/scala-stm-library/src/test/scala/stmbench7/scalastm/DocumentImpl.scala b/benchmarks/scala-stm/scala-stm-library/src/test/scala/stmbench7/scalastm/DocumentImpl.scala
deleted file mode 100644
index 9325f3ee..00000000
--- a/benchmarks/scala-stm/scala-stm-library/src/test/scala/stmbench7/scalastm/DocumentImpl.scala
+++ /dev/null
@@ -1,34 +0,0 @@
-/* scala-stm - (c) 2009-2011, Stanford University, PPL */
-
-package stmbench7.scalastm
-
-import scala.annotation.tailrec
-import scala.concurrent.stm._
-import stmbench7.core._
-
-class DocumentImpl(id: Int, title: String, text0: String) extends Document {
- val text = Ref(text0).single
- val part = Ref(null : CompositePart).single
-
- def getDocumentId = id
- def getTitle = title
-
- def getCompositePart = part()
- def setPart(v: CompositePart) { part() = v }
-
- def nullOperation() {}
-
- def getText = text()
- def searchText(symbol: Char): Int = searchText(text(), symbol, 0, 0)
- @tailrec private def searchText(s: String, c: Char, pos: Int, n: Int): Int = {
- val i = s.indexOf(c, pos)
- if (i < 0) n else searchText(s, c, i + 1, n + 1)
- }
- def replaceText(from: String, to: String) = {
- val f = text transformIfDefined {
- case s if s.startsWith(from) => s.replaceFirst(from, to)
- }
- if (f) 1 else 0
- }
- def textBeginsWith(prefix: String) = text().startsWith(prefix)
-}
diff --git a/benchmarks/scala-stm/scala-stm-library/src/test/scala/stmbench7/scalastm/ImmutableSeqImpl.scala b/benchmarks/scala-stm/scala-stm-library/src/test/scala/stmbench7/scalastm/ImmutableSeqImpl.scala
deleted file mode 100644
index e9f4e1a4..00000000
--- a/benchmarks/scala-stm/scala-stm-library/src/test/scala/stmbench7/scalastm/ImmutableSeqImpl.scala
+++ /dev/null
@@ -1,13 +0,0 @@
-/* scala-stm - (c) 2009-2012, Stanford University, PPL */
-
-package stmbench7.scalastm
-
-import scala.collection.JavaConversions
-import stmbench7.backend.ImmutableCollection
-
-class ImmutableSeqImpl[A](contents: Seq[A]) extends ImmutableCollection[A] {
- override def clone = this
- def contains(element: A) = contents.contains(element)
- def size = contents.size
- def iterator = JavaConversions.asJavaIterator(contents.iterator)
-}
diff --git a/benchmarks/scala-stm/scala-stm-library/src/test/scala/stmbench7/scalastm/ImmutableSetImpl.scala b/benchmarks/scala-stm/scala-stm-library/src/test/scala/stmbench7/scalastm/ImmutableSetImpl.scala
deleted file mode 100644
index 8cd68cfd..00000000
--- a/benchmarks/scala-stm/scala-stm-library/src/test/scala/stmbench7/scalastm/ImmutableSetImpl.scala
+++ /dev/null
@@ -1,15 +0,0 @@
-/* scala-stm - (c) 2009-2012, Stanford University, PPL */
-
-package stmbench7.scalastm
-
-import scala.collection.JavaConversions
-import scala.concurrent.stm._
-import stmbench7.backend.ImmutableCollection
-
-/** Read-only wrapper */
-class ImmutableSetImpl[A](contents: TSet.View[A], shared: Boolean = true) extends ImmutableCollection[A] {
- override def clone: ImmutableSetImpl[A] = if (!shared) this else new ImmutableSetImpl(contents.clone(), false)
- def contains(element: A) = contents.contains(element)
- def size = contents.size
- def iterator = JavaConversions.asJavaIterator(contents.iterator)
-}
diff --git a/benchmarks/scala-stm/scala-stm-library/src/test/scala/stmbench7/scalastm/IndexImpl.scala b/benchmarks/scala-stm/scala-stm-library/src/test/scala/stmbench7/scalastm/IndexImpl.scala
deleted file mode 100644
index 3efd4b08..00000000
--- a/benchmarks/scala-stm/scala-stm-library/src/test/scala/stmbench7/scalastm/IndexImpl.scala
+++ /dev/null
@@ -1,46 +0,0 @@
-/* scala-stm - (c) 2009-2012, Stanford University, PPL */
-
-package stmbench7.scalastm
-
-import scala.annotation._
-import scala.collection.immutable.TreeMap
-import scala.collection.mutable.ArrayBuffer
-import scala.collection.JavaConversions
-import scala.concurrent.stm._
-import stmbench7.backend.Index
-
-object IndexImpl {
- class BoxedImmutable[A <: Comparable[A], B] extends Index[A,B] {
- // needed for 2.8, harmless in 2.9
- implicit val order = new Ordering[A] {
- def compare(lhs: A, rhs: A) = lhs compareTo rhs
- }
-
- val underlying = Ref(TreeMap.empty[A,B]).single
-
- def get(key: A) = underlying().getOrElse(key, null.asInstanceOf[B])
-
- def put(key: A, value: B) { underlying.transform(_ + (key -> value)) }
-
- def putIfAbsent(key: A, value: B): B = {
- underlying.getAndTransform({ m => if (m.contains(key)) m else m + (key -> value) }).getOrElse(key, null.asInstanceOf[B])
- }
-
- def remove(key: A) = underlying transformIfDefined {
- case m if m.contains(key) => m - key
- }
-
- def iterator = makeValuesIterator(underlying())
-
- def getKeys = JavaConversions.setAsJavaSet(underlying().keySet)
-
- def getRange(minKey: A, maxKey: A) = new java.lang.Iterable[B] {
- val range = underlying().range(minKey, maxKey)
- def iterator = makeValuesIterator(range)
- }
-
- private def makeValuesIterator(m: TreeMap[A, B]) = {
- JavaConversions.asJavaIterator(m.values.iterator)
- }
- }
-}
diff --git a/benchmarks/scala-stm/scala-stm-library/src/test/scala/stmbench7/scalastm/LargeSetImpl.scala b/benchmarks/scala-stm/scala-stm-library/src/test/scala/stmbench7/scalastm/LargeSetImpl.scala
deleted file mode 100644
index 56bb62f7..00000000
--- a/benchmarks/scala-stm/scala-stm-library/src/test/scala/stmbench7/scalastm/LargeSetImpl.scala
+++ /dev/null
@@ -1,19 +0,0 @@
-/* scala-stm - (c) 2009-2012, Stanford University, PPL */
-
-package stmbench7.scalastm
-
-import scala.collection.JavaConversions
-import scala.concurrent.stm._
-import stmbench7.backend.LargeSet
-
-// LargeSetImpl
-
-class LargeSetImpl[A <: Comparable[A]] extends LargeSet[A] {
- val underlying = TMap.empty[A,Unit].single
-
- def add(e: A) = underlying.put(e, ()).isEmpty
- def remove(e: A) = !underlying.remove(e).isEmpty
- def contains(e: A) = underlying.contains(e)
- def size = underlying.size
- def iterator = JavaConversions.asJavaIterator(underlying.keysIterator)
-}
diff --git a/benchmarks/scala-stm/scala-stm-library/src/test/scala/stmbench7/scalastm/ManualImpl.scala b/benchmarks/scala-stm/scala-stm-library/src/test/scala/stmbench7/scalastm/ManualImpl.scala
deleted file mode 100644
index 3edbbdab..00000000
--- a/benchmarks/scala-stm/scala-stm-library/src/test/scala/stmbench7/scalastm/ManualImpl.scala
+++ /dev/null
@@ -1,40 +0,0 @@
-/* scala-stm - (c) 2009-2011, Stanford University, PPL */
-
-package stmbench7.scalastm
-
-import scala.concurrent.stm._
-import scala.collection.immutable.WrappedString
-import scala.annotation.tailrec
-import stmbench7.core._
-
-class ManualImpl(id: Int, title0: String, text0: String) extends Manual {
- val title = Ref(title0).single
- val text = Ref(text0).single
- val module = Ref(null : Module).single
-
- def getId = id
- def getTitle = title()
- def getText = text()
- def getModule = module()
-
- def setModule(v: Module) { module() = v }
-
- def countOccurences(ch: Char): Int = countOccurrences(ch)
- def countOccurrences(ch: Char): Int = countOccurrences(text(), ch, 0, 0)
- @tailrec private def countOccurrences(s: String, c: Char, pos: Int, n: Int): Int = {
- val i = s.indexOf(c, pos)
- if (i < 0) n else countOccurrences(s, c, i + 1, n + 1)
- }
-
- def checkFirstLastCharTheSame = {
- val t = text()
- if (t.charAt(0) == t.charAt(t.length - 1)) 1 else 0
- }
-
- def startsWith(ch: Char) = text().charAt(0) == ch
-
- def replaceChar(from: Char, to: Char) = {
- text.transform(_.replace(from, to))
- countOccurences(to)
- }
-}
diff --git a/benchmarks/scala-stm/scala-stm-library/src/test/scala/stmbench7/scalastm/ModuleImpl.scala b/benchmarks/scala-stm/scala-stm-library/src/test/scala/stmbench7/scalastm/ModuleImpl.scala
deleted file mode 100644
index 7ccac29c..00000000
--- a/benchmarks/scala-stm/scala-stm-library/src/test/scala/stmbench7/scalastm/ModuleImpl.scala
+++ /dev/null
@@ -1,18 +0,0 @@
-/* scala-stm - (c) 2009-2011, Stanford University, PPL */
-
-package stmbench7.scalastm
-
-import scala.concurrent.stm._
-import stmbench7.core._
-
-class ModuleImpl(id: Int, typ: String, buildDate: Int, man: Manual
- ) extends DesignObjImpl(id, typ, buildDate) with Module {
-
- val designRoot = Ref(null : ComplexAssembly).single
-
- man.setModule(this)
-
- def setDesignRoot(v: ComplexAssembly ) { designRoot() = v }
- def getDesignRoot = designRoot()
- def getManual = man
-}
diff --git a/benchmarks/scala-stm/scala-stm-library/src/test/scala/stmbench7/scalastm/ScalaSTMInitializer.scala b/benchmarks/scala-stm/scala-stm-library/src/test/scala/stmbench7/scalastm/ScalaSTMInitializer.scala
deleted file mode 100644
index aea0a5c5..00000000
--- a/benchmarks/scala-stm/scala-stm-library/src/test/scala/stmbench7/scalastm/ScalaSTMInitializer.scala
+++ /dev/null
@@ -1,76 +0,0 @@
-/* scala-stm - (c) 2009-2011, Stanford University, PPL */
-
-package stmbench7.scalastm
-
-import scala.concurrent.stm._
-import stmbench7.backend._
-import stmbench7.core._
-import stmbench7.impl.core.ConnectionImpl
-import stmbench7._
-
-class ScalaSTMInitializer extends SynchMethodInitializer {
- def createOperationExecutorFactory() = new OperationExecutorFactory {
-
- val timestamp = Ref(0)
-
- def createOperationExecutor(op: Operation) = new OperationExecutor {
- var lastTS = 0
-
- def execute(): Int = {
- atomic { implicit t =>
- val z = op.performOperation()
- if (Parameters.sequentialReplayEnabled) {
- timestamp += 1
- lastTS = timestamp()
- }
- z
- }
- }
-
- def getLastOperationTimestamp = lastTS
- }
- }
-
- def createBackendFactory() = new BackendFactory {
-
- // a couple hundred, not ordered, except for huge numbers of discarded
- // sets with exactly 1 element
- def createLargeSet[E <: Comparable[E]](): LargeSet[E] = new LargeSetImpl[E]
-
- // ordered
- def createIndex[K <: Comparable[K],V](): Index[K,V] = new IndexImpl.BoxedImmutable[K,V]
-
- def createIdPool(maxNumberOfIds: Int): IdPool = new IdPoolImpl.BoxedList(maxNumberOfIds)
- }
-
- def createDesignObjFactory() = new DesignObjFactory {
-
- def createAtomicPart(id: Int, typ: String, bd: Int, x: Int, y: Int) =
- new AtomicPartImpl(id, typ, bd, x, y)
-
- def createConnection(from: AtomicPart, to: AtomicPart, typ: String, length: Int) =
- new ConnectionImpl(from, to, typ, length)
-
- def createBaseAssembly(id: Int, typ: String, buildDate: Int, module: Module, superAssembly: ComplexAssembly) =
- new BaseAssemblyImpl(id, typ, buildDate, module, superAssembly)
-
- def createComplexAssembly(id: Int, typ: String, buildDate: Int, module: Module, superAssembly: ComplexAssembly) =
- new ComplexAssemblyImpl(id, typ, buildDate, module, superAssembly)
-
- def createCompositePart(id: Int, typ: String, buildDate: Int, documentation: Document) =
- new CompositePartImpl(id, typ, buildDate, documentation)
-
- def createDocument(id: Int, title: String, text: String) =
- new DocumentImpl(id, title, text)
-
- def createManual(id: Int, title: String, text: String) =
- new ManualImpl(id, title, text)
-
- def createModule(id: Int, typ: String, buildDate: Int, man: Manual) =
- new ModuleImpl(id, typ, buildDate, man)
- }
-
- def createThreadFactory() = new stmbench7.ThreadFactory {
- def createThread(body: Runnable) = new Thread(body)
- }
-}
\ No newline at end of file
diff --git a/benchmarks/scala-stm/src/main/scala/stmbench7/scalastm/AssemblyImpl.scala b/benchmarks/scala-stm/src/main/scala/stmbench7/scalastm/AssemblyImpl.scala
new file mode 100644
index 00000000..edae77b8
--- /dev/null
+++ b/benchmarks/scala-stm/src/main/scala/stmbench7/scalastm/AssemblyImpl.scala
@@ -0,0 +1,30 @@
+/* scala-stm - (c) 2009-2011, Stanford University, PPL */
+
+package stmbench7.scalastm
+
+import scala.concurrent.stm.Ref
+
+import stmbench7.core.Assembly
+import stmbench7.core.ComplexAssembly
+import stmbench7.core.Module
+
+abstract class AssemblyImpl(
+ id: Int,
+ typ: String,
+ buildDate: Int,
+ module0: Module,
+ superAssembly0: ComplexAssembly
+) extends DesignObjImpl(id, typ, buildDate)
+ with Assembly {
+
+ private val module = Ref(module0).single
+ private val superAssembly = Ref(superAssembly0).single
+
+ override def getSuperAssembly: ComplexAssembly = superAssembly()
+ override def getModule: Module = module()
+
+ override def clearPointers(): Unit = {
+ superAssembly() = null
+ module() = null
+ }
+}
diff --git a/benchmarks/scala-stm/src/main/scala/stmbench7/scalastm/AtomicPartImpl.scala b/benchmarks/scala-stm/src/main/scala/stmbench7/scalastm/AtomicPartImpl.scala
new file mode 100644
index 00000000..bd5f5480
--- /dev/null
+++ b/benchmarks/scala-stm/src/main/scala/stmbench7/scalastm/AtomicPartImpl.scala
@@ -0,0 +1,58 @@
+/* scala-stm - (c) 2009-2011, Stanford University, PPL */
+
+package stmbench7.scalastm
+
+import scala.concurrent.stm.atomic
+import scala.concurrent.stm.Ref
+import scala.concurrent.stm.TSet
+
+import stmbench7.core.AtomicPart
+import stmbench7.core.CompositePart
+import stmbench7.core.Connection
+import stmbench7.impl.core.ConnectionImpl
+
+class AtomicPartImpl(id0: Int, typ0: String, bd0: Int, x0: Int, y0: Int)
+ extends DesignObjImpl(id0, typ0, bd0)
+ with AtomicPart {
+
+ private val x = Ref(x0)
+ private val y = Ref(y0)
+ private val partOf = Ref(null: CompositePart).single
+ private val from = TSet.empty[Connection].single // this is the equivalent of SmallSetImpl
+ private val to = TSet.empty[Connection].single
+
+ override def connectTo(dest: AtomicPart, typ: String, length: Int): Unit = {
+ val c = new ConnectionImpl(this, dest, typ, length)
+ to += c
+ dest.addConnectionFromOtherPart(c.getReversed)
+ }
+
+ override def addConnectionFromOtherPart(c: Connection): Unit = { from += c }
+ override def setCompositePart(po: CompositePart): Unit = { partOf() = po }
+ override def getNumToConnections: Int = to.size
+ override def getToConnections = new ImmutableSetImpl[Connection](to)
+ override def getFromConnections = new ImmutableSetImpl[Connection](from)
+ override def getPartOf: CompositePart = partOf()
+
+ override def swapXY(): Unit = {
+ atomic { implicit t =>
+ y() = x.swap(y())
+ }
+ }
+ override def getX: Int = x.single()
+ override def getY: Int = y.single()
+
+ override def clearPointers(): Unit = {
+ atomic { implicit t =>
+ x() = 0
+ y() = 0
+ to.clear()
+ from.clear()
+ partOf() = null
+ }
+ }
+
+ // Comparable[AtomicPart]
+ override def compareTo(rhs: AtomicPart): Int =
+ getId - rhs.getId // subtraction is faithful to reference impl
+}
diff --git a/benchmarks/scala-stm/src/main/scala/stmbench7/scalastm/BaseAssemblyImpl.scala b/benchmarks/scala-stm/src/main/scala/stmbench7/scalastm/BaseAssemblyImpl.scala
new file mode 100644
index 00000000..850e542d
--- /dev/null
+++ b/benchmarks/scala-stm/src/main/scala/stmbench7/scalastm/BaseAssemblyImpl.scala
@@ -0,0 +1,43 @@
+/* scala-stm - (c) 2009-2011, Stanford University, PPL */
+
+package stmbench7.scalastm
+
+import scala.concurrent.stm.Ref
+
+import stmbench7.core.BaseAssembly
+import stmbench7.core.ComplexAssembly
+import stmbench7.core.CompositePart
+import stmbench7.core.Module
+
+class BaseAssemblyImpl(
+ id: Int,
+ typ: String,
+ buildDate: Int,
+ module: Module,
+ superAssembly: ComplexAssembly
+) extends AssemblyImpl(id, typ, buildDate, module, superAssembly)
+ with BaseAssembly {
+
+ private val components =
+ Ref(List.empty[CompositePart]).single // the original BagImpl was just an ArrayList
+
+ override def addComponent(component: CompositePart): Unit = {
+ components.transform(component :: _)
+ component.addAssembly(this)
+ }
+
+ override def removeComponent(component: CompositePart): Boolean = {
+ val f = components transformIfDefined {
+ case x if x contains component => x filterNot { _ == component }
+ }
+ if (f) component.removeAssembly(this)
+ f
+ }
+
+ override def getComponents = new ImmutableSeqImpl[CompositePart](components())
+
+ override def clearPointers(): Unit = {
+ super.clearPointers()
+ components() = null
+ }
+}
diff --git a/benchmarks/scala-stm/src/main/scala/stmbench7/scalastm/ComplexAssemblyImpl.scala b/benchmarks/scala-stm/src/main/scala/stmbench7/scalastm/ComplexAssemblyImpl.scala
new file mode 100644
index 00000000..99306215
--- /dev/null
+++ b/benchmarks/scala-stm/src/main/scala/stmbench7/scalastm/ComplexAssemblyImpl.scala
@@ -0,0 +1,45 @@
+/* scala-stm - (c) 2009-2011, Stanford University, PPL */
+
+package stmbench7.scalastm
+
+import scala.concurrent.stm.TSet
+
+import stmbench7.Parameters
+import stmbench7.core.Assembly
+import stmbench7.core.BaseAssembly
+import stmbench7.core.ComplexAssembly
+import stmbench7.core.Module
+import stmbench7.core.RuntimeError
+
+class ComplexAssemblyImpl(
+ id: Int,
+ typ: String,
+ buildDate: Int,
+ module: Module,
+ superAssembly: ComplexAssembly
+) extends AssemblyImpl(id, typ, buildDate, module, superAssembly)
+ with ComplexAssembly {
+
+ private val subAssemblies = TSet.empty[Assembly].single
+
+ private val level =
+ if (superAssembly == null) Parameters.NumAssmLevels else superAssembly.getLevel - 1
+
+ override def addSubAssembly(assembly: Assembly): Boolean = {
+ if (assembly.isInstanceOf[BaseAssembly] && level != 2)
+ throw new RuntimeError("ComplexAssembly.addAssembly: BaseAssembly at wrong level!");
+
+ subAssemblies.add(assembly)
+ }
+
+ override def removeSubAssembly(assembly: Assembly): Boolean = subAssemblies.remove(assembly)
+
+ override def getSubAssemblies = new ImmutableSetImpl[Assembly](subAssemblies)
+
+ override def getLevel: Short = level.asInstanceOf[Short]
+
+ override def clearPointers(): Unit = {
+ super.clearPointers()
+ subAssemblies.clear()
+ }
+}
diff --git a/benchmarks/scala-stm/src/main/scala/stmbench7/scalastm/CompositePartImpl.scala b/benchmarks/scala-stm/src/main/scala/stmbench7/scalastm/CompositePartImpl.scala
new file mode 100644
index 00000000..8192aa59
--- /dev/null
+++ b/benchmarks/scala-stm/src/main/scala/stmbench7/scalastm/CompositePartImpl.scala
@@ -0,0 +1,55 @@
+/* scala-stm - (c) 2009-2011, Stanford University, PPL */
+
+package stmbench7.scalastm
+
+import scala.concurrent.stm.Ref
+
+import stmbench7.backend.BackendFactory
+import stmbench7.backend.LargeSet
+import stmbench7.core.AtomicPart
+import stmbench7.core.BaseAssembly
+import stmbench7.core.CompositePart
+import stmbench7.core.Document
+
+class CompositePartImpl(id: Int, typ: String, buildDate: Int, documentation0: Document)
+ extends DesignObjImpl(id, typ, buildDate)
+ with CompositePart {
+
+ private val documentation = Ref(documentation0).single
+ private val usedIn = Ref(List.empty[BaseAssembly]).single
+ private val parts = Ref(BackendFactory.instance.createLargeSet[AtomicPart]).single
+ private val rootPart = Ref(null: AtomicPart).single
+
+ documentation0.setPart(this)
+
+ override def addAssembly(assembly: BaseAssembly): Unit = { usedIn.transform(assembly :: _) }
+
+ override def addPart(part: AtomicPart): Boolean = {
+ val f = parts().add(part)
+ if (f) {
+ part.setCompositePart(this)
+ if (rootPart() == null) rootPart() = part
+ }
+ f
+ }
+
+ override def getRootPart: AtomicPart = rootPart()
+ override def setRootPart(part: AtomicPart): Unit = { rootPart() = part }
+
+ override def getDocumentation: Document = documentation()
+
+ override def getParts: LargeSet[AtomicPart] = parts()
+
+ override def removeAssembly(assembly: BaseAssembly): Unit = {
+ usedIn.transform { _.filterNot(_ == assembly) }
+ }
+
+ override def getUsedIn = new ImmutableSeqImpl[BaseAssembly](usedIn())
+
+ override def clearPointers(): Unit = {
+ documentation() = null
+ parts() = null
+ usedIn() = null
+ rootPart() = null
+ }
+}
diff --git a/benchmarks/scala-stm/src/main/scala/stmbench7/scalastm/DesignObjImpl.scala b/benchmarks/scala-stm/src/main/scala/stmbench7/scalastm/DesignObjImpl.scala
new file mode 100644
index 00000000..426fd98a
--- /dev/null
+++ b/benchmarks/scala-stm/src/main/scala/stmbench7/scalastm/DesignObjImpl.scala
@@ -0,0 +1,17 @@
+/* scala-stm - (c) 2009-2011, Stanford University, PPL */
+
+package stmbench7.scalastm
+
+import scala.concurrent.stm.Ref
+
+import stmbench7.core.DesignObj
+
+class DesignObjImpl(id: Int, typ: String, buildDate0: Int) extends DesignObj {
+ private val bd = Ref(buildDate0).single
+
+ override def getId: Int = id
+ override def getType: String = typ
+ override def getBuildDate: Int = bd()
+ override def updateBuildDate(): Unit = { if (bd() % 2 == 0) bd -= 1 else bd += 1 }
+ override def nullOperation(): Unit = {}
+}
diff --git a/benchmarks/scala-stm/src/main/scala/stmbench7/scalastm/DocumentImpl.scala b/benchmarks/scala-stm/src/main/scala/stmbench7/scalastm/DocumentImpl.scala
new file mode 100644
index 00000000..bb210ad6
--- /dev/null
+++ b/benchmarks/scala-stm/src/main/scala/stmbench7/scalastm/DocumentImpl.scala
@@ -0,0 +1,40 @@
+/* scala-stm - (c) 2009-2011, Stanford University, PPL */
+
+package stmbench7.scalastm
+
+import scala.annotation.tailrec
+
+import scala.concurrent.stm.Ref
+
+import stmbench7.core.CompositePart
+import stmbench7.core.Document
+
+class DocumentImpl(id: Int, title: String, text0: String) extends Document {
+ private val text = Ref(text0).single
+ private val part = Ref(null: CompositePart).single
+
+ override def getDocumentId: Int = id
+ override def getTitle: String = title
+
+ override def getCompositePart: CompositePart = part()
+ override def setPart(v: CompositePart): Unit = { part() = v }
+
+ override def nullOperation(): Unit = {}
+
+ override def getText: String = text()
+ override def searchText(symbol: Char): Int = searchText(text(), symbol, 0, 0)
+
+ @tailrec private def searchText(s: String, c: Char, pos: Int, n: Int): Int = {
+ val i = s.indexOf(c, pos)
+ if (i < 0) n else searchText(s, c, i + 1, n + 1)
+ }
+
+ override def replaceText(from: String, to: String): Int = {
+ val f = text transformIfDefined {
+ case s if s.startsWith(from) => s.replaceFirst(from, to)
+ }
+ if (f) 1 else 0
+ }
+
+ override def textBeginsWith(prefix: String): Boolean = text().startsWith(prefix)
+}
diff --git a/benchmarks/scala-stm/scala-stm-library/src/test/scala/stmbench7/scalastm/IdPoolImpl.scala b/benchmarks/scala-stm/src/main/scala/stmbench7/scalastm/IdPoolImpl.scala
similarity index 56%
rename from benchmarks/scala-stm/scala-stm-library/src/test/scala/stmbench7/scalastm/IdPoolImpl.scala
rename to benchmarks/scala-stm/src/main/scala/stmbench7/scalastm/IdPoolImpl.scala
index c1e43b03..144954a6 100644
--- a/benchmarks/scala-stm/scala-stm-library/src/test/scala/stmbench7/scalastm/IdPoolImpl.scala
+++ b/benchmarks/scala-stm/src/main/scala/stmbench7/scalastm/IdPoolImpl.scala
@@ -2,21 +2,23 @@
package stmbench7.scalastm
-import scala.concurrent.stm._
-import stmbench7.core._
+import scala.concurrent.stm.Ref
+
import stmbench7.backend.IdPool
+import stmbench7.core.OperationFailedException
object IdPoolImpl {
+
class BoxedList(n: Int) extends IdPool {
- val underlying = Ref(List.range(1, n + 1)).single
-
- def putUnusedId(id: Int) { underlying.transform(id :: _) }
+ private val underlying = Ref(List.range(1, n + 1)).single
+
+ override def putUnusedId(id: Int): Unit = { underlying.transform(id :: _) }
- def getId = {
+ override def getId: Int = {
underlying.getAndTransform(_.drop(1)) match {
case head :: _ => head
case _ => throw new OperationFailedException
}
}
}
-}
\ No newline at end of file
+}
diff --git a/benchmarks/scala-stm/src/main/scala/stmbench7/scalastm/ImmutableSeqImpl.scala b/benchmarks/scala-stm/src/main/scala/stmbench7/scalastm/ImmutableSeqImpl.scala
new file mode 100644
index 00000000..2d95f8e4
--- /dev/null
+++ b/benchmarks/scala-stm/src/main/scala/stmbench7/scalastm/ImmutableSeqImpl.scala
@@ -0,0 +1,16 @@
+/* scala-stm - (c) 2009-2012, Stanford University, PPL */
+
+package stmbench7.scalastm
+
+import scala.collection.JavaConversions
+
+import stmbench7.backend.ImmutableCollection
+
+class ImmutableSeqImpl[A](contents: Seq[A]) extends ImmutableCollection[A] {
+ override def clone: ImmutableCollection[A] = this
+ override def contains(element: A): Boolean = contents.contains(element)
+ override def size: Int = contents.size
+
+ override def iterator: java.util.Iterator[A] =
+ JavaConversions.asJavaIterator(contents.iterator)
+}
diff --git a/benchmarks/scala-stm/src/main/scala/stmbench7/scalastm/ImmutableSetImpl.scala b/benchmarks/scala-stm/src/main/scala/stmbench7/scalastm/ImmutableSetImpl.scala
new file mode 100644
index 00000000..a350d560
--- /dev/null
+++ b/benchmarks/scala-stm/src/main/scala/stmbench7/scalastm/ImmutableSetImpl.scala
@@ -0,0 +1,23 @@
+/* scala-stm - (c) 2009-2012, Stanford University, PPL */
+
+package stmbench7.scalastm
+
+import scala.collection.JavaConversions
+
+import scala.concurrent.stm.TSet
+
+import stmbench7.backend.ImmutableCollection
+
+/** Read-only wrapper */
+class ImmutableSetImpl[A](contents: TSet.View[A], shared: Boolean = true)
+ extends ImmutableCollection[A] {
+
+ override def clone: ImmutableCollection[A] =
+ if (!shared) this else new ImmutableSetImpl(contents.clone(), false)
+
+ override def contains(element: A): Boolean = contents.contains(element)
+ override def size: Int = contents.size
+
+ override def iterator: java.util.Iterator[A] =
+ JavaConversions.asJavaIterator(contents.iterator)
+}
diff --git a/benchmarks/scala-stm/src/main/scala/stmbench7/scalastm/IndexImpl.scala b/benchmarks/scala-stm/src/main/scala/stmbench7/scalastm/IndexImpl.scala
new file mode 100644
index 00000000..88fb9ee2
--- /dev/null
+++ b/benchmarks/scala-stm/src/main/scala/stmbench7/scalastm/IndexImpl.scala
@@ -0,0 +1,50 @@
+/* scala-stm - (c) 2009-2012, Stanford University, PPL */
+
+package stmbench7.scalastm
+
+import scala.collection.JavaConversions
+import scala.collection.immutable.TreeMap
+
+import scala.concurrent.stm.Ref
+
+import stmbench7.backend.Index
+
+object IndexImpl {
+
+ class BoxedImmutable[K <: Comparable[K], V] extends Index[K, V] {
+ // needed for 2.8, harmless in 2.9
+ implicit val order: Ordering[K] = (lhs: K, rhs: K) => lhs compareTo rhs
+
+ private val underlying = Ref(TreeMap.empty[K, V]).single
+
+ override def get(key: K): V = underlying().getOrElse(key, null.asInstanceOf[V])
+
+ override def put(key: K, value: V): Unit = { underlying.transform(_ + (key -> value)) }
+
+ override def putIfAbsent(key: K, value: V): V = {
+ underlying
+ .getAndTransform({ m => if (m.contains(key)) m else m + (key -> value) })
+ .getOrElse(key, null.asInstanceOf[V])
+ }
+
+ override def remove(key: K): Boolean =
+ underlying transformIfDefined {
+ case m if m.contains(key) => m - key
+ }
+
+ override def iterator: java.util.Iterator[V] = makeValuesIterator(underlying())
+
+ override def getKeys: java.lang.Iterable[K] =
+ JavaConversions.setAsJavaSet(underlying().keySet)
+
+ override def getRange(minKey: K, maxKey: K): java.lang.Iterable[V] =
+ new java.lang.Iterable[V] {
+ private val range = underlying().range(minKey, maxKey)
+ override def iterator: java.util.Iterator[V] = makeValuesIterator(range)
+ }
+
+ private def makeValuesIterator(m: TreeMap[K, V]) = {
+ JavaConversions.asJavaIterator(m.values.iterator)
+ }
+ }
+}
diff --git a/benchmarks/scala-stm/src/main/scala/stmbench7/scalastm/LargeSetImpl.scala b/benchmarks/scala-stm/src/main/scala/stmbench7/scalastm/LargeSetImpl.scala
new file mode 100644
index 00000000..614c4265
--- /dev/null
+++ b/benchmarks/scala-stm/src/main/scala/stmbench7/scalastm/LargeSetImpl.scala
@@ -0,0 +1,21 @@
+/* scala-stm - (c) 2009-2012, Stanford University, PPL */
+
+package stmbench7.scalastm
+
+import scala.collection.JavaConversions
+
+import scala.concurrent.stm.TMap
+
+import stmbench7.backend.LargeSet
+
+class LargeSetImpl[A <: Comparable[A]] extends LargeSet[A] {
+ private val underlying = TMap.empty[A, Unit].single
+
+ override def add(e: A): Boolean = underlying.put(e, ()).isEmpty
+ override def remove(e: A): Boolean = underlying.remove(e).isDefined
+ override def contains(e: A): Boolean = underlying.contains(e)
+ override def size: Int = underlying.size
+
+ override def iterator: java.util.Iterator[A] =
+ JavaConversions.asJavaIterator(underlying.keysIterator)
+}
diff --git a/benchmarks/scala-stm/src/main/scala/stmbench7/scalastm/ManualImpl.scala b/benchmarks/scala-stm/src/main/scala/stmbench7/scalastm/ManualImpl.scala
new file mode 100644
index 00000000..b34fc8e7
--- /dev/null
+++ b/benchmarks/scala-stm/src/main/scala/stmbench7/scalastm/ManualImpl.scala
@@ -0,0 +1,42 @@
+/* scala-stm - (c) 2009-2011, Stanford University, PPL */
+
+package stmbench7.scalastm
+
+import scala.annotation.tailrec
+
+import scala.concurrent.stm.Ref
+
+import stmbench7.core.Manual
+import stmbench7.core.Module
+
+class ManualImpl(id: Int, title0: String, text0: String) extends Manual {
+ private val title = Ref(title0).single
+ private val text = Ref(text0).single
+ private val module = Ref(null: Module).single
+
+ override def getId: Int = id
+ override def getTitle: String = title()
+ override def getText: String = text()
+ override def getModule: Module = module()
+
+ override def setModule(v: Module): Unit = { module() = v }
+
+ override def countOccurences(ch: Char): Int = countOccurrences(text(), ch, 0, 0)
+
+ @tailrec private def countOccurrences(s: String, c: Char, pos: Int, n: Int): Int = {
+ val i = s.indexOf(c, pos)
+ if (i < 0) n else countOccurrences(s, c, i + 1, n + 1)
+ }
+
+ override def checkFirstLastCharTheSame: Int = {
+ val t = text()
+ if (t.charAt(0) == t.charAt(t.length - 1)) 1 else 0
+ }
+
+ override def startsWith(ch: Char): Boolean = text().charAt(0) == ch
+
+ override def replaceChar(from: Char, to: Char): Int = {
+ text.transform(_.replace(from, to))
+ countOccurences(to)
+ }
+}
diff --git a/benchmarks/scala-stm/src/main/scala/stmbench7/scalastm/ModuleImpl.scala b/benchmarks/scala-stm/src/main/scala/stmbench7/scalastm/ModuleImpl.scala
new file mode 100644
index 00000000..4bc462cc
--- /dev/null
+++ b/benchmarks/scala-stm/src/main/scala/stmbench7/scalastm/ModuleImpl.scala
@@ -0,0 +1,22 @@
+/* scala-stm - (c) 2009-2011, Stanford University, PPL */
+
+package stmbench7.scalastm
+
+import scala.concurrent.stm.Ref
+
+import stmbench7.core.ComplexAssembly
+import stmbench7.core.Manual
+import stmbench7.core.Module
+
+class ModuleImpl(id: Int, typ: String, buildDate: Int, man: Manual)
+ extends DesignObjImpl(id, typ, buildDate)
+ with Module {
+
+ private val designRoot = Ref(null: ComplexAssembly).single
+
+ man.setModule(this)
+
+ override def setDesignRoot(v: ComplexAssembly): Unit = { designRoot() = v }
+ override def getDesignRoot: ComplexAssembly = designRoot()
+ override def getManual: Manual = man
+}
diff --git a/benchmarks/scala-stm/src/main/scala/stmbench7/scalastm/ScalaSTMInitializer.scala b/benchmarks/scala-stm/src/main/scala/stmbench7/scalastm/ScalaSTMInitializer.scala
new file mode 100644
index 00000000..16aad7d8
--- /dev/null
+++ b/benchmarks/scala-stm/src/main/scala/stmbench7/scalastm/ScalaSTMInitializer.scala
@@ -0,0 +1,107 @@
+/* scala-stm - (c) 2009-2011, Stanford University, PPL */
+
+package stmbench7.scalastm
+
+import scala.concurrent.stm.atomic
+import scala.concurrent.stm.Ref
+
+import stmbench7.OperationExecutor
+import stmbench7.OperationExecutorFactory
+import stmbench7.Parameters
+import stmbench7.SynchMethodInitializer
+import stmbench7.ThreadFactory
+import stmbench7.backend.BackendFactory
+import stmbench7.backend.IdPool
+import stmbench7.backend.Index
+import stmbench7.backend.LargeSet
+import stmbench7.core.AtomicPart
+import stmbench7.core.ComplexAssembly
+import stmbench7.core.DesignObjFactory
+import stmbench7.core.Document
+import stmbench7.core.Manual
+import stmbench7.core.Module
+import stmbench7.core.Operation
+import stmbench7.impl.core.ConnectionImpl
+
+class ScalaSTMInitializer extends SynchMethodInitializer {
+
+ def createOperationExecutorFactory(): OperationExecutorFactory =
+ new OperationExecutorFactory {
+
+ private val timestamp = Ref(0)
+
+ def createOperationExecutor(op: Operation): OperationExecutor =
+ new OperationExecutor {
+ private var lastTS = 0
+
+ def execute(): Int = {
+ atomic { implicit t =>
+ val z = op.performOperation()
+ if (Parameters.sequentialReplayEnabled) {
+ timestamp += 1
+ lastTS = timestamp()
+ }
+ z
+ }
+ }
+
+ def getLastOperationTimestamp: Int = lastTS
+ }
+ }
+
+ def createBackendFactory(): BackendFactory =
+ new BackendFactory {
+
+ // a couple hundred, not ordered, except for huge numbers of discarded
+ // sets with exactly 1 element
+ def createLargeSet[E <: Comparable[E]](): LargeSet[E] = new LargeSetImpl[E]
+
+ // ordered
+ def createIndex[K <: Comparable[K], V](): Index[K, V] = new IndexImpl.BoxedImmutable[K, V]
+
+ def createIdPool(maxNumberOfIds: Int): IdPool = new IdPoolImpl.BoxedList(maxNumberOfIds)
+ }
+
+ def createDesignObjFactory(): DesignObjFactory =
+ new DesignObjFactory {
+
+ def createAtomicPart(id: Int, typ: String, bd: Int, x: Int, y: Int) =
+ new AtomicPartImpl(id, typ, bd, x, y)
+
+ def createConnection(from: AtomicPart, to: AtomicPart, typ: String, length: Int) =
+ new ConnectionImpl(from, to, typ, length)
+
+ def createBaseAssembly(
+ id: Int,
+ typ: String,
+ buildDate: Int,
+ module: Module,
+ superAssembly: ComplexAssembly
+ ) =
+ new BaseAssemblyImpl(id, typ, buildDate, module, superAssembly)
+
+ def createComplexAssembly(
+ id: Int,
+ typ: String,
+ buildDate: Int,
+ module: Module,
+ superAssembly: ComplexAssembly
+ ) =
+ new ComplexAssemblyImpl(id, typ, buildDate, module, superAssembly)
+
+ def createCompositePart(id: Int, typ: String, buildDate: Int, documentation: Document) =
+ new CompositePartImpl(id, typ, buildDate, documentation)
+
+ def createDocument(id: Int, title: String, text: String) =
+ new DocumentImpl(id, title, text)
+
+ def createManual(id: Int, title: String, text: String) =
+ new ManualImpl(id, title, text)
+
+ def createModule(id: Int, typ: String, buildDate: Int, man: Manual) =
+ new ModuleImpl(id, typ, buildDate, man)
+ }
+
+ def createThreadFactory(): ThreadFactory =
+ (body: Runnable) => new Thread(body)
+}
diff --git a/benchmarks/scala-stm/stmbench7/build.sbt b/benchmarks/scala-stm/stmbench7/build.sbt
new file mode 100644
index 00000000..c9315c27
--- /dev/null
+++ b/benchmarks/scala-stm/stmbench7/build.sbt
@@ -0,0 +1,12 @@
+lazy val parentProject = ProjectRef(uri("../../.."), "scalaStmBenchmarks")
+
+lazy val stmBench7 = (project in file("."))
+ .settings(
+ name := "stmbench7",
+ organization := "ch.epfl.dcl",
+ version := "1.0-20110215-nodeuce",
+ crossPaths := false,
+ autoScalaLibrary := false,
+ javacOptions := (parentProject / javacOptions).value,
+ exportJars := true
+ )
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/BenchThread.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/BenchThread.java
similarity index 90%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/BenchThread.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/BenchThread.java
index 8da09477..94713e3d 100644
--- a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/BenchThread.java
+++ b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/BenchThread.java
@@ -20,7 +20,7 @@ public class BenchThread implements Runnable {
protected double[] operationCDF;
protected OperationExecutor[] operations;
protected final short myThreadNum;
- protected final int countOfOperations;
+ protected final int countOfOperations;
public int[] successfulOperations, failedOperations;
public int[][] operationsTTC, operationsHighTTCLog;
@@ -57,7 +57,7 @@ public BenchThread(Setup setup, double[] operationCDF, short myThreadNum, int co
failedOperations = new int[numOfOperations];
operations = new OperationExecutor[numOfOperations];
this.myThreadNum = myThreadNum;
- this.countOfOperations = countOfOperations;
+ this.countOfOperations = countOfOperations;
createOperations(setup);
@@ -70,19 +70,17 @@ protected BenchThread(Setup setup, double[] operationCDF) {
operations = new OperationExecutor[OperationId.values().length];
createOperations(setup);
myThreadNum = 0;
- throw new RuntimeException("This ctor is no longer allowed.");
+ throw new RuntimeException("This ctor is no longer allowed.");
}
public void run() {
- int i = 0;
- int iteration = 0;
- while (!stop && iteration < countOfOperations) {
- iteration++;
+ int opIndex = 0;
+ while (!stop && opIndex < countOfOperations) {
+ opIndex++;
//if (i++ > 55) continue;
- int operationNumber = getNextOperationNumber(iteration);
+ int operationNumber = getNextOperationNumber(opIndex);
- OperationType type = OperationId.values()[operationNumber].getType();
- // System.out.println(iteration + ": " + operationNumber + ", " + type);
+ // OperationType type = OperationId.values()[operationNumber].getType();
//if( (type != OperationType.SHORT_TRAVERSAL) ) continue;
// (type != OperationType.SHORT_TRAVERSAL_RO) &&
// (type != OperationType.OPERATION) )
@@ -163,7 +161,7 @@ protected void createOperations(Setup setup) {
protected int getNextOperationNumber(int iteration) {
// double whichOperation = ThreadRandom.nextDouble();
- double whichOperation = (iteration % 20) / 20.0;
+ double whichOperation = (iteration % 20) / 20.0;
int operationNumber = 0;
while (whichOperation >= operationCDF[operationNumber])
operationNumber++;
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/Benchmark.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/Benchmark.java
similarity index 98%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/Benchmark.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/Benchmark.java
index 8f35d51a..f5421728 100644
--- a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/Benchmark.java
+++ b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/Benchmark.java
@@ -72,7 +72,7 @@ public static void main(String[] args) throws InterruptedException {
private Setup setup, setupClone;
private double elapsedTime;
private int countOfOperations;
-
+
private Benchmark(String[] args) throws BenchmarkParametersException, InterruptedException {
printHeader();
@@ -130,7 +130,7 @@ else if(currentArg.equals("--")) {
else if(currentArg.equals("-w")) workload = optionValue;
else if(currentArg.equals("-g")) synchType = optionValue;
else if(currentArg.equals("-s")) stmInitializerClassName = optionValue;
- else if(currentArg.equals("-c")) countOfOperations = Integer.parseInt(optionValue);
+ else if(currentArg.equals("-c")) countOfOperations = Integer.parseInt(optionValue);
else throw new BenchmarkParametersException("Invalid option: " + currentArg);
}
}
@@ -263,7 +263,7 @@ private void generateOperationCDF() {
operationsRatio /= sumRatios;
structuralModificationsRatio /= sumRatios;
- for (OperationType type : OperationType.values()) type.count = 0;
+ for (OperationType type : OperationType.values()) type.count = 0;
OperationId[] operations = OperationId.values();
for(OperationId operation : operations) operation.getType().count++;
@@ -301,7 +301,7 @@ private void generateOperationCDF() {
prevProbValue = operationCDF[opNum];
}
operationCDF[operations.length - 1] = 1.0; // to avoid rounding errors
- // System.out.println(Arrays.stream(operationCDF).boxed().collect(java.util.stream.Collectors.toList()));
+ // System.out.println(Arrays.stream(operationCDF).boxed().collect(java.util.stream.Collectors.toList()));
}
private void setupStructures() throws InterruptedException {
@@ -352,10 +352,10 @@ private void start() throws InterruptedException {
for(Thread thread : threads) thread.start();
- // Note: we require the threads to execute the specified number of operations.
+ // Renaissance: we require the threads to execute the specified number of operations.
// Thread.sleep(Parameters.numSeconds * 1000);
-
// for(BenchThread thread : benchThreads) thread.stopThread();
+
for(Thread thread : threads) thread.join();
long endTime = System.currentTimeMillis();
@@ -516,6 +516,7 @@ private void printSyntax() {
"Options:\n" +
"\t-t numThreads -- set the number of threads (default: 1)\n" +
"\t-l length -- set the length of the benchmark, in seconds (default: 10)\n" +
+ "\t-c count -- set the length of the benchmark, in operations\n" +
"\t-w r|rw|w -- set the workload: r = read-dominated, w = write-dominated\n" +
"\t rw = read-write (default: read-dominated)\n" +
"\t-g coarse|medium|fine|none|stm -- set synchronization method (default: coarse)\n" +
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/ImplParameters.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/ImplParameters.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/ImplParameters.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/ImplParameters.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/OperationExecutor.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/OperationExecutor.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/OperationExecutor.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/OperationExecutor.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/OperationExecutorFactory.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/OperationExecutorFactory.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/OperationExecutorFactory.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/OperationExecutorFactory.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/OperationId.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/OperationId.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/OperationId.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/OperationId.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/OperationType.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/OperationType.java
similarity index 97%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/OperationType.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/OperationType.java
index 983d8c69..4079ce5c 100644
--- a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/OperationType.java
+++ b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/OperationType.java
@@ -14,7 +14,6 @@ public enum OperationType {
/**
* Some helper fields to make life easier.
- * Lord...
*/
public int count = 0;
public double probability = 0;
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/Parameters.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/Parameters.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/Parameters.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/Parameters.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/Setup.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/Setup.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/Setup.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/Setup.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/SynchMethodInitializer.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/SynchMethodInitializer.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/SynchMethodInitializer.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/SynchMethodInitializer.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/ThreadFactory.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/ThreadFactory.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/ThreadFactory.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/ThreadFactory.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/ThreadRandom.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/ThreadRandom.java
similarity index 98%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/ThreadRandom.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/ThreadRandom.java
index ba226c8f..ce7df7fd 100644
--- a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/ThreadRandom.java
+++ b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/ThreadRandom.java
@@ -88,9 +88,9 @@ public static double nextDouble() {
public static void reset() {
if(phase != Phase.INIT) {
- System.out.println("Warning, cannot reset!");
+ System.out.println("Warning, cannot reset!");
throw new RuntimeError("Cannot reset ThreadRandom after the initialization phase");
- }
+ }
initRandom = new RandomState();
}
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/annotations/Atomic.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/annotations/Atomic.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/annotations/Atomic.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/annotations/Atomic.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/annotations/ContainedInAtomic.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/annotations/ContainedInAtomic.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/annotations/ContainedInAtomic.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/annotations/ContainedInAtomic.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/annotations/Immutable.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/annotations/Immutable.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/annotations/Immutable.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/annotations/Immutable.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/annotations/NonAtomic.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/annotations/NonAtomic.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/annotations/NonAtomic.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/annotations/NonAtomic.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/annotations/ReadOnly.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/annotations/ReadOnly.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/annotations/ReadOnly.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/annotations/ReadOnly.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/annotations/ThreadLocal.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/annotations/ThreadLocal.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/annotations/ThreadLocal.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/annotations/ThreadLocal.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/annotations/Transactional.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/annotations/Transactional.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/annotations/Transactional.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/annotations/Transactional.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/annotations/Update.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/annotations/Update.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/annotations/Update.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/annotations/Update.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/backend/BackendFactory.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/backend/BackendFactory.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/backend/BackendFactory.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/backend/BackendFactory.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/backend/IdPool.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/backend/IdPool.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/backend/IdPool.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/backend/IdPool.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/backend/ImmutableCollection.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/backend/ImmutableCollection.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/backend/ImmutableCollection.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/backend/ImmutableCollection.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/backend/Index.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/backend/Index.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/backend/Index.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/backend/Index.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/backend/LargeSet.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/backend/LargeSet.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/backend/LargeSet.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/backend/LargeSet.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/core/Assembly.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/core/Assembly.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/core/Assembly.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/core/Assembly.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/core/AssemblyBuilder.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/core/AssemblyBuilder.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/core/AssemblyBuilder.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/core/AssemblyBuilder.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/core/AtomicPart.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/core/AtomicPart.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/core/AtomicPart.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/core/AtomicPart.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/core/AtomicPartBuilder.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/core/AtomicPartBuilder.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/core/AtomicPartBuilder.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/core/AtomicPartBuilder.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/core/BaseAssembly.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/core/BaseAssembly.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/core/BaseAssembly.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/core/BaseAssembly.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/core/ComplexAssembly.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/core/ComplexAssembly.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/core/ComplexAssembly.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/core/ComplexAssembly.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/core/CompositePart.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/core/CompositePart.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/core/CompositePart.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/core/CompositePart.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/core/CompositePartBuilder.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/core/CompositePartBuilder.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/core/CompositePartBuilder.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/core/CompositePartBuilder.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/core/Connection.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/core/Connection.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/core/Connection.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/core/Connection.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/core/DesignObj.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/core/DesignObj.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/core/DesignObj.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/core/DesignObj.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/core/DesignObjBuilder.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/core/DesignObjBuilder.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/core/DesignObjBuilder.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/core/DesignObjBuilder.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/core/DesignObjFactory.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/core/DesignObjFactory.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/core/DesignObjFactory.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/core/DesignObjFactory.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/core/Document.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/core/Document.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/core/Document.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/core/Document.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/core/DocumentBuilder.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/core/DocumentBuilder.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/core/DocumentBuilder.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/core/DocumentBuilder.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/core/Manual.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/core/Manual.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/core/Manual.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/core/Manual.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/core/ManualBuilder.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/core/ManualBuilder.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/core/ManualBuilder.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/core/ManualBuilder.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/core/Module.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/core/Module.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/core/Module.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/core/Module.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/core/ModuleBuilder.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/core/ModuleBuilder.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/core/ModuleBuilder.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/core/ModuleBuilder.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/core/Operation.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/core/Operation.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/core/Operation.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/core/Operation.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/core/OperationFailedException.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/core/OperationFailedException.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/core/OperationFailedException.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/core/OperationFailedException.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/core/RuntimeError.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/core/RuntimeError.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/core/RuntimeError.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/core/RuntimeError.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/correctness/invariants/AssemblyTest.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/correctness/invariants/AssemblyTest.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/correctness/invariants/AssemblyTest.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/correctness/invariants/AssemblyTest.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/correctness/invariants/AtomicPartTest.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/correctness/invariants/AtomicPartTest.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/correctness/invariants/AtomicPartTest.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/correctness/invariants/AtomicPartTest.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/correctness/invariants/BaseAssemblyTest.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/correctness/invariants/BaseAssemblyTest.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/correctness/invariants/BaseAssemblyTest.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/correctness/invariants/BaseAssemblyTest.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/correctness/invariants/CheckInvariantsOperation.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/correctness/invariants/CheckInvariantsOperation.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/correctness/invariants/CheckInvariantsOperation.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/correctness/invariants/CheckInvariantsOperation.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/correctness/invariants/ComplexAssemblyTest.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/correctness/invariants/ComplexAssemblyTest.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/correctness/invariants/ComplexAssemblyTest.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/correctness/invariants/ComplexAssemblyTest.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/correctness/invariants/CompositePartTest.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/correctness/invariants/CompositePartTest.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/correctness/invariants/CompositePartTest.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/correctness/invariants/CompositePartTest.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/correctness/invariants/ConnectionTest.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/correctness/invariants/ConnectionTest.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/correctness/invariants/ConnectionTest.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/correctness/invariants/ConnectionTest.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/correctness/invariants/DesignObjTest.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/correctness/invariants/DesignObjTest.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/correctness/invariants/DesignObjTest.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/correctness/invariants/DesignObjTest.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/correctness/invariants/DocumentationTest.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/correctness/invariants/DocumentationTest.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/correctness/invariants/DocumentationTest.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/correctness/invariants/DocumentationTest.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/correctness/invariants/IndexTest.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/correctness/invariants/IndexTest.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/correctness/invariants/IndexTest.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/correctness/invariants/IndexTest.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/correctness/invariants/InvariantTest.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/correctness/invariants/InvariantTest.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/correctness/invariants/InvariantTest.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/correctness/invariants/InvariantTest.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/correctness/invariants/ManualTest.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/correctness/invariants/ManualTest.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/correctness/invariants/ManualTest.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/correctness/invariants/ManualTest.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/correctness/invariants/ModuleTest.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/correctness/invariants/ModuleTest.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/correctness/invariants/ModuleTest.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/correctness/invariants/ModuleTest.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/correctness/invariants/TraversedObjects.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/correctness/invariants/TraversedObjects.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/correctness/invariants/TraversedObjects.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/correctness/invariants/TraversedObjects.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/correctness/opacity/SequentialReplayThread.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/correctness/opacity/SequentialReplayThread.java
similarity index 90%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/correctness/opacity/SequentialReplayThread.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/correctness/opacity/SequentialReplayThread.java
index 825e9717..b0017e65 100644
--- a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/correctness/opacity/SequentialReplayThread.java
+++ b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/correctness/opacity/SequentialReplayThread.java
@@ -27,19 +27,19 @@ public SequentialReplayThread(Setup setup, double[] operationCDF,
}
public void run() {
- int i = 0;
+ // int i = 0;
//for(ReplayLogEntry entry : replayLog)
// System.out.println(i++ + " @ " + OperationId.values()[entry.opNum] + " -- " + entry.timestamp);
- i=0;
- int opNum = 1, numOfOps = replayLog.size();
+ int opIndex = 1, opCount = replayLog.size();
for(ReplayLogEntry entry : replayLog) {
- System.err.print("Operation " + (opNum++) + " out of " + numOfOps + "\r");
+ System.err.print("Operation " + opIndex + " out of " + opCount + "\r");
short threadNum = entry.threadNum;
ThreadRandom.setVirtualThreadNumber(threadNum);
//System.out.println(++i);
- int operationNumber = getNextOperationNumber();
-
+ int operationNumber = getNextOperationNumber(opIndex);
+ opIndex++;
+
//System.out.println(entry.threadNum + " -- " + OperationId.values()[entry.opNum] +
// " / " + OperationId.values()[operationNumber]);
if(operationNumber != entry.opNum)
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/correctness/opacity/StructureComparisonOperation.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/correctness/opacity/StructureComparisonOperation.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/correctness/opacity/StructureComparisonOperation.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/correctness/opacity/StructureComparisonOperation.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/impl/DefaultOperationExecutor.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/impl/DefaultOperationExecutor.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/impl/DefaultOperationExecutor.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/impl/DefaultOperationExecutor.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/impl/DefaultOperationExecutorFactory.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/impl/DefaultOperationExecutorFactory.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/impl/DefaultOperationExecutorFactory.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/impl/DefaultOperationExecutorFactory.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/impl/DefaultThreadFactory.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/impl/DefaultThreadFactory.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/impl/DefaultThreadFactory.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/impl/DefaultThreadFactory.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/impl/NoSynchronizationInitializer.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/impl/NoSynchronizationInitializer.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/impl/NoSynchronizationInitializer.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/impl/NoSynchronizationInitializer.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/impl/backend/BackendFactoryImpl.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/impl/backend/BackendFactoryImpl.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/impl/backend/BackendFactoryImpl.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/impl/backend/BackendFactoryImpl.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/impl/backend/BagImpl.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/impl/backend/BagImpl.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/impl/backend/BagImpl.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/impl/backend/BagImpl.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/impl/backend/IdPoolImpl.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/impl/backend/IdPoolImpl.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/impl/backend/IdPoolImpl.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/impl/backend/IdPoolImpl.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/impl/backend/ImmutableViewImpl.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/impl/backend/ImmutableViewImpl.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/impl/backend/ImmutableViewImpl.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/impl/backend/ImmutableViewImpl.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/impl/backend/LargeSetImpl.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/impl/backend/LargeSetImpl.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/impl/backend/LargeSetImpl.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/impl/backend/LargeSetImpl.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/impl/backend/SmallSetImpl.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/impl/backend/SmallSetImpl.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/impl/backend/SmallSetImpl.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/impl/backend/SmallSetImpl.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/impl/backend/TreeMapIndex.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/impl/backend/TreeMapIndex.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/impl/backend/TreeMapIndex.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/impl/backend/TreeMapIndex.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/impl/core/AssemblyImpl.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/impl/core/AssemblyImpl.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/impl/core/AssemblyImpl.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/impl/core/AssemblyImpl.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/impl/core/AtomicPartImpl.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/impl/core/AtomicPartImpl.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/impl/core/AtomicPartImpl.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/impl/core/AtomicPartImpl.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/impl/core/BaseAssemblyImpl.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/impl/core/BaseAssemblyImpl.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/impl/core/BaseAssemblyImpl.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/impl/core/BaseAssemblyImpl.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/impl/core/ComplexAssemblyImpl.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/impl/core/ComplexAssemblyImpl.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/impl/core/ComplexAssemblyImpl.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/impl/core/ComplexAssemblyImpl.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/impl/core/CompositePartImpl.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/impl/core/CompositePartImpl.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/impl/core/CompositePartImpl.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/impl/core/CompositePartImpl.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/impl/core/ConnectionImpl.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/impl/core/ConnectionImpl.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/impl/core/ConnectionImpl.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/impl/core/ConnectionImpl.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/impl/core/DesignObjFactoryImpl.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/impl/core/DesignObjFactoryImpl.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/impl/core/DesignObjFactoryImpl.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/impl/core/DesignObjFactoryImpl.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/impl/core/DesignObjImpl.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/impl/core/DesignObjImpl.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/impl/core/DesignObjImpl.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/impl/core/DesignObjImpl.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/impl/core/DocumentImpl.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/impl/core/DocumentImpl.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/impl/core/DocumentImpl.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/impl/core/DocumentImpl.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/impl/core/ManualImpl.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/impl/core/ManualImpl.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/impl/core/ManualImpl.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/impl/core/ManualImpl.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/impl/core/ModuleImpl.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/impl/core/ModuleImpl.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/impl/core/ModuleImpl.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/impl/core/ModuleImpl.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/locking/CGLockingInitializer.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/locking/CGLockingInitializer.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/locking/CGLockingInitializer.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/locking/CGLockingInitializer.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/locking/CGLockingOperationExecutor.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/locking/CGLockingOperationExecutor.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/locking/CGLockingOperationExecutor.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/locking/CGLockingOperationExecutor.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/locking/CGLockingOperationExecutorFactory.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/locking/CGLockingOperationExecutorFactory.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/locking/CGLockingOperationExecutorFactory.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/locking/CGLockingOperationExecutorFactory.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/locking/MGLockingComplexAssemblyImpl.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/locking/MGLockingComplexAssemblyImpl.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/locking/MGLockingComplexAssemblyImpl.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/locking/MGLockingComplexAssemblyImpl.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/locking/MGLockingDesignObjFactory.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/locking/MGLockingDesignObjFactory.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/locking/MGLockingDesignObjFactory.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/locking/MGLockingDesignObjFactory.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/locking/MGLockingInitializer.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/locking/MGLockingInitializer.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/locking/MGLockingInitializer.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/locking/MGLockingInitializer.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/locking/MGLockingOperationExecutor.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/locking/MGLockingOperationExecutor.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/locking/MGLockingOperationExecutor.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/locking/MGLockingOperationExecutor.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/locking/MGLockingOperationExecutorFactory.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/locking/MGLockingOperationExecutorFactory.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/locking/MGLockingOperationExecutorFactory.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/locking/MGLockingOperationExecutorFactory.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/BaseOperation.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/BaseOperation.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/BaseOperation.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/BaseOperation.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/Operation10.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/Operation10.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/Operation10.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/Operation10.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/Operation11.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/Operation11.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/Operation11.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/Operation11.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/Operation12.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/Operation12.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/Operation12.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/Operation12.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/Operation13.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/Operation13.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/Operation13.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/Operation13.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/Operation14.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/Operation14.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/Operation14.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/Operation14.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/Operation15.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/Operation15.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/Operation15.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/Operation15.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/Operation6.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/Operation6.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/Operation6.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/Operation6.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/Operation7.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/Operation7.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/Operation7.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/Operation7.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/Operation8.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/Operation8.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/Operation8.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/Operation8.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/Operation9.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/Operation9.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/Operation9.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/Operation9.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/Query1.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/Query1.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/Query1.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/Query1.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/Query2.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/Query2.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/Query2.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/Query2.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/Query3.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/Query3.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/Query3.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/Query3.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/Query4.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/Query4.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/Query4.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/Query4.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/Query5.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/Query5.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/Query5.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/Query5.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/Query6.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/Query6.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/Query6.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/Query6.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/Query7.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/Query7.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/Query7.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/Query7.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/SetupDataStructure.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/SetupDataStructure.java
similarity index 95%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/SetupDataStructure.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/SetupDataStructure.java
index a4e5eec1..57d7c207 100644
--- a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/SetupDataStructure.java
+++ b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/SetupDataStructure.java
@@ -32,7 +32,7 @@ public int performOperation() throws OperationFailedException {
CompositePartBuilder compositePartBuilder = setup.getCompositePartBuilder();
for(int i = 0; i < Parameters.InitialTotalCompParts; i++) {
- // Removed, because of too much output.
+ // Renaissance: Removed, because of too much output.
// System.err.print("Component " + (i+1) + " of " + Parameters.InitialTotalCompParts + "\r");
try {
designLibrary[i] = compositePartBuilder.createAndRegisterCompositePart();
@@ -53,7 +53,7 @@ public int performOperation() throws OperationFailedException {
int i = 1;
for(BaseAssembly baseAssembly : setup.getBaseAssemblyIdIndex()) {
- // Removed, because of too much output.
+ // Renaissance: Removed, because of too much output.
// System.err.print("Base Assembly " + (i++) + " of " + Parameters.InitialTotalBaseAssemblies + "\r");
for(int connections = 0; connections < Parameters.NumCompPerAssm; connections++) {
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/ShortTraversal1.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/ShortTraversal1.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/ShortTraversal1.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/ShortTraversal1.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/ShortTraversal10.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/ShortTraversal10.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/ShortTraversal10.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/ShortTraversal10.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/ShortTraversal2.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/ShortTraversal2.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/ShortTraversal2.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/ShortTraversal2.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/ShortTraversal6.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/ShortTraversal6.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/ShortTraversal6.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/ShortTraversal6.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/ShortTraversal7.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/ShortTraversal7.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/ShortTraversal7.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/ShortTraversal7.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/ShortTraversal8.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/ShortTraversal8.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/ShortTraversal8.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/ShortTraversal8.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/ShortTraversal9.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/ShortTraversal9.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/ShortTraversal9.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/ShortTraversal9.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/StructuralModification1.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/StructuralModification1.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/StructuralModification1.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/StructuralModification1.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/StructuralModification2.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/StructuralModification2.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/StructuralModification2.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/StructuralModification2.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/StructuralModification3.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/StructuralModification3.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/StructuralModification3.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/StructuralModification3.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/StructuralModification4.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/StructuralModification4.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/StructuralModification4.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/StructuralModification4.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/StructuralModification5.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/StructuralModification5.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/StructuralModification5.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/StructuralModification5.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/StructuralModification6.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/StructuralModification6.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/StructuralModification6.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/StructuralModification6.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/StructuralModification7.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/StructuralModification7.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/StructuralModification7.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/StructuralModification7.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/StructuralModification8.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/StructuralModification8.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/StructuralModification8.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/StructuralModification8.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/Traversal1.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/Traversal1.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/Traversal1.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/Traversal1.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/Traversal2a.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/Traversal2a.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/Traversal2a.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/Traversal2a.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/Traversal2b.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/Traversal2b.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/Traversal2b.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/Traversal2b.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/Traversal2c.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/Traversal2c.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/Traversal2c.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/Traversal2c.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/Traversal3a.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/Traversal3a.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/Traversal3a.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/Traversal3a.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/Traversal3b.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/Traversal3b.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/Traversal3b.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/Traversal3b.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/Traversal3c.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/Traversal3c.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/Traversal3c.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/Traversal3c.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/Traversal4.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/Traversal4.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/Traversal4.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/Traversal4.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/Traversal5.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/Traversal5.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/Traversal5.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/Traversal5.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/Traversal6.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/Traversal6.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/Traversal6.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/Traversal6.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/Traversal7.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/Traversal7.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/Traversal7.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/Traversal7.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/Traversal8.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/Traversal8.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/Traversal8.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/Traversal8.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/Traversal9.java b/benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/Traversal9.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/operations/Traversal9.java
rename to benchmarks/scala-stm/stmbench7/src/main/java/stmbench7/operations/Traversal9.java
diff --git a/benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/test/backend/IndexTest.java b/benchmarks/scala-stm/stmbench7/src/test/java/stmbench7/test/backend/IndexTest.java
similarity index 100%
rename from benchmarks/scala-stm/scala-stm-library/lib/sb7-java-v1.2/src/stmbench7/test/backend/IndexTest.java
rename to benchmarks/scala-stm/stmbench7/src/test/java/stmbench7/test/backend/IndexTest.java
diff --git a/build.sbt b/build.sbt
index 1a025309..ac183ea6 100644
--- a/build.sbt
+++ b/build.sbt
@@ -450,13 +450,14 @@ lazy val scalaStdlibBenchmarks = (project in file("benchmarks/scala-stdlib"))
lazy val scalaStmBenchmarks = (project in file("benchmarks/scala-stm"))
.settings(
name := "scala-stm",
- commonSettingsScala212
+ commonSettingsScala212,
+ libraryDependencies := Seq(
+ "org.scala-stm" %% "scala-stm" % "0.11.1"
+ )
)
.dependsOn(
renaissanceCore % "provided",
- RootProject(
- uri("benchmarks/scala-stm/scala-stm-library")
- ) % "compile->compile;compile->test"
+ RootProject(uri("benchmarks/scala-stm/stmbench7"))
)
val finagleVersion = "22.12.0"