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

Asked 2023-09-20 20:22:33 View 602,126

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 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
  • 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 - anyone
  • Both seem to run for same amount of time on my machine, ~4 seconds. - anyone
  • 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 - anyone
  • Based on the accepted answer, you apparently didn't try running it with output redirected to a file or /dev/null. - anyone
  • @fejese, Random() is not a cryptographical rng and so doesn't use up the entropy pool. - anyone

Answers

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.

Answered   2023-09-20 20:22:33

  • 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. - anyone
  • @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. - anyone
  • @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). - anyone
  • @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? - anyone
  • @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 - anyone

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 a 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"); // <- contains 1000 "B"s
        long t2 = System.nanoTime();
        System.out.println(t2 - t1);
        System.out.println("");
    }

The time results are less than 1 millisecond every iteration except every fifth iteration, when the time result is around 225 milliseconds. 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 ")).

Answered   2023-09-20 20:22:33

  • 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!) - anyone
  • Word wrapping in Netbeans can be disabled. - anyone
  • "I used System.nanoTime()" ... generally speaking, microbenchmarking without a purpose built benchmarking harness is meaningless. - anyone

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 the first loop. But you didn't use any line breaks in the 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 to change the settings of NetBeans IDE. First of all, go to NetBeans Tools and click Options. After that, click Editor and go to the Formatting tab. Then select Anywhere in Line Wrap Option. It will take almost 6.24% less time to compile the program.

NetBeans Editor Settings

Answered   2023-09-20 20:22:33

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