A method for processing shared data, an apparatus, and a server are provided, and relate to the field of communications technologies, so that shared data can be cached across application programs, which facilitates data sharing across applications programs, can reduce a quantity of repeated computations, and helps accelerate a computing speed of a Spark architecture. The method includes: receiving a first instruction; starting a first Spark context for a first application program, to create a DAG of the first application program, and caching the DAG of the first application program in a first area of a first server; receiving a second instruction; starting a second Spark context for a second application program reading m DAGs from the first area; and caching the to-be-cached shareable RDDs in a main memory of a second server, where the shareable RDD is an RDD included in at least two DAGs of the m DAGs.

Embodiments described herein include mechanisms for encapsulating data that needs to be shared between or across processes. These mechanisms include slawx (plural of “slaw”), proteins, and pools. Generally, slawx provide the lowest-level of data definition for inter-process exchange, proteins provide mid-level structure and hooks for querying and filtering, and pools provide for high-level organization and access semantics. Slawx includes a mechanism for efficient, platform-independent data representation and access. Proteins provide a data encapsulation and transport scheme using slawx as the payload. Pools provide structured and flexible aggregation, ordering, filtering, and distribution of proteins within a process, among local processes, across a network between remote or distributed processes, and via longer term (e.g. on-disk, etc.) storage.

A virtual machine (VM) runs on system hardware, which includes a physical network interface device that enables transfer of packets between the VM and a destination over a network. A virtual machine monitor (VMM) exports a hardware interface to the VM and runs on a kernel, which forms a system software layer between the VMM and the system hardware. Pending packets (both transmit and receive) issued by the VM are stored in a memory region that is shared by, that is, addressable by, the VM, the VMM, and the kernel. Rather than always transferring each packet as it is issued, packets are clustered in the shared memory region until a trigger event occurs, whereupon the cluster of packets is passed as a group to the physical network interface device. Optional mechanisms are included to prevent packets from waiting too long in the shared memory space before being transferred to the network. An interrupt offloading mechanism is also disclosed for use in multiprocessor systems such that it is in most cases unnecessary to interrupt the VM in order to request a VMM action, and the need for VMM-to-kernel context transitions is reduced.

A data processing system including a shared memory; a host processor configured to possess an ownership of the shared memory, and process a first task by accessing the shared memory; a processor configured to possess the ownership transferred from the host processor, and process a second task by accessing the shared memory; and a memory controller coupled among the host processor, the processor, and the shared memory, and configured to allow the host processor or the processor to access the shared memory according to the ownership.

One embodiment provides for a general-purpose graphics processing unit comprising a set of processing elements to execute one or more thread groups of a second kernel to be executed by the general-purpose graphics processor, an on-chip memory coupled to the set of processing elements, and a scheduler coupled with the set of processing elements, the scheduler to schedule the thread groups of the kernel to the set of processing elements, wherein the scheduler is to schedule a thread group of the second kernel to execute subsequent to a thread group of a first kernel, the thread group of the second kernel configured to access a region of the on-chip memory that contains data written by the thread group of the first kernel in response to a determination that the second kernel is dependent upon the first kernel.

Examples herein describe techniques for generating dataflow graphs using source code for defining kernels and communication links between those kernels. In one embodiment, the graph is formed using nodes (e.g., kernels) which are communicatively coupled by edges (e.g., the communication links between the kernels). A compiler converts the source code into a bit stream and/or binary code which configure a heterogeneous processing system of a SoC to execute the graph. The compiler uses the graph expressed in source code to determine where to assign the kernels in the heterogeneous processing system. Further, the compiler can select the specific communication techniques to establish the communication links between the kernels and whether synchronization should be used in a communication link. Thus, the programmer can express the dataflow graph at a high-level (using source code) without understanding about how the operator graph is implemented using the heterogeneous hardware in the SoC.

Disclosed herein are a data processing apparatus for pipeline execution acceleration and a method thereof. According to an exemplary embodiment of the present invention, the data processing apparatus for pipeline execution acceleration includes: a processor configured to sequentially execute a first application program and a second application program reading or writing a specific file; and a file system configured to complete a write for a file data for the specific file to a data block previously allocated from the first application program and provide the file data for the specific file to the second application program prior to executing a close call for the specific file from the first application program, when executing a read call for the specific file from the second application program.

According to one embodiment, a computer program embodied on a tangible computer readable medium includes computer code for obtaining baseboard management controller (BMC) access details, computer code for establishing a communication mechanism between a software driver and the BMC, utilizing the BMC access details, and computer code for sending a request between the software driver and the BMC, utilizing the communication mechanism.

A method of filesystem-based communication of computer applications is provided. The method implemented using a filesystem communications interface (FCI) computer device coupled to a first computer and a second computer on which computer applications are installed. The method includes mounting file systems on the first computer and second computer by installing communications interface drivers, receiving a data transfer command that includes a data unit from the first computer, identifying that the data transfer command corresponds to a filesystem-based data transfer protocol, generating another data transfer command by converting the first data transfer command into a first network-based data transfer protocol, receiving the data unit from the first computer, and transmitting, using the second communications interface driver, the data unit to the second computer application by the using a third data transfer command.

A automation system, a computer and method for communicating includes exchanging data, between a first computer, a second computer and at least one automation device over a wide area network via an application-specific protocol, wherein one of the computers has a local network connection to the automation device, the application-specific protocol has an application layer, and the first and second computers execute respective first and second automation programs such that a transparent connection is provided for the automation programs and their application-specific protocol beyond local network boundaries which can be it efficiently, where signaling functions from lower communication layers that are missing are simulated by introducing event loops on both sides of the communication.