Abstract: A system and method for facilitating reuse of a portion of process logic by different processes. An example method includes providing a subprocess that is adapted to perform the process logic in a file accessible to a composite system, wherein the subprocess is adapted to be called by a first parent process via a subprocess extension to a business process language employed to encode the first parent process; using a call activity defined as part of the subprocess extension, and included in a scope of the first parent process to facilitate access to functionality of the subprocess by the parent process; and employing a business process engine to facilitate instantiating the subprocess, resulting in an instantiated subprocess in response thereto; and using a second parent process to share use of the instantiated subprocess with the first parent process.

Abstract: There are provided mechanisms and methods for automating management of Scalable Distributed Persistent Applications (SDPA) in a grid computing environment. These mechanisms and methods make it possible for physical and operating system resources in the grid to be dynamically allocated and/or de-allocated based upon the results of monitoring performance and monitoring usage of physical and operating system resources.

Abstract: A task is marked as dependent upon a preceding task. The task that is attempted to be taken for execution from a head of a pending task queue that is marked is deferred. The deferred task is removed from the pending task queue and placed in a deferred task queue. The deferred task is reinserted back into the pending task queue for execution upon determining that the preceding tasks are completed.

Abstract: Some embodiments provide a system that increases parallelization in a computer program. During operation, the system obtains a binary associative operator and a ordered set of elements associated with a prefix operation in the computer program. Next, the system divides the elements into multiple sets of contiguous iterations based on a number of processors used to execute the computer program. The system then performs, in parallel on the processors, a set of local reductions on the contiguous iterations using the binary associative operator. Afterwards, the system calculates a set of boundary prefixes between the contiguous iterations using the local reductions. Finally, the system applies, in parallel on the processors, the boundary prefixes to the contiguous iterations using the binary associative operator to obtain a set of prefixes for the prefix operation.

Abstract: A computer implemented method for configuring virtual internal networks for testing is provided, such that affects of testing are internally isolated. The method includes deploying a virtual firewall and deploying a public switch enabling access to an external local area network through a first interface of the virtual firewall. A private switch enabling access to a plurality of virtual machines through a second interface of the virtual firewall is provided. The plurality of virtual machines defines a private network behind the firewall. A network address is assigned to the virtual firewall and a private address is assigned to each of the virtual machines. The plurality of virtual machines is then tested through a test launcher in communication with the public switch.

Abstract: Technologies are described herein for using stages for managing dependencies between tasks executed in parallel. A request for permission to execute a task from a group or batch of tasks is received. The specified task is retrieved from a task definition list defining a task ID, stage, and maximum stage for each task in the group. If another pending or currently running task exists with a stage and maximum stage less than the stage defined for the retrieved task, then the retrieved task is not allowed to run. If no other pending or currently running task exists with a stage and maximum stage less than the stage defined for the retrieved task, then the permission to execute the specified task is given.

Abstract: A mechanism for yielding input/output scheduler to increase overall system throughput is described. A method of embodiments of the invention includes initiating a first process issuing a first input/output (I/O) operation. The first process is initiated by a first I/O scheduling entity running on a computer system. The method further includes yielding, in response to a yield call made by the first I/O scheduling entity, an I/O scheduler to a second I/O scheduling entity to initiate a second process issuing a second I/O operation to complete a transaction including the first and second processes, and committing the transaction to a storage device coupled to the computer system.

Abstract: A storage unit stores information indicting the past execution records of a plurality of related tasks. An operating unit obtains information indicating the execution status of a plurality of tasks. After obtaining the information, the operating unit obtains the execution status of an unexecuted task included in the plurality of related tasks, which was not yet executed, at an estimated time by which the unexecuted task is completed and which is estimated based on the information stored in the storage unit.

Abstract: A communication system is applicable to communications between client terminals and a server via the Internet, and includes a communication service unit creating a communication interface and a memory region in response to a communication request from a client terminal via the Internet, starting an application program in the created memory region in response to the communication request, sending contents of the started application program to the client terminal, and updating data in the memory region and sending the updated data to the client terminal when the communication request includes data updating.

Abstract: A dependency datastructure represents a processing task. The dependency datastructure comprising a plurality of components, each component encapsulating a code unit. The dependency datastructure may include dependency arcs to inter-component dependencies. Dependencies that are not satisfied by components within the dependency datastructure may be represented as pseudo-components. An execution environment identifies components that can be executed (e.g., have satisfied dependencies), using the dependency datastructure and/or concurrency state metadata. The execution environment may identify and exploit concurrencies in the processing task, allowing for multiple components to be executed in parallel.

Abstract: Data from one or more sensors is input to a workflow and fragmented to produce HyperFragments. The HyperFragments of input data are processed by a plurality of Distributed Experts, who make decisions about what is included in the HyperFragments or add details relating to elements included therein, producing tagged HyperFragments, which are maintained as tuples in a Semantic Database. Algorithms are applied to process the HyperFragments to create an event definition corresponding to a specific activity. Based on related activity included in historical data and on ground truth data, the event definition is refined to produce a more accurate event definition. The resulting refined event definition can then be used with the current input data to more accurately detect when the specific activity is being carried out.

Abstract: Systems, methods, and machine-readable and executable instructions are provided for mapping application dependencies. Mapping application dependencies can include defining an application model with a number of application dependencies that enables an application to run and defining a platform model that defines a number of capabilities that are provided by a server. Mapping application dependencies can also include creating a topology model that maps the application model to the platform model at runtime by mapping the number of application dependencies to the number of capabilities while the application remains independent from the server.

Abstract: A method of executing an algorithm in a parallel manner using a plurality of concurrent threads includes generating a lock-free barrier that includes a variable that stores both a total participants count and a current participants count. The total participants count indicates a total number of threads in the plurality of concurrent threads that are participating in a current phase of the algorithm, and the current participants count indicates a total number of threads in the plurality of concurrent threads that have completed the current phase. The barrier blocks the threads that have completed the current phase. The total participants count is dynamically updated during execution of the current phase of the algorithm. The generating, blocking, and dynamically updating are performed by at least one processor.

Abstract: A mechanism for migration of client-side virtual machine system resources is described. A method of embodiments includes receiving notification that a virtual machine (VM) is being live migrated from a first server to a second server, connecting client resources associated with the VM to the second server during the live migration of the VM, and maintaining, during the live migration, an active VM connection of the client resources to the first server and an inactive VM connection of the client resources to the second server, the client resources pertaining to a client application and associated with the VM to enable the VM to access the client resources. The method further includes, upon completion of the live migration, disconnecting the active VM connection with the first server and activating the inactive VM connection between the one or more client resources and the second server.

Abstract: A system and method for compiling includes, for a parallelizable code portion of an application stored on a computer readable storage medium, determining one or more variables that are to be transferred to and/or from a coprocessor if the parallelizable code portion were to be offloaded. A start location and an end location are determined for at least one of the one or more variables as a size in memory. The parallelizable code portion is transformed by inserting an offload construct around the parallelizable code portion and passing the one or more variables and the size as arguments of the offload construct such that the parallelizable code portion is offloaded to a coprocessor at runtime.

Abstract: Embodiments relate to systems and methods for a shared object lock under state machine control. An operating system or virtual machine environment can host a set of multiple executing threads, and provide those threads with mutual access to one or more objects such as storage objects, memory objects, or others. The threads can independently request that the object be locked or unlocked, and the locked or unlocked state can be shared between the threads. Rather than communicate with the object(s) directly, in embodiments the threads communicate with a state machine that in turn controls the state of the object(s). When a request to change the state of the object(s) is received, the state machine can permit the object(s) to change between locked, unlocked, or other states based on the current state of the machine and the received message. Contention between threads can be reduced or eliminated.

Abstract: Techniques are described which simplify and/or automate many of the tasks associated with the configuration, deployment, and management of network resources to support cloud-based services.

Abstract: One or more techniques and/or systems are provided for facilitating lifetime management of dynamically created child applications and/or for managing dependencies between a set of applications of an application package. In an example, a parent application may dynamically create a child application. A child lifetime of the child application may be managed independently and/or individually from lifetimes of other applications with which the child application does not have a dependency relationship. In another example, an application within an application package may be identified as a dependency application that may provide functionality depended upon by another application, such as a first application, within the application package. A dependency lifetime of the dependency application may be managed according to a first lifetime of the first application. In this way, lifetimes (e.g., initialization, execution, suspension, termination, etc.

Abstract: The present disclosure provides a method for identifying idleness in a processor via a concurrent software environment. A thread state indicator records an indication of a synchronization state of a software thread that is associated with an identification of the software thread. A time profiler identifies a processor of the computer system being idle and records an indication that the processor is idle. A dispatch monitor identifies a dispatch of the software thread to the processor. In response to the dispatch monitor determining the indication identifies that the processor is idle and the indication of a synchronization state of the software thread indicating the software thread ceases to execute in the processor, the dispatch monitor generates a record attributing the idleness of the processor to the software thread and the indicated synchronization state.

Abstract: A system, method and computer program product to execute a first and a second work-group, and compare the signature variables of the first work-group to the signature variables of the second work-group via a synchronization mechanism. The first and the second work-group are mapped to an identifier via software. This mapping ensures that the first and second work-groups execute exactly the same data for exactly the same code without changes to the underlying hardware. By executing the first and second work-groups independently, the underlying computation of the first and second work-groups can be verified. Moreover, system performance is not substantially affected because the execution results of the first and second work-groups are compared only at specified comparison points.

Abstract: A virtual storage management method that can increase the overall processing speed while preventing a processor from being overloaded. A request for acquisition of a memory area in a primary storage device is received from a process executed by a processor. It is determined whether or not the process that has made the acquisition request is a utility process executable in cooperation with another process. Control is provided so as to restrict swap-out of the utility process when it is determined that the process that has made the received acquisition request is a utility process executable in cooperation with another process, and a process cooperating with the utility process executed by the processor is a preferred process of which swap-out is restricted, and a processor utilization of the preferred process is greater than a predetermined value.

Abstract: A computer-implemented method, program product and system for planning execution of a plurality of tasks according to a plurality of dependencies includes receiving an indication of a task type and execution time, ordering the tasks into a task list according to a primary ordering criterion, receiving an indication of a dependency type for the task type and an indication of a dependency time for the execution time of a predecessor one of the tasks, ordering the dependencies into a dependency list according to the primary ordering criterion, scanning the dependency list for resolving each current one of the dependencies, identifying the predecessor task as a current one of the tasks having the task type meeting the dependency type and the execution time meeting the dependency time, and planning the execution of the tasks according to the resolved dependencies.

Abstract: When different types of shared resources need mutex protection, the shared resources can be organized into classes. Each class of shared resources can have multiple types of resources. A mutex pool can store multiple mutex objects, each mutex object corresponding to a class of resources. The mutex object can be used to protect each shared resource in the corresponding class.

Abstract: Registry information systems and methods are presented. In one embodiment, an application resource switchover method comprises receiving a switchover indication wherein the switchover indication includes an indication to switchover execution of at least one service of an application running on a primary system resource to running on a secondary system resource; performing a switchover preparation process, wherein the switchover preparation process includes automatically generating a switchover plan including indications of switchover operations for performance of a switchover process; and performing the switchover process in which the at least one of the application services is brought up on the secondary system resource in accordance with the plan of switchover operations. In one embodiment, automatically generating a plan of switchover operations includes analyzing the switchover indication, wherein the analyzing includes determining a type of switchover corresponding to the switchover indication.

Abstract: Software development tools and techniques for configuring parallel processing systems to execute software modules implementing processes for solving complex problems, including over-the-counter trading processes and foreign exchange trading processes, to execute quickly and efficiently. The parallel processing system may include low-cost, consumer-grade multicore processing units. A process for solving a complex problem may be divided into software modules, including by evaluating the process to determine discrete processing steps that produce an intermediate result on which later steps of the process depend. The software modules created for a process may form a template processing chain describing multiple processing chains of the process that are to be executed.

Abstract: An illustrative embodiment of an apparatus for interdependent task management selects a task from an execution task dependency chain to form a selected task, wherein a type selected from a set of types including “forAll,” “runOnce” and none is associated with the selected task and determines whether there is a “forAll” task. Responsive to a determination that there is no “forAll” task, determines whether there is a “runOnce” task and responsive to a determination that there is a “runOnce” task further determines whether there is a semaphore for the selected task. Responsive to a determination that there is a semaphore for the selected task, the computer-implemented process determines whether the semaphore is “on” for the selected task and responsive to a determination that the semaphore is “on,” sets the semaphore “off” and executes the selected task.

Abstract: Executing computing tasks on a parallel computer that includes compute nodes coupled for data communications, where each compute node executes tasks, with one task on each compute node designated as a master task, including: for each task on each compute node until all master tasks have joined a global barrier: determining whether the task is a master task; if the task is not a master task, joining a single local barrier; if the task is a master task, joining the global barrier and the single local barrier only after all other tasks on the compute node have joined the single local barrier.

Abstract: An illustrative embodiment of a computer-implemented process for interdependent task management selects a task from an execution task dependency chain to form a selected task, wherein a type selected from a set of types including “forAll,” “runOnce” and none is associated with the selected task and determines whether there is a “forAll” task. Responsive to a determination that there is no “forAll” task, determines whether there is a “runOnce” task and responsive to a determination that there is a “runOnce” task further determines whether there is a semaphore for the selected task. Responsive to a determination that there is a semaphore for the selected task, the computer-implemented process determines whether the semaphore is “on” for the selected task and responsive to a determination that the semaphore is “on,” sets the semaphore “off” and executes the selected task.

Abstract: Embodiments include systems and methods that implement semaphore-based protection of various system resources. In an embodiment, a job scheduling module receives a job execution request from a requesting module (e.g., a CPU or other autonomous module). In response to receiving the job execution request, the job scheduling module identifies a descriptor, where the descriptor includes code configured to access a semaphore-protected resource. The job scheduling module causes a descriptor controller module to execute the descriptor. More specifically, execution of the descriptor includes the descriptor controller module performing a semaphore-based access of the protected resource. The job scheduling module also may coordinate sharing the descriptor among multiple descriptor controller modules (e.g., allowing parallel execution of portions of the descriptor).

Abstract: To coordinate tasks executed by a plurality of threads that each includes plural task sections, a call of a mark primitive to mark a first point after a first of the plural task sections is provided. Also, a call of a second primitive is provided to indicate that a second of the plural task sections is not allowed to begin until after the plurality of threads have each reached the first point.

Abstract: An invention is disclosed for updating a networked, single-threaded application's data model without blocking the application's entire user interface. In embodiments of the invention, a client executes a networked application with a single-threaded user interface that communicates with a server to refresh its data model. The client sends a message to the server that requests a refresh of the data model. Before the data model has been refreshed, the client receives local user input to perform an action on the data model. The client sends a message to the server to cancel the refresh. When the client receives an acknowledgement from the server that the refresh has been cancelled, the client performs the action. After performing the action, the client sends a second message to the server that requests a refresh of the data model, and then refreshes the data model upon receiving the refreshed data model from the server.

Abstract: A multi-core system configured to execute a plurality of tasks and having a semaphore engine and a direct memory access (DMA) engine capable of selecting, by a task scheduler of a first core, a first task for execution by the first core. In response to a semaphore lock request, the task scheduler of the first core switches the first task to an inactive state and selects a next task for execution by the first core. After the semaphore engine acquires the semaphore lock of the first semaphore, a data transfer request is provided to the DMA engine. In response to the data transfer request, the DMA engine transfers data associated with the locked first semaphore to the entry of the workspace of the first core.

Abstract: An approach to managing software components in a datacenter having virtualized components includes maintaining a suitable data construct for representing the virtualized elements. In embodiments, virtualized elements include knowledge relating to instantiations of virtual machines. Management of software components includes traversing a data representation of the datacenter, and assessing the compatibility of the software component with components in the datacenter that relate to the target of the software component.

Abstract: Identifying a collective operation within an application executing on a parallel computer; identifying a call site of the collective operation; determining whether the collective operation is root-based; if the collective operation is not root-based: establishing a tuning session and executing the collective operation in the tuning session; if the collective operation is root-based, determining whether all compute nodes executing the application identified the collective operation at the same call site; if all compute nodes identified the collective operation at the same call site, establishing a tuning session and executing the collective operation in the tuning session; and if all compute nodes executing the application did not identify the collective operation at the same call site, executing the collective operation without establishing a tuning session.

Abstract: To reduce performance degradation due to a high-performance core's waiting for a processing result of a low-performance core in a multi-core processor including a plurality of cores with different running performance, included are a task pool that stores executable tasks for each computational core, a task scheduler, and a reference count analysis module that acquires hint information and a reference count estimation method from a running task and estimates a reference count of a task to be newly inserted into the task pool or a task existing in the task pool based on the specified method. The scheduler performs insertion and acquisition of a task by mainly using performance of the cores and the reference count.

Abstract: The method of calculating the processor utilization for each of logical processors in a computer, including the steps of: dividing the computation interval in which the processor utilization by each logical processor is to be calculated into a single task mode (ST) execution interval and a multitask mode (MT) execution interval, appropriately calculating them based on the before-and-after relation between two times; and adding the MT execution interval multiplied by a predetermined MT mode processor resource assignment ratio to the ST mode execution interval to obtain the processor utilization for the calculation-targeted logical processor in the computation interval.

Abstract: Provide is a processor that can maintain a dependency relationship between a plurality of instructions and one read instruction. The processor comprises: a setting unit configured to set, when an instruction that exists at a location ensuring that writing into a memory area has been completed is executed, usage information indicating whether writing into the memory area has been completed such that the usage information indicates that writing into a memory area during execution of one thread has been completed; and a control unit configured to (i) perform execution of a read instruction to read data stored in the memory area when the usage information indicates that writing into the memory area during execution of the one thread has been completed, and (ii) suppress execution of the read instruction when the usage information indicates that writing into the memory area during execution of the one thread has not been completed.

Abstract: A system and method can support asynchronous message processing in a distributed data grid. A cluster node in the distributed data grid can provide a message processor running on a message processing thread. The message processor can receive a request to process an incoming message from a service thread, wherein the request is associated with a continuation data structure. Then, the message processor can wrap the continuation data structure in a return message after processing the incoming message, and forward the return message to a service queue that is associated with the service thread.

Abstract: Described are techniques for providing access to storage devices. An I/O request directed to a storage device is sent over a network connection from a first computer system to a second computer system. The second computer system includes a simulated computing environment simulating aspects of the first computer system. The I/O request is received at the second computer system. The data storage system is connected to the second computer system over a first connection operating in accordance with a first protocol thereby providing the second computer system access to the storage device of the data storage system. The simulated computing environment of the second computer system may, for example, include emulation capabilities in accordance with the first protocol thereby allowing the second computer system to issue the first I/O request to the first storage device on behalf of the first computer system.

Abstract: A data arrangement calculating system including a master unit and a plurality of slave units connected with said master unit. The master unit includes a data arranging section and a job allocating section. The data arranging section includes a data dividing section and an arranging section configured to arrange a first block of the blocks in a first slave unit of the plurality of slave units as an owner block, and arrange the replica block of a second block of the blocks next to the first block in the first slave unit. The first slave unit includes a data retaining section configured to retain said first block and the replica block of said second block and a job executing section. The job executing section executes the sliding window calculation by using the first block and the replica block of the second block.

Abstract: A facility for guiding users through a series of steps or tasks, often associated with a process, is described. The facility assigns tasks or steps to users having roles identified with the task or step. The role associated with the task or step may change depending on the state of the task or step. When the role associated with a task or step changes, the facility may assign the task or step to another user. The facility guides a user through a task or step by providing instructions and other information, such as data tables and user input fields, that may be used to complete the task or step. The facility provides for the definition of processes by allowing users to specify tasks, steps and instructions relating to processes.

Abstract: Identifying a collective operation within an application executing on a parallel computer; identifying a call site of the collective operation; determining whether the collective operation is root-based; if the collective operation is not root-based: establishing a tuning session and executing the collective operation in the tuning session; if the collective operation is root-based, determining whether all compute nodes executing the application identified the collective operation at the same call site; if all compute nodes identified the collective operation at the same call site, establishing a tuning session and executing the collective operation in the tuning session; and if all compute nodes executing the application did not identify the collective operation at the same call site, executing the collective operation without establishing a tuning session.

Abstract: Example methods and systems are directed to dispatching database tasks. An application may access data associated with a task. The data may indicate features (e.g., processing functionality) that will be used to complete the task. The application may determine whether all such features are implemented in the database layer. The application may dispatch the task to the database layer if all features are implemented therein. The application may perform the task in the application layer if one or more of the features are not available in the database layer. In some example embodiments, the task involves materials requirements planning. Such a task may include determining, for a given bill of materials (“BOM”), the quantity of materials available on-hand, the quantity available from suppliers, the transport or delivery time for the various quantities, and other data regarding the BOM.

Abstract: An example system identifies a set of tasks as being designated for execution, and the set of tasks includes a first task and a second task. The example system accesses task dependency data that corresponds to the second task and indicates that the first task is to be executed prior to the second task. The example system, based on the task dependency data, generates a task dependency model of the set of tasks. The dependency model indicates that the first task is to be executed prior to the second task. The example system schedules an execution of the first task, which is scheduled to use a particular data processing resource. The scheduling is based on the dependency model.

Abstract: Disclosed is an automatic optimization system capable of searching for an allocation with a good performance from among a plurality of task allocations which can be scheduled in a system of a development target configured with a plurality of periodic tasks. A task allocation optimization system for a multi-core processor including a plurality of cores calculates a response time of each of a plurality of tasks which are core allocation decision targets, and outputs an accumulative value of the calculated response time as an evaluation function value which is an index representing excellence of a task allocation. A task allocation from which a good evaluation function value is calculated is searched based on the evaluation function value. A candidate having a good evaluation function value among a plurality of searched task allocation candidates is held.

Abstract: A data processing system (1) is programmed with an interface (2) for capturing events which arise, and a process engine (3) for automatically monitoring captured events to identify completion of steps, each comprising a plurality of events linked by dependency relationships; and to identify completion of processes, each comprising a plurality of steps linked by dependency relationships. Software functions (5) execute in response to output of the process engine (3). The process engine (3) processes events to recognise a plurality of potential steps, but terminates other potential steps when completion of a step is determined. The process engine (3) processes steps to recognise a plurality of potential processes, but terminates other potential process when completion of a process is determined. The dependency relationships include Boolean AND operators and Boolean OR operators. There is a discrete start event for each step and a discrete start step for each process.

Abstract: Processing data includes: receiving units of work that each include one or more work elements, and processing a first unit of work using a first compiled dataflow graph (160) loaded into a data processing system (100) in response to receiving the first unit of work. The processing includes: analysis to determine a characteristic of the first unit of work; identifying one or more compiled dataflow graphs from graphs stored in a data storage system (107) that include at least some that were compiled for processing a unit of work having the determined characteristic; loading one of the identified compiled dataflow graphs into the data processing system (100) as the first compiled dataflow graph (160); and generating one or more output work elements from at least one work element in the first unit of work.

Abstract: A stream application uses small chunks of executable code configured to process data tuples flowing into a processing element. A scheduler allocates the processing elements to individual compute nodes or hosts for execution. However, the stream application may assign various constraints that stipulate which hosts are suitable for a particular processing element. If a host meets the constraints, it may be categorized as an unconditional candidate host. In addition, the scheduler may also track conditional candidate hosts that would be suitable for the processing element if a certain user action is performed—e.g., modifying a constraint, removing a constraint, modifying a stream element, and the like. The list of conditional candidate hosts may then be displayed to the user who can choose to perform the one or more actions to change the conditional candidate host to an unconditional candidate host for the processing element.

Abstract: The present invention relates to a data broadcast processing device, method, and program which enable secure control of an operation of a data broadcast processing device. Since a flag standalone is not set in a script NCL Script 133, the script NCL Script 133 is executed from time t13 till time t15, simultaneously with a script NCL Script 132 and a script NCL Script 134. In contrast, a script NCL Script 135, in which the flag standalone is set, is prohibited from being executed simultaneously with another script NCL Script 134 in which the flag standalone is set.

Abstract: A method for scheduling tasks to processor cores of a parallel computing system may include the steps of processing a source code which comprises at least one parallel lambda function having a function body called by a task and having a capture list specifying the data structures accessed in the function body of said parallel lambda function and used to derive data location information; executing the task calling said function body on the processor core which is associated to a memory unit of the parallel computing system where the data of the data structures specified by said capture list is stored, wherein the memory unit is selected or localized based on the derived data location information.