लोड-सिंक-कम्प्यूट पैटर्न

हर kernel में tiling की एक ही लय होती है: tile को shared memory में load करें, sync करें, फिर तेज़ copy से compute करें।

load चरण में हर thread global memory से एक element पढ़कर उसे shared-memory tile में रखता है, जिसे उसका पूरा block देख सकता है।

Loading एक team job है। हर thread अपना हिस्सा लाता है, इसलिए पूरा block मिलकर एक full tile को एक ही coalesced pass में तैयार करता है।

किसी neighbor का मान पढ़ने से पहले सभी threads को loading पूरी करनी होगी। __syncthreads वह barrier है जो सुनिश्चित करता है कि tile तैयार है।

Barrier छोड़ देने पर कोई thread tile के ऐसे slot को पढ़ सकता है जिसे उसके neighbor ने अभी लिखा ही न हो। यह race है और गलत results देता है। 💥

अब हर मान chip पर मौजूद है। compute चरण में threads tile entries को स्वतंत्र रूप से पढ़ते हैं, क्योंकि shared memory global memory से कई गुना तेज़ है।

Tile shared memory में रहता है, इसलिए एक बार load किया गया मान कई threads द्वारा लगभग no extra cost पर फिर से उपयोग किया जाता है। पूरा लाभ यही है।

यदि compute चरण अगले step के लिए उसी tile में वापस लिखता है, तो उन slots का पुनः उपयोग करने से पहले एक second __syncthreads जोड़ें।

Block के हर thread को __syncthreads तक पहुँचना आवश्यक है। यदि कुछ threads किसी branch के भीतर इसे छोड़ देते हैं, तो kernel deadlock हो सकता है या गलत ढंग से काम कर सकता है।

Load, sync, compute एक template है, जिसका उपयोग आप इस category में convolutions, matrix multiply और reductions के लिए बार-बार करेंगे।

Shared tile को block में समा जाना चाहिए। Tile width आमतौर पर blockDim के बराबर होती है, इसलिए हर thread के पास load और reuse करने के लिए ठीक एक slot होता है।

Tiling का क्रम load, sync, compute है: tile को मिलकर तैयार करें, उसके पूरा होने के लिए barrier लगाएँ, फिर chip पर उसका तेज़ी से पुनः उपयोग करें। ✅