void CCppLanguageTester::test_cpp_alloc_physical_memory()
{
MEMORYSTATUS startMemoryStatus = {0};
MEMORYSTATUS afterNewMemoryStatus = {0};
MEMORYSTATUS afterAccessMemoryStatus = {0};
GlobalMemoryStatus(&startMemoryStatus);
//申请分配10M的内存空间
const int nAllocSize = 10 * 1024 * 1024;
BYTE *pBuff = new BYTE[ nAllocSize ];
GlobalMemoryStatus(&afterNewMemoryStatus);
ZeroMemory(pBuff, nAllocSize);
GlobalMemoryStatus(&afterAccessMemoryStatus);
delete [] pBuff;
FTLTRACE(TEXT("Memory Status: Start -> AfterNew -> AfterAccess\n")),
FTLTRACE(TEXT(" AvailPhys: %fM -> %fM -> %fM\n"),
(float)startMemoryStatus.dwAvailPhys/1024/1024,
(float)afterNewMemoryStatus.dwAvailPhys/1024/1024,
(float)afterAccessMemoryStatus.dwAvailPhys/1024/1024);
FTLTRACE(TEXT(" AvailVirtual: %fM -> %fM -> %fM\n"),
(float)startMemoryStatus.dwAvailVirtual/1024/1024,
(float)afterNewMemoryStatus.dwAvailVirtual/1024/1024,
(float)afterAccessMemoryStatus.dwAvailVirtual/1024/1024);
//调用new以后内存即会分配
CPPUNIT_ASSERT(startMemoryStatus.dwAvailPhys - afterNewMemoryStatus.dwAvailPhys >= nAllocSize);
}
static int modmem_memory_total( INSTANCE * my, int * params )
{
#ifdef WIN32
MEMORYSTATUS mem ;
GlobalMemoryStatus( &mem ) ;
return mem.dwTotalPhys ;
#elif defined(TARGET_BEOS)
system_info info;
get_system_info( &info );
return B_PAGE_SIZE * ( info.max_pages );
#elif !defined(TARGET_MAC) && !defined(TARGET_WII)
/* Linux and other Unix (?) */
struct sysinfo meminf;
int fv;
if ( sysinfo( &meminf ) == -1 ) return -1;
if ( !( fv = kernel_version_type() ) ) return -1;
if ( fv == 1 )
return meminf.totalram * meminf.mem_unit;
else
return meminf.totalram;
return -1;
#else
return 0; //TODO
#endif
}
static void get_random_info(unsigned char seed[16])
{
#if defined(_XBOX)
AssertFatal(false, "get_random_info not implemented on Xbox360");
#else
MD5_CTX c;
struct {
MEMORYSTATUS m;
SYSTEM_INFO s;
FILETIME t;
LARGE_INTEGER pc;
DWORD tc;
DWORD l;
TCHAR hostname[MAX_COMPUTERNAME_LENGTH + 1];
} r;
MD5Init(&c); /* memory usage stats */
GlobalMemoryStatus(&r.m); /* random system stats */
GetSystemInfo(&r.s); /* 100ns resolution (nominally) time of day */
GetSystemTimeAsFileTime(&r.t); /* high resolution performance counter */
QueryPerformanceCounter(&r.pc); /* milliseconds since last boot */
r.tc = GetTickCount();
r.l = MAX_COMPUTERNAME_LENGTH + 1;
GetComputerName(r.hostname, &r.l );
MD5Update(&c, (unsigned char *) &r, sizeof(r));
MD5Final(seed, &c);
#endif
}
bool UpdateSystemInfoP( FvSystemInfo &kSI )
{
if ( s_pfImportedGetSystemTimes )
{
FILETIME kIdleFileTime, kKernelFileTime, kUserFileTime;
s_pfImportedGetSystemTimes( &kIdleFileTime, &kKernelFileTime, &kUserFileTime );
FvUInt64 uiIdleTime = *(FvUInt64*)&kIdleFileTime;
FvUInt64 uiKernelTime = *(FvUInt64*)&kKernelFileTime;
FvUInt64 uiUserTime = *(FvUInt64*)&kUserFileTime;
//gCurMaxCPU = (uiKernelTime + uiKserTime) / gCPUCount;
//td.curCPU = gCurMaxCPU - uiIdleTime / gCPUCount;
}
MEMORYSTATUS kMem;
GlobalMemoryStatus( &kMem );
kSI.m_kMem.max.update(kMem.dwTotalPhys);
kSI.m_kMem.val.update(kMem.dwAvailPhys);
MIB_IPSTATS kIPStats;
GetIpStatistics( &kIPStats );
kSI.m_kPackTotOut.update(kIPStats.dwOutRequests);
kSI.m_kPackDropOut.update(kIPStats.dwOutDiscards);
kSI.m_kPackTotIn.update(kIPStats.dwInReceives);
kSI.m_kPackDropIn.update(kIPStats.dwInDiscards);
return true;
}
void ofApp::checkMemory() {
// Check Memory
MEMORYSTATUS memInfo;
memInfo.dwLength = sizeof(MEMORYSTATUS);
GlobalMemoryStatus(&memInfo);
// Virtual Memory
DWORDLONG totalVirtualMem = memInfo.dwTotalVirtual;
DWORDLONG totalVirtualMemMB = totalVirtualMem / DIV;
DWORDLONG virtualMemUsed = memInfo.dwTotalVirtual - memInfo.dwAvailVirtual;
DWORDLONG virtualMemUsedMB = virtualMemUsed / DIV;
cout << "Total Virtual Memory Is " << totalVirtualMemMB << " MB (" << (totalVirtualMemMB / 1000) / 1000 << " GB)." << endl;
cout << "We Are Using " << virtualMemUsedMB << " MB (" << (virtualMemUsedMB / 1000) / 1000 << " GB) Of That Amount. " << endl;
// Physical Memory
DWORDLONG totalPhysMem = memInfo.dwTotalPhys;
DWORDLONG totalPhysMemMB = totalPhysMem / DIV;
DWORDLONG physMemUsed = memInfo.dwTotalPhys - memInfo.dwAvailPhys;
DWORDLONG physMemUsedMB = physMemUsed / DIV;
cout << "Total Physical Memory Is " << totalPhysMemMB << " MB (" << (totalPhysMemMB / 1000) / 1000 << " GB)." << endl;
cout << "We Are Using " << physMemUsedMB << " MB (" << (physMemUsedMB / 1000) / 1000 << " GB) Of That Amount. " << endl;
}
/*
* This function is called on a timer, and it will monitor
* frequently changing quantities such as the state of physical and
* virtual memory, the state of the process's message queue, which
* window is in the foreground, which owns the clipboard, etc.
*/
void noise_regular(void)
{
HWND w;
DWORD z;
POINT pt;
MEMORYSTATUS memstat;
FILETIME times[4];
w = GetForegroundWindow();
random_add_noise(&w, sizeof(w));
w = GetCapture();
random_add_noise(&w, sizeof(w));
w = GetClipboardOwner();
random_add_noise(&w, sizeof(w));
z = GetQueueStatus(QS_ALLEVENTS);
random_add_noise(&z, sizeof(z));
GetCursorPos(&pt);
random_add_noise(&pt, sizeof(pt));
GlobalMemoryStatus(&memstat);
random_add_noise(&memstat, sizeof(memstat));
GetThreadTimes(GetCurrentThread(), times, times + 1, times + 2,
times + 3);
random_add_noise(×, sizeof(times));
GetProcessTimes(GetCurrentProcess(), times, times + 1, times + 2,
times + 3);
random_add_noise(×, sizeof(times));
}
void _MEMInfo::_UpdateMI( )
{
#ifdef WIN32
MEMORYSTATUS MS;
GlobalMemoryStatus( &MS );
m_MI.nTotalMem = MS.dwTotalPhys / 1024;
m_MI.nFreeMem = MS.dwAvailPhys / 1024;
#else
char* szfile = ftostr( "/proc/meminfo" );
char* szfind = NULL;
if( szfile )
{
szfind = strstr( szfile, "MemTotal" );
if( szfind )
sscanf( szfind, "MemTotal:\t%u kB",
&m_MI.nTotalMem );
szfind = strstr( szfile, "MemFree" );
if( szfind )
sscanf( szfind, "MemFree:\t%u kB",
&m_MI.nFreeMem );
}
#endif
}
void get_random_info(unsigned char seed[16])
{
MD5_CTX c;
typedef struct {
MEMORYSTATUS m;
SYSTEM_INFO s;
FILETIME t;
LARGE_INTEGER pc;
DWORD tc;
DWORD l;
char hostname[MAX_COMPUTERNAME_LENGTH + 1];
} randomness;
randomness r;
/* Initialize memory area so that valgrind does not complain */
memset(&r, 0, sizeof r);
/* memory usage stats */
GlobalMemoryStatus( &r.m );
/* random system stats */
GetSystemInfo( &r.s );
/* 100ns resolution (nominally) time of day */
GetSystemTimeAsFileTime( &r.t );
/* high resolution performance counter */
QueryPerformanceCounter( &r.pc );
/* milliseconds since last boot */
r.tc = GetTickCount();
r.l = MAX_COMPUTERNAME_LENGTH + 1;
GetComputerName( r.hostname, &r.l );
/* MD5 it */
MD5Init(&c);
MD5Update(&c, (unsigned char *)(&r), sizeof r);
MD5Final(seed, &c);
};
/* Make a guess for a reasonable amount of memory for the hashtable
* @return number of kilo-bytes to be used
*/
unsigned long guessReasonableMaxmemory(void)
{
unsigned long const one_kilo = 1024;
unsigned long const one_giga = 1024*1024;
unsigned long result = one_giga;
/* GlobalMemoryStatusEx() has only been available since Windows 2000
*/
#if defined(_WIN32_WINNT) && _WIN32_WINNT>=_WIN32_WINNT_WIN2K
MEMORYSTATUSEX memstatEx;
memstatEx.dwLength = sizeof memstatEx;
if (GlobalMemoryStatusEx(&memstatEx))
{
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;
}
#else
MEMORYSTATUS memstat;
GlobalMemoryStatus(&memstat);
result = memstat.dwAvailPhys/one_kilo;
#endif
return result;
}
bool VirtualMemoryManager::EnsureFreeMemory(size_t size)
{
if(!inited)
return false;
LockMut(vmemMutex);
MEMORYSTATUS ms;
GlobalMemoryStatus(&ms);
while(ms.dwAvailPhys < size)
{
if(LOG && logging)
LOG->Trace("Freeing memory: need %i, have %i", size, ms.dwAvailPhys);
if(!DecommitLRU())
{
if(LOG)
LOG->Trace("VMem error: No pages left to free while reserving memory");
return false;
}
}
return true;
}
void Sys_InitMemory(void)
{
int i;
i = COM_CheckParm("-heapsize");
if (i && i < com_argc - 1)
host_parms.memsize = Q_atoi(com_argv[i + 1]) * 1024;
if (host_parms.memsize < MINIMUM_WIN_MEMORY)
{
#ifdef _WIN32
MEMORYSTATUS lpBuffer;
lpBuffer.dwLength = sizeof(MEMORYSTATUS);
GlobalMemoryStatus(&lpBuffer);
if (lpBuffer.dwTotalPhys)
{
if (lpBuffer.dwTotalPhys < FIFTEEN_MB)
Sys_Error("%s: Available memory less than 15MB!!! %i", __func__, host_parms.memsize);
host_parms.memsize = (int)(lpBuffer.dwTotalPhys >> 1);
if (host_parms.memsize < MINIMUM_WIN_MEMORY)
host_parms.memsize = MINIMUM_WIN_MEMORY;
}
else
bool COSOperator::getSystemMemory(irr::u32* Total, irr::u32* Avail)
{
#if defined(_IRR_WINDOWS_API_)
MEMORYSTATUS MemoryStatus;
MemoryStatus.dwLength = sizeof(MEMORYSTATUS);
// cannot fail
GlobalMemoryStatus(&MemoryStatus);
if (Total)
*Total = (irr::u32)(MemoryStatus.dwTotalPhys>>10);
if (Avail)
*Avail = (irr::u32)(MemoryStatus.dwAvailPhys>>10);
_IRR_IMPLEMENT_MANAGED_MARSHALLING_BUGFIX;
return true;
#elif defined(_IRR_POSIX_API_) // || defined(MACOSX)
long ps = sysconf(_SC_PAGESIZE);
long pp = sysconf(_SC_PHYS_PAGES);
long ap = sysconf(_SC_AVPHYS_PAGES);
if ((ps==-1)||(pp==-1)||(ap==-1))
return false;
if (Total)
*Total = ((ps*(long long)pp)>>10);
if (Avail)
*Avail = ((ps*(long long)ap)>>10);
return true;
#endif
// TODO: implement for OSX
return false;
}
void Dlg_OnTimer(HWND hwnd, UINT id) {
// Initialize the structure length before calling GlobalMemoryStatus.
MEMORYSTATUS ms = { sizeof(ms) };
GlobalMemoryStatus(&ms);
TCHAR szData[512] = { 0 };
StringCchPrintf(szData, _countof(szData),
TEXT("%d\n%d\n%I64d\n%I64d\n%I64d\n%I64d\n%I64d"),
ms.dwMemoryLoad, ms.dwTotalPhys,
(__int64) ms.dwAvailPhys, (__int64) ms.dwTotalPageFile,
(__int64) ms.dwAvailPageFile, (__int64) ms.dwTotalVirtual,
(__int64) ms.dwAvailVirtual);
SetDlgItemText(hwnd, IDC_DATA, szData);
// Get the current process working set and private bytes.
PROCESS_MEMORY_COUNTERS_EX pmc = { sizeof(PROCESS_MEMORY_COUNTERS_EX) };
GetProcessMemoryInfo(GetCurrentProcess(), (PPROCESS_MEMORY_COUNTERS)&pmc, sizeof(pmc));
StringCchPrintf(szData, _countof(szData),
TEXT("%I64d K\n%I64d K"),
(__int64) pmc.WorkingSetSize / 1024,
(__int64) pmc.PrivateUsage / 1024);
SetDlgItemText(hwnd, IDC_PROCESSDATA, szData);
}
void updateMemoryStatus()
{
//メモリの使用状況を更新する
static Uint32 m_uMemoryUse = 1;
static Uint32 m_uMemoryMaxUse = 1;
static Uint32 m_uMemoryTotal = 0;
MEMORYSTATUS memory;
memory.dwLength = sizeof( MEMORYSTATUS );
GlobalMemoryStatus( &memory );
if( m_uMemoryTotal == 0 )
{
//ゲームで使用可能なメモリ量を計測
m_uMemoryTotal = memory.dwAvailPhys;
m_uMemoryTotal = memory.dwAvailVirtual;
}
//現在ゲームが使用しているメモリ量
m_uMemoryUse = m_uMemoryTotal - memory.dwAvailPhys;
m_uMemoryUse = m_uMemoryTotal - memory.dwAvailVirtual;
//最大風速
if( m_uMemoryUse > m_uMemoryMaxUse ) m_uMemoryMaxUse = m_uMemoryUse;
CGameGirl::GetInstance()->ReportMemoryStatus( m_uMemoryUse , m_uMemoryTotal , m_uMemoryMaxUse );
}
/*
* int sysinfo(struct sysinfo *info)
*/
void SysCalls::sys_sysinfo(CONTEXT& ctx)
{
linux::sysinfo si;
MEMORYSTATUS ms;
GlobalMemoryStatus(&ms);
memset(&si, 0, sizeof(si));
si.uptime = GetTickCount()/1000;
si.loads[0] = 0; //1, 5, and 15 minute load averages
si.loads[1] = 0;
si.loads[2] = 0;
si.totalram = ms.dwAvailPhys;
si.freeram = ms.dwTotalPhys;
si.sharedram = 0;/* Amount of shared memory */
si.bufferram = 0; /* Memory used by buffers */
si.totalswap = ms.dwTotalPageFile;
si.freeswap = ms.dwAvailPageFile;
si.procs = g_pKernelTable->m_Processes.size();
si.totalhigh = 0; /* Total high memory size */
si.freehigh = 0; /* Available high memory size */
si.mem_unit = 4096; //same as page size???
P->WriteMemory((ADDR)ctx.Ebx, sizeof(si), &si);
ctx.Eax = 0;
}
void DumpSystemInformation(HANDLE hLogFile, TCHAR* lpModuleName)
{
//system user name
DWORD nUserNameSize = 120;
TCHAR szTemp[120] = {0};
if (!GetUserName(szTemp, &nUserNameSize))
strcpy_s(szTemp, 120, "UnKnow");
WriteLogFile(hLogFile, "%s run by %s.\r\n", lpModuleName, szTemp);
//system version
TCHAR szWinVer[50] = {0};
TCHAR szMajorMinorBuild[50] = {0};
int nWinVer;
GetWinVer(szWinVer, &nWinVer, szMajorMinorBuild);
WriteLogFile(hLogFile, "Operating system version:%s(%s).\r\n", szWinVer, szMajorMinorBuild);
//process state
SYSTEM_INFO sysinfo;
GetSystemInfo(&sysinfo);
WriteLogFile(hLogFile, "%d process, type %d.\r\n", sysinfo.dwNumberOfProcessors, sysinfo.dwProcessorType);
//memory state
MEMORYSTATUS meminfo;
GlobalMemoryStatus(&meminfo);
WriteLogFile(hLogFile, _T("%d%% memory in use.\r\n"), meminfo.dwMemoryLoad);
WriteLogFile(hLogFile, _T("%d MBytes physical memory.\r\n"), (meminfo.dwTotalPhys+ONEM-1)/ONEM);
WriteLogFile(hLogFile, _T("%d MBytes physical memory free.\r\n"), (meminfo.dwAvailPhys+ONEM-1)/ONEM);
WriteLogFile(hLogFile, _T("%d MBytes paging file.\r\n"), (meminfo.dwTotalPageFile+ONEM-1)/ONEM);
WriteLogFile(hLogFile, _T("%d MBytes paging file free.\r\n"), (meminfo.dwAvailPageFile+ONEM-1)/ONEM);
WriteLogFile(hLogFile, _T("%d MBytes user address space.\r\n"), (meminfo.dwTotalVirtual+ONEM-1)/ONEM);
WriteLogFile(hLogFile, _T("%d MBytes user address space free.\r\n"), (meminfo.dwAvailVirtual+ONEM-1)/ONEM);
}
void plDispatchLog::LogStatusBarChange(const char* name, const char* action)
{
fLog->AddLineF("----- Status bar '%s' %s -----", name, action);
#ifdef HS_BUILD_FOR_WIN32
MEMORYSTATUS ms;
GlobalMemoryStatus(&ms);
MEMORY_BASIC_INFORMATION mbi;
memset(&mbi, 0, sizeof(MEMORY_BASIC_INFORMATION));
// Note: this will return shared mem too on Win9x. There's a way to catch that, but it's too slow -Colin
uint32_t processMemUsed = 0;
void* curAddress = 0;
while (VirtualQuery(curAddress, &mbi, sizeof(MEMORY_BASIC_INFORMATION)) == sizeof(MEMORY_BASIC_INFORMATION))
{
if (mbi.State == MEM_COMMIT && mbi.Type == MEM_PRIVATE)
processMemUsed += mbi.RegionSize;
curAddress = ((BYTE*)mbi.BaseAddress) + mbi.RegionSize;
}
#define ToMB(mem) float(mem) / (1024.f*1024.f)
fLog->AddLineF("# Mem stats");
fLog->AddLineF("# Physical: %.1f MB used %.1f MB free", ToMB(ms.dwTotalPhys-ms.dwAvailPhys), ToMB(ms.dwAvailPhys));
fLog->AddLineF("# Virtual: %.1f MB used %.1f MB free", ToMB(ms.dwTotalVirtual-ms.dwAvailVirtual), ToMB(ms.dwAvailVirtual));
fLog->AddLineF("# Pagefile: %.1f MB used %.1f MB free", ToMB(ms.dwTotalPageFile-ms.dwAvailPageFile), ToMB(ms.dwAvailPageFile));
fLog->AddLineF("# Process: %.1f MB used", ToMB(processMemUsed));
#endif // HS_BUILD_FOR_WIN32
}
CString CBot::SysInfo()
{ CString sSysInfo;
#ifdef WIN32
int total=GetTickCount()/1000;
MEMORYSTATUS memstat; OSVERSIONINFO verinfo;
char szBuffer[MAX_COMPUTERNAME_LENGTH + 1];
DWORD dwNameSize = MAX_COMPUTERNAME_LENGTH + 1;
char *szCompname;
TCHAR szUserName[21];
DWORD dwUserSize = sizeof(szUserName);
GlobalMemoryStatus(&memstat); verinfo.dwOSVersionInfoSize=sizeof(OSVERSIONINFO); GetVersionEx(&verinfo); char *os; char os2[140];
if(verinfo.dwMajorVersion==4 && verinfo.dwMinorVersion==0)
{ if(verinfo.dwPlatformId==VER_PLATFORM_WIN32_WINDOWS) os="95";
if(verinfo.dwPlatformId==VER_PLATFORM_WIN32_NT) os="NT"; }
else if(verinfo.dwMajorVersion==4 && verinfo.dwMinorVersion==10) os="98";
else if(verinfo.dwMajorVersion==4 && verinfo.dwMinorVersion==90) os="ME";
else if(verinfo.dwMajorVersion==5 && verinfo.dwMinorVersion==0) os="2000";
else if(verinfo.dwMajorVersion==5 && verinfo.dwMinorVersion==1) os="XP";
else if(verinfo.dwMajorVersion==5 && verinfo.dwMinorVersion==2) os="2003";
else os="???";
if(verinfo.dwPlatformId==VER_PLATFORM_WIN32_NT && verinfo.szCSDVersion[0]!='\0')
{ sprintf(os2, "%s [%s]", os, verinfo.szCSDVersion); os=os2; }
GetComputerName(szBuffer, &dwNameSize);
szCompname = szBuffer;
GetUserName(szUserName, &dwUserSize);
// *** PhaTTy <MOD> Changed ram: to ##MB/##MB , added box: , added user: </MOD>
sSysInfo.Format("cpu: %dMHz ram: %dMB/%dMB os: %s (%d.%d, build %d) uptime: %dd %dh %dm box: %s user: %s freespace: %s",
cpuspeed(), memstat.dwAvailPhys/1046528, memstat.dwTotalPhys/1046528, os, verinfo.dwMajorVersion, verinfo.dwMinorVersion, verinfo.dwBuildNumber, total/86400, (total%86400)/3600, ((total%86400)%3600)/60, szCompname, szUserName , GetFreeDiskSpace().CStr());
#else
FILE *fp=fopen("/proc/uptime", "r");
float f1, f2;
if(!fp) return CString("Error: Can't open /proc/uptime!");
if(fscanf(fp, "%f %f", &f1, &f2)<2) return CString("Error: Invalid or changed /proc/uptime format!");
fclose(fp);
int days, hours, minutes;
days=((abs((int)f1)/60)/60)/24;
hours=((abs((int)f1)/60)/60)%24;
minutes=(abs((int)f1)/60)%60;
int iDistro=GetDistro(); char *szVersion; char *szKVersion;
bool bGotVer=GetVersion(&szVersion, iDistro);
bool bGotKVer=GetKVersion(&szKVersion, iDistro);
if(!bGotVer) szVersion="Unknown\n"; if(!bGotKVer) szKVersion="Unknown\n";
sSysInfo.Format("cpu: %dMHz. os: %s. kernel: %s. uptime: %dd %dh %dm", cpuspeed(), szVersion, szKVersion, days, hours, minutes);
if(bGotVer) free(szVersion); if(bGotKVer) free(szKVersion);
#endif
return sSysInfo; }
/**
* random init
* @return void
*/
void rand_init()
{
struct
{
#ifndef _WIN32
struct timeval nowt; /* time */
char rnd[32]; /* /dev/urandom */
#else
MEMORYSTATUS mstat; /* memory status */
struct _timeb nowt; /* time */
#endif
} rdat;
arc4_init();
/* Grab OS specific "random" data */
#ifndef _WIN32
/* unix/bsd: time */
gettimeofday(&rdat.nowt, NULL);
/* unix/bsd: /dev/urandom */
int fd = open("/dev/urandom", O_RDONLY);
if (fd)
{
read(fd, &rdat.rnd, sizeof(rdat.rnd));
close(fd);
}
#else
/* win32: time */
_ftime(&rdat.nowt);
/* win32: memory status */
GlobalMemoryStatus(&rdat.mstat);
#endif
arc4_addrandom(&rdat, sizeof(rdat));
}
static void gfx_ctx_d3d_update_title(void *data)
{
d3d_video_t *d3d = (d3d_video_t*)data;
char buf[128], buffer_fps[128];
bool fps_draw = g_settings.fps_show;
if (gfx_get_fps(buf, sizeof(buf), fps_draw ? buffer_fps : NULL, sizeof(buffer_fps)))
{
#ifndef _XBOX
SetWindowText(d3d->hWnd, buf);
#endif
}
if (fps_draw)
{
#ifdef _XBOX
char mem[128];
MEMORYSTATUS stat;
GlobalMemoryStatus(&stat);
snprintf(mem, sizeof(mem), "|| MEM: %.2f/%.2fMB", stat.dwAvailPhys/(1024.0f*1024.0f), stat.dwTotalPhys/(1024.0f*1024.0f));
strlcat(buffer_fps, mem, sizeof(buffer_fps));
#endif
msg_queue_push(g_extern.msg_queue, buffer_fps, 1, 1);
}
#ifndef _XBOX
g_extern.frame_count++;
#endif
}
guint64
gimp_get_physical_memory_size (void)
{
#ifdef G_OS_UNIX
#if defined(HAVE_UNISTD_H) && defined(_SC_PHYS_PAGES) && defined (_SC_PAGE_SIZE)
return (guint64) sysconf (_SC_PHYS_PAGES) * sysconf (_SC_PAGE_SIZE);
#endif
#endif
#ifdef G_OS_WIN32
# if defined(_MSC_VER) && (_MSC_VER <= 1200)
MEMORYSTATUS memory_status;
memory_status.dwLength = sizeof (memory_status);
GlobalMemoryStatus (&memory_status);
return memory_status.dwTotalPhys;
# else
/* requires w2k and newer SDK than provided with msvc6 */
MEMORYSTATUSEX memory_status;
memory_status.dwLength = sizeof (memory_status);
if (GlobalMemoryStatusEx (&memory_status))
return memory_status.ullTotalPhys;
# endif
#endif
return 0;
}
static long long AvailableMemory() {
#ifdef _MSC_VER
MEMORYSTATUS status;
GlobalMemoryStatus(&status);
if (status.dwLength != sizeof(status))
return -1;
return (long long)status.dwAvailPhys;
#elif defined(__APPLE__)
mach_msg_type_number_t count = HOST_VM_INFO_COUNT;
vm_statistics_data_t vmstat;
if (KERN_SUCCESS == host_statistics(mach_host_self(), HOST_VM_INFO,
(host_info_t)&vmstat, &count)) {
double total = vmstat.wire_count + vmstat.active_count +
vmstat.inactive_count + vmstat.free_count;
double free = vmstat.free_count / total; // fraction
return (long long)(TotalGlobalMemory() * free);
}
return -1;
#elif defined(_SC_AVPHYS_PAGES) && defined(_SC_PAGE_SIZE)
long pages = sysconf(_SC_AVPHYS_PAGES);
long page_size = sysconf(_SC_PAGE_SIZE);
if (pages < 0L || page_size < 0L) return -1;
return (long long)(pages * page_size);
#else
return -1;
#endif
}
inline int64_t memory_available()
{
#if defined( ZI_OS_LINUX )
int64_t page_size = static_cast< uint32_t >( sysconf( _SC_PAGE_SIZE ) );
return page_size * sysconf( _SC_AVPHYS_PAGES );
#elif defined( ZI_OS_MACOS )
return memory_size();
#elif defined ( ZI_OS_WINDOWS )
#ifdef WIN64
MEMORYSTATUSEX ms;
#else
MEMORYSTATUS ms;
#endif
ms.dwLength = sizeof(ms);
GlobalMemoryStatus(&ms);
#ifdef WIN64
return static_cast< int64_t >( ms.ullAvailPhys );
#else
return static_cast< int64_t >( ms.dwAvailPhys );
#endif
#else
#warning "no memory_size function available"
#endif
}
//
// getsysmemsize() -- gets the amount of system memory in the machine
//
unsigned int Bgetsysmemsize(void)
{
#ifdef _WIN32
MEMORYSTATUS memst;
GlobalMemoryStatus(&memst);
return (unsigned int)memst.dwTotalPhys;
#elif (defined(_SC_PAGE_SIZE) || defined(_SC_PAGESIZE)) && defined(_SC_PHYS_PAGES)
unsigned int siz = 0x7fffffff;
long scpagesiz, scphyspages;
#ifdef _SC_PAGE_SIZE
scpagesiz = sysconf(_SC_PAGE_SIZE);
#else
scpagesiz = sysconf(_SC_PAGESIZE);
#endif
scphyspages = sysconf(_SC_PHYS_PAGES);
if (scpagesiz >= 0 && scphyspages >= 0)
siz = (unsigned int)min(longlong(0x7fffffff), (int64)scpagesiz * (int64)scphyspages);
//initprintf("Bgetsysmemsize(): %d pages of %d bytes, %d bytes of system memory\n",
// scphyspages, scpagesiz, siz);
return siz;
#else
return 0x7fffffff;
#endif
}
/*
* This function is called on a timer, and it will monitor
* frequently changing quantities such as the state of physical and
* virtual memory, the state of the process's message queue, which
* window is in the foreground, which owns the clipboard, etc.
*/
void noise_regular(void)
{
HWND w;
DWORD z;
POINT pt;
MEMORYSTATUS memstat;
FILETIME times[4];
w = GetForegroundWindow();
random_add_noise(NOISE_SOURCE_FGWINDOW, &w, sizeof(w));
w = GetCapture();
random_add_noise(NOISE_SOURCE_CAPTURE, &w, sizeof(w));
w = GetClipboardOwner();
random_add_noise(NOISE_SOURCE_CLIPBOARD, &w, sizeof(w));
z = GetQueueStatus(QS_ALLEVENTS);
random_add_noise(NOISE_SOURCE_QUEUE, &z, sizeof(z));
GetCursorPos(&pt);
random_add_noise(NOISE_SOURCE_CURSORPOS, &pt, sizeof(pt));
GlobalMemoryStatus(&memstat);
random_add_noise(NOISE_SOURCE_MEMINFO, &memstat, sizeof(memstat));
GetThreadTimes(GetCurrentThread(), times, times + 1, times + 2,
times + 3);
random_add_noise(NOISE_SOURCE_THREADTIME, ×, sizeof(times));
GetProcessTimes(GetCurrentProcess(), times, times + 1, times + 2,
times + 3);
random_add_noise(NOISE_SOURCE_PROCTIME, ×, sizeof(times));
}
void myservice_run()
{
MEMORYSTATUS ms;
DWORD dwWritten;
char str[256];
SYSTEMTIME st;
HANDLE hFile;
// 현재 시간과 메모리 양을 조사하여 문자열로 조립한다.
GetLocalTime(&st);
GlobalMemoryStatus(&ms);
wsprintf(str, "%d월 %d일 %02d시 %02d분 %02d초 => "
"사용가능 물리 메모리=%dMbytes(%d%%), 사용가능 가상메모리=%dMbytes,"
" 사용가능 페이징 파일=%dMbytes\r\n",
st.wMonth, st.wDay, st.wHour, st.wMinute, st.wSecond,
ms.dwAvailPhys/1048576,100-ms.dwMemoryLoad,ms.dwAvailVirtual/1048576,
ms.dwAvailPageFile/1048576);
// 파일로 통계를 출력한다. 버퍼가 가득찬 경우 파일을 다시 만든다.
if (strlen(gbuf) > 60000)
{
hFile=CreateFile("c:\\MemStat.txt",GENERIC_WRITE,0,NULL,
CREATE_ALWAYS,FILE_ATTRIBUTE_NORMAL,NULL);
strcpy(gbuf,"메모리 통계 파일\r\n");
}
else
{
hFile=CreateFile("c:\\MemStat.txt",GENERIC_WRITE,0,NULL,
OPEN_ALWAYS,FILE_ATTRIBUTE_NORMAL,NULL);
}
strcat(gbuf, str);
WriteFile(hFile, gbuf, strlen(gbuf), &dwWritten, NULL);
CloseHandle(hFile);
}
double BytesRandomD()
{
BYTE Buffer[0x464];
SHA_CTX Context;
int idx;
idx = 0;
memcpy(Buffer, RandomSeed, SHA_DIGEST_LENGTH);
idx += sizeof(RandomSeed);
GlobalMemoryStatus((LPMEMORYSTATUS)&Buffer[idx]);
idx += sizeof(MEMORYSTATUS);
UuidCreate((UUID *)&Buffer[idx]);
idx += sizeof(UUID);
GetCursorPos((LPPOINT)&Buffer[idx]);
idx += sizeof(POINT);
*(DWORD *)(Buffer + idx) = GetTickCount();
*(DWORD *)(Buffer + idx + 4) = GetMessageTime();
*(DWORD *)(Buffer + idx + 8) = GetCurrentThreadId();
*(DWORD *)(Buffer + idx + 12) = GetCurrentProcessId();
idx += 16;
QueryPerformanceCounter((LARGE_INTEGER *)&Buffer[idx]);
SHA1_Init(&Context);
SHA1_Update(&Context, Buffer, 0x464);
SHA1_Update(&Context, "additional salt...", 0x13);
SHA1_Final(RandomSeed, &Context);
return BytesSHA1d(Buffer, 0x464);
}
static void RecordSystemInformation(HANDLE LogFile)
{
FILETIME CurrentTime;
GetSystemTimeAsFileTime(&CurrentTime);
char TimeBuffer[100];
PrintTime(TimeBuffer, CurrentTime);
hprintf(LogFile, "Error occurred at %s.\r\n", TimeBuffer);
char ModuleName[MAX_PATH];
if (GetModuleFileName(0, ModuleName, sizeof(ModuleName)) <= 0) {
lstrcpy(ModuleName, "Unknown");
}
char UserName[200];
DWORD UserNameSize = sizeof(UserName);
if (!GetUserName(UserName, &UserNameSize)) {
lstrcpy(UserName, "Unknown");
}
hprintf(LogFile, "%s, run by %s.\r\n", ModuleName, UserName);
SYSTEM_INFO SystemInfo;
GetSystemInfo(&SystemInfo);
hprintf(LogFile, "%d processor(s), type %d.\r\n",
SystemInfo.dwNumberOfProcessors, SystemInfo.dwProcessorType);
MEMORYSTATUS MemInfo;
MemInfo.dwLength = sizeof(MemInfo);
GlobalMemoryStatus(&MemInfo);
// Print out the amount of physical memory, rounded up.
hprintf(LogFile, "%d MBytes physical memory.\r\n", (MemInfo.dwTotalPhys +
ONEM - 1) / ONEM);
}
static void gfx_ctx_d3d_update_title(void *data)
{
char buf[128] = {0};
char buffer_fps[128] = {0};
settings_t *settings = config_get_ptr();
if (video_monitor_get_fps(buf, sizeof(buf),
buffer_fps, sizeof(buffer_fps)))
{
#ifndef _XBOX
d3d_video_t *d3d = (d3d_video_t*)data;
SetWindowText(g_hwnd, buf);
#endif
}
if (settings->fps_show)
{
#ifdef _XBOX
MEMORYSTATUS stat;
char mem[128] = {0};
GlobalMemoryStatus(&stat);
snprintf(mem, sizeof(mem), "|| MEM: %.2f/%.2fMB",
stat.dwAvailPhys/(1024.0f*1024.0f), stat.dwTotalPhys/(1024.0f*1024.0f));
strlcat(buffer_fps, mem, sizeof(buffer_fps));
#endif
rarch_main_msg_queue_push(buffer_fps, 1, 1, false);
}
}
/*
==================
Sys_LowPhysicalMemory
==================
*/
qboolean Sys_LowPhysicalMemory(void)
{
MEMORYSTATUS stat;
GlobalMemoryStatus(&stat);
return (stat.dwTotalPhys <= MEM_THRESHOLD) ? qtrue : qfalse;
}