CODEWITHSUNDEEP
javamemory-managementjvmheap-memory
JayC667
JayC667

Reputation: 2588

JVM creating Objects on the Stack? (and more)

Are there JVMs out there, that create Objects on the stack? Or JVMs that do not interact with Java Garbage Collection via Reference Counters etc?

Assuming we have a temporary Object created in a method. And this Object's reference never gets passed/stored/accessed outside the method. It is just used internally.

When following the classic approach of allocating objects (on the stack, along with reference counters), the following steps would have to be take care of:

  1. Find a spot in the Heap that is large enough to hold the Object
  2. Allocate the space
  3. Update reference pointer
  4. Register Object with garbage collection
  5. [... object gets used, eventually discarded ...]
  6. Identify for Garbage Collection
  7. Remove from Heap
  8. Unregister from GC

So if now a VM created Objects on the stack, the steps 1,3,4,6,7,8 would not be necessary, and step 2 and its 7ish counterpart would be easy stack management.

So are there JVMs that optimize this?

Or any hybrid systems, like allocating the Object in Heap, but not touching the normal GC, and instead direclty remove the Object at the end of its scope?

Are there implementations with multiple Heaps (one GC-supervised and the other stack-supervised)?

Upvotes: 1

Views: 604

Answers (1)

GotoFinal
GotoFinal

Reputation: 3695

Kinda, there is project called valhalla that aims to provide value types to java, and it can be already download & used, but it is NOT ready for production usage (and if it will be ready, then it will be probably just merged to one of java official releases).
You can download the early access release. You can download the EA release from https://jdk.java.net/valhalla/ and page about feature itself: https://openjdk.java.net/jeps/169

Additional notes: Java does not use reference counting, GC works by looking for root objects that are definitely used, like object from currently executed methods, and then finds any other objects that are referenced from these roots, and remove all the rest.

Also JIT perform escape analysis and can remove the need of allocating an object at all, instead will just use the stack to store data that would normally be stored in that object. (note that this is NOT stack allocation, as object is not even created). And thanks to inlining it can also do that cross-methods, but you can't control it or have any guarantee that it will happen.

Upvotes: 4

Related Questions