Content uploaded by Roy Longbottom
Author content
All content in this area was uploaded by Roy Longbottom on Jul 19, 2019
Content may be subject to copyright.
Raspberry Pi 4B Stress Tests Including High Performance Linpack
Roy Longbottom
Contents
Introduction
General Integer Test Floating Point Tests
Environment Monitors OpenGL Test Livermore Loops Test
Input/Output Test High Performance Linpack
Test Results
Unstressed Tests Single/Multi Core CPU Tests OpenGL Test No Cooling
Integer Stress Tests SP Floating Point Stress Tests DP Floating Point Stress Tests
High Performance Linpack Tests Livermore Loops/OpenGL Tests Loops/OpenGL Dual Monitors
Input/Output Stress Tests
Summary
These stress tests are a continuation of activity covered in Raspberry-Pi-4-Benchmarks.pdf at ResearchGate.
This report contains details and results of the programs used for stress testing Raspberry Pi 4B. They cover multi core CPU
integer and floating point tests with data covering caches and RAM, Input/Output exercisers for the main, USB and
network connected drives and graphics activity via OpenGL. The programs used, or new test functions, are ones that are
known to have caused errors, system failures or overheating issuers on earlier Raspberry Pi systems and PCs. Those
reported here represent a small sample of the tests carried out.
When running the stress tests, the environment was monitored using system utilities and a program that measures CPU
MHz, voltage and temperature. The specially written stress tests mainly provide, display and log average ongoing
measurements of performance over sections of the testing period, more useful than a report at the end.
An important observation is that the processor runs at full speed 1500 MHz, until the temperature reaches 80°C, when
throttling starts, firstly at 1000 MHz, then 750, 600 and lower. The first tests are intended to show that, using a single
core, the CPU can run at full speed with the temperatures less than 75°C (room up to 25°C). This applied to a one hour
OpenGL session and a five minute integer stress test, where four cores started throttling after less than a minute.
4 Core Integer Tests - These were run for 15 minutes without any cooling, with a copper heatsink, using an official Power
Over Ethernet Hat/Fan and an inexpensive case/fan. The first started throttling after a minute, reaching 85°C, finally
running at 56% of initial speed. The second was slightly better at 63%. Both with fans ran at full speed at up to 61°C and
66°C respectively.
4 Core Floating Point Tests - These included runs with no cooling and using the case/fan enclosure, covering L1 cache
and L2 cache based data, with the same thermal behaviour as the integer tests. The single precision version ran
continuously at more than 20 GFLOPS with the fan, reducing slowly to 10.9 GFLOPS with no cooling. The double precision
version obtained up to 10.7 GFLOPS, down to 5.2 GFLOPS.
High Performance Linpack - This double precision benchmark was included as it lead to wrong results and all sorts of
other failures using the original Pi 3. The version using ATLAS, with the alternative Basic Linear Algebra Subprograms, was
built on the Pi 4 and run with increasing data array sizes up to 20000 x 20000 words, occupying over 3 GB. All ran
successfully with and without cooling. At the largest size, the fan cooled setup obtained 10.8 GFLOPS at up to 71°C in just
over 8 minutes. The one without cooling was completed in over 14 minutes, down to 6.2 GFLOPS reaching 87°C.
Livermore Loops and OpenGL Benchmarks - Three copies of the former were run along with the most demanding test
function from the latter at 1920 x 1080 pixels. The CPU program executes 24 different double precision calculations using
three different data sizes for a minimum of nearly 15 minutes. With the case/fan combination all ran at near full speed at
an average of 60°C. There was an overall reduction in performance of up to 40% with no cooling, with temperature up to
85°C. The latter was repeated using dual monitors, effectively at 3840 x 1080 pixels, with all programs running somewhat
slower.
Input/Output Stress Tests - The main I/O program writes four 164 MB files comprising numerous different hexadecimal
data patterns, reads them on a random selection basis, for a specified time, then repetitively reads each 64 KB data block
numerous times. Three copies were run for nearly 15 minutes, accessing the main drive, a USB 3 stick and a remote PC via
a 1 Gbps LAN, at the same time, along with a copy of the 4 threaded integer testing program, with no cooling attachment.
There was the usual throttling at temperatures up to 86°C, with CPU test starting at 58% of possible maximum, reducing
to 44%. The LAN test appeared to run continuously at over 32 MB/second, the main drive at 85% of maximum expectation
and the USB 3 drive slower at down to 64%. No data comparison failures were detected in handling all that data.
Introduction below or Go To Start
Introduction
My original Raspberry Pi Stress Tests were reported in September 2017 for up to Pi 3B, then September 2018 with Pi 3B+
and later March 2019 for Pi 3B and 3B+, including High Performance Linpack errors
There were two versions, one using single precision floating point multiply and add calculations and the other with integer
add and subtract instructions. The tests comprised running multiple copies of the programs, in different terminal windows,
along with another program that measures CPU MHz, voltage and temperature. The latter tests were carried out, following
earlier reports that the Linpack High Performance Benchmark could produce the wrong numeric results, or cause a system
crash, using the older Raspberry Pi 3B. The stress tests could reproduce the same sort of failures, using the Pi 3B but, as
with HPL, not running on the Pi 3B+.
Analysing results of the earlier tests was complicated when Operating Systems did not assign resources evenly between
programs and tests would become more restrictive with CPUs containing more than four cores.
On producing benchmarks to run on Android based systems, the multiple program approach to stress testing was not really
applicable. So, I produced Android App version with single programs using multiple threads. I have now converted these to
run on Raspberry Pi systems. This March 2018 report. provides details of the latest Android tests. These include MP
behaviour and performance of more advanced ARM processors, up to 8 core Cortex-A73.
The new Respberry Pi Versions are initially available as 32 bit programs, comprising tests using single precision floating
point, double precision floating point and integer calculations. For these programs, each thread uses dedicated segments of
memory based data. There is also a slightly modified MHz/volts/temperature application.
The older OpenGL program is also considered here. All these have run time options to select a particular test function and
running time. The CPU tests can be run in a benchmarking mode, the default without any command line parameters, to
indicate which function is most appropriate and, at run time, the data size can be specified.
These stress tests are a continuation of activity covered in Raspberry-Pi-4-Benchmarks.pdf at ResearchGate, with
programs and source codes in Raspberry-Pi-4-Benchmarks.tar.gz, that also includes those used for this exercise.
Integer test next or Go To Start
Integer Stress Test - MP-IntStress
The integer program test loop comprises 32 add or subtract instructions, operating on hexadecimal data patterns, with
sequences of 8 subtracts then 8 adds to restore the original pattern. The benchmarking mode uses 1, 2, 4, 8, 16 and 32
threads, with data sizes 16 KB, 160 KB and 16 MB. Below is the log file from running the 32 bit benchmark on a Raspberry Pi
4B via Raspbian Buster. Disassembly shows that the test loop, in fact, used 68 instructions, most additional ones being load
register type. The result of these is 68/32 instructions per 4 byte word. At the maximum of 1489M words per second, using
a single core, resultant execution speed was 3164 MIPS with nearly four times more using all cores.
MP-Integer-Test 32 Bit v1.0 Fri Jun 21 15:39:57 2019
Benchmark 1, 2, 4, 8, 16 and 32 Threads
MB/second
KB KB MB Same All
Secs Thrds 16 160 16 Sumcheck Tests
4.9 1 5956 5754 3977 00000000 Yes
3.6 2 11861 11429 3763 FFFFFFFF Yes
3.1 4 22998 21799 3464 5A5A5A5A Yes
3.1 8 22695 21128 3490 AAAAAAAA Yes
3.1 16 22835 23491 3485 CCCCCCCC Yes
3.0 32 22593 23485 3591 0F0F0F0F Yes
Stress Testing Mode
The following shows the run time command and available parameters.
./MP_IntStress Threads tt, Minutes mm, KB kk, Log ll
tt = 1, 2, 4, 8, 16, 32
mm = greater than 0
kk = between 12 and 15624
ll = number added to log file name between 0 and 99
Floating Point Stress Tests below or Go To Start
Floating Point Stress Tests - MP-FPUStress, MP-FPUStressDP
The floating point programs use functions containing 2, 8 or 32 multiply and add operations, to exploit the availability of
instructions that can fuse them together for increased performance. The benchmark uses data sizes of 12.8 KB, 128 KB
and 12.8 MB with calculations via 1, 2, 4 and 8 threads. Each word is initialised with the same value of 0.99999 that
calculations slowly reduce, the final one being multiplied by 100000 for a sumcheck. Each word is then checked to confirm
that all results are identical.
Results are provided below, showing that sumchecks vary by data size and operations per word, due to variations in the
number of calculations, but are constant when the thread count is different through executing the same calculations.
Disassembly shows that Double Precision (DP) compilation produced instructions such as vfma.f64 d16, d25, fused multiply
and add, operating in one DP word registers. Information available indicates that this is the best possible performance
option, producing two operation results per clock cycle, 3.0 GFLOPS per core, in this case. Single Precision (SP) code was
vfma.f32 q8, q2, q13 with 4 words in quad registers, where eight results per cycle, might be expected, or 12 GFLOPS per
core. Actual maximum SP speeds look as though they could be about half of that.
MP-Threaded-MFLOPS 32 Bit v1.0 Sun May 26 21:23:49 2019
Benchmark 1, 2, 4 and 8 Threads
MFLOPS Numeric Results
Ops/ KB KB MB KB KB MB
Secs Thrd Word 12.8 128 12.8 12.8 128 12.8
1.6 T1 2 2134 2607 656 40392 76406 99700
2.9 T2 2 5048 5156 621 40392 76406 99700
4.0 T4 2 7536 9939 681 40392 76406 99700
5.2 T8 2 7934 9839 639 40392 76406 99700
7.2 T1 8 5535 5420 2569 54756 85091 99820
8.7 T2 8 10757 10732 2454 54756 85091 99820
10.1 T4 8 18108 20703 2444 54756 85091 99820
11.5 T8 8 19236 20286 2245 54756 85091 99820
17.4 T1 32 5309 5270 5262 35296 66020 99519
20.4 T2 32 10551 10528 9753 35296 66020 99519
22.4 T4 32 20120 20886 11064 35296 66020 99519
24.5 T8 32 19415 20464 9929 35296 66020 99519
MP-Threaded-MFLOPS 32 Bit v1.0 Sun May 26 21:26:37 2019
Double Precision Benchmark 1, 2, 4 and 8 Threads
MFLOPS Numeric Results
Ops/ KB KB MB KB KB MB
Secs Thrd Word 12.8 128 12.8 12.8 128 12.8
3.4 T1 2 921 998 326 40395 76384 99700
6.1 T2 2 1968 1995 308 40395 76384 99700
8.4 T4 2 3465 3925 342 40395 76384 99700
10.9 T8 2 3646 3702 301 40395 76384 99700
15.1 T1 8 2377 2446 1283 54805 85108 99820
18.1 T2 8 4916 4860 1326 54805 85108 99820
20.5 T4 8 9202 9510 1391 54805 85108 99820
23.1 T8 8 9090 9006 1298 54805 85108 99820
34.5 T1 32 2695 2725 2707 35159 66065 99521
40.3 T2 32 5416 5441 5121 35159 66065 99521
44.1 T4 32 10666 10831 5275 35159 66065 99521
48.3 T8 32 10427 10602 4832 35159 66065 99521
Stress Testing Mode
The following shows the run time command and available parameters.
./MP_FPUStress Threads tt, Minutes mm, KB kk, Ops 00, Log ll
or MP_FPUStressDP
tt = 1, 2, 4, 8, 16, 32, 64
mm = greater than 0
kk = between 12 and 15624
ll = number added to log file name between 0 and 99
oo = 2, 8 or 32 operations per word
Environment Monitors below or Go To Start
Environment Monitors - RPiHeatMHzVolts2 vmstat, sar
A new version of RPiHeatMHzVolts2 was produced to incorporate temperature of the Power Measurement Integrated
Circuit (PMIC). The following shows the run time command and available parameters for the program and an example of
logged output. Note that the details are instantaneous samples. This is fine for temperature measurements, that change
relatively slowly, but when CPU temperature reaches a critical level, 80°C in this case, MHz throttling comes into play, and
this can be down and up quite rapidly. My CPU stress test programs repetitively report average performance over a number
of seconds, carrying out the same calculations, providing a better indication of the amount of throttling.
./RPiHeatMHzVolts2 Passes pp, Seconds ss, Log ll
pp = number of passes at ss intervals
ss = sampling intervals
ll = number added to log file name between 0 and 99
Temperature and CPU MHz Measurement
Temperature and CPU MHz Measurement
Start at Sun Jun 30 14:53:16 2019
Using 11 samples at 30 second intervals
Seconds
0.0 ARM MHz=1500, core volt=0.8912V, CPU temp=60.0'C, pmic temp=54.3'C
30.0 ARM MHz=1500, core volt=0.8859V, CPU temp=74.0'C, pmic temp=62.8'C
60.7 ARM MHz=1500, core volt=0.8859V, CPU temp=78.0'C, pmic temp=68.4'C
91.3 ARM MHz=1500, core volt=0.8859V, CPU temp=82.0'C, pmic temp=70.3'C
122.0 ARM MHz=1500, core volt=0.8859V, CPU temp=81.0'C, pmic temp=70.3'C
152.8 ARM MHz=1000, core volt=0.8859V, CPU temp=82.0'C, pmic temp=70.3'C
183.5 ARM MHz=1000, core volt=0.8859V, CPU temp=82.0'C, pmic temp=70.3'C
214.4 ARM MHz=1000, core volt=0.8859V, CPU temp=82.0'C, pmic temp=72.2'C
245.1 ARM MHz=1000, core volt=0.8859V, CPU temp=82.0'C, pmic temp=72.2'C
276.0 ARM MHz=1000, core volt=0.8859V, CPU temp=82.0'C, pmic temp=72.2'C
306.9 ARM MHz=1000, core volt=0.8859V, CPU temp=81.0'C, pmic temp=71.2'C
337.6 ARM MHz=1500, core volt=0.8859V, CPU temp=71.0'C, pmic temp=65.6'C
End at Sun Jun 30 14:58:54 2019
vmstat - This is used when running stress tests, to indicate system utilisation and to confirm speeds
measured by tests. Main columns used are free memory, I/O bytes in and out and user plus system
CPU utilisation, where 25% equals equivalent of 100% of one core.
pi@raspberrypi:~ $ vmstat 10 6 - for 6 measurements at 10 second intervals
procs -----------memory---------- ---swap-- -----io---- -system-- ------cpu----
r b swpd free buff cache si so bi bo in cs us sy id wa st
0 0 0 3654628 20884 196956 0 0 26 1 136 223 3 1 96 0 0
1 0 0 3613900 20888 213328 0 0 0 6 1249 2143 13 2 85 0 0
1 0 0 3612044 20904 214660 0 0 0 12 991 1650 24 3 73 0 0
1 0 0 3609776 20904 216944 0 0 0 3 935 1556 25 2 73 0 0
1 0 0 3604040 20912 222448 0 0 0 12 1025 1653 25 3 73 0 0
1 0 0 3602588 20920 224852 0 0 0 6 946 1548 25 2 73 0 0
sar -n DEV - This utility can be used to measure network traffic after installing Sysstat.
sar -n DEV 30 25 > sar.txt - for 25 measurements over 30 second periods
IFACE rxpck/s txpck/s rxkB/s txkB/s rxcmp/s txcmp/s rxmcst/s %ifutil
Example Write
wlan0 1190.20 2527.47 65.99 3744.17 0.00 0.00 2.93 0.00
Example Read
wlan0 2340.90 1059.03 3378.11 98.89 0.00 0.00 1.60 0.00
OpenGL Stress Tests below or Go To Start
OpenGL Stress Tests - videogl32
The OpenGL benchmark can also be run as a stress test. As a benchmark, it has six tests, the first four portraying moving
up and down a tunnel including various independently moving objects, with and without texturing. The last two tests,
represent a real application for designing kitchens. The first is in wireframe format, drawn with 23,000 straight lines, the
second having colours and textures applied to the surfaces.
The program has options to specify window sizes and to avoid excessive logging for use in a script file, as in the example
below. Starting with export vblank_mode=0, turns off VSYNC, identifying where FPS speeds greater than 60 FPS are
possible. Following is a script file and sample Pi 4 log. Default running time is 5 seconds each test and full screen, where no
sizes are specified. The time can be changes by adding such as Seconds 20 to the commands.
export vblank_mode=0
./videogl32 Width 320, Height 240, NoEnd
./videogl32 Width 640, Height 480, NoHeading, NoEnd
./videogl32 Width 1024, Height 768, NoHeading, NoEnd
./videogl32 NoHeading
###################################################################
GLUT OpenGL Benchmark 32 Bit Version 1, Thu May 2 19:01:05 2019
Running Time Approximately 5 Seconds Each Test
Window Size Coloured Objects Textured Objects WireFrm Texture
Pixels Few All Few All Kitchen Kitchen
Wide High FPS FPS FPS FPS FPS FPS
320 240 766.7 371.4 230.6 130.2 32.5 22.7
640 480 427.3 276.5 206.0 121.8 31.7 22.2
1024 768 193.1 178.8 150.5 110.4 31.9 21.5
1920 1080 81.4 79.4 74.6 68.3 30.8 20.0
Stress Tests
It is more appropriate to produce a script file to run stress tests and to include that
export function. The run command needs a minutes parameter and an optional test,
the default being Test 4 (./videogl32, Minutes 60 would run test 4 for an hour on a
full screen.
Below is an indication of CPU utilisation during the six tests. This is followed by
results of a short stress test, where average speed over each 30 seconds is
reported.
GLUT OpenGL Benchmark 32 Bit Version 1, Mon Jul 1 16:10:02 2019
Running Time Approximately 5 Seconds Each Test
Window Size Coloured Objects Textured Objects WireFrm Texture
Pixels Few All Few All Kitchen Kitchen
Wide High FPS FPS FPS FPS FPS FPS
1920 1080 57.3 56.2 53.4 49.9 30.7 19.9
1 core CP UT 20 28 40 68 104 100
###################################################################
Run Commands - export vblank_mode=0
./videogl32 Test 4, Mins 1, Log 7
OpenGL Reliability Test 32 Bit Version 1, Wed Jul 3 17:28:02 2019
Display 1920 x 1080 All Objects, With Textures, Test for 1 minutes
Test 4 All Objects, With Textures, 30 seconds, 47 FPS
Test 4 All Objects, With Textures, 30 seconds, 46 FPS
End at Wed Jul 3 17:29:03 2019
Livermore Loops Stress below or Go To Start
Livermore Loops Stress Test - liverloopsPiA7R
The Livermore Loops benchmark was converted to act as a stress test, following wrong numeric results being produced on
an overclocked, PC using a Pentium Pro CPU. The Loops comprise 24 double precision floating point kernels, with
performance measurements in terms of Millions of Floating Point Operations Per Second or MFLOPS. The kernel tests are
repeated three times, with different data sizes. By including the running time of each loop converts the benchmark into a
stress test, whereby numeric results of calculations are checked for correctness after each of the numerous passes, with
errors errors being logged, along with performance details. Detailed results are displayed continuously, as the tests are
running. There is too much detail for logging. So, as shown below, the start times of each section are reported.
Below an example command to run each test for approximately 12 seconds and save results in LoopsLog1.txt. Total time
should be around 24 x 3 x 12 = 864 seconds, or longer with CPU MHz throttling. This is followed by an example of results
for a short run.
Run command - ./liverloopsPiA7R Seconds 12 Log 1
#####################################################
Livermore Loops Benchmark vfpv4 32 Bit via C/C++ Wed Jul 3 15:11:50 2019
Reliability test 2 seconds each loop x 24 x 3
Part 1 of 3 start at Wed Jul 3 15:11:50 2019
Part 2 of 3 start at Wed Jul 3 15:12:38 2019
Part 3 of 3 start at Wed Jul 3 15:13:27 2019
Numeric results were as expected
MFLOPS for 24 loops
745.8 955.8 988.7 942.6 209.0 769.8 1194.1 1792.5 1254.6 447.9 213.2 186.3
150.7 349.9 778.3 623.3 734.2 1035.4 322.9 350.0 435.8 352.9 746.1 187.3
Overall Ratings
Maximum Average Geomean Harmean Minimum
1793.5 641.2 520.2 412.7 140.3
End of test Wed Jul 3 15:14:16 2019
Input/Output Stress Test below or Go To Start
Input/Output Stress Test - burnindrive2
This is essentially the same as my program used during hundreds of UK Government and University computer acceptance
trials during the 1970s and 1980s, with some significant achievements. Burnindrive writes four files, using 164 blocks of 64
KB, repeated 16 times (164.0 MB), with each block containing a unique data pattern. The files are then read for two
minutes, on a sort of random sequence, with data and file ID checked for correct values. Then each block (unique pattern)
is read numerous times, over one second, again with checking for correct values. Total time is normally about 5 minutes for
all tests, with default parameters. The data patterns are shown below, followed by run time parameters, then examples of
results provided (see later detailed results).
Patterns
No. Hex No. Hex No. Hex No. Hex No. Hex No. Hex No. Hex
1 0 25 800000 49 3 73 FF 97 FFFFDFFF 121 FFFFEAAA 145 FFFFF0F0
2 1 26 1000000 50 33 74 FF00FF 98 FFFFBFFF 122 FFFFAAAA 146 FFF0F0F0
3 2 27 2000000 51 333 75 1FF 99 FFFF7FFF 123 FFFEAAAA 147 F0F0F0F0
4 4 28 4000000 52 3333 76 3FF 100 FFFEFFFF 124 FFFAAAAA 148 FFFFFFE0
5 8 29 8000000 53 33333 77 7FF 101 FFFDFFFF 125 FFEAAAAA 149 FFFF83E0
6 10 30 10000000 54 333333 78 FFF 102 FFFBFFFF 126 FFAAAAAA 150 FE0F83E0
7 20 31 20000000 55 3333333 79 1FFF 103 FFF7FFFF 127 FEAAAAAA 151 FFFFFFC0
8 40 32 40000000 56 33333333 80 3FFF 104 FFEFFFFF 128 FAAAAAAA 152 FFFC0FC0
9 80 33 1 57 7 81 7FFF 105 FFDFFFFF 129 EAAAAAAA 153 FFFFFF80
10 100 34 5 58 1C7 82 FFFF 106 FFBFFFFF 130 AAAAAAAA 154 FFE03F80
11 200 35 15 59 71C7 83 FFFFFFFF 107 FF7FFFFF 131 FFFFFFFC 155 FFFFFF00
12 400 36 55 60 1C71C7 84 FFFFFFFE 108 FEFFFFFF 132 FFFFFFCC 156 FF00FF00
13 800 37 155 61 71C71C7 85 FFFFFFFD 109 FDFFFFFF 133 FFFFFCCC 157 FFFFFE00
14 1000 38 555 62 F 86 FFFFFFFB 110 FBFFFFFF 134 FFFFCCCC 158 FFFFFC00
15 2000 39 1555 63 F0F 87 FFFFFFF7 111 F7FFFFFF 135 FFFCCCCC 159 FFFFF800
16 4000 40 5555 64 F0F0F 88 FFFFFFEF 112 EFFFFFFF 136 FFCCCCCC 160 FFFFF000
17 8000 41 15555 65 F0F0F0F 89 FFFFFFDF 113 DFFFFFFF 137 FCCCCCCC 161 FFFFE000
18 10000 42 55555 66 1F 90 FFFFFFBF 114 BFFFFFFF 138 CCCCCCCC 162 FFFFC000
19 20000 43 155555 67 7C1F 91 FFFFFF7F 115 FFFFFFFE 139 FFFFFFF8 163 FFFF8000
20 40000 44 555555 68 1F07C1F 92 FFFFFEFF 116 FFFFFFFA 140 FFFFFE38 164 FFFF0000
21 80000 45 1555555 69 3F 93 FFFFFDFF 117 FFFFFFEA 141 FFFF8E38
22 100000 46 5555555 70 3F03F 94 FFFFFBFF 118 FFFFFFAA 142 FFE38E38
23 200000 47 15555555 71 7F 95 FFFFF7FF 119 FFFFFEAA 143 F8E38E38
24 400000 48 55555555 72 1FC07F 96 FFFFEFFF 120 FFFFFAAA 144 FFFFFFF0
Sequences - First 16
No. File No. File No. File No. File
1 0 1 2 3 5 0 2 1 3 9 0 3 1 2 13 0 1 2 3
2 1 2 3 0 6 1 3 2 0 10 1 0 3 2 14 1 2 3 0
3 2 3 0 1 7 2 0 1 3 11 2 1 0 3 15 2 3 0 1
4 3 0 2 1 8 3 1 2 0 12 3 2 1 0 16 3 0 2 1
###########################################################################
Run Time Parameters - Upper or Lower Case
Default
R or Repeats Data size, multiplier of 10.25 MB, more or less 16
P or Patterns Number of patterns for smaller files < 164 164
M or Minutes Large file reading time 2
L or Log Log file name extension 0 to 99 0
S or Seconds Time to read each block, last section 1
F or FilePath For other than SD card or SD card directory
C or CacheData Omit O_DIRECT on opening files to allow caching No
O or OutputPatterns Log patterns and file sequences used as above No
D or DontRunReadTests Or only run write tests No
Format ./burnindrive2 Repeats 16, Minutes 2, Log 0, Seconds 1
or ./burnindrive2 R 16, M 2, L 0, S 1
###########################################################################
Examples of Results
File 1 164.00 MB written in 12.79 seconds
File 2 164.00 MB written in 11.93 seconds
Read passes 1 x 4 Files x 164.00 MB in 0.31 minutes
Read passes 2 x 4 Files x 164.00 MB in 0.63 minutes
Passes in 1 second(s) for each of 164 blocks of 64KB:
580 580 580 580 580 580 580 580 580 580 580
580 580 580 580 580 580 580 580 580 580 580
High Performance Linpack Benchmark below or Go To Start
High Performance Linpack Benchmark - xhpl
In 1993, it was found that a precompiled version of High Performance Linpack (HPL) could produce the wrong and
inconsistent numeric calculations, also system crashes. For more information see this PDF file at ResearchGate. This report
includes behaviour of another version, compiled to use ATLAS, using alternative Basic Linear Algebra Subprograms. This
took 14 hours to build, and was slower than the earlier one, but still produced the same failures. As indicated in the report,
my stress tests could be arranged to produce similar problems. There were no sumcheck failures or system crashes, using
the Pi 3B+.
The original precompiled version would not run on the Pi 4 but I rebuilt ATLAS on the new system, this time taking 8 hours.
an example of the output for a quick test is shown below:
HPLinpack 2.2 -- High-Performance Linpack benchmark -- February 24, 2016
Written by A. Petitet and R. Clint Whaley, Innovative Computing Laboratory, UTK
Modified by Piotr Luszczek, Innovative Computing Laboratory, UTK
Modified by Julien Langou, University of Colorado Denver
================================================================================
An explanation of the input/output parameters follows:
T/V : Wall time / encoded variant.
N : The order of the coefficient matrix A.
NB : The partitioning blocking factor.
P : The number of process rows.
Q : The number of process columns.
Time : Time in seconds to solve the linear system.
Gflops : Rate of execution for solving the linear system.
The following parameter values will be used:
N : 1000
NB : 128
PMAP : Row-major process mapping
P : 2
Q : 2
PFACT : Right
NBMIN : 4
NDIV : 2
RFACT : Crout
BCAST : 1ringM
DEPTH : 1
SWAP : Mix (threshold = 64)
L1 : transposed form
U : transposed form
EQUIL : yes
ALIGN : 8 double precision words
--------------------------------------------------------------------------------
- The matrix A is randomly generated for each test.
- The following scaled residual check will be computed:
||Ax-b||_oo / ( eps * ( || x ||_oo * || A ||_oo + || b ||_oo ) * N )
- The relative machine precision (eps) is taken to be 1.110223e-16
- Computational tests pass if scaled residuals are less than 16.0
================================================================================
T/V N NB P Q Time Gflops
--------------------------------------------------------------------------------
WR11C2R4 1000 128 2 2 0.17 4.048e+00
HPL_pdgesv() start time Sun May 26 08:44:56 2019
HPL_pdgesv() end time Sun May 26 08:44:56 2019
------------------------------------------------------------------------========
Unstressed Tests below or Go To Start
Unstressed Tests
It is quite easy to produce programs that run at high speeds on all cores of a modern computer, be it a PC, tablet, phone
or a small board system like the Raspberry Pi. These programs are likely to lead to increased CPU temperatures. Given
insufficient cooling arrangements, the systems are likely to continuously reduce CPU MHz (throttling) in order to continue
operation, and eventually power down. Before examining the results of stress testing, it is useful to consider what can be
run without throttling occurring, in this case, on a Raspberry Pi 4, without any cooling.
Single Core and Multi-Core CPU Tests
Below are various results from running five minute MP-Integer-Tests on a Raspberry Pi 4B, out of the case, with no cooling
attachment. As indicated earlier, ongoing speed measurements by a benchmark provides a better understanding of
behaviour, than samples of CPU MHz, that can vary rapidly.
Starting and ending recorded temperatures are shown, along with time when and if 80°C was reached, when throttling will
start. The first column is for a run using a single thread, where CPU MHz, and effectively measured speeds, were constant
over the whole period. The second column provides details when using four threads, with data in L1 caches. The next two
made use of data in L2 cache, starting throttling after one minute, worse than the L1 results, but starting at a higher
temperature. The last column provides results when data was in RAM and running at full speed for over four aand a half
minutes.
MB/second
Cache/RAM L2 L1 L2 L2 RAM
KB 512 64 640 1536 15624
Threads 1 4 4 8 4
Start 62 60 62 64 61
10 5718 23631 22628 20177 3445
20 5717 23603 22634 18329 3443
30 5640 23416 22670 18756 3405
40 5735 23613 22045 17737 3440
50 5740 23618 22636 18456 3444
60 5652 23244 22069 19059 3410
70 5707 23483 19864 17648 3437
80 5736 23360 18639 16017 3445
90 5683 21552 17986 16654 3447
100 5695 20867 17383 14864 3395
110 5719 20218 16475 14805 3437
120 5672 19017 16207 15128 3443
130 5727 18871 15165 13328 3401
140 5735 18888 14773 12638 3437
150 5732 18460 14979 12780 3443
160 5677 17799 14780 13086 3440
170 5719 17976 14313 13221 3404
180 5711 18005 14391 12618 3443
190 5650 17745 14018 12185 3440
200 5738 17312 14120 13267 3397
210 5709 17241 14062 11916 3442
220 5678 17124 14004 11866 3441
230 5719 17392 13467 12018 3397
240 5720 16990 13728 11825 3440
250 5651 17289 13372 12011 3434
260 5714 17135 13683 11596 3442
270 5717 16891 13584 11481 3398
280 5657 16505 13055 11781 3442
290 5725 17049 13396 11550 3445
300 5713 16578 12957 11666 3402
Max 5740 23631 22670 20177 3447
Min 5640 16505 12957 11481 3395
% 98 70 57 57 98
Max C 72 82 84 85 80
Time 80°C N/A 90 60 60 280
OpenGL Test below or Go To Start
OpenGL Test No Cooling
Earlier, I connected the Pi 4 system to BBC iPlayer, via WiFi, and displayed programmes for more than two hours on a full
screen 1920x1080 display (not a hot day). With CPU utilisation around 100% of one core, maximum temperature was 70°C,
with CPU at 1500 MHz all the time.
For this exercise, I ran the OpenGL Textured Kitchen test for an hour, with a full screen display (hotter day than above).
Following is a summary of recorded results by the program, the environmental monitor and vmstat. The program ran at 22
FPS over the whole period, with CPU at a constant 1500 MHz, recording slightly more than 100% utilisation of one core,
with maximum temperature reaching 73°C.
=------ Monitors ------ --------- vmstat --------- Video
gl32
°C °C
Seconds MHz Volts CPU PMIC free User System Idle FPS
0 1500 0.8894 61 54 3589900 0 0 100
120 1500 0.8841 69 59 3523336 25 2 73 22
240 1500 0.8841 71 62 3520464 25 2 73 22
360 1500 0.8841 71 63 3522848 25 2 73 22
480 1500 0.8841 73 63 3522292 25 2 73 22
600 1500 0.8841 72 63 3522284 25 2 73 22
720 1500 0.8841 72 63 3521780 24 2 74 22
840 1500 0.8841 73 63 3520640 25 2 73 22
960 1500 0.8841 72 63 3520884 25 2 73 22
1080 1500 0.8841 72 63 3520140 25 2 73 22
1200 1500 0.8841 73 63 3519864 24 2 73 22
1320 1500 0.8841 73 63 3519892 25 2 73 22
1440 1500 0.8841 73 63 3519892 25 2 73 22
1560 1500 0.8841 73 63 3518880 25 2 73 22
1680 1500 0.8841 72 63 3519264 25 2 73 22
1800 1500 0.8841 73 63 3517976 25 2 73 22
1920 1500 0.8841 73 63 3518616 25 2 73 22
2040 1500 0.8841 72 63 3517984 25 2 73 22
2160 1500 0.8841 72 63 3518604 24 2 73 22
2280 1500 0.8841 73 63 3518496 25 2 73 22
2400 1500 0.8841 73 63 3518868 25 2 73 22
2520 1500 0.8841 72 63 3518488 25 2 73 22
2640 1500 0.8841 73 63 3518212 25 2 73 22
2760 1500 0.8841 73 63 3520008 25 2 73 22
2880 1500 0.8841 73 63 3519756 25 2 73 22
3000 1500 0.8841 73 63 3516752 25 3 72 22
3120 1500 0.8841 73 63 3518132 25 2 73 22
3240 1500 0.8841 73 63 3518132 25 2 73 22
3360 1500 0.8841 73 63 3517620 24 2 73 22
3480 1500 0.8841 73 63 3517428 25 2 73 22
3600 1500 0.8841 73 63 3517656 25 2 73 22
Integer Stress Tests below or Go To Start
Integer Stress Tests - MP-IntStress
The following are results of 15 minute stress tests, using 1280 KB data and 8 threads. The data is greater than L2 cache,
but was in cache as only four threads were executed at a time. This then ran at full speed, with additional swapping of
cached data.
Four tests were carried out with no added cooling on a bare board, fitted with a copper heatsink, then with the official,
and expensive, Power Over Ethernet fan and, finally, using an inexpensive case with a fitted fan (GeeekPi Acrylic Case).
The changing CPU MHz measurements show that throttling is occurring but, with coarse sampling, they do not reflect real
performance, unlike the MB/second details.
With no cooling, throttling started after a minute, reaching 85°C to 86°C, slowly reducing performance to almost half
speed. The copper heatsink produced a small improvement. During the two tests where fans were used, the processor ran
continuously at 1500 MHz and throughput effectively at a constant MB/second. The POE fan appeared to be slightly more
efficient.
No Cooling Copper Heatsink Official POE Hat Case With Fan
Seconds MB/sec MHz °C MB/sec MHz °C MB/sec MHz °C MB/sec MHz °C
0 1500 60 1500 60 1500 47 1500 41
20 21651 1500 73 21381 1500 71 21770 1500 56 22018 1500 54
40 21892 1500 79 20517 1500 74 21767 1500 57 21979 1500 56
60 20919 1500 81 21407 1500 77 22234 1500 57 22076 1500 58
80 17174 1000 81 21153 1500 79 22035 1500 58 22248 1500 60
100 15643 1000 81 20960 1500 81 21920 1500 59 22153 1500 61
120 15163 1000 82 18967 1500 82 22184 1500 60 22239 1500 63
140 14756 1000 81 16828 1000 81 21941 1500 60 22037 1500 64
160 14491 1000 83 15892 1500 83 21863 1500 60 22231 1500 65
180 14492 1000 83 16157 1000 82 21753 1500 60 22130 1500 64
200 14283 1000 84 15039 1000 82 21921 1500 60 22050 1500 65
220 14386 1000 83 15438 1000 82 21656 1500 60 22210 1500 66
240 14101 1000 83 14905 1000 82 21908 1500 60 22132 1500 65
260 13574 1000 84 14597 1000 83 21983 1500 60 22298 1500 65
280 13763 1000 83 14703 1000 83 21701 1500 60 22031 1500 66
300 13179 1000 84 14519 1000 82 21857 1500 60 22285 1500 65
320 13566 1000 84 14204 1000 84 21791 1500 60 22009 1500 65
340 13368 750 84 14139 750 83 21468 1500 60 22101 1500 65
360 13530 1000 84 14249 1000 84 22162 1500 60 22166 1500 65
380 13190 1000 85 14457 1000 82 21819 1500 61 22163 1500 66
400 13215 1000 84 14395 1000 83 21800 1500 60 22243 1500 65
420 13021 750 85 14365 1000 83 22083 1500 61 22115 1500 64
440 13127 1000 84 14214 1000 83 21780 1500 60 22172 1500 64
460 12933 1000 85 14152 1000 83 21902 1500 60 22138 1500 64
480 12658 1000 85 14090 1000 84 21964 1500 60 22220 1500 64
500 12981 750 83 14199 1000 84 22026 1500 61 22061 1500 65
520 12699 1000 85 14005 1000 83 21661 1500 61 22027 1500 64
540 12622 1000 84 13987 1000 84 21684 1500 60 22281 1500 65
560 12761 1000 84 14222 1000 84 22071 1500 59 22097 1500 64
580 13408 1000 84 13845 1000 84 21728 1500 58 22225 1500 64
600 13878 1000 85 13945 1000 84 21981 1500 59 22091 1500 62
620 13893 1000 83 13877 1000 84 21704 1500 58 22203 1500 62
640 13717 1000 86 13844 1000 84 21935 1500 58 22133 1500 62
660 13321 1000 85 13774 1000 83 21816 1500 61 22075 1500 62
680 13154 1000 85 13500 1000 83 21827 1500 61 22229 1500 63
700 12663 1000 85 13926 1000 83 21995 1500 60 22007 1500 63
720 12504 1000 85 13722 1000 83 22004 1500 60 22279 1500 64
740 12501 750 85 13778 750 84 21954 1500 60 22020 1500 65
760 12227 1000 85 13564 1000 83 21848 1500 60 22270 1500 65
780 12199 750 85 13755 1000 82 21840 1500 61 22129 1500 65
800 12505 1000 85 13451 1500 82 22137 1500 59 22175 1500 64
820 12268 750 85 13587 1000 83 21876 1500 60 22210 1500 64
840 12322 1500 85 13610 1000 82 21685 1500 61 22041 1500 65
860 12312 1500 85 14411 1500 82 22077 1500 61 22192 1500 65
880 12306 1500 85 14380 1500 83 21842 1500 61 22109 1500 65
900 12305 1500 85 14345 1500 83 21883 1500 61 22199 1500 65
Max 21892 86 21407 84 22234 61 22298 66
Min 12199 750 13451 750 21468 1500 21979 1500
%Min/Max 56 63 97 99
Floating Point Stress Tests or Go To Start
Single Precision Floating Point Stress Tests - MP-FPUStress
The table below covers the first 10 minutes of tests on the three cooling configurations. This time, the rather meaningless
variations in recorded CPU MHz are not included. Again they used 1280 KB data (320K words) and 8 threads, with 8 floating
point operations per word. Maximum temperatures and associated performance degradations were similar to those during
the integer tests.
The following graphs provide a more meaningful indication of the effects of adequate cooling that is needed for this kind
CPU utilisation (confirmed during running by vmstat as 100% of four cores).
No Cooling Copper HS Case+Fan
Seconds °C GFLOPS °C GFLOPS °C GFLOPS
0 61 59 40
20 76 19.2 73 19.6 55 20.7
40 81 19.0 78 19.4 61 20.3
60 82 17.8 80 19.6 62 20.2
80 83 15.5 82 17.2 64 20.7
100 84 15.0 82 15.6 65 20.2
120 83 14.0 82 14.5 66 20.3
140 84 13.3 81 13.9 65 20.3
160 84 13.3 83 13.9 66 20.7
180 86 12.9 83 13.5 67 20.3
200 85 13.0 83 13.6 67 20.3
220 84 12.8 84 13.4 66 20.4
240 84 12.6 83 13.3 67 20.6
260 83 12.6 84 13.3 67 20.3
280 85 12.2 84 13.3 67 20.4
300 84 12.1 83 13.0 67 20.3
320 85 12.0 84 13.0 67 20.8
340 84 11.6 85 12.8 67 20.3
360 85 11.6 84 13.0 67 20.2
380 85 11.3 83 12.7 67 20.7
400 85 11.6 84 12.8 67 20.5
420 84 11.6 84 12.5 68 20.2
440 85 11.5 84 12.7 67 20.4
460 84 11.5 85 12.6 67 20.4
480 85 11.5 84 12.3 66 20.2
500 84 11.1 85 12.4 67 20.3
520 85 11.3 83 12.4 67 20.2
540 84 11.4 85 12.4 68 20.5
560 84 11.3 84 12.3 67 20.2
580 85 11.3 83 12.3 67 20.4
600 85 11.3 84 12.3 67 20.2
900 85 10.9 84 12.2 67 20.3
Max 19.2 19.6 20.8
Min 10.9 12.2 20.3
%Min/Max 57
Double Precision Floating Point Stress Tests below or Go To Start
Double Precision Floating Point Stress Tests - MP-FPUStressDP
Four sets of results are below, again excluding those CPU MHz figures, but including PMIC temperatures. They are without
and with the case/fan, using 8 threads, one with 1280 KB data size at 8 operations per word, and the other 128 KB with 32
operations per word.
The second one runs at a higher speed and lower temperature, using data in L1 caches, compared with the other via L2
cache. Maximum temperature and performance degradation of the latter were similar to the earlier examples.
1280 KB, 8 Threads, 8 Ops/Word 128 KB, 8 Threads, 32 Ops/Word
No Fan CPU PMIC Fan CPU PMIC No Fan CPU PMIC Fan CPU PMIC
Second GFLOPS °C °C GFLOPS °C °C GFLOPS °C °C GFLOPS °C °C
0 48 42.0 45 42.0 54 47.7 39 35.4
20 9.3 64 55.2 9.1 61 55.2 10.7 70 57.1 10.7 39 35.4
40 9.2 73 62.8 9.0 65 59.0 10.6 73 61.8 10.7 53 43.9
60 9.2 79 68.4 9.1 67 61.8 10.7 75 64.6 10.6 56 48.6
80 8.8 80 70.3 9.3 66 62.8 10.7 78 67.5 10.6 57 50.5
100 7.8 81 70.3 9.1 67 62.8 10.7 80 69.4 10.7 58 51.4
120 7.2 82 70.3 9.2 67 62.8 10.1 82 70.3 10.7 59 53.3
140 6.8 82 70.3 9.3 67 62.8 9.5 81 70.3 10.7 59 53.3
160 6.5 82 70.3 9.1 68 62.8 9.1 80 70.3 10.6 59 53.3
180 6.3 82 70.3 9.1 68 62.8 8.7 82 70.3 10.7 60 53.3
200 6.1 81 70.3 9.3 68 64.6 8.5 81 70.3 10.7 59 54.3
220 6.2 82 70.3 9.1 69 62.8 8.5 82 70.3 10.7 59 54.3
240 6.2 83 72.2 9.1 68 62.8 8.3 81 70.3 10.6 60 54.3
260 6.1 83 72.2 9.3 68 62.8 8.3 81 70.3 10.7 59 54.3
280 6.1 84 72.2 9.1 67 64.6 8.0 83 70.3 10.7 61 54.3
300 6.1 83 70.3 9.1 68 64.6 8.0 81 70.3 10.6 60 54.3
320 6.0 84 72.2 9.1 68 64.6 7.9 82 70.3 10.7 61 54.3
340 5.9 85 72.2 9.2 68 64.6 7.6 82 71.2 10.8 61 53.3
360 5.8 85 72.2 9.1 68 62.8 7.7 82 70.3 10.7 60 54.3
380 5.8 84 72.2 9.2 68 64.6 7.8 83 70.3 10.6 60 54.3
400 5.7 84 72.2 9.1 68 62.8 7.7 83 70.3 10.6 61 54.3
420 5.7 84 72.2 9.2 68 62.8 7.7 82 70.3 10.6 60 54.3
440 5.6 84 72.2 9.1 68 64.6 7.6 82 70.3 10.7 60 54.3
460 5.7 84 72.2 9.1 68 62.8 7.6 83 70.3 10.6 61 54.3
480 5.6 84 72.2 9.1 69 64.6 7.5 82 70.3 10.7 60 54.3
500 5.6 84 72.2 9.1 69 62.8 7.5 82 71.2 10.6 60 54.3
520 5.5 85 72.2 9.1 68 62.8 7.4 81 70.3 10.7 60 54.3
540 5.5 84 74.1 9.3 67 64.6 7.4 82 70.3 10.7 60 54.3
560 5.5 84 72.2 9.1 69 62.8 7.4 82 70.3 10.8 59 54.3
580 5.4 84 74.1 9.1 67 64.6 7.3 82 70.3 10.7 60 55.2
600 5.5 84 74.1 9.2 68 62.8 7.3 81 70.3 10.7 60 54.3
620 5.4 85 74.1 9.2 68 62.8 7.3 82 70.3 10.6 61 54.3
640 5.4 84 74.1 9.2 69 62.8 7.3 83 70.3 10.6 62 55.2
660 5.4 85 74.1 9.3 68 62.8 7.3 83 70.3 10.7 60 54.3
680 5.5 85 72.2 9.0 67 62.8 7.3 83 70.3 10.7 60 54.3
700 5.4 85 74.1 9.1 69 62.8 7.3 81 70.3 10.7 60 54.3
720 5.4 85 72.2 9.2 68 64.6 7.3 84 70.3 10.7 60 54.3
740 5.4 84 72.2 9.1 68 62.8 7.3 82 70.3 10.7 60 55.2
760 5.3 85 74.1 9.1 68 62.8 7.3 81 70.3 10.7 60 54.3
780 5.4 85 74.1 9.3 67 62.8 7.3 83 70.3 10.7 59 54.3
800 5.4 84 74.1 9.1 69 64.6 7.3 81 70.3 10.7 60 54.3
820 5.3 85 72.2 9.1 68 62.8 7.3 82 70.3 10.7 60 54.3
840 5.3 84 72.2 9.2 68 62.8 7.2 82 70.3 10.7 60 54.3
860 5.2 85 74.1 9.1 69 64.6 7.2 81 70.3 10.6 60 54.3
880 5.2 85 74.1 9.1 68 62.8 7.2 82 70.3 10.6 60 54.3
900 5.3 84 74.1 9.1 68 62.8 7.2 81 70.3 10.6 60 54.3
Max 9.3 85 74.1 9.3 69 64.6 10.7 84 71.2 10.8 62 55.2
Min 5.2 9.0 7.2 10.6
%Min/Ma 57 97 67 98
High Performance Linpack below or Go To Start
High Performance Linpack Tests - xhpl
Parameter sizes (as set in HPL.dat) were the same as in the introductory description, except for the one for data size (N).
The programs were run on a bare board Pi 4 and one in the inexpensive case with a fan. No data errors or system
freezes/crashes were encountered over these and many more runs.
Following is a summary of four tests on each of the test beds. The the bare board arrangement performs relatively well for
short duration tests, but the long ones are needed to demonstrate maximum performance. The latter was 10.8 Double
Precision GFLOPS, similar to my MP-FPUStressDP program, where, at 58%, that also applied to efficiency of the uncooled
processor. As it should be, the sumchecks of hot and cold systems were identical, at a given data size.
Assuming similarity with the original scalar Linpack benchmark, data size would be N x N x 8 for double precision operation
or 3.2 GB at N = 20000, as approximately confirmed by the vmstat memory details provided below. The latter also indicate
that the four core CPU utilisation was 100%.
Below the table is a graph, of the worst case uncooled scenario, to demonstrate CPU MHz throttling and temperature (°C
times 10), based on samples every 10 seconds.
Cooling N Seconds GFLOPS SumCheck Max °C Av MHz
None 4000 5.7 7.4 0.002398 71 1500
Fan 4000 5.2 8.2 0.002398 54 1500
None 8000 39.9 8.6 0.001675 81 1500
Fan 8000 36.7 9.3 0.001675 61 1500
None 16000 404.3 6.8 0.001126 86 919
Fan 16000 263.0 10.4 0.001126 70 1500
None 20000 856.0 6.2 0.001019 87 828
Fan 20000 494.3 10.8 0.001019 71 1500
%None/Fan 20000 58 58 Same 55
procs -----------memory---------- ---swap-- -----io---- -system- ------cpu-----
r b swpd free buff cache si so bi bo in cs us sy id wa st
0 0 0 3510712 30172 276440 0 0 17 1 90 111 16 1 83 0 0
4 0 0 3097880 30180 277088 0 0 0 6 526 515 52 3 45 0 0
4 0 0 2357404 30188 276492 0 0 0 6 620 344 95 5 0 0 0
4 0 0 1615192 30196 276976 0 0 0 11 586 289 95 5 0 0 0
5 0 0 871872 30204 271032 0 0 0 5 490 75 96 4 0 0 0
4 0 768 282692 26828 241092 0 34 20 40 604 307 95 4 0 0 0
4 0 768 276088 26968 250344 6 0 118 12 591 288 99 1 0 0 0
Livermore loops/OpenGL Tests below or Go To Start
Livermore Loops/OpenGL Tests
Three copies of Livermore Loops stress tests were run along with the OpenGL Tiled Kitchen section, on a Pi 4 without any
cooling, then in the case with a fan. The former program was arranged to have a nominal durations of 864 seconds (72 x
12). When running, the CPU load is continuously changing and that can be reflected in ongoing temperature and OpenGL
Frames Per Second. The tests make use of six terminal windows and a full screen display, run by the commands shown
below. This is followed by the results.
With no cooling, there were the usual increases in temperature and performance degradation, but not as severe as some of
the earlier tests. With cooling performance was effectively constant. Averages at the end reflect the differences. There
were no reports of errors or any sign of system failures.
Dual Monitors - The benchmarks, with no cooling, were repeated using two monitors, providing a screen area of 3840 x
1080 pixels, the results being included below. Performance was only between 7% and 15% slower than the single monitor
example. Benchmark results of all OpenGL tests and provided at the end of the table, showing those more dependent on
graphics speed were affected by the number of pixels displayed.
Run Commands
Terminal 1
vmstat 10 100
Terminal 2 script file
lxterminal -e ./RPiHeatMHzVolts2 Passes 120 Seconds 10 Log 20
lxterminal -e ./liverloopsPiA7R Seconds 12 Log 20
lxterminal -e ./liverloopsPiA7R Seconds 12 Log 21
lxterminal -e ./liverloopsPiA7R Seconds 12 Log 22
Terminal 3
./videogl32 Test 6, Mins 16, Log 20
Dual Monitors
No Cooling Case + Fan No Cooling
Seconds MHz °C FPS MHz °C FPS MHz °C FPS
0 1500 64 1500 42 1500 69
30 1000 82 19 1500 57 20 1000 82 13
60 1000 82 16 1500 62 21 750 84 13
90 1500 83 15 1500 66 20 1000 83 12
120 750 85 13 1500 64 21 1000 85 11
150 1000 84 13 1500 62 20 600 84 10
180 1000 83 14 1500 60 22 750 85 10
210 1000 84 15 1500 62 21 1000 85 12
240 1000 83 14 1500 61 19 750 84 12
270 1000 84 14 1500 63 21 1000 85 11
300 1000 84 14 1500 61 21 750 84 12
330 750 84 14 1500 64 21 1000 85 12
360 1000 82 14 1500 64 21 750 84 11
390 1000 83 12 1500 66 21 750 84 12
420 1000 84 13 1500 63 21 750 84 12
450 1000 84 14 1500 62 20 750 85 11
480 750 84 12 1500 63 21 750 85 12
510 750 85 13 1500 61 21 1000 84 12
540 750 84 11 1500 59 21 750 84 11
570 1000 84 12 1500 62 21 1000 85 11
600 1000 84 14 1500 62 22 750 83 10
630 1000 84 13 1500 66 19 750 84 11
660 750 84 14 1500 60 21 750 85 12
690 750 86 13 1500 65 21 1000 85 12
720 1000 84 13 1500 63 21 600 83 11
750 1000 83 13 1500 62 21 1000 84 12
780 750 84 12 1500 61 21 1000 85 11
810 750 85 12 1500 62 21 1000 84 11
840 1000 85 12 1500 58 21 750 86 10
870 750 85 12 1500 58 21 750 85 11
900 1000 84 13 1500 54 21 1000 85 10
930 1000 85 13 1500 50 21 1000 85 11
960 1000 84 13 1500 49 21 750 85 11
990 1000 85 14 1500 45 21 750 85 12
Average 956 83 13 1500 60 21 866 84 11
%Fan 64 139 64
MFLOPS 916 1502 854
%Fan 61
OpenGL Benchmark Single and Dual Monitors
Window Size Coloured Objects Textured Objects WireFrm Texture
Pixels Few All Few All Kitchen Kitchen
Wide High FPS FPS FPS FPS FPS FPS
1920 1080 58.2 56.7 54.5 49.9 31.0 20.7
3840 1080 27.9 26.5 26.0 25.2 25.7 16.3
Input/Output Stress Tests below or Go To Start
Input/Output Stress Tests - burnindrive2
For this test, three copies of burnindrive2 were run, accessing the main drive, a USB 3 stick and a remote PC via a 1 Gbps
LAN, along with MP-IntStress using four threads. The environment was monitored using RPiHeatMHzVolts2, vmstat for drive
activity and CPU MHz, and sar -n for network traffic. Commands used and results are provided below. Stress tests are
generally based on executing a fixed set of activities, where completion times can vary. Hence, the provided results are
extrapolated approximations, with drive speeds the average for a particular activity.
All stress tests ran to completion without detecting any errors. CPU utilisation was around 90% of four cores but CPU
throttling still occurred, with temperatures up to 86°C (and possibly not enough throttling). Performance measured by the
stress tests was broadly in line with the system vmstat and sar measurements. In order to indicate which activity suffered
from the most degradation, performance of standalone runs are also provided. It seems that LAN traffic was given a higher
priority, with no speed reduction, followed by the main SD drive. Worst was the CPU bound program, probably suffering
from a lower priority besides throttling.
------ MB/second ------
Secs Main USB 3 1Gbps MP-Int MHz °C
Drive Drive LAN Stress
0 1500 55
30 11.9 38.0 42.3 13116 1500 66
60 11.9 44.1 32.8 13063 1500 73
90 28.1 44.1 32.8 13615 1500 75
120 28.1 44.1 32.8 13734 1500 81
150 28.1 44.1 32.8 13370 1500 83
180 28.1 44.1 32.8 13555 1000 82
210 28.1 44.1 32.8 13285 1000 82
240 28.1 44.1 32.8 13194 1000 82
270 28.1 44.1 32.8 13022 1000 83
300 28.1 44.1 32.8 13316 1000 82
330 28.1 44.1 32.8 13615 1000 82
360 28.1 44.1 32.8 13677 1000 84
390 28.1 44.1 32.8 13315 1000 83
420 28.1 44.1 32.8 13273 1000 82
450 28.1 44.1 32.8 13117 1000 83
480 28.1 44.1 32.8 12860 1000 83
510 28.1 44.1 32.8 12370 1000 83
540 28.1 44.1 32.8 11863 1000 84
570 28.1 44.1 32.8 11550 1000 84
600 28.1 44.1 32.8 11312 1000 82
630 28.1 44.1 32.7 10895 1000 83
660 28.1 54.0 32.7 10696 1000 83
690 29.7 54.0 32.7 10479 1000 84
720 29.7 54.0 32.7 10223 750 84
750 29.7 54.0 32.7 10227 1000 85
780 29.7 54.0 32.7 10413 750 84
810 29.7 54.0 10090 750 86
840 29.7 9952 1000 84
Stand Alone
Max 33.4 68.6 32.3 22664
vmstat
procs -----------memory---------- --swap-- -----io---- -system- ------cpu-----
r b swpd free buff cache si so bi bo in cs us sy id wa st
Start
6 2 0 3499820 45700 271552 0 0 12409 32193 16450 13425 54 24 20 2 0
2 2 0 3503956 45776 264632 0 0 46811 12381 27174 16714 68 23 3 5 0
4 2 0 3506080 45816 264348 0 0 76271 248 25885 16188 64 22 7 7 0
Read 1
5 2 0 3502984 45992 264844 0 0 75473 5 18777 14118 67 24 3 6 0
5 2 0 3504888 46032 264884 0 0 74726 7 18907 14631 66 25 4 5 0
Read 2
6 2 0 3503236 46544 265452 0 0 86628 7 17180 15114 62 28 4 6 0
4 2 0 3501964 46592 265452 0 0 80815 6 15395 14321 68 28 2 2 0
Ethernet Read sar -n DEV
rxpck/s txpck/s rxkB/s txkB/s rxcmp/s txcmp/s rxmcst/s %ifutil
24841.37 6883.90 36206.23 505.50 0.00 0.00 0.03 29.66
Go To Start