WebGL கம்ப்யூட் ஷேடர் பணிப் பங்கீடு: GPU த்ரெட் ஒதுக்கீட்டில் ஒரு ஆழமான பார்வை

WebGL இல் உள்ள கம்ப்யூட் ஷேடர்கள், வலை உலாவியில் நேரடியாக பொது நோக்கத்திற்கான கணினிப் பணிகளுக்காக (GPGPU) GPU-வின் இணைச் செயலாக்கத் திறன்களைப் பயன்படுத்த ஒரு சக்திவாய்ந்த வழியை வழங்குகின்றன. தனிப்பட்ட GPU த்ரெட்களுக்குப் பணி எவ்வாறு பகிரப்படுகிறது என்பதைப் புரிந்துகொள்வது, திறமையான மற்றும் உயர் செயல்திறன் கொண்ட கம்ப்யூட் கெர்னல்களை எழுதுவதற்கு மிக முக்கியம். இந்தக் கட்டுரை, WebGL கம்ப்யூட் ஷேடர்களில் பணிப் பங்கீடு, அதன் அடிப்படைக் கருத்துகள், த்ரெட் ஒதுக்கீட்டு உத்திகள் மற்றும் மேம்படுத்தல் நுட்பங்கள் பற்றிய விரிவான ஆய்வை வழங்குகிறது.

கம்ப்யூட் ஷேடர் செயலாக்க மாதிரியைப் புரிந்துகொள்ளுதல்

பணிப் பங்கீட்டைப் பற்றி ஆழமாகப் பார்ப்பதற்கு முன், WebGL இல் உள்ள கம்ப்யூட் ஷேடர் செயலாக்க மாதிரியைப் புரிந்துகொண்டு ஒரு அடித்தளத்தை உருவாக்குவோம். இந்த மாதிரி படிநிலை அமைப்பைக் கொண்டது, பல முக்கிய கூறுகளைக் கொண்டுள்ளது:

• கம்ப்யூட் ஷேடர்: GPU-வில் செயல்படுத்தப்படும் நிரல், இது இணைச் செயலாக்கத்திற்கான தர்க்கத்தைக் கொண்டுள்ளது.
• வொர்க்குழு (Workgroup): ஒன்றாகச் செயல்படுத்தப்படும் வொர்க் ஐட்டம்களின் தொகுப்பு. இவை பகிரப்பட்ட லோக்கல் நினைவகம் மூலம் தரவைப் பகிர்ந்து கொள்ளலாம். இதை, ஒரு பெரிய பணியின் ஒரு பகுதியைச் செய்யும் தொழிலாளர்களின் குழுவாகக் கருதலாம்.
• வொர்க் ஐட்டம் (Work Item): கம்ப்யூட் ஷேடரின் ஒரு தனிப்பட்ட நிகழ்வு, இது ஒரு GPU த்ரெட்டைக் குறிக்கிறது. ஒவ்வொரு வொர்க் ஐட்டமும் ஒரே ஷேடர் குறியீட்டைச் செயல்படுத்தும், ஆனால் வெவ்வேறு தரவுகளில் செயல்படக்கூடும். இது குழுவில் உள்ள ஒரு தனிப்பட்ட தொழிலாளி.
• குளோபல் இன்வொகேஷன் ஐடி (Global Invocation ID): முழு கம்ப்யூட் டிஸ்பாட்ச் முழுவதும் ஒவ்வொரு வொர்க் ஐட்டத்திற்கும் ஒரு தனித்துவமான அடையாளங்காட்டி.
• லோக்கல் இன்வொகேஷன் ஐடி (Local Invocation ID): ஒரு வொர்க்குழுவிற்குள் ஒவ்வொரு வொர்க் ஐட்டத்திற்கும் ஒரு தனித்துவமான அடையாளங்காட்டி.
• வொர்க்குழு ஐடி (Workgroup ID): கம்ப்யூட் டிஸ்பாட்ச்சில் உள்ள ஒவ்வொரு வொர்க்குழுவிற்கும் ஒரு தனித்துவமான அடையாளங்காட்டி.

நீங்கள் ஒரு கம்ப்யூட் ஷேடரை டிஸ்பாட்ச் செய்யும்போது, நீங்கள் வொர்க்குழு கட்டத்தின் (workgroup grid) பரிமாணங்களைக் குறிப்பிடுகிறீர்கள். இந்தக் கட்டம் எத்தனை வொர்க்குழுக்கள் உருவாக்கப்படும் மற்றும் ஒவ்வொரு வொர்க்குழுவிலும் எத்தனை வொர்க் ஐட்டம்கள் இருக்கும் என்பதை வரையறுக்கிறது. எடுத்துக்காட்டாக, ஒரு dispatchCompute(16, 8, 4) டிஸ்பாட்ச், 16x8x4 பரிமாணங்களைக் கொண்ட ஒரு 3D வொர்க்குழு கட்டத்தை உருவாக்கும். இந்த வொர்க்குழுக்களில் ஒவ்வொன்றும் முன்வரையறுக்கப்பட்ட எண்ணிக்கையிலான வொர்க் ஐட்டம்களால் நிரப்பப்படுகின்றன.

வொர்க்குழு அளவை உள்ளமைத்தல்

வொர்க்குழு அளவு கம்ப்யூட் ஷேடர் மூலக் குறியீட்டில் layout தகுதிச்சொல்லைப் பயன்படுத்தி வரையறுக்கப்படுகிறது:

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

              
                Copy
              
            
          

இந்த அறிவிப்பு ஒவ்வொரு வொர்க்குழுவிலும் 8 * 8 * 1 = 64 வொர்க் ஐட்டம்கள் இருக்கும் என்று குறிப்பிடுகிறது. local_size_x, local_size_y, மற்றும் local_size_z ஆகியவற்றிற்கான மதிப்புகள் நிலையான வெளிப்பாடுகளாக இருக்க வேண்டும் மற்றும் பொதுவாக 2-இன் அடுக்குகளாக இருக்கும். அதிகபட்ச வொர்க்குழு அளவு வன்பொருளைப் பொறுத்தது மற்றும் gl.getParameter(gl.MAX_COMPUTE_WORK_GROUP_INVOCATIONS) ஐப் பயன்படுத்தி வினவலாம். மேலும், ஒரு வொர்க்குழுவின் தனிப்பட்ட பரிமாணங்களுக்கும் வரம்புகள் உள்ளன, அவற்றை gl.getParameter(gl.MAX_COMPUTE_WORK_GROUP_SIZE) ஐப் பயன்படுத்தி வினவலாம். இது X, Y, மற்றும் Z பரிமாணங்களுக்கான அதிகபட்ச அளவைக் குறிக்கும் மூன்று எண்களின் வரிசையை வழங்கும்.

எடுத்துக்காட்டு: அதிகபட்ச வொர்க்குழு அளவைக் கண்டறிதல்

            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
              
            
          

செயல்திறனுக்கு பொருத்தமான வொர்க்குழு அளவைத் தேர்ந்தெடுப்பது மிகவும் முக்கியம். சிறிய வொர்க்குழுக்கள் GPU-வின் இணைச் செயலாக்கத்தை முழுமையாகப் பயன்படுத்தாமல் போகலாம், அதேசமயம் பெரிய வொர்க்குழுக்கள் வன்பொருள் வரம்புகளை மீறலாம் அல்லது திறனற்ற நினைவக அணுகல் முறைகளுக்கு வழிவகுக்கும். ஒரு குறிப்பிட்ட கம்ப்யூட் கெர்னல் மற்றும் இலக்கு வன்பொருளுக்கு உகந்த வொர்க்குழு அளவைக் கண்டறிய பெரும்பாலும் பரிசோதனை தேவைப்படுகிறது. இரண்டு-இன் அடுக்குகளான வொர்க்குழு அளவுகளுடன் (எ.கா., 4, 8, 16, 32, 64) பரிசோதனை செய்து, செயல்திறனில் அவற்றின் தாக்கத்தை பகுப்பாய்வு செய்வது ஒரு நல்ல தொடக்கப் புள்ளியாகும்.

GPU த்ரெட் ஒதுக்கீடு மற்றும் குளோபல் இன்வொகேஷன் ஐடி

ஒரு கம்ப்யூட் ஷேடர் டிஸ்பாட்ச் செய்யப்படும்போது, ஒவ்வொரு வொர்க் ஐட்டத்தையும் ஒரு குறிப்பிட்ட GPU த்ரெட்டிற்கு ஒதுக்குவதற்கு WebGL செயலாக்கம் பொறுப்பாகும். ஒவ்வொரு வொர்க் ஐட்டமும் அதன் குளோபல் இன்வொகேஷன் ஐடி மூலம் தனித்துவமாக அடையாளம் காணப்படுகிறது, இது முழு கம்ப்யூட் டிஸ்பாட்ச் கட்டத்திற்குள் அதன் நிலையைக் குறிக்கும் ஒரு 3D வெக்டார் ஆகும். இந்த ஐடியை கம்ப்யூட் ஷேடருக்குள் உள்ளமைக்கப்பட்ட GLSL மாறியான gl_GlobalInvocationID ஐப் பயன்படுத்தி அணுகலாம்.

gl_GlobalInvocationID என்பது gl_WorkGroupID மற்றும் gl_LocalInvocationID ஆகியவற்றிலிருந்து பின்வரும் சூத்திரத்தைப் பயன்படுத்தி கணக்கிடப்படுகிறது:

            gl_GlobalInvocationID = gl_WorkGroupID * gl_WorkGroupSize + gl_LocalInvocationID;
            

              
                Copy
              
            
          

இதில் gl_WorkGroupSize என்பது layout தகுதிச்சொல்லில் குறிப்பிடப்பட்ட வொர்க்குழு அளவு. இந்த சூத்திரம் வொர்க்குழு கட்டத்திற்கும் தனிப்பட்ட வொர்க் ஐட்டங்களுக்கும் இடையிலான உறவை எடுத்துக்காட்டுகிறது. ஒவ்வொரு வொர்க்குழுவிற்கும் ஒரு தனித்துவமான ஐடி (gl_WorkGroupID) ஒதுக்கப்படுகிறது, மேலும் அந்த வொர்க்குழுவிற்குள் உள்ள ஒவ்வொரு வொர்க் ஐட்டத்திற்கும் ஒரு தனித்துவமான லோக்கல் ஐடி (gl_LocalInvocationID) ஒதுக்கப்படுகிறது. குளோபல் ஐடி இந்த இரண்டு ஐடிகளையும் இணைப்பதன் மூலம் கணக்கிடப்படுகிறது.

எடுத்துக்காட்டு: குளோபல் இன்வொகேஷன் ஐடியை அணுகுதல்

            #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
              
            
          

இந்த எடுத்துக்காட்டில், ஒவ்வொரு வொர்க் ஐட்டமும் gl_GlobalInvocationID ஐப் பயன்படுத்தி outputData பஃப்பரில் அதன் குறியீட்டைக் கணக்கிடுகிறது. இது ஒரு பெரிய தரவுத்தொகுப்பில் பணியைப் பகிர்வதற்கான ஒரு பொதுவான முறையாகும். `uint index = gl_GlobalInvocationID.x + gl_GlobalInvocationID.y * gl_NumWorkGroups.x * gl_WorkGroupSize.x;` என்ற வரி முக்கியமானது. அதை விரிவாகப் பார்ப்போம்: * `gl_GlobalInvocationID.x` குளோபல் கட்டத்தில் வொர்க் ஐட்டத்தின் x-ஆயத்தொலைவை வழங்குகிறது. * `gl_GlobalInvocationID.y` குளோபல் கட்டத்தில் வொர்க் ஐட்டத்தின் y-ஆயத்தொலைவை வழங்குகிறது. * `gl_NumWorkGroups.x` x-பரிமாணத்தில் உள்ள மொத்த வொர்க்குழுக்களின் எண்ணிக்கையை வழங்குகிறது. * `gl_WorkGroupSize.x` ஒவ்வொரு வொர்க்குழுவின் x-பரிமாணத்தில் உள்ள வொர்க் ஐட்டம்களின் எண்ணிக்கையை வழங்குகிறது. இவை அனைத்தும் சேர்ந்து, ஒவ்வொரு வொர்க் ஐட்டமும் தட்டையான வெளியீட்டுத் தரவு வரிசையில் அதன் தனித்துவமான குறியீட்டைக் கணக்கிட அனுமதிக்கிறது. நீங்கள் ஒரு 3D தரவு அமைப்புடன் பணிபுரிந்தால், குறியீட்டுக் கணக்கீட்டில் `gl_GlobalInvocationID.z`, `gl_NumWorkGroups.y`, `gl_WorkGroupSize.y`, `gl_NumWorkGroups.z` மற்றும் `gl_WorkGroupSize.z` ஆகியவற்றையும் இணைக்க வேண்டும்.

நினைவக அணுகல் முறைகள் மற்றும் ஒருங்கிணைந்த நினைவக அணுகல்

வொர்க் ஐட்டம்கள் நினைவகத்தை அணுகும் விதம் செயல்திறனில் குறிப்பிடத்தக்க தாக்கத்தை ஏற்படுத்தும். ஒரு வொர்க்குழுவில் உள்ள வொர்க் ஐட்டம்கள் தொடர்ச்சியான நினைவக இடங்களை அணுகுவது சிறந்தது. இது ஒருங்கிணைந்த நினைவக அணுகல் (coalesced memory access) என அழைக்கப்படுகிறது, மேலும் இது GPU-விற்கு பெரிய துண்டுகளாகத் தரவை திறமையாகப் பெற அனுமதிக்கிறது. நினைவக அணுகல் சிதறியோ அல்லது தொடர்ச்சியற்றோ இருக்கும்போது, GPU பல சிறிய நினைவகப் பரிவர்த்தனைகளைச் செய்ய வேண்டியிருக்கும், இது செயல்திறன் தடைகளுக்கு வழிவகுக்கும்.

ஒருங்கிணைந்த நினைவக அணுகலை அடைய, நினைவகத்தில் தரவின் தளவமைப்பு மற்றும் வொர்க் ஐட்டம்கள் தரவு கூறுகளுக்கு ஒதுக்கப்படும் விதத்தை கவனமாகப் பரிசீலிப்பது முக்கியம். எடுத்துக்காட்டாக, ஒரு 2D படத்தைச் செயலாக்கும்போது, ஒரே வரிசையில் உள்ள அருகிலுள்ள பிக்சல்களுக்கு வொர்க் ஐட்டம்களை ஒதுக்குவது ஒருங்கிணைந்த நினைவக அணுகலுக்கு வழிவகுக்கும்.

எடுத்துக்காட்டு: பட செயலாக்கத்திற்கான ஒருங்கிணைந்த நினைவக அணுகல்

            #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
              
            
          

இந்த எடுத்துக்காட்டில், ஒவ்வொரு வொர்க் ஐட்டமும் படத்தில் உள்ள ஒரு பிக்சலைச் செயலாக்குகிறது. வொர்க்குழு அளவு 16x16 என்பதால், ஒரே வொர்க்குழுவில் உள்ள அருகிலுள்ள வொர்க் ஐட்டம்கள் ஒரே வரிசையில் உள்ள அருகிலுள்ள பிக்சல்களைச் செயலாக்கும். இது inputImage இலிருந்து படிக்கும்போதும், outputImage இல் எழுதும்போதும் ஒருங்கிணைந்த நினைவக அணுகலை ஊக்குவிக்கிறது.

இருப்பினும், நீங்கள் படத் தரவை இடமாற்றம் செய்தால் அல்லது வரிசை-முதன்மை வரிசைக்கு பதிலாக நெடுவரிசை-முதன்மை வரிசையில் பிக்சல்களை அணுகினால் என்ன நடக்கும் என்று கருதுங்கள். அருகிலுள்ள வொர்க் ஐட்டம்கள் தொடர்ச்சியற்ற நினைவக இடங்களை அணுகுவதால், செயல்திறன் கணிசமாகக் குறைந்திருப்பதைக் காண்பீர்கள்.

பகிரப்பட்ட லோக்கல் நினைவகம்

பகிரப்பட்ட லோக்கல் நினைவகம், லோக்கல் பகிரப்பட்ட நினைவகம் (LSM) என்றும் அழைக்கப்படுகிறது. இது ஒரு சிறிய, வேகமான நினைவகப் பகுதியாகும், இது ஒரு வொர்க்குழுவில் உள்ள அனைத்து வொர்க் ஐட்டம்களாலும் பகிரப்படுகிறது. அடிக்கடி அணுகப்படும் தரவை இடைமாற்றுவதன் மூலமோ அல்லது ஒரே வொர்க்குழுவில் உள்ள வொர்க் ஐட்டம்களுக்கு இடையேயான தொடர்பை எளிதாக்குவதன் மூலமோ செயல்திறனை மேம்படுத்த இதைப் பயன்படுத்தலாம். பகிரப்பட்ட லோக்கல் நினைவகம் GLSL-இல் shared என்ற முக்கிய சொல்லைப் பயன்படுத்தி அறிவிக்கப்படுகிறது.

எடுத்துக்காட்டு: தரவுக் குறைப்பிற்கு பகிரப்பட்ட லோக்கல் நினைவகத்தைப் பயன்படுத்துதல்

            #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