First there is a problem to overcome, Linux does not provide much as an OS, so to overcome this we add some form of X implementation to the allowable spec for Linux. We could add either traditional X or a Wayland based implementation. For the best performance on Linux I would recommend the use of XCB as the interface (more direct than XLib, and as such faster).
To Be clear on GNU/Linux as an OS:
GNU/Linux is the Linux kernel with a libc version, and the GNU coreutils, to provide an operating system that is similar to Unix. This is the operating system included with many distrobutions, the distrobutions are NOT just the OS, they are the GNU/Linux OS with a lot of extras added. As such we are focusing on GNU/Linux plus the X Windowing System (any implementation of the X Windowing System). This is the OS that Raspbian, Ubuntu, Debian, TinyCore, Puppy Linux, and many others run on top of (these distros include GNU/Linux so they have an OS, they are a bunch of extras packaged with the OS).
Yes it is adding an advantage for GNU/Linux by using the X Windowing System, as X is not part of the OS.
What the challeng is:
The list below is open to change if good suggestions are made that test the Operating Systems speeds (not the speed of other libs or extensions).
Now that we have something that can be compared we need to figure out what to test, so my recommendation would be:
- Open 16 windows, with various levels of overlap, and draw 8192 each of each of the basic graphics primitives in each (line, oval, circle, rectangle, filled oval, filled circle, and filled rectangle).
- Draw text in 4 different fonts to each of the windows, with 32 character strings, 8192 times.
- Close the 16 windows.
- Repeat the above 3 steps using off screen buffered graphics.
- Open and close 16 Windows 8192 times.
- Open a 640x440 pixel window, and place a 1280x880 pixel image in the window.
- Scroll the picture in the window in each direction 8192 times.
- Do a block load of a 8MB file from disk (preferably RAM disk for good comparison).
- Do a block write of an 8MB file from disk (again preferring RAM disk).
- Do byte wise reading of 4MB of data from file, non sequential.
- Do a byte wise writing of 4MB to file, non sequential.
This would be a test that shows the actual speed of the OS in both cases. We would want to minimize the code in the test program so that the speed of the OS is the primarily what is shown, not the speed of the test program.
this is intended to help back the claim that RISC OS is fast, a claim made by many including myself.
Unfortunately RISC OS has some tricks to do things even faster than these tests can show, though there is no equivalent on GNU/Linux+X without adding a bunch of third party libs (and we are testing the speed of the OS not of third party libraries).
Also unfortunately in the case of both OS's there is no standard builtin OpenGL implementation, so testing Graphics acceleration would not say anything about either OS (though would rather speak to the implementations of OpenGL in each).
I am working on a framework to implement these tests. I am making the framework in Assembly, in order to reduce the effect of the implimentation language on the tests. Once the framework is together and posted I will fill in the rest to complete the RISC OS version of the tests.
Thereafter I will ask someone more familiar with X and Linux to implement an equivilent Linux version. If no one else wishes to do this I will do the best I can at impllimenting a Linux version.
Also I added to the list primitive drawing to off screen buffers.
Changed some of the number of itterations, to further ruduce the amount of time spent in the test code (values that can be loaded as imediates in a single MOV instruction now).
Better clarified the definition of GNU/Linux as an operating system.