OSTEP Homework Measurement 1: 测量 System Call 和 Context Switch 的开销

/* Get the current time of day, putting it into *TV.
   If TZ is not null, *TZ must be a struct timezone, and both fields
   will be set to zero.
   Calling this function with a non-null TZ is obsolete;
   use localtime etc. instead.
   This function itself is semi-obsolete;
   most callers should use time or clock_gettime instead. */
#ifndef __USE_TIME_BITS64
extern int gettimeofday (struct timeval *__restrict __tv, void *__restrict __tz) __THROW __nonnull ((1));
#else
# ifdef __REDIRECT_NTH
extern int __REDIRECT_NTH (gettimeofday, (struct timeval *__restrict __tv,
                                          void *__restrict __tz),
                           __gettimeofday64) __nonnull ((1));
# else
#  define gettimeofday __gettimeofday64
# endif
#endif

/* A time value that is accurate to the nearest
   microsecond but also has a range of years.  */
struct timeval
{
    #ifdef __USE_TIME_BITS64
    __time64_t tv_sec;          /* Seconds.  */
    __suseconds64_t tv_usec;    /* Microseconds.  */
    #else
    __time_t tv_sec;            /* Seconds.  */
    __suseconds_t tv_usec;      /* Microseconds.  */
    #endif
};
#endif

#include <sys/time.h>   // 提供 gettimeofday
#include <stdio.h>      // 提供 printf

int main(void) {
    struct timeval val;
    int ret = gettimeofday(&val, NULL); // 
    if (ret == -1) {
        printf("Error: gettimeofday()\n");
        return ret;
    }
    printf("sec: %ld, usec: %ld\n", val.tv_sec, val.tv_usec);
    return 0;
}

#include <sys/time.h>   // 提供 gettimeofday
#include <stdio.h>      // 提供 printf

int main(void) {
    struct timeval prev, now;
    gettimeofday(&prev,NULL);
    while (1) {
        gettimeofday(&now,NULL);
        long diff =
            (now.tv_sec-prev.tv_sec)*1000000
            +(now.tv_usec-prev.tv_usec);
        if (diff != 0) {
            printf("%ld us\n", diff);
            break;
        }
        prev=now;
    }
}

#include <sys/time.h> // 提供 gettimeofday
#include <stdio.h>    // 提供 printf

int main()
{
    struct timeval start, end;
    int interval[20];
    int top = 0;
    for (int i = 0; i < 500; i++)
    {
        gettimeofday(&start, NULL);
        gettimeofday(&end, NULL);
        long diff =
            (end.tv_sec - start.tv_sec) * 1000000 + (end.tv_usec - start.tv_usec);
        if (diff)
            interval[top++] = i;
    }
    for (int i = 0; i < top; i++)
        printf("%d ", interval[i]);
    printf("\n");
    return 0;
}

start = rdtsc();
operation();
end = rdtsc();
cycles = end - start;

#include <stdio.h>
#include <stdint.h>
static inline uint64_t rdtsc() {
    unsigned int lo, hi;
    __asm__ volatile(
        "rdtsc"
        : "=a"(lo), "=d"(hi)
    );
    return ((uint64_t)hi << 32) | lo;
}

int main() {
    uint64_t start, end;
    start = rdtsc();
    for (int i = 0; i < 1000; i++) {
        ;
    }
    end = rdtsc();
    printf("cycles: %lu\n", end-start);
    return 0;
}

#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/time.h>

int main() {
    int N = 10000000;
    int fd = open("/dev/null", O_RDONLY); // null device, open read only
    char buf;
    struct timeval start, end;
    volatile ssize_t ret;
    gettimeofday(&start, NULL);
    for (int i = 0; i < N; i++) {
        ret = read(fd, &buf, 0); // read 0 byte
    }
    gettimeofday(&end, NULL);

    long time =
        (end.tv_sec - start.tv_sec) * 1000000 + (end.tv_usec - start.tv_usec);

    printf("total: %ld us\n", time);
    printf("per syscall: %.3f us\n",
           (double)time / N);
    return ret;
}

#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/time.h>

int main() {
    int N = 10000000;
    struct timeval start, end;
    volatile pid_t ret;

    gettimeofday(&start, NULL);
    for (int i = 0; i < N; i++) {
        ret = getpid();
    }
    gettimeofday(&end, NULL);

    long time =
        (end.tv_sec - start.tv_sec) * 1000000 + (end.tv_usec - start.tv_usec);
    printf("pid: %d\n", ret);
    printf("total: %ld us\n", time);
    printf("per syscall: %.3f us\n",
           (double)time / N);
    return 0;
}

// Function prototype
int sched_setaffinity(
    pid_t pid,
    size_t cpusetsize,
    const cpu_set_t *mask
);

#define _GNU_SOURCE
#include <sched.h>
#include <stdio.h>
#include <unistd.h>
#include <sys/time.h>
#include <stdlib.h>

#define ITERATIONS 1000000

void bind_cpu() {
    cpu_set_t set;
    CPU_ZERO(&set);     // 清空 CPU mask
    CPU_SET(0, &set);   // 添加 CPU0
    if (sched_setaffinity(  // 当前程序只能运行在 CPU0 上
            0,
            sizeof(set),
            &set) == -1) {
        perror("sched_setaffinity");
        exit(1);
    }
}

int main() {
    int pipe1[2];
    int pipe2[2];
    pipe(pipe1);
    pipe(pipe2);
    bind_cpu();

    pid_t pid = fork();
    char buf = 'a';

    if (pid == 0) {
        // child
        bind_cpu();
        for (int i = 0; i < ITERATIONS; i++) {
            read(pipe1[0], &buf, 1);
            write(pipe2[1], &buf, 1);
        }
    }
    else {
        // parent
        struct timeval start, end;
        gettimeofday(&start, NULL);
        for (int i = 0; i < ITERATIONS; i++) {
            write(pipe1[1], &buf, 1);
            read(pipe2[0], &buf, 1);
        }
        gettimeofday(&end, NULL);

        long elapsed =
            (end.tv_sec - start.tv_sec) * 1000000 
            + (end.tv_usec - start.tv_usec);
        printf("total: %ld us\n", elapsed);
        double per_switch =
            (double)elapsed /
            (ITERATIONS * 2);
        printf(
            "context switch: %.3f us\n",
            per_switch);
    }
    return 0;
}

Parent → Child
Child → Parent

用户进程 A

User Mode
    |
    | syscall instruction
    |
    v

Kernel Mode
    |
    | 执行 read handler
    |
    v

User Mode

Process A

write(pipe)
    |
    v
Kernel
    |
    | A blocks
    |
scheduler
    |
    v
Process B

read(pipe)