inner .par collection breaks outer ForkJoinTaskSupport in Scala - scala

Question

I want to make a parallel collection that uses a fixed number of threads.
The standard advice for this is to set tasksupport for the parallel collection to use a ForkJoinTaskSupport with a ForkJoinPool with a fixed number of threads. That works fine UNTIL the processing you are doing in your parallel collection itself uses a parallel collection. When this is the case it appears that the limit set for the ForkJoinPool goes away.
A simple test looks something like the following:
import java.util.concurrent.atomic.AtomicInteger
import java.util.concurrent.ForkJoinPool
import scala.collection.parallel.ForkJoinTaskSupport
object InnerPar {
def forkJoinPoolIsSuccess(useInnerPar:Boolean): Boolean = {
val numTasks = 100
val numThreads = 10
// every thread in the outer collection will increment
// and decrement this counter as it starts and exits
val threadCounter = new AtomicInteger(0)
// function that returns the thread count when we first
// started running and creates an inner parallel collection
def incrementAndCountThreads(idx:Int):Int = {
val otherThreadsRunning:Int = threadCounter.getAndAdd(1)
if (useInnerPar) {
(0 until 20).toSeq.par.map { elem => elem + 1 }
}
Thread.sleep(10)
threadCounter.getAndAdd(-1)
otherThreadsRunning + 1
}
// create parallel collection using a ForkJoinPool with numThreads
val parCollection = (0 until numTasks).toVector.par
parCollection.tasksupport = new ForkJoinTaskSupport(new ForkJoinPool(numThreads))
val threadCountLogList = parCollection.map { idx =>
incrementAndCountThreads(idx)
}
// the total number of threads running should not have exceeded
// numThreads at any point, similarly we hope that the number of
// simultaneously executing threads was close numThreads at some point
val respectsNumThreadsCapSuccess = threadCountLogList.max <= numThreads
respectsNumThreadsCapSuccess
}
def main(args:Array[String]):Unit = {
val testConfigs = Seq(true, false, true, false)
testConfigs.foreach { useInnerPar =>
val isSuccess = forkJoinPoolIsSuccess(useInnerPar)
println(f"useInnerPar $useInnerPar%6s, success is $isSuccess%6s")
}
}
}
And from this we get the following output, showing that more than numThreads (in the example 10) threads are running simultaneously if we create a parallel collection inside of incrementAndCountThreads().
useInnerPar true, success is false
useInnerPar false, success is true
useInnerPar true, success is false
useInnerPar false, success is true
Also note that using a ForkJoinTaskSupport in the inner collection does not fix the problem. In other words you get the same results if you use the following code for the inner collection:
if (useInnerPar) {
val innerParCollection = (0 until 20).toVector.par
innerParCollection.tasksupport = new ForkJoinTaskSupport(new ForkJoinPool(3))
innerParCollection.map { elem => elem + 1 }
}
I'm using Scala 2.12.5 and Java OpenJDK 1.8.0_161-b14 on a Linux 3.10.0 x86_64 kernel.
Am I missing something? If not is there a way to work around this?
Thanks!

Answer 1

The core issue is that in Java 8 the numThreads parameter passed to the ForkJoinPool is just a guide, not a hard limit. In Java 9 there is a maxPoolSize parameter you can set which should provide a hard limit for the number of threads in the pool and solve this problem directly. I don't know of a great way to solve this in Java 8.
See the following for more details:
https://github.com/scala/bug/issues/11036