Why the default option for non-dynamic vertex/index buffers isn't managed or private for metal backend?

[leeziyu]

Hi! I noticed the performance is much slower on Metal backend compared with DX11 when rendering a mesh with millions of triangles. And I found all the non-dynamic vertex/index buffer is created with default flag which is MTLStorageModeShared. Why the default option for non-dynamic vertex/index buffers isn't managed or private for metal backend? Is there another way to create a private vertex buffer for performance? Thanks!

[attilaz]

On iOS(tvOS) with unified memory model I think there is no extra penalty. Using private only makes life more complicated/slower: To create a buffer with content we need to create a shared buffer and blit data to private buffer.

https://developer.apple.com/documentation/metal/setting_resource_storage_modes/choosing_a_resource_storage_mode_in_ios_and_tvos?language=objc
https://developer.apple.com/documentation/metal/copying_data_to_a_private_resource?language=objc

On macOS there could be performance issue with discrete graphics.
We could use

• private: we need an extra buffer (shared) that can be blitted to the private buffer.
• managed can be created directly with newBufferWithBytes but needs syncresource (which does the copy to video mem if needed).

On discrete memory: both cases do a copy from system to video memory with slightly different API.
On unified memory: private creates two buffers and does a copy, but managed mode sync is a noop(i think).

So I think managed could handle the problem better for both unified and discreet mode.

https://developer.apple.com/documentation/metal/setting_resource_storage_modes/choosing_a_resource_storage_mode_in_macos?language=objc

Quick modification in BufferMtl::create renderer_mtl.mm that uses managed:

	void BufferMtl::create(uint32_t _size, void* _data, uint16_t _flags, uint16_t _stride, bool _vertex)
	{
		BX_UNUSED(_stride);

		m_size   = _size;
		m_flags  = _flags;
		m_vertex = _vertex;

		if (NULL == _data)
		{
			m_ptr = s_renderMtl->m_device.newBufferWithLength(_size, 0);
		}
		else
		{
			m_ptr = s_renderMtl->m_device.newBufferWithBytes(_data, _size, MTLResourceStorageModeManaged);
            s_renderMtl->getBlitCommandEncoder().synchronizeResource(m_ptr);
		}
	}

This should only happen on macos. Can you check if this is faster?
And I am not 100% sure that buffers that are created with content are not allowed to change. @bkaradzic

[bkaradzic]

Yes, if buffer is created with content, it's considered immutable.

[leeziyu]

Yes, I get much faster.
But do you need synchronization after creating new buffer with MTLResourceStorageModeManaged? I thought newBufferWithBytes should already do that for you.

I also tried to modify the BufferMtl::create like this below and it makes even faster. I'm not sure this will cause some undefined behaviors though.

void BufferMtl::create(uint32_t _size, void* _data, uint16_t _flags, uint16_t _stride, bool _vertex)
{
	BX_UNUSED(_stride);

	m_size   = _size;
	m_flags  = _flags;
	m_vertex = _vertex;

	if (NULL == _data)
	{
		m_ptr = s_renderMtl->m_device.newBufferWithLength(_size, MTLResourceStorageModePrivate);
	}
	else
	{
		m_ptr = s_renderMtl->m_device.newBufferWithBytes(_data, _size, MTLResourceStorageModeManaged);
	}
}