US20070064694A1 - System and method for connecting a logic circuit simulation to a network - Google Patents

Abstract

A system and method for connecting a running logic circuit simulation to a network running at a higher speed that includes a computer for receiving data packets from the network and storing the received data packets in a first buffer. The computer next transmits the received data packets to an electronic circuit in the logic circuit simulation at a slower speed. The computer also receives data packets from the electronic device under simulation, and stores the data packets received from the electronic device under simulation in a second buffer. The computer then transmits the data packets received from the electronic device under simulation to the network at a higher speed.

Description

CROSS-REFERENCE TO RELATED PATENT APPLICATION
• The present application is a continuation-in-part application of copending U.S. patent application, entitled “METHOD FOR CONNECTING A HARDWARE EMULATOR TO A NETWORK,” Ser. No. 09/751,573, filed on Dec. 28, 2000.
BACKGROUND OF THE INVENTION
• Prior to reducing an integrated circuit design to a form suitable for fabrication, the integrated circuit design is often simulated in software on a computer, and emulated in hardware to allow the design to be optimized and debugged. Typically, using a hardware description language (e.g., VHDL), the circuit designer prepares a hardware description of the integrated circuit, which is then compiled into a software model to be simulated on a computer (e.g., an engineering workstation). Often, the hardware description can also be compiled into a hardware model that can be emulated in a hardware emulator. A hardware emulator suitable for such use typically includes field programmable gate arrays (FPGAs) that serve as a breadboard for implementing the integrated circuit design. Both the simulation and the emulator typically run at a slower speed than a computer network (e.g., an Ethernet network).
• When an integrated circuit that has a computer network interface is simulated or emulated, network activities are usually simulated or emulated at the speed of the circuit emulator or the circuit simulation. When using a circuit emulator, a conventional network-emulation device is typically connected to a port of the circuit emulator. The circuit emulator receives data packets from the network-emulation device, re-packages the data and transmits the re-packaged data back at the speed of the circuit emulator. The re-packaged data is then received by the network-emulation device, which inspects the re-packaged data to determine if the integrated circuit under emulation in the circuit emulator correctly sends and receives data packets. However, on balance, such a conventional network-emulation device does not emulate network behavior accurately and correctly.
• Alternatively, another conventional technique for connecting a circuit emulator to the network requires slowing down the network, receiving signals from the slowed network and translating the signals into suitable electrical signals in the form that the circuit emulator can accept. The circuit emulator, which typically operates at a slower speed than the network, can also send packets to the slowed network. However, because the network is designed to operate at a different speed, timing issues may arise in such a slowed network. These timing issues may require further modification to the network to resolve. Such modifications are undesirable because the modified network may not adequately represent network characteristics. Because not all network devices can be slowed to the circuit emulator speed, the circuit emulator is typically also limited to communication with a small subset of devices on the network.
• Shortcomings of an emulation are typically also present in a logic circuit simulation.
SUMMARY OF THE INVENTION
• The present invention allows a logic circuit simulator (“circuit simulation”) running on a host processor to connect to a computer network at full network speed. The present invention provides a method and an apparatus for transferring data packets between a circuit simulation and the network. In one embodiment, an interface software program also installed on a host computer (e.g., a personal computer) is provided to handle communication between the network and the circuit simulator. The network can be, for example, an Ethernet network.
• According to the present invention, data packets addressed to a device under simulation, or alternatively, addressed to a workstation connected to the network through the circuit simulation, is received and stored in buffers of the host computer. (In one example, a workstation is connected to a network through a simulated network interface.) The interface software in the host computer repackages the data packet into a second format for transmission to the simulated device at the speed of the circuit simulation. Under this arrangement, the interface software in the host computer need not send to the circuit simulation, for example, the preamble required to synchronize the clocks of the network and the circuit simulation, because the circuit simulation is usually not capable of providing an analog interface required to respond to the preamble. Similarly, the interface software in the host computer repackages the data packets received from the circuit simulation into proper format for transmission to the network at full network speed. Under this arrangement, the existing memory in the host computer is used to buffer data packets communicated between the circuit simulation and the network, so that data packets received from the network at network speed are transmitted to the circuit simulation at a slower speed, and data packets received from the circuit simulation at the slower speed is provided to the network at full network speed.
• In one embodiment, the present invention allows the interface software of a host computer to individually examine a data packet of a conventional off-the-shelf interface card to identify the beginning and the end of the packet. When the beginning and the end of a data packet can be identified, the interface software of the host computer ignores data packets not addressed to the simulated circuit. Consequently, compared to the prior art, a much smaller amount of buffer memory is required. This arrangement loses data packets only in the occasional event of a buffer overflow, thus effectively preventing network connection loss.
• In one embodiment, the interface software of the host computer is implemented as a multithreaded program having, in one instance, two executing threads. One thread is a task that receives data packets from the network interface card, stores the received data packets in a buffer, retrieves the stored data for repackaging, and sends the repackaged data over a simulation interface to the circuit simulation. Another thread is a task that receives packets from the simulation interface, repackages the data into a network data packet and sends the network data packet over the network interface card to the network.
• In another embodiment, the interface software of the host computer is implemented as a multithread program including four executing threads. One thread is a task that receives data packets from the network, and stores the received data packets in a buffer. A second thread is a task that polls the buffer for the received data packets. This second thread repackages the data packets and sends the repackaged packets over the simulation interface to the circuit simulation. A third thread is a task that receives data packets from the circuit simulation over the simulation interface and stores the received packets in a second buffer. A fourth thread is a task that polls the second buffer for the data packets received from the circuit simulation. This fourth thread repackages these data packets and sends the repackaged packets over the network interface to the network.
• In yet another embodiment, the interface software of the host computer is also implemented as a multithread program, as in the previous embodiment, except that the second buffer is eliminated and the third and fourth tasks are combined into a single task executing as a single thread. In this embodiment, the single task receives data packets from the simulation interface from the circuit simulation, repackages the data packets received and sends the repackaged packets over the network interface to the network. This approach is possible because a circuit simulation runs at a much slower speed than the network, such that a data packet received from the circuit simulation can be repackaged and sent to the network before the next data packet's arrival from the circuit simulation.
• Further features and advantages of various embodiments of the invention are described in the detailed description below, which is given by way of example only.
BRIEF DESCRIPTION OF THE DRAWINGS
• FIG. 1 shows a configuration includingfirst workstation10,second workstation20,host computer30 andcircuit emulator12, in accordance with the present invention.
• FIG. 2 is a block diagram showing one configuration ofcircuit emulator12, during an emulation of a network interface card.
• FIG. 3 is a block diagram300 showing the functions performed by Molassesprogram50, in accordance with one embodiment of the present invention.
• FIG. 4 shows a user interface Mainscreen80 in Molassesprogram50.
• FIG. 5 shows a test setup suitable for a self-test in Molassesprogram50, involving three personal computers (PC)
• FIG. 6 is a block diagram600 showing the functions performed by Molassesprogram40, in accordance with a second embodiment of the present invention.
• FIG. 7 is a block diagram700 showing the functions performed by Molassesprogram750, in accordance with a third embodiment of the present invention.
• FIG. 8 is a block diagram800 showing the functions performed by Molasses program850, in accordance with a fourth embodiment of the present invention.
• FIG. 9 shows a configuration includingfirst workstation920 andhost computer930.
• In the following detailed description, to simplify the description, like elements are provided like reference numerals.
DETAILED DESCRIPTION
• The present invention is illustrated in the following using first, as an example, an emulation of a network interface device. At a latter part of this description, the present invention is illustrated, by way of another example, a simulation of a network interface device.FIG. 1 shows a configuration includingfirst workstation10,second workstation20,host computer30 andcircuit emulator12. In this embodiment, a network interface card is emulated incircuit emulator12, which interfaces withfirst workstation10 over a conventional internal bus (e.g., a PCI bus). The network interface card emulated is intended to operate as a network interface of a workstation, such asworkstation10. However,circuit emulator12 does not operate at the full network speed the network interface card is intended.Circuit emulator12 is connected tohost computer30 overbidirectional interface22, such as a conventional personal computer (PC) parallel port.Host computer30 runs an interface program “Molasses” which is discussed in further detail below in conjunction withFIG. 4.Host computer30 connects to conventional computer network24 (e.g., 10BaseT Ethernet over twisted pair) using a conventional network interface.Workstation20 communicates withhost computer30 overcomputer network24 using conventional network protocols.Host computer30 can be, for example, a desktop PC running Windows 95 or Windows 98 and equipped with a 10baseT Ethernet controller card and two parallel ports. A proprietary parallel port interface can be used for faster transfer speeds or easier connection tocircuit emulator12. In one embodiment,host computer30 includes an Intel Pentium class processor and is equipped with 32 Mbytes of DRAM and 500 Mbytes of hard disk space.Host computer30 also includes Media Access Controller (“MAC”) drivers, parallel port drivers and the NDIS API (Network Driver Interface Specification—Application Program Interface). MAC drivers interface the operating system to the Ethernet card hardware. The parallel port drivers allow the operating system to interact with the parallel port hardware, and the NDIS API allows functional enhancements to network drivers in the operating system.Host computer30 also includes a Graphical Users Interface (“GUI”) and a packet capture, buffering and transmission application program as part of the “Molasses” program, which will be described in further detail later.Workstations10 and20 can each be any conventional workstation, including a PC running the Windows 98 operating system.
• Alternatively, the network interface card can also be simulated in a circuit simulation running onhost computer30.Host computer30 also runs a version of the interface program “Molasses” (e.g.,Molasses program750 or850) which is discussed in further detail below in conjunction withFIG. 7 orFIG. 8.
• FIG. 2 is a block diagram of one configuration ofcircuit emulator12 during an emulation of the network interface card. As shown inFIG. 2,circuit emulator12 provideslogic circuit18 that couples circuit emulator12's circuit tobi-directional interface22, an emulatedEthernet MAC26,interface23 tointernal bus21, andlogic circuit27, which is the remainder of the emulated network interface card.Cable assemblies19A and19B connect the input terminals and the output terminals (“I/O terminals”) ofEthernet MAC26 andlogic circuit18.Logic circuit18 translates the signals of Ethernet MAC26 (communicated overcable assemblies19A) into the signals ofbi-directional interface22 for transmitting tohost computer30. In one embodiment,computer network24 includes a conventional hub providing 10baseT connections. Alternatively,computer network24 can also include a switch, which selectively transmits data packet based on destination addresses. Use of a switch can reduce packet traffic at a particular connection, and thus reduce the buffer requirements at the connected devices (e.g., host computer30). Providing a switch athost computer30's connection tocomputer network24 also simplifies theMolasses program50 running onhost computer30. In this configuration, emulator12's connection toworkstation10 overinternal bus21 allows examination of signals inlogic circuits18 and27 for debugging purpose.
• FIG. 3 is a block diagram300 showing the functions performed byMolasses program50, in accordance with one embodiment of the present invention.Molasses program50 includes a graphical user interface illustrated inFIG. 4 byMainscreen80. As shown inFIG. 4,Mainscreen80 allows the user to specify an Ethernet NIC (act82) and a port address forbidirectional interface22 connected to emulator12 (act84).Status line92 displays continuously information about packets being processed byMolasses program50. The amount of information to be shown onstatus line92 can be selected usingverbose mode option86 andsilent mode option88. The user can also specify a log file (act90) to record information such as the value of each byte in each data packet, a count or the nature of errors that occur, or comments that the user may wish to add. The log file can be used for future reference and debugging purposes.
• Referring back toFIG. 3,Molasses program50 interfaces with network interface card (NIC)74, which provideshost computer30's access tocomputer network24, andinterface72, which coupleshost computer30 throughbidirectional interface22 tocircuit emulator12. In this embodiment,interface72 can be a conventional parallel port operating under the conventional EPP standard. Once the parameters ofMainscreen80 are set,Mainscreen80 calls “W32N_MolassesStart”routine52.Routine52 creates simultaneous threads running “W32N_MolassesBuffer” routine54 and “PORT32_MolassesBuffer” routine56, respectively.W32N_MolassesBuffer routine54 receives packets from the Ethernet NIC74 (via a W32N_PacketRead routine58), stores the received packets into receive buffer60 (“RPacketPack0”) inhost computer30's main memory. Subsequently, the received packets inbuffer60 are transferred to transmit buffer62 (“XPacketPack1”), from which they are then transmitted to interface72 via “PORT32_PacketSend”routine64.PORT32_MolassesBuffer routine56 receives packets from interface72 (via “PORT32_PacketRead” routine66), stores the packets into receive buffer68 (“RPacketPack1”). Subsequently, routine56 then transfers the data packets inbuffer68 to a transmit buffer70 (“XPacketPack0”), which are then transmitted to theEthernet NIC74 via “W32N_PacketSend”routine76.Molasses program50 converts data packet formats, when necessary. For example, the preamble that is used in a packet for synchronizing the clock signals of the network and the emulated device is removed before being forwarded tocircuit emulator12 overinterface72.
• Mainscreen80 calls “W32N_MolassesStop” routine94 to terminate execution of boththreads54 and56.
• FIG. 6 is a block diagram600 showing the functions performed byMolasses program40, in accordance with a second embodiment of the present invention. As inMolasses program50 ofFIG. 3,Molasses program40 ofFIG. 6 interfaces withnetwork interface74, which provideshost computer30's access tocomputer network24, andinterface72, which coupleshost computer30 tobidirectional interface22 tocircuit emulator12.Interface72 can be implemented by a conventional parallel port operating under, for example, the EPP standard. Once the parameters of Mainscreen80 (FIG. 4) are set,Mainscreen80 calls “W32N_MolassesStart” routine52, which creates fourthreads120,122,124 and126.Thread120 executes “W32_PacketRead” routine58, which receives data packets fromEthernet NIC74 and stores the received data packet into sharedbuffer128 in the main memory of thehost computer30.Thread122 executes “Port32_PacketSend” routine64, which polls sharedbuffer128 for the received data packets, repackages these data packets and sends them tocircuit emulator12 over emulation interface (parallel port)72.Thread124 executes “Port32_PacketRead” routine66, which receives data packets fromcircuit emulator12 overparallel port72 and stores the received data packet into sharedbuffer130.Thread126 executes a “W32N_PacketSend” routine76, which polls sharedbuffer130 for data packets, repackages the data packets and sends them intonetwork24 overEthernet NIC74.
• Becausecircuit emulator12 typically runs at a speed much slower than devices onnetwork24, an alternative embodiment combinesthreads124 and126 and eliminates sharedbuffer130, taking advantage that W32N_PacketSend routine76 can complete repackaging and sending out a data packet to network24 before arrival of the next data packet fromcircuit emulator12 overparallel port72.
• Mainscreen80 calls “W32N_MolassesStop” routine94 to terminate execution of boththreads120,122,124 and126.
• The size of each ofbuffers60,62,68 and70,128 and130 can be changed dynamically. Even then, a buffer overflow condition can occasionally occur, resulting in data packets being discarded. Typically, discarding an incomplete packet risks losing a network connection. However, there is no risk of losing a network connection under the present invention, because only whole packets are discarded.
• As mentioned above, the present invention is also applicable to a circuit simulation of the network interface device.FIG. 9 shows a configuration includingfirst workstation920 andhost computer930. In this embodiment, a network interface card is simulated in a circuit simulation program running onhost computer930. Circuit simulation does not operate at the full network speed the network interface card is intended.Host computer930 runs the interface program “Molasses” concurrently with the circuit simulation program.Host computer930 connects to conventional computer network924 (e.g., 10BaseT Ethernet over twisted pair) using a conventional network interface.Workstation920 communicates withhost computer930 overcomputer network924 using conventional network protocols.Host computer930 can be, for example, a desktop PC running Windows 95 or Windows 98 and equipped with a 10baseT Ethernet controller card. In one embodiment,host computer930 includes an Intel Pentium class processor and is equipped with 32 Mbytes of DRAM and 500 Mbytes of hard disk space.Host computer930 also includes Media Access Controller (“MAC”) drivers, parallel port drivers and the NDIS API (Network Driver Interface Specification—Application Program Interface). MAC drivers interface the operating system to the Ethernet card hardware. The NDIS API allows functional enhancements to network drivers in the operating system. A programming language interface (PLI) supported by the circuit simulation program allows the circuit simulation program to interact with the Molasses software.Workstation920 can each be any conventional workstation, including a PC running the Windows 98 operating system.
• FIG. 7 is a block diagram700 showing the functions performed byMolasses program750, in accordance with a third embodiment of the present invention that can be implemented in the configuration ofFIG. 9Molasses program750 can include a graphical user interface similar to that illustrated inFIG. 4 byMainscreen80. As inMolasses program50,Molasses program750 interfaces with network interface card (NIC)74, which provideshost computer930's access tocomputer network24, andsimulation interface772, which provides a program interface inhost computer930 to a circuit simulation running onhost computer930 concurrently withMolasses program50. In this embodiment,simulation interface772 can be a conventional programming language interface (PLI), an interprocess communication mechanism (e.g., a socket), a client-server type interface, or any other suitable software interface. For example, hardware description languages, such as Verilog or VHDL, provide support for programming interfaces. In particular, under Verilog, which is standardized by the Institute of Electrical and Electronics Engineers (IEEE), defines a PLI interface through which a compiled C Language program can communicate with a running circuit simulation.
• Once the parameters ofMainscreen80 are set,Mainscreen80 calls “W32N_MolassesStart”routine752.Routine752 creates simultaneous threads running “W32N_MolassesBuffer” routine754 and “SIM_MolassesBuffer” routine756, respectively. As in W32N_MolassesBuffer routine54 discussed above, W32N_MolassesBuffer routine754 receives packets from the Ethernet NIC74 (via the same W32N_PacketRead routine58 discussed above), stores the received packets into receivebuffer60 inhost computer930's main memory. Subsequently, the received packets inbuffer60 are transferred to transmitbuffer62, from which they are then transmitted tosimulation PLI772 via “SIM_PacketSend”routine764. SIM_MolassesBuffer routine756 receives packets from simulation PLI772 (via “SIM_PacketRead” routine766), stores the packets into receivebuffer68. Subsequently, routine56 then transfers the data packets inbuffer68 to a transmitbuffer70, which are then transmitted to theEthernet NIC74 via “W32N_PacketSend”routine76. As inMolasses program50 above,Molasses program750 converts data packet formats, when necessary. For example, the preamble that is used in a packet for synchronizing the clock signals of the network and the emulated device is removed before being forwarded to the circuit simulation oversimulation PLI772.Mainscreen80 calls “W32N_MolassesStop” routine794 to terminate execution of boththreads754 and756.
• FIG. 8 is a block diagram800 showing the functions performed byMolasses program840, in accordance with a fourth embodiment of the present invention that can also be implemented in the configuration ofFIG. 9. As inMolasses program750 ofFIG. 7,Molasses program840 ofFIG. 8 interfaces withnetwork interface74, which provideshost computer930's access tocomputer network24, andsimulation PLI772, which coupleshost computer930 to the running circuit simulation. Once the parameters of Mainscreen80 (FIG. 4) are set,Mainscreen80 calls “W32N_MolassesStart” routine852, which creates fourthreads820,822,824 and826.Thread820 executes “W32_PacketRead” routine58, which receives data packets fromEthernet NIC74 and stores the received data packet into sharedbuffer128 in the main memory of thehost computer930.Thread822 executes “SIM_PacketSend” routine864, which polls sharedbuffer128 for the received data packets, repackages these data packets and sends them to the running circuit simulation oversimulation PLI772.Thread824 executes “SIM_PacketRead” routine866, which receives data packets from the running circuit simulation oversimulation PLI772 and stores the received data packet into sharedbuffer130.Thread826 executes a “W32N_PacketSend” routine76, which polls sharedbuffer130 for data packets, repackages the data packets and sends them intonetwork24 overEthernet NIC74.
• As incircuit emulator12, because a circuit simulation typically runs at a speed much slower than devices onnetwork24, an alternative embodiment combinesthreads824 and826 and eliminates sharedbuffer130, taking advantage that W32N_PacketSend routine76 can complete repackaging and sending out a data packet to network24 before arrival of the next data packet from thecircuit simulation emulator12 oversimulation PLI772.
• Mainscreen80 calls “W32N_MolassesStop” routine894 to terminate execution ofthreads820,822,824 and826.
• Molasses programs50,40,750 and840 each include a test program for self-test.FIG. 5 shows a test setup suitable for use with the self-test involving PCs501,502 and503. For brevity, this test program is described with respect toMolasses program50. Description herein regardingMolasses program50 is equally applicable toMolasses program40. The test program has two modes of operation—“initiate” and “respond”.PC502runs Molasses program50, configured to address two Ethernet network interface cards, rather than the bi-directional interface, as inFIG. 1.PC501 runs the test software in initiate mode, generating and sending Ethernet packets of varying size toPC502 via local area network504 (e.g., Ethernet with 10BaseT connections) atstep521. Atstep522,Molasses program50 ofPC502 receives the packets fromPC501 using one of its two network interface cards, and then forwards the received packets toPC503 overnetwork505, which is coupled to the other one of its network interface cards.PC503 runs the test software in respond mode, taking each packet received from PC502 (step523) and re-transmitting it back toPC502 over local area network505 (step524). Atstep525, Molasses software ofPC502 then forwards the received packet fromPC503 toPC501 overlocal area network504. There, atstep526, under initiate mode, the test software onPC501 compares the returned packet to the packet it transmitted atstep521. Any mismatch of these packets is reported as an error. In one embodiment, a timer can be set in 1/18-second increments to specify the frequency of packet generation in PC102.
• A user interface is provided by the test program to self-test Molasses program50. The user interface displays an appropriate amount of information, based on a user's selection of silent mode or verbose mode. Through this user interface, a user can vary a packet throughput rate, effectuate an overflow condition in any ofbuffers60,62,68,70,128 and130, or test for timing and throughput problems. A status line is provided in the user interface to continuously update information about packets processed byMolasses program50, such as the number of packets sent and received, the current value of the timer, an error count, and other status information desired. In addition, a log file can be specified to record the value of each byte of each packet, errors that occurred, and comments that the user may wish to add using a comment line in the user interface. The recorded information may be used for future reference and debugging.
• The test program also provides a test for accessingcircuit emulator12 through a bidirectional interface (e.g., a parallel port). In one embodiment, an industry standard parallel port conforming to the enhanced parallel port (EPP) standard is provided. The test program allows a user to read and write 8-bit addresses and 8-bit data patterns via the parallel port tocircuit emulator12. In one test, data is continuously written to and read back fromcircuit emulator12 and compared. Any mismatch between the written data and the read back data is reported as an error.
• Various modifications and adaptations of the operations described here would be apparent to those skilled in the art based on the above disclosure. Many variations and modifications within the scope of the present invention are therefore possible. The present invention is set forth by the following claims.

Claims (45)

1-24. (canceled)

25. A method for simulating an electronic device that interacts with a network, the simulation being carried out by a program executing in a host computer, the simulation includes simulating the electronic device's interaction with the network, the method comprising executing instructions on the host computer for:

(a) receiving data packets designating the electronic device as recipient from the network through a network interface; and

(b) transmitting the data packets to the simulation through a software interface to provide data packets for simulating the electronic device's interaction with the network.

26. The method ofclaim 25, the instructions further comprising instructions for storing the data packets received from the network in a buffer allocated in the memory of the host computer.

27. The method ofclaim 26, the instructions further comprising instructions for changing the size of the buffer at run time.

28. The method ofclaim 26, the instructions further comprising instructions to cause to be discarded packets of data when the buffer is full.

29. The method ofclaim 26, the instructions further comprising instructions for keeping a record of the data packets received from the network.

30. The method ofclaim 29, the instructions further comprising instructions for displaying the record.

31. The method ofclaim 29, the instructions further comprising instructions for storing the record in a file.

32. The method ofclaim 25, the instructions further comprising instructions for recording the throughput of the data packets.

33. The method ofclaim 25, the instructions further comprising instructions for modifying the packets to make the packets suitable for receipt by the simulation.

34. The method ofclaim 33, wherein modifying includes removing a preamble from a data packet.

35. The method ofclaim 25, wherein the instructions for receiving data packets from the network, and the instructions for transmitting the data packets to the simulation are executed in a single thread.

36. The method ofclaim 25, wherein the instructions for receiving data packets from the network is executed in a first thread, and the instructions for transmitting the data packets to the simulation is executed in a second thread.

37. A method for simulating an electronic device that interacts with a network, the simulation of the electronic device being carried out by a program executing in a host computer, the simulation including simulating the electronic device's interaction with the network, the method comprising executing on the host computer instructions for:

(a) receiving data packets designating the electronic device as a source through a software interface from the simulation of the electronic device's interaction with the network; and

(b) transmitting the data packets to the network through a network interface.

38. The method ofclaim 37, the instructions further comprising instructions for storing the data packets received from the simulation in a buffer allocated in the memory of the host computer.

39. The method ofclaim 38, the instructions further comprising instructions for changing the size of the buffer at run time.

40. The method ofclaim 38, the instructions further comprising instructions to cause to be discarded packets of data when the buffer is full.

41. The method ofclaim 37, the instructions further comprising instruction for keeping a record of the data packets received from the simulation.

42. The method ofclaim 41, the instructions further comprising instructions for displaying the record.

43. The method ofclaim 41, the instructions further comprising instructions for storing the record in a file.

44. The method ofclaim 37, the instructions further comprising instructions for recording the throughput of the data packets.

45. The method ofclaim 37, the instructions further comprising instructions for modifying the data packets to make the packets suitable for receipt by the network.

46. The method ofclaim 45, wherein modifying includes inserting a preamble in a data packet.

47. The method ofclaim 37, wherein the instructions for receiving data packets from the simulation and the instructions for transmitting the data packets received from the simulation to the network are executed in a single thread.

48. The method ofclaim 37, wherein the receiving data packets from the simulation is executed in a first thread and the transmitting the data packets to the network is executed in a second thread.

49. A computer-readable medium for use in a simulation of an electronic device, wherein the simulation is to be carried out by a program executing in a host computer, and wherein the simulation of the electronic device includes simulating the electronic device's interaction with the network; the computer-readable medium comprising computer-executable instructions to be executed on the host computer for:

(a) receiving data packets designating the electronic device as a recipient from the network through a network interface; and

(b) transmitting the data packets to the simulation through a software interface to provide data packets for simulating the electronic device's interaction with the network.

50. The computer-readable medium ofclaim 49, further comprising computer instructions for storing the data packets received from the network in a buffer allocated in the memory of the host computer.

51. The computer-readable medium ofclaim 50, further comprising computer-executable instructions for changing the size of the buffer at run time.

52. The computer-readable of mediumclaim 50, further comprising computer-executable instructions for discarding packets of data when the buffer is full.

53. The computer-readable medium ofclaim 49, further comprising computer instructions for keeping a record of the data packets.

54. The computer-readable medium ofclaim 53, further comprising computer-executable instructions for displaying the record.

55. The computer-readable medium ofclaim 53, further comprising computer-executable instructions for storing the record in the storage medium.

56. The computer-readable medium ofclaim 49, further comprising computer-executable instructions for recording the throughput of the data packets.

57. The computer-readable medium ofclaim 49, further comprising computer-executable instructions for modifying the data packets for receipt by the simulation.

58. The computer-readable medium ofclaim 57, wherein the computer-executable instructions for modifying includes computer-executable instructions for removing a preamble from a data packet.

59. A computer-readable medium for use in a simulation of an electronic device, wherein the simulation is to be carried out by a program executing in a host computer, and wherein the simulation of the electronic device includes simulating the electronic device's interaction with the network; the computer-readable medium comprising computer-executable instructions to be executed on the host computer for:

(a) receiving data packets designating the electronic device as a source through a software interface from the simulation of the electronic device's interaction with the network; and

(b) transmitting the data packets received from the simulation to the network through a network interface.

60. The computer-readable medium ofclaim 59, further comprising computer-executable instructions for storing the data packets received from the simulation in a buffer allocated in the memory of the host computer.

61. The computer-readable medium ofclaim 60, further comprising computer-executable instructions for changing the size of the buffer at run time.

62. The computer-readable medium ofclaim 60, further comprising computer-executable instructions for discarding packets of data when the buffer is full.

63. The computer-readable medium ofclaim 59, further comprising computer-executable instructions for keeping a record of the data packets.

64. The computer-readable medium ofclaim 63, further comprising computer-executable instructions for displaying the record.

65. The computer-readable medium ofclaim 63, further comprising computer-executable instructions for storing the record in the storage medium.

66. The computer-readable medium ofclaim 59, further comprising computer-executable instructions for recording the throughput of the data packets.

67. The computer-readable medium ofclaim 59, further comprising computer-executable instructions for modifying the data packets to make the packets suitable for receipt by the network.

68. The computer-readable medium ofclaim 67, wherein computer-executable instructions for modifying includes computer-executable instructions for inserting a preamble in a data packet.

Images