Utilisation de la CPU

[Dlzlogic]

Bonjour,
Je suis entrain d'écrire un programme qui tourne en arrière plan, donc en permanence et qui effectue une opération toutes les N secondes (par exemple tous les 1/4 d'heure)
La séquance concernée est celle-ci

    while (!should_terminate)
    {
      time_t le_jour=time(0);
      if ((le_jour - init_interval) > interval)
      {
        tm *tml=localtime(&le_jour);
fprintf(espion,"Envoi du fichier  %d mn %d sec\n",tml->tm_min,tml->tm_sec);
printf("Envoi du fichier  %d mn %d sec\n",tml->tm_min,tml->tm_sec);
fflush(espion);
//C'est là qu'intervient le fichier à créer et envoyer
// Ici le traitement qui ne pose pas de problème
        time(&init_interval);   // réinitialisation de init_interval
      }  // fin du bloc if
    }  // fin du bloc while

Il n'y a que 2 façons de sortir du while (should_terminate à true) Ctrl+c ou fermeture
Mon souci : pendant que le programme attend le moment de faire la manipe suivante (Création de fichier etc.) la CPU est utilisée à 50%, ce qui ne me parait parait pas acceptable.
Est-il possible que ce soit juste mon timer qui en est la cause ? y aurait-il un autre moyen ? ou au contraire le timer n'est certainement pas responsable, alors où chercher ?

Mon environnement, Windows XP, je travaille avec Borland Builder
Merci d'avance.
-----

[invite936c567e]

Bonjour

Ton programme ne cesse de tourner en exécutant les trois premières lignes, sans repos. Si par exemple l'exécution de ces lignes prend 100 ns, alors la boucle est répétée 10 millions de fois par seconde. Il est donc normal que cela charge le processeur.

Si tu ajoutais une petite temporisation par un appel système, la boucle serait répétée beaucoup moins souvent et les autres logiciels exécutés auraient beaucoup plus souvent la main. Si l'attente se compte en minutes, une temporisation d'une ou plusieurs secondes pourrait certainement convenir.

Tu pourrais donc utiliser la fonction sleep() pour la réaliser.

[invite936c567e]

J'avais mal lu. Comme tu es sous Borland Builder, tu peux utiliser la fonction Sleep() de l'API Windows, avec une majuscule et une valeur de temporisation exprimée en millisecondes.

[Dlzlogic]

Ca marche, merci.

[A voir en vidéo sur Futura]

[Dlzlogic]

Je ne connaissais pas cette fonction.
Mais comme le but est de lancer cette opération toutes les N secondes, et N est une variable, il suffit que Je mette Sleep(N*1000).
Pas utile de se compliquer la vie avec les time, init_interval et Cie.
En effet, l'opération peut éventuellement modifier N;

[polo974]

sauf que Sleep ou sleep ne garanti pas la durée exacte, seulement un dodo minimum...

donc lire l'heure, calculer ce qu'il reste à dormir, bosser, boucler

[Dlzlogic]

Ok, donc je laisse comme ça.
Merci.

[invite7a96054d]

Bonjour,

et utiliser le scheduler windows ? XP doit bien en avoir un je suppose ... du coup tu n'as plus qu'à coder ton traitement sans t'embêter plus.

[invite2d7144a7]

Bonjour,

Le scheduler n'est pas vraiment fait pour des intervalles si faibles (l'exemple donné est 1/ d'heure), et surtout, il ne sera pas plus précis.

Plutôt que sleep, un timer pourrait peut-être donner une meilleure précision, et quoi qu'il en soit, je pense que ce serait une solution plus "propre", mais ce n'est qu'un avis personnel.

[Dlzlogic]

Oui, le timer parait pas mal, d'autant qu'on reste au bas niveau, et ça, j'aime bien.
L'intervalle peut descendre à 5 mn, et pourquoi pas encore moins, dans des cas probablement rares, mais c'est justement dans ces cas là qu'il faut être sûr de soi.
Merci, c'est sympa de vous intéresser à mon problème.

[Jack]

Oui, le timer parait pas mal, d'autant qu'on reste au bas niveau

Il me semble que le timer de la VCL est logiciel et que sa précision n'est pas garantie

[Dlzlogic]

Bonsoir Jack,
En fait j'utilise les fonctions de base, et pas la VCL. Donc c'est MON timer : mon programme, c'est du C pur et dur
C'est un projet difficile sur lequel je suis depuis près de 2 mois, et j'ai eu un mail ce matin pour me demander une version démo pour vendredi (demain).
Toutes vos réponses m'ont vraiment fait plaisir.
Bonne soirée.

[Jack]

Et on utilise comment ce timer bas niveau?

[Dlzlogic]

La chose qui m'intéresse est d'exécuter un module toutes les N secondes.
J'initialise interval et init_ interval, respectivement l'intervalle voulu et le début du comptage.

      time_t le_jour=time(0);
      if ((le_jour - init_interval) > interval)
      {
       .... traitement
         time(&init_interval);   // réinitialisation de init_interval
      }

Ce sont des fonctions de time.h, peut-être pas "base-niveau" mais en tout cas ne dépendant pas de la VCL.
Pour tout dire, je comprends pas très bien ta question.
Il est bien évident que le Sleep() peut faire dépasser le moment précis d'exécution, mais il y aura lieu de préciser le nombre de millisecondes à donner en paramètre.

[Jack]

Je pensais que tu utilisais un vrai timer, qui lancerait un événement au bout de la période donnée. Ca m'intéressait de voir comment ça fonctionnait

En l'occurrence, tu as défini du code qui s'exécute durant un temps donné, ce qui est plus classique

[Dlzlogic]

Oui et non, parce que je suis dans une boucle infinie

     while (!should_terminate)
    {
      Sleep(1000);
      time_t le_jour=time(0);
      if ((le_jour - init_interval) > interval)
      {
        Le treitement
        time(&init_interval);   // réinitialisation de init_interval
      }  // fin du bloc if
    }  // fin du bloc while

Donc, dans mon esprit, c'est un timer.
Dans le cas précis on ne peut sortir de la boucle que par une fin de traitement.
Il est bien évident que ça n'a rien d'original.

[Jack]

Ce que je ne comprends pas c'est pourquoi ne pas faire directement un Sleep() avec la tempo qui va bien

[Dlzlogic]

J'avais envisagé cela, mais Whoami me l'a déconseillé.
Le système et les réseaux, c'est pas mon truc, alors, je me limité à m'assurer que ca marche, même si c'est pas optimisé.
Y'a des trucs que je connais mieux, alors sur ces points-là, je suis sûr de moi.
Sur-ce, dodo.

[polo974]

si ton code doit s'executer à un intervale moyen stable quel que soit le temps de traitement, il faut faire un truc du genre:

    time_t cur_t , next_t;

    for (next_t = time(NULL) + interval; !should_terminate; next_t += interval)
    {
        cur_t = time(NULL);
        if ( cur_t < next_t)
        {
            Sleep((next_t - cur_t) * 1000);
        }
        else
        {
            oulàlà, j'ai trop trainé dans le traitement précédent...
        }  // fin du bloc if

        Le traitement

    }  // fin du bloc for

le bloc else est optionnel, mais toujours utile au debug...

[invite2d7144a7]

Bonjour,

Et si la précision du temps est importante, il faudra en plus faire tourner le programme en très haute priorité, soit en la changeant "manuellement", c'est à dire à chaque démarrage du logiciel, soit en la forçant avec le programme lui-même.

C'est un des inconvénients des systèmes modernes, il y a tant de processus qui tournent qu'on ne peut pas garantir des délais parfaitement maîtrisés.

[Dlzlogic]

Bonjour,
La précision du temps n'est pas vraiment importante en tant que précision. Simplement, lorsque les intervalles sont courts, c'est qu'il y a une raison, alors il ne faut pas que le système de surveillance coince justement au moment où on en a besoin.
"chaque démarrage du logiciel" : dans un contexte normal, il n'y en aura qu'un seul.

[invite2d7144a7]

Bonjour,

Bonjour,
La précision du temps n'est pas vraiment importante en tant que précision. Simplement, lorsque les intervalles sont courts, c'est qu'il y a une raison, alors il ne faut pas que le système de surveillance coince justement au moment où on en a besoin.
"chaque démarrage du logiciel" : dans un contexte normal, il n'y en aura qu'un seul.

C'est impossible, à moins que ta machine soit constamment en fonction, constamment étant pris au sens fort : sans la moindre interruption, quelle que soit la cause, ce qui est strictement impossible.