/*
 **********************************************************************************
 *
 * Project         : Imagine
 * File            : perfos.c
 * Version         : $Id$
 * Author          : Patrick LECOANET
 * Created On      : 
 * Purpose         : Implementation of perf.
 *
 **********************************************************************************
 */

/*
 *----------------- Distribution and Copyright --------------------------
 *
 * This software is copyright by the CENA/DGAC/FRANCE
 * All rights reserved.
 *
 * No part of the material protected by this copyright notice
 * may be reproduced or utilized for commercial use in any form
 * without written permission of the copyright owner.
 *
 * It may be reproduced or utilized for R&D use in Non Profit
 * Organization.
 *
 *-----------------------------------------------------------------------
 */


/*
 *----------------- Disclaimer ------------------------------------------
 *
 * This software and its documentation are provided "AS IS" and
 * without any expressed or implied warranties whatsoever.
 * No warranties as to performance, merchantability, or fitness
 * for a particular purpose exist.
 *
 * Because of the diversity of conditions and hardware under
 * which this software may be used, no warranty of fitness for
 * a particular purpose is offered.  The user is advised to
 * test the software thoroughly before relying on it.  The user
 * must assume the entire risk and liability of using this
 * software.
 *
 * In no event shall any person or organization of people be
 * held responsible for any direct, indirect, consequential
 * or inconsequential damages or lost profits.
 *
 *-----------------------------------------------------------------------
 */


/*
 **********************************************************************************
 *
 * Incuded files.
 *
 **********************************************************************************
 */

#include "perfos.h"
#include "List.h"


/*
 **********************************************************************************
 *
 * Constants.
 * 
 **********************************************************************************
 */

static const char rcsid[] = "$Id$";


#ifdef PERFOS


static RadarList	Chronos = NULL;

/*
 **********************************************************************************
 *
 * HardwareSynchronize - Synchronise Xwindow.
 *
 **********************************************************************************
 */
static void
HardwareSynchronize(Display *test_display, Drawable test_window)
{
  XImage   *image;

  /* Synchronize yourself with the drawing engine by sending a
     XGetImage one pixel square. */

  image = XGetImage(test_display, test_window, 0, 0, 1, 1, ~0, ZPixmap);
  XDestroyImage(image);
}


/*
 **********************************************************************************
 *
 * GetUCTime - Return machine time. This is the sum of user and system
 *	times for the process so far.
 *
 **********************************************************************************
 */
static long
GetUCTime(void)
{
  struct tms	time;

  times(&time);
  return time.tms_utime + time.tms_stime;
}


/*
 **********************************************************************************
 *
 * GetCurrentTime - Return current time.
 *
 **********************************************************************************
 */
static long
GetCurrentTime(void)
{
  struct timeval start;

  gettimeofday(&start, NULL);
  return((start.tv_sec * 100) + (start.tv_usec / 10000));
}


/*
 **********************************************************************************
 *
 * XGetCurrentTime - return current time after Xwindow synchronize.
 *
 **********************************************************************************
 */
static long
XGetCurrentTime(Display *display, Drawable window)
{
  HardwareSynchronize(display, window);
  return(GetCurrentTime());
}


/*
 **********************************************************************************
 *
 * XCorrectionValue - Evaluate the correction value to apply
 *                    to counter the client-server round trip
 *		      time.
 *
 **********************************************************************************
 */
static long
XCorrectionValue(Display *display, Drawable window)
{ 
  int               i;
  long              start, stop;

  start = GetCurrentTime();
  for (i = 0; i < 5; i++) {
    HardwareSynchronize(display, window);
  }
  stop = GetCurrentTime();
  return((stop - start) / 5);
}

/*
 **********************************************************************************
 *
 * XStartChrono - Start a perf chrono with X synchronize.
 *
 **********************************************************************************
 */
void
XStartChrono(Chrono chrono, Display *display, Drawable window)
{
  chrono->current_correction = XCorrectionValue(display, window);
  chrono->current_delay = XGetCurrentTime(display, window);
}


/*
 **********************************************************************************
 *
 * XStopChrono - Stop a perf chrono with X synchronize.
 *
 **********************************************************************************
 */
void
XStopChrono(Chrono chrono, Display *display, Drawable window)
{
  chrono->total_delay = chrono->total_delay +
    (XGetCurrentTime(display, window) - 
     chrono->current_delay - chrono->current_correction);
  chrono->actions++;
}


/*
 **********************************************************************************
 *
 * StartChrono - Start a perf chrono in user time.
 *
 **********************************************************************************
 */
void
StartChrono(Chrono chrono)
{
  chrono->current_delay = GetCurrentTime();
}


/*
 **********************************************************************************
 *
 * StopChrono - Stop a perf chrono in user time.
 *
 **********************************************************************************
 */
void
StopChrono(Chrono chrono)
{
  chrono->total_delay = chrono->total_delay + (GetCurrentTime() - chrono->current_delay);
  chrono->actions++;
}


/*
 **********************************************************************************
 *
 * StartUCChrono - Start a perf chrono in uc time.
 *
 **********************************************************************************
 */
void
StartUCChrono(Chrono chrono)
{
  chrono->current_delay = GetUCTime();
}


/*
 **********************************************************************************
 *
 * StopUCChrono - Stop a perf chrono in uc time.
 *
 **********************************************************************************
 */
void
StopUCChrono(Chrono chrono)
{
  chrono->total_delay = chrono->total_delay + (GetUCTime() - chrono->current_delay);
  chrono->actions++;
}


/*
 **********************************************************************************
 *
 * PrintChronos - Print the currently available stats on all
 *                chronos registered so far.
 *
 **********************************************************************************
 */
void
PrintChronos(void)
{
  int		i, cnt;
  Chrono	*chrs;
  
  cnt = RadarListSize(Chronos);
  chrs = (Chrono *) RadarListArray(Chronos);
  for (i = 0; i < cnt; i++) {
    if (chrs[i]->actions != 0) {
      printf("%s : %d ms on %d times\n",
             chrs[i]->message,
             chrs[i]->total_delay * 10 / chrs[i]->actions,
             chrs[i]->actions);
    }
  }
}


/*
 **********************************************************************************
 *
 * ResetChronos - Reset all chronos registered so far.
 *
 **********************************************************************************
 */
void
RazChronos(void)
{
  int		i, cnt;
  Chrono	*chrs;

  cnt = RadarListSize(Chronos);
  chrs = (Chrono *) RadarListArray(Chronos);
  for (i = 0; i < cnt; i++) {
    chrs[i]->actions = 0;
    chrs[i]->total_delay = 0;
  }
}


/*
 **********************************************************************************
 *
 * NewChrono - Return a new initialized chrono associated with
 *             message.
 *
 **********************************************************************************
 */
Chrono
NewChrono(char *message)
{
  Chrono	new;

  if (!Chronos) {
    Chronos = RadarListNew(8, sizeof(Chrono));
  }

  new = (Chrono) malloc(sizeof(ChronoRec));
  new->actions = 0;
  new->total_delay = 0;
  new->message = message;

  RadarListAdd(Chronos, &new, RadarListTail);

  return new;
}

/*
 **********************************************************************************
 *
 * FreeChrono - Free the resources of a chrono.
 *
 **********************************************************************************
 */
void
FreeChrono(Chrono	chrono)
{
  free(chrono);

  RadarListDelete(Chronos, RadarListHead, &chrono);
}

#endif	/* PERFOS */