Necesita algo que sea más rápido que "wc -l"

Para un archivo realmente grande como 1GB wc -lresulta ser lento. ¿Tenemos una forma más rápida de calcular el número de líneas nuevas para un archivo en particular?

Puedes intentar escribir en C:

#include <unistd.h>
#include <stdio.h>
#include <string.h>
int main(){
  char buf[BUFSIZ];
  int nread;
  size_t nfound=0;
  while((nread=read(0, buf, BUFSIZ))>0){
    char const* p;
    for(p=buf; p=memchr(p,'\n',nread-(p-buf)); nfound++,p++) {;}
  }
  if(nread<0) { perror("Error"); return 1; }
  printf("%lu\n", nfound);
  return 0;
}

Guardar en, por ejemplo, wcl.ccompilar, por ejemplo, con gcc wcl.c -O2 -o wcly ejecutar con

<yourFile ./wcl

Esto encuentra nuevas líneas esparcidas en un archivo de 1 GB en mi sistema en aproximadamente 370 ms ( ejecuciones repetidas). (Aumentar el tamaño del búfer aumenta ligeramente el tiempo, lo cual es de esperar; BUFSIZ debería estar cerca de lo óptimo). Esto es muy comparable a los ~ 380 ms que estoy obteniendo wc -l.

Mmaping me da un mejor tiempo de aproximadamente 280 ms , pero por supuesto tiene la limitación de estar limitado a archivos reales (sin FIFOS, sin entrada de terminal, etc.):

#include <stdio.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
int main(){
  struct stat sbuf;
  if(fstat(0, &sbuf)<0){ perror("Can't stat stdin"); return 1; }

  char* buf = mmap(NULL, sbuf.st_size, PROT_READ, MAP_PRIVATE, 0/*stdin*/, 0/*offset*/);
  if(buf == MAP_FAILED){ perror("Mmap error"); return 1; } 

  size_t nread = sbuf.st_size, nfound=0;
  char const* p;
  for(p=buf; p=memchr(p,'\n',nread-(p-buf)); nfound++,p++) {;}

  printf("%lu\n", nfound);
  return 0;
}

Creé mi archivo de prueba con:

 $ dd if=/dev/zero of=file bs=1M count=1042 

y agregó algunas nuevas líneas de prueba con:

 $ echo >> 1GB 

y un editor hexadecimal.

Puede mejorar la solución sugerida por @pskocik reduciendo el número de llamadas a read. Hay muchas llamadas para leer BUFSIZfragmentos de un archivo de 1 Gb. El enfoque habitual para hacerlo es aumentar el tamaño del búfer:

• solo por diversión, intente aumentar el tamaño del búfer en un factor de 10. O 100. En mi Debian 7, BUFSIZes 8192. Con el programa original, eso es 120 mil operaciones de lectura. Probablemente pueda permitirse un búfer de entrada de 1Mb para reducir eso en un factor de 100.
• Para un enfoque más óptimo, las aplicaciones pueden asignar un búfer tan grande como el archivo, lo que requiere una sola operación de lectura. Eso funciona lo suficientemente bien para archivos "pequeños" (aunque algunos lectores tienen más de 1 Gb en su máquina).
• finalmente, podría experimentar con E / S mapeadas en memoria, que maneja la asignación como tal.

Al realizar una evaluación comparativa de los diversos enfoques, debe tener en cuenta que algunos sistemas (como Linux) utilizan la mayor parte de la memoria no utilizada de su máquina como caché de disco. Hace un tiempo (hace casi 20 años, mencionado en las preguntas frecuentes viles ), me sorprendieron los resultados inesperadamente buenos de un algoritmo de paginación (no muy bueno) que había desarrollado para manejar condiciones de poca memoria en un editor de texto. Me explicaron que funcionaba rápido porque el programa funcionaba desde las memorias intermedias utilizadas para leer el archivo, y que solo si el archivo se volvía a leer o escribir, habría una diferencia en la velocidad.

Lo mismo se aplica a mmap(en otro caso aún en mi lista de tareas pendientes para incorporar a un FAQ, un desarrollador reportó muy buenos resultados en un escenario donde la memoria caché del disco fue la razón real para mejorar). El desarrollo de puntos de referencia requiere tiempo y cuidado para analizar las razones del buen (o mal) desempeño.

Otras lecturas:

• ¿Es útil usar un buffer más grande?
• mmap () vs. bloques de lectura
• mmap, munmap: asigna o desasigna archivos o dispositivos en la memoria (muestra un programa de muestra)
• 13.7 E / S mapeadas en memoria (The GNU C Library)
• Cómo purgar cachés de E / S de disco en Linux
• ¿Cómo se vacían las memorias intermedias y el caché en un sistema Linux?