// common.h — utilidades pequeñas para los ejemplos de la semana 1.
#ifndef COMMON_H
#define COMMON_H

#include <time.h>

// Espera activa: ocupa la CPU durante `segundos`.
static inline void spin(double segundos) {
    struct timespec t0, t;
    clock_gettime(CLOCK_MONOTONIC, &t0);
    do {
        clock_gettime(CLOCK_MONOTONIC, &t);
    } while ((t.tv_sec - t0.tv_sec) + (t.tv_nsec - t0.tv_nsec) / 1e9 < segundos);
}

#endif

// cpu.c — virtualización de la CPU.
// Ejecuten varias copias a la vez:  ./cpu A & ./cpu B & ./cpu C &
// Con un solo núcleo físico, las tres avanzan "al mismo tiempo".
#include <stdio.h>
#include <stdlib.h>
#include "common.h"

int main(int argc, char *argv[]) {
    if (argc != 2) {
        fprintf(stderr, "uso: cpu <texto>\n");
        return 1;
    }
    for (int i = 0; i < 5; i++) {
        spin(1);
        printf("%s\n", argv[1]);
        fflush(stdout);
    }
    return 0;
}

// io.c — persistencia: escribir un archivo y forzarlo al disco.
#include <fcntl.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>

int main(void) {
    int fd = open("hola.txt", O_WRONLY | O_CREAT | O_TRUNC, 0644);
    if (fd < 0) {
        perror("open");
        return 1;
    }
    const char *msg = "hola, disco\n";
    if (write(fd, msg, strlen(msg)) != (ssize_t)strlen(msg)) {
        perror("write");
        return 1;
    }
    fsync(fd);   // sin esto, los datos podrían quedar solo en la caché del kernel
    close(fd);
    printf("listo: hola.txt\n");
    return 0;
}

// mem.c — virtualización de la memoria.
// Dos copias imprimen la MISMA dirección pero valores independientes:
//   setarch -R ./mem 0 & setarch -R ./mem 100 &
// (setarch -R desactiva la aleatorización de direcciones para verlo mejor.)
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include "common.h"

int main(int argc, char *argv[]) {
    if (argc != 2) {
        fprintf(stderr, "uso: mem <valor inicial>\n");
        return 1;
    }
    int *p = malloc(sizeof(int));
    if (p == NULL) {
        perror("malloc");
        return 1;
    }
    *p = atoi(argv[1]);
    printf("(%d) dirección: %p\n", getpid(), (void *)p);
    for (int i = 0; i < 4; i++) {
        spin(1);
        *p = *p + 1;
        printf("(%d) *p = %d\n", getpid(), *p);
    }
    free(p);
    return 0;
}

// threads.c — concurrencia: dos hilos incrementan un contador compartido.
//   ./threads 1000       casi siempre imprime 2000
//   ./threads 1000000    casi nunca imprime 2000000. ¿Por qué?
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>

static volatile long counter = 0;
static long loops;

static void *worker(void *arg) {
    (void)arg;
    for (long i = 0; i < loops; i++)
        counter++;          // leer, sumar, escribir: tres pasos, no uno
    return NULL;
}

int main(int argc, char *argv[]) {
    if (argc != 2) {
        fprintf(stderr, "uso: threads <iteraciones>\n");
        return 1;
    }
    loops = atol(argv[1]);
    pthread_t a, b;
    pthread_create(&a, NULL, worker, NULL);
    pthread_create(&b, NULL, worker, NULL);
    pthread_join(a, NULL);
    pthread_join(b, NULL);
    printf("esperado: %ld\nobtenido: %ld\n", 2 * loops, counter);
    return 0;
}

# Semana 1: las cuatro demostraciones del cap. 2 de OSTEP.
#   make         compila todo
#   make test    corre cada demostración una vez (unos 10 s)
#   make clean   borra los binarios
CFLAGS  = -Wall -Wextra -O1 -g
LDLIBS  = -pthread
PROGS   = cpu mem threads io

all: $(PROGS)

$(PROGS): common.h

test: $(PROGS)
	./cpu A
	./mem 0
	./threads 1000
	./io
	cat hola.txt

clean:
	rm -f $(PROGS) hola.txt

.PHONY: all test clean