## AIBB test results |

## Description of tests- Emutest
- This test is basically a small CPU emulator core running an instruction set simulation. It was developed for the purpose of showing various systems' ability to emulate other platforms. All instructions and internal operations are completely software emulated.
- Sieve
- The Sieve of Erathosthenes. It uses a fairly simple algorithm to determine prime numbers within a range of numbers. This test simply times the system when implementing this algorithm.
- Dhrystone
- This test attempts to put conditions upon the system which more closely simulates a possible application program section.
- Sort
- A series of 30,000 16 bit integers is sorted from a mixed setup, and the procedure is timed.
- Matrix
- A matrix manipulation benchmark utilizing 3 50x50 integer matrices. The test is set up in such a way that a great amount of time is spent moving data, as well as performing arithmetic operations upon it. The test is an indicator of how well a processor/memory combination handles memory accesses to data and operations on such, as the test does not allow the processor to simply perform the data operations solely within it's registers.
- IMath
- Integer Math. This test performs a wide variety of integer math functions. Included among these operations are the standard functions, such as addition, subtraction, multiplication, division, and a few additional bitwise functions, such as AND, OR, and XOR.
- MemTest
- A memory block movement test, timing the efficiency of memory accesses and transfers using longword (32 bit) sizes.
- InstTest
- This test performs a series of the most common CPU instructions in a 6k loop, and times their execution. This test is basically to determine the raw speed of code execution on any given system.
- Savage
- This is a standard implementation of the Savage test, which makes nested calls to transcendental functions to create a single value. Double precision floating point operations/values are used.
- FMath
- Floating Point Math. Similar to the IMath test, with the exeception that Floating Point values and operations are utilized and no bitwise operations are performed. Single precision floating point operations/values are used here.
- FMatrix
- The FMatrix test is similar in concept to the Integer Matrix test outlined above. Again, a great deal of data movement is performed, in addition to the operations involved, which are floating point operations in this case. Double precision floating point math is used for this test.
- With the matrix operations, the results under Floating Point coprocessor equipped systems can be interesting to note, as the system is not able to keep the data within fast-access FPU registers, and thus must make frequent bus accesses for the data it needs.
- BeachBall
- The BeachBall is essentially a very math intensive operation which draws a beachball on the screen, complete with shading. The system will end up being tested in both the floating point arena, and in Chip RAM access performance, which is done through standard operating system graphics handling calls (thus will be affected by the speed of such, which in turn can be affected by ROM image remapping, etc).
- Flops
- A common rating of floating point operations, the term 'Flops' denotes Floating point operations per second. This test takes a composite of operations and reports its results.
- TranTest
- A series of transcendental functions are performed in a large loop, and timed for speed of operation. This test will tend to show the relative efficiency of a system in performing more complex mathematical functions.
- FTrace
- FTrace implements a subset of the calculating functions which are used to perform raytracing operations. Raytracing is a particularly floating point intensive art, and this test gives some indication of a system's performance in this type of operation.
- CplxTest
- This test implements a series of complex-number operations and times their execution. This test utilizes a lot of quick, small memory moves, as well as performing a variety of floating point operations.
- WritePixel
- The WritePixel benchmark will open a screen/window combination and fill it completely with a given color pattern. The work is done one pixel at a time, utilizing operating system routines.
- The test is basically a benchmark of the time needed to call these routines, and for them to execute. For the most part, it is primarily useful for evaluating the effective ROM image access time, and it can also give a hint as to the efficiency of a system's Chip RAM bus interface.
- EllipseTest
- This is a test of an applied graphics operation. The test draws a series of filled, antialiased ellipses and times the operation.
- TGTest
- Text/graphics test. This test is another one which is dependent upon the efficiency of the system graphics routines' execution speed, as well as the efficiency of the Chip RAM bus interface on the system.
- LineTest
- A test of line drawing primitives. LineTest opens a screen/window combination and draws a series of lines throughout them. The lines are drawn in horizontal, vertical, and diagonal fashion, with emphasis being on the former two.
Note: graphics card performance depends on the type and version of RTG software; floating point performance depends on the version and type of math libraries and the use of programs like Oxypatcher, CyberPatcher, etc. |