---

deppmark_main.c

/***************************************************************************
                               deppmark_main.c
                             -------------------
    begin                : Tue Jan 15 19:19:41 CET 2002
    copyright            : (C) 2002 by Christian Hoenig & Gunter Ohrner
    email                : pdepp@customcdrom.de
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/


#include "pdeppd/common.h"


#ifdef HAVE_GETOPT_H
#  include <getopt.h>
#endif


#include <errno.h>
#include <netdb.h>
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#include "client.h"
#include "pdeppd/misc.h"
#include "pdeppd/xmalloc.h"
#include "pdeppd/bufplist.h"
#include "pdeppd/pthreadlist.h"
#include "deppmark.h"


int runLikeHell(char* file, unsigned num_of_users);


void printVersionText()
{
  printf("%s (%s) Version %s\n", BENCHNAME, PACKAGE, BENCHVERSION);
}


void printCopyright()
{
  printVersionText();
  printf("Copyright (C) 2002 Christian Hoenig & Gunter Ohrner <pdepp@CustomCDROM.de>\n"
         "%s comes with ABSOLUTELY NO WARRANTY. This is free software, and\n"
         "you are welcome to redistribute it under certain conditions.\n"
         "For more details see the GNU General Public License Version 2\n"
         "(http://www.gnu.org/copyleft/gpl.html).\n\n",
         PACKAGE);
}


void printHelpText(int briefHelp, char* argv_0)
{
  if (briefHelp)
  { //print brief info
    fprintf(stderr,
#ifdef HAVE_GETOPT_LONG
      "Try %s --help\n", argv_0
#else
      "Try %s -h\n", argv_0
#endif        
    );
  }
  else
  { //print long helptext
    printf(
      "Usage: %s [options]\n\n"
      "Options:\n"
#ifdef HAVE_GETOPT_LONG
//      "--benchmark    "
#endif
//     "-b        Benchmarking mode: disable all delays and run like hell...\n"
#ifdef HAVE_GETOPT_LONG
      "--file=file     "
#endif
      "-f file   Tells %s that <file> contains a list of files to be used in that test\n"
#ifdef HAVE_GETOPT_LONG
      "--help          "
#endif
      "-h        Prints this text\n"
#ifdef HAVE_GETOPT_LONG
      "--host=NAME     "
#endif
      "-H NAME   Tells %s to use NAME as destination host\n"
#ifdef HAVE_GETOPT_LONG
      "--delay=N       "
#endif
      "-d N      Virtual user pauses N / 10 sec between querys\n"
#ifdef HAVE_GETOPT_LONG
      "--port=N        "
#endif
      "-p N      Tells %s to use N as benchmarking destination port\n"
#ifdef HAVE_GETOPT_LONG
      "--repetitions=N "
#endif
      "-r N      Every VirtualUser repeats N times the whole URI-list\n"
#ifdef HAVE_GETOPT_LONG
      "--users=N       "
#endif
      "-u N      Sets the count of VirtualUsers to be simulated\n"
#ifdef HAVE_GETOPT_LONG
      "--version       "
#endif
      "-v        Prints version information and exits\n"
      ,
      argv_0,
      BENCHNAME,
      BENCHNAME,
      BENCHNAME);
  }
}




int main(int argc, char *argv[])
{
  int ret_val = EXIT_SUCCESS;
  int c;
  int size = 0;
  unsigned user = 1;
  char* file = NULL;
  struct hostent* host;
  long int tmp;

  // set some default values
  benchmark = false;
  delay = 1;
  repeat = 1;

  //temporary data for the commandline parameters
  
#ifndef NDEBUG
  fprintf(stderr, "\n\n!!! DEBUG mode enabled !!!\n\n");
#endif

  printCopyright();


  while (true)
  {
#ifdef HAVE_GETOPT_LONG
    int option_index = 0;
    static struct option long_options[] =
    {
      {"benchmark"              , 0, 0, 'b'},
      {"file"                   , 1, 0, 'f'},
      {"help"                   , 0, 0, 'h'},
      {"host"                   , 1, 0, 'H'},
      {"delay"                  , 1, 0, 'd'},
      {"port"                   , 1, 0, 'p'},
      {"repetitions"            , 1, 0, 'r'},
      {"users"                  , 1, 0, 'u'},
      {"version"                , 0, 0, 'v'},
      {0, 0, 0, 0}
    };
    c = getopt_long(argc, argv, "bf:hH:d:p:r:u:v", long_options, &option_index);
#else
    c = getopt(argc, argv,"bf:hH:d:p:r:u:v");
#endif
    //if no more parameters found, leave...
    if (c == -1)
      break;

    //check the commandline parameters:
    switch (c)
    {
    case('b'): //benchmark
      benchmark = true;
      break;
    case('f'): //file
      size = strlen(optarg)+1;
      file = (char*)pd_malloc(size);
      strcpy(file, optarg);
      break;
    case('h'): //help
      printHelpText(false,argv[0]);
      return EXIT_SUCCESS;
    case('H'): //host
      if ((host = gethostbyname(optarg)) == NULL)
      {
        fprintf(stderr, "Invalid Hostname / IP-Address given: %s\n", optarg);
        exit(EXIT_FAILURE);
      }

      host_addr.s_addr = *((unsigned long int*) (host->h_addr_list)[0]);

/*      if (inet_aton(test, &host_addr) == 0)
      {
        fprintf(stderr, "Invalid Hostname / IP-Address given: %s\n", optarg);
        exit(EXIT_FAILURE);
      }*/

      break;
    case('d'): // delay
      tmp = strtol(optarg, NULL, 10);
      if (tmp < 0)
      {
        fprintf(stderr, "Error: invalid delay value given: %u\n", delay);
        tmp = 1;
      }
      delay = (unsigned int) tmp;
      break;
    case('p'): //port
      tmp = strtol(optarg, NULL, 10);
      if (tmp < 0 || tmp > 65535)
      {
        fprintf(stderr, "Error: Invalid port given: %s\n", optarg);
        tmp = 1952;
      }
      port = htons((unsigned short) tmp);
      break;
    case('r'): // repetition
      repeat = strtol(optarg, NULL, 10);
      if (repeat <= 0)
      {
        fprintf(stderr, "Error: Invalid repetition value given: %s\n", optarg);
        repeat = 1;
      }
      break;
    case('u'): // user
      user = strtol(optarg, NULL, 10);
      if (user <= 0)
      {
        fprintf(stderr, "Error: Invalid number of users given: %s\n", optarg);
        user = 1;
      }
      break;
    case('v'): //version
//      printVersionText();
      return EXIT_SUCCESS;
    default:
      printHelpText(true,argv[0]);
      return EXIT_FAILURE;
    }
  }

  //start usersimulation/benchmarking here:
  ret_val = runLikeHell(file, user);


#ifndef NDEBUG
  // this is an unfreed malloc to see if mpatrol really is working *g*
  pd_malloc(1952);
#endif

  return ret_val;
}


int runLikeHell(char* file, unsigned num_of_users)
{
  unsigned cnt;
  char* line;
  size_t maxtmp;
  pthread_t thrd;
  PThreadList vclient_list;
  time_t start_time, duration;

  FILE* filep = fopen(file, "r");

  if (filep == NULL)
  {
    fprintf(stderr, "Error: URL file could not be opened: %s\n", strerror(errno));
    return -1;
  }

  puts("Starting benchmark...");

  file_list = bufpListInit();

  buf_len = 0;
  while ((line = getLine(filep)))
  {
    maxtmp = strlen(line);
    bufpListAppend(file_list, bufpInit(line, maxtmp, 0));
    buf_len = MAX(buf_len, maxtmp);
    if (feof(filep))
      break;
  }

  buf_len = MAX(4 + buf_len + 9 + 4 + 1, 1024);

  pthread_mutex_init(&malloc_mut, NULL);

  vclient_list = pthrdListInit();

  start_time = time(NULL);

  for(cnt = 1; cnt <= num_of_users; ++cnt)   /* this is pretty vv dirty vv but seems to work... */
    if (pthread_create(&thrd, NULL, (void*)virtualClient, (void*)cnt) == 0)
    {
#ifndef NDEBUG 
      printf("A new virtual client has been spawned successfully...\n");
#endif      
      pthrdListAppend(vclient_list, thrd);
    }
    else
      fprintf(stderr, "Error: Thread creation failed! %s\n", strerror(errno));

  pthrdListFirst(vclient_list);
  while(!pthrdListIsTail(vclient_list))
  {
    int* retval;
    thrd = pthrdListGetPayload(vclient_list);
    pthread_join(thrd, (void**) &retval);
    pthrdListDelete(vclient_list);
  }

  duration = time(NULL) - start_time;

  printf("The benchmark (%u users, %u 1/10 sec delay, %u repetitions) took\n"
         "%lu seconds wall time to complete.\n\n",
         num_of_users, delay, repeat, duration);

  pthrdListTerminate(vclient_list);

  return 0;
}

---