moyen facile d'analyser un fichier texte?

Question

Je fais un équilibreur de charge (très simple). Il examine la durée pendant laquelle l'utilisateur a été inactif et la charge sur le système pour déterminer si un processus peut s'exécuter, et il parcourt les processus de manière circulaire. Toutes les données nécessaires au contrôle des processus sont stockées dans un fichier texte.

Le fichier pourrait ressembler à ceci:

PID=4390 IDLE=0.000000 BUSY=2.000000 USER=2.000000 
PID=4397 IDLE=3.000000 BUSY=1.500000 USER=4.000000 
PID=4405 IDLE=0.000000 BUSY=2.000000 USER=2.000000 
PID=4412 IDLE=0.000000 BUSY=2.000000 USER=2.000000 
PID=4420 IDLE=3.000000 BUSY=1.500000 USER=4.000000 

C'est une mission de l'université, l'analyse syntaxique mais le fichier texte n'est pas censé être une grande partie de celui-ci, ce qui signifie que je peux utiliser quelque manière est le plus rapide pour moi implémenter.

Les entrées de ce fichier seront ajoutées et supprimées à mesure que les processus se termineront ou seront ajoutés sous contrôle.

Des idées sur la façon d'analyser cela?

Merci.

Answer 1

Voici un code qui analysera votre fichier et tiendra également compte du fait que votre fichier pourrait être indisponible (fopen peut échouer), ou être écrit pendant que vous le lisez (fscanf peut échouer) . Notez cette boucle infinie, que vous ne voudrez peut-être pas utiliser (c'est plus de pseudo-code que de code réel à copier-coller dans votre projet, je n'ai pas essayé de l'exécuter). Notez également que cela peut être assez lent étant donné la durée du sommeil: vous pouvez utiliser une approche plus avancée, c'est plutôt un hack.

int pid; 
float idle, busy, user; 

FILE* fid; 
fpos_t pos; 
int pos_init = 0; 

while (1) 
{ 
    // try to open the file 
    if ((fid = fopen("myfile.txt","rw+")) == NULL) 
    { 
    sleep(1); // sleep for a little while, and try again 
    continue; 
    } 

    // reset position in file (if initialized) 
    if (pos_init) 
    fsetpos (pFile,&pos); 

    // read as many line as you can 
    while (!feof(fid)) 
    { 
    if (fscanf(fid,"PID=%d IDLE=%f BUSY=%f USER=%f",&pid, &idle, &busy, &user)) 
    { 
     // found a line that does match this pattern: try again later, the file might be currently written 
     break; 
    } 

    // add here your code processing data   

    fgetpos (pFile,&pos); // remember current position 
    pos_init = 1; // position has been initialized 
    } 

    fclose(fid); 
} 

Answer 2

Utilisez fscanf dans une boucle. Voici un tutoriel GNU C sur l'utilisation fscanf.

/* fscanf example */ 
#include <stdio.h> 

typedef struct lbCfgData { 
    int pid; 
    double idle; 
    double busy; 
    double user; 
} lbCfgData_t ; 

int main() 
{ 
    // PID=4390 IDLE=0.000000 BUSY=2.000000 USER=2.000000 
    lbCfgData_t cfgData[128]; 

    FILE *f; 

    f = fopen ("myfile.txt","rw+"); 
    for ( int i = 0; 
      i != 128 // Make sure we don't overflow the array 
      && fscanf(f, "PID=%u IDLE=%f BUSY=%f USER=%f", &cfgData[i].pid, 
       &cfgData[i].idle, &cfgData[i].busy, cfgData[i].user) != EOF; 
      i++ 
     ); 

    fclose (f); 
    return 0; 
} 

Answer 3

En ce qui concerne l'analyse syntaxique juste est concerné, quelque chose comme cela dans une boucle:

int pid; 
float idle, busy, user; 
if(fscanf(inputStream, "PID=%d IDLE=%f BUSY=%f USER=%f", %pid, &idle, &busy, &user)!=4) 
{ 
    /* handle the error */ 
} 

Mais comme @Blrfl a souligné, le gros problème est d'éviter mixups lorsque votre application est la lecture du fichier et les autres lui écrivent. Pour résoudre ce problème, vous devez utiliser un verrou ou quelque chose comme ça; voir par exemple le syscall flock.