Ignore:
Timestamp:
Jul 15, 2002, 4:28:53 PM (23 years ago)
Author:
sandervl
Message:

Rewrote algorithm for 64kb alignment in VirtualAlloc'ed memory; allocation changes for heap (in 64kb chunks) & PE image (align at 64kb)

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/kernel32/heapshared.cpp

    r5564 r8877  
    1 /* $Id: heapshared.cpp,v 1.8 2001-04-22 09:00:19 sandervl Exp $ */
     1/* $Id: heapshared.cpp,v 1.9 2002-07-15 14:28:51 sandervl Exp $ */
    22/*
    33 * Shared heap functions for OS/2
    … …  
    3939BOOL InitializeSharedHeap()
    4040{
    41  APIRET rc;
     41    APIRET rc;
    4242
    43   if(pSharedMem == NULL) {
    44         rc = DosAllocSharedMem(&pSharedMem, NULL, MAX_HEAPSIZE, PAG_READ|PAG_WRITE|OBJ_GETTABLE);
    45         if(rc != 0) {
    46                 dprintf(("InitializeSharedHeap: DosAllocSharedMem failed with %d", rc));
    47                 return FALSE;
    48         }
    49         rc = DosSetMem(pSharedMem, INCR_HEAPSIZE, PAG_READ|PAG_WRITE|PAG_COMMIT);
    50         if(rc != 0) {
    51                 DosFreeMem(pSharedMem);
    52                 dprintf(("InitializeSharedHeap: DosSetMem failed with %d", rc));
    53                 return FALSE;
    54         }
    55         sharedHeap = _ucreate(pSharedMem, INCR_HEAPSIZE, _BLOCK_CLEAN,
    56                               _HEAP_REGULAR|_HEAP_SHARED,
    57                               getmoreShared, releaseShared);
     43    if(pSharedMem == NULL) {
     44            rc = DosAllocSharedMem(&pSharedMem, NULL, MAX_HEAPSIZE, PAG_READ|PAG_WRITE|OBJ_GETTABLE);
     45            if(rc != 0) {
     46                dprintf(("InitializeSharedHeap: DosAllocSharedMem failed with %d", rc));
     47                    return FALSE;
     48            }
     49            rc = DosSetMem(pSharedMem, INCR_HEAPSIZE, PAG_READ|PAG_WRITE|PAG_COMMIT);
     50            if(rc != 0) {
     51                DosFreeMem(pSharedMem);
     52                    dprintf(("InitializeSharedHeap: DosSetMem failed with %d", rc));
     53                    return FALSE;
     54            }
     55            sharedHeap = _ucreate(pSharedMem, INCR_HEAPSIZE, _BLOCK_CLEAN, _HEAP_REGULAR|_HEAP_SHARED,
     56                                  getmoreShared, releaseShared);
    5857
    59         if(sharedHeap == NULL) {
    60                 DosFreeMem(pSharedMem);
    61                 dprintf(("InitializeSharedHeap: _ucreate failed!"));
    62                 return FALSE;
    63         }
    64         dprintf(("KERNEL32: First InitializeSharedHeap %x %x", pSharedMem, sharedHeap));
    65         for(int i=0;i<INCR_HEAPSIZE/PAGE_SIZE;i++) {
    66                 pageBitmap[i] = 1; //mark as committed
    67         }
    68   }
    69   else {
    70         if(DosGetSharedMem(pSharedMem, PAG_READ|PAG_WRITE) != 0) {
    71                 dprintf(("InitializeSharedHeap: DosGetSharedMem failed!"));
    72                 return FALSE;
    73         }
    74         dprintf(("KERNEL32: InitializeSharedHeap %x %x refcount %d", pSharedMem, sharedHeap, refCount));
    75         if(_uopen(sharedHeap) != 0) {
    76                 dprintf(("InitializeSharedHeap: unable to open shared heap!"));
    77                 return FALSE;
    78         }
    79   }
    80   refCount++;
    81   return TRUE;
     58            if(sharedHeap == NULL) {
     59                DosFreeMem(pSharedMem);
     60                    dprintf(("InitializeSharedHeap: _ucreate failed!"));
     61                    return FALSE;
     62            }
     63            dprintf(("KERNEL32: First InitializeSharedHeap %x %x", pSharedMem, sharedHeap));
     64            for(int i=0;i<INCR_HEAPSIZE/PAGE_SIZE;i++) {
     65                pageBitmap[i] = 1; //mark as committed
     66        }
     67    }
     68    else {
     69        if(DosGetSharedMem(pSharedMem, PAG_READ|PAG_WRITE) != 0) {
     70                    dprintf(("InitializeSharedHeap: DosGetSharedMem failed!"));
     71                    return FALSE;
     72            }
     73            dprintf(("KERNEL32: InitializeSharedHeap %x %x refcount %d", pSharedMem, sharedHeap, refCount));
     74            if(_uopen(sharedHeap) != 0) {
     75                dprintf(("InitializeSharedHeap: unable to open shared heap!"));
     76                    return FALSE;
     77            }
     78    }
     79    refCount++;
     80    return TRUE;
    8281}
    8382//******************************************************************************
    … …  
    8584void DestroySharedHeap()
    8685{
    87   dprintf(("KERNEL32: DestroySharedHeap %d", refCount));
    88   if(--refCount == 0) {
    89         if(sharedHeap) {
    90                 _uclose(sharedHeap);
    91                 _udestroy(sharedHeap, _FORCE);
    92                 sharedHeap = NULL;
    93         }
    94         if(pSharedMem) {
    95                 DosFreeMem(pSharedMem);
    96                 pSharedMem = NULL;
    97         }
    98   }
    99   else {
    100         _uclose(sharedHeap);
    101   }
     86    dprintf(("KERNEL32: DestroySharedHeap %d", refCount));
     87    if(--refCount == 0) {
     88            if(sharedHeap) {
     89                _uclose(sharedHeap);
     90                    _udestroy(sharedHeap, _FORCE);
     91                    sharedHeap = NULL;
     92            }
     93            if(pSharedMem) {
     94                DosFreeMem(pSharedMem);
     95                    pSharedMem = NULL;
     96            }
     97    }
     98    else {
     99        _uclose(sharedHeap);
     100    }
    102101}
    103102//******************************************************************************
    … …  
    105104ULONG GetPageRangeFree(ULONG pageoffset)
    106105{
    107   dprintf(("KERNEL32: GetPageRangeFree(%08xh)\n",
    108            pageoffset));
     106    dprintf(("KERNEL32: GetPageRangeFree(%08xh)", pageoffset));
    109107
    110   for(int i=pageoffset;i<MAX_HEAPPAGES;i++) {
    111         if(pageBitmap[i] == 1) {
    112                 break;
    113         }
    114   }
    115   return i-pageoffset;
     108    for(int i=pageoffset;i<MAX_HEAPPAGES;i++) {
     109        if(pageBitmap[i] == 1) {
     110                    break;
     111            }
     112    }
     113    return i-pageoffset;
    116114}
    117115//******************************************************************************
    … …  
    119117void * _LNK_CONV getmoreShared(Heap_t pHeap, size_t *size, int *clean)
    120118{
    121  APIRET rc;
    122  ULONG newsize;
    123  PVOID newblock;
     119    APIRET rc;
     120    ULONG newsize;
     121    PVOID newblock;
    124122
    125  dprintf(("KERNEL32: getmoreShared(%08xh, %08xh, %08xh)\n",
    126           pHeap,
    127           *size,
    128           *clean));
     123    dprintf(("KERNEL32: getmoreShared(%08xh, %08xh, %08xh)\n", pHeap, *size, *clean));
    129124
    130   /* round the size up to a multiple of 4K */
    131   // *size = (*size / 4096) * 4096 + 4096;
    132   // @@@PH speed improvement
    133   *size = (*size + 4096) & 0xFFFFF000;
    134   *size = max(*size, INCR_HEAPSIZE);
     125    /* round the size up to a multiple of 4K */
     126    // *size = (*size / 4096) * 4096 + 4096;
     127    // @@@PH speed improvement
     128    *size = (*size + 4096) & 0xFFFFF000;
     129    *size = max(*size, INCR_HEAPSIZE);
    135130
    136   for(int i=0;i<MAX_HEAPPAGES;i++)
    137   {
    138         int nrpagesfree = GetPageRangeFree(i);
    139         if(nrpagesfree >= *size/PAGE_SIZE) {
    140                 newblock = (PVOID)((ULONG)pSharedMem + i*PAGE_SIZE);
    141                 rc = DosSetMem(newblock, *size, PAG_READ|PAG_WRITE|PAG_COMMIT);
    142                 if(rc != 0) {
    143                         dprintf(("getmoreShared: DosSetMem failed with %d", rc));
    144                         return NULL;
    145                 }
    146                 for(int j=0;j < *size/PAGE_SIZE; j++)
    147                 {
    148                         pageBitmap[i+j] = 1; //mark as committed
    149                 }
     131    for(int i=0;i<MAX_HEAPPAGES;i++)
     132    {
     133        int nrpagesfree = GetPageRangeFree(i);
     134        if(nrpagesfree >= *size/PAGE_SIZE) {
     135                    newblock = (PVOID)((ULONG)pSharedMem + i*PAGE_SIZE);
     136                    rc = DosSetMem(newblock, *size, PAG_READ|PAG_WRITE|PAG_COMMIT);
     137                    if(rc != 0) {
     138                        dprintf(("getmoreShared: DosSetMem failed with %d", rc));
     139                            return NULL;
     140                    }
     141                    for(int j=0;j < *size/PAGE_SIZE; j++)
     142            {
     143                            pageBitmap[i+j] = 1; //mark as committed
     144                    }
    150145
    151                 *clean = _BLOCK_CLEAN;
    152                 dprintf(("KERNEL32: getmoreShared %x %d", newblock, *size));
    153                 return newblock;
    154         }
    155         if(nrpagesfree)
    156                 i += nrpagesfree-1;
    157   }
    158   dprintf(("KERNEL32: getmoreShared NOTHING LEFT (%d)", *size));
    159   return NULL;
     146                    *clean = _BLOCK_CLEAN;
     147                    dprintf(("KERNEL32: getmoreShared %x %d", newblock, *size));
     148                    return newblock;
     149            }
     150            if(nrpagesfree)
     151                i += nrpagesfree-1;
     152    }
     153    dprintf(("KERNEL32: getmoreShared NOTHING LEFT (%d)", *size));
     154    return NULL;
    160155}
    161156//******************************************************************************
    … …  
    163158void _LNK_CONV releaseShared(Heap_t pHeap, void *block, size_t size)
    164159{
    165  ULONG pagenr;
     160    ULONG pagenr;
    166161
    167   dprintf(("KERNEL32: releaseShared %x %d", block, size));
    168   DosSetMem(block, size, PAG_READ|PAG_WRITE|PAG_DECOMMIT);
     162    dprintf(("KERNEL32: releaseShared %x %d", block, size));
     163    DosSetMem(block, size, PAG_READ|PAG_WRITE|PAG_DECOMMIT);
    169164
    170   pagenr  = (ULONG)block - (ULONG)pSharedMem;
    171   pagenr /= PAGE_SIZE;
    172   for(int i=pagenr;i<pagenr+size/PAGE_SIZE;i++) {
    173         pageBitmap[i] = 0; //mark as decommitted
    174   }
     165    pagenr  = (ULONG)block - (ULONG)pSharedMem;
     166    pagenr /= PAGE_SIZE;
     167    for(int i=pagenr;i<pagenr+size/PAGE_SIZE;i++) {
     168            pageBitmap[i] = 0; //mark as decommitted
     169    }
    175170}
    176171//******************************************************************************
    … …  
    178173DWORD  HeapGetSharedMemBase()
    179174{
    180   dprintf(("KERNEL32: HeapGetSharedMemBase()\n"));
    181   return (DWORD) pSharedMem;
     175    dprintf(("KERNEL32: HeapGetSharedMemBase()\n"));
     176    return (DWORD) pSharedMem;
    182177}
    183178//******************************************************************************
Note: See TracChangeset for help on using the changeset viewer.