diff --git a/bin/.gitattributes b/bin/.gitattributes
new file mode 100644
index 0000000..c32f4d2
--- /dev/null
+++ b/bin/.gitattributes
@@ -0,0 +1 @@
+lld filter=lfs diff=lfs merge=lfs -text
diff --git a/bin/iga64 b/bin/iga64
new file mode 100755
index 0000000..1f5f6e6
Binary files /dev/null and b/bin/iga64 differ
diff --git a/bin/lld b/bin/lld
new file mode 100755
index 0000000..7d43d61
--- /dev/null
+++ b/bin/lld
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ee11aee3e56440cf6c462a5d7b70d76f396c9d677849c090c62002e08593711a
+size 130394592
diff --git a/include/iga/iga.h b/include/iga/iga.h
index 242ee29..6c0a979 100644
--- a/include/iga/iga.h
+++ b/include/iga/iga.h
@@ -439,6 +439,7 @@ static_assert(sizeof(iga_disassemble_options_t) == 6 * 4,
 /* just the default decoding opts */
 #define IGA_DECODING_OPTS_DEFAULT (0u)
 
+
 /*
  * Disassembles kernel bits into a string.
  *
diff --git a/include/iga/igaEncoderWrapper.hpp b/include/iga/igaEncoderWrapper.hpp
index 3e84f4d..0890798 100644
--- a/include/iga/igaEncoderWrapper.hpp
+++ b/include/iga/igaEncoderWrapper.hpp
@@ -59,6 +59,7 @@ class KernelEncoder {
   // enable IGA swsb set. When enabled, the original swsb in the input
   // instructions will be obsoleted
   void enableIGAAutoDeps(bool enable = true) { m_enableAutoDeps = enable; }
+
 };
 
 #endif // _IGA_ENCODER_WRAPPER_HPP
diff --git a/include/iga/igad.h b/include/iga/igad.h
index 5b94122..1a85021 100644
--- a/include/iga/igad.h
+++ b/include/iga/igad.h
@@ -148,12 +148,19 @@ typedef iga_status_t(CDECLATTRIBUTE *pIGAOpspecOp)(iga_opspec_t op,
 typedef kv_t *(CDECLATTRIBUTE *pIGAKVCreate)(
     iga_gen_t plat, const void *bytes, size_t bytes_len, iga_status_t *status,
     char *errbuf, size_t errbuf_cap,
-    /* iga::SWSB_ENCODE_MODE */ uint32_t swsb_mode);
+    /* iga::SWSB_ENCODE_MODE */ uint32_t swsb_mode
+    );
 #define IGA_KV_DELETE_STR "kv_delete"
 typedef void(CDECLATTRIBUTE *pIGAKVDelete)(kv_t *);
 
 #define IGA_KV_GET_INST_SIZE_STR "kv_get_inst_size"
 typedef int32_t(CDECLATTRIBUTE *pIGAKVGetInstSize)(const kv_t *kv, int32_t pc);
+#define IGA_KV_GET_INST_MSG_INFO_STR "kv_get_inst_msg_info"
+typedef int32_t(CDECLATTRIBUTE *pIGAKVGetInstMsgInfo)(const kv_t *kv,
+                                                      int32_t pc,
+                                                      bool *isAtomic,
+                                                      bool *isSlm,
+                                                      bool *isScratch);
 #define IGA_KV_GET_INST_TARGETS_STR "kv_get_inst_targets"
 typedef uint32_t(CDECLATTRIBUTE *pIGAKVGetInstTargets)(const kv_t *kv,
                                                        int32_t pc,
@@ -379,6 +386,7 @@ typedef struct {
   pIGAKVCreate kv_create;
   pIGAKVDelete kv_delete;
   pIGAKVGetInstSize kv_get_inst_size;
+  pIGAKVGetInstMsgInfo kv_get_inst_msg_info;
   pIGAKVGetInstTargets kv_get_inst_targets;
   pIGAKVIsInstTarget kv_is_inst_target;
   pIGAKVGetDefaultLabelName kv_get_default_label_name;
diff --git a/include/iga/kv.h b/include/iga/kv.h
index 5eb330c..abd7d7f 100644
--- a/include/iga/kv.h
+++ b/include/iga/kv.h
@@ -89,7 +89,8 @@ typedef enum {
  */
 IGA_API struct kv_t *kv_create(iga_gen_t plat, const void *bytes, size_t bytes_len,
                         iga_status_t *status, char *errbuf, size_t errbuf_cap,
-                        uint32_t swsb_enc_mode /* iga::SWSB_ENCODE_MODE */);
+                        uint32_t swsb_enc_mode /* iga::SWSB_ENCODE_MODE */
+                         );
 
 /*
  * Destroys a kernel view deallocating all resources sequestered by the kv_t
@@ -112,6 +113,18 @@ IGA_API void kv_delete(struct kv_t *);
  */
 IGA_API int32_t kv_get_inst_size(const struct kv_t *kv, int32_t pc);
 
+/*
+ * Returns some attributes of a message: if it is atomic, slm, scratch
+ * operation.
+ * Returns:
+ *   KV_SUCCESS on success; output is stored to isAtomic and isSlm
+ *   KV_ERROR if kv is invalid
+ *   KV_INVALID_PC if instruction cannot be found
+ *   KV_DECODE_ERROR if an instruction cannot be docoded
+ */
+IGA_API kv_status_t kv_get_inst_msg_info(const kv_t* kv, int32_t pc,
+    bool* isAtomic, bool* isSlm, bool* isScratch);
+
 /*
  * Returns true if the instruction has the opt
  */
@@ -307,6 +320,11 @@ IGA_API kv_status_t kv_get_sendg_ind_desc1(const kv_t *kv, int32_t pc,
  */
 #define KV_INVALID_SEND_DESC ((uint32_t)0xFFFFFFFFF)
 
+ /*
+  * A symbol to indicate an invalid sendg descriptor value.
+  */
+#define KV_INVALID_SEND_DESC64B ((uint64_t)0xFFFFFFFFFFFFFFFFL)
+
 /* TODO: review necessity of this macro.
  * A symbol to indicate an invalid message length value.
  */
diff --git a/include/iga/kv.hpp b/include/iga/kv.hpp
index d229318..3cab9eb 100644
--- a/include/iga/kv.hpp
+++ b/include/iga/kv.hpp
@@ -50,10 +50,12 @@ class KernelView {
   KernelView(
       iga_gen_t platf, const void *bytes, size_t bytesLength,
       iga::SWSB_ENCODE_MODE swsb_mode = iga::SWSB_ENCODE_MODE::SWSBInvalidMode,
-      char *decodeLog = nullptr, size_t decodeLogLen = 0)
+      char *decodeLog = nullptr, size_t decodeLogLen = 0
+      )
       : m_kv(nullptr), m_disasm_status(IGA_SUCCESS), m_gen(platf) {
     m_kv = kv_create(platf, bytes, bytesLength, &m_disasm_status, decodeLog,
-                     decodeLogLen, static_cast<uint32_t>(swsb_mode));
+                     decodeLogLen, static_cast<uint32_t>(swsb_mode)
+                    );
   }
 
   // The destructor automatically deallocates the underlying kernel view
diff --git a/include/igc/OCLAPI/oclapi.h b/include/igc/OCLAPI/oclapi.h
index 06be0cd..08e53d7 100644
--- a/include/igc/OCLAPI/oclapi.h
+++ b/include/igc/OCLAPI/oclapi.h
@@ -10,9 +10,9 @@ SPDX-License-Identifier: MIT
 #define OCL_API_CALLS_H
 
 #if defined(_WIN32)
-    #define OCL_API_CALL
+#define OCL_API_CALL
 #else
-    #define OCL_API_CALL __attribute__ ((visibility("default")))
+#define OCL_API_CALL __attribute__((visibility("default")))
 #endif
 
 #endif // OCL_API_CALLS_H
diff --git a/include/igc/cif/cif/builtins/builtins_registry.cpp b/include/igc/cif/cif/builtins/builtins_registry.cpp
index 64ca625..672c220 100644
--- a/include/igc/cif/cif/builtins/builtins_registry.cpp
+++ b/include/igc/cif/cif/builtins/builtins_registry.cpp
@@ -17,24 +17,25 @@ namespace CIF {
 namespace Builtins {
 
 // List of all supported builtins
-using AllBuiltinsListT =  InterfacesList<CIF::Builtins::Buffer>;
+using AllBuiltinsListT = InterfacesList<CIF::Builtins::Buffer>;
 
-bool IsBuiltin(InterfaceId_t intId){
-    return AllBuiltinsListT::ContainsInterface(intId);
-}
+bool IsBuiltin(InterfaceId_t intId) { return AllBuiltinsListT::ContainsInterface(intId); }
 
-ICIF *Create(InterfaceId_t entryPointInterface, Version_t version, ICIF *parentInterface){
-    return AllBuiltinsListT::template forwardToOne<Helpers::ForwardCreateInterfaceImpl, ICIF *, ICIF *>(entryPointInterface, nullptr, version, version, parentInterface);
+ICIF *Create(InterfaceId_t entryPointInterface, Version_t version, ICIF *parentInterface) {
+  return AllBuiltinsListT::template forwardToOne<Helpers::ForwardCreateInterfaceImpl, ICIF *, ICIF *>(
+      entryPointInterface, nullptr, version, version, parentInterface);
 }
 
-bool GetSupportedVersions(InterfaceId_t entryPointInterface, Version_t &verMin, Version_t &verMax){
-    return AllBuiltinsListT::template forwardToOne<Helpers::ForwardGetSupportedVersions, bool>(entryPointInterface, false, verMin, verMax);
+bool GetSupportedVersions(InterfaceId_t entryPointInterface, Version_t &verMin, Version_t &verMax) {
+  return AllBuiltinsListT::template forwardToOne<Helpers::ForwardGetSupportedVersions, bool>(entryPointInterface, false,
+                                                                                             verMin, verMax);
 }
 
-InterfaceId_t FindIncompatible(InterfaceId_t entryPointInterface, CIF::CompatibilityDataHandle handle){
-    return AllBuiltinsListT::template forwardToOne<Helpers::ForwardGetFirstIncompatible, InterfaceId_t>(entryPointInterface, entryPointInterface, handle);
+InterfaceId_t FindIncompatible(InterfaceId_t entryPointInterface, CIF::CompatibilityDataHandle handle) {
+  return AllBuiltinsListT::template forwardToOne<Helpers::ForwardGetFirstIncompatible, InterfaceId_t>(
+      entryPointInterface, entryPointInterface, handle);
 }
 
-}
+} // namespace Builtins
 
-}
+} // namespace CIF
diff --git a/include/igc/cif/cif/builtins/builtins_registry.h b/include/igc/cif/cif/builtins/builtins_registry.h
index ee3fb99..44eca2e 100644
--- a/include/igc/cif/cif/builtins/builtins_registry.h
+++ b/include/igc/cif/cif/builtins/builtins_registry.h
@@ -24,6 +24,6 @@ bool GetSupportedVersions(InterfaceId_t entryPointInterface, Version_t &verMin,
 
 InterfaceId_t FindIncompatible(InterfaceId_t entryPointInterface, CIF::CompatibilityDataHandle handle);
 
-}
+} // namespace Builtins
 
-}
+} // namespace CIF
diff --git a/include/igc/cif/cif/builtins/memory/buffer/buffer.h b/include/igc/cif/cif/builtins/memory/buffer/buffer.h
index 9b59450..6b2cc4b 100644
--- a/include/igc/cif/cif/builtins/memory/buffer/buffer.h
+++ b/include/igc/cif/cif/builtins/memory/buffer/buffer.h
@@ -26,54 +26,53 @@ using AllocatorT = void *(CIF_CALLING_CONV *)(size_t size);
 using ReallocatorT = void *(CIF_CALLING_CONV *)(void *oldMemory, size_t oldSize, size_t newSize);
 
 /// Custom deallocator function
-using DeallocatorT = void (CIF_CALLING_CONV *)(void *memory);
+using DeallocatorT = void(CIF_CALLING_CONV *)(void *memory);
 
 /// Builtin interface that can be used as generic buffer
 CIF_DECLARE_COMMON_INTERFACE(Buffer, "CIF_BUFFER");
 
 /// v #1
-CIF_DEFINE_INTERFACE_VER(Buffer, 1){
+CIF_DEFINE_INTERFACE_VER(Buffer, 1) {
   CIF_INHERIT_CONSTRUCTOR();
 
   /// Get address to underlying buffer with ElementT as pointer element type
-  template<typename ElementT>
-  ElementT *GetMemoryWriteable(){
-      return reinterpret_cast<ElementT*>(GetMemoryRawWriteable());
+  template <typename ElementT> ElementT *GetMemoryWriteable() {
+    return reinterpret_cast<ElementT *>(GetMemoryRawWriteable());
   }
 
   /// Get address to underlying const buffer with ElementT as pointer element type
-  template<typename ElementT>
-  const ElementT *GetMemory() const{
-      return reinterpret_cast<const ElementT*>(GetMemoryRaw());
+  template <typename ElementT> const ElementT *GetMemory() const {
+    return reinterpret_cast<const ElementT *>(GetMemoryRaw());
   }
 
   /// Get size in units of ElementT (ElementT == void version)
-  template<typename ElementT>
-  const typename std::enable_if<std::is_void<ElementT>::value, size_t>::type GetSize() const{
-      return GetSizeRaw();
+  template <typename ElementT>
+  const typename std::enable_if<std::is_void<ElementT>::value, size_t>::type GetSize() const {
+    return GetSizeRaw();
   }
 
   /// Get size in units of ElementT (ElementT != void version)
-  template<typename ElementT>
-  const typename std::enable_if<false == std::is_void<ElementT>::value, size_t>::type GetSize() const{
-      return GetSizeRaw() / sizeof(ElementT);
+  template <typename ElementT>
+  const typename std::enable_if<false == std::is_void<ElementT>::value, size_t>::type GetSize() const {
+    return GetSizeRaw() / sizeof(ElementT);
   }
 
   /// Copies given element to the end of the buffer
   /// Note : If (packed == false), then this function will automatically align current underlying buffer
   ///        pointer to alignof(ElementT)
-  template<typename ElementT>
-  bool PushBackRawCopy(const ElementT &newEl, bool packed = true){
-      static_assert(std::is_standard_layout_v<ElementT> && std::is_trivial_v<ElementT> && std::is_trivially_copyable_v<ElementT>, "Supporting only POD types");
-      if(packed == false){
-          size_t alignment = alignof(ElementT);
-          bool success = AlignUp(static_cast<uint32_t>(alignment));
-          if(success == false){
-              return false;
-          }
+  template <typename ElementT> bool PushBackRawCopy(const ElementT &newEl, bool packed = true) {
+    static_assert(std::is_standard_layout_v<ElementT> && std::is_trivial_v<ElementT> &&
+                      std::is_trivially_copyable_v<ElementT>,
+                  "Supporting only POD types");
+    if (packed == false) {
+      size_t alignment = alignof(ElementT);
+      bool success = AlignUp(static_cast<uint32_t>(alignment));
+      if (success == false) {
+        return false;
       }
+    }
 
-      return PushBackRawBytes(&newEl, sizeof(ElementT));
+    return PushBackRawBytes(&newEl, sizeof(ElementT));
   }
 
   /// Sets custom allocator and deallocator functions to be used by this buffer interface
@@ -135,49 +134,51 @@ CIF_GENERATE_VERSIONS_LIST(Buffer);
 CIF_MARK_LATEST_VERSION(BufferLatest, Buffer);
 using BufferSimple = Buffer<1>; /// tag the most common version
 
-template<typename BufferInterface = BufferLatest>
-CIF::RAII::UPtr_t<BufferInterface> CreateConstBuffer(CIF::CIFMain *provider, const void *data, size_t size){
-    if(provider == nullptr){
-        return CIF::RAII::UPtr<BufferInterface>(nullptr);
-    }
-    auto buff = provider->CreateBuiltin<BufferInterface>();
-    if(buff == nullptr){
-        return CIF::RAII::UPtr<BufferInterface>(nullptr);
-    }
-    if((data != nullptr) && (size != 0)){
-        buff->SetUnderlyingStorage(data, size);
-    }
-    return buff;
+template <typename BufferInterface = BufferLatest>
+CIF::RAII::UPtr_t<BufferInterface> CreateConstBuffer(CIF::CIFMain *provider, const void *data, size_t size) {
+  if (provider == nullptr) {
+    return CIF::RAII::UPtr<BufferInterface>(nullptr);
+  }
+  auto buff = provider->CreateBuiltin<BufferInterface>();
+  if (buff == nullptr) {
+    return CIF::RAII::UPtr<BufferInterface>(nullptr);
+  }
+  if ((data != nullptr) && (size != 0)) {
+    buff->SetUnderlyingStorage(data, size);
+  }
+  return buff;
 }
 
-template<typename BufferInterface = BufferLatest>
-CIF::RAII::UPtr_t<BufferInterface> CreateWriteableBuffer(CIF::CIFMain *provider, const void *initialData, size_t initialSize){
-    auto buff = CreateConstBuffer<BufferInterface>(provider, initialData, initialSize);
-    if(buff == nullptr){
-        return CIF::RAII::UPtr<BufferInterface>(nullptr);
-    }
-    auto writeableMem = buff->GetMemoryRawWriteable();
-    if(writeableMem == nullptr && (initialData != nullptr && initialSize != 0)){
-        // failed to allocate new memory in writeable memory
-        return CIF::RAII::UPtr<BufferInterface>(nullptr);
-    }
-    return buff;
+template <typename BufferInterface = BufferLatest>
+CIF::RAII::UPtr_t<BufferInterface> CreateWriteableBuffer(CIF::CIFMain *provider, const void *initialData,
+                                                         size_t initialSize) {
+  auto buff = CreateConstBuffer<BufferInterface>(provider, initialData, initialSize);
+  if (buff == nullptr) {
+    return CIF::RAII::UPtr<BufferInterface>(nullptr);
+  }
+  auto writeableMem = buff->GetMemoryRawWriteable();
+  if (writeableMem == nullptr && (initialData != nullptr && initialSize != 0)) {
+    // failed to allocate new memory in writeable memory
+    return CIF::RAII::UPtr<BufferInterface>(nullptr);
+  }
+  return buff;
 }
 
-template<typename BufferInterface = BufferLatest>
-CIF::RAII::UPtr_t<BufferInterface> CreateBufferFromPtr(CIF::CIFMain *provider, void *ptr, size_t size, DeallocatorT ptrDeallocator){
-    auto buff = CreateConstBuffer<BufferInterface>(provider, nullptr, 0);
-    if(buff == nullptr){
-        return CIF::RAII::UPtr<BufferInterface>(nullptr);
-    }
+template <typename BufferInterface = BufferLatest>
+CIF::RAII::UPtr_t<BufferInterface> CreateBufferFromPtr(CIF::CIFMain *provider, void *ptr, size_t size,
+                                                       DeallocatorT ptrDeallocator) {
+  auto buff = CreateConstBuffer<BufferInterface>(provider, nullptr, 0);
+  if (buff == nullptr) {
+    return CIF::RAII::UPtr<BufferInterface>(nullptr);
+  }
 
-    buff->SetUnderlyingStorage(ptr, size, ptrDeallocator);
+  buff->SetUnderlyingStorage(ptr, size, ptrDeallocator);
 
-    return buff;
+  return buff;
 }
 
-}
+} // namespace Builtins
 
-}
+} // namespace CIF
 
 #include "cif/macros/disable.h"
diff --git a/include/igc/cif/cif/builtins/memory/buffer/impl/buffer_impl.cpp b/include/igc/cif/cif/builtins/memory/buffer/impl/buffer_impl.cpp
index 326ddfc..81bc89c 100644
--- a/include/igc/cif/cif/builtins/memory/buffer/impl/buffer_impl.cpp
+++ b/include/igc/cif/cif/builtins/memory/buffer/impl/buffer_impl.cpp
@@ -11,72 +11,51 @@ SPDX-License-Identifier: MIT
 
 #include "cif/macros/enable.h"
 
-namespace CIF{
+namespace CIF {
 
-namespace Builtins{
+namespace Builtins {
 
-void CIF_GET_INTERFACE_CLASS(Buffer, 1)::SetAllocator(AllocatorT allocator, DeallocatorT deallocator, ReallocatorT reallocator){
-    CIF_GET_PIMPL()->SetAllocator(allocator, deallocator, reallocator);
+void CIF_GET_INTERFACE_CLASS(Buffer, 1)::SetAllocator(AllocatorT allocator, DeallocatorT deallocator,
+                                                      ReallocatorT reallocator) {
+  CIF_GET_PIMPL()->SetAllocator(allocator, deallocator, reallocator);
 }
 
-void CIF_GET_INTERFACE_CLASS(Buffer, 1)::SetUnderlyingStorage(void *memory, size_t size, DeallocatorT deallocator){
-    CIF_GET_PIMPL()->SetUnderlyingStorage(memory, size, deallocator);
+void CIF_GET_INTERFACE_CLASS(Buffer, 1)::SetUnderlyingStorage(void *memory, size_t size, DeallocatorT deallocator) {
+  CIF_GET_PIMPL()->SetUnderlyingStorage(memory, size, deallocator);
 }
 
-void CIF_GET_INTERFACE_CLASS(Buffer, 1)::SetUnderlyingStorage(const void *memory, size_t size){
-    CIF_GET_PIMPL()->SetUnderlyingStorage(memory, size);
+void CIF_GET_INTERFACE_CLASS(Buffer, 1)::SetUnderlyingStorage(const void *memory, size_t size) {
+  CIF_GET_PIMPL()->SetUnderlyingStorage(memory, size);
 }
 
-void *CIF_GET_INTERFACE_CLASS(Buffer, 1)::DetachAllocation(){
-    return CIF_GET_PIMPL()->DetachAllocation();
-}
+void *CIF_GET_INTERFACE_CLASS(Buffer, 1)::DetachAllocation() { return CIF_GET_PIMPL()->DetachAllocation(); }
 
-const void *CIF_GET_INTERFACE_CLASS(Buffer, 1)::GetMemoryRaw() const{
-    return CIF_GET_PIMPL()->GetMemoryRaw();
-}
+const void *CIF_GET_INTERFACE_CLASS(Buffer, 1)::GetMemoryRaw() const { return CIF_GET_PIMPL()->GetMemoryRaw(); }
 
-void *CIF_GET_INTERFACE_CLASS(Buffer, 1)::GetMemoryRawWriteable(){
-    return CIF_GET_PIMPL()->GetMemoryRawWriteable();
-}
+void *CIF_GET_INTERFACE_CLASS(Buffer, 1)::GetMemoryRawWriteable() { return CIF_GET_PIMPL()->GetMemoryRawWriteable(); }
 
-size_t CIF_GET_INTERFACE_CLASS(Buffer, 1)::GetSizeRaw() const{
-    return CIF_GET_PIMPL()->GetSizeRaw();
-}
+size_t CIF_GET_INTERFACE_CLASS(Buffer, 1)::GetSizeRaw() const { return CIF_GET_PIMPL()->GetSizeRaw(); }
 
-size_t CIF_GET_INTERFACE_CLASS(Buffer, 1)::GetCapacityRaw() const{
-    return CIF_GET_PIMPL()->GetCapacityRaw();
-}
+size_t CIF_GET_INTERFACE_CLASS(Buffer, 1)::GetCapacityRaw() const { return CIF_GET_PIMPL()->GetCapacityRaw(); }
 
-bool CIF_GET_INTERFACE_CLASS(Buffer, 1)::Resize(size_t newSize){
-    return CIF_GET_PIMPL()->Resize(newSize);
-}
+bool CIF_GET_INTERFACE_CLASS(Buffer, 1)::Resize(size_t newSize) { return CIF_GET_PIMPL()->Resize(newSize); }
 
-bool CIF_GET_INTERFACE_CLASS(Buffer, 1)::Reserve(size_t newCapacity){
-    return CIF_GET_PIMPL()->Reserve(newCapacity);
-}
+bool CIF_GET_INTERFACE_CLASS(Buffer, 1)::Reserve(size_t newCapacity) { return CIF_GET_PIMPL()->Reserve(newCapacity); }
 
-void CIF_GET_INTERFACE_CLASS(Buffer, 1)::Clear(){
-    CIF_GET_PIMPL()->Clear();
-}
+void CIF_GET_INTERFACE_CLASS(Buffer, 1)::Clear() { CIF_GET_PIMPL()->Clear(); }
 
-void CIF_GET_INTERFACE_CLASS(Buffer, 1)::Deallocate(){
-    CIF_GET_PIMPL()->Deallocate();
-}
+void CIF_GET_INTERFACE_CLASS(Buffer, 1)::Deallocate() { CIF_GET_PIMPL()->Deallocate(); }
 
-bool CIF_GET_INTERFACE_CLASS(Buffer, 1)::AlignUp(uint32_t alignment){
-    return CIF_GET_PIMPL()->AlignUp(alignment);
-}
+bool CIF_GET_INTERFACE_CLASS(Buffer, 1)::AlignUp(uint32_t alignment) { return CIF_GET_PIMPL()->AlignUp(alignment); }
 
-bool CIF_GET_INTERFACE_CLASS(Buffer, 1)::PushBackRawBytes(const void *newData, size_t size){
-    return CIF_GET_PIMPL()->PushBackRawBytes(newData, size);
+bool CIF_GET_INTERFACE_CLASS(Buffer, 1)::PushBackRawBytes(const void *newData, size_t size) {
+  return CIF_GET_PIMPL()->PushBackRawBytes(newData, size);
 }
 
-bool CIF_GET_INTERFACE_CLASS(Buffer, 1)::IsConst()const{
-    return CIF_GET_PIMPL()->IsConst();
-}
+bool CIF_GET_INTERFACE_CLASS(Buffer, 1)::IsConst() const { return CIF_GET_PIMPL()->IsConst(); }
 
-}
+} // namespace Builtins
 
-}
+} // namespace CIF
 
 #include "cif/macros/disable.h"
diff --git a/include/igc/cif/cif/builtins/memory/buffer/impl/buffer_impl.h b/include/igc/cif/cif/builtins/memory/buffer/impl/buffer_impl.h
index 329e76c..cec680d 100644
--- a/include/igc/cif/cif/builtins/memory/buffer/impl/buffer_impl.h
+++ b/include/igc/cif/cif/builtins/memory/buffer/impl/buffer_impl.h
@@ -21,284 +21,260 @@ namespace CIF {
 namespace Builtins {
 
 CIF_DECLARE_INTERFACE_PIMPL(Buffer) : CIF::PimplBase {
-    CIF_PIMPL_DECLARE_CONSTRUCTOR(Version_t version, CIF::ICIF *parentInterface) {
-    }
+  CIF_PIMPL_DECLARE_CONSTRUCTOR(Version_t version, CIF::ICIF * parentInterface) {}
 
-    CIF_PIMPL_DECLARE_CONSTRUCTOR(Version_t version) {
-    }
+  CIF_PIMPL_DECLARE_CONSTRUCTOR(Version_t version) {}
 
-    CIF_PIMPL_DECLARE_CONSTRUCTOR() {
-    }
+  CIF_PIMPL_DECLARE_CONSTRUCTOR() {}
 
-    CIF_PIMPL_DECLARE_DESTRUCTOR(){
-        Deallocate();
-    }
+  CIF_PIMPL_DECLARE_DESTRUCTOR() { Deallocate(); }
 
   /// Copies given element to the end of the buffer
   /// Note : If (packed == false), then this function will automatically align current underlying buffer
   ///        pointer to alignof(ElementT)
-  template<typename ElementT>
-  bool PushBackRawCopy(const ElementT &newEl, bool packed = true){
-      static_assert(std::is_pod<ElementT>::value, "Supporting only POD types");
-      if(packed == false){
-          size_t alignment = alignof(ElementT);
-          bool success = AlignUp(alignment);
-          if(success == false){
-              return false;
-          }
+  template <typename ElementT> bool PushBackRawCopy(const ElementT &newEl, bool packed = true) {
+    static_assert(std::is_standard_layout_v<ElementT> && std::is_trivial_v<ElementT>, "Supporting only POD types");
+    if (packed == false) {
+      size_t alignment = alignof(ElementT);
+      bool success = AlignUp(alignment);
+      if (success == false) {
+        return false;
       }
+    }
 
-      return PushBackRawBytes(&newEl, sizeof(ElementT));
+    return PushBackRawBytes(&newEl, sizeof(ElementT));
   }
 
-    /// Sets custom allocator and deallocator functions to be used by this buffer interface
-    /// Note : will reallocate using new allocators only when additional space will be needed
-    /// Note : reallocator is optional and can be nullptr
-    void SetAllocator(AllocatorT allocator, DeallocatorT deallocator, ReallocatorT reallocator){
-        if(allocator == nullptr){
-            allocator = EmptyAllocator;
-        }
-
-        if((this->memory) && (this->tempDeallocator == nullptr)){
-            this->tempDeallocator = this->deallocator;
-        }
-
-        this->allocator = allocator;
-        this->deallocator = deallocator;
-        this->reallocator = reallocator;
+  /// Sets custom allocator and deallocator functions to be used by this buffer interface
+  /// Note : will reallocate using new allocators only when additional space will be needed
+  /// Note : reallocator is optional and can be nullptr
+  void SetAllocator(AllocatorT allocator, DeallocatorT deallocator, ReallocatorT reallocator) {
+    if (allocator == nullptr) {
+      allocator = EmptyAllocator;
     }
 
-    /// Sets underlying buffer storage and its deallocator
-    /// Note : will destroy current underlying buffer (if any)
-    void SetUnderlyingStorage(void *memory, size_t size, DeallocatorT deallocator){
-        Deallocate();
-
-        this->memory = memory;
-        this->size = size;
-        this->capacity = size;
-        this->tempDeallocator = deallocator;
+    if ((this->memory) && (this->tempDeallocator == nullptr)) {
+      this->tempDeallocator = this->deallocator;
     }
 
-    /// Sets underlying constant buffer storage and its deallocator
-    /// Note : will destroy current underlying buffer (if any)
-    /// Note : will allocate new memory if this const memory will be accessed in non-const manners
-    void SetUnderlyingStorage(const void *memory, size_t size){
-        Deallocate();
+    this->allocator = allocator;
+    this->deallocator = deallocator;
+    this->reallocator = reallocator;
+  }
 
-        // casting-away constness, but marking as const
-        this->memory = const_cast<void*>(memory);
-        this->isConst = true;
+  /// Sets underlying buffer storage and its deallocator
+  /// Note : will destroy current underlying buffer (if any)
+  void SetUnderlyingStorage(void *memory, size_t size, DeallocatorT deallocator) {
+    Deallocate();
 
-        this->size = size;
-        this->capacity = size;
-        this->tempDeallocator = nullptr;
-    }
+    this->memory = memory;
+    this->size = size;
+    this->capacity = size;
+    this->tempDeallocator = deallocator;
+  }
 
-    /// Detaches and returns current allocation leaving this buffer's underlying buffer empty
-    void *DetachAllocation(){
-        void *mem = memory;
-        this->memory = nullptr;
-        this->size = 0;
-        this->capacity = 0;
-        this->isConst = false;
-        this->tempDeallocator = nullptr;
-        return mem;
-    }
+  /// Sets underlying constant buffer storage and its deallocator
+  /// Note : will destroy current underlying buffer (if any)
+  /// Note : will allocate new memory if this const memory will be accessed in non-const manners
+  void SetUnderlyingStorage(const void *memory, size_t size) {
+    Deallocate();
 
-    /// Returns const raw access to underlying buffer
-    const void *GetMemoryRaw() const{
-        return memory;
-    }
+    // casting-away constness, but marking as const
+    this->memory = const_cast<void *>(memory);
+    this->isConst = true;
 
-    /// Returns writeable access to underlyng buffer
-    /// Note : for constant buffer this will cause reallocation (copy!) to writeable memory
-    void *GetMemoryRawWriteable(){
-        if(this->isConst && this->capacity != 0){
-            if(false == Reallocate(this->size, this->capacity)){
-                return nullptr;
-            }
-        }
-        return memory;
-    }
+    this->size = size;
+    this->capacity = size;
+    this->tempDeallocator = nullptr;
+  }
 
-    /// Returns size in bytes of underlying buffer
-    size_t GetSizeRaw() const{
-        return size;
-    }
+  /// Detaches and returns current allocation leaving this buffer's underlying buffer empty
+  void *DetachAllocation() {
+    void *mem = memory;
+    this->memory = nullptr;
+    this->size = 0;
+    this->capacity = 0;
+    this->isConst = false;
+    this->tempDeallocator = nullptr;
+    return mem;
+  }
 
-    /// Returns capacity in bytes of underlying buffer
-    size_t GetCapacityRaw() const{
-        return capacity;
-    }
+  /// Returns const raw access to underlying buffer
+  const void *GetMemoryRaw() const { return memory; }
 
-    /// Resizes (may reallocate) underlying buffer's size
-    bool Resize(size_t newSize) {
-        return this->Reallocate(newSize, std::max(this->capacity, newSize));
+  /// Returns writeable access to underlyng buffer
+  /// Note : for constant buffer this will cause reallocation (copy!) to writeable memory
+  void *GetMemoryRawWriteable() {
+    if (this->isConst && this->capacity != 0) {
+      if (false == Reallocate(this->size, this->capacity)) {
+        return nullptr;
+      }
     }
+    return memory;
+  }
 
-    /// Resizes (may reallocate) the underlying buffer's capacity
-    bool Reserve(size_t newCapacity){
-        return this->Reallocate(this->size, newCapacity);
+  /// Returns size in bytes of underlying buffer
+  size_t GetSizeRaw() const { return size; }
+
+  /// Returns capacity in bytes of underlying buffer
+  size_t GetCapacityRaw() const { return capacity; }
+
+  /// Resizes (may reallocate) underlying buffer's size
+  bool Resize(size_t newSize) { return this->Reallocate(newSize, std::max(this->capacity, newSize)); }
+
+  /// Resizes (may reallocate) the underlying buffer's capacity
+  bool Reserve(size_t newCapacity) { return this->Reallocate(this->size, newCapacity); }
+
+  /// Sets the size to 0
+  void Clear() { this->size = 0; }
+
+  /// Sets the size to 0 and deallocates underlying buffer
+  void Deallocate() {
+    if (isConst) {
+      this->memory = nullptr;
+      this->size = 0;
+      this->capacity = 0;
+      this->isConst = false;
+      this->tempDeallocator = nullptr;
+    } else if (tempDeallocator) {
+      tempDeallocator(this->memory);
+      this->memory = nullptr;
+      this->size = 0;
+      this->capacity = 0;
+      this->tempDeallocator = nullptr;
+    } else {
+      if (deallocator != nullptr) {
+        deallocator(this->memory);
+      }
+      this->memory = nullptr;
+      this->size = 0;
+      this->capacity = 0;
     }
+  }
 
-    /// Sets the size to 0
-    void Clear(){
-        this->size = 0;
-    }
+  /// Aligns up current size to meet required alignment
+  bool AlignUp(uint32_t alignment) {
+    size_t misalligned = alignment - (this->size % alignment);
+    size_t newSize = this->size + misalligned;
+    return Reallocate(newSize, newSize);
+  }
 
-    /// Sets the size to 0 and deallocates underlying buffer
-    void Deallocate(){
-        if(isConst){
-            this->memory = nullptr;
-            this->size = 0;
-            this->capacity = 0;
-            this->isConst = false;
-            this->tempDeallocator = nullptr;
-        }else if(tempDeallocator){
-            tempDeallocator(this->memory);
-            this->memory = nullptr;
-            this->size = 0;
-            this->capacity = 0;
-            this->tempDeallocator = nullptr;
-        }else{
-            if(deallocator != nullptr){
-                deallocator(this->memory);
-            }
-            this->memory = nullptr;
-            this->size = 0;
-            this->capacity = 0;
-        }
+  /// Pushes new raw element to buffer
+  bool PushBackRawBytes(const void *newData, size_t size) {
+    if (size == 0) {
+      // nothing to do
+      return true;
     }
 
-    /// Aligns up current size to meet required alignment
-    bool AlignUp(uint32_t alignment){
-        size_t misalligned = alignment - (this->size % alignment);
-        size_t newSize = this->size + misalligned;
-        return Reallocate(newSize, newSize);
+    size_t oldSize = this->size;
+    if (false == Reallocate(this->size + size, this->size + size)) {
+      return false;
     }
 
-    /// Pushes new raw element to buffer
-    bool PushBackRawBytes(const void *newData, size_t size){
-        if(size == 0){
-            // nothing to do
-            return true;
-        }
+    CIF::SafeCopy(CIF::OffsetedPtr(GetMemoryRawWriteable(), oldSize), this->capacity - oldSize, newData, size);
+    return true;
+  }
 
-        size_t oldSize = this->size;
-        if(false == Reallocate(this->size + size, this->size + size)){
-            return false;
-        }
+  /// Can be true if SetUnderlyingStorage(const void *, size_t) was used, please refer to SetUnderlyingStorage
+  bool IsConst() const { return isConst; }
 
-        CIF::SafeCopy(CIF::OffsetedPtr(GetMemoryRawWriteable(), oldSize), this->capacity - oldSize, newData, size);
-        return true;
+protected:
+  static void *CIF_CALLING_CONV EmptyAllocator(size_t size) { return nullptr; }
+
+  static void *CIF_CALLING_CONV DefaultAllocator(size_t size) { return new (std::nothrow) char[size]; }
+
+  static void CIF_CALLING_CONV DefaultDeallocator(void *memory) {
+    if (memory != nullptr) {
+      delete[] reinterpret_cast<char *>(memory);
     }
+  }
 
-    /// Can be true if SetUnderlyingStorage(const void *, size_t) was used, please refer to SetUnderlyingStorage
-    bool IsConst() const{
-        return isConst;
+  bool Reallocate(size_t newSize, size_t newCapacity) {
+    if (isConst) {
+      void *newMem = this->allocator(newCapacity);
+      if (newMem == nullptr) {
+        return false;
+      }
+
+      size_t bytesToCopy = std::min(newSize, this->size);
+      CIF::SafeCopy(newMem, newCapacity, this->memory, bytesToCopy);
+      this->memory = newMem;
+      this->isConst = false;
+      this->tempDeallocator = nullptr;
+      this->capacity = newCapacity;
+      this->size = newSize;
+      return true;
     }
 
-protected:
-    static void * CIF_CALLING_CONV EmptyAllocator(size_t size){
-        return nullptr;
+    if (tempDeallocator != nullptr) {
+      if (newCapacity <= this->capacity) {
+        this->size = newSize;
+        return true;
+      }
+
+      void *newMem = this->allocator(newCapacity);
+      if (newMem == nullptr) {
+        return false;
+      }
+      size_t bytesToCopy = std::min(newSize, this->size);
+      CIF::SafeCopy(newMem, newCapacity, this->memory, bytesToCopy);
+      void *oldMemory = this->memory;
+      this->memory = newMem;
+      this->capacity = newCapacity;
+      this->size = newSize;
+      this->tempDeallocator(oldMemory);
+      this->tempDeallocator = nullptr;
+      return true;
     }
 
-    static void * CIF_CALLING_CONV DefaultAllocator(size_t size){
-        return new(std::nothrow) char[size];
+    if (newCapacity <= this->capacity) {
+      this->size = newSize;
+      return true;
     }
 
-    static void CIF_CALLING_CONV DefaultDeallocator(void * memory){
-        if(memory != nullptr){
-            delete []reinterpret_cast<char*>(memory);
-        }
+    if (reallocator != nullptr) {
+      void *newMem = reallocator(this->memory, this->capacity, newCapacity);
+      if (newMem == nullptr) {
+        return false;
+      }
+
+      this->memory = newMem;
+      this->capacity = newCapacity;
+      this->size = newSize;
+      return true;
     }
 
-    bool Reallocate(size_t newSize, size_t newCapacity){
-        if(isConst){
-            void * newMem = this->allocator(newCapacity);
-            if(newMem == nullptr){
-                return false;
-            }
-
-            size_t bytesToCopy = std::min(newSize, this->size);
-            CIF::SafeCopy(newMem, newCapacity, this->memory, bytesToCopy);
-            this->memory = newMem;
-            this->isConst = false;
-            this->tempDeallocator = nullptr;
-            this->capacity = newCapacity;
-            this->size = newSize;
-            return true;
-        }
-
-        if(tempDeallocator != nullptr){
-            if(newCapacity <= this->capacity){
-                this->size = newSize;
-                return true;
-            }
-
-            void * newMem = this->allocator(newCapacity);
-            if(newMem == nullptr){
-                return false;
-            }
-            size_t bytesToCopy = std::min(newSize, this->size);
-            CIF::SafeCopy(newMem, newCapacity, this->memory, bytesToCopy);
-            void *oldMemory = this->memory;
-            this->memory = newMem;
-            this->capacity = newCapacity;
-            this->size = newSize;
-            this->tempDeallocator(oldMemory);
-            this->tempDeallocator = nullptr;
-            return true;
-        }
-
-        if(newCapacity <= this->capacity){
-            this->size = newSize;
-            return true;
-        }
-
-        if(reallocator != nullptr){
-            void *newMem = reallocator(this->memory, this->capacity, newCapacity);
-            if(newMem == nullptr){
-                return false;
-            }
-
-            this->memory = newMem;
-            this->capacity = newCapacity;
-            this->size = newSize;
-            return true;
-        }
-
-        void *newMem = allocator(newCapacity);
-        if(newMem == nullptr){
-            return false;
-        }
-
-        size_t bytesToCopy = std::min(newSize, this->size);
-        CIF::SafeCopy(newMem, newCapacity, this->memory, bytesToCopy);
-        if(deallocator != nullptr){
-            deallocator(this->memory);
-        }
-        this->memory = newMem;
-        this->capacity = newCapacity;
-        this->size = newSize;
+    void *newMem = allocator(newCapacity);
+    if (newMem == nullptr) {
+      return false;
+    }
 
-        return true;
+    size_t bytesToCopy = std::min(newSize, this->size);
+    CIF::SafeCopy(newMem, newCapacity, this->memory, bytesToCopy);
+    if (deallocator != nullptr) {
+      deallocator(this->memory);
     }
+    this->memory = newMem;
+    this->capacity = newCapacity;
+    this->size = newSize;
+
+    return true;
+  }
 
-    void *memory = nullptr;
-    size_t size = 0;
-    size_t capacity = 0;
-    bool isConst = false;
-    DeallocatorT tempDeallocator = nullptr;
-    AllocatorT allocator = DefaultAllocator;
-    DeallocatorT deallocator = DefaultDeallocator;
-    ReallocatorT reallocator = nullptr;
+  void *memory = nullptr;
+  size_t size = 0;
+  size_t capacity = 0;
+  bool isConst = false;
+  DeallocatorT tempDeallocator = nullptr;
+  AllocatorT allocator = DefaultAllocator;
+  DeallocatorT deallocator = DefaultDeallocator;
+  ReallocatorT reallocator = nullptr;
 };
 
 CIF_DEFINE_INTERFACE_TO_PIMPL_FORWARDING_CTOR_DTOR(Buffer);
 
-}
+} // namespace Builtins
 
-}
+} // namespace CIF
 
 #include "cif/macros/disable.h"
diff --git a/include/igc/cif/cif/common/cif.h b/include/igc/cif/cif/common/cif.h
index ba7c029..d34967b 100644
--- a/include/igc/cif/cif/common/cif.h
+++ b/include/igc/cif/cif/common/cif.h
@@ -23,41 +23,35 @@ namespace CIF {
 constexpr Version_t CifFrameworkVersion = 2;
 
 namespace RAII {
-template <typename T>
-struct ReleaseHelper {
-    void operator() (T *handle) const {
-        assert(handle != nullptr);
-        handle->Release();
-    }
+template <typename T> struct ReleaseHelper {
+  void operator()(T *handle) const {
+    assert(handle != nullptr);
+    handle->Release();
+  }
 };
 
-template <typename T>
-using UPtr_t = std::unique_ptr<T, ReleaseHelper<T>>;
+template <typename T> using UPtr_t = std::unique_ptr<T, ReleaseHelper<T>>;
 
-template <typename T> static UPtr_t<T> UPtr(T *handle) {
-    return UPtr_t<T>(handle);
-}
+template <typename T> static UPtr_t<T> UPtr(T *handle) { return UPtr_t<T>(handle); }
 
-template<typename DstType, typename SrcType>
-UPtr_t<DstType> RetainAndPack(SrcType * ptr){
-    if(ptr == nullptr){
-        return UPtr<DstType>(nullptr);
-    }
+template <typename DstType, typename SrcType> UPtr_t<DstType> RetainAndPack(SrcType *ptr) {
+  if (ptr == nullptr) {
+    return UPtr<DstType>(nullptr);
+  }
 
-    ptr->Retain();
-    return UPtr<DstType>(static_cast<DstType*>(ptr));
+  ptr->Retain();
+  return UPtr<DstType>(static_cast<DstType *>(ptr));
 }
 
-template<typename DstType, typename SrcType>
-UPtr_t<DstType> Pack(SrcType * ptr){
-    if(ptr == nullptr){
-        return UPtr<DstType>(nullptr);
-    }
+template <typename DstType, typename SrcType> UPtr_t<DstType> Pack(SrcType *ptr) {
+  if (ptr == nullptr) {
+    return UPtr<DstType>(nullptr);
+  }
 
-    return UPtr<DstType>(static_cast<DstType*>(ptr));
+  return UPtr<DstType>(static_cast<DstType *>(ptr));
 }
 
-}
+} // namespace RAII
 
 // generic interface for all components
 struct ICIF {
@@ -72,46 +66,37 @@ struct ICIF {
 
   virtual Version_t GetEnabledVersion() const = 0;
   virtual Version_t GetUnderlyingVersion() const {
-      return GetEnabledVersion(); // by default : redirect to enabled version
+    return GetEnabledVersion(); // by default : redirect to enabled version
   }
-  virtual bool GetSupportedVersions(InterfaceId_t intId, Version_t &verMin,
-                                    Version_t &verMax) const {
-      return false; // by default : no sub-interface are supported
+  virtual bool GetSupportedVersions(InterfaceId_t intId, Version_t &verMin, Version_t &verMax) const {
+    return false; // by default : no sub-interface are supported
   }
 
   // get specific version of interface
-  template <typename InterfaceT, Version_t version>
-  RAII::UPtr_t<InterfaceT> CreateInterface() {
-    static_assert((version >= InterfaceT::GetBackwardsCompatibilityVersion()) &&
-                      (version <= InterfaceT::GetVersion()),
+  template <typename InterfaceT, Version_t version> RAII::UPtr_t<InterfaceT> CreateInterface() {
+    static_assert((version >= InterfaceT::GetBackwardsCompatibilityVersion()) && (version <= InterfaceT::GetVersion()),
                   "Invalid version requested");
-    return RAII::UPtr(reinterpret_cast<InterfaceT *>(
-        CreateInterfaceImpl(InterfaceT::GetInterfaceId(), version)));
+    return RAII::UPtr(reinterpret_cast<InterfaceT *>(CreateInterfaceImpl(InterfaceT::GetInterfaceId(), version)));
   }
 
   // get latest version of interface that matches interface class
-  template <typename InterfaceT>
-  RAII::UPtr_t<InterfaceT> CreateInterface() {
+  template <typename InterfaceT> RAII::UPtr_t<InterfaceT> CreateInterface() {
     uint64_t minVerSupported = 0;
     uint64_t maxVerSupported = 0;
-    if (false == GetSupportedVersions(InterfaceT::GetInterfaceId(),
-                                      minVerSupported, maxVerSupported)) {
+    if (false == GetSupportedVersions(InterfaceT::GetInterfaceId(), minVerSupported, maxVerSupported)) {
       // interface not supported
       return RAII::UPtr<InterfaceT>(nullptr);
     }
 
-    if ((InterfaceT::GetVersion() < minVerSupported) ||
-        (InterfaceT::GetVersion() > maxVerSupported)) {
+    if ((InterfaceT::GetVersion() < minVerSupported) || (InterfaceT::GetVersion() > maxVerSupported)) {
       // interface version not supported
       return RAII::UPtr<InterfaceT>(nullptr);
     }
 
     // get latest compatible
-    uint64_t chosenVersion =
-        std::min(maxVerSupported, InterfaceT::GetVersion());
+    uint64_t chosenVersion = std::min(maxVerSupported, InterfaceT::GetVersion());
 
-    return RAII::UPtr(reinterpret_cast<InterfaceT *>(
-        CreateInterfaceImpl(InterfaceT::GetInterfaceId(), chosenVersion)));
+    return RAII::UPtr(reinterpret_cast<InterfaceT *>(CreateInterfaceImpl(InterfaceT::GetInterfaceId(), chosenVersion)));
   }
 
 protected:
@@ -119,97 +104,86 @@ struct ICIF {
   virtual ~ICIF() = default;
 
   virtual ICIF *CreateInterfaceImpl(InterfaceId_t intId, Version_t version) {
-      return nullptr; // by default : no sub-interface are supported
+    return nullptr; // by default : no sub-interface are supported
   }
 };
 
-template <InterfaceId_t id, typename BaseClass = ICIF>
-struct NamedCIF : public BaseClass {
+template <InterfaceId_t id, typename BaseClass = ICIF> struct NamedCIF : public BaseClass {
   static constexpr InterfaceId_t GetInterfaceId() { return id; };
 };
 
-template <template <Version_t> class BaseClass, Version_t VersionP,
-          Version_t BackwardsCompatibilityVersionP = VersionP,
+template <template <Version_t> class BaseClass, Version_t VersionP, Version_t BackwardsCompatibilityVersionP = VersionP,
           Version_t InheritFromVersion =
               (VersionP == BackwardsCompatibilityVersionP)
                   ? 0
                   : BackwardsCompatibilityVersionP /* TODO : assertion - backwards compatibility chain*/>
 struct VersionedCIF : public BaseClass<InheritFromVersion> {
   template <typename... Args>
-  VersionedCIF(Args &&... args)
-      : BaseClass<InheritFromVersion>(std::forward<Args>(args)...) {}
-
-  static constexpr Version_t GetVersion(){ return VersionP; }
-  static constexpr Version_t GetBackwardsCompatibilityVersion(){ return BackwardsCompatibilityVersionP; }
-  Version_t GetUnderlyingVersion() const override
-  {
-      return VersionP;
-  }
+  VersionedCIF(Args &&...args) : BaseClass<InheritFromVersion>(std::forward<Args>(args)...) {}
+
+  static constexpr Version_t GetVersion() { return VersionP; }
+  static constexpr Version_t GetBackwardsCompatibilityVersion() { return BackwardsCompatibilityVersionP; }
+  Version_t GetUnderlyingVersion() const override { return VersionP; }
   // Compatible versions are all versions from BackwardsCompatibilityVersion
   // up-to Version
 
-  static_assert((GetVersion() >= MinVersion) && (GetVersion() <= MaxVersion),
-                "Invalid version");
+  static_assert((GetVersion() >= MinVersion) && (GetVersion() <= MaxVersion), "Invalid version");
 };
 
 template <typename Interface> class HasVersion {
   template <typename I>
-  static constexpr typename std::enable_if<I::GetVersion() != InvalidVersion,
-                                           std::true_type>::type
-  Evaluate(int);
+  static constexpr typename std::enable_if<I::GetVersion() != InvalidVersion, std::true_type>::type Evaluate(int);
 
   template <typename I> static constexpr std::false_type Evaluate(...);
 
 public:
-    static constexpr bool GetValue(){ return decltype(Evaluate<Interface>(0))::value; }
+  static constexpr bool GetValue() { return decltype(Evaluate<Interface>(0))::value; }
 };
 
-template <template <Version_t> class Interface>
-struct FindVersion {
-  template <Version_t CurrVersion>
-  static constexpr Version_t GetVersion() {
-    return GetVersionHelper<CurrVersion>(typename std::integral_constant<bool, HasVersion<Interface<CurrVersion>>::GetValue()>::type{});
+template <template <Version_t> class Interface> struct FindVersion {
+  template <Version_t CurrVersion> static constexpr Version_t GetVersion() {
+    return GetVersionHelper<CurrVersion>(
+        typename std::integral_constant<bool, HasVersion<Interface<CurrVersion>>::GetValue()>::type{});
   }
 
-  template <Version_t CurrVersion = 1>
-  static constexpr Version_t FindOldest() {
-    return FindOldestHelper<CurrVersion>(typename std::integral_constant<bool, HasVersion<Interface<CurrVersion>>::GetValue()>::type{},
-                                         typename std::integral_constant<bool, HasVersion<Interface<CurrVersion - 1>>::GetValue()>::type{});
+  template <Version_t CurrVersion = 1> static constexpr Version_t FindOldest() {
+    return FindOldestHelper<CurrVersion>(
+        typename std::integral_constant<bool, HasVersion<Interface<CurrVersion>>::GetValue()>::type{},
+        typename std::integral_constant<bool, HasVersion<Interface<CurrVersion - 1>>::GetValue()>::type{});
   }
 
-  template <Version_t CurrVersion = 1>
-  static constexpr Version_t FindLatest(){
-      return FindLatestHelper<IsLatestVer<CurrVersion>(), CurrVersion>();
+  template <Version_t CurrVersion = 1> static constexpr Version_t FindLatest() {
+    return FindLatestHelper<IsLatestVer<CurrVersion>(), CurrVersion>();
   }
 
 protected:
-  template <Version_t CurrVersion>
-  static constexpr
-  Version_t GetVersionHelper(std::true_type hasVersion) {
+  template <Version_t CurrVersion> static constexpr Version_t GetVersionHelper(std::true_type hasVersion) {
     return Interface<CurrVersion>::GetVersion();
   }
 
-  template <Version_t CurrVersion>
-  static constexpr Version_t GetVersionHelper(std::false_type hasVersion) {
+  template <Version_t CurrVersion> static constexpr Version_t GetVersionHelper(std::false_type hasVersion) {
     return InvalidVersion;
   }
 
- template <Version_t CurrVersion = 1>
+  template <Version_t CurrVersion = 1>
   static constexpr Version_t FindOldestHelper(std::false_type hasVersion, std::true_type prevHasVersion) {
-    return FindOldestHelper<CurrVersion + 1>(typename std::integral_constant<bool, HasVersion<Interface<CurrVersion + 1>>::GetValue()>::type{},
-                                             typename std::integral_constant<bool, HasVersion<Interface<CurrVersion>>::GetValue()>::type{});
+    return FindOldestHelper<CurrVersion + 1>(
+        typename std::integral_constant<bool, HasVersion<Interface<CurrVersion + 1>>::GetValue()>::type{},
+        typename std::integral_constant<bool, HasVersion<Interface<CurrVersion>>::GetValue()>::type{});
   }
 
   template <Version_t CurrVersion = 1>
   static constexpr Version_t FindOldestHelper(std::false_type hasVersion, std::false_type prevHasVersion) {
-    return FindOldestHelper<CurrVersion + 1>(typename std::integral_constant<bool, HasVersion<Interface<CurrVersion + 1>>::GetValue()>::type{},
-                                             typename std::integral_constant<bool, HasVersion<Interface<CurrVersion>>::GetValue()>::type{});
+    return FindOldestHelper<CurrVersion + 1>(
+        typename std::integral_constant<bool, HasVersion<Interface<CurrVersion + 1>>::GetValue()>::type{},
+        typename std::integral_constant<bool, HasVersion<Interface<CurrVersion>>::GetValue()>::type{});
   }
 
   template <Version_t CurrVersion = 1>
   static constexpr Version_t FindOldestHelper(std::true_type hasVersion, std::true_type prevHasVersion) {
-    return FindOldestHelper<CurrVersion - 1>(typename std::integral_constant<bool, HasVersion<Interface<CurrVersion - 1>>::GetValue()>::type{},
-                                             typename std::integral_constant<bool, HasVersion<Interface<CurrVersion - 2>>::GetValue()>::type{});
+    return FindOldestHelper<CurrVersion - 1>(
+        typename std::integral_constant<bool, HasVersion<Interface<CurrVersion - 1>>::GetValue()>::type{},
+        typename std::integral_constant<bool, HasVersion<Interface<CurrVersion - 2>>::GetValue()>::type{});
   }
 
   template <Version_t CurrVersion = 1>
@@ -217,9 +191,8 @@ struct FindVersion {
     return Interface<CurrVersion>::GetVersion();
   }
 
-  template<Version_t Version>
-  static constexpr bool IsLatestVer(){
-      return (false == HasVersion<Interface<Version + 1>>::GetValue()) && (HasVersion<Interface<Version>>::GetValue());
+  template <Version_t Version> static constexpr bool IsLatestVer() {
+    return (false == HasVersion<Interface<Version + 1>>::GetValue()) && (HasVersion<Interface<Version>>::GetValue());
   }
 
   template <bool IsLatest, Version_t CurrVersion = 1>
@@ -229,36 +202,33 @@ struct FindVersion {
 
   template <bool IsLatest, Version_t CurrVersion = 1>
   static constexpr typename std::enable_if<false == IsLatest, Version_t>::type FindLatestHelper() {
-      return FindLatestHelper<IsLatestVer<CurrVersion+1>(), CurrVersion + 1>();
+    return FindLatestHelper<IsLatestVer<CurrVersion + 1>(), CurrVersion + 1>();
   }
 };
 
-template <template <Version_t> class Interface,
-          Version_t Oldest = CIF::MinVersion>
-struct SupportedVersions {
-    static constexpr Version_t GetOldestSupportedVersion()
-    {
-        return FindVersion<Interface>::template FindOldest<Oldest>();
-    }
+template <template <Version_t> class Interface, Version_t Oldest = CIF::MinVersion> struct SupportedVersions {
+  static constexpr Version_t GetOldestSupportedVersion() {
+    return FindVersion<Interface>::template FindOldest<Oldest>();
+  }
 
-    static constexpr Version_t GetLatestSupportedVersion()
-    {
-        static_assert(CIF::FindVersion<Interface>::template FindLatest<SupportedVersions<Interface, Oldest>::GetOldestSupportedVersion()>(), "Workaround for VS 2015");
-        return CIF::FindVersion<Interface>::template FindLatest<SupportedVersions<Interface, Oldest>::GetOldestSupportedVersion()>();
-    }
+  static constexpr Version_t GetLatestSupportedVersion() {
+    static_assert(CIF::FindVersion<Interface>::template FindLatest<
+                      SupportedVersions<Interface, Oldest>::GetOldestSupportedVersion()>(),
+                  "Workaround for VS 2015");
+    return CIF::FindVersion<Interface>::template FindLatest<
+        SupportedVersions<Interface, Oldest>::GetOldestSupportedVersion()>();
+  }
 
-    static constexpr Version_t GetNumSupportedVersions()
-    {
-        return static_cast<Version_t>((GetLatestSupportedVersion() == CIF::BaseVersion) ? 0 :
-                                                                                        ((GetLatestSupportedVersion() - GetOldestSupportedVersion()) + 1)
-                                     );
-    }
+  static constexpr Version_t GetNumSupportedVersions() {
+    return static_cast<Version_t>((GetLatestSupportedVersion() == CIF::BaseVersion)
+                                      ? 0
+                                      : ((GetLatestSupportedVersion() - GetOldestSupportedVersion()) + 1));
+  }
 };
 
 template <template <Version_t> class... Interfaces> struct InterfacePack;
 
-template <template <Version_t> class Interface,
-          template <Version_t> class... Interfaces>
+template <template <Version_t> class Interface, template <Version_t> class... Interfaces>
 struct InterfacePack<Interface, Interfaces...> {
   template <Version_t V> using Current = Interface<V>;
   using Next = InterfacePack<Interfaces...>;
@@ -269,24 +239,18 @@ template <> struct InterfacePack<> {
   using Next = InterfacePack<>;
 };
 
-
-struct IsInterfaceIdFwdToOne
-{
-    template<template <Version_t> class Interface>
-    static bool Call(){
-        return true;
-    }
+struct IsInterfaceIdFwdToOne {
+  template <template <Version_t> class Interface> static bool Call() { return true; }
 };
 
 /// Storage for versioned CIF interfaces
 /// Useful in operations on sets of interfaces
-template <template <Version_t> class... SupportedInterfaces>
-struct InterfacesList {
+template <template <Version_t> class... SupportedInterfaces> struct InterfacesList {
   /// Calls Callable::Call with requested interface as template parameter.
   /// Arguments (args) will be forwarded as regular function parameters to Callable::Call.
   /// If requested interface is not on the list, then defaultValue is returned.
   template <typename Callable, typename RetType, typename DefaultValueT, typename... Args>
-  static RetType forwardToOne(InterfaceId_t requestedInterfaceId, DefaultValueT &&defaultValue, Args &&... args) {
+  static RetType forwardToOne(InterfaceId_t requestedInterfaceId, DefaultValueT &&defaultValue, Args &&...args) {
     return forwardToOneImpl<0, RetType, Callable, DefaultValueT, InterfacePack<SupportedInterfaces...>, Args...>(
         requestedInterfaceId, std::forward<DefaultValueT>(defaultValue), std::forward<Args>(args)...);
   }
@@ -301,8 +265,7 @@ struct InterfacesList {
 
   /// Calls Callable::Call with all contained interfaces (sequentially, one at a time) as template parameters.
   /// Arguments will be forwarded as regular function parameters to Callable::Call.
-  template <typename Callable, typename... Args>
-  static void forwardToAll(Args &&... args) {
+  template <typename Callable, typename... Args> static void forwardToAll(Args &&...args) {
     forwardToAllImpl<0, Callable, InterfacePack<SupportedInterfaces...>, Args...>(std::forward<Args>(args)...);
   }
 
@@ -310,64 +273,50 @@ struct InterfacesList {
   /// Could do sizeof...(SupportedInterfaces) instead, but GCC 4.8 has a bug
   static constexpr uint32_t GetNumInterfaces() {
 #if defined _WIN32
-      return sizeof...(SupportedInterfaces);
+    return sizeof...(SupportedInterfaces);
 #else
     return GetNumInterfacesImpl<SupportedInterfaces...>();
 #endif
   }
 
-  static bool ContainsInterface(InterfaceId_t id){
-      return forwardToOne<IsInterfaceIdFwdToOne, bool, bool>(id, false);
-  }
+  static bool ContainsInterface(InterfaceId_t id) { return forwardToOne<IsInterfaceIdFwdToOne, bool, bool>(id, false); }
 
 protected:
-  template<typename T = void>
-  static constexpr uint32_t GetNumInterfacesImpl(){
-      return 0;
-  }
+  template <typename T = void> static constexpr uint32_t GetNumInterfacesImpl() { return 0; }
 
-  template<template <Version_t> class InterfaceT, template <Version_t> class... RestInterfacesT>
-  static constexpr uint32_t GetNumInterfacesImpl(){
-      return 1 + GetNumInterfacesImpl<RestInterfacesT...>();
+  template <template <Version_t> class InterfaceT, template <Version_t> class... RestInterfacesT>
+  static constexpr uint32_t GetNumInterfacesImpl() {
+    return 1 + GetNumInterfacesImpl<RestInterfacesT...>();
   }
 
-  template <uint32_t InterfaceIt, typename RetType, typename Callable,
-            typename DefaultValueT, typename IP, typename... Args>
-  static
-      typename std::enable_if<InterfaceIt == GetNumInterfaces(), RetType>::type
-      forwardToOneImpl(InterfaceId_t requestedInterfaceId,
-                  DefaultValueT &&defaultValue, Args &&... args) {
+  template <uint32_t InterfaceIt, typename RetType, typename Callable, typename DefaultValueT, typename IP,
+            typename... Args>
+  static typename std::enable_if<InterfaceIt == GetNumInterfaces(), RetType>::type
+  forwardToOneImpl(InterfaceId_t requestedInterfaceId, DefaultValueT &&defaultValue, Args &&...args) {
     return defaultValue;
   }
 
-  template <uint32_t InterfaceIt, typename RetType, typename Callable,
-            typename DefaultValueT, typename IP, typename... Args>
+  template <uint32_t InterfaceIt, typename RetType, typename Callable, typename DefaultValueT, typename IP,
+            typename... Args>
       static typename std::enable_if <
-      InterfaceIt<GetNumInterfaces(), RetType>::type
-      forwardToOneImpl(InterfaceId_t requestedInterfaceId,
-                  DefaultValueT &&defaultValue, Args &&... args) {
-    if (IP::template Current<BaseVersion>::GetInterfaceId() ==
-        requestedInterfaceId) {
+      InterfaceIt<GetNumInterfaces(), RetType>::type forwardToOneImpl(InterfaceId_t requestedInterfaceId,
+                                                                      DefaultValueT &&defaultValue, Args &&...args) {
+    if (IP::template Current<BaseVersion>::GetInterfaceId() == requestedInterfaceId) {
       return Callable::template Call<IP::template Current>(std::forward<Args>(args)...);
     } else {
-      return forwardToOneImpl<InterfaceIt + 1, RetType, Callable, DefaultValueT,
-                         typename IP::Next, Args...>(
-          requestedInterfaceId, std::forward<DefaultValueT>(defaultValue),
-          std::forward<Args>(args)...);
+      return forwardToOneImpl<InterfaceIt + 1, RetType, Callable, DefaultValueT, typename IP::Next, Args...>(
+          requestedInterfaceId, std::forward<DefaultValueT>(defaultValue), std::forward<Args>(args)...);
     }
   }
 
   template <uint32_t InterfaceIt, typename Callable, typename IP, typename... Args>
-  static typename std::enable_if<InterfaceIt == GetNumInterfaces(), void>::type
-      forwardToAllImpl(Args &&... args) {
-  }
+  static typename std::enable_if<InterfaceIt == GetNumInterfaces(), void>::type forwardToAllImpl(Args &&...args) {}
 
   template <uint32_t InterfaceIt, typename Callable, typename IP, typename... Args>
-  static typename std::enable_if<InterfaceIt < GetNumInterfaces(), void>::type
-      forwardToAllImpl(Args &&... args) {
-      Callable::template Call<IP::template Current>(std::forward<Args>(args)...);
-      forwardToAllImpl<InterfaceIt + 1, Callable, typename IP::Next, Args...>(std::forward<Args>(args)...);
-    }
+      static typename std::enable_if < InterfaceIt<GetNumInterfaces(), void>::type forwardToAllImpl(Args &&...args) {
+    Callable::template Call<IP::template Current>(std::forward<Args>(args)...);
+    forwardToAllImpl<InterfaceIt + 1, Callable, typename IP::Next, Args...>(std::forward<Args>(args)...);
+  }
 };
 
 template <template <Version_t> class... Interfaces> struct UsedInterfaces {
@@ -384,7 +333,7 @@ constexpr Version_t SetCompatibilityV(Version_t v) { return v; }
 constexpr Version_t SetLatestVersion(Version_t v) { return v; }
 
 constexpr Version_t SetOldestVersion(Version_t v) { return v; }
-}
+} // namespace ExplicitTemplateArgs
 
 namespace E // namespace alias for shorter typing
 {
@@ -393,45 +342,32 @@ using namespace CIF::ExplicitTemplateArgs;
 
 template <typename... Types> struct TypesPack;
 
-template <typename Type, typename... RemainingTypes>
-struct TypesPack<Type, RemainingTypes...> {
+template <typename Type, typename... RemainingTypes> struct TypesPack<Type, RemainingTypes...> {
   using ThisType = TypesPack<Type, RemainingTypes...>;
   using Current = Type;
   using Next = TypesPack<RemainingTypes...>;
 
-  template<size_t Num>
+  template <size_t Num>
   constexpr static typename std::enable_if<Num == 0, typename ThisType::Current>::type GetTypeHelper();
 
-  template<size_t Num>
-  constexpr static typename std::enable_if<(Num > 0), typename Next::template GetType<Num-1>>::type GetTypeHelper();
+  template <size_t Num>
+  constexpr static typename std::enable_if<(Num > 0), typename Next::template GetType<Num - 1>>::type GetTypeHelper();
 
-  constexpr static size_t Count()
-  {
-      return 1 + Next::Count();
-  }
+  constexpr static size_t Count() { return 1 + Next::Count(); }
 
-  template<size_t Num>
-  using GetType = decltype(GetTypeHelper<Num>());
+  template <size_t Num> using GetType = decltype(GetTypeHelper<Num>());
 };
 
 template <> struct TypesPack<> {
   using Current = TypesPack<>;
   using Next = TypesPack<>;
   struct InvalidTypeS;
-  using InvalidType = InvalidTypeS*;
+  using InvalidType = InvalidTypeS *;
 
-  template<size_t Num>
-  constexpr static InvalidType GetTypeHelper()
-  {
-      return nullptr;
-  }
+  template <size_t Num> constexpr static InvalidType GetTypeHelper() { return nullptr; }
 
-  constexpr static size_t Count()
-  {
-      return 0;
-  }
+  constexpr static size_t Count() { return 0; }
 
-  template<size_t Num>
-  using GetType = decltype(GetTypeHelper<Num>());
+  template <size_t Num> using GetType = decltype(GetTypeHelper<Num>());
 };
-}
+} // namespace CIF
diff --git a/include/igc/cif/cif/common/cif_main.h b/include/igc/cif/cif/common/cif_main.h
index 010a5ac..e88efb7 100644
--- a/include/igc/cif/cif/common/cif_main.h
+++ b/include/igc/cif/cif/common/cif_main.h
@@ -20,35 +20,35 @@ namespace CIF {
 struct CIFMain : public ICIF {
   virtual Version_t GetBinaryVersion() const = 0;
 
-  template <template <Version_t> class InterfaceEntryPoint> bool IsCompatible(const std::vector<InterfaceId_t> *interfacesToIgnore = nullptr) {
-      return FindIncompatible<InterfaceEntryPoint>(interfacesToIgnore) == InvalidInterface;
+  template <template <Version_t> class InterfaceEntryPoint>
+  bool IsCompatible(const std::vector<InterfaceId_t> *interfacesToIgnore = nullptr) {
+    return FindIncompatible<InterfaceEntryPoint>(interfacesToIgnore) == InvalidInterface;
   }
 
   template <template <Version_t> class InterfaceEntryPoint>
   InterfaceId_t FindIncompatible(const std::vector<InterfaceId_t> *interfacesToIgnore = nullptr) {
-      CompatibilityEncoder encoder;
-      auto encoded = encoder.Encode<InterfaceEntryPoint>(interfacesToIgnore);
-      return FindIncompatibleImpl(InterfaceEntryPoint<BaseVersion>::GetInterfaceId(), encoded);
+    CompatibilityEncoder encoder;
+    auto encoded = encoder.Encode<InterfaceEntryPoint>(interfacesToIgnore);
+    return FindIncompatibleImpl(InterfaceEntryPoint<BaseVersion>::GetInterfaceId(), encoded);
   }
 
   template <template <Version_t> class InterfaceEntryPoint>
   bool FindSupportedVersions(InterfaceId_t subIntId, Version_t &verMin, Version_t &verMax) const {
-      return FindSupportedVersionsImpl(InterfaceEntryPoint<BaseVersion>::GetInterfaceId(), subIntId, verMin, verMax);
+    return FindSupportedVersionsImpl(InterfaceEntryPoint<BaseVersion>::GetInterfaceId(), subIntId, verMin, verMax);
   }
 
   // get latest version of builtin that matches interface class
-  template <typename BuiltinT>
-  RAII::UPtr_t<BuiltinT> CreateBuiltin() {
-      return CreateInterface<BuiltinT>();
-  }
+  template <typename BuiltinT> RAII::UPtr_t<BuiltinT> CreateBuiltin() { return CreateInterface<BuiltinT>(); }
 
 protected:
-    CIFMain() = default;
-
-    virtual InterfaceId_t FindIncompatibleImpl(InterfaceId_t entryPointInterface, CIF::CompatibilityDataHandle handle) const = 0;
-    virtual bool FindSupportedVersionsImpl(InterfaceId_t entryPointInterface, InterfaceId_t interfaceToFind, Version_t &verMin, Version_t &verMax) const {
-        Abort(); // make pure-virtual once all mocks addapt to new interface
-        return false;
-    }
+  CIFMain() = default;
+
+  virtual InterfaceId_t FindIncompatibleImpl(InterfaceId_t entryPointInterface,
+                                             CIF::CompatibilityDataHandle handle) const = 0;
+  virtual bool FindSupportedVersionsImpl(InterfaceId_t entryPointInterface, InterfaceId_t interfaceToFind,
+                                         Version_t &verMin, Version_t &verMax) const {
+    Abort(); // make pure-virtual once all mocks addapt to new interface
+    return false;
+  }
 };
-}
+} // namespace CIF
diff --git a/include/igc/cif/cif/common/coder.h b/include/igc/cif/cif/common/coder.h
index 256a555..8070d95 100644
--- a/include/igc/cif/cif/common/coder.h
+++ b/include/igc/cif/cif/common/coder.h
@@ -22,29 +22,18 @@ enum Mode { Text = 0, Numeric = 1 };
 
 template <Mode M> struct Traits;
 
-template<typename T, T ... RestVals>
-struct ConstexprArray;
+template <typename T, T... RestVals> struct ConstexprArray;
 
-template<typename T>
-struct ConstexprArray<T>{
-    static constexpr T Get(size_t Idx){
-        return 0;
-    }
+template <typename T> struct ConstexprArray<T> {
+  static constexpr T Get(size_t Idx) { return 0; }
 
-    static constexpr T Size(){
-        return 0;
-    }
+  static constexpr T Size() { return 0; }
 };
 
-template<typename T, T Val, T ... RestVals>
-struct ConstexprArray<T, Val, RestVals...>{
-  static constexpr T Get(size_t Idx){
-    return (Idx == 0) ? Val : ConstexprArray<T, RestVals...>::Get(Idx-1);
-  }
+template <typename T, T Val, T... RestVals> struct ConstexprArray<T, Val, RestVals...> {
+  static constexpr T Get(size_t Idx) { return (Idx == 0) ? Val : ConstexprArray<T, RestVals...>::Get(Idx - 1); }
 
-  static constexpr size_t Size(){
-      return 1 + ConstexprArray<T, RestVals...>::Size();
-  }
+  static constexpr size_t Size() { return 1 + ConstexprArray<T, RestVals...>::Size(); }
 };
 
 template <> struct Traits<Text> {
@@ -56,8 +45,7 @@ template <> struct Traits<Text> {
   static constexpr char SwitchModeMarker = (char)SpecialChars::Size();
 
   static_assert((static_cast<size_t>(1) << CodingSize) >
-                    static_cast<size_t>(((LastChar - FirstChar) +
-                                         SwitchModeMarker + 1)),
+                    static_cast<size_t>(((LastChar - FirstChar) + SwitchModeMarker + 1)),
                 "Invalid Encoding");
 
   static constexpr Mode OpositeTraits = Numeric;
@@ -71,109 +59,91 @@ template <> struct Traits<Numeric> {
   using SpecialChars = ConstexprArray<char, '-', '_', ':', '#', '.'>;
   static constexpr char SwitchModeMarker = (char)SpecialChars::Size();
 
-  static_assert((static_cast<size_t>(1) << CodingSize) >
-                    ((LastChar - FirstChar) + SwitchModeMarker + 1),
+  static_assert((static_cast<size_t>(1) << CodingSize) > ((LastChar - FirstChar) + SwitchModeMarker + 1),
                 "Invalid Encoding");
 
   static constexpr Mode OpositeTraits = Text;
 };
 
-template <typename CurrTraits> inline bool IsSwitchMode(char v) {
-  return false;
-}
+template <typename CurrTraits> inline bool IsSwitchMode(char v) { return false; }
 
-template <typename T, typename CurrTraits>
-inline constexpr T EncSwitchMode(uint32_t offset) {
-  return static_cast<T>(
-             (CurrTraits::SpecialCharsOffset + CurrTraits::SwitchModeMarker))
-         << offset;
+template <typename T, typename CurrTraits> inline constexpr T EncSwitchMode(uint32_t offset) {
+  return static_cast<T>((CurrTraits::SpecialCharsOffset + CurrTraits::SwitchModeMarker)) << offset;
 }
 
-template <typename CurrTraits>
-inline constexpr bool IsSpecialChar(char v, uint32_t offset = 0) {
+template <typename CurrTraits> inline constexpr bool IsSpecialChar(char v, uint32_t offset = 0) {
   return (offset >= CurrTraits::SpecialChars::Size())
              ? false
-             : (v == CurrTraits::SpecialChars::Get(offset)) ||
-                   IsSpecialChar<CurrTraits>(v, offset + 1);
+             : (v == CurrTraits::SpecialChars::Get(offset)) || IsSpecialChar<CurrTraits>(v, offset + 1);
 }
 
 template <typename CurrTraits> inline constexpr bool IsValid(char v) {
-  return ((v >= CurrTraits::FirstChar) && (v <= CurrTraits::LastChar)) ||
-         (IsSpecialChar<CurrTraits>(v));
+  return ((v >= CurrTraits::FirstChar) && (v <= CurrTraits::LastChar)) || (IsSpecialChar<CurrTraits>(v));
 }
 
 template <typename T, typename CurrTraits>
-inline constexpr T EncSpecialChar(char v, uint32_t bitOffset,
-                                  uint32_t offset = 0) {
+inline constexpr T EncSpecialChar(char v, uint32_t bitOffset, uint32_t offset = 0) {
   return (offset >= CurrTraits::SpecialChars::Size())
              ? CIF::Abort<T>()
              : ((v == CurrTraits::SpecialChars::Get(offset))
-                    ? (static_cast<T>(CurrTraits::SpecialCharsOffset + offset)
-                       << bitOffset)
+                    ? (static_cast<T>(CurrTraits::SpecialCharsOffset + offset) << bitOffset)
                     : EncSpecialChar<T, CurrTraits>(v, bitOffset, offset + 1));
 }
 
-template <typename T, typename CurrTraits>
-inline constexpr T EncOneChar(char v, uint32_t bitOffset) {
-  return (IsValid<CurrTraits>(v) == false)
-             ? CIF::Abort<T>()
-             : ((((v >= CurrTraits::FirstChar) && (v <= CurrTraits::LastChar))
-                     ? (static_cast<T>(v - CurrTraits::FirstChar) << bitOffset)
-                     : EncSpecialChar<T, CurrTraits>(v, bitOffset)));
+template <typename T, typename CurrTraits> inline constexpr T EncOneChar(char v, uint32_t bitOffset) {
+  return (IsValid<CurrTraits>(v) == false) ? CIF::Abort<T>()
+                                           : ((((v >= CurrTraits::FirstChar) && (v <= CurrTraits::LastChar))
+                                                   ? (static_cast<T>(v - CurrTraits::FirstChar) << bitOffset)
+                                                   : EncSpecialChar<T, CurrTraits>(v, bitOffset)));
 }
 
 // This is to prevent clang from blowing-up
 constexpr uint32_t MaxTemplateDepth = 32;
 
 template <typename T, typename CurrTraits, uint32_t Depth>
-inline constexpr typename std::enable_if<Depth >= MaxTemplateDepth, T>::type EncTrailWithSwitchMode(uint32_t bitOffset) {
+inline constexpr typename std::enable_if<Depth >= MaxTemplateDepth, T>::type
+EncTrailWithSwitchMode(uint32_t bitOffset) {
   return 0;
 }
 
 template <typename T, typename CurrTraits, uint32_t Depth>
-inline constexpr typename std::enable_if<Depth < MaxTemplateDepth, T>::type EncTrailWithSwitchMode(uint32_t bitOffset) {
+    inline constexpr typename std::enable_if <
+    Depth<MaxTemplateDepth, T>::type EncTrailWithSwitchMode(uint32_t bitOffset) {
   return ((bitOffset + CurrTraits::CodingSize > sizeof(T) * 8))
              ? 0
              : EncSwitchMode<T, CurrTraits>(bitOffset) |
-                   EncTrailWithSwitchMode<
-                       T, CoderHelpers::Traits<CurrTraits::OpositeTraits>, Depth+1>(
+                   EncTrailWithSwitchMode<T, CoderHelpers::Traits<CurrTraits::OpositeTraits>, Depth + 1>(
                        bitOffset + CurrTraits::CodingSize);
 }
 
 template <typename T, typename CurrTraits, uint32_t Depth>
-inline constexpr typename std::enable_if<Depth >= MaxTemplateDepth, T>::type Enc(const char *str, uint32_t strIt, uint32_t bitOffset) {
-    return 0;
+inline constexpr typename std::enable_if<Depth >= MaxTemplateDepth, T>::type Enc(const char *str, uint32_t strIt,
+                                                                                 uint32_t bitOffset) {
+  return 0;
 }
 
 template <typename T, typename CurrTraits, uint32_t Depth>
-inline constexpr typename std::enable_if<Depth < MaxTemplateDepth, T>::type Enc(const char *str, uint32_t strIt, uint32_t bitOffset) {
+    inline constexpr typename std::enable_if <
+    Depth<MaxTemplateDepth, T>::type Enc(const char *str, uint32_t strIt, uint32_t bitOffset) {
   return (str[strIt] == '\0')
              ? EncTrailWithSwitchMode<T, CurrTraits, 0>(bitOffset)
              : (((bitOffset + CurrTraits::CodingSize > sizeof(T) * 8))
                     ? CIF::Abort<T>()
                     : (IsValid<CurrTraits>(str[strIt])
                            ? (EncOneChar<T, CurrTraits>(str[strIt], bitOffset) |
-                              Enc<T, CurrTraits, Depth+1>(str, strIt + 1,
-                                                 bitOffset +
-                                                     CurrTraits::CodingSize))
-                           : (IsValid<CoderHelpers::Traits<
-                                      CurrTraits::OpositeTraits>>(str[strIt])
+                              Enc<T, CurrTraits, Depth + 1>(str, strIt + 1, bitOffset + CurrTraits::CodingSize))
+                           : (IsValid<CoderHelpers::Traits<CurrTraits::OpositeTraits>>(str[strIt])
                                   ? EncSwitchMode<T, CurrTraits>(bitOffset) |
-                                        Enc<T, CoderHelpers::Traits<
-                                                   CurrTraits::OpositeTraits>, Depth+1>(
-                                            str, strIt,
-                                            bitOffset + CurrTraits::CodingSize)
+                                        Enc<T, CoderHelpers::Traits<CurrTraits::OpositeTraits>, Depth + 1>(
+                                            str, strIt, bitOffset + CurrTraits::CodingSize)
                                   : CIF::Abort<T>())));
 }
 
-template <typename T, typename CurrTraits>
-inline constexpr char Extract(T val, uint32_t bitOffset) {
-  return static_cast<char>((val >> bitOffset) &
-                           static_cast<T>((1 << CurrTraits::CodingSize) - 1));
+template <typename T, typename CurrTraits> inline constexpr char Extract(T val, uint32_t bitOffset) {
+  return static_cast<char>((val >> bitOffset) & static_cast<T>((1 << CurrTraits::CodingSize) - 1));
 }
 
-template <typename T, typename CurrTraits>
-inline bool Dec(T val, uint32_t bitOffset, char &outC) {
+template <typename T, typename CurrTraits> inline bool Dec(T val, uint32_t bitOffset, char &outC) {
   auto extr = Extract<T, CurrTraits>(val, bitOffset);
   if (extr < CurrTraits::SpecialCharsOffset) {
     outC = extr + CurrTraits::FirstChar;
@@ -189,12 +159,9 @@ inline bool Dec(T val, uint32_t bitOffset, char &outC) {
   return false;
 }
 
-template<typename T>
-inline constexpr T Min(T a, T b){
-    return (a<b) ? a : b;
-}
+template <typename T> inline constexpr T Min(T a, T b) { return (a < b) ? a : b; }
 
-}
+} // namespace CoderHelpers
 
 constexpr size_t CompileTimeStrlen(const char *s, size_t it = 0) {
   return (s[it] == '\0') ? it : CompileTimeStrlen(s, it + 1);
@@ -202,8 +169,7 @@ constexpr size_t CompileTimeStrlen(const char *s, size_t it = 0) {
 
 template <typename StorageType> struct Coder {
   static constexpr StorageType Enc(const char *str) {
-    return CoderHelpers::Enc<StorageType,
-                             CoderHelpers::Traits<CoderHelpers::Text>, 0>(str, 0, 0);
+    return CoderHelpers::Enc<StorageType, CoderHelpers::Traits<CoderHelpers::Text>, 0>(str, 0, 0);
   }
 
   static std::string Dec(const StorageType &v) {
@@ -213,36 +179,25 @@ template <typename StorageType> struct Coder {
     size_t strIt = 0;
     bool numericMode = false;
     char str[totalBits /
-             (CIF::CoderHelpers::Min<std::uint32_t>(
-                 CoderHelpers::Traits<CoderHelpers::Text>::CodingSize,
-                 CoderHelpers::Traits<CoderHelpers::Numeric>::CodingSize))] = {
-        0};
+             (CIF::CoderHelpers::Min<std::uint32_t>(CoderHelpers::Traits<CoderHelpers::Text>::CodingSize,
+                                                    CoderHelpers::Traits<CoderHelpers::Numeric>::CodingSize))] = {0};
     while (bitOffset < totalBits) {
       bool switchMode = false;
       if (numericMode) {
-        if (bitOffset +
-                CoderHelpers::Traits<CoderHelpers::Numeric>::CodingSize >
-            totalBits) {
+        if (bitOffset + CoderHelpers::Traits<CoderHelpers::Numeric>::CodingSize > totalBits) {
           break;
         }
         switchMode =
-            CoderHelpers::Dec<StorageType,
-                              CoderHelpers::Traits<CoderHelpers::Numeric>>(
-                v, bitOffset, str[strIt]);
+            CoderHelpers::Dec<StorageType, CoderHelpers::Traits<CoderHelpers::Numeric>>(v, bitOffset, str[strIt]);
       } else {
-        if (bitOffset + CoderHelpers::Traits<CoderHelpers::Text>::CodingSize >
-            totalBits) {
+        if (bitOffset + CoderHelpers::Traits<CoderHelpers::Text>::CodingSize > totalBits) {
           break;
         }
-        switchMode =
-            CoderHelpers::Dec<StorageType,
-                              CoderHelpers::Traits<CoderHelpers::Text>>(
-                v, bitOffset, str[strIt]);
+        switchMode = CoderHelpers::Dec<StorageType, CoderHelpers::Traits<CoderHelpers::Text>>(v, bitOffset, str[strIt]);
       }
 
-      bitOffset += numericMode
-                       ? CoderHelpers::Traits<CoderHelpers::Numeric>::CodingSize
-                       : CoderHelpers::Traits<CoderHelpers::Text>::CodingSize;
+      bitOffset += numericMode ? CoderHelpers::Traits<CoderHelpers::Numeric>::CodingSize
+                               : CoderHelpers::Traits<CoderHelpers::Text>::CodingSize;
 
       if (switchMode) {
         numericMode = !numericMode;
@@ -253,4 +208,4 @@ template <typename StorageType> struct Coder {
     return std::string{str};
   }
 };
-}
+} // namespace CIF
diff --git a/include/igc/cif/cif/common/compatibility.h b/include/igc/cif/cif/common/compatibility.h
index e48877b..554f348 100644
--- a/include/igc/cif/cif/common/compatibility.h
+++ b/include/igc/cif/cif/common/compatibility.h
@@ -16,211 +16,194 @@ SPDX-License-Identifier: MIT
 namespace CIF {
 
 constexpr Version_t CompatibilityEncoderVersion = 1;
-using CompatibilityDataHandle = const void*;
+using CompatibilityDataHandle = const void *;
 
 namespace Helpers {
 
-template<typename EncodingBaseType>
-struct EncInterface{
-    static constexpr size_t GetDescriptorSizeInEncodingBaseType(){
-        return 3;
-    }
-    static constexpr size_t GetDescriptorSizeInBytes(){
-        return GetDescriptorSizeInEncodingBaseType() * sizeof(EncodingBaseType);
-    }
+template <typename EncodingBaseType> struct EncInterface {
+  static constexpr size_t GetDescriptorSizeInEncodingBaseType() { return 3; }
+  static constexpr size_t GetDescriptorSizeInBytes() {
+    return GetDescriptorSizeInEncodingBaseType() * sizeof(EncodingBaseType);
+  }
 
-    static constexpr size_t GetInterfaceIdIdx(){
-        return 0;
-    }
+  static constexpr size_t GetInterfaceIdIdx() { return 0; }
 
-    static constexpr size_t GetVersionIdx(){
-        return 1;
-    }
+  static constexpr size_t GetVersionIdx() { return 1; }
 
-    static constexpr size_t GetChildrenCountIdx(){
-        return 2;
-    }
+  static constexpr size_t GetChildrenCountIdx() { return 2; }
 
-    static void Encode(EncodingBaseType * out,
-                       InterfaceId_t interfaceId, Version_t version, EncodingBaseType childrenCount){
-        out[GetInterfaceIdIdx()] = interfaceId;
-        out[GetVersionIdx()] = version;
-        out[GetChildrenCountIdx()] = childrenCount;
-    }
+  static void Encode(EncodingBaseType *out, InterfaceId_t interfaceId, Version_t version,
+                     EncodingBaseType childrenCount) {
+    out[GetInterfaceIdIdx()] = interfaceId;
+    out[GetVersionIdx()] = version;
+    out[GetChildrenCountIdx()] = childrenCount;
+  }
 
-    static void Decode(const EncodingBaseType * in,
-                       InterfaceId_t &interfaceIdRet, Version_t &versionRet, EncodingBaseType &childrenCountRet){
-        interfaceIdRet = in[GetInterfaceIdIdx()];
-        versionRet = in[GetVersionIdx()];
-        childrenCountRet = in[GetChildrenCountIdx()];
-    }
+  static void Decode(const EncodingBaseType *in, InterfaceId_t &interfaceIdRet, Version_t &versionRet,
+                     EncodingBaseType &childrenCountRet) {
+    interfaceIdRet = in[GetInterfaceIdIdx()];
+    versionRet = in[GetVersionIdx()];
+    childrenCountRet = in[GetChildrenCountIdx()];
+  }
 };
 
-template<typename EncodingBaseType>
-struct EncHeader{
-    static constexpr size_t GetHeaderSizeInEncodingBaseType(){
-        return 3;
-    }
+template <typename EncodingBaseType> struct EncHeader {
+  static constexpr size_t GetHeaderSizeInEncodingBaseType() { return 3; }
 
-    static constexpr size_t GetHeaderSizeInBytes(){
-        return GetHeaderSizeInEncodingBaseType() * sizeof(EncodingBaseType);
-    }
+  static constexpr size_t GetHeaderSizeInBytes() {
+    return GetHeaderSizeInEncodingBaseType() * sizeof(EncodingBaseType);
+  }
 
-    static constexpr size_t GetMagicIdx(){
-        return 0;
-    }
+  static constexpr size_t GetMagicIdx() { return 0; }
 
-    static constexpr size_t GetVersionIdx(){
-        return 1;
-    }
+  static constexpr size_t GetVersionIdx() { return 1; }
 
-    static constexpr size_t GetSizeIdx(){
-        return 2;
-    }
+  static constexpr size_t GetSizeIdx() { return 2; }
 
-    static void Encode(EncodingBaseType * out, EncodingBaseType magic,
-                       EncodingBaseType version, EncodingBaseType encodedInterfacesNum){
-        auto * header = out;
-        header[GetMagicIdx()] = magic;
-        header[GetVersionIdx()] = version;
-        header[GetSizeIdx()] = GetHeaderSizeInBytes() +
-                               encodedInterfacesNum * EncInterface<EncodingBaseType>::GetDescriptorSizeInBytes();
-    }
+  static void Encode(EncodingBaseType *out, EncodingBaseType magic, EncodingBaseType version,
+                     EncodingBaseType encodedInterfacesNum) {
+    auto *header = out;
+    header[GetMagicIdx()] = magic;
+    header[GetVersionIdx()] = version;
+    header[GetSizeIdx()] =
+        GetHeaderSizeInBytes() + encodedInterfacesNum * EncInterface<EncodingBaseType>::GetDescriptorSizeInBytes();
+  }
 
-    static const EncodingBaseType *Decode(CompatibilityDataHandle handle, EncodingBaseType magic, EncodingBaseType version,
-                                          EncodingBaseType & encodedInterfacesNumRet, EncodingBaseType & encodedEncoderVersionRet){
-        uint64_t invalidHeader[GetHeaderSizeInEncodingBaseType()];
-        invalidHeader[GetMagicIdx()] = InvalidInterface;
-        invalidHeader[GetVersionIdx()] = InvalidVersion;
-        invalidHeader[GetSizeIdx()] = 0;
+  static const EncodingBaseType *Decode(CompatibilityDataHandle handle, EncodingBaseType magic,
+                                        EncodingBaseType version, EncodingBaseType &encodedInterfacesNumRet,
+                                        EncodingBaseType &encodedEncoderVersionRet) {
+    uint64_t invalidHeader[GetHeaderSizeInEncodingBaseType()];
+    invalidHeader[GetMagicIdx()] = InvalidInterface;
+    invalidHeader[GetVersionIdx()] = InvalidVersion;
+    invalidHeader[GetSizeIdx()] = 0;
 
-        auto * header = reinterpret_cast<const EncodingBaseType*>(handle);
-        if((header == nullptr) || (header[GetMagicIdx()] != magic)){
-            header = invalidHeader;
-        }
-
-        encodedEncoderVersionRet = header[GetVersionIdx()];
-        encodedInterfacesNumRet = (header[GetSizeIdx()] - GetHeaderSizeInBytes());
-        encodedInterfacesNumRet /= EncInterface<EncodingBaseType>::GetDescriptorSizeInBytes();
+    auto *header = reinterpret_cast<const EncodingBaseType *>(handle);
+    if ((header == nullptr) || (header[GetMagicIdx()] != magic)) {
+      header = invalidHeader;
+    }
 
-        if(header[GetVersionIdx()] != version){
-            // incompatible encoder/decoders
-            // we require strict compatibility (no backwards compatibility),
-            // but this encoder should not change very often (hardly ever)
-            return nullptr;
-        }
+    encodedEncoderVersionRet = header[GetVersionIdx()];
+    encodedInterfacesNumRet = (header[GetSizeIdx()] - GetHeaderSizeInBytes());
+    encodedInterfacesNumRet /= EncInterface<EncodingBaseType>::GetDescriptorSizeInBytes();
 
-        return header + GetHeaderSizeInEncodingBaseType();
+    if (header[GetVersionIdx()] != version) {
+      // incompatible encoder/decoders
+      // we require strict compatibility (no backwards compatibility),
+      // but this encoder should not change very often (hardly ever)
+      return nullptr;
     }
+
+    return header + GetHeaderSizeInEncodingBaseType();
+  }
 };
 
 /// Node class that compatibility tree is made of
-struct CompatibilityNode{
-    /// Id of this interface
-    InterfaceId_t InterfaceId = InvalidInterface;
+struct CompatibilityNode {
+  /// Id of this interface
+  InterfaceId_t InterfaceId = InvalidInterface;
 
-    /// Version requested by the client
-    Version_t RequestedVersion = InvalidVersion;
+  /// Version requested by the client
+  Version_t RequestedVersion = InvalidVersion;
 
-    /// Next child of parent node
-    CompatibilityNode * NextSibling = nullptr;
+  /// Next child of parent node
+  CompatibilityNode *NextSibling = nullptr;
 
-    /// First child of this node
-    CompatibilityNode * FirstChild = nullptr;
+  /// First child of this node
+  CompatibilityNode *FirstChild = nullptr;
 
-    /// Minimum version supported by server
-    Version_t MinSupportedVersion = InvalidVersion;
+  /// Minimum version supported by server
+  Version_t MinSupportedVersion = InvalidVersion;
 
-    /// Maximum version supported by server
-    Version_t MaxSupportedVersion = InvalidVersion;
+  /// Maximum version supported by server
+  Version_t MaxSupportedVersion = InvalidVersion;
 
-    /// Adds a child node to this node (will update current children's nextSibling members)
-    void AddChild(CompatibilityNode & nd){
-        if(FirstChild == nullptr){
-            FirstChild = &nd;
-            return;
-        }
-
-        CompatibilityNode * currNd = FirstChild;
-        while(currNd->NextSibling != nullptr){
-            currNd = currNd->NextSibling;
-        }
-
-        currNd->NextSibling = &nd;
+  /// Adds a child node to this node (will update current children's nextSibling members)
+  void AddChild(CompatibilityNode &nd) {
+    if (FirstChild == nullptr) {
+      FirstChild = &nd;
+      return;
     }
 
-    /// Looks for child node with requested interfaceId
-    CompatibilityNode * FindChild(InterfaceId_t interfaceId){
-        CompatibilityNode * currNd = FirstChild;
-        while((currNd != nullptr)&&(currNd->InterfaceId != interfaceId)){
-            currNd = currNd->NextSibling;
-        }
-        return currNd;
+    CompatibilityNode *currNd = FirstChild;
+    while (currNd->NextSibling != nullptr) {
+      currNd = currNd->NextSibling;
     }
 
-    /// Decodes the compatibility data into a tree of nodes
-    /// First node in the returned vector is the root node
-    template<typename EncodingBaseType, template <Version_t> class EntryPointInterface>
-    static std::vector<CompatibilityNode> BuildTree(const EncodingBaseType* enc, uint64_t encWordsCount){
-        if((enc == nullptr) || (encWordsCount%EncInterface<EncodingBaseType>::GetDescriptorSizeInEncodingBaseType() != 0)){
-            assert(0);
-            return std::vector<CompatibilityNode>{};
-        }
-        std::vector<CompatibilityNode> allNodes;
-        CompatibilityNode dummyRootNode;
-        allNodes.reserve(static_cast<size_t>(encWordsCount / EncInterface<EncodingBaseType>::GetDescriptorSizeInEncodingBaseType()));
-        uint64_t currOffset = 0;
-        BuildTreeImpl<EncodingBaseType>(enc, encWordsCount, currOffset, dummyRootNode, allNodes);
-        PatchSupportedVersionFwd::Call<EntryPointInterface>(dummyRootNode);
-        return allNodes;
-    }
+    currNd->NextSibling = &nd;
+  }
 
-    template <typename InterfacesTree>
-    static void PatchSupportedVersion(CompatibilityNode & parentNode){
-        InterfacesTree::template forwardToAll<PatchSupportedVersionFwd>(parentNode);
+  /// Looks for child node with requested interfaceId
+  CompatibilityNode *FindChild(InterfaceId_t interfaceId) {
+    CompatibilityNode *currNd = FirstChild;
+    while ((currNd != nullptr) && (currNd->InterfaceId != interfaceId)) {
+      currNd = currNd->NextSibling;
+    }
+    return currNd;
+  }
+
+  /// Decodes the compatibility data into a tree of nodes
+  /// First node in the returned vector is the root node
+  template <typename EncodingBaseType, template <Version_t> class EntryPointInterface>
+  static std::vector<CompatibilityNode> BuildTree(const EncodingBaseType *enc, uint64_t encWordsCount) {
+    if ((enc == nullptr) ||
+        (encWordsCount % EncInterface<EncodingBaseType>::GetDescriptorSizeInEncodingBaseType() != 0)) {
+      assert(0);
+      return std::vector<CompatibilityNode>{};
     }
+    std::vector<CompatibilityNode> allNodes;
+    CompatibilityNode dummyRootNode;
+    allNodes.reserve(
+        static_cast<size_t>(encWordsCount / EncInterface<EncodingBaseType>::GetDescriptorSizeInEncodingBaseType()));
+    uint64_t currOffset = 0;
+    BuildTreeImpl<EncodingBaseType>(enc, encWordsCount, currOffset, dummyRootNode, allNodes);
+    PatchSupportedVersionFwd::Call<EntryPointInterface>(dummyRootNode);
+    return allNodes;
+  }
+
+  template <typename InterfacesTree> static void PatchSupportedVersion(CompatibilityNode &parentNode) {
+    InterfacesTree::template forwardToAll<PatchSupportedVersionFwd>(parentNode);
+  }
 
 protected:
-    /// Helper forwarder struct - see PatchSupportedVersionFwd::Call for details
-   struct PatchSupportedVersionFwd
-    {
-        /// Recursive worker for patching compatibility tree with data
-        /// of interface versions supported by server
-        template<template <Version_t> class Interface>
-        static void Call(CompatibilityNode & parentNode){
-            CompatibilityNode * matchingNd = parentNode.FindChild(Interface<CIF::BaseVersion>::GetInterfaceId());
-            if(matchingNd == nullptr){
-                return;
-            }
-
-            auto minVer = Interface<CIF::TraitsSpecialVersion>::GetOldestSupportedVersion();
-            auto maxVer = Interface<CIF::TraitsSpecialVersion>::GetLatestSupportedVersion();
-            matchingNd->MinSupportedVersion = minVer;
-            matchingNd->MaxSupportedVersion = maxVer;
-
-            Interface<CIF::TraitsSpecialVersion>::AllUsedInterfaces::template forwardToAll<PatchSupportedVersionFwd>(*matchingNd);
-        }
-    };
-
-   /// Recursive worker for decoding compatibility data into a tree
-   template<typename EncodingBaseType>
-    static void BuildTreeImpl(const EncodingBaseType* enc, uint64_t encWordsCount, uint64_t &currOffset,
-                         CompatibilityNode & parent, std::vector<CompatibilityNode> &nodesAllocator){
-        if(currOffset >= encWordsCount){
-            return; // no more data to decode
-        }
+  /// Helper forwarder struct - see PatchSupportedVersionFwd::Call for details
+  struct PatchSupportedVersionFwd {
+    /// Recursive worker for patching compatibility tree with data
+    /// of interface versions supported by server
+    template <template <Version_t> class Interface> static void Call(CompatibilityNode &parentNode) {
+      CompatibilityNode *matchingNd = parentNode.FindChild(Interface<CIF::BaseVersion>::GetInterfaceId());
+      if (matchingNd == nullptr) {
+        return;
+      }
+
+      auto minVer = Interface<CIF::TraitsSpecialVersion>::GetOldestSupportedVersion();
+      auto maxVer = Interface<CIF::TraitsSpecialVersion>::GetLatestSupportedVersion();
+      matchingNd->MinSupportedVersion = minVer;
+      matchingNd->MaxSupportedVersion = maxVer;
+
+      Interface<CIF::TraitsSpecialVersion>::AllUsedInterfaces::template forwardToAll<PatchSupportedVersionFwd>(
+          *matchingNd);
+    }
+  };
+
+  /// Recursive worker for decoding compatibility data into a tree
+  template <typename EncodingBaseType>
+  static void BuildTreeImpl(const EncodingBaseType *enc, uint64_t encWordsCount, uint64_t &currOffset,
+                            CompatibilityNode &parent, std::vector<CompatibilityNode> &nodesAllocator) {
+    if (currOffset >= encWordsCount) {
+      return; // no more data to decode
+    }
 
-        nodesAllocator.push_back(CompatibilityNode{});
-        CompatibilityNode * nd = &*(--nodesAllocator.end());
-        parent.AddChild(*nd);
+    nodesAllocator.push_back(CompatibilityNode{});
+    CompatibilityNode *nd = &*(--nodesAllocator.end());
+    parent.AddChild(*nd);
 
-        EncodingBaseType numChildren = 0;
-        EncInterface<EncodingBaseType>::Decode(enc + currOffset, nd->InterfaceId, nd->RequestedVersion, numChildren);
-        currOffset += EncInterface<EncodingBaseType>::GetDescriptorSizeInEncodingBaseType();
-        for(EncodingBaseType childIt = 0; childIt < numChildren; ++childIt){
-            BuildTreeImpl(enc, encWordsCount, currOffset, *nd, nodesAllocator);
-        }
+    EncodingBaseType numChildren = 0;
+    EncInterface<EncodingBaseType>::Decode(enc + currOffset, nd->InterfaceId, nd->RequestedVersion, numChildren);
+    currOffset += EncInterface<EncodingBaseType>::GetDescriptorSizeInEncodingBaseType();
+    for (EncodingBaseType childIt = 0; childIt < numChildren; ++childIt) {
+      BuildTreeImpl(enc, encWordsCount, currOffset, *nd, nodesAllocator);
     }
+  }
 };
 
 } // end namespace Helpers
@@ -231,162 +214,162 @@ struct CompatibilityNode{
 /// Third value is the size (in bytes) of the whole encoding (including id, version and this size).
 /// Next, are encoded requirements of all interfaces that were used for encoding.
 /// Encoding is based on DFS and has following layout:
-///   | uint64_t CurrentInterfaceId | uint64_t VersionOfCurrentInterface | uint64_t NumChildInterfacesOfCurrent | ENCODING OF CHILD INTERFACES | uint64_t NextInterfaceId ...
+///   | uint64_t CurrentInterfaceId | uint64_t VersionOfCurrentInterface | uint64_t NumChildInterfacesOfCurrent |
+///   ENCODING OF CHILD INTERFACES | uint64_t NextInterfaceId ...
 struct CompatibilityEncoder {
-    using EncodingBaseType = uint64_t;
-    using BackingStorage = std::vector<EncodingBaseType>;
+  using EncodingBaseType = uint64_t;
+  using BackingStorage = std::vector<EncodingBaseType>;
 
-    struct IncompatibilityData{
-        InterfaceId_t Interface;
-        Version_t     RequestedVersion;
-        Version_t     MinVersionSupported;
-        Version_t     MaxVersionSupported;
-    };
+  struct IncompatibilityData {
+    InterfaceId_t Interface;
+    Version_t RequestedVersion;
+    Version_t MinVersionSupported;
+    Version_t MaxVersionSupported;
+  };
 
-    CompatibilityEncoder(){
-    }
+  CompatibilityEncoder() {}
 
-    static constexpr InterfaceId_t GetIntefaceId(){
-        return CIF::InterfaceIdCoder::Enc("CIF_COMP_ENC");
-    }
+  static constexpr InterfaceId_t GetIntefaceId() { return CIF::InterfaceIdCoder::Enc("CIF_COMP_ENC"); }
 
-    template <template <Version_t> class EntryPointInterface>
-    CompatibilityDataHandle Encode(const std::vector<InterfaceId_t> *interfacesToIgnore = nullptr){
-        const size_t sizeToReserve = Helpers::EncHeader<EncodingBaseType>::GetHeaderSizeInEncodingBaseType()
-                                     +
-                                     (Helpers::EncInterface<EncodingBaseType>::GetDescriptorSizeInEncodingBaseType()
-                                      * 2); // *2 - potential overestimate
+  template <template <Version_t> class EntryPointInterface>
+  CompatibilityDataHandle Encode(const std::vector<InterfaceId_t> *interfacesToIgnore = nullptr) {
+    const size_t sizeToReserve = Helpers::EncHeader<EncodingBaseType>::GetHeaderSizeInEncodingBaseType() +
+                                 (Helpers::EncInterface<EncodingBaseType>::GetDescriptorSizeInEncodingBaseType() *
+                                  2); // *2 - potential overestimate
 
-        encodedData.clear();
-        encodedData.reserve(sizeToReserve);
+    encodedData.clear();
+    encodedData.reserve(sizeToReserve);
 
-        // reserve space for header
-        for(EncodingBaseType i = 0; i < Helpers::EncHeader<EncodingBaseType>::GetHeaderSizeInEncodingBaseType(); ++i){
-            encodedData.push_back(0);
-        }
-
-        // encode compatibility descriptors
-        EncodeFwd::Call<EntryPointInterface>(encodedData, interfacesToIgnore);
+    // reserve space for header
+    for (EncodingBaseType i = 0; i < Helpers::EncHeader<EncodingBaseType>::GetHeaderSizeInEncodingBaseType(); ++i) {
+      encodedData.push_back(0);
+    }
 
-        // encode header
-        const size_t encodedInterfacesNum = (encodedData.size() - Helpers::EncHeader<EncodingBaseType>::GetHeaderSizeInEncodingBaseType())
-                                                        / Helpers::EncInterface<EncodingBaseType>::GetDescriptorSizeInEncodingBaseType();
-        Helpers::EncHeader<EncodingBaseType>::Encode(encodedData.data(), GetIntefaceId(), CompatibilityEncoderVersion,
-                                                     encodedInterfacesNum);
-        return encodedData.data();
+    // encode compatibility descriptors
+    EncodeFwd::Call<EntryPointInterface>(encodedData, interfacesToIgnore);
+
+    // encode header
+    const size_t encodedInterfacesNum =
+        (encodedData.size() - Helpers::EncHeader<EncodingBaseType>::GetHeaderSizeInEncodingBaseType()) /
+        Helpers::EncInterface<EncodingBaseType>::GetDescriptorSizeInEncodingBaseType();
+    Helpers::EncHeader<EncodingBaseType>::Encode(encodedData.data(), GetIntefaceId(), CompatibilityEncoderVersion,
+                                                 encodedInterfacesNum);
+    return encodedData.data();
+  }
+
+  template <template <Version_t> class EntryPointInterface>
+  static bool GetFirstIncompatible(CompatibilityDataHandle externalEncoding, IncompatibilityData &ret) {
+    uint64_t encodedInterfacesNum = 0;
+    uint64_t encodedEncoderVersion = InvalidVersion;
+    const EncodingBaseType *encodedInterfaces = Helpers::EncHeader<EncodingBaseType>::Decode(
+        externalEncoding, GetIntefaceId(), CompatibilityEncoderVersion, encodedInterfacesNum, encodedEncoderVersion);
+
+    if (encodedInterfaces == nullptr) {
+      // incompatible encoder/decoders
+      // we require strict compatibility, but this encoder should not change very often
+      ret.Interface = GetIntefaceId();
+      ret.RequestedVersion = encodedEncoderVersion;
+      ret.MinVersionSupported = ret.MaxVersionSupported = CompatibilityEncoderVersion;
+      return true;
     }
 
-    template <template <Version_t> class EntryPointInterface>
-    static bool GetFirstIncompatible(CompatibilityDataHandle externalEncoding, IncompatibilityData & ret){
-        uint64_t encodedInterfacesNum = 0;
-        uint64_t encodedEncoderVersion = InvalidVersion;
-        const EncodingBaseType* encodedInterfaces =
-                            Helpers::EncHeader<EncodingBaseType>::Decode(externalEncoding, GetIntefaceId(), CompatibilityEncoderVersion,
-                                                                encodedInterfacesNum, encodedEncoderVersion);
-
-        if(encodedInterfaces == nullptr){
-            // incompatible encoder/decoders
-            // we require strict compatibility, but this encoder should not change very often
-            ret.Interface = GetIntefaceId();
-            ret.RequestedVersion = encodedEncoderVersion;
-            ret.MinVersionSupported = ret.MaxVersionSupported = CompatibilityEncoderVersion;
-            return true;
-        }
+    {
+      // TODO : Verify if this is actually better performant then full comparison
+      // TODO : Maybe hash encodings in compile time instead?
+      CompatibilityEncoder enc;
+      auto thisSideEncoding = enc.Encode<EntryPointInterface>();
+      auto sizeInBytes = encodedInterfacesNum * Helpers::EncInterface<EncodingBaseType>::GetDescriptorSizeInBytes() +
+                         Helpers::EncInterface<EncodingBaseType>::GetDescriptorSizeInBytes();
+      if (0 == std::memcmp(externalEncoding, thisSideEncoding, static_cast<uint32_t>(sizeInBytes))) {
+        // fast path - exactly the same versions of interfaces
+        return false;
+      }
+    }
 
-        {
-            // TODO : Verify if this is actually better performant then full comparison
-            // TODO : Maybe hash encodings in compile time instead?
-            CompatibilityEncoder enc;
-            auto thisSideEncoding = enc.Encode<EntryPointInterface>();
-            auto sizeInBytes = encodedInterfacesNum * Helpers::EncInterface<EncodingBaseType>::GetDescriptorSizeInBytes()
-                               + Helpers::EncInterface<EncodingBaseType>::GetDescriptorSizeInBytes();
-            if(0 == std::memcmp(externalEncoding, thisSideEncoding, static_cast<uint32_t>(sizeInBytes))){
-                // fast path - exactly the same versions of interfaces
-                return false;
-            }
-        }
+    auto incomp = GetAllIncompatibleImpl<EntryPointInterface>(
+        encodedInterfaces,
+        encodedInterfacesNum * Helpers::EncInterface<EncodingBaseType>::GetDescriptorSizeInEncodingBaseType());
+    if (incomp.size() == 0) {
+      return false;
+    }
 
-        auto incomp = GetAllIncompatibleImpl<EntryPointInterface>(encodedInterfaces, encodedInterfacesNum *
-                                                                  Helpers::EncInterface<EncodingBaseType>::GetDescriptorSizeInEncodingBaseType());
-        if(incomp.size() == 0){
-            return false;
-        }
+    ret = *incomp.begin();
+    return true;
+  }
 
-        ret = *incomp.begin();
-        return true;
+  static bool AreIdentical(CompatibilityDataHandle a, CompatibilityDataHandle b) {
+    if (a == b) {
+      return true;
     }
 
-    static bool AreIdentical(CompatibilityDataHandle a, CompatibilityDataHandle b){
-        if(a == b){
-            return true;
-        }
+    if ((a == nullptr) || (b == nullptr)) {
+      return false;
+    }
 
-        if((a == nullptr) || (b == nullptr)){
-            return false;
-        }
+    uint64_t encodedInterfacesNum = 0;
+    uint64_t encodedEncoderVersion = InvalidVersion;
 
-        uint64_t encodedInterfacesNum = 0;
-        uint64_t encodedEncoderVersion = InvalidVersion;
+    Helpers::EncHeader<EncodingBaseType>::Decode(a, GetIntefaceId(), CompatibilityEncoderVersion, encodedInterfacesNum,
+                                                 encodedEncoderVersion);
 
-        Helpers::EncHeader<EncodingBaseType>::Decode(a, GetIntefaceId(), CompatibilityEncoderVersion,
-                                                     encodedInterfacesNum, encodedEncoderVersion);
-
-        auto sizeInBytes = encodedInterfacesNum * Helpers::EncInterface<EncodingBaseType>::GetDescriptorSizeInBytes()
-                            + Helpers::EncInterface<EncodingBaseType>::GetDescriptorSizeInBytes();
-        return 0 == std::memcmp(a, b, static_cast<size_t>(sizeInBytes));
-    }
+    auto sizeInBytes = encodedInterfacesNum * Helpers::EncInterface<EncodingBaseType>::GetDescriptorSizeInBytes() +
+                       Helpers::EncInterface<EncodingBaseType>::GetDescriptorSizeInBytes();
+    return 0 == std::memcmp(a, b, static_cast<size_t>(sizeInBytes));
+  }
 
 protected:
-    struct EncodeFwd
-    {
-        template<template <Version_t> class Interface>
-        static void Call(BackingStorage & storage, const std::vector<InterfaceId_t> *interfacesToIgnore = nullptr){
-            auto offset = storage.size();
-            for(EncodingBaseType i = 0; i < Helpers::EncInterface<EncodingBaseType>::GetDescriptorSizeInEncodingBaseType(); ++i){
-                storage.push_back(0);
-            }
-
-            auto requestedInterface = Interface<CIF::BaseVersion>::GetInterfaceId();
-            auto requestedVersion = Interface<CIF::TraitsSpecialVersion>::GetLatestSupportedVersion();
-            if(nullptr != interfacesToIgnore){
-                if(std::find(interfacesToIgnore->begin(), interfacesToIgnore->end(), requestedInterface) != interfacesToIgnore->end()){
-                    requestedVersion = AnyVersion;
-                }
-            }
-
-            Helpers::EncInterface<EncodingBaseType>::Encode(storage.data() + offset,
-                                                            requestedInterface,
-                                                            requestedVersion,
-                                                            Interface<CIF::TraitsSpecialVersion>::AllUsedInterfaces::GetNumInterfaces());
-
-            Interface<CIF::TraitsSpecialVersion>::AllUsedInterfaces::template forwardToAll<EncodeFwd>(storage, interfacesToIgnore);
-        }
-    };
-
-    template <template <Version_t> class EntryPointInterface>
-    static std::vector<IncompatibilityData> GetAllIncompatibleImpl(const EncodingBaseType* enc, uint64_t encWordsCount){
-        std::vector<Helpers::CompatibilityNode> allNodes;
-        allNodes = Helpers::CompatibilityNode::BuildTree<EncodingBaseType, EntryPointInterface>(enc, encWordsCount);
-
-        std::vector<IncompatibilityData> ret;
-        for(auto & nd : allNodes){
-            bool supported = (nd.RequestedVersion >= nd.MinSupportedVersion) & (nd.RequestedVersion <= nd.MaxSupportedVersion);
-            supported |= (nd.RequestedVersion == AnyVersion);
-            if(supported){
-                continue;
-            }
-            IncompatibilityData id;
-            id.Interface = nd.InterfaceId;
-            id.RequestedVersion = nd.RequestedVersion;
-            id.MaxVersionSupported = nd.MaxSupportedVersion;
-            id.MinVersionSupported = nd.MinSupportedVersion;
-            ret.push_back(std::move(id));
+  struct EncodeFwd {
+    template <template <Version_t> class Interface>
+    static void Call(BackingStorage &storage, const std::vector<InterfaceId_t> *interfacesToIgnore = nullptr) {
+      auto offset = storage.size();
+      for (EncodingBaseType i = 0; i < Helpers::EncInterface<EncodingBaseType>::GetDescriptorSizeInEncodingBaseType();
+           ++i) {
+        storage.push_back(0);
+      }
+
+      auto requestedInterface = Interface<CIF::BaseVersion>::GetInterfaceId();
+      auto requestedVersion = Interface<CIF::TraitsSpecialVersion>::GetLatestSupportedVersion();
+      if (nullptr != interfacesToIgnore) {
+        if (std::find(interfacesToIgnore->begin(), interfacesToIgnore->end(), requestedInterface) !=
+            interfacesToIgnore->end()) {
+          requestedVersion = AnyVersion;
         }
+      }
 
-        return ret;
+      Helpers::EncInterface<EncodingBaseType>::Encode(
+          storage.data() + offset, requestedInterface, requestedVersion,
+          Interface<CIF::TraitsSpecialVersion>::AllUsedInterfaces::GetNumInterfaces());
+
+      Interface<CIF::TraitsSpecialVersion>::AllUsedInterfaces::template forwardToAll<EncodeFwd>(storage,
+                                                                                                interfacesToIgnore);
+    }
+  };
+
+  template <template <Version_t> class EntryPointInterface>
+  static std::vector<IncompatibilityData> GetAllIncompatibleImpl(const EncodingBaseType *enc, uint64_t encWordsCount) {
+    std::vector<Helpers::CompatibilityNode> allNodes;
+    allNodes = Helpers::CompatibilityNode::BuildTree<EncodingBaseType, EntryPointInterface>(enc, encWordsCount);
+
+    std::vector<IncompatibilityData> ret;
+    for (auto &nd : allNodes) {
+      bool supported =
+          (nd.RequestedVersion >= nd.MinSupportedVersion) & (nd.RequestedVersion <= nd.MaxSupportedVersion);
+      supported |= (nd.RequestedVersion == AnyVersion);
+      if (supported) {
+        continue;
+      }
+      IncompatibilityData id;
+      id.Interface = nd.InterfaceId;
+      id.RequestedVersion = nd.RequestedVersion;
+      id.MaxVersionSupported = nd.MaxSupportedVersion;
+      id.MinVersionSupported = nd.MinSupportedVersion;
+      ret.push_back(std::move(id));
     }
 
-    BackingStorage encodedData;
+    return ret;
+  }
+
+  BackingStorage encodedData;
 };
 
-}
+} // namespace CIF
diff --git a/include/igc/cif/cif/common/id.h b/include/igc/cif/cif/common/id.h
index 5411c24..37a2f8b 100644
--- a/include/igc/cif/cif/common/id.h
+++ b/include/igc/cif/cif/common/id.h
@@ -30,7 +30,6 @@ constexpr Version_t BaseVersion = 0;
 constexpr Version_t MinVersion = BaseVersion + 1;
 constexpr Version_t MaxVersion = TraitsSpecialVersion - 1;
 
-constexpr InterfaceId_t InvalidInterface =
-    std::numeric_limits<InterfaceId_t>::max();
+constexpr InterfaceId_t InvalidInterface = std::numeric_limits<InterfaceId_t>::max();
 constexpr InterfaceId_t UnknownInterface = InvalidInterface - 1;
-}
+} // namespace CIF
diff --git a/include/igc/cif/cif/common/library_api.h b/include/igc/cif/cif/common/library_api.h
index 1775624..c36ac32 100644
--- a/include/igc/cif/cif/common/library_api.h
+++ b/include/igc/cif/cif/common/library_api.h
@@ -27,10 +27,10 @@ struct CIFMain;
 using CreateCIFMainFunc_t = CIF::CIFMain *(CREATE_CIF_MAIN_CALLING_CONV *)();
 #define STR2(X) #X
 #define STR(X) STR2(X)
-static const char * const CreateCIFMainFuncName = STR(EXPORTED_FUNC_NAME);
+static const char *const CreateCIFMainFuncName = STR(EXPORTED_FUNC_NAME);
 #undef STR
 #undef STR2
-}
+} // namespace CIF
 
 #ifdef CIF_EXPORT
 CIF::CIFMain *CreateCIFMainImpl();
@@ -40,9 +40,7 @@ extern "C" {
 // entry point to shared object (dynamic library)
 // the only function that gets exported explicitly
 #if defined CIF_EXPORT
-CREATE_CIF_MAIN_API void *CREATE_CIF_MAIN_CALLING_CONV EXPORTED_FUNC_NAME() {
-  return CreateCIFMainImpl();
-}
+CREATE_CIF_MAIN_API void *CREATE_CIF_MAIN_CALLING_CONV EXPORTED_FUNC_NAME() { return CreateCIFMainImpl(); }
 #endif
 }
 
diff --git a/include/igc/cif/cif/common/library_handle.h b/include/igc/cif/cif/common/library_handle.h
index d673d38..3e81978 100644
--- a/include/igc/cif/cif/common/library_handle.h
+++ b/include/igc/cif/cif/common/library_handle.h
@@ -32,4 +32,4 @@ class LibraryHandle {
 // for OS-specific versions, please refer to OS_NAME/LibaryHandle.h headers
 std::unique_ptr<LibraryHandle> OpenLibrary(const std::string &path, bool addOsSpecificExtensionToPath);
 std::unique_ptr<LibraryHandle> OpenLibrary(const std::wstring &path, bool addOsSpecificExtensionToPath);
-}
+} // namespace CIF
diff --git a/include/igc/cif/cif/export/build/binary_version.h b/include/igc/cif/cif/export/build/binary_version.h
index f8fed93..6008ade 100644
--- a/include/igc/cif/cif/export/build/binary_version.h
+++ b/include/igc/cif/cif/export/build/binary_version.h
@@ -26,5 +26,5 @@ inline Version_t GetBinaryVersion() {
   return CIF::UnknownVersion;
 #endif
 }
-}
-}
+} // namespace Build
+} // namespace CIF
diff --git a/include/igc/cif/cif/export/cif_impl.h b/include/igc/cif/cif/export/cif_impl.h
index 557bc47..db12df1 100644
--- a/include/igc/cif/cif/export/cif_impl.h
+++ b/include/igc/cif/cif/export/cif_impl.h
@@ -19,16 +19,12 @@ SPDX-License-Identifier: MIT
 
 namespace CIF {
 
-template <typename BaseClass = ICIF>
-class ICIFImpl : public BaseClass {
+template <typename BaseClass = ICIF> class ICIFImpl : public BaseClass {
   static_assert(std::is_base_of<ICIF, BaseClass>::value, "Invalid BaseClass");
 
 public:
   template <typename... ArgsT>
-  ICIFImpl(Version_t version, ArgsT && ... args)
-      : BaseClass(std::forward<ArgsT>(args)...),
-        refCount(1)
-  {
+  ICIFImpl(Version_t version, ArgsT &&...args) : BaseClass(std::forward<ArgsT>(args)...), refCount(1) {
     this->version = version;
   }
 
@@ -44,9 +40,7 @@ class ICIFImpl : public BaseClass {
 
   void Retain() override { ++refCount; }
 
-  uint32_t GetRefCount() const override {
-      return refCount.load();
-  }
+  uint32_t GetRefCount() const override { return refCount.load(); }
 
   Version_t GetEnabledVersion() const override { return version; }
 
@@ -55,9 +49,8 @@ class ICIFImpl : public BaseClass {
   Version_t version;
 };
 
-template<typename InterfaceT, typename ... ArgsT>
-InterfaceT* CreateImplVer(ArgsT && ... args){
-    return new ICIFImpl<InterfaceT>(InterfaceT::GetVersion(), std::forward<ArgsT>(args)...);
+template <typename InterfaceT, typename... ArgsT> InterfaceT *CreateImplVer(ArgsT &&...args) {
+  return new ICIFImpl<InterfaceT>(InterfaceT::GetVersion(), std::forward<ArgsT>(args)...);
 }
 
-}
+} // namespace CIF
diff --git a/include/igc/cif/cif/export/cif_main.cpp b/include/igc/cif/cif/export/cif_main.cpp
index 5798fd0..8b105bb 100644
--- a/include/igc/cif/cif/export/cif_main.cpp
+++ b/include/igc/cif/cif/export/cif_main.cpp
@@ -5,4 +5,3 @@ Copyright (C) 2017-2021 Intel Corporation
 SPDX-License-Identifier: MIT
 
 ============================= end_copyright_notice ===========================*/
-
diff --git a/include/igc/cif/cif/export/cif_main_impl.h b/include/igc/cif/cif/export/cif_main_impl.h
index 48bcd4a..b9ca2eb 100644
--- a/include/igc/cif/cif/export/cif_main_impl.h
+++ b/include/igc/cif/cif/export/cif_main_impl.h
@@ -17,138 +17,139 @@ SPDX-License-Identifier: MIT
 namespace CIF {
 
 namespace Helpers {
-  struct ForwardCreateInterfaceImpl {
-    template <template <Version_t> class Interface, typename ... ArgsT>
-    static Interface<CIF::BaseVersion> *Call(Version_t version, ArgsT && ... args) {
-      return CIF::InterfaceCreator<Interface>::template CreateInterfaceVer<ArgsT...>(version, std::forward<ArgsT>(args)...);
-    }
-  };
-
-  struct ForwardFindSupportedVersions {
-      template <template <Version_t> class Interface>
-      static bool Call(InterfaceId_t interfaceToFind, Version_t &verMin, Version_t &verMax) {
-          return Interface<CIF::TraitsSpecialVersion>::AllUsedInterfaces::template forwardToOne<ForwardGetSupportedVersions, bool>(interfaceToFind, false, verMin, verMax);
-      }
-  };
-
-  struct ForwardGetFirstIncompatible {
-    template <template <Version_t> class Interface>
-    static InterfaceId_t Call(CIF::CompatibilityDataHandle handle) {
-        CIF::CompatibilityEncoder::IncompatibilityData ret;
-        auto incompatible = CompatibilityEncoder::GetFirstIncompatible<Interface>(handle, ret);
-        if(incompatible == false){
-            return CIF::InvalidInterface;
-        }
-
-        return ret.Interface;
+struct ForwardCreateInterfaceImpl {
+  template <template <Version_t> class Interface, typename... ArgsT>
+  static Interface<CIF::BaseVersion> *Call(Version_t version, ArgsT &&...args) {
+    return CIF::InterfaceCreator<Interface>::template CreateInterfaceVer<ArgsT...>(version,
+                                                                                   std::forward<ArgsT>(args)...);
+  }
+};
+
+struct ForwardFindSupportedVersions {
+  template <template <Version_t> class Interface>
+  static bool Call(InterfaceId_t interfaceToFind, Version_t &verMin, Version_t &verMax) {
+    return Interface<CIF::TraitsSpecialVersion>::AllUsedInterfaces::template forwardToOne<ForwardGetSupportedVersions,
+                                                                                          bool>(interfaceToFind, false,
+                                                                                                verMin, verMax);
+  }
+};
+
+struct ForwardGetFirstIncompatible {
+  template <template <Version_t> class Interface> static InterfaceId_t Call(CIF::CompatibilityDataHandle handle) {
+    CIF::CompatibilityEncoder::IncompatibilityData ret;
+    auto incompatible = CompatibilityEncoder::GetFirstIncompatible<Interface>(handle, ret);
+    if (incompatible == false) {
+      return CIF::InvalidInterface;
     }
-  };
-}
+
+    return ret.Interface;
+  }
+};
+} // namespace Helpers
 
 // STATIC VERSION - based on entry point templates list
-template <template <Version_t> class... EntryPointInterfaces>
-struct CIFMainImplStatic : ICIFImpl<CIF::CIFMain> {
+template <template <Version_t> class... EntryPointInterfaces> struct CIFMainImplStatic : ICIFImpl<CIF::CIFMain> {
   using EntryPointInterfacesList = InterfacesList<EntryPointInterfaces...>;
 
-  CIFMainImplStatic()
-      :  ICIFImpl<CIF::CIFMain>(CifFrameworkVersion){
-  }
+  CIFMainImplStatic() : ICIFImpl<CIF::CIFMain>(CifFrameworkVersion) {}
 
-  Version_t GetBinaryVersion() const override {
-    return CIF::Build::GetBinaryVersion();
-  }
+  Version_t GetBinaryVersion() const override { return CIF::Build::GetBinaryVersion(); }
 
   ICIF *CreateInterfaceImpl(InterfaceId_t entryPointInterface, Version_t version) override {
-    if(CIF::Builtins::IsBuiltin(entryPointInterface)){
-        return CIF::Builtins::Create(entryPointInterface, version, this);
+    if (CIF::Builtins::IsBuiltin(entryPointInterface)) {
+      return CIF::Builtins::Create(entryPointInterface, version, this);
     }
-    return EntryPointInterfacesList::template forwardToOne<Helpers::ForwardCreateInterfaceImpl, ICIF *, ICIF *>(entryPointInterface, nullptr, version, version, this);
+    return EntryPointInterfacesList::template forwardToOne<Helpers::ForwardCreateInterfaceImpl, ICIF *, ICIF *>(
+        entryPointInterface, nullptr, version, version, this);
   }
 
   bool GetSupportedVersions(InterfaceId_t entryPointInterface, Version_t &verMin, Version_t &verMax) const override {
-    if(CIF::Builtins::IsBuiltin(entryPointInterface)){
-        return CIF::Builtins::GetSupportedVersions(entryPointInterface, verMin, verMax);
+    if (CIF::Builtins::IsBuiltin(entryPointInterface)) {
+      return CIF::Builtins::GetSupportedVersions(entryPointInterface, verMin, verMax);
     }
-    return EntryPointInterfacesList::template forwardToOne<Helpers::ForwardGetSupportedVersions, bool>(entryPointInterface, false, verMin, verMax);
+    return EntryPointInterfacesList::template forwardToOne<Helpers::ForwardGetSupportedVersions, bool>(
+        entryPointInterface, false, verMin, verMax);
   }
 
-  bool FindSupportedVersionsImpl(InterfaceId_t entryPointInterface, InterfaceId_t interfaceToFind, Version_t &verMin, Version_t &verMax) const override {
-    if(CIF::Builtins::IsBuiltin(entryPointInterface)){
-        assert(entryPointInterface == interfaceToFind); // builtins don't have subinterfaces
-        return CIF::Builtins::GetSupportedVersions(entryPointInterface, verMin, verMax);
+  bool FindSupportedVersionsImpl(InterfaceId_t entryPointInterface, InterfaceId_t interfaceToFind, Version_t &verMin,
+                                 Version_t &verMax) const override {
+    if (CIF::Builtins::IsBuiltin(entryPointInterface)) {
+      assert(entryPointInterface == interfaceToFind); // builtins don't have subinterfaces
+      return CIF::Builtins::GetSupportedVersions(entryPointInterface, verMin, verMax);
     }
-    return EntryPointInterfacesList::template forwardToOne<Helpers::ForwardFindSupportedVersions, bool>(entryPointInterface, false, interfaceToFind, verMin, verMax);
+    return EntryPointInterfacesList::template forwardToOne<Helpers::ForwardFindSupportedVersions, bool>(
+        entryPointInterface, false, interfaceToFind, verMin, verMax);
   }
 
-  InterfaceId_t FindIncompatibleImpl(InterfaceId_t entryPointInterface, CIF::CompatibilityDataHandle handle) const override {
-    if(CIF::Builtins::IsBuiltin(entryPointInterface)){
-        return CIF::Builtins::FindIncompatible(entryPointInterface, handle);
+  InterfaceId_t FindIncompatibleImpl(InterfaceId_t entryPointInterface,
+                                     CIF::CompatibilityDataHandle handle) const override {
+    if (CIF::Builtins::IsBuiltin(entryPointInterface)) {
+      return CIF::Builtins::FindIncompatible(entryPointInterface, handle);
     }
-    return EntryPointInterfacesList::template forwardToOne<Helpers::ForwardGetFirstIncompatible, InterfaceId_t>(entryPointInterface, entryPointInterface, handle);
+    return EntryPointInterfacesList::template forwardToOne<Helpers::ForwardGetFirstIncompatible, InterfaceId_t>(
+        entryPointInterface, entryPointInterface, handle);
   }
 };
 
 // DYNAMIC VERSION - based on registry
 struct CIFMainImplRegistry : ICIFImpl<CIF::CIFMain> {
-  CIFMainImplRegistry()
-      :  ICIFImpl<CIF::CIFMain>(CifFrameworkVersion){
-  }
+  CIFMainImplRegistry() : ICIFImpl<CIF::CIFMain>(CifFrameworkVersion) {}
 
-  Version_t GetBinaryVersion() const override {
-    return CIF::Build::GetBinaryVersion();
-  }
+  Version_t GetBinaryVersion() const override { return CIF::Build::GetBinaryVersion(); }
 
   ICIF *CreateInterfaceImpl(InterfaceId_t entryPointInterface, Version_t version) override {
-    if(CIF::Builtins::IsBuiltin(entryPointInterface)){
-        return CIF::Builtins::Create(entryPointInterface, version, this);
+    if (CIF::Builtins::IsBuiltin(entryPointInterface)) {
+      return CIF::Builtins::Create(entryPointInterface, version, this);
     }
     auto entryPointInfo = CIF::EntryPointRegistry::Get().GetEntryPointInterface(entryPointInterface);
-    if(entryPointInfo == nullptr){
-        // interface info not availabe in the registry
-        return nullptr;
+    if (entryPointInfo == nullptr) {
+      // interface info not availabe in the registry
+      return nullptr;
     }
     return entryPointInfo->Create(version, this);
   }
 
   bool GetSupportedVersions(InterfaceId_t entryPointInterface, Version_t &verMin, Version_t &verMax) const override {
-    if(CIF::Builtins::IsBuiltin(entryPointInterface)){
-        return CIF::Builtins::GetSupportedVersions(entryPointInterface, verMin, verMax);
+    if (CIF::Builtins::IsBuiltin(entryPointInterface)) {
+      return CIF::Builtins::GetSupportedVersions(entryPointInterface, verMin, verMax);
     }
     auto entryPointInfo = CIF::EntryPointRegistry::Get().GetEntryPointInterface(entryPointInterface);
-    if(entryPointInfo == nullptr){
-        // interace info not availabe in the registry
-        return false;
+    if (entryPointInfo == nullptr) {
+      // interace info not availabe in the registry
+      return false;
     }
     entryPointInfo->GetSupportedVersions(verMin, verMax);
     return true;
   }
 
-  bool FindSupportedVersionsImpl(InterfaceId_t entryPointInterface, InterfaceId_t interfaceToFind, Version_t &verMin, Version_t &verMax) const override {
-    if(CIF::Builtins::IsBuiltin(entryPointInterface)){
-        assert(entryPointInterface == interfaceToFind); // builtins don't have subinterfaces
-        GetSupportedVersions(entryPointInterface, verMin, verMax);
-        return false;
+  bool FindSupportedVersionsImpl(InterfaceId_t entryPointInterface, InterfaceId_t interfaceToFind, Version_t &verMin,
+                                 Version_t &verMax) const override {
+    if (CIF::Builtins::IsBuiltin(entryPointInterface)) {
+      assert(entryPointInterface == interfaceToFind); // builtins don't have subinterfaces
+      GetSupportedVersions(entryPointInterface, verMin, verMax);
+      return false;
     }
     auto entryPointInfo = CIF::EntryPointRegistry::Get().GetEntryPointInterface(entryPointInterface);
-    if(entryPointInfo == nullptr){
-        // interface info not availabe in the registry
-        return false;
+    if (entryPointInfo == nullptr) {
+      // interface info not availabe in the registry
+      return false;
     }
 
     return entryPointInfo->FindSupportedVersions(interfaceToFind, verMin, verMax);
   }
 
-  InterfaceId_t FindIncompatibleImpl(InterfaceId_t entryPointInterface, CIF::CompatibilityDataHandle handle) const override {
-    if(CIF::Builtins::IsBuiltin(entryPointInterface)){
-        return CIF::Builtins::FindIncompatible(entryPointInterface, handle);
+  InterfaceId_t FindIncompatibleImpl(InterfaceId_t entryPointInterface,
+                                     CIF::CompatibilityDataHandle handle) const override {
+    if (CIF::Builtins::IsBuiltin(entryPointInterface)) {
+      return CIF::Builtins::FindIncompatible(entryPointInterface, handle);
     }
     auto entryPointInfo = CIF::EntryPointRegistry::Get().GetEntryPointInterface(entryPointInterface);
-    if(entryPointInfo == nullptr){
-        // interface info not availabe in the registry
-        return entryPointInterface;
+    if (entryPointInfo == nullptr) {
+      // interface info not availabe in the registry
+      return entryPointInterface;
     }
 
     return entryPointInfo->GetFirstIncompatible(handle);
   }
 };
-}
+} // namespace CIF
diff --git a/include/igc/cif/cif/export/interface_creator.h b/include/igc/cif/cif/export/interface_creator.h
index ac6e7b9..8f29caa 100644
--- a/include/igc/cif/cif/export/interface_creator.h
+++ b/include/igc/cif/cif/export/interface_creator.h
@@ -11,45 +11,42 @@ SPDX-License-Identifier: MIT
 #include "cif/common/cif.h"
 #include "cif/export/cif_impl.h"
 
-namespace CIF{
+namespace CIF {
 
-template <template <Version_t> class Interface>
-struct InterfaceCreator
-{
+template <template <Version_t> class Interface> struct InterfaceCreator {
 protected:
-    template <Version_t currVer>
-    static constexpr bool IsTooOld()
-    {
-        return currVer < Interface<CIF::TraitsSpecialVersion>::GetOldestSupportedVersion();
+  template <Version_t currVer> static constexpr bool IsTooOld() {
+    return currVer < Interface<CIF::TraitsSpecialVersion>::GetOldestSupportedVersion();
+  }
+
+  template <bool TooOld, Version_t CurrVer, typename... ArgsT>
+  static typename std::enable_if<TooOld, Interface<CIF::BaseVersion> *>::type
+  CreateInterfaceVerHelper(Version_t ver, ArgsT &&...args) {
+    return nullptr;
+  }
+
+  template <bool TooOld, Version_t CurrVer, typename... ArgsT>
+  static typename std::enable_if<false == TooOld, Interface<CIF::BaseVersion> *>::type
+  CreateInterfaceVerHelper(Version_t ver, ArgsT &&...args) {
+    if ((ver <= Interface<CurrVer>::GetVersion()) && (ver >= Interface<CurrVer>::GetBackwardsCompatibilityVersion())) {
+      return new ICIFImpl<Interface<CurrVer>>(ver, std::forward<ArgsT>(args)...);
+    } else {
+      return CreateInterfaceVerHelper<IsTooOld<CurrVer - 1>(), CurrVer - 1, ArgsT...>(ver,
+                                                                                      std::forward<ArgsT>(args)...);
     }
+  }
 
-    template <bool TooOld, Version_t CurrVer, typename... ArgsT>
-    static typename std::enable_if<TooOld, Interface<CIF::BaseVersion>*>::type CreateInterfaceVerHelper(Version_t ver, ArgsT &&... args) {
-      return nullptr;
-    }
-
-    template <bool TooOld, Version_t CurrVer, typename... ArgsT>
-    static typename std::enable_if<false == TooOld, Interface<CIF::BaseVersion>*>::type CreateInterfaceVerHelper(Version_t ver, ArgsT &&... args) {
-      if ((ver <= Interface<CurrVer>::GetVersion()) &&
-          (ver >= Interface<CurrVer>::GetBackwardsCompatibilityVersion())) {
-        return new ICIFImpl<Interface<CurrVer>>(ver, std::forward<ArgsT>(args)...);
-      } else {
-          return CreateInterfaceVerHelper<IsTooOld<CurrVer - 1>(), CurrVer - 1, ArgsT...>(ver, std::forward<ArgsT>(args)...);
-      }
-    }
 public:
-    template <typename... ArgsT>
-    static Interface<BaseVersion> *CreateInterfaceVer(Version_t ver, ArgsT &&... args) {
-      constexpr Version_t latestVer = Interface<CIF::TraitsSpecialVersion>::GetLatestSupportedVersion();
-      constexpr Version_t oldestVer = Interface<CIF::TraitsSpecialVersion>::GetOldestSupportedVersion();
-      if ((ver <= latestVer) && (ver >= oldestVer)) {
+  template <typename... ArgsT> static Interface<BaseVersion> *CreateInterfaceVer(Version_t ver, ArgsT &&...args) {
+    constexpr Version_t latestVer = Interface<CIF::TraitsSpecialVersion>::GetLatestSupportedVersion();
+    constexpr Version_t oldestVer = Interface<CIF::TraitsSpecialVersion>::GetOldestSupportedVersion();
+    if ((ver <= latestVer) && (ver >= oldestVer)) {
 
-         return CreateInterfaceVerHelper<false, latestVer,
-                                          ArgsT...>(ver, std::forward<ArgsT>(args)...);
-      }
-
-      return nullptr;
+      return CreateInterfaceVerHelper<false, latestVer, ArgsT...>(ver, std::forward<ArgsT>(args)...);
     }
+
+    return nullptr;
+  }
 };
 
-}
+} // namespace CIF
diff --git a/include/igc/cif/cif/export/library_api.h b/include/igc/cif/cif/export/library_api.h
index bfb3b17..2a02358 100644
--- a/include/igc/cif/cif/export/library_api.h
+++ b/include/igc/cif/cif/export/library_api.h
@@ -10,14 +10,13 @@ SPDX-License-Identifier: MIT
 
 #pragma once
 #ifdef CIF_EXPORT
-#  undef CIF_EXPORT
+#undef CIF_EXPORT
 #endif
 
 #ifdef CIF_IMPORT
-#  undef CIF_IMPORT
+#undef CIF_IMPORT
 #endif
 
 #define CIF_EXPORT
 #include "cif/common/library_api.h"
 #undef CIF_EXPORT
-
diff --git a/include/igc/cif/cif/export/muiltiversion.h b/include/igc/cif/cif/export/muiltiversion.h
index b638c48..7b5b73c 100644
--- a/include/igc/cif/cif/export/muiltiversion.h
+++ b/include/igc/cif/cif/export/muiltiversion.h
@@ -13,104 +13,95 @@ SPDX-License-Identifier: MIT
 #include "cif/common/cif.h"
 #include "cif/export/interface_creator.h"
 
-namespace CIF{
-
-template <template <Version_t> class Interface>
-struct Multiversion
-{
-    using ImplT = typename Interface<CIF::BaseVersion>::Impl;
-    using BaseInterfaceT = Interface<CIF::BaseVersion>;
-
-    Multiversion(){
-        this->impl = nullptr;
-        std::fill(versions.begin(), versions.end(), nullptr);
+namespace CIF {
+
+template <template <Version_t> class Interface> struct Multiversion {
+  using ImplT = typename Interface<CIF::BaseVersion>::Impl;
+  using BaseInterfaceT = Interface<CIF::BaseVersion>;
+
+  Multiversion() {
+    this->impl = nullptr;
+    std::fill(versions.begin(), versions.end(), nullptr);
+  }
+
+  template <typename ArgT, typename... ArgsT> Multiversion(ArgT &&arg, ArgsT &&...args) : Multiversion() {
+    impl = new ImplT(std::forward<ArgT>(arg), std::forward<ArgsT>(args)...);
+    impl->retain(nullptr);
+  }
+
+  Multiversion(ImplT *impl) : Multiversion() {
+    this->impl = impl;
+    this->impl->retain(nullptr);
+  }
+
+  template <typename... ArgsT> void CreateImpl(ArgsT &&...args) {
+    // release interface tied-up to previous impl (if any)
+    for (BaseInterfaceT *&iVer : versions) {
+      if (iVer == nullptr) {
+        continue;
+      }
+      iVer->Release();
+      iVer = nullptr;
     }
 
-    template<typename ArgT, typename ... ArgsT>
-    Multiversion(ArgT && arg, ArgsT && ... args)
-        : Multiversion(){
-        impl = new ImplT(std::forward<ArgT>(arg), std::forward<ArgsT>(args)...);
-        impl->retain(nullptr);
+    if (this->impl != nullptr) {
+      this->impl->Release(nullptr);
     }
-
-    Multiversion(ImplT *impl)
-        : Multiversion(){
-        this->impl = impl;
-        this->impl->retain(nullptr);
+    this->impl = new ImplT(std::forward<ArgsT>(args)...);
+    this->impl->Retain(nullptr);
+  }
+
+  ~Multiversion() {
+    for (BaseInterfaceT *iVer : versions) {
+      if (iVer == nullptr) {
+        continue;
+      }
+      iVer->Release();
     }
 
-    template<typename ... ArgsT>
-    void CreateImpl(ArgsT && ... args){
-        // release interface tied-up to previous impl (if any)
-        for(BaseInterfaceT *&iVer : versions){
-            if(iVer == nullptr){
-                continue;
-            }
-            iVer->Release();
-            iVer = nullptr;
-        }
-
-        if(this->impl != nullptr){
-            this->impl->Release(nullptr);
-        }
-        this->impl = new ImplT(std::forward<ArgsT>(args)...);
-        this->impl->Retain(nullptr);
+    if (this->impl != nullptr) {
+      impl->Release(nullptr);
     }
+  }
 
-    ~Multiversion(){
-        for(BaseInterfaceT * iVer : versions){
-            if(iVer == nullptr){
-                continue;
-            }
-            iVer->Release();
-        }
-
-        if(this->impl != nullptr){
-            impl->Release(nullptr);
-        }
-    }
+  Multiversion(const Multiversion &) = delete;
+  Multiversion &operator=(const Multiversion &) = delete;
+  Multiversion(Multiversion &&) = delete;
+  Multiversion *operator=(Multiversion &&) = delete;
 
-    Multiversion(const Multiversion &) = delete;
-    Multiversion &operator=(const Multiversion &) = delete;
-    Multiversion(Multiversion &&) = delete;
-    Multiversion *operator=(Multiversion &&) = delete;
+  ImplT *operator->() { return impl; }
 
-    ImplT *operator->() { return impl; }
+  ImplT *operator->() const { return impl; }
 
-    ImplT *operator->() const { return impl; }
+  ImplT *GetImpl() { return impl; }
 
-    ImplT *GetImpl(){
-        return impl;
-    }
+  const ImplT *GetImpl() const { return impl; }
 
-    const ImplT *GetImpl() const {
-        return impl;
-    }
+  const BaseInterfaceT *GetVersion(Version_t v) const {
+    constexpr Version_t oldestSupportedVersion = Interface<CIF::TraitsSpecialVersion>::GetOldestSupportedVersion();
+    constexpr Version_t latestSupportedVersion = Interface<CIF::TraitsSpecialVersion>::GetLatestSupportedVersion();
 
-    const BaseInterfaceT *GetVersion(Version_t v) const {
-        constexpr Version_t oldestSupportedVersion = Interface<CIF::TraitsSpecialVersion>::GetOldestSupportedVersion();
-        constexpr Version_t latestSupportedVersion = Interface<CIF::TraitsSpecialVersion>::GetLatestSupportedVersion();
-
-        if((v < oldestSupportedVersion) || (v > latestSupportedVersion)){
-            return nullptr;
-        }
-
-        size_t idx = static_cast<size_t>(v - oldestSupportedVersion);
-        BaseInterfaceT *curr = versions[idx];
-        if(curr != nullptr){
-            return curr;
-        }
-        versions[idx] = InterfaceCreator<Interface>::CreateInterfaceVer(v, impl);
-        return versions[idx];
+    if ((v < oldestSupportedVersion) || (v > latestSupportedVersion)) {
+      return nullptr;
     }
 
-    BaseInterfaceT *GetVersion(Version_t v) {
-        return const_cast<BaseInterfaceT*>(const_cast<const Multiversion<Interface>*>(this)->GetVersion(v));
+    size_t idx = static_cast<size_t>(v - oldestSupportedVersion);
+    BaseInterfaceT *curr = versions[idx];
+    if (curr != nullptr) {
+      return curr;
     }
+    versions[idx] = InterfaceCreator<Interface>::CreateInterfaceVer(v, impl);
+    return versions[idx];
+  }
+
+  BaseInterfaceT *GetVersion(Version_t v) {
+    return const_cast<BaseInterfaceT *>(const_cast<const Multiversion<Interface> *>(this)->GetVersion(v));
+  }
+
 protected:
-    mutable std::array<BaseInterfaceT*, Interface<CIF::TraitsSpecialVersion>::GetNumSupportedVersions()> versions = {};
-    ImplT *impl = nullptr;
-    bool ownsImpl = false;
+  mutable std::array<BaseInterfaceT *, Interface<CIF::TraitsSpecialVersion>::GetNumSupportedVersions()> versions = {};
+  ImplT *impl = nullptr;
+  bool ownsImpl = false;
 };
 
-}
+} // namespace CIF
diff --git a/include/igc/cif/cif/export/pimpl_base.h b/include/igc/cif/cif/export/pimpl_base.h
index ec3e3c4..dd22c82 100644
--- a/include/igc/cif/cif/export/pimpl_base.h
+++ b/include/igc/cif/cif/export/pimpl_base.h
@@ -16,39 +16,34 @@ SPDX-License-Identifier: MIT
 #include "cif/common/cif.h"
 #include "cif/helpers/error.h"
 
-namespace CIF{
+namespace CIF {
 
-struct PimplBase
-{
-    PimplBase(){
-        referenceCounter.store(0U);
-    }
-    virtual ~PimplBase() = default;
-
-    virtual void Retain(CIF::ICIF *retainer){
-        ++referenceCounter;
-    }
+struct PimplBase {
+  PimplBase() { referenceCounter.store(0U); }
+  virtual ~PimplBase() = default;
 
-    virtual std::unique_ptr<PimplBase> Release(CIF::ICIF *releaser){
-        auto prevRefCount = referenceCounter.load();
-        --referenceCounter;
+  virtual void Retain(CIF::ICIF *retainer) { ++referenceCounter; }
 
-        if(prevRefCount == 0){
-            CIF::Abort();
-        }
+  virtual std::unique_ptr<PimplBase> Release(CIF::ICIF *releaser) {
+    auto prevRefCount = referenceCounter.load();
+    --referenceCounter;
 
-        if(prevRefCount > 1){
-            return std::unique_ptr<PimplBase>(nullptr);
-        }
+    if (prevRefCount == 0) {
+      CIF::Abort();
+    }
 
-        assert(prevRefCount == 1);
-        // this was the last reference to this object
-        // make sure the caller will delete this
-        return std::unique_ptr<PimplBase>(this);
+    if (prevRefCount > 1) {
+      return std::unique_ptr<PimplBase>(nullptr);
     }
 
+    assert(prevRefCount == 1);
+    // this was the last reference to this object
+    // make sure the caller will delete this
+    return std::unique_ptr<PimplBase>(this);
+  }
+
 protected:
-    std::atomic<std::uint32_t> referenceCounter;
+  std::atomic<std::uint32_t> referenceCounter;
 };
 
-}
+} // namespace CIF
diff --git a/include/igc/cif/cif/export/registry.h b/include/igc/cif/cif/export/registry.h
index 998585c..6a58563 100644
--- a/include/igc/cif/cif/export/registry.h
+++ b/include/igc/cif/cif/export/registry.h
@@ -19,108 +19,97 @@ SPDX-License-Identifier: MIT
 namespace CIF {
 
 namespace Helpers {
-  struct ForwardGetSupportedVersions {
-    template <template <Version_t> class Interface>
-    static bool Call(Version_t &verMin, Version_t &verMax) {
-      verMax = Interface<CIF::TraitsSpecialVersion>::GetLatestSupportedVersion();
-      verMin = Interface<CIF::TraitsSpecialVersion>::GetOldestSupportedVersion();
-      return true;
-    }
-  };
-}
+struct ForwardGetSupportedVersions {
+  template <template <Version_t> class Interface> static bool Call(Version_t &verMin, Version_t &verMax) {
+    verMax = Interface<CIF::TraitsSpecialVersion>::GetLatestSupportedVersion();
+    verMin = Interface<CIF::TraitsSpecialVersion>::GetOldestSupportedVersion();
+    return true;
+  }
+};
+} // namespace Helpers
 
-struct EntryPointInterfaceBase{
-    EntryPointInterfaceBase(){
-    }
-    virtual ~EntryPointInterfaceBase() = default;
+struct EntryPointInterfaceBase {
+  EntryPointInterfaceBase() {}
+  virtual ~EntryPointInterfaceBase() = default;
 
-    virtual ICIF * Create(Version_t version, ICIF * parent) const = 0;
-    virtual InterfaceId_t GetFirstIncompatible(CIF::CompatibilityDataHandle handle) const = 0;
-    virtual void GetSupportedVersions(Version_t &verMin, Version_t &verMax) const = 0;
-    virtual bool FindSupportedVersions(CIF::InterfaceId_t interfaceToFind, Version_t &verMin, Version_t &verMax) const = 0;
+  virtual ICIF *Create(Version_t version, ICIF *parent) const = 0;
+  virtual InterfaceId_t GetFirstIncompatible(CIF::CompatibilityDataHandle handle) const = 0;
+  virtual void GetSupportedVersions(Version_t &verMin, Version_t &verMax) const = 0;
+  virtual bool FindSupportedVersions(CIF::InterfaceId_t interfaceToFind, Version_t &verMin,
+                                     Version_t &verMax) const = 0;
 };
 
-template<template <Version_t> class Interface>
-struct EntryPointInterface : EntryPointInterfaceBase {
-    EntryPointInterface(){
-    }
+template <template <Version_t> class Interface> struct EntryPointInterface : EntryPointInterfaceBase {
+  EntryPointInterface() {}
 
-    ICIF * Create(Version_t version, ICIF * parent) const override{
-        return CIF::InterfaceCreator<Interface>::template CreateInterfaceVer(version, version, parent);
-    }
+  ICIF *Create(Version_t version, ICIF *parent) const override {
+    return CIF::InterfaceCreator<Interface>::template CreateInterfaceVer(version, version, parent);
+  }
 
-    InterfaceId_t GetFirstIncompatible(CIF::CompatibilityDataHandle handle) const override{
-        CIF::CompatibilityEncoder::IncompatibilityData ret;
-        auto incompatible = CompatibilityEncoder::GetFirstIncompatible<Interface>(handle, ret);
-        if(incompatible == false){
-            return CIF::InvalidInterface;
-        }
-
-        return ret.Interface;
+  InterfaceId_t GetFirstIncompatible(CIF::CompatibilityDataHandle handle) const override {
+    CIF::CompatibilityEncoder::IncompatibilityData ret;
+    auto incompatible = CompatibilityEncoder::GetFirstIncompatible<Interface>(handle, ret);
+    if (incompatible == false) {
+      return CIF::InvalidInterface;
     }
 
-    void GetSupportedVersions(Version_t &verMin, Version_t &verMax) const override{
-      verMax = Interface<CIF::TraitsSpecialVersion>::GetLatestSupportedVersion();
-      verMin = Interface<CIF::TraitsSpecialVersion>::GetOldestSupportedVersion();
-    }
+    return ret.Interface;
+  }
 
-    bool FindSupportedVersions(CIF::InterfaceId_t interfaceToFind, Version_t &verMin, Version_t &verMax) const override{
-        return Interface<CIF::TraitsSpecialVersion>::AllUsedInterfaces::template forwardToOne<Helpers::ForwardGetSupportedVersions, bool>(interfaceToFind, false, verMin, verMax);
-    }
+  void GetSupportedVersions(Version_t &verMin, Version_t &verMax) const override {
+    verMax = Interface<CIF::TraitsSpecialVersion>::GetLatestSupportedVersion();
+    verMin = Interface<CIF::TraitsSpecialVersion>::GetOldestSupportedVersion();
+  }
+
+  bool FindSupportedVersions(CIF::InterfaceId_t interfaceToFind, Version_t &verMin, Version_t &verMax) const override {
+    return Interface<CIF::TraitsSpecialVersion>::AllUsedInterfaces::template forwardToOne<
+        Helpers::ForwardGetSupportedVersions, bool>(interfaceToFind, false, verMin, verMax);
+  }
 };
 
 struct EntryPointRegistry {
 protected:
-    void Clear(){
-        registeredEntryPoints.clear();
-    }
+  void Clear() { registeredEntryPoints.clear(); }
 
 public:
-    static EntryPointRegistry & Get () {
-        static EntryPointRegistry r;
-        return r;
-    }
-
-    template<template <Version_t> class Interface>
-    void Register(){
-        assert(registeredEntryPoints.find(Interface<BaseVersion>::GetInterfaceId()) == registeredEntryPoints.end());
-        registeredEntryPoints[Interface<BaseVersion>::GetInterfaceId()]
-            = std::unique_ptr<EntryPointInterfaceBase>(new EntryPointInterface<Interface>{});
+  static EntryPointRegistry &Get() {
+    static EntryPointRegistry r;
+    return r;
+  }
+
+  template <template <Version_t> class Interface> void Register() {
+    assert(registeredEntryPoints.find(Interface<BaseVersion>::GetInterfaceId()) == registeredEntryPoints.end());
+    registeredEntryPoints[Interface<BaseVersion>::GetInterfaceId()] =
+        std::unique_ptr<EntryPointInterfaceBase>(new EntryPointInterface<Interface>{});
+  }
+
+  EntryPointInterfaceBase *GetEntryPointInterface(InterfaceId_t interface) const {
+    auto it = registeredEntryPoints.find(interface);
+    if (it == registeredEntryPoints.end()) {
+      return nullptr;
     }
 
-    EntryPointInterfaceBase * GetEntryPointInterface(InterfaceId_t interface) const {
-        auto it = registeredEntryPoints.find(interface);
-        if(it == registeredEntryPoints.end()){
-            return nullptr;
-        }
-
-        return &*it->second;
-    }
+    return &*it->second;
+  }
 
-    template<typename Sentinel = void>
-    void RegisterAll(){
-    }
+  template <typename Sentinel = void> void RegisterAll() {}
 
-    template<template <Version_t> class Interface, template <Version_t> class ... RestInterfaces>
-    void RegisterAll(){
-        Register<Interface>();
-        RegisterAll<RestInterfaces...>();
-    }
+  template <template <Version_t> class Interface, template <Version_t> class... RestInterfaces> void RegisterAll() {
+    Register<Interface>();
+    RegisterAll<RestInterfaces...>();
+  }
 
 #include "cif/macros/enable.h"
-    CIF_ULT_EXPOSE(Clear)
+  CIF_ULT_EXPOSE(Clear)
 #include "cif/macros/disable.h"
 
 protected:
-    using RegistryContainerT = std::unordered_map<InterfaceId_t, std::unique_ptr<EntryPointInterfaceBase>>;
-    RegistryContainerT registeredEntryPoints;
+  using RegistryContainerT = std::unordered_map<InterfaceId_t, std::unique_ptr<EntryPointInterfaceBase>>;
+  RegistryContainerT registeredEntryPoints;
 };
 
-template<template <Version_t> class Interface>
-struct RegisterEntryPoint{
-    RegisterEntryPoint(){
-        EntryPointRegistry::Get().Register<Interface>();
-    }
+template <template <Version_t> class Interface> struct RegisterEntryPoint {
+  RegisterEntryPoint() { EntryPointRegistry::Get().Register<Interface>(); }
 };
 
-}
+} // namespace CIF
diff --git a/include/igc/cif/cif/helpers/error.h b/include/igc/cif/cif/helpers/error.h
index 744b628..1186687 100644
--- a/include/igc/cif/cif/helpers/error.h
+++ b/include/igc/cif/cif/helpers/error.h
@@ -13,47 +13,40 @@ SPDX-License-Identifier: MIT
 
 namespace CIF {
 
-inline void AbortImpl(){
+inline void AbortImpl() {
 #if defined(NDEBUG)
-    throw std::runtime_error("Internal Error.");
+  throw std::runtime_error("Internal Error.");
 #else
-    std::abort();
+  std::abort();
 #endif
 }
 
-template<typename T = void>
-inline T Abort();
+template <typename T = void> inline T Abort();
 
-template<typename T>
-inline T Abort(){
-    AbortImpl();
-    T t{};
-    return t;
+template <typename T> inline T Abort() {
+  AbortImpl();
+  T t{};
+  return t;
 }
 
-template<>
-inline void Abort() {
-    AbortImpl();
-}
+template <> inline void Abort() { AbortImpl(); }
 
-namespace Sanity{
+namespace Sanity {
 
-template<typename T>
-inline T *NotNullOrAbort(T *ptr){
-    if(ptr == nullptr){
-        Abort();
-    }
-    return ptr;
+template <typename T> inline T *NotNullOrAbort(T *ptr) {
+  if (ptr == nullptr) {
+    Abort();
+  }
+  return ptr;
 }
 
-template<typename T>
-inline T &ToReferenceOrAbort(T *ptr){
-    if(ptr == nullptr){
-        Abort();
-    }
-    return *ptr;
+template <typename T> inline T &ToReferenceOrAbort(T *ptr) {
+  if (ptr == nullptr) {
+    Abort();
+  }
+  return *ptr;
 }
 
-}
+} // namespace Sanity
 
-}
+} // namespace CIF
diff --git a/include/igc/cif/cif/helpers/memory.h b/include/igc/cif/cif/helpers/memory.h
index 98259a5..0f532e3 100644
--- a/include/igc/cif/cif/helpers/memory.h
+++ b/include/igc/cif/cif/helpers/memory.h
@@ -13,55 +13,49 @@ SPDX-License-Identifier: MIT
 #include "inc/common/secure_mem.h"
 #endif
 
-namespace CIF{
+namespace CIF {
 
-inline void SafeCopy(void *dst, size_t dstAvailableSizeInBytes, const void *src, size_t bytesToCopy){
-    if(dstAvailableSizeInBytes < bytesToCopy){
-        CIF::Abort();
-    }
+inline void SafeCopy(void *dst, size_t dstAvailableSizeInBytes, const void *src, size_t bytesToCopy) {
+  if (dstAvailableSizeInBytes < bytesToCopy) {
+    CIF::Abort();
+  }
 
-    if(bytesToCopy == 0){
-        return;
-    }
+  if (bytesToCopy == 0) {
+    return;
+  }
 
-    if((dst == nullptr) || (src == nullptr)){
-        CIF::Abort();
-    }
+  if ((dst == nullptr) || (src == nullptr)) {
+    CIF::Abort();
+  }
 
-    char * dstAsChar = reinterpret_cast<char*>(dst);
-    const char * srcAsChar = reinterpret_cast<const char*>(src);
+  char *dstAsChar = reinterpret_cast<char *>(dst);
+  const char *srcAsChar = reinterpret_cast<const char *>(src);
 
-    // TODO : Verify that compiler actually picks this pattern-up as memcpy and optimizes it
-    memcpy_s(dstAsChar, dstAvailableSizeInBytes, srcAsChar, bytesToCopy);
+  // TODO : Verify that compiler actually picks this pattern-up as memcpy and optimizes it
+  memcpy_s(dstAsChar, dstAvailableSizeInBytes, srcAsChar, bytesToCopy);
 }
 
-template<typename T>
-inline void SafeCopy(void *dst, size_t dstAvailableSizeInBytes, const T &v){
-    SafeCopy(dst, dstAvailableSizeInBytes, &v, sizeof(T));
+template <typename T> inline void SafeCopy(void *dst, size_t dstAvailableSizeInBytes, const T &v) {
+  SafeCopy(dst, dstAvailableSizeInBytes, &v, sizeof(T));
 }
 
-inline void SafeZeroOut(void *dst, size_t dstAvailableSizeInBytes){
-    char * dstAsChar = reinterpret_cast<char*>(dst);
+inline void SafeZeroOut(void *dst, size_t dstAvailableSizeInBytes) {
+  char *dstAsChar = reinterpret_cast<char *>(dst);
 
-    // TODO : Verify that compiler actually picks this pattern-up as memcpy and optimizes it
-    for(size_t i = 0; i < dstAvailableSizeInBytes; ++i){
-        dstAsChar[i] = 0;
-    }
+  // TODO : Verify that compiler actually picks this pattern-up as memcpy and optimizes it
+  for (size_t i = 0; i < dstAvailableSizeInBytes; ++i) {
+    dstAsChar[i] = 0;
+  }
 }
 
-template<typename T>
-inline void SafeZeroOut(T &v){
-    SafeZeroOut(&v, sizeof(T));
-}
+template <typename T> inline void SafeZeroOut(T &v) { SafeZeroOut(&v, sizeof(T)); }
 
-template<typename PtrElT, typename OffsetT>
-inline PtrElT *OffsetedPtr(PtrElT *ptr, OffsetT offset){
-    return reinterpret_cast<PtrElT*>(reinterpret_cast<char *>(ptr) + offset);
+template <typename PtrElT, typename OffsetT> inline PtrElT *OffsetedPtr(PtrElT *ptr, OffsetT offset) {
+  return reinterpret_cast<PtrElT *>(reinterpret_cast<char *>(ptr) + offset);
 }
 
-template<typename PtrElT, typename OffsetT>
-inline const PtrElT *OffsetedPtr(const PtrElT *ptr, OffsetT offset){
-    return reinterpret_cast<const PtrElT*>(reinterpret_cast<char *>(ptr) + offset);
+template <typename PtrElT, typename OffsetT> inline const PtrElT *OffsetedPtr(const PtrElT *ptr, OffsetT offset) {
+  return reinterpret_cast<const PtrElT *>(reinterpret_cast<char *>(ptr) + offset);
 }
 
-}
+} // namespace CIF
diff --git a/include/igc/cif/cif/import/cif_main.cpp b/include/igc/cif/cif/import/cif_main.cpp
index b57989b..91bb3d5 100644
--- a/include/igc/cif/cif/import/cif_main.cpp
+++ b/include/igc/cif/cif/import/cif_main.cpp
@@ -18,14 +18,12 @@ CIF::RAII::UPtr_t<CIFMain> OpenLibraryInterface(LibraryHandle &lib) {
   if (createMainFuncPtr == nullptr) {
     return CIF::RAII::UPtr(ret = nullptr);
   }
-  auto CreateCIFFunc =
-      reinterpret_cast<CIF::CreateCIFMainFunc_t>(createMainFuncPtr);
+  auto CreateCIFFunc = reinterpret_cast<CIF::CreateCIFMainFunc_t>(createMainFuncPtr);
   auto main = (*CreateCIFFunc)();
   return CIF::RAII::UPtr(main);
 }
 
-std::unique_ptr<CIFPackage>
-OpenLibraryInterface(std::unique_ptr<CIF::LibraryHandle> &&lib) {
+std::unique_ptr<CIFPackage> OpenLibraryInterface(std::unique_ptr<CIF::LibraryHandle> &&lib) {
   if (lib.get() == nullptr) {
     return std::unique_ptr<CIFPackage>(nullptr);
   }
@@ -33,4 +31,4 @@ OpenLibraryInterface(std::unique_ptr<CIF::LibraryHandle> &&lib) {
   CIFPackage *pckg = new CIFPackage(std::move(entryPoint), std::move(lib));
   return std::unique_ptr<CIFPackage>(pckg);
 }
-}
+} // namespace CIF
diff --git a/include/igc/cif/cif/import/cif_main.h b/include/igc/cif/cif/import/cif_main.h
index 99160c6..f943656 100644
--- a/include/igc/cif/cif/import/cif_main.h
+++ b/include/igc/cif/cif/import/cif_main.h
@@ -41,4 +41,4 @@ struct CIFPackage {
 // helpers for opening CIF Main inferface over given library handle
 CIF::RAII::UPtr_t<CIFMain> OpenLibraryInterface(CIF::LibraryHandle &lib);
 std::unique_ptr<CIFPackage> OpenLibraryInterface(std::unique_ptr<CIF::LibraryHandle> &&lib);
-}
+} // namespace CIF
diff --git a/include/igc/cif/cif/import/library_api.h b/include/igc/cif/cif/import/library_api.h
index 4a2a357..671f2d4 100644
--- a/include/igc/cif/cif/import/library_api.h
+++ b/include/igc/cif/cif/import/library_api.h
@@ -8,11 +8,11 @@ SPDX-License-Identifier: MIT
 
 #pragma once
 #ifdef CIF_EXPORT
-#  undef CIF_EXPORT
+#undef CIF_EXPORT
 #endif
 
 #ifdef CIF_IMPORT
-#  undef CIF_IMPORT
+#undef CIF_IMPORT
 #endif
 
 #define CIF_IMPORT
diff --git a/include/igc/cif/cif/macros/enable.h b/include/igc/cif/cif/macros/enable.h
index ef872c7..97beccc 100644
--- a/include/igc/cif/cif/macros/enable.h
+++ b/include/igc/cif/cif/macros/enable.h
@@ -6,101 +6,93 @@ SPDX-License-Identifier: MIT
 
 ============================= end_copyright_notice ===========================*/
 
-#define CIF_FORWARD_DECLARE(TYPE, STRUCT_NAME)                                \
-  template <CIF::Version_t ver> TYPE STRUCT_NAME
+#define CIF_FORWARD_DECLARE(TYPE, STRUCT_NAME) template <CIF::Version_t ver> TYPE STRUCT_NAME
 
 #define CIF_FORWARD_DECLARE_S(NAME) CIF_FORWARD_DECLARE(struct, NAME)
 #define CIF_FORWARD_DECLARE_C(NAME) CIF_FORWARD_DECLARE(class, NAME)
 
 #if defined CIF_ULT
-#  define CIF_ULT_EXPOSE(FUNC_NAME)               \
-      template<typename ... ArgsT>                \
-      auto FUNC_NAME##_CIF_ULT(ArgsT && ... args) -> decltype(this->FUNC_NAME(std::forward<ArgsT>(args)...)) {\
-           return FUNC_NAME(std::forward<ArgsT>(args)...);   \
-      }
+#define CIF_ULT_EXPOSE(FUNC_NAME)                                                                                      \
+  template <typename... ArgsT>                                                                                         \
+  auto FUNC_NAME##_CIF_ULT(ArgsT &&...args)->decltype(this->FUNC_NAME(std::forward<ArgsT>(args)...)) {                 \
+    return FUNC_NAME(std::forward<ArgsT>(args)...);                                                                    \
+  }
 #else
-#  define CIF_ULT_EXPOSE(FUNC_NAME)
+#define CIF_ULT_EXPOSE(FUNC_NAME)
 #endif
 
-#define CIF_DECLARE_INTERFACE(NAME, ID)                            \
-    template <CIF::Version_t version = CIF::InvalidVersion>        \
-    struct NAME;                                                   \
-                                                                   \
-    template <>                                                    \
-    struct NAME<CIF::BaseVersion>                                  \
-        : public CIF::NamedCIF<CIF::InterfaceIdCoder::Enc(ID)>     \
-    {                                                              \
-        struct Impl;                                               \
-        virtual Impl * GetImpl(){ return pImpl; }                  \
-        virtual const Impl * GetImpl() const { return pImpl; }     \
-    protected:                                                     \
-        ~NAME()override;                                           \
-        Impl * pImpl;                                              \
-        template<typename ... ArgsT>                               \
-        NAME(ArgsT &&... args);                                    \
-        NAME(Impl * pImpl);                                        \
-        NAME(const NAME&) = delete;                                \
-        NAME& operator=(const NAME&) = delete;                     \
-        NAME& operator=(NAME&&) = delete;                          \
-    };                                                             \
-    using NAME##Base = NAME<CIF::BaseVersion>;
+#define CIF_DECLARE_INTERFACE(NAME, ID)                                                                                \
+  template <CIF::Version_t version = CIF::InvalidVersion> struct NAME;                                                 \
+                                                                                                                       \
+  template <> struct NAME<CIF::BaseVersion> : public CIF::NamedCIF<CIF::InterfaceIdCoder::Enc(ID)> {                   \
+    struct Impl;                                                                                                       \
+    virtual Impl *GetImpl() { return pImpl; }                                                                          \
+    virtual const Impl *GetImpl() const { return pImpl; }                                                              \
+                                                                                                                       \
+  protected:                                                                                                           \
+    ~NAME() override;                                                                                                  \
+    Impl *pImpl;                                                                                                       \
+    template <typename... ArgsT> NAME(ArgsT &&...args);                                                                \
+    NAME(Impl *pImpl);                                                                                                 \
+    NAME(const NAME &) = delete;                                                                                       \
+    NAME &operator=(const NAME &) = delete;                                                                            \
+    NAME &operator=(NAME &&) = delete;                                                                                 \
+  };                                                                                                                   \
+  using NAME##Base = NAME<CIF::BaseVersion>;
 
 // For common (i.e. shared) interfaces (such as builtins), access to pimpl
 // is blocked, becasue we can't reliably check if given dynamic library
 // knows the correct underlying version of interface's pimpl class
-#define CIF_DECLARE_COMMON_INTERFACE(NAME, ID)                     \
-    template <CIF::Version_t version = CIF::InvalidVersion>        \
-    struct NAME;                                                   \
-                                                                   \
-    template <>                                                    \
-    struct NAME<CIF::BaseVersion>                                  \
-        : public CIF::NamedCIF<CIF::InterfaceIdCoder::Enc(ID)>     \
-    {                                                              \
-        struct Impl;                                               \
-    protected:                                                     \
-        virtual Impl * GetImpl(){ return pImpl; }                  \
-        virtual const Impl * GetImpl() const { return pImpl; }     \
-        ~NAME()override;                                           \
-        Impl * pImpl;                                              \
-        template<typename ... ArgsT>                               \
-        NAME(ArgsT &&... args);                                    \
-        NAME(Impl * pImpl);                                        \
-        NAME(const NAME&) = delete;                                \
-        NAME& operator=(const NAME&) = delete;                     \
-        NAME& operator=(NAME&&) = delete;                          \
-    };                                                             \
-    using NAME##Base = NAME<CIF::BaseVersion>;
-
-#define CIF_DEFINE_INTERFACE_VER(NAME, VER)                         \
-    template<>                                                      \
-    struct NAME<VER> : public CIF::VersionedCIF<NAME, VER>
-
-#define CIF_DEFINE_INTERFACE_VER_WITH_COMPATIBILITY(NAME, VER, COMPATIBILITY_VER)\
-    template<>                                                                   \
-    struct NAME<VER> : public CIF::VersionedCIF<NAME, VER, COMPATIBILITY_VER>
+#define CIF_DECLARE_COMMON_INTERFACE(NAME, ID)                                                                         \
+  template <CIF::Version_t version = CIF::InvalidVersion> struct NAME;                                                 \
+                                                                                                                       \
+  template <> struct NAME<CIF::BaseVersion> : public CIF::NamedCIF<CIF::InterfaceIdCoder::Enc(ID)> {                   \
+    struct Impl;                                                                                                       \
+                                                                                                                       \
+  protected:                                                                                                           \
+    virtual Impl *GetImpl() { return pImpl; }                                                                          \
+    virtual const Impl *GetImpl() const { return pImpl; }                                                              \
+    ~NAME() override;                                                                                                  \
+    Impl *pImpl;                                                                                                       \
+    template <typename... ArgsT> NAME(ArgsT &&...args);                                                                \
+    NAME(Impl *pImpl);                                                                                                 \
+    NAME(const NAME &) = delete;                                                                                       \
+    NAME &operator=(const NAME &) = delete;                                                                            \
+    NAME &operator=(NAME &&) = delete;                                                                                 \
+  };                                                                                                                   \
+  using NAME##Base = NAME<CIF::BaseVersion>;
+
+#define CIF_DEFINE_INTERFACE_VER(NAME, VER) template <> struct NAME<VER> : public CIF::VersionedCIF<NAME, VER>
+
+#define CIF_DEFINE_INTERFACE_VER_WITH_COMPATIBILITY(NAME, VER, COMPATIBILITY_VER)                                      \
+  template <> struct NAME<VER> : public CIF::VersionedCIF<NAME, VER, COMPATIBILITY_VER>
 
 #define CIF_INHERIT_CONSTRUCTOR() using VersionedCIF::VersionedCIF;
 
 #define CIF_DECLARE_INTERFACE_DEPENDENCIES(DEPENDEE_INTERFACE, ...)
 
-#define CIF_GENERATE_VERSIONS_LIST(INTERFACE)\
-    template<>\
-    struct INTERFACE<CIF::TraitsSpecialVersion> : public CIF::SupportedVersions<INTERFACE>, public CIF::UsedInterfaces<> {};
+#define CIF_GENERATE_VERSIONS_LIST(INTERFACE)                                                                          \
+  template <>                                                                                                          \
+  struct INTERFACE<CIF::TraitsSpecialVersion> : public CIF::SupportedVersions<INTERFACE>,                              \
+                                                public CIF::UsedInterfaces<> {};
 
-#define CIF_GENERATE_VERSIONS_LIST_WITH_BASE(INTERFACE, BASE)\
-    template<>\
-    struct INTERFACE<CIF::TraitsSpecialVersion> : public CIF::SupportedVersions<INTERFACE, BASE>, public CIF::UsedInterfaces<> {};
+#define CIF_GENERATE_VERSIONS_LIST_WITH_BASE(INTERFACE, BASE)                                                          \
+  template <>                                                                                                          \
+  struct INTERFACE<CIF::TraitsSpecialVersion> : public CIF::SupportedVersions<INTERFACE, BASE>,                        \
+                                                public CIF::UsedInterfaces<> {};
 
-#define CIF_GENERATE_VERSIONS_LIST_AND_DECLARE_INTERFACE_DEPENDENCIES(INTERFACE, ...)\
-    template<>\
-    struct INTERFACE<CIF::TraitsSpecialVersion> : public CIF::SupportedVersions<INTERFACE>, public CIF::UsedInterfaces<__VA_ARGS__> {};
+#define CIF_GENERATE_VERSIONS_LIST_AND_DECLARE_INTERFACE_DEPENDENCIES(INTERFACE, ...)                                  \
+  template <>                                                                                                          \
+  struct INTERFACE<CIF::TraitsSpecialVersion> : public CIF::SupportedVersions<INTERFACE>,                              \
+                                                public CIF::UsedInterfaces<__VA_ARGS__> {};
 
-#define CIF_GENERATE_VERSIONS_LIST_WITH_BASE_AND_DECLARE_INTERFACE_DEPENDENCIES(INTERFACE, BASE, ...)\
-    template<>\
-    struct INTERFACE<CIF::TraitsSpecialVersion> : public CIF::SupportedVersions<INTERFACE, BASE>, public CIF::UsedInterfaces<__VA_ARGS__> {};
+#define CIF_GENERATE_VERSIONS_LIST_WITH_BASE_AND_DECLARE_INTERFACE_DEPENDENCIES(INTERFACE, BASE, ...)                  \
+  template <>                                                                                                          \
+  struct INTERFACE<CIF::TraitsSpecialVersion> : public CIF::SupportedVersions<INTERFACE, BASE>,                        \
+                                                public CIF::UsedInterfaces<__VA_ARGS__> {};
 
-#define CIF_MARK_LATEST_VERSION(LATEST_INTERFACE_ALIAS, INTERFACE)\
-    using LATEST_INTERFACE_ALIAS = INTERFACE<INTERFACE<CIF::TraitsSpecialVersion>::GetLatestSupportedVersion()>;
+#define CIF_MARK_LATEST_VERSION(LATEST_INTERFACE_ALIAS, INTERFACE)                                                     \
+  using LATEST_INTERFACE_ALIAS = INTERFACE<INTERFACE<CIF::TraitsSpecialVersion>::GetLatestSupportedVersion()>;
 
 #define CIF_DECLARE_INTERFACE_PIMPL(NAME) struct NAME<CIF::BaseVersion>::Impl
 #define CIF_TYPE_PIMPL(NAME) NAME<CIF::BaseVersion>::Impl
@@ -108,27 +100,22 @@ SPDX-License-Identifier: MIT
 #define CIF_PIMPL_DECLARE_DESTRUCTOR() ~Impl()
 #define CIF_GET_INTERFACE_CLASS(NAME, VER) NAME<VER>
 #define CIF_GET_PIMPL() GetImpl()
-#define CIF_EXPORT_ENTRY_POINTS_STATIC(...)                         \
-    extern CIF::CIFMain *CreateCIFMainImpl(){                       \
-        return new CIF::CIFMainImplStatic<__VA_ARGS__>;             \
-    }
-#define CIF_DEFINE_INTERFACE_TO_PIMPL_FORWARDING_CTOR_DTOR(NAME) \
-    template<typename ... ArgsT> \
-    inline NAME<CIF::BaseVersion>::NAME(ArgsT &&... args)\
-                : pImpl(new Impl(std::forward<ArgsT>(args)...)){ pImpl->Retain(this); }\
-    inline NAME<CIF::BaseVersion>::NAME(Impl *pImpl)\
-                : pImpl(pImpl){ pImpl->Retain(this); }\
-    inline NAME<CIF::BaseVersion>::~NAME() { pImpl->Release(this); }
-
-#define CIF_PIMPL(T)\
-    T<CIF::BaseVersion>::Impl
-#define CIF_PIMPL_TYPENAME(T)\
-     typename T<CIF::BaseVersion>::Impl
-
-#define CREATE_CIF_PIMPL(T, ...)\
-    new CIF_PIMPL_T(T)(__VA_ARGS__)
+#define CIF_EXPORT_ENTRY_POINTS_STATIC(...)                                                                            \
+  extern CIF::CIFMain *CreateCIFMainImpl() { return new CIF::CIFMainImplStatic<__VA_ARGS__>; }
+#define CIF_DEFINE_INTERFACE_TO_PIMPL_FORWARDING_CTOR_DTOR(NAME)                                                       \
+  template <typename... ArgsT>                                                                                         \
+  inline NAME<CIF::BaseVersion>::NAME(ArgsT &&...args) : pImpl(new Impl(std::forward<ArgsT>(args)...)) {               \
+    pImpl->Retain(this);                                                                                               \
+  }                                                                                                                    \
+  inline NAME<CIF::BaseVersion>::NAME(Impl *pImpl) : pImpl(pImpl) { pImpl->Retain(this); }                             \
+  inline NAME<CIF::BaseVersion>::~NAME() { pImpl->Release(this); }
+
+#define CIF_PIMPL(T) T<CIF::BaseVersion>::Impl
+#define CIF_PIMPL_TYPENAME(T) typename T<CIF::BaseVersion>::Impl
+
+#define CREATE_CIF_PIMPL(T, ...) new CIF_PIMPL_T(T)(__VA_ARGS__)
 #if defined(_WIN32)
-    #define CIF_CALLING_CONV __cdecl
+#define CIF_CALLING_CONV __cdecl
 #else
-    #define CIF_CALLING_CONV
+#define CIF_CALLING_CONV
 #endif
diff --git a/include/igc/cif/cif/os/lin/lin_library_handle.cpp b/include/igc/cif/cif/os/lin/lin_library_handle.cpp
index 2f0cd61..bd79552 100644
--- a/include/igc/cif/cif/os/lin/lin_library_handle.cpp
+++ b/include/igc/cif/cif/os/lin/lin_library_handle.cpp
@@ -12,10 +12,10 @@ namespace CIF {
 
 std::unique_ptr<LibraryHandle> OpenLibrary(const std::string &path, bool addOsSpecificExtensionToPath) {
   void *mod = nullptr;
-  if(addOsSpecificExtensionToPath){
-      mod = dlopen((path + ".so").c_str(), RTLD_NOW);
-  }else{
-      mod = dlopen(path.c_str(), RTLD_NOW);
+  if (addOsSpecificExtensionToPath) {
+    mod = dlopen((path + ".so").c_str(), RTLD_NOW);
+  } else {
+    mod = dlopen(path.c_str(), RTLD_NOW);
   }
   return OpenLibrary(UniquePtrLibrary(mod));
 }
@@ -24,4 +24,4 @@ std::unique_ptr<LibraryHandle> OpenLibrary(const std::wstring &path, bool addOsS
   std::string pathAsString(path.begin(), path.end());
   return OpenLibrary(pathAsString, addOsSpecificExtensionToPath);
 }
-}
+} // namespace CIF
diff --git a/include/igc/cif/cif/os/lin/lin_library_handle.h b/include/igc/cif/cif/os/lin/lin_library_handle.h
index 60bb1e3..f7581e6 100644
--- a/include/igc/cif/cif/os/lin/lin_library_handle.h
+++ b/include/igc/cif/cif/os/lin/lin_library_handle.h
@@ -14,23 +14,19 @@ SPDX-License-Identifier: MIT
 
 namespace CIF {
 
-void RAIIReleaseHelper(void * mod) noexcept {
+void RAIIReleaseHelper(void *mod) noexcept {
   if (nullptr == mod) {
     return;
   }
   dlclose(mod);
 }
 
-using UniquePtrLibrary_t = std::unique_ptr<void,
-                                           decltype(&RAIIReleaseHelper)>;
-inline UniquePtrLibrary_t UniquePtrLibrary(void* mod) {
-  return UniquePtrLibrary_t(mod, &CIF::RAIIReleaseHelper);
-}
+using UniquePtrLibrary_t = std::unique_ptr<void, decltype(&RAIIReleaseHelper)>;
+inline UniquePtrLibrary_t UniquePtrLibrary(void *mod) { return UniquePtrLibrary_t(mod, &CIF::RAIIReleaseHelper); }
 
 class LinLibraryHandle : public LibraryHandle {
 public:
-  LinLibraryHandle(void* module, bool ownsHandle)
-      : module(module), ownsHandle(ownsHandle) {}
+  LinLibraryHandle(void *module, bool ownsHandle) : module(module), ownsHandle(ownsHandle) {}
   ~LinLibraryHandle() override {
     if (ownsHandle && (nullptr != module)) {
       dlclose(module);
@@ -45,7 +41,7 @@ class LinLibraryHandle : public LibraryHandle {
   }
 
 protected:
-  void* module;
+  void *module;
   bool ownsHandle;
 };
 
@@ -57,9 +53,9 @@ inline std::unique_ptr<LibraryHandle> OpenLibrary(UniquePtrLibrary_t module) {
 }
 
 // open based on existing handle - does not take ownership over handle
-inline std::unique_ptr<LibraryHandle> OpenLibrary(void* module) {
+inline std::unique_ptr<LibraryHandle> OpenLibrary(void *module) {
   std::unique_ptr<LibraryHandle> ret;
   ret.reset(new LinLibraryHandle(module, false));
   return ret;
 }
-}
+} // namespace CIF
diff --git a/include/igc/cif/cif/os/win/win_library_handle.cpp b/include/igc/cif/cif/os/win/win_library_handle.cpp
index 9c56e39..3602818 100644
--- a/include/igc/cif/cif/os/win/win_library_handle.cpp
+++ b/include/igc/cif/cif/os/win/win_library_handle.cpp
@@ -12,21 +12,21 @@ namespace CIF {
 
 std::unique_ptr<LibraryHandle> OpenLibrary(const std::string &path, bool addOsSpecificExtensionToPath) {
   HMODULE mod = NULL;
-  if(addOsSpecificExtensionToPath){
-      mod = LoadLibraryExA((path + ".dll").c_str(), NULL, 0);
-  }else{
-      mod = LoadLibraryExA(path.c_str(), NULL, 0);
+  if (addOsSpecificExtensionToPath) {
+    mod = LoadLibraryExA((path + ".dll").c_str(), NULL, 0);
+  } else {
+    mod = LoadLibraryExA(path.c_str(), NULL, 0);
   }
   return OpenLibrary(UniquePtrHMODULE(mod));
 }
 
 std::unique_ptr<LibraryHandle> OpenLibrary(const std::wstring &path, bool addOsSpecificExtensionToPath) {
   HMODULE mod = NULL;
-  if(addOsSpecificExtensionToPath){
-      mod = LoadLibraryExW((path + L".dll").c_str(), NULL, 0);
-  }else{
-      mod = LoadLibraryExW(path.c_str(), NULL, 0);
+  if (addOsSpecificExtensionToPath) {
+    mod = LoadLibraryExW((path + L".dll").c_str(), NULL, 0);
+  } else {
+    mod = LoadLibraryExW(path.c_str(), NULL, 0);
   }
   return OpenLibrary(UniquePtrHMODULE(mod));
 }
-}
+} // namespace CIF
diff --git a/include/igc/cif/cif/os/win/win_library_handle.h b/include/igc/cif/cif/os/win/win_library_handle.h
index 38a5ebf..31054d8 100644
--- a/include/igc/cif/cif/os/win/win_library_handle.h
+++ b/include/igc/cif/cif/os/win/win_library_handle.h
@@ -20,16 +20,12 @@ void RAIIReleaseHelper(HMODULE mod) {
   FreeLibrary(mod);
 }
 
-using UniquePtrHMODULE_t = std::unique_ptr<std::remove_pointer<HMODULE>::type,
-                                           decltype(&RAIIReleaseHelper)>;
-inline UniquePtrHMODULE_t UniquePtrHMODULE(HMODULE mod) {
-  return UniquePtrHMODULE_t(mod, RAIIReleaseHelper);
-}
+using UniquePtrHMODULE_t = std::unique_ptr<std::remove_pointer<HMODULE>::type, decltype(&RAIIReleaseHelper)>;
+inline UniquePtrHMODULE_t UniquePtrHMODULE(HMODULE mod) { return UniquePtrHMODULE_t(mod, RAIIReleaseHelper); }
 
 class WinLibraryHandle : public LibraryHandle {
 public:
-  WinLibraryHandle(HMODULE module, bool ownsHandle)
-      : module(module), ownsHandle(ownsHandle) {}
+  WinLibraryHandle(HMODULE module, bool ownsHandle) : module(module), ownsHandle(ownsHandle) {}
   ~WinLibraryHandle() override {
     if (ownsHandle && (NULL != module)) {
       FreeLibrary(module);
@@ -61,4 +57,4 @@ inline std::unique_ptr<LibraryHandle> OpenLibrary(HMODULE module) {
   ret.reset(new WinLibraryHandle(module, false));
   return ret;
 }
-}
+} // namespace CIF
diff --git a/include/igc/common/StateSaveAreaHeader.h b/include/igc/common/StateSaveAreaHeader.h
index 87f683a..698ec20 100644
--- a/include/igc/common/StateSaveAreaHeader.h
+++ b/include/igc/common/StateSaveAreaHeader.h
@@ -10,144 +10,140 @@ SPDX-License-Identifier: MIT
 
 namespace SIP {
 struct alignas(4) version {
-    uint8_t major;
-    uint8_t minor;
-    uint16_t patch;
+  uint8_t major;
+  uint8_t minor;
+  uint16_t patch;
 };
 
 struct alignas(8) StateSaveArea {
-    char magic[8] = "tssarea";
-    uint64_t reserved1;
-    struct version version;
-    uint8_t size;
-    uint8_t reserved2[3];
+  char magic[8] = "tssarea";
+  uint64_t reserved1;
+  struct version version;
+  uint8_t size;
+  uint8_t reserved2[3];
 };
 
 // Debug SIP will dump this data in debug surface.
 struct sr_ident {
-    char magic[8] = "srmagic";
-    struct version version;
-    uint8_t count;
-    uint8_t reserved[7];
+  char magic[8] = "srmagic";
+  struct version version;
+  uint8_t count;
+  uint8_t reserved[7];
 };
 
 struct alignas(8) regset_desc {
-    uint32_t offset;
-    uint16_t num;
-    uint16_t bits;
-    uint16_t bytes;
+  uint32_t offset;
+  uint16_t num;
+  uint16_t bits;
+  uint16_t bytes;
 };
 
 #define EXCHANGE_BUFFER_SIZE 112
 
 struct sip_command {
-    uint32_t command;
-    uint32_t size;
-    uint64_t offset;
-    uint8_t buffer[EXCHANGE_BUFFER_SIZE];
+  uint32_t command;
+  uint32_t size;
+  uint64_t offset;
+  uint8_t buffer[EXCHANGE_BUFFER_SIZE];
 };
 
 struct alignas(8) intelgt_state_save_area {
-    uint32_t num_slices;
-    uint32_t num_subslices_per_slice;
-    uint32_t num_eus_per_subslice;
-    uint32_t num_threads_per_eu;
-    uint32_t state_area_offset;
-    uint32_t state_save_size;
-    uint32_t slm_area_offset;
-    uint32_t slm_bank_size;
-    uint32_t slm_bank_valid;
-    uint32_t sr_magic_offset;
-    struct regset_desc grf;
-    struct regset_desc addr;
-    struct regset_desc flag;
-    struct regset_desc emask;
-    struct regset_desc sr;
-    struct regset_desc cr;
-    struct regset_desc notification;
-    struct regset_desc tdr;
-    struct regset_desc acc;
-    struct regset_desc mme;
-    struct regset_desc ce;
-    struct regset_desc sp;
-    struct regset_desc cmd;
-    struct regset_desc tm;
-    struct regset_desc fc;
-    struct regset_desc dbg;
-    struct regset_desc ctx;
-    struct regset_desc dbg_reg;
+  uint32_t num_slices;
+  uint32_t num_subslices_per_slice;
+  uint32_t num_eus_per_subslice;
+  uint32_t num_threads_per_eu;
+  uint32_t state_area_offset;
+  uint32_t state_save_size;
+  uint32_t slm_area_offset;
+  uint32_t slm_bank_size;
+  uint32_t slm_bank_valid;
+  uint32_t sr_magic_offset;
+  struct regset_desc grf;
+  struct regset_desc addr;
+  struct regset_desc flag;
+  struct regset_desc emask;
+  struct regset_desc sr;
+  struct regset_desc cr;
+  struct regset_desc notification;
+  struct regset_desc tdr;
+  struct regset_desc acc;
+  struct regset_desc mme;
+  struct regset_desc ce;
+  struct regset_desc sp;
+  struct regset_desc cmd;
+  struct regset_desc tm;
+  struct regset_desc fc;
+  struct regset_desc dbg;
+  struct regset_desc ctx;
+  struct regset_desc dbg_reg;
 };
 
 struct StateSaveAreaHeader {
-    struct StateSaveArea versionHeader;
-    struct intelgt_state_save_area regHeader;
+  struct StateSaveArea versionHeader;
+  struct intelgt_state_save_area regHeader;
 };
 
 struct fifo_node {
-    uint8_t valid;
-    uint8_t thread_id;
-    uint8_t eu_id;
-    uint8_t subslice_id;
-    uint8_t slice_id;
-    uint8_t reserved[3];
+  uint8_t valid;
+  uint8_t thread_id;
+  uint8_t eu_id;
+  uint8_t subslice_id;
+  uint8_t slice_id;
+  uint8_t reserved[3];
 };
 
-enum SIP_FLAGS {
-    SIP_FLAG_HEAPLESS = 1
-};
+enum SIP_FLAGS { SIP_FLAG_HEAPLESS = 1 };
 
 struct alignas(8) intelgt_state_save_area_V3 {
-    uint32_t num_slices;
-    uint32_t num_subslices_per_slice;
-    uint32_t num_eus_per_subslice;
-    uint32_t num_threads_per_eu;
-    uint32_t state_area_offset;
-    uint32_t state_save_size;
-    uint32_t slm_area_offset;
-    uint32_t slm_bank_size;
-    uint32_t reserved0;
-    uint32_t sr_magic_offset;
-    uint32_t fifo_offset;
-    uint32_t fifo_size;
-    uint32_t fifo_head;
-    uint32_t fifo_tail;
-    uint32_t fifo_version;
-    uint32_t reserved1[10];
-    uint32_t sip_flags;
-    struct regset_desc grf;
-    struct regset_desc addr;
-    struct regset_desc flag;
-    struct regset_desc emask;
-    struct regset_desc sr;
-    struct regset_desc cr;
-    struct regset_desc notification;
-    struct regset_desc tdr;
-    struct regset_desc acc;
-    struct regset_desc mme;
-    struct regset_desc ce;
-    struct regset_desc sp;
-    struct regset_desc cmd;
-    struct regset_desc tm;
-    struct regset_desc fc;
-    struct regset_desc dbg;
-    struct regset_desc ctx;
-    struct regset_desc dbg_reg;
-    struct regset_desc scalar;
-    struct regset_desc msg;
+  uint32_t num_slices;
+  uint32_t num_subslices_per_slice;
+  uint32_t num_eus_per_subslice;
+  uint32_t num_threads_per_eu;
+  uint32_t state_area_offset;
+  uint32_t state_save_size;
+  uint32_t slm_area_offset;
+  uint32_t slm_bank_size;
+  uint32_t reserved0;
+  uint32_t sr_magic_offset;
+  uint32_t fifo_offset;
+  uint32_t fifo_size;
+  uint32_t fifo_head;
+  uint32_t fifo_tail;
+  uint32_t fifo_version;
+  uint32_t reserved1[10];
+  uint32_t sip_flags;
+  struct regset_desc grf;
+  struct regset_desc addr;
+  struct regset_desc flag;
+  struct regset_desc emask;
+  struct regset_desc sr;
+  struct regset_desc cr;
+  struct regset_desc notification;
+  struct regset_desc tdr;
+  struct regset_desc acc;
+  struct regset_desc mme;
+  struct regset_desc ce;
+  struct regset_desc sp;
+  struct regset_desc cmd;
+  struct regset_desc tm;
+  struct regset_desc fc;
+  struct regset_desc dbg;
+  struct regset_desc ctx;
+  struct regset_desc dbg_reg;
+  struct regset_desc scalar;
+  struct regset_desc msg;
 };
 
 // versionHeader.version.major = 3
-struct StateSaveAreaHeaderV3
-{
-    struct StateSaveArea versionHeader;
-    struct intelgt_state_save_area_V3 regHeader;
+struct StateSaveAreaHeaderV3 {
+  struct StateSaveArea versionHeader;
+  struct intelgt_state_save_area_V3 regHeader;
 };
 
 // versionHeader.version.major = 4
-struct StateSaveAreaHeaderV4
-{
-    struct StateSaveArea versionHeader;
-    uint64_t total_wmtp_data_size;
+struct StateSaveAreaHeaderV4 {
+  struct StateSaveArea versionHeader;
+  uint64_t total_wmtp_data_size;
 };
 
-}  // namespace SIP
+} // namespace SIP
diff --git a/include/igc/ocl_igc_interface/code_type.h b/include/igc/ocl_igc_interface/code_type.h
index 6609f86..d49a8bd 100644
--- a/include/igc/ocl_igc_interface/code_type.h
+++ b/include/igc/ocl_igc_interface/code_type.h
@@ -24,6 +24,6 @@ constexpr auto oclGenBin = CodeTypeCoder::Enc("OCL_GEN_BIN");
 constexpr auto elf = CodeTypeCoder::Enc("ELF");
 constexpr auto undefined = CodeTypeCoder::Enc("UNDEFINED");
 constexpr auto invalid = CodeTypeCoder::Enc("INVALID");
-}
+} // namespace CodeType
 
-}
+} // namespace IGC
diff --git a/include/igc/ocl_igc_interface/fcl_ocl_device_ctx.h b/include/igc/ocl_igc_interface/fcl_ocl_device_ctx.h
index 988e651..55104fa 100644
--- a/include/igc/ocl_igc_interface/fcl_ocl_device_ctx.h
+++ b/include/igc/ocl_igc_interface/fcl_ocl_device_ctx.h
@@ -28,22 +28,24 @@ namespace IGC {
 
 CIF_DECLARE_INTERFACE(FclOclDeviceCtx, "FCL_OCL_DEVC");
 
-CIF_DEFINE_INTERFACE_VER(FclOclDeviceCtx, 1){
+CIF_DEFINE_INTERFACE_VER(FclOclDeviceCtx, 1) {
   CIF_INHERIT_CONSTRUCTOR();
 
-  // oclApiVersion (as supported by OCL runtime) format : version = major_revision*100 + minor_revision*10 +  sub_revision
+  // oclApiVersion (as supported by OCL runtime) format : version = major_revision*100 + minor_revision*10 +
+  // sub_revision
   //                                             e.g. OCL2.1 = 210
   OCL_API_CALL virtual void SetOclApiVersion(uint32_t version);
 
   template <typename FclOclTranslationCtxInterface = FclOclTranslationCtxTagOCL>
-  OCL_API_CALL CIF::RAII::UPtr_t<FclOclTranslationCtxInterface> CreateTranslationCtx(CodeType::CodeType_t inType, CodeType::CodeType_t outType) {
-    return CIF::RAII::Pack<FclOclTranslationCtxInterface>( CreateTranslationCtxImpl(FclOclTranslationCtxInterface::GetVersion(), inType, outType) );
+  OCL_API_CALL CIF::RAII::UPtr_t<FclOclTranslationCtxInterface> CreateTranslationCtx(CodeType::CodeType_t inType,
+                                                                                     CodeType::CodeType_t outType) {
+    return CIF::RAII::Pack<FclOclTranslationCtxInterface>(
+        CreateTranslationCtxImpl(FclOclTranslationCtxInterface::GetVersion(), inType, outType));
   }
 
 protected:
-  OCL_API_CALL virtual FclOclTranslationCtxBase *CreateTranslationCtxImpl(CIF::Version_t ver,
-                                                             CodeType::CodeType_t inType,
-                                                             CodeType::CodeType_t outType);
+  OCL_API_CALL virtual FclOclTranslationCtxBase *CreateTranslationCtxImpl(
+      CIF::Version_t ver, CodeType::CodeType_t inType, CodeType::CodeType_t outType);
 };
 
 CIF_DEFINE_INTERFACE_VER_WITH_COMPATIBILITY(FclOclDeviceCtx, 2, 1) {
@@ -52,42 +54,41 @@ CIF_DEFINE_INTERFACE_VER_WITH_COMPATIBILITY(FclOclDeviceCtx, 2, 1) {
 };
 
 CIF_DEFINE_INTERFACE_VER_WITH_COMPATIBILITY(FclOclDeviceCtx, 3, 2) {
-    CIF_INHERIT_CONSTRUCTOR();
-    using FclOclDeviceCtx<1>::CreateTranslationCtxImpl;
-    using FclOclDeviceCtx<1>::CreateTranslationCtx;
+  CIF_INHERIT_CONSTRUCTOR();
+  using FclOclDeviceCtx<1>::CreateTranslationCtxImpl;
+  using FclOclDeviceCtx<1>::CreateTranslationCtx;
 
-    template <typename FclOclTranslationCtxInterface = FclOclTranslationCtxTagOCL>
-    OCL_API_CALL CIF::RAII::UPtr_t<FclOclTranslationCtxInterface> CreateTranslationCtx(CodeType::CodeType_t inType, CodeType::CodeType_t outType, CIF::Builtins::BufferSimple* err) {
-        return CIF::RAII::Pack<FclOclTranslationCtxInterface>(CreateTranslationCtxImpl(FclOclTranslationCtxInterface::GetVersion(), inType, outType, err));
-    }
+  template <typename FclOclTranslationCtxInterface = FclOclTranslationCtxTagOCL>
+  OCL_API_CALL CIF::RAII::UPtr_t<FclOclTranslationCtxInterface> CreateTranslationCtx(
+      CodeType::CodeType_t inType, CodeType::CodeType_t outType, CIF::Builtins::BufferSimple * err) {
+    return CIF::RAII::Pack<FclOclTranslationCtxInterface>(
+        CreateTranslationCtxImpl(FclOclTranslationCtxInterface::GetVersion(), inType, outType, err));
+  }
 
 protected:
-    OCL_API_CALL virtual FclOclTranslationCtxBase* CreateTranslationCtxImpl(CIF::Version_t ver,
-                                                              CodeType::CodeType_t inType,
-                                                              CodeType::CodeType_t outType,
-                                                              CIF::Builtins::BufferSimple* err);
+  OCL_API_CALL virtual FclOclTranslationCtxBase *CreateTranslationCtxImpl(
+      CIF::Version_t ver, CodeType::CodeType_t inType, CodeType::CodeType_t outType, CIF::Builtins::BufferSimple * err);
 };
 
 CIF_DEFINE_INTERFACE_VER_WITH_COMPATIBILITY(FclOclDeviceCtx, 4, 3) {
-    CIF_INHERIT_CONSTRUCTOR();
+  CIF_INHERIT_CONSTRUCTOR();
 
-    template <typename PlatformInterface = PlatformTagOCL>
-    OCL_API_CALL CIF::RAII::UPtr_t<PlatformInterface> GetPlatformHandle() {
-        return CIF::RAII::RetainAndPack<PlatformInterface>( GetPlatformHandleImpl(PlatformInterface::GetVersion()) );
-    }
+  template <typename PlatformInterface = PlatformTagOCL>
+  OCL_API_CALL CIF::RAII::UPtr_t<PlatformInterface> GetPlatformHandle() {
+    return CIF::RAII::RetainAndPack<PlatformInterface>(GetPlatformHandleImpl(PlatformInterface::GetVersion()));
+  }
 
 protected:
-    OCL_API_CALL virtual PlatformBase *GetPlatformHandleImpl(CIF::Version_t ver);
+  OCL_API_CALL virtual PlatformBase *GetPlatformHandleImpl(CIF::Version_t ver);
 };
 
-CIF_DEFINE_INTERFACE_VER_WITH_COMPATIBILITY(FclOclDeviceCtx, 5, 4) {
-    CIF_INHERIT_CONSTRUCTOR();
-};
+CIF_DEFINE_INTERFACE_VER_WITH_COMPATIBILITY(FclOclDeviceCtx, 5, 4) { CIF_INHERIT_CONSTRUCTOR(); };
 
-CIF_GENERATE_VERSIONS_LIST_AND_DECLARE_INTERFACE_DEPENDENCIES(FclOclDeviceCtx, IGC::FclOclTranslationCtx, IGC::Platform);
+CIF_GENERATE_VERSIONS_LIST_AND_DECLARE_INTERFACE_DEPENDENCIES(FclOclDeviceCtx, IGC::FclOclTranslationCtx,
+                                                              IGC::Platform);
 CIF_MARK_LATEST_VERSION(FclOclDeviceCtxLatest, FclOclDeviceCtx);
 using FclOclDeviceCtxTagOCL = FclOclDeviceCtxLatest; // Note : can tag with different version for
                                                      //        transition periods
-}
+} // namespace IGC
 
 #include "cif/macros/disable.h"
diff --git a/include/igc/ocl_igc_interface/fcl_ocl_translation_ctx.h b/include/igc/ocl_igc_interface/fcl_ocl_translation_ctx.h
index 72a5cc5..0999eac 100644
--- a/include/igc/ocl_igc_interface/fcl_ocl_translation_ctx.h
+++ b/include/igc/ocl_igc_interface/fcl_ocl_translation_ctx.h
@@ -32,37 +32,32 @@ CIF_DEFINE_INTERFACE_VER(FclOclTranslationCtx, 1) {
 
   template <typename OclTranslationOutputInterface = OclTranslationOutputTagOCL>
   OCL_API_CALL CIF::RAII::UPtr_t<OclTranslationOutputInterface> Translate(
-                                                             CIF::Builtins::BufferSimple *src,
-                                                             CIF::Builtins::BufferSimple *options,
-                                                             CIF::Builtins::BufferSimple *internalOptions,
-                                                             CIF::Builtins::BufferSimple *tracingOptions,
-                                                             uint32_t tracingOptionsCount
-                                                             ) {
-      auto p = TranslateImpl(OclTranslationOutputInterface::GetVersion(),
-                             src, options, internalOptions, tracingOptions, tracingOptionsCount);
-      return CIF::RAII::Pack<OclTranslationOutputInterface>(p);
+      CIF::Builtins::BufferSimple * src, CIF::Builtins::BufferSimple * options,
+      CIF::Builtins::BufferSimple * internalOptions, CIF::Builtins::BufferSimple * tracingOptions,
+      uint32_t tracingOptionsCount) {
+    auto p = TranslateImpl(OclTranslationOutputInterface::GetVersion(), src, options, internalOptions, tracingOptions,
+                           tracingOptionsCount);
+    return CIF::RAII::Pack<OclTranslationOutputInterface>(p);
   }
 
 protected:
-   OCL_API_CALL virtual OclTranslationOutputBase *TranslateImpl(CIF::Version_t outVersion,
-                                                  CIF::Builtins::BufferSimple *src,
-                                                  CIF::Builtins::BufferSimple *options,
-                                                  CIF::Builtins::BufferSimple *internalOptions,
-                                                  CIF::Builtins::BufferSimple *tracingOptions,
-                                                  uint32_t tracingOptionsCount);
+  OCL_API_CALL virtual OclTranslationOutputBase *TranslateImpl(
+      CIF::Version_t outVersion, CIF::Builtins::BufferSimple * src, CIF::Builtins::BufferSimple * options,
+      CIF::Builtins::BufferSimple * internalOptions, CIF::Builtins::BufferSimple * tracingOptions,
+      uint32_t tracingOptionsCount);
 };
 
 CIF_DEFINE_INTERFACE_VER_WITH_COMPATIBILITY(FclOclTranslationCtx, 2, 1) {
   CIF_INHERIT_CONSTRUCTOR();
-  OCL_API_CALL virtual void GetFclOptions(CIF::Builtins::BufferSimple *options);
-  OCL_API_CALL virtual void GetFclInternalOptions(CIF::Builtins::BufferSimple *internalOptions);
+  OCL_API_CALL virtual void GetFclOptions(CIF::Builtins::BufferSimple * options);
+  OCL_API_CALL virtual void GetFclInternalOptions(CIF::Builtins::BufferSimple * internalOptions);
 };
 
-CIF_GENERATE_VERSIONS_LIST_AND_DECLARE_INTERFACE_DEPENDENCIES(FclOclTranslationCtx, IGC::OclTranslationOutput, CIF::Builtins::Buffer);
+CIF_GENERATE_VERSIONS_LIST_AND_DECLARE_INTERFACE_DEPENDENCIES(FclOclTranslationCtx, IGC::OclTranslationOutput,
+                                                              CIF::Builtins::Buffer);
 CIF_MARK_LATEST_VERSION(FclOclTranslationCtxLatest, FclOclTranslationCtx);
-using FclOclTranslationCtxTagOCL =
-    FclOclTranslationCtxLatest; // Note : can tag with different version for
-                                //        transition periods
-}
+using FclOclTranslationCtxTagOCL = FclOclTranslationCtxLatest; // Note : can tag with different version for
+                                                               //        transition periods
+} // namespace IGC
 
 #include "cif/macros/disable.h"
diff --git a/include/igc/ocl_igc_interface/gt_system_info.h b/include/igc/ocl_igc_interface/gt_system_info.h
index 603fb6a..c54b76d 100644
--- a/include/igc/ocl_igc_interface/gt_system_info.h
+++ b/include/igc/ocl_igc_interface/gt_system_info.h
@@ -23,88 +23,86 @@ namespace IGC {
 
 CIF_DECLARE_INTERFACE(GTSystemInfo, "GT_SYS_INFO")
 
-CIF_DEFINE_INTERFACE_VER(GTSystemInfo, 1){
+CIF_DEFINE_INTERFACE_VER(GTSystemInfo, 1) {
   CIF_INHERIT_CONSTRUCTOR();
 
- OCL_API_CALL virtual uint32_t GetEUCount() const;
- OCL_API_CALL virtual void SetEUCount(uint32_t v);
- OCL_API_CALL virtual uint32_t GetThreadCount() const;
- OCL_API_CALL virtual void SetThreadCount(uint32_t v);
- OCL_API_CALL virtual uint32_t GetSliceCount() const;
- OCL_API_CALL virtual void SetSliceCount(uint32_t v);
- OCL_API_CALL virtual uint32_t GetSubSliceCount() const;
- OCL_API_CALL virtual void SetSubSliceCount(uint32_t v);
- OCL_API_CALL virtual uint64_t GetL3CacheSizeInKb() const;
- OCL_API_CALL virtual void SetL3CacheSizeInKb(uint64_t v);
- OCL_API_CALL virtual uint64_t GetLLCCacheSizeInKb() const;
- OCL_API_CALL virtual void SetLLCCacheSizeInKb(uint64_t v);
- OCL_API_CALL virtual uint64_t GetEdramSizeInKb() const;
- OCL_API_CALL virtual void SetEdramSizeInKb(uint64_t v);
- OCL_API_CALL virtual uint32_t GetL3BankCount() const;
- OCL_API_CALL virtual void SetL3BankCount(uint32_t v);
- OCL_API_CALL virtual uint32_t GetMaxFillRate() const;
- OCL_API_CALL virtual void SetMaxFillRate(uint32_t v);
- OCL_API_CALL virtual uint32_t GetEuCountPerPoolMax() const;
- OCL_API_CALL virtual void SetEuCountPerPoolMax(uint32_t v);
- OCL_API_CALL virtual uint32_t GetEuCountPerPoolMin() const;
- OCL_API_CALL virtual void SetEuCountPerPoolMin(uint32_t v);
-
- OCL_API_CALL virtual uint32_t GetTotalVsThreads() const;
- OCL_API_CALL virtual void SetTotalVsThreads(uint32_t v);
- OCL_API_CALL virtual uint32_t GetTotalHsThreads() const;
- OCL_API_CALL virtual void SetTotalHsThreads(uint32_t v);
- OCL_API_CALL virtual uint32_t GetTotalDsThreads() const;
- OCL_API_CALL virtual void SetTotalDsThreads(uint32_t v);
- OCL_API_CALL virtual uint32_t GetTotalGsThreads() const;
- OCL_API_CALL virtual void SetTotalGsThreads(uint32_t v);
- OCL_API_CALL virtual uint32_t GetTotalPsThreadsWindowerRange() const;
- OCL_API_CALL virtual void SetTotalPsThreadsWindowerRange(uint32_t v);
-
- OCL_API_CALL virtual uint32_t GetCsrSizeInMb() const;
- OCL_API_CALL virtual void SetCsrSizeInMb(uint32_t v);
-
- OCL_API_CALL virtual uint32_t GetMaxEuPerSubSlice() const;
- OCL_API_CALL virtual void SetMaxEuPerSubSlice(uint32_t v);
- OCL_API_CALL virtual uint32_t GetMaxSlicesSupported() const;
- OCL_API_CALL virtual void SetMaxSlicesSupported(uint32_t v);
- OCL_API_CALL virtual uint32_t GetMaxSubSlicesSupported() const;
- OCL_API_CALL virtual void SetMaxSubSlicesSupported(uint32_t v);
- OCL_API_CALL virtual bool GetIsL3HashModeEnabled() const;
- OCL_API_CALL virtual void SetIsL3HashModeEnabled(bool v);
-
- OCL_API_CALL virtual bool GetIsDynamicallyPopulated() const;
- OCL_API_CALL virtual void SetIsDynamicallyPopulated(bool v);
+  OCL_API_CALL virtual uint32_t GetEUCount() const;
+  OCL_API_CALL virtual void SetEUCount(uint32_t v);
+  OCL_API_CALL virtual uint32_t GetThreadCount() const;
+  OCL_API_CALL virtual void SetThreadCount(uint32_t v);
+  OCL_API_CALL virtual uint32_t GetSliceCount() const;
+  OCL_API_CALL virtual void SetSliceCount(uint32_t v);
+  OCL_API_CALL virtual uint32_t GetSubSliceCount() const;
+  OCL_API_CALL virtual void SetSubSliceCount(uint32_t v);
+  OCL_API_CALL virtual uint64_t GetL3CacheSizeInKb() const;
+  OCL_API_CALL virtual void SetL3CacheSizeInKb(uint64_t v);
+  OCL_API_CALL virtual uint64_t GetLLCCacheSizeInKb() const;
+  OCL_API_CALL virtual void SetLLCCacheSizeInKb(uint64_t v);
+  OCL_API_CALL virtual uint64_t GetEdramSizeInKb() const;
+  OCL_API_CALL virtual void SetEdramSizeInKb(uint64_t v);
+  OCL_API_CALL virtual uint32_t GetL3BankCount() const;
+  OCL_API_CALL virtual void SetL3BankCount(uint32_t v);
+  OCL_API_CALL virtual uint32_t GetMaxFillRate() const;
+  OCL_API_CALL virtual void SetMaxFillRate(uint32_t v);
+  OCL_API_CALL virtual uint32_t GetEuCountPerPoolMax() const;
+  OCL_API_CALL virtual void SetEuCountPerPoolMax(uint32_t v);
+  OCL_API_CALL virtual uint32_t GetEuCountPerPoolMin() const;
+  OCL_API_CALL virtual void SetEuCountPerPoolMin(uint32_t v);
+
+  OCL_API_CALL virtual uint32_t GetTotalVsThreads() const;
+  OCL_API_CALL virtual void SetTotalVsThreads(uint32_t v);
+  OCL_API_CALL virtual uint32_t GetTotalHsThreads() const;
+  OCL_API_CALL virtual void SetTotalHsThreads(uint32_t v);
+  OCL_API_CALL virtual uint32_t GetTotalDsThreads() const;
+  OCL_API_CALL virtual void SetTotalDsThreads(uint32_t v);
+  OCL_API_CALL virtual uint32_t GetTotalGsThreads() const;
+  OCL_API_CALL virtual void SetTotalGsThreads(uint32_t v);
+  OCL_API_CALL virtual uint32_t GetTotalPsThreadsWindowerRange() const;
+  OCL_API_CALL virtual void SetTotalPsThreadsWindowerRange(uint32_t v);
+
+  OCL_API_CALL virtual uint32_t GetCsrSizeInMb() const;
+  OCL_API_CALL virtual void SetCsrSizeInMb(uint32_t v);
+
+  OCL_API_CALL virtual uint32_t GetMaxEuPerSubSlice() const;
+  OCL_API_CALL virtual void SetMaxEuPerSubSlice(uint32_t v);
+  OCL_API_CALL virtual uint32_t GetMaxSlicesSupported() const;
+  OCL_API_CALL virtual void SetMaxSlicesSupported(uint32_t v);
+  OCL_API_CALL virtual uint32_t GetMaxSubSlicesSupported() const;
+  OCL_API_CALL virtual void SetMaxSubSlicesSupported(uint32_t v);
+  OCL_API_CALL virtual bool GetIsL3HashModeEnabled() const;
+  OCL_API_CALL virtual void SetIsL3HashModeEnabled(bool v);
+
+  OCL_API_CALL virtual bool GetIsDynamicallyPopulated() const;
+  OCL_API_CALL virtual void SetIsDynamicallyPopulated(bool v);
 };
 
-CIF_DEFINE_INTERFACE_VER_WITH_COMPATIBILITY(GTSystemInfo, 2, 1) {
-  CIF_INHERIT_CONSTRUCTOR();
-};
+CIF_DEFINE_INTERFACE_VER_WITH_COMPATIBILITY(GTSystemInfo, 2, 1) { CIF_INHERIT_CONSTRUCTOR(); };
 
 CIF_DEFINE_INTERFACE_VER_WITH_COMPATIBILITY(GTSystemInfo, 3, 1) {
-    CIF_INHERIT_CONSTRUCTOR();
+  CIF_INHERIT_CONSTRUCTOR();
 
-   OCL_API_CALL virtual uint32_t GetMaxDualSubSlicesSupported() const;
-   OCL_API_CALL virtual void SetMaxDualSubSlicesSupported(uint32_t v);
-   OCL_API_CALL virtual uint32_t GetDualSubSliceCount() const;
-   OCL_API_CALL virtual void SetDualSubSliceCount(uint32_t v);
+  OCL_API_CALL virtual uint32_t GetMaxDualSubSlicesSupported() const;
+  OCL_API_CALL virtual void SetMaxDualSubSlicesSupported(uint32_t v);
+  OCL_API_CALL virtual uint32_t GetDualSubSliceCount() const;
+  OCL_API_CALL virtual void SetDualSubSliceCount(uint32_t v);
 };
 
 CIF_DEFINE_INTERFACE_VER_WITH_COMPATIBILITY(GTSystemInfo, 4, 3) {
-    CIF_INHERIT_CONSTRUCTOR();
+  CIF_INHERIT_CONSTRUCTOR();
 
-    OCL_API_CALL virtual uint32_t GetSLMSizeInKb() const;
-    OCL_API_CALL virtual void SetSLMSizeInKb(uint32_t v);
+  OCL_API_CALL virtual uint32_t GetSLMSizeInKb() const;
+  OCL_API_CALL virtual void SetSLMSizeInKb(uint32_t v);
 };
 
 CIF_DEFINE_INTERFACE_VER_WITH_COMPATIBILITY(GTSystemInfo, 5, 4) {
-    CIF_INHERIT_CONSTRUCTOR();
+  CIF_INHERIT_CONSTRUCTOR();
 };
 
 CIF_GENERATE_VERSIONS_LIST(GTSystemInfo);
 CIF_MARK_LATEST_VERSION(GTSystemInfoLatest, GTSystemInfo);
-using GTSystemInfoTagOCL = GTSystemInfo<5>;    // Note : can tag with different version for
-                                               //        transition periods
+using GTSystemInfoTagOCL = GTSystemInfo<5>; // Note : can tag with different version for
+                                            //        transition periods
 
-}
+} // namespace IGC
 
 #include "cif/macros/disable.h"
diff --git a/include/igc/ocl_igc_interface/igc_builtins.h b/include/igc/ocl_igc_interface/igc_builtins.h
index f76001d..a5d8057 100644
--- a/include/igc/ocl_igc_interface/igc_builtins.h
+++ b/include/igc/ocl_igc_interface/igc_builtins.h
@@ -23,90 +23,86 @@ namespace IGC {
 CIF_DECLARE_INTERFACE(IgcBuiltins, "IGC_BUILTINS")
 
 CIF_DEFINE_INTERFACE_VER(IgcBuiltins, 1) {
-    CIF_INHERIT_CONSTRUCTOR();
-
-    typedef struct BuiltinAlgorithm {
-        using Algorithm_t = uint64_t;
-        using AlgorithmCoder = CIF::Coder<Algorithm_t>;
-
-        static constexpr auto sort = AlgorithmCoder::Enc("SORT");
-        static constexpr auto clusteredSort = AlgorithmCoder::Enc("CLUSTER_SORT");
-        static constexpr auto clusteredSortedOrdinal = AlgorithmCoder::Enc("CSORTED_ORD");
-    } BuiltinAlgorithm;
-
-    typedef struct BuiltinMemoryType {
-        using MemoryType_t = uint64_t;
-        using MemoryTypeCoder = CIF::Coder<MemoryType_t>;
-
-        static constexpr auto SLM = MemoryTypeCoder::Enc("SLM");
-        static constexpr auto global = MemoryTypeCoder::Enc("GLOBAL");
-    } BuiltinMemoryType;
-
-    typedef struct BuiltinMemoryScope {
-        using MemoryScope_t = uint64_t;
-        using MemoryScopeCoder = CIF::Coder<MemoryScope_t>;
-
-        static constexpr auto workGroup = MemoryScopeCoder::Enc("WORK_GROUP");
-        static constexpr auto subGroup = MemoryScopeCoder::Enc("SUB_GROUP");
-    } BuiltinMemoryScope;
-
-    typedef struct BuiltinDataType {
-        using DataType_t = uint64_t;
-        using DataTypeCoder = CIF::Coder<DataType_t>;
-
-        static constexpr auto uint8_type = DataTypeCoder::Enc("UINT8");
-        static constexpr auto uint16_type = DataTypeCoder::Enc("UINT16");
-        static constexpr auto uint32_type = DataTypeCoder::Enc("UINT32");
-        static constexpr auto uint64_type = DataTypeCoder::Enc("UINT64");
-        static constexpr auto int8_type = DataTypeCoder::Enc("INT8");
-        static constexpr auto int16_type = DataTypeCoder::Enc("INT16");
-        static constexpr auto int32_type = DataTypeCoder::Enc("INT32");
-        static constexpr auto int64_type = DataTypeCoder::Enc("INT64");
-        static constexpr auto half_type = DataTypeCoder::Enc("HALF");
-        static constexpr auto float_type = DataTypeCoder::Enc("FLOAT");
-        static constexpr auto double_type = DataTypeCoder::Enc("DOUBLE");
-    } BuiltinDataType;
-
-    using AlgorithmVariant_t = uint64_t;
-    typedef struct SortAlgorithmVariant {
-        using SortVariantCoder = CIF::Coder<AlgorithmVariant_t>;
-
-        static constexpr auto defaultJointSort = SortVariantCoder::Enc("JOINT");
-        static constexpr auto defaultPrivateSort = SortVariantCoder::Enc("PRIVATE");
-    } SortAlgorithmVariant;
-
-    typedef struct IGCBuiltinMemoryInfo {
-        // Required amount of memory of a specified type (global or SLM)
-        // for a particular algorithm in IGC builtins.
-        long globalMemoryInBytes;
-        long sharedMemoryInBytes;
-
-        // The value is in bytes per scope (for example, if scope == WORK_GROUP,
-        // then the value is per work-group), >=0.
-        BuiltinMemoryScope::MemoryScope_t scope;
-
-        // Whether the temporary memory, requested by algorithm in IGC builtins
-        // can be used concurrently by different scopes.
-        // For example, if scope == WORK_GROUP, "true" means the same pointer can be passed
-        // to different work groups.
-        bool canMemoryBeUsedConcurrently;
-    } IGCBuiltinMemoryInfo;
-
-    // Returns true if the requrested configuration is supported by IGC
-    // Populates IGCBuiltinMemoryInfo struct that should be allocated by the caller
-    OCL_API_CALL virtual bool GetBuiltinMemoryRequired(IGCBuiltinMemoryInfo *memoryInfo,
-                                          BuiltinAlgorithm::Algorithm_t algorithm,
-                                          AlgorithmVariant_t variant,
-                                          BuiltinMemoryScope::MemoryScope_t scope,
-                                          long items,
-                                          long rangeSize,
-                                          BuiltinDataType::DataType_t keyType,
-                                          long valueTypeSizeInBytes) const;
+  CIF_INHERIT_CONSTRUCTOR();
+
+  typedef struct BuiltinAlgorithm {
+    using Algorithm_t = uint64_t;
+    using AlgorithmCoder = CIF::Coder<Algorithm_t>;
+
+    static constexpr auto sort = AlgorithmCoder::Enc("SORT");
+    static constexpr auto clusteredSort = AlgorithmCoder::Enc("CLUSTER_SORT");
+    static constexpr auto clusteredSortedOrdinal = AlgorithmCoder::Enc("CSORTED_ORD");
+  } BuiltinAlgorithm;
+
+  typedef struct BuiltinMemoryType {
+    using MemoryType_t = uint64_t;
+    using MemoryTypeCoder = CIF::Coder<MemoryType_t>;
+
+    static constexpr auto SLM = MemoryTypeCoder::Enc("SLM");
+    static constexpr auto global = MemoryTypeCoder::Enc("GLOBAL");
+  } BuiltinMemoryType;
+
+  typedef struct BuiltinMemoryScope {
+    using MemoryScope_t = uint64_t;
+    using MemoryScopeCoder = CIF::Coder<MemoryScope_t>;
+
+    static constexpr auto workGroup = MemoryScopeCoder::Enc("WORK_GROUP");
+    static constexpr auto subGroup = MemoryScopeCoder::Enc("SUB_GROUP");
+  } BuiltinMemoryScope;
+
+  typedef struct BuiltinDataType {
+    using DataType_t = uint64_t;
+    using DataTypeCoder = CIF::Coder<DataType_t>;
+
+    static constexpr auto uint8_type = DataTypeCoder::Enc("UINT8");
+    static constexpr auto uint16_type = DataTypeCoder::Enc("UINT16");
+    static constexpr auto uint32_type = DataTypeCoder::Enc("UINT32");
+    static constexpr auto uint64_type = DataTypeCoder::Enc("UINT64");
+    static constexpr auto int8_type = DataTypeCoder::Enc("INT8");
+    static constexpr auto int16_type = DataTypeCoder::Enc("INT16");
+    static constexpr auto int32_type = DataTypeCoder::Enc("INT32");
+    static constexpr auto int64_type = DataTypeCoder::Enc("INT64");
+    static constexpr auto half_type = DataTypeCoder::Enc("HALF");
+    static constexpr auto float_type = DataTypeCoder::Enc("FLOAT");
+    static constexpr auto double_type = DataTypeCoder::Enc("DOUBLE");
+  } BuiltinDataType;
+
+  using AlgorithmVariant_t = uint64_t;
+  typedef struct SortAlgorithmVariant {
+    using SortVariantCoder = CIF::Coder<AlgorithmVariant_t>;
+
+    static constexpr auto defaultJointSort = SortVariantCoder::Enc("JOINT");
+    static constexpr auto defaultPrivateSort = SortVariantCoder::Enc("PRIVATE");
+  } SortAlgorithmVariant;
+
+  typedef struct IGCBuiltinMemoryInfo {
+    // Required amount of memory of a specified type (global or SLM)
+    // for a particular algorithm in IGC builtins.
+    long globalMemoryInBytes;
+    long sharedMemoryInBytes;
+
+    // The value is in bytes per scope (for example, if scope == WORK_GROUP,
+    // then the value is per work-group), >=0.
+    BuiltinMemoryScope::MemoryScope_t scope;
+
+    // Whether the temporary memory, requested by algorithm in IGC builtins
+    // can be used concurrently by different scopes.
+    // For example, if scope == WORK_GROUP, "true" means the same pointer can be passed
+    // to different work groups.
+    bool canMemoryBeUsedConcurrently;
+  } IGCBuiltinMemoryInfo;
+
+  // Returns true if the requrested configuration is supported by IGC
+  // Populates IGCBuiltinMemoryInfo struct that should be allocated by the caller
+  OCL_API_CALL virtual bool GetBuiltinMemoryRequired(
+      IGCBuiltinMemoryInfo * memoryInfo, BuiltinAlgorithm::Algorithm_t algorithm, AlgorithmVariant_t variant,
+      BuiltinMemoryScope::MemoryScope_t scope, long items, long rangeSize, BuiltinDataType::DataType_t keyType,
+      long valueTypeSizeInBytes) const;
 };
 
 CIF_GENERATE_VERSIONS_LIST(IgcBuiltins);
 CIF_MARK_LATEST_VERSION(IgcBuiltinsLatest, IgcBuiltins);
 
-}
+} // namespace IGC
 
 #include "cif/macros/disable.h"
diff --git a/include/igc/ocl_igc_interface/igc_features_and_workarounds.h b/include/igc/ocl_igc_interface/igc_features_and_workarounds.h
index d1665c5..c9bb7d2 100644
--- a/include/igc/ocl_igc_interface/igc_features_and_workarounds.h
+++ b/include/igc/ocl_igc_interface/igc_features_and_workarounds.h
@@ -23,7 +23,7 @@ namespace IGC {
 
 CIF_DECLARE_INTERFACE(IgcFeaturesAndWorkarounds, "IGC_FE_WA")
 
-CIF_DEFINE_INTERFACE_VER(IgcFeaturesAndWorkarounds, 1){
+CIF_DEFINE_INTERFACE_VER(IgcFeaturesAndWorkarounds, 1) {
   CIF_INHERIT_CONSTRUCTOR();
 
   OCL_API_CALL virtual bool GetFtrDesktop() const;
@@ -79,7 +79,6 @@ CIF_DEFINE_INTERFACE_VER(IgcFeaturesAndWorkarounds, 1){
 
   OCL_API_CALL virtual bool GetFtrResourceStreamer() const;
   OCL_API_CALL virtual void SetFtrResourceStreamer(bool v);
-
 };
 
 CIF_DEFINE_INTERFACE_VER_WITH_COMPATIBILITY(IgcFeaturesAndWorkarounds, 2, 1) {
@@ -88,10 +87,7 @@ CIF_DEFINE_INTERFACE_VER_WITH_COMPATIBILITY(IgcFeaturesAndWorkarounds, 2, 1) {
   OCL_API_CALL virtual void SetMaxOCLParamSize(uint32_t s);
   OCL_API_CALL virtual uint32_t GetMaxOCLParamSize() const;
 };
-CIF_DEFINE_INTERFACE_VER_WITH_COMPATIBILITY(IgcFeaturesAndWorkarounds, 3, 2) {
-    CIF_INHERIT_CONSTRUCTOR();
-};
-
+CIF_DEFINE_INTERFACE_VER_WITH_COMPATIBILITY(IgcFeaturesAndWorkarounds, 3, 2) { CIF_INHERIT_CONSTRUCTOR(); };
 
 CIF_GENERATE_VERSIONS_LIST(IgcFeaturesAndWorkarounds);
 CIF_MARK_LATEST_VERSION(IgcFeaturesAndWorkaroundsLatest, IgcFeaturesAndWorkarounds);
@@ -99,8 +95,8 @@ CIF_MARK_LATEST_VERSION(IgcFeaturesAndWorkaroundsLatest, IgcFeaturesAndWorkaroun
 using IgcFeaturesAndWorkaroundsTagOCL = IgcFeaturesAndWorkarounds<3>; // transition time - remove this using
                                                                       // and uncomment the one below when finished
 
-//using IgcFeaturesAndWorkaroundsTagOCL = IgcFeaturesAndWorkaroundsLatest; // Note : can tag with different version for
-                                                                        //        transition periods
-}
+// using IgcFeaturesAndWorkaroundsTagOCL = IgcFeaturesAndWorkaroundsLatest; // Note : can tag with different version for
+//         transition periods
+} // namespace IGC
 
 #include "cif/macros/disable.h"
diff --git a/include/igc/ocl_igc_interface/igc_ocl_device_ctx.h b/include/igc/ocl_igc_interface/igc_ocl_device_ctx.h
index 05c51db..f3ff0f4 100644
--- a/include/igc/ocl_igc_interface/igc_ocl_device_ctx.h
+++ b/include/igc/ocl_igc_interface/igc_ocl_device_ctx.h
@@ -30,87 +30,86 @@ namespace IGC {
 
 CIF_DECLARE_INTERFACE(IgcOclDeviceCtx, "IGC_OCL_DEVC");
 
-CIF_DEFINE_INTERFACE_VER(IgcOclDeviceCtx, 1){
+CIF_DEFINE_INTERFACE_VER(IgcOclDeviceCtx, 1) {
   CIF_INHERIT_CONSTRUCTOR();
 
   template <typename PlatformInterface = PlatformTagOCL>
   OCL_API_CALL CIF::RAII::UPtr_t<PlatformInterface> GetPlatformHandle() {
-    return CIF::RAII::RetainAndPack<PlatformInterface>( GetPlatformHandleImpl(PlatformInterface::GetVersion()) );
+    return CIF::RAII::RetainAndPack<PlatformInterface>(GetPlatformHandleImpl(PlatformInterface::GetVersion()));
   }
 
   template <typename GTSystemInfoInterface = GTSystemInfoTagOCL>
   OCL_API_CALL CIF::RAII::UPtr_t<GTSystemInfoInterface> GetGTSystemInfoHandle() {
-    return CIF::RAII::RetainAndPack<GTSystemInfoInterface>( GetGTSystemInfoHandleImpl(GTSystemInfoInterface::GetVersion()) );
+    return CIF::RAII::RetainAndPack<GTSystemInfoInterface>(
+        GetGTSystemInfoHandleImpl(GTSystemInfoInterface::GetVersion()));
   }
 
   template <typename IgcFeaturesAndWorkaroundsInterface = IgcFeaturesAndWorkaroundsTagOCL>
   OCL_API_CALL CIF::RAII::UPtr_t<IgcFeaturesAndWorkaroundsInterface> GetIgcFeaturesAndWorkaroundsHandle() {
-    return CIF::RAII::RetainAndPack<IgcFeaturesAndWorkaroundsInterface>(  GetIgcFeaturesAndWorkaroundsHandleImpl(IgcFeaturesAndWorkaroundsInterface::GetVersion()) );
+    return CIF::RAII::RetainAndPack<IgcFeaturesAndWorkaroundsInterface>(
+        GetIgcFeaturesAndWorkaroundsHandleImpl(IgcFeaturesAndWorkaroundsInterface::GetVersion()));
   }
 
   virtual void SetProfilingTimerResolution(float v);
 
   template <typename OclIgcTranslationInterface = IgcOclTranslationCtxTagOCL>
-  OCL_API_CALL CIF::RAII::UPtr_t<OclIgcTranslationInterface> CreateTranslationCtx(CodeType::CodeType_t inType, CodeType::CodeType_t outType) {
-    return CIF::RAII::Pack<OclIgcTranslationInterface>( CreateTranslationCtxImpl(OclIgcTranslationInterface::GetVersion(), inType, outType) );
+  OCL_API_CALL CIF::RAII::UPtr_t<OclIgcTranslationInterface> CreateTranslationCtx(CodeType::CodeType_t inType,
+                                                                                  CodeType::CodeType_t outType) {
+    return CIF::RAII::Pack<OclIgcTranslationInterface>(
+        CreateTranslationCtxImpl(OclIgcTranslationInterface::GetVersion(), inType, outType));
   }
 
 protected:
   OCL_API_CALL virtual PlatformBase *GetPlatformHandleImpl(CIF::Version_t ver);
   OCL_API_CALL virtual GTSystemInfoBase *GetGTSystemInfoHandleImpl(CIF::Version_t ver);
   OCL_API_CALL virtual IgcFeaturesAndWorkaroundsBase *GetIgcFeaturesAndWorkaroundsHandleImpl(CIF::Version_t ver);
-  OCL_API_CALL virtual IgcOclTranslationCtxBase *CreateTranslationCtxImpl(CIF::Version_t ver,
-                                                             CodeType::CodeType_t inType,
-                                                             CodeType::CodeType_t outType);
+  OCL_API_CALL virtual IgcOclTranslationCtxBase *CreateTranslationCtxImpl(
+      CIF::Version_t ver, CodeType::CodeType_t inType, CodeType::CodeType_t outType);
 };
 
 namespace SystemRoutineType {
-    using SystemRoutineType_t = uint64_t;
-    using SystemRoutineTypeCoder = CIF::Coder<SystemRoutineType_t>;
-    constexpr auto contextSaveRestore = SystemRoutineTypeCoder::Enc("CSR");
-    constexpr auto debug = SystemRoutineTypeCoder::Enc("DBG");
-    constexpr auto debugSlm = SystemRoutineTypeCoder::Enc("DBG_SLM");
-    constexpr auto undefined = SystemRoutineTypeCoder::Enc("UNDEFINED");
-    constexpr auto invalid = SystemRoutineTypeCoder::Enc("INVALID");
-}
+using SystemRoutineType_t = uint64_t;
+using SystemRoutineTypeCoder = CIF::Coder<SystemRoutineType_t>;
+constexpr auto contextSaveRestore = SystemRoutineTypeCoder::Enc("CSR");
+constexpr auto debug = SystemRoutineTypeCoder::Enc("DBG");
+constexpr auto debugSlm = SystemRoutineTypeCoder::Enc("DBG_SLM");
+constexpr auto undefined = SystemRoutineTypeCoder::Enc("UNDEFINED");
+constexpr auto invalid = SystemRoutineTypeCoder::Enc("INVALID");
+} // namespace SystemRoutineType
 
 CIF_DEFINE_INTERFACE_VER_WITH_COMPATIBILITY(IgcOclDeviceCtx, 2, 1) {
-    CIF_INHERIT_CONSTRUCTOR();
+  CIF_INHERIT_CONSTRUCTOR();
 
-    OCL_API_CALL virtual bool GetSystemRoutine(SystemRoutineType::SystemRoutineType_t typeOfSystemRoutine,
-                                    bool bindless,
-                                    CIF::Builtins::BufferSimple *outSystemRoutineBuffer,
-                                    CIF::Builtins::BufferSimple *stateSaveAreaHeaderInit);
+  OCL_API_CALL virtual bool GetSystemRoutine(SystemRoutineType::SystemRoutineType_t typeOfSystemRoutine, bool bindless,
+                                             CIF::Builtins::BufferSimple *outSystemRoutineBuffer,
+                                             CIF::Builtins::BufferSimple *stateSaveAreaHeaderInit);
 };
 
 CIF_DEFINE_INTERFACE_VER_WITH_COMPATIBILITY(IgcOclDeviceCtx, 3, 2) {
   CIF_INHERIT_CONSTRUCTOR();
 
-  OCL_API_CALL virtual const char* GetIGCRevision();
+  OCL_API_CALL virtual const char *GetIGCRevision();
 };
 
 CIF_DEFINE_INTERFACE_VER_WITH_COMPATIBILITY(IgcOclDeviceCtx, 4, 3) {
-    CIF_INHERIT_CONSTRUCTOR();
+  CIF_INHERIT_CONSTRUCTOR();
 
-    template <typename IgcBuiltinsInterface = IgcBuiltinsLatest>
-    OCL_API_CALL CIF::RAII::UPtr_t<IgcBuiltinsInterface> GetIgcBuiltinsHandle() {
-        return CIF::RAII::RetainAndPack<IgcBuiltinsInterface>( GetIgcBuiltinsHandleImpl(IgcBuiltinsInterface::GetVersion()) );
-    }
+  template <typename IgcBuiltinsInterface = IgcBuiltinsLatest>
+  OCL_API_CALL CIF::RAII::UPtr_t<IgcBuiltinsInterface> GetIgcBuiltinsHandle() {
+    return CIF::RAII::RetainAndPack<IgcBuiltinsInterface>(GetIgcBuiltinsHandleImpl(IgcBuiltinsInterface::GetVersion()));
+  }
 
 protected:
-    OCL_API_CALL virtual IgcBuiltinsBase *GetIgcBuiltinsHandleImpl(CIF::Version_t ver);
+  OCL_API_CALL virtual IgcBuiltinsBase *GetIgcBuiltinsHandleImpl(CIF::Version_t ver);
 };
 
 CIF_GENERATE_VERSIONS_LIST_AND_DECLARE_INTERFACE_DEPENDENCIES(IgcOclDeviceCtx, IGC::Platform, IGC::GTSystemInfo,
-                                                                               IGC::OclGenBinary,
-                                                                               IGC::IgcFeaturesAndWorkarounds,
-                                                                               IGC::IgcOclTranslationCtx,
-                                                                               IGC::IgcBuiltins
-                                                             );
+                                                              IGC::OclGenBinary, IGC::IgcFeaturesAndWorkarounds,
+                                                              IGC::IgcOclTranslationCtx, IGC::IgcBuiltins);
 CIF_MARK_LATEST_VERSION(IgcOclDeviceCtxLatest, IgcOclDeviceCtx);
 using IgcOclDeviceCtxTagOCL = IgcOclDeviceCtx<3>; // Note : can tag with different version for
-                                                             //        transition periods
+                                                  //        transition periods
 
-}
+} // namespace IGC
 
 #include "cif/macros/disable.h"
diff --git a/include/igc/ocl_igc_interface/igc_ocl_translation_ctx.h b/include/igc/ocl_igc_interface/igc_ocl_translation_ctx.h
index e5dda35..89a155c 100644
--- a/include/igc/ocl_igc_interface/igc_ocl_translation_ctx.h
+++ b/include/igc/ocl_igc_interface/igc_ocl_translation_ctx.h
@@ -31,22 +31,20 @@ CIF_DEFINE_INTERFACE_VER(IgcOclTranslationCtx, 1) {
   CIF_INHERIT_CONSTRUCTOR();
 
   template <typename OclTranslationOutputInterface = OclTranslationOutputTagOCL>
-  OCL_API_CALL CIF::RAII::UPtr_t<OclTranslationOutputInterface> Translate(CIF::Builtins::BufferSimple *src,
-                                                             CIF::Builtins::BufferSimple *options,
-                                                             CIF::Builtins::BufferSimple *internalOptions,
-                                                             CIF::Builtins::BufferSimple *tracingOptions,
-                                                             uint32_t tracingOptionsCount) {
-      auto p = TranslateImpl(OclTranslationOutputInterface::GetVersion(), src, options, internalOptions, tracingOptions, tracingOptionsCount);
-      return CIF::RAII::Pack<OclTranslationOutputInterface>(p);
+  OCL_API_CALL CIF::RAII::UPtr_t<OclTranslationOutputInterface> Translate(
+      CIF::Builtins::BufferSimple * src, CIF::Builtins::BufferSimple * options,
+      CIF::Builtins::BufferSimple * internalOptions, CIF::Builtins::BufferSimple * tracingOptions,
+      uint32_t tracingOptionsCount) {
+    auto p = TranslateImpl(OclTranslationOutputInterface::GetVersion(), src, options, internalOptions, tracingOptions,
+                           tracingOptionsCount);
+    return CIF::RAII::Pack<OclTranslationOutputInterface>(p);
   }
 
 protected:
-  OCL_API_CALL virtual OclTranslationOutputBase *TranslateImpl(CIF::Version_t outVersion,
-                                                  CIF::Builtins::BufferSimple *src,
-                                                  CIF::Builtins::BufferSimple *options,
-                                                  CIF::Builtins::BufferSimple *internalOptions,
-                                                  CIF::Builtins::BufferSimple *tracingOptions,
-                                                  uint32_t tracingOptionsCount);
+  OCL_API_CALL virtual OclTranslationOutputBase *TranslateImpl(
+      CIF::Version_t outVersion, CIF::Builtins::BufferSimple * src, CIF::Builtins::BufferSimple * options,
+      CIF::Builtins::BufferSimple * internalOptions, CIF::Builtins::BufferSimple * tracingOptions,
+      uint32_t tracingOptionsCount);
 };
 
 CIF_DEFINE_INTERFACE_VER_WITH_COMPATIBILITY(IgcOclTranslationCtx, 2, 1) {
@@ -56,24 +54,20 @@ CIF_DEFINE_INTERFACE_VER_WITH_COMPATIBILITY(IgcOclTranslationCtx, 2, 1) {
   CIF_INHERIT_CONSTRUCTOR();
 
   template <typename OclTranslationOutputInterface = OclTranslationOutputTagOCL>
-  OCL_API_CALL CIF::RAII::UPtr_t<OclTranslationOutputInterface> Translate(CIF::Builtins::BufferSimple *src,
-                                                             CIF::Builtins::BufferSimple *options,
-                                                             CIF::Builtins::BufferSimple *internalOptions,
-                                                             CIF::Builtins::BufferSimple *tracingOptions,
-                                                             uint32_t tracingOptionsCount,
-                                                             void *gtPinInput) {
-      auto p = TranslateImpl(OclTranslationOutputInterface::GetVersion(), src, options, internalOptions, tracingOptions, tracingOptionsCount, gtPinInput);
-      return CIF::RAII::Pack<OclTranslationOutputInterface>(p);
+  OCL_API_CALL CIF::RAII::UPtr_t<OclTranslationOutputInterface> Translate(
+      CIF::Builtins::BufferSimple * src, CIF::Builtins::BufferSimple * options,
+      CIF::Builtins::BufferSimple * internalOptions, CIF::Builtins::BufferSimple * tracingOptions,
+      uint32_t tracingOptionsCount, void *gtPinInput) {
+    auto p = TranslateImpl(OclTranslationOutputInterface::GetVersion(), src, options, internalOptions, tracingOptions,
+                           tracingOptionsCount, gtPinInput);
+    return CIF::RAII::Pack<OclTranslationOutputInterface>(p);
   }
 
 protected:
-  OCL_API_CALL virtual OclTranslationOutputBase *TranslateImpl(CIF::Version_t outVersion,
-                                                  CIF::Builtins::BufferSimple *src,
-                                                  CIF::Builtins::BufferSimple *options,
-                                                  CIF::Builtins::BufferSimple *internalOptions,
-                                                  CIF::Builtins::BufferSimple *tracingOptions,
-                                                  uint32_t tracingOptionsCount,
-                                                  void *gtPinInput);
+  OCL_API_CALL virtual OclTranslationOutputBase *TranslateImpl(
+      CIF::Version_t outVersion, CIF::Builtins::BufferSimple * src, CIF::Builtins::BufferSimple * options,
+      CIF::Builtins::BufferSimple * internalOptions, CIF::Builtins::BufferSimple * tracingOptions,
+      uint32_t tracingOptionsCount, void *gtPinInput);
 };
 
 CIF_DEFINE_INTERFACE_VER_WITH_COMPATIBILITY(IgcOclTranslationCtx, 3, 2) {
@@ -83,39 +77,34 @@ CIF_DEFINE_INTERFACE_VER_WITH_COMPATIBILITY(IgcOclTranslationCtx, 3, 2) {
   CIF_INHERIT_CONSTRUCTOR();
 
   template <typename OclTranslationOutputInterface = OclTranslationOutputTagOCL>
-  OCL_API_CALL CIF::RAII::UPtr_t<OclTranslationOutputInterface> Translate(CIF::Builtins::BufferSimple *src,
-                                                             CIF::Builtins::BufferSimple *specConstantsIds,
-                                                             CIF::Builtins::BufferSimple *specConstantsValues,
-                                                             CIF::Builtins::BufferSimple *options,
-                                                             CIF::Builtins::BufferSimple *internalOptions,
-                                                             CIF::Builtins::BufferSimple *tracingOptions,
-                                                             uint32_t tracingOptionsCount,
-                                                             void *gtPinInput) {
-      auto p = TranslateImpl(OclTranslationOutputInterface::GetVersion(), src, specConstantsIds, specConstantsValues, options, internalOptions, tracingOptions, tracingOptionsCount, gtPinInput);
-      return CIF::RAII::Pack<OclTranslationOutputInterface>(p);
+  OCL_API_CALL CIF::RAII::UPtr_t<OclTranslationOutputInterface> Translate(
+      CIF::Builtins::BufferSimple * src, CIF::Builtins::BufferSimple * specConstantsIds,
+      CIF::Builtins::BufferSimple * specConstantsValues, CIF::Builtins::BufferSimple * options,
+      CIF::Builtins::BufferSimple * internalOptions, CIF::Builtins::BufferSimple * tracingOptions,
+      uint32_t tracingOptionsCount, void *gtPinInput) {
+    auto p = TranslateImpl(OclTranslationOutputInterface::GetVersion(), src, specConstantsIds, specConstantsValues,
+                           options, internalOptions, tracingOptions, tracingOptionsCount, gtPinInput);
+    return CIF::RAII::Pack<OclTranslationOutputInterface>(p);
   }
 
-  OCL_API_CALL virtual bool GetSpecConstantsInfoImpl(CIF::Builtins::BufferSimple *src,
-                                CIF::Builtins::BufferSimple *outSpecConstantsIds,
-                                CIF::Builtins::BufferSimple *outSpecConstantsSizes);
+  OCL_API_CALL virtual bool GetSpecConstantsInfoImpl(CIF::Builtins::BufferSimple * src,
+                                                     CIF::Builtins::BufferSimple * outSpecConstantsIds,
+                                                     CIF::Builtins::BufferSimple * outSpecConstantsSizes);
 
 protected:
-  OCL_API_CALL virtual OclTranslationOutputBase *TranslateImpl(CIF::Version_t outVersion,
-                                                  CIF::Builtins::BufferSimple *src,
-                                                  CIF::Builtins::BufferSimple *specConstantsIds,
-                                                  CIF::Builtins::BufferSimple *specConstantsValues,
-                                                  CIF::Builtins::BufferSimple *options,
-                                                  CIF::Builtins::BufferSimple *internalOptions,
-                                                  CIF::Builtins::BufferSimple *tracingOptions,
-                                                  uint32_t tracingOptionsCount,
-                                                  void *gtPinInput);
+  OCL_API_CALL virtual OclTranslationOutputBase *TranslateImpl(
+      CIF::Version_t outVersion, CIF::Builtins::BufferSimple * src, CIF::Builtins::BufferSimple * specConstantsIds,
+      CIF::Builtins::BufferSimple * specConstantsValues, CIF::Builtins::BufferSimple * options,
+      CIF::Builtins::BufferSimple * internalOptions, CIF::Builtins::BufferSimple * tracingOptions,
+      uint32_t tracingOptionsCount, void *gtPinInput);
 };
 
-CIF_GENERATE_VERSIONS_LIST_AND_DECLARE_INTERFACE_DEPENDENCIES(IgcOclTranslationCtx, IGC::OclTranslationOutput, CIF::Builtins::Buffer);
+CIF_GENERATE_VERSIONS_LIST_AND_DECLARE_INTERFACE_DEPENDENCIES(IgcOclTranslationCtx, IGC::OclTranslationOutput,
+                                                              CIF::Builtins::Buffer);
 CIF_MARK_LATEST_VERSION(IgcOclTranslationCtxLatest, IgcOclTranslationCtx);
 using IgcOclTranslationCtxTagOCL = IgcOclTranslationCtxLatest; // Note : can tag with different version for
                                                                //        transition periods
 
-}
+} // namespace IGC
 
 #include "cif/macros/disable.h"
diff --git a/include/igc/ocl_igc_interface/impl/fcl_ocl_device_ctx_impl.cpp b/include/igc/ocl_igc_interface/impl/fcl_ocl_device_ctx_impl.cpp
index 084fbd7..6f3c7f2 100644
--- a/include/igc/ocl_igc_interface/impl/fcl_ocl_device_ctx_impl.cpp
+++ b/include/igc/ocl_igc_interface/impl/fcl_ocl_device_ctx_impl.cpp
@@ -26,65 +26,60 @@ jmp_buf sig_jmp_buf;
 
 namespace IGC {
 
-void CIF_GET_INTERFACE_CLASS(FclOclDeviceCtx, 1)::SetOclApiVersion(uint32_t oclVersion){
-    CIF_GET_PIMPL()->MiscOptions.OclApiVersion = oclVersion;
+void CIF_GET_INTERFACE_CLASS(FclOclDeviceCtx, 1)::SetOclApiVersion(uint32_t oclVersion) {
+  CIF_GET_PIMPL()->MiscOptions.OclApiVersion = oclVersion;
 }
 
 CodeType::CodeType_t CIF_GET_INTERFACE_CLASS(FclOclDeviceCtx, 2)::GetPreferredIntermediateRepresentation() {
   return CodeType::spirV;
 }
 
-FclOclTranslationCtxBase *CIF_GET_INTERFACE_CLASS(FclOclDeviceCtx, 1)::CreateTranslationCtxImpl(CIF::Version_t ver,
-                                                                                                  CodeType::CodeType_t inType,
-                                                                                                  CodeType::CodeType_t outType){
-    EX_GUARD_BEGIN
-    return CIF_GET_PIMPL()->CreateTranslationCtx(ver, inType, outType);
-    EX_GUARD_END
+FclOclTranslationCtxBase *
+CIF_GET_INTERFACE_CLASS(FclOclDeviceCtx, 1)::CreateTranslationCtxImpl(CIF::Version_t ver, CodeType::CodeType_t inType,
+                                                                      CodeType::CodeType_t outType) {
+  EX_GUARD_BEGIN
+  return CIF_GET_PIMPL()->CreateTranslationCtx(ver, inType, outType);
+  EX_GUARD_END
 }
 
-FclOclTranslationCtxBase *CIF_PIMPL(FclOclDeviceCtx)::CreateTranslationCtx(CIF::Version_t version, CodeType::CodeType_t inType, CodeType::CodeType_t outType)
-{
-    if(false == CIF_PIMPL(FclOclTranslationCtx)::SupportsTranslation(inType, outType)){
-        return nullptr;
-    }
-    return CIF::InterfaceCreator<FclOclTranslationCtx>::CreateInterfaceVer(version, version, this, inType, outType);
+FclOclTranslationCtxBase *CIF_PIMPL(FclOclDeviceCtx)::CreateTranslationCtx(CIF::Version_t version,
+                                                                           CodeType::CodeType_t inType,
+                                                                           CodeType::CodeType_t outType) {
+  if (false == CIF_PIMPL(FclOclTranslationCtx)::SupportsTranslation(inType, outType)) {
+    return nullptr;
+  }
+  return CIF::InterfaceCreator<FclOclTranslationCtx>::CreateInterfaceVer(version, version, this, inType, outType);
 }
 
-FclOclTranslationCtxBase* CIF_GET_INTERFACE_CLASS(FclOclDeviceCtx, 3)::CreateTranslationCtxImpl(CIF::Version_t ver,
-                                                                                                  CodeType::CodeType_t inType,
-                                                                                                  CodeType::CodeType_t outType,
-                                                                                                  CIF::Builtins::BufferSimple* err) {
-    EX_GUARD_BEGIN
-    return CIF_GET_PIMPL()->CreateTranslationCtx(ver, inType, outType, err);
-    EX_GUARD_END
+FclOclTranslationCtxBase *CIF_GET_INTERFACE_CLASS(FclOclDeviceCtx, 3)::CreateTranslationCtxImpl(
+    CIF::Version_t ver, CodeType::CodeType_t inType, CodeType::CodeType_t outType, CIF::Builtins::BufferSimple *err) {
+  EX_GUARD_BEGIN
+  return CIF_GET_PIMPL()->CreateTranslationCtx(ver, inType, outType, err);
+  EX_GUARD_END
 }
 
-FclOclTranslationCtxBase* CIF_PIMPL(FclOclDeviceCtx)::CreateTranslationCtx(CIF::Version_t version, CodeType::CodeType_t inType, CodeType::CodeType_t outType, CIF::Builtins::BufferSimple* err)
-{
-    if (false == CIF_PIMPL(FclOclTranslationCtx)::SupportsTranslation(inType, outType)) {
-        return nullptr;
-    }
-    return CIF::InterfaceCreator<FclOclTranslationCtx>::CreateInterfaceVer(version, version, this, inType, outType, err);
+FclOclTranslationCtxBase *CIF_PIMPL(FclOclDeviceCtx)::CreateTranslationCtx(CIF::Version_t version,
+                                                                           CodeType::CodeType_t inType,
+                                                                           CodeType::CodeType_t outType,
+                                                                           CIF::Builtins::BufferSimple *err) {
+  if (false == CIF_PIMPL(FclOclTranslationCtx)::SupportsTranslation(inType, outType)) {
+    return nullptr;
+  }
+  return CIF::InterfaceCreator<FclOclTranslationCtx>::CreateInterfaceVer(version, version, this, inType, outType, err);
 }
 
-PlatformBase *CIF_GET_INTERFACE_CLASS(FclOclDeviceCtx, 4)::GetPlatformHandleImpl(CIF::Version_t ver){
-    return CIF_GET_PIMPL()->GetPlatformHandle(ver);
+PlatformBase *CIF_GET_INTERFACE_CLASS(FclOclDeviceCtx, 4)::GetPlatformHandleImpl(CIF::Version_t ver) {
+  return CIF_GET_PIMPL()->GetPlatformHandle(ver);
 }
 
-}
+} // namespace IGC
 
 CIF_EXPORT_ENTRY_POINTS_STATIC(IGC::FclOclDeviceCtx);
 
 #include "cif/macros/disable.h"
 
 #if defined(WIN32)
-int ex_filter(unsigned int code, struct _EXCEPTION_POINTERS* ep)
-{
-    return EXCEPTION_EXECUTE_HANDLER;
-}
+int ex_filter(unsigned int code, struct _EXCEPTION_POINTERS *ep) { return EXCEPTION_EXECUTE_HANDLER; }
 #else
-void signalHandler(int sig, siginfo_t* info, void* ucontext)
-{
-    longjmp(sig_jmp_buf, sig);
-}
+void signalHandler(int sig, siginfo_t *info, void *ucontext) { longjmp(sig_jmp_buf, sig); }
 #endif
diff --git a/include/igc/ocl_igc_interface/impl/fcl_ocl_device_ctx_impl.h b/include/igc/ocl_igc_interface/impl/fcl_ocl_device_ctx_impl.h
index 602605e..b7b16fa 100644
--- a/include/igc/ocl_igc_interface/impl/fcl_ocl_device_ctx_impl.h
+++ b/include/igc/ocl_igc_interface/impl/fcl_ocl_device_ctx_impl.h
@@ -25,98 +25,83 @@ SPDX-License-Identifier: MIT
 #include "cif/macros/enable.h"
 #include "OCLAPI/oclapi.h"
 
-namespace IGC
-{
-
-CIF_DECLARE_INTERFACE_PIMPL(FclOclDeviceCtx) : CIF::PimplBase
-{
-    CIF_PIMPL_DECLARE_CONSTRUCTOR(CIF::Version_t version, CIF::ICIF *parentInterface)
-    {
-        platform.CreateImpl();
-    }
-
-    OCL_API_CALL FclOclTranslationCtxBase * CreateTranslationCtx(CIF::Version_t version, CodeType::CodeType_t inType, CodeType::CodeType_t outType);
-    OCL_API_CALL FclOclTranslationCtxBase * CreateTranslationCtx(CIF::Version_t version, CodeType::CodeType_t inType, CodeType::CodeType_t outType, CIF::Builtins::BufferSimple* err);
-
-    OCL_API_CALL PlatformBase * GetPlatformHandle(CIF::Version_t version)
-    {
-        return platform.GetVersion(version);
-    }
-
-    OCL_API_CALL CIF_PIMPL(Platform)* GetPlatformImpl()
-    {
-        return this->platform.GetImpl();
-    }
-
-    struct OCL_API_CALL MiscOptions
-    {
-        MiscOptions()
-        {
-            this->Clear();
-        }
-
-        void Clear()
-        {
-            OclApiVersion = 120;
-        }
-
-        // oclApiVersion format : version = major_revision*100 + minor_revision*10 +  sub_revision
-        //                                    e.g. OCL2.1 = 210
-        uint32_t OclApiVersion;
-    } MiscOptions;
+namespace IGC {
+
+CIF_DECLARE_INTERFACE_PIMPL(FclOclDeviceCtx) : CIF::PimplBase {
+  CIF_PIMPL_DECLARE_CONSTRUCTOR(CIF::Version_t version, CIF::ICIF * parentInterface) { platform.CreateImpl(); }
+
+  OCL_API_CALL FclOclTranslationCtxBase *CreateTranslationCtx(CIF::Version_t version, CodeType::CodeType_t inType,
+                                                              CodeType::CodeType_t outType);
+  OCL_API_CALL FclOclTranslationCtxBase *CreateTranslationCtx(CIF::Version_t version, CodeType::CodeType_t inType,
+                                                              CodeType::CodeType_t outType,
+                                                              CIF::Builtins::BufferSimple * err);
+
+  OCL_API_CALL PlatformBase *GetPlatformHandle(CIF::Version_t version) { return platform.GetVersion(version); }
+
+  OCL_API_CALL CIF_PIMPL(Platform) * GetPlatformImpl() { return this->platform.GetImpl(); }
+
+  struct OCL_API_CALL MiscOptions {
+    MiscOptions() { this->Clear(); }
+
+    void Clear() { OclApiVersion = 120; }
+
+    // oclApiVersion format : version = major_revision*100 + minor_revision*10 +  sub_revision
+    //                                    e.g. OCL2.1 = 210
+    uint32_t OclApiVersion;
+  } MiscOptions;
 
 protected:
-    CIF::Multiversion<Platform> platform;
+  CIF::Multiversion<Platform> platform;
 };
 
 CIF_DEFINE_INTERFACE_TO_PIMPL_FORWARDING_CTOR_DTOR(FclOclDeviceCtx);
 
-}
+} // namespace IGC
 
 #include "cif/macros/disable.h"
 
 #if defined(NDEBUG)
 #if defined(WIN32)
-OCL_API_CALL int ex_filter(unsigned int code, struct _EXCEPTION_POINTERS* ep);
+OCL_API_CALL int ex_filter(unsigned int code, struct _EXCEPTION_POINTERS *ep);
 
-#define EX_GUARD_BEGIN                                                        \
-__try                                                                         \
-{                                                                             \
+#define EX_GUARD_BEGIN __try {
 
-#define EX_GUARD_END                                                          \
-}                                                                             \
-__except (ex_filter(GetExceptionCode(), GetExceptionInformation()))           \
-{                                                                             \
-    return nullptr;                                                            \
-}                                                                             \
+#define EX_GUARD_END                                                                                                   \
+  }                                                                                                                    \
+  __except (ex_filter(GetExceptionCode(), GetExceptionInformation())) {                                                \
+    return nullptr;                                                                                                    \
+  }
 
 #else
-OCL_API_CALL void signalHandler(int sig, siginfo_t* info, void* ucontext);
+OCL_API_CALL void signalHandler(int sig, siginfo_t *info, void *ucontext);
 
 #include "igc_signal_guard.h"
 
-#define EX_GUARD_BEGIN                                                         \
-  do {                                                                         \
-    SET_SIG_HANDLER(SIGABRT)                                                   \
-    SET_SIG_HANDLER(SIGFPE)                                                    \
-    SET_SIG_HANDLER(SIGILL)                                                    \
-    SET_SIG_HANDLER(SIGINT)                                                    \
-    SET_SIG_HANDLER(SIGSEGV)                                                   \
-    SET_SIG_HANDLER(SIGTERM)                                                   \
-    int sig = setjmp(sig_jmp_buf);                                             \
+#define EX_GUARD_BEGIN                                                                                                 \
+  do {                                                                                                                 \
+    SET_SIG_HANDLER(SIGABRT)                                                                                           \
+    SET_SIG_HANDLER(SIGFPE)                                                                                            \
+    SET_SIG_HANDLER(SIGILL)                                                                                            \
+    SET_SIG_HANDLER(SIGINT)                                                                                            \
+    SET_SIG_HANDLER(SIGSEGV)                                                                                           \
+    SET_SIG_HANDLER(SIGTERM)                                                                                           \
+    int sig = setjmp(sig_jmp_buf);                                                                                     \
     if (sig == 0) {
 
-#define EX_GUARD_END                                                           \
-    } else {                                                                   \
-      return nullptr;                                                          \
-    }                                                                          \
-    REMOVE_SIG_HANDLER(SIGABRT)                                                \
-    REMOVE_SIG_HANDLER(SIGFPE)                                                 \
-    REMOVE_SIG_HANDLER(SIGILL)                                                 \
-    REMOVE_SIG_HANDLER(SIGINT)                                                 \
-    REMOVE_SIG_HANDLER(SIGSEGV)                                                \
-    REMOVE_SIG_HANDLER(SIGTERM)                                                \
-  } while (0);
+#define EX_GUARD_END                                                                                                   \
+  }                                                                                                                    \
+  else {                                                                                                               \
+    return nullptr;                                                                                                    \
+  }                                                                                                                    \
+  REMOVE_SIG_HANDLER(SIGABRT)                                                                                          \
+  REMOVE_SIG_HANDLER(SIGFPE)                                                                                           \
+  REMOVE_SIG_HANDLER(SIGILL)                                                                                           \
+  REMOVE_SIG_HANDLER(SIGINT)                                                                                           \
+  REMOVE_SIG_HANDLER(SIGSEGV)                                                                                          \
+  REMOVE_SIG_HANDLER(SIGTERM)                                                                                          \
+  }                                                                                                                    \
+  while (0)                                                                                                            \
+    ;
 
 #endif
 #else
diff --git a/include/igc/ocl_igc_interface/impl/fcl_ocl_translation_ctx_impl.cpp b/include/igc/ocl_igc_interface/impl/fcl_ocl_translation_ctx_impl.cpp
index a82ca14..d3ec5e2 100644
--- a/include/igc/ocl_igc_interface/impl/fcl_ocl_translation_ctx_impl.cpp
+++ b/include/igc/ocl_igc_interface/impl/fcl_ocl_translation_ctx_impl.cpp
@@ -19,9 +19,9 @@ SPDX-License-Identifier: MIT
 
 #include <optional>
 
-#pragma warning(disable:4141)
-#pragma warning(disable:4146)
-#pragma warning(disable:4242)
+#pragma warning(disable : 4141)
+#pragma warning(disable : 4146)
+#pragma warning(disable : 4242)
 #include <llvm/ADT/Triple.h>
 #include <llvm/ADT/STLExtras.h>
 #include <llvm/Support/CommandLine.h>
@@ -33,9 +33,9 @@ SPDX-License-Identifier: MIT
 #include <llvm/Support/StringSaver.h>
 #include <llvm/Support/Host.h>
 #include <llvmWrapper/ADT/Optional.h>
-#pragma warning(default:4242)
-#pragma warning(default:4146)
-#pragma warning(default:4141)
+#pragma warning(default : 4242)
+#pragma warning(default : 4146)
+#pragma warning(default : 4141)
 
 #include <algorithm>
 #include <numeric>
@@ -49,7 +49,7 @@ SPDX-License-Identifier: MIT
 #include <sstream>
 #endif
 
-#if defined( _DEBUG ) || defined( _INTERNAL )
+#if defined(_DEBUG) || defined(_INTERNAL)
 #include <numeric>
 #include <array>
 #endif // defined( _DEBUG ) || defined( _INTERNAL )
@@ -70,170 +70,149 @@ namespace {
 using HashType = unsigned long long;
 
 struct FeShaderDumpData {
-    struct DumpDescriptor {
-        llvm::StringRef OutputName;
-        llvm::StringRef Contents;
-    };
-    FeShaderDumpData(PLATFORM *Platform, const char *Selected,
-                     int Stepping, CIF::Builtins::BufferSimple* src,
-                     CIF::Builtins::BufferSimple* options,
-                     CIF::Builtins::BufferSimple* internalOptions,
-                     CIF::Builtins::BufferSimple* tracingOptions);
-    std::vector<DumpDescriptor> getDumps() const;
+  struct DumpDescriptor {
+    llvm::StringRef OutputName;
+    llvm::StringRef Contents;
+  };
+  FeShaderDumpData(PLATFORM *Platform, const char *Selected, int Stepping, CIF::Builtins::BufferSimple *src,
+                   CIF::Builtins::BufferSimple *options, CIF::Builtins::BufferSimple *internalOptions,
+                   CIF::Builtins::BufferSimple *tracingOptions);
+  std::vector<DumpDescriptor> getDumps() const;
 
 private:
-    std::string PlatformInformation;
-    CIF::Builtins::BufferSimple* InputSource = nullptr;
-    CIF::Builtins::BufferSimple* Options = nullptr;
-    CIF::Builtins::BufferSimple* InternalOptions = nullptr;
-    CIF::Builtins::BufferSimple* TracingOptions = nullptr;
+  std::string PlatformInformation;
+  CIF::Builtins::BufferSimple *InputSource = nullptr;
+  CIF::Builtins::BufferSimple *Options = nullptr;
+  CIF::Builtins::BufferSimple *InternalOptions = nullptr;
+  CIF::Builtins::BufferSimple *TracingOptions = nullptr;
 };
 
-FeShaderDumpData::FeShaderDumpData(PLATFORM *Platform, const char *Selected,
-                                   int Stepping,
-                                   CIF::Builtins::BufferSimple* Src,
-                                   CIF::Builtins::BufferSimple* Opts,
-                                   CIF::Builtins::BufferSimple* InternalOpts,
-                                   CIF::Builtins::BufferSimple* TracingOpts) {
-    std::ostringstream Os;
-    if (Platform) {
-        auto Core = Platform->eDisplayCoreFamily;
-        auto RenderCore = Platform->eRenderCoreFamily;
-        auto Product = Platform->eProductFamily;
-        auto RevId = Platform->usRevId;
-
-        Os << "NEO passed: DisplayCore = " << Core
-            << ", RenderCore = " << RenderCore << ", Product = " << Product
-            << ", Revision = " << RevId << "\n";
-        Os << "IGC translated into: " << Selected << ", " << Stepping << "\n";
-    } else {
-        Os << "Nothing came from NEO\n";
-    }
-    PlatformInformation = Os.str();
-
-    InputSource = Src;
-    Options = Opts;
-    InternalOptions = InternalOpts;
-    TracingOptions = TracingOpts;
+FeShaderDumpData::FeShaderDumpData(PLATFORM *Platform, const char *Selected, int Stepping,
+                                   CIF::Builtins::BufferSimple *Src, CIF::Builtins::BufferSimple *Opts,
+                                   CIF::Builtins::BufferSimple *InternalOpts,
+                                   CIF::Builtins::BufferSimple *TracingOpts) {
+  std::ostringstream Os;
+  if (Platform) {
+    auto Core = Platform->eDisplayCoreFamily;
+    auto RenderCore = Platform->eRenderCoreFamily;
+    auto Product = Platform->eProductFamily;
+    auto RevId = Platform->usRevId;
+
+    Os << "NEO passed: DisplayCore = " << Core << ", RenderCore = " << RenderCore << ", Product = " << Product
+       << ", Revision = " << RevId << "\n";
+    Os << "IGC translated into: " << Selected << ", " << Stepping << "\n";
+  } else {
+    Os << "Nothing came from NEO\n";
+  }
+  PlatformInformation = Os.str();
+
+  InputSource = Src;
+  Options = Opts;
+  InternalOptions = InternalOpts;
+  TracingOptions = TracingOpts;
 }
 
 std::vector<FeShaderDumpData::DumpDescriptor> FeShaderDumpData::getDumps() const {
-    auto AsStringRef = [](CIF::Builtins::BufferSimple* Src) {
-        if (!Src)
-            return llvm::StringRef();
-        size_t Size = Src->GetSize<char>();
-        const char* Buff = Src->GetMemory<char>();
-        return llvm::StringRef(Buff, Size);
-    };
-    return {
-        { "platform", PlatformInformation.c_str() },
-        { "source_code", AsStringRef(InputSource) },
-        { "options", AsStringRef(Options) },
-        { "internal_options", AsStringRef(InternalOptions) },
-        { "tracing_options", AsStringRef(TracingOptions) }
-    };
+  auto AsStringRef = [](CIF::Builtins::BufferSimple *Src) {
+    if (!Src)
+      return llvm::StringRef();
+    size_t Size = Src->GetSize<char>();
+    const char *Buff = Src->GetMemory<char>();
+    return llvm::StringRef(Buff, Size);
+  };
+  return {{"platform", PlatformInformation.c_str()},
+          {"source_code", AsStringRef(InputSource)},
+          {"options", AsStringRef(Options)},
+          {"internal_options", AsStringRef(InternalOptions)},
+          {"tracing_options", AsStringRef(TracingOptions)}};
 }
 
-std::optional<FeShaderDumpData>
-getShaderDumpData(PLATFORM *Platform, const char *Selected,
-                  int Stepping, CIF::Builtins::BufferSimple* Src,
-                  CIF::Builtins::BufferSimple* Options,
-                  CIF::Builtins::BufferSimple* InternalOptions,
-                  CIF::Builtins::BufferSimple* TracingOptions) {
-#if defined( _DEBUG ) || defined( _INTERNAL )
-    if (!FCL_IGC_IS_FLAG_ENABLED(ShaderDumpEnable))
-        return {};
-
-    return FeShaderDumpData(Platform, Selected, Stepping, Src,
-                            Options, InternalOptions, TracingOptions);
-#else
+std::optional<FeShaderDumpData> getShaderDumpData(PLATFORM *Platform, const char *Selected, int Stepping,
+                                                  CIF::Builtins::BufferSimple *Src,
+                                                  CIF::Builtins::BufferSimple *Options,
+                                                  CIF::Builtins::BufferSimple *InternalOptions,
+                                                  CIF::Builtins::BufferSimple *TracingOptions) {
+#if defined(_DEBUG) || defined(_INTERNAL)
+  if (!FCL_IGC_IS_FLAG_ENABLED(ShaderDumpEnable))
     return {};
+
+  return FeShaderDumpData(Platform, Selected, Stepping, Src, Options, InternalOptions, TracingOptions);
+#else
+  return {};
 #endif
 }
 
-void emitFCLDump(llvm::StringRef FilenamePrefix,
-                        FeShaderDumpData::DumpDescriptor DataToDump) {
-#if defined( _DEBUG ) || defined( _INTERNAL )
-    // do factual dump, this part can be replaced to DumpShaderFile
-    const char *DstDir = FCL::GetShaderOutputFolder();
-    std::ostringstream FullPath(DstDir, std::ostringstream::ate);
-    FullPath << FilenamePrefix.str() << "_" << DataToDump.OutputName.str()
-             << ".txt";
-    // NOTE: for now, we expect only text data here
-    std::ofstream OutF(FullPath.str(), std::ofstream::out);
-    // if we can create dump file at all...
-    if (OutF)
-        OutF.write(DataToDump.Contents.data(), DataToDump.Contents.size());
+void emitFCLDump(llvm::StringRef FilenamePrefix, FeShaderDumpData::DumpDescriptor DataToDump) {
+#if defined(_DEBUG) || defined(_INTERNAL)
+  // do factual dump, this part can be replaced to DumpShaderFile
+  const char *DstDir = FCL::GetShaderOutputFolder();
+  std::ostringstream FullPath(DstDir, std::ostringstream::ate);
+  FullPath << FilenamePrefix.str() << "_" << DataToDump.OutputName.str() << ".txt";
+  // NOTE: for now, we expect only text data here
+  std::ofstream OutF(FullPath.str(), std::ofstream::out);
+  // if we can create dump file at all...
+  if (OutF)
+    OutF.write(DataToDump.Contents.data(), DataToDump.Contents.size());
 #endif
 }
 
-std::string makeShaderDumpPrefixWithHash(llvm::StringRef Prefix,
-                                                HashType Hash) {
-    std::ostringstream OS;
-    OS << Prefix.str() << std::hex << std::setfill('0') <<
-        std::setw(sizeof(Hash) * CHAR_BIT / 4) << Hash;
-    return OS.str();
+std::string makeShaderDumpPrefixWithHash(llvm::StringRef Prefix, HashType Hash) {
+  std::ostringstream OS;
+  OS << Prefix.str() << std::hex << std::setfill('0') << std::setw(sizeof(Hash) * CHAR_BIT / 4) << Hash;
+  return OS.str();
 }
 
-void DoShaderDumpPreFE(const FeShaderDumpData& DumpInfo) {
-    auto Dumps = DumpInfo.getDumps();
-    auto Hash = std::accumulate(Dumps.begin(), Dumps.end(), 0ull,
-        [](const auto& HashVal, const auto& DI) {
-            const auto *BuffStart = DI.Contents.data();
-            auto BuffSize = DI.Contents.size();
-            return HashVal ^ iSTD::HashFromBuffer(BuffStart, BuffSize);
-        });
-    auto DumpNamePrefix = makeShaderDumpPrefixWithHash("VC_fe_", Hash);
-    for (const auto &DumpDescriptor : Dumps)
-      emitFCLDump(DumpNamePrefix, DumpDescriptor);
+void DoShaderDumpPreFE(const FeShaderDumpData &DumpInfo) {
+  auto Dumps = DumpInfo.getDumps();
+  auto Hash = std::accumulate(Dumps.begin(), Dumps.end(), 0ull, [](const auto &HashVal, const auto &DI) {
+    const auto *BuffStart = DI.Contents.data();
+    auto BuffSize = DI.Contents.size();
+    return HashVal ^ iSTD::HashFromBuffer(BuffStart, BuffSize);
+  });
+  auto DumpNamePrefix = makeShaderDumpPrefixWithHash("VC_fe_", Hash);
+  for (const auto &DumpDescriptor : Dumps)
+    emitFCLDump(DumpNamePrefix, DumpDescriptor);
 };
 
-void DoShaderDumpPostFE(const FeShaderDumpData& DumpInfo,
-                               HashType Hash) {
-    auto DumpNamePrefix = makeShaderDumpPrefixWithHash("VC_PostFe_", Hash);
-    for (const auto &DumpDescriptor : DumpInfo.getDumps())
-      emitFCLDump(DumpNamePrefix, DumpDescriptor);
+void DoShaderDumpPostFE(const FeShaderDumpData &DumpInfo, HashType Hash) {
+  auto DumpNamePrefix = makeShaderDumpPrefixWithHash("VC_PostFe_", Hash);
+  for (const auto &DumpDescriptor : DumpInfo.getDumps())
+    emitFCLDump(DumpNamePrefix, DumpDescriptor);
 };
 
-}
+} // namespace
 
 namespace IGC {
 
-OclTranslationOutputBase *
-CIF_GET_INTERFACE_CLASS(FclOclTranslationCtx, 1)::TranslateImpl(
-        CIF::Version_t outVersion,
-        CIF::Builtins::BufferSimple *src,
-        CIF::Builtins::BufferSimple *options,
-        CIF::Builtins::BufferSimple *internalOptions,
-        CIF::Builtins::BufferSimple *tracingOptions,
-        uint32_t tracingOptionsCount) {
-
-    return CIF_GET_PIMPL()->Translate(outVersion, src, options, internalOptions,
-                                      tracingOptions, tracingOptionsCount);
-}
+OclTranslationOutputBase *CIF_GET_INTERFACE_CLASS(FclOclTranslationCtx, 1)::TranslateImpl(
+    CIF::Version_t outVersion, CIF::Builtins::BufferSimple *src, CIF::Builtins::BufferSimple *options,
+    CIF::Builtins::BufferSimple *internalOptions, CIF::Builtins::BufferSimple *tracingOptions,
+    uint32_t tracingOptionsCount) {
 
-void CIF_GET_INTERFACE_CLASS(FclOclTranslationCtx, 2)::GetFclOptions(CIF::Builtins::BufferSimple* opts){
-   CIF_GET_PIMPL()->GetFclOptions(opts);
+  return CIF_GET_PIMPL()->Translate(outVersion, src, options, internalOptions, tracingOptions, tracingOptionsCount);
 }
 
-void CIF_GET_INTERFACE_CLASS(FclOclTranslationCtx, 2)::GetFclInternalOptions(CIF::Builtins::BufferSimple* opts){
-   CIF_GET_PIMPL()->GetFclInternalOptions(opts);
+void CIF_GET_INTERFACE_CLASS(FclOclTranslationCtx, 2)::GetFclOptions(CIF::Builtins::BufferSimple *opts) {
+  CIF_GET_PIMPL()->GetFclOptions(opts);
 }
 
-std::optional<std::vector<char>> readBinaryFile(const std::string& fileName) {
-    std::ifstream file(fileName, std::ios_base::binary);
-    if (!file.good()) {
-        return std::nullopt;
-    }
-    size_t length;
-    file.seekg(0, file.end);
-    length = static_cast<size_t>(file.tellg());
-    file.seekg(0, file.beg);
-    std::vector<char> binary(length);
-    file.read(binary.data(), length);
-    return binary;
+void CIF_GET_INTERFACE_CLASS(FclOclTranslationCtx, 2)::GetFclInternalOptions(CIF::Builtins::BufferSimple *opts) {
+  CIF_GET_PIMPL()->GetFclInternalOptions(opts);
 }
 
+std::optional<std::vector<char>> readBinaryFile(const std::string &fileName) {
+  std::ifstream file(fileName, std::ios_base::binary);
+  if (!file.good()) {
+    return std::nullopt;
+  }
+  size_t length;
+  file.seekg(0, file.end);
+  length = static_cast<size_t>(file.tellg());
+  file.seekg(0, file.beg);
+  std::vector<char> binary(length);
+  file.read(binary.data(), length);
+  return binary;
+}
 
 #if defined(IGC_VC_ENABLED)
 
@@ -241,387 +220,335 @@ using InvocationInfo = IGC::AdaptorCM::Frontend::IDriverInvocation;
 using PathT = llvm::SmallVector<char, 1024>;
 
 using CMStringVect = IGC::AdaptorCM::Frontend::StringVect_t;
-static std::vector<char>
-makeVcOptPayload(uint64_t IR_size, const std::string& VCApiOpts,
-                 const CMStringVect& VCLLVMOptions,
-                 const std::string& TargetFeaturesStr) {
-    std::string InternalVcOptions;
-    if (!VCLLVMOptions.empty()) {
-        InternalVcOptions +=
-            " -llvm-options='" + llvm::join(VCLLVMOptions, " ") + "'";
-    }
-    if (!TargetFeaturesStr.empty()) {
-        InternalVcOptions.append(" -target-features=").append(TargetFeaturesStr);
-    }
-    // Payload format:
-    // |-vc-payload|api opts|internal opts|i64(IR size)|i64(Payload size)|-vc-payload|
-    // NOTE: <api/internal opts> are c-strings.
-    //
-    // Should be in sync with:
-    //      Source/IGC/AdaptorOCL/dllInterfaceCompute.cpp
-    const std::string PayloadMarker = "-vc-payload";
-    std::vector<char> VcPayload;
-    VcPayload.insert(VcPayload.end(), PayloadMarker.begin(), PayloadMarker.end());
-    VcPayload.insert(VcPayload.end(), VCApiOpts.begin(), VCApiOpts.end());
-    VcPayload.push_back(0); // zero-terminate api options
-    VcPayload.insert(VcPayload.end(), InternalVcOptions.begin(), InternalVcOptions.end());
-    VcPayload.push_back(0); // zero-terminate internal options
-    uint64_t payloadSize = VcPayload.size() +
-                            /* as suffix */ PayloadMarker.size() +
-                            /* for sanity-checks */ + sizeof(IR_size) +
-                            /* include the size itself */ + sizeof(uint64_t);
-    VcPayload.insert(VcPayload.end(),
-                     reinterpret_cast<const char*>(&IR_size),
-                     reinterpret_cast<const char*>(&IR_size + 1));
-    VcPayload.insert(VcPayload.end(),
-                     reinterpret_cast<const char*>(&payloadSize),
-                     reinterpret_cast<const char*>(&payloadSize + 1));
-    VcPayload.insert(VcPayload.end(), PayloadMarker.begin(), PayloadMarker.end());
-    return VcPayload;
-}
-
-static void finalizeFEOutput(const IGC::AdaptorCM::Frontend::IOutputArgs& FEOutput,
-                             const std::string& VCApiOptions,
-                             const CMStringVect& VCLLVMOptions,
-                             const std::string& TargetFeatures,
-                             OclTranslationOutputBase& Output,
-                             const std::optional<FeShaderDumpData>& ShaderDumpInfo)
-{
-    auto& OutputInterface = *Output.GetImpl();
-    const auto& ErrLog = FEOutput.getLog();
-    if (FEOutput.getStatus() ==
-        Intel::CM::ClangFE::IOutputArgs::ErrT::COMPILE_PROGRAM_FAILURE)
-    {
-        if (ErrLog.empty())
-            OutputInterface.SetError(
-                TranslationErrorType::Internal,
-                "unknown error during cm source compilation");
-        else
-            OutputInterface.SetError(TranslationErrorType::UnhandledInput,
-                                     ErrLog.c_str());
-        return;
-    }
-
-    if (!ErrLog.empty())
-        OutputInterface.AddWarning(ErrLog);
-
-    const auto& IR = FEOutput.getIR();
-    // This is where the tricky part starts
-    // Right now we have no way to pass auxiliary options to vc-codegen backend
-    // So we introduce a temporary hack to incorporate the options
-    // into the underlying buffer which contains SPIRV IR
-    std::vector<char> Payload = makeVcOptPayload(IR.size(), VCApiOptions,
-                                                 VCLLVMOptions, TargetFeatures);
-
-    std::vector<char> FinalOutput;
-    FinalOutput.reserve(IR.size() + Payload.size());
-    FinalOutput.insert(FinalOutput.end(), IR.begin(), IR.end());
-    FinalOutput.insert(FinalOutput.end(), Payload.begin(), Payload.end());
-
-    if (!OutputInterface.SetSuccessfulAndCloneOutput(FinalOutput.data(),
-                                                     FinalOutput.size()))
-    {
-        OutputInterface.SetError(TranslationErrorType::Internal, "OOM (cm FE)");
-        return;
-    }
-
-    if (ShaderDumpInfo)
-    {
-        auto HashValue = iSTD::HashFromBuffer(FinalOutput.data(),
-                                              FinalOutput.size());
-        DoShaderDumpPostFE(*ShaderDumpInfo, HashValue);
-    }
-}
-
-static std::optional<std::string> MakeTemporaryCMSource(
-    CIF::Builtins::BufferSimple* Src,
-    std::string tmpFilename,
-    OclTranslationOutputBase& outI);
-
-static bool processCmSrcOptions(
-    llvm::SmallVectorImpl<const char*> &userArgs,
-    std::string optname,
-    std::string &inputFile) {
-
-    auto toErase = std::find_if(userArgs.begin(), userArgs.end(),
-        [&optname](const auto& Item) { return std::strcmp(Item, optname.c_str()) == 0; });
-    if (toErase != userArgs.end()) {
-        auto itFilename = toErase + 1;
-        if (itFilename != userArgs.end() && strcmp(*itFilename, "--") != 0) {
-            inputFile = *itFilename;
-            userArgs.erase(toErase, toErase + 2);
-            return true;
-        }
-    }
-
-    optname += "=";
-    toErase = std::find_if(userArgs.begin(), userArgs.end(),
-        [&optname](const auto& Item) {
-          llvm::StringRef S = Item;
-          return S.startswith(optname);
-        });
-    if (toErase != userArgs.end()) {
-        inputFile = *toErase;
-        inputFile = inputFile.substr(optname.length());
-        userArgs.erase(toErase);
-        return true;
-    }
-
-    return false;
+static std::vector<char> makeVcOptPayload(uint64_t IR_size, const std::string &VCApiOpts,
+                                          const CMStringVect &VCLLVMOptions, const std::string &TargetFeaturesStr) {
+  std::string InternalVcOptions;
+  if (!VCLLVMOptions.empty()) {
+    InternalVcOptions += " -llvm-options='" + llvm::join(VCLLVMOptions, " ") + "'";
+  }
+  if (!TargetFeaturesStr.empty()) {
+    InternalVcOptions.append(" -target-features=").append(TargetFeaturesStr);
+  }
+  // Payload format:
+  // |-vc-payload|api opts|internal opts|i64(IR size)|i64(Payload size)|-vc-payload|
+  // NOTE: <api/internal opts> are c-strings.
+  //
+  // Should be in sync with:
+  //      Source/IGC/AdaptorOCL/dllInterfaceCompute.cpp
+  const std::string PayloadMarker = "-vc-payload";
+  std::vector<char> VcPayload;
+  VcPayload.insert(VcPayload.end(), PayloadMarker.begin(), PayloadMarker.end());
+  VcPayload.insert(VcPayload.end(), VCApiOpts.begin(), VCApiOpts.end());
+  VcPayload.push_back(0); // zero-terminate api options
+  VcPayload.insert(VcPayload.end(), InternalVcOptions.begin(), InternalVcOptions.end());
+  VcPayload.push_back(0); // zero-terminate internal options
+  uint64_t payloadSize = VcPayload.size() +
+                         /* as suffix */ PayloadMarker.size() +
+                         /* for sanity-checks */ +sizeof(IR_size) +
+                         /* include the size itself */ +sizeof(uint64_t);
+  VcPayload.insert(VcPayload.end(), reinterpret_cast<const char *>(&IR_size),
+                   reinterpret_cast<const char *>(&IR_size + 1));
+  VcPayload.insert(VcPayload.end(), reinterpret_cast<const char *>(&payloadSize),
+                   reinterpret_cast<const char *>(&payloadSize + 1));
+  VcPayload.insert(VcPayload.end(), PayloadMarker.begin(), PayloadMarker.end());
+  return VcPayload;
 }
 
-static std::vector<const char*>
-    processFeOptions(llvm::sys::DynamicLibrary &LibInfo,
-                     CIF::Builtins::BufferSimple* Src,
-                     OclTranslationOutputBase& outI,
-                     CIF::Builtins::BufferSimple* options,
-                     llvm::StringSaver& stringSaver,
-                     const char *platform,
-                     unsigned stepping,
-                     bool &isMemFile) {
-
-    llvm::SmallVector<const char*, 20> userArgs;
-
-    std::string userArgsStr { options->GetMemory<char>(), options->GetSize<char>() };
-    if (llvm::Triple(llvm::sys::getProcessTriple()).isOSWindows())
-        llvm::cl::TokenizeWindowsCommandLine(userArgsStr, stringSaver, userArgs);
+static void finalizeFEOutput(const IGC::AdaptorCM::Frontend::IOutputArgs &FEOutput, const std::string &VCApiOptions,
+                             const CMStringVect &VCLLVMOptions, const std::string &TargetFeatures,
+                             OclTranslationOutputBase &Output, const std::optional<FeShaderDumpData> &ShaderDumpInfo) {
+  auto &OutputInterface = *Output.GetImpl();
+  const auto &ErrLog = FEOutput.getLog();
+  if (FEOutput.getStatus() == Intel::CM::ClangFE::IOutputArgs::ErrT::COMPILE_PROGRAM_FAILURE) {
+    if (ErrLog.empty())
+      OutputInterface.SetError(TranslationErrorType::Internal, "unknown error during cm source compilation");
     else
-        llvm::cl::TokenizeGNUCommandLine(userArgsStr, stringSaver, userArgs);
-
-    auto toErase = std::remove_if(userArgs.begin(), userArgs.end(),
-        [](const auto& Item) { return std::strcmp(Item, "-cmc") == 0; });
-    userArgs.erase(toErase, userArgs.end());
-
-    // this was old hack before FE can pass platform, now we prefer to use argument
-    // but if it is null, it may be still useful, so let it be for a while
-    auto cmfeDefaultArchOpt = IGCLLVM::makeOptional(llvm::sys::Process::GetEnv("IGC_CMFE_DEFAULT_ARCH"));
-    const std::string& cmfeDefaultArch =
-        cmfeDefaultArchOpt ? cmfeDefaultArchOpt.value() : "";
-
-    std::string inputFile = "src.cm";
-    isMemFile = processCmSrcOptions(userArgs, "-cm-src", inputFile) ||
-                processCmSrcOptions(userArgs, "-s", inputFile);
-    if (!isMemFile) {
-        auto OptSrc = MakeTemporaryCMSource(Src, inputFile, outI);
-        if (!OptSrc)
-            return {};
-        inputFile = OptSrc.value();
-    }
-
-    std::vector<const char *> result = {
-        "-emit-spirv",
-    };
+      OutputInterface.SetError(TranslationErrorType::UnhandledInput, ErrLog.c_str());
+    return;
+  }
+
+  if (!ErrLog.empty())
+    OutputInterface.AddWarning(ErrLog);
+
+  const auto &IR = FEOutput.getIR();
+  // This is where the tricky part starts
+  // Right now we have no way to pass auxiliary options to vc-codegen backend
+  // So we introduce a temporary hack to incorporate the options
+  // into the underlying buffer which contains SPIRV IR
+  std::vector<char> Payload = makeVcOptPayload(IR.size(), VCApiOptions, VCLLVMOptions, TargetFeatures);
+
+  std::vector<char> FinalOutput;
+  FinalOutput.reserve(IR.size() + Payload.size());
+  FinalOutput.insert(FinalOutput.end(), IR.begin(), IR.end());
+  FinalOutput.insert(FinalOutput.end(), Payload.begin(), Payload.end());
+
+  if (!OutputInterface.SetSuccessfulAndCloneOutput(FinalOutput.data(), FinalOutput.size())) {
+    OutputInterface.SetError(TranslationErrorType::Internal, "OOM (cm FE)");
+    return;
+  }
+
+  if (ShaderDumpInfo) {
+    auto HashValue = iSTD::HashFromBuffer(FinalOutput.data(), FinalOutput.size());
+    DoShaderDumpPostFE(*ShaderDumpInfo, HashValue);
+  }
+}
 
-    // Pass the runtime-specified architecture.
-    // User still can override it if -march is passed in user arguments
-    if (platform)
-      result.push_back(stringSaver.save("-march=" + std::string(platform)).data());
-    else
-      result.push_back(stringSaver.save("-march=" + cmfeDefaultArch).data());
+static std::optional<std::string> MakeTemporaryCMSource(CIF::Builtins::BufferSimple *Src, std::string tmpFilename,
+                                                        OclTranslationOutputBase &outI);
 
-    result.push_back(stringSaver.save(inputFile).data());
-    result.insert(result.end(), userArgs.begin(), userArgs.end());
+static bool processCmSrcOptions(llvm::SmallVectorImpl<const char *> &userArgs, std::string optname,
+                                std::string &inputFile) {
 
-    auto ExtraCMOpts = IGCLLVM::makeOptional(llvm::sys::Process::GetEnv("IGC_ExtraCMOptions"));
-    if (ExtraCMOpts) {
-        llvm::SmallVector<const char *, 8> Argv;
-        llvm::cl::TokenizeGNUCommandLine(ExtraCMOpts.value(), stringSaver, Argv);
-        result.insert(result.end(), Argv.begin(), Argv.end());
+  auto toErase = std::find_if(userArgs.begin(), userArgs.end(),
+                              [&optname](const auto &Item) { return std::strcmp(Item, optname.c_str()) == 0; });
+  if (toErase != userArgs.end()) {
+    auto itFilename = toErase + 1;
+    if (itFilename != userArgs.end() && strcmp(*itFilename, "--") != 0) {
+      inputFile = *itFilename;
+      userArgs.erase(toErase, toErase + 2);
+      return true;
     }
+  }
+
+  optname += "=";
+  toErase = std::find_if(userArgs.begin(), userArgs.end(), [&optname](const auto &Item) {
+    llvm::StringRef S = Item;
+    return S.startswith(optname);
+  });
+  if (toErase != userArgs.end()) {
+    inputFile = *toErase;
+    inputFile = inputFile.substr(optname.length());
+    userArgs.erase(toErase);
+    return true;
+  }
+
+  return false;
+}
 
-    return result;
+static std::vector<const char *> processFeOptions(llvm::sys::DynamicLibrary &LibInfo, CIF::Builtins::BufferSimple *Src,
+                                                  OclTranslationOutputBase &outI, CIF::Builtins::BufferSimple *options,
+                                                  llvm::StringSaver &stringSaver, const char *platform,
+                                                  unsigned stepping, bool &isMemFile) {
+
+  llvm::SmallVector<const char *, 20> userArgs;
+
+  std::string userArgsStr{options->GetMemory<char>(), options->GetSize<char>()};
+  if (llvm::Triple(llvm::sys::getProcessTriple()).isOSWindows())
+    llvm::cl::TokenizeWindowsCommandLine(userArgsStr, stringSaver, userArgs);
+  else
+    llvm::cl::TokenizeGNUCommandLine(userArgsStr, stringSaver, userArgs);
+
+  auto toErase =
+      std::remove_if(userArgs.begin(), userArgs.end(), [](const auto &Item) { return std::strcmp(Item, "-cmc") == 0; });
+  userArgs.erase(toErase, userArgs.end());
+
+  // this was old hack before FE can pass platform, now we prefer to use argument
+  // but if it is null, it may be still useful, so let it be for a while
+  auto cmfeDefaultArchOpt = IGCLLVM::makeOptional(llvm::sys::Process::GetEnv("IGC_CMFE_DEFAULT_ARCH"));
+  const std::string &cmfeDefaultArch = cmfeDefaultArchOpt ? cmfeDefaultArchOpt.value() : "";
+
+  std::string inputFile = "src.cm";
+  isMemFile = processCmSrcOptions(userArgs, "-cm-src", inputFile) || processCmSrcOptions(userArgs, "-s", inputFile);
+  if (!isMemFile) {
+    auto OptSrc = MakeTemporaryCMSource(Src, inputFile, outI);
+    if (!OptSrc)
+      return {};
+    inputFile = OptSrc.value();
+  }
+
+  std::vector<const char *> result = {
+      "-emit-spirv",
+  };
+
+  // Pass the runtime-specified architecture.
+  // User still can override it if -march is passed in user arguments
+  if (platform)
+    result.push_back(stringSaver.save("-march=" + std::string(platform)).data());
+  else
+    result.push_back(stringSaver.save("-march=" + cmfeDefaultArch).data());
+
+  result.push_back(stringSaver.save(inputFile).data());
+  result.insert(result.end(), userArgs.begin(), userArgs.end());
+
+  auto ExtraCMOpts = IGCLLVM::makeOptional(llvm::sys::Process::GetEnv("IGC_ExtraCMOptions"));
+  if (ExtraCMOpts) {
+    llvm::SmallVector<const char *, 8> Argv;
+    llvm::cl::TokenizeGNUCommandLine(ExtraCMOpts.value(), stringSaver, Argv);
+    result.insert(result.end(), Argv.begin(), Argv.end());
+  }
+
+  return result;
 }
 
 // TODO: most probably we should remove this function once FrontendWrapper
 // is capable to handle in-memory objects properly
-static std::optional<std::string> MakeTemporaryCMSource(
-    CIF::Builtins::BufferSimple* Src,
-    std::string tmpFilename,
-    OclTranslationOutputBase& outI) {
+static std::optional<std::string> MakeTemporaryCMSource(CIF::Builtins::BufferSimple *Src, std::string tmpFilename,
+                                                        OclTranslationOutputBase &outI) {
 
-    auto& outputInterface = *outI.GetImpl();
+  auto &outputInterface = *outI.GetImpl();
 
-    assert(Src);
+  assert(Src);
 
-    PathT workDir;
-
-    // TODO: resulting temporary file can collide with the existing one
-    auto Err = llvm::sys::fs::getPotentiallyUniqueTempFileName("tmp_cm_to_spv",
-                                                               "", workDir);
-    if (Err) {
-        outputInterface.SetError(TranslationErrorType::Internal,
-                                 "could not determine temporary directory name");
-        return {};
-    }
-    if (llvm::sys::fs::create_directories(workDir)) {
-        outputInterface.SetError(TranslationErrorType::Internal,
-                                 "could not create temporary directory");
-        return {};
-    }
-
-    size_t sizeToDump = Src->GetSize<char>();
-    // TODO: consider removing this legacy code.
-    // It looks like that we are trying to handle some kind of weird user input,
-    // instead of reporting an error.
-    while( (sizeToDump > 0) && (Src->GetMemory<char>()[sizeToDump - 1] == 0)) {
-        --sizeToDump;
-    }
-    if(sizeToDump == 0){
-        outputInterface.SetError(TranslationErrorType::Internal,
-                                 "effective input is zero");
-        return {};
-    }
+  PathT workDir;
 
-    // Dump Src
-    PathT srcPath{ workDir.begin(), workDir.end() };
-    llvm::sys::path::append(srcPath, tmpFilename);
-
-    std::string strPath(srcPath.begin(), srcPath.end());
-    std::ofstream TmpSrc(strPath, std::ios::out);
-    TmpSrc.write(Src->GetMemory<char>(), sizeToDump);
-    TmpSrc.close();
-    if (!TmpSrc) {
-        outputInterface.SetError(TranslationErrorType::Internal,
-                                 "could not create temporary temporary file");
-        return {};
-    }
-    return strPath;
+  // TODO: resulting temporary file can collide with the existing one
+  auto Err = llvm::sys::fs::getPotentiallyUniqueTempFileName("tmp_cm_to_spv", "", workDir);
+  if (Err) {
+    outputInterface.SetError(TranslationErrorType::Internal, "could not determine temporary directory name");
+    return {};
+  }
+  if (llvm::sys::fs::create_directories(workDir)) {
+    outputInterface.SetError(TranslationErrorType::Internal, "could not create temporary directory");
+    return {};
+  }
+
+  size_t sizeToDump = Src->GetSize<char>();
+  // TODO: consider removing this legacy code.
+  // It looks like that we are trying to handle some kind of weird user input,
+  // instead of reporting an error.
+  while ((sizeToDump > 0) && (Src->GetMemory<char>()[sizeToDump - 1] == 0)) {
+    --sizeToDump;
+  }
+  if (sizeToDump == 0) {
+    outputInterface.SetError(TranslationErrorType::Internal, "effective input is zero");
+    return {};
+  }
+
+  // Dump Src
+  PathT srcPath{workDir.begin(), workDir.end()};
+  llvm::sys::path::append(srcPath, tmpFilename);
+
+  std::string strPath(srcPath.begin(), srcPath.end());
+  std::ofstream TmpSrc(strPath, std::ios::out);
+  TmpSrc.write(Src->GetMemory<char>(), sizeToDump);
+  TmpSrc.close();
+  if (!TmpSrc) {
+    outputInterface.SetError(TranslationErrorType::Internal, "could not create temporary temporary file");
+    return {};
+  }
+  return strPath;
 }
 
 // Retrieve directory where FEWrapper is located.
 // Return driver store path on windows and empty path on linux.
 static std::string getCMFEWrapperDir() {
 #if defined(_WIN32)
-    // Expand libname to full driver path on windows.
-    char DriverPath[MAX_PATH] = {};
-    GetDependencyPath(DriverPath, "");
-    return DriverPath;
+  // Expand libname to full driver path on windows.
+  char DriverPath[MAX_PATH] = {};
+  GetDependencyPath(DriverPath, "");
+  return DriverPath;
 #else
-    return "";
+  return "";
 #endif
 }
 
 #endif // defined(IGC_VC_ENABLED)
 
-OclTranslationOutputBase* CIF_PIMPL(FclOclTranslationCtx)::TranslateCM(
-    CIF::Version_t outVersion,
-    CIF::Builtins::BufferSimple* src,
-    CIF::Builtins::BufferSimple* options,
-    CIF::Builtins::BufferSimple* internalOptions,
-    CIF::Builtins::BufferSimple* tracingOptions,
-    uint32_t tracingOptionsCount) {
-
-    // Output
-    auto* outputInterface =
-        CIF::InterfaceCreator<OclTranslationOutput>::CreateInterfaceVer(
-            outVersion, outType);
-    if (outputInterface == nullptr)
-        return nullptr;
-
-    PLATFORM *platformDescr = nullptr;
-    const char *platformStr = nullptr;
-    unsigned stepping       = 0U;
-
-    if(globalState.GetPlatformImpl()){
-      // NEO supports platform interface
-      auto *PlatformImpl = globalState.GetPlatformImpl();
-      platformDescr = &PlatformImpl->p;
-      stepping = PlatformImpl->p.usRevId;
-      platformStr = cmc::getPlatformStr(PlatformImpl->p, /* inout */ stepping);
-    }
+OclTranslationOutputBase *CIF_PIMPL(FclOclTranslationCtx)::TranslateCM(CIF::Version_t outVersion,
+                                                                       CIF::Builtins::BufferSimple *src,
+                                                                       CIF::Builtins::BufferSimple *options,
+                                                                       CIF::Builtins::BufferSimple *internalOptions,
+                                                                       CIF::Builtins::BufferSimple *tracingOptions,
+                                                                       uint32_t tracingOptionsCount) {
+
+  // Output
+  auto *outputInterface = CIF::InterfaceCreator<OclTranslationOutput>::CreateInterfaceVer(outVersion, outType);
+  if (outputInterface == nullptr)
+    return nullptr;
+
+  PLATFORM *platformDescr = nullptr;
+  const char *platformStr = nullptr;
+  unsigned stepping = 0U;
+
+  if (globalState.GetPlatformImpl()) {
+    // NEO supports platform interface
+    auto *PlatformImpl = globalState.GetPlatformImpl();
+    platformDescr = &PlatformImpl->p;
+    stepping = PlatformImpl->p.usRevId;
+    platformStr = cmc::getPlatformStr(PlatformImpl->p, /* inout */ stepping);
+  }
+
+  // we need output shader dumps before reporting fatal error for
+  // unsupported/empty platform
+  auto ShaderDumpData = getShaderDumpData(platformDescr, platformStr ? platformStr : "(empty)", stepping, src, options,
+                                          internalOptions, tracingOptions);
+  if (ShaderDumpData)
+    DoShaderDumpPreFE(*ShaderDumpData);
+
+  if (platformStr == nullptr) {
+    // llvm::report_fatal_error("TranslateCM: unsupported platform");
+    // this is temporary to unblock customers
+    platformStr = "SKL";
+  }
+
+  OclTranslationOutputBase &Out = *outputInterface;
 
-    // we need output shader dumps before reporting fatal error for
-    // unsupported/empty platform
-    auto ShaderDumpData = getShaderDumpData(
-        platformDescr, platformStr ? platformStr : "(empty)", stepping, src,
-        options, internalOptions, tracingOptions);
-    if (ShaderDumpData)
-        DoShaderDumpPreFE(*ShaderDumpData);
-
-    if (platformStr == nullptr) {
-      // llvm::report_fatal_error("TranslateCM: unsupported platform");
-      // this is temporary to unblock customers
-      platformStr = "SKL";
-    }
+#if defined(IGC_VC_ENABLED)
+  auto ErrFn = [&Out](const std::string &Err) { Out.GetImpl()->SetError(TranslationErrorType::Internal, Err.c_str()); };
 
-    OclTranslationOutputBase& Out = *outputInterface;
+  auto MaybeFE = IGC::AdaptorCM::Frontend::makeFEWrapper(ErrFn, getCMFEWrapperDir());
 
-#if defined(IGC_VC_ENABLED)
-    auto ErrFn = [&Out](const std::string& Err) {
-        Out.GetImpl()->SetError(TranslationErrorType::Internal, Err.c_str());
-    };
-
-    auto MaybeFE =
-        IGC::AdaptorCM::Frontend::makeFEWrapper(ErrFn, getCMFEWrapperDir());
-
-    if (!MaybeFE)
-        return outputInterface;
-
-    llvm::BumpPtrAllocator A;
-    llvm::StringSaver Saver(A);
-    auto& FE = MaybeFE.value();
-    bool isMemFile = false;
-    auto FeArgs = processFeOptions(FE.LibInfo(), src, Out,
-                                   options, Saver, platformStr,
-                                   stepping, isMemFile);
-    if (FeArgs.empty())
-        return outputInterface; // proper error message is already set
-
-    auto Drv = FE.buildDriverInvocation(FeArgs.size(), FeArgs.data());
-    if (!Drv)
-    {
-        ErrFn("Null driver invocation in CMFE");
-        return outputInterface;
-    }
-    if (Drv->getOutputType() != InvocationInfo::OutputTypeT::SPIRV)
-    {
-        ErrFn("CM frontend: unsupported output request");
-        return outputInterface;
-    }
+  if (!MaybeFE)
+    return outputInterface;
 
-    IGC::AdaptorCM::Frontend::InputArgs InputArgs;
-    InputArgs.CompilationOpts = Drv->getFEArgs();
-    // if real file is used, then don't fill InputArgs.InputText
-    // with content of source to avoid compilation from
-    // both memory and real temporary files
-    if (isMemFile)
-        InputArgs.InputText = src->GetMemory<char>();
-
-    // CM frontend option parser is not thread-safe, so guard the frontend call
-    // with a mutex.
-    auto FEOutput = [&]() {
-      static std::mutex M;
-      const std::lock_guard<std::mutex> Lock(M);
-      return FE.translate(InputArgs);
-    }();
-
-    if (!FEOutput) {
-      ErrFn("Null output in CMFE");
-      return outputInterface;
-    }
+  llvm::BumpPtrAllocator A;
+  llvm::StringSaver Saver(A);
+  auto &FE = MaybeFE.value();
+  bool isMemFile = false;
+  auto FeArgs = processFeOptions(FE.LibInfo(), src, Out, options, Saver, platformStr, stepping, isMemFile);
+  if (FeArgs.empty())
+    return outputInterface; // proper error message is already set
+
+  auto Drv = FE.buildDriverInvocation(FeArgs.size(), FeArgs.data());
+  if (!Drv) {
+    ErrFn("Null driver invocation in CMFE");
+    return outputInterface;
+  }
+  if (Drv->getOutputType() != InvocationInfo::OutputTypeT::SPIRV) {
+    ErrFn("CM frontend: unsupported output request");
+    return outputInterface;
+  }
+
+  IGC::AdaptorCM::Frontend::InputArgs InputArgs;
+  InputArgs.CompilationOpts = Drv->getFEArgs();
+  // if real file is used, then don't fill InputArgs.InputText
+  // with content of source to avoid compilation from
+  // both memory and real temporary files
+  if (isMemFile)
+    InputArgs.InputText = src->GetMemory<char>();
+
+  // CM frontend option parser is not thread-safe, so guard the frontend call
+  // with a mutex.
+  auto FEOutput = [&]() {
+    static std::mutex M;
+    const std::lock_guard<std::mutex> Lock(M);
+    return FE.translate(InputArgs);
+  }();
+
+  if (!FEOutput) {
+    ErrFn("Null output in CMFE");
+    return outputInterface;
+  }
 
-    const auto& TargetFeatures = Drv->getTargetFeaturesStr();
-    const auto& [VCLLVMOpts, VCFinalizerOpts] =
-        IGC::AdaptorCM::Frontend::convertBackendArgsToVcAndFinalizerOpts(
-            Drv->getBEArgs());
-    auto VCApiOpts = FE.getVCApiOptions(&*Drv);
-    if (!VCFinalizerOpts.empty())
-      VCApiOpts += " -Xfinalizer '" + llvm::join(VCFinalizerOpts, " ") + "'";
+  const auto &TargetFeatures = Drv->getTargetFeaturesStr();
+  const auto &[VCLLVMOpts, VCFinalizerOpts] =
+      IGC::AdaptorCM::Frontend::convertBackendArgsToVcAndFinalizerOpts(Drv->getBEArgs());
+  auto VCApiOpts = FE.getVCApiOptions(&*Drv);
+  if (!VCFinalizerOpts.empty())
+    VCApiOpts += " -Xfinalizer '" + llvm::join(VCFinalizerOpts, " ") + "'";
 
-    finalizeFEOutput(*FEOutput, VCApiOpts, VCLLVMOpts, TargetFeatures, Out,
-                     ShaderDumpData);
+  finalizeFEOutput(*FEOutput, VCApiOpts, VCLLVMOpts, TargetFeatures, Out, ShaderDumpData);
 
-    FclInternalOpts = std::string(" -llvm-options='" + llvm::join(VCLLVMOpts, " ") + "'");
-    FclOpts = VCApiOpts;
+  FclInternalOpts = std::string(" -llvm-options='" + llvm::join(VCLLVMOpts, " ") + "'");
+  FclOpts = VCApiOpts;
 
 #else
-    Out.GetImpl()->SetError(TranslationErrorType::Internal,
-                            "CM compilation is not supported in this configuration");
+  Out.GetImpl()->SetError(TranslationErrorType::Internal, "CM compilation is not supported in this configuration");
 #endif // defined(IGC_VC_ENABLED)
 
-    return outputInterface;
+  return outputInterface;
 }
 
-}
+} // namespace IGC
 
 #include "cif/macros/disable.h"
diff --git a/include/igc/ocl_igc_interface/impl/fcl_ocl_translation_ctx_impl.h b/include/igc/ocl_igc_interface/impl/fcl_ocl_translation_ctx_impl.h
index b77b424..6535c53 100644
--- a/include/igc/ocl_igc_interface/impl/fcl_ocl_translation_ctx_impl.h
+++ b/include/igc/ocl_igc_interface/impl/fcl_ocl_translation_ctx_impl.h
@@ -28,180 +28,174 @@ SPDX-License-Identifier: MIT
 #include "cif/macros/enable.h"
 #include "OCLAPI/oclapi.h"
 
-namespace TC{
-
-}
+namespace TC {}
 
 namespace IGC {
 
-CIF_DECLARE_INTERFACE_PIMPL(FclOclTranslationCtx) : CIF::PimplBase
-{
-    OCL_API_CALL CIF_PIMPL_DECLARE_CONSTRUCTOR(CIF::Version_t version, CIF_PIMPL(FclOclDeviceCtx) *globalState,
-                                  CodeType::CodeType_t inType, CodeType::CodeType_t outType)
-        : globalState(CIF::Sanity::ToReferenceOrAbort(globalState)), inType(inType), outType(outType){
-        this->legacyInterface = CreateLegacyInterface(inType, outType, err);
-        CIF::Sanity::NotNullOrAbort(this->legacyInterface);
-        this->legacyInterface->SetOclApiVersion(globalState->MiscOptions.OclApiVersion);
-    }
-
-    OCL_API_CALL CIF_PIMPL_DECLARE_CONSTRUCTOR(CIF::Version_t version, CIF_PIMPL(FclOclDeviceCtx)* globalState,
-                                  CodeType::CodeType_t inType, CodeType::CodeType_t outType, CIF::Builtins::BufferSimple* err)
-        : globalState(CIF::Sanity::ToReferenceOrAbort(globalState)), inType(inType), outType(outType), err(err) {
-        this->legacyInterface = CreateLegacyInterface(inType, outType, err);
-        if (this->legacyInterface)
-        {
-            this->legacyInterface->SetOclApiVersion(globalState->MiscOptions.OclApiVersion);
-        }
-    }
-
-    OCL_API_CALL CIF_PIMPL_DECLARE_DESTRUCTOR() override{
-        if(this->legacyInterface != nullptr){
-            TC::CClangTranslationBlock::Delete(this->legacyInterface);
-            this->legacyInterface = nullptr;
-        }
-    }
-
-    OCL_API_CALL static bool SupportsTranslation(CodeType::CodeType_t inType, CodeType::CodeType_t outType){
-        static std::pair<CodeType::CodeType_t, CodeType::CodeType_t> supportedTranslations[] =
-            {
-                  // from                 // to
-                { CodeType::elf,     CodeType::llvmBc },
-                { CodeType::elf,     CodeType::llvmLl },
-                { CodeType::elf,     CodeType::spirV  },
-                { CodeType::oclC,    CodeType::llvmBc },
-                { CodeType::oclC,    CodeType::llvmLl },
-                { CodeType::oclC,    CodeType::spirV },
-            };
-        for(const auto & st : supportedTranslations){
-            if((inType == st.first) && (outType == st.second)){
-                return true;
-            }
-        }
-        return false;
-    }
-
-    OCL_API_CALL OclTranslationOutputBase* TranslateCM(CIF::Version_t outVersion,
-                                        CIF::Builtins::BufferSimple* src,
-                                        CIF::Builtins::BufferSimple* options,
-                                        CIF::Builtins::BufferSimple* internalOptions,
-                                        CIF::Builtins::BufferSimple* tracingOptions,
-                                        uint32_t tracingOptionsCount
-                                        );
-    OCL_API_CALL OclTranslationOutputBase *Translate(CIF::Version_t outVersion,
-                                        CIF::Builtins::BufferSimple *src,
-                                        CIF::Builtins::BufferSimple *options,
-                                        CIF::Builtins::BufferSimple *internalOptions,
-                                        CIF::Builtins::BufferSimple *tracingOptions,
-                                        uint32_t tracingOptionsCount
-                                        ) {
-        if ((options != nullptr) && (options->GetSizeRaw() > 0) && (strstr(options->GetMemory<char>(), "-cmc"))) {
-            assert(this->outType == CodeType::spirV);
-            return TranslateCM(outVersion, src, options, internalOptions, tracingOptions, tracingOptionsCount);
-        }
-        // Create a copy of input arguments that can be modified
-        TC::STB_TranslateInputArgs inputArgs;
-        if(src != nullptr){
-            inputArgs.pInput = src->GetMemoryWriteable<char>();
-            inputArgs.InputSize = static_cast<uint32_t>(src->GetSizeRaw());
-        }
-        if(options != nullptr){
-            inputArgs.pOptions =  options->GetMemory<char>();
-            inputArgs.OptionsSize = static_cast<uint32_t>(options->GetSizeRaw());
-        }
-        if(internalOptions != nullptr){
-            inputArgs.pInternalOptions =  internalOptions->GetMemory<char>();
-            inputArgs.InternalOptionsSize = static_cast<uint32_t>(internalOptions->GetSizeRaw());
-        }
-        if(tracingOptions != nullptr){
-            inputArgs.pTracingOptions = tracingOptions->GetMemoryRawWriteable();
-        }
-        inputArgs.TracingOptionsCount = tracingOptionsCount;
-
-        TC::STB_TranslateOutputArgs outputArgs;
-        bool success = legacyInterface->Translate(&inputArgs, &outputArgs);
-
-        auto outputInterface = CIF::RAII::UPtr(CIF::InterfaceCreator<OclTranslationOutput>::CreateInterfaceVer(outVersion, outType));
-        if(outputInterface == nullptr){
-            // OOM or unsupported
-            return nullptr;
-        }
-
-        bool dataCopiedSuccessfuly = true;
-        if(success){
-            dataCopiedSuccessfuly &= outputInterface->GetImpl()->AddWarning(outputArgs.pErrorString, outputArgs.ErrorStringSize);
-            dataCopiedSuccessfuly &= outputInterface->GetImpl()->CloneDebugData(outputArgs.pDebugData, outputArgs.DebugDataSize);
-            dataCopiedSuccessfuly &= outputInterface->GetImpl()->SetSuccessfulAndCloneOutput(outputArgs.pOutput, outputArgs.OutputSize);
-        }else{
-            dataCopiedSuccessfuly &= outputInterface->GetImpl()->SetError(TranslationErrorType::FailedCompilation, outputArgs.pErrorString);
-        }
-
-        if(dataCopiedSuccessfuly == false){
-            legacyInterface->FreeAllocations(&outputArgs);
-            return nullptr; // OOM
-        }
-
-        legacyInterface->FreeAllocations(&outputArgs);
-
-        return outputInterface.release();
+CIF_DECLARE_INTERFACE_PIMPL(FclOclTranslationCtx) : CIF::PimplBase {
+  OCL_API_CALL CIF_PIMPL_DECLARE_CONSTRUCTOR(CIF::Version_t version, CIF_PIMPL(FclOclDeviceCtx) * globalState,
+                                             CodeType::CodeType_t inType, CodeType::CodeType_t outType)
+      : globalState(CIF::Sanity::ToReferenceOrAbort(globalState)), inType(inType), outType(outType) {
+    this->legacyInterface = CreateLegacyInterface(inType, outType, err);
+    CIF::Sanity::NotNullOrAbort(this->legacyInterface);
+    this->legacyInterface->SetOclApiVersion(globalState->MiscOptions.OclApiVersion);
+  }
+
+  OCL_API_CALL CIF_PIMPL_DECLARE_CONSTRUCTOR(CIF::Version_t version, CIF_PIMPL(FclOclDeviceCtx) * globalState,
+                                             CodeType::CodeType_t inType, CodeType::CodeType_t outType,
+                                             CIF::Builtins::BufferSimple * err)
+      : globalState(CIF::Sanity::ToReferenceOrAbort(globalState)), inType(inType), outType(outType), err(err) {
+    this->legacyInterface = CreateLegacyInterface(inType, outType, err);
+    if (this->legacyInterface) {
+      this->legacyInterface->SetOclApiVersion(globalState->MiscOptions.OclApiVersion);
     }
+  }
+
+  OCL_API_CALL CIF_PIMPL_DECLARE_DESTRUCTOR() override {
+    if (this->legacyInterface != nullptr) {
+      TC::CClangTranslationBlock::Delete(this->legacyInterface);
+      this->legacyInterface = nullptr;
+    }
+  }
+
+  OCL_API_CALL static bool SupportsTranslation(CodeType::CodeType_t inType, CodeType::CodeType_t outType) {
+    static std::pair<CodeType::CodeType_t, CodeType::CodeType_t> supportedTranslations[] = {
+        // from                 // to
+        {CodeType::elf, CodeType::llvmBc},  {CodeType::elf, CodeType::llvmLl},  {CodeType::elf, CodeType::spirV},
+        {CodeType::oclC, CodeType::llvmBc}, {CodeType::oclC, CodeType::llvmLl}, {CodeType::oclC, CodeType::spirV},
+    };
+    for (const auto &st : supportedTranslations) {
+      if ((inType == st.first) && (outType == st.second)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  OCL_API_CALL OclTranslationOutputBase *TranslateCM(
+      CIF::Version_t outVersion, CIF::Builtins::BufferSimple * src, CIF::Builtins::BufferSimple * options,
+      CIF::Builtins::BufferSimple * internalOptions, CIF::Builtins::BufferSimple * tracingOptions,
+      uint32_t tracingOptionsCount);
+  OCL_API_CALL OclTranslationOutputBase *Translate(
+      CIF::Version_t outVersion, CIF::Builtins::BufferSimple * src, CIF::Builtins::BufferSimple * options,
+      CIF::Builtins::BufferSimple * internalOptions, CIF::Builtins::BufferSimple * tracingOptions,
+      uint32_t tracingOptionsCount) {
+    if ((options != nullptr) && (options->GetSizeRaw() > 0) && (strstr(options->GetMemory<char>(), "-cmc"))) {
+      assert(this->outType == CodeType::spirV);
+      return TranslateCM(outVersion, src, options, internalOptions, tracingOptions, tracingOptionsCount);
+    }
+    // Create a copy of input arguments that can be modified
+    TC::STB_TranslateInputArgs inputArgs;
+    if (src != nullptr) {
+      inputArgs.pInput = src->GetMemoryWriteable<char>();
+      inputArgs.InputSize = static_cast<uint32_t>(src->GetSizeRaw());
+    }
+    if (options != nullptr) {
+      inputArgs.pOptions = options->GetMemory<char>();
+      inputArgs.OptionsSize = static_cast<uint32_t>(options->GetSizeRaw());
+    }
+    if (internalOptions != nullptr) {
+      inputArgs.pInternalOptions = internalOptions->GetMemory<char>();
+      inputArgs.InternalOptionsSize = static_cast<uint32_t>(internalOptions->GetSizeRaw());
+    }
+    if (tracingOptions != nullptr) {
+      inputArgs.pTracingOptions = tracingOptions->GetMemoryRawWriteable();
+    }
+    inputArgs.TracingOptionsCount = tracingOptionsCount;
+
+    TC::STB_TranslateOutputArgs outputArgs;
+    bool success = legacyInterface->Translate(&inputArgs, &outputArgs);
+
+    auto outputInterface =
+        CIF::RAII::UPtr(CIF::InterfaceCreator<OclTranslationOutput>::CreateInterfaceVer(outVersion, outType));
+    if (outputInterface == nullptr) {
+      // OOM or unsupported
+      return nullptr;
+    }
+
+    bool dataCopiedSuccessfuly = true;
+    if (success) {
+      dataCopiedSuccessfuly &=
+          outputInterface->GetImpl()->AddWarning(outputArgs.pErrorString, outputArgs.ErrorStringSize);
+      dataCopiedSuccessfuly &=
+          outputInterface->GetImpl()->CloneDebugData(outputArgs.pDebugData, outputArgs.DebugDataSize);
+      dataCopiedSuccessfuly &=
+          outputInterface->GetImpl()->SetSuccessfulAndCloneOutput(outputArgs.pOutput, outputArgs.OutputSize);
+    } else {
+      dataCopiedSuccessfuly &=
+          outputInterface->GetImpl()->SetError(TranslationErrorType::FailedCompilation, outputArgs.pErrorString);
+    }
+
+    if (dataCopiedSuccessfuly == false) {
+      legacyInterface->FreeAllocations(&outputArgs);
+      return nullptr; // OOM
+    }
+
+    legacyInterface->FreeAllocations(&outputArgs);
+
+    return outputInterface.release();
+  }
 
 protected:
-    std::string FclOpts{};
-    std::string FclInternalOpts{};
+  std::string FclOpts{};
+  std::string FclInternalOpts{};
+
 public:
-    OCL_API_CALL void GetFclOptions(CIF::Builtins::BufferSimple *opts){
-      assert(opts && opts->GetSizeRaw() == 0 && "GetFclOptions expects empty buffer");
-      opts->Resize(FclOpts.size() + 1);
-      strncpy((char*)opts->GetMemoryRawWriteable(), FclOpts.c_str(), FclOpts.size() + 1);
+  OCL_API_CALL void GetFclOptions(CIF::Builtins::BufferSimple * opts) {
+    assert(opts && opts->GetSizeRaw() == 0 && "GetFclOptions expects empty buffer");
+    opts->Resize(FclOpts.size() + 1);
+    strncpy((char *)opts->GetMemoryRawWriteable(), FclOpts.c_str(), FclOpts.size() + 1);
+  }
+  OCL_API_CALL void GetFclInternalOptions(CIF::Builtins::BufferSimple * opts) {
+    assert(opts && opts->GetSizeRaw() == 0 && "GetFclInternalOptions expects empty buffer");
+    opts->Resize(FclInternalOpts.size() + 1);
+    strncpy((char *)opts->GetMemoryRawWriteable(), FclInternalOpts.c_str(), FclInternalOpts.size() + 1);
+  }
+
+protected:
+  OCL_API_CALL static TC::CClangTranslationBlock *CreateLegacyInterface(
+      CodeType::CodeType_t inType, CodeType::CodeType_t outType, CIF::Builtins::BufferSimple * err) {
+    if (SupportsTranslation(inType, outType) == false) {
+      return nullptr;
+    }
+
+    TC::STB_CreateArgs createArgs;
+    createArgs.TranslationCode.Type.Input = TC::TB_DATA_FORMAT_OCL_TEXT;
+    if (inType == CodeType::elf) {
+      createArgs.TranslationCode.Type.Input = TC::TB_DATA_FORMAT_ELF;
     }
-    OCL_API_CALL void GetFclInternalOptions(CIF::Builtins::BufferSimple *opts) {
-      assert(opts && opts->GetSizeRaw() == 0 && "GetFclInternalOptions expects empty buffer");
-      opts->Resize(FclInternalOpts.size() + 1);
-      strncpy((char*)opts->GetMemoryRawWriteable(), FclInternalOpts.c_str(), FclInternalOpts.size() + 1);
+    createArgs.TranslationCode.Type.Output = TC::TB_DATA_FORMAT_LLVM_BINARY;
+    if (outType == CodeType::llvmLl) {
+      createArgs.TranslationCode.Type.Output = TC::TB_DATA_FORMAT_LLVM_TEXT;
+    } else if (outType == CodeType::spirV) {
+      createArgs.TranslationCode.Type.Output = TC::TB_DATA_FORMAT_SPIR_V;
     }
-protected:
-    OCL_API_CALL static TC::CClangTranslationBlock* CreateLegacyInterface(CodeType::CodeType_t inType, CodeType::CodeType_t outType, CIF::Builtins::BufferSimple* err) {
-        if (SupportsTranslation(inType, outType) == false) {
-            return nullptr;
-        }
-
-        TC::STB_CreateArgs createArgs;
-        createArgs.TranslationCode.Type.Input = TC::TB_DATA_FORMAT_OCL_TEXT;
-        if (inType == CodeType::elf) {
-            createArgs.TranslationCode.Type.Input = TC::TB_DATA_FORMAT_ELF;
-        }
-        createArgs.TranslationCode.Type.Output = TC::TB_DATA_FORMAT_LLVM_BINARY;
-        if (outType == CodeType::llvmLl) {
-            createArgs.TranslationCode.Type.Output = TC::TB_DATA_FORMAT_LLVM_TEXT;
-        }else if (outType == CodeType::spirV) {
-            createArgs.TranslationCode.Type.Output = TC::TB_DATA_FORMAT_SPIR_V;
-        }
-
-        TC::CClangTranslationBlock* legacyInterface = nullptr;
-        TC::STB_TranslateOutputArgs outputArgs;
-        bool success;
-        success = TC::CClangTranslationBlock::Create(&createArgs,&outputArgs, legacyInterface);
-        if (!success && err != nullptr) {
-            const char* pErrorMsg = outputArgs.pErrorString;
-            uint32_t pErrorMsgSize = outputArgs.ErrorStringSize;
-            err->PushBackRawBytes(pErrorMsg, pErrorMsgSize);
-        }
-        if (legacyInterface == nullptr) {
-            return nullptr;
-        }
-
-        return legacyInterface;
-    }
-
-    CIF_PIMPL(FclOclDeviceCtx) &globalState;
-    CodeType::CodeType_t inType = CodeType::undefined;
-    CodeType::CodeType_t outType = CodeType::undefined;
-    CIF::Builtins::BufferSimple* err = nullptr;
+
     TC::CClangTranslationBlock *legacyInterface = nullptr;
+    TC::STB_TranslateOutputArgs outputArgs;
+    bool success;
+    success = TC::CClangTranslationBlock::Create(&createArgs, &outputArgs, legacyInterface);
+    if (!success && err != nullptr) {
+      const char *pErrorMsg = outputArgs.pErrorString;
+      uint32_t pErrorMsgSize = outputArgs.ErrorStringSize;
+      err->PushBackRawBytes(pErrorMsg, pErrorMsgSize);
+    }
+    if (legacyInterface == nullptr) {
+      return nullptr;
+    }
+
+    return legacyInterface;
+  }
+
+  CIF_PIMPL(FclOclDeviceCtx) & globalState;
+  CodeType::CodeType_t inType = CodeType::undefined;
+  CodeType::CodeType_t outType = CodeType::undefined;
+  CIF::Builtins::BufferSimple *err = nullptr;
+  TC::CClangTranslationBlock *legacyInterface = nullptr;
 };
 
 CIF_DEFINE_INTERFACE_TO_PIMPL_FORWARDING_CTOR_DTOR(FclOclTranslationCtx);
 
-}
+} // namespace IGC
 
 #include "cif/macros/disable.h"
diff --git a/include/igc/ocl_igc_interface/impl/gt_system_info_impl.cpp b/include/igc/ocl_igc_interface/impl/gt_system_info_impl.cpp
index 50880d1..15d7355 100644
--- a/include/igc/ocl_igc_interface/impl/gt_system_info_impl.cpp
+++ b/include/igc/ocl_igc_interface/impl/gt_system_info_impl.cpp
@@ -11,17 +11,13 @@ SPDX-License-Identifier: MIT
 
 #include "cif/macros/enable.h"
 
-namespace IGC{
+namespace IGC {
 // Helpers for clarity
 // Basically, these forward GetX/SetX from interface (of given version)
 // to GT_SYSTEM_INFO inside pImpl
-#define DEFINE_GET_SET(INTERFACE, VERSION, NAME, TYPE)\
-    TYPE CIF_GET_INTERFACE_CLASS(INTERFACE, VERSION)::Get##NAME() const {\
-        return CIF_GET_PIMPL()->gsi.NAME;\
-    }\
-    void CIF_GET_INTERFACE_CLASS(INTERFACE, VERSION)::Set##NAME(TYPE v) {\
-        CIF_GET_PIMPL()->gsi.NAME = v;\
-    }
+#define DEFINE_GET_SET(INTERFACE, VERSION, NAME, TYPE)                                                                 \
+  TYPE CIF_GET_INTERFACE_CLASS(INTERFACE, VERSION)::Get##NAME() const { return CIF_GET_PIMPL()->gsi.NAME; }            \
+  void CIF_GET_INTERFACE_CLASS(INTERFACE, VERSION)::Set##NAME(TYPE v) { CIF_GET_PIMPL()->gsi.NAME = v; }
 
 DEFINE_GET_SET(GTSystemInfo, 1, EUCount, uint32_t);
 DEFINE_GET_SET(GTSystemInfo, 1, ThreadCount, uint32_t);
@@ -51,6 +47,6 @@ DEFINE_GET_SET(GTSystemInfo, 3, DualSubSliceCount, uint32_t);
 
 DEFINE_GET_SET(GTSystemInfo, 4, SLMSizeInKb, uint32_t);
 
-}
+} // namespace IGC
 
 #include "cif/macros/disable.h"
diff --git a/include/igc/ocl_igc_interface/impl/gt_system_info_impl.h b/include/igc/ocl_igc_interface/impl/gt_system_info_impl.h
index 99dacc1..63b0708 100644
--- a/include/igc/ocl_igc_interface/impl/gt_system_info_impl.h
+++ b/include/igc/ocl_igc_interface/impl/gt_system_info_impl.h
@@ -21,15 +21,13 @@ SPDX-License-Identifier: MIT
 namespace IGC {
 
 CIF_DECLARE_INTERFACE_PIMPL(GTSystemInfo) : CIF::PimplBase {
-  OCL_API_CALL CIF_PIMPL_DECLARE_CONSTRUCTOR() {
-      CIF::SafeZeroOut(gsi);
-  }
+  OCL_API_CALL CIF_PIMPL_DECLARE_CONSTRUCTOR() { CIF::SafeZeroOut(gsi); }
 
   GT_SYSTEM_INFO gsi;
 };
 
 CIF_DEFINE_INTERFACE_TO_PIMPL_FORWARDING_CTOR_DTOR(GTSystemInfo);
 
-}
+} // namespace IGC
 
 #include "cif/macros/disable.h"
diff --git a/include/igc/ocl_igc_interface/impl/igc_builtins_impl.cpp b/include/igc/ocl_igc_interface/impl/igc_builtins_impl.cpp
index d9c1931..f1481bd 100644
--- a/include/igc/ocl_igc_interface/impl/igc_builtins_impl.cpp
+++ b/include/igc/ocl_igc_interface/impl/igc_builtins_impl.cpp
@@ -14,132 +14,104 @@ SPDX-License-Identifier: MIT
 
 namespace IGC {
 
-static long getDataTypeSize(CIF_GET_INTERFACE_CLASS(IgcBuiltins, 1)::BuiltinDataType::DataType_t t)
-{
-    switch(t)
-    {
-    case CIF_GET_INTERFACE_CLASS(IgcBuiltins, 1)::BuiltinDataType::uint8_type:
-    case CIF_GET_INTERFACE_CLASS(IgcBuiltins, 1)::BuiltinDataType::int8_type:
-        return 8;
-    case CIF_GET_INTERFACE_CLASS(IgcBuiltins, 1)::BuiltinDataType::uint16_type:
-    case CIF_GET_INTERFACE_CLASS(IgcBuiltins, 1)::BuiltinDataType::int16_type:
-    case CIF_GET_INTERFACE_CLASS(IgcBuiltins, 1)::BuiltinDataType::half_type:
-        return 16;
-    case CIF_GET_INTERFACE_CLASS(IgcBuiltins, 1)::BuiltinDataType::uint32_type:
-    case CIF_GET_INTERFACE_CLASS(IgcBuiltins, 1)::BuiltinDataType::int32_type:
-    case CIF_GET_INTERFACE_CLASS(IgcBuiltins, 1)::BuiltinDataType::float_type:
-        return 32;
-    case CIF_GET_INTERFACE_CLASS(IgcBuiltins, 1)::BuiltinDataType::uint64_type:
-    case CIF_GET_INTERFACE_CLASS(IgcBuiltins, 1)::BuiltinDataType::int64_type:
-    case CIF_GET_INTERFACE_CLASS(IgcBuiltins, 1)::BuiltinDataType::double_type:
-        return 64;
-    default:
-        return 0;
-    }
+static long getDataTypeSize(CIF_GET_INTERFACE_CLASS(IgcBuiltins, 1)::BuiltinDataType::DataType_t t) {
+  switch (t) {
+  case CIF_GET_INTERFACE_CLASS(IgcBuiltins, 1)::BuiltinDataType::uint8_type:
+  case CIF_GET_INTERFACE_CLASS(IgcBuiltins, 1)::BuiltinDataType::int8_type:
+    return 8;
+  case CIF_GET_INTERFACE_CLASS(IgcBuiltins, 1)::BuiltinDataType::uint16_type:
+  case CIF_GET_INTERFACE_CLASS(IgcBuiltins, 1)::BuiltinDataType::int16_type:
+  case CIF_GET_INTERFACE_CLASS(IgcBuiltins, 1)::BuiltinDataType::half_type:
+    return 16;
+  case CIF_GET_INTERFACE_CLASS(IgcBuiltins, 1)::BuiltinDataType::uint32_type:
+  case CIF_GET_INTERFACE_CLASS(IgcBuiltins, 1)::BuiltinDataType::int32_type:
+  case CIF_GET_INTERFACE_CLASS(IgcBuiltins, 1)::BuiltinDataType::float_type:
+    return 32;
+  case CIF_GET_INTERFACE_CLASS(IgcBuiltins, 1)::BuiltinDataType::uint64_type:
+  case CIF_GET_INTERFACE_CLASS(IgcBuiltins, 1)::BuiltinDataType::int64_type:
+  case CIF_GET_INTERFACE_CLASS(IgcBuiltins, 1)::BuiltinDataType::double_type:
+    return 64;
+  default:
+    return 0;
+  }
 }
 
-bool CIF_GET_INTERFACE_CLASS(IgcBuiltins, 1)::GetBuiltinMemoryRequired(IGCBuiltinMemoryInfo *memoryInfo,
-                                                                       BuiltinAlgorithm::Algorithm_t algorithm,
-                                                                       AlgorithmVariant_t variant,
-                                                                       BuiltinMemoryScope::MemoryScope_t scope,
-                                                                       long items,
-                                                                       long rangeSize,
-                                                                       BuiltinDataType::DataType_t keyType,
-                                                                       long valueTypeSizeInBytes) const
-{
-    memoryInfo->scope = scope;
-    memoryInfo->globalMemoryInBytes = -1;
-    memoryInfo->sharedMemoryInBytes = -1;
-    memoryInfo->canMemoryBeUsedConcurrently = false;
-
-    long keyTypeSizeInBytes = getDataTypeSize(keyType);
-    if (keyTypeSizeInBytes == 0)
+bool CIF_GET_INTERFACE_CLASS(IgcBuiltins, 1)::GetBuiltinMemoryRequired(
+    IGCBuiltinMemoryInfo *memoryInfo, BuiltinAlgorithm::Algorithm_t algorithm, AlgorithmVariant_t variant,
+    BuiltinMemoryScope::MemoryScope_t scope, long items, long rangeSize, BuiltinDataType::DataType_t keyType,
+    long valueTypeSizeInBytes) const {
+  memoryInfo->scope = scope;
+  memoryInfo->globalMemoryInBytes = -1;
+  memoryInfo->sharedMemoryInBytes = -1;
+  memoryInfo->canMemoryBeUsedConcurrently = false;
+
+  long keyTypeSizeInBytes = getDataTypeSize(keyType);
+  if (keyTypeSizeInBytes == 0)
+    return false;
+
+  switch (algorithm) {
+  case BuiltinAlgorithm::sort:
+  case BuiltinAlgorithm::clusteredSort:
+  case BuiltinAlgorithm::clusteredSortedOrdinal: {
+    const size_t bits_per_pass = 4;
+
+    if ((algorithm == BuiltinAlgorithm::clusteredSort || algorithm == BuiltinAlgorithm::clusteredSortedOrdinal) &&
+        (scope != BuiltinMemoryScope::subGroup)) {
+      return false;
+    }
+
+    if (scope == BuiltinMemoryScope::subGroup) {
+      if ((variant != SortAlgorithmVariant::defaultPrivateSort) || (items > 1) ||
+          ((rangeSize != 8) && (rangeSize != 16) && (rangeSize != 32)) || valueTypeSizeInBytes != 0) {
+        return false;
+      }
+      if (keyType == BuiltinDataType::half_type) {
         return false;
+      }
 
-    switch(algorithm)
+      memoryInfo->globalMemoryInBytes = 0;
+      memoryInfo->sharedMemoryInBytes = 0;
+      return true;
+    } else // WorkGroup Sort
     {
-    case BuiltinAlgorithm::sort:
-    case BuiltinAlgorithm::clusteredSort:
-    case BuiltinAlgorithm::clusteredSortedOrdinal:
-    {
-        const size_t bits_per_pass = 4;
-
-        if ((algorithm == BuiltinAlgorithm::clusteredSort || algorithm == BuiltinAlgorithm::clusteredSortedOrdinal) &&
-            (scope != BuiltinMemoryScope::subGroup))
-        {
-            return false;
-        }
-
-        if (scope == BuiltinMemoryScope::subGroup)
-        {
-            if ((variant != SortAlgorithmVariant::defaultPrivateSort) || (items > 1) ||
-                    ((rangeSize != 8) && (rangeSize != 16) && (rangeSize != 32)) ||
-                    valueTypeSizeInBytes != 0)
-            {
-                return false;
-            }
-            if (keyType == BuiltinDataType::half_type)
-            {
-                return false;
-            }
-
-            memoryInfo->globalMemoryInBytes = 0;
-            memoryInfo->sharedMemoryInBytes = 0;
-            return true;
-        }
-        else  // WorkGroup Sort
-        {
-            memoryInfo->sharedMemoryInBytes = 0;
-
-            long totalItems = 0;
-            long itemsPerWorkItem = 0;
-            long mergeSortMemory = 0;
-
-            long dataPairSizeInBytes = keyTypeSizeInBytes + valueTypeSizeInBytes;
-
-            if (variant == SortAlgorithmVariant::defaultJointSort)
-            {
-                totalItems = items;
-                itemsPerWorkItem = (totalItems - 1) / rangeSize + 1;
-
-                mergeSortMemory =
-                    totalItems * dataPairSizeInBytes +
-                    sizeof(uint32_t) +
-                    (valueTypeSizeInBytes > 0 ? sizeof(uint32_t) : 0);
-            }
-            else
-            {
-                totalItems = items * rangeSize;
-                itemsPerWorkItem = items;
-
-                mergeSortMemory =
-                    2 * totalItems * dataPairSizeInBytes
-                    + (valueTypeSizeInBytes > 0 ? 4 : 1) * sizeof(uint32_t);
-            }
-
-            long radixSortMemory =
-                totalItems * dataPairSizeInBytes +
-                rangeSize * (1 << bits_per_pass) * sizeof(uint32_t) +
-                sizeof(uint32_t) +
-                (valueTypeSizeInBytes > 0 ? sizeof(uint32_t) : 0);
-
-            bool isRadix = (itemsPerWorkItem > 8 &&
-                itemsPerWorkItem >= keyTypeSizeInBytes * 8);
-
-            memoryInfo->globalMemoryInBytes = isRadix ? radixSortMemory : mergeSortMemory;
-            return true;
-        };
-        break;
-    }
-    default:
-        break;
-    }
+      memoryInfo->sharedMemoryInBytes = 0;
 
-    return false;
-}
+      long totalItems = 0;
+      long itemsPerWorkItem = 0;
+      long mergeSortMemory = 0;
+
+      long dataPairSizeInBytes = keyTypeSizeInBytes + valueTypeSizeInBytes;
+
+      if (variant == SortAlgorithmVariant::defaultJointSort) {
+        totalItems = items;
+        itemsPerWorkItem = (totalItems - 1) / rangeSize + 1;
 
+        mergeSortMemory =
+            totalItems * dataPairSizeInBytes + sizeof(uint32_t) + (valueTypeSizeInBytes > 0 ? sizeof(uint32_t) : 0);
+      } else {
+        totalItems = items * rangeSize;
+        itemsPerWorkItem = items;
 
+        mergeSortMemory = 2 * totalItems * dataPairSizeInBytes + (valueTypeSizeInBytes > 0 ? 4 : 1) * sizeof(uint32_t);
+      }
 
+      long radixSortMemory = totalItems * dataPairSizeInBytes + rangeSize * (1 << bits_per_pass) * sizeof(uint32_t) +
+                             sizeof(uint32_t) + (valueTypeSizeInBytes > 0 ? sizeof(uint32_t) : 0);
+
+      bool isRadix = (itemsPerWorkItem > 8 && itemsPerWorkItem >= keyTypeSizeInBytes * 8);
+
+      memoryInfo->globalMemoryInBytes = isRadix ? radixSortMemory : mergeSortMemory;
+      return true;
+    };
+    break;
+  }
+  default:
+    break;
+  }
+
+  return false;
 }
 
+} // namespace IGC
+
 #include "cif/macros/disable.h"
diff --git a/include/igc/ocl_igc_interface/impl/igc_builtins_impl.h b/include/igc/ocl_igc_interface/impl/igc_builtins_impl.h
index cf9365d..8a63d8d 100644
--- a/include/igc/ocl_igc_interface/impl/igc_builtins_impl.h
+++ b/include/igc/ocl_igc_interface/impl/igc_builtins_impl.h
@@ -16,16 +16,15 @@ SPDX-License-Identifier: MIT
 
 namespace IGC {
 
-CIF_DECLARE_INTERFACE_PIMPL(IgcBuiltins) : CIF::PimplBase {
+CIF_DECLARE_INTERFACE_PIMPL(IgcBuiltins)
+    : CIF::PimplBase{
 
-  OCL_API_CALL CIF_PIMPL_DECLARE_CONSTRUCTOR()
-  {
-  }
+          OCL_API_CALL CIF_PIMPL_DECLARE_CONSTRUCTOR(){}
 
-};
+      };
 
 CIF_DEFINE_INTERFACE_TO_PIMPL_FORWARDING_CTOR_DTOR(IgcBuiltins);
 
-}
+} // namespace IGC
 
 #include "cif/macros/disable.h"
diff --git a/include/igc/ocl_igc_interface/impl/igc_features_and_workarounds_impl.cpp b/include/igc/ocl_igc_interface/impl/igc_features_and_workarounds_impl.cpp
index c1d60bc..70c7e8d 100644
--- a/include/igc/ocl_igc_interface/impl/igc_features_and_workarounds_impl.cpp
+++ b/include/igc/ocl_igc_interface/impl/igc_features_and_workarounds_impl.cpp
@@ -17,13 +17,9 @@ namespace IGC {
 // Helpers for clarity
 // Basically, these forward GetX/SetX from interface (of given version)
 // to GT_SYSTEM_INFO inside pImpl
-#define DEFINE_GET_SET(INTERFACE, VERSION, NAME, TYPE)\
-    TYPE CIF_GET_INTERFACE_CLASS(INTERFACE, VERSION)::Get##NAME() const {\
-        return CIF_GET_PIMPL()->FeTable.NAME;\
-    }\
-    void CIF_GET_INTERFACE_CLASS(INTERFACE, VERSION)::Set##NAME(TYPE v) {\
-        CIF_GET_PIMPL()->FeTable.NAME = v;\
-    }
+#define DEFINE_GET_SET(INTERFACE, VERSION, NAME, TYPE)                                                                 \
+  TYPE CIF_GET_INTERFACE_CLASS(INTERFACE, VERSION)::Get##NAME() const { return CIF_GET_PIMPL()->FeTable.NAME; }        \
+  void CIF_GET_INTERFACE_CLASS(INTERFACE, VERSION)::Set##NAME(TYPE v) { CIF_GET_PIMPL()->FeTable.NAME = v; }
 
 DEFINE_GET_SET(IgcFeaturesAndWorkarounds, 1, FtrDesktop, bool);
 DEFINE_GET_SET(IgcFeaturesAndWorkarounds, 1, FtrChannelSwizzlingXOREnabled, bool);
@@ -51,13 +47,13 @@ DEFINE_GET_SET(IgcFeaturesAndWorkarounds, 1, FtrPooledEuEnabled, bool);
 DEFINE_GET_SET(IgcFeaturesAndWorkarounds, 1, FtrResourceStreamer, bool);
 
 uint32_t CIF_GET_INTERFACE_CLASS(IgcFeaturesAndWorkarounds, 2)::GetMaxOCLParamSize() const {
-    return CIF_GET_PIMPL()->OCLCaps.MaxParameterSize;
+  return CIF_GET_PIMPL()->OCLCaps.MaxParameterSize;
 }
 void CIF_GET_INTERFACE_CLASS(IgcFeaturesAndWorkarounds, 2)::SetMaxOCLParamSize(uint32_t s) {
-    IGC_ASSERT(s >= OCLCaps::MINIMAL_MAX_PARAMETER_SIZE);
-    CIF_GET_PIMPL()->OCLCaps.MaxParameterSize = s;
+  IGC_ASSERT(s >= OCLCaps::MINIMAL_MAX_PARAMETER_SIZE);
+  CIF_GET_PIMPL()->OCLCaps.MaxParameterSize = s;
 }
 
-}
+} // namespace IGC
 
 #include "cif/macros/disable.h"
diff --git a/include/igc/ocl_igc_interface/impl/igc_features_and_workarounds_impl.h b/include/igc/ocl_igc_interface/impl/igc_features_and_workarounds_impl.h
index cdb1b51..316e33b 100644
--- a/include/igc/ocl_igc_interface/impl/igc_features_and_workarounds_impl.h
+++ b/include/igc/ocl_igc_interface/impl/igc_features_and_workarounds_impl.h
@@ -23,9 +23,7 @@ namespace IGC {
 
 CIF_DECLARE_INTERFACE_PIMPL(IgcFeaturesAndWorkarounds) : CIF::PimplBase {
 
-  OCL_API_CALL CIF_PIMPL_DECLARE_CONSTRUCTOR() {
-      CIF::SafeZeroOut(FeTable);
-  }
+  OCL_API_CALL CIF_PIMPL_DECLARE_CONSTRUCTOR() { CIF::SafeZeroOut(FeTable); }
 
   _SUscSkuFeatureTable FeTable;
   OCLCaps OCLCaps;
@@ -35,6 +33,6 @@ CIF_DECLARE_INTERFACE_PIMPL(IgcFeaturesAndWorkarounds) : CIF::PimplBase {
 
 CIF_DEFINE_INTERFACE_TO_PIMPL_FORWARDING_CTOR_DTOR(IgcFeaturesAndWorkarounds);
 
-}
+} // namespace IGC
 
 #include "cif/macros/disable.h"
diff --git a/include/igc/ocl_igc_interface/impl/igc_ocl_device_ctx_impl.cpp b/include/igc/ocl_igc_interface/impl/igc_ocl_device_ctx_impl.cpp
index a928fb9..bf4c4c7 100644
--- a/include/igc/ocl_igc_interface/impl/igc_ocl_device_ctx_impl.cpp
+++ b/include/igc/ocl_igc_interface/impl/igc_ocl_device_ctx_impl.cpp
@@ -20,52 +20,53 @@ SPDX-License-Identifier: MIT
 
 namespace IGC {
 
-void CIF_GET_INTERFACE_CLASS(IgcOclDeviceCtx, 1)::SetProfilingTimerResolution(float v){
-    CIF_GET_PIMPL()->MiscOptions.ProfilingTimerResolution = v;
+void CIF_GET_INTERFACE_CLASS(IgcOclDeviceCtx, 1)::SetProfilingTimerResolution(float v) {
+  CIF_GET_PIMPL()->MiscOptions.ProfilingTimerResolution = v;
 }
 
-PlatformBase *CIF_GET_INTERFACE_CLASS(IgcOclDeviceCtx, 1)::GetPlatformHandleImpl(CIF::Version_t ver){
-    return CIF_GET_PIMPL()->GetPlatformHandle(ver);
+PlatformBase *CIF_GET_INTERFACE_CLASS(IgcOclDeviceCtx, 1)::GetPlatformHandleImpl(CIF::Version_t ver) {
+  return CIF_GET_PIMPL()->GetPlatformHandle(ver);
 }
 
-GTSystemInfoBase *CIF_GET_INTERFACE_CLASS(IgcOclDeviceCtx, 1)::GetGTSystemInfoHandleImpl(CIF::Version_t ver){
-    return CIF_GET_PIMPL()->GetGTSystemInfoHandle(ver);
+GTSystemInfoBase *CIF_GET_INTERFACE_CLASS(IgcOclDeviceCtx, 1)::GetGTSystemInfoHandleImpl(CIF::Version_t ver) {
+  return CIF_GET_PIMPL()->GetGTSystemInfoHandle(ver);
 }
 
-IgcFeaturesAndWorkaroundsBase *CIF_GET_INTERFACE_CLASS(IgcOclDeviceCtx, 1)::GetIgcFeaturesAndWorkaroundsHandleImpl(CIF::Version_t ver){
-    return CIF_GET_PIMPL()->GetIgcFeaturesAndWorkaroundsHandle(ver);
+IgcFeaturesAndWorkaroundsBase *CIF_GET_INTERFACE_CLASS(IgcOclDeviceCtx,
+                                                       1)::GetIgcFeaturesAndWorkaroundsHandleImpl(CIF::Version_t ver) {
+  return CIF_GET_PIMPL()->GetIgcFeaturesAndWorkaroundsHandle(ver);
 }
 
-IgcOclTranslationCtxBase *CIF_GET_INTERFACE_CLASS(IgcOclDeviceCtx, 1)::CreateTranslationCtxImpl(CIF::Version_t ver,
-                                                                                                  CodeType::CodeType_t inType,
-                                                                                                  CodeType::CodeType_t outType){
-    return CIF_GET_PIMPL()->CreateTranslationCtx(ver, inType, outType);
+IgcOclTranslationCtxBase *
+CIF_GET_INTERFACE_CLASS(IgcOclDeviceCtx, 1)::CreateTranslationCtxImpl(CIF::Version_t ver, CodeType::CodeType_t inType,
+                                                                      CodeType::CodeType_t outType) {
+  return CIF_GET_PIMPL()->CreateTranslationCtx(ver, inType, outType);
 }
 
-bool CIF_GET_INTERFACE_CLASS(IgcOclDeviceCtx, 2)::GetSystemRoutine(SystemRoutineType::SystemRoutineType_t typeOfSystemRoutine,
-                                                                    bool bindless,
-                                                                    CIF::Builtins::BufferSimple *outSystemRoutineBuffer,
-                                                                    CIF::Builtins::BufferSimple *stateSaveAreaHeaderInit) {
-    return CIF_GET_PIMPL()->GetSystemRoutine(typeOfSystemRoutine, bindless, outSystemRoutineBuffer, stateSaveAreaHeaderInit);
+bool CIF_GET_INTERFACE_CLASS(IgcOclDeviceCtx,
+                             2)::GetSystemRoutine(SystemRoutineType::SystemRoutineType_t typeOfSystemRoutine,
+                                                  bool bindless, CIF::Builtins::BufferSimple *outSystemRoutineBuffer,
+                                                  CIF::Builtins::BufferSimple *stateSaveAreaHeaderInit) {
+  return CIF_GET_PIMPL()->GetSystemRoutine(typeOfSystemRoutine, bindless, outSystemRoutineBuffer,
+                                           stateSaveAreaHeaderInit);
 }
 
-const char* CIF_GET_INTERFACE_CLASS(IgcOclDeviceCtx, 3)::GetIGCRevision() {
-    return CIF_GET_PIMPL()->GetIGCRevision();
-}
+const char *CIF_GET_INTERFACE_CLASS(IgcOclDeviceCtx, 3)::GetIGCRevision() { return CIF_GET_PIMPL()->GetIGCRevision(); }
 
-IgcOclTranslationCtxBase *CIF_PIMPL(IgcOclDeviceCtx)::CreateTranslationCtx(CIF::Version_t version, CodeType::CodeType_t inType, CodeType::CodeType_t outType)
-{
-    if(false == CIF_PIMPL(IgcOclTranslationCtx)::SupportsTranslation(inType, outType)){
-        return nullptr;
-    }
-    return CIF::InterfaceCreator<IgcOclTranslationCtx>::CreateInterfaceVer(version, version, this, inType, outType);
+IgcOclTranslationCtxBase *CIF_PIMPL(IgcOclDeviceCtx)::CreateTranslationCtx(CIF::Version_t version,
+                                                                           CodeType::CodeType_t inType,
+                                                                           CodeType::CodeType_t outType) {
+  if (false == CIF_PIMPL(IgcOclTranslationCtx)::SupportsTranslation(inType, outType)) {
+    return nullptr;
+  }
+  return CIF::InterfaceCreator<IgcOclTranslationCtx>::CreateInterfaceVer(version, version, this, inType, outType);
 }
 
-IgcBuiltinsBase *CIF_GET_INTERFACE_CLASS(IgcOclDeviceCtx, 4)::GetIgcBuiltinsHandleImpl(CIF::Version_t ver){
-    return CIF_GET_PIMPL()->GetIgcBuiltinsHandle(ver);
+IgcBuiltinsBase *CIF_GET_INTERFACE_CLASS(IgcOclDeviceCtx, 4)::GetIgcBuiltinsHandleImpl(CIF::Version_t ver) {
+  return CIF_GET_PIMPL()->GetIgcBuiltinsHandle(ver);
 }
 
-}
+} // namespace IGC
 
 CIF_EXPORT_ENTRY_POINTS_STATIC(IGC::IgcOclDeviceCtx);
 
diff --git a/include/igc/ocl_igc_interface/impl/igc_ocl_device_ctx_impl.h b/include/igc/ocl_igc_interface/impl/igc_ocl_device_ctx_impl.h
index 1304762..f37994f 100644
--- a/include/igc/ocl_igc_interface/impl/igc_ocl_device_ctx_impl.h
+++ b/include/igc/ocl_igc_interface/impl/igc_ocl_device_ctx_impl.h
@@ -31,144 +31,123 @@ SPDX-License-Identifier: MIT
 
 #include "OCLAPI/oclapi.h"
 
-namespace IGC
-{
-
-CIF_DECLARE_INTERFACE_PIMPL(IgcOclDeviceCtx) : CIF::PimplBase
-{
-    OCL_API_CALL CIF_PIMPL_DECLARE_CONSTRUCTOR(CIF::Version_t version, CIF::ICIF *parentInterface)
-    {
-        platform.CreateImpl();
-        gtSystemInfo.CreateImpl();
-        igcFeaturesAndWorkarounds.CreateImpl();
-        igcBuiltins.CreateImpl();
-    }
+namespace IGC {
 
-    OCL_API_CALL CIF_PIMPL(Platform) *GetPlatformImpl(){
-        return this->platform.GetImpl();
-    }
+CIF_DECLARE_INTERFACE_PIMPL(IgcOclDeviceCtx) : CIF::PimplBase {
+  OCL_API_CALL CIF_PIMPL_DECLARE_CONSTRUCTOR(CIF::Version_t version, CIF::ICIF * parentInterface) {
+    platform.CreateImpl();
+    gtSystemInfo.CreateImpl();
+    igcFeaturesAndWorkarounds.CreateImpl();
+    igcBuiltins.CreateImpl();
+  }
 
-    OCL_API_CALL PlatformBase *GetPlatformHandle(CIF::Version_t version)
-    {
-        return platform.GetVersion(version);
-    }
+  OCL_API_CALL CIF_PIMPL(Platform) * GetPlatformImpl() { return this->platform.GetImpl(); }
 
-    OCL_API_CALL GTSystemInfoBase *GetGTSystemInfoHandle(CIF::Version_t version)
-    {
-        return gtSystemInfo.GetVersion(version);
-    }
+  OCL_API_CALL PlatformBase *GetPlatformHandle(CIF::Version_t version) { return platform.GetVersion(version); }
+
+  OCL_API_CALL GTSystemInfoBase *GetGTSystemInfoHandle(CIF::Version_t version) {
+    return gtSystemInfo.GetVersion(version);
+  }
 
-    OCL_API_CALL IgcFeaturesAndWorkaroundsBase *GetIgcFeaturesAndWorkaroundsHandle(CIF::Version_t version)
-    {
-        return igcFeaturesAndWorkarounds.GetVersion(version);
+  OCL_API_CALL IgcFeaturesAndWorkaroundsBase *GetIgcFeaturesAndWorkaroundsHandle(CIF::Version_t version) {
+    return igcFeaturesAndWorkarounds.GetVersion(version);
+  }
+
+  OCL_API_CALL IgcBuiltinsBase *GetIgcBuiltinsHandle(CIF::Version_t version) { return igcBuiltins.GetVersion(version); }
+
+  OCL_API_CALL IgcOclTranslationCtxBase *CreateTranslationCtx(CIF::Version_t version, CodeType::CodeType_t inType,
+                                                              CodeType::CodeType_t outType);
+
+  OCL_API_CALL bool GetSystemRoutine(SystemRoutineType::SystemRoutineType_t typeOfSystemRoutine, bool bindless,
+                                     CIF::Builtins::BufferSimple *outSystemRoutineBuffer,
+                                     CIF::Builtins::BufferSimple *stateSaveAreaHeaderInit) {
+    if (nullptr == outSystemRoutineBuffer) {
+      return false;
     }
 
-    OCL_API_CALL IgcBuiltinsBase *GetIgcBuiltinsHandle(CIF::Version_t version)
-    {
-        return igcBuiltins.GetVersion(version);
+    USC::SYSTEM_THREAD_MODE mode;
+    switch (typeOfSystemRoutine) {
+    case SystemRoutineType::contextSaveRestore:
+      mode = USC::SYSTEM_THREAD_MODE_CSR;
+      break;
+    case SystemRoutineType::debug:
+      mode = static_cast<USC::SYSTEM_THREAD_MODE>(USC::SYSTEM_THREAD_MODE_DEBUG | USC::SYSTEM_THREAD_MODE_CSR);
+      break;
+    case SystemRoutineType::debugSlm:
+      mode = static_cast<USC::SYSTEM_THREAD_MODE>(USC::SYSTEM_THREAD_MODE_DEBUG_LOCAL | USC::SYSTEM_THREAD_MODE_CSR);
+      break;
+    default:
+      assert(0);
+      return false;
     }
 
-    OCL_API_CALL IgcOclTranslationCtxBase *CreateTranslationCtx(CIF::Version_t version, CodeType::CodeType_t inType, CodeType::CodeType_t outType);
-
-    OCL_API_CALL bool GetSystemRoutine(SystemRoutineType::SystemRoutineType_t typeOfSystemRoutine, bool bindless, CIF::Builtins::BufferSimple *outSystemRoutineBuffer, CIF::Builtins::BufferSimple *stateSaveAreaHeaderInit) {
-        if (nullptr == outSystemRoutineBuffer) {
-            return false;
-        }
-
-        USC::SYSTEM_THREAD_MODE mode;
-        switch (typeOfSystemRoutine) {
-        case SystemRoutineType::contextSaveRestore:
-            mode = USC::SYSTEM_THREAD_MODE_CSR;
-            break;
-        case SystemRoutineType::debug:
-            mode = static_cast<USC::SYSTEM_THREAD_MODE>(USC::SYSTEM_THREAD_MODE_DEBUG | USC::SYSTEM_THREAD_MODE_CSR);
-            break;
-        case SystemRoutineType::debugSlm:
-            mode = static_cast<USC::SYSTEM_THREAD_MODE>(USC::SYSTEM_THREAD_MODE_DEBUG_LOCAL | USC::SYSTEM_THREAD_MODE_CSR);
-            break;
-        default:
-            assert(0);
-            return false;
-        }
-
-        USC::SSystemThreadKernelOutput *systemKernel = nullptr;
-        if (false == SIP::CSystemThread::CreateSystemThreadKernel(this->GetIgcCPlatform(), mode, systemKernel, bindless)) {
-            return false;
-        }
-
-        outSystemRoutineBuffer->Clear();
-        outSystemRoutineBuffer->PushBackRawBytes(systemKernel->m_pKernelProgram, systemKernel->m_KernelProgramSize);
-        stateSaveAreaHeaderInit->Clear();
-        stateSaveAreaHeaderInit->PushBackRawBytes(systemKernel->m_pStateSaveAreaHeader, systemKernel->m_StateSaveAreaHeaderSize);
-        SIP::CSystemThread::DeleteSystemThreadKernel(systemKernel);
-        return true;
+    USC::SSystemThreadKernelOutput *systemKernel = nullptr;
+    if (false == SIP::CSystemThread::CreateSystemThreadKernel(this->GetIgcCPlatform(), mode, systemKernel, bindless)) {
+      return false;
     }
 
-    const char* GetIGCRevision() {
+    outSystemRoutineBuffer->Clear();
+    outSystemRoutineBuffer->PushBackRawBytes(systemKernel->m_pKernelProgram, systemKernel->m_KernelProgramSize);
+    stateSaveAreaHeaderInit->Clear();
+    stateSaveAreaHeaderInit->PushBackRawBytes(systemKernel->m_pStateSaveAreaHeader,
+                                              systemKernel->m_StateSaveAreaHeaderSize);
+    SIP::CSystemThread::DeleteSystemThreadKernel(systemKernel);
+    return true;
+  }
+
+  const char *GetIGCRevision() {
 #ifdef IGC_REVISION
-      return IGC_REVISION;
+    return IGC_REVISION;
 #else
-      return "";
+    return "";
 #endif
+  }
+
+  struct OCL_API_CALL MiscOptions {
+    MiscOptions() { this->Clear(); }
+
+    void Clear() { ProfilingTimerResolution = .0f; }
+
+    float ProfilingTimerResolution;
+  } MiscOptions;
+
+  OCL_API_CALL const IGC::CPlatform &GetIgcCPlatform() {
+    // "fast path" where we return initialized igcPlatform without a lock
+    if (igcPlatform.get() != nullptr) {
+      return *igcPlatform;
     }
 
-    struct OCL_API_CALL MiscOptions
-    {
-        MiscOptions()
-        {
-            this->Clear();
-        }
-
-        void Clear()
-        {
-            ProfilingTimerResolution = .0f;
-        }
-
-        float ProfilingTimerResolution;
-    } MiscOptions;
-
-    OCL_API_CALL const IGC::CPlatform & GetIgcCPlatform()
-    {
-        // "fast path" where we return initialized igcPlatform without a lock
-        if(igcPlatform.get() != nullptr)
-        {
-            return *igcPlatform;
-        }
-
-        // acquire a lock to if igcPlatform is uninitialized
-        std::lock_guard<std::mutex> lock{this->mutex};
-
-        // check if other thread initialized igcPlatform first
-        if(igcPlatform.get() != nullptr)
-        {
-            return *igcPlatform;
-        }
-
-        // construct fully initialized CPlatform object
-        IGC::CPlatform *new_platform = new IGC::CPlatform(platform->p);
-        new_platform->SetGTSystemInfo(gtSystemInfo->gsi);
-        new_platform->setOclCaps(igcFeaturesAndWorkarounds->OCLCaps);
-        IGC::SetWorkaroundTable(&igcFeaturesAndWorkarounds->FeTable, new_platform);
-        IGC::SetCompilerCaps(&igcFeaturesAndWorkarounds->FeTable, new_platform);
-        // assign new_platform to igcPlatform after a full initialization
-        // is finished to avoid race conditions
-        igcPlatform.reset(new_platform);
-        return *igcPlatform;
+    // acquire a lock to if igcPlatform is uninitialized
+    std::lock_guard<std::mutex> lock{this->mutex};
+
+    // check if other thread initialized igcPlatform first
+    if (igcPlatform.get() != nullptr) {
+      return *igcPlatform;
     }
 
+    // construct fully initialized CPlatform object
+    IGC::CPlatform *new_platform = new IGC::CPlatform(platform->p);
+    new_platform->SetGTSystemInfo(gtSystemInfo->gsi);
+    new_platform->setOclCaps(igcFeaturesAndWorkarounds->OCLCaps);
+    IGC::SetWorkaroundTable(&igcFeaturesAndWorkarounds->FeTable, new_platform);
+    IGC::SetCompilerCaps(&igcFeaturesAndWorkarounds->FeTable, new_platform);
+    // assign new_platform to igcPlatform after a full initialization
+    // is finished to avoid race conditions
+    igcPlatform.reset(new_platform);
+    return *igcPlatform;
+  }
+
 protected:
-    std::mutex                                   mutex;
-    CIF::Multiversion<Platform>                  platform;
-    CIF::Multiversion<GTSystemInfo>              gtSystemInfo;
-    CIF::Multiversion<IgcFeaturesAndWorkarounds> igcFeaturesAndWorkarounds;
-    CIF::Multiversion<IgcBuiltins>               igcBuiltins;
-    std::unique_ptr<IGC::CPlatform>              igcPlatform;
+  std::mutex mutex;
+  CIF::Multiversion<Platform> platform;
+  CIF::Multiversion<GTSystemInfo> gtSystemInfo;
+  CIF::Multiversion<IgcFeaturesAndWorkarounds> igcFeaturesAndWorkarounds;
+  CIF::Multiversion<IgcBuiltins> igcBuiltins;
+  std::unique_ptr<IGC::CPlatform> igcPlatform;
 };
 
 CIF_DEFINE_INTERFACE_TO_PIMPL_FORWARDING_CTOR_DTOR(IgcOclDeviceCtx);
 
-
-
-}
+} // namespace IGC
 
 #include "cif/macros/disable.h"
diff --git a/include/igc/ocl_igc_interface/impl/igc_ocl_translation_ctx_impl.cpp b/include/igc/ocl_igc_interface/impl/igc_ocl_translation_ctx_impl.cpp
index 815d4f8..da581f6 100644
--- a/include/igc/ocl_igc_interface/impl/igc_ocl_translation_ctx_impl.cpp
+++ b/include/igc/ocl_igc_interface/impl/igc_ocl_translation_ctx_impl.cpp
@@ -18,70 +18,55 @@ jmp_buf sig_jmp_buf;
 namespace IGC {
 
 OclTranslationOutputBase *CIF_GET_INTERFACE_CLASS(IgcOclTranslationCtx, 1)::TranslateImpl(
-                                                 CIF::Version_t outVersion,
-                                                 CIF::Builtins::BufferSimple *src,
-                                                 CIF::Builtins::BufferSimple *options,
-                                                 CIF::Builtins::BufferSimple *internalOptions,
-                                                 CIF::Builtins::BufferSimple *tracingOptions,
-                                                 uint32_t tracingOptionsCount) {
-    OclTranslationOutputBase* res;
-    EX_GUARD_BEGIN
-    res = CIF_GET_PIMPL()->Translate(outVersion, src, nullptr, nullptr, options, internalOptions, tracingOptions, tracingOptionsCount, nullptr);
-    EX_GUARD_END
-    return res;
+    CIF::Version_t outVersion, CIF::Builtins::BufferSimple *src, CIF::Builtins::BufferSimple *options,
+    CIF::Builtins::BufferSimple *internalOptions, CIF::Builtins::BufferSimple *tracingOptions,
+    uint32_t tracingOptionsCount) {
+  OclTranslationOutputBase *res;
+  EX_GUARD_BEGIN
+  res = CIF_GET_PIMPL()->Translate(outVersion, src, nullptr, nullptr, options, internalOptions, tracingOptions,
+                                   tracingOptionsCount, nullptr);
+  EX_GUARD_END
+  return res;
 }
 
 OclTranslationOutputBase *CIF_GET_INTERFACE_CLASS(IgcOclTranslationCtx, 2)::TranslateImpl(
-                                                 CIF::Version_t outVersion,
-                                                 CIF::Builtins::BufferSimple *src,
-                                                 CIF::Builtins::BufferSimple *options,
-                                                 CIF::Builtins::BufferSimple *internalOptions,
-                                                 CIF::Builtins::BufferSimple *tracingOptions,
-                                                 uint32_t tracingOptionsCount,
-                                                 void *gtPinInput) {
-    OclTranslationOutputBase* res;
-    EX_GUARD_BEGIN
-    res = CIF_GET_PIMPL()->Translate(outVersion, src, nullptr, nullptr, options, internalOptions, tracingOptions, tracingOptionsCount, gtPinInput);
-    EX_GUARD_END
-    return res;
+    CIF::Version_t outVersion, CIF::Builtins::BufferSimple *src, CIF::Builtins::BufferSimple *options,
+    CIF::Builtins::BufferSimple *internalOptions, CIF::Builtins::BufferSimple *tracingOptions,
+    uint32_t tracingOptionsCount, void *gtPinInput) {
+  OclTranslationOutputBase *res;
+  EX_GUARD_BEGIN
+  res = CIF_GET_PIMPL()->Translate(outVersion, src, nullptr, nullptr, options, internalOptions, tracingOptions,
+                                   tracingOptionsCount, gtPinInput);
+  EX_GUARD_END
+  return res;
 }
 
-bool CIF_GET_INTERFACE_CLASS(IgcOclTranslationCtx, 3)::GetSpecConstantsInfoImpl(
-                            CIF::Builtins::BufferSimple *src,
-                            CIF::Builtins::BufferSimple *outSpecConstantsIds,
-                            CIF::Builtins::BufferSimple *outSpecConstantsSizes) {
-    return CIF_GET_PIMPL()->GetSpecConstantsInfo(src, outSpecConstantsIds, outSpecConstantsSizes);
+bool CIF_GET_INTERFACE_CLASS(IgcOclTranslationCtx,
+                             3)::GetSpecConstantsInfoImpl(CIF::Builtins::BufferSimple *src,
+                                                          CIF::Builtins::BufferSimple *outSpecConstantsIds,
+                                                          CIF::Builtins::BufferSimple *outSpecConstantsSizes) {
+  return CIF_GET_PIMPL()->GetSpecConstantsInfo(src, outSpecConstantsIds, outSpecConstantsSizes);
 }
 
 OclTranslationOutputBase *CIF_GET_INTERFACE_CLASS(IgcOclTranslationCtx, 3)::TranslateImpl(
-                                                 CIF::Version_t outVersion,
-                                                 CIF::Builtins::BufferSimple *src,
-                                                 CIF::Builtins::BufferSimple *specConstantsIds,
-                                                 CIF::Builtins::BufferSimple *specConstantsValues,
-                                                 CIF::Builtins::BufferSimple *options,
-                                                 CIF::Builtins::BufferSimple *internalOptions,
-                                                 CIF::Builtins::BufferSimple *tracingOptions,
-                                                 uint32_t tracingOptionsCount,
-                                                 void *gtPinInput) {
-    OclTranslationOutputBase* res;
-    EX_GUARD_BEGIN
-    res = CIF_GET_PIMPL()->Translate(outVersion, src, specConstantsIds, specConstantsValues, options, internalOptions, tracingOptions, tracingOptionsCount, gtPinInput);
-    EX_GUARD_END
-    return res;
+    CIF::Version_t outVersion, CIF::Builtins::BufferSimple *src, CIF::Builtins::BufferSimple *specConstantsIds,
+    CIF::Builtins::BufferSimple *specConstantsValues, CIF::Builtins::BufferSimple *options,
+    CIF::Builtins::BufferSimple *internalOptions, CIF::Builtins::BufferSimple *tracingOptions,
+    uint32_t tracingOptionsCount, void *gtPinInput) {
+  OclTranslationOutputBase *res;
+  EX_GUARD_BEGIN
+  res = CIF_GET_PIMPL()->Translate(outVersion, src, specConstantsIds, specConstantsValues, options, internalOptions,
+                                   tracingOptions, tracingOptionsCount, gtPinInput);
+  EX_GUARD_END
+  return res;
 }
 
-}
+} // namespace IGC
 
 #include "cif/macros/disable.h"
 
 #if defined(WIN32)
-int ex_filter(unsigned int code, struct _EXCEPTION_POINTERS* ep)
-{
-    return EXCEPTION_EXECUTE_HANDLER;
-}
+int ex_filter(unsigned int code, struct _EXCEPTION_POINTERS *ep) { return EXCEPTION_EXECUTE_HANDLER; }
 #else
-void signalHandler(int sig, siginfo_t* info, void* ucontext)
-{
-    longjmp(sig_jmp_buf, sig);
-}
+void signalHandler(int sig, siginfo_t *info, void *ucontext) { longjmp(sig_jmp_buf, sig); }
 #endif
diff --git a/include/igc/ocl_igc_interface/impl/igc_ocl_translation_ctx_impl.h b/include/igc/ocl_igc_interface/impl/igc_ocl_translation_ctx_impl.h
index 79760b0..5dedcf8 100644
--- a/include/igc/ocl_igc_interface/impl/igc_ocl_translation_ctx_impl.h
+++ b/include/igc/ocl_igc_interface/impl/igc_ocl_translation_ctx_impl.h
@@ -31,492 +31,439 @@ SPDX-License-Identifier: MIT
 #include "Compiler/CISACodeGen/OpenCLKernelCodeGen.hpp"
 #include "OCLAPI/oclapi.h"
 
-namespace TC{
+namespace TC {
 
 // Taken from dllInterfaceCompute
-extern bool ProcessElfInput(
-  STB_TranslateInputArgs &InputArgs,
-  STB_TranslateOutputArgs &OutputArgs,
-  IGC::OpenCLProgramContext &Context,
-  PLATFORM &platform,
-  const TB_DATA_FORMAT& outType,
-  float profilingTimerResolution);
-
-extern bool ParseInput(
-  llvm::Module*& pKernelModule,
-  const STB_TranslateInputArgs* pInputArgs,
-  STB_TranslateOutputArgs* pOutputArgs,
-  IGC::OpenCLProgramContext &oclContext,
-  TB_DATA_FORMAT inputDataFormatTemp);
-
-OCL_API_CALL bool TranslateBuild(
-  const STB_TranslateInputArgs* pInputArgs,
-  STB_TranslateOutputArgs* pOutputArgs,
-  TB_DATA_FORMAT inputDataFormatTemp,
-  const IGC::CPlatform &platform,
-  float profilingTimerResolution);
-
-OCL_API_CALL bool TranslateBuildSPMD(
-  const STB_TranslateInputArgs* pInputArgs,
-  STB_TranslateOutputArgs* pOutputArgs,
-  TB_DATA_FORMAT inputDataFormatTemp,
-  const IGC::CPlatform &platform,
-  float profilingTimerResolution,
-  const ShaderHash& inputShHash);
-
-OCL_API_CALL bool TranslateBuildVC(
-  const STB_TranslateInputArgs* pInputArgs,
-  STB_TranslateOutputArgs* pOutputArgs,
-  TB_DATA_FORMAT inputDataFormatTemp,
-  const IGC::CPlatform &platform,
-  float profilingTimerResolution,
-  const ShaderHash& inputShHash);
-
-OCL_API_CALL void RebuildGlobalAnnotations(
-  IGC::OpenCLProgramContext& oclContext,
-  llvm::Module* pKernelModule
-);
-
-OCL_API_CALL bool ReadSpecConstantsFromSPIRV(
-    std::istream &IS,
-    std::vector<std::pair<uint32_t, uint32_t>> &OutSCInfo);
-
-OCL_API_CALL void DumpShaderFile(
-    const std::string& dstDir,
-    const char* pBuffer,
-    const UINT bufferSize,
-    const QWORD hash,
-    const std::string& ext,
-    std::string* fileName);
-
-OCL_API_CALL spv_result_t DisassembleSPIRV(
-    const char* pBuffer,
-    UINT bufferSize,
-    spv_text* outSpirvAsm);
+extern bool ProcessElfInput(STB_TranslateInputArgs &InputArgs, STB_TranslateOutputArgs &OutputArgs,
+                            IGC::OpenCLProgramContext &Context, PLATFORM &platform, const TB_DATA_FORMAT &outType,
+                            float profilingTimerResolution);
+
+extern bool ParseInput(llvm::Module *&pKernelModule, const STB_TranslateInputArgs *pInputArgs,
+                       STB_TranslateOutputArgs *pOutputArgs, IGC::OpenCLProgramContext &oclContext,
+                       TB_DATA_FORMAT inputDataFormatTemp);
+
+OCL_API_CALL bool TranslateBuild(const STB_TranslateInputArgs *pInputArgs, STB_TranslateOutputArgs *pOutputArgs,
+                                 TB_DATA_FORMAT inputDataFormatTemp, const IGC::CPlatform &platform,
+                                 float profilingTimerResolution);
+
+OCL_API_CALL bool TranslateBuildSPMD(const STB_TranslateInputArgs *pInputArgs, STB_TranslateOutputArgs *pOutputArgs,
+                                     TB_DATA_FORMAT inputDataFormatTemp, const IGC::CPlatform &platform,
+                                     float profilingTimerResolution, const ShaderHash &inputShHash);
+
+OCL_API_CALL bool TranslateBuildVC(const STB_TranslateInputArgs *pInputArgs, STB_TranslateOutputArgs *pOutputArgs,
+                                   TB_DATA_FORMAT inputDataFormatTemp, const IGC::CPlatform &platform,
+                                   float profilingTimerResolution, const ShaderHash &inputShHash);
+
+OCL_API_CALL void RebuildGlobalAnnotations(IGC::OpenCLProgramContext &oclContext, llvm::Module *pKernelModule);
+
+OCL_API_CALL bool ReadSpecConstantsFromSPIRV(std::istream &IS, std::vector<std::pair<uint32_t, uint32_t>> &OutSCInfo);
+
+OCL_API_CALL void DumpShaderFile(const std::string &dstDir, const char *pBuffer, const UINT bufferSize,
+                                 const QWORD hash, const std::string &ext, std::string *fileName);
+
+OCL_API_CALL spv_result_t DisassembleSPIRV(const char *pBuffer, UINT bufferSize, spv_text *outSpirvAsm);
 
 OCL_API_CALL void UnlockMutex();
 
-}
+} // namespace TC
 
-OCL_API_CALL bool enableSrcLine(void*);
+OCL_API_CALL bool enableSrcLine(void *);
 
 namespace IGC {
 
-    OCL_API_CALL inline TC::TB_DATA_FORMAT toLegacyFormat(CodeType::CodeType_t format){
-    switch(format){
-        case CodeType::elf : return TC::TB_DATA_FORMAT_ELF; break;
-        case CodeType::llvmBc : return TC::TB_DATA_FORMAT_LLVM_BINARY; break;
-        case CodeType::llvmLl : return TC::TB_DATA_FORMAT_LLVM_TEXT; break;
-        case CodeType::oclC : return TC::TB_DATA_FORMAT_OCL_TEXT; break;
-        case CodeType::oclGenBin : return TC::TB_DATA_FORMAT_DEVICE_BINARY; break;
-        case CodeType::spirV : return TC::TB_DATA_FORMAT_SPIR_V; break;
-        default:
-            return TC::TB_DATA_FORMAT_UNKNOWN;
-    }
+OCL_API_CALL inline TC::TB_DATA_FORMAT toLegacyFormat(CodeType::CodeType_t format) {
+  switch (format) {
+  case CodeType::elf:
+    return TC::TB_DATA_FORMAT_ELF;
+    break;
+  case CodeType::llvmBc:
+    return TC::TB_DATA_FORMAT_LLVM_BINARY;
+    break;
+  case CodeType::llvmLl:
+    return TC::TB_DATA_FORMAT_LLVM_TEXT;
+    break;
+  case CodeType::oclC:
+    return TC::TB_DATA_FORMAT_OCL_TEXT;
+    break;
+  case CodeType::oclGenBin:
+    return TC::TB_DATA_FORMAT_DEVICE_BINARY;
+    break;
+  case CodeType::spirV:
+    return TC::TB_DATA_FORMAT_SPIR_V;
+    break;
+  default:
+    return TC::TB_DATA_FORMAT_UNKNOWN;
+  }
 }
 
 struct OCL_API_CALL IGC_State {
 protected:
-    bool isAlive;
+  bool isAlive;
+
 public:
-    IGC_State() {
-        isAlive = true;
-    }
-    ~IGC_State() {
-        isAlive = false;
-    }
-    IGC_State(const IGC_State&) = delete;
-    IGC_State& operator=(const IGC_State&) = delete;
-    static const bool isDestructed() {
-        static const IGC_State obj;
-        return !obj.isAlive;
-    }
+  IGC_State() { isAlive = true; }
+  ~IGC_State() { isAlive = false; }
+  IGC_State(const IGC_State &) = delete;
+  IGC_State &operator=(const IGC_State &) = delete;
+  static const bool isDestructed() {
+    static const IGC_State obj;
+    return !obj.isAlive;
+  }
 };
 
-CIF_DECLARE_INTERFACE_PIMPL(IgcOclTranslationCtx) : CIF::PimplBase
-{
-    OCL_API_CALL CIF_PIMPL_DECLARE_CONSTRUCTOR(CIF::Version_t version, CIF_PIMPL(IgcOclDeviceCtx) *globalState,
-                                  CodeType::CodeType_t inType, CodeType::CodeType_t outType)
-        : globalState(CIF::Sanity::ToReferenceOrAbort(globalState)), inType(inType), outType(outType)
-    {
-    }
+CIF_DECLARE_INTERFACE_PIMPL(IgcOclTranslationCtx) : CIF::PimplBase {
+  OCL_API_CALL CIF_PIMPL_DECLARE_CONSTRUCTOR(CIF::Version_t version, CIF_PIMPL(IgcOclDeviceCtx) * globalState,
+                                             CodeType::CodeType_t inType, CodeType::CodeType_t outType)
+      : globalState(CIF::Sanity::ToReferenceOrAbort(globalState)), inType(inType), outType(outType) {}
 
-    OCL_API_CALL static bool SupportsTranslation(CodeType::CodeType_t inType, CodeType::CodeType_t outType){
-        static std::pair<CodeType::CodeType_t, CodeType::CodeType_t> supportedTranslations[] =
-            {
+  OCL_API_CALL static bool SupportsTranslation(CodeType::CodeType_t inType, CodeType::CodeType_t outType) {
+    static std::pair<CodeType::CodeType_t, CodeType::CodeType_t> supportedTranslations[] = {
+        // clang-format off
                   // from                 // to
                 { CodeType::elf,      CodeType::llvmBc },
                 { CodeType::elf,      CodeType::oclGenBin },
                 { CodeType::llvmLl,   CodeType::oclGenBin },
                 { CodeType::llvmBc,   CodeType::oclGenBin },
                 { CodeType::spirV,    CodeType::oclGenBin },
-            };
-        for(const auto & st : supportedTranslations){
-            if((inType == st.first) && (outType == st.second)){
-                return true;
-            }
-        }
-        return false;
+        // clang-format on
+    };
+    for (const auto &st : supportedTranslations) {
+      if ((inType == st.first) && (outType == st.second)) {
+        return true;
+      }
     }
-
-    OCL_API_CALL bool GetSpecConstantsInfo(CIF::Builtins::BufferSimple *src,
-                              CIF::Builtins::BufferSimple *outSpecConstantsIds,
-                              CIF::Builtins::BufferSimple *outSpecConstantsSizes)
-    {
-        if (IGC_State::isDestructed()) {
-            return false;
-        }
-        bool success = false;
-        const char* pInput = src->GetMemory<char>();
-        uint32_t inputSize = static_cast<uint32_t>(src->GetSizeRaw());
-
-        if(this->inType == CodeType::spirV){
-            // load registry keys to make sure that flags can be read correctly
-            LoadRegistryKeys();
-            if (IGC_IS_FLAG_ENABLED(ShaderDumpEnable))
-            {
-                // dump SPIRV input if flag is enabled
-                const char* pOutputFolder = Debug::GetShaderOutputFolder();
-                QWORD hash = Debug::ShaderHashOCL(reinterpret_cast<const UINT*>(pInput), inputSize / 4).getAsmHash();
-
-                TC::DumpShaderFile(pOutputFolder, pInput, inputSize, hash, ".spv", nullptr);
+    return false;
+  }
+
+  OCL_API_CALL bool GetSpecConstantsInfo(CIF::Builtins::BufferSimple * src,
+                                         CIF::Builtins::BufferSimple * outSpecConstantsIds,
+                                         CIF::Builtins::BufferSimple * outSpecConstantsSizes) {
+    if (IGC_State::isDestructed()) {
+      return false;
+    }
+    bool success = false;
+    const char *pInput = src->GetMemory<char>();
+    uint32_t inputSize = static_cast<uint32_t>(src->GetSizeRaw());
+
+    if (this->inType == CodeType::spirV) {
+      // load registry keys to make sure that flags can be read correctly
+      LoadRegistryKeys();
+      if (IGC_IS_FLAG_ENABLED(ShaderDumpEnable)) {
+        // dump SPIRV input if flag is enabled
+        const char *pOutputFolder = Debug::GetShaderOutputFolder();
+        QWORD hash = Debug::ShaderHashOCL(reinterpret_cast<const UINT *>(pInput), inputSize / 4).getAsmHash();
+
+        TC::DumpShaderFile(pOutputFolder, pInput, inputSize, hash, ".spv", nullptr);
 #if defined(IGC_SPIRV_TOOLS_ENABLED)
-                spv_text spirvAsm = nullptr;
-                if (TC::DisassembleSPIRV(pInput, inputSize, &spirvAsm) == SPV_SUCCESS)
-                {
-                    TC::DumpShaderFile(pOutputFolder, spirvAsm->str, spirvAsm->length, hash, ".spvasm", nullptr);
-                }
-                spvTextDestroy(spirvAsm);
-#endif // defined(IGC_SPIRV_TOOLS_ENABLED)
-            }
-            llvm::StringRef strInput = llvm::StringRef(pInput, inputSize);
-            std::istringstream IS(strInput.str());
-
-            // vector of pairs [spec_id, spec_size]
-            std::vector<std::pair<uint32_t, uint32_t>> SCInfo;
-            success = TC::ReadSpecConstantsFromSPIRV(IS, SCInfo);
-
-            outSpecConstantsIds->Resize(sizeof(uint32_t) * SCInfo.size());
-            outSpecConstantsSizes->Resize(sizeof(uint32_t) * SCInfo.size());
-
-            uint32_t* specConstantsIds = outSpecConstantsIds->GetMemoryWriteable<uint32_t>();
-            uint32_t* specConstantsSizes = outSpecConstantsSizes->GetMemoryWriteable<uint32_t>();
-
-            for(uint32_t i = 0; i < SCInfo.size(); ++i){
-                specConstantsIds[i] = SCInfo.at(i).first;
-                specConstantsSizes[i] = SCInfo.at(i).second;
-            }
-        }
-        else{
-            success = false;
+        if (IGC_IS_FLAG_ENABLED(SpvAsmDumpEnable)) {
+          spv_text spirvAsm = nullptr;
+          if (TC::DisassembleSPIRV(pInput, inputSize, &spirvAsm) == SPV_SUCCESS) {
+            TC::DumpShaderFile(pOutputFolder, spirvAsm->str, spirvAsm->length, hash, ".spvasm", nullptr);
+          }
+          spvTextDestroy(spirvAsm);
         }
+#endif // defined(IGC_SPIRV_TOOLS_ENABLED)
+      }
+      llvm::StringRef strInput = llvm::StringRef(pInput, inputSize);
+      std::istringstream IS(strInput.str());
+
+      // vector of pairs [spec_id, spec_size]
+      std::vector<std::pair<uint32_t, uint32_t>> SCInfo;
+      success = TC::ReadSpecConstantsFromSPIRV(IS, SCInfo);
+
+      outSpecConstantsIds->Resize(sizeof(uint32_t) * SCInfo.size());
+      outSpecConstantsSizes->Resize(sizeof(uint32_t) * SCInfo.size());
+
+      uint32_t *specConstantsIds = outSpecConstantsIds->GetMemoryWriteable<uint32_t>();
+      uint32_t *specConstantsSizes = outSpecConstantsSizes->GetMemoryWriteable<uint32_t>();
+
+      for (uint32_t i = 0; i < SCInfo.size(); ++i) {
+        specConstantsIds[i] = SCInfo.at(i).first;
+        specConstantsSizes[i] = SCInfo.at(i).second;
+      }
+    } else {
+      success = false;
+    }
 
-        return success;
+    return success;
+  }
+
+  OCL_API_CALL OclTranslationOutputBase *Translate(
+      CIF::Version_t outVersion, CIF::Builtins::BufferSimple * src, CIF::Builtins::BufferSimple * specConstantsIds,
+      CIF::Builtins::BufferSimple * specConstantsValues, CIF::Builtins::BufferSimple * options,
+      CIF::Builtins::BufferSimple * internalOptions, CIF::Builtins::BufferSimple * tracingOptions,
+      uint32_t tracingOptionsCount, void *gtPinInput) const {
+    // Create interface for return data
+    auto outputInterface =
+        CIF::RAII::UPtr(CIF::InterfaceCreator<OclTranslationOutput>::CreateInterfaceVer(outVersion, this->outType));
+    if (outputInterface == nullptr) {
+      return nullptr; // OOM
+    }
+    if (IGC_State::isDestructed()) {
+      outputInterface->GetImpl()->SetError(TranslationErrorType::UnhandledInput, "IGC is destructed");
+      return outputInterface.release();
     }
 
-    OCL_API_CALL OclTranslationOutputBase *Translate(CIF::Version_t outVersion,
-                                        CIF::Builtins::BufferSimple *src,
-                                        CIF::Builtins::BufferSimple *specConstantsIds,
-                                        CIF::Builtins::BufferSimple *specConstantsValues,
-                                        CIF::Builtins::BufferSimple *options,
-                                        CIF::Builtins::BufferSimple *internalOptions,
-                                        CIF::Builtins::BufferSimple *tracingOptions,
-                                        uint32_t tracingOptionsCount,
-                                        void *gtPinInput) const{
-        // Create interface for return data
-        auto outputInterface = CIF::RAII::UPtr(CIF::InterfaceCreator<OclTranslationOutput>::CreateInterfaceVer(outVersion, this->outType));
-        if(outputInterface == nullptr){
-            return nullptr; // OOM
+    TC::STB_TranslateInputArgs inputArgs;
+    if (src != nullptr) {
+      if (gtPinInput) {
+        bool srcLine = enableSrcLine(gtPinInput);
+        if (srcLine) {
+          const char *arg = " -gline-tables-only";
+          src->PushBackRawBytes(arg, strlen(arg));
         }
-        if (IGC_State::isDestructed()) {
-            outputInterface->GetImpl()->SetError(TranslationErrorType::UnhandledInput, "IGC is destructed");
-            return outputInterface.release();
+      }
+      inputArgs.pInput = src->GetMemoryWriteable<char>();
+      inputArgs.InputSize = static_cast<uint32_t>(src->GetSizeRaw());
+    }
+    if (options != nullptr) {
+      inputArgs.pOptions = options->GetMemory<char>();
+      inputArgs.OptionsSize = static_cast<uint32_t>(options->GetSizeRaw());
+    }
+    if (internalOptions != nullptr) {
+      inputArgs.pInternalOptions = internalOptions->GetMemory<char>();
+      inputArgs.InternalOptionsSize = static_cast<uint32_t>(internalOptions->GetSizeRaw());
+    }
+    if (tracingOptions != nullptr) {
+      inputArgs.pTracingOptions = tracingOptions->GetMemoryRawWriteable();
+    }
+    inputArgs.TracingOptionsCount = tracingOptionsCount;
+    if (specConstantsIds != nullptr && specConstantsValues != nullptr) {
+      inputArgs.pSpecConstantsIds = specConstantsIds->GetMemory<uint32_t>();
+      inputArgs.SpecConstantsSize = static_cast<uint32_t>(specConstantsIds->GetSizeRaw() / sizeof(uint32_t));
+      inputArgs.pSpecConstantsValues = specConstantsValues->GetMemory<uint64_t>();
+    }
+    inputArgs.GTPinInput = gtPinInput;
+
+    CIF::Sanity::NotNullOrAbort(this->globalState.GetPlatformImpl());
+    auto platform = this->globalState.GetPlatformImpl()->p;
+
+    USC::SShaderStageBTLayout zeroLayout = USC::g_cZeroShaderStageBTLayout;
+    IGC::COCLBTILayout oclLayout(&zeroLayout);
+
+    TC::STB_TranslateOutputArgs output;
+    CIF::SafeZeroOut(output);
+
+    std::string RegKeysFlagsFromOptions;
+    if (inputArgs.pOptions != nullptr) {
+      std::string_view optionsWithFlags = inputArgs.pOptions;
+
+      // check if there are more instances of '-igc_opts'
+      while (!optionsWithFlags.empty()) {
+        std::size_t found = optionsWithFlags.find("-igc_opts");
+        if (found == std::string::npos)
+          break;
+
+        std::size_t foundFirstSingleQuote = optionsWithFlags.find('\'', found);
+        std::size_t foundSecondSingleQuote = optionsWithFlags.find('\'', foundFirstSingleQuote + 1);
+        if (foundFirstSingleQuote != std::string::npos && foundSecondSingleQuote) {
+          RegKeysFlagsFromOptions +=
+              optionsWithFlags.substr(foundFirstSingleQuote + 1, (foundSecondSingleQuote - foundFirstSingleQuote - 1));
+          RegKeysFlagsFromOptions = RegKeysFlagsFromOptions + ',';
+          optionsWithFlags = optionsWithFlags.substr(foundSecondSingleQuote + 1, optionsWithFlags.length());
         }
+      }
+    }
+    bool RegFlagNameError = 0;
+    LoadRegistryKeys(RegKeysFlagsFromOptions, &RegFlagNameError);
+    if (RegFlagNameError)
+      outputInterface->GetImpl()->SetError(
+          TranslationErrorType::Unused, "Invalid registry flag name in -igc_opts, at least one flag has been ignored");
+
+    IGC::CPlatform igcPlatform = this->globalState.GetIgcCPlatform();
+
+    // extra ocl options set from regkey
+    const char *extraOptions = IGC_GET_REGKEYSTRING(ExtraOCLOptions);
+    std::string combinedOptions;
+    if (extraOptions[0] != '\0') {
+      if (inputArgs.pOptions != nullptr) {
+        combinedOptions = std::string(inputArgs.pOptions) + ' ';
+      }
+      combinedOptions += extraOptions;
+      inputArgs.pOptions = combinedOptions.c_str();
+      inputArgs.OptionsSize = combinedOptions.size();
+    }
 
-        TC::STB_TranslateInputArgs inputArgs;
-        if(src != nullptr){
-            if (gtPinInput)
-            {
-                bool srcLine = enableSrcLine(gtPinInput);
-                if (srcLine)
-                {
-                    const char* arg = " -gline-tables-only";
-                    src->PushBackRawBytes(arg, strlen(arg));
-                }
-            }
-            inputArgs.pInput = src->GetMemoryWriteable<char>();
-            inputArgs.InputSize = static_cast<uint32_t>(src->GetSizeRaw());
-        }
-        if(options != nullptr){
-            inputArgs.pOptions = options->GetMemory<char>();
-            inputArgs.OptionsSize = static_cast<uint32_t>(options->GetSizeRaw());
-        }
-        if(internalOptions != nullptr){
-            inputArgs.pInternalOptions =  internalOptions->GetMemory<char>();
-            inputArgs.InternalOptionsSize = static_cast<uint32_t>(internalOptions->GetSizeRaw());
-        }
-        if(tracingOptions != nullptr){
-            inputArgs.pTracingOptions = tracingOptions->GetMemoryRawWriteable();
-        }
-        inputArgs.TracingOptionsCount = tracingOptionsCount;
-        if(specConstantsIds != nullptr && specConstantsValues != nullptr){
-            inputArgs.pSpecConstantsIds = specConstantsIds->GetMemory<uint32_t>();
-            inputArgs.SpecConstantsSize = static_cast<uint32_t>(specConstantsIds->GetSizeRaw() / sizeof(uint32_t));
-            inputArgs.pSpecConstantsValues = specConstantsValues->GetMemory<uint64_t>();
-        }
-        inputArgs.GTPinInput = gtPinInput;
-
-        CIF::Sanity::NotNullOrAbort(this->globalState.GetPlatformImpl());
-        auto platform = this->globalState.GetPlatformImpl()->p;
-
-        USC::SShaderStageBTLayout zeroLayout = USC::g_cZeroShaderStageBTLayout;
-        IGC::COCLBTILayout oclLayout(&zeroLayout);
-
-        TC::STB_TranslateOutputArgs output;
-        CIF::SafeZeroOut(output);
-
-        std::string RegKeysFlagsFromOptions;
-        if (inputArgs.pOptions != nullptr)
-        {
-            std::string_view optionsWithFlags = inputArgs.pOptions;
-
-            // check if there are more instances of '-igc_opts'
-            while (!optionsWithFlags.empty())
-            {
-                std::size_t found = optionsWithFlags.find("-igc_opts");
-                if (found == std::string::npos)
-                    break;
-
-                std::size_t foundFirstSingleQuote = optionsWithFlags.find('\'', found);
-                std::size_t foundSecondSingleQuote = optionsWithFlags.find('\'', foundFirstSingleQuote + 1);
-                if (foundFirstSingleQuote != std::string::npos && foundSecondSingleQuote)
-                {
-                    RegKeysFlagsFromOptions += optionsWithFlags.substr(foundFirstSingleQuote + 1, (foundSecondSingleQuote - foundFirstSingleQuote - 1));
-                    RegKeysFlagsFromOptions = RegKeysFlagsFromOptions + ',';
-                    optionsWithFlags = optionsWithFlags.substr(foundSecondSingleQuote + 1, optionsWithFlags.length());
-                }
-            }
-        }
-        bool RegFlagNameError = 0;
-        LoadRegistryKeys(RegKeysFlagsFromOptions, &RegFlagNameError);
-        if(RegFlagNameError) outputInterface->GetImpl()->SetError(TranslationErrorType::Unused, "Invalid registry flag name in -igc_opts, at least one flag has been ignored");
-
-        IGC::CPlatform igcPlatform = this->globalState.GetIgcCPlatform();
-
-        // extra ocl options set from regkey
-        const char *extraOptions = IGC_GET_REGKEYSTRING(ExtraOCLOptions);
-        std::string combinedOptions;
-        if (extraOptions[0] != '\0')
-        {
-            if (inputArgs.pOptions != nullptr)
-            {
-                combinedOptions = std::string(inputArgs.pOptions) + ' ';
-            }
-            combinedOptions += extraOptions;
-            inputArgs.pOptions = combinedOptions.c_str();
-            inputArgs.OptionsSize = combinedOptions.size();
-        }
+    // extra ocl internal options set from regkey
+    const char *extraInternlOptions = IGC_GET_REGKEYSTRING(ExtraOCLInternalOptions);
+    std::string combinedInternalOptions;
+    if (extraInternlOptions[0] != '\0') {
+      if (inputArgs.pInternalOptions != nullptr) {
+        combinedInternalOptions = std::string(inputArgs.pInternalOptions) + ' ';
+      }
+      combinedInternalOptions += extraInternlOptions;
+      inputArgs.pInternalOptions = combinedInternalOptions.c_str();
+      inputArgs.InternalOptionsSize = combinedInternalOptions.size();
+    }
 
-        // extra ocl internal options set from regkey
-        const char *extraInternlOptions = IGC_GET_REGKEYSTRING(ExtraOCLInternalOptions);
-        std::string combinedInternalOptions;
-        if (extraInternlOptions[0] != '\0')
-        {
-            if (inputArgs.pInternalOptions != nullptr)
-            {
-                combinedInternalOptions = std::string(inputArgs.pInternalOptions) + ' ';
-            }
-            combinedInternalOptions += extraInternlOptions;
-            inputArgs.pInternalOptions = combinedInternalOptions.c_str();
-            inputArgs.InternalOptionsSize = combinedInternalOptions.size();
+    bool success = false;
+    try {
+      if (this->inType == CodeType::elf) {
+        // Handle TB_DATA_FORMAT_ELF input as a result of a call to
+        // clLinkLibrary(). There are two possible scenarios, link input
+        // to form a new library (BC module) or link input to form an
+        // executable.
+
+        // First, link input modules together
+        CDriverInfo dummyDriverInfo;
+        IGC::OpenCLProgramContext oclContextTemp(oclLayout, igcPlatform, &inputArgs, dummyDriverInfo, nullptr, false);
+        IGC::Debug::RegisterComputeErrHandlers(*oclContextTemp.getLLVMContext());
+        success = TC::ProcessElfInput(inputArgs, output, oclContextTemp, platform, toLegacyFormat(this->outType),
+                                      this->globalState.MiscOptions.ProfilingTimerResolution);
+      } else {
+        if ((this->inType == CodeType::llvmLl) || (this->inType == CodeType::spirV) ||
+            (this->inType == CodeType::llvmBc)) {
+          TC::TB_DATA_FORMAT inFormatLegacy = toLegacyFormat(this->inType);
+          success = TC::TranslateBuild(&inputArgs, &output, inFormatLegacy, igcPlatform,
+                                       this->globalState.MiscOptions.ProfilingTimerResolution);
+        } else {
+          outputInterface->GetImpl()->SetError(TranslationErrorType::UnhandledInput, "Unhandled inType");
+          success = false;
         }
+      }
+    } catch (std::exception &e) {
+      success = false;
+      if (output.ErrorStringSize == 0 && output.pErrorString == nullptr) {
+        std::string msg = "IGC: ";
+        msg += e.what();
+        outputInterface->GetImpl()->SetError(TranslationErrorType::FailedCompilation, msg.c_str());
+      }
+    } catch (...) {
+      success = false;
+      if (output.ErrorStringSize == 0 && output.pErrorString == nullptr) {
+        outputInterface->GetImpl()->SetError(TranslationErrorType::FailedCompilation, "IGC: Internal Compiler Error");
+      }
+    }
 
-        bool success = false;
-        try
-        {
-            if (this->inType == CodeType::elf)
-            {
-                // Handle TB_DATA_FORMAT_ELF input as a result of a call to
-                // clLinkLibrary(). There are two possible scenarios, link input
-                // to form a new library (BC module) or link input to form an
-                // executable.
-
-                // First, link input modules together
-                CDriverInfo dummyDriverInfo;
-                IGC::OpenCLProgramContext oclContextTemp(oclLayout, igcPlatform, &inputArgs, dummyDriverInfo, nullptr, false);
-                IGC::Debug::RegisterComputeErrHandlers(*oclContextTemp.getLLVMContext());
-                success = TC::ProcessElfInput(
-                    inputArgs, output, oclContextTemp, platform,
-                    toLegacyFormat(this->outType),
-                    this->globalState.MiscOptions.ProfilingTimerResolution);
-            }
-            else
-            {
-                if ((this->inType == CodeType::llvmLl) ||
-                    (this->inType == CodeType::spirV) ||
-                    (this->inType == CodeType::llvmBc))
-                {
-                    TC::TB_DATA_FORMAT inFormatLegacy = toLegacyFormat(this->inType);
-                    success = TC::TranslateBuild(
-                        &inputArgs,
-                        &output,
-                        inFormatLegacy,
-                        igcPlatform,
-                        this->globalState.MiscOptions.ProfilingTimerResolution);
-                }
-                else
-                {
-                    outputInterface->GetImpl()->SetError(TranslationErrorType::UnhandledInput, "Unhandled inType");
-                    success = false;
-                }
-            }
-        }
-        catch (std::exception& e)
-        {
-            success = false;
-            if (output.ErrorStringSize == 0 && output.pErrorString == nullptr)
-            {
-                std::string msg = "IGC: ";
-                msg += e.what();
-                outputInterface->GetImpl()->SetError(TranslationErrorType::FailedCompilation, msg.c_str());
-            }
-        }
-        catch (...)
-        {
-            success = false;
-            if (output.ErrorStringSize == 0 && output.pErrorString == nullptr)
-            {
-                outputInterface->GetImpl()->SetError(TranslationErrorType::FailedCompilation, "IGC: Internal Compiler Error");
-            }
-        }
+    auto outputData = std::unique_ptr<char[]>(output.pOutput);
+    auto errorString = std::unique_ptr<char[]>(output.pErrorString);
+    auto debugData = std::unique_ptr<char[]>(output.pDebugData);
+
+    bool dataCopiedSuccessfuly = true;
+    if (success) {
+      dataCopiedSuccessfuly &= outputInterface->GetImpl()->AddWarning(output.pErrorString, output.ErrorStringSize);
+      dataCopiedSuccessfuly &= outputInterface->GetImpl()->CloneDebugData(output.pDebugData, output.DebugDataSize);
+      dataCopiedSuccessfuly &=
+          outputInterface->GetImpl()->SetSuccessfulAndCloneOutput(output.pOutput, output.OutputSize);
+    } else {
+      dataCopiedSuccessfuly &=
+          outputInterface->GetImpl()->SetError(TranslationErrorType::FailedCompilation, output.pErrorString);
+    }
 
-        auto outputData = std::unique_ptr<char[]>(output.pOutput);
-        auto errorString = std::unique_ptr<char[]>(output.pErrorString);
-        auto debugData = std::unique_ptr<char[]>(output.pDebugData);
-
-        bool dataCopiedSuccessfuly = true;
-        if(success){
-            dataCopiedSuccessfuly &= outputInterface->GetImpl()->AddWarning(output.pErrorString, output.ErrorStringSize);
-            dataCopiedSuccessfuly &= outputInterface->GetImpl()->CloneDebugData(output.pDebugData, output.DebugDataSize);
-            dataCopiedSuccessfuly &= outputInterface->GetImpl()->SetSuccessfulAndCloneOutput(output.pOutput, output.OutputSize);
-        }else{
-            dataCopiedSuccessfuly &= outputInterface->GetImpl()->SetError(TranslationErrorType::FailedCompilation, output.pErrorString);
-        }
+    if (dataCopiedSuccessfuly == false) {
+      return nullptr; // OOM
+    }
 
-        if(dataCopiedSuccessfuly == false){
-            return nullptr; // OOM
-        }
+    return outputInterface.release();
+  }
 
-        return outputInterface.release();
+  OCL_API_CALL OclTranslationOutputBase *GetErrorOutput(CIF::Version_t outVersion, unsigned int code) const {
+    auto outputInterface =
+        CIF::RAII::UPtr(CIF::InterfaceCreator<OclTranslationOutput>::CreateInterfaceVer(outVersion, this->outType));
+    if (outputInterface == nullptr) {
+      return nullptr; // OOM
     }
-
-    OCL_API_CALL OclTranslationOutputBase* GetErrorOutput(CIF::Version_t outVersion, unsigned int code) const
-    {
-        auto outputInterface = CIF::RAII::UPtr(CIF::InterfaceCreator<OclTranslationOutput>::CreateInterfaceVer(outVersion, this->outType));
-        if (outputInterface == nullptr) {
-            return nullptr; // OOM
-        }
-        const char* outputMessage;
-        switch (code) {
+    const char *outputMessage;
+    switch (code) {
 #if defined(WIN32)
-        case EXCEPTION_ACCESS_VIOLATION:
-            outputMessage = "IGC: Internal Compiler Error: Access violation";
-            break;
-        case EXCEPTION_DATATYPE_MISALIGNMENT:
-            outputMessage = "IGC: Internal Compiler Error: Datatype misalignement";
-            break;
-        case EXCEPTION_FLT_DIVIDE_BY_ZERO:
-        case EXCEPTION_INT_DIVIDE_BY_ZERO:
-            outputMessage = "IGC: Internal Compiler Error: Divide by zero";
-            break;
-        case EXCEPTION_STACK_OVERFLOW:
-            outputMessage = "IGC: Internal Compiler Error: Stack overflow";
-            break;
+    case EXCEPTION_ACCESS_VIOLATION:
+      outputMessage = "IGC: Internal Compiler Error: Access violation";
+      break;
+    case EXCEPTION_DATATYPE_MISALIGNMENT:
+      outputMessage = "IGC: Internal Compiler Error: Datatype misalignement";
+      break;
+    case EXCEPTION_FLT_DIVIDE_BY_ZERO:
+    case EXCEPTION_INT_DIVIDE_BY_ZERO:
+      outputMessage = "IGC: Internal Compiler Error: Divide by zero";
+      break;
+    case EXCEPTION_STACK_OVERFLOW:
+      outputMessage = "IGC: Internal Compiler Error: Stack overflow";
+      break;
 #else
-        case SIGABRT:
-            outputMessage = "IGC: Internal Compiler Error: Abnormal termination";
-            break;
-        case SIGFPE:
-            outputMessage = "IGC: Internal Compiler Error: Floating point exception";
-            break;
-        case SIGILL:
-            outputMessage = "IGC: Internal Compiler Error: Invalid instruction";
-            break;
-        case SIGINT:
-            outputMessage = "IGC: Internal Compiler Error: Interrupt request sent to the program";
-            break;
-        case SIGSEGV:
-            outputMessage = "IGC: Internal Compiler Error: Segmentation violation";
-            break;
-        case SIGTERM:
-            outputMessage = "IGC: Internal Compiler Error: Termination request sent to the program";
-            break;
+    case SIGABRT:
+      outputMessage = "IGC: Internal Compiler Error: Abnormal termination";
+      break;
+    case SIGFPE:
+      outputMessage = "IGC: Internal Compiler Error: Floating point exception";
+      break;
+    case SIGILL:
+      outputMessage = "IGC: Internal Compiler Error: Invalid instruction";
+      break;
+    case SIGINT:
+      outputMessage = "IGC: Internal Compiler Error: Interrupt request sent to the program";
+      break;
+    case SIGSEGV:
+      outputMessage = "IGC: Internal Compiler Error: Segmentation violation";
+      break;
+    case SIGTERM:
+      outputMessage = "IGC: Internal Compiler Error: Termination request sent to the program";
+      break;
 #endif
-        default:
-            outputMessage = "IGC: Internal Compiler Error: Signal caught";
-        }
-        if (outputInterface->GetImpl()->SetError(TranslationErrorType::Internal, outputMessage)) {
-            return outputInterface.release();
-        }
-        return nullptr;
+    default:
+      outputMessage = "IGC: Internal Compiler Error: Signal caught";
+    }
+    if (outputInterface->GetImpl()->SetError(TranslationErrorType::Internal, outputMessage)) {
+      return outputInterface.release();
     }
+    return nullptr;
+  }
 
 protected:
-    CIF_PIMPL(IgcOclDeviceCtx) &globalState;
-    CodeType::CodeType_t inType;
-    CodeType::CodeType_t outType;
+  CIF_PIMPL(IgcOclDeviceCtx) & globalState;
+  CodeType::CodeType_t inType;
+  CodeType::CodeType_t outType;
 };
 
 CIF_DEFINE_INTERFACE_TO_PIMPL_FORWARDING_CTOR_DTOR(IgcOclTranslationCtx);
 
-}
+} // namespace IGC
 
 #include "cif/macros/disable.h"
 
 #if defined(NDEBUG)
 #if defined(WIN32)
-OCL_API_CALL int ex_filter(unsigned int code, struct _EXCEPTION_POINTERS* ep);
+OCL_API_CALL int ex_filter(unsigned int code, struct _EXCEPTION_POINTERS *ep);
 
-#define EX_GUARD_BEGIN                                                        \
-__try                                                                         \
-{                                                                             \
+#define EX_GUARD_BEGIN __try {
 
-#define EX_GUARD_END                                                          \
-}                                                                             \
-__except (ex_filter(GetExceptionCode(), GetExceptionInformation()))           \
-{                                                                             \
-    TC::UnlockMutex();                                                        \
-    res = CIF_GET_PIMPL()->GetErrorOutput(outVersion, GetExceptionCode());    \
-}                                                                             \
+#define EX_GUARD_END                                                                                                   \
+  }                                                                                                                    \
+  __except (ex_filter(GetExceptionCode(), GetExceptionInformation())) {                                                \
+    TC::UnlockMutex();                                                                                                 \
+    res = CIF_GET_PIMPL()->GetErrorOutput(outVersion, GetExceptionCode());                                             \
+  }
 
 #else
-OCL_API_CALL void signalHandler(int sig, siginfo_t* info, void* ucontext);
+OCL_API_CALL void signalHandler(int sig, siginfo_t *info, void *ucontext);
 
 #include "igc_signal_guard.h"
 
-#define EX_GUARD_BEGIN                                                         \
-  do {                                                                         \
-    SET_SIG_HANDLER(SIGABRT)                                                   \
-    SET_SIG_HANDLER(SIGFPE)                                                    \
-    SET_SIG_HANDLER(SIGILL)                                                    \
-    SET_SIG_HANDLER(SIGINT)                                                    \
-    SET_SIG_HANDLER(SIGSEGV)                                                   \
-    SET_SIG_HANDLER(SIGTERM)                                                   \
-    int sig = setjmp(sig_jmp_buf);                                             \
+#define EX_GUARD_BEGIN                                                                                                 \
+  do {                                                                                                                 \
+    SET_SIG_HANDLER(SIGABRT)                                                                                           \
+    SET_SIG_HANDLER(SIGFPE)                                                                                            \
+    SET_SIG_HANDLER(SIGILL)                                                                                            \
+    SET_SIG_HANDLER(SIGINT)                                                                                            \
+    SET_SIG_HANDLER(SIGSEGV)                                                                                           \
+    SET_SIG_HANDLER(SIGTERM)                                                                                           \
+    int sig = setjmp(sig_jmp_buf);                                                                                     \
     if (sig == 0) {
 
-#define EX_GUARD_END                                                           \
-    } else {                                                                   \
-      TC::UnlockMutex();                                                       \
-      res = CIF_GET_PIMPL()->GetErrorOutput(outVersion, sig);                  \
-    }                                                                          \
-    REMOVE_SIG_HANDLER(SIGABRT)                                                \
-    REMOVE_SIG_HANDLER(SIGFPE)                                                 \
-    REMOVE_SIG_HANDLER(SIGILL)                                                 \
-    REMOVE_SIG_HANDLER(SIGINT)                                                 \
-    REMOVE_SIG_HANDLER(SIGSEGV)                                                \
-    REMOVE_SIG_HANDLER(SIGTERM)                                                \
-  } while (0);
+#define EX_GUARD_END                                                                                                   \
+  }                                                                                                                    \
+  else {                                                                                                               \
+    TC::UnlockMutex();                                                                                                 \
+    res = CIF_GET_PIMPL()->GetErrorOutput(outVersion, sig);                                                            \
+  }                                                                                                                    \
+  REMOVE_SIG_HANDLER(SIGABRT)                                                                                          \
+  REMOVE_SIG_HANDLER(SIGFPE)                                                                                           \
+  REMOVE_SIG_HANDLER(SIGILL)                                                                                           \
+  REMOVE_SIG_HANDLER(SIGINT)                                                                                           \
+  REMOVE_SIG_HANDLER(SIGSEGV)                                                                                          \
+  REMOVE_SIG_HANDLER(SIGTERM)                                                                                          \
+  }                                                                                                                    \
+  while (0)                                                                                                            \
+    ;
 
 #endif
 #else
diff --git a/include/igc/ocl_igc_interface/impl/igc_signal_guard.h b/include/igc/ocl_igc_interface/impl/igc_signal_guard.h
index 691c2e2..a2dade8 100644
--- a/include/igc/ocl_igc_interface/impl/igc_signal_guard.h
+++ b/include/igc/ocl_igc_interface/impl/igc_signal_guard.h
@@ -14,8 +14,7 @@ SPDX-License-Identifier: MIT
 namespace IGC::detail {
 class SignalGuard {
 public:
-  SignalGuard(int Signal, void (*Handler)(int, siginfo_t *, void *))
-      : Signal(Signal) {
+  SignalGuard(int Signal, void (*Handler)(int, siginfo_t *, void *)) : Signal(Signal) {
     sigaction(Signal, nullptr, &SAOld);
     struct sigaction SA{};
     sigemptyset(&SA.sa_mask);
@@ -24,9 +23,7 @@ class SignalGuard {
     sigaction(Signal, &SA, nullptr);
   }
 
-  ~SignalGuard() {
-    sigaction(Signal, &SAOld, nullptr);
-  }
+  ~SignalGuard() { sigaction(Signal, &SAOld, nullptr); }
 
   SignalGuard(const SignalGuard &) = delete;
   SignalGuard &operator=(const SignalGuard &) = delete;
@@ -37,8 +34,7 @@ class SignalGuard {
 }; // class SignalGuard
 } // namespace IGC::detail
 
-#define SET_SIG_HANDLER(SIG)                                                   \
-  ::IGC::detail::SignalGuard SG##SIG(SIG, signalHandler);
+#define SET_SIG_HANDLER(SIG) ::IGC::detail::SignalGuard SG##SIG(SIG, signalHandler);
 
 #define REMOVE_SIG_HANDLER(SIG) (void)SG##SIG;
 
diff --git a/include/igc/ocl_igc_interface/impl/ocl_gen_binary_impl.cpp b/include/igc/ocl_igc_interface/impl/ocl_gen_binary_impl.cpp
index 3295b2d..57ce915 100644
--- a/include/igc/ocl_igc_interface/impl/ocl_gen_binary_impl.cpp
+++ b/include/igc/ocl_igc_interface/impl/ocl_gen_binary_impl.cpp
@@ -11,8 +11,6 @@ SPDX-License-Identifier: MIT
 
 #include "cif/macros/enable.h"
 
-namespace IGC {
-
-}
+namespace IGC {}
 
 #include "cif/macros/disable.h"
diff --git a/include/igc/ocl_igc_interface/impl/ocl_gen_binary_impl.h b/include/igc/ocl_igc_interface/impl/ocl_gen_binary_impl.h
index 0324056..a6b8e28 100644
--- a/include/igc/ocl_igc_interface/impl/ocl_gen_binary_impl.h
+++ b/include/igc/ocl_igc_interface/impl/ocl_gen_binary_impl.h
@@ -19,14 +19,10 @@ SPDX-License-Identifier: MIT
 
 namespace IGC {
 
-CIF_DECLARE_INTERFACE_PIMPL(OclGenBinary) : CIF::PimplBase {
-  OCL_API_CALL CIF_PIMPL_DECLARE_CONSTRUCTOR()
-  {
-  }
-};
+CIF_DECLARE_INTERFACE_PIMPL(OclGenBinary) : CIF::PimplBase{OCL_API_CALL CIF_PIMPL_DECLARE_CONSTRUCTOR(){}};
 
 CIF_DEFINE_INTERFACE_TO_PIMPL_FORWARDING_CTOR_DTOR(OclGenBinary);
 
-}
+} // namespace IGC
 
 #include "cif/macros/disable.h"
diff --git a/include/igc/ocl_igc_interface/impl/ocl_translation_output_impl.cpp b/include/igc/ocl_igc_interface/impl/ocl_translation_output_impl.cpp
index 7da7c1e..95dcd5e 100644
--- a/include/igc/ocl_igc_interface/impl/ocl_translation_output_impl.cpp
+++ b/include/igc/ocl_igc_interface/impl/ocl_translation_output_impl.cpp
@@ -13,30 +13,29 @@ SPDX-License-Identifier: MIT
 
 namespace IGC {
 
-bool CIF_GET_INTERFACE_CLASS(OclTranslationOutput, 1)::Successful() const {
-  return CIF_GET_PIMPL()->Successful();
-}
+bool CIF_GET_INTERFACE_CLASS(OclTranslationOutput, 1)::Successful() const { return CIF_GET_PIMPL()->Successful(); }
 
-bool CIF_GET_INTERFACE_CLASS(OclTranslationOutput, 1)::HasWarnings() const {
-  return CIF_GET_PIMPL()->HasWarnings();
-}
+bool CIF_GET_INTERFACE_CLASS(OclTranslationOutput, 1)::HasWarnings() const { return CIF_GET_PIMPL()->HasWarnings(); }
 
-CIF::Builtins::BufferBase *CIF_GET_INTERFACE_CLASS(OclTranslationOutput, 1)::GetBuildLogImpl(CIF::Version_t bufferVersion){
-    return CIF_GET_PIMPL()->GetBuildLog(bufferVersion);
+CIF::Builtins::BufferBase *CIF_GET_INTERFACE_CLASS(OclTranslationOutput,
+                                                   1)::GetBuildLogImpl(CIF::Version_t bufferVersion) {
+  return CIF_GET_PIMPL()->GetBuildLog(bufferVersion);
 }
 
-CIF::Builtins::BufferBase *CIF_GET_INTERFACE_CLASS(OclTranslationOutput, 1)::GetOutputImpl(CIF::Version_t bufferVersion){
-    return CIF_GET_PIMPL()->GetOutput(bufferVersion);
+CIF::Builtins::BufferBase *CIF_GET_INTERFACE_CLASS(OclTranslationOutput,
+                                                   1)::GetOutputImpl(CIF::Version_t bufferVersion) {
+  return CIF_GET_PIMPL()->GetOutput(bufferVersion);
 }
 
-CIF::Builtins::BufferBase *CIF_GET_INTERFACE_CLASS(OclTranslationOutput, 1)::GetDebugDataImpl(CIF::Version_t bufferVersion){
-    return CIF_GET_PIMPL()->GetDebugData(bufferVersion);
+CIF::Builtins::BufferBase *CIF_GET_INTERFACE_CLASS(OclTranslationOutput,
+                                                   1)::GetDebugDataImpl(CIF::Version_t bufferVersion) {
+  return CIF_GET_PIMPL()->GetDebugData(bufferVersion);
 }
 
 CodeType::CodeType_t CIF_GET_INTERFACE_CLASS(OclTranslationOutput, 1)::GetOutputType() const {
   return CIF_GET_PIMPL()->GetOutputType();
 }
 
-}
+} // namespace IGC
 
 #include "cif/macros/disable.h"
diff --git a/include/igc/ocl_igc_interface/impl/ocl_translation_output_impl.h b/include/igc/ocl_igc_interface/impl/ocl_translation_output_impl.h
index 41dcce2..7c09abd 100644
--- a/include/igc/ocl_igc_interface/impl/ocl_translation_output_impl.h
+++ b/include/igc/ocl_igc_interface/impl/ocl_translation_output_impl.h
@@ -17,128 +17,105 @@ SPDX-License-Identifier: MIT
 #include "cif/macros/enable.h"
 #include "OCLAPI/oclapi.h"
 
-namespace IGC{
-
-struct TranslationErrorType
-{
-    using ErrorCode_t = uint64_t;
-    using ErrorCodeCoder = CIF::Coder<ErrorCode_t>;
-
-    static constexpr ErrorCode_t Success           = ErrorCodeCoder::Enc("E_SUCCESS");
-    static constexpr ErrorCode_t Internal          = ErrorCodeCoder::Enc("E_INTERNAL");
-    static constexpr ErrorCode_t Unused            = ErrorCodeCoder::Enc("E_UNUSED");
-    static constexpr ErrorCode_t Unknown           = ErrorCodeCoder::Enc("E_UNKNOWN");
-    static constexpr ErrorCode_t FailedCompilation = ErrorCodeCoder::Enc("E_FAIL_COMP");
-    static constexpr ErrorCode_t InvalidInput      = ErrorCodeCoder::Enc("E_INV_INPUT");
-    static constexpr ErrorCode_t UnhandledInput    = ErrorCodeCoder::Enc("E_UNH_INPUT");
+namespace IGC {
+
+struct TranslationErrorType {
+  using ErrorCode_t = uint64_t;
+  using ErrorCodeCoder = CIF::Coder<ErrorCode_t>;
+
+  static constexpr ErrorCode_t Success = ErrorCodeCoder::Enc("E_SUCCESS");
+  static constexpr ErrorCode_t Internal = ErrorCodeCoder::Enc("E_INTERNAL");
+  static constexpr ErrorCode_t Unused = ErrorCodeCoder::Enc("E_UNUSED");
+  static constexpr ErrorCode_t Unknown = ErrorCodeCoder::Enc("E_UNKNOWN");
+  static constexpr ErrorCode_t FailedCompilation = ErrorCodeCoder::Enc("E_FAIL_COMP");
+  static constexpr ErrorCode_t InvalidInput = ErrorCodeCoder::Enc("E_INV_INPUT");
+  static constexpr ErrorCode_t UnhandledInput = ErrorCodeCoder::Enc("E_UNH_INPUT");
 };
 
-CIF_DECLARE_INTERFACE_PIMPL(OclTranslationOutput) : CIF::PimplBase
-{
-    OCL_API_CALL CIF_PIMPL_DECLARE_CONSTRUCTOR(CodeType::CodeType_t OutputType)
-        : OutputType(OutputType), Error(TranslationErrorType::Unused)
-    {
-        BuildLog.CreateImpl();
-        Output.CreateImpl();
-        DebugData.CreateImpl();
-    }
+CIF_DECLARE_INTERFACE_PIMPL(OclTranslationOutput) : CIF::PimplBase {
+  OCL_API_CALL CIF_PIMPL_DECLARE_CONSTRUCTOR(CodeType::CodeType_t OutputType)
+      : OutputType(OutputType), Error(TranslationErrorType::Unused) {
+    BuildLog.CreateImpl();
+    Output.CreateImpl();
+    DebugData.CreateImpl();
+  }
 
-    OCL_API_CALL bool Successful() const
-    {
-        return Error == TranslationErrorType::Success;
-    }
+  OCL_API_CALL bool Successful() const { return Error == TranslationErrorType::Success; }
 
-    OCL_API_CALL bool HasWarnings() const
-    {
-        return false;
-    }
+  OCL_API_CALL bool HasWarnings() const { return false; }
 
-    OCL_API_CALL CIF::Builtins::BufferBase * GetBuildLog(CIF::Version_t bufferVersion)
-    {
-        return BuildLog.GetVersion(bufferVersion);
-    }
+  OCL_API_CALL CIF::Builtins::BufferBase *GetBuildLog(CIF::Version_t bufferVersion) {
+    return BuildLog.GetVersion(bufferVersion);
+  }
 
-    OCL_API_CALL CIF::Builtins::BufferBase * GetOutput(CIF::Version_t bufferVersion)
-    {
-        return Output.GetVersion(bufferVersion);
-    }
+  OCL_API_CALL CIF::Builtins::BufferBase *GetOutput(CIF::Version_t bufferVersion) {
+    return Output.GetVersion(bufferVersion);
+  }
 
-    OCL_API_CALL CIF::Builtins::BufferBase * GetDebugData(CIF::Version_t bufferVersion)
-    {
-        return DebugData.GetVersion(bufferVersion);
-    }
+  OCL_API_CALL CIF::Builtins::BufferBase *GetDebugData(CIF::Version_t bufferVersion) {
+    return DebugData.GetVersion(bufferVersion);
+  }
 
-    OCL_API_CALL CodeType::CodeType_t GetOutputType() const
-    {
-        return OutputType;
-    }
-
-    OCL_API_CALL bool SetError(TranslationErrorType::ErrorCode_t e, const char * errString = nullptr)
-    {
-        this->Error = e;
+  OCL_API_CALL CodeType::CodeType_t GetOutputType() const { return OutputType; }
 
-        if(errString == nullptr){
-            return true;
-        }
+  OCL_API_CALL bool SetError(TranslationErrorType::ErrorCode_t e, const char *errString = nullptr) {
+    this->Error = e;
 
-        auto len = strlen(errString);
-        return BuildLog->PushBackRawBytes(errString, len + 1);
+    if (errString == nullptr) {
+      return true;
     }
 
-    OCL_API_CALL bool AddWarning(const std::string & warnString)
-    {
-        return AddWarning(warnString.c_str(), warnString.size());
-    }
+    auto len = strlen(errString);
+    return BuildLog->PushBackRawBytes(errString, len + 1);
+  }
 
-    OCL_API_CALL bool AddWarning(const char * warn, size_t warnLength)
-    {
-        if((warn == nullptr) || (warnLength == 0)){
-            return true;
-        }
+  OCL_API_CALL bool AddWarning(const std::string &warnString) {
+    return AddWarning(warnString.c_str(), warnString.size());
+  }
 
-        if(BuildLog->GetSizeRaw() > 0){
-            char * lastChar = reinterpret_cast<char*>(BuildLog->GetMemoryRawWriteable()) + BuildLog->GetSizeRaw() - 1;
-            if(*lastChar == '\0'){
-                *lastChar = '\n';
-            }else{
-                if(BuildLog->PushBackRawCopy('\n') == false){
-                    return false;
-                }
-            }
-        }
-        if(BuildLog->PushBackRawBytes(warn, warnLength) == false){
-            return false;
-        }
-        char * lastChar = reinterpret_cast<char*>(BuildLog->GetMemoryRawWriteable()) + BuildLog->GetSizeRaw() - 1;
-        if(*lastChar != '\0'){
-            return BuildLog->PushBackRawCopy('\0');
-        }
-
-        return true;
+  OCL_API_CALL bool AddWarning(const char *warn, size_t warnLength) {
+    if ((warn == nullptr) || (warnLength == 0)) {
+      return true;
     }
 
-    template<typename T>
-    OCL_API_CALL bool SetSuccessfulAndCloneOutput(const T * data, size_t size)
-    {
-        this->Error = TranslationErrorType::Success;
-        return Output->PushBackRawBytes(data, size);
+    if (BuildLog->GetSizeRaw() > 0) {
+      char *lastChar = reinterpret_cast<char *>(BuildLog->GetMemoryRawWriteable()) + BuildLog->GetSizeRaw() - 1;
+      if (*lastChar == '\0') {
+        *lastChar = '\n';
+      } else {
+        if (BuildLog->PushBackRawCopy('\n') == false) {
+          return false;
+        }
+      }
     }
-
-    OCL_API_CALL bool CloneDebugData(const char * data, size_t size)
-    {
-        return DebugData->PushBackRawBytes(data, size);
+    if (BuildLog->PushBackRawBytes(warn, warnLength) == false) {
+      return false;
+    }
+    char *lastChar = reinterpret_cast<char *>(BuildLog->GetMemoryRawWriteable()) + BuildLog->GetSizeRaw() - 1;
+    if (*lastChar != '\0') {
+      return BuildLog->PushBackRawCopy('\0');
     }
 
+    return true;
+  }
+
+  template <typename T> OCL_API_CALL bool SetSuccessfulAndCloneOutput(const T *data, size_t size) {
+    this->Error = TranslationErrorType::Success;
+    return Output->PushBackRawBytes(data, size);
+  }
+
+  OCL_API_CALL bool CloneDebugData(const char *data, size_t size) { return DebugData->PushBackRawBytes(data, size); }
+
 protected:
-    CIF::Multiversion<CIF::Builtins::Buffer> BuildLog;
-    CIF::Multiversion<CIF::Builtins::Buffer> Output;
-    CIF::Multiversion<CIF::Builtins::Buffer> DebugData;
-    CodeType::CodeType_t OutputType;
-    TranslationErrorType::ErrorCode_t  Error;
+  CIF::Multiversion<CIF::Builtins::Buffer> BuildLog;
+  CIF::Multiversion<CIF::Builtins::Buffer> Output;
+  CIF::Multiversion<CIF::Builtins::Buffer> DebugData;
+  CodeType::CodeType_t OutputType;
+  TranslationErrorType::ErrorCode_t Error;
 };
 
 CIF_DEFINE_INTERFACE_TO_PIMPL_FORWARDING_CTOR_DTOR(OclTranslationOutput);
 
-}
+} // namespace IGC
 
 #include "cif/macros/disable.h"
diff --git a/include/igc/ocl_igc_interface/impl/platform_impl.cpp b/include/igc/ocl_igc_interface/impl/platform_impl.cpp
index 1aa45e5..e5f2e9b 100644
--- a/include/igc/ocl_igc_interface/impl/platform_impl.cpp
+++ b/include/igc/ocl_igc_interface/impl/platform_impl.cpp
@@ -19,33 +19,33 @@ namespace IGC {
 //
 // DEFINE_GET_SET as defined in igc_features_and_workarounds_impl.cpp cannot
 // handle complex objects.
-#define DEFINE_GET_SET_COMPLEX(INTERFACE, VERSION, NAME, TYPE, SOURCE)\
-    TYPE CIF_GET_INTERFACE_CLASS(INTERFACE, VERSION)::Get##NAME() const {\
-        return static_cast<TYPE>(CIF_GET_PIMPL()->p.SOURCE);\
-    }\
-    void CIF_GET_INTERFACE_CLASS(INTERFACE, VERSION)::Set##NAME(TYPE v) {\
-        CIF_GET_PIMPL()->p.SOURCE = static_cast<decltype(CIF_GET_PIMPL()->p.SOURCE)>(v);\
-    }
+#define DEFINE_GET_SET_COMPLEX(INTERFACE, VERSION, NAME, TYPE, SOURCE)                                                 \
+  TYPE CIF_GET_INTERFACE_CLASS(INTERFACE, VERSION)::Get##NAME() const {                                                \
+    return static_cast<TYPE>(CIF_GET_PIMPL()->p.SOURCE);                                                               \
+  }                                                                                                                    \
+  void CIF_GET_INTERFACE_CLASS(INTERFACE, VERSION)::Set##NAME(TYPE v) {                                                \
+    CIF_GET_PIMPL()->p.SOURCE = static_cast<decltype(CIF_GET_PIMPL()->p.SOURCE)>(v);                                   \
+  }
 
 // Interface version 1.
-DEFINE_GET_SET_COMPLEX(Platform, 1, ProductFamily,     TypeErasedEnum, eProductFamily);
-DEFINE_GET_SET_COMPLEX(Platform, 1, PCHProductFamily,  TypeErasedEnum, ePCHProductFamily);
+DEFINE_GET_SET_COMPLEX(Platform, 1, ProductFamily, TypeErasedEnum, eProductFamily);
+DEFINE_GET_SET_COMPLEX(Platform, 1, PCHProductFamily, TypeErasedEnum, ePCHProductFamily);
 DEFINE_GET_SET_COMPLEX(Platform, 1, DisplayCoreFamily, TypeErasedEnum, eDisplayCoreFamily);
-DEFINE_GET_SET_COMPLEX(Platform, 1, RenderCoreFamily,  TypeErasedEnum, eRenderCoreFamily);
-DEFINE_GET_SET_COMPLEX(Platform, 1, PlatformType,      TypeErasedEnum, ePlatformType);
-DEFINE_GET_SET_COMPLEX(Platform, 1, DeviceID,          unsigned short, usDeviceID);
-DEFINE_GET_SET_COMPLEX(Platform, 1, RevId,             unsigned short, usRevId);
-DEFINE_GET_SET_COMPLEX(Platform, 1, DeviceID_PCH,      unsigned short, usDeviceID_PCH);
-DEFINE_GET_SET_COMPLEX(Platform, 1, RevId_PCH,         unsigned short, usRevId_PCH);
-DEFINE_GET_SET_COMPLEX(Platform, 1, GTType,            TypeErasedEnum, eGTType);
+DEFINE_GET_SET_COMPLEX(Platform, 1, RenderCoreFamily, TypeErasedEnum, eRenderCoreFamily);
+DEFINE_GET_SET_COMPLEX(Platform, 1, PlatformType, TypeErasedEnum, ePlatformType);
+DEFINE_GET_SET_COMPLEX(Platform, 1, DeviceID, unsigned short, usDeviceID);
+DEFINE_GET_SET_COMPLEX(Platform, 1, RevId, unsigned short, usRevId);
+DEFINE_GET_SET_COMPLEX(Platform, 1, DeviceID_PCH, unsigned short, usDeviceID_PCH);
+DEFINE_GET_SET_COMPLEX(Platform, 1, RevId_PCH, unsigned short, usRevId_PCH);
+DEFINE_GET_SET_COMPLEX(Platform, 1, GTType, TypeErasedEnum, eGTType);
 
 // Interface version 2.
 //  Added Render/Media/Display block IDs
-DEFINE_GET_SET_COMPLEX(Platform, 2, RenderBlockID,     unsigned int,   sRenderBlockID.Value);
-DEFINE_GET_SET_COMPLEX(Platform, 2, MediaBlockID,      unsigned int,   sMediaBlockID.Value);
-DEFINE_GET_SET_COMPLEX(Platform, 2, DisplayBlockID,    unsigned int,   sDisplayBlockID.Value);
+DEFINE_GET_SET_COMPLEX(Platform, 2, RenderBlockID, unsigned int, sRenderBlockID.Value);
+DEFINE_GET_SET_COMPLEX(Platform, 2, MediaBlockID, unsigned int, sMediaBlockID.Value);
+DEFINE_GET_SET_COMPLEX(Platform, 2, DisplayBlockID, unsigned int, sDisplayBlockID.Value);
 
 #undef DEFINE_GET_SET_COMPLEX
-}
+} // namespace IGC
 
 #include "cif/macros/disable.h"
diff --git a/include/igc/ocl_igc_interface/impl/platform_impl.h b/include/igc/ocl_igc_interface/impl/platform_impl.h
index 41ab1d5..baccb79 100644
--- a/include/igc/ocl_igc_interface/impl/platform_impl.h
+++ b/include/igc/ocl_igc_interface/impl/platform_impl.h
@@ -21,16 +21,13 @@ SPDX-License-Identifier: MIT
 namespace IGC {
 
 CIF_DECLARE_INTERFACE_PIMPL(Platform) : CIF::PimplBase {
-  OCL_API_CALL CIF_PIMPL_DECLARE_CONSTRUCTOR()
-  {
-      memset(&p, 0, sizeof(p));
-  }
+  OCL_API_CALL CIF_PIMPL_DECLARE_CONSTRUCTOR() { memset(&p, 0, sizeof(p)); }
 
   PLATFORM p;
 };
 
 CIF_DEFINE_INTERFACE_TO_PIMPL_FORWARDING_CTOR_DTOR(Platform);
 
-}
+} // namespace IGC
 
 #include "cif/macros/disable.h"
diff --git a/include/igc/ocl_igc_interface/impl/version_in.h b/include/igc/ocl_igc_interface/impl/version_in.h
index 5179c44..0367f4a 100644
--- a/include/igc/ocl_igc_interface/impl/version_in.h
+++ b/include/igc/ocl_igc_interface/impl/version_in.h
@@ -6,7 +6,6 @@ SPDX-License-Identifier: MIT
 
 ============================= end_copyright_notice ===========================*/
 
-
 #ifndef IGC_VERSION_H
 #define IGC_VERSION_H
 
diff --git a/include/igc/ocl_igc_interface/ocl_gen_binary.h b/include/igc/ocl_igc_interface/ocl_gen_binary.h
index b2dac30..7409e68 100644
--- a/include/igc/ocl_igc_interface/ocl_gen_binary.h
+++ b/include/igc/ocl_igc_interface/ocl_gen_binary.h
@@ -27,9 +27,7 @@ CIF_DECLARE_INTERFACE(OclGenBinary, "OCL_GEN_BIN")
 
 // Default OCL GEN binary interface works only as 1:1 version checker,
 // but can be easily used for declaring backwards compatibility as well
-CIF_DEFINE_INTERFACE_VER(OclGenBinary, iOpenCL::CURRENT_ICBE_VERSION){
-  CIF_INHERIT_CONSTRUCTOR();
-};
+CIF_DEFINE_INTERFACE_VER(OclGenBinary, iOpenCL::CURRENT_ICBE_VERSION) { CIF_INHERIT_CONSTRUCTOR(); };
 
 CIF_GENERATE_VERSIONS_LIST_WITH_BASE(OclGenBinary, 1000);
 
@@ -37,6 +35,6 @@ CIF_MARK_LATEST_VERSION(OclGenBinaryLatest, OclGenBinary);
 using OclGenBinaryTagOCL = OclGenBinaryLatest; // Note : can tag with different version for
                                                //        transition periods
 
-}
+} // namespace IGC
 
 #include "cif/macros/disable.h"
diff --git a/include/igc/ocl_igc_interface/ocl_translation_output.h b/include/igc/ocl_igc_interface/ocl_translation_output.h
index 2e5f077..bf6c409 100644
--- a/include/igc/ocl_igc_interface/ocl_translation_output.h
+++ b/include/igc/ocl_igc_interface/ocl_translation_output.h
@@ -32,20 +32,18 @@ CIF_DEFINE_INTERFACE_VER(OclTranslationOutput, 1) {
   OCL_API_CALL virtual bool HasWarnings() const;
   OCL_API_CALL virtual CodeType::CodeType_t GetOutputType() const;
 
-  template <typename BufferInterface = CIF::Builtins::BufferLatest>
-  OCL_API_CALL BufferInterface *GetBuildLog() {
-    return static_cast<BufferInterface*>(GetBuildLogImpl(BufferInterface::GetVersion()));
+  template <typename BufferInterface = CIF::Builtins::BufferLatest> OCL_API_CALL BufferInterface *GetBuildLog() {
+    return static_cast<BufferInterface *>(GetBuildLogImpl(BufferInterface::GetVersion()));
   }
 
-  template <typename BufferInterface = CIF::Builtins::BufferLatest>
-  OCL_API_CALL BufferInterface *GetOutput() {
-    return static_cast<BufferInterface*>(GetOutputImpl(BufferInterface::GetVersion()));
+  template <typename BufferInterface = CIF::Builtins::BufferLatest> OCL_API_CALL BufferInterface *GetOutput() {
+    return static_cast<BufferInterface *>(GetOutputImpl(BufferInterface::GetVersion()));
   }
 
-  template <typename BufferInterface = CIF::Builtins::BufferLatest>
-  OCL_API_CALL BufferInterface *GetDebugData() {
-    return static_cast<BufferInterface*>(GetDebugDataImpl(BufferInterface::GetVersion()));
+  template <typename BufferInterface = CIF::Builtins::BufferLatest> OCL_API_CALL BufferInterface *GetDebugData() {
+    return static_cast<BufferInterface *>(GetDebugDataImpl(BufferInterface::GetVersion()));
   }
+
 protected:
   OCL_API_CALL virtual CIF::Builtins::BufferBase *GetBuildLogImpl(CIF::Version_t bufferVersion);
   OCL_API_CALL virtual CIF::Builtins::BufferBase *GetOutputImpl(CIF::Version_t bufferVersion);
@@ -57,6 +55,6 @@ CIF_MARK_LATEST_VERSION(OclTranslationOutputLatest, OclTranslationOutput);
 using OclTranslationOutputTagOCL = OclTranslationOutputLatest; // Note : can tag with different version for
                                                                //        transition periods
 
-}
+} // namespace IGC
 
 #include "cif/macros/disable.h"
diff --git a/include/igc/ocl_igc_interface/platform.h b/include/igc/ocl_igc_interface/platform.h
index ee507e0..42df1ce 100644
--- a/include/igc/ocl_igc_interface/platform.h
+++ b/include/igc/ocl_igc_interface/platform.h
@@ -24,7 +24,7 @@ using TypeErasedEnum = uint64_t;
 
 CIF_DECLARE_INTERFACE(Platform, "PLATFORM")
 
-CIF_DEFINE_INTERFACE_VER(Platform, 1){
+CIF_DEFINE_INTERFACE_VER(Platform, 1) {
   CIF_INHERIT_CONSTRUCTOR();
 
   OCL_API_CALL virtual TypeErasedEnum GetProductFamily() const;
@@ -66,6 +66,6 @@ CIF_GENERATE_VERSIONS_LIST(Platform);
 CIF_MARK_LATEST_VERSION(PlatformLatest, Platform);
 using PlatformTagOCL = Platform<2>; // Note : can tag with different version for
                                     //        transition periods
-}
+} // namespace IGC
 
 #include "cif/macros/disable.h"
diff --git a/include/igc/ocl_igc_interface/platform_helper.h b/include/igc/ocl_igc_interface/platform_helper.h
index dc29f0c..208b8d5 100644
--- a/include/igc/ocl_igc_interface/platform_helper.h
+++ b/include/igc/ocl_igc_interface/platform_helper.h
@@ -14,16 +14,14 @@ SPDX-License-Identifier: MIT
 #include "ocl_igc_interface/platform.h"
 #include "OCLAPI/oclapi.h"
 
-#define COPY_VAL(INTEFACE_VAL_NAME, SRC_VAL_NAME)                              \
-  dst.Set##INTEFACE_VAL_NAME(src.SRC_VAL_NAME)
+#define COPY_VAL(INTEFACE_VAL_NAME, SRC_VAL_NAME) dst.Set##INTEFACE_VAL_NAME(src.SRC_VAL_NAME)
 #define COPY_VAL_E(VAL_NAME) dst.Set##VAL_NAME(src.e##VAL_NAME)
 #define COPY_VAL_EXACT(VAL_NAME) dst.Set##VAL_NAME(src.VAL_NAME)
 
 namespace IGC {
 namespace PlatformHelper {
 template <CIF::Version_t Ver, typename SrcStructT>
-OCL_API_CALL inline void PopulateInterfaceWith(IGC::Platform<Ver> &dst,
-                                   const SrcStructT &src) {
+OCL_API_CALL inline void PopulateInterfaceWith(IGC::Platform<Ver> &dst, const SrcStructT &src) {
   COPY_VAL_E(ProductFamily);
   COPY_VAL_E(PCHProductFamily);
   COPY_VAL_E(DisplayCoreFamily);
@@ -37,8 +35,7 @@ OCL_API_CALL inline void PopulateInterfaceWith(IGC::Platform<Ver> &dst,
 }
 
 template <typename SrcStructT>
-OCL_API_CALL inline void PopulateInterfaceWith(IGC::Platform<2>& dst,
-                                  const SrcStructT& src) {
+OCL_API_CALL inline void PopulateInterfaceWith(IGC::Platform<2> &dst, const SrcStructT &src) {
   PopulateInterfaceWith<1>(dst, src);
   // Below COPY_VALs are not valid. NEO will populate *BlockID values
   // by calling the setters directly
@@ -46,12 +43,11 @@ OCL_API_CALL inline void PopulateInterfaceWith(IGC::Platform<2>& dst,
   // COPY_VAL(MediaBlockID, sMediaBlockID.Value);
   // COPY_VAL(DisplayBlockID, sDisplayBlockID.Value);
 }
-}
+} // namespace PlatformHelper
 
 namespace GtSysInfoHelper {
 template <CIF::Version_t Ver, typename SrcStructT>
-OCL_API_CALL inline void PopulateInterfaceWith(IGC::GTSystemInfo<Ver> &dst,
-                                  const SrcStructT &src) {
+OCL_API_CALL inline void PopulateInterfaceWith(IGC::GTSystemInfo<Ver> &dst, const SrcStructT &src) {
   COPY_VAL_EXACT(EUCount);
   COPY_VAL_EXACT(ThreadCount);
   COPY_VAL_EXACT(SliceCount);
@@ -82,32 +78,28 @@ OCL_API_CALL inline void PopulateInterfaceWith(IGC::GTSystemInfo<Ver> &dst,
 }
 
 template <typename SrcStructT>
-OCL_API_CALL inline void PopulateInterfaceWith(IGC::GTSystemInfo<3>& dst,
-                                  const SrcStructT& src) {
+OCL_API_CALL inline void PopulateInterfaceWith(IGC::GTSystemInfo<3> &dst, const SrcStructT &src) {
   PopulateInterfaceWith<1>(dst, src);
   COPY_VAL_EXACT(MaxDualSubSlicesSupported);
   COPY_VAL_EXACT(DualSubSliceCount);
 }
 
 template <typename SrcStructT>
-OCL_API_CALL inline void PopulateInterfaceWith(IGC::GTSystemInfo<4>& dst,
-                                  const SrcStructT& src) {
+OCL_API_CALL inline void PopulateInterfaceWith(IGC::GTSystemInfo<4> &dst, const SrcStructT &src) {
   PopulateInterfaceWith<SrcStructT>(static_cast<IGC::GTSystemInfo<3> &>(dst), src);
   COPY_VAL_EXACT(SLMSizeInKb);
 }
 
 template <typename SrcStructT>
-OCL_API_CALL inline void PopulateInterfaceWith(IGC::GTSystemInfo<5>& dst,
-                                  const SrcStructT& src) {
+OCL_API_CALL inline void PopulateInterfaceWith(IGC::GTSystemInfo<5> &dst, const SrcStructT &src) {
   PopulateInterfaceWith<SrcStructT>(static_cast<IGC::GTSystemInfo<4> &>(dst), src);
 }
 
-}
+} // namespace GtSysInfoHelper
 
 namespace IgcPlatformFeaturesHelper {
 template <CIF::Version_t Ver, typename SrcStructT>
-OCL_API_CALL inline void PopulateInterfaceWith(IGC::IgcFeaturesAndWorkarounds<Ver> &dst,
-                                  const SrcStructT &src) {
+OCL_API_CALL inline void PopulateInterfaceWith(IGC::IgcFeaturesAndWorkarounds<Ver> &dst, const SrcStructT &src) {
   COPY_VAL_EXACT(FtrDesktop);
   COPY_VAL_EXACT(FtrChannelSwizzlingXOREnabled);
 
@@ -138,8 +130,8 @@ OCL_API_CALL inline void PopulateInterfaceWith(IGC::IgcFeaturesAndWorkarounds<Ve
 
   COPY_VAL_EXACT(FtrResourceStreamer);
 }
-}
-}
+} // namespace IgcPlatformFeaturesHelper
+} // namespace IGC
 
 #undef COPY_VAL_EXACT
 #undef COPY_VAL_E
diff --git a/include/igc/ocl_igc_shared/device_enqueue/DeviceEnqueueInternalTypes.h b/include/igc/ocl_igc_shared/device_enqueue/DeviceEnqueueInternalTypes.h
index 7de13e5..ad8f0ec 100644
--- a/include/igc/ocl_igc_shared/device_enqueue/DeviceEnqueueInternalTypes.h
+++ b/include/igc/ocl_igc_shared/device_enqueue/DeviceEnqueueInternalTypes.h
@@ -13,47 +13,45 @@ Notes: Common file that will be used for C99 device enqueue kernels and Runtime
 #ifndef DEVICE_ENQUEUE_INTERNAL_TYPES_H
 #define DEVICE_ENQUEUE_INTERNAL_TYPES_H
 
-#define IGIL_KERNEL_ID_ENQUEUE_MARKER               -1
+#define IGIL_KERNEL_ID_ENQUEUE_MARKER -1
 
 // IGIL Event Flags
-#define IGIL_EVENT_UNUSED                           -501
-#define IGIL_EVENT_QUEUED                           -502
-#define IGIL_EVENT_INVALID_HANDLE                   0xffffffff
+#define IGIL_EVENT_UNUSED -501
+#define IGIL_EVENT_QUEUED -502
+#define IGIL_EVENT_INVALID_HANDLE 0xffffffff
 
 // IGIL Event Types
-#define IGIL_EVENT_TYPE_NORMAL                      0x0
-#define IGIL_EVENT_TYPE_USER                        0x1
-#define IGIL_EVENT_TYPE_PROFILING                   0x2
+#define IGIL_EVENT_TYPE_NORMAL 0x0
+#define IGIL_EVENT_TYPE_USER 0x1
+#define IGIL_EVENT_TYPE_PROFILING 0x2
 
 // Canary values
-#define IGIL_MAGIC_NUMBER                           0x494E5443
-#define IGIL_COMMAND_MAGIC_NUMBER                   0x494E544347505500
+#define IGIL_MAGIC_NUMBER 0x494E5443
+#define IGIL_COMMAND_MAGIC_NUMBER 0x494E544347505500
 
 //!!! Make sure value of this define equals PARALLEL_SCHEDULER_HW_GROUPS in DeviceEnqueue.h
-#define MAX_NUMBER_OF_PARALLEL_GPGPU_WALKERS        ( 64 )
-#define MAX_NUMBER_OF_ENQUEUE_MARKER                ( 128 )
-#define MAX_NUMBER_OF_EVENTS_TO_UPDATE              ( MAX_NUMBER_OF_PARALLEL_GPGPU_WALKERS + MAX_NUMBER_OF_ENQUEUE_MARKER )
+#define MAX_NUMBER_OF_PARALLEL_GPGPU_WALKERS (64)
+#define MAX_NUMBER_OF_ENQUEUE_MARKER (128)
+#define MAX_NUMBER_OF_EVENTS_TO_UPDATE (MAX_NUMBER_OF_PARALLEL_GPGPU_WALKERS + MAX_NUMBER_OF_ENQUEUE_MARKER)
 
+// timestamp written by pipe control needs to be multipled by 80 ns, TODO : this is different on SKL and BXT. code needs
+// to be added to handle them correctly.
+#define PROFILING_TIMER_RESOLUTION 80
+// timestamp value is written on 36 bits
+#define PROFILING_MAX_TIMER_VALUE 0xFFFFFFFFF
 
-//timestamp written by pipe control needs to be multipled by 80 ns, TODO : this is different on SKL and BXT. code needs to be added to handle them correctly.
-#define    PROFILING_TIMER_RESOLUTION                                                   80
-//timestamp value is written on 36 bits
-#define    PROFILING_MAX_TIMER_VALUE                                                    0xFFFFFFFFF
+#define exec_offsetof(x, y) (int)(&((x *)(0))->y)
 
-#define exec_offsetof( x, y ) (int)(&((x*)(0))->y)
-
-typedef union ptr64_t
-{
-    long*  m_ptr;
-    ulong  m_value;
+typedef union ptr64_t {
+  long *m_ptr;
+  ulong m_value;
 } IGIL_ptr64_t;
 
-typedef struct
-{
-    uint  m_dispatchDimensions;
-    ulong m_globalWorkOffset[3];
-    ulong m_globalWorkSize[3];
-    ulong m_localWorkSize[3];
+typedef struct {
+  uint m_dispatchDimensions;
+  ulong m_globalWorkOffset[3];
+  ulong m_globalWorkSize[3];
+  ulong m_localWorkSize[3];
 } IGIL_ndrange_t;
 
 typedef int IGIL_clk_event_t;
@@ -61,213 +59,208 @@ typedef int IGIL_clk_event_t;
 typedef int IGIL_kernel_enqueue_flags_t;
 
 // internal device representation of an event
-typedef struct
-{
-    uint m_state;                   // unused, queued, submitted, running, complete.
-    uint m_eventType;               // user event, profiling enabled...
-    int m_refCount;                 // enqueues that depend on this event. free event when all 0: {refCount, numChildren, numDependents}
-    int m_numChildren;              // this event triggers success when all children complete
-    int m_numDependents;            // number of events waiting for this event to reach CL_COMPLETE
-    uint m_parentEvent;             // when this child completes (m_numChildren=0):
-                                    //   1. set state = CL_COMPLETE
-                                    //   2. decrement the parent's m_numChildren (if parent valid)
-                                    //   3. if parent's numChildren == 0, goto #1
-    //!!!!! make sure that profiling variables are aligned to 64 bits, be extremly precaucious when modifiying this structure, in case of broken alignement PIPE CONTROL will write to wrong offset!!!!!!
-    ulong m_profilingCmdStart;      // timestamp when this command starts -> it is event returned by some enqueue and timestamp start for this is after scheduler which enqueued this cmd
-    ulong m_profilingCmdEnd;        // timestamp when this command ends -> timestamp write after kernel directly associated with this event.
-    ulong m_profilingCmdComplete;   // timestamp when this event is complete, all childs are done, so when this event transitions to CL_COMPLETE.
-    ulong m_pProfiling;      // address to write profiling info to (if enabled) //turned off becasue of pointer size problems todo:resolve
+typedef struct {
+  uint m_state;     // unused, queued, submitted, running, complete.
+  uint m_eventType; // user event, profiling enabled...
+  int m_refCount;   // enqueues that depend on this event. free event when all 0: {refCount, numChildren, numDependents}
+  int m_numChildren;   // this event triggers success when all children complete
+  int m_numDependents; // number of events waiting for this event to reach CL_COMPLETE
+  uint m_parentEvent;  // when this child completes (m_numChildren=0):
+                       //   1. set state = CL_COMPLETE
+                       //   2. decrement the parent's m_numChildren (if parent valid)
+                       //   3. if parent's numChildren == 0, goto #1
+  //!!!!! make sure that profiling variables are aligned to 64 bits, be extremly precaucious when modifiying this
+  //!structure, in case of broken alignement PIPE CONTROL will write to wrong offset!!!!!!
+  ulong m_profilingCmdStart; // timestamp when this command starts -> it is event returned by some enqueue and timestamp
+                             // start for this is after scheduler which enqueued this cmd
+  ulong m_profilingCmdEnd; // timestamp when this command ends -> timestamp write after kernel directly associated with
+                           // this event.
+  ulong m_profilingCmdComplete; // timestamp when this event is complete, all childs are done, so when this event
+                                // transitions to CL_COMPLETE.
+  ulong m_pProfiling; // address to write profiling info to (if enabled) //turned off becasue of pointer size problems
+                      // todo:resolve
 } IGIL_DeviceEvent;
 
 // internal device event pool representation
-typedef struct
-{
-    ulong m_CLcompleteTimestamp;    // only scheduler updates state of events, here is timestamp used for profiling to indicate when this transition happened.
-    float m_TimestampResolution;    // resolution of the timestamp counter
-    uint m_padding;                 // padding is needed because of alignment requirements for events
-    uint m_head;                    // pool head point in IGIL_DeviceEvent units (0 means first event)
-    uint m_size;                    // number of events there is space for after m_size
-    // variable legnth part starts here
-    //  m_size * sizeof(IGIL_DeviceEvent) bytes long
+typedef struct {
+  ulong m_CLcompleteTimestamp; // only scheduler updates state of events, here is timestamp used for profiling to
+                               // indicate when this transition happened.
+  float m_TimestampResolution; // resolution of the timestamp counter
+  uint m_padding;              // padding is needed because of alignment requirements for events
+  uint m_head;                 // pool head point in IGIL_DeviceEvent units (0 means first event)
+  uint m_size;                 // number of events there is space for after m_size
+                               // variable legnth part starts here
+                               //  m_size * sizeof(IGIL_DeviceEvent) bytes long
 } IGIL_EventPool;
 
 // internal device enqueue command representation
-typedef struct
-{
-    uint   m_commandSize;           // size in bytes, including variable part and padding to 64bytes and sizeof(IGIL_CommandHeader)
-    ulong  m_magic;                 // 'I' 'N' 'T' 'C' 'G' 'P' 'U' canary
-    int    m_kernelId;              // this value will be used to choose kernel for GPGPU walker.
-    IGIL_ndrange_t    m_range;      // real version would have dimensions, offsets, multiple ranges
-    IGIL_clk_event_t  m_event;      // handle to event associated with this command, if any
-    uint   m_numScalarArguments;    // number of scalars to patch in curbe including values
-    uint   m_sizeOfScalarArguments; // size of scalars. TODO : needed?
-    uint   m_numOfLocalPtrSizes;    // number of local sizes passed into m_data
-    uint   m_totalLocalSize;        // total amount of SLM used within kernel.
-    uint   m_numGlobalCapturedBuffer; // total number of global buffer passes from parent to child
-    uint   m_numDependencies;       // events this command depends on. handles to them will be the first members of m_args
-    uint   m_commandState;          // command state , may not be needed.
-    IGIL_kernel_enqueue_flags_t m_enqueueFlags;    // flags that were used during enqueue
-    uint   m_numGlobalArguments;    //total number of global arguments passed as kernel arguments, excluding global pointers.
-    uint   m_data[1];
-    // variable length part starts here
-    //   Event Data: # number of events of size sizeof(clk_event_t) store events IDS ( m_numDependencies )
-    //   Scalar Captured Variable Data: # number of scalar kernel arguments with values ( m_numScalarArguments )
-    //   Global UAV Argument Data: arg number associated with each of the global memory pointer
-    //                             size of each argument is 2B. size: m_numGlobalCapturedBuffer * 2
-    //   Global UAV Address Data: address of global mem surfaces: uav address(64 bit).
-    //                        size: m_numGlobalCapturedBuffer * 8
-    //   Local: # number of local surfaces sizes ( DWORD each )
-    //   Global arguments data : arn number associated with each of the global memory argument
-    //   Global argument unique id : argument unique ID that can identify this resource.
+typedef struct {
+  uint m_commandSize; // size in bytes, including variable part and padding to 64bytes and sizeof(IGIL_CommandHeader)
+  ulong m_magic;      // 'I' 'N' 'T' 'C' 'G' 'P' 'U' canary
+  int m_kernelId;     // this value will be used to choose kernel for GPGPU walker.
+  IGIL_ndrange_t m_range;         // real version would have dimensions, offsets, multiple ranges
+  IGIL_clk_event_t m_event;       // handle to event associated with this command, if any
+  uint m_numScalarArguments;      // number of scalars to patch in curbe including values
+  uint m_sizeOfScalarArguments;   // size of scalars. TODO : needed?
+  uint m_numOfLocalPtrSizes;      // number of local sizes passed into m_data
+  uint m_totalLocalSize;          // total amount of SLM used within kernel.
+  uint m_numGlobalCapturedBuffer; // total number of global buffer passes from parent to child
+  uint m_numDependencies;         // events this command depends on. handles to them will be the first members of m_args
+  uint m_commandState;            // command state , may not be needed.
+  IGIL_kernel_enqueue_flags_t m_enqueueFlags; // flags that were used during enqueue
+  uint m_numGlobalArguments; // total number of global arguments passed as kernel arguments, excluding global pointers.
+  uint m_data[1];
+  // variable length part starts here
+  //   Event Data: # number of events of size sizeof(clk_event_t) store events IDS ( m_numDependencies )
+  //   Scalar Captured Variable Data: # number of scalar kernel arguments with values ( m_numScalarArguments )
+  //   Global UAV Argument Data: arg number associated with each of the global memory pointer
+  //                             size of each argument is 2B. size: m_numGlobalCapturedBuffer * 2
+  //   Global UAV Address Data: address of global mem surfaces: uav address(64 bit).
+  //                        size: m_numGlobalCapturedBuffer * 8
+  //   Local: # number of local surfaces sizes ( DWORD each )
+  //   Global arguments data : arn number associated with each of the global memory argument
+  //   Global argument unique id : argument unique ID that can identify this resource.
 } IGIL_CommandHeader;
 
 // intneral device controls/flags
-typedef struct
-{
-    uint m_StackSize;
-    uint m_StackTop;
-    uint m_PreviousHead;
-    uint m_TotalNumberOfQueues;
-    uint m_SecondLevelBatchOffset;
-    uint m_PreviousNumberOfQueues;
-    uint m_LastScheduleEventNumber;
-    uint m_IsProfilingEnabled;
-    uint m_DebugNextBlockID;
-    uint m_DebugNextBlockGWS;
-    uint m_DebugParentEvent;
-    uint m_SchedulerConstantBufferSize;
-    uint m_SchedulerDSHOffset;
-    uint m_DynamicHeapSizeInBytes;
-    uint m_DynamicHeapStart;
-    uint m_IDTstart;
-    uint m_QstorageSize;
-    uint m_QstorageTop;
-    ulong m_EventTimestampAddress;
-    uint m_CurrentIDToffset;
-    uint m_CurrentDSHoffset;
-    uint m_PreviousStorageTop;
-    uint m_PreviousStackTop;
-    uint m_IDTAfterFirstPhase;
-    uint m_CurrentScheduleEventNumber;
-    uint m_EnqueueMarkerScheduled;
-    ulong m_DummyAtomicOperationPlaceholder;
-    uint m_StartBlockID;
-    int m_SLBENDoffsetInBytes;
-    uint m_BTbaseOffset;
-    uint m_BTmaxSize;
-    uint m_CurrentSSHoffset;
-    uint m_ErrorCode;
-    uint m_CriticalSection;
-    uint m_ParentDSHOffset;         // Offset to DSH in DSHMemInfo.pBuffer
-    IGIL_clk_event_t m_EventDependencies[ MAX_NUMBER_OF_EVENTS_TO_UPDATE ];
-    ulong m_CleanupSectionAddress;
-    uint m_CleanupSectionSize;
-    uint m_IsSimulation;
-    //temporary place for experiments.
-    uint m_SchedulerEarlyReturnCounter;
-    uint m_SchedulerEarlyReturn;
-    uint Temporary[10];//for debug
+typedef struct {
+  uint m_StackSize;
+  uint m_StackTop;
+  uint m_PreviousHead;
+  uint m_TotalNumberOfQueues;
+  uint m_SecondLevelBatchOffset;
+  uint m_PreviousNumberOfQueues;
+  uint m_LastScheduleEventNumber;
+  uint m_IsProfilingEnabled;
+  uint m_DebugNextBlockID;
+  uint m_DebugNextBlockGWS;
+  uint m_DebugParentEvent;
+  uint m_SchedulerConstantBufferSize;
+  uint m_SchedulerDSHOffset;
+  uint m_DynamicHeapSizeInBytes;
+  uint m_DynamicHeapStart;
+  uint m_IDTstart;
+  uint m_QstorageSize;
+  uint m_QstorageTop;
+  ulong m_EventTimestampAddress;
+  uint m_CurrentIDToffset;
+  uint m_CurrentDSHoffset;
+  uint m_PreviousStorageTop;
+  uint m_PreviousStackTop;
+  uint m_IDTAfterFirstPhase;
+  uint m_CurrentScheduleEventNumber;
+  uint m_EnqueueMarkerScheduled;
+  ulong m_DummyAtomicOperationPlaceholder;
+  uint m_StartBlockID;
+  int m_SLBENDoffsetInBytes;
+  uint m_BTbaseOffset;
+  uint m_BTmaxSize;
+  uint m_CurrentSSHoffset;
+  uint m_ErrorCode;
+  uint m_CriticalSection;
+  uint m_ParentDSHOffset; // Offset to DSH in DSHMemInfo.pBuffer
+  IGIL_clk_event_t m_EventDependencies[MAX_NUMBER_OF_EVENTS_TO_UPDATE];
+  ulong m_CleanupSectionAddress;
+  uint m_CleanupSectionSize;
+  uint m_IsSimulation;
+  // temporary place for experiments.
+  uint m_SchedulerEarlyReturnCounter;
+  uint m_SchedulerEarlyReturn;
+  uint Temporary[10]; // for debug
 } IGIL_ExecutionControls;
 
 // internal device command queue representation
-typedef struct
-{
-    uint m_magic;            // 'I' 'N' 'T' C'
-    uint m_head;             // next free location in the queue
-    uint m_size;             // size of the queue in bytes
-    IGIL_ExecutionControls m_controls;
+typedef struct {
+  uint m_magic; // 'I' 'N' 'T' C'
+  uint m_head;  // next free location in the queue
+  uint m_size;  // size of the queue in bytes
+  IGIL_ExecutionControls m_controls;
 
-    // The header must be aligned to sizeof(IGIL_CommandHeader)
+  // The header must be aligned to sizeof(IGIL_CommandHeader)
 
-    // variable length part starts here
-    // m_size bytes used to fill
+  // variable length part starts here
+  // m_size bytes used to fill
 } IGIL_CommandQueue;
 
-typedef struct
-{
-    uint m_parameterType;
-    uint m_parameterSize;
-    uint m_patchOffset;
-    uint m_sourceOffset; // for tokens that use 3 dimensions, 0 , 4, 8 indicates dimension
+typedef struct {
+  uint m_parameterType;
+  uint m_parameterSize;
+  uint m_patchOffset;
+  uint m_sourceOffset; // for tokens that use 3 dimensions, 0 , 4, 8 indicates dimension
 } IGIL_KernelCurbeParams;
-typedef struct
-{
-    uint            m_KernelDataOffset;
-    uint            m_SamplerHeapOffset;       // Offset to SamplerHeap ( BorderColorState and SamplerStateArray ) on KRS
-    uint            m_SamplerParamsOffset;
-    uint            m_ConstantBufferOffset;
-    uint            m_SSHTokensOffset;
-    uint            m_BTSoffset;
-    uint            m_BTSize;
-}IGIL_KernelAddressData;
-typedef struct
-{
-    uint                      m_numberOfCurbeParams; // number of paramters to patch
-    uint                      m_numberOfCurbeTokens;
-    uint                      m_numberOfSamplerStates;
-    uint                      m_SizeOfSamplerHeap;              // BorderColorState with SamplerStateArray
-    uint                      m_SamplerBorderColorStateOffsetOnDSH;    // Offset to SamplerStateArray on block's DSH
-    uint                      m_SamplerStateArrayOffsetOnDSH;    // Offset to SamplerStateArray on block's DSH
-    uint                      m_sizeOfConstantBuffer;
-    ulong                     m_PatchTokensMask;
-    ulong                     m_ScratchSpacePatchValue;
-    uint                      m_SIMDSize;
-    uint                      m_HasBarriers;
-    uint                      m_RequiredWkgSizes[3];
-    uint                      m_InilineSLMSize;
-    uint                      m_NeedLocalIDS;
-    uint                      m_PayloadSize;
-    uint                      m_DisablePreemption;
-    uint                      m_CanRunConcurently;
-    IGIL_KernelCurbeParams    m_data[1]; //IGIL_KernelCurbeParams
+typedef struct {
+  uint m_KernelDataOffset;
+  uint m_SamplerHeapOffset; // Offset to SamplerHeap ( BorderColorState and SamplerStateArray ) on KRS
+  uint m_SamplerParamsOffset;
+  uint m_ConstantBufferOffset;
+  uint m_SSHTokensOffset;
+  uint m_BTSoffset;
+  uint m_BTSize;
+} IGIL_KernelAddressData;
+typedef struct {
+  uint m_numberOfCurbeParams; // number of paramters to patch
+  uint m_numberOfCurbeTokens;
+  uint m_numberOfSamplerStates;
+  uint m_SizeOfSamplerHeap;                  // BorderColorState with SamplerStateArray
+  uint m_SamplerBorderColorStateOffsetOnDSH; // Offset to SamplerStateArray on block's DSH
+  uint m_SamplerStateArrayOffsetOnDSH;       // Offset to SamplerStateArray on block's DSH
+  uint m_sizeOfConstantBuffer;
+  ulong m_PatchTokensMask;
+  ulong m_ScratchSpacePatchValue;
+  uint m_SIMDSize;
+  uint m_HasBarriers;
+  uint m_RequiredWkgSizes[3];
+  uint m_InilineSLMSize;
+  uint m_NeedLocalIDS;
+  uint m_PayloadSize;
+  uint m_DisablePreemption;
+  uint m_CanRunConcurently;
+  IGIL_KernelCurbeParams m_data[1]; // IGIL_KernelCurbeParams
 } IGIL_KernelData;
 
-typedef struct
-{
-    ulong                  m_numberOfKernels; //number of kernels.
-    uint                   m_ParentImageDataOffset;
-    uint                   m_ParentKernelImageCount;
-    uint                   m_ParentSamplerParamsOffset;
-    uint                   m_ParentSamplerCount;
-    IGIL_KernelAddressData m_data[1]; //offsets for n x kernel data.
+typedef struct {
+  ulong m_numberOfKernels; // number of kernels.
+  uint m_ParentImageDataOffset;
+  uint m_ParentKernelImageCount;
+  uint m_ParentSamplerParamsOffset;
+  uint m_ParentSamplerCount;
+  IGIL_KernelAddressData m_data[1]; // offsets for n x kernel data.
 } IGIL_KernelDataHeader;
 
-typedef struct
-{
-    uint                   m_Width;
-    uint                   m_Height;
-    uint                   m_Depth;
-    uint                   m_ArraySize;
-    uint                   m_NumMipLevels;
-    uint                   m_NumSamples;
-    uint                   m_ChannelOrder;
-    uint                   m_ChannelDataType;
-    uint                   m_ObjectID;
+typedef struct {
+  uint m_Width;
+  uint m_Height;
+  uint m_Depth;
+  uint m_ArraySize;
+  uint m_NumMipLevels;
+  uint m_NumSamples;
+  uint m_ChannelOrder;
+  uint m_ChannelDataType;
+  uint m_ObjectID;
 } IGIL_ImageParamters;
 
-
-typedef struct
-{
-    uint                   m_ArgID;                     // Block's argument id
-    uint                   m_SamplerStateOffset;        // Offset of specific ( with m_ArgID ) Sampler state on per-block DSH
+typedef struct {
+  uint m_ArgID;              // Block's argument id
+  uint m_SamplerStateOffset; // Offset of specific ( with m_ArgID ) Sampler state on per-block DSH
 } IGIL_SamplerParams;
 
-typedef struct
-{
-    uint                   m_ObjectID;                  // Sampler Object id
-
-    uint                   m_AddressingMode;
-    uint                   NormalizedCoords;
-    uint                   CoordinateSnapRequired;
-} IGIL_ParentSamplerParams;                             // Parent's Sampler Curbe data
-
+typedef struct {
+  uint m_ObjectID; // Sampler Object id
 
+  uint m_AddressingMode;
+  uint NormalizedCoords;
+  uint CoordinateSnapRequired;
+} IGIL_ParentSamplerParams; // Parent's Sampler Curbe data
 
-#define IGIL_QUEUE_PROLOG_SIZE ( sizeof(IGIL_CommandQueue) )
-#define IGIL_QUEUE_COMMAND_SIZE ( sizeof(IGIL_CommandHeader) )
-#define IGIL_QUEUE_PROLOG_COMMAND_SIZE ( IGIL_QUEUE_PROLOG_SIZE + IGIL_QUEUE_COMMAND_SIZE )
+#define IGIL_QUEUE_PROLOG_SIZE (sizeof(IGIL_CommandQueue))
+#define IGIL_QUEUE_COMMAND_SIZE (sizeof(IGIL_CommandHeader))
+#define IGIL_QUEUE_PROLOG_COMMAND_SIZE (IGIL_QUEUE_PROLOG_SIZE + IGIL_QUEUE_COMMAND_SIZE)
 // IGIL_CommandQueue.m_head must be aligned to sizeof(IGIL_CommandHeader).
 // This macro sets m_head to the correct initial value
-#define IGIL_DEVICE_QUEUE_HEAD_INIT ( IGIL_QUEUE_COMMAND_SIZE > IGIL_QUEUE_PROLOG_SIZE ? sizeof(IGIL_CommandHeader) : ( IGIL_QUEUE_PROLOG_SIZE + ( IGIL_QUEUE_COMMAND_SIZE - IGIL_QUEUE_PROLOG_COMMAND_SIZE % IGIL_QUEUE_COMMAND_SIZE ) ) )
+#define IGIL_DEVICE_QUEUE_HEAD_INIT                                                                                    \
+  (IGIL_QUEUE_COMMAND_SIZE > IGIL_QUEUE_PROLOG_SIZE                                                                    \
+       ? sizeof(IGIL_CommandHeader)                                                                                    \
+       : (IGIL_QUEUE_PROLOG_SIZE +                                                                                     \
+          (IGIL_QUEUE_COMMAND_SIZE - IGIL_QUEUE_PROLOG_COMMAND_SIZE % IGIL_QUEUE_COMMAND_SIZE)))
 
 #endif
diff --git a/include/igc/ocl_igc_shared/executable_format/patch_g10.h b/include/igc/ocl_igc_shared/executable_format/patch_g10.h
index 5a3a0f7..a4dc77b 100644
--- a/include/igc/ocl_igc_shared/executable_format/patch_g10.h
+++ b/include/igc/ocl_igc_shared/executable_format/patch_g10.h
@@ -9,15 +9,11 @@ SPDX-License-Identifier: MIT
 #pragma once
 #include "patch_shared.h"
 
-namespace iOpenCL
-{
+namespace iOpenCL {
 
 /*****************************************************************************\
 STRUCT: SKernelBinaryHeaderGen10
 \*****************************************************************************/
-struct SKernelBinaryHeaderGen10 :
-       SKernelBinaryHeaderCommon
-{
-};
+struct SKernelBinaryHeaderGen10 : SKernelBinaryHeaderCommon {};
 
-} // namespace
+} // namespace iOpenCL
diff --git a/include/igc/ocl_igc_shared/executable_format/patch_g7.h b/include/igc/ocl_igc_shared/executable_format/patch_g7.h
index 5a75519..941f500 100644
--- a/include/igc/ocl_igc_shared/executable_format/patch_g7.h
+++ b/include/igc/ocl_igc_shared/executable_format/patch_g7.h
@@ -10,45 +10,35 @@ SPDX-License-Identifier: MIT
 #include "stdint.h"
 #include "patch_shared.h"
 
-namespace iOpenCL
-{
+namespace iOpenCL {
 
 /*****************************************************************************\
 STRUCT: SKernelBinaryHeaderGen7
 \*****************************************************************************/
-struct SKernelBinaryHeaderGen7 :
-       SKernelBinaryHeaderCommon
-{
-};
+struct SKernelBinaryHeaderGen7 : SKernelBinaryHeaderCommon {};
 
 /*****************************************************************************\
 STRUCT: SPatchMediaInterfaceDescriptorLoad
 \*****************************************************************************/
-struct SPatchMediaInterfaceDescriptorLoad :
-       SPatchItemHeader
-{
-    uint32_t   InterfaceDescriptorDataOffset;
+struct SPatchMediaInterfaceDescriptorLoad : SPatchItemHeader {
+  uint32_t InterfaceDescriptorDataOffset;
 };
 
 /*****************************************************************************\
 STRUCT: SPatchInterfaceDescriptorData
 \*****************************************************************************/
-struct SPatchInterfaceDescriptorData :
-       SPatchItemHeader
-{
-    uint32_t   Offset;
-    uint32_t   SamplerStateOffset;
-    uint32_t   KernelOffset;
-    uint32_t   BindingTableOffset;
+struct SPatchInterfaceDescriptorData : SPatchItemHeader {
+  uint32_t Offset;
+  uint32_t SamplerStateOffset;
+  uint32_t KernelOffset;
+  uint32_t BindingTableOffset;
 };
 
 /*****************************************************************************\
 STRUCT: SPatchDataParameterStream
 \*****************************************************************************/
-struct SPatchDataParameterStream :
-       SPatchItemHeader
-{
-    uint32_t   DataParameterStreamSize;
+struct SPatchDataParameterStream : SPatchItemHeader {
+  uint32_t DataParameterStreamSize;
 };
 
-} // namespace
+} // namespace iOpenCL
diff --git a/include/igc/ocl_igc_shared/executable_format/patch_g8.h b/include/igc/ocl_igc_shared/executable_format/patch_g8.h
index 3afaeb5..c919d32 100644
--- a/include/igc/ocl_igc_shared/executable_format/patch_g8.h
+++ b/include/igc/ocl_igc_shared/executable_format/patch_g8.h
@@ -9,15 +9,11 @@ SPDX-License-Identifier: MIT
 #pragma once
 #include "patch_shared.h"
 
-namespace iOpenCL
-{
+namespace iOpenCL {
 
 /*****************************************************************************\
 STRUCT: SKernelBinaryHeaderGen8
 \*****************************************************************************/
-struct SKernelBinaryHeaderGen8 :
-       SKernelBinaryHeaderCommon
-{
-};
+struct SKernelBinaryHeaderGen8 : SKernelBinaryHeaderCommon {};
 
-} // namespace
+} // namespace iOpenCL
diff --git a/include/igc/ocl_igc_shared/executable_format/patch_g9.h b/include/igc/ocl_igc_shared/executable_format/patch_g9.h
index b11e9b4..221ff74 100644
--- a/include/igc/ocl_igc_shared/executable_format/patch_g9.h
+++ b/include/igc/ocl_igc_shared/executable_format/patch_g9.h
@@ -12,15 +12,11 @@ Abstract:   Contains Gen9 patch structure definitions
 #pragma once
 #include "patch_shared.h"
 
-namespace iOpenCL
-{
+namespace iOpenCL {
 
 /*****************************************************************************\
 STRUCT: SKernelBinaryHeaderGen9
 \*****************************************************************************/
-struct SKernelBinaryHeaderGen9 :
-       SKernelBinaryHeaderCommon
-{
-};
+struct SKernelBinaryHeaderGen9 : SKernelBinaryHeaderCommon {};
 
-} // namespace
+} // namespace iOpenCL
diff --git a/include/igc/ocl_igc_shared/executable_format/patch_list.h b/include/igc/ocl_igc_shared/executable_format/patch_list.h
index 9cb0761..05eb890 100644
--- a/include/igc/ocl_igc_shared/executable_format/patch_list.h
+++ b/include/igc/ocl_igc_shared/executable_format/patch_list.h
@@ -12,246 +12,245 @@ Abstract:   Contains common patch structure definitions
 #pragma once
 #include <stdint.h>
 
-#pragma pack( push, 1 )
+#pragma pack(push, 1)
 
-namespace iOpenCL
-{
+namespace iOpenCL {
 const uint32_t CURRENT_ICBE_VERSION = 1082;
-const uint32_t MAGIC_CL = 0x494E5443;      // 'I', 'N', 'T', 'C'
+const uint32_t MAGIC_CL = 0x494E5443; // 'I', 'N', 'T', 'C'
 const uint32_t INVALID_INDEX = 0xFFFFFFFF;
 
 /*****************************************************************************\
 STRUCT: SProgramBinaryHeader
 \*****************************************************************************/
-struct SProgramBinaryHeader
-{
-    uint32_t   Magic;
-    uint32_t   Version;
+struct SProgramBinaryHeader {
+  uint32_t Magic;
+  uint32_t Version;
 
-    uint32_t   Device;
-    uint32_t   GPUPointerSizeInBytes;
+  uint32_t Device;
+  uint32_t GPUPointerSizeInBytes;
 
-    uint32_t   NumberOfKernels;
+  uint32_t NumberOfKernels;
 
-    uint32_t   SteppingId;
+  uint32_t SteppingId;
 
-    uint32_t   PatchListSize;
+  uint32_t PatchListSize;
 };
 
 // Update CURRENT_ICBE_VERSION when modifying the patch list
-static_assert( sizeof( SProgramBinaryHeader ) == 28 , "The size of SProgramBinaryHeader is not what is expected" );
+static_assert(sizeof(SProgramBinaryHeader) == 28, "The size of SProgramBinaryHeader is not what is expected");
 
 /*****************************************************************************\
 STRUCT: SKernelBinaryHeader
 \*****************************************************************************/
-struct SKernelBinaryHeader
-{
-    uint32_t   CheckSum;
-    uint64_t   ShaderHashCode;
-    uint32_t   KernelNameSize;
-    uint32_t   PatchListSize;
+struct SKernelBinaryHeader {
+  uint32_t CheckSum;
+  uint64_t ShaderHashCode;
+  uint32_t KernelNameSize;
+  uint32_t PatchListSize;
 };
 
 // Update CURRENT_ICBE_VERSION when modifying the patch list
-static_assert( sizeof( SKernelBinaryHeader ) == 20 , "The size of SKernelBinaryHeader is not what is expected" );
+static_assert(sizeof(SKernelBinaryHeader) == 20, "The size of SKernelBinaryHeader is not what is expected");
 
 /*****************************************************************************\
 STRUCT: SKernelBinaryHeaderCommon  (used by Gen7, Gen7.5, Gen8, Gen9, Gen10)
 \*****************************************************************************/
-struct SKernelBinaryHeaderCommon :
-       SKernelBinaryHeader
-{
-    uint32_t   KernelHeapSize;
-    uint32_t   GeneralStateHeapSize;
-    uint32_t   DynamicStateHeapSize;
-    uint32_t   SurfaceStateHeapSize;
-    uint32_t   KernelUnpaddedSize;
+struct SKernelBinaryHeaderCommon : SKernelBinaryHeader {
+  uint32_t KernelHeapSize;
+  uint32_t GeneralStateHeapSize;
+  uint32_t DynamicStateHeapSize;
+  uint32_t SurfaceStateHeapSize;
+  uint32_t KernelUnpaddedSize;
 };
 
 // Update CURRENT_ICBE_VERSION when modifying the patch list
-static_assert( sizeof( SKernelBinaryHeaderCommon ) == ( 20 + sizeof( SKernelBinaryHeader ) ) , "The size of SKernelBinaryHeaderCommon is not what is expected" );
+static_assert(sizeof(SKernelBinaryHeaderCommon) == (20 + sizeof(SKernelBinaryHeader)),
+              "The size of SKernelBinaryHeaderCommon is not what is expected");
 
 /*****************************************************************************\
 ENUM: PATCH_TOKEN
 \*****************************************************************************/
-enum PATCH_TOKEN
-{
-    PATCH_TOKEN_UNKNOWN,                                        // 0  - (Unused)
-    PATCH_TOKEN_MEDIA_STATE_POINTERS,                           // 1    - (Unused)
-    PATCH_TOKEN_STATE_SIP,                                      // 2  @SPatchStateSIP@
-    PATCH_TOKEN_CS_URB_STATE,                                   // 3    - (Unused)
-    PATCH_TOKEN_CONSTANT_BUFFER,                                // 4    - (Unused)
-    PATCH_TOKEN_SAMPLER_STATE_ARRAY,                            // 5  @SPatchSamplerStateArray@
-    PATCH_TOKEN_INTERFACE_DESCRIPTOR,                           // 6    - (Unused)
-    PATCH_TOKEN_VFE_STATE,                                      // 7    - (Unused)
-    PATCH_TOKEN_BINDING_TABLE_STATE,                            // 8  @SPatchBindingTableState@
-    PATCH_TOKEN_ALLOCATE_SCRATCH_SURFACE,                       // 9  - (Unused)
-    PATCH_TOKEN_ALLOCATE_SIP_SURFACE,                           // 10 @SPatchAllocateSystemThreadSurface@
-    PATCH_TOKEN_GLOBAL_MEMORY_OBJECT_KERNEL_ARGUMENT,           // 11   @SPatchGlobalMemoryObjectKernelArgument@ - OpenCL
-    PATCH_TOKEN_IMAGE_MEMORY_OBJECT_KERNEL_ARGUMENT,            // 12   @SPatchImageMemoryObjectKernelArgument@ - OpenCL
-    PATCH_TOKEN_CONSTANT_MEMORY_OBJECT_KERNEL_ARGUMENT,         // 13   - (Unused)  - OpenCL
-    PATCH_TOKEN_ALLOCATE_SURFACE_WITH_INITIALIZATION,           // 14 - (Unused)
-    PATCH_TOKEN_ALLOCATE_LOCAL_SURFACE,                         // 15 @SPatchAllocateLocalSurface@
-    PATCH_TOKEN_SAMPLER_KERNEL_ARGUMENT,                        // 16   @SPatchSamplerKernelArgument@ - OpenCL
-    PATCH_TOKEN_DATA_PARAMETER_BUFFER,                          // 17   @SPatchDataParameterBuffer@ - OpenCL
-    PATCH_TOKEN_MEDIA_VFE_STATE,                                // 18 @SPatchMediaVFEState@
-    PATCH_TOKEN_MEDIA_INTERFACE_DESCRIPTOR_LOAD,                // 19 @SPatchMediaInterfaceDescriptorLoad@
-    PATCH_TOKEN_MEDIA_CURBE_LOAD,                               // 20   - (Unused)
-    PATCH_TOKEN_INTERFACE_DESCRIPTOR_DATA,                      // 21 @SPatchInterfaceDescriptorData@
-    PATCH_TOKEN_THREAD_PAYLOAD,                                 // 22 @SPatchThreadPayload@
-    PATCH_TOKEN_EXECUTION_ENVIRONMENT,                          // 23 @SPatchExecutionEnvironment@
-    PATCH_TOKEN_ALLOCATE_PRIVATE_MEMORY,                        // 24 - (Unused)
-    PATCH_TOKEN_DATA_PARAMETER_STREAM,                          // 25 @SPatchDataParameterStream
-    PATCH_TOKEN_KERNEL_ARGUMENT_INFO,                           // 26   @SPatchKernelArgumentInfo@ - OpenCL
-    PATCH_TOKEN_KERNEL_ATTRIBUTES_INFO,                         // 27   @SPatchKernelAttributesInfo@ - OpenCL
-    PATCH_TOKEN_STRING,                                         // 28   @SPatchString@ - OpenCL
-    PATCH_TOKEN_ALLOCATE_PRINTF_SURFACE,                        // 29   - (Unused)  - OpenCL
-    PATCH_TOKEN_STATELESS_GLOBAL_MEMORY_OBJECT_KERNEL_ARGUMENT, // 30   @SPatchStatelessGlobalMemoryObjectKernelArgument@ - OpenCL
-    PATCH_TOKEN_STATELESS_CONSTANT_MEMORY_OBJECT_KERNEL_ARGUMENT,//31   @SPatchStatelessConstantMemoryObjectKernelArgument@ - OpenCL
-    PATCH_TOKEN_ALLOCATE_STATELESS_SURFACE_WITH_INITIALIZATION, // 32 - (Unused)
-    PATCH_TOKEN_ALLOCATE_STATELESS_PRINTF_SURFACE,              // 33 @SPatchAllocateStatelessPrintfSurface@
-    PATCH_TOKEN_CB_MAPPING,                                     // 34 - (Unused)
-    PATCH_TOKEN_CB2CR_GATHER_TABLE,                             // 35 - (Unused)
-    PATCH_TOKEN_ALLOCATE_STATELESS_EVENT_POOL_SURFACE,          // 36 @SPatchAllocateStatelessEventPoolSurface@
-    PATCH_TOKEN_NULL_SURFACE_LOCATION,                          // 37 - (Unused)
-    PATCH_TOKEN_ALLOCATE_STATELESS_PRIVATE_MEMORY,              // 38 @SPatchAllocateStatelessPrivateSurface@
-    PATCH_TOKEN_ALLOCATE_CONSTANT_MEMORY_SURFACE_WITH_INITIALIZATION,           // 39 - (Unused)
-    PATCH_TOKEN_ALLOCATE_GLOBAL_MEMORY_SURFACE_WITH_INITIALIZATION,             // 40 - (Unused)
-    PATCH_TOKEN_ALLOCATE_GLOBAL_MEMORY_SURFACE_PROGRAM_BINARY_INFO,             // 41 @SPatchAllocateGlobalMemorySurfaceProgramBinaryInfo@
-    PATCH_TOKEN_ALLOCATE_CONSTANT_MEMORY_SURFACE_PROGRAM_BINARY_INFO,           // 42 @SPatchAllocateConstantMemorySurfaceProgramBinaryInfo@
-    PATCH_TOKEN_ALLOCATE_STATELESS_GLOBAL_MEMORY_SURFACE_WITH_INITIALIZATION,   // 43 @SPatchAllocateStatelessGlobalMemorySurfaceWithInitialization@
-    PATCH_TOKEN_ALLOCATE_STATELESS_CONSTANT_MEMORY_SURFACE_WITH_INITIALIZATION, // 44 @SPatchAllocateStatelessConstantMemorySurfaceWithInitialization@
-    PATCH_TOKEN_ALLOCATE_STATELESS_DEFAULT_DEVICE_QUEUE_SURFACE,                // 45 @SPatchAllocateStatelessDefaultDeviceQueueSurface@
-    PATCH_TOKEN_STATELESS_DEVICE_QUEUE_KERNEL_ARGUMENT,            // 46  @SPatchStatelessDeviceQueueKernelArgument@
-    PATCH_TOKEN_GLOBAL_POINTER_PROGRAM_BINARY_INFO,                // 47  @SPatchGlobalPointerProgramBinaryInfo@
-    PATCH_TOKEN_CONSTANT_POINTER_PROGRAM_BINARY_INFO,              // 48  @SPatchConstantPointerProgramBinaryInfo@
-    PATCH_TOKEN_CONSTRUCTOR_DESTRUCTOR_KERNEL_PROGRAM_BINARY_INFO, // 49  - (Unused)
-    PATCH_TOKEN_INLINE_VME_SAMPLER_INFO,                           // 50  - (Unused)
-    PATCH_TOKEN_GTPIN_FREE_GRF_INFO,                               // 51  @SPatchGtpinFreeGRFInfo@
-    PATCH_TOKEN_GTPIN_INFO,                                        // 52  @SPatchItemHeader@
-    PATCH_TOKEN_PROGRAM_SYMBOL_TABLE,                             // 53  @SPatchFunctionTableInfo@
-    PATCH_TOKEN_PROGRAM_RELOCATION_TABLE,                         // 54  @SPatchFunctionTableInfo@
-    PATCH_TOKEN_MEDIA_VFE_STATE_SLOT1,                            // 55  @SPatchMediaVFEState of slot1@
-    PATCH_TOKEN_ALLOCATE_SYNC_BUFFER,                             // 56  @SPatchAllocateSyncBuffer@
-    PATCH_TOKEN_GLOBAL_HOST_ACCESS_TABLE,                         // 57  @SPatchHostAccessTableInfo@
-    PATCH_TOKEN_ALLOCATE_RT_GLOBAL_BUFFER,                        // 58  @SPatchAllocateRTGlobalBuffer@
-
-    NUM_PATCH_TOKENS
+enum PATCH_TOKEN {
+  PATCH_TOKEN_UNKNOWN,                                        // 0  - (Unused)
+  PATCH_TOKEN_MEDIA_STATE_POINTERS,                           // 1    - (Unused)
+  PATCH_TOKEN_STATE_SIP,                                      // 2  @SPatchStateSIP@
+  PATCH_TOKEN_CS_URB_STATE,                                   // 3    - (Unused)
+  PATCH_TOKEN_CONSTANT_BUFFER,                                // 4    - (Unused)
+  PATCH_TOKEN_SAMPLER_STATE_ARRAY,                            // 5  @SPatchSamplerStateArray@
+  PATCH_TOKEN_INTERFACE_DESCRIPTOR,                           // 6    - (Unused)
+  PATCH_TOKEN_VFE_STATE,                                      // 7    - (Unused)
+  PATCH_TOKEN_BINDING_TABLE_STATE,                            // 8  @SPatchBindingTableState@
+  PATCH_TOKEN_ALLOCATE_SCRATCH_SURFACE,                       // 9  - (Unused)
+  PATCH_TOKEN_ALLOCATE_SIP_SURFACE,                           // 10 @SPatchAllocateSystemThreadSurface@
+  PATCH_TOKEN_GLOBAL_MEMORY_OBJECT_KERNEL_ARGUMENT,           // 11   @SPatchGlobalMemoryObjectKernelArgument@ - OpenCL
+  PATCH_TOKEN_IMAGE_MEMORY_OBJECT_KERNEL_ARGUMENT,            // 12   @SPatchImageMemoryObjectKernelArgument@ - OpenCL
+  PATCH_TOKEN_CONSTANT_MEMORY_OBJECT_KERNEL_ARGUMENT,         // 13   - (Unused)  - OpenCL
+  PATCH_TOKEN_ALLOCATE_SURFACE_WITH_INITIALIZATION,           // 14 - (Unused)
+  PATCH_TOKEN_ALLOCATE_LOCAL_SURFACE,                         // 15 @SPatchAllocateLocalSurface@
+  PATCH_TOKEN_SAMPLER_KERNEL_ARGUMENT,                        // 16   @SPatchSamplerKernelArgument@ - OpenCL
+  PATCH_TOKEN_DATA_PARAMETER_BUFFER,                          // 17   @SPatchDataParameterBuffer@ - OpenCL
+  PATCH_TOKEN_MEDIA_VFE_STATE,                                // 18 @SPatchMediaVFEState@
+  PATCH_TOKEN_MEDIA_INTERFACE_DESCRIPTOR_LOAD,                // 19 @SPatchMediaInterfaceDescriptorLoad@
+  PATCH_TOKEN_MEDIA_CURBE_LOAD,                               // 20   - (Unused)
+  PATCH_TOKEN_INTERFACE_DESCRIPTOR_DATA,                      // 21 @SPatchInterfaceDescriptorData@
+  PATCH_TOKEN_THREAD_PAYLOAD,                                 // 22 @SPatchThreadPayload@
+  PATCH_TOKEN_EXECUTION_ENVIRONMENT,                          // 23 @SPatchExecutionEnvironment@
+  PATCH_TOKEN_ALLOCATE_PRIVATE_MEMORY,                        // 24 - (Unused)
+  PATCH_TOKEN_DATA_PARAMETER_STREAM,                          // 25 @SPatchDataParameterStream
+  PATCH_TOKEN_KERNEL_ARGUMENT_INFO,                           // 26   @SPatchKernelArgumentInfo@ - OpenCL
+  PATCH_TOKEN_KERNEL_ATTRIBUTES_INFO,                         // 27   @SPatchKernelAttributesInfo@ - OpenCL
+  PATCH_TOKEN_STRING,                                         // 28   @SPatchString@ - OpenCL
+  PATCH_TOKEN_ALLOCATE_PRINTF_SURFACE,                        // 29   - (Unused)  - OpenCL
+  PATCH_TOKEN_STATELESS_GLOBAL_MEMORY_OBJECT_KERNEL_ARGUMENT, // 30   @SPatchStatelessGlobalMemoryObjectKernelArgument@
+                                                              // - OpenCL
+  PATCH_TOKEN_STATELESS_CONSTANT_MEMORY_OBJECT_KERNEL_ARGUMENT, // 31
+                                                                // @SPatchStatelessConstantMemoryObjectKernelArgument@ -
+                                                                // OpenCL
+  PATCH_TOKEN_ALLOCATE_STATELESS_SURFACE_WITH_INITIALIZATION,       // 32 - (Unused)
+  PATCH_TOKEN_ALLOCATE_STATELESS_PRINTF_SURFACE,                    // 33 @SPatchAllocateStatelessPrintfSurface@
+  PATCH_TOKEN_CB_MAPPING,                                           // 34 - (Unused)
+  PATCH_TOKEN_CB2CR_GATHER_TABLE,                                   // 35 - (Unused)
+  PATCH_TOKEN_ALLOCATE_STATELESS_EVENT_POOL_SURFACE,                // 36 @SPatchAllocateStatelessEventPoolSurface@
+  PATCH_TOKEN_NULL_SURFACE_LOCATION,                                // 37 - (Unused)
+  PATCH_TOKEN_ALLOCATE_STATELESS_PRIVATE_MEMORY,                    // 38 @SPatchAllocateStatelessPrivateSurface@
+  PATCH_TOKEN_ALLOCATE_CONSTANT_MEMORY_SURFACE_WITH_INITIALIZATION, // 39 - (Unused)
+  PATCH_TOKEN_ALLOCATE_GLOBAL_MEMORY_SURFACE_WITH_INITIALIZATION,   // 40 - (Unused)
+  PATCH_TOKEN_ALLOCATE_GLOBAL_MEMORY_SURFACE_PROGRAM_BINARY_INFO,   // 41
+                                                                  // @SPatchAllocateGlobalMemorySurfaceProgramBinaryInfo@
+  PATCH_TOKEN_ALLOCATE_CONSTANT_MEMORY_SURFACE_PROGRAM_BINARY_INFO, // 42
+                                                                    // @SPatchAllocateConstantMemorySurfaceProgramBinaryInfo@
+  PATCH_TOKEN_ALLOCATE_STATELESS_GLOBAL_MEMORY_SURFACE_WITH_INITIALIZATION, // 43
+                                                                            // @SPatchAllocateStatelessGlobalMemorySurfaceWithInitialization@
+  PATCH_TOKEN_ALLOCATE_STATELESS_CONSTANT_MEMORY_SURFACE_WITH_INITIALIZATION, // 44
+                                                                              // @SPatchAllocateStatelessConstantMemorySurfaceWithInitialization@
+  PATCH_TOKEN_ALLOCATE_STATELESS_DEFAULT_DEVICE_QUEUE_SURFACE, // 45 @SPatchAllocateStatelessDefaultDeviceQueueSurface@
+  PATCH_TOKEN_STATELESS_DEVICE_QUEUE_KERNEL_ARGUMENT,          // 46  @SPatchStatelessDeviceQueueKernelArgument@
+  PATCH_TOKEN_GLOBAL_POINTER_PROGRAM_BINARY_INFO,              // 47  @SPatchGlobalPointerProgramBinaryInfo@
+  PATCH_TOKEN_CONSTANT_POINTER_PROGRAM_BINARY_INFO,            // 48  @SPatchConstantPointerProgramBinaryInfo@
+  PATCH_TOKEN_CONSTRUCTOR_DESTRUCTOR_KERNEL_PROGRAM_BINARY_INFO, // 49  - (Unused)
+  PATCH_TOKEN_INLINE_VME_SAMPLER_INFO,                           // 50  - (Unused)
+  PATCH_TOKEN_GTPIN_FREE_GRF_INFO,                               // 51  @SPatchGtpinFreeGRFInfo@
+  PATCH_TOKEN_GTPIN_INFO,                                        // 52  @SPatchItemHeader@
+  PATCH_TOKEN_PROGRAM_SYMBOL_TABLE,                              // 53  @SPatchFunctionTableInfo@
+  PATCH_TOKEN_PROGRAM_RELOCATION_TABLE,                          // 54  @SPatchFunctionTableInfo@
+  PATCH_TOKEN_MEDIA_VFE_STATE_SLOT1,                             // 55  @SPatchMediaVFEState of slot1@
+  PATCH_TOKEN_ALLOCATE_SYNC_BUFFER,                              // 56  @SPatchAllocateSyncBuffer@
+  PATCH_TOKEN_GLOBAL_HOST_ACCESS_TABLE,                          // 57  @SPatchHostAccessTableInfo@
+  PATCH_TOKEN_ALLOCATE_RT_GLOBAL_BUFFER,                         // 58  @SPatchAllocateRTGlobalBuffer@
+
+  NUM_PATCH_TOKENS
 };
 
 // Update CURRENT_ICBE_VERSION when modifying the patch list
-static_assert( NUM_PATCH_TOKENS == 59, "NUM_PATCH_TOKENS has invalid value");
+static_assert(NUM_PATCH_TOKENS == 59, "NUM_PATCH_TOKENS has invalid value");
 
 /*****************************************************************************\
 ENUM: IMAGE_MEMORY_OBJECT_TYPE
 \*****************************************************************************/
-enum IMAGE_MEMORY_OBJECT_TYPE
-{
-    IMAGE_MEMORY_OBJECT_INVALID,
-    IMAGE_MEMORY_OBJECT_BUFFER,
-    IMAGE_MEMORY_OBJECT_1D,
-    IMAGE_MEMORY_OBJECT_1D_ARRAY,
-    IMAGE_MEMORY_OBJECT_2D,
-    IMAGE_MEMORY_OBJECT_2D_ARRAY,
-    IMAGE_MEMORY_OBJECT_3D,
-    IMAGE_MEMORY_OBJECT_CUBE,
-    IMAGE_MEMORY_OBJECT_CUBE_ARRAY,
-    IMAGE_MEMORY_OBJECT_2D_DEPTH,
-    IMAGE_MEMORY_OBJECT_2D_ARRAY_DEPTH,
-    IMAGE_MEMORY_OBJECT_2D_MSAA,
-    IMAGE_MEMORY_OBJECT_2D_MSAA_DEPTH,
-    IMAGE_MEMORY_OBJECT_2D_ARRAY_MSAA,
-    IMAGE_MEMORY_OBJECT_2D_ARRAY_MSAA_DEPTH,
-    IMAGE_MEMORY_OBJECT_2D_MEDIA,
-    IMAGE_MEMORY_OBJECT_2D_MEDIA_BLOCK,
-    NUM_IMAGE_MEMORY_OBJECT_TYPES
+enum IMAGE_MEMORY_OBJECT_TYPE {
+  IMAGE_MEMORY_OBJECT_INVALID,
+  IMAGE_MEMORY_OBJECT_BUFFER,
+  IMAGE_MEMORY_OBJECT_1D,
+  IMAGE_MEMORY_OBJECT_1D_ARRAY,
+  IMAGE_MEMORY_OBJECT_2D,
+  IMAGE_MEMORY_OBJECT_2D_ARRAY,
+  IMAGE_MEMORY_OBJECT_3D,
+  IMAGE_MEMORY_OBJECT_CUBE,
+  IMAGE_MEMORY_OBJECT_CUBE_ARRAY,
+  IMAGE_MEMORY_OBJECT_2D_DEPTH,
+  IMAGE_MEMORY_OBJECT_2D_ARRAY_DEPTH,
+  IMAGE_MEMORY_OBJECT_2D_MSAA,
+  IMAGE_MEMORY_OBJECT_2D_MSAA_DEPTH,
+  IMAGE_MEMORY_OBJECT_2D_ARRAY_MSAA,
+  IMAGE_MEMORY_OBJECT_2D_ARRAY_MSAA_DEPTH,
+  IMAGE_MEMORY_OBJECT_2D_MEDIA,
+  IMAGE_MEMORY_OBJECT_2D_MEDIA_BLOCK,
+  NUM_IMAGE_MEMORY_OBJECT_TYPES
 };
 
 // Update CURRENT_ICBE_VERSION when modifying the patch list
-static_assert( NUM_IMAGE_MEMORY_OBJECT_TYPES == 17, "NUM_IMAGE_MEMORY_OBJECT_TYPES has invalid value");
+static_assert(NUM_IMAGE_MEMORY_OBJECT_TYPES == 17, "NUM_IMAGE_MEMORY_OBJECT_TYPES has invalid value");
 
 /*****************************************************************************\
 ENUM: SAMPLER_OBJECT_TYPE
 \*****************************************************************************/
-enum SAMPLER_OBJECT_TYPE
-{
-    SAMPLER_OBJECT_INVALID,
-    SAMPLER_OBJECT_TEXTURE,
-    SAMPLER_OBJECT_SAMPLE_8X8,
-    SAMPLER_OBJECT_SAMPLE_8X8_2DCONVOLVE,
-    SAMPLER_OBJECT_SAMPLE_8X8_ERODE,
-    SAMPLER_OBJECT_SAMPLE_8X8_DILATE,
-    SAMPLER_OBJECT_SAMPLE_8X8_MINMAXFILTER,
-    SAMPLER_OBJECT_VME,
-    SAMPLER_OBJECT_SAMPLE_8X8_MINMAX,
-    SAMPLER_OBJECT_SAMPLE_8X8_CENTROID,
-    SAMPLER_OBJECT_SAMPLE_8X8_BOOL_CENTROID,
-    SAMPLER_OBJECT_SAMPLE_8X8_BOOL_SUM,
-    SAMPLER_OBJECT_VE,
-    SAMPLER_OBJECT_VD,
-    NUM_SAMPLER_OBJECT_TYPES
+enum SAMPLER_OBJECT_TYPE {
+  SAMPLER_OBJECT_INVALID,
+  SAMPLER_OBJECT_TEXTURE,
+  SAMPLER_OBJECT_SAMPLE_8X8,
+  SAMPLER_OBJECT_SAMPLE_8X8_2DCONVOLVE,
+  SAMPLER_OBJECT_SAMPLE_8X8_ERODE,
+  SAMPLER_OBJECT_SAMPLE_8X8_DILATE,
+  SAMPLER_OBJECT_SAMPLE_8X8_MINMAXFILTER,
+  SAMPLER_OBJECT_VME,
+  SAMPLER_OBJECT_SAMPLE_8X8_MINMAX,
+  SAMPLER_OBJECT_SAMPLE_8X8_CENTROID,
+  SAMPLER_OBJECT_SAMPLE_8X8_BOOL_CENTROID,
+  SAMPLER_OBJECT_SAMPLE_8X8_BOOL_SUM,
+  SAMPLER_OBJECT_VE,
+  SAMPLER_OBJECT_VD,
+  NUM_SAMPLER_OBJECT_TYPES
 };
 
 // Update CURRENT_ICBE_VERSION when modifying the patch list
-static_assert( NUM_SAMPLER_OBJECT_TYPES == 14, "NUM_SAMPLER_OBJECT_TYPES has invalid value");
+static_assert(NUM_SAMPLER_OBJECT_TYPES == 14, "NUM_SAMPLER_OBJECT_TYPES has invalid value");
 
 /*****************************************************************************\
 ENUM: DATA_PARAMETER_TOKEN
 \*****************************************************************************/
-enum DATA_PARAMETER_TOKEN
-{
-    DATA_PARAMETER_TOKEN_UNKNOWN,                                   // 0
-    DATA_PARAMETER_KERNEL_ARGUMENT,                                 // 1
-    DATA_PARAMETER_LOCAL_WORK_SIZE,                                 // 2
-    DATA_PARAMETER_GLOBAL_WORK_SIZE,                                // 3
-    DATA_PARAMETER_NUM_WORK_GROUPS,                                 // 4
-    DATA_PARAMETER_WORK_DIMENSIONS,                                 // 5
-    DATA_PARAMETER_LOCAL_ID,                                        // 6
-    DATA_PARAMETER_EXECUTION_MASK,                                  // 7
-    DATA_PARAMETER_SUM_OF_LOCAL_MEMORY_OBJECT_ARGUMENT_SIZES,       // 8
-    DATA_PARAMETER_IMAGE_WIDTH,                                     // 9
-    DATA_PARAMETER_IMAGE_HEIGHT,                                    // 10
-    DATA_PARAMETER_IMAGE_DEPTH,                                     // 11
-    DATA_PARAMETER_IMAGE_CHANNEL_DATA_TYPE,                         // 12
-    DATA_PARAMETER_IMAGE_CHANNEL_ORDER,                             // 13
-    DATA_PARAMETER_SAMPLER_ADDRESS_MODE,                            // 14
-    DATA_PARAMETER_SAMPLER_NORMALIZED_COORDS,                       // 15
-    DATA_PARAMETER_GLOBAL_WORK_OFFSET,                              // 16
-    DATA_PARAMETER_NUM_HARDWARE_THREADS,                            // 17
-    DATA_PARAMETER_IMAGE_ARRAY_SIZE,                                // 18
-    DATA_PARAMETER_PRINTF_SURFACE_SIZE,                             // 19
-    DATA_PARAMETER_IMAGE_NUM_SAMPLES,                               // 20
-    DATA_PARAMETER_SAMPLER_COORDINATE_SNAP_WA_REQUIRED,             // 21
-    DATA_PARAMETER_PARENT_EVENT,                                    // 22
-    DATA_PARAMETER_VME_MB_BLOCK_TYPE,                               // 22
-    DATA_PARAMETER_VME_SUBPIXEL_MODE,                               // 24
-    DATA_PARAMETER_VME_SAD_ADJUST_MODE,                             // 25
-    DATA_PARAMETER_VME_SEARCH_PATH_TYPE,                            // 26
-    DATA_PARAMETER_IMAGE_NUM_MIP_LEVELS,                            // 27
-    DATA_PARAMETER_ENQUEUED_LOCAL_WORK_SIZE,                        // 28
-    DATA_PARAMETER_MAX_WORKGROUP_SIZE,                              // 29
-    DATA_PARAMETER_PREFERRED_WORKGROUP_MULTIPLE,                    // 30
-    DATA_PARAMETER_LOCAL_MEMORY_STATELESS_WINDOW_START_ADDRESS,     // 31
-    DATA_PARAMETER_LOCAL_MEMORY_STATELESS_WINDOW_SIZE,              // 32
-    DATA_PARAMETER_PRIVATE_MEMORY_STATELESS_SIZE,                   // 33
-    DATA_PARAMETER_SIMD_SIZE,                                       // 34
-    DATA_PARAMETER_OBJECT_ID,                                       // 35
-    DATA_PARAMETER_VME_IMAGE_TYPE,                                  // 36
-    DATA_PARAMETER_VME_MB_SKIP_BLOCK_TYPE,                          // 37
-    DATA_PARAMETER_CHILD_BLOCK_SIMD_SIZE,                           // 38
-    DATA_PARAMETER_IMAGE_SRGB_CHANNEL_ORDER,                        // 39
-    DATA_PARAMETER_STAGE_IN_GRID_ORIGIN,                            // 40
-    DATA_PARAMETER_STAGE_IN_GRID_SIZE,                              // 41
-    DATA_PARAMETER_BUFFER_OFFSET,                                   // 42
-    DATA_PARAMETER_BUFFER_STATEFUL,                                 // 43
-    DATA_PARAMETER_FLAT_IMAGE_BASEOFFSET,                           // 44
-    DATA_PARAMETER_FLAT_IMAGE_WIDTH,                                // 45
-    DATA_PARAMETER_FLAT_IMAGE_HEIGHT,                               // 46
-    DATA_PARAMETER_FLAT_IMAGE_PITCH,                                // 47
-    DATA_PARAMETER_RT_STACK_ID,                                     // 48
-    DATA_PARAMETER_IMPL_ARG_BUFFER,                                 // 49
-    DATA_PARAMETER_LOCAL_ID_BUFFER,                                 // 50
-    NUM_DATA_PARAMETER_TOKENS
+enum DATA_PARAMETER_TOKEN {
+  DATA_PARAMETER_TOKEN_UNKNOWN,                               // 0
+  DATA_PARAMETER_KERNEL_ARGUMENT,                             // 1
+  DATA_PARAMETER_LOCAL_WORK_SIZE,                             // 2
+  DATA_PARAMETER_GLOBAL_WORK_SIZE,                            // 3
+  DATA_PARAMETER_NUM_WORK_GROUPS,                             // 4
+  DATA_PARAMETER_WORK_DIMENSIONS,                             // 5
+  DATA_PARAMETER_LOCAL_ID,                                    // 6
+  DATA_PARAMETER_EXECUTION_MASK,                              // 7
+  DATA_PARAMETER_SUM_OF_LOCAL_MEMORY_OBJECT_ARGUMENT_SIZES,   // 8
+  DATA_PARAMETER_IMAGE_WIDTH,                                 // 9
+  DATA_PARAMETER_IMAGE_HEIGHT,                                // 10
+  DATA_PARAMETER_IMAGE_DEPTH,                                 // 11
+  DATA_PARAMETER_IMAGE_CHANNEL_DATA_TYPE,                     // 12
+  DATA_PARAMETER_IMAGE_CHANNEL_ORDER,                         // 13
+  DATA_PARAMETER_SAMPLER_ADDRESS_MODE,                        // 14
+  DATA_PARAMETER_SAMPLER_NORMALIZED_COORDS,                   // 15
+  DATA_PARAMETER_GLOBAL_WORK_OFFSET,                          // 16
+  DATA_PARAMETER_NUM_HARDWARE_THREADS,                        // 17
+  DATA_PARAMETER_IMAGE_ARRAY_SIZE,                            // 18
+  DATA_PARAMETER_PRINTF_SURFACE_SIZE,                         // 19
+  DATA_PARAMETER_IMAGE_NUM_SAMPLES,                           // 20
+  DATA_PARAMETER_SAMPLER_COORDINATE_SNAP_WA_REQUIRED,         // 21
+  DATA_PARAMETER_PARENT_EVENT,                                // 22
+  DATA_PARAMETER_VME_MB_BLOCK_TYPE,                           // 22
+  DATA_PARAMETER_VME_SUBPIXEL_MODE,                           // 24
+  DATA_PARAMETER_VME_SAD_ADJUST_MODE,                         // 25
+  DATA_PARAMETER_VME_SEARCH_PATH_TYPE,                        // 26
+  DATA_PARAMETER_IMAGE_NUM_MIP_LEVELS,                        // 27
+  DATA_PARAMETER_ENQUEUED_LOCAL_WORK_SIZE,                    // 28
+  DATA_PARAMETER_MAX_WORKGROUP_SIZE,                          // 29
+  DATA_PARAMETER_PREFERRED_WORKGROUP_MULTIPLE,                // 30
+  DATA_PARAMETER_LOCAL_MEMORY_STATELESS_WINDOW_START_ADDRESS, // 31
+  DATA_PARAMETER_LOCAL_MEMORY_STATELESS_WINDOW_SIZE,          // 32
+  DATA_PARAMETER_PRIVATE_MEMORY_STATELESS_SIZE,               // 33
+  DATA_PARAMETER_SIMD_SIZE,                                   // 34
+  DATA_PARAMETER_OBJECT_ID,                                   // 35
+  DATA_PARAMETER_VME_IMAGE_TYPE,                              // 36
+  DATA_PARAMETER_VME_MB_SKIP_BLOCK_TYPE,                      // 37
+  DATA_PARAMETER_CHILD_BLOCK_SIMD_SIZE,                       // 38
+  DATA_PARAMETER_IMAGE_SRGB_CHANNEL_ORDER,                    // 39
+  DATA_PARAMETER_STAGE_IN_GRID_ORIGIN,                        // 40
+  DATA_PARAMETER_STAGE_IN_GRID_SIZE,                          // 41
+  DATA_PARAMETER_BUFFER_OFFSET,                               // 42
+  DATA_PARAMETER_BUFFER_STATEFUL,                             // 43
+  DATA_PARAMETER_FLAT_IMAGE_BASEOFFSET,                       // 44
+  DATA_PARAMETER_FLAT_IMAGE_WIDTH,                            // 45
+  DATA_PARAMETER_FLAT_IMAGE_HEIGHT,                           // 46
+  DATA_PARAMETER_FLAT_IMAGE_PITCH,                            // 47
+  DATA_PARAMETER_RT_STACK_ID,                                 // 48
+  DATA_PARAMETER_IMPL_ARG_BUFFER,                             // 49
+  DATA_PARAMETER_LOCAL_ID_BUFFER,                             // 50
+  NUM_DATA_PARAMETER_TOKENS
 };
 
 // Update CURRENT_ICBE_VERSION when modifying the patch list
@@ -260,206 +259,186 @@ static_assert(NUM_DATA_PARAMETER_TOKENS == 51, "NUM_DATA_PARAMETER_TOKENS has in
 /*****************************************************************************\
 ENUM: CONSTANT_BUFFER_TYPE
 \*****************************************************************************/
-enum CONSTANT_BUFFER_TYPE
-{
-    CONSTANT_BUFFER_TYPE_KERNEL_ARGUMENT,
-    CONSTANT_BUFFER_TYPE_INLINE,
-    NUM_CONSTANT_BUFFER_TYPES
+enum CONSTANT_BUFFER_TYPE {
+  CONSTANT_BUFFER_TYPE_KERNEL_ARGUMENT,
+  CONSTANT_BUFFER_TYPE_INLINE,
+  NUM_CONSTANT_BUFFER_TYPES
 };
 
 // Update CURRENT_ICBE_VERSION when modifying the patch list
-static_assert( NUM_CONSTANT_BUFFER_TYPES == 2, "NUM_CONSTANT_BUFFER_TYPES has invalid value");
+static_assert(NUM_CONSTANT_BUFFER_TYPES == 2, "NUM_CONSTANT_BUFFER_TYPES has invalid value");
 
 /*****************************************************************************\
 ENUM: GLOBAL_BUFFER_TYPE
 \*****************************************************************************/
-enum GLOBAL_BUFFER_TYPE
-{
-    GLOBAL_BUFFER_TYPE_INLINE,
-    GLOBAL_BUFFER_TYPE_INLINE_UNINIT,
-    NUM_GLOBAL_BUFFER_TYPES
-};
+enum GLOBAL_BUFFER_TYPE { GLOBAL_BUFFER_TYPE_INLINE, GLOBAL_BUFFER_TYPE_INLINE_UNINIT, NUM_GLOBAL_BUFFER_TYPES };
 
 // Update CURRENT_ICBE_VERSION when modifying the patch list
-static_assert( NUM_GLOBAL_BUFFER_TYPES == 2, "NUM_GLOBAL_BUFFER_TYPES has invalid value");
+static_assert(NUM_GLOBAL_BUFFER_TYPES == 2, "NUM_GLOBAL_BUFFER_TYPES has invalid value");
 
 /*****************************************************************************\
 ENUM: BUFFER_TYPES
 \*****************************************************************************/
-enum PROGRAM_SCOPE_BUFFER_TYPE
-{
-    PROGRAM_SCOPE_GLOBAL_BUFFER,
-    PROGRAM_SCOPE_CONSTANT_BUFFER,
-    NUM_PROGRAM_SCOPE_BUFFER_TYPE
+enum PROGRAM_SCOPE_BUFFER_TYPE {
+  PROGRAM_SCOPE_GLOBAL_BUFFER,
+  PROGRAM_SCOPE_CONSTANT_BUFFER,
+  NUM_PROGRAM_SCOPE_BUFFER_TYPE
 };
 
 // Update CURRENT_ICBE_VERSION when modifying the patch list
-static_assert( NUM_PROGRAM_SCOPE_BUFFER_TYPE == 2, "NUM_PROGRAM_SCOPE_BUFFER_TYPE has invalid value");
+static_assert(NUM_PROGRAM_SCOPE_BUFFER_TYPE == 2, "NUM_PROGRAM_SCOPE_BUFFER_TYPE has invalid value");
 
 /*****************************************************************************\
 ENUM: CONSTANT_REGISTER_BOOLEAN
 \*****************************************************************************/
-enum CONSTANT_REGISTER_BOOLEAN
-{
-    CONSTANT_REGISTER_BOOLEAN_FALSE = 0x0,
-    CONSTANT_REGISTER_BOOLEAN_TRUE = 0xffffffff
-};
+enum CONSTANT_REGISTER_BOOLEAN { CONSTANT_REGISTER_BOOLEAN_FALSE = 0x0, CONSTANT_REGISTER_BOOLEAN_TRUE = 0xffffffff };
 
 // Update CURRENT_ICBE_VERSION when modifying the patch list
-static_assert( CONSTANT_REGISTER_BOOLEAN_FALSE == 0, "CONSTANT_REGISTER_BOOLEAN_FALSE has invalid value");
-static_assert( CONSTANT_REGISTER_BOOLEAN_TRUE == 0xffffffff, "CONSTANT_REGISTER_BOOLEAN_TRUE has invalid value");
+static_assert(CONSTANT_REGISTER_BOOLEAN_FALSE == 0, "CONSTANT_REGISTER_BOOLEAN_FALSE has invalid value");
+static_assert(CONSTANT_REGISTER_BOOLEAN_TRUE == 0xffffffff, "CONSTANT_REGISTER_BOOLEAN_TRUE has invalid value");
 
 /*****************************************************************************\
 ENUM: BUFFER_TYPES
 \*****************************************************************************/
-enum PROGRAM_SCOPE_KERNEL_TYPE
-{
-    PROGRAM_SCOPE_KERNEL_CONSTRUCTOR,
-    PROGRAM_SCOPE_KERNEL_DESTRUCTOR,
-    NUM_PROGRAM_SCOPE_KERNEL_TYPE
+enum PROGRAM_SCOPE_KERNEL_TYPE {
+  PROGRAM_SCOPE_KERNEL_CONSTRUCTOR,
+  PROGRAM_SCOPE_KERNEL_DESTRUCTOR,
+  NUM_PROGRAM_SCOPE_KERNEL_TYPE
 };
 
 // Update CURRENT_ICBE_VERSION when modifying the patch list
-static_assert( NUM_PROGRAM_SCOPE_KERNEL_TYPE == 2, "NUM_PROGRAM_SCOPE_KERNEL_TYPE has invalid value");
+static_assert(NUM_PROGRAM_SCOPE_KERNEL_TYPE == 2, "NUM_PROGRAM_SCOPE_KERNEL_TYPE has invalid value");
 
 /*****************************************************************************\
 STRUCT: SPatchItemHeader
 \*****************************************************************************/
-struct SPatchItemHeader
-{
-    uint32_t   Token;
-    uint32_t   Size;
+struct SPatchItemHeader {
+  uint32_t Token;
+  uint32_t Size;
 };
 
 // Update CURRENT_ICBE_VERSION when modifying the patch list
-static_assert( sizeof( SPatchItemHeader ) == 8 , "The size of SPatchItemHeader is not what is expected" );
+static_assert(sizeof(SPatchItemHeader) == 8, "The size of SPatchItemHeader is not what is expected");
 
 /*****************************************************************************\
 STRUCT: SPatchGlobalMemoryObjectKernelArgument
 \*****************************************************************************/
-struct SPatchGlobalMemoryObjectKernelArgument :
-       SPatchItemHeader
-{
-    uint32_t   ArgumentNumber;
-    uint32_t   Offset;
-    uint32_t   LocationIndex;
-    uint32_t   LocationIndex2;
-    uint32_t   IsEmulationArgument;
+struct SPatchGlobalMemoryObjectKernelArgument : SPatchItemHeader {
+  uint32_t ArgumentNumber;
+  uint32_t Offset;
+  uint32_t LocationIndex;
+  uint32_t LocationIndex2;
+  uint32_t IsEmulationArgument;
 };
 
 // Update CURRENT_ICBE_VERSION when modifying the patch list
-static_assert( sizeof( SPatchGlobalMemoryObjectKernelArgument ) == ( 20 + sizeof( SPatchItemHeader ) ) , "The size of SPatchGlobalMemoryObjectKernelArgument is not what is expected" );
+static_assert(sizeof(SPatchGlobalMemoryObjectKernelArgument) == (20 + sizeof(SPatchItemHeader)),
+              "The size of SPatchGlobalMemoryObjectKernelArgument is not what is expected");
 
 /*****************************************************************************\
 STRUCT: SPatchImageMemoryObjectKernelArgument
 \*****************************************************************************/
-struct SPatchImageMemoryObjectKernelArgument :
-       SPatchItemHeader
-{
-    uint32_t  ArgumentNumber;
-    uint32_t  Type;
-    uint32_t  Offset;
-    uint32_t  LocationIndex;
-    uint32_t  LocationIndex2;
-
-    uint32_t  Writeable;
-    uint32_t  Transformable;
-    uint32_t  needBindlessHandle;
-    uint32_t  IsEmulationArgument;
-
-    uint32_t  btiOffset;
+struct SPatchImageMemoryObjectKernelArgument : SPatchItemHeader {
+  uint32_t ArgumentNumber;
+  uint32_t Type;
+  uint32_t Offset;
+  uint32_t LocationIndex;
+  uint32_t LocationIndex2;
+
+  uint32_t Writeable;
+  uint32_t Transformable;
+  uint32_t needBindlessHandle;
+  uint32_t IsEmulationArgument;
+
+  uint32_t btiOffset;
 };
 
 // Update CURRENT_ICBE_VERSION when modifying the patch list
-static_assert( sizeof( SPatchImageMemoryObjectKernelArgument ) == ( 40 + sizeof( SPatchItemHeader ) ) , "The size of SPatchImageMemoryObjectKernelArgument is not what is expected" );
+static_assert(sizeof(SPatchImageMemoryObjectKernelArgument) == (40 + sizeof(SPatchItemHeader)),
+              "The size of SPatchImageMemoryObjectKernelArgument is not what is expected");
 
 /*****************************************************************************\
 STRUCT: SPatchConstantMemoryObjectKernelArgument
 \*****************************************************************************/
-struct SPatchConstantMemoryObjectKernelArgument :
-       SPatchItemHeader
-{
-    uint32_t   ArgumentNumber;
-    uint32_t   Offset;
-    uint32_t   LocationIndex;
-    uint32_t   LocationIndex2;
-    uint32_t   IsEmulationArgument;
+struct SPatchConstantMemoryObjectKernelArgument : SPatchItemHeader {
+  uint32_t ArgumentNumber;
+  uint32_t Offset;
+  uint32_t LocationIndex;
+  uint32_t LocationIndex2;
+  uint32_t IsEmulationArgument;
 };
 
 // Update CURRENT_ICBE_VERSION when modifying the patch list
-static_assert( sizeof( SPatchConstantMemoryObjectKernelArgument ) == ( 20 + sizeof( SPatchItemHeader ) ) , "The size of SPatchConstantMemoryObjectKernelArgument is not what is expected" );
+static_assert(sizeof(SPatchConstantMemoryObjectKernelArgument) == (20 + sizeof(SPatchItemHeader)),
+              "The size of SPatchConstantMemoryObjectKernelArgument is not what is expected");
 
 /*****************************************************************************\
 STRUCT: SPatchSamplerKernelArgument
 \*****************************************************************************/
-struct SPatchSamplerKernelArgument :
-       SPatchItemHeader
-{
-    uint32_t   ArgumentNumber;
-    uint32_t   Type;
-    uint32_t   Offset;
-    uint32_t   LocationIndex;
-    uint32_t   LocationIndex2;
-    uint32_t   needBindlessHandle;
-    uint32_t   TextureMask;
-    uint32_t   IsEmulationArgument;
-    uint32_t   btiOffset;
+struct SPatchSamplerKernelArgument : SPatchItemHeader {
+  uint32_t ArgumentNumber;
+  uint32_t Type;
+  uint32_t Offset;
+  uint32_t LocationIndex;
+  uint32_t LocationIndex2;
+  uint32_t needBindlessHandle;
+  uint32_t TextureMask;
+  uint32_t IsEmulationArgument;
+  uint32_t btiOffset;
 };
 
 // Update CURRENT_ICBE_VERSION when modifying the patch list
-static_assert( sizeof( SPatchSamplerKernelArgument ) == ( 36 + sizeof( SPatchItemHeader ) ) , "The size of SPatchSamplerKernelArgument is not what is expected" );
+static_assert(sizeof(SPatchSamplerKernelArgument) == (36 + sizeof(SPatchItemHeader)),
+              "The size of SPatchSamplerKernelArgument is not what is expected");
 
 /*****************************************************************************\
 STRUCT: SPatchDataParameterBuffer
 \*****************************************************************************/
-struct SPatchDataParameterBuffer :
-       SPatchItemHeader
-{
-    uint32_t   Type;
-    uint32_t   ArgumentNumber;
-    uint32_t   Offset;
-    uint32_t   DataSize;
-    uint32_t   SourceOffset;
-    uint32_t   LocationIndex;
-    uint32_t   LocationIndex2;
-    uint32_t   IsEmulationArgument;
-    uint32_t   IsScalarCastedToPointer;
+struct SPatchDataParameterBuffer : SPatchItemHeader {
+  uint32_t Type;
+  uint32_t ArgumentNumber;
+  uint32_t Offset;
+  uint32_t DataSize;
+  uint32_t SourceOffset;
+  uint32_t LocationIndex;
+  uint32_t LocationIndex2;
+  uint32_t IsEmulationArgument;
+  uint32_t IsScalarCastedToPointer;
 };
 
 // Update CURRENT_ICBE_VERSION when modifying the patch list
-static_assert( sizeof( SPatchDataParameterBuffer ) == ( 36 + sizeof( SPatchItemHeader ) ) , "The size of SPatchDataParameterBuffer is not what is expected" );
+static_assert(sizeof(SPatchDataParameterBuffer) == (36 + sizeof(SPatchItemHeader)),
+              "The size of SPatchDataParameterBuffer is not what is expected");
 
 const uint32_t DATA_PARAMETER_DATA_SIZE = 4;
 
 /*****************************************************************************\
 STRUCT: SPatchKernelArgumentInfo
 \*****************************************************************************/
-struct SPatchKernelArgumentInfo :
-       SPatchItemHeader
-{
-    uint32_t ArgumentNumber;
-    uint32_t AddressQualifierSize;
-    uint32_t AccessQualifierSize;
-    uint32_t ArgumentNameSize;
-    uint32_t TypeNameSize;
-    uint32_t TypeQualifierSize;
+struct SPatchKernelArgumentInfo : SPatchItemHeader {
+  uint32_t ArgumentNumber;
+  uint32_t AddressQualifierSize;
+  uint32_t AccessQualifierSize;
+  uint32_t ArgumentNameSize;
+  uint32_t TypeNameSize;
+  uint32_t TypeQualifierSize;
 };
 
 // Update CURRENT_ICBE_VERSION when modifying the patch list
-static_assert( sizeof( SPatchKernelArgumentInfo ) == ( 24 + sizeof( SPatchItemHeader ) ) , "The size of SPatchKernelArgumentInfo is not what is expected" );
+static_assert(sizeof(SPatchKernelArgumentInfo) == (24 + sizeof(SPatchItemHeader)),
+              "The size of SPatchKernelArgumentInfo is not what is expected");
 
 /*****************************************************************************\
 STRUCT: SPatchKernelAttributesInfo
 \*****************************************************************************/
-struct SPatchKernelAttributesInfo :
-       SPatchItemHeader
-{
-    uint32_t AttributesSize;
+struct SPatchKernelAttributesInfo : SPatchItemHeader {
+  uint32_t AttributesSize;
 };
 
 // Update CURRENT_ICBE_VERSION when modifying the patch list
-static_assert( sizeof( SPatchKernelAttributesInfo ) == ( 4 + sizeof( SPatchItemHeader ) ) , "The size of SPatchKernelAttributesInfo is not what is expected" );
+static_assert(sizeof(SPatchKernelAttributesInfo) == (4 + sizeof(SPatchItemHeader)),
+              "The size of SPatchKernelAttributesInfo is not what is expected");
 
-} // namespace
+} // namespace iOpenCL
 
-#pragma pack( pop )
+#pragma pack(pop)
diff --git a/include/igc/ocl_igc_shared/executable_format/patch_shared.h b/include/igc/ocl_igc_shared/executable_format/patch_shared.h
index d03e7c5..d1da718 100644
--- a/include/igc/ocl_igc_shared/executable_format/patch_shared.h
+++ b/include/igc/ocl_igc_shared/executable_format/patch_shared.h
@@ -10,584 +10,543 @@ SPDX-License-Identifier: MIT
 #include <stdint.h>
 #include "patch_list.h"
 
-#pragma pack( push, 1 )
+#pragma pack(push, 1)
 
-namespace iOpenCL
-{
+namespace iOpenCL {
 /*****************************************************************************\
 STRUCT: SPatchStateSIP
 \*****************************************************************************/
-struct SPatchStateSIP :
-       SPatchItemHeader
-{
-    uint32_t   SystemKernelOffset;
+struct SPatchStateSIP : SPatchItemHeader {
+  uint32_t SystemKernelOffset;
 };
 
 // Update CURRENT_ICBE_VERSION when modifying the patch list
-static_assert( sizeof( SPatchStateSIP ) == ( 4 + sizeof( SPatchItemHeader ) ) , "The size of SPatchStateSIP is not what is expected" );
+static_assert(sizeof(SPatchStateSIP) == (4 + sizeof(SPatchItemHeader)),
+              "The size of SPatchStateSIP is not what is expected");
 
 /*****************************************************************************\
 STRUCT: SPatchSamplerStateArray
 \*****************************************************************************/
-struct SPatchSamplerStateArray :
-       SPatchItemHeader
-{
-    uint32_t   Offset;
-    uint32_t   Count;
-    uint32_t   BorderColorOffset;
+struct SPatchSamplerStateArray : SPatchItemHeader {
+  uint32_t Offset;
+  uint32_t Count;
+  uint32_t BorderColorOffset;
 };
 
 // Update CURRENT_ICBE_VERSION when modifying the patch list
-static_assert( sizeof( SPatchSamplerStateArray ) == ( 12 + sizeof( SPatchItemHeader ) ) , "The size of SPatchSamplerStateArray is not what is expected" );
+static_assert(sizeof(SPatchSamplerStateArray) == (12 + sizeof(SPatchItemHeader)),
+              "The size of SPatchSamplerStateArray is not what is expected");
 
 /*****************************************************************************\
 STRUCT: SPatchBindingTableState
 \*****************************************************************************/
-struct SPatchBindingTableState :
-       SPatchItemHeader
-{
-    uint32_t   Offset;
-    uint32_t   Count;
-    uint32_t   SurfaceStateOffset;
+struct SPatchBindingTableState : SPatchItemHeader {
+  uint32_t Offset;
+  uint32_t Count;
+  uint32_t SurfaceStateOffset;
 };
 
 // Update CURRENT_ICBE_VERSION when modifying the patch list
-static_assert( sizeof( SPatchBindingTableState ) == ( 12 + sizeof( SPatchItemHeader ) ) , "The size of SPatchBindingTableState is not what is expected" );
-
+static_assert(sizeof(SPatchBindingTableState) == (12 + sizeof(SPatchItemHeader)),
+              "The size of SPatchBindingTableState is not what is expected");
 
 /*****************************************************************************\
 STRUCT: SPatchAllocateScratchSurface
 \*****************************************************************************/
-struct SPatchAllocateScratchSurface :
-       SPatchItemHeader
-{
-    uint32_t   Offset;
-    uint32_t   PerThreadScratchSpaceSize;
+struct SPatchAllocateScratchSurface : SPatchItemHeader {
+  uint32_t Offset;
+  uint32_t PerThreadScratchSpaceSize;
 };
 
 // Update CURRENT_ICBE_VERSION when modifying the patch list
-static_assert( sizeof( SPatchAllocateScratchSurface ) == ( 8 + sizeof( SPatchItemHeader ) ) , "The size of SPatchAllocateScratchSurface is not what is expected" );
+static_assert(sizeof(SPatchAllocateScratchSurface) == (8 + sizeof(SPatchItemHeader)),
+              "The size of SPatchAllocateScratchSurface is not what is expected");
 
 /*****************************************************************************\
 STRUCT: SPatchAllocatePrivateMemorySurface
 \*****************************************************************************/
-struct SPatchAllocatePrivateMemorySurface :
-       SPatchItemHeader
-{
-    uint32_t   Offset;
-    uint32_t   PerThreadPrivateMemorySize;
+struct SPatchAllocatePrivateMemorySurface : SPatchItemHeader {
+  uint32_t Offset;
+  uint32_t PerThreadPrivateMemorySize;
 };
 
 // Update CURRENT_ICBE_VERSION when modifying the patch list
-static_assert( sizeof( SPatchAllocatePrivateMemorySurface ) == ( 8 + sizeof( SPatchItemHeader ) ) , "The size of SPatchAllocatePrivateMemorySurface is not what is expected" );
+static_assert(sizeof(SPatchAllocatePrivateMemorySurface) == (8 + sizeof(SPatchItemHeader)),
+              "The size of SPatchAllocatePrivateMemorySurface is not what is expected");
 
 /*****************************************************************************\
 STRUCT: SPatchAllocateSystemThreadSurface
 \*****************************************************************************/
-struct SPatchAllocateSystemThreadSurface :
-       SPatchItemHeader
-{
-    uint32_t   Offset;
-    uint32_t   PerThreadSystemThreadSurfaceSize;
-    uint32_t   BTI;
+struct SPatchAllocateSystemThreadSurface : SPatchItemHeader {
+  uint32_t Offset;
+  uint32_t PerThreadSystemThreadSurfaceSize;
+  uint32_t BTI;
 };
 
 // Update CURRENT_ICBE_VERSION when modifying the patch list
-static_assert( sizeof( SPatchAllocateSystemThreadSurface ) == ( 12 + sizeof( SPatchItemHeader ) ) , "The size of SPatchAllocateSystemThreadSurface is not what is expected" );
+static_assert(sizeof(SPatchAllocateSystemThreadSurface) == (12 + sizeof(SPatchItemHeader)),
+              "The size of SPatchAllocateSystemThreadSurface is not what is expected");
 
 /*****************************************************************************\
 STRUCT: SPatchAllocateSurfaceWithInitialization
 \*****************************************************************************/
-struct SPatchAllocateSurfaceWithInitialization :
-       SPatchItemHeader
-{
-    uint32_t   Offset;
-    uint32_t   InitializationDataSize;
+struct SPatchAllocateSurfaceWithInitialization : SPatchItemHeader {
+  uint32_t Offset;
+  uint32_t InitializationDataSize;
 };
 
 // Update CURRENT_ICBE_VERSION when modifying the patch list
-static_assert( sizeof( SPatchAllocateSurfaceWithInitialization ) == ( 8 + sizeof( SPatchItemHeader ) ) , "The size of SPatchAllocateSurfaceWithInitialization is not what is expected" );
+static_assert(sizeof(SPatchAllocateSurfaceWithInitialization) == (8 + sizeof(SPatchItemHeader)),
+              "The size of SPatchAllocateSurfaceWithInitialization is not what is expected");
 
 /*****************************************************************************\
 STRUCT: SPatchAllocateConstantMemorySurfaceWithInitialization
 \*****************************************************************************/
-struct SPatchAllocateConstantMemorySurfaceWithInitialization :
-       SPatchItemHeader
-{
-    uint32_t   ConstantBufferIndex;
-    uint32_t   Offset;
+struct SPatchAllocateConstantMemorySurfaceWithInitialization : SPatchItemHeader {
+  uint32_t ConstantBufferIndex;
+  uint32_t Offset;
 #if 0 // needed for CB2CR - need RT buy off.
     uint32_t   InlineConstantBufferIndex;
 #endif
 };
 
 // Update CURRENT_ICBE_VERSION when modifying the patch list
-static_assert( sizeof( SPatchAllocateConstantMemorySurfaceWithInitialization ) == ( 8 + sizeof( SPatchItemHeader ) ) , "The size of SPatchAllocateConstantMemorySurfaceWithInitialization is not what is expected" );
+static_assert(sizeof(SPatchAllocateConstantMemorySurfaceWithInitialization) == (8 + sizeof(SPatchItemHeader)),
+              "The size of SPatchAllocateConstantMemorySurfaceWithInitialization is not what is expected");
 
 /*****************************************************************************\
 STRUCT: SPatchAllocateLocalSurface
 \*****************************************************************************/
-struct SPatchAllocateLocalSurface :
-       SPatchItemHeader
-{
-    uint32_t   Offset;
-    uint32_t   TotalInlineLocalMemorySize;
+struct SPatchAllocateLocalSurface : SPatchItemHeader {
+  uint32_t Offset;
+  uint32_t TotalInlineLocalMemorySize;
 };
 
 // Update CURRENT_ICBE_VERSION when modifying the patch list
-static_assert( sizeof( SPatchAllocateLocalSurface ) == ( 8 + sizeof( SPatchItemHeader ) ) , "The size of SPatchAllocateLocalSurface is not what is expected" );
+static_assert(sizeof(SPatchAllocateLocalSurface) == (8 + sizeof(SPatchItemHeader)),
+              "The size of SPatchAllocateLocalSurface is not what is expected");
 
 /*****************************************************************************\
 STRUCT: SPatchThreadPayload
 \*****************************************************************************/
-struct SPatchThreadPayload :
-       SPatchItemHeader
-{
-    uint32_t HeaderPresent;
-    uint32_t LocalIDXPresent;
-    uint32_t LocalIDYPresent;
-    uint32_t LocalIDZPresent;
-    uint32_t LocalIDFlattenedPresent;
-    uint32_t IndirectPayloadStorage;
-    uint32_t UnusedPerThreadConstantPresent;
-    uint32_t GetLocalIDPresent;
-    uint32_t GetGroupIDPresent;
-    uint32_t GetGlobalOffsetPresent;
-    uint32_t StageInGridOriginPresent;
-    uint32_t StageInGridSizePresent;
-    uint32_t OffsetToSkipPerThreadDataLoad;
-    uint32_t OffsetToSkipSetFFIDGP;
-    uint32_t PassInlineData;
-    uint32_t RTStackIDPresent;
-    uint32_t generateLocalID;
-    uint32_t emitLocalMask;
-    uint32_t walkOrder;
-    uint32_t tileY;
-};
-
-// Update CURRENT_ICBE_VERSION when modifying the patch list
-static_assert(sizeof(SPatchThreadPayload) == (80 + sizeof(SPatchItemHeader)), "The size of SPatchThreadPayload is not what is expected");
+struct SPatchThreadPayload : SPatchItemHeader {
+  uint32_t HeaderPresent;
+  uint32_t LocalIDXPresent;
+  uint32_t LocalIDYPresent;
+  uint32_t LocalIDZPresent;
+  uint32_t LocalIDFlattenedPresent;
+  uint32_t IndirectPayloadStorage;
+  uint32_t UnusedPerThreadConstantPresent;
+  uint32_t GetLocalIDPresent;
+  uint32_t GetGroupIDPresent;
+  uint32_t GetGlobalOffsetPresent;
+  uint32_t StageInGridOriginPresent;
+  uint32_t StageInGridSizePresent;
+  uint32_t OffsetToSkipPerThreadDataLoad;
+  uint32_t OffsetToSkipSetFFIDGP;
+  uint32_t PassInlineData;
+  uint32_t RTStackIDPresent;
+  uint32_t generateLocalID;
+  uint32_t emitLocalMask;
+  uint32_t walkOrder;
+  uint32_t tileY;
+};
+
+// Update CURRENT_ICBE_VERSION when modifying the patch list
+static_assert(sizeof(SPatchThreadPayload) == (80 + sizeof(SPatchItemHeader)),
+              "The size of SPatchThreadPayload is not what is expected");
 
 /*****************************************************************************\
 STRUCT: SPatchExecutionEnvironment
 \*****************************************************************************/
-struct SPatchExecutionEnvironment :
-       SPatchItemHeader
-{
-    uint32_t    RequiredWorkGroupSizeX;
-    uint32_t    RequiredWorkGroupSizeY;
-    uint32_t    RequiredWorkGroupSizeZ;
-    uint32_t    LargestCompiledSIMDSize;
-    uint32_t    CompiledSubGroupsNumber;
-    uint32_t    HasBarriers;
-    uint32_t    HasSample;
-    uint32_t    DisableMidThreadPreemption;
-    uint32_t    CompiledSIMD8;
-    uint32_t    CompiledSIMD16;
-    uint32_t    CompiledSIMD32;
-    uint32_t    HasDeviceEnqueue;
-    uint32_t    MayAccessUndeclaredResource;
-    uint32_t    UsesFencesForReadWriteImages;
-    uint32_t    UsesStatelessSpillFill;
-    uint32_t    UsesMultiScratchSpaces;
-    uint32_t    IsCoherent;
-    uint32_t    IsInitializer;
-    uint32_t    IsFinalizer;
-    uint32_t    SubgroupIndependentForwardProgressRequired;
-    uint32_t    CompiledForGreaterThan4GBBuffers;
-    uint32_t    NumGRFRequired;
-    uint32_t    WorkgroupWalkOrderDims; // dim0 : [0 : 1]; dim1 : [2 : 3]; dim2 : [4 : 5]
-    uint32_t    HasGlobalAtomics;
-    uint32_t    HasDPAS;
-    uint32_t    HasRTCalls; // Raytracing extensions used in kernel.
-    uint32_t    NumThreadsRequired;
-    uint32_t    StatelessWritesCount;
-    uint32_t    IndirectStatelessCount;
-    uint32_t    UseBindlessMode;
-    uint32_t    HasStackCalls;
-    uint64_t    SIMDInfo;
-    uint32_t    RequireDisableEUFusion;
-};
-
-// Update CURRENT_ICBE_VERSION when modifying the patch list
-static_assert(sizeof(SPatchExecutionEnvironment) == (136 + sizeof(SPatchItemHeader)), "The size of SPatchExecutionEnvironment is not what is expected");
+struct SPatchExecutionEnvironment : SPatchItemHeader {
+  uint32_t RequiredWorkGroupSizeX;
+  uint32_t RequiredWorkGroupSizeY;
+  uint32_t RequiredWorkGroupSizeZ;
+  uint32_t LargestCompiledSIMDSize;
+  uint32_t CompiledSubGroupsNumber;
+  uint32_t HasBarriers;
+  uint32_t HasSample;
+  uint32_t DisableMidThreadPreemption;
+  uint32_t CompiledSIMD8;
+  uint32_t CompiledSIMD16;
+  uint32_t CompiledSIMD32;
+  uint32_t HasDeviceEnqueue;
+  uint32_t MayAccessUndeclaredResource;
+  uint32_t UsesFencesForReadWriteImages;
+  uint32_t UsesStatelessSpillFill;
+  uint32_t UsesMultiScratchSpaces;
+  uint32_t IsCoherent;
+  uint32_t IsInitializer;
+  uint32_t IsFinalizer;
+  uint32_t SubgroupIndependentForwardProgressRequired;
+  uint32_t CompiledForGreaterThan4GBBuffers;
+  uint32_t NumGRFRequired;
+  uint32_t WorkgroupWalkOrderDims; // dim0 : [0 : 1]; dim1 : [2 : 3]; dim2 : [4 : 5]
+  uint32_t HasGlobalAtomics;
+  uint32_t HasDPAS;
+  uint32_t HasRTCalls; // Raytracing extensions used in kernel.
+  uint32_t NumThreadsRequired;
+  uint32_t StatelessWritesCount;
+  uint32_t IndirectStatelessCount;
+  uint32_t UseBindlessMode;
+  uint32_t HasStackCalls;
+  uint64_t SIMDInfo;
+  uint32_t RequireDisableEUFusion;
+};
+
+// Update CURRENT_ICBE_VERSION when modifying the patch list
+static_assert(sizeof(SPatchExecutionEnvironment) == (136 + sizeof(SPatchItemHeader)),
+              "The size of SPatchExecutionEnvironment is not what is expected");
 
 /*****************************************************************************\
 STRUCT: SPatchString
 \*****************************************************************************/
-struct SPatchString :
-       SPatchItemHeader
-{
-    uint32_t   Index;
-    uint32_t   StringSize;
+struct SPatchString : SPatchItemHeader {
+  uint32_t Index;
+  uint32_t StringSize;
 };
 
 // Update CURRENT_ICBE_VERSION when modifying the patch list
-static_assert( sizeof( SPatchString ) == ( 8 + sizeof( SPatchItemHeader ) ) , "The size of SPatchString is not what is expected" );
+static_assert(sizeof(SPatchString) == (8 + sizeof(SPatchItemHeader)),
+              "The size of SPatchString is not what is expected");
 
 /*****************************************************************************\
 STRUCT: SPatchAllocatePrintfSurface
 \*****************************************************************************/
-struct SPatchAllocatePrintfSurface :
-       SPatchItemHeader
-{
-    uint32_t   PrintfSurfaceIndex;
-    uint32_t   Offset;
+struct SPatchAllocatePrintfSurface : SPatchItemHeader {
+  uint32_t PrintfSurfaceIndex;
+  uint32_t Offset;
 };
 
 // Update CURRENT_ICBE_VERSION when modifying the patch list
-static_assert( sizeof( SPatchAllocatePrintfSurface ) == ( 8 + sizeof( SPatchItemHeader ) ) , "The size of SPatchAllocatePrintfSurface is not what is expected" );
+static_assert(sizeof(SPatchAllocatePrintfSurface) == (8 + sizeof(SPatchItemHeader)),
+              "The size of SPatchAllocatePrintfSurface is not what is expected");
 
 /*****************************************************************************\
 STRUCT: SPatchAllocateGlobalMemorySurfaceWithInitialization
 \*****************************************************************************/
-struct SPatchAllocateGlobalMemorySurfaceWithInitialization :
-       SPatchItemHeader
-{
-    uint32_t   GlobalBufferIndex;
-    uint32_t   Offset;
+struct SPatchAllocateGlobalMemorySurfaceWithInitialization : SPatchItemHeader {
+  uint32_t GlobalBufferIndex;
+  uint32_t Offset;
 };
 
 // Update CURRENT_ICBE_VERSION when modifying the patch list
-static_assert( sizeof( SPatchAllocateGlobalMemorySurfaceWithInitialization ) == ( 8 + sizeof( SPatchItemHeader ) ) , "The size of SPatchAllocateGlobalMemorySurfaceWithInitialization is not what is expected" );
+static_assert(sizeof(SPatchAllocateGlobalMemorySurfaceWithInitialization) == (8 + sizeof(SPatchItemHeader)),
+              "The size of SPatchAllocateGlobalMemorySurfaceWithInitialization is not what is expected");
 
 /*****************************************************************************\
 STRUCT: SPatchCB2CRGatherTable
 \*****************************************************************************/
-struct SPatchCB2CRGatherTable :
-        SPatchItemHeader
-{
-    uint32_t   NumberOfEntries;
-    uint32_t   Offset;
+struct SPatchCB2CRGatherTable : SPatchItemHeader {
+  uint32_t NumberOfEntries;
+  uint32_t Offset;
 };
 
 // Update CURRENT_ICBE_VERSION when modifying the patch list
-static_assert( sizeof( SPatchCB2CRGatherTable ) == ( 8 + sizeof( SPatchItemHeader ) ) , "The size of SPatchCB2CRGatherTable is not what is expected" );
+static_assert(sizeof(SPatchCB2CRGatherTable) == (8 + sizeof(SPatchItemHeader)),
+              "The size of SPatchCB2CRGatherTable is not what is expected");
 
 /*****************************************************************************\
 STRUCT: SPatchCB2KernelArgument
 \*****************************************************************************/
-struct SPatchConstantBufferMapping :
-        SPatchItemHeader
-{
-    uint32_t   ConstantBufferType;
-    uint32_t   ConstantBufferIndex;
-    uint32_t   ConstantBufferId;
+struct SPatchConstantBufferMapping : SPatchItemHeader {
+  uint32_t ConstantBufferType;
+  uint32_t ConstantBufferIndex;
+  uint32_t ConstantBufferId;
 };
 
 // Update CURRENT_ICBE_VERSION when modifying the patch list
-static_assert( sizeof( SPatchConstantBufferMapping ) == ( 12 + sizeof( SPatchItemHeader ) ) , "The size of SPatchConstantBufferMapping is not what is expected" );
+static_assert(sizeof(SPatchConstantBufferMapping) == (12 + sizeof(SPatchItemHeader)),
+              "The size of SPatchConstantBufferMapping is not what is expected");
 
 /*****************************************************************************\
 STRUCT: SPatchStatelessGlobalMemoryObjectKernelArgument
 \*****************************************************************************/
-struct SPatchStatelessGlobalMemoryObjectKernelArgument :
-       SPatchItemHeader
-{
-    uint32_t   ArgumentNumber;
-    uint32_t   SurfaceStateHeapOffset;
-    uint32_t   DataParamOffset;
-    uint32_t   DataParamSize;
-    uint32_t   LocationIndex;
-    uint32_t   LocationIndex2;
-    uint32_t   IsEmulationArgument;
+struct SPatchStatelessGlobalMemoryObjectKernelArgument : SPatchItemHeader {
+  uint32_t ArgumentNumber;
+  uint32_t SurfaceStateHeapOffset;
+  uint32_t DataParamOffset;
+  uint32_t DataParamSize;
+  uint32_t LocationIndex;
+  uint32_t LocationIndex2;
+  uint32_t IsEmulationArgument;
 };
 
 // Update CURRENT_ICBE_VERSION when modifying the patch list
-static_assert( sizeof( SPatchStatelessGlobalMemoryObjectKernelArgument ) == ( 28 + sizeof( SPatchItemHeader ) ) , "The size of SPatchStatelessGlobalMemoryObjectKernelArgument is not what is expected" );
+static_assert(sizeof(SPatchStatelessGlobalMemoryObjectKernelArgument) == (28 + sizeof(SPatchItemHeader)),
+              "The size of SPatchStatelessGlobalMemoryObjectKernelArgument is not what is expected");
 
 /*****************************************************************************\
 STRUCT: SPatchStatelessConstantMemoryObjectKernelArgument
 \*****************************************************************************/
-struct SPatchStatelessConstantMemoryObjectKernelArgument :
-       SPatchItemHeader
-{
-    uint32_t   ArgumentNumber;
-    uint32_t   SurfaceStateHeapOffset;
-    uint32_t   DataParamOffset;
-    uint32_t   DataParamSize;
-    uint32_t   LocationIndex;
-    uint32_t   LocationIndex2;
-    uint32_t   IsEmulationArgument;
+struct SPatchStatelessConstantMemoryObjectKernelArgument : SPatchItemHeader {
+  uint32_t ArgumentNumber;
+  uint32_t SurfaceStateHeapOffset;
+  uint32_t DataParamOffset;
+  uint32_t DataParamSize;
+  uint32_t LocationIndex;
+  uint32_t LocationIndex2;
+  uint32_t IsEmulationArgument;
 };
 
 // Update CURRENT_ICBE_VERSION when modifying the patch list
-static_assert( sizeof( SPatchStatelessConstantMemoryObjectKernelArgument ) == ( 28 + sizeof( SPatchItemHeader ) ) , "The size of SPatchStatelessConstantMemoryObjectKernelArgument is not what is expected" );
+static_assert(sizeof(SPatchStatelessConstantMemoryObjectKernelArgument) == (28 + sizeof(SPatchItemHeader)),
+              "The size of SPatchStatelessConstantMemoryObjectKernelArgument is not what is expected");
 
 /*****************************************************************************\
 STRUCT: SPatchAllocateStatelessGlobalMemorySurfaceWithInitialization
 \*****************************************************************************/
-struct SPatchAllocateStatelessGlobalMemorySurfaceWithInitialization :
-    SPatchItemHeader
-{
-    uint32_t   GlobalBufferIndex;
-    uint32_t   SurfaceStateHeapOffset;
-    uint32_t   DataParamOffset;
-    uint32_t   DataParamSize;
+struct SPatchAllocateStatelessGlobalMemorySurfaceWithInitialization : SPatchItemHeader {
+  uint32_t GlobalBufferIndex;
+  uint32_t SurfaceStateHeapOffset;
+  uint32_t DataParamOffset;
+  uint32_t DataParamSize;
 };
 
 // Update CURRENT_ICBE_VERSION when modifying the patch list
-static_assert( sizeof( SPatchAllocateStatelessGlobalMemorySurfaceWithInitialization ) == ( 16 + sizeof( SPatchItemHeader ) ) , "The size of SPatchAllocateStatelessGlobalMemorySurfaceWithInitialization is not what is expected" );
+static_assert(sizeof(SPatchAllocateStatelessGlobalMemorySurfaceWithInitialization) == (16 + sizeof(SPatchItemHeader)),
+              "The size of SPatchAllocateStatelessGlobalMemorySurfaceWithInitialization is not what is expected");
 
 /*****************************************************************************\
 STRUCT: SPatchAllocateStatelessConstantMemorySurfaceWithInitialization
 \*****************************************************************************/
-struct SPatchAllocateStatelessConstantMemorySurfaceWithInitialization :
-    SPatchItemHeader
-{
-    uint32_t   ConstantBufferIndex;
-    uint32_t   SurfaceStateHeapOffset;
-    uint32_t   DataParamOffset;
-    uint32_t   DataParamSize;
+struct SPatchAllocateStatelessConstantMemorySurfaceWithInitialization : SPatchItemHeader {
+  uint32_t ConstantBufferIndex;
+  uint32_t SurfaceStateHeapOffset;
+  uint32_t DataParamOffset;
+  uint32_t DataParamSize;
 };
 
 // Update CURRENT_ICBE_VERSION when modifying the patch list
-static_assert( sizeof( SPatchAllocateStatelessConstantMemorySurfaceWithInitialization ) == ( 16 + sizeof( SPatchItemHeader ) ) , "The size of SPatchAllocateStatelessConstantMemorySurfaceWithInitialization is not what is expected" );
+static_assert(sizeof(SPatchAllocateStatelessConstantMemorySurfaceWithInitialization) == (16 + sizeof(SPatchItemHeader)),
+              "The size of SPatchAllocateStatelessConstantMemorySurfaceWithInitialization is not what is expected");
 
 /*****************************************************************************\
 STRUCT: SPatchAllocateGlobalMemorySurfaceProgramBinaryInfo
 \*****************************************************************************/
-struct SPatchAllocateGlobalMemorySurfaceProgramBinaryInfo :
-    SPatchItemHeader
-{
-    uint32_t   Type;
-    uint32_t   GlobalBufferIndex;
-    uint32_t   InlineDataSize;
+struct SPatchAllocateGlobalMemorySurfaceProgramBinaryInfo : SPatchItemHeader {
+  uint32_t Type;
+  uint32_t GlobalBufferIndex;
+  uint32_t InlineDataSize;
 };
 
 // Update CURRENT_ICBE_VERSION when modifying the patch list
-static_assert( sizeof( SPatchAllocateGlobalMemorySurfaceProgramBinaryInfo ) == ( 12 + sizeof( SPatchItemHeader ) ) , "The size of SPatchAllocateGlobalMemorySurfaceProgramBinaryInfo is not what is expected" );
+static_assert(sizeof(SPatchAllocateGlobalMemorySurfaceProgramBinaryInfo) == (12 + sizeof(SPatchItemHeader)),
+              "The size of SPatchAllocateGlobalMemorySurfaceProgramBinaryInfo is not what is expected");
 
 /*****************************************************************************\
 STRUCT: SPatchKernelTypeProgramBinaryInfo
 \*****************************************************************************/
-struct SPatchKernelTypeProgramBinaryInfo :
-    SPatchItemHeader
-{
-    uint32_t   Type; // constructor or destructor
-    uint32_t   InlineDataSize;  // size of kernel name for constructor/desctructor
+struct SPatchKernelTypeProgramBinaryInfo : SPatchItemHeader {
+  uint32_t Type;           // constructor or destructor
+  uint32_t InlineDataSize; // size of kernel name for constructor/desctructor
 };
 
 // Update CURRENT_ICBE_VERSION when modifying the patch list
-static_assert( sizeof( SPatchKernelTypeProgramBinaryInfo ) == ( 8 + sizeof( SPatchItemHeader ) ) , "The size of SPatchKernelTypeProgramBinaryInfo is not what is expected" );
+static_assert(sizeof(SPatchKernelTypeProgramBinaryInfo) == (8 + sizeof(SPatchItemHeader)),
+              "The size of SPatchKernelTypeProgramBinaryInfo is not what is expected");
 
 /*****************************************************************************\
 STRUCT: SPatchInlineVMESamplerInfo
 \*****************************************************************************/
-struct SPatchInlineVMESamplerInfo :
-       SPatchItemHeader
-{
-};
+struct SPatchInlineVMESamplerInfo : SPatchItemHeader {};
 
 // Update CURRENT_ICBE_VERSION when modifying the patch list
-static_assert( sizeof( SPatchInlineVMESamplerInfo ) == ( sizeof( SPatchItemHeader ) ) , "The size of SPatchInlineVMESamplerInfo is not what is expected" );
+static_assert(sizeof(SPatchInlineVMESamplerInfo) == (sizeof(SPatchItemHeader)),
+              "The size of SPatchInlineVMESamplerInfo is not what is expected");
 
 /*****************************************************************************\
 STRUCT: SPatchAllocateConstantMemorySurfaceProgramBinaryInfo
 \*****************************************************************************/
-struct SPatchAllocateConstantMemorySurfaceProgramBinaryInfo :
-    SPatchItemHeader
-{
-    uint32_t   ConstantBufferIndex;
-    uint32_t   InlineDataSize;
+struct SPatchAllocateConstantMemorySurfaceProgramBinaryInfo : SPatchItemHeader {
+  uint32_t ConstantBufferIndex;
+  uint32_t InlineDataSize;
 };
 
 // Update CURRENT_ICBE_VERSION when modifying the patch list
-static_assert( sizeof( SPatchAllocateConstantMemorySurfaceProgramBinaryInfo ) == ( 8 + sizeof( SPatchItemHeader ) ) , "The size of SPatchAllocateConstantMemorySurfaceProgramBinaryInfo is not what is expected" );
+static_assert(sizeof(SPatchAllocateConstantMemorySurfaceProgramBinaryInfo) == (8 + sizeof(SPatchItemHeader)),
+              "The size of SPatchAllocateConstantMemorySurfaceProgramBinaryInfo is not what is expected");
 
 /*****************************************************************************\
 STRUCT: SPatchGlobalPointerProgramBinaryInfo
 \*****************************************************************************/
-struct SPatchGlobalPointerProgramBinaryInfo :
-    SPatchItemHeader
-{
-    uint32_t   GlobalBufferIndex;
-    uint64_t   GlobalPointerOffset;
-    uint32_t   BufferType;
-    uint32_t   BufferIndex;
+struct SPatchGlobalPointerProgramBinaryInfo : SPatchItemHeader {
+  uint32_t GlobalBufferIndex;
+  uint64_t GlobalPointerOffset;
+  uint32_t BufferType;
+  uint32_t BufferIndex;
 };
 
 // Update CURRENT_ICBE_VERSION when modifying the patch list
-static_assert( sizeof( SPatchGlobalPointerProgramBinaryInfo ) == ( 20 + sizeof( SPatchItemHeader ) ) , "The size of SPatchGlobalPointerProgramBinaryInfo is not what is expected" );
+static_assert(sizeof(SPatchGlobalPointerProgramBinaryInfo) == (20 + sizeof(SPatchItemHeader)),
+              "The size of SPatchGlobalPointerProgramBinaryInfo is not what is expected");
 
 /*****************************************************************************\
 STRUCT: SPatchConstantPointerProgramBinaryInfo
 \*****************************************************************************/
-struct SPatchConstantPointerProgramBinaryInfo :
-    SPatchItemHeader
-{
-    uint32_t   ConstantBufferIndex;
-    uint64_t   ConstantPointerOffset;
-    uint32_t   BufferType;
-    uint32_t   BufferIndex;
+struct SPatchConstantPointerProgramBinaryInfo : SPatchItemHeader {
+  uint32_t ConstantBufferIndex;
+  uint64_t ConstantPointerOffset;
+  uint32_t BufferType;
+  uint32_t BufferIndex;
 };
 
 // Update CURRENT_ICBE_VERSION when modifying the patch list
-static_assert( sizeof( SPatchConstantPointerProgramBinaryInfo ) == ( 20 + sizeof( SPatchItemHeader ) ) , "The size of SPatchConstantPointerProgramBinaryInfo is not what is expected" );
+static_assert(sizeof(SPatchConstantPointerProgramBinaryInfo) == (20 + sizeof(SPatchItemHeader)),
+              "The size of SPatchConstantPointerProgramBinaryInfo is not what is expected");
 
 /*****************************************************************************\
 STRUCT: SPatchAllocateStatelessPrintfSurface
 \*****************************************************************************/
-struct SPatchAllocateStatelessPrintfSurface :
-       SPatchItemHeader
-{
-    uint32_t   PrintfSurfaceIndex;
-    uint32_t   SurfaceStateHeapOffset;
-    uint32_t   DataParamOffset;
-    uint32_t   DataParamSize;
+struct SPatchAllocateStatelessPrintfSurface : SPatchItemHeader {
+  uint32_t PrintfSurfaceIndex;
+  uint32_t SurfaceStateHeapOffset;
+  uint32_t DataParamOffset;
+  uint32_t DataParamSize;
 };
 
 // Update CURRENT_ICBE_VERSION when modifying the patch list
-static_assert( sizeof( SPatchAllocateStatelessPrintfSurface ) == ( 16 + sizeof( SPatchItemHeader ) ) , "The size of SPatchAllocateStatelessPrintfSurface is not what is expected" );
+static_assert(sizeof(SPatchAllocateStatelessPrintfSurface) == (16 + sizeof(SPatchItemHeader)),
+              "The size of SPatchAllocateStatelessPrintfSurface is not what is expected");
 
-struct SPatchAllocateSyncBuffer :
-       SPatchItemHeader
-{
-    uint32_t   SurfaceStateHeapOffset;
-    uint32_t   DataParamOffset;
-    uint32_t   DataParamSize;
+struct SPatchAllocateSyncBuffer : SPatchItemHeader {
+  uint32_t SurfaceStateHeapOffset;
+  uint32_t DataParamOffset;
+  uint32_t DataParamSize;
 };
 
 // Update CURRENT_ICBE_VERSION when modifying the patch list
-static_assert( sizeof( SPatchAllocateSyncBuffer ) == ( 12 + sizeof( SPatchItemHeader ) ), "The size of SPatchAllocateSyncBuffer is not what is expected" );
+static_assert(sizeof(SPatchAllocateSyncBuffer) == (12 + sizeof(SPatchItemHeader)),
+              "The size of SPatchAllocateSyncBuffer is not what is expected");
 
 // Raytracing
-struct SPatchAllocateRTGlobalBuffer :
-    SPatchItemHeader
-{
-    uint32_t   SurfaceStateHeapOffset;
-    uint32_t   DataParamOffset;
-    uint32_t   DataParamSize;
+struct SPatchAllocateRTGlobalBuffer : SPatchItemHeader {
+  uint32_t SurfaceStateHeapOffset;
+  uint32_t DataParamOffset;
+  uint32_t DataParamSize;
 };
 
 // Update CURRENT_ICBE_VERSION when modifying the patch list
-static_assert( sizeof( SPatchAllocateRTGlobalBuffer ) == ( 12 + sizeof( SPatchItemHeader ) ), "The size of SPatchAllocateRTGlobalBuffer is not what is expected" );
+static_assert(sizeof(SPatchAllocateRTGlobalBuffer) == (12 + sizeof(SPatchItemHeader)),
+              "The size of SPatchAllocateRTGlobalBuffer is not what is expected");
 
 /*****************************************************************************\
 STRUCT: SPatchAllocateStatelessPrivateSurface
 \*****************************************************************************/
-struct SPatchAllocateStatelessPrivateSurface :
-       SPatchItemHeader
-{
-    uint32_t   SurfaceStateHeapOffset;
-    uint32_t   DataParamOffset;
-    uint32_t   DataParamSize;
-    uint32_t   PerThreadPrivateMemorySize;
-    // if IsSimtThread is true, API assumes it is allocated per-simt-thread
-    // else, API assumes it's allocated per-hardware-thread
-    uint32_t   IsSimtThread;
+struct SPatchAllocateStatelessPrivateSurface : SPatchItemHeader {
+  uint32_t SurfaceStateHeapOffset;
+  uint32_t DataParamOffset;
+  uint32_t DataParamSize;
+  uint32_t PerThreadPrivateMemorySize;
+  // if IsSimtThread is true, API assumes it is allocated per-simt-thread
+  // else, API assumes it's allocated per-hardware-thread
+  uint32_t IsSimtThread;
 };
 
 // Update CURRENT_ICBE_VERSION when modifying the patch list
-static_assert( sizeof( SPatchAllocateStatelessPrivateSurface ) == ( 20 + sizeof( SPatchItemHeader ) ) , "The size of SPatchAllocateStatelessPrivateSurface is not what is expected" );
+static_assert(sizeof(SPatchAllocateStatelessPrivateSurface) == (20 + sizeof(SPatchItemHeader)),
+              "The size of SPatchAllocateStatelessPrivateSurface is not what is expected");
 
 /*****************************************************************************\
 STRUCT: SPatchMediaVFEState
 \*****************************************************************************/
-struct SPatchMediaVFEState :
-       SPatchItemHeader
-{
-    uint32_t   ScratchSpaceOffset;
-    uint32_t   PerThreadScratchSpace;
+struct SPatchMediaVFEState : SPatchItemHeader {
+  uint32_t ScratchSpaceOffset;
+  uint32_t PerThreadScratchSpace;
 };
 
 // Update CURRENT_ICBE_VERSION when modifying the patch list
-static_assert( sizeof( SPatchMediaVFEState ) == ( 8 + sizeof( SPatchItemHeader ) ) , "The size of SPatchMediaVFEState is not what is expected" );
+static_assert(sizeof(SPatchMediaVFEState) == (8 + sizeof(SPatchItemHeader)),
+              "The size of SPatchMediaVFEState is not what is expected");
 
 /*****************************************************************************\
 STRUCT: SPatchAllocateStatelessEventPoolSurface
 \*****************************************************************************/
-struct SPatchAllocateStatelessEventPoolSurface :
-       SPatchItemHeader
-{
-    uint32_t   EventPoolSurfaceIndex;
-    uint32_t   SurfaceStateHeapOffset;
-    uint32_t   DataParamOffset;
-    uint32_t   DataParamSize;
+struct SPatchAllocateStatelessEventPoolSurface : SPatchItemHeader {
+  uint32_t EventPoolSurfaceIndex;
+  uint32_t SurfaceStateHeapOffset;
+  uint32_t DataParamOffset;
+  uint32_t DataParamSize;
 };
 
 // Update CURRENT_ICBE_VERSION when modifying the patch list
-static_assert( sizeof( SPatchAllocateStatelessEventPoolSurface ) == ( 16 + sizeof( SPatchItemHeader ) ) , "The size of SPatchAllocateStatelessEventPoolSurface is not what is expected" );
+static_assert(sizeof(SPatchAllocateStatelessEventPoolSurface) == (16 + sizeof(SPatchItemHeader)),
+              "The size of SPatchAllocateStatelessEventPoolSurface is not what is expected");
 
 /*****************************************************************************\
 STRUCT: SPatchAllocateStatelessDefaultDeviceQueueSurface
 \*****************************************************************************/
-struct SPatchAllocateStatelessDefaultDeviceQueueSurface :
-       SPatchItemHeader
-{
-    uint32_t   SurfaceStateHeapOffset;
-    uint32_t   DataParamOffset;
-    uint32_t   DataParamSize;
+struct SPatchAllocateStatelessDefaultDeviceQueueSurface : SPatchItemHeader {
+  uint32_t SurfaceStateHeapOffset;
+  uint32_t DataParamOffset;
+  uint32_t DataParamSize;
 };
 
 // Update CURRENT_ICBE_VERSION when modifying the patch list
-static_assert( sizeof( SPatchAllocateStatelessDefaultDeviceQueueSurface ) == ( 12 + sizeof( SPatchItemHeader ) ) , "The size of SPatchAllocateStatelessDefaultDeviceQueueSurface is not what is expected" );
+static_assert(sizeof(SPatchAllocateStatelessDefaultDeviceQueueSurface) == (12 + sizeof(SPatchItemHeader)),
+              "The size of SPatchAllocateStatelessDefaultDeviceQueueSurface is not what is expected");
 
 /*****************************************************************************\
 STRUCT: SPatchStatelessDeviceQueueKernelArgument
 \*****************************************************************************/
-struct SPatchStatelessDeviceQueueKernelArgument :
-       SPatchItemHeader
-{
-    uint32_t   ArgumentNumber;
-    uint32_t   SurfaceStateHeapOffset;
-    uint32_t   DataParamOffset;
-    uint32_t   DataParamSize;
-    uint32_t   LocationIndex;
-    uint32_t   LocationIndex2;
-    uint32_t   IsEmulationArgument;
+struct SPatchStatelessDeviceQueueKernelArgument : SPatchItemHeader {
+  uint32_t ArgumentNumber;
+  uint32_t SurfaceStateHeapOffset;
+  uint32_t DataParamOffset;
+  uint32_t DataParamSize;
+  uint32_t LocationIndex;
+  uint32_t LocationIndex2;
+  uint32_t IsEmulationArgument;
 };
 
 // Update CURRENT_ICBE_VERSION when modifying the patch list
-static_assert( sizeof( SPatchStatelessDeviceQueueKernelArgument ) == ( 28 + sizeof( SPatchItemHeader ) ) , "The size of SPatchStatelessDeviceQueueKernelArgument is not what is expected" );
+static_assert(sizeof(SPatchStatelessDeviceQueueKernelArgument) == (28 + sizeof(SPatchItemHeader)),
+              "The size of SPatchStatelessDeviceQueueKernelArgument is not what is expected");
 
 /*****************************************************************************\
 STRUCT: SPatchNullSurfaceLocation
 \*****************************************************************************/
-struct SPatchNullSurfaceLocation :
-       SPatchItemHeader
-{
-    uint32_t   Offset;
+struct SPatchNullSurfaceLocation : SPatchItemHeader {
+  uint32_t Offset;
 };
 
 // Update CURRENT_ICBE_VERSION when modifying the patch list
-static_assert( sizeof( SPatchNullSurfaceLocation ) == ( 4 + sizeof( SPatchItemHeader ) ) , "The size of SPatchNullSurfaceLocation is not what is expected" );
+static_assert(sizeof(SPatchNullSurfaceLocation) == (4 + sizeof(SPatchItemHeader)),
+              "The size of SPatchNullSurfaceLocation is not what is expected");
 
 /*****************************************************************************\
 STRUCT: SPatchGtpinFreeGRFInfo
 \*****************************************************************************/
-struct SPatchGtpinFreeGRFInfo :
-    SPatchItemHeader
-{
-    uint32_t   BufferSize;
+struct SPatchGtpinFreeGRFInfo : SPatchItemHeader {
+  uint32_t BufferSize;
 };
 
 // Update CURRENT_ICBE_VERSION when modifying the patch list
-static_assert(sizeof(SPatchGtpinFreeGRFInfo) == (4 + sizeof(SPatchItemHeader)), "The size of SPatchGtpinFreeGRFInfo is not what is expected");
+static_assert(sizeof(SPatchGtpinFreeGRFInfo) == (4 + sizeof(SPatchItemHeader)),
+              "The size of SPatchGtpinFreeGRFInfo is not what is expected");
 
 /*****************************************************************************\
  STRUCT: SPatchFunctionTableInfo
  \*****************************************************************************/
-struct SPatchFunctionTableInfo :
-    SPatchItemHeader
-{
-    uint32_t   NumEntries;
+struct SPatchFunctionTableInfo : SPatchItemHeader {
+  uint32_t NumEntries;
 };
 
 // Update CURRENT_ICBE_VERSION when modifying the patch list
-static_assert(sizeof(SPatchFunctionTableInfo) == (4 + sizeof(SPatchItemHeader)), "The size of SPatchFunctionTableInfo is not what is expected");
+static_assert(sizeof(SPatchFunctionTableInfo) == (4 + sizeof(SPatchItemHeader)),
+              "The size of SPatchFunctionTableInfo is not what is expected");
 
 /*****************************************************************************\
  STRUCT: SPatchGlobalHostAccessTableInfo
  \*****************************************************************************/
-struct SPatchGlobalHostAccessTableInfo :
-    SPatchItemHeader
-{
-    uint32_t   NumEntries;
+struct SPatchGlobalHostAccessTableInfo : SPatchItemHeader {
+  uint32_t NumEntries;
 };
 
 // Update CURRENT_ICBE_VERSION when modifying the patch list
-static_assert(sizeof(SPatchGlobalHostAccessTableInfo) == (4 + sizeof(SPatchItemHeader)), "The size of SPatchGlobalHostAccessTableInfo is not what is expected");
+static_assert(sizeof(SPatchGlobalHostAccessTableInfo) == (4 + sizeof(SPatchItemHeader)),
+              "The size of SPatchGlobalHostAccessTableInfo is not what is expected");
 
-} // namespace
-#pragma pack( pop )
+} // namespace iOpenCL
+#pragma pack(pop)
diff --git a/include/igc/ocl_igc_shared/executable_format/program_debug_data.h b/include/igc/ocl_igc_shared/executable_format/program_debug_data.h
index 94f1944..6c862d9 100644
--- a/include/igc/ocl_igc_shared/executable_format/program_debug_data.h
+++ b/include/igc/ocl_igc_shared/executable_format/program_debug_data.h
@@ -10,8 +10,7 @@ SPDX-License-Identifier: MIT
 
 #include <stdint.h>
 
-namespace iOpenCL
-{
+namespace iOpenCL {
 //
 // The layout of the (IGC) program debug data is as follows:
 //
@@ -51,29 +50,25 @@ namespace iOpenCL
 /*****************************************************************************\
 STRUCT: SProgramDebugDataHeaderIGC
 \*****************************************************************************/
-typedef struct _SProgramDebugDataHeaderIGC
-{
-    uint32_t         Magic;
-    uint32_t         Version;
-    uint32_t         Size;
-    uint32_t         Device;
-    uint32_t         SteppingId;
-    uint32_t         GPUPointerSizeInBytes;
-    uint32_t         NumberOfKernels;
+typedef struct _SProgramDebugDataHeaderIGC {
+  uint32_t Magic;
+  uint32_t Version;
+  uint32_t Size;
+  uint32_t Device;
+  uint32_t SteppingId;
+  uint32_t GPUPointerSizeInBytes;
+  uint32_t NumberOfKernels;
 } SProgramDebugDataHeaderIGC;
 
-
 /*****************************************************************************\
 STRUCT: SKernelDebugDataHeaderIGC
 \*****************************************************************************/
-typedef struct _SKernelDebugDataHeaderIGC
-{
-    uint32_t         KernelNameSize;
-    uint32_t         SizeVisaDbgInBytes;
-    uint32_t         SizeGenIsaDbgInBytes;
+typedef struct _SKernelDebugDataHeaderIGC {
+  uint32_t KernelNameSize;
+  uint32_t SizeVisaDbgInBytes;
+  uint32_t SizeGenIsaDbgInBytes;
 } SKernelDebugDataHeaderIGC;
 
-
 //
 // The layout of the program debug data is as follows:
 //
@@ -137,71 +132,64 @@ typedef struct _SKernelDebugDataHeaderIGC
 /*****************************************************************************\
 STRUCT: SProgramDebugDataHeader
 \*****************************************************************************/
-typedef struct _SProgramDebugDataHeader
-{
-    uint32_t         Magic;
-    uint32_t         Version;
-    uint32_t         Size;
-    uint32_t         StringTableSize;
-    uint32_t         DirTableSize;
-    uint32_t         FileTableSize;
-    uint32_t         Device;
-    uint32_t         SteppingId;
-    uint32_t         GPUPointerSizeInBytes;
-    uint32_t         NumberOfKernels;
-    uint32_t         NumberOfKernelsWithDebugData;
+typedef struct _SProgramDebugDataHeader {
+  uint32_t Magic;
+  uint32_t Version;
+  uint32_t Size;
+  uint32_t StringTableSize;
+  uint32_t DirTableSize;
+  uint32_t FileTableSize;
+  uint32_t Device;
+  uint32_t SteppingId;
+  uint32_t GPUPointerSizeInBytes;
+  uint32_t NumberOfKernels;
+  uint32_t NumberOfKernelsWithDebugData;
 } SProgramDebugDataHeader;
 
 /*****************************************************************************\
 STRUCT: SProgramProgramDebugDataDirTableHeader
 \*****************************************************************************/
-typedef struct _SProgramDebugDataDirTableHeader
-{
-    uint32_t         NumberOfDirs;
+typedef struct _SProgramDebugDataDirTableHeader {
+  uint32_t NumberOfDirs;
 } SProgramDebugDataDirTableHeader;
 
 /*****************************************************************************\
 STRUCT: SProgramProgramDebugDataFileTableHeader
 \*****************************************************************************/
-typedef struct _SProgramDebugDataFileTableHeader
-{
-    uint32_t         NumberOfFiles;
+typedef struct _SProgramDebugDataFileTableHeader {
+  uint32_t NumberOfFiles;
 } SProgramDebugDataFileTableHeader;
 
 /*****************************************************************************\
 STRUCT: SProgramDebugDataFileTableEntry
 \*****************************************************************************/
-typedef struct _SProgramDebugDataFileTableEntry
-{
-    uint32_t         DirIndex;
+typedef struct _SProgramDebugDataFileTableEntry {
+  uint32_t DirIndex;
 } SProgramDebugDataFileTableEntry;
 
 /*****************************************************************************\
 STRUCT: SKernelDebugDataHeader
 \*****************************************************************************/
-typedef struct _SKernelDebugDataHeader
-{
-    uint32_t         KernelIndex;
-    uint32_t         CodeOffset;
-    uint32_t         Size;
+typedef struct _SKernelDebugDataHeader {
+  uint32_t KernelIndex;
+  uint32_t CodeOffset;
+  uint32_t Size;
 } SKernelDebugDataHeader;
 
 /*****************************************************************************\
 STRUCT: SKernelDebugDataLineTableHeader
 \*****************************************************************************/
-typedef struct _SKernelDebugDataLineTableHeader
-{
-    uint32_t         NumberOfEntries;
+typedef struct _SKernelDebugDataLineTableHeader {
+  uint32_t NumberOfEntries;
 } SKernelDebugDataLineTableHeader;
 
 /*****************************************************************************\
 STRUCT: SKernelDebugDataLineTableEntry
 \*****************************************************************************/
-typedef struct _SKernelDebugDataLineTableEntry
-{
-    uint32_t         Offset;
-    uint32_t         LineColumnNumber;
-    uint32_t         FileIndex;
+typedef struct _SKernelDebugDataLineTableEntry {
+  uint32_t Offset;
+  uint32_t LineColumnNumber;
+  uint32_t FileIndex;
 } SKernelDebugDataLineTableEntry;
 
-}; // iOpenCL
+}; // namespace iOpenCL
diff --git a/include/igc/ocl_igc_shared/gtpin/gtpin_driver_common.h b/include/igc/ocl_igc_shared/gtpin/gtpin_driver_common.h
index 3d1f88e..1b798ee 100644
--- a/include/igc/ocl_igc_shared/gtpin/gtpin_driver_common.h
+++ b/include/igc/ocl_igc_shared/gtpin/gtpin_driver_common.h
@@ -12,21 +12,19 @@ SPDX-License-Identifier: MIT
 #include <stdint.h>
 
 #ifdef _WIN32
-    #define GTPIN_DRIVER_CALLCONV __fastcall
+#define GTPIN_DRIVER_CALLCONV __fastcall
 #else
-    #define GTPIN_DRIVER_CALLCONV
+#define GTPIN_DRIVER_CALLCONV
 #endif
 
 /************************************************************************/
 /* Data Types                                                           */
 /************************************************************************/
-namespace gtpin
-{
+namespace gtpin {
 /// GTPin <-> Driver interface version
 
 static const uint16_t GTPIN_COMMON_INTERFACE_VERSION = 6;
 
-
 /*!
  * Common Interface Changelog:
  * 6. Added back context_handle_t for backward compatibility
@@ -38,110 +36,92 @@ static const uint16_t GTPIN_COMMON_INTERFACE_VERSION = 6;
  * 0. Not supported
  */
 
+typedef struct resource_handle_s *resource_handle_t; /// driver's handle to the resource
+typedef struct device_handle_s *device_handle_t;     /// driver's handle to the device
+typedef device_handle_t context_handle_t;            /// for backward compatibility
+typedef struct igc_init_s igc_init_t;                /// info passed by IGC
+typedef struct igc_info_s igc_info_t;                /// info passed by IGC
 
-typedef struct resource_handle_s*       resource_handle_t; /// driver's handle to the resource
-typedef struct device_handle_s*         device_handle_t;   /// driver's handle to the device
-typedef device_handle_t                 context_handle_t;  /// for backward compatibility
-typedef struct igc_init_s               igc_init_t;        /// info passed by IGC
-typedef struct igc_info_s               igc_info_t;        /// info passed by IGC
-
-
-typedef struct interface_version_s
-{
-    uint16_t    specific;
-    uint16_t    common;
+typedef struct interface_version_s {
+  uint16_t specific;
+  uint16_t common;
 } interface_version_t;
 
-
 /**
  * Gen Version
  */
-typedef enum
-{
-    GTPIN_GEN_INVALID,
-    GTPIN_GEN_8,
-    GTPIN_GEN_9,
-    GTPIN_GEN_10,
-    GTPIN_GEN_11,
-    GTPIN_GEN_12_1,
-    GTPIN_XEHP_CORE,
-    GTPIN_XE_HPG_CORE,
-    GTPIN_XE_HPC_CORE = GTPIN_XE_HPG_CORE,
+typedef enum {
+  GTPIN_GEN_INVALID,
+  GTPIN_GEN_8,
+  GTPIN_GEN_9,
+  GTPIN_GEN_10,
+  GTPIN_GEN_11,
+  GTPIN_GEN_12_1,
+  GTPIN_XEHP_CORE,
+  GTPIN_XE_HPG_CORE,
+  GTPIN_XE_HPC_CORE = GTPIN_XE_HPG_CORE,
 } GTPIN_GEN_VERSION;
 
-
 /*!
  * Possible results of GTPin driver interface functions
  */
-typedef enum
-{
-    GTPIN_DI_SUCCESS = 0,                           /// operation is successful
-    GTPIN_DI_ERROR_INVALID_ARGUMENT,                /// one of the arguments is invalid (null)
-    GTPIN_DI_ERROR_NO_INSTANCE,                     /// no instance of GTPin inside the driver
-    GTPIN_DI_ERROR_INSTANCE_ALREADY_CREATED,        /// GTPin was already initialized in the driver
-    GTPIN_DI_ERROR_ALLOCATION_FAILED,               /// failed to allocate a buffer
-    GTPIN_DI_ERROR_NO_VIRTUAL_ADDRESS_TO_BUFFER,    /// failed to obtain virtual address to the buffer
-    GTPIN_DI_FAIL,                                  /// general failure
+typedef enum {
+  GTPIN_DI_SUCCESS = 0,                        /// operation is successful
+  GTPIN_DI_ERROR_INVALID_ARGUMENT,             /// one of the arguments is invalid (null)
+  GTPIN_DI_ERROR_NO_INSTANCE,                  /// no instance of GTPin inside the driver
+  GTPIN_DI_ERROR_INSTANCE_ALREADY_CREATED,     /// GTPin was already initialized in the driver
+  GTPIN_DI_ERROR_ALLOCATION_FAILED,            /// failed to allocate a buffer
+  GTPIN_DI_ERROR_NO_VIRTUAL_ADDRESS_TO_BUFFER, /// failed to obtain virtual address to the buffer
+  GTPIN_DI_FAIL,                               /// general failure
 } GTPIN_DI_STATUS;
 
-
 /*!
  * Kernel types
  */
-typedef enum
-{
-    GTPIN_KERNEL_TYPE_INVALID,
-    GTPIN_KERNEL_TYPE_HS,      /// Hull Shader
-    GTPIN_KERNEL_TYPE_DS,      /// Domain Shader
-    GTPIN_KERNEL_TYPE_VS,      /// Vertex Shader
-    GTPIN_KERNEL_TYPE_PS,      /// Pixel Shader
-    GTPIN_KERNEL_TYPE_CS,      /// Compute Shader (GPGPU)
-    GTPIN_KERNEL_TYPE_GS       /// Geometry Shader
+typedef enum {
+  GTPIN_KERNEL_TYPE_INVALID,
+  GTPIN_KERNEL_TYPE_HS, /// Hull Shader
+  GTPIN_KERNEL_TYPE_DS, /// Domain Shader
+  GTPIN_KERNEL_TYPE_VS, /// Vertex Shader
+  GTPIN_KERNEL_TYPE_PS, /// Pixel Shader
+  GTPIN_KERNEL_TYPE_CS, /// Compute Shader (GPGPU)
+  GTPIN_KERNEL_TYPE_GS  /// Geometry Shader
 } GTPIN_KERNEL_TYPE;
 
-
 /*!
  * SIMD widths
  */
-typedef enum
-{
-    GTPIN_SIMD_INVALID,
-    GTPIN_SIMD_4x2  = 4,
-    GTPIN_SIMD_8    = 8,
-    GTPIN_SIMD_16   = 16,
-    GTPIN_SIMD_32   = 32
+typedef enum {
+  GTPIN_SIMD_INVALID,
+  GTPIN_SIMD_4x2 = 4,
+  GTPIN_SIMD_8 = 8,
+  GTPIN_SIMD_16 = 16,
+  GTPIN_SIMD_32 = 32
 } GTPIN_SIMD_WIDTH;
 
-
 /*!
  * GPU interfaces
  */
-typedef enum
-{
-    GFX_OPENCL,
-    GFX_CM,
+typedef enum {
+  GFX_OPENCL,
+  GFX_CM,
 } GFX_TARGET;
 
-
 /*!
  * Platform information
  */
-typedef struct platform_info_s
-{
-    GTPIN_GEN_VERSION   gen_version;
-    uint32_t            device_id;
+typedef struct platform_info_s {
+  GTPIN_GEN_VERSION gen_version;
+  uint32_t device_id;
 } platform_info_t;
 
-
 /*!
  * Driver information
  */
-typedef struct driver_info_s
-{
-    interface_version_t  version;
-    GFX_TARGET           gfx_target;
+typedef struct driver_info_s {
+  interface_version_t version;
+  GFX_TARGET gfx_target;
 } driver_info_t;
 
-
-}
+} // namespace gtpin
 #endif /// GPTIN_DRIVER_COMMON_H
diff --git a/include/igc/ocl_igc_shared/gtpin/gtpin_driver_common_bti.h b/include/igc/ocl_igc_shared/gtpin/gtpin_driver_common_bti.h
index 468fab0..a6990d8 100644
--- a/include/igc/ocl_igc_shared/gtpin/gtpin_driver_common_bti.h
+++ b/include/igc/ocl_igc_shared/gtpin/gtpin_driver_common_bti.h
@@ -13,127 +13,117 @@ SPDX-License-Identifier: MIT
 
 #include "gtpin_driver_common.h"
 
-
 /************************************************************************/
 /* Data Types                                                           */
 /************************************************************************/
-namespace gtpin
-{
+namespace gtpin {
 /*!
-* GTPin <-> Driver Interface Changelog:
-* 1. File reordering
-*/
+ * GTPin <-> Driver Interface Changelog:
+ * 1. File reordering
+ */
 static const uint8_t GTPIN_COMMON_BTI_INTERFACE_VERSION = 1;
 
-#define GENERATE_SPECIFIC_VERSION(PLATFORM_INTERFACE_VERSION) ((GTPIN_COMMON_BTI_INTERFACE_VERSION << 8) | PLATFORM_INTERFACE_VERSION)
-
-typedef struct command_buffer_handle_s* command_buffer_handle_t; /// driver's handle to the command buffer
+#define GENERATE_SPECIFIC_VERSION(PLATFORM_INTERFACE_VERSION)                                                          \
+  ((GTPIN_COMMON_BTI_INTERFACE_VERSION << 8) | PLATFORM_INTERFACE_VERSION)
 
+typedef struct command_buffer_handle_s *command_buffer_handle_t; /// driver's handle to the command buffer
 
 /*!
-* Resource addressing mode
-*/
-typedef enum
-{
-    GTPIN_BUFFER_BINDFULL,  /// using binding table index
-    GTPIN_BUFFER_BINDLESS,  /// using an offset to the surface table in a register
-    GTPIN_BUFFER_STATELESS, /// using an address to the resource in a register
+ * Resource addressing mode
+ */
+typedef enum {
+  GTPIN_BUFFER_BINDFULL,  /// using binding table index
+  GTPIN_BUFFER_BINDLESS,  /// using an offset to the surface table in a register
+  GTPIN_BUFFER_STATELESS, /// using an address to the resource in a register
 } GTPIN_BUFFER_TYPE;
 
-
 /*!
-* The offest of the register in the GRF.
-* e.g. r2.5(dw) will be represented as 2*256 + 5*4
-*/
-typedef struct reg_desc_s
-{
-    uint32_t    reg_offset; /// the location of the register in the GRF (in bytes)
-    uint32_t    size;       /// size of the register in bytes
+ * The offest of the register in the GRF.
+ * e.g. r2.5(dw) will be represented as 2*256 + 5*4
+ */
+typedef struct reg_desc_s {
+  uint32_t reg_offset; /// the location of the register in the GRF (in bytes)
+  uint32_t size;       /// size of the register in bytes
 } reg_desc_t;
 
-
 /*!
-* Buffer's descriptor - could be:
-* 1. BTI - binding table index (in bindfull buffer addressing)
-* 2. register (in bindless / stateless buffer addressing)
-*/
-typedef union buffer_desc_s
-{
-    uint32_t        BTI;      /// Binding table index
-    reg_desc_t      reg_desc;
+ * Buffer's descriptor - could be:
+ * 1. BTI - binding table index (in bindfull buffer addressing)
+ * 2. register (in bindless / stateless buffer addressing)
+ */
+typedef union buffer_desc_s {
+  uint32_t BTI; /// Binding table index
+  reg_desc_t reg_desc;
 } buffer_desc_t;
 
-
 /*!
-* kernel instrumentation parameters structure:
-*/
-typedef struct instrument_params_s
-{
-    GTPIN_KERNEL_TYPE   kernel_type;
-    GTPIN_SIMD_WIDTH    simd;
-    const uint8_t*      orig_kernel_binary; /// the original kernel binary
-    uint32_t            orig_kernel_size;   /// size of the kernel binary in bytes
-
-    GTPIN_BUFFER_TYPE   buffer_type;
-    buffer_desc_t       buffer_desc;
-    uint64_t            igc_hash_id;
-
-    char*               kernel_name;        /// the kernel name
-    const igc_info_t*   igc_info;           /// information form IGC
-
-    /// START Exists only from COMMON_SUPPORTED_FEATURE_SOURCELINE_MAPPING
-    const void*         debug_data;         /// debug data including the elf file
-    uint32_t            debug_data_size;    /// size of the elf file in bytes
-    /// End Exists only from COMMON_SUPPORTED_FEATURE_SOURCELINE_MAPPING
+ * kernel instrumentation parameters structure:
+ */
+typedef struct instrument_params_s {
+  GTPIN_KERNEL_TYPE kernel_type;
+  GTPIN_SIMD_WIDTH simd;
+  const uint8_t *orig_kernel_binary; /// the original kernel binary
+  uint32_t orig_kernel_size;         /// size of the kernel binary in bytes
+
+  GTPIN_BUFFER_TYPE buffer_type;
+  buffer_desc_t buffer_desc;
+  uint64_t igc_hash_id;
+
+  char *kernel_name;          /// the kernel name
+  const igc_info_t *igc_info; /// information form IGC
+
+  /// START Exists only from COMMON_SUPPORTED_FEATURE_SOURCELINE_MAPPING
+  const void *debug_data;   /// debug data including the elf file
+  uint32_t debug_data_size; /// size of the elf file in bytes
+                            /// End Exists only from COMMON_SUPPORTED_FEATURE_SOURCELINE_MAPPING
 } instrument_params_in_t;
 
-
 /*!
-* kernel instrumented data structure:
-*/
-typedef struct instrument_params_out_s
-{
-    uint8_t*            inst_kernel_binary; /// the instrumented binary
-    uint32_t            inst_kernel_size;   /// size in bytes on the instrumented binary
-    uint64_t            kernel_id;          /// GTPin's associated kernel id
+ * kernel instrumented data structure:
+ */
+typedef struct instrument_params_out_s {
+  uint8_t *inst_kernel_binary; /// the instrumented binary
+  uint32_t inst_kernel_size;   /// size in bytes on the instrumented binary
+  uint64_t kernel_id;          /// GTPin's associated kernel id
 } instrument_params_out_t;
 
-
 /*!
-* Allocate a buffer(resource) for GTPin
-*
-* @param[in]  deviceHandle  The handle to the device
-* @param[in]  size          Size of the buffer to allocate
-* @param[out] resource      The handle to the created resource
-*/
-typedef GTPIN_DI_STATUS(GTPIN_DRIVER_CALLCONV *BufferAllocateFPTR)(device_handle_t deviceHandle, uint32_t size, resource_handle_t* resource);
-
+ * Allocate a buffer(resource) for GTPin
+ *
+ * @param[in]  deviceHandle  The handle to the device
+ * @param[in]  size          Size of the buffer to allocate
+ * @param[out] resource      The handle to the created resource
+ */
+typedef GTPIN_DI_STATUS(GTPIN_DRIVER_CALLCONV *BufferAllocateFPTR)(device_handle_t deviceHandle, uint32_t size,
+                                                                   resource_handle_t *resource);
 
 /*!
-* Deallocate GTPin's buffer
-*
-* @param[in] deviceHandle   The handle to the device
-* @param[in] resource       The handle to the resource
-*/
-typedef GTPIN_DI_STATUS(GTPIN_DRIVER_CALLCONV *BufferDeallocateFPTR)(device_handle_t deviceHandle, resource_handle_t resource);
+ * Deallocate GTPin's buffer
+ *
+ * @param[in] deviceHandle   The handle to the device
+ * @param[in] resource       The handle to the resource
+ */
+typedef GTPIN_DI_STATUS(GTPIN_DRIVER_CALLCONV *BufferDeallocateFPTR)(device_handle_t deviceHandle,
+                                                                     resource_handle_t resource);
 
 /*!
-* Map GTPin's buffer to obtain the virtual address
-*
-* @param[in]  deviceHandle  The handle to the device
-* @param[in]  resource      The handle to the resource
-* @param[out] address       The virtual address of the resource
-*/
-typedef GTPIN_DI_STATUS(GTPIN_DRIVER_CALLCONV *BufferMapFPTR)(device_handle_t deviceHandle, resource_handle_t resource, uint8_t** address);
+ * Map GTPin's buffer to obtain the virtual address
+ *
+ * @param[in]  deviceHandle  The handle to the device
+ * @param[in]  resource      The handle to the resource
+ * @param[out] address       The virtual address of the resource
+ */
+typedef GTPIN_DI_STATUS(GTPIN_DRIVER_CALLCONV *BufferMapFPTR)(device_handle_t deviceHandle, resource_handle_t resource,
+                                                              uint8_t **address);
 
 /*!
-* UnMap GTPin's allocated buffer
-*
-* @param[in] deviceHandle   The handle to the device
-* @param[in] resource       The handle to the resource
-*/
-typedef GTPIN_DI_STATUS(GTPIN_DRIVER_CALLCONV *BufferUnMapFPTR)(device_handle_t deviceHandle, resource_handle_t resource);
-
+ * UnMap GTPin's allocated buffer
+ *
+ * @param[in] deviceHandle   The handle to the device
+ * @param[in] resource       The handle to the resource
+ */
+typedef GTPIN_DI_STATUS(GTPIN_DRIVER_CALLCONV *BufferUnMapFPTR)(device_handle_t deviceHandle,
+                                                                resource_handle_t resource);
 
 /************************************************************************/
 /* Services (GTPin -> Driver)                                           */
@@ -141,14 +131,13 @@ typedef GTPIN_DI_STATUS(GTPIN_DRIVER_CALLCONV *BufferUnMapFPTR)(device_handle_t
 /* and called by GTPin                                                  */
 /************************************************************************/
 
-typedef struct driver_services_s
-{
-    BufferAllocateFPTR       bufferAllocate;   /// request the Driver to allocate a buffer
-    BufferDeallocateFPTR     bufferDeallocate; /// request the Driver to de-allocate a buffer
-    BufferMapFPTR            bufferMap;        /// request the Driver to map a buffer
-    BufferUnMapFPTR          bufferUnMap;      /// request the Driver to unmap a buffer
+typedef struct driver_services_s {
+  BufferAllocateFPTR bufferAllocate;     /// request the Driver to allocate a buffer
+  BufferDeallocateFPTR bufferDeallocate; /// request the Driver to de-allocate a buffer
+  BufferMapFPTR bufferMap;               /// request the Driver to map a buffer
+  BufferUnMapFPTR bufferUnMap;           /// request the Driver to unmap a buffer
 } driver_services_t;
 
-} /// namespace gtpin
+} // namespace gtpin
 
 #endif /// GPTIN_DRIVER_COMMON_BTI_H
diff --git a/include/igc/ocl_igc_shared/gtpin/gtpin_ocl_interface.h b/include/igc/ocl_igc_shared/gtpin/gtpin_ocl_interface.h
index 08c3357..65ab733 100644
--- a/include/igc/ocl_igc_shared/gtpin/gtpin_ocl_interface.h
+++ b/include/igc/ocl_igc_shared/gtpin/gtpin_ocl_interface.h
@@ -12,16 +12,14 @@ SPDX-License-Identifier: MIT
 #include <stdint.h>
 #include "gtpin_driver_common_bti.h"
 
-namespace gtpin
-{
-namespace ocl
-{
+namespace gtpin {
+namespace ocl {
 /*!
-* GTPin <-> OpenCL Driver Interface Changelog:
-* 2. File reordering
-* 1. IGC info added
-* 0. Official release of OpenCL support
-*/
+ * GTPin <-> OpenCL Driver Interface Changelog:
+ * 2. File reordering
+ * 1. IGC info added
+ * 0. Official release of OpenCL support
+ */
 // GTPin <-> OpenCL driver interface version
 static const uint8_t GTPIN_OCL_INTERNAL_INTERFACE_VERSION = 2; /// GTPIN INTERNAL VALUE
 static const uint16_t GTPIN_OCL_INTERFACE_VERSION = GENERATE_SPECIFIC_VERSION(GTPIN_OCL_INTERNAL_INTERFACE_VERSION);
@@ -36,7 +34,6 @@ the scope of the call.
 */
 /************************************************************************/
 
-
 /************************************************************************/
 /* Events (Driver -> GTPin)                                             */
 /* The following functions are implemented by GTPin                     */
@@ -51,7 +48,7 @@ Called up on a creation of a new Device by the application
 (in)  platform_info - information about the platform
 (out) igc_init      - IGC's initialization data
 */
-typedef void(*OnContextCreateFPTR)(device_handle_t handle, platform_info_t* platform_info, igc_init_t** igc_init);
+typedef void (*OnContextCreateFPTR)(device_handle_t handle, platform_info_t *platform_info, igc_init_t **igc_init);
 
 /**
 Called up on a destruction of the device
@@ -59,7 +56,7 @@ Called up on a destruction of the device
 Params:
 (in) context - The context been destroyed.
 **/
-typedef void(*OnContextDestroyFPTR)(device_handle_t handle);
+typedef void (*OnContextDestroyFPTR)(device_handle_t handle);
 
 /**
 Called on up the creation of a new shader by the application
@@ -69,7 +66,8 @@ Called on up the creation of a new shader by the application
 (in)  params_in     -  All instrumentation parameters needed for GTPin's instrumentation
 (out) params_out    -  GTPin's instrumentation artifacts
 **/
-typedef void(*OnKernelCreateFPTR)(device_handle_t handle, const instrument_params_in_t* params_in, instrument_params_out_t* params_out);
+typedef void (*OnKernelCreateFPTR)(device_handle_t handle, const instrument_params_in_t *params_in,
+                                   instrument_params_out_t *params_out);
 
 /**
 Called up on applications call to the EnqueueNDRange API.
@@ -82,7 +80,8 @@ and is submitted into the command buffer
 (out) entry_offset  -  The entry point in the binary relative to the first instruction
 (out) resource      -  GTPin's resource for this kernel
 **/
-typedef void(*OnKernelSubmitFPTR)(command_buffer_handle_t cb, uint64_t kernel_id, uint32_t* entry_offset, resource_handle_t* resource);
+typedef void (*OnKernelSubmitFPTR)(command_buffer_handle_t cb, uint64_t kernel_id, uint32_t *entry_offset,
+                                   resource_handle_t *resource);
 
 /**
 Called up on the creation of driver's internal command buffer
@@ -91,7 +90,7 @@ Called up on the creation of driver's internal command buffer
 (in) context -  The handle of the context
 (in) cb      -  Driver's internal command buffer handle
 **/
-typedef void(*OnCommandBufferCreateFPTR)(device_handle_t handle, command_buffer_handle_t cb);
+typedef void (*OnCommandBufferCreateFPTR)(device_handle_t handle, command_buffer_handle_t cb);
 
 /**
 Called up on the submissions for execution driver's internal command buffer
@@ -100,22 +99,20 @@ Called up on the submissions for execution driver's internal command buffer
 (in) cb         -  Driver's internal command buffer handle
 (out) resource  -  GTPin's resource for polling on to identify command buffer completion
 **/
-typedef void(*OnCommandBufferCompleteFPTR)(command_buffer_handle_t cb);
-
+typedef void (*OnCommandBufferCompleteFPTR)(command_buffer_handle_t cb);
 
 /**
 Event structure:
 Holds the pointers for functions implemented by GTPin.
 Those function will be called by the Driver upon a corresponding events.
 */
-typedef struct gtpin_events_s
-{
-    OnContextCreateFPTR         onContextCreate;
-    OnContextDestroyFPTR        onContextDestroy;
-    OnKernelCreateFPTR          onKernelCreate;
-    OnKernelSubmitFPTR          onKernelSubmit;
-    OnCommandBufferCreateFPTR   onCommandBufferCreate;
-    OnCommandBufferCompleteFPTR onCommandBufferComplete;
+typedef struct gtpin_events_s {
+  OnContextCreateFPTR onContextCreate;
+  OnContextDestroyFPTR onContextDestroy;
+  OnKernelCreateFPTR onKernelCreate;
+  OnKernelSubmitFPTR onKernelSubmit;
+  OnCommandBufferCreateFPTR onCommandBufferCreate;
+  OnCommandBufferCompleteFPTR onCommandBufferComplete;
 
 } gtpin_events_t;
 
@@ -134,9 +131,9 @@ This function must be:
 (out) driver_version    - Driver's version of the interface (if NULL ignored)
 */
 
-//extern "C"
-//GTPIN_DI_STATUS GTPin_Init(gtpin::ocl::gtpin_events_t* gtpin_events, driver_services_t* driver_services,
-//                           interface_version_t* driver_version);
+// extern "C"
+// GTPIN_DI_STATUS GTPin_Init(gtpin::ocl::gtpin_events_t* gtpin_events, driver_services_t* driver_services,
+//                            interface_version_t* driver_version);
 
 } // namespace ocl
 } // namespace gtpin
diff --git a/include/igc/ocl_igc_shared/indirect_access_detection/version.h b/include/igc/ocl_igc_shared/indirect_access_detection/version.h
index 78b0e2e..76b32f8 100644
--- a/include/igc/ocl_igc_shared/indirect_access_detection/version.h
+++ b/include/igc/ocl_igc_shared/indirect_access_detection/version.h
@@ -8,9 +8,11 @@ SPDX-License-Identifier: MIT
 
 // This file stores version of indirect access detection mechanism that is supported
 // by IGC. The version is used to generate .note.intelgt.compat in ZEBinary. It is also
-// shared with Neo, so that a decision whether a kernel binary requires recompilation can
-// be made.
+// shared with Neo, so that a decision whether a kernel binary requires recompilation can be made.
+// It also includes the major version of Indirect Access Buffer layout,
+// as defined in its spec.
 
 #pragma once
 
 const uint32_t INDIRECT_ACCESS_DETECTION_VERSION = 10;
+const uint32_t INDIRECT_ACCESS_BUFFER_MAJOR_VERSION = 1;
diff --git a/include/igc/ocl_igc_shared/raytracing/ocl_raytracing_structures.h b/include/igc/ocl_igc_shared/raytracing/ocl_raytracing_structures.h
index 3a2e2e2..e1cb2ac 100644
--- a/include/igc/ocl_igc_shared/raytracing/ocl_raytracing_structures.h
+++ b/include/igc/ocl_igc_shared/raytracing/ocl_raytracing_structures.h
@@ -12,104 +12,103 @@ SPDX-License-Identifier: MIT
 
 using Vec3f = float[3];
 
-enum NodeType
-{
-  NODE_TYPE_MIXED = 0x0,        // identifies a mixed internal node where each child can have a different type
-  NODE_TYPE_INTERNAL = 0x0,     // internal BVH node with 6 children
-  NODE_TYPE_INSTANCE = 0x1,     // instance leaf
-  NODE_TYPE_PROCEDURAL = 0x3,   // procedural leaf
-  NODE_TYPE_QUAD = 0x4,         // quad leaf
-  NODE_TYPE_MESHLET = 0x6,      // meshlet leaf
-  NODE_TYPE_INVALID = 0x7       // indicates invalid node
+enum NodeType {
+  NODE_TYPE_MIXED = 0x0,      // identifies a mixed internal node where each child can have a different type
+  NODE_TYPE_INTERNAL = 0x0,   // internal BVH node with 6 children
+  NODE_TYPE_INSTANCE = 0x1,   // instance leaf
+  NODE_TYPE_PROCEDURAL = 0x3, // procedural leaf
+  NODE_TYPE_QUAD = 0x4,       // quad leaf
+  NODE_TYPE_MESHLET = 0x6,    // meshlet leaf
+  NODE_TYPE_INVALID = 0x7     // indicates invalid node
 };
 
-struct MemRay
-{
+struct MemRay {
   // 32 B
-  Vec3f org;         // the origin of the ray
-  Vec3f dir;         // the direction of the ray
-  float tnear;       // the start of the ray
-  float tfar;        // the end of the ray
+  Vec3f org;   // the origin of the ray
+  Vec3f dir;   // the direction of the ray
+  float tnear; // the start of the ray
+  float tfar;  // the end of the ray
 
   // 32 B
-  uint64_t rootNodePtr : 48;  // root node to start traversal at
-  uint64_t rayFlags : 16;     // ray flags (see RayFlag structure)
+  uint64_t rootNodePtr : 48; // root node to start traversal at
+  uint64_t rayFlags : 16;    // ray flags (see RayFlag structure)
 
   uint64_t hitGroupSRBasePtr : 48; // base of hit group shader record array (16-bytes alignment)
   uint64_t hitGroupSRStride : 16;  // stride of hit group shader record array (16-bytes alignment)
 
-  uint64_t missSRPtr : 48;  // pointer to miss shader record to invoke on a miss (8-bytes alignment)
+  uint64_t missSRPtr : 48; // pointer to miss shader record to invoke on a miss (8-bytes alignment)
   uint64_t pad : 8;
   uint64_t shaderIndexMultiplier : 8; // shader index multiplier
 
-  uint64_t instLeafPtr : 48;  // the pointer to instance leaf in case we traverse an instance (64-bytes alignment)
-  uint64_t rayMask : 8;       // ray mask used for ray masking
+  uint64_t instLeafPtr : 48; // the pointer to instance leaf in case we traverse an instance (64-bytes alignment)
+  uint64_t rayMask : 8;      // ray mask used for ray masking
 };
 static_assert(sizeof(MemRay) == 64, "Wrong MemRay size");
 
 struct MemHit {
-  float    t;                   // hit distance of current hit (or initial traversal distance)
-  float    u,v;                 // barycentric hit coordinates
-
-  uint32_t primIndexDelta  : 16; // prim index delta for compressed meshlets and quads
-  uint32_t valid           : 1; // set if there is a hit
-  uint32_t leafType        : 3; // type of node primLeafPtr is pointing to
-  uint32_t primLeafIndex   : 4; // index of the hit primitive inside the leaf
-  uint32_t bvhLevel        : 3; // the instancing level at which the hit occured
-  uint32_t frontFace       : 1; // whether we hit the front-facing side of a triangle (also used to pass opaque flag when calling intersection shaders)
-  uint32_t done            : 1; // used in sync mode to indicate that traversal is done
-  uint32_t pad0            : 3; // unused bits
-
-  uint64_t primLeafPtr     : 42; // pointer to BVH leaf node (multiple of 64 bytes)
+  float t;    // hit distance of current hit (or initial traversal distance)
+  float u, v; // barycentric hit coordinates
+
+  uint32_t primIndexDelta : 16; // prim index delta for compressed meshlets and quads
+  uint32_t valid : 1;           // set if there is a hit
+  uint32_t leafType : 3;        // type of node primLeafPtr is pointing to
+  uint32_t primLeafIndex : 4;   // index of the hit primitive inside the leaf
+  uint32_t bvhLevel : 3;        // the instancing level at which the hit occured
+  uint32_t frontFace : 1; // whether we hit the front-facing side of a triangle (also used to pass opaque flag when
+                          // calling intersection shaders)
+  uint32_t done : 1;      // used in sync mode to indicate that traversal is done
+  uint32_t pad0 : 3;      // unused bits
+
+  uint64_t primLeafPtr : 42;     // pointer to BVH leaf node (multiple of 64 bytes)
   uint64_t hitGroupRecPtr0 : 22; // LSB of hit group record of the hit triangle (multiple of 16 bytes)
-  uint64_t instLeafPtr     : 42; // pointer to BVH instance leaf node (in multiple of 64 bytes)
+  uint64_t instLeafPtr : 42;     // pointer to BVH instance leaf node (in multiple of 64 bytes)
   uint64_t hitGroupRecPtr1 : 22; // MSB of hit group record of the hit triangle (multiple of 16 bytes)
 };
 static_assert(sizeof(MemHit) == 32, "Wrong MemHit size");
 
-struct NodeInfo
-{
-  uint8_t type      : 3;
-  uint8_t  parent   : 1;  // Indicates a culled stack entry where a single parent node
-                          // is stored in place of multiple child nodes
-  uint8_t  cur_prim : 4;
+struct NodeInfo {
+  uint8_t type : 3;
+  uint8_t parent : 1; // Indicates a culled stack entry where a single parent node
+                      // is stored in place of multiple child nodes
+  uint8_t cur_prim : 4;
 };
 static_assert(sizeof(NodeInfo) == 1, "Wrong NodeInfo size");
 
 static const uint32_t MEM_STACK_SIZE = 4;
 
-struct MemTravStack
-{
-  uint64_t curDepth      : 5;        // current depth in the restart trail
-  uint64_t restartTrail0 : 29;       // lower bits of restart trail
-  uint64_t restartTrail1 : 29;       // higher bits of restart trail
-  uint64_t lastChild0    : 1;        // last child bit for node 0
-  uint32_t restartTrail2 : 29;       // highest bits of restart trail
-  uint32_t lastChild123  : 3;        // last child bit for nodes 1/2/3
+struct MemTravStack {
+  uint64_t curDepth : 5;       // current depth in the restart trail
+  uint64_t restartTrail0 : 29; // lower bits of restart trail
+  uint64_t restartTrail1 : 29; // higher bits of restart trail
+  uint64_t lastChild0 : 1;     // last child bit for node 0
+  uint32_t restartTrail2 : 29; // highest bits of restart trail
+  uint32_t lastChild123 : 3;   // last child bit for nodes 1/2/3
 
-  int32_t offset[MEM_STACK_SIZE];    // Signed offset relative to BVH root in multiples of 64B.
+  int32_t offset[MEM_STACK_SIZE]; // Signed offset relative to BVH root in multiples of 64B.
   NodeInfo nodeInfo[MEM_STACK_SIZE];
 };
 static_assert(sizeof(MemTravStack) == 32, "Wrong MemTravStack size");
 
-struct alignas(32) RTDispatchGlobals
-{
+struct alignas(32) RTDispatchGlobals {
   // Cached by HW
 public:
-  uint64_t rtMemBasePtr;               // base address of the allocated stack memory
-  uint64_t callStackHandlerKSP;        // this is the KSP of the continuation handler that is invoked by BTD when the read KSP is 0
-  uint32_t stackSizePerRay;            // maximal stack size of a ray in 64 byte blocks
-  uint32_t numDSSRTStacks;             // number of stacks per DSS
-  /* : 3; TODO: should this be a bitfield here?*/
-  uint32_t maxBVHLevels;               // the maximal number of supported instancing levels, 0->8, 1->1, 2->2, etc.
+  uint64_t rtMemBasePtr; // base address of the allocated stack memory
+  uint64_t
+      callStackHandlerKSP;  // this is the KSP of the continuation handler that is invoked by BTD when the read KSP is 0
+  uint32_t stackSizePerRay; // maximal stack size of a ray in 64 byte blocks
+  uint32_t numDSSRTStacks; // number of stacks per DSS
+  // TODO: update with:
+  // uint32_t maxBVHLevels       : 3;      // the maximal number of supported instancing levels, 0->8, 1->1, 2->2, etc.
+  // uint32_t hitGroupStride     : 13;    // stride of hit group shader records (16-bytes alignment)
+  // uint32_t missShaderStride   : 13;    // stride of miss shader records (8-bytes alignment)
+  // uint32_t _pad2_mbz          : 3;
+  uint32_t maxBVHLevels;
+  uint32_t flags : 1;
+  uint32_t pad_mbz : 31;
 
   // Not cached by HW
 public:
-  uint64_t hitGroupBasePtr;            // base pointer of hit group shader record array (16-bytes alignment)
-  uint64_t missShaderBasePtr;          // base pointer of miss shader record array (8-bytes alignment)
-  uint64_t callableShaderBasePtr;      // base pointer of callable shader record array (8-bytes alignment)
-  uint32_t hitGroupStride;             // stride of hit group shader records (16-bytes alignment)
-  uint32_t missShaderStride;           // stride of miss shader records (8-bytes alignment)
-  uint32_t callableShaderStride;       // stride of callable shader records (8-bytes alignment)
-  uint32_t dispatchRaysDimensions[3];  // dispatch dimensions of the thread grid
+  uint64_t hitGroupBasePtr;   // base pointer of hit group shader record array (16-bytes alignment)
+  uint64_t missShaderBasePtr; // base pointer of miss shader record array (8-bytes alignment)
+  uint32_t _align_mbz[4];     // pad hardware section to 64 bytes
 };
diff --git a/lib/x86_64/libiga64.so b/lib/x86_64/libiga64.so
new file mode 100644
index 0000000..1e7da46
Binary files /dev/null and b/lib/x86_64/libiga64.so differ
diff --git a/lib/x86_64/libigc.so b/lib/x86_64/libigc.so
index 7763a69..3a44997 100755
--- a/lib/x86_64/libigc.so
+++ b/lib/x86_64/libigc.so
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:409312d98ef7a67829a3e8f516c1846e0dbc8017f70299dac661ce86b0caf44d
-size 127161456
+oid sha256:cf3c37e54eaa5f28a3ac416d40cd6480dd90a89d6ee765ae847ca54ddf932716
+size 389012120
diff --git a/lib/x86_64/libigdfcl.so b/lib/x86_64/libigdfcl.so
index 679c57a..50fc1f5 100755
--- a/lib/x86_64/libigdfcl.so
+++ b/lib/x86_64/libigdfcl.so
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:f563f5f24440791ae6b77fdb00b2d8cf35cdb644a52c45851b75cd9f6f3b6d4b
-size 3935680
+oid sha256:1fdc85018bbf15d38ba826273daf0bf624b5e118564af48eddd52dae3e9ce2e6
+size 10948968
diff --git a/lib/x86_64/libopencl-clang.so b/lib/x86_64/libopencl-clang.so
index 0f0dc31..1b2bdf9 100644
--- a/lib/x86_64/libopencl-clang.so
+++ b/lib/x86_64/libopencl-clang.so
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:c31b9c57858d0425aa028fc46ab430e227bc64047aaa50076977ca1cbea4103b
-size 226734208
+oid sha256:1d821145a4352a06271557a6f61727afff9e9602b773a0fd988afa39bdd4bd60
+size 322963912