Method of efficiently sending packets onto a network by eliminating an interrupt

Computer programs transmit information over computer networks through the use of a network driver programs. To efficiently transmit information across a network, an improved network driver program is introduced. The improved network driver program receives a pointer to a memory block containing information to be sent. The network driver program then modifies the write protection of the memory page containing the received memory block such that the memory block is write-protected. The network driver program then starts a direct memory access (DMA) operation and returns control to the original program. The DMA operation will continue while the original program continues execution. When the DMA operation is complete, the page characteristics of the received memory block will be changed back to read/write so that the memory block may be used again.

FIELD OF THE INVENTION 
The present invention pertains to the field of computer network 
communication. More particularly, the present invention discloses a method 
for efficiently sending packets from a computer program to a network 
communication driver. 
BACKGROUND OF THE INVENTION 
To increase efficiency, most computers used within an office environment 
are connected together into a computer network. The computer network 
allows the users to share information and to share computer resources 
coupled to the network such as printers, modems, and servers. 
The speed at which computer network communications is taking place is 
increasing. It is therefore important to make the routines that send and 
receive network communication packets as efficient as possible such that 
information can be transmitted as fast as possible. 
Associated with most computer communication systems are network 
communication subroutines and hardware generated events such as interrupts 
that indicate to the central processing unit (CPU) that a hardware device 
is in need of service. It is critical that network communication 
subroutines and interrupt handling routines be as efficient as possible 
such that the CPU can quickly handle network communication requests and 
return to the processing of normal computer programs. 
Today's era of sophisticated computer processors maintain a significant 
amount of task dependent state information such as cache memory buffers, 
branch target buffers (for branch prediction), and return stack buffers. 
The stored state information is best utilized if the processor performs as 
few task switches or interrupts as possible. 
SUMMARY AND OBJECTS OF THE INVENTION 
It is therefore an object of the present invention to provide a very 
efficient send-packet subroutine to send network communications packets 
out onto the computer network such that the processor may return to the 
calling program for further processing. 
It is a further objective of the present invention to eliminate any extra 
interrupt routines used for computer network communication. These and 
other objectives are achieved by the method for eliminating an interrupt 
during routine of the present invention. 
In the present invention, when a program thread needs to send a network 
communication packet, the program calls the efficient send-packet routine 
of the present invention. The send-packet routine receives a buffer 
containing data to be sent out onto the network. The send-packet routine 
immediately marks the page or pages of memory containing the received 
buffer as read-only using memory protection features provided by the 
processor. The send-packet routine then immediately calls a send-complete 
callback routine to inform the calling program that the data packet has 
been sent out onto the network. The send-packet routine then immediately 
returns back to the calling program so that it may continue processing. 
When a network driver has a chance to send the data packet, then the 
network driver transmits the data packet and changes the read-only status 
of the memory pages containing the buffer back into a read/write status. 
If the program attempts to write to the memory pages marked as read-only, 
then the program will enter an interrupt routine that either copies the 
contents of the buffer to a safe region or waits until the network driver 
sends the packet. The interrupt routine then changes the memory pages back 
to read/write and the interrupt routine returns.

DETAILED DESCRIPTION 
A method for implementing an efficient send-packet routine and eliminating 
an interrupt is disclosed. In the following description, for purposes of 
explanation, specific nomenclature is set forth to provide a thorough 
understanding of the present invention. However, it will be apparent to 
one skilled in the art that these specific details are not required in 
order to practice the present invention. For example, the present 
invention has been described with reference to the Novell Network 
Operating System Open Data-Link Interface (ODI). However, the same 
techniques can easily be applied to other Network Operating systems or any 
other network driver architecture. 
A Computer System 
FIG. 1 illustrates a typical computer system 100 that can be used to 
implement the teachings of the present invention. The computer system 100 
comprises a processor 110 and a main memory 140 for processing computer 
instructions and data. The processor 110 is coupled to a computer bus 130 
through a bus interface 120. The computer bus 130 couples the processor 
110 and main memory 140 to server Input/Output units such as long term 
storage device 150 and network interface 160. The present invention 
teaches methods and an apparatus for transferring information from an 
application program 147 to a computer network 165 using network buffers 
145. 
An Early Send-Packet Routine 
A simple method of implementing a send-packet routine is to write a 
subroutine that completely performs all the functions required to send a 
data packet out onto a computer network. FIG. 2A illustrates the program 
flow for such send-packet routine. As illustrated in FIG. 2A a normal 
program thread continues until a data packet needs to be sent. The program 
then calls the send-packet subroutine with a buffer that contains the data 
to be sent. The send-packet subroutine then executes while the main 
program thread remains suspended. The send-packet routine communicates 
directly with the network hardware and sends the information stored within 
the buffer. When the send-packet routine of FIG. 2A has completely 
completed its operation it then returns back to the original program 
thread with a return code that indicates if the packet was sent 
successfully or if an error occurred. After returning back to the original 
program the original program can continue execution. 
The send-packet routine of FIG. 2A suffers several deficiencies. Most 
notably, the send-packet routine FIG. 2A completely monopolizes the 
central processing unit such that it cannot perform any other operation 
while the network hardware is attempting to send a packet. This waste of 
computing resources needed to be remedied. 
An Improved Send-Packet Routine 
FIG. 2B illustrates an improved technique that is used to implement a 
Novell ODI Send-Packet() routine. The improved send-packet routine of FIG. 
2B operates as follows. As illustrated in FIG. 2B the normal program 
thread continues until a data packet needs to be sent. The program then 
calls the send-packet routine with a buffer that contains the data to be 
sent. The send-packet routine then copies the data from the received 
buffer into a private communication buffer. This can be performed with a 
Direct Memory Access (DMA) operation. After the data to be sent has been 
copied to a communication buffer the send-packet routine returns back to 
the original program thread such that the program can continue with its 
processing operations. The network hardware independently sends the packet 
out onto the computer network without any further need of CPU resources. 
Thus, the send-packet routine illustrated in FIG. 2B does not monopolize 
the CPU resources. 
When the network hardware has successfully sent the packet, or if the 
network hardware has determined that the packet cannot be sent, the 
results must be reported to the sending program. To report the results, 
the network hardware interrupts the program thread. This interrupt is 
caught by a network interrupt handler. If the packet was successfully 
sent, the network interrupt handler calls a send-complete callback routine 
with a result code that informs the program thread that the packet has 
been sent successfully. Otherwise, the network interrupt handler calls a 
send-complete callback routine with a result code that informs the program 
that the packet was not sent successfully. After reporting the send-packet 
results, the network interrupt handler terminates so that the original 
program threads may continue execution. 
Note that it is not necessary for all send-packet calls to generate an 
interrupt. Some implementations may only interrupt after a number of 
packets have been sent. The present invention provides the greatest 
benefit to those implementations that interrupt the processor after each 
packet has been sent. 
Although the improved send-packet routine of FIG. 2B allows the main 
program thread to continue processing as the network hardware sends the 
packet, the improved send-packet routine of FIG. 2B still suffers some 
efficiency drawbacks. Specifically the program thread must wait while the 
send-packet subroutine copies the packet data from the provided buffer 
into a private communication buffer. Furthermore, an interrupt routine 
later interrupts the main program thread when the packet is sent 
successfully. The interrupt routine calls a callback routine to notify the 
main program thread that the packet was sent. This routine takes time away 
from the main program thread. The second interrupt may disturb processor 
state values such as the contents of a memory cache or a branch target 
buffer. By disturbing this processor state information, the processor will 
not execute instructions as efficiently as it normally could. 
A Further Improved Send-Packet Routine 
FIG. 3a illustrates the program flow of the efficient send-packet routine 
of the present invention. The efficient send-packet routine of FIG. 3a 
operates as follows. First the program thread calls the send-packet 
routine with a buffer containing information to be sent. Upon receiving 
the buffer, the send-packet routine marks the pages of memory containing 
the received buffer as read-only using memory protection systems provided 
by the processor. 
After marking the pages of memory containing the received buffer as 
read-only, the send-packet routine then starts a Direct Memory Access 
operation to copy the information. Next, the send-packet routine calls the 
send-complete callback routine to inform the main program thread that the 
packet has been sent. After calling the send-complete callback routine, 
the send-packet routine returns back to the original program thread so 
that the original thread can continue processing. Thus, the send-packet 
routine of the present invention merely marks the received buffer as 
read-only, notes its location, and then returns. 
The Direct Memory Access operation can copy from the buffer containing the 
information to be sent while the main program continues its operations. 
After the buffer that was received during the send-packet routine call is 
copied with the DMA, it can be changed back to read/write by the some 
section of network software such that the original program thread can 
continue to use that buffer. For example, this may occur during subsequent 
send-packet calls such that each time the send-packet routine is called, 
the send-packet routine checks to see if there are any buffers from 
previous calls that should now be changed to read/write. In another 
embodiment, a network interrupt routine may check if there are any buffers 
from previous calls that should now be changed to read/write. 
To fully describe one embodiment of the present invention, an example with 
reference to the Intel x86 Architecture processors. To enable write 
protection on a section of memory, the x86 processor must be in protected 
mode. (CRO.PE=1) The particular write-protection mode will depend on 
whether paging is enabled. (Is CRO.PG=1?) Write protection may be enabled 
on memory segments or memory pages. Write protection on memory segments is 
possible when CRO.PE=1. To enable segment protection, the W bit set in the 
Access Rights byte of the memory segment descriptor. Write protection on 
memory pages is possible when CRO.PE=1 and CRO.PG=1. To enable page 
protection, the page table entry in the page directory must be modified. 
Specifically, the R/W bit, the U/S bit, and the WP bit must be set 
appropriately. 
In most situations, the buffer that is marked as read-only by the 
send-packet routine will not be accessed by the original program thread. 
This has been tested using diagnostic software. However, in certain rare 
situations the original program may attempt to write to the buffer that 
was provided with the send-packet routine call and subsequently marked as 
read-only. There are two methods of handling this situation. 
FIG. 3b illustrates a first method for handling a write to read-only 
buffer. In FIG. 3b, the program thread is continuing along when it 
attempts to write to read-only buffer. At this point an interrupt occurs. 
The interrupt handling routine can then stay into a wait loop until the 
network hardware sends the packet onto the network. After the network 
hardware completes the send packet operation, the interrupt routine can 
then change the read-only buffer back to read/write. The interrupt routine 
can then return back to the original program thread whereby the main 
program thread can now write to the buffer. 
FIG. 3c discloses an alternate method of handling writes to read-only 
pages. In FIG. 3c the program thread is continuing along until it attempts 
to write to a read-only buffer. When the write attempt to a read-only 
buffer occurs, the interrupt routine takes over. During the interrupt 
routine, the information within the buffer supplied during the send-packet 
call is copied into a private communication buffer. After coping the 
information, the interrupt routine marks the buffer as read/write and 
returns back to the original program thread so it may continue. In this 
situation the performance is no worse than that of the send-packet routine 
of FIG. 2B since an initial send-packet routine was executed and then 
additional interrupt is executed. Thus even in the worst case, the present 
invention is no worse then the send-packet routine of FIG. 2B. 
In a preferred embodiment, the teachings of FIG. 3b and FIG. 3c are 
combined. The hybrid routine operates as follows. When the interrupt 
routine is activated, the interrupt routine determines the stated of the 
network hardware. If the network hardware is in the process copying the 
information from the buffer, either a direct send or copying to network 
hardware memory, then the interrupt routine will simply wait until the 
operation is complete. Otherwise, if the buffer is not being actively used 
by the network hardware, then the interrupt routine will copy the 
information into a safe place. The network hardware is notified of the new 
location of the information. After copying the information, the original 
buffer is changed back to read/write and the interrupt routine ends. 
In the foregoing specification the invention has been described with 
reference to specific exemplary embodiments thereof. It will, however, be 
evident that various modifications and changes may be made thereto without 
departing from the broader spirit and scope of the invention as set forth 
in the appended claims. The specification and drawings are, accordingly, 
to be regarded in an illustrative rather than restrictive sense.