VulkanRaytracingCycles 0.0.0
Cycles Render Engine With VulkanRaytracingShaderModules. ( Experiment , in progress)
Classes | Public Types | Public Member Functions | Public Attributes | List of all members
CacheVk< Mem, Size > Struct Template Reference

#include <CacheVk.h>

Classes

struct  index
 

Public Types

typedef Mem MemTy[Size]
 
typedef uintptr_t OwnTy[Size]
 

Public Member Functions

 CacheVk ()
 
 ~CacheVk ()
 
void clear ()
 
void enter ()
 
void leave ()
 
bool $get (Mem &mem, Hache *obj)
 
template<class T >
bool get (Mem &mem, T *obj)
 
bool get (Mem &mem, Hache *obj)
 
template<class T >
bool $set$ (Mem &&mem, T *obj)
 
bool $set$ (Mem &&mem, Hache *obj)
 
template<class T >
bool $delete$ (T *obj)
 
bool $delete$ (Hache *obj)
 
bool $kill$ (long id)
 
template<class O >
bool $createVisibleMemory$ (VkMemoryRequirements &memReqs, O &obj)
 

Public Attributes

Mem cache [Size]
 
uintptr_t owner [Size]
 
uint32_t idx
 
size_t size = Size
 
SRWLOCK SlimLock
 
std::queue< uint32_t > vacancy
 

Detailed Description

template<class Mem, size_t Size>
struct CacheVk< Mem, Size >

Definition at line 81 of file CacheVk.h.

Member Typedef Documentation

◆ MemTy

template<class Mem , size_t Size>
typedef Mem CacheVk< Mem, Size >::MemTy[Size]

Definition at line 83 of file CacheVk.h.

◆ OwnTy

template<class Mem , size_t Size>
typedef uintptr_t CacheVk< Mem, Size >::OwnTy[Size]

Definition at line 84 of file CacheVk.h.

Constructor & Destructor Documentation

◆ CacheVk()

template<class Mem , size_t Size>
CacheVk< Mem, Size >::CacheVk ( )
inline

Definition at line 94 of file CacheVk.h.

94 {
95 idx = -1;
96 InitializeSRWLock(&SlimLock);
97 };
CacheVk::SlimLock
SRWLOCK SlimLock
Definition: CacheVk.h:90
CacheVk::idx
uint32_t idx
Definition: CacheVk.h:88

◆ ~CacheVk()

template<class Mem , size_t Size>
CacheVk< Mem, Size >::~CacheVk ( )
inline

Definition at line 98 of file CacheVk.h.

98{}

Member Function Documentation

◆ $createVisibleMemory$()

template<class Mem , size_t Size>
template<class O >
bool CacheVk< Mem, Size >::$createVisibleMemory$ ( VkMemoryRequirements &  memReqs,
O &  obj 
)
inline

Definition at line 277 of file CacheVk.h.

277 {
278
279
280 AcquireSRWLockExclusive(&SlimLock);
281 if (obj.mem.id >= 0 && owner[obj.mem.id] == obj.mem.hash) {
282 ReleaseSRWLockExclusive(&SlimLock);
283 return true;
284 }
285
286
287 idx = (idx + 1) % Size;
288 if (cache[idx].isValid()) {
289 log_bad(" Buffer is not created for Over limit Nums. \n");
290 ReleaseSRWLockExclusive(&SlimLock);
291 return false;
292 };
293
294 Mvk& _ = cache[idx];
295 VkMemoryAllocateInfo allocInfo = {
296 .sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
297 .allocationSize = obj.memSize,
298 .memoryTypeIndex = vka::shelve::getMemoryTypeIndex(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT)
299 };
300
301 VK_CHECK_RESULT(vkAllocateMemory($device, &allocInfo, nullptr, &(_.memory)));
302 _.version = ++obj.mem.version;
303 obj.mem.id = idx;
304 owner[idx] = obj.mem.hash;
305 ReleaseSRWLockExclusive(&SlimLock);
306
307 log_ca("$createVisibleMemory$ %s IDX %d OWNER %zu \n", typeid(Mem).name(), obj.mem.id, obj.mem.hash);
308
309 return true;
310 };
log_ca
#define log_ca(...)
Definition: CacheVk.h:11
Mem
#define Mem(vk, sz)
Definition: incomplete.h:329
log_bad
#define log_bad(...)
Definition: log.hpp:37
CacheVk::owner
uintptr_t owner[Size]
Definition: CacheVk.h:87
CacheVk::cache
Mem cache[Size]
Definition: CacheVk.h:86
Mvk::memory
VkDeviceMemory memory
Definition: vthreepy_types.h:378
Mvk::version
int version
Definition: vthreepy_types.h:380

◆ $delete$() [1/2]

template<class Mem , size_t Size>
bool CacheVk< Mem, Size >::$delete$ ( Hache *  obj)
inline

Definition at line 225 of file CacheVk.h.

225 {
226
227 if (obj->id < 0)return false;
228
229 AcquireSRWLockExclusive(&SlimLock);
230
231 if (!cache[obj->id].isValid()) {
232 log_bad("you can't delete buffer becouse of being not Valid.\n");
233 ReleaseSRWLockExclusive(&SlimLock);
234 return false;
235 };
236 if (owner[obj->id] != obj->hash) {
237 log_bad("Owner is exclusive. you are'nt owner.");
238 return false;
239 };
240
241 cache[obj->id].dealloc();
242 owner[obj->id] = (uintptr_t)(-1);
243 vacancy.push(obj->id);
244 obj->id = -1;
245
246
247 ReleaseSRWLockExclusive(&SlimLock);
248
249 return true;
250 };
CacheVk::vacancy
std::queue< uint32_t > vacancy
Definition: CacheVk.h:92
Hache::hash
size_t hash
Definition: vthreepy_types.h:440

◆ $delete$() [2/2]

template<class Mem , size_t Size>
template<class T >
bool CacheVk< Mem, Size >::$delete$ ( T *  obj)
inline

Definition at line 200 of file CacheVk.h.

200 {
201 if (obj->id < 0)return false;
202
203 AcquireSRWLockExclusive(&SlimLock);
204
205 if (!cache[obj->id].isValid()) {
206 log_bad("you can't delete buffer becouse of being not Valid.\n");
207 ReleaseSRWLockExclusive(&SlimLock);
208 return false;
209 };
210 if (owner[obj->id] != (uintptr_t)obj) {
211 log_bad("Owner is exclusive. you are'nt owner.");
212 return false;
213 };
214
215 cache[obj->id].dealloc();
216 owner[obj->id] = (uintptr_t)(-1);
217 vacancy.push(obj->id);
218
219
220 ReleaseSRWLockExclusive(&SlimLock);
221
222 return true;
223 };

◆ $get()

template<class Mem , size_t Size>
bool CacheVk< Mem, Size >::$get ( Mem &  mem,
Hache *  obj 
)
inline

Definition at line 113 of file CacheVk.h.

113 {
114 if (obj->id < 0) {
115 return false;
116 }
117
118 AcquireSRWLockShared(&SlimLock);
119 if(Size <= obj->id || owner[obj->id] != obj->hash) {
120 ReleaseSRWLockShared(&SlimLock);
121 return false;
122 }
123 mem = cache[obj->id];
124 ReleaseSRWLockShared(&SlimLock);
125 return true;
126 };

◆ $kill$()

template<class Mem , size_t Size>
bool CacheVk< Mem, Size >::$kill$ ( long  id)
inline

Definition at line 252 of file CacheVk.h.

252 {
253
254 AcquireSRWLockExclusive(&SlimLock);
255
256 if (!cache[id].isValid()) {
257 log_bad("you can't delete buffer becouse of being not Valid.\n");
258 ReleaseSRWLockExclusive(&SlimLock);
259 return false;
260 };
261
262 cache[id].dealloc();
263 owner[id] = (uintptr_t)(-1);
264 vacancy.push(id);
265
266 ReleaseSRWLockExclusive(&SlimLock);
267
268 return true;
269 };

◆ $set$() [1/2]

template<class Mem , size_t Size>
bool CacheVk< Mem, Size >::$set$ ( Mem &&  mem,
Hache *  obj 
)
inline

Definition at line 179 of file CacheVk.h.

179 {
180
181 AcquireSRWLockExclusive(&SlimLock);
182
183 idx = (idx + 1) % Size;
184 if (cache[idx].isValid()) {
185 log_bad(" Buffer is not created for Over limit Nums. \n");
186 ReleaseSRWLockExclusive(&SlimLock);
187 return false;
188 };
189 cache[idx] = mem;
190 cache[idx].version = ++obj->version;
191 obj->id = idx;
192 owner[idx] = obj->hash;
193
194 ReleaseSRWLockExclusive(&SlimLock);
195
196 return true;
197 };
Hache::version
long version
Definition: vthreepy_types.h:439

◆ $set$() [2/2]

template<class Mem , size_t Size>
template<class T >
bool CacheVk< Mem, Size >::$set$ ( Mem &&  mem,
T *  obj 
)
inline

Definition at line 161 of file CacheVk.h.

161 {
162
163 AcquireSRWLockExclusive(&SlimLock);
164 idx = (idx + 1) % Size;
165 if (cache[idx].isValid()) {
166 log_bad(" Buffer is not created for Over limit Nums. \n");
167 ReleaseSRWLockExclusive(&SlimLock);
168 return false;
169 };
170 cache[idx] = mem;
171 cache[idx].version = ++obj->version;
172 obj->id = idx;
173 owner[idx] = (uintptr_t)obj;
174 ReleaseSRWLockExclusive(&SlimLock);
175
176 return true;
177 };

◆ clear()

template<class Mem , size_t Size>
void CacheVk< Mem, Size >::clear ( )
inline

Definition at line 100 of file CacheVk.h.

100 {
101 memset(cache, 0, sizeof(Mem) * Size);
102 memset(owner, 0, sizeof(uintptr_t) * Size);
103 while (vacancy.size() > 0)vacancy.pop();
104 };

◆ enter()

template<class Mem , size_t Size>
void CacheVk< Mem, Size >::enter ( )
inline

Definition at line 106 of file CacheVk.h.

106 {
107 AcquireSRWLockExclusive(&SlimLock);
108 };

◆ get() [1/2]

template<class Mem , size_t Size>
bool CacheVk< Mem, Size >::get ( Mem &  mem,
Hache *  obj 
)
inline

log_ca(" get %s IDX %d OWNER %zu HASH %zu \n",typeid(Mem).name(), obj->id, owner[obj->id], obj->hash);

Definition at line 143 of file CacheVk.h.

143 {
144 if (obj->id < 0) {
145 log_once("CacheVk incorrect index < 0.\n");
146 return false;
147 }
148
150
151 if (Size <= obj->id || owner[obj->id] != obj->hash) {
152 log_once("Hash is exclusive. you don't have the hash.");
153 return false;
154 }
155 mem = cache[obj->id];
156
157 return true;
158 };
log_once
#define log_once(...)
DELETE ALL ^((?!\w).)*log_once(.*; ^((?!\w).)*log_once((.* )+?.*;.
Definition: log.hpp:13

◆ get() [2/2]

template<class Mem , size_t Size>
template<class T >
bool CacheVk< Mem, Size >::get ( Mem &  mem,
T *  obj 
)
inline

Definition at line 129 of file CacheVk.h.

129 {
130 if (obj->id < 0) {
131 log_once("CacheVk incorrect index < 0.\n");
132 return false;
133 }
134
135 if(Size <= obj->id || owner[obj->id] != (uintptr_t)obj) {
136 log_once("Owner is exclusive. you are'nt owner.");
137 return false;
138 };
139 mem = cache[obj->id];
140 return true;
141 };

◆ leave()

template<class Mem , size_t Size>
void CacheVk< Mem, Size >::leave ( )
inline

Definition at line 109 of file CacheVk.h.

109 {
110 ReleaseSRWLockExclusive(&SlimLock);
111 };

Member Data Documentation

◆ cache

template<class Mem , size_t Size>
Mem CacheVk< Mem, Size >::cache[Size]

Definition at line 86 of file CacheVk.h.

◆ idx

template<class Mem , size_t Size>
uint32_t CacheVk< Mem, Size >::idx

Definition at line 88 of file CacheVk.h.

◆ owner

template<class Mem , size_t Size>
uintptr_t CacheVk< Mem, Size >::owner[Size]

Definition at line 87 of file CacheVk.h.

◆ size

template<class Mem , size_t Size>
size_t CacheVk< Mem, Size >::size = Size

Definition at line 89 of file CacheVk.h.

◆ SlimLock

template<class Mem , size_t Size>
SRWLOCK CacheVk< Mem, Size >::SlimLock

Definition at line 90 of file CacheVk.h.

◆ vacancy

template<class Mem , size_t Size>
std::queue<uint32_t> CacheVk< Mem, Size >::vacancy

Definition at line 92 of file CacheVk.h.

The documentation for this struct was generated from the following file: