Cobalt/Clocks and timers

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

int main() {
    // 定义一个 timespec 结构体变量，用于存储时钟的分辨率
    struct timespec res;
    
    // 定义一个时钟ID，例如 CLOCK_REALTIME
    clockid_t clock_id = CLOCK_REALTIME;
    
    // 调用 clock_getres() 函数获取时钟的分辨率
    // 如果成功，返回 0；如果失败，返回 -1
    if (clock_getres(clock_id, &res) == -1) {
        perror("clock_getres");
        return 1;
    }
    
    // 打印时钟的分辨率，转换为秒和纳秒
    printf("Resolution of clock %d: %ld seconds and %ld nanoseconds\n", clock_id, res.tv_sec, res.tv_nsec);
    
    return 0;
}

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

int main() {
    // 定义一个 timespec 结构体变量，用于存储时钟的当前值
    struct timespec tp;

    // 定义一个时钟ID，例如 CLOCK_REALTIME
    clockid_t clock_id = CLOCK_REALTIME;

    // 调用 clock_gettime() 函数获取时钟的当前值
    // 如果成功，返回 0；如果失败，返回 -1
    if (clock_gettime(clock_id, &tp) == -1) {
        perror("clock_gettime");
        return 1;
    }

    // 打印时钟的当前值，转换为秒和纳秒
    printf("Current time for clock %d: %ld seconds and %ld nanoseconds since the Epoch\n", clock_id, (long)tp.tv_sec, tp.tv_nsec);

    return 0;
}

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

int main() {
    // 定义一个 timespec 结构体，用于存储睡眠时间
    struct timespec req, rem;

    // 设置需要休眠的时间（秒和纳秒）
    req.tv_sec = 2;      // 休眠2秒
    req.tv_nsec = 0;     // 0纳秒

    // 打印开始休眠的时间
    printf("Going to sleep for %ld seconds and %ld nanoseconds\n", req.tv_sec, req.tv_nsec);

    int res = clock_nanosleep(CLOCK_REALTIME, 0, &req, NULL);

    // 检查函数调用是否成功
    if (res == 0) {
        printf("Woke up after sleeping\n");
    } else {
        fprintf(stderr, "clock_nanosleep failed: %s\n", strerror(errno));
    }

    return 0;
}

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

int main() {
    // 定义一个 timespec 结构体变量，用于存储要设置的时钟值
    struct timespec ts;

    // 获取当前时间作为示例
    if (clock_gettime(CLOCK_REALTIME, &ts) == -1) {
        perror("clock_gettime");
        return 1;
    }

    // 将当前时间增加 5 秒作为示例
    ts.tv_sec += 5;

    // 定义一个时钟ID，例如 CLOCK_REALTIME
    clockid_t clock_id = CLOCK_REALTIME;

    // 调用 clock_settime() 函数设置时钟的当前值
    // 如果成功，返回 0；如果失败，返回 -1
    if (clock_settime(clock_id, &ts) == -1) {
        perror("clock_settime");
        if (errno == EPERM) {
            printf("This program needs superuser privileges to set the system clock.\n");
        }
        return 1;
    }

    printf("System clock has been set to: %ld seconds since the Epoch\n", (long)ts.tv_sec);

    return 0;
}

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

int main() {
    // 定义一个 timespec 结构体变量，用于存储暂停的时间长度
    struct timespec req, rem;

    // 设置请求的暂停时间为 2 秒和 500 毫秒（500000 纳秒）
    req.tv_sec = 2; // 2 秒
    req.tv_nsec = 500000000; // 500 毫秒转换为纳秒

    // 打印暂停前的时间
    printf("Thread is going to sleep for %ld seconds and %ld nanoseconds.\n", req.tv_sec, req.tv_nsec);

    // 调用 nanosleep() 函数使线程暂停
    // 如果成功，返回 0；如果被信号打断，返回 -1 并将剩余时间存储在 rem 中
    if (nanosleep(&req, &rem) == -1) {
        perror("nanosleep");
        printf("Remaining time: %ld seconds and %ld nanoseconds.\n", rem.tv_sec, rem.tv_nsec);
    }

    // 打印暂停后的时间
    printf("Thread woke up.\n");

    return 0;
}

#include <stdio.h>
#include <time.h>
#include <signal.h>
#include <stdlib.h>
#include <unistd.h>

// 定时器到期时调用的信号处理函数
void timer_handler(int sv) {
    printf("Timer expired\n");
}

int main() {
    // 定义定时器 ID
    timer_t timerid;

    // 定义定时器的超时时间
    struct itimerspec ts;
    ts.it_interval.tv_sec = 5; // 5 秒
    ts.it_interval.tv_nsec = 0; // 0 纳秒
    ts.it_value.tv_sec = 2;  
    ts.it_value.tv_nsec = 0; 

    // 定义定时器的信号处理函数参数
    struct sigevent evp;
    evp.sigev_value.sival_ptr = &timerid;  
    evp.sigev_notify = SIGEV_SIGNAL;  
    evp.sigev_signo = SIGUSR1;  
    signal(SIGUSR1, timer_handler);  

    // 创建定时器
    if (timer_create(CLOCK_REALTIME, &evp, &timerid) == -1) {
        perror("timer_create");
        return 1;
    }

    // 设置定时器到期时间为 5 秒后
    if (timer_settime(timerid, 0, &ts, NULL) == -1) {
        perror("timer_settime");
        timer_delete(timerid); // 删除定时器以释放资源
        return 1;
    }

    printf("Timer created, waiting for it to expire...\n");

    // 等待定时器到期
    pause(); // 暂停进程，直到捕获信号

    // 删除定时器
    if (timer_delete(timerid) == -1) {
        perror("timer_delete");
        return 1;
    }

    printf("Timer deleted\n");

    return 0;
}

#include <signal.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <unistd.h>

#define CLOCKID CLOCK_REALTIME
#define SIG SIGRTMIN

#define errExit(msg)    do { perror(msg); exit(EXIT_FAILURE); \
                        } while (0)

static void
print_siginfo(siginfo_t *si)
{
    int      or;
    timer_t  *tidp;

    tidp = si->si_value.sival_ptr;

    printf("    sival_ptr = %p; ", si->si_value.sival_ptr);
    printf("    *sival_ptr = %#jx\n", (uintmax_t) *tidp);

    or = timer_getoverrun(*tidp);
    if (or == -1)
        errExit("timer_getoverrun");
    else
        printf("    overrun count = %d\n", or);
}

static void
handler(int sig, siginfo_t *si, void *uc)
{
    printf("Caught signal %d\n", sig);
    print_siginfo(si);
    signal(sig, SIG_IGN);
}

int
main()
{
    timer_t            timerid;
    sigset_t           mask;
    long long          freq_nanosecs;
    struct sigevent    sev;
    struct sigaction   sa;
    struct itimerspec  its;
    // 创建定时器处理程序
    printf("Establishing handler for signal %d\n", SIG);
    sa.sa_flags = SA_SIGINFO;
    sa.sa_sigaction = handler;
    sigemptyset(&sa.sa_mask);
    if (sigaction(SIG, &sa, NULL) == -1)
        errExit("sigaction");

    /* 暂时阻断定时器信号，用于触发overrun. */
    printf("Blocking signal %d\n", SIG);
    sigemptyset(&mask);
    sigaddset(&mask, SIG);
    if (sigprocmask(SIG_SETMASK, &mask, NULL) == -1)
        errExit("sigprocmask");

    // 创建定时器
    sev.sigev_notify = SIGEV_SIGNAL;
    sev.sigev_signo = SIG;
    sev.sigev_value.sival_ptr = &timerid;
    if (timer_create(CLOCKID, &sev, &timerid) == -1)
        errExit("timer_create");

    printf("timer ID is %#jx\n", (uintmax_t) timerid);

    // 启动定时器，100ms触发一次
    freq_nanosecs = 100*1000*1000;
    its.it_value.tv_sec = freq_nanosecs / 1000000000;
    its.it_value.tv_nsec = freq_nanosecs % 1000000000;
    its.it_interval.tv_sec = its.it_value.tv_sec;
    its.it_interval.tv_nsec = its.it_value.tv_nsec;

    if (timer_settime(timerid, 0, &its, NULL) == -1)
        errExit("timer_settime");

 
    // 停止1s，用于触发overrun
    printf("Sleeping for 1 seconds\n");
    sleep(1);

    // 释放定时器信号，触发定时器函数
    printf("Unblocking signal %d\n", SIG);
    if (sigprocmask(SIG_UNBLOCK, &mask, NULL) == -1)
        errExit("sigprocmask");

    exit(EXIT_SUCCESS);
}