/*

 * LIBOIL - Library of Optimized Inner Loops

 * Copyright (c) 2003,2004 David A. Schleef <ds@schleef.org>

 * All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 * 

 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR

 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,

 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES

 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR

 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,

 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING

 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

 * POSSIBILITY OF SUCH DAMAGE.

 */

//Portions Copyright (c)  2008-2009 Nokia Corporation and/or its subsidiary(-ies). All rights reserved. 

#ifdef HAVE_CONFIG_H

#include <config.h>

#endif

#include <liboil/liboilprofile.h>

#include <liboil/liboildebug.h>

#ifdef HAVE_SYS_TIME_H

#include <sys/time.h>

#endif

#include <time.h>

#include <string.h>

#include <math.h>

#ifdef __SYMBIAN32__

#ifdef __ARMCC__

#pragma diag_remark 68

#endif//__ARMCC__

#endif//__SYMBIAN32__

/**

 * SECTION:liboilprofile

 * @title:OilProfile

 * @short_description:

 * Measuring the length of time needed to execute Liboil functions.

 *

 */

/**

 * oil_profile_init:

 * @prof: the OilProfile structure

 *

 * Initializes a profiling structure.

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

void

oil_profile_init (OilProfile *prof)

{

  memset(prof, 0, sizeof(OilProfile));

  prof->min = -1;

}

/**

 * oil_profile_stop_handle:

 * @prof: the OilProfile structure

 *

 * Handles post-processing of a single profiling run.

 *

 * FIXME: need more info

 */

 #ifdef __SYMBIAN32__

EXPORT_C

#endif

void

oil_profile_stop_handle (OilProfile *prof)

{

  int i;

  prof->last = prof->stop - prof->start;

  prof->total += prof->last;

  prof->n++;

  if (prof->last < prof->min) prof->min = prof->last;

  for(i=0;i<prof->hist_n;i++) {

    if (prof->last == prof->hist_time[i]) {

      prof->hist_count[i]++;

      break;

    }

  }

  if (i == prof->hist_n && prof->hist_n < OIL_PROFILE_HIST_LENGTH) {

    prof->hist_time[prof->hist_n] = prof->last;

    prof->hist_count[prof->hist_n] = 1;

    prof->hist_n++;

  }

}

/**

 * oil_profile_get_ave_std:

 * @prof: the OilProfile structure

 * @ave_p: pointer to average

 * @std_p: pointer to standard deviation

 *

 * Calculates the average and standard deviation of a number of

 * profiling runs, and places the results in the locations

 * provided by @ave_p and @std_p.  Either @ave_p and @std_p may

 * be NULL, in which case the values will not be written.

 */

 #ifdef __SYMBIAN32__

EXPORT_C

#endif

void

oil_profile_get_ave_std (OilProfile *prof, double *ave_p, double *std_p)

{

  double ave;

  double std;

  int max_i;

  double off;

  double s;

  double s2;

  int i;

  int n;

  double x;

  do {

    s = s2 = 0;

    n = 0;

    max_i = -1;

    for(i=0;i<10;i++){

      x = prof->hist_time[i];

      s2 += x * x * prof->hist_count[i];

      s += x * prof->hist_count[i];

      n += prof->hist_count[i];

      if (prof->hist_count[i] > 0) {

        if (max_i == -1 || prof->hist_time[i] > prof->hist_time[max_i]) {

          max_i = i;

        }

      }

    }

    ave = s / n;

    std = sqrt (s2 - s * s / n + n*n) / (n-1);

    off = (prof->hist_time[max_i] - ave)/std;

    if (off > 4.0) {

      prof->hist_count[max_i] = 0;

    }

  } while (off > 4.0);

  if (ave_p) *ave_p = ave;

  if (std_p) *std_p = std;

}

unsigned long (*_oil_profile_stamp)(void);

/**

 * oil_profile_stamp:

 *

 * Creates a timestamp based on a CPU-specific high-frequency

 * counter, if available.

 *

 * Returns: a timestamp

 */

 #ifdef __SYMBIAN32__

EXPORT_C

#endif

unsigned long

oil_profile_stamp (void)

{

  return _oil_profile_stamp();

}