Abstract:
An apparatus and a method are provided to distribute interrupts from a system bus to Intel® Architecture (IA)-32 applications processors. The apparatus includes a bridge that couples a processor bus to the system bus. In addition, the bridge is coupled to an advanced programmable interrupt controller (APIC) by an APIC bus. The bridge monitors the system bus for interrupts and converts selected interrupt transactions into APIC messages. The bridge then sends the APIC messages to the APIC bus. Each of the applications processors is also coupled to one of many APIC buses. The applications processor that is the target of the interrupt transaction receives the APIC message and executes an interrupt handler routine. The apparatus and method also incorporate interrupt transaction buffering and throttling.

Description:
TECHNICAL FIELD 
     The invention is directed to an apparatus and a method that distributes interrupts. In particular, the invention is directed to an apparatus and a method that converts interrupt transactions on a system bus into interrupt mechanisms supported by Intel® Architecture (IA-32) processors. 
     BACKGROUND ART 
     Multiprocessor computers implement varying levels of symmetry. Master-slave processor computer systems are very. asymmetric, whereas in computers designed with higher levels of symmetry, each of the working processors are capable of performing the same functions. In symmetric computers, the working processors share buses, address the same memory and basic input/output system (BIOS) resources, and receive the same array of interrupts. However, in current computer systems, no mechanism exists to distribute interrupts to an IA-32processor when mixed with an IA-64 architecture. 
     SUMMARY OF INVENTION 
     A computer system provides a mechanism to distribute interrupts from a system bus to Intel® Architecture (IA-)32 processors. The system includes a number of applications processors that are coupled together by an advanced programmable interrupt controller (APIC) bus and by an advanced processor bus. As many as four applications processors can be so coupled. A bridge couples the processor bus and the APIC bus to the system bus. The bridge translates interrupt transactions between the applications processors and the system bus. 
     The system may include any number of applications processors and bridges. A combination of up to four applications processors and a bridge forms a node. The nodes are coupled together on the system bus. Each applications processor has a unique address related to a nodeID of the processor and a further processor ID. In an improvement over current computer architectures, more than sixteen applications processors may be included in the system. 
     The system uses the above-described architecture to assert, acknowledge and process the interrupts. Interrupts are forced transfers of execution from a currently running program or task to a special program or task called an interrupt handler. Each of the applications processors may be provided with an interrupt handler in software. Each also may be provided with an APIC to process the interrupts. The applications processors can receive interrupts from other applications processors, or from external devices, such as a keyboard, for example. The source of the interrupt determines some features of the interrupt handling. 
     In an embodiment, the system uses a bridge to convert interrupt transactions on the system bus into APIC messages that are delivered to a target APIC bus. The bridge monitors the system bus and determines when a particular interrupt transaction is directed to an applications processor at the bridge&#39;s node. The bridge may acquire the interrupt transaction, convert the interrupt transaction to an APIC message and send the APIC message to the appropriate applications processor over the APIC bus. 
     For external interrupts, when the applications processor is able to receive the interrupt, the applications processor will return an interrupt acknowledge over the processor bus. The bridge then provides the interrupt acknowledge to the system bus and the device that generated the external interrupt returns the interrupt vector. With the interrupt vector, the applications processor is able to acquire the interrupt and to execute it using the interrupt handler. 
     Normal interrupts are delivered to the applications processor as APIC messages over the APIC bus. Since normal interrupts include the interrupt vector, the applications processor does not have to generate an interrupt acknowledge transaction to acquire the vector. 
     The system also incorporates advanced features of interrupt buffering and interrupt throttling. For example, a bridge may buffer interrupt transactions for an applications processor that cannot currently accept an interrupt because, for example, the applications processor is currently processing an interrupt. 
     Interrupts may originate from external programmable interrupt controllers. In this operating mode, the interrupts may be delivered as external interrupt transactions. The bridge forwards an interrupt acknowledge from the applications processor to the system bus to obtain the interrupt vector. 
    
    
     BRIEF DESCRIPTION OF DRAWINGS 
     The invention will be described with reference to the following drawings in which like numerals refer to like objects, and wherein: 
     FIG. 1 is a block diagram of a computer architecture used to distribute interrupts; 
     FIG. 2 is a block diagram of an IA-32 processor in the computer architecture of FIG. 1; and 
     FIG. 3 illustrates a mixed IA-32 and IA-64 computer architecture in which a bridge is used to distribute interrupts. 
    
    
     DISCLOSURE OF INVENTION, 
     BEST MODE FOR CARRYING OUT INVENTION, INDUSTRIAL APPLICABILITY, AND 
     DETAILED DESCRIPTION OF INVENTION 
     Multi-processor computer systems may have a mechanism for distributing interrupts to the processors. Interrupts are forced transfers of execution from a currently running program or task to a special program or task called an interrupt handler. Interrupts may occur at random times during the execution of a program, in response to signals from hardware, for example. These interrupts are used to handle events that occur external to a processor. An example is a power failure. Interrupts may also be generated by software. 
     The processors in the computer system may include an interrupt handling mechanism that allows the interrupts to be handled in a manner that is transparent to the application program that is running on the processor. When an interrupt is received, the currently running application program is automatically suspended while the processor executes an interrupt handling sequence. When execution of the interrupt is completed, the processor may return to execution of the suspended application program. The resumption of the interrupted application program happens without loss of application program continuity, unless the interrupt caused the application program to be terminated. 
     In a multi-processor environment, the computer system may address interrupts to a desired processor for execution. This may require a mechanism for locating each of the processors, transmitting the interrupts, and in some cases buffering and throttling the interrupts and receiving interrupt acknowledge signals from the processors. The interrupt mechanism is complicated when components with different architectures are used in the same computer system. 
     FIG. 1 shows a system  10  that may be used to distribute interrupts in a personal computer or server application. The system  10  includes an Intel® Architecture (IA-)32 processor system  11  coupled to system components  12  by a bridge  13 . The IA-32 processor system  11  may include one or more parallel processors  14  that perform various computing functions. The processors  14  are coupled to a common bus  15 , and may be coupled to a local advanced programmable interrupt controller (APIC) bus  18 . The processors  14  share access to the common bus  15 , and may also share other resources such as memory, input/output (I/O) devices, and interrupt handlers, for example. The system components  12  provide enhanced functionality, and can be used with the existing IA-32 processors  14 , provided that appropriate hardware and/or software is used to ensure compatibility between the IA-32 processor system  11  and the system components  12 . For example, the system components  12  may include a system bus  19  coupled to a memory controller  16  and an I/O controller  17 , all of which are designed for use with an IA-64 architecture. The resulting system  10  may require special mechanisms to distribute interrupts. The bridge  13  may be part of the special mechanism. The bridge  13  may include a buffer  20  for storing interrupt transactions and a throttling mechanism to prevent buffer overflow. To ensure optimum performance, the bridge  13  may be implemented in a VLSI, for example. 
     FIG. 2 is a block diagram of the IA-32 processor  14  used in the system  10  of FIG.  1 . The processor  14  includes a core  140  that controls processing on the processor  14 . The processor  14  may be an IA-32 processor. An APIC  141  processes local external and normal interrupts that the processor  14  may receive at its interrupt pins or at an APIC bus connection, and processes local internal interrupts that software generates. The APIC  141  may include an interrupt priority mechanism (not shown). Such an interrupt priority mechanism is well-known in the art. The APIC  141  may be referred to as a local APIC. 
     The processor  14  may include one or more pins, such as pins  143  and  144  which may be used to assert an interrupt to the processor  14 . 
     FIG. 3 shows an overall computer architecture  100  that includes IA-32 processors. System components include one or more I/O controllers  105 , which are coupled to a memory controller  107 . The I/O controllers  105  are coupled to I/O device bus  109 . The bus  109  may be peripheral computer interface (PCI) bus, for example. The bus  109  may connect standard computer peripherals such as monitors and keyboards, for example. The bus  109  may also be used to signal interrupts from external devices. The external interrupts may be delivered by a standard programmable interrupt controller (PIC) such as an Intel® 8259A PIC  13 , for example. 
     A system bus  110  connects the memory controller  107  and other components to IA-32 processors  120   i  via bridges  112   i , and processor buses  114   i . Each bridge  112   i  is coupled to one or more IA-32 processors  120   i  via a local APIC bus  130   i . 
     The IA-32 processors  120   i  and the bridges  112   i  are grouped at nodes  111   i . In FIG. 3, two IA-32 processors  120   i  are shown connected at each of the nodes  111   i . However, only one IA-32 processor  120   i , or more than two IA-32 processors  120   i  (e.g., up to four) may be connected at each of the nodes  111   i . Also in FIG. 3, sixteen IA-32 processors  120   i  are shown coupled to the system components. However, the computer architecture  100  can support more than sixteen IA-32 processors  120   i . 
     The bridge  112   i  takes the interrupts that are being delivered over the system bus  110  and signals the interrupt to the appropriate IA-32 processor  120   i . To ensure that a particular interrupt reaches the appropriate IA-32 processor  120   i , all interrupt transactions on the system bus  110  contain target node  111 , and IA-32 processor  120   i  identification. Each bridge  112   i  monitors the system bus  110  to determine if an interrupt transaction on the system bus  110  is addressed to one of the IA-32 processors  120   i  on the bridge&#39;s node  111   i . That is, when an interrupt transaction is presented on the system bus  110 , each of the bridges  112   i  examines a destination ID field in the interrupt transaction. This field contains a nodeID and a processor ID. The bridge  112   i  whose nodeID matches the nodeID of the interrupt transaction will accept and track the interrupt. 
     Software may initialize the I/O devices to transfer an interrupt transaction in a manner that encodes the identification of the IA-32 processor  120   i  to be interrupted. The bridge  112   i  that is connected to the same IA-32 bus  114   i  as the destination IA-32 processor  120   i  recognizes the interrupt transaction, converts the interrupt transaction into an APIC message, and sends the APIC message to the targeted IA-32 processor  120   i  on the APIC bus  130   i . Since more than one interrupt could be dedicated to a node, the bridge  112   i  may buffer or throttle the interrupt transactions. 
     If the interrupt is a normal interrupt, the interrupt vector is supplied with the interrupt transaction. If the interrupt is an external interrupt, the interrupt vector is not supplied. Therefore, upon receiving an APIC message for an external interrupt, the targeted IA-32 processor  120   i  generates an interrupt acknowledge transaction requesting the interrupt vector. The bridge  112   i  forwards the interrupt acknowledge transaction to the system bus  110 , which will then supply the interrupt vector, allowing the interrupt handler in the IA-32 processor  120   i  to be executed. 
     Interrupts may originate from a pair of cascaded 8259A PICs, for example. The IA-32 processor  120   i  may produce an interrupt acknowledge transaction to obtain the vector from the 8259A PIC. In an alternative method, the targeted bridge  112   i  could recognize that the interrupt transaction is for an 8259-type interrupt, directly issue the interrupt acknowledge and obtain the interrupt vector prior to issuing the APIC message on the APIC bus  130   i . In this way, the interrupt sequence on the APIC bus  130   i  is identical regardless of the type of interrupt, because the bridge  112   i  will always already have the interrupt vector. 
     Alternatively, when the targeted IA-32 processor  120   i  issues an interrupt acknowledge in response to an 8259-type interrupt, the targeted bridge  112   i  forwards the interrupt acknowledge transaction onto the system bus  110 , and returns the resulting interrupt vector to the IA-32 processor  120   i  over the IA-32 bus  114   i . 
     In the computer architecture  100  shown in FIG. 3, I/O devices may transfer interrupts as transactions on the system bus  110 . If an IA-64 architecture is used, interrupts may be delivered with a particular type of transaction on the system bus  110 . In a IA-32 architecture, interrupts may be transferred over the APIC bus  130   i . In a mixed IA-32 and IA-64 architecture, one way to distribute interrupts between the nodes  111   i  is to use the above-described interrupt mechanism, adapted to be used with the IA-32 processors. For example, to send an interrupt from an I/O device, which is not on a node, but instead is somewhere off in the system  100 , to a IA-32 processor  120   i , the interrupt may appear as an interrupt transaction on the system bus  110 . The interrupt mechanism and interrupt architecture will ensure that the interrupt is delivered to the appropriate IA-32 processor  120   i . 
     In the architecture  100  shown in FIG. 3, interrupt transactions are sent to the IA-32 processors  120   i  over the APIC buses  130   i . The APIC buses  130   i  operate at a much slower speed than the system bus  110 . The system bus  110  may provide interrupt transactions for a particular IA-32 processor  120   i  at a much faster rate than the interrupt transaction can be processed over the APIC bus  130   i . 
     Returning to FIG. 1, the interrupt architecture for the bridge  13  is shown with interrupt buffer  20 . The buffer  20  may partially overcome the above-described problem of mismatched processing speed. For example, when the bridge  13  recognizes a new interrupt transaction to the targeted IA-32 processor  14 , the previous interrupt transaction may not have been completely delivered over the APIC bus. As a result, the bridge  13  may have to buffer up interrupts occurring in that interval. 
     The above-described buffer may be used to store some of these pending interrupt transactions. However, the buffer may reach capacity with more interrupt transactions being provided from the system bus  110 . Therefore, the bridges  112   i  may also throttle interrupt transactions to avoid over filling the buffer. For example, a bridge  112   i  may monitor the state of its interrupt transaction buffer. When the buffer reaches its capacity for storing interrupt transactions, the bridge  112   i  may halt transactions on the system bus  110  by initiating a snoop stall, for example. Other throttling mechanisms may also be used in the computer architecture  100  to prevent over filling the interrupt transaction buffer. 
     One of ordinary skill in the art will recognize that the above description is that of preferred embodiments of the invention and that various changes and modifications may be made thereto without departing from the spirit and scope of the invention as defined in the following claims.