1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
|
/*
* Copyright (C) 2017-2020 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#include "shared/source/debug_settings/debug_settings_manager.h"
#include "shared/source/memory_manager/multi_graphics_allocation.h"
#include "opencl/extensions/public/cl_ext_private.h"
#include "opencl/source/api/cl_types.h"
#include "opencl/source/helpers/base_object.h"
#include "opencl/source/helpers/destructor_callback.h"
#include "opencl/source/helpers/mipmap.h"
#include "opencl/source/mem_obj/map_operations_handler.h"
#include "opencl/source/sharings/sharing.h"
#include "memory_properties_flags.h"
#include <atomic>
#include <cstdint>
#include <list>
#include <vector>
namespace NEO {
class ExecutionEnvironment;
class GraphicsAllocation;
struct KernelInfo;
class MemoryManager;
class Context;
template <>
struct OpenCLObjectMapper<_cl_mem> {
typedef class MemObj DerivedType;
};
class MemObj : public BaseObject<_cl_mem> {
public:
constexpr static cl_ulong maskMagic = 0xFFFFFFFFFFFFFF00LL;
constexpr static cl_ulong objectMagic = 0xAB2212340CACDD00LL;
MemObj(Context *context,
cl_mem_object_type memObjectType,
const MemoryProperties &memoryProperties,
cl_mem_flags flags,
cl_mem_flags_intel flagsIntel,
size_t size,
void *memoryStorage,
void *hostPtr,
MultiGraphicsAllocation multiGraphicsAllocation,
bool zeroCopy,
bool isHostPtrSVM,
bool isObjectRedescrbied);
~MemObj() override;
cl_int getMemObjectInfo(cl_mem_info paramName,
size_t paramValueSize,
void *paramValue,
size_t *paramValueSizeRet);
cl_int setDestructorCallback(void(CL_CALLBACK *funcNotify)(cl_mem, void *),
void *userData);
void *getCpuAddress() const;
void *getHostPtr() const;
bool getIsObjectRedescribed() const { return isObjectRedescribed; };
size_t getSize() const;
bool addMappedPtr(void *ptr, size_t ptrLength, cl_map_flags &mapFlags, MemObjSizeArray &size, MemObjOffsetArray &offset, uint32_t mipLevel);
bool findMappedPtr(void *mappedPtr, MapInfo &outMapInfo) { return mapOperationsHandler.find(mappedPtr, outMapInfo); }
void removeMappedPtr(void *mappedPtr) { mapOperationsHandler.remove(mappedPtr); }
void *getBasePtrForMap(uint32_t rootDeviceIndex);
MOCKABLE_VIRTUAL void setAllocatedMapPtr(void *allocatedMapPtr);
void *getAllocatedMapPtr() const { return allocatedMapPtr; }
void setHostPtrMinSize(size_t size);
void releaseAllocatedMapPtr();
void releaseMapAllocation(uint32_t rootDeviceIndex, bool asyncDestroy);
bool isMemObjZeroCopy() const;
bool isMemObjWithHostPtrSVM() const;
bool isMemObjUncacheable() const;
bool isMemObjUncacheableForSurfaceState() const;
virtual void transferDataToHostPtr(MemObjSizeArray ©Size, MemObjOffsetArray ©Offset) { UNRECOVERABLE_IF(true); };
virtual void transferDataFromHostPtr(MemObjSizeArray ©Size, MemObjOffsetArray ©Offset) { UNRECOVERABLE_IF(true); };
GraphicsAllocation *getGraphicsAllocation(uint32_t rootDeviceIndex) const;
void resetGraphicsAllocation(GraphicsAllocation *newGraphicsAllocation);
void removeGraphicsAllocation(uint32_t rootDeviceIndex);
GraphicsAllocation *getMcsAllocation() { return mcsAllocation; }
void setMcsAllocation(GraphicsAllocation *alloc) { mcsAllocation = alloc; }
bool readMemObjFlagsInvalid();
bool writeMemObjFlagsInvalid();
bool mapMemObjFlagsInvalid(cl_map_flags mapFlags);
MOCKABLE_VIRTUAL bool isTiledAllocation() const;
void *getCpuAddressForMapping();
void *getCpuAddressForMemoryTransfer();
std::shared_ptr<SharingHandler> &getSharingHandler() { return sharingHandler; }
SharingHandler *peekSharingHandler() const { return sharingHandler.get(); }
void setSharingHandler(SharingHandler *sharingHandler) { this->sharingHandler.reset(sharingHandler); }
void setParentSharingHandler(std::shared_ptr<SharingHandler> &handler) { sharingHandler = handler; }
unsigned int acquireCount = 0;
Context *getContext() const { return context; }
void destroyGraphicsAllocation(GraphicsAllocation *allocation, bool asyncDestroy);
bool checkIfMemoryTransferIsRequired(size_t offsetInMemObject, size_t offsetInHostPtr, const void *ptr, cl_command_type cmdType);
bool mappingOnCpuAllowed() const;
virtual size_t calculateOffsetForMapping(const MemObjOffsetArray &offset) const { return offset[0]; }
size_t calculateMappedPtrLength(const MemObjSizeArray &size) const { return calculateOffsetForMapping(size); }
cl_mem_object_type peekClMemObjType() const { return memObjectType; }
size_t getOffset() const { return offset; }
MemoryManager *getMemoryManager() const {
return memoryManager;
}
void setMapAllocation(GraphicsAllocation *allocation) {
mapAllocations.addAllocation(allocation);
}
GraphicsAllocation *getMapAllocation(uint32_t rootDeviceIndex) const {
if (associatedMemObject) {
return associatedMemObject->getMapAllocation(rootDeviceIndex);
}
return mapAllocations.getGraphicsAllocation(rootDeviceIndex);
}
const cl_mem_flags &getFlags() const { return flags; }
const cl_mem_flags &getFlagsIntel() const { return flagsIntel; }
const MultiGraphicsAllocation &getMultiGraphicsAllocation() const { return multiGraphicsAllocation; }
protected:
void getOsSpecificMemObjectInfo(const cl_mem_info ¶mName, size_t *srcParamSize, void **srcParam);
void storeProperties(const cl_mem_properties *properties);
void checkUsageAndReleaseOldAllocation(uint32_t rootDeviceIndex);
Context *context;
cl_mem_object_type memObjectType;
MemoryProperties memoryProperties;
cl_mem_flags flags = 0;
cl_mem_flags_intel flagsIntel = 0;
size_t size;
size_t hostPtrMinSize = 0;
void *memoryStorage;
void *hostPtr;
void *allocatedMapPtr = nullptr;
MapOperationsHandler mapOperationsHandler;
size_t offset = 0;
MemObj *associatedMemObject = nullptr;
cl_uint refCount = 0;
ExecutionEnvironment *executionEnvironment = nullptr;
bool isZeroCopy;
bool isHostPtrSVM;
bool isObjectRedescribed;
MemoryManager *memoryManager = nullptr;
MultiGraphicsAllocation multiGraphicsAllocation;
GraphicsAllocation *mcsAllocation = nullptr;
MultiGraphicsAllocation mapAllocations;
std::shared_ptr<SharingHandler> sharingHandler;
std::vector<uint64_t> propertiesVector;
std::list<MemObjDestructorCallback *> destructorCallbacks;
};
} // namespace NEO
|
