usermode/library/malloc-hoard-old/src/persistentheap.cpp

#include <mnemosyne.h>
#include <stdint.h>
#include <sys/mman.h>
#include "config.h"
#include "threadheap.h"
#include "persistentheap.h"
#include "persistentsuperblock.h"

MNEMOSYNE_PERSISTENT void *psegmentheader = 0;
MNEMOSYNE_PERSISTENT void *psegment = 0;

persistentHeap::persistentHeap (void)
  : _buffer (NULL),
    _bufferCount (0)
{
        int                  i;
        persistentSuperblock *psb;

        // Format persistent heap; this happens only the first time 
        // the heap is ever incarnated
        format();
        scavenge();
        
        // Initialize some logically non-persistent information 
        // FIXME: This should really be implemented as a volatile index to avoid writing PCM
        for(i=0; i<PERSISTENTSUPERBLOCK_NUM; i++) { 
                psb = (persistentSuperblock *) ((uintptr_t) psegmentheader + i*sizeof(persistentSuperblock));
                psb->volatileInit();
        }       
}


void persistentHeap::format()
{
        int   i;
        void  *b;
        void  *buf;

        assert((!psegmentheader && !psegment) || (psegmentheader && psegment));

        if (!psegmentheader) {
                psegmentheader = m_pmap((void *) PERSISTENTHEAP_HEADER_BASE, PERSISTENTSUPERBLOCK_NUM*sizeof(persistentSuperblock), PROT_READ|PROT_WRITE, 0);
                psegment = m_pmap((void *)PERSISTENTHEAP_BASE, persistentSuperblock::PERSISTENTSUPERBLOCK_SIZE * PERSISTENTSUPERBLOCK_NUM, PROT_READ|PROT_WRITE, 0);
                for(i=0; i<PERSISTENTSUPERBLOCK_NUM; i++) { 
                        b = (void *) ((uintptr_t) psegmentheader + i*sizeof(persistentSuperblock));
                        buf = (void *) ((uintptr_t) psegment + i*persistentSuperblock::PERSISTENTSUPERBLOCK_SIZE);
                        new(b) persistentSuperblock((char *)buf);
                }
                _psegmentBase = psegment;
        }
}


// For every persistent superblock create a superblock that higher layers can use
void persistentHeap::scavenge()
{
        int                  i;
        int                  sizeclass;
        int                  blksize;
        persistentSuperblock *psb;
        superblock           *sb;

        for(i=0; i<PERSISTENTSUPERBLOCK_NUM; i++) { 
                psb = (persistentSuperblock *) ((uintptr_t) psegmentheader + i*sizeof(persistentSuperblock));
                blksize = psb->getBlockSize();
                sizeclass = sizeClass(blksize);
                sb = superblock::makeSuperblock (psb);
                insertSuperblock (sizeclass, sb, (persistentHeap *) NULL);
#if 0
                std::cout << "psb: " << psb << std::endl;
                std::cout << "  ->fullness : " << psb->getFullness() << std::endl;
                std::cout << "  ->isFree   : " << psb->isFree() << std::endl;
                std::cout << "  ->sizeClass: " << sizeclass << std::endl;
                std::cout << "  ->blksize: " << blksize << std::endl;
                std::cout << "sb: " << sb << std::endl;
                std::cout << "  ->numBlocks: " << sb->getNumBlocks() << std::endl;
                std::cout << "  ->numAvailable: " << sb->getNumAvailable() << std::endl;
#endif          
        }       
}


// Print out statistics information.
void persistentHeap::stats (void) {
}



// free (ptr, pheap):
//   inputs: a pointer to an object allocated by malloc().
//   side effects: returns the block to the object's superblock;
//                 updates the thread heap's statistics;
//                 may release the superblock to the process heap.

void persistentHeap::free (void * ptr)
{
  // Return if ptr is 0.
  // This is the behavior prescribed by the standard.
  if (ptr == 0) {
    return;
  }

  // Find the block and superblock corresponding to this ptr.

  uintptr_t psb_index = ((uintptr_t) ptr - (uintptr_t) psegment) / persistentSuperblock::PERSISTENTSUPERBLOCK_SIZE;
  persistentSuperblock *psb = (persistentSuperblock *) ((uintptr_t) psegmentheader + psb_index * sizeof(persistentSuperblock));
  int blksize = psb->getBlockSize();
  uintptr_t block_index = (((uintptr_t) ptr - (uintptr_t) psegment) % persistentSuperblock::PERSISTENTSUPERBLOCK_SIZE) / blksize;
  superblock *sb = psb->getSuperblock();
  //std::cout << "block_index = " << block_index << std::endl;
  //std::cout << "psb = " << psb << std::endl;
  //std::cout << "1.sb = " << sb << std::endl;
  assert (sb);
  assert (sb->isValid());
  block *b = sb->getBlock(block_index);
  //std::cout << "2.sb = " << sb << std::endl;

  // Check to see if this block came from a memalign() call.
  // TODO: Currently we don't support memalign()

  b->markFree();

  assert (sb == b->getSuperblock());
  assert (sb);
  assert (sb->isValid());

  //std::cout << sb << std::endl;
  const int sizeclass = sb->getBlockSizeClass();

  //
  // Return the block to the superblock,
  // find the heap that owns this superblock
  // and update its statistics.
  //

  hoardHeap * owner;

  // By acquiring the up lock on the superblock,
  // we prevent it from moving to the global heap.
  // This eventually pins it down in one heap,
  // so this loop is guaranteed to terminate.
  // (It should generally take no more than two iterations.)
  sb->upLock();
  for (;;) {
    owner = sb->getOwner();
    owner->lock();
    if (owner == sb->getOwner()) {
      break;
    } else {
      owner->unlock();
    }
    // Suspend to allow ownership to quiesce.
    hoardYield();
  }

#if HEAP_LOG
  MemoryRequest m;
  m.free (ptr);
  getLog (owner->getIndex()).append(m);
#endif
#if HEAP_FRAG_STATS
  setDeallocated (b->getRequestedSize(), 0);
#endif

  std::cout << "persistentheap::free  b = " << b << " ptr = " << ptr << std::endl;
  int sbUnmapped = owner->freeBlock (b, sb, sizeclass, this);

  owner->unlock();
  if (!sbUnmapped) {
    sb->upUnlock();
  }
}


persistentSuperblock *
persistentHeap::acquirePersistentSuperblock(bool isFree, int fullness, int blksize)
{
        int i;
        persistentSuperblock *psb;
        assert(0); // deprecated interface

        for(i=0; i<PERSISTENTSUPERBLOCK_NUM; i++) { 
                psb = (persistentSuperblock *) ((uintptr_t) psegmentheader + i*sizeof(persistentSuperblock));
                //std::cout << psb << " " <<  psb->getFullness() << std::endl;
                //std::cout << psb << " " <<  psb->isAcquired() << std::endl;
                if (isFree == true) {
                        if (!psb->isAcquired() && psb->isFree() == true) {
                                psb->acquire();
                                psb->setBlockSize(blksize);
                                return psb;
                        }
                } else {
                        if (!psb->isAcquired() && psb->getFullness()==fullness 
                            && psb->getBlockSize() == blksize) 
                        {
                                psb->acquire();
                                return psb;
                        }
                }
        }       

        return NULL;
}

---