src/dawn_native/metal/BufferMTL.mm - dawn - Git at Google

 // Copyright 2017 The Dawn Authors
 //
 // 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 "dawn_native/metal/BufferMTL.h"

 #include "common/Math.h"
 #include "dawn_native/CommandBuffer.h"
 #include "dawn_native/metal/CommandRecordingContext.h"
 #include "dawn_native/metal/DeviceMTL.h"

 #include <limits>

 namespace dawn::native::metal {
     // The size of uniform buffer and storage buffer need to be aligned to 16 bytes which is the
     // largest alignment of supported data types
     static constexpr uint32_t kMinUniformOrStorageBufferAlignment = 16u;

     // static
     ResultOrError<Ref<Buffer>> Buffer::Create(Device* device, const BufferDescriptor* descriptor) {
         Ref<Buffer> buffer = AcquireRef(new Buffer(device, descriptor));
         DAWN_TRY(buffer->Initialize(descriptor->mappedAtCreation));
         return std::move(buffer);
     }

     // static
     uint64_t Buffer::QueryMaxBufferLength(id<MTLDevice> mtlDevice) {
         if (@available(iOS 12, tvOS 12, macOS 10.14, *)) {
             return [mtlDevice maxBufferLength];
         }

         // Earlier versions of Metal had maximums defined in the Metal feature set tables
         // https://metalbyexample.com/wp-content/uploads/Metal-Feature-Set-Tables-2018.pdf
 #if defined(DAWN_PLATFORM_MACOS)
         // 10.12 and 10.13 have a 1Gb limit.
         if (@available(macOS 10.12, *)) {
             // |maxBufferLength| isn't always available on older systems. If available, use
             // |recommendedMaxWorkingSetSize| instead. We can probably allocate more than this,
             // but don't have a way to discover a better limit. MoltenVK also uses this heuristic.
             return 1024 * 1024 * 1024;
         }
         // 10.11 has a 256Mb limit
         if (@available(maxOS 10.11, *)) {
             return 256 * 1024 * 1024;
         }
 #else
         // macOS / tvOS: 256Mb limit in versions without [MTLDevice maxBufferLength]
         return 256 * 1024 * 1024;
 #endif
     }

     MaybeError Buffer::Initialize(bool mappedAtCreation) {
         MTLResourceOptions storageMode;
         if (GetUsage() & kMappableBufferUsages) {
             storageMode = MTLResourceStorageModeShared;
         } else {
             storageMode = MTLResourceStorageModePrivate;
         }

         uint32_t alignment = 1;
 #ifdef DAWN_PLATFORM_MACOS
         // [MTLBlitCommandEncoder fillBuffer] requires the size to be a multiple of 4 on MacOS.
         alignment = 4;
 #endif

         // Metal validation layer requires the size of uniform buffer and storage buffer to be no
         // less than the size of the buffer block defined in shader, and the overall size of the
         // buffer must be aligned to the largest alignment of its members.
         if (GetUsage() &
             (wgpu::BufferUsage::Uniform | wgpu::BufferUsage::Storage | kInternalStorageBuffer)) {
             ASSERT(IsAligned(kMinUniformOrStorageBufferAlignment, alignment));
             alignment = kMinUniformOrStorageBufferAlignment;
         }

         // The vertex pulling transform requires at least 4 bytes in the buffer.
         // 0-sized vertex buffer bindings are allowed, so we always need an additional 4 bytes
         // after the end.
         NSUInteger extraBytes = 0u;
         if ((GetUsage() & wgpu::BufferUsage::Vertex) != 0) {
             extraBytes = 4u;
         }

         if (GetSize() > std::numeric_limits<NSUInteger>::max() - extraBytes) {
             return DAWN_OUT_OF_MEMORY_ERROR("Buffer allocation is too large");
         }
         NSUInteger currentSize =
             std::max(static_cast<NSUInteger>(GetSize()) + extraBytes, NSUInteger(4));

         if (currentSize > std::numeric_limits<NSUInteger>::max() - alignment) {
             // Alignment would overlow.
             return DAWN_OUT_OF_MEMORY_ERROR("Buffer allocation is too large");
         }
         currentSize = Align(currentSize, alignment);

         uint64_t maxBufferSize = QueryMaxBufferLength(ToBackend(GetDevice())->GetMTLDevice());
         if (currentSize > maxBufferSize) {
             return DAWN_OUT_OF_MEMORY_ERROR("Buffer allocation is too large");
         }

         mAllocatedSize = currentSize;
         mMtlBuffer.Acquire([ToBackend(GetDevice())->GetMTLDevice()
             newBufferWithLength:currentSize
                         options:storageMode]);
         if (mMtlBuffer == nullptr) {
             return DAWN_OUT_OF_MEMORY_ERROR("Buffer allocation failed");
         }

         // The buffers with mappedAtCreation == true will be initialized in
         // BufferBase::MapAtCreation().
         if (GetDevice()->IsToggleEnabled(Toggle::NonzeroClearResourcesOnCreationForTesting) &&
             !mappedAtCreation) {
             CommandRecordingContext* commandContext =
                 ToBackend(GetDevice())->GetPendingCommandContext();
             ClearBuffer(commandContext, uint8_t(1u));
         }

         // Initialize the padding bytes to zero.
         if (GetDevice()->IsToggleEnabled(Toggle::LazyClearResourceOnFirstUse) &&
             !mappedAtCreation) {
             uint32_t paddingBytes = GetAllocatedSize() - GetSize();
             if (paddingBytes > 0) {
                 uint32_t clearSize = Align(paddingBytes, 4);
                 uint64_t clearOffset = GetAllocatedSize() - clearSize;

                 CommandRecordingContext* commandContext =
                     ToBackend(GetDevice())->GetPendingCommandContext();
                 ClearBuffer(commandContext, 0, clearOffset, clearSize);
             }
         }
         return {};
     }

     Buffer::~Buffer() = default;

     id<MTLBuffer> Buffer::GetMTLBuffer() const {
         return mMtlBuffer.Get();
     }

     bool Buffer::IsCPUWritableAtCreation() const {
         // TODO(enga): Handle CPU-visible memory on UMA
         return GetUsage() & kMappableBufferUsages;
     }

     MaybeError Buffer::MapAtCreationImpl() {
         return {};
     }

     MaybeError Buffer::MapAsyncImpl(wgpu::MapMode mode, size_t offset, size_t size) {
         CommandRecordingContext* commandContext =
             ToBackend(GetDevice())->GetPendingCommandContext();
         EnsureDataInitialized(commandContext);

         return {};
     }

     void* Buffer::GetMappedPointerImpl() {
         return [*mMtlBuffer contents];
     }

     void Buffer::UnmapImpl() {
         // Nothing to do, Metal StorageModeShared buffers are always mapped.
     }

     void Buffer::DestroyImpl() {
         BufferBase::DestroyImpl();
         mMtlBuffer = nullptr;
     }

     bool Buffer::EnsureDataInitialized(CommandRecordingContext* commandContext) {
         if (!NeedsInitialization()) {
             return false;
         }

         InitializeToZero(commandContext);
         return true;
     }

     bool Buffer::EnsureDataInitializedAsDestination(CommandRecordingContext* commandContext,
                                                     uint64_t offset,
                                                     uint64_t size) {
         if (!NeedsInitialization()) {
             return false;
         }

         if (IsFullBufferRange(offset, size)) {
             SetIsDataInitialized();
             return false;
         }

         InitializeToZero(commandContext);
         return true;
     }

     bool Buffer::EnsureDataInitializedAsDestination(CommandRecordingContext* commandContext,
                                                     const CopyTextureToBufferCmd* copy) {
         if (!NeedsInitialization()) {
             return false;
         }

         if (IsFullBufferOverwrittenInTextureToBufferCopy(copy)) {
             SetIsDataInitialized();
             return false;
         }

         InitializeToZero(commandContext);
         return true;
     }

     void Buffer::InitializeToZero(CommandRecordingContext* commandContext) {
         ASSERT(NeedsInitialization());

         ClearBuffer(commandContext, uint8_t(0u));

         SetIsDataInitialized();
         GetDevice()->IncrementLazyClearCountForTesting();
     }

     void Buffer::ClearBuffer(CommandRecordingContext* commandContext,
                              uint8_t clearValue,
                              uint64_t offset,
                              uint64_t size) {
         ASSERT(commandContext != nullptr);
         size = size > 0 ? size : GetAllocatedSize();
         ASSERT(size > 0);
         [commandContext->EnsureBlit() fillBuffer:mMtlBuffer.Get()
                                            range:NSMakeRange(offset, size)
                                            value:clearValue];
     }

 }  // namespace dawn::native::metal
	// Copyright 2017 The Dawn Authors
	//
	// 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 "dawn_native/metal/BufferMTL.h"

	#include "common/Math.h"
	#include "dawn_native/CommandBuffer.h"
	#include "dawn_native/metal/CommandRecordingContext.h"
	#include "dawn_native/metal/DeviceMTL.h"

	#include <limits>

	namespace dawn::native::metal {
	// The size of uniform buffer and storage buffer need to be aligned to 16 bytes which is the
	// largest alignment of supported data types
	static constexpr uint32_t kMinUniformOrStorageBufferAlignment = 16u;

	// static
	ResultOrError<Ref<Buffer>> Buffer::Create(Device* device, const BufferDescriptor* descriptor) {
	Ref<Buffer> buffer = AcquireRef(new Buffer(device, descriptor));
	DAWN_TRY(buffer->Initialize(descriptor->mappedAtCreation));
	return std::move(buffer);
	}

	// static
	uint64_t Buffer::QueryMaxBufferLength(id<MTLDevice> mtlDevice) {
	if (@available(iOS 12, tvOS 12, macOS 10.14, *)) {
	return [mtlDevice maxBufferLength];
	}

	// Earlier versions of Metal had maximums defined in the Metal feature set tables
	// https://metalbyexample.com/wp-content/uploads/Metal-Feature-Set-Tables-2018.pdf
	#if defined(DAWN_PLATFORM_MACOS)
	// 10.12 and 10.13 have a 1Gb limit.
	if (@available(macOS 10.12, *)) {
	// \|maxBufferLength\| isn't always available on older systems. If available, use
	// \|recommendedMaxWorkingSetSize\| instead. We can probably allocate more than this,
	// but don't have a way to discover a better limit. MoltenVK also uses this heuristic.
	return 1024 * 1024 * 1024;
	}
	// 10.11 has a 256Mb limit
	if (@available(maxOS 10.11, *)) {
	return 256 * 1024 * 1024;
	}
	#else
	// macOS / tvOS: 256Mb limit in versions without [MTLDevice maxBufferLength]
	return 256 * 1024 * 1024;
	#endif
	}

	MaybeError Buffer::Initialize(bool mappedAtCreation) {
	MTLResourceOptions storageMode;
	if (GetUsage() & kMappableBufferUsages) {
	storageMode = MTLResourceStorageModeShared;
	} else {
	storageMode = MTLResourceStorageModePrivate;
	}

	uint32_t alignment = 1;
	#ifdef DAWN_PLATFORM_MACOS
	// [MTLBlitCommandEncoder fillBuffer] requires the size to be a multiple of 4 on MacOS.
	alignment = 4;
	#endif

	// Metal validation layer requires the size of uniform buffer and storage buffer to be no
	// less than the size of the buffer block defined in shader, and the overall size of the
	// buffer must be aligned to the largest alignment of its members.
	if (GetUsage() &
	(wgpu::BufferUsage::Uniform \| wgpu::BufferUsage::Storage \| kInternalStorageBuffer)) {
	ASSERT(IsAligned(kMinUniformOrStorageBufferAlignment, alignment));
	alignment = kMinUniformOrStorageBufferAlignment;
	}

	// The vertex pulling transform requires at least 4 bytes in the buffer.
	// 0-sized vertex buffer bindings are allowed, so we always need an additional 4 bytes
	// after the end.
	NSUInteger extraBytes = 0u;
	if ((GetUsage() & wgpu::BufferUsage::Vertex) != 0) {
	extraBytes = 4u;
	}

	if (GetSize() > std::numeric_limits<NSUInteger>::max() - extraBytes) {
	return DAWN_OUT_OF_MEMORY_ERROR("Buffer allocation is too large");
	}
	NSUInteger currentSize =
	std::max(static_cast<NSUInteger>(GetSize()) + extraBytes, NSUInteger(4));

	if (currentSize > std::numeric_limits<NSUInteger>::max() - alignment) {
	// Alignment would overlow.
	return DAWN_OUT_OF_MEMORY_ERROR("Buffer allocation is too large");
	}
	currentSize = Align(currentSize, alignment);

	uint64_t maxBufferSize = QueryMaxBufferLength(ToBackend(GetDevice())->GetMTLDevice());
	if (currentSize > maxBufferSize) {
	return DAWN_OUT_OF_MEMORY_ERROR("Buffer allocation is too large");
	}

	mAllocatedSize = currentSize;
	mMtlBuffer.Acquire([ToBackend(GetDevice())->GetMTLDevice()
	newBufferWithLength:currentSize
	options:storageMode]);
	if (mMtlBuffer == nullptr) {
	return DAWN_OUT_OF_MEMORY_ERROR("Buffer allocation failed");
	}

	// The buffers with mappedAtCreation == true will be initialized in
	// BufferBase::MapAtCreation().
	if (GetDevice()->IsToggleEnabled(Toggle::NonzeroClearResourcesOnCreationForTesting) &&
	!mappedAtCreation) {
	CommandRecordingContext* commandContext =
	ToBackend(GetDevice())->GetPendingCommandContext();
	ClearBuffer(commandContext, uint8_t(1u));
	}

	// Initialize the padding bytes to zero.
	if (GetDevice()->IsToggleEnabled(Toggle::LazyClearResourceOnFirstUse) &&
	!mappedAtCreation) {
	uint32_t paddingBytes = GetAllocatedSize() - GetSize();
	if (paddingBytes > 0) {
	uint32_t clearSize = Align(paddingBytes, 4);
	uint64_t clearOffset = GetAllocatedSize() - clearSize;

	CommandRecordingContext* commandContext =
	ToBackend(GetDevice())->GetPendingCommandContext();
	ClearBuffer(commandContext, 0, clearOffset, clearSize);
	}
	}
	return {};
	}

	Buffer::~Buffer() = default;

	id<MTLBuffer> Buffer::GetMTLBuffer() const {
	return mMtlBuffer.Get();
	}

	bool Buffer::IsCPUWritableAtCreation() const {
	// TODO(enga): Handle CPU-visible memory on UMA
	return GetUsage() & kMappableBufferUsages;
	}

	MaybeError Buffer::MapAtCreationImpl() {
	return {};
	}

	MaybeError Buffer::MapAsyncImpl(wgpu::MapMode mode, size_t offset, size_t size) {
	CommandRecordingContext* commandContext =
	ToBackend(GetDevice())->GetPendingCommandContext();
	EnsureDataInitialized(commandContext);

	return {};
	}

	void* Buffer::GetMappedPointerImpl() {
	return [*mMtlBuffer contents];
	}

	void Buffer::UnmapImpl() {
	// Nothing to do, Metal StorageModeShared buffers are always mapped.
	}

	void Buffer::DestroyImpl() {
	BufferBase::DestroyImpl();
	mMtlBuffer = nullptr;
	}

	bool Buffer::EnsureDataInitialized(CommandRecordingContext* commandContext) {
	if (!NeedsInitialization()) {
	return false;
	}

	InitializeToZero(commandContext);
	return true;
	}

	bool Buffer::EnsureDataInitializedAsDestination(CommandRecordingContext* commandContext,
	uint64_t offset,
	uint64_t size) {
	if (!NeedsInitialization()) {
	return false;
	}

	if (IsFullBufferRange(offset, size)) {
	SetIsDataInitialized();
	return false;
	}

	InitializeToZero(commandContext);
	return true;
	}

	bool Buffer::EnsureDataInitializedAsDestination(CommandRecordingContext* commandContext,
	const CopyTextureToBufferCmd* copy) {
	if (!NeedsInitialization()) {
	return false;
	}

	if (IsFullBufferOverwrittenInTextureToBufferCopy(copy)) {
	SetIsDataInitialized();
	return false;
	}

	InitializeToZero(commandContext);
	return true;
	}

	void Buffer::InitializeToZero(CommandRecordingContext* commandContext) {
	ASSERT(NeedsInitialization());

	ClearBuffer(commandContext, uint8_t(0u));

	SetIsDataInitialized();
	GetDevice()->IncrementLazyClearCountForTesting();
	}

	void Buffer::ClearBuffer(CommandRecordingContext* commandContext,
	uint8_t clearValue,
	uint64_t offset,
	uint64_t size) {
	ASSERT(commandContext != nullptr);
	size = size > 0 ? size : GetAllocatedSize();
	ASSERT(size > 0);
	[commandContext->EnsureBlit() fillBuffer:mMtlBuffer.Get()
	range:NSMakeRange(offset, size)
	value:clearValue];
	}

	} // namespace dawn::native::metal