मशीन पर हार्डवेयर (सीपीयू और रैम) कैसे निर्धारित करें?

Question

मैं एक क्रॉस प्लेटफ़ॉर्म प्रोफाइलिंग सूट पर काम कर रहा हूं, और प्रत्येक रन की रिपोर्ट में मशीन के सीपीयू (आर्किटेक्चर/घड़ी की गति/कोर) और रैम (कुल) के बारे में जानकारी जोड़ना चाहता हूं। वर्तमान में मुझे विंडोज और यूनिक्स को लक्षित करने की आवश्यकता है, इसलिए मुझे इस जानकारी को दोनों प्लेटफार्मों, किसी भी सुराग से प्राप्त करने के तरीकों की आवश्यकता है?

संपादित करें: महान जवाब के लिए धन्यवाद, अब मैं CPU वास्तुकला, कोर और कुल मेमोरी का सीपीयू नंबर मिला, लेकिन मैं अभी भी है कि एक के लिए किसी भी विचार सीपीयू के लिए एक क्लॉक कमी कर रहा हूँ?

Answer 1

सीपीयू आसान है। cpuid निर्देश का प्रयोग करें। मैं यह निर्धारित करने के लिए एक पोर्टेबल तरीका खोजने के लिए अन्य पोस्टर छोड़ दूंगा कि सिस्टम में कितनी रैम है। :-)

लिनक्स विशिष्ट विधियों के लिए, आप (और /proc/cpuinfo अगर आप cpuid प्रतिक्रियाओं पार्स करने के लिए परेशान नहीं किया जा सकता है) /proc/meminfo पहुँच सकते हैं।

Answer 2

लिनक्स पर आप पार्स/proc/cpuinfo (प्रत्येक प्रोसेसर पर जानकारी का एक ब्लॉक शामिल कर सकते हैं) और/proc/meminfo (मेमोटॉल समेत विभिन्न सामान्य स्मृति आंकड़े शामिल हैं)।

Answer 3

विंडोज़ पर आप वास्तविक RAM की मात्रा प्राप्त करने के लिए GlobalMemoryStatusEx का उपयोग कर सकते हैं।

प्रोसेसर जानकारी GetSystemInfo के माध्यम से प्राप्त की जा सकती है।

Answer 4

विंडोज मशीन पर जो जानकारी आप चाहते हैं उसे प्राप्त करने के लिए यहां एक तरीका है। मैंने कुछ मामूली संशोधनों के साथ एक वास्तविक परियोजना से इसकी प्रतिलिपि बनाई और चिपकाया, इसलिए अधिक समझने के लिए इसे साफ़ करने के लिए स्वतंत्र महसूस करें।

 int CPUInfo[4] = {-1}; 
     unsigned nExIds, i = 0; 
     char CPUBrandString[0x40]; 
     // Get the information associated with each extended ID. 
     __cpuid(CPUInfo, 0x80000000); 
     nExIds = CPUInfo[0]; 
     for (i=0x80000000; i<=nExIds; ++i) 
     { 
      __cpuid(CPUInfo, i); 
      // Interpret CPU brand string 
      if (i == 0x80000002) 
       memcpy(CPUBrandString, CPUInfo, sizeof(CPUInfo)); 
      else if (i == 0x80000003) 
       memcpy(CPUBrandString + 16, CPUInfo, sizeof(CPUInfo)); 
      else if (i == 0x80000004) 
       memcpy(CPUBrandString + 32, CPUInfo, sizeof(CPUInfo)); 
     } 
     //string includes manufacturer, model and clockspeed 
     cout << "CPU Type: " << CPUBrandString << endl; 


     SYSTEM_INFO sysInfo; 
     GetSystemInfo(&sysInfo); 
     cout << "Number of Cores: " << sysInfo.dwNumberOfProcessors << endl; 

     MEMORYSTATUSEX statex; 
     statex.dwLength = sizeof (statex); 
     GlobalMemoryStatusEx(&statex); 
     cout << "Total System Memory: " << (statex.ullTotalPhys/1024)/1024 << "MB" << endl; 

अधिक जानकारी के लिए, GetSystemInfo, GlobalMemoryStatusEx और __cpuid। हालांकि मैंने इसे शामिल नहीं किया है, लेकिन आप यह भी निर्धारित कर सकते हैं कि ओएस 32 या 64 बिट GetSystemInfo फ़ंक्शन के माध्यम से है या नहीं।

Answer 5

सोलारिस पर:

के लिए इस स्मृति

prtconf | grep Memory 

के लिए इस सीपीयू

psrinfo -v | grep MHz 

Answer 6

विंडोज़ पर सीपीयू क्लॉक स्पीड निर्धारित करने के लिए:

double CPUSpeed() 
{ 
    wchar_t Buffer[_MAX_PATH]; 
    DWORD BufSize = _MAX_PATH; 
    DWORD dwMHz = _MAX_PATH; 
    HKEY hKey; 

    // open the key where the proc speed is hidden: 
    long lError = RegOpenKeyEx(HKEY_LOCAL_MACHINE, 
           L"HARDWARE\\DESCRIPTION\\System\\CentralProcessor\\0", 
           0, 
           KEY_READ, 
           &hKey); 
    if(lError != ERROR_SUCCESS) 
    {// if the key is not found, tell the user why: 
     FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, 
         NULL, 
         lError, 
         0, 
         Buffer, 
         _MAX_PATH, 
         0); 
     wprintf(Buffer); 
     return 0; 
    } 

    // query the key: 
    RegQueryValueEx(hKey, L"~MHz", NULL, NULL, (LPBYTE) &dwMHz, &BufSize); 
    return (double)dwMHz; 
} 

Answer 7

http://en.wikipedia.org/wiki/CPUID के लिए मदद कर सकता है सी PUID

Answer 8

मैं कुछ कोड है जो अधिकतम घड़ी गति प्राप्त करने के लिए WMI सेवा का उपयोग करता लिखा है, मुझे पता है यह VB.net है, लेकिन यह विचार पता चलता है:

''' <summary> 
''' Use WMI to get the Clock Speed in Hz 
''' </summary> 
Public Function GetMaxClockSpeedInHz() As Double 
    Dim manObj = New ManagementObject("Win32_Processor.DeviceID='CPU0'") 
    manObj.Get() 
    GetMaxClockSpeedInHz = Convert.ToInt32(manObj.Properties("MaxClockSpeed").Value) 
End Function 

Win32_OperatingSystem संदर्भ: http://msdn.microsoft.com/en-us/library/Aa394239

डब्ल्यूएमआई संदर्भ: http://msdn.microsoft.com/en-us/library/aa394572(v=VS.85).aspx

Answer 9

ओपी एक सीपीयू घड़ी की गति विंडोज और लिनक्स के बीच नियमित पोर्टेबल की गणना करना चाहता है।ये रहा:

#ifdef WIN32 
#define WIN32_LEAN_AND_MEAN 
#include <windows.h> 
typedef unsigned __int64 usCount; 
static usCount GetUsCount() 
{ 
    static LARGE_INTEGER ticksPerSec; 
    static double scalefactor; 
    LARGE_INTEGER val; 
    if(!scalefactor) 
    { 
     if(QueryPerformanceFrequency(&ticksPerSec)) 
      scalefactor=ticksPerSec.QuadPart/1000000000000.0; 
     else 
      scalefactor=1; 
    } 
    if(!QueryPerformanceCounter(&val)) 
     return (usCount) GetTickCount() * 1000000000; 
    return (usCount) (val.QuadPart/scalefactor); 
} 
#else 
#include <sys/time.h> 
#include <time.h> 
#include <sched.h> 
typedef unsigned long long usCount; 
static usCount GetUsCount() 
{ 
#ifdef CLOCK_MONOTONIC 
    struct timespec ts; 
    clock_gettime(CLOCK_MONOTONIC, &ts); 
    return ((usCount) ts.tv_sec*1000000000000LL)+ts.tv_nsec*1000LL; 
#else 
    struct timeval tv; 
    gettimeofday(&tv, 0); 
    return ((usCount) tv.tv_sec*1000000000000LL)+tv.tv_usec*1000000LL; 
#endif 
} 
#endif 
static usCount usCountOverhead, CPUClockSpeed; 
#ifdef __GNUC__ 
#include "x86intrin.h" 
#define __rdtsc() __builtin_ia32_rdtsc() 
#endif 
static usCount GetClockSpeed() 
{ 
    int n; 
    usCount start, end, start_tsc, end_tsc; 
    if(!usCountOverhead) 
    { 
    usCount foo=0; 
    start=GetUsCount(); 
    for(n=0; n<1000000; n++) 
    { 
     foo+=GetUsCount(); 
    } 
    end=GetUsCount(); 
    usCountOverhead=(end-start)/n; 
    } 
    start=GetUsCount(); 
    start_tsc=__rdtsc(); 
    for(n=0; n<1000; n++) 
#ifdef WIN32 
    Sleep(0); 
#else 
    sched_yield(); 
#endif 
    end_tsc=__rdtsc(); 
    end=GetUsCount(); 
    return (usCount)((1000000000000.0*(end_tsc-start_tsc))/(end-start-usCountOverhead)); 
} 

जाहिर है इस 86/64 पर ही काम करता है, और यह सीपीयू के रूप में एक ही गति से गिनती टीएससी पर निर्भर करता है। यदि आपने अजीब ओवरक्लिंग चीजें की हैं जैसे उदा। मेरे पर मैं एफएसबी पर चढ़ता हूं लेकिन कोर घड़ी को स्पेक पर रखने के लिए गुणक को डाउन्रेट करता हूं, इसलिए टीएससी एफएसबी समय पर अधिकतम गुणक जितना तेज़ होगा।

GetClockSpeed ​​() चलाने से पहले सर्वोत्तम परिणाम प्राप्त करने के लिए, मैं सुझाव दूंगा कि आप एंटी-स्पीडस्टेप लूप उदा।

usCount start; 
start=GetUsCount(); 
while(GetUsCount()-start<3000000000000ULL); 
CPUClockSpeed=GetClockSpeed(); 

नियाल

Answer 10

Windows और Win32 सी ++ परियोजनाओं के लिए:

http://www.codeguru.com/cpp/w-p/system/hardwareinformation/article.php/c9087/Three-Ways-to-Retrieve-Processor-Information.htm

ऊपर URL और निहित लेख विंडोज पर सीपीयू जानकारी प्राप्त करने में 3 अलग अलग तरीकों को दर्शाता है। स्रोत कोड आलेख के निचले हिस्से में है, अच्छी तरह से लिखा गया है, और इसमें तीन उपयोगी वर्ग हैं जिन्हें आप अपने Win32 C++ कोड से कॉल कर सकते हैं।