QeHardware.dll

Overview

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

cpuid

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.

speed

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.

timetest1

Time how long a specific operation takes. This area is superseeded by "speed"

qemode

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.zip

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

Examples

Example of "rundll32 qehardware.dll,WinStart cpuid" output

MaxMask=10
#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
MaxMaskE=8
#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
Features(1): FPU VME DE PSE TSC MSR PAE MCE CX8 APIC SEP MTRR PGE MCA CMOV PAT PSE-36 CLFSH DS ACPI MMX FXSR SSE SSE2 SS HTT TM PBE
Features(2): SSE3 DTES64 MONITOR DS-CPL VMX EIST TM2 SSSE3 CMPXCHG16B xTPR PDCM
 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]