CeHeapCreate

9/8/2008

Essa função permite que os usuários criem um heap com um personalizado alocador ou função deallocator.

Syntax

HANDLE CeHeapCreate(
  DWORD flOptions,
  DWORD dwInitialSize,
  DWORD dwMaximumSize,
  PFN_AllocHeapMem pfnAlloc,
  PFN_FreeHeapMem pfnFree
);

Parameters

• flOptions
  [no] Reservado. Este parâmetro deve ser definido como zero.

• dwInitialSize
  [no] Tamanho inicial, em bytes, do heap.

  Esse valor determina a quantidade inicial de físico armazenamento que está alocado para o heap.

  O valor é arredondado up to o próximo limite página.

  Para determinar o tamanho de uma página no computador a hospedar, use a função GetSystemInfo.

• dwMaximumSize
  [no] Se dwMaximumSize é um diferente de zero valor, ele especifica o tamanho máximo, em bytes, do heap.

  CeHeapCreate Arredonda dwMaximumSize up to o próximo limite página e, em seguida, reserva um bloco de que tamanho na espaço de endereço virtual do processo para o heap.

  Se alocação solicitações feitas por HeapAlloc ou HeapReAlloc exceder a quantidade inicial de físico espaço armazenamento especificado por dwInitialSize, o sistema aloca páginas adicionais de físico armazenamento para o heap, up to tamanho máximo do heap.

  Se dwMaximumSize é diferente de zero, não é possível aumentar o heap e uma limitação absoluta surge onde todas as alocações são atendidas dentro de heap especificado, a menos que não haja suficiente espaço livre.

  Se dwMaximumSize for zero, ele especifica que o heap pode crescer e tamanho do heap é limitado apenas pela disponível memória.

  As solicitações para alocar blocos maior do que 0x0018000 bytes não falha automaticamente. O sistema chama VirtualAlloc para obter a memória necessária para esses blocos grandes.

  Configure aplicativos que precisam para alocar memória grandes blocos dwMaximumSize para zero.

• pfnAlloc
  [no] A função alocador.

• pfnFree
  [no] A função deallocator.

Return Value

Um identificador para o heap indica sucesso. NULL Indica falha.

Remarks

O seguinte amostra de código mostra uma implementação que usa uma única reserva no físico memória.

É possível usar o físico memória em uma página - por - página base se você mantiver um livre lista do físico memória. Em tais uma maiúsculas e minúsculas, você usar o função nas páginas durante MEM_COMMIT e MEM_DECOMMIT.

// Assuming there are some fast memory available on a platform at physical 
// address 0x40000000, of size 0x80000.
// The following code creates a heap on using this memory when possible.
//
#define  PHYS_MEM_ADDR 0x40000000
#define  PHYS_MEM_SIZE 0x00080000
//
BOOL g_fPhysMemUsed;
//
// The allocator
LPVOID MyAllocMem (LPVOID pAddr, DWORD cbSize, DWORD fdwAction, LPDWORD pdwData)
{
   LPVOID lpRet = NULL;
   switch (fdwAction) {
      case MEM_RESERVE:
      // Reserve VM using VirtualAlloc
      if (!(lpRet = VirtualAlloc (pAddr, cbSize, MEM_RESERVE, PAGE_NOACCESS))) {
         SetLastError (ERROR_OUTOFMEMORY);
         break;
      }
      // Use the physical memory if possible
      if (!g_fPhysMemUsed && (cbSize <= PHYS_MEM_SIZE)) {
         // Yes, physical memory is available, use VirtualCopy
         if (!VirtualCopy (lpRet, (LPVOID) (PHYS_MEM_ADDR >> 8), cbSize, PAGE_READWRITE|PAGE_PHYSICAL)) {
               SetLastError (ERROR_OUTOFMEMORY);
               break;
         }
         g_fPhysMemUsed = TRUE;
         *pdwData = PHYS_MEM_ADDR;
      } 
      else {
         *pdwData = 0;   // Indicates this is not using physical memory
      }
      break;
      case MEM_COMMIT:
      // MEM_COMMIT should not change the content of *pdwData, as the data
      // is a 'per-reservation' information.
      if (PHYS_MEM_ADDR  == *pdwData) {
         // This is using physical memory, already committed
         lpRet = pAddr;
      } 
      else {
         lpRet = VirtualAlloc (pAddr, cbSize, MEM_COMMIT, PAGE_READWRITE);
      }
      break;
      default:
      // This should never happen
         DEBUGCHK (0);
         break;
   }
return lpRet;
}
//
// The de-allocator
//
BOOL MyFreeMem (LPVOID pAddr, DWORD cbSize, DWORD fdwAction, DWORD dwData)
{
   BOOL fRet = FALSE;
   switch (fdwAction) {
      case MEM_DECOMMIT:
         if (PHYS_MEM_ADDR  == dwData) {
            // This is using physical memory; never needs to decommit
            break;
         }
         // VirtualAlloc'd data, decommit the memory
         fRet = VirtualFree (pAddr, cbSize, MEM_DECOMMIT);
         break;
      case MEM_RELEASE:
         // Release the reservation
         fRet = VirtualFree (pAddr, 0, MEM_RELEASE);
         if (fRet && (PHYS_MEM_ADDR  == dwData)) {
            // Physical memory is released and is available again
            g_fPhysMemUsed = TRUE;
         }
         break;
      default:
      // This should never happen
         DEBUGCHK (0);
         break;
      }
   return fRet;
}
//
// To create a heap with the custom allocator/de-allocator
int MyFunc ()
{
   HANDLE hHeap = CeHeapCreate (0, 0, 0, MyAllocMem, MyFreeMem);
   LPVOID p;
   if (hHeap) {
      // Heap creation failed
      // ErrorHandling ();
      return 0;
   }
   // Ordinary heap operation can be performed on the heap
   p = HeapAlloc (hHeap, 0, 100);  
   HeapFree (hHeap, 0, p);
   //...
   // Finish using the heap, destroy it
   HeapDestroy (hHeap);
    return 0;
}

Requirements

Header	winbase.h
Library	coredll.lib
Windows Embedded CE	Windows CE 5.0 and later
Windows Mobile	Windows Mobile Version 5.0 and later

See Also

Reference

Memory Management Functions
GetSystemInfo
HeapAlloc
HeapReAlloc
VirtualAlloc
VirtualFree

Other Resources

PFN_AllocHeapMem
PFN_FreeHeapMem
VirtualCopy