seca - tos al acostarse causas

¿Hay una alternativa para dormir() en C?

Question

En la programación incrustada tradicional, le daremos una función de retardo de la siguiente manera:

for(i=0;i<255;i++)
   for(j=0;j<255;j++);

En la vista del microprocesador, ¿así es como funciona la función sleep ()?

¿Hay una alternativa para la función sleep () en C?

Answer 1

El tipo de ciclo que describes se llama "espera ocupada". En sistemas operativos reales, dormir no causa una espera ocupada; le dice al sistema operativo que no programe el proceso hasta que termine el período de espera.

Answer 2

En un sistema operativo derivado de Unix, probablemente programe una llamada a la señal (), y su código simplemente bloqueará el código hasta que se eleve la señal. Las señales están diseñadas para este propósito, y son muy simples y eficientes.

Answer 3

Encontré la función en esta publicación ( http://cboard.cprogramming.com/c-programming/111229-how-use-sleep-function.html ) y funciona:

#include <stdio.h>
#include <windows.h>

int main()
{
    puts("Hello /n");
    /* in windows.h is declared the Sleep (upper S) function and it takes time in 
miliseconds */
    Sleep(3000);
    puts("World /n");
    return 0;
}

Answer 4

Hay más información sobre cómo funciona el sueño () aquí

Por cierto, la espera ocupada no es necesariamente para aficionados, aunque graba un procesador que puede usar para otro propósito. Si está utilizando una fuente de tiempo, está limitado a la granularidad de esa fuente. Por ejemplo, si tiene un temporizador de 1 ms, y quiere recorrer 500 uS, tiene un problema. Si su sistema integrado puede manejar el hecho de que estará zumbando en un bucle para 500 uSec, eso podría ser aceptable. E incluso si tiene un temporizador con la granularidad deseada, también necesita obtener una interrupción de ese temporizador en el momento correcto ... luego envíe el controlador de interrupción ... luego obtenga su código. A veces, un bucle ocupado es la solución más conveniente. A veces.

Answer 5

La espera ocupada es para los aficionados incluso en un sistema integrado, utilice una fuente en tiempo real.

Answer 6

La página 20 de ''Enhebrado en C #'' de Joseph Albahari tiene una interesante discusión sobre esto. No puede dormir por menos de 1 ms en .Net pero DateTime.Ticks tiene una granularidad de intervalos de 100 nanosegundos (= 0.1 microsegundos). Para controlar mi stepper CNC de 5 ejes, solo necesito hacer una pausa de 10 microsegundos entre los comandos de paso. He usado un microcontrolador para hacer el asqueroso looping pero creo que está bien entregar un procesador para el trabajo si tienes un grupo completo de todos modos, detén el hilo cuando puedas. Al menos no será siempre el mismo.

Answer 7

Las alternativas dependen de lo que estás tratando de hacer y del sistema operativo en el que te encuentres.

Si solo quieres perder el tiempo, estos pueden ayudar:

En la mayoría de los sistemas de tipo Unix, encontrará una función ''usleep'', que es más o menos como dormir con mayor resolución. Tenga cuidado con eso porque generalmente no puede dormir por solo un microsegundo.

En algunos sistemas de tipo Unix, la llamada al sistema de selección se puede usar con todos los descriptores de archivos para establecer cero con el fin de obtener una espera de segundos por segundo bastante precisa.

En los sistemas Windows, tiene Sleep, que es más o menos lo mismo, pero tarda unos milisegundos.

En un sistema operativo multitarea, a veces se le puede dar a 0 una función de reposo como parámetro. Por lo general, esto hace que la función abandone su intervalo de tiempo, pero se volverá a programar inmediatamente si ninguna otra tarea está lista para ejecutarse.

Answer 8

No usaría el código que publicó para dormir en un sistema integrado. Un compilador decente lo eliminaría por completo, e incluso si su compilador no lo elimina, no es óptimo, ya que ejecutar el procesador en un ciclo cerrado quemará energía, lo cual es un problema para el sistema integrado. Incluso los sistemas que no funcionan con batería se preocupan por el uso de energía, ya que un menor consumo de energía significa un suministro de energía y refrigeración más económicos.

La forma en que normalmente lo hace es que su CPU implementará algún tipo de instrucciones IDLE o SLEEP, que provocarán que detenga temporalmente el procesamiento de comandos. Una línea de interrupción externa conectada a un circuito de temporizador reactivará el procesador a intervalos regulares, y en ese punto la CPU verifica si ha estado dormido el tiempo suficiente y, si no, vuelve a dormirse.

//Pseudo code
int start = getTime();
int end = start + sleepTime;

while (getTime() < end) {
       asm("SLEEP");
}

Los detalles exactos varían de procesador a procesador. Si se está ejecutando como un proceso en un SO, la llamada de espera generalmente solo le dice al planificador que suspenda su proceso, y luego el núcleo decide si programar otro proceso o dormir la CPU. Además, el código anterior no será apropiado para sistemas en tiempo real, que quieran garantías de fecha límite, etc. En esos casos, necesitará obtener el tiempo en el ciclo, saber la duración de la interrupción del tiempo para saber si puede dormir sin volando la fecha límite, y posiblemente reprogramar el hardware del temporizador o la espera ocupada.

Answer 9

Si está utilizando for-loops, será mejor que comprenda a qué compilan y cuánto tiempo tardan esas instrucciones a la velocidad de reloj dada, y asegúrese de que la CPU ejecuta sus instrucciones y nada más (esto se puede hacer en sistemas integrados pero es complicado porque no permite interrupciones).

De lo contrario, no podrá decir cuánto tiempo realmente tomará.

Los primeros juegos de PC tenían este problema: estaban diseñados para una PC de 4.7MHz y, cuando aparecían las computadoras más veloces, no se podían jugar.

La mejor manera de que un ''sueño'' funcione es que la CPU sepa qué hora es en cualquier punto dado. No necesariamente el tiempo real (7:15 a.m.), pero al menos el tiempo relativo (8612 segundos desde algún punto en el tiempo).

De esta forma, puede aplicar un delta a la hora actual y esperar en un bucle hasta alcanzar el + delta actual.

Cualquier cosa que dependa de un número de ciclos de CPU es intrínsecamente poco confiable ya que la CPU puede pasar a otra tarea y dejar el ciclo colgando.

Digamos que tiene un puerto de E / S de 16 bits mapeado en memoria que la CPU incrementa una vez por segundo. Supongamos también que está en la ubicación de memoria 0x33 en su sistema integrado, donde las entradas también son de 16 bits. Una función llamada dormir se convierte en algo así como:

void sleep (unsigned int delay) {
    unsigned int target = peek(0x33) + delay;
    while (peek(0x33) != target);
}

Tendrá que asegurarse de que peek () devuelva el contenido de la memoria todo el tiempo (para optimizar los compiladores no arruine la lógica) y que su sentencia while se ejecute más de una vez por segundo para que no pierda el objetivo, pero estos son cuestiones operacionales que no afectan el concepto que estoy presentando.

Answer 10

Un mecanismo común es usar un select() que garantiza que se agote el tiempo de espera, y especifique el tiempo de espera como el tiempo de espera:

// Sleep for 1.5 sec
struct timeval tv;
tv.tv_sec = 1;
tv.tv_usec = 500000;
select(0, NULL, NULL, NULL, &tv);

El select() se usa generalmente para verificar un conjunto de descriptores de archivos y esperar hasta que al menos uno esté listo para realizar E / S. Si ninguno está listo (o, en este caso, si no se especifica ningún fds), se agotará el tiempo de espera.

La ventaja de select() en un bucle ocupado es que consume muy pocos recursos mientras duerme, mientras que un bucle ocupado monopoliza el procesador tanto como lo permite su nivel de prioridad.

Answer 11

Usted habla sobre "programación integrada" en el OP. Si está realizando un trabajo incrustado y necesita algo como sleep (), a menudo hay contadores de hardware / temporizadores disponibles. Esto variará de arquitectura a arquitectura, así que eche un vistazo a la hoja de datos.

Si no estás haciendo un trabajo integrado, me disculpo :)

Answer 12

cualquier compilador de C decente, sin trabajo extra, eliminaría el código por completo y la demora desaparecería

Answer 13

disponible en linux usleep (int microsegundos) nanosleep (...) más precisión ver páginas de manual para argumentos de llamadas

Answer 14

sleep realmente interactúa con el sistema operativo, donde los procesos de suspensión se colocan fuera de la cola de programación. Usualmente uso:

poll(0, 0, milliseconds);

para sistemas compatibles con POSIX. select también funciona para Windows (deben tener una API nativa (probablemente llamada Sleep ) para eso).

Answer 15

un intento ... de resolver realmente este problema, es decir, algo que funciona (no como los intentos anteriores de respuesta) lol

Todavía tengo que mejorar este código para hacerlo. Pocos complementos son bienvenidos.

// Sleep for both Windows and Linux: 
// Too bad? No one proposed you a solution that works? 
// Since Windows has no select.h nor poll.h, an implementation
// is necessary.
//  
// Solutions on boards are often refered to use either select or poll, but ok, what about C (not c++)?
//
/// implementation of poll is destined in this attempt for windows
/// Ideally, you add this part of code to the header of you *.c file, and it might work through...

#ifdef WIN32
#include <time.h>
#include <sys/time.h>
#include <ws2tcpip.h>
#include <Winsock2.h>
#include <windows.h>
/* winsock doesn''t feature poll(), so there is a version implemented
 * in terms of select() in mingw.c. The following definitions
 * are copied from linux man pages. A poll() macro is defined to
 * call the version in mingw.c.
 */
#define POLLIN      0x0001    /* There is data to read */
#define POLLPRI     0x0002    /* There is urgent data to read */
#define POLLOUT     0x0004    /* Writing now will not block */
#define POLLERR     0x0008    /* Error condition */
#define POLLHUP     0x0010    /* Hung up */
#define POLLNVAL    0x0020    /* Invalid request: fd not open */
struct pollfd {
  SOCKET fd;        /* file descriptor */
  short events;     /* requested events */
  short revents;    /* returned events */
};

int mingw_poll (struct pollfd *, unsigned int, int);

#define poll(x, y, z)        mingw_poll(x, y, z)
#endif





int mingw_poll(struct pollfd *fds, unsigned int nfds, int timo)
{
    struct timeval timeout, *toptr;
    fd_set ifds, ofds, efds, *ip, *op;
    int i, rc;

    /* Set up the file-descriptor sets in ifds, ofds and efds. */
    FD_ZERO(&ifds);
    FD_ZERO(&ofds);
    FD_ZERO(&efds);
    for (i = 0, op = ip = 0; i < nfds; ++i) {
    fds[i].revents = 0;
    if(fds[i].events & (POLLIN|POLLPRI)) {
        ip = &ifds;
        FD_SET(fds[i].fd, ip);
    }
    if(fds[i].events & POLLOUT) {
        op = &ofds;
        FD_SET(fds[i].fd, op);
    }
    FD_SET(fds[i].fd, &efds);
    } 

    /* Set up the timeval structure for the timeout parameter */
    if(timo < 0) {
    toptr = 0;
    } else {
    toptr = &timeout;
    timeout.tv_sec = timo / 1000;
    timeout.tv_usec = (timo - timeout.tv_sec * 1000) * 1000;
    }

#ifdef DEBUG_POLL
    printf("Entering select() sec=%ld usec=%ld ip=%lx op=%lx/n",
           (long)timeout.tv_sec, (long)timeout.tv_usec, (long)ip, (long)op);
#endif
    rc = select(0, ip, op, &efds, toptr);
#ifdef DEBUG_POLL
    printf("Exiting select rc=%d/n", rc);
#endif

    if(rc <= 0)
    return rc;

    if(rc > 0) {
        for (i = 0; i < nfds; ++i) {
            int fd = fds[i].fd;
        if(fds[i].events & (POLLIN|POLLPRI) && FD_ISSET(fd, &ifds))
            fds[i].revents |= POLLIN;
        if(fds[i].events & POLLOUT && FD_ISSET(fd, &ofds))
            fds[i].revents |= POLLOUT;
        if(FD_ISSET(fd, &efds))
            /* Some error was detected ... should be some way to know. */
            fds[i].revents |= POLLHUP;
#ifdef DEBUG_POLL
        printf("%d %d %d revent = %x/n", 
                FD_ISSET(fd, &ifds), FD_ISSET(fd, &ofds), FD_ISSET(fd, &efds), 
                fds[i].revents
        );
#endif
        }
    }
    return rc;
}

Answer 16

#include <Windows.h>

static NTSTATUS(__stdcall *NtDelayExecution)(BOOL Alertable, PLARGE_INTEGER DelayInterval) = (NTSTATUS(__stdcall*)(BOOL, PLARGE_INTEGER)) GetProcAddress(GetModuleHandle("ntdll.dll"), "NtDelayExecution");

static NTSTATUS(__stdcall *ZwSetTimerResolution)(IN ULONG RequestedResolution, IN BOOLEAN Set, OUT PULONG ActualResolution) = (NTSTATUS(__stdcall*)(ULONG, BOOLEAN, PULONG)) GetProcAddress(GetModuleHandle("ntdll.dll"), "ZwSetTimerResolution");




static void SleepShort(float milliseconds) {
    static bool once = true;
    if (once) {
        ULONG actualResolution;
        ZwSetTimerResolution(1, true, &actualResolution);
        once = false;
    }

    LARGE_INTEGER interval;
    interval.QuadPart = -1 * (int)(milliseconds * 10000.0f);
    NtDelayExecution(false, &interval);
}

Sí, utiliza algunas funciones del kernel no documentadas, pero, sinceramente, es mucho más rápido que la mayoría de las sugerencias y funciona muy bien (tenga en cuenta que se limitará a la cantidad de CPU, por ejemplo, la mía solo puede dormir 500 nanosegundos (0.5))