I just got my BeagleBone black device, this is really looking like a Raspberry PI, but personally I found multiple advantage for this card compare to RPI, the first one is related to the embedded 2GB of flash memory that do not require to add external storage. Thank to that, for the first start, you just need to connect the device to your network and a screen and it run ! After about 30s you are connected to a graphical interface and able to surf the web.
The first issue I got with this device is the micro-hdmi connector located really close to the USB connector, due to the current use of an micro-hdmi 2 hdmi adaptor, i’m not able to connect correctly a USB device.I highly recommend to use a micro-hdmi cable instead of a monoblock micro-hdmi to hdmi adaptor for this reason.
By the way, the device is accessible using ssh (root/rootme) and display can be exported easily.
The next part of the article will be about different comparison between BeagleBone and other systems like Raspberry Pi.
Continue to read this article …
Performance comparison
I used to compare systems with lmbench because it is simple and really low level, so I have different systems compared in the history of this blog. This time, I benched the BeagleBone Black and a Raspberry PI (not overclocked) and as I still had a Atom dual core 1.8GB in my lmbench history, i’ll indicate it also as a reference for mini PC vs embedded system.
Processor, Processes - times in microseconds - smaller is better ------------------------------------------------------------------------------ Host OS Mhz null null open slct sig sig fork exec sh call I/O stat clos TCP inst hndl proc proc proc --------- ------------- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- raspberry Linux 3.6.11+ 800 0.50 1.23 5.77 14.6 34.2 1.33 6.56 1816 5593 12.K beaglebon Linux 3.8.13 994 0.39 0.74 4.34 10.4 19.9 1.07 5.86 982. 3313 10.K jupiter Linux 2.6.31. 1785 0.21 0.46 4.12 8.13 9.02 0.49 3.55 382. 435. 6494
This first part about process submission & call show that beagle bone a little bit better, the different is easily explained by the frequency. We can also see a ratio of 2 in many cases with an Atom processor ; also explained by frequency.
Basic integer operations - times in nanoseconds - smaller is better ------------------------------------------------------------------- Host OS intgr intgr intgr intgr intgr bit add mul div mod --------- ------------- ------ ------ ------ ------ ------ raspberry Linux 3.6.11+ 1.4800 0.1500 7.4200 111.2 50.8 beaglebon Linux 3.8.13 1.0100 0.1100 6.1400 60.6 23.1 jupiter Linux 2.6.31. 0.5700 0.0100 0.3300 35.4 35.4
The integer computation engine of both embedded systems is far away from Atom with a ratio of >10 for add & mul. BeagleBone si better than raspberry, particularly on div & mod.
Basic double operations - times in nanoseconds - smaller is better ------------------------------------------------------------------ Host OS double double double double add mul div bogo --------- ------------- ------ ------ ------ ------ raspberry Linux 3.6.11+ 11.7 13.1 48.2 92.2 beaglebon Linux 3.8.13 31.0 25.3 461.2 621.9 jupiter Linux 2.6.31. 2.8000 2.8100 34.7 41.7
For Float computations, raspberry is going better with a ratio from 2 to 10 ; this stay true in case of simple float computation even if the ratio is about 3. It makes the BeagleBone really bad for floating point operations. Atom is 4 time better than RPI which is far away from the frequency ratio. The difference is architectural. [ check comment for completion, it seems, this test was invalid]
File & VM system latencies in microseconds - smaller is better ------------------------------------------------------------------------------- Host OS 0K File 10K File Mmap Prot Page 100fd Create Delete Create Delete Latency Fault Fault selct --------- ------------- ------ ------ ------ ------ ------- ----- ------- ----- raspberry Linux 3.6.11+ 129.3 97.6 332.8 145.5 3063.0 0.481 4.26960 14.6 beaglebon Linux 3.8.13 115.5 94.9 162.8 90.5 13.8K 1.050 5.51250 8.062 jupiter Linux 2.6.31. 46.9K 1.371 4.500
Access to file system works better on BeagleBone Back. It make sense as the filesystem is located on the board on flash.
*Local* Communication bandwidths in MB/s - bigger is better ----------------------------------------------------------------------------- Host OS Pipe AF TCP File Mmap Bcopy Bcopy Mem Mem UNIX reread reread (libc) (hand) read write --------- ------------- ---- ---- ---- ------ ------ ------ ------ ---- ----- raspberry Linux 3.6.11+ 103. 104. 65.7 105.0 152.3 104.4 105.1 152. 355.1 beaglebon Linux 3.8.13 345. 281. 122. 214.2 273.8 215.7 215.9 273. 1496. jupiter Linux 2.6.31. 908. 994. 507. 1560.6 4154.2 1252.0 1268.7 3484 1533.
Internal communcation bandwidth is better on BeagleBone it may be due to the memory architecture, the ratio is 2 which is over the cpu frequency difference. This is about 5 time less that on an Atom system.
Memory latencies in nanoseconds - smaller is better (WARNING - may not be correct, check graphs) ------------------------------------------------------------------------------ Host OS Mhz L1 $ L2 $ Main mem Rand mem Guesses --------- ------------- --- ---- ---- -------- -------- ------- raspberry Linux 3.6.11+ 800 6.0350 89.8 168.9 418.3 beaglebon Linux 3.8.13 994 3.0530 11.8 215.8 423.9 jupiter Linux 2.6.31. 1785 1.7070 9.1280 25.7 177.2
To finish this comparison, the latency on BeagleBone cache is really better than RPI when on main memory RPI have better results. Finally the two system are equivalent. The Ratio compared to an atom system is going from 2 to 5 making a real difference.
To conclude, RPI, BeagleBone are quite similar, I assume beaglebone is to avoid for float computations but a little bit better for all other operation. The objective was not to demonstrate these systems are not as good as Atom minipc systems which was a known fact. But it shows that we can’t do on RPIs & BeagleBone the same thing as on miniPC with same performance. The ratio is from 5 to 10 depending on usage. It’s big !
… to be continued
Very interesting post !
I find very strange the difference for float computations. I remind me that the Angstrom distribution that comes with Beaglebone Black does not use the hard float instructions (you have to use Java Soft Float version for instance).
To check that point, I have installed an ubuntu distribution (armhf version) and results are similar or better than for Raspberry Pi :
Basic double operations - times in nanoseconds - smaller is better
------------------------------------------------------------------
Host OS double double double double
add mul div bogo
--------- ------------- ------ ------ ------ ------
arm Linux 3.8.13- 8.9700 11.1 57.4 120.6
I think that the ubuntu distribution I use does not use all Beaglebone’s CPU instructions (NEON intructions for instance). For such bench, the compile options use for the OS seems to be important.
Laurent
Thank you for having made this test and complete this article, I was expecting some trouble around hard/soft float but according some search I had made I supposed it was hard float. Seems is was not !