Minisat::RegionAllocator< T > Class Template Reference

#include <Alloc.h>

Public Types
enum	{ Ref_Undef = UINT32_MAX }
enum	{ Unit_Size = sizeof(uint32_t) }
typedef uint32_t	Ref

Public Member Functions
	RegionAllocator (uint32_t start_cap=1024 *1024)
	~RegionAllocator ()
uint32_t	size () const
uint32_t	wasted () const
Ref	alloc (int size)
void	_free (int size)
T &	operator[] (Ref r)
const T &	operator[] (Ref r) const
T *	lea (Ref r)
const T *	lea (Ref r) const
Ref	ael (const T *t)
void	moveTo (RegionAllocator &to)

Private Member Functions
void	capacity (uint32_t min_cap)

Private Attributes
T *	memory
uint32_t	sz
uint32_t	cap
uint32_t	wasted_

Detailed Description

template<class T>
class Minisat::RegionAllocator< T >

Definition at line 33 of file Alloc.h.

Member Typedef Documentation

template<class T>

typedef uint32_t Minisat::RegionAllocator< T >::Ref

Definition at line 44 of file Alloc.h.

Member Enumeration Documentation

template<class T>

anonymous enum

Enumerator
Ref_Undef

Definition at line 45 of file Alloc.h.

{ Ref_Undef = UINT32_MAX };

template<class T>

anonymous enum

Enumerator
Unit_Size

Definition at line 46 of file Alloc.h.

{ Unit_Size = sizeof(uint32_t) };

Constructor & Destructor Documentation

template<class T>

Minisat::RegionAllocator< T >::RegionAllocator ( uint32_t  start_cap = 1024*1024 )

inlineexplicit

Definition at line 48 of file Alloc.h.

: memory(NULL), sz(0), cap(0), wasted_(0){ capacity(start_cap); }

template<class T>

Minisat::RegionAllocator< T >::~RegionAllocator ( )

inline

Definition at line 49 of file Alloc.h.

    {
        if (memory != NULL)
            ::free(memory);
    }

Member Function Documentation

template<class T>

void Minisat::RegionAllocator< T >::_free ( int  size )

inline

Definition at line 60 of file Alloc.h.

{ wasted_ += size; }

template<class T>

Ref Minisat::RegionAllocator< T >::ael ( const T *  t )

inline

Definition at line 68 of file Alloc.h.

                                     { assert((void*)t >= (void*)&memory[0] && (void*)t < (void*)&memory[sz-1]);
        return  (Ref)(t - &memory[0]); }

template<class T >

RegionAllocator< T >::Ref Minisat::RegionAllocator< T >::alloc

(

int

size

)

Definition at line 111 of file Alloc.h.

{ 
    // printf("ALLOC called (this = %p, size = %d)\n", this, size); fflush(stdout);
    assert(size > 0);
    capacity(sz + size);

    uint32_t prev_sz = sz;
    sz += size;
    
    // Handle overflow:
    if (sz < prev_sz)
        throw OutOfMemoryException();

    return prev_sz;
}

template<class T >

void Minisat::RegionAllocator< T >::capacity ( uint32_t  min_cap )

private

Definition at line 86 of file Alloc.h.

{
    if (cap >= min_cap) return;

    uint32_t prev_cap = cap;
    while (cap < min_cap){
        // NOTE: Multiply by a factor (13/8) without causing overflow, then add 2 and make the
        // result even by clearing the least significant bit. The resulting sequence of capacities
        // is carefully chosen to hit a maximum capacity that is close to the '2^32-1' limit when
        // using 'uint32_t' as indices so that as much as possible of this space can be used.
        uint32_t delta = ((cap >> 1) + (cap >> 3) + 2) & ~1;
        cap += delta;

        if (cap <= prev_cap)
            throw OutOfMemoryException();
    }
    // printf(" .. (%p) cap = %u\n", this, cap);

    assert(cap > 0);
    memory = (T*)xrealloc(memory, sizeof(T)*cap);
}

template<class T>

T* Minisat::RegionAllocator< T >::lea ( Ref  r )

inline

Definition at line 66 of file Alloc.h.

{ assert(r >= 0 && r < sz); return &memory[r]; }

template<class T>

const T* Minisat::RegionAllocator< T >::lea ( Ref  r ) const

inline

Definition at line 67 of file Alloc.h.

{ assert(r >= 0 && r < sz); return &memory[r]; }

template<class T>

void Minisat::RegionAllocator< T >::moveTo ( RegionAllocator< T > &  to )

inline

Definition at line 71 of file Alloc.h.

                                         {
        if (to.memory != NULL) ::free(to.memory);
        to.memory = memory;
        to.sz = sz;
        to.cap = cap;
        to.wasted_ = wasted_;

        memory = NULL;
        sz = cap = wasted_ = 0;
    }

template<class T>

T& Minisat::RegionAllocator< T >::operator[] ( Ref  r )

inline

Definition at line 63 of file Alloc.h.

{ assert(r >= 0 && r < sz); return memory[r]; }

template<class T>

const T& Minisat::RegionAllocator< T >::operator[] ( Ref  r ) const

inline

Definition at line 64 of file Alloc.h.

{ assert(r >= 0 && r < sz); return memory[r]; }

template<class T>

uint32_t Minisat::RegionAllocator< T >::size ( ) const

inline

Definition at line 56 of file Alloc.h.

{ return sz; }

template<class T>

uint32_t Minisat::RegionAllocator< T >::wasted ( ) const

inline

Definition at line 57 of file Alloc.h.

{ return wasted_; }

Field Documentation

template<class T>

uint32_t Minisat::RegionAllocator< T >::cap

private

Definition at line 37 of file Alloc.h.

template<class T>

T* Minisat::RegionAllocator< T >::memory

private

Definition at line 35 of file Alloc.h.

template<class T>

uint32_t Minisat::RegionAllocator< T >::sz

private

Definition at line 36 of file Alloc.h.

template<class T>

uint32_t Minisat::RegionAllocator< T >::wasted_

private

Definition at line 38 of file Alloc.h.

---

The documentation for this class was generated from the following file:

• Alloc.h