Traitement des données massives (INF442, A6)

INF442 : Traitement des Données Massives

A6 : MapRedu e et des Big Data aux Tiny data !

Frank Nielsen

nielsen�lix.polyte hnique.fr

X2013

20 mai 2015

Frank Nielsen A6-1

Plan

◮le formalisme MapRedu e (ou Hadoop MapRedu e)

◮des Big Data aux Tiny Data ave les sous-ensembles ÷urs : oresets

◮ réer son Makefile

Frank Nielsen A6-2

Le formalisme MapRedu e :

Parallélisme à �ne

granularité

Frank Nielsen 1.MapRedu e A6-3

Le adre MapRedu e

◮modèle abstrait de programmation parallèle pour les grandes données

sur un très grand luster de ma hines

◮ar hite ture maître/serviteurs

◮simple à utiliser

◮fa ilement extensible

◮résistan e aux diverses pannes matérielles, réseaux, et .

◮développé originellement par Google en 2003 en C++ (Hadoop

MapRedu e en Java

R©)


Les grandes données ... Les Big Data !

◮1 Tera Byte (TB) = 1024 Giga Byte (GB)

◮1 Peta Byte (PB) = 1024 Tera Byte

◮En 2007, Google traitait 20 PB par jour de données ...

Pour se �xer les idées : 1 PB, 'est :

◮ ≈ 10 milliards de photos (Fa ebook, Fli kr, Instagram, ...)

◮13 années de vidéo HD (YouTube, Dailymotion, ...)

→ sur un PC standard, il faudrait 7+ années pour traiter en temps

linéaire 20 PB ...

Comment faire pour traiter en temps raisonnable des grandes données ?

→ parallélisme à �ne granularité (SPMD)


Traitement massif des données

◮indexer les do uments sur Internet (par rawling)

◮analyser les � hiers logs de requêtes sur les sites webs

◮donner les mots lefs du jour (Google zeitgeist, et .)

◮et .

... mais aussi au quotidien pour :

◮analyse de génomes

◮analyse des téles opes et autre données issues de apteurs physiques

◮analyse du tra� routier

◮et .


MapRedu e : simple mais ri he en appli ations !

Beau oup de problèmes peuvent être résolu en deux étapes élémentaires :

1. en mappant une fon tion sur une séquen e de données pour produire des

éléments intermédiaires ...

2. puis en réduisant es nouveaux éléments intermédiaires

→ granularité �ne du parallèlisme


Prin ipe de MapRedu e : la programmation fon tionnelle

Deux primitives de base des langages fon tionnels omme le Lisp (Common

Lisp/S heme) ou OCaml http:// aml.inria.fr/o aml/ :

◮map :

(x1

, ..., xn)f−→ (f (x

1

), ..., f (xn))

◮redu e :

(x1

, ..., xn)∑

−→

n∑

i=1

xi

opérateur binaire �+� : ommutatif ou non omme pour le produit de

matri es

◮pas de variables des langages impératifs don fa ilement parallélisable

◮outils pour le ontr�le et monitoring des deux tâ hes map & redu e


http://caml.inria.fr/ocaml/

Culture générale : Map & Redu e en Lisp

◮map ar :

CL-USER > (map ar #'sqrt '(3 4 5 6 7))

(1.7320508 2.0 2.236068 2.4494899 2.6457513)

◮redu e :

CL-USER > (redu e #'+ '(1 2 3 4 5))

15

Pour jouer, installez Lisp :

http://www.lispworks. om/


http://www.lispworks.com/

Culture générale : Map en OCaml

Syntaxe pour un opérateur unaire omme le arré :

# let square x=x*x;;

val square : int -> int = <fun>

# let mapliste = List.map square;;

val mapliste : int list -> int list = <fun>

# mapliste [4;4;2℄;;

- : int list = [16; 16; 4℄

#

Pour jouer, installez OCaml :

http:// aml.inria.fr/o aml/


http://caml.inria.fr/ocaml/

Culture générale : Redu e en OCaml

Syntaxe pour un opérateur binaire :

n∑

i=1

ai = (a1

+

n∑

i=2

ai) = (

n−1∑

i=1

ai + an)

→ asso iativité gau he/droite

fold_right f [e1;e2; ... ;en℄ a = (f e1 (f e2 (f en a))

fold_left f a [e1;e2; ... ;en℄=(f .. (f (f a e1) e2) ... en)

Exemple :

List.fold_left ( + ) 0 [1;2;3;4℄ ;;

List.fold_right ( + ) [1;2;3;4℄ 0 ;;


Le typage des opérations de MapRedu e

On manipule des paires ( lefs,valeurs)

◮Mapper :

map(k1

, v1

)→ list(k2

, v2

)

◮Redu er :

redu e(k2

, list(v2

))→ list(v2

)


MapRedu e : les trois phases du al ul

1. Mapper : émet à partir des entrées des paires ( lefs,valeur)

2. Sort : regroupe les paires intermédiaires par la valeur des lefs

3. Redu e : sur les lefs intermédiaires, on applique un al ul de pré�xe

(= rédu tion, a umulation, aggrégation) sur toutes les valeurs asso iées

ave les mêmes lefs.


L'algorithme MapRedu e

◮appliquer le mapper sur les données en entrées

◮regrouper les listes résultats dans une liste de paires ( lef2,valeur2)

◮ré-arranger la liste en une liste de paires ( lef2, liste de valeur2) pour

haque valeur distin te de lef2

◮appeler le redu er sur haque élément de la nouvelle liste

◮aggréger les résultats


Un exemple : le produit matri e-ve teur

Soit A une grande matri e de dimension (n, d) et x un petit ve teur olonne

(d , 1) :

y = A× x , yi =d∑

j=1

ai ,j × xj

On suppose x entiérement sto ké sur haque pro essus Map et A partitionné

sur l'ensemble des pro essus Maps :

◮Entrée : paires lefs-valeurs (i , ai ,j)

◮Map :

Les pro essus Maps produisent les paires intermédiaires lefs-valeurs

(i , ai ,j × xj)

◮Redu e :

Les pro essus Redu es aggrégent les valeurs asso iées aux lefs i . Les

résultats produits sont don les paires lefs-valeurs (i , yi )

Similaire pour le produit matri iel ci ,j =∑d

k=1 ai ,k × bk,j ...

Paire (di + j , ai ,kbk,j)Frank Nielsen 2.MapRedu e A6-15

Un exemple : ompter les mots dans les do uments

map (string do name, string do ontents):

for ea h word w in do ontents:

emit (w, "1")

redu e (string word, list<string> ounts):

int result = 0

for ea h n in ounts:

result := parseInt(n)

emit([""+result℄)

MapRedu e utilise des haînes de ara tères pour sto ker les données : pour

ré uperer les données en nombres, il faut don onvertir es haînes. "123" →123, "3,14" → 3,14


Un exemple de ode C++

en MapRedu e

(pour information seulement)


#i n l u d e "mapredu e /mapredu e . h"

l a s s WordCounter : p u b l i Mapper {

p u b l i :

v i r t u a l vo i d Map( on s t MapInput& i npu t ) {

on s t s t r i n g& t e x t = i npu t . v a l u e ( ) ;

on s t i n t n = t e x t . s i z e ( ) ;

f o r ( i n t i = 0 ; i < n ; ) {

// Skip past leading whitespa e

wh i l e ( ( i < n ) && i s s p a e ( t e x t [ i ℄ ) ) i ++;

// Find word end

i n t s t a r t = i ;

wh i l e ( ( i < n ) && ! i s s p a e ( t e x t [ i ℄ ) ) i ++;

i f ( s t a r t < i ) Emit ( t e x t . s u b s t r ( s t a r t , i−s t a r t ) , "1" ) ;}

}

} ;

REGISTER_MAPPER(WordCounter ) ;


#i n l u d e "mapredu e /mapredu e . h"

l a s s Adder : p u b l i Redu er {

v i r t u a l vo i d Redu e ( Redu e Input∗ i n p u t ) {

// Iterate over all entries with the

// same key and add the values

i n t 6 4 v a l u e = 0 ;

wh i l e ( ! i nput−>done ( ) ) {

v a l u e += St r i n gTo I n t ( input−>va l u e ( ) ) ;

i nput−>NextValue ( ) ;

}

// Emit sum for input->key()

Emit ( I n tToS t r i n g ( v a l u e ) ) ;

}

} ;

REGISTER_REDUCER( Adder ) ;


#in l u d e "mapredu e /mapredu e . h"

i n t main ( i n t arg , har ∗∗ argv ) {

ParseCommandLineFlags ( arg , a rgv ) ;

MapRedu eSpe i f i a t i on spe ;

// Store list of input �les into "spe "

f o r ( i n t i = 1 ; i < a rg ; i++) {

MapRedu eInput ∗ i n pu t = spe . add_input ( ) ;

input−>set_format ( " t e x t " ) ;

input−>s e t_ f i l e p a t t e r n ( a rgv [ i ℄ ) ;

i nput−>set_mapper_ lass ( "WordCounter" ) ;

}

// Spe ify the output �les :

// /gfs/test/freq-00000-of-00100

// /gfs/test/freq-00001-of-00100

// ...

MapRedu eOutput∗ out = spe . output ( ) ;

out−>s e t_ f i l e b a s e ( "/ g f s / t e s t / f r e q " ) ;

out−>set_num_tasks(100) ;

out−>set_format ( " t e x t " ) ;

out−>se t_redu e r_ l a s s ( "Adder " ) ;


// Optional : do partial sums within map

// tasks to save network bandwidth

out−>set_ ombine r_ las s ( "Adder " ) ;

// Tuning parameters : use at most 2000

// ma hines and 100 MB memory per task

spe . set_ma hines (2000) ;

spe . set_map_megabytes (100) ;

spe . set_redu e_megabytes (100) ;

// Now run it

MapRedu eResult r e s u l t ;

i f ( ! MapRedu e ( spe , &r e s u l t ) ) abo r t ( ) ;

// Done : 'result' stru ture ontains info

// about ounters, time taken, number of

// ma hines used, et .

r e t u r n 0 ;

}


Autres exemples

◮la ommande Unix grep distribuée :

grep -Eh regularexpression repertoire/*

| sort | uniq - | sort -nr

◮map : émet une ligne si elle orrespond au motif

◮redu e : fon tion identité : opie les données intermédiaires en sortie

◮liste inversée des référen es du web :

◮map : émet des paires (target,sour e) pour haque lien sur une URL

target trouvé dans une page sour e

◮redu e : on aténe toutes les URLs asso iées à une URL

Frank Nielsen 2.MapRedu e-1.exemples A6-22

∅

M M M M

(k1; v)(k1; v)(k2; v)... (k3; v)(k4; v)(k3; v)... (k2; v)(k1; v)...

Regrouper par clefs

Donnees

(k1; v, v, v, v) (k2; v, v, v) (k3; v, v, v, v, v, v, v) (k4; v, v)

R R R R

Sorties

Mapper

Sorter

Reducer

donnees groupees


Déploiement des tâ hes

M M M M M M M M M

R R R R R

(k2; v, v, v) (k9; v) (k5; v, v, v) (k1; v, v) (k6; v, v, v)

Tache map 1 Tache map 2 Tache map 3

Tache reduce 2Tache reduce 1

Tri et regroupe Tri et regroupe

R E S E A U R E S E A U R E S E A U


Ar hite ture système de MapRedu e

◮système MapRedu e fon tionne sur un grand luster de ma hines

(1000+, 10000+)

◮toléran e aux fautes : une ma hine ou un disque dur (Hard Disk Drive,

HDD) peut subitement tomber en panne.

ça arrive souvent si le nombre de ma hines est grand !

→ MapRedu e relan era automatiquement les tâ hes qui n'ont pas

abouti.

◮rapidité : ertaines ma hines peuvent être trop lentes dûes à leurs

sur harges (les �stragglers�).

→ MapRedu e peut lan er une même tâ he sur plusieurs ma hines

( redondan e par répli ation ) et obtenir le résultat dès qu'une des tâ hes

est �nie.


Ar hite ture système de MapRedu e

◮lo alité/réseau : le transfert de données sur le réseau étant oûteux,

l' ordonnan eur essaye d'allouer les tâ hes sur les ma hines où résident

les données

◮surveillan e/ ontr�le (monitoring) : interfa e web qui rapporte diverses

statistiques sur les tâ hes (prévoit la durée d'éxe ution d'une tâ he, et .)


MapRedu e : Ar hite ture Master/workers (papier OSDI,

2004)


Master Che kpoints/GFS/Combiner

◮La ma hine Master é rit périodiquement les stru tures de données du

Master a�n de pouvoir reprendre le al ul en ours si le Master lui-même

tombe en panne !

◮Google File System (GFS) ou Hadoop File System (HFS) divise les

� hiers en blo s de 64MB et sauvegarde plusieurs opies sur des

ma hines di�érentes (tolèran e aux pannes)

◮Phase Combiner : quand il y a de multiples lefs intermediaires

identiques sur une même ma hine, on les ombine lo alement


Pourquoi un tel su ès de MapRedu e ?

◮parallélisation automatique et distribution des tâ hes de al ul

◮distribution des données et équilibrage des tâ hes ( load balan ing )

◮tolérant aux pannes

◮abstra tion simple et propre basé sur deux fon tions utilisateurs :

appli ations pour le tri, en apprentissage, en fouille de données (data

mining), et .

◮outils de ontr�le (monitoring, permet d'ajuster les ressour es allouées si

né essaire en ours d'exé ution)


Le TD d'aujourdhui : MapRedu e en MPI

Utilisation de MapRedu e pour l'alignement de séquen es sur une référen e :

re onstruire une portion importante du gène BRCA1 grâ e à l'algorithme

BLAST : Basi Lo al Alignment Sear h Tool (1990, sa parallélisation en 2007)

MapRedu e ave MPI : http://mapredu e.sandia.gov/


http://mapreduce.sandia.gov/

La bibliothéque MR-MPI, MapRedu e en MPI

◮MapRedu e *mr=new MapRedu e(MPI_COMM_WORLD); : réé un nouvel

objet MapRedu e

◮uint64_t MapRedu e::map(int nmap, int nstr, har

**strings, int re urse, int readfile, har sep har, int

delta, void (*mymap)(int, har *, int, KeyValue *, void

*),void *ptr); : appelle la fon tion mymap en répartissant le ontenu

des � hiers d'entrée sur les di�érents pro esseurs

Notez dans les arguments les pointeurs de fon tions du C/C++


La bibliothéque MR-MPI, MapRedu e en MPI

◮uint64_t MapRedu e:: ollate(int (*myhash)( har *, int)); :

permet de regrouper les objets KeyValue *kv répartis sur les di�érents

pro esseurs en un seul objet KeyMultiValue ave des lefs uniques

asso iées à des listes de valeurs. La fon tion de ha hage en entrée est

utilisée pour répartir les lefs sur les pro esseurs, nous utiliserons NULL

pour la fon tion de ha hage par défault de la bibliothèque

◮uint64_t MapRedu e::redu e(void (*myredu e)( har *, int,

har *, int, int *, KeyValue *, void *), void *ptr); :

appelle la fon tion myredu e

◮void KeyValue::add( har *key, int keybytes, har *value,

int valuebytes) : ajoute le ouple (key, value) dans l'objet KeyValue ,

il faut pour ela pré iser la taille en o tets de la lef et de la valeur.


Des Big Data aux Tiny

Data !

Les sous-ensembles ÷urs

Frank Nielsen 3.Les sous-ensembles ÷urs A6-33

Les sous-ensembles ÷urs pour l'optimisation appro hée

rapide

sous-ensembles ÷urs ( ore-sets, é rit aussi oresets)

◮soit un problème d'optimisation sur n données X = {x

1

, ..., xn} :

min

θ∈Θf (θ|x

1

, ..., xn)

θ∗ = sol(θ|X ) = argminθf (θ|x1, ..., xn)

c∗ = oût(θ|X )min

θf (θ|x

1

, ..., xn)

◮On her he à trouver un sous-ensemble C ⊂ X tel que :

oût((θ|X ) ≤ oût((θ|C ) ≤ (1+ ǫ) oût((θ|X )

◮De plus, on voudrait |C | ≪ |S | qui dépend uniquement de ǫ (pas de n, ni

de d)

Frank Nielsen 3.Les sous-ensembles ÷urs A6-34

Exemple : la plus petite boule englobante (SEB)

SEB=Smallest En losing Ball

Trouver la plus petite boule englobante B = Ball(c , r) qui ouvre X

(minimisations équivalentes : volume ≡ rayon ≡ in lusion)

c∗ = min

c∈Rd

nmax

i=1‖c − xi‖

La plus petite boule Eu lidienne est unique, son entre ir ons rit est c∗

Frank Nielsen 3.Les sous-ensembles ÷urs-1.SEB A6-35

Core-set pour la plus petite boule englobante

◮ c(X ) : entre de la plus petite boule, r(X ) : rayon de la plus petite boule

◮pour tout ǫ > 0, un ǫ- ore-set C ⊆ X est tel que :

X ⊆ Ball(c(C ), (1 + ǫ)r(C ))

◮en élargissant SEB(C ) par un fa teur 1+ ǫ, on ouvre omplétement X


Illustration : sous-ensemble ÷ur

X ⊆ Ball(c(C ), (1 + ǫ)r(C ))

En élargissant SEB(C ) par un fa teur 1+ ǫ, on ouvre omplétement X


Des Big Data aux Tiny Data !

Théorème

il existe un sous-ensemble ÷ur de taille ⌈1ǫ⌉, indépendant de la dimension

d , et de n

On passe d'un problème d'optimisation à n données à un problème

d'optimisation à ⌈1ǫ⌉ données

⇒ les ore-sets ont beau oup d'appli ations en grandes dimensions voire

même quand d ≫ n


Le as où d ≫ n

n points en position générale :

◮pas trois points sur une même droite, et .

◮pas k + 1 points dans un sous espa e-a�ne de dimension k

◮mathématiquement, on peut réduire e as à d ′ = n− 1 don !

◮... néanmoins, ela ferait intervenir des al uls de déterminants, non

seulement oûteux, mais aussi instable en pratique ar on perd de la

pré ision numérique à haque multipli ation

◮pas d'implémentation en al ul virgule �ottante IEEE 754 ... (sinon on

doit utiliser de l'arithmétique multi-pré ision, omme le pa kage gmp)


Algorithme de Badoiu & Clarkson (2003)

SEB par sous-ensemble ÷ur :

◮Initialiser le entre c

1

∈ X = {x1

, ..., xn},

◮Mettre à jour itérativement le entre ave la règle :

ci+1 ← ci +fi − ci

i + 1

où fi est le plus lointain point de X de ci :

fi = ps , s = argmax

nj=1‖ci − xj‖

◮méthode style des ente de gradient (sto hastique)

◮ (1+ ǫ)-approximation après ⌈ 1ǫ2⌉ itérations : temps total en O(dn

ǫ2)

◮le sous-ensemble ÷ur est : f

1

, ..., fl ave l = ⌈ 1ǫ2⌉


Sous-ensemble ÷ur pour la boule englobante

Démo http://ken larkson.org/sga/t/t.xml


http://kenclarkson.org/sga/t/t.xml

Core-sets pour le regroupement par les k-moyennes

◮distan e Eu lidienne (au arré) point/ entres des lusters :

d2(p,C ) = min

c∈Cd2(p, c)

◮ oût des k-moyennes :

lC (P) =∑

p∈P

wpd2(p,C )

◮ S est un (k , ǫ)- oreset pour P :

∀C = (c1

, ..., ck ), (1− ǫ)lC (P) ≤ lC (S) ≤ (1+ ǫ)lC (P)

Théorème

En 1D, il existe un (k , ǫ)- oreset de taille O(k2

ǫ2), et O(k3/ǫd+1) quand d > 1

Smaller Coresets for k-Median and k-Means Clustering, Dis rete &

Computational Geometry, 2007


Mathémagie : Des grandes données aux petites données

Philosophie des ensembles ÷urs : hanger un problème d'optimisation exa te

sur n données en un problème d'optimisation exa te sur f (ǫ) qui garantie uneoptimisation appro hée sur toutes les données.

Turning Big data into tiny data : Constant-size oresets for k-means, PCA

and proje tive lustering (2013)

http://people. sail.mit.edu/dannyf/big/subspa e.pdf


http://people.csail.mit.edu/dannyf/big/subspace.pdf

Compiler des programmes

ave un

Makefile

Frank Nielsen 4.Make�le A6-44

Compiler un programme

Exemple ave la fon tion main dans le � hier main. pp :

g++ -Wall -o monProg442.exe fon tions . pp main. pp

Les � hiers d'en-têtes (headers) en .h (templates) sont in lus dans les . pp

et lus lors de la ompilation de � hiers . pp

Plus le programme (= ensemble de � hiers) devient gros, plus la ligne de

ompilation devient grande à taper :

g++ -Wall -o monProg442.exe main. pp fi hier1 .

pp fi hier2 . pp fi hier3 . pp

Compilation ave l'option de débogage (option/ �ag '-g') puis exé ution dans

un déboggeur. Quand le programme rashe, il é rit un � hier ore puis

débogage ave gdb, ou dans un IDE (E lipse)

Que faire lorsqu'on a de nombreux � hiers à gèrer dans un projet ?


Compilation dans un � hier ompilé objet : les .o

Attention : i i objet n'a pas le sens de OO (orienté objet) !

g++ - fi hier. pp

produit un � hier fi hier.o

Dépend de l'ar hite ture où a lieu la ompilation : x86 32-bits ou 64-bits,

Ora le Spar , Ma OS, et .

Par exemple, si vous ompilez sous Windows, votre .o ne sera pas utilisable

en salles ma hines (UNIX).

C'est une grande di�éren e ave Java qui ompile en . lass qui mar he pour

la JVM (Java Virtual Ma hine), don partout où on a une JVM !


Édition de liens : linking

Édition de liens = phase �nale de la ompilation.

Rassemble tous les � hiers objets .o et produit un � hier exé utable.

Les � hiers objets utilisés proviennent de :

◮de la ompilation de � hiers . pp (. pp

g++ -

−−−−→ .o)

◮de la bibliothèque standard (fon tions E/Ss, fon tions mathématiques

log, exp, et .)

◮de bibliothèques extérieures ( omme CImg lors du TD5)

g++ fi hier1 .o fi hier2 .o main.o -o monProg442.exe -

lpthread -lX11

Di�éren e entre une bibliothèque statique .so (shared obje ts) et une

bibliothèque dynamique .dll (dynami linked library)


Édition de liens : la ommande ldd

ldd : print shared library dependen ies (Linux)

#in l u d e<ios t ream>

us i n g namespa e s td ;

i n t main ( )

{ out << "J ' u t i l i s e un out ! " ;

r e t u r n 0 ;}

ldd programme .exe

linux -gate.so.1 => (0 x00142000 )

libstd ++.so.6 => /usr/lib/libstd ++.so.6 (0

x008f8000 )

libm.so.6 => /lib/libm.so.6 (0 x0063 000 )

libg _s .so.1 => /lib/libg _s .so.1 (0

x008 000 )

lib .so.6 => /lib/lib .so.6 (0 x004de000 )

/lib/ld-linux.so.2 (0 x004bf000 )


Graphe de dépendan es d'un programme

Projet Programme

donnee.o main.o lecture.o

donnee.cpp donnee.h main.cpp lecture.h lecture.cpp

Comment faire pour re ompiler si on a tou hé seulement au � hier

donnee. pp ? Doit-on re ompiler le ture. pp en le ture.o ?


L'utilitaire UNIX make

◮utilitaire pour ompiler ( building ) des programmes exé utables, des

bibliothèques, et .

◮organise les ompilations, n'est pas spé i�que à un langage donné

◮utilise un s ript en entrée : Makefile

◮on veut ompiler un ensemble de ibles à partir de � hiers sour es

orrespondants

La ommande tou h permet de modi�er les dates de dernière modi� ation

des � hiers. Pour for er la re ompilation :

tou h * ; make


Les règles dans un Makefile

Les ommandes doivent suivre une tabulation (pas des espa es !) :

target : sour e1 sour e2 ... sour eN

ommande1

ommande2

...

Exemple :

monProg : fi hier1 . pp fi hier2 . pp main. pp

g++ -o monProg fi hier1 . pp fi hier2 . pp

main. pp

Puis make target, par exemple :

make monProg


Règle sans sour es

On nettoie tous les � hiers :

lean :

rm fi hier1 .o fi hier2 .o fi hier3 .o monProg

puis par exemple ...

make monProg


Règle sans ommandes

all: monProg monProg2

monProg: file1.o file2.o file3.o

g -g -Wall -o myprog file1.o file2.o file3

.o

monProg2 : file4.

g -g -Wall -o myprog2 file4.

Il su�t alors de faire

make all


Les variables dans un Makefile

◮dé laration d'une variable : NOM = valeur

◮utilisation d'une variable : $(NOM)

Par exemple,

OBJFILES = file1.o file2.o file3.o

PROGRAM = myprog

$(PROGRAM): $(OBJFILES )

g -g -Wall -o $(PROGRAM) $(OBJFILES )

lean:

rm $(OBJFILES ) $(PROGRAM)


Makefile : partie générique

Idéalement, on aimerait paramétrer pour un ensemble d'ar hite tures

(UNIX/Windows/Ma OS/Spar , et .). Pour haque ar hite ture, le nom du

ompilateur et ses options peuvent hanger ...

CC = g++

CCFLAGS = -g -Wall

OBJFILES = file1.o file2.o file3.o

PROGRAM = myprog

$(PROGRAM): $(OBJFILES )

$(CC) $(CCFLAGS) -o $(PROGRAM) $(OBJFILES )

Bien d'autres possibilités plus étendues ave le Makefile



◮$� : le � hier target ourant

◮$^ : la liste de tous les � hiers sour es

◮$< : la sour e la plus à gau he pour la ible ourante

myprog: file1.o file2.o file3.o

g $(CCFLAGS) -o $� $^

file1.o: file1. file1.h file2.h

g $(CCFLAGS) - $<



BIN = JL_kmeans

OBJS = randomsample.o mathtools .o partition .o

FLAGS = -O3

INCLUDE = -I/usr/lo al/CImg -1.6.2/

LIBS = -L/usr/lo al/boost -1.58.0/ lib/

LDPATH = LD_LIBRARY_PATH=/usr/lo al/boost -1.58.0/ lib

:/usr/lib/allian e /lib

# exer i e 0

imgve : imgve . xx Makefile

$(CXX) $(FLAGS) $(INCLUDE) -o $� $�. xx $(

LIBS)

# exer i e 1

imageresize: imageresize. xx Makefile

$(CXX) $(FLAGS) $(INCLUDE) -o $� $�. xx $(

LIBS)

...


Résumé A6

�X le formalisme MapRedu e

�X l'optimisation appro hée pour les Big Data grâ e aux petit ensembles

noyaux ( ore-sets) : des Big Data aux Tiny Data !

�X initiation aux Make�les

Pour la pro haine fois : lire les hapitres 6 et 10 du poly opié


Science

Traitement des données massives (INF442, A6)