Why is a fluent implementation slower than a non-fluent one?

Question

I wrote some test code that compares the speed of using the append() method of StringBuilder eight times sequentially as a fluent interface against invoking it separately in 8 lines.

As fluent:

StringBuilder s = new StringBuilder();
s.append(x)
.append(y)
.append(z); //etc

As non-fluent:

StringBuilder s = new StringBuilder();
s.append(x)
s.append(y)
s.append(z); //etc

Each method was invoked 10 million times. GC was called between each block. The order of doing the versions was reversed with the same result.

My testing shows that the fluent version of the code is about 10% slower (fyi, testing code was fair with matched but unpredictable appends and I gave time for JVM warm up etc).

This is a surprise, as the fluent code is one line.

Why would the non-fluent code be faster?

That seems quite unlikely... One of your previous questions apparently had a flaw and you could not consistently reproduce the results. How many times did you test this? Have you tried inverting the order of the 2 tests (testing A then B in one pass and B then A in another pass)? — assylias, Dec 31 '12 at 11:11
The return value of append, `this`, must be `pop`ped from the stack, before the `invokevirtual` method call. The JIT compiler will alleviate this somewhat. — Joop Eggen, Dec 31 '12 at 11:14
I wouldn't trust any performance testing done in a simplistic way. Take a course with Kirk Pepperdine and learn how to perform real performance tests :). Recommended reading: http://www.javaperformancetuning.comhttp://kirk.blog-city.com/ http://www.kodewerk.com/ — Peter Svensson, Dec 31 '12 at 12:47
@Bohemian 2 answers get different results - Why don't you show the testing code you used? Which JVM version and parameters did you use? Unless you do that it can only be a guessing game (unless you already know the answer in which case you should post it!). — assylias, Dec 31 '12 at 13:17

Peter Lawrey · Accepted Answer · 2012-12-31T12:14:23.417

I suspect it's a feature of some versions of Java.

If I run the following

public class Main {

    public static final int RUNS = 100000000;

    static final ThreadLocal<StringBuilder> STRING_BUILDER_THREAD_LOCAL = new ThreadLocal<StringBuilder>() {
        @Override
        protected StringBuilder initialValue() {
            return new StringBuilder();
        }
    };

    public static final StringBuilder myStringBuilder() {
        StringBuilder sb = STRING_BUILDER_THREAD_LOCAL.get();
        sb.setLength(0);
        return sb;
    }

    public static long testSeparate(String x, String y, String z) {
        long start = System.nanoTime();
        for (int i = 0; i < RUNS; i++) {
            StringBuilder s = myStringBuilder();
            s.append(x)
                    .append(y)
                    .append(z);
            dontOptimiseAway = s.toString();
        }
        long time = System.nanoTime() - start;
        return time;
    }

    public static long testChained(String x, String y, String z) {
        long start = System.nanoTime();
        for (int i = 0; i < RUNS; i++) {
            StringBuilder s = myStringBuilder();
            s.append(x);
            s.append(y);
            s.append(z);
            dontOptimiseAway = s.toString();
        }
        long time = System.nanoTime() - start;
        return time;
    }

    static String dontOptimiseAway = null;

    public static void main(String... args) {
        for (int i = 0; i < 10; i++) {
            long time1 = testSeparate("x", "y", "z");
            long time2 = testChained("x", "y", "z");
            System.out.printf("Average time separate %.1f ns, chained %.1f ns%n",
                    (double) time1 / RUNS, (double) time2 / RUNS);
        }
    }
}

with Java 7 update 4

Average time separate 49.8 ns, chained 49.0 ns
Average time separate 50.7 ns, chained 49.3 ns
Average time separate 46.9 ns, chained 46.5 ns
Average time separate 46.6 ns, chained 46.4 ns
Average time separate 46.6 ns, chained 46.6 ns
Average time separate 47.6 ns, chained 47.3 ns
Average time separate 46.7 ns, chained 47.2 ns
Average time separate 46.7 ns, chained 47.0 ns
Average time separate 46.0 ns, chained 46.6 ns
Average time separate 46.7 ns, chained 46.3 ns

with Java 7 update 10

Average time separate 50.4 ns, chained 50.0 ns
Average time separate 50.1 ns, chained 50.1 ns
Average time separate 45.9 ns, chained 46.5 ns
Average time separate 46.6 ns, chained 46.7 ns
Average time separate 46.3 ns, chained 46.4 ns
Average time separate 46.7 ns, chained 46.5 ns
Average time separate 46.2 ns, chained 46.4 ns
Average time separate 46.6 ns, chained 46.0 ns
Average time separate 46.4 ns, chained 46.2 ns
Average time separate 45.9 ns, chained 46.2 ns

It might look like there is a slight bias initially but if your run update 10 there is no obvious bias over time.

In any case, the slight bias is far from the 10% mentioned in the question. Also there is a lot of GC going on which in itself introduces noise in the results. — assylias, Dec 31 '12 at 11:56

score 3 · Answer 2 · answered Dec 31 '12 at 11:16

3

First, please repeat your benchmark with larger tests (i.e. 10000 instead of 8 calls), run the benchmark over many iterations, and run the entire thing multiple times to see if the results are consistent.

The number of source code lines is irrelevent to the speed of the result. The fluent call has a return value that needs to be handled, while the non-fluent call simply accesses a variable that is never written, ignoring the return values. This could be a possible explanation for a difference, although I don't think it should be that large.

answered Dec 31 '12 at 11:16

Jan Schejbal

4,000
19
40

Also we are talking of 10% of *fast* code. I doubt that one may optimize speed much. But nevertheless one wonders that a java SE final class does not optimize such code. – Joop Eggen Dec 31 '12 at 11:30
1

My test of 8 items appended was repeated 10 million times – Bohemian Dec 31 '12 at 12:27

score 3 · Answer 3 · answered Dec 31 '12 at 12:17

It all depends on JVM optimization and its behaviour is hard to predict. If you switch it off (-Xint) then you will see that v.1 is faster. On my PC with 1,000,000 invocations v.1 gives 1466 ms and v.2 1544 ms. With optimization 'on' I cannot see any real difference. Anyway, the bytecode for v.1 looks better (I use A.Loskutov's Bytecode Outline plugin for Eclipse)

for

s.append(x)
.append(y)
.append(z);

it is

    ALOAD 1
    ALOAD 0
    GETFIELD test/Test1.x : Ljava/lang/String;
    INVOKEVIRTUAL java/lang/StringBuilder.append(Ljava/lang/String;)Ljava/lang/StringBuilder;
    ALOAD 0
    GETFIELD test/Test1.y : Ljava/lang/String;
    INVOKEVIRTUAL java/lang/StringBuilder.append(Ljava/lang/String;)Ljava/lang/StringBuilder;
    ALOAD 0
    GETFIELD test/Test1.z : Ljava/lang/String;
    INVOKEVIRTUAL java/lang/StringBuilder.append(Ljava/lang/String;)Ljava/lang/StringBuilder;

and for

    s.append(x);
    s.append(y);
    s.append(z);

it is

    ALOAD 1
    ALOAD 0
    GETFIELD test/Test1.x : Ljava/lang/String;
    INVOKEVIRTUAL java/lang/StringBuilder.append(Ljava/lang/String;)Ljava/lang/StringBuilder;
    POP
    ALOAD 1
    ALOAD 0
    GETFIELD test/Test1.y : Ljava/lang/String;
    INVOKEVIRTUAL java/lang/StringBuilder.append(Ljava/lang/String;)Ljava/lang/StringBuilder;
    POP
    ALOAD 1
    ALOAD 0
    GETFIELD test/Test1.z : Ljava/lang/String;
    INVOKEVIRTUAL java/lang/StringBuilder.append(Ljava/lang/String;)Ljava/lang/StringBuilder;

score 2 · Answer 4 · answered Dec 31 '12 at 11:29

I tried the test below and get very close results for both methods (exact match in some runs) - all methods are compiled before the actual test:

public class Test1 {

    public static void main(String[] arg) {
        //warm up
        for (int i = 0; i < 1_000; i++) {
            method1("" + i);
        }

        for (int i = 0; i < 1_000; i++) {
            method2("" + i);
        }

        //full gc + test method1
        System.gc();
        System.out.println("method1");
        long start = System.nanoTime();
        for (int i = 0; i < 1_000; i++) {
            method1("" + i);
        }
        long end = System.nanoTime();
        System.out.println("method1: " + (end - start) / 1_000_000);

        //full gc + test method2
        System.gc();
        System.out.println("method2");
        start = System.nanoTime();
        for (int i = 0; i < 1_000; i++) {
            method2("" + i);
        }
        end = System.nanoTime();
        System.out.println("method2: " + (end - start) / 1_000_000);
    }

    public static void method1(String seed) {
        StringBuilder sb = new StringBuilder(seed);
        for (int i = 0; i < 10000; i++) {
            sb.append(seed + i)
                    .append(seed + i)
                    .append(seed + i)
                    .append(seed + i)
                    .append(seed + i)
                    .append(seed + i);
        }
        if (sb.length() == 7) {
            System.out.println("ok"); //pretending we are doing something
        }
    }

    public static void method2(String seed) {
        StringBuilder sb = new StringBuilder(seed);
        for (int i = 0; i < 10000; i++) {
            sb.append(seed + i);
            sb.append(seed + i);
            sb.append(seed + i);
            sb.append(seed + i);
            sb.append(seed + i);
            sb.append(seed + i);
        }
        if (sb.length() == 7) {
            System.out.println("ok"); //pretending we are doing something
        }
    }
}

hmm there is performance issue, more than 3t. faster "String concentrations in StringBuilder", meaning replace sb.append(seed + i); with sb.append(seed).append(i); then diff are smaller too — mKorbel, Dec 31 '12 at 11:59
I get similar results with `sb.append(seed).append(i)` (about 20% faster than with string concatenation in both cases). — assylias, Dec 31 '12 at 12:02

Why is a fluent implementation slower than a non-fluent one?

4 Answers4