Есть ли альтернатива sleep () в C?

вид цикла, который вы описываете, называется "занятое ожидание". В реальных операционных системах сон не вызывает напряженного ожидания; он говорит операционной системе не планировать процесс, пока не закончится период сна.

один общий механизм использовать select() это гарантированно тайм-аут, и укажите время сна в качестве тайм-аута:

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

на select() обычно используется для проверки набора файловых дескрипторов и ожидания, пока хотя бы один из них не будет готов к выполнению ввода-вывода.Если ни один из них не готов (или, в данном случае, если fds не указан), время ожидания истекает.

преимущество select() по циклу занятости является то, что он потребляет очень мало ресурсов во время сна, в то время как цикл занятости монополизирует процессор настолько, насколько это разрешено его уровнем приоритета.

вы не будете использовать опубликованный код для сна во встроенной системе. Приличный компилятор полностью удалит его, и даже если ваш компилятор не удалит его, это неоптимально, так как запуск процессора в узком цикле будет сжигать энергию, что является проблемой для встроенной системы. Даже системы, не работающие от батареи, заботятся об использовании энергии, поскольку более низкое энергопотребление означает более дешевые источники питания и охлаждение.

Как вы обычно это делаете, ваш процессор будет реализовывать какой-то Инструкции IDLE или SLEEP, которые заставят его временно остановить обработку команд. Внешняя линия прерывания, подключенная к схеме таймера, будет будить процессор через регулярные промежутки времени, и в какой момент процессор проверяет, достаточно ли он спал, а если нет, он снова засыпает.

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

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

точные детали варьируются от процессора к процессору. Если вы работаете как процесс в ОС, вызов сна обычно просто сообщает планировщику приостановить процесс, а затем ядро решает, планировать ли другой процесс или спать CPU. Кроме того, вышеуказанный код не будет адекватным для систем реального времени, которые хотят гарантий крайнего срока и т. д. В этих случаях вам нужно будет получить время в цикле, знать продолжительность прерывания времени, чтобы вы знали, можете ли вы переспать, не дуя крайний срок, и потенциально перепрограммировать оборудование таймера или занятое ожидание.

вы говорите о "встроенном программировании" в OP. Если вы выполняете встроенную работу и вам нужно что-то вроде sleep(), часто доступны аппаратные счетчики/таймеры. Это будет варьироваться от архитектуры к архитектуре, поэтому посмотрите на таблицу данных.

Если вы не делаете встроенную работу, я извиняюсь:)

Если вы используете for-loops, вам лучше знать, что они компилируют и как долго эти инструкции занимают при заданной тактовой частоте,и убедитесь, что CPU выполняет ваши инструкции и ничего больше (это можно сделать во встроенных системах, но это сложно, так как он запрещает прерывания).

в противном случае вы не сможете сказать, сколько времени это действительно займет.

ранние компьютерные игры имели эту проблему - они были построены для ПК 4.7 MHz и, когда быстрее появились компьютеры, их нельзя было воспроизводить.

лучший способ "сна"может работать для процессора, чтобы знать, какое время это в любой момент. Не обязательно фактическое время (7:15 am), но, по крайней мере, относительное время (8612 секунд с некоторого момента времени).

таким образом, он может применить дельту к текущему времени и ждать в цикле, пока не будет достигнута текущая+Дельта.

все, что зависит от количества циклов процессора, по своей сути ненадежно, поскольку процессор может отключиться еще одно задание и оставь петлю висеть.

предположим, у вас есть 16-разрядный порт ввода-вывода с отображением памяти, который CPU увеличивает раз в секунду. Предположим также, что он находится в памяти 0x33 в вашей встроенной системе, где ints также 16 бит. Функция, называемая сном, становится чем-то вроде:

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

вам нужно будет убедиться, что peek() возвращает содержимое памяти каждый раз (так что оптимизирующие компиляторы не испортят логику) и что ваш оператор while работает больше не один раз в секунду, чтобы не пропустить цель, но это оперативные вопросы, которые не влияют на концепцию, которую я представляю.

есть больше информации о том, как sleep () работает здесь

кстати, занятое ожидание не обязательно для любителей-хотя он сжигает процессор, который вы можете использовать для какой-то другой цели. Если вы используете Источник времени, вы ограничены гранулярностью этого источника. Например, если у вас есть таймер 1 мс, и вы хотите, чтобы путь 500 нас, у вас есть проблема. Если ваша встроенная система может справиться с тем, что вы будете жужжать в цикле для 500 uSec, это может быть допустимый. И даже если у вас есть таймер с желаемой детализацией, вам также нужно прервать этот таймер в нужное время...затем отправьте обработчик прерываний...затем получить код. Иногда цикл занятости является наиболее целесообразным решением. иногда.

занят-ожидание для любителей даже во встроенной системе, используйте источник Реального времени.

любой приличный компилятор C без дополнительной работы полностью удалит ваш код, и задержка исчезнет

sleep фактически взаимодействует с операционной системой, где спящие процессы размещаются вне очереди планирования. Я обычно использую:

poll(0, 0, milliseconds);

для систем, совместимых с POSIX. select также работает для windows (они должны иметь собственный API (возможно, называемый Sleep) для этого.)

Страница 20 в "Threading in C#" Джозефа Албахари имеет интересное обсуждение этого. Вы не можете спать менее 1 мс в .Net, но DateTime.Тики имеют зернистость интервалов 100 наносекунд (= 0,1 микросекунды). Для управления моим 5 axis CNC stepper мне нужно всего лишь сделать паузу в течение 10 микросекунд между шаговыми командами. Я использовал микроконтроллер для выполнения неприятного цикла, но я думаю, что это нормально, передайте процессор для работы, если у вас есть целая куча в любом случае, остановите поток, когда вы можете. По крайней мере, не всегда одно и то же.

#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);
}

Да, он использует некоторые недокументированные функции ядра, но, честно говоря, он намного быстрее, чем большинство предложений, и работает очень хорошо (обратите внимание, что он будет ограничен количеством процессора, например, мой может спать только 500 наносекунд (0.5))

доступно в linux usleep (int микросекунды ) nanosleep( ... ) больше точности см. man-страницы для вызова аргументов

в Unix-производной ОС вы, вероятно, запланируете вызов signal (), и ваш код просто заблокирует код, пока сигнал не будет поднят. Сигналы предназначены для этой цели, и они очень просты и эффективны.

попытка... чтобы действительно решить эту проблему, т. е. что-то, что работает (не так, как вышеупомянутые попытки ответа) lol

Мне все еще нужно улучшить этот код, чтобы сделать это. Несколько дополнений приветствуются.

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

Я нашел функцию в этом сообщении (http://cboard.cprogramming.com/c-programming/111229-how-use-sleep-function.html) и это работает:

#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;
}