palinkapika
What took me a bit to figure out is that this does not mount a single folder, but a virtual parent folder to which you can add and remove directories without changing the mount. This even works while the VM is running.
For example, mounting
share /mnt/host virtiofs rw,nofail 0 0
in the guest and then sharing ~/Downloads
in UTM will share the Downloads folder as /mnt/host/Downloads
When using the QEMU backend, VirtFS is used instead, which does not use such a parent folder and requires restarting the VM to change shares iirc.Sorry, I phrased that poorly. What I was trying to say was that the moment we introduced a 3rd candidate the performance with C2 decreased by ~5x. Whereas with Graal the performance stayed virtually the same when introducing a 3rd or 4th candidate. And it was performing well. But it did decrease at some point after adding more and more candidates and then the performance hit was much bigger.
I will reach out to my colleagues still working on this next week (long weekend ahead where I live). If we can reproduce this with a current Graal release, I'll share the benchmark – always happy to learn something new and if it is 'just' why out benchmark is broken. :)
The last time I looked into Graal (over a year ago), I ran into something I could not make sense of.
We were designing an API with methods similar to Arrays.setAll(double[], IntToDoubleFunction) which we expected to be called with large input arrays from many places in the code base.
The performance of the code generated by C2 dropped as one would expect once you were using more that two functions (lambda functions were no longer inlined and invoked for each element). For simple arithmetic operations the runtime increased by around 5x.
The performance of the code generated by Graal was competitive with C2's code for mono- and bimorphic scenarios for a much larger number of input functions. I don't recall the exact number, but I believe it was around 25. However, once we hit that threshold, performance tanked. I believe the difference was closer to 15x than than C2's 5x.
We never figured out what caused this.
Do you have an idea? Or, since this is probably outdated data, do you know what the expected behavior is nowadays? Is there maybe any documentation on this?
Last time I checked C2 inlines at most two implementations at a polymorphic call-site (in this case the line that calls your lambda). If you pass in more lambda functions, it won’t inline them and might de-optimize existing compiled code to remove previously inlined functions (there are also cases where one implementation that is heavily used gets inlined and the others will be invoked via a function call). Graal does not seem to have the same limit but when I tested it two years ago it had others averaging out to the same performance.
Thus, increasing the max inline level does not necessarily help (you can already do that in Java 8 and 11) for this particular problem. What you would want is that the compiler inlines the for each method and the local lambdas into the methods using the API (the benchmark methods in our case), i.e., you want the compiler to copy the hot loop somewhere higher up in the call stack and then optimize it. But apparently this is easier said than done.
But again, this is probably only relevant for workloads where there is very little work to do for each item.
However, when writing benchmarks, there is often no other code around to force the JIT compiler to generate such generalized code.
The following code demonstrates this. If the parameter warmup is set, I invoke the forEach methods with different inputs first (they do the same but are different methods in the Java byte code). The purpose is to force the compiler to generate generalized code:
@Param({"true", "false"})
public boolean warmup;
@Setup
public void setup() {
if (!warmup) {
Interval.oneTo(20).forEach(
(IntProcedure) i -> Interval.oneTo(1_000_000).forEach(
(IntProcedure) j -> Integer.toString(j)));
Interval.oneTo(20).forEach(
(IntProcedure) i -> Interval.oneTo(1_000_000).forEach(
(IntProcedure) j -> Integer.toString(j)));
Interval.oneTo(20).forEach(
(IntProcedure) i -> Interval.oneTo(1_000_000).forEach(
(IntProcedure) j -> Integer.toString(j)));
}
}
@Benchmark
public void coollectionsBlackhole(Blackhole blackhole) {
Interval.oneTo(20).forEach(
(IntProcedure) i -> Interval.oneTo(1_000_000).forEach(
(IntProcedure)j -> blackhole.consume(Integer.toString(j))));
}
@Benchmark
public void collectionsDeadCode() {
Interval.oneTo(20).forEach(
(IntProcedure) i -> Interval.oneTo(1_000_000).forEach(
(IntProcedure)j -> Integer.toString(j)));
}
And the for loop implementations for reference: @Benchmark
public void loopBlackhole(Blackhole blackHole) {
for (int j = 0; j < 20; j++) {
for (int i = 0; i < 1_000_000; i++) {
blackHole.consume(Integer.toString(i));
}
}
}
@Benchmark
public void loopDeadCode() {
for (int j = 0; j < 20; j++) {
for (int i = 0; i < 1_000_000; i++) {
Integer.toString(i);
}
}
}
@Benchmark
public void loopBlackholeOnly(Blackhole hole) {
for (int j = 0; j < 20; j++) {
for (int i = 0; i < 1_000_000; i++) {
hole.consume(0xCAFEBABE);
}
}
}
On my desktop machine, this gives me the following results (Java 11/Hotspot/C2): Benchmark (warmup) Mode Cnt Score Error Units
collectionsDeadCode true avgt 99 162.482 ± 1.615 ms/op
collectionsDeadCode false avgt 99 218.816 ± 4.217 ms/op
coollectionsBlackhole true avgt 99 235.122 ± 1.362 ms/op
coollectionsBlackhole false avgt 99 270.192 ± 1.627 ms/op
loopBlackhole true avgt 99 207.214 ± 1.162 ms/op
loopBlackhole false avgt 99 206.711 ± 0.932 ms/op
loopBlackholeOnly true avgt 99 74.774 ± 0.180 ms/op
loopBlackholeOnly false avgt 99 74.359 ± 0.180 ms/op
loopDeadCode true avgt 99 143.394 ± 0.900 ms/op
loopDeadCode false avgt 99 142.654 ± 0.795 ms/op
All results are for single threaded code. Now, the difference is not huge, but significant. Overall it looks like the invocation of toString(int) is not removed and accounts for most of the runtime.Just to be clear: I am not saying one should stay way from the stream APIs. As soon as the work per item is more than just a few arithmetic operations, there is a good chance the difference in runtime is negligible. But when doing numerical work (aggregations etc.), a simple loop might be the better option.
Finally, these differences are of course compiler-dependent. For example, C2 might behave differently than Graal and who knows what the future brings.