@@ -14,13 +14,13 @@ public:
static SQArray* Create(SQSharedState *ss,SQInteger nInitialSize){
SQArray *newarray=(SQArray*)SQ_MALLOC(sizeof(SQArray));
new (newarray) SQArray(ss,nInitialSize);
return newarray;
}
#ifndef NO_GARBAGE_COLLECTOR
void Mark(SQCollectable **chain);
void EnqueueMarkObjectForChildren(SQGCMarkerQueue &queue);
#endif
void Finalize(){
_values.resize(0);
bool Get(const SQInteger nidx,SQObjectPtr &val)
{
@@ -56,13 +56,13 @@ public:
void Release() {
if (_hook) { _hook(_typetag,0);}
sq_delete(this, SQClass);
void Finalize();
void Mark(SQCollectable ** );
SQInteger Next(const SQObjectPtr &refpos, SQObjectPtr &outkey, SQObjectPtr &outval);
SQInstance *CreateInstance();
SQTable *_members;
SQClass *_base;
SQClassMemberVec _defaultvalues;
@@ -144,13 +144,13 @@ public:
SQInteger size = _memsize;
this->~SQInstance();
SQ_FREE(this, size);
bool InstanceOf(SQClass *trg);
bool GetMetaMethod(SQVM *v,SQMetaMethod mm,SQObjectPtr &res);
SQClass *_class;
SQUserPointer _userpointer;
@@ -29,13 +29,13 @@ public:
REMOVE_FROM_CHAIN(&_ss(this)->_gc_chain,this);
bool Save(SQVM *v,SQUserPointer up,SQWRITEFUNC write);
static bool Load(SQVM *v,SQUserPointer up,SQREADFUNC read,SQObjectPtr &ret);
void Finalize(){_outervalues.resize(0); }
SQObjectPtr _env;
SQObjectPtr _function;
SQObjectPtrVec _outervalues;
SQObjectPtrVec _defaultparams;
@@ -63,13 +63,13 @@ public:
void Release(){
sq_delete(this,SQGenerator);
bool Yield(SQVM *v);
bool Resume(SQVM *v,SQInteger target);
void Finalize(){_stack.resize(0);_closure=_null_;}
SQObjectPtr _closure;
SQObjectPtrVec _stack;
SQObjectPtrVec _vargsstack;
SQVM::CallInfo _ci;
@@ -103,13 +103,13 @@ public:
sq_delete(this,SQNativeClosure);
void Finalize(){_outervalues.resize(0);}
SQInteger _nparamscheck;
SQIntVec _typecheck;
@@ -483,110 +483,87 @@ bool SQFunctionProto::Load(SQVM *v,SQUse
ret = f;
return true;
#define START_MARK() if(!(_uiRef&MARK_FLAG)){ \
_uiRef|=MARK_FLAG;
#define END_MARK() RemoveFromChain(&_sharedstate->_gc_chain, this); \
AddToChain(chain, this); }
void SQVM::Mark(SQCollectable **chain)
void SQVM::EnqueueMarkObjectForChildren(SQGCMarkerQueue &queue)
START_MARK()
SQSharedState::MarkObject(_lasterror,chain);
SQSharedState::MarkObject(_errorhandler,chain);
SQSharedState::MarkObject(_debughook,chain);
SQSharedState::MarkObject(_roottable, chain);
SQSharedState::MarkObject(temp_reg, chain);
for(SQUnsignedInteger i = 0; i < _stack.size(); i++) SQSharedState::MarkObject(_stack[i], chain);
for(SQUnsignedInteger j = 0; j < _vargsstack.size(); j++) SQSharedState::MarkObject(_vargsstack[j], chain);
for(SQInteger k = 0; k < _callsstacksize; k++) SQSharedState::MarkObject(_callsstack[k]._closure, chain);
END_MARK()
SQSharedState::EnqueueMarkObject(_lasterror,queue);
SQSharedState::EnqueueMarkObject(_errorhandler,queue);
SQSharedState::EnqueueMarkObject(_debughook,queue);
SQSharedState::EnqueueMarkObject(_roottable, queue);
SQSharedState::EnqueueMarkObject(temp_reg, queue);
for(SQUnsignedInteger i = 0; i < _stack.size(); i++) SQSharedState::EnqueueMarkObject(_stack[i], queue);
for(SQUnsignedInteger j = 0; j < _vargsstack.size(); j++) SQSharedState::EnqueueMarkObject(_vargsstack[j], queue);
for(SQInteger k = 0; k < _callsstacksize; k++) SQSharedState::EnqueueMarkObject(_callsstack[k]._closure, queue);
void SQArray::Mark(SQCollectable **chain)
void SQArray::EnqueueMarkObjectForChildren(SQGCMarkerQueue &queue)
SQInteger len = _values.size();
for(SQInteger i = 0;i < len; i++) SQSharedState::MarkObject(_values[i], chain);
for(SQInteger i = 0;i < len; i++) SQSharedState::EnqueueMarkObject(_values[i], queue);
void SQTable::Mark(SQCollectable **chain)
void SQTable::EnqueueMarkObjectForChildren(SQGCMarkerQueue &queue)
if(_delegate) _delegate->Mark(chain);
if(_delegate) queue.Enqueue(_delegate);
SQInteger len = _numofnodes;
for(SQInteger i = 0; i < len; i++){
SQSharedState::MarkObject(_nodes[i].key, chain);
SQSharedState::MarkObject(_nodes[i].val, chain);
SQSharedState::EnqueueMarkObject(_nodes[i].key, queue);
SQSharedState::EnqueueMarkObject(_nodes[i].val, queue);
void SQClass::Mark(SQCollectable **chain)
void SQClass::EnqueueMarkObjectForChildren(SQGCMarkerQueue &queue)
_members->Mark(chain);
if(_base) _base->Mark(chain);
SQSharedState::MarkObject(_attributes, chain);
queue.Enqueue(_members);
if(_base) queue.Enqueue(_base);
SQSharedState::EnqueueMarkObject(_attributes, queue);
for(SQUnsignedInteger i =0; i< _defaultvalues.size(); i++) {
SQSharedState::MarkObject(_defaultvalues[i].val, chain);
SQSharedState::MarkObject(_defaultvalues[i].attrs, chain);
SQSharedState::EnqueueMarkObject(_defaultvalues[i].val, queue);
SQSharedState::EnqueueMarkObject(_defaultvalues[i].attrs, queue);
for(SQUnsignedInteger j =0; j< _methods.size(); j++) {
SQSharedState::MarkObject(_methods[j].val, chain);
SQSharedState::MarkObject(_methods[j].attrs, chain);
SQSharedState::EnqueueMarkObject(_methods[j].val, queue);
SQSharedState::EnqueueMarkObject(_methods[j].attrs, queue);
for(SQUnsignedInteger k =0; k< _metamethods.size(); k++) {
SQSharedState::MarkObject(_metamethods[k], chain);
SQSharedState::EnqueueMarkObject(_metamethods[k], queue);
void SQInstance::Mark(SQCollectable **chain)
void SQInstance::EnqueueMarkObjectForChildren(SQGCMarkerQueue &queue)
_class->Mark(chain);
queue.Enqueue(_class);
SQUnsignedInteger nvalues = _class->_defaultvalues.size();
for(SQUnsignedInteger i =0; i< nvalues; i++) {
SQSharedState::MarkObject(_values[i], chain);
SQSharedState::EnqueueMarkObject(_values[i], queue);
void SQGenerator::Mark(SQCollectable **chain)
void SQGenerator::EnqueueMarkObjectForChildren(SQGCMarkerQueue &queue)
SQSharedState::MarkObject(_closure, chain);
SQSharedState::EnqueueMarkObject(_closure, queue);
void SQClosure::Mark(SQCollectable **chain)
void SQClosure::EnqueueMarkObjectForChildren(SQGCMarkerQueue &queue)
for(SQUnsignedInteger i = 0; i < _outervalues.size(); i++) SQSharedState::MarkObject(_outervalues[i], chain);
for(SQUnsignedInteger i = 0; i < _defaultparams.size(); i++) SQSharedState::MarkObject(_defaultparams[i], chain);
for(SQUnsignedInteger i = 0; i < _outervalues.size(); i++) SQSharedState::EnqueueMarkObject(_outervalues[i], queue);
for(SQUnsignedInteger i = 0; i < _defaultparams.size(); i++) SQSharedState::EnqueueMarkObject(_defaultparams[i], queue);
void SQNativeClosure::Mark(SQCollectable **chain)
void SQNativeClosure::EnqueueMarkObjectForChildren(SQGCMarkerQueue &queue)
void SQUserData::Mark(SQCollectable **chain){
void SQUserData::EnqueueMarkObjectForChildren(SQGCMarkerQueue &queue){
void SQCollectable::UnMark() { _uiRef&=~MARK_FLAG; }
/* see copyright notice in squirrel.h */
#ifndef _SQOBJECT_H_
#define _SQOBJECT_H_
#include <forward_list>
#include "squtils.h"
#define SQ_CLOSURESTREAM_HEAD (('S'<<24)|('Q'<<16)|('I'<<8)|('R'))
#define SQ_CLOSURESTREAM_PART (('P'<<24)|('A'<<16)|('R'<<8)|('T'))
#define SQ_CLOSURESTREAM_TAIL (('T'<<24)|('A'<<16)|('I'<<8)|('L'))
@@ -341,19 +342,54 @@ inline void _Swap(SQObject &a,SQObject &
#define MARK_FLAG 0x80000000
struct SQCollectable : public SQRefCounted {
SQCollectable *_next;
SQCollectable *_prev;
SQSharedState *_sharedstate;
virtual void Release()=0;
virtual void Mark(SQCollectable **chain)=0;
virtual void EnqueueMarkObjectForChildren(class SQGCMarkerQueue &queue)=0;
void UnMark();
virtual void Finalize()=0;
static void AddToChain(SQCollectable **chain,SQCollectable *c);
static void RemoveFromChain(SQCollectable **chain,SQCollectable *c);
};
/**
* Helper container for state to change the garbage collection from a recursive to an iterative approach.
* The iterative approach provides effectively a depth first search approach.
*/
class SQGCMarkerQueue {
std::forward_list<SQCollectable*> queue; ///< The queue of elements to still process.
public:
/** Whether there are any elements left to process. */
bool IsEmpty() { return this->queue.empty(); }
* Remove the first element from the queue.
* Removal when the queue is empty results in undefined behaviour.
SQCollectable *Pop()
SQCollectable *collectable = this->queue.front();
this->queue.pop_front();
return collectable;
* Add a collectable to the queue, but only when it has not been marked yet.
* When adding it to the queue, the collectable will be marked, so subsequent calls
* will not add it again.
void Enqueue(SQCollectable *collectable)
if ((collectable->_uiRef & MARK_FLAG) == 0) {
collectable->_uiRef |= MARK_FLAG;
this->queue.push_front(collectable);
#define ADD_TO_CHAIN(chain,obj) AddToChain(chain,obj)
#define REMOVE_FROM_CHAIN(chain,obj) {if(!(_uiRef&MARK_FLAG))RemoveFromChain(chain,obj);}
#define CHAINABLE_OBJ SQCollectable
#define INIT_CHAIN() {_next=NULL;_prev=NULL;_sharedstate=ss;}
#else
@@ -225,53 +225,62 @@ SQInteger SQSharedState::GetMetaMethodId
return -1;
void SQSharedState::MarkObject(SQObjectPtr &o,SQCollectable **chain)
void SQSharedState::EnqueueMarkObject(SQObjectPtr &o,SQGCMarkerQueue &queue)
switch(type(o)){
case OT_TABLE:_table(o)->Mark(chain);break;
case OT_ARRAY:_array(o)->Mark(chain);break;
case OT_USERDATA:_userdata(o)->Mark(chain);break;
case OT_CLOSURE:_closure(o)->Mark(chain);break;
case OT_NATIVECLOSURE:_nativeclosure(o)->Mark(chain);break;
case OT_GENERATOR:_generator(o)->Mark(chain);break;
case OT_THREAD:_thread(o)->Mark(chain);break;
case OT_CLASS:_class(o)->Mark(chain);break;
case OT_INSTANCE:_instance(o)->Mark(chain);break;
case OT_TABLE:queue.Enqueue(_table(o));break;
case OT_ARRAY:queue.Enqueue(_array(o));break;
case OT_USERDATA:queue.Enqueue(_userdata(o));break;
case OT_CLOSURE:queue.Enqueue(_closure(o));break;
case OT_NATIVECLOSURE:queue.Enqueue(_nativeclosure(o));break;
case OT_GENERATOR:queue.Enqueue(_generator(o));break;
case OT_THREAD:queue.Enqueue(_thread(o));break;
case OT_CLASS:queue.Enqueue(_class(o));break;
case OT_INSTANCE:queue.Enqueue(_instance(o));break;
default: break; //shutup compiler
SQInteger SQSharedState::CollectGarbage(SQVM *vm)
SQInteger n=0;
SQCollectable *tchain=NULL;
SQVM *vms = _thread(_root_vm);
vms->Mark(&tchain);
SQGCMarkerQueue queue;
queue.Enqueue(vms);
#ifdef WITH_ASSERT
SQInteger x = _table(_thread(_root_vm)->_roottable)->CountUsed();
_refs_table.Mark(&tchain);
MarkObject(_registry,&tchain);
MarkObject(_consts,&tchain);
MarkObject(_metamethodsmap,&tchain);
MarkObject(_table_default_delegate,&tchain);
MarkObject(_array_default_delegate,&tchain);
MarkObject(_string_default_delegate,&tchain);
MarkObject(_number_default_delegate,&tchain);
MarkObject(_generator_default_delegate,&tchain);
MarkObject(_thread_default_delegate,&tchain);
MarkObject(_closure_default_delegate,&tchain);
MarkObject(_class_default_delegate,&tchain);
MarkObject(_instance_default_delegate,&tchain);
MarkObject(_weakref_default_delegate,&tchain);
_refs_table.EnqueueMarkObject(queue);
EnqueueMarkObject(_registry,queue);
EnqueueMarkObject(_consts,queue);
EnqueueMarkObject(_metamethodsmap,queue);
EnqueueMarkObject(_table_default_delegate,queue);
EnqueueMarkObject(_array_default_delegate,queue);
EnqueueMarkObject(_string_default_delegate,queue);
EnqueueMarkObject(_number_default_delegate,queue);
EnqueueMarkObject(_generator_default_delegate,queue);
EnqueueMarkObject(_thread_default_delegate,queue);
EnqueueMarkObject(_closure_default_delegate,queue);
EnqueueMarkObject(_class_default_delegate,queue);
EnqueueMarkObject(_instance_default_delegate,queue);
EnqueueMarkObject(_weakref_default_delegate,queue);
while (!queue.IsEmpty()) {
SQCollectable *q = queue.Pop();
q->EnqueueMarkObjectForChildren(queue);
SQCollectable::RemoveFromChain(&_gc_chain, q);
SQCollectable::AddToChain(&tchain, q);
SQCollectable *t = _gc_chain;
SQCollectable *nx = NULL;
if(t) {
t->_uiRef++;
while(t) {
@@ -354,18 +363,18 @@ void RefTable::Finalize()
RefTable::~RefTable()
SQ_FREE(_buckets,(_numofslots * sizeof(RefNode *)) + (_numofslots * sizeof(RefNode)));
void RefTable::Mark(SQCollectable **chain)
void RefTable::EnqueueMarkObject(SQGCMarkerQueue &queue)
RefNode *nodes = (RefNode *)_nodes;
for(SQUnsignedInteger n = 0; n < _numofslots; n++) {
if(type(nodes->obj) != OT_NULL) {
SQSharedState::MarkObject(nodes->obj,chain);
SQSharedState::EnqueueMarkObject(nodes->obj,queue);
nodes++;
@@ -31,13 +31,13 @@ struct RefTable {
RefTable();
~RefTable();
void AddRef(SQObject &obj);
SQBool Release(SQObject &obj);
void EnqueueMarkObject(SQGCMarkerQueue &queue);
private:
RefNode *Get(SQObject &obj,SQHash &mainpos,RefNode **prev,bool add);
RefNode *Add(SQHash mainpos,SQObject &obj);
void Resize(SQUnsignedInteger size);
@@ -60,13 +60,13 @@ struct SQSharedState
~SQSharedState();
SQChar* GetScratchPad(SQInteger size);
SQInteger GetMetaMethodIdxByName(const SQObjectPtr &name);
SQInteger CollectGarbage(SQVM *vm);
static void MarkObject(SQObjectPtr &o,SQCollectable **chain);
static void EnqueueMarkObject(SQObjectPtr &o,SQGCMarkerQueue &queue);
SQObjectPtrVec *_metamethods;
SQObjectPtr _metamethodsmap;
SQObjectPtrVec *_systemstrings;
SQObjectPtrVec *_types;
SQStringTable *_stringtable;
@@ -57,13 +57,13 @@ public:
SetDelegate(NULL);
REMOVE_FROM_CHAIN(&_sharedstate->_gc_chain, this);
for (SQInteger i = 0; i < _numofnodes; i++) _nodes[i].~_HashNode();
SQ_FREE(_nodes, _numofnodes * sizeof(_HashNode));
inline _HashNode *_Get(const SQObjectPtr &key,SQHash hash)
_HashNode *n = &_nodes[hash];
do{
if(_rawval(n->key) == _rawval(key) && type(n->key) == type(key)){
@@ -15,13 +15,13 @@ struct SQUserData : SQDelegable
SQUserData* ud = (SQUserData*)SQ_MALLOC(sizeof(SQUserData)+(size-1));
new (ud) SQUserData(ss, size);
return ud;
void Finalize(){SetDelegate(NULL);}
if (_hook) _hook(_val,_size);
SQInteger tsize = _size - 1;
this->~SQUserData();
@@ -110,13 +110,13 @@ public:
void ClearStack(SQInteger last_top);
#ifdef _DEBUG_DUMP
void dumpstack(SQInteger stackbase=-1, bool dumpall = false);
void GrowCallStack() {
SQInteger newsize = _alloccallsstacksize*2;
_callstackdata.resize(newsize);
_callsstack = &_callstackdata[0];
Status change: