GCHeap.h

Go to the documentation of this file.

/* -*- Mode: C++; c-basic-offset: 4; indent-tabs-mode: t; tab-width: 4 -*- */
/* ***** BEGIN LICENSE BLOCK *****
 * Version: MPL 1.1/GPL 2.0/LGPL 2.1
 *
 * The contents of this file are subject to the Mozilla Public License Version
 * 1.1 (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 * for the specific language governing rights and limitations under the
 * License.
 *
 * The Original Code is [Open Source Virtual Machine.].
 *
 * The Initial Developer of the Original Code is
 * Adobe System Incorporated.
 * Portions created by the Initial Developer are Copyright (C) 2004-2006
 * the Initial Developer. All Rights Reserved.
 *
 * Contributor(s):
 *   Adobe AS3 Team
 *
 * Alternatively, the contents of this file may be used under the terms of
 * either the GNU General Public License Version 2 or later (the "GPL"), or
 * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
 * in which case the provisions of the GPL or the LGPL are applicable instead
 * of those above. If you wish to allow use of your version of this file only
 * under the terms of either the GPL or the LGPL, and not to allow others to
 * use your version of this file under the terms of the MPL, indicate your
 * decision by deleting the provisions above and replace them with the notice
 * and other provisions required by the GPL or the LGPL. If you do not delete
 * the provisions above, a recipient may use your version of this file under
 * the terms of any one of the MPL, the GPL or the LGPL.
 *
 * ***** END LICENSE BLOCK ***** */

#ifndef __GCHeap__
#define __GCHeap__


namespace MMgc
{
    class MMGC_API GCHeap : public GCAllocObject
    {
    public:
        // -- Constants
        
        const static int kBlockSize = 4096;

#ifdef UNDER_CE
        const static int kDefaultReserve = 512;
#else
        const static int kDefaultReserve = 4096;
#endif
        
        const static int kUniqueThreshold = 16;

        const static int kHugeThreshold = 128;

        const static int kFreeListCompression = 8;

        const static int kNumFreeLists = (kHugeThreshold-kUniqueThreshold)/kFreeListCompression+kUniqueThreshold;

        const static int kMinHeapIncrement = 32;

        const static int kDecommitThresholdPercentage = 25;

        
        const static int kDecommitThresholdMillis = 1000;

        int kNativePageSize;

        bool heapVerbose;

#ifdef _DEBUG

        bool enableMemoryProfiling;
#endif

        static void Init(GCMallocFuncPtr malloc = NULL, GCFreeFuncPtr free = NULL, int initialSize=128);

        static void Destroy();

        static GCHeap *GetGCHeap() { GCAssert(instance != NULL); return instance; }

        void *Alloc(int size, bool expand=true, bool zero=true);

        void Free(void *item);

        size_t Size(const void *item);

        bool ExpandHeap(int size);


        size_t GetUsedHeapSize() const { return numAlloc; }

        size_t GetFreeHeapSize() const { return GetTotalHeapSize()-numAlloc; }

        size_t GetTotalHeapSize() const;
        
        void Decommit();

        static size_t SizeToBlocks(size_t bytes) { return ((bytes + kBlockSize - 1) & ~(kBlockSize-1)) / kBlockSize; }

        static size_t GetPrivateBytes();
        
        void SetHeapLimit(size_t numpages) { heapLimit = numpages; }
    private:

        // -- Implementation
        static GCHeap *instance;
        GCHeap(GCMallocFuncPtr m, GCFreeFuncPtr f, int initialSize);
        ~GCHeap();
        
        // Heap regions
        class Region : public GCAllocObject
        {
        public:
            Region *prev;
            char *baseAddr;
            char *reserveTop;
            char *commitTop;
            int blockId;
        };
        Region *lastRegion;
        
        // Block struct used for free lists and memory traversal
        class MMGC_API HeapBlock : public GCAllocObject
        {
        public:
            char *baseAddr;   // base address of block's memory
            int size;         // size of this block
            int sizePrevious; // size of previous block
            HeapBlock *prev;      // prev entry on free list
            HeapBlock *next;      // next entry on free list
            bool committed;   // is block fully committed?
            bool dirty;       // needs zero'ing, only valid if committed
#ifdef MEMORY_INFO
            int allocTrace;
            int freeTrace;
#endif
            bool inUse() { return prev == NULL; }
        };

        bool ExpandHeapPrivate(int size);

        // Core data structures
        HeapBlock *blocks;
        unsigned int blocksLen;
        unsigned int numDecommitted;
        HeapBlock freelists[kNumFreeLists];
        unsigned int numAlloc;
        size_t heapLimit;
        
        // Core methods
        void AddToFreeList(HeapBlock *block);
        void AddToFreeList(HeapBlock *block, HeapBlock* pointToInsert);
        HeapBlock *AllocBlock(int size, bool& zero);
        void FreeBlock(HeapBlock *block);
        void FreeAll();
    
        HeapBlock *Split(HeapBlock *block, int size);

#ifdef DECOMMIT_MEMORY
        void Commit(HeapBlock *block);
#endif

#ifdef _DEBUG
        friend class GC;
#endif
        HeapBlock *AddrToBlock(const void *item) const;
        Region *AddrToRegion(const void *item) const;
        void RemoveRegion(Region *r);

        // only used on mac
        GCMallocFuncPtr m_malloc;
        GCFreeFuncPtr m_free;

        // debug only freelist consistency checks
        void CheckFreelist();
        bool BlocksAreContiguous(void *item1, void *item2);

        // Remove a block from a free list (inlined for speed)
        inline void RemoveFromList(HeapBlock *block)
        {
            GCAssert(!block->inUse());
            block->prev->next = block->next;
            block->next->prev = block->prev;
            block->next = block->prev = 0;
        }           


        // Map a number of blocks to the appropriate large block free list index
        // (inlined for speed)
        inline int GetFreeListIndex(int size)
        {
            if (size <= kUniqueThreshold) {
                return size-1;
            } else if (size >= kHugeThreshold) {
                return kNumFreeLists-1;
            } else {
                return (size-kUniqueThreshold)/kFreeListCompression+kUniqueThreshold-1;
            }
        }

        // used for decommit smoothing
        // millis to wait before decommitting anything
        uint64 decommitTicks;
        uint64 decommitThresholdTicks;

#ifdef GCHEAP_LOCK
        GCSpinLock m_spinlock;
#endif /* GCHEAP_LOCK */

#ifdef MMGC_AVMPLUS
        // OS abstraction to determine native page size
        int vmPageSize();
        size_t committedCodeMemory;

        #ifdef WIN32
        bool useGuardPages;
        #endif
        
        // mir buffer management, share a common pool across threads
        GCSpinLock m_mirBufferLock;
        typedef struct _MirMemInfo
        {
            void* addr;
            size_t size;
            bool free;
        } 
        MirMemInfo;

        static const int MirBufferCount = 8;
        MirMemInfo m_mirBuffers[MirBufferCount];

        void InitMirMemory();
        void FlushMirMemory();
        
public:

        // support for Mir buffers
        void* ReserveMirMemory(size_t size);        
        void  ReleaseMirMemory(void* addr, size_t size);

        // support for jit buffers
        void* ReserveCodeMemory(void* address, size_t size);
        void* CommitCodeMemory(void* address, size_t size=0);  // size=0 => 1 page
        void* DecommitCodeMemory(void* address, size_t size=0);  // size=0 => 1 page
        void ReleaseCodeMemory(void* address, size_t size);
        bool SetGuardPage(void *address);
#ifdef AVMPLUS_JIT_READONLY
        // SECURITY: setting executeFlag and writeableFlag at the same time is DANGEROUS! 
        //           Make sure that you know what you are doing!
        void SetPageProtection(void *address, size_t size, bool executeFlag, bool writeableFlag);
#endif /* AVMPLUS_JIT_READONLY */
        size_t GetCodeMemorySize() const { return committedCodeMemory; }
#endif

#ifdef USE_MMAP
    public:
        char *ReserveMemory(char *address, size_t size);
        bool CommitMemory(char *address, size_t size);
        bool DecommitMemory(char *address, size_t size);
        void ReleaseMemory(char *address, size_t size);


        bool CommitMemoryThatMaySpanRegions(char *address, size_t size);
        bool DecommitMemoryThatMaySpanRegions(char *address, size_t size);      
#else
        char *AllocateMemory(size_t size);
        void ReleaseMemory(char *address);
#endif

private:

#ifdef _DEBUG
        /* m_megamap is a debugging aid for finding bugs in this
           memory allocator.  It tracks allocated/free pages in
           the crudest way possible ... a 1MB byte array with a
           0/1 byte for every page in the 32-bit address space. */
        static uint8 m_megamap[1048576];
#endif
    };
}

#endif /* __GCHeap__ */

---