public static void GetMemoryStatus(out Int32 dwAvailPhys, out Int32 dwTotalPhys)
{
MEMORYSTATUS ms = new MEMORYSTATUS();
ms.dwLength = Marshal.SizeOf(ms);
GlobalMemoryStatus(ref ms);
dwAvailPhys = ms.dwAvailPhys;
dwTotalPhys = ms.dwTotalPhys;
}
/// <summary>
/// get total avail phys bytes
/// </summary>
/// <returns></returns>
public static UInt32 getTotalPhys()
{
UInt32 tvm = 0;
MEMORYSTATUS ms=new MEMORYSTATUS();
ms.dwLength=(uint)Marshal.SizeOf(typeof(MEMORYSTATUS));
if (GetMemoryStatus(ref ms))
tvm = ms.dwTotalPhys;
return tvm;
}
}//public static void Stub()
///<summary>MemoryStatus()</summary>
public static void MemoryStatus()
{
MEMORYSTATUS memoryStatus = new MEMORYSTATUS();
GlobalMemoryStatus( ref memoryStatus );
System.Console.WriteLine("dwLength: {0}", memoryStatus.dwLength);
System.Console.WriteLine("dwMemoryLoad: {0}", memoryStatus.dwMemoryLoad);
System.Console.WriteLine("dwTotalPhys: {0}", memoryStatus.dwTotalPhys);
System.Console.WriteLine("dwAvailPhys: {0}", memoryStatus.dwAvailPhys);
System.Console.WriteLine("dwTotalPageFile: {0}", memoryStatus.dwTotalPageFile);
System.Console.WriteLine("dwAvailPageFile: {0}", memoryStatus.dwAvailPageFile);
System.Console.WriteLine("dwTotalVirtual: {0}", memoryStatus.dwTotalVirtual);
System.Console.WriteLine("dwAvailVirtual: {0}", memoryStatus.dwAvailVirtual);
}//MemoryStatus()
/// <summary>
/// 每隔一秒刷新内存使用率
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void timer1_Tick(object sender, EventArgs e)
{
/// 获取内存使用率
MEMORYSTATUS MemInfo = new MEMORYSTATUS();
GlobalMemoryStatus(ref MemInfo);
int dwMemoryLoad = Convert.ToInt32(MemInfo.dwMemoryLoad);
if (dwMemoryLoad != controlProgressBar4.Progress)
{
controlProgressBar4.Progress = Convert.ToInt32(MemInfo.dwMemoryLoad);
}
controlProgressBar1.Progress = ClassStatic.totalNumberOfUsers;
controlProgressBar2.Progress = ClassStatic.totalNumberOfUsersOnline;
}
public uint GetPhysicalMemoryLoadPercent()
{
//UInt32 storePages = 0;
//UInt32 ramPages = 0;
//UInt32 pageSize = 0;
//int res = GetSystemMemoryDivision(ref storePages,
// ref ramPages, ref pageSize);
// Call the native GlobalMemoryStatus method
// with the defined structure.
MEMORYSTATUS memStatus = new MEMORYSTATUS();
GlobalMemoryStatus(ref memStatus);
return(memStatus.dwMemoryLoad);
}
public static bool GetMemoryStatus(ref MEMORYSTATUS memStatus)
{
bool result = true;
// Call the native GlobalMemoryStatus method
// with the defined structure.
memStatus.dwLength = (uint) Marshal.SizeOf(memStatus);// 32; // bytes
try
{
GlobalMemoryStatus(ref memStatus);
}
catch
{
result = false;
}
return result;
}
// Methods
public static string GetMemoryInfo()
{
uint lpdwStorePages = 0;
uint lpdwRamPages = 0;
uint lpdwPageSize = 0;
GetSystemMemoryDivision(ref lpdwStorePages, ref lpdwRamPages, ref lpdwPageSize);
MEMORYSTATUS lpBuffer = new MEMORYSTATUS();
GlobalMemoryStatus(ref lpBuffer);
StringBuilder builder = new StringBuilder();
builder.Append("\r\nMemory Load: " + lpBuffer.dwMemoryLoad.ToString() + "\r\n");
builder.Append("Total Physical Memory: " + lpBuffer.dwTotalPhys.ToString() + "\r\n");
builder.Append("Avail Physical Memory: " + lpBuffer.dwAvailPhys.ToString() + "\r\n");
builder.Append("Total Virtual Memory: " + lpBuffer.dwTotalVirtual.ToString() + "\r\n");
builder.Append("Avail Virtual Memory: " + lpBuffer.dwAvailVirtual.ToString());
return builder.ToString();
}
/// <summary>
/// Gets the global memory status information for the device.
/// </summary>
/// <param name="total"></param>
/// <param name="free"></param>
public void GetMemoryStatus(out uint total, out uint free)
{
try
{
var mem = new MEMORYSTATUS();
mem.dwLength = (uint)Marshal.SizeOf(mem);
GlobalMemoryStatus(ref mem);
total = mem.dwTotalPhys;
free = mem.dwAvailPhys;
}
catch (Exception)
{
total = 0;
free = 0;
}
}
public static string dumpMSI(MEMORYSTATUS _ms)
{
StringBuilder sb = new StringBuilder();
sb.Append("MEMORYSTATUS info" + "\r\n");
sb.Append("dwTotalPhys: " + _ms.dwTotalPhys.ToString()+"\r\n");
sb.Append("dwAvailPhys: " + _ms.dwAvailPhys.ToString() + "\r\n");
sb.Append("dwTotalVirtual: " + _ms.dwTotalVirtual.ToString() + "\r\n");
sb.Append("dwAvailVirtual: " + _ms.dwAvailVirtual.ToString() + "\r\n");
sb.Append("dwTotalPageFile: " + _ms.dwTotalPageFile.ToString() + "\r\n");
sb.Append("dwAvailPageFile: " + _ms.dwAvailPageFile.ToString() + "\r\n");
sb.Append("dwMemoryLoad: " + _ms.dwMemoryLoad.ToString() + "\r\n");
return sb.ToString();
}
public static bool GetMemoryStatus(ref MEMORYSTATUS memStatus)
{
bool result = true;
// Call the native GlobalMemoryStatus method
// with the defined structure.
memStatus.dwLength = (uint)Marshal.SizeOf(memStatus); // 32; // bytes
try
{
GlobalMemoryStatus(ref memStatus);
}
catch
{
result = false;
}
return(result);
}
private void Refresh()
{
if (isOldOS)
{
memoryStatus = new MEMORYSTATUS();
GlobalMemoryStatus(ref memoryStatus);
}
else
{
memoryStatusEx = new MEMORYSTATUSEX();
memoryStatusEx.Init();
if (!GlobalMemoryStatusEx(ref memoryStatusEx))
{
throw new Win32Exception("Could not obtain memory information due to internal error.");
}
}
}
public static bool FreeVirtualMemoryIfNeeded(int needed)
{
bool result = true;
MEMORYSTATUS memStatus = new MEMORYSTATUS();
GlobalMemoryStatus(ref memStatus);
if (memStatus.dwTotalVirtual < needed)
{
if (SHCloseApps(needed) != 0)
{
result = false;
}
}
return(result);
}
public static string dumpMSI(MEMORYSTATUS _ms)
{
StringBuilder sb = new StringBuilder();
sb.Append("MEMORYSTATUS info" + "\r\n");
sb.Append("dwTotalPhys: " + _ms.dwTotalPhys.ToString() + "\r\n");
sb.Append("dwAvailPhys: " + _ms.dwAvailPhys.ToString() + "\r\n");
sb.Append("dwTotalVirtual: " + _ms.dwTotalVirtual.ToString() + "\r\n");
sb.Append("dwAvailVirtual: " + _ms.dwAvailVirtual.ToString() + "\r\n");
sb.Append("dwTotalPageFile: " + _ms.dwTotalPageFile.ToString() + "\r\n");
sb.Append("dwAvailPageFile: " + _ms.dwAvailPageFile.ToString() + "\r\n");
sb.Append("dwMemoryLoad: " + _ms.dwMemoryLoad.ToString() + "\r\n");
return(sb.ToString());
}
private void Refresh()
{
try
{
if (_monoTotalMemoryCounter != null && _monoAvailableMemoryCounter != null)
{
_totalPhysicalMemory = (ulong)_monoTotalMemoryCounter.NextValue();
_availablePhysicalMemory = (ulong)_monoAvailableMemoryCounter.NextValue();
}
else if (Environment.OSVersion.Version.Major < 5)
{
var memoryStatus = MEMORYSTATUS.Init();
GlobalMemoryStatus(ref memoryStatus);
if (memoryStatus.dwTotalPhys > 0)
{
_availablePhysicalMemory = memoryStatus.dwAvailPhys;
_totalPhysicalMemory = memoryStatus.dwTotalPhys;
}
else if (_netAvailableMemoryCounter != null)
{
_availablePhysicalMemory = (ulong)_netAvailableMemoryCounter.NextValue();
}
}
else
{
var memoryStatusEx = MEMORYSTATUSEX.Init();
if (GlobalMemoryStatusEx(ref memoryStatusEx))
{
_availablePhysicalMemory = memoryStatusEx.ullAvailPhys;
_totalPhysicalMemory = memoryStatusEx.ullTotalPhys;
}
else if (_netAvailableMemoryCounter != null)
{
_availablePhysicalMemory = (ulong)_netAvailableMemoryCounter.NextValue();
}
}
}
catch
{
// ignored
}
}
}//MemoryStatus()
///<summary>FreeProgramMemory()</summary>
public static bool FreeProgramMemory
(
int memSought
)
{
bool result = true;
MEMORYSTATUS memStatus = new MEMORYSTATUS();
GlobalMemoryStatus( ref memStatus );
//check if we're out of memory first
if( memStatus.dwAvailPhys < memSought )
{
if (SHCloseApps(memSought)!= 0)
{
result = false;
}
}//if( memStatus.dwAvailPhys < memSought )
return result;
}//public bool FreeProgramMemory( int memSought )
// Methods
public static string GetMemoryInfo()
{
uint lpdwStorePages = 0;
uint lpdwRamPages = 0;
uint lpdwPageSize = 0;
GetSystemMemoryDivision(ref lpdwStorePages, ref lpdwRamPages, ref lpdwPageSize);
MEMORYSTATUS lpBuffer = new MEMORYSTATUS();
GlobalMemoryStatus(ref lpBuffer);
StringBuilder builder = new StringBuilder();
builder.Append("\r\nMemory Load: " + lpBuffer.dwMemoryLoad.ToString() + "\r\n");
builder.Append("Total Physical Memory: " + lpBuffer.dwTotalPhys.ToString() + "\r\n");
builder.Append("Avail Physical Memory: " + lpBuffer.dwAvailPhys.ToString() + "\r\n");
builder.Append("Total Virtual Memory: " + lpBuffer.dwTotalVirtual.ToString() + "\r\n");
builder.Append("Avail Virtual Memory: " + lpBuffer.dwAvailVirtual.ToString());
return(builder.ToString());
}
/// <summary>
/// This function tries to free up memory for an application. If necessary, the shell closes down other applications by sending WM_CLOSE messages.
/// </summary>
/// <remarks>If a large memory allocation fails in your application, call SHCloseApps and attempt to allocate memory again.</remarks>
/// <param name="needed">Specifies, in kilobytes, the amount of memory to be freed</param>
/// <returns>This function returns TRUE if it is successful and FALSE if it fail</returns>
public static bool FreeProgramMemoryIfNeeded(int needed)
{
bool result = true;
needed *= 1024;
MEMORYSTATUS memStatus = new MEMORYSTATUS();
GlobalMemoryStatus(ref memStatus);
if (memStatus.dwAvailPhys < needed)
{
if (SHCloseApps(needed) != 0)
{
//result = false;
System.Threading.Thread.Sleep(1000);
result = SHCloseApps(needed) == 0;
}
}
return result;
}
/// <summary>
/// This function tries to free up memory for an application. If necessary, the shell closes down other applications by sending WM_CLOSE messages.
/// </summary>
/// <remarks>If a large memory allocation fails in your application, call SHCloseApps and attempt to allocate memory again.</remarks>
/// <param name="needed">Specifies, in kilobytes, the amount of memory to be freed</param>
/// <returns>This function returns TRUE if it is successful and FALSE if it fail</returns>
public static bool FreeProgramMemoryIfNeeded(int needed)
{
bool result = true;
needed *= 1024;
MEMORYSTATUS memStatus = new MEMORYSTATUS();
GlobalMemoryStatus(ref memStatus);
if (memStatus.dwAvailPhys < needed)
{
if (SHCloseApps(needed) != 0)
{
//result = false;
System.Threading.Thread.Sleep(1000);
result = SHCloseApps(needed) == 0;
}
}
return(result);
}
public int availCPUCore(int usedBytePerImage)
{
int num = 0;
int cpuCore = 0;
cpuCore = Environment.ProcessorCount;
if (cpuCore <= 0)
{
SYSTEM_INFO pSI = new SYSTEM_INFO();
GetSystemInfo(ref pSI);
cpuCore = (int)pSI.dwNumberOfProcessors;
}
if (cpuCore <= 0)
{
cpuCore = getCpuCores();
}
MEMORYSTATUS memSt = new MEMORYSTATUS();
GlobalMemoryStatus(ref memSt);
int availMem = (int)memSt.dwAvailPhys;
if (cpuCore * usedBytePerImage < availMem)
{
num = cpuCore;
}
else
{
for (int i = cpuCore - 1; i > 0; i--)
{
if (i * usedBytePerImage < availMem)
{
num = i;
break;
}
}
}
return(num);
}
void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e)
{
MEMORYSTATUS status = new MEMORYSTATUS();
GlobalMemoryStatus(status);
int mem = (int)status.totalPhys;
byte[] src = null;
bool bContinue = true;
do
{
try
{
src = new byte[mem];
int len = src.Length;
while (true && bLoop)
{
len--;
if (len <= 0)
return;
src[len] = 0;
}
bContinue = false;
}
catch (OutOfMemoryException)
{
mem = (int)((double)mem * 0.99);
}
} while (bContinue);
backgroundWorker1.ReportProgress(10);
if (backgroundWorker2 != null)
if (backgroundWorker2.IsBusy)
backgroundWorker2.CancelAsync();
src = null; // free resources instancely
GC.Collect();
GC.GetTotalMemory(false);
GC.Collect();
}
void tmrMain_Tick(object sender, EventArgs e)
{
ulong memusage = 0;
try
{
PerformanceCounter statusBarCounter = new PerformanceCounter("Memory", "Available MBytes");
memusage = ((((new ComputerInfo().TotalPhysicalMemory) / 1024) / 1024) - (ulong)statusBarCounter.NextValue());
}
catch
{
}
lblMemoryUsage.Text = memusage + " MB";
if (chtMemory.Series[0].Points.Count >= 39)
{
chtMemory.Series[0].Points.RemoveAt(0);
}
chtMemory.Series[0].Points.Add(memusage);
CalcCPUUsage();
totalRam = Convert.ToInt32(memusage) + CalcFreeRAM();
lblMemoryTotal.Text = totalRam.ToString() + " MB";
chtMemory.ChartAreas[0].AxisY.Maximum = totalRam;
chtMemory.ChartAreas[0].AxisY.Minimum = 0;
chtMemory.ChartAreas[0].AxisX.Maximum = 39;
if (track == false)
{
trackBarMemoryAmount.Maximum = totalRam - 94;
trackBarMemoryAmount.Value = trackBarMemoryAmount.Maximum;
track = true;
}
if (!ProcessExited)
{
if (prsMain.HasExited)
{
if (File.Exists(Optexe))
prsMain_Exited(prsMain, e);
}
else
{
prbMemory.PerformStep();
if (prbMemory.Value >= prbMemory.Maximum)
{
try
{
prsMain.Kill();
}
catch
{
}
prsMain_Exited(prsMain, e);
}
}
}
if (Visible) return;
if (!W1Done) return;
if ((DateTime.Now.Subtract(LastAuto)).Minutes < 5) return;
MEMORYSTATUS stats = new MEMORYSTATUS();
GlobalMemoryStatus(stats);
if (!(nudOptimizeIfMemory.Value != 0 && stats.availPhys / Math.Pow(1024, 2) <= (double)nudOptimizeIfMemory.Value)
|| (nudIncreaseMemory.Value == 0) || !(nudOptimizeIfCPU.Value == 0 || CPUUsage < (int)nudOptimizeIfCPU.Value))
{
return;
}
// run resource
if (ProcessExited)
{
if (RunMemOpti(null))
{
ProcessExited = false;
prbMemory.Step = 5;
prbMemory.Value = 0;
LastAuto = DateTime.Now;
}
}
if (!ProcessExited) return; //??
prbMemory.Step = 10;
prbMemory.Value = 0;
Trackbar = (int)nudIncreaseMemory.Value;
if (bgwMemory != null)
{
bgwMemory.Dispose();
bgwMemory = null;
}
if (bgwCounter != null)
{
bgwCounter.Dispose();
bgwCounter = null;
}
bgwMemory = new BackgroundWorker { WorkerReportsProgress = true, WorkerSupportsCancellation = false };
bgwMemory.ProgressChanged += bgwMemory_ProgressChanged;
bgwMemory.DoWork += bgwMemory_DoWork;
bgwMemory.RunWorkerCompleted += bgwMemory_RunWorkerCompleted;
bgwCounter = new BackgroundWorker();
bgwCounter.DoWork += bgwCounter_DoWork;
W1Done = false;
Silent = true;
LastAuto = DateTime.Now;
bgwMemory.RunWorkerAsync();
bgwCounter.RunWorkerAsync();
}
static extern void GlobalMemoryStatus(ref MEMORYSTATUS buf);
static extern void GlobalMemoryStatus(ref MEMORYSTATUS ms);
public static extern void GlobalMemoryStatus(out MEMORYSTATUS buffer);
public static extern void CeGlobalMemoryStatus(ref MEMORYSTATUS lpmst);
public int availCPUCore(string filename)
{
int num = 0;
int cpuCore = 0;
cpuCore = Environment.ProcessorCount;
//ManagementClass c = new ManagementClass(new ManagementPath("Win32_Processor"));
//// Get the properties in the class
//ManagementObjectCollection moc = c.GetInstances();
//if (moc.Count > 0)
//{
// cpuCore = moc.Count;
//}
//else
if (cpuCore <= 0)
{
SYSTEM_INFO pSI = new SYSTEM_INFO();
GetSystemInfo(ref pSI);
cpuCore = (int)pSI.dwNumberOfProcessors;
}
if (cpuCore <= 0)
{
cpuCore = getCpuCores();
}
MEMORYSTATUS memSt = new MEMORYSTATUS();
GlobalMemoryStatus(ref memSt);
long availMem = (long)memSt.dwAvailPhys;
Bitmap curBitmap = (Bitmap)Image.FromFile(filename);
GlobalMemoryStatus(ref memSt);
long availMemUsed = (long)memSt.dwAvailPhys;
long usedBytePerImage = availMem - availMemUsed;
long usedByte = curBitmap.Width * curBitmap.Height * 3;
if (usedBytePerImage < usedByte)
{
usedBytePerImage = Convert.ToInt64(usedByte * 1.05);
}
curBitmap.Dispose();
GC.Collect();
GlobalMemoryStatus(ref memSt);
availMem = (long)memSt.dwAvailPhys;
//if (Convert.ToInt32(usedBytePerImage / 1024 / 1024) >= 100)
// cpuCore = 1;
// 每张照片在 读入过程中， 其可能使用的内存为其本身所占内存大小的 8 位左右
// 故以 8 倍来检测可能并行的 核心数
if (cpuCore * (usedBytePerImage / 1024) * 10 < availMem / 1024)
{
num = cpuCore;
}
else
{
for (int i = cpuCore - 1; i > 0; i--)
{
if (i * (usedBytePerImage / 1024) * 10 < availMem / 1024)
{
num = i;
break;
}
}
}
if (num == 0)
{
num = 8;
}
return(num);
}
public uint GetAppVirtualMemoryLoadPercent()
{
MEMORYSTATUS memStatus = new MEMORYSTATUS();
GlobalMemoryStatus(ref memStatus);
return memStatus.dwAvailVirtual / memStatus.dwTotalVirtual;
}
public static int GetMemoryLoad()
{
MEMORYSTATUS memStatus = new MEMORYSTATUS();
GlobalMemoryStatus(ref memStatus);
return memStatus.dwMemoryLoad;
}
public static bool FreeVirtualMemoryIfNeeded(int needed)
{
bool result = true;
MEMORYSTATUS memStatus = new MEMORYSTATUS();
GlobalMemoryStatus(ref memStatus);
if (memStatus.dwTotalVirtual < needed)
{
if (SHCloseApps(needed) != 0)
result = false;
}
return result;
}
private static extern void GlobalMemoryStatus([In, Out] MEMORYSTATUS lpBuffer);
public static extern bool GlobalMemoryStatus(ref MEMORYSTATUS lpBuffer);
/// <summary>
/// Log the systeminformation at the beginning of the logile
/// </summary>
private void LogHeader()
{
// System info
SYSTEM_INFO pSI = new SYSTEM_INFO();
GetSystemInfo(ref pSI);
string CPUType;
switch (pSI.dwProcessorType)
{
case PROCESSOR_INTEL_386:
CPUType = "Intel 386";
break;
case PROCESSOR_INTEL_486:
CPUType = "Intel 486";
break;
case PROCESSOR_INTEL_PENTIUM:
CPUType = "Intel Pentium";
break;
case PROCESSOR_MIPS_R4000:
CPUType = "MIPS R4000";
break;
case PROCESSOR_ALPHA_21064:
CPUType = "DEC Alpha 21064";
break;
default:
CPUType = "(unknown)";
break;
}
MEMORYSTATUS memSt = new MEMORYSTATUS();
GlobalMemoryStatus(ref memSt);
if (USE_LOG4NET)
{
boxLog.Info("Pandora's Box - Log");
boxLog.InfoFormat("Pandora version {0}", Pandora.Version);
boxLog.Info("");
boxLog.Info(DateTime.Now.ToString());
boxLog.Info("Windows version: " + Environment.OSVersion.Version.ToString());
boxLog.Info("Processor family: " + CPUType);
boxLog.Info("Physical memory: " + (memSt.dwTotalPhys / 1024).ToString());
boxLog.Info("");
}
else
{
m_Stream.WriteLine("Pandora's Box - Log");
m_Stream.WriteLine(string.Format("Pandora version {0}", Pandora.Version));
m_Stream.WriteLine("");
m_Stream.WriteLine(DateTime.Now.ToString());
m_Stream.WriteLine("Windows version: " + Environment.OSVersion.Version.ToString());
m_Stream.WriteLine("Processor family: " + CPUType);
m_Stream.WriteLine("Physical memory: " + (memSt.dwTotalPhys / 1024).ToString());
m_Stream.WriteLine();
}
}
internal static extern bool GlobalMemoryStatus(MEMORYSTATUS buffer);
float EXT.IStatusProvider.NextValue()
{
MEMORYSTATUS status = new MEMORYSTATUS();
GlobalMemoryStatus(status);
return (float)status.dwMemoryLoad;
}
private void GetInfo()
{
cpuListView.Items.Clear();
cpuListView.SuspendLayout();
cpuListView.BeginUpdate();
try
{
ManagementObjectCollection mbsList = null;
ManagementObjectSearcher mbs = new ManagementObjectSearcher("Select * From Win32_processor");
mbsList = mbs.Get();
foreach (ManagementObject mo in mbsList)
{
AddItemToList("Processor ID", mo["ProcessorID"].ToString());
}
ManagementObject dsk = new ManagementObject(@"win32_logicaldisk.deviceid=""c:""");
dsk.Get();
AddItemToList("Hard Drive ID", dsk["VolumeSerialNumber"].ToString());
ManagementObjectSearcher mos = new ManagementObjectSearcher("SELECT * FROM Win32_BaseBoard");
ManagementObjectCollection moc = mos.Get();
foreach (ManagementObject mo in moc)
{
AddItemToList("MotherboardID", mo["SerialNumber"].ToString());
}
SYSTEM_INFO pSI = new SYSTEM_INFO();
GetSystemInfo(ref pSI);
string CPUType;
switch (pSI.dwProcessorType)
{
case PROCESSOR_INTEL_386:
CPUType = "Intel 386";
break;
case PROCESSOR_INTEL_486:
CPUType = "Intel 486";
break;
case PROCESSOR_INTEL_PENTIUM:
CPUType = "Intel Pentium";
break;
case PROCESSOR_MIPS_R4000:
CPUType = "MIPS R4000";
break;
case PROCESSOR_ALPHA_21064:
CPUType = "DEC Alpha 21064";
break;
default:
CPUType = pSI.dwProcessorType.ToString();
break;
}
AddItemToList("Active Processor Mask", pSI.dwActiveProcessorMask.ToString());
AddItemToList("Allocation Granularity", pSI.dwAllocationGranularity.ToString());
AddItemToList("Number Of Processors", pSI.dwNumberOfProcessors.ToString());
AddItemToList("OEM ID", pSI.dwOemId.ToString());
AddItemToList("Page Size", pSI.dwPageSize.ToString());
// Processor Level (Req filtering to get level)
AddItemToList("Processor Level Value", pSI.dwProcessorLevel.ToString());
AddItemToList("Processor Revision", pSI.dwProcessorRevision.ToString());
AddItemToList("CPU type", CPUType);
AddItemToList("Minimum Application Address", pSI.lpMinimumApplicationAddress.ToString());
AddItemToList("Maximum Application Address", pSI.lpMaximumApplicationAddress.ToString());
/************** To retrive info from GlobalMemoryStatus ****************/
MEMORYSTATUS memSt = new MEMORYSTATUS();
GlobalMemoryStatus(ref memSt);
AddItemToList("Available Page File", (memSt.dwAvailPageFile / 1024).ToString());
AddItemToList("Available Physical Memory", (memSt.dwAvailPhys / 1024).ToString());
AddItemToList("Available Virtual Memory", (memSt.dwAvailVirtual / 1024).ToString());
AddItemToList("Size of structure", memSt.dwLength.ToString());
AddItemToList("Memory In Use", memSt.dwMemoryLoad.ToString());
AddItemToList("Total Page Size", (memSt.dwTotalPageFile / 1024).ToString());
AddItemToList("Total Physical Memory", (memSt.dwTotalPhys / 1024).ToString());
AddItemToList("Total Virtual Memory", (memSt.dwTotalVirtual / 1024).ToString());
if (System.IntPtr.Size == 4)
{
AddItemToList("Operating System", "32 bit");
}
else if (System.IntPtr.Size == 8)
{
AddItemToList("Operating System", "64 bit");
}
else
{
AddItemToList("Operating System", "Unknown");
}
}
catch (Exception er)
{
MessageBox.Show(er.Message);
}
cpuListView.EndUpdate();
cpuListView.ResumeLayout();
}
public static MEMORYSTATUS GetMemoryStatus()
{
MEMORYSTATUS memSt = new MEMORYSTATUS();
return(memSt);
}
public static extern void GlobalMemoryStatus(MEMORYSTATUS lpBuffer);
public uint GetPhysicalMemoryLoadPercent()
{
//UInt32 storePages = 0;
//UInt32 ramPages = 0;
//UInt32 pageSize = 0;
//int res = GetSystemMemoryDivision(ref storePages,
// ref ramPages, ref pageSize);
// Call the native GlobalMemoryStatus method
// with the defined structure.
MEMORYSTATUS memStatus = new MEMORYSTATUS();
GlobalMemoryStatus(ref memStatus);
return memStatus.dwMemoryLoad;
}
public static extern void GlobalMemoryStatus(ref MEMORYSTATUS stat);
private void GetInfo()
{
cpuListView.Items.Clear();
cpuListView.SuspendLayout();
cpuListView.BeginUpdate();
try
{
ManagementObjectCollection mbsList = null;
ManagementObjectSearcher mbs = new ManagementObjectSearcher("Select * From Win32_processor");
mbsList = mbs.Get();
foreach (ManagementObject mo in mbsList)
AddItemToList("Processor ID", mo["ProcessorID"].ToString());
ManagementObject dsk = new ManagementObject(@"win32_logicaldisk.deviceid=""c:""");
dsk.Get();
AddItemToList("Hard Drive ID", dsk["VolumeSerialNumber"].ToString());
ManagementObjectSearcher mos = new ManagementObjectSearcher("SELECT * FROM Win32_BaseBoard");
ManagementObjectCollection moc = mos.Get();
foreach (ManagementObject mo in moc)
AddItemToList("MotherboardID", mo["SerialNumber"].ToString());
SYSTEM_INFO pSI = new SYSTEM_INFO();
GetSystemInfo(ref pSI);
string CPUType;
switch (pSI.dwProcessorType)
{
case PROCESSOR_INTEL_386:
CPUType = "Intel 386";
break;
case PROCESSOR_INTEL_486:
CPUType = "Intel 486";
break;
case PROCESSOR_INTEL_PENTIUM:
CPUType = "Intel Pentium";
break;
case PROCESSOR_MIPS_R4000:
CPUType = "MIPS R4000";
break;
case PROCESSOR_ALPHA_21064:
CPUType = "DEC Alpha 21064";
break;
default:
CPUType = pSI.dwProcessorType.ToString();
break;
}
AddItemToList("Active Processor Mask", pSI.dwActiveProcessorMask.ToString());
AddItemToList("Allocation Granularity", pSI.dwAllocationGranularity.ToString());
AddItemToList("Number Of Processors", pSI.dwNumberOfProcessors.ToString());
AddItemToList("OEM ID", pSI.dwOemId.ToString());
AddItemToList("Page Size", pSI.dwPageSize.ToString());
// Processor Level (Req filtering to get level)
AddItemToList("Processor Level Value", pSI.dwProcessorLevel.ToString());
AddItemToList("Processor Revision", pSI.dwProcessorRevision.ToString());
AddItemToList("CPU type", CPUType);
AddItemToList("Minimum Application Address", pSI.lpMinimumApplicationAddress.ToString());
AddItemToList("Maximum Application Address", pSI.lpMaximumApplicationAddress.ToString());
/************** To retrive info from GlobalMemoryStatus ****************/
MEMORYSTATUS memSt = new MEMORYSTATUS();
GlobalMemoryStatus(ref memSt);
AddItemToList("Available Page File", (memSt.dwAvailPageFile / 1024).ToString());
AddItemToList("Available Physical Memory", (memSt.dwAvailPhys / 1024).ToString());
AddItemToList("Available Virtual Memory", (memSt.dwAvailVirtual / 1024).ToString());
AddItemToList("Size of structure", memSt.dwLength.ToString());
AddItemToList("Memory In Use", memSt.dwMemoryLoad.ToString());
AddItemToList("Total Page Size", (memSt.dwTotalPageFile / 1024).ToString());
AddItemToList("Total Physical Memory", (memSt.dwTotalPhys / 1024).ToString());
AddItemToList("Total Virtual Memory", (memSt.dwTotalVirtual / 1024).ToString());
if (System.IntPtr.Size == 4)
AddItemToList("Operating System", "32 bit");
else if (System.IntPtr.Size == 8)
AddItemToList("Operating System", "64 bit");
else
AddItemToList("Operating System", "Unknown");
}
catch (Exception er)
{
MessageBox.Show(er.Message);
}
cpuListView.EndUpdate();
cpuListView.ResumeLayout();
}
internal static extern bool GlobalMemoryStatus(MEMORYSTATUS buffer);
/// <summary>
/// Log the systeminformation at the beginning of the logile
/// </summary>
private void LogHeader()
{
// System info
var pSI = new SYSTEM_INFO();
GetSystemInfo(ref pSI);
string CPUType;
switch (pSI.dwProcessorType)
{
case PROCESSOR_INTEL_386:
CPUType = "Intel 386";
break;
case PROCESSOR_INTEL_486:
CPUType = "Intel 486";
break;
case PROCESSOR_INTEL_PENTIUM:
CPUType = "Intel Pentium";
break;
case PROCESSOR_MIPS_R4000:
CPUType = "MIPS R4000";
break;
case PROCESSOR_ALPHA_21064:
CPUType = "DEC Alpha 21064";
break;
default:
CPUType = "(unknown)";
break;
}
var memSt = new MEMORYSTATUS();
GlobalMemoryStatus(ref memSt);
if (USE_LOG4NET)
{
boxLog.Info("Pandora's Box - Log");
boxLog.InfoFormat("Pandora version {0}", Pandora.Version);
boxLog.Info("");
boxLog.Info(DateTime.Now.ToString());
boxLog.Info("Windows version: " + Environment.OSVersion.Version);
boxLog.Info("Processor family: " + CPUType);
boxLog.Info("Physical memory: " + (memSt.dwTotalPhys / 1024));
boxLog.Info("");
}
else
{
m_Stream.WriteLine("Pandora's Box - Log");
m_Stream.WriteLine("Pandora version {0}", Pandora.Version);
m_Stream.WriteLine("");
m_Stream.WriteLine(DateTime.Now.ToString());
m_Stream.WriteLine("Windows version: " + Environment.OSVersion.Version);
m_Stream.WriteLine("Processor family: " + CPUType);
m_Stream.WriteLine("Physical memory: " + (memSt.dwTotalPhys / 1024));
m_Stream.WriteLine();
}
}
void GlobalMemoryStatus(ref MEMORYSTATUS lpBuffer);
extern static void GlobalMemoryStatus(ref MEMORYSTATUS status);
internal static extern void GlobalMemoryStatus(ref MEMORYSTATUS lpBuffer);
public static extern void GlobalMemoryStatus(ref MEMORYSTATUS lpBuffer);
