NdbMem.c
上传用户:romrleung
上传日期:2022-05-23
资源大小:18897k
文件大小:7k
源码类别:

MySQL数据库

开发平台:

Visual C++

  1. /* Copyright (C) 2003 MySQL AB
  2.    This program is free software; you can redistribute it and/or modify
  3.    it under the terms of the GNU General Public License as published by
  4.    the Free Software Foundation; either version 2 of the License, or
  5.    (at your option) any later version.
  6.    This program is distributed in the hope that it will be useful,
  7.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  8.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  9.    GNU General Public License for more details.
  10.    You should have received a copy of the GNU General Public License
  11.    along with this program; if not, write to the Free Software
  12.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  13. #include <windows.h>
  14. #include "NdbMem.h"
  15. struct AWEINFO
  16. {
  17.     SIZE_T dwSizeInBytesRequested;
  18.     ULONG_PTR nNumberOfPagesRequested;
  19.     ULONG_PTR nNumberOfPagesActual;
  20.     ULONG_PTR nNumberOfPagesFreed;
  21.     ULONG_PTR* pnPhysicalMemoryPageArray;
  22.     void* pRegionReserved;
  23. };
  24. const size_t cNdbMem_nMaxAWEinfo = 256;
  25. size_t gNdbMem_nAWEinfo = 0;
  26. struct AWEINFO* gNdbMem_pAWEinfo = 0;
  27. void ShowLastError(const char* szContext, const char* szFunction)
  28. {
  29.     DWORD dwError = GetLastError();
  30.     LPVOID lpMsgBuf;
  31.     FormatMessage( 
  32.         FORMAT_MESSAGE_ALLOCATE_BUFFER | 
  33.         FORMAT_MESSAGE_FROM_SYSTEM | 
  34.         FORMAT_MESSAGE_IGNORE_INSERTS,
  35.         NULL,
  36.         dwError,
  37.         MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
  38.         (LPTSTR)&lpMsgBuf,
  39.         0,
  40.         NULL 
  41.         );
  42.     printf("%s : %s failed : %lu : %sn", szContext, szFunction, dwError, (char*)lpMsgBuf);
  43.     LocalFree(lpMsgBuf);
  44. }
  45. void NdbMem_Create()
  46. {
  47.     // Address Windowing Extensions
  48.     struct PRIVINFO
  49.     {
  50.         DWORD Count;
  51.         LUID_AND_ATTRIBUTES Privilege[1];
  52.     } Info;
  53.     HANDLE hProcess = GetCurrentProcess();
  54.     HANDLE hToken;
  55.     if(!OpenProcessToken(hProcess, TOKEN_ADJUST_PRIVILEGES, &hToken))
  56.     {
  57.         ShowLastError("NdbMem_Create", "OpenProcessToken");
  58.     }
  59.     
  60.     Info.Count = 1;
  61.     Info.Privilege[0].Attributes = SE_PRIVILEGE_ENABLED;
  62.     if(!LookupPrivilegeValue(0, SE_LOCK_MEMORY_NAME, &(Info.Privilege[0].Luid)))
  63.     {
  64.         ShowLastError("NdbMem_Create", "LookupPrivilegeValue");
  65.     }
  66.     
  67.     if(!AdjustTokenPrivileges(hToken, FALSE, (PTOKEN_PRIVILEGES)&Info, 0, 0, 0))
  68.     {
  69.         ShowLastError("NdbMem_Create", "AdjustTokenPrivileges");
  70.     }
  71.     
  72.     if(!CloseHandle(hToken))
  73.     {
  74.         ShowLastError("NdbMem_Create", "CloseHandle");
  75.     }
  76.     
  77.     return;
  78. }
  79. void NdbMem_Destroy()
  80. {
  81.     /* Do nothing */
  82.     return;
  83. }
  84. void* NdbMem_Allocate(size_t size)
  85. {
  86.     // Address Windowing Extensions
  87.     struct AWEINFO* pAWEinfo;
  88.     HANDLE hProcess;
  89.     SYSTEM_INFO sysinfo;
  90.     if(!gNdbMem_pAWEinfo)
  91.     {
  92.         gNdbMem_pAWEinfo = VirtualAlloc(0, 
  93.             sizeof(struct AWEINFO)*cNdbMem_nMaxAWEinfo, 
  94.             MEM_COMMIT|MEM_RESERVE, PAGE_READWRITE);
  95.     }
  96.     assert(gNdbMem_nAWEinfo < cNdbMem_nMaxAWEinfo);
  97.     pAWEinfo = gNdbMem_pAWEinfo+gNdbMem_nAWEinfo++;
  98.     hProcess = GetCurrentProcess();
  99.     GetSystemInfo(&sysinfo);
  100.     pAWEinfo->nNumberOfPagesRequested = (size+sysinfo.dwPageSize-1)/sysinfo.dwPageSize;
  101.     pAWEinfo->pnPhysicalMemoryPageArray = VirtualAlloc(0, 
  102.         sizeof(ULONG_PTR)*pAWEinfo->nNumberOfPagesRequested, 
  103.         MEM_COMMIT|MEM_RESERVE, PAGE_READWRITE);
  104.     pAWEinfo->nNumberOfPagesActual = pAWEinfo->nNumberOfPagesRequested;
  105.     if(!AllocateUserPhysicalPages(hProcess, &(pAWEinfo->nNumberOfPagesActual), pAWEinfo->pnPhysicalMemoryPageArray))
  106.     {
  107.         ShowLastError("NdbMem_Allocate", "AllocateUserPhysicalPages");
  108.         return 0;
  109.     }
  110.     if(pAWEinfo->nNumberOfPagesRequested != pAWEinfo->nNumberOfPagesActual)
  111.     {
  112.         ShowLastError("NdbMem_Allocate", "nNumberOfPagesRequested != nNumberOfPagesActual");
  113.         return 0;
  114.     }
  115.     
  116.     pAWEinfo->dwSizeInBytesRequested = size;
  117.     pAWEinfo->pRegionReserved = VirtualAlloc(0, pAWEinfo->dwSizeInBytesRequested, MEM_RESERVE | MEM_PHYSICAL, PAGE_READWRITE);
  118.     if(!pAWEinfo->pRegionReserved)
  119.     {
  120.         ShowLastError("NdbMem_Allocate", "VirtualAlloc");
  121.         return 0;
  122.     }
  123.     
  124.     if(!MapUserPhysicalPages(pAWEinfo->pRegionReserved, pAWEinfo->nNumberOfPagesActual, pAWEinfo->pnPhysicalMemoryPageArray))
  125.     {
  126.         ShowLastError("NdbMem_Allocate", "MapUserPhysicalPages");
  127.         return 0;
  128.     }
  129.     /*
  130.     printf("allocate AWE memory: %lu bytes, %lu pages, address %lxn", 
  131.         pAWEinfo->dwSizeInBytesRequested, 
  132.         pAWEinfo->nNumberOfPagesActual,
  133.         pAWEinfo->pRegionReserved);
  134.     */
  135.     return pAWEinfo->pRegionReserved;
  136. }
  137. void* NdbMem_AllocateAlign(size_t size, size_t alignment)
  138. {
  139.     /*
  140.     return (void*)memalign(alignment, size);
  141.     TEMP fix
  142.     */
  143.     return NdbMem_Allocate(size);
  144. }
  145. void NdbMem_Free(void* ptr)
  146. {
  147.     // VirtualFree(ptr, 0, MEM_DECOMMIT|MEM_RELEASE);
  148.     
  149.     // Address Windowing Extensions
  150.     struct AWEINFO* pAWEinfo = 0;
  151.     size_t i;
  152.     HANDLE hProcess;
  153.     for(i=0; i<gNdbMem_nAWEinfo; ++i)
  154.     {
  155.         if(ptr==gNdbMem_pAWEinfo[i].pRegionReserved)
  156.         {
  157.             pAWEinfo = gNdbMem_pAWEinfo+i;
  158.         }
  159.     }
  160.     if(!pAWEinfo)
  161.     {
  162.         ShowLastError("NdbMem_Free", "ptr is not AWE memory");
  163.     }
  164.     hProcess = GetCurrentProcess();
  165.     if(!MapUserPhysicalPages(ptr, pAWEinfo->nNumberOfPagesActual, 0))
  166.     {
  167.         ShowLastError("NdbMem_Free", "MapUserPhysicalPages");
  168.     }
  169.     
  170.     if(!VirtualFree(ptr, 0, MEM_RELEASE))
  171.     {
  172.         ShowLastError("NdbMem_Free", "VirtualFree");
  173.     }
  174.     
  175.     pAWEinfo->nNumberOfPagesFreed = pAWEinfo->nNumberOfPagesActual;
  176.     if(!FreeUserPhysicalPages(hProcess, &(pAWEinfo->nNumberOfPagesFreed), pAWEinfo->pnPhysicalMemoryPageArray))
  177.     {
  178.         ShowLastError("NdbMem_Free", "FreeUserPhysicalPages");
  179.     }
  180.     
  181.     VirtualFree(pAWEinfo->pnPhysicalMemoryPageArray, 0, MEM_DECOMMIT|MEM_RELEASE);
  182. }
  183. int NdbMem_MemLockAll()
  184. {
  185.     /*
  186.     HANDLE hProcess = GetCurrentProcess();
  187.     SIZE_T nMinimumWorkingSetSize;
  188.     SIZE_T nMaximumWorkingSetSize;
  189.     GetProcessWorkingSetSize(hProcess, &nMinimumWorkingSetSize, &nMaximumWorkingSetSize);
  190.     ndbout << "nMinimumWorkingSetSize=" << nMinimumWorkingSetSize << ", nMaximumWorkingSetSize=" << nMaximumWorkingSetSize << endl;
  191.     SetProcessWorkingSetSize(hProcess, 50000000, 100000000);
  192.   
  193.     GetProcessWorkingSetSize(hProcess, &nMinimumWorkingSetSize, &nMaximumWorkingSetSize);
  194.     ndbout << "nMinimumWorkingSetSize=" << nMinimumWorkingSetSize << ", nMaximumWorkingSetSize=" << nMaximumWorkingSetSize << endl;
  195.     */
  196.     return -1;
  197. }
  198. int NdbMem_MemUnlockAll()
  199. {
  200.     //VirtualUnlock();
  201.     return -1;
  202. }