rsx: Implement deferred buffer allocations for GPU write

rpcs3/io_buffer.h

@@ -0,0 +1,65 @@
+#pragma once
+#include <util/types.hpp>
+#include <span>
+#include <vector>
+#include <functional>
+
+namespace rsx
+{
+	template <typename T>
+	concept SpanLike = requires(T t)
+	{
+		{ t.data() } -> std::convertible_to<void*>;
+		{ t.size_bytes() } -> std::convertible_to<usz>;
+	};
+
+	template <typename T>
+	concept Integral = std::is_integral_v<T> || std::is_same_v<T, u128>;
+
+	class io_buffer
+	{
+		void* m_ptr = nullptr;
+		usz m_size = 0;
+
+		std::function<std::tuple<void*, usz> ()> m_allocator = nullptr;
+
+	public:
+		io_buffer() = default;
+
+		template <SpanLike T>
+		io_buffer(T& container)
+		{
+			m_ptr = reinterpret_cast<void*>(container.data());
+			m_size = container.size_bytes();
+		}
+
+		io_buffer(std::function<std::tuple<void*, usz> ()> allocator)
+		{
+			ensure(allocator);
+			m_allocator = allocator;
+		}
+
+		template<Integral T>
+		T* data()
+		{
+			if (!m_ptr && m_allocator)
+			{
+				std::tie(m_ptr, m_size) = m_allocator();
+			}
+
+			return static_cast<T*>(m_ptr);
+		}
+
+		usz size() const
+		{
+			return m_size;
+		}
+
+		template<Integral T>
+		std::span<T> as_span()
+		{
+			const auto bytes = data<T>();
+			return { bytes, m_size / sizeof(T) };
+		}
+	};
+}