memory-allocator | Memory allocator writen in C

Try specify instead -Dbuild.pkg_config_path=... from this

Since 0.51.0, some options are specified per machine rather than globally for all machine configurations. Prefixing the option with build. just affects the build machine configuration...

build.pkg_config_path controls the paths pkg-config will search for just native: true dependencies (build machine).

PS, the version of meson and that you have native build I deduced from your previous question ;)

This is currently not supported, as you could see from the table of core options, only 3 options are settable per subproject as of now: werror and default_library (since 0.54.0) and warning_level (since 0.56.0). And below in Specifying options per subproject you can find more details e.g. about order of applying.

Also I found from discussion in issue Subproject default_options are ignored one of the main contributor says:

Right now only a couple of options are allowed on a per-project basis: default_library, werror (and one more I can't remember off the top of my head). We keep adding more over time, but other ones are ignored, yes.

Removing all meson files through rm -rf meson* inside the build directory and recompiling seems to have fixed the problem.

A memory allocator needs to maintain metadata about the size of each allocated block and where the available unallocated memory is. It is common for an allocator to maintain that metadata longside the allocated regions themselves. That is what the example allocator is doing. struct Block Represents an allocated block of memory including its associated metadata. The first three members (size, used, next) are the metadata. data corresponds to the space presented to the allocator's user (see also below).

In response to an allocation request, the allocator will choose an available block or maybe merge or split blocks to obtain a suitable one, mark it used, and return a pointer to its data member to the caller. Later, it will want to access the metadata that goes with that data pointer again, and that's what the getHeader() function achieves:

• data is expected to be a pointer to the data member of a struct Block.
• It is cast to type char * so that the pointer addition is performed in units of bytes rather than word_ts.
• sizeof(std::declval().data) - sizeof(Block), which is C++, not C, computes the (negative) offset of the beginning of a struct Block from the beginning of its data member, assuming, unsafely, that there is no trailing padding in struct Block's layout.
• The pointer addition therefore yields a char * pointing to the address of the beginning of the block, and
• casting that to Block * yields the wanted pointer.

A word about the data member: this member is declared as an array of length 1, with the expectation that the allocator user can safely overrun its bounds. This is known as the "struct hack". Although it happens to work in many implementations, it does not conform to any C or C++ standard. Its behavior therefore being undefined, you should not take this as a model to be copied.

Note also that the accompanying comment is misleading: data is not a pointer, but rather (the first word_t of) the data themselves.

It turns out After Effects has its own v8 dynamic library inside it, so when After Effects was loading our dynamic library there was a name clash between some of the functions. My solution for now will be to recompile v8 with changed namespaces to avoid the conflict.

The source code of malloc is not required to conform to the C standard in the way that normal source code is. It is part of the C implementation.

The people who work on malloc, the compiler, and other parts of the C implementation are responsible for ensuring they work together. That can include the compiler treating malloc specially and malloc using behaviors that are guaranteed to it by the C compiler but not by the C standard.

Is there a way to supplant the default std::allocator for 3rd party libs that don't provide a hook to override the default std::allocator used by STL containers?

Not in general; especially for things that you don't have source code for.

Consider (for example) a call to std::allocator::allocate. Chances are, it's marked as inline, which means that the body of the function has been embedded in the object code that you're linking. Providing your own copy of that function at link time (or in a separate dylib) will have no effect.

Providing your own global operator new is probably the best you can do.