Metal — ano ito, graphic API at shader

Ano ang Metal?

Metal ay isang mababang-antas na API para sa pagtatrabaho sa graphics processor (GPU), na ipinakilala ng Apple noong 2014 kasama ng iOS 8 at OS X Yosemite. Ang Metal ay nilikha bilang kapalit ng OpenGL at OpenCL na may layuning bawasan ang CPU overhead at magbigay ng mas direktang access sa GPU hardware sa mga Apple device.

Hindi tulad ng OpenGL, kung saan ang driver ay nagsasagawa ng maraming pagsusuri at pagbabago sa CPU, ang Metal ay gumagamit ng modelo ng explicit resource management. Kinokontrol ng developer ang memory allocation, synchronization, at pagpapadala ng GPU commands, na nagbibigay ng performance increase na hanggang 50% kumpara sa OpenGL ES sa parehong hardware.

Sinusuportahan ng Metal ang lahat ng Apple chips, simula sa A7 (2013) hanggang M4 Ultra (2025). Patuloy na umuunlad ang API: Ang Metal 3 (2022) ay nagdagdag ng suporta para sa mesh-shader at ray tracing, Metal 3.1 (2023) — mabilis na pagbabahagi ng resources sa pagitan ng CPU at GPU, at Metal 4 (2025) — hardware acceleration ng neural networks sa GPU na may suporta sa FP8 at INT4.

Kasaysayan ng Metal

Ang unang bersyon ng Metal (2014) ay nagbigay ng basic API para sa graphic rendering sa iOS. Ang Metal 2 (2017) ay nagdagdag ng compute shader at Metal Performance Shaders. Ang Metal 3 (2022) ay nagpakilala ng MetalFX Upscaling — sariling upscaling technology para sa mga laro, katunggali ng NVIDIA DLSS at AMD FSR. Ang MetalFX ay nagbibigay ng performance increase na hanggang 2x sa Mac na may M2.

Ang Metal 4 (2025) ay nakatuon sa machine learning at ray tracing. Ayon sa datos ng Apple (2025), ang Metal 4 sa M4 Ultra ay umaabot ng hanggang 80 TFLOPS sa computational tasks sa FP16 at sumusuporta sa hardware decoding ng AV1. Ang Metal ay sinusuportahan na rin sa Apple Vision Pro sa pamamagitan ng compositor service para sa rendering ng immersive content.

Arkitektura ng Metal: device at resources

Arkitektura ng Metal ay binuo sa paligid ng konsepto ng explicit management: ang developer ay lumilikha ng MTLDevice (device), MTLBuffer (data buffer), MTLTexture (texture), at MTLCommandQueue (command queue) na mga object. Hindi tulad ng OpenGL, kung saan ang state ay nakaimbak sa context, ang Metal ay gumagamit ng state objects na na-co-compile nang maaga.

MTLDevice — entry point ng API

MTLDevice ay kumakatawan sa isang physical o virtual GPU. Lahat ng Metal resources ay nilikha sa pamamagitan ng object na ito: buffer, texture, shader library, pipeline. Sa mga system na may maraming GPU (Mac Pro), maaaring pumili ng partikular na device. Ang method na supportsFamily: ay sumusuri ng suporta sa feature: ray tracing, mesh-shader, MetalFX.

import Metal
 
// Pagkuha ng GPU device
guard let device = MTLCreateSystemDefaultDevice() else {
    fatalError("Hindi sinusuportahan ang Metal")
}
 
// Pagsusuri ng mga kakayahan
let supportsRayTracing = device.supportsFamily(.metal3)
let gpuName = device.name // “Apple M4 Pro”
let maxBufferSize = device.maxBufferLength

Ang property na maxBufferLength ay tumutukoy sa maximum na laki ng buffer na sinusuportahan ng device. Sa Apple Silicon na may Unified Memory, ang limitasyon ay hanggang 128 GB (sa M4 Ultra). Ito ay nagpapahintulot ng pagtatrabaho sa malalaking dataset para sa ML at siyentipikong pagcompute nang walang segmentation ng buffer. Ang device ay namamahala rin ng memory pool sa pamamagitan ng MTLHeap.

MTLBuffer at MTLTexture — data para sa GPU

MTLBuffer — tuloy-tuloy na memory area na accessible sa GPU. Ang buffer ay ginagamit para sa vertex data, matrices, uniform variables. Mga mode: shared (CPU + GPU access sa unified memory), private (GPU lang, mas mabilis), managed (para sa discrete GPU, may synchronization). Sa Apple Silicon, inirerekomenda ang shared para sa pagiging simple.

MTLTexture — multidimensional pixel array para sa texture at render targets. Sinusuportahan ang 1D, 2D, 3D, cube at array texture. Mga format: RGBA8Unorm, BGRA8Unorm, RGBA16Float, R32Float, ASTC (compression), depth (depth32Float) at stencil. Ang Texture Usage flags ay nagpapahiwatig kung paano gagamitin ang texture: rendering, shader reading, pagcopy.

MTLLibrary at compilation ng shader

MTLLibrary — koleksyon ng naka-compile na GPU functions (shader). Ang library ay maaaring gawin mula sa MSL source code (Metal Shading Language) sa runtime o pre-compiled at isama sa bundle (.metallib). Inirerekomenda ang pre-compilation upang maalis ang mga pagkaantala sa yugto ng initialisation.

MTLFunction ay kumakatawan sa isang partikular na shader function. Ang vertex shader, fragment shader, compute shader (kernel), at mesh-shader ay nilikha sa pamamagitan ng library. Ang mga function ay naka-cache sa GPU at ginagamit muli sa pagitan ng mga frame. Ang mga argumento ng shader ay tinutukoy sa pamamagitan ng buffer at texture slot na may binding batay sa index.

Rendering sa pamamagitan ng Metal: command buffer

Rendering sa Metal ay organisado sa pamamagitan ng asynchronous command queue. Ang developer ay lumilikha ng MTLCommandBuffer, nag-e-encode ng rendering o compute commands dito, at ipinapadala sa MTLCommandQueue. Ang GPU ay nag-e-execute ng commands nang sequential, habang ang CPU ay maaaring magpatuloy sa trabaho. Ang synchronization ay nagaganap sa pamamagitan ng semaphore o completionHandler.

MTLCommandQueue at MTLCommandBuffer

MTLCommandQueue — command queue na ginawa mula sa MTLDevice. Ang application ay maaaring magkaroon ng maraming queue para sa graphics, computing, at pagcopy. Ang bawat queue ay ginagarantiyahan ang sequential execution ng commands. MTLCommandBuffer — container para sa isang bahagi ng GPU work. Pagkatapos ng encoding, ito ay nagco-commit at nag-e-execute sa GPU.

// Pangunahing rendering loop
let commandQueue = device.makeCommandQueue()!
 
guard let commandBuffer = commandQueue.makeCommandBuffer()
else { return }
 
guard let descriptor = currentDrawable.texture.makeRenderPassDescriptor(
    attachment: 0
) else { return }
 
let encoder = commandBuffer.makeRenderCommandEncoder(
    descriptor: descriptor
)!
encoder.setRenderPipelineState(pipelineState)
encoder.drawPrimitives(type: .triangle,
    vertexStart: 0, vertexCount: 36)
encoder.endEncoding()
 
commandBuffer.present(currentDrawable)
commandBuffer.commit()

Ang method na drawPrimitives ay nagsasagawa ng pag-drawing ng geometry. Ang parameter na vertexCount ay nagpapahiwatig ng bilang ng vertices. Para sa bawat frame, isang bagong command buffer ang nilikha. Present ay nagsi-sync ng pag-drawing sa VSync ng screen. Ang Metal ay awtomatikong namamahala ng synchronization sa display sa pamamagitan ng CAMetalLayer.

Render Pipeline State

MTLRenderPipelineState — naka-compile na state ng rendering pipeline, kasama ang vertex at fragment shader, depth-stencil configuration, blending, at output pixel format. Ang paggawa ng pipeline state ay isang mamahaling operasyon, kaya ang mga object ay naka-cache at ginagamit muli. Para sa iba't ibang kombinasyon ng shader, iba't ibang pipeline states ang nilikha.

Ang Metal 3.1 ay nagpakilala ng mabilis na rendering sa pamamagitan ng Immutable Samplers, na naka-cache sa GPU para sa pagpapabilis ng texture sampling. Ang Metal ay sumusuporta ng hanggang 31 texture bawat shader slot sa Apple Silicon environments. Sa mas lumang device na may A13 pababa, ang limitasyon ay binabaan sa 16 slots. Inirerekomenda ang pagsasama ng texture sa Texture Atlases upang mabawasan ang bilang ng samples.

Metal Shading Language at shader

Metal Shading Language (MSL) — programming language para sa shader batay sa C++14 na may mga extension para sa GPU computing. Ang MSL ay sumusuporta sa templates, function overloading, namespace, at address arithmetic. Ang shader ay na-co-compile sa binary GPU code sa pamamagitan ng Apple LLVM backend.

Vertex at Fragment Shader

Vertex shader ay nagpro-process ng bawat vertex: nag-transform ng coordinates mula sa world space patungo sa screen space, nagko-compute ng normals, at nagpapadala ng data sa fragment shader. Fragment shader ay nagko-compute ng kulay ng bawat pixel: nag-a-apply ng texture, lighting, at post-processing effects.

// Metal vertex shader
#include <metal_stdlib>
using namespace metal;
 
struct VertexIn {
    float3 position [[attribute(0)]];
    float3 normal   [[attribute(1)]];
};
 
struct VertexOut {
    float4 position [[position]];
    float3 worldNormal;
};
 
vertex VertexOut vertexMain(
    VertexIn in [[stage_in]],
    constant float4x4 &mvp [[buffer(0)]]
) {
    VertexOut out;
    out.position = mvp * float4(in.position, 1.0);
    out.worldNormal = in.normal;
    return out;
}

Ang mga attribute na [[attribute(N)]] ay tumutugma sa vertex formats na tinukoy sa MTLVertexDescriptor. Ang buffer [buffer(0)] ay nagpapadala ng MVP matrix bilang uniform variable. Ang posisyon ng vertex ay dapat markahan ng [[position]] para sa pagpapadala sa rasterizer. Lahat ng MSL vector types — float2, float3, float4 — ay nami-map sa hardware GPU registers.

Compute Shader (Compute Kernels)

Compute shader (kernel) — GPU function na na-e-execute sa labas ng graphics pipeline. Ang kernel functions ay mina-markahan ng qualifier na kernel at na-e-execute sa threads na naka-organisa sa threadgroups. Ang compute shader ay ginagamit para sa image processing, physics simulation, ML, at post-processing.

// Compute kernel para sa pag-blur ng imahe
kernel void blurKernel(
    texture2d<half> input  [[texture(0)]],
    texture2d<half> output [[texture(1)]],
    constant float &radius  [[buffer(0)]],
    uint2 gid [[thread_position_in_grid]]
) {
    if (gid.x >= input.get_width() ||
        gid.y >= input.get_height()) { return; }
    half4 color = input.read(gid);
    output.write(color, gid);
}

Ang parameter na gid [[thread_position_in_grid]] ay naglalaman ng unique thread index. Ang Texture2D ay nag-specialize batay sa pixel type: half (FP16), float (FP32). Ang compute kernels ay maaaring i-launch na may grid size na higit sa 1 bilyong thread sa M4 Ultra. Ang maximum na threadgroup size ay 1024 thread sa Apple Silicon GPU.

Performance at Metal Performance Shaders

Metal Performance Shaders (MPS) — library ng optimized GPU functions na ibinibigay ng Apple. Ang MPS ay may kasamang convolutional neural networks (MPSNNConvolution), matrix multiplication (MPSMatrixMultiplication), sorting (MPSParallelSort), at image processing (MPSImageGaussianBlur). Lahat ng functions ay na-optimize para sa partikular na Apple GPU.

MetalFX Upscaling

MetalFX — upscaling at anti-aliasing technology, katunggali ng NVIDIA DLSS at AMD FSR. Ang MetalFX ay nag-aalok ng dalawang mode: Spatial (spatial upscaling sa pamamagitan ng FSR 2 algorithm) at Temporal (temporal upscaling na may motion vectors). Ang Temporal MetalFX ay nagbibigay ng kalidad na malapit sa native 4K mula sa rendering sa 1440p.

Ayon sa datos ng Apple (2025), ang MetalFX Temporal sa M4 Max ay nagbibigay ng performance increase na hanggang 3x sa mga laro habang pinapanatili ang kalidad na hindi makikita ang pagkakaiba sa native resolution. Ang MetalFX ay gumagana sa anumang GPU na sumusuporta sa Metal 3, nang walang dedicated tensor cores. Ang integration ng MetalFX sa isang project ay nangangailangan ng mga 50 lines ng code.

Ray Tracing sa Metal

Ray Tracing sa Metal 3 ay sinusuportahan sa M3, M4, at A17 Pro chips na may hardware acceleration blocks (Ray Tracing Accelerators). Ang Metal ay nagbibigay ng MTLAccelerationStructure para sa pagbuo ng BVH at MTLIntersectionFunction para sa ray intersection sa shader. Ang mga higanteng eksena na may milyun-milyong triangles ay na-co-compile sa BVH sa millisecond.

Ayon sa datos ng Apple (2025), ang hardware ray tracing sa M4 Ultra ay nagsasagawa ng hanggang 40 bilyong ray intersection bawat segundo (Giga rays/s). Ito ay 4 na beses na mas mabilis kaysa software ray tracing sa M1 Ultra. Ang Metal RT ay sumusuporta sa intersection queries, dynamic geometries, at Motion Blur para sa makatotohanang animation. Ang mga reflection at anino na may ray tracing ay gumagana sa real-time sa 60 FPS.

Unified Memory at Zero-Copy

Unified Memory — arkitektura ng Apple Silicon kung saan ang CPU at GPU ay gumagamit ng parehong physical memory. Ang Metal sa Apple Silicon ay hindi nangangailangan ng pagcopy ng data sa pagitan ng CPU at GPU: ang MTLBuffer sa shared mode ay accessible sa parehong processor nang walang pagcopy. Ito ay nag-aalis ng pangunahing bottleneck ng tradisyonal na GPU (PCIe transfers).

Ang Zero-Copy sa Metal ay nagpapahintulot sa CPU na magsulat ng data sa buffer, at ang GPU na basahin ito nang walang pagkaantala. Ayon sa datos ng Apple (2025), ito ay nagbibigay ng performance increase na 30–50% kumpara sa discrete GPU sa mga laro at ML tasks. Para sa discrete GPU (Mac Pro na may Radeon), ang Metal ay sumusuporta sa managed mode na may automatic synchronization sa pamamagitan ng memory barriers.