|
|
|
@ -13,39 +13,39 @@ char *
|
|
|
|
random_string(unsigned length)
|
|
|
|
random_string(unsigned length)
|
|
|
|
{
|
|
|
|
{
|
|
|
|
|
|
|
|
|
|
|
|
char *state = (char *) malloc(sizeof(char) * STATES);
|
|
|
|
char *state = (char *) malloc(sizeof(char) * STATES);
|
|
|
|
char *result = (char *) malloc(length + 1);
|
|
|
|
char *result = (char *) malloc(length + 1);
|
|
|
|
int i, number;
|
|
|
|
int i, number;
|
|
|
|
unsigned seed = (unsigned) time((time_t *) NULL);
|
|
|
|
unsigned seed = (unsigned) time((time_t *) NULL);
|
|
|
|
|
|
|
|
|
|
|
|
/* printf ("Seed is %u\n", seed); */
|
|
|
|
/* printf ("Seed is %u\n", seed); */
|
|
|
|
|
|
|
|
|
|
|
|
/* Initialize random generator */
|
|
|
|
/* Initialize random generator */
|
|
|
|
(void) initstate(seed, state, STATES);
|
|
|
|
(void) initstate(seed, state, STATES);
|
|
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < length; i++) {
|
|
|
|
for (i = 0; i < length; i++) {
|
|
|
|
number = (random() % 94) + 33;
|
|
|
|
number = (random() % 94) + 33;
|
|
|
|
/* printf ("Number for %d is %d\n", i, number); */
|
|
|
|
/* printf ("Number for %d is %d\n", i, number); */
|
|
|
|
result[i] = (char) number;
|
|
|
|
result[i] = (char) number;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
result[length] = '\0';
|
|
|
|
result[length] = '\0';
|
|
|
|
|
|
|
|
|
|
|
|
/* printf ("Result is %s\n", result); */
|
|
|
|
/* printf ("Result is %s\n", result); */
|
|
|
|
|
|
|
|
|
|
|
|
return result;
|
|
|
|
return result;
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
char *
|
|
|
|
char *
|
|
|
|
to_upper(char *input)
|
|
|
|
to_upper(char *input)
|
|
|
|
{
|
|
|
|
{
|
|
|
|
int c;
|
|
|
|
int c;
|
|
|
|
char *result;
|
|
|
|
char *result;
|
|
|
|
result = (char *) malloc(strlen(input));
|
|
|
|
result = (char *) malloc(strlen(input));
|
|
|
|
for (c = 0; c < strlen(input); c++)
|
|
|
|
for (c = 0; c < strlen(input); c++)
|
|
|
|
result[c] = toupper((int)input[c]);
|
|
|
|
result[c] = toupper((int) input[c]);
|
|
|
|
result[strlen(input)] = '\0';
|
|
|
|
result[strlen(input)] = '\0';
|
|
|
|
return result;
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
/*
|
|
|
|
@ -54,91 +54,91 @@ to_upper(char *input)
|
|
|
|
*/
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
void
|
|
|
|
tvsub(out, in)
|
|
|
|
tvsub(out, in)
|
|
|
|
struct timeval *out, *in;
|
|
|
|
struct timeval *out, *in;
|
|
|
|
{
|
|
|
|
{
|
|
|
|
if ((out->tv_usec -= in->tv_usec) < 0) {
|
|
|
|
if ((out->tv_usec -= in->tv_usec) < 0) {
|
|
|
|
--out->tv_sec;
|
|
|
|
--out->tv_sec;
|
|
|
|
out->tv_usec += 1000000;
|
|
|
|
out->tv_usec += 1000000;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
out->tv_sec -= in->tv_sec;
|
|
|
|
out->tv_sec -= in->tv_sec;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* tvadd -- Adds 2 timeval structs: out = out + in. */
|
|
|
|
/* tvadd -- Adds 2 timeval structs: out = out + in. */
|
|
|
|
void
|
|
|
|
void
|
|
|
|
tvadd(out, in)
|
|
|
|
tvadd(out, in)
|
|
|
|
struct timeval *out, *in;
|
|
|
|
struct timeval *out, *in;
|
|
|
|
{
|
|
|
|
{
|
|
|
|
if ((out->tv_usec += in->tv_usec) >= 1000000) {
|
|
|
|
if ((out->tv_usec += in->tv_usec) >= 1000000) {
|
|
|
|
++out->tv_sec;
|
|
|
|
++out->tv_sec;
|
|
|
|
out->tv_usec -= 1000000;
|
|
|
|
out->tv_usec -= 1000000;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
out->tv_sec += in->tv_sec;
|
|
|
|
out->tv_sec += in->tv_sec;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* tvavg -- Averages a timeval struct */
|
|
|
|
/* tvavg -- Averages a timeval struct */
|
|
|
|
void
|
|
|
|
void
|
|
|
|
tvavg(out, number)
|
|
|
|
tvavg(out, number)
|
|
|
|
struct timeval *out;
|
|
|
|
struct timeval *out;
|
|
|
|
int number;
|
|
|
|
int number;
|
|
|
|
{
|
|
|
|
{
|
|
|
|
double result;
|
|
|
|
double result;
|
|
|
|
/*
|
|
|
|
/*
|
|
|
|
* out->tv_sec = out->tv_sec/number; out->tv_usec =
|
|
|
|
* out->tv_sec = out->tv_sec/number; out->tv_usec =
|
|
|
|
* out->tv_usec/number;
|
|
|
|
* out->tv_usec/number;
|
|
|
|
*/
|
|
|
|
*/
|
|
|
|
result = (1000000 * out->tv_sec + out->tv_usec) / number;
|
|
|
|
result = (1000000 * out->tv_sec + out->tv_usec) / number;
|
|
|
|
/* printf ("Result of average is %f\n", result) */ ;
|
|
|
|
/* printf ("Result of average is %f\n", result) */ ;
|
|
|
|
out->tv_sec = (long) (result / 1000000);
|
|
|
|
out->tv_sec = (long) (result / 1000000);
|
|
|
|
out->tv_usec = (long) (result - (out->tv_sec * 1000000));
|
|
|
|
out->tv_usec = (long) (result - (out->tv_sec * 1000000));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* tvstddev -- Computes the standard deviation of a set of results */
|
|
|
|
/* tvstddev -- Computes the standard deviation of a set of results */
|
|
|
|
void
|
|
|
|
void
|
|
|
|
tvstddev(out, number, average, results)
|
|
|
|
tvstddev(out, number, average, results)
|
|
|
|
struct timeval *out;
|
|
|
|
struct timeval *out;
|
|
|
|
int number;
|
|
|
|
int number;
|
|
|
|
struct timeval average;
|
|
|
|
struct timeval average;
|
|
|
|
struct result *results;
|
|
|
|
struct result *results;
|
|
|
|
{
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
int i;
|
|
|
|
struct timeval result = null_timeval;
|
|
|
|
struct timeval result = null_timeval;
|
|
|
|
struct timeval avg = null_timeval;
|
|
|
|
struct timeval avg = null_timeval;
|
|
|
|
#ifdef DEBUG
|
|
|
|
#ifdef DEBUG
|
|
|
|
struct timeval var = null_timeval;
|
|
|
|
struct timeval var = null_timeval;
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
struct timeval large, small;
|
|
|
|
struct timeval large, small;
|
|
|
|
double d_offset, d_square, d_variance = 0;
|
|
|
|
double d_offset, d_square, d_variance = 0;
|
|
|
|
*out = null_timeval;
|
|
|
|
*out = null_timeval;
|
|
|
|
for (i = 0; i < number; i++) {
|
|
|
|
for (i = 0; i < number; i++) {
|
|
|
|
if (results[i].valid == 1) {
|
|
|
|
if (results[i].valid == 1) {
|
|
|
|
result = results[i].timevalue;
|
|
|
|
result = results[i].timevalue;
|
|
|
|
#ifdef DEBUG
|
|
|
|
#ifdef DEBUG
|
|
|
|
printf("DEBUG: Value is %f (average is %f)\n", tv2double
|
|
|
|
printf("DEBUG: Value is %f (average is %f)\n", tv2double
|
|
|
|
(result), tv2double(average));
|
|
|
|
(result), tv2double(average));
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
avg = average;
|
|
|
|
avg = average;
|
|
|
|
if (tvcmp(&result, &avg) == -1) {
|
|
|
|
if (tvcmp(&result, &avg) == -1) {
|
|
|
|
small = result;
|
|
|
|
small = result;
|
|
|
|
large = avg;
|
|
|
|
large = avg;
|
|
|
|
} else {
|
|
|
|
} else {
|
|
|
|
large = result;
|
|
|
|
large = result;
|
|
|
|
small = avg;
|
|
|
|
small = avg;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
tvsub(&large, &small);
|
|
|
|
tvsub(&large, &small);
|
|
|
|
#ifdef DEBUG
|
|
|
|
#ifdef DEBUG
|
|
|
|
printf("abs offset is %f\n", tv2double(large));
|
|
|
|
printf("abs offset is %f\n", tv2double(large));
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
d_offset = tv2double(large);
|
|
|
|
d_offset = tv2double(large);
|
|
|
|
d_square = d_offset * d_offset;
|
|
|
|
d_square = d_offset * d_offset;
|
|
|
|
d_variance += d_square;
|
|
|
|
d_variance += d_square;
|
|
|
|
#ifdef DEBUG
|
|
|
|
#ifdef DEBUG
|
|
|
|
printf("variance is now %f\n", tv2double(var));
|
|
|
|
printf("variance is now %f\n", tv2double(var));
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
result = double2tv(sqrt(d_variance / (double) number));
|
|
|
|
result = double2tv(sqrt(d_variance / (double) number));
|
|
|
|
out->tv_sec = result.tv_sec;
|
|
|
|
out->tv_sec = result.tv_sec;
|
|
|
|
out->tv_usec = result.tv_usec;
|
|
|
|
out->tv_usec = result.tv_usec;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
@ -147,116 +147,115 @@ tvstddev(out, number, average, results)
|
|
|
|
/* TODO: IWBN to return the number of excluded outliers */
|
|
|
|
/* TODO: IWBN to return the number of excluded outliers */
|
|
|
|
void
|
|
|
|
void
|
|
|
|
tvstddevavg(out, number, average, results, n_stddev)
|
|
|
|
tvstddevavg(out, number, average, results, n_stddev)
|
|
|
|
struct timeval *out; /* contains std dev on entry */
|
|
|
|
struct timeval *out; /* contains std dev on entry */
|
|
|
|
int number;
|
|
|
|
int number;
|
|
|
|
struct timeval average;
|
|
|
|
struct timeval average;
|
|
|
|
struct result *results;
|
|
|
|
struct result *results;
|
|
|
|
double n_stddev;
|
|
|
|
double n_stddev;
|
|
|
|
{
|
|
|
|
{
|
|
|
|
int i, valid = 0;
|
|
|
|
int i, valid = 0;
|
|
|
|
struct timeval result; /* working value */
|
|
|
|
struct timeval result; /* working value */
|
|
|
|
struct timeval var = null_timeval; /* result accumulator */
|
|
|
|
struct timeval var = null_timeval; /* result accumulator */
|
|
|
|
double x;
|
|
|
|
double x;
|
|
|
|
double maxdev = tv2double(*out) * n_stddev;
|
|
|
|
double maxdev = tv2double(*out) * n_stddev;
|
|
|
|
|
|
|
|
|
|
|
|
if (tvcmp(out, &null_timeval) == 0) {
|
|
|
|
if (tvcmp(out, &null_timeval) == 0) {
|
|
|
|
/* if the SD is 0 then we just return the average */
|
|
|
|
/* if the SD is 0 then we just return the average */
|
|
|
|
*out = average;
|
|
|
|
*out = average;
|
|
|
|
return;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < number; i++) {
|
|
|
|
for (i = 0; i < number; i++) {
|
|
|
|
if (results[i].valid == 1) {
|
|
|
|
if (results[i].valid == 1) {
|
|
|
|
result = results[i].timevalue;
|
|
|
|
result = results[i].timevalue;
|
|
|
|
tvsub(&result, &average);
|
|
|
|
tvsub(&result, &average);
|
|
|
|
/* printf ("value is %f (stddev is %f)\n", tv2double
|
|
|
|
/* printf ("value is %f (stddev is %f)\n", tv2double (result), tv2double
|
|
|
|
* (result), tv2double (stddev)); */
|
|
|
|
* (stddev)); */
|
|
|
|
/* ensure that result (difference to average) is absolute
|
|
|
|
/* ensure that result (difference to average) is absolute value */
|
|
|
|
* value */
|
|
|
|
if (tvcmp(&result, &null_timeval) == -1) {
|
|
|
|
if (tvcmp(&result, &null_timeval) == -1) {
|
|
|
|
result = average;
|
|
|
|
result = average;
|
|
|
|
tvsub(&result, &results[i].timevalue);
|
|
|
|
tvsub(&result, &results[i].timevalue);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
x = tv2double(result);
|
|
|
|
x = tv2double(result);
|
|
|
|
/* printf("value is %g maxdev %g\n",x,maxdev); */
|
|
|
|
/* printf("value is %g maxdev %g\n",x,maxdev); */
|
|
|
|
if (x <= maxdev) {
|
|
|
|
if (x <= maxdev) {
|
|
|
|
/* deviation is less than stddev */
|
|
|
|
/* deviation is less than stddev */
|
|
|
|
tvadd(&var, &results[i].timevalue);
|
|
|
|
tvadd(&var, &results[i].timevalue);
|
|
|
|
valid++;
|
|
|
|
valid++;
|
|
|
|
} else {
|
|
|
|
} else {
|
|
|
|
/* printf("dropped\n"); */
|
|
|
|
/* printf("dropped\n"); */
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* printf ("total is %f in %d samples\n", tv2double (var), valid); */
|
|
|
|
/* printf ("total is %f in %d samples\n", tv2double (var), valid); */
|
|
|
|
if (valid > 0) {
|
|
|
|
if (valid > 0) {
|
|
|
|
*out = double2tv(tv2double(var) / valid);
|
|
|
|
*out = double2tv(tv2double(var) / valid);
|
|
|
|
} else {
|
|
|
|
} else {
|
|
|
|
*out = null_timeval;
|
|
|
|
*out = null_timeval;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* tvcmp -- Compares two timeval structs */
|
|
|
|
/* tvcmp -- Compares two timeval structs */
|
|
|
|
int
|
|
|
|
int
|
|
|
|
tvcmp(left, right)
|
|
|
|
tvcmp(left, right)
|
|
|
|
struct timeval *left, *right;
|
|
|
|
struct timeval *left, *right;
|
|
|
|
{
|
|
|
|
{
|
|
|
|
if (left->tv_sec < right->tv_sec) {
|
|
|
|
if (left->tv_sec < right->tv_sec) {
|
|
|
|
return -1;
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (left->tv_sec > right->tv_sec) {
|
|
|
|
if (left->tv_sec > right->tv_sec) {
|
|
|
|
return 1;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (left->tv_usec < right->tv_usec) {
|
|
|
|
if (left->tv_usec < right->tv_usec) {
|
|
|
|
return -1;
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (left->tv_usec > right->tv_usec) {
|
|
|
|
if (left->tv_usec > right->tv_usec) {
|
|
|
|
return 1;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* tvmin */
|
|
|
|
/* tvmin */
|
|
|
|
void
|
|
|
|
void
|
|
|
|
tvmin(champion, challenger)
|
|
|
|
tvmin(champion, challenger)
|
|
|
|
struct timeval *champion, *challenger;
|
|
|
|
struct timeval *champion, *challenger;
|
|
|
|
{
|
|
|
|
{
|
|
|
|
if (tvcmp(champion, challenger) == 1) {
|
|
|
|
if (tvcmp(champion, challenger) == 1) {
|
|
|
|
champion->tv_sec = challenger->tv_sec;
|
|
|
|
champion->tv_sec = challenger->tv_sec;
|
|
|
|
champion->tv_usec = challenger->tv_usec;
|
|
|
|
champion->tv_usec = challenger->tv_usec;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* tvmax */
|
|
|
|
/* tvmax */
|
|
|
|
void
|
|
|
|
void
|
|
|
|
tvmax(champion, challenger)
|
|
|
|
tvmax(champion, challenger)
|
|
|
|
struct timeval *champion, *challenger;
|
|
|
|
struct timeval *champion, *challenger;
|
|
|
|
{
|
|
|
|
{
|
|
|
|
if (tvcmp(champion, challenger) == -1) {
|
|
|
|
if (tvcmp(champion, challenger) == -1) {
|
|
|
|
champion->tv_sec = challenger->tv_sec;
|
|
|
|
champion->tv_sec = challenger->tv_sec;
|
|
|
|
champion->tv_usec = challenger->tv_usec;
|
|
|
|
champion->tv_usec = challenger->tv_usec;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
double
|
|
|
|
double
|
|
|
|
tv2double(tv)
|
|
|
|
tv2double(tv)
|
|
|
|
struct timeval tv;
|
|
|
|
struct timeval tv;
|
|
|
|
{
|
|
|
|
{
|
|
|
|
double result;
|
|
|
|
double result;
|
|
|
|
result =
|
|
|
|
result =
|
|
|
|
(((((double) tv.tv_sec) * 1000000.0) + (double) tv.tv_usec) / 1000000.0);
|
|
|
|
(((((double) tv.tv_sec) * 1000000.0) + (double) tv.tv_usec) / 1000000.0);
|
|
|
|
/* printf ("Double is %9.3f\n", result); */
|
|
|
|
/* printf ("Double is %9.3f\n", result); */
|
|
|
|
return result;
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
struct timeval
|
|
|
|
struct timeval
|
|
|
|
double2tv(x)
|
|
|
|
double2tv(x)
|
|
|
|
double x;
|
|
|
|
double x;
|
|
|
|
{
|
|
|
|
{
|
|
|
|
struct timeval result;
|
|
|
|
struct timeval result;
|
|
|
|
result.tv_sec = (int) (x);
|
|
|
|
result.tv_sec = (int) (x);
|
|
|
|
result.tv_usec = (int) ((x - result.tv_sec) * 1000000);
|
|
|
|
result.tv_usec = (int) ((x - result.tv_sec) * 1000000);
|
|
|
|
return result;
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
Stephane Bortzmeyer
16 years ago