WebGL Hesaplama Gölgelendiricisi İş Dağıtımı: GPU İş Parçacığı Atamasına Derinlemesine Bir Bakış

WebGL'deki hesaplama gölgelendiricileri, genel amaçlı hesaplama (GPGPU) görevleri için GPU'nun paralel işlem yeteneklerinden doğrudan bir web tarayıcısı içinde yararlanmanın güçlü bir yolunu sunar. İşin bireysel GPU iş parçacıklarına nasıl dağıtıldığını anlamak, verimli ve yüksek performanslı hesaplama çekirdekleri yazmak için çok önemlidir. Bu makale, WebGL hesaplama gölgelendiricilerinde iş dağıtımının temel kavramlarını, iş parçacığı atama stratejilerini ve optimizasyon tekniklerini kapsayan kapsamlı bir incelemesini sunar.

Hesaplama Gölgelendiricisi Yürütme Modelini Anlamak

İş dağıtımına dalmadan önce, WebGL'deki hesaplama gölgelendiricisi yürütme modelini anlayarak bir temel oluşturalım. Bu model, birkaç ana bileşenden oluşan hiyerarşik bir yapıdır:

• Hesaplama Gölgelendiricisi: Paralel hesaplama mantığını içeren, GPU üzerinde yürütülen program.
• İş Grubu (Workgroup): Birlikte çalışan ve paylaşımlı yerel bellek aracılığıyla veri paylaşabilen bir iş öğesi koleksiyonu. Bunu, genel görevin bir bölümünü yürüten bir çalışan ekibi olarak düşünebilirsiniz.
• İş Öğesi (Work Item): Tek bir GPU iş parçacığını temsil eden, hesaplama gölgelendiricisinin bireysel bir örneği. Her iş öğesi aynı gölgelendirici kodunu yürütür ancak potansiyel olarak farklı veriler üzerinde çalışır. Bu, ekibin bireysel çalışanıdır.
• Küresel Çağrı Kimliği (Global Invocation ID): Tüm hesaplama gönderimi boyunca her iş öğesi için benzersiz bir tanımlayıcı.
• Yerel Çağrı Kimliği (Local Invocation ID): Kendi iş grubu içinde her iş öğesi için benzersiz bir tanımlayıcı.
• İş Grubu Kimliği (Workgroup ID): Hesaplama gönderimindeki her iş grubu için benzersiz bir tanımlayıcı.

Bir hesaplama gölgelendiricisi gönderdiğinizde, iş grubu ızgarasının boyutlarını belirlersiniz. Bu ızgara, kaç iş grubu oluşturulacağını ve her iş grubunun kaç iş öğesi içereceğini tanımlar. Örneğin, dispatchCompute(16, 8, 4) gönderimi 16x8x4 boyutlarında 3D bir iş grubu ızgarası oluşturacaktır. Bu iş gruplarının her biri daha sonra önceden tanımlanmış sayıda iş öğesi ile doldurulur.

İş Grubu Boyutunu Yapılandırma

İş grubu boyutu, hesaplama gölgelendiricisi kaynak kodunda layout niteleyicisi kullanılarak tanımlanır:

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

              
                Copy
              
            
          

Bu bildirim, her iş grubunun 8 * 8 * 1 = 64 iş öğesi içereceğini belirtir. local_size_x, local_size_y ve local_size_z değerleri sabit ifadeler olmalı ve genellikle 2'nin kuvvetleri olmalıdır. Maksimum iş grubu boyutu donanım bağımlıdır ve gl.getParameter(gl.MAX_COMPUTE_WORK_GROUP_INVOCATIONS) kullanılarak sorgulanabilir. Ayrıca, gl.getParameter(gl.MAX_COMPUTE_WORK_GROUP_SIZE) kullanılarak sorgulanabilen iş grubunun bireysel boyutlarına ilişkin sınırlamalar vardır; bu, X, Y ve Z boyutları için maksimum boyutu temsil eden üç sayılık bir dizi döndürür.

Örnek: Maksimum İş Grubu Boyutunu Bulma

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

console.log("Maximum workgroup invocations: ", maxWorkGroupInvocations);
console.log("Maximum workgroup size: ", maxWorkGroupSize); // Output: [1024, 1024, 64]

            

              
                Copy
              
            
          

Uygun bir iş grubu boyutu seçmek performans için kritik öneme sahiptir. Daha küçük iş grupları GPU'nun paralelliğini tam olarak kullanamazken, daha büyük iş grupları donanım sınırlamalarını aşabilir veya verimsiz bellek erişim modellerine yol açabilir. Genellikle, belirli bir hesaplama çekirdeği ve hedef donanım için en uygun iş grubu boyutunu belirlemek için deneme yapmak gerekir. İyi bir başlangıç noktası, 2'nin kuvvetleri olan iş grubu boyutlarını (örn. 4, 8, 16, 32, 64) denemek ve performans üzerindeki etkilerini analiz etmektir.

GPU İş Parçacığı Ataması ve Küresel Çağrı Kimliği

Bir hesaplama gölgelendiricisi gönderildiğinde, WebGL uygulaması her iş öğesini belirli bir GPU iş parçacığına atamaktan sorumludur. Her iş öğesi, tüm hesaplama gönderim ızgarasındaki konumunu temsil eden 3B bir vektör olan Küresel Çağrı Kimliği (Global Invocation ID) ile benzersiz şekilde tanımlanır. Bu kimliğe, dahili GLSL değişkeni gl_GlobalInvocationID kullanılarak hesaplama gölgelendiricisi içinde erişilebilir.

gl_GlobalInvocationID, gl_WorkGroupID ve gl_LocalInvocationID'den aşağıdaki formül kullanılarak hesaplanır:

            gl_GlobalInvocationID = gl_WorkGroupID * gl_WorkGroupSize + gl_LocalInvocationID;
            

              
                Copy
              
            
          

Burada gl_WorkGroupSize, layout niteleyicisinde belirtilen iş grubu boyutudur. Bu formül, iş grubu ızgarası ile bireysel iş öğeleri arasındaki ilişkiyi vurgular. Her iş grubuna benzersiz bir kimlik (gl_WorkGroupID) atanır ve bu iş grubu içindeki her iş öğesine benzersiz bir yerel kimlik (gl_LocalInvocationID) atanır. Küresel kimlik daha sonra bu iki kimliğin birleştirilmesiyle hesaplanır.

Örnek: Küresel Çağrı Kimliğine Erişim

            #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
              
            
          

Bu örnekte, her iş öğesi gl_GlobalInvocationID kullanarak outputData arabelleğindeki kendi dizinini hesaplar. Bu, büyük bir veri kümesi genelinde iş dağıtımı için yaygın bir desendir. `uint index = gl_GlobalInvocationID.x + gl_GlobalInvocationID.y * gl_NumWorkGroups.x * gl_WorkGroupSize.x;` satırı çok önemlidir. Şimdi bunu inceleyelim: * `gl_GlobalInvocationID.x`, iş öğesinin küresel ızgaradaki x koordinatını sağlar. * `gl_GlobalInvocationID.y`, iş öğesinin küresel ızgaradaki y koordinatını sağlar. * `gl_NumWorkGroups.x`, x boyutundaki toplam iş grubu sayısını sağlar. * `gl_WorkGroupSize.x`, her iş grubunun x boyutundaki iş öğesi sayısını sağlar. Bu değerler birlikte, her iş öğesinin düzleştirilmiş çıkış veri dizisi içinde kendi benzersiz dizinini hesaplamasına olanak tanır. Bir 3D veri yapısıyla çalışıyor olsaydınız, dizin hesaplamasına `gl_GlobalInvocationID.z`, `gl_NumWorkGroups.y`, `gl_WorkGroupSize.y`, `gl_NumWorkGroups.z` ve `gl_WorkGroupSize.z`'yi de dahil etmeniz gerekirdi.

Bellek Erişim Desenleri ve Birleşik Bellek Erişimi

İş öğelerinin belleğe erişme şekli performansı önemli ölçüde etkileyebilir. İdeal olarak, bir iş grubu içindeki iş öğeleri bitişik bellek konumlarına erişmelidir. Bu, birleşik bellek erişimi (coalesced memory access) olarak bilinir ve GPU'nun verileri büyük parçalar halinde verimli bir şekilde getirmesine olanak tanır. Bellek erişimi dağınık veya bitişik olmadığında, GPU'nun birden fazla daha küçük bellek işlemi gerçekleştirmesi gerekebilir, bu da performans darboğazlarına yol açabilir.

Birleşik bellek erişimi elde etmek için, bellekteki veri düzenini ve iş öğelerinin veri elemanlarına nasıl atandığını dikkatlice değerlendirmek önemlidir. Örneğin, 2B bir görüntüyü işlerken, iş öğelerini aynı satırdaki bitişik piksellere atamak birleşik bellek erişimine yol açabilir.

Örnek: Görüntü İşleme için Birleşik Bellek Erişimi

            #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));

    // Perform some image processing operation (e.g., grayscale conversion)
    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
              
            
          

Bu örnekte, her iş öğesi görüntüdeki tek bir pikseli işler. İş grubu boyutu 16x16 olduğundan, aynı iş grubundaki bitişik iş öğeleri aynı satırdaki bitişik pikselleri işleyecektir. Bu durum, inputImage'den okuma ve outputImage'e yazma sırasında birleşik bellek erişimini teşvik eder.

Ancak, görüntü verilerini devşirseydiniz veya piksellere satır-öncelikli sıra yerine sütun-öncelikli sırada erişseydiniz ne olacağını düşünün. Bitişik iş öğeleri bitişik olmayan bellek konumlarına erişeceği için muhtemelen önemli ölçüde düşük performans görürdünüz.

Paylaşımlı Yerel Bellek

Paylaşımlı yerel bellek, aynı zamanda yerel paylaşımlı bellek (LSM) olarak da bilinir, bir iş grubu içindeki tüm iş öğeleri tarafından paylaşılan küçük, hızlı bir bellek bölgesidir. Sık erişilen verileri önbelleğe alarak veya aynı iş grubu içindeki iş öğeleri arasındaki iletişimi kolaylaştırarak performansı artırmak için kullanılabilir. Paylaşımlı yerel bellek, GLSL'de shared anahtar kelimesi kullanılarak bildirilir.

Örnek: Veri Azaltma için Paylaşımlı Yerel Bellek Kullanımı

            #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(); // Wait for all work items to write to shared memory

    // Perform reduction within the workgroup
    for (uint i = gl_WorkGroupSize.x / 2; i > 0; i /= 2) {
        if (localId < i) {
            localSum[localId] += localSum[localId + i];
        }
        barrier(); // Wait for all work items to complete the reduction step
    }

    // Write the final sum to the output buffer
    if (localId == 0) {
        outputBuffer.outputData[gl_WorkGroupID.x] = localSum[0];
    }
}
            

              
                Copy