Multithreading in scala

Question

I was given a challenge recently in school to create a simple program in Scala the does some calculations in a matrix, the thing is I have to do these calculations using 5 threads, since I had no prior knowledge of Scala I am stuck. I searched online but I did not find how to create the exact number of threads I want. This is the code:

import scala.math

object Test{

  def main(args: Array[String]){

    val M1: Seq[Seq[Int]] = List(
      List(1, 2, 3),
      List(4, 5, 6),
      List(7, 8, 9)
    )

    var tempData : Float= 0
    var count:Int = 1
    var finalData:Int=0

    for(i<-0 to M1.length-1; j<-0 to M1(0).length-1){

      count = 1

      tempData = M1(i)(j)+ calc(i-1,j)+calc(i,j-1)+calc(i+1,j)
      finalData = math.ceil(tempData/count).toInt
      printf("%d ", finalData)
    }

    def calc(i:Int, j:Int): Int ={

      if((i<0)|| (j<0) || (i>M1.length-1))
        return 0

      else{
        count +=1
        return M1(i)(j)}
      }
    }

I tried this:

    for (a <- 0 until 1) {
      val thread = new Thread {
        override def run { 

          for(i<-0 to M1.length-1; j<-0 to M1(0).length-1){

            count = 1

            tempData = M1(i)(j)+ calc(i-1,j)+calc(i,j-1)+calc(i+1,j)
            finalData = math.ceil(tempData/count).toInt
            printf("%d ", finalData)
          }
        }
      }
      thread.start
    }

but it only executed the same thing 10 times

Answer 1

Here's the original core of the calculation.

for(i<-0 to M1.length-1; j<-0 to M1(0).length-1){

  count = 1

  tempData = M1(i)(j)+ calc(i-1,j)+calc(i,j-1)+calc(i+1,j)
  finalData = math.ceil(tempData/count).toInt
  printf("%d ", finalData)
}

Let's actually build a result array

val R = Array.ofDim[Int](M1.length, M1(0).length)

var tempData : Float= 0
var count:Int = 1
var finalData:Int=0

for(i<-0 to M1.length-1; j<-0 to M1(0).length-1){

  count = 1

  tempData = M1(i)(j)+ calc(i-1,j)+calc(i,j-1)+calc(i+1,j)
  R(i)(j) = math.ceil(tempData/count).toInt
}

Now, that mutable count modified in one function and referenced in another is a bit of a code smell. Let's remove it - change calc to return an option, assemble a list of the things to average, and flatten to keep only the Some

val R = Array.ofDim[Int](M1.length, M1(0).length)

for (i <- 0 to M1.length - 1; j <- 0 to M1(0).length - 1) {

  val tempList = List(Some(M1(i)(j)), calc(i - 1, j), calc(i, j - 1), calc(i + 1, j)).flatten
  R(i)(j) = math.ceil(tempList.sum.toDouble / tempList.length).toInt
}

def calc(i: Int, j: Int): Option[Int] = {

  if ((i < 0) || (j < 0) || (i > M1.length - 1))
    None

  else {

    Some(M1(i)(j))
  }
}

Next, a side-effecting for is a bit of a code smell too. So in the inner loop, let's produce each row and in the outer loop a list of the rows...

val R = for (i <- 0 to M1.length - 1) yield {
  for (j <- 0 to M1(0).length - 1) yield {

    val tempList = List(Some(M1(i)(j)), calc(i - 1, j), calc(i, j - 1), calc(i + 1, j)).flatten
    math.ceil(tempList.sum / tempList.length).toInt
  }
}

Now, we read the Scala API and we notice ParSeq and Seq.par so we'd like to work with map and friends. So let's un-sugar the for comprehensions

val R = (0 until M1.length).map { i =>
  (0 until M1(0).length).map { j =>

    val tempList = List(Some(M1(i)(j)), calc(i - 1, j), calc(i, j - 1), calc(i + 1, j)).flatten
    math.ceil(tempList.sum / tempList.length).toInt
  }
}

This is our MotionBlurSingleThread. To make it parallel, we simply do

val R = (0 until M1.length).par.map { i =>
  (0 until M1(0).length).par.map { j =>

    val tempList = List(Some(M1(i)(j)), calc(i - 1, j), calc(i, j - 1), calc(i + 1, j)).flatten
    math.ceil(tempList.sum / tempList.length).toInt
  }.seq
}.seq

And this is our MotionBlurMultiThread. And it is nicely functional too (no mutable values)

The limit to 5 or 10 threads isn't in the challenge on Github, but if you need to do that you can look at scala parallel collections degree of parallelism and related questions

Answer 2

I am not an expert, neither on Scala nor on concurrency. Scala approach to concurrency is through the use of actors and messaging, you can read a little about that here, Programming in Scala, chapter 30 Actors and Concurrency (the first edition is free but it is outdated). As I was telling, the edition is outdated and in the latest version of Scala (2.12) the actors library is no longer included, and they recommend to use Akka, you can read about that here.

So, I would not recommend learning about Scala, Sbt and Akka just for a challenge, but you can download an Akka quickstart here and customize the example given to your needs, it is nicely explained in the link. Each instance of the Actor has his own thread. You can read about actors and threads here, in specific, the section about state.