Nvidia Corporation

Zorroa Corporation

Daniel Elliot Wexler

Ignacio Llamas

Lacky V Shah

Sean Jeffrey Treichler

Philip Alexander Cuadra

Craig Duttweiler

Jerome Francis Duluk, Jr

Jeffrey A Bolz

Stephen Jones

Eric Enderton

Larry I Gritz

Christopher Frederick Lamb

Philip Nemec

Samuel Hammond Duncan

Cass Watson Everitt

Philip Browning Johnson

Luke Durant

Jesse David Hall

Timothy Paul Lottes

Juan Jose Buhler

Jonathon Stuart Ramsay Evans

Matthew Chambers

David DeBry

Timothy Paul Lottes Farrar

Naveen Leekha

John F Schlag

A computing system receives user input selecting a first search folder in a hierarchical set of search folders for a collection of documents. The system identifies documents of the first search folder by: (i) executing a predefined query specified for the first search folder to dynamically retrieve documents, if any, from the collection of documents, that satisfy the specified query, (ii) identifying documents, if any, from the collection of documents, that are individually associated with the first search folder, (iii) determining whether the search folder includes one or more subfolders, and (iv) in accordance with a determination that the search folder includes one or more subfolders, recursively performing (i), (ii), (iii), and (iv) on each of the one or more subfolders of the first search folder, to retrieve documents, if any, contained in the one or more subfolders. The system displays the identified documents to the user.

Hierarchical search folders for a document repository

Apparatuses, systems, and techniques for performing nested kernel execution within a parallel processing subsystem. In at least one embodiment, a parent thread launches a nested child grid on the parallel processing subsystem, and enables the parent thread to perform a thread synchronization barrier on the child grid for proper execution semantics between the parent thread and the child grid.

Technique for computational nested parallelism

A method of analyzing and organizing printed documents is performed at a computing system having one or more processors and memory. The method includes receiving one or more printed documents, each including one or more pages. The method includes processing each page of each printed document. The method includes scanning the respective page to obtain an image file. The method also includes determining a document class for the respective page by inputting the image file to one or more trained classifier models, and generating a semantic analyzer pipeline including at least an optical character recognition (OCR)-based semantic analyzer. The method also includes applying the OCR-based semantic analyzer to the preprocessed output page to generate a preprocessed output page and to extract semantic information corresponding to the respective page. The method includes determining a digital organization for the respective printed document based on the extracted semantic information and the document class.

Digital organization of printed documents according to extracted semantic information

A method for scheduling work for processing by a GPU is disclosed. The method includes accessing a work completion data structure and accessing a work tracking data structure. Dependency logic analysis is then performed using work completion data and work tracking data. Work items that have dependencies are then launched into the GPU by using a software work item launch interface.

System and method for runtime scheduling of GPU tasks

One embodiment of the present invention sets forth a technique for performing nested kernel execution within a parallel processing subsystem. The technique involves enabling a parent thread to launch a nested child grid on the parallel processing subsystem, and enabling the parent thread to perform a thread synchronization barrier on the child grid for proper execution semantics between the parent thread and the child grid. This technique advantageously enables the parallel processing subsystem to perform a richer set of programming constructs, such as conditionally executed and nested operations and externally defined library functions without the additional complexity of CPU involvement.

One embodiment of the present invention enables threads executing on a processor to locally generate and execute work within that processor by way of work queues and command blocks. A device driver, as an initialization procedure for establishing memory objects that enable the threads to locally generate and execute work, generates a work queue, and sets a GP_GET pointer of the work queue to the first entry in the work queue. The device driver also, during the initialization procedure, sets a GP_PUT pointer of the work queue to the last free entry included in the work queue, thereby establishing a range of entries in the work queue into which new work generated by the threads can be loaded and subsequently executed by the processor. The threads then populate command blocks with generated work and point entries in the work queue to the command blocks to effect processor execution of the work stored in the command blocks.

Work-queue-based graphics processing unit work creation

A time slice group (TSG) is a grouping of different streams of work (referred to herein as 'channels') that share the same context information. The set of channels belonging to a TSG are processed in a pre-determined order. However, when a channel stalls while processing, the next channel with independent work can be switched to fully load the parallel processing unit. Importantly, because each channel in the TSG shares the same context information, a context switch operation is not needed when the processing of a particular channel in the TSG stops and the processing of a next channel in the TSG begins. Therefore, multiple independent streams of work are allowed to run concurrently within a single context increasing utilization of parallel processing units.

Concurrent execution of independent streams in multi-channel time slice groups

One embodiment of the present invention sets forth a technique for launching work on a processor. The method includes the steps of initializing a first state object within a memory region accessible to a program executing on the processor, populating the first state object with data associated with a first workload that is generated by the program, and triggering the processing of the first workload on the processor according to the data within the first state object.

API for launching work on a processor

One embodiment of the present invention sets forth a technique for receiving versions of state objects at one or more stages in a processing pipeline. The method includes receiving a first version of a state object at a first stage in the processing pipeline, determining that the first version of the state object is relevant to the first stage, incrementing a first reference counter associated with the first version of the state object, assigning the first version of the state object to work requests that arrive at the first stage subsequent to the receipt of the first version of the state object, and transmitting the first version of the state object to a second stage in the processing pipeline.

Method for handling state transitions in a network of virtual processing nodes

One embodiment of the present invention sets forth a technique for executing an operation once work associated with a version of a state object has been completed. The method includes receiving the version of the state object at a first stage in a processing pipeline, where the version of the state object is associated with a reference count object, determining that the version of the state object is relevant to the first stage, incrementing a counter included in the reference count object, transmitting the version of the state object to a second stage in the processing pipeline, processing work associated with the version of the state object, decrementing the counter, determining that the counter is equal to zero, and in response, executing an operation specified by the reference count object.

One embodiment of the present invention sets forth a technique for performing low latency computation on a parallel processing subsystem. A low latency functional node is exposed to an operating system. The low latency functional node and a generic functional node are configured to target the same underlying processor resource within the parallel processing subsystem. The operating system stores low latency tasks generated by a user application within a low latency command buffer associated with the low latency functional node. The parallel processing subsystem advantageously executes tasks from the low latency command buffer prior to completing execution of tasks in the generic command buffer, thereby reducing completion latency for the low latency tasks.

Low latency concurrent computation

In an example embodiment, 3D graphics object information associated with a render of a frame may be stored in an object-indexed cache in a memory. The 3D graphics object information comprises results for one or more shading operations further comprises one or more input values for the one or more shading operations.

Re-render acceleration of frame with lighting change

Embodiments of methods, apparatuses, devices, and/or systems for load balancing two processors, such as for graphics and/or video processing, for example, are described.

Growing community of inventors

Soda Springs, CA, United States of America

Daniel Elliot Wexler