Cours GRF
This commit is contained in:
Némunaire
parent
98e42d4fc1
commit
ee965d6137
2
base.tex
2
base.tex
@ -14,6 +14,8 @@
|
||||
\usepackage{array}
|
||||
\usepackage{tikz}
|
||||
|
||||
\usepackage{gantt}
|
||||
|
||||
\definecolor{dkgreen}{rgb}{0,0.6,0}
|
||||
\definecolor{gray}{rgb}{0.5,0.5,0.5}
|
||||
\definecolor{mauve}{rgb}{0.58,0,0.82}
|
||||
|
||||
@ -4,4 +4,4 @@
|
||||
|
||||
\maketitle
|
||||
|
||||
\input{20120306}
|
||||
\input{20120426-instructionselection}
|
||||
|
||||
319
grf/cours.tex
319
grf/cours.tex
@ -432,3 +432,322 @@ courts en appliquant deux changements~:
|
||||
\item \textbf{À l'itération $k$~:} on remplace l'opération $\max$ par
|
||||
$\min$.
|
||||
\end{itemize}
|
||||
|
||||
%Deuxième cours
|
||||
\section{Problème d'orgonnancement de projets}
|
||||
|
||||
Le but est de trouver l'ordonnancement au plus tôt de toutes les tâches.
|
||||
|
||||
On représente généralement ce genre de problème sous la forme de diagrammes de
|
||||
Gantt calés à gauche.
|
||||
|
||||
Le deuxième objectif est de déterminer le chemin critique~: tout retard sur une
|
||||
tâche critique se représente sur la durée totale du projet.
|
||||
|
||||
POiur les tâches non-critiques, on peut calculer la marge totale et la marge
|
||||
libre.\\
|
||||
|
||||
Il existe deux méthodes principales pour calculer les crontraites de type
|
||||
\emph{potentiel}~: la méthode tâche et la méthode PERT (qui ne sera pas traitée
|
||||
dans ce cours).
|
||||
|
||||
Les seules contraintes sont du type~: \og la tâche B ne peut démarrer que 3
|
||||
jours après la tâche A\fg.
|
||||
|
||||
\paragraph{Remarque} les contraintes les plus dures ne sont pas prises en
|
||||
compte~: on parle de type cumulatif.
|
||||
|
||||
Lorsque les ressources sont limités, les interactions sont très fortes entre
|
||||
les tâches.
|
||||
|
||||
\subsection{Méthode portentiels-tâches}
|
||||
|
||||
\paragraph{Exemple} On a un problème à 7 tâches ($a$, $b$, $c$, $d$, $e$, $f$
|
||||
et $g$)~; les contraintes sont de type portentiel seulement.
|
||||
|
||||
Soit le tableau des contraintes suivantes~:
|
||||
|
||||
\begin{figure}[h]
|
||||
\centering
|
||||
\begin{tabular}{c|c|c}
|
||||
\textbf{Tâches} & \textbf{Durées} & \textbf{Contraintes}\\
|
||||
\hline
|
||||
$a$ & 6 & \\
|
||||
$b$ & 3 & \\
|
||||
$c$ & 6 & \\
|
||||
$d$ & 2 & $b$ achevée\\
|
||||
$e$ & 4 & $b$ achevée\\
|
||||
$f$ & 3 & $a$ et $d$ achevées\\
|
||||
$g$ & 1 & $c$, $e$ et $f$ achevées\\
|
||||
\end{tabular}
|
||||
\end{figure}
|
||||
|
||||
\subsubsection{Ordonancement au plus tôt -- Algorithme de Bellman}
|
||||
|
||||
On peut représenter le tableau des contraintes à l'aide d'un graphe, le graphe
|
||||
\emph{potentiels-tâches}, dans lequel~:
|
||||
|
||||
\begin{itemize}
|
||||
\item un sommet est associé à chaque tâche~;
|
||||
\item un sommet $\alpha$ que l'on associe au début du projet~;
|
||||
\item un sommet $\omega$ qui sera la fin du projet.
|
||||
\end{itemize}
|
||||
|
||||
On aura un arc $i,j$ si la tâche $j$ ne peut démarrer qu'après la tâche $i$. Il
|
||||
s'agit d'une contrainte d'antécédence entre tâches.
|
||||
|
||||
La valuation de l'arc $i,j$~: le plus souvent, c'est la durée de la tâche $i$.
|
||||
La tâche $j$ ne peut démarrer que lorsque la tâche $i$ est achevée~: entre le
|
||||
début de la tâche $j$ et le début de la tâche $i$ qui la précéde s'écoule le
|
||||
temps d'exécution de la tâche $i$.
|
||||
|
||||
\paragraph{Remarque} On peut rencontrer le contraire~: \og $j$ ne peut démarrer
|
||||
que 2 jours après le début de $i$\fg. Dans ce cas, l'arc $i,j$ sera valué par
|
||||
2.
|
||||
|
||||
\begin{tikzpicture}[->,>=stealth',shorten >=1pt,auto,node distance=3cm,
|
||||
thick,main node/.style={circle,fill=blue!20,draw,font=\sffamily\Large\bfseries}]
|
||||
\node[main node] (2) {$a$};
|
||||
\node[main node] (3) [below of=2] {$b$};
|
||||
\node[main node] (1) [left of=3] {$\alpha$};
|
||||
\node[main node] (4) [below of=3] {$c$};
|
||||
\node[main node] (5) [right of=3] {$d$};
|
||||
\node[main node] (6) [below of=5] {$e$};
|
||||
\node[main node] (7) [right of=5] {$f$};
|
||||
\node[main node] (8) [below of=7] {$g$};
|
||||
\node[main node] (9) [right of=7] {$\omega$};
|
||||
|
||||
\path[every node/.style={font=\sffamily\small}]
|
||||
(1) edge [right] node[right] {0} (2)
|
||||
edge [right] node[left] {0} (3)
|
||||
edge [right] node[left] {0} (4)
|
||||
(2) edge [right] node[right] {6} (7)
|
||||
(3) edge [right] node[right] {3} (5)
|
||||
edge [right] node[left] {3} (6)
|
||||
(4) edge [bend right] node[right] {6} (8)
|
||||
(5) edge [right] node[right] {2} (7)
|
||||
(6) edge [right] node[right] {4} (8)
|
||||
(7) edge [right] node[right] {3} (8)
|
||||
(8) edge [right] node[right] {1} (9)
|
||||
;
|
||||
\end{tikzpicture}
|
||||
|
||||
La durée minimale correspond au chemin le plug long entre $\alpha$ et
|
||||
$\omega$.
|
||||
|
||||
\subsubsection{Algorithme de Bellman}
|
||||
|
||||
On commence par dresser le tableau suivant~:
|
||||
|
||||
\hspace{-1cm}
|
||||
\begin{tabular}{|c|c|c|c|c|c|c|c|c|c|}
|
||||
\hline
|
||||
& {\color{mauve} 0} & {\color{dkgreen} 0} & {\color{dkgreen} 0} &
|
||||
{\color{dkgreen} 0} & {\color{red} 3} & {\color{red} 3} & {\color{red} 6} &
|
||||
{\color{red} 9} & {\color{red} 10} \\
|
||||
\hline
|
||||
Tâche & $\alpha$ & $a$ & $b$ & $c$ & $d$ & $e$ & $f$ & $g$ & $\omega$\\
|
||||
\hline
|
||||
Prédécesseurs & & {\color{mauve} 0} $\alpha$~: 0 & {\color{mauve} 0}
|
||||
$\alpha$~: 0 & {\color{mauve} 0} $\alpha$~: 0 & {\color{blue} 0} $b$~: 3 &
|
||||
{\color{blue} 0} $b$~: 3 & $\psi=$ {\color{blue} 0} $a$~: 6 & {\color{blue}
|
||||
0} $c$~: 6 & {\color{blue} 9} $g$~: 1\\
|
||||
&&&&&&& $\chi=$ {\color{blue} 3} $d$~: 2 & {\color{blue} 3} $e$~: 4&\\
|
||||
&&&&&&&& {\color{blue} 6} $f$~: 3&\\
|
||||
\hline
|
||||
\end{tabular}
|
||||
|
||||
\paragraph{Initialisation} Le projet démarre à la date 0. Il s'agit de la date
|
||||
de début au plus tôt de $\alpha$~; ici {\color{mauve} 0}.
|
||||
|
||||
\paragraph{Deuxième phase} {\color{mauve} Mmouvement de haut en bas.}\\
|
||||
Dès que l'on connaît une date de début au plus tôt (1\iere ligne du tableau),
|
||||
on la répercute dans la deuxième ligne du tableau partout où la tâche concernée
|
||||
apparaît.
|
||||
|
||||
\subparagraph{Ensuite} {\color{dkgreen} mouvement de bas en haut.}\\
|
||||
Dès que l'on connaît les dates de début au plus tôt de tous les prédécesseurs
|
||||
d'une tâche, on dit que la colonne est complète, et on calcule la date de
|
||||
dévbut au plus tôt de la tâche en tête de colonne (première ligne) par la
|
||||
formule de Bellman~:
|
||||
|
||||
$$t_j=\max[t_i+v_{ij}]\qquad i\in(\Gamma^{-1}(j))$$
|
||||
|
||||
Par exemple, dans la colonne $f$, $\psi$ et $\chi$ sont $t_i$ et 6 et 2 sont $v_{ij}$
|
||||
|
||||
\begin{itemize}
|
||||
\item $t_j$~: la date de début au plus tôt de $j$~;
|
||||
\item $v_{ij}$~: valuation de l'arc $(i,j)$~;
|
||||
\item $\Gamma^{-1}$~: prédécesseur de $j$.
|
||||
\end{itemize}
|
||||
|
||||
{\color{blue} Ensuite}
|
||||
|
||||
{\color{red} Ensuite}
|
||||
|
||||
\vspace{1.5em}
|
||||
|
||||
L'ordonnancement au plus tôt est donc la durée minimale du projet, soit la date
|
||||
au plus tôt de $\omega$ = 10~jours.
|
||||
|
||||
\begin{gantt}{8}{10}
|
||||
\begin{ganttitle}
|
||||
\numtitle{1}{1}{10}{1}
|
||||
\end{ganttitle}
|
||||
\ganttbar{$a$}{0}{6}
|
||||
\ganttbar{$b$}{0}{3}
|
||||
\ganttbar{$c$}{0}{6}
|
||||
\ganttbar{$d$}{3}{2}
|
||||
\ganttbar{$e$}{3}{4}
|
||||
\ganttbar{$f$}{6}{3}
|
||||
\ganttbar{$g$}{9}{1}
|
||||
\ganttcon{6}{1}{6}{6}
|
||||
\ganttcon{9}{6}{9}{7}
|
||||
\end{gantt}
|
||||
|
||||
|
||||
\begin{figure}[h]
|
||||
\centering
|
||||
\begin{tikzpicture}[->,>=stealth',shorten >=1pt,auto,node distance=2.5cm,
|
||||
thick,main node/.style={circle,fill=blue!20,draw,font=\sffamily\Large\bfseries}]
|
||||
\node[main node] (1) {$\alpha$};
|
||||
\node[main node] (2) [right of=1] {$a$};
|
||||
\node[main node] (3) [right of=2] {$f$};
|
||||
\node[main node] (4) [right of=3] {$g$};
|
||||
\node[main node] (5) [right of=4] {$\omega$};
|
||||
|
||||
\path[every node/.style={font=\sffamily\small}]
|
||||
(1) edge [right] node[right] {0} (2)
|
||||
(2) edge [right] node[right] {6} (3)
|
||||
(3) edge [right] node[right] {3} (4)
|
||||
(4) edge [right] node[right] {1} (5)
|
||||
;
|
||||
\end{tikzpicture}
|
||||
\caption{Chemin critique}
|
||||
\end{figure}
|
||||
|
||||
\vspace{1.5em}
|
||||
|
||||
On s'intéresse à l'ordonancement au plud tard, pour calculer les marges de
|
||||
toutes les tâches non critiques.
|
||||
|
||||
\subparagraph{Hypothèse} La durée minimale du projet est respectée.
|
||||
|
||||
Pour les tâches croitiques, la date de début au plus tard est égale à la date
|
||||
de début au plus tôt.
|
||||
|
||||
Quelles sont les dates de début au plus tard des tâches non critiques~?
|
||||
|
||||
\vspace{1em}
|
||||
|
||||
\hspace{-1.5cm}
|
||||
\begin{tabular}{|c|c|c|c|c|c|c|c|c|c|}
|
||||
\hline
|
||||
& 0 & 0 & 1 & 3 & 4 & 5 & 6 & 9 & 10\\
|
||||
\hline
|
||||
Tâche & $\alpha$ & $a$ & $b$ & $c$ & $d$ & $e$ & $f$ & $g$ & $\omega$\\
|
||||
\hline
|
||||
Successeurs & {\color{blue} 0} $a$~: 0 & {\color{blue} 6} $f$~: 6 &
|
||||
{\color{blue} 4} $d$~: 3 & {\color{blue} 9} $g$~: 6 & {\color{blue} 6} $f$~:
|
||||
2 & {\color{blue} 9} $g$~: 4 & {\color{blue} 9} $g$~: 3 & {\color{blue} 10}
|
||||
$\omega$~: 1&\\
|
||||
& {\color{blue} 1} $b$~: 0 & & {\color{blue} 5} $e$~: 3 &&&&&&\\
|
||||
& {\color{blue} 3} $c$~: 0 &&&&&&&&\\
|
||||
\hline
|
||||
\end{tabular}
|
||||
\vspace{1em}
|
||||
|
||||
Pour les tâches critiques~:
|
||||
$$t_a^*=t_a=0$$
|
||||
$$t_f^*=t_f=6$$
|
||||
$$t_g^*=t_g=9$$
|
||||
|
||||
Pour les tâches non-critiques~: la \emph{marge totale} = $M_i=t_i^*-t_i$, soit~:
|
||||
$$M_b=1$$
|
||||
$$M_c=3$$
|
||||
$$M_d=1$$
|
||||
$$M_e=2$$
|
||||
|
||||
La \emph{marge libre}, $m_i$, est le délai dont on peut retarder la tâche $i$
|
||||
sans conséquence sur ses successeurs.
|
||||
$$m_i=\min(t_j-t_i-v_{ij})\qquad j\in\Gamma(i)$$
|
||||
|
||||
$$m_b=\min_{d,e}\lbrace t_d-t_b-v_{bd};t_e-t_b-v_{be}\rbrace$$
|
||||
$$=\min_{d,e}\lbrace 3-0-3;3-0-3\rbrace=0$$
|
||||
|
||||
\subsubsection{Deuxième application~: algorithme de Ford}
|
||||
|
||||
Cet algorithme permet de trouver le chemin le plus long, ou le chemin le plus
|
||||
court entre un sommet particulier (la racine) et tous les autres sommets du
|
||||
graphe.
|
||||
|
||||
\paragraph{Initialisation} On numérote les sommets, le sommet racine prennant
|
||||
le numéro 1. On essaye de respecter autant que possible la numérotation
|
||||
topologique des sommets.
|
||||
|
||||
\begin{figure}[h]
|
||||
\centering
|
||||
\begin{tikzpicture}[->,>=stealth',shorten >=1pt,auto,node distance=2.5cm,
|
||||
thick,main node/.style={circle,fill=blue!20,draw,font=\sffamily\Large\bfseries}]
|
||||
\node[main node] (1) {$i$};
|
||||
\node[main node] (2) [right of=1] {$j$};
|
||||
|
||||
\path[every node/.style={font=\sffamily\small}]
|
||||
(1) edge [right] node[right] {} (2)
|
||||
;
|
||||
\end{tikzpicture}
|
||||
\caption{Représentation topologique~; ici $i<j$}
|
||||
\end{figure}
|
||||
|
||||
|
||||
Voir graphe page 106.
|
||||
|
||||
On cherche le chemin le plus court allant du sommet 1 vers tous les autres
|
||||
sommets.
|
||||
|
||||
\paragraph{Marquage des sommets} On affecte au sommet 1 la valeur $\lambda_1=0$
|
||||
et à tous les autres sommets la valeur $\lambda_i=+\infty$.
|
||||
|
||||
\begin{itemize}
|
||||
\item $\lambda_i$ évolue en cours d'algorithme~;
|
||||
\item le dernier $\lambda_i$ affecté à $i$ donne la longueur du chemin le
|
||||
plus court allant du sommet 1 au sommet $i$.
|
||||
\end{itemize}
|
||||
|
||||
\vspace{1em}
|
||||
|
||||
On examine à tour de rôle tous les arcs partant du sommet $i$, en commençant
|
||||
par $i=1$. Pour ne pas en oublier, on fait cet examen dans l'ordre croissant de
|
||||
l'extrémité $j$.
|
||||
\vspace{1em}
|
||||
Au moment de l'examen de l'arc $(i,j)$~: $v(i,j)$ est la valuation de l'arc
|
||||
$(i,j)$.
|
||||
|
||||
Si $v(i,j)<\lambda_i-\lambda_j$, alors on remplace $\lambda_j$ par
|
||||
$\lambda_i+v(i,j)$.
|
||||
|
||||
Si à un moment donné, on a $i>j$ et un changement de valeur pour $\lambda_j$,
|
||||
il faut recommencer une partie des opérations, en repartant du sommet $i=j$. On
|
||||
appel cela un retour en arrière.
|
||||
|
||||
|
||||
\subparagraph{Par exemple} examen de l'arc $(11,10)$.
|
||||
|
||||
Cet examen risque d'entraîner le changement de valeur de $\lambda_{10}$. Alors,
|
||||
il faut reprendre l'examen de l'arc $(10,13)$ avec la nouvelle valeur
|
||||
$\lambda_{10}$.
|
||||
|
||||
\subparagraph{Go~!} examen de l'arc $(1,2)$.
|
||||
$2 < \infty - 0$~? Oui $\Rightarrow$ on remplace $\lambda_2$ par
|
||||
$\lambda_1+v(1,2)=0+2=2$.
|
||||
|
||||
\subparagraph{Remarque} Dans cet exemple, pas de retour en arrière, bien qu'un arc
|
||||
ait ses extrêmités avec une numérotation non topologique. L'examen de l'arc
|
||||
$(11,10)$ n'a pas entraîné la modification de $\lambda_{10}$. On ne doit pas
|
||||
reaire l'examen de l'arc $(10,13)$.
|
||||
|
||||
\paragraph{Phase 2} identification du chemin solution.
|
||||
|
||||
On par de l'extrêmité terminale soit $i$. Le prédécesseur de $i$ est le sommet
|
||||
$i$ tel que~:
|
||||
$$\lambda_i-\lambda_{i'}=v(i',i)$$
|
||||
|
||||
263
grf/gantt.sty
Normal file
263
grf/gantt.sty
Normal file
@ -0,0 +1,263 @@
|
||||
\ProvidesPackage{gantt}[2011/03/20 Some macros for drawing gantt diagrams using tkiz v.1.3]
|
||||
% Some macros for drawing gantt diagrams using tkiz.
|
||||
%
|
||||
% Martin Kumm, 17.05.2010 (Version 1.0)
|
||||
% Alan Munn, Martin Kumm, 14.03.2011 (Version 1.2)
|
||||
% Andrés Silva Marambio, 20.03.2011 (Version 1.3)
|
||||
%
|
||||
% Update 20.03.2011, Version 1.3
|
||||
%
|
||||
% changes from v1.2:
|
||||
% change \ProvidesPackage{gantt.sty} for \ProvidesPackage{gantt}
|
||||
% add \bfseries for the command \ganttgroup
|
||||
% add two newcommands for doing Gantt Milestones: \ganttmilestone and \ganttmilestonecon
|
||||
% usage: \ganttmilestone[color=<color>]{label}{start} - Create a gantt milestone using a diamond
|
||||
% usage: \ganttmilestonecon[color=<color>]{label}{start} - Create a gantt milestone using a diamond and conect with the previuos itemg
|
||||
% fixed the issue when \ganttbarcon or \ganttmilestonecon connect in decimal positions
|
||||
%
|
||||
% Update 15.03.2011, Version 1.2
|
||||
%
|
||||
% changes from v1.1:
|
||||
% px sizes has ben changed ot pt due to problems with some LaTeX distributions (thanks to Michael Kubovy and Loïc Le Guyader!)
|
||||
% Correction of the text aligned in \titleelement (thanks to Josh Hykes!)
|
||||
% \unitlength was changed to \ganttunitlength (thanks to Alan Munn!)
|
||||
% \RequirePackage was added (thanks to Alan Munn!)
|
||||
%
|
||||
% Update 05.08.2010, Version 1.1
|
||||
%
|
||||
% changes from v1.0:
|
||||
% \ganttbar and \ganttbarcon have been extended with the xkeyval syntax
|
||||
% The pattern of the bar is now independent of the color and can be set by
|
||||
% e.g. \ganttbar[pattern=horizontal lines,color=blue]{...}{1}{1}
|
||||
% This syntax is incompatible with the previous ones!
|
||||
% replace \ganttbar[<pattern>] with \ganttbar[pattern=<pattern>]
|
||||
|
||||
\RequirePackage{tikz,pgffor,xkeyval,ifthen,calc,forloop}
|
||||
|
||||
\usetikzlibrary{patterns}
|
||||
\usetikzlibrary{arrows}
|
||||
|
||||
\newcounter{ganttnum}
|
||||
\newcounter{ganttwidth}
|
||||
|
||||
\newlength{\ganttlastx}
|
||||
\setlength{\ganttlastx}{0cm}
|
||||
|
||||
\newlength{\nextganttlastx}
|
||||
|
||||
\newlength{\gantttmpa}
|
||||
\newlength{\gantttmpb}
|
||||
\newlength{\ganttunitlength}
|
||||
|
||||
\setlength{\ganttunitlength}{1cm}
|
||||
|
||||
\newlength{\titleunitlength}
|
||||
\setlength{\titleunitlength}{1cm}
|
||||
|
||||
\newcounter{gantttitlenum}
|
||||
|
||||
\define@key{ganttx}{xunitlength}{%
|
||||
\setlength{\ganttunitlength}{#1}
|
||||
}
|
||||
\define@boolkey{ganttx}{drawledgerline}{}
|
||||
|
||||
\define@key{ganttx}{fontsize}{\def\ganttfontsize{#1}}
|
||||
\define@key{ganttx}{titlefontsize}{\def\gantttitlefontsize{#1}}
|
||||
|
||||
\presetkeys{ganttx}{drawledgerline=false,xunitlength=1cm,titlefontsize=\small,fontsize=\normalsize}{}
|
||||
|
||||
\define@key{ganttbarx}{pattern}{\def\ganttbarpattern{#1}}
|
||||
\define@key{ganttbarx}{color}{\def\ganttbarcolor{#1}}
|
||||
|
||||
\presetkeys{ganttbarx}{pattern=north west lines,color=black}{}
|
||||
|
||||
|
||||
% The gantt environment draws the canvas of a gantt figure (realized as tikzpicture)
|
||||
% The usage is \begin{gantt}[...]{no of Tasks to plot}{no of time slots}
|
||||
% The optional argument [...] can be filled in a key=value syntax, using one or more of the following keys:
|
||||
%
|
||||
% xunitlength - length of one time slot (default: 1 cm)
|
||||
% fontsize - fontsize of labels (default: \normalsize)
|
||||
% titlefontsize - fontsize of title section (default: \small)
|
||||
% drawledgerline - Switch to enable/disable the drawing of horizontal ledger lines (default value: false)
|
||||
|
||||
\newenvironment{gantt}[3][]{%
|
||||
\begin{tikzpicture}[draw=black, yscale=.7,xscale=1]
|
||||
\tikzstyle{time}=[coordinate]
|
||||
\setkeys{ganttx}{#1}{%
|
||||
\setcounter{ganttwidth}{#3}
|
||||
|
||||
\setcounter{ganttnum}{0}
|
||||
\newcount\ganttx
|
||||
\newcount\ganttheight
|
||||
\ganttheight=#2 %define the number of Y ticks
|
||||
\advance\ganttheight by 1
|
||||
|
||||
\def\ganttxstringtop{};
|
||||
\def\ganttxstringbottom{};
|
||||
|
||||
\ganttx=0
|
||||
\draw (0,0.5) node[above] {\ganttxstringtop} -- (0,1.4-\ganttheight) node[below] {\ganttxstringbottom};
|
||||
\draw (\value{ganttwidth}*\ganttunitlength,0.5) node[above] {\ganttxstringtop} -- (\value{ganttwidth}*\ganttunitlength,1.4-\ganttheight) node[below] {\ganttxstringbottom};
|
||||
|
||||
%draw grid
|
||||
\foreach \t in {1,2,...,\value{ganttwidth}}{
|
||||
\ganttx=1
|
||||
\multiply\ganttx by \t
|
||||
|
||||
\draw[dotted] (\ganttunitlength*\t,-0.5) node[above] {\ganttxstringtop} -- (\ganttunitlength*\t,1.4-\ganttheight) node[below] {\ganttxstringbottom};
|
||||
}
|
||||
%draw x axis
|
||||
\draw[] (0,-#2+0.4) -- (\value{ganttwidth}*\ganttunitlength,-#2+0.4);
|
||||
}
|
||||
}{\end{tikzpicture}}
|
||||
|
||||
|
||||
% ganttitle is the environment for drawing the title section
|
||||
\newenvironment{ganttitle}[1][]{%
|
||||
\setlength{\ganttlastx}{0 cm}
|
||||
}{%
|
||||
\setlength{\ganttlastx}{0 cm}
|
||||
\addtocounter{ganttnum}{-1}%
|
||||
}
|
||||
|
||||
% \titleelement draws one element of the title
|
||||
% usage: \titleelement{label}{length}
|
||||
\newcommand{\titleelement}[2]{
|
||||
\setlength{\gantttmpa}{\ganttunitlength*#2}
|
||||
\divide\gantttmpa by 2;
|
||||
|
||||
\draw (\the\ganttlastx,\value{ganttnum}) rectangle (\the\ganttlastx+#2*\ganttunitlength,\value{ganttnum}+0.6);
|
||||
\node [text height=1.5ex,text depth=0.7ex] at (\the\ganttlastx+\the\gantttmpa,\value{ganttnum}+0.25) {%
|
||||
\gantttitlefontsize #1%
|
||||
};
|
||||
\setlength{\ganttlastx}{\ganttlastx+\ganttunitlength*\real{#2}}
|
||||
}
|
||||
|
||||
|
||||
% \numtitle draws a numbered sequence of title elements
|
||||
% usage: \numtitle{start number}{increment}{end number}{length of each title element}
|
||||
\newcommand{\numtitle}[4]{
|
||||
\forloop[#2]{gantttitlenum}{#1}{\(\value{gantttitlenum} < #3\) \or \(\value{gantttitlenum} = #3\)}%
|
||||
{%
|
||||
\titleelement{\thegantttitlenum}{#4}
|
||||
}
|
||||
}
|
||||
|
||||
% \ganttbar draws a single, unconnected bar for representing a task
|
||||
% usage: \ganttbar[pattern=<pattern>,color=<color>]{label}{start}{length}
|
||||
% where the optional comma separated arguments are:
|
||||
% pattern - is a tikz pattern (e.g. north west lines (default), north east lines, crosshatch, crosshatch dots, grid, ...)
|
||||
% color - a tikz color of the pattern (e.g. red, green blue gray, dark gray)
|
||||
% for more information see the tikz documentation
|
||||
\newcommand{\ganttbar}[4][]{
|
||||
\setlength{\gantttmpa}{#3\ganttunitlength}
|
||||
\setlength{\gantttmpb}{#4\ganttunitlength}
|
||||
\setlength{\gantttmpb}{\gantttmpa+\gantttmpb}
|
||||
|
||||
\ifKV@ganttx@drawledgerline
|
||||
\draw[dotted] (0,\value{ganttnum}-0.2) -- (\value{ganttwidth}*\ganttunitlength,\value{ganttnum}-0.2);
|
||||
\fi
|
||||
\node at (0,\value{ganttnum}) [anchor=base east] {%
|
||||
\ganttfontsize #2%
|
||||
};
|
||||
\setkeys{ganttbarx}{#1}{%
|
||||
\draw[pattern=\ganttbarpattern,pattern color=\ganttbarcolor] (\gantttmpa,\value{ganttnum}+0.1) rectangle (\gantttmpb,\value{ganttnum}+0.5);
|
||||
}
|
||||
\setlength{\ganttlastx}{\gantttmpb}
|
||||
\addtocounter{ganttnum}{-1}
|
||||
}
|
||||
|
||||
|
||||
% \ganttcon draws an arrow between to bars with specified coordinates
|
||||
% usage: \ganttcon{startx}{starty}{endx}{endy}
|
||||
\newcommand{\ganttcon}[4]{
|
||||
\draw[-latex,rounded corners=1pt] (#1\ganttunitlength,-#2+0.1 + 0.2) -- (#1\ganttunitlength+0.4*\ganttunitlength,-#2+0.1+0.2) -- (#1\ganttunitlength+0.4*\ganttunitlength,-#2-0.4+0.2) -- (#1\ganttunitlength-0.4*\ganttunitlength,-#2-0.4+0.2) -- (#1\ganttunitlength-0.4*\ganttunitlength,-#4+0.1+0.2) -- (#3\ganttunitlength,-#4+0.1+0.2);
|
||||
}
|
||||
|
||||
|
||||
% \ganttbarcon draws a single bar *and* connects the bar with the previous bar for
|
||||
% consecutive tasks
|
||||
% usage: \ganttbarcon[pattern=<pattern>,color=<color>]{label}{start}{length}
|
||||
% where the optional pattern argument are the same as for \ganttbar
|
||||
\newcommand{\ganttbarcon}[4][]{
|
||||
\setlength{\nextganttlastx}{\the\ganttlastx+1\ganttunitlength}
|
||||
\ifdim\nextganttlastx>#3\ganttunitlength
|
||||
\draw[-latex,rounded corners=1pt] (\the\ganttlastx,\value{ganttnum}+1.1 + 0.2) -- (\the\ganttlastx+0.4*\ganttunitlength,\value{ganttnum}+1.1+0.2) -- (\the\ganttlastx+0.4*\ganttunitlength,\value{ganttnum}+0.6+0.2) -- (\the\ganttlastx-0.4*\ganttunitlength,\value{ganttnum}+0.6+0.2) -- (\the\ganttlastx-0.4*\ganttunitlength,\value{ganttnum}+0.1+0.2) -- (#3\ganttunitlength,\value{ganttnum}+0.1+0.2);
|
||||
\else
|
||||
\draw[-latex,rounded corners=1pt] (\the\ganttlastx,\value{ganttnum}+1.1 + 0.2) -- (\the\ganttlastx+0.4*\ganttunitlength,\value{ganttnum}+1.1+0.2) -- (\the\ganttlastx+0.4*\ganttunitlength,\value{ganttnum}+0.1+0.2) -- (#3\ganttunitlength,\value{ganttnum}+0.1+0.2);
|
||||
\fi
|
||||
\ganttbar[#1]{#2}{#3}{#4}
|
||||
}
|
||||
|
||||
|
||||
% \ganttgroup draws a bar to group tasks
|
||||
% usage: \ganttgroup{label}{start}{length}
|
||||
\newcommand{\ganttgroup}[3]{%
|
||||
\setlength{\gantttmpa}{#2\ganttunitlength}
|
||||
\setlength{\gantttmpb}{#3\ganttunitlength}
|
||||
\setlength{\gantttmpb}{\gantttmpa+\gantttmpb}
|
||||
|
||||
\ifKV@ganttx@drawledgerline
|
||||
\draw[dotted] (0,\value{ganttnum}-0.2) -- (\value{ganttwidth}*\ganttunitlength,\value{ganttnum}-0.2);
|
||||
\fi
|
||||
\node at (0,\value{ganttnum}) [anchor=base east] {%
|
||||
\ganttfontsize\bfseries #1%
|
||||
};
|
||||
\fill[black] (\gantttmpa-0.14cm,\value{ganttnum}+0.2) rectangle (\gantttmpb+0.14cm,\value{ganttnum}+0.4);
|
||||
\draw[diamond-diamond] (\gantttmpa-0.14cm,\value{ganttnum}+0.2) -- (\gantttmpb+0.14cm,\value{ganttnum}+0.2);
|
||||
|
||||
\setlength{\ganttlastx}{\gantttmpb}
|
||||
\addtocounter{ganttnum}{-1}
|
||||
}
|
||||
|
||||
|
||||
% \ganttmilestone, draw a diamond to represent a milestone
|
||||
% usage: \ganttgroup[fill=<color>]{label}{start}
|
||||
% color - a tikz color of the pattern (e.g. red, green blue gray, dark gray)
|
||||
% for more information see the tikz documentation
|
||||
|
||||
% Declaring layers to abvoid superposition when you connect a \ganttmileston with a task
|
||||
\pgfdeclarelayer{background}
|
||||
\pgfdeclarelayer{foreground}
|
||||
\pgfsetlayers{background,main,foreground}
|
||||
|
||||
\newcommand{\ganttmilestone}[3][]{
|
||||
\setlength{\gantttmpa}{#3\ganttunitlength}
|
||||
\setlength{\gantttmpb}{0\ganttunitlength}
|
||||
\setlength{\gantttmpb}{\gantttmpa+\gantttmpb}
|
||||
|
||||
\ifKV@ganttx@drawledgerline
|
||||
\draw[dotted] (0,\value{ganttnum}-0.2) -- (\value{ganttwidth}*\ganttunitlength,\value{ganttnum}-0.2);
|
||||
\fi
|
||||
\node at (0,\value{ganttnum}) [anchor=base east] {%
|
||||
\ganttfontsize #2%
|
||||
};
|
||||
\setkeys{ganttbarx}{#1}{%
|
||||
\pgfonlayer{foreground}
|
||||
\draw[diamond-, color=\ganttbarcolor] (\gantttmpa,\value{ganttnum}+0.1) -- (\gantttmpb,\value{ganttnum}+0.4);
|
||||
\endpgfonlayer
|
||||
}
|
||||
\setlength{\ganttlastx}{\gantttmpb}
|
||||
\addtocounter{ganttnum}{-1}
|
||||
}
|
||||
|
||||
|
||||
% \ganttmilestonecon draws a single diamond *and* connects the diamond with the previous task
|
||||
% usage: \ganttmilestonecon[color=<color>]{label}{start}{length}
|
||||
% where the optional color argument are the same as for \ganttbar and \ganttmilestone
|
||||
|
||||
\newcommand{\ganttmilestonecon}[3][]{
|
||||
\setlength{\nextganttlastx}{\the\ganttlastx+1\ganttunitlength}
|
||||
\ifdim\nextganttlastx>#3\ganttunitlength
|
||||
\draw[-latex,rounded corners=1pt] (\the\ganttlastx,\value{ganttnum}+1.1 + 0.2) -- (\the\ganttlastx+0.4*\ganttunitlength,\value{ganttnum}+1.1+0.2) -- (\the\ganttlastx+0.4*\ganttunitlength,\value{ganttnum}+0.6+0.2) -- (\the\ganttlastx-0.4*\ganttunitlength-1.8,\value{ganttnum}+0.6+0.2) -- (\the\ganttlastx-0.4*\ganttunitlength-1.8,\value{ganttnum}+0.1+0.2) -- (#3\ganttunitlength-1.8,\value{ganttnum}+0.1+0.2);
|
||||
%
|
||||
\else
|
||||
\draw[-latex,rounded corners=1pt] (\the\ganttlastx,\value{ganttnum}+1.1 + 0.2) -- (\the\ganttlastx+0.4*\ganttunitlength,\value{ganttnum}+1.1+0.2) -- (\the\ganttlastx+0.4*\ganttunitlength,\value{ganttnum}+0.1+0.2) -- (#3\ganttunitlength-1.8,\value{ganttnum}+0.1+0.2);
|
||||
\fi
|
||||
% \fi
|
||||
\ganttmilestone[#1]{#2}{#3}
|
||||
}
|
||||
|
||||
|
||||
\endinput
|
||||
@ -140,7 +140,7 @@ Choisi le 2 octobre 2000 par le NIST. Il n'a pas de faille connue.
|
||||
$\frac{\mathbb{Z}}{\mathbb{NZ}}$.
|
||||
\end{itemize}
|
||||
|
||||
Évidemment, de nombreux calcul cryptographique se basent sur ce dernier point.
|
||||
Évidemment, de nombreux calculs cryptographique se basent sur ce dernier point.
|
||||
|
||||
\section{Diffie Hellman (échange de clef sur un réseau public)}
|
||||
|
||||
@ -157,6 +157,15 @@ Un pirate peur retrouver $g^{a+b}$, mais pas $g^{a.b}$.\\
|
||||
Cependant, cet algorithme est cassable par l'attaque de \emph{man in the
|
||||
middle}.
|
||||
|
||||
\section{Système de El Gamal}
|
||||
|
||||
Alice génére un $a$ secret, puis calcul $g^a$ qu'elle publie.
|
||||
|
||||
Pour envoyer un message, B génére un $k$, puis calcul $g^{ak}$ puis chiffre le
|
||||
message en faisant un XOR entre le message et $g^{ak}$. Il envoie ensuite le
|
||||
message avec $g^k$. Seul Alice pourra alors déchiffrer le message puisqu'il est
|
||||
nécessaire de connaître $a$.
|
||||
|
||||
\section{Génération de nombres premiers aléatoires}
|
||||
|
||||
La suite des aléas générés doir ressembler à une suite au hasard ; la suite des
|
||||
@ -169,3 +178,46 @@ Les générateurs aléatoires purs (basés sur un phénomène aléatoire)~:
|
||||
\item Trafic sur un réseau informatique~;
|
||||
\item Checksum de la mémoire vive.
|
||||
\end{itemize}
|
||||
|
||||
\section{À propos des ordres de grandeur}
|
||||
|
||||
Avec un processeur à 1GHz, il est possible de casser DES en un an avec une
|
||||
seule machine. Avec un chiffrement AES, il faut compter plus de 20 milliards
|
||||
d'années avec un milliard de supercalculateurs actuels.
|
||||
|
||||
Mais les ressources ne;cessaures au pirate croissent comme la racine carrée de
|
||||
N.
|
||||
|
||||
\section{Théorème de Fermat}
|
||||
|
||||
Pour $p$ premier, $a\neq 0[p]$, on a $a^{p-1}\equiv 1[p]$.
|
||||
|
||||
\section{La fonction d'Euler}
|
||||
|
||||
$a$ est premier à $n$ si et seulement s'il est inversible dans
|
||||
$\mathbb{Z}/n\mathbb{Z}$.
|
||||
|
||||
\section{Le théorème d'Euler}
|
||||
|
||||
Cas général du théorème de Fermat~: pour $a\in U_n$, on a $a^\Phi(n)\equiv
|
||||
1[n]$. Mais on ne peut pas en conclure que pour tout
|
||||
$a\in(\mathbb{Z}/n\mathbb{Z})a^{\Phi(n)+1\equiv a[n]}$.
|
||||
|
||||
\subsection{Cas particulier}
|
||||
|
||||
RSA se base sur un cas particulier du théorème d'Euler.
|
||||
|
||||
\section{RSA}
|
||||
|
||||
De quoi à-t-on besoin~:
|
||||
\begin{itemize}
|
||||
\item Addition, multiplication~;
|
||||
\item Division modulo $\Phi(n)$ pour le calcul des clefs~;
|
||||
\item Réduction modulo $n$~;
|
||||
\item Exponentuation.
|
||||
\end{itemize}
|
||||
|
||||
\subsection{Casser RSA~?}
|
||||
|
||||
Il faut prendre quelques précautions quand au choix des nombres premiers
|
||||
choisis (ils doivent être suffisamment grands et ne pas être trop proche).
|
||||
|
||||
110
prpa/cours.tex
110
prpa/cours.tex
@ -169,3 +169,113 @@ sont pas respectées.
|
||||
\paragraph{Famine~:} un thread est en famine quand il attend indéfiniment une
|
||||
ressources.
|
||||
|
||||
|
||||
|
||||
\chapter{Techniques de lock}
|
||||
|
||||
\section{Comment locker~?}
|
||||
|
||||
\subsection{Bloquer les interruptions et la mémoire}
|
||||
|
||||
\subsubsection{Interruptions}
|
||||
|
||||
Dans le code on déclenche des interruptions de temps en temps pour
|
||||
changer de thread.
|
||||
|
||||
\subsubsection{Mémoire}
|
||||
|
||||
On bloque un espace mémoire le temps de faire une série d'opération.
|
||||
|
||||
|
||||
\subsection{Test and set}
|
||||
|
||||
On swap 1 avec le contenu d'une adresse mémoire. Ensuite on lit le
|
||||
contenu récupéré. S'il vaut 1, on continue de boucler. S'il vaut 0,
|
||||
tout autre thread obtiendrait un 1 du fait que l'opération de swap est
|
||||
atomique.
|
||||
|
||||
\subsection{Compare and swap}
|
||||
|
||||
On lui donne une adresse, une valeur de test, une nouvelle valeur.
|
||||
|
||||
Exemple~: $+=$, $-=$, \ldots
|
||||
|
||||
\subsection{Mutex}
|
||||
|
||||
C'est un verrou que l'on utilise comme valeur abstraite qui correspond
|
||||
à une porte de toilette.
|
||||
|
||||
C'est implémenté à base de compare and swap.
|
||||
\newline
|
||||
|
||||
Pthread n'utilise pas des mutex équitables, ni implémentés sous forme
|
||||
de pile, ils sont réentrants et sont en attente passive.
|
||||
|
||||
\newline
|
||||
|
||||
L'attente passive c'est le fait de donner au kernel la charge de
|
||||
réveiller le thread lorsqu'un autre syscall indiquant qu'il a fini
|
||||
d'exécuter le code critique.
|
||||
|
||||
Du fait du nombre de syscall, il est intéressant de garder un spin
|
||||
lock plutôt qu'un mutex.
|
||||
|
||||
\subsection{Barrière}
|
||||
|
||||
C'est un outil de synchronisation. Elle reste fermée tant qu'il n'y a
|
||||
pas assez de monde pour rentrer. La barrière se referme derrière le
|
||||
dernier.
|
||||
|
||||
Peut utilisé, sauf avec Cuda sur les cartes graphiques.
|
||||
|
||||
\subsection{Read/Write lock}
|
||||
|
||||
Répond au problème du lecteur/rédacteur.
|
||||
|
||||
Des thread lisent la zone mémoire et d'autre écrivent la zone
|
||||
mémoire.
|
||||
|
||||
Lorsqu'il n'y a pas d'écriture, on peut lire sans gérer les
|
||||
locks. Mais lorsqu'il y a de l'écriture, il peut arriver que l'on lise
|
||||
le début de la réécriture puis l'ancien contenu écrit.
|
||||
|
||||
On a donc deux mutex~: un pour la lecture, un autre pour
|
||||
l'écriture. Si le mutex d'écriture est actif, on attend systématique,
|
||||
si le mutex de lecture est actif, on autorise les autres lecteure,
|
||||
mais on attend pour faire les écritures.
|
||||
|
||||
\subsection{Variable de condition}
|
||||
|
||||
On associe une condition à un mutex. On boucle sur la condition, et on
|
||||
wait (sans oublier de libérer le mutex) tant que la condition n'est
|
||||
pas valide.
|
||||
|
||||
|
||||
\subsection{Sémaphores}
|
||||
|
||||
On a un compteur protégé que l'on peut incrémenté ou
|
||||
décrémenter. Quand ce compteur est supérieur ou égal à 0~: le
|
||||
sémaphore est réveillé. Lorsqu'il est à 0 et qu'il est décrémenté, il
|
||||
se met en sommeil.
|
||||
|
||||
Généralement, on utiliser les opérations P et V. P incrémente le
|
||||
compteur et V le décrémente. Par défaut, on a une notion de pile.
|
||||
|
||||
\subsection{Moniteur}
|
||||
|
||||
L'avantage des moniteurs est de cacher l'utilisation des wait
|
||||
Cela requiert d'avoir un langage objet.
|
||||
|
||||
\section{Le diner des philosophes}
|
||||
|
||||
On a 5 philosophes.
|
||||
|
||||
\section{Structure de données}
|
||||
|
||||
Les B-tree sont très adaptés au parallélisme.
|
||||
|
||||
Les listes doublement chaînées sont à l'inverse, le pire choix
|
||||
possible.
|
||||
|
||||
\subsection{Structures non bloquantes}
|
||||
|
||||
|
||||
Reference in New Issue
Block a user