Made most of the very basic pieces for the simulation parts

Started to implement curbe support

Fixed issue with new / delete operators

Fix name of callback initializer

Fixed compilation with the current compiler code

Revamp the backend classes to be easily able to output Gen or simulator code

Started to handle cl_mem regular buffers

Improved and simplify file and class naming for the code generation step

Started to simplify backend file directory

Fixed the getCode kernel function for the simulator

Made the EOT code run on the simulator

Added a script to support the performance simulator

Implemented some pieces of the GenIR to c++ conversion used by the performance simulator

Made a better c-style interface Improved the base interfaces for both programs and kernels

Adapted properly the driver to the new gen compiler interface

Put sim and gen files into a common sub-directory

Started to implement the interface for the compiler. This will allow us to output either Gen ISA or the performance simulator code

Fixed memory leaks in llvm_to_gen pass

Added all the call backs to support the simulator. The simulator does nothing but works now. Fixed several memory leaks in the simulator code

Made the structure naming more consistent

Removed all direct dependencies to the intel driver (ie files contained in intel/) and replaced them by dependencies to the call backs. This should allow an easier integration with the performance simulator

Started to rename all driver files to make the naming more consistent

Added more call backs to abstract the driver back end

Started to implement the clean interface to support both HW and simulator

Made EOT work correctly Extended public API

Made EOT work on simulator

Added more functions to interface Gen programs

Started to inject the new compiler API

Removed Gen6 Stripped out all dependencies from previous compiler Added a dependency on the new compiler

Started to implement external C interface for the compiler Output a first dummy program

Started to implement Gen code generation

started to implement gen encoding

Added first support for constant vector Recompiled all ocl kernels Fixed problem when a block does not end with a branch Added proper support for special registers and function argument in liveness analysis and function DAG creation

Fixed several bugs in the DAG creation code

Fixed a bug in memory debugger (...) Fixed a stupid bug while releasing FunctionDAG

Fixed auto keyword use

Started to fix problem with blocks that do not end with BRA instructions

Kept on implementing full function DAG Added a monitor for the memory consumption

Started to implement the iterative data flow pass to build the global DAG

Started to implement values and ud | du chains

value.hpp -> immediate.hpp value is going to be a real "Value" (as compiler values)

Added proper bookkeeping for the argument types Finished the liveness pretty printer

Started to implement pretty printer for the liveness analysis

Started to implement liveness analysis

Started to implement liveness analysis

Removed unused returnStruct field from function Included stdlib.h for all files

Made the instructions double-chain list elements Renamed the register family s/RegisterData::Family/RegisterFamily/ s/RegisterData::/FAMILY_/

Added new test

Implemented PHI and Branch instruction translation

Added shuffle/insert/extract elements LLVM IR translation Added Gen IR select instruction and LLVM IR select translation

Added more kernels for the very basic tests

Added extra check when dealing with our own builtins functions

Added first support for compare instructions Added first support for convert instructions

Removed unused code from former C backend

Made first tests pass with vectors

Extended the llvm-to-gen translation pass

Added first support for immediates Started to add support for builtin functions

Finished a first very very limited LLVM to Gen-IR translation. It should be just enough to write a first very simple kernel

Added various helper functions in the LLVM to Gen translation Implemented binary instruction translation Implemented return instruction translation

Implemented a first implementation of the function argument parsing from LLVM IR

Removed more stuff from CBackend

Removed the crap related to llvm targets and triples

Started to remove the useless crap from CBackend. We only keep the code as a pass and not as a triple

Compiled the skeletong of what the llvm to gbe translator should be

Added a new define for the debug mode (GBE_DEBUG)

Started llvm work

Added missing file

Added support for output streams for functions

Added more tests

Fixed instruction size in the instruction definitions Added more tests for the context Added more check on the labels

Improved error messages with better assertions

s/Register/RegisterData/g s/RegisterIndex/Register/g s/TupleIndex/Tuple/g

Changed typing in GrowingPool. It is more C++ like

Added missing test

Added type safety for all uint* Added one more test

Made the memory debugger properly output the unfreed allocations

Added more functionality in the unit test "framework" Created one test that basically checks that the unit test system works

Added missing function for compares

Ensure type safety for tuple and register indices by making specific classes

Added compare instructions Finished to implement well formed functions. They basically check that the definition is consistent (types match, registers and tuple are not out-of-bound the register files or the tuple files...)

Added more functionalities for the context Started to implement wellFormed function that basically checks that everything is properly set in the instruction

Improved memory debugger -> added memory re-initialization at free time -> added automatic memory debugger initialization

Renamed ir_{...} to {...} Put ir structures and classes into an IR namespace Made all headers homogeneous Removed unused files Put again fixed_array since it is pretty convienent

int* -> [u]uint*_t

Plasma specific changes

Start to implement context and compilation unit creation

Added first support for compilation units Added first support for constant definition Finished a first version of instruction definitions

Added missing files

Keep on implementing instruction class implementation. This basically a set of classes that implements the opaque public instruction classes

Started to add cleaner and safer cast facilities for the instructions

Cleaned up instruction class implementation

Added a clean interface for instruction (encoding in 8 bytes with alternative encoding for long instruction (using tuples)) Simplified the register structure

Fixed SNB build

Started to implement IR VM

Removed unused tests

- renamed namespace (s/pf/gbe) - created first files for the IR

Implemented SIMD8 for IVB (only tested on Fulsim but should work out of the box on the HW)

Implemented image tiling on IVB fulsim

Fixed compilation while using the old compiler

Ported the code to HSW Updated the compiler. Both old and view compilers are supported via a compiler flag