Appunti CUDA:

20-Series Architecture

La Cache L2 e' piu piccola rispetto alla somma delle L1 dei singoli core

ogni thread ha fino a 256 registri.

Ogni blocco di thread e' suddiviso in pacchi da 32 Thread, questi 32 thread vengono eseguiti in sincrono.

Quando viene eseguito codice, alla suddivisione di branch vengono fermati i thread che devono saltare dopo l'else finche quelli dentro la if finiscono.

GUIDA AL LANCIO DI KERNEL:

Bisogna fare partire sufficienti thread in modo che venga nascosta la latenza.

Su Serie-200 almeno 20 warp (576) circa thread.

Come funzionano accessi a memoria:

Bisogna essere consapevoli del fatto di come allochiamo la memoria (posizionamento)
in modo da utilizzare al meglio la cache.

Avere algoritmo che accede alla memoria in maniera lineare (e' meglio anche se piu' complesso)
cioe' avere accessi coerenti, cioe non avere accessi sparsi in giro per la memoria.

Esempio con matrice 32x32:

Matrice caricata su 32 blocchi ogni colonna viene caricata su un blocco. Se tutti i thread accedono a stessa colonna siamo in merda
perche' si congestiona la via di accesso per quel determinato blocco

Se allcochiamo 32x33 rompiamo il pattern e gli elementi vengono caricati in modo piu, casuale
in modo da rendere le vie di accessi meno congestionate.

#####################################################

Perche paralizzazione e' cosi difficile?

E, difficile perche bisogna bilanciare i seguenti aspetti:
Parallismo massivo
Efficienza Lavoro
Preservazione della localita
Bilanciamento del carico

Qualsiasi algoritmo seriale e' piu corto rispetto allo stesso parallelizato

ESEMPI:

Depth first:

Visione dellalbero fino alla prima foglia poi si va in backtracking per vedere le altre foglie.

Questo ha buona localita ma scarsa paralizzazione

Breath first:
Visita prima un livello alla volta fino ad arrivare al livello delle foglie.

Questo ha buona localita e paralizzazione decente.

Localita VS Load-Balancing

meglio con ray tracing.

k-d Tree Construction

####################################33

Esercizio:

Ogni thread ha una  particella di cui si calcola la forza che applica sulle altre particelle