Designing with the GC out of mind

[anonymous]

On Tuesday, 6 August 2013 at 14:27:32 UTC, Adam D. Ruppe wrote:
> and there's a gc proxy in the code but idk how to use it.

I have this little piece of hack that uses the proxy to disable 
GC allocations at runtime. It's not tested well, so it probably 
has some issues, but maybe it's a start for someone. See the 
unittest for how to use.

CODE:

import std.exception: assertThrown;
import std.traits: ParameterTypeTuple, ReturnType;

static import core.memory;

/*NOTE: Deriving from Throwable instead of Exception, because 
with Exception
catch(GCUsedWhenForbidden) doesn't work (dmd 2.063). */
class GCUsedWhenForbidden : Throwable
{
	this(string gcProcName, string file = __FILE__, size_t line = 
__LINE__)
	{
		super(gcProcName, file, line);
	}
}

struct GC
{
	static auto opDispatch(string n, A ...)(A args)
	{
		mixin("return core.memory.GC." ~ n ~ "(args);");
	}
	private static Proxy proxy;
	static this()
	{
		foreach(name; __traits(allMembers, Proxy))
			makeDie!name();
	}
	private shared static uint forbidCount = 0;
	static void forbidUse()
	{
		if(forbidCount++ == 0) actuallyForbidUse;
	}
	private static void actuallyForbidUse()
	{
		makeNop!"gc_addRange"();
		gc_setProxy(&proxy);
		makeDie!"gc_addRange"();
	}
	static void allowUse()
	{
		if(--forbidCount == 0) actuallyAllowUse;
	}
	private static void actuallyAllowUse()
	{
		makeNop!"gc_removeRange"();
		gc_clrProxy();
		makeDie!"gc_removeRange"();
	}
	private static auto proxyMember(string name)()
	{
		mixin("return &proxy." ~ name ~ ";");
	}
	private static makeNop(string name)()
	{
		*proxyMember!name = &nop!(typeof(*proxyMember!name));
	}
	private static makeDie(string name)()
	{
		*proxyMember!name = &die!(typeof(*proxyMember!name), name);
	}
}
unittest
{
	int[] h = new int[1];
	
	GC.forbidUse; // 1
	assertThrown!GCUsedWhenForbidden(new int[1]);
	
	GC.forbidUse; // 2
	assertThrown!GCUsedWhenForbidden(new int[1]);
	
	GC.allowUse; // 1
	assertThrown!GCUsedWhenForbidden(new int[1]);
	
	GC.allowUse; // 0
	h = new int[1]; // now, GC can be used again
}

private extern(C) void nop(T)(ParameterTypeTuple!T) {}
private extern(C) ReturnType!T die(T, string 
name)(ParameterTypeTuple!T)
{
	GC.actuallyAllowUse;
	scope(exit) GC.actuallyForbidUse;
	throw new GCUsedWhenForbidden(name);
}

//NOTE: copied from druntime/src/gc/gc.d
private struct BlkInfo
{
	void*  base;
	size_t size;
	uint   attr;
}
//NOTE: copied from druntime/src/gc/proxy.d
private struct Proxy
{
	extern(C)
	{
		void function() gc_enable;
		void function() gc_disable;
		void function() gc_collect;
		void function() gc_minimize;

		uint function(void*) gc_getAttr;
		uint function(void*, uint) gc_setAttr;
		uint function(void*, uint) gc_clrAttr;

		void*   function(size_t, uint) gc_malloc;
		BlkInfo function(size_t, uint) gc_qalloc;
		void*   function(size_t, uint) gc_calloc;
		void*   function(void*, size_t, uint ba) gc_realloc;
		size_t  function(void*, size_t, size_t) gc_extend;
		size_t  function(size_t) gc_reserve;
		void    function(void*) gc_free;

		void*   function(void*) gc_addrOf;
		size_t  function(void*) gc_sizeOf;

		BlkInfo function(void*) gc_query;

		void function(void*) gc_addRoot;
		void function(void*, size_t) gc_addRange;

		void function(void*) gc_removeRoot;
		void function(void*) gc_removeRange;
	}
}
//NOTE: copied from druntime/src/gc/proxy.d
private extern(C) void gc_setProxy(Proxy*);
private extern(C) void gc_clrProxy();