mirror of
https://github.com/autc04/Retro68.git
synced 2025-02-22 01:29:13 +00:00
389 lines
9.5 KiB
D
389 lines
9.5 KiB
D
/**
|
|
* This module contains a minimal garbage collector implementation according to
|
|
* published requirements. This library is mostly intended to serve as an
|
|
* example, but it is usable in applications which do not rely on a garbage
|
|
* collector to clean up memory (ie. when dynamic array resizing is not used,
|
|
* and all memory allocated with 'new' is freed deterministically with
|
|
* 'delete').
|
|
*
|
|
* Please note that block attribute data must be tracked, or at a minimum, the
|
|
* FINALIZE bit must be tracked for any allocated memory block because calling
|
|
* rt_finalize on a non-object block can result in an access violation. In the
|
|
* allocator below, this tracking is done via a leading uint bitmask. A real
|
|
* allocator may do better to store this data separately, similar to the basic
|
|
* GC.
|
|
*
|
|
* Copyright: Copyright Sean Kelly 2005 - 2009.
|
|
* License: $(WEB www.boost.org/LICENSE_1_0.txt, Boost License 1.0).
|
|
* Authors: Sean Kelly
|
|
*/
|
|
|
|
/* Copyright Sean Kelly 2005 - 2009.
|
|
* Distributed under the Boost Software License, Version 1.0.
|
|
* (See accompanying file LICENSE or copy at
|
|
* http://www.boost.org/LICENSE_1_0.txt)
|
|
*/
|
|
module gc.gc;
|
|
|
|
private
|
|
{
|
|
import core.stdc.stdlib;
|
|
import core.stdc.stdio;
|
|
|
|
static import core.memory;
|
|
private alias BlkAttr = core.memory.GC.BlkAttr;
|
|
private alias BlkInfo = core.memory.GC.BlkInfo;
|
|
|
|
extern (C) void thread_init();
|
|
extern (C) void onOutOfMemoryError(void* pretend_sideffect = null) @trusted pure nothrow @nogc; /* dmd @@@BUG11461@@@ */
|
|
|
|
struct Proxy
|
|
{
|
|
extern (C) void function() gc_enable;
|
|
extern (C) void function() gc_disable;
|
|
extern (C) void function() gc_collect;
|
|
extern (C) void function() gc_minimize;
|
|
|
|
extern (C) uint function(void*) gc_getAttr;
|
|
extern (C) uint function(void*, uint) gc_setAttr;
|
|
extern (C) uint function(void*, uint) gc_clrAttr;
|
|
|
|
extern (C) void* function(size_t, uint, const TypeInfo) gc_malloc;
|
|
extern (C) BlkInfo function(size_t, uint, const TypeInfo) gc_qalloc;
|
|
extern (C) void* function(size_t, uint, const TypeInfo) gc_calloc;
|
|
extern (C) void* function(void*, size_t, uint ba, const TypeInfo) gc_realloc;
|
|
extern (C) size_t function(void*, size_t, size_t, const TypeInfo) gc_extend;
|
|
extern (C) size_t function(size_t) gc_reserve;
|
|
extern (C) void function(void*) gc_free;
|
|
|
|
extern (C) void* function(void*) gc_addrOf;
|
|
extern (C) size_t function(void*) gc_sizeOf;
|
|
|
|
extern (C) BlkInfo function(void*) gc_query;
|
|
|
|
extern (C) void function(void*) gc_addRoot;
|
|
extern (C) void function(void*, size_t, const TypeInfo ti) gc_addRange;
|
|
|
|
extern (C) void function(void*) gc_removeRoot;
|
|
extern (C) void function(void*) gc_removeRange;
|
|
extern (C) void function(in void[]) gc_runFinalizers;
|
|
|
|
extern (C) bool function() gc_inFinalizer;
|
|
}
|
|
|
|
__gshared Proxy pthis;
|
|
__gshared Proxy* proxy;
|
|
|
|
void initProxy()
|
|
{
|
|
pthis.gc_enable = &gc_enable;
|
|
pthis.gc_disable = &gc_disable;
|
|
pthis.gc_collect = &gc_collect;
|
|
pthis.gc_minimize = &gc_minimize;
|
|
|
|
pthis.gc_getAttr = &gc_getAttr;
|
|
pthis.gc_setAttr = &gc_setAttr;
|
|
pthis.gc_clrAttr = &gc_clrAttr;
|
|
|
|
pthis.gc_malloc = &gc_malloc;
|
|
pthis.gc_qalloc = &gc_qalloc;
|
|
pthis.gc_calloc = &gc_calloc;
|
|
pthis.gc_realloc = &gc_realloc;
|
|
pthis.gc_extend = &gc_extend;
|
|
pthis.gc_reserve = &gc_reserve;
|
|
pthis.gc_free = &gc_free;
|
|
|
|
pthis.gc_addrOf = &gc_addrOf;
|
|
pthis.gc_sizeOf = &gc_sizeOf;
|
|
|
|
pthis.gc_query = &gc_query;
|
|
|
|
pthis.gc_addRoot = &gc_addRoot;
|
|
pthis.gc_addRange = &gc_addRange;
|
|
|
|
pthis.gc_removeRoot = &gc_removeRoot;
|
|
pthis.gc_removeRange = &gc_removeRange;
|
|
pthis.gc_runFinalizers = &gc_runFinalizers;
|
|
|
|
pthis.gc_inFinalizer = &gc_inFinalizer;
|
|
}
|
|
|
|
__gshared void** roots = null;
|
|
__gshared size_t nroots = 0;
|
|
|
|
struct Range
|
|
{
|
|
void* pos;
|
|
size_t len;
|
|
TypeInfo ti; // should be tail const, but doesn't exist for references
|
|
}
|
|
|
|
__gshared Range* ranges = null;
|
|
__gshared size_t nranges = 0;
|
|
}
|
|
|
|
extern (C) void gc_init()
|
|
{
|
|
// NOTE: The GC must initialize the thread library before its first
|
|
// collection, and always before returning from gc_init().
|
|
thread_init();
|
|
initProxy();
|
|
}
|
|
|
|
extern (C) void gc_term()
|
|
{
|
|
free( roots );
|
|
free( ranges );
|
|
}
|
|
|
|
extern (C) void gc_enable()
|
|
{
|
|
if ( proxy is null )
|
|
return;
|
|
return proxy.gc_enable();
|
|
}
|
|
|
|
extern (C) void gc_disable()
|
|
{
|
|
if ( proxy is null )
|
|
return;
|
|
return proxy.gc_disable();
|
|
}
|
|
|
|
extern (C) void gc_collect()
|
|
{
|
|
if ( proxy is null )
|
|
return;
|
|
return proxy.gc_collect();
|
|
}
|
|
|
|
extern (C) void gc_minimize()
|
|
{
|
|
if ( proxy is null )
|
|
return;
|
|
return proxy.gc_minimize();
|
|
}
|
|
|
|
extern (C) uint gc_getAttr( void* p )
|
|
{
|
|
if ( proxy is null )
|
|
return 0;
|
|
return proxy.gc_getAttr( p );
|
|
}
|
|
|
|
extern (C) uint gc_setAttr( void* p, uint a )
|
|
{
|
|
if ( proxy is null )
|
|
return 0;
|
|
return proxy.gc_setAttr( p, a );
|
|
}
|
|
|
|
extern (C) uint gc_clrAttr( void* p, uint a )
|
|
{
|
|
if ( proxy is null )
|
|
return 0;
|
|
return proxy.gc_clrAttr( p, a );
|
|
}
|
|
|
|
extern (C) void* gc_malloc( size_t sz, uint ba = 0, const TypeInfo ti = null )
|
|
{
|
|
if ( proxy is null )
|
|
{
|
|
void* p = malloc( sz );
|
|
|
|
if ( sz && p is null )
|
|
onOutOfMemoryError();
|
|
return p;
|
|
}
|
|
return proxy.gc_malloc( sz, ba, ti );
|
|
}
|
|
|
|
extern (C) BlkInfo gc_qalloc( size_t sz, uint ba = 0, const TypeInfo ti = null )
|
|
{
|
|
if ( proxy is null )
|
|
{
|
|
BlkInfo retval;
|
|
retval.base = gc_malloc(sz, ba);
|
|
retval.size = sz;
|
|
retval.attr = ba;
|
|
return retval;
|
|
}
|
|
return proxy.gc_qalloc( sz, ba, ti );
|
|
}
|
|
|
|
extern (C) void* gc_calloc( size_t sz, uint ba = 0, const TypeInfo ti = null )
|
|
{
|
|
if ( proxy is null )
|
|
{
|
|
void* p = calloc( 1, sz );
|
|
|
|
if ( sz && p is null )
|
|
onOutOfMemoryError();
|
|
return p;
|
|
}
|
|
return proxy.gc_calloc( sz, ba, ti );
|
|
}
|
|
|
|
extern (C) void* gc_realloc( void* p, size_t sz, uint ba = 0, const TypeInfo ti = null )
|
|
{
|
|
if ( proxy is null )
|
|
{
|
|
p = realloc( p, sz );
|
|
|
|
if ( sz && p is null )
|
|
onOutOfMemoryError();
|
|
return p;
|
|
}
|
|
return proxy.gc_realloc( p, sz, ba, ti );
|
|
}
|
|
|
|
extern (C) size_t gc_extend( void* p, size_t mx, size_t sz, const TypeInfo ti = null )
|
|
{
|
|
if ( proxy is null )
|
|
return 0;
|
|
return proxy.gc_extend( p, mx, sz, ti );
|
|
}
|
|
|
|
extern (C) size_t gc_reserve( size_t sz )
|
|
{
|
|
if ( proxy is null )
|
|
return 0;
|
|
return proxy.gc_reserve( sz );
|
|
}
|
|
|
|
extern (C) void gc_free( void* p )
|
|
{
|
|
if ( proxy is null )
|
|
return free( p );
|
|
return proxy.gc_free( p );
|
|
}
|
|
|
|
extern (C) void* gc_addrOf( void* p )
|
|
{
|
|
if ( proxy is null )
|
|
return null;
|
|
return proxy.gc_addrOf( p );
|
|
}
|
|
|
|
extern (C) size_t gc_sizeOf( void* p )
|
|
{
|
|
if ( proxy is null )
|
|
return 0;
|
|
return proxy.gc_sizeOf( p );
|
|
}
|
|
|
|
extern (C) BlkInfo gc_query( void* p )
|
|
{
|
|
if ( proxy is null )
|
|
return BlkInfo.init;
|
|
return proxy.gc_query( p );
|
|
}
|
|
|
|
extern (C) void gc_addRoot( void* p )
|
|
{
|
|
if ( proxy is null )
|
|
{
|
|
void** r = cast(void**) realloc( roots,
|
|
(nroots+1) * roots[0].sizeof );
|
|
if ( r is null )
|
|
onOutOfMemoryError();
|
|
r[nroots++] = p;
|
|
roots = r;
|
|
return;
|
|
}
|
|
return proxy.gc_addRoot( p );
|
|
}
|
|
|
|
extern (C) void gc_addRange( void* p, size_t sz, const TypeInfo ti = null )
|
|
{
|
|
//printf("gcstub::gc_addRange() proxy = %p\n", proxy);
|
|
if ( proxy is null )
|
|
{
|
|
Range* r = cast(Range*) realloc( ranges,
|
|
(nranges+1) * ranges[0].sizeof );
|
|
if ( r is null )
|
|
onOutOfMemoryError();
|
|
r[nranges].pos = p;
|
|
r[nranges].len = sz;
|
|
r[nranges].ti = cast()ti;
|
|
ranges = r;
|
|
++nranges;
|
|
return;
|
|
}
|
|
return proxy.gc_addRange( p, sz, ti );
|
|
}
|
|
|
|
extern (C) void gc_removeRoot( void *p )
|
|
{
|
|
if ( proxy is null )
|
|
{
|
|
for ( size_t i = 0; i < nroots; ++i )
|
|
{
|
|
if ( roots[i] is p )
|
|
{
|
|
roots[i] = roots[--nroots];
|
|
return;
|
|
}
|
|
}
|
|
assert( false );
|
|
}
|
|
return proxy.gc_removeRoot( p );
|
|
}
|
|
|
|
extern (C) void gc_removeRange( void *p )
|
|
{
|
|
if ( proxy is null )
|
|
{
|
|
for ( size_t i = 0; i < nranges; ++i )
|
|
{
|
|
if ( ranges[i].pos is p )
|
|
{
|
|
ranges[i] = ranges[--nranges];
|
|
return;
|
|
}
|
|
}
|
|
assert( false );
|
|
}
|
|
return proxy.gc_removeRange( p );
|
|
}
|
|
|
|
extern (C) void gc_runFinalizers( in void[] segment )
|
|
{
|
|
if ( proxy !is null )
|
|
proxy.gc_runFinalizers( segment );
|
|
}
|
|
|
|
extern (C) bool gc_inFinalizer()
|
|
{
|
|
if ( proxy !is null )
|
|
return proxy.gc_inFinalizer();
|
|
return false;
|
|
}
|
|
|
|
extern (C) Proxy* gc_getProxy()
|
|
{
|
|
return &pthis;
|
|
}
|
|
|
|
export extern (C) void gc_setProxy( Proxy* p )
|
|
{
|
|
if ( proxy !is null )
|
|
{
|
|
// TODO: Decide if this is an error condition.
|
|
}
|
|
proxy = p;
|
|
foreach ( r; roots[0 .. nroots] )
|
|
proxy.gc_addRoot( r );
|
|
foreach ( r; ranges[0 .. nranges] )
|
|
proxy.gc_addRange( r.pos, r.len, r.ti );
|
|
}
|
|
|
|
export extern (C) void gc_clrProxy()
|
|
{
|
|
foreach ( r; ranges[0 .. nranges] )
|
|
proxy.gc_removeRange( r.pos );
|
|
foreach ( r; roots[0 .. nroots] )
|
|
proxy.gc_removeRoot( r );
|
|
proxy = null;
|
|
}
|