WebGL hisoblash sheyderida ishni taqsimlash: GPU oqimlarini tayinlashni chuqur o'rganish

WebGL'dagi hisoblash sheyderlari to'g'ridan-to'g'ri veb-brauzerda umumiy maqsadli hisoblashlar (GPGPU) vazifalari uchun GPU'ning parallel ishlov berish imkoniyatlaridan foydalanishning kuchli usulini taklif etadi. Ishning alohida GPU oqimlariga qanday taqsimlanishini tushunish samarali va yuqori unumdorlikka ega hisoblash yadrolarini yozish uchun juda muhimdir. Ushbu maqolada WebGL hisoblash sheyderlarida ish taqsimotini, jumladan, asosiy tushunchalar, oqimlarni tayinlash strategiyalari va optimallashtirish usullarini har tomonlama o'rganish taqdim etilgan.

Hisoblash sheyderini bajarish modelini tushunish

Ish taqsimotini o'rganishdan oldin, keling, WebGL'dagi hisoblash sheyderini bajarish modelini tushunib, poydevor yarataylik. Ushbu model ierarxik bo'lib, bir nechta asosiy komponentlardan iborat:

• Hisoblash sheyderi: GPU'da bajariladigan, parallel hisoblash mantig'ini o'z ichiga olgan dastur.
• Ishchi guruh: Birgalikda bajariladigan va umumiy lokal xotira orqali ma'lumotlar almasha oladigan ish elementlari to'plami. Buni umumiy vazifaning bir qismini bajarayotgan ishchilar jamoasi deb tasavvur qiling.
• Ish elementi: Yagona GPU oqimini ifodalovchi hisoblash sheyderining alohida nusxasi. Har bir ish elementi bir xil sheyder kodini bajaradi, lekin potentsial ravishda turli ma'lumotlar bilan ishlaydi. Bu jamoadagi yakka ishchidir.
• Global chaqiruv identifikatori (ID): Butun hisoblash dispetchi bo'ylab har bir ish elementi uchun noyob identifikator.
• Lokal chaqiruv identifikatori (ID): O'z ishchi guruhi ichidagi har bir ish elementi uchun noyob identifikator.
• Ishchi guruh identifikatori (ID): Hisoblash dispetchidagi har bir ishchi guruh uchun noyob identifikator.

Siz hisoblash sheyderini ishga tushirganingizda, siz ishchi guruhlar to'ri o'lchamlarini belgilaysiz. Ushbu to'r qancha ishchi guruh yaratilishini va har bir ishchi guruh qancha ish elementini o'z ichiga olishini belgilaydi. Masalan, dispatchCompute(16, 8, 4) dispetchi 16x8x4 o'lchamdagi 3D ishchi guruhlar to'rini yaratadi. Keyin bu ishchi guruhlarning har biri oldindan belgilangan miqdordagi ish elementlari bilan to'ldiriladi.

Ishchi guruh hajmini sozlash

Ishchi guruh hajmi hisoblash sheyderining manba kodida layout kvalifikatori yordamida aniqlanadi:

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

              
                Copy
              
            
          

Ushbu e'lon har bir ishchi guruh 8 * 8 * 1 = 64 ish elementini o'z ichiga olishini belgilaydi. local_size_x, local_size_y va local_size_z qiymatlari doimiy ifodalar bo'lishi kerak va odatda 2 ning darajalari bo'ladi. Maksimal ishchi guruh hajmi apparatga bog'liq va uni gl.getParameter(gl.MAX_COMPUTE_WORK_GROUP_INVOCATIONS) yordamida so'rash mumkin. Bundan tashqari, ishchi guruhning alohida o'lchamlari uchun ham cheklovlar mavjud bo'lib, ularni gl.getParameter(gl.MAX_COMPUTE_WORK_GROUP_SIZE) yordamida so'rash mumkin, bu X, Y va Z o'lchamlari uchun maksimal hajmni ifodalovchi uchta raqamdan iborat massivni qaytaradi.

Misol: Maksimal ishchi guruh hajmini topish

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

console.log("Maksimal ishchi guruh chaqiruvlari: ", maxWorkGroupInvocations);
console.log("Maksimal ishchi guruh hajmi: ", maxWorkGroupSize); // Chiqish: [1024, 1024, 64]

            

              
                Copy
              
            
          

Tegishli ishchi guruh hajmini tanlash unumdorlik uchun juda muhimdir. Kichikroq ishchi guruhlar GPU parallelizmidan to'liq foydalana olmasligi mumkin, kattaroq ishchi guruhlar esa apparat cheklovlaridan oshib ketishi yoki samarasiz xotiraga kirish naqshlariga olib kelishi mumkin. Ko'pincha, ma'lum bir hisoblash yadrosi va maqsadli apparat uchun optimal ishchi guruh hajmini aniqlash uchun tajriba talab etiladi. Yaxshi boshlanish nuqtasi - ikkining darajalari bo'lgan ishchi guruh o'lchamlari bilan tajriba o'tkazish (masalan, 4, 8, 16, 32, 64) va ularning unumdorlikka ta'sirini tahlil qilishdir.

GPU oqimlarini tayinlash va global chaqiruv identifikatori

Hisoblash sheyderi ishga tushirilganda, WebGL implementatsiyasi har bir ish elementini ma'lum bir GPU oqimiga tayinlash uchun mas'uldir. Har bir ish elementi o'zining Global chaqiruv identifikatori bilan noyob tarzda aniqlanadi, bu uning butun hisoblash dispetchi to'ridagi pozitsiyasini ifodalovchi 3D vektor. Ushbu IDga hisoblash sheyderi ichida o'rnatilgan GLSL o'zgaruvchisi gl_GlobalInvocationID yordamida kirish mumkin.

gl_GlobalInvocationID gl_WorkGroupID va gl_LocalInvocationID dan quyidagi formula yordamida hisoblanadi:

            gl_GlobalInvocationID = gl_WorkGroupID * gl_WorkGroupSize + gl_LocalInvocationID;
            

              
                Copy
              
            
          

Bu yerda gl_WorkGroupSize - layout kvalifikatorida belgilangan ishchi guruh hajmi. Bu formula ishchi guruh to'ri va alohida ish elementlari o'rtasidagi munosabatni ko'rsatadi. Har bir ishchi guruhga noyob ID (gl_WorkGroupID) tayinlanadi va shu ishchi guruh ichidagi har bir ish elementiga noyob lokal ID (gl_LocalInvocationID) tayinlanadi. Keyin global ID ushbu ikki IDni birlashtirish orqali hisoblanadi.

Misol: Global chaqiruv identifikatoriga kirish

            #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
              
            
          

Ushbu misolda har bir ish elementi gl_GlobalInvocationID yordamida outputData buferidagi o'z indeksini hisoblaydi. Bu katta hajmdagi ma'lumotlar to'plami bo'ylab ishni taqsimlashning keng tarqalgan usulidir. `uint index = gl_GlobalInvocationID.x + gl_GlobalInvocationID.y * gl_NumWorkGroups.x * gl_WorkGroupSize.x;` qatori juda muhim. Keling, buni tahlil qilaylik: * gl_GlobalInvocationID.x global to'rdagi ish elementining x-koordinatasini beradi. * gl_GlobalInvocationID.y global to'rdagi ish elementining y-koordinatasini beradi. * gl_NumWorkGroups.x x-o'lchamidagi ishchi guruhlarning umumiy sonini beradi. * gl_WorkGroupSize.x har bir ishchi guruhning x-o'lchamidagi ish elementlari sonini beradi. Birgalikda bu qiymatlar har bir ish elementiga yassilangan chiqish ma'lumotlari massivi ichida o'zining noyob indeksini hisoblash imkonini beradi. Agar siz 3D ma'lumotlar strukturasi bilan ishlayotgan bo'lsangiz, siz indeksni hisoblashga `gl_GlobalInvocationID.z`, `gl_NumWorkGroups.y`, `gl_WorkGroupSize.y`, `gl_NumWorkGroups.z` va `gl_WorkGroupSize.z` ni ham kiritishingiz kerak bo'ladi.

Xotiraga kirish naqshlari va birlashtirilgan xotiraga kirish

Ish elementlarining xotiraga kirish usuli unumdorlikka sezilarli ta'sir qilishi mumkin. Ideal holda, ishchi guruh ichidagi ish elementlari ketma-ket joylashgan xotira manzillariga kirishi kerak. Bu birlashtirilgan xotiraga kirish deb nomlanadi va GPU'ga ma'lumotlarni katta qismlarda samarali yuklab olish imkonini beradi. Xotiraga kirish tarqoq yoki ketma-ket bo'lmaganda, GPU bir nechta kichikroq xotira operatsiyalarini bajarishiga to'g'ri kelishi mumkin, bu esa unumdorlikda muammolarga olib kelishi mumkin.

Birlashtirilgan xotiraga kirishga erishish uchun xotiradagi ma'lumotlarning joylashishini va ish elementlarining ma'lumotlar elementlariga qanday tayinlanishini diqqat bilan ko'rib chiqish muhim. Masalan, 2D tasvirni qayta ishlashda ish elementlarini bir xil qatordagi qo'shni piksellarga tayinlash birlashtirilgan xotiraga kirishga olib kelishi mumkin.

Misol: Tasvirni qayta ishlash uchun birlashtirilgan xotiraga kirish

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

    // Biror tasvirni qayta ishlash amalini bajaring (masalan, kulrang rangga o'tkazish)
    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
              
            
          

Ushbu misolda har bir ish elementi tasvirdagi bitta pikselni qayta ishlaydi. Ishchi guruh hajmi 16x16 bo'lganligi sababli, bir xil ishchi guruhdagi qo'shni ish elementlari bir xil qatordagi qo'shni piksellarni qayta ishlaydi. Bu inputImage dan o'qish va outputImage ga yozish paytida birlashtirilgan xotiraga kirishni ta'minlaydi.

Biroq, agar siz tasvir ma'lumotlarini transpozitsiya qilsangiz yoki piksellarga qator bo'yicha emas, balki ustun bo'yicha kirsangiz nima bo'lishini o'ylab ko'ring. Siz qo'shni ish elementlari ketma-ket bo'lmagan xotira manzillariga kirishi sababli, unumdorlik sezilarli darajada pasayishini ko'rishingiz mumkin.

Umumiy lokal xotira

Umumiy lokal xotira, shuningdek, lokal umumiy xotira (LSM) sifatida ham tanilgan, ishchi guruh ichidagi barcha ish elementlari tomonidan birgalikda foydalaniladigan kichik, tezkor xotira sohasidir. Uni tez-tez murojaat qilinadigan ma'lumotlarni keshda saqlash yoki bir xil ishchi guruh ichidagi ish elementlari o'rtasidagi aloqani osonlashtirish orqali unumdorlikni oshirish uchun ishlatish mumkin. Umumiy lokal xotira GLSL'da shared kalit so'zi yordamida e'lon qilinadi.

Misol: Ma'lumotlarni qisqartirish uchun umumiy lokal xotiradan foydalanish

            #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(); // Barcha ish elementlari umumiy xotiraga yozishini kuting

    // Ishchi guruh ichida qisqartirishni bajaring
    for (uint i = gl_WorkGroupSize.x / 2; i > 0; i /= 2) {
        if (localId < i) {
            localSum[localId] += localSum[localId + i];
        }
        barrier(); // Barcha ish elementlari qisqartirish bosqichini yakunlashini kuting
    }

    // Yakuniy yig'indini chiqish buferiga yozing
    if (localId == 0) {
        outputBuffer.outputData[gl_WorkGroupID.x] = localSum[0];
    }
}
            

              
                Copy