Distribusi Pekerjaan WebGL Compute Shader: Selami Penugasan Thread GPU

Compute shader di WebGL menawarkan cara ampuh untuk memanfaatkan kemampuan pemrosesan paralel GPU untuk tugas komputasi tujuan umum (GPGPU) langsung di dalam peramban web. Memahami bagaimana pekerjaan didistribusikan ke thread GPU individu sangat penting untuk menulis kernel komputasi yang efisien dan berkinerja tinggi. Artikel ini memberikan eksplorasi komprehensif tentang distribusi pekerjaan di compute shader WebGL, mencakup konsep dasar, strategi penugasan thread, dan teknik optimasi.

Memahami Model Eksekusi Compute Shader

Sebelum menyelami distribusi pekerjaan, mari kita bangun fondasi dengan memahami model eksekusi compute shader di WebGL. Model ini bersifat hierarkis, terdiri dari beberapa komponen kunci:

• Compute Shader: Program yang dieksekusi di GPU, berisi logika untuk komputasi paralel.
• Workgroup: Kumpulan item kerja yang dieksekusi bersama dan dapat berbagi data melalui memori lokal bersama. Anggap ini sebagai tim pekerja yang mengeksekusi bagian dari tugas keseluruhan.
• Work Item: Instansi tunggal dari compute shader, mewakili satu thread GPU. Setiap item kerja mengeksekusi kode shader yang sama tetapi beroperasi pada data yang berpotensi berbeda. Ini adalah pekerja individu dalam tim.
• Global Invocation ID: Pengenal unik untuk setiap item kerja di seluruh dispatch komputasi.
• Local Invocation ID: Pengenal unik untuk setiap item kerja di dalam workgroup-nya.
• Workgroup ID: Pengenal unik untuk setiap workgroup dalam dispatch komputasi.

Ketika Anda mengirimkan compute shader, Anda menentukan dimensi grid workgroup. Grid ini menentukan berapa banyak workgroup yang akan dibuat dan berapa banyak item kerja yang akan berisi setiap workgroup. Misalnya, pengiriman dispatchCompute(16, 8, 4) akan membuat grid 3D workgroup dengan dimensi 16x8x4. Setiap workgroup ini kemudian diisi dengan jumlah item kerja yang telah ditentukan.

Mengonfigurasi Ukuran Workgroup

Ukuran workgroup ditentukan dalam kode sumber compute shader menggunakan pengubah layout:

            layout (local_size_x = 8, local_size_y = 8, local_size_z = 1) in;
            

              
                Copy
              
            
          

Deklarasi ini menentukan bahwa setiap workgroup akan berisi 8 * 8 * 1 = 64 item kerja. Nilai untuk local_size_x, local_size_y, dan local_size_z harus berupa ekspresi konstan dan biasanya merupakan pangkat dari 2. Ukuran workgroup maksimum bergantung pada perangkat keras dan dapat ditanyakan menggunakan gl.getParameter(gl.MAX_COMPUTE_WORK_GROUP_INVOCATIONS). Selain itu, ada batasan pada dimensi individual workgroup yang dapat ditanyakan menggunakan gl.getParameter(gl.MAX_COMPUTE_WORK_GROUP_SIZE) yang mengembalikan array tiga angka yang mewakili ukuran maksimum untuk dimensi X, Y, dan Z masing-masing.

Contoh: Mencari Ukuran Workgroup Maksimum

            const maxWorkGroupInvocations = gl.getParameter(gl.MAX_COMPUTE_WORK_GROUP_INVOCATIONS);
const maxWorkGroupSize = gl.getParameter(gl.MAX_COMPUTE_WORK_GROUP_SIZE);

console.log("Jumlah invocasi workgroup maksimum: ", maxWorkGroupInvocations);
console.log("Ukuran workgroup maksimum: ", maxWorkGroupSize); // Output: [1024, 1024, 64]
            

              
                Copy
              
            
          

Memilih ukuran workgroup yang tepat sangat penting untuk kinerja. Workgroup yang lebih kecil mungkin tidak sepenuhnya memanfaatkan paralelisme GPU, sementara workgroup yang lebih besar dapat melebihi batasan perangkat keras atau menyebabkan pola akses memori yang tidak efisien. Seringkali, eksperimen diperlukan untuk menentukan ukuran workgroup yang optimal untuk kernel komputasi tertentu dan perangkat keras target. Titik awal yang baik adalah bereksperimen dengan ukuran workgroup yang merupakan pangkat dua (misalnya, 4, 8, 16, 32, 64) dan menganalisis dampaknya pada kinerja.

Penugasan Thread GPU dan Global Invocation ID

Ketika compute shader dikirimkan, implementasi WebGL bertanggung jawab untuk menugaskan setiap item kerja ke thread GPU tertentu. Setiap item kerja secara unik diidentifikasi oleh Global Invocation ID-nya, yang merupakan vektor 3D yang mewakili posisinya di dalam seluruh grid dispatch komputasi. ID ini dapat diakses di dalam compute shader menggunakan variabel bawaan GLSL gl_GlobalInvocationID.

gl_GlobalInvocationID dihitung dari gl_WorkGroupID dan gl_LocalInvocationID menggunakan rumus berikut:

            gl_GlobalInvocationID = gl_WorkGroupID * gl_WorkGroupSize + gl_LocalInvocationID;
            

              
                Copy
              
            
          

Di mana gl_WorkGroupSize adalah ukuran workgroup yang ditentukan dalam pengubah layout. Rumus ini menyoroti hubungan antara grid workgroup dan item kerja individu. Setiap workgroup diberi ID unik (gl_WorkGroupID), dan setiap item kerja di dalam workgroup tersebut diberi ID lokal unik (gl_LocalInvocationID). ID global kemudian dihitung dengan menggabungkan kedua ID ini.

Contoh: Mengakses Global Invocation ID

            #version 450

layout (local_size_x = 8, local_size_y = 8, local_size_z = 1) in;

layout (binding = 0) buffer DataBuffer {
    float data[];
} outputData;

void main() {
    uint index = gl_GlobalInvocationID.x + gl_GlobalInvocationID.y * gl_NumWorkGroups.x * gl_WorkGroupSize.x;
    outputData.data[index] = float(index);
}
            

              
                Copy
              
            
          

Dalam contoh ini, setiap item kerja menghitung indeksnya ke dalam buffer outputData menggunakan gl_GlobalInvocationID. Ini adalah pola umum untuk mendistribusikan pekerjaan di seluruh kumpulan data yang besar. Baris `uint index = gl_GlobalInvocationID.x + gl_GlobalInvocationID.y * gl_NumWorkGroups.x * gl_WorkGroupSize.x;` sangat penting. Mari kita bedah:

• gl_GlobalInvocationID.x menyediakan koordinat x item kerja dalam grid global.
• gl_GlobalInvocationID.y menyediakan koordinat y item kerja dalam grid global.
• gl_NumWorkGroups.x menyediakan jumlah total workgroup dalam dimensi x.
• gl_WorkGroupSize.x menyediakan jumlah item kerja dalam dimensi x dari setiap workgroup.

Bersama-sama, nilai-nilai ini memungkinkan setiap item kerja untuk menghitung indeks uniknya dalam array data keluaran yang diratakan. Jika Anda bekerja dengan struktur data 3D, Anda perlu memasukkan gl_GlobalInvocationID.z, gl_NumWorkGroups.y, gl_WorkGroupSize.y, gl_NumWorkGroups.z, dan gl_WorkGroupSize.z ke dalam perhitungan indeks juga.

Pola Akses Memori dan Akses Memori Terkoalesensi

Cara item kerja mengakses memori dapat berdampak signifikan pada kinerja. Idealnya, item kerja dalam satu workgroup harus mengakses lokasi memori yang berdekatan. Ini dikenal sebagai akses memori terkoalesensi, dan memungkinkan GPU untuk mengambil data secara efisien dalam jumlah besar. Ketika akses memori tersebar atau tidak berdekatan, GPU mungkin perlu melakukan beberapa transaksi memori yang lebih kecil, yang dapat menyebabkan hambatan kinerja.

Untuk mencapai akses memori terkoalesensi, penting untuk mempertimbangkan dengan cermat tata letak data dalam memori dan cara item kerja ditugaskan ke elemen data. Misalnya, saat memproses gambar 2D, menugaskan item kerja ke piksel yang berdekatan di baris yang sama dapat menghasilkan akses memori terkoalesensi.

Contoh: Akses Memori Terkoalesensi untuk Pemrosesan Gambar

            #version 450

layout (local_size_x = 16, local_size_y = 16, local_size_z = 1) in;

layout (binding = 0) uniform sampler2D inputImage;
layout (binding = 1) writeonly uniform image2D outputImage;

void main() {
    ivec2 pixelCoord = ivec2(gl_GlobalInvocationID.xy);
    vec4 pixelColor = texture(inputImage, vec2(pixelCoord) / textureSize(inputImage, 0));

    // Lakukan beberapa operasi pemrosesan gambar (misalnya, konversi grayscale)
    float gray = dot(pixelColor.rgb, vec3(0.299, 0.587, 0.114));
    vec4 outputColor = vec4(gray, gray, gray, pixelColor.a);

    imageStore(outputImage, pixelCoord, outputColor);
}
            

              
                Copy
              
            
          

Dalam contoh ini, setiap item kerja memproses satu piksel dalam gambar. Karena ukuran workgroup adalah 16x16, item kerja yang berdekatan dalam workgroup yang sama akan memproses piksel yang berdekatan di baris yang sama. Ini mendorong akses memori terkoalesensi saat membaca dari inputImage dan menulis ke outputImage.

Namun, pertimbangkan apa yang akan terjadi jika Anda mentransposisi data gambar, atau jika Anda mengakses piksel dalam urutan kolom-utama alih-alih urutan baris-utama. Anda kemungkinan akan melihat penurunan kinerja yang signifikan karena item kerja yang berdekatan akan mengakses lokasi memori yang tidak berdekatan.

Memori Lokal Bersama

Memori lokal bersama, juga dikenal sebagai memori lokal bersama (LSM), adalah wilayah memori kecil dan cepat yang dibagikan oleh semua item kerja dalam satu workgroup. Ini dapat digunakan untuk meningkatkan kinerja dengan menyimpan data yang sering diakses atau dengan memfasilitasi komunikasi antara item kerja dalam workgroup yang sama. Memori lokal bersama dinyatakan menggunakan kata kunci shared di GLSL.

Contoh: Menggunakan Memori Lokal Bersama untuk Pengurangan Data

            #version 450

layout (local_size_x = 64, local_size_y = 1, local_size_z = 1) in;

layout (binding = 0) buffer InputBuffer {
    float inputData[];
} inputBuffer;

layout (binding = 1) buffer OutputBuffer {
    float outputData[];
} outputBuffer;

shared float localSum[gl_WorkGroupSize.x];

void main() {
    uint localId = gl_LocalInvocationID.x;
    uint globalId = gl_GlobalInvocationID.x;

    localSum[localId] = inputBuffer.inputData[globalId];

    barrier(); // Tunggu semua item kerja menulis ke memori bersama

    // Lakukan pengurangan di dalam workgroup
    for (uint i = gl_WorkGroupSize.x / 2; i > 0; i /= 2) {
        if (localId < i) {
            localSum[localId] += localSum[localId + i];
        }
        barrier(); // Tunggu semua item kerja menyelesaikan langkah pengurangan
    }

    // Tulis jumlah akhir ke buffer keluaran
    if (localId == 0) {
        outputBuffer.outputData[gl_WorkGroupID.x] = localSum[0];
    }
}
            

              
                Copy