\documentclass[10pt]{article}

\usepackage{fullpage}
\usepackage{setspace}
\usepackage{parskip}
\usepackage{titlesec}
\usepackage[section]{placeins}
\usepackage{xcolor}
\usepackage{breakcites}
\usepackage{lineno}
\usepackage{hyphenat}





\PassOptionsToPackage{hyphens}{url}
\usepackage[colorlinks = true,
            linkcolor = blue,
            urlcolor  = blue,
            citecolor = blue,
            anchorcolor = blue]{hyperref}
\usepackage{etoolbox}
\makeatletter
\patchcmd\@combinedblfloats{\box\@outputbox}{\unvbox\@outputbox}{}{%
  \errmessage{\noexpand\@combinedblfloats could not be patched}%
}%
\makeatother






\renewenvironment{abstract}
  {{\bfseries\noindent{\abstractname}\par\nobreak}\footnotesize}
  {\bigskip}

\titlespacing{\section}{0pt}{*3}{*1}
\titlespacing{\subsection}{0pt}{*2}{*0.5}
\titlespacing{\subsubsection}{0pt}{*1.5}{0pt}


\usepackage{authblk}


\usepackage{graphicx}
\usepackage[space]{grffile}
\usepackage{latexsym}
\usepackage{textcomp}
\usepackage{longtable}
\usepackage{tabulary}
\usepackage{booktabs,array,multirow}
\usepackage{amsfonts,amsmath,amssymb}
\providecommand\citet{\cite}
\providecommand\citep{\cite}
\providecommand\citealt{\cite}
% You can conditionalize code for latexml or normal latex using this.
\newif\iflatexml\latexmlfalse
\providecommand{\tightlist}{\setlength{\itemsep}{0pt}\setlength{\parskip}{0pt}}%

\AtBeginDocument{\DeclareGraphicsExtensions{.pdf,.PDF,.eps,.EPS,.png,.PNG,.tif,.TIF,.jpg,.JPG,.jpeg,.JPEG}}

\usepackage[utf8]{inputenc}
\usepackage[ngerman,english]{babel}



\usepackage{float}








\begin{document}

\title{Projet round robin}



\author[1]{Maël Bourdon}%
\author[1]{Mathias Cabezas}%
\affil[1]{Université de Technologie de Belfort Montbéliard}%


\vspace{-1em}



  
  \date{May 04, 2024}


\begingroup
\let\center\flushleft
\let\endcenter\endflushleft
\maketitle
\endgroup








\sloppy


\selectlanguage{ngerman}\section*{Modèle général}

{\label{487434}}\par\null\selectlanguage{english}
\begin{figure}[H]
\begin{center}
\includegraphics[width=0.84\columnwidth]{figures/conceptual-scheme1/conceptual-scheme}
\caption{\selectlanguage{ngerman}{modèle général
{\label{654332}}%
}}
\end{center}
\end{figure}\selectlanguage{ngerman}

\pagebreak

Notre conceptualisation du projet utilise 5 processus :

\begin{itemize}
\tightlist
\item
  Le processus ``Initiateur'' :
\end{itemize}

Ce processus est en charge du lancement du projet. Afin de répondre à ce
besoin le processus créer 4 threads qui sont ``Orchestrateur'',
``Générateur'', ``Exécuteur'' et ``Ordonnanceur'' (les 4 processus
cardinaux). La philosophie derrière cette répartition est d'avoir un
processus maître qui va fixer les bases de l'architecture des cardinaux
et ainsi nous permet d'avoir un projet modulaire. On pourrait y fixer
des variables ``globales'' ou rajouter des nouveaux processus.

\begin{itemize}
\tightlist
\item
  Le processus ``Générateur'' :
\end{itemize}

Ce cardinal à pour rôle de créer les processus du round robin. Pour ce
faire il possèdent une méthode de création de structures qui
représentent nos processus. L'ensembles des processus sont créés au
lancement de l'application est sont stockés dans une table. Générateur
est alors en attente d'une demande de Orchestrateur et lui fournit alors
sur demande le processus réquisitionné.

\begin{itemize}
\tightlist
\item
  Le processus ``Exécuteur'' :
\end{itemize}

Ce cardinal~ endosse le rôle de traitement des données liés aux
processus. Il récupère les processus qui lui sont donnés par
Orchestrateur. Une fois qu'un processus est récupéré, il est stocké dans
la file de message des processus (nous évoquerons les spécificités des
files de messages par la suite).~

\begin{itemize}
\tightlist
\item
  Le processus ``Ordonnanceur'' :
\end{itemize}

Ce cardinal est le régent de l'ordre d'exécution. En effet il est
mandaté par l'orchestrateur pour la recherche de la file à un quantum
donné.~ Pour répondre à cette fonction il attend une requête de
l'orchestrateur contenant le quantum puis recherche la file à exécuter
dans la table d'allocation CPU et renvoi cette file en réponse à
l'Orchestrateur.

\begin{itemize}
\tightlist
\item
  Le processus ``Orchestrateur'' :
\end{itemize}

C'est le cardinal principal. En effet il endosse la synchronisation du
système. Il est donc l'intermédiaire de tous les cardinaux de ``bas
niveau'' (Générateur, Exécuteur et Ordonnanceur).

\pagebreak

\section*{Modèle de dialogue}

{\label{849584}}

Pour créer notre modèle nos esprits se sont implicitement tournés vers
du dialogue client serveur puisque en effet les processus cardinaux de
``bas niveau'' (Générateur, Exécuteur et Ordonnanceur) sont
majoritairement en écoute d'une requête venant de notre client
l'Orchestrateur d'où le parallèle avec le modèle client serveur.\selectlanguage{english}
\begin{figure}[H]
\begin{center}
\includegraphics[width=0.84\columnwidth]{figures/dialogue-scheme/dialogue-scheme}
\caption{\selectlanguage{ngerman}{modèle de dialogue
{\label{782314}}%
}}
\end{center}
\end{figure}\selectlanguage{ngerman}

\pagebreak

\section*{Modèle de structure}

{\label{318278}}

Afin que nos processus puisse dialoguer entre eux par l'intermédiaire
des files de messages il nous faut définir des structures représentants
alors nos messages :

\begin{itemize}
\tightlist
\item
  Processus :~
\end{itemize}

\begin{verbatim}
typedef struct {
long type;
long prio;
int pidProcess;
int tempsExec;
int tempsArrivee;
}process;
\end{verbatim}

\begin{itemize}
\tightlist
\item
  Message à donnée entière
\end{itemize}

\begin{verbatim}
typedef struct {
long type;
int msg;
}tMessage;
\end{verbatim}

\pagebreak

\section*{Modèle de table d'allocation
CPU}

{\label{558024}}

Concernant la table d'allocation CPU il était complexe de trouver une
bonne répartition des processus qui soit ``correcte'' puisque par
définition celle ci est arbitraire.

La premier étape de raisonnement consistait à fixer nos ``bases'' :

\begin{itemize}
\tightlist
\item
  Nombres de files : 10 (0 - 9)
\item
  Plus une file d'attente est de numéro faible plus elle est prioritaire
\item
  On doit consacrer plus de quantum à une file d'attente de numéro
  faible
\item
  On se limite à 100 quantum maximum
\end{itemize}

On as donc tracé un gabarit de courbe simple :

\(f\left(n\right)=-n+11\)

\(f\left(n\right)\) : nombre de quantum dédié à la file d'attente

\(n\) : numéro de file

\par\null\selectlanguage{english}
\begin{figure}[H]
\begin{center}
\includegraphics[width=1.00\columnwidth]{figures/geogebra-export/geogebra-export}
\caption{{Courbe d'allocation CPU
{\label{522600}}%
}}
\end{center}
\end{figure}

\textbf{Hosted file}

\verb`table_allocation_cpu.xlsx` available at \url{https://authorea.com/users/285959/articles/409883-projet-round-robin}

\pagebreak

\selectlanguage{ngerman}\subsection*{Modèle des files de
messages}

{\label{382883}}

Nous avons utilisés deux files de messages dans notre projet. Une
d'entre elle est utilisée pour permettre à nos processus cardinaux de
communiquer tandis que l'autre est utilisée pour stocker l'ensemble de
nos processus simulés.

\subsection*{La file de message de communication
:}

{\label{869032}}\selectlanguage{english}
\begin{figure}[H]
\begin{center}
\includegraphics[width=1.00\columnwidth]{figures/file-message-communication/file-message-communication}
\caption{{File de communication inter-cardinaux
{\label{103197}}%
}}
\end{center}
\end{figure}

Nous avons fait le choix d'utiliser un type de message par \selectlanguage{ngerman}échange
possible (référence au modèle de dialogue). En effet dans le cas d'une
requête-réponse dont les messages serait de même type un processus
cardinal aurait pu être capable de se répondre à lui même.

\subsection*{La file de message de processus
:}

{\label{781367}}\selectlanguage{english}
\begin{figure}[H]
\begin{center}
\includegraphics[width=1.00\columnwidth]{figures/file-message-processus/file-message-processus}
\caption{{File de message de processus
{\label{435721}}%
}}
\end{center}
\end{figure}

Concernant la file de message de processus chaque type de message
correspond \selectlanguage{ngerman}à la priorité (donc à la file d'attente) d'un processus.

\pagebreak

\section*{Teste}

{\label{726485}}

Pour vérifier que notre application produit des résultats en accords
avec la théorie du round-robin et notre table d'allocation CPU, on
récupère les conditions initiales que notre algorithme à utilisé pour
arriver à ce résultat et on met en pratique la théorie du round-robin
sur ces conditions initiales.

Voici les conditions initiale utilisées par notre algorithme :

\begin{verbatim}
PID : 887 | Priorité : 4 | Temps Exécution : 8 | Temps Arrivée : 0 
PID : 336 | Priorité : 4 | Temps Exécution : 7 | Temps Arrivée : 2 
\end{verbatim}

Voici le résultat de notre algorithme :

\begin{verbatim}
*****************************
Quantum Courant = 0
----------------------
Processus = 887
Arrivee = 0
Priorité = 5
Temps Execution Restant = 7
*****************************

*****************************
Quantum Courant = 1
----------------------
Processus = 887
Arrivee = 0
Priorité = 6
Temps Execution Restant = 6
*****************************

*****************************
Quantum Courant = 2
----------------------
Processus = 336
Arrivee = 2
Priorité = 5
Temps Execution Restant = 6
*****************************

*****************************
Quantum Courant = 3
----------------------
Processus = 336
Arrivee = 2
Priorité = 6
Temps Execution Restant = 5
*****************************

*****************************
Quantum Courant = 4
----------------------
Processus = 887
Arrivee = 0
Priorité = 7
Temps Execution Restant = 5
*****************************

*****************************
Quantum Courant = 5
----------------------
Processus = 336
Arrivee = 2
Priorité = 7
Temps Execution Restant = 4
*****************************

*****************************
Quantum Courant = 6
----------------------
Processus = 887
Arrivee = 0
Priorité = 8
Temps Execution Restant = 4
*****************************

*****************************
Quantum Courant = 7
----------------------
Processus = 336
Arrivee = 2
Priorité = 8
Temps Execution Restant = 3
*****************************

*****************************
Quantum Courant = 8
----------------------
Processus = 887
Arrivee = 0
Priorité = 9
Temps Execution Restant = 3
*****************************

*****************************
Quantum Courant = 9
----------------------
Processus = 336
Arrivee = 2
Priorité = 9
Temps Execution Restant = 2
*****************************

*****************************
Quantum Courant = 10
----------------------
Processus = 887
Arrivee = 0
Priorité = 10
Temps Execution Restant = 2
*****************************

*****************************
Quantum Courant = 11
----------------------
Processus = 336
Arrivee = 2
Priorité = 10
Temps Execution Restant = 1
*****************************

*****************************
Quantum Courant = 12
----------------------
Processus = 887
Arrivee = 0
Priorité = 10
Temps Execution Restant = 1
*****************************

*****************************
Quantum Courant = 13
----------------------
Processus = 336
Arrivee = 2
Priorité = 10
Temps Execution Restant = 0
*****************************

*****************************
Quantum Courant = 14
----------------------
Processus = 887
Arrivee = 0
Priorité = 10
Temps Execution Restant = 0
*****************************

*****************************
Quantum Courant = 15
----------------------
RIEN A EXECUTER POUR CE QUANTUM
*****************************

Fin de l'execution
\end{verbatim}

Voici le résultat de notre mise en pratique de la théorie du round-robin
en partant de ces mêmes conditions initiales :\selectlanguage{english}
\begin{figure}[H]
\begin{center}
\includegraphics[width=1.00\columnwidth]{figures/Annotation-2019-11-29-215023/Annotation-2019-11-29-223717}
\caption{\selectlanguage{ngerman}{Résultat de la théorie
{\label{933187}}%
}}
\end{center}
\end{figure}\selectlanguage{ngerman}

\section*{Conclusion}

{\label{910217}}

Pour conclure ce projet, l'objectif est atteint cependant certaines
fonctionnalités sont manquantes, notamment la possibilité de changer le
quantum ou de pouvoir modifier les processus par action humaine. Le
projet manque aussi d'une fin d'exécution.

\selectlanguage{english}
\FloatBarrier
\end{document}

