Hypervisor abstraction layer (HAB) socket communication via single copy based on shared memory

Abstract

Aspects of the disclosure are directed to inter-processor socket communication. In accordance with one aspect, the disclosure includes sending a message from a first virtual machine (VM) to a sender buffer using a socket; copying the message from the sender buffer to generate a first message copy; sending the first message copy to a shared memory; and retrieving the first message copy at a second virtual machine (VM).

Description

HYPERVISOR ABSTRACTION LAYER (HAB) SOCKET COMMUNICATION VIA SINGLE COPY BASED ON SHARED MEMORYTECHNICAL FIELD

[0001] This disclosure relates generally to the field of information processing, and, in particular, to a shared memory architecture between virtual machines (VMs) in an information processing system.BACKGROUND

[0002] In information processing, greater throughput and efficiency may be attained by using a virtualization architecture. A virtualization architecture deploys a plurality of virtual machines (VMs) for a plurality of clients onto one physical machine. Each client of each virtual machine (VM) of the plurality of VMs operates independently of other clients. However, in many scenarios, data and information need to be exchanged among the plurality of VMs. Thus, there is a need for an efficient data exchange mechanism in a virtualization architecture.SUMMARY

[0003] The following presents a simplified summary of one or more aspects of the present disclosure, in order to provide a basic understanding of such aspects. This summary is not an extensive overview of all contemplated features of the disclosure, and is intended neither to identify key or critical elements of all aspects of the disclosure nor to delineate the scope of any or all aspects of the disclosure. Its sole purpose is to present some concepts of one or more aspects of the disclosure in a simplified form as a prelude to the more detailed description that is presented later.

[0004] In one aspect, the disclosure provides inter-processor socket communication. Accordingly, the present disclosure discloses an apparatus including: a shared memory configured to receive a first message copy; a sender buffer coupled to the shared memory, the sender buffer configured to send the first message copy to the shared memory; and a first virtual machine (VM) coupled to the sender buffer, the first virtual machine (VM) configured to send a message to the sender buffer.

[0005] In one example, the message copy is a copy of the message. In one example, the apparatus further includes a second virtual machine (VM) coupled to the shared memory, the second virtual machine (VM) configured to retrieve the first message copy from the shared memory. In one example, the apparatus further includes a receiver buffer coupled to the shared memory, the receiver buffer configured to receive a second memory copy from the shared memory. In one example, the shared memory is in a kernel, and the kernel is part of the first virtual machine (VM) .

[0006] Another aspect of the disclosure provides an apparatus including: means for sending a message from a first virtual machine (VM) to a sender buffer using a socket; means for copying the message from the sender buffer to generate a first message copy; means for sending the first message copy to a shared memory; and means for retrieving the first message copy at a second virtual machine (VM) .

[0007] In one example, the apparatus further includes: means for retrieving the first message copy at the second virtual machine (VM) from the shared memory; means for retrieving the first message copy at a receiver; and means for performing one or more preparatory actions for the shared memory after the socket is opened. In one example, the shared memory is in a first kernel and a second kernel.

[0008] Another aspect of the disclosure provides a method including: sending a message from a first virtual machine (VM) to a sender buffer using a socket; copying the message from the sender buffer to generate a first message copy; sending the first message copy to a shared memory; and retrieving the first message copy at a receiver of a second virtual machine (VM) from the shared memory.

[0009] In one example, the message originates at a sender. In one example, the first virtual machine (VM) is hosted by a physical machine using a hypervisor. In one example, the shared memory is in a first kernel. In one example, the first kernel is part of the first virtual machine (VM) . In one example, the shared memory is also in a second kernel.

[0010] In one example, the method further includes retrieving the first message copy at a receiver from the shared memory. In one example, the receiver is the second virtual machine (VM) . In one example, the method further includes retrieving the first message copy from a receive buffer at the socket. In one example, the method further includes retrieving the first message copy from a receive buffer at the socket. In one example, the receive buffer receives a second message copy from the shared memory. In one example, the method  further includes opening the socket. In one example, the method further includes performing one or more preparatory actions for the shared memory after the socket is opened. In one example, the method further includes closing the socket. In one example, the method further includes deallocating the shared memory.

[0011] These and other aspects of the present disclosure will become more fully understood upon a review of the detailed description, which follows. Other aspects, features, and implementations of the present disclosure will become apparent to those of ordinary skill in the art, upon reviewing the following description of specific, exemplary implementations of the present invention in conjunction with the accompanying figures. While features of the present invention may be discussed relative to certain implementations and figures below, all implementations of the present invention can include one or more of the advantageous features discussed herein. In other words, while one or more implementations may be discussed as having certain advantageous features, one or more of such features may also be used in accordance with the various implementations of the invention discussed herein. In similar fashion, while exemplary implementations may be discussed below as device, system, or method implementations it should be understood that such exemplary implementations can be implemented in various devices, systems, and methods.BRIEF DESCRIPTION OF THE DRAWINGS

[0012] FIG. 1 illustrates an example information processing system.

[0013] FIG. 2 illustrates an example virtualization hierarchy.

[0014] FIG. 3 illustrates a first example inter-processor socket communication system.

[0015] FIG. 4 illustrates a second example inter-processor socket communication system.

[0016] FIG. 5 illustrates an example memory allocation timing performance graph.

[0017] FIG. 6 illustrates an example message copy timing performance graph.

[0018] FIG. 7 illustrates a third example inter-processor socket communication system.

[0019] FIG. 8a illustrates a first example open socket sequence.

[0020] FIG. 8b illustrates a second example open socket sequence.

[0021] FIG. 9a illustrates a first example send / receive sequence.

[0022] FIG. 9b illustrates a second example send / receive sequence.

[0023] FIG. 10a illustrates a third example send / receive sequence.

[0024] FIG. 10b illustrates a fourth example send / receive sequence.

[0025] FIG. 11a illustrates a first example close socket sequence.

[0026] FIG. 11b illustrates a second example close socket sequence.

[0027] FIG. 12 illustrates an example flow diagram for implementing inter-processor socket communication.DETAILED DESCRIPTION

[0028] The detailed description set forth below in connection with the appended drawings is intended as a description of various configurations and is not intended to represent the only configurations in which the concepts described herein may be practiced. The detailed description includes specific details for the purpose of providing a thorough understanding of various concepts. However, it will be apparent to those skilled in the art that these concepts may be practiced without these specific details. In some instances, well known structures and components are shown in block diagram form in order to avoid obscuring such concepts.

[0029] While for purposes of simplicity of explanation, the methodologies are shown and described as a series of acts, it is to be understood and appreciated that the methodologies are not limited by the order of acts, as some acts may, in accordance with one or more aspects, occur in different orders and / or concurrently with other acts from that shown and described herein. For example, those skilled in the art will understand and appreciate that a methodology could alternatively be represented as a series of interrelated states or events, such as in a state diagram. Moreover, not all illustrated acts may be required to implement a methodology in accordance with one or more aspects.

[0030] FIG. 1 illustrates an example information processing system 100. In one example, the example information processing system 100 includes a plurality of processors or processing engines such as a central processing unit (CPU) 120, a digital signal processor (DSP) 130, a graphics processing unit (GPU) 140, a display processing unit (DPU) 180, etc. In one example, various other functions in the information processing system 100 may be included such as a support system 110, a modem 150, a memory 160, a cache memory 170 and a video display 190. For example, the plurality of processing engines and various other functions may be interconnected by an interconnection databus 105 to transport data and control information. For example, the memory 160 and / or the cache  memory 170 may be shared among the CPU 120, the GPU 140 and the other processing engines. In one example, the CPU 120 may include a first internal memory which is not shared with the other processing engines. In one example, the GPU 140 may include a second internal memory which is not shared with the other processing engines. In one example, any processing engine of the plurality of processing engines may have an internal memory which is not shared with the other processing engines.

[0031] An information processing system, for example, a computing system with multiple slices (e.g., processing engines) or a system on a chip (SoC) , may include a virtualization architecture. The virtualization architecture deploys a plurality of virtual machines (VMs) onto one physical machine. Each VM of the plurality of VMs may be accessed by a client independently of other clients. That is, each VM is isolated from other VMs to ensure independent operation. In one example, a VM is a separate processing entity which appears as a physical machine to its client but is hosted on the physical machine along with other VMs. The virtualization architecture allows more efficient usage of physical resources by allowing parallel, isolated usage of VMs on a single physical machine.

[0032] FIG. 2 illustrates an example virtualization hierarchy 200. In one example, the virtualization hierarchy 200 includes a plurality of guest operating systems 210, a hypervisor 220 and a physical machine 230. In one example, the plurality of guest operating systems (OS) 210 includes a first guest OS 211 and a second guest OS 212. For example, the first guest OS 211 operates a first VM and the second guest OS 212 operates a second VM. In one example, the hypervisor 220 provides management and operational control of the physical machine 230 on behalf of the plurality of guest OS 210. That is, the hypervisor 220 facilitates the implementation of the first VM and the second VM onto the physical machine 230.

[0033] FIG. 3 illustrates a first example inter-processor socket communication system 300. In one example, a sender 310 (e.g., a first processor) sends a message to a receiver 330 (e.g., a second processor) through a hypervisor abstraction (HAB) socket 320. For example, the sender 310 use the functionality of the HAB socket 320 to transport a message between two processors (e.g., the first processor and the second processor) . In one example, the message is between two operating systems (OS) , e.g., a first OS and a second OS. In one example, a socket is a communication connection endpoint node. For example, the socket serves as a communications portal for the sender 310.

[0034] In one example, a display application may communicate at a high message rate between the sender 310 and the receiver 330, for example, at approximately 300 messages per second. For example, if a number of messages sent at a first time is 10, 026, 403 and a number of messages sent at a second time is 10, 028, 097, where the second time is 5 seconds later than the first time, there are 1694 messages sent in 5 seconds (i.e., a message rate of 338.8 messages per second) . In one example, the HAB socket 320 should be optimized for high message rate communication. One skilled in the art would understand that the message rate disclosed herein is an example, and that other examples of message rates may also be within the scope and spirit of the present disclosure.

[0035] FIG. 4 illustrates a second example inter-processor socket communication system 400. In one example, a sender 410 (e.g., a first processor) sends a message to a receiver 430 (e.g., a second processor) through a bounce buffer 420. In one example, a first message copy 441 is sent from the sender 410 to a sender memory 411. In one example, a second message copy 442 is sent from the sender memory 411 to the bounce buffer 420. In one example, a third message copy 443 is sent from the bounce buffer 420 to a receiver memory 431. In one example, a fourth message copy 444 is sent from the receiver memory 431 to the receiver 430. In one example, the bounce buffer 420 is an interface between a first processor kernel 450 (e.g., including the sender memory 411) and second processor kernel 460 (e.g., including the receiver memory 431) . In one example, a kernel is a core component of an operating system. For example, the kernel includes a direct interface to hardware in a physical machine.

[0036] In one example, to ensure memory isolation between the sender 410 (e.g., first processor) and the receiver 430 (e.g., second processor) , the sender 410 and the receiver 430 each cannot directly access a memory associated with the other. In one example, when a message needs to be transported between the sender 410 and the receiver 430, a source OS copies the message from the sender memory 411 to the bounce buffer 420 first, then a destination OS copies the message from the bounce buffer 420 to the receiver memory 431.

[0037] In one example, the second inter-processor socket communication system 400 requires a total of four copies of the message between the sender 410 and the receiver 430. In one example, the entire message transfer requires one memory allocation. In one example, the memory allocation is executed using an allocate memory directive from the bounce buffer  420 to the receiver memory 431. In one example, the entire message sending-receiving sequence involves multiple memory operations. For example, as a consequence, system resource usage (i.e., processor bandwidth, memory bus bandwidth, etc. ) of each message transfer is heavy.

[0038] FIG. 5 illustrates an example memory allocation timing performance graph 500. In one example, the memory allocation timing performance graph 500 includes a memory allocation axis (e.g., horizontal axis) 501 in base two logarithmic byte units and a memory allocation time axis (e.g., vertical axis) 502 in microseconds (i.e., μs) . Shown, for example, are a minimum memory allocation time trace 511, a mean memory allocation time trace 512 and a maximum memory allocation time trace 513. For example, the memory allocation timing performance graph 500 was generated using a standard memory allocation benchmark test on a processor in an idle state for a total of 10, 000 iterations.

[0039] For example, a maximum memory allocation time of 34 μs is recorded for a memory allocation of 512 bytes (i.e., 9 in base two logarithmic units) . For example, a maximum memory allocation time of > 100 μs is recorded for a memory allocation of 64 kilobytes (i.e., 16 in base two logarithmic units) . For example, an average memory allocation time of > 1 μs is recorded for a memory allocation of 16 kilobytes (i.e., 14 in base two logarithmic units) . In one example, a HAB socket may operate in a high traffic load scenario where the memory allocation time exceeds the values shown in FIG. 5.

[0040] FIG. 6 illustrates an example message copy timing performance graph 600. In one example, the message copy timing performance graph 600 includes a memory allocation axis (e.g., horizontal axis) 601 in base two logarithmic byte units and a message copy time axis (e.g., vertical axis) 602 in microseconds (i.e., μs) . Shown, for example, are a minimum message copy time trace 611, a mean message copy time trace 612 and a maximum message copy time trace 613. For example, the message copy timing performance graph 600 was generated using a standard message copy benchmark test on a processor in an idle state for a total of 10, 000 iterations.

[0041] For example, a maximum message copy time of 38 μs is recorded for a message copy of 256 bytes (i.e., 8 in base two logarithmic units) . For example, a maximum message copy time of 60 μs is recorded for a message copy of 4 kilobytes (i.e., 12 in base two  logarithmic units) . For example, an average message copy time of > 1 μs is recorded for a message copy of 16 kilobytes (i.e., 14 in base two logarithmic units) . In one example, a HAB socket may operate in a high traffic load scenario where the message copy time exceeds the values shown in FIG. 6. In one example, a target address during memory testing is in a kernel space. In one example, the target address is in a user space, where more time may be required to perform a message copy and a memory page fault may occur.

[0042] FIG. 7 illustrates a third example inter-processor socket communication system 700. In one example, a sender 710 (e.g., a first processor) sends a message to a receiver 730 (e.g., a second processor) through a shared memory 720. In one example, the shared memory 720 is memory mapped to a user space 721. In one example, a first message copy 741 is sent from the sender 710 to the shared memory 720. In one example, a second message copy 742 is sent from the user space 721 to the receiver 730 using the memory mapping from the shared memory 720 to the user space 721. In one example, the shared memory 720 is an interface between a first processor kernel 750 and second processor kernel 760. In one example, the shared memory 720 serves as a socket for the sender 710. In one example, the first processor kernel 750 provides a first virtual machine (VM) for the sender 710. In one example, the second processor kernel 760 provides a second virtual machine (VM) for the receiver 730.

[0043] In one example, for improved message delivery efficiency, a hypervisor may reserve a portion of the shared memory 720. In one example, both the sender 710 and the receiver 730 may access the shared memory 720 without violating isolation between the first processor kernel 750 and the second processor kernel 750. In one example, since the shared memory 720 is managed by the hypervisor, the shared memory 720 may be memory mapped to the user space 721.

[0044] In one example, the hypervisor may allocate the shared memory 720 for a virtual channel as needed. In one example, a memory mapping of the shared memory 720 to the user space 721 allows direct access to the shared memory 720 by the receiver 730.

[0045] In one example, the sender 710 only needs to send a first message copy to the shared memory 720. In one example, the receiver 730 may directly access the first message copy in the shared memory 720 such that a quantity of copies needed for each message is one (e.g., instead of four copies illustrated in FIG. 4) . Alternatively, in one example, the  receiver 730 may instead copy the first message copy to create a second message copy in a receiver buffer memory such that a quantity of copies needed for each message is two (e.g., instead of four copies illustrated in FIG. 4) . In one example, for message delivery, the memory allocation may be required only once.

[0046] FIG. 8a illustrates a first example open socket sequence 800. In one example, open a socket at block 801. For example, the socket may be a hypervisor abstraction (HAB) socket. In one example, indicate a successful socket opening at block 802. For example, the indication may be a status signal or a memory state.

[0047] FIG. 8b illustrates a second example open socket sequence 850. In one example, open a socket at block 851. For example, the socket may be a HAB socket. In one example, allocate a shared memory from pre-reserved memory at block 852. In one example, export and import from the shared memory at block 853. In one example, form a memory map for a receiver at block 854. In one example, indicate a successful socket opening at block 855. For example, the indication may be a status signal or a memory state.

[0048] FIG. 9a illustrates a first example send / receive sequence 900. In one example, send a message to a sender buffer for a socket at block 901. For example, the message originates at a sender. In one example, copy the message from the sender buffer to a HAB buffer at block 902. For example, the sender buffer is in a first kernel 910. In one example, copy the message from the HAB buffer to a bounce buffer at block 903. In one example, allocate memory for a message buffer at block 904. In one example, copy the message from the bounce buffer to the message buffer at block 905. In one example, copy the message from the message buffer to a receive buffer at block 906. For example, the receiver buffer is in a second kernel 920. In one example, retrieve the message from the receive buffer at the socket at block 907. For example, the message is retrieved at a receiver.

[0049] FIG. 9b illustrates a second example send / receive sequence 950. In one example, send a message to a sender buffer for a socket at block 951. For example, the message originates at a sender. In one example, copy the message from the sender buffer to a shared memory at block 952. For example, the shared memory is in a first kernel 970. In one example, retrieve the message from the shared memory at the socket at block 953. For example, the shared memory is also in a second kernel 980. For example, the message is retrieved at a receiver.

[0050] In one example, since a send / receive sequence has a high duty cycle, it is sensitive to timing performance and requires significant resources. In one example, if the receiver does not need to copy the message to a receive buffer, then one copy of the message is needed (i.e., four copies of FIG. 9a are reduced to one copy in FIG. 9b) and no message buffer memory allocation is required.

[0051] FIG. 10a illustrates a third example send / receive sequence 1000. In one example, send a message to a sender buffer for a socket at block 1001. For example, the message originates at a sender. In one example, copy the message from the sender buffer to a HAB buffer at block 1002. For example, the sender buffer is in a first kernel 1010. In one example, copy the message from the HAB buffer to a bounce buffer at block 1003. In one example, allocate memory for a message buffer at block 1004. In one example, copy the message from the bounce buffer to the message buffer at block 1005. In one example, copy the message from the message buffer to a receive buffer at block 1006. For example, the receiver buffer is in a second kernel 1020. In one example, retrieve the message from the receive buffer at the socket at block 1007. For example, the message is retrieved at a receiver.

[0052] FIG. 10b illustrates a fourth example send / receive sequence 1050. In one example, send a message to a sender buffer for a socket at block 1051. For example, the message originates at a sender. In one example, copy the message from the sender buffer to a shared memory at block 1052. For example, the shared memory is in a first kernel 1070. In one example, copy the message from the shared memory to a receive buffer at block 1053. In one example, retrieve the message from the receive buffer at the socket at block 1054. For example, the shared memory is also in a second kernel 1080. For example, the message is retrieved at a receiver.

[0053] In one example, since a send / receive sequence has a high duty cycle, it is sensitive to timing performance and requires significant resources. In one example, if the receiver needs to copy the message to a receive buffer, then two copies of the message are needed (i.e., four copies of FIG. 9a are reduced to two copies in FIG. 9b) and no message buffer memory allocation is required.

[0054] FIG. 11a illustrates a first example close socket sequence 1100. In one example, close a socket at block 1101. For example, the socket may be a hypervisor abstraction (HAB)  socket. In one example, indicate a successful socket closing at block 1102. For example, the indication may be a status signal or a memory state.

[0055] FIG. 11b illustrates a second example close socket sequence 1150. In one example, close a socket at block 1151. For example, the socket may be a HAB socket. In one example, execute a memory unmap for a receiver at block 1152. In one example, de-export and de-import from a shared memory at block 1153. In one example, de-allocate (i.e., free up) a shared memory at block 1154. In one example, indicate a successful socket closing at block 1155. For example, the indication may be a status signal or a memory state.

[0056] FIG. 12 illustrates an example flow diagram 1200 for implementing inter-processor socket communication. In one example, the inter-processor socket communication is between a first virtual machine (VM) and a second virtual machine (VM) , between a guest virtual machine (GVM) and a host machine, or between a GVM and a physical virtual machine (PVM) . In block 1210, open a socket. In one example, the socket is opened. For example, the socket may be a hypervisor abstraction (HAB) socket. In one example, the socket is a communication connection endpoint node. For example, the socket serves as a communications portal for a user. In one example, the socket may include an Internet Protocol (IP) address and a transport layer port address. In one example, the transport layer port address is a Transmission Control Protocol (TCP) port address. In one example, the transport layer port address is a User Datagram Protocol (UDP) port address. In one example, the step of block 1210 may be performed by one of the following: a hypervisor, a processing engine, a CPU or a DPU.

[0057] In block 1220, perform one or more preparatory actions for a shared memory after the socket is opened. In one example, one or more preparatory actions is performed for a shared memory after the socket is opened. In one example, the preparatory actions include allocating a shared memory from pre-reserved memory. In one example, the preparatory actions include exporting and importing from the shared memory. In one example, the preparatory actions include forming a memory map for a receiver. In one example, the preparatory actions include indicating a successful socket opening. For example, the indication may be a status signal or a memory state. In one example, the memory map allows direct access to the shared memory by the receiver. In one example, the step of block 1220 may be performed by one of the following: a memory controller, a hypervisor, a processing engine, a CPU or a DPU.

[0058] In block 1230, send a message from a first virtual machine (VM) to a sender buffer using the socket. In one example, a message from a first virtual machine (VM) is sent to a sender buffer using the socket. For example, the message originates at a sender. In one example, the first VM is hosted by a physical machine using a hypervisor. In one example, the step of block 1230 may be performed by one of the following: a virtual machine, a physical machine, a processing engine, a CPU or a DPU.

[0059] In block 1240, copy the message from the sender buffer to generate a message copy, and send the message copy to the shared memory. In one example, the message is copied from the sender buffer to generate a message copy, and the message copy is sent to the shared memory. A message copy is a copy of the message. In one example, the shared memory is in a first kernel. In one example, the first kernel is part of the first VM. In one example, the message copy is also sent from the shared memory to a receive buffer at the socket. In one example, the step of block 1240 may be performed by one of the following: a sender buffer, a memory or a cache memory.

[0060] In block 1250, retrieve the message copy at a second VM from the shared memory. In one example, the message copy is retrieved at a second VM from the shared memory. In one example, the message copy may be retrieved from the receive buffer at the socket. For example, the shared memory is also in a second kernel. For example, the message is retrieved at a receiver. In one example, the receive buffer receives a second message copy from the shared memory. In one example, the second kernel is part of the second VM. In one example, the second message copy is the same as the message copy. In one example, the second message copy is the same as the message. In one example, the step of block 1250 may be performed by one of the following: a virtual machine, a physical machine, a processing engine, a CPU or a DPU.

[0061] In block 1260, close the socket. In one example, the socket is closed. In one example, the socket closing includes executing a memory unmap for a receiver. In one example, the socket closing includes de-exporting and de-importing from the shared memory. In one example, the socket closing includes de-allocating (i.e., freeing up) the shared memory. In one example, the socket closing includes indicating a successful socket closing. In one example, the step of block 1260 may be performed by one of the following: a hypervisor, a processing engine, a CPU or a DPU.

[0062] In one aspect, one or more of the steps for providing inter-processor socket communication. in FIG. 12 may be executed by one or more processors which may include hardware, software, firmware, etc. The one or more processors, for example, may be used to execute software or firmware needed to perform the steps in the flow diagram of FIG. 12. Software shall be construed broadly to mean instructions, instruction sets, code, code segments, program code, programs, subprograms, software modules, applications, software applications, software packages, routines, subroutines, objects, executables, threads of execution, procedures, functions, etc., whether referred to as software, firmware, middleware, microcode, hardware description language, or otherwise.

[0063] The software may reside on a computer-readable medium. The computer-readable medium may be a non-transitory computer-readable medium. A non-transitory computer-readable medium includes, by way of example, a magnetic storage device (e.g., hard disk, floppy disk, magnetic strip) , an optical disk (e.g., a compact disc (CD) or a digital versatile disc (DVD) ) , a smart card, a flash memory device (e.g., a card, a stick, or a key drive) , a random access memory (RAM) , a read only memory (ROM) , a programmable ROM (PROM) , an erasable PROM (EPROM) , an electrically erasable PROM (EEPROM) , a register, a removable disk, and any other suitable medium for storing software and / or instructions that may be accessed and read by a computer. The computer-readable medium may also include, by way of example, a carrier wave, a transmission line, and any other suitable medium for transmitting software and / or instructions that may be accessed and read by a computer. The computer-readable medium may reside in a processing system, external to the processing system, or distributed across multiple entities including the processing system. The computer-readable medium may be embodied in a computer program product. By way of example, a computer program product may include a computer-readable medium in packaging materials. The computer-readable medium may include software or firmware. Those skilled in the art will recognize how best to implement the described functionality presented throughout this disclosure depending on the particular application and the overall design constraints imposed on the overall system.

[0064] Any circuitry included in the processor (s) is merely provided as an example, and other means for carrying out the described functions may be included within various aspects of the present disclosure, including but not limited to the instructions stored in the computer- readable medium, or any other suitable apparatus or means described herein, and utilizing, for example, the processes and / or algorithms described herein in relation to the example flow diagram.

[0065] Within the present disclosure, the word “exemplary” is used to mean “serving as an example, instance, or illustration. ” Any implementation or aspect described herein as “exemplary” is not necessarily to be construed as preferred or advantageous over other aspects of the disclosure. Likewise, the term “aspects” does not require that all aspects of the disclosure include the discussed feature, advantage or mode of operation. The term “coupled” is used herein to refer to the direct or indirect coupling between two objects. For example, if object A physically touches object B, and object B touches object C, then objects A and C may still be considered coupled to one another-even if they do not directly physically touch each other. The terms “circuit” and “circuitry” are used broadly, and intended to include both hardware implementations of electrical devices and conductors that, when connected and configured, enable the performance of the functions described in the present disclosure, without limitation as to the type of electronic circuits, as well as software implementations of information and instructions that, when executed by a processor, enable the performance of the functions described in the present disclosure.

[0066] One or more of the components, steps, features and / or functions illustrated in the figures may be rearranged and / or combined into a single component, step, feature or function or embodied in several components, steps, or functions. Additional elements, components, steps, and / or functions may also be added without departing from novel features disclosed herein. The apparatus, devices, and / or components illustrated in the figures may be configured to perform one or more of the methods, features, or steps described herein. The novel algorithms described herein may also be efficiently implemented in software and / or embedded in hardware.

[0067] It is to be understood that the specific order or hierarchy of steps in the methods disclosed is an illustration of exemplary processes. Based upon design preferences, it is understood that the specific order or hierarchy of steps in the methods may be rearranged. The accompanying method claims present elements of the various steps in a sample order, and are not meant to be limited to the specific order or hierarchy presented unless specifically recited therein.

[0068] The previous description is provided to enable any person skilled in the art to practice the various aspects described herein. Various modifications to these aspects will be readily apparent to those skilled in the art, and the principles defined herein may be applied to other aspects. Thus, the claims are not intended to be limited to the aspects shown herein, but are to be accorded the full scope consistent with the language of the claims, wherein reference to an element in the singular is not intended to mean “one and only one” unless specifically so stated, but rather “one or more. ” Unless specifically stated otherwise, the term “some” refers to one or more. A phrase referring to “at least one of” a list of items refers to any combination of those items, including single members. As an example, “at least one of: a, b, or c” is intended to cover: a; b; c; a and b; a and c; b and c; and a, b and c. All structural and functional equivalents to the elements of the various aspects described throughout this disclosure that are known or later come to be known to those of ordinary skill in the art are expressly incorporated herein by reference and are intended to be encompassed by the claims. Moreover, nothing disclosed herein is intended to be dedicated to the public regardless of whether such disclosure is explicitly recited in the claims.

[0069] One skilled in the art would understand that various features of different embodiments may be combined or modified and still be within the spirit and scope of the present disclosure.

Claims

1.An apparatus comprising:a shared memory configured to receive a first message copy;a sender buffer coupled to the shared memory, the sender buffer configured to send the first message copy to the shared memory;a first virtual machine (VM) coupled to the sender buffer, the first virtual machine (VM) configured to send a message to the sender buffer; anda second virtual machine (VM) coupled to the shared memory, the second virtual machine (VM) configured to retrieve the first message copy from the shared memory.2.The apparatus of claim 1, wherein the message copy is a copy of the message.3.The apparatus of claim 2, wherein the shared memory is in a kernel and the kernel is part of the first virtual machine (VM) .4.The apparatus of claim 2, further comprising a receiver buffer coupled to the shared memory, the receiver buffer configured to receive a second memory copy from the shared memory.5.An apparatus comprising:means for sending a message from a first virtual machine (VM) to a sender buffer using a socket;means for copying the message from the sender buffer to generate a first message copy;means for sending the first message copy to a shared memory; andmeans for retrieving the first message copy at a second virtual machine (VM) .6.The apparatus of claim 5, further comprising:means for retrieving the first message copy at the second virtual machine (VM) from the shared memory;means for retrieving the first message copy at a receiver; andmeans for performing one or more preparatory actions for the shared memory after the socket is opened.7.The apparatus of claim 6, wherein the shared memory is in a first kernel and a second kernel.8.A method comprising:sending a message from a first virtual machine (VM) to a sender buffer using a socket;copying the message from the sender buffer to generate a first message copy;sending the first message copy to a shared memory; andretrieving the first message copy at a receiver of a second virtual machine (VM) from the shared memory.9.The method of claim 8, wherein the message originates at a sender.10.The method of claim 9, wherein the first virtual machine (VM) is hosted by a physical machine using a hypervisor.11.The method of claim 10, wherein the shared memory is in a first kernel.12.The method of claim 11, wherein the first kernel is part of the first virtual machine (VM) .13.The method of claim 11, wherein the shared memory is also in a second kernel.14.The method of claim 8, further comprising retrieving the first message copy from a receive buffer at the socket.15.The method of claim 14, wherein the receive buffer receives a second message copy from the shared memory.16.The method of claim 14, further comprising opening the socket.17.The method of claim 16 further comprising performing one or more preparatory actions for the shared memory after the socket is opened.18.The method of claim 17, further comprising closing the socket.19.The method of claim 18, further comprising deallocating the shared memory.

Images