__shared__-arrays declareren
Snelle scratchpadgeheugen per block.
__shared__-arrays declareren is een gratis CUDA Academy-les op CoddyKit. Dit is les 1 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject CUDA Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus CUDA Academy bevat in totaal 4 lessen.
Een kladblok per blok
Elk blok krijgt een kleine, snelle pool on-chipgeheugen die gedeeld geheugen wordt genoemd. Zie het als een kladblok waarin het hele blok samen kan schrijven en lezen.
Waarom het zo snel is
Gedeeld geheugen bevindt zich direct op de streaming multiprocessor en is daardoor ongeveer 100x sneller dan globaal geheugen. Gebruik het om traag off-chip DRAM-geheugen niet voortdurend te belasten. 🚀
Het sleutelwoord __shared__
U declareert het met de kwalificatie __shared__ binnen een kernel. Deze ene array wordt vervolgens gedeeld door elke thread in het blok.
__global__ void kern() {
__shared__ float tile[256];
}Vaste grootte tijdens het compileren
Wanneer u een grootte tussen blokhaken opgeeft, is dat statisch gedeeld geheugen. De compiler moet de grootte kennen, dus deze moet een constante zijn en mag geen runtimewaarde zijn.
__shared__ int counts[128];Eén kopie, niet één per thread
Dit is het belangrijkste idee: een __shared__-array wordt één keer per blok aangemaakt, niet één keer per thread. Alle threads zien exact dezelfde array.
Threads werken ermee samen
Omdat elke thread dezelfde gegevens ziet, kunnen threads met gedeeld geheugen samenwerken. De ene thread kan een waarde opslaan en een naburige thread kan die ophalen.
Blokbereik, niet daarbuiten
De levensduur ervan komt overeen met die van het blok. De array ontstaat wanneer het blok start en verdwijnt wanneer het eindigt, dus hij heeft alleen blokbereik. 🧱
Elke thread bezit één plek
Een veelgebruikt patroon is één plek per thread, geïndexeerd met threadIdx.x. Elke thread laadt zijn element parallel in het gedeelde geheugen.
__shared__ float s[256];
s[threadIdx.x] = input[i];Een kleine maar kostbare hulpbron
Gedeeld geheugen is klein, vaak slechts 48 tot 100 KB per SM. Als u per blok te veel vraagt, kunnen er minder blokken tegelijk worden uitgevoerd.
Het klassieke gebruik: tegels klaarzetten
De meest voorkomende taak is een tegel met globale gegevens klaarzetten, zodat het blok die vele keren opnieuw kan gebruiken zonder terug te gaan naar traag DRAM-geheugen.
Niet zichtbaar voor andere blokken
Onthoud de grens: gedeeld geheugen is privé voor het eigen blok. Twee verschillende blokken krijgen elk hun eigen afzonderlijke kopie en kunnen niet bij elkaar kijken.
Snelle controle
Laten we controleren hoe het bereik van gedeeld geheugen werkt.
Samenvatting
U hebt geleerd dat __shared__ elk blok een snel on-chipkladblok geeft, dat één keer per blok wordt aangemaakt en ideaal is voor het klaarzetten van herbruikbare gegevens. Hierna: threads synchroon laten lopen. 🎯
Leer C++ met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 30
- Lessen
- 120
Veelgestelde vragen
Is de les “__shared__-arrays declareren” gratis?
Ja — de volledige tekst van “__shared__-arrays declareren” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus CUDA Academy wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus CUDA Academy bevat in totaal 4 lessen.
Wat leer ik in “__shared__-arrays declareren”?
Snelle scratchpadgeheugen per block. Je oefent met CUDA Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met CUDA Academy te beginnen?
Ervaring vooraf is niet nodig. CUDA Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 1 van 4.
Hoe lang duurt de les “__shared__-arrays declareren”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over CUDA Academy?
Ja. Elke les over CUDA Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.
Alle lessen in deze cursus
- __shared__-arrays declareren
- Synchroniseren met __syncthreads
- Bankconflicten voorkomen
- Dynamisch shared memory