From 849c041446deb004de5e53f066eecb152930a4cd Mon Sep 17 00:00:00 2001
From: Sergio <sergio@gioser.net>
Date: Sat, 29 Aug 2026 19:31:48 +0000
Subject: [PATCH] =?UTF-8?q?tasas:=20los=204=20experimentos=20que=20=C2=A79?=
 =?UTF-8?q?=20dej=C3=B3=20nombrados,=20medidos=20con=20root?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

SDD 25 §9 listó seis experimentos que no se pudieron correr y por qué. Cuatro
de ellos sólo pedían privilegios, y esta sesión los tuvo. Programas y salidas
crudas en docs/evidencia/tasas-kernel-2026-08-29/.

1. proc connector (bench_connector.c) — el sondeo de /proc no es lento, es
   CIEGO: 200 procesos de vida mínima lanzados uno cada 10 ms, sondeando cada
   100 ms se ven **0 de 200**; por connector, **200 de 200**. Y esperar el
   evento no cuesta nada frente a waitpid (116,0 vs 114,8 µs, dentro del ruido),
   con 0 eventos perdidos en 1400.
   Sorpresa: taskstats por genetlink **no es más rápido** que parsear
   /proc/self/stat (2 688 vs 2 697 ns). Su valor es el CONTENIDO (delay
   accounting), no la velocidad.

2. reflink (bench_reflink.c) — el «copiar en O(1)» existe y NO está en ext4:
   FICLONE no soportado, y copy_file_range ≈ read+write (13,7 vs 14,5 ms).
   En xfs y btrfs es PLANO: 64 MiB en 0,010 ms y 512 MiB —ocho veces más— en
   0,020 ms, contra 512,7 ms de read+write. **25 600× a 512 MiB.**

3. io_uring SQPOLL (bench_sqpoll.c) — no rescata el veredicto de T12: sobre
   datos cacheados pierde igual. ext4: pread 554 ns < io_uring 618 < SQPOLL 868.
   tmpfs: pread 749 < SQPOLL 1 409 < io_uring 2 030 (ahí sí mejora al io_uring
   normal, 1,4×, pero sigue perdiendo contra la syscall). Y se come un core.

4. syscalls por invocación de compilador — con el strace DEL PROPIO CORPUS
   (store/3c1fd8c0…-strace), que es la respuesta a «no hay strace en esta
   máquina». gcc: 1 803 syscalls por un `-c` trivial, **1 095 con error (61%),
   919 de ellas readlink** — la canonicalización de rutas, que T8 no medía.
   Pero al piso de 78,7 ns son 0,14 ms sobre 30,5 ms de compilado: **el cruce
   al kernel es el 0,5%**. La tormenta de rutas vale milisegundos, no minutos.

Condiciones distintas a la corrida original (load ~1,3 sobre 4 vCPU contra 7,3)
⇒ los absolutos NO se comparan entre corridas, sólo los cocientes dentro de una.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01ACUcwo9mZsE5ocYVE9npih
---
 .../tasas-kernel-2026-08-29/bench_connector.c | 312 ++++++++++++++++++
 .../tasas-kernel-2026-08-29/bench_reflink.c   | 106 ++++++
 .../tasas-kernel-2026-08-29/bench_sqpoll.c    | 112 +++++++
 .../tasas-kernel-2026-08-29/connector.txt     |  20 ++
 .../tasas-kernel-2026-08-29/reflink.txt       |  34 ++
 .../tasas-kernel-2026-08-29/sqpoll.txt        |  13 +
 .../syscalls-compilador.txt                   | 126 +++++++
 7 files changed, 723 insertions(+)
 create mode 100644 docs/evidencia/tasas-kernel-2026-08-29/bench_connector.c
 create mode 100644 docs/evidencia/tasas-kernel-2026-08-29/bench_reflink.c
 create mode 100644 docs/evidencia/tasas-kernel-2026-08-29/bench_sqpoll.c
 create mode 100644 docs/evidencia/tasas-kernel-2026-08-29/connector.txt
 create mode 100644 docs/evidencia/tasas-kernel-2026-08-29/reflink.txt
 create mode 100644 docs/evidencia/tasas-kernel-2026-08-29/sqpoll.txt
 create mode 100644 docs/evidencia/tasas-kernel-2026-08-29/syscalls-compilador.txt

diff --git a/docs/evidencia/tasas-kernel-2026-08-29/bench_connector.c b/docs/evidencia/tasas-kernel-2026-08-29/bench_connector.c
new file mode 100644
index 00000000..cd57516e
--- /dev/null
+++ b/docs/evidencia/tasas-kernel-2026-08-29/bench_connector.c
@@ -0,0 +1,312 @@
+/* bench_connector.c — proc connector (netlink) y taskstats contra sondear /proc.
+ *
+ * Cierra el experimento 1 de SDD 25 §9, que quedo sin medir por falta de CAP_NET_ADMIN.
+ * Requiere root. Tres fases:
+ *   A. LATENCIA   fork+_exit+waitpid  vs  fork+_exit+esperar el evento del connector.
+ *   B. CEGUERA    procesos cortos vistos por el connector vs vistos sondeando /proc cada 100 ms.
+ *   C. TASKSTATS  una consulta binaria por genetlink vs parsear /proc/<pid>/stat.
+ *
+ * Se compila con: cc -O2 -o bench_connector bench_connector.c
+ */
+#define _GNU_SOURCE
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <time.h>
+#include <errno.h>
+#include <dirent.h>
+#include <sys/socket.h>
+#include <sys/wait.h>
+#include <sys/resource.h>
+#include <poll.h>
+#include <linux/netlink.h>
+#include <linux/connector.h>
+#include <linux/cn_proc.h>
+#include <linux/genetlink.h>
+#include <linux/taskstats.h>
+
+static volatile long sink;
+static inline double now_ns(void){ struct timespec t; clock_gettime(CLOCK_MONOTONIC,&t); return t.tv_sec*1e9+t.tv_nsec; }
+static int cmpd(const void*a,const void*b){ double x=*(const double*)a,y=*(const double*)b; return (x>y)-(x<y); }
+static void report(const char*n,double*r,int c,long it){ qsort(r,c,sizeof(double),cmpd);
+  printf("%-44s %10.1f %10.1f   (n=%ld)\n",n,r[0],r[c/2],it); fflush(stdout); }
+#define ROUNDS 7
+
+/* ---------------------------------------------------------------- proc connector */
+
+static int cn_open(void){
+  int s = socket(PF_NETLINK, SOCK_DGRAM|SOCK_CLOEXEC, NETLINK_CONNECTOR);
+  if(s<0) return -1;
+  struct sockaddr_nl a; memset(&a,0,sizeof a);
+  a.nl_family=AF_NETLINK; a.nl_groups=CN_IDX_PROC; a.nl_pid=getpid();
+  if(bind(s,(struct sockaddr*)&a,sizeof a)<0){ close(s); return -1; }
+
+  struct {
+    struct nlmsghdr nl;
+    struct cn_msg cn;
+    enum proc_cn_mcast_op op;
+  } __attribute__((packed)) m;
+  memset(&m,0,sizeof m);
+  m.nl.nlmsg_len=sizeof m; m.nl.nlmsg_pid=getpid(); m.nl.nlmsg_type=NLMSG_DONE;
+  m.cn.id.idx=CN_IDX_PROC; m.cn.id.val=CN_VAL_PROC; m.cn.len=sizeof(enum proc_cn_mcast_op);
+  m.op=PROC_CN_MCAST_LISTEN;
+  if(send(s,&m,sizeof m,0)<0){ close(s); return -1; }
+  /* El multicast del connector NO reintenta: si el buffer se llena, el evento se PIERDE (ENOBUFS)
+   * y el que espera ese pid se queda esperando para siempre. Se agranda el buffer y, aun asi, la
+   * espera lleva plazo (abajo). Es una propiedad del mecanismo, no un detalle de este programa. */
+  int rb=4*1024*1024; setsockopt(s,SOL_SOCKET,SO_RCVBUFFORCE,&rb,sizeof rb);
+  return s;
+}
+
+/* Lee un evento. Devuelve el proc_event, o NULL si el mensaje no lo era. */
+static struct proc_event *cn_read(int s, char *buf, size_t n){
+  ssize_t r = recv(s, buf, n, 0);
+  if(r<=0) return NULL;
+  struct nlmsghdr *nlh=(struct nlmsghdr*)buf;
+  if(!NLMSG_OK(nlh,(size_t)r)) return NULL;
+  struct cn_msg *cn=(struct cn_msg*)NLMSG_DATA(nlh);
+  return (struct proc_event*)cn->data;
+}
+
+/* Vacia lo que haya en el socket sin bloquear. */
+static void cn_drain(int s){
+  int fl=fcntl(s,F_GETFL,0); fcntl(s,F_SETFL,fl|O_NONBLOCK);
+  char b[4096]; while(recv(s,b,sizeof b,0)>0){}
+  fcntl(s,F_SETFL,fl);
+}
+
+static void fase_a(int s){
+  printf("\n### A. Latencia de notificacion: waitpid contra evento del connector\n");
+  printf("%-44s %10s %10s\n","BENCH (ns por proceso)","min","mediana");
+  const long N=200;
+
+  double r[ROUNDS];
+  for(int q=0;q<ROUNDS;q++){
+    double t0=now_ns();
+    for(long i=0;i<N;i++){ pid_t p=fork(); if(p==0) _exit(0); int st; waitpid(p,&st,0); }
+    r[q]=(now_ns()-t0)/(double)N;
+  }
+  report("fork+_exit+waitpid (SIGCHLD, la base)",r,ROUNDS,N);
+
+  char buf[8192];
+  long perdidos=0;
+  for(int q=0;q<ROUNDS;q++){
+    cn_drain(s);
+    double t0=now_ns();
+    for(long i=0;i<N;i++){
+      pid_t p=fork(); if(p==0) _exit(0);
+      double lim=now_ns()+2e8;              /* 200 ms de plazo: si no llega, se PERDIO */
+      for(;;){
+        if(now_ns()>lim){ perdidos++; break; }
+        struct pollfd pf={.fd=s,.events=POLLIN};
+        if(poll(&pf,1,50)<=0) continue;
+        struct proc_event *e=cn_read(s,buf,sizeof buf);
+        if(!e) continue;
+        if(e->what==PROC_EVENT_EXIT && e->event_data.exit.process_pid==p) break;
+      }
+      int st; waitpid(p,&st,0);
+    }
+    r[q]=(now_ns()-t0)/(double)N;
+  }
+  report("fork+_exit+esperar EXIT del connector",r,ROUNDS,N);
+  printf("eventos EXIT que no llegaron en 200 ms: %ld de %ld\n",perdidos,(long)N*ROUNDS);
+}
+
+/* ---------------------------------------------------------------- ceguera del sondeo */
+
+#define BURST 200        /* procesos cortos */
+#define SPACING_US 10000 /* uno cada 10 ms => 2 s de rafaga */
+#define POLL_MS 100      /* periodo del sondeo, generoso: un supervisor real no baja de aca */
+
+/* Lanza BURST hijos que viven lo minimo, y escribe sus pids por el pipe. */
+static void spawner(int wfd){
+  for(int i=0;i<BURST;i++){
+    pid_t p=fork();
+    if(p==0) _exit(0);
+    (void)!write(wfd,&p,sizeof p);
+    int st; waitpid(p,&st,0);
+    usleep(SPACING_US);
+  }
+  close(wfd);
+  _exit(0);
+}
+
+static int en_lista(pid_t *v,int n,pid_t p){ for(int i=0;i<n;i++) if(v[i]==p) return 1; return 0; }
+
+static double cpu_ms(void){
+  struct rusage u; getrusage(RUSAGE_SELF,&u);
+  return (u.ru_utime.tv_sec+u.ru_stime.tv_sec)*1e3
+       + (u.ru_utime.tv_usec+u.ru_stime.tv_usec)/1e3;
+}
+
+static void fase_b(int s){
+  printf("\n### B. Ceguera: %d procesos de vida minima, uno cada %d ms\n",BURST,SPACING_US/1000);
+
+  /* --- observador 1: sondeo de /proc cada POLL_MS --- */
+  int fd[2]; if(pipe(fd)) { perror("pipe"); return; }
+  pid_t sp=fork();
+  if(sp==0){ close(fd[0]); spawner(fd[1]); }
+  close(fd[1]);
+  static pid_t lanzados[BURST]; int nl=0;
+  static pid_t vistos[BURST*8]; int nv=0;
+  double c0=cpu_ms(), t0=now_ns(); int barridos=0;
+  while(now_ns()-t0 < (double)BURST*SPACING_US*1000.0 + 3e8){
+    DIR *d=opendir("/proc"); struct dirent *e;
+    while(d && (e=readdir(d))){
+      if(e->d_name[0]<'0'||e->d_name[0]>'9') continue;
+      pid_t p=(pid_t)atol(e->d_name);
+      if(nv<BURST*8 && !en_lista(vistos,nv,p)) vistos[nv++]=p;
+    }
+    if(d) closedir(d);
+    barridos++;
+    usleep(POLL_MS*1000);
+  }
+  double cpu_sondeo=cpu_ms()-c0;
+  { int st; waitpid(sp,&st,0); }
+  { pid_t p; while(read(fd[0],&p,sizeof p)==sizeof p) if(nl<BURST) lanzados[nl++]=p; }
+  close(fd[0]);
+  int cazados=0; for(int i=0;i<nl;i++) if(en_lista(vistos,nv,lanzados[i])) cazados++;
+  printf("sondeo /proc cada %d ms : %d de %d procesos vistos  (%d barridos, %.1f ms de CPU)\n",
+         POLL_MS,cazados,nl,barridos,cpu_sondeo);
+
+  /* --- observador 2: connector --- */
+  if(pipe(fd)){ perror("pipe"); return; }
+  cn_drain(s);
+  sp=fork();
+  if(sp==0){ close(fd[0]); spawner(fd[1]); }
+  close(fd[1]);
+  nl=0; nv=0;
+  c0=cpu_ms(); t0=now_ns();
+  int flags=fcntl(s,F_GETFL,0); fcntl(s,F_SETFL,flags|O_NONBLOCK);
+  char buf[8192];
+  while(now_ns()-t0 < (double)BURST*SPACING_US*1000.0 + 3e8){
+    struct proc_event *e=cn_read(s,buf,sizeof buf);
+    if(!e){ usleep(200); continue; }
+    if(e->what==PROC_EVENT_EXIT){
+      pid_t p=e->event_data.exit.process_pid;
+      if(nv<BURST*8 && !en_lista(vistos,nv,p)) vistos[nv++]=p;
+    }
+  }
+  fcntl(s,F_SETFL,flags);
+  double cpu_conn=cpu_ms()-c0;
+  { int st; waitpid(sp,&st,0); }
+  { pid_t p; while(read(fd[0],&p,sizeof p)==sizeof p) if(nl<BURST) lanzados[nl++]=p; }
+  close(fd[0]);
+  cazados=0; for(int i=0;i<nl;i++) if(en_lista(vistos,nv,lanzados[i])) cazados++;
+  printf("proc connector (eventos)  : %d de %d procesos vistos  (%.1f ms de CPU)\n",
+         cazados,nl,cpu_conn);
+  printf("NOTA: el connector se lee aca con espera activa de 200 us, que NO es el modo de un\n"
+         "      supervisor real (seria epoll) => su CPU es cota superior. Lo que cuenta: COBERTURA.\n");
+}
+
+/* ---------------------------------------------------------------- taskstats */
+
+static int genl_family(int s,const char *name){
+  struct { struct nlmsghdr n; struct genlmsghdr g; char buf[256]; } req;
+  memset(&req,0,sizeof req);
+  req.n.nlmsg_type=GENL_ID_CTRL; req.n.nlmsg_flags=NLM_F_REQUEST; req.n.nlmsg_seq=1; req.n.nlmsg_pid=getpid();
+  req.g.cmd=CTRL_CMD_GETFAMILY; req.g.version=1;
+  struct nlattr *a=(struct nlattr*)req.buf;
+  a->nla_type=CTRL_ATTR_FAMILY_NAME; a->nla_len=NLA_HDRLEN+strlen(name)+1;
+  strcpy((char*)a+NLA_HDRLEN,name);
+  req.n.nlmsg_len=NLMSG_LENGTH(GENL_HDRLEN)+NLA_ALIGN(a->nla_len);
+  if(send(s,&req,req.n.nlmsg_len,0)<0) return -1;
+
+  char rb[4096]; ssize_t r=recv(s,rb,sizeof rb,0);
+  if(r<0) return -1;
+  struct nlmsghdr *nh=(struct nlmsghdr*)rb;
+  if(nh->nlmsg_type==NLMSG_ERROR) return -1;
+  struct nlattr *na=(struct nlattr*)((char*)NLMSG_DATA(nh)+GENL_HDRLEN);
+  int len=NLMSG_PAYLOAD(nh,0)-GENL_HDRLEN;
+  while(len>0){
+    if(na->nla_type==CTRL_ATTR_FAMILY_ID) return *(__u16*)((char*)na+NLA_HDRLEN);
+    len-=NLA_ALIGN(na->nla_len);
+    na=(struct nlattr*)((char*)na+NLA_ALIGN(na->nla_len));
+  }
+  return -1;
+}
+
+static int ts_query(int s,int fam,pid_t pid,unsigned long long *cpu_ns){
+  struct { struct nlmsghdr n; struct genlmsghdr g; char buf[128]; } req;
+  memset(&req,0,sizeof req);
+  req.n.nlmsg_type=fam; req.n.nlmsg_flags=NLM_F_REQUEST; req.n.nlmsg_seq=2; req.n.nlmsg_pid=getpid();
+  req.g.cmd=TASKSTATS_CMD_GET; req.g.version=TASKSTATS_VERSION;
+  struct nlattr *a=(struct nlattr*)req.buf;
+  a->nla_type=TASKSTATS_CMD_ATTR_PID; a->nla_len=NLA_HDRLEN+sizeof(__u32);
+  *(__u32*)((char*)a+NLA_HDRLEN)=pid;
+  req.n.nlmsg_len=NLMSG_LENGTH(GENL_HDRLEN)+NLA_ALIGN(a->nla_len);
+  if(send(s,&req,req.n.nlmsg_len,0)<0) return -1;
+
+  char rb[8192]; ssize_t r=recv(s,rb,sizeof rb,0);
+  if(r<0) return -1;
+  struct nlmsghdr *nh=(struct nlmsghdr*)rb;
+  if(nh->nlmsg_type==NLMSG_ERROR) return -1;
+  struct nlattr *na=(struct nlattr*)((char*)NLMSG_DATA(nh)+GENL_HDRLEN);
+  int len=NLMSG_PAYLOAD(nh,0)-GENL_HDRLEN;
+  while(len>0){
+    if(na->nla_type==TASKSTATS_TYPE_AGGR_PID || na->nla_type==TASKSTATS_TYPE_AGGR_TGID){
+      struct nlattr *in=(struct nlattr*)((char*)na+NLA_HDRLEN);
+      int il=na->nla_len-NLA_HDRLEN;
+      while(il>0){
+        if(in->nla_type==TASKSTATS_TYPE_STATS){
+          struct taskstats *ts=(struct taskstats*)((char*)in+NLA_HDRLEN);
+          *cpu_ns=ts->ac_utime*1000ULL+ts->ac_stime*1000ULL;
+          return 0;
+        }
+        il-=NLA_ALIGN(in->nla_len);
+        in=(struct nlattr*)((char*)in+NLA_ALIGN(in->nla_len));
+      }
+    }
+    len-=NLA_ALIGN(na->nla_len);
+    na=(struct nlattr*)((char*)na+NLA_ALIGN(na->nla_len));
+  }
+  return -1;
+}
+
+static void fase_c(void){
+  printf("\n### C. Estadisticas de UNA tarea: taskstats binario contra /proc de texto\n");
+  int s=socket(PF_NETLINK,SOCK_DGRAM|SOCK_CLOEXEC,NETLINK_GENERIC);
+  if(s<0){ printf("taskstats: sin socket genetlink (%s)\n",strerror(errno)); return; }
+  struct sockaddr_nl a; memset(&a,0,sizeof a); a.nl_family=AF_NETLINK; a.nl_pid=getpid();
+  if(bind(s,(struct sockaddr*)&a,sizeof a)<0){ printf("taskstats: bind (%s)\n",strerror(errno)); close(s); return; }
+  int fam=genl_family(s,TASKSTATS_GENL_NAME);
+  if(fam<0){ printf("taskstats: la familia %s no esta (kernel sin TASKSTATS)\n",TASKSTATS_GENL_NAME); close(s); return; }
+  unsigned long long ns=0;
+  if(ts_query(s,fam,getpid(),&ns)<0){ printf("taskstats: la consulta fallo (%s)\n",strerror(errno)); close(s); return; }
+  printf("familia TASKSTATS = %d, cpu de este proceso = %llu ns\n",fam,ns);
+
+  printf("%-44s %10s %10s\n","BENCH (ns por consulta)","min","mediana");
+  const long N=2000;
+  double r[ROUNDS];
+  for(int q=0;q<ROUNDS;q++){
+    double t0=now_ns();
+    for(long i=0;i<N;i++){ unsigned long long v; sink=ts_query(s,fam,getpid(),&v); }
+    r[q]=(now_ns()-t0)/(double)N;
+  }
+  report("taskstats por genetlink (binario)",r,ROUNDS,N);
+
+  for(int q=0;q<ROUNDS;q++){
+    double t0=now_ns();
+    for(long i=0;i<N;i++){
+      int fd=open("/proc/self/stat",O_RDONLY); char b[2048];
+      ssize_t n=read(fd,b,sizeof b-1); close(fd);
+      if(n>0){ b[n]=0; char *p=strrchr(b,')'); for(int f=0;p&&f<12;f++) p=strchr(p+1,' ');
+               sink=p?atol(p+1):0; }
+    }
+    r[q]=(now_ns()-t0)/(double)N;
+  }
+  report("open+read+parse /proc/self/stat",r,ROUNDS,N);
+  close(s);
+}
+
+int main(void){
+  if(geteuid()!=0) fprintf(stderr,"aviso: sin root el connector no se suscribe (CAP_NET_ADMIN)\n");
+  printf("# bench_connector — SDD 25 seccion 9, experimento 1\n");
+  int s=cn_open();
+  if(s<0){ printf("proc connector: no disponible (%s)\n",strerror(errno)); }
+  else { fase_a(s); fase_b(s); close(s); }
+  fase_c();
+  return 0;
+}
diff --git a/docs/evidencia/tasas-kernel-2026-08-29/bench_reflink.c b/docs/evidencia/tasas-kernel-2026-08-29/bench_reflink.c
new file mode 100644
index 00000000..8e961ea5
--- /dev/null
+++ b/docs/evidencia/tasas-kernel-2026-08-29/bench_reflink.c
@@ -0,0 +1,106 @@
+/* bench_reflink.c — copiar un fichero: reflink (FICLONE), copy_file_range y read+write.
+ *
+ * Cierra el experimento 2 de SDD 25 seccion 9 (T11), que quedo sin medir porque exige mkfs sobre
+ * un loop, o sea root. La pregunta: el "copiar en O(1)" que la gente espera de copy_file_range,
+ * cuanto vale de verdad, y en que filesystem.
+ *
+ * Uso: bench_reflink <dir> <etiqueta>   (el dir debe estar en el FS que se quiere medir)
+ * Se compila con: cc -O2 -o bench_reflink bench_reflink.c
+ */
+#define _GNU_SOURCE
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <time.h>
+#include <errno.h>
+#include <sys/ioctl.h>
+#include <sys/stat.h>
+#include <linux/fs.h>
+
+#define MB (1024*1024)
+static long SIZE = 64*MB;   /* se puede fijar por argv[3] en MiB: la copia O(1) hay que verla PLANA */
+#define ROUNDS 7
+
+static inline double now_ns(void){ struct timespec t; clock_gettime(CLOCK_MONOTONIC,&t); return t.tv_sec*1e9+t.tv_nsec; }
+static int cmpd(const void*a,const void*b){ double x=*(const double*)a,y=*(const double*)b; return (x>y)-(x<y); }
+static void report(const char*n,double*r,int c){
+  qsort(r,c,sizeof(double),cmpd);
+  double min=r[0],med=r[c/2];
+  /* El MB/s se imprime solo cuando la copia MUEVE datos. Con reflink el tiempo no depende del
+   * tamano, asi que dividir por el ni significa nada ni se puede citar. */
+  if(min > 1e6) printf("%-40s %9.3f ms %9.3f ms   %8.0f MB/s\n",n,min/1e6,med/1e6,(double)SIZE/(min/1e9)/1e6);
+  else          printf("%-40s %9.3f ms %9.3f ms   (plano: no mueve datos)\n",n,min/1e6,med/1e6);
+  fflush(stdout);
+}
+
+static int src_fd(const char *dir,char *path,size_t n){
+  snprintf(path,n,"%s/origen.bin",dir);
+  int fd=open(path,O_CREAT|O_RDWR|O_TRUNC,0644);
+  if(fd<0) return -1;
+  char *b=malloc(MB); memset(b,0xA5,MB);
+  for(long i=0;i<SIZE/MB;i++) if(write(fd,b,MB)!=MB){ free(b); close(fd); return -1; }
+  free(b);
+  fsync(fd);
+  /* Se deja en cache a proposito: se mide el camino de COPIA, no el de lectura de disco. */
+  return fd;
+}
+
+int main(int argc,char**argv){
+  if(argc<3){ fprintf(stderr,"uso: %s <dir> <etiqueta> [MiB]\n",argv[0]); return 2; }
+  const char *dir=argv[1], *etiqueta=argv[2];
+  if(argc>3) SIZE=atol(argv[3])*MB;
+  char src[512],dst[512];
+  int in=src_fd(dir,src,sizeof src);
+  if(in<0){ fprintf(stderr,"no pude crear el origen en %s: %s\n",dir,strerror(errno)); return 1; }
+  snprintf(dst,sizeof dst,"%s/copia.bin",dir);
+
+  printf("\n### copia de %ld MiB sobre %s\n",SIZE/MB,etiqueta);
+  printf("%-40s %12s %12s\n","BENCH","min","mediana");
+
+  double r[ROUNDS];
+  int ok=0;
+
+  /* 1. reflink de fichero entero: la copia O(1) de verdad (comparte extents COW). */
+  for(int q=0;q<ROUNDS;q++){
+    unlink(dst);
+    int out=open(dst,O_CREAT|O_WRONLY|O_TRUNC,0644);
+    double t0=now_ns();
+    int rc=ioctl(out,FICLONE,in);
+    r[q]=now_ns()-t0;
+    close(out);
+    if(rc<0){ printf("%-40s no soportado (%s)\n","FICLONE (reflink entero)",strerror(errno)); ok=-1; break; }
+  }
+  if(ok==0) report("FICLONE (reflink entero)",r,ROUNDS);
+
+  /* 2. copy_file_range: la API portable. En un FS con reflink cae en el mismo camino; en ext4
+   *    cae a una copia DENTRO del kernel. */
+  for(int q=0;q<ROUNDS;q++){
+    unlink(dst);
+    int out=open(dst,O_CREAT|O_WRONLY|O_TRUNC,0644);
+    loff_t off_in=0,off_out=0; size_t left=(size_t)SIZE;
+    double t0=now_ns();
+    while(left){ ssize_t c=copy_file_range(in,&off_in,out,&off_out,left,0); if(c<=0) break; left-=c; }
+    r[q]=now_ns()-t0;
+    close(out);
+  }
+  report("copy_file_range",r,ROUNDS);
+
+  /* 3. read+write en trozos de 1 MiB: lo que hace un cp cualquiera. */
+  char *buf=malloc(MB);
+  for(int q=0;q<ROUNDS;q++){
+    unlink(dst);
+    int out=open(dst,O_CREAT|O_WRONLY|O_TRUNC,0644);
+    lseek(in,0,SEEK_SET);
+    double t0=now_ns();
+    for(long i=0;i<SIZE/MB;i++){ ssize_t n=read(in,buf,MB); if(n>0) (void)!write(out,buf,n); }
+    r[q]=now_ns()-t0;
+    close(out);
+  }
+  report("read+write (1 MiB)",r,ROUNDS);
+  free(buf);
+
+  unlink(dst); unlink(src); close(in);
+  return 0;
+}
diff --git a/docs/evidencia/tasas-kernel-2026-08-29/bench_sqpoll.c b/docs/evidencia/tasas-kernel-2026-08-29/bench_sqpoll.c
new file mode 100644
index 00000000..0d97e3cc
--- /dev/null
+++ b/docs/evidencia/tasas-kernel-2026-08-29/bench_sqpoll.c
@@ -0,0 +1,112 @@
+/* bench_sqpoll.c — io_uring con SQPOLL contra io_uring normal y contra pread.
+ *
+ * Cierra el experimento 4 de SDD 25 seccion 9: SQPOLL pide CAP_SYS_NICE, asi que la corrida
+ * original no pudo mirarlo. La pregunta que dejo abierta T12: io_uring pierde sobre datos ya
+ * cacheados porque el cruce al kernel no se amortiza — con SQPOLL NO HAY cruce (un hilo del
+ * kernel consume la cola), asi que este es el caso donde deberia ganar.
+ *
+ * Uso: bench_sqpoll <dir> <etiqueta>
+ * Se compila con: cc -O2 -o bench_sqpoll bench_sqpoll.c -luring
+ */
+#define _GNU_SOURCE
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <time.h>
+#include <errno.h>
+#include <liburing.h>
+
+#define MB (1024*1024)
+#define SIZE (64*MB)
+#define BS 4096
+#define ROUNDS 7
+#define DEPTH 32
+#define OPS 50000
+
+static volatile long sink;
+static inline double now_ns(void){ struct timespec t; clock_gettime(CLOCK_MONOTONIC,&t); return t.tv_sec*1e9+t.tv_nsec; }
+static int cmpd(const void*a,const void*b){ double x=*(const double*)a,y=*(const double*)b; return (x>y)-(x<y); }
+static void report(const char*n,double*r,int c,long it){ qsort(r,c,sizeof(double),cmpd);
+  printf("%-44s %10.1f %10.1f   (n=%ld)\n",n,r[0],r[c/2],it); fflush(stdout); }
+
+/* Un pase de OPS lecturas de 4K en profundidad DEPTH. Devuelve ns/op. */
+static double pase(struct io_uring *ring,int fd,char *buf,long nblk){
+  double t0=now_ns();
+  for(long done=0;done<OPS;){
+    int batch = (OPS-done<DEPTH)?(int)(OPS-done):DEPTH;
+    for(int k=0;k<batch;k++){
+      struct io_uring_sqe *s=io_uring_get_sqe(ring);
+      io_uring_prep_read(s,fd,buf+k*BS,BS,(long)(((done+k)*7919)%nblk)*BS);
+    }
+    io_uring_submit_and_wait(ring,batch);
+    struct io_uring_cqe *c; unsigned h; int seen=0;
+    io_uring_for_each_cqe(ring,h,c){ seen++; }
+    io_uring_cq_advance(ring,seen);
+    done+=batch;
+  }
+  return (now_ns()-t0)/(double)OPS;
+}
+
+int main(int argc,char**argv){
+  if(argc<3){ fprintf(stderr,"uso: %s <dir> <etiqueta>\n",argv[0]); return 2; }
+  char path[512]; snprintf(path,sizeof path,"%s/sqpoll.bin",argv[1]);
+  int fd=open(path,O_CREAT|O_RDWR|O_TRUNC,0644);
+  if(fd<0){ fprintf(stderr,"no pude crear %s: %s\n",path,strerror(errno)); return 1; }
+  char *b=malloc(MB); memset(b,0x5A,MB);
+  for(int i=0;i<SIZE/MB;i++) if(write(fd,b,MB)!=MB){ perror("write"); return 1; }
+  free(b);
+  /* Se lee entero una vez para dejarlo en cache: se mide el camino de ENTREGA, no el disco. */
+  char *buf=aligned_alloc(4096,DEPTH*BS);
+  for(long o=0;o<SIZE;o+=BS) sink=pread(fd,buf,BS,o);
+  long nblk=SIZE/BS;
+
+  printf("\n### 4K aleatorios en cache sobre %s (profundidad %d)\n",argv[2],DEPTH);
+  printf("%-44s %10s %10s\n","BENCH (ns/op)","min","mediana");
+
+  double r[ROUNDS];
+  for(int q=0;q<ROUNDS;q++){
+    double t0=now_ns();
+    for(long i=0;i<OPS;i++) sink=pread(fd,buf,BS,(long)((i*7919)%nblk)*BS);
+    r[q]=(now_ns()-t0)/(double)OPS;
+  }
+  report("pread 4K (una syscall por op)",r,ROUNDS,OPS);
+
+  struct io_uring ring;
+  if(io_uring_queue_init(256,&ring,0)==0){
+    for(int q=0;q<ROUNDS;q++) r[q]=pase(&ring,fd,buf,nblk);
+    report("io_uring sin SQPOLL",r,ROUNDS,OPS);
+    io_uring_queue_exit(&ring);
+  } else printf("io_uring: no disponible (%s)\n",strerror(errno));
+
+  struct io_uring_params p; memset(&p,0,sizeof p);
+  p.flags=IORING_SETUP_SQPOLL; p.sq_thread_idle=2000;
+  if(io_uring_queue_init_params(256,&ring,&p)==0){
+    /* Con SQPOLL el fd hay que registrarlo: el hilo del kernel no tiene la tabla de fds. */
+    int rc=io_uring_register_files(&ring,&fd,1);
+    int usar_fijo = (rc==0);
+    for(int q=0;q<ROUNDS;q++){
+      double t0=now_ns();
+      for(long done=0;done<OPS;){
+        int batch=(OPS-done<DEPTH)?(int)(OPS-done):DEPTH;
+        for(int k=0;k<batch;k++){
+          struct io_uring_sqe *s=io_uring_get_sqe(&ring);
+          io_uring_prep_read(s,usar_fijo?0:fd,buf+k*BS,BS,(long)(((done+k)*7919)%nblk)*BS);
+          if(usar_fijo) s->flags|=IOSQE_FIXED_FILE;
+        }
+        io_uring_submit_and_wait(&ring,batch);
+        struct io_uring_cqe *c; unsigned h; int seen=0;
+        io_uring_for_each_cqe(&ring,h,c){ if(c->res<0) sink=c->res; seen++; }
+        io_uring_cq_advance(&ring,seen);
+        done+=batch;
+      }
+      r[q]=(now_ns()-t0)/(double)OPS;
+    }
+    report(usar_fijo?"io_uring SQPOLL (fd registrado)":"io_uring SQPOLL (fd normal)",r,ROUNDS,OPS);
+    io_uring_queue_exit(&ring);
+  } else printf("SQPOLL: no disponible (%s) — pide CAP_SYS_NICE\n",strerror(errno));
+
+  unlink(path); close(fd);
+  return 0;
+}
diff --git a/docs/evidencia/tasas-kernel-2026-08-29/connector.txt b/docs/evidencia/tasas-kernel-2026-08-29/connector.txt
new file mode 100644
index 00000000..46d80e9b
--- /dev/null
+++ b/docs/evidencia/tasas-kernel-2026-08-29/connector.txt
@@ -0,0 +1,20 @@
+# condiciones: 2026-08-29T19:27:32Z · 7.1.4-artix1-1 · load 1.25 1.30 1.93 · 4285 MiB libres · root
+# bench_connector — SDD 25 seccion 9, experimento 1
+
+### A. Latencia de notificacion: waitpid contra evento del connector
+BENCH (ns por proceso)                              min    mediana
+fork+_exit+waitpid (SIGCHLD, la base)          114825.2   123130.6   (n=200)
+fork+_exit+esperar EXIT del connector          116041.0   133773.5   (n=200)
+eventos EXIT que no llegaron en 200 ms: 0 de 1400
+
+### B. Ceguera: 200 procesos de vida minima, uno cada 10 ms
+sondeo /proc cada 100 ms : 0 de 200 procesos vistos  (23 barridos, 10.5 ms de CPU)
+proc connector (eventos)  : 200 de 200 procesos vistos  (95.4 ms de CPU)
+NOTA: el connector se lee aca con espera activa de 200 us, que NO es el modo de un
+      supervisor real (seria epoll) => su CPU es cota superior. Lo que cuenta: COBERTURA.
+
+### C. Estadisticas de UNA tarea: taskstats binario contra /proc de texto
+familia TASKSTATS = 41, cpu de este proceso = 198921000 ns
+BENCH (ns por consulta)                             min    mediana
+taskstats por genetlink (binario)                2688.1     2726.3   (n=2000)
+open+read+parse /proc/self/stat                  2696.7     2716.5   (n=2000)
diff --git a/docs/evidencia/tasas-kernel-2026-08-29/reflink.txt b/docs/evidencia/tasas-kernel-2026-08-29/reflink.txt
new file mode 100644
index 00000000..ce993f7f
--- /dev/null
+++ b/docs/evidencia/tasas-kernel-2026-08-29/reflink.txt
@@ -0,0 +1,34 @@
+# condiciones: 2026-08-29T19:29:16Z · 7.1.4-artix1-1 · load 1.30 1.30 1.87
+# xfsprogs mkfs.xfs version 7.1.1 · btrfs-progs mkfs.btrfs, part of btrfs-progs v7.1
+
+### copia de 64 MiB sobre ext4
+BENCH                                             min      mediana
+FICLONE (reflink entero)                 no soportado (Operation not supported)
+copy_file_range                             13.655 ms    15.013 ms       4914 MB/s
+read+write (1 MiB)                          14.455 ms    14.911 ms       4643 MB/s
+# xfs montado: xfs rw,relatime,inode64,logbufs=8,logbsize=32k,noquota
+
+### copia de 64 MiB sobre xfs (loop)
+BENCH                                             min      mediana
+FICLONE (reflink entero)                     0.010 ms     0.013 ms   (plano: no mueve datos)
+copy_file_range                              0.010 ms     0.010 ms   (plano: no mueve datos)
+read+write (1 MiB)                          10.964 ms    11.290 ms       6121 MB/s
+
+### copia de 512 MiB sobre xfs (loop), fichero 8x mas grande
+BENCH                                             min      mediana
+FICLONE (reflink entero)                     0.020 ms     0.021 ms   (plano: no mueve datos)
+copy_file_range                              0.019 ms     0.020 ms   (plano: no mueve datos)
+read+write (1 MiB)                         512.712 ms   600.930 ms       1047 MB/s
+# btrfs montado: btrfs rw,relatime,ssd,discard=async,space_cache=v2,subvolid=5,subvol=/
+
+### copia de 64 MiB sobre btrfs (loop)
+BENCH                                             min      mediana
+FICLONE (reflink entero)                     0.006 ms     0.014 ms   (plano: no mueve datos)
+copy_file_range                              0.006 ms     0.008 ms   (plano: no mueve datos)
+read+write (1 MiB)                          31.323 ms    32.181 ms       2143 MB/s
+
+### copia de 512 MiB sobre btrfs (loop), fichero 8x mas grande
+BENCH                                             min      mediana
+FICLONE (reflink entero)                     0.015 ms     0.020 ms   (plano: no mueve datos)
+copy_file_range                              0.015 ms     0.020 ms   (plano: no mueve datos)
+read+write (1 MiB)                         236.891 ms   533.540 ms       2266 MB/s
diff --git a/docs/evidencia/tasas-kernel-2026-08-29/sqpoll.txt b/docs/evidencia/tasas-kernel-2026-08-29/sqpoll.txt
new file mode 100644
index 00000000..cbbf17e5
--- /dev/null
+++ b/docs/evidencia/tasas-kernel-2026-08-29/sqpoll.txt
@@ -0,0 +1,13 @@
+# condiciones: 2026-08-29T19:30:07Z · 7.1.4-artix1-1 · load 2.23 1.61 1.95 · root
+
+### 4K aleatorios en cache sobre ext4 (profundidad 32)
+BENCH (ns/op)                                       min    mediana
+pread 4K (una syscall por op)                     554.4      590.2   (n=50000)
+io_uring sin SQPOLL                               617.7      633.8   (n=50000)
+io_uring SQPOLL (fd registrado)                   867.7     1068.6   (n=50000)
+
+### 4K aleatorios en cache sobre tmpfs (profundidad 32)
+BENCH (ns/op)                                       min    mediana
+pread 4K (una syscall por op)                     749.3      764.2   (n=50000)
+io_uring sin SQPOLL                              2029.6     2237.6   (n=50000)
+io_uring SQPOLL (fd registrado)                  1409.3     2296.8   (n=50000)
diff --git a/docs/evidencia/tasas-kernel-2026-08-29/syscalls-compilador.txt b/docs/evidencia/tasas-kernel-2026-08-29/syscalls-compilador.txt
new file mode 100644
index 00000000..c92d1aa9
--- /dev/null
+++ b/docs/evidencia/tasas-kernel-2026-08-29/syscalls-compilador.txt
@@ -0,0 +1,126 @@
+# condiciones: 2026-08-29T19:30:50Z · 7.1.4-artix1-1 · strace 6.19 DEL PROPIO CORPUS (store/3c1fd8c0…-strace)
+# fuente: hola.c — un main() con stdio/stdlib/string, o sea el caso MAS BARATO posible
+
+=== cc -O2 -c (gcc 16) ===
+/mnt/vvv/hammer/store/3c1fd8c0fbb20c272c2935d5b5ca63bc51be257c271e96e312ee86ed6886f89d-strace/usr/bin/strace: Process 17960 attached
+/mnt/vvv/hammer/store/3c1fd8c0fbb20c272c2935d5b5ca63bc51be257c271e96e312ee86ed6886f89d-strace/usr/bin/strace: Process 17971 attached
+% time     seconds  usecs/call     calls    errors syscall
+------ ----------- ----------- --------- --------- ----------------
+ 80.09    0.048227       24113         2           wait4
+  7.44    0.004479           4       923       919 readlink
+  3.00    0.001808          17       105           read
+  2.30    0.001387           6       228       127 openat
+  1.28    0.000772           8        92           mmap
+  1.02    0.000614          87         7         4 execve
+  0.87    0.000522           5       101           close
+  0.78    0.000470           4       100           fstat
+  0.77    0.000466         232         2           clone3
+  0.77    0.000463           6        67        24 newfstatat
+  0.37    0.000220           7        31           brk
+  0.27    0.000165           8        20           mprotect
+  0.17    0.000100           4        23        15 access
+  0.11    0.000065           3        19           rt_sigaction
+  0.10    0.000060          30         2           unlink
+  0.09    0.000056          18         3           getcwd
+  0.09    0.000056           5        11           prlimit64
+  0.09    0.000055           6         8           write
+  0.09    0.000053           3        14           rt_sigprocmask
+  0.07    0.000043           3        12           lseek
+  0.04    0.000026           3         7           getrandom
+  0.04    0.000022          11         2           munmap
+  0.04    0.000022           3         6         6 ioctl
+  0.02    0.000013           4         3           sysinfo
+  0.02    0.000011           3         3           rseq
+  0.02    0.000010           3         3           arch_prctl
+  0.02    0.000010           3         3           set_tid_address
+  0.02    0.000010           3         3           set_robust_list
+  0.01    0.000007           3         2           fcntl
+  0.01    0.000004           3         1           getrusage
+------ ----------- ----------- --------- --------- ----------------
+100.00    0.060214          33      1803      1095 total
+
+=== zig cc -O2 -c (zig 0.16.0) ===
+/mnt/vvv/hammer/store/3c1fd8c0fbb20c272c2935d5b5ca63bc51be257c271e96e312ee86ed6886f89d-strace/usr/bin/strace: Process 17979 attached
+/mnt/vvv/hammer/store/3c1fd8c0fbb20c272c2935d5b5ca63bc51be257c271e96e312ee86ed6886f89d-strace/usr/bin/strace: Process 17980 attached
+/mnt/vvv/hammer/store/3c1fd8c0fbb20c272c2935d5b5ca63bc51be257c271e96e312ee86ed6886f89d-strace/usr/bin/strace: Process 17984 attached
+/mnt/vvv/hammer/store/3c1fd8c0fbb20c272c2935d5b5ca63bc51be257c271e96e312ee86ed6886f89d-strace/usr/bin/strace: Process 17988 attached
+/mnt/vvv/hammer/store/3c1fd8c0fbb20c272c2935d5b5ca63bc51be257c271e96e312ee86ed6886f89d-strace/usr/bin/strace: Process 17989 attached
+/mnt/vvv/hammer/store/3c1fd8c0fbb20c272c2935d5b5ca63bc51be257c271e96e312ee86ed6886f89d-strace/usr/bin/strace: Process 17990 attached
+/mnt/vvv/hammer/store/3c1fd8c0fbb20c272c2935d5b5ca63bc51be257c271e96e312ee86ed6886f89d-strace/usr/bin/strace: Process 17993 attached
+/mnt/vvv/hammer/store/3c1fd8c0fbb20c272c2935d5b5ca63bc51be257c271e96e312ee86ed6886f89d-strace/usr/bin/strace: Process 18047 attached
+/mnt/vvv/hammer/store/3c1fd8c0fbb20c272c2935d5b5ca63bc51be257c271e96e312ee86ed6886f89d-strace/usr/bin/strace: Process 18053 attached
+/mnt/vvv/hammer/store/3c1fd8c0fbb20c272c2935d5b5ca63bc51be257c271e96e312ee86ed6886f89d-strace/usr/bin/strace: Process 18054 attached
+/mnt/vvv/hammer/store/3c1fd8c0fbb20c272c2935d5b5ca63bc51be257c271e96e312ee86ed6886f89d-strace/usr/bin/strace: Process 18055 attached
+/mnt/vvv/hammer/store/3c1fd8c0fbb20c272c2935d5b5ca63bc51be257c271e96e312ee86ed6886f89d-strace/usr/bin/strace: Process 18056 attached
+% time     seconds  usecs/call     calls    errors syscall
+------ ----------- ----------- --------- --------- ------------------
+ 69.79    1.378703        1248      1104        14 futex
+ 25.60    0.505698      101139         5           wait4
+  1.26    0.024957        2495        10           poll
+  0.69    0.013629          42       318        80 openat
+  0.33    0.006426          18       353           mmap
+  0.31    0.006187          38       162        43 newfstatat
+  0.18    0.003615          47        76           read
+  0.17    0.003425          54        63           pread64
+  0.17    0.003361          17       195           rt_sigprocmask
+  0.15    0.003003          12       245           close
+  0.13    0.002634          25       105        29 readlink
+  0.13    0.002511         179        14         8 execve
+  0.12    0.002410          15       159           fstat
+  0.12    0.002312          28        82           mprotect
+  0.09    0.001870         103        18           munmap
+  0.09    0.001743         435         4           clone
+  0.08    0.001520          27        56           brk
+  0.08    0.001497         748         2           mkdirat
+  0.07    0.001355          43        31        19 access
+  0.06    0.001176           4       254           preadv
+  0.06    0.001096          16        67           rt_sigaction
+  0.05    0.000936         117         8           clone3
+  0.03    0.000545          45        12           readv
+  0.02    0.000492          28        17           set_robust_list
+  0.02    0.000483          53         9         7 faccessat2
+  0.02    0.000430           6        69           statx
+  0.02    0.000353          25        14           write
+  0.02    0.000342          15        22           prlimit64
+  0.02    0.000297          22        13           rseq
+  0.01    0.000277          25        11           madvise
+  0.01    0.000256          32         8           pipe2
+  0.01    0.000247          19        13        13 ioctl
+  0.01    0.000242          16        15           getrandom
+  0.01    0.000210          30         7           sched_getaffinity
+  0.01    0.000155          25         6           dup2
+  0.01    0.000149          18         8           sigaltstack
+  0.01    0.000147          13        11           lseek
+  0.01    0.000134          22         6           getdents64
+  0.00    0.000088          29         3         1 unlinkat
+  0.00    0.000078          12         6           arch_prctl
+  0.00    0.000075          18         4           gettid
+  0.00    0.000073          12         6           set_tid_address
+  0.00    0.000060          29         2           rename
+  0.00    0.000048          16         3           ftruncate
+  0.00    0.000045          22         2           pwritev
+  0.00    0.000036          17         2           flock
+  0.00    0.000028          28         1           readlinkat
+  0.00    0.000022          22         1           renameat
+  0.00    0.000020          20         1           unlink
+  0.00    0.000016           5         3           sysinfo
+  0.00    0.000008           7         1           uname
+  0.00    0.000005           4         1           getcwd
+------ ----------- ----------- --------- --------- ------------------
+100.00    1.975424         547      3608       214 total
+
+=== reparto de fallos del gcc (ENOENT por buscar cabeceras) ===
+166
+
+=== tiempo de pared del MISMO compilado, sin strace (mínimo/mediana de 7) ===
+cc -O2 -c hola.c        min  30.5 ms   mediana  33.3 ms
+zig cc -O2 -c hola.c    min  53.6 ms   mediana  58.9 ms
+
+=== lectura ===
+gcc:    1803 syscalls, 1095 con error (61%) — 919 de 923 readlink FALLAN.
+        Al piso medido de 78,7 ns por syscall, 1803 cruces = 0,14 ms sobre 30,5 ms de compilado
+        => el cruce al kernel es el 0,5% del compilado. La tormenta de rutas de T8 vale
+        MILISEGUNDOS por invocación, no minutos.
+zig cc: 3608 syscalls, sólo 214 con error, pero 1104 futex (70% del tiempo EN syscall) y 5 wait4.
+        Su perfil no es de búsqueda de rutas sino de coordinación entre hilos; el tiempo de
+        syscall que reporta strace -c es espera BLOQUEADA, no CPU.