MrX

// Compile with -lpthread
// Written by Cl�o Saulnier
#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>
#include <fcntl.h>
#include <string.h>
#include <pthread.h>
#include <errno.h>
#include <sys/time.h>

#define BUFFER_SIZE 32*1024

class CStopWatch
{
   private:
      typedef struct {
         timeval start;
         timeval stop;
      } stopWatch;
      stopWatch timer;
   public:
      void startTimer( ) { gettimeofday(&(timer.start),0); }
      void stopTimer( ) { gettimeofday(&(timer.stop),0); }
      double getElapsedTime()
      {
         timeval res;
         timersub(&(timer.stop),&(timer.start),&res);
         return res.tv_sec + res.tv_usec/1000000.0;
      }
};

// Thread stuff
int threadID;
int threadPID;
char threadStack[64*1024];

// Buffer
struct timeval tm;
volatile unsigned char *buffer1;
volatile unsigned char *buffer2;
volatile unsigned int *b1;
volatile unsigned int *b2;
volatile int rd2;
volatile int rd1;

// Communication between threads.
int pipe1[2];
int pipe2[2];

// Write to pipe1
// Read from pipe2
int processfile(void *arg)
{
  struct timeval tm2;
  fd_set fds2;
  FD_ZERO(&fds2);
  FD_SET(pipe2[0],&fds2);

  int count[256];
  memset(count,0,256*sizeof(int));

  for(;;)
  {
    // Wait on pipe2
    // Wait until data ready.
    char d;
    int st = read(pipe2[0],&d,1);
    if (st!=1) return 2;

    if (d==0) return 2;
    if (d==2) break;

    // Process input buffer.
    int rdd = rd1;  // Read it in to avoid volatile property.
    int cnt = rdd>>2;
    unsigned int *ptr = (unsigned int*)b1;
    for(register int i=0;i<cnt;i++)
    {
      register int a = *ptr++;
      count[a&255]++;
      count[(a>>8)&255]++;
      count[(a>>16)&255]++;
      count[(a>>24)&255]++;
    }

    // Send that we are ready.
    d = 1;
    write(pipe1[1],&d,1);
  }

  // Print the results.
  int total = 0;
  for(int i='A';i<='Z';i++)
  {
    count[i]+=count[i-'A'+'a'];
    total+=count[i];
  }
  double dtotal = ((double)total)/100.0;
  for(int i='A';i<='Z';i++)
  {
    printf("%c: %.3f%% %d\n",(unsigned char)i,((double)count[i])/dtotal,count[i]);
  }
  printf("total: %d\n",total);

  return 0;
}

int main(int argc, char **argv)
{
  clock_t const start = clock();
  CStopWatch s;
  s.startTimer();
  // Check if filename given.
  if (argc!=2)
  {
    printf("No filename.\n");
    return 1;
  }

  int pid;

  pipe(pipe1);
  pipe(pipe2);

  memset(&tm,0,sizeof(timeval));

  // Spawn thread that will count the data.
  threadID = 1;

  if (0!=pthread_create((pthread_t*)&pid,NULL,(void* (*)(void*))&processfile,(void*)&threadID))
  {
    printf("Error creating thread.\n");
    if (errno==EAGAIN)
    {
      printf("Too many processes.\n");
    }
    else if (errno==ENOMEM)
    {
      printf("Out of memory.\n");
    }
    return 4;
  }
  else
  {
    threadPID = pid;
  }

  // Open file
  int fd = open(argv[1], O_RDONLY, 0);
  if (fd==-1)
  {
    printf("Cannot open file %s.\n",argv[1]);
    char d = 0;
    write(pipe2[1],&d,1);
    int exitcode;
    pthread_join(threadPID,(void**)&exitcode);
    return 2;
  }

  // fd_set for select()
  fd_set fds,fds2;
  FD_ZERO(&fds2);
  FD_SET(pipe1[0],&fds2);

  // Allocate memory to use for buffer.
  unsigned char *buffer = new unsigned char[(BUFFER_SIZE)*2];
  buffer1 = buffer;
  buffer2 = buffer+(BUFFER_SIZE);
  b1 = (unsigned int*)buffer;
  b2 = (unsigned int*)buffer2;

  // start reading
  rd1 = read(fd, (void*)buffer1, BUFFER_SIZE);
  if (rd1==-1)
  {
    // Read error
    close(fd);
    delete[] buffer;
    printf("Read error.\n");
    fflush(stdout);
    char d = 0;
    write(pipe2[1],&d,1);
    int exitcode;
    pthread_join(threadPID,(void**)&exitcode);
    return 3;
  }

  // Send ok to read.
  char d = rd1?1:2;
  write(pipe2[1],&d,1);

  while(rd1 > 0)
  {
    // Start reading next group
    rd2 = read(fd,(void*)buffer2,BUFFER_SIZE);
    if (rd2==-1)
    {
      // Read error
      printf("Read error.\n");
      char d = 0;
      write(pipe2[1],&d,1);
      int exitcode;
      pthread_join(threadPID,(void**)&exitcode);
      close(pipe1[0]);
      close(pipe1[1]);
      close(pipe2[0]);
      close(pipe2[1]);
      close(fd);
      delete[] buffer;
      return 3;
    }
    // Blank end of buffer if necessary so that our stats don't get messed up.
    if (rd2&3)
    {
      int rd3 = 4-(rd2&3);
      for(int i=0;i<rd3;i++)
      {
        buffer2[rd2+i] = '\0';
      }
      rd2+=4;
      rd2&=~3;
    }

    // read
    char d;
    int st = read(pipe1[0],&d,1);
    if (st!=1)
    {
      // Pipe error
      printf("Pipe error.\n");
      fflush(stdout);
      char d = 0;
      write(pipe2[1],&d,1);
      int exitcode;
      pthread_join(threadPID,(void**)&exitcode);
      close(pipe1[0]);
      close(pipe1[1]);
      close(pipe2[0]);
      close(pipe2[1]);
      close(fd);
      delete[] buffer;
      return 3;
    }

    if (d==0) break;

    // Swap buffers.
    unsigned char *b = (unsigned char*)buffer1;
    buffer1 = buffer2;
    buffer2 = b;
    unsigned int *bb = (unsigned int*)b1;
    b1 = b2;
    b2 = bb;
    int rr = rd1;
    rd1 = rd2;
    rd2 = rr;

    // report back that buffer1 is ready to be processed.
    d = rd1?1:2;
    write(pipe2[1],&d,1);
  }

  int exitcode;
  pthread_join(threadPID,(void**)&exitcode);

  delete[] buffer;
  close(fd);
  close(pipe1[0]);
  close(pipe1[1]);
  close(pipe2[0]);
  close(pipe2[1]);

  s.stopTimer();
  printf("Total runtime: %f seconds\n",s.getElapsedTime());

  clock_t const end = clock();
  printf("Execution time only: %f seconds\n",(((double)end - (double)start) / CLOCKS_PER_SEC));

  return 0;
}