• Refine Query
  • Source
  • Publication year
  • to
  • Language
  • 33
  • 23
  • 4
  • Tagged with
  • 63
  • 63
  • 29
  • 25
  • 25
  • 24
  • 11
  • 11
  • 10
  • 10
  • 10
  • 10
  • 10
  • 9
  • 9
  • About
  • The Global ETD Search service is a free service for researchers to find electronic theses and dissertations. This service is provided by the Networked Digital Library of Theses and Dissertations.
    Our metadata is collected from universities around the world. If you manage a university/consortium/country archive and want to be added, details can be found on the NDLTD website.
1

Parallélisation sur matériel graphique : contributions au repliement d'ARN et à l'alignement de séquences

Rizk, Guillaume 12 January 2011 (has links) (PDF)
La bioinformatique nécessite l'analyse de grandes quantités de données. Avec l'apparition de nouvelles technologies permettant un séquençage à haut débit à bas coût, la puissance de calcul requise pour traiter les données a énormément augmenté.. Cette thèse examine la possibilité d'utiliser les processeurs graphiques (GPU) pour des applications de bioinformatique. Dans un premier temps, ce travail s'intéresse au calcul des structures secondaires d'ARN. Ce problème est en général calculé par programmation dynamique, avec un algorithme qui pose de sérieux problèmes pour un code GPU. Nous introduisons une nouvelle implémentation tuilée qui fait apparaitre une bonne localité mémoire, permettant ainsi un programme GPU très efficace. Cette modification permet également de vectoriser le code CPU et donc de faire une comparaison honnête des performances entre GPU et CPU. Dans un deuxième temps, ce travail aborde le problème d'alignements de séquences. Nous présentons une parallélisation GPU d'une méthode utilisant une indexation par graines. L' implémentation sur GPU n'étant pas efficace, nous nous tournons vers le développement d'une version CPU. Notre contribution principale est le développement d'un nouvel algorithme éliminant rapidement les nombreux alignements potentiels, basé sur le précalcul de portions de la matrice de programmation dynamique. Ce nouvel algorithme a conduit au développement d'un nouveau programme d'alignement très efficace. Notre travail fournit l'exemple de deux problèmes différents dont seulement un a pu être efficacement parallélisé sur GPU. Ces deux expériences nous permettent d'évaluer l'efficacité des GPU et leur place en bioinformatique.
2

Extensions parallèles pour le langage Nit

Poirier, Sylvain 06 1900 (has links) (PDF)
Grâce à la miniaturisation et à l'arrivée des processeurs multicœurs dans les ordinateurs personnels, la programmation parallèle ne semble plus être réservée aux groupes restreints d'utilisateurs ayant accès à des superordinateurs ou à des grappes de calculs. De plus, avec la tendance actuelle d'augmenter constamment le nombre de cœurs des processeurs, le besoin de développer des applications pouvant s'exécuter correctement sur l'ensemble des unités de traitement disponibles est un enjeu déterminant. Sous de telles conditions, tout langage de programmation récent devrait être doté de mécanismes permettant la génération et l'exploitation de calculs parallèles. Dans le présent mémoire, nous explorons la possibilité d'intégrer des extensions parallèles à un langage orienté objet récent qui, au départ, ne possédait aucun support pour la programmation parallèle. Le langage utilisé est Nit, un langage développé conjointement à l'UQAM et au LIRMM (Montpellier, France). Nit est un langage moderne orienté objet dont la mise en œuvre utilise de nouvelles techniques de compilation, à la fine pointe de la recherche sur les langages orientés objet. À ce langage de base séquentiel, nous avons ajouté un module, appelé NitSpace, qui permet d'échanger de l'information entre des processus qui s'exécutent en parallèle. Ce module est fondé sur le modèle Linda proposé par Carriero et Gelernter (2). Le modèle Linda propose de partager, entre les processus, un espace de tuples par l'intermédiaire duquel les divers processus échangent de l'information, et ce à l'aide de quatre opérations principales : out, in, rd et eval. À ces quatre opérations s'ajoutent aussi deux variantes non bloquantes des opérations de lecture : inp et rdp. Ces diverses opérations permettent l'ajout, l'extraction et la lecture dans un espace partagé de tuples. Un avantage du modèle Linda est sa simplicité, mais en permettant malgré tout la définition des structures de données plus complexes telles que sémaphores, barrières de synchronisation, sacs de tâches, tableaux distribués, flux de données, etc. Le modèle Linda, défini au départ dans le contexte du langage C, a par la suite été intégré à d'autres langages, qui ont introduit des variantes au modèle original. Quelques-unes de ces variantes seront présentées, en présentant les implémentations qui ont été réalisées dans les langages Ruby, Python, Scala et Java. Nous avons choisi de présenter ces langages car, tout comme Nit, il s'agit de langages orientés objets. Les caractéristiques de ces différentes mises en œuvre du modèle Linda ont aussi influencé le choix de conception et de réalisation de notre module NitSpace. L'implémentation de ce module fut réalisée en trois couches que l'on présentera en détail. La majeure partie représentant la couche de bas niveau fut réalisée en C. À celle-ci s'ajoute une couche médiane qui permet de relier la couche C à la couche Nit. Finalement, la couche supérieure, écrite entièrement en Nit, représente l'API qui permet à un programme Nit de générer des calculs parallèles. ______________________________________________________________________________ MOTS-CLÉS DE L’AUTEUR : Nit, NitSpace, programmation parallèle, Linda, espace de tuples.
3

Programmation distribuée et migration de processus / Programmation distribuée et migration de processus

Lavoie, Gabriel, Lavoie, Gabriel January 2011 (has links)
Ce mémoire propose un modèle de programmation distribuée basé sur la migration de processus pouvant communiquer à l’aide de canaux de communication. Ce travail cadre bien avec le contexte actuel où l’augmentation de la puissance de traitement passe par les processeurs multicoeurs et les systèmes distribués, qui permettent l’exécution de plusieurs processus en parallèle. L’étude de différentes algèbres de processus et langages de programmation permettant le parallélisme a tout d’abord permis de comparer leurs différentes caractéristiques. Suite à cette étude, nous présentons différents concepts nécessaires à la mise en place de notre modèle distribué par migration de processus, dans le cadre des langages objets qui imposent certaines contraintes. Finalement, l’implé- mentation de notre modèle à l’aide des fonctionnalités de Stackless Python permet de voir comment chacun des concepts a été mis en place. Cette implémentation se présente sous la forme d’une extension qui permet la transformation de programmes existants en programmes distribués. / Ce mémoire propose un modèle de programmation distribuée basé sur la migration de processus pouvant communiquer à l’aide de canaux de communication. Ce travail cadre bien avec le contexte actuel où l’augmentation de la puissance de traitement passe par les processeurs multicoeurs et les systèmes distribués, qui permettent l’exécution de plusieurs processus en parallèle. L’étude de différentes algèbres de processus et langages de programmation permettant le parallélisme a tout d’abord permis de comparer leurs différentes caractéristiques. Suite à cette étude, nous présentons différents concepts nécessaires à la mise en place de notre modèle distribué par migration de processus, dans le cadre des langages objets qui imposent certaines contraintes. Finalement, l’implé- mentation de notre modèle à l’aide des fonctionnalités de Stackless Python permet de voir comment chacun des concepts a été mis en place. Cette implémentation se présente sous la forme d’une extension qui permet la transformation de programmes existants en programmes distribués.
4

Programmation des architectures hiérarchiques et hétérogènes.

Hamidouche, Khaled 10 November 2011 (has links) (PDF)
Les architectures de calcul haute performance de nos jours sont des architectures hiérarchiques et hétérogènes: hiérarchiques car elles sont composées d'une hiérarchie de mémoire, une mémoire distribuée entre les noeuds et une mémoire partagée entre les coeurs d'un même noeud. Hétérogènes due à l'utilisation des processeurs spécifiques appelés Accélérateurs tel que le processeur CellBE d'IBM et les CPUs de NVIDIA. La complexité de maîtrise de ces architectures est double. D'une part, le problème de programmabilité: la programmation doit rester simple, la plus proche possible de la programmation séquentielle classique et indépendante de l'architecture cible. D'autre part, le problème d'efficacité: les performances doivent êtres proches de celles qu'obtiendrait un expert en écrivant le code à la main en utilisant des outils de bas niveau. Dans cette thèse, nous avons proposé une plateforme de développement pour répondre à ces problèmes. Pour cela, nous proposons deux outils : BSP++ est une bibliothèque générique utilisant des templates C++ et BSPGen est un framework permettant la génération automatique de code hybride à plusieurs niveaux de la hiérarchie (MPI+OpenMP ou MPI + Cell BE). Basée sur un modèle hiérarchique, la bibliothèque BSP++ prend les architectures hybrides comme cibles natives. Utilisant un ensemble réduit de primitives et de concepts intuitifs, BSP++ offre une simplicité d'utilisation et un haut niveau d' abstraction de la machine cible. Utilisant le modèle de coût de BSP++, BSPGen estime et génère le code hybride hiérarchique adéquat pour une application donnée sur une architecture cible. BSPGen génère un code hybride à partir d'une liste de fonctions séquentielles et d'une description de l'algorithme parallèle. Nos outils ont été validés sur différentes applications de différents domaines allant de la vérification et du calcul scientifique au traitement d'images en passant par la bioinformatique. En utilisant une large sélection d'architecture cible allant de simple machines à mémoire partagée au machines Petascale en passant par les architectures hétérogènes équipées d'accélérateurs de type Cell BE.
5

Acquisition et traitement d'images 3D couleur temps réel / Acquisition and real time image processing for 3D color images

Itthirad, Frédéric 15 September 2011 (has links)
Les capteurs 3D existants sont encore peu utilisés et ne permettent que l’acquisition de données 3D. En cas de nécessité de données 2D monochrome ou couleur, il faut alors obligatoirement ajouter un capteur supplémentaire et procéder au recalage des données. La société NT2I a décidé de développer sa propre solution afin de pouvoir rester maître de la chaîne d’acquisition. Mon travail a consisté en la conception d’un capteur spécifique intégrant couleur et calibration et au traitement des images issues de celui-ci. Pour cela, j’ai été amené à travailler sur l’extension du modèle LIP (Logarithmic Image Processing) pour des images couleur et à l’implémentation d’algorithmes temps réel / The existing 3D sensors aren’t much used and are only capable of capturing 3D dat. When 2D data are necessary, one has to use another camera and correlate the 2 images. NT2I has decided to develop its own solution in order to control the acquisition chain. My work has been to develop a specific camera with color, calibration, and image processing algorithms. In that purpose, I've worked on the extension of the LIP model (Logarithmic Image Processing) for color images and on the implementation of real time algorithms
6

Stratégies d'analyse de performance pour les applications basées sur tâches sur plates-formes hybrides / Performance Analysis Strategies for Task-based Applications on Hybrid Platforms

Garcia Pinto, Vinicius 30 October 2018 (has links)
Les techniques de programmations pour le calcul de haute performanceont adopté les modèles basés sur parallélisme de tâche qui sontcapables de s’adapter plus facilement à des superordinateurs avec desarchitectures hybrides. La performance des applications basées surtâches dépende fortement des heuristiques d'ordonnancement dynamiqueset de sa capacité à exploiter les ressources de calcul et decommunication.Malheureusement, les stratégies d'analyse de performancetraditionnelles ne sont pas convenables pour comprendre les supportsd'exécution dynamiques et les applications basées sur tâches. Cesstratégies prévoient un comportement régulier avec des phases decalcul et de communication, par contre, des applications basées surtâches ne manifestent pas de phases précises. Par ailleurs, la granularitéplus fine des applications basées sur tâches typiquement provoque descomportements stochastiques qui donnent lieu aux structuresirrégulières qui sont difficiles à analyser.Dans cette thèse, nous proposons des stratégies d'analyse deperformance qui exploitent la combinaison de la structure del'application, d'ordonnancement et des informations de laplate-forme. Nous présentons comment nos stratégies peuvent aider àcomprendre des problèmes de performance dans des applications baséesur tâches qui exécutent dans des plates-formes hybrides. Nosstratégies d'analyse de performance sont construites avec des outilsmodernes pour l'analyse de données, ce que permettre la création despanneaux de visualisation personnalisés. Ces panneaux permettent lacompréhension et l'identification de problèmes de performancesoccasionnés par de mauvaises décisions d'ordonnancement etconfiguration incorrect du support d'exécution et de laplate-forme. Grâce à combinaison de simulation et débogage nouspouvons aussi construire une représentation visuelle de l'état interneet des estimations calculées par l'ordonnancer durant l'ordonnancementd'une nouvelle tâche.Nous validons notre proposition parmi de l'analyse de tracesd'exécutions d'une factorisation de Cholesky implémenté avec lesupport d'exécution StarPU et exécutée dans une plate-forme hybride(CPU/GPU). Nos études de cas montrent comment améliorer la partitiondes tâches entre le multi-(GPU, coeur) pour s'approcher des bornesinférieures théoriques, comment améliorer le pipeline des opérationsMPI entre le multi-(noeud, coeur, GPU) pour réduire le démarrage lentedans les noeuds distribués et comment optimiser le support d'exécutionpour augmenter la bande passante MPI. Avec l'emploi des stratégies desimulation et débogage, nous fournissons un workflow pourl'examiner, en détail, les décisions d'ordonnancement. Cela permet deproposer des changements pour améliorer les mécanismes d'ordonnancementet prefetch du support d'exécution. / Programming paradigms in High-Performance Computing have been shiftingtoward task-based models that are capable of adapting readily toheterogeneous and scalable supercomputers. The performance oftask-based applications heavily depends on the runtime schedulingheuristics and on its ability to exploit computing and communicationresources.Unfortunately, the traditional performance analysis strategies areunfit to fully understand task-based runtime systems and applications:they expect a regular behavior with communication and computationphases, while task-based applications demonstrate no clearphases. Moreover, the finer granularity of task-based applicationstypically induces a stochastic behavior that leads to irregularstructures that are difficult to analyze.In this thesis, we propose performance analysis strategies thatexploit the combination of application structure, scheduler, andhardware information. We show how our strategies can help tounderstand performance issues of task-based applications running onhybrid platforms. Our performance analysis strategies are built on topof modern data analysis tools, enabling the creation of customvisualization panels that allow understanding and pinpointingperformance problems incurred by bad scheduling decisions andincorrect runtime system and platform configuration.By combining simulation and debugging we are also able to build a visualrepresentation of the internal state and the estimations computed bythe scheduler when scheduling a new task.We validate our proposal by analyzing traces from a Choleskydecomposition implemented with the StarPU task-based runtime systemand running on hybrid (CPU/GPU) platforms. Our case studies show howto enhance the task partitioning among the multi-(GPU, core) to getcloser to theoretical lower bounds, how to improve MPI pipelining inmulti-(node, core, GPU) to reduce the slow start in distributed nodesand how to upgrade the runtime system to increase MPI bandwidth. Byemploying simulation and debugging strategies, we also provide aworkflow to investigate, in depth, assumptions concerning the schedulerdecisions. This allows us to suggest changes to improve the runtimesystem scheduling and prefetch mechanisms.
7

Quelques applications de la programmation des processeurs graphiques à la simulation neuronale et à la vision par ordinateur

Chariot, Alexandre 16 December 2008 (has links) (PDF)
Largement poussés par l'industrie vidéoludique, la recherche et le développement d'outils matériels destinés à la génération d'images de synthèse, tels les cartes graphiques (ou GPU, Graphics Processing Units), ont connu un essor formidable ces dernières années. L'augmentation de puissance et de
8

Réseaux de Pétri pour la sémantique et l'implémentation de processus parallèles

Autant, Cyril 10 May 1993 (has links) (PDF)
Dans la première partie de cette thèse, nous présentons une implémentation du langage fp2 ayant pour modèle les réseaux de Petri. Fp2 est un langage de programmation parallèle base sur la réécriture de termes et les spécifications algébriques. Nous donnons une nouvelle sémantique a fp2, de la famille des sémantiques du vrai parallélisme, et prouvons la correction de cette sémantique par rapport a la sémantique interleaving du langage. Le modèle utilise, les réseaux de Petri, et la nouvelle sémantique donnée au langage permettent une représentation plus compacte de programmes complexes, évitant les problèmes d'explosion combinatoire rencontres avec les implémentations précédentes. Nous évaluons le gain de notre approche, et proposons plusieurs schémas d'interprétation du langage, bases sur cette nouvelle sémantique. La seconde partie de ce travail concerne la définition d'une nouvelle famille d'équivalences comportementales pour les réseaux de Petri. Alors que les équivalences proposées jusqu'alors sont définies entre les marquages, c'est-a-dire entre les états globaux du réseau, nous définissons une relation entre les places du réseau, reprenant une idée proposée par olderog. De nouvelles équivalences, les bisimulations de places, sont proposées a partir de cette définition. Un algorithme efficace (polynomial) permettant de calculer la plus grande bisimulation de places sur un réseau est propose. Nous montrons comment simplifier un réseau en le quotientant par cette plus grande bisimulation, obtenant ainsi un représentant canonique d'une classe d'équivalence de réseaux bisimilaires de places. L'étude de ces équivalences est ensuite étendue aux réseaux avec actions internes
9

Traçage flexible d'exécutions de programmes parallèles

Guilloud, Cyril 05 February 2004 (has links) (PDF)
Cette thèse (financée par l'INRIA) s'est déroulée au sein du laboratoire ID-imag (sous les tutelles : CNRS (UMR 5132) - INRIA - INPG - UJF) dont l'un des axes de recherche est la conception d'applications parallèles et de techniques pour l'exploitation de machines parallèles. La mise au point, tant pour la correction que pour les performances, de telles applications est nécessaire à l'exploitation efficace d'architectures de type grappes. Notre approche du débogage pour les performances se base sur l'observation comportementale de l'exécution des programmes, reconstituée à partir de traces d'exécution, cette observation étant facilitée par l'utilisation d'outils de visualisation. L'objectif de cette thèse est l'étude de méthodes permettant d'enregistrer facilement des traces d'exécution de programmes parallèles pour une grande variété de modèles de programmation parallèle ou distribuée, d'interfaces de programmation ainsi que d'outils de visualisation. Nous nous appuyons pour cela sur des formats adaptables pour l'enregistrement et l'exploitation de traces d'exécution. Afin de permettre l'adaptation du système de traçage à divers modèles de programmation, nous utilisons un format de trace brut élémentaire sans sémantique intrinsèque. Ce format brut présente l'avantage d'être compact et facilement adaptable aux programmes des utilisateurs et à leurs contraintes. L'utilisateur du système de traçage peut définir les événements à observer ainsi que les types des paramètres qui leurs sont associés. Les outils de visualisation ou d'analyse utilisent généralement des formats élaborés plus expressifs. La distinction des formats implique donc l'utilisation d'un système de conversion pour passer de l'un à l'autre. Ces formats étant adaptables, la conversion doit de plus être configurable. Nous avons donc conçu un système de conversion, paramétrée à l'aide de règles de réécriture, permettant d'apporter une sémantique aux événements bruts. À l'aide de ce système flexible de traçage et de conversion, nous avons pu visualiser des exécutions de programmes mettant en oeuvre les divers niveaux d'abstractions d'un intergiciel multicouche pour la programmation parallèle.
10

Ordonnancement avec communications pour systèmes multiprocesseurs dans divers modèles d'exécution

Guinand, Frédéric 07 June 1995 (has links) (PDF)
En quelques dizaines d'années, l'informatique a vu naître et se développer des machines fonctionnant avec plusieurs processeurs. Les difficultés techniques rencontrées pour la conception de ces ordinateurs ont été surmontées et l'un des défis majeur d'aujourd'hui est de fournir une plateforme pour la programmation parallèle. Ce travail de thèse s'inscrit dans le cadre du projet IMAG APACHE qui a pour but la conception d'un tel environnement. Le modèle de graphes que nous manipulons est un graphe de tâches orienté sans cycle. Le processus consistant à paralléliser une application est découpé en trois phases principales, avec l'ordonnancement et le placement des différentes parties de l'application comme étape centrale. Dans ce contexte, nous avons concentrés nos efforts sur la recherche de stratégies d'ordonnancement présentant de réelles qualités de robustesse et d'efficacité pour des graphes de différentes granularités, et pour des ensembles d'hypothèses d'exécution différents. A partir d'un algorithme produisant des ordonnancements optimaux dans le cas de graphes à structure arborescente formés de tàches de durées unitaires et de communications unitaires, nous avons montré qu'il était possible d'obtenir des ordonnancements, dont l'écart par rapport à l'optimal est borné, pour des arbres de granularité différente. Nous avons montré également que ce même algorithme permettait d'obtenir dans certains cas des ordonnancements optimaux pour un modèle d'exécution totalement différent de celui pour lequel il avait été originellement conçu. Cette étude sur deux processeurs a été mené pour un nombre supérieur de processeurs identiques et pour deux processeurs uniformes. Enfin, une partie de ce travail est dédiée à la recherche de stratégies d'ordonnancement pour des graphes générés par l'environnement Athapascan (projet APACHE) qui présentent la particularité de permettre l'adaptation de la granularité en fonction de la machine cible.

Page generated in 0.1569 seconds