Added Function Definitions for Overwritten Functions

MoltenVK/MoltenVK/Commands/MVKCommandBuffer.mm

@@ -865,6 +865,19 @@
  return _mtlBlitEncoder;
 }
 
+id<MTLAccelerationStructureCommandEncoder> MVKCommandEncoder::getMTLAccelerationStructureEncoder(MVKCommandUse cmdUse) {
+ if ( !_mtlAccelerationStructureEncoder ) {
+ endCurrentMetalEncoding();
+ _mtlAccelerationStructureEncoder = [_mtlCmdBuffer accelerationStructureCommandEncoder];
+ retainIfImmediatelyEncoding(_mtlAccelerationStructureEncoder);
+ }
+ if (_mtlAccelerationStructureUse != cmdUse) {
+ _mtlAccelerationStructureUse = cmdUse;
+ setLabelIfNotNil(_mtlAccelerationStructureEncoder, mvkMTLBlitCommandEncoderLabel(cmdUse));
+ }
+ return _mtlAccelerationStructureEncoder;
+}
+
 id<MTLCommandEncoder> MVKCommandEncoder::getMTLEncoder(){
  if (_mtlRenderEncoder) { return _mtlRenderEncoder; }
  if (_mtlComputeEncoder) { return _mtlComputeEncoder; }

MoltenVK/MoltenVK/GPUObjects/MVKDevice.mm

@@ -33,6 +33,7 @@
 #include "MVKFoundation.h"
 #include "MVKCodec.h"
 #include "MVKStrings.h"
+#include "MVKAccelerationStructure.h"
 #include <MoltenVKShaderConverter/SPIRVToMSLConverter.h>
 
 #import "CAMetalLayer+MoltenVK.h"
@@ -3696,6 +3697,48 @@ static uint32_t mvkGetEntryProperty(io_registry_entry_t entry, CFStringRef prope
  *pMaxDeviation = cpuEnd - cpuStart;
 }
 
+MVKBuffer* MVKDevice::getBufferAtAddress(uint64_t address)
+{
+ lock_guard<mutex> lock(_rezLock);
+
+ std::unordered_map<MVKBufferAddressRange, MVKBuffer*>::iterator it;
+ // Super inefficent but this can be fixed in the future
+ for(it = _gpuBufferAddressMap.begin(); it != _gpuBufferAddressMap.end(); it++)
+ {
+ // If the beginning address is bigger than, or the ending address is smaller than the passed address, then skip this it
+ if(it->first.first > address || it->first.second < address)
+ {
+ continue;
+ }
+ break;
+ }
+
+ // Couldn't find the buffer at address
+ if (it == _gpuBufferAddressMap.end()) { return nullptr;}
+
+ return it->second;
+}
+
+MVKAccelerationStructure* MVKDevice::getAccelerationStructureAtAddress(uint64_t address)
+{
+ std::unordered_map<uint64_t, MVKAccelerationStructure*>::iterator accStructIt = _gpuAccStructAddressMap.find(address);
+ if(accStructIt == _gpuAccStructAddressMap.end()) { return nullptr; }
+
+ return accStructIt->second;
+}
+
+VkAccelerationStructureCompatibilityKHR MVKDevice::getAccelerationStructureCompatibility(const VkAccelerationStructureVersionInfoKHR* pVersionInfo)
+{
+ VkAccelerationStructureCompatibilityKHR compat = VK_ACCELERATION_STRUCTURE_COMPATIBILITY_INCOMPATIBLE_KHR;
+
+ if(_enabledAccelerationStructureFeatures.accelerationStructure)
+ {
+ compat = VK_ACCELERATION_STRUCTURE_COMPATIBILITY_COMPATIBLE_KHR;
+ }
+
+ return compat;
+}
+
 #pragma mark Object lifecycle
 
 uint32_t MVKDevice::getVulkanMemoryTypeIndex(MTLStorageMode mtlStorageMode) {
@@ -3950,6 +3993,18 @@ static uint32_t mvkGetEntryProperty(io_registry_entry_t entry, CFStringRef prope
  if (mvkPLL) { mvkPLL->destroy(); }
 }
 
+MVKAccelerationStructure* MVKDevice::createAccelerationStructure(const VkAccelerationStructureCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator) {
+ return addAccelerationStructure(new MVKAccelerationStructure(this));
+}
+
+void MVKDevice::destroyAccelerationStructure(MVKAccelerationStructure* mvkAccStruct,
+ const VkAllocationCallbacks* pAllocator) {
+ if(!mvkAccStruct) { return; }
+ removeAccelerationStructure(mvkAccStruct);
+ mvkAccStruct->destroy();
+}
+
 template<typename PipelineType, typename PipelineInfoType>
 VkResult MVKDevice::createPipelines(VkPipelineCache pipelineCache,
  uint32_t count,
@@ -4243,6 +4298,30 @@ static uint32_t mvkGetEntryProperty(io_registry_entry_t entry, CFStringRef prope
  mvkRemoveFirstOccurance(_awaitingTimelineSem4s, make_pair(sem4, value));
 }
 
+MVKAccelerationStructure* MVKDevice::addAccelerationStructure(MVKAccelerationStructure* accStruct) {
+ std::pair<uint64_t, MVKAccelerationStructure*> accStructMemoryPair = std::make_pair(_nextValidAccStructureAddress, accStruct);
+ _gpuAccStructAddressMap.insert(accStructMemoryPair);
+ accStruct->setDeviceAddress(_nextValidAccStructureAddress);
+ _nextValidAccStructureAddress += accStruct->getMTLSize();
+ return accStruct;
+}
+
+void MVKDevice::removeAccelerationStructure(MVKAccelerationStructure* accStruct) {
+ std::unordered_map<uint64_t, MVKAccelerationStructure*>::iterator accStructIt = _gpuAccStructAddressMap.find(accStruct->getDeviceAddress());
+ uint64_t addressOffset = accStructIt->second->getMTLSize();
+ _gpuAccStructAddressMap.erase(accStructIt);
+
+ // This can lead to fragmentation over time, so I'll just push all keys after this back
+ // This, however is also another performance issue
+ for(auto it = accStructIt; it != _gpuAccStructAddressMap.end(); it++)
+ {
+ auto extractedAccStruct = _gpuAccStructAddressMap.extract(it->first);
+ extractedAccStruct.key() = it->first - addressOffset;
+ _gpuAccStructAddressMap.insert(std::move(extractedAccStruct));
+ _gpuAccStructAddressMap.erase(it->first);
+ }
+}
+
 void MVKDevice::applyMemoryBarrier(MVKPipelineBarrier& barrier,
  MVKCommandEncoder* cmdEncoder,
  MVKCommandUse cmdUse) {