Fieldpine Logo Documentation Home  



QeHardware is a standalone test dll used by various Fieldpine applications to ensure that underlying hardware is actually achieving the performance required, rather than assuming it meets certain levels. It is not designed as a benchmarking application and there are better tools if you wish to perform hardware benchmarking.

In general, this DLL will be invoked automatically at various times by the system to test hardware performance, but it can be invoked manually if you wish to perform and capture a manual check. If you are using Gds/2, this tool is available on the support tab under the debug section.

Command Line

	rundll32 qehardware.dll,WinStart area [ -o output.file ]
Area can be any of the following

Report the internal CPU and harware capabilities, such as processor level, available instructions etc. On a virtual machine, this reports that information provided by the VM, not the underlying actual hardware.
Measure the speed of various components of the system. CPU, memory, instructions and IO performance. The IO performance portion of the test uses the current working drive, so typically you will have your default directory set to C: or whatever drive is being used. Do not do IO tests from USB flash drives, this does not reflect where the application is performing IO.

Most of the speed tests provide relative metrics rather than time windows, if you require exact timing, use a benchmarking application.

Time how long a specific operation takes. This area is superseeded by "speed"
Dump minimal information about if certain instructions are present. The "cpuid" instruction provides a more comprehensive human readable equivalent.

You can download a copy of QeHardware from qehardware.dll or

QeHardware writes to Stdout. If you are not seeing output when run from a command line prompt, use the -o option. eg

	rundll32 qehardware.dll,WinStart speed -o speed.txt


Example of "rundll32 qehardware.dll,WinStart cpuid" output
#1, EAX=000006fd EBX=00020800 ECX=0000e3bd EDX=bfebfbff
#2, EAX=05b0b101 EBX=005657f0 ECX=00000000 EDX=2cb4307d
#3, EAX=00000000 EBX=00000000 ECX=00000000 EDX=00000000
#4, EAX=04000121 EBX=01c0003f ECX=0000003f EDX=00000001
#5, EAX=00000040 EBX=00000040 ECX=00000003 EDX=00022220
#6, EAX=00000003 EBX=00000002 ECX=00000001 EDX=00000000
#7, EAX=00000000 EBX=00000000 ECX=00000000 EDX=00000000
#8, EAX=00000400 EBX=00000000 ECX=00000000 EDX=00000000
#9, EAX=00000000 EBX=00000000 ECX=00000000 EDX=00000000
#10, EAX=07280202 EBX=00000000 ECX=00000000 EDX=00000503
#80000000(0), EAX=80000008 EBX=00000000 ECX=00000000 EDX=00000000
#80000001(1), EAX=00000000 EBX=00000000 ECX=00000001 EDX=20100000
#80000002(2), EAX=65746e49 EBX=2952286c ECX=726f4320 EDX=4d542865
#80000003(3), EAX=44203229 EBX=43206f75 ECX=20205550 EDX=54202020
#80000004(4), EAX=30353237 EBX=20402020 ECX=30302e32 EDX=007a4847
#80000005(5), EAX=00000000 EBX=00000000 ECX=00000000 EDX=00000000
#80000006(6), EAX=00000000 EBX=00000000 ECX=08006040 EDX=00000000
#80000007(7), EAX=00000000 EBX=00000000 ECX=00000000 EDX=00000000
#80000008(8), EAX=00003024 EBX=00000000 ECX=00000000 EDX=00000000

CPU: GenuineIntel
 Processor Type=00 (Original OEM Processor) Family Id=06 Model=0f Stepping Id=0d Extended Family Id=00 Extended Model Id=00
 BrandIndex=00, CFlush Line Size=64, MaxAddressId=2, Initial APID Id=00
Cache(1):   57 56 b4
  Prefetch:  64Byte
  iTLB: 2M pages 4 way 8 entries OR 4M pages 4 way 4 entries, 4K pages 4 way set associative 128 entries
  dTLB: 4M pages 4 way set associative 32 entries
  Data Cache L1: , 32K 8 way set associative 64 byte line size
  Data Cache L2: , 2M 8 way set associative 64 byte line size
  Data Cache L3: 
  I Cache L1: , 32K 8 way set associative 64 byte line size
  I Cache L2: 
  I Cache L3: 

Features(3): LAHF/SAHF[64bit] ExecuteDisable Intel-64
Brand String: Intel(R) Core(TM)2 Duo CPU     T7250  @ 2.00GHz
CacheLineSize=64 L2CacheSize=2048K L2 Associativity=06 (8-way)

Example of "rundll32 qehardware.dll,WinStart speed" output. Some comments about the information shown are inline in red.

The lines starting with CPU. report time to perform some simple loop operations. The numbers underlined
are most relevant.  Less than say 200 indicates a slow CPU, numbers of 300+ are typical for modern architectures
CPU.t1 2109
CPU.t2 1000 253
CPU.t1 2047
CPU.t2 1000 257
CPU.t1 2078
CPU.t2 1000 260
CPU.t1 2032
CPU.t2 1000 256

The FILE counters relate to various file level operations such as open/close FILE.t1 406 1413 FILE.t1 406 1427 FILE.t1 406 1207 FILE.t1 407 1489 FILE.t2 406 1429 FILE.t2 406 1258 FILE.t2 406 1450 FILE.t2 407 1263 FILE.t3 578 75 FILE.t3 484 74 FILE.t3 422 73 FILE.t3 531 66
MEM.AllocClear shows the speed at which new memory can be allocated and initialised for a process. Numbers over 1,000MB/sec would be expected on real hardware, while most VM systems only achieve around 500MB/sec for this operation. Allocation of new memory to a process is not a frequent operation in reality, but does affect process startup and load ramp up times. MEM.AllocClear 235 (851 MB/sec)
Mem.General test various ways of accessing main memory. Most of these tests are using sequential and random, or 32bit, 64bit, or multiple thread access. Gds/2 systems may use these results to detect the "best" algorithm for a platform at runtime.
The numbers underlined are a good general purpose reference. Numbers more than around 2400 indicate slower general purpose memory access. A typical average system should report around 1500 or less, although these tests vary considerably depending on exactly what is executing on the CPU at the time of test
MEM.General t1=218 MEM.General t2=235 MEM.General t3=219 MEM.General t4=1531 MEM.General t1=219 MEM.General t2=250 MEM.General t3=218 MEM.General t4=1735 MEM.General t1=234 MEM.General t2=234 MEM.General t3=219 MEM.General t4=1578 MEM.General t1=235 MEM.General t2=250 MEM.General t3=234 MEM.General t4=1641 MEM.SeqLong t1=140 MEM.SeqLong t2=125 MEM.SeqLong t3=172 MEM.SeqLong t1=141 MEM.SeqLong t2=125 MEM.SeqLong t3=140 MEM.SeqLong t1=141 MEM.SeqLong t2=125 MEM.SeqLong t3=125 MEM.SeqLong t1=141 MEM.SeqLong t2=125 MEM.SeqLong t3=125 MEM.Seq16 125 MEM.Seq16 109 MEM.Seq16 109 MEM.Seq16 125 MEM.ParaSep64.4A 94 94 MEM.ParaSep64.4A 109 110 MEM.ParaSep64.4A 110 125 MEM.ParaSep64.4A 109 109 MEM.Para64.4B 46 47 MEM.Para64.4B 47 47 MEM.Para64.4B 63 62 MEM.Para64.4B 47 47
The IO block shows performance of different types of IO operations.
For RandomShortSmallWait, you times should be less than about 8mS, higher than this might indicate contention. Above around 20mS would indicate problems.
For SeqBigWait, you should easily achieve 80MB/sec on modern hardware, but contention will lower this number
SeqBigQueue should report the highest MB/sec for all tests. This tests queues a number of large IO requests for random information to the disk, forcing it to prioritise requests. This test will cause head movement and load the IO bus. This test can fail on some environments and report 0.
IO.RandomShortSmallWait 6735 (13.47mS) (296 kB/sec) (Error 0) IO.SeqBigWait 13218 (132.18mS) (30 MB/sec) IO.SeqBigWaitGap 12847 (128.47mS) (31 MB/sec) IO.RandomLongSmallWait 18671 (37.34mS) (107 kB/sec) (Error 0) IO.SeqBigQueue 9860 (246.50mS) (32 MB/sec) [22]