/home/gian/Progetti/falcon/core/include/falcon/mempool.h

Go to the documentation of this file.

/*
   FALCON - The Falcon Programming Language.
   FILE: mempool.h

   garbage basket class
   -------------------------------------------------------------------
   Author: Giancarlo Niccolai
   Begin: Sun, 08 Feb 2009 16:08:50 +0100

   -------------------------------------------------------------------
   (C) Copyright 2009: the FALCON developers (see list in AUTHORS file)

   See LICENSE file for licensing details.
*/

#ifndef FALCON_MEMPOOL_H
#define FALCON_MEMPOOL_H

#include <falcon/setup.h>
#include <falcon/item.h>
#include <falcon/basealloc.h>
#include <falcon/mt.h>
#include <falcon/rampmode.h>

namespace Falcon {

class Garbageable;
class GarbageableBase;
class GarbageLock;

#if 0
class FALCON_DYN_CLASS PoolRing: public BaseAlloc
{
   Garbageable* m_head;

public:
   PoolRing();
   ~PoolRing();

   void add( Garbageable * );
   void transfer( PoolRing *target );
   Garbageable *linearize();
};
#endif

class FALCON_DYN_CLASS MemPool: public Runnable, public BaseAlloc
{

protected:
   size_t m_thresholdNormal;
   size_t m_thresholdActive;

   uint32 m_mingen;

   GarbageableBase *m_garbageRoot;

   GarbageableBase *m_newRoot;

   bool m_bNewReady;

   VMachine *m_olderVM;

   VMachine *m_vmRing;

   int32 m_vmCount;

   VMachine *m_vmIdle_head;
   VMachine *m_vmIdle_tail;

   // for gc
   uint32 m_generation;
   int32 m_allocatedItems;
   uint32 m_allocatedMem;

   SysThread *m_th;
   bool m_bLive;

   Event m_eRequest;
   Mutex m_mtxa;


   mutable Mutex m_mtx_newitem;

   Mutex m_mtx_vms;

   Mutex m_mtx_idlevm;

   mutable Mutex m_mtx_ramp;
   
   mutable Mutex m_mtx_gen;

   RampMode* m_ramp[RAMP_MODE_COUNT];
   RampMode* m_curRampMode;
   int m_curRampID;

   Mutex m_mtxRequest;
   Event m_eGCPerformed;
   bool m_bRequestSweep;

   Mutex m_mtx_lockitem;

   GarbageLock *m_lockRoot;

   uint32 m_lockGen;

   //==================================================
   // Private functions
   //==================================================

   bool markVM( VMachine *vm );
   void gcSweep();

   /*
   To reimplement this, we need to have anti-recursion checks on item, which are
   currently being under consideration. However, I would prefer not to need to
   have this functions back, as they were meant to be used when the memory
   model wasn't complete.

   In other words, I want items to be in garbage as soon as they are created,
   and to exit when they are destroyed.

   void removeFromGarbage( String *ptr );
   void removeFromGarbage( Garbageable *ptr );

   void storeForGarbageDeep( const Item &item );
   void removeFromGarbageDeep( const Item &item );
   */

   void clearRing( GarbageableBase *ringRoot );
   void rollover();
   void remark(uint32 mark);
   void electOlderVM(); // to be called with m_mtx_vms locked

   void promote( uint32 oldgen, uint32 curgen );
   void advanceGeneration( VMachine* vm, uint32 oldGeneration );
   void markLocked();
   
   friend class GarbageLock;
   void addGarbageLock( GarbageLock* lock );
   void removeGarbageLock( GarbageLock* lock );

public:
   enum constants {
      MAX_GENERATION = 0xFFFFFFFE,
      SWEEP_GENERATION = 0xFFFFFFFF
   };

   MemPool();

   virtual ~MemPool();

   void registerVM( VMachine *vm );

   void unregisterVM( VMachine *vm );

   void markItem( const Item &itm );

   int32 allocatedItems() const;

   uint32 generation() const { return m_generation; }
   /*
   void generation( uint32 i );
   uint32 incgen();
   */
   void storeForGarbage( Garbageable *ptr );

   virtual void* run();

   void start();

   void stop();

   void safeArea();

   void unsafeArea();

   void idleVM( VMachine *vm, bool bPrio = false );

   void thresholdNormal( size_t mem ) { m_thresholdNormal = mem; }

   void thresholdActive( size_t mem ) { m_thresholdActive = mem; }

   size_t thresholdNormal() const { return m_thresholdNormal; }

   size_t thresholdActive() const { return m_thresholdActive; }

   bool rampMode( int mode );
   int rampMode() const;
   
   void accountItems( int itemCount );

   void performGC();
};


}

#endif
/* end of mempool.h */

---