Merge pull request scala#59 from axel22/gh-pages

heathermiller · heathermiller · commit e264d4cd3287 · 2012-03-16T08:48:05.000-07:00
Rename Ctrie to ConcurrentTrieMap
diff --git a/overviews/parallel-collections/concrete-parallel-collections.md b/overviews/parallel-collections/concrete-parallel-collections.md
@@ -82,10 +82,10 @@ Parallel hash tries can be converted back and forth to sequential hash tries by
 
 ## Parallel Ctries
 
-A [mutable.Ctrie](http://www.scala-lang.org/api/{{ site.scala-version }}/scala/collection/mutable/Ctrie.html) is a concurrent thread-safe map, whereas a [mutable.ParCtrie](http://www.scala-lang.org/api/{{ site.scala-version }}/scala/collection/parallel/mutable/ParCtrie.html) is its parallel counterpart. While most concurrent data structures do not guarantee consistent traversal if the the data structure is modified during traversal, Ctries guarantee that updates are only visible in the next iteration. This means that you can mutate the concurrent trie while traversing it, like in the following example which outputs square roots of number from 1 to 99:
+A [mutable.ConcurrentTrieMap](http://www.scala-lang.org/api/{{ site.scala-version }}/scala/collection/mutable/ConcurrentTrieMap.html) is a concurrent thread-safe map, whereas a [mutable.ParConcurrentTrieMap](http://www.scala-lang.org/api/{{ site.scala-version }}/scala/collection/parallel/mutable/ParConcurrentTrieMap.html) is its parallel counterpart. While most concurrent data structures do not guarantee consistent traversal if the the data structure is modified during traversal, Ctries guarantee that updates are only visible in the next iteration. This means that you can mutate the concurrent trie while traversing it, like in the following example which outputs square roots of number from 1 to 99:
 
-    scala> val numbers = scala.collection.parallel.mutable.ParCtrie((1 until 100) zip (1 until 100): _*) map { case (k, v) => (k.toDouble, v.toDouble) }
-    numbers: scala.collection.parallel.mutable.ParCtrie[Double,Double] = ParCtrie(0.0 -> 0.0, 42.0 -> 42.0, 70.0 -> 70.0, 2.0 -> 2.0,...
+    scala> val numbers = scala.collection.parallel.mutable.ParConcurrentTrieMap((1 until 100) zip (1 until 100): _*) map { case (k, v) => (k.toDouble, v.toDouble) }
+    numbers: scala.collection.parallel.mutable.ParConcurrentTrieMap[Double,Double] = ParCtrie(0.0 -> 0.0, 42.0 -> 42.0, 70.0 -> 70.0, 2.0 -> 2.0,...
     scala> while (numbers.nonEmpty) {
          |   numbers foreach { case (num, sqrt) =>
 		 |     val nsqrt = 0.5 * (sqrt + num / sqrt)
diff --git a/overviews/parallel-collections/ctries.md b/overviews/parallel-collections/ctries.md
@@ -31,7 +31,7 @@ are removed from the map.
 	
 	// prepare the list
     val entries = (1 until length) map { num => Entry(num.toDouble) }
-    val results = ParCtrie()
+    val results = ParConcurrentTrieMap()
     for (e <- entries) results += ((e.num, e))
     
 	// compute square roots
@@ -66,8 +66,8 @@ until either it finds some path to the target or there are no more nodes to expa
     
     // open list - the nodefront
     // closed list - nodes already processed
-    val open = ParCtrie[Node, Parent]()
-    val closed = ParCtrie[Node, Parent]()
+    val open = ParConcurrentTrieMap[Node, Parent]()
+    val closed = ParConcurrentTrieMap[Node, Parent]()
     
     // add a couple of starting positions
     open((0, 0)) = null
