/* ================== Sys_LowPhysicalMemory ================== */ qboolean Sys_LowPhysicalMemory() { static MEMORYSTATUSEX stat; static qboolean bAsked = qfalse; static cvar_t* sys_lowmem = Cvar_Get( "sys_lowmem", "0", 0 ); if (!bAsked) // just in case it takes a little time for GlobalMemoryStatus() to gather stats on { // stuff we don't care about such as virtual mem etc. bAsked = qtrue; GlobalMemoryStatusEx (&stat); } if (sys_lowmem->integer) { return qtrue; } return (stat.ullTotalPhys <= MEM_THRESHOLD) ? qtrue : qfalse; }
///////////////////////////////////////////////////////////////////// // GetMemoryInfo => 메모리에 대한 정보를 얻어온다. (단위 MB) // dwTotalMemMB : 시스템 전체 메모리 용량 // dwAvailMemMB : 사용중인 메모리 용량 // dwVirtualMemMB : 가상메모리 전체 용량 ///////////////////////////////////////////////////////////////////// void MBMatchSystemInfo::GetMemoryInfo(DWORD* dwTotalMemMB, DWORD* dwAvailMemMB, DWORD* dwVirtualMemMB) { #ifdef _MONITORING MEMORYSTATUSEX statex; statex.dwLength = sizeof(statex); GlobalMemoryStatusEx(&statex); DWORDLONG lMemTotalMB = (statex.ullTotalPhys / (1024 * 1024)); *dwTotalMemMB = (DWORD)lMemTotalMB; DWORDLONG lAvailMemMB = (statex.ullAvailPhys / (1024 * 1024)); *dwAvailMemMB = (DWORD)lAvailMemMB; DWORDLONG lVirtualMemMB = (statex.ullTotalVirtual / (1024 * 1024)); *dwVirtualMemMB = (DWORD)lVirtualMemMB; #endif }
/* Returns 0 if physical memory size cannot be identified */ StgWord64 getPhysicalMemorySize (void) { static StgWord64 physMemSize = 0; if (!physMemSize) { MEMORYSTATUSEX status; status.dwLength = sizeof(status); if (!GlobalMemoryStatusEx(&status)) { #if defined(DEBUG) errorBelch("warning: getPhysicalMemorySize: cannot get physical " "memory size"); #endif return 0; } physMemSize = status.ullTotalPhys; } return physMemSize; }
boost::uint64_t physical_ram() { boost::uint64_t ret = 0; // figure out how much physical RAM there is in // this machine. This is used for automatically // sizing the disk cache size when it's set to // automatic. #ifdef TORRENT_BSD #ifdef HW_MEMSIZE int mib[2] = { CTL_HW, HW_MEMSIZE }; #else // not entirely sure this sysctl supports 64 // bit return values, but it's probably better // than not building int mib[2] = { CTL_HW, HW_PHYSMEM }; #endif size_t len = sizeof(ret); if (sysctl(mib, 2, &ret, &len, NULL, 0) != 0) ret = 0; #elif defined TORRENT_WINDOWS MEMORYSTATUSEX ms; ms.dwLength = sizeof(MEMORYSTATUSEX); if (GlobalMemoryStatusEx(&ms)) ret = ms.ullTotalPhys; else ret = 0; #elif defined TORRENT_LINUX ret = sysconf(_SC_PHYS_PAGES); ret *= sysconf(_SC_PAGESIZE); #elif defined TORRENT_AMIGA ret = AvailMem(MEMF_PUBLIC); #endif #if TORRENT_USE_RLIMIT if (ret > 0) { struct rlimit r; if (getrlimit(RLIMIT_AS, &r) == 0 && r.rlim_cur != RLIM_INFINITY) { if (ret > r.rlim_cur) ret = r.rlim_cur; } } #endif return ret; }
/*==========================================================================*/ size_t SystemInformation::TotalMemorySize() { // Windows #if defined ( KVS_PLATFORM_WINDOWS ) #if defined ( KVS_PLATFORM_CPU_64 ) MEMORYSTATUSEX memstat; GlobalMemoryStatusEx( &memstat ); return memstat.ullTotalPhys; #else MEMORYSTATUS memstat; GlobalMemoryStatus( &memstat ); return memstat.dwTotalPhys; #endif // Linux #elif defined ( KVS_PLATFORM_LINUX ) || defined ( KVS_PLATFORM_CYGWIN ) long phys_page_size = sysconf( _SC_PHYS_PAGES ); kvsMessageWarning( phys_page_size != -1, ::GetWarningMessage( errno, "_SC_PHYS_PAGES is not supported." ) ); long page_size = sysconf( _SC_PAGESIZE ); kvsMessageWarning( page_size != -1, ::GetWarningMessage( errno, "_SC_PAGESIZE is not supported." ) ); return phys_page_size * page_size; // Mac OS X #elif defined ( KVS_PLATFORM_MACOSX ) #if defined ( KVS_PLATFORM_CPU_64 ) uint64_t memory_size = 0; size_t length = sizeof( memory_size ); int ret = 0; ret = sysctlbyname( "hw.memsize", &memory_size, &length, NULL, 0 ); kvsMessageWarning( ret != -1, strerror( errno ) ); return memory_size; #else uint32_t memory_size = 0; size_t length = sizeof( memory_size ); int ret = 0; ret = sysctlbyname( "hw.physmem", &memory_size, &length, NULL, 0 ); kvsMessageWarning( ret != -1, strerror( errno ) ); return memory_size; #endif #endif }
/** * Return the size of the total physical memory. * \param size returns the size of the total physical memory * \return true for success, or false on failure */ bool os_get_total_physical_memory(uint64_t *size) { #if defined(PIPE_OS_LINUX) const long phys_pages = sysconf(_SC_PHYS_PAGES); const long page_size = sysconf(_SC_PAGE_SIZE); *size = phys_pages * page_size; return (phys_pages > 0 && page_size > 0); #elif defined(PIPE_OS_APPLE) || defined(PIPE_OS_BSD) size_t len = sizeof(size); int mib[2]; mib[0] = CTL_HW; #if defined(PIPE_OS_APPLE) mib[1] = HW_MEMSIZE; #elif defined(PIPE_OS_NETBSD) || defined(PIPE_OS_OPENBSD) mib[1] = HW_PHYSMEM64; #elif defined(PIPE_OS_FREEBSD) mib[1] = HW_REALMEM; #else #error Unsupported *BSD #endif return (sysctl(mib, 2, &size, &len, NULL, 0) == 0); #elif defined(PIPE_OS_HAIKU) system_info info; status_t ret; ret = get_system_info(&info); *size = info.max_pages * B_PAGE_SIZE; return (ret == B_OK); #elif defined(PIPE_OS_WINDOWS) MEMORYSTATUSEX status; BOOL ret; status.dwLength = sizeof(status); ret = GlobalMemoryStatusEx(&status); *size = status.ullTotalPhys; return (ret == TRUE); #else #error unexpected platform in os_sysinfo.c return false; #endif }
static int l_freeMemory (lua_State *L) { #if defined(_WIN32) && (defined(__CYGWIN__) || defined(__CYGWIN32__)) MEMORYSTATUS status; status.dwLength = sizeof(status); GlobalMemoryStatus( &status ); lua_pushnumber(L, status.dwAvailPhys); #elif defined(_WIN32) MEMORYSTATUSEX status; status.dwLength = sizeof(status); GlobalMemoryStatusEx( &status ); lua_pushnumber(L, (size_t)status.ullAvailPhys); #else long pages = sysconf(_SC_AVPHYS_PAGES); long page_size = sysconf(_SC_PAGE_SIZE); lua_pushnumber(L, pages * page_size); #endif return 1; }
/* Make a guess for a reasonable amount of memory for the hashtable * @return number of kilo-bytes to be used */ unsigned long platform_guess_reasonable_maxmemory(void) { unsigned long const one_giga = 1024*1024; unsigned long result = one_giga; MEMORYSTATUSEX memstatEx; memstatEx.dwLength = sizeof memstatEx; if (GlobalMemoryStatusEx(&memstatEx)) { unsigned long const one_kilo = 1024; unsigned long long const available_kilos = memstatEx.ullAvailPhys/one_kilo; /* we are really erring on the safe side here :-) */ if (available_kilos<=ULONG_MAX) result = (unsigned long)available_kilos; } return result; }
RamInfo GetRamInfo() { static Cache<RamInfo> Value; return Value.Get([]() { MEMORYSTATUSEX MemInfo; MemInfo.dwLength = sizeof(MEMORYSTATUSEX); GlobalMemoryStatusEx(&MemInfo); RamInfo Info; Info.TotalPhysicalRam = MemInfo.ullTotalPhys; Info.TotalVirtualRam = MemInfo.ullTotalVirtual; Info.TotalPageRam = MemInfo.ullTotalPageFile; return Info; }); }
// ///////////////////////////////////////////////////////////////// // // ///////////////////////////////////////////////////////////////// bool SystemCheck::CheckVirtualMemory(const I64 minFreeVirtualMemory) { bool result = true; #ifdef _WINDOWS MEMORYSTATUSEX status; GlobalMemoryStatusEx(&status); if(status.ullTotalVirtual < minFreeVirtualMemory) { result = false; } #else std::cout << "No Virtual memory available on this platform!" << std::endl; #endif return (result); }
/** * @file * @brief * Total Ram * * @details * This function looks up the total ram in bytes. * * @param totalram * Output, passed by reference. On successful return, the value * is set to the total ram (in bytes) available on the system. * * @return * The return value indicates the status of the function. */ int meminfo_totalram(memsize_t *totalram) { int ret = MEMINFO_OK; *totalram = 0L; #if OS_LINUX struct sysinfo info; int test = sysinfo(&info); chkret(test, FAILURE); *totalram = (memsize_t) info.totalram * info.mem_unit; #elif OS_MAC int test = sysctl_val("hw.memsize", totalram); chkret(test, FAILURE); #elif OS_WINDOWS MEMORYSTATUSEX status; status.dwLength = sizeof(status); int test = GlobalMemoryStatusEx(&status); winchkret(test, FAILURE); *totalram = (memsize_t) status.ullTotalPhys; #elif OS_FREEBSD int test = sysctl_val("hw.physmem", totalram); chkret(test, FAILURE); #elif OS_NIX memsize_t npages, pagesize; npages = sysconf(_SC_PHYS_PAGES); if (npages == FAILURE) return FAILURE; pagesize = sysconf(_SC_PAGESIZE); if (pagesize == FAILURE) return FAILURE; *totalram = (memsize_t) npages * pagesize; #else ret = PLATFORM_ERROR; #endif return ret; }
/* FIXME: should be using PERFORMANCE_INFORMATION.CommitTotal */ g_val_t swap_free_func ( void ) { MEMORYSTATUSEX stat; DWORDLONG size; g_val_t val; stat.dwLength = sizeof(stat); if ( GlobalMemoryStatusEx (&stat)) { size = stat.ullAvailPageFile; /* get the value in kB */ val.f = size / 1024; } else { val.f = 0; } return val; }
//***************************************************************************** INT64 GetAvailableMemory() { #ifdef _WIN32 // Size of available memory in bytes, with an additional // 200Mb subtracted to take into account heap fragmentation, // and a 100Mb buffer for smaller allocations that may happen in // between checks. MEMORYSTATUSEX statex; statex.dwLength = sizeof (statex); INT64 maxAvailable = 0L; if(GlobalMemoryStatusEx (&statex)) { maxAvailable = min(statex.ullAvailPhys + statex.ullAvailPageFile, statex.ullAvailVirtual); maxAvailable = (maxAvailable > 300000000L) ? maxAvailable - 300000000L : 0L; } return maxAvailable; #else // LINUX throw new MgNotImplementedException(L"GetAvailableMemory", __LINE__, __WFILE__, NULL, L"", NULL); #endif }
/*==========================================================================*/ size_t SystemInformation::FreeMemorySize() { // Windows #if defined ( KVS_PLATFORM_WINDOWS ) #if defined ( KVS_PLATFORM_CPU_64 ) MEMORYSTATUSEX memstat; GlobalMemoryStatusEx( &memstat ); return memstat.ullAvailPhys; #else MEMORYSTATUS memstat; GlobalMemoryStatus( &memstat ); return memstat.dwAvailPhys; #endif // Linux #elif defined ( KVS_PLATFORM_LINUX ) || defined ( KVS_PLATFORM_CYGWIN ) long avphys_page_size = sysconf( _SC_AVPHYS_PAGES ); kvsMessageWarning( avphys_page_size != -1, ::GetWarningMessage( errno, "_SC_AVPHYS_PAGES is not supported." ) ); long page_size = sysconf( _SC_PAGESIZE ); kvsMessageWarning( page_size != -1, ::GetWarningMessage( errno, "_SC_PAGESIZE is not supported." ) ); return avphys_page_size * page_size; // Mac OS X #elif defined ( KVS_PLATFORM_MACOSX ) kern_return_t kr; vm_size_t page_size = 0; kr = host_page_size( mach_host_self(), &page_size ); kvsMessageWarning( kr != KERN_SUCCESS, "Failure to get page size." ); vm_statistics_data_t page_info; mach_msg_type_number_t count = HOST_VM_INFO_COUNT; kr = host_statistics( mach_host_self(), HOST_VM_INFO, (host_info_t)&page_info, &count ); kvsMessageWarning( kr != KERN_SUCCESS, "Failure to get page info." ); return page_info.free_count * page_size; #endif }
static int meminfo_gettext(int tag, char *buf) { MEMORYSTATUSEX memory; memory.dwLength = sizeof(memory); GlobalMemoryStatusEx(&memory); return ksprintf(buf, "MemTotal: %13llu kB\n" "MemFree: %13llu kB\n" "HighTotal: %13llu kB\n" "HighFree: %13llu kB\n" "LowTotal: %13llu kB\n" "LowFree: %13llu kB\n" "SwapTotal: %13llu kB\n" "SwapFree: %13llu kB\n", memory.ullTotalPhys / 1024ULL, memory.ullAvailPhys / 1024ULL, 0ULL, 0ULL, memory.ullTotalPhys / 1024ULL, memory.ullAvailPhys / 1024ULL, memory.ullTotalPageFile / 1024ULL, memory.ullAvailPageFile / 1024ULL); }
/** * @brief * Called from machine independent code to do any machine * dependent initialization. * * @return Void * */ void dep_initialize() { MEMORYSTATUSEX mse; SYSTEM_INFO si; mse.dwLength = sizeof(MEMORYSTATUSEX); GlobalMemoryStatusEx(&mse); pmem_size = mse.ullTotalPhys / 1024; GetSystemInfo(&si); num_acpus = num_oscpus = num_pcpus = si.dwNumberOfProcessors; page_size = si.dwPageSize; if (!init_profile("\\System\\Processor Queue Length", &mom_prof)) { log_err(-1, "dep_initialize", "init_profile failed!"); return; } }
int ustring_GlobalMemoryStatus(lua_State *L) { MEMORYSTATUSEX ms; ms.dwLength = sizeof(ms); if(0 == GlobalMemoryStatusEx(&ms)) return SysErrorReturn(L); lua_createtable(L, 0, 8); PutNumToTable(L, "MemoryLoad", ms.dwMemoryLoad); PutNumToTable(L, "TotalPhys", CAST(double, ms.ullTotalPhys)); PutNumToTable(L, "AvailPhys", CAST(double, ms.ullAvailPhys)); PutNumToTable(L, "TotalPageFile", CAST(double, ms.ullTotalPageFile)); PutNumToTable(L, "AvailPageFile", CAST(double, ms.ullAvailPageFile)); PutNumToTable(L, "TotalVirtual", CAST(double, ms.ullTotalVirtual)); PutNumToTable(L, "AvailVirtual", CAST(double, ms.ullAvailVirtual)); PutNumToTable(L, "AvailExtendedVirtual", CAST(double, ms.ullAvailExtendedVirtual)); return 1; }
HRESULT QueryFreePhysicalMemory( __int64 * pFreeMegaBytes ) { // http://msdn.microsoft.com/en-us/library/aa366589(VS.85).aspx // return an indication of how much free memory is available (in mb) HRESULT hr = E_FAIL; MEMORYSTATUSEX MemoryStatus; ZeroMemory( &MemoryStatus, sizeof(MEMORYSTATUSEX) ); *pFreeMegaBytes = 0; if( GlobalMemoryStatusEx(&MemoryStatus) ) { *pFreeMegaBytes = ((MemoryStatus.ullAvailPhys / 1024) / 1024); hr = S_OK; } return hr; }
g_val_t mem_total_func ( void ) { MEMORYSTATUSEX stat; DWORDLONG size; g_val_t val; stat.dwLength = sizeof(stat); if ( GlobalMemoryStatusEx (&stat)) { size = stat.ullTotalPhys; /* get the value in kB */ val.f = size / 1024; } else { val.f = 0; } return val; }
static unsigned int getmem(void) { unsigned int mem = 0; #ifdef KONOHA_ON_MACOSX int mem_sels[2] = { CTL_HW, HW_PHYSMEM }; size_t length = sizeof(int); sysctl(mem_sels, 2, &mem, &length, NULL, 0); mem = (unsigned int) mem / ONE_MB; #elif defined(KONOHA_ON_WINDOWS) MEMORYSTATUSEX stat; GlobalMemoryStatusEx(&stat); mem = (unsigned int) stat.ullTotalPhys / ONE_MB; #elif defined(KONOHA_ON_LINUX) mem = (unsigned int) getpagesize() * sysconf (_SC_PHYS_PAGES) / ONE_MB; #else TODO(); #endif return mem; }
/** * Populates the host_memory structure using data retrieved using * GlobalMemoryStatusEx function and the Memory performance counter * object. * Returns FALSE if call to GlobalMemoryStatusEx produces an error, TRUE otherwise. * Note that the Windows use of memory and classification of use does * not map cleanly to Linux terms. * We are using Windows available memory for mem_free. Available memory * includes standby memory (memory removed from a process's working set * - its physical memory - on route to disk, but is still available to be recalled) * and free and zero page list bytes. Windows Resource Monitor reports free memory * as free page list bytes. * Memory\\Cache Bytes is used for mem_cached since this really does appear to be * the Linux equivalent of cache (file system cache). * Windows Resource Monitor reports cached as Standby+Modified this is not the * equivalent of Linux file system cache. * Windows also does not seem to report swapping (all memory associated with a process * swapped in/out of memory). Memory\\Pages Input/sec and Memory\\Pages Output/sec * are used for page_in and page_out. */ BOOL readMemoryCounters(SFLHost_mem_counters *mem) { MEMORYSTATUSEX memStat; memStat.dwLength = sizeof(memStat); if (GlobalMemoryStatusEx(&memStat) == 0){ myLog(LOG_ERR,"GlobalMemoryStatusEx failed: %d\n",GetLastError()); return FALSE; } mem->mem_total = memStat.ullTotalPhys; mem->mem_free = memStat.ullAvailPhys; mem->swap_total = memStat.ullTotalPageFile; mem->swap_free = memStat.ullAvailPageFile; PDH_HQUERY query; if (PdhOpenQuery(NULL, 0, &query) == ERROR_SUCCESS) { PDH_HCOUNTER cache, pageIn, pageOut; if (addCounterToQuery(MEM_COUNTER_OBJECT, NULL, MEM_COUNTER_CACHE, &query, &cache) == ERROR_SUCCESS && addCounterToQuery(MEM_COUNTER_OBJECT, NULL, MEM_COUNTER_PAGE_IN, &query, &pageIn) == ERROR_SUCCESS && addCounterToQuery(MEM_COUNTER_OBJECT, NULL, MEM_COUNTER_PAGE_OUT, &query, &pageOut) == ERROR_SUCCESS && PdhCollectQueryData(query) == ERROR_SUCCESS) { mem->mem_cached= getRawCounterValue(&cache); mem->page_in = (uint32_t)getRawCounterValue(&pageIn); mem->page_out = (uint32_t)getRawCounterValue(&pageOut); } PdhCloseQuery(query); } //There are no obvious Windows equivalents mem->mem_shared = UNKNOWN_COUNTER_64; mem->mem_buffers = UNKNOWN_COUNTER_64; //using the definition that swapping is when all the memory associated with a //process is moved in/out of RAM mem->swap_in = UNKNOWN_COUNTER; mem->swap_out = UNKNOWN_COUNTER; myLog(LOG_INFO, "readMemoryCounters:\n\ttotal: \t\t%I64d\n\tfree: \t\t%I64d\n" "\tcached: \t%I64d\n\tpage_in: \t%d\n\tpage_out: \t%d\n" "\tswap_total: \t%I64d\n\tswap_free: \t%I64d\n", mem->mem_total,mem->mem_free, mem->mem_cached,mem->page_in,mem->page_out, mem->swap_total, mem->swap_free); return TRUE; }
Environment::Environment() : m_startup_clock(std::chrono::system_clock::now()) { // detect the compiler std::ostringstream compiler; #ifdef _MSC_VER compiler << "MSC - " << _MSC_VER; #elif defined(__clang__) compiler << "Clang - " << __clang_major__ << '.' << __clang_minor__ << '.' << __clang_patchlevel__; #elif defined(__GNUC__) compiler << "GCC - " << __GNUC__ << '.' << __GNUC_MINOR__ << '.' << __GNUC_PATCHLEVEL__; #else compiler << "unknown"; #endif m_compiler = compiler.str(); #if WIN32_WMI WMIServices wmi; // query system info auto proc_prop = wmi.get_properties( L"SELECT * FROM Win32_Processor", {L"Caption", L"Name", L"L2CacheSize"}); m_system_info = proc_prop[0] + " - " + proc_prop[1] + " - L2Cache(KiB) " + proc_prop[2]; MEMORYSTATUSEX memory_status; ZeroMemory(&memory_status, sizeof(memory_status)); memory_status.dwLength = sizeof(memory_status); if (GlobalMemoryStatusEx(&memory_status)) { std::ostringstream memory_size; memory_size << ", System memory: " << memory_status.ullTotalPhys / (1024. * 1024.) << " GiB"; m_system_info += memory_size.str(); } // query os name auto os_prop = wmi.get_properties(L"SELECT * FROM Win32_OperatingSystem", {L"Caption"}); m_operating_sytem = os_prop[0]; #else m_operating_sytem = "unknown"; m_system_info = "unknown"; #endif }
void Interface_General::get_free_mem(void* kodiBase, long* free, long* total, bool as_bytes) { CAddonDll* addon = static_cast<CAddonDll*>(kodiBase); if (addon == nullptr || free == nullptr || total == nullptr) { CLog::Log(LOGERROR, "Interface_General::%s - invalid data (addon='%p', free='%p', total='%p')", __FUNCTION__, addon, free, total); return; } MEMORYSTATUSEX stat; stat.dwLength = sizeof(MEMORYSTATUSEX); GlobalMemoryStatusEx(&stat); *free = static_cast<long>(stat.ullAvailPhys); *total = static_cast<long>(stat.ullTotalPhys); if (!as_bytes) { *free = *free / ( 1024 * 1024 ); *total = *total / ( 1024 * 1024 ); } }
void display_computer_info(os_info_t const * const oi, system_info_t const * const si) { MEMORYSTATUSEX ms; ms.dwLength = sizeof(ms); GlobalMemoryStatusEx(&ms); printf("------ System Information ------\n"); printf("Computer: %s\n", oi->computer_name); printf("OS: %s (%s)\n", oi->product_name, si->cpu_arch); printf("Build: %s\n", oi->build); printf("Manufacturer: %s\n", si->manufacturer); printf("Pruduct: %s\n", si->product_name); printf("BIOS: %s (%s)\n", si->bios_version, si->bios_date); printf("CPU: %s (%d CPUs)\n", si->cpu_desc, si->cpu_num); printf("Memory: %ldMB RAM\n", (long)get_mb_from_byte(si->memory)); printf("Pagefile: %ldMB\n", (long)get_mb_from_byte(si->pagefile)); printf("\n"); }
void ProcessInfo::getExtraInfo(BSONObjBuilder& info) { MEMORYSTATUSEX mse; mse.dwLength = sizeof(mse); PROCESS_MEMORY_COUNTERS pmc; if (GetProcessMemoryInfo(GetCurrentProcess(), &pmc, sizeof(pmc))) { info.append("page_faults", static_cast<int>(pmc.PageFaultCount)); info.append("usagePageFileMB", static_cast<int>(pmc.PagefileUsage / 1024 / 1024)); } if (GlobalMemoryStatusEx(&mse)) { info.append("totalPageFileMB", static_cast<int>(mse.ullTotalPageFile / 1024 / 1024)); info.append("availPageFileMB", static_cast<int>(mse.ullAvailPageFile / 1024 / 1024)); info.append("ramMB", static_cast<int>(mse.ullTotalPhys / 1024 / 1024)); } #ifndef _WIN64 BOOL wow64Process; BOOL retWow64 = IsWow64Process(GetCurrentProcess(), &wow64Process); info.append("wow64Process", static_cast<bool>(retWow64 && wow64Process)); #endif }
uint64_t Virtual::used() { uint64_t res = 0; #ifdef _WIN32 MEMORYSTATUSEX memInfo; memInfo.dwLength = sizeof(MEMORYSTATUSEX); GlobalMemoryStatusEx(&memInfo); res = memInfo.ullTotalPageFile - memInfo.ullAvailPageFile; #elif __linux struct sysinfo memInfo; sysinfo (&memInfo); res = memInfo.totalram - memInfo.freeram; //Add other values in next statement to avoid int overflow on right hand side... res += memInfo.totalswap - memInfo.freeswap; res *= memInfo.mem_unit; #endif return res; }
INT32 CGSProcessInfo::GSGetTotalMemoryUsage(DWORD &dwMem) { INT32 iRet = -1; #ifdef _WIN32 MEMORYSTATUSEX statex; statex.dwLength = sizeof (statex); GlobalMemoryStatusEx (&statex); dwMem = statex.dwMemoryLoad; iRet = 0; #elif _LINUX FILE *fd; int n; char buff[256]; char name[20]; unsigned long total; char name2[20]; unsigned long free; fd = fopen ("/proc/meminfo", "r"); fgets (buff, sizeof(buff), fd); fgets (buff, sizeof(buff), fd); fgets (buff, sizeof(buff), fd); fgets (buff, sizeof(buff), fd); sscanf (buff, "%s %u %s", name, &total, name2); fgets (buff, sizeof(buff), fd); //从fd文件中读取长度为buff的字符串再存到起始地址为buff这个空间里 sscanf (buff, "%s %u", name2, &free, name2); fclose(fd); //关闭文件fd dwMem = (total - free)*100/total; #endif return iRet; }
static size_t computeRAMSize() { #if OS(DARWIN) int mib[2]; uint64_t ramSize; size_t length; mib[0] = CTL_HW; mib[1] = HW_MEMSIZE; length = sizeof(int64_t); int sysctlResult = sysctl(mib, 2, &ramSize, &length, 0, 0); if (sysctlResult == -1) return ramSizeGuess; return ramSize > std::numeric_limits<size_t>::max() ? std::numeric_limits<size_t>::max() : static_cast<size_t>(ramSize); #elif OS(UNIX) long pages = sysconf(_SC_PHYS_PAGES); long pageSize = sysconf(_SC_PAGE_SIZE); if (pages == -1 || pageSize == -1) return ramSizeGuess; return pages * pageSize; #elif OS(WINCE) MEMORYSTATUS status; status.dwLength = sizeof(status); GlobalMemoryStatus(&status); if (status.dwTotalPhys <= 0) return ramSizeGuess; return status.dwTotalPhys; #elif OS(WINDOWS) MEMORYSTATUSEX status; status.dwLength = sizeof(status); bool result = GlobalMemoryStatusEx(&status); if (!result) return ramSizeGuess; return status.ullTotalPhys; #elif OS(QNX) struct stat mst; if (stat("/proc", &mst)) return ramSizeGuess; return mst.st_size; #endif }
long long unsigned int getFreePhysicalMemory() { #ifdef _WIN32 MEMORYSTATUSEX status; status.dwLength = sizeof(status); GlobalMemoryStatusEx(&status); return status.ullTotalPhys; #elif __APPLE__ int mib[2]; uint64_t physical_memory; size_t length; // Get the Physical memory size mib[0] = CTL_HW; mib[1] = HW_USERMEM; // HW_MEMSIZE -> physical memory length = sizeof(uint64_t); sysctl(mib, 2, &physical_memory, &length, NULL, 0); return physical_memory; #elif __GNUC__ return get_avphys_pages() * getpagesize(); #endif }
static size_t computeRAMSize() { #if OS(WINDOWS) MEMORYSTATUSEX status; status.dwLength = sizeof(status); bool result = GlobalMemoryStatusEx(&status); if (!result) return ramSizeGuess; return status.ullTotalPhys; #elif defined(USE_SYSTEM_MALLOC) && USE_SYSTEM_MALLOC #if OS(LINUX) struct sysinfo si; sysinfo(&si); return si.totalram * si.mem_unit; #else #error "Missing a platform specific way of determining the available RAM" #endif // OS(LINUX) #else return bmalloc::api::availableMemory(); #endif }