1 /*
2  * Copyright (C) 2020-2021 Intel Corporation
3  *
4  * SPDX-License-Identifier: MIT
5  *
6  */
7 
8 #pragma once
9 
10 #include "shared/source/os_interface/os_library.h"
11 
12 #include "level_zero/api/extensions/public/ze_exp_ext.h"
13 #include "level_zero/core/source/driver/driver_handle.h"
14 #include "level_zero/core/source/get_extension_function_lookup_map.h"
15 
16 namespace L0 {
17 class HostPointerManager;
18 
19 struct DriverHandleImp : public DriverHandle {
20     ~DriverHandleImp() override;
21     DriverHandleImp();
22 
23     ze_result_t createContext(const ze_context_desc_t *desc,
24                               uint32_t numDevices,
25                               ze_device_handle_t *phDevices,
26                               ze_context_handle_t *phContext) override;
27     ze_result_t getDevice(uint32_t *pCount, ze_device_handle_t *phDevices) override;
28     ze_result_t getProperties(ze_driver_properties_t *properties) override;
29     ze_result_t getApiVersion(ze_api_version_t *version) override;
30     ze_result_t getIPCProperties(ze_driver_ipc_properties_t *pIPCProperties) override;
31     ze_result_t getExtensionFunctionAddress(const char *pFuncName, void **pfunc) override;
32     ze_result_t getExtensionProperties(uint32_t *pCount,
33                                        ze_driver_extension_properties_t *pExtensionProperties) override;
34 
35     NEO::MemoryManager *getMemoryManager() override;
36     void setMemoryManager(NEO::MemoryManager *memoryManager) override;
37     MOCKABLE_VIRTUAL void *importFdHandle(ze_device_handle_t hDevice, ze_ipc_memory_flags_t flags, uint64_t handle, NEO::GraphicsAllocation **pAlloc);
38     MOCKABLE_VIRTUAL void *importNTHandle(ze_device_handle_t hDevice, void *handle);
39     ze_result_t checkMemoryAccessFromDevice(Device *device, const void *ptr) override;
40     NEO::SVMAllocsManager *getSvmAllocsManager() override;
41     ze_result_t initialize(std::vector<std::unique_ptr<NEO::Device>> neoDevices);
42     bool findAllocationDataForRange(const void *buffer,
43                                     size_t size,
44                                     NEO::SvmAllocationData **allocData) override;
45     std::vector<NEO::SvmAllocationData *> findAllocationsWithinRange(const void *buffer,
46                                                                      size_t size,
47                                                                      bool *allocationRangeCovered) override;
48 
49     ze_result_t sysmanEventsListen(uint32_t timeout, uint32_t count, zes_device_handle_t *phDevices,
50                                    uint32_t *pNumDeviceEvents, zes_event_type_flags_t *pEvents) override;
51 
52     ze_result_t sysmanEventsListenEx(uint64_t timeout, uint32_t count, zes_device_handle_t *phDevices,
53                                      uint32_t *pNumDeviceEvents, zes_event_type_flags_t *pEvents) override;
54 
55     ze_result_t importExternalPointer(void *ptr, size_t size) override;
56     ze_result_t releaseImportedPointer(void *ptr) override;
57     ze_result_t getHostPointerBaseAddress(void *ptr, void **baseAddress) override;
58 
59     virtual NEO::GraphicsAllocation *findHostPointerAllocation(void *ptr, size_t size, uint32_t rootDeviceIndex) override;
60     virtual NEO::GraphicsAllocation *getDriverSystemMemoryAllocation(void *ptr,
61                                                                      size_t size,
62                                                                      uint32_t rootDeviceIndex,
63                                                                      uintptr_t *gpuAddress) override;
64     NEO::GraphicsAllocation *getPeerAllocation(Device *device,
65                                                NEO::SvmAllocationData *allocData,
66                                                void *basePtr,
67                                                uintptr_t *peerGpuAddress);
68     void createHostPointerManager();
69     void sortNeoDevices(std::vector<std::unique_ptr<NEO::Device>> &neoDevices);
70 
71     bool isRemoteResourceNeeded(void *ptr,
72                                 NEO::GraphicsAllocation *alloc,
73                                 NEO::SvmAllocationData *allocData,
74                                 Device *device);
75 
76     std::unique_ptr<HostPointerManager> hostPointerManager;
77     // Experimental functions
78     std::unordered_map<std::string, void *> extensionFunctionsLookupMap;
79 
80     std::mutex sharedMakeResidentAllocationsLock;
81     std::map<void *, NEO::GraphicsAllocation *> sharedMakeResidentAllocations;
82 
83     std::vector<Device *> devices;
84     // Spec extensions
85     const std::vector<std::pair<std::string, uint32_t>> extensionsSupported = {
86         {ZE_FLOAT_ATOMICS_EXT_NAME, ZE_FLOAT_ATOMICS_EXT_VERSION_CURRENT},
87         {ZE_RELAXED_ALLOCATION_LIMITS_EXP_NAME, ZE_RELAXED_ALLOCATION_LIMITS_EXP_VERSION_CURRENT},
88         {ZE_MODULE_PROGRAM_EXP_NAME, ZE_MODULE_PROGRAM_EXP_VERSION_CURRENT},
89         {ZE_KERNEL_SCHEDULING_HINTS_EXP_NAME, ZE_SCHEDULING_HINTS_EXP_VERSION_CURRENT},
90         {ZE_GLOBAL_OFFSET_EXP_NAME, ZE_GLOBAL_OFFSET_EXP_VERSION_CURRENT}};
91 
92     uint64_t uuidTimestamp = 0u;
93 
94     NEO::MemoryManager *memoryManager = nullptr;
95     NEO::SVMAllocsManager *svmAllocsManager = nullptr;
96 
97     uint32_t numDevices = 0;
98 
99     std::set<uint32_t> rootDeviceIndices = {};
100     std::map<uint32_t, NEO::DeviceBitfield> deviceBitfields;
101     void updateRootDeviceBitFields(std::unique_ptr<NEO::Device> &neoDevice);
102     void enableRootDeviceDebugger(std::unique_ptr<NEO::Device> &neoDevice);
103 
104     // Environment Variables
105     bool enableProgramDebugging = false;
106     bool enableSysman = false;
107     bool enablePciIdDeviceOrder = false;
108 };
109 
110 extern struct DriverHandleImp *GlobalDriver;
111 
112 } // namespace L0
113