tMemManager Class Reference

Collaboration diagram for tMemManager:

[legend]

List of all members.

Public Member Functions
	tMemManager (int size, int blocksize)
	tMemManager (int size)
	~tMemManager ()
void *	Alloc (tAllocationInfo const &info)
void	complete_Dispose (memblock *m)
void	Check ()
Static Public Member Functions
static void *	AllocDefault (tAllocationInfo const &info, size_t size)
static void	Dispose (tAllocationInfo const &info, void *p, bool keep=false)
Private Member Functions
int	Lower (int i)
bool	SwapIf (int i, int j)
void	SwapDown (int j)
void	SwapUp (int i)
void	CheckHeap ()
void	Insert (memblock *b)
void	Remove (memblock *b)
memblock *	Remove (int i)
void	Replace (int i)
void	Replace (memblock *e)
Static Private Member Functions
static int	UpperL (int i)
static int	UpperR (int i)
Private Attributes
int	size
int	blocksize
tList< memblock, true >	blocks
tList< memblock, true >	full_blocks
int	semaphore
Friends
class	memblock

---

Detailed Description

Definition at line 194 of file tMemManager.cpp.

---

Constructor & Destructor Documentation

tMemManager::tMemManager	(	int	size,
		int	blocksize
	)

Definition at line 662 of file tMemManager.cpp.

References blocksize, and semaphore.

                                    :size(s),blocksize(s){
    // std::cout << sizeof(chunkinfo);
    if (blocksize>255)
        blocksize=255;
    semaphore = 1;

    tBottleNeck neck;

#ifdef WIN32
    if (!inited)
        InitializeCriticalSection(&mutex);
#endif

    inited = true;
}

tMemManager::tMemManager

(

int

size

)

Definition at line 678 of file tMemManager.cpp.

References blocks, blocksize, cs, full_blocks, SAFETYBYTES, semaphore, tArray< T, MALLOC >::SetLen(), and size.

                             :size(s){//,blocks(1000),full_blocks(1000){
    tBottleNeck neck;

    inited = false;

    blocks.SetLen(0);
    full_blocks.SetLen(0);
    blocksize=16000/(s+sizeof(chunkinfo)+SAFETYBYTES);
    if (blocksize>252)
        blocksize=252;
    //  std::cout << sizeof(chunkinfo) << ',' << s << ',' << blocksize << '\n';
    semaphore = 1;

#ifdef LEAKFINDER
    if (size == 0){
        for ( int i = MAXCHECKSUM-1; i>=0; --i )
        {
            leaks[i] = 0;
            counter[i] = 0;
#ifdef PROFILER
            checksum_filename[i] = 0;
            checksum_classname[i] = 0;
            checksum_line[i] = 0;
            checksum_blocks[i] = 0;
            checksum_bytes[i] = 0;
#endif
        }

        std::ifstream l(leakname);
        while (l.good() && !l.eof()){
            int cs,ln;
            l >> cs >> ln;

            if (cs>=0 && cs < MAXCHECKSUM && (ln < leaks[cs] || leaks[cs] == 0))
                leaks[cs]=ln;
        }
    }
    if (!inited){
        // delete it
        std::ofstream lw(leakname);
        lw << "\n\n";
    }
#endif

#ifdef WIN32
    if (!inited)
        InitializeCriticalSection(&mutex);
#endif

    inited = true;
}

Here is the call graph for this function:

tMemManager::~tMemManager

(

)

Definition at line 604 of file tMemManager.cpp.

References blocks, blocksize, memblock::destroy(), full_blocks, GrowingArrayBase::Len(), and tMemManBase::Profile().

                         {
#ifdef LEAKFINDER
    bool warn = true;
#ifdef HAVE_LIBZTHREAD
    warn = false;
#endif

    if (inited){
        // l???sche das ding
        std::ofstream lw(leakname);
        lw << "\n\n";
        tMemMan::Profile();
    }
#endif

#ifdef WIN32
    if (inited)
        DeleteCriticalSection(&mutex);
#endif

    inited = false;

    //tASSERT (full_blocks.Len() == 0);
    int i;
    for (i=blocks.Len()-1;i>=0;i--){
        if (blocks(i)->value==blocksize)
            memblock::destroy(blocks(i));
        else{
#ifdef LEAKFINDER
            if ( warn )
            {
                std::cout << "Memmanager warning: leaving block untouched.\n";
                warn = false;
            }
            std::ofstream l(leakname,std::ios::app);
            blocks(i)->dumpleaks(l);
#endif
        }
    }

    for (i=full_blocks.Len()-1;i>=0;i--){
        if (full_blocks(i)->value==blocksize)
            memblock::destroy(full_blocks(i));
        else{
#ifdef LEAKFINDER
            if ( warn )
            {
                std::cout << "Memmanager warning: leaving block untouched.\n";
                warn = false;
            }
            std::ofstream l(leakname,std::ios::app);
            full_blocks(i)->dumpleaks(l);
#endif
        }
    }

}

Here is the call graph for this function:

---

Member Function Documentation

void * tMemManager::Alloc

(

tAllocationInfo const &

info

)

Definition at line 860 of file tMemManager.cpp.

References tList< T, MALLOC, REFERENCE >::Add(), memblock::Alloc(), AllocDefault(), blocks, memblock::create(), full_blocks, memblock::hID, Insert(), GrowingArrayBase::Len(), Remove(), semaphore, memblock::size, size, tASSERT, and memblock::value.

Referenced by tMemMan::Alloc().

                                                       {
    semaphore--;
    if (semaphore<0 || size == 0){
        semaphore++;
        return AllocDefault(info, size);
    }

#ifdef WIN32
    EnterCriticalSection(&mutex);
#endif

    if (blocks.Len()==0) // no free space available. create new block...
        Insert(memblock::create(this));
    //tASSERT(_CrtCheckMemory());

    memblock *block=blocks(0);
    tASSERT (block->size == size);
    void *mem = block->Alloc( info );
    //tASSERT(_CrtCheckMemory());
    if (block->value == 0){
        Remove(block);
        full_blocks.Add(block,block->hID);
    }

#ifdef WIN32
    LeaveCriticalSection(&mutex);
#endif

    semaphore++;
    return mem;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void * tMemManager::AllocDefault	(	tAllocationInfo const &	info,
		size_t	size
	)			[static]

Definition at line 1078 of file tMemManager.cpp.

References malloc.

Referenced by tMemMan::Alloc(), and Alloc().

                                                                     {
#ifdef LEAKFINDER
    void *ret=malloc(s+sizeof(chunkinfo));//,classname,fileName,line);
    ((chunkinfo *)ret)->checksum=info.checksum;
    ((chunkinfo *)ret)->array=info.array;
#ifdef PROFILER
    ((chunkinfo *)ret)->realSize=s;
    if ( info.checksum >= 0 )
    {
        if (!counter[info.checksum]){
            checksum_filename [info.checksum] = info.filename;
            checksum_classname[info.checksum] = info.classname;
            checksum_line     [info.checksum] = info.line;
        }
        checksum_blocks[info.checksum]++;
        checksum_bytes[info.checksum]+=s;
    }
#endif
#else
    void *ret=malloc(s+sizeof(chunkinfo));
#endif
    ((chunkinfo *)ret)->size_in_dwords=0;
    ((chunkinfo *)ret)->occupied=true;
    ret = ((chunkinfo *)ret)+1;
    return ret;

Here is the caller graph for this function:

void tMemManager::Dispose	(	tAllocationInfo const &	info,
		void *	p,
		bool	keep = false
	)			[static]

Definition at line 1059 of file tMemManager.cpp.

References complete_Dispose(), memblock::Dispose(), and size.

                                                                         {
    int size;

    if (!p)
        return;

    memblock *block = memblock::Dispose(p,size,info, keep);
#ifndef DOUBLEFREEFINDER
    if (inited && block){
        tBottleNeck neck;
        memman[size >> 2].complete_Dispose(block);
#ifdef WIN32
        LeaveCriticalSection(&mutex);
#endif
    }
#else
    block = 0;
#endif

Here is the call graph for this function:

void tMemManager::complete_Dispose

(

memblock *

m

)

Definition at line 892 of file tMemManager.cpp.

References memblock::Check(), full_blocks, memblock::hID, Insert(), tList< T, MALLOC, REFERENCE >::Remove(), Replace(), semaphore, and memblock::value.

Referenced by Dispose().

                                                 {
#ifdef MEM_DEB_SMALL
    block->Check();
#endif

    semaphore--;
    if (semaphore>=0){
        if (block->value == 1){
            full_blocks.Remove(block,block->hID);
            Insert(block);
        }
        else{
            Replace(block);
        }
    }
    //else
    // tASSERT(0);
    semaphore++;

#ifdef MEM_DEB_SMALL
    block->Check();
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

void tMemManager::Check

(

)

Definition at line 916 of file tMemManager.cpp.

References blocks, CheckHeap(), full_blocks, GrowingArrayBase::Len(), size, and tASSERT.

                       {
#ifdef DEBUG_EXPENSIVE
    if ( !inited )
        return;

    CheckHeap();
    int i;
    for (i=blocks.Len()-1;i>=0;i--)
    {
        blocks(i)->Check();
        tASSERT (blocks(i)->myman == this);
        tASSERT (blocks(i)->size == size);
    }
    for (i=full_blocks.Len()-1;i>=0;i--)
    {
        if ( full_blocks(i) )
        {
            full_blocks(i)->Check();
            tASSERT (full_blocks(i)->myman == this);
            tASSERT (full_blocks(i)->size == size);
        }
    }
#endif
}

Here is the call graph for this function:

int tMemManager::Lower

(

int

i

)

[inline, private]

Definition at line 208 of file tMemManager.cpp.

Referenced by CheckHeap(), Replace(), and SwapDown().

                     { // the element below i in the heap
        if(i%2==0)  // just to make sure what happens; you never know what 1/2 is..
            return i/2-1;
        else
            return (i-1)/2;
    }

Here is the caller graph for this function:

bool tMemManager::SwapIf	(	int	i,
		int	j
	)			[private]

Definition at line 589 of file tMemManager.cpp.

References blocks, memblock::hID, Swap(), and memblock::value.

Referenced by SwapDown(), and SwapUp().

                                   {
    if (i==j || i<0) return false; // safety

    memblock *e1=blocks(i),*e2=blocks(j);
    if (e1->value > e2->value){
        Swap(blocks(i),blocks(j));
        e1->hID=j;
        e2->hID=i;
        return true;
    }
    else
        return false;

}

Here is the call graph for this function:

Here is the caller graph for this function:

void tMemManager::SwapDown

(

int

j

)

[private]

Definition at line 744 of file tMemManager.cpp.

References CheckHeap(), Lower(), and SwapIf().

Referenced by Insert(), and Replace().

                               {
    int i=j;
    // e is now at position i. swap it down
    // as far as it goes:
    do{
        j=i;
        i=Lower(j);
    }
    while(SwapIf(i,j)); // mean: relies on the fact that SwapIf returns -1
    // if i<0.

#ifdef MEM_DEB
    CheckHeap();
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

void tMemManager::SwapUp

(

int

i

)

[private]

Definition at line 760 of file tMemManager.cpp.

References blocks, CheckHeap(), GrowingArrayBase::Len(), SwapIf(), UpperL(), and UpperR().

Referenced by Replace().

                             {
#ifdef MEM_DEB
    //  static int su=0;
    //if (su%100 ==0 )
    // std::cout << "su=" << su << '\n';
    //  if (su > 11594 )
    // con << "su=" << su << '\n';
    // su ++;
#endif

    int ul,ur;
    bool goon=1;
    while(goon && UpperL(i)<blocks.Len()){
        ul=UpperL(i);
        ur=UpperR(i);
        if(ur>=blocks.Len() ||
                blocks(ul)->value < blocks(ur)->value){
            goon=SwapIf(i,ul);
            i=ul;
        }
        else{
            goon=SwapIf(i,ur);
            i=ur;
        }
    }

#ifdef MEM_DEB
    CheckHeap();
#endif

}

Here is the call graph for this function:

Here is the caller graph for this function:

void tMemManager::CheckHeap

(

)

[private]

Definition at line 731 of file tMemManager.cpp.

References blocks, GrowingArrayBase::Len(), Lower(), tERR_ERROR_INT, UpperL(), UpperR(), and memblock::value.

Referenced by Check(), Insert(), Remove(), Replace(), SwapDown(), and SwapUp().

                           {
    for(int i=blocks.Len()-1;i>0;i--){
        memblock *current=blocks(i);
        memblock *low=blocks(Lower(i));
        if (Lower(UpperL(i))!=i || Lower(UpperR(i))!=i)
            tERR_ERROR_INT("Error in lower/upper " << i << "!");

        if (low->value>current->value)
            tERR_ERROR_INT("Heap structure corrupt!");
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int tMemManager::UpperL

(

int

i

)

[inline, static, private]

Definition at line 226 of file tMemManager.cpp.

Referenced by CheckHeap(), and SwapUp().

{return 2*i+1;} // the elements left and

Here is the caller graph for this function:

static int tMemManager::UpperR

(

int

i

)

[inline, static, private]

Definition at line 227 of file tMemManager.cpp.

Referenced by CheckHeap(), and SwapUp().

{return 2*i+2;} // right above i

Here is the caller graph for this function:

void tMemManager::Insert

(

memblock *

b

)

[private]

Definition at line 792 of file tMemManager.cpp.

References tList< T, MALLOC, REFERENCE >::Add(), blocks, CheckHeap(), memblock::hID, GrowingArrayBase::Len(), and SwapDown().

Referenced by Alloc(), and complete_Dispose().

                                   {
    blocks.Add(e,e->hID); // relies on the implementation of List: e is
    // put to the back of the heap.
    SwapDown(blocks.Len()-1); // bring it to the right place

#ifdef MEM_DEB
    CheckHeap();
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

void tMemManager::Remove

(

memblock *

b

)

[private]

Definition at line 802 of file tMemManager.cpp.

References CheckHeap(), memblock::hID, and tERR_ERROR_INT.

Referenced by Alloc().

                                   {
    int i=e->hID;

    if(i<0 || this != e->myman)
        tERR_ERROR_INT("Element is not in this heap!");

    Remove(i);

#ifdef MEM_DEB
    CheckHeap();
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

memblock * tMemManager::Remove

(

int

i

)

[private]

Definition at line 841 of file tMemManager.cpp.

References blocks, CheckHeap(), memblock::hID, GrowingArrayBase::Len(), NULL, tList< T, MALLOC, REFERENCE >::Remove(), and Replace().

                                   {
    if (i>=0 && i<blocks.Len()){
        memblock *ret=blocks(i);

        blocks.Remove(ret,ret->hID);

        // now we have an misplaced element at pos i. (if i was not at the end..)
        if (i<blocks.Len())
            Replace(i);

#ifdef MEM_DEB
        CheckHeap();
#endif

        return ret;
    }
    return NULL;
}

Here is the call graph for this function:

void tMemManager::Replace

(

int

i

)

[private]

Definition at line 815 of file tMemManager.cpp.

References blocks, CheckHeap(), GrowingArrayBase::Len(), Lower(), SwapDown(), and SwapUp().

Referenced by complete_Dispose(), Remove(), and Replace().

                              {
    if (i>=0 && i < blocks.Len()){
        if (i==0 || blocks(i)->value > blocks(Lower(i))->value)
            SwapUp(i);          // put it up where it belongs
        else
            SwapDown(i);

#ifdef MEM_DEB
        CheckHeap();
#endif
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void tMemManager::Replace

(

memblock *

e

)

[private]

Definition at line 828 of file tMemManager.cpp.

References CheckHeap(), memblock::hID, Replace(), and tERR_ERROR_INT.

                                    {
    int i=e->hID;

    if(i<0 || this != e->myman)
        tERR_ERROR_INT("Element is not in this heap!");

    Replace(i);

#ifdef MEM_DEB
    CheckHeap();
#endif
}

Here is the call graph for this function:

---

Friends And Related Function Documentation

friend class memblock [friend]

Definition at line 195 of file tMemManager.cpp.

---

Member Data Documentation

int tMemManager::size [private]

Definition at line 237 of file tMemManager.cpp.

Referenced by Alloc(), Check(), memblock::Check(), memblock::create(), Dispose(), memblock::memblock(), and tMemManager().

int tMemManager::blocksize [private]

Definition at line 238 of file tMemManager.cpp.

Referenced by memblock::Check(), memblock::create(), memblock::Dispose(), memblock::memblock(), tMemManager(), and ~tMemManager().

tList<memblock, true> tMemManager::blocks [private]

Definition at line 240 of file tMemManager.cpp.

Referenced by Alloc(), Check(), CheckHeap(), Insert(), memblock::memblock(), Remove(), Replace(), SwapIf(), SwapUp(), tMemManager(), memblock::~memblock(), and ~tMemManager().

tList<memblock, true> tMemManager::full_blocks [private]

Definition at line 241 of file tMemManager.cpp.

Referenced by Alloc(), Check(), complete_Dispose(), tMemManager(), and ~tMemManager().

int tMemManager::semaphore [private]

Definition at line 243 of file tMemManager.cpp.

Referenced by Alloc(), complete_Dispose(), and tMemManager().

---

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

• src/tools/tMemManager.cpp

---