Reorganization directory structure [1/n]

Change-Id: Id1a94577437a4826a32411869f516fec20314ec0
2025-09-15 13:01:45 +08:00 · 2020-02-22 21:54:11 +01:00
parent 247cc953d1
commit fa8e720f9e
660 changed files with 3 additions and 3 deletions
--- a/opencl/source/sharings/unified/CMakeLists.txt
+++ b/opencl/source/sharings/unified/CMakeLists.txt
@ -0,0 +1,23 @@
+#
+# Copyright (C) 2019-2020 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+#
+
+set(RUNTIME_SRCS_SHARINGS_UNIFIED
+  ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
+  ${CMAKE_CURRENT_SOURCE_DIR}/enable_unified.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/unified_buffer.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/unified_buffer.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/unified_image.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/unified_image.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/unified_sharing.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/unified_sharing.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/unified_sharing_types.h
+)
+
+target_sources(${NEO_STATIC_LIB_NAME} PRIVATE ${RUNTIME_SRCS_SHARINGS_UNIFIED})
+set_property(GLOBAL PROPERTY RUNTIME_SRCS_SHARINGS_UNIFIED ${RUNTIME_SRCS_SHARINGS_UNIFIED})
+add_subdirectories()
+
+target_sources(${SHARINGS_ENABLE_LIB_NAME} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}/unified_enable_name.cpp)
--- a/opencl/source/sharings/unified/enable_unified.cpp
+++ b/opencl/source/sharings/unified/enable_unified.cpp
@ -0,0 +1,54 @@
+/*
+ * Copyright (C) 2019-2020 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "sharings/unified/enable_unified.h"
+
+#include "core/debug_settings/debug_settings_manager.h"
+
+#include "context/context.h"
+#include "context/context.inl"
+#include "sharings/sharing_factory.h"
+#include "sharings/sharing_factory.inl"
+#include "sharings/unified/unified_sharing.h"
+#include "sharings/unified/unified_sharing_types.h"
+
+#include <memory>
+
+namespace NEO {
+
+bool UnifiedSharingContextBuilder::processProperties(cl_context_properties &propertyType, cl_context_properties &propertyValue,
+                                                     cl_int &errcodeRet) {
+    switch (propertyType) {
+    case static_cast<cl_context_properties>(UnifiedSharingContextType::DeviceHandle):
+    case static_cast<cl_context_properties>(UnifiedSharingContextType::DeviceGroup):
+        this->contextData = std::make_unique<UnifiedCreateContextProperties>();
+        return true;
+    default:
+        return false;
+    }
+}
+
+bool UnifiedSharingContextBuilder::finalizeProperties(Context &context, int32_t &errcodeRet) {
+    if (contextData.get() != nullptr) {
+        if (context.getInteropUserSyncEnabled()) {
+            context.registerSharing(new UnifiedSharingFunctions());
+        }
+        contextData.reset(nullptr);
+    }
+    return true;
+}
+
+std::unique_ptr<SharingContextBuilder> UnifiedSharingBuilderFactory::createContextBuilder() {
+    return std::make_unique<UnifiedSharingContextBuilder>();
+};
+
+void *UnifiedSharingBuilderFactory::getExtensionFunctionAddress(const std::string &functionName) {
+    return nullptr;
+}
+
+static SharingFactory::RegisterSharing<UnifiedSharingBuilderFactory, UnifiedSharingFunctions> unifiedSharing;
+} // namespace NEO
--- a/opencl/source/sharings/unified/enable_unified.h
+++ b/opencl/source/sharings/unified/enable_unified.h
@ -0,0 +1,34 @@
+/*
+ * Copyright (C) 2019-2020 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#pragma once
+#include "sharings/sharing_factory.h"
+
+#include <memory>
+
+namespace NEO {
+class Context;
+
+struct UnifiedCreateContextProperties {
+};
+
+class UnifiedSharingContextBuilder : public SharingContextBuilder {
+  protected:
+    std::unique_ptr<UnifiedCreateContextProperties> contextData;
+
+  public:
+    bool processProperties(cl_context_properties &propertyType, cl_context_properties &propertyValue, cl_int &errcodeRet) override;
+    bool finalizeProperties(Context &context, int32_t &errcodeRet) override;
+};
+
+class UnifiedSharingBuilderFactory : public SharingBuilderFactory {
+  public:
+    std::unique_ptr<SharingContextBuilder> createContextBuilder() override;
+    std::string getExtensions() override;
+    void *getExtensionFunctionAddress(const std::string &functionName) override;
+};
+} // namespace NEO
--- a/opencl/source/sharings/unified/unified_buffer.cpp
+++ b/opencl/source/sharings/unified/unified_buffer.cpp
@ -0,0 +1,32 @@
+/*
+ * Copyright (C) 2019-2020 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "unified_buffer.h"
+
+#include "core/gmm_helper/gmm.h"
+#include "core/helpers/get_info.h"
+#include "core/memory_manager/memory_manager.h"
+
+#include "config.h"
+#include "context/context.h"
+#include "mem_obj/buffer.h"
+
+using namespace NEO;
+
+Buffer *UnifiedBuffer::createSharedUnifiedBuffer(Context *context, cl_mem_flags flags, UnifiedSharingMemoryDescription extMem, cl_int *errcodeRet) {
+    ErrorCodeHelper errorCode(errcodeRet, CL_SUCCESS);
+
+    auto graphicsAllocation = UnifiedBuffer::createGraphicsAllocation(context, extMem, GraphicsAllocation::AllocationType::SHARED_BUFFER);
+    if (!graphicsAllocation) {
+        errorCode.set(CL_INVALID_MEM_OBJECT);
+        return nullptr;
+    }
+
+    UnifiedSharingFunctions *sharingFunctions = context->getSharing<UnifiedSharingFunctions>();
+    auto sharingHandler = new UnifiedBuffer(sharingFunctions, extMem.type);
+    return Buffer::createSharedBuffer(context, flags, sharingHandler, graphicsAllocation);
+}
--- a/opencl/source/sharings/unified/unified_buffer.h
+++ b/opencl/source/sharings/unified/unified_buffer.h
@ -0,0 +1,22 @@
+/*
+ * Copyright (C) 2019-2020 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#pragma once
+
+#include "sharings/unified/unified_sharing.h"
+
+namespace NEO {
+class Buffer;
+class Context;
+
+class UnifiedBuffer : public UnifiedSharing {
+    using UnifiedSharing::UnifiedSharing;
+
+  public:
+    static Buffer *createSharedUnifiedBuffer(Context *context, cl_mem_flags flags, UnifiedSharingMemoryDescription description, cl_int *errcodeRet);
+};
+} // namespace NEO
--- a/opencl/source/sharings/unified/unified_enable_name.cpp
+++ b/opencl/source/sharings/unified/unified_enable_name.cpp
@ -0,0 +1,14 @@
+/*
+ * Copyright (C) 2019-2020 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "sharings/unified/enable_unified.h"
+
+namespace NEO {
+std::string UnifiedSharingBuilderFactory::getExtensions() {
+    return "";
+}
+} // namespace NEO
--- a/opencl/source/sharings/unified/unified_image.cpp
+++ b/opencl/source/sharings/unified/unified_image.cpp
@ -0,0 +1,56 @@
+/*
+ * Copyright (C) 2019-2020 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "unified_image.h"
+
+#include "core/execution_environment/execution_environment.h"
+#include "core/gmm_helper/gmm.h"
+#include "core/gmm_helper/resource_info.h"
+#include "core/helpers/get_info.h"
+#include "core/helpers/hw_helper.h"
+#include "core/memory_manager/graphics_allocation.h"
+#include "core/memory_manager/memory_manager.h"
+
+#include "context/context.h"
+#include "device/cl_device.h"
+#include "mem_obj/image.h"
+
+namespace NEO {
+
+Image *UnifiedImage::createSharedUnifiedImage(Context *context, cl_mem_flags flags, UnifiedSharingMemoryDescription description,
+                                              const cl_image_format *imageFormat, const cl_image_desc *imageDesc, cl_int *errcodeRet) {
+    ErrorCodeHelper errorCode(errcodeRet, CL_SUCCESS);
+    UnifiedSharingFunctions *sharingFunctions = context->getSharing<UnifiedSharingFunctions>();
+
+    auto *clSurfaceFormat = Image::getSurfaceFormatFromTable(flags, imageFormat, context->getDevice(0)->getHardwareInfo().capabilityTable.clVersionSupport);
+    ImageInfo imgInfo = {};
+    imgInfo.imgDesc = Image::convertDescriptor(*imageDesc);
+    imgInfo.surfaceFormat = &clSurfaceFormat->surfaceFormat;
+
+    GraphicsAllocation *graphicsAllocation = createGraphicsAllocation(context, description, GraphicsAllocation::AllocationType::SHARED_IMAGE);
+    if (!graphicsAllocation) {
+        errorCode.set(CL_INVALID_MEM_OBJECT);
+        return nullptr;
+    }
+
+    graphicsAllocation->getDefaultGmm()->updateOffsetsInImgInfo(imgInfo, 0u);
+
+    auto &memoryManager = *context->getMemoryManager();
+    if (graphicsAllocation->getDefaultGmm()->unifiedAuxTranslationCapable()) {
+        const auto &hwInfo = context->getDevice(0)->getHardwareInfo();
+        const auto &hwHelper = HwHelper::get(hwInfo.platform.eRenderCoreFamily);
+        graphicsAllocation->getDefaultGmm()->isRenderCompressed = hwHelper.isPageTableManagerSupported(hwInfo) ? memoryManager.mapAuxGpuVA(graphicsAllocation) : true;
+    }
+
+    const uint32_t baseMipmapIndex = 0u;
+    const uint32_t sharedMipmapsCount = imageDesc->num_mip_levels;
+    auto sharingHandler = new UnifiedImage(sharingFunctions, description.type);
+    return Image::createSharedImage(context, sharingHandler, McsSurfaceInfo{}, graphicsAllocation, nullptr,
+                                    flags, clSurfaceFormat, imgInfo, __GMM_NO_CUBE_MAP, baseMipmapIndex, sharedMipmapsCount);
+}
+
+} // namespace NEO
--- a/opencl/source/sharings/unified/unified_image.h
+++ b/opencl/source/sharings/unified/unified_image.h
@ -0,0 +1,23 @@
+/*
+ * Copyright (C) 2019-2020 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#pragma once
+
+#include "sharings/unified/unified_sharing.h"
+
+namespace NEO {
+class Image;
+class Context;
+
+class UnifiedImage : public UnifiedSharing {
+    using UnifiedSharing::UnifiedSharing;
+
+  public:
+    static Image *createSharedUnifiedImage(Context *context, cl_mem_flags flags, UnifiedSharingMemoryDescription description,
+                                           const cl_image_format *imageFormat, const cl_image_desc *imageDesc, cl_int *errcodeRet);
+};
+} // namespace NEO
--- a/opencl/source/sharings/unified/unified_sharing.cpp
+++ b/opencl/source/sharings/unified/unified_sharing.cpp
@ -0,0 +1,56 @@
+/*
+ * Copyright (C) 2019-2020 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "sharings/unified/unified_sharing.h"
+
+#include "core/helpers/string.h"
+#include "core/helpers/timestamp_packet.h"
+
+#include "context/context.h"
+#include "sharings/sharing_factory.h"
+
+#include <unordered_map>
+
+namespace NEO {
+
+const uint32_t UnifiedSharingFunctions::sharingId = SharingType::UNIFIED_SHARING;
+
+UnifiedSharing::UnifiedSharing(UnifiedSharingFunctions *sharingFunctions, UnifiedSharingHandleType memoryType)
+    : sharingFunctions(sharingFunctions),
+      memoryType(memoryType) {
+}
+
+void UnifiedSharing::synchronizeObject(UpdateData &updateData) {
+    updateData.synchronizationStatus = SynchronizeStatus::ACQUIRE_SUCCESFUL;
+}
+
+void UnifiedSharing::releaseResource(MemObj *memObject) {
+}
+
+GraphicsAllocation *UnifiedSharing::createGraphicsAllocation(Context *context, UnifiedSharingMemoryDescription description, GraphicsAllocation::AllocationType allocationType) {
+    auto memoryManager = context->getMemoryManager();
+    switch (description.type) {
+    case UnifiedSharingHandleType::Win32Nt: {
+        return memoryManager->createGraphicsAllocationFromNTHandle(description.handle, 0u);
+    }
+    case UnifiedSharingHandleType::LinuxFd:
+    case UnifiedSharingHandleType::Win32Shared: {
+        const AllocationProperties properties{0u, false, 0u, allocationType, false};
+        return memoryManager->createGraphicsAllocationFromSharedHandle(toOsHandle(description.handle), properties, false);
+    }
+    default:
+        return nullptr;
+    }
+}
+
+template <>
+UnifiedSharingFunctions *Context::getSharing() {
+    UNRECOVERABLE_IF(UnifiedSharingFunctions::sharingId >= sharingFunctions.size())
+    return reinterpret_cast<UnifiedSharingFunctions *>(sharingFunctions[UnifiedSharingFunctions::sharingId].get());
+}
+
+} // namespace NEO
--- a/opencl/source/sharings/unified/unified_sharing.h
+++ b/opencl/source/sharings/unified/unified_sharing.h
@ -0,0 +1,49 @@
+/*
+ * Copyright (C) 2019-2020 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#pragma once
+
+#include "core/os_interface/os_library.h"
+
+#include "CL/cl.h"
+#include "mem_obj/mem_obj.h"
+#include "sharings/sharing.h"
+#include "sharings/unified/unified_sharing_types.h"
+
+#include <functional>
+#include <mutex>
+#include <unordered_map>
+
+namespace NEO {
+
+class UnifiedSharingFunctions : public SharingFunctions {
+  public:
+    uint32_t getId() const override {
+        return UnifiedSharingFunctions::sharingId;
+    }
+    static const uint32_t sharingId;
+};
+
+class UnifiedSharing : public SharingHandler {
+  public:
+    UnifiedSharing(UnifiedSharingFunctions *sharingFunctions, UnifiedSharingHandleType memoryType);
+
+    UnifiedSharingFunctions *peekFunctionsHandler() { return sharingFunctions; }
+    UnifiedSharingHandleType getExternalMemoryType() { return memoryType; }
+
+  protected:
+    void synchronizeObject(UpdateData &updateData) override;
+    void releaseResource(MemObj *memObject) override;
+
+    static GraphicsAllocation *createGraphicsAllocation(Context *context, UnifiedSharingMemoryDescription description, GraphicsAllocation::AllocationType allocationType);
+
+  private:
+    UnifiedSharingFunctions *sharingFunctions;
+    UnifiedSharingHandleType memoryType;
+};
+
+} // namespace NEO
--- a/opencl/source/sharings/unified/unified_sharing_types.h
+++ b/opencl/source/sharings/unified/unified_sharing_types.h
@ -0,0 +1,33 @@
+/*
+ * Copyright (C) 2019-2020 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#pragma once
+
+#include <cstdint>
+
+namespace NEO {
+
+using UnifiedSharingMemoryProperties = uint64_t;
+
+enum class UnifiedSharingContextType {
+    DeviceHandle = 0x300B,
+    DeviceGroup = 0x300C
+};
+
+enum class UnifiedSharingHandleType {
+    LinuxFd = 1,
+    Win32Shared = 2,
+    Win32Nt = 3
+};
+
+struct UnifiedSharingMemoryDescription {
+    UnifiedSharingHandleType type;
+    void *handle;
+    unsigned long long size;
+};
+
+} // namespace NEO