Move files to core

engine_node_helper
kmdaf_listener
wddm_engine_mapper
windows_defs

Related-To: NEO-3982
Change-Id: Ia39342059bdeafa97d17f286c167138e5c40553c
Signed-off-by: Mateusz Jablonski <mateusz.jablonski@intel.com>

core/helpers/CMakeLists.txt

@@ -16,6 +16,8 @@ set(NEO_CORE_HELPERS
   ${CMAKE_CURRENT_SOURCE_DIR}/completion_stamp.h
   ${CMAKE_CURRENT_SOURCE_DIR}/debug_helpers.h
   ${CMAKE_CURRENT_SOURCE_DIR}/deferred_deleter_helper.h
+  ${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}/engine_node_helper.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/engine_node_helper.h
   ${CMAKE_CURRENT_SOURCE_DIR}/extendable_enum.h
   ${CMAKE_CURRENT_SOURCE_DIR}/file_io.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/file_io.h

core/helpers/engine_node_helper.cpp

@@ -0,0 +1,20 @@
+/*
+ * Copyright (C) 2019 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "engine_node.h"
+
+namespace NEO {
+
+bool isCcs(aub_stream::EngineType engineType) {
+    return engineType == aub_stream::ENGINE_CCS;
+}
+
+bool isBcs(aub_stream::EngineType engineType) {
+    return engineType == aub_stream::ENGINE_BCS;
+}
+
+} // namespace NEO

core/helpers/engine_node_helper.h

@@ -0,0 +1,17 @@
+/*
+ * Copyright (C) 2019 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#pragma once
+
+#include "engine_node.h"
+
+namespace NEO {
+
+bool isCcs(aub_stream::EngineType engineType);
+bool isBcs(aub_stream::EngineType engineType);
+
+} // namespace NEO

core/os_interface/windows/CMakeLists.txt

@@ -4,15 +4,26 @@
 # SPDX-License-Identifier: MIT
 #
 
+if(KMDAF_HEADERS_DIR)
+  set(KMDAF_FILE_SUFFIX "")
+else()
+  set(KMDAF_FILE_SUFFIX "_stub")
+endif()
+
 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}/kmdaf_listener${KMDAF_FILE_SUFFIX}.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/kmdaf_listener.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}/print.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}/wddm_engine_mapper.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/wddm_engine_mapper.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/windows_defs.h
   ${CMAKE_CURRENT_SOURCE_DIR}/windows_wrapper.h
 )
 

core/os_interface/windows/kmdaf_listener.cpp

@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2018-2019 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "core/os_interface/windows/kmdaf_listener.h"
+#pragma warning(push)           // save the current state
+#pragma warning(disable : 4189) // disable warning 4189 (unused local variable)
+#include "kmdaf.h"
+#pragma warning(pop) // restore state.
+
+namespace NEO {
+
+void KmDafListener::notifyLock(bool ftrKmdDaf, D3DKMT_HANDLE hAdapter, D3DKMT_HANDLE hDevice, const D3DKMT_HANDLE hAllocation, D3DDDICB_LOCKFLAGS *pLockFlags, PFND3DKMT_ESCAPE pfnEscape) {
+    KM_DAF_NOTIFY_LOCK(ftrKmdDaf, hAdapter, hDevice, hAllocation, pLockFlags, pfnEscape);
+}
+
+void KmDafListener::notifyUnlock(bool ftrKmdDaf, D3DKMT_HANDLE hAdapter, D3DKMT_HANDLE hDevice, const D3DKMT_HANDLE *phAllocation, ULONG allocations, PFND3DKMT_ESCAPE pfnEscape) {
+    KM_DAF_NOTIFY_UNLOCK(ftrKmdDaf, hAdapter, hDevice, phAllocation, allocations, pfnEscape);
+}
+
+void KmDafListener::notifyMapGpuVA(bool ftrKmdDaf, D3DKMT_HANDLE hAdapter, D3DKMT_HANDLE hDevice, const D3DKMT_HANDLE hAllocation, D3DGPU_VIRTUAL_ADDRESS GpuVirtualAddress, PFND3DKMT_ESCAPE pfnEscape) {
+    KM_DAF_NOTIFY_MAP_GPUVA(ftrKmdDaf, hAdapter, hDevice, hAllocation, GpuVirtualAddress, pfnEscape);
+}
+
+void KmDafListener::notifyUnmapGpuVA(bool ftrKmdDaf, D3DKMT_HANDLE hAdapter, D3DKMT_HANDLE hDevice, D3DGPU_VIRTUAL_ADDRESS GpuVirtualAddress, PFND3DKMT_ESCAPE pfnEscape) {
+    KM_DAF_NOTIFY_UNMAP_GPUVA(ftrKmdDaf, hAdapter, hDevice, GpuVirtualAddress, pfnEscape);
+}
+
+void KmDafListener::notifyMakeResident(bool ftrKmdDaf, D3DKMT_HANDLE hAdapter, D3DKMT_HANDLE hDevice, const D3DKMT_HANDLE *phAllocation, ULONG allocations, PFND3DKMT_ESCAPE pfnEscape) {
+    KM_DAF_NOTIFY_MAKERESIDENT(ftrKmdDaf, hAdapter, hDevice, phAllocation, allocations, pfnEscape);
+}
+
+void KmDafListener::notifyEvict(bool ftrKmdDaf, D3DKMT_HANDLE hAdapter, D3DKMT_HANDLE hDevice, const D3DKMT_HANDLE *phAllocation, ULONG allocations, PFND3DKMT_ESCAPE pfnEscape) {
+    KM_DAF_NOTIFY_EVICT(ftrKmdDaf, hAdapter, hDevice, phAllocation, allocations, pfnEscape);
+}
+
+void KmDafListener::notifyWriteTarget(bool ftrKmdDaf, D3DKMT_HANDLE hAdapter, D3DKMT_HANDLE hDevice, const D3DKMT_HANDLE hAllocation, PFND3DKMT_ESCAPE pfnEscape) {
+    KM_DAF_NOTIFY_WRITE_TARGET(ftrKmdDaf, hAdapter, hDevice, hAllocation, pfnEscape);
+}
+} // namespace NEO

core/os_interface/windows/kmdaf_listener.h

@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) 2018-2019 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#pragma once
+#include "core/os_interface/windows/windows_wrapper.h"
+
+#include <d3dkmthk.h>
+
+namespace NEO {
+
+struct KmDafListener {
+
+    MOCKABLE_VIRTUAL void notifyLock(bool ftrKmdDaf, D3DKMT_HANDLE hAdapter, D3DKMT_HANDLE hDevice, const D3DKMT_HANDLE hAllocation, D3DDDICB_LOCKFLAGS *pLockFlags, PFND3DKMT_ESCAPE pfnEscape);
+
+    MOCKABLE_VIRTUAL void notifyUnlock(bool ftrKmdDaf, D3DKMT_HANDLE hAdapter, D3DKMT_HANDLE hDevice, const D3DKMT_HANDLE *phAllocation, ULONG allocations, PFND3DKMT_ESCAPE pfnEscape);
+
+    MOCKABLE_VIRTUAL void notifyMapGpuVA(bool ftrKmdDaf, D3DKMT_HANDLE hAdapter, D3DKMT_HANDLE hDevice, const D3DKMT_HANDLE hAllocation, D3DGPU_VIRTUAL_ADDRESS GpuVirtualAddress, PFND3DKMT_ESCAPE pfnEscape);
+
+    MOCKABLE_VIRTUAL void notifyUnmapGpuVA(bool ftrKmdDaf, D3DKMT_HANDLE hAdapter, D3DKMT_HANDLE hDevice, D3DGPU_VIRTUAL_ADDRESS GpuVirtualAddress, PFND3DKMT_ESCAPE pfnEscape);
+
+    MOCKABLE_VIRTUAL void notifyMakeResident(bool ftrKmdDaf, D3DKMT_HANDLE hAdapter, D3DKMT_HANDLE hDevice, const D3DKMT_HANDLE *phAllocation, ULONG allocations, PFND3DKMT_ESCAPE pfnEscape);
+
+    MOCKABLE_VIRTUAL void notifyEvict(bool ftrKmdDaf, D3DKMT_HANDLE hAdapter, D3DKMT_HANDLE hDevice, const D3DKMT_HANDLE *phAllocation, ULONG allocations, PFND3DKMT_ESCAPE pfnEscape);
+
+    MOCKABLE_VIRTUAL void notifyWriteTarget(bool ftrKmdDaf, D3DKMT_HANDLE hAdapter, D3DKMT_HANDLE hDevice, const D3DKMT_HANDLE hAllocation, PFND3DKMT_ESCAPE pfnEscape);
+};
+} // namespace NEO

core/os_interface/windows/kmdaf_listener_stub.cpp

@@ -0,0 +1,32 @@
+/*
+ * Copyright (C) 2018-2019 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "core/os_interface/windows/kmdaf_listener.h"
+
+namespace NEO {
+
+void KmDafListener::notifyLock(bool ftrKmdDaf, D3DKMT_HANDLE hAdapter, D3DKMT_HANDLE hDevice, const D3DKMT_HANDLE hAllocation, D3DDDICB_LOCKFLAGS *pLockFlags, PFND3DKMT_ESCAPE pfnEscape) {
+}
+
+void KmDafListener::notifyUnlock(bool ftrKmdDaf, D3DKMT_HANDLE hAdapter, D3DKMT_HANDLE hDevice, const D3DKMT_HANDLE *phAllocation, ULONG allocations, PFND3DKMT_ESCAPE pfnEscape) {
+}
+
+void KmDafListener::notifyMapGpuVA(bool ftrKmdDaf, D3DKMT_HANDLE hAdapter, D3DKMT_HANDLE hDevice, const D3DKMT_HANDLE hAllocation, D3DGPU_VIRTUAL_ADDRESS GpuVirtualAddress, PFND3DKMT_ESCAPE pfnEscape) {
+}
+
+void KmDafListener::notifyUnmapGpuVA(bool ftrKmdDaf, D3DKMT_HANDLE hAdapter, D3DKMT_HANDLE hDevice, D3DGPU_VIRTUAL_ADDRESS GpuVirtualAddress, PFND3DKMT_ESCAPE pfnEscape) {
+}
+
+void KmDafListener::notifyMakeResident(bool ftrKmdDaf, D3DKMT_HANDLE hAdapter, D3DKMT_HANDLE hDevice, const D3DKMT_HANDLE *phAllocation, ULONG allocations, PFND3DKMT_ESCAPE pfnEscape) {
+}
+
+void KmDafListener::notifyEvict(bool ftrKmdDaf, D3DKMT_HANDLE hAdapter, D3DKMT_HANDLE hDevice, const D3DKMT_HANDLE *phAllocation, ULONG allocations, PFND3DKMT_ESCAPE pfnEscape) {
+}
+
+void KmDafListener::notifyWriteTarget(bool ftrKmdDaf, D3DKMT_HANDLE hAdapter, D3DKMT_HANDLE hDevice, const D3DKMT_HANDLE hAllocation, PFND3DKMT_ESCAPE pfnEscape) {
+}
+} // namespace NEO

core/os_interface/windows/wddm_engine_mapper.cpp

@@ -0,0 +1,25 @@
+/*
+ * Copyright (C) 2018-2019 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "core/os_interface/windows/wddm_engine_mapper.h"
+
+#include "core/helpers/debug_helpers.h"
+
+namespace NEO {
+
+GPUNODE_ORDINAL WddmEngineMapper::engineNodeMap(aub_stream::EngineType engineType) {
+    if (aub_stream::ENGINE_RCS == engineType) {
+        return GPUNODE_3D;
+    } else if (aub_stream::ENGINE_BCS == engineType) {
+        return GPUNODE_BLT;
+    } else if (aub_stream::ENGINE_CCS == engineType) {
+        return GPUNODE_CCS0;
+    }
+    UNRECOVERABLE_IF(true);
+}
+
+} // namespace NEO

core/os_interface/windows/wddm_engine_mapper.h

@@ -0,0 +1,21 @@
+/*
+ * Copyright (C) 2017-2019 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#pragma once
+
+#include "core/gmm_helper/gmm_lib.h"
+
+#include "engine_node.h"
+
+namespace NEO {
+
+class WddmEngineMapper {
+  public:
+    static GPUNODE_ORDINAL engineNodeMap(aub_stream::EngineType engineType);
+};
+
+} // namespace NEO

core/os_interface/windows/windows_defs.h

@@ -0,0 +1,27 @@
+/*
+ * Copyright (C) 2018-2019 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#pragma once
+
+#include "Windows.h"
+#include <d3dkmthk.h>
+
+#include <cstdint>
+
+namespace NEO {
+
+constexpr uintptr_t windowsMinAddress = 0x200000;
+
+struct MonitoredFence {
+    D3DKMT_HANDLE fenceHandle = 0;
+    D3DGPU_VIRTUAL_ADDRESS gpuAddress = 0;
+    volatile uint64_t *cpuAddress = nullptr;
+    volatile uint64_t currentFenceValue = 0;
+    uint64_t lastSubmittedFence = 0;
+};
+
+} // namespace NEO