DEoptim | Differential evoluation in R | Machine Learning library

This was a lucky shot, as @apangin comments. If you want to know what really happens, do not waste time reading this answer.

-- pic of me while answering

Although the JIT compiler may inline aggressively in some cases, it still has its own time constraints, and won't inline if that's going to take significant time to do. As a result, a method is eligible for inlining only if its bytecode size is less than 35 bytes (by default).

In your case, your methods are 81 bytes of size, hence not eligible:

I recommend you read this answer as it explains it quite clearly. In a nutshell, unrolling won't mean that the code will run faster.

For example, if, instead of a simple counter++, you had a function call (taken from the linked answer):

Native memory allocation (mmap) failed to map 31138512896 bytes - which is about 31,14G, well above your limit of 29G.

KISS -- Do what is easy for you, the programmer. Interpretive languages such as JS/Perl/PHP/etc have a lot of overhead.

I like to count the number of tokens in the source to judge performance. Shorter code also leads to fewer places for me to screw up.

Of course, there are good reasons to make judicious use of functions (methods), classes, etc.

Try this code!

override fun onViewCreated(view: View, savedInstanceState: Bundle?) { super.onViewCreated(view, savedInstanceState)

I bet it is crashing because your lib (from Geonames.org) is trying to http vs https. To workaround (bad!) put this under your manifest tag: android:usesCleartextTraffic="true"

This is all wrong too. You should be executing (.execute()) your AsyncTask in the first place. But actually you better not be using AsyncTask at all and opt for rx or coroutines.

Python interns small integers. Use integers > 255. * just adds references to the number already in the list when expanded, use unique values instead. Caches hate randomness, so go random.

Uncommon traps and deoptimization are HotSpot implementation details. You won't find them in a standard interface like JVM TI (which is designed for a generic virtual machine, not just HotSpot).

As suggested in my previous answer, one possible way to diagnose deoptimization is to add -XX:+UnlockDiagnosticVMOptions -XX:+LogCompilation options and to look for in the compilation log.

Another approach is to trace deoptimization events with async-profiler.
To do so, use -e Deoptimization::uncommon_trap_inner.
This will show you the places in Java code where deoptimization happens, and also timestamps, if using jfr output format.

Since JDK 14, deoptimization events are also reported natively by Flight Recorder (JDK-8216041). Using Event Browser in JMC, you may find all uncommon traps, including method name, bytecode index, deoptimization reason, etc.

The overhead of all the above approaches is small enough. There is usually no problem in using async-profiler in production; JFR is also fine, if the recording settings are not superfluous.

However, there is no much use in profiling deoptimizations, except for very special cases. This is absolutely normal for a typical Java application to recompile methods multiple times, as long as the JVM learns more about the application in runtime. It may sound weird, but uncommon traps is a common technique of the speculative optimization :) As you can see on the above pictures, even basic methods like HashMap.put may cause deoptimization, and this is fine.

I think it is sigar-lib that cassandra uses that is causing the problem (especially on the recent JDK8).

It is not necessary to run cassandra, so you can comment out this line from cassandra-env.ps1 in conf directory: https://github.com/apache/cassandra/blob/cassandra-3.11.7/conf/cassandra-env.ps1#L357