Le problème de partitionnement dans le codesign

1. Introduction
Le partitionnement est le processus qui détermine les parties du système (System On
Chip) qui doivent être mises en œuvre en matériel et celles qui doivent l'être en logiciel. Cette
tâche est d'une importance critique car elle a un impact important sur les caractéristiques de
coût/performances du produit final. Par conséquent, toute décision de partitionnement doit
prendre en compte un certain nombre de contraintes relatives à l'environnement, à la plate-
forme de mise en œuvre et aux exigences de fonctionnement du système.
Pour les petits systèmes ayant une structure et des fonctionnalités parfaitement maîtrisées,
le nombre d'alternatives de partitionnement matériel/logiciel est petit. L'affectation de
fonctionnalités aux domaines matériels et logiciels peut donc être effectuée en utilisant
l'expérience et l'intuition du concepteur. Si le système spécifié est de grande taille, avec des
fonctionnalités complexes résultant d'un plus grand nombre de composants interagissant entre
eux, le nombre d'alternatives de partitionnement devient très grand et leur impact sur le coût
et les performances ne peuvent pas être estimées sans l'apport d'un outil de conception
performant. Dans ce cas, différents schémas de partitionnement peuvent être explorés avec
l'aide d'heuristiques efficaces basées sur des fonctions de coût.

2. Criteres d’assignation au materiel et au logiciel

La principale question qui se pose par le concepteur d’un système au cours de la phase du
partitionnement est : Quelles sont les parties qui doivent ou peuvent être implémentés en
matériel et quelles sont celles qui le seront en logiciel ? Il est cependant très difficile de
trouver des critères objectifs pour une bonne assignation. Les principaux critères d’une
assignation matérielle/logicielle sont :
- Performance : s’il existe des problèmes de performances, il est conseillé de placer les
parties demandant un temps d’exécution élevé en matériel.
- Coût : le problème de coût se pose dans les applications de grande taille. Une partie
coûtera moins cher si elle est implémentée en logiciel.
- Flexibilité : le manque de flexibilité du matériel est un inconvénient. Cependant, les
circuits programmables permettent de surmonter cette faiblesse.
- Fiabilité : les solutions matérielles présentent souvent une plus grande fiabilité que les
solutions logicielles. Les progrès en test étant plus importants dans le domaine du
matériel qu'en logiciel. Par contre, une erreur logicielle est plus facile à corriger.

3. L’architecture cible

Une architecture indique comment le système à réaliser sera réellement mis en œuvre. Elle
est constituée d’un ensemble de composants, d’une organisation et d’un modèle d’interaction
entre les différents composants. Dans le cas des architectures mixtes matérielles / logicielles
on distinguera les composants logiciels (processeurs, DSPs, microcontrôleurs, etc.), les
composants matériels (ASIC, FPGA) et les composants de communication.
Si par exemple nous avons un système composé de 50 tâches (multiplication, addition,
multiplexage, FFT, codage vidéo, etc.) et nous disposons d’une architecture cible (architecture
disponible quel que soit l’application à implémenter) composée d’un processeur (logiciel), un
DSP (logiciel), un ASIC (matériel) et un bus de communication. Le partitionnement consiste
alors à choisir pour chaque tâche quelle entité (processeur, DSP et ASIC) devra l’exécuter.

1
Des algorithmes de partitionnement existent déjà et permettent d’avoir un bon compromis
entre performances du système et coût final de l’application.

4. Paramètres d’évaluation
De nombreux paramètres peuvent participer à l’évaluation du résultat d’un partitionnement,
parmi lesquels figurent : le temps (et par conséquent la fréquence maximale de
fonctionnement), l’espace (surface silicium), les communications, la flexibilité, la
concurrence (possibilité d’exécution de plusieurs tâches en parallèle ou non), la testabilité, la
sécurité, la réutilisabilité, la sûreté de fonctionnement, etc. Cependant, certaines contraintes
sont difficiles à quantifier. Par contre, les paramètres les plus souvent utilisés peuvent être
regroupés comme suit :
- Les paramètres temporels : englobent essentiellement le temps d'exécution du
logiciel et du matériel, ou des contraintes associées aux systèmes temps-réel
(échéances des tâches, priorité des tâches, etc.).
- Les paramètres spatiaux : peuvent être divisés en espace matériel et espace logiciel.
L’espace matériel (surface silicium, nombre de portes ou de transistors, etc.) est plus
coûteux que l’espace logiciel (nombre de mots occupés par les données et le code sur
les différentes mémoires (registres, RAM, mémoire cache, etc.) utilisées sur
l'architecture cible).
- La communication : est caractérisée par les paramètres temporels et le volume des
transferts. Les premiers décrivent essentiellement le temps de communication. Le
deuxième est étroitement lié aux données transférées à travers les interfaces
matérielles/logicielles et à la bande passante des bus de l'architecture cible.

5. La fonction coût dans le codesign

L’objectif du partitionnement est d’obtenir la meilleure distribution possible des

différentes parties de l’application sur les différentes parties de l’architecture cible. Mais pour
pouvoir dire qu’une distribution est meilleure qu'une autre, il faudrait pouvoir quantifier les
performances de chacune d’elles en vue de les comparer. Cette quantification est rendue
possible par l’introduction d’une fonction de coût évaluant un certain nombre de paramètres
qui dépendent des objectifs à atteindre.
Le problème est rendu plus ardu par le fait que les différents paramètres n’ont pas la
même grandeur physique (par exemple : le temps en nanosecondes et l’espace en octets ou
bien en nombre de portes logique). Donc, un paramètre peut influencer plus qu’un autre sur le
résultat final de la fonction de coût. Ainsi, Cette fonction est souvent une combinaison
pondérée de plusieurs métriques comme le temps d’exécution.
La fonction de coût a généralement la forme suivante :
Coût de la tâche Ti= k1 * temps + k2 * surface + k3 * communication
- Temps : temps d’exécution de la tâche Ti sur l’entité Ej. L’entité Ej (processeur,
FPGA ou autre) est l’entité qui exécute cette tâche selon le schéma de partitionnement
choisi.
- Surface : surface silicium, nombre de portes, ou nombre de LUTs si l’entité qui
exécute la tâche Ti est matérielle ; ou bien taille du code et des données en octets si
l’entité qui exécute la tâche Ti est logicielle.
2
 - Communication : coût de la communication entre la tâche Ti et les autres tâches en
lien avec cette tâche.

6. Etudes de quelques algorithmes de partitionnement

Il est indispensable de trouver un algorithme de partitionnement efficace pour explorer
l’espace de solutions, qui peut être très grand, et en retenir une (ou plusieurs) qui vérifie(nt)
les contraintes imposées au départ et optimise la fonction de coût.

6.1.Algorithme de Kernighan-Lin (KL algorithm)

Dans cet algorithme, les constantes k1 et k2 sont supposées nulles. La fonction coût se
limitera au coût de la communication entre la tâche Ti et les tâches en lien avec cette tâche.
Cet algorithme permettra de partitionner les différentes tâches du système sur une architecture
cible intégrant uniquement deux entités (processeur et ASIC par exemple). Malheureusement,
une architecture cible intégrant plus que deux entités nécessite un autre algorithme pour
résoudre le problème de partitionnement.

Figure 1 : Principe de l’algorithme KL.

Le principe de l’algorithme KL consiste à permuter les tâches Vi entre les deux
partitions jusqu’à l’obtention du meilleur coût (le meilleur coût signifie que chaque partition
contient les bonnes tâches à exécuter afin d’obtenir le meilleur compromis performances /
coût).

Exemple :
Soit le système suivant :

3
 Figure 2 : Différentes tâches du système à implémenter.
Nous désirons partitionner les différentes tâches (a, b, c, d, e, f, g et h) sur une
architecture cible composée d’un processeur et d’un ASIC. La fonction coût déjà calculée
donne la matrice de coût suivante :

Figure 3 : Matrice de coût.

C(x,y) est le coût de communication entre les tâches x et y. Par exemple, la tâche a
communique uniquement avec les tâches c et e avec un coût de 0.5 (C(a,c) = 0.5 et C(a,e) =
0.5 selon la matrice des coûts).
Au début, nous allons faire une partition aléatoire des différentes tâches (figure 3). Par
la suite nous allons vérifier si cette partition est bonne ou non.

4
 Figure 4 : Partition initiale choisie au hasard.
La figure 4 et la figure 2 sont les mêmes, mais nous avons séparés dans la figure 4 les
deux partitions matérielle (c, f, g et h) et logicielle (a, b, d et e).
La communication entre deux tâches exécutées par la même entité est une
communication interne (par exemple la communication entre b et d ou entre f et g sont des
communications internes puisque b et d sont exécutés par la même entité et f et g sont
exécutés par la même entité). Par contre la communication entre deux tâches exécutées par
deux entités différentes est une communication externe (par exemple la communication entre
a et c ou entre d et f est une communication externe puisque a et c ou d et f sont exécutées par
deux entités différentes).
La deuxième étape consiste à remplir le tableau suivant :

5
 Le tableau contient toutes les combinaisons de paires possibles entre les tâches
logicielles (a, b, d, et e) et les tâches matérielles (c, f, g et h). Chaque paire doit contenir
forcément une tâche logicielle (élément x de la paire (x,y)) et une tâche matérielle (élément y
de la paire (x,y)).

Ex : coût externe de la tâche x de la paire (x,y).

Ix : coût interne de la tâche x de la paire (x,y).
Ey : coût externe de la tâche y de la paire (x,y).
Iy : coût interne de la tâche y de la paire (x,y).
C(x,y) : coût de communication entre les tâches x et y (coût donné par la matrice : figure 3).
Dx : désirabilité de permuter la tâche x de la paire (x,y). Dx = Ex – Ix.
Dy : désirabilité de permuter la tâche y de la paire (x,y). Dy = Ey – Iy.
Gain = Dx + Dy – 2*C(x,y). C’est le gain réalisé si on permute les deux tâches x et y.

Pour comprendre le principe de fonctionnement de l’algorithme, nous devrons

comprendre le principe de calcul du gain. Prenons le cas du premier couple (a, c). Ex
représente le coût externe de la tâche a (Ex = 0.5 car la tâche a possède une seule
communication externe, précisément avec la tâche c, avec un coût de 0.5 selon la matrice de
coûts : C(a,c) = 0.5). Ix représente le coût interne de la tâche a (Ix = 0.5 car la tâche a possède
une seule communication interne, précisément avec la tâche e, avec un coût de 0.5 selon la
matrice de coûts : C(a,e) = 0.5).

Passons maintenant au calcul de Ey et Iy du même couple (a, c). Ey représente le coût

externe de la tâche c (Ey = 2.5 car la tâche c possède 4 communications externes, précisément
avec les tâches a, b, d et e, avec un coût total de 2.5 selon la matrice de coûts : C(c,a) + C(c,b)
+ C (c,d) + C(c,e) = 2.5). Iy représente le coût interne de la tâche c (Iy = 0.5 car la tâche c
possède une seule communication interne, précisément avec la tâche f, avec un coût de 0.5
selon la matrice de coûts : C(c,f) = 0.5).

Le gain calculée du couple (a,c) = Dx + Dy – 2*C(x,y) = (Ex – Ix) + (Ey – Iy) –

2*C(x,y) = Da + Dc – 2*C(a,c) = (Ea – Ia) + (Ec – Ic) – 2*C(a,c) = 1.

De la même façon, nous allons terminer tous les calculs nécessaires aux différentes
paires du tableau. La paire ayant le gain le plus élevé est la paire (d,c). L’algorithme implique
que les tâches ayant le gain le plus élevé doivent être permutées entre eux. Dans notre cas
nous devrons permuter les tâches d etc, c’est-à-dire d devient un tâche matérielle et et c
devient une tâche logicielle.

Après avoir permuté les deux tâches, la nouvelle partition devient comme suit :

6
 Figure 5 : Nouvelle partition après permutation de c et d.
Le même traitement sera répété avec les autres tâches non permutées (a, b et e) et (f, g
et h). Les résultats des calculs sont présentés dans le tableau suivant :

Le meilleur gain obtenu est égal à zéro pour la paire (b,g). Par conséquent, nous
devons permuter les tâches b etg, ce qui donne la nouvelle partition suivante :

7
 Figure 6 : Nouvelle partition après permutation de g et b.
Le même traitement sera répété avec les autres tâches non permutées (a et e) et (f et h).
Les résultats des calculs sont présentés dans le tableau suivant :

Le meilleur gain obtenu est égal à (-1) pour la paire (a,f) (nous pouvons aussi choisir
la paire (a,h)). Par conséquent, nous devons permuter les tâches a et f, ce qui donne la
nouvelle partition suivante :

Figure 7 : Nouvelle partition après permutation de a et f.

8
Remarque :
Au départ, le concepteur doit définir le gain minimal permettant de permuter deux tâches. Si
par exemple le concepteur définira un gain >= 2, nous allons donc retenir uniquement la
première itération, c’est-à-dire permuter uniquement les tâches d et c.

6.2.Algorithmes hiérarchiques
Ces algorithmes permettent de regrouper, de façon hiérarchique, les tâches qui ont les mêmes
caractéristiques et les exécuter par une même entité. Le calcul du degré de ressemblance des
tâches (et par conséquent leurs exécution par la même entité) se fait par une fonction qui
s’appelle « closeness function ». Plusieurs fonctions existent dans la littérature :

Exemple 1: Algorithme hiérarchique de Yorktown Silicon Compiler

Figure 8 : Architecture du système à partitionner.

Données :
- a, b, x, y et z sont les entrées des tâches +, =, - et <.
- S1, S2, et S3 sont les sorties du système.
- Les entrées sont codées sur 4 bits.
- Size (+) = 120, Size (=) = 140, Size (-) = 160, Size (<) = 180.
- size_max = 300 (taille maximale permise d’un groupement de tâches).
- K1 = K2 = K3 = 1 dans cet exemple.
- La fonction « closeness » est la suivante :

Closeness( pi , p j )  ( MaxConni , j( P ) ) k 2  ( Minsize  ( size

Conn _ max k3 size _ max
( sizei , size j ) ) i  size j
)
Conni , j k1  inputsi , j  wirei , j
inputsi , j number of common inputs shared
wiresi , j number of output to input and input to output
MaxConn( P) maximum Conn i, j over all pairs
sizei estimated size of group pi
size _ max maximum group size allowed
k1, k 2, k 3 constants

9
L’application de la fonction « closeness » donne les résultats suivants :

Closeness (+, <) = Closeness (+, -) = Closeness (<, =) = Closeness (-, =) = 0

Ceci donne le résultat de partitionnement hiérarchique suivant :

Figure 9 : Résultat de la première itération du partitionnement.

Une deuxième itération de l’algorithme donne :

Closeness (group1, group2) = Closeness (g1, g2) = 0

Figure 10 : Résultat de la deuxième itération du partitionnement.

10
Exemple 2: Algorithme hiérarchique avec une nouvelle fonction « closeness »
Soit la fonction « closeness » suivante :

Appliquez la nouvelle fonction « closeness » sur l’architecture suivante :

Figure 11 : Architecture du système à partitionner.

11
 La valeur maximale de la fonction « closeness » est c(o1,o3), donc nous pouvons
regrouper o1 et o3 ensemble (o1 et o3 seront considérées comme une seule tâche appelée
o13). La figure suivante montre la nouvelle architecture du système :

O13

Figure 12 : Nouvelle architecture du système après la première itération du

partitionnement hiérarchique.

12
 La valeur maximale de la fonction « closeness » est c(o13,o2), donc nous pouvons
regrouper o13 et o2 ensemble (o13 et o2 seront considérées comme une seule tâche appelée
o132). La figure suivante montre la nouvelle architecture du système :

O132

Figure 13 : Nouvelle architecture du système après la deuxième itération du

partitionnement hiérarchique.
6.3.Algorithme ILP (Integer Linear Program)
Afin de comprendre le principe de fonctionnement de l’algorithme ILP, nous présentons le
système à implémenter ainsi que l’architecture cible :

13
Figure 14 : Système à implémenter, architecture cible et coût matériel et logiciel des
différentes tâches.
L’objectif de l’algorithme ILP est de chercher la solution optimale (quelles sont les
tâches matérielles et quelles sont les tâches logicielles) permettant de minimiser le coût total
de l’application.

- Xi,k : « i » représente le numéro de la tâche et « k » représente le numéro de l’entité

qui exécute cette tâche. Par exemple X1,2 = 1 signifie que la tâche 1 s’exécute sur
l’entité 2. X3,1 = 0 signifie que la tâche 3 ne s’exécute pas sur l’entité 1.
- Le nombre total des tâches est « n » alors que le nombre total d’entités (processeur,
ASIC, etc.) est « m ».
- Ci,k : le coût d’exécution de la tâche « i » lorsqu’elle s’exécute sur l’entité « k ».

14
 Figure 15 : Application de l’algorithme IPL sur l’architecture cible disponible.
Ici nous avons n = 6 tâches et m = 2 entités (un processeur : Software et un ASIC :
Hardware). Si la tâche 1 s’exécute sur le processeur alors X1,1 = 1 et X1,2 = 0 (une tâche
s’exécute uniquement sur une seule entité, dans notre cas soit sur le processeur soit sur
l’ASIC). Donc nous avons le système d’équations suivant :
X1,1 + X1,2 = 1.
X2,1 + X2,2 = 1.
X3,1 + X3,2 = 1.
X4,1 + X4,2 = 1.
X5,1 + X5,2 = 1.
X6,1 + X6,2 = 1.
La fonction à minimiser est la suivante :
F= 80 X1,1 + 320 X1,2 + 240 X2,1 + 170 X2,2 + 710 X3,1 + 120 X3,2 + 130 X4,1 + 20
X4,2 + 100 X5,1 + 400 X5,2 + 80 X6,1 + 260 X6,2.
F = 80 (X1,1 + X1,2) + 240 X1,2 + 170 (X2,1 + X2,2) + 70 X2,1 + 120 (X3,1 + X3,2) + 590
X3,1 + 20 (X4,1 + X4,2) + 110 X4,1 + 100 (X5,1 + X5,2) + 300 X5,2 + 80 (X6,1 + X6,2) +
180 X6,2.
F = 80 + 170 + 120 + 20 + 100 + 80 + 240 X1,2 + 70 X2,1 + 590 X3,1 + 110 X4,1 + 300
X5,2 + 180 X6,2.
F = 570 + 240 X1,2 + 70 X2,1 + 590 X3,1 + 110 X4,1 + 300 X5,2 + 180 X6,2.
Minimizer F  X1,2 = X2,1 = X3,1 = X4,1 = X5,2 = X6,2 = 0.
 X1,1 = 1 (la tâche 1 s’exécute sur l’entité 1, c’est à dire le processeur).
 X2,2 = 1 (la tâche 2 s’exécute sur l’entité 2, c’est à dire l’ASIC).
 X3,2 = 1 (la tâche 3 s’exécute sur l’entité 2, c’est à dire l’ASIC).
15
 X4,2 = 1 (la tâche 4 s’exécute sur l’entité 2, c’est à dire le processeur).
 X5,1 = 1 (la tâche 5 s’exécute sur l’entité 1, c’est à dire le processeur).
 X6,1 = 1 (la tâche 6 s’exécute sur l’entité 1, c’est à dire le processeur).
La figure suivante montre que le coût optimal obtenu est 570. La meilleure solution
obtenue est : les tâches 1, 5, et 6 sont des tâches logicielles alors que les tâches 2, 3 et 4 sont
des tâches matérielles.

Figure 16 : Solution optimale en appliquant l’algorithme ILP.

Supposons maintenant qu’on va ajouter la contrainte suivante : le coût matériel de la
solution ne doit pas dépasser 300.

Donc il faut optimiser le coût total (le coût d’implémentation du système entier sur
l’architecture cible) tout en respectant la nouvelle contrainte (coût matériel <= 300).
Coût matériel <= 300  320 X1,2 + 170 X2,2 + 120 X3,2 + 20 X4,2 + 400 X5,2 + 260 X6,2
<= 300  X1,2 = 0, X5,2 = 0  X1,1 = X5,1 = 1 (les tâches 1 et 5 sont exécutées sur l’entité
1 qui est l’entité logicielle : le processeur).
Pour résoudre le reste du problème, il faut remplir le tableau suivant (X1,2 et X5,2 ne
figurent pas dans le tableau puisque nous savons déjà que les tâches 1 et 5 ne peuvent pas être

16
matérielles puisque chacune des deux tâches dépasse le coût matériel 300 en cas de leurs
exécution sur l’entité matérielle) :
X2,2 X3,2 X4,2 X6,2 Coût logiciel Coût matériel Coût total
0 0 0 0 1340 0 1340
0 0 0 1 1260 260 1520
0 0 1 0 1210 20 1230
0 0 1 1 1130 280 1410
0 1 0 0 630 120 750
0 1 0 1 550 380 930
0 1 1 0 500 140 640
0 1 1 1 420 400 820
1 0 0 0 1100 170 1270
1 0 0 1 1020 430 1450
1 0 1 0 970 190 1160
1 0 1 1 890 450 1340
1 1 0 0 390 290 680
1 1 0 1 310 550 860
1 1 1 0 260 310 570
1 1 1 1 180 570 750

Parmi toutes les solutions ayant un coût matériel <= 300, nous devrons choisir la
solution ayant le coût total optimal, c’est-à-dire la solution ayant un coût total = 640.

Figure 17 : Solution optimale en appliquant l’algorithme ILP avec la contrainte Hw_cost

<=300.

17
Remarque :
Les coûts des communications entre les différentes tâches dans l’algorithme ILP ont
été négligés dans la partie précédente. Dans l’exemple de la figure 22 (le même exemple
précédent en ajoutant les coûts des communications entre les différentes tâches), nous allons
considérer que la communication externe entre deux tâches a un coût alors que la
communication interne entre deux tâches est nulle. Avant de passer à l’exemple de la figure
22, définissons tout d’abord la communication interne et la communication externe :
Communication interne
Deux tâches ont une communication interne si elles sont exécutées par la même entité
et il y a une dépendance de données entre ces deux tâches.
Communication externe
Deux tâches ont une communication externe si elles sont exécutées par deux entités
différentes et il y a une dépendance de données entre ces deux tâches.

Exemple :
Soit l’architecture suivante : (la valeur 2 signifie que la communication entre la tâche Ti et la
tâche Tj est égale à 2 si la communication est externe).

Figure 18 : Système composé de neuf tâches à implémenter sur une architecture cible.

18
 Dans l’exemple de la figure 18, on suppose que le partitionnement a été déjà fait en
utilisant un algorithme de partitionnement quelconque et une architecture cible composée de
deux processeurs et d’un bus de communication.

Processeur P1

Bus de communication

Processeur P2

Figure 19 : Architecture cible.

Supposons que le résultat de partitionnement donne le résultat suivant : les tâches T0,
T1, T2, T3 et T4 sont exécutées sur le processeur P1 (entité 1), alors que les tâches T5, T6, T7
et T8 sont exécutés sur le processeur P2 (entité 2).

Figure 20 : Résultat de partitionnement de neuf taches sur une architecture composée de

deux processeurs.
La communication entre la tâche T1 et la tâche T5 et la communication entre la tâche
T4 et la tâche T7 sont deux communications externes de coût égal à 2 pour chacune des

19
communications. Par contre le coût de la communication entre T0 et T1 ou entre T6 et T8, ou
entre T2 et T3, etc. sont des communications internes de coût égal à zéro (le coût est nul
puisque les deux tâches communicantes sont exécutés par la même entité. Les coûts indiqués
sur la figure seraient considérés si les tâches communicantes étaient exécutées par des entités
différentes).
Le schéma exact après partitionnement est donc le suivant :

Figure 21 : Résultat correct de partitionnement de neuf tâches sur une architecture cible
composée de deux processeurs.

20
Soit l’exemple suivant :

Figure 22 : Application de l’algorithme IPL sur l’architecture cible disponible en tenant

compte des coûts des communications.
La nouvelle fonction coût à optimiser est la suivante pour cet exemple :

- com i,j est le coût de la communication entre la tâche i et le tâche j.

21
 - g i,j = 1 s’il y a communication externe entre la tâche i et la tâche j (c’est-à-dire que la
communication est réalisée à travers un bus externe de communication. Autrement dit
si les deux tâches i et j sont réalisées par deux entités différentes).
Nous avons le même système d’équations de la page 15 :
X1,1 + X1,2 = 1.
X2,1 + X2,2 = 1.
X3,1 + X3,2 = 1.
X4,1 + X4,2 = 1.
X5,1 + X5,2 = 1.
X6,1 + X6,2 = 1.
La fonction coût dans ce cas-là devient :
F= 80 X1,1 + 320 X1,2 + 240 X2,1 + 170 X2,2 + 710 X3,1 + 120 X3,2 + 130 X4,1 + 20
X4,2 + 100 X5,1 + 400 X5,2 + 80 X6,1 + 260 X6,2 + com1,2 g1,2 + com1,3 g1,3 + com2,4
g2,4 + com2,5 g2,5 + com3,5 g3,5 + com4,6 g4,6 + com5,6 g5,6.
F = 80 (X1,1 + X1,2) + 240 X1,2 + 170 (X2,1 + X2,2) + 70 X2,1 + 120 (X3,1 + X3,2) + 590
X3,1 + 20 (X4,1 + X4,2) + 110 X4,1 + 100 (X5,1 + X5,2) + 300 X5,2 + 80 (X6,1 + X6,2) +
180 X6,2 + com1,2 g1,2 + com1,3 g1,3 + com2,4 g2,4 + com2,5 g2,5 + com3,5 g3,5 +
com4,6 g4,6 + com5,6 g5,6.
F = 80 + 170 + 120 + 20 + 100 + 80 + 240 X1,2 + 70 X2,1 + 590 X3,1 + 110 X4,1 + 300
X5,2 + 180 X6,2 + com1,2 g1,2 + com1,3 g1,3 + com2,4 g2,4 + com2,5 g2,5 + com3,5 g3,5 +
com4,6 g4,6 + com5,6 g5,6.
F = 570 + 240 X1,2 + 70 X2,1 + 590 X3,1 + 110 X4,1 + 300 X5,2 + 180 X6,2 + com1,2 g1,2
+ com1,3 g1,3 + com2,4 g2,4 + com2,5 g2,5 + com3,5 g3,5 + com4,6 g4,6 + com5,6 g5,6.
Il s’agit des mêmes équations de la page 15 mais en ajoutant les coûts des
communications externes (en rouge). Sans aucune contrainte, la minimisation de cette
fonction est difficile à résoudre.
Si on ajoute la même contrainte de la page 16 (coût matériel <=300) :

La résolution du problème devient plus facile : il faut optimiser le coût total (le coût
d’implémentation du système entier sur l’architecture cible en tenant compte des coûts des
communications) tout en respectant la nouvelle contrainte (coût matériel <= 300).
Coût matériel <= 300  320 X1,2 + 170 X2,2 + 120 X3,2 + 20 X4,2 + 400 X5,2 + 260 X6,2
<= 300  X1,2 = 0, X5,2 = 0  X1,1 = X5,1 = 1 (les tâches 1 et 5 sont exécutées sur l’entité
1 qui est l’entité logicielle : le processeur).

22
 Pour résoudre le reste du problème, il faut remplir le tableau suivant (X1,2 et X5,2 ne
figurent pas dans le tableau puisque nous savons déjà que les tâches 1 et 5 ne peuvent pas être
matérielles puisque chacune des deux tâches dépasse le coût matériel 300 en cas de leurs
exécution sur l’entité matérielle) :
X2,2 X3,2 X4,2 X6,2 Coût Coût Coût des Coût total (en tenant
logiciel matériel communications compte des
communications
externes)
0 0 0 0 1340 0 0 1340
0 0 0 1 1260 260 5 + 50 = 55 1575
0 0 1 0 1210 20 200 + 5 = 205 1435
0 0 1 1 1130 280 200 + 50 = 250 1660
0 1 0 0 630 120 250 + 100 = 350 1100
0 1 0 1 550 380 250 +100 + 5 + 1335
50 = 405
0 1 1 0 500 140 200 + 5 + 250 + 1195
100 = 555
0 1 1 1 420 400 200 + 50 + 250 1420
+ 100 = 600
1 0 0 0 1100 170 20 + 200 + 10 = 1500
230
1 0 0 1 1020 430 20 + 200 + 10 + 1735
5 + 50 = 285
1 0 1 0 970 190 20 + 10 + 5 = 35 1195
1 0 1 1 890 450 20 + 10 + 50 = 1420
80
1 1 0 0 390 290 20 + 10 + 200 + 1260
250 +100 = 580
1 1 0 1 310 550 20 + 10 + 200 + 1495
250 +100 + 5 +
50 = 635
1 1 1 0 260 310 20 + 10 +5 + 955
250 + 100 = 385
1 1 1 1 180 570 20 + 10 + 50 + 1180
250 + 100 = 430

Parmi toutes les solutions ayant un coût matériel <= 300, nous devrons choisir la
solution ayant le coût total optimal, c’est-à-dire la solution ayant un coût total = 1100.

23
Figure 23 : Solution optimale en appliquant l’algorithme ILP avec la contrainte Hw_cost
<=300 et en tenant compte des communications externes.

24