| The PowerUP system software offers mainly three interfaces, the HAL (Hardware
                                                                                          Abstraction Layer), the ABI (Application Binary Interface) and the API (Application
                                                                                          Programming Interface). The HAL is by definition always hardware dependant.
                                                                                          It is a low level software provided by the hardware manufacturer, which
                                                                                          communicates directly with the hardware. To obtain optimal performance and
                                                                                          to utilize all hardware features, complete knowledge of the underlying hardware
                                                                                          is necessary. This is fact for our current hardware as well as any other
                                                                                          processor hardware which will be developed in future. The ABI is the next layer of system software which uses the HAL as basics.
                                                                                          It can be seen as the "physical" definition of the interface.
                                                                                          This means, the ABI is responsible for correct implementation of register
                                                                                          layouts for system calls. Different kinds of hardware using a compatible
                                                                                          HAL may use the same ABI. Our proposed ABI is compliant to the standard
                                                                                          PowerPC EABI from Motorol, which defines platform independant register layouts
                                                                                          and calling conventions. By use of standard Motorola PowerPC-EABI for our
                                                                                          HAL it is possible to use different platforms and software development systems
                                                                                          apart from the Amiga as well as standard software libraries for PowerPC
                                                                                          based systems, such as e.g. the LIBMOTO library developed by Motorola for
                                                                                          MkLinux which speeds up floating point calculations significantly, which
                                                                                          is only possible because of the built-in compatibility to EABI in our HAL
                                                                                          (this LIBMOTO library for example is included by default on the CDROM delivered
                                                                                          with the PowerUP boards). The API (Application Programmer Interface) is based on the ABI and is
                                                                                          the logical interface definition for applications, which is mainly the definition
                                                                                          of library calls of the PowerUP system software. The functionality and conventions are documented by the developer notes
                                                                                          included in the PowerUP package or available from phase 5 and will be uniform
                                                                                          for all products of the PowerUP family. Future enhancements and additions
                                                                                          to the functionality will be compatible to the current implementation of
                                                                                          the system libraries. Even main changes to the hardware, like e.g. cluster
                                                                                          based multiprocessing systems, will not require applications using our API
                                                                                          to be adapted and make them take advantage of new capabilities. Therefore
                                                                                          an application, which is compatible to our PowerUP system software and its
                                                                                          API and ABI, is prepared to be fully compatible to various hardware solutions,
                                                                                          even if provided by different vendors. Third party vendors can implement
                                                                                          full compatibility regardles of the individual functionality of the underlying
                                                                                          hardware. Concerning this matter, please also regard to our guidelines to PowerUP programming styles. Summing up it can be said that the conceptual design of our PowerUP system
                                                                                          software fulfills all requirements to implement a standardized software
                                                                                          interface for any kind of processor hardware (including multiprocessing
                                                                                          systems) and offers an optimal hardware independency. The options offered
                                                                                          by our solution are in addition based on well introduced standards, what
                                                                                          results in various benefits for users and developers from the beginning
                                                                                          (as demonstrated by the LIBMOTO example above).
                                                                                           |