1 | \section{Introduction} |
---|
2 | |
---|
3 | \frame |
---|
4 | { |
---|
5 | \frametitle{Introduction} |
---|
6 | |
---|
7 | Chip MultiProcessors (CMP) et le Simultaneous Multi-Threading (SMT) sont 2 approches opposée qui résolves le même problème : éxècuter sur un même chip plusieurs threads. |
---|
8 | |
---|
9 | \begin{description} |
---|
10 | \item[CMP :] Chaque thread dispose de l'ensemble des ressources d'un core\\(Hydra, Piranha, Opteron) |
---|
11 | \item[SMT :] Chaque thread partage les ressources d'un core avec toutes les autres\\(MARS-M, 21464, Pentium4 HyperThreading) |
---|
12 | \item[CMP de SMT : ] il s'agit de plusieurs core de processeurs où chaque core est multi-threadé\\(Niagara, Power5, Montecito) |
---|
13 | \end{description} |
---|
14 | } |
---|
15 | |
---|
16 | \frame |
---|
17 | { |
---|
18 | \frametitle{Approche grain fin} |
---|
19 | |
---|
20 | Entre le tout partagé et le tout dédié, nous pouvons faire varier dégré de partage de certaines ressources. |
---|
21 | |
---|
22 | Ces objectif sont : |
---|
23 | \begin{itemize} |
---|
24 | \item Economiser de la surface%(Pour une même structure on compare sa duplication avec le contrôle nécessaire pour permettre son partage) |
---|
25 | \item Augmenter leur taux d'utilisation en profitant du Thread Level Parallelism |
---|
26 | \item Avoir le maximum de ressource disponible en éxècution ST (Single Thread), tout en minimisant la dégradation des performances en éxècution MT (Multi Thread) |
---|
27 | \end{itemize} |
---|
28 | } |
---|
29 | |
---|
30 | \frame |
---|
31 | { |
---|
32 | \frametitle{Travaux liés} |
---|
33 | |
---|
34 | \begin{description} |
---|
35 | \item[CASH : Revisiting hardware sharing in single-chip parallel processor]~\\2004 - Dolbeau et Seznec\\Partage entre les threads des unités à latence longue (multiplication, division ...), Prédicteur de branchement, Icache et Dcache. |
---|
36 | \item[Conjoined-core Chip Multiprocessing]~\\2004 - Kumar, Jouppi et Tullsen\\Partage des unités flottantes, ports du crossbar (Cache à la mémoire), Icache et Dcache. |
---|
37 | \end{description} |
---|
38 | } |
---|
39 | |
---|
40 | \section{Expérimentation} |
---|
41 | \frame |
---|
42 | { |
---|
43 | \frametitle{Expérimentation} |
---|
44 | Nous allons déterminer l'incidence du partage des ressources suivantes : |
---|
45 | |
---|
46 | \begin{itemize} |
---|
47 | \item I/Dcache |
---|
48 | \item Front et Back end |
---|
49 | \item Unités d'executions |
---|
50 | \end{itemize} |
---|
51 | } |
---|
52 | |
---|
53 | \subsection{Charge de travails} |
---|
54 | \frame |
---|
55 | { |
---|
56 | \frametitle{Charge de travails} |
---|
57 | |
---|
58 | \begin{itemize} |
---|
59 | \item Sélection des benchmarks parmit les SPECINT2000 (164.gzip, 175.vpr, 181.mcf, 255.vortex, 256.bzip2, 300.twolf) |
---|
60 | \item Le nombre de software soumit au architecture est décrite par la combinaison $C_{\text{nb\_benchmarks}}^{\text{nb\_threads}}$ |
---|
61 | Une charge de travail est donc composée de 4 benchmarks qui vont être éxecuter par l'un des 4 contextes disponibles. |
---|
62 | \item Utilisation de {\it Newlib} pour d'avoir les librairies standard (libc, libm et fonction de bas niveau (read, write, open, close ...)) |
---|
63 | \end{itemize} |
---|
64 | } |
---|
65 | |
---|
66 | \subsection{Architecture de référence} |
---|
67 | \frame |
---|
68 | { |
---|
69 | \frametitle{Architecture de référence - Core} |
---|
70 | |
---|
71 | \begin{tabular}{l|c} |
---|
72 | & Commun \\ |
---|
73 | \hline |
---|
74 | \hline |
---|
75 | nb\_ue & 8 \\ |
---|
76 | \hline |
---|
77 | taille - select\_queue & 4 \\ |
---|
78 | taille - reservation\_station & 4 \\ |
---|
79 | taille - execute\_queue & 4 \\ |
---|
80 | \hline |
---|
81 | Nombre de branchements spéculé & 8 \\ |
---|
82 | Return Address Stack & 16 \\ |
---|
83 | \hline |
---|
84 | Réseau de bypass & Complet \\ |
---|
85 | \hline |
---|
86 | nb\_data\_access & 4* \\ |
---|
87 | \hline |
---|
88 | nb\_gpr\_reader & 12 \\ |
---|
89 | nb\_gpr\_writer & 8 \\ |
---|
90 | nb\_memory\_write & 3 \\ |
---|
91 | nb\_execute\_write & 6 \\ |
---|
92 | nb\_spr\_reader & 2 \\ |
---|
93 | nb\_spr\_writer & 2 \\ |
---|
94 | \end{tabular} |
---|
95 | } |
---|
96 | |
---|
97 | \frame |
---|
98 | { |
---|
99 | \begin{tabular}{l|ccc} |
---|
100 | & 1 Core & 2 Cores & 4 Cores \\ |
---|
101 | \hline |
---|
102 | \hline |
---|
103 | largeur & 8 & 4 & 2 \\ |
---|
104 | largeur des fenêtres & 16 & 8 & 4 \\ |
---|
105 | \hline |
---|
106 | taille - ifetch\_queue & 8 & 4 & 2 \\ |
---|
107 | taille - decod\_queue & 16 & 8 & 4 \\ |
---|
108 | taille - rename\_queue & 32 & 16 & 8 \\ |
---|
109 | taille - Re Order Buffer & 128 & 64 & 32 \\ |
---|
110 | \hline |
---|
111 | Branch Target Buffer & 256 & 128 & 64 \\ |
---|
112 | nb compteur 2bits (predicteur meta) & 128 & 64 & 32 \\ |
---|
113 | nb compteur 2bits (predicteur global) & 1K & 512 & 256 \\ |
---|
114 | nb compteur 2bits (predicteur local) & 16k & 8k & 4k \\ |
---|
115 | \hline |
---|
116 | nb\_branch\_complete & 4 & 2 & 1 \\ |
---|
117 | nb\_memory\_complete & 4 & 2 & 1 \\ |
---|
118 | \hline |
---|
119 | nb\_gpr\_phy & 128+128 & 64+64 & 32+32 \\ |
---|
120 | nb\_gpr\_free & 8 & 4 & 2 \\ |
---|
121 | nb\_spr\_phy & 64 & 32 & 64 \\ |
---|
122 | nb\_spr\_free & 8 & 4 & 2 \\ |
---|
123 | \end{tabular} |
---|
124 | } |
---|
125 | |
---|
126 | \frame |
---|
127 | { |
---|
128 | \frametitle{Architecture de référence - Système mémoire} |
---|
129 | |
---|
130 | \begin{tabular}{l|ll} |
---|
131 | & L1 & L2 \\ |
---|
132 | & I/D séparé & unifié \\ |
---|
133 | \hline |
---|
134 | Taille & 8 ko & 2 Mo \\ |
---|
135 | Nombre de lignes & 128* & 16k \\ |
---|
136 | Nombre de mots/ligne & 16 & 32 \\ |
---|
137 | Associatif & 4 voies & 4 voies \\ |
---|
138 | Latence - Hit & 2 cycles & 6 cycles \\ |
---|
139 | Pénalités - Miss & 4 cycles & 100 cycles \\ |
---|
140 | \end{tabular} |
---|
141 | |
---|
142 | \vspace{\stretch{1}} |
---|
143 | |
---|
144 | Les caches IL1 et DL1 sont dupliqués NB\_CLUSTER fois, de plus chacun ont leur nombre de lignes divisé par NB\_CLUSTER. De même pour les ports du Dcache (nb\_data\_access). |
---|
145 | } |
---|
146 | |
---|
147 | \frame |
---|
148 | { |
---|
149 | \frametitle{Méthodologie} |
---|
150 | |
---|
151 | Pour chaque instance |
---|
152 | \begin{itemize} |
---|
153 | \item On réalise autant de simulations qu'il y a de charge de travail (soit 15). |
---|
154 | \item Une execution se fait en 11 millions de cycles dans lequel 1 millions ne sera pas prit en compte |
---|
155 | \item Nous prenons le temps moyen sur ces 15 simulations et on le compare à la moyenne de ces 6 benchmarks exécuter dans la version ST du processeur |
---|
156 | \item La comparaison donne le speedup de la version MT par rapport à la version ST |
---|
157 | \end{itemize} |
---|
158 | } |
---|
159 | |
---|
160 | \section{Résultat} |
---|
161 | |
---|
162 | \frame |
---|
163 | { |
---|
164 | \frametitle{Résultat} |
---|
165 | |
---|
166 | \begin{center} |
---|
167 | \printgraph{simulation_all}{0.8} |
---|
168 | \end{center} |
---|
169 | |
---|
170 | } |
---|
171 | |
---|
172 | \frame |
---|
173 | { |
---|
174 | \begin{minipage}{0.45\textwidth} |
---|
175 | \begin{center} |
---|
176 | \printgraph{simulation_cachel1}{0.8} |
---|
177 | \end{center} |
---|
178 | \end{minipage} |
---|
179 | \begin{minipage}{0.45\textwidth} |
---|
180 | Partage du cache induit : |
---|
181 | \begin{itemize} |
---|
182 | \item un conflit d'accès au port |
---|
183 | \item un pourrissement des données par les autre contextes |
---|
184 | \item |
---|
185 | \end{itemize} |
---|
186 | \end{minipage} |
---|
187 | } |
---|
188 | |
---|
189 | \frame |
---|
190 | { |
---|
191 | \begin{minipage}{0.45\textwidth} |
---|
192 | \begin{center} |
---|
193 | \printgraph{simulation_operative}{0.8} |
---|
194 | \end{center} |
---|
195 | \end{minipage} |
---|
196 | \begin{minipage}{0.45\textwidth} |
---|
197 | Partage de la partie opérative induit |
---|
198 | \begin{itemize} |
---|
199 | \item Une augmentation de l'influence des instructions mal prédite |
---|
200 | \item Une augmentation de la sensiblité au évenement peu courant (synchronisation, ...) |
---|
201 | \end{itemize} |
---|
202 | \end{minipage} |
---|
203 | } |
---|
204 | |
---|
205 | \frame |
---|
206 | { |
---|
207 | \begin{minipage}{0.45\textwidth} |
---|
208 | \begin{center} |
---|
209 | \printgraph{simulation_ue}{0.8} |
---|
210 | \end{center} |
---|
211 | \end{minipage} |
---|
212 | \begin{minipage}{0.45\textwidth} |
---|
213 | Partage des unités d'exécutions |
---|
214 | \begin{itemize} |
---|
215 | \item Augmente leur taux d'utilisations |
---|
216 | \item Augmente la sensiblité dut au erreur de routage (envoye vers une unité surchargé alors que d'autre sont en famine d'instructions) |
---|
217 | \end{itemize} |
---|
218 | \end{minipage} |
---|
219 | } |
---|
220 | |
---|
221 | \section{Réalisation VHDL} |
---|
222 | |
---|
223 | \frame |
---|
224 | { |
---|
225 | \frametitle{Réalisation VHDL} |
---|
226 | |
---|
227 | Les modèles vont être générés par des méthodes du modeles SystemC afin d'obtenir du VHDL classique |
---|
228 | } |
---|
229 | |
---|
230 | \subsection{Regroupement d'instruction} |
---|
231 | \frame |
---|
232 | { |
---|
233 | \frametitle{Regroupement d'instruction} |
---|
234 | |
---|
235 | Les processeurs à contrôle dynamique (superscalaire classique) ou à contrôle statique (VLIW) résolvent différemment le problème du lancement multiple d'instructions. |
---|
236 | |
---|
237 | L'avantage principal du VLIW étant sa simplicité de ses unités de contrôles : les instructions sont dans des slots précaractérisés. |
---|
238 | } |
---|
239 | |
---|
240 | \frame |
---|
241 | { |
---|
242 | \frametitle{Nouvel étage : {\it Group}} |
---|
243 | |
---|
244 | \begin{itemize} |
---|
245 | \item Entrée : A paquets contenant N éléments |
---|
246 | \item Sortie : B paquets contenant M éléments |
---|
247 | \item 1 élément soit un paquet d'éléments soit une instruction |
---|
248 | \item Algorithme de paquétisation libre |
---|
249 | \item Simplification : M est un multiple de N paquets |
---|
250 | \end{itemize} |
---|
251 | } |
---|
252 | |
---|
253 | \frame |
---|
254 | { |
---|
255 | \frametitle{Etage {\it Group1}} |
---|
256 | |
---|
257 | Situé après l'étage de décodage |
---|
258 | |
---|
259 | \begin{itemize} |
---|
260 | \item Les paquets sont formée d'instructions consécutive (car non encore inséré dans le ReOrder Buffer) |
---|
261 | \item Un paquet contient des instructions indépendants |
---|
262 | \item Les paquets suivent des règles de Types (Suivant les routages possibles et des types des unités d'éxecutions) |
---|
263 | \end{itemize} |
---|
264 | } |
---|
265 | |
---|
266 | \frame |
---|
267 | { |
---|
268 | \begin{itemize} |
---|
269 | \item + Simplification de la logique de gestion des dépendances RAW et WAW proche (comparaison sur les numéros de registres logiques) |
---|
270 | \item + Une potentiel simplification du RAT si l'algorithme prends en compte de définir un seuil maximum du nombre de lecture/écriture |
---|
271 | \item + ReOrder Buffer simplifié, les requêtes d'insertion et de retirement sont sur des paquets |
---|
272 | \item - Insertion de Nop |
---|
273 | \item - Paquetisation dans l'ordre du programme (Peu ou pas de liberté dans l'algo de paquétisations) |
---|
274 | \end{itemize} |
---|
275 | } |
---|
276 | |
---|
277 | \frame |
---|
278 | { |
---|
279 | \frametitle{Etage {\it Group2}} |
---|
280 | |
---|
281 | Situé après l'insertion dans le ReOrder Buffer |
---|
282 | |
---|
283 | \begin{itemize} |
---|
284 | \item + L'algorhtme de paquétisations à de plus grand degré de liberté (Car peut prendre les paquets dans le désordre) |
---|
285 | \item + Diminution du contrôle pour les étages de sélection |
---|
286 | \item - Encore plus de Nop inséré |
---|
287 | \item - Performance de la paquetisation lié au nombre d'instruction en attente dans la rename\_queue et à la fenêtre d'instruction |
---|
288 | \end{itemize} |
---|
289 | } |
---|
290 | |
---|
291 | \frame |
---|
292 | { |
---|
293 | \printgraph{MORPHEO_paquetisation}{0.5} |
---|
294 | } |
---|
295 | |
---|
296 | \frame |
---|
297 | { |
---|
298 | \frametitle{Incidence} |
---|
299 | |
---|
300 | \begin{enumerate} |
---|
301 | \item L'accès au banc de registres en lecture se fait sur un paquet entier? Si une des instructions n'a pas ses opérandes? |
---|
302 | \item L'écriture dans le banc de registres se fait sur un paquet entier? |
---|
303 | \item Plusieurs niveaux de dispatch, clusterisation implicite des unités fonctionnelles |
---|
304 | \item Attendre la fin d'un paquet de niveau 2, alors que l'étage Commit n'a besoin que de paquet de niveau 1? |
---|
305 | \end{enumerate} |
---|
306 | } |
---|
307 | |
---|
308 | |
---|
309 | \subsection{Partage des ensembles associatifs} |
---|
310 | \frame |
---|
311 | { |
---|
312 | \frametitle{Partage des ensembles associatifs} |
---|
313 | |
---|
314 | Soit une structure associative par ensemble (par exemple le cache ou la Branch Target Buffer) |
---|
315 | |
---|
316 | Posons : |
---|
317 | \begin{itemize} |
---|
318 | \item E le nombre d'entité accédant à cette structure |
---|
319 | \item P le nombre de port nécessaire pour chaque entité (on posera P identique pour chaque E) |
---|
320 | \item N le degré d'associativité de la structure |
---|
321 | \end{itemize} |
---|
322 | } |
---|
323 | |
---|
324 | \frame |
---|
325 | { |
---|
326 | \frametitle{Structure complémentement partagée} |
---|
327 | |
---|
328 | La structure est ici entièrement partagé entre toutes les entités. |
---|
329 | |
---|
330 | \printgraph{MORPHEO_structure_associative_full_share}{0.8} |
---|
331 | |
---|
332 | \begin{center} |
---|
333 | $P_{total1} = E*N*P$ |
---|
334 | \end{center} |
---|
335 | } |
---|
336 | |
---|
337 | \frame |
---|
338 | { |
---|
339 | \frametitle{Structure partiellement partagée} |
---|
340 | |
---|
341 | Nous allons maintenant décomposer la structure en deux parties : |
---|
342 | \begin{enumerate} |
---|
343 | \item une première qui est accessible par toutes les entités et sera associative de degré M |
---|
344 | \item la seconde est accessible par X sous-ensemble d'entité. Chaque groupe sont disjoint 2 à 2 et contient E' élément (donc $X=\frac{E}{E'}$). Dans chaque groupe il y a une structure associative de degré K |
---|
345 | \item Pour simplifier : $N=M+X*K$ avec E' et K et constant pour chaque groupe |
---|
346 | \end{enumerate} |
---|
347 | } |
---|
348 | |
---|
349 | \frame |
---|
350 | { |
---|
351 | \printgraph{MORPHEO_structure_associative_semi_share}{0.8} |
---|
352 | \begin{center} |
---|
353 | $P_{total2} = E*(M+K)*P$ |
---|
354 | \end{center} |
---|
355 | } |
---|
356 | |
---|
357 | \frame |
---|
358 | { |
---|
359 | \frametitle{Gain} |
---|
360 | \begin{center} |
---|
361 | $P_{total1} - P_{total2} = E*(\frac{E}{E'}-1)*K*P$ |
---|
362 | \end{center} |
---|
363 | |
---|
364 | Soit dans les deux exemples précédents : |
---|
365 | |
---|
366 | \begin{center} |
---|
367 | \begin{tabular}{l|cc} |
---|
368 | & Full shared & Semi shared \\ |
---|
369 | \hline |
---|
370 | N & 8 & $M+X*K = 8$ \\ |
---|
371 | M & - & 4 \\ |
---|
372 | K & - & 2 \\ |
---|
373 | E & 6 & 6 \\ |
---|
374 | E' & - & 3 \\ |
---|
375 | \hline |
---|
376 | Total & $E*N*P$ & $E*(M+K)*P$ \\ |
---|
377 | & $48*P$ & $36*P$ \\ |
---|
378 | \hline |
---|
379 | Gain & \multicolumn{2}{c}{$E*(\frac{E}{E'}-1)*K*P$}\\ |
---|
380 | & \multicolumn{2}{c}{$12*P$} \\ |
---|
381 | \end{tabular} |
---|
382 | \end{center} |
---|
383 | } |
---|
384 | |
---|
385 | \frame |
---|
386 | { |
---|
387 | \frametitle{Incidence} |
---|
388 | |
---|
389 | \begin{itemize} |
---|
390 | \item + Gain en nombre de port |
---|
391 | \item + Moins de pourrisement des structures dut au partage des ressources |
---|
392 | \item - Perte de performance en execution ST, et potentiellement en execution MT |
---|
393 | \end{itemize} |
---|
394 | } |
---|
395 | |
---|
396 | |
---|
397 | \subsection{Clusterisation des Unités d'éxecution - Cache de banc de registres} |
---|
398 | \frame |
---|
399 | { |
---|
400 | \begin{minipage}{0.55\textwidth} |
---|
401 | \frametitle{Partie exécutive \dots} |
---|
402 | \printgraph{MORPHEO_Partie_executive-schema_de_principe}{0.65} |
---|
403 | \end{minipage} |
---|
404 | \begin{minipage}{0.40\textwidth} |
---|
405 | Posons : |
---|
406 | \begin{itemize} |
---|
407 | \item $N = \sum_{i=1}^{k} n_{i}$ |
---|
408 | \item $M = \sum_{i=1}^{k} m_{i}$ |
---|
409 | \item W : Nb reg dest |
---|
410 | \item R : Nb reg src |
---|
411 | \item D : Profondeur SR |
---|
412 | \end{itemize} |
---|
413 | \end{minipage} |
---|
414 | } |
---|
415 | |
---|
416 | \frame |
---|
417 | { |
---|
418 | \frametitle{\dots ~ avec un réseaux de bypass complet} |
---|
419 | |
---|
420 | \begin{center} |
---|
421 | \printgraph{MORPHEO_Partie_executive-bypass_complet}{0.6} |
---|
422 | \end{center} |
---|
423 | } |
---|
424 | |
---|
425 | \frame |
---|
426 | { |
---|
427 | \frametitle{\dots ~ avec clusterisation} |
---|
428 | |
---|
429 | \begin{minipage}{0.48\textwidth} |
---|
430 | \begin{center} |
---|
431 | \printgraph{MORPHEO_Partie_executive-cluster}{0.6} |
---|
432 | \end{center} |
---|
433 | \end{minipage} |
---|
434 | \begin{minipage}{0.48\textwidth} |
---|
435 | En posant : |
---|
436 | |
---|
437 | \begin{itemize} |
---|
438 | \item V : le nombre de voisin |
---|
439 | \item M' : le nombre de résultat circulant entre les clusters |
---|
440 | \end{itemize} |
---|
441 | \end{minipage} |
---|
442 | } |
---|
443 | |
---|
444 | \frame |
---|
445 | { |
---|
446 | \frametitle{\dots ~ avec cache de banc de registres} |
---|
447 | |
---|
448 | \begin{center} |
---|
449 | \begin{minipage}{0.48\textwidth} |
---|
450 | \printgraph{MORPHEO_Partie_executive-cluster_avec_cache1}{0.6} |
---|
451 | \end{minipage} |
---|
452 | \begin{minipage}{0.48\textwidth} |
---|
453 | \printgraph{MORPHEO_Partie_executive-cluster_avec_cache2}{0.6} |
---|
454 | \end{minipage} |
---|
455 | \end{center} |
---|
456 | } |
---|
457 | |
---|
458 | %\frame |
---|
459 | % { |
---|
460 | % \frametitle{Comparaison} |
---|
461 | % |
---|
462 | % Posons S le nombre de registres physiques. |
---|
463 | % |
---|
464 | % Avec : |
---|
465 | % \begin{center} |
---|
466 | % \begin{tabular}{lc} |
---|
467 | % sff2 & 34 transistors\\ |
---|
468 | % nmx2 & 12 transistors\\ |
---|
469 | % \end{tabular} |
---|
470 | % \end{center} |
---|
471 | % |
---|
472 | % Avec : |
---|
473 | % \begin{itemize} |
---|
474 | % \item R = 2 |
---|
475 | % \item W = 1 |
---|
476 | % \item $\forall i,j \in [1:k[ ~ n_{i}=n_{j}$, avec M = 12 |
---|
477 | % \item $\forall i,j \in [1:k[ ~ m_{i}=m_{j}$, avec N = 8 |
---|
478 | % %\item $\forall i \in [1:k[ ~ D_{i}=D$ |
---|
479 | % \end{itemize} |
---|
480 | % |
---|
481 | % Taille du Banc de registres : $S * Size_{sff2} + ((W_{RF}-1)*S + R_{RF}*(S-1)) * Size_{nmx2}$ |
---|
482 | % |
---|
483 | % |
---|
484 | % } |
---|
485 | |
---|
486 | \frame |
---|
487 | { |
---|
488 | \frametitle{Comparaison} |
---|
489 | |
---|
490 | \begin{center} |
---|
491 | \begin{tabular}{l|c} |
---|
492 | & nb bypass \\ |
---|
493 | \hline |
---|
494 | Complete & $(W*M)*(R*D*N)$ \\ |
---|
495 | Clusterisé & $\sum_{i=1}^{k} ((W*m_{i} + V*B) * R*D*m_{i})$\\ |
---|
496 | Cache 1 & $\sum_{i=1}^{k} (W*m_{i} * R*D*m_{i})$\\ |
---|
497 | Cache 2 & $0$\\ |
---|
498 | \end{tabular} |
---|
499 | |
---|
500 | \begin{tabular}{l|c} |
---|
501 | & Banc de registres \\ |
---|
502 | \hline |
---|
503 | Complete & $(W*M)$ port d'écriture, $(R*N)$ de lecture\\ |
---|
504 | Clusterisé & Bonne cible pour le multi banc \\ |
---|
505 | Cache 1 & 1 port de lecture, 1 port d'écriture\\ |
---|
506 | Cache 2 & 1 port de lecture, 1 port d'écriture\\ |
---|
507 | \end{tabular} |
---|
508 | |
---|
509 | \end{center} |
---|
510 | |
---|
511 | |
---|
512 | } |
---|
513 | |
---|
514 | |
---|
515 | \section{Planning} |
---|
516 | \frame |
---|
517 | { |
---|
518 | \frametitle{Tâche à réaliser} |
---|
519 | |
---|
520 | \begin{enumerate} |
---|
521 | \item Réecriture complete du code SystemC |
---|
522 | \begin{itemize} |
---|
523 | \item Compatibilité avec SystemCass |
---|
524 | \item Optimisation du code et des algorithmes |
---|
525 | \item Mise en forme pour l'exportation du projet |
---|
526 | \item Définition d'un format pour la configuration |
---|
527 | \item Définition d'un format pour les statistiques |
---|
528 | \end{itemize} |
---|
529 | \item Ecriture systématique de la documentation pour chaque composant |
---|
530 | \begin{itemize} |
---|
531 | \item Structure interne |
---|
532 | \item Incidence des paramètres sur la structure (Surface et Temps d'execution) |
---|
533 | \item Choix architecturaux pour le passage au VHDL |
---|
534 | \end{itemize} |
---|
535 | \item Ecriture des modèles VHDL et synthèse sur FPGA |
---|
536 | \end{enumerate} |
---|
537 | } |
---|
538 | |
---|
539 | \frame |
---|
540 | { |
---|
541 | \frametitle{Tâche déléguée} |
---|
542 | |
---|
543 | \begin{enumerate} |
---|
544 | \item Ecriture d'un cache de donnée en SystemC/VHDL |
---|
545 | \item Ecriture d'un cache d'instruction en VHDL |
---|
546 | \item Automatisation du processus d'optimisation de la configuration en fonction des statistiques et de contraintes |
---|
547 | \item Synthèse des modèles VHDL avec Coriolis |
---|
548 | \end{enumerate} |
---|
549 | } |
---|