refactors to ParallelProg/w2

Author: spamegg1

courses/ParallelProg/w2/reductions/build.sbt

@@ -1,13 +1,12 @@
 course := "parprog1"
 assignment := "reductions"
 
-scalaVersion := "3.0.0"
+scalaVersion := "3.4.2"
 scalacOptions ++= Seq("-language:implicitConversions", "-deprecation")
 libraryDependencies ++= Seq(
-  ("com.storm-enroute" %% "scalameter-core" % "0.21")
-    .cross(CrossVersion.for3Use2_13),
-  "org.scala-lang.modules" %% "scala-parallel-collections" % "1.0.3",
-  "org.scalameta" %% "munit" % "0.7.26" % Test
+  ("com.storm-enroute" %% "scalameter-core" % "0.21").cross(CrossVersion.for3Use2_13),
+  "org.scala-lang.modules" %% "scala-parallel-collections" % "1.0.4",
+  "org.scalameta" %% "munit" % "1.0.0" % Test
 )
 
 testFrameworks += new TestFramework("munit.Framework")

courses/ParallelProg/w2/reductions/project/build.properties

@@ -1 +1 @@
-sbt.version=1.5.0
+sbt.version=1.10.0

courses/ParallelProg/w2/reductions/src/main/scala/reductions/Interfaces.scala

@@ -2,26 +2,38 @@ package reductions
 
 // Interfaces used by the grading infrastructure. Do not change signatures
 // or your submission will fail with a NoSuchMethodError.
-
 trait LineOfSightInterface:
   def lineOfSight(input: Array[Float], output: Array[Float]): Unit
   def upsweepSequential(input: Array[Float], from: Int, until: Int): Float
   def upsweep(input: Array[Float], from: Int, end: Int, threshold: Int): Tree
-  def downsweepSequential(input: Array[Float], output: Array[Float],
-                          startingAngle: Float, from: Int, until: Int): Unit
-  def downsweep(input: Array[Float], output: Array[Float],
-                startingAngle: Float, tree: Tree): Unit
-  def parLineOfSight(input: Array[Float], output: Array[Float],
-                     threshold: Int): Unit
+  def downsweepSequential(
+      input: Array[Float],
+      output: Array[Float],
+      startingAngle: Float,
+      from: Int,
+      until: Int
+  ): Unit
+  def downsweep(
+      input: Array[Float],
+      output: Array[Float],
+      startingAngle: Float,
+      tree: Tree
+  ): Unit
+  def parLineOfSight(input: Array[Float], output: Array[Float], threshold: Int): Unit
 
 trait ParallelCountChangeInterface:
   def countChange(money: Int, coins: List[Int]): Int
-  def parCountChange(money: Int, coins: List[Int],
-                     threshold: (Int, List[Int]) => Boolean): Int
+  def parCountChange(
+      money: Int,
+      coins: List[Int],
+      threshold: (Int, List[Int]) => Boolean
+  ): Int
   def moneyThreshold(startingMoney: Int): (Int, List[Int]) => Boolean
   def totalCoinsThreshold(totalCoins: Int): (Int, List[Int]) => Boolean
-  def combinedThreshold(startingMoney: Int, allCoins: List[Int])
-                     : (Int, List[Int]) => Boolean
+  def combinedThreshold(
+      startingMoney: Int,
+      allCoins: List[Int]
+  ): (Int, List[Int]) => Boolean
 
 trait ParallelParenthesesBalancingInterface:
   def balance(chars: Array[Char]): Boolean

courses/ParallelProg/w2/reductions/src/main/scala/reductions/LineOfSight.scala

@@ -3,25 +3,24 @@ package reductions
 import org.scalameter.*
 
 object LineOfSightRunner:
-
   val standardConfig = config(
     Key.exec.minWarmupRuns := 40,
     Key.exec.maxWarmupRuns := 80,
     Key.exec.benchRuns := 100,
     Key.verbose := false
-  ) withWarmer (Warmer.Default())
+  ).withWarmer(Warmer.Default())
 
-  def main(args: Array[String]): Unit =
+  def main: Unit =
     val length = 10000000
     val input = (0 until length).map(_ % 100 * 1.0f).toArray
     val output = new Array[Float](length + 1)
-    val seqtime = standardConfig.measure(LineOfSight.lineOfSight(input, output))
 
+    val seqtime = standardConfig.measure(LineOfSight.lineOfSight(input, output))
     println(s"sequential time: $seqtime")
 
     val partime = standardConfig.measure(LineOfSight.parLineOfSight(input, output, 10000))
-
     println(s"parallel time: $partime")
+
     println(s"speedup: ${seqtime.value / partime.value}")
 
 enum Tree(val maxPrevious: Float):
@@ -30,7 +29,6 @@ enum Tree(val maxPrevious: Float):
       extends Tree(maxPrevious)
 
 object LineOfSight extends LineOfSightInterface:
-
   def lineOfSight(input: Array[Float], output: Array[Float]): Unit = // TODO
     output(0) = 0
     var maximum: Float = 0
@@ -40,23 +38,20 @@ object LineOfSight extends LineOfSightInterface:
       output(i) = maximum
       i = i + 1
 
-  /** Traverses the specified part of the array and returns the maximum angle.
-    */
-  def upsweepSequential(input: Array[Float], from: Int, until: Int): Float =
-    var maximum: Float = 0 // TODO
+  /* Traverses the specified part of the array and returns the maximum angle. */
+  def upsweepSequential(input: Array[Float], from: Int, until: Int): Float = // TODO
+    var maximum: Float = 0
     var i: Int = from
     while i < until do
       maximum = math.max(maximum, input(i) / i)
       i = i + 1
     maximum
 
   /** Traverses the part of the array starting at `from` and until `end`, and returns the
-    * reduction tree for that part of the array.
-    *
-    * The reduction tree is a `Tree.Leaf` if the length of the specified part of the array
-    * is smaller or equal to `threshold`, and a `Tree.Node` otherwise. If the specified
-    * part of the array is longer than `threshold`, then the work is divided and done
-    * recursively in parallel.
+    * reduction tree for that part of the array. The reduction tree is a `Tree.Leaf` if
+    * the length of the specified part of the array is smaller or equal to `threshold`,
+    * and a `Tree.Node` otherwise. If the specified part of the array is longer than
+    * `threshold`, then the work is divided and done recursively in parallel.
     */
   def upsweep(input: Array[Float], from: Int, end: Int, threshold: Int): Tree = // TODO
     if end - from <= threshold then // if I use < only, I get stackOverFlow

courses/ParallelProg/w2/reductions/src/main/scala/reductions/ParallelCountChange.scala

@@ -11,31 +11,24 @@ object ParallelCountChangeRunner:
     Key.exec.maxWarmupRuns := 40,
     Key.exec.benchRuns := 80,
     Key.verbose := false
-  ) withWarmer (Warmer.Default())
+  ).withWarmer(Warmer.Default())
 
-  def main(args: Array[String]): Unit =
+  def main: Unit =
     val amount = 250
     val coins = List(1, 2, 5, 10, 20, 50)
-    val seqtime = standardConfig measure {
+    val seqtime = standardConfig.measure:
       seqResult = ParallelCountChange.countChange(amount, coins)
-    }
-
     println(s"sequential result = $seqResult")
     println(s"sequential count time: $seqtime")
 
     def measureParallelCountChange(threshold: => ParallelCountChange.Threshold): Unit =
       try
-        val fjtime = standardConfig measure {
+        val fjtime = standardConfig.measure:
           parResult = ParallelCountChange.parCountChange(amount, coins, threshold)
-        }
-
         println(s"parallel result = $parResult")
         println(s"parallel count time: $fjtime")
         println(s"speedup: ${seqtime.value / fjtime.value}")
-
-      catch
-        case e: NotImplementedError =>
-          println("Not implemented.")
+      catch case e: NotImplementedError => println("Not implemented.")
 
     println("\n# Using moneyThreshold\n")
     measureParallelCountChange(ParallelCountChange.moneyThreshold(amount))
@@ -47,7 +40,6 @@ object ParallelCountChangeRunner:
     measureParallelCountChange(ParallelCountChange.combinedThreshold(amount, coins))
 
 object ParallelCountChange extends ParallelCountChangeInterface:
-
   /** Returns the number of ways change can be made from the specified list of coins for
     * the specified amount of money.
     */
@@ -56,18 +48,16 @@ object ParallelCountChange extends ParallelCountChangeInterface:
     case 0          => 1
     case _ =>
       coins match
-        case Nil => 0
-        case head :: tail =>
-          countChange(money - head, coins) + countChange(money, tail)
+        case Nil          => 0
+        case head :: tail => countChange(money - head, coins) + countChange(money, tail)
 
   type Threshold = (Int, List[Int]) => Boolean
 
   /** In parallel, counts the number of ways change can be made from the specified list of
     * coins for the specified amount of money.
     */
-  def parCountChange(money: Int, coins: List[Int], threshold: Threshold): Int =
-    if threshold(money, coins) // TODO
-    then countChange(money, coins)
+  def parCountChange(money: Int, coins: List[Int], threshold: Threshold): Int = // TODO
+    if threshold(money, coins) then countChange(money, coins)
     else
       money match
         case m if m < 0 => 0

courses/ParallelProg/w2/reductions/src/main/scala/reductions/ParallelParenthesesBalancing.scala

@@ -12,37 +12,30 @@ object ParallelParenthesesBalancingRunner:
     Key.exec.maxWarmupRuns := 80,
     Key.exec.benchRuns := 120,
     Key.verbose := false
-  ) withWarmer (Warmer.Default())
+  ).withWarmer(Warmer.Default())
 
-  def main(args: Array[String]): Unit =
+  def main: Unit =
     val length = 100000000
     val threshold = 10000
-
     val openParens = Array.fill(length / 4)('(')
     val closeParens = Array.fill(length / 4)(')')
-
     val chars = openParens ++ closeParens ++ openParens ++ closeParens
     // val chars = new Array[Char](length)
 
-    val seqtime = standardConfig measure {
+    val seqtime = standardConfig.measure:
       seqResult = ParallelParenthesesBalancing.balance(chars)
-    }
-
     println(s"sequential result = $seqResult")
     println(s"sequential balancing time: $seqtime")
 
-    val fjtime = standardConfig measure {
+    val fjtime = standardConfig.measure:
       parResult = ParallelParenthesesBalancing.parBalance(chars, threshold)
-    }
-
     println(s"parallel result = $parResult")
     println(s"parallel balancing time: $fjtime")
+
     println(s"speedup: ${seqtime.value / fjtime.value}")
 
 object ParallelParenthesesBalancing extends ParallelParenthesesBalancingInterface:
-
-  /** Returns `true` iff the parentheses in the input `chars` are balanced.
-    */
+  /* Returns `true` iff the parentheses in the input `chars` are balanced. */
   def balance(chars: Array[Char]): Boolean = // TODO
     @annotation.tailrec
     def helper(left: Int, right: Int, chars: Array[Char]): Boolean =
@@ -55,8 +48,7 @@ object ParallelParenthesesBalancing extends ParallelParenthesesBalancingInterfac
           case _                    => helper(left, right, chars.tail)
     helper(0, 0, chars)
 
-  /** Returns `true` iff the parentheses in the input `chars` are balanced.
-    */
+  /* Returns `true` iff the parentheses in the input `chars` are balanced. */
   def parBalance(chars: Array[Char], threshold: Int): Boolean = // TODO
     @annotation.tailrec
     def traverse(idx: Int, until: Int, arg1: Int, arg2: Int): (Int, Int) =
@@ -69,8 +61,7 @@ object ParallelParenthesesBalancing extends ParallelParenthesesBalancingInterfac
           case _                => traverse(idx + 1, until, arg1, arg2)
 
     def reduce(from: Int, until: Int): (Int, Int) = // TODO
-      if until - from <= threshold
-      then traverse(from, until, 0, 0)
+      if until - from <= threshold then traverse(from, until, 0, 0)
       else
         val mid: Int = (until - from) / 2 + from
         val ((l1, r1), (l2, r2)) = parallel(reduce(from, mid), reduce(mid, until))

courses/ParallelProg/w2/reductions/src/main/scala/reductions/common.scala

@@ -2,15 +2,14 @@ package reductions
 
 import java.util.concurrent.*
 import scala.util.DynamicVariable
-
 import org.scalameter.*
 
 val forkJoinPool = ForkJoinPool()
 
 abstract class TaskScheduler:
   def schedule[T](body: => T): ForkJoinTask[T]
   def parallel[A, B](taskA: => A, taskB: => B): (A, B) =
-    val right = task { taskB }
+    val right = task(taskB)
     val left = taskA
     (left, right.join())
 
@@ -21,7 +20,7 @@ class DefaultTaskScheduler extends TaskScheduler:
 
     Thread.currentThread match
       case wt: ForkJoinWorkerThread => t.fork()
-      case _ => forkJoinPool.execute(t)
+      case _                        => forkJoinPool.execute(t)
     t
 
 val scheduler = DynamicVariable[TaskScheduler](DefaultTaskScheduler())
@@ -31,10 +30,14 @@ def task[T](body: => T): ForkJoinTask[T] = scheduler.value.schedule(body)
 def parallel[A, B](taskA: => A, taskB: => B): (A, B) =
   scheduler.value.parallel(taskA, taskB)
 
-def parallel[A, B, C, D](taskA: => A, taskB: => B,
-                         taskC: => C, taskD: => D): (A, B, C, D) =
-  val ta = task { taskA }
-  val tb = task { taskB }
-  val tc = task { taskC }
+def parallel[A, B, C, D](
+    taskA: => A,
+    taskB: => B,
+    taskC: => C,
+    taskD: => D
+): (A, B, C, D) =
+  val ta = task(taskA)
+  val tb = task(taskB)
+  val tc = task(taskC)
   val td = taskD
   (ta.join(), tb.join(), tc.join(), td)