International Business Machines Corporation

Huawei Technologies Co., Limited

Globalfoundries Inc.

Yaoqing Gao

Roch Georges Archambault

Raul Esteban Silvera

Shimin Cui

Lixin Zhang

Francis Patrick O'Connell

Peng Zhao

Robert J Blainey

Gheorghe Calin Cascaval

Kai-Ting Amy Wang

James Lawrence McInnes

Allan Russell Martin

Denis Palmeiro

Liangxiao Hu

Robert Brett Tremaine

Steven Wayne White

William Evan Speight

Xiang Wang

Tong Chen

Allan Henry Kielstra

William G O'Farrell

Michael Edward Wazlowski

Christopher M Barton

Pascal Vezolle

Mark Peter Mendell

Reza Azimi

Ye Tian

Ehsan Amiri

Cheng Xiang Feng

Stephen Curial

Jeffrey A Stuecheli

Martin Ohmacht

Richard James Eickemeyer

Bradly George Frey

Kevin Alexander Stoodley

Zehra Noman Sura

Peng Wu

Geoffrey Owen Blandy

Long Chen

Miles Robert Dooley

Ettore Tiotto

Trong Truong

Jason Nathaniel Dale

Guansong Zhang

Chengliang Zhang

Ahmed Mohammed ElShafiey Mohammed Eltantawy

Chen Ding

John R MacMillan

Jeremiah S Swan

Archana Ravindar

Hans Boettiger

Nicolas Tallet

Eric Michel

John David McCalpin

Zhixing Ren

Graham K Yiu

Allen Russell Martin

Christopher Rodrigues

Lijuan Hai

Roland Froese

Francois Gibello

Kevin K O'Brien

Xiaoming Gu

Kamen Y Yotov

Kobimanalan Vinayagamoorthy

Xuan Zhong

Denis M Palmeiro

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

A method for improving the performance of applications executed within asynchronous processor architectures. In an embodiment, a method for improving execution time of compiled synchronized source code on an asynchronous processor architecture includes receiving, by a processing system, synchronized source code comprising synchronization instructions to synchronize execution of the synchronized source code on different pipelines of the asynchronous processor architecture. The method also includes analyzing, by the processing system, the synchronized source code to determine whether the synchronized source code includes a broken code condition. The method also includes, after determining, by the processing system, that the synchronized source code does not include a broken code condition, outputting an optimized synchronized source code generated by performing a corrective action on the synchronized source code to correct a synchronization inaccuracy, inconsistency, or inefficiency in the synchronized source code.

Method of deadlock detection and synchronization-aware optimizations on asynchronous architectures

Systems and methods for auto-tuning and compiling source code are provided. A first executable file is generated by compiling the source code in accordance with a first optimization scheme. Compiling reports, performance reports, and bottleneck information are generated for the first executable file. A second optimization scheme is generated, and a second executable file is generated by compiling the source code in accordance with the second optimization scheme. An optimized executable file is output based on the first executable file and the second executable file.

Method and system of intelligent iterative compiler optimizations based on static and dynamic feedback

An approach to dynamic run-time alias checking comprising creating a main thread and a helper thread, computing an optimized first region of code in a rollback-only transactional memory associated with the main thread checking for one or more alias dependencies in an un-optimized first region of code, responsive to a determination in a predetermined amount of time that no alias dependencies are present in the un-optimized first region of code, committing a transaction and responsive to at least one of a failure to determine results of the check for one or more alias dependencies in the predetermined amount of time and a determination in the predetermined amount of time that alias dependencies are present in the un-optimized first region of code, performing a rollback of the transaction and executing the un-optimized first region of code.

Dynamic alias checking with transactional memory

Embodiments of the present invention provide a method, system and computer program product for the data splitting of recursive data structures. In one embodiment of the invention, a method for data splitting recursive data structures can be provided. The method can include identifying data objects of a recursive data structure type, such as a linked list, within source code, the recursive data structure type defining multiple different data fields. The method further can include grouping the data objects into some memory pool units, each of which can contain the same number of data objects. Each memory pool unit can be seen as an array of data objects. The method can include data splitting, which could be maximal array splitting in each different memory pool unit. Finally, the method can include three different approaches, including field padding, field padding and field splitting, to handle irregular field sizes in the data structure.

Data splitting for recursive data structures

A code region of an application is instrumented by a multi-pass profiler with first annotations for generating profile data. The application is executed with the first annotations, wherein executing the application with the first annotations generates first profile data for the code region. The multi-pass profiler identifies, from the first profile data, the code region as a delinquent code region. The multi-pass profiler determines second annotations based, at least in part, on the first profile data and the at least one of the first annotations that defines the delinquent code region. The multi-pass profiler instruments, based on the first profile data, a code sub-region of the delinquent code region with the second annotations for generating profile data. The application is executed with second annotations, wherein executing the application with the second annotations generates second profile data for the code sub-region.

Multiple pass compiler instrumentation infrastructure

A solution for cooperative data prefetching that enables software control of a memory-side data prefetch and/or a processor-side data prefetch is provided. In one embodiment, the invention provides a solution for generating an application, in which access to application data for the application is improved (e.g., optimized) in program code for the application. In particular, a push request, for performing a memory-side data prefetch of the application data, and a prefetch request, for performing a processor-side data prefetch, are added to the program code. The memory-side data prefetch results in the application data being copied from a first data store to a second data store that is faster than the first data store while the processor-side data prefetch results in the application data being copied from the second data store to a third data store that is faster than the second data store.

Software solution for cooperative memory-side and processor-side data prefetching

A source code is pre-processed to form a pre-processed source code. The source code refers to an external code in a separate file, and the pre-processed source code creates a single file that includes the source code and the external code. The source code is profiled to create profile information identifying a hot portion having a first degree of hotness. A set of environment parameter values is determined to be applicable to a data processing system where the application will execute. At a remote optimizing compiler, a selection of a set of compiler options from a knowledgebase corresponding to the profile information and the set of environment parameter values is caused and an object code resulting from compiling the pre-processed source code using the set of compiler options is obtained. The object code is optimized according to the profile information and the set of environment parameter values.

Optimized compilation using an auto-tuned compiler as a service

A computer identifies one or more pairs of scalar statements and performs a cost analysis of operations of each of the one or more pairs of scalar statements to determine both a benefit and a cost of operations. The computer determines, based, at least in part, on the cost analysis, a gain for each of the one or more pairs of scalar statements. The computer creates based, at least in part, on the gain, a sorted list of each of the one or more pairs of scalar statements and selects a first pair from the sorted list. The computer issues a query to a hash table using a statement of the first pair and selects from results received from the query, a second pair. The computer then extends, based, at least in part, on the second pair, the first pair to create a pack.

Extending superword level parallelism

A method for reducing loop branches comprises analyzing an intermediate code to identify a candidate loop; analyzing the candidate loop to identify a candidate conditional statement containing at least one mutable operand; and determining if the computation in the candidate conditional statement is monotonic. The method further comprises calculating initial and final values of the mutable operand and generating a first version of the candidate loop which does not contain the candidate conditional statement and which is configured to be executed if the initial and final values of the mutable operand satisfy a range check. The method also comprises generating a second version of the candidate loop which contains the candidate conditional statement and which is configured to be executed if at least one of the initial and final values of the mutable operand does not satisfy the range check.

Loop branch reduction

A computer-implemented method, carried out by one or more processors, for recursive expression reduction. In an embodiment, the method comprises the steps of identifying a candidate loop, where the candidate loop includes at least one or more reduction variables and reduction operations; altering grouping of loop invariants and loop variants within the candidate loop; and performing recursive expression simplification for an inner loop, wherein the inner loop is located within the candidate loop.

Recursive expression simplification

Code versioning for enabling transactional memory region promotion may include receiving a portion of candidate source code; outlining the portion of candidate source code received for parallel execution; wrapping a critical region with entry and exit routines to enter into a speculation sub-process, wherein the entry and exit routines also gather conflict statistics at run time; and generating an outlined code portion comprising multiple loop versions using a processor.

Code versioning for enabling transactional memory promotion

Growing community of inventors

North York, Canada

Yaoqing Gao