CAHIDER DES CHARGES DU SWITCHING MICO KERNEL ENRICHIT 2NR (c) .pdf



Nom original: CAHIDER DES CHARGES DU SWITCHING MICO KERNEL ENRICHIT 2NR (c).pdf

Ce document au format PDF 1.7 a été généré par Conv2pdf.com, et a été envoyé sur fichier-pdf.fr le 12/04/2020 à 15:54, depuis l'adresse IP 92.137.x.x. La présente page de téléchargement du fichier a été vue 133 fois.
Taille du document: 914 Ko (442 pages).
Confidentialité: fichier public
Ce document a été actualisé le 12/04/2020, son contenu peut ainsi différer des résultats présentés par les moteurs de recherche.


Aperçu du document


EXPERT ANALYSTE
PROGRAMMEUR :OUESLATI MATTHIEU
START UP :COMPUTER INDUSTRIES(France)
DIRIGEANT :OUESLATI MATTHIEU
GERANT :OUESLATI MATTHIEU
CHEF DE PROJET :OUESLATI MATTHIEU
DESIGNER HARDWARE :OUESLATI MATTHIEU
DESIGNER SYSTEM :OUESLATI MATTHIEU
BUSINESS MAN :OUESLATI MATTHIEU
siret :

copyright © OUESLATI MATTHIEU
author name :OUESLATI MATTHIEU

préface:
Ce module est le coeur de ELECTRONIC BUSINESS NETWORK (c) ceci est le
SWINTCHING MICRO KERNEL ENRICHIT 2NR (c) ce programme fonctionne en deux temps
d une part avec le micro noyau et de l autre avec la partie enrichi ce type de noyau système est
u »n gros micro kernel. LE SWITCHING MICRO KERNEL ENRICHIT 2NR (c) fonctionne avec
le deeplearning et la vr. LE SWITCHING MICRCO KERNEL ENRICHIT 2NR (c) contient une
nouvelle STL E STL Embbeded Standard Template Librairy C++ J ai pour cela refondus
totalalement l AST et créer de nouveaux système de gestion de fichier DFS1,DFS2 et OFS
Il existe deux grande familles de kernel système il y a les noyaux système de type
monolithique et les micro noyau ainsi que les micro-noyau enrichi .Une des differences est la
rapidité ainsi que la robustesse du kernel un monolithique sera un noyau système plus rapide
mais moins robuste qu'un micro kernel. Le SWITCHING MICRO KERNEL ENRICHIT 2NR ©
est un micro noyau enrichi adaptable sous 8,16,32,64,128 et 256 bits ELECTRONIC BUSINESS
NETWORK © est un système a 256 bits en temps réel donc j ai axé le SWITCHING MICRO
KERNEL ENRICHIT 2NR © sur un kernel de type UNIX mais de composition NT vu que c
est un SWITCHING MICRO KERNEL ENRICHIT 2NR ©. Le but du 2NR est de démarrer le
noyau système sous tout type de machine. J ai également embarqué le deeplearning et la VR
sous le système informatique ELECTRONIC BUSINESS NETWORK © Au départ j ai conçus
ELECTRONIC BUSINESS NETWORK © pour palier a un problème de gestion de stock de
pharmacie une fois cela fait j ai conçus un système d 'information qu' es aujourd'hui
ELECTRONIC BUSINESS NETWORK © en plus j y ai embarqué le temps réel ce qui fait de
ELECTRONIC BUSINESS NETWORK © un système aussi rapide que Linux et aussi solide qu
un windows Pour calibrer le problème j ai créer une grille de calcul EGEE qui permet de
matérialiser une grille et un ordonnanceur pour un système en deeplearning qui n existait qu en
theorie jusque là. Aujourd'hui j'ai conçus un système qui fonctionnera sur server par conséquent
un ensemble de machine connectée entre elles. L'origine du SWITCHING MICRO KERNEL
ENRICHIT 2NR © est à l origine un kernel typé UNIX et axé NT ; le NT de microsoft est le
cœur des système tel que windows 10. ELECTRONIC BUSINESS NETWORK © est un
système d information dans la lignée des systèmes de système( C est un système capable de
gérer d 'autre système classés selon la régle des système information) un système d'informations
sont des systèmes qui gèrent un ensemble de corps de métiers en locurence ELECTRONIC
BUSINESS NETWORK © est un système spécialisé dans la gestion de stocks en outre
ELECTRONIC BUSINESS NETWORK © est un système d 'information il est doté du
deeplearning et de la VR . La politique de la pièce maitresse fonctionne avec l intelligence

artificielle .Donc j ai initialiser un GRAPH en DEEPLEARNING. Electronic Business Network ©
etant un système embbeded ou embarqué les applications d ELECTRONIC BUSINESS
NETWORK © dépendront de la capacite de la batterie du SMARTPHONE JOB NET . Il y aura
donc une echance temporelle . Le systeme ELECTRONIC BUSINESS NETWORK © est un
systeme Embbeded prevus pour un SMART PHONE. Pour consommer moins de batteries
pour le SMART PHONE JOB NET j ai embarquer le parallelisme dans le systeme ELECTRONIC
BUSINESS NETWORK(c),
ELECTRONIC BUSINESS NETWORK est un OS Embbeded prévus pour SMARTPHONE
Sur un OS embarquer a l inverse d'une unite centrale les applications consomme de la batterie
Donc je vais remanier l EPROM . Et les capacité de SGF Systeme de Gestion de Fichier
Dans le but d une perte d'énergie moindre

SOMMAIRE
PARTIE A : ANALYSE FONCTIONNELLE
/*
PROJET :SWITCHING MICRO KERNEL ENRICHIT 2NR ©
copyright © :OUESLATI MATTHIEU
author name :OUESLATI MATTHIEU
rôle :
Cette partie est l analyse fonctionnelle qui permet d'écrire les fonctionnalité de n importe quel
programme donc j ai conçus l analyse du 2NR comme celle d'un programme standard
*/
SECTION I: INTRODUCTION AU PILOTE D HORLOGE
SECTION II: INTRODUCTION AU MMU GESTIONNAIRE DE MEMOIRE EPROM
(ELECTRICAL PROGRAMMABLE READ ONLY MEMORY)
SECTION III :INTRODUCTION A L ORDONNANCEUR ET A L ALGORITHME RSJF
SECTION IV INTRODUCTION AU PILOTE D AFFICHAGE
SECTION V : INTRODUCTION A L IPC(INTER PROCESS COMMUNICATION)
PARTIE ENRICHI
SECTION VI :INTRODUCTION AU SYSTEME DE FICHIER I DFS1(Delta File System 1)
SECTION VII:INTRODUCTION AU SYSTEME DE FICHIER II DFS2(Delta File System 2)
SECTION VIII:INTRODUCTION AU SYSTEME DE FICHIER VIRTUELLE (OMEGA FILE SY
STEME)
SECTION IX: INTRODUCTION AU SYSTEME SWAP QUI PERMET DE GERER LA
MEMOIRE DU SYSTEME DE FICHIER VIRTUELLE
SECTION X:INTRODUCTION A LA MEMOIRE VIRTUELLE
SECTION XI:INTRODUCTION AU SYSTEME DE PAGINATION PAR DEFAUT
SECTION XII:INTRODUCTION AU SYSTEM PAGER I
SECTION XIII:INTRODUCTION AU SYSTEM PAGER 2
SECTION XIV:INTRODUCTION AU DRIV ER KERNEL
SECTION XV:INTRODUCTION AUX PILOTES D ENTREES/SORTIES
SECTION XVI;INTRODUCTION AUX CONTROLEUR DE DISQUE

SECTION XVII:INTRODUCTION A L INTERFACE RESEAU
SECTION XVIII ; INTRODUCTION AUX INTERRUPTION HARDWARE.
SECTION XIX:INTRODUCTION AUX INTERRUPTION LOGICIEL
SECTION XXI:INTRODUCTION AU DEEP LEARNING
SECTION XXII :INTRODUCTION A VRDREAM

PARTIE B : ANALYSE ORGANIQUE

/*
PROJET :SWITCHING MICRO KERNEL ENRICHIT 2NR ©
copyright © OUESLATI MATTHIEU
author name :OUESLATI MATTHIEU
rôle :
Cette partie permet de matérialiser le code software que ça soit en n importe quel langage
*/
CHAPITRE I:DEVELOPPEMENT DU PILOTE D HORLOGE
CHAPITRE II:DEVELOPPEMENT DU MMU
U OU GESTIONNAIRE EPROM
CHAPITRE III:DEVELOPPEMENT DU SCHEDULER RSJF
CHAPITRE IV:DEVELOPPEMENT DE SCREENDRIVE
CHAPITRE V:DEVELOPPEMENT DE LIPC(INTER PROCESS COMMUNICATION)
PARTIE ENRICHI
CHAPITRE VI:DEVELOPPEMENT DE DFS 1
CHAPITRE VII:DEVELOPPEMENT DE DFS 2
CHAPITRE VIII.DEVELOPPEMENT DE OFS
CHAPITRE IX:DEVELOPPEMENT DU SYSTEME SWAP
CHAPITRE X :DEVELOPPEMENT DE VIRTUALMEMORY
CHAPITRE XI:DEVELOPPEMENT DE PAGERDEFAULT
CHAPITRE XII:DEVELOPPEMENT DE PAGER 1
CHAPITRE XIII:DEVELOPPEMENTDE PAGER 2
CHAPITRE XIV:DEVELOPPEMENT DE DRIVNET
CHAPITRE XV:DEVELOPPEMENT DE HARDWAREINTERRUPT
CHAPITRE XVI:DEVELOPPEMENT DE SOFTINTERRUPT
CHAPITRE XVII:DEVELOPPEMENT DE CONTROLDISK
CHAPITRE XVII:DEVELOPPEMENT DE I/O
CHAPITRE XVIII:DEVELOPPEMENT DU DEEPDRIVE
CHAPITRE XIX: DEVELOPPEMENT DU VRDREAM (developpement des pilote)
CHAPITRE XX DEVELOPPEMENT DE GRAPHTEXT
CHAPITRE XXI :DEVELOPPEMENT DE PHOTOMAKER
CHAPITRE XXII :DEVELOPPEMENT

CHAPITRE XXIII :DEVELOPPEMENT
CHAPITRE XXIV :DEVELOPPEMENT
CHAPITRE XXV :DEVELOPPEMENT
CHAPITRE XXVI :DEVELOPPEMENT
CHAPITRE XXVII :DEVELOPPEMENT
CHAPITRE XXVIII :DEVELOPPEMENT
CHAPITRE XXIX :DEVELOPPEMENT
CHAPITRE XXX : DEVELOPPEMENT
(Driver du software MACBUSINESS qui permet le deep learning ,une autre application avec
le deeplearning est le clustering intelligent)

PARTIE C: ANALYSE STRUCTUREE
SECTION I:DEVELOPPEMENT EN LANAGAGE DE PROGRAMMATION LAVA
SECTION II:TRADUCTION EN LANGAGE DE PROGRAMMATION C++

PARTIE A : ANALYSE FONCTIONNELLE
/*
PROJET :SWITCHING MICRO KERNEL ENRICHIT 2NR ©
copyright © :OUESLATI MATTHIEU
author name :OUESLATI MATTHIEU
rôle :
Ceci est la partie de l analyse fonctionnelle ;cette dernière permet d'ecrire les fonctionnalité du
système.
/

ANNEXE I ; INTRODUCTION AUX PROCESSEUR
On a deux famille de processeur les processeur SPARC et X86 .Ce qui differencie
les processeur c est leurs architecture. Le processeur est le cerveau de l'ordinateur
On a les nappes On a les registre de type X86 et les registres SPARC. Donc X86 fonctionne de
la façon suivante il y a les registres RI et R10 qui sont les premiers registres et les registres SS
a FG Le registre SS est àle registre de pile Il y a egalement les compteurs ordinaux. Qui sont
CS GS et ECX il y a egalement les unité de calculs logique UAL ou Unit Algorithm Logical
il y en a sept sur les processeur récents. On les bus qui traversent tout le systèmes ils
mettent en liaison les périphérique comme les Disque dure ou les cartes graphique
SS est le registre de la pile d un processeur. On a également le systèmede paginaton
d'un système d' exploitation qui est le registre PSW

SECTION I:INTRODUCTION AU PILOTE D HORLOGE
/*
PROJET :SWITCHING MICRO KERNEL ENRICHIT 2NR ©
copyright © :OUESLATI MATTHIEU
author name :OUESLATI MATTHIEU
rôle :
*/
Une horloge système permet de pouvoir gérer le temps dans le système informatique ,une
horloge et reliée a un ordonnanceur ou scheduler , Une horloge système est reliée au processeur,
Le pilote d horloge est relié au BIOS Basic Input Output System.L horloge système gére la
cadence du système ainsi que la fréquence entre autre grâce au CPU, La fréquence va
déterminer la puissance d'un système . Le temps est également demandé lors d une
interrution système qui est une fonction permettant de créer un temps d"arret lorsque un
périphérique ou un processus est interromput.Le temps est également demandé lors de l appel
de l ordonnanceur qui va définir un quantum de temps dans le cas d un RR Round Robin ; et
dans celui du SJF du temps de visite, C est également grâce à l horloge système que l
utilisateur peut lire l heure.

SECTION II:INTRODUCTION AU MMU DE L EPROM
/*
PROJET :SWITCHING MICRO KERNEL ENRICHIT 2NR ©
copyright © :OUESLATI MATTHIEU
author name :OUESLATI MATTHIEU
rôle :
*/
Il existe plusieurs type mémoire il y a la RAM , Random Acces Memory ou Rom , et SRAM,
DRAM, il y a aussi LEPROM ELECTRICAL PROGRAMMABLE READ ONLY MEMRORY
un MMU est un gestionnaire de mémoire VIVE qui permet de calculer la rapidité d une
machine ,elle épaule également la carte graphique . LEPROM est une mémoire programmable
par conéquent en lecture écriture. On peut l effacé aux ultra violets. ELECTRONIC BUSINESS

NETWORK (c) est le SWITCHING MICRO KERNEL ENRICHIT 2NR (c) ont une EPROM
En terme de memoire ELECTRONIC BUSINESS NETWORK (c) dispose d une mémoire
centrale.

SECTION III : INTRODUCTION A L ORDONNANCEUR RSJF
/*
PROJET :SWITCHING MICRO KERNEL ENRICHIT 2NR ©
copyright © :OUESLATI MATTHIEU
author name :OUESLATI MATTHIEU
rôle :
*/
Dans un système , un ordonnanceur est un module permettant de gérer tous le système l
ordonnanceur est le squelette ou le point névralgique d un système informatique ; c est a dire que
tous les éléments vont tournés autours de ce derniers. Un ordonnanceur inter reagit avec les
périphériques et les application . Il y a une partie kernel et une partie utilisateur . La partie
kernel mode gère les accès périphérique tans dis que le mode utilisateur permet d avoir accès
aux applications. Le SCHEDULER ou ORDONNANCEUR est régit par le CPU (CENTRAL
PROCESS UNIT). Mon algorithme combine deux algoritme ou rZégle de programmation l
algorithmie RR et SJF d ou son nom RSJF . L algorithmie dit RR est Roud Robin et SJF
Shortest Job First la combinaison des deux algoritmes évite la fuite mémoire. Un algorithme RR
est axé sur un quantum de temps dans lequel sont distribué des unites de temps . Il existe
deux type d algorithme d ordonnancement il y a le type Round Robin et Shortest Job First
Pour expliquer l algorithme Round Robin on peut décrire l algorithme on a PI,P2,P3, P4 ,P5
et P6 qui sont le nombre de processus un quantum de 2 unités. quand le processus est
achevé il va en queue d algorithme . Dans un RR on retrouve un BirthTime qui est l allocation
processeur, il y a le temps d arriver qui est l ArrivalTime , Dans l algorithme Round Robin on
retrouve un quantum de temps . Un processus passe d un état elut ,a un état d attente wait , a

un etat prêt . C est à dire que le processeur élit un processus pour l envoyer à l application

L algorithme SJF Shortest First Job est un ordonnanceur ou l ordinateur se sert en premier
Il existe des algorithme SJF a etage il y a jusqu a 120 étages.

Le Shortest Job First est l algorithme du premier arriver premier traité . Avec cet algorithme
avec un birthTime qui est l allocation processeur . Pour trouver l allocation CPU on doit
pouvoir trouver l équité . L équité permet de d avoir accès aux ressource à part égale .
Les resources sont l unité centrale. L équité fonctionne avec la solution de Paretto et le vecteur
de paretto et la solution du leximain. Pour l algorithme SJF on calcul le TAT sur le temps de
viste et le waiting time avec le temps de visite. Pour développer légérement cela il est a noté
que si un processus PI,PII sont arrivés l ordonnanceur prendra sur le processus PIII .Pour
materialiser ELECTRONIC BUSINESS NETWORK(c) il y a l'ordonnancement en deeplearning l
ordonnanceur est le squelette d un système informatique ;par conséquent j ai créer des tâches
intelligentes , les premières applications sont le SGF le Systeme de Gestion de Fichier en deep
learning ,J ai initialiser un ordonnanceur ou SCHEDULER sur une grille EGEE par conséquant
il y a des taches oujob intelligents. Lorsque on parle d'un software ou d une application.
Selon la thése des ordonanceur on a des systèmes a échéance.
On a un écheance par temps. Un système d'information se travail comme
un système informatique classique a savoir qu il y a une grille de calcul ici c est inspiré de la
grille de calcul du CERN la Grille EGEE pour calculer le deeplearning

SECTION IV: INTRODUCTION AU PILOTE D AFFICHAGE
/*
PROJET :SWITCHING MICRO KERNEL ENRICHIT 2NR ©
copyright © :OUESLATI MATTHIEU
author name :OUESLATI MATTHIEU
rôle :
*/
Le pilote d affichage fonctionne directement avec la carte graphique . L affichage de l ecran se
fait grace a la carte graphique et a son pilote d affichage. Le pilote est construit en deeplearning

SECTION V : INTRODUCTION A L IPC Inter Process Communication
/*
PROJET :SWITCHING MICRO KERNEL ENRICHIT 2NR ©
copyright © :OUESLATI MATTHIEU
author name :OUESLATI MATTHIEU
rôle :
*/
Le systeme de communication ou IPC sert a envoyer des messages au travers du systeme .
L IPC fonctionne sur canneaux , il fonctionne également sur sémaphore , les sémaphores sont
des processus envoyés au travers du système , Dans ELECTRONIC BUSINESS NETWORK
(c) il y a 160 Sémaphores qui sont envoyés pour amorcé le kernel .

PARTIE ENRICHI
/*
Cette partie est la partie qui contient la seconde partie du kernel
SECTION VI: INTRODUCTION A DELTA FILE SYSTEM 1
/*
PROJET :SWITCHING MICRO KERNEL ENRICHIT 2NR ©
copyright(c) :OUESLATI MATTHIEU
author name :OUESLATI MATTHIEU

rôle :
*/
Un système de fichier permet de ranger de la mémoire . Le
système de fichier permet d
amorcer le système de fichier virtuelle. Le système Delta File System I est un système en deep
learning on a des chaines intelligentes rendue possible grâce a l AI. Le premier SGF amorce
les SGF de ELECTRONIC BUSINESS NETWORK ©. Pour amorcé les premiers secteurs ont a les
block de 1 a 512 sur 4096 octets. LES secteurs contiendront les premiers node le système de
fichier sera optimiser avec le code de huffman qui permet de calculer le système avec les fichiers
deux part deux sous stockage binaires.

SECTION VII: INTRODUCTION A DELTA FILE SYSTEM 2
/*
PROJET :SWITCHING MICRO KERNEL ENRICHIT 2NR ©
copyright © :OUESLATI MATTHIEU
author name :OUESLATI MATTHIEU
rôle :
*/

Le systeme de fichier DFS 2 Delta File System2 est le systeme de fichier auxilliere.
Pour développer le second SGF je vais me basé sur les secteur

SECTION VIII: INTRODUCTION A OFS OMEGA FILE SYSTEME
/*
PROJET :SWITCHING MICRO KERNEL ENRICHIT 2NR ©
copyright © :OUESLATI MATTHIEU
author name :OUESLATI MATTHIEU
rôle :
*/
Le systeme de fichier OFS est le système de fichier virtuelle de ELECTRONIC BUSINESS
NETWORK. (c), Le systeme de fichier OFS OMEGA FILE SYSTEM est le système de
fichier que les utilisateur vont avoir pour pouvoir se sevir de ELECTRONIC BUSINES
NETWORK(c),Omega est le système de fichier virtuel de ELECTRONIC BUSINESS NETWORK
©.

SECTION IX : INTRODUCTION AU SWAP
/*
PROJET :SWITCHING MICRO KERNEL ENRICHIT 2NR ©
copyright © :OUESLATI MATTHIEU
author name OUESLATI MATTHIEU
rôle :

*/
Le mécanisme de swap dique autorise la manipulation par un processus utilisateur d un espace
d'adressage mémoire de taille supérieur a l'espace mémoire physique disponible sur le matériel.
Le principe est d utiliser la partition swap pour étendre l espace mémoire physique
Gestion du SWAP
Une partition de swap est un ensemble de bloc pouvant etre directement lus ou écrits sur un
disque . un bloc correspond à une page virtuelle. La taile de la partition est égale à la taille de
la plage mémoire adressable virtuellement
On a seulement une seule partition de swap.

SECTION X: INTRODUCTION A VIRTUALMEMORY
/*
PROJET :SWITCHING MICRO KERNEL ENRICHIT 2NR ©
copyright(c) :OUESLATI MATTHIEU
author name :OUESLATI MATTHIEU
*/
Dans un disque dur la mémoire virtuelle aide a épauler le disque dur, la mémoire virtuelle
fonctionne avec le système mémoire physique et une partition . La mémoire virtuelle ne
contient pas d adresse mémoire fixé en mémoire physique donc sous ELECTRONIC
BUSINESS NETWORK (c) l EPROM (ELECTRICAL PROGRAMMABLE ONLY
MEMORY) . La mémoire virtuelle fonctionne avec une pile de données dont de la mémoire
libre. Des données initialisés et non .Sous ELECTRONIC BUSINESS NETWORK(c) la mémoire
sera virtuelle sera mise a jour dans plusieurs registre de base afin de soulager le processeur
même si le processeur de JOB NET 1,0 va faire 22 coeurs. Donc la partition envois les
données à aux offset via un selecteur qui renvois les données a une adresse mémoire, puis à l
adresse physique on appelle la table mémoire la table de correspondance

SECTION XI : INTRODUCTION AUX SYSTEME DE PAGINATIONS
/*
PROJET :SWITCHING MICRO KERNEL ENRICHIT 2NR ©
copyright © :OUESLATI MATTHIEU
author name :OUESLATI MATTHIEU
rôle :
*/
Un système de pagination permet de diviser les pages en mots,La pagination découpe la
mémoire vive. La pagination fonction permet un echange entre les divers types mémoire
La pagination systeme se charge avec des mots donc il y a un registre PSW.

SECTION XIV: INTRODUCTION AU DRIVENET OU PILOTE ETHERNET TIRE DE
LINUX
/*
PROJET :SWITCHING MICRO KERNEL ENRICHIT 2NR ©
copyright © :OUESLATI MATTHIEU
author name :OUESLATI MATTHIEU
rôle :
*/
Un pilote ethernet est un composant permettant l acces internet,
SECTION XV : INTRODUCTION AU HARDINTERRUPT
/*
PROJET :SWITCHING MICRO KERNEL ENRICHIT 2NR ©
copyright © :OUESLATI MATTHIEU
author name OUESLATI MATTHIEU
rôle :
*/

L interruption ou IQRS en anglais fonctionne sur un systeme de table . Pour le système d
interruption hardware on a une table mémoire . Cette dernière est relié à des registres
processeur.Une interruption intervient après utilisation du matériel ,Pour initialiser l interruption
harware il y a une table,laquelle est reliée a une unite de logique UAL. Une interruption
hardware est un signal sur materiel .

SECTION XVI: INTRODUCTION AU SOFTWAREINTERRUPT
/*
PROJET :SWITCHING MICRO KERNEL ENRICHIT 2NR ©
copyright © :OUESLATI MATTHIEU
author name :OUESLATI MATTHIEU
*/
L interruption software fonctionne avec les appels systems Quand une application est appelée
au niveau système peut de temps après il y a interruption .Au niveau logiciel une interruption
est appellé lorsque le système emet une interruption sur les software .Un signal systeme intervient
au niveau des processus au niveau du kernel sous LINUX avec les fonctions call() et les
fonctions system() ;

SECTION XVII:INTRODUCTION AU CONTROLDISK
/*
PROJET :SWITCHING MICRO KERNEL ENRICHIT 2NR ©
copyright © :OUESLATI MATTHIEU

author name OUESLATI MATTHIEU
rôle :
*/
Un controleur de disque sert a utiliser les disque dur. Il permet de lire les données disque dur
Le controleur de disque dure est du materiel ou hardware servant a aidé à la lecture du materiel.

SECTION XVIII: INTRODUCTION I/O
/*
PROJET :SWITCHING MICRO KERNEL ENRICHIT 2NR ©
copyright © :OUESLATI MATTHIEU
author name :OUESLATI MATTHIEU
rôle :
*/
I/O ou Input Output system sont les entrées à la fois software et materiel

SECTION XIX : INTRODUCTION AU DEEP LEARNING
/*
PROJET :SWITCHING MICRO KERNEL ENRICHIT 2NR ©
copyright © :OUESLATI MATTHIEU
author name :OUESLATI MATTHIEU
rôle :
*/

Le deep le-arning permet de faire fonctionner l'intelligence artificielle./L intelligence artificielle
fonctionne sous un système neuronale . Un réseau deep learning fonctionne avec des
équations .Ainsi les que la croyance profonde.Au départ l intelligence artificielle se définissait a
vec le machine learning. Aujourdhui les super calculateur prennent en charge le deep learning
mais aussi bien les derniers SMART PHONE dont JOBNET 1,0.
La methode dite par renforcement est le deeplearning avec un systeme a action et a etat
On parle d horizon et de DEEPCONTROLE pour parler d'algorithme de scheduler

void createPthread();
void gain();
void probabilities(DEEPHORIZON&Action);
void probabilitiesII(DEEPHORIZON&etat);

void gradient();
void poids();
void biais();
Etant donne que j ai initialise le système en multi threading j ai créer un mode multi threading,
un thread est un lien en anglais sous UNIX c est ce qui est fork() sous window et sous
ELECTRONIC BUSINESS NETWORK(c) c est pthread,h J ai egalement les fonction gain
et des fonctions de calcul de probabilite un gradient qui permet d initialiser le deep learning()
et jai initialiser le poids et le biais'()

En deeplearning il y a plusieurs type de réseaux .Les réseau ou network neuronal est constistué
de neurones qui permettent de stocker des informations
Reseau dense
/*
PROJET :SWITCHING MICRO KERNEL ENRICHIT 2NR ©
copyright © :OUESLATI MATTHIEU
author name :OUESLATI MATTHIEU
rôle :
/
Un réseau dense est un réseau neuronal simlple on a généralement une fonction softmax
dans les nouveau réseau ,Pour initialiser un réseau en deeplearning on

Reseau convolutionnel
/*
PROJET :SWITCHING MICRO KERNEL ENRICHIT 2NR ©
copyright © :OUESLATI MATTHIEU
author name :OUESLATI MATTHIEU
rôle :
*/
Un réseau convolutionnel est un reseau qui comme sont nom l indique contient des
convolutions, ces dernieres sont des divergences . Pour un reseau profond on a 40 couches
neuronnles ;sous ELECTRONIC BUSINESS NETWORK(c) il y a un systeme en
deeplearning avec un reseau recurent .
J ai concus ELECTRONIC BUSINESS NETWORK © avec un système a reseau profond
il faut 40 couches réseau pour programmer un reseau neural. Pour construire
ELECTRONIC BUSINESS NETWORK(c) je vais initialiser un graph qui aura au moins 40

couches de profondeur

Reseau Récurent
/*
PROJET :SWITCHING MICRO KERNEL ENRICHIT 2NR ©
copyright(c) :OUESLATI MATTHIEU
author name :OUESLATI MATTHIEU
rôle :
*/
Un réseau récurent fonctionne avec une en entree X et un etat Y. Ce dernier fonctionne sur
un ensemble de cellule récurente.

PARTIE B: ANALYSE ORGANIQUE
/*
PROJET:SWITCHING MICRO KERNEL ENRICHIT 2NR (c)
copyright(c):OUESLATI MATTHIEU
author name :OUESLATI MATTHIEU
role:
Cette seconde partie du cahier des charge sert a initialiser les fonctions et les instances qui
serviron a controler le micro noyau SWITCHING MICRO KERNEL ENRICHIT 2NR(c)
Le switching micro kernel enrichit 2NR © de ELECTRONIC BUSINESS NETWORK ©
est un kernel de la famille des kernel NT. D 'architecture UNIX V5
En langage de programmation C++ un fichier est compilable que si on a
un .exe ou executable. Sous ELECTRONIC BUSINESS NETWORK ©
je vais initialiser d autre formats. A commencer par les ,sys qui regroupent
tout les fichiers système.

CHAPITRE I DEVELOPPEMENT DE L HORLOGE SYSTEME
/*
PROJET: SWITCHING MICRO KERNEL ENRICHIT 2NR ©
copyright(c):OUESLATI MATTHIEU
author name:OUESLATI MATTHIEU
role:
*/
Pour développer l horloge système je vais creér plusieurs instances qui fonctionneront avec la
technique de l heritage, Le développement se fera en plusieurs fichier les instances herité
seront placés dans les fichiers séparere, L'horloge système est reliée au BIOS du système
informatique avec les système traditionnelle elle sert a donner l heure mais également a cadencer
les ordonnanceur.

FICHIER HEADER
/*
PROJET:SWITCHING MICRO KERNEL ENRICHIT 2NR (c)
copyright (c):OUESLATI MATTHIEU
author name: OUESLATI MATTHIEU
Pour développer le l horloge systeme je vais développer cela en plusieurs fichiers , Il y a
plusieurs instances : dans la première instance je vais placer une instance SetClock() qui servira
de colone vertebrale a SetClock ,Je vais commencer par définir un fichier setClock . Avec les
commandes suivantes #ifdef DEF_SetClock avec les fonctions #define DEF_SetClock ensuite
je vais créer instance class SetClock() qui sera l objet mère . En terme cle je vais placer
public et private. A l interieur de l instance SetClock il y a les bibliotheque suivantes . Il y a la
bibliothèque #include<iostream>, la bibliotheque qui gere le temps donc #include<ctime>
#ifdef DEF_SetClock
#define DEF_SetClock
#include<iostream>
#include<ctime>
class SetClock
{
public:
void createPthread();
void init_cycle(int processus);
void initMatrix();
private:
}
Dans l'instance ci-dessus j ai initialiser une fonction init_cycle qui prend pour paramettre une
fonction avec un type entier int processus ;la fonction après est une fonction initMatrix qui
permet de lancer la fonction matriciel de l'horloge.

pour terminer le premier fichier du module il y a un #endif
Dans le second cas je vais créer une le fichier suivant , #ifdef DEF_CLOCKSYS
#define DEF_CLOCKSYS
#include<iostream>

#include"SetClock,h"
class CLOCKSYS : public SetClock
{
public:
CLOCKSYS();
void createPthread();
void uploadBIOS();
void setPeripherique();
void
~CLOCKSYS();
private:
}
Dans un tiers temps je vais créer le fichier suivant #ifdef DEF_CLOCKSYS et #define
DEF_CLOCKSYS
je vais initialiser les fonction suivantes createPthread la fonction uploadBIOS() ainsi que la
fonction setPeriphérique() la fonction uploadBIOS qui permet de chargé la commande CIOS qui
permet de charger les fonctionalité du CIOS,Le CIOS est le BIOS du système ELECTRONIC
BUSINESS NETWORK ©

FICHIER SOURCE
/*
PROJET:SWITCHING MICRO KERNEL ENRICHIT 2NR (c)
copyright (c):OUESLATI MATTHIEU
author name:OUESLATI MATTHIEU
role:
*/
#include'' SetClock,h ''
using namespace std;
SetClock::SetClock()
{
}
void SetClock::createPthread()
{
}
void SetClock::init_cycle(int processus)
{
}
SetClock::SetClock()
{
}
FICHIER CLOCKSYS
/*

PROJET :SWITCHING MICRO KERNEL ENRICHIT 2NR ©
copyright © :OUESLATI MATTHIEU
author name :OUESLATI MATTHIEU
rôle :
*/
FICHIER CLOCKCYCLE
/*
PROJET :SWITCHING MICRO KERNEL ENRICHIT 2NR ©
copyright © :OUESLATI MATTHIEU
author name : OUESLATI MATTHIEU
rôle :
/
FICHIER HEADER
/*
PROJET :SWITCHING MICRO KERNEL ENRICHIT 2NR ©
copyright © :OUESLATI MATTHIEU
author name :OUESLATI MATTHIEU
rôle :
*/
#ifndef DEF_CLOCKCYCLE
#define DEF_CLOCKCYCLE
#include<iostream>
class CLOCKCYCLE
{
public :
CLOCKCYCLE()
private :
}
#endif
En langage de programmation C++ on utilise un fichier header et un source
pour la compilation Donc dans un premier temps j ai initialiser les commandes
pres processeur avec #ifndef DEF_CLCOCYCLE .Ici j ai definit l horloge systeme
J ai commencé a rédiger le programme avec son constructeur

FICHIER SOURCE
/*
PROJET :SWITCHING MICRO KERNEL ENRICHIT 2NR ©
copyright © :OUESLATI MATTHIEU
author name OUESLATI MATTHIEU
rôle :
Ce fichier fait partie de l horloge systeme il permet de calculer les cycle de l horloge dans le
SWITCHING MICRO KERNEL ENRICHIT 2NR ©Une horloge système est relié au BIOS
Basic Input Output System qui relie le hardwarea à l'interface du système
*/

#ifndef DEF_CLOCKCYCLE
#define DEF_CLOCKCYCLE
#include<iostream>
class CLOCKCYCLE :public SetClock
{
public :
CLOCKCYCLE()
void createPthread() ;
void init_cycle()
private :
}
L instance ci dessus est pour initialiser le cycle de l horloge système qui est axée sur le cycle
processeur sous JOB NET il y a le DUAL DECA CORE I8 © qui est un APU soit un processeur
multi fonctions . L APU DUAL DECA CORE a 22 cœur JOB NET est un SMART PHONE
La fonction createPthread() fonctionne avec la bibliothèque pthread et la fonction init_cycle()
permet d'initialiser le contrôle des cycle d horologe . J ai axé l'horloge sous lamport .
ELECTRONIC BUSINESS NETWORK © est un système informatique événementiel donc l
horloge de Lamport fonction avec e1>e2 . Elle est axée sur des estempilles en outre des vecteurs
temporels.
#ifndef DEF_CLOCKCYCLE
#define DEF_CLOCKCYCLE
#include<iostream>
#include<ctime>
#include'' SetClock,h''
class CLOCKCYCLE : public SetClock
{
public :
CLOCKCYCLE() ;
void createPthread() ;
void time() ;
void initCycle() ;
void loadCPU() ;
void loadBIOS() ;
private :
int m_setCycle ;
}

FICHIER Evenement
/*
PROJET :SWITCHING MICRO KERNEL ENRICHIT 2NR ©
copyright © :OUESLATI MATTHIEU

author name :OUESLATI MATTHIEU
rôle :
Dans un operating system dans le type windows ou UNIX on a une horloge qui est une horloge dit
horloge a quartz elle cadence le système a note le software et sa machine
*/
Pour développer le fichier Evenement.En C++ on doit gerer fonction de

FICHIER Event
/*
J ai choisis le modele de Lamport qui est une horloge evenementielle il y a un evenement qui est
envoyer pour un site on parle dans ces cas la d un evenement vers une machine e1-> e2
Le modele de l horloge de Lamport est un modele qui permet de calculer un ensemble
d ordinateur ou de système. Il y a evnement lorsque e1 va vers e2

PROJET :SWITCHING MICRO KERNEL ENRICHIT 2NR ©
copyright © :OUESLATI MATTHIEU
author name :OUESLATI MATTHIEU
rôle :
/
FICHIER HEADER
/*
PROJET :SWITCHING MICRO KERNEL ENRICHIT 2NR ©
copyright © :OUESLATI MATTHIEU
author name :OUESLATI MATTHIEU
rôle :
*/
Pour développer le fichier Horloge,sys . Je commence par
des commandes près processeurs #ifndef et #define

#ifndef DEF_Evenement
#define DEF_Evenement
#include<iostream>//permet d initialiser les entrée de flux et sortie
#include<ctime> // permet de materialiser la bibliothèque et les fonctions de temps =
#include<CSIGNAL> // Permet de materialiser les signaux au niveau du systèmes
#include<pthread,h>// permet d initialiser le mode multi threading du système
#include<cmath>
#include''SetClock,h''

En langage de programmation C++ il existe deux technique de programmation
le polymorphisme et l'heritage une instance herite d'une class mère
La class fille prends les fonctions de la classe principale ou l objet mère.
Le polymorphisme permet les fonction virtuelle avecc virtual.
Le programme ci dessus permet d inclure un fichier SetClock pour l'heritage
j ai les bibliothéque ctime qui permet les fonction temps
j ai une bibliotheque qui permet de gérer les commandes multi threading
avec pthread,h et cmath pour les fonction mathématique de C++

class Evenement :public SetClock
{
public :
Evenement() ;
Ici j
void createPthread() ;
void det() ; // la fonction det est le determinant de la matrice,Sous LE SWITCHING MICRO
KERNEL ENRICHIT 2NR © est un système matriciel une matrice est un ensemble de tableau
bool test_Evenement() ; // ici j ai une fonction de test qui permet de renvoyer un vrai faux
private :
};
#endif

FICHIER SOURCE
/*
PROJET :SWITCHING MICRO KERNEL ENRICHIT 2NR ©
copyright © :OUESLATI MATTHIEU
author name :OUESLATI MATTHIEU
rôle :
*/
#include ''Evenement,h''

using namespace std ;

Evenement ::Evenement() :SetClock() ;
{
}
void Evenement ::createPthread()
{
}

void Evenement ::det()
{
new calculEvent[][]
tabI[][] ;
}
Pour demarrer la serie d evenement je vais initialiser une conditionnelle sur un mouvement de
SIGNAL
bool Evenement ::test_Evenement()
{
if( !SIGNSTART)
{
}
else(startSystem)
{
}
}
Evenement ::~Evenement()
{
}
Ici je me suis basé sur un modele de Lamport ; une horloge de Lamport est un horloge qui calcul
les evenements d un systeme ou d une unite centrale donc vers e1 → e2

FICHIER SOURCE
/*
PROJET :SWITCHING MICRO KERNEL ENRICHIT 2NR ©
copyright © :OUESLATI MATTHIEU
author name :OUESLATI MATTHIEU
rôle :
*/
Dans un système infomatique il y a des cycles processeur.Une horloge aide a compter les cycles
de processeurs,un cycle sert a calculer la rapidité du processeur

#include ''CLOCKCYCLE,h ''
using namespace std ;

CLOCKCYCLE ::CLOCKCYCLE() :SetClock
{
m_setCycle ;
}
Ici j ai l objet et sont constructeur avec l'attribut m_setCycle pour initialiser le cycle d'horloge
void CLOCKCYCLE ::createPthread()
{
}
Ici j ai mon instance CLOCKCYCLE qui initialise createPthread() ;
void CLOCKCYCLE ::Process(int time)
{
m_setCycle=time ;
}
void CLOCKCYCLE ::initCycle(CLOCKCYCLE&Process)
{
process,calculCycle(m_setCycle)
}
J ai initialiser les processus par cycles avec initCycle() avec en parametre
CLOCKCYCLE&Process l esperluette est la référence.
void CLOCKCYCLE ::loadCPU()
{
}
void CLOCKCYCLE ::loadBIOS()
{
}
Etant donné que l horloge est reliée au BIOS (Basic Input Output System) j ai initialiser une
fonction de chargement du BIOS .
bool CLOCKCYCLE ::test_CYCLE()
{
}
CLOCKCYCLE ::~ CLOCKCYCLE()

{
}
Ici c est un fichier source dans l analyse organique on detail le pès code de manière litteral en
outre on décrit le mécanisme de ce dernier.
Createpthread() est le mode multi threading du module dans un thread il y a les mutex qui sont
les entrées sorties d 'instance la seconde fonction est une fonction temps avec la fonction time
et la bibliothèque ctime en langage de programmation C++.
Il y a la fonction initCycle () pour paramètre, L 'interface BI.OS permet de relié un périphérique
au système BIOS Basic Input Output System ; ce programme contient tous les périphérique en
comptant HDD , le CPU ou GPU la RAM
En langage de programmation C++ ; il y a les methods et les attributs en outres les methodes
sont les fonctions. En langage C++on parle de POO Programmation Oriente Objet .En derrnière
fonction j ai placer une fonction de test qui est test_CYCLE() , à l 'intérieur del
FICHIER MATRIXROW
/*
PROJET :SWITCHING MICRO KERNEL ENRICHIT 2NR ©
copyright © : OUESLATI MATTHIEU
author name :OUESLATI MATTHIEU
rôle :
*/
Pour initialiser le fichier source je vais créer un objet constructeur SetClock qui s'initialise avec
SetClock()
la fonction createPthread() permet d initialiser le mode multi threading la seconde fonction
permet d'initialiser le cycle d'horloge avec une fonction init_cycle(); Le fichier herite de
l'instance SetClock() en ocurence ; en langage de programmation C++ le fichier herite dela classe
mère. Je vais donc lui inclure les bibliotheque suivante. #include<iostream> #include<pthread .h>
après j 'ai initialiser les commandes suivantes class MatrixRow :public SetClock a la fin du
travail je vais initialiser un système d'interface graphique grâce Me trouvant dans une horloge
de lamport car l architecture des nouveau systèmes comprend l architecture sur le network donc
sur INTERNET . J'ai conçus le server GOLDENEYE © La matrice viens stocker les événements
de l horloge qui est le comportement de cette dernière sur le système. Je vais initialiser une
troisième bibliothèque #include<ctime> ce qui correspond a la bibliothèque time,h en
langage C. Sachant qu un système informatique compte les tics d une horloge. Comme dit en
début de fichier les matériaux embarqués sont des montres à quartz ,
z
Les fonctions sont createPthread() , la fonction calculjournee() , Le switching micro kernel
enrichit 2NR(c) étant en temps réel et en multi threading pour pouvoir initialiser le mode
m_
parallelisme sur le système ELECTRONIC BUSINESS NETWORK © .
Schématiquement j ai l instance ou l objet suivante
#ifndef DEF_MATRIXROW
#define DEF_MATRIXROW
#include<iostream>
#include<ctime>
#include<pthread,h>
class MATRIXROW :public SetClock

{
public :
MATRIXROW()
void createPthread() ;
void calculJournee() ;
void time() ;
void det(MATRIXROW&tic) ;
private :
int m_setTime ;
int m_initProcess ;//Definit les processus dans lamport
}
#endif

FICHIER SOURCE
/*
PROJET :SWITCHING MICRO KERNEL ENRICHIT 2NR ©
copyright © OUESLATI MATTHIEU
author name OUESLATI MATTHIEU
rôle :
*/
Dans cette partie-ci je vais initialiser le fichier source donc lorsque que j ai créer un objet
constructeur MATRIXROW()

#include<iostream>
using namespace std ;
namespace est en langage de programmation C++ un espace nom c est un ensemble de stockage
d'instances , grâce a l'espace nom on peu stocker plusieurs objet dans un même programme
En langage de programmation Oriente Objet on a des classes ou des instances
#include'' MATRIXROW,h'
using namespace std ;'
MATRIXROW ::MATRIXROW () :public SetClock
{
}
void MATRIXROW ::createPthread()
{
e}
void MATRIXROW ::calculJournee()
{
}
void MATRIXROW ::time()
{
}
void MATRIXROW ::det(MATRIXROW&tic)
{
tic.(m_setTime) ;

}
bool MATRIXROW ::test_MATRIXROW()
{
int i ;
int tic ;
for(i=10,i<3600 ; i++)
{
}
return det
for(tic= ;tic< 3600, tic++)
{
}
Ma fonction det prend pour parametre un parametre par référence soit void
MATRIXROW ::det(MATRIXRO&tic)

Ici j ai placé une fonction boolean soit une fonction bool qui retourne normalement 1 si la
condition est vrai A l interieur du test matriciel j ai placer une valeur de retour det qui est le
déterminant matriciel. Je vais calculer le tic qui correspond au tour d horloge comme il y a
3600 tic en 1 minutes

}
MATRIXROW ::~MATRIXROW()
{
}

CHAPITRE II:DEVELOPPEMENT DE MMU GESTIONNARE DE MEMOIRE
/*
PROJET:SWITCHING MICRO KERNEL ENRICHIT 2NR
copyright(c):OUESLATI MATTHIEU
author name: OUESLATI MATTHIEU
*/
FICHIER Memory
/*
PROJET :SWITCHING MICRO KERNEL ENRICHIT 2NR ©
copyright(c) :OUESLATI MATTHIEU
author name :OUESLATI MATTHIEU
rôle :
*/
Pour développer cette instance je vais initialiser la bibliothèque du système aduino,puis il faudra
cartographié le MMU pour répartir la mémoire dans le système informatique .L Operating System

ELECTRONIC BUSINESS NETWORK © est un système d'information la mémoire doit etre
embarqué dans les modules embbeded.

Dans la programmation C++ il existe une technique de programmation dite héritage qui
fonctionne avec une instance mère ou objet il y a egalement les instances fils
qui héritent des traits de la class mère .
Ensuite on appelera l objet constructor dans le cas échéant Mémory() ; ,
class Memory
{
}
class Modem :public Memory
{
public :
Modem()
void sendByte(unint8_t byte)
bool charAwail() ;
bool carrier()
int getByte(int tenths=100) ;
void setup() ;
private ;
int
}
Dans un système informatique on calcul la mémoire sous la forme de mémoire vive RAM ici j
ai initialiser de l EPROM donc Electrical Programmable Read Only Memory ceci est de la
mémoire effacable aux ultra violet.L avantage est au niveau programmeur car je peux la
programmer dans n importe quel langage de programmation ici en C++ j ai une serie
d instances avec la technique de l'heritage. La seconde instance est Modem qui herite de l
instance Memoryh elle a pour fonction cinq fonctions preprocesseur dont deux type boolean
les boolean servvent a tester la fonction generalement suivit d'un if et else
Ici dans les cinq fonctions j ai un types int ou integer .Les int sont signé de 0 a128 bit les double de
32,00 a -32,00 les float a 32000 a-32000 les double sont les décimales les float sont les floattant
et les int les nombres entiers

FICHIER SOURCE Modem.h
/*
PROJET :SWITCHING MICRO KERNEL ENRICHIT 2NR ©
copyright © :OUESLATI MATTHIEU
author name :OUESLATI MATTHIEU
rôle :
*/
J ai programmer l EPROM pour 8GIGA de mémoire ; ici elle remplace la mémoire vive du
SMART PHONE JOB NET ;il a pour système ELECTRONIC BUSINESS NETWORK ©

Modem ::Modem() :
{
}
void Modem ::createPthread()
{
}
void Modem ::sendByte(uint8_t)
{
Serial.write(uint8_t byte)
}
La fonction sendByte permet d'envoyer le nombre d'octet dans l EPROM elle prend une fonction
uint8_t qui est unsigned donc un type non signé
bool Modem ::charAvail()
{
return Serial.aviable() >0 ;
}
bool Modem ::Carrier()
{
return Serial
}
int Modem ::GetByte(int tenths=100)
{
Serial set
char byte='7'
int n=serial.readByte(&byte,1) ;
return(uint8_t)
}
void Modem ::setup()
{Serial,begin(115200) ;
while( !Serial)
{
}
void Modem ::loop()
{
usigned long counter=0,counter2=0 ;
for( ;;)
{
if(Serial.availble)
{
char c= Serial.read() ;
if( c== 'ç' ::c=='y')break ;
continue
}
if(counter++==1000)
{
char Buf[128] ;
sprintf.buf,
++ counter2) ;

Serial.println,(Buf) ;
counter=0 ;
}

delay(2)
}
for(unsigned a=0 a(512 ; a=16)
for(unsigned b=0 ;b(16 ;++b)
{
char data[16],Buf(5+16*3+16*i)=
'' '' ;
for ( unsigned b=0 ;b (16 ;++b))

class ROMsender :public Modem
{
enum(AdressLoBegin=36,AddrHiBegin=46,DataBegin=26)
CE=2,VPP=3 ;
}
void SendAddress(uint32_t addr)
}
}
uint8_t ReadData()
Lorsque on observe un circuit d EPROM Electrical Programmable Only Memory on a des plots
ou des broches ces dernières sont CE et VPP il y a également la broche CRC
Ici j ai calibrer la fonction GetByte()avec La fonction SerialSet()
Serial set
char byte()
int n=serial.readByte(&byte1) ;
ceci retourne
le type(uint8_t) vu que sous aduino c est des blocs de 8bits donc il y a unsigned 8
for)
for(int a=0,a (a ;++a))
(digitalWrite(AddHiBegin+ a,addr&i) ;addr)) =i ;)
for(int a=0 ;a(0,++a) )
digitalWrite(AddrHiBegin+a addre&1) ;addr>>=i ;>
digitaWrite(CE,addr&i) ; addr)) =i ;
digitalWrite(VPP,addr&i,addr&i),addr))=i ;
uint8_t ReadData()
{
uint8_t result=0 ;
for(int a=0 ;--a)=0 ;)
{
result<<=i ;
result := digitRead(DataBegin+a)

}
ROMSender sender ;
for (unsigned a=0 ;a(512 ;a=16)
{
char data[16] Buff(5+ 16*3+16+i)= '''' ;
sprintf (Buf ''/04X '' 'a')
Q'
}
En me basant sur les régles d électronique pour la programmation des circuit imprimés j ai
initialiser un buffer à l adresse memoire 04X .Ici c est le système aduino ; mais sous windows
c est le même schémas
for(unsigned b=0 ;b (16 ;++b))
sprintf(Buf%04X) ;
for unsigned b=0 ;b(16 ;++ b)
data[b]=sender GetData(a*b) ;
for(unsign b=0 ;, b (16 ;++ b))
uint8_t GetData(uint32_t position)
{
SendAdress(position)
return ReadData
}
for unsigned a=0 ; a(512 ; a =16)
{
char data[16],Buf(5+16*3+16+i]= '' '')
sprintf(Buf'' %04X%'')
for unsigned b=0 ; b(16,++b)
data[b]=sender GetData(a*b) ;
for(unsigned b=0 , b( 16 ;++b)) ;
for(unsigned b=0, b= ;''%02XXXc'',data[b]((b*i)%8) ?'')data[b],((b*i)%8) ?'' :' :') ;
Buf[53*b]=uint8_t(data[b]-32)(126-32) ?',' :
}
Serial .println(''Fait')
return result ;

FICHIER ZMODEM
/*
PROJET :SWITCHING MICRO KERNEL ENRICHIT 2NR ©
copyright © :OUESLATI MATTHIEU
author name :OUESLATI MATTHIEU
rôle :
La bibliothèque ADUINO est une bibliothèque qui permet de materialiser une EPROM
Dans un kernel ou noyau systeme il y a de la RAM, il y a une horloge systeme
un scheduler ici RSJF qui combine Round Robin et Shortest Job First
Il y a egalement le pilote d affichage qui affiche directement l ecran ce dernier est relié à la carte
graphique .On a également l IPC pour la gestion des processus et des taches mais aussi des
peripherique d une machine. En outre grace au BIOS de la machine Basic Input Output System

*/

#ifndef DEF_ZMODEM
#define DEF_ZMODEM
#include<iostream >
class ZMODEM
{
public :
bool send() ;// permet d envoyer le nombre de byte sur le circuit imprim é
void CE() ;// ceci initialise le pin du circuit EPROM , la fonction agit sur les borne du circuit
imprimés
void VPP (z) ; //ceci initialise l autre pin de L EPROM
//Electrical Programmable Only Rom Memory
private :
}
#endif
FICHIER SOURCE ZMODEM,cpp
/*
PROJET :SWITCHING MICRO KERNEL ENRICHIT 2NR ©
copyright © :OUESLATI MATTHIEU
author name :OUESLATI MATTHIEU
rôle :
*/
bool ZMODEM ::Send(const char*KERNELROM,uint32_t file_length)
{
sendByte('r' 'z', CR)
sendByte('0' ' 0' CR)
}
struct Zmessage
{
short type
uint8_t data[4]
auto SendData ;
}
auto sendDataEnd=[&](uint8_t frameend)->void
{
SendByte=(ODLE)
SendByteEncoded(frameread)
SendCRC() ;
if(framread==OCRCM ::frameread==OCRCQ)SendByte(XON)
}
auto SendMessage[&](const Zmessage&msg .uint8_t mode)-> void
SendByte(OPAD,ODLE,send mode)
SendByte(msg,type) ;
for unsigned a 0, a <4 ;++a) SendByteEncoded(msg,data )
SendDataBegin() ;
SendByteEncoded(msg,type) ;
for (unsigned a=0 ;a<4 ++a) sendByteEncoded(msg,data[a])

CHRONOGRAMME DU SYSTEME ELECTRONIC BUSINESS NETWORK ©
/*
PROJET :SWITCHING MICRO KERNEL ENRICHIT 2NR ©
copyright © :OUESLATI MATTHIEU
author name :OUESLATI MATTHIEU
rôle :
*/
Un chronogramme permet d initialiser un message un processus et un evenemment dans un
ordonnanceur ;grace au chronogramme on peut prevoir le nombre de processus
dans un system

FICHIER HEADER
/*
PROJET :SWITCHING MICRO KERNEL ENRICHIT 2NR ©
copyright © :OUESLATI MATTHIEU
author name :OUESLATI MATTHIEU
rôle :
*/

Pour développer le fichier je vais initialiser deux commandes pres processeur
je vais initialiser les commandes SCHEDCHRONO
#define DEF_ SCHEDCHRONO
#ifndef DEF_SCHEDCHRONO
#define DEF_SCHEDCHRONO
#include <iostream>
class SchedChrono
{
public :
SchedChrono() ;
private :
}
class :public SCHEDCHRONO
{
public :
private:
}
#endif

CHAPITRE III :DEVELOEPPEMENT DE L ORDONNANCEUR RSJF
/*
PROJET:SWITCHING MICRO KERNEL ENRICHIT 2NR (c)
copyright(c):OUESLATI MATTHIEU
author name:OUESLATI MATTHIEU
role:
Cette étape du cahier des charges on créer les premieres analyse du code avant l analyse
structurée ; qui ici sera écrite en langage de programmation C++.
L ordonnanceur RSJF est le point nevralgique de ELECTRONIC BUSINESS NETWORK (c) il
fonctionne selon un équilibre des resources pour cela il faut travaillé l'équité et la solution de
paretto pour avoir un équilibre des resource robuste la souplesse d utilisation sera d utiliser un
écrant tactile. Selon l algorithmie il n y a système informatique faisable que si il y a
ordonnancement possible. Il existe plusieurs régles d'ordonnan cement il y a RoundRobin et SJF
RounRobin est un système a tourniquet . Dans RR il y a des quantum de temps le langage de
programmation utilisé est le langage C++ il y a du temps reel vus qu ELECTRONIC BUSINESS
NETWORK (c) est un système en temps réel il y a également les nouveaux SGF avec le deep
learning Comme le Scheduler est le squelette ou le point nevralgique du système informatique
je vais programmer . Aussi bien la peremption système que En outre il faudra faire un graph qui
permettra l option de deeplearning et trouver le mode SWITCHING du MICRO KERNEL le mode
switching permet de créer un noyau système adataptable 8,16,32,64,128,256 bits ELECTRONIC
BUSINESS NETWORK © a 256 bits tant dis que les systemes commerciaux actuel tournent en
32 et 64 bits donc il devrait etre plus rapide pour la Grille de Calcul je prend EGEE avec le
deeplearning en approche par renforcement
Le deeplearning est l intelligence artificiel . EGEE est Electronic Grid Embbeded .Pour calculer
un système embbeded donc embarquer il faut initialiser le taux electrique qui circule dans le
système.Ceci permettra de gérer la mémoire applicative.Pour initialiser le RSJF j ai appliquer la
méthode de paretto qui découle du theoreme de NASH pour la distributivité des processus
soit un rapport 20/80 selon la regle. Je vais initialiser en loccurence le parellisme ceci permet
d'économiser la batterie du système.Lorsqu on charge un multi threading les threads passent par
plusieurs cœur on a l algorithme en parallelisme.

FICHIER SCHEDULERRSJF

/*
PROJET :SWITCHING MICRO KERNEL ENRICHIT 2NR ©
copyright(c) :OUESLATI MATTHIEU
author name :OUESLATI MATTHIEU
rôle :
*/
Pour d évelopper le fichier ci dessous j ai initialiser j'ai initialiser les commandes prés processeur
en langage de programmation C ++ #ifndef DEFet SCHEDU LERRSJF
j ai egalement créer la commande pre processeu #define DEF_SCHEDULERRSJF
#ifndef DEF_SCHEDULERRSJF
#define DEF_SCHEDULERRSJF
#include <iostream>
#include<>
En démmarant l'instance
Dans l instance SCHEDULERRSJF j ai initialiser les fonctions suivantes il y a la fonction
createPthread() qui permet d initialiserr le mode multi-threading()
j ai initialiser une fonction init() qui va permettre d initialiser le fonctionnement du
SCHEDULERRSJF(),la fonction setGrid() permet d initialiser la grilleGrille de calcul() ;
La grille de calcul est une EGEE donc pour un ensemble de machine.elle seront relier au server
GOLDENEYE , Un Scheduler est le squelette du d un Operating System.

class SCHEDULERRSJF
{
public :
SCHEDULERRSJF()
void createPthread() ;
void init()
vid setGrid() ;
private :
}
#endif
L objet ici est SchedulerRSJF qui permet de programmer l ordonnanceur
On a les fonction void createPthread(), j ai la fonction
init() et la fonction setGrid() ;
en private j ai les m_initScheduler ; Les fonction membre en priver
ne sont accessible que dans la zone private ;

FICHIER SOURCE
/*
PROJET :SWITCHING MICRO KERNEL ENRICHIT 2NR ©
copyright © :OUESLATI MATTHIEU
author name :OUESLATI MATTHIEU
rôle :
*/

SCHEDULERRSJF ::SCHEDULERRSJF()
{
}
SCHEDULERRSJF ::~SCHEDULERRSJF()
{
}
TOURNIQUET ::TOURNIQUET() :SCHEDULERRSJF()
{
}
TOURNIQUET ::~TOURNIQUET()
{
}

FICHIER CRITICALSEUIL
/*
PROJET :SWITCHING MICRO KERNEL ENRICHIT 2NR ©
copyright © :OUESLATI MATTHIEU
author name :OUESLATI MATTHIEU
rôle :
Dans un systeme informatique le seuil critique est le point minimum du processus

*/
;
Le SEUIL CRITIQUE d une machine est l etat limite de la panne de cette dernière aussi bien a
son niveau minimale que son niveau maximale. IcI J ai initialiser un système en deeplearning
avec la technique de l approche par renforcement. Cette méthode utilise les propri étée dite de ma
kov. Le calcul de seuil critique vient après les calculs d equité qui vise a equilibrer les ressources
d un OS.

FICHIER HEADER
/*
PROJET :SWITCHING MICRO KERNEL ENRICHIT 2NR ©
copyright © :OUESLATI MATTHIEU
author name :OUESLATI MATTHIEU
rôle :
*/
Pour développer le fichier CriticalSeuil j ai initialiser un fichier #ifndef et une commande pres
processeur #define DEF avec le nom du fichier CRITICALSEUIL
Un seuil critique en informatique permet de calculer le comportement d un OS ,d un Operating
System au fonctionnement critique,ceci pour calculer en outre les failles de ce dernier
Un SeuilCritique dans un systeme informatique initialise les tache et les failles au maximum et
minimum de leurs capacités.

#ifndef DEF_CRITICALSEUIL
#define DEF_CRITICALSEUIL
#include<iostream>
#include <fstream>
#include <sstream>
#include<string,h>
#include<time.h>
class CRITICALSEUIL
{
public :
CRITICALSEUIL() ;
void createPthread() ;
void initCalculMin(int minimax) ;
void time(CRITICALSEUIL&echeance) ;
void testCPU() ;
void testBattery() ;
bool test_CRITICALSEUIL() ;
private :
int m_calculSeuil ;
};
#endif
Les algorithmes du premier niveau d ordonnancement systeme est en RoundRobin je ne vais pas
tout mettre en bloque dans le sens ou je me retrouverai en monolithique

FICHIER SOURC E
/*
PROJET:SWITCHING MICRO KERNEL ENRICHIT 2NR ©
copyright © :OUESLATI MATTHIEU
author name :OUESLATI MATTHIEU
rôle :
*/
#include'' CRITICALSEUIL,h'
using namespace std ;
CRITICALSEUIL ::CRITICALSEUIL()
{
m_calculSeuil ;
}
void CRITICALSEUIL ::createPthread()
{
}
&void CRITICALSEUIL ::initCalculMin(int minimax)
{
}
void CRITICALSEUIL :: testCPU()
{
}

void CRITICALSEUIL ::testBattery(CRITICALSEUIL&testBattery)
{
testBattery ,(m_calculSeuil) ;
}
void CRITICALSEUIL ::time(CRITICALSEUIL&echance)
{
}
CRITICALSEUIL ::~CRITICALSEUIL()
{
}

FICHIER SchedUploadProcess
/*
PROJET :SWITCHING MICRO KERNEL ENRICHIT 2NR ©
copyright(c) :OUESLATI MATTHIEU
author name :OUESLATI MATTHIEU
rôle :
*/
Pour développer les fichiers pour fabriquer un système en deeplearning et a tache
paralleles
#ifndef DEF_SchedUploadProcess
#define DEF_SchedUploadProcess
#include<iostream>
#include<pthread,h>

class SchedUploadProcess
{
public :
SchedUploadProcess() ;
void uploadProcess() ;
void initfdtdt() ;
void principale() ;
bool test_SchedUploadProcess() ;
private
}

xx
SchedUploadProcess ::SchedUploadProcess()
{
}
void SchedUploadProcess ::uploadProcess()
{
}
void SchedUploadProcess ::initfdtdt()
{
}
void SchedUploadProcess ::principale()
{
}
bool SchedUploadProcess ::test_SchedUploadProcess()
{
}

Pour développer l instance je vais initialiser un objet
SchedUploadProcess(
j ai une fonction qui va initialiser le parallelisme initfdtdt
la fonction principale lance le systeme de boucle en langage de programmation C++
il existe trois type de boucle le do while le while et le for en algorithmie
on a tant que et pour que.

FICHIER SOURCE
/*
PROJET :SWITCHING MICRO KERNEL ENRICHIT 2NR ©
copyright © :OUESLATI MATTHIEU
author name :OUESLATI MATTHIEU
rôle :
*/
#include ''SchedUploadProcess,h''
using namespace std ;

SchedUploadProcess ::SchedProcessUpload()
{
}
void SchedUploadProcess :: uploadProcess() ;
void SchedUploadProcess ::initfdtdt() ;
void SchedUploadProcess ::principale() ;
bool SchedUploadProcess :: test_SchedUploadProcess() ;
SchedUploadProcess ::~ SchedUploadProcess()

{
En C++ on a deux type de fichiers il y a le fichier source et le fichier header
Dans le header il y a les fonction prototype

Dans le fichier source ci présent j ai un objet SchedUploadProcess
Avec une fonction uploadProcess(), une fonction initfdtdt()
La fonction initfdtdt permet d initialiser le parallelisme dans le systeme informatique

FICHIER SCHEDPEREMPT
/*
PROJET :SWITCHING MICRO KERNEL ENRICHIT 2NR ©
copyright © :OUESLATI MATTHIEU
author name :OUESLATI MATTHIEU
rôle :
*/
Selon la régle d un Operating System on initialise une peremption cette derniere permet
de gerer les processus on a un processus d arriere plan

class Background
{
public :
Background() ;
private :
}
#endif

FICHIER HEADER
/*
PROJET :SWITCHING MICRO KERNEL ENRICHIT 2NR ©
copyright © :OUESLATI MATTHIEU
author name :OUESLATI MATTHIEU
rôle :
La peremption d'un système est ce qui permet d intialiser un multi tache en outre un système d
information est un systeme multi tache et multi ultilisateur une tache est une interruption au
niveau des applications software en
*/
En langage de programmation C++, on ecrit le fichier sous forme de macros une macro est un

morceau de code donc je vais initialiser le probleme avec du temps pour ordonnancer les processus
au mieux . La peremption s effectue au premier et a l arriere plan d un ordonnanceur
le schema de gantt permet de prevoir les proc
essus dans l ordonnanceur ou scheduler en anglais
Donc ici j ai initialiser les fonctions gant() front et backgound() ; la fonction front permet d
'initialiser les processus en actions et en arriere plan les processus a faible taux d utilisations

Pour développer le fichier j ai devlopper les commandes pres processeur #ifndef
DEF_SCHEDPERENT
et la commande pres processeur #define DEF_SCHEDPERREMPT
#ifndef DEF_SCHEDPERRENT
#define DEF_SCHEDPERENT
#include<iostream>
#include<ctime>
#include<vector>

J ai initialiser la commande #include<iostream> et la bibliotheque #include<ctime>

class SCHEDPERRENT
{
public :
Le nom de la classe est SCHEDPERREMPT j ai initialiser l objet du meme nom
SCHEDPERENT() ;
Etant dans une manipulation de processus j ai initialiser une fonction de Gantt
void gantt() ;
void front() ;
void backround() ;
void processus(SchedPerent&HiProcess) ;
void processusII(SchedPerent&nice) ;
void time() ;
bool test_Perent() ;
private :
int m_initPerrenpt ;
};
#endif
Toujours dans l'instance SCHEDPERENT j ai la fonction processus qui passe en reference
SchedPerent & HiProcess ceci pour initialiser les procesus a haute priorité et background pour les
processus a basse priorité.
Class TOURNIQUET :public SCHEDPERREMPT
{
public :
TOURNIQUET()
void createPthread() ;
Dans cette partie jai intialiser la politique d'ordonnancement cette partie est en RoundRobin
C est la fonction politique qui permet d initialiser l ordonnancement.Ce dernier fonctionnera

plutard avec le deeplearning.
void politique(TOURNIQUET&POLICY_RR).
Bool test_TOURNIQUET() ;
private
}
#endif
En algorithmie on initialise un algorithme RR ou SJF
RoundRobin ou Shortest Job First La peremption permet de définir la priorite des processus
au seins d un SCHEDPERREMPT

En langage de programmation C++ le compilateur execute deux fichiers
il y a le fichier header et sou rce

SCHEDPERREMPT ::SCHEDPERREMPT()
{
}
void SCHEDPERREMT ::gantt()
{
}
void SCHEDPERREMPT ::front()
{
}
void SCHEDPERREMPT :
SCHEDPERREMPT ::~SCHEDPERREMPT()
{
}
TOURNIQUET ::TOURNIQUET()
{
}
TOURNIQUET ::~TOURNIQUET()
{
}

FICHIER SOURCE
/*
PROJET :SWITCHING MICRO KERNEL ENRICHIT 2NR ©
copyright © :OUESLATI MATTHIEU
author name :OUESLATI MATTHIEU
rôle :
*/

FICHIER SOURCE
/*
PROJET :SWITCHING MICRO KERNEL ENRICHIT 2NR ©
copyright © :OUESLATI MATTHIEU
author name :OUESLATI MATTHIEU
rôle :
*/
#include ''SCHEDPEREMPT,h''
using namespace std ;

SchedPerent ::SchedPerent()
{
m_initPerrempt ;
}
void SchedPerent ::gantt()
{
}
La fonction gantt qui initialise le diagramme de gantt
j ai l objet SchedPerempt qui porte sur la fonction gantt
un diagramme de gantt sert pour prevoir les processus dans le système
informatique. Sous ELECTRONIC BUSINESS NETWORK(c)
c est en deeplearning.Par défault ELECTRONIC BUSINESS NETWORK(c)
est une machine autonome

voidSchedPerent :: front()
{
}
void SchedPerent :: backround()
{
}
void SchedPerent ::processus(SchedPerent&HiProcess)
{
HiProcess,startPeremption(m_initPerent) ;
}
Ici j ai initialiser une fonction processus.cette derniere
est porté par l objet Sched Perempt
Dans le corps de fonction j ai Une fonctio HiProcess
J ai pris pour patron Linux pour les distribution de priorité
void SchedPerent ::processusII(SchedPerent&nice)
{
nice,() ;
}
void SchedPerent ::time() ;
{
}
void SchedPerent ::tabAPI()

{
}
Le tableau ci dessus permet de lancer les processus des applications de ELECTRONIC BUSINESS
NETWORK ©
bool SchedPerent :: test_Perent()
{
int
if()
{
}
else()
}
SchedPerent ::

FICHIER SOURCE
/*
PROJET :SWITCHING MICRO KERNEL ENRICHIT 2NR ©
copyright © :OUESLATI MATTHIEU
author name :OUESLATI MATTHIEU
rôle :
*/
#ifndef DEF_SchedulerSJF
#define DEF_SchedulerSJF
#include<iostream>
class SchedulerSJF :public SCHEDPERENT
{
public :
SchedulerSJF() ;=
void createPthread() ;
void scheduling(SchedulerSJF&POLICY_SJF) ;
bool test_SchedulerSJF() ;
private :
}
#endif
FICHIER SOURCE
/*
PROJET : SWITCHING MICRO KERNEL ENRICHIT 2NR ©
copyright © :OUESLATI MATTHIEU
author name :OUESLATI MATTHIEU
rôle :
*/

#include''SchedulerRSJF,h'
using namespace std ;
SchedulerRSJF ::SchedulerRSJF()
{
}
void SchedulerRSJF ::createPthread()
{
}
void ScheduleRSJF :: scheduling(SchedulerSJF&POLICY_SJF)
{
}
bool SchedulerRSJF ::test_SchedulerSJF()
{
}
SchedulerRSJF ::~SchedulerRSJF()
{
}

FICHIER SOURCE
/*
PROJET :SWITCHING MICRO KENEL ENRICHIT 2NR ©
copyright(c) :OUESLATI MATTHIEU
author name :OUESLATI MATTHIEU
rôle :
*/
FICHIER HEADER
/*
PROJET :SWITCHING MICRO KERNEL ENRICHIT 2NR(c)
copyright © :OUESLATI MATTHIEU
author name :OUESLATI MATTHIEU
rôle :
*/
Pour développer l algorithme de tourniquet je vais initialiser
les fonction pre processeur #ifndef et #define avec les nom TOURNIQUET
J ai pour bibliothèque la bibliothèque #include <iostream>
#ifndef DEF_TOURNIQUET
#define DEF_TOURNIQUET
#include<iostream>
#include''CRITICALSEUIL.h''

Ici j ai l instance Tourniquet elle herite de CRITICALSEUIL
Ici j ai l objet TOURNIQUET et les fonction
de type void un type void ne renvois rien par ce que par default vide
createPthread() , loadProcess() qui charge les processus
j ai en référence l instance TOURNIQUET&POLICY_RR

class TOURNIQUET :public CRITICALSEUIL
{
public :
TOURNIQUET() ;
void createPthread() ;
void loadProcess(TOURNIQUET&POLICY_RR) ;
void uploadProcess() ;
private :
int m_calculTOURNIQUET ;
}
#endif

FICHIER SOURCE
/*
PROJET :SWITCHING MICRO KERNEL ENRICHIT 2NR ©
copyright © :OUESLATI MATTHIEU
author name :OUESLATI MATTHIEU
rôle :
*/

CRITICALSEUIL ::CRITICALSEUIL()
{
}
void CRITICALSEUIL ::createPthread()
{
}
Etant dans un systeme en multi threading j ai initialiser une fonction createPthread qui permet d
initialiser plusieurs processus legers.
void CRITICALSEUIL ::initCalculMin()
{
}
J ai initialiser ici une fonction de calcul des performances minimums du systeme avec
initCalculMin

void CRITICALSEUIL ::uploadProcess()
{
En langage de programmation objet donc en C++dans le cas présent je vais initialiser une boucle
while soit tant que qui prend en parametre de repetition uploadProcess et setCache() avec en
finition un seuilCritique en theorie on a un une boucle suivit d un default ma
int setSeuilCritique() ;
while(seuilCritique)
{
void uploadProcess() ;
void setCache() ;
default(seuilCritique)
{
}
}
En C++ pour initialiser un fichier on utilise fstream avec les fonction ofstream , ifstream
j ai egalement initialiser une fonction initFile pour initialiser le fichier
A l interieur j ai calculer le stoud qui prend pour parametre le nom et le chemin d accès du fichier
On test d abord si le fichier est ouvert avant d ecrire les flux
void CRITICALSEUIL ::initFile()
{
std ::ofstream('A :\CritiCalSeuil,sys')
if(''CriticalSeuil ''){
ss>>x>>stream>>x>>

fclose('' A :\CritiCalSeuil'')
}
}
Ici j ai initialiser les fonctionaliter de lâ STL pour les manip de flux et de test de mémoire critique
void CRITICALSEUIL ::testCPU()
{
}
void CRITICALSEUIL :: testBattery()
{
}
CRITICALSEUIL ::~ CRITICALSEUIL()
{
}
FICHIER SOURCE
/*
PROJET :SWITCHING MICRO KERNEL ENRICHIT 2NR(c)
copyright © :OUESLATI MATTHIEU
author name :OUESLATI MATTHIEU

rôle :
*/
En langage de programmation C++ j ai initialisé un fichier header grace a l inclusion du fichier
j ai initialiser l espacenom avec le mot cle namespace et le std pour initialiser le flux de fichier
dans lefichier prototype on initialisera la bibliothèque #include<iostream> qui permet d 'initialiser
les entrée sortie sur flux
#include'' CRITICALSEUIL,h''
using namespace std ;
TOURNIQUET ::TOURNIQUET() :CRITICALSEUIL()
{
m_calculTOURNIQUET()
}
void TOURNIQUET ::createPthread()
{
}
void TOURNIQUET ::loadProcess(TOURNIQUET&POLICY_RR)
{
POLICY_RR,(m_calculTROURNIQUET) ;

}
Dans un ordonnanceur RR ou RoundRobin on initialise une tete et un queue d ordonnancement
void TOURNIQUET ::queue(TOURNIQUET&POLICY_RR)
{
POLITIC_RR,(m_calculTOURNIQUET) ;
}
void TOURNIQUET ::tete(TOURNIQUET&POLICY_RR)
{
POLICY_RR,initProcess(m_calculTOURNIQUET);
}
bool TOURNIQUET ::initTOURNIQUET()
{
}

FICHIER EQUITE
/*
PROJET:SWITCHING MICRO KERNEL ENRICHIT 2NR (c)
copyright (c):OUESLATI MATTHIEU
author name:OUESLATI MATTHIEU
role:

Dans un système informatique l equite est l equilibre des ressources.On egalement un système de
distibution électrique qui permet une alim équitable. L equite fonctionne selon un principe d
ecaunomie avec une relation 20/80 on initialisera l optimum de paretto
*/
Pour initialiser le fichier je procederai comme à l'accoutumé en identifiant le fichier #ifndef et
#define donc sijamais le fichier est définit alors on le definit en omettant pas les commandes près
processeurs #ifndef une commande près processeur est pres chargée dans le cache processeur ;

#ifndef DEF_EQUITE
#define DEF_EQUITE
#include<iostream>
#include <fstream>
#include<pthread,h>
class Equite
{
public:
Equite();
void createPthread();
void tableDesProcessus();
void initRessource'();
void tauxDeProcessus(Equite&tauxDeProcess) ;
private:
int m_setEquite;
}
#endif

Etant dans une grille de calcul Egee .Une grille de calcul est un ensemble de machine ou d applica
ion dans le cas échéant ; La grille EGEE est la grille de calcul qui permet la deeplearning
class EQUITEEGEE :public EQUITE
{
public :
EQUITEEGEE() ;
void createPthread() ;
void loadApplication() ;
void initFileIV()
bool test_EQUITEEGEE()
private :
}

FICHIER SOURCE

/*
PROJET :SWITCHING MICRO KERNEL ENRICHIT 2NR ©
copyright © :OUESLATI MATTHIEU
author name :OUESLATI MATTHIEU
rôle :
*/
#include''Equite,h''
usin namespace std

EQUITE ::EQUITE()
{
}
void EQUITE ::createPthread()
{
}
void EQUITE ::tableDesProcessus()
{
}
Ici j ai initialiser un fichier initFileV dans lequel j ai initialiser un flux de debut de fichier ios ::in
et ios ::app

void EQUITE ::initFileV()
{
std ::ofstream(''A \Equite,sys''ios ::in |ios ::app)
if(initFile)
{
}
i
{
}
La fonction if permet de tester le fichier savoir si le fichier renvois une troncature ou un début
de calcul de bit dans le cas échéants j ai initialisé un début de calcul de bits avec le flux in ::ios
j ai initialiser une fonction tableDesProcessus qui permet d'initialiser les PID et les processus sous
ELECTRONIC BUSINESS NETWORK(c)
)
}
EQUITE ::~EQUITE()
{
}


CAHIDER DES CHARGES DU SWITCHING MICO KERNEL ENRICHIT 2NR (c).pdf - page 1/442
 
CAHIDER DES CHARGES DU SWITCHING MICO KERNEL ENRICHIT 2NR (c).pdf - page 2/442
CAHIDER DES CHARGES DU SWITCHING MICO KERNEL ENRICHIT 2NR (c).pdf - page 3/442
CAHIDER DES CHARGES DU SWITCHING MICO KERNEL ENRICHIT 2NR (c).pdf - page 4/442
CAHIDER DES CHARGES DU SWITCHING MICO KERNEL ENRICHIT 2NR (c).pdf - page 5/442
CAHIDER DES CHARGES DU SWITCHING MICO KERNEL ENRICHIT 2NR (c).pdf - page 6/442
 




Télécharger le fichier (PDF)


CAHIDER DES CHARGES DU SWITCHING MICO KERNEL ENRICHIT 2NR (c).pdf (PDF, 914 Ko)

Télécharger
Formats alternatifs: ZIP



Documents similaires


cahider des charges du switching mico kernel enrichit 2nr c
cours mcc18 20v14
wdpet9 manuel fr
polys c mm
d3 rapport fina projet electronique
intro cs poo