Version imprimable
Bonjour,
Je cherche comment je pourrais faire pour modéliser (et simuler) des graphes de dependance de processus en temps réel avec c++. Je ne sais sincèrement pas par quoi et comment commencer .. et ou ?
J'espere que vous pourriez m'aider en me mettant sur des pistes.
Merci.
Par le début.:aie:Citation:
pas par quoi et comment commencer
Au plus simple.
Bien définir le problème.
Processus Père-Fils à la POSIX ?Citation:
graphes de dependance de processus
Pareil, rien compris au problème... Qu'appelles tu "graphes de dépendance" ?? Habituellement, au sens "père-fils", ça se règle tout bêtement via une treelist (cf. Process Explorer par exemple), donc le problème semble franchement trivial...
voilà ce que je veux faire , j'essaye d'expliquer mon but :
conception et réalisation d'une application qui permet la visualisation des processus et les détails de leurs exécutions ( Les accès mémoires en temps réel de leurs différentes instructions, classement automatique des variables en différentes catégorie [Read Only, Read Never, ...]). cet outil va permettre de tracer le graphe de dépendance des différentes variables d'un programme.
Cet outil permet d'etudier des codes en c ou c++ et nous fournir des informations tres utiles pour comprendre et interpréter son exécution aucours du temps et faire des simulations.
Moi, j'essaierais de faire une dll d'extension à Windbg ou encore mieux, d'en trouver une qui fasse le boulot.
http://www.codeproject.com/KB/debug/cdbntsd4.aspx
Mais c'est vraiment pas fait pour des débutants.
C'est bien d'être optimiste, mais là, faudra vraiment s'accrocher très très fort.
Puisque je suis encore debutante dans ce theme de SE
Mais j'ai lu quelques documents pour gestion des processus et acces memoires et j'arrive à comprendre quelques notions :P .
Mais, je cherche une idée comment je peux recupere ma table de processus cad les processus qui sont entrain d'executer .. la liste affiché avec la commande ( ps -f ou ps -ef)
Je veux le recuperer ( en fait le PID du chancun ça suffit :) ) pour avoir quelques informations sur chaque processus qui existe ( que ce soit son etat = actif , endormi , zombie ou bloqué ), les afficher dans un diagramme ( simulateur ) selon un algorithme d'acces memoires (SFJ , FCFS , .... )
Ca c'est mon idée au debut à ameliorer apres, mais reste toujours des idées sans rien ..:marteau:
Pouvez m'aider et merci ..
Il se pose alors la question de l'OS ciblé, du framework graphique choisi pour l'affichage, et surtout, du moyen que tu as d'accéder à ces informations...
Mais bon : il serait bon que tu saches que tu n'as à priori aucun moyen de savoir quand un processus accède à une de ses données, pas plus que tu ne peux savoir quand un thread / processus est activé par le scheduler... Ce genre d'outils est en général non seulement spécifique à un OS donné, mais en plus, ils n'existent en général que sur des OS temps réel. Ils sont également chers, très chers, certains imposent d'ailleurs l'utilisation d'une sonde matérielle sur le CPU pour fonctionner.
Sans accès direct au kernel et au scheduler, tu ne peux guère faire que du polling façon top sur la charge de chaque processus / thread. Quant à savoir ce que chaque processus / thread fait réellement, c'est quasi-impossible.
En fait , je lis bien les données de mon travail et j ai trouvé que je dois commencer par cette demarche pour extraire les axes de ma solution a suivre.
Je vais proposer un exemple à suivre pour mieux me comprendre afin de m'aider si possible encore une fois ( merci ) :
En prennant exemple du produit sequentiel des deux matrices :
1- Je fais une etude "manuelle " de mon code , c'est à dire lire instruction par instruction pour avoir mes variables utilisées au cours d'execution, en classifiant mes variables ceci suivant un simple critere qui est l'etat de mon variable ou bien plus clairement est ce que ce variable en mode = lecture , ectriture ou non utilisé jamais (ou bien utilisé une fois apres on a besoin de lui encore , tout depend )
Cette classification me permet de trouver une methode technique à implementer pour n'importe quel code à utiliser ou à etudier afin de realiser mon graphe de dependance.
C'est à dire une application qui lit un code ( produit matrice matrice , factorisation , ...) instruction par instruction en degageant mes variables selon le bloc d'instruction et le dependence entre eux s'ils existent bien sur
Je veux faire un petit exemple plus simple pour me comprendre :
Supposons mon code suivant :
Comment mon application quand elle lit mes instructions sait que quand elle lit un " egal = " , on a une affectation ; c'est à dire une allocation simple au niveau memoire ?Code:
2
3
4
5
6
quand elle lit une operation " + ,* ,- ou /) ,mon application sait qu'il un lien de dependance entre ma variable modifiée et les variables utilisées dans mes instructions ?
Ici je suppose qu'on doit affecter un Tag pour chaque variable pour identifier son " etat" pour que mon application à la fin puisse generer mon graphe de dependence voulu .
Voilà c'est que je veux dire . J'espere que vous arriverez à me comprendre et merci pour vos pseudo code pour mon application ou n'importe quoi peuvent m'aider à implementer ceci.
Le code est compilé, dans l'exécutable final, tu n'as plus que des instructions assembleur... Tu ne sais pas comment est fabriqué un programme C++ ???
je veux juste mieux comprendre ma tache et fixer les points sur les i .
ma tache consiste à trouver une technique qui permet de lire un code ( produit matrice matrice ) et degager mes variables utiilsé en le classifiant suivant un Tag bien determinée et selon son utilisation de la memoire . Ainsi , j'implemente cette technique dans un code pour le degager automatiquement en precisant les variables dans un fichier ainsi que le relations de dependance via un graphe .
Bon pour le fichier : je pensais qu'elle va contient 6 colonnes ( le 6ème je suis pas sur à le faire ) :
en supposons exemple suivant :
a=2;
b=3;
c=1;
z=a+b;
y=z+c;
On cherche a representer les dependances des variables au cours du temps. comme le code est sequentiel on peut commenter que une seule instruction a la fois. PAr contre j'ai pas besoin de connaitre la valeur de la variable tant que j'ai traca sur son @memoire.
Pour l'exemple, on peut representer les données autrement:
Temps #Variables #Status # @ # Dependance # Tag (a la fin de l'instruction)
=============================================================================================
=============================================================================================
0 # a # Write (on initialise) # # null # Dirty (Parcequ'il est modifié)
1 # b # Write (on initialise) # # null # Dirty (Parcequ'il est modifié)
2 # c # Write (on initialise) # # null # Dirty (Parcequ'il est modifié)
3 # a # Read # # null # Dead(will never used)
4 # b # Read # # null # Dead(will never used)
5 # z # Write # # a,b # Dirty
6 # c # Read # # null # Dead(will never used)
7 # z # Read # # null # Dead(will never used)
8 # y # Write # # c,z # Dirty
Remarque: // ça c ma tache pour le comprendre que vous devez avoir une idée plus :
1) Apres l'initialisation en generale, on fait un checkpoint (sauvegarde des valeurs)
2) Temps=7 le z n'a plus de dependance pask il est deja calculé et on suppose qu'on a sauvegardé sa valeur
sinon (si on n'a pas fait un checkpoint apres t=7), il faut gardé trace sur les dependances pour qu'on puisse recalculer sa valeur en cas de panne.
On va mettre les points sur les I.
Il n'y a pas de variables dans du code compilé natif.
Il n'y a que des cases mémoires et des registres en assembleur.
Le code qui s'exécute est en code machine.
Si j'ai bien compris, et c'est loin d'être sûr, vous voulez faire une analyse de l'utilisation des variables. Ce genre de chose ce fait en amont de la chaîne de compilation et il faut maîtriser toute la chaîne pour conserver ces informations synchrone avec le résultat attendu.
Vous parler d'accès mémoire, notion assembleur, et de variable, notion du langage de programmation. Ce sont donc des domaines distincts.
Soit vous voulez traquer les accès mémoire et vous ne devez pas résonner en variable. -> Outils de profiling mémoire.
Soit vous voulez traquer les variables et vous ne devez pas résonner en assez mémoire. -> Outil à intégrer en amont de la chaine de compilation
Si vous voulez faire les deux, il vous faut maîtriser toute la chaine de compilation et donc en choisir une que vous devez customiser de A à Z.