Estoy haciendo un equilibrador de carga (muy simple). Parece que en el tiempo que el usuario ha estado inactivo, y la carga en el sistema para determinar si un proceso puede ejecutar, y pasa a través de los procesos en un round-robin.

Todos los datos necesarios para el control de los procesos se almacenan en un archivo de texto.
El archivo podría tener este aspecto:

 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

Esta es una universidad de asignación, sin embargo analizando el archivo de texto no debería ser una gran parte de ella, lo que significa que puedo usar cualquier manera es la mejor para mí para poner en práctica.

Entradas en este archivo se añade y quita como los procesos de acabado o se agregan bajo control.

Alguna idea sobre cómo analizar esto?

Gracias.

  • El análisis es fácil. La parte más difícil va a ser asegurarse de que usted no trate de leer, mientras que algo más está escrito.
  • Estoy usando el rebaño para que.
InformationsquelleAutor Blackbinary | 2011-03-06

3 Comentarios

  1. 1

    Aquí es un código que se va a analizar el archivo, y también tener en cuenta el hecho de que el archivo podría no estar disponible (es decir, fopen puede fallar), o por escrito, mientras usted lee esto (que es, fscanf puede fallar). Tenga en cuenta que bucle infinito, que puede que no desee utilizar (más de pseudo-código que el código real de la copia-pega en tu proyecto, yo no intentar ejecutarlo). Tenga en cuenta también que podría ser muy lento dada la duración del sueño no: es posible que desee utilizar un enfoque de avanzada, que es más una especie de 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);
    }
    • Usted se olvidó de todos los signos, y todos los campos (menos pid) son floats.
    • corregido, gracias 😛
    • No estoy seguro de a quién dar la respuesta correcta a. Estoy eligiendo Greg, porque ha incluido el bucle y apertura de archivo, como una respuesta más completa.
    • modifiqué mi respuesta con el fin de tener en cuenta el hecho de que el archivo que usted está leyendo puede no estar disponible, o puede ser que se escriben mientras usted lee esto.
    • En realidad, no puede no estar disponible debido a que anteriormente en el programa yo lo cree si no está disponible. Y no se puede ser escrito como he encerrado en bandadas. Me estoy perdiendo algo?
    • Ah. Pensé que este archivo fue escrito por una serie de otros procesos, y de que su programa estaba leyendo al mismo tiempo. Así que no importa :P, Si el archivo está completamente bajo el control de tu (single-threaded) programa, entonces usted no necesita de bloqueo (si el diseño es correcto).

  2. 1

    Tan lejos como se acaba de análisis se refiere, algo como esto en un bucle:

    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 */
    }

    Pero como @Blrfl señaló, el gran problema es evitar mixups cuando su aplicación es leer el archivo y los otros son la escritura. Para resolver este problema, debe utilizar un bloqueo o algo por el estilo; ver, por ejemplo, la flock syscall.

    • sí, yo estoy usando el rebaño
  3. 0

    Uso fscanf en un bucle. He aquí una de C de GNU tutorial sobre el uso de 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;
    }

Dejar respuesta

Please enter your comment!
Please enter your name here