Ignore:
Timestamp:
Jan 24, 2000, 2:45:21 AM (26 years ago)
Author:
bird
Message:

Heapcoding nearly completed...

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/win32k/misc/rmalloc_avl.c

    r2503 r2507  
    1 /* $Id: rmalloc_avl.c,v 1.2 2000-01-23 03:20:53 bird Exp $
     1/* $Id: rmalloc_avl.c,v 1.3 2000-01-24 01:45:20 bird Exp $
    22 *
    33 * Resident Heap - AVL.
     
    66 *       Use with care! We're running at Ring-0!
    77 *
    8  * Copyright (c) 1999 knut st. osmundsen
     8 * Copyright (c) 1999-2000 knut st. osmundsen
    99 *
    1010 * Project Odin Software License can be found in LICENSE.TXT
     
    1212 */
    1313
    14 #define static
     14
    1515/*******************************************************************************
    1616*   Defined Constants And Macros                                               *
     
    1818#ifdef DEBUG
    1919    #define DEBUG_ALLOC
    20     #undef ALLWAYS_HEAPCHECK
     20    #define ALLWAYS_HEAPCHECK
    2121#endif
    2222
     
    167167    PMEMBLOCKFREE pmbfTmp;
    168168
    169     pmbfTmp = (PMEMBLOCKFREE)AVLGetWithParent((PPAVLNODECORE)&pha->pcoreFreeSize,
     169    pmbfTmp = (PMEMBLOCKFREE)AVLGetWithParent(&pha->pcoreFreeSize,
    170170                                              (PPAVLNODECORE)SSToDS(&pmbfParent),
    171171                                              pmbf->coreFree.Key);
     
    191191            if (pmbfTmp->pmbfNext == NULL)
    192192            {   /* no list - no other nodes of this size: simply remove it. */
    193                 AVLRemove((PPAVLNODECORE)&pha->pcoreFreeSize, pmbf->coreFree.Key);
     193                AVLRemove(&pha->pcoreFreeSize, pmbf->coreFree.Key);
    194194            }
    195195            else
     
    200200                    pmbfParent = MEMBLOCKFREE_FROM_FREESIZENODE(pmbfParent);
    201201                    if (pmbfTmp->coreFree.Key < pmbfParent->coreFree.Key)
    202                         pmbfParent->coreFree.pLeft = (PAVLNODECORE)&pmbf->pmbfNext->coreFree;
     202                        pmbfParent->coreFree.pLeft = &pmbf->pmbfNext->coreFree;
    203203                    else
    204                         pmbfParent->coreFree.pRight = (PAVLNODECORE)&pmbf->pmbfNext->coreFree;
     204                        pmbfParent->coreFree.pRight = &pmbf->pmbfNext->coreFree;
    205205                }
    206206                else
    207                     pha->pcoreFreeSize = (PAVLNODECORE)&pmbf->pmbfNext->coreFree;
     207                    pha->pcoreFreeSize = &pmbf->pmbfNext->coreFree;
    208208            }
    209209        }
     
    221221    PMEMBLOCKFREE pmbfTmp;
    222222
    223     pmbfTmp = (PMEMBLOCKFREE)AVLGet((PPAVLNODECORE)&pha->pcoreFreeSize, pmbf->coreFree.Key);
     223    pmbfTmp = (PMEMBLOCKFREE)AVLGet(&pha->pcoreFreeSize, pmbf->coreFree.Key);
    224224    if (pmbfTmp != NULL)
    225225    {
     
    234234    {
    235235        pmbf->pmbfNext = NULL;
    236         AVLInsert((PPAVLNODECORE)&pha->pcoreFreeSize, &pmbf->coreFree);
     236        AVLInsert(&pha->pcoreFreeSize, &pmbf->coreFree);
    237237    }
    238238}
     
    248248static void resInsertFree(PHEAPANCHOR pha, PMEMBLOCK pmb)
    249249{
    250     /* some more work left here... */
    251250    PMEMBLOCKFREE   pmbf = (PMEMBLOCKFREE)pmb;
    252251    PMEMBLOCKFREE   pmbfRight;
     
    401400            register PHEAPANCHOR pha = *ppha;
    402401            PMEMBLOCK pmb;
     402            memset(pha, 0, sizeof(*pha));
    403403
    404404            /* anchor block */
     
    407407            #endif
    408408            pha->cbSize = cbBlockSize;
    409             pha->pmbUsed = NULL;
    410             pha->cbUsed = 0;
    411             pha->cbFree = 0;
    412             pha->pcoreFreeSize = NULL;
    413409
    414410            /* free memblock */
     
    458454 *                       NULL is allowed.
    459455 * @param     pvUser     User pointer to find the block to.
    460  * @param     fWithin    When this flag is set, the pointer may point anywhere within the block.
    461  *                       When clear, it has to point exactly at the start of the user data area.
    462456 */
    463457static PMEMBLOCK resFindUsedBlock(PHEAPANCHOR *ppha, void *pvUser)
    464458{
    465     if (pvUser != NULL && ppha != NULL)
     459    if (pvUser != NULL)
    466460    {
    467461        register PHEAPANCHOR pha = phaFirst;
     
    524518            if (pha->ulSignature != HEAPANCHOR_SIGNATURE)
    525519            {
    526                 kprintf(("resFindUsedBlock: Invalid heapanchor signature.\n"));
     520                kprintf(("resFindWithinUsedBlock: Invalid heapanchor signature.\n"));
    527521                return NULL;
    528522            }
     
    534528        if (pmb != NULL
    535529            && (unsigned)pmb + pmb->cbSize + CB_HDR > (unsigned)pvUser
    536             && (unsigned)pmb + CB_HDR >= (unsigned)pvUser
     530            && (unsigned)pmb + CB_HDR <= (unsigned)pvUser
    537531            )
    538532        {
     
    558552 * @param     cbSizeMax   Maximum heapsize in bytes.
    559553 */
    560 int ResHeapInit(unsigned cbSizeInit, unsigned cbSizeMax)
     554int resHeapInit(unsigned cbSizeInit, unsigned cbSizeMax)
    561555{
    562556    unsigned  cbSize = MAX(BLOCKSIZE, cbSizeInit);
     
    600594    #ifdef ALLWAYS_HEAPCHECK
    601595        if (!_res_heap_check())
    602         {
    603             /* error! */
    604             kprintf(("%s: _res_heap_check failed!\n", "heapInit"));
     596        {   /* error! */
     597            kprintf(("resHeapInit: _res_heap_check failed!\n"));
     598            #ifdef DEBUG
    605599            Int3();
     600            #endif
    606601            return -2;
    607602        }
     
    623618void * rmalloc(unsigned cbSize)
    624619{
    625     void *pvRet = NULL;
    626 
    627620    #ifdef ALLWAYS_HEAPCHECK
    628         if (!_res_heap_check())
    629         {
    630             kprintf(("rmalloc: _res_heap_check failed!\n"));
    631             return NULL;
    632         }
     621    if (!_res_heap_check())
     622    {
     623        kprintf(("rmalloc: _res_heap_check failed!\n"));
     624        return NULL;
     625    }
    633626    #endif
    634627
     
    640633        {
    641634            resInsertUsed(pha, pmb);
    642             pvRet = &pmb->achUserData[0];
     635            return &pmb->achUserData[0];
    643636        }
    644637    }
    645638    else
    646     {   /* error! */
    647639        kprintf(("rmalloc: error cbSize = 0\n"));
    648     }
    649 
    650     return pvRet;
     640
     641    return NULL;
    651642}
    652643
     
    665656
    666657    #ifdef ALLWAYS_HEAPCHECK
    667         if (!_res_heap_check())
    668         {
    669             kprintf(("rmalloc: _res_heap_check failed!\n"));
    670             return NULL;
    671         }
     658    if (!_res_heap_check())
     659    {
     660        kprintf(("rrealloc: _res_heap_check failed!\n"));
     661        return NULL;
     662    }
    672663    #endif
    673664    pmb = resFindUsedBlock(SSToDS(&pha), pv);
     
    684675                PMEMBLOCKFREE pmbfNew = (PMEMBLOCKFREE)((unsigned)pmb + CB_HDR + cbNew);
    685676                #ifdef DEBUG_ALLOC
    686                     pmbfNew->ulSignature = MEMBLOCK_SIGNATURE;
     677                pmbfNew->ulSignature = MEMBLOCK_SIGNATURE;
    687678                #endif
    688679                pha->cbUsed -= pmb->cbSize - cbNew;
     
    691682                resInsertFree(pha, (PMEMBLOCK)pmbfNew);
    692683                #ifdef ALLWAYS_HEAPCHECK
    693                     if (!_res_heap_check())
     684                if (!_res_heap_check())
     685                {
     686                    kprintf(("rrealloc: _res_heap_check failed!\n"));
     687                    return NULL;
     688                }
     689                #endif
     690            }
     691        }
     692        else
     693        {   /* expand block - this code may be optimized... */
     694            #if 0
     695            pvRet = rmalloc(cbNew);
     696            if (pvRet != NULL)
     697            {
     698                memcpy(pvRet, pv, pmb->cbSize);
     699                rfree(pv);
     700            }
     701            #else
     702            /* optimized FIXME! */
     703            PMEMBLOCKFREE pmbfRightParent;
     704            PMEMBLOCKFREE pmbfRight = (PMEMBLOCKFREE)AVLGetWithParent((PPAVLNODECORE)&pha->pmbFree,
     705                                                                      (PPAVLNODECORE)SSToDS(&pmbfRightParent),
     706                                                                      (AVLKEY)PNEXT_BLOCK(pmb));
     707            if (pmbfRight != NULL && pmbfRight->coreFree.Key + pmb->cbSize + CB_HDR >= cbNew)
     708            {
     709                pvRet = pv;
     710                /* split the free block? */
     711                if (pmbfRight->coreFree.Key + pmb->cbSize + CB_HDR - sizeof(MEMBLOCKFREE) >= cbNew)
     712                {
     713                    unsigned      cb = pmbfRight->coreFree.Key;
     714                    PMEMBLOCKFREE pmbfNew = (PMEMBLOCKFREE)((unsigned)pmb + CB_HDR + cbNew);
     715                    resRemoveFromFreeSize(pha, pmbfRight);
     716                    pmbfNew->coreFree.Key = cb + pmb->cbSize - cbNew;
     717                    memmove((void*)&pmbfNew->core, (void*)&pmbfRight->core, sizeof(pmbfNew->core));
     718                    pmbfNew->core.Key = (AVLKEY)pmbfNew;
     719                    #ifdef DEBUG_ALLOC
     720                    pmbfNew->ulSignature = MEMBLOCK_SIGNATURE;
     721                    #endif
     722                    if (pmbfRightParent != NULL)
    694723                    {
    695                         kprintf(("rrealloc: _res_heap_check failed!\n"));
     724                        if (pmbfNew < pmbfRightParent)
     725                            pmbfRightParent->core.pLeft = &pmbfNew->core;
     726                        else
     727                            pmbfRightParent->core.pRight = &pmbfNew->core;
     728                    }
     729                    else
     730                        pha->pmbFree = (PMEMBLOCK)pmbfNew;
     731
     732                    resInsertIntoFreeSize(pha, pmbfNew);
     733                    pha->cbUsed += cbNew - pmb->cbSize;
     734                    pha->cbFree -= cb - pmbfNew->coreFree.Key;
     735                    pmb->cbSize = cbNew;
     736                }
     737                else
     738                {
     739                    if (AVLRemove((PPAVLNODECORE)&pha->pmbFree, (AVLKEY)pmbfRight) != (PAVLNODECORE)pmbfRight)
     740                    {
     741                        kprintf(("rrealloc: AVLRemove failed for pmbfRight - hmm!\n"));
    696742                        return NULL;
    697743                    }
    698                 #endif
     744                    resRemoveFromFreeSize(pha, pmbfRight);
     745                    pmb->cbSize += pmbfRight->coreFree.Key + CB_HDR;
     746                    pha->cbFree -= pmbfRight->coreFree.Key;
     747                    pha->cbUsed += pmbfRight->coreFree.Key + CB_HDR;
     748                }
     749
    699750            }
    700         }
    701         else
    702         {   /* expand block - this code may be more optimized... */
    703             #if 1
     751            else
     752            {   /* worst case: allocate a new block, copy data and free the old block. */
    704753                pvRet = rmalloc(cbNew);
    705754                if (pvRet != NULL)
     
    708757                    rfree(pv);
    709758                }
    710             #else
    711                 /* optimized */
    712                 PMEMBLOCK pmb
     759            }
    713760            #endif
    714761        }
     
    779826    #ifdef ALLWAYS_HEAPCHECK
    780827        if (!_res_heap_check())
    781             kprintf(("_msize: _res_heap_check failed!\n"));
     828            kprintf(("_res_msize: _res_heap_check failed!\n"));
    782829    #endif
    783830
     
    799846    #ifdef ALLWAYS_HEAPCHECK
    800847        if (!_res_heap_check())
    801             kprintf(("_validptr: _res_heap_check failed!\n"));
     848            kprintf(("_res_validptr: _res_heap_check failed!\n"));
    802849    #endif
    803850
     
    820867    #ifdef ALLWAYS_HEAPCHECK
    821868        if (!_res_heap_check())
    822             kprintf(("_validptr: _res_heap_check failed!\n"));
     869            kprintf(("_res_validptr: _res_heap_check failed!\n"));
    823870    #endif
    824871
     
    843890    #ifdef ALLWAYS_HEAPCHECK
    844891        if (!_res_heap_check())
    845             kprintf(("res_memfree: _res_heap_check failed!\n"));
     892            kprintf(("_res_memfree: _res_heap_check failed!\n"));
    846893    #endif
    847894
     
    9881035            else
    9891036            {
    990                 PMEMBLOCKFREE pmbf = (PMEMBLOCKFREE)AVLGet((PPAVLNODECORE)&pha->pcoreFreeSize, pmbFree->cbSize);
     1037                PMEMBLOCKFREE pmbf = (PMEMBLOCKFREE)AVLGet(&pha->pcoreFreeSize, pmbFree->cbSize);
    9911038                if (pmbf != NULL)
    9921039                {
     
    11271174    if (pNode == NULL)
    11281175        return 0;
    1129     if (pNode->Key < 4 || (pNode->Key % 4) != 0)
     1176    if (pNode->Key < 4 || (pNode->Key % ALIGNMENT) != 0)
    11301177    {
    11311178        kprintf(("resCheckAVLTreeFree: Invalid Key! 0x%08x\n", pNode->Key));
     
    12081255            #endif
    12091256            if (rc != NO_ERROR)
    1210                 kprintf(("_res_heapmin: DosFreeMem failed for pha=0x%08x, rc = %d\n",
     1257                kprintf(("_res_heapmin: DosFreeMem/D32Help_VMFree failed for pha=0x%08x, rc = %d\n",
    12111258                         pha, rc));
    12121259        }
Note: See TracChangeset for help on using the changeset viewer.