Cómo usar nanosleep() en C? ¿Qué son `tim.tv_sec` y` tim.tv_nsec`?

¿Cuál es el uso de tim.tv_sec y tim.tv_nsec en lo siguiente?Cómo usar nanosleep() en C? ¿Qué son `tim.tv_sec` y` tim.tv_nsec`?

¿Cómo puedo suspender la ejecución de 500000 microsegundos?

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

int main() 
{ 
    struct timespec tim, tim2; 
    tim.tv_sec = 1; 
    tim.tv_nsec = 500; 

    if(nanosleep(&tim , &tim2) < 0) 
    { 
     printf("Nano sleep system call failed \n"); 
     return -1; 
    } 

    printf("Nano sleep successfull \n"); 

    return 0; 
}

Fuente

2011-10-07 pnizzle

Medio segundo es 500.000.000 nanosegundos, por lo que su código debe decir:

tim.tv_sec = 0; 
tim.tv_nsec = 500000000L;

Tal como están las cosas, que el código está durmiendo para 1.0000005s (1s + 500 ns).

Fuente

2011-10-07 07:44:07 NPE

genial. Solo una pregunta mas. Estoy probando esto usando gettimeofday() dos veces y obteniendo la diferencia. Por lo tanto, obtuve una diferencia de medio segundo. Pero también hubo una fracción muy pequeña de un segundo, debido al tiempo de procesamiento de la CPU. ¿Cómo puedo calcular esto y restarlo del tiempo de mi sueño? mi tiempo fue como: 0.501033 seg – pnizzle

@pnizzle: ¿Qué es exactamente lo que espera lograr con esa resta? – NPE

espero alcanzar exactamente 0.500000secs. Gracias – pnizzle

500000 microsegundos son 500000000 nanosegundos. Solo esperas 500 ns = 0.5 μs.

Fuente

2011-10-07 07:43:04 glglgl

gracias, trabaja ahora! – pnizzle

tv_nsec es el tiempo de suspensión en nanosegundos. 500000us = 500000000ns, por lo que desea:

nanosleep((const struct timespec[]){{0, 500000000L}}, NULL);

Fuente

2011-10-07 07:45:41 Dave

acaba de probarlo, duerme por medio segundo Gracias – pnizzle

¿Para qué sirve 'L' al final de '500000000L'? – Sahand

Esto se relaciona con el doble largo. como el segundo argumento de nanosleep() tiene doble tipo largo. ver https://stackoverflow.com/questions/1380653/why-do-you-need-to-append-an-l-or-f-after-a-value-assigned-to-ac-c-concontent – EsmaeelE

normalmente utilizo algunos #define y constantes para hacer el cálculo fácil:

#define NANO_SECOND_MULTIPLIER 1000000 // 1 millisecond = 1,000,000 Nanoseconds 
const long INTERVAL_MS = 500 * NANO_SECOND_MULTIPLIER;

De ahí que mi código se vería así:

timespec sleepValue = {0}; 

sleepValue.tv_nsec = INTERVAL_MS; 
nanosleep(&sleepValue, NULL);

Fuente

2013-08-10 06:04:29

Esto funcionó para mí ....

#include <stdio.h> 
#include <time.h> /* Needed for struct timespec */ 


int nsleep(long miliseconds) 
{ 
    struct timespec req, rem; 

    if(miliseconds > 999) 
    { 
     req.tv_sec = (int)(miliseconds/1000);       /* Must be Non-Negative */ 
     req.tv_nsec = (miliseconds - ((long)req.tv_sec * 1000)) * 1000000; /* Must be in range of 0 to 999999999 */ 
    } 
    else 
    { 
     req.tv_sec = 0;       /* Must be Non-Negative */ 
     req.tv_nsec = miliseconds * 1000000; /* Must be in range of 0 to 999999999 */ 
    } 

    return nanosleep(&req , &rem); 
} 

int main() 
{ 
    int ret = nsleep(2500); 
    printf("sleep result %d\n",ret); 
    return 0; 
}

Fuente

2015-10-29 11:26:58

POSIX 7

En primer lugar encontramos la función: http://pubs.opengroup.org/onlinepubs/9699919799/functions/nanosleep.html

que contiene un enlace a un time.h, que como cabecera debe ser el que se definen estructuras:

La cabecera declarará la timespec estructura, que incluirá al menos los siguientes miembros:

time_t tv_sec Seconds. 
long tv_nsec Nanoseconds.

hombre 2 nanosleep

docs glibc pseudo-oficial en el que siempre se debe comprobar si hay llamadas al sistema:

struct timespec { 
    time_t tv_sec;  /* seconds */ 
    long tv_nsec;  /* nanoseconds */ 
};

Fuente

2015-11-10 21:12:11

Cómo usar nanosleep() en C? ¿Qué son `tim.tv_sec` y` tim.tv_nsec`?

Respuesta

Cuestiones relacionadas