Scala：按名称呼叫，按值性能呼叫

Question

Consider the following code:

class A(val name: String)

Compare the two wrappers of A :

class B(a: A){
  def name: String = a.name
}

and

class B1(a: A){
  val name: String = a.name
}

B and B1 have the same functionality. How is the memory efficiency and computation efficiency comparison between them? Will Scala compiler view them as the same thing?

Answer 1

First, I'll say that micro optimizations questions are usually tricky to answer for their lack of context. Additionally, this question has nothing to do with call by name or call by value, as non of your examples are call by name.

Now, let's compile your code with scalac -Xprint:typer and see what gets emitted:

class B extends scala.AnyRef {                              
  <paramaccessor> private[this] val a: A = _;               
  def <init>(a: A): B = {                                   
    B.super.<init>();                                       
    ()                                                      
  };                                                        
  def name: String = B.this.a.name                          
};                                                          

class B1 extends scala.AnyRef {                             
  <paramaccessor> private[this] val a: A = _;               
  def <init>(a: A): B1 = {                                  
    B1.super.<init>();                                      
    ()                                                      
  };                                                        
  private[this] val name: String = B1.this.a.name;          
  <stable> <accessor> def name: String = B1.this.name       
};

In class B , we hold a reference to a , and have a method name which calls the name value on A .

In class B1 , we store name locally, since it is a value of B1 directly, not a method. By definition, val declarations in have a method generated for them and that is how they're accessed.

This boils down to the fact that B1 holds an additional reference to the name string allocated by A . Is this significant in any way from a performance perspective? I don't know. It looks negligible to me under general question you've posted, but I wouldn't be to bothered with this unless you've profiled your application and found this a bottleneck.

---

Lets take this one step further, and run a simple JMH micro benchmark on this:

[info] Benchmark                        Mode  Cnt    Score     Error   Units
[info] MicroBenchClasses.testB1Access  thrpt   50    296.291 ± 20.787    ops/us
[info] MicroBenchClasses.testBAccess   thrpt   50    303.866 ± 5.435    ops/us
[info] MicroBenchClasses.testB1Access   avgt    9    0.004 ±   0.001   us/op
[info] MicroBenchClasses.testBAccess    avgt    9    0.003 ±   0.001   us/op

We see that call times are identical, since in both times we're invoking a method. One thing we can notice is that the throughput on B is higher, why is that? Lets look at the byte code:

B:

public java.lang.String name();
  Code:
       0: aload_0
       1: getfield      #20                 // Field a:Lcom/testing/SimpleTryExample$A$1;
       4: invokevirtual #22                 // Method com/testing/SimpleTryExample$A$1.name:()Ljava/lang/String;
       7: areturn

B1:

public java.lang.String name();
    Code:
       0: aload_0
       1: getfield      #19                 // Field name:Ljava/lang/String;
       4: areturn

It isn't trivial to understand why a getfield would be slower than a invokevirtual , but in the end the JIT may inline the getter call to name . This goes to show you that you should take nothing for granted, benchmark everything.

Code for test:

import java.util.concurrent.TimeUnit
import org.openjdk.jmh.annotations._

/**
  * Created by Yuval.Itzchakov on 19/10/2017.
  */
@State(Scope.Thread)
@Warmup(iterations = 3, time = 1)
@Measurement(iterations = 3)
@BenchmarkMode(Array(Mode.AverageTime, Mode.Throughput))
@OutputTimeUnit(TimeUnit.MICROSECONDS)
@Fork(3)
class MicroBenchClasses {
  class A(val name: String)
  class B(a: A){
    def name: String = a.name
  }

  class B1(a: A){
    val name: String = a.name
  }

  var b: B = _
  var b1: B1 = _
  @Setup
  def setup() = {
    val firstA = new A("yuval")
    val secondA = new A("yuval")

    b = new B(firstA)
    b1 = new B1(secondA)
  }

  @Benchmark
  def testBAccess(): String = {
    b.name
  }

  @Benchmark
  def testB1Access(): String = {
    b1.name
  }
}