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