US20120221671A1 - Controlling Shared Memory - Google Patents

Controlling Shared Memory Download PDF

Info

Publication number
US20120221671A1
US20120221671A1 US13/400,768 US201213400768A US2012221671A1 US 20120221671 A1 US20120221671 A1 US 20120221671A1 US 201213400768 A US201213400768 A US 201213400768A US 2012221671 A1 US2012221671 A1 US 2012221671A1
Authority
US
United States
Prior art keywords
shared memory
read
network interface
interface card
write operation
Prior art date
Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
Abandoned
Application number
US13/400,768
Inventor
Ying Chen
Yan Li
Qiming Teng
Huayong Wang
Current Assignee (The listed assignees may be inaccurate. Google has not performed a legal analysis and makes no representation or warranty as to the accuracy of the list.)
International Business Machines Corp
Original Assignee
International Business Machines Corp
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date
Application filed by International Business Machines Corp filed Critical International Business Machines Corp
Assigned to INTERNATIONAL BUSINESS MACHINES CORPORATION reassignment INTERNATIONAL BUSINESS MACHINES CORPORATION ASSIGNMENT OF ASSIGNORS INTEREST (SEE DOCUMENT FOR DETAILS). Assignors: CHEN, YING, LI, YAN, Teng, Qiming, Wang, Huayong
Priority to US13/599,501 priority Critical patent/US9356887B2/en
Publication of US20120221671A1 publication Critical patent/US20120221671A1/en
Abandoned legal-status Critical Current

Links

Images

Classifications

    • HELECTRICITY
    • H04ELECTRIC COMMUNICATION TECHNIQUE
    • H04LTRANSMISSION OF DIGITAL INFORMATION, e.g. TELEGRAPHIC COMMUNICATION
    • H04L49/00Packet switching elements
    • H04L49/90Buffering arrangements
    • H04L49/901Buffering arrangements using storage descriptor, e.g. read or write pointers
    • GPHYSICS
    • G06COMPUTING; CALCULATING OR COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F15/00Digital computers in general; Data processing equipment in general
    • G06F15/16Combinations of two or more digital computers each having at least an arithmetic unit, a program unit and a register, e.g. for a simultaneous processing of several programs
    • G06F15/163Interprocessor communication
    • G06F15/167Interprocessor communication using a common memory, e.g. mailbox
    • GPHYSICS
    • G06COMPUTING; CALCULATING OR COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00Arrangements for program control, e.g. control units
    • G06F9/06Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/46Multiprogramming arrangements
    • G06F9/54Interprogram communication
    • G06F9/544Buffers; Shared memory; Pipes

Definitions

  • the present invention generally relates to technologies for processing data on a network interface card (NIC), and specifically to an NIC, a computer device, a method for controlling a read/write operation on a shared memory on a NIC and a method for scheduling a NIC.
  • NIC network interface card
  • a distributed application refers to an application distributed on different computer nodes and accomplishing a task together through a network.
  • the task can be divided into a plurality of processes, and different processes can be distributed on different computer nodes.
  • the plural processes need to invoke each other frequently, or perform plural read/write operations on the same data.
  • the processes of a distributed application distributed on different nodes usually perform network communications using the TCP/IP protocol.
  • TCP/IP is a general communication protocol for supporting communications of almost all kinds of applications on the transmission layer/network layer.
  • the TCP/IP protocol has not provided customized protocol architecture for distributed applications.
  • an independent program buffer for a distributed application is allocated on each computer node.
  • Each process of the distributed program independently performs operations on the program buffer, and performs data transmission through a TCP/IP network.
  • data is required to go through multi-layered packaging before being transmitted through the network, as well as multi-layered decapsulation after being transmitted through the network.
  • the above encapsulation and decapsulation processes result in delays of multiple times during the entire data transmission process, and cause many unnecessary system overheads.
  • FIG. 1 illustrates schematic diagram of a system for performing data communication between two computer nodes in the prior art.
  • computer node A requests to read a piece of data from computer node B.
  • the architecture of computer node A includes an application process A, a language runtime A, a network protocol stack A, a device driver module A, a NIC A and a program buffer A, the program buffer usually residing in the physical memory of the computer node.
  • the computer node A can further include other devices not shown in FIG. 1 , such as a CPU.
  • the architecture of computer node B is identical with that of computer node A.
  • step S 1 the application process A transmits a read data request to the language runtime A through a dedicated programming interface; in step S 2 , the language runtime A converts the read data request into a network data transmission request, and passes it to the network protocol stack A for processing; in step S 3 , the network protocol stack A, after performing TCP/IP encapsulation on the data, invokes the device driver module A to initiate a direct memory access (DMA) operation of the NIC A; in step S 4 , the NIC A copies the address of the program buffer A to the NIC memory (not shown) on the NIC A through the DMA operation; in step S 5 , the NIC A transmits the content in its NIC memory to the NIC B of the other computer node B; in step S 6 , the NIC B generates an interrupt signal after receiving the data request packet from the NIC A, and informs the device driver module B; in step S 7 , the device driver module B copies the data request packet from the NIC memory of the NIC B to the program buffer B
  • One aspect of the present invention provides a network interface card, including: a shared memory configured to provide shared storage for tasks of distributed applications, where said shared memory can be accessed by a plurality of computing nodes executing a same task; and a microcontroller configured to control read/write operations on said shared memory.
  • Another aspect of the present invention provides a method for controlling a read/write operation on a shared memory of a network interface card, where the shared memory is configured to provide shared storage for tasks of a distributed application, and the shared memory can be accessed by a plurality of computing nodes executing a same task, the method including: determining whether a local network interface card is configured with a shared memory supporting said read/write operation; and performing the read/write operation to the shared memory on the local network interface card when the local network interface card is configured with the shared memory supporting the read/write operation.
  • Another aspect of the present invention provides a method for invoking a network interface card, the method including: providing a program buffer of a distributed application; invoking a language runtime through a dedicated interface on the language runtime; invoking a device driver module to perform physical layer encapsulation; and controlling a read/write operation on the shared memory of the network interface card.
  • FIG. 1 illustrates a schematic diagram of a system for performing data communication between two computer nodes in the prior art.
  • FIG. 2A illustrates a schematic diagram of an encapsulation structure of a data frame transmitted on a network in the prior art.
  • FIG. 2B illustrates a schematic diagram of an encapsulation structure of a data frame transmitted on a network according to an embodiment of the present invention.
  • FIG. 3 illustrates a schematic diagram of an internal structure of a NIC in the prior art.
  • FIG. 4A illustrates a schematic diagram of the structure of an NIC according to an embodiment of the present invention.
  • FIG. 4B illustrates a schematic diagram of the structure of an NIC according to another embodiment of the present invention.
  • FIG. 5A illustrates a schematic diagram of a field structure of a command port according to an embodiment of the present invention.
  • FIG. 5B illustrates a schematic diagram of the structure of a write operation instance of a command port according to an embodiment of the present invention.
  • FIG. 5C illustrates a schematic diagram of the structure of an allocation operation instance of a command port according to another embodiment of the present invention.
  • FIG. 6 illustrates a schematic diagram of the structure of an allocation table in the shared memory according to an embodiment of the present invention.
  • FIG. 7A illustrates a schematic diagram of a physical layer data frame transmitted according to the RFC894 Ethernet network transmission standard.
  • FIG. 7B illustrates a schematic diagram of a physical layer data frame transmitted according to the RFC1042 Ethernet network transmission standard.
  • FIG. 8 illustrates a schematic diagram of a system for performing data transmission between two computer nodes according to an embodiment of the present invention.
  • FIG. 9 illustrates a schematic diagram of a system for performing data transmission between two computer nodes according to another embodiment of the present invention.
  • FIG. 10 illustrates a flowchart of a method for controlling a read/write operation on the shared memory of an NIC.
  • FIG. 11 illustrates a flowchart of a method for determining whether there is a locally configured shared memory supporting a read/write operation according to an embodiment of the present invention.
  • FIG. 12 illustrates a flowchart of a method for invocating an NIC according to an embodiment of the present invention.
  • the inventor of the present invention finds that the steps S 8 , S 9 , S 17 and S 18 have significant and unpredictable delay during the above data read process. Therein, scheduling delay of the operating system will occur in the steps S 8 and S 17 ; data receiving can be finished only when the operating system schedules the target application to run, and this delay is difficult to estimate, usually between 1-1000 milliseconds. And in the steps S 9 and S 17 , scheduling delay of the language runtime will occur, and this can be up to several seconds in the worst case.
  • FIG. 2A illustrates a schematic diagram of the encapsulation structure of a data frame transmitted on a network in the prior art.
  • the TCP packet header and tail have 20 bytes in total
  • the IP packet header and tail have 20 bytes in total
  • the physical packet header and tail have 26 bytes in total. Therefore, after being processed by the network protocol stack, if the data packet transmitted on the network has only 1 byte of original data, the finally formed network layer data frame will have 67 (20+20+26+1) bytes.
  • the present invention proposes a technical solution of realizing shared memory on a NIC.
  • the present invention provides a device modeled after NIC, including: a shared memory configured to provide shared storage for a distributed application, and the shared memory can be accessed by a plurality of computing nodes running a same application, as well as a microcontroller configured to control a read/write operation on the shared memory.
  • the present invention further provides a computer device, including: the above-described NIC, and a device driver module configured to perform physical layer encapsulation on the shared memory on the above NIC.
  • the present invention further provides a method for controlling read/write operations on a shared memory of a NIC, where the shared memory is configured to provide shared storage for a distributed application, and the shared memory can be accessed by a plurality of computing nodes running the same application, the method including: determining whether the local NIC is configured with a shared memory supporting the read/write operation, and performing the read/write operation on the shared memory on the local NIC if the local NIC is configured with a shared memory supporting the read/write operation.
  • the present invention provides a method for invocating an NIC, the method including: providing a program buffer for the distributed application, invoking a language runtime through a dedicated interface on the language runtime, invoking a device driver module to perform physical layer encapsulation, and controlling a read/write operation on the shared memory on the NIC through a dedicated interface on the NIC, where the shared memory is configured to provide shared storage for a task of the distributed application, and the shared memory can be accessed by a plurality of computing nodes running the same application.
  • the network stack processing is bypassed, and the device driver module is invoked directly by the language runtime, thus the time delay brought by steps S 8 , S 9 , S 17 , S 18 in FIG. 1 can be avoided.
  • the present invention bypasses the network protocol stack processing, and does not need to perform TCP/IP encapsulation on the data packet and only needs to perform physical layer encapsulation, the data packet can be transmitted according to the existing physical layer transmission model. This significantly saves the additional packet header and tail overheads brought by the TCP/IP layer data encapsulation.
  • FIG. 3 shows a schematic diagram of an internal structure of a NIC in the prior art.
  • the NIC in the prior art includes control logics, an NIC memory, a DMA interface and a medium access unit, where the control logics can be configured to be a programmable chip to control a DMA operation, so as to realize data read/write to the NIC memory.
  • the DMA interface is connected externally to the bus of the computer node to perform a DMA operation.
  • the medium access unit is responsible for receiving data frames from the network and transmitting data frames in the NIC memory to the network.
  • the NIC memory is a temporary storage unit of the data frames.
  • FIG. 4A shows a schematic diagram of the structure of an NIC according to an embodiment of the present invention.
  • the NIC in FIG. 4A is added with a shared memory and a microcontroller on the basis of the structure of a current NIC.
  • the shared memory is configured to provide shared storage for a distributed application, and the shared memory can be accessed by plural computing nodes running the same application.
  • the microcontroller is configured to control a read/write operation on the shared memory.
  • the microcontroller is configured to determine whether the shared memory supports a received read/write request, and perform the read/write operation on the shared memory when it determined that the shared memory supports the received read/write request.
  • the microcontroller can be implemented by a simple Field Programmable Gate Array (FPGA), and not necessarily be designed as a complex general processor.
  • FPGA Field Programmable Gate Array
  • the original control logic of the NIC communicates with the upper-layer device driver module through a specific port, and similarly, the microcontroller can also communicate with the upper-layer device driver module through a specific port.
  • the device driver module communicating with the control logics and the device driver module communicating with the microcontroller are different device driver modules.
  • the NIC memory can be configured to buffer data read/written by the shared memory.
  • the shared memory directly performs the read/write operation with the program buffer in the local physical memory without being buffered by the NIC memory. The specific buffering process will be described in detail in the following.
  • the NIC also includes a command port CMD (not shown) thereon, the command port is connected with the microcontroller and communicates with the upper-layer device driver module, and the command port is configured to receive control commands to the microcontroller, so as to realize the read/write operation on the shared memory.
  • the NIC can also include a state port STAT (not shown) thereon, and the state port is connected with the microcontroller and communicates with the upper-layer device driver module, and is responsible for providing the state result of the data read/write operation on the shared memory on the NIC, so as to be read and checked by the device driver module.
  • the command port and the state port together realize the controlling of the controller.
  • I/O primitives can be used to accomplish port read/write.
  • the following instructions issued by the driver program can accomplish the port read/write:
  • EAX # move the command word into the EAX register OUT 0x4A0
  • EAX # write the command word into the CMD port IN EAX, 0x4A1 # read in state word from the STAT port
  • the CMD port can be a 16-bit or 32-bit register that controls read/write of the on-chip storage module.
  • FIG. 5A illustrates a schematic diagram of a field structure of a command port according to an embodiment of the present invention.
  • the CMD port is implemented as a 32-bit register, which includes a TID field, a SIZE/KEY field, a UNIT field, an OP field and a FLAGS field.
  • the TID field at bits 24 - 31 is used to indicate a task identification code (TID), and the task identification code is used to indicate to which task of the distributed application the data read/written belongs.
  • a distributed application can include plural tasks.
  • the present invention can apply shared memory on the NIC for each task to perform data sharing, or apply shared memory on the NIC for one or more tasks to perform data sharing.
  • the NIC of one computer node provides a common shared memory for all the tasks, or the NICs of different computer nodes provide shared memory for different tasks respectively.
  • the OP field at bits 8 - 11 is used to indicate the operation type, e.g., 0011 denotes to perform data read operation on the shared memory, 0100 denotes to perform data write operation on the shared memory, 0001 denotes to perform memory allocation operation on the shared memory, 0010 denotes to perform memory release operation on the shared memory.
  • the read operation and write operation are two basic operations of data.
  • the allocation operation is used to request allocating a piece of memory space before the data read/write operation
  • the release operation is used to release a previously allocated memory space after the data read/write operation.
  • bits 16 - 23 store the size of the storage space requested to be allocated by the shared memory. Each allocated storage space of the shared memory will be assigned a key KEY for identifying a piece of occupied storage space.
  • the key stored by bits 16 - 23 is used to denote the storage space of the shared memory to which the write operation, the read operation and the free operation correspond.
  • the UNIT field at bits 12 - 15 of the command port is used to denote allocation granularity.
  • the UNIT field can realize an extension of the storage space size.
  • the UNIT field is used to denote a multiple of the filed SIZE.
  • the UNIT field is used to indicate plural multiplies of the field SIZE.
  • bits 12 - 15 when what is stored in bits 12 - 15 is 0001, it indicates that the storage space size of the shared memory requested to be allocated is 1 ⁇ 1; when what is stored in bits 12 - 15 is 0010, it indicates that the storage space size of the shared memory requested to be allocated is 1 ⁇ 8, and so forth.
  • the FLAGS field at bits 0 - 7 of the command port is used to denote other control options, including whether the storage space of the allocated shared memory is allowed to be modified.
  • FIG. 5B illustrates a schematic diagram of the structure of a write operation instance of a command port according to an embodiment of the present invention.
  • the TID field is 00000011
  • the KEY field is 00000001
  • the UNIT field is 0001
  • the OP field is 0100
  • the FLAGS field is 00000000.
  • FIG. 5B denotes a command port instance of executing a write data operation on a piece of storage space with a shared memory key of 1 through the CMD port for a task with a task identifier TID of 3.
  • FIG. 5C shows a schematic diagram of the structure of an allocation operation instance of a command port according to another embodiment of the present invention.
  • the TID field is 00000011
  • the SIZE field is 00001010
  • the UNIT field is 0001
  • the OP field is 0001
  • the FLAGS field is 00000000.
  • FIG. 5C denotes that, for a task with a task identifier 3 , it requests the shared memory to allocate a storage space of 10 bytes of shared memory through the CMD port.
  • the structural design of the CMD port can be adjusted according to the difference of specific applications, and not limited to the above-listed instances.
  • the structural design of the STAT port can also be adjusted according to the difference of specific applications.
  • the structure of the STAT port includes a KEY field and a TID field to indicate the execution status of a read/write command, e.g., whether a read/write operation is executed successfully, or whether a read/write operation invokes a remote computer node.
  • This invention does no specifically define the format of the STAT port.
  • FIG. 6 illustrates a schematic diagram of the structure of an allocation table in the shared memory according to an embodiment of the present invention.
  • an allocation table is maintained in the shared memory.
  • the allocation table records the tasks supported by the shared memory. Specifically, the allocation table in FIG.
  • the microcontroller can, by querying the allocation table, learn whether the local shared memory has allocable space and supports the read/write operation required by the device driver module.
  • the NIC can be further configured with a state switch thereon, which indicates whether the local NIC is configured with a shared memory which in an enabled working state.
  • the microcontroller can be further configured to determine whether the local NIC is configured with a shared memory module according to the state switch.
  • the state in the state switch can be altered to denote whether the shared memory on the local NIC is in an enabled or disabled working state.
  • the microcontroller can determine whether the shared memory configured on the local NIC supports a certain read/write operation according to the task identification code TID in the above allocation table. This function is especially useful for the case where the NICs of plural computer nodes are all configured with different shared memories so as to support different distributed program tasks, by which a microcontroller can determine whether the shared memory configured on the local NIC is the shared memory to which a certain read/write operation is directed.
  • the device driver module In order to indicate that the write operation is to write data into the shared memory rather than the NIC memory, or to indicate that the read operation is to read data out from the shared memory rather than the NIC memory, the device driver module writes a special identifier in the frame structure of the physical layer data while performing physical layer data encapsulation so as to indicate the packet is targeted at the shared memory.
  • the special identifier is recorded in the type field of the physical layer packet header of the data.
  • FIG. 7A illustrates a schematic diagram of a physical layer data frame transmitted according to the RFC894 Ethernet transmission standard.
  • FIG. 7B illustrates a schematic diagram of a physical layer data frame transmitted according to the RFC1042 Ethernet transmission standard. Both transmission standards include a two-byte type field.
  • the device driver module first sets the frame type of the physical layer network frame to identify the difference with a common network data packet before it writes data to the shared memory.
  • the type field is 0x0800 to indicate that an IP packet is carried in the data frame.
  • the present invention can distinguish a shared memory read/write packet from a network data packet by setting the type field to 0x00FF.
  • Other embodiments of the present invention can use other fields of the physical layer frame structure packet header to record the special identifier, or change the physical layer frame structure to add a special identifier field.
  • FIG. 4B illustrates a schematic diagram of an NIC structure according to another embodiment of the present invention.
  • the NIC of FIG. 4B includes control logics, a NIC memory, a media access unit, a DMA interface and a microcontroller. Different from FIG.
  • the NIC in FIG. 4B does not include a shared memory.
  • the microcontroller in FIG. 4B is only used to provide controlling logics to the shared memory of a remote computer node, and not used to control the local shared memory. The specific details will be described in more detail below.
  • Embodiment 1 only one computer node in the plural computer nodes is configured with a shared memory:
  • the NIC A of computer node A is configured with a shared memory A, while the NIC B of computer node B is not configured with a share memory.
  • Embodiment 1.1 a read/write operation is issued by the application process of the computer node configured with a shared memory:
  • FIG. 8 Taking FIG. 8 as an example, assuming that the application process A of computer node A issues a data read/write request.
  • Embodiment 1.1.1 the issued read/write request is a write data request:
  • FIG. 8 Taking FIG. 8 as an example, assuming that the application process A issues a write data request requesting to write a piece of data in the program buffer A into the shared memory. For the application, it is transparent whether data is stored using the shared memory.
  • the application process A provides the address of the program buffer A of the distributed application, the data to be written into the shared memory being stored in the program buffer A.
  • the application process A invokes the language runtime A using a dedicated interface of the language runtime A to perform data writing.
  • the language runtime A invokes the device driver module A to encapsulate the data into a physical layer data frame, including encapsulating the packet header and packet tail of the physical layer data frame.
  • the device driver module A is a device driver module dedicated to perform shared memory operations.
  • the computer node A further includes a device driver module (not shown) corresponding to the controller in the NIC A, i.e., a device driver module used in a traditional NIC.
  • the device driver module A will invoke the traditional device driver module, so as to copy the data from the program buffer A to the NIC memory (not shown) of the NIC A.
  • the physical layer encapsulation can also be performed by a traditional device driver module.
  • the microcontroller A determines whether the local NIC is configured with a shared memory according to the state switch on the NIC A. In this embodiment, the microcontroller A determines that the local NIC has the shared memory. Since only one computer node in the plural computer nodes is configured with the shared memory, the object upon which the above data write request is targeted is exactly the shared memory on the local NIC.
  • the microcontroller A copies the data packet from the NIC memory on the NIC A into the shared memory A.
  • the above step has various implementations, one of which is to remove the packet header and packet tail of the data packet, and copy the effective data part therein into the shared memory A. In another implementation, the entire data packet is copied into the shared memory A.
  • the storage capacity of the shared memory is usually very large, and much larger than the storage capacity of the NIC memory. In this case, if a write operation of a large amount of data is performed, it can be impossible to copy all the data to be written into the NIC memory. Therefore, it is needed to partition a large bulk of data, so that the partitioned data can be written into the shared memory B piece by piece from the program buffer A through the NIC memory. All data read from the program buffer A are finally written into the shared memory A through buffering of the NIC memory.
  • the device driver module A can copy data from the program buffer A into the shared memory A directly by writing to the command port of the microcontroller A.
  • the KEY field in the command port can be used to describe the address of the data to be written in the program buffer A, by which the microcontroller can be able to control copying the data at the address from the program buffer A to the shared memory A.
  • Embodiment 1.1.2 the issued read/write request is a read data request:
  • FIG. 8 assume that the application process A issues a read request, requesting to read data from the shared memory into the program buffer A.
  • the application process A provides the address of the program buffer A for receiving the data.
  • the application process A invokes the language runtime A using a dedicated interface of the language runtime A.
  • the language runtime A invokes the device driver module A to encapsulate the address of the program buffer A to a simple physical layer data frame.
  • the device driver module A invokes a traditional device driver module (not shown) corresponding to the NIC memory in the NIC A, so as to copy the address of the program buffer A to the NIC memory (not shown) of the NIC A.
  • the microcontroller A determines whether the local NIC is configured with a shared memory according to the state switch on the NIC A. In the present embodiment, the microcontroller A determines that the local NIC has the shared memory. Since only one computer node in the plural computer nodes is configured with the shared memory, the object upon which the above data read request is executed is exactly the shared memory on the local NIC.
  • the microcontroller A copies the data from the shared memory A to the NIC memory of the NIC A, and then the controller of the NIC A copies the data from the NIC memory to the program buffer A according to the address of the program buffer A stored in the NIC memory.
  • the device driver module A can also directly copy the data from the shared memory A to the program buffer A by writing to the command port of the microcontroller A.
  • the structure of the command port should be added with a field of program buffer address to indicate the address into which the data is to be written.
  • Embodiment 1.2 a read/write request is issued by the application process of a computer node not configured with a shared memory:
  • Embodiment 1.2.1 the issued read/write request is a write data request:
  • FIG. 8 assume that the application process B issues a write data quest, requesting to write a piece of data in the program buffer B into the share memory A.
  • the application process B provides the address of the program buffer B, in which the data to be written into the shared memory is stored, of the distributed application.
  • the application process B invokes the language runtime B by a dedicated interface on the language runtime B to perform data partition.
  • the language runtime B invokes the device driver module B to encapsulate the data into a data frame of the physical layer, where the device driver module B is a device driver module dedicated to perform shared memory operations.
  • the computer node B further includes a device driver module (not shown) corresponding to the controller in the NIC B, i.e., a device driver module used in a traditional NIC.
  • the device driver module B will invoke the traditional device driver module, so as to copy the data from the program buffer B to the NIC memory (not shown) of the NIC B.
  • the physical layer encapsulation of the data can also be performed by the traditional device driver module.
  • the microcontroller B determines whether the local NIC is configured with a shared memory according to the state switch on the NIC B. In this embodiment, the microcontroller B determines that the local NIC does not have a shared memory thereon.
  • the microcontroller B invokes the controller on the NIC B, so as to transmit the data in the NIC memory of the NIC B to other computer nodes through the medium access unit (not shown), the other computer nodes being computer node A in the present embodiment.
  • the NIC A of computer node A receives the data and copies it to the shared memory A. Specifically, after the N IC A receives the data, the controller of the NIC A determines whether the data is the data to be written into the shared memory by querying a special identifier in the data frame, e.g., a type field. If the data is to be written into the shared memory, then the microcontroller A further determines whether there is a locally configured share memory according to the state switch on its own NIC. In the present embodiment, the microcontroller A determines that a shared memory A is configured locally. Since only one computer node in the plural computer nodes is configured with a shared memory, the object upon which the above data write request is executed is exactly the shared memory on the NIC A. Next, the microcontroller A writes the data into the local shared memory A.
  • a special identifier in the data frame e.g., a type field.
  • a data frame transmitted in a network can include a task identifier field TID and a key field KEY.
  • the TID and KEY can be recorded in the data fields shown in FIG. 7A , 7 B, and the values of TID and KEY will be recorded in the allocation table of the shared memory.
  • the structure of the allocation table refer to the above description with respect to FIG. 6 .
  • Embodiment 1.2.2 the issued read/write request is a read data request:
  • the application process B provides the address of the program buffer B for receiving data.
  • the application process B invokes the language runtime B using a dedicated interface of the language runtime B.
  • the language runtime B invokes the device driver module B to encapsulate the address of the program buffer B into a physical layer data frame.
  • the device driver module B invokes a traditional device driver module (not shown) corresponding to the NIC memory in NIC B, so as to copy the address of the program buffer B into the NIC memory (not shown) of the NIC B.
  • the microcontroller B determines whether a shared memory is configured locally according to the state switch on the NIC B. In the present embodiment, the microcontroller B determines that there is no shared memory on the local NIC, and then the microcontroller B forwards the data read request to other computer nodes or simply neglects this data read request, the other computer node being computer node A in the present embodiment.
  • the controller in the NIC A can determine whether the requested data is data stored in the shared memory by checking the field type in the data frame. If the conclusion is yes, the microcontroller A further determines whether there is a shared memory configured locally. If the further conclusion is yes, the microcontroller A parses the data read request and constructs the data in the shared memory A into a physical layer data frame. Then, the NIC A transmits the data to the computer node B. After receiving the data, the computer node B copies the data to the program buffer B under the control of the controller of NIC B, thus accomplishing the data read operation.
  • Embodiment 2 the plural computer nodes are all configured with shared memories to support different tasks:
  • the NIC A of the computer node A is configured with a shared memory A
  • the NIC B of the computer node B is configured with a shared memory B.
  • the shared memory A and the shared memory B can be used to support different tasks.
  • only the parts of the embodiment 2 different from embodiment 1 are described in detail, while the parts identical with the embodiments in embodiment 1 are merely described briefly.
  • Embodiment 2.1 a read/write request is issued to the local shared memory:
  • FIG. 9 assume that the application process A of the computer node A issues a data read/write request, requesting to perform a read/write operation on the shared memory.
  • Embodiment 2.1.1 the issued read/write request is a write data request:
  • FIG. 9 assume that application process A issues a write data request, requesting to write a piece of data in the program buffer A into the shared memory A.
  • the application process A provides the address of the program buffer A of the distributed application.
  • the application process A invokes the language runtime A, which in turn invokes the device driver module A to encapsulate the data into a physical layer data frame.
  • the device driver module A will invoke the traditional device driver module (not shown) of the NIC A, so as to copy the data from the program buffer A into the NIC memory (not shown) of the NIC A.
  • the microcontroller A determines whether the local NIC is configured with a shared memory according to the state switch on the NIC A. In the present embodiment, the microcontroller A determines that the local NIC is configured with a shared memory. Next, the microcontroller A further determines whether the shared memory A configured on the local NIC supports the write operation, i.e., whether data is to be written into this instance of shared memory A instead of the shared memories on other computer nodes, according to the task identification code TID stored in the allocation table of the shared memory A. Specifically, the microcontroller A can determine whether the write operation is to be performed on the local shared memory by comparing the task identification code TID in the allocation table with the TID field of the write command obtained by the command port of the NIC A. In the present embodiment, the microcontroller A determines that the write operation is to be performed on the local shared memory A.
  • the microcontroller A copies the data from the NIC A memory on the NIC memory A into the shared memory A.
  • Embodiment 2.1.2 the issued read/write request is a read data request:
  • the application process A provides the address of the program buffer A for receiving data.
  • the application process A invokes the language runtime A.
  • the language runtime A invokes the device driver module A to encapsulate the address of the program buffer A into a simple physical layer data frame.
  • the device driver module A invokes a traditional device driver module (not shown) corresponding to the NIC memory in the NIC A so as to copy the address of the program buffer A into the NIC memory (not shown) of the NIC A.
  • the microcontroller A determines whether the local NIC is configured with a shared memory according to the state switch on the NIC A. In the present embodiment, the microcontroller A determines that there is a shared memory on the locale NIC. Next, the microcontroller A further determines whether the shared memory A configured on the local NIC supports the read operation, i.e., whether the data is to be read from the shared memory A instead of the shared memories on other computer nodes, according to the task identification code TID stored in the allocation table of the shared memory A.
  • the microcontroller A copies the data from the shared memory A into the NIC memory of the NIC A, and the controller of the NIC A copies the data from the NIC memory to the program bufferA according the address of the program bufferA stored in the NIC memory, thus accomplishing the data read operation.
  • Embodiment 2.2 a read/write request is issued to a remote shared memory:
  • FIG. 9 assume the application process A of the computer node A issues a data read/write operation, requesting to perform read/write operation on a shared memory located at a remote node B.
  • Embodiment 2.2.1 the issued read/write request is a write data request:
  • the application process A provides the address of the program buffer A, in which the data to be written into the shared memory is stored, of the distributed application, and the application process A invokes the language runtime A. Then, the language runtime A in turn invokes the device driver module A to encapsulate the data to a physical layer data frame. Next, the device driver module A will invoke a traditional device driver module (not shown) corresponding to the controller in the NIC A, so as to copy the data from the program buffer A into the NIC memory (not shown) on the NIC A.
  • the microcontroller A determines whether the local NIC is configured with a shared memory according to the state switch on the NIC A. In the present embodiment, the microcontroller A determines that there is a shared memory on the local NIC. Next, the microcontroller A further determines whether the shared memory A configured on the local NIC supports the write operation, i.e., whether the data is to be written into the shared memory A in stead of the shared memories on other computer nodes, according to the task identification code TID stored in the allocation table of the shared memory A. In the present embodiment, the application process A will write the data into the shared memory B.
  • the microcontroller A invokes the controller on the NIC A, so as to transmit the data in the NIC memory of the NIC A to the computer node B through a medium access unit (not shown).
  • the NIC B of the computer node B receives the data and copies the data to the shared memory B. Specifically, after the NIC B has received the data, the controller of the NIC B determines whether the data is the data to be written into the shared memory by querying a special identifier in the data frame, e.g., a type field. If the data is to be written into the shared memory, then the microcontroller B further determines whether a shared memory is provided locally according to the state switch on its own NIC. In the present embodiment, the microcontroller B determines that there is a shared memory B configured locally.
  • the microcontroller B further determines whether the shared memory B configured on the local NIC supports the write operation, i.e., whether the data is to be written into the shared memory B instead of the shared memories on other computer nodes, according to the task identification code TID stored in the allocation table of the shared memory B. If the conclusion is yes, the microcontroller B writes the data into the local shared memory.
  • Embodiment 2.2.2 the issued read/write request is a read data request:
  • the application process A provides the address of the program buffer A for receiving data.
  • the application process A invokes the language runtime A.
  • the language runtime A invokes the device driver module A to encapsulate the address of the program buffer A to a simple physical layer data frame.
  • the device driver module A invokes a traditional device driver module (not shown) corresponding to the NIC memory in the NIC A, so as to copy the address of the program buffer A into the NIC memory (not shown) of the NIC A.
  • the microcontroller A determines whether a shared memory is configured locally according to the state switch on the NIC A. In the present embodiment, the microcontroller A determines that there is a shared memory on the local NIC. Next, the microcontroller A further determines whether the shared memory A configured on the local NIC supports the read operation, i.e., whether the data is to be read from the shared memory A instead of the shared memories on the other computer nodes, according to the task identification code TID stored in the allocation table of the shared memory A. In the present embodiment, the application process A is to read the data from the shared memory B.
  • the NIC A transmits the data read request to the NIC B.
  • the controller in the NIC B can determine whether it is a read/write request to the shared memory, i.e., whether the requested data is data stored in the shared memory, according to the type field in the data frame. If the conclusion is yes, the microcontroller B further determines whether there is a shared memory configured locally. If the further conclusion is yes, the microcontroller B parses the data read request and constructs the data in the shared memory into a physical layer network frame. Thereafter, the NIC B transmits the data along with the physical layer network frame to the computer node A. After receiving the data, the computer node A copies the data to the program buffer A under the control of the controller of the NIC A, thus accomplishing the data read operation.
  • FIGS. 8 and 9 only schematically describe some steps of the related read/write operations in the present invention, and more detailed steps about memory allocation and release have been described generally above, and will not be repeated here.
  • FIG. 10 illustrates a flowchart of a method for controlling a read/write operation on a shared memory of an NIC.
  • step 1001 it is determined whether a shared memory supporting the read/write operation is configured locally.
  • step 1003 if the shared memory supporting the read/write operation is configured locally, the read/write operation is performed on the local shared memory. The detailed process of performing a read/write operation has been described above, and will not be repeated here.
  • a remote shared memory is requested to perform the read/write operation. If the read/write operation is a write operation, then a physical layer encapsulation is further performed on the data to be written, and the steps for requesting a remote shared memory to perform the read/write operation further includes transmitting the encapsulated data to be written to the remote shared memory. If the read/write operation is a read operation, then perform a physical layer encapsulation on the address of the program buffer into which the data to be read is to be written, so as to be part of the data read request transmitted to the remote, and the step for requesting the remote shared memory to perform the read/write operation further includes transmitting the encapsulated data read request to the remote shared memory.
  • the detailed process of the above operations has been described above and will be omitted here.
  • FIG. 11 illustrates a flowchart of a method for determining whether a shared memory supporting the read/write operation is configured locally according to an embodiment of the present invention.
  • step 1101 it is determined whether the local NIC is configured with a shared memory according to the state switch on the NIC.
  • step 1103 if the local NIC is configured with a shared memory, it is further determined whether the shared memory configured on the local NIC supports the read/write operation according to the task identification code stored in the shared memory. More detailed descriptions of the above two determination steps have been described above and will be omitted here.
  • FIG. 12 illustrates a flowchart of a method for invocating an NIC according to an embodiment of the present invention.
  • a program buffer of the distributed application is provided; in step 1203 , a language runtime is invoked by a dedicated interface on the language runtime; in step 1205 , the device driver module is invoked to perform physical layer encapsulation; in step 1207 , the read/write operation on the shared memory of the NIC is controlled using the above method. More detailed description of the above multiple steps have been described above and will not be repeated here.
  • the present invention can be implemented as a system, method or computer program product. Therefore, unless explicitly stated, the present invention can be implemented in the following forms, i.e., complete hardware, complete software (including firmware, resident software, microcode, etc.), or a combination of software part and hardware part which is generally called “circuit”, “module” or “system” herein. Furthermore, the present invention can be implemented in the form of a computer program product embodied in any tangible medium of expression, which medium includes computer usable program code.
  • a computer usable or computer readable medium can be, for example, but not limited to, electric, magnetic, optical, electromagnetic, infrared or semi-conductive system, apparatus, device or transmission medium. More specific examples of a computer readable medium (a non-exhaustive list) include the following: electric connection with one or more wires, portable computer disk, hard disk, random access memory (RAM), read-only memory (ROM), erasable programmable read only memory (EPROM or flash), optical fiber, portable compact disk read only memory (CD-ROM), optic storage device, transmission medium supporting, for example, internet or internal network, or magnetic storage device.
  • RAM random access memory
  • ROM read-only memory
  • EPROM or flash erasable programmable read only memory
  • CD-ROM compact disk read only memory
  • optic storage device transmission medium supporting, for example, internet or internal network, or magnetic storage device.
  • a computer usable or computer readable medium can even be papers or other mediums on which programs are printed, because, by electrically scanning the papers or other medium, for example, the program can be obtained in an electrical manner, and can be compiled, interpreted or processed in a proper way, and stored in a computer memory if necessary.
  • a computer usable or computer readable medium can be any medium that contains, stores, conveys, propagates or transmits programs to be used by or associated with an instruction execution system, device or apparatus.
  • the computer usable medium can include data signals transmitted in a baseband or as part of a carrier, and embodying computer usable program code.
  • the computer usable program code can be transmitted through any appropriate mediums, including but not limited to wireless, cable, optical fiber, RF.
  • the computer program code for performing the operations of the present invention can be written in any combination of one or more programming languages, which include object-oriented programming languages such as Java, Smalltalk, C++, as well as conventional procedural programming languages such as “C” programming language or similar programming languages.
  • the program code can be executed entirely on a user computer, or executed partially on a user's computer, or executed as an independent software package, or executed partially on a user computer and partially on a remote computer, or executed entirely on a remote computer or server.
  • the remote computer can be connected to the user's computer through any kind of networks, including local area network (LAN) or wide area network (WAN), or can be connected to external computers (e.g., through the Internet using an internet service provider).
  • each block of the flowcharts and/or block diagrams and the combination of the blocks in the flowcharts and/or block diagrams can be implemented by computer program instructions, which can be provided to a general-purpose computer, a dedicated computer or processors of other programmable data processing devices, so as to produce a machine, which enables to produce an apparatus for implementing the functions/operations specified in the blocks of the flowcharts and/or block diagrams through executing the instructions by the computer or other programmable data processing device.
  • the computer program instructions can also be stored in a computer readable medium that is capable of instructing a computer or other programmable data processing devices to operate in a specific way, by which the instructions stored in the computer readable medium produce a manufactured product including instruction means for implementing the functions/operations specified in the blocks of the flowcharts and/or block diagrams.
  • the computer program instructions can also be loaded in a computer or other programmable data processing devices to enable the computer or other programmable data processing devices to perform a series of operation steps, to produce computer-implemented processes, so that the instructions executed on the computer or other programmable data processing devices provide a process of implementing the functions/operations specified in the blocks of the flowcharts and/or block diagrams.
  • each block in the flowcharts or the block diagrams represents a module, a program segment or part of the code, said module, program segment or part of the code includes one or more executable instructions for implementing the specified logic functions.
  • the functions indicated in the blocks can occur in a different order from that is indicated in the blocks. For example, two blocks illustrated consecutively can actually be performed in parallel substantially, and sometimes can also be performed in a reverse order, which depends on the functions involved.
  • each block in the block diagrams and/or the flowcharts and the combination of blocks in the block diagrams and/or flowcharts can be implemented by a dedicated hardware-based system that perform specified functions or operations, or can be implemented by a combination of dedicated hardware and computer instructions.

Abstract

In view of the characteristics of distributed applications, the present invention proposes a technical solution for applying a shared memory on an NIC comprising: a shared memory configured to provide shared storage space for a task of a distributed application, and a microcontroller. Furthermore, the present invention provides a computer device that includes the above-mentioned NIC, a method for controlling a read/write operation on a shared memory of a NIC, and a method for invoking the NIC. The use of the technical solution provided in the present invention bypasses the processing of network protocol stack, avoids the time delay introduced by the network protocol stack. The present invention does not need to perform TCP/IP encapsulation on the data packet, thus greatly saving additional packet header and packet tail overheads generated from the TCP/IP layer data encapsulation.

Description

    CROSS-REFERENCE TO RELATED APPLICATION
  • This application claims priority under 35 U.S.C. §119 from Chinese Patent Application No. 201110047985.X filed Feb. 28, 2011, the entire contents of which are incorporated herein by reference.
  • BACKGROUND OF THE INVENTION
  • 1. Field of the Invention
  • The present invention generally relates to technologies for processing data on a network interface card (NIC), and specifically to an NIC, a computer device, a method for controlling a read/write operation on a shared memory on a NIC and a method for scheduling a NIC.
  • 2. Description of Related Art
  • A distributed application refers to an application distributed on different computer nodes and accomplishing a task together through a network. The task can be divided into a plurality of processes, and different processes can be distributed on different computer nodes. The plural processes need to invoke each other frequently, or perform plural read/write operations on the same data. The processes of a distributed application distributed on different nodes usually perform network communications using the TCP/IP protocol. TCP/IP is a general communication protocol for supporting communications of almost all kinds of applications on the transmission layer/network layer. The TCP/IP protocol has not provided customized protocol architecture for distributed applications.
  • On traditional distributed computer architecture, an independent program buffer for a distributed application is allocated on each computer node. Each process of the distributed program independently performs operations on the program buffer, and performs data transmission through a TCP/IP network. According to the traditional architecture, data is required to go through multi-layered packaging before being transmitted through the network, as well as multi-layered decapsulation after being transmitted through the network. The above encapsulation and decapsulation processes result in delays of multiple times during the entire data transmission process, and cause many unnecessary system overheads.
  • FIG. 1 illustrates schematic diagram of a system for performing data communication between two computer nodes in the prior art. Specifically, in the example shown in FIG. 1, computer node A requests to read a piece of data from computer node B. The architecture of computer node A includes an application process A, a language runtime A, a network protocol stack A, a device driver module A, a NIC A and a program buffer A, the program buffer usually residing in the physical memory of the computer node. The computer node A can further include other devices not shown in FIG. 1, such as a CPU. The architecture of computer node B is identical with that of computer node A.
  • In step S1, the application process A transmits a read data request to the language runtime A through a dedicated programming interface; in step S2, the language runtime A converts the read data request into a network data transmission request, and passes it to the network protocol stack A for processing; in step S3, the network protocol stack A, after performing TCP/IP encapsulation on the data, invokes the device driver module A to initiate a direct memory access (DMA) operation of the NIC A; in step S4, the NIC A copies the address of the program buffer A to the NIC memory (not shown) on the NIC A through the DMA operation; in step S5, the NIC A transmits the content in its NIC memory to the NIC B of the other computer node B; in step S6, the NIC B generates an interrupt signal after receiving the data request packet from the NIC A, and informs the device driver module B; in step S7, the device driver module B copies the data request packet from the NIC memory of the NIC B to the program buffer B; in step S8, the device driver module B informs the network protocol stack B of the event of the arrival of the data request packet, and requests the network protocol stack B to parse the arrived data request packet; in step S9, by parsing the data request packet, the network protocol stack B learns that the content in the data request packet is a read data request, and informs the application process B by the language runtime B; in step S10, the application process B reads the data required by the computer node A, and constructs a network response notification, then invokes the language runtime B requesting to transmit the data; in step S11, the language runtime B passes the network response notification to the network protocol stack B to form a network data transmission request; in step S12, after performing TCP/IP protocol encapsulation on the data, the network protocol stack B invokes the device driver module B and indicates the address of the program buffer B in which the data to be transmitted is located to initiate the NIC B to perform a DMA operation; in step S13, the NIC B copies the data from the program buffer B to the NIC memory on the NIC B through the DMA operation; in step S14, the NIC B transmits the data to the NIC A on the computer node A; in step S15, the NIC A forms an interrupt signal after receiving the data from network, and informs the device driver module A; in step S16, the device driver module A copies the data from the NIC memory of the NIC A to the network protocol stack A; in step S17, the device driver module A informs the network protocol stack A of the data arrival event to request the network protocol stack A to parse the arrived data; in step S18, the network protocol stack A learns that the content of the data packet is a response corresponding to the read data request by parsing the data packet, and informs the application process A by the language runtime A, so as to make the application process A get the final result.
  • SUMMARY OF THE INVENTION
  • One aspect of the present invention provides a network interface card, including: a shared memory configured to provide shared storage for tasks of distributed applications, where said shared memory can be accessed by a plurality of computing nodes executing a same task; and a microcontroller configured to control read/write operations on said shared memory.
  • Another aspect of the present invention provides a method for controlling a read/write operation on a shared memory of a network interface card, where the shared memory is configured to provide shared storage for tasks of a distributed application, and the shared memory can be accessed by a plurality of computing nodes executing a same task, the method including: determining whether a local network interface card is configured with a shared memory supporting said read/write operation; and performing the read/write operation to the shared memory on the local network interface card when the local network interface card is configured with the shared memory supporting the read/write operation.
  • Another aspect of the present invention provides a method for invoking a network interface card, the method including: providing a program buffer of a distributed application; invoking a language runtime through a dedicated interface on the language runtime; invoking a device driver module to perform physical layer encapsulation; and controlling a read/write operation on the shared memory of the network interface card.
  • BRIEF DESCRIPTION OF THE DRAWINGS
  • The accompanying drawings referenced by this description are only used to illustrate typical embodiments of the present invention, and shall not be construed as limitation to the scope of the present invention.
  • FIG. 1 illustrates a schematic diagram of a system for performing data communication between two computer nodes in the prior art.
  • FIG. 2A illustrates a schematic diagram of an encapsulation structure of a data frame transmitted on a network in the prior art.
  • FIG. 2B illustrates a schematic diagram of an encapsulation structure of a data frame transmitted on a network according to an embodiment of the present invention.
  • FIG. 3 illustrates a schematic diagram of an internal structure of a NIC in the prior art.
  • FIG. 4A illustrates a schematic diagram of the structure of an NIC according to an embodiment of the present invention.
  • FIG. 4B illustrates a schematic diagram of the structure of an NIC according to another embodiment of the present invention.
  • FIG. 5A illustrates a schematic diagram of a field structure of a command port according to an embodiment of the present invention.
  • FIG. 5B illustrates a schematic diagram of the structure of a write operation instance of a command port according to an embodiment of the present invention.
  • FIG. 5C illustrates a schematic diagram of the structure of an allocation operation instance of a command port according to another embodiment of the present invention.
  • FIG. 6 illustrates a schematic diagram of the structure of an allocation table in the shared memory according to an embodiment of the present invention.
  • FIG. 7A illustrates a schematic diagram of a physical layer data frame transmitted according to the RFC894 Ethernet network transmission standard.
  • FIG. 7B illustrates a schematic diagram of a physical layer data frame transmitted according to the RFC1042 Ethernet network transmission standard.
  • FIG. 8 illustrates a schematic diagram of a system for performing data transmission between two computer nodes according to an embodiment of the present invention.
  • FIG. 9 illustrates a schematic diagram of a system for performing data transmission between two computer nodes according to another embodiment of the present invention.
  • FIG. 10 illustrates a flowchart of a method for controlling a read/write operation on the shared memory of an NIC.
  • FIG. 11 illustrates a flowchart of a method for determining whether there is a locally configured shared memory supporting a read/write operation according to an embodiment of the present invention.
  • FIG. 12 illustrates a flowchart of a method for invocating an NIC according to an embodiment of the present invention.
  • DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS
  • Numerous specific details are provided in the following discussion to facilitate thorough understanding of the present invention. However, it is obvious to those skilled in the art that the understanding of the present invention can not be affected without these specific details. It should be appreciated that the use of any of the following specific terms is only for the convenience of description, and therefore, the present invention should not be limited to be used in any specific application denoted and/or implied by such terms.
  • The inventor of the present invention finds that the steps S8, S9, S17 and S18 have significant and unpredictable delay during the above data read process. Therein, scheduling delay of the operating system will occur in the steps S8 and S17; data receiving can be finished only when the operating system schedules the target application to run, and this delay is difficult to estimate, usually between 1-1000 milliseconds. And in the steps S9 and S17, scheduling delay of the language runtime will occur, and this can be up to several seconds in the worst case.
  • Besides the time delays, the whole data read process will result in a large amount of network data packet head/tail overheads, since the network protocol stack will be responsible for performing the TCP/IP encapsulation/decapsualtion on the data during the entire data read process. FIG. 2A illustrates a schematic diagram of the encapsulation structure of a data frame transmitted on a network in the prior art. In the schematic diagram of FIG. 2A, it can be found that when being transmitted on the network, data go through three encapsulation processes of TCP, IP and physical layers. The TCP packet header and tail have 20 bytes in total, the IP packet header and tail have 20 bytes in total, and the physical packet header and tail have 26 bytes in total. Therefore, after being processed by the network protocol stack, if the data packet transmitted on the network has only 1 byte of original data, the finally formed network layer data frame will have 67 (20+20+26+1) bytes.
  • For a distributed application, it needs to perform frequent transmission and synchronization of shared data on several specific computer nodes, thus requiring performing frequent communication among the plural computer nodes and performing transmission between the program buffer and NIC memory on each computer node. Obviously, for a task of a distributed application, its main objective is to make the application processes on the computing nodes to obtain consistent data views, and to ensure the consistency of data update. TCP/IP protocol stack processing is not only unnecessary, but also brings additional processing and storage overheads. In view of the above features of a distributed application, the present invention proposes a technical solution of realizing shared memory on a NIC.
  • Specifically, the present invention provides a device modeled after NIC, including: a shared memory configured to provide shared storage for a distributed application, and the shared memory can be accessed by a plurality of computing nodes running a same application, as well as a microcontroller configured to control a read/write operation on the shared memory.
  • In addition, the present invention further provides a computer device, including: the above-described NIC, and a device driver module configured to perform physical layer encapsulation on the shared memory on the above NIC.
  • Additionally, the present invention further provides a method for controlling read/write operations on a shared memory of a NIC, where the shared memory is configured to provide shared storage for a distributed application, and the shared memory can be accessed by a plurality of computing nodes running the same application, the method including: determining whether the local NIC is configured with a shared memory supporting the read/write operation, and performing the read/write operation on the shared memory on the local NIC if the local NIC is configured with a shared memory supporting the read/write operation.
  • Furthermore, the present invention provides a method for invocating an NIC, the method including: providing a program buffer for the distributed application, invoking a language runtime through a dedicated interface on the language runtime, invoking a device driver module to perform physical layer encapsulation, and controlling a read/write operation on the shared memory on the NIC through a dedicated interface on the NIC, where the shared memory is configured to provide shared storage for a task of the distributed application, and the shared memory can be accessed by a plurality of computing nodes running the same application.
  • By using the technical solution of the present invention, the network stack processing is bypassed, and the device driver module is invoked directly by the language runtime, thus the time delay brought by steps S8, S9, S17, S18 in FIG. 1 can be avoided. In addition, since the present invention bypasses the network protocol stack processing, and does not need to perform TCP/IP encapsulation on the data packet and only needs to perform physical layer encapsulation, the data packet can be transmitted according to the existing physical layer transmission model. This significantly saves the additional packet header and tail overheads brought by the TCP/IP layer data encapsulation.
  • FIG. 3 shows a schematic diagram of an internal structure of a NIC in the prior art. The NIC in the prior art includes control logics, an NIC memory, a DMA interface and a medium access unit, where the control logics can be configured to be a programmable chip to control a DMA operation, so as to realize data read/write to the NIC memory. The DMA interface is connected externally to the bus of the computer node to perform a DMA operation. The medium access unit is responsible for receiving data frames from the network and transmitting data frames in the NIC memory to the network. The NIC memory is a temporary storage unit of the data frames.
  • FIG. 4A shows a schematic diagram of the structure of an NIC according to an embodiment of the present invention. The NIC in FIG. 4A is added with a shared memory and a microcontroller on the basis of the structure of a current NIC. Therein, the shared memory is configured to provide shared storage for a distributed application, and the shared memory can be accessed by plural computing nodes running the same application. The microcontroller is configured to control a read/write operation on the shared memory. Furthermore, the microcontroller is configured to determine whether the shared memory supports a received read/write request, and perform the read/write operation on the shared memory when it determined that the shared memory supports the received read/write request. The microcontroller can be implemented by a simple Field Programmable Gate Array (FPGA), and not necessarily be designed as a complex general processor.
  • The original control logic of the NIC communicates with the upper-layer device driver module through a specific port, and similarly, the microcontroller can also communicate with the upper-layer device driver module through a specific port. Generally, the device driver module communicating with the control logics and the device driver module communicating with the microcontroller are different device driver modules.
  • According to an embodiment of the present invention, the NIC memory can be configured to buffer data read/written by the shared memory. According to another embodiment of the present invention, the shared memory directly performs the read/write operation with the program buffer in the local physical memory without being buffered by the NIC memory. The specific buffering process will be described in detail in the following.
  • According to an embodiment of the present invention, the NIC also includes a command port CMD (not shown) thereon, the command port is connected with the microcontroller and communicates with the upper-layer device driver module, and the command port is configured to receive control commands to the microcontroller, so as to realize the read/write operation on the shared memory. Furthermore, the NIC can also include a state port STAT (not shown) thereon, and the state port is connected with the microcontroller and communicates with the upper-layer device driver module, and is responsible for providing the state result of the data read/write operation on the shared memory on the NIC, so as to be read and checked by the device driver module. The command port and the state port together realize the controlling of the controller.
  • In different architectures, different I/O primitives can be used to accomplish port read/write. Taking the IA32 architecture as an example, assuming the port addresses of CMD and STAT are 0x4A0 and 0x4A1 respectively, the following instructions issued by the driver program can accomplish the port read/write:
  • MOV cmd_word, EAX # move the command word into the EAX
    register
    OUT 0x4A0, EAX # write the command word into the CMD port
    IN EAX, 0x4A1 # read in state word from the STAT port
  • According to an embodiment of the present invention, in specific hardware implementation, the CMD port can be a 16-bit or 32-bit register that controls read/write of the on-chip storage module. FIG. 5A illustrates a schematic diagram of a field structure of a command port according to an embodiment of the present invention. In the embodiment of FIG. 5A, the CMD port is implemented as a 32-bit register, which includes a TID field, a SIZE/KEY field, a UNIT field, an OP field and a FLAGS field.
  • Therein, the TID field at bits 24-31 is used to indicate a task identification code (TID), and the task identification code is used to indicate to which task of the distributed application the data read/written belongs. A distributed application can include plural tasks. The present invention can apply shared memory on the NIC for each task to perform data sharing, or apply shared memory on the NIC for one or more tasks to perform data sharing. For the plural computer nodes, either the NIC of one computer node provides a common shared memory for all the tasks, or the NICs of different computer nodes provide shared memory for different tasks respectively.
  • The OP field at bits 8-11 is used to indicate the operation type, e.g., 0011 denotes to perform data read operation on the shared memory, 0100 denotes to perform data write operation on the shared memory, 0001 denotes to perform memory allocation operation on the shared memory, 0010 denotes to perform memory release operation on the shared memory. Therein, the read operation and write operation are two basic operations of data. The allocation operation is used to request allocating a piece of memory space before the data read/write operation, and the release operation is used to release a previously allocated memory space after the data read/write operation.
  • For different operation types, the meanings of the SIZE/KEY field of the command port bits 16-23 can also be different. For example, for the allocation operation, bits 16-23 store the size of the storage space requested to be allocated by the shared memory. Each allocated storage space of the shared memory will be assigned a key KEY for identifying a piece of occupied storage space. For the write operation, the read operation and the release operation, the key stored by bits 16-23 is used to denote the storage space of the shared memory to which the write operation, the read operation and the free operation correspond.
  • The UNIT field at bits 12-15 of the command port is used to denote allocation granularity. In an allocation operation, since bits 16-23 only have 8 bytes and the size of the storage space requested to be allocated by the shared memory that can be denoted thereby is limited, the UNIT field can realize an extension of the storage space size. According to an embodiment of the present invention, the UNIT field is used to denote a multiple of the filed SIZE. For example, for the allocation operation, if what is stored between bits 16-23 is 00000001, then when what is stored by bits 12-15 of the command port is 0001, it indicates that the storage space size of the shared memory requested to be allocated is 1×1; when what is stored in bits 12-15 of the command port is 0010, it indicates that the storage space size of the shared memory requested to be allocated is 1×2; when what is stored in bits 12-15 of the command port is 0011, it indicates that the storage space size of the shared memory requested to be allocated is 1×3, and so forth. According to another embodiment of the present invention, the UNIT field is used to indicate plural multiplies of the field SIZE. For example, when what is stored in bits 12-15 is 0001, it indicates that the storage space size of the shared memory requested to be allocated is 1×1; when what is stored in bits 12-15 is 0010, it indicates that the storage space size of the shared memory requested to be allocated is 1×8, and so forth.
  • Optionally, the FLAGS field at bits 0-7 of the command port is used to denote other control options, including whether the storage space of the allocated shared memory is allowed to be modified.
  • FIG. 5B illustrates a schematic diagram of the structure of a write operation instance of a command port according to an embodiment of the present invention. Therein, the TID field is 00000011, the KEY field is 00000001, the UNIT field is 0001, the OP field is 0100, and the FLAGS field is 00000000. FIG. 5B denotes a command port instance of executing a write data operation on a piece of storage space with a shared memory key of 1 through the CMD port for a task with a task identifier TID of 3.
  • FIG. 5C shows a schematic diagram of the structure of an allocation operation instance of a command port according to another embodiment of the present invention. Therein, the TID field is 00000011, the SIZE field is 00001010, the UNIT field is 0001, the OP field is 0001, and the FLAGS field is 00000000. FIG. 5C denotes that, for a task with a task identifier 3, it requests the shared memory to allocate a storage space of 10 bytes of shared memory through the CMD port.
  • The structural design of the CMD port can be adjusted according to the difference of specific applications, and not limited to the above-listed instances.
  • The structural design of the STAT port can also be adjusted according to the difference of specific applications. In an embodiment of the present invention, the structure of the STAT port includes a KEY field and a TID field to indicate the execution status of a read/write command, e.g., whether a read/write operation is executed successfully, or whether a read/write operation invokes a remote computer node. This invention does no specifically define the format of the STAT port.
  • FIG. 6 illustrates a schematic diagram of the structure of an allocation table in the shared memory according to an embodiment of the present invention. In order to perform effective control on the shared memory in the NIC, according to an embodiment of the present invention, an allocation table is maintained in the shared memory. The allocation table records the tasks supported by the shared memory. Specifically, the allocation table in FIG. 6 includes a TID field, a KEY field, an ADDR field, a LEN field and a FLAGS field, where the TID field records the task identification code supported by the shared memory, the KEY field records the key to which the storage space allocated by the shared memory for the corresponding task, the ADDR field records the start address of the shared memory to which the key corresponds, the LEN field records the size of the storage space of the shared memory to which the key corresponds, and the FLAGS field records other related information. Thus, the microcontroller can, by querying the allocation table, learn whether the local shared memory has allocable space and supports the read/write operation required by the device driver module.
  • According to an embodiment of the present invention, the NIC can be further configured with a state switch thereon, which indicates whether the local NIC is configured with a shared memory which in an enabled working state. The microcontroller can be further configured to determine whether the local NIC is configured with a shared memory module according to the state switch. Moreover, the state in the state switch can be altered to denote whether the shared memory on the local NIC is in an enabled or disabled working state.
  • Furthermore, if the local NIC is configured with a shared memory, the microcontroller can determine whether the shared memory configured on the local NIC supports a certain read/write operation according to the task identification code TID in the above allocation table. This function is especially useful for the case where the NICs of plural computer nodes are all configured with different shared memories so as to support different distributed program tasks, by which a microcontroller can determine whether the shared memory configured on the local NIC is the shared memory to which a certain read/write operation is directed.
  • In order to indicate that the write operation is to write data into the shared memory rather than the NIC memory, or to indicate that the read operation is to read data out from the shared memory rather than the NIC memory, the device driver module writes a special identifier in the frame structure of the physical layer data while performing physical layer data encapsulation so as to indicate the packet is targeted at the shared memory. In an embodiment of the present invention, the special identifier is recorded in the type field of the physical layer packet header of the data. FIG. 7A illustrates a schematic diagram of a physical layer data frame transmitted according to the RFC894 Ethernet transmission standard. FIG. 7B illustrates a schematic diagram of a physical layer data frame transmitted according to the RFC1042 Ethernet transmission standard. Both transmission standards include a two-byte type field. The device driver module first sets the frame type of the physical layer network frame to identify the difference with a common network data packet before it writes data to the shared memory. For example, generally the type field is 0x0800 to indicate that an IP packet is carried in the data frame. The present invention can distinguish a shared memory read/write packet from a network data packet by setting the type field to 0x00FF. Other embodiments of the present invention can use other fields of the physical layer frame structure packet header to record the special identifier, or change the physical layer frame structure to add a special identifier field.
  • As described above, in the present invention, either a common shared memory is provided for all tasks by the NIC of only one computer node in the plural computer nodes, or different shared memories are provided for different tasks by the NICs of different computer nodes. In the former embodiment, the NIC of only one computer node among the plural computer nodes is configured with both the shared memory and the microcontroller, while the NICs of other computer nodes are merely configured with a microcontroller to realize controlling the read/write operation on the remote shared memory. FIG. 4B illustrates a schematic diagram of an NIC structure according to another embodiment of the present invention. The NIC of FIG. 4B includes control logics, a NIC memory, a media access unit, a DMA interface and a microcontroller. Different from FIG. 4A, the NIC in FIG. 4B does not include a shared memory. The microcontroller in FIG. 4B is only used to provide controlling logics to the shared memory of a remote computer node, and not used to control the local shared memory. The specific details will be described in more detail below.
  • In the following is described different data flows in the above two embodiments with respect to the architecture of the computer nodes.
  • Embodiment 1—only one computer node in the plural computer nodes is configured with a shared memory:
  • Taking FIG. 8 as an example, the NIC A of computer node A is configured with a shared memory A, while the NIC B of computer node B is not configured with a share memory.
  • Embodiment 1.1—a read/write operation is issued by the application process of the computer node configured with a shared memory:
  • Taking FIG. 8 as an example, assuming that the application process A of computer node A issues a data read/write request.
  • Embodiment 1.1.1—the issued read/write request is a write data request:
  • Taking FIG. 8 as an example, assuming that the application process A issues a write data request requesting to write a piece of data in the program buffer A into the shared memory. For the application, it is transparent whether data is stored using the shared memory.
  • First, the application process A provides the address of the program buffer A of the distributed application, the data to be written into the shared memory being stored in the program buffer A. The application process A invokes the language runtime A using a dedicated interface of the language runtime A to perform data writing. The language runtime A invokes the device driver module A to encapsulate the data into a physical layer data frame, including encapsulating the packet header and packet tail of the physical layer data frame. Therein the device driver module A is a device driver module dedicated to perform shared memory operations. Besides, the computer node A further includes a device driver module (not shown) corresponding to the controller in the NIC A, i.e., a device driver module used in a traditional NIC. Next, the device driver module A will invoke the traditional device driver module, so as to copy the data from the program buffer A to the NIC memory (not shown) of the NIC A. As a variation of the above embodiment, the physical layer encapsulation can also be performed by a traditional device driver module.
  • Next, the microcontroller A determines whether the local NIC is configured with a shared memory according to the state switch on the NIC A. In this embodiment, the microcontroller A determines that the local NIC has the shared memory. Since only one computer node in the plural computer nodes is configured with the shared memory, the object upon which the above data write request is targeted is exactly the shared memory on the local NIC.
  • Next, the microcontroller A copies the data packet from the NIC memory on the NIC A into the shared memory A. The above step has various implementations, one of which is to remove the packet header and packet tail of the data packet, and copy the effective data part therein into the shared memory A. In another implementation, the entire data packet is copied into the shared memory A.
  • To support data sharing, the storage capacity of the shared memory is usually very large, and much larger than the storage capacity of the NIC memory. In this case, if a write operation of a large amount of data is performed, it can be impossible to copy all the data to be written into the NIC memory. Therefore, it is needed to partition a large bulk of data, so that the partitioned data can be written into the shared memory B piece by piece from the program buffer A through the NIC memory. All data read from the program buffer A are finally written into the shared memory A through buffering of the NIC memory.
  • As a variation of the present embodiment, the device driver module A can copy data from the program buffer A into the shared memory A directly by writing to the command port of the microcontroller A. For example, the KEY field in the command port can be used to describe the address of the data to be written in the program buffer A, by which the microcontroller can be able to control copying the data at the address from the program buffer A to the shared memory A. The above manner can realize a direct data exchange between the program buffer and the shared memory, but can also bring additional control overheads.
  • Embodiment 1.1.2—the issued read/write request is a read data request:
  • Taking FIG. 8 as an example, assume that the application process A issues a read request, requesting to read data from the shared memory into the program buffer A.
  • First, the application process A provides the address of the program buffer A for receiving the data. The application process A invokes the language runtime A using a dedicated interface of the language runtime A. The language runtime A invokes the device driver module A to encapsulate the address of the program buffer A to a simple physical layer data frame. The device driver module A invokes a traditional device driver module (not shown) corresponding to the NIC memory in the NIC A, so as to copy the address of the program buffer A to the NIC memory (not shown) of the NIC A.
  • Next, the microcontroller A determines whether the local NIC is configured with a shared memory according to the state switch on the NIC A. In the present embodiment, the microcontroller A determines that the local NIC has the shared memory. Since only one computer node in the plural computer nodes is configured with the shared memory, the object upon which the above data read request is executed is exactly the shared memory on the local NIC.
  • Next, the microcontroller A copies the data from the shared memory A to the NIC memory of the NIC A, and then the controller of the NIC A copies the data from the NIC memory to the program buffer A according to the address of the program buffer A stored in the NIC memory.
  • As a variation of the present embodiment, the device driver module A can also directly copy the data from the shared memory A to the program buffer A by writing to the command port of the microcontroller A. In this way, the structure of the command port should be added with a field of program buffer address to indicate the address into which the data is to be written.
  • Embodiment 1.2—a read/write request is issued by the application process of a computer node not configured with a shared memory:
  • Taking FIG. 8 as an example, assume that the application process B of the computer node B issues a data read/write request.
  • Embodiment 1.2.1—the issued read/write request is a write data request:
  • Taking FIG. 8 as an example, assume that the application process B issues a write data quest, requesting to write a piece of data in the program buffer B into the share memory A.
  • First, the application process B provides the address of the program buffer B, in which the data to be written into the shared memory is stored, of the distributed application. The application process B invokes the language runtime B by a dedicated interface on the language runtime B to perform data partition. The language runtime B invokes the device driver module B to encapsulate the data into a data frame of the physical layer, where the device driver module B is a device driver module dedicated to perform shared memory operations. Besides, the computer node B further includes a device driver module (not shown) corresponding to the controller in the NIC B, i.e., a device driver module used in a traditional NIC. Next, the device driver module B will invoke the traditional device driver module, so as to copy the data from the program buffer B to the NIC memory (not shown) of the NIC B. As a variation of the above embodiment, the physical layer encapsulation of the data can also be performed by the traditional device driver module.
  • Next, the microcontroller B determines whether the local NIC is configured with a shared memory according to the state switch on the NIC B. In this embodiment, the microcontroller B determines that the local NIC does not have a shared memory thereon.
  • Next, the microcontroller B invokes the controller on the NIC B, so as to transmit the data in the NIC memory of the NIC B to other computer nodes through the medium access unit (not shown), the other computer nodes being computer node A in the present embodiment.
  • Then, the NIC A of computer node A receives the data and copies it to the shared memory A. Specifically, after the N IC A receives the data, the controller of the NIC A determines whether the data is the data to be written into the shared memory by querying a special identifier in the data frame, e.g., a type field. If the data is to be written into the shared memory, then the microcontroller A further determines whether there is a locally configured share memory according to the state switch on its own NIC. In the present embodiment, the microcontroller A determines that a shared memory A is configured locally. Since only one computer node in the plural computer nodes is configured with a shared memory, the object upon which the above data write request is executed is exactly the shared memory on the NIC A. Next, the microcontroller A writes the data into the local shared memory A.
  • It should be pointed out that, a data frame transmitted in a network can include a task identifier field TID and a key field KEY. The TID and KEY can be recorded in the data fields shown in FIG. 7A, 7B, and the values of TID and KEY will be recorded in the allocation table of the shared memory. As for the structure of the allocation table, refer to the above description with respect to FIG. 6.
  • Embodiment 1.2.2—the issued read/write request is a read data request:
  • Taking FIG. 8 as an example, assume the application process B issues a read data request, requesting to read data from the shared memory into the program buffer B.
  • First, the application process B provides the address of the program buffer B for receiving data. The application process B invokes the language runtime B using a dedicated interface of the language runtime B. Then, the language runtime B invokes the device driver module B to encapsulate the address of the program buffer B into a physical layer data frame. Moreover, the device driver module B invokes a traditional device driver module (not shown) corresponding to the NIC memory in NIC B, so as to copy the address of the program buffer B into the NIC memory (not shown) of the NIC B.
  • Next, the microcontroller B determines whether a shared memory is configured locally according to the state switch on the NIC B. In the present embodiment, the microcontroller B determines that there is no shared memory on the local NIC, and then the microcontroller B forwards the data read request to other computer nodes or simply neglects this data read request, the other computer node being computer node A in the present embodiment.
  • Next, the controller in the NIC A can determine whether the requested data is data stored in the shared memory by checking the field type in the data frame. If the conclusion is yes, the microcontroller A further determines whether there is a shared memory configured locally. If the further conclusion is yes, the microcontroller A parses the data read request and constructs the data in the shared memory A into a physical layer data frame. Then, the NIC A transmits the data to the computer node B. After receiving the data, the computer node B copies the data to the program buffer B under the control of the controller of NIC B, thus accomplishing the data read operation.
  • Embodiment 2—the plural computer nodes are all configured with shared memories to support different tasks:
  • Taking FIG. 9 as an example, the NIC A of the computer node A is configured with a shared memory A, and the NIC B of the computer node B is configured with a shared memory B. The shared memory A and the shared memory B can be used to support different tasks. Hereinafter, only the parts of the embodiment 2 different from embodiment 1 are described in detail, while the parts identical with the embodiments in embodiment 1 are merely described briefly.
  • Embodiment 2.1—a read/write request is issued to the local shared memory:
  • Taking FIG. 9 as an example, assume that the application process A of the computer node A issues a data read/write request, requesting to perform a read/write operation on the shared memory.
  • Embodiment 2.1.1—the issued read/write request is a write data request:
  • Taking FIG. 9 as an example, assume that application process A issues a write data request, requesting to write a piece of data in the program buffer A into the shared memory A.
  • First, the application process A provides the address of the program buffer A of the distributed application. The application process A invokes the language runtime A, which in turn invokes the device driver module A to encapsulate the data into a physical layer data frame. Next, the device driver module A will invoke the traditional device driver module (not shown) of the NIC A, so as to copy the data from the program buffer A into the NIC memory (not shown) of the NIC A.
  • Next, the microcontroller A determines whether the local NIC is configured with a shared memory according to the state switch on the NIC A. In the present embodiment, the microcontroller A determines that the local NIC is configured with a shared memory. Next, the microcontroller A further determines whether the shared memory A configured on the local NIC supports the write operation, i.e., whether data is to be written into this instance of shared memory A instead of the shared memories on other computer nodes, according to the task identification code TID stored in the allocation table of the shared memory A. Specifically, the microcontroller A can determine whether the write operation is to be performed on the local shared memory by comparing the task identification code TID in the allocation table with the TID field of the write command obtained by the command port of the NIC A. In the present embodiment, the microcontroller A determines that the write operation is to be performed on the local shared memory A.
  • Next, the microcontroller A copies the data from the NIC A memory on the NIC memory A into the shared memory A.
  • Embodiment 2.1.2—the issued read/write request is a read data request:
  • Taking FIG. 9 as an example, assume the application process A issues a read data request, requesting to read the data from the shared memory into the program buffer A.
  • First, the application process A provides the address of the program buffer A for receiving data. The application process A invokes the language runtime A. Next, the language runtime A invokes the device driver module A to encapsulate the address of the program buffer A into a simple physical layer data frame. The device driver module A invokes a traditional device driver module (not shown) corresponding to the NIC memory in the NIC A so as to copy the address of the program buffer A into the NIC memory (not shown) of the NIC A.
  • Next, the microcontroller A determines whether the local NIC is configured with a shared memory according to the state switch on the NIC A. In the present embodiment, the microcontroller A determines that there is a shared memory on the locale NIC. Next, the microcontroller A further determines whether the shared memory A configured on the local NIC supports the read operation, i.e., whether the data is to be read from the shared memory A instead of the shared memories on other computer nodes, according to the task identification code TID stored in the allocation table of the shared memory A.
  • Then, the microcontroller A copies the data from the shared memory A into the NIC memory of the NIC A, and the controller of the NIC A copies the data from the NIC memory to the program bufferA according the address of the program bufferA stored in the NIC memory, thus accomplishing the data read operation.
  • Embodiment 2.2—a read/write request is issued to a remote shared memory:
  • Taking FIG. 9 as an example, assume the application process A of the computer node A issues a data read/write operation, requesting to perform read/write operation on a shared memory located at a remote node B.
  • Embodiment 2.2.1—the issued read/write request is a write data request:
  • Taking FIG. 9 as example, assume that the application process A issues a write data request, requesting to write a piece of data in the program buffer A into the shared memory B.
  • First, the application process A provides the address of the program buffer A, in which the data to be written into the shared memory is stored, of the distributed application, and the application process A invokes the language runtime A. Then, the language runtime A in turn invokes the device driver module A to encapsulate the data to a physical layer data frame. Next, the device driver module A will invoke a traditional device driver module (not shown) corresponding to the controller in the NIC A, so as to copy the data from the program buffer A into the NIC memory (not shown) on the NIC A.
  • Next, the microcontroller A determines whether the local NIC is configured with a shared memory according to the state switch on the NIC A. In the present embodiment, the microcontroller A determines that there is a shared memory on the local NIC. Next, the microcontroller A further determines whether the shared memory A configured on the local NIC supports the write operation, i.e., whether the data is to be written into the shared memory A in stead of the shared memories on other computer nodes, according to the task identification code TID stored in the allocation table of the shared memory A. In the present embodiment, the application process A will write the data into the shared memory B.
  • Then, the microcontroller A invokes the controller on the NIC A, so as to transmit the data in the NIC memory of the NIC A to the computer node B through a medium access unit (not shown).
  • Then, the NIC B of the computer node B receives the data and copies the data to the shared memory B. Specifically, after the NIC B has received the data, the controller of the NIC B determines whether the data is the data to be written into the shared memory by querying a special identifier in the data frame, e.g., a type field. If the data is to be written into the shared memory, then the microcontroller B further determines whether a shared memory is provided locally according to the state switch on its own NIC. In the present embodiment, the microcontroller B determines that there is a shared memory B configured locally. Next, the microcontroller B further determines whether the shared memory B configured on the local NIC supports the write operation, i.e., whether the data is to be written into the shared memory B instead of the shared memories on other computer nodes, according to the task identification code TID stored in the allocation table of the shared memory B. If the conclusion is yes, the microcontroller B writes the data into the local shared memory.
  • Embodiment 2.2.2—the issued read/write request is a read data request:
  • Taking FIG. 9 as an example, assume the application process A issues a data read request, requesting to read data from the shared memory into the program buffer A.
  • First, the application process A provides the address of the program buffer A for receiving data. The application process A invokes the language runtime A. Then, the language runtime A invokes the device driver module A to encapsulate the address of the program buffer A to a simple physical layer data frame. The device driver module A invokes a traditional device driver module (not shown) corresponding to the NIC memory in the NIC A, so as to copy the address of the program buffer A into the NIC memory (not shown) of the NIC A.
  • Next, the microcontroller A determines whether a shared memory is configured locally according to the state switch on the NIC A. In the present embodiment, the microcontroller A determines that there is a shared memory on the local NIC. Next, the microcontroller A further determines whether the shared memory A configured on the local NIC supports the read operation, i.e., whether the data is to be read from the shared memory A instead of the shared memories on the other computer nodes, according to the task identification code TID stored in the allocation table of the shared memory A. In the present embodiment, the application process A is to read the data from the shared memory B.
  • Then, the NIC A transmits the data read request to the NIC B. Next, the controller in the NIC B can determine whether it is a read/write request to the shared memory, i.e., whether the requested data is data stored in the shared memory, according to the type field in the data frame. If the conclusion is yes, the microcontroller B further determines whether there is a shared memory configured locally. If the further conclusion is yes, the microcontroller B parses the data read request and constructs the data in the shared memory into a physical layer network frame. Thereafter, the NIC B transmits the data along with the physical layer network frame to the computer node A. After receiving the data, the computer node A copies the data to the program buffer A under the control of the controller of the NIC A, thus accomplishing the data read operation.
  • The above various embodiments described in conjunction with FIGS. 8 and 9 only schematically describe some steps of the related read/write operations in the present invention, and more detailed steps about memory allocation and release have been described generally above, and will not be repeated here.
  • FIG. 10 illustrates a flowchart of a method for controlling a read/write operation on a shared memory of an NIC. In step 1001, it is determined whether a shared memory supporting the read/write operation is configured locally. In step 1003, if the shared memory supporting the read/write operation is configured locally, the read/write operation is performed on the local shared memory. The detailed process of performing a read/write operation has been described above, and will not be repeated here.
  • Furthermore, when there is no shared memory supporting the read/write operation configured locally, a remote shared memory is requested to perform the read/write operation. If the read/write operation is a write operation, then a physical layer encapsulation is further performed on the data to be written, and the steps for requesting a remote shared memory to perform the read/write operation further includes transmitting the encapsulated data to be written to the remote shared memory. If the read/write operation is a read operation, then perform a physical layer encapsulation on the address of the program buffer into which the data to be read is to be written, so as to be part of the data read request transmitted to the remote, and the step for requesting the remote shared memory to perform the read/write operation further includes transmitting the encapsulated data read request to the remote shared memory. The detailed process of the above operations has been described above and will be omitted here.
  • FIG. 11 illustrates a flowchart of a method for determining whether a shared memory supporting the read/write operation is configured locally according to an embodiment of the present invention. First, in step 1101, it is determined whether the local NIC is configured with a shared memory according to the state switch on the NIC. Then in step 1103, if the local NIC is configured with a shared memory, it is further determined whether the shared memory configured on the local NIC supports the read/write operation according to the task identification code stored in the shared memory. More detailed descriptions of the above two determination steps have been described above and will be omitted here.
  • FIG. 12 illustrates a flowchart of a method for invocating an NIC according to an embodiment of the present invention. In step 1201, a program buffer of the distributed application is provided; in step 1203, a language runtime is invoked by a dedicated interface on the language runtime; in step 1205, the device driver module is invoked to perform physical layer encapsulation; in step 1207, the read/write operation on the shared memory of the NIC is controlled using the above method. More detailed description of the above multiple steps have been described above and will not be repeated here.
  • It will be appreciated by those skilled in the art that, unless explicitly stated, the present invention can be implemented as a system, method or computer program product. Therefore, unless explicitly stated, the present invention can be implemented in the following forms, i.e., complete hardware, complete software (including firmware, resident software, microcode, etc.), or a combination of software part and hardware part which is generally called “circuit”, “module” or “system” herein. Furthermore, the present invention can be implemented in the form of a computer program product embodied in any tangible medium of expression, which medium includes computer usable program code.
  • Any combination of one or more computer usable or computer readable mediums can be used. A computer usable or computer readable medium can be, for example, but not limited to, electric, magnetic, optical, electromagnetic, infrared or semi-conductive system, apparatus, device or transmission medium. More specific examples of a computer readable medium (a non-exhaustive list) include the following: electric connection with one or more wires, portable computer disk, hard disk, random access memory (RAM), read-only memory (ROM), erasable programmable read only memory (EPROM or flash), optical fiber, portable compact disk read only memory (CD-ROM), optic storage device, transmission medium supporting, for example, internet or internal network, or magnetic storage device. It should be noted that a computer usable or computer readable medium can even be papers or other mediums on which programs are printed, because, by electrically scanning the papers or other medium, for example, the program can be obtained in an electrical manner, and can be compiled, interpreted or processed in a proper way, and stored in a computer memory if necessary. In the context of this specification, a computer usable or computer readable medium can be any medium that contains, stores, conveys, propagates or transmits programs to be used by or associated with an instruction execution system, device or apparatus. The computer usable medium can include data signals transmitted in a baseband or as part of a carrier, and embodying computer usable program code. The computer usable program code can be transmitted through any appropriate mediums, including but not limited to wireless, cable, optical fiber, RF.
  • The computer program code for performing the operations of the present invention can be written in any combination of one or more programming languages, which include object-oriented programming languages such as Java, Smalltalk, C++, as well as conventional procedural programming languages such as “C” programming language or similar programming languages. The program code can be executed entirely on a user computer, or executed partially on a user's computer, or executed as an independent software package, or executed partially on a user computer and partially on a remote computer, or executed entirely on a remote computer or server. In the latter case, the remote computer can be connected to the user's computer through any kind of networks, including local area network (LAN) or wide area network (WAN), or can be connected to external computers (e.g., through the Internet using an internet service provider).
  • The present invention is described above by referring to the flowcharts and/or block diagrams of the method, apparatus (system) and computer program product according to embodiments of the present invention. It should be appreciated that, each block of the flowcharts and/or block diagrams and the combination of the blocks in the flowcharts and/or block diagrams can be implemented by computer program instructions, which can be provided to a general-purpose computer, a dedicated computer or processors of other programmable data processing devices, so as to produce a machine, which enables to produce an apparatus for implementing the functions/operations specified in the blocks of the flowcharts and/or block diagrams through executing the instructions by the computer or other programmable data processing device.
  • The computer program instructions can also be stored in a computer readable medium that is capable of instructing a computer or other programmable data processing devices to operate in a specific way, by which the instructions stored in the computer readable medium produce a manufactured product including instruction means for implementing the functions/operations specified in the blocks of the flowcharts and/or block diagrams.
  • The computer program instructions can also be loaded in a computer or other programmable data processing devices to enable the computer or other programmable data processing devices to perform a series of operation steps, to produce computer-implemented processes, so that the instructions executed on the computer or other programmable data processing devices provide a process of implementing the functions/operations specified in the blocks of the flowcharts and/or block diagrams.
  • The flowcharts and block diagrams in the accompanying drawings illustrate the architectures, functions or operations that can be implemented according to the system, method or computer program products of the various embodiments of the present invention. In this regard, each block in the flowcharts or the block diagrams represents a module, a program segment or part of the code, said module, program segment or part of the code includes one or more executable instructions for implementing the specified logic functions. It should be also noted that, in some alternative implementations, the functions indicated in the blocks can occur in a different order from that is indicated in the blocks. For example, two blocks illustrated consecutively can actually be performed in parallel substantially, and sometimes can also be performed in a reverse order, which depends on the functions involved. It should also be noted that, each block in the block diagrams and/or the flowcharts and the combination of blocks in the block diagrams and/or flowcharts can be implemented by a dedicated hardware-based system that perform specified functions or operations, or can be implemented by a combination of dedicated hardware and computer instructions.
  • The terminology used herein is only for describing specific embodiments, and not intended to limit the present invention. The singular forms of “one” and “the” used herein are intended to include plural forms, unless explicitly stated otherwise in the context. It should also be appreciated that, when the word “include” is used herein, it means the existence of the indicated features, entities, steps, operations, units and/or components, but does not exclude the existence or addition of one or more other features, entities, steps, operations, units and/or components, and/or the combination thereof.
  • Equivalent alternatives of the corresponding structures, materials, operations and all the functionally defined means or steps in the claims are intended to include any structures, materials or operations for executing the functions in combination with other units specifically stated in the claims. The objective of the given description of the present invention is to illustrate and describe, and not exhaustive, nor to limit the present invention to the described forms. For those of ordinary skill in the art, it is obvious that can modifications and variations can be made without departing from the scope and sprit of the present invention. The selection and description of the embodiments are for the purpose of best explaining the principles and actual application of the present invention, so that those of ordinary skill in the art can understand that the present invention can have various implementations with all kinds of variations suitable for the desired specific purposes.

Claims (22)

1. A network interface card, comprising:
a shared memory configured to provide shared storage for tasks of distributed applications, wherein said shared memory can be accessed by a plurality of computing nodes executing a same task; and
a microcontroller configured to control read/write operations on said shared memory.
2. The network interface card of claim 1, wherein said microcontroller is further configured to:
determine whether said shared memory supports a received read/write request; and
perform the read/write operation to said shared memory when said shared memory supports the received read/write request.
3. The network interface card of claim 1, further comprising:
a command port, wherein (i) said command port is connected with said microcontroller, and (ii) said command port is configured to transmit a control command to the microcontroller.
4. The network interface card of claim 3, wherein said control command includes fields for controlling said shared memory to perform one of the following operations: read operation, write operation, allocation operation and release operation.
5. The network interface card of claim 1, further comprising:
a state switch; and
said microcontroller being further configured to determine whether a shared memory is configured on said network interface card according to said state switch.
6. The network interface card of claim 5, wherein a task identification code is stored in said shared memory, and wherein if a shared memory is configured on said network interface card, then said microcontroller is further configured to determine whether said shared memory supports the received read/write request according to said task identification code.
7. The network interface card of claim 1, wherein the frame structure of data stored in said shared memory includes an identifier to indicate that said data is targeted at said shared memory.
8. The network interface card of claim 7, wherein said identifier is recorded in a type field of a physical layer header of said data.
9. The network interface card of claim 1, further comprising:
a network interface card memory configured to buffer the data read/written by said shared memory.
10. The network interface card of claim 1, wherein said shared memory is further configured to directly perform the read/write operation with a program buffer outside said network interface card.
11. A computer device, comprising the network interface card of claim 1.
12. A method for controlling a read/write operation on a shared memory of a network interface card, wherein said shared memory is configured to provide shared storage for tasks of a distributed application, and said shared memory is accessed by a plurality of computing nodes executing a same task, said method comprising:
determining whether a local network interface card is configured with a shared memory supporting said read/write operation; and
performing the read/write operation to the shared memory on the local network interface card when the local network interface card is configured with the shared memory supporting said read/write operation.
13. The method of claim 12, wherein the step of determining whether the local network interface card is configured with the shared memory supporting said read/write operation comprises:
determining whether the local network interface card is configured with the shared memory according to a state switch on the network interface card.
14. The method of claim 13, wherein the step of determining whether the local network interface card is configured with the shared memory supporting said read/write operation further comprises:
determining whether the shared memory configured on the local network interface card supports the read/write operation according to a task identification code stored on the shared memory on the local network interface card if the local network interface card is configured with the shared memory.
15. The method of claim 12, further comprising:
requesting a shared memory on a remote network interface card to perform the read/write operation when there is no shared memory supporting said read/write operation configured on the local network interface card.
16. The method of claim 15, wherein if said read/write operation is a write operation, then said step of requesting a shared memory on a remote network interface card to perform the read/write operation further comprises:
transmitting data to be written to the shared memory on the remote network interface card.
17. The method of claim 15, wherein if the read/write operation is a read operation, then said step of requesting a shared memory on a remote network interface card to perform the read/write operation further comprises:
transmitting a data read request to the shared memory on the remote network interface card.
18. The method of claim 12, wherein said network interface card further comprises a network interface card memory, and wherein the step of performing the read/write operation on the shared memory on the local network interface card further comprises:
performing the read/write operation on the shared memory on the local network interface card through a buffer of the memory of the local network interface card.
19. The method of claim 12, wherein the step of performing the read/write operation on the shared memory on the local network interface card further comprises:
directly performing said read/write operation between the shared memory on the local network interface card and a program buffer outside the local network interface card.
20. The method of claim 12, further comprises:
performing physical layer encapsulation on the data to be written if said read/write operation is a write operation.
21. The method of claim 12, further comprises:
performing physical layer encapsulation on a program buffer address of the program buffer into which the data to be read out is to be written if said read/write operation is a read operation.
22. A method for invoking a network interface card, the method comprising:
providing a program buffer of a distributed application;
invoking a language runtime through a dedicated interface on the language runtime;
invoking a device driver module to perform physical layer encapsulation; and
controlling a read/write operation on a shared memory of the network interface card by a method comprising:
determining whether a local network interface card is configured with a shared memory supporting said read/write operation; and
performing the read/write operation to the shared memory on the local network interface card when the local network interface card is configured with the shared memory supporting said read/write operation;
wherein said shared memory is configured to provide shared storage for tasks of a distributed application; and
wherein said shared memory is accessed by a plurality of computing nodes executing a same task.
US13/400,768 2011-02-28 2012-02-21 Controlling Shared Memory Abandoned US20120221671A1 (en)

Priority Applications (1)

Application Number Priority Date Filing Date Title
US13/599,501 US9356887B2 (en) 2011-02-28 2012-08-30 Controlling shared memory

Applications Claiming Priority (2)

Application Number Priority Date Filing Date Title
CN201110047985.XA CN102651690B (en) 2011-02-28 2011-02-28 To the method and apparatus that shared drive controls
CN201110047985.X 2011-02-28

Related Child Applications (1)

Application Number Title Priority Date Filing Date
US13/599,501 Continuation US9356887B2 (en) 2011-02-28 2012-08-30 Controlling shared memory

Publications (1)

Publication Number Publication Date
US20120221671A1 true US20120221671A1 (en) 2012-08-30

Family

ID=46693586

Family Applications (2)

Application Number Title Priority Date Filing Date
US13/400,768 Abandoned US20120221671A1 (en) 2011-02-28 2012-02-21 Controlling Shared Memory
US13/599,501 Expired - Fee Related US9356887B2 (en) 2011-02-28 2012-08-30 Controlling shared memory

Family Applications After (1)

Application Number Title Priority Date Filing Date
US13/599,501 Expired - Fee Related US9356887B2 (en) 2011-02-28 2012-08-30 Controlling shared memory

Country Status (2)

Country Link
US (2) US20120221671A1 (en)
CN (1) CN102651690B (en)

Cited By (7)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US20160239314A1 (en) * 2015-02-16 2016-08-18 Dell Products L.P. Systems and methods for efficient file transfer in a boot mode of a basic input/output system
US9882972B2 (en) 2015-10-30 2018-01-30 International Business Machines Corporation Packet forwarding optimization without an intervening load balancing node
US9916280B2 (en) * 2016-06-09 2018-03-13 International Business Machines Corporation Virtualizing TCP/IP services with shared memory transport
US20180293188A1 (en) * 2017-04-05 2018-10-11 International Business Machines Corporation Low overhead exclusive control for shared memory objects
US10839289B2 (en) 2016-04-28 2020-11-17 International Business Machines Corporation Neural network processing with von-Neumann cores
US20200387405A1 (en) * 2018-02-24 2020-12-10 Huawei Technologies Co., Ltd. Communication Method and Apparatus
CN114071222A (en) * 2021-11-15 2022-02-18 深圳Tcl新技术有限公司 Audio and video data sharing device and electronic equipment

Families Citing this family (13)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US9459910B1 (en) * 2013-03-13 2016-10-04 Emc Corporation Controlling a layered driver
US9378046B1 (en) 2013-03-13 2016-06-28 Emc Corporation Manipulating hardware using a layered device driver
WO2015065429A1 (en) * 2013-10-31 2015-05-07 Hewlett-Packard Development Company, L.P. Copy-on-write update-triggered consistency
CN103888510B (en) * 2014-01-14 2017-07-14 无锡城市云计算中心有限公司 A kind of business high availability method of cloud computation data center
US9515931B2 (en) 2014-05-30 2016-12-06 International Business Machines Corporation Virtual network data control with network interface card
CN106792629B (en) * 2015-11-25 2021-03-19 深圳市六二九科技有限公司 Smart card data system and use method
EP3663928B1 (en) * 2017-09-05 2021-06-23 Huawei Technologies Co., Ltd. Data migration method and system and intelligent network card
CN108667903B (en) * 2018-04-03 2019-11-12 新华三技术有限公司 Data transmission method for uplink, device and storage medium
CN110086571A (en) * 2019-04-10 2019-08-02 广州华多网络科技有限公司 A kind of data transmission and received method, apparatus and data processing system
CN111142969A (en) * 2019-12-27 2020-05-12 贵阳动视云科技有限公司 Method, device, medium and equipment for calling 32-bit program module by 64-bit program
CN112532690B (en) * 2020-11-04 2023-03-24 杭州迪普科技股份有限公司 Message parsing method and device, electronic equipment and storage medium
CN112817767B (en) * 2021-02-24 2021-11-16 上海交通大学 Method and system for realizing optimization of graph computation working set under separated combined architecture
CN113839889A (en) * 2021-09-18 2021-12-24 深圳震有科技股份有限公司 Message processing method, terminal and computer readable storage medium

Citations (6)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US5257369A (en) * 1990-10-22 1993-10-26 Skeen Marion D Apparatus and method for providing decoupling of data exchange details for providing high performance communication between software processes
US5339392A (en) * 1989-07-27 1994-08-16 Risberg Jeffrey S Apparatus and method for creation of a user definable video displayed document showing changes in real time data
US5557798A (en) * 1989-07-27 1996-09-17 Tibco, Inc. Apparatus and method for providing decoupling of data exchange details for providing high performance communication between software processes
US20020172199A1 (en) * 2000-12-14 2002-11-21 Scott Steven L. Node translation and protection in a clustered multiprocessor system
US7716667B2 (en) * 2003-07-09 2010-05-11 Symantec Operating Corporation Migrating virtual machines among computer systems to balance load caused by virtual machines
US8417833B1 (en) * 2006-11-29 2013-04-09 F5 Networks, Inc. Metacodec for optimizing network data compression based on comparison of write and read rates

Family Cites Families (9)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US5299313A (en) 1992-07-28 1994-03-29 3Com Corporation Network interface with host independent buffer management
KR0170500B1 (en) 1995-11-18 1999-03-30 양승택 Multiprocessor system
JP3601955B2 (en) 1997-10-23 2004-12-15 株式会社日立製作所 Data transfer method and computer system suitable for it
US7620955B1 (en) 2001-06-08 2009-11-17 Vmware, Inc. High-performance virtual machine networking
CN100349142C (en) * 2004-05-25 2007-11-14 中国科学院计算技术研究所 Remote page access method for use in shared virtual memory system and network interface card
US7624157B2 (en) 2004-06-30 2009-11-24 Silicon Laboratories Inc. Ethernet controller with excess on-board flash for microcontroller interface
US7743191B1 (en) 2007-12-20 2010-06-22 Pmc-Sierra, Inc. On-chip shared memory based device architecture
US8793117B1 (en) * 2008-04-16 2014-07-29 Scalable Network Technologies, Inc. System and method for virtualization of networking system software via emulation
US9178839B2 (en) 2008-07-24 2015-11-03 International Business Machines Corporation Sharing buffer space in link aggregation configurations

Patent Citations (8)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US5339392A (en) * 1989-07-27 1994-08-16 Risberg Jeffrey S Apparatus and method for creation of a user definable video displayed document showing changes in real time data
US5557798A (en) * 1989-07-27 1996-09-17 Tibco, Inc. Apparatus and method for providing decoupling of data exchange details for providing high performance communication between software processes
US5966531A (en) * 1989-07-27 1999-10-12 Reuters, Ltd. Apparatus and method for providing decoupled data communications between software processes
US5257369A (en) * 1990-10-22 1993-10-26 Skeen Marion D Apparatus and method for providing decoupling of data exchange details for providing high performance communication between software processes
US20020172199A1 (en) * 2000-12-14 2002-11-21 Scott Steven L. Node translation and protection in a clustered multiprocessor system
US7356026B2 (en) * 2000-12-14 2008-04-08 Silicon Graphics, Inc. Node translation and protection in a clustered multiprocessor system
US7716667B2 (en) * 2003-07-09 2010-05-11 Symantec Operating Corporation Migrating virtual machines among computer systems to balance load caused by virtual machines
US8417833B1 (en) * 2006-11-29 2013-04-09 F5 Networks, Inc. Metacodec for optimizing network data compression based on comparison of write and read rates

Cited By (13)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US9912454B2 (en) * 2015-02-16 2018-03-06 Dell Products L.P. Systems and methods for efficient file transfer in a boot mode of a basic input/output system
US20160239314A1 (en) * 2015-02-16 2016-08-18 Dell Products L.P. Systems and methods for efficient file transfer in a boot mode of a basic input/output system
US9882972B2 (en) 2015-10-30 2018-01-30 International Business Machines Corporation Packet forwarding optimization without an intervening load balancing node
US10839289B2 (en) 2016-04-28 2020-11-17 International Business Machines Corporation Neural network processing with von-Neumann cores
US9916280B2 (en) * 2016-06-09 2018-03-13 International Business Machines Corporation Virtualizing TCP/IP services with shared memory transport
US9977761B2 (en) * 2016-06-09 2018-05-22 International Business Machines Corporation Virtualizing TCP/IP services with shared memory transport
US20180293188A1 (en) * 2017-04-05 2018-10-11 International Business Machines Corporation Low overhead exclusive control for shared memory objects
US20180293186A1 (en) * 2017-04-05 2018-10-11 International Business Machines Corporation Low overhead exclusive control for shared memory objects
US10579550B2 (en) * 2017-04-05 2020-03-03 International Business Machines Corporation Low overhead exclusive control for shared memory objects
US10585818B2 (en) * 2017-04-05 2020-03-10 International Business Machines Corporation Low overhead exclusive control for shared memory objects
US20200387405A1 (en) * 2018-02-24 2020-12-10 Huawei Technologies Co., Ltd. Communication Method and Apparatus
US11500689B2 (en) * 2018-02-24 2022-11-15 Huawei Technologies Co., Ltd. Communication method and apparatus
CN114071222A (en) * 2021-11-15 2022-02-18 深圳Tcl新技术有限公司 Audio and video data sharing device and electronic equipment

Also Published As

Publication number Publication date
CN102651690B (en) 2015-11-25
CN102651690A (en) 2012-08-29
US9356887B2 (en) 2016-05-31
US20120324038A1 (en) 2012-12-20

Similar Documents

Publication Publication Date Title
US9356887B2 (en) Controlling shared memory
CN109976925B (en) Method and system based on mixed multi-system inter-core real-time communication
US11025544B2 (en) Network interface for data transport in heterogeneous computing environments
US10789191B2 (en) Real-time embedded system
JP4597553B2 (en) Computer processor and processor
US11240155B2 (en) Technologies for network device load balancers for accelerated functions as a service
WO2022095634A1 (en) Multi-core processing system and inter-core communication method therefor, and storage medium
US20160117129A1 (en) Disaggregated memory appliance
US11507426B2 (en) Resource pool management method and apparatus, resource pool control unit, and communications device
US9274971B2 (en) Low latency data exchange
US11171831B2 (en) Technologies for autonomous edge compute instance optimization and auto-healing using local hardware platform QoS services
US20220263913A1 (en) Data center cluster architecture
US20190188165A1 (en) Extended mode (xm) bus mode change, configuration register accesses and broadcast / multi-cast transactions to devices on a xm bus
JP6449287B2 (en) Autonomous memory method and system
CN109478168A (en) Internal storage access technology and computer system
WO2017032112A1 (en) Method for communicating with board having no central processing unit and communication device
US20130173835A1 (en) Controlling HDMI Devices Via Intelligent Emulation of Consumer Electronics Control (CEC) Protocol
CN114327930A (en) System architecture for communication between heterogeneous multi-core and operation method of system architecture
WO2021120674A1 (en) Method and apparatus for multi-bus device fused access
US9411763B2 (en) Allocation of flow control credits for high performance devices
US20200021862A1 (en) Multimedia streaming and routing apparatus and operation method of the same
WO2013075445A1 (en) Virtual drive interaction method and device
JP6146306B2 (en) I / O device control system and control method of I / O device control system
WO2020122024A1 (en) Network interface card, computer, circuit information rewriting method and program
JP7049810B2 (en) How computing devices work, including storage devices, modems, switches, and application processors.

Legal Events

Date Code Title Description
AS Assignment

Owner name: INTERNATIONAL BUSINESS MACHINES CORPORATION, NEW Y

Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNORS:CHEN, YING;LI, YAN;TENG, QIMING;AND OTHERS;REEL/FRAME:027733/0641

Effective date: 20120215

STCB Information on status: application discontinuation

Free format text: ABANDONED -- FAILURE TO RESPOND TO AN OFFICE ACTION