*** old/src/share/vm/gc_implementation/concurrentMarkSweep/freeBlockDictionary.hpp	Thu May 29 11:14:09 2008
--- new/src/share/vm/gc_implementation/concurrentMarkSweep/freeBlockDictionary.hpp	Thu May 29 11:14:08 2008

*** 20,112 ****
--- 20,30 ----
   * CA 95054 USA or visit www.sun.com if you need additional information or
   * have any questions.
   *
   */
  
  //
  // Free block maintenance for Concurrent Mark Sweep Generation
  //
  // The main data structure for free blocks are
  // . an indexed array of small free blocks, and
  // . a dictionary of large free blocks
  //
  
  // No virtuals in FreeChunk (don't want any vtables).
  
  // A FreeChunk is merely a chunk that can be in a doubly linked list
  // and has a size field. NOTE: FreeChunks are distinguished from allocated
  // objects in two ways (by the sweeper). The second word (prev) has the
  // LSB set to indicate a free chunk; allocated objects' klass() pointers
  // don't have their LSB set. The corresponding bit in the CMSBitMap is
  // set when the chunk is allocated. There are also blocks that "look free"
  // but are not part of the free list and should not be coalesced into larger
  // free blocks. These free blocks have their two LSB's set.
  
  class FreeChunk VALUE_OBJ_CLASS_SPEC {
    friend class VMStructs;
    FreeChunk* _next;
    FreeChunk* _prev;
    size_t     _size;
  
   public:
    NOT_PRODUCT(static const size_t header_size();)
    // Returns "true" if the "wrd", which is required to be the second word
    // of a block, indicates that the block represents a free chunk.
    static bool secondWordIndicatesFreeChunk(intptr_t wrd) {
      return (wrd & 0x1) == 0x1;
    }
    bool isFree()       const {
      return secondWordIndicatesFreeChunk((intptr_t)_prev);
    }
    bool cantCoalesce() const { return (((intptr_t)_prev) & 0x3) == 0x3; }
    FreeChunk* next()   const { return _next; }
    FreeChunk* prev()   const { return (FreeChunk*)(((intptr_t)_prev) & ~(0x3)); }
    debug_only(void* prev_addr() const { return (void*)&_prev; })
  
    void linkAfter(FreeChunk* ptr) {
      linkNext(ptr);
      if (ptr != NULL) ptr->linkPrev(this);
    }
    void linkAfterNonNull(FreeChunk* ptr) {
      assert(ptr != NULL, "precondition violation");
      linkNext(ptr);
      ptr->linkPrev(this);
    }
    void linkNext(FreeChunk* ptr) { _next = ptr; }
    void linkPrev(FreeChunk* ptr) { _prev = (FreeChunk*)((intptr_t)ptr | 0x1); }
    void clearPrev()              { _prev = NULL; }
    void clearNext()              { _next = NULL; }
    void dontCoalesce()      {
      // the block should be free
      assert(isFree(), "Should look like a free block");
      _prev = (FreeChunk*)(((intptr_t)_prev) | 0x2);
    }
    void markFree()    { _prev = (FreeChunk*)((intptr_t)_prev | 0x1);    }
    void markNotFree() { _prev = NULL; }
  
    size_t size()           const { return _size; }
    void setSize(size_t size)     { _size = size; }
  
    // For volatile reads:
    size_t* size_addr()           { return &_size; }
  
    // Return the address past the end of this chunk
    HeapWord* end() const { return ((HeapWord*) this) + _size; }
  
    // debugging
    void verify()             const PRODUCT_RETURN;
    void verifyList()         const PRODUCT_RETURN;
    void mangleAllocated(size_t size) PRODUCT_RETURN;
    void mangleFreed(size_t size)     PRODUCT_RETURN;
  };
  
  // Alignment helpers etc.
  #define numQuanta(x,y) ((x+y-1)/y)
  enum AlignmentConstants {
    MinChunkSize = numQuanta(sizeof(FreeChunk), MinObjAlignmentInBytes) * MinObjAlignment
  };
  
  // A FreeBlockDictionary is an abstract superclass that will allow
  // a number of alternative implementations in the future.
  class FreeBlockDictionary: public CHeapObj {
   public:
    enum Dither {