Abstract: An information processing apparatus includes a management unit configured to manage configuration information indicating a device configuration of the information processing apparatus, a receiving unit configured to receive setting information to be used by the information processing apparatus to perform an operation, from a server, and a control unit configured to control, in a case where setting information stored in the information processing apparatus is updated by using the received setting information, whether to execute processing for causing the information processing apparatus to reflect the update of the setting information, based on a type of the setting information to be updated and the configuration information.

Abstract: A method for managing data includes selecting a first workload, wherein the first workload is implemented on at least a resource device, obtaining a snapshot of performance metrics for the resource device, storing the snapshot of performance metrics in a performance database, making a first determination that a minimum number of previous snapshots have been obtained after a previous performance analysis, and in response to the first determination: performing a performance analysis on a set of previous snapshots of the first workload to obtain a performance report, making a second determination, based on the performance report, that the resource device does not meet standard performance, and in response to the second determination, performing a resource device remediation on the resource device.

Abstract: Time delays used in a reconciliation process can be dynamically adjusted. For example, a system can receive a request from a client for a time delay value. The time delay value can be a timespan in which to wait between a first execution and a second execution of reconciliation software. The request can indicate a result of the first execution. In response to receiving the request, the system can select an algorithm from among a group of algorithms based on the result of the first execution. The system can then determine the time delay value by executing the algorithm. The system can transmit the time delay value to the client, which can wait for the timespan prior to initiating the second execution of the reconciliation software.

Abstract: A method for dispatching tasks on processor cores based on memory access efficiency is disclosed. The method identifies a task and a memory area to be accessed by the task. The method may use one or more of a compiler, code knowledge, and run-time statistics to identify the memory area that is accessed by the task. The method identifies multiple processor cores that are candidates to execute the task and identifies a particular processor core from the multiple processor cores that provides most efficient access to the memory area. The method dispatches the task to execute on the particular processor core that is deemed most efficient. A corresponding system and computer program product are also disclosed.

Abstract: Methods, systems, and computer-readable media for scalable job transformation and management are disclosed. A plurality of tasks expressed in a first format are received at a host. The tasks are associated with a shard identifier based at least in part on one or more criteria, and the tasks are acquired by the host based at least in part on the shard identifier. A subset of the tasks having a common characteristic are determined. The subset of the tasks are aggregated into a job expressed in a second format, where the job represents the subset of the tasks. The job is provided to a job manager, and the subset of the tasks are scheduled for processing using the job manager.

Abstract: An information processing apparatus, an information processing system, and an information processing method, each of which: stores in a memory a retained log which has not been transferred to an external device, among a plurality of logs generated in response to execution of a job; and stop operating the information processing apparatus and reactivate the information processing apparatus, based on a number of retained logs.

Abstract: A task processing method, apparatus, and system based on a distributed system. The method comprises: obtaining, by a task processing device, task information from a master control device by initiating a task request, wherein the task information corresponding to the task request is stored in the master control device; starting, by a main process of the task processing device, a corresponding task subprocess by triggering a proxy process for executing the task information after receiving the task information; and storing, by the task processing device, task execution information to a target location through the proxy process, wherein the task execution information comprises one or more of the following pieces of information: a task identifier of the task information, process information of the task subprocess, log information and a return code generated when the task subprocess executes the task information.

Abstract: Various approaches for allocating resources to an application having multiple application components, with at least one executing one or more functions, in a serverless service architecture include identifying one or more pods having multiple containers organized as a cluster in a container system capable of executing the function(s); identifying one or more routing paths in the serverless service architecture, the routing path being associated with one or more serverless execution entities capable of executing the function(s) thereon; determining (i) traffic information on the routing path(s), (ii) a cost or a performance characteristic associated with a computer resource bundle for the pod(s), and/or (iii) a cost or a performance characteristic associated with the serverless execution entity(entities); and based thereon, determining whether to (i) terminate execution of the function(s) on the pod(s) and (ii) cause execution of the function(s) on the serverless execution entity (entities).

Abstract: Methods, systems, and computer-readable storage media for determining, by an application instance, that first data is to be requested, transmitting, by a total outage compensator of the application instance, one or more requests for the first data to one or more peer application instances, receiving, by the total outage compensator, a response to a request for the first data, the response including the data, and executing, by the instance of the application instance, at least one function based on the first data.

Abstract: A method, computer program product, and computing system for determining a block application execution utilization on a central processing unit (CPU) of the computing device. A non-block application execution utilization on the CPU may be determined. A CPU execution release interval and CPU execution release duration for the block application may be generated based upon, at least in part, the block application execution utilization and the non-block application execution utilization.

Abstract: Systems, apparatuses, and methods to implement time to live for memory access by processors. For example, a processor has a register configured to store a parameter specifying a time duration indicative of the desired time to live. A memory system has multiple components with different latencies for memory access. When the memory controller of the processor sends a command to the memory system to load an item from a memory address, the memory system can fail to provide, to the processor within the time duration, the item from the memory address currently being hosted in a first component. In response, the memory controller can send a signal to abort the command; and the memory system can select a second component having a memory access latency shorter than the first component, and change the hosting of the memory address from in the first component to in the second component.

Abstract: An information processing apparatus includes a memory and a processor. The memory stores a first queue being registered a newly generated task, and a second queue being registered a thread in an executable state among threads assigned to the task. The processor performs a process including: judging execution priority of a second task registered in the first queue and of a second thread registered in the second queue when execution of a first task by a first thread ends, retrieving, if it is judged that the second thread is to be executed first, the second thread from the second queue and executing a task, to which the second thread is assigned, by the second thread, and retrieving, if it is judged that the second task is to be executed first, the second task from the first queue and executing the second task by the first thread.

Abstract: A closed-loop system for asynchronous brain control of at least one task includes a brain state decoder configured to decode neural signals of a user into control signals for controlling the at least one task, a task interface module configured to transmit the control signals to the at least one task, store status information including a series of messages regarding each of the at least one task, and select one message of the series of messages regarding the at least one task to transmit to the user, and a brain state encoder configured to map the one message received from the task interface module into brain state montages for transmission to the user.

Abstract: An orchestrator generated pod specifications for role instances of a bundled application and submits these pod specifications to a KUBERNETES master. The pod specification specifies a node on which to implement a container executing the role instance, the node being selected according to an application manifest that may include affinity and anti-affinity constraints. The pod specification may be implemented by a KUBELET executing on the node, which may invoke interfaces to the orchestrator in order to obtain a network address for the container. A storage volume to be used by the container may have been mounted to the node previously by the orchestrator and be ready for use by the container. Upon failure of the node, the orchestrator generates a new pod specification according to the application manifest that instructs the master to create a new container having a same identity and state as the former container.

Abstract: An accelerator loading apparatus obtains an acceleration requirement, where the acceleration requirement includes an acceleration function and acceleration performance of a to-be-created virtual machine, determines an image that meets the acceleration function and the acceleration performance, and determines a target host in which an available accelerator that can load the image is located, and then sends an image loading command to the target host. The image loading command includes a descriptor of the image, and is used to enable the target host to load the image for the available accelerator. In the method, a target host that can create the virtual machine may be determined based on the acceleration function and the acceleration performance of the to-be-created virtual machine, and an image used for acceleration is loaded to an available accelerator of the target host, to implement dynamic accelerator loading and deployment.

Abstract: In an example, Virtual Machine (VM) attributes of a first VM are received. First VM data corresponding to the first VM is to be moved from a first cluster of nodes in which the first VM data is stored. Further, a movement value of the first VM is determined based on a movement model and the VM attributes of the first VM. The movement model indicates a dependence of movement value of a VM on VM attributes of the VM. The movement value of the first VM is indicative of a rank order for movement of the first VM data among a plurality of sets of VM data to be moved, where each set of VM data corresponds to a VM.

Abstract: Techniques are disclosed for a workflow engine performing a checkpoint phase to determine a result of a merge of workflow updates. The techniques may include the workflow engine determining to allow parallel execution of updates of a workflow. The workflow engine may receive first checkpoint data associated with a first update. The workflow engine may also receive second checkpoint data associated with a second update. The workflow engine may initiate the checkpoint phase that includes comparing one or more data elements of the first checkpoint data with respective data elements of the second checkpoint data; and determining the result of the merge of the workflow updates based on the comparing. The workflow engine may then complete the checkpoint phase and transmit the result to at least one user device for presentation.

Abstract: A data processing system includes one or more computer systems, each executing at least one hypervisor. Host bus adapters on the computer system are connectable to storage resources in at least one storage area network. The at least one hypervisor provides virtual instances of the host bus adapters as virtual host bus adapters, and a world-wide unique port number and a logical unit number are used to access a storage volume. A globally unique identifier is used to identify the storage volume. The system includes a management server comprising a management instance for evaluating a possibility of attaching storage resources to virtual machine instances generated by the hypervisor.

Abstract: Embodiments of the present disclosure relate to loading software resources for execution by a software application. Other embodiments may be described and/or claimed.

Abstract: The disclosed computer-implemented method for performing load balancing and distributed high-availability may include (i) detecting through a group communication channel that links all nodes of a computing cluster that an overburdened node of the computing cluster has fallen below a predefined performance level, (ii) determining to transfer a specific microservice transaction from the overburdened node to a helper node in the computing cluster, (iii) copying data for the specific microservice transaction from a portion of a central data store that is reserved for the overburdened node to another data store that is reserved for the helper node, and (iv) completing, by the helper node, the specific microservice transaction by referencing the copied data for the specific microservice transaction in the data store that is reserved for the helper node. Various other methods, systems, and computer-readable media are also disclosed.