Move files to core

- OsLibrary class
- sku_info directory
- gmm_lib.h header

Change-Id: Ia86280e61cd2913c546afc40c3751b42e04ab137
Signed-off-by: Mateusz Jablonski <mateusz.jablonski@intel.com>

core/compiler_interface/compiler_interface.h

@@ -8,9 +8,9 @@
 #pragma once
 #include "core/compiler_interface/compiler_cache.h"
 #include "core/helpers/string.h"
+#include "core/os_interface/os_library.h"
 #include "core/utilities/arrayref.h"
 #include "runtime/built_ins/sip.h"
-#include "runtime/os_interface/os_library.h"
 
 #include "cif/common/cif_main.h"
 #include "ocl_igc_interface/code_type.h"

core/compiler_interface/compiler_interface.inl

@@ -6,8 +6,8 @@
  */
 
 #pragma once
+#include "core/os_interface/os_library.h"
 #include "runtime/helpers/validators.h"
-#include "runtime/os_interface/os_library.h"
 
 #include "cif/builtins/memory/buffer/buffer.h"
 #include "cif/common/cif.h"

core/gmm_helper/CMakeLists.txt

@@ -0,0 +1,13 @@
+#
+# Copyright (C) 2019 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+#
+
+set(NEO_CORE_GMM_HELPER
+  ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
+  ${CMAKE_CURRENT_SOURCE_DIR}/gmm_lib.h
+)
+
+set_property(GLOBAL PROPERTY NEO_CORE_GMM_HELPER ${NEO_CORE_GMM_HELPER})
+add_subdirectories()

core/gmm_helper/gmm_lib.h

@@ -0,0 +1,22 @@
+/*
+ * Copyright (C) 2017-2019 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#pragma once
+#ifdef WIN32
+#include "core/os_interface/windows/windows_wrapper.h"
+
+#include <d3d9types.h>
+
+#include "d3dumddi.h"
+#include <d3dkmthk.h>
+#else
+#ifndef C_ASSERT
+#define C_ASSERT(e) static_assert(e, #e)
+#endif
+#define __stdcall
+#endif
+#include "GmmLib.h"

core/os_interface/CMakeLists.txt

@@ -8,6 +8,7 @@ set(NEO_CORE_OS_INTERFACE
   ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
   ${CMAKE_CURRENT_SOURCE_DIR}/aub_memory_operations_handler.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/aub_memory_operations_handler.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/os_library.h
   ${CMAKE_CURRENT_SOURCE_DIR}/os_memory.h
 )
 

core/os_interface/linux/CMakeLists.txt

@@ -8,6 +8,8 @@ set(NEO_CORE_OS_INTERFACE_LINUX
   ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
   ${CMAKE_CURRENT_SOURCE_DIR}/debug_env_reader.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/debug_env_reader.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/os_library_linux.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/os_library_linux.h
   ${CMAKE_CURRENT_SOURCE_DIR}/os_memory_linux.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/os_memory_linux.h
 )

core/os_interface/linux/os_library_linux.cpp

@@ -0,0 +1,58 @@
+/*
+ * Copyright (C) 2017-2019 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "core/os_interface/linux/os_library_linux.h"
+
+#include "core/helpers/debug_helpers.h"
+
+#include <dlfcn.h>
+
+namespace NEO {
+OsLibrary *OsLibrary::load(const std::string &name) {
+    auto ptr = new (std::nothrow) Linux::OsLibrary(name);
+    if (ptr == nullptr)
+        return nullptr;
+
+    if (!ptr->isLoaded()) {
+        delete ptr;
+        return nullptr;
+    }
+    return ptr;
+}
+namespace Linux {
+
+OsLibrary::OsLibrary(const std::string &name) {
+    if (name.empty()) {
+        this->handle = dlopen(0, RTLD_LAZY);
+    } else {
+#ifdef SANITIZER_BUILD
+        constexpr auto dlopenFlag = RTLD_LAZY;
+#else
+        constexpr auto dlopenFlag = RTLD_LAZY | RTLD_DEEPBIND;
+#endif
+        this->handle = dlopen(name.c_str(), dlopenFlag);
+    }
+}
+
+OsLibrary::~OsLibrary() {
+    if (this->handle != nullptr) {
+        dlclose(this->handle);
+        this->handle = nullptr;
+    }
+}
+
+bool OsLibrary::isLoaded() {
+    return this->handle != nullptr;
+}
+
+void *OsLibrary::getProcAddress(const std::string &procName) {
+    DEBUG_BREAK_IF(this->handle == nullptr);
+
+    return dlsym(this->handle, procName.c_str());
+}
+} // namespace Linux
+} // namespace NEO

core/os_interface/linux/os_library_linux.h

@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2017-2019 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#pragma once
+#include "core/os_interface/os_library.h"
+
+namespace NEO {
+namespace Linux {
+
+class OsLibrary : public NEO::OsLibrary {
+  private:
+    void *handle;
+
+  public:
+    OsLibrary(const std::string &name);
+    ~OsLibrary() override;
+
+    bool isLoaded() override;
+    void *getProcAddress(const std::string &procName) override;
+};
+} // namespace Linux
+} // namespace NEO

core/os_interface/os_library.h

@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2017-2019 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#pragma once
+#include <string>
+#include <type_traits>
+
+namespace NEO {
+
+struct ConvertibleProcAddr {
+    template <typename T>
+    operator T *() const {
+        static_assert(std::is_function<T>::value, "Cannot convert to non-function and non-void* type");
+        return reinterpret_cast<T *>(ptr);
+    }
+
+    operator void *() const {
+        return ptr;
+    }
+    void *ptr = nullptr;
+};
+
+class OsLibrary {
+  protected:
+    OsLibrary() = default;
+
+  public:
+    virtual ~OsLibrary() = default;
+
+    static OsLibrary *load(const std::string &name);
+
+    ConvertibleProcAddr operator[](const std::string &name) {
+        return ConvertibleProcAddr{getProcAddress(name)};
+    }
+    virtual void *getProcAddress(const std::string &procName) = 0;
+    virtual bool isLoaded() = 0;
+};
+} // namespace NEO

core/os_interface/windows/CMakeLists.txt

@@ -8,6 +8,8 @@ set(NEO_CORE_OS_INTERFACE_WINDOWS
   ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
   ${CMAKE_CURRENT_SOURCE_DIR}/debug_registry_reader.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/debug_registry_reader.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/os_library_win.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/os_library_win.h
   ${CMAKE_CURRENT_SOURCE_DIR}/os_memory_win.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/os_memory_win.h
   ${CMAKE_CURRENT_SOURCE_DIR}/windows_wrapper.h

core/os_interface/windows/os_library_win.cpp

@@ -0,0 +1,69 @@
+/*
+ * Copyright (C) 2017-2019 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "core/os_interface/windows/os_library_win.h"
+
+namespace NEO {
+
+OsLibrary *OsLibrary::load(const std::string &name) {
+    Windows::OsLibrary *ptr = new Windows::OsLibrary(name);
+
+    if (!ptr->isLoaded()) {
+        delete ptr;
+        return nullptr;
+    }
+    return ptr;
+}
+
+namespace Windows {
+decltype(&LoadLibraryExA) OsLibrary::loadLibraryExA = LoadLibraryExA;
+decltype(&GetModuleFileNameA) OsLibrary::getModuleFileNameA = GetModuleFileNameA;
+
+extern "C" IMAGE_DOS_HEADER __ImageBase;
+__inline HINSTANCE GetModuleHINSTANCE() { return (HINSTANCE)&__ImageBase; }
+
+HMODULE OsLibrary::loadDependency(const std::string &dependencyFileName) const {
+    char dllPath[MAX_PATH];
+    DWORD length = getModuleFileNameA(GetModuleHINSTANCE(), dllPath, MAX_PATH);
+    for (DWORD idx = length; idx > 0; idx--) {
+        if (dllPath[idx - 1] == '\\') {
+            dllPath[idx] = '\0';
+            break;
+        }
+    }
+    strcat_s(dllPath, MAX_PATH, dependencyFileName.c_str());
+
+    return loadLibraryExA(dllPath, NULL, 0);
+}
+
+OsLibrary::OsLibrary(const std::string &name) {
+    if (name.empty()) {
+        this->handle = GetModuleHandleA(nullptr);
+    } else {
+        this->handle = loadDependency(name);
+        if (this->handle == nullptr) {
+            this->handle = ::LoadLibraryA(name.c_str());
+        }
+    }
+}
+
+OsLibrary::~OsLibrary() {
+    if ((this->handle != nullptr) && (this->handle != GetModuleHandleA(nullptr))) {
+        ::FreeLibrary(this->handle);
+        this->handle = nullptr;
+    }
+}
+
+bool OsLibrary::isLoaded() {
+    return this->handle != nullptr;
+}
+
+void *OsLibrary::getProcAddress(const std::string &procName) {
+    return ::GetProcAddress(this->handle, procName.c_str());
+}
+} // namespace Windows
+} // namespace NEO

core/os_interface/windows/os_library_win.h

@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) 2017-2019 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#pragma once
+#include "core/os_interface/os_library.h"
+
+#define UMDF_USING_NTSTATUS
+#include "core/os_interface/windows/windows_wrapper.h"
+
+namespace NEO {
+namespace Windows {
+
+class OsLibrary : public NEO::OsLibrary {
+  private:
+    HMODULE handle;
+
+  public:
+    OsLibrary(const std::string &name);
+    ~OsLibrary();
+
+    bool isLoaded();
+    void *getProcAddress(const std::string &procName);
+
+  protected:
+    HMODULE loadDependency(const std::string &dependencyFileName) const;
+
+    static decltype(&LoadLibraryExA) loadLibraryExA;
+    static decltype(&GetModuleFileNameA) getModuleFileNameA;
+};
+} // namespace Windows
+} // namespace NEO

core/sku_info/CMakeLists.txt

@@ -0,0 +1,21 @@
+#
+# Copyright (C) 2019 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+#
+
+set(NEO_CORE_SKU_INFO_BASE
+  ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
+  ${CMAKE_CURRENT_SOURCE_DIR}/sku_info_base.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/operations/sku_info_transfer.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/definitions${BRANCH_DIR_SUFFIX}/sku_info.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/operations${BRANCH_DIR_SUFFIX}/sku_info_transfer.cpp
+)
+
+set(NEO_CORE_SKU_INFO_WINDOWS
+  ${CMAKE_CURRENT_SOURCE_DIR}/operations/windows/sku_info_receiver.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/operations/windows${BRANCH_DIR_SUFFIX}/sku_info_receiver.cpp
+)
+
+set_property(GLOBAL PROPERTY NEO_CORE_SKU_INFO_BASE ${NEO_CORE_SKU_INFO_BASE})
+set_property(GLOBAL PROPERTY NEO_CORE_SKU_INFO_WINDOWS ${NEO_CORE_SKU_INFO_WINDOWS})

core/sku_info/definitions/sku_info.h

@@ -0,0 +1,15 @@
+/*
+ * Copyright (C) 2018-2019 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#pragma once
+#include "core/sku_info/sku_info_base.h"
+
+namespace NEO {
+struct FeatureTable : FeatureTableBase {};
+
+struct WorkaroundTable : WorkaroundTableBase {};
+} // namespace NEO

core/sku_info/operations/sku_info_transfer.cpp

@@ -0,0 +1,18 @@
+/*
+ * Copyright (C) 2018-2019 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "core/sku_info/operations/sku_info_transfer.h"
+
+namespace NEO {
+void SkuInfoTransfer::transferWaTableForGmm(_WA_TABLE *dstWaTable, const NEO::WorkaroundTable *srcWaTable) {
+    transferWaTableForGmmBase(dstWaTable, srcWaTable);
+}
+
+void SkuInfoTransfer::transferFtrTableForGmm(_SKU_FEATURE_TABLE *dstFtrTable, const NEO::FeatureTable *srcFtrTable) {
+    transferFtrTableForGmmBase(dstFtrTable, srcFtrTable);
+}
+} // namespace NEO

core/sku_info/operations/sku_info_transfer.h

@@ -0,0 +1,65 @@
+/*
+ * Copyright (C) 2018-2019 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#pragma once
+#include "core/gmm_helper/gmm_lib.h"
+#include "core/sku_info/operations/sku_info_transfer.h"
+
+#include "sku_info.h"
+
+namespace NEO {
+class SkuInfoTransfer {
+  public:
+    static void transferFtrTableForGmm(_SKU_FEATURE_TABLE *dstFtrTable, const FeatureTable *srcFtrTable);
+    static void transferWaTableForGmm(_WA_TABLE *dstWaTable, const WorkaroundTable *srcWaTable);
+
+  protected:
+    static void transferFtrTableForGmmBase(_SKU_FEATURE_TABLE *dstFtrTable, const NEO::FeatureTable *srcFtrTable) {
+#define TRANSFER_FTR_TO_GMM(VAL_NAME) dstFtrTable->Ftr##VAL_NAME = srcFtrTable->ftr##VAL_NAME
+        TRANSFER_FTR_TO_GMM(StandardMipTailFormat);
+        TRANSFER_FTR_TO_GMM(ULT);
+        TRANSFER_FTR_TO_GMM(EDram);
+        TRANSFER_FTR_TO_GMM(FrameBufferLLC);
+        TRANSFER_FTR_TO_GMM(Crystalwell);
+        TRANSFER_FTR_TO_GMM(DisplayEngineS3d);
+        TRANSFER_FTR_TO_GMM(TileY);
+        TRANSFER_FTR_TO_GMM(DisplayYTiling);
+        TRANSFER_FTR_TO_GMM(Fbc);
+        TRANSFER_FTR_TO_GMM(VERing);
+        TRANSFER_FTR_TO_GMM(Vcs2);
+        TRANSFER_FTR_TO_GMM(LCIA);
+        TRANSFER_FTR_TO_GMM(IA32eGfxPTEs);
+        TRANSFER_FTR_TO_GMM(Wddm2GpuMmu);
+        TRANSFER_FTR_TO_GMM(Wddm2_1_64kbPages);
+        TRANSFER_FTR_TO_GMM(TranslationTable);
+        TRANSFER_FTR_TO_GMM(UserModeTranslationTable);
+        TRANSFER_FTR_TO_GMM(Wddm2Svm);
+        TRANSFER_FTR_TO_GMM(LLCBypass);
+        TRANSFER_FTR_TO_GMM(E2ECompression);
+        TRANSFER_FTR_TO_GMM(LinearCCS);
+        TRANSFER_FTR_TO_GMM(CCSRing);
+        TRANSFER_FTR_TO_GMM(CCSNode);
+        TRANSFER_FTR_TO_GMM(MemTypeMocsDeferPAT);
+
+#undef TRANSFER_FTR_TO_GMM
+    }
+
+    static void transferWaTableForGmmBase(_WA_TABLE *dstWaTable, const NEO::WorkaroundTable *srcWaTable) {
+#define TRANSFER_WA_TO_GMM(VAL_NAME) dstWaTable->Wa##VAL_NAME = srcWaTable->wa##VAL_NAME
+        TRANSFER_WA_TO_GMM(FbcLinearSurfaceStride);
+        TRANSFER_WA_TO_GMM(DisableEdramForDisplayRT);
+        TRANSFER_WA_TO_GMM(EncryptedEdramOnlyPartials);
+        TRANSFER_WA_TO_GMM(LosslessCompressionSurfaceStride);
+        TRANSFER_WA_TO_GMM(RestrictPitch128KB);
+        TRANSFER_WA_TO_GMM(AuxTable16KGranular);
+        TRANSFER_WA_TO_GMM(Limit128BMediaCompr);
+        TRANSFER_WA_TO_GMM(UntypedBufferCompression);
+#undef TRANSFER_WA_TO_GMM
+    }
+};
+
+} // namespace NEO

core/sku_info/operations/windows/sku_info_receiver.cpp

@@ -0,0 +1,18 @@
+/*
+ * Copyright (C) 2018-2019 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "core/sku_info/operations/windows/sku_info_receiver.h"
+
+namespace NEO {
+void SkuInfoReceiver::receiveFtrTableFromAdapterInfo(FeatureTable *ftrTable, _ADAPTER_INFO *adapterInfo) {
+    receiveFtrTableFromAdapterInfoBase(ftrTable, adapterInfo);
+}
+
+void SkuInfoReceiver::receiveWaTableFromAdapterInfo(WorkaroundTable *workaroundTable, _ADAPTER_INFO *adapterInfo) {
+    receiveWaTableFromAdapterInfoBase(workaroundTable, adapterInfo);
+}
+} // namespace NEO

core/sku_info/operations/windows/sku_info_receiver.h

@@ -0,0 +1,137 @@
+/*
+ * Copyright (C) 2018-2019 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#pragma once
+#include "core/os_interface/windows/windows_wrapper.h"
+
+#include "sku_info.h"
+#include "umKmInc/sharedata.h"
+
+namespace NEO {
+class SkuInfoReceiver {
+  public:
+    static void receiveFtrTableFromAdapterInfo(FeatureTable *ftrTable, _ADAPTER_INFO *adapterInfo);
+    static void receiveWaTableFromAdapterInfo(WorkaroundTable *workaroundTable, _ADAPTER_INFO *adapterInfo);
+
+  protected:
+    static void receiveFtrTableFromAdapterInfoBase(FeatureTable *ftrTable, _ADAPTER_INFO *adapterInfo) {
+#define RECEIVE_FTR(VAL_NAME) ftrTable->ftr##VAL_NAME = adapterInfo->SkuTable.Ftr##VAL_NAME
+        RECEIVE_FTR(Desktop);
+        RECEIVE_FTR(ChannelSwizzlingXOREnabled);
+
+        RECEIVE_FTR(GtBigDie);
+        RECEIVE_FTR(GtMediumDie);
+        RECEIVE_FTR(GtSmallDie);
+
+        RECEIVE_FTR(GT1);
+        RECEIVE_FTR(GT1_5);
+        RECEIVE_FTR(GT2);
+        RECEIVE_FTR(GT2_5);
+        RECEIVE_FTR(GT3);
+        RECEIVE_FTR(GT4);
+
+        RECEIVE_FTR(IVBM0M1Platform);
+        RECEIVE_FTR(SGTPVSKUStrapPresent);
+        RECEIVE_FTR(GTA);
+        RECEIVE_FTR(GTC);
+        RECEIVE_FTR(GTX);
+        RECEIVE_FTR(5Slice);
+
+        RECEIVE_FTR(GpGpuMidBatchPreempt);
+        RECEIVE_FTR(GpGpuThreadGroupLevelPreempt);
+        RECEIVE_FTR(GpGpuMidThreadLevelPreempt);
+
+        RECEIVE_FTR(IoMmuPageFaulting);
+        RECEIVE_FTR(Wddm2Svm);
+        RECEIVE_FTR(PooledEuEnabled);
+
+        RECEIVE_FTR(ResourceStreamer);
+
+        RECEIVE_FTR(PPGTT);
+        RECEIVE_FTR(SVM);
+        RECEIVE_FTR(EDram);
+        RECEIVE_FTR(L3IACoherency);
+        RECEIVE_FTR(IA32eGfxPTEs);
+
+        RECEIVE_FTR(3dMidBatchPreempt);
+        RECEIVE_FTR(3dObjectLevelPreempt);
+        RECEIVE_FTR(PerCtxtPreemptionGranularityControl);
+
+        RECEIVE_FTR(TileY);
+        RECEIVE_FTR(DisplayYTiling);
+        RECEIVE_FTR(TranslationTable);
+        RECEIVE_FTR(UserModeTranslationTable);
+
+        RECEIVE_FTR(EnableGuC);
+
+        RECEIVE_FTR(Fbc);
+        RECEIVE_FTR(Fbc2AddressTranslation);
+        RECEIVE_FTR(FbcBlitterTracking);
+        RECEIVE_FTR(FbcCpuTracking);
+
+        RECEIVE_FTR(Vcs2);
+        RECEIVE_FTR(VEBOX);
+        RECEIVE_FTR(SingleVeboxSlice);
+        RECEIVE_FTR(ULT);
+        RECEIVE_FTR(LCIA);
+        RECEIVE_FTR(GttCacheInvalidation);
+        RECEIVE_FTR(TileMappedResource);
+        RECEIVE_FTR(AstcHdr2D);
+        RECEIVE_FTR(AstcLdr2D);
+
+        RECEIVE_FTR(StandardMipTailFormat);
+        RECEIVE_FTR(FrameBufferLLC);
+        RECEIVE_FTR(Crystalwell);
+        RECEIVE_FTR(LLCBypass);
+        RECEIVE_FTR(DisplayEngineS3d);
+        RECEIVE_FTR(VERing);
+        RECEIVE_FTR(Wddm2GpuMmu);
+        RECEIVE_FTR(Wddm2_1_64kbPages);
+
+        RECEIVE_FTR(KmdDaf);
+        RECEIVE_FTR(SimulationMode);
+
+        RECEIVE_FTR(E2ECompression);
+        RECEIVE_FTR(LinearCCS);
+        RECEIVE_FTR(CCSRing);
+        RECEIVE_FTR(CCSNode);
+        RECEIVE_FTR(MemTypeMocsDeferPAT);
+#undef RECEIVE_FTR
+    }
+
+    static void receiveWaTableFromAdapterInfoBase(WorkaroundTable *workaroundTable, _ADAPTER_INFO *adapterInfo) {
+#define RECEIVE_WA(VAL_NAME) workaroundTable->wa##VAL_NAME = adapterInfo->WaTable.Wa##VAL_NAME
+        RECEIVE_WA(DoNotUseMIReportPerfCount);
+
+        RECEIVE_WA(EnablePreemptionGranularityControlByUMD);
+        RECEIVE_WA(SendMIFLUSHBeforeVFE);
+        RECEIVE_WA(ReportPerfCountUseGlobalContextID);
+        RECEIVE_WA(DisableLSQCROPERFforOCL);
+        RECEIVE_WA(Msaa8xTileYDepthPitchAlignment);
+        RECEIVE_WA(LosslessCompressionSurfaceStride);
+        RECEIVE_WA(FbcLinearSurfaceStride);
+        RECEIVE_WA(4kAlignUVOffsetNV12LinearSurface);
+        RECEIVE_WA(EncryptedEdramOnlyPartials);
+        RECEIVE_WA(DisableEdramForDisplayRT);
+        RECEIVE_WA(ForcePcBbFullCfgRestore);
+        RECEIVE_WA(CompressedResourceRequiresConstVA21);
+        RECEIVE_WA(DisablePerCtxtPreemptionGranularityControl);
+        RECEIVE_WA(LLCCachingUnsupported);
+        RECEIVE_WA(UseVAlign16OnTileXYBpp816);
+        RECEIVE_WA(ModifyVFEStateAfterGPGPUPreemption);
+        RECEIVE_WA(CSRUncachable);
+        RECEIVE_WA(SamplerCacheFlushBetweenRedescribedSurfaceReads);
+        RECEIVE_WA(RestrictPitch128KB);
+        RECEIVE_WA(AuxTable16KGranular);
+        RECEIVE_WA(Limit128BMediaCompr);
+        RECEIVE_WA(UntypedBufferCompression);
+        RECEIVE_WA(DisableFusedThreadScheduling);
+#undef RECEIVE_WA
+    }
+};
+
+} // namespace NEO

core/sku_info/sku_info_base.h

@@ -0,0 +1,122 @@
+/*
+ * Copyright (C) 2018-2019 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#pragma once
+
+namespace NEO {
+struct FeatureTableBase {
+    bool ftrDesktop = false;
+    bool ftrChannelSwizzlingXOREnabled = false;
+
+    bool ftrGtBigDie = false;
+    bool ftrGtMediumDie = false;
+    bool ftrGtSmallDie = false;
+
+    bool ftrGT1 = false;
+    bool ftrGT1_5 = false;
+    bool ftrGT2 = false;
+    bool ftrGT2_5 = false;
+    bool ftrGT3 = false;
+    bool ftrGT4 = false;
+
+    bool ftrIVBM0M1Platform = false;
+    bool ftrSGTPVSKUStrapPresent = false;
+    bool ftrGTA = false;
+    bool ftrGTC = false;
+    bool ftrGTX = false;
+    bool ftr5Slice = false;
+
+    bool ftrGpGpuMidBatchPreempt = false;
+    bool ftrGpGpuThreadGroupLevelPreempt = false;
+    bool ftrGpGpuMidThreadLevelPreempt = false;
+
+    bool ftrIoMmuPageFaulting = false;
+    bool ftrWddm2Svm = false;
+    bool ftrPooledEuEnabled = false;
+
+    bool ftrResourceStreamer = false;
+
+    bool ftrPPGTT = false;
+    bool ftrSVM = false;
+    bool ftrEDram = false;
+    bool ftrL3IACoherency = false;
+    bool ftrIA32eGfxPTEs = false;
+
+    bool ftr3dMidBatchPreempt = false;
+    bool ftr3dObjectLevelPreempt = false;
+    bool ftrPerCtxtPreemptionGranularityControl = false;
+
+    bool ftrTileY = false;
+    bool ftrDisplayYTiling = false;
+    bool ftrTranslationTable = false;
+    bool ftrUserModeTranslationTable = false;
+
+    bool ftrEnableGuC = false;
+
+    bool ftrFbc = false;
+    bool ftrFbc2AddressTranslation = false;
+    bool ftrFbcBlitterTracking = false;
+    bool ftrFbcCpuTracking = false;
+
+    bool ftrVcs2 = false;
+    bool ftrVEBOX = false;
+    bool ftrSingleVeboxSlice = false;
+    bool ftrULT = false;
+    bool ftrLCIA = false;
+    bool ftrGttCacheInvalidation = false;
+    bool ftrTileMappedResource = false;
+    bool ftrAstcHdr2D = false;
+    bool ftrAstcLdr2D = false;
+
+    bool ftrStandardMipTailFormat = false;
+    bool ftrFrameBufferLLC = false;
+    bool ftrCrystalwell = false;
+    bool ftrLLCBypass = false;
+    bool ftrDisplayEngineS3d = false;
+    bool ftrVERing = false;
+    bool ftrWddm2GpuMmu = false;
+    bool ftrWddm2_1_64kbPages = false;
+    bool ftrWddmHwQueues = false;
+    bool ftrMemTypeMocsDeferPAT = false;
+
+    bool ftrKmdDaf = false;
+    bool ftrSimulationMode = false;
+
+    bool ftrE2ECompression = false;
+    bool ftrLinearCCS = false;
+    bool ftrCCSRing = false;
+    bool ftrCCSNode = false;
+};
+
+struct WorkaroundTableBase {
+    bool waDoNotUseMIReportPerfCount = false;
+
+    bool waEnablePreemptionGranularityControlByUMD = false;
+    bool waSendMIFLUSHBeforeVFE = false;
+    bool waReportPerfCountUseGlobalContextID = false;
+    bool waDisableLSQCROPERFforOCL = false;
+    bool waMsaa8xTileYDepthPitchAlignment = false;
+    bool waLosslessCompressionSurfaceStride = false;
+    bool waFbcLinearSurfaceStride = false;
+    bool wa4kAlignUVOffsetNV12LinearSurface = false;
+    bool waEncryptedEdramOnlyPartials = false;
+    bool waDisableEdramForDisplayRT = false;
+    bool waForcePcBbFullCfgRestore = false;
+    bool waCompressedResourceRequiresConstVA21 = false;
+    bool waDisablePerCtxtPreemptionGranularityControl = false;
+    bool waLLCCachingUnsupported = false;
+    bool waUseVAlign16OnTileXYBpp816 = false;
+    bool waModifyVFEStateAfterGPGPUPreemption = false;
+    bool waCSRUncachable = false;
+    bool waSamplerCacheFlushBetweenRedescribedSurfaceReads = false;
+    bool waRestrictPitch128KB = false;
+    bool waLimit128BMediaCompr = false;
+    bool waUntypedBufferCompression = false;
+    bool waAuxTable16KGranular = false;
+    bool waDisableFusedThreadScheduling = false;
+};
+} // namespace NEO