memblock Class Reference

Collaboration diagram for memblock:

[legend]

List of all members.

Public Member Functions
	~memblock ()
chunkinfo &	chunk (int i)
char *	safety (int i)
void *	data (int i)
	memblock (tMemManager *man)
void *	Alloc (tAllocationInfo const &info)
void	Check ()
Static Public Member Functions
static memblock *	Dispose (void *p, int &size, tAllocationInfo const &info, bool keep=false)
static memblock *	create (tMemManager *man)
static void	destroy (memblock *b)
Public Attributes
int	value
int	hID
tMemManager *	myman
int	size
unsigned char	first_free

---

Detailed Description

Definition at line 290 of file tMemManager.cpp.

---

Constructor & Destructor Documentation

memblock::~memblock

(

)

[inline]

Definition at line 303 of file tMemManager.cpp.

References tMemManager::blocks, hID, myman, and tList< T, MALLOC, REFERENCE >::Remove().

Referenced by destroy().

               {
        if (myman) myman->blocks.Remove(this,hID);
        //tASSERT(myman->blocksize == value);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

memblock::memblock

(

tMemManager *

man

)

[inline]

Definition at line 330 of file tMemManager.cpp.

References tList< T, MALLOC, REFERENCE >::Add(), tMemManager::blocks, tMemManager::blocksize, Check(), chunk(), first_free, hID, myman, chunkinfo::next, chunkinfo::occupied, PAD, chunkinfo::pos, chunkinfo::prev, safety(), SAFETYBYTES, tMemManager::size, size, and chunkinfo::size_in_dwords.

Referenced by create().

                              :value(man->blocksize),hID(-1),myman(man){
        //    std::cout << "new memblock..\n";
        size=man->size;
        myman->blocks.Add(this,hID);

        // TODO: init linked list

        for (int i=man->blocksize-1 ; i>=0 ; i--){
            if (i<man->blocksize-1)
                chunk(i).next=i+2;
            else
                chunk(i).next=0;

            if (i>0)
                chunk(i).prev=i;
            else
                chunk(i).prev=0;

            chunk(i).pos = i;
            chunk(i).occupied = false;
            chunk(i).size_in_dwords = size >> 2;

            for (int j=SAFETYBYTES-1;j>=0;j--)
                safety(i)[j]=(j ^ PAD);
        }

#ifdef MEM_DEB
        Check();
#endif

        first_free=1;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

---

Member Function Documentation

chunkinfo& memblock::chunk

(

int

i

)

[inline]

Definition at line 308 of file tMemManager.cpp.

References SAFETYBYTES, size, and tASSERT.

Referenced by Alloc(), Check(), Dispose(), and memblock().

                            {
        tASSERT(i>=0 && i<myman->blocksize);
        return *(
                   (chunkinfo *)(void *)
                   ( ( (char *)(this+1) )+(sizeof(chunkinfo)+size+SAFETYBYTES)*i)
               );
    }

Here is the caller graph for this function:

char* memblock::safety

(

int

i

)

[inline]

Definition at line 316 of file tMemManager.cpp.

References SAFETYBYTES, size, and tASSERT.

Referenced by Check(), and memblock().

                        {
        tASSERT(i>=0 && i<myman->blocksize);
        return (
                   ( ( (char *)(this+1) )+(sizeof(chunkinfo)+size+SAFETYBYTES)*i)
                   +sizeof(chunkinfo)+size );
    }

Here is the caller graph for this function:

void* memblock::data

(

int

i

)

[inline]

Definition at line 323 of file tMemManager.cpp.

References SAFETYBYTES, size, and tASSERT.

Referenced by Alloc().

                      {
        tASSERT(i>=0 && i<myman->blocksize);
        return  (void *)
                ( ( (char *)(this+1) )+(sizeof(chunkinfo)+size+SAFETYBYTES)*i + sizeof(chunkinfo));
    }

Here is the caller graph for this function:

void* memblock::Alloc

(

tAllocationInfo const &

info

)

[inline]

Definition at line 364 of file tMemManager.cpp.

References Check(), chunk(), data(), first_free, chunkinfo::next, NULL, chunkinfo::occupied, chunkinfo::prev, size, st_Breakpoint(), tASSERT, value, and wmemset().

Referenced by tMemManager::Alloc().

                                               {
#ifdef MEM_DEB_SMALL
        Check();
#endif


        tASSERT(value>0);
        value--;

        // TODO: faster using linked list

        int ret=-1;
        /*
          for (int i=myman->blocksize-1 ; i>=0 ; i--)
          if (!chunk(i).occupied){
          //      chunk(i).occupied=true;
          ret=i;
          i=-1;
          //  return data(i);
          }*/


        ret=first_free-1;
        tASSERT(ret>=0);
        // tASSERT(_CrtCheckMemory());

        chunk(ret).occupied=true;
        first_free=chunk(ret).next;
        //  tASSERT(_CrtCheckMemory());
        if (first_free>0) chunk(first_free-1).prev=0;

        chunk(ret).next=chunk(ret).prev=0;
        //   tASSERT(_CrtCheckMemory());

#ifdef LEAKFINDER
        if (info.checksum >= 0){
            tASSERT(info.checksum < MAXCHECKSUM);

#ifdef PROFILER
            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]+=size;
            chunk(ret).realSize = size;
#endif
            chunk(ret).array=info.array;
            chunk(ret).checksum=info.checksum;
            chunk(ret).counter =++counter[info.checksum];

            static int count =0;
            if (checkleaks && counter[info.checksum] == leaks[info.checksum]){
                count ++;
                if (count <= 0)
                {
                    std::cerr << "one of the endless ignored objects that were leaky last time created!\n";
                }
                else if (count <= 1)
                {
                    std::cerr << "Object that was leaky last time created!\n";
                    st_Breakpoint();
                }
                else if (count <= 3)
                {
                    std::cerr << "One more object that was leaky last time created!\n";
                    st_Breakpoint();
                }
                else
                {
                    std::cerr << "one of the endless objects that were leaky last time created!\n";
                    //      st_Breakpoint();
                }
            }
        }
#endif

#ifdef LEAKFINDER
#ifdef PROFILER
        chunk(ret).realSize = size;
#endif
        chunk(ret).array=info.array;
        chunk(ret).checksum=info.checksum;
#endif

#ifdef DEBUG
        wmemset(static_cast< wchar_t * >( data(ret) ), wchar_t(0xfedabeef), size / sizeof( wchar_t ));
#else
        wmemset(static_cast< wchar_t * >( data(ret) ), 0, size / sizeof( wchar_t ));
#endif

#ifdef MEM_DEB_SMALL
        Check();
#endif

        return data(ret);

        tASSERT(0); // we should never get here
        return NULL;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

static memblock* memblock::Dispose	(	void *	p,
		int &	size,
		tAllocationInfo const &	info,
		bool	keep = false
	)			[inline, static]

Definition at line 466 of file tMemManager.cpp.

References tMemManager::blocksize, c, chunk(), first_free, free, myman, chunkinfo::next, NULL, chunkinfo::occupied, chunkinfo::pos, chunkinfo::prev, SAFETYBYTES, chunkinfo::size_in_dwords, tASSERT, value, and wmemset().

Referenced by tMemManager::Dispose().

                                                                                                {
        chunkinfo &c=((chunkinfo *)p)[-1];
        size=c.size_in_dwords*4;

#ifdef PROFILER
        if (c.checksum >=0 && c.checksum < MAXCHECKSUM){
            checksum_blocks[c.checksum]--;
            checksum_bytes [c.checksum]-=c.realSize;
        }
#else
#ifdef LEAKFINDER
        tASSERT(c.checksum>=-1 && c.checksum < MAXCHECKSUM);
#endif
#endif

#ifndef WIN32 // grr. on windows, this assertion fails on calls from STL.
        tASSERT( c.array == info.array );
#endif

        if (size==0){
            bool o = c.occupied;
            // tASSERT(c.occupied);
            c.occupied=false;
            if (o) free(&c);
            return NULL;
        }

        tASSERT(c.occupied == 1);
        if (!c.occupied)
            return NULL;

#ifdef DEBUG
        wmemset(static_cast< wchar_t * >( p ), wchar_t(0xbadf00d), size / sizeof( wchar_t ));
#else
        wmemset(static_cast< wchar_t * >( p ), 0, size / sizeof( wchar_t ) );
#endif

        memblock *myblock=(
                              (memblock *)(void *)
                              (
                                  ( (char *)(void *)p ) -
                                  ( (sizeof(chunkinfo)+size+SAFETYBYTES)*c.pos
                                    + sizeof(chunkinfo) )
                              ) ) - 1;

        c.occupied=false;



#ifndef DOUBLEFREEFINDER
        if (keep)
            return NULL;

#ifdef WIN32
        EnterCriticalSection(&mutex);
#endif

        tASSERT(myblock -> value < myblock->myman->blocksize);
        c.prev=0;
        c.next=myblock->first_free;
        myblock->first_free=c.pos+1;
        if (c.next)   myblock->chunk(c.next-1).prev=c.pos+1;

        myblock->value++;
#endif

        // TODO:  use linked list
        return myblock;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

static memblock* memblock::create

(

tMemManager *

man

)

[inline, static]

Definition at line 536 of file tMemManager.cpp.

References tMemManager::blocksize, malloc, memblock(), SAFETYBYTES, and tMemManager::size.

Referenced by tMemManager::Alloc().

                                              {
        //tASSERT(_CrtCheckMemory());
        void *mem = malloc(man->blocksize * (SAFETYBYTES + man->size + sizeof(chunkinfo))
                           + sizeof(memblock));
        //  tASSERT(_CrtCheckMemory());
        return new(mem) memblock(man);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

static void memblock::destroy

(

memblock *

b

)

[inline, static]

Definition at line 544 of file tMemManager.cpp.

References free, and ~memblock().

Referenced by tMemManager::~tMemManager().

                                     {
        b->~memblock();
        free((void *)b);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

void memblock::Check

(

)

[inline]

Definition at line 549 of file tMemManager.cpp.

References a, b, tMemManager::blocksize, chunk(), myman, PAD, pos, safety(), SAFETYBYTES, tMemManager::size, size, tASSERT, and value.

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

                 {
#ifdef DEBUG
        tASSERT (size == myman->size);

        tASSERT (value >=0);
        tASSERT (value <= myman->blocksize);

        for(int i=myman->blocksize-1;i>=0;i--){
            tASSERT(chunk(i).pos == i);

            for (int j=SAFETYBYTES-1;j>=0;j--){
                char a=safety(i)[j];
                char b=j^PAD;
                tASSERT(a==b);
            }
        }
#endif
    }

Here is the call graph for this function:

Here is the caller graph for this function:

---

Member Data Documentation

int memblock::value

Definition at line 293 of file tMemManager.cpp.

Referenced by tMemManager::Alloc(), Alloc(), Check(), tMemManager::CheckHeap(), tMemManager::complete_Dispose(), Dispose(), and tMemManager::SwapIf().

int memblock::hID

Definition at line 295 of file tMemManager.cpp.

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

tMemManager* memblock::myman

Definition at line 297 of file tMemManager.cpp.

Referenced by Check(), Dispose(), memblock(), and ~memblock().

int memblock::size

Definition at line 299 of file tMemManager.cpp.

Referenced by tMemManager::Alloc(), Alloc(), Check(), chunk(), data(), memblock(), and safety().

unsigned char memblock::first_free

Definition at line 300 of file tMemManager.cpp.

Referenced by Alloc(), Dispose(), and memblock().

---

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

• src/tools/tMemManager.cpp

---