rxin

class LegalPerson(name: String) {
  def aaaaaaaaaa = name
}

class DoomedPerson(name: String) extends LegalPerson(name) {
  def curName = name
}

rxin

  date/time   | used  buff  cach  free|usr sys idl wai hiq siq| read  writ| recv  send
15-09 04:55:05|52.6G 56.8M  176G 11.4G|  4   2  82  12   0   0| 527M    0 |   0   198B
15-09 04:55:06|52.6G 56.8M  176G 10.9G|  3   2  80  15   0   0| 542M   64k| 581B   36k
15-09 04:55:07|52.6G 56.8M  177G 10.4G|  3   1  82  13   0   0| 535M    0 |   0     0 
15-09 04:55:08|52.6G 56.8M  177G 9.87G|  2   1  85  12   0   0| 520M    0 |   0   506B
15-09 04:55:09|52.6G 56.8M  178G 9558M|  2   1  84  12   0   0| 549M    0 | 260B  520B
15-09 04:55:10|52.6G 56.8M  179G 9009M|  3   1  82  14   0   0| 557M    0 | 104B  594B
15-09 04:55:11|52.6G 56.8M  179G 8463M|  3   2  83  13   0   0| 530M   72k| 104B  272B
15-09 04:55:12|52.6G 56.8M  180G 7940M|  3   2  81  15   0   0| 532M    0 | 200B  888B
15-09 04:55:13|52.6G 56.8M  180G 7417M|  3   2  82  12   0   0| 510M    0 |   0   198B

rxin

scala> class A { 
     |   private[this] val abc = 1
     | 
     |   def print() = println(abc)
     | }

# abc gets inlined by the compiler as a field

[[syntax trees at end of                   cleanup]] // <console>
package $line4 {

rxin

 num     #instances         #bytes  class name
----------------------------------------------
   1:          6443       80317016  [B
   2:         15102        1939472  <methodKlass>
   3:         15102        1749784  <constMethodKlass>
   4:          1029        1161976  <constantPoolKlass>
   5:          1029         959320  <instanceKlassKlass>
   6:           891         697312  <constantPoolCacheKlass>
   7:          3680         245496  [C

rxin

Every 1000 com.ning.compress.lzf.LZFOutputStream instances allocate 198976424 bytes.

Every 1000 org.xerial.snappy.SnappyOutputStream instances allocate 67660104 bytes.

rxin

I was curious about the results reported here, which reports that Scala's mutable maps are slower than Java's: http://www.infoq.com/news/2011/11/yammer-scala

In my tests, Scala's OpenHashMap equals or beats java's HashMap:

Insertion 100k elements (String keys) time in ms:

• scala HashMap: 92.75
• scala OpenHashMap: 14.03125
• java HashMap: 15.78125

rxin

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *

rxin

  def takeAsync(num: Int): FutureAction[Seq[T]] = {
    val promise = new CancellablePromise[Seq[T]]

    promise.run {
      val buf = new ArrayBuffer[T](num)
      val totalParts = self.partitions.length
      var partsScanned = 0
      while (buf.size < num && partsScanned < totalParts && !promise.cancelled) {
        // The number of partitions to try in this iteration. It is ok for this number to be

rxin

set -e
set -o pipefail

/root/spark/bin/stop-all.sh

rm -rf ~/.ivy2/local/org.spark*
rm -rf ~/.ivy2/cache/org.spark*

cd /root/spark
git checkout master

rxin

// 1001  381	384	384	383	384	407	404	409	407

object ArrayBufferBenchmark extends scala.testing.Benchmark {

  def run = {

    val len = 10 * 1000 * 1000
    val a = new scala.collection.mutable.ArrayBuffer[Int](len)