Applications of ICIs
In the broadest definition, an ICI is a list of user-defined data items that can be associated with an event. This capability allows information to be transferred from the context where an event is generated to the context where it later occurs. The two contexts may be distinct modules within the same node or in separate nodes, or the two contexts may be the same module executing two separate events at different times. Therefore, an ICI can be viewed as playing a role in a communication mechanism between contexts, where an event provides the active notification, and the ICI provides the data “payload” that is transferred.
For certain types of events that normally carry little or no user-defined information, ICIs provide an important enhancement in data transfer capability. These event types include:
- self – the only information inherently associated with this type of event is an integer code specified at the time that the KP
op_intrpt_schedule_self()is called. However, because the event occurs at the same process that generates it, it is possible to store information in state variables for later retrieval. - remote, process, and multicast – like the self interrupt, only an integer code is provided. In addition, state variables cannot be used because the destination process is different than the source process.
- access – no accompanying information is directly provided with this type of event.
- statistic – one floating point value may be conveyed with this type of interrupt.
Because the ICI mechanism is not specific to any particular event type, it can be used in cases involving any of the above event types to transfer general amounts of user-defined data between contexts.
ICIs are also commonly used with stream events, even though such events inherently convey packets which can contain general, user-defined information. The purpose generally served by an ICI in such cases is to associate additional parameters with a packet transfer while avoiding the use of the packet itself to contain these parameter values. A common reason for avoiding the use of the packet to carry such parameters is that the packet’s format would then depart from an actual specification. This situation typically arises when a packet-based interface models a service that operates on packets in a manner that is affected by associated parameters; for instance, a packet may be submitted by a higher layer protocol to the next service layer which may require the designation of service class and destination.