diff options
author | Paul Phillips <paulp@improving.org> | 2011-03-11 12:13:58 +0000 |
---|---|---|
committer | Paul Phillips <paulp@improving.org> | 2011-03-11 12:13:58 +0000 |
commit | be49752855a1a6997d4112eeff351e1c119a8a93 (patch) | |
tree | ee2cef3642b675420d47ff30bda9ddb2b74f1c30 /test/files/run/bug4279.scala | |
parent | 67c461b2d9c19d51e40e1f3ff23455cead1413b5 (diff) | |
download | scala-be49752855a1a6997d4112eeff351e1c119a8a93.tar.gz scala-be49752855a1a6997d4112eeff351e1c119a8a93.tar.bz2 scala-be49752855a1a6997d4112eeff351e1c119a8a93.zip |
A patch for views. Most relevant change:
Almost all view classes now list parents like
trait Appended[B >: A] extends super.Appended[B] with Transformed[B]
instead of the former
trait Appended[B >: A] extends Transformed[B] with super.Appended[B]
because as it was, the implementation of foreach in
TraversableViewLike#Transformed was repeatedly trumping overrides found
in e.g. IterableLike. This change was not without its own consequences,
and much of the rest of the patch is dealing with that. A more general
issue is clearly revealed here: there is no straightforward way to deal
with trait composition and overrides when some methods should prefer B
over A and some the reverse. (It's more like A through Z in this case.)
That closes #4279, with some views being five orders of magnitude slower
than necessary. There is a test that confirms they'll stay performance
neighbors.
In the view classes (Zipped, Mapped, etc.) I attended to them with
comb and brush until they were reasonably consistent. I only use
"override" where necessary and throw in some "final" in the interests
of trying to anchor the composition outcome. I also switched the
newSliced, newZipped, etc. methods to use early init syntax since a
number have abstract vals and I found at least one bug originating with
uninitialized access.
There was a piece of a parallel collections scalacheck test failing,
which
I disabled out of expedience - am emailing prokopec.
There is plenty of work left to do but paulp must get back to other 2.9
issues. This is the Zurich->SF airplane patch. No review.
Diffstat (limited to 'test/files/run/bug4279.scala')
-rw-r--r-- | test/files/run/bug4279.scala | 38 |
1 files changed, 38 insertions, 0 deletions
diff --git a/test/files/run/bug4279.scala b/test/files/run/bug4279.scala new file mode 100644 index 0000000000..3ca74dbbf3 --- /dev/null +++ b/test/files/run/bug4279.scala @@ -0,0 +1,38 @@ +import scala.tools.partest._ + +// Attempting to verify slice isn't 100,000x slower +// with views than non-views. +class Runner(num: Int, reps: Int) extends TestUtil { + var dummy = 0 + val range = Array.range(0, num) + + def iteratorSlice = { + def it = range.iterator.slice(num - 2, num) + for (i <- 1 to reps) + it foreach (dummy = _) + } + def viewSlice = { + val view = range.view.slice(num - 2, num) + for (i <- 1 to reps) + view foreach (dummy = _) + } + def straightSlice = { + val xs = range.slice(num - 2, num) + for (i <- 1 to reps) + xs foreach (dummy = _) + } + def run(multiple: Double) = { + verifySpeed(straightSlice, iteratorSlice, multiple) + verifySpeed(straightSlice, viewSlice, multiple) + } +} + +object Test { + def main(args: Array[String]): Unit = { + // warmup + { val r = new Runner(1000000, 10) ; r.straightSlice ; r.iteratorSlice ; r.viewSlice } + + new Runner(10000000, 10) run 10 + new Runner(10000000, 50) run 10 + } +} |