Wie stellen Sie eine genaue countdown-timer mit clock_gettime?

Könnte jemand bitte erklären, wie man einen countdown-timer mit clock_gettime, unter Linux. Ich weiß, Sie können verwenden Sie die clock () - Funktion, um die cpu-Zeit, und multiplizieren Sie es durch CLOCKS_PER_SEC um die tatsächliche Zeit, aber ich habe gehört, dass die clock () - Funktion ist nicht gut für diese geeignet.

So weit ich habe versucht diese (eine Milliarde ist die pause für eine Sekunde)

#include <stdio.h>
#include <time.h>

#define BILLION 1000000000

int main()
{
 struct timespec rawtime;
 clock_gettime(CLOCK_MONOTONIC_RAW, &rawtime);
 unsigned long int current =  ( rawtime.tv_sec + rawtime.tv_nsec );
 unsigned long int end =  (( rawtime.tv_sec + rawtime.tv_nsec ) + BILLION );
 while ( current < end )
 {
  clock_gettime(CLOCK_MONOTONIC_RAW, &rawtime);
  current =  ( rawtime.tv_sec + rawtime.tv_nsec );
 }

 return 0;
}

Ich weiß, das wäre nicht sehr nützlich, auf Ihre eigene, aber sobald ich herausgefunden habe, wie man Zeit richtig kann ich dieses in meine Projekte. Ich weiß, dass sleep() kann für diesen Zweck verwendet werden, aber ich möchte code der timer selbst damit kann ich mich besser integrieren es in meinem Projekte - wie beispielsweise die Möglichkeit der Rückkehr der Zeit, im Gegensatz zu pausieren, das ganze Programm.

Und ja, ich gelinkt habe es mit -lrt
Willkommen zum Programmierer. Bitte nehmen Sie sich einen Augenblick Zeit und Lesen Sie die Website FAQ wo Sie finden einige gute Informationen über die Fragen hier. Diese Frage ist wahrscheinlich besser gedient, SO wie es befasst sich mit der code-Implementierung. Bitte nicht wieder Fragen, es gibt, wie diese migriert werden können. Eine Allgemeine Regel ist, wenn Ihre Frage hat Sie vor Ihrer IDE es gehört SO. Wenn es Sie hat, vor einem whiteboard gehört es auf die Programmierer.

InformationsquelleAutor Joshun | 2012-12-16

c linux time

5

Bitte, tun Sie das nicht. Du bist burning CPU-Leistung für nichts in einem busy-loop.

Warum nicht die nanosleep() - Funktion statt? Es ist perfekt geeignet, um die use-case-Sie skizziert. Oder, wenn Sie möchten, eine einfachere Schnittstelle, vielleicht so etwas wie
```
#define _POSIX_C_SOURCE 200809L
#include <time.h>
#include <errno.h>

/* Sleep for the specified number of seconds,
 * and return the time left over.
*/
double dsleep(const double seconds)
{
    struct timespec  req, rem;

    /* No sleep? */
    if (seconds <= 0.0)
        return 0.0;

    /* Convert to seconds and nanoseconds. */
    req.tv_sec = (time_t)seconds;
    req.tv_nsec = (long)((seconds - (double)req.tv_sec) * 1000000000.0);

    /* Take care of any rounding errors. */
    if (req.tv_nsec < 0L)
        req.tv_nsec = 0L;
    else
    if (req.tv_nsec > 999999999L)
        req.tv_nsec = 999999999L;

    /* Do the nanosleep. */
    if (nanosleep(&req, &rem) != -1)
        return 0.0;

    /* Error? */
    if (errno != EINTR)
        return 0.0;

    /* Return remainder. */
    return (double)rem.tv_sec + (double)rem.tv_nsec / 1000000000.0;
}
```
Der Unterschied ist, dass mit dieser CPU frei ist, etwas anderes zu tun, als vielmehr drehen sich wie ein verrückter Eichhörnchen auf speed.
- Dank Nominal Tier, das tut was ich brauche! Glaubst du, es ist sowieso tut dies ohne anhalten der Ausführung vollständig -, so ein Programm könnte laufen weiter wie normal, und drucken Sie eine Anweisung, wenn ein timer erreicht ist
- Natürlich. Verwenden Sie einen signal-handler, der ändert z.B. eine Globale volatile sig_atomic_t variable. Erstellen Sie einen timer mit timer_create() (siehe kernel.org/doc/man-pages/online/pages/man2/timer_create.2.html), dann Bewaffnen Sie,/Entwaffnen Sie, bei Bedarf, mit timer_settime() (siehe kernel.org/doc/man-pages/online/pages/man2/timer_settime.2.html). Die Lieferung des Signals, um das signal-handler interrupt-Sperrung I/O-Funktionen, so müssen Sie behandeln -1 mit errno == EINTR von der Sperrung-Funktionen. Ich mag, um die interrupt-Wiederholung bald nach dem trigger, also glaube ich nicht, miss Veranstaltungen.
- Ich empfehle Ihnen, denken, ein gutes, einfaches Beispiel, Fall oder Programm, und buchen, die als ein neues Thema. Nur machen Sie es interessant, so dass wir nicht verpassen :).
- Ich kann nicht denken, ein Fall genau das kann aber nützlich sein, in einem text-adventure-Spiel, das ich auf Arbeit bin (wäre noch spannender, mit der Zeit!). Das sieht vielversprechend aus: library.developer.nokia.com/index.jsp?topic=/...
- Ich wirklich brauchen ein einfaches Beispiel obwohl
InformationsquelleAutor Nominal Animal

Dies ist keine Antwort, sondern ein Beispiel, wie Signale und eine POSIX-timer zu implementieren, die einen timeout-timer; soll eine Antwort auf die OP ' s Nachfolge-Frage in einem Kommentar auf die akzeptierte Antwort.

#define _POSIX_C_SOURCE 200809L
#include <stdlib.h>
#include <signal.h>
#include <time.h>
#include <errno.h>
#include <string.h>
#include <stdio.h>

/* Timeout timer.
*/
static timer_t                  timeout_timer;
static volatile sig_atomic_t    timeout_state = 0;
static volatile sig_atomic_t    timeout_armed = 2;
static const int                timeout_signo = SIGALRM;

#define TIMEDOUT() (timeout_state != 0)

/* Timeout signal handler.
*/
static void timeout_handler(int signo, siginfo_t *info, void *context __attribute__((unused)))
{
    if (timeout_armed == 1)
        if (signo == timeout_signo && info && info->si_code == SI_TIMER)
            timeout_state = ~0;
}

/* Unset timeout.
 * Returns nonzero if timeout had expired, zero otherwise.
*/
static int timeout_unset(void)
{
    struct itimerspec   t;   
    const int           retval = timeout_state;

    /* Not armed? */
    if (timeout_armed != 1)
        return retval;

    /* Disarm. */
    t.it_value.tv_sec = 0;
    t.it_value.tv_nsec = 0;
    t.it_interval.tv_sec = 0;
    t.it_interval.tv_nsec = 0;
    timer_settime(timeout_timer, 0, &t, NULL);

    return retval;
}

/* Set timeout (in wall clock seconds).
 * Cancels any pending timeouts.
*/
static int timeout_set(const double seconds)
{
    struct itimerspec  t;

    /* Uninitialized yet? */
    if (timeout_armed == 2) {
        struct sigaction    act;
        struct sigevent     evt;

        /* Use timeout_handler() for timeout_signo signal. */
        sigemptyset(&act.sa_mask);
        act.sa_sigaction = timeout_handler;
        act.sa_flags = SA_SIGINFO;

        if (sigaction(timeout_signo, &act, NULL) == -1)
            return errno;

        /* Create a monotonic timer, delivering timeout_signo signal. */
        evt.sigev_value.sival_ptr = NULL;
        evt.sigev_signo = timeout_signo;
        evt.sigev_notify = SIGEV_SIGNAL;

        if (timer_create(CLOCK_MONOTONIC, &evt, &timeout_timer) == -1)
            return errno;

        /* Timeout is initialzied but unarmed. */
        timeout_armed = 0;
    }

    /* Disarm timer, if armed. */
    if (timeout_armed == 1) {

        /* Set zero timeout, disarming the timer. */
        t.it_value.tv_sec = 0;
        t.it_value.tv_nsec = 0;
        t.it_interval.tv_sec = 0;
        t.it_interval.tv_nsec = 0;

        if (timer_settime(timeout_timer, 0, &t, NULL) == -1)
            return errno;

        timeout_armed = 0;
    }

    /* Clear timeout state. It should be safe (no pending signals). */
    timeout_state = 0;

    /* Invalid timeout? */
    if (seconds <= 0.0)
        return errno = EINVAL;

    /* Set new timeout. Check for underflow/overflow. */
    t.it_value.tv_sec = (time_t)seconds;
    t.it_value.tv_nsec = (long)((seconds - (double)t.it_value.tv_sec) * 1000000000.0);
    if (t.it_value.tv_nsec < 0L)
        t.it_value.tv_nsec = 0L;
    else
    if (t.it_value.tv_nsec > 999999999L)
        t.it_value.tv_nsec = 999999999L;

    /* Set it repeat once every millisecond, just in case the initial
     * interrupt is missed. */
    t.it_interval.tv_sec = 0;
    t.it_interval.tv_nsec = 1000000L;

    if (timer_settime(timeout_timer, 0, &t, NULL) == -1)
        return errno;

    timeout_armed = 1;

    return 0;
}


int main(void)
{
    char    *line = NULL;
    size_t   size = 0;
    ssize_t  len;

    fprintf(stderr, "Please supply input. The program will exit automatically if\n");
    fprintf(stderr, "it takes more than five seconds for the next line to arrive.\n");
    fflush(stderr);

    while (1) {

        if (timeout_set(5.0)) {
            const char *const errmsg = strerror(errno);
            fprintf(stderr, "Cannot set timeout: %s.\n", errmsg);
            return 1;
        }

        len = getline(&line, &size, stdin);
        if (len == (ssize_t)-1)
            break;

        if (len < (ssize_t)1) {
            /* This should never occur (except for -1, of course). */
            errno = EIO;
            break;
        }

        /* We do not want *output* to be interrupted,
         * so we cancel the timeout. */
        timeout_unset();

        if (fwrite(line, (size_t)len, 1, stdout) != 1) {
            fprintf(stderr, "Error writing to standard output.\n");
            fflush(stderr);
            return 1;
        }
        fflush(stdout);

        /* Next line. */
    }

    /* Remember to cancel the timeout. Also check it. */
    if (timeout_unset())
        fprintf(stderr, "Timed out.\n");
    else
    if (ferror(stdin) || !feof(stdin))
        fprintf(stderr, "Error reading standard input.\n");
    else
        fprintf(stderr, "End of input.\n");

    fflush(stderr);

    /* Free line buffer. */
    free(line);
    line = NULL;
    size = 0;

    /* Done. */
    return 0;
}

Wenn Sie speichern, wie Sie oben timer.c, können Sie es kompilieren, das beispielsweise mit

gcc -W -Wall -O3 -std=c99 -pedantic timer.c -lrt -o timer

und führen Sie es mit ./timer.

Wenn Sie Lesen Sie den code oben sorgfältig, Sie werden sehen, dass es tatsächlich eine periodische timer-Signals (in Millisekunden-Intervallen), mit einer Variablen Verzögerung, bevor das erste signal. Das ist nur eine Technik, die ich mag zu verwenden, um sicherzustellen, dass ich don ' T verpassen das signal. (Das signal wird wiederholt, bis der timeout nicht gesetzt ist.)

Beachten Sie, dass obwohl Sie tun können, Berechnung in ein signal-handler sollten nur Funktionen verwenden, die sind async-signal-safe; siehe man 7 signal. Auch, nur die sig_atomic_t Typ atomic-wrt. normale single-threaded-code und einen signal-handler. Also, es ist besser, benutzen Sie einfach das signal als Indikator, und die eigentliche code in ein eigenes Programm.

Wenn man wollte-z.B. update-monster-Koordinaten in ein signal-handler ist es möglich, aber ein bisschen tricky. Ich würde drei arrays, die die monster-Informationen, und verwenden Sie GCC __sync_bool_compare_and_swap() zur Aktualisierung der array-Zeiger-sehr viel die gleiche Technik, triple-buffering in der Grafik.

Wenn Sie mehr als eine gleichzeitige timeout, Sie könnte verwenden Sie mehrere Timer (es gibt eine Reihe davon), aber die beste option ist, um zu definieren, timeout-slots. (Man kann die generation von Zählern zu erkennen "vergessen" timeouts, und so weiter.) Wenn Sie eine neue timeout-Wert gesetzt ist oder nicht gesetzt aktualisieren Sie den timeout zu reflektieren, die nächste timeout abläuft. Es ist ein bisschen mehr code, aber wirklich eine einfache Erweiterung des oben.

Vielen Dank dafür, ich werde sehen, durch den code, und versuchen den Sinn dahinter

InformationsquelleAutor Nominal Animal

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.