Nvidia Corporation

Girish Bharambe

Michael Murphy

Kyrylo Perelygin

Konstantinos Kyriakopoulos

Gokul Ramaswamy Hirisave Chandra Shekhara

Jack H Choquette

Vinod Grover

Sean Jeffrey Treichler

Ronny Krashinsky

Luke Durant

Stephen Jones

Jaydeep Marathe

Sean Jong Lee

Andrew Robert Kerr

Ze Long

Bastiaan Aarts

Alan Kaatz

Apoorv Parle

Harold Carter Edwards

Rishkul Kulkarni

Maciej Piotr Tyrlik

Edward H Gornish

Aditya Avinash Atluri

Sebastian Piotr Jodlowski

Maciej Marcin Piechotka

Bageshri Sathe

David Allan Berson

Haicheng Wu

Cody Addison

Aman Arora

Ralf Andreas Karrenberg

James Player

Vijay Thakkar

Zhiwei Cao

Cris Cecka

Michael F Haidl

Bharath Vasudevan

Justin Andrew Holewinski

Raphael Dominique Pierre Boissel

Anis Ladram

Isaac Gelado

Balaji Krishna Yugandhar Atukuri

Apparatuses, systems, and techniques to enable a program to access data regardless of where said data is stored. In at least one embodiment, a system enables a program to access data regardless of where said data is stored, based on, for example, one or more locations encoding one or more addresses of said data.

Location agnostic data access

Apparatuses, systems, and techniques to perform computational operations in response to one or more compute uniform device architecture (CUDA) programs. In at least one embodiment, one or more computational operations are to cause one or more other computational operations to wait until a portion of matrix multiply-accumulate (MMA) operations have been performed.

Application programming interface to wait on matrix multiply-accumulate

Systems and methods related to generating machine code using a coroutine suspension mechanism are disclosed below. An asynchronous programming model utilizing coroutines may be implemented in a compiler for a high-level programming language. The compiler is configured to include functionality related to an intrinsic function for a suspend operation of a coroutine. In accordance with an aspect of the disclosure, a method is disclosed for generating machine code that includes the coroutine mechanism. The method includes: receiving source code for a program in a high-level programming language, and compiling the source code with a compiler to generate machine code for a target processor. The source code includes a caller and a coroutine called by the caller. The compiler is configured to detect an intrinsic function for a suspend operation in the source code for the coroutine. The compiler inserts low-level code in the machine code in accordance with an ABI.

Coroutine suspension mechanism for improving performance of a computer device

Embodiments of the present invention provide a novel solution that supports the separate compilation of host code and device code used within a heterogeneous programming environment. Embodiments of the present invention are operable to link device code embedded within multiple host object files using a separate device linking operation. Embodiments of the present invention may extract device code from their respective host object files and then linked them together to form linked device code. This linked device code may then be embedded back into a host object generated by embodiments of the present invention which may then be passed to a host linker to form a host executable file. As such, device code may be split into multiple files and then linked together to form a final executable file by embodiments of the present invention.

Method and system for separate compilation of device code embedded in host code

A system and method are provided for launching a callable function. A processing system includes a host processor, a graphics processing unit, and a driver for launching a callable function. The driver is adapted to recognize at load time of a program that a first function within the program is a callable function. The driver is further adapted to generate a second function. The second function is adapted to receive arguments and translate the arguments from a calling convention for launching a function into a calling convention for calling a callable function. The second function is further adapted to call the first function using the translated arguments. The driver is also adapted to receive from the host processor or the GPU a procedure call representing a launch of the first function and, in response, launch the second function.

System and method for launching callable functions

Growing community of inventors

Pune, India

Girish Bharambe