Seeking feedback: OSTEP chapter 6 measurement homework

See more:

C

Linux

Greetings,

I am self-studying OSTEP (Operating Systems Three Easy Pieces). It's an amazing book, and I'm learning a ton from it. Currently, I am working on the measurement homework at the end of Chapter 6 (Mechanism: Limited Direct Execution). I come from a C++ background, so, please, if there are better ways to write a piece of code in this program, I would appreciate your insights.

Homework (bottom of the pdf):
https://pages.cs.wisc.edu/~remzi/OSTEP/cpu-mechanisms.pdf

Code:

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <sched.h>
#include <unistd.h>

#define SIZE      7
#define READ_END  0
#define WRITE_END 1

static __inline__ uint64_t rdtsc(void)
{
    unsigned lo, hi;
    __asm__ __volatile__ ("rdtsc" : "=a" (lo), "=d" (hi));
    return (((uint64_t)lo) | (((uint64_t)hi) << 32));
}

int main(void)
{
    int fd1[2], fd2[2];
    if(pipe(fd1) == -1 || pipe(fd2) == -1) {
        perror("pipe()");
        return EXIT_FAILURE;
    }

    pid_t pid = fork();

    int cpu = 0;
    cpu_set_t mask;
    CPU_ZERO(&mask);
    CPU_SET(cpu, &mask);
    if(sched_setaffinity(0, sizeof(mask), &mask) == -1) {
        perror("sched_setaffinity()");
        return EXIT_FAILURE;
    }

    uint64_t start = rdtsc();

    switch(pid) {
    case -1:
        perror("fork()");
        return EXIT_FAILURE;

    case 0: {
        close(fd1[READ_END]);
        char ca[] = {"rodata"};
        ssize_t bytes = write(fd1[WRITE_END], ca, sizeof(ca));
        if(bytes == -1) {
            perror("write()");
            return EXIT_FAILURE;
        }
        close(fd1[WRITE_END]);

        bytes = read(fd2[READ_END], ca, sizeof(ca));
        if(bytes == -1) {
            perror("read()");
            return EXIT_FAILURE;
        }
        close(fd2[READ_END]);
        break;
    }

    default: {
        close(fd1[WRITE_END]);
        char ca[SIZE];
        ssize_t bytes = read(fd1[READ_END], ca, SIZE);
        if(bytes == -1) {
            perror("read()");
            return EXIT_FAILURE;
        }
        close(fd1[READ_END]);

        bytes = write(fd2[WRITE_END], ca, sizeof(ca));
        if(bytes == -1) {
            perror("read()");
            return EXIT_FAILURE;
        }
        close(fd2[WRITE_END]);
        break;
    }
    
    }

    uint64_t end = rdtsc();

    printf("Total clock cycles: %llu\n", (unsigned long long)(end - start));

    return EXIT_SUCCESS;
}

What I have tried:

I read the man page for the sched_setaffinity to better understand how to take advantage of just one core for the two processes to run on. My concern is whether the code does what it is suppose to do. And to do it correctly.