talloc | Hierarchical memory allocator

Solved in the library source: https://gitlab.com/painlessMesh/painlessMesh/issues/253

Author comment:

Thanks for reporting. This should be fixed in the latest version (1.3.1). Let me know if you still have problems

This should be a bug in the implementation of map in libstdc++. Its map implementation assumes that a allocator's pointer type (i.e. typename std::allocator_traits::pointer) is actually a pointer.

This is not required by the standard, and allocator provided by boost::interprocess indeed uses an offset_ptr as the pointer type, which is an object instead of a real pointer.

The culprit code in bits/stl_tree.h:

I found this very interesting article about how Java 9 planned to garbage collect differently.

More specifically, Java 9 plans to use the G1 Garbage collector which divides memories into fixed sizes. What your code may be doing is triggering the memory to split into two fixed size blocks for Java 9. The reason it would do this is that it would save the other half of memory for moving everything and 'compacting' the memory still in use. However, because you just keep using memory, it would just break immediately when ~1/2 the memory was used. I'm not sure how rigorous of an CS you may have, but at my school we studied simple garbage techniques, and one such simple one that G1GC reminds me of is the stop-and-copy technique which switches the allocated memory between halves of memory while it 'compacts' the memory as it does this.

With Java 8, the Parallel Collector is used, which does is different from the G1GC as all it cares about is throughput. Thus, closer to 100% of the true heap will be used, at the cost of longer GC times. Of course, this is a tradeoff between the two versions, but you can get around this be explicitly specifying the kind of GC to use. For example, if on Java 9 you use the option:

In the POSIX specification there's a function, mprotect. mprotect allows the permissions (read/write/execute) on individual pages of memory to be changed.

The problem with using mprotect to mark up parts of the heap as read-only, is the fact that the highest granularity is a single page, which is usually 4k (dependent on OS/architecture). Padding all heap allocated structures to a multiple of 4k would cause massive memory bloat, boo.

So in order to use mprotect for case 1) we need to get it all the data we want to protect in one contiguous area of memory.

Talloc can help out here. talloc pools are a type of slab allocation that can give large performance gains when used correctly, and (if of sufficient size), allow all allocations within the pool to be done in a single contiguous memory area.

Great! Problem solved, allocate a talloc memory pool, do all the instantiation and parsing work, use mprotect to mark the pool as read-only, done! Unfortunately, it's not quite that simple...

There are three additional issues to solve:

1. mprotect needs memory to be a multiple of the page size.
2. mprotect needs the start address to be page aligned.
3. We don't know how much memory to allocate for the pool.

Problem 1 is simple enough, we just need to round up to a multiple of the page size (which can be conveniently retrieved with getpagesize).

An aside about obfuscated names

Minecraft has 3 levels of naming:

1. Notch Names - these are the names of methods and fields that Minecraft uses when distributed. Often things like a.aa and b.cf2. This is the fully obfuscated state
2. SRG Names - these are the names given to methods and fields by the runtime deobfuscation process that Forge performs when you run the game. Compiled mods use these names, as they are consistent across minor versions
3. MCP Names - these are the human readable names you see inside Eclipse. These names are supplied by hand when someone figures out what a field or method does via the MCP Bot on IRC. Installing the Forge development environment with the MDK grabs the "current" mappings when you run gradlew setup

In order to run a mod in the development environment you need to deobfuscate it first, changing SRG names into MCP names, so that it can run in the development environment.

There are a couple ways of doing this:

1. Acquire a "sources" jar from the mod's author (subject to the whims of the author; may or may not be public or open source, have an API, etc. etc.)
2. Use Code Chicken Core to perform a runtime deobf in Eclipse (may or may not work; note: you want the sources jar)
3. Using a tool like BON2 (never used it, should work)
4. use Gradle to deobfuscate the mod (should always work)

The problem with option 4 here, is that while I know it's possible I can't (and haven't been able to for some time) find the necessary instructions. The things I can find now, posted by people who would know how to do 4 are suggesting doing 3.

I think the use of template class with static function instead of set of overloaded possibly template functions would do the trick:

VariantHelperAddHelper.h

Freeing doesn't guarantee that pointers pointing to the allocated block will be set to NULL. If you actually try doing

You are absolutely right. The function you have is missing a return call after the else statement which would definitely give you confusion. Try using the following function:

The problem is in your Variables class