Changeset 7360 for trunk/src/kernel32


Ignore:
Timestamp:
Nov 16, 2001, 3:52:56 PM (24 years ago)
Author:
phaller
Message:

slightly more tuning

Location:
trunk/src/kernel32
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/kernel32/heap.cpp

    r7358 r7360  
    1919#include "os2heap.h"
    2020#include <heap.h>
     21#include "os2heap.h"
    2122#include <odinwrap.h>
    2223#include "initterm.h"
    … …  
    2728ODINDEBUGCHANNEL(KERNEL32-HEAP)
    2829
    29 
    30 static HANDLE processheap = NULL;
    31 OS2Heap *OS2ProcessHeap = NULL;
    32 
     30//******************************************************************************
     31// Local variables
     32//******************************************************************************
     33
     34static OS2Heap *OS2ProcessHeap = NULL;
     35
     36static HANDLE i_initializeProcessHeap()
     37{
     38  HANDLE _processheap;
     39 
     40  //SvL: Only one process heap per process
     41  OS2ProcessHeap = new OS2Heap(HEAP_GENERATE_EXCEPTIONS, 0x4000, 0);
     42
     43  if(OS2ProcessHeap == NULL)
     44    return(NULL);
     45  _processheap = OS2ProcessHeap->getHeapHandle();
     46 
     47  return _processheap;
     48}
     49
     50static HANDLE processheap = i_initializeProcessHeap();
     51
     52// This macro could be mapped to GetProcessHeap() if there
     53// is any change in functionality
     54#define GETPROCESSHEAP processheap
    3355
    3456
    … …  
    4668  else                               \
    4769    curheap = OS2Heap::find(hHeap);  \
     70 
    4871
    4972
    … …  
    202225{
    203226//    dprintf2(("KERNEL32: GetProcessHeap\n"));
    204     //SvL: Only one process heap per process
    205     if(processheap == NULL) {
    206       OS2ProcessHeap = new OS2Heap(HEAP_GENERATE_EXCEPTIONS, 0x4000, 0);
    207 
    208       if(OS2ProcessHeap == NULL) {
    209                 return(NULL);
    210       }
    211       processheap = OS2ProcessHeap->getHeapHandle();
    212     }
    213227    return(processheap);
    214228}
    … …  
    270284   if((flags & GMEM_MOVEABLE)==0) /* POINTER */
    271285   {
    272       palloc=HeapAlloc(GetProcessHeap(), hpflags, size);
     286      palloc=HeapAlloc(GETPROCESSHEAP, hpflags, size);
    273287      return (HGLOBAL) palloc;
    274288   }
    … …  
    277291      /* HeapLock(heap); */
    278292
    279       pintern=(PGLOBAL32_INTERN)HeapAlloc(GetProcessHeap(), 0,  sizeof(GLOBAL32_INTERN));
     293      pintern=(PGLOBAL32_INTERN)HeapAlloc(GETPROCESSHEAP, 0,  sizeof(GLOBAL32_INTERN));
    280294      if (!pintern) return 0;
    281295      if(size)
    282296      {
    283297         //SvL: 2*sizeof for 8 byte alignment
    284          if (!(palloc=HeapAlloc(GetProcessHeap(), hpflags, size+HGLOBAL_SIZE))) {
    285             HeapFree(GetProcessHeap(), 0, pintern);
     298         if (!(palloc=HeapAlloc(GETPROCESSHEAP, hpflags, size+HGLOBAL_SIZE))) {
     299            HeapFree(GETPROCESSHEAP, 0, pintern);
    286300            return 0;
    287301         }
    … …  
    327341   }
    328342
    329    /* HeapLock(GetProcessHeap()); */
     343   /* HeapLock(GETPROCESSHEAP); */
    330344   
    331345   pintern=HANDLE_TO_INTERN(hmem);
    … …  
    342356      SetLastError(ERROR_INVALID_HANDLE);
    343357   }
    344    /* HeapUnlock(GetProcessHeap()); */;
     358   /* HeapUnlock(GETPROCESSHEAP); */;
    345359
    346360   dprintf(("KERNEL32: GlobalLock %x returned %x", hmem, palloc));
    … …  
    372386   }
    373387
    374    /* HeapLock(GetProcessHeap()); */
     388   /* HeapLock(GETPROCESSHEAP); */
    375389   pintern=HANDLE_TO_INTERN(hmem);
    376390   
    … …  
    389403      locked=FALSE;
    390404   }
    391    /* HeapUnlock(GetProcessHeap()); */
     405   /* HeapUnlock(GETPROCESSHEAP); */
    392406   return locked;
    393407}
    … …  
    422436        /* will fail.                                                      */
    423437        if (ISPOINTER(pmem)) {
    424             if (HeapValidate( GetProcessHeap(), 0, pmem )) {
     438            if (HeapValidate( GETPROCESSHEAP, 0, pmem )) {
    425439                handle = (HGLOBAL)pmem;  /* valid fixed block */
    426440                return handle;
    … …  
    440454            test = maybe_intern->Pointer;
    441455            //SvL: -2 for 8 byte alignment
    442             if (HeapValidate( GetProcessHeap(), 0, ((HGLOBAL *)test)-2 ) && /* obj(-handle) valid arena? */
    443                 HeapValidate( GetProcessHeap(), 0, maybe_intern ))  /* intern valid arena? */
     456            if (HeapValidate( GETPROCESSHEAP, 0, ((HGLOBAL *)test)-2 ) && /* obj(-handle) valid arena? */
     457                HeapValidate( GETPROCESSHEAP, 0, maybe_intern ))  /* intern valid arena? */
    444458            {
    445459                return handle;
    … …  
    457471        /* will fail.                                                      */
    458472        if (ISPOINTER(pmem)) {
    459             if (HeapValidate( GetProcessHeap(), 0, pmem )) {
     473            if (HeapValidate( GETPROCESSHEAP, 0, pmem )) {
    460474                handle = (HGLOBAL)pmem;  /* valid fixed block */
    461475                break;
    … …  
    469483        if (maybe_intern->Magic == MAGIC_GLOBAL_USED) {
    470484            test = maybe_intern->Pointer;
    471             if (HeapValidate( GetProcessHeap(), 0, ((HGLOBAL *)test)-1 ) && /* obj(-handle) valid arena? */
    472                 HeapValidate( GetProcessHeap(), 0, maybe_intern ))  /* intern valid arena? */
     485            if (HeapValidate( GETPROCESSHEAP, 0, ((HGLOBAL *)test)-1 ) && /* obj(-handle) valid arena? */
     486                HeapValidate( GETPROCESSHEAP, 0, maybe_intern ))  /* intern valid arena? */
    473487                break;  /* valid moveable block */
    474488        }
    … …  
    525539             return 0;
    526540         }
    527          size=HeapSize(GetProcessHeap(), 0, (LPVOID) hmem);
     541         size=HeapSize(GETPROCESSHEAP, 0, (LPVOID) hmem);
    528542         hnew=GlobalAlloc( flags, size);
    529543         palloc=GlobalLock(hnew);
    … …  
    550564      {
    551565         /* reallocate fixed memory */
    552          hnew=(HGLOBAL)HeapReAlloc(GetProcessHeap(), heap_flags, (LPVOID) hmem, size);
     566         hnew=(HGLOBAL)HeapReAlloc(GETPROCESSHEAP, heap_flags, (LPVOID) hmem, size);
    553567      }
    554568      else
    … …  
    570584            if(pintern->Pointer)
    571585            {
    572                if((palloc = HeapReAlloc(GetProcessHeap(), heap_flags,
     586               if((palloc = HeapReAlloc(GETPROCESSHEAP, heap_flags,
    573587                                   (char *) pintern->Pointer-HGLOBAL_SIZE,
    574588                                   size+HGLOBAL_SIZE)) == NULL)
    … …  
    578592            else
    579593            {
    580                 if((palloc=HeapAlloc(GetProcessHeap(), heap_flags, size+HGLOBAL_SIZE))
     594                if((palloc=HeapAlloc(GETPROCESSHEAP, heap_flags, size+HGLOBAL_SIZE))
    581595                   == NULL)
    582596                    return 0;
    … …  
    589603            if(pintern->Pointer)
    590604            {
    591                HeapFree(GetProcessHeap(), 0, (char *) pintern->Pointer-HGLOBAL_SIZE);
     605               HeapFree(GETPROCESSHEAP, 0, (char *) pintern->Pointer-HGLOBAL_SIZE);
    592606               pintern->Pointer=NULL;
    593607            }
    … …  
    628642   if(ISPOINTER(hmem)) /* POINTER */
    629643   {
    630      if(HeapFree(GetProcessHeap(), 0, (LPVOID) hmem) == TRUE)
     644     if(HeapFree(GETPROCESSHEAP, 0, (LPVOID) hmem) == TRUE)
    631645       hreturned = 0;    // success
    632646     else
    … …  
    647661
    648662         if(pintern->Pointer)
    649             if(!HeapFree(GetProcessHeap(), 0, (char *)(pintern->Pointer)-HGLOBAL_SIZE))
     663            if(!HeapFree(GETPROCESSHEAP, 0, (char *)(pintern->Pointer)-HGLOBAL_SIZE))
    650664               hreturned=hmem;
    651          if(!HeapFree(GetProcessHeap(), 0, pintern))
     665         if(!HeapFree(GETPROCESSHEAP, 0, pintern))
    652666            hreturned=hmem;
    653667      }     
    … …  
    680694   if(ISPOINTER(hmem))
    681695   {
    682       retval=HeapSize(GetProcessHeap(), 0,  (LPVOID) hmem);
     696      retval=HeapSize(GETPROCESSHEAP, 0,  (LPVOID) hmem);
    683697   }
    684698   else
    … …  
    691705        if (!pintern->Pointer) /* handle case of GlobalAlloc( ??,0) */
    692706            return 0;
    693          retval=HeapSize(GetProcessHeap(), 0,
     707         retval=HeapSize(GETPROCESSHEAP, 0,
    694708                         (char *)(pintern->Pointer)-HGLOBAL_SIZE)-HGLOBAL_SIZE;
    695709         //SvL: ???
    … …  
    773787   else
    774788   {
    775       /* HeapLock(GetProcessHeap()); */
     789      /* HeapLock(GETPROCESSHEAP); */
    776790      pintern=HANDLE_TO_INTERN(hmem);
    777791      if(pintern->Magic==MAGIC_GLOBAL_USED)
    … …  
    786800         retval=0;
    787801      }
    788       /* HeapUnlock(GetProcessHeap()); */
     802      /* HeapUnlock(GETPROCESSHEAP); */
    789803   }
    790804   return retval;

  • trunk/src/kernel32/os2heap.cpp

    r7358 r7360  
    1 /* $Id: os2heap.cpp,v 1.30 2001-11-16 12:57:00 phaller Exp $ */
     1/* $Id: os2heap.cpp,v 1.31 2001-11-16 14:52:55 phaller Exp $ */
    22
    33/*
    … …  
    4040#endif
    4141
    42 VMutex heaplistmutex;   //protects linked lists of heaps
    43 
    4442void * _LNK_CONV getmoreHeapMem(Heap_t pHeap, size_t *size, int *clean);
    4543void   _LNK_CONV releaseHeapMem(Heap_t pHeap, void *block, size_t size);
    4644
     45VMutex heaplistmutex;   //protects linked lists of heaps
     46
    4747
    4848//******************************************************************************
    … …  
    6060  OS2Heap *curheap = OS2Heap::heap;
    6161 
     62#ifdef DEBUG
    6263  totalAlloc   = 0;
     64#endif
    6365  fInitialized = 0;
    6466  nrHeaps      = 0;
    … …  
    158160      memset(lpMem, 0, dwBytes+HEAP_OVERHEAD);
    159161  }
     162 
     163#ifdef DEBUG
    160164  totalAlloc += dwBytes;
    161 
     165#endif
     166 
    162167  //align at 8 byte boundary
    163168  lpHeapObj = (HEAPELEM *)(((ULONG)lpMem+7) & ~7);
    … …  
    251256  int size = Size(0, lpMem);
    252257  dprintf(("OS2Heap::Free lpMem = %X, size %d\n", lpMem, size));
     258#ifdef DEBUG
    253259  totalAlloc -= size;
     260#endif
    254261#endif
    255262
    … …  
    272279  dprintf(("OS2Heap::Validate, %X %X", dwFlags, lpMem));
    273280
    274   if(lpMem == NULL) {
    275         dprintf(("OS2Heap::Validate lpMem == NULL\n"));
    276         return(FALSE);
    277   }
    278281  /* verify lpMem address */
    279282  if (lpMem >= (LPVOID)ulMaxAddr || lpMem < (LPVOID)0x10000)
    … …  
    341344OS2Heap *OS2Heap::heap = NULL;
    342345
     346
    343347//******************************************************************************
    344348//******************************************************************************
    … …  
    353357  //NOTE: MUST use 64kb here or else we are at risk of running out of virtual
    354358  //      memory space. (when allocating 4kb we actually get 4kb + 60k uncommited)
    355   *size = (*size / 65536) * 65536 + 65536;
     359  *size = ( (*size / 65536) + 1) * 65536;
    356360
    357361  rc = DosAllocMem(&newblock, *size, PAG_READ|PAG_WRITE|PAG_COMMIT|PAG_EXECUTE);

  • trunk/src/kernel32/os2heap.h

    r7091 r7360  
    1 /* $Id: os2heap.h,v 1.9 2001-10-17 13:38:50 phaller Exp $ */
     1/* $Id: os2heap.h,v 1.10 2001-11-16 14:52:56 phaller Exp $ */
    22
    33/*
    … …  
    5151protected:
    5252
    53     DWORD     dwMaximumSize, dwInitialSize, flOptions, totalAlloc, nrHeaps;
     53    DWORD     dwMaximumSize, dwInitialSize, flOptions, nrHeaps;
     54#ifdef DEBUG
     55    DWORD totalAlloc;
     56#endif
    5457    HANDLE    hPrimaryHeap;
    5558    BOOL      fInitialized;
Note: See TracChangeset for help on using the changeset viewer.