Abstract: Fault isolation capabilities made available by user space can be provided for a embedded network storage system without sacrificing efficiency. By giving user space processes direct access to specific devices (e.g., network interface cards and storage adapters), processes in a user space can initiate Input/Output requests without issuing system calls (and entering kernel mode). The multiple user spaces processes can initiate requests serviced by a user space device driver by sharing a read-only address space that maps the entire physical memory one-to-one. In addition, a user space process can initiate communication with another user space process by use of transmit and receive queues similar to transmit and receiver queues used by hardware devices. And, a mechanism of ensuring that virtual addresses that work in one address space reference the same physical page in another address space is used.

Abstract: A sending process maintains a sending process language-specific object in memory in a format that is dictated by a programming language utilized to implement the sending process. The sending process is also configured to cause the sending process language-specific object to be translated to a receiving process language-specific object. The receiving process language-specific object is in a format that is dictated by a programming language utilized to implement a receiving process. The sending process might also expose an application programming interface or another mechanism through which the receiving process can provide data indicating the programming language with which the receiving process has been programmed. The receiving process language-specific object is then transmitted to the receiving process. The receiving process can utilize the receiving process language-specific object directly without deserializing the received object.

Abstract: A technique is specified for configuring an electronic control unit having intercommunicating applications which have been arranged in various partitions and to which differing safety integrity levels have been assigned. According to one method aspect, the communications behaviour of the applications assigned to the differing partitions amongst themselves is analysed, in order to identify data-writing and data-reading applications that are not located in the same partition. Subsequently, a shared memory area for the intercommunicating applications is configured, and a to communications data structure for the applications is generated. The communications data structure is at least partially arranged in the shared memory area.

Abstract: Systems and methods provide a single reader single writer (SRSW) queue structure having entries that can be concurrently accessed in an atomic manner with a single memory access. The SRSW queues may be combined to create more complicated queues, including multiple reader single writer (MRSW), single reader multiple writer (SRMW), and multiple reader multiple writer (MRMW) queues.

Abstract: Two threads may communicate via shared memory using two different modes. In a polling mode, a receiving thread may poll an indicator set by the sending thread to determine if a message is present. In a blocking mode, the receiving thread may wait until a synchronization object is set by the sending thread which may cause the receiving thread to return to the polling mode. The polling mode may have low latency buy may use processor activity of the receiving thread to repetitively check the indictor. The blocking mode may have a higher latency but may allow the receiving thread to enter a sleep mode or perform other activities.

Abstract: Internode data communications in a parallel computer that includes compute nodes that each include main memory and a messaging unit, the messaging unit including computer memory and coupling compute nodes for data communications, in which, for each compute node at compute node boot time: a messaging unit allocates, in the messaging unit's computer memory, a predefined number of message buffers, each message buffer associated with a process to be initialized on the compute node; receives, prior to initialization of a particular process on the compute node, a data communications message intended for the particular process; and stores the data communications message in the message buffer associated with the particular process. Upon initialization of the particular process, the process establishes a messaging buffer in main memory of the compute node and copies the data communications message from the message buffer of the messaging unit into the message buffer of main memory.

Abstract: The present invention relates generally to computer graphics, and more specifically to methods of, and systems for, configuring, controlling and accessing multiple hardware graphics layers that are used to compose a single video display.

Abstract: Multiple logical partitions are provided access to a self-virtualizing input/output device of a data processing system via multiple dedicated partition adjunct instances.

Abstract: Secure marshaling of data via one or more intermediate processes is provided. A source process may create a named shared memory section resulting in a first handle to the shared memory section. The source process may populate the shared memory section with information. An access control list may secure the shared memory section by preventing the one or more intermediate processes from accessing content of the shared memory section, while allowing a target process to access the content. The first handle and a name of the shared memory section may be marshaled to a first intermediate process resulting in a respective new handle to the shared memory section. A last intermediate process may marshal the name to a target process, which may use the name to obtain access to the content of the shared memory section.

Abstract: Some embodiments of the present invention provide a method and system for correlating information regarding an interactive communication. A session application record is provided to store information of a session that represents an interactive communication that is at least between two endpoints. An application programming interface (API) is provided for users to create and manipulate session application records. Application specific data or customized data can be stored with the session application record using a tag that includes a name and value pair. One session application record can be associated with another session application record by using a relation. Any information that is gathered during a session can be accessible even when one of the endpoints is replaced by another endpoint.

Abstract: Scalable session management is achieved by generating a cookie that includes an encrypted session key and encrypted cookie data. The cookie data is encrypted using the session key. The session key is then signed and encrypted using one or more public/private key pairs. The encrypted session key can be decrypted and verified using the same private/public key pair(s). Once verified, the decrypted session key can then be used to decrypt and verify the encrypted cookie data. A first server having the private/public key pair(s) may generate the cookie using a randomly generated session key. A second server having the same private/public key pair(s) may decrypt and verify the cookie even if the session key is not initially installed on the second server. A session key cache may be used to provide session key lookup to save public/private key operations on the servers.

Abstract: Intranode data communications in a parallel computer that includes compute nodes configured to execute processes, where the data communications include: allocating, upon initialization of a first process of a compute node, a region of shared memory; establishing, by the first process, a predefined number of message buffers, each message buffer associated with a process to be initialized on the compute node; sending, to a second process on the same compute node, a data communications message without determining whether the second process has been initialized, including storing the data communications message in the message buffer of the second process; and upon initialization of the second process: retrieving, by the second process, a pointer to the second process's message buffer; and retrieving, by the second process from the second process's message buffer in dependence upon the pointer, the data communications message sent by the first process.

Abstract: Embodiments of the invention relate to message queuing. In one embodiment, a request from an application for retrieving a message from a queue is received. The queue is stored across multiple nodes of a distributed storage system. A preference with respect to message order and message duplication associated with the queue is identified. A message sequence index associated with the queue is sampled based on the preference that has been identified. The message is selected in response to the sampling. The message that has been selected is made unavailable to other applications for a given interval of time, while maintaining the message in the queue. The message is sent to the application.

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: In a computer system having a memory, a processor, and a network interface, a method for listening on multiple conferencing interfaces having the steps of loading a set of transport components into the memory; initializing each transport components of the set of transport components to listen on a particular conferencing interface using the network interface, each transport component of the set of transport components listening to a different conferencing interface; receiving an incoming call signal on the network interface having an incoming conferencing interface; processing the incoming call signal to detect the incoming conferencing interface; and launching an application based on the incoming conferencing interface. Other embodiments are also described.

Abstract: Embodiments described herein enable information sharing between multiple software applications in a way that supports seamless workflow when a user interacts with these applications, even when these applications were not originally designed to coexist within the same workflows. The embodiments enable each application to initiate processes, create notifications, and automate actions based on information from all the connected applications. The application programming interface (API) of each application communicates with a dedicated delegate, and the delegates of the different applications interact with each other by reading and writing into a shared hardware and software environment. The delegates, along with the applications and the shared environment, form a composite application.

Abstract: To facilitate changing a system configuration and allow having high redundancy in a computer system connecting a plurality of nodes. A node includes a CPU and constitutes a computer system. The node executes one or more processes and including predetermined functions. The node includes a shared memory that stores system information including process information related to each process executed by each node, in a state accessible from each process of its own node. In the node, the system information including the process information related to each process of its own node is multicast to the other nodes. A shared memory control process of the node receives the system information multicast from the other nodes and stores the system information in the shared memory.

Abstract: The subject matter of this specification can be embodied in, among other things, a method that includes executing one or more computer applications and ranking the applications according to one or more criteria that change in response to a user's interaction with the applications. State information for certain of the one or more applications is saved and one or more applications are terminated in response to a memory condition. Subsequently, one of the terminated applications is revived using the saved state information.

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 relates to a computer-implemented method, system and non-transitory medium for managing debt instrument. Insuring for a default of a debt is managed by establishing an insuring debt related to an insured debt of a debtor based on an insured debt amount of the insured debt. The debts can be bonds issued by a municipality. A first loss class and a second loss class can be allocated in an insuring trust. A first class holder can be entitled to a payment from the insuring debt based on a debt owed to the first class holder from an established insuring fund of the insuring trust. The insuring fund is used to insure for a default of the insured debt. If the insured debt is not in default, the payment is diverted to the first class holder. Otherwise, the payment is intercepted, and an insuring payment from the insuring fund is paid to a holder of the insured debt to cure the default.

Abstract: A multi-process interactive system is described. The system includes numerous processes running on a processing device. The processes include separable program execution contexts of application programs, such that each application program comprises at least one process. The system translates events of each process into data capsules. A data capsule includes an application-independent representation of event data of an event and state information of the process originating the content of the data capsule. The system transfers the data messages into pools or repositories. Each process operates as a recognizing process, where the recognizing process recognizes in the pools data capsules comprising content that corresponds to an interactive function of the recognizing process and/or an identification of the recognizing process. The recognizing process retrieves recognized data capsules from the pools and executes processing appropriate to contents of the recognized data capsules.

Abstract: A method for preventing a browser timeout resulting from multiple requests sent from a client to a server is provided. In response to receiving a request from the client, an application thread is initialized on the server for submitting data to the client. The application thread is observed using a daemon observation thread. If a loading time of the application thread exceeds a timeout, the application thread is terminated. In response to terminating the application thread, an empty response is sent to the client. In response to receiving the empty response to the client, a determination is made whether to make an additional request to the server.

Abstract: An image processing system including: storage; image processing devices; and job divider dividing an unprocessed job into partial jobs and store them into storage. Each image processing device includes: a first judging part to judge whether partial job stored in the storage can be processed by own device; a transmitter to, if the judgment result is positive, transmit and store first information indicating condition for processing the partial job, to the storage; an obtaining part to obtain second information indicating condition with which another image processing device processes the partial job, from the storage; a second judging part to judge whether own device should process the partial job, in accordance with standard common to the image processing devices, referring to first and second information; and job processor to process the partial job if second judging part judges positively.

Abstract: A communications manager in a telecommunications transaction server communicates service request messages and service response messages between one or more remotely executing service request processes and one or more service applications executing on the transaction server. A main thread in the communications manager monitors connections requests and initializes other threads. A unique logical communications connection is established between one of the service request processes and the communications manager. The communications manager creates both a read thread and a write thread for each logical communication connection that is validated and active. The read thread communicates service request messages from a service request process to an appropriate service application. The write thread communications service response messages from the service application to the service request process that issues the service request message.

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: A graphical program execution environment that facilitates communication between a producer program and a consumer program is disclosed. The producer program may store data in a memory block allocated by the producer program. A graphical program may communicate with the producer program to obtain a reference to the memory block. The graphical program may asynchronously pass the reference to the consumer program, e.g., may pass the reference without blocking or waiting while the consumer program accesses the data in the memory block. After the consumer program is finished accessing the data, the consumer program may asynchronously notify the graphical program execution environment to release the memory block. The graphical program execution environment may then notify the producer program that the block of memory is no longer in use so that the producer program can de-allocate or re-use the memory block.

Abstract: The present invention relates generally to computer operating systems, and more specifically, to operating system calls in a symmetric multiprocessing (SMP) environment. Existing SMP strategies either use a single lock or multiple locks to limit access to critical areas of the operating system to one thread at a time. These strategies suffer from a number of performance problems including slow execution, large software and execution overheads and deadlocking problems. The invention applies a single lock strategy to a micro kernel operating system design which delegates functionality to external processes. The micro kernel has a single critical area, the micro kernel itself, which executes very quickly, while the external processes are protected by proper thread management. As a result, a single lock may be used, overcoming the performance problems of the existing strategies.

Abstract: Systems and methods are provided for controlling a device. In one aspect, a method for controlling a device includes exposing a plurality of virtual device interfaces (13) for a device (11), wherein each virtual device interface (13) enables client control of a discrete function of the device, and controlling concurrent communication between the device (11) and two or more virtual device interfaces (13) operating on a single shared I/O connection (15) using a shared I/O port controlled by a device I/O module (12). The device I/O module (12) enables independent development of multiple device interfaces (13) that can seamlessly and independently operate on a single (physical) device communication connection (15), wherein the device shared I/O (input/output) module (12) implements functions to arbitrate and coordinate I/O activity between the device interfaces (13) and target device (11).

Abstract: An embodiment of the invention pertains to a method of filtering messages in a kernel of an operating system. The method includes receiving message traffic from network and determining information that indicates contents of each message in the kernel. The method also includes selectively passing the message from the kernel to one or more applications based on the information and according to at least one criterion, where the least one criterion is associated with a respective application of the one or more applications.

Abstract: A method and system is disclosed which can enhance the performance of computer systems by altering the operation of the operating system of those computer systems. The invention provides a system and method for making exception-less system calls, decoupling the invocation and execution of system calls, thus avoiding or reducing the direct and indirect overheads associated with making a conventional exception-based system call. The invention can be employed with single core processor systems and with multi-core processor systems, both affording improved temporal execution locality and the later also providing improved spatial execution locality. The system and method can be employed in a wide range of operating systems.

Abstract: The present disclosure involves systems, software, and computer implemented methods for providing high-load business process scalability in cloud-based infrastructures. One process includes operations for receiving a message at a first computer node executing a first business process instance. A second business process instance associated with the message is identified. The message is sent to a messaging queue for retrieval by the second business process instance if the second business process instance is not located at the first computer node.

Abstract: An object of this invention is to enable free customization of a component class executed by an application program. To achieve this object, an information processing apparatus executably stores an application program main body and a class library having a plurality of classes. The apparatus includes a unit which acquires the name of an interface described in the application program main body and the name of a customization point, a unit which acquires the name of an interface stored in the class library and the name of a class belonging to the interface, a unit which generates an instance for each customization point by executing a selected one of the classes belonging to the interface corresponding to the customization point, a unit which embeds the instance at the corresponding customization point, and a unit which executes the application program main body with the instance being embedded.

Abstract: Two threads may communicate via shared memory using two different modes. In a polling mode, a receiving thread may poll an indicator set by the sending thread to determine if a message is present. In a blocking mode, the receiving thread may wait until a synchronization object is set by the sending thread which may cause the receiving thread to return to the polling mode. The polling mode may have low latency buy may use processor activity of the receiving thread to repetitively check the indictor. The blocking mode may have a higher latency but may allow the receiving thread to enter a sleep mode or perform other activities.

Abstract: An approach is provided to allow virtual devices that use a plurality of processors in a multiprocessor systems, such as the BE environment. Using this method, a synergistic processing unit (SPU) can either be dedicated to performing a particular function (i.e., audio, video, etc.) or a single SPU can be programmed to perform several functions on behalf of the other processors in the system. The application, preferably running in one of the primary (PU) processors, issues IOCTL commands through device drivers that correspond to SPUs. The kernel managing the primary processors responds by sending an appropriate message to the SPU that is performing the dedicated function. Using this method, an SPU can be virtualized for swapping multiple tasks or dedicated to performing a particular task.

Abstract: This invention relates to a middleware bridge system, for bridging a kernel space module and a user space middleware having a user space interface, including: a kernel space bridge manager, for providing a kernel space interface to receive function call request from the kernel space module; an user space bridge manager, for bringing a function call relating to the function call request to the user space middleware through the user space interface, and receiving a return data from the user space middleware; wherein the architecture of the kernel space interface is the same with the architecture of the user space interface. The present invention further includes a middleware bridge method thereof.

Abstract: An IC chip, a board, information processing equipment, and a storage medium are provided that can prevent, even when information is transferred between a plurality of programs, leaking of the right protection algorithm of information in connection with the transfer. A security board is included an IC chip having a secure module. The secure module receives an encryption key request signal, and generates a communication encryption key every time when the encryption key request signal is received, the communication encryption key being used to encrypt information to be transferred between a plurality of programs. The number of times the communication encryption key is supplied is counted. If the counted number is equal to or less than a predetermined number, the communication encryption key is supplied to outside. If the counted number exceeds the predetermined number, the supply of the generated communication encryption key to outside is stopped.

Abstract: A method, system and computer program product for transferring data between two applications over a local network connection. The invention establishes a socket connection between the applications and transfers data through the socket connection using a pseudo socket layer interface when the two endpoints of the socket connection are on the same host. Socket application program interface comprises socket buffers for sending and receiving data. A connecting application identifies and establishes a connection with a listening socket, and places data directly in the socket receive buffer of the receiving socket. If the other end of the socket connection is on a remote host, then data is transferred using underlying network facilities.

Abstract: A multi-processor system comprises a sending processor adapted to send a data message, a receiving processor adapted to receive the date message, and a memory unit associated with the receiving processor. The multi-processor system has a size-index table associated with the sending processor, and the sending processor is adapted to map a size of a payload portion of the data message to an index of the size-index table, and to send the data message containing the size, the index and the payload portion to the receiving processor. The multi-processor system also has mapping circuitry associated with the receiving processor. The mapping circuitry is adapted to the map the index contained in the data message received from the sending processor to a pointer, wherein the pointer is associated with a buffer of the memory unit. The receiving processor is adapted to write the payload portion of the received data message to the buffer as indicated by the pointer.

Abstract: A method of virtualizing an application to execute on a plurality of operating systems without installation. The method includes creating an input configuration file for each operating system. The templates each include a collection of configurations that were made by the application during installation on a computing device executing the operating system. The templates are combined into a single application template having a layer including the collection of configurations for each operating system. The collection of configurations includes files and registry entries. The collections also identifies and configures environmental variables, systems, and the like. Files in the collection of configurations and references to those files may be replaced with references to files stored on installation media. The application template is used to build an executable of the virtualized application.

Abstract: A method, system, and computer program product for managing a heterogeneous connection pooling structure. The heterogeneous architecture of pooling management comprises connections having different connection attributes (i.e. different data source properties) that can share a same connection pool (i.e. same connection pool data source). An application requests a connection from data source having a specified data source property. An application server searches a pool module for an available cached connection. If a cached connection is available, the cached connection is automatically selected as a returned connection. A connection reuse protocol and a statement reuse protocol is determined and invoked to reconfigure the cached connection for reuse as a connection between the application and a database server.

Abstract: Various embodiments of a system and method for automatically arranging or positioning objects included in a selected portion of a graphical program are described. A user may select a first portion of the graphical program. The graphical programming development environment may automatically re-arrange the selected first portion of the graphical program without re-arranging the rest of the graphical program. For example, nodes in the first portion of the graphical program may be automatically re-positioned so as to better organize the first portion of the graphical program.

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: Various embodiments of a system and method for automatically arranging or positioning objects in a block diagram of a graphical program are described. The graphical program may include a first plurality of interconnected nodes that visually indicate functionality of the graphical program, where the first plurality of interconnected nodes includes a structure object having a border visually defining a sub-diagram that includes a second plurality of interconnected nodes that visually indicate functionality of the structure object. The method may operate to automatically re-arrange the graphical program. Re-arranging the graphical program may include shifting the structure object and the second plurality of interconnected nodes included in the sub-diagram of the structure object to new locations without re-arranging the second plurality of interconnected nodes with respect to each other.

Abstract: A data processing system with intercepting instructions comprising an operating system for supporting processes, such that the process are associated with one or more resources and the operating system being arranged to police the accessing by processes of resources so as to inhibit a process from accessing resources with which it is not associated. Part of this system is an interface for interfacing between each process and the operating system and a memory for storing state information for at least one process. The interface may be arranged to analyze instructions from the processes to the operating system, and upon detecting an instruction to re-initialize a process cause state information corresponding to that pre-existing state information to be stored in the memory as state information for the re-initialized process and to be associated with the resource.

Abstract: A system and method are described for performing data processing using shared memory. In one embodiment, a request to perform a transaction is received at a memory. The memory includes a shared memory to provide a common access to a plurality of components including a plurality of work processes and a plurality of worker nodes. The request is then cached at the memory and later assigned to an available work process for performance.

Abstract: Various embodiments of a system and method for automatically re-arranging a graphical program are described. The method may operate to receive user input excluding a portion of the graphical program from re-arrangement, and to then automatically re-arrange the graphical program without re-arranging the excluded portion of the graphical program. In various embodiments, the objects in the non-excluded part of the may be re-positioned so as to better organize the graphical program or enable a user to more easily view or understand the graphical program.

Abstract: A host includes an operating system segmented into a user space and a kernel space with a driver. The user space stores a firmware file and the kernel space includes memory. The driver is stored in the kernel space and performs download cycles to download the firmware file to the memory. The device driver, during a first download cycle, transfers a first block of data to the memory. During each download cycle performed subsequent to the first download cycle, the driver is configured to: identify first and second segments of the memory, where data including the first block of data was stored in the first segment during a previous download cycle; copy the data including the first block of data from the first segment to the second segment; and transfer a block of data of the firmware file, not previously stored in the memory, to the second segment.

Abstract: Providing controlled access for a destination in a messaging system includes: selecting a destination for storing messages in a messaging system, one or more of the messages comprising one or more message properties; associating each of a set of message requestors with a set of message selectors; and in response to an access request for the destination from a message requestor, determining the set of said message selectors associated with the message requestor and using the identified set of message selectors to check against messages on the destination comprising a corresponding set of message properties for providing a response to the access request.

Abstract: Internode data communications in a parallel computer that includes compute nodes that each include main memory and a messaging unit, the messaging unit including computer memory and coupling compute nodes for data communications, in which, for each compute node at compute node boot time: a messaging unit allocates, in the messaging unit's computer memory, a predefined number of message buffers, each message buffer associated with a process to be initialized on the compute node; receives, prior to initialization of a particular process on the compute node, a data communications message intended for the particular process; and stores the data communications message in the message buffer associated with the particular process. Upon initialization of the particular process, the process establishes a messaging buffer in main memory of the compute node and copies the data communications message from the message buffer of the messaging unit into the message buffer of main memory.

Abstract: A manager program for managing virtual machines includes a process which receives a notification message indicating an occurrence of an event affecting a data storage unit in a data storage system that supports a shared file system. The notification message might have come from a virtual machine host or resulted from a hardware reconfiguration. The manager program then determines whether another virtual machine host is sharing the data storage unit. The manager program might make this determination by polling each of the virtual machine hosts it manages or by checking information previously collected and stored in a database. If another virtual machine host is sharing the data storage unit, the manager program sends a refresh message to that virtual machine host that causes the virtual machine host to update information relating to the data storage unit in a cache associated with the virtual machine host.