International Business Machines Corporation

Huawei Technologies Co., Limited

Globalfoundries Inc.

Future Wei Technologies, Inc.

Kai-Ting Amy Wang

Peng Wu

Alexandre E Eichenberger

Martin Ohmacht

Raul Esteban Silvera

Xiaotong Zhuang

Maged M Michael

Marcel Mitran

Thomas M Gooding

Haichuan Wang

Man Pok Ho

Yaoqing Gao

Peng Zhao

Mark Edwin Giampapa

John Kevin O'Brien

Xiang Wang

Robert J Blainey

Mark Graham Stoodley

John K P O'Brien

Barnaby Dalton

Mark Yamashita

Reza Azimi

Brice Adam Dobry

Ye Tian

Cheng Xiang Feng

Louis Ly

James A Sedgwick

Lior Velichover

Khaled A Mohammed

Kathryn Mary O'Brien

Chao Wang

Jose Nelson Amaral

Hans Boettiger

Fei Yang

Wei Tang

Xun Deng

Jack Lee

Marcus Theodore Chernenko Karpoff

Ende Jin

A method and system are provided to construct, from a TensorFlow graph, a common intermediate representation that can be converted to a plurality of compiler intermediate representations (IRs), which enables compiler optimization to be applied efficiently.

Method and system for constructing compiler intermediate representations from TensorFlow graph

There is provided methods and devices for computing a tile size for software optimization. A method includes receiving, by a computing device, information indicative of one or more of a set of loop bounds and a set of data shapes; processing, by the computing device, the information to determine a computation configuration based on the obtained information, the computation configuration implementable by a compiler, said processing including evaluating at least the computation configuration based on a build cost model, the build cost model representative of a data transfer cost and a data efficiency of the computation configuration; and transmitting, by the computing device, instructions directing the compiler to implement the computation configuration.

Methods and devices for computing a memory size for software optimization

A computer-implemented method includes the following operations. A transactional lock elision transaction including a critical section is executed. The critical section is processed. After the processing of the critical section and prior to a commit point in the transactional lock elision transaction, a status of a lock is checked. Responsive to a determination that a status of the lock is free, a result of the transactional lock elision transaction is committed.

Transactional lock elision with delayed lock checking

A method includes analyzing a dataflow graph representing data dependencies between operators of a dataflow application to identify a plurality of candidate groups of the operators. Based on characteristics of a given hardware accelerator and the operators of a given candidate group of the plurality of candidate groups, determining whether the operators of the given candidate group are to be combined. In response to determining that the operators of the given candidate group are to be combined, retrieving executable binary code segments corresponding to the operators of the given candidate group, generating a unit of binary code including the executable binary code segments and metadata representing an execution control flow among the executable binary code segments, and dispatching the unit of code to the given hardware accelerator for execution of the unit of code.

Method and apparatus for enabling autonomous acceleration of dataflow AI applications

Systems, methods, and processor readable media are described for verifying software. A liquid type system is used by a programming language to allow source code to define tensor variables with dimensionality and/or shape dynamically defined at runtime. The dimensionality and shape of a tensor variable invoked in the source code, as well as the data type of the constituent elements of such a tensor variable, may be defined by a static type that may be verified at compile time.

Systems, methods and media for dynamically shaped tensors using liquid types

Embodiments of this disclosure allow non-position-independent-code to be shared between a closed application and a subsequent application without converting the non-position-independent-code into position-independent-code. In particular, embodiment techniques store live data of a closed application during runtime of the closed application, and thereafter page a portion of the live data that is common to both the closed application and a subsequent application back into volatile memory at the same virtual memory address in which the portion of live data was stored during runtime of the closed application so that the paged lived data may be re-used to execute the subsequent application in the managed runtime environment. Because the paged live data is stored at the same virtual memory address during the runtimes of both applications, non-position-independent-code can be shared between the applications.

Re-playable execution optimized for page sharing in a managed runtime environment

A computer implemented method manages execution of applications within a memory space of a multi-tenant virtual machine (MVM). The method includes instantiating a container for an application. The container has a thin client and a name space that is part of a memory space of the MVM. Threads of the application are moved from the MVM to the container. The threads are executed using the thin client in the name space of the container.

Virtual machine container for applications

Methods and systems for managing a connection in an internet protocol virtual server (IPVS). At least a portion of checkpoint data is transmitted by a first node of the IPVS to a load balancer of the IPVS. The checkpoint data includes information for restoring an active connection of the first node and also information representing the current state of the active connection. The load balancer stores the checkpoint data in association with connection data for the connection. The first node terminates the connection. The load balancer updates the connection data with information about a second node of the IPVS. The checkpoint data is transmitted to the second node. Incoming data packets for the connection are then forwarded to the second node, in accordance with the updated connection data.

Managing persistent TCP connections in an IPVS environment

An embodiment method for retiring a dynamically updatable function includes receiving, by a collector-thread, a registration of the function, wherein the registration indicates to the collector-thread addresses of memory locations for counters that count a number of calls currently being made to a previous version of the function by a plurality of execution threads; reading, by the collector-thread, values of the counters; and when the values of all the counters are zero, deleting, by the collector-thread, the function from a storage medium on a device previously executing the previous version of the function.

Method to manage multiple versions of parts of a software application and to retire older versions in a dynamically updatable software system

System and method for managing migration of global variables on processing system during live program updates, including creating a shared data segment is created in a physical memory of the processing system, binding a logical address space of a first global variable data segment for a first version of a program to a physical address of the shared data segment, and binding a logical address space for a second global variable data segment for an update version of the program to the physical address of the shared data segment. The first global variable data segment and the second global variable data segment exist concurrently and each map to common global variables stored in the shared data segment.

Global variable migration via virtual memory overlay technique for multi-version asynchronous dynamic software update

A method and system for using multiple versions of a software component, includes storing, in memory, a first function table that points to executable code in the memory for functions from a first version of the software component, and storing, in the memory, a second function table that points to executable code in the memory for functions from a second version of the software component, referencing the first function table, when running a first application thread, to execute the functions from the first version of the software component; and referencing the second function table, when running a second application thread that is active concurrently with the first application thread, to execute the functions from the second version of the software component.

Multi-version asynchronous dynamic software update system and method for applications with multiple threads

A computing system includes at least one processor and at least one module operable by the at least one processor to calculate a tail of a first dataset by determining elements of the first dataset that fall outside of a specified percentile, and determine locations of the first dataset at which elements of the first dataset that fall outside of the specified percentile are located. The at least one module may be operable to calculate a tail of a second dataset by populating a data structure with elements of the second dataset that correspond to the locations of the first dataset, and determining, using the data structure, elements of the second dataset that fall outside of the specified percentile. The at least one module may be operable to output an indication of at least one of the tail of the first dataset or the tail of the second dataset.

Efficient tail calculation to exploit data correlation

Growing community of inventors

North York, Canada

Kai-Ting Amy Wang