International Business Machines Corporation

Globalfoundries Inc.

Ibm Canada Limited - Ibm Canada Limitee

Michael H Dawson

Graeme Johnson

Seetharami R Seelam

Megumi Ito

Yuqing Gao

San Hong Li

Arun Kwangil Iyengar

Thomas James Watson

Liana Liyow Fong

Charles Robert Gracie

Bentley John Hargrave

Li Feng Zhang

Aaron J Quirk

Parijat Dube

Curtis E Hrischuk

Michel H T Hack

Xavier Rene Guerin

Daniel J Heidinga

Gireesh Punathil

Graham Alan Chapman

Oluwatobi Ajila

Hui Qing Shi

Kenneth Blair Kent

Christopher J Blythe

Wei Tan

Xiaoqiao Meng

Peter Hans Westerink

Andrew Russell Low

Norman Bobroff

Trent Gray-Donald

Prashanth K Nageshappa

Balbir Singh

Yanbin Liu

Pramod B Nagaraja

Jinghua Feng

Nai K Ling

Panagiotis Patros

Vijay Sundaresan

Marius Pirvu

Peter Duncan Shipton

Joran S C Siu

Liana L Fo

Panos Patros

Vijay V Sundaresan

Alexei I Svikine

Anyang Yu

Dhruv Chopra

Sujit Bhandari

Maria Patrou

Alen Badel

Dayal D Dilli

A smart contract clause can be generated with a processor communicatively coupled to a blockchain supported by a peer-to-peer network. The smart contract clause can be automatically invoked in response to a sensor-generated signal, wherein the sensor-generated signal corresponds to at least one or more predefined contract variance conditions. The smart contract clause can be embedded in a smart contract in the blockchain.

Smart contract compliance monitoring and enforcement

A method manages a cluster. A computer system determines a measurement of a process variable for the cluster, wherein the process variable indicates a quality of service for the cluster. The computer system determines a comparison between the measurement of the process variable and a desired value for the process variable. The computer system determines an adjustment to a setpoint for a runtime metric in the cluster based on the comparison, wherein the runtime metric is a control variable for the cluster. The computer system updates the setpoint for the runtime metric in a controller for the cluster using the adjustment, wherein the runtime metric is used by the controller as the control variable to scale a set of resources in the cluster to cause a value of the runtime metric to move towards the setpoint.

Automatic cluster scaling based on varying workloads

Embodiments of the present invention comprise a class sharing orchestrator (CSO) operating as a subsystem of a container orchestrator. The CSO manages sharing of class data among containerized applications to improve startup performance, CPU consumption and memory footprint. The CSO stores application class data in a shared class cache (SCC). The CSO provides a compatible SCC to every deployed application running within the CSO's purview. The CSO collects SCC data from running applications, and processes the data offline to continuously improve the quality of SCCs provided to each deployment, while causing minimum impact to running applications. The CSO combines updates from running applications of a given type to generate an improved quality SCC for use by newly launched applications of the same type. The CSO comprises an SCC update mechanism that optimizes the size, and network traffic, associated with SCC data exchange, and guarantees SCC quality improves over time.

Sharing cached class data in a containerized environment

A computer system for event loop optimization through event ordering within an event loop of a node to improve externally visible attributes of the runtime. The optimization is carried out by labeling a set of events by assigning one or more attributes to each event of the set of events; processing a plurality of events of the set of events for an interval based on at least the attributes of each event of the plurality of events; ordering the events of the plurality of events within the interval based on assigned priorities to the one or more assigned attributes of each event of the plurality of events; and executing the plurality of events in the order determined based on the assigned priorities.

Event loop optimization through event ordering

Aspects of the present invention provide devices that determine a load for each tenant of a plurality of tenants running applications on a shared computer server for a predetermined interval of time, wherein the computer server includes a plurality of computer processor cores, compute a capacity for each tenant of the plurality of tenants which includes a difference between the load and a service level agreement for each tenant, determine computer processor cores corresponding to the capacity of a largest capacity tenant, wherein the processors cores include a subset of the plurality of computer processor cores for the shared computer server, pin the subset of computer processor cores to perform garbage collection for one or more tenants, and invoke the garbage collection using the pinned subset of computer processor cores which deallocates no longer used memory in a corresponding heap for the one or more tenants.

Multi-tenant cloud elastic garbage collector

Methods and systems for pre-fetching operations include executing event callbacks in an event loop using a processor until execution stops on a polling request. A path walk is performed on future events in the event loop until the polling request returns to pre-fetch information for the future events into a processor cache associated with the processor. Execution of the event callbacks in the event loop is resumed after the polling request returns.

Response times in asynchronous I/O-based software using thread pairing and co-execution

An illustrative embodiment of a computer-implemented method for working set adjustment receives a request to use less heap memory than an original maximum forming a new maximum, and determines whether a garbage collection will move objects in response to the request. Responsive to a determination the garbage collection will move objects, add a first callback triggered by initiation of the garbage collection and invoking a handler for the first callback notifying a memory manager to free objects allocated by balloon. The first callback completes and the garbage collection starts. A handler for a second callback is invoked which notifies the memory manager to allocate balloon objects and frees backing memory to an operating system, the balloon objects consuming an amount of memory space equal to a remaining portion of memory necessary to return to the operating system. Completion of the second call back allows the garbage collection to proceed as usual.

Working set adjustment in a managed environment

A method of event loop optimization through event ordering within an event loop of a node to improve externally visible attributes of the runtime. The optimization is carried out by labeling a set of events by assigning one or more attributes to each event of the set of events; processing a plurality of events of the set of events for an interval based on at least the attributes of each event of the plurality of events; ordering the events of the plurality of events within the interval based on assigned priorities to the one or more assigned attributes of each event of the plurality of events; and executing the plurality of events in the order determined based on the assigned priorities.

Embodiments disclose systems, methods and computer program products to perform an operation for sharing artifacts between instances of an application deployed in a cloud computing environment. The operation generally includes upon determining, during staging of the application, that a set of artifacts are not available for instances of the application to share in the cloud computing environment, generating the set of artifacts via a first application instance, storing the set of artifacts, and requesting a re-staging of the application. The operation also includes during the re-staging of the application, generating a file for deploying scaled instances of the application and packing the stored set of artifacts into the generated file via a second application instance. The operation further includes executing an instance scale out of the application with the generated file comprising the stored set of artifacts.

Dynamically compiled artifact sharing on PaaS clouds

Real-time application metrics of an application executed by a virtual machine are dynamically monitored by a controlling agent and analyzed to determine an optimal configuration of the virtual machine for executing the application. Based on the measured metrics, tunable parameters of the virtual machine may be adjusted to achieve desired application performance.

Optimizing virtual machine synchronization for application software

An embodiments of the invention may include a method, computer program product and computer system for optimizing computer programs. The embodiment may include a computing device that determines a program code of a computer program contains at least two consecutive method handles. The embodiment may determine that the at least two consecutive method handles can be optimized. The embodiment may optimize the at least two consecutive method handles. Optimizing the at least two consecutive method handles may include one or more of: replacing the at least two consecutive method handles with one or more different commands; and reordering the at least two consecutive method handles.

Creating optimized shortcuts

In an approach for removing tenant initialization check per tenant for compiled code, a processor receives a request to create a tenant. A processor creates the tenant. A processor marks a current thread of the tenant as not eligible to run just-in-time (JIT) code, wherein the marking indicates that when a method is invoked, a non-JIT version of the method is executed. A processor executes initialization of a first class from an optimization list, wherein the optimization list is a configurable list of classes to be initialized prior to running JIT code. A processor determines that class initialization has been executed for all classes on the optimization list. A processor adjusts the marking to indicate that the current thread is eligible to run JIT code and that the tenant may run JIT code that assumes, without checking, that classes on the optimization list are initialized.

Per tenant initialization check removal

An illustrative embodiment of a computer-implemented method for working set adjustment receives a request to use less heap memory than an original maximum forming a new maximum, and determines whether a garbage collection will move objects in response to the request. Responsive to a determination the garbage collection will move objects, add a first callback triggered by initiation of the garbage collection and invoking a handler for the first callback notifying a memory manager to free objects allocated by balloon. The first callback completes and the garbage collection starts. A handler for a second callback is invoked which notifies the memory manager to allocate balloon objects and frees backing memory to an operating system. Completion of the second call back allows the garbage collection to proceed as usual.

Embodiments of the present invention disclose an approach for inserting code into a running thread of execution. A computer sets a first set of bits to a first value, wherein the first value indicates that a first set of instructions should be inserted onto a stack. The computer executes a second set of instructions associated with a first safepoint, wherein the second set of instructions comprises one or more instructions to determine if the first set of bits is set to the first value. The computer determines that the first set of bits is set to the first value, and the computer inserts the first set of instructions onto the stack.

Dynamic code injection

An apparatus includes at least one processor executing a method for managing memory among a plurality of concurrently-running virtual machines, and a non-transitory memory device that stores a set of computer readable instructions for implementing and executing said memory management method. A memory optimization mechanism can reduce a memory usage of a virtual machine at a cost of increasing a central processing unit (CPU) usage. Information on a memory usage and a CPU usage of each virtual machine is periodically collected. When a first virtual machine exhibits high memory use, at least one second virtual machine with an extra CPU capacity is identified. A memory optimization mechanism is applied to the second virtual machine to reduce memory used by the second virtual machine, thereby providing a portion of freed memory that is then allocated to the first virtual machine.

System and method for improving memory usage in virtual machines at a cost of increasing CPU usage

Growing community of inventors

CA

Michael H Dawson