smr | Scala MapReduce , redux

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

You should manually pass CSRF token when making a request. Just push the following to every request:

I believe you want the created method to be called when the component is being created. Remove the created function from inside the methods property and add it to the exported default object.

try this:

I think you'd benefit from placing your arrays into a dataframe and then merging that with your world geodataframe. So what you have would become:

From my experience performance problems with JDKs are related mostly to one of the following:

• JIT Compilation
• VM configuration (heap sizes)
• GC algorithm
• Changes in the JVM/JDK which break known good running applications
• (Oh, and I forgot to mention class loading...)

If you just use the default JVM configuration since OpenJDK11, maybe you should set some of the more prominent options to fixed values, like GC, Heap size, etc.

Maybe some graphical analyse tool could help track your issue down. Like Retrace, AppDynamics or FlightRecorder and the like. These give more overview on the overall state of heap, GC cycles, RAM, threads, CPU load and so on at a given time than log files could provide.

Do I understand correctly that your application writes about 30710 lines to the log within the first second of running (under OpenJDK11)? Why is it "only" writing about 7k lines under OpenJDK14 in the first second? This seems like a huge difference for an application that is just started on different JVMs to me... Are you sure there are not for example high amounts of Exception stacktraces dumped into the log?

The other numbers are even higher sometimes, so maybe the slowdowns are related to exception logging? Or even swapping, if RAM gets low?

Actually I am thinking, if an application does not write anything into the log, this is a sign of smooth running without problems (unless it is frozen entirely in this time). What is happening from seconds 12-22 (in the OpenJDK14 case here) is what would concern me more... the logged lines go through the roof... why?

And afterwards the logging goes down to all time low values of about 1-2k lines... what is the reason for that?? (Well, maybe it is the GC kicking in at second 22 and does a tabula rasa which resolves some things...?)

Another thing may be your statement about "single CPU" machines. Does this imply "single core" also (Idk, maybe your software is tailored on legacy hardware or something)?

And the "single CPU" VMs are running on those machines? But I assume, I am wrong about these assumptions, since almost all CPUs are multicore nowadays... but I would investigate on a multithreading issue (deadlock) problem maybe.

It's not the StringBuffer but the JSONArray.

The order of elements in an array [] is maintained like the list ["AUT","FRA","SMR","SVN","CHE","VAT"] in both examples.

Anything as a name value pair surrounded by {} can be reordered like {"code":"EUR","name":"Euro","symbol":"€"} and {"symbol":"\u20ac","code":"EUR","name":"Euro"}.

To prevent this, you can keep it as a String or create your own object and define the toString method.

Delete this part:

So I found a solution. I used the jSerialComm library from fazecast with almost the same code and it worked.