# Check current value (0 = parent first, 1 = child first):
cat /proc/sys/kernel/sched_child_runs_first

# Set child-runs-first for testing (needs root):
echo 1 > /proc/sys/kernel/sched_child_runs_first

# Set parent-runs-first (default):
echo 0 > /proc/sys/kernel/sched_child_runs_first

# Also queryable via sysctl:
sysctl kernel.sched_child_runs_first

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
#include <time.h>

int main(void)
{
    setbuf(stdout, NULL);

    /* Read current sched_child_runs_first setting */
    FILE *f = fopen("/proc/sys/kernel/sched_child_runs_first", "r");
    if (f) {
        int val;
        fscanf(f, "%d", &val);
        fclose(f);
        printf("sched_child_runs_first = %d (%s runs first by default)\n",
               val, val ? "child" : "parent");
    }

    struct timespec ts;
    clock_gettime(CLOCK_MONOTONIC, &ts);
    long before = ts.tv_nsec;

    pid_t pid = fork();
    if (pid == -1) { perror("fork"); exit(1); }

    if (pid == 0) {
        clock_gettime(CLOCK_MONOTONIC, &ts);
        printf("[Child  PID=%d] Ran at ns offset: %ld\n",
               getpid(), ts.tv_nsec - before);
        _exit(0);
    }

    clock_gettime(CLOCK_MONOTONIC, &ts);
    printf("[Parent PID=%d] Ran at ns offset: %ld\n",
           getpid(), ts.tv_nsec - before);

    wait(NULL);
    printf("(Whoever has smaller offset ran first)\n");
    return 0;
}

/* WHY CHILD-FIRST WAS PREFERRED IN EARLY 2.6:
   
   Scenario: parent forks, child immediately execs.
   
   If PARENT runs first after fork():
     - Parent continues executing → may write to CoW pages
     - Each write triggers a CoW copy (wasted work)
     - Child then execs → discards all copied pages anyway
     - Result: unnecessary memory copies
   
   If CHILD runs first after fork():
     - Child execs immediately → discards all pages
     - No CoW copies happen at all
     - Parent resumes with untouched shared pages
     - Result: zero wasted memory copies
   
   This is why early 2.6 kernels chose child-first.
   Modern kernels switched back to parent-first because:
   - On multicore systems, both run simultaneously anyway
   - The optimization assumes exec follows immediately
   - Overall system throughput was better with parent-first */

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <time.h>
#include <sys/wait.h>

/* Measure fork+exec time to see effect of parent writes before exec */
int main(void)
{
    /* Large allocation to make CoW cost visible */
    char *buf = malloc(20 * 1024 * 1024);
    memset(buf, 'X', 20 * 1024 * 1024);

    struct timespec s, e;
    clock_gettime(CLOCK_MONOTONIC, &s);

    int N = 100;
    for (int i = 0; i < N; i++) {
        pid_t pid = fork();
        if (pid == 0) {
            /* Child: exec immediately, no CoW triggered */
            char *argv[] = { "true", NULL };
            execvp("true", argv);
            _exit(0);
        }
        /* Parent: does NOT write to buf before waiting */
        waitpid(pid, NULL, 0);
    }

    clock_gettime(CLOCK_MONOTONIC, &e);
    double ms = ((e.tv_sec - s.tv_sec)*1e3 +
                 (e.tv_nsec - s.tv_nsec)/1e6) / N;
    printf("fork+exec (no parent write): %.3f ms/call\n", ms);

    free(buf);
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>

/* WRONG: assumes parent runs before child */
void bad_example(void)
{
    int counter = 0;

    pid_t pid = fork();
    if (pid == -1) { perror("fork"); exit(1); }

    if (pid == 0) {
        /* Child assumes counter was already set by parent.
           WRONG: parent might not have run yet! */
        printf("[Child] counter = %d (expected 42!)\n", counter);
        _exit(0);
    }

    counter = 42;  /* Parent sets counter */
    printf("[Parent] Set counter = %d\n", counter);
    wait(NULL);
}

/* CORRECT: don't assume order; set values BEFORE fork */
void good_example(void)
{
    int counter = 42;  /* Set BEFORE fork — safe */

    pid_t pid = fork();
    if (pid == -1) { perror("fork"); exit(1); }

    if (pid == 0) {
        printf("[Child] counter = %d (correct: set before fork)\n",
               counter);
        _exit(0);
    }

    wait(NULL);
}

int main(void)
{
    printf("=== BAD (order-dependent) ===\n");
    bad_example();

    printf("\n=== GOOD (order-independent) ===\n");
    good_example();

    return 0;
}