Working with Metal: Fundamental

Building Metal Application

초기화

Device 획득

Device는 Metatl의 핵심 오브젝트 → GPU 드라이버 및 하드웨어와 다이렉트로 연결

Metal의 다른 API객체들을 만드는 역할

protocol MTLDevice {
	func makeCommandQueue() -> MTLCommandQueue?
	func makeBuffer(...) -> MTLBuffer?
	func makeTexture(...) -> MTLTexture?
	func makeSamplerState(descriptor: MTLSamplerDescriptor) -> MTLSamplerState?
	func makeRenderPipelineState(...) throws -> MTLRenderPipelineState
	// 그 외 다수
}

// 디바이스 가져오기
let device: MTLDevice? = MTLCreateSystemDefaultDevice()

CommandQueue생성

GPU로 작업을 제출하는 채널

let commandQueue: MTLCommandQueue? = device.makeCommandQueue()

리소스(Buffer&Texture) 생성

let buffer = [...]

withUnsafePointer(buffer) {
	// 새로운 버퍼를 할당하고 포인터가 가리키는 내용을 복사한다.
	// 복사하지 않는 버전도 있다.
	device.makeBuffer(bytes: $0, // RawPointer로 암시적 캐스팅
									length: buffer.count,
									options: [])
}

렌더 파이프 라인 생성
- MTLRenderPipelineDescriptor
  - Vertex Layout Descriptor
  - Vetext Shader
  - Rasterizer Coverage
  - Fragment Shader
  - Blending
  - Framebuffer Formats
- MTLRenderPipelineState: Descriptor로 만들어진 상태
- 셰이더는 Xcode가 오프라인으로 빌드하고, 그 결과는 디바이스 독립적인 바이트 코드 형태이다. → 앱과 함께 번들되어서, 이를 런타임에 이름으로 로딩할 수 있게 된다.
- 이 파이프라인 생성 작업은 비싼 작업이다. 대신 여기서 비싼 작업을 다 해놔서, 렌더 파이프라인간 교체는 아주 싸게 할 수 있다.
```
let desc = MTLRenderPipelineDescriptor()

// 셰이더 설정
let library: MTLLibrary? = device.makeDefaultLibrary()

desc.vertexFunction = library?.makeFunction(name: "myVertexShader")
desc.fragmentFunction = library?.makeFunction(name: "myFragmentShader")

// 픽셀 포맷 설정. 나머지 설정값은 기본값으로 잘 맞춰진다.
desc.colorAttachments[0].pixelFormat = .bgra8Unorm

let renderPipeline = try device.makeRenderPipelineState(descriptor: desc)
```
뷰 생성
- CAMetalLayer라는 CALayer의 서브 클래스가 생김.
- 이걸로 레이어를 오버라이드 하는 것이 첫번째다.

class MyView: UIView {
	override var layerClass: AnyClass {
		return CAMetalLayer.self
	}
}

전체 플로우

// 1. Device 획득
guard let device = MTLCreateSystemDefaultDevice() else {
    return
}
// 2. CommandQueue 생성
guard let commandQueue = device.makeCommandQueue() else {
    return
}
// 3. 리소스 생성
var bytes: [UInt8] = // Raw Pointer로 넘겨야 됨. 
device.makeBuffer(bytes: &bytes, length: bytes.count, options: [])

// 4. 파이프라인 생성
let desc = MTLRenderPipelineDescriptor()

// 셰이더 설정
let library = device.makeDefaultLibrary()
desc.vertexFunction = library?.makeFunction(name: "myVertexShader")
desc.fragmentFunction = library?.makeFunction(name: "myFragmentShader")

// 프레임 버퍼의 픽셀 포맷 지정
desc.colorAttachments[0].pixelFormat = .bgra8Unorm

guard let renderPipeline = try? device.makeRenderPipelineState(descriptor: desc) else { return }

// 5. 뷰 만들기
let view = MyView() //layer가 CAMetalLayer인 뷰

셰이더의 입력과 출력예제

struct Vertex {
	float4 position;
	float4 color;
};

struct VertexOut {
	float4 position [[position]];
	float4 color;
}

vertex VertexOut myVertexShader(
const global Vertex* vertexArray [[buffer(0)]],
unsigned int vid                 [[vertex_id]])
{
	VSOut out;
	out.position = vertexArray[vid].position;
	out.color = vertexArray[vid].color
	return out;
}

fragment float4 myFragmentShader(
	VertexOut interpolated [[stage_in]] {
	return interpolated.color;
}

드로잉 과정
1. 커맨드 버퍼 획득
  - CommandQueue에서 나온다.
2. 랜더 패스 시작
  - RenderPass도 Descriptor를 기반으로 한다.
3. 드로잉
4. 커맨드 버퍼에 커밋

// 현재 프레임의 타겟 drawalbe을 가져온다.
// 쓸 수 있는 텍스쳐가 당장 없으면 스레드가 블록될 수 있다.
let drawable = metalLayer.nextDrawable()

// 1. 커맨드 버퍼 획득
let commandBuffer = commandQueue.makeCommandBuffer()

let renderDesc = MTLRenderPassDescriptor()

renderDesc.colorAttachments[0].texture = drawable.texture
renderDesc.colorAttachments[0].loadAction = .clear
renderDesc.colorAttachments[0].clearColor = MTLClearColor()

// 2. 랜더 패스 시작
let render = commandBuffer?.makeRenderCommandEncoder(descriptor: renderDesc)

// 3. 드로잉
render?.setRenderPipelineState(renderPipeline)
render?.setVertexBuffer(vertexBuffer, offset: 0, index: 0)
render?.drawPrimitives(type: .triangle, vertexStart: 0, vertexCount: 3)
render?.endEncoding()

// 4. 커맨드 버퍼에 커밋

// Core Animation에 해당 drawable 객체를 표시할지를 알려줌
// 당장은 그려진게 없으니, 커밋 이후에 다그려지면 메탈이 Core Animation에 통보
commandBuffer?.present(drawable)

// commandBuffer를 CommandQueue에 커밋
// 큐에 들어간 이후에 실제 모든 작업이 일어난다.
commandBuffer?.commit()

Uniforms and Synchronization

Uniform: Shader에서 쓸 수 있는 읽기 전용 변수
메탈에서는 인자로 제공한다.

struct Uniforms {
	float4x4 mvp_matrix;
};

vertex VSOut vertexShader(
	const global Vertex* vertexArray [[ buffer(0) ]],
	constant Uniforms& uniforms [[ buffer(1) ]],
	unsigned int vid [[ vertex_id]]) {
		VSOut out;
		out.position = uniform.mvp_matrix * vertexArray[vid].position;
		out.color = half4(vertexArray[vid].color);
		return out;
	}

API에서 인자로 제공하는 법


// Uniform data 는 만들었다 가정
// Buffer를 만들고, 포인터로 바인딩해서, 데이터를 설정해준다..
render?.setRenderPipelineState(renderPipeline)
render?.setVertexBuffer(vertexBuffer, offset: 0, index: 0)
render?.setVertexBuffer(uniformBuffer, offset: 0, index: 1)
render?.drawPrimitives(type: .triangle, vertexStart: 0, vertexCount: 3)

하지만 여기서 경쟁 상태가 있을 수 있다.
- GPU 동작은 비동기이기 떄문에, CPU가 프레임을 준비하는 것과는 별개로 돌아간다.
- 이 때 GPU가 사용하고 있는 버퍼에 데이터를 쓰면 경쟁상태가 된다.
- 다른 버퍼를 쓰면 해결이 되긴 하지만, 새로운 버퍼를 무한정 할당할 수는 없는 노릇이다.
- 그래서 최후의 수단으로는, 기다려야 한다. 이때 세마포어를 쓸 수 있다.

let avaliableResources = DispatchSemaphore(value: 3)

// 프레임 루프
{
	avaliableResources.wait()
		
	// commandBuffer 생성
	// ...
	
	commandBuffer?.addCompletionHandler { commandBuffer in
		avaliableResources.signal()
	}

	commandBuffer?.commit()
}

Metal Shading Language

writing shaders in Metal

shader는 vertex단위로 parallel하게 돌아간다.
글로벌 변수는 없다. 모든 변수는 인자로 제공되어야 한다.
pseudo code → 이를 기반으로 Metal shader를 만들자.

struct VertexOutput {
	float4 pos [[ position ]];
	float2 uv;
}

VertexOutput
texturedQuadVertex(const float4* vtx_data,
									const float2* uv_data,
									uint vid) {

	VertexOutput v_out;
	v_out.pos = vtx_data[vid];
	v_out.uv = uv_data[vid];
	return v_out;
}

shader code

#include <metal_stdlib> // metal은 C++ 표준 라이브러리 대신, GPU에 최적화된 자체 표준 라이브러리를 쓴다.
using namespace metal;

struct VertexOutput {
	float4 pos [[ position ]];
	float2 uv;
}

// vertex shader임을 나타내기 위한 vertex 키워드 추가
vertex VertexOutput
texturedQuadVertex(const global float4* vtx_data [[ buffer(0) ]], // buffer에서 몇번째 데이터인지를 명시
									const float2* uv_data [[ buffer(1) ]],
									uint vid [[ vertex_id ]]) {

	VertexOutput v_out;
	v_out.pos = vtx_data[vid];
	v_out.uv = uv_data[vid];
	return v_out;
}

// fragment shader임을 나타내기 위한 fragment키워드 추가
fragment float4
textureQuadFragment(VertexOutput frag_input [[ stage_in ]], // vertex shader의 output이 input으로 들어간다.
										texture2d<float> tex [[ texture(0) ]],
										sampler s [[  sampler(0))  ]]

Data types in Metal
- basic types
  - Scalars
    - C++ 11에서의 스칼라타입들 + half(IEEE 754 16 bit 부동 소숫점 타입)
    - half 타입도 다른 부동소숫점 타입과 똑같이 다룰 수 있다.
    - 퍼포먼스와 에너지 효율 측면에서 half를 권장한다.
  - 벡터
    - 스칼라 여러개를 묶어놓은 것. 2,3,4개 짜리 타입이 있다.
    - ex) char2, int3, float4, half2 등
    - 이를 가지고 별도 타입을 정의할경우, align문제로 예상보다 타입 크기가 커질 수 있다.(가장 큰 타입의 크기 * 필드 수) 이떄 작은 타입들을 packed_(typename)으로 선언하면 타입 크기를 줄일 수 있다.
      - 다만 이렇게 패킹된 타입은 CPU 입장에서는 다루기 좋지 않기 때문에, 호스트 어플리케이션에서 계산할때는 align된 걸 쓰는 게 좋다. 셰이더에 넘겨서 셰이더가 계산하게 할때 쓰는 테크닉이다.
  - 행렬
    - 부동 소숫점 타입의 행렬만 존재
    - floatnxm,halfnxm
    - column major → GL과 같은 순서
    - 벡터와 행렬 생성자 및 연산자는 GLSL과 유사함
    - 데이터 타입은 simd.h(swift는 simd)에 정의되어 있다. shader와 host 모두 이 두개를 가지고 와아 타입을 제대로 해석할 수 있다. → 양쪽에서 별개로 타입을 정의할 필요가 없다.
  - atomics
    - atomic_int, atomic_uint
    - 해당 타입에 대한 연산은 race_free
      - C++11의 atomic 함수들의 서브셋
      - 다른 스레드의 간섭을 받지 않고 작업을 수행할 수 있음이 보장된다.
- resources and state objects
  - Texture
    - 템플릿 기반
    - 컬러 타입(컬러 데이터가 담긴 벡터 타입)과 접근 모드(샘플링, 읽기, 쓰기)를 템플릿 인자로 받는다. → 모드에 따라 타입이 달라진다. 이는 최적화 때문
```
fragment FragOutput
my_fragment_shader(
	texture2d<float> tA [[ texture(0) ]], // default는 sample
	texture2d<half, access::write> tB [[ texture(1) ]],
	depth2d<float> tc [[ texture(2) ]],
	...)
{
}
```
  - Sampler
    - 텍스쳐와 분리된 존재. → 여러 텍스쳐에 같은 샘플러를 쓸 수 있다. 혹은 여러 샘플러를 한 텍스쳐에 쓸 수도 있다.
```
fragment float4
texturedQuadFragment(VertexOutput frag_input [[ stage_in ]],
											texture2d<float> tex [[ texture(0) ]],
											sampler s [[ sampler(0]])
{
	return tex.sample(s, frag_input.texcoord);
}
```
    - 아니면 아예 코드상으로 정의할 수도 있다.
```
// 가변 템플릿
constexpr sampler s(coord::normalized,
										filter::linear,
										address::clamp_to_edge);

// sampler 프로퍼티를 명시하지 않았을 때의 기본 값
constexpr sampler s(address::clamp_to_zero);
```
  - buffer
    - 포인터 혹은 특정 타입에 대한 참조
    - 어떤 주소 공간에서 온 것인지 명시해야 한다. → global, constant
    - 언제 global을 써야 하는가?
      - buffer가 vertex ID, 혹은 global ID 등으로 동적으로 참조될 때
    - 언제 constant를 써야 하는가?
      - 여러 셰이더가 동일한 영역을 참조할때
        
        Lignt Descriptors, material properties
        
        Skinning matrices
        
        Filter weights
      - 참조 형태로 넘겨짐(크기 정보를 알 수 있고 프리패칭을 해서 최적화할 수 있기 때문
```
vertex VertexOutput
my_vertex(const global float3* position_data [[ buffer(0) ]],
					const global float3* normal_data [[ buffer(1) ]],
					constant TransformMatrices& matrices [[ buffer(2) ]],
					uint vid [[ vertex_id ]])
{
	VertexOut out;
	float3 n_d = normal_data[vid];
	float3 transformed_normal = matrices.normal_matrix * n_d;
	float4 p_d = float4([position_data[vid], 1.0f);
	out.position = matrices.modelview_projection_matrix * p_d;
	float4 eye_vector = matrices.modelview_matrix * p_d;
	...
	return out;
}
```

Shader inputs, outputs, and matching rules

Per-Vertex input

shader가 vertex data의 레이아웃을 알 수 있는 경우: vertex buffer를 global로 넘기고 vertex ID와 instance ID로 참조

vertex VertexOutput
my_vertex_shader(vertexInputA* inputA [[ buffer(0) ]],
								vertexInputB* inputB [[ buffer(1) ]],
								uint vid [[ vertex_id ]],
								unit instid [[instance_id]])
{
	float a = inputA[vid].a;
	half4 b = inputB[instid].b;
	// ...
}

shader와 vertex data 타입을 디커플링시키고 싶은 경우

OpenGL의 vertex Array API와 매칭됨

vertext Descriptor를 만들어서, 어떤 버퍼인지, 버퍼에서 어느 우치인지, 포맷이 무엇인지등을 지정한다. → 1개 이상의 버퍼를 사용 가능

struct VertexInput {
	float4 position [[ attribute(0) ]];
	float3 normal [[ attribute(1) ]];
	half4 color [[ attribute(2) ]];
	half2 texcoord [[ attribute[3 ]];
};

vertex VertexOutput
my_vertex_shader(VertexInput v_in [[ stage_in ]], ...

let vertexDesc = MTLVertexDescriptor()

let positionDesc = MTLVertexAttributeDescriptor()
positionDesc.bufferIndex = 0
positionDesc.offset = 0
positionDesc.format = .float3

vertexDesc.attributes[0] = positionDesc

let normalDesc = MTLVertexAttributeDescriptor()
normalDesc.bufferIndex = 0
normalDesc.offset = 12
normalDesc.format = .float3
vertexDesc.attributes[1] = normalDesc

let colorDesc = MTLVertexAttributeDescriptor()
colorDesc.bufferIndex = 0
colorDesc.offset = 24
colorDesc.format = .uchar4Normalized
vertexDesc.attributes[2] = normalDesc

let textureCoordDesc = MTLVertexAttributeDescriptor()
textureCoordDesc.bufferIndex = 0
textureCoordDesc.offset = 28
textureCoordDesc.format = .ushort2Normalized
vertexDesc.attributes[3] = normalDesc

let strideDesc = MTLVertexBufferLayoutDescriptor()
strideDesc.stride = 32

vertexDesc.layouts[0] = strideDesc // 이 인덱스는 버퍼 인덱스를 의미

pipelineDescriptor.vertexDescriptor = vertexDesc

Per-Vertex Outputs
- output은 보통 resterizer로 가게 됨
- float4 혹은 커스텀 구조체를 반환한다.
  - 스칼라, 벡터 , 행렬 모두 가능
  - built-in 변수들
    - [[ postion ]]
    - [[ point_size ]]
    - [[ clip_distance ]]