flx_gc.hpp

#line 80 "./lpsrc/flx_gc.pak"
#ifndef __FLX_GC_H__
#define __FLX_GC_H__

#include <cstdlib>
#include "flx_gc_config.hpp"

// we use an STL set to hold the collection of roots
#include <set>

namespace flx {
namespace gc {
namespace generic {
// Here are the types we refer to:

struct GC_EXTERN gc_shape_t;   // the shape of collectable objects
struct GC_EXTERN collector_t;  // the collector itself
struct GC_EXTERN allocator_t;  // the collector itself

enum gc_shape_flags_t {
  gc_flags_default    = 0,            //< collectable and mobile
  gc_flags_immobile   = 1,            //< cannot be moved
  gc_flags_persistent = 2             //< cannot be deallocated
};

/// Describes runtime object shape.
struct GC_EXTERN gc_shape_t
{
  gc_shape_t *next_shape;         ///< pointer to next shape in list or NULL
  char const *cname;              ///< C++ typename
  std::size_t count;              ///< array element count
  std::size_t amt;                ///< bytes allocated
  void (*finaliser)(collector_t*, void*);  ///< finalisation function
  std::size_t n_offsets;          ///< number of offsets
  std::size_t *offsets;           ///< actual offsets
  gc_shape_flags_t flags;         ///< flags
};
#line 140 "./lpsrc/flx_gc.pak"
template<class T>
void std_finaliser(collector_t*, void *t)
{
  static_cast<T*>(t) -> ~T();
}

#line 149 "./lpsrc/flx_gc.pak"

/// Allocator abstraction.

struct allocator_t {
  bool debug;
  allocator_t():debug(false){}
  virtual void *allocate(std::size_t)=0;
  virtual void deallocate(void *)=0;
  virtual void *reallocate(void *, std::size_t)=0;
  virtual ~allocator_t(){};
  void set_debug(bool d){debug=d;}
};

#line 165 "./lpsrc/flx_gc.pak"

/// Collector abstraction.
struct GC_EXTERN collector_t
{
  bool debug;
  void set_debug(bool d){debug=d;}
  collector_t();
  virtual ~collector_t(){}

#line 177 "./lpsrc/flx_gc.pak"
  unsigned long get_allocation_count()const {
    return v_get_allocation_count();
  }

  unsigned long get_root_count()const {
    return v_get_root_count();
  }

  unsigned long get_allocation_amt()const {
    return v_get_allocation_amt();
  }

#line 193 "./lpsrc/flx_gc.pak"
  void *allocate(gc_shape_t *shape, unsigned long x) {
    return v_allocate(shape,x);
  }

#line 200 "./lpsrc/flx_gc.pak"
  unsigned long collect() {
    return v_collect();
  }

#line 207 "./lpsrc/flx_gc.pak"
  void add_root(void *memory) {
    v_add_root(memory);
  }

  void remove_root(void *memory) {
    v_remove_root(memory);
  }

  void finalise(void *frame) {
    v_finalise(frame);
  }

#line 222 "./lpsrc/flx_gc.pak"
  //array management
  virtual void set_used(void *memory, unsigned long)=0;
  virtual void incr_used(void *memory, unsigned long)=0;
  virtual unsigned long get_used(void *memory)=0;
  virtual unsigned long get_count(void *memory)=0;
  virtual void *create_empty_array( gc_shape_t &shape, unsigned long count)=0;
private:
  virtual unsigned long v_get_allocation_count()const=0;
  virtual unsigned long v_get_root_count()const=0;
  virtual unsigned long v_get_allocation_amt()const=0;
  virtual void *v_allocate(gc_shape_t *shape, unsigned long)=0;
  virtual void v_finalise(void *fp)=0;
  virtual unsigned long v_collect()=0;
  virtual void v_add_root(void *memory)=0;
  virtual void v_remove_root(void *memory)=0;

#line 242 "./lpsrc/flx_gc.pak"
  void operator=(collector_t const&);
  collector_t(collector_t const&);
};


#line 248 "./lpsrc/flx_gc.pak"

}}} // end namespaces

#line 261 "./lpsrc/flx_gc.pak"
/// Allocate collectable object
GC_EXTERN void *operator new
(
  std::size_t,
  flx::gc::generic::collector_t &,
  flx::gc::generic::gc_shape_t &
);
#endif

---