/*      $NetBSD: nameibench.c,v 1.3 2019/11/23 20:37:49 ad Exp $        */

/*-
 * Copyright (c) 2009 The NetBSD Foundation, Inc.
 * All rights reserved.
 *
 * This code is derived from software contributed to The NetBSD Foundation
 * by Andrew Doran.
 *
 * 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 NETBSD FOUNDATION, INC. AND CONTRIBUTORS
 * ``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 FOUNDATION OR CONTRIBUTORS
 * 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.
 */

#include <sys/param.h>

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <time.h>
#include <pthread.h>
#include <inttypes.h>
#include <signal.h>

#define MAXFILES        4096

const int primes[] = {
        233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283,
        293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359,
        367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431,
        433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491,
        499, 503, 509, 521, 523, 541, 
};

char    **sa;
u_int   sasize;
u_int   sacnt;
struct  timespec sts;
struct  timespec ets;
pthread_barrier_t       barrier;
pthread_mutex_t lock;
volatile sig_atomic_t   stop;
double  nlookups;
double  ideal;

static void
makelist(void)
{
        char buf[MAXPATHLEN], *p;
        size_t l;
        FILE *fp;

        fp = popen("/usr/bin/locate x", "r");
        if (fp == NULL) {
                perror("popen");
                exit(EXIT_FAILURE);
        }

        while (fgets(buf, sizeof(buf), fp) != NULL) {
                l = strlen(buf) + 1;
                p = malloc(l);
                if (p == NULL) {
                        perror("malloc");
                        exit(EXIT_FAILURE);
                }
                strcpy(p, buf);
                p[l - 2] = '\0';
                if (sacnt == sasize) {
                        sasize += 256;
                        sa = realloc(sa, sizeof(*sa) * sasize);
                        if (sa == NULL) {
                                perror("realloc");
                                exit(EXIT_FAILURE);
                        }
                }
                sa[sacnt++] = p;
                if (sacnt == MAXFILES) {
                        break;
                }
        }

        fclose(fp);
}

static void
lookups(int idx)
{
        u_int p, c;

        for (c = 0, p = 0; !stop; c++) {
                p += primes[idx];
                if (p >= sacnt) {
                        p %= sacnt;
                }
                (void)access(sa[p], F_OK);
                
        }

        pthread_mutex_lock(&lock);
        nlookups += c;
        pthread_mutex_unlock(&lock);
}

static void
start(void)
{

        (void)pthread_barrier_wait(&barrier);
        if (clock_gettime(CLOCK_MONOTONIC, &sts)) {
                perror("clock_gettime");
                exit(EXIT_FAILURE);
        }
}

static void
end(void)
{

        if (clock_gettime(CLOCK_MONOTONIC, &ets)) {
                perror("clock_gettime");
                exit(EXIT_FAILURE);
        }
        (void)pthread_barrier_wait(&barrier);
}

static void *
thread(void *cookie)
{

        start();
        lookups((int)(uintptr_t)cookie);
        end();

        return NULL;
}

static void
sigalrm(int junk)
{

        stop = (sig_atomic_t)1;
}

static void
run(int nt)
{
        pthread_t pt;
        double c;
        int i;
        long us;

        if (pthread_barrier_init(&barrier, NULL, nt + 1)) {
                fprintf(stderr, "pthread_barrier_init\n");
                exit(EXIT_FAILURE);
        }

        nlookups = 0;
        stop = 0;
        for (i = 0; i < nt; i++) {
                if (pthread_create(&pt, NULL, thread, (void *)(uintptr_t)i)) {
                        fprintf(stderr, "pthread_create\n");
                        exit(EXIT_FAILURE);
                }
        }
        start();
        alarm(10);
        end();
        us = (long)(ets.tv_sec * (uint64_t)1000000 + ets.tv_nsec / 1000);
        us -= (long)(sts.tv_sec * (uint64_t)1000000 + sts.tv_nsec / 1000);
        c = nlookups * 1000000.0 / us;
        if (ideal == 0) {
                ideal = c;
        }
        printf("%d\t%d\t%.0f\t%.0f\n", sacnt, nt, c, ideal * nt);

        if (pthread_barrier_destroy(&barrier)) {
                fprintf(stderr, "pthread_barrier_destroy\n");
                exit(EXIT_FAILURE);
        }
}

int
main(int argc, char **argv)
{
        int i, mt;

        (void)setvbuf(stdout, NULL, _IOLBF, BUFSIZ);
        if (argc < 2) {
                mt = sysconf(_SC_NPROCESSORS_ONLN);
        } else {
                mt = atoi(argv[1]);
                if (mt < 1) {
                        mt = 1;
                }
        }
        if (pthread_mutex_init(&lock, NULL)) {
                fprintf(stderr, "pthread_mutex_init\n");
                exit(EXIT_FAILURE);
        }
        makelist();
        (void)signal(SIGALRM, sigalrm);
        printf("# nname\tnthr\tpersec\tideal\n");
        for (i = 1; i <= mt; i++) {
                run(i); 
        }
        exit(EXIT_SUCCESS);
}