jvm | Java / Vmware samples using web services SDK | Learning library

Just do that and you will be fine (all external classes will be excluded):

In Java 11, you can find out the flags that have been passed to the JVM and the "ergonomic" ones that have been set by the JVM by adding -XX:+PrintCommandLineFlags to the JVM options.

That should tell you if the container you are using is overriding the flags you have given.

Having said that, its is (IMO) unlikely that the container is what is overriding the parameters.

It is not unusual for a JVM to use more memory that the -Xmx option says. The explanation is that that option only controls the size of the Java heap. A JVM consumes a lot of memory that is not part of the Java heap; e.g. the executable and native libraries, the native heap, metaspace, off-heap memory allocations, stack frames, mapped files, and so on. Depending on your application, this could easily exceed 300MB.

Secondly, OOMEs are not necessarily caused by running out of heap space. Check what the "reason" string says.

Finally, this could be a difference in your app's memory utilization in a containerized environment versus when you run it locally.

I don't think MutableState is designed to be used in the ViewModel layer, since it's an observable integrated with the compose runtime. You could create a MutableStateFlow instead and use collectAsState() from the view layer.

In your case the issue is probably, because of the state is captured in a coroutine invoked outside composition.

First of all, modern JVMs do not have a PermGen.

The PermGen was dropped entirely in Java 8. So there is really little point in learning about it. All versions of Java prior to Java 8 are end-of-life, and you should have migrated your code a long time ago. And if you are having problems with PermGen in a legacy application on a pre Java 8 JVM, that is another reason to port it¹.

The (Java 7 and earlier) PermGen is described by different people / sources as either:

• a separate heap, or
• a separate region of "the heap".

Both of these descriptions are true, depending on your perspective. The facts that are not open to debate are:

• The PermGen heap (or region) was sized separately from the rest of the "regular" heap. Thus there was a risk of running out of PermGen space even there was regular heap space available.
• The PermGen was garbage collected ... with one or two exceptions. The thing was that it was garbage collected infrequently, on the assumption that there would be minimal garbage in the PermGen to actually collect.

The PermGen was used for class metadata, and (prior to Java 7) for the string pool used for string objects that corresponded to compile-time string constants (e.g. literals). In Java 7, the string pool was moved to the regular heap.

^{1 - OK. Sometimes, upgrading is not possible; e.g. due to legacy hardware, or customers who refuse to do the sensible thing. But for those cases, you should avoid the kind of new code development that may introduce new PermGen problems. And you should eschew the kind of dev/test/deploy practices (e.g. hotloading) that can lead to PermGen leaks.}

You've used -Xms to force the JVM to get ~30GB at JVM startup.

It has tried, and failed. It only obtained 8GB. It needs another 22-ish GB but cannot get it. That is what the error message is telling you. This is consistent with a dump that says the heap is only 8GB.

You're asking for more than the OS will provide. You'll need to figure out what's going on in the OS in general.

Your application code is probably not involved. The JVM is still initializing its heap in accordance with your command-line options.

it looks like you are using wrong dependency. change to below line :

• executor is a jvm process when you use local[*] you run Spark locally with as many worker threads as logical cores on your machine so : 1 executor and as many worker threads as logical cores. when you configure SPARK_WORKER_INSTANCES=5 in spark-env.sh and execute these commands start-master.sh and start-slave.sh spark://local:7077 to bring up a standalone spark cluster in your local machine you have one master and 5 workers, if you want to send your application to this cluster you must configure application like SparkSession.builder().appName("app").master("spark://localhost:7077") in this case you can't specify [*] or [2] for example. but when you specify master to be local[*] a jvm process is created and master and all workers will be in that jvm process and after your application finished that jvm instance will be destroyed. local[*] and spark://localhost:7077 are two separate things.
• workers do their job using tasks and each task actually is a thread i.e. task = thread. workers have memory and they assign a memory partition to each task in order to they do their job such as reading a part of a dataset into its own memory partition or do a transformation on read data. when a task such as join needs other partitions, shuffle occurs regardless weather the job is ran in cluster or local. if you were in cluster there is a possibility that two tasks were in different machines so Network transmission will be added to other stuffs such as writing the result and then reading by another task. in local if task B needs the data in the partition of the task A, task A should write it down and then task B will read it to do its job

The Pod here can't be reached from your machine until it's exposed. You can do that by creating a service which directs your requests to the pods.

https://kubernetes.io/docs/concepts/services-networking/service/

Alternatively, If you want to test only without exposing your app, you can do port-forward from your machine to pods, like below

Maybe your version is not compatible with gradle:7.0.0-beta03, you should change it to gradle:7.0.0-beta02 in your dependencies