introduction aux architectures d ordinateurs n.
Download
Skip this Video
Loading SlideShow in 5 Seconds..
INTRODUCTION AUX ARCHITECTURES D’ORDINATEURS PowerPoint Presentation
Download Presentation
INTRODUCTION AUX ARCHITECTURES D’ORDINATEURS

Loading in 2 Seconds...

play fullscreen
1 / 34
leila-arnold

INTRODUCTION AUX ARCHITECTURES D’ORDINATEURS - PowerPoint PPT Presentation

81 Views
Download Presentation
INTRODUCTION AUX ARCHITECTURES D’ORDINATEURS
An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript

  1. INTRODUCTION AUX ARCHITECTURES D’ORDINATEURS Smail NIAR MASTER 1 Informatique Smail.Niar@univ-valenciennes.fr

  2. Plan

  3. Les Performances des processors superscalaire sont loins des performances idéales • Exécution sur un processeur super scalaire exécutant un ensemble de prgs, en supposant: •  d ’unités Fonctionnelles •  vitesse de transfert entre Mémoire et UC • Prédiction des branchement parfaite • Taille de la mémoire et vitesse réelles • Taux d’échec dans la mémoire $ non nul

  4. Pourquoi le // ?

  5. Les grandes Applications

  6. Qu’est ce qu’un ordinateur // ?

  7. Classification de Flynn

  8. SIMD

  9. MIMD

  10. MIMD

  11. Architecture à Mémoire PartagéeShared Address Space Architectures • Any processor can directly reference any memory location • Communication occurs implicitly as result of loads and stores • Convenient: • Location transparency • Similar programming model to time-sharing on uniprocessors • Wide range of scale: few to hundreds of processors • memory may be physically distributed among processors

  12. Mémoire partagée Centralisée UMA Mémoire Partagée Distribuée NUMA • Quelles solution pour le réseau d’interconnections: Connection Complète ou crossbar (coûteuse) , bus commun (faible performance pour un grand nombre de processeurs) • Solution possible : Une mémoire distribué ou «  non-uniform memory access (NUMA) » • Construire une espace d’adressage partagé sur un réseau de communication fonctionnant par message

  13. SMP : Symmetric Multi-Processors • Deux ou + processeurs • Même mémoire principale (DRAM) et E/S. Réseau d’interconnection entre processeurs • Tous les processeurs peuvent exécuter les mêmes fct (symm) • Un seul OS, supporte les interactions entre les tâches parallèles

  14. Ring Fully Connected Quelques exemple de réseaux d’interconnexion 3 a . 2 D g r i d o r m e s h o f 1 6 n o d e s b . n - c u b e t r e e o f 8 n o d e s ( 8 = 2 s o n = 3 )

  15. Message-Passing Y , P , t Match Receive Addr esse Y Send X, Q, t • Send instruction specifies buffer to be transmitted and/or receiving process • Receive specifies : sending process and application storage to receive into • In simplest form, the send/receive are pairwise; synch event • Send/receive Blockant ou non blockant X Addr esse ocess Local pr Local pr ocess ess space addr addr ess space Pr ocess P Pr ocess Q

  16. Tâche A Tâche B envoie donnée canal de communication réception donnée Communication Par Passage de Messages Tâche A Tâche B Mémoire partagée écrire dans V v lire dans V Communication Par Mémoire Partagée

  17. Example: IBM SP-2

  18. Example: Cray T3E • Scale up to 1024 processors, 480MB/s links • Memory controller generates comm. request for nonlocal references • No hardware mechanism for coherence (SGI Origin etc. provide this)

  19. Processeurs Multi-cores • Architecture intel core-duo • Architecture Intel Itanium Montécito

  20. MIMD_DM Vs MIMD_SM

  21. Organisation des processeurs Flux à plusieurs instructions et une donnée Flux à plusieurs instructions et plusieurs données Flux à 1 instruction SISD Monoprocesseur Mémoire Distribuée (clusters) Mémoire partagée • Flux à une instruction • Sur plusieurs données • Processeurs vectoriels • (ex Cray) • 2) Processeurs tableau Accès Non uniforme NUMA MultiPro. Symétrique SMP

  22. 1 b c e - ´ + a = (b +1) ´ - (b c) d = c ´ e ´ d f = a d Dataflow graph ´ a ´ f Dataflow Architectures • Représenter le programme à exécuter par un graphe • Un processeur virtuel dans chaque nœud • Une instruction (nœud, processeur Virtuel) s’exécute dés que les opérandes sont présents. Un message (jeton) est envoyé a chacun des destinataires • La dépendance de données est représentés par des jetons (Token) sur le graphe. • Pratiquement un processeur (réel) représente plusieurs processeur virtuel. • Lorsqu’une instruction a calculer sont résultats il faut savoir/trouver les autres opérandes utilisés par la même instr (matching)

  23. Architecture Typique d’un processeur Data Flow Mémoire des programme Le programme à exécuter Les résultats (jetons) déjà calcules en attente des autres résultats pour activer une instr Network T oken Pr ogram e e stor stor Network W aiting Form Instruction Execute fetch token Matching T oken queue Network

  24. Évaluation des Performances

  25. Accélération Super-linéaire

  26. L’iso-Efficacité

  27. Les Sources du //Ou trouvez les tâches //?

  28. Les Trois sources du // F.Capello, LRI Orsay Paris XI

  29. master1 Mémoire UAL UC Conclusion Lic2 Lic3

  30. Any Time, Anywhere, Any Device All computing devices communicate All communication devices compute All enabled by silicon Demandes COMPUTING COMMUNICATIONS Innovation

  31. Shared Memory Programming • Example: Sum 100,000 numbers (Assume 10 processors). Each processor executes the same program (Pn = processor number), Array A contains shared data. sum[Pn] = 0; for (i=10000*Pn; i < 10000*(Pn + 1); i++) sum[Pn] = sum[Pn] + A[i]; half = 10; repeat synch(); /* wait for partial sum completion */ if (half % 2 != 0 && Pn == 0) sum[0] = sum[0] + sum[half -1]; half = half/2; if (Pn < half) sum[Pn] = sum[Pn] + sum[Pn + half]; until (half == 1); /* exit with final sum in sum[0] */

  32. Distributed Memory Programming • Example: Sum 100,000 numbers (Assume 100 processors) • Partition global array, A, into 100 equal parts and distribute each part to a different processor: sum = 0; for (i=0; i < 1000; i++) sum = sum + A[i]; half = 100; limit = 100; repeat half = (half+1)/2; /* send vs. receive dividing line */ if (Pn >= half && Pn < limit) send(Pn - half, sum); if (Pn <= limit/2 -1) sum = sum + receive(); limit = half; /* upper limit of senders */ until (half == 1); /* exit with final sum */