VMemPool.C

Go to the documentation of this file.

// Copyright (C) 2001, Compaq Computer Corporation
// 
// This file is part of Vesta.
// 
// Vesta is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
// 
// Vesta is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
// 
// You should have received a copy of the GNU Lesser General Public
// License along with Vesta; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

//
// VMemPool.C
// Last modified on Mon May 23 21:53:56 EDT 2005 by ken@xorian.net  
//      modified on Tue Aug  7 19:43:45 PDT 2001 by mann  
//      modified on Mon Apr 28 17:30:26 PDT 1997 by heydon
//
// Memory pool for Vesta repository directory structure.  Confined to
// a range of addresses that can be represented in 32 bits.

// High-level garbage collection and checkpointing code is here.

// For now, we use a dumb first-fit allocation algorithm.  All freed
// memory is linked in a circular list with a cursor pointing into it.
// An allocation request searches around the list to find the first
// large-enough block and returns it.  (If there is none, a new block
// is made from currently unused memory.)  The block is split if it
// was larger than the requested size.  A block on the free list may
// not be smaller than FREEBK_MINSIZE = sizeof(VMemPoolFreeBlock), so:
// (1) Smaller sized allocates (and frees) are rounded up.  (2) If
// splitting a block would leave a too-small fragment, the fragment is
// filled with "freeByte" type codes and left off the free list.  (3)
// If gc or checkpointing compacts a block to less than FREEBK_MINSIZE
// and it is later freed, again the fragment is filled with "freeByte"
// type codes and left off the free list.  Such fragments are
// reclaimed by the next gc or checkpoint.


#if __linux__
#include <stdint.h>
#endif
#include <stdlib.h>
#include <sys/mman.h>
#include "Basics.H"
#include "VMemPool.H"
#include "VestaSource.H"
#include "VestaConfig.H"
#include "logging.H"
#include "DirShortId.H"
#include "VDirChangeable.H"
#include "VestaAttribsRep.H"
#include "FPShortId.H"
#include <Thread.H>

using std::fstream;
using std::hex;
using std::endl;
using std::streampos;

// Internal block types.
// See VDirChangeable.H for an explanation of the notation.
//
// packed struct VMemPoolFreeByte {
//     Bit8 clientBits: 4;           // Always 0.
//     Bit8 type: 4;                 // Must be VMemPool::freeByte
// };
//
// packed struct VMemPoolFreeBlock {
//     Bit8 clientBits: 4;           // Always 0.
//     Bit8 type: 4;                 // Must be VMemPool::freeBlock
//     Bit32 length;
//     VMemPoolFreeBlock@ next;
// };
//

// Offsets in packed struct
#define FREEBK_FLAGS 0
#define FREEBK_LENGTH 1
#define FREEBK_NEXT 5
#define FREEBK_MINSIZE 9

// Short pointer to a VMemPool block, with methods for common fields
// and fields in freed blocks.
class VMemPoolBlockSP : VMemPool {
  public:
    Bit32 sp;
    inline VMemPool::typeCode type() {
        return (VMemPool::typeCode)
          ((base[sp - 1 + FREEBK_FLAGS] >> 4) & 0xf);
    }; 
    inline void setType(VMemPool::typeCode val)
      { base[sp - 1 + FREEBK_FLAGS] = ((int) val) << 4; };
    inline Bit32 length() {
        Bit32 val;
        memcpy(&val, &base[sp - 1 + FREEBK_LENGTH], sizeof(Bit32));
        return val;
    };
    inline void setLength(Bit32 val) {
        memcpy(&base[sp - 1 + FREEBK_LENGTH], &val, sizeof(Bit32));
    };
    inline VMemPoolBlockSP next() {
        VMemPoolBlockSP val;
        memcpy(&val.sp, &base[sp - 1 + FREEBK_NEXT], sizeof(Bit32));
        return val;
    };
    inline void setNext(VMemPoolBlockSP val) {
        memcpy(&base[sp - 1 + FREEBK_NEXT], &val.sp, sizeof(Bit32));
    };
    inline friend int operator==(VMemPoolBlockSP a, VMemPoolBlockSP b)
      { return a.sp == b.sp; };
    inline friend int operator!=(VMemPoolBlockSP a, VMemPoolBlockSP b)
      { return a.sp != b.sp; };
    inline VMemPoolBlockSP() { };
    inline VMemPoolBlockSP(Bit32 sp) { this->sp = sp; };
};

const VMemPoolBlockSP SNULL(0);

// Module globals
static pthread_once_t once = PTHREAD_ONCE_INIT;
static Basics::mutex mu;
static long page_size;
Bit8* VMemPool::base;
Bit32 VMemPool::totalSize;
Bit32 VMemPool::minGrowBy;
static VMemPoolBlockSP freedMemCursor;
static VMemPoolBlockSP unusedMem;
static VMemPoolBlockSP unusedMemEnd;
static struct {
    VMemPool::markCallback markcb;
    void* markcl;
    VMemPool::sweepCallback sweepcb;
    void* sweepcl;
    VMemPool::rebuildCallback rebuildcb;
    void* rebuildcl;

    // Statistical information; examine in debugger.
    // Not saved in a checkpoint; accurate only
    // if there has been at least one sweep (source
    // weed) since recovery from a checkpoint.
    Bit32 totalSize;    
} callback[VMemPool::maxTypeCodes];
static const int CkptMinVersion = 4;
static const int CkptMaxVersion = 11;  // version 11 adds (vroot ...)
static int currentCkptVersion;
int VMemPool::alignmentMask;

// Set the prevailing checkpoint version: if writing a new checkpoint,
// the latest version; else if recovered from a checkpoint, the
// version recovered from; else the latest version.
static void
setCurrentCkptVersion(int ckptVersion)
{
  currentCkptVersion = ckptVersion;
  if (ckptVersion >= 7) {
    // Note: the alignment code in version 7 was buggy; if you can't
    // recover from a version 7 checkpoint due to assertion failures,
    // delete it and recover from the most recent version 6 or 5
    // checkpoint instead.
    VMemPool::alignmentMask = 7;
  } else if (ckptVersion == 6) {
    VMemPool::alignmentMask = 3;
  } else {
    VMemPool::alignmentMask = 0;
  }
}

extern "C"
{
  void VMemPool_init()
  {
    VMemPool::init();
  }
}

void*
VMemPool::allocate(VMemPool::typeCode type, Bit32 size) throw ()
{
    VMemPoolBlockSP p;
    Bit32 asize = size;
    pthread_once(&once, VMemPool_init);

    // Round up to minimum size that can be put on free list.
    // Note: a sweep or checkpoint can still make a block
    // too small to be put on the free list.
    if (asize < FREEBK_MINSIZE) {
        asize = FREEBK_MINSIZE;
    }

    // Round up to the required alignment
    // Assumes 2's complement negation.
    asize += (-asize) & VMemPool::alignmentMask;
    mu.lock();

    //Repos::dprintf(DBG_VMEMPOOL, "allocate(%d, %u) ", (int) type, size);

    if (freedMemCursor != SNULL) {
        VMemPoolBlockSP prev = freedMemCursor;
        p = prev.next();
        do {
            if (p.length() >= asize) {
                // Found a block
                Bit32 excess = p.length() - asize;
                assert((excess & VMemPool::alignmentMask) == 0);
                if (excess < FREEBK_MINSIZE) {
                    // Exact size, or nearly
                    asize = p.length();
                    if (prev == p) {
                        // Free list was of length 1
                        freedMemCursor = SNULL;
                    } else {
                        prev.setNext(p.next());
                        freedMemCursor = prev;
                    }
                } else {
                    // Larger block, need to split
                    VMemPoolBlockSP q;
                    q.sp = p.sp + asize;
                    q.setType(VMemPool::freeBlock);
                    q.setLength(excess);
                    if (prev == p) {
                        // Free list was of length 1
                        q.setNext(q);
                        freedMemCursor = q;
                    } else {
                        q.setNext(p.next());
                        prev.setNext(q);
                        freedMemCursor = prev;
                    }
                }
                goto finish;
            }
            prev = p;
            p = p.next();
        } while (prev != freedMemCursor);
        // fall though => couldn't find a big enough block
    }   
    // Make a new block in the previously unused area
    p = unusedMem;
    if (unusedMemEnd.sp - unusedMem.sp <= asize) {
        // Grow pool by (at least) the amount needed
        grow(asize - (unusedMemEnd.sp - unusedMem.sp));
    }
    unusedMem.sp += asize;

  finish:
    callback[(int)type].totalSize += size;
    callback[(int)VMemPool::freeBlock].totalSize -= asize;
    while (size < asize) {
        ((VMemPoolBlockSP) (p.sp + size++)).setType(VMemPool::freeByte);
        callback[(int)VMemPool::freeByte].totalSize++;
    }
    p.setType(type);
    mu.unlock();

    void *ret = (void*) VMemPool::lengthenPointer(p.sp);
    assert((((PointerInt)ret) & VMemPool::alignmentMask) == 0);
    //Repos::dprintf(DBG_VMEMPOOL, "returns 0x%016x\n", ret);
    return ret;
}

void
VMemPool::free(void* addr, Bit32 size, typeCode type) throw ()
{
    VMemPoolBlockSP p;
    p.sp = VMemPool::shortenPointer(addr);
    assert((((PointerInt)(addr)) & VMemPool::alignmentMask) == 0);
    if (type != unspecified) {
        assert(p.type() == type);
    }
    mu.lock();

    //Repos::dprintf(DBG_VMEMPOOL, "free(0x%016x, %d) ", addr, size);

    if (type != unspecified) {
        assert(p.type() == type);
    }
    callback[(int)p.type()].totalSize -= size;
    p.setType(VMemPool::freeBlock);
    // Find size to free by merging in following freeBytes
    Bit32 asize = size;
    VMemPoolBlockSP q;
    q.sp = p.sp + asize;
    while (q.sp < unusedMem.sp && q.type() == VMemPool::freeByte) {
        q.sp++;
        asize++;
        callback[(int)VMemPool::freeByte].totalSize--;
    }
    assert((asize & VMemPool::alignmentMask) == 0);

    if (asize < FREEBK_MINSIZE) {
        // The block is too small to go on the free list; fill it with
        // freeBytes instead.
        while (size--) {
            p.setType(VMemPool::freeByte);
            p.sp++;
        }
        callback[(int)VMemPool::freeByte].totalSize += asize;
    } else {
        p.setLength(asize);
        callback[(int)VMemPool::freeBlock].totalSize += asize;

        if (freedMemCursor == SNULL) {
            freedMemCursor = p;
            p.setNext(p);
        } else {
            p.setNext(freedMemCursor.next());
            freedMemCursor.setNext(p);
        }       
    }
    mu.unlock();
}

VMemPool::typeCode
VMemPool::type(void* addr) throw ()
{
    VMemPoolBlockSP p;
    p.sp = VMemPool::shortenPointer(addr);
    return p.type();
}

void
VMemPool::gc(ShortId keepDerivedSid) throw ()
{
    int i;
    pthread_once(&once, VMemPool_init);
    mu.lock();
    // Source mark phase.  Recursively mark everything reachable from
    // the roots.
    for (i = 0; i < (int) VMemPool::maxTypeCodes; i++) {
        if (callback[i].markcb != NULL) {
            callback[i].markcb(callback[i].markcl,
                               (VMemPool::typeCode) i);
        }
        callback[i].totalSize = 0;
    }

    // Recursively mark immutable directories that are on the derived
    // keep list and everything reachable from them.  (Note that we
    // don't do anything about the derived keep time, because sources
    // are not leased; see design document on Vesta internal home page.)
    if (keepDerivedSid != NullShortId) {
        SourceOrDerived sidstream;
        sidstream.open(keepDerivedSid); 
        sidstream >> hex;
        for (;;) {
            ShortId nextkeep;
            sidstream >> nextkeep;
            if (sidstream.fail()) {
                assert(sidstream.eof());
                break;
            }
            if (SourceOrDerived::dirShortId(nextkeep)) {
                Bit32 sp = GetDirShortId(nextkeep);
                if (sp != 0) {
                    VDirChangeable vs(VestaSource::immutableDirectory,
                                      (Bit8*) VMemPool::lengthenPointer(sp));
                    if (!vs.hasName()) {
                        vs.setHasName(true);
                        vs.mark();
                    }
                }
            }
        }
        sidstream.close();
    }

    // Sweep phase.  Also rebuilds the free list, compacting adjacent
    // free blocks.
    VMemPoolBlockSP p;
    p.sp = VMemPool::shortenPointer(base);
    VMemPoolBlockSP curFree;
    curFree = SNULL;
    Bit32 curFreeSize = 0;
    freedMemCursor = SNULL;
    while (p.sp < unusedMem.sp) {
        VMemPool::typeCode ptype = p.type();
        Bit32 size;
        bool free =
          !callback[(int) ptype].sweepcb(callback[(int) ptype].sweepcl, 
                                         ptype, (void*)
                                         VMemPool::lengthenPointer(p.sp),
                                         size);
        if (free) {
            //Repos::dprintf(DBG_VMEMPOOL, 
            //        "gc free, type %d, sp 0x%08x\n", (int) ptype, p.sp);
            if (curFree == SNULL) {
                curFree = p;
                curFreeSize = size;
            } else {
                curFreeSize += size;
            }
        } else {
            if (curFree != SNULL) {
                // Skip free bytes to achieve required alignment
                while ((curFree.sp - 1) & VMemPool::alignmentMask) {
                    callback[(int)VMemPool::freeByte].totalSize++;
                    curFree.setType(VMemPool::freeByte);
                    curFree.sp++;
                    curFreeSize--;
                }
                assert((curFreeSize & VMemPool::alignmentMask) == 0);
                if (curFreeSize < FREEBK_MINSIZE) {
                    callback[(int)VMemPool::freeByte].totalSize +=curFreeSize;
                    while (curFreeSize--) {
                        curFree.setType(VMemPool::freeByte);
                        curFree.sp++;
                    }
                } else {
                    callback[(int)VMemPool::freeBlock].totalSize +=curFreeSize;
                    curFree.setType(VMemPool::freeBlock);
                    curFree.setLength(curFreeSize);
                    if (freedMemCursor == SNULL) {
                        freedMemCursor = curFree;
                        curFree.setNext(curFree);
                    } else {
                        curFree.setNext(freedMemCursor.next());
                        freedMemCursor.setNext(curFree);
                    }
                }
                curFree = SNULL;
                curFreeSize = 0;
            }
            callback[(int) ptype].totalSize += size;
        }
        p.sp += size;
        assert(p.sp <= unusedMem.sp); // bug trap
    }

    if (curFree != SNULL) {
      // Adjust curFree to proper alignment
      while ((curFree.sp - 1) & VMemPool::alignmentMask) {
        assert(curFree.sp < unusedMemEnd.sp);
        callback[(int)VMemPool::freeByte].totalSize++;
        curFree.setType(VMemPool::freeByte);
        curFree.sp++;
        curFreeSize--;
      }
      unusedMem = curFree;
    }    

    // Enumerate and log freed DirShortIds
    LogAllDirShortIds("fsid");

    // Rebuild hash tables
    VMemPool::rebuildDirShortIdTable();

    if (Repos::isDebugLevel(DBG_VMEMPOOL)) {
      Repos::dprintf(0, "Memory pool size statistics:\n"
                     "freeByte\t%u\n"
                     "freeBlock\t%u\n"
                     "vDirChangeable\t%u\n"
                     "vForward\t%u\n"
                     "vDirEvaluator\t%u\n"
                     "vDirImmutable\t%u\n"
                     "vAttrib\t\t%u\n"
                     "vDirAppendable\t%u\n",
                     callback[freeByte].totalSize,
                     callback[freeBlock].totalSize,
                     callback[vDirChangeable].totalSize,
                     callback[vForward].totalSize,
                     callback[vDirEvaluator].totalSize,
                     callback[vDirImmutable].totalSize,
                     callback[vAttrib].totalSize,
                     callback[vDirAppendable].totalSize);
      VDirChangeable::printStats();
    }

    mu.unlock();
}

// Assumes mutex is locked!
void
VMemPool::rebuildDirShortIdTable() throw ()
{
    DeleteAllDirShortIds();
    DeleteAllFPShortId();

    // Sweep through memory, rebuilding the DirShortId table
    // and the FPShortId table.
    VMemPoolBlockSP p;
    p.sp = VMemPool::shortenPointer(base);
    while (p.sp < unusedMem.sp) {
        VMemPool::typeCode ptype = p.type();
        Bit32 size = 0, oldsize;
        oldsize = size; // for debugging only
        callback[(int) ptype].rebuildcb(callback[(int) ptype].rebuildcl, 
                                        ptype, (void*)
                                        VMemPool::lengthenPointer(p.sp),
                                        size);
        assert(size > 0); // bug trap
        p.sp += size;
        assert(p.sp <= unusedMem.sp); // bug trap
    }
}

void
VMemPool::registerCallbacks(VMemPool::typeCode type,
                            VMemPool::markCallback markcb, void* markcl,
                            VMemPool::sweepCallback sweepcb, void* sweepcl,
                            VMemPool::rebuildCallback rebuildcb,
                            void* rebuildcl) throw ()
{
    pthread_once(&once, VMemPool_init);
    mu.lock();
    callback[(int) type].markcb = markcb;
    callback[(int) type].markcl = markcl;
    callback[(int) type].sweepcb = sweepcb;
    callback[(int) type].sweepcl = sweepcl;
    callback[(int) type].rebuildcb = rebuildcb;
    callback[(int) type].rebuildcl = rebuildcl;
    callback[(int) type].totalSize = 0;
    mu.unlock();
}

// Callbacks for free bytes and blocks
static bool sweepFreeByteCallback(void* closure, VMemPool::typeCode type,
                                  void* addr, Bit32& size)
{
    size = 1;
    return false;
}

static void rebuildFreeByteCallback(void* closure, VMemPool::typeCode type,
                                    void* addr, Bit32& size)
{
    size = 1;
}

static bool sweepFreeBlockCallback(void* closure, VMemPool::typeCode type,
                                   void* addr, Bit32& size)
{
    size = ((VMemPoolBlockSP) VMemPool::shortenPointer(addr)).length();
    return false;
}

static void rebuildFreeBlockCallback(void* closure, VMemPool::typeCode type,
                                     void* addr, Bit32& size)
{
    size = ((VMemPoolBlockSP) VMemPool::shortenPointer(addr)).length();
}

void
VMemPool::init()
{
    page_size = sysconf(_SC_PAGE_SIZE);
    setCurrentCkptVersion(CkptMaxVersion); // default if no ckpt read
    mu.lock();
    Bit8* baseReq;
    try {
        Text t;
        if (VestaConfig::get("Repository", "VMemPool_size", t)) {
            // Clear errno, as strtoul will only modify it on
            // overflow.
            errno = 0;
            totalSize = strtoul(t.cchars(), NULL, 0);
            if(errno == ERANGE)
              {
                Repos::dprintf(DBG_ALWAYS,
                               "Fatal: [Repository]VMemPool_size is too large\n");
                abort();
              }
            assert(totalSize > 0);
            totalSize = (((totalSize - 1) / page_size) + 1) * page_size;
        } else {
            totalSize = page_size;
        }
        if (VestaConfig::get("Repository", "VMemPool_base", t)) {
            // Clear errno, as strtoul will only modify it on
            // overflow.
            errno = 0;
            baseReq = (Bit8*) strtoul(t.cchars(), NULL, 0);
            if(errno == ERANGE)
              {
                Repos::dprintf(DBG_ALWAYS,
                               "Fatal: [Repository]VMemPool_base is too large\n");
                abort();
              }
            baseReq = (Bit8*) (((((PointerInt) baseReq - 1)
                                 / page_size) + 1) * page_size);
        } else {
            baseReq = NULL;
        }
        if (VestaConfig::get("Repository", "VMemPool_minGrowBy", t)) {
            // Clear errno, as strtoul will only modify it on
            // overflow.
            errno = 0;
            minGrowBy = (Bit32) strtoul(t.cchars(), NULL, 0);
            if(errno == ERANGE)
              {
                Repos::dprintf(DBG_ALWAYS,
                               "Fatal: [Repository]VMemPool_minGrowBy is too large\n");
                abort();
              }
        } else {
            minGrowBy = page_size;
        }
    } catch (VestaConfig::failure f) {
        Repos::dprintf(DBG_ALWAYS, "VMemPool::init got VestaConfig::failure: %s\n",
                       f.msg.cchars());
        abort();
    }
#if MALLOC_VMEMPOOL
    base = (Bit8*) malloc(totalSize);
    assert(base != NULL);
#else
    if (baseReq == NULL) {
        base = (Bit8*) mmap(baseReq, totalSize, PROT_READ|PROT_WRITE,
                            MAP_ANONYMOUS|/*MAP_VARIABLE|*/MAP_PRIVATE, -1, 0);
    } else {
        base = (Bit8*) mmap(baseReq, totalSize, PROT_READ|PROT_WRITE,
                            MAP_ANONYMOUS|MAP_FIXED|MAP_PRIVATE, -1, 0);
    }
    assert(base != (Bit8*) -1);
#endif
    unusedMemEnd.sp = totalSize;
    freedMemCursor = SNULL;
    unusedMem.sp = VMemPool::shortenPointer(base);
    callback[(int) VMemPool::freeByte].sweepcb = sweepFreeByteCallback;
    callback[(int) VMemPool::freeByte].rebuildcb = rebuildFreeByteCallback;
    callback[(int) VMemPool::freeByte].totalSize = 0;
    callback[(int) VMemPool::freeBlock].sweepcb = sweepFreeBlockCallback;
    callback[(int) VMemPool::freeBlock].rebuildcb = rebuildFreeBlockCallback;
    callback[(int) VMemPool::freeBlock].totalSize = totalSize;
    Repos::dprintf(DBG_VMEMPOOL, "VMemPool baseReq 0x%p, base 0x%p,\n"
                   "  size 0x%x, minGrowBy 0x%x\n",
                   baseReq, base, totalSize, minGrowBy);
    mu.unlock();
}

void
VMemPool::grow(Bit32 growBy) throw ()
{
#if NOGROW_VMEMPOOL
    Repos::dprintf(DBG_ALWAYS, 
                   "Out of memory; crashing! (total %d, used %d, req %d)\n",
                   unusedMemEnd.sp, unusedMem.sp, growBy);
    abort();
#else
    Bit32 gb = growBy;
    if (gb < minGrowBy) gb = minGrowBy;
#if MALLOC_VMEMPOOL
    // Can this work?  Might invalidate pointers in other threads
    base = (Bit8*) realloc(base, totalSize + gb);
    assert(base != NULL);
#else
    gb = (((gb - 1) / page_size) + 1) * page_size;
    void* more = mmap(base + totalSize, gb, PROT_READ|PROT_WRITE,
                      MAP_ANONYMOUS|/*MAP_VARIABLE|*/MAP_PRIVATE, -1, 0);
    assert(more == base + totalSize);
#endif
    totalSize += gb;
    callback[(int)VMemPool::freeBlock].totalSize += gb;
    Repos::dprintf(DBG_VMEMPOOL, 
                   "VMemPool grow req 0x%x, rounded 0x%x, new size 0x%x\n",
                   growBy, gb, totalSize);
    unusedMemEnd.sp = totalSize;
#endif
}

//
// Checkpointing code
//

void
VMemPool::writeCheckpoint(fstream& ckpt) throw ()
{
    Bit32 nextSP = 1;
    Bit32 endianFlag = 0x01020304;

    mu.lock(); // needed?

    // Get pointers to roots now; don't call these functions after
    // possibly munging memory, because they read the attributes to
    // set the access permissions.
    VestaSource* rr = VestaSource::repositoryRoot();
    VestaSource* mr = VestaSource::mutableRoot();
    VestaSource* vr = VestaSource::volatileRoot();

    // Start checkpointing stable memory
    setCurrentCkptVersion(CkptMaxVersion);
    ckpt << "(smem " << CkptMaxVersion << endl;
    ckpt.write((char *) &endianFlag, sizeof(Bit32));

    // Leave space to write first unused SP value
    streampos lenpos = ckpt.tellp();
    ckpt.write((char *) &nextSP, sizeof(Bit32));

    // Checkpoint all directory structure and internal attributes
    Bit32 rSP = rr->checkpoint(nextSP, ckpt);
    Bit32 mSP = mr->checkpoint(nextSP, ckpt);
    CheckpointAllDirShortIds(nextSP, ckpt);

    // Checkpoint attributes of stable roots
    VestaAttribsRep* ar;
    ar = (VestaAttribsRep*) VMemPool::lengthenPointer(rr->firstAttrib());
    Bit32 raSP = 0;
    if (ar) raSP = ar->checkpoint(nextSP, ckpt);
    rr->rep = NULL;
    *(Bit32*)rr->attribs = 0;
    ar = (VestaAttribsRep*) VMemPool::lengthenPointer(mr->firstAttrib());
    Bit32 maSP = 0;
    if (ar) maSP = ar->checkpoint(nextSP, ckpt);
    mr->rep = NULL;
    *(Bit32*)mr->attribs = 0;

    // Write end of stable memory checkpoint
    streampos endpos = ckpt.tellp();
    ckpt.seekp(lenpos, fstream::beg);
    ckpt.write((char *) &nextSP, sizeof(Bit32));
    ckpt.seekp(endpos, fstream::beg);
    ckpt << "\n)\n";

    // Record new stable root rep and attrib pointers
    ckpt << "(rroot " << rSP << " " << raSP << ")\n";
    ckpt << "(mroot " << mSP << " " << maSP << ")\n";

    // Start checkpointing volatile memory (for immediate re-read)
    ckpt << "(vmem " << CkptMaxVersion << endl;
    ckpt.write((char *) &endianFlag, sizeof(Bit32));

    // Leave space to write first unused SP value
    lenpos = ckpt.tellp();
    ckpt.write((char *) &nextSP, sizeof(Bit32));

    (void) vr->checkpoint(nextSP, ckpt);

    // Checkpoint attributes of volatile root
    ar = (VestaAttribsRep*) VMemPool::lengthenPointer(vr->firstAttrib());
    Bit32 vaSP = 0;
    if (ar) vaSP = ar->checkpoint(nextSP, ckpt);
    *(Bit32*)vr->attribs = 0;

    // Write end of volatile memory checkpoint
    endpos = ckpt.tellp();
    ckpt.seekp(lenpos, fstream::beg);
    ckpt.write((char *) &nextSP, sizeof(Bit32));
    ckpt.seekp(endpos, fstream::beg);
    ckpt << "\n)\n";

    // Record new volatile root attrib pointer
    ckpt << "(vroot " << vaSP << ")\n";

    mu.unlock();
}

static void assertGood(fstream& ckpt)
{
    if (!ckpt.good()) {
        Repos::dprintf(DBG_ALWAYS, 
                       "read from checkpoint file failed: errno %d\n", errno);
        assert(ckpt.good());  // crash
    }
}

void
VMemPool::readCheckpoint(fstream& ckpt, bool readVolatile) throw ()
{
    char buf1[64];
    char buf2[64];
    char newline;
    Bit32 endianFlag;
    Bit32 nextSP, rootSP, rootAttribsSP;
    int ckptVersion;

    mu.lock();

    // Get pointers to roots
    VestaSource* rr = VestaSource::repositoryRoot();
    VestaSource* mr = VestaSource::mutableRoot();
    VestaSource* vr = VestaSource::volatileRoot();

    // Get header for stable data
    ckpt.get(buf1, sizeof(buf1));
    assertGood(ckpt);
    int ok = sscanf(buf1, "(smem %d", &ckptVersion);
    assert(ok == 1);
    if (ckptVersion < CkptMinVersion || ckptVersion > CkptMaxVersion) {
        Repos::dprintf(DBG_ALWAYS, "checkpoint version %d not between %d and %d\n",
                       ckptVersion, CkptMinVersion, CkptMaxVersion);
        exit(2);
    }
    setCurrentCkptVersion(ckptVersion);
    ckpt.get(newline);
    assertGood(ckpt);
    assert(newline == '\n');
    ckpt.read((char *) &endianFlag, sizeof(Bit32));
    assertGood(ckpt);
    switch (endianFlag) {
      case 0x01020304:
        break;
      case 0x04030201:
        assert(false);  // Not implemented yet
        break;
      default:
        assert(false);
        break;
    }
    ckpt.read((char *) &nextSP, sizeof(Bit32));
    assertGood(ckpt);

    // Get stable data
    if (nextSP > unusedMemEnd.sp) {
      grow(nextSP - unusedMemEnd.sp);
    }
    ckpt.read((char *) VMemPool::base, nextSP - 1);
    assertGood(ckpt);
    freedMemCursor = SNULL;
    Bit32 volSP = nextSP;
    assert(((nextSP - 1) & VMemPool::alignmentMask) == 0);
    unusedMem.sp = nextSP;

    // Get stable data trailer
    ckpt.get(newline);
    assertGood(ckpt);
    assert(newline == '\n');
    ckpt.get(buf2, sizeof(buf2));
    assertGood(ckpt);
    assert(strcmp(buf2, ")") == 0);
    ckpt.get(newline);
    assertGood(ckpt);
    assert(newline == '\n');

    // Get stable roots.
    if (ckptVersion >= 5) {
        ckpt >> buf1 >> rootSP >> rootAttribsSP >> buf2;
    } else {
        ckpt >> buf1 >> rootSP >> buf2;
        rootAttribsSP = 0;
    }   
    assertGood(ckpt);
    assert(strcmp(buf1, "(rroot") == 0);
    assert(strcmp(buf2, ")") == 0);
    ckpt.get(newline);
    assertGood(ckpt);
    assert(newline == '\n');
    rr->rep = (Bit8*) VMemPool::lengthenPointer(rootSP);
    *(Bit32*) rr->attribs = rootAttribsSP;
    rr->resync();

    if (ckptVersion >= 5) {
        ckpt >> buf1 >> rootSP >> rootAttribsSP >> buf2;
    } else {
        ckpt >> buf1 >> rootSP >> buf2;
        rootAttribsSP = 0;
    }   
    assertGood(ckpt);
    assert(strcmp(buf1, "(mroot") == 0);
    assert(strcmp(buf2, ")") == 0);
    ckpt.get(newline);
    assertGood(ckpt);
    assert(newline == '\n');
    mr->rep = (Bit8*) VMemPool::lengthenPointer(rootSP);
    *(Bit32*) mr->attribs = rootAttribsSP;
    mr->resync();

    // Get header for volatile data
    ckpt.get(buf1, sizeof(buf1));
    assertGood(ckpt);
    ok = sscanf(buf1, "(vmem %d", &ckptVersion);
    assert(ok == 1);

    ckpt.get(newline);
    assertGood(ckpt);
    assert(newline == '\n');
    ckpt.read((char *) &endianFlag, sizeof(Bit32));
    assertGood(ckpt);
    switch (endianFlag) {
      case 0x01020304:
        break;
      case 0x04030201:
        assert(false);          // Not implemented yet
        break;
      default:
        assert(false);
        break;
    }
    ckpt.read((char *) &nextSP, sizeof(Bit32));
    assertGood(ckpt);

    // Get or skip volatile data
    if (readVolatile) {
        // We only read volatile checkpoints we just wrote, so no
        // need to be able to handle old versions.
        assert(ckptVersion == CkptMaxVersion);
        assert(nextSP >= unusedMem.sp);

        if (nextSP > unusedMemEnd.sp) {
          grow(nextSP - unusedMemEnd.sp);
        }
#if 0
        // Seems to be a cxx library bug that causes 1 byte to be
        // skipped if we try to read 0 bytes here!?
        ckpt.read((char *) VMemPool::lengthenPointer(unusedMem.sp),
                  nextSP - unusedMem.sp);
#else
        if (nextSP > unusedMem.sp) {
            ckpt.read((char *) VMemPool::lengthenPointer(unusedMem.sp),
                      nextSP - unusedMem.sp);
            assertGood(ckpt);
        }
#endif
        unusedMem.sp = nextSP;
    } else {
        // Skip volatile data
        ckpt.seekg(nextSP - volSP, std::ios::cur);
        assertGood(ckpt);
    }
    
    // Get volatile data trailer
    ckpt.get(newline);
    assertGood(ckpt);
    assert(newline == '\n');
    ckpt.get(buf2, sizeof(buf2));
    assertGood(ckpt);
    assert(strcmp(buf2, ")") == 0);
    ckpt.get(newline);
    assertGood(ckpt);
    assert(newline == '\n');

    // Get or skip volatile root attribs pointer
    if (ckptVersion >= 11) {
      ckpt >> buf1 >> rootAttribsSP >> buf2;
      assertGood(ckpt);
      assert(strcmp(buf1, "(vroot") == 0);
      assert(strcmp(buf2, ")") == 0);
      if (readVolatile) {
        *(Bit32*) vr->attribs = rootAttribsSP;
        vr->resync();
      }
    }

    rebuildDirShortIdTable();

    mu.unlock();
}

---