/* bench_extra.c — lo que las dos sorpresas piden aislar:
 *  a) coste de fork EN FUNCION del espacio de direcciones del padre
 *  b) contabilidad por cgroup v2 vs sumar /proc
 *  c) tasa del enlazado dinamico en el exec
 *  d) cierre de descriptores en el spawn  */
#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 <spawn.h>
#include <dirent.h>
#include <sched.h>
#include <sys/syscall.h>
#include <sys/wait.h>
#include <sys/mman.h>
#include <sys/stat.h>

extern char **environ;
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); }
#define ROUNDS 7
static void rep(const char*n,double*r,int c){ qsort(r,c,sizeof(double),cmpd);
  printf("%-44s %10.1f %10.1f\n",n,r[0],r[c/2]); fflush(stdout); }

static double *area=NULL; static long area_sz=0;
static void grow(long mb){
  if(area) munmap(area,area_sz);
  area_sz=mb*1024L*1024; if(mb==0){area=NULL;return;}
  area=mmap(0,area_sz,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANONYMOUS,-1,0);
  madvise(area,area_sz,MADV_NOHUGEPAGE);          /* tablas de paginas reales, no THP */
  for(long o=0;o<area_sz;o+=4096) ((char*)area)[o]=1;
}
static double t_fork(int n){ double t0=now_ns();
  for(int i=0;i<n;i++){ pid_t p=fork(); if(p==0)_exit(0); int st; waitpid(p,&st,0);} return (now_ns()-t0)/n/1000; }
static double t_vfork_exec(int n,const char*prog){ double t0=now_ns();
  for(int i=0;i<n;i++){ pid_t p=vfork(); if(p==0){char*a[]={(char*)prog,0};execve(prog,a,environ);_exit(127);} int st; waitpid(p,&st,0);} return (now_ns()-t0)/n/1000; }
static double t_fork_exec(int n,const char*prog){ double t0=now_ns();
  for(int i=0;i<n;i++){ pid_t p=fork(); if(p==0){char*a[]={(char*)prog,0};execve(prog,a,environ);_exit(127);} int st; waitpid(p,&st,0);} return (now_ns()-t0)/n/1000; }
static double t_spawn(int n,const char*prog){ double t0=now_ns();
  for(int i=0;i<n;i++){ pid_t p; char*a[]={(char*)prog,0}; if(posix_spawn(&p,prog,0,0,a,environ)==0){int st;waitpid(p,&st,0);} } return (now_ns()-t0)/n/1000; }

int main(int argc,char**argv){
  const char *sta = argc>1?argv[1]:"/bin/true";
  const char *dyn = argc>2?argv[2]:"/bin/true";
  printf("%-44s %10s %10s\n","BENCH (us/op)","min","mediana");
  printf("--- a) fork segun el espacio de direcciones del padre ---\n");
  long mbs[]={0,16,64,256};
  for(unsigned k=0;k<sizeof mbs/sizeof*mbs;k++){
    grow(mbs[k]); double r[ROUNDS],r2[ROUNDS],r3[ROUNDS];
    for(int q=0;q<ROUNDS;q++) r[q]=t_fork(150);
    for(int q=0;q<ROUNDS;q++) r2[q]=t_fork_exec(120,sta);
    for(int q=0;q<ROUNDS;q++) r3[q]=t_spawn(120,sta);
    char n1[80],n2[80],n3[80];
    snprintf(n1,sizeof n1,"  padre %3ld MB tocados: fork+_exit",mbs[k]);
    snprintf(n2,sizeof n2,"  padre %3ld MB tocados: fork+exec",mbs[k]);
    snprintf(n3,sizeof n3,"  padre %3ld MB tocados: posix_spawn(CLONE_VFORK)",mbs[k]);
    rep(n1,r,ROUNDS); rep(n2,r2,ROUNDS); rep(n3,r3,ROUNDS); }
  grow(0);

  printf("--- c) tasa del enlazado dinamico en exec ---\n");
  { double r[ROUNDS]; for(int q=0;q<ROUNDS;q++) r[q]=t_vfork_exec(150,sta); rep("  vfork+exec binario ESTATICO",r,ROUNDS);
    for(int q=0;q<ROUNDS;q++) r[q]=t_vfork_exec(150,dyn); rep("  vfork+exec binario DINAMICO",r,ROUNDS); }

  printf("--- d) cierre de descriptores antes del exec ---\n");
  { int base=open("/dev/null",O_RDONLY); int fds[512]; for(int i=0;i<512;i++) fds[i]=dup(base);
    double r[ROUNDS];
    for(int q=0;q<ROUNDS;q++){ double t0=now_ns(); for(int i=0;i<512;i++){int f=dup(base); close(f);} r[q]=(now_ns()-t0)/512/1000; }
    rep("  dup+close x512, uno a uno (us/fd)",r,ROUNDS);
    for(int q=0;q<ROUNDS;q++){ int a[512]; for(int i=0;i<512;i++) a[i]=dup(base);
      double t0=now_ns(); sink=syscall(SYS_close_range,a[0],a[511],0); r[q]=(now_ns()-t0)/512/1000; }
    rep("  close_range(lo,hi) (us/fd)",r,ROUNDS);
    for(int i=0;i<512;i++) close(fds[i]); close(base); }

  printf("--- b) contabilidad: cgroup v2 vs sumar /proc ---\n");
  { char cg[512]="", path[600]; FILE*f=fopen("/proc/self/cgroup","r");
    if(f){ char line[512]; while(fgets(line,sizeof line,f)){ char*p=strstr(line,"0::"); if(p){ p+=3; p[strcspn(p,"\n")]=0; snprintf(cg,sizeof cg,"/sys/fs/cgroup%s",p);} } fclose(f);} 
    if(cg[0]){ printf("  cgroup: %s\n",cg);
      const char*campos[]={"cpu.stat","memory.current","pids.current"};
      double r[ROUNDS];
      for(int q=0;q<ROUNDS;q++){ int N=2000; double t0=now_ns();
        for(int i=0;i<N;i++){ for(int c=0;c<3;c++){ snprintf(path,sizeof path,"%s/%s",cg,campos[c]);
            int fd=open(path,O_RDONLY); if(fd<0)continue; char b[512]; sink=read(fd,b,sizeof b); close(fd);} }
        r[q]=(now_ns()-t0)/N/1000; }
      rep("  leer cpu.stat+memory.current+pids.current",r,ROUNDS);
    } else printf("  sin cgroup v2 legible\n"); }
  return 0;
}