plumbr | Mutable dynamic data structures for R | Runtime Evironment library

In order to use plumber inside a docker container you will have to:

1. Make a Dockerfile with all the dependencies

2. Link inside docker-compose.yml

Make the Dockerfile

In this example you make an image with an r-script which route is src/myscript.R

All right. I got this and learned a lot in the process.

Under the following assumptions ...

• No logging options are explicitly configured.
• The only log related JARs in the classpath are the jboss logging ones (i.e. no slf4j, log4j, etc.).

... Hibernate will automatically select JDK logging via JBoss Logging, and the java.util.logging facilities may be used to control the log level. Therefore, setting the log level of all JDK logs to SEVERE, at the root logger level (doesn't matter if you do it before or after Hibernate initializes, see below) successfully stops the SHOW WARNING commands:

Concurrent Mark Sweep has 4 main phases.

• Initial mark
• Concurrent mark / Concurrent preclean
• Final remark
• Sweep

Additional specific of Concurrent Mark Sweep - all object in young space are treated as GC roots.

Main reason concurrent mark is concurrent is because it take significant time to traverse object graph in old space. Though on subsequent marks are much faster because most object are already marked and do not need to be revisited.

Still concurrent operation cannot guaranty consistent marking, because thread continue to change object graph. Stop the World is required to catch up.

"Final remark" is a stop the world phase involving full marking (root scanning + recursive traversal), but due to most object are already marked by concurrent mark/preclean recursive traversal phase is typically quick.

You find more details in my Understanding GC pauses in JVM, HotSpot's CMS collector article.

You can pass in launch instructions (user data) when a new EC2 instance is launched. Assuming you're running a Linux AMI:

So something like this:

You don't name your OS, though it's fairly obvious it's a *NIX-type OS.

The memory that ps shows is real, allocated memory. It will include all "native", heap, and mmaped memory that has been allocated to your process. If your process is very young (i.e. hasn't been running very long), then it will not have used very much of its heap, yet.

Many OSs, most notably Linux, will allow malloc to return success even if physical memory is not actually allocated. Since the JVM allocates your -Xms setting immediately upon startup, you'd likely expect that your process's memory size would be at least 3072MiB, but if that memory isn't actually being used, then ps will likely show a smaller size than you expect.

If you are indeed using Linux, check out https://serverfault.com/questions/48582 and do a bit of web searching for exactly how the Linux kernel allocates memory. Also, if you are using Linux, consider adding the linux tag to your question.

If you are not using Linux, you may want to read about how your OS allocates memory. If your OS uses an "overcommit" strategy, then it will behave as described above.

References from Young generation to Old must be found, but how at this point Young Generation is scanned? Is it full scan like in minor GC?

Yes. Whole young space is scanned.

No. It is not like minor GC. Young (minor) GC does not scan whole young space. Young collection is traversing object graph visiting (and coping) only live objects.

As you may guess, from may description initial scan could potentially a big contributor to GC pause. CMS usually does initial mark "soon after" young GC completed in assumption that young space is small at that moment.

Same concern is valid for remark phase of CMS, whihc also involves young space full scan. You can find more details about CMS mechanics in my article.

The java 8, null-safe way would be to use the Optional class.

It is not possible to have a single object that requires such an amount of memory. But not because of memory limits, but for a more practical reason - the JVM limits the number of fields per class, see here:

The number of fields that may be declared by a class or interface is limited to 65535 by the size of the fields_count item of the ClassFile structure (§4.1).

You can't have so many fields in your class that you would blow up memory. I am pretty sure: if you start a JVM with a heap so small that a single object containing those 65535 long fields would not fit in ... the JVM would most likely not even start.

In that sense, we could rephrase your question to something like: what happens when I create an array that is too large to fit into the heap space provided to the JVM? And then you are basically back to this question ... which says: OutOfMemoryError.

In the linked explanation the "sweep" step is actually not described.

Roughly speeking:

1. mark: find the "root" object(s), and perform a traversal of the object graph, marking all objects, which are touched during the traversal.
2. sweep: go through your heap from A to Z and delete all objects which aren't marked (sweep through your heap; or sweep the non-marked objects from your heap).

If you don't do sweep the memory is not freed, just marked as free (think of the "Trash bin" in your OS -> mark = put into trash bin; sweep = delete from trash bin).