Abstract: An approach for composing an analytic solution is provided. After associating descriptive schemas with web services and web-based applets, a set of input data sources is enumerated for selection. A desired output type is received. Based on the descriptive schemas that specify required inputs and outputs of the web services and web-based applets, combinations of web services and web-based applets are generated. The generated combinations achieve a result of the desired output type from one of the enumerated input data sources. Each combination is derived from available web services and web-based applets. The combinations include one or more workflows that provide an analytic solution. A workflow whose result satisfies the business objective may be saved. Steps in a workflow may be iteratively refined to generate a workflow whose result satisfies the business objective.

Abstract: There is provided a method of providing a template virtual machine. An exemplary method comprises creating a template virtual machine comprising an image of an operating system and software running on the operating system. The template virtual machine does not include machine-specific identifiers. The template virtual machine is booted into a virtual machine environment. Subsequently, machine-specific identifiers for the template virtual machine are updated. The template virtual machine may then be booted with machine-specific identifiers into a service instance to perform a function determined by the software running on the operating system such that uniform code pages representing the operating system and software running on the operating system are shared among virtual machines in the virtual machine environment.

Abstract: A script server architecture is disclosed herein. The script server architecture includes a core comprising means for creating a DOM node in a HTML document, a framework written in JavaScript, the framework comprising a plurality of registered event handlers for performing the business logic of the script server architecture and means for modifying the DOM of a HTML document, and means for bridging the core and the framework.

Abstract: A mechanism for memory change tracking during migration of a virtual machine (VM) with VM-controlled assigned peripherals is disclosed. A method of the invention includes interacting with a VM executed by a hypervisor of a origin host machine in order to cause the VM to prevent a state of a peripheral device controlled by the VM from changing, receiving the state of the peripheral device from at least one of the VM, a memory of the VM, or the peripheral device, and transferring the obtained state of the peripheral device to a destination host machine as part of a migration process of the VM.

Abstract: When an instruction about changing the job execution limit information is made, a policy server determines whether or not the changed job execution limit information indicates that the execution of the job by the job execution unit is not limited. When the changed job execution limit information indicates that the execution of the job is not limited and the setting is made such that the job history information for the job is recorded on the image processing apparatus, the policy server sets the changed job execution limit information to the image processing apparatus.

Abstract: Techniques are disclosed for load balancing in networks such as those networks handling telephony applications. By way of example, a method for directing requests associated with calls to servers in a system comprised of a network routing calls between a plurality of nodes wherein a node participates in a call as a caller or a receiver and wherein a load balancer sends requests associated with calls to a plurality of servers comprises the following steps. A request associated with a node belonging to a group including a plurality of nodes is received. A server is selected to receive the request. A subsequent request is received. A determination is made whether or not the subsequent request is associated with a node belonging to the group. The subsequent request is sent to the server based on determining that the subsequent request is associated with a node belonging to the group.

Abstract: Mechanisms and methods are provided for dynamically increasing resources utilized for processing tasks. These mechanisms and methods for dynamically increasing resources utilized for processing tasks can enable embodiments to adjust processing power utilized for task processing. Further, adjusting processing power can ensure that quality of service goals set for processing tasks are achieved.

Abstract: Embodiments of an event-driven process management and automation system are disclosed. Such system may be particularly appropriate for a multi-tenant environment so that a single process handling flow may be generated for a given process. Because in a multi-tenant environment many different entities may desire to customize or optimize this process handling flow for their particular usage, modifications to the process flow may be easily handled by a non-technical user to realize process modification without incurring additional development costs. Using a multi-level hierarchical inheritance model in accordance with an embodiment of the present invention, a process may be standardized, with focused customization available on a macro and/or micro level.

Abstract: An apparatus and method for a remote debugging proxy. An embodiment of a method for debugging a system includes receiving notification of an event regarding a target system at a first proxy component, requesting information from the target computing system regarding the event, and receiving the information from the target computing system. The event notification is transferred to a debugging component via a second proxy component, and the requested information is transferred to the second proxy component.

Abstract: Method to selectively assign a reduced busy-wait time to threads is described. The method comprises determining whether at least one thread is spinning on a mutex lock associated with a condition variable and assigning, when the at least one thread is spinning on the mutex lock, a predetermined reduced busy-wait time for a subsequent thread spinning on the mutex lock.

Abstract: Object code is generated from an internal representation that includes a plurality of source operands. The generating includes performing for each source operand in the internal representation determining whether a last use has occurred for the source operand. The determining includes accessing a data flow graph to determine whether all uses of a live range have been emitted. If it is determined that a last use has occurred for the source operand, an architected resource associated with the source operand is marked for last-use indication. A last-use indication is then generated for the architected resource. Instructions and the last-use indications are emitted into the object code.

Abstract: A method and system of checkpointing multi-threaded applications, and multi-process application groups on Windows operating systems. In an exemplary embodiment, the method may include creating at least one full checkpoint for each application in an application group, and creating at least one incremental application checkpoint for each application in the application group. Further, each of the at least one incremental application checkpoint may be automatically merged against a corresponding full application checkpoint. Further, checkpointing may be synchronized across all applications in the application group. Further, checkpointing may be configured to perform live migration. In the exemplary embodiment, checkpoints are triggered asynchronously using Asynchronous Procedure Calls (APC).

Abstract: A computer readable medium and method providing checkpointing to Windows application groups, the computer readable medium having computer-executable instructions for execution by a processing system. The computer-executable instructions may be for launching an application and creating one or more application threads, receiving a checkpoint signal by an application thread, and entering a checkpoint Asynchronous Procedure Call (APC) handler at IRQL APC_LEVEL, the APC handler disposed in a kernel module, acquiring an ETHREAD block and user-mode context for the application thread, and examining an execution state of the one or more application threads at a time of the checkpoint signal.

Abstract: While preemptive multitasking has been available for task-driven methods that use multiple call stacks and even-driven methods that use a single call stack, an embodiment of a new method teaches how preemptive multitasking may be achieved in a single call stack for task-driven applications. The new method requires significantly less memory and processing overhead than required to manage multiple call stacks and provides a significant reduction in transition states and lines of application code than required for event-driven methods. The method comprises providing a single call stack, providing a preemptive scheduler, providing a wait operation which is followed by a return to the scheduler, wherein execution context is not preserved, and providing a signal operation which may be invoked synchronously from a task handling function and/or asynchronously from an interrupt routine, whereby the scheduler is invoked and execution context is preserved and subsequently restored by the single call stack.

Abstract: Object code is generated from an internal representation that includes a plurality of source operands. The generating includes performing for each source operand in the internal representation determining whether a last use has occurred for the source operand. The determining includes accessing a data flow graph to determine whether all uses of a live range have been emitted. If it is determined that a last use has occurred for the source operand, an architected resource associated with the source operand is marked for last-use indication. A last-use indication is then generated for the architected resource. Instructions and the last-use indications are emitted into the object code.

Abstract: A server apparatus manages a device driver for enabling any of a plurality of devices to which a plurality of client apparatuses are connected on a network. The server apparatus comprises a storage unit that stores, for each device, a device driver that can be installed to the device in association with the device, a generating unit that generates different tasks for any of the stored device drivers, a creating unit that creates a schedule for executing the generated tasks, and an executing unit that executes the generated tasks based on the created schedule.

Abstract: Task scheduling in cooperative multi-tasking environments is accomplished by a task scheduler that evaluates the relative priority of an executing task and tasks in a queue waiting to be executed. The task scheduler may issue a suspend request to lower priority tasks so that high priority tasks can be executed. Tasks are written or compiled with checks located at opportune locations for suspending and resuming the given task. The tasks under a suspend request continue operation until they reach a check, at which point the task will suspend operation depending on specific criteria. By allowing both the task and the task scheduler to assist in determining the precise timing of the suspension, the multi-tasking environment becomes highly efficient and responsive.

Abstract: A hard real time (HRT) thread scheduler and a non-real time (NRT) thread scheduler for allocating processor resources among HRT threads and NRT threads are disclosed. The HRT thread scheduler communicates with a HRT thread table including a plurality of entries specifying a temporal order for allocating execution cycles to one or more HRT threads. If a HRT thread identified by the HRT thread table is unable to be scheduled during the current execution cycle, the NRT thread scheduler accesses an NRT thread table which includes a plurality of entries specifying a temporal order for allocating execution cycles to one or more NRT threads. In an execution cycle where a HRT thread is not scheduled, the NRT thread scheduler identifies an NRT thread from the NRT thread table and an instruction from the identified NRT thread is executed during the execution cycle.

Abstract: System and method for a method for indicating relative usage of a computer system resource by a plurality of applications each running in an active window, wherein each active window is represented on a taskbar element by a taskbar button, are described. In one embodiment, the method comprises, for each of the active windows, determining a resource usage rate for the application running in the active window, the resource usage rate comprising a percentage of a total system resource usage for which the application accounts; subsequent to the determining, ranking the applications in order of the determined resource usage rates thereof; and redisplaying the taskbar buttons to indicate, via at least one display characteristic, the relative system resource usage rates of the applications.

Abstract: Activations of a plurality of incoming branches may be detected at a synchronization point having a plurality of outgoing branches. A first synchronization may be executed after a first number of activations is detected, and at least one of a plurality of outgoing branches from the synchronization point may be activated, based on the first synchronization. A second synchronization may be executed after a second number of activations is detected, and at least a second one of the plurality of outgoing branches from the synchronization point may be activated, based on the second synchronization.