Abstract: In embodiments of a programming interface for data communications, a request queue and a completion queue can be allocated from a user-mode virtual memory buffer that corresponds to an application. The request queue and the completion queue can be pinned to physical memory and then mapped to kernel-mode system addresses so that the request queue and the completion queue can be accessed by a kernel-mode execution thread. A request can be received from an application for the kernel to handle data in the request queue, and a system issued to the kernel for the kernel-mode execution thread to handle the request. The kernel-mode execution thread can then handle additional requests from the application without additional system calls being issued.

Abstract: Shared memory and sockets are used to protect shared resources where multiple operating systems execute concurrently on the same hardware. Rather than using spinlocks for serializing access, when a thread is unable to acquire a shared resource because that resource is already held by another thread, the thread creates a socket with which it will wait to be notified that the shared resource has been released. The sockets may be network sockets or in-memory sockets that are accessible across the multiple operating systems; if sockets are not available, communication technology that provides analogous services between operating systems may be used instead. Optionally, fault tolerance is provided to address socket failures, in which case one or more threads may fall back (at least temporarily) to using spinlocks. A locking service may execute on each operating system to provide a programming interface through which threads can invoke lock operations.

Abstract: A a system for relocating a workload partition (WPAR) from a departure logical partition (LPAR) to an arrival LPAR determines an amount of a resource allocated to the relocating WPAR on the departure LPAR and allocates to the relocating WPAR on the arrival LPAR an amount of the resource substantially equal to the amount of the resource allocated to the relocating WPAR on the departure LPAR.

Abstract: A method of pasting data from a source application to a destination application, where the source and destination applications are not the same; the method comprising the steps of: identifying a data type for the data and an appropriate input handler for the data type; converting the data using the appropriate input handle to a standard format based on the data type; in an output module determining the context of the data in the standard format to identify an appropriate output handler; obtaining a suggested paste operation from a suggestion engine based on the type and context of the data; and instructing a paste operation on the basis of the suggested paste operation.

Abstract: A method for determining status of system resources in a computer system includes loading a first operating system into a first memory, wherein the first operating system discovers system resources and reserves a number of the system resources for use of an augmenting operating system, loading the augmenting operating system into a second memory reserved for the augmenting operating system by the first operating system, accessing the first memory from the augmenting operating system and obtaining data, running a process on the augmenting operating system to perform a computation using the data obtained from the first memory, and outputting the results of the computation using the system resources reserved for the augmenting operating system.

Abstract: Methods, apparatus, systems, and computer program products for invoking remote process calls and facilitating inter-process communications in a protected memory system employ a kernel that supports remote invocation of objects by a system call. The system call may include an object identifier and a set of pointers to input and output buffers. The kernel locates the specified object in a separate server process domain and awakens a server thread within the server domain to invoke the object. Using provided memory pointers, the kernel can copy input and output data across the protection domains in a single step without the need for copying data into an intermediate buffer. This eliminates the overhead of multiple data copy steps that are required in conventional protected memory systems.

Abstract: Certain example embodiments relate to techniques for managing the interprocess communication between at least one database client process and at least one database server process in a database system. The at least one database client process sends at least one request to the at least one database server process, with the at least one request comprising one or more buffers. The one or more buffers are transferred, in a single step, from the at least one database client process to a buffer area. The one or more buffers are transferred, in a single step, from the buffer area to the at least one database client process. The buffer area is directly accessible by the at least one database server process.

Abstract: Methods, systems, apparatuses and program products are disclosed for managing multiple OSes within a single computer and the like. Provision is made for swapping OSes with BIOS assistance and conforming with ACPI features for System State management especially as related to ACPI system sleep State S3.

Abstract: A server supporting the implementation of virtual machines includes a local memory used for caching, such as a solid state device drive. During I/O intensive processes, such as a boot storm, a “content aware” cache filter component of the hypervisor of the server first accesses a cache structure in a content cache device to determine whether data blocks have been stored in the cache structure prior to requesting the data blocks from a networked disk array via a standard I/O stack of the hypervisor. The content aware cache filter component is implemented in an I/O virtualization layer of the standard I/O stack that sits above a file system layer of the standard I/O stack, such that any file system protocol may be implemented in the file system layer.

Abstract: A multi-core processor which includes a plurality of processor dies. The multi-core processor has a first processor core which processes a first task and a second processor core which processes a second task. The first processor core and the second processor core are formed on each of the plurality of processor dies. When the first processor core makes a request for the second task processing in processing the first task, information on the second task is stored in a memory area used by the first processor core and interrupt notification is made to each of the second processor cores provided respectively on the plurality of processor dies. Each of the second processor cores having received the interrupt notification accesses the memory area used by the first processor core provided on the same processor die as the processor die on which the second processor core is provided.

Abstract: A method for sharing a resource between multiple processors within a single integrated circuit that share a memory is described. A command structure is built in shared memory by a client on a first processor for a service offered by a second processor, wherein the first processor and second processor have access to the shared memory. Attention from the second processor is requested. The command in shared memory is decoded by a host on the second processor in response to the request for attention. The service is performed on the second processor according to the command. The client on the first processor is notified when the service is complete.

Abstract: A processor includes a plurality of processing sections, each of which executes a predetermined process. A plurality of fault detecting circuits are respectively provided for the plurality of processing sections, to detect a fault in one of the plurality of processing sections as a fault processing section to generate a fault detection signal. A fault monitoring and control section controls a normal processing section as at least one of the plurality of processing sections other than the fault processing section to execute a relieving process in response to the fault detection signal. The relieving process is determined based on a process load of the fault processing section, a process load of the normal processing section, and priority levels of processes to be executed by the fault processing section and the normal processing section.

Abstract: An efficient mechanism for terminating applications of a data processing system is described herein. In one embodiment, in response to a request for exiting from an operating environment of a data processing system, an operating system examines an operating state associated with an application running within the operating environment, where the operating state is stored at a predetermined memory location shared between the operating system and the application. The operating system immediately terminates the application if the operating state associated with the application indicates that the application is safe for a sudden termination. Otherwise, the operating system defers terminating the application if the operating state associated with the application indicates that the application is unsafe for the sudden termination.

Abstract: The invention provides hardware logic based techniques for a set of processing tasks of a software program to efficiently communicate with each other while running in parallel on an array of processing cores of a multi-core data processing system dynamically shared among a group of software programs. These inter-task communication techniques comprise, by one or more task of the set, writing their inter-task communication information to a memory segment of other tasks of the set at the system memories, as well as reading inter-task communication information from their own segments at the system memories. The invention facilitates efficient inter-task communication on a multi-core fabric, without any of the communications tasks needing to know whether and at which core in the fabric any other task is executing at any given time. The invention thus enables flexibly and efficiently running any task of any program at any core of the fabric.

Abstract: A message is efficiently relayed in a cut-through mode to a communication line of the transmission destination of a transmission rate higher than that of the communication line of the recipient while preventing the state that there is no data to be transmitted. A vehicle-mounted relay connection unit is used to relay messages received through first CAN communication lines to a second CAN communication line of a transmission rate higher than that of the first transmission lines in a cut-though mode.

Abstract: An interprocess memory controller is described that may be used to provide multiple processes within a multi-process device with access to a shared physical memory. The described interprocess memory controller may enforce access rights to shared memory that has been allocated to the respective processes, thereby guarding the multi-process device from instability due to the unauthorized overwriting and/or unauthorized freeing of allocated memory. The described interprocess memory controller approach may streamline interprocess communication by allowing data associated with an interprocess communication to be passed from a first process to a second process by passing a pointer as well as access rights to a buffer in shared memory that contains the message data.

Abstract: A computer readable medium and method for providing checkpointing to Windows application groups. The checkpointing may be triggered asynchronously using Asynchronous Procedure Calls. The computer readable medium includes computer-executable instructions for execution by a processing system. The computer-executable instructions may be for reviewing one or more command line arguments to determine whether to start at least one of the application groups, and when determining to start the at least one of the application groups, creating a process table in a shared memory to store information about each process of the at least one of the application groups. Further, the instructions may be for registering with a kernel module to create an application group barrier, creating a named pipe for applications of the application group to register and unregister, triggering a checkpoint thread to initiate an application group checkpoint; and launching an initial application of the applications of the application group.

Abstract: Managing an asynchronous messaging queue with a client computer in an asynchronous messaging system, where the client computer is programmed to store an manage the asynchronous messaging queue, includes receiving a reactive message in the asynchronous messaging queue, the reactive message including an identification of a referenced message and an action to be performed on the referenced message; and performing the action on the previously initiated message with the client computer if the referenced message is present in the asynchronous messaging queue.

Abstract: Described are techniques for communicating between one or more producers and one or more consumers. A first consumer of an event queue registers for notification regarding occurrences of one or more events. A producer of the event queue posts one or more notifications to one or more consumers of the event queue regarding one or more occurrences of one or more events. Each of the consumers receive notification regarding occurrences of events for which the consumer is registered. The first consumer retrieves posted event notifications regarding events for which the first consumer is registered. If the first consumer is executing in user space and an event notification list to which the event notifications for the first consumer are posted is located in shared memory, the first consumer retrieves the posted event notifications without proxying into kernel space.

Abstract: Adapters are provided to convert a decoupled provider interface to a coupled provider interface and/or to convert a coupled provider interface to a decoupled provider interface. A decoupled provider may indirectly expose a data model by providing one or more of a sequence of unchanging views of data via snapshots and snapshot update events. A coupled provider may directly expose a dynamic data model or view and model update events. A decoupled consumer of data may consume data that is provided in snapshots and snapshot update events while a coupled consumer may consume data in the form of a dynamic data model and model update events.

Abstract: A method for enabling access to functionality provided by resources outside of an operating system environment is provided. The method includes: receiving a call for functionality provided by resources outside of the operating system environment; and copying function parameters from within the received call to an area of memory accessible to the resources outside of the operating system environment that provide the called functionality.

Abstract: One embodiment of the present invention provides a system that facilitates using a web-based client-server application offline. During operation, the system receives a function call at an object within a browser that is executing on a client, wherein the function call is generated by the web-based client-server application and is directed to a communication layer on the client. Next, the system determines an intended resource for the function call. The system also determines if the function call should be redirected to an alternate resource. If so, the system redirects the function call to the alternate resource. If not, the system forwards the function call to the intended resource. Note that in some embodiments of the present invention, the entire system operates within the context of the browser.

Abstract: A mechanism is disclosed for enabling multiple processes to share the same portion of physical memory. The first time an instance of a process is executed, a list of common components is compiled. The compiled code is then written into a newly created mappable data structure, which is stored into persistent storage. The next time an instance of that process is executed, the mappable data structure is mapped into a portion of the process instance's virtual memory space. This enables the process instance to invoke the compiled code for the common components. Multiple instances of the process may have their virtual memory spaces mapped to the same mappable data structure in this way. Thereafter, it is up to the operating system to load the contents of the mappable data structure into a portion of physical memory, and to ensure that all of the process instances share that physical memory portion.

Abstract: Technologies for enabling a continuation based runtime to accept or reject external stimulus and, in addition, to determine if an external stimulus may be valid for processing at a later point in execution.

Abstract: 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.

Abstract: Software rendering and fine grained parallelism are utilized to reduce/avoid memory latency in a multi-processor (MP) system. According to one embodiment, the management of the transfer of data from one processor to another in the MP environment is moved into a low overhead hardware system. The low overhead hardware system may be a FIFO (“First In First Out”) hardware control. Each FIFO may be real or virtual.

Abstract: A hypervisor receives a memory page checksum from a guest operating system, which corresponds to a page of memory utilized by the guest. Next, the hypervisor proceeds through a series of steps to detect that the memory page checksum matches a checksum value included in a checksum entry item, which includes an identifier of a different guest. In turn, the hypervisor shares the page of memory between the guest and the different guest in response to detecting that the memory page checksum matches the checksum value included the checksum entry item.

Abstract: A hypervisor receives a memory page checksum from a guest operating system, which corresponds to a page of memory utilized by the guest. Next, the hypervisor proceeds through a series of steps to detect that the memory page checksum matches a checksum value included in a checksum entry item, which includes an identifier of a different guest. In turn, the hypervisor shares the page of memory between the guest and the different guest in response to detecting that the memory page checksum matches the checksum value included the checksum entry item.

Abstract: A method and computer program product for providing Global Attribute Uniqueness (GAU) using an Ordered Message Service (OMS) is presented. A database operation is received from a client. A determination is made regarding whether the operation changes a value to a current value and when the operation would change a value to a current value then operation is ended. When the operation would not change a value to a current value the operation is decomposed into ADD messages and DELETE messages. The ADD messages are sent to a GAU manager and GAU state is checked and updated. The updates are committed to GAU state and the Directory Server (DS) is updated. Operation is then returned to the client. DELETE messages are sent to the GAU manager and GAU state is updated. The updates are then committed.

Abstract: An apparatus for sharing resources between interconnected processes via an interprocess communication may include a processor and a memory storing executable instructions that in response to execution by the processor cause the apparatus to at least perform operations including receiving a request from at least one first process that controls one or more resources. The request may include data requesting assignment of one or more rights to share at least one of the resources with at least a second process. The instructions may further cause the apparatus to assign the rights to share the resource with the second process and remove the rights to share the resource from the second process upon receipt of a first message. Corresponding computer program products and methods are also provided.

Abstract: A data processing system is programmed to provide a method for enabling user-level one-to-all message/messaging (OTAM) broadcast within a distributed parallel computing environment in which multiple threads of a single job execute on different processing nodes across a network. The method comprises: generating one or more messages for transmission to at least one other processing node accessible via a network, where the messages are generated by/for a first thread executing at the data processing system (first processing node) and the other processing node executes one or more second threads of a same parallel job as the first thread. An OTAM broadcast is transmitting via a host fabric interface (HFI) of the data processing system as a one-to-all broadcast on the network, whereby the messages are transmitted to a cluster of processing nodes across the network that execute threads of the same parallel job as the first thread.

Abstract: A network on chip (‘NOC’) that includes IP blocks, routers, memory communications controllers, and network interface controllers, each IP block adapted to the network by an application messaging interconnect including an inbox and an outbox, one or more of the IP blocks including computer processors supporting a plurality of threads, the NOC also including an inbox and outbox controller configured to set pointers to the inbox and outbox, respectively, that identify valid message data for a current thread; and software running in the current thread that, upon a context switch to a new thread, is configured to: save the pointer values for the current thread, and reset the pointer values to identify valid message data for the new thread, where the inbox and outbox controller are further configured to retain the valid message data for the current thread in the boxes until context switches again to the current thread.

Abstract: Described are techniques for intermodule communication between a first code module and a second code module wherein one of the first and second code modules executing in user space and the other of the first and second code modules executing in kernel space. A shared memory portion includes storage for one or more commands. A first first-in-first-out (FIFO) structure is used to send a location in the shared memory portion from the first to the second code module. A second FIFO structure is used for sending a location in the shared memory portion from the second to the first code module. The first code module stores command data for a command at a first location in the shared memory portion. A command is issued from the first to the second code module by sending the first location using the first FIFO structure.

Abstract: A mechanism for enabling a computer which includes an installer for providing Plug and Play (PnP) to obtain information for a network device is provided. Using an existing development resource, such as a PnP installer, a simple installation method is provided. By causing a proxy server to as a communication intermediary between the computer and a peripheral device which is not in compliance with a predetermined management method, the peripheral device can be managed using the predetermined management method.

Abstract: The present invention relates to native and platform-independent software code. In a particular embodiment, the method includes providing a first software program compiled to platform-independent code for execution in a first process of the computer system, providing a second software program compiled to native code for execution in a second process of the computer system, and sending a message from the first process to the second process to request a memory buffer.

Abstract: In general, the invention relates to reclaiming transmit descriptors by configuring a media access control (MAC) to execute a first MAC layer thread to reclaim a first number of transmit descriptors (TDs) from a first hardware transmit ring (HTR) using a first reclaim algorithm, where the first reclaim algorithm is associated with a first transmission pattern and a first TDR status. The invention further includes receiving, by a virtual NIC (VNIC) executing within the MAC layer, a first number of packets, forwarding the first number of packets to a device driver on the host associated with the physical NIC, and forwarding the first number of packets from the device driver to the physical NIC using the first number of TDs, where the first plurality of TDs are reclaimed by the first MAC layer thread according to the first reclaim algorithm.

Abstract: One embodiment of the present invention provides a system that facilitates making an inter-process procedure call through a shared memory that is shared between a client process and a server process, wherein the client makes the inter-process procedure call as if the client is making a local procedure call, but the procedure call actually executes on the server. The system operates by an Application Programming Interface (API) to allow the client to make an inter-process procedure call. The system then allocates a section of the shared memory for the data structure parameters of the inter-process procedure call.

Abstract: A system and a method (100, 500) for integrating an uncertified client (104) with a certified host device (102) are provided. The integration system (100) is configured to integrate the uncertified client (104), which has a plurality of client applications (106), with the certified host device (102), and has a client virtual machine (108), host applications (142), and an abstraction layer (138, 156). The client virtual machine (108) is coupled to the uncertified client (104) and is configured to execute the plurality of client applications (106). The host applications (142) are coupled to the certified host device (102) and are configured to control host dependent features on the certified host device (102). The abstraction layer (138, 156) are coupled to the host applications (142) and to the client virtual machine (108), and are configured to translate feature calls from the plurality of client applications (106) to function calls for the host applications (142).

Abstract: Presence messages are managed for one or more members of a pre-defined group of e-mail users. An unavailability time period, during which a pre-defined group of e-mail users will be unavailable in the future, is established. A notice, which notifies the pre-defined group of e-mail users that an unavailability control instruction will be sent in the future to participating members of the group of e-mail users, is transmitted to the group of e-mail users. An acceptance signal, identifying the participating members, is received, indicating which members of the group of e-mail users agree to permit the unavailability control instruction to be received and implemented on their participating computers in the future. The unavailability control instruction is then transmitted to the participating computers at an initiation of the unavailability time period, in order to auto-generate an appropriate presence message for the participating members.

Abstract: A system and method for hybrid virtual machine monitor system is provided. A first operating system uses a file system to manage data storage and retrieval within a data storage area. A second operating system, which is not compatible with the first operating system's file system, executes a management application backup utility. The first operating system includes a filter driver that sends logical block addresses, which correspond to data reads/writes, to the management application backup utility. In turn, the management application backup utility uses the logical block addresses to perform operations on the data storage locations. In one embodiment, the management application backup utility performs actions on the data storage area, such as a disk defragmentation, and subsequently sends data location changes to the filter driver. In this embodiment, the filter driver instructs the first operating system's file system to update its translation tables based upon the data location changes.

Abstract: A method of mapping processes to processors in a parallel computing environment where a parallel application is to be run on a cluster of nodes wherein at least one of the nodes has multiple processors sharing a common memory, the method comprising using compiler based communication analysis to map Message Passing Interface processes to processors on the nodes, whereby at least some more heavily communicating processes are mapped to processors within nodes. Other methods, apparatus, and computer readable media are also provided.

Abstract: A method is described that involves establishing a connection over a shared memory between a connection manager and a worker node. The shared memory is accessible to multiple worker nodes. Then sending, from the connection manager to the worker node over the connection, a first request containing a method call to a remote object on the worker node. Also sending, from the connection manager to the worker node over the connection, a second request containing a second method call to a second remote object on the worker node.

Abstract: A method and apparatus for offloading processing tasks from a first computing environment to a second computing environment, such as from a first interpreter emulation environment to a second native operating system within which the interpreter is running. The offloading method uses memory queues in the first computing environment that are accessible by the first computing environment and one or more offload engines residing in the second computing environment. Using the queues, the first computing environment can allocate and queue a control block for access by a corresponding offload engine. Once the offload engine dequeues the control block and performs the processing task in the control block, the control block is returned for interrogation into the success or failure of the requested processing task. The offload engine is a separate process in a separate computing environment, and does not execute as part of any portion of the first computing environment.

Abstract: In one embodiment, a plurality of executable instructions is stored at a first software module. The plurality of executable instructions are collectively configured to provide an identifier of a first object instance to a second software module stored at a memory and executed at the processor. The identifier of the first object instance is received at the second software module in response to execution of the plurality of executable instructions and a textual object element identifier is selected from a plurality of textual object element identifiers. Each textual object element identifier from the plurality of textual object element identifiers uniquely associated with an object element. An identifier of a second object instance is accessed and the object element uniquely associated with the textual object element identifier is reflectively accessed at the second object instance. The first object instance derived from the second object instance.

Abstract: A system and method is disclosed for establishing an interactive multimedia application environment in which server-side streaming media may be controlled by a client using a programming model provided at both a communication server and an interactive multimedia runtime on the client. The application program interface (API) preferably provides methods for the client user to establish a stream of data from the client to the communication server in addition to allowing a stream from the communication server to the client. The API also preferably allows the user at a client to exert control over the broadcasting of the media streams. Streams may be built, edited, paused, stopped, augmented, and the like by the client user. Each function that the client user may operate on the broadcast media stream is preferably viewable by all of the other subscribing clients.

Abstract: A target task ensures complete delivery of a global shared memory (GSM) message from an originating task to the target task. The target task's HFI receives a first of multiple GSM packets generated from a single GSM message sent from the originating task. The HFI logic assigns a sequence number and corresponding tuple to track receipt of the complete GSM message. The sequence number is unique relative to other sequence numbers assigned to GSM messages that have not been completely received from the initiating task. The HFI updates a count value within the tuple, which comprises the sequence number and the count value for the first GSM packet and for each subsequent GSM packet received for the GSM message. The HFI determines when receipt of the GSM message is complete by comparing the count value with a count total retrieved from the packet header.

Abstract: An image-data-processing device for processing first image data includes an image processing chip with a first memory and a second memory. The image processing chip further includes a data managing unit and a coding module, wherein the memory space of the second memory is greater than the memory space of the first memory. The data managing unit receives the first image data from an image sensor and transmits the image data to the encoding module, wherein the encoding module generates a second image data based on the first image data received. The data managing unit then selectively stores the second image data in the first memory or the second memory.

Abstract: In one embodiment, a non-transitory processor-readable medium stores code representing instructions that when executed cause a processor operating in an operating system environment that includes a clipboard function that stores information at a first memory location, to receive, from an application, a first request to store content. The code further represents instructions to store, at a second memory location, a content portion indicated by the first request, and receive, from a trusted application, a second request to retrieve the content portion. The code further represents instructions to send, to the trusted application, the content portion.

Abstract: Representative embodiments are disclosed of a system and method for linearly exposing client-server interaction comprising interpreting a function command representing a first group of sequential action requests to an integrated multimedia communication server (iMCS), sequentially transmitting the first group of sequential action requests from an interactive multimedia runtime (iMR) client to the iMCS, wherein a next sequential action request of the first group is transmitted to the iMCS prior to receiving a response message from the iMCS associated with a previous sequential action request of the first group, queuing response messages received from the iMCS, and handling the queued response messages.

Abstract: A system to address resource management and security in a computer system may include an operating system kernel executing on a computer processor. The system may also include a data processing application and a mediator configured to execute on the computer processor. The mediator may operate between the operating system kernel and the data processing application. The mediator may control access of user generated state data of the data processing application and may restrict access of the operating system kernel to the user generated state data.