Intel Corporation

Rajiv Deodhar

Kent D Glossop

Rakesh Krishnaiyer

Daniel Woodworth

Milind Baburao Girkar

Bratin Saha

Stephen Junkins

David M Putzolu

Shoumeng Yan

Ying Gao

Robert Geva

Mohan Rajagopalan

Xiaocheng Zhou

Sai Luo

Joshua Cranmer

Ravi Narayanaswamy

Clark F Nelson

Arvind Sudarsanam

Tiger Chen

Patrick Xi

Dounia Khaldi

Sergey Dmitriev

Systems, apparatuses and methods may provide for technology that detects one or more local variables in source code, wherein the local variable(s) lack dependencies across iterations of a loop in the source code, automatically generate pipeline execution code for the local variable(s), and incorporate the pipeline execution code into an output of a compiler. In one example, the pipeline execution code includes an initialization of a pool of buffer storage for the local variable(s).

Automatic compiler dataflow optimization to enable pipelining of loops with local storage requirements

Various embodiments are generally directed to optimizing dataflow in automated transformation frameworks (e.g., compiler, runtime, etc.) for spatial architectures (e.g., Configurable Spatial Accelerator) that translate high-level user code into forms that use 'streams' (e.g., Latency Insensitive Channels, line buffers) to reduce overhead, eliminate or improve the efficiency of redundant memory accesses, and improve overall throughput.

Integration of automated complier dataflow optimizations

A computer system may comprise a computer platform and input-output devices. The computer platform may include a plurality of heterogeneous processors comprising a central processing unit (CPU) and a graphics processing unit) GPU, for example. The GPU may be coupled to a GPU compiler and a GPU linker/loader and the CPU may be coupled to a CPU compiler and a CPU linker/loader. The user may create a shared object in an object oriented language and the shared object may include virtual functions. The shared object may be fine grain partitioned between the heterogeneous processors. The GPU compiler may allocate the shared object to the CPU and may create a first and a second enabling path to allow the GPU to invoke virtual functions of the shared object. Thus, the shared object that may include virtual functions may be shared seamlessly between the CPU and the GPU.

Two way communication support for heterogenous processors of a computer platform

Growing community of inventors

Phoenix, AZ, United States of America

Rajiv Deodhar