llmemory.cpp
上传用户:king477883
上传日期:2021-03-01
资源大小:9553k
文件大小:5k
源码类别:

游戏引擎

开发平台:

C++ Builder

  1. /** 
  2.  * @file llmemory.cpp
  3.  * @brief Very special memory allocation/deallocation stuff here
  4.  *
  5.  * $LicenseInfo:firstyear=2002&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2002-2010, Linden Research, Inc.
  8.  * 
  9.  * Second Life Viewer Source Code
  10.  * The source code in this file ("Source Code") is provided by Linden Lab
  11.  * to you under the terms of the GNU General Public License, version 2.0
  12.  * ("GPL"), unless you have obtained a separate licensing agreement
  13.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  14.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  15.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  16.  * 
  17.  * There are special exceptions to the terms and conditions of the GPL as
  18.  * it is applied to this Source Code. View the full text of the exception
  19.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  20.  * online at
  21.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  22.  * 
  23.  * By copying, modifying or distributing this software, you acknowledge
  24.  * that you have read and understood your obligations described above,
  25.  * and agree to abide by those obligations.
  26.  * 
  27.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  28.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  29.  * COMPLETENESS OR PERFORMANCE.
  30.  * $/LicenseInfo$
  31.  */
  32. #include "linden_common.h"
  33. #if defined(LL_WINDOWS)
  34. # include <windows.h>
  35. # include <psapi.h>
  36. #elif defined(LL_DARWIN)
  37. # include <sys/types.h>
  38. # include <mach/task.h>
  39. # include <mach/mach_init.h>
  40. #elif LL_LINUX || LL_SOLARIS
  41. # include <unistd.h>
  42. #endif
  43. #include "llmemory.h"
  44. //----------------------------------------------------------------------------
  45. //static
  46. char* LLMemory::reserveMem = 0;
  47. //static
  48. void LLMemory::initClass()
  49. {
  50. if (!reserveMem)
  51. {
  52. reserveMem = new char[16*1024]; // reserve 16K for out of memory error handling
  53. }
  54. }
  55. //static
  56. void LLMemory::cleanupClass()
  57. {
  58. delete [] reserveMem;
  59. reserveMem = NULL;
  60. }
  61. //static
  62. void LLMemory::freeReserve()
  63. {
  64. delete [] reserveMem;
  65. reserveMem = NULL;
  66. }
  67. void* ll_allocate (size_t size)
  68. {
  69. if (size == 0)
  70. {
  71. llwarns << "Null allocation" << llendl;
  72. }
  73. void *p = malloc(size);
  74. if (p == NULL)
  75. {
  76. LLMemory::freeReserve();
  77. llerrs << "Out of memory Error" << llendl;
  78. }
  79. return p;
  80. }
  81. void ll_release (void *p)
  82. {
  83. free(p);
  84. }
  85. //----------------------------------------------------------------------------
  86. #if defined(LL_WINDOWS)
  87. U64 LLMemory::getCurrentRSS()
  88. {
  89. HANDLE self = GetCurrentProcess();
  90. PROCESS_MEMORY_COUNTERS counters;
  91. if (!GetProcessMemoryInfo(self, &counters, sizeof(counters)))
  92. {
  93. llwarns << "GetProcessMemoryInfo failed" << llendl;
  94. return 0;
  95. }
  96. return counters.WorkingSetSize;
  97. }
  98. #elif defined(LL_DARWIN)
  99. /* 
  100. The API used here is not capable of dealing with 64-bit memory sizes, but is available before 10.4.
  101. Once we start requiring 10.4, we can use the updated API, which looks like this:
  102. task_basic_info_64_data_t basicInfo;
  103. mach_msg_type_number_t  basicInfoCount = TASK_BASIC_INFO_64_COUNT;
  104. if (task_info(mach_task_self(), TASK_BASIC_INFO_64, (task_info_t)&basicInfo, &basicInfoCount) == KERN_SUCCESS)
  105. Of course, this doesn't gain us anything unless we start building the viewer as a 64-bit executable, since that's the only way
  106. for our memory allocation to exceed 2^32.
  107. */
  108. //  if (sysctl(ctl, 2, &page_size, &size, NULL, 0) == -1)
  109. //  {
  110. //  llwarns << "Couldn't get page size" << llendl;
  111. //  return 0;
  112. //  } else {
  113. //  return page_size;
  114. //  }
  115. // }
  116. U64 LLMemory::getCurrentRSS()
  117. {
  118. U64 residentSize = 0;
  119. task_basic_info_data_t basicInfo;
  120. mach_msg_type_number_t  basicInfoCount = TASK_BASIC_INFO_COUNT;
  121. if (task_info(mach_task_self(), TASK_BASIC_INFO, (task_info_t)&basicInfo, &basicInfoCount) == KERN_SUCCESS)
  122. {
  123. residentSize = basicInfo.resident_size;
  124. // If we ever wanted it, the process virtual size is also available as:
  125. // virtualSize = basicInfo.virtual_size;
  126. // llinfos << "resident size is " << residentSize << llendl;
  127. }
  128. else
  129. {
  130. llwarns << "task_info failed" << llendl;
  131. }
  132. return residentSize;
  133. }
  134. #elif defined(LL_LINUX)
  135. U64 LLMemory::getCurrentRSS()
  136. {
  137. static const char statPath[] = "/proc/self/stat";
  138. LLFILE *fp = LLFile::fopen(statPath, "r");
  139. U64 rss = 0;
  140. if (fp == NULL)
  141. {
  142. llwarns << "couldn't open " << statPath << llendl;
  143. goto bail;
  144. }
  145. // Eee-yew!  See Documentation/filesystems/proc.txt in your
  146. // nearest friendly kernel tree for details.
  147. {
  148. int ret = fscanf(fp, "%*d (%*[^)]) %*c %*d %*d %*d %*d %*d %*d %*d "
  149.  "%*d %*d %*d %*d %*d %*d %*d %*d %*d %*d %*d %Lu",
  150.  &rss);
  151. if (ret != 1)
  152. {
  153. llwarns << "couldn't parse contents of " << statPath << llendl;
  154. rss = 0;
  155. }
  156. }
  157. fclose(fp);
  158. bail:
  159. return rss;
  160. }
  161. #elif LL_SOLARIS
  162. #include <sys/types.h>
  163. #include <sys/stat.h>
  164. #include <fcntl.h>
  165. #define _STRUCTURED_PROC 1
  166. #include <sys/procfs.h>
  167. U64 LLMemory::getCurrentRSS()
  168. {
  169. char path [LL_MAX_PATH]; /* Flawfinder: ignore */ 
  170. sprintf(path, "/proc/%d/psinfo", (int)getpid());
  171. int proc_fd = -1;
  172. if((proc_fd = open(path, O_RDONLY)) == -1){
  173. llwarns << "LLmemory::getCurrentRSS() unable to open " << path << ". Returning 0 RSS!" << llendl;
  174. return 0;
  175. }
  176. psinfo_t proc_psinfo;
  177. if(read(proc_fd, &proc_psinfo, sizeof(psinfo_t)) != sizeof(psinfo_t)){
  178. llwarns << "LLmemory::getCurrentRSS() Unable to read from " << path << ". Returning 0 RSS!" << llendl;
  179. close(proc_fd);
  180. return 0;
  181. }
  182. close(proc_fd);
  183. return((U64)proc_psinfo.pr_rssize * 1024);
  184. }
  185. #else
  186. U64 LLMemory::getCurrentRSS()
  187. {
  188. return 0;
  189. }
  190. #endif