开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 游戏引擎 > 查看源码
llprocessor.cpp
资源名称：snowglobe-src-viewer-2.0.0-r0.tar.gz　[点击查看]
上传用户：king477883
上传日期：2021-03-01
资源大小：9553k
文件大小：90k
源码类别：

游戏引擎

开发平台：

C++ Builder

llprocessor.cpp：源码内容
  1. /** 
  2.  * @file llprocessor.cpp
  3.  * @brief Code to figure out the processor. Originally by Benjamin Jurke.
  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.  */
  33. // Filename: Processor.cpp
  34. // =======================
  35. // Author: Benjamin Jurke
  36. // File history: 27.02.2002  - File created. Support for Intel and AMD processors
  37. //               05.03.2002  - Fixed the CPUID bug: On Pre-Pentium CPUs the CPUID
  38. //                             command is not available
  39. //                           - The CProcessor::WriteInfoTextFile function do not 
  40. //                             longer use Win32 file functions (-> os independend)
  41. //                           - Optional include of the windows.h header which is
  42. //                             still need for CProcessor::GetCPUFrequency.
  43. //               06.03.2002  - My birthday (18th :-))
  44. //                           - Replaced the 'rn' line endings in function 
  45. //                             CProcessor::CPUInfoToText by 'n'
  46. //                           - Replaced unsigned __int64 by signed __int64 for
  47. //                             solving some compiler conversion problems
  48. //                           - Fixed a bug at family=6, model=6 (Celeron -> P2)
  49. //////////////////////////////////////////////////////////////////////////////////
  51. #include "linden_common.h"
  53. #include "processor.h"
  55. #include <memory>
  57. #if LL_WINDOWS
  58. # define WIN32_LEAN_AND_MEAN
  59. # include <winsock2.h>
  60. # include <windows.h>
  61. #endif
  63. #if !LL_DARWIN && !LL_SOLARIS
  65. #ifdef PROCESSOR_FREQUENCY_MEASURE_AVAILABLE
  66. // We need the QueryPerformanceCounter and Sleep functions
  67. #define FORCEINLINE __forceinline
  68. #else
  69. #define FORCEINLINE 
  70. #endif
  73. // Some macros we often need
  74. ////////////////////////////
  75. #define CheckBit(var, bit)   ((var & (1 << bit)) ? true : false)
  77. #ifdef PROCESSOR_FREQUENCY_MEASURE_AVAILABLE
  78. // Delays for the specified amount of milliseconds
  79. static void _Delay(unsigned int ms)
  80. {
  81.    LARGE_INTEGER freq, c1, c2;
  82. __int64 x;
  84.    // Get High-Res Timer frequency
  85. if (!QueryPerformanceFrequency(&freq))
  86. return;
  88. // Convert ms to High-Res Timer value
  89. x = freq.QuadPart/1000*ms;
  91.    // Get first snapshot of High-Res Timer value
  92. QueryPerformanceCounter(&c1);
  93. do
  94. {
  95.             // Get second snapshot
  96.     QueryPerformanceCounter(&c2);
  97. }while(c2.QuadPart-c1.QuadPart < x);
  98. // Loop while (second-first < x)
  99. }
  100. #endif
  102. // CProcessor::CProcessor
  103. // ======================
  104. // Class constructor:
  105. /////////////////////////
  106. CProcessor::CProcessor()
  107. {
  108. uqwFrequency = 0;
  109. strCPUName[0] = 0;
  110. memset(&CPUInfo, 0, sizeof(CPUInfo));
  111. }
  113. // unsigned __int64 CProcessor::GetCPUFrequency(unsigned int uiMeasureMSecs)
  114. // =========================================================================
  115. // Function to measure the current CPU frequency
  116. ////////////////////////////////////////////////////////////////////////////
  117. F64 CProcessor::GetCPUFrequency(unsigned int uiMeasureMSecs)
  118. {
  119. #ifndef PROCESSOR_FREQUENCY_MEASURE_AVAILABLE
  120. return 0;
  121. #else
  122. // If there are invalid measure time parameters, zero msecs for example,
  123. // we've to exit the function
  124. if (uiMeasureMSecs < 1)
  125. {
  126. // If theres already a measured frequency available, we return it
  127.         if (uqwFrequency > 0)
  128. return uqwFrequency;
  129. else
  130. return 0;
  131. }
  133. // Now we check if the CPUID command is available
  134. if (!CheckCPUIDPresence())
  135. return 0;
  137. // First we get the CPUID standard level 0x00000001
  138. unsigned long reg;
  139. __asm
  140. {
  141. mov eax, 1
  142.         cpuid
  143. mov reg, edx
  144. }
  146. // Then we check, if the RDTSC (Real Date Time Stamp Counter) is available.
  147. // This function is necessary for our measure process.
  148. if (!(reg & (1 << 4)))
  149. return 0;
  151. // After that we declare some vars and check the frequency of the high
  152. // resolution timer for the measure process.
  153. // If there's no high-res timer, we exit.
  154. __int64 starttime, endtime, timedif, freq, start, end, dif;
  155. if (!QueryPerformanceFrequency((LARGE_INTEGER *) &freq))
  156. return 0;
  158. // Now we can init the measure process. We set the process and thread priority
  159. // to the highest available level (Realtime priority). Also we focus the
  160. // first processor in the multiprocessor system.
  161. HANDLE hProcess = GetCurrentProcess();
  162. HANDLE hThread = GetCurrentThread();
  163. unsigned long dwCurPriorityClass = GetPriorityClass(hProcess);
  164. int iCurThreadPriority = GetThreadPriority(hThread);
  165. unsigned long dwProcessMask, dwSystemMask, dwNewMask = 1;
  166. GetProcessAffinityMask(hProcess, &dwProcessMask, &dwSystemMask);
  168. SetPriorityClass(hProcess, REALTIME_PRIORITY_CLASS);
  169. SetThreadPriority(hThread, THREAD_PRIORITY_TIME_CRITICAL);
  170. SetProcessAffinityMask(hProcess, dwNewMask);
  172. // Now we call a CPUID to ensure, that all other prior called functions are
  173. // completed now (serialization)
  174. __asm cpuid
  176. // We ask the high-res timer for the start time
  177. QueryPerformanceCounter((LARGE_INTEGER *) &starttime);
  179. // Then we get the current cpu clock and store it
  180. __asm 
  181. {
  182. rdtsc
  183. mov dword ptr [start+4], edx
  184. mov dword ptr [start], eax
  185. }
  187. // Now we wart for some msecs
  188. _Delay(uiMeasureMSecs);
  189. // Sleep(uiMeasureMSecs);
  191. // We ask for the end time
  192. QueryPerformanceCounter((LARGE_INTEGER *) &endtime);
  194. // And also for the end cpu clock
  195. __asm 
  196. {
  197. rdtsc
  198. mov dword ptr [end+4], edx
  199. mov dword ptr [end], eax
  200. }
  202. // Now we can restore the default process and thread priorities
  203. SetProcessAffinityMask(hProcess, dwProcessMask);
  204. SetThreadPriority(hThread, iCurThreadPriority);
  205. SetPriorityClass(hProcess, dwCurPriorityClass);
  207. // Then we calculate the time and clock differences
  208. dif = end - start;
  209. timedif = endtime - starttime;
  211. // And finally the frequency is the clock difference divided by the time
  212. // difference. 
  213. uqwFrequency = (F64)dif / (((F64)timedif) / freq);
  215. // At last we just return the frequency that is also stored in the call
  216. // member var uqwFrequency
  217. return uqwFrequency;
  218. #endif
  219. }
  221. // bool CProcessor::AnalyzeIntelProcessor()
  222. // ========================================
  223. // Private class function for analyzing an Intel processor
  224. //////////////////////////////////////////////////////////
  225. bool CProcessor::AnalyzeIntelProcessor()
  226. {
  227. #if LL_WINDOWS
  228. unsigned long eaxreg, ebxreg, edxreg;
  230. // First we check if the CPUID command is available
  231. if (!CheckCPUIDPresence())
  232. return false;
  234. // Now we get the CPUID standard level 0x00000001
  235. __asm
  236. {
  237. mov eax, 1
  238. cpuid
  239. mov eaxreg, eax
  240. mov ebxreg, ebx
  241. mov edxreg, edx
  242. }
  243.     
  244. // Then get the cpu model, family, type, stepping and brand id by masking
  245. // the eax and ebx register
  246. CPUInfo.uiStepping = eaxreg & 0xF;
  247. CPUInfo.uiModel    = (eaxreg >> 4) & 0xF;
  248. CPUInfo.uiFamily   = (eaxreg >> 8) & 0xF;
  249. CPUInfo.uiType     = (eaxreg >> 12) & 0x3;
  250. CPUInfo.uiBrandID  = ebxreg & 0xF;
  252. static const char* INTEL_BRAND[] =
  253. {
  254. /* 0x00 */ "",
  255. /* 0x01 */ "0.18 micron Intel Celeron",
  256. /* 0x02 */ "0.18 micron Intel Pentium III",
  257. /* 0x03 */ "0.13 micron Intel Celeron",
  258. /* 0x04 */ "0.13 micron Intel Pentium III",
  259. /* 0x05 */ "",
  260. /* 0x06 */ "0.13 micron Intel Pentium III Mobile",
  261. /* 0x07 */ "0.13 micron Intel Celeron Mobile",
  262. /* 0x08 */ "0.18 micron Intel Pentium 4",
  263. /* 0x09 */ "0.13 micron Intel Pentium 4",
  264. /* 0x0A */ "0.13 micron Intel Celeron",
  265. /* 0x0B */ "0.13 micron Intel Pentium 4 Xeon",
  266. /* 0x0C */ "Intel Xeon MP",
  267. /* 0x0D */ "",
  268. /* 0x0E */ "0.18 micron Intel Pentium 4 Xeon",
  269. /* 0x0F */ "Mobile Intel Celeron",
  270. /* 0x10 */ "",
  271. /* 0x11 */ "Mobile Genuine Intel",
  272. /* 0x12 */ "Intel Celeron M",
  273. /* 0x13 */ "Mobile Intel Celeron",
  274. /* 0x14 */ "Intel Celeron",
  275. /* 0x15 */ "Mobile Genuine Intel",
  276. /* 0x16 */ "Intel Pentium M",
  277. /* 0x17 */ "Mobile Intel Celeron",
  278. };
  280. // Only override the brand if we have it in the lookup table.  We should
  281. // already have a string here from GetCPUInfo().  JC
  282. if ( CPUInfo.uiBrandID < LL_ARRAY_SIZE(INTEL_BRAND) )
  283. {
  284. strncpy(CPUInfo.strBrandID, INTEL_BRAND[CPUInfo.uiBrandID], sizeof(CPUInfo.strBrandID)-1);
  285. CPUInfo.strBrandID[sizeof(CPUInfo.strBrandID)-1]='';
  287. if (CPUInfo.uiBrandID == 3 && CPUInfo.uiModel == 6)
  288. {
  289. strcpy(CPUInfo.strBrandID, "0.18 micron Intel Pentium III Xeon");
  290. }
  291. }
  293. // Then we translate the cpu family
  294.     switch (CPUInfo.uiFamily)
  295. {
  296. case 3: // Family = 3:  i386 (80386) processor family
  297. strcpy(CPUInfo.strFamily, "Intel i386"); /* Flawfinder: ignore */
  298. break;
  299. case 4: // Family = 4:  i486 (80486) processor family
  300. strcpy(CPUInfo.strFamily, "Intel i486"); /* Flawfinder: ignore */
  301. break;
  302. case 5: // Family = 5:  Pentium (80586) processor family
  303. strcpy(CPUInfo.strFamily, "Intel Pentium"); /* Flawfinder: ignore */
  304. break;
  305. case 6: // Family = 6:  Pentium Pro (80686) processor family
  306. strcpy(CPUInfo.strFamily, "Intel Pentium Pro/2/3, Core"); /* Flawfinder: ignore */
  307. break;
  308. case 15: // Family = 15:  Extended family specific
  309. // Masking the extended family
  310. CPUInfo.uiExtendedFamily = (eaxreg >> 20) & 0xFF;
  311. switch (CPUInfo.uiExtendedFamily)
  312. {
  313. case 0: // Family = 15, Ext. Family = 0:  Pentium 4 (80786 ??) processor family
  314. strcpy(CPUInfo.strFamily, "Intel Pentium 4"); /* Flawfinder: ignore */
  315. break;
  316. case 1: // Family = 15, Ext. Family = 1:  McKinley (64-bit) processor family
  317. strcpy(CPUInfo.strFamily, "Intel McKinley (IA-64)"); /* Flawfinder: ignore */
  318. break;
  319. default: // Sure is sure
  320. strcpy(CPUInfo.strFamily, "Unknown Intel Pentium 4+"); /* Flawfinder: ignore */
  321. break;
  322. }
  323. break;
  324. default: // Failsave
  325. strcpy(CPUInfo.strFamily, "Unknown"); /* Flawfinder: ignore */
  326. break;
  327.     }
  329. // Now we come to the big deal, the exact model name
  330. switch (CPUInfo.uiFamily)
  331. {
  332. case 3: // i386 (80386) processor family
  333. strcpy(CPUInfo.strModel, "Unknown Intel i386"); /* Flawfinder: ignore */
  334. strncat(strCPUName, "Intel i386", sizeof(strCPUName)-strlen(strCPUName)-1); /* Flawfinder: ignore */
  335. break;
  336. case 4: // i486 (80486) processor family
  337. switch (CPUInfo.uiModel)
  338. {
  339. case 0: // Model = 0:  i486 DX-25/33 processor model
  340. strcpy(CPUInfo.strModel, "Intel i486 DX-25/33"); /* Flawfinder: ignore */
  341. strncat(strCPUName, "Intel i486 DX-25/33", sizeof(strCPUName)-strlen(strCPUName)-1); /* Flawfinder: ignore */
  342. break;
  343. case 1: // Model = 1:  i486 DX-50 processor model
  344. strcpy(CPUInfo.strModel, "Intel i486 DX-50"); /* Flawfinder: ignore */
  345. strncat(strCPUName, "Intel i486 DX-50", sizeof(strCPUName)-strlen(strCPUName)-1); /* Flawfinder: ignore */
  346. break;
  347. case 2: // Model = 2:  i486 SX processor model
  348. strcpy(CPUInfo.strModel, "Intel i486 SX"); /* Flawfinder: ignore */
  349. strncat(strCPUName, "Intel i486 SX", sizeof(strCPUName)-strlen(strCPUName)-1); /* Flawfinder: ignore */
  350. break;
  351. case 3: // Model = 3:  i486 DX2 (with i487 numeric coprocessor) processor model
  352. strcpy(CPUInfo.strModel, "Intel i486 487/DX2"); /* Flawfinder: ignore */
  353. strncat(strCPUName, "Intel i486 DX2 with i487 numeric coprocessor", sizeof(strCPUName)-strlen(strCPUName)-1); /* Flawfinder: ignore */
  354. break;
  355. case 4: // Model = 4:  i486 SL processor model (never heard ?!?)
  356. strcpy(CPUInfo.strModel, "Intel i486 SL"); /* Flawfinder: ignore */
  357. strncat(strCPUName, "Intel i486 SL", sizeof(strCPUName)-strlen(strCPUName)-1); /* Flawfinder: ignore */
  358. break;
  359. case 5: // Model = 5:  i486 SX2 processor model
  360. strcpy(CPUInfo.strModel, "Intel i486 SX2"); /* Flawfinder: ignore */
  361. strncat(strCPUName, "Intel i486 SX2", sizeof(strCPUName)-strlen(strCPUName)-1); /* Flawfinder: ignore */
  362. break;
  363. case 7: // Model = 7:  i486 write-back enhanced DX2 processor model
  364. strcpy(CPUInfo.strModel, "Intel i486 write-back enhanced DX2"); /* Flawfinder: ignore */
  365. strncat(strCPUName, "Intel i486 write-back enhanced DX2", sizeof(strCPUName)-strlen(strCPUName)-1); /* Flawfinder: ignore */
  366. break;
  367. case 8: // Model = 8:  i486 DX4 processor model
  368. strcpy(CPUInfo.strModel, "Intel i486 DX4"); /* Flawfinder: ignore */
  369. strncat(strCPUName, "Intel i486 DX4", sizeof(strCPUName)-strlen(strCPUName)-1); /* Flawfinder: ignore */
  370. break;
  371. case 9: // Model = 9:  i486 write-back enhanced DX4 processor model
  372. strcpy(CPUInfo.strModel, "Intel i486 write-back enhanced DX4"); /* Flawfinder: ignore */
  373. strncat(strCPUName, "Intel i486 DX4", sizeof(strCPUName)-strlen(strCPUName)-1); /* Flawfinder: ignore */
  374. break;
  375. default: // ...
  376. strcpy(CPUInfo.strModel, "Unknown Intel i486"); /* Flawfinder: ignore */
  377. strncat(strCPUName, "Intel i486 (Unknown model)", sizeof(strCPUName)-strlen(strCPUName)-1); /* Flawfinder: ignore */
  378. break;
  379. }
  380. break;
  381. case 5: // Pentium (80586) processor family
  382. switch (CPUInfo.uiModel)
  383. {
  384. case 0: // Model = 0:  Pentium (P5 A-Step) processor model
  385. strcpy(CPUInfo.strModel, "Intel Pentium (P5 A-Step)"); /* Flawfinder: ignore */
  386. strncat(strCPUName, "Intel Pentium (P5 A-Step core)", sizeof(strCPUName)-strlen(strCPUName)-1); /* Flawfinder: ignore */
  387. break; // Famous for the DIV bug, as far as I know
  388. case 1: // Model = 1:  Pentium 60/66 processor model
  389. strcpy(CPUInfo.strModel, "Intel Pentium 60/66 (P5)"); /* Flawfinder: ignore */
  390. strncat(strCPUName, "Intel Pentium 60/66 (P5 core)", sizeof(strCPUName)-strlen(strCPUName)-1); /* Flawfinder: ignore */
  391. break;
  392. case 2: // Model = 2:  Pentium 75-200 (P54C) processor model
  393. strcpy(CPUInfo.strModel, "Intel Pentium 75-200 (P54C)"); /* Flawfinder: ignore */
  394. strncat(strCPUName, "Intel Pentium 75-200 (P54C core)", sizeof(strCPUName)-strlen(strCPUName)-1); /* Flawfinder: ignore */
  395. break;
  396. case 3: // Model = 3:  Pentium overdrive for 486 systems processor model
  397. strcpy(CPUInfo.strModel, "Intel Pentium for 486 system (P24T Overdrive)"); /* Flawfinder: ignore */
  398. strncat(strCPUName, "Intel Pentium for 486 (P24T overdrive core)", sizeof(strCPUName)-(strlen(strCPUName)-1)); /*Flawfinder: ignore*/
  399. break;
  400. case 4: // Model = 4:  Pentium MMX processor model
  401. strcpy(CPUInfo.strModel, "Intel Pentium MMX (P55C)"); /*Flawfinder: ignore*/
  402. strncat(strCPUName, "Intel Pentium MMX (P55C core)", sizeof(strCPUName)-(strlen(strCPUName)-1)); /*Flawfinder: ignore*/
  403. break;
  404. case 7: // Model = 7:  Pentium processor model (don't know difference to Model=2)
  405. strcpy(CPUInfo.strModel, "Intel Pentium (P54C)"); /*Flawfinder: ignore*/
  406. strncat(strCPUName, "Intel Pentium (P54C core)", sizeof(strCPUName)-(strlen(strCPUName)-1)); /*Flawfinder: ignore*/
  407. break;
  408. case 8: // Model = 8:  Pentium MMX (0.25 micron) processor model
  409. strcpy(CPUInfo.strModel, "Intel Pentium MMX (P55C), 0.25 micron"); /*Flawfinder: ignore*/
  410. strncat(strCPUName, "Intel Pentium MMX (P55C core), 0.25 micron", sizeof(strCPUName)-(strlen(strCPUName)-1)); /*Flawfinder: ignore*/
  411. break;
  412. default: // ...
  413. strcpy(CPUInfo.strModel, "Unknown Intel Pentium"); /*Flawfinder: ignore*/
  414. strncat(strCPUName, "Intel Pentium (Unknown P5-model)", sizeof(strCPUName)-(strlen(strCPUName)-1)); /*Flawfinder: ignore*/
  415. break;
  416. }
  417. break;
  418. case 6: // Pentium Pro (80686) processor family
  419. switch (CPUInfo.uiModel)
  420. {
  421. case 0: // Model = 0:  Pentium Pro (P6 A-Step) processor model
  422. strcpy(CPUInfo.strModel, "Intel Pentium Pro (P6 A-Step)"); /*Flawfinder: ignore*/
  423. strncat(strCPUName, "Intel Pentium Pro (P6 A-Step core)", sizeof(strCPUName)-(strlen(strCPUName)-1)); /*Flawfinder: ignore*/
  424. break;
  425. case 1: // Model = 1:  Pentium Pro
  426. strcpy(CPUInfo.strModel, "Intel Pentium Pro (P6)"); /*Flawfinder: ignore*/
  427. strncat(strCPUName, "Intel Pentium Pro (P6 core)", sizeof(strCPUName)-(strlen(strCPUName)-1)); /*Flawfinder: ignore*/
  428. break;
  429. case 3: // Model = 3:  Pentium II (66 MHz FSB, I think) processor model
  430. strcpy(CPUInfo.strModel, "Intel Pentium II Model 3, 0.28 micron"); /*Flawfinder: ignore*/
  431. strncat(strCPUName, "Intel Pentium II (Model 3 core, 0.28 micron process)", sizeof(strCPUName)-(strlen(strCPUName)-1)); /*Flawfinder: ignore*/
  432. break;
  433. case 5: // Model = 5:  Pentium II/Xeon/Celeron (0.25 micron) processor model
  434. strcpy(CPUInfo.strModel, "Intel Pentium II Model 5/Xeon/Celeron, 0.25 micron"); /*Flawfinder: ignore*/
  435. strncat(strCPUName, "Intel Pentium II/Xeon/Celeron (Model 5 core, 0.25 micron process)", sizeof(strCPUName)-(strlen(strCPUName)-1)); /*Flawfinder: ignore*/
  436. break;
  437. case 6: // Model = 6:  Pentium II with internal L2 cache
  438. strcpy(CPUInfo.strModel, "Intel Pentium II - internal L2 cache"); /*Flawfinder: ignore*/
  439. strncat(strCPUName, "Intel Pentium II with internal L2 cache", sizeof(strCPUName)-(strlen(strCPUName)-1)); /*Flawfinder: ignore*/
  440. break;
  441. case 7: // Model = 7:  Pentium III/Xeon (extern L2 cache) processor model
  442. strcpy(CPUInfo.strModel, "Intel Pentium III/Pentium III Xeon - external L2 cache, 0.25 micron");  /*Flawfinder: ignore*/
  443. strncat(strCPUName, "Intel Pentium III/Pentium III Xeon (0.25 micron process) with external L2 cache", sizeof(strCPUName)-(strlen(strCPUName)-1)); /*Flawfinder: ignore*/
  444. break;
  445. case 8: // Model = 8:  Pentium III/Xeon/Celeron (256 KB on-die L2 cache) processor model
  446. strcpy(CPUInfo.strModel, "Intel Pentium III/Celeron/Pentium III Xeon - internal L2 cache, 0.18 micron");  /*Flawfinder: ignore*/
  447. // We want to know it exactly:
  448. switch (CPUInfo.uiBrandID)
  449. {
  450. case 1: // Model = 8, Brand id = 1:  Celeron (on-die L2 cache) processor model
  451. strncat(strCPUName, "Intel Celeron (0.18 micron process) with internal L2 cache", sizeof(strCPUName)-(strlen(strCPUName)-1)); /*Flawfinder: ignore*/
  452. break;
  453.                         case 2: // Model = 8, Brand id = 2:  Pentium III (on-die L2 cache) processor model (my current cpu :-))
  454. strncat(strCPUName, "Intel Pentium III (0.18 micron process) with internal L2 cache", sizeof(strCPUName)-(strlen(strCPUName)-1)); /*Flawfinder: ignore*/
  455. break;
  456. case 3: // Model = 8, Brand id = 3:  Pentium III Xeon (on-die L2 cache) processor model
  457.                             strncat(strCPUName, "Intel Pentium III Xeon (0.18 micron process) with internal L2 cache", sizeof(strCPUName)-(strlen(strCPUName)-1)); /*Flawfinder: ignore*/
  458. break;
  459. default: // ...
  460. strncat(strCPUName, "Intel Pentium III core (unknown model, 0.18 micron process) with internal L2 cache", sizeof(strCPUName)-(strlen(strCPUName)-1)); /*Flawfinder: ignore*/
  461. break;
  462. }
  463. break;
  464. case 9: // Model = 9:  Intel Pentium M processor, Intel Celeron M processor, model 9
  465. strcpy(CPUInfo.strModel, "Intel Pentium M Series Processor");  /*Flawfinder: ignore*/
  466. strncat(strCPUName, "Intel Pentium M Series Processor", sizeof(strCPUName)-(strlen(strCPUName)-1)); /*Flawfinder: ignore*/
  467. break;
  468. case 0xA: // Model = 0xA:  Pentium III/Xeon/Celeron (1 or 2 MB on-die L2 cache) processor model
  469. strcpy(CPUInfo.strModel, "Intel Pentium III/Celeron/Pentium III Xeon - internal L2 cache, 0.18 micron");  /*Flawfinder: ignore*/
  470. // Exact detection:
  471. switch (CPUInfo.uiBrandID)
  472. {
  473. case 1: // Model = 0xA, Brand id = 1:  Celeron (1 or 2 MB on-die L2 cache (does it exist??)) processor model
  474. strncat(strCPUName, "Intel Celeron (0.18 micron process) with internal L2 cache", sizeof(strCPUName)-(strlen(strCPUName)-1)); /*Flawfinder: ignore*/
  475. break;
  476.                         case 2: // Model = 0xA, Brand id = 2:  Pentium III (1 or 2 MB on-die L2 cache (never seen...)) processor model
  477. strncat(strCPUName, "Intel Pentium III (0.18 micron process) with internal L2 cache", sizeof(strCPUName)-(strlen(strCPUName)-1)); /*Flawfinder: ignore*/
  478. break;
  479. case 3: // Model = 0xA, Brand id = 3:  Pentium III Xeon (1 or 2 MB on-die L2 cache) processor model
  480.                             strncat(strCPUName, "Intel Pentium III Xeon (0.18 micron process) with internal L2 cache", sizeof(strCPUName)-(strlen(strCPUName)-1)); /*Flawfinder: ignore*/
  481. break;
  482. default: // Getting bored of this............
  483. strncat(strCPUName, "Intel Pentium III core (unknown model, 0.18 micron process) with internal L2 cache", sizeof(strCPUName)-(strlen(strCPUName)-1)); /*Flawfinder: ignore*/
  484. break;
  485. }
  486. break;
  487. case 0xB: // Model = 0xB: Pentium III/Xeon/Celeron (Tualatin core, on-die cache) processor model
  488. strcpy(CPUInfo.strModel, "Intel Pentium III/Celeron/Pentium III Xeon - internal L2 cache, 0.13 micron");  /*Flawfinder: ignore*/
  489. // Omniscient: ;-)
  490. switch (CPUInfo.uiBrandID)
  491. {
  492. case 3: // Model = 0xB, Brand id = 3:  Celeron (Tualatin core) processor model
  493. strncat(strCPUName, "Intel Celeron (Tualatin core, 0.13 micron process) with internal L2 cache", sizeof(strCPUName)-(strlen(strCPUName)-1)); /*Flawfinder: ignore*/
  494. break;
  495.                         case 4: // Model = 0xB, Brand id = 4:  Pentium III (Tualatin core) processor model
  496. strncat(strCPUName, "Intel Pentium III (Tualatin core, 0.13 micron process) with internal L2 cache", sizeof(strCPUName)-(strlen(strCPUName)-1)); /*Flawfinder: ignore*/
  497. break;
  498. case 7: // Model = 0xB, Brand id = 7:  Celeron mobile (Tualatin core) processor model
  499.                             strncat(strCPUName, "Intel Celeron mobile (Tualatin core, 0.13 micron process) with internal L2 cache", sizeof(strCPUName)-(strlen(strCPUName)-1)); /*Flawfinder: ignore*/
  500. break;
  501. default: // *bored*
  502. strncat(strCPUName, "Intel Pentium III Tualatin core (unknown model, 0.13 micron process) with internal L2 cache", sizeof(strCPUName)-(strlen(strCPUName)-1)); /*Flawfinder: ignore*/
  503. break;
  504. }
  505. break;
  506. case 0xD: // Model = 0xD:  Intel Pentium M processor, Intel Celeron M processor, model D
  507. strcpy(CPUInfo.strModel, "Intel Pentium M Series Processor");  /*Flawfinder: ignore*/
  508. strncat(strCPUName, "Intel Pentium M Series Processor", sizeof(strCPUName)-(strlen(strCPUName)-1)); /*Flawfinder: ignore*/
  509. break;
  510. case 0xE: // Model = 0xE:  Intel Core Duo processor, Intel Core Solo processor, model E
  511. strcpy(CPUInfo.strModel, "Intel Core Series Processor");  /*Flawfinder: ignore*/
  512. strncat(strCPUName, "Intel Core Series Processor", sizeof(strCPUName)-(strlen(strCPUName)-1)); /*Flawfinder: ignore*/
  513. break;
  514. case 0xF: // Model = 0xF:  Intel Core 2 Duo processor, model F
  515. strcpy(CPUInfo.strModel, "Intel Core 2 Series Processor");  /*Flawfinder: ignore*/
  516. strncat(strCPUName, "Intel Core 2 Series Processor", sizeof(strCPUName)-(strlen(strCPUName)-1)); /*Flawfinder: ignore*/
  517. break;
  518. default: // *more bored*
  519. strcpy(CPUInfo.strModel, "Unknown Intel Pentium Pro/2/3, Core"); /*Flawfinder: ignore*/
  520. strncat(strCPUName, "Intel Pentium Pro/2/3, Core (Unknown model)", sizeof(strCPUName)-(strlen(strCPUName)-1)); /*Flawfinder: ignore*/
  521. break;
  522. }
  523. break;
  524. case 15: // Extended processor family
  525. // Masking the extended model
  526. CPUInfo.uiExtendedModel = (eaxreg >> 16) & 0xFF;
  527. switch (CPUInfo.uiModel)
  528. {
  529. case 0: // Model = 0:  Pentium 4 Willamette (A-Step) core
  530. if ((CPUInfo.uiBrandID) == 8) // Brand id = 8:  P4 Willamette
  531. {
  532. strcpy(CPUInfo.strModel, "Intel Pentium 4 Willamette (A-Step)"); /*Flawfinder: ignore*/
  533. strncat(strCPUName, "Intel Pentium 4 Willamette (A-Step)", sizeof(strCPUName)-(strlen(strCPUName)-1)); /*Flawfinder: ignore*/
  534. }
  535. else // else Xeon
  536. {
  537. strcpy(CPUInfo.strModel, "Intel Pentium 4 Willamette Xeon (A-Step)"); /* Flawfinder: ignore */
  538. strncat(strCPUName, "Intel Pentium 4 Willamette Xeon (A-Step)", sizeof(strCPUName) - strlen(strCPUName) - 1); /* Flawfinder: ignore */
  539. }
  540. break;
  541. case 1: // Model = 1:  Pentium 4 Willamette core
  542. if ((CPUInfo.uiBrandID) == 8) // Brand id = 8:  P4 Willamette
  543. {
  544. strcpy(CPUInfo.strModel, "Intel Pentium 4 Willamette"); /* Flawfinder: ignore */
  545. strncat(strCPUName, "Intel Pentium 4 Willamette", sizeof(strCPUName) - strlen(strCPUName) - 1); /* Flawfinder: ignore */
  546. }
  547. else // else Xeon
  548. {
  549. strcpy(CPUInfo.strModel, "Intel Pentium 4 Willamette Xeon"); /* Flawfinder: ignore */
  550. strncat(strCPUName, "Intel Pentium 4 Willamette Xeon", sizeof(strCPUName) - strlen(strCPUName) - 1); /* Flawfinder: ignore */
  551. }
  552. break;
  553. case 2: // Model = 2:  Pentium 4 Northwood core
  554. if (((CPUInfo.uiBrandID) == 9) || ((CPUInfo.uiBrandID) == 0xA)) // P4 Willamette
  555. {
  556. strcpy(CPUInfo.strModel, "Intel Pentium 4 Northwood"); /* Flawfinder: ignore */
  557. strncat(strCPUName, "Intel Pentium 4 Northwood", sizeof(strCPUName) - strlen(strCPUName) - 1); /* Flawfinder: ignore */
  558. }
  559. else // Xeon
  560. {
  561. strcpy(CPUInfo.strModel, "Intel Pentium 4 Northwood Xeon"); /* Flawfinder: ignore */
  562. strncat(strCPUName, "Intel Pentium 4 Northwood Xeon", sizeof(strCPUName) - strlen(strCPUName) - 1); /* Flawfinder: ignore */
  563. }
  564. break;
  565. default: // Silly stupid never used failsave option
  566. strcpy(CPUInfo.strModel, "Unknown Intel Pentium 4"); /* Flawfinder: ignore */
  567. strncat(strCPUName, "Intel Pentium 4 (Unknown model)", sizeof(strCPUName) - strlen(strCPUName) - 1); /* Flawfinder: ignore */
  568. break;
  569. }
  570. break;
  571. default: // *grmpf*
  572. strcpy(CPUInfo.strModel, "Unknown Intel model"); /* Flawfinder: ignore */
  573. strncat(strCPUName, "Intel (Unknown model)", sizeof(strCPUName) - strlen(strCPUName) - 1); /* Flawfinder: ignore */
  574. break;
  575.     }
  577. // After the long processor model block we now come to the processors serial
  578. // number.
  579. // First of all we check if the processor supports the serial number
  580. if (CPUInfo.MaxSupportedLevel >= 3)
  581. {
  582. // If it supports the serial number CPUID level 0x00000003 we read the data
  583. unsigned long sig1, sig2, sig3;
  584. __asm
  585. {
  586. mov eax, 1
  587. cpuid
  588. mov sig1, eax
  589. mov eax, 3
  590. cpuid
  591. mov sig2, ecx
  592. mov sig3, edx
  593. }
  594. // Then we convert the data to a readable string
  595. snprintf( /* Flawfinder: ignore */
  596. CPUInfo.strProcessorSerial,
  597. sizeof(CPUInfo.strProcessorSerial),
  598. "%04lX-%04lX-%04lX-%04lX-%04lX-%04lX",
  599. sig1 >> 16,
  600. sig1 & 0xFFFF,
  601. sig3 >> 16,
  602. sig3 & 0xFFFF,
  603. sig2 >> 16, sig2 & 0xFFFF);
  604. }
  605. else
  606. {
  607. // If there's no serial number support we just put "No serial number"
  608. snprintf( /* Flawfinder: ignore */
  609. CPUInfo.strProcessorSerial,
  610. sizeof(CPUInfo.strProcessorSerial),
  611. "No Processor Serial Number");
  612. }
  614. // Now we get the standard processor extensions
  615. GetStandardProcessorExtensions();
  617. // And finally the processor configuration (caches, TLBs, ...) and translate
  618. // the data to readable strings
  619. GetStandardProcessorConfiguration();
  620. TranslateProcessorConfiguration();
  622. // At last...
  623. return true;
  624. #else
  625. return FALSE;
  626. #endif
  627. }
  629. // bool CProcessor::AnalyzeAMDProcessor()
  630. // ======================================
  631. // Private class function for analyzing an AMD processor
  632. ////////////////////////////////////////////////////////
  633. bool CProcessor::AnalyzeAMDProcessor()
  634. {
  635. #if LL_WINDOWS
  636. unsigned long eaxreg, ebxreg, ecxreg, edxreg;
  638. // First of all we check if the CPUID command is available
  639. if (!CheckCPUIDPresence())
  640. return 0;
  642. // Now we get the CPUID standard level 0x00000001
  643. __asm
  644. {
  645. mov eax, 1
  646. cpuid
  647. mov eaxreg, eax
  648. mov ebxreg, ebx
  649. mov edxreg, edx
  650. }
  651.     
  652. // Then we mask the model, family, stepping and type (AMD does not support brand id)
  653. CPUInfo.uiStepping = eaxreg & 0xF;
  654. CPUInfo.uiModel    = (eaxreg >> 4) & 0xF;
  655. CPUInfo.uiFamily   = (eaxreg >> 8) & 0xF;
  656. CPUInfo.uiType     = (eaxreg >> 12) & 0x3;
  658. // Now we check if the processor supports the brand id string extended CPUID level
  659. if (CPUInfo.MaxSupportedExtendedLevel >= 0x80000004)
  660. {
  661. // If it supports the extended CPUID level 0x80000004 we read the data
  662. char tmp[52]; /* Flawfinder: ignore */
  663. memset(tmp, 0, sizeof(tmp));
  664.         __asm
  665. {
  666. mov eax, 0x80000002
  667. cpuid
  668. mov dword ptr [tmp], eax
  669. mov dword ptr [tmp+4], ebx
  670. mov dword ptr [tmp+8], ecx
  671. mov dword ptr [tmp+12], edx
  672. mov eax, 0x80000003
  673. cpuid
  674. mov dword ptr [tmp+16], eax
  675. mov dword ptr [tmp+20], ebx
  676. mov dword ptr [tmp+24], ecx
  677. mov dword ptr [tmp+28], edx
  678. mov eax, 0x80000004
  679. cpuid
  680. mov dword ptr [tmp+32], eax
  681. mov dword ptr [tmp+36], ebx
  682. mov dword ptr [tmp+40], ecx
  683. mov dword ptr [tmp+44], edx
  684. }
  685. // And copy it to the brand id string
  686. strncpy(CPUInfo.strBrandID, tmp,sizeof(CPUInfo.strBrandID)-1);
  687. CPUInfo.strBrandID[sizeof(CPUInfo.strBrandID)-1]='';
  688. }
  689. else
  690. {
  691. // Or just tell there is no brand id string support
  692. strcpy(CPUInfo.strBrandID, ""); /* Flawfinder: ignore */
  693. }
  695. // After that we translate the processor family
  696.     switch(CPUInfo.uiFamily)
  697. {
  698. case 4: // Family = 4:  486 (80486) or 5x86 (80486) processor family
  699. switch (CPUInfo.uiModel)
  700. {
  701. case 3: // Thanks to AMD for this nice form of family
  702. case 7: // detection.... *grmpf*
  703. case 8:
  704. case 9:
  705. strcpy(CPUInfo.strFamily, "AMD 80486"); /* Flawfinder: ignore */
  706. break;
  707. case 0xE:
  708. case 0xF:
  709. strcpy(CPUInfo.strFamily, "AMD 5x86"); /* Flawfinder: ignore */
  710. break;
  711. default:
  712. strcpy(CPUInfo.strFamily, "Unknown family"); /* Flawfinder: ignore */
  713. break;
  714. }
  715. break;
  716. case 5: // Family = 5:  K5 or K6 processor family
  717. switch (CPUInfo.uiModel)
  718. {
  719. case 0:
  720. case 1:
  721. case 2:
  722. case 3:
  723. strcpy(CPUInfo.strFamily, "AMD K5"); /* Flawfinder: ignore */
  724. break;
  725. case 6:
  726. case 7:
  727. case 8:
  728. case 9:
  729. strcpy(CPUInfo.strFamily, "AMD K6"); /* Flawfinder: ignore */
  730. break;
  731. default:
  732. strcpy(CPUInfo.strFamily, "Unknown family"); /* Flawfinder: ignore */
  733. break;
  734. }
  735. break;
  736. case 6: // Family = 6:  K7 (Athlon, ...) processor family
  737. strcpy(CPUInfo.strFamily, "AMD K7"); /* Flawfinder: ignore */
  738. break;
  739. default: // For security
  740. strcpy(CPUInfo.strFamily, "Unknown family"); /* Flawfinder: ignore */
  741. break;
  742. }
  744. // After the family detection we come to the specific processor model
  745. // detection
  746. switch (CPUInfo.uiFamily)
  747. {
  748. case 4: // Family = 4:  486 (80486) or 5x85 (80486) processor family
  749. switch (CPUInfo.uiModel)
  750. {
  751. case 3: // Model = 3:  80486 DX2
  752. strcpy(CPUInfo.strModel, "AMD 80486 DX2"); /* Flawfinder: ignore */
  753. strncat(strCPUName, "AMD 80486 DX2", sizeof(strCPUName) - strlen(strCPUName) -1); /* Flawfinder: ignore */
  754. break;
  755. case 7: // Model = 7:  80486 write-back enhanced DX2
  756. strcpy(CPUInfo.strModel, "AMD 80486 write-back enhanced DX2"); /* Flawfinder: ignore */
  757. strncat(strCPUName, "AMD 80486 write-back enhanced DX2", sizeof(strCPUName) - strlen(strCPUName) -1); /* Flawfinder: ignore */
  758. break;
  759. case 8: // Model = 8:  80486 DX4
  760. strcpy(CPUInfo.strModel, "AMD 80486 DX4"); /* Flawfinder: ignore */
  761. strncat(strCPUName, "AMD 80486 DX4", sizeof(strCPUName) - strlen(strCPUName) -1); /* Flawfinder: ignore */
  762. break;
  763. case 9: // Model = 9:  80486 write-back enhanced DX4
  764. strcpy(CPUInfo.strModel, "AMD 80486 write-back enhanced DX4"); /* Flawfinder: ignore */
  765. strncat(strCPUName, "AMD 80486 write-back enhanced DX4", sizeof(strCPUName) - strlen(strCPUName) -1); /* Flawfinder: ignore */
  766. break;
  767. case 0xE: // Model = 0xE:  5x86
  768. strcpy(CPUInfo.strModel, "AMD 5x86"); /* Flawfinder: ignore */
  769. strncat(strCPUName, "AMD 5x86", sizeof(strCPUName) - strlen(strCPUName) -1); /* Flawfinder: ignore */
  770. break;
  771. case 0xF: // Model = 0xF:  5x86 write-back enhanced (oh my god.....)
  772. strcpy(CPUInfo.strModel, "AMD 5x86 write-back enhanced"); /* Flawfinder: ignore */
  773. strncat(strCPUName, "AMD 5x86 write-back enhanced", sizeof(strCPUName) - strlen(strCPUName) -1); /* Flawfinder: ignore */
  774. break;
  775. default: // ...
  776. strcpy(CPUInfo.strModel, "Unknown AMD 80486 or 5x86 model"); /* Flawfinder: ignore */
  777. strncat(strCPUName, "AMD 80486 or 5x86 (Unknown model)", sizeof(strCPUName) - strlen(strCPUName) -1); /* Flawfinder: ignore */
  778. break;
  779. }
  780. break;
  781. case 5: // Family = 5:  K5 / K6 processor family
  782. switch (CPUInfo.uiModel)
  783. {
  784. case 0: // Model = 0:  K5 SSA 5 (Pentium Rating *ggg* 75, 90 and 100 Mhz)
  785. strcpy(CPUInfo.strModel, "AMD K5 SSA5 (PR75, PR90, PR100)"); /* Flawfinder: ignore */
  786. strncat(strCPUName, "AMD K5 SSA5 (PR75, PR90, PR100)", sizeof(strCPUName) - strlen(strCPUName) -1); /* Flawfinder: ignore */
  787. break;
  788. case 1: // Model = 1:  K5 5k86 (PR 120 and 133 MHz)
  789. strcpy(CPUInfo.strModel, "AMD K5 5k86 (PR120, PR133)"); /* Flawfinder: ignore */
  790. strncat(strCPUName, "AMD K5 5k86 (PR120, PR133)", sizeof(strCPUName) - strlen(strCPUName) -1); /* Flawfinder: ignore */
  791. break;
  792. case 2: // Model = 2:  K5 5k86 (PR 166 MHz)
  793. strcpy(CPUInfo.strModel, "AMD K5 5k86 (PR166)"); /* Flawfinder: ignore */
  794. strncat(strCPUName, "AMD K5 5k86 (PR166)", sizeof(strCPUName) - strlen(strCPUName) -1); /* Flawfinder: ignore */
  795. break;
  796. case 3: // Model = 3:  K5 5k86 (PR 200 MHz)
  797. strcpy(CPUInfo.strModel, "AMD K5 5k86 (PR200)"); /* Flawfinder: ignore */
  798. strncat(strCPUName, "AMD K5 5k86 (PR200)", sizeof(strCPUName) - strlen(strCPUName) -1); /* Flawfinder: ignore */
  799. break;
  800. case 6: // Model = 6:  K6
  801. strcpy(CPUInfo.strModel, "AMD K6 (0.30 micron)"); /* Flawfinder: ignore */
  802. strncat(strCPUName, "AMD K6 (0.30 micron)", sizeof(strCPUName) - strlen(strCPUName) -1); /* Flawfinder: ignore */
  803. break;
  804. case 7: // Model = 7:  K6 (0.25 micron)
  805. strcpy(CPUInfo.strModel, "AMD K6 (0.25 micron)"); /* Flawfinder: ignore */
  806. strncat(strCPUName, "AMD K6 (0.25 micron)", sizeof(strCPUName) - strlen(strCPUName) -1); /* Flawfinder: ignore */
  807. break;
  808. case 8: // Model = 8:  K6-2
  809. strcpy(CPUInfo.strModel, "AMD K6-2"); /* Flawfinder: ignore */
  810. strncat(strCPUName, "AMD K6-2", sizeof(strCPUName) - strlen(strCPUName) -1); /* Flawfinder: ignore */
  811. break;
  812. case 9: // Model = 9:  K6-III
  813. strcpy(CPUInfo.strModel, "AMD K6-III"); /* Flawfinder: ignore */
  814. strncat(strCPUName, "AMD K6-III", sizeof(strCPUName) - strlen(strCPUName) -1); /* Flawfinder: ignore */
  815. break;
  816. case 0xD: // Model = 0xD:  K6-2+ / K6-III+
  817. strcpy(CPUInfo.strModel, "AMD K6-2+ or K6-III+ (0.18 micron)"); /* Flawfinder: ignore */
  818. strncat(strCPUName, "AMD K6-2+ or K6-III+ (0.18 micron)", sizeof(strCPUName) - strlen(strCPUName) -1); /* Flawfinder: ignore */
  819. break;
  820. default: // ...
  821. strcpy(CPUInfo.strModel, "Unknown AMD K5 or K6 model"); /* Flawfinder: ignore */
  822. strncat(strCPUName, "AMD K5 or K6 (Unknown model)", sizeof(strCPUName) - strlen(strCPUName) -1); /* Flawfinder: ignore */
  823. break;
  824. }
  825. break;
  826. case 6: // Family = 6:  K7 processor family (AMDs first good processors)
  827. switch (CPUInfo.uiModel)
  828. {
  829. case 1: // Athlon
  830. strcpy(CPUInfo.strModel, "AMD Athlon (0.25 micron)"); /* Flawfinder: ignore */
  831. strncat(strCPUName, "AMD Athlon (0.25 micron)", sizeof(strCPUName) - strlen(strCPUName) -1); /* Flawfinder: ignore */
  832. break;
  833. case 2: // Athlon (0.18 micron)
  834. strcpy(CPUInfo.strModel, "AMD Athlon (0.18 micron)"); /* Flawfinder: ignore */
  835. strncat(strCPUName, "AMD Athlon (0.18 micron)", sizeof(strCPUName) - strlen(strCPUName) -1); /* Flawfinder: ignore */
  836. break;
  837. case 3: // Duron (Spitfire core)
  838. strcpy(CPUInfo.strModel, "AMD Duron (Spitfire)"); /* Flawfinder: ignore */
  839. strncat(strCPUName, "AMD Duron (Spitfire core)", sizeof(strCPUName) - strlen(strCPUName) -1); /* Flawfinder: ignore */
  840. break;
  841. case 4: // Athlon (Thunderbird core)
  842. strcpy(CPUInfo.strModel, "AMD Athlon (Thunderbird)"); /* Flawfinder: ignore */
  843. strncat(strCPUName, "AMD Athlon (Thunderbird core)", sizeof(strCPUName) - strlen(strCPUName) -1); /* Flawfinder: ignore */
  844. break;
  845. case 6: // Athlon MP / Mobile Athlon (Palomino core)
  846. strcpy(CPUInfo.strModel, "AMD Athlon MP/Mobile Athlon (Palomino)"); /* Flawfinder: ignore */
  847. strncat(strCPUName, "AMD Athlon MP/Mobile Athlon (Palomino core)", sizeof(strCPUName) - strlen(strCPUName) -1); /* Flawfinder: ignore */
  848. break;
  849. case 7: // Mobile Duron (Morgan core)
  850. strcpy(CPUInfo.strModel, "AMD Mobile Duron (Morgan)"); /* Flawfinder: ignore */
  851. strncat(strCPUName, "AMD Mobile Duron (Morgan core)", sizeof(strCPUName) - strlen(strCPUName) -1); /* Flawfinder: ignore */
  852. break;
  853. default: // ...
  854. strcpy(CPUInfo.strModel, "Unknown AMD K7 model"); /* Flawfinder: ignore */
  855. strncat(strCPUName, "AMD K7 (Unknown model)", sizeof(strCPUName) - strlen(strCPUName) -1); /* Flawfinder: ignore */
  856. break;
  857. }
  858. break;
  859. default: // ...
  860. strcpy(CPUInfo.strModel, "Unknown AMD model"); /* Flawfinder: ignore */
  861. strncat(strCPUName, "AMD (Unknown model)", sizeof(strCPUName) - strlen(strCPUName) -1); /* Flawfinder: ignore */
  862. break;
  863.     }
  865. // Now we read the standard processor extension that are stored in the same
  866. // way the Intel standard extensions are
  867. GetStandardProcessorExtensions();
  869. // Then we check if theres an extended CPUID level support
  870. if (CPUInfo.MaxSupportedExtendedLevel >= 0x80000001)
  871. {
  872. // If we can access the extended CPUID level 0x80000001 we get the
  873. // edx register
  874. __asm
  875. {
  876. mov eax, 0x80000001
  877. cpuid
  878. mov edxreg, edx
  879. }
  881. // Now we can mask some AMD specific cpu extensions
  882. CPUInfo._Ext.EMMX_MultimediaExtensions = CheckBit(edxreg, 22);
  883. CPUInfo._Ext.AA64_AMD64BitArchitecture = CheckBit(edxreg, 29);
  884. CPUInfo._Ext._E3DNOW_InstructionExtensions = CheckBit(edxreg, 30);
  885. CPUInfo._Ext._3DNOW_InstructionExtensions = CheckBit(edxreg, 31);
  886. }
  888. // After that we check if the processor supports the ext. CPUID level
  889. // 0x80000006
  890. if (CPUInfo.MaxSupportedExtendedLevel >= 0x80000006)
  891. {
  892. // If it's present, we read it out
  893.         __asm
  894. {
  895.             mov eax, 0x80000005
  896. cpuid
  897. mov eaxreg, eax
  898. mov ebxreg, ebx
  899. mov ecxreg, ecx
  900. mov edxreg, edx
  901. }
  903. // Then we mask the L1 Data TLB information
  904. if ((ebxreg >> 16) && (eaxreg >> 16))
  905. {
  906. CPUInfo._Data.bPresent = true;
  907. strcpy(CPUInfo._Data.strPageSize, "4 KB / 2 MB / 4MB");  /*Flawfinder: ignore*/
  908. CPUInfo._Data.uiAssociativeWays = (eaxreg >> 24) & 0xFF;
  909. CPUInfo._Data.uiEntries = (eaxreg >> 16) & 0xFF;
  910. }
  911. else if (eaxreg >> 16)
  912. {
  913. CPUInfo._Data.bPresent = true;
  914. strcpy(CPUInfo._Data.strPageSize, "2 MB / 4MB"); /*Flawfinder: ignore*/
  915. CPUInfo._Data.uiAssociativeWays = (eaxreg >> 24) & 0xFF;
  916. CPUInfo._Data.uiEntries = (eaxreg >> 16) & 0xFF;
  917. }
  918. else if (ebxreg >> 16)
  919. {
  920. CPUInfo._Data.bPresent = true;
  921. strcpy(CPUInfo._Data.strPageSize, "4 KB"); /*Flawfinder: ignore*/
  922. CPUInfo._Data.uiAssociativeWays = (ebxreg >> 24) & 0xFF;
  923. CPUInfo._Data.uiEntries = (ebxreg >> 16) & 0xFF;
  924. }
  925. if (CPUInfo._Data.uiAssociativeWays == 0xFF)
  926. CPUInfo._Data.uiAssociativeWays = (unsigned int) -1;
  928. // Now the L1 Instruction/Code TLB information
  929. if ((ebxreg & 0xFFFF) && (eaxreg & 0xFFFF))
  930. {
  931. CPUInfo._Instruction.bPresent = true;
  932. strcpy(CPUInfo._Instruction.strPageSize, "4 KB / 2 MB / 4MB"); /*Flawfinder: ignore*/
  933. CPUInfo._Instruction.uiAssociativeWays = (eaxreg >> 8) & 0xFF;
  934. CPUInfo._Instruction.uiEntries = eaxreg & 0xFF;
  935. }
  936. else if (eaxreg & 0xFFFF)
  937. {
  938. CPUInfo._Instruction.bPresent = true;
  939. strcpy(CPUInfo._Instruction.strPageSize, "2 MB / 4MB"); /*Flawfinder: ignore*/
  940. CPUInfo._Instruction.uiAssociativeWays = (eaxreg >> 8) & 0xFF;
  941. CPUInfo._Instruction.uiEntries = eaxreg & 0xFF;
  942. }
  943. else if (ebxreg & 0xFFFF)
  944. {
  945. CPUInfo._Instruction.bPresent = true;
  946. strcpy(CPUInfo._Instruction.strPageSize, "4 KB"); /*Flawfinder: ignore*/
  947. CPUInfo._Instruction.uiAssociativeWays = (ebxreg >> 8) & 0xFF;
  948. CPUInfo._Instruction.uiEntries = ebxreg & 0xFF;
  949. }
  950. if (CPUInfo._Instruction.uiAssociativeWays == 0xFF)
  951. CPUInfo._Instruction.uiAssociativeWays = (unsigned int) -1;
  953. // Then we read the L1 data cache information
  954. if ((ecxreg >> 24) > 0)
  955. {
  956. CPUInfo._L1.Data.bPresent = true;
  957. snprintf(CPUInfo._L1.Data.strSize, sizeof(CPUInfo._L1.Data.strSize), "%d KB", ecxreg >> 24); /* Flawfinder: ignore */
  958. CPUInfo._L1.Data.uiAssociativeWays = (ecxreg >> 15) & 0xFF;
  959. CPUInfo._L1.Data.uiLineSize = ecxreg & 0xFF;
  960. }
  961. // After that we read the L2 instruction/code cache information
  962. if ((edxreg >> 24) > 0)
  963. {
  964. CPUInfo._L1.Instruction.bPresent = true;
  965. snprintf(CPUInfo._L1.Instruction.strSize, sizeof(CPUInfo._L1.Instruction.strSize), "%d KB", edxreg >> 24);  /* Flawfinder: ignore */
  966. CPUInfo._L1.Instruction.uiAssociativeWays = (edxreg >> 15) & 0xFF;
  967. CPUInfo._L1.Instruction.uiLineSize = edxreg & 0xFF;
  968. }
  970. // Note: I'm not absolutely sure that the L1 page size code (the
  971. // 'if/else if/else if' structs above) really detects the real page
  972. // size for the TLB. Somebody should check it....
  974. // Now we read the ext. CPUID level 0x80000006
  975.         __asm
  976. {
  977. mov eax, 0x80000006
  978. cpuid
  979. mov eaxreg, eax
  980. mov ebxreg, ebx
  981. mov ecxreg, ecx
  982. }
  984. // We only mask the unified L2 cache masks (never heard of an
  985. // L2 cache that is divided in data and code parts)
  986. if (((ecxreg >> 12) & 0xF) > 0)
  987. {
  988. CPUInfo._L2.bPresent = true;
  989. snprintf(CPUInfo._L2.strSize, sizeof(CPUInfo._L2.strSize), "%d KB", ecxreg >> 16); /* Flawfinder: ignore */
  990. switch ((ecxreg >> 12) & 0xF)
  991. {
  992. case 1:
  993. CPUInfo._L2.uiAssociativeWays = 1;
  994. break;
  995. case 2:
  996. CPUInfo._L2.uiAssociativeWays = 2;
  997. break;
  998. case 4:
  999. CPUInfo._L2.uiAssociativeWays = 4;
  1000. break;
  1001. case 6:
  1002. CPUInfo._L2.uiAssociativeWays = 8;
  1003. break;
  1004. case 8:
  1005. CPUInfo._L2.uiAssociativeWays = 16;
  1006. break;
  1007. case 0xF:
  1008. CPUInfo._L2.uiAssociativeWays = (unsigned int) -1;
  1009. break;
  1010. default:
  1011. CPUInfo._L2.uiAssociativeWays = 0;
  1012. break;
  1013. }
  1014. CPUInfo._L2.uiLineSize = ecxreg & 0xFF;
  1015. }
  1016. }
  1017. else
  1018. {
  1019. // If we could not detect the ext. CPUID level 0x80000006 we
  1020. // try to read the standard processor configuration.
  1021. GetStandardProcessorConfiguration();
  1022. }
  1023. // After reading we translate the configuration to strings
  1024. TranslateProcessorConfiguration();
  1026. // And finally exit
  1027. return true;
  1028. #else
  1029. return FALSE;
  1030. #endif
  1031. }
  1033. // bool CProcessor::AnalyzeUnknownProcessor()
  1034. // ==========================================
  1035. // Private class function to analyze an unknown (No Intel or AMD) processor
  1036. ///////////////////////////////////////////////////////////////////////////
  1037. bool CProcessor::AnalyzeUnknownProcessor()
  1038. {
  1039. #if LL_WINDOWS
  1040. unsigned long eaxreg, ebxreg;
  1042. // We check if the CPUID command is available
  1043. if (!CheckCPUIDPresence())
  1044. return false;
  1046. // First of all we read the standard CPUID level 0x00000001
  1047. // This level should be available on every x86-processor clone
  1048. __asm
  1049. {
  1050.         mov eax, 1
  1051. cpuid
  1052. mov eaxreg, eax
  1053. mov ebxreg, ebx
  1054. }
  1055. // Then we mask the processor model, family, type and stepping
  1056. CPUInfo.uiStepping = eaxreg & 0xF;
  1057. CPUInfo.uiModel    = (eaxreg >> 4) & 0xF;
  1058. CPUInfo.uiFamily   = (eaxreg >> 8) & 0xF;
  1059. CPUInfo.uiType     = (eaxreg >> 12) & 0x3;
  1061. // To have complete information we also mask the brand id
  1062. CPUInfo.uiBrandID  = ebxreg & 0xF;
  1064. // Then we get the standard processor extensions
  1065. GetStandardProcessorExtensions();
  1067. // Now we mark everything we do not know as unknown
  1068. strcpy(strCPUName, "Unknown"); /*Flawfinder: ignore*/
  1070. strcpy(CPUInfo._Data.strTLB, "Unknown"); /*Flawfinder: ignore*/
  1071. strcpy(CPUInfo._Instruction.strTLB, "Unknown"); /*Flawfinder: ignore*/
  1073. strcpy(CPUInfo._Trace.strCache, "Unknown"); /*Flawfinder: ignore*/
  1074. strcpy(CPUInfo._L1.Data.strCache, "Unknown"); /*Flawfinder: ignore*/
  1075. strcpy(CPUInfo._L1.Instruction.strCache, "Unknown"); /*Flawfinder: ignore*/
  1076. strcpy(CPUInfo._L2.strCache, "Unknown"); /*Flawfinder: ignore*/
  1077. strcpy(CPUInfo._L3.strCache, "Unknown"); /*Flawfinder: ignore*/
  1079. strcpy(CPUInfo.strProcessorSerial, "Unknown / Not supported"); /*Flawfinder: ignore*/
  1081. // For the family, model and brand id we can only print the numeric value
  1082. snprintf(CPUInfo.strBrandID, sizeof(CPUInfo.strBrandID), "Brand-ID number %d", CPUInfo.uiBrandID); /* Flawfinder: ignore */
  1083. snprintf(CPUInfo.strFamily, sizeof(CPUInfo.strFamily), "Family number %d", CPUInfo.uiFamily); /* Flawfinder: ignore */
  1084. snprintf(CPUInfo.strModel, sizeof(CPUInfo.strModel), "Model number %d", CPUInfo.uiModel); /* Flawfinder: ignore */
  1086. // And thats it
  1087. return true;
  1088. #else
  1089. return FALSE;
  1090. #endif
  1091. }
  1093. // bool CProcessor::CheckCPUIDPresence()
  1094. // =====================================
  1095. // This function checks if the CPUID command is available on the current
  1096. // processor
  1097. ////////////////////////////////////////////////////////////////////////
  1098. bool CProcessor::CheckCPUIDPresence()
  1099. {
  1100. #if LL_WINDOWS
  1101. unsigned long BitChanged;
  1103. // We've to check if we can toggle the flag register bit 21
  1104. // If we can't the processor does not support the CPUID command
  1105. __asm
  1106. {
  1107. pushfd
  1108. pop eax
  1109. mov ebx, eax
  1110. xor eax, 0x00200000 
  1111. push eax
  1112. popfd
  1113. pushfd
  1114. pop eax
  1115. xor eax,ebx 
  1116. mov BitChanged, eax
  1117. }
  1119. return ((BitChanged) ? true : false);
  1120. #else
  1121. return FALSE;
  1122. #endif
  1123. }
  1125. // void CProcessor::DecodeProcessorConfiguration(unsigned int cfg)
  1126. // ===============================================================
  1127. // This function (or switch ?!) just translates a one-byte processor configuration
  1128. // byte to understandable values
  1129. //////////////////////////////////////////////////////////////////////////////////
  1130. void CProcessor::DecodeProcessorConfiguration(unsigned int cfg)
  1131. {
  1132. // First we ensure that there's only one single byte
  1133. cfg &= 0xFF;
  1135. // Then we do a big switch
  1136. switch(cfg)
  1137. {
  1138. case 0: // cfg = 0:  Unused
  1139. break;
  1140. case 0x1: // cfg = 0x1:  code TLB present, 4 KB pages, 4 ways, 32 entries
  1141. CPUInfo._Instruction.bPresent = true;
  1142. strcpy(CPUInfo._Instruction.strPageSize, "4 KB"); /*Flawfinder: ignore*/
  1143. CPUInfo._Instruction.uiAssociativeWays = 4;
  1144. CPUInfo._Instruction.uiEntries = 32;
  1145. break;
  1146. case 0x2: // cfg = 0x2:  code TLB present, 4 MB pages, fully associative, 2 entries
  1147. CPUInfo._Instruction.bPresent = true;
  1148. strcpy(CPUInfo._Instruction.strPageSize, "4 MB"); /*Flawfinder: ignore*/
  1149. CPUInfo._Instruction.uiAssociativeWays = 4;
  1150. CPUInfo._Instruction.uiEntries = 2;
  1151. break;
  1152. case 0x3: // cfg = 0x3:  data TLB present, 4 KB pages, 4 ways, 64 entries
  1153. CPUInfo._Data.bPresent = true;
  1154. strcpy(CPUInfo._Data.strPageSize, "4 KB"); /*Flawfinder: ignore*/
  1155. CPUInfo._Data.uiAssociativeWays = 4;
  1156. CPUInfo._Data.uiEntries = 64;
  1157. break;
  1158. case 0x4: // cfg = 0x4:  data TLB present, 4 MB pages, 4 ways, 8 entries
  1159. CPUInfo._Data.bPresent = true;
  1160. strcpy(CPUInfo._Data.strPageSize, "4 MB"); /*Flawfinder: ignore*/
  1161. CPUInfo._Data.uiAssociativeWays = 4;
  1162. CPUInfo._Data.uiEntries = 8;
  1163. break;
  1164. case 0x6: // cfg = 0x6:  code L1 cache present, 8 KB, 4 ways, 32 byte lines
  1165. CPUInfo._L1.Instruction.bPresent = true;
  1166. strcpy(CPUInfo._L1.Instruction.strSize, "8 KB"); /*Flawfinder: ignore*/
  1167. CPUInfo._L1.Instruction.uiAssociativeWays = 4;
  1168. CPUInfo._L1.Instruction.uiLineSize = 32;
  1169. break;
  1170. case 0x8: // cfg = 0x8:  code L1 cache present, 16 KB, 4 ways, 32 byte lines
  1171. CPUInfo._L1.Instruction.bPresent = true;
  1172. strcpy(CPUInfo._L1.Instruction.strSize, "16 KB"); /*Flawfinder: ignore*/
  1173. CPUInfo._L1.Instruction.uiAssociativeWays = 4;
  1174. CPUInfo._L1.Instruction.uiLineSize = 32;
  1175. break;
  1176. case 0xA: // cfg = 0xA:  data L1 cache present, 8 KB, 2 ways, 32 byte lines
  1177. CPUInfo._L1.Data.bPresent = true;
  1178. strcpy(CPUInfo._L1.Data.strSize, "8 KB"); /*Flawfinder: ignore*/
  1179. CPUInfo._L1.Data.uiAssociativeWays = 2;
  1180. CPUInfo._L1.Data.uiLineSize = 32;
  1181. break;
  1182. case 0xC: // cfg = 0xC:  data L1 cache present, 16 KB, 4 ways, 32 byte lines
  1183. CPUInfo._L1.Data.bPresent = true;
  1184. strcpy(CPUInfo._L1.Data.strSize, "16 KB"); /*Flawfinder: ignore*/
  1185. CPUInfo._L1.Data.uiAssociativeWays = 4;
  1186. CPUInfo._L1.Data.uiLineSize = 32;
  1187. break;
  1188. case 0x22: // cfg = 0x22:  code and data L3 cache present, 512 KB, 4 ways, 64 byte lines, sectored
  1189. CPUInfo._L3.bPresent = true;
  1190. strcpy(CPUInfo._L3.strSize, "512 KB"); /*Flawfinder: ignore*/
  1191. CPUInfo._L3.uiAssociativeWays = 4;
  1192. CPUInfo._L3.uiLineSize = 64;
  1193. CPUInfo._L3.bSectored = true;
  1194. break;
  1195. case 0x23: // cfg = 0x23:  code and data L3 cache present, 1024 KB, 8 ways, 64 byte lines, sectored
  1196. CPUInfo._L3.bPresent = true;
  1197. strcpy(CPUInfo._L3.strSize, "1024 KB"); /*Flawfinder: ignore*/
  1198. CPUInfo._L3.uiAssociativeWays = 8;
  1199. CPUInfo._L3.uiLineSize = 64;
  1200. CPUInfo._L3.bSectored = true;
  1201. break;
  1202. case 0x25: // cfg = 0x25:  code and data L3 cache present, 2048 KB, 8 ways, 64 byte lines, sectored
  1203. CPUInfo._L3.bPresent = true;
  1204. strcpy(CPUInfo._L3.strSize, "2048 KB"); /*Flawfinder: ignore*/
  1205. CPUInfo._L3.uiAssociativeWays = 8;
  1206. CPUInfo._L3.uiLineSize = 64;
  1207. CPUInfo._L3.bSectored = true;
  1208. break;
  1209. case 0x29: // cfg = 0x29:  code and data L3 cache present, 4096 KB, 8 ways, 64 byte lines, sectored
  1210. CPUInfo._L3.bPresent = true;
  1211. strcpy(CPUInfo._L3.strSize, "4096 KB"); /*Flawfinder: ignore*/
  1212. CPUInfo._L3.uiAssociativeWays = 8;
  1213. CPUInfo._L3.uiLineSize = 64;
  1214. CPUInfo._L3.bSectored = true;
  1215. break;
  1216. case 0x40: // cfg = 0x40:  no integrated L2 cache (P6 core) or L3 cache (P4 core)
  1217. break;
  1218. case 0x41: // cfg = 0x41:  code and data L2 cache present, 128 KB, 4 ways, 32 byte lines
  1219. CPUInfo._L2.bPresent = true;
  1220. strcpy(CPUInfo._L2.strSize, "128 KB"); /*Flawfinder: ignore*/
  1221. CPUInfo._L2.uiAssociativeWays = 4;
  1222. CPUInfo._L2.uiLineSize = 32;
  1223. break;
  1224. case 0x42: // cfg = 0x42:  code and data L2 cache present, 256 KB, 4 ways, 32 byte lines
  1225. CPUInfo._L2.bPresent = true;
  1226. strcpy(CPUInfo._L2.strSize, "256 KB"); /*Flawfinder: ignore*/
  1227. CPUInfo._L2.uiAssociativeWays = 4;
  1228. CPUInfo._L2.uiLineSize = 32;
  1229. break;
  1230. case 0x43: // cfg = 0x43:  code and data L2 cache present, 512 KB, 4 ways, 32 byte lines
  1231. CPUInfo._L2.bPresent = true;
  1232. strcpy(CPUInfo._L2.strSize, "512 KB"); /* Flawfinder: ignore */
  1233. CPUInfo._L2.uiAssociativeWays = 4;
  1234. CPUInfo._L2.uiLineSize = 32;
  1235. break;
  1236. case 0x44: // cfg = 0x44:  code and data L2 cache present, 1024 KB, 4 ways, 32 byte lines
  1237. CPUInfo._L2.bPresent = true;
  1238. strcpy(CPUInfo._L2.strSize, "1 MB"); /* Flawfinder: ignore */
  1239. CPUInfo._L2.uiAssociativeWays = 4;
  1240. CPUInfo._L2.uiLineSize = 32;
  1241. break;
  1242. case 0x45: // cfg = 0x45:  code and data L2 cache present, 2048 KB, 4 ways, 32 byte lines
  1243. CPUInfo._L2.bPresent = true;
  1244. strcpy(CPUInfo._L2.strSize, "2 MB"); /* Flawfinder: ignore */
  1245. CPUInfo._L2.uiAssociativeWays = 4;
  1246. CPUInfo._L2.uiLineSize = 32;
  1247. break;
  1248. case 0x50: // cfg = 0x50:  code TLB present, 4 KB / 4 MB / 2 MB pages, fully associative, 64 entries
  1249. CPUInfo._Instruction.bPresent = true;
  1250. strcpy(CPUInfo._Instruction.strPageSize, "4 KB / 2 MB / 4 MB"); /* Flawfinder: ignore */
  1251. CPUInfo._Instruction.uiAssociativeWays = (unsigned int) -1;
  1252. CPUInfo._Instruction.uiEntries = 64;
  1253. break;
  1254. case 0x51: // cfg = 0x51:  code TLB present, 4 KB / 4 MB / 2 MB pages, fully associative, 128 entries
  1255. CPUInfo._Instruction.bPresent = true;
  1256. strcpy(CPUInfo._Instruction.strPageSize, "4 KB / 2 MB / 4 MB"); /* Flawfinder: ignore */
  1257. CPUInfo._Instruction.uiAssociativeWays = (unsigned int) -1;
  1258. CPUInfo._Instruction.uiEntries = 128;
  1259. break;
  1260. case 0x52: // cfg = 0x52:  code TLB present, 4 KB / 4 MB / 2 MB pages, fully associative, 256 entries
  1261. CPUInfo._Instruction.bPresent = true;
  1262. strcpy(CPUInfo._Instruction.strPageSize, "4 KB / 2 MB / 4 MB"); /* Flawfinder: ignore */
  1263. CPUInfo._Instruction.uiAssociativeWays = (unsigned int) -1;
  1264. CPUInfo._Instruction.uiEntries = 256;
  1265. break;
  1266. case 0x5B: // cfg = 0x5B:  data TLB present, 4 KB / 4 MB pages, fully associative, 64 entries
  1267. CPUInfo._Data.bPresent = true;
  1268. strcpy(CPUInfo._Data.strPageSize, "4 KB / 4 MB"); /* Flawfinder: ignore */
  1269. CPUInfo._Data.uiAssociativeWays = (unsigned int) -1;
  1270. CPUInfo._Data.uiEntries = 64;
  1271. break;
  1272. case 0x5C: // cfg = 0x5C:  data TLB present, 4 KB / 4 MB pages, fully associative, 128 entries
  1273. CPUInfo._Data.bPresent = true;
  1274. strcpy(CPUInfo._Data.strPageSize, "4 KB / 4 MB"); /* Flawfinder: ignore */
  1275. CPUInfo._Data.uiAssociativeWays = (unsigned int) -1;
  1276. CPUInfo._Data.uiEntries = 128;
  1277. break;
  1278. case 0x5d: // cfg = 0x5D:  data TLB present, 4 KB / 4 MB pages, fully associative, 256 entries
  1279. CPUInfo._Data.bPresent = true;
  1280. strcpy(CPUInfo._Data.strPageSize, "4 KB / 4 MB"); /* Flawfinder: ignore */
  1281. CPUInfo._Data.uiAssociativeWays = (unsigned int) -1;
  1282. CPUInfo._Data.uiEntries = 256;
  1283. break;
  1284. case 0x66: // cfg = 0x66:  data L1 cache present, 8 KB, 4 ways, 64 byte lines, sectored
  1285. CPUInfo._L1.Data.bPresent = true;
  1286. strcpy(CPUInfo._L1.Data.strSize, "8 KB"); /* Flawfinder: ignore */
  1287. CPUInfo._L1.Data.uiAssociativeWays = 4;
  1288. CPUInfo._L1.Data.uiLineSize = 64;
  1289. break;
  1290. case 0x67: // cfg = 0x67:  data L1 cache present, 16 KB, 4 ways, 64 byte lines, sectored
  1291. CPUInfo._L1.Data.bPresent = true;
  1292. strcpy(CPUInfo._L1.Data.strSize, "16 KB"); /* Flawfinder: ignore */
  1293. CPUInfo._L1.Data.uiAssociativeWays = 4;
  1294. CPUInfo._L1.Data.uiLineSize = 64;
  1295. break;
  1296. case 0x68: // cfg = 0x68:  data L1 cache present, 32 KB, 4 ways, 64 byte lines, sectored
  1297. CPUInfo._L1.Data.bPresent = true;
  1298. strcpy(CPUInfo._L1.Data.strSize, "32 KB"); /* Flawfinder: ignore */
  1299. CPUInfo._L1.Data.uiAssociativeWays = 4;
  1300. CPUInfo._L1.Data.uiLineSize = 64;
  1301. break;
  1302. case 0x70: // cfg = 0x70:  trace L1 cache present, 12 KuOPs, 4 ways
  1303. CPUInfo._Trace.bPresent = true;
  1304. strcpy(CPUInfo._Trace.strSize, "12 K-micro-ops"); /* Flawfinder: ignore */
  1305. CPUInfo._Trace.uiAssociativeWays = 4;
  1306. break;
  1307. case 0x71: // cfg = 0x71:  trace L1 cache present, 16 KuOPs, 4 ways
  1308. CPUInfo._Trace.bPresent = true;
  1309. strcpy(CPUInfo._Trace.strSize, "16 K-micro-ops"); /* Flawfinder: ignore */
  1310. CPUInfo._Trace.uiAssociativeWays = 4;
  1311. break;
  1312. case 0x72: // cfg = 0x72:  trace L1 cache present, 32 KuOPs, 4 ways
  1313. CPUInfo._Trace.bPresent = true;
  1314. strcpy(CPUInfo._Trace.strSize, "32 K-micro-ops"); /* Flawfinder: ignore */
  1315. CPUInfo._Trace.uiAssociativeWays = 4;
  1316. break;
  1317. case 0x79: // cfg = 0x79:  code and data L2 cache present, 128 KB, 8 ways, 64 byte lines, sectored
  1318. CPUInfo._L2.bPresent = true;
  1319. strcpy(CPUInfo._L2.strSize, "128 KB"); /* Flawfinder: ignore */
  1320. CPUInfo._L2.uiAssociativeWays = 8;
  1321. CPUInfo._L2.uiLineSize = 64;
  1322. CPUInfo._L2.bSectored = true;
  1323. break;
  1324. case 0x7A: // cfg = 0x7A:  code and data L2 cache present, 256 KB, 8 ways, 64 byte lines, sectored
  1325. CPUInfo._L2.bPresent = true;
  1326. strcpy(CPUInfo._L2.strSize, "256 KB"); /* Flawfinder: ignore */
  1327. CPUInfo._L2.uiAssociativeWays = 8;
  1328. CPUInfo._L2.uiLineSize = 64;
  1329. CPUInfo._L2.bSectored = true;
  1330. break;
  1331. case 0x7B: // cfg = 0x7B:  code and data L2 cache present, 512 KB, 8 ways, 64 byte lines, sectored
  1332. CPUInfo._L2.bPresent = true;
  1333. strcpy(CPUInfo._L2.strSize, "512 KB"); /* Flawfinder: ignore */
  1334. CPUInfo._L2.uiAssociativeWays = 8;
  1335. CPUInfo._L2.uiLineSize = 64;
  1336. CPUInfo._L2.bSectored = true;
  1337. break;
  1338. case 0x7C: // cfg = 0x7C:  code and data L2 cache present, 1024 KB, 8 ways, 64 byte lines, sectored
  1339. CPUInfo._L2.bPresent = true;
  1340. strcpy(CPUInfo._L2.strSize, "1 MB"); /* Flawfinder: ignore */
  1341. CPUInfo._L2.uiAssociativeWays = 8;
  1342. CPUInfo._L2.uiLineSize = 64;
  1343. CPUInfo._L2.bSectored = true;
  1344. break;
  1345. case 0x81: // cfg = 0x81:  code and data L2 cache present, 128 KB, 8 ways, 32 byte lines
  1346. CPUInfo._L2.bPresent = true;
  1347. strcpy(CPUInfo._L2.strSize, "128 KB"); /* Flawfinder: ignore */
  1348. CPUInfo._L2.uiAssociativeWays = 8;
  1349. CPUInfo._L2.uiLineSize = 32;
  1350. break;
  1351. case 0x82: // cfg = 0x82:  code and data L2 cache present, 256 KB, 8 ways, 32 byte lines
  1352. CPUInfo._L2.bPresent = true;
  1353. strcpy(CPUInfo._L2.strSize, "256 KB"); /* Flawfinder: ignore */
  1354. CPUInfo._L2.uiAssociativeWays = 8;
  1355. CPUInfo._L2.uiLineSize = 32;
  1356. break;
  1357. case 0x83: // cfg = 0x83:  code and data L2 cache present, 512 KB, 8 ways, 32 byte lines
  1358. CPUInfo._L2.bPresent = true;
  1359. strcpy(CPUInfo._L2.strSize, "512 KB"); /* Flawfinder: ignore */
  1360. CPUInfo._L2.uiAssociativeWays = 8;
  1361. CPUInfo._L2.uiLineSize = 32;
  1362. break;
  1363. case 0x84: // cfg = 0x84:  code and data L2 cache present, 1024 KB, 8 ways, 32 byte lines
  1364. CPUInfo._L2.bPresent = true;
  1365. strcpy(CPUInfo._L2.strSize, "1 MB"); /* Flawfinder: ignore */
  1366. CPUInfo._L2.uiAssociativeWays = 8;
  1367. CPUInfo._L2.uiLineSize = 32;
  1368. break;
  1369. case 0x85: // cfg = 0x85:  code and data L2 cache present, 2048 KB, 8 ways, 32 byte lines
  1370. CPUInfo._L2.bPresent = true;
  1371. strcpy(CPUInfo._L2.strSize, "2 MB"); /* Flawfinder: ignore */
  1372. CPUInfo._L2.uiAssociativeWays = 8;
  1373. CPUInfo._L2.uiLineSize = 32;
  1374. break;
  1375. }
  1376. }
  1378. FORCEINLINE static char *TranslateAssociativeWays(unsigned int uiWays, char *buf)
  1379. {
  1380. // We define 0xFFFFFFFF (= -1) as fully associative
  1381.     if (uiWays == ((unsigned int) -1))
  1382. strcpy(buf, "fully associative"); /* Flawfinder: ignore */
  1383. else
  1384. {
  1385. if (uiWays == 1) // A one way associative cache is just direct mapped
  1386. strcpy(buf, "direct mapped"); /* Flawfinder: ignore */
  1387. else if (uiWays == 0) // This should not happen...
  1388. strcpy(buf, "unknown associative ways"); /* Flawfinder: ignore */
  1389. else // The x-way associative cache
  1390. sprintf(buf, "%d ways associative", uiWays); /* Flawfinder: ignore */
  1391. }
  1392. // To ease the function use we return the buffer
  1393. return buf;
  1394. }
  1395. FORCEINLINE static void TranslateTLB(ProcessorTLB *tlb)
  1396. {
  1397. char buf[64]; /* Flawfinder: ignore */
  1399. // We just check if the TLB is present
  1400. if (tlb->bPresent)
  1401.         snprintf(tlb->strTLB,sizeof(tlb->strTLB), "%s page size, %s, %d entries", tlb->strPageSize, TranslateAssociativeWays(tlb->uiAssociativeWays, buf), tlb->uiEntries); /* Flawfinder: ignore */
  1402. else
  1403.         strcpy(tlb->strTLB, "Not present"); /* Flawfinder: ignore */
  1404. }
  1405. FORCEINLINE static void TranslateCache(ProcessorCache *cache)
  1406. {
  1407. char buf[64]; /* Flawfinder: ignore */
  1409. // We just check if the cache is present
  1410.     if (cache->bPresent)
  1411. {
  1412. // If present we construct the string
  1413. snprintf(cache->strCache, sizeof(cache->strCache), "%s cache size, %s, %d bytes line size", cache->strSize, TranslateAssociativeWays(cache->uiAssociativeWays, buf), cache->uiLineSize); /* Flawfinder: ignore */
  1414. if (cache->bSectored)
  1415. strncat(cache->strCache, ", sectored", sizeof(cache->strCache)-strlen(cache->strCache)-1); /* Flawfinder: ignore */
  1416. }
  1417. else
  1418. {
  1419. // Else we just say "Not present"
  1420. strcpy(cache->strCache, "Not present"); /* Flawfinder: ignore */
  1421. }
  1422. }
  1424. // void CProcessor::TranslateProcessorConfiguration()
  1425. // ==================================================
  1426. // Private class function to translate the processor configuration values
  1427. // to strings
  1428. /////////////////////////////////////////////////////////////////////////
  1429. void CProcessor::TranslateProcessorConfiguration()
  1430. {
  1431. // We just call the small functions defined above
  1432. TranslateTLB(&CPUInfo._Data);
  1433. TranslateTLB(&CPUInfo._Instruction);
  1435. TranslateCache(&CPUInfo._Trace);
  1437. TranslateCache(&CPUInfo._L1.Instruction);
  1438. TranslateCache(&CPUInfo._L1.Data);
  1439. TranslateCache(&CPUInfo._L2);
  1440. TranslateCache(&CPUInfo._L3);
  1441. }
  1443. // void CProcessor::GetStandardProcessorConfiguration()
  1444. // ====================================================
  1445. // Private class function to read the standard processor configuration
  1446. //////////////////////////////////////////////////////////////////////
  1447. void CProcessor::GetStandardProcessorConfiguration()
  1448. {
  1449. #if LL_WINDOWS
  1450. unsigned long eaxreg, ebxreg, ecxreg, edxreg;
  1452. // We check if the CPUID function is available
  1453. if (!CheckCPUIDPresence())
  1454. return;
  1456. // First we check if the processor supports the standard
  1457. // CPUID level 0x00000002
  1458. if (CPUInfo.MaxSupportedLevel >= 2)
  1459. {
  1460. // Now we go read the std. CPUID level 0x00000002 the first time
  1461. unsigned long count, num = 255;
  1462. for (count = 0; count < num; count++)
  1463. {
  1464. __asm
  1465. {
  1466. mov eax, 2
  1467. cpuid
  1468. mov eaxreg, eax
  1469. mov ebxreg, ebx
  1470. mov ecxreg, ecx
  1471. mov edxreg, edx
  1472. }
  1473. // We have to repeat this reading for 'num' times
  1474. num = eaxreg & 0xFF;
  1476. // Then we call the big decode switch function
  1477. DecodeProcessorConfiguration(eaxreg >> 8);
  1478. DecodeProcessorConfiguration(eaxreg >> 16);
  1479. DecodeProcessorConfiguration(eaxreg >> 24);
  1481. // If ebx contains additional data we also decode it
  1482. if ((ebxreg & 0x80000000) == 0)
  1483. {
  1484. DecodeProcessorConfiguration(ebxreg);
  1485. DecodeProcessorConfiguration(ebxreg >> 8);
  1486. DecodeProcessorConfiguration(ebxreg >> 16);
  1487. DecodeProcessorConfiguration(ebxreg >> 24);
  1488. }
  1489. // And also the ecx register
  1490. if ((ecxreg & 0x80000000) == 0)
  1491. {
  1492. DecodeProcessorConfiguration(ecxreg);
  1493. DecodeProcessorConfiguration(ecxreg >> 8);
  1494. DecodeProcessorConfiguration(ecxreg >> 16);
  1495. DecodeProcessorConfiguration(ecxreg >> 24);
  1496. }
  1497. // At last the edx processor register
  1498. if ((edxreg & 0x80000000) == 0)
  1499. {
  1500. DecodeProcessorConfiguration(edxreg);
  1501. DecodeProcessorConfiguration(edxreg >> 8);
  1502. DecodeProcessorConfiguration(edxreg >> 16);
  1503. DecodeProcessorConfiguration(edxreg >> 24);
  1504. }
  1505. }
  1506. }
  1507. #endif
  1508. }
  1510. // void CProcessor::GetStandardProcessorExtensions()
  1511. // =================================================
  1512. // Private class function to read the standard processor extensions
  1513. ///////////////////////////////////////////////////////////////////
  1514. void CProcessor::GetStandardProcessorExtensions()
  1515. {
  1516. #if LL_WINDOWS
  1517. unsigned long ebxreg, edxreg;
  1519. // We check if the CPUID command is available
  1520. if (!CheckCPUIDPresence())
  1521. return;
  1522. // We just get the standard CPUID level 0x00000001 which should be
  1523. // available on every x86 processor
  1524. __asm
  1525. {
  1526. mov eax, 1
  1527. cpuid
  1528. mov ebxreg, ebx
  1529. mov edxreg, edx
  1530. }
  1531.     
  1532. // Then we mask some bits
  1533. CPUInfo._Ext.FPU_FloatingPointUnit = CheckBit(edxreg, 0);
  1534. CPUInfo._Ext.VME_Virtual8086ModeEnhancements = CheckBit(edxreg, 1);
  1535. CPUInfo._Ext.DE_DebuggingExtensions = CheckBit(edxreg, 2);
  1536. CPUInfo._Ext.PSE_PageSizeExtensions = CheckBit(edxreg, 3);
  1537. CPUInfo._Ext.TSC_TimeStampCounter = CheckBit(edxreg, 4);
  1538. CPUInfo._Ext.MSR_ModelSpecificRegisters = CheckBit(edxreg, 5);
  1539. CPUInfo._Ext.PAE_PhysicalAddressExtension = CheckBit(edxreg, 6);
  1540. CPUInfo._Ext.MCE_MachineCheckException = CheckBit(edxreg, 7);
  1541. CPUInfo._Ext.CX8_COMPXCHG8B_Instruction = CheckBit(edxreg, 8);
  1542. CPUInfo._Ext.APIC_AdvancedProgrammableInterruptController = CheckBit(edxreg, 9);
  1543. CPUInfo._Ext.APIC_ID = (ebxreg >> 24) & 0xFF;
  1544. CPUInfo._Ext.SEP_FastSystemCall = CheckBit(edxreg, 11);
  1545. CPUInfo._Ext.MTRR_MemoryTypeRangeRegisters = CheckBit(edxreg, 12);
  1546. CPUInfo._Ext.PGE_PTE_GlobalFlag = CheckBit(edxreg, 13);
  1547. CPUInfo._Ext.MCA_MachineCheckArchitecture = CheckBit(edxreg, 14);
  1548. CPUInfo._Ext.CMOV_ConditionalMoveAndCompareInstructions = CheckBit(edxreg, 15);
  1549. CPUInfo._Ext.FGPAT_PageAttributeTable = CheckBit(edxreg, 16);
  1550. CPUInfo._Ext.PSE36_36bitPageSizeExtension = CheckBit(edxreg, 17);
  1551. CPUInfo._Ext.PN_ProcessorSerialNumber = CheckBit(edxreg, 18);
  1552. CPUInfo._Ext.CLFSH_CFLUSH_Instruction = CheckBit(edxreg, 19);
  1553. CPUInfo._Ext.CLFLUSH_InstructionCacheLineSize = (ebxreg >> 8) & 0xFF;
  1554. CPUInfo._Ext.DS_DebugStore = CheckBit(edxreg, 21);
  1555. CPUInfo._Ext.ACPI_ThermalMonitorAndClockControl = CheckBit(edxreg, 22);
  1556. CPUInfo._Ext.MMX_MultimediaExtensions = CheckBit(edxreg, 23);
  1557. CPUInfo._Ext.FXSR_FastStreamingSIMD_ExtensionsSaveRestore = CheckBit(edxreg, 24);
  1558. CPUInfo._Ext.SSE_StreamingSIMD_Extensions = CheckBit(edxreg, 25);
  1559. CPUInfo._Ext.SSE2_StreamingSIMD2_Extensions = CheckBit(edxreg, 26);
  1560. CPUInfo._Ext.Altivec_Extensions = false;
  1561. CPUInfo._Ext.SS_SelfSnoop = CheckBit(edxreg, 27);
  1562. CPUInfo._Ext.HT_HyperThreading = CheckBit(edxreg, 28);
  1563. CPUInfo._Ext.HT_HyterThreadingSiblings = (ebxreg >> 16) & 0xFF;
  1564. CPUInfo._Ext.TM_ThermalMonitor = CheckBit(edxreg, 29);
  1565. CPUInfo._Ext.IA64_Intel64BitArchitecture = CheckBit(edxreg, 30);
  1566. #endif
  1567. }
  1569. // const ProcessorInfo *CProcessor::GetCPUInfo()
  1570. // =============================================
  1571. // Calls all the other detection function to create an detailed
  1572. // processor information
  1573. ///////////////////////////////////////////////////////////////
  1574. const ProcessorInfo *CProcessor::GetCPUInfo()
  1575. {
  1576. #if LL_WINDOWS
  1577. unsigned long eaxreg, ebxreg, ecxreg, edxreg;
  1578.  
  1579. // First of all we check if the CPUID command is available
  1580. if (!CheckCPUIDPresence())
  1581. return NULL;
  1583. // We read the standard CPUID level 0x00000000 which should
  1584. // be available on every x86 processor
  1585. __asm
  1586. {
  1587. mov eax, 0
  1588. cpuid
  1589. mov eaxreg, eax
  1590. mov ebxreg, ebx
  1591. mov edxreg, edx
  1592. mov ecxreg, ecx
  1593. }
  1594. // Then we connect the single register values to the vendor string
  1595. *((unsigned long *) CPUInfo.strVendor) = ebxreg;
  1596. *((unsigned long *) (CPUInfo.strVendor+4)) = edxreg;
  1597. *((unsigned long *) (CPUInfo.strVendor+8)) = ecxreg;
  1598. // Null terminate for string comparisons below.
  1599. CPUInfo.strVendor[12] = 0;
  1601. // We can also read the max. supported standard CPUID level
  1602. CPUInfo.MaxSupportedLevel = eaxreg & 0xFFFF;
  1604. // Then we read the ext. CPUID level 0x80000000
  1605. __asm
  1606. {
  1607.         mov eax, 0x80000000
  1608. cpuid
  1609. mov eaxreg, eax
  1610. }
  1611. // ...to check the max. supportted extended CPUID level
  1612. CPUInfo.MaxSupportedExtendedLevel = eaxreg;
  1614. // Then we switch to the specific processor vendors
  1615. // See http://www.sandpile.org/ia32/cpuid.htm
  1616. if (!strcmp(CPUInfo.strVendor, "GenuineIntel"))
  1617. {
  1618. AnalyzeIntelProcessor();
  1619. }
  1620. else if (!strcmp(CPUInfo.strVendor, "AuthenticAMD"))
  1621. {
  1622. AnalyzeAMDProcessor();
  1623. }
  1624. else if (!strcmp(CPUInfo.strVendor, "UMC UMC UMC"))
  1625. {
  1626. AnalyzeUnknownProcessor();
  1627. }
  1628. else if (!strcmp(CPUInfo.strVendor, "CyrixInstead"))
  1629. {
  1630. AnalyzeUnknownProcessor();
  1631. }
  1632. else if (!strcmp(CPUInfo.strVendor, "NexGenDriven"))
  1633. {
  1634. AnalyzeUnknownProcessor();
  1635. }
  1636. else if (!strcmp(CPUInfo.strVendor, "CentaurHauls"))
  1637. {
  1638. AnalyzeUnknownProcessor();
  1639. }
  1640. else if (!strcmp(CPUInfo.strVendor, "RiseRiseRise"))
  1641. {
  1642. AnalyzeUnknownProcessor();
  1643. }
  1644. else if (!strcmp(CPUInfo.strVendor, "SiS SiS SiS"))
  1645. {
  1646. AnalyzeUnknownProcessor();
  1647. }
  1648. else if (!strcmp(CPUInfo.strVendor, "GenuineTMx86"))
  1649. {
  1650. // Transmeta
  1651. AnalyzeUnknownProcessor();
  1652. }
  1653. else if (!strcmp(CPUInfo.strVendor, "Geode by NSC"))
  1654. {
  1655. AnalyzeUnknownProcessor();
  1656. }
  1657. else
  1658. {
  1659. AnalyzeUnknownProcessor();
  1660. }
  1661. #endif
  1662. // After all we return the class CPUInfo member var
  1663. return (&CPUInfo);
  1664. }
  1666. #elif LL_SOLARIS
  1667. #include <kstat.h>
  1669. #if defined(__i386)
  1670. #include <sys/auxv.h>
  1671. #endif
  1673. // ======================
  1674. // Class constructor:
  1675. /////////////////////////
  1676. CProcessor::CProcessor()
  1677. {
  1678. uqwFrequency = 0;
  1679. strCPUName[0] = 0;
  1680. memset(&CPUInfo, 0, sizeof(CPUInfo));
  1681. }
  1683. // unsigned __int64 CProcessor::GetCPUFrequency(unsigned int uiMeasureMSecs)
  1684. // =========================================================================
  1685. // Function to query the current CPU frequency
  1686. ////////////////////////////////////////////////////////////////////////////
  1687. F64 CProcessor::GetCPUFrequency(unsigned int /*uiMeasureMSecs*/)
  1688. {
  1689. if(uqwFrequency == 0){
  1690. GetCPUInfo();
  1691. }
  1693. return uqwFrequency;
  1694. }
  1696. // const ProcessorInfo *CProcessor::GetCPUInfo()
  1697. // =============================================
  1698. // Calls all the other detection function to create an detailed
  1699. // processor information
  1700. ///////////////////////////////////////////////////////////////
  1701. const ProcessorInfo *CProcessor::GetCPUInfo()
  1702. {
  1703. // In Solaris the CPU info is in the kstats
  1704. // try "psrinfo" or "kstat cpu_info" to see all
  1705. // that's available
  1706. int ncpus=0, i; 
  1707. kstat_ctl_t *kc;
  1708. kstat_t  *ks;
  1709. kstat_named_t   *ksinfo, *ksi;
  1710. kstat_t  *CPU_stats_list;
  1712. kc = kstat_open();
  1714. if((int)kc == -1){
  1715. llwarns << "kstat_open(0 failed!" << llendl;
  1716. return (&CPUInfo);
  1717. }
  1719. for (ks = kc->kc_chain; ks != NULL; ks = ks->ks_next) {
  1720. if (strncmp(ks->ks_module, "cpu_info", 8) == 0 &&
  1721. strncmp(ks->ks_name, "cpu_info", 8) == 0)
  1722. ncpus++;
  1723. }
  1725. if(ncpus < 1){
  1726. llwarns << "No cpus found in kstats!" << llendl;
  1727. return (&CPUInfo);
  1728. }
  1730. for (ks = kc->kc_chain; ks; ks = ks->ks_next) {
  1731. if (strncmp(ks->ks_module, "cpu_info", 8) == 0 
  1732. &&  strncmp(ks->ks_name, "cpu_info", 8) == 0 
  1733. &&  kstat_read(kc, ks, NULL) != -1){     
  1734. CPU_stats_list = ks; // only looking at the first CPU
  1736. break;
  1737. }
  1738. }
  1740. if(ncpus > 1)
  1741.          snprintf(strCPUName, sizeof(strCPUName), "%d x ", ncpus); 
  1743. kstat_read(kc, CPU_stats_list, NULL);
  1744. ksinfo = (kstat_named_t *)CPU_stats_list->ks_data;
  1745. for(i=0; i < (int)(CPU_stats_list->ks_ndata); ++i){ // Walk the kstats for this cpu gathering what we need
  1746. ksi = ksinfo++;
  1747. if(!strcmp(ksi->name, "brand")){
  1748. strncat(strCPUName, (char *)KSTAT_NAMED_STR_PTR(ksi),
  1749. sizeof(strCPUName)-strlen(strCPUName)-1);
  1750. strncat(CPUInfo.strFamily, (char *)KSTAT_NAMED_STR_PTR(ksi),
  1751. sizeof(CPUInfo.strFamily)-strlen(CPUInfo.strFamily)-1);
  1752. strncpy(CPUInfo.strBrandID, strCPUName,sizeof(CPUInfo.strBrandID)-1);
  1753. CPUInfo.strBrandID[sizeof(CPUInfo.strBrandID)-1]='';
  1754. // DEBUG llinfos << "CPU brand: " << strCPUName << llendl;
  1755. continue;
  1756. }
  1758. if(!strcmp(ksi->name, "clock_MHz")){
  1759. #if defined(__sparc)
  1760. llinfos << "Raw kstat clock rate is: " << ksi->value.l << llendl;
  1761. uqwFrequency = (F64)(ksi->value.l * 1000000);
  1762. #else
  1763. uqwFrequency = (F64)(ksi->value.i64 * 1000000);
  1764. #endif
  1765. //DEBUG llinfos << "CPU frequency: " << uqwFrequency << llendl;
  1766. continue;
  1767. }
  1769. #if defined(__i386)
  1770. if(!strcmp(ksi->name, "vendor_id")){
  1771. strncpy(CPUInfo.strVendor, (char *)KSTAT_NAMED_STR_PTR(ksi), sizeof(CPUInfo.strVendor)-1);
  1772. // DEBUG llinfos << "CPU vendor: " << CPUInfo.strVendor << llendl;
  1773. continue;
  1774. }
  1775. #endif
  1776. }
  1778. kstat_close(kc);
  1780. #if defined(__sparc) // SPARC does not define a vendor string in kstat
  1781. strncpy(CPUInfo.strVendor, "Sun Microsystems, Inc.", sizeof(CPUInfo.strVendor)-1);
  1782. #endif
  1784. // DEBUG llinfo << "The system has " << ncpus << " CPUs with a clock rate of " <<  uqwFrequency << "MHz." << llendl;
  1786. #if defined (__i386)  //  we really don't care about the CPU extensions on SPARC but on x86...
  1788. // Now get cpu extensions
  1790. uint_t ui;
  1792. (void) getisax(&ui, 1);
  1794. if(ui & AV_386_FPU)
  1795. CPUInfo._Ext.FPU_FloatingPointUnit = true;
  1796. if(ui & AV_386_CX8)
  1797. CPUInfo._Ext.CX8_COMPXCHG8B_Instruction = true;
  1798. if(ui & AV_386_MMX)
  1799. CPUInfo._Ext.MMX_MultimediaExtensions = true;
  1800. if(ui & AV_386_AMD_MMX)
  1801. CPUInfo._Ext.MMX_MultimediaExtensions = true;
  1802. if(ui & AV_386_FXSR)
  1803. CPUInfo._Ext.FXSR_FastStreamingSIMD_ExtensionsSaveRestore = true;
  1804. if(ui & AV_386_SSE)
  1805.  CPUInfo._Ext.SSE_StreamingSIMD_Extensions = true;
  1806. if(ui & AV_386_SSE2)
  1807. CPUInfo._Ext.SSE2_StreamingSIMD2_Extensions = true;
  1808. /* Left these here since they may get used later
  1809. if(ui & AV_386_SSE3)
  1810. CPUInfo._Ext.... = true;
  1811. if(ui & AV_386_AMD_3DNow)
  1812. CPUInfo._Ext.... = true;
  1813. if(ui & AV_386_AMD_3DNowx)
  1814. CPUInfo._Ext.... = true;
  1815. */
  1816. #endif
  1817. return (&CPUInfo);
  1818. }
  1820. #else
  1821. // LL_DARWIN
  1823. #include <mach/machine.h>
  1824. #include <sys/sysctl.h>
  1826. static char *TranslateAssociativeWays(unsigned int uiWays, char *buf)
  1827. {
  1828. // We define 0xFFFFFFFF (= -1) as fully associative
  1829.     if (uiWays == ((unsigned int) -1))
  1830. strcpy(buf, "fully associative"); /* Flawfinder: ignore */
  1831. else
  1832. {
  1833. if (uiWays == 1) // A one way associative cache is just direct mapped
  1834. strcpy(buf, "direct mapped"); /* Flawfinder: ignore */
  1835. else if (uiWays == 0) // This should not happen...
  1836. strcpy(buf, "unknown associative ways"); /* Flawfinder: ignore */
  1837. else // The x-way associative cache
  1838. sprintf(buf, "%d ways associative", uiWays); /* Flawfinder: ignore */
  1839. }
  1840. // To ease the function use we return the buffer
  1841. return buf;
  1842. }
  1843. static void TranslateTLB(ProcessorTLB *tlb)
  1844. {
  1845. char buf[64]; /* Flawfinder: ignore */
  1847. // We just check if the TLB is present
  1848. if (tlb->bPresent)
  1849.         snprintf(tlb->strTLB, sizeof(tlb->strTLB), "%s page size, %s, %d entries", tlb->strPageSize, TranslateAssociativeWays(tlb->uiAssociativeWays, buf), tlb->uiEntries); /* Flawfinder: ignore */
  1850. else
  1851.         strcpy(tlb->strTLB, "Not present"); /* Flawfinder: ignore */
  1852. }
  1853. static void TranslateCache(ProcessorCache *cache)
  1854. {
  1855. char buf[64]; /* Flawfinder: ignore */
  1857. // We just check if the cache is present
  1858.     if (cache->bPresent)
  1859. {
  1860. // If present we construct the string
  1861. snprintf(cache->strCache,sizeof(cache->strCache), "%s cache size, %s, %d bytes line size", cache->strSize, TranslateAssociativeWays(cache->uiAssociativeWays, buf), cache->uiLineSize); /* Flawfinder: ignore */
  1862. if (cache->bSectored)
  1863. strncat(cache->strCache, ", sectored", sizeof(cache->strCache)-strlen(cache->strCache)-1); /* Flawfinder: ignore */
  1864. }
  1865. else
  1866. {
  1867. // Else we just say "Not present"
  1868. strcpy(cache->strCache, "Not present"); /* Flawfinder: ignore */
  1869. }
  1870. }
  1872. // void CProcessor::TranslateProcessorConfiguration()
  1873. // ==================================================
  1874. // Private class function to translate the processor configuration values
  1875. // to strings
  1876. /////////////////////////////////////////////////////////////////////////
  1877. void CProcessor::TranslateProcessorConfiguration()
  1878. {
  1879. // We just call the small functions defined above
  1880. TranslateTLB(&CPUInfo._Data);
  1881. TranslateTLB(&CPUInfo._Instruction);
  1883. TranslateCache(&CPUInfo._Trace);
  1885. TranslateCache(&CPUInfo._L1.Instruction);
  1886. TranslateCache(&CPUInfo._L1.Data);
  1887. TranslateCache(&CPUInfo._L2);
  1888. TranslateCache(&CPUInfo._L3);
  1889. }
  1891. // CProcessor::CProcessor
  1892. // ======================
  1893. // Class constructor:
  1894. /////////////////////////
  1895. CProcessor::CProcessor()
  1896. {
  1897. uqwFrequency = 0;
  1898. strCPUName[0] = 0;
  1899. memset(&CPUInfo, 0, sizeof(CPUInfo));
  1900. }
  1902. // unsigned __int64 CProcessor::GetCPUFrequency(unsigned int uiMeasureMSecs)
  1903. // =========================================================================
  1904. // Function to query the current CPU frequency
  1905. ////////////////////////////////////////////////////////////////////////////
  1906. F64 CProcessor::GetCPUFrequency(unsigned int /*uiMeasureMSecs*/)
  1907. {
  1908. U64 frequency = 0;
  1909. size_t len = sizeof(frequency);
  1911. if(sysctlbyname("hw.cpufrequency", &frequency, &len, NULL, 0) == 0)
  1912. {
  1913. uqwFrequency = (F64)frequency;
  1914. }
  1916. return uqwFrequency;
  1917. }
  1919. static bool hasFeature(const char *name)
  1920. {
  1921. bool result = false;
  1922. int val = 0;
  1923. size_t len = sizeof(val);
  1925. if(sysctlbyname(name, &val, &len, NULL, 0) == 0)
  1926. {
  1927. if(val != 0)
  1928. result = true;
  1929. }
  1931. return result;
  1932. }
  1934. // const ProcessorInfo *CProcessor::GetCPUInfo()
  1935. // =============================================
  1936. // Calls all the other detection function to create an detailed
  1937. // processor information
  1938. ///////////////////////////////////////////////////////////////
  1939. const ProcessorInfo *CProcessor::GetCPUInfo()
  1940. {
  1941. int pagesize = 0;
  1942. int cachelinesize = 0;
  1943. int l1icachesize = 0;
  1944. int l1dcachesize = 0;
  1945. int l2settings = 0;
  1946. int l2cachesize = 0;
  1947. int l3settings = 0;
  1948. int l3cachesize = 0;
  1949. int ncpu = 0;
  1950. int cpusubtype = 0;
  1952. // sysctl knows all.
  1953. int mib[2];
  1954. size_t len;
  1955. mib[0] = CTL_HW;
  1957. mib[1] = HW_PAGESIZE;
  1958. len = sizeof(pagesize);
  1959. sysctl(mib, 2, &pagesize, &len, NULL, 0);
  1961. mib[1] = HW_CACHELINE;
  1962. len = sizeof(cachelinesize);
  1963. sysctl(mib, 2, &cachelinesize, &len, NULL, 0);
  1965. mib[1] = HW_L1ICACHESIZE;
  1966. len = sizeof(l1icachesize);
  1967. sysctl(mib, 2, &l1icachesize, &len, NULL, 0);
  1969. mib[1] = HW_L1DCACHESIZE;
  1970. len = sizeof(l1dcachesize);
  1971. sysctl(mib, 2, &l1dcachesize, &len, NULL, 0);
  1973. mib[1] = HW_L2SETTINGS;
  1974. len = sizeof(l2settings);
  1975. sysctl(mib, 2, &l2settings, &len, NULL, 0);
  1977. mib[1] = HW_L2CACHESIZE;
  1978. len = sizeof(l2cachesize);
  1979. sysctl(mib, 2, &l2cachesize, &len, NULL, 0);
  1981. mib[1] = HW_L3SETTINGS;
  1982. len = sizeof(l3settings);
  1983. sysctl(mib, 2, &l3settings, &len, NULL, 0);
  1985. mib[1] = HW_L3CACHESIZE;
  1986. len = sizeof(l3cachesize);
  1987. sysctl(mib, 2, &l3cachesize, &len, NULL, 0);
  1989. mib[1] = HW_NCPU;
  1990. len = sizeof(ncpu);
  1991. sysctl(mib, 2, &ncpu, &len, NULL, 0);
  1993. sysctlbyname("hw.cpusubtype", &cpusubtype, &len, NULL, 0);
  1995. strCPUName[0] = 0;
  1997. if((ncpu == 0) || (ncpu == 1))
  1998. {
  1999. // Uhhh...
  2000. }
  2001. else if(ncpu == 2)
  2002. {
  2003. strncat(strCPUName, "Dual ", sizeof(strCPUName)-strlen(strCPUName)-1); /* Flawfinder: ignore */
  2004. }
  2005. else
  2006. {
  2007. snprintf(strCPUName, sizeof(strCPUName), "%d x ", ncpu); /* Flawfinder: ignore */
  2008. }
  2010. #if __ppc__
  2011. switch(cpusubtype)
  2012. {
  2013. case CPU_SUBTYPE_POWERPC_601://         ((cpu_subtype_t) 1)
  2014. strncat(strCPUName, "PowerPC 601", sizeof(strCPUName)-strlen(strCPUName)-1); /* Flawfinder: ignore */
  2015. strncat(CPUInfo.strFamily, "PowerPC", sizeof(CPUInfo.strFamily)-strlen(CPUInfo.strFamily)-1); /* Flawfinder: ignore */
  2017. break;
  2018. case CPU_SUBTYPE_POWERPC_602://         ((cpu_subtype_t) 2)
  2019. strncat(strCPUName, "PowerPC 602", sizeof(strCPUName)-strlen(strCPUName)-1); /* Flawfinder: ignore */
  2020. strncat(CPUInfo.strFamily, "PowerPC", sizeof(CPUInfo.strFamily)-strlen(CPUInfo.strFamily)-1); /* Flawfinder: ignore */
  2021. break;
  2022. case CPU_SUBTYPE_POWERPC_603://         ((cpu_subtype_t) 3)
  2023. strncat(strCPUName, "PowerPC 603", sizeof(strCPUName)-strlen(strCPUName)-1); /* Flawfinder: ignore */
  2024. strncat(CPUInfo.strFamily, "PowerPC", sizeof(CPUInfo.strFamily)-strlen(CPUInfo.strFamily)-1); /* Flawfinder: ignore */
  2025. break;
  2026. case CPU_SUBTYPE_POWERPC_603e://        ((cpu_subtype_t) 4)
  2027. strncat(strCPUName, "PowerPC 603e", sizeof(strCPUName)-strlen(strCPUName)-1); /* Flawfinder: ignore */
  2028. strncat(CPUInfo.strFamily, "PowerPC", sizeof(CPUInfo.strFamily)-strlen(CPUInfo.strFamily)-1); /* Flawfinder: ignore */
  2029. break;
  2030. case CPU_SUBTYPE_POWERPC_603ev://       ((cpu_subtype_t) 5)
  2031. strncat(strCPUName, "PowerPC 603ev", sizeof(strCPUName)-strlen(strCPUName)-1); /* Flawfinder: ignore */
  2032. strncat(CPUInfo.strFamily, "PowerPC", sizeof(CPUInfo.strFamily)-strlen(CPUInfo.strFamily)-1); /* Flawfinder: ignore */
  2033. break;
  2034. case CPU_SUBTYPE_POWERPC_604://         ((cpu_subtype_t) 6)
  2035. strncat(strCPUName, "PowerPC 604", sizeof(strCPUName)-strlen(strCPUName)-1); /* Flawfinder: ignore */
  2036. strncat(CPUInfo.strFamily, "PowerPC", sizeof(CPUInfo.strFamily)-strlen(CPUInfo.strFamily)-1); /* Flawfinder: ignore */
  2037. break;
  2038. case CPU_SUBTYPE_POWERPC_604e://        ((cpu_subtype_t) 7)
  2039. strncat(strCPUName, "PowerPC 604e", sizeof(strCPUName)-strlen(strCPUName)-1); /* Flawfinder: ignore */
  2040. strncat(CPUInfo.strFamily, "PowerPC", sizeof(CPUInfo.strFamily)-strlen(CPUInfo.strFamily)-1); /* Flawfinder: ignore */
  2041. break;
  2042. case CPU_SUBTYPE_POWERPC_620:// ((cpu_subtype_t) 8)
  2043. strncat(strCPUName, "PowerPC 620", sizeof(strCPUName)-strlen(strCPUName)-1); /* Flawfinder: ignore */
  2044. strncat(CPUInfo.strFamily, "PowerPC", sizeof(CPUInfo.strFamily)-strlen(CPUInfo.strFamily)-1); /* Flawfinder: ignore */
  2045. break;
  2046. case CPU_SUBTYPE_POWERPC_750://         ((cpu_subtype_t) 9)
  2047. strncat(strCPUName, "PowerPC 750", sizeof(strCPUName)-strlen(strCPUName)-1); /* Flawfinder: ignore */
  2048. strncat(CPUInfo.strFamily, "PowerPC G3", sizeof(CPUInfo.strFamily)-strlen(CPUInfo.strFamily)-1); /* Flawfinder: ignore */
  2049. break;
  2050. case CPU_SUBTYPE_POWERPC_7400://        ((cpu_subtype_t) 10)
  2051. strncat(strCPUName, "PowerPC 7400", sizeof(strCPUName)-strlen(strCPUName)-1); /* Flawfinder: ignore */
  2052. strncat(CPUInfo.strFamily, "PowerPC G4", sizeof(CPUInfo.strFamily)-strlen(CPUInfo.strFamily)-1); /* Flawfinder: ignore */
  2053. break;
  2054. case CPU_SUBTYPE_POWERPC_7450://        ((cpu_subtype_t) 11)
  2055. strncat(strCPUName, "PowerPC 7450", sizeof(strCPUName)-strlen(strCPUName)-1); /* Flawfinder: ignore */
  2056. strncat(CPUInfo.strFamily, "PowerPC G4", sizeof(CPUInfo.strFamily)-strlen(CPUInfo.strFamily)-1); /* Flawfinder: ignore */
  2057. break;
  2058. case CPU_SUBTYPE_POWERPC_970://         ((cpu_subtype_t) 100)
  2059. strncat(strCPUName, "PowerPC 970", sizeof(strCPUName)-strlen(strCPUName)-1); /* Flawfinder: ignore */
  2060. strncat(CPUInfo.strFamily, "PowerPC G5", sizeof(CPUInfo.strFamily)-strlen(CPUInfo.strFamily)-1); /* Flawfinder: ignore */
  2061. break;
  2063. default:
  2064. strncat(strCPUName, "PowerPC (Unknown)", sizeof(strCPUName)-strlen(strCPUName)-1); /* Flawfinder: ignore */
  2065. break;
  2066. }
  2068. CPUInfo._Ext.EMMX_MultimediaExtensions = 
  2069. CPUInfo._Ext.MMX_MultimediaExtensions = 
  2070. CPUInfo._Ext.SSE_StreamingSIMD_Extensions =
  2071. CPUInfo._Ext.SSE2_StreamingSIMD2_Extensions = false;
  2073. CPUInfo._Ext.Altivec_Extensions = hasFeature("hw.optional.altivec");
  2075. #endif
  2077. #if __i386__
  2078. // MBW -- XXX -- TODO -- make this call AnalyzeIntelProcessor()?
  2079. switch(cpusubtype)
  2080. {
  2081. default:
  2082. strncat(strCPUName, "i386 (Unknown)", sizeof(strCPUName)-strlen(strCPUName)-1); /* Flawfinder: ignore */
  2083. break;
  2084. }
  2086. CPUInfo._Ext.EMMX_MultimediaExtensions = hasFeature("hw.optional.mmx");  // MBW -- XXX -- this may be wrong...
  2087. CPUInfo._Ext.MMX_MultimediaExtensions = hasFeature("hw.optional.mmx");
  2088. CPUInfo._Ext.SSE_StreamingSIMD_Extensions = hasFeature("hw.optional.sse");
  2089. CPUInfo._Ext.SSE2_StreamingSIMD2_Extensions = hasFeature("hw.optional.sse2");
  2090. CPUInfo._Ext.Altivec_Extensions = false;
  2091. CPUInfo._Ext.AA64_AMD64BitArchitecture = hasFeature("hw.optional.x86_64");
  2093. #endif
  2095. // Terse CPU info uses this string...
  2096. strncpy(CPUInfo.strBrandID, strCPUName,sizeof(CPUInfo.strBrandID)-1); /* Flawfinder: ignore */
  2097. CPUInfo.strBrandID[sizeof(CPUInfo.strBrandID)-1]='';
  2099. // Fun cache config stuff...
  2101. if(l1dcachesize != 0)
  2102. {
  2103. CPUInfo._L1.Data.bPresent = true;
  2104. snprintf(CPUInfo._L1.Data.strSize, sizeof(CPUInfo._L1.Data.strSize), "%d KB", l1dcachesize / 1024); /* Flawfinder: ignore */
  2105. // CPUInfo._L1.Data.uiAssociativeWays = ???;
  2106. CPUInfo._L1.Data.uiLineSize = cachelinesize;
  2107. }
  2109. if(l1icachesize != 0)
  2110. {
  2111. CPUInfo._L1.Instruction.bPresent = true;
  2112. snprintf(CPUInfo._L1.Instruction.strSize, sizeof(CPUInfo._L1.Instruction.strSize), "%d KB", l1icachesize / 1024); /* Flawfinder: ignore */
  2113. // CPUInfo._L1.Instruction.uiAssociativeWays = ???;
  2114. CPUInfo._L1.Instruction.uiLineSize = cachelinesize;
  2115. }
  2117. if(l2cachesize != 0)
  2118. {
  2119. CPUInfo._L2.bPresent = true;
  2120. snprintf(CPUInfo._L2.strSize, sizeof(CPUInfo._L2.strSize), "%d KB", l2cachesize / 1024); /* Flawfinder: ignore */
  2121. // CPUInfo._L2.uiAssociativeWays = ???;
  2122. CPUInfo._L2.uiLineSize = cachelinesize;
  2123. }
  2125. if(l3cachesize != 0)
  2126. {
  2127. CPUInfo._L2.bPresent = true;
  2128. snprintf(CPUInfo._L2.strSize, sizeof(CPUInfo._L2.strSize), "%d KB", l3cachesize / 1024); /* Flawfinder: ignore */
  2129. // CPUInfo._L2.uiAssociativeWays = ???;
  2130. CPUInfo._L2.uiLineSize = cachelinesize;
  2131. }
  2133. CPUInfo._Ext.FPU_FloatingPointUnit = hasFeature("hw.optional.floatingpoint");
  2135. // printf("pagesize = 0x%xn", pagesize);
  2136. // printf("cachelinesize = 0x%xn", cachelinesize);
  2137. // printf("l1icachesize = 0x%xn", l1icachesize);
  2138. // printf("l1dcachesize = 0x%xn", l1dcachesize);
  2139. // printf("l2settings = 0x%xn", l2settings);
  2140. // printf("l2cachesize = 0x%xn", l2cachesize);
  2141. // printf("l3settings = 0x%xn", l3settings);
  2142. // printf("l3cachesize = 0x%xn", l3cachesize);
  2144. // After reading we translate the configuration to strings
  2145. TranslateProcessorConfiguration();
  2147. // After all we return the class CPUInfo member var
  2148. return (&CPUInfo);
  2149. }
  2151. #endif // LL_DARWIN
  2153. // bool CProcessor::CPUInfoToText(char *strBuffer, unsigned int uiMaxLen)
  2154. // ======================================================================
  2155. // Gets the frequency and processor information and writes it to a string
  2156. /////////////////////////////////////////////////////////////////////////
  2157. bool CProcessor::CPUInfoToText(char *strBuffer, unsigned int uiMaxLen)
  2158. {
  2159. #define LENCHECK                len = (unsigned int) strlen(buf); if (len >= uiMaxLen) return false; strcpy(strBuffer, buf); strBuffer += len;     /*Flawfinder: ignore*/
  2160. #define COPYADD(str)            strcpy(buf, str); LENCHECK;    /* Flawfinder: ignore */
  2161. #define FORMATADD(format, var)  sprintf(buf, format, var); LENCHECK;    /* Flawfinder: ignore */
  2162. #define BOOLADD(str, boolvar)   COPYADD(str); if (boolvar) { COPYADD(" Yesn"); } else { COPYADD(" Non"); }
  2164. char buf[1024]; /* Flawfinder: ignore */
  2165. unsigned int len;
  2167. // First we have to get the frequency
  2168.     GetCPUFrequency(50);
  2170. // Then we get the processor information
  2171. GetCPUInfo();
  2173.     // Now we construct the string (see the macros at function beginning)
  2174. strBuffer[0] = 0;
  2176. COPYADD("// CPU General Informationn//////////////////////////n");
  2177. FORMATADD("Processor name:   %sn", strCPUName);
  2178. FORMATADD("Frequency:        %.2f MHznn", (float) uqwFrequency / 1000000.0f);
  2179. FORMATADD("Vendor:           %sn", CPUInfo.strVendor);
  2180. FORMATADD("Family:           %sn", CPUInfo.strFamily);
  2181. FORMATADD("Extended family:  %dn", CPUInfo.uiExtendedFamily);
  2182. FORMATADD("Model:            %sn", CPUInfo.strModel);
  2183. FORMATADD("Extended model:   %dn", CPUInfo.uiExtendedModel);
  2184. FORMATADD("Type:             %sn", CPUInfo.strType);
  2185. FORMATADD("Brand ID:         %sn", CPUInfo.strBrandID);
  2186. if (CPUInfo._Ext.PN_ProcessorSerialNumber)
  2187. {
  2188. FORMATADD("Processor Serial: %sn", CPUInfo.strProcessorSerial);
  2189. }
  2190. else
  2191. {
  2192.   COPYADD("Processor Serial: Disabledn");
  2193. }
  2194. #if !LL_SOLARIS //  NOTE: Why bother printing all this when it's irrelavent
  2196. COPYADD("nn// CPU Configurationn////////////////////n");
  2197. FORMATADD("L1 instruction cache:           %sn", CPUInfo._L1.Instruction.strCache);
  2198. FORMATADD("L1 data cache:                  %sn", CPUInfo._L1.Data.strCache);
  2199. FORMATADD("L2 cache:                       %sn", CPUInfo._L2.strCache);
  2200. FORMATADD("L3 cache:                       %sn", CPUInfo._L3.strCache);
  2201. FORMATADD("Trace cache:                    %sn", CPUInfo._Trace.strCache);
  2202. FORMATADD("Instruction TLB:                %sn", CPUInfo._Instruction.strTLB);
  2203. FORMATADD("Data TLB:                       %sn", CPUInfo._Data.strTLB);
  2204. FORMATADD("Max Supported CPUID-Level:      0x%08lXn", CPUInfo.MaxSupportedLevel);
  2205. FORMATADD("Max Supported Ext. CPUID-Level: 0x%08lXn", CPUInfo.MaxSupportedExtendedLevel);
  2207. COPYADD("nn// CPU Extensionsn/////////////////n");
  2208. BOOLADD("AA64   AMD 64-bit Architecture:                    ", CPUInfo._Ext.AA64_AMD64BitArchitecture);
  2209. BOOLADD("ACPI   Thermal Monitor And Clock Control:          ", CPUInfo._Ext.ACPI_ThermalMonitorAndClockControl);
  2210. BOOLADD("APIC   Advanced Programmable Interrupt Controller: ", CPUInfo._Ext.APIC_AdvancedProgrammableInterruptController);
  2211. FORMATADD("       APIC-ID:                                     %dn", CPUInfo._Ext.APIC_ID);
  2212. BOOLADD("CLFSH  CLFLUSH Instruction Presence:               ", CPUInfo._Ext.CLFSH_CFLUSH_Instruction);
  2213. FORMATADD("       CLFLUSH Instruction Cache Line Size:         %dn", CPUInfo._Ext.CLFLUSH_InstructionCacheLineSize);
  2214. BOOLADD("CMOV   Conditional Move And Compare Instructions:  ", CPUInfo._Ext.CMOV_ConditionalMoveAndCompareInstructions);
  2215. BOOLADD("CX8    COMPXCHG8B Instruction:                     ", CPUInfo._Ext.CX8_COMPXCHG8B_Instruction);
  2216. BOOLADD("DE     Debugging Extensions:                       ", CPUInfo._Ext.DE_DebuggingExtensions);
  2217. BOOLADD("DS     Debug Store:                                ", CPUInfo._Ext.DS_DebugStore);
  2218. BOOLADD("FGPAT  Page Attribute Table:                       ", CPUInfo._Ext.FGPAT_PageAttributeTable);
  2219. BOOLADD("FPU    Floating Point Unit:                        ", CPUInfo._Ext.FPU_FloatingPointUnit);
  2220. BOOLADD("FXSR   Fast Streaming SIMD Extensions Save/Restore:", CPUInfo._Ext.FXSR_FastStreamingSIMD_ExtensionsSaveRestore);
  2221. BOOLADD("HT     Hyper Threading:                            ", CPUInfo._Ext.HT_HyperThreading);
  2222. BOOLADD("IA64   Intel 64-Bit Architecture:                  ", CPUInfo._Ext.IA64_Intel64BitArchitecture);
  2223. BOOLADD("MCA    Machine Check Architecture:                 ", CPUInfo._Ext.MCA_MachineCheckArchitecture);
  2224. BOOLADD("MCE    Machine Check Exception:                    ", CPUInfo._Ext.MCE_MachineCheckException);
  2225. BOOLADD("MMX    Multimedia Extensions:                      ", CPUInfo._Ext.MMX_MultimediaExtensions);
  2226. BOOLADD("MMX+   Multimedia Extensions:                      ", CPUInfo._Ext.EMMX_MultimediaExtensions);
  2227. BOOLADD("MSR    Model Specific Registers:                   ", CPUInfo._Ext.MSR_ModelSpecificRegisters);
  2228. BOOLADD("MTRR   Memory Type Range Registers:                ", CPUInfo._Ext.MTRR_MemoryTypeRangeRegisters);
  2229. BOOLADD("PAE    Physical Address Extension:                 ", CPUInfo._Ext.PAE_PhysicalAddressExtension);
  2230. BOOLADD("PGE    PTE Global Flag:                            ", CPUInfo._Ext.PGE_PTE_GlobalFlag);
  2231. if (CPUInfo._Ext.PN_ProcessorSerialNumber)
  2232. {
  2233. FORMATADD("PN     Processor Serial Number:                     %sn", CPUInfo.strProcessorSerial);
  2234. }
  2235. else
  2236. {
  2237. COPYADD("PN     Processor Serial Number:                     Disabledn");
  2238. }
  2239. BOOLADD("PSE    Page Size Extensions:                       ", CPUInfo._Ext.PSE_PageSizeExtensions);
  2240. BOOLADD("PSE36  36-bit Page Size Extension:                 ", CPUInfo._Ext.PSE36_36bitPageSizeExtension);
  2241. BOOLADD("SEP    Fast System Call:                           ", CPUInfo._Ext.SEP_FastSystemCall);
  2242. BOOLADD("SS     Self Snoop:                                 ", CPUInfo._Ext.SS_SelfSnoop);
  2243. BOOLADD("SSE    Streaming SIMD Extensions:                  ", CPUInfo._Ext.SSE_StreamingSIMD_Extensions);
  2244. BOOLADD("SSE2   Streaming SIMD 2 Extensions:                ", CPUInfo._Ext.SSE2_StreamingSIMD2_Extensions);
  2245. BOOLADD("ALTVEC Altivec Extensions:                         ", CPUInfo._Ext.Altivec_Extensions);
  2246. BOOLADD("TM     Thermal Monitor:                            ", CPUInfo._Ext.TM_ThermalMonitor);
  2247. BOOLADD("TSC    Time Stamp Counter:                         ", CPUInfo._Ext.TSC_TimeStampCounter);
  2248. BOOLADD("VME    Virtual 8086 Mode Enhancements:             ", CPUInfo._Ext.VME_Virtual8086ModeEnhancements);
  2249. BOOLADD("3DNow! Instructions:                               ", CPUInfo._Ext._3DNOW_InstructionExtensions);
  2250. BOOLADD("Enhanced 3DNow! Instructions:                      ", CPUInfo._Ext._E3DNOW_InstructionExtensions);
  2251. #endif
  2252. // Yippie!!!
  2253. return true;
  2254. }
  2256. // bool CProcessor::WriteInfoTextFile(const std::string& strFilename)
  2257. // ===========================================================
  2258. // Takes use of CProcessor::CPUInfoToText and saves the string to a
  2259. // file
  2260. ///////////////////////////////////////////////////////////////////
  2261. bool CProcessor::WriteInfoTextFile(const std::string& strFilename)
  2262. {
  2263. char buf[16384]; /* Flawfinder: ignore */
  2265. // First we get the string
  2266. if (!CPUInfoToText(buf, 16383))
  2267. return false;
  2269. // Then we create a new file (CREATE_ALWAYS)
  2270. LLFILE *file = LLFile::fopen(strFilename, "w"); /* Flawfinder: ignore */
  2271. if (!file)
  2272. return false;
  2274. // After that we write the string to the file
  2275. unsigned long dwBytesToWrite, dwBytesWritten;
  2276. dwBytesToWrite = (unsigned long) strlen(buf);  /*Flawfinder: ignore*/
  2277. dwBytesWritten = (unsigned long) fwrite(buf, 1, dwBytesToWrite, file);
  2278. fclose(file);
  2279. if (dwBytesToWrite != dwBytesWritten)
  2280. return false;
  2282. // Done
  2283. return true;
  2284. }