Talk abstract
From LRDE
This is a property of type Text.
S
Dans la recherche multimédia basée contenu, on distingue trois champs d'applications différents : la recherche de cible dans laquelle on désire retrouver un document particulier ; la recherche interactive, dans laquelle l'utilisateur définit l'objet de la requête au fil de son interaction avec le système ; et la catégorisation, où il s'agit d'étiqueter les données en un certain nombre de classes prédéfinies.
Cette présentation fera le tour d'horizon de mes travaux de recherche dans deux de ces domaines. Une première partie concernera la recherche de cible, où je présenterai le cas particulier de la recherche de quasi-copies dans de très grands volumes de données, et en particulier une application à la recherche de scènes urbaines identiques dans le cadre du projet iTowns.
Dans la deuxième partie, je développerai mes travaux récents sur la classification d'images. L'accent y sera mis sur la fusion de descripteurs multimédias et les techniques d'apprentissage statistique permettant d'apprendre conjointement l'opération de fusion avec la fonction de classification. +
L'idée d'une fonction est que la quantité d'entrée détermine complètement la quantité de sortie. En informatique, la quantité est une structure de données qui peut être simple, booléenne, entière, ou complexe, image, graphe, arbre. Dans ce domaine, un champ de recherche est de construire un ensemble de fonctions élémentaires, puis par composition d'en créer des plus compliquées. Pour cette dernière, une solution pratique est le langage Caméléon conçu par V. Tariel et O. Cugnon de Sevricourt, qui est un langage de flux de données génériques dont la sortie est prévue en janvier 2011. Générique signifie que tous les types de données peuvent être intégrés dans le langage. Pour cette première, ce séminaire couvrira quelques définitions de fonctions primaires reliées à l'image, incorporées à la bibliothèque standard de Caméléon. A la manière de l'implémentation de la bibliothèque standard du C++, il y aura l'utilisation d'un côté de l'algorithme générique for\_each en typage statique et de l'autre des opérateurs et des itérateurs organisés en programmation orientée objet. L'itérateur localise l'action suivant différents paradigmes : ensemble fini et dénombrable, voisinage, convolution, zone d'influence. L'opérateur agit suivant différents paradigmes : arithmétique, croissance de régions. +
Depuis 2000, on assiste à un regain d'intérêt pour les langages typés dynamiquement
regroupés sous la bannière "langage de script". Pour les langages de script les plus
populaires, comme PHP, Python ou Ruby, il existe, en plus des implantations
écrites en C, des implantations plus récentes utilisant des environnements
comme la machine virtuelle Java (JVM) ou la plateforme .Net.
Ces implantations sont souvent plus efficaces que les implantations historiques,
pourtant, ces environnements d'exécution utilisent des langages intermédiaires
typés statiquement qui sont peu propices à l'implantation de langage typé dynamiquement.
Partant de ce constat, le Java Community Process a créé la JSR 292 intitulée
"Supporting Dynamically Typed Languages on the JavaTM Platform" dont le but
est de proposer une API facilitant l'implantation et les performances des
langages de script sur une machine virtuelle Java.
Mon exposé se compose de deux parties.
Dans un premier temps, en tant que membre du groupe d'experts, j'essaierai de restituer
de façon didactique les concepts introduits par la JSR 292 en expliquant les tenants et les aboutissants.
La seconde partie, plus personnelle, montrera comment développer l'environnement
d'exécution d'un langage de script en utilisant les outils fournis par la JSR 292.
Je m'appuierai pour cela sur un prototype de langage que j'ai développé et nommé
PHP.reboot. +
Nous étudions la problématique du mélange de paradigmes de programmation
variés plongés dans un environnement concurrent. Dans cette
perspective, nous poursuivons
un cheminement similaire à celui qui conduit du lambda-calcul aux
langages fonctionnels, mais
en prenant comme point de départ le π-calcul. Nous proposons la
machine abstraite des π-threads
dont la principale originalité est l’absence de pile d’exécution.
Cette caractéristique
permet de nous reposer dans nos implémentations sur des algorithmes
simples et naturellement
concurrents, notamment pour ce qui concerne l’ordonnancement et le
ramasse-miettes. Pour ce
dernier, nous proposons un algorithme permettant de récupérer très
simplement les cycles de
processus en interblocage et autres structures bloquantes. +
La plupart des bibliothèques génériques en traitement d’images mettent l’accent sur la généricité, la mise en pipeline d’opérations basiques, mais peu mettent l’accent sur la sélection d’un sous-ensemble de pixels concerné par un algorithme. En pratique de nombreux algorithmes ne s’appliquent que sur un sous-ensemble simple (rectangle) ou complexe (forme contiguë quelconque) de pixels qui ne sont qu’une petite fraction d’une image. La création d’un masque précisant les pixels concernés ne semble pas une solution optimale (contrainte mémoire et calculatoire). Dans le cadre de développement d’algorithmes en traitement d’images et vidéos, le laboratoire Canon Research Centre France (localisé à Rennes) développe une bibliothèque générique de traitement d’images qui ajoute la notion de forme à toute manipulation basique ou complexe d’une image. Une « arithmétique » des formes permet une sélection précise de pixels et une exécution efficace d’algorithme complexe. Les motivations, la mise en œuvre de cette bibliothèque, les outils template utilisés seront présentés et illustrés d’exemples concrets. +
Pour encoder de manière efficace une séquence vidéo, la redondance
temporelle est souvent utilisée. Pour cela, le mouvement entre l'image
considérée et une image de référence est estimé. Cela permet de
générer une prédiction à partir de l'image de référence et seule la
différence entre la prédiction et l'image réelle est enregistrée. Pour
estimer ce mouvement, les codecs se contentent souvent de suivre
l'évolution spatiale de blocs dans l'image. Ils associent, pour chaque
bloc de l'image considérée, un bloc similaire dans un voisinage proche
dans l'image de référence. Nous présentons ici une méthode originale
pour réaliser cette prédiction par compensation de mouvement. Notre
méthode utilise les distances tangentes. Cela permet non seulement
d'estimer l'évolution de la position des blocs de l'image mais en
partie aussi l'évolution du bloc lui-même. Nos prédictions sont donc
de meilleure qualité. Utilisée dans l'encodage de séquences, on peut
espérer un gain de compression non négligeable. Pour valider
l'efficacité de la méthode, nous intégrons cette méthode dans le codec
Theora et mesurons son efficacité en comparant les résultats obtenus
avec notre méthode et ceux obtenus par une stratégie classique (le
block-matching). +
Ces dernières années ont vu exploser le nombre de vidéos disponibles
sur internet. Pour permettre leur exploitation, il est nécessaire de
mettre en place des systèmes analysant automatiquement ces données
multimédia. De tels systèmes permettent notamment d'indexer
automatiquement des vidéos en fonction de leurs contenus. Durant
cette présentation, je m'intéresserai aux récentes avancées effectuées
dans ce domaine. Je présenterai des descripteurs vidéos, développés
dans le cadre de ma thèse, qui capturent le mouvement et l'apparence
d'une vidéo pour les résumer dans une courte signature. Ces
signatures peuvent être utilisées a posteriori pour détecter
différents évènements ou concepts dans les vidéos. +, Conçus à l'origine pour le rendu 2D et 3D, les processeurs graphiques
(GPU) peuvent aujourd'hui être considérés comme des processeurs
génériques massivement parallèles. Mais ce parallélisme impose des
contraintes sur les algorithmes implantés et les types de données
utilisés. D'autre part, le bus de communication entre le processeur
central (CPU) et le GPU peut être un goulot d'étranglement.
Ce séminaire débutera par un aperçu des avantages et inconvénients de
la programmation GPU, puis je présenterai l'implantation d'un
algorithme temps réel de suivi de points dans une vidéo. Je terminerai
par l’introduction de deux petites boîtes à outils : Cuimg et Dige.
Cuimg utilise C++ pour simplifier l'écriture d'algorithmes de
traitement d'images avec CUDA, tandis que Dige, basée sur le framework
Qt, permet le prototypage rapide d'interfaces graphiques. +
Dans ce séminaire je présenterai un algorithme de résolution approchée
pour le problème du Compressive Sensing basé sur la programmation convexe.
Cet algorithme a la particularité d'avoir été pensé dès sa conception pour
tirer partie des architectures matérielles modernes, ce qui permet une
implémentation efficace et rapide sur celles-ci. Bien qu'une résolution
approchée soit en pratique suffisante pour obtenir rapidement une solution
de très bonne qualité, une variante exacte très rapide sera aussi
présentée. Cette dernière n'est toutefois utilisable que sous certaines
conditions. Trois types d'architectures parallèles sont ici envisagées :
des processeurs multi-cœurs avec unités de calcul vectoriel, des
processeurs graphiques (GPU) et le processeur Cell. +
Comment Javascript, un langage dynamique, interprété et non typé,
parvient à être aussi rapide ? Quelles sont les avancées qu'il reste
à faire pour obtenir des performances identiques au langage C ?
Pour illustrer cette présentation, on s’intéressera à l’évolution du
navigateur Mozilla Firefox et aux différentes approches pour résoudre
ce problème. +
The ilastik system developed by our group uses machine learning and
simple interaction techniques to empower users without special image
processing expertise to segment and analyze their 2- and 3-dimensional
image data on their own. It offers a number of easy-to-use workflows
for various common analysis tasks. The talk will present two of these
workflows (“interactive classification” and “region carving”), going
from an online demonstration of the high-level user experience down to
the algorithmic and software design details. Special emphasis will be
put on aspects of genericity and parallelization which facilitate
convenient adaptation of basic building blocks to different contexts
without loss of performance. Examples from challenging biological
applications will illustrate our system's capabilities. +
«The effective exploitation of his powers of abstraction must be
regarded as one of the most vital activities of a competent
programmer.» disait Dijsktra.
En effet, pour aborder la complexité d'un problème, l'explicitation
des concepts utiles à sa formalisation et à sa résolution est bien
souvent une étape clé. Lorsque que l'on étend ce processus à une
classe de problèmes qui partagent les mêmes concepts, il est naturel
de se doter d'un langage le plus approprié possible pour manipuler ces
abstractions spécifiques à un domaine (en anglais, «Domain Specific
Language»).
Comment implémenter ces DSLs? Une première approche classique reflète
les constructions du DSL sous la forme d'un jeu de fonctions de
bibliothèque. L'avantage de cette approche est d'utiliser directement
son langage généraliste préféré, et sa chaîne de compilation
optimisée, de façon à générer du code machine à moindre frais. Par
contre, dans ce cadre, l'écriture de passe d'optimisations spécifiques
au DSL - à moins d'utiliser des techniques pointues de
méta-programmation - est a priori impossible.
Une seconde approche, opposée, consiste à écrire un compilateur pour
le DSL à partir de zéro. Toute liberté est alors donnée à
l'implémenteur d'intégrer à son compilateur des passes d'optimisation
spécifiques… mais au prix d'une réimplémentation de passes de
compilation déjà présentes, et certainement plus abouties, dans le
compilateur de son langage généraliste favori.
Dans cet exposé, je présenterai les travaux de Martin Odersky et
son équipe sur la virtualisation de DSLs à l'intérieur du langage de
programmation Scala. La virtualisation de langage utilise
intensivement le polymorphisme et la composition mixin de Scala ainsi
que des techniques de génération de code à l'exécution pour embarquer
des langages spécifiques dans Scala dont la compilation peut
réutiliser des modules du compilateur mais aussi étendre ces derniers
par des optimisations spécifiques au domaine. +, Nous traitons du problème de la conception d'un compilateur où des
informations sur le coût à l'exécution du code objet sont retournées
en tant qu'annotations de coût sur le code source, et ce de façon
certifiée correcte. Pour cela, nous avons besoin d'une idée souple et
précise : (i) du sens donné aux annotations de coût, (ii) de la
méthode pour les prouver correctes et précises, et (iii) de la manière
d'en composer les preuves. Nous proposons ce que nous appelons une
approche par étiquetage pour répondre à ces trois questions. Dans un
premier temps, nous montrons son application sur un compilateur jouet.
L'étude formelle qui en découle suggère que l'approche par étiquetage
a de bonnes propriétés de compositionnalité et de passage à l'échelle.
Afin de s'en convaincre davantage, nous rapportons notre retour
d'expérience sur l'implémentation d'un compilateur prototype écrit en
ocaml pour un large sous-ensemble du langage C. +
L'industrie des effets spéciaux produit une grande quantité d'images
qu'il faut traiter et afficher. Dans le cadre de ses développements
internes, Mikros Image a développé et mis en Open Source un player
d'images temps réel : duke. Dans cet exposé je décrirai quels sont
les enjeux techniques d'un tel logiciel (allocation mémoire, accès
disque, multiplicité des formats, affichage, traitement...) puis
j'expliquerai plus en détails les étapes de la conception d'un
composant essentiel permettant de lire et décoder le plus rapidement
possible les images à afficher. Ce composant ayant pour but d'être
intégré dans d'autres outils, il doit être réutilisable. +
Une question fondamentale pour mes recherches est de savoir ce qu'est
une image. Cela peut sembler à première vue une question trop simple :
une image, c'est un ensemble de points. Mais ces points sont reliés
entre eux, c'est ce qu'on appelle une structure, et ils ont des
données de types multiples qui leur sont attachées. La bibliothèque
Milena, développée au LRDE, est une bibliothèque générique dédiée au
traitement d'images. Dans Milena, trois axes indépendants sont
développés : l'axe des structures, l'axe des données, et celui des
algorithmes, c'est-à-dire de ce qu'on peut faire avec une image.
Dans cet exposé, je vais développer plusieurs exemples dans lesquels
je choisirai un algorithme et un type de données, en faisant varier la
structure. Changer la structure, c'est penser les images d'une manière
différente, et c'est quelque chose d'extrêmement porteur en recherche.
- Un premier exemple est celui d'un algorithme classique de
segmentation : la ligne de partage des eaux. Originellement pensé sur
les pixels, sa traduction dans le cadre des arêtes donne le problème
classique d'arbre couvrant de poids minimum. Si la ligne de partage
des eaux est très connue en traitement d'images, les arbres de
poids minimum sont très utilisés en classification. Un pont naturel
est alors établi entre deux communautés différentes, et les idées
provenant de ces deux communautés peuvent être combinées.
- Un deuxième exemple est celui de la représentation arborescente des
images. Pour illustrer, tant les lignes de niveaux que les
composantes connexes des ensembles de niveaux (les coupes) des
images sont naturellement structurées en arbre : deux lignes ou deux
composantes sont soit disjointes soit emboîtées. On peut filtrer
une image en éliminant de l'arbre tous les nœuds qui ne vérifient
pas un critère. Mais on peut aussi considérer l'arbre lui-même comme
une image, et appliquer sur cet arbre un algorithme de traitement
d'images. C'est une idée récursive très riche.
D'autres exemples pourront être développés en fonction du temps : liens
entre ligne de partage des eaux topologique et segmentation
hiérarchique, topologie discrète dans divers cadres...
La bibliothèque Milena permet d’appliquer la plupart des algorithmes
existants à une nouvelle structure, ce qui est un gain de temps
incontestable. Cela permet de se concentrer sur ce qui fait le cœur
de mon métier: chercher un algorithme plus efficace, adapté à un type
de structure, ou encore chercher quelles sont les propriétés
mathématiques d’un algorithme sur une structure donnée.
Concilier généricité et performance des systèmes de vision a toujours
été au cœur des préoccupations scientifiques du laboratoire
d'Électronique et Informatique d'ENSTA-ParisTech. Nous y avons abordé
ce problème sous différents points de vue: électronique,
algorithmique, et logiciel. Depuis nos travaux sur les rétines
programmables et leur algorithmique exotique, nous avons
progressivement intégré la multiplicité des modèles et structures de
données, ainsi que l'emprise des architectures sur étagères, pour
appréhender l'hétérogénéité des systèmes multi-plateformes.
Dans cette présentation à deux voix, on abordera le problème sous deux
angles complémentaires, l'un touchant au modèle et aux algorithmes,
l'autre au logiciel et aux plateformes de calcul.
Ce premier exposé présente un modèle générique de traitement et de
représentation des images fondé sur les espaces de caractéristiques
"local jets" (LJ, ou dérivées partielles multi-échelles), comme
exemple de cadre algorithmique unifié. Grâce à un espace où la
métrique naturelle est directement liée à la similarité visuelle, ce
cadre permet d'aborder un grand nombre d'opérateurs de traitement
d'images de bas niveau, qui correspondent généralement à la
rétro-projection dans l'espace image de points de l'espace des
caractéristiques transformé. Il permet aussi d'aborder des
représentations visuelles de plus haut niveau (modèles d'objet par
exemple) à partir de statistiques globales extraites de l'espace des
caractéristiques. On justifiera cette représentation et on
l'illustrera par diverses applications : Moyennes non locales
(NL-Means) par Convolution dans l'espace LJ pour le débruitage de
vidéos, Calcul du flux optique par recherche du plus proche voisin
dans l'espace LJ, Modélisation de fond statique par échantillonnage de
l'espace LJ, Détection d'objets par transformée de Hough dense... +, Dans ce second exposé, Matthieu Garrigues parlera de ses travaux sur
l'analyse des mouvements apparents dans un flux vidéo. La primitive de
base, présentée dans un séminaire précédent, permet le suivi temps
réel (supérieur à 30 images par seconde) de plusieurs milliers de
particules. Ces travaux nous ont permis de développer un cadre
générique facilitant l'analyse de scènes dynamiques prises de caméras
fixes ou mobiles. Nous montrerons comment cette brique logicielle a
été utilisée dans deux exemples d'applications : l'extraction des
plans principaux et l'estimation de la profondeur dans un système
mono-caméra. Le suivi de particules a été implémenté sur processeurs
graphiques avec le framework CUDA, et sur CPU-multicœurs avec
OpenMP. Nous expliquerons comment C++ a été utilisé pour factoriser un
maximum de code entre ces deux implémentations. +
L'arrivée des GPU (Graphics Processing Unit) a profondément changé la
manière de concevoir la notion de coprocesseur. A moins de 500€, il est
désormais possible d'avoir à sa disposition une puissance de calcul qui
n'était réservée jusqu'à un passé récent qu'aux grands centres de calcul. La
société Nvidia, en mettant au point l'environnement CUDA, a fourni à la
communauté des développeurs des moyens simples et efficaces pour rendre
cette puissance de calcul accessible au plus grand nombre. Depuis, sous
l'impulsion de la société Apple, le standard OpenCL est venu ouvrir la voie
d'une véritable parallélisation des applications sur l'ensemble des
ressources processeur offertes aux développeurs.
Cet exposé décrira les différentes technologies permettant la programmation
parallèle des GPU en mettant l'accent sur les contraintes actuelles et les
progrès à venir des futures architectures comme le processeur Kepler. Des
démonstrations ainsi que des exemples de code viendront compléter cet
exposé. +
(Morphological Filtering in Shape Spaces: Applications using Tree-Based Image
Representations)
Connected operators are filtering tools that act by merging elementary
regions of an image. A popular strategy is based on tree-based image
representations: for example, one can compute a shape-based attribute on
each node of the tree and keep only the nodes for which the attribute is
sufficiently strong. This operation can be seen as a thresholding of the
tree, seen as a graph whose nodes are weighted by the attribute. Rather than
being satisfied with a mere thresholding, we propose to expand on this idea,
and to apply connected filters on this latest graph. Consequently, the
filtering is done not in the image space, but in the space of shapes built
from the image. Such a processing is a generalization of the existing
tree-based connected operators. Indeed, the framework includes classical
existing connected operators by attributes. It also allows us to propose a
class of novel connected operators from the leveling family, based on shape
attributes. Finally, we also propose a novel class of self-dual connected
operators that we call morphological shapings. +, Le model checking est une technique de vérification formelle
automatique. Prenant en entrée un modèle décrivant toutes les exécutions
possibles du système et une propriété exprimée sous la forme d'une formule
de logique temporelle, un algorithme de model checking répond si le modèle
satisfait ou non la formule. Le problème principal du model-checking est
l'explosion combinatoire de l'espace d'états décrivant le système.
Afin d'améliorer les performances, on a apporté les contributions suivantes
à l'approche automate du model checking. D'abord l'amélioration de
l'algorithme de vérification en deux passes de l'approche basée sur les
automates Testeur TA (Testing Automaton). Ensuite la proposition d'une
méthode permettant de transformer un automate TA en un automate vérifiable
en une seule passe, qu'on a appelé STA (Single-pass Testing
Automaton). Enfin, la contribution la plus significative est un nouveau type
d'automate baptisé TGTA (Transition-based Generalized Testing
Automaton). L'apport principal de cette nouvelle approche consiste à
proposer une méthode permettant de supprimer les transitions bégayantes dans
un TGTA sans avoir besoin, ni d'ajouter une seconde passe comme dans
l'approche TA, ni d'ajouter un état artificiel comme dans l'approche STA. +, Le model checking est une technique qui permet de s'assurer qu'un système
vérifie un ensemble de caratéristiques appelées propriétés. Le système et la
négation de la formule sont ensuite représentés de manière abstraite (ici un
automate) pour pouvoir détecter des comportements incohérents. Ces
propriétés ont été classifiées et possèdent des particularités qui peuvent
être exploitées afin de réduire la complexité du processus de
vérification. Nous montrerons ici comment tirer parti dynamiquement des
différentes classes de formules. +
The Single-chip Cloud Computer (SCC) is a 48-core experimental processor
created by Intel Labs targeting the many-core research community. The 6x4
mesh Network-on-Chip provides 24 tiles with 2 cores each. All cores are
independent and run their own instance of an operating system. It has
hardware support (local buffers on the tiles) for sending short messages
between cores, and allows for voltage and frequency control at 8 and 2 cores
respectively.
We have already modified the SVP runtime system to use these on-chip buffers
for the communication between threads executed on separate cores. We also
created a visual application for manual process migration and scheduling on
the SCC as well as a library for customized voltage and frequency scaling on
the chip.
Currently we focus on automated parallelization and mapping of one or
multiple sequential programs onto the 48 cores by modifying the daedalus
framework to target the SCC. The daedalus framework parallelizes sequential
C programs using Kahn Process Networks (KPNs) and generates code to run the
KPN on multiple hardware platforms like for example an FPGA, SMP CPU or
GPU. The SCC backend, which is work in progress, should result in a tool
that utilizes the SCC cores in an optimal way by means of performance and
energy consumption. It should also allow the system to dynamically adapt on
changes in the computational or communicational needs of the processes by
scaling frequency and migrating processes. +, Afin d'exploiter le potentiel des puces multi-cœurs pour une performance
évolutive et à haut rendement énergétique, le projet Apple-CORE a
co-conçu un modèle général d'architecture matérielle et une interface de
contrôle de parallélisme. Cette interface, appelée SVP, est réalisée par
du matériel sur puce dédié à la gestion de la concurrence de programmes
parallèles exécutés sur plusieurs cœurs. SVP se base sur les principes
de synchronisation de flux de données («data flow»), de programmation
impérative et d'exécution efficace du parallélisme en termes de budget
temps et énergie. Les composants matériels correspondants peuvent
coordonner plusieurs cœurs RISC équipés de multi-threading matériel,
organisés en clusters de calcul sur puce, dits «Microgrids».
Comparés à l'approche traditionnelle «accélérateurs», les Microgrids sont
destinés à être utilisés comme composants dans les systèmes distribués sur
puce contenant à la fois des grappes de petits cœurs et optionnellement de
gros cœurs –optimisés pour l'exécution séquentielle– disponibles en tant que
«services» pour les applications. Les principaux aspects de cette
architecture sont l'asynchronisme, c'est-à-dire la capacité à tolérer les
opérations irrégulières avec des temps de latence longs, un modèle de
programmation à échelle invariante, une vision distribuée de la puce, et une
mise à l'échelle transparente de la performance d'un seul code binaire à
plusieurs tailles de grappes de cœurs.
Cette présentation décrit le modèle d'exécution, la micro-architecture des
cœurs, sa réalisation au sein d'une plateforme et son environnement
logiciel. +
Avec l'avènement du Web et du besoin de protéger les utilisateurs contre des
logiciels malicieux, les machines virtuelles langages, comme les machines
virtuelles Java et .Net, sont devenues la norme pour exécuter des
programmes. Dans cet exposé, je vais présenter les travaux que j'ai menés
ces dernières années et qui se sont concentrés sur trois aspects des
machines virtuelles: leur design, leur sûreté de fonctionnement, et leur
performance sur les architectures multi-cœurs.
Ma première contribution est VMKit, une bibliothèque qui facilite le
développement de nouvelles machines virtuelles performantes en cachant leur
complexité dans un ensemble de composants réutilisables. Ma seconde
contribution est I-JVM, une machine virtuelle Java qui élimine les huit
vulnérabilités connues qu'un composant de la plateforme OSGi pouvait
exploiter. Ma troisième contribution vise à améliorer les performances des
machines virtuelles sur les architectures multi-cœurs en se focalisant sur
les verrous et les ramasse-miettes: avec un mécanisme de verrouillage qui
surpasse tous les autres mécanismes connus lorsque le nombre de cœurs
augmente, et avec avec une étude des goulets d'étranglement des
ramasse-miettes sur les architectures multi-cœurs. +
En morphologie mathématique, la représentation d'une image par l'arbre
des formes n'est en fait pas vraiment auto-duale: elle se heurte à la
dualité entre séparation et connexité (c4 vs. c8 en 2D) et au final
des aberrations apparaissent. À la recherche d'un algorithme original
pour le calcul de l'arbre des formes, une nouvelle représentation
discrète d'images 2D est apparue. Définie sur la grille de Khalimsky
avec la topologie d'Alexandroff et s'appuyant sur l'analyse
multivoque, cette représentation a la particularité de satisfaire à de
nombreuses propriétés du continu et de s'affranchir des problèmes
topologiques classiques. +
SMIL est une bibliothèque de traitement d'images 2D/3D. Elle a été
développée pour répondre à une demande de plus en plus forte (en
particulier dans le cas de projets industriels) en termes de
performances : taille d'images (2D ou 3D) et temps d'exécution.
Développée en C++ et utilisant les templates, elle peut être utilisée
avec n'importe quel type standard de données. Un effort important a
été porté sur la factorisation du code (par le biais de functors),
d'une part, pour faciliter l'intégration de nouvelles fonctions, et
d'autre part pour concentrer les parties du code permettant
l'optimisation. Ces "briques" communes optimisées utilisent le code
SIMD généré par l'auto-vectorisation de gcc et sont également
parallélisées grâce à l'utilisation d'OpenMP. +