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.

Abstract: Techniques for executing a batch of one or more workflows on one or more domains are provided. The techniques include receiving a request for workflow execution, sending at least one of one or more individual jobs in each workflow and dependency information to a scheduler, computing, by the scheduler, one or more outputs, wherein the one or more outputs are based on one or more performance objectives, and integrating orchestration of one or more workflows and scheduling of at least one of one or more jobs and one or more data transfers, wherein the integrating is used to execute a batch of one or more workflows based on at least one of one or more outputs of the scheduler, static information and run-time information.

Abstract: A symbolic execution task is dynamically divided among multiple computing nodes. Each of the multiple computing nodes explores a different portion of a same symbolic execution tree independently of other computing nodes. Workload status updates are received from the multiple computing nodes. A workload status update includes a length of a job queue of a computing node. A list of the multiple computing nodes ordered based on the computing nodes' job queue lengths is generated. A determination is made regarding whether a first computing node in the list is underloaded. A determination is made regarding whether a last computing node in the list is overloaded. Responsive to the first computing node being underloaded and the last computing node being overloaded, a job transfer request is generated that instructs the last computing node to transfer a set of one or more jobs to the first computing node.

Abstract: A system initiates multiple instances of a concurrent computing process, establishes a communication channel among the multiple instances, initiates execution of a computational job on the multiple instances, detects an interrupt request on one of the multiple instances, and terminates execution of the computational job while maintaining communication among the multiple instances via the communication channel.

Abstract: Methods and apparatuses for realizing and enabling a requested computational main task by operation of a task manager and a service node. The task manager defines a set of sub-tasks that accomplish the main task, and sends a source code to the service node including a device instruction for a device connected to the service node, to fetch and execute a sub-task from the task manager. The service node then sends the source code to the device which accordingly fetches and executes the sub-task according to the instruction. When the task manager has received enough sub-task results such that the main task has been completed, it returns an aggregated total result of the main task in response to the main task request.

Abstract: A technique for executing normally interruptible threads of a process in a non-preemptive manner includes in response to a first entry associated with a first message for a first thread reaching a head of a run queue, receiving, by the first thread, a first wake-up signal. In response to receiving the wake-up signal, the first thread waits for a global lock. In response to the first thread receiving the global lock, the first thread retrieves the first message from an associated message queue and processes the retrieved first message. In response to completing the processing of the first message, the first thread transmits a second wake-up signal to a second thread whose associated entry is next in the run queue. Finally, following the transmitting of the second wake-up signal the first thread releases the global lock.

Abstract: A resource requirements method and system is provided. The method includes identifying dependencies and calculating a utilization value for a source server. The source server is mapped to an application and a source infrastructure is compared to a target infrastructure. Deficiencies and differences associated with the target infrastructure are determined and dependency requirements for fulfillment in the target infrastructure are generated. The utilization value is compared to a resource capability of the target server and resource requirements for fulfillment on the target server are generated.

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: A method, system, and computer program product for providing asynchronous resumption of a dataflow are provided. The method includes building an executable directed graph from a dataflow that includes multiple interconnected nodes, where at least one of the interconnected nodes is an asynchronous node. The method further includes creating an event flow that includes the asynchronous node and interconnections subsequent to the asynchronous node. The method also includes invoking execution of the executable directed graph, and creating a state object with an identifier associated with the event flow in response to reaching the asynchronous node. The method additionally includes continuing execution of the executable directed graph while avoiding the asynchronous node and the interconnections subsequent to the asynchronous node, and resuming execution of the event flow as identified via the state object upon receiving a response for the asynchronous node.

Abstract: A method for dependency broadcasting through a block organized source view data structure.

Abstract: Among other things, a machine-based method comprises receiving an application specification comprising one or more algorithms. Each algorithm is not necessarily suitable for concurrent execution on multiple nodes in parallel. One or more different object classes are grouped into one or more groups, each being appropriate for executing the one or more algorithms of the application specification. The executing involves data that is available in objects of the object classes. A user is enabled to code an algorithm of the one or more algorithms for one group in a single threaded environment without regard to concurrent execution of the algorithm on multiple nodes in parallel. An copy of the coded algorithm is distributed to each of the multiple nodes, without needing additional coding. The coded algorithm is caused to be executed on each node in association with at least one instance of a group independently of and in parallel to executing the other copies of the coded algorithm on the other nodes.

Abstract: Techniques are disclosed for loading programs efficiently in a parallel computing system. In one embodiment, nodes of the parallel computing system receive a load description file which indicates, for each program of a multiple program multiple data (MPMD) job, nodes which are to load the program. The nodes determine, using collective operations, a total number of programs to load and a number of programs to load in parallel. The nodes further generate a class route for each program to be loaded in parallel, where the class route generated for a particular program includes only those nodes on which the program needs to be loaded. For each class route, a node is selected using a collective operation to be a load leader which accesses a file system to load the program associated with a class route and broadcasts the program via the class route to other nodes which require the program.

Abstract: A method of pausing a plurality of service-oriented application (SOA) instances may include receiving, from an instance of an SOA entering a pause state, an initiation message. The initiation message may include an exit criterion that identifies a business condition that must be satisfied before the instance of the SOA exits the pause state. The method may also include receiving a notification from an event producer, the notification comprising a status of a business event and determining whether the status of the business event satisfies the business condition of the exit criterion. The method may additionally include sending, in response to a determination that the status of the business event satisfies the business condition of the exit criterion, an indication to the instance of the SOA that the business condition has been satisfied such that the instance of the SOA can exit the pause state.

Abstract: A method for providing a service containing facilities in a peer-to-peer network comprising peer devices is provided. The peer devices may be associated with groups, each group being defined by a pre-determined facility. The pre-determined facility may be executed by each peer device associated with a respective group, and a selected peer device of a group executes the respective facility. A sequence of facilities and specifications to be executed is publicized in the peer-to-peer network, on the peer devices executing the respective facility by a peer device requesting the combined service, and the selection of the selected peer devices is carried out according to the publicized sequence and the publicized specifications.

Abstract: In a multiprocessor system with at least two levels of cache, a speculative thread may run on a core processor in parallel with other threads. When the thread seeks to do a write to main memory, this access is to be written through the first level cache to the second level cache. After the write though, the corresponding line is deleted from the first level cache and/or prefetch unit, so that any further accesses to the same location in main memory have to be retrieved from the second level cache. The second level cache keeps track of multiple versions of data, where more than one speculative thread is running in parallel, while the first level cache does not have any of the versions during speculation. A switch allows choosing between modes of operation of a speculation blind first level cache.

Abstract: An input unit of a compiler accepts a second program called by a first program. A converting unit of the compiler converts the accepted second program into a program in which an initialization instruction and a return instruction are additionally written as instructions executed when an error occurs. An execution control unit of an execution controller executes an execution file having the program where the instructions are additionally written by the compiler in cooperation with a predetermined function group. If an error occurs, an error processing unit of the execution controller initializes a resource based on the initialization instruction described in the program in the execution file having the error, and returns to a caller program based on the return instruction.

Abstract: Command sequencing may be provided. Upon receiving a plurality of action requests, an ordered queue comprising at least some of the plurality of actions may be created. The actions may then be performed in the queue's order.

Abstract: The present invention relates to a method and apparatus for parallel computing. According to one embodiment of the present invention, there is provided a job parallel processing method, the job processing at least comprising executing an upstream task in a first phase and executing a downstream task in a second phase. The method comprises: quantitatively determining data dependence between the upstream task and the downstream task; and selecting time for initiating the downstream task at least partially based on the data dependence. There is further disclosed a corresponding apparatus. According to embodiments of the present invention, it is possible to more accurately and quantitatively determine data dependence between tasks during different phases and thus select the right time to initiate a downstream task.

Abstract: A computer system and method are provided to assess a proper degree of parallelism in executing programs to obtain efficiency objectives, including but not limited to increases in processing speed or reduction in computational resource usage. This assessment of proper degree of parallelism may be used to actively moderate the requests for threads by application processes to control parallelism when those efficiency objectives would be furthered by this control.

Abstract: In one embodiment the present invention includes a computer implemented system and method of multithreaded processing on multiple servers. Jobs may be received in a jobs table for execution. Each of a plurality of servers may associate a thread for executing a particular job type. As a job is received in the job table, the associated thread on each server may access the jobs table and pick up the job if the job type for the job is associated with the thread. Jobs may include sequential and parallel tasks to be performed. Sequential job tasks may be performed by one associated thread on one server, while parallel job tasks may be performed by each associated thread on each server. In one embodiment, a metadata table is used to coordinate multithreaded processing across multiple servers.

Abstract: A method of processing threads is provided. The method includes receiving a first thread that accesses a memory resource in a current state, holding the first thread, and releasing the first thread based responsive to a final thread that accesses the memory resource in the current state has been received.

Abstract: An application framework is disclosed for handling predefined events for various application modules executing as threads. Events are received and associated with a thread and an event handling function. Event handling functions are classified as mutually exclusive and non-mutually exclusive. Mutually exclusive functions are blocked while another mutually exclusive function is executing. Event handling functions are processed by setting a corresponding thread to execute the function and placing the thread in a ‘non-wait’ state. Threads in the ‘non-wait’ state are then executed concurrently under the control of a system thread manger and are returned to a ‘wait’ state when the handling function ends. Each such thread maintains the session state throughout use of the application.

Abstract: An application framework is disclosed for receiving requests for access to application modules. A module thread is instantiated and placed in a wait state for each request and the application framework associates a plurality of predefined events with a plurality of event handling functions for each event. Upon receiving a user generated event, the application framework sets a corresponding module thread to execute the corresponding event handling function and changes the thread state to ‘running.’ Threads in the ‘running’ state are executed concurrently under the control of a system thread manger and are returned to a ‘wait’ state when the handling function ends. Each such thread maintains the session state throughout the use of the application.

Abstract: A deadlock preventing apparatus includes a deadlock detecting section 360 configured to detect a lock command causing a deadlock on a program code of application programs 120, 130 and an emergency processing section 180 configured to insert a new lock command and a new unlock command to the program code to encompass a part from a lock command place corresponding to the lock command detected by the deadlock detecting section 360 to an unlock command place.

Abstract: In one embodiment, the present invention includes a method of assigning a location within a shared variable for each of multiple threads and writing a value to a corresponding location to indicate that the corresponding thread has reached a barrier. In such manner, when all the threads have reached the barrier, synchronization is established. In some embodiments, the shared variable may be stored in a cache accessible by the multiple threads. Other embodiments are described and claimed.

Abstract: Various embodiments are directed to computer networks, computer systems, computer-implemented methods, and computer program products for controlling application landscapes. The computer network may comprise an application landscape comprising a plurality of components and at least one sequence of processes which can run in the application landscape and a central control unit comprising a central control mechanism and a repository, wherein the central control unit is operable to control the application landscape and wherein the central control mechanism comprises an activation mechanism operable to check in the sequence of processes for activation in the application landscape.

Abstract: A method and system for processing work items. Information identifying work items from a server responsible for handling work items based on a set of configuration rules is retrieved and stored in a cache that includes N containers. Responsive to a work item request from an application, searching is performed for matching work items in the cache. The work item request specifies n+1 criteria for work items such that n+1 is at least 2, wherein N is a product over a cardinality Ci of criterion i from i=0 through i=n, wherein C0=1 and Ci?2 for i=1 through i=n. Responsive to finding work item(s) matching the work item request, a piece of information is identified to the application the matching work item(s) from the cache. Information identifying work items of an allowable type of work item is stored in a respective container.

Abstract: In some embodiments, the invention involves a system and method to enhance an operating system's ability to schedule ready threads, specifically to select a logical processor on which to run the ready thread, based on platform policy. Platform policy may be performance-centric, power-centric, or a balance of the two. Embodiments of the present invention use temporal characteristics of the system utilization, or workload, and/or temporal characteristics of the ready thread in choosing a logical processor. Other embodiments are described and claimed.

Abstract: A method and an apparatus for a parallel computing program calling APIs (application programming interfaces) in a host processor to perform a data processing task in parallel among compute units are described. The compute units are coupled to the host processor including central processing units (CPUs) and graphic processing units (GPUs). A program object corresponding to a source code for the data processing task is generated in a memory coupled to the host processor according to the API calls. Executable codes for the compute units are generated from the program object according to the API calls to be loaded for concurrent execution among the compute units to perform the data processing task.

Abstract: A method for performing an operation using more than one resource may include several steps: requesting an operation performed by a resource; populating a ring frame with an indirect buffer command packet corresponding to the operation using a method that may include for the resource requested to perform the operation, creating a semaphore object with a resource identifier and timestamp, in the event that the resource is found to be unavailable; inserting a command packet (wait) into the ring frame, wherein the command packet (wait) corresponds to the semaphore object; and submitting the ring frame to the graphics engine.

Abstract: The present invention enables an overlay capability to be invoked on network systems and elements that are designed to support multiple customer bases. Depending on the registered identification of the user, screens and other user interfaces that provide access to functions can be overlaid on the network component and segmented along customer classifications.

Abstract: A system and method for request processing management that includes receiving requests for tasks from a plurality of sources; reviewing the requests by a review group comprising representatives from different functional areas; and identifying at least one functional area for each request for handling the associated request. The requests for tasks from the plurality of sources are received at a single entry point.

Abstract: A scheduling apparatus and method allocate a plurality of works to a plurality of processing cores by transferring a work having no dependency on the execution completion of another work from a dependency queue to a runnable queue, transferring the work from the runnable queue to an idle one of the processing cores for execution, transferring the work executed by the one processing core to a finish queue, where the work becomes designated a finished work, and transferring a work within the dependency queue, having a dependency upon the execution completion of the finished work, to the runnable queue.

Abstract: An apparatus for providing remote services to an integrated information technology environment. The apparatus comprises a remote management platform. The remote management platform comprises a service delivery platform which comprises a plug in module. The plug in module is configurable to comprise a plurality of service functions. The plug in module enables some or all of the plurality of service functions to be selectively enabled.

Abstract: A method for tuning workflow settings in a distributed computing workflow comprising sequential interdependent jobs includes pairing a terminal stage of a first job and a leading stage of a second, sequential job to form an optimization pair, in which data segments output by the terminal stage of the first job comprises data input for the leading stage of the second job. The performance of the optimization pair is tuned by determining, with a computational processor, an estimated minimum execution time for the optimization pair and increasing the minimum execution time to generate an increased execution time. The method further includes calculating a minimum number of data segments that still permit execution of the optimization pair within the increased execution time.

Abstract: It is an object of the present invention to provide a program that can simply input dependency of tasks. The first aspect of the invention relates to a program, especially relates to a higher level language. The program requires only inputs regarding tasks and dependency. Then the program may decide all tasks and dependency such that it can schedule all of the tasks with error-free. After all the tasks are scheduled using the dependency determined using the program of the invention. Each task may be executed by means of other programs or hardware.

Abstract: An information processing system includes a managing unit that sorts a process execution request based on a type of process of the process execution request; a storing unit that stores the sorted process execution request according to the type of process of the process execution request; and a plurality of executing units that are configured to execute a process corresponding to the process execution request stored in the storing unit. At least one executing unit of the plurality of executing units is configured to split the process corresponding to the process execution request stored in the storing unit into a plurality of processes to be executed by at least two other executing units of the plurality of executing units and store in the storing unit a split process execution request including the split processes for prompting the other executing units to cooperatively execute the split processes.

Abstract: This disclosure describes monitoring the execution of jobs in a work plan. In an embodiment, a system maintains a risk level associated with the critical job to represent whether the execution of a job preceding the critical job has a problem, and it maintains the list associated with the critical job so as to quickly identify the preceding job which may cause a delay to the critical job execution.

Abstract: A method for assigning work to a plurality of threads using a primitive data element to partition a work load into a plurality of partitions. A first partition is assigned to a first thread and a second partition is assigned to a second thread of the plurality of threads. A method for improving the concurrency of a multithreaded program by replacing a queue structure storing a plurality of tasks to be performed by a plurality of threads with a partition function. A computer system including a processor unit configured to run a plurality of threads and a system memory coupled to the processor unit that stores a multithreaded program. The multithreaded program workload is partitioned into a plurality of partitions using a primitive data element and a first partition of the plurality of partitions is assigned to a first thread of the plurality of threads for execution.

Abstract: Techniques are provided for restoring thread groups in a cooperative thread array (CTA) within a processing core. Each thread group in the CTA is launched to execute a context restore routine. Each thread group, executes the context restore routine to restore from a memory a first portion of context associated with the thread group, and determines whether the thread group completed an assigned function prior to executing the context restore routine. If the thread group completed an assigned function prior to executing the context restore routine, then the thread group exits the context restore routine. If the thread group did not complete the assigned function prior to executing the context restore routine, then the thread group executes one or more operations associated with a trap handler routine. One advantage of the disclosed techniques is that the trap handling routine operates efficiently in parallel processors.

Abstract: A method, computer program product, and system for performing a hybrid dependency analysis is described. According to an embodiment, a method may include computing, by one or more computing devices, one or more dynamic hints based on a finite set of executions of a computer program. The method may further include performing, by the one or more computing devices, a hybrid dependence analysis of one or more statements of the computer program.

Abstract: A method, computer program product, and system for performing a hybrid dependency analysis is described. According to an embodiment, a method may include computing, by one or more computing devices, one or more dynamic hints based on a finite set of executions of a computer program. The method may further include performing, by the one or more computing devices, a hybrid dependence analysis of one or more statements of the computer program.

Abstract: A method of chaining a plurality of engines for a system on chip (SOC) controller device and a SOC controller device are disclosed herein. The method comprises: generating, at an initiator, a super-descriptor for providing instructions to the plurality of engines of the SOC controller; passing the super-descriptor from the initiator to a first engine of the plurality of engines; and executing a portion of the super-descriptor at each of the plurality of engines in series without the intervention of the initiator.

Abstract: Workflows to be used in managing a computing environment are dynamically and programmatically created and/or activities are invoked, based on the current state of the environment. In creating a workflow, activities are conditionally included in the workflow based on the state of the environment. Different types of workflows may be created.

Abstract: Methods, parallel computers, and computer program products for broadcasting shared variable directory (SVD) information in a parallel computer are provided. Embodiments include a runtime optimizer detecting, by a runtime optimizer of the parallel computer, a change in SVD information within an SVD associated with a first thread. Embodiments also include a runtime optimizer identifying a plurality of threads requiring notification of the change in the SVD information. Embodiments also include the runtime optimizer in response to detecting the change in the SVD information, broadcasting to each thread of the identified plurality of threads, a broadcast message header and update data indicating the change in the SVD information.

Abstract: Among other things, one or more techniques and/or systems for facilitating task completion through inter-application communication and/or for registering a target application for contextually aware task execution are provided. That is, a current application may display content comprising an entity (e.g., a mapping application may display a restaurant entity). One or more actions capable of being performed on the entity may be exposed (e.g., a reserve table action). Responsive to selection of an action, one or more target applications capable of performing the action on the entity may be presented. Responsive to selection of a target application, contextual information for the entity and/or the action may be passed to the target application so that the target application may be launched in a contextually relevant state to facilitate completion of a task. For example, a dinning application may be launched to a table reservation form for the restaurant entity.

Abstract: Methods, parallel computers, and computer program products for requesting shared variable directory (SVD) information from a plurality of threads in a parallel computer are provided. Embodiments include a runtime optimizer detecting that a first thread requires a plurality of updated SVD information associated with shared resource data stored in a plurality of memory partitions. Embodiments also include a runtime optimizer broadcasting, in response to detecting that the first thread requires the updated SVD information, a gather operation message header to the plurality of threads. The gather operation message header indicates an SVD key corresponding to the required updated SVD information and a local address associated with the first thread to receive a plurality of updated SVD information associated with the SVD key. Embodiments also include the runtime optimizer receiving at the local address, the plurality of updated SVD information from the plurality of threads.

Abstract: Application context changes associated with instantiated applications are monitored at a context tracking device. In response to each application context change, relationship context dependency properties between the instantiated applications and application resources associated with the instantiated applications are evaluated. At least one relationship context dependency property that is used by at least one of the instantiated applications is determined to have changed as a result of an application context change. The at least one relationship context dependency property is updated during runtime based upon the application context change.

Abstract: Provided is a method that enables an interpretive engine to execute in a non-homogeneous, multiple processor architecture. Am interpretive engine is modified to identify code native to a target processor that is executing an ISA different than the ISA of the processor executing the interpretive engine. An intermediate function is called to correlate the native code with a processor type and a target processor is identified. A context is created for the native code and the context is either transmitted to the target processor or stored in a memory location such that the target processor may retrieve the context. Once the context is transmitted, the target processor executes the task. Results are either transmitted to the originating processor or placed in memory such that the originating processor can access the result and the originating processor is signaled of the completion of the task.

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 recognize a plurality of potential steps, but terminates other potential steps when completion of a step is determined. The process engine (3) processes steps to recognize 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.