MoltenVK/MoltenVK/GPUObjects/MVKBuffer.mm - external/github.com/KhronosGroup/MoltenVK - Git at Google

 /*
  * MVKBuffer.mm
  *
  * Copyright (c) 2014-2018 The Brenwill Workshop Ltd. (http://www.brenwill.com)
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #include "MVKBuffer.h"
 #include "MVKCommandBuffer.h"
 #include "MVKFoundation.h"
 #include "mvk_datatypes.h"

 using namespace std;


 #pragma mark -
 #pragma mark MVKBuffer

 #pragma mark Resource memory

 VkResult MVKBuffer::getMemoryRequirements(VkMemoryRequirements* pMemoryRequirements) {
 	pMemoryRequirements->size = getByteCount();
 	pMemoryRequirements->alignment = getByteAlignment();
 	pMemoryRequirements->memoryTypeBits = _device->getPhysicalDevice()->getAllMemoryTypes();
 	return VK_SUCCESS;
 }

 void MVKBuffer::applyMemoryBarrier(VkPipelineStageFlags srcStageMask,
 								   VkPipelineStageFlags dstStageMask,
 								   VkMemoryBarrier* pMemoryBarrier,
                                    MVKCommandEncoder* cmdEncoder,
                                    MVKCommandUse cmdUse) {
 #if MVK_MACOS
 	if ( needsHostReadSync(srcStageMask, dstStageMask, pMemoryBarrier) ) {
 		[cmdEncoder->getMTLBlitEncoder(cmdUse) synchronizeResource: getMTLBuffer()];
 	}
 #endif
 }

 void MVKBuffer::applyBufferMemoryBarrier(VkPipelineStageFlags srcStageMask,
 										 VkPipelineStageFlags dstStageMask,
 										 VkBufferMemoryBarrier* pBufferMemoryBarrier,
                                          MVKCommandEncoder* cmdEncoder,
                                          MVKCommandUse cmdUse) {
 #if MVK_MACOS
 	if ( needsHostReadSync(srcStageMask, dstStageMask, pBufferMemoryBarrier) ) {
 		[cmdEncoder->getMTLBlitEncoder(cmdUse) synchronizeResource: getMTLBuffer()];
 	}
 #endif
 }

 /**
  * Returns whether the specified buffer memory barrier requires a sync between this
  * buffer and host memory for the purpose of the host reading texture memory.
  */
 bool MVKBuffer::needsHostReadSync(VkPipelineStageFlags srcStageMask,
 								  VkPipelineStageFlags dstStageMask,
 								  VkBufferMemoryBarrier* pBufferMemoryBarrier) {
 #if MVK_IOS
 	return false;
 #endif
 #if MVK_MACOS
 	return (mvkIsAnyFlagEnabled(dstStageMask, (VK_PIPELINE_STAGE_HOST_BIT)) &&
 			mvkIsAnyFlagEnabled(pBufferMemoryBarrier->dstAccessMask, (VK_ACCESS_HOST_READ_BIT)) &&
 			_deviceMemory->isMemoryHostAccessible() && !_deviceMemory->isMemoryHostCoherent());
 #endif
 }

 /** Called when the bound device memory is updated. Flushes any associated resource memory. */
 VkResult MVKBuffer::flushToDevice(VkDeviceSize offset, VkDeviceSize size) {
     VkResult rslt = copyMTLBufferContent(offset, size, true);

 #if MVK_MACOS
     if (_deviceMemory->getMTLStorageMode() == MTLStorageModeManaged) {
         [getMTLBuffer() didModifyRange: mtlBufferRange(offset, size)];
     }
 #endif

     return rslt;
 }

 // Called when the bound device memory is invalidated. Pulls any associated resource memory from the device.
 VkResult MVKBuffer::pullFromDevice(VkDeviceSize offset, VkDeviceSize size) {
     VkResult rslt = copyMTLBufferContent(offset, size, false);

     // If we are pulling to populate a newly created device memory MTLBuffer,
     // from a previously created local MTLBuffer, remove the local MTLBuffer.
 	// Use autorelease in case the earlier MTLBuffer was encoded.
     if (_mtlBuffer && _deviceMemory->getMTLBuffer()) {
         [_mtlBuffer autorelease];
         _mtlBuffer = nil;
     }

     return rslt;
 }

 void* MVKBuffer::map(VkDeviceSize offset, VkDeviceSize size) {
     return (void*)((uintptr_t)getMTLBuffer().contents + mtlBufferRange(offset, size).location);
 }

 // Copies host content into or out of the MTLBuffer.
 VkResult MVKBuffer::copyMTLBufferContent(VkDeviceSize offset, VkDeviceSize size, bool intoMTLBuffer) {

     // Only copy if there is separate host memory and this buffer overlaps the host memory range
     void* pMemBase = _deviceMemory->getLogicalMappedMemory();
     if (pMemBase && doesOverlap(offset, size)) {

         NSRange copyRange = mtlBufferRange(offset, size);
         VkDeviceSize memOffset = max(offset, _deviceMemoryOffset);

 //        MVKLogDebug("Copying contents %s buffer %p at buffer offset %d memory offset %d and length %d.", (intoMTLBuffer ? "to" : "from"), this, copyRange.location, memOffset, copyRange.length);

         void* pMemBytes = (void*)((uintptr_t)pMemBase + memOffset);
         void* pMTLBuffBytes = (void*)((uintptr_t)getMTLBuffer().contents + copyRange.location);

         // Copy in the direction indicated.
         // Don't copy if the source and destination are the same address, which will
         // occur if the underlying MTLBuffer comes from the device memory object.
         if (pMemBytes != pMTLBuffBytes) {
 //            MVKLogDebug("Copying buffer contents.");
             if (intoMTLBuffer) {
                 memcpy(pMTLBuffBytes, pMemBytes, copyRange.length);
             } else {
                 memcpy(pMemBytes, pMTLBuffBytes, copyRange.length);
             }
         }
     }

     return VK_SUCCESS;
 }


 #pragma mark Metal

 // If a local MTLBuffer already exists, use it.
 // If the device memory has a MTLBuffer, use it.
 // Otherwise, create a new MTLBuffer and use it from now on.
 id<MTLBuffer> MVKBuffer::getMTLBuffer() {

     if (_mtlBuffer) { return _mtlBuffer; }

     id<MTLBuffer> devMemMTLBuff = _deviceMemory->getMTLBuffer();
     if (devMemMTLBuff) { return devMemMTLBuff; }

 	// Lock and check again in case another thread has created the buffer.
     lock_guard<mutex> lock(_lock);
     if (_mtlBuffer) { return _mtlBuffer; }

     NSUInteger mtlBuffLen = mvkAlignByteOffset(_byteCount, _byteAlignment);
     _mtlBuffer = [getMTLDevice() newBufferWithLength: mtlBuffLen
                                              options: _deviceMemory->getMTLResourceOptions()];     // retained
 //    MVKLogDebug("MVKBuffer %p creating local MTLBuffer of size %d.", this, _mtlBuffer.length);
     return _mtlBuffer;
 }

 NSUInteger MVKBuffer::getMTLBufferOffset() { return _mtlBuffer ? 0 : _deviceMemoryOffset; }

 // Returns an NSRange that maps the specified host memory range to the MTLBuffer.
 NSRange MVKBuffer::mtlBufferRange(VkDeviceSize offset, VkDeviceSize size) {
     NSUInteger localRangeLoc = min((offset > _deviceMemoryOffset) ? (offset - _deviceMemoryOffset) : 0, _byteCount);
     NSUInteger localRangeLen = min(size, _byteCount - localRangeLoc);
     return NSMakeRange(getMTLBufferOffset() + localRangeLoc, localRangeLen);
 }


 #pragma mark Construction

 MVKBuffer::MVKBuffer(MVKDevice* device, const VkBufferCreateInfo* pCreateInfo) : MVKResource(device) {
     _byteAlignment = _device->_pMetalFeatures->mtlBufferAlignment;
     _byteCount = pCreateInfo->size;
     _mtlBuffer = nil;
 }

 MVKBuffer::~MVKBuffer() {
     [_mtlBuffer release];
     _mtlBuffer = nil;
 }


 #pragma mark -
 #pragma mark MVKBufferView


 #pragma mark Metal

 id<MTLTexture> MVKBufferView::getMTLTexture() {
     if ( !_mtlTexture && _mtlPixelFormat &&  _device->_pMetalFeatures->texelBuffers) {

 		// Lock and check again in case another thread has created the texture.
 		lock_guard<mutex> lock(_lock);
 		if (_mtlTexture) { return _mtlTexture; }

         VkDeviceSize byteAlign = _device->_pProperties->limits.minTexelBufferOffsetAlignment;
         NSUInteger mtlByteCnt = mvkAlignByteOffset(_byteCount, byteAlign);
         MTLTextureDescriptor* mtlTexDesc = [MTLTextureDescriptor texture2DDescriptorWithPixelFormat: _mtlPixelFormat
                                                                                               width: _textureSize.width
                                                                                              height: _textureSize.height
                                                                                           mipmapped: NO];
         _mtlTexture = [getMTLBuffer() newTextureWithDescriptor: mtlTexDesc
                                                         offset: _mtlBufferOffset
                                                    bytesPerRow: mtlByteCnt];
     }
     return _mtlTexture;
 }


 #pragma mark Construction

 MVKBufferView::MVKBufferView(MVKDevice* device, const VkBufferViewCreateInfo* pCreateInfo) : MVKBaseDeviceObject(device) {
     _buffer = (MVKBuffer*)pCreateInfo->buffer;
     _mtlBufferOffset = _buffer->getMTLBufferOffset() + pCreateInfo->offset;
     _mtlPixelFormat = mtlPixelFormatFromVkFormat(pCreateInfo->format);
     _mtlTexture = nil;
     VkExtent2D fmtBlockSize = mvkVkFormatBlockTexelSize(pCreateInfo->format);  // Pixel size of format
     size_t bytesPerBlock = mvkVkFormatBytesPerBlock(pCreateInfo->format);

     // Layout texture as a 1D array of texel blocks (which are texels for non-compressed textures) that covers the bytes
     _byteCount = pCreateInfo->range;
     if (_byteCount == VK_WHOLE_SIZE) { _byteCount = _buffer->getByteCount() - _mtlBufferOffset; }    // Remaining bytes in buffer
     size_t blockCount = _byteCount / bytesPerBlock;
     _byteCount = blockCount * bytesPerBlock;            // Round down

     _textureSize.width = (uint32_t)blockCount * fmtBlockSize.width;
     _textureSize.height = fmtBlockSize.height;

     if ( !_device->_pMetalFeatures->texelBuffers ) {
         setConfigurationResult(mvkNotifyErrorWithText(VK_ERROR_FEATURE_NOT_PRESENT, "Texel buffers are not supported on this device."));
     }
 }

 MVKBufferView::~MVKBufferView() {
     [_mtlTexture release];
     _mtlTexture = nil;
 }
	/*
	* MVKBuffer.mm
	*
	* Copyright (c) 2014-2018 The Brenwill Workshop Ltd. (http://www.brenwill.com)
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#include "MVKBuffer.h"
	#include "MVKCommandBuffer.h"
	#include "MVKFoundation.h"
	#include "mvk_datatypes.h"

	using namespace std;


	#pragma mark -
	#pragma mark MVKBuffer

	#pragma mark Resource memory

	VkResult MVKBuffer::getMemoryRequirements(VkMemoryRequirements* pMemoryRequirements) {
	pMemoryRequirements->size = getByteCount();
	pMemoryRequirements->alignment = getByteAlignment();
	pMemoryRequirements->memoryTypeBits = _device->getPhysicalDevice()->getAllMemoryTypes();
	return VK_SUCCESS;
	}

	void MVKBuffer::applyMemoryBarrier(VkPipelineStageFlags srcStageMask,
	VkPipelineStageFlags dstStageMask,
	VkMemoryBarrier* pMemoryBarrier,
	MVKCommandEncoder* cmdEncoder,
	MVKCommandUse cmdUse) {
	#if MVK_MACOS
	if ( needsHostReadSync(srcStageMask, dstStageMask, pMemoryBarrier) ) {
	[cmdEncoder->getMTLBlitEncoder(cmdUse) synchronizeResource: getMTLBuffer()];
	}
	#endif
	}

	void MVKBuffer::applyBufferMemoryBarrier(VkPipelineStageFlags srcStageMask,
	VkPipelineStageFlags dstStageMask,
	VkBufferMemoryBarrier* pBufferMemoryBarrier,
	MVKCommandEncoder* cmdEncoder,
	MVKCommandUse cmdUse) {
	#if MVK_MACOS
	if ( needsHostReadSync(srcStageMask, dstStageMask, pBufferMemoryBarrier) ) {
	[cmdEncoder->getMTLBlitEncoder(cmdUse) synchronizeResource: getMTLBuffer()];
	}
	#endif
	}

	/**
	* Returns whether the specified buffer memory barrier requires a sync between this
	* buffer and host memory for the purpose of the host reading texture memory.
	*/
	bool MVKBuffer::needsHostReadSync(VkPipelineStageFlags srcStageMask,
	VkPipelineStageFlags dstStageMask,
	VkBufferMemoryBarrier* pBufferMemoryBarrier) {
	#if MVK_IOS
	return false;
	#endif
	#if MVK_MACOS
	return (mvkIsAnyFlagEnabled(dstStageMask, (VK_PIPELINE_STAGE_HOST_BIT)) &&
	mvkIsAnyFlagEnabled(pBufferMemoryBarrier->dstAccessMask, (VK_ACCESS_HOST_READ_BIT)) &&
	_deviceMemory->isMemoryHostAccessible() && !_deviceMemory->isMemoryHostCoherent());
	#endif
	}

	/** Called when the bound device memory is updated. Flushes any associated resource memory. */
	VkResult MVKBuffer::flushToDevice(VkDeviceSize offset, VkDeviceSize size) {
	VkResult rslt = copyMTLBufferContent(offset, size, true);

	#if MVK_MACOS
	if (_deviceMemory->getMTLStorageMode() == MTLStorageModeManaged) {
	[getMTLBuffer() didModifyRange: mtlBufferRange(offset, size)];
	}
	#endif

	return rslt;
	}

	// Called when the bound device memory is invalidated. Pulls any associated resource memory from the device.
	VkResult MVKBuffer::pullFromDevice(VkDeviceSize offset, VkDeviceSize size) {
	VkResult rslt = copyMTLBufferContent(offset, size, false);

	// If we are pulling to populate a newly created device memory MTLBuffer,
	// from a previously created local MTLBuffer, remove the local MTLBuffer.
	// Use autorelease in case the earlier MTLBuffer was encoded.
	if (_mtlBuffer && _deviceMemory->getMTLBuffer()) {
	[_mtlBuffer autorelease];
	_mtlBuffer = nil;
	}

	return rslt;
	}

	void* MVKBuffer::map(VkDeviceSize offset, VkDeviceSize size) {
	return (void*)((uintptr_t)getMTLBuffer().contents + mtlBufferRange(offset, size).location);
	}

	// Copies host content into or out of the MTLBuffer.
	VkResult MVKBuffer::copyMTLBufferContent(VkDeviceSize offset, VkDeviceSize size, bool intoMTLBuffer) {

	// Only copy if there is separate host memory and this buffer overlaps the host memory range
	void* pMemBase = _deviceMemory->getLogicalMappedMemory();
	if (pMemBase && doesOverlap(offset, size)) {

	NSRange copyRange = mtlBufferRange(offset, size);
	VkDeviceSize memOffset = max(offset, _deviceMemoryOffset);

	// MVKLogDebug("Copying contents %s buffer %p at buffer offset %d memory offset %d and length %d.", (intoMTLBuffer ? "to" : "from"), this, copyRange.location, memOffset, copyRange.length);

	void* pMemBytes = (void*)((uintptr_t)pMemBase + memOffset);
	void* pMTLBuffBytes = (void*)((uintptr_t)getMTLBuffer().contents + copyRange.location);

	// Copy in the direction indicated.
	// Don't copy if the source and destination are the same address, which will
	// occur if the underlying MTLBuffer comes from the device memory object.
	if (pMemBytes != pMTLBuffBytes) {
	// MVKLogDebug("Copying buffer contents.");
	if (intoMTLBuffer) {
	memcpy(pMTLBuffBytes, pMemBytes, copyRange.length);
	} else {
	memcpy(pMemBytes, pMTLBuffBytes, copyRange.length);
	}
	}
	}

	return VK_SUCCESS;
	}


	#pragma mark Metal

	// If a local MTLBuffer already exists, use it.
	// If the device memory has a MTLBuffer, use it.
	// Otherwise, create a new MTLBuffer and use it from now on.
	id<MTLBuffer> MVKBuffer::getMTLBuffer() {

	if (_mtlBuffer) { return _mtlBuffer; }

	id<MTLBuffer> devMemMTLBuff = _deviceMemory->getMTLBuffer();
	if (devMemMTLBuff) { return devMemMTLBuff; }

	// Lock and check again in case another thread has created the buffer.
	lock_guard<mutex> lock(_lock);
	if (_mtlBuffer) { return _mtlBuffer; }

	NSUInteger mtlBuffLen = mvkAlignByteOffset(_byteCount, _byteAlignment);
	_mtlBuffer = [getMTLDevice() newBufferWithLength: mtlBuffLen
	options: _deviceMemory->getMTLResourceOptions()]; // retained
	// MVKLogDebug("MVKBuffer %p creating local MTLBuffer of size %d.", this, _mtlBuffer.length);
	return _mtlBuffer;
	}

	NSUInteger MVKBuffer::getMTLBufferOffset() { return _mtlBuffer ? 0 : _deviceMemoryOffset; }

	// Returns an NSRange that maps the specified host memory range to the MTLBuffer.
	NSRange MVKBuffer::mtlBufferRange(VkDeviceSize offset, VkDeviceSize size) {
	NSUInteger localRangeLoc = min((offset > _deviceMemoryOffset) ? (offset - _deviceMemoryOffset) : 0, _byteCount);
	NSUInteger localRangeLen = min(size, _byteCount - localRangeLoc);
	return NSMakeRange(getMTLBufferOffset() + localRangeLoc, localRangeLen);
	}


	#pragma mark Construction

	MVKBuffer::MVKBuffer(MVKDevice* device, const VkBufferCreateInfo* pCreateInfo) : MVKResource(device) {
	_byteAlignment = _device->_pMetalFeatures->mtlBufferAlignment;
	_byteCount = pCreateInfo->size;
	_mtlBuffer = nil;
	}

	MVKBuffer::~MVKBuffer() {
	[_mtlBuffer release];
	_mtlBuffer = nil;
	}


	#pragma mark -
	#pragma mark MVKBufferView


	#pragma mark Metal

	id<MTLTexture> MVKBufferView::getMTLTexture() {
	if ( !_mtlTexture && _mtlPixelFormat && _device->_pMetalFeatures->texelBuffers) {

	// Lock and check again in case another thread has created the texture.
	lock_guard<mutex> lock(_lock);
	if (_mtlTexture) { return _mtlTexture; }

	VkDeviceSize byteAlign = _device->_pProperties->limits.minTexelBufferOffsetAlignment;
	NSUInteger mtlByteCnt = mvkAlignByteOffset(_byteCount, byteAlign);
	MTLTextureDescriptor* mtlTexDesc = [MTLTextureDescriptor texture2DDescriptorWithPixelFormat: _mtlPixelFormat
	width: _textureSize.width
	height: _textureSize.height
	mipmapped: NO];
	_mtlTexture = [getMTLBuffer() newTextureWithDescriptor: mtlTexDesc
	offset: _mtlBufferOffset
	bytesPerRow: mtlByteCnt];
	}
	return _mtlTexture;
	}


	#pragma mark Construction

	MVKBufferView::MVKBufferView(MVKDevice* device, const VkBufferViewCreateInfo* pCreateInfo) : MVKBaseDeviceObject(device) {
	_buffer = (MVKBuffer*)pCreateInfo->buffer;
	_mtlBufferOffset = _buffer->getMTLBufferOffset() + pCreateInfo->offset;
	_mtlPixelFormat = mtlPixelFormatFromVkFormat(pCreateInfo->format);
	_mtlTexture = nil;
	VkExtent2D fmtBlockSize = mvkVkFormatBlockTexelSize(pCreateInfo->format); // Pixel size of format
	size_t bytesPerBlock = mvkVkFormatBytesPerBlock(pCreateInfo->format);

	// Layout texture as a 1D array of texel blocks (which are texels for non-compressed textures) that covers the bytes
	_byteCount = pCreateInfo->range;
	if (_byteCount == VK_WHOLE_SIZE) { _byteCount = _buffer->getByteCount() - _mtlBufferOffset; } // Remaining bytes in buffer
	size_t blockCount = _byteCount / bytesPerBlock;
	_byteCount = blockCount * bytesPerBlock; // Round down

	_textureSize.width = (uint32_t)blockCount * fmtBlockSize.width;
	_textureSize.height = fmtBlockSize.height;

	if ( !_device->_pMetalFeatures->texelBuffers ) {
	setConfigurationResult(mvkNotifyErrorWithText(VK_ERROR_FEATURE_NOT_PRESENT, "Texel buffers are not supported on this device."));
	}
	}

	MVKBufferView::~MVKBufferView() {
	[_mtlTexture release];
	_mtlTexture = nil;
	}