/* benchmark.c -- Benchmarks how quickly the computer does SHA512 hashing
 *
 *  GPLv2 only - Copyright (C) 2009
 *               David Sommerseth <dazo@users.sourceforge.net>
 *
 *  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; version 2
 *  of the License.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 *
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <sys/time.h>

void benchmark_hashing(int rounds);

int timeval_subtract (result, x, y)
     struct timeval *result, *x, *y;
{
        /* Perform the carry for the later subtraction by updating y. */
        if (x->tv_usec < y->tv_usec) {
                int nsec = (y->tv_usec - x->tv_usec) / 1000000 + 1;
                y->tv_usec -= 1000000 * nsec;
                y->tv_sec += nsec;
        }
        if (x->tv_usec - y->tv_usec > 1000000) {
                int nsec = (y->tv_usec - x->tv_usec) / 1000000;
                y->tv_usec += 1000000 * nsec;
                y->tv_sec -= nsec;
        }

        /* Compute the time remaining to wait.
           tv_usec is certainly positive. */
        result->tv_sec = x->tv_sec - y->tv_sec;
        result->tv_usec = x->tv_usec - y->tv_usec;

        /* Return 1 if result is negative. */
        return x->tv_sec < y->tv_sec;
}

struct timeval *do_benchmark(int rounds) {
        struct timeval start, end, *timediff = NULL;

        timediff = (struct timeval *) malloc(sizeof(struct timeval)+2);
        memset(timediff, 0, sizeof(struct timeval)+2);

        gettimeofday(&start, NULL);
        benchmark_hashing(rounds);
        gettimeofday(&end, NULL);
        timeval_subtract(timediff, &end, &start);

        return timediff;
}

// This function will try to find the best minium and maximum rounds for
// the SHA512 hashing.  The values are returned in the min and max variables
// and the thr_min and thr_max defines the minimum and maximum thresholds in
// milliseconds the hashing algorithm should use.
int benchmark(int *min, int *max, int thr_min, int thr_max) {
        int i = 0, success = 0;
        struct timeval *time = NULL, min_time, max_time ;

        printf("Benchmarking ");
        *min = 1000;
        *max = 5000;
        for( i = 1000; i < 100000000; i += 1000 ) {
                printf(".");
                fflush(stdout);
                time = do_benchmark(i);
                // printf("%i rounds: %ld sec %ld ms\n", i, time->tv_sec, time->tv_usec);
                if( time->tv_usec > (thr_max * 1000) ) {
                        success = 1;
                        free(time);
                        break;
                }
                if( (*min == 1000) && (time->tv_usec > (thr_min * 1000)) ) {
                        *min = i;
                        min_time.tv_usec = time->tv_usec;
                }
                if( (time->tv_usec < (thr_max * 1000)) ) {
                        *max = i;
                        max_time.tv_usec = time->tv_usec;
                }
                free(time);
        }
        printf(" Done\n");
        if( success == 1 ) {
                printf("Suggested minimum rounds: %i (takes %ldms)\n", *min, min_time.tv_usec/1000);
                printf("Suggested maximum rounds: %i (takes %ldms)\n", *max, max_time.tv_usec/1000);
        } else {
                *min = 0;
                *max = 0;
                printf("Could not find any good times, as your computer is too fast for this test.\n");
        }
        return success;
}

#if 0
int main() {
        int min, max;

        benchmark(&min, &max, 90, 220);
        printf("---> %i - %i\n", min, max);
        return 0;
}
#endif