Architecting reliable software for high performance computing platforms has become a daunting task.  In today's multiprocessor (MP) systems having a large number of processors in various architectural arrangements, the task is even more challenging.  Because the teachings of the present invention will be exemplified in particular reference to MP platforms, a brief introduction thereto is set forth below. 
In the most general sense, multiprocessing may be defined as the use of multiple processors to perform computing tasks.  The term could apply to a set of networked computers in different locations, or to a single system containing several processors.  As is well known, however, the term is most often used to describe an architecture where two or more linked processors are contained in a single or partitioned enclosure.  Further, multiprocessing does not occur just because multiple processors are present.  For example, having a stack of personal computers in a rack is not multiprocessing.  Similarly, a server with one or more “standby” processors is not multiprocessing, either.  The term “multiprocessing” is typically applied, therefore, only to architectures where two or more processors are designed to work in a cooperative fashion on a task or set of tasks. 
There exist numerous variations on the basic theme of multiprocessing.  In general, these variations relate to how independently the processors operate and how the workload among these processors is distributed.  In loosely-coupled multiprocessing architectures, the processors perform related tasks but they do so as if they were standalone processors.  Each processor is typically provided with its own private memory and may have its own mass storage and input/output (I/O).  Further, each loosely-coupled processor runs its own copy of an operating system (OS), and communicates with the other processor or processors through a message-passing scheme, much like devices communicating over a local area network.  Loosely-coupled multiprocessing has been widely used in mainframes and minicomputers, but the software to do so is closely tied to the hardware design.  For this reason, among others, it has not gained the support of software vendors and is not widely used in today's high performance server systems. 
In tightly-coupled multiprocessing, on the other hand, operation of the processors is more closely integrated.  They typically share main memory, and may even have a shared cache.  The processors need not be identical to one another, and may or may not perform similar tasks.  However, they typically share other system resources such as mass storage and I/O. Additionally, instead of a separate copy of the OS for each processor, they run a single copy, with the OS handling the coordination of tasks between the processors.  The sharing of system resources makes tightly-coupled multiprocessing platforms somewhat less expensive, and it is the dominant multiprocessor architecture in the business-class servers currently deployed. 
Hardware architectures for tightly-coupled MP platforms can be further divided into two broad categories.  In symmetrical MP (SMP) systems, system resources such as memory, disk storage and I/O are shared by all the microprocessors in the system.  The workload is distributed evenly to available processors so that one does not sit idle while another is heavily loaded with a specific task.  Further, the SMP architecture is highly scalable, i.e., the performance of SMP systems increases, at least theoretically, as more processor units are added. 
In asymmetrical MP systems, tasks and resources are managed by different processor units.  For example, one processor unit may handle I/O and another may handle network OS (NOS)-related tasks.  Thus, it should be apparent that an asymmetrical MP system may not balance the workload and, accordingly, it is possible that a processor unit handling one task can be overworked while another unit sits idle. 
SMP systems are further subdivided into two types, depending on the way cache memory is implemented. “ Shared-cache” platforms, where off-chip (i.e., Level 2, or L2) cache is shared among the processors, offer lower performance in general.  In “dedicated-cache” systems, every processor unit is provided with a dedicated L2 cache, in addition to its on-chip (Level 1, or L1) cache memory.  The dedicated L2 cache arrangement accelerates processor-memory interactions in the multiprocessing environment and, moreover, facilitates higher scalability. 
As alluded to at the beginning, designing software intended for reliable cross-platform execution on numerous MP systems available nowadays has become an arduous undertaking.  Further, with ever-shrinking design/debug cycle times, software developers are continuously looking for ways to streamline the debug operations necessary to architect well-tested code, be it application software, OS software, or firmware (collectively, “applications”). 
A particular difficulty arises when a software application is afflicted with latent errors that may go largely unnoticed when it is actually executed on a machine.  For instance, a software application may involve transactions that require access to hardware and, at times, a transaction may be directed to a non-existent hardware address.  Typically, that is not a problem because the system hardware (each hardware block having a range of addresses supported by control status registers with appropriate initialization information) simply ignores the access transaction when there is no backing and continues to stay in operational mode without raising any alarm.  Instead, some undefined value may be returned to the application.  This is usually the case since the operational paradigm of high availability MP systems requires that the hardware not go off-line unless it is somehow critically impacted.  However, the application code (and the user) does not have the opportunity to realize that an improper access operation to non-existent hardware registers has been issued during the execution.  Since the hardware is not designed to catch such accesses and the software application may continue to execute based on some undefined values returned from the hardware, the dynamic behavior and reliability of the application is somewhat compromised.  In addition, the problem can be compounded by the fact that oftentimes the hardware development of a particular platform may not have advanced far enough to allow complete testing of the software code targeted for that platform.