Why is printing "B" dramatically slower than printing "#"?

Question

I generated two matrices of 1000 x 1000:

First Matrix: O and #.
Second Matrix: O and B.

Using the following code, the first matrix took 8.52 seconds to complete:

Random r = new Random();
for (int i = 0; i < 1000; i++) {
    for (int j = 0; j < 1000; j++) {
        if(r.nextInt(4) == 0) {
            System.out.print("O");
        } else {
            System.out.print("#");
        }
    }

   System.out.println("");
 }

With this code, the second matrix took 259.152 seconds to complete:

Random r = new Random();
for (int i = 0; i < 1000; i++) {
    for (int j = 0; j < 1000; j++) {
        if(r.nextInt(4) == 0) {
            System.out.print("O");
        } else {
            System.out.print("B"); //only line changed
        }
    }

    System.out.println("");
}

What is the reason behind the dramatically different run times?

---

As suggested in the comments, printing only System.out.print("#"); takes 7.8871 seconds, whereas System.out.print("B"); gives still printing....

As others who pointed out that it works for them normally, I tried Ideone.com for instance, and both pieces of code execute at the same speed.

Test Conditions:

• I ran this test from Netbeans 7.2, with the output into its console
• I used System.nanoTime() for measurements

Solution 1

Pure speculation is that you're using a terminal that attempts to do word-wrapping rather than character-wrapping, and treats B as a word character but # as a non-word character. So when it reaches the end of a line and searches for a place to break the line, it sees a # almost immediately and happily breaks there; whereas with the B, it has to keep searching for longer, and may have more text to wrap (which may be expensive on some terminals, e.g., outputting backspaces, then outputting spaces to overwrite the letters being wrapped).

But that's pure speculation.

Solution 2

I performed tests on Eclipse vs Netbeans 8.0.2, both with Java version 1.8; I used System.nanoTime() for measurements.

Eclipse:

I got the same time on both cases - around 1.564 seconds.

Netbeans:

• Using "#": 1.536 seconds
• Using "B": 44.164 seconds

So, it looks like Netbeans has bad performance on print to console.

After more research I realized that the problem is line-wrapping of the max buffer of Netbeans (it's not restricted to System.out.println command), demonstrated by this code:

for (int i = 0; i < 1000; i++) {
    long t1 = System.nanoTime();
    System.out.print("BBB......BBB"); \\<-contain 1000 "B"
    long t2 = System.nanoTime();
    System.out.println(t2-t1);
    System.out.println("");
}

The time results are less then 1 millisecond every iteration except every fifth iteration, when the time result is around 225 millisecond. Something like (in nanoseconds):

BBB...31744
BBB...31744
BBB...31744
BBB...31744
BBB...226365807
BBB...31744
BBB...31744
BBB...31744
BBB...31744
BBB...226365807
.
.
.

And so on..

Summary:

1. Eclipse works perfectly with "B"
2. Netbeans has a line-wrapping problem that can be solved (because the problem does not occur in eclipse)(without adding space after B ("B ")).

Solution 3

Yes the culprit is definitely word-wrapping. When I tested your two programs, NetBeans IDE 8.2 gave me the following result.

1. First Matrix: O and # = 6.03 seconds
2. Second Matrix: O and B = 50.97 seconds

Looking at your code closely you have used a line break at the end of first loop. But you didn't use any line break in second loop. So you are going to print a word with 1000 characters in the second loop. That causes a word-wrapping problem. If we use a non-word character " " after B, it takes only 5.35 seconds to compile the program. And If we use a line break in the second loop after passing 100 values or 50 values, it takes only 8.56 seconds and 7.05 seconds respectively.

Random r = new Random();
for (int i = 0; i < 1000; i++) {
    for (int j = 0; j < 1000; j++) {
        if(r.nextInt(4) == 0) {
            System.out.print("O");
        } else {
            System.out.print("B");
        }
        if(j%100==0){               //Adding a line break in second loop      
            System.out.println();
        }                    
    }
    System.out.println("");                
}

Another advice is that to change settings of NetBeans IDE. First of all, go to NetBeans Tools and click Options. After that click Editor and go to Formatting tab. Then select Anywhere in Line Wrap Option. It will take almost 6.24% less time to compile the program.

Comments

[fejese]

Try changing rand.nextInt(4) == 0 to i < 250 to eliminate the effect of the random generator. You might run out of entropy that slows down the random generation

[Sotirios Delimanolis]

Both seem to run for same amount of time on my machine, ~4 seconds.

[Justin]

@fejese Then branch prediction would kick in. Something like changing rand.nextInt(4)==0 to i%4==0 would be better (in terms of avoiding branch prediction speeding up the process)

[Kakarot]

if you are suggesting that printing B takes more time than printing #....why dont you try to print all B & all # rather than relying on random variable r

[MarsAtomic]

Across three trials of each ('B' vs '#') I'm getting between 36 and 38 seconds (rounded down). I added startTime and endTime fields that grab System.currentTimeMillis before and after the loop for my timing. I'm going to suggest that there's some problem local to you (runtime engine, processor, black helicopters).

[Barmar]

Based on the accepted answer, you apparently didn't try running it with output redirected to a file or /dev/null.

[Divide]

@fejese, Random() is not a cryptographical rng and so doesn't use up the entropy pool.

[Palec]

matrix, @FrancescoMenzani? IMO it makes no sense here; is makes the question not a bit easier to find, does not describe its scope better, just adds noise.

[spongebob]

@Palec I couldn't find any print tag specific to System.out, but I think system.out itself will represent that part of the question quite good.

[Nishit]

I tried running the same code on my system. In each of the 20 trials, printing "#" code was 3-5 times SLOWER than printing "B".

[Bob Kerns]

Brilliant deduction. But we should generalize from this lesson, and always measure performance with output either eliminated, directed to /dev/null (NUL on Windows) or at least to a file. Displaying on any sort of Console is generally very expensive IO, and always distorts timings -- even if not as dramatically confusingly as this.

[Chris]

@BobKerns: Surely that would still have generated an appropriate question though. The problem remains that printing Bs takes longer and not printing them isn't really a solution so much as a trick to help debug the problem.

[Mr Lister]

Is this still speculation? I mean, does System.out.print actually do word wrapping? Do we have documentation somewhere? Can you switch this feature on and off?

[Silly Freak]

@MrLister this is not an issue with System.out, but with its consumer, in this case NetBeans' console view. Whether you can turn it off, check in Netbeans' settings.

[T.J. Crowder]

@MrLister: System.out.println doesn't do wordwrapping; the thing it was outputting to was doing word-wrapping (and blocking, so System.out.println had to wait).

[Bob Kerns]

@Chris -- actually, I'll argue that not printing them IS the solution, to the problem of getting accurate timings of the algorithm. Each time you print to a Console (of any sort), you're invoking all manner of external processing not related to what you're testing the performance of. That's a bug in your measurement procedure, pure and simple. On the other hand, if you view the problem not as measurement, but understanding the discrepancy, then yes, not printing is a debugging trick. It comes down to, which problem are you trying to solve?

[UpAndAdam]

@BobKerns Thanks for injecting some sanity into this thread! So many people don't seem to understand this. You need to be careful that you are only measuring the thing you are trying to measure

[Koray Tugay]

@SillyFreak Can you please tell me what is meant by "word wrapping must be done in case of B" ?

[silph]

can you elaborate on your research strategies and then what finally led you to find out that line-wrapping was the culprit? (i'm curious about your detective skills, that is!)

[matbrgz]

Word wrapping in Netbeans can be disabled.

[Tobias]

The longer i am around, the less attractive becomes Netbeans.

[eis]

"It will take almost 6.24% less time to compile the program." surely you refer to executing, not compiling...

[scottb]

"I used System.nanoTime()" ... generally speaking, microbenchmarking without a purpose built benchmarking harness is meaningless.