/* 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;
}