A MS define INVALID_HANDLE_VALUEo seguinte (Windows SDK, handleapi.h):
#define INVALID_HANDLE_VALUE ((HANDLE)(LONG_PTR)-1)
Por que eles fazem isso com uma conversão dupla - primeiro para LONG_PTR(alias __int64alias long longem 64 bits ou longem 32 bits) e segundo HANDLE(alias void*), por que não apenas:
#define INVALID_HANDLE_VALUE ((HANDLE)-1)
Eu assumo um significado, mas não o vejo.
cppreference em relaçãostd::atomic<T>::wait a:
void wait( T old, std::memory_order order = std::memory_order::seq_cst ) const noexcept;Executa operações de espera atômica. Comporta-se como se executasse repetidamente os seguintes passos:
- Compare a representação de valor de this->load(order) com a de old. Se forem iguais, então bloqueia até que *this seja notificado por notify_one() ou notify_all(), ou o thread seja desbloqueado espuriosamente .
- Caso contrário, retorna.
Essas funções têm garantia de retornar somente se o valor tiver sido alterado, mesmo que a implementação subjacente desbloqueie falsamente .
Estou confuso. Preciso me preocupar com ativações espúrias (o que significa que
wait()podem retornar mesmo que o valor esteja parado old) ou não?
Quero esperar uma vez pelos resultados de vários outros threads. A std::latchseria uma construção adequada - a de espera usa wait()o produtor count_down(), mas quero poder definir um tempo limite, então preciso da funcionalidade wait_for . Infelizmente std::latchnão tem wait_for . Bem std::semaphore, tem, mas geralmente std::semaphoreé usado em lógica inversa. Seria adequado se eu pudesse usar um valor de inicialização negativo, mas mesmo que seja um tipo assinado ( ptrdiff_t) não é permitido - pré-condição: desejado >= 0.
std::atomic wait()- poderia resolver todas as tarefas de sincronização, mas... sem wait_for . Parece que preciso construir meu próprio latch com std::condition_variable e std::mutex.
Mas eu gostaria de entender por que algumas construções oferecem funcionalidade de tempo limite (semáforo, mutex, condicional) e outras (trava, barreira, espera atômica) não - há uma razão ou é só porque sim?
Editar Parece que não sou o único que gosta de ter operações temporizadas em atomics: APIs de espera temporizada (try_wait, wait_for e wait_until) para std::atomic são propostas em P2643, visando C++26. ( stack overflow / C++20: Como esperar por um objeto atômico com tempo limite?
O uso interprocessual (memória compartilhada) de atomic-wait seria um sonho real ;-)
clock_gettime(clockid_t clockid, struct timespec *tp);
clockid CLOCK_REALTIME_COARSE: Uma versão mais rápida, mas menos precisa de CLOCK_REALTIME. Este relógio não é configurável . ...
Mas se eu ajustar, CLOCK_REALTIMEele CLOCK_REALTIME_COARSEadota essas mudanças? Quero dizer, ele ainda é um relógio em tempo real (tempo de parede) - apenas mais rápido (vdso) em detrimento da precisão, não é?