From d2fd3d61d1cceb79c731a4be46977384c7cb7c9b Mon Sep 17 00:00:00 2001 From: Aleksandar Pokopec Date: Mon, 20 Jun 2011 13:36:24 +0000 Subject: Fixed an overflow which occurs in hashtable siz... Fixed an overflow which occurs in hashtable size computations. Fixes #4678. No review. --- .../scala/collection/mutable/FlatHashTable.scala | 2 +- .../collection/parallel/mutable/ParHashSet.scala | 4 ++- test/files/run/TestFlatMap.scala | 29 ++++++++++++++++++++++ 3 files changed, 33 insertions(+), 2 deletions(-) create mode 100644 test/files/run/TestFlatMap.scala diff --git a/src/library/scala/collection/mutable/FlatHashTable.scala b/src/library/scala/collection/mutable/FlatHashTable.scala index d74c5f3c4d..3118d6aa31 100644 --- a/src/library/scala/collection/mutable/FlatHashTable.scala +++ b/src/library/scala/collection/mutable/FlatHashTable.scala @@ -323,7 +323,7 @@ private[collection] object FlatHashTable { */ private[collection] def initialSize: Int = 16 - private[collection] def sizeForThreshold(size: Int, _loadFactor: Int) = size * loadFactorDenum / _loadFactor + private[collection] def sizeForThreshold(size: Int, _loadFactor: Int) = (size.toLong * loadFactorDenum / _loadFactor).toInt private[collection] def newThreshold(_loadFactor: Int, size: Int) = { val lf = _loadFactor diff --git a/src/library/scala/collection/parallel/mutable/ParHashSet.scala b/src/library/scala/collection/parallel/mutable/ParHashSet.scala index 0e48995cbe..3e22e3cdd8 100644 --- a/src/library/scala/collection/parallel/mutable/ParHashSet.scala +++ b/src/library/scala/collection/parallel/mutable/ParHashSet.scala @@ -178,6 +178,8 @@ with collection.mutable.FlatHashTable.HashUtils[T] { threshold = FlatHashTable.newThreshold(_loadFactor, table.length) sizeMapInit(table.length) + override def toString = "AFHT(%s)".format(table.length) + def tableLength = table.length def setSize(sz: Int) = tableSize = sz @@ -194,7 +196,7 @@ with collection.mutable.FlatHashTable.HashUtils[T] { * the table will try to add the element in such a position if possible. Collisions are resolved * using linear hashing, so the element may actually have to be added to a position * that follows the specified one. In the case that the first unoccupied position - * comes after `comesBefore`, the element is not added and the method simply returns `-1`, + * comes after `comesBefore`, the element is not added and the method simply returns -1, * indicating that it couldn't add the element in a position that comes before the * specified one. * If the element is already present in the hash table, it is not added, and this method diff --git a/test/files/run/TestFlatMap.scala b/test/files/run/TestFlatMap.scala new file mode 100644 index 0000000000..e6fb696aa2 --- /dev/null +++ b/test/files/run/TestFlatMap.scala @@ -0,0 +1,29 @@ +import scala.collection.parallel.{ ParMap => PMap } +import scala.collection.parallel.mutable.{ ParHashSet => PMHashSet, ParHashMap => PMHashMap, ParArray } +import scala.util.Random +import scala.collection.parallel.CompositeThrowable + +object Test { + + def main(args: Array[String]) { + val N = 1500 + val M = 1500 + var unmatchedLeft = new PMHashSet[Int] + var unmatchedRight = new PMHashSet[Int] + Range(0, N).foreach{ x => unmatchedLeft += x} + Range(0, M).foreach{ x => unmatchedRight += x} + + try { + val matches = unmatchedLeft.flatMap{ lind: Int => + val dists = unmatchedRight.seq.map{ rind: Int => + val dist = Random.nextInt + (rind, dist) + } + dists + } + } catch { + case c: CompositeThrowable => for (t <- c.throwables) println("\n%s\n%s".format(t, t.getStackTrace.mkString("\n"))) + } + } + +} -- cgit v1.2.3