Abstract:
A method for use in a data processing system connected to a network in accordance with a data transfer protocol, the data processing system having one or more event queues for holding network events, and being capable of responding to interrupts issued in response to the presence of a network event in the data processing system by invoking a stack to cause processing in accordance with the data transfer protocol of network events on the event queues; the method comprising: deciding whether to permit the interrupts to be enabled, in dependence on the result of a determination as to the presence of current indications that the stack will be invoked by an entity in the data processing system to cause processing in accordance with the data transfer protocol of network events on the event queues.

Description:
CROSS-REFERENCE TO RELATED APPLICATIONS 
       [0001]    This application is a Continuation-In-Part of U.S. application Ser. No. 12/373,173, filed Jun. 12, 2009, which is incorporated herein by reference in its entirety. 
     
    
     BACKGROUND 
       [0002]    The present invention relates to a method and system for processing data, and in particular it relates to processing data in accordance with a data transfer protocol. 
         [0003]      FIG. 1  represents elements of a computer system capable of implementing a conventional protocol stack, such as a transmission control protocol (TCP) stack in a computer connected to a network. The computer system includes an application  101 , a socket  102  and an operating system  103  incorporating a kernel  104 . A network interface such as a network interface card (NIC)  106  is provided for interfacing between the computer system and the network. The socket  102  connects the application to a remote entity by means of a network protocol, in this example TCP/IP. The application can send and receive TCP/IP messages by opening a socket and reading and writing data to and from the socket, and the operating system causes the messages to be transported across the network via the NIC. One socket is typically provided for each network endpoint with which an application wishes to communicate. The application can invoke a system call (syscall) for transmission of data onto the network. Syscalls can be thought of as functions taking a series of arguments which cause execution of the CPU to switch to a privileged level and start executing the operating system. A given syscall will be composed of a specific list of arguments, and the combination of arguments will vary depending on the type of syscall. 
         [0004]    Syscalls made by applications in a computer system can indicate a file descriptor (sometimes called a handle), which is usually an integer number that identifies an open file within a process. A file descriptor is obtained each time a file is opened or a socket or other resource is created. File descriptors can be re-used within a computer system, but at any given time a descriptor uniquely identifies an open file or other resource within the context of a process. Thus, when a resource (such as a file) is closed down, the descriptor will be destroyed, and when another resource is subsequently opened the descriptor can be re-used to identify the new resource. Any operations which for example read from, write to or close the resource take the corresponding file descriptor as an input parameter. A system call when invoked causes the operating system to execute algorithms which are specific to the file descriptor identified in the syscall. 
         [0005]    In the context of networking, syscalls are used by applications to invoke a stack to send data, and to consume data that has been received, optionally blocking until more data arrives. In this context, a stack is a set of software and/or hardware resources that implement a collection of sockets. Other system calls are used for control plane operations such as creating and destroying sockets, connecting to remote endpoints, and querying the state of sockets. 
         [0006]    In a typical network arrangement packets arriving at a NIC are delivered into buffers in host memory, and a notification is sent, in the form of a communication to the NIC&#39;s device driver in the operating system kernel. The communication channel by which this communication is delivered typically consists of a queue of notifications that may include notifications of other types of events, including successful transmission of outgoing packets. This communication channel is referred to in the following description as an event queue. 
         [0007]    When network events are occurring in the computer system, at some point the device driver must process the event queue by inspecting each event notification and processing the received packets. It is desirable that this happen promptly, since undue delay in the processing of received packets may delay the progress of applications, or may cause the link to go idle. In conventional systems the processing of the event queue is invoked by way of an interrupt generated by the NIC at the time that the event is delivered to the event queue. 
         [0008]    An interrupt causes the CPU to save the state of whatever process is currently running, and switch control to an interrupt service routine. This routine processes the event queue, and carries out network processing for the received packets. Thus network processing is carried out in a timely manner and at high priority in response to packet arrival. 
         [0009]    A disadvantage of this mechanism is that interrupts incur high overhead due to the requirement to save and subsequently restore the state of the running process, and to interact with the hardware, and due to the impact on the memory caches in the processor. 
         [0010]    It is widely known that performance can be improved by reducing the rate at which interrupts are invoked. One means by which this can be achieved is interrupt moderation, which imposes a minimum time gap between each interrupt. This may delay the processing of received packets slightly, but it means that the overheads of an interrupt are effectively spread over a larger number of event notifications. 
         [0011]    Another means to reduce overheads due to interrupts is “Lazy Receiver Processing”, discussed at http: (slash) (slash) www.cs.rice.edu/CS/Systems/LRP/final.html in an article entitled Lazy Receiver Processing: A Network Subsystem Architecture for Server Systems by Peter Druschel and Gaurav Banga. In this model interrupts are not enabled by default. Instead any outstanding event notifications in the event queue are processed when the stack is invoked by the application via a system call. Thus received packets are processed promptly provided the application invokes the stack frequently. When the application is blocked waiting to send or receive on a socket it is not available to process the event queue. To ensure that events will still be handled at this time, interrupts are enabled and the event queue is processed in the conventional way. 
         [0012]    A problem with the Lazy Receiver Processing scheme is that if the process does not invoke the stack frequently, and is not blocked waiting for a socket, then the event queue may not get processed in a timely fashion. This can be resolved by providing a kernel thread that is able process the event queue from time-to-time as necessary, as described in the applicant&#39;s co-pending PCT application no. PCT/GB06/002202. However, this mechanism may not always be capable of implementation in a way that is both efficient and timely, partly because it involves the use of an additional thread competing with applications for CPU time. 
       SUMMARY 
       [0013]    According to a first aspect of the present invention there is provided a method for use in a data processing system connected to a network in accordance with a data transfer protocol, the data processing system having one or more event queues for holding network events, and being capable of responding to interrupts issued in response to the presence of a network event in the data processing system by invoking a stack to cause processing in accordance with the data transfer protocol of network events on the event queues; the method comprising: deciding whether to permit the interrupts to be enabled, in dependence on the result of a determination as to the presence of current indications that the stack will be invoked by an entity in the data processing system to cause processing in accordance with the data transfer protocol of network events on the event queues. 
         [0014]    According to a second aspect of the present invention there is provided a data processing system capable of connection to a network in accordance with a data transfer protocol, the data processing system having one or more event queues for holding network events, and being capable of responding to interrupts issued in response to the presence of a network event in the data processing system by invoking a stack to cause processing in accordance with the data transfer protocol of network events on the event queues; the data processing system being capable of deciding whether to permit the interrupts to be enabled, in dependence on the result of a determination as to the presence of current indications that the stack will be invoked by an entity in the data processing system to cause processing in accordance with the data transfer protocol of network events on the event queues. 
         [0015]    According to a third aspect of the present invention there is provided a computer program for use in a data processing system connected to a network in accordance with a data transfer protocol, the data processing system having one or more event queues for holding network events, and being capable of responding to interrupts issued in response to the presence of a network event in the data processing system by invoking a stack to cause processing in accordance with the data transfer protocol of network events on the event queues; the computer program being capable of deciding whether to permit the interrupts to be enabled, in dependence on the result of a determination as to the presence of current indications that the stack will be invoked by an entity in the data processing system to cause processing in accordance with the data transfer protocol of network events on the event queues. 
         [0016]    According to a fourth aspect of the present invention there is provided a data carrier bearing a computer program as set out above. 
         [0017]    A network event may comprise: (i) an indication of completion of a requested transmission of data from the data processing system; (ii) an indication of receipt at the data processing system of data from the network; or (iii) an indication of a network error. 
         [0018]    The data processing system may comprise a network interface for interfacing with the network, and the said interrupts may be issued by the network interface. 
         [0019]    The stack may be capable of being invoked directly by an application supported by the data processing system. 
         [0020]    Access to at least a part of the stack is preferably restricted by means of a lock, such that only one thread of execution may access the restricted part of the stack concurrently. The said determination may comprise checking the status of the lock to determine whether an application is currently accessing or attempting to access the restricted part of the stack. When the step of checking the status of the lock results in an indication that an application is currently accessing or attempting to access the restricted part of the stack, the said step of deciding preferably results in a decision not to permit interrupts to be enabled. 
         [0021]    The method may further comprise the step of maintaining state to indicate whether interrupts are currently enabled. The said determination may comprise the step of checking the state to determine whether interrupts are currently enabled. When the step of checking the state results in an indication that interrupts are currently enabled, the said step of deciding preferably results in a decision not to permit interrupts to be enabled. 
         [0022]    The data processing system may support application blocking, and processing in accordance with the data transfer protocol of network events in the event queues may cause waking of blocked applications associated with the network events on which the processing was performed. The said determination may comprise checking whether recent processing in accordance with the data transfer protocol of network events in the event queues caused the waking of any blocked applications. When the step of checking whether recent processing caused the waking of any blocked applications results in an indication that blocked applications were woken, the said step of deciding preferably results in a decision not to permit interrupts to be enabled. 
         [0023]    The said entity may be an application process or a routine invoked in response to an interrupt. 
         [0024]    According to a fifth aspect of the present invention there is provided a method for use in a data processing system connected by means of one or more sockets to a network in accordance with a data transfer protocol, the data processing system having one or more event queues for holding network events, each network event being associated with at least one of the sockets, and the data processing system being capable of responding to interrupts issued in response to the presence of a network event in the data processing system by invoking a stack to cause processing in accordance with the data transfer protocol of network events on the event queues, wherein such processing can cause a change in a status of one or more of the sockets, the method comprising the steps of: receiving an enquiry from an application supported by the data processing system as to the status of at least one of the sockets; in response to receiving the enquiry, determining whether the interrupts are enabled in the data processing system; and in dependence on the result of the determination, deciding whether to perform processing in accordance with the data transfer protocol of network events on the event queues. 
         [0025]    According to a sixth aspect of the present invention there is provided a data processing system capable of connection by means of one or more sockets to a network in accordance with a data transfer protocol, the data processing system having one or more event queues for holding network events, each network event being associated with at least one of the sockets, and the data processing system being capable of responding to interrupts issued in response to the presence of a network event in the data processing system by invoking a stack to cause processing in accordance with the data transfer protocol of network events on the event queues, wherein such processing can cause a change in a status of one or more of the sockets, the data processing system being further capable of: receiving an enquiry from an application supported by the data processing system as to the status of at least one of the sockets; in response to receiving the enquiry, determining whether the interrupts are enabled in the data processing system; and in dependence on the result of the determination, deciding whether to perform processing in accordance with the data transfer protocol of network events on the event queues. 
         [0026]    According to a seventh aspect of the present invention there is provided a computer program for use in a data processing system connected by means of one or more sockets to a network in accordance with a data transfer protocol, the data processing system having one or more event queues for holding network events, each network event being associated with at least one of the sockets, and the data processing system being capable of responding to interrupts issued in response to the presence of a network event in the data processing system by invoking a stack to cause processing in accordance with the data transfer protocol of network events on the event queues, wherein such processing can cause a change in a status of one or more of the sockets, the data processing system being further capable of receiving an enquiry from an application supported by the data processing system as to the status of at least one of the sockets; and the computer program being capable of: in response to receipt of the enquiry at the data processing system, determining whether the interrupts are enabled in the data processing system; and in dependence on the result of the determination, deciding whether to perform processing in accordance with the data transfer protocol of network events on the event queues. 
         [0027]    According to an eighth aspect of the present invention there is provided a data carrier bearing a computer program as set out above. 
         [0028]    The method may further comprise the step of, in response to receiving the enquiry, checking the current status of at least one of the sockets and, in dependence on the result of the check deciding whether to block the application until a change occurs in the status of at least one of the sockets. 
         [0029]    The said status is preferably an indicator of whether the at least one of the sockets is ready to receive data for transmission over the network or ready to provide to an application data received over the network. 
         [0030]    When the result of the determination is positive, the step of deciding preferably results in a decision not to perform the said processing. Conversely, when the result of the determination is negative, the step of deciding preferably results in a decision to perform the said processing. 
         [0031]    Access to at least a part of the stack is preferably restricted by means of a lock, such that only one thread of execution may access the restricted part of the stack concurrently. The step of deciding whether to perform the said processing may comprise checking the status of the lock to determine whether an application is currently accessing or attempting to access the restricted part of the stack. When the step of checking the status of the lock results in an indication that an application is currently accessing or attempting to access the restricted part of the stack, the step of deciding preferably results in a decision not to perform the said processing. 
         [0032]    The said enquiry may be an enquiry from the group comprising poll( ) select( ), epoll( ) and GetQueuedCompletionStatus calls. 
         [0033]    The method may further comprise the step of returning a response to the application indicating the status of the at least one of the sockets. 
         [0034]    The method may further comprise the step of maintaining state indicating whether interrupts are currently enabled, and the step of determining may comprise checking the said state. When the step of checking the said state results in an indication that interrupts are currently enabled, the step of deciding preferably results in a decision not to perform the said processing. 
         [0035]    The above summary of the invention is provided in order to provide a basic understanding of some aspects of the invention. This summary is not intended to identify key or critical elements of the invention or to delineate the scope of the invention. Its sole purpose is to present some concepts of the invention in a simplified form as a prelude to the more detailed description that is presented later. Particular aspects of the invention are described in the claims, specification and drawings. 
     
    
     
       DESCRIPTION OF THE DRAWINGS 
         [0036]    The present invention will now be described by way of example with reference to the accompanying drawings, in which: 
           [0037]      FIG. 1  shows a prior art computer system; 
           [0038]      FIG. 2  shows a computer system for use with embodiments of the invention; and 
           [0039]      FIG. 3  shows the path of incoming data received at a computer system. 
           [0040]      FIG. 4  is a schematic diagram of a network interface device in use. 
       
    
    
     DETAILED DESCRIPTION 
       [0041]    The following description is presented to enable any person skilled in the art to make and use the invention, and is provided in the context of a particular application and its requirements. Various modifications to the disclosed embodiments will be readily apparent to those skilled in the art, and the general principles defined herein may be applied to other embodiments and applications without departing from the spirit and scope of the present invention. Thus, the present invention is not intended to be limited to the embodiments shown, but is to be accorded the widest scope consistent with the principles and features disclosed herein. 
         [0042]      FIG. 4  is a schematic diagram showing a network interface device such as a network interface card (NIC) and the general architecture of the system in which it may be used. The network interface device  6  is connected via a data link  405  to a processing device such as computer  401 , and via a data link  414  to a data network  420 . Further network interface devices such as processing device  430  are also connected to the network, providing interfaces between the network and further processing devices such as processing device  440 . 
         [0043]    The computer  401  may, for example, be a personal computer, a server or a dedicated processing device such as a data logger or controller. In this example it comprises a processor  402 , a program store  404  and a memory  403 . The program store stores instructions defining an operating system and applications that can run on that operating system. The operating system provides means such as drivers and interface libraries by means of which applications can access peripheral hardware devices connected to the computer. Drivers and libraries that are external to the operating system may also be provided. 
         [0044]    A typical computer system  401  includes a processor subsystem (including one or more processors), a memory subsystem (including main memory, cache memory, etc.), and a variety of “peripheral devices” connected to the processor subsystem via a peripheral bus. Peripheral devices may include, for example, keyboard, mouse and display adapters, disk drives and CD-ROM drives, network interface devices, and so on. The processor subsystem communicates with the peripheral devices by reading and writing commands and information to specific addresses that have been preassigned to the devices. The addresses may be preassigned regions of a main memory address space, an I/O address space, or another kind of configuration space. Communication with peripheral devices can also take place via direct memory access (DMA), in which the peripheral devices (or another agent on the peripheral bus) transfers data directly between the memory subsystem and one of the preassigned regions of address space assigned to the peripheral devices. 
         [0045]    The exemplary system of  FIG. 2  includes a computer system which may be in accordance with the system  401  of  FIG. 4 . In such a system, items 1, 2, 3, 4, 5 and 12 execute in response to software code portions as described below. 
         [0046]    For a given stack, an event queue  1  is provided. However it is possible for one stack to manage a number of event queues. Since one stack is capable of supporting a large number of sockets  2 , it can therefore occur that a single event queue contains data relating to a number of network endpoints, and thus a single event queue can contain data relating to a number of descriptors. Each application process in the data processing system can be associated with one or more sockets if it is involved in transferring data over the network, and can use one or more stacks. 
         [0047]    As mentioned in the introduction above, data arriving from the network at the NIC  6  is delivered into memory by the NIC, and a notification event is delivered to an event queue with which the data is associated. This step is indicated as  20  in  FIG. 3 . At some subsequent time, software in the stack  5  will perform network protocol processing on each received packet. The processing of events on the event queues is referred to hereafter as “updating the stack”, since it results in any outstanding data in the event queues handled by the stack being processed. Updating the stack causes received packets to be transferred to the appropriate socket (step 21). If the data in the event queue relates to more than one socket, then it will be demultiplexed onto the appropriate sockets. 
         [0048]    When a thread wishes to receive data from a particular socket  2 , it issues a recv( ) system call. For this call to operate correctly in general it is necessary that the stack first be brought up-to-date. That is, any events in the event queue must be handled so that received packets will be processed. As a result of the recv( ) call, any received data available in the socket will be copied into a buffer supplied by the application. If there is no new received data the thread may choose to block inside the recv( ) call until data arrives. Blocking while awaiting a given condition is a well-known occurrence in data processing systems, and in the preferred embodiment it comprises the following steps: 
         [0049]    1) placing the thread in a wait-queue associated with the socket; 
         [0050]    2) optionally setting state (for example a flag) to indicate that the wait-queue should be woken when the given condition (e.g. the arrival of new data at a socket) is met; 
         [0051]    3) checking that the condition has not yet been met; 
         [0052]    4) enabling interrupts for the event queue associated with the socket; and 
         [0053]    5) putting the thread “to sleep”—the thread becomes inactive until the wait-queue is woken. 
         [0054]    When the given condition occurs, the corresponding wait-queue is signalled, and any threads waiting on the wait-queue become runnable again, i.e. they begin competing for CPU time to carry out required processing. Thus, in the present example, when processed data appears at the relevant socket of the blocking thread  1   a , the thread will be woken from its wait queue (step 22). Software in the stack  5  can be used to implement the wake-up of waiting threads. The thread  1   a  can then receive the data using a recv( ) call or similar. 
         [0055]    The above implementation of a recv( ) call is suitable for an application-driven stack. It is desirable in this case for interrupts to be enabled before the thread is put to sleep to ensure that unprocessed events are not left unprocessed for an undue length of time while the application blocks. In an interrupt-driven stack the implementation of recv( ) differs only in that it is not first necessary to bring the stack up-to-date, and step 4) is not necessary, because interrupts are always enabled. 
         [0056]    The above discussion uses the receipt of data from the network as an example. Corresponding considerations apply to the transmission of data over the network, as will be understood by a skilled person. Specifically, when a thread wishes to push data onto the network, it will first need to determine whether the relevant socket has available space in its transmit buffers so that the data can be passed by the thread to the buffers and then onto the network via the NIC. Thus, in the transmission case, a thread may block until there is sufficient space available in the socket&#39;s transmit buffers. 
         [0057]    When a process carrying out networking tasks blocks, that process can no longer invoke the stack in order to process newly arrived data. Unprocessed data may therefore build up on the event queue, and this can be inefficient and cause the link to go idle as discussed above. In embodiments of the invention, measures are taken to ensure that incoming data can be processed while the process blocks or is descheduled. Specifically, interrupts are enabled (e.g. at step 4 of the blocking scheme given above) so that as soon as a network event occurs an interrupt service routine will run to enable prompt processing of the event queue by means of the stack. 
         [0058]    However, it may not always be desirable to enable interrupts while a process is blocking because interrupts have a high overhead (as explained in the introduction) and it is possible that there may be another process capable of invoking the stack while the first process is blocking, or another blocking process may already have enabled interrupts for the same stack. In such cases, interrupts would be unnecessary and could therefore usefully be avoided. 
         [0059]    Embodiments of the present invention can permit greater efficiency by making certain determinations as to the condition of the system and accordingly reducing the use of interrupts as far as possible. A number of techniques are used in this regard: 
         [0060]    State (such as a flag) is set to indicate when interrupts are enabled. This can be queried to avoid multiple processes enabling interrupts concurrently for the same stack, which would lead to unnecessary overhead. 
         [0061]    Checks are made as to whether the lock used to protect parts of the state of the shared stack is contended. The lock is conventionally implemented to prevent multiple processes from accessing the stack concurrently. If the lock is already being held by a process, then that suggests that the process has invoked (or is likely soon to invoke) the stack and cause processing of the event queue. In such a case, it would be unnecessary for a different process to enable interrupts in respect of the stack. 
         [0062]    When a process capable of invoking the stack has just been woken from a blocked state, this is used as an indication that there is a process running, or about to be running, that will keep the stack up-to-date. Interrupts need not be enabled by another process in this situation. 
         [0063]    The use of such techniques can provide a relatively low interrupt rate, while ensuring that the stack is kept up-to-date. Keeping the stack up-to-date at all times has the advantage that there is a low overhead for select( ), poll( ) and similar calls, because if there is no backlog of unprocessed data waiting on the event queue then a response can be issued relatively rapidly to such calls. Maintaining an up-to-date stack has the further advantage of enabling efficient network connections, since sockets&#39; transmit buffers are emptied frequently, thereby enabling new data for transmission to be placed on the buffers, and incoming data is processed shortly after it arrives at the event queue so that the process for which it is intended can access it quickly. 
         [0064]    Specific implementation details according to a preferred embodiment of the invention will now be discussed. 
         [0065]    First, a modified blocking mechanism is used that only enables interrupts under certain conditions. A flag is maintained to indicate whether the lock protecting a part of the stack is currently being held, and this is queried during execution of the blocking mechanism. Specifically, step 4) of the blocking scheme described above includes the following two parts: 
         [0066]    4a) checking the condition of the stack lock; 
         [0067]    4b) only if the lock is unlocked, enabling interrupts for the event queue. 
         [0068]    It is possible that while a first application is holding the lock to the protected part of the stack, further applications may be attempting to acquire the lock. Such a situation is referred to as lock contention, and the lock may be implemented so as to comprise an indicator of whether further applications are attempting to access the lock concurrently. In the preferred embodiment this indicator is implemented as a single bit of state to represent either “contended” or “uncontended”. 
         [0069]    In the situation where a first thread of an application is holding the lock while deciding whether to enable interrupts, for example before blocking, it can be useful for that first thread to know whether another thread will take up the lock when the first thread relinquishes it and blocks. If it knows that the lock is contended then the likelihood is that the stack will be invoked by one of the threads currently contending the lock and that protocol processing will be carried out promptly while the first thread blocks. Thus, in the case where a first thread already holds the lock, step 4b) could usefully be modified as follows: 
         [0070]    4b) only if the stack lock is uncontended, enabling interrupts for the event queue. 
         [0071]    In the preferred embodiment, the routine for handling interrupts (“interrupt service routine”) is a part of the NIC driver  12  in the OS and has the following properties: 
         [0072]    It ensures that when a new event arrives at the event queue, software will be invoked to bring the stack up-to-date. The act of updating the stack may cause one or more blocking processes to be woken, for example if data in a received packet is processed and passed to the process&#39;s socket, triggering a wake-up call. 
         [0073]    It interprets such a waking of a process as an indication that there is currently no requirement for interrupts to be enabled, and accordingly does not re-enable interrupts. This is because the woken process is assumed to be seeking CPU allocation in order to invoke the stack in future, and there is therefore a process available to keep the stack up-to-date. 
         [0074]    If no processes are woken as a result of the event queue processing phase, then it re-enables interrupts to ensure that action will be taken promptly in response to the next network event. 
         [0075]    It checks the lock protecting the stack. If the lock is locked, it interprets this as an indication that there is a process currently invoking the stack. In this case it does not attempt to bring the stack up-to-date, and does not re-enable interrupts. 
         [0076]    An exemplary interrupt service routine for achieving the above features is expressed in pseudo-code below: 
         [0000]    
       
         
               
               
             
           
               
                   
                   
               
             
             
               
                   
                 nic_interrupt_service_routine(stack) { 
               
               
                   
                   do_reenable_interrupts = false; 
               
               
                   
                   if( trylock(stack) ) { 
               
               
                   
                    update_stack(stack); 
               
               
                   
                    unlock(stack); 
               
               
                   
                    if( update_stack_did_not_wake_any_threads ) 
               
               
                   
                     do_reenable_interrupts = true; 
               
               
                   
                   } 
               
               
                   
                   if( do_reenable_interrupts ) 
               
               
                   
                    enable_interrupts(stack); 
               
               
                   
                   else 
               
               
                   
                    stack-&gt;interrupts_enabled = false; 
               
               
                   
                 } 
               
               
                   
                   
               
             
          
         
       
     
         [0077]    The trylock operation in the interrupt service routine attempts to acquire the lock required for accessing the stack&#39;s event queue. If the lock is available it takes the lock, and if it is unavailable the operation returns false, and the stack is not brought up-to-date. 
         [0078]    Operating systems provide a number of APIs to allow processes to manage multiple descriptors. In the multiple descriptor case, each descriptor may identify a socket or another type of resource. The APIs are used to allow a process to determine which among a set of file/socket descriptors are “ready” for I/O (i.e. have received data ready to be consumed, or are ready to transmit). They also typically provide a means to block until at least one of them becomes ready. 
         [0079]    Certain known mechansims such as GetQueuedCompletionStatus( ) are used on Microsoft Windows systems. On Unix systems multiple sockets are managed using APIs including select( ), poll( ) and epoll( ). These APIs are implemented by the operating system kernel: when a user process invokes an API call a system call is generated, which causes the CPU to switch to privileged mode and its control is passed to the kernel. A detailed example of code implementing a poll( ) system call is given in the Appendix below. In each case a set of file/socket descriptors is provided by the process. For each type of file/socket descriptor the kernel invokes a poll hook function in the subsystem that implements the file/socket. This hook must indicate the status of the file/socket (whether or not it is “ready”) and must also link the thread to a wait-queue so that it will be woken when the file/socket becomes ready. 
         [0080]    As explained above, in order to determine whether a given one of the sockets is ready it is necessary to ensure that the stack is up-to-date. To ensure that the responsible process will be woken promptly when a socket becomes ready it is necessary to ensure the stack will be kept up-to-date, so it is necessary to enable interrupts under certain conditions. 
         [0081]    It is not possible to pass state between each invocation of the hook for each socket. This is because the API used for the hook function may be invoked concurrently by more than one thread. As a result, each socket has to be treated independently. However these operations incur significant CPU overhead if they are done on a per-socket basis. The preferred implementation of the invention is intended to minimise that overhead, especially when there are multiple sockets indicated in the set of file descriptors. A poll hook implementation for sockets is shown in terms of psuedo-code below: 
         [0000]    
       
         
               
               
             
           
               
                   
               
             
             
               
                  1 
                 socket_poll_hook(socket) { 
               
               
                  2 
                  stack = stack_of(socket); 
               
               
                  3 
                  if( interrupts_not_enabled(stack) ) { 
               
               
                  4 
                   do_enable_interrupts = true; 
               
               
                  5 
                   if( any_events_outstanding(stack) ) { 
               
               
                  6 
                    if( trylock(stack) ) { 
               
               
                  7 
                     /* The stack may not be up-to-date. The following brings 
               
               
                  8 
                     ** the stack up-to-date by processing any network 
               
               
                  9 
                     ** events. */ 
               
               
                 10 
                     update_stack(stack); 
               
               
                 11 
                     unlock(stack); 
               
               
                 12 
                     if( update_stack_woke_any_threads ) 
               
               
                 13 
                      do_enable_interrupts = false; 
               
               
                 14 
                    } 
               
               
                 15 
                    else 
               
               
                 16 
                     do_enable_interrupts = false; 
               
               
                 17 
                   } 
               
               
                 18 
                   if( do_enable_interrupts ) enable_interrupts(stack); 
               
               
                 19 
                  } 
               
               
                 20 
                  link_thread_to_wait_queue(current_thread, socket); 
               
               
                 21 
                  return readiness_of(socket); 
               
               
                 22 
                 } 
               
               
                   
               
             
          
         
       
     
         [0082]    Whenever the interrupt service routine runs and does not re-enable interrupts, the interrupt flag is cleared. By maintaining a flag in this way, quick checks can be made, for example in line  3  of the poll hook, as to whether interrupts are currently enabled. The flag can be used to efficiently implement select( ), poll( ) and epoll( ) API calls, since the poll hook is designed to update the stack only when interrupts are not enabled. This is useful because interrupts are only enabled when the stack has just been updated, so a positive determination that interrupts are enabled can be used as an indication that the stack is up-to-date. The poll hook therefore has low overhead when interrupts are enabled. 
         [0083]    The preferred implementation also takes advantage of the fact that if many sockets are being managed then they are all likely to be in the same stack. Once the hook has run a first time, running it for second and subsequent sockets tends to be very quick because the test on line  3  of the socket_poll_hook( ) is likely to fail. This helps to keep overhead down. 
         [0084]      FIG. 2  shows a series of steps summarising the various features of the preferred embodiment described above. Step 50 illustrates an API call such as poll( ) being issued from an application process  1  to cause updating of the stack. 
         [0085]    In response to the call from the application, the device driver  12  supporting the network hardware  6  invokes the stack  5  (step 52) to process events on the event queue (step 52). The stack then performs protocol processing of any events in the event queues  31 - 33  (step 53). In the preferred embodiment, events are notifications identifying incidents that have occurred in respect of the network connections of the computer system. They may include: (i) an indication that a requested transmission of a data packet over the network has been successfully completed; (ii) an indication of the arrival of data at the NIC; or (iii) an indication of a transmission or reception error (e.g. a erroneous packet received). In some implementations, such as where a user-level stack is used, it may be desirable to use additional events including timeouts and wake-ups. 
         [0086]    After the events have been processed, packets of data are passed at step 54 to the relevant socket(s)  2 . The preferred embodiment provides one socket for each network endpoint to which the computer is connected, although other implementations are possible within the scope of the invention. Similarly, the preferred embodiment uses a stack with one event queue per NIC in a system, although further stacks each with one or more event queues may be implemented if desired. 
         [0087]    Once data is placed on the sockets  2  it can be retrieved by the application at step 55 by means of an API call such as recv( ). 
         [0088]    Step 51 shows the alternative route for invoking the stack in the preferred embodiment. An interrupt is generated by the NIC and causes the CPU to save the context of the currently running process and switch to privileged mode to process the interrupt service routine implemented in the NIC driver  12 . This causes the NIC driver to invoke the stack at step 52, and steps 52 to 55 can proceed as described above. 
         [0089]    The preferred embodiment involves the generation of interrupts using an indirection. Specifically, the first event to arrive at an event queue following the enablement of interrupts causes a second event to be delivered to a particular event queue designated for interrupt triggering. The second event indicates the event queue at which the first event was received, and may be a wakeup event of type (v) mentioned above. The receipt at the designated event queue of an event of this type triggers an interrupt to be issued from the NIC to the OS, as shown in step 51 of  FIG. 2 . This indirect interrupt-triggering mechanism has the advantage that only one event queue needs to be configured for triggering interrupts, while the system as a whole can support a plurality of event queues for handling other network events. As an alternative, interrupts could be generated by the NIC directly in response to the receipt of an event at any of the event queues. 
         [0090]    It should be noted that the stack  5  shown in  FIG. 2  is accessible by the kernel in the preferred embodiment, but could alternatively or in addition be accessible directly by a user application by means of an appropriate call. User-level stacks are discussed in detail in the applicant&#39;s co-pending PCT applications WO2004/079981 and WO2005/104475. Embodiments of the invention could provide one stack for each application involved in networking tasks. 
         [0091]    It will be appreciated that modifications of the techniques described herein may be made within the scope of the invention to achieve the overall advantage of reducing overhead in a networked data processing system. Similarly, other techniques involving the intelligent use of system conditions may be conceived which also lie within the scope of the invention. 
         [0092]    It will also be understood that while TCP has been used herein as an example of a data transmission protocol, the principles of the invention are equally applicable to other protocols. 
         [0093]    While the present invention has been described in the context of fully functioning data processing systems, those of ordinary skill in the art will appreciate that the processes described herein are capable of being distributed in the form of a computer readable medium of instructions and data and that the invention applies equally regardless of the particular type of signal bearing media actually used to carry out the distribution. As used herein, a computer readable medium is one on which information can be stored and read by a computer system. Examples include a floppy disk, a hard disk drive, a RAM, a CD, a DVD, flash memory, a USB drive, and so on. The computer readable medium may store information in coded formats that are decoded for actual use in a particular data processing system. A single computer readable medium, as the term is used herein, may also include more than one physical item, such as a plurality of CD ROMs or a plurality of segments of RAM, or a combination of several different kinds of media. As used herein, the term does not include mere time varying signals in which the information is encoded in the way the signal varies over time. 
         [0094]    The applicant hereby discloses in isolation each individual feature described herein and any combination of two or more such features, to the extent that such features or combinations are capable of being carried out based on the present specification as a whole in the light of the common general knowledge of a person skilled in the art, irrespective of whether such features or combinations of features solve any problems disclosed herein, and without limitation to the scope of the claims. The applicant indicates that aspects of the present invention may consist of any such individual feature or combination of features. In view of the foregoing description it will be evident to a person skilled in the art that various modifications may be made within the scope of the invention. 
       APPENDIX 
       [0095]    The following is simplified pseudo-code for the kernel&#39;s poll( ) system call, to show how it interacts with the subsystems that implement the file objects identified by file descriptors. poll( ) is invoked with an array “pfds”, whose entries specify which file/socket descriptors the application is querying, and are also used to store the result (whether or not that file/socket is “ready”). 
         [0000]    
       
         
               
               
             
           
               
                   
                   
               
             
             
               
                   
                 poll_all(pfds) { 
               
               
                   
                  int n_ready = 0; 
               
               
                   
                  for( each pfd in pfds ) { 
               
               
                   
                   file_obj = lookup_file(current_process, pfd-&gt;fd); 
               
               
                   
                   pfd-&gt;ready = file_obj-&gt;subsystem-&gt;poll_hook(file_obj); 
               
               
                   
                   if( pfd-&gt;ready ) n_ready = n_ready + 1; 
               
               
                   
                  } 
               
               
                   
                  return n_ready; 
               
               
                   
                 } 
               
               
                   
                 poll(pfds, timeout) { 
               
               
                   
                  loop( forever ) { 
               
               
                   
                   n_ready = poll_all(pfds); 
               
               
                   
                   if( n_ready or nonblocking ) return n_ready; 
               
               
                   
                   block_thread(timeout); 
               
               
                   
                  } 
               
               
                   
                 } 
               
               
                   
                   
               
             
          
         
       
     
         [0096]    First, poll( ) calls poll_all( ) to query the subsystem that implements each file/socket to determine whether any are already ready. If any are, or if this is a non-blocking call, it returns immediately. Otherwise it blocks until the thread is woken and then calls poll_all( ) again. The thread is woken when one of the files/sockets changes state. (This will usually, but not always, correspond to one of the files/sockets becoming ready) 
         [0097]    This code is invoked by an application at user-level via a system call. The following is a highly simplified example of how a user-level application might use poll 
         [0000]    
       
         
               
               
             
           
               
                   
                   
               
             
             
               
                   
                 /* We are interested in file descriptors 1 and 3. */ 
               
               
                   
                 pfds[0]-&gt;fd = 1; 
               
               
                   
                 pfds[1]-&gt;fd = 3; 
               
               
                   
                 loop( forever ) { 
               
               
                   
                  /* Block until at least one socket is ready. */ 
               
               
                   
                  poll(pfds, timeout); 
               
               
                   
                  /* For each socket that is ready, receive some data. */ 
               
               
                   
                  for( i = 0; i &lt; len(pfds); i = i + 1 ) 
               
               
                   
                   if( pfds[i]-&gt;ready ) 
               
               
                   
                    recv(pfds[i]-&gt;fd, buffer, len(buffer)); 
               
               
                   
                 }