libphobos/src/std/experimental/allocator/mallocator.d - gcc - Git at Google

 // Written in the D programming language.
 /**
 The C heap allocator.

 Source: $(PHOBOSSRC std/experimental/allocator/mallocator.d)
 */
 module std.experimental.allocator.mallocator;
 import std.experimental.allocator.common;

 /**
    The C heap allocator.
  */
 struct Mallocator
 {
     version (StdUnittest) @system unittest { testAllocator!(() => Mallocator.instance); }

     /**
     The alignment is a static constant equal to `platformAlignment`, which
     ensures proper alignment for any D data type.
     */
     enum uint alignment = platformAlignment;

     /**
     Standard allocator methods per the semantics defined above. The
     `deallocate` and `reallocate` methods are `@system` because they
     may move memory around, leaving dangling pointers in user code. Somewhat
     paradoxically, `malloc` is `@safe` but that's only useful to safe
     programs that can afford to leak memory allocated.
     */
     @trusted @nogc nothrow pure
     void[] allocate(size_t bytes) shared const
     {
         import core.memory : pureMalloc;
         if (!bytes) return null;
         auto p = pureMalloc(bytes);
         return p ? p[0 .. bytes] : null;
     }

     /// Ditto
     @system @nogc nothrow pure
     bool deallocate(void[] b) shared const
     {
         import core.memory : pureFree;
         pureFree(b.ptr);
         return true;
     }

     /// Ditto
     @system @nogc nothrow pure
     bool reallocate(ref void[] b, size_t s) shared const
     {
         import core.memory : pureRealloc;
         if (!s)
         {
             // fuzzy area in the C standard, see https://stackoverflow.com/questions/6502077/malloc-and-realloc-functions
             // so just deallocate and nullify the pointer
             deallocate(b);
             b = null;
             return true;
         }
         auto p = cast(ubyte*) pureRealloc(b.ptr, s);
         if (!p) return false;
         b = p[0 .. s];
         return true;
     }

     @trusted @nogc nothrow pure
     package void[] allocateZeroed()(size_t bytes) shared const
     {
         import core.memory : pureCalloc;
         if (!bytes) return null;
         auto p = pureCalloc(1, bytes);
         return p ? p[0 .. bytes] : null;
     }

     /**
     Returns the global instance of this allocator type. The C heap allocator is
     thread-safe, therefore all of its methods and `it` itself are
     `shared`.
     */
     static shared Mallocator instance;
 }

 ///
 @nogc @system nothrow unittest
 {
     auto buffer = Mallocator.instance.allocate(1024 * 1024 * 4);
     scope(exit) Mallocator.instance.deallocate(buffer);
     //...
 }

 @nogc @system nothrow pure unittest
 {
     @nogc nothrow pure
     static void test(A)()
     {
         int* p = null;
         p = cast(int*) A.instance.allocate(int.sizeof);
         scope(exit) () nothrow @nogc { A.instance.deallocate(p[0 .. int.sizeof]); }();
         *p = 42;
         assert(*p == 42);
     }
     test!Mallocator();
 }

 @nogc @system nothrow pure unittest
 {
     static void test(A)()
     {
         import std.experimental.allocator : make;
         Object p = null;
         p = A.instance.make!Object();
         assert(p !is null);
     }

     test!Mallocator();
 }

 version (CRuntime_Microsoft)
 {
     @nogc nothrow pure private extern(C) void* _aligned_malloc(size_t, size_t);
     @nogc nothrow pure private extern(C) void _aligned_free(void *memblock);
     @nogc nothrow pure private extern(C) void* _aligned_realloc(void *, size_t, size_t);
 }

 /**
    Aligned allocator using OS-specific primitives, under a uniform API.
  */
 struct AlignedMallocator
 {
     version (StdUnittest) @system unittest { testAllocator!(() => typeof(this).instance); }

     /**
     The default alignment is `platformAlignment`.
     */
     enum uint alignment = platformAlignment;

     /**
     Forwards to $(D alignedAllocate(bytes, platformAlignment)).
     */
     @trusted @nogc nothrow pure
     void[] allocate(size_t bytes) shared
     {
         if (!bytes) return null;
         return alignedAllocate(bytes, alignment);
     }

     /**
     Uses $(HTTP man7.org/linux/man-pages/man3/posix_memalign.3.html,
     `posix_memalign`) on Posix and
     $(HTTP msdn.microsoft.com/en-us/library/8z34s9c6(v=vs.80).aspx,
     `__aligned_malloc`) on Windows.
     */
     version (Posix)
     @trusted @nogc nothrow pure
     void[] alignedAllocate(size_t bytes, uint a) shared
     {
         import core.stdc.errno : ENOMEM, EINVAL;
         import core.sys.posix.stdlib : posix_memalign;
         assert(a.isGoodDynamicAlignment);
         void* result;
         auto code = posix_memalign(&result, a, bytes);

 version (OSX)
 version (LDC_AddressSanitizer)
 {
         // The return value with AddressSanitizer may be -1 instead of ENOMEM
         // or EINVAL. See https://bugs.llvm.org/show_bug.cgi?id=36510
         if (code == -1)
             return null;
 }
         if (code == ENOMEM)
             return null;

         else if (code == EINVAL)
         {
             assert(0, "AlignedMallocator.alignment is not a power of two "
                 ~"multiple of (void*).sizeof, according to posix_memalign!");
         }
         else if (code != 0)
             assert(0, "posix_memalign returned an unknown code!");

         else
             return result[0 .. bytes];
     }
     else version (Windows)
     @trusted @nogc nothrow pure
     void[] alignedAllocate(size_t bytes, uint a) shared
     {
         auto result = _aligned_malloc(bytes, a);
         return result ? result[0 .. bytes] : null;
     }
     else static assert(0);

     /**
     Calls `free(b.ptr)` on Posix and
     $(HTTP msdn.microsoft.com/en-US/library/17b5h8td(v=vs.80).aspx,
     `__aligned_free(b.ptr)`) on Windows.
     */
     version (Posix)
     @system @nogc nothrow pure
     bool deallocate(void[] b) shared
     {
         import core.memory : pureFree;
         pureFree(b.ptr);
         return true;
     }
     else version (Windows)
     @system @nogc nothrow pure
     bool deallocate(void[] b) shared
     {
         _aligned_free(b.ptr);
         return true;
     }
     else static assert(0);

     /**
     Forwards to $(D alignedReallocate(b, newSize, platformAlignment)).
     Should be used with blocks obtained with `allocate` otherwise the custom
     alignment passed with `alignedAllocate` can be lost.
     */
     @system @nogc nothrow pure
     bool reallocate(ref void[] b, size_t newSize) shared
     {
         return alignedReallocate(b, newSize, alignment);
     }

     /**
     On Posix there is no `realloc` for aligned memory, so `alignedReallocate` emulates
     the needed behavior by using `alignedAllocate` to get a new block. The existing
     block is copied to the new block and then freed.
     On Windows, calls $(HTTPS msdn.microsoft.com/en-us/library/y69db7sx.aspx,
     $(D __aligned_realloc(b.ptr, newSize, a))).
     */
     version (Windows)
     @system @nogc nothrow pure
     bool alignedReallocate(ref void[] b, size_t s, uint a) shared
     {
         if (!s)
         {
             deallocate(b);
             b = null;
             return true;
         }
         auto p = cast(ubyte*) _aligned_realloc(b.ptr, s, a);
         if (!p) return false;
         b = p[0 .. s];
         return true;
     }

     /// ditto
     version (Posix)
     @system @nogc nothrow pure
     bool alignedReallocate(ref void[] b, size_t s, uint a) shared
     {
         if (!s)
         {
             deallocate(b);
             b = null;
             return true;
         }
         auto p = alignedAllocate(s, a);
         if (!p.ptr)
         {
             return false;
         }
         import std.algorithm.comparison : min;
         const upTo = min(s, b.length);
         p[0 .. upTo] = b[0 .. upTo];
         deallocate(b);
         b = p;
         return true;
     }

     /**
     Returns the global instance of this allocator type. The C heap allocator is
     thread-safe, therefore all of its methods and `instance` itself are
     `shared`.
     */
     static shared AlignedMallocator instance;
 }

 ///
 pure @nogc @system nothrow unittest
 {
     auto buffer = AlignedMallocator.instance.alignedAllocate(1024 * 1024 * 4,
         128);
     scope(exit) AlignedMallocator.instance.deallocate(buffer);
     //...
 }

 version (Posix)
 pure @nogc @system nothrow unittest
 {
     // https://issues.dlang.org/show_bug.cgi?id=16398
     // test the "pseudo" alignedReallocate for Posix
     void[] b = AlignedMallocator.instance.alignedAllocate(16, 32);
     (cast(ubyte[]) b)[] = ubyte(1);
     AlignedMallocator.instance.alignedReallocate(b, 32, 32);
     ubyte[16] o;
     o[] = 1;
     assert((cast(ubyte[]) b)[0 .. 16] == o);
     AlignedMallocator.instance.alignedReallocate(b, 4, 32);
     assert((cast(ubyte[]) b)[0 .. 3] == o[0 .. 3]);
     AlignedMallocator.instance.alignedReallocate(b, 128, 32);
     assert((cast(ubyte[]) b)[0 .. 3] == o[0 .. 3]);
     AlignedMallocator.instance.deallocate(b);

     void[] c;
     AlignedMallocator.instance.alignedReallocate(c, 32, 32);
     assert(c.ptr);

     version (LDC_AddressSanitizer) {} else // AddressSanitizer does not support such large memory allocations (0x10000000000 max)
     version (DragonFlyBSD) {} else    /* FIXME: Malloc on DragonFly does not return NULL when allocating more than UINTPTR_MAX
                                        * $(LINK: https://bugs.dragonflybsd.org/issues/3114, dragonfly bug report)
                                        * $(LINK: https://github.com/dlang/druntime/pull/1999#discussion_r157536030, PR Discussion) */
     assert(!AlignedMallocator.instance.alignedReallocate(c, size_t.max, 4096));
     AlignedMallocator.instance.deallocate(c);
 }
	// Written in the D programming language.
	/**
	The C heap allocator.

	Source: $(PHOBOSSRC std/experimental/allocator/mallocator.d)
	*/
	module std.experimental.allocator.mallocator;
	import std.experimental.allocator.common;

	/**
	The C heap allocator.
	*/
	struct Mallocator
	{
	version (StdUnittest) @system unittest { testAllocator!(() => Mallocator.instance); }

	/**
	The alignment is a static constant equal to `platformAlignment`, which
	ensures proper alignment for any D data type.
	*/
	enum uint alignment = platformAlignment;

	/**
	Standard allocator methods per the semantics defined above. The
	`deallocate` and `reallocate` methods are `@system` because they
	may move memory around, leaving dangling pointers in user code. Somewhat
	paradoxically, `malloc` is `@safe` but that's only useful to safe
	programs that can afford to leak memory allocated.
	*/
	@trusted @nogc nothrow pure
	void[] allocate(size_t bytes) shared const
	{
	import core.memory : pureMalloc;
	if (!bytes) return null;
	auto p = pureMalloc(bytes);
	return p ? p[0 .. bytes] : null;
	}

	/// Ditto
	@system @nogc nothrow pure
	bool deallocate(void[] b) shared const
	{
	import core.memory : pureFree;
	pureFree(b.ptr);
	return true;
	}

	/// Ditto
	@system @nogc nothrow pure
	bool reallocate(ref void[] b, size_t s) shared const
	{
	import core.memory : pureRealloc;
	if (!s)
	{
	// fuzzy area in the C standard, see https://stackoverflow.com/questions/6502077/malloc-and-realloc-functions
	// so just deallocate and nullify the pointer
	deallocate(b);
	b = null;
	return true;
	}
	auto p = cast(ubyte*) pureRealloc(b.ptr, s);
	if (!p) return false;
	b = p[0 .. s];
	return true;
	}

	@trusted @nogc nothrow pure
	package void[] allocateZeroed()(size_t bytes) shared const
	{
	import core.memory : pureCalloc;
	if (!bytes) return null;
	auto p = pureCalloc(1, bytes);
	return p ? p[0 .. bytes] : null;
	}

	/**
	Returns the global instance of this allocator type. The C heap allocator is
	thread-safe, therefore all of its methods and `it` itself are
	`shared`.
	*/
	static shared Mallocator instance;
	}

	///
	@nogc @system nothrow unittest
	{
	auto buffer = Mallocator.instance.allocate(1024 * 1024 * 4);
	scope(exit) Mallocator.instance.deallocate(buffer);
	//...
	}

	@nogc @system nothrow pure unittest
	{
	@nogc nothrow pure
	static void test(A)()
	{
	int* p = null;
	p = cast(int*) A.instance.allocate(int.sizeof);
	scope(exit) () nothrow @nogc { A.instance.deallocate(p[0 .. int.sizeof]); }();
	*p = 42;
	assert(*p == 42);
	}
	test!Mallocator();
	}

	@nogc @system nothrow pure unittest
	{
	static void test(A)()
	{
	import std.experimental.allocator : make;
	Object p = null;
	p = A.instance.make!Object();
	assert(p !is null);
	}

	test!Mallocator();
	}

	version (CRuntime_Microsoft)
	{
	@nogc nothrow pure private extern(C) void* _aligned_malloc(size_t, size_t);
	@nogc nothrow pure private extern(C) void _aligned_free(void *memblock);
	@nogc nothrow pure private extern(C) void* _aligned_realloc(void *, size_t, size_t);
	}

	/**
	Aligned allocator using OS-specific primitives, under a uniform API.
	*/
	struct AlignedMallocator
	{
	version (StdUnittest) @system unittest { testAllocator!(() => typeof(this).instance); }

	/**
	The default alignment is `platformAlignment`.
	*/
	enum uint alignment = platformAlignment;

	/**
	Forwards to $(D alignedAllocate(bytes, platformAlignment)).
	*/
	@trusted @nogc nothrow pure
	void[] allocate(size_t bytes) shared
	{
	if (!bytes) return null;
	return alignedAllocate(bytes, alignment);
	}

	/**
	Uses $(HTTP man7.org/linux/man-pages/man3/posix_memalign.3.html,
	`posix_memalign`) on Posix and
	$(HTTP msdn.microsoft.com/en-us/library/8z34s9c6(v=vs.80).aspx,
	`__aligned_malloc`) on Windows.
	*/
	version (Posix)
	@trusted @nogc nothrow pure
	void[] alignedAllocate(size_t bytes, uint a) shared
	{
	import core.stdc.errno : ENOMEM, EINVAL;
	import core.sys.posix.stdlib : posix_memalign;
	assert(a.isGoodDynamicAlignment);
	void* result;
	auto code = posix_memalign(&result, a, bytes);

	version (OSX)
	version (LDC_AddressSanitizer)
	{
	// The return value with AddressSanitizer may be -1 instead of ENOMEM
	// or EINVAL. See https://bugs.llvm.org/show_bug.cgi?id=36510
	if (code == -1)
	return null;
	}
	if (code == ENOMEM)
	return null;

	else if (code == EINVAL)
	{
	assert(0, "AlignedMallocator.alignment is not a power of two "
	~"multiple of (void*).sizeof, according to posix_memalign!");
	}
	else if (code != 0)
	assert(0, "posix_memalign returned an unknown code!");

	else
	return result[0 .. bytes];
	}
	else version (Windows)
	@trusted @nogc nothrow pure
	void[] alignedAllocate(size_t bytes, uint a) shared
	{
	auto result = _aligned_malloc(bytes, a);
	return result ? result[0 .. bytes] : null;
	}
	else static assert(0);

	/**
	Calls `free(b.ptr)` on Posix and
	$(HTTP msdn.microsoft.com/en-US/library/17b5h8td(v=vs.80).aspx,
	`__aligned_free(b.ptr)`) on Windows.
	*/
	version (Posix)
	@system @nogc nothrow pure
	bool deallocate(void[] b) shared
	{
	import core.memory : pureFree;
	pureFree(b.ptr);
	return true;
	}
	else version (Windows)
	@system @nogc nothrow pure
	bool deallocate(void[] b) shared
	{
	_aligned_free(b.ptr);
	return true;
	}
	else static assert(0);

	/**
	Forwards to $(D alignedReallocate(b, newSize, platformAlignment)).
	Should be used with blocks obtained with `allocate` otherwise the custom
	alignment passed with `alignedAllocate` can be lost.
	*/
	@system @nogc nothrow pure
	bool reallocate(ref void[] b, size_t newSize) shared
	{
	return alignedReallocate(b, newSize, alignment);
	}

	/**
	On Posix there is no `realloc` for aligned memory, so `alignedReallocate` emulates
	the needed behavior by using `alignedAllocate` to get a new block. The existing
	block is copied to the new block and then freed.
	On Windows, calls $(HTTPS msdn.microsoft.com/en-us/library/y69db7sx.aspx,
	$(D __aligned_realloc(b.ptr, newSize, a))).
	*/
	version (Windows)
	@system @nogc nothrow pure
	bool alignedReallocate(ref void[] b, size_t s, uint a) shared
	{
	if (!s)
	{
	deallocate(b);
	b = null;
	return true;
	}
	auto p = cast(ubyte*) _aligned_realloc(b.ptr, s, a);
	if (!p) return false;
	b = p[0 .. s];
	return true;
	}

	/// ditto
	version (Posix)
	@system @nogc nothrow pure
	bool alignedReallocate(ref void[] b, size_t s, uint a) shared
	{
	if (!s)
	{
	deallocate(b);
	b = null;
	return true;
	}
	auto p = alignedAllocate(s, a);
	if (!p.ptr)
	{
	return false;
	}
	import std.algorithm.comparison : min;
	const upTo = min(s, b.length);
	p[0 .. upTo] = b[0 .. upTo];
	deallocate(b);
	b = p;
	return true;
	}

	/**
	Returns the global instance of this allocator type. The C heap allocator is
	thread-safe, therefore all of its methods and `instance` itself are
	`shared`.
	*/
	static shared AlignedMallocator instance;
	}

	///
	pure @nogc @system nothrow unittest
	{
	auto buffer = AlignedMallocator.instance.alignedAllocate(1024 * 1024 * 4,
	128);
	scope(exit) AlignedMallocator.instance.deallocate(buffer);
	//...
	}

	version (Posix)
	pure @nogc @system nothrow unittest
	{
	// https://issues.dlang.org/show_bug.cgi?id=16398
	// test the "pseudo" alignedReallocate for Posix
	void[] b = AlignedMallocator.instance.alignedAllocate(16, 32);
	(cast(ubyte[]) b)[] = ubyte(1);
	AlignedMallocator.instance.alignedReallocate(b, 32, 32);
	ubyte[16] o;
	o[] = 1;
	assert((cast(ubyte[]) b)[0 .. 16] == o);
	AlignedMallocator.instance.alignedReallocate(b, 4, 32);
	assert((cast(ubyte[]) b)[0 .. 3] == o[0 .. 3]);
	AlignedMallocator.instance.alignedReallocate(b, 128, 32);
	assert((cast(ubyte[]) b)[0 .. 3] == o[0 .. 3]);
	AlignedMallocator.instance.deallocate(b);

	void[] c;
	AlignedMallocator.instance.alignedReallocate(c, 32, 32);
	assert(c.ptr);

	version (LDC_AddressSanitizer) {} else // AddressSanitizer does not support such large memory allocations (0x10000000000 max)
	version (DragonFlyBSD) {} else /* FIXME: Malloc on DragonFly does not return NULL when allocating more than UINTPTR_MAX
	* $(LINK: https://bugs.dragonflybsd.org/issues/3114, dragonfly bug report)
	* $(LINK: https://github.com/dlang/druntime/pull/1999#discussion_r157536030, PR Discussion) */
	assert(!AlignedMallocator.instance.alignedReallocate(c, size_t.max, 4096));
	AlignedMallocator.instance.deallocate(c);
	}