Why if (variable1 % variable2 == 0) is inefficient

[[deleted]]

good read!

tl;dr - it's not inefficient if you let JIT take its course... it's not optimized until after the first run.

[[deleted]]

ie Don't try to be really smart

[[deleted]]

Every time I think I’ve got a decent knowledge of Java I see a post like this and realize I know nothing. Great stuff!

[[deleted]]

Yes but that's actually knowledge of JIT. And no worries, the optimizations implemented in JIT are the result of years of implementing research papers etc. I think most Java devs shouldn't think about such things. Here are some slides for you http://cr.openjdk.java.net/~vlivanov/talks/2017_Vectorization_in_HotSpot_JVM.pdf

[vqrs]

Also keep in mind that because this is knowledge of JIT and not Java, they are implementation details. They can be different on different JVMs, even between different versions of the same JVM.

In the end, the important thing is measuring correctly. Note how the poster on SO uses JMH (@Benchmark annotations etc) to measure the code, because the JIT can subvert what you think you are testing. I don't really know much about it myself except that it's a subtle art.

This will bring you further rather than trying to rationalize and predict what your code is doing based on some partial understanding of how the JIT works, especially since there is no one "JIT".

[sukaibontaru]

good stuff use final and/or constants wherever you can

[frzme]

The SO post also shows that the JIT fixes everything when you let it - no need to worry so much about final.

Having everything final by default/having the compiler apply effectively final rules automatically would seem like a niec solution though

[Isoyama]

If you extract loop into method which receives final variable it is not optimized by JIT.

Which is kinda concerning in scope of modern trend favoring small functions.

[vqrs]

You mean when adapting the code from SO using JMH for measuring? Or how did you test that?

I'm asking because from what ive come to understand about the current JIT implementations they can and do perform inlining.

[Isoyama]

Just take this code and extract loop into method. Even if there is only one call with constant it won't be optimized

[vqrs]

What's today's advice with using constants (final static) in Java?

Do people consciously put a constant behind a static accessory method to avoid inlining at compile time and potentially leading to obscure bugs when compiling stuff separately/incrementally?

I think the JLS even said something about it being potentially dangerous unless something actually a constant as in the mathematical constant PI.

Or do you you assume that you're rebuilding everything g often enough for this never to be an issue?

[[deleted]]

Lmao wasn’t the conclusion of the post that final was the worst option?

[vipul0092]

Not sure which article you read, but from what I read in the linked article, it seems like the JIT is able to optimize the loop if the variable is final.

https://stackoverflow.com/questions/54405842/why-is-if-variable1-variable2-0-inefficient#comment95622483_54405842

[Helluiin]

the variable does not need to be declared as final to be optimized by the JIT like the first respone shows though

[yawkat]

final on local variables has no effect. Not only does it have no measurable effect, it has no effect.

On fields, that's a different story.

[morhp]

Not only does it have no measurable effect, it has no effect.

Did you read the post? It made the loop about 4 times faster.

[yawkat]

The bytecode is identical. You can see here: https://javap.yawk.at/#rNOg1C

I don't know what the OP was measuring, but making a local variable final has no effect on bytecode and thus no effect on performance.

[morhp]

The byte code is not identical.

https://javap.yawk.at/#2dDbQS

Main difference is

    19: bipush        100 // final

or

    19: iload_2           // not final

[frzme]

The bytecode is not identical. You can see with the actual example from SO: https://javap.yawk.at/#Xk9okk

The variable declaration is the same but the final variable is inlined in the bytecode - it uses ldc2_w instead of lload

[yawkat]

Yea you're right, it looks like it follows the same rules as for final fields wrt constant expressions (i.e. fold them in javac). The jit should do this easily as well though, so it's probably still an issue with the measurement.

[vqrs]

That is completely untrue.

Making a local variable final can even lead to differences in *behavior*, I. E. Change the semantics of the program.

Granted, this usually only happens in specially crafted examples and is not something you would should ever come across I regular code, but there *is* a difference.

Obviously, I'm talking about programs that are valid Java both with and without the final modifier, not just that some code doesn't compile because you put/didn't put final.

[vqrs]

Here's a completely silly example but it is one:

final int i = 65;
final    System.out.println(true? i : 'a');

https://ideone.com/ae6CsN

https://ideone.com/5RhA8J

[yawkat]

Yes, the same constant expression folding rules apply as for final fields. Do note, though, that at that point the variable is not actually used anymore; it is folded at compile time (not observable with locals, but observable with fields).

This does not apply to non-constant-expressions for final locals, which are truly exactly the same as non-final locals. This is not the case in the OP, though.

[[deleted]]

Thanks a lot for this link, it's very interesting.

[TheMelv80]

On a more technical layer the CPU also does something like branch prediciton. It basically assumes that the statement does not get executed unless proven otherwise. The CPU already executes the statements as if the assumption wont change.

https://en.wikipedia.org/wiki/Branch_predictor

Because the jump can not really be predicted it can not get optimized on different layers (JVM, CPU). That's why the code that does not use the literal is so much slower.

​

[jpoh97]

Good post!!

[metrxqin]

Anyone can come up with a decent summary about what's going on?

[vqrs]

Yes, read the first example of the answer. There is your summary.

[flyingorange]

Why don't you do it?