Dissertations / Theses: 'C (langage de programmation)'

1

El, Mokhtari Mounir. "Contribution à l'intégration de C++ et de Prolog à travers la machine abstraite de Warren : le système cop-compilé." Sherbrooke : Université de Sherbrooke, 1997.

Find full text

APA, Harvard, Vancouver, ISO, and other styles

2

David, Pierre. "Analyse semantique des programmes en langage c en vue de leur parallelisation." Paris 6, 1991. http://www.theses.fr/1991PA066088.

Full text

Abstract:

Les recherches dans le domaine de la parallelisation automatique se sont concentrees sur le langage fortran. Or, ce langage souffre de defauts qui le rendent inadapte a un certain nombre de problemes. Le but de notre etude est la detection automatique de parallelisme en langage c. Le probleme est complexe puisque le langage c dispose de nombreuses constructions destinees a faciliter une ecriture optimisee sur une architecture traditionnelle, et en particulier les pointeurs, l'arithmetique sur ces pointeurs et les expressions avec effets de bord. Notre approche consiste a desoptimiser le programme pour en faciliter l'analyse semantique. Dans un premier temps, nous definissons un sous-ensemble du langage c sans appel de fonctions ni coercitions, mais en acceptant toutes les expressions avec effets de bord. L'absence de coercitions nous permet de definir une structuration de la memoire suivant le systeme de types du langage. Dans un deuxieme temps, nous transformons les boucles for, qui ont en langage c une semantique tres complexe, en boucles while, puis nous retirons les effets de bord des expressions. Enfin, nous procedons a une evaluation symbolique du programme pour un extraire une suite de transformations, c'est-a-dire des substitutions gardees par des expressions logiques. Ce calcul est direct et precis pour les sequences lineaires, mais nous devons proceder a des approximations pour les boucles. Un des sous-produits de cette analyse est l'identification de celles des boucles while qui ont une semantique de boucle do de fortran. A partir de la, il nous est possible de nous interfacer avec un paralleliseur classique

APA, Harvard, Vancouver, ISO, and other styles

3

Tran, tan Antoine. "Squelettes algorithmiques asynchrones : application aux langages orientés domaine." Thesis, Université Paris-Saclay (ComUE), 2015. http://www.theses.fr/2015SACLS025/document.

Full text

Abstract:

Dans cette thèse, nous présentons des développements de l'approche utilisée dans l'équipe « ParSys » du LRI pour traduire automatiquement des codes scientifiques écrits dans un langage dédié inspiré de Matlab en codes de production haute performance. Pour garantir cette performance, nous mettons à profit d'une part la méta-programmation par templates C++ afin d'analyser chaque expression pour détecter les opportunités de parallélisme, et d'autre part la programmation parallèle asynchrone pour utiliser au mieux les ressources disponibles des machines multi-cœurs. Pour faire le lien entre ces deux étapes du processus de génération de code, des squelettes algorithmiques multi-niveaux sont implémentés. Nos outils ont été implantés dans la bibliothèque NT2 et évalués sur des applications scientifiques du monde réel
In this thesis, we present developments to the approach used by the LRI Parsys team to automatically translate MATLAB-like scientific codes into high performance production codes. To reach a high level of performance, we have combined C++ template meta-programming and asynchronous parallel programming to analyze each expression and detect parallelism opportunities first, and then to ensure near-optimal use of the available resources of multi-core machines. To link these two stages of the code generation process, we have implemented a solution based on multi-level algorithmic skeletons. We have implemented our tools in the NT2 library and evaluated them with several significant scientific benchmarks

APA, Harvard, Vancouver, ISO, and other styles

4

Labbé, Alexandre. "Développement de logiciels d'analyse structurale à interface graphique : WMNPhi et CalWin." Sherbrooke : Université de Sherbrooke, 2001.

Find full text

APA, Harvard, Vancouver, ISO, and other styles

5

Kerneis, Gabriel. "Continuation-Passing C : transformations de programmes pour compiler la concurrence dans un langage impératif." Phd thesis, Paris 7, 2012. http://www.theses.fr/2012PA077133.

Full text

Abstract:

La plupart des programmes informatiques sont concurrents : ils doivent effectuer plusieurs tâches en même temps. Les threads et les événements sont deux techniques usuelles d'implémentation de la concurrence. Les événements sont généralement plus légers et efficaces que les threads, mais aussi plus difficiles à utiliser. De plus, ils sont souvent trop limités ; il est alors nécessaire d'écrire du code hybride, encore plus complexe, utilisant à la fois des threads ordonnancés préemptivement et des événements ordonnancés coopérativement. Nous montrons dans cette thèse que des programmes concurrents écrits dans un style à threads sont traduisibles automatiquement en programmes à événements équivalents et efficaces par une suite de transformations source-source prouvées. Nous proposons d'abord Continuation-Passing C, une extension du langage C pour l'écriture de systèmes concurrents qui offre des threads très légers et unifiés (coopératifs et préemptifs). Les programmes CPC sont transformés par le traducteur CPC pour produire du code à événements séquentialisé efficace, utilisant des threads natifs pour les parties préemptives. Nous définissons et prouvons ensuite la correction de ces transformations, en particulier le lambda lifting et la conversion CPS, pour un langage impératif. Enfin, nous validons la conception et l'implémentation de CPC en le comparant à d'autres bibliothèques de threads et en exhibant notre seeder BitTorrent Hekate. Nous justifions aussi notre choix du lambda lifting en implémentant eCPC, une variante de CPC utilisant les environnements, et en comparant ses performances à celles de CPC
Most computer programs are concurrent ones: they need to perform several tasks at the same time. Threads and events are two common techniques to implement concurrency. Events are generally more lightweight and efficient than threads, but also more difficult to use. Additionally, they are often not powerful enough; it is then necessary to write hybrid code, that uses both preemptively-scheduled threads and cooperatively-scheduled event handlers, which is even more complex. In this dissertation, we show that concurrent programs written in threaded style can be translated automatically into efficient, equivalent event-driven programs through a series of proven source-to-source transformations. We first propose Continuation-Passing C, an extension of the C programming language for writing concurrent Systems that provides very lightweight, unified (cooperative and preemptive) threads. CPC programs are processed by the CPC translater to produce efficient sequentialized event-loop code, using native threads for the preemptive parts. We then define and prove the correctness of these transformations, in particular lambda lifting and CPS conversion, for an imperative language. Finally, we validate the design and implementation CPC by comparing it to other thread librairies, and by exhibiting our Hekate BitTorrent seeder. We also justify the choice of lambda lifting by implementing eCPC, a variant of CPC using environments, and comparing its performances to CPC

APA, Harvard, Vancouver, ISO, and other styles

6

Kerneis, Gabriel. "Continuation-Passing C : Transformations de programmes pour compiler la concurrence dans un langage impératif." Phd thesis, Université Paris-Diderot - Paris VII, 2012. http://tel.archives-ouvertes.fr/tel-00751444.

Full text

Abstract:

La plupart des programmes informatiques sont concurrents : ils doivent effectuer plusieurs tâches en même temps. Les threads et les événements sont deux techniques usuelles d'implémentation de la concurrence. Les événements sont généralement plus légers et efficaces que les threads, mais aussi plus difficiles à utiliser. De plus, ils sont souvent trop limités ; il est alors nécessaire d'écrire du code hybride, encore plus complexe, utilisant à la fois des threads ordonnancés préemptivement et des événements ordonnancés coopérativement. Nous montrons dans cette thèse que des programmes concurrents écrits dans un style à threads sont traduisibles automatiquement en programmes à événements équivalents et efficaces par une suite de transformations source-source prouvées. Nous proposons d'abord Continuation-Passing C, une extension du langage C pour l'écriture de systèmes concurrents qui offre des threads très légers et unifiés (coopératifs et préemptifs). Les programmes CPC sont transformés par le traducteur CPC pour produire du code à événements séquentialisé efficace, utilisant des threads natifs pour les parties préemptives. Nous définissons et prouvons ensuite la correction de ces transformations, en particulier le lambda lifting et la conversion CPS, pour un langage impératif. Enfin, nous validons la conception et l'implémentation de CPC en le comparant à d'autres bibliothèques de threads et en exhibant notre seeder BitTorrent Hekate. Nous justifions aussi notre choix du lambda lifting en implémentant eCPC, une variante de CPC utilisant les environnements, et en comparant ses performances à celles de CPC.

APA, Harvard, Vancouver, ISO, and other styles

7

Mopolo-Moke, Gabriel. "Nice-c++ : une extension c++ pour la programmation persistante a partir d'un serveur de bases d'objets." Nice, 1991. http://www.theses.fr/1991NICE4516.

Full text

Abstract:

Le projet tootsi est un projet de recherche europeen qui a debute en fevrier 1989 et prend fin en fevrier 1991. Il vise l'amelioration de l'utilisation des serveurs et banques de donnees existants. Pour mener a bien ce projet, un certain nombre d'outils de developpement ont ete juges necessaires notamment un langage de programmation susceptible de supporter des types complexes et multimedias, la notion de la persistance, le partage et certains liens semantiques tels que l'heritage et l'association. Le langage selectionne c++ ne possede pas toutes ces caracteristiques. Cette etude a pour but de proposer, dans le cadre du projet tootsi, une approche d'extension du langage c++ vers la programmation persistante et la prise en compte de nouveaux types. Notre demarche consiste a ne pas reecrire ou modifier le compilateur c++ mais au contraire a utiliser les concepts d'abstraction de donnees, de polymorphisme et d'heritage deja presents dans ce langage. Dans une premiere partie nous faisons l'etat de l'art dans le domaine de la programmation orientee-objets et de la programmation persistante. Ce systeme est defini par: 1) un modele de programmation fonde sur l'extension du modele d'objets et du systeme de type c++; 2) des interfaces de manipulation des objets et meta-objets; 3) un serveur d'objets pour la gestion de persistance. L'objectif finale de notre travail est de permettre a nice-c++ de supporter: les types complexes et multimedias, les liens d'association, la persistance et le partage afin de repondre aux besoins du projet tootsi

APA, Harvard, Vancouver, ISO, and other styles

8

Serrano, Manuel. "Vers une compilation portable et performante des langages fonctionnels /." Le Chesnay : INRIA, 1995. http://catalogue.bnf.fr/ark:/12148/cb370188956.

Full text

APA, Harvard, Vancouver, ISO, and other styles

9

Roegel, Denis. "Étude de la sémantique de programmes parallèles réels en TLA." Nancy 1, 1996. http://www.theses.fr/1996NAN10272.

Full text

Abstract:

Dans la première partie de cette thèse, nous avons voulu faciliter la dérivation de programmes parallèles réels à partir de spécifications abstraites. Nous avons défini une étape intermédiaire (cTLA) comme un croisement entre un langage de spécification (TLA+) et un langage parallèle réel. Nous avons conservé des structures de données très souples et abstraites, et en même temps, nous avons incorporé des structures de contrôle plus proches de langages réels. Toute la sémantique du langage a été définie au sein de TLA+. Dans la seconde partie, nous avons étudié des réseaux d'actions TLA. Un réseau est une représentation graphique d'une exécution structurée. Nous avons défini une opération de réduction sur les réseaux, dont le but est de trouver un réseau équivalent à un réseau donné, mais plus simple, au sens où le nombre d'arêtes est plus petit. Le système de réécriture que nous avons proposé correspond à des simplifications élémentaires dans les réseaux, et par voie de conséquence dans les programmes parallèles pouvant correspondre aux réseaux. Ce système est confluent. Lorsqu’un réseau peut être entièrement réduit à une action TLA, et si ce réseau satisfait quelques contraintes simples, le calcul représenté par le réseau est observationnellement équivalent à l'exécution de l'action qui est sa réduction. La réduction est alors un moyen de prouver qu'une action est implémentée par un groupe structure d'actions

APA, Harvard, Vancouver, ISO, and other styles

10

Dillon, Eric. "Propositions pour la maîtrise de la programmation par échange de messages." Nancy 1, 1997. http://www.theses.fr/1997NAN10192.

Full text

Abstract:

Le travail de thèse a été dirigé par le besoin de maîtrise de la programmation paralléle par échange de messages, qui peut être résumé en deux points : - une aide et une méthodologie lors de la conception de l'application parallèle ; - une garantie de performances optimales à l'exécution. Dans ce cadre, après avoir identifié les problèmes concrets posés par l'utilisation des bibliothèques de communication à la fois sur des réseaux de stations et sur de véritables machines parallèles, nous proposons deux approches permettant de résoudre tout ou partie de ces problèmes. La première approche est présentée à travers une interface C++ dédiée à la programmation par échange de messages. Cette interface, appelée Para++ apporte essentiellement une simplification sur la structure de l'application, et une simplification sur l'utilisation des services de deux bibliothèques de communication, PYM et MPI. La seconde approche propose d'apporter des solutions plus globales à l'utilisateur de la programmation par échange de messages. Elle est basée sur la définition d'un formalisme appelé MeDLey permettant d'exprimer les communications au sein d'une application parallèle. À partir de cette spécification, un générateur automatique de fonctions de communications va faire tous les choix concernant l'implantation des communications, laissant l'utilisateur se consacrer à l'implantation parallèle de son modèle sans avoir à se soucier de l'efficacité des communications. Enfin, les deux approches sont comparées et critiquées.

APA, Harvard, Vancouver, ISO, and other styles

11

Mahbouli, Hatem. "Modélisation de programmes C en expressions régulières." Thesis, Université Laval, 2011. http://www.theses.ulaval.ca/2011/28220/28220.pdf.

Full text

Abstract:

L’analyse statique des programmes est une technique de vérification qui permet de statuer si un programme est conforme à une propriété donnée. Pour l’atteinte de cet objectif, il faudrait disposer d’une abstraction du programme à vérifier et d’une définition des propriétés. Dans la mesure où l’outil de vérification prend place dans un cadre algébrique, la définition des propriétés ainsi que la modélisation du programme sont représentées sous la forme d’expressions régulières. Ce mémoire traite en premier lieu de la traduction des programmes écrits en langage C vers une abstraction sous forme d’expressions régulières. La méthode de traduction proposée, ainsi que les différentes étapes de transformations y sont exposées. Les premiers chapitres du présent mémoire énoncent les connaissances élémentaires de la théorie des langages ainsi que de la compilation des programmes. Un bref aperçu des différentes méthodes de vérification des programmes est présenté comme une mise en contexte. Finalement, la dernière partie concerne la traduction des programmes ainsi que la description de l’outil de traduction qui a été réalisé.

APA, Harvard, Vancouver, ISO, and other styles

12

Fatni, Abdelkrim. "Environnement de programmation parallèle adapté au traitement d'images et au calcul scientifique : le langage C// et son compilateur." Toulouse, INPT, 1998. http://www.theses.fr/1998INPT005H.

Full text

Abstract:

Les applications " Grand Challenge " nécessitent une puissance de calcul très importante. Malgré la haute performance des outils informatiques engendrée par la haute intégration des circuits électroniques, la puissance requise par ces applications, de l'ordre du tera-flops, reste non satisfaite. Le challenge pose a l'informaticien trouve sa solution dans la parallélisation de l'environnement de calcul. Celui-ci est constitué du calculateur, de l'algorithmique, du langage de programmation et de son compilateur. Mais l'environnement ne peut être efficace que s'il y a adéquation entre ces différentes composantes. Dans ce but, un environnement de programmation parallèle adapte au traitement d'images et au calcul scientifique est proposé dans cette thèse. Dans cette étude nous avons introduit le langage C// et son compilateur. Le langage C// est une extension parallèle du C basée sur le modèle de programmation a parallélisme de données. Le modèle d'exécution est de type SPMD à mémoire partagée et physiquement distribuée (DSM). Plusieurs processeurs de la machine exécutent le même programme et communiquent à travers des variables partagées. Des points de synchronisation sont utilisés par le programmeur pour coordonner les divers flots de la machine et maintenir la cohérence de données. L'atelier de compilation de C // se compose de deux phases consécutives. La première phase consiste en la traduction du code C // en code C après analyse syntaxique et sémantique des constructions parallèles relevant de notre paradigme de programmation. Ce code sera ensuite compilé par le compilateur Gcc de la FSF (Free Software Foundation) en code machine. L'utilité de Gcc provient de sa disponibilité, sa portabilité et sa configurabilité pour d'autres plates-formes. La machine symphonie nous a servi d'exemple pour la configuration de Gcc. Nous avons aussi implanté l'atelier de compilation sur la machine GFLOPS. Plusieurs applications relevant du domaine de traitement d'images ont été développées et simulées sur GFLOPS. Ceci nous a permis d'évaluer et de valider notre environnement de programmation C // sur cette machine. Les premiers résultats sont très encourageants.

APA, Harvard, Vancouver, ISO, and other styles

13

Mahieddine, Mohammed. "Modélisation, visualisation et animation d'objets 3D : Approche orientée objets." nice, 1991. http://www.theses.fr/1991NICE4496.

Full text

Abstract:

L'objectif de cette thèse est d'étudier l'application de l'approche orientée objets pour la modélisation, la visualisation et l'animation d'objets graphiques en 3 dimensions. Une première phase de cette étude a consiste en la construction d'une extension orientée objets de standards graphiques existants. Pour la construction du graphe d'héritage des classes, une méthode nouvelle est présentée qui consiste à utiliser a la fois l'héritage comportemental et l'héritage implémentationnel. Une extension orientée objets des systèmes core et cgi est présentée pour illustrer ces idées. Une étude exhaustive des méthodes de modélisation des courbes, des surfaces et des solides a permis de montrer l'intérêt des classes et de l'héritage pour réduire la difficulté de confection d'un logiciel de modélisation d'objets géométriques 3d. En ce qui concerne la visualisation des objets, nous montrons les avantages et les limites de l'approche orientée objets pour l'élimination des faces cachées, la manipulation des couleurs et le rendu réaliste (lancer de rayons). Nous montrons ensuite comment décrire l'animation des objets avec les concepts de classes et d'héritage et nous comparons cette approche avec celle des acteurs. La validation de cette approche a consiste à réaliser une application d'animation de robots articules en c++ sous x window. Ce travail démontre que la méthodologie orientée objets permet d'avoir une approche unifiée a la fois pour la modélisation géométrique, la visualisation des objets graphiques et pour leur animation

APA, Harvard, Vancouver, ISO, and other styles

14

Raharijaona, Jacques. "Étude du fonctionnement et commande numérique en langage C d'un groupe de pompage photovoltai͏̈que sans balais." Toulouse, INPT, 1991. http://www.theses.fr/1991INPT081H.

Full text

Abstract:

Ce memoire concerne l'utilisation des groupes a aimants permanents et commutation electronique pour le pompage photovoltaique en zone isolee. Apres definition du cahier des charges, les differentes structures d'alimentation sont presentees en relation avec les degres de liberte offerts pour l'optimisation du transfert d'energie. Puis l'auteur s'interesse particulierement a un dispositif a onduleur de courant fonctionnant en commutation naturelle. L'influence des caracteristiques propres de la machine, les lois de commande et les criteres d'adaptation pour une optimisation a un ou deux degres de liberte sont etudies par simulation. Pour le dispositif experimental, une commande numerique conviviale utilisant le langage c est developpee. Le montage est alimente par un generateur reel de 1. 5 kw ou par un simulateur programmable et entraine une pompe centrifuge debitant sur un puits de profondeur reglable. Ce systeme muni de sa commande est utilise pour valider les etudes theoriques et evaluer les lois de commande, puis pour developper une carte de commande autonome en vue d'une implantation sur site reel

APA, Harvard, Vancouver, ISO, and other styles

15

Mensi, Amira. "Analyse des pointeurs pour le langage C." Phd thesis, Ecole Nationale Supérieure des Mines de Paris, 2013. http://pastel.archives-ouvertes.fr/pastel-00944703.

Full text

Abstract:

Les analyses statiques ont pour but de déterminer les propriétés des programmes au moment de la compilation. Contrairement aux analyses dynamiques, le comportement exact du programme ne peut être connu. Par conséquent, on a recours à des approximations pour remédier à ce manque d'information. Malgré ces approximations, les analyses statiques permettent des optimisations et des transformations efficaces pour améliorer les performances des programmes. Parmi les premières analyses du processus d'optimisation figure l'analyse des pointeurs. Son but est d'analyser statiquement un programme en entrée et de fournir en résultat une approximation des emplacements mémoire vers lesquels pointent ses variables pointeurs. Cette analyse est considérée comme l'une des analyses de programmes les plus délicates et l'information qu'elle apporte est très précieuse pour un grand nombre d'autres analyses clientes. En effet, son résultat est nécessaire à d'autres optimisations, comme la propagation de constante, l'élimination du code inutile, le renommage des scalaires ainsi que la parallélisation automatique des programmes. L'analyse des pointeurs est très nécessaire pour l'exploitation du parallélisme présent dans les applications scientifiques écrites en C. Ceci est dû au fait que les tableaux, très présents dans ce type d'applications, sont accédés via les pointeurs. Il devient nécessaire d'analyser les dépendances entre les éléments de tableau dans le but de paralléliser les boucles. Le langage C présente beaucoup de difficultés lors de son analyse par la liberté qu'il offre aux utilisateurs pour gérer et manipuler la mémoire par le biais des pointeurs. Ces difficultés apparaissent par exemple lors de l'accès aux tableaux par pointeurs, l'allocation dynamique (via "malloc") ainsi que les structures de données récursives. L'un des objectifs principaux de cette thèse est de déterminer les emplacements mémoire vers lesquels les pointeurs pointent. Ceci se fait en assurant plusieurs dimensions comme : - la sensibilité au flot de contrôle, c'est-à-dire la mise à jour des informations d'un point programme à un autre ; - la non-sensibilité au contexte, c'est-à-dire l'utilisation de résumés au lieu de l'analyse du corps de la fonction à chaque appel ; - la modélisation des champs pointeurs des structures de données agrégées, dans laquelle chaque champ représente un emplacement mémoire distinct. D'autres aspects sont pris en compte lors de l'analyse des programmes écrits en C comme la précision des emplacements mémoire alloués au niveau du tas, l'arithmétique sur pointeurs ou encore les pointeurs vers tableaux. Notre travail permet l'amélioration des résultats des analyses clientes et en particulier il permet la parallélisation des boucles lorsqu'on accède aux éléments de tableaux via les pointeurs, la détection de code inutile ou le calcul du graphe de dépendances. Il est implémenté dans le compilateur parallélliseur PIPS (Parallélisation Interprocédurale de Programmes Scientifiques) et permet d'analyser, en particulier, les applications scientifiques de traitement du signal tout en assurant une analyse intraprocédurale précise et une analyse interprocédurale efficace via les résumés.

APA, Harvard, Vancouver, ISO, and other styles

16

Blatter, Lionel. "Relational properties for specification and verification of C programs in Frama-C." Thesis, Université Paris-Saclay (ComUE), 2019. http://www.theses.fr/2019SACLC065/document.

Full text

Abstract:

Les techniques de vérification déductive fournissent des méthodes puissantes pour la vérification formelle des propriétés exprimées dans la Logique de Hoare. Dans cette formalisation, également connue sous le nom de sémantique axiomatique, un programme est considéré comme un transformateur de prédicat, où chaque programme c exécuté sur un état vérifiant une propriété P conduit à un état vérifiant une autre propriété Q. Les propriétés relationnelles, de leur côté, lient un ensemble de programmes à deux propriétés. Plus précisément, une propriété relationnelle est une propriété concernant n programmes c1; ::::; cn, indiquant que si chaque programme ci commence dans un état si et termine dans un état s0 i tel que P(s1; ::::; sn) soit vérifié, alors Q(s0 1; :::; s0 n) est vérifié. Ainsi, les propriétés relationnelles invoquent tout nombre fini d’exécutions de programmes éventuellement dissemblables. De telles propriétés ne peuvent pas être exprimées directement dans le cadre traditionnel de la vérification déductive modulaire, car la sémantique axiomatique ne peut se référer à deux exécutions distinctes d’un programme c, ou à des programmes différents c1 et c2. Cette thèse apporte deux solutions à la vérification déductive des propriétés relationnelles. Les deux approches permettent de prouver une propriété relationnelle et de l’utiliser comme hypothèse dans des vérifications ultérieures. Nous modélisons ces solutions à l’aide d’un mini-langage impératif contenant des appels de procédures. Les deux solutions sont implémentées dans le contexte du langage de programmation C, de la plateforme FRAMA-C, du langage de spécification ACSL et du plugin de vérification déductive WP. Le nouvel outil, appelé RPP, permet de spécifier une propriété relationnelle, de la prouver en utilisant la vérification déductive classique, et de l’utiliser comme hypothèse dans la preuve d’autres propriétés. L’outil est évalué sur une série d’exemples illustratifs. Des expériences ont également été faites sur la vérification à l’exécution de propriétés relationnelles et la génération de contre-exemples lorsqu’une propriété ne peut être prouvée
Deductive verification techniques provide powerful methods for formal verification of properties expressed in Hoare Logic. In this formalization, also known as axiomatic semantics, a program is seen as a predicate transformer, where each program c executed on a state verifying a property P leads to a state verifying another property Q. Relational properties, on the other hand, link n program to two properties. More precisely, a relational property is a property about n programs c1; :::; cn stating that if each program ci starts in a state si and ends in a state s0 i such that P(s1; :::; sn) holds, then Q(s0 1; :::; s0 n) holds. Thus, relational properties invoke any finite number of executions of possibly dissimilar programs. Such properties cannot be expressed directly in the traditional setting of modular deductive verification, as axiomatic semantics cannot refer to two distinct executions of a program c, or different programs c1 and c2. This thesis brings two solutions to the deductive verification of relational properties. Both of them make it possible to prove a relational property and to use it as a hypothesis in the subsequent verifications. We model our solutions using a small imperative language containing procedure calls. Both solutions are implemented in the context of the C programming language, the FRAMA-C platform, the ACSL specification language and the deductive verification plugin WP. The new tool, called RPP, allows one to specify a relational property, to prove it using classic deductive verification, and to use it as hypothesis in the proof of other properties. The tool is evaluated over a set of illustrative examples. Experiments have also been made on runtime checking of relational properties and counterexample generation when a property cannot be proved

APA, Harvard, Vancouver, ISO, and other styles

17

Masliah, Ian. "Méthodes de génération automatique de code appliquées à l’algèbre linéaire numérique dans le calcul haute performance." Thesis, Université Paris-Saclay (ComUE), 2016. http://www.theses.fr/2016SACLS285/document.

Full text

Abstract:

Les architectures parallèles sont aujourd'hui présentes dans tous les systèmes informatiques, allant des smartphones aux supercalculateurs en passant par les ordinateurs de bureau. Programmer efficacement ces architectures en fonction des applications requiert un effort pluridisciplinaire portant sur les langages dédiés (Domain Specific Languages - DSL), les techniques de génération de code et d'optimisation, et les algorithmes numériques propres aux applications. Dans cette thèse, nous présentons une méthode de programmation haut niveau prenant en compte les caractéristiques des architectures hétérogènes et les propriétés existantes des matrices pour produire un solveur générique d'algèbre linéaire dense. Notre modèle de programmation supporte les transferts explicites et implicites entre un processeur (CPU) et un processeur graphique qui peut être généraliste (GPU) ou intégré (IGP). Dans la mesure où les GPU sont devenus un outil important pour le calcul haute performance, il est essentiel d'intégrer leur usage dans les plateformes de calcul. Une architecture récente telle que l'IGP requiert des connaissances supplémentaires pour pouvoir être programmée efficacement. Notre méthodologie a pour but de simplifier le développement sur ces architectures parallèles en utilisant des outils de programmation haut niveau. À titre d'exemple, nous avons développé un solveur de moindres carrés en précision mixte basé sur les équations semi-normales qui n'existait pas dans les bibliothèques actuelles. Nous avons par la suite étendu nos travaux à un modèle de programmation multi-étape ("multi-stage") pour résoudre les problèmes d'interopérabilité entre les modèles de programmation CPU et GPU. Nous utilisons cette technique pour générer automatiquement du code pour accélérateur à partir d'un code effectuant des opérations point par point ou utilisant des squelettes algorithmiques. L'approche multi-étape nous assure que le typage du code généré est valide. Nous avons ensuite montré que notre méthode est applicable à d'autres architectures et algorithmes. Les routines développées ont été intégrées dans une bibliothèque de calcul appelée NT2.Enfin, nous montrons comment la programmation haut niveau peut être appliquée à des calculs groupés et des contractions de tenseurs. Tout d'abord, nous expliquons comment concevoir un modèle de container en utilisant des techniques de programmation basées sur le C++ moderne (C++-14). Ensuite, nous avons implémenté un produit de matrices optimisé pour des matrices de petites tailles en utilisant des instructions SIMD. Pour ce faire, nous avons pris en compte les multiples problèmes liés au calcul groupé ainsi que les problèmes de localité mémoire et de vectorisation. En combinant la programmation haut niveau avec des techniques avancées de programmation parallèle, nous montrons qu'il est possible d'obtenir de meilleures performances que celles des bibliothèques numériques actuelles
Parallelism in today's computer architectures is ubiquitous whether it be in supercomputers, workstations or on portable devices such as smartphones. Exploiting efficiently these systems for a specific application requires a multidisciplinary effort that concerns Domain Specific Languages (DSL), code generation and optimization techniques and application-specific numerical algorithms. In this PhD thesis, we present a method of high level programming that takes into account the features of heterogenous architectures and the properties of matrices to build a generic dense linear algebra solver. Our programming model supports both implicit or explicit data transfers to and from General-Purpose Graphics Processing Units (GPGPU) and Integrated Graphic Processors (IGPs). As GPUs have become an asset in high performance computing, incorporating their use in general solvers is an important issue. Recent architectures such as IGPs also require further knowledge to program them efficiently. Our methodology aims at simplifying the development on parallel architectures through the use of high level programming techniques. As an example, we developed a least-squares solver based on semi-normal equations in mixed precision that cannot be found in current libraries. This solver achieves similar performance as other mixed-precision algorithms. We extend our approach to a new multistage programming model that alleviates the interoperability problems between the CPU and GPU programming models. Our multistage approach is used to automatically generate GPU code for CPU-based element-wise expressions and parallel skeletons while allowing for type-safe program generation. We illustrate that this work can be applied to recent architectures and algorithms. The resulting code has been incorporated into a C++ library called NT2. Finally, we investigate how to apply high level programming techniques to batched computations and tensor contractions. We start by explaining how to design a simple data container using modern C++14 programming techniques. Then, we study the issues around batched computations, memory locality and code vectorization to implement a highly optimized matrix-matrix product for small sizes using SIMD instructions. By combining a high level programming approach and advanced parallel programming techniques, we show that we can outperform state of the art numerical libraries

APA, Harvard, Vancouver, ISO, and other styles

18

Dong, Jing-Tong. "Localite semantique et mecanisme dlru : application au systeme nice-c++." Nice, 1992. http://www.theses.fr/1992NICE4558.

Full text

Abstract:

Le sujet de cette these s'articule autour de deux facteurs qui ont particulierement compte dans la conception physique d'un sgbd: * la comprehension du comportement de la manipulation des donnees: l'introduction de la localite semantique a pour but de faire comprendre le comportement de manipulation des donnees dans un environnement avec les structures semantiques de donnees. Dans lequel il existe un phenomene ou la reference a une page de donnees provoque souvent d'intervenir d'autres pages de donnees l'existence d'une correlation semantique de references entre ces pages. La localite semantique permet de partitionner une base de donnees en ensembles des groupes des pages. Dans chaque groupe de pages il existe une forte correlation semantique de references entre ses pages. * le choix d'un mecanisme de gestion de la memoire: le developpement du mecanisme dlru permet d'exploiter la localite semantique dans la gestion de la memoire de travail. Ce mecanisme combine un ensemble de piles de lru en assurant le maintien de piles separees pour les differents groupes de pages. La memoire de l'algorithme dlru est geree comme une pile lru a double-niveau: un ensemble de piles lru pour les pages de differents groupes et une pile lru globale pour ces differentes piles de pages. Cette etude est composee de trois parties. La premiere partie constitue un etat de l'art qui presente les mecanismes de gestion des memoires dans les systemes d'informatique. La deuxieme partie presente l'introduction de la localite semantique, le developpement du mecanisme dlru, et l'evaluation de performance de l'algorithme dlru. Quant a la troisieme partie, elle est consacree a la specification et a l'implantation de l'algorithme dlru dans le systeme nice-c++

APA, Harvard, Vancouver, ISO, and other styles

19

Ozbolt, Jean. "Etude des difficultés des étudiants de section de brevet de technicien supérieur en informatique industrielle dans l'apprentissage de la programmation en utilisant le langage C." Paris 7, 2000. http://www.theses.fr/2000PA070016.

Full text

Abstract:

Le processus d'apprentissage de la programmation faisant appel a des << savoir-faire >>, pour l'étudier, il faut collecter toutes les étapes du travail des étudiants et pas seulement le résultat final. Nous avons donc décidé de collecter leurs travaux a l'aide d'un outil logiciel, que nous avons créé, ayant comme principale caractéristique d'enregistrer en << temps réel >> toutes les actions effectuées. L'outil est un épiphyte a l'éditeur de texte, il enregistre, les dates de début et de fin de session, les commandes utilisées, l'état d'avancement du travail, etc. Ainsi, il est possible de reconstituer pas à pas le cheminement de l'étudiant lors d'une session de travaux pratiques. Il est aussi possible d'isoler les parties des travaux ou les étudiants éprouvent des difficultés. Comme il n'est pas question de mener une étude exhaustive, nous avons développe les deux points suivants : 1. Analyse statistique et factorielle de commandes d'édition spécifiques comparativement au niveau en programmation ; 2. Mise en place d'un répertoire des erreurs selon une typologie faisant intervenir :. Les erreurs associées a la phase d'apprentissage de la programmation,. Les erreurs provoquées par l'utilisation du langage C,. Les erreurs de programmation. Ce répertoire des erreurs a été établi grâce a l'étude et a l'analyse du cheminement des étudiants sur un ensemble d'exercices généraux, mais une attention particulière a été apportée a l'écriture des structures itératives (condition d'arrêt, corps de la structure). Ce travail se divise en deux parties. La première partie fait le point sur certains aspects théoriques de la didactique de l'informatique et sur la pédagogie de l'erreur. La deuxième partie est l'expérimentation aboutissant, entre autres, a la mise en œuvre du répertoire des erreurs.

APA, Harvard, Vancouver, ISO, and other styles

20

Genestier, Richard. "Vérification formelle de programmes de génération de données structurées." Thesis, Besançon, 2016. http://www.theses.fr/2016BESA2041/document.

Full text

Abstract:

Le problème général de la preuve de propriétés de programmes impératifs est indécidable. Pour deslangages de programmation et de propriétés plus restrictifs, des sous-problèmes décidables sontconnus. En pratique, grâce à des heuristiques, les outils de preuve de programmes automatisent despreuves qui sortent du cadre théorique de ces sous-problèmes décidables connus. Nous illustronscette réussite pratique en construisant un catalogue de preuves, pour des programmes et despropriétés de nature similaire et de complexité croissante. Ces programmes sont principalementdes générateurs de cartes combinatoires.Ainsi, ce travail contribue aux domaines de recherche de la combinatoire énumérative et dugénie logiciel. Nous distribuons une bibliothèque C de générateurs exhaustifs bornés de tableauxstructurés, formellement spécifiés en ACSL et vérifiés avec le greffon WP de la plateforme d’analyseFrama-C. Nous proposons également une méthodologie de test qui facilite la preuve interactive enCoq, une étude formelle des cartes originale, et de nouveaux résultats en combinatoire énumérative
The general problem of proving properties of imperative programs is undecidable. Some subproblems– restricting the languages of programs and properties – are known to be decidable. Inpractice, thanks to heuristics, program proving tools sometimes automate proofs for programs andproperties living outside of the theoretical framework of known decidability results. We illustrate thisfact by building a catalog of proofs, for similar programs and properties of increasing complexity. Mostof these programs are combinatorial map generators.Thus, this work contributes to the research fields of enumerative combinatorics and softwareengineering. We distribute a C library of bounded exhaustive generators of structured arrays, formallyspecified in ACSL and verified with the WP plugin of the Frama-C analysis platform. We also proposea testing-based methodology to assist interactive proof in Coq, an original formal study of maps, andnew results in enumerative combinatorics

APA, Harvard, Vancouver, ISO, and other styles

21

Alias, Christophe. "Optimisation de programmes par reconnaissance de templates." Versailles-St Quentin en Yvelines, 2005. https://tel.archives-ouvertes.fr/tel-01892198.

Full text

Abstract:

La plupart des optimisations appliquent des transformations locales bas-niveau, sans se soucier du calcul exprimé par le programme. Bien que ces optimisations produisent des résultats satisfaisants, elles ne sont pas encore suffisantes, et amènent bien souvent le programmeur à utiliser des bibliothèques optimisées. Pour le moment, les bibliothèques optimisées doivent être appelées à la main. Apprendre et utiliser une nouvelle bibliothèque est malheureusement très fastidieux, et il est surprenant de voir le peu d’aide apporté par le compilateur. Une solution naturelle serait de chercher les occurrences immédiates des fonctions d’une bibliothèque dans le programme, et de les remplacer par l’appel correspondant. Dans cette thèse, nous proposons une approche totalement automatique pour reconnaitre dans un programme les occurrences des fonctions d’une bibliothèque optimisée, et les substituer par l’appel de fonction lorsque c’est possible et intéressant. Notre méthode est capable de détecter toutes les tranches de programme équivalentes aux fonctions recherchées au sens de l'équivalence de Herbrand, un sous-ensemble de l'équivalence sémantique qui ne tient pas compte de la sémantique des opérations atomiques. En plus des fonctions, nous sommes capables de trouver des instances de templates dans un programme. Une telle caractéristique rend possible la reconnaissance de bibliothèques de templates, et la réécriture d'un programme pour utiliser des templates. Une fois les instances trouvées dans le programme, il reste à sélectionner les candidats dont le remplacement par un appel de fonction est possible et améliore effectivement les performances du programme. Nous proposons également un algorithme pour sélectionner les substitutions valides, et pour générer le code avec la substitution. La sélection du bon ensemble de substitution se fait par un système de notes. Deux autres solutions expérimentales basées sur du benchmarking sont proposées, l’une décrivant exhaustivement l’espace des substitutions, et l’autre testant les substitutions en suivant une approche gloutonne. Notre approche a été implémentée dans l'outil TeMa (Template Matcher). TeMa représente plus de 17000 lignes de code C++ et OCaml, et a été appliqué à la détection des fonctions de la bibliothèque BLAS (Basic Linear Algebra Subroutines) dans les noyaux des benchmarks SpecFP 2000 et Perfect ClubLes résultats expérimentaux montrent un facteur d'accélération substantiel sur les noyaux swim, mgrid et mdg
Most of compiler optimization techniques apply local transformations on the code, replacing sub-optimal fragments with better ones. They are often low-level, and applied without knowing what the code is supposed to do. Unfortunately, these optimizations are not enough to produce an optimal code, and lead the programmer to use performance libraries. For the moment, the library functions must be called by hand. However, learning and using a new library remains fastidious, and it is surprising how little the compiler helps the programmer in this task. A natural solution would be to search naïve occurrences of library functions through the program, and to replace them by the corresponding call. In this thesis, we propose a fully automatic approach to recognize occurrences of library functions in a program. In this thesis, we propose a fully automatic approach to recognize occurrences of library functions in a program, and to substitute them, whenever it is possible and interesting, by a call to the library. Our approach is able to recognize all the program slices computing the same mathematical formula than the searched function. This allow to cope with organization, data structure and control variations, and more generally with any program transformation which does not take operators properties (associativity, commutativity, ect…) into account. In addition to functions descriptions, we are also able to find template instances in the source code. Such a characteristic enable the recognition of template libraries, and the rewriting of a program to use templates. Once the proper instances are found within the program, it remains to select the slices whose replacement by a library call is possible, and interesting. We propose a complete algorithmic framework to select all valid substitutions, and to generate the corresponding code. To select a good substitution set, we propose a preliminary solution based on a system of marks. Two other experimental approaches based on benchmarking are also investigated. Our approach has been implemented in the TeMa tool (Teplate Matcher). TeMa represents more than 17000 lines of code, and was applied to the detection of the BLAS functions (Basic Linear Algebra Subroutines) within the kernels of the SpecFP 2000 and thePerfect Club benchmarks. Experimental results report a substantial acceleration factor for the kernels sim, mgrid and applu

APA, Harvard, Vancouver, ISO, and other styles

22

Monat, Raphaël. "Static type and value analysis by abstract interpretation of Python programs with native C libraries." Electronic Thesis or Diss., Sorbonne université, 2021. http://www.theses.fr/2021SORUS263.

Full text

Abstract:

Dans cette thèse, nous avons pour objectif de concevoir, à la fois théoriquement et expérimentalement, des méthodes pour la détection automatique de bogues potentiels dans les logiciels – ou la preuve de leur absence. Ces méthodes sont statiques : elles analysent le code source des programmes sans les exécuter. Nos travaux s’inscrivent dans le cadre de l’interprétation abstraite pour dériver une sémantique sûre et décidable. Le principal objet de ce travail est l’analyse des langages de programmation dynamiques. En particulier, ce travail se concentre sur les programmes écrits en Python, qui peuvent appeler des bibliothèques écrites en C
In this thesis, we aim at designing both theoretically and experimentally methods for the automatic detection of potential bugs in software – or the proof of the absence thereof. This detection is done statically by analyzing programs’ source code without running them. We rely on the abstract interpretation framework to derive sound, computable semantics. In particular, we focus on analyzing dynamic programming languages. The target of this work is the analysis of Python programs combined with native C libraries

APA, Harvard, Vancouver, ISO, and other styles

23

Cassé, Hugues. "Analyse des références mémoires en C par interprétation abstraite." Toulouse 3, 2001. http://www.theses.fr/2001TOU30205.

Full text

APA, Harvard, Vancouver, ISO, and other styles

24

Pélissier, Gilles. "Méthodologies de conception conjointe logicielle/matérielle." Montpellier 2, 2002. http://www.theses.fr/2002MON20055.

Full text

APA, Harvard, Vancouver, ISO, and other styles

25

Garrier, Yves. "Spécification d'un service objet CORBA de gestion de persistance introduisant une indépendance totale entre un langage d'implémentation et des bases de données hétérogènes." Versailles-St Quentin en Yvelines, 1996. http://www.theses.fr/1996VERS0010.

Full text

Abstract:

Les compagnies manipulant de grands volumes d'informations ont l'aide d'applications distribuées ont récemment migré vers des architectures multi-niveaux. Ceci, ajouté à la popularité croissante des technologies objets a conduit à l'émergence de systèmes objets distribués comme common object request broker architecture (CORBA). Corba, au travers de l'object request broker (ORB) agit comme un bus de communication pour les méthodes mais la gestion des données n'est pas incluse dans la spécification de base. L'intégration de bases de données est une priorité pour nombre de compagnies. Il en est de même de la portabilité des applications entre supports de stockage et la réutilisation des données existantes. Ces points ont été pris en compte dans la thèse. Plusieurs standards ou solutions existent pour gérer la persistance des objets. Nous proposons au travers d'une étude comparative, une spécification compatible avec les standards rassemblant les points forts des systèmes existants. La valeur ajoutée vient de l'intégration et de la fusion des standards et des implémentations de vendeurs comme IBM, SUN, IONA. Cette fusion couvre l'ensemble de la problématique de gestion de la persistance. Nous avons réutilisé le modèle odmg comme modeler canonique, l'object définition language (ODL) pour décrire le schéma de façon indépendante. Nous avons également spécifié comment publier sur un ORB les concepts d'odl, décrit un dictionnaire extensible, réutilise et étendu les interfaces du service et mis en oeuvre une correspondance vers c++ qui fusionne celles de l'omg et de l'odmg. Nous avons enfin décrit le processus de développement lors de l'utilisation du service, en considérant l'intégration de données hétérogènes ou la génération de schéma dans le cas de système nouveau

APA, Harvard, Vancouver, ISO, and other styles

26

Estérie, Pierre. "Multi-Architectural Support : A Generic and Generative Approach." Thesis, Paris 11, 2014. http://www.theses.fr/2014PA112124/document.

Full text

Abstract:

Le besoin constant de puissance de calcul a poussé les développeurs à concevoir de nouvelles architectures: les architectures parallèles. Le calcul scientifique dépend fortement des performances de ces dernières afin de fournir des résultats dans un temps optimal. Les applications scientifiques exécutées sur de tels systèmes doivent alors tirer partie des spécificités de ces nouvelles architectures pour être efficaces.Cette thèse présente une nouvelle approche pour la conception de logiciels embarquant des optimisations relatives aux architectures : l'approche AADEMRAL (Architecture Aware DEMRAL). Cette méthodologie a pour but de simplifier le développement de bibliothèques de calcul parallèle avec un support multi-Architectural grâce à une approche générique et générative.Cette nouvelle méthodologie est ensuite intégrée dans trois bibliothèques. La première d'entre elles, Boost.Dispatch, permet de concevoir des logiciels basés sur l'approche AADEMRAL. Boost.Dispatch est une bibliothèque C++fournissant une interface générique pour réaliser de la surcharge de fonction avisée de l'architecture sous-Jacente. Ensuite nous présentons deux bibliothèques C++ implémentées en tant que langages orientés domaine : Boost.SIMD et NT2. Leurs conceptions mettent en œuvre la méthodologie AADEMRAL et leurs implémentations sont basées sur Boost.Dispatch. Boost.SIMD propose une interface de haut niveau pour la programmation des unités vectorielles.NT2 se base sur une interface similaire à celle de Matlab et fournie un support pour les systèmes multi-Cœurs et les unités vectorielles. Enfin, nous validons les performances de ces deux outils ainsi que la robustesse de notre nouvelle approche en présentant une série de résultats obtenus sur des applications de référence
The constant increasing need for computing power has pushed the development of parallel architectures. Scientific computing relies on the performance of such architectures to produce scientific results. Programming efficient applications that takes advantage of these computing systems remains a non trivial task. In this thesis, we present a new methodology to design architecture aware software: the AA-DEMRAL methodology. This methodology aims at simplifying the development of parallel programming tools with multi-Architectural support through a generic and generative approach. We then present three high level programming tools that rely on this approach. First, we introduce the Boost.Dispatch library that provides a way to develop software based on the AA-DEMRAL methodology. The Boost.Dispatch library is a C++ generic framework for architecture aware function dispatching. Then, we present two C++ template libraries implemented as Architecture Aware DSELs which assess the AA-DEMRAL methodology through the use of Boost.Dispatch: Boost.SIMD, that provides a high level API for SIMD extensions and NT2 , which propose a Matlab like interface with support for multi-Core and SIMD based systems. We assess the performance of these libraries and the validity of our new methodology through benchmarks

APA, Harvard, Vancouver, ISO, and other styles

27

Félix, Patrick. "Implémentation centralisée de C. S. P : étude de théorique et réalisation." Bordeaux 1, 1988. http://www.theses.fr/1988BOR10558.

Full text

Abstract:

La semantique du langage csp est precisee en associant a tout programme csp un automate csp. Une implementation centralisee de ce langage est decrite. Une methode formelle permettant de montrer que cette implementation respecte la semantique definie precedemment est proposee

APA, Harvard, Vancouver, ISO, and other styles

28

Valvassori, Moïse. "Modélisation et programmation d'ordinateurs amorphes : de l'ordinateur amorphe à la machine Blob." Paris 8, 2009. http://octaviana.fr/document/158471954#?c=0&m=0&s=0&cv=0.

Full text

Abstract:

We present new methods of configurations of computers said amorphous to equip them of capabilities of duplication and developments. Inspired by their self-organizational aspects, especially during their embryonic development, we apply our methods of configurations on specialized calculations. Our research have three contributions : An amorphous computer simulator. An amorphous computer is a set of static elementary processors, spatially distributed and whose omnidirectionally communicate over short distances with their neighborhoods. All the computing elements contain the same program and their computing and storage resources are assumed low. We have build the fastest amorphous computer simulator at the moment. We simulate amorphous computers made of more than processing elements. -A low level aspect and component oriented language for amorphous programming and its compiler. We call this programming language Tical. Programming a amorphous computer is to specialize their computing elements when the program starts in order to distribute the computing power and the data. Our approach to amorphous programming is inspired by biology and cell biology development. We began by exploring a multi-agent model of P-systems (membrane computing) using the Fungus simulation platform. Learning from this experience, we develop Tical, our domain specific language. It partitions the program in a library of (reusable) components. The concerns of an amorphous program are represented by aspects : initialization, messages handling, reaction to some states, the conventional program. Tical programs compile into a equivalent C program. The low-level algorithms implemented in this language are : gradient generation, leader election, aggregation and data propagation. -Three high-level primitives of the Blob abstract machine. We propose an implementation three primitives of the Blob abstract machine in our language. An Blob abstract machine is an abstract parallel machine spatially organized to perform its calculations. A blob is a group of computing elements. The blobs are organized hierarchically and may be linked. The high-level primitives are formation of a blob from dispersed computing elements, the creation of communication channels and duplication of a blob into two blobs. All these implementations are inspired from developmental biology : symmetry breaking by gradients, chemotaxis and mitosis. The following document is organized in five parts. In the first chapter, we introduce our goals and our position in the field of amorphous computing. In Chapter 2, we present a state of the art of programming amorphous and spatial computing. Chapter 3 presents Tical, our low-level aspect and component oriented programming language and low level primitives. The first part of this chapter presents the design model of the language and the simulator that runs programs. We present the aspect oriented programming, then we detail the standard aspects of our language. The Tical component model and the process of compiling programs to Tical simulations are widely developed. We finish this chapter with examples of our language and construction of low-level primitives commonly cited in the literature. Chapter 4 presents the implementation of high-level primitives Blob. After a presentation the Blob abstract machine, we present the implementation of our three primitives : blob construction, linking of two blobs, duplication of a blob. Chapter 5 presents a conclusion of all of our contributions and proposes a synthesis of our perspectives
Nous présentons des méthodes nouvelles de configurations des ordinateurs dits amorphes qui les doteront de capacités de duplications et d’évolutions. Inspirés par leurs aspects auto-organisationnels, notamment lors de leur embryogenèse, nous appliquerons nos méthodes de configurations en fonction de calculs spécialisés. Notre recherche comporte trois contributions : Un simulateur d’ordinateurs amorphes. Un ordinateur amorphe est un ensemble de processeurs élémentaires statiques, spatialement distribués et communiquant sur de courtes distances de manière omnidirectionnelle avec leurs voisinages. Les éléments de calcul contiennent tous le même programme et leurs capacités de calculs et de stockages sont supposées faibles. Nous avons réalisé le simulateur d’ordinateurs amorphes le plus véloce à l’heure actuelle. Nous simulons ainsi des ordinateurs amorphes composés de plus de éléments de calcul. -Un langage pour la programmation amorphe bas niveau orienté aspect et composant ainsi que son compilateur. Nous appelons Tical ce langage de programmation. La programmation d’un ordinateur amorphe consiste à spécialiser les éléments de calcul au début de l’exécution du programme afin de distribuer les informations et la puissance de calcul. Notre approche de la programmation amorphe est inspirée de la biologie cellulaire et de la biologie du développement. Nous avons commencé par explorer un modèle multi-agents de P-systems (calcul par membranes) à l’aide de la plate-forme de simulation Fungus que nous avons réalisé à cet effet. À partir des enseignements de cette expérience, nous développons Tical, notre langage dédié. Il découpe le programme en une bibliothèque de composants (réutilisables). Les différentes facettes d’un programme amorphe y sont représentées par des aspects : initialisation, réaction aux messages, réaction à certains états, programme traditionnel. Le programme ainsi exprimé est compilé vers un programme C équivalent. Les algorithmes de bas niveau implémentés à l’aide de ce langage sont : création de gradient, élection de leader, agrégation et propagation d’informations. -Trois primitives haut niveau de la machine abstraite Blob. Nous proposons une implémentation des trois primitives de la machine abstraite Blob dans notre langage. Une machine abstraite Blob est une machine parallèle abstraite s’organisant spatialement pour y effectuer ses calculs. Un blob est alors un groupe d’éléments de calcul. Les blobs sont organisés hiérarchiquement et peuvent être liés entre eux. Les primitives de haut niveau que nous développons comprennent la constitution d’un blob à partir d’éléments de calcul dispersés, la création de canaux de communication et la duplication d’un blob en deux blobs. Toutes ces implémentations sont inspirées de la biologie du développement : rupture de symétrie par des gradients, chimiotaxie et mitose. La suite du document est organisée en cinq parties. Dans le premier chapitre, nous introduisons nos objectifs ainsi que notre position dans le domaine des ordinateurs amorphes. Dans le chapitre 2, nous exposons un état de l’art de la programmation amorphe et du calcul dans l’espace. Le chapitre 3 présente Tical, notre langage de bas niveau orienté aspect et composant et les primitives bas niveaux. La première partie de ce chapitre présente le modèle de conception du langage ainsi que le simulateur qui exécute les programmes. Nous présentons la programmation par aspect, puis nous détaillons les aspects standards de notre langage. La présentation du modèle de composant de Tical ainsi que le processus de compilation des programmes Tical vers les simulations sont ensuite largement développés. Nous finissons ce chapitre en présentant des exemples de notre langage et la construction de primitives bas niveau couramment évoqués dans la littérature. Le chapitre 4 présente l’implémentation des primitives de haut niveau Blob. Après une présentation de la machine abstraite Blob, nous présentons l’implémentation de nos trois primitives : constitution d’un blob, liaison de deux blobs, duplication d’un blob. Le chapitre 5 présente une conclusion de l’ensemble de nos contributions et propose une synthèse des perspectives faisant suite à nos travaux

APA, Harvard, Vancouver, ISO, and other styles

29

Wilke, Pierre. "Compilation formellement vérifiée de code C de bas-niveau." Thesis, Rennes 1, 2016. http://www.theses.fr/2016REN1S088/document.

Full text

Abstract:

Cette thèse présente une extension du compilateur CompCert permettant de fournir des garanties formelles de préservation sémantique à des programmes auxquels CompCert n'en donne pas. CompCert est un compilateur pour le langage C vers différentes architectures qui fournit, en plus d'un exécutable compilé, des garanties formelles concernant le comportement du programme assembleur généré. En particulier, tout programme C ayant une sémantique définie selon le standard C est compilé en un programme assembleur équivalent, c'est-à-dire qui a la même sémantique. En revanche, ce théorème n'assure aucune garantie lorsque le programme source n'a pas de sémantique définie : on parle en C de comportement indéfini. Toutefois, des programmes C issus de réels projets largement utilisés contiennent des comportements indéfinis. Cette thèse détaille dans un premier temps un certain nombre d'exemples de programmes C qui déclenchent des comportements indéfinis. Nous argumentons que ces programmes devraient tout de même bénéficier du théorème de préservation sémantique de CompCert, d'abord parce qu'ils apparaissent dans de vrais projets et parce que leur utilisation des comportements indéfinis semble légitime. Dans ce but, nous proposons d'abord un modèle mémoire pour CompCert qui définit l'arithmétique arbitraire de pointeurs et la manipulation de données non initialisées, à l'aide d'un formalisme de valeurs symboliques qui capturent la sémantique d'opérations non définies dans le standard. Nous adaptons l'intégralité du modèle mémoire de CompCert avec ces valeurs symboliques, puis nous adaptons les sémantiques formelles de chacun des langages intermédiaires de CompCert. Nous montrons que ces sémantiques symboliques sont un raffinement des sémantiques existantes dans CompCert, et nous montrons par ailleurs que ces sémantiques capturent effectivement le comportement des programmes sus-cités. Enfin, afin d'obtenir des garanties similaires à celles que CompCert fournit, nous devons adapter les preuves de préservation sémantique à notre nouveau modèle. Pour ce faire, nous généralisons d'importantes techniques de preuves comme les injections mémoire, ce qui nous permet de transporter les preuves de CompCert sur nos nouvelles sémantiques. Nous obtenons ainsi un théorème de préservation sémantique qui traite plus de programmes C
This thesis presents an extension of the CompCert compiler that aims at providing formal guarantees about the compilation of more programs than CompCert does. The CompCert compiler compiles C code into assembly code for various architectures and provides formal guarantees about the behaviour of the compiled assembly program. It states that whenever the C program has a defined semantics, the generated assembly program behaves similarly. However, the theorem does not provide any guarantee when the source program has undefined semantics, or, in C parlance, when it exhibits undefined behaviour, even though those behaviours actually happen in real-world code. This thesis exhibits a number of C idioms, that occur in real-life code and whose behaviour is undefined according to the C standard. Because they happen in real programs, our goal is to enhance the CompCert verified compiler so that it also provides formal guarantees for those programs. To that end, we propose a memory model for CompCert that makes pointer arithmetic and uninitialised data manipulation defined, introducing a notion of symbolic values that capture the meaning of otherwise undefined idioms. We adapt the whole memory model of CompCert with this new formalism and adapt the semantics of all the intermediate languages. We prove that our enhanced semantics subsumes that of CompCert. Moreover, we show that these symbolic semantics capture the behaviour of the previously undefined C idioms. The proof of semantic preservation from CompCert needs to be reworked to cope with our model. We therefore generalize important proof techniques such as memory injections, which enable us to port the whole proof of CompCert to our new memory model, therefore providing formal guarantees for more programs

APA, Harvard, Vancouver, ISO, and other styles

30

Ramananandro, Tahina. "Les objets en C + + : sémantique formelle mécanisée et compilation vérifiée." Phd thesis, Université Paris-Diderot - Paris VII, 2012. http://tel.archives-ouvertes.fr/tel-00769044.

Full text

Abstract:

C++ est un des langages de programmation les plus utilisés en pratique, y compris pour le logiciel embarqué critique. C'est pourquoi la vérication de programmes écrits en C++ devient intéressante, en particulier via l'utilisation de méthodes formelles. Pour cela, il est nécessaire de se fonder sur une sémantique formelle de C++. De plus, une telle sémantique formelle peut être validée en la prenant comme base pour la spécication et la preuve d'un compilateur C++ réaliste, afin d'établir la confiance dans les techniques usuelles des compilateurs C++. Dans cette thèse, nous nous focalisons sur le modèle objet de C++. Nous proposons une sémantique formelle de l'héritage multiple en C++ comprenant les structures imbriquées à la C, sur laquelle s'appuie notre étude de la représentation concrète des objets avec optimisations des bases vides, à travers des conditions suffisantes que nous prouvons correctes vis-à-vis des accès aux champs et des opérations polymorphes. Puis nous spécifions un algorithme de représentation en mémoire fondé sur l'ABI pour Itanium, et une extension de cet algorithme avec optimisations des champs vides, et nous prouvons qu'ils satisfont nos conditions. Nous obtenons alors un compilateur vérifié et réaliste d'un sous-ensemble de C++ vers un langage à trois adresses et accès mémoire de bas niveau. Rajoutant à notre sémantique la construction et la destruction d'objets, nous étudions leurs interactions avec l'héritage multiple. Cela nous permet de formaliser la gestion de ressources, notamment le principe RAII (resource acquisition is initialization) via l'ordre de construction et destruction des sous-objets. Nous étudions aussi les effets sur les opérations polymorphes telles que la sélection de fonction virtuelle pendant la construction et la destruction, en généralisant la notion de type dynamique. Nous obtenons alors un compilateur vérifié pour notre sémantique étendue, notamment en prouvant la correction de l'implémentation des changements de types dynamiques. Toutes nos spécifications et preuves sont formalisées en Coq.

APA, Harvard, Vancouver, ISO, and other styles

31

Hajjam, El Hassani Amir. "Iac++ : un environnement interactif de programmation orientée objet dirigée par une assistance intelligente pour la réutilisation de composants logiciels." Mulhouse, 1990. http://www.theses.fr/1990MULH0154.

Full text

Abstract:

IAC++ est un environnement partagé de programmation orientée objet pour le langage C++. Il est conçu dans le but de faciliter le prototypage et de permettre ainsi une amélioration de la productivité du logiciel sous le système UNIX. Son architecture se compose de deux parties bien distinctes, communiquant via le protocole TCP/IP : 1) l'environnement serveur, constitué par une base de composants logiciels, construite à partir de la librairie de classes C++ de Keith Gorlen, une couche de gestion de ces composants et un serveur basé sur les sockets, objets définis dans la version 4. 2 BSD du système UNIX ; 2) l'environnement client, constitué par une interface utilisateur, un module de gestion du dialogue avec le serveur et une assistance intelligente implémentée sous forme de système expert. IAC++ offre un environnement de développement multifenêtré. Il propose trois schémas de classification, afin d'offrir aux utilisateurs, suivant leur niveau de connaissance de l'environnement trois modes de visualisation différents de la base de composants. Une aide, suivant le concept d'hypertexte, facilite l'utilisation de l'environnement et l'apprentissage du C++, et permet aux utilisateurs de documenter leurs applications. Le travail en équipe est pris en compte et facilite, notamment sur l'automatisation de certaines tâches répétitives telles que la génération de chaînes de production. Pour pallier les problèmes de la recherche et de l'évaluation des composants logiciels, IAC++ propose une assistance intelligente. Elle a la capacité de suivre l'évolution de l'environnement et d'offrir une aide correspondant à l'état réel de la base de composants

APA, Harvard, Vancouver, ISO, and other styles

32

Gautron, Philippe. "UNIX et multiprocessus, C++ et multitâche : une approche logicielle de la simulation et de l'improvisation dans le jazz." Paris 11, 1985. http://www.theses.fr/1985PA112261.

Full text

Abstract:

Cette thèse traite l'approche logicielle de l'improvisation dans le jazz et tire profit pour cela des ressources d'un système d'exploitation, UNIX et d'un langage Orienté Objets, C++. L'architecture conceptuelle repose sur une double ossature parallèle : multiprocessus pour la synchronisation des voies musicales, multitâche pour la gestion des accords (notes simultanées) propres à chaque voie. Ces techniques de programmation ont permis l'élaboration de trois logiciels dans des domaines rythmiques différents : blues tempo rapide et lent, ballad.

APA, Harvard, Vancouver, ISO, and other styles

33

Levillain, Roland. "Towards a software architecture for generic image processing." Phd thesis, Université Paris-Est, 2011. http://pastel.archives-ouvertes.fr/pastel-00673121.

Full text

Abstract:

In the context of software engineering for image processing (IP), we consider the notion of reusability of algorithms. In many software tools, an algorithm's implementation often depends on the type of processed data. In a broad definition, discrete digital images may have various forms : classical 2D images, 3D volumes, non-regular graphs, cell complexes, and so on : thus leading to a combinatorial explosion of the theoretical number of implementations. Generic programming (GP) is a framework suited to the development of reusable software tools. We present a programming paradigm based on GP designed for the creation of scientific software such as IP tools. This approach combines the benefits of reusability, expressive power, extensibility, and efficiency. We then propose a software architecture for IP using this programming paradigm based on a generic IP library. The foundations of this framework define essential IP concepts, enabling the development of algorithms compatible with many image types. We finally present a strategy to build high-level tools on top of this library, such as bridges to dynamic languages or graphical user interfaces. This mechanism has been designed to preserve the genericity and efficiency of the underlying software tools, while making them simpler to use and more flexible

APA, Harvard, Vancouver, ISO, and other styles

34

Lemarie, Sylvie. "Etude et réalisation d'un système réparti fondé sur les acteurs." Paris 6, 1992. http://www.theses.fr/1992PA066225.

Full text

Abstract:

Le but de cette thèse est de réaliser un système réparti supportant un environnement de programmation dédié à la mise au point d'applications réparties. Cette thèse prend appui sur Actalk pour sa flexibilité qui permet de modéliser tous langages / systèmes d'acteurs. Actalk offre également un environnement de programmation très complet grâce à son système hôte smalltalk qui s'exécute sur un unique processeur. La machine cible de notre système réparti est une machine parallèle à mémoire non partagée. Les réalisations présentées pour passer de l'exécution concurrente d'une application écrite en actalk à son exécution en réparti reposent sur la transformation de actalk en un système réparti. Dans l'optique langages d'acteurs et parallélisme, nous avons transposé actalk dans un langage existant sur la machine parallèle, c++. Cette réalisation met en évidence le comportement des acteurs dans un langage compilé et type statiquement. La seconde partie de cette thèse consiste à répartir des noyaux actalk / smalltalk sur la machine parallèle afin que les applications écrites en actalk puissent s'exécuter simultanément. Cette réalisation est fondée sur la coopération de systèmes concurrents à travers la connexion de plusieurs smalltalk supportant actalk. L'introduction de la concurrence dans smalltalk comme fonctionnalité de base est obtenue par l'intégration de l'envoi de message asynchrone. La coopération entre les systèmes concurrents prend appui sur la gestion des objets distants

APA, Harvard, Vancouver, ISO, and other styles

35

Chamont, David. "Architecture logicielle pour la simulation des transferts radiatifs." Nancy 1, 1997. http://docnum.univ-lorraine.fr/public/SCD_T_1997_0254_CHAMONT.pdf.

Full text

Abstract:

La synthèse d'images est fondée depuis quelques années sur des bases physiques et mathématiques plus rigoureuses, notamment la modélisation des propriétés radiatives des surfaces et la simulation par éléments finis des transferts radiatifs entre ces surfaces. Une telle évolution permet d'envisager de nouvelles applications industrielles, en particulier en ingénierie de l'éclairage. Ce mémoire présente une architecture logicielle à base d'objets, conçue pour soutenir la recherche dans les disciplines évoquées ci-dessus et faciliter le développement de prototypes industriels. Elle repose d'une part sur une bibliothèque de classes abstraites tirées de l'équation de transfert, d'autre part sur un système de fichiers et de programmes calqués sur les étapes et les taches d'une simulation. A travers différents projets de recherche et plusieurs applications, nous montrons comment notre architecture a été mise en œuvre avec succès, en particulier pour évaluer de nouveaux modèles d'émission ou de réflexion de la lumière. Nous discutons également ses lacunes dans la représentation des algorithmes et la mise en œuvre du paradigme objet.

APA, Harvard, Vancouver, ISO, and other styles

36

Vieira, De Mello Aline. "Tlmdt : une stratégie de modélisation basée sur temps distribué pour la simulation prallèle de systèmes multi-processeurs intégrés sur puce." Paris 6, 2013. http://www.theses.fr/2013PA066201.

Full text

Abstract:

Les architectures matérielles innovantes dans l’industrie de la microélectronique se caractérisent principalement par leur niveau incroyablement élevé de parallélisme. Plusieurs environnements de conception industriels et académiques sont apparus pour aider dans la modélisation, la simulation et la mise au point de “Massively Parallel Multi-Processors System on Chip” (MP2SoCs). Le langage de description matérielle SystemC est le point commun de tous ces environnements. La bibliothèque SystemC de classes C++ permet de décrire le matériel à différents niveaux d’abstraction, allant de RTL synthétisable à la modélisation de niveau transactionnel (TLM). Cependant, quand il s’agit de simuler une architecture contenant des centaines de processeurs, même la vitesse de simulation fourni par l’approche TLM n’est pas suffisante. Simultanément, les stations de travail multi-coeur sont de plus acessible au grand public. Malheureusement, le noyau de simulation SystemC est entièrement séquentiel et ne peut pas exploiter la puissance de traitement offerte par ces machines multi-coeurs. L’objectif stratégique de cette thèse est de proposer une approche de modélisation avec temps, pour les architectures numériques multi-processeurs complexes à mémoire partagée, appelée modélisation au niveau transaction avec temps distribué (TLM-DT). L’idée principale de l’approche TLM-DT est de ne plus utiliser le temps global de simulation SystemC, rendant ainsi possible l’utilisation d’un moteur de simulation véritablement parallèle et permettant une réduction significative du temps de simulation avec une perte limitée de précision
Innovative hardware architectures in the microelectronics industry are mainly characterized by their incredibly high level of parallelism. Despite their relative novelty, Multi-Processors System on Chip (MPSoCs) containing a few cores tend to be replaced by Massively Parallel MPSoCs (MP2SoCs), which integrate dozens or hundreds of processor cores interconnected through a possibly hierarchical network on chip. Several industrial and academic frameworks appeared to help modeling, simulating and debugging MP2SoC architectures. The SystemC hardware description language is the effective backbone of all these frameworks, which allows to describe the hardware at various levels of abstraction, ranging from synthesizable RTL (more accurate and very slow) to TLM (less accurate and very fast). However, when it comes to simulate an architecture containing hundreds of processors, even the simulation speed brought by TLM is not enough. Simultaneously, multi-core workstations are becoming the mainstream. Unfortunately, the genuine SystemC simulation kernel is fully sequential and cannot exploit the processing power provided by these multi-cores machines. In this context, the strategic goal of this thesis is to propose a general modeling approach for timed TLM virtual prototyping of shared memory MP2SoCs, called Transaction Level Modeling with Distributed Time (TLM-DT). The main idea of the TLM-DT approach is not to use anymore the SystemC global simulation time, becoming possible to use a truly parallel simulation engine and providing a significant reduction in simulation time with a limited loss of precision

APA, Harvard, Vancouver, ISO, and other styles

37

Roynard, Michaël. "Generic programming in modern C++ for Image Processing." Electronic Thesis or Diss., Sorbonne université, 2022. https://theses.hal.science/tel-03922670.

Full text

Abstract:

C++ est un langage de programmation multi-paradigme qui permet au développeur initié de mettre au point des algorithmes de traitement d'images. La force de langage se base sur plusieurs aspects. C++ est haut-niveau, cela signifie qu'il est possible de développer des abstractions puissantes mélangeant plusieurs styles de programmation pour faciliter le développement. En même temps, C++ reste bas-niveau et peut pleinement tirer partie du matériel pour fournir un maximum de performances. Il est aussi portable et très compatible ce qui lui permet de se brancher à d'autres langages de haut niveau pour le prototypage rapide tel que Python ou Matlab. Un des aspects les plus fondamentaux où le C++ brille, c'est la programmation générique. La programmation générique rend possible le développement et la réutilisation de briques logiciel comme des objets (images) de différentes natures (types) sans avoir de perte au niveau performance. Néanmoins, il n'est pas trivial de concilier les aspects de généricité, de performance et de simplicité d'utilisation. Le C++ moderne (post-2011) amène de nouvelles fonctionnalités qui le rendent plus simple et plus puissant. Dans cette thèse, nous explorons en premier un aspect particulier du C++20 : les concepts, dans le but de construire une taxonomie des types relatifs au traitement d'images. Deuxièmement, nous explorons une autre fonctionnalité ajoutée au C++20 : les ranges (et les vues). Nous appliquons ce design aux algorithmes de traitement d'images et aux types d'image, dans le but résoudre les problèmes liés, notamment, à la difficulté qu'il existe pour customiser les algorithmes de traitement d'image. Enfin, nous explorons les possibilités concernant la façon dont il est possible de construire un pont entre du code C++ générique statique (compile-time) et du code Python dynamique (runtime). Nous fournissons une solution hybride et nous mesurons ses performances. Nous discutons aussi les pistes qui peuvent être explorées dans le futur, notamment celles qui concernent les technologies JIT. Étant donné ces trois axes,nous voulons résoudre le problème concernant la conciliation des aspects de généricité, de performance et de simplicité d'utilisation
C++ is a multi-paradigm language that enables the initiated programmer to set up efficient image processing algorithms. This language strength comes from several aspects. C++ is high-level, which enables developing powerful abstractions and mixing different programming styles to ease the development. At the same time, C++ is low-level and can fully take advantage of the hardware to deliver the best performance. It is also very portable and highly compatible which allows algorithms to be called from high-level, fast-prototyping languages such as Python or Matlab. One of the most fundamental aspects where C++ really shines is generic programming. Generic programming makes it possible to develop and reuse bricks of software on objects (images) of different natures (types) without performance loss. Nevertheless,conciliating the aspects of genericity, efficiency, and simplicity is not trivial. Modern C++ (post-2011) has brought new features that made the language simpler and more powerful. In this thesis, we first explore one particular C++20aspect: the concepts, in order to build a concrete taxonomy of image related types and algorithms. Second, we explore another addition to C++20, ranges (and views), and we apply this design to image processing algorithms and image types in order to solve issues such as how hard it is to customize/tweak image processing algorithms. Finally, we explore possibilities regarding how we can offer a bridge between static (compile-time) generic C++ code and dynamic (runtime) Python code. We offer our own hybrid solution and benchmark its performance as well as discuss what can be done in the future with JIT technologies. Considering those three axes, we will address the issue regarding the way to conciliate generic programming, efficiency and ease of use

APA, Harvard, Vancouver, ISO, and other styles

38

Cornea, Bogdan Florin. "Prédiction de performances d’applications de calcul distribué exécutées sur une architecture pair-à-pair." Thesis, Besançon, 2011. http://www.theses.fr/2011BESA2012/document.

Full text

Abstract:

Dans le domaine du calcul de haute performance, les architectures d’exécution sont en continuelle évolution. L’augmentation du nombre de nœuds de calcul, ou le choix d’une topologie réseau plus rapide représentent un investissement important tant en temps qu’en moyen financier. Les méthodes de prédiction de performances permettent de guider ce choix. En parallèle à ce développement, les systèmes HPC pair-à-pair (P2P) se sont également développés ces dernières années. Ce type d’architecture hétérogène permettrait la résolution des problèmes scientifiques pour un coût très faible par rapport au coût d’une architecture dédiée.Ce manuscrit présente une méthode nouvelle de prédiction de performances pour les applications réelles de calcul distribué, exécutées dans des conditions réelles. La prédiction prend en compte l’optimisation du compilateur. Les résultats sont extrapolables et ils sont obtenus pour un ralentissement réduit. Ce travail de recherche est implémenté dans un logiciel nouveau nommé dPerf. dPerf est capable de prédire les performances des applications C, C++ ou Fortran qui communiquent en utilisant les normes MPI ou P2P-SAP et qui s’exécutent sur une architecture cible pair à pair, hétérogène et décentralisée. La précision de cette contribution a été étudiée sur (i) la transformée Laplace, pour l’aspect séquentiel, (ii) le benchmark IS de NAS, pour l’aspect MPI, (iii) et le code de l’obstacle pour l’aspect calcul P2P décentralisé et l’extrapolation du nombre de nœuds
In the field of high performance computing, the architectures evolve continuously. In order to increase the number of computing nodes or the network speed, an important investment must be considered, from both temporal and financial point of view. Performance prediction methods aim at assisting in finding the best trade-off for such an investment. At the same time, P2P HPC systems have known an increase in development. These heterogeneous architectures would allow solving scientific problems at a low cost, with respect to dedicated systems.The manuscript presents a new method for performance prediction. This method applies to real applications for distributed computing, considered in a real execution environment. This method uses information about the different compiler optimization levels. The prediction results are obtained with reduced slowdown and are scalable. This thesis took shape in the development of the dPerf tool. dPerf predicts the performances of C, C++, and Fortran application, which use MPI or P2P-SAP to communicate. The applications modeled by dPerf are meant for execution on P2P heterogeneous architectures, with a decentralized communication topology. The accuracy of dPerf has been studied on three applications: (i) the Laplace transform, for sequential codes, (ii) the NAS Integer Sort benchmark for distributed MPI programs, (iii) and the obstacle problem, for the decentralized P2P computing and the scaling of the number of computing nodes

APA, Harvard, Vancouver, ISO, and other styles

39

Gasmi, Bernadette. "Safir : système d'assemblage flexible intelligent multi-robots." Toulouse, ENSAE, 1990. http://www.theses.fr/1990ESAE0014.

Full text

Abstract:

Ce mémoire de thèse présente un environnement de programmation pour une cellule flexible d'assemblage multi-robots: SAFIR. Il comprend un mode hors-ligne qui correspond à l'interface opérateur (spécification des graphes d'assemblage contenant plusieurs plans d'assemblage d'un même produit; instanciation des bases de données concernant les pièces à assembler et les liaisons existant entre elles) et un mode en-ligne qui gère et supervise l'exécution des tâches d'assemblage de manière dynamique. L'objectif est de s'adapter, en temps réel, à l'évolution de la cellule (retard de pièces, pannes de ressources,. . . ). SAFIR utilise une approche distribuée des connaissances sur les pièces, les ressources, les tâches d'assemblage, etc. . . Son implémentation s'appuie sur les concepts de programmation orientée objet (encapsulation et niveau d'abstraction des données).

APA, Harvard, Vancouver, ISO, and other styles

40

Khammassi, Nader. "High-level structured programming models for explicit and automatic parallelization on multicore architectures." Thesis, Lorient, 2014. http://www.theses.fr/2014LORIS350/document.

Full text

Abstract:

La prolifération des architectures multi-coeurs est source d’unepression importante pour les developpeurs, qui doivent chercherà paralléliser leurs applications de manière à profiter au mieux deces plateformes. Malheureusement, les modèles de programmationde bas niveau amplifient les difficultés inhérentes à la conceptiond’applications complexes et parallèles. Il existe donc une attentepour des modèles de programmation de plus haut niveau, quipuissent simplifier la vie des programmeurs de manière significative,tout en proposant des abstractions suffisantes pour absorberl’hétérogénéité des architectures matérielles.Contrairement à une multitude de modèles de programmation parallèlequi introduisent de nouveaux langages, annotations ou étendentdes langages existants et requièrent donc des compilateurs spécialisés,nous exploitons ici le potentiel du language C++ standardet traditionnel. En particulier nous avons recours à ses capacitésen terme de meta-programmation, afin de fournir au programmeurune interface de programmation parallèle simple et directe. Cetteinterface autorise le programmeur à exprimer le parallélismede son application au prix d’une altération négligeable du codeséquentiel initial. Un runtime intelligent se charge d’extraire touteinformation relative aux dépendances de données entre tâches,ainsi que celles relatives à l’ordonnancement. Nous montronscomment ce runtime est à même d’exploiter ces informations dansle but de détecter et protéger les données partagées, puis réaliserun ordonnancement prenant en compte les particularités des caches.L’implémentation initiale de notre modèle de programmation est unelibrairie C++ pure appelée XPU. XPU est conÃ˘gue dans le but defaciliter l’explicitation, par le programmeur, du parallélisme applicatif.Une seconde réalisation appelée FATMA doit être considérée commeune extension d’XPU qui permet une détection automatique desdépendances dans une séquence de tâches : il s’agit donc de parallélisationautomatique, sans recours à quelque outil que se soit,excepté un compilateur C++ standard. Afin de démontrer le potentielde notre approche, nous utilisons ces deux outils –XPU et FATMA–pour paralléliser des problèmes populaires, ainsi que des applicationsindustrielles réelles. Nous montrons qu’en dépit de leur abstractionélevée, nos modèles de programmation présentent des performancescomparables à des modèles de programmation de basniveau,et offrent un meilleur compromis productivité-performance
The continuous proliferation of multicore architectures has placeddevelopers under great pressure to parallelize their applicationsaccordingly with what such platforms can offer. Unfortunately,traditional low-level programming models exacerbate the difficultiesof building large and complex parallel applications. High-level parallelprogramming models are in high-demand as they reduce the burdenson programmers significantly and provide enough abstraction toaccommodate hardware heterogeneity. In this thesis, we proposea flexible parallelization methodology, and we introduce a newtask-based parallel programming model designed to provide highproductivity and expressiveness without sacrificing performance.Our programming model aims to ease expression of both sequentialexecution and several types of parallelism including task, data andpipeline parallelism at different granularity levels to form a structuredhomogeneous programming model.Contrary to many parallel programming models which introducenew languages, compiler annotations or extend existing languagesand thus require specialized compilers, extra-hardware or virtualmachines..., we exploit the potential of the traditional standardC++ language and particularly its meta-programming capabilities toprovide a light-weight and smart parallel programming interface. Thisprogramming interface enable programmer to express parallelismat the cost of a little amount of extra-code while reuse its legacysequential code almost without any alteration. An intelligent run-timesystem is able to extract transparently many information on task-datadependencies and ordering. We show how the run-time system canexploit these valuable information to detect and protect shared dataautomatically and perform cache-aware scheduling.The initial implementation of our programming model is a pure C++library named "XPU" and is designed for explicit parallelism specification.A second implementation named "FATMA" extends XPU andexploits the transparent task dependencies extraction feature to provideautomatic parallelization of a given sequence of tasks withoutneed to any specific tool apart a standard C++ compiler. In order todemonstrate the potential of our approach, we use both of the explicitand automatic parallel programming models to parallelize popularproblems as well as real industrial applications. We show thatdespite its high abstraction, our programming models provide comparableperformances to lower-level programming models and offersa better productivity-performance tradeoff

APA, Harvard, Vancouver, ISO, and other styles

41

Zacklad, Manuel. "Principes de modélisation qualitative pour l'aide à la décision dans les organisations : méthode d'utilisation du logiciel d'acquisition des connaissances C-KAT." Compiègne, 1993. http://www.theses.fr/1993COMPD633.

Full text

Abstract:

La thèse décrit une méthode d'aide à l'acquisition des connaissances guidée par le modèle de la classification heuristique et un langage de modélisation des connaissances du domaine : KAL. Cette méthode est supportée par un logiciel, C-KAT, développé en Smalltalk, qui génère semi-automatiquement une base de règles à partir de taxinomies (réseaux sémantiques) décrivant le domaine. Elle présente un exemple d'application dans le domaine de l'analyse de risque incendie.

APA, Harvard, Vancouver, ISO, and other styles

42

Gratien, Jean-Marc. "A DSEL in C++ for lowest-order methods for diffusive problem on general meshes." Thesis, Grenoble, 2013. http://www.theses.fr/2013GRENM018/document.

Full text

Abstract:

Les simulateurs industriels deviennent de plus en plus complexes car ils doivent intégrer de façon performante des modèles physiques complets et des méthodes de discrétisation évoluées. Leur mise au point nécessite de gérer de manière efficace la complexité des modèles physiques sous-jacents, la complexité des méthodes numériques utilisées, la complexité des services numériques de bas niveau nécessaires pour tirer parti des architectures matérielle modernes et la complexité liée aux langages informatiques. Une réponse partielle au problème est aujourd'hui fournie par des plate-formes qui proposent des outils avancés pour gérer de façon transparente la complexité liée au parallélisme. Cependant elles ne gèrent que la complexité du matériel et les services numériques de bas niveau comme l'algèbre linéaire. Dans le contexte des méthodes Éléments Finis (EF), l'existence d'un cadre mathématique unifié a permis d'envisager des outils qui permettent d'aborder aussi la complexité issue des méthodes numériques et celle liée aux problèmes physiques, citons, par exemple, les projets Freefem++, Getdp, Getfem++, Sundance, Feel++ et Fenics. Le travail de thèse a consisté à étendre cette approche aux méthodes d'ordre bas pour des systèmes d'EDPs, méthodes qui souffraient jusqu'à maintenant d'une absence d'un cadre suffisamment général permettant son extension à des problèmes différents. Des travaux récents ont résolue cette difficulté, par l'introduction d'une nouvelle classe de méthodes d'ordre bas inspirée par les éléments finis non conformes. Cette formulation permet d'exprimer dans un cadre unifié les schémas VF multi-points et les méthodes DFM/VFMH. Ce nouveau cadre a permis la mise au point d'un langage spécifique DSEL en C++ qui permet de développer des applications avec un haut niveau d'abstraction, cachant la complexité des méthodes numériques et des services bas niveau garanties de haute performances. La syntaxe et les techniques utilisées sont inspirée par celles de Feel++. Le DSEL a été développé à partir de la plate-forme Arcane, et embarqué dans le C++. Les techniques de DSEL permettent de représenter un problème et sa méthode de résolution avec une expression, parsée à la compilation pour générer un programme, et évaluée à l'exécution pour construire un système linéaire que l'on peut résoudre pour trouver la solution du problème. Nous avons mis au point notre DSEL à l'aide d'outils standard issus de la bibliothèque Boost puis l'avons validé sur divers problèmes académiques non triviaux tels que des problèmes de diffusion hétérogène et le problème de Stokes. Dans un deuxième temps, dans le cadre du projet ANR HAMM (Hybrid Architecture and Multiscale Methods), nous avons validé notre approche en complexifiant le type de méthodes abordées et le type d'architecture matérielle cible pour nos programmes. Nous avons étendu le formalisme mathématique sur lequel nous nous basons pour pouvoir écrire des méthodes multi-échelle puis nous avons enrichi notre DSEL pour pouvoir implémenter de telles méthodes. Afin de pouvoir tirer partie de façon transparente des performances de ressources issues d'architectures hybrides proposant des cartes graphiques de type GPGPU, nous avons mis au point une couche abstraite proposant un modèle de programmation unifié qui permet d'accéder à différents niveaux de parallélisme plus ou moins fin en fonction des spécificités de l'architecture matérielle cible. Nous avons validé cette approche en évaluant les performances de cas tests utilisant des méthodes multi-échelle sur des configurations variés de machines hétérogènes. Pour finir nous avons implémenté des applications variées de type diffusion-advection-réaction, de Navier-Stokes incompressible et de type réservoir. Nous avons validé la flexibilité de notre approche et la capacité qu'elle offre à appréhender des problèmes variés puis avons étudié les performances des diverses implémentations
Industrial simulation software has to manage : the complexity of the underlying physical models, usually expressed in terms of a PDE system completed with algebraic closure laws, the complexity of numerical methods used to solve the PDE systems, and finally the complexity of the low level computer science services required to have efficient software on modern hardware. Nowadays, this complexity management becomes a key issue for the development of scientific software. Some frameworks already offer a number of advanced tools to deal with the complexity related to parallelism in a transparent way. However, all these frameworks often provide only partial answers to the problem as they only deal with hardware complexity and low level numerical complexity like linear algebra. High level complexity related to discretization methods and physical models lack tools to help physicists to develop complex applications. New paradigms for scientific software must be developed to help them to seamlessly handle the different levels of complexity so that they can focus on their specific domain. Generative programming, component engineering and domain-specific languages (either DSL or DSEL) are key technologies to make the development of complex applications easier to physicists, hiding the complexity of numerical methods and low level computer science services. These paradigms allow to write code with a high level expressive language and take advantage of the efficiency of generated code for low level services close to hardware specificities. In the domain of numerical algorithms to solve partial differential equations, their application has been up to now limited to Finite Element (FE) methods, for which a unified mathematical framework has been existing for a long time. Such kinds of DSL have been developed for finite element or Galerkin methods in projects like Freefem++, Getdp, Getfem++, Sundance, Feel++ and Fenics. A new consistent unified mathematical frame has recently emerged and allows a unified description of a large family of lowest-order methods. This framework allows then, as in FE methods, the design of a high level language inspired from the mathematical notation, that could help physicists to implement their application writing the mathematical formulation at a high level. We propose to develop a language based on that frame, embedded in the C++ language. Our work relies on a mathematical framework that enables us to describe a wide family of lowest order methods including multiscale methods based on lowest order methods. We propose a DSEL developed on top of Arcane platform, based on the concepts presented in the unified mathematical frame and on the Feel++ DSEL. The DSEL is implemented with the Boost.Proto library by Niebler, a powerful framework to build a DSEL in C++. We have proposed an extension of the computational framework to multiscale methods and focus on the capability of our approach to handle complex methods.Our approach is extended to the runtime system layer providing an abstract layer that enable our DSEL to generate efficient code for heterogeneous architectures. We validate the design of this layer by benchmarking multiscale methods. This method provides a great amount of independent computations and is therefore the kind of algorithms that can take advantage efficiently of new hybrid hardware technology. Finally we benchmark various complex applications and study the performance results of their implementations with our DSEL

APA, Harvard, Vancouver, ISO, and other styles

43

Bennegadi, Karim. "Étude et réalisation d'opérateurs câblés pour le traitement d'images en temps réel." Compiègne, 1990. http://www.theses.fr/1990COMPD263.

Full text

Abstract:

Afin de permettre une réalisation aisée d'opérateurs de traitement d'image câblés, un environnement autonome matériel et logiciel a été développé. Pour intégrer ces opérateurs dans un seul système, pour en faciliter la maintenance et pour normaliser les extensions pour d'autres opérateurs, un bus image matériel a été mis au point, reliant les sources possibles d'images que sont une carte d'acquisition vidéo ainsi que le bus d'un ordinateur hôte, à l'ensemble des opérateurs câblés. Un ensemble de routines logicielles groupées sous forme de deux librairies, l'une présentant une interface utilisateur graphique évoluée, capable de se superposer à l'image, et l'autre comprenant une boîte à outils logiciels permettant de faciliter l'intégration de nouveaux traitements, l'extension du langage interprété déjà disponible pour l'environnement ainsi que la méthodologie de câblage d'un opérateur logiciel. L'environnement matériel basé sur le bus image permet des débits élevés grâce à un fonctionnement synchrone. La partie logicielle a été écrite en langage C pour en faciliter la portabilité et la modularité
In order to facilitate the realisation of the hardware processing units in image analysis and pattern recognition, an autonomous environment was designed. To group these hardware units in a single system, to ease their extension and to normalize them for modularity purpose, a hardware image bus was designed, creating the link between different image sources as video digitizing cards or computer buses, and the set of hardware processing units. A full software package that consists in two libraries, complete the hardware part. The first library presents an enhanced user interface that can overlay the image, and the second is a software toolbox used to ease new routines integration, user interface extension and provides a methodology to translate algorithms from software form to hardware form. The hardware bus based part, provides a high data transfer rate using synchronous mode, and the software part is written in C language for modularity and portability purposes

APA, Harvard, Vancouver, ISO, and other styles

44

Voegtlin, Marc. "Procédé de génération d'objets pour la création d'applications interactives adaptables." Mulhouse, 1991. http://www.theses.fr/1991MULH0181.

Full text

Abstract:

Le thème de recherche abordé dans cette thèse concerne le développement rapide et sans difficulté d'applications interactives en langage C++ ciblées sur un système de fenêtrage ouvert comme X-Window (X11). Ceci pour satisfaire des besoins de prototypage et d'adaptabilité, tout en ayant la puissance d'un langage compilé et compatible avec les objectifs du génie logiciel. Dans une première partie, nous présentons une étude générale du domaine des interfaces utilisateurs avec un état de l'art sur les systèmes de fenêtrages, les langages et modèles orientés objets d'applications interactives, ainsi que les outils de construction d'interface utilisateur. La seconde partie du travail traite la conception d'un mécanisme facilitant le prototypage et l'adaptabilité des applications interactives en C++. Ce mécanisme, inspiré en partie de l'environnement de MacIntosh dont la convivialité n'est plus à démontrer, repose sur un nouveau concept de ressource. La méthode utilise le gestionnaire de ressources primitif existant sur X11 et définit un procédé de génération d'objets dans le sens de la programmation orientée objet, à partir d'une description sous forme de ressources. Il sera ainsi possible de créer des objets de façon dynamique qui seront adaptables sans passer par une phase de compilation. Le mécanisme, valable pour les objets C++ en général, est appliqué en particulier aux objets interactifs de la boite à outils d'interface utilisateur InterViews qui est exploitable en C++ au-dessus de X11. Ceci permettra de construire des applications interactives de manière plus conviviale en apportant des aspects de prototypage et d'adaptabilité au langage C++

APA, Harvard, Vancouver, ISO, and other styles

45

Girard, Pierre. "Formalisation et mise en œuvre d'une analyse statique de code en vue de la vérification d'applications sécurisées." Toulouse, ENSAE, 1996. http://www.theses.fr/1996ESAE0010.

Full text

Abstract:

Dans le domaine de la sécurité informatique, de nombreux travaux théoriques concernent les modèles et les règlements de sécurité en se situant très en amont des systèmes réellement implémentés. Cette thèse s'appuie sur les bases théoriques offertes par ces travaux pour fonder une méthode de vérification statique de logiciels applicatifs. Nous proposons pour cela des algorithmes d'analyse qui s'appliquent aux programmes sources et nous démontrons qu'ils sont corrects en les dérivant d'un modèle de sécurité formel. Ils sont utilisés concrètement pour analyser des programmes écrits en langage C. Après une présentation de la problématique de sécurité informatique, nous effectuons un inventaire des menaces et des attaques récemment constatées et nous montrons qu'il existe un besoin en matière de validation statique de logiciels existants. Nous proposons ensuite une méthodologie de vérification de programmes écrits en langage C par annotation de leur code source puis analyse automatique de celui-ci. Dans une seconde partie, nous cherchons à démontrer la correction des algorithmes d'analyse. Pour cela, nous partons d'un modèle formel de sécurité : le modèle de la causalité. Nous le modifions pour en faire un modèle calculatoire, puis nous l'appliquons à la sémantique opérationnelle d'un langage impératif. Nous démontrons alors que l'analyse de la sécurité, exprimée comme une sémantique non standard du langage, est correcte par rapport au modèle de sécurité. Nous examinons enfin les difficultés pratiques posées par l'analyse statique du langage C. Nous nous attachons à analyser ses particularités en termes de structures de donnée et de structures de contôle. Nous proposons des techniques pour résoudre les problèmes posés, en particulier par les variables de type pointeur et les instructions déstructurantes de type saut inconditionnel.

APA, Harvard, Vancouver, ISO, and other styles

46

Sallenave, Olivier. "Contribution à l'efficacité des programmes orientés objet pour processeurs embarqués." Thesis, Montpellier 2, 2012. http://www.theses.fr/2012MON20120.

Full text

Abstract:

Les systèmes embarqués sont largement utilisés de nos jours. Pour des raisons d'efficacité, les plus contraints en termes de ressources sont toujours programmés en C et en assembleur. L'adoption de langages de plus haut niveau tels que C# ou Java offrirait plus d'abstraction au programmeur, ce qui réduirait les temps de développement et par conséquent le coût de ces systèmes. Certains d'entre eux ont déjà migré vers de tels langages, comme les téléphones mobiles ou les tablettes tactiles, mais ils sont équipés d'une grande quantité de mémoire externe et ne reflètent pas la majorité des systèmes embarqués.Cette thèse s'intéresse à l'implémentation de Java et .NET pour l'embarqué, et plus spécifiquement à la compilation efficace du polymorphisme. Ce polymorphisme génère un certain coût à l'exécution, comme des indirections dans le cas des appels de méthodes (polymorphisme d'inclusion), ou de la duplication de code dans le cas de la généricité (polymorphisme paramétrique). De nombreuses techniques d'implémentation ont été proposées, notamment pour Java. Il reste cependant à identifier lesquelles sont applicables pour le type de systèmes que nous ciblons, et à en concevoir de nouvelles pour certains aspects comme la généricité. Nous partons du principe que les techniques globales (hypothèse du monde clos) sont les mieux adaptées. Par l'analyse de types, nous détectons qu'une partie importante des programmes est monomorphe et qu'elle peut donc être compilée sans surcoût. Pour implémenter le polymorphisme restant, nous choisissons la technique la mieux adaptée au matériel cible. Nous proposons également une implémentation de la généricité qui est adaptée aux systèmes embarqués. D'après nos évaluations, l'impact négatif du polymorphisme sur l'efficacité est largement réduit. L'efficacité du code optimisé devrait s'approcher de celle du C, et les techniques que nous employons pourraient être applicables dans le contexte plus général du chargement dynamique
Nowadays, embedded systems are ubiquitous. For efficiency reasons, most constrained systems are still programmed in C and assembly. Adopting higher-level languages such as C# or Java should enhance the level of abstraction offered to programmers and reduce development time and cost for these systems. A small part of them have migrated to such languages, like smartphones and tablet computers, but they have a large amount of external memory available and do not represent the majority of embedded systems.This thesis focuses on the implementation of Java and .NET for embedded systems, and more especially on the efficient compilation of polymorphism. Polymorphism generates an overhead at run-time, such as indirections when methods are invoked (inclusion polymorphism) or code duplication in the case of generics (parametric polymorphism). Many implementation techniques have been proposed, especially for Java. However, it remains to identify which ones are applicable in the context of low-end embedded systems. We consider that whole program optimization (closed-world assumption) is well-suited in this context. Using type analysis, we observe that most part of programs is monomorph, therefore it can be compiled with no overhead with respect to C. In order to implement the remaining polymorphism, we choose the technique which is better suited for the target hardware. We also propose an appropriate implementation of run-time generics. Our results show that the negative impact of polymorphism is mostly reduced. The efficiency of the optimized code should be comparable with C, and the techniques we employ could be applicable in the context of dynamic loading (open-world assumption)

APA, Harvard, Vancouver, ISO, and other styles

47

Gratien, Jean-Marc. "A Domain Specific Embedded Language in C++ for lowest-order methods for diffusive problem on general meshes." Phd thesis, Université de Grenoble, 2013. http://tel.archives-ouvertes.fr/tel-00926232.

Full text

Abstract:

La spécificité des logiciels scientifiques développés par IFP Energies nouvelles tient avant tout à l'originalité des modèles représentant les situations physiques exprimés sous forme de systèmes d'EDPs assortis de lois de fermeture complexes. Le développement de ces logiciels, conçus pour être exécutés sur les super calculateurs parallèles modernes, nécessite de combiner des méthodes volumes finis robustes et efficaces avec des technologies informatiques qui permettent de tirer au mieux parti de ces calculateurs (parallélisme, gestion de la mémoire, réseaux d'interconnexion, etc). Ces technologies de plus en plus sophistiquées ne peuvent plus être maîtrisées dans leur ensemble par les chercheurs métiers chargés d'implémenter des nouveaux modèles. Dans ce rapport nous proposons un langage spécifique aux méthodes de discrétisation Volumes Finis permettant le prototypage rapide de codes industriels ou de recherche. Nous décrivons le cadre mathématique sur lequel nous nous basons ainsi que la mise au point du nouveau langage. Les travaux out été validés sur des problèmes académiques puis par le prototypage d'une application industrielle dans le cadre de l'axe ''CO2 maîtrisé''.

APA, Harvard, Vancouver, ISO, and other styles

48

Алексахіна, Тетяна Олексіївна, Татьяна Алексеевна Алексахина, Tetiana Oleksiivna Aleksakhina, and A. Krivodub. "La langage de programmation." Thesis, Вид-во СумДУ, 2009. http://essuir.sumdu.edu.ua/handle/123456789/16780.

Full text

APA, Harvard, Vancouver, ISO, and other styles

49

Samyn, Mickaël. "Une simulation fonctionnelle d'un système monopuce dédié au traitement du signal intensif : une approche dirigée par les modèles." Lille 1, 2005. https://ori-nuxeo.univ-lille1.fr/nuxeo/site/esupversions/9eec6f23-301f-4b30-b5b0-73be4f4ad924.

Full text

Abstract:

Ces quelques dernières années, le monde de la conception des systèmes monopuces a subi un très grand bouleversement. D'une part, la puissance des nouvelles applications fait que les nouveaux systèmes doivent incorporer de nombreuses ressources hétérogènes. D'autre part, les nouvelles technologies permettent d'incorporer de plus en plus de composants sur une même surface de silicium. Les méthodes de conception actuelles, basées sur l'expérience des concepteurs pour choisir les différentes architectures, ne permettent plus de suivre l'évolution des technologies, d'autant plus que la durée de vie des systèmes est de plus en plus courte, alors que le temps de mise sur le marché et le coût de conception ne font qu'augmenter. L'approche adoptée dans cette thèse s'inscrit dans un projet global de co-modélisation et co-conception appelé Gaspard. Elle vise à remédier, même partiellement à ces nouvelles exigences. La méthodologie est basée sur les principes de l'architecture dirigée sur les modèles (MDA), et plus particulièrement la partie traitant de la simulation et de l'analyse de performances à un haut niveau d'abstraction. Dans cette thèse, un métamodèle, permettant la modélisation des systèmes, est décrit. Ensuite, une méthodologie de génération de code, utilisant des moteurs de transformations, est utilisée afin de générer le code nécessaire à la simulation du système modélisé. Enfin, une présentation des différents critères retenus pour l'estimation du système est faite.

APA, Harvard, Vancouver, ISO, and other styles

50

Delpech, Nicolas. "Architecture orientée objet de contrôle-commande de robots." Toulouse, ENSAE, 1994. http://www.theses.fr/1994ESAE0002.

Full text

Abstract:

Le travail que nous proposons porte sur l'introduction des concepts objet dans le développement des architectures de contrôle/commande de robots. Dans une première partie, nous passons en revue certaines approches structurelles caractéristqiues d'architectures de commande. Nous étudions également certaines solutions au problème de l'intégration du modèle objet dans les systèmes de commande temps-réel. Ensuite, nous proposons un environnement de programmation d'applications temps-réel reposant sur un modèle étendu du modèle objet standard (qui est dans notre cas, celui du langage C++) adapté aux environnements parallèles et distribués et amenant à la définition d'un modèle agent exécutif. Il s'appuie sur un système de communication permettant l'envoi de messages (communication par objets partagés) et l'invocation distante des agents (communication par objets image). Nous avons dû définir un schéma de développement de logiciels plus adapté au modèle objet proposé. Il repose sur une phase de modélisation de l'application sous forme d'objets passifs qui sont, dans une deuxième phase, distribués dans des agents exécutifs. Chacune de ces phases comprend un niveau générique aux systèmes de commande et un niveau spécifique aux applications développées. Pour valider l'ensemble de ces concepts, nous avons développé les sytèmes de contrôle/commande de deux applications robotiques : un site de téléopération reposant sur la commande hybride position/force et un site de robotique mobile composé d'une plateforme supportant un bras manipulateur à six degrés de liberté.

APA, Harvard, Vancouver, ISO, and other styles

Dissertations / Theses on the topic 'C (langage de programmation)'

Create a spot-on reference in APA, MLA, Chicago, Harvard, and other styles