/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

/*
 * A test for the pollable events.
 *
 * A number of threads are in a ring configuration, each waiting on
 * a pollable event that is set by its upstream neighbor.
 */

#include "prinit.h"
#include "prio.h"
#include "prthread.h"
#include "prerror.h"
#include "prmem.h"
#include "prlog.h"
#include "prprf.h"

#include "plgetopt.h"

#include <stdlib.h>

#define DEFAULT_THREADS 10
#define DEFAULT_LOOPS 100

PRIntn numThreads = DEFAULT_THREADS;
PRIntn numIterations = DEFAULT_LOOPS;
PRIntervalTime dally = PR_INTERVAL_NO_WAIT;
PRFileDesc* debug_out = NULL;
PRBool debug_mode = PR_FALSE;
PRBool verbosity = PR_FALSE;

typedef struct ThreadData {
  PRFileDesc* event;
  int index;
  struct ThreadData* next;
} ThreadData;

void ThreadRoutine(void* arg) {
  ThreadData* data = (ThreadData*)arg;
  PRIntn i;
  PRPollDesc pd;
  PRInt32 rv;

  pd.fd = data->event;
  pd.in_flags = PR_POLL_READ;

  for (i = 0; i < numIterations; i++) {
    rv = PR_Poll(&pd, 1, PR_INTERVAL_NO_TIMEOUT);
    if (rv == -1) {
      PR_fprintf(PR_STDERR, "PR_Poll failed\n");
      exit(1);
    }
    if (verbosity) {
      PR_fprintf(debug_out, "thread %d awakened\n", data->index);
    }
    PR_ASSERT(rv != 0);
    PR_ASSERT(pd.out_flags & PR_POLL_READ);
    if (PR_WaitForPollableEvent(data->event) == PR_FAILURE) {
      PR_fprintf(PR_STDERR, "consume event failed\n");
      exit(1);
    }
    if (dally != PR_INTERVAL_NO_WAIT) {
      PR_Sleep(dally);
    }
    if (verbosity) {
      PR_fprintf(debug_out, "thread %d posting event\n", data->index);
    }
    if (PR_SetPollableEvent(data->next->event) == PR_FAILURE) {
      PR_fprintf(PR_STDERR, "post event failed\n");
      exit(1);
    }
  }
}

static void Help(void) {
  debug_out = PR_STDOUT;

  PR_fprintf(debug_out,
             "Usage: pollable [-c n] [-t n] [-d] [-v] [-G] [-C n] [-D n]\n");
  PR_fprintf(debug_out, "-c n\tloops at thread level (default: %d)\n",
             DEFAULT_LOOPS);
  PR_fprintf(debug_out, "-t n\tnumber of threads (default: %d)\n",
             DEFAULT_THREADS);
  PR_fprintf(debug_out, "-d\tturn on debugging output (default: FALSE)\n");
  PR_fprintf(debug_out, "-v\tturn on verbose output (default: FALSE)\n");
  PR_fprintf(debug_out, "-G\tglobal threads only (default: FALSE)\n");
  PR_fprintf(debug_out, "-C n\tconcurrency setting (default: 1)\n");
  PR_fprintf(debug_out, "-D n\tdally setting (msecs) (default: 0)\n");
} /* Help */

int main(int argc, char** argv) {
  ThreadData selfData;
  ThreadData* data;
  PRThread** thread;
  void* block;
  PRIntn i;
  PRIntervalTime timeStart, timeEnd;
  PRPollDesc pd;
  PRInt32 rv;
  PRThreadScope thread_scope = PR_LOCAL_THREAD;
  PRBool help = PR_FALSE;
  PRUintn concurrency = 1;
  PRUintn average;
  PLOptStatus os;
  PLOptState* opt;

  PR_STDIO_INIT();

  opt = PL_CreateOptState(argc, argv, "hdvc:t:C:GD:");
  while (PL_OPT_EOL != (os = PL_GetNextOpt(opt))) {
    if (PL_OPT_BAD == os) {
      continue;
    }
    switch (opt->option) {
      case 'v': /* verbose mode */
        verbosity = PR_TRUE;
      case 'd': /* debug mode */
        debug_mode = PR_TRUE;
        break;
      case 'c': /* loop counter */
        numIterations = atoi(opt->value);
        break;
      case 't': /* thread limit */
        numThreads = atoi(opt->value);
        break;
      case 'C': /* Concurrency limit */
        concurrency = atoi(opt->value);
        break;
      case 'G': /* global threads only */
        thread_scope = PR_GLOBAL_THREAD;
        break;
      case 'D': /* dally */
        dally = PR_MillisecondsToInterval(atoi(opt->value));
        break;
      case 'h': /* help message */
        Help();
        help = PR_TRUE;
        break;
      default:
        break;
    }
  }
  PL_DestroyOptState(opt);

  if (help) {
    return 1;
  }

  if (concurrency > 1) {
    PR_SetConcurrency(concurrency);
  }

  if (PR_TRUE == debug_mode) {
    debug_out = PR_STDOUT;
    PR_fprintf(debug_out, "Test parameters\n");
    PR_fprintf(debug_out, "\tThreads involved: %d\n", numThreads);
    PR_fprintf(debug_out, "\tIteration limit: %d\n", numIterations);
    PR_fprintf(debug_out, "\tConcurrency: %d\n", concurrency);
    PR_fprintf(debug_out, "\tThread type: %s\n",
               (PR_GLOBAL_THREAD == thread_scope) ? "GLOBAL" : "LOCAL");
  }

  /*
   * Malloc a block of memory and divide it into data and thread.
   */
  block = PR_MALLOC(numThreads * (sizeof(ThreadData) + sizeof(PRThread*)));
  if (block == NULL) {
    PR_fprintf(PR_STDERR, "cannot malloc, failed\n");
    exit(1);
  }
  data = (ThreadData*)block;
  thread = (PRThread**)&data[numThreads];

  /* Pollable event */
  selfData.event = PR_NewPollableEvent();
  if (selfData.event == NULL) {
    PR_fprintf(PR_STDERR, "cannot create event: (%ld, %ld)\n", PR_GetError(),
               PR_GetOSError());
    exit(1);
  }
  selfData.next = &data[0];
  for (i = 0; i < numThreads; i++) {
    data[i].event = PR_NewPollableEvent();
    if (data[i].event == NULL) {
      PR_fprintf(PR_STDERR, "cannot create event: (%ld, %ld)\n", PR_GetError(),
                 PR_GetOSError());
      exit(1);
    }
    data[i].index = i;
    if (i != numThreads - 1) {
      data[i].next = &data[i + 1];
    } else {
      data[i].next = &selfData;
    }

    thread[i] = PR_CreateThread(PR_USER_THREAD, ThreadRoutine, &data[i],
                                PR_PRIORITY_NORMAL, thread_scope,
                                PR_JOINABLE_THREAD, 0);
    if (thread[i] == NULL) {
      PR_fprintf(PR_STDERR, "cannot create thread\n");
      exit(1);
    }
  }

  timeStart = PR_IntervalNow();
  pd.fd = selfData.event;
  pd.in_flags = PR_POLL_READ;
  for (i = 0; i < numIterations; i++) {
    if (dally != PR_INTERVAL_NO_WAIT) {
      PR_Sleep(dally);
    }
    if (verbosity) {
      PR_fprintf(debug_out, "main thread posting event\n");
    }
    if (PR_SetPollableEvent(selfData.next->event) == PR_FAILURE) {
      PR_fprintf(PR_STDERR, "set event failed\n");
      exit(1);
    }
    rv = PR_Poll(&pd, 1, PR_INTERVAL_NO_TIMEOUT);
    if (rv == -1) {
      PR_fprintf(PR_STDERR, "wait failed\n");
      exit(1);
    }
    PR_ASSERT(rv != 0);
    PR_ASSERT(pd.out_flags & PR_POLL_READ);
    if (verbosity) {
      PR_fprintf(debug_out, "main thread awakened\n");
    }
    if (PR_WaitForPollableEvent(selfData.event) == PR_FAILURE) {
      PR_fprintf(PR_STDERR, "consume event failed\n");
      exit(1);
    }
  }
  timeEnd = PR_IntervalNow();

  if (debug_mode) {
    average = PR_IntervalToMicroseconds(timeEnd - timeStart) /
              (numIterations * numThreads);
    PR_fprintf(debug_out, "Average switch times %d usecs for %d threads\n",
               average, numThreads);
  }

  for (i = 0; i < numThreads; i++) {
    if (PR_JoinThread(thread[i]) == PR_FAILURE) {
      PR_fprintf(PR_STDERR, "join thread failed\n");
      exit(1);
    }
    PR_DestroyPollableEvent(data[i].event);
  }
  PR_DELETE(block);
  PR_DestroyPollableEvent(selfData.event);

  PR_fprintf(PR_STDOUT, "PASSED\n");
  return 0;
}
