ROOT::Minuit2::StackAllocator Class Reference

Description

StackAllocator controls the memory allocation/deallocation of Minuit. If MN_NO_THREAD_SAVE is defined, memory is taken from a pre-allocated piece of heap memory which is then used like a stack, otherwise via standard malloc/free. Note that defining MN_NO_THREAD_SAVE makes the code thread- unsave. The gain in performance is mainly for cost-cheap FCN functions.

Definition at line 52 of file StackAllocator.h.

Public Types
enum	{ default_size = 524288 }

Public Member Functions
	StackAllocator ()
	~StackAllocator ()
int	AlignedSize (int nBytes)
void *	Allocate (size_t nBytes)
bool	CheckConsistency ()
void	CheckOverflow (int n)
void	Deallocate (void *p)
int	ReadInt (int offset)
int	ToInt (void *p)
void	WriteInt (int offset, int Value)

Private Attributes
int	fBlockCount
unsigned char *	fStack
int	fStackOffset

Member Enumeration Documentation

anonymous enum

anonymous enum

Enumerator
default_size

Definition at line 57 of file StackAllocator.h.

{default_size = 524288};

Constructor & Destructor Documentation

StackAllocator()

ROOT::Minuit2::StackAllocator::StackAllocator ( )

inline

Definition at line 59 of file StackAllocator.h.

                    :   fStack(0)  {
#ifdef _MN_NO_THREAD_SAVE_
    //std::cout<<"StackAllocator Allocate "<<default_size<<std::endl;
    fStack = new unsigned char[default_size];
#endif
    fStackOffset = 0;
    fBlockCount = 0;
  }

References default_size, fBlockCount, fStack, and fStackOffset.

~StackAllocator()

ROOT::Minuit2::StackAllocator::~StackAllocator ( )

inline

Definition at line 68 of file StackAllocator.h.

                    {
#ifdef _MN_NO_THREAD_SAVE_
    //std::cout<<"StackAllocator destruct "<<fStackOffset<<std::endl;
    if(fStack) delete [] fStack;
#endif
  }

References fStack.

Member Function Documentation

AlignedSize()

int ROOT::Minuit2::StackAllocator::AlignedSize ( int  nBytes )

inline

Definition at line 158 of file StackAllocator.h.

                               {
      const int fAlignment = 4;
      int needed = nBytes % fAlignment == 0 ? nBytes : (nBytes/fAlignment+1)*fAlignment;
      return needed + 2*sizeof(int);
  }

Referenced by Allocate().

Allocate()

void* ROOT::Minuit2::StackAllocator::Allocate ( size_t  nBytes )

inline

Definition at line 75 of file StackAllocator.h.

                                 {
#ifdef _MN_NO_THREAD_SAVE_
    if(fStack == 0) fStack = new unsigned char[default_size];
      int nAlloc = AlignedSize(nBytes);
      CheckOverflow(nAlloc);
 
//       std::cout << "Allocating " << nAlloc << " bytes, requested = " << nBytes << std::endl;
 
      // write the start position of the next block at the start of the block
      WriteInt( fStackOffset, fStackOffset+nAlloc);
      // write the start position of the new block at the end of the block
      WriteInt( fStackOffset + nAlloc - sizeof(int), fStackOffset);
 
      void* result = fStack + fStackOffset + sizeof(int);
      fStackOffset += nAlloc;
      fBlockCount++;
 
#ifdef DEBUG_ALLOCATOR
      CheckConsistency();
#endif
 
#else
      void* result = malloc(nBytes);
      if (!result) throw std::bad_alloc();
#endif
 
      return result;
  }

References AlignedSize(), CheckConsistency(), CheckOverflow(), default_size, fBlockCount, fStack, fStackOffset, and WriteInt().

Referenced by ROOT::Minuit2::BasicFunctionGradient::operator new(), ROOT::Minuit2::BasicFunctionMinimum::operator new(), ROOT::Minuit2::BasicMinimumError::operator new(), ROOT::Minuit2::BasicMinimumParameters::operator new(), ROOT::Minuit2::BasicMinimumSeed::operator new(), ROOT::Minuit2::BasicMinimumState::operator new(), ROOT::Minuit2::MnReferenceCounter::operator new(), ROOT::Minuit2::LASymMatrix::operator=(), and ROOT::Minuit2::LAVector::operator=().

Here is the call graph for this function:

CheckConsistency()

bool ROOT::Minuit2::StackAllocator::CheckConsistency ( )

inline

Definition at line 171 of file StackAllocator.h.

                          {
 
    //std::cout << "checking consistency for " << fBlockCount << " blocks"<< std::endl;
 
      // loop over all blocks
      int beg = 0;
      int end = fStackOffset;
      int nblocks = 0;
      while (beg < fStackOffset) {
         end = ReadInt( beg);
 
         // std::cout << "beg = " << beg << " end = " << end
         //     << " fStackOffset = " << fStackOffset << std::endl;
 
         int beg2 = ReadInt( end - sizeof(int));
         if ( beg != beg2) {
            //std::cout << "  beg != beg2 " << std::endl;
            return false;
         }
         nblocks++;
         beg = end;
      }
     if (end != fStackOffset) {
        //std::cout << " end != fStackOffset" << std::endl;
        return false;
     }
     if (nblocks != fBlockCount) {
        //std::cout << "nblocks != fBlockCount" << std::endl;
        return false;
     }
     //std::cout << "Allocator is in consistent state, nblocks = " << nblocks << std::endl;
     return true;
  }

References fBlockCount, fStackOffset, and ReadInt().

Referenced by Allocate(), and Deallocate().

Here is the call graph for this function:

CheckOverflow()

void ROOT::Minuit2::StackAllocator::CheckOverflow ( int  n )

inline

Definition at line 164 of file StackAllocator.h.

                             {
      if (fStackOffset + n >= default_size) {
         //std::cout << " no more space on stack allocator" << std::endl;
         throw StackOverflow();
      }
  }

References default_size, and fStackOffset.

Referenced by Allocate().

Deallocate()

void ROOT::Minuit2::StackAllocator::Deallocate ( void *  p )

inline

Definition at line 104 of file StackAllocator.h.

                            {
#ifdef _MN_NO_THREAD_SAVE_
      // int previousOffset = ReadInt( fStackOffset - sizeof(int));
      int delBlock = ToInt(p);
      int nextBlock = ReadInt( delBlock);
      int previousBlock = ReadInt( nextBlock - sizeof(int));
      if ( nextBlock == fStackOffset) {
          // deallocating last allocated
         fStackOffset = previousBlock;
      }
      else {
          // overwrite previous adr of next block
         int nextNextBlock = ReadInt(nextBlock);
         WriteInt( nextNextBlock - sizeof(int), previousBlock);
         // overwrite head of deleted block
         WriteInt( previousBlock, nextNextBlock);
      }
      fBlockCount--;
 
#ifdef DEBUG_ALLOCATOR
      CheckConsistency();
#endif
#else
      free(p);
#endif
      // std::cout << "Block at " << delBlock
      //   << " deallocated, fStackOffset = " << fStackOffset << std::endl;
  }

References CheckConsistency(), fBlockCount, fStackOffset, ReadInt(), ToInt(), and WriteInt().

Referenced by ROOT::Minuit2::LASymMatrix::~LASymMatrix(), ROOT::Minuit2::LAVector::~LAVector(), ROOT::Minuit2::BasicFunctionGradient::operator delete(), ROOT::Minuit2::BasicFunctionMinimum::operator delete(), ROOT::Minuit2::BasicMinimumError::operator delete(), ROOT::Minuit2::BasicMinimumParameters::operator delete(), ROOT::Minuit2::BasicMinimumSeed::operator delete(), ROOT::Minuit2::BasicMinimumState::operator delete(), and ROOT::Minuit2::MnReferenceCounter::operator delete().

Here is the call graph for this function:

ReadInt()

int ROOT::Minuit2::StackAllocator::ReadInt ( int  offset )

inline

Definition at line 133 of file StackAllocator.h.

                           {
      int* ip = (int*)(fStack+offset);
 
      // std::cout << "read " << *ip << " from offset " << offset << std::endl;
 
      return *ip;
  }

References fStack.

Referenced by CheckConsistency(), and Deallocate().

ToInt()

int ROOT::Minuit2::StackAllocator::ToInt ( void *  p )

inline

Definition at line 149 of file StackAllocator.h.

                      {
      unsigned char* pc = static_cast<unsigned char*>(p);
 
     // std::cout << "toInt: p = " << p << " fStack = " << (void*) fStack << std::endl;
     // VC 7.1 warning:conversin from __w64 int to int
      int userBlock = pc - fStack;
      return userBlock - sizeof(int); // correct for starting int
  }

References fStack.

Referenced by Deallocate().

WriteInt()

void ROOT::Minuit2::StackAllocator::WriteInt ( int  offset, int  Value  )

inline

Definition at line 141 of file StackAllocator.h.

                                        {
 
      // std::cout << "writing " << Value << " to offset " << offset << std::endl;
 
      int* ip = reinterpret_cast<int*>(fStack+offset);
      *ip = Value;
  }

References fStack.

Referenced by Allocate(), and Deallocate().

Member Data Documentation

fBlockCount

int ROOT::Minuit2::StackAllocator::fBlockCount

private

Definition at line 210 of file StackAllocator.h.

Referenced by StackAllocator(), Allocate(), CheckConsistency(), and Deallocate().

fStack

unsigned char* ROOT::Minuit2::StackAllocator::fStack

private

Definition at line 207 of file StackAllocator.h.

Referenced by StackAllocator(), ~StackAllocator(), Allocate(), ReadInt(), ToInt(), and WriteInt().

fStackOffset

int ROOT::Minuit2::StackAllocator::fStackOffset

private

Definition at line 209 of file StackAllocator.h.

Referenced by StackAllocator(), Allocate(), CheckConsistency(), CheckOverflow(), and Deallocate().

---

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

• /home/build/builds/o5h8MZZm/0/mlz/bornagain/Fit/3rdparty/RootMinimizers/Minuit2/StackAllocator.h