xnu-4903.270.47.tar.gz

[apple/xnu.git] / tools / tests / perf_index / perf_index.c

diff --git a/tools/tests/perf_index/perf_index.c b/tools/tests/perf_index/perf_index.c
index 19532883669532c7fda71f7a6003bd6905f6baab..8d71a0c8fc0e64ba1d0372b65f5e08090d289883 100644 (file)
--- a/tools/tests/perf_index/perf_index.c
+++ b/tools/tests/perf_index/perf_index.c
@@ -12,19 +12,19 @@
 #include "fail.h"
 
 typedef struct parsed_args_struct {
 #include "fail.h"
 
 typedef struct parsed_args_struct {

-    char* my_name;
-    char* test_name;
-    int num_threads;
-    long long length;
-    int test_argc;
-    void** test_argv;
+       char* my_name;
+       char* test_name;
+       int num_threads;
+       long long length;
+       int test_argc;
+       void** test_argv;

 } parsed_args_t;
 
 typedef struct test_struct {
 } parsed_args_t;
 
 typedef struct test_struct {

-    int (*setup)(int, long long, int, void**);
-    int (*execute)(int, int, long long, int, void**);
-    int (*cleanup)(int, long long);
-    char** error_str_ptr;
+       int (*setup)(int, long long, int, void**);
+       int (*execute)(int, int, long long, int, void**);
+       int (*cleanup)(int, long long);
+       char** error_str_ptr;

 } test_t;
 
 parsed_args_t args;
 } test_t;
 
 parsed_args_t args;


@@ -34,181 +34,202 @@ pthread_mutex_t ready_thread_count_lock;
 pthread_cond_t start_cvar;
 pthread_cond_t threads_ready_cvar;
 
 pthread_cond_t start_cvar;
 pthread_cond_t threads_ready_cvar;
 

-int parse_args(int argc, char** argv, parsed_args_t* parsed_args) {
-    if(argc != 4) {
-        return -1;
-    }
-
-    parsed_args->my_name = argv[0];
-    parsed_args->test_name = argv[1];
-    parsed_args->num_threads = atoi(argv[2]);
-    parsed_args->length = strtoll(argv[3], NULL, 10);
-    parsed_args->test_argc = 0;
-    parsed_args->test_argv = NULL;
-    return 0;
+int
+parse_args(int argc, char** argv, parsed_args_t* parsed_args)
+{
+       if (argc != 4) {
+               return -1;
+       }
+
+       parsed_args->my_name = argv[0];
+       parsed_args->test_name = argv[1];
+       parsed_args->num_threads = atoi(argv[2]);
+       parsed_args->length = strtoll(argv[3], NULL, 10);
+       parsed_args->test_argc = 0;
+       parsed_args->test_argv = NULL;
+       return 0;

 }
 
 }
 

-void print_usage(char** argv) {
-    printf("Usage: %s test_name threads length\n", argv[0]);
+void
+print_usage(char** argv)
+{
+       printf("Usage: %s test_name threads length\n", argv[0]);

 }
 
 }
 

-int find_test(char* test_name, char* test_path) {
-    char binpath[MAXPATHLEN];
-    char* dirpath;
-    uint32_t size = sizeof(binpath);
-    int retval;
-
-    retval = _NSGetExecutablePath(binpath, &size);
-    assert(retval == 0);
-    dirpath = dirname(binpath);
-
-    snprintf(test_path, MAXPATHLEN, "%s/perfindex-%s.dylib", dirpath, test_name);
-    if(access(test_path, F_OK) == 0)
-        return 0;
-    else
-        return -1;
+int
+find_test(char* test_name, char* test_path)
+{
+       char binpath[MAXPATHLEN];
+       char* dirpath;
+       uint32_t size = sizeof(binpath);
+       int retval;
+
+       retval = _NSGetExecutablePath(binpath, &size);
+       assert(retval == 0);
+       dirpath = dirname(binpath);
+
+       snprintf(test_path, MAXPATHLEN, "%s/perfindex-%s.dylib", dirpath, test_name);
+       if (access(test_path, F_OK) == 0) {
+               return 0;
+       } else {
+               return -1;
+       }

 }
 
 }
 

-int load_test(char* path, test_t* test) {
-    void* handle;
-    void* p;
+int
+load_test(char* path, test_t* test)
+{
+       void* handle;
+       void* p;

 
 

-    handle = dlopen(path, RTLD_NOW | RTLD_LOCAL);
-    if(!handle) {
-        return -1;
-    }
+       handle = dlopen(path, RTLD_NOW | RTLD_LOCAL);
+       if (!handle) {
+               return -1;
+       }

 
 
 
 

-    p = dlsym(handle, "setup");
-    test->setup = (int (*)(int, long long, int, void **))p;
+       p = dlsym(handle, "setup");
+       test->setup = (int (*)(int, long long, int, void **))p;

 
 

-    p = dlsym(handle, "execute");
-    test->execute = (int (*)(int, int, long long, int, void **))p;
-    if(p == NULL)
-        return -1;
+       p = dlsym(handle, "execute");
+       test->execute = (int (*)(int, int, long long, int, void **))p;
+       if (p == NULL) {
+               return -1;
+       }

 
 

-    p = dlsym(handle, "cleanup");
-    test->cleanup = (int (*)(int, long long))p;
+       p = dlsym(handle, "cleanup");
+       test->cleanup = (int (*)(int, long long))p;

 
 

-    p = dlsym(handle, "error_str");
-    test->error_str_ptr = (char**)p;
+       p = dlsym(handle, "error_str");
+       test->error_str_ptr = (char**)p;

 
 

-    return 0;
+       return 0;

 }
 
 }
 

-void start_timer(struct timeval *tp) {
-  gettimeofday(tp, NULL);
+void
+start_timer(struct timeval *tp)
+{
+       gettimeofday(tp, NULL);

 }
 
 }
 

-void end_timer(struct timeval *tp) {
-  struct timeval tend;
-  gettimeofday(&tend, NULL);
-  if(tend.tv_usec >= tp->tv_usec) {
-    tp->tv_sec = tend.tv_sec - tp->tv_sec;
-    tp->tv_usec = tend.tv_usec - tp->tv_usec;
-  }
-  else {
-    tp->tv_sec = tend.tv_sec - tp->tv_sec - 1;
-    tp->tv_usec = tend.tv_usec - tp->tv_usec + 1000000;
-  }
+void
+end_timer(struct timeval *tp)
+{
+       struct timeval tend;
+       gettimeofday(&tend, NULL);
+       if (tend.tv_usec >= tp->tv_usec) {
+               tp->tv_sec = tend.tv_sec - tp->tv_sec;
+               tp->tv_usec = tend.tv_usec - tp->tv_usec;
+       } else {
+               tp->tv_sec = tend.tv_sec - tp->tv_sec - 1;
+               tp->tv_usec = tend.tv_usec - tp->tv_usec + 1000000;
+       }

 }
 
 }
 

-void print_timer(struct timeval *tp) {
-  printf("%ld.%06d\n", tp->tv_sec, tp->tv_usec);
+void
+print_timer(struct timeval *tp)
+{
+       printf("%ld.%06d\n", tp->tv_sec, tp->tv_usec);

 }
 
 }
 

-static void* thread_setup(void *arg) {
-  int my_index = (int)arg;
-  long long work_size = args.length / args.num_threads;
-  int work_remainder = args.length % args.num_threads;
-
-  if(work_remainder > my_index) {
-    work_size++;
-  }
-
-  pthread_mutex_lock(&ready_thread_count_lock);
-  ready_thread_count++;
-  if(ready_thread_count == args.num_threads)
-    pthread_cond_signal(&threads_ready_cvar);
-  pthread_cond_wait(&start_cvar, &ready_thread_count_lock);
-  pthread_mutex_unlock(&ready_thread_count_lock);
-  test.execute(my_index, args.num_threads, work_size, args.test_argc, args.test_argv);
-  return NULL;
+static void*
+thread_setup(void *arg)
+{
+       int my_index = (int)arg;
+       long long work_size = args.length / args.num_threads;
+       int work_remainder = args.length % args.num_threads;
+
+       if (work_remainder > my_index) {
+               work_size++;
+       }
+
+       pthread_mutex_lock(&ready_thread_count_lock);
+       ready_thread_count++;
+       if (ready_thread_count == args.num_threads) {
+               pthread_cond_signal(&threads_ready_cvar);
+       }
+       pthread_cond_wait(&start_cvar, &ready_thread_count_lock);
+       pthread_mutex_unlock(&ready_thread_count_lock);
+       test.execute(my_index, args.num_threads, work_size, args.test_argc, args.test_argv);
+       return NULL;

 }
 
 }
 

-int main(int argc, char** argv) {
-    int retval;
-    int thread_index;
-    struct timeval timer;
-    pthread_t* threads;
-    int thread_retval;
-    void* thread_retval_ptr = &thread_retval;
-    char test_path[MAXPATHLEN];
-
-    retval = parse_args(argc, argv, &args);
-    if(retval) {
-        print_usage(argv);
-        return -1;
-    }
-
-    retval = find_test(args.test_name, test_path);
-    if(retval) {
-        printf("Unable to find test %s\n", args.test_name);
-        return -1;
-    }
-
-    load_test(test_path, &test);
-    if(retval) {
-        printf("Unable to load test %s\n", args.test_name);
-        return -1;
-    }
-
-    pthread_cond_init(&threads_ready_cvar, NULL);
-    pthread_cond_init(&start_cvar, NULL);
-    pthread_mutex_init(&ready_thread_count_lock, NULL);
-    ready_thread_count = 0;
-
-    if(test.setup) {
-        retval = test.setup(args.num_threads, args.length, 0, NULL);
-        if(retval == PERFINDEX_FAILURE) {
-            fprintf(stderr, "Test setup failed: %s\n", *test.error_str_ptr);
-            return -1;
-        }
-    }
-
-    threads = (pthread_t*)malloc(sizeof(pthread_t)*args.num_threads);
-    for(thread_index = 0; thread_index < args.num_threads; thread_index++) {
-        retval = pthread_create(&threads[thread_index], NULL, thread_setup, (void*)(long)thread_index);
-        assert(retval == 0);
-    }
-
-    pthread_mutex_lock(&ready_thread_count_lock);
-    if(ready_thread_count != args.num_threads) {
-        pthread_cond_wait(&threads_ready_cvar, &ready_thread_count_lock);
-    }
-    pthread_mutex_unlock(&ready_thread_count_lock);
-
-    start_timer(&timer);
-    pthread_cond_broadcast(&start_cvar);
-    for(thread_index = 0; thread_index < args.num_threads; thread_index++) {
-        pthread_join(threads[thread_index], &thread_retval_ptr);
-        if(**test.error_str_ptr) {
-            printf("Test failed: %s\n", *test.error_str_ptr);
-        }
-    }
-    end_timer(&timer);
-
-    if(test.cleanup)
-        retval = test.cleanup(args.num_threads, args.length);
-        if(retval == PERFINDEX_FAILURE) {
-            fprintf(stderr, "Test cleanup failed: %s\n", *test.error_str_ptr);
-            free(threads);
-            return -1;
-        }
-
-    print_timer(&timer);
-
-    free(threads);
-
-    return 0;
+int
+main(int argc, char** argv)
+{
+       int retval;
+       int thread_index;
+       struct timeval timer;
+       pthread_t* threads;
+       int thread_retval;
+       void* thread_retval_ptr = &thread_retval;
+       char test_path[MAXPATHLEN];
+
+       retval = parse_args(argc, argv, &args);
+       if (retval) {
+               print_usage(argv);
+               return -1;
+       }
+
+       retval = find_test(args.test_name, test_path);
+       if (retval) {
+               printf("Unable to find test %s\n", args.test_name);
+               return -1;
+       }
+
+       load_test(test_path, &test);
+       if (retval) {
+               printf("Unable to load test %s\n", args.test_name);
+               return -1;
+       }
+
+       pthread_cond_init(&threads_ready_cvar, NULL);
+       pthread_cond_init(&start_cvar, NULL);
+       pthread_mutex_init(&ready_thread_count_lock, NULL);
+       ready_thread_count = 0;
+
+       if (test.setup) {
+               retval = test.setup(args.num_threads, args.length, 0, NULL);
+               if (retval == PERFINDEX_FAILURE) {
+                       fprintf(stderr, "Test setup failed: %s\n", *test.error_str_ptr);
+                       return -1;
+               }
+       }
+
+       threads = (pthread_t*)malloc(sizeof(pthread_t) * args.num_threads);
+       for (thread_index = 0; thread_index < args.num_threads; thread_index++) {
+               retval = pthread_create(&threads[thread_index], NULL, thread_setup, (void*)(long)thread_index);
+               assert(retval == 0);
+       }
+
+       pthread_mutex_lock(&ready_thread_count_lock);
+       if (ready_thread_count != args.num_threads) {
+               pthread_cond_wait(&threads_ready_cvar, &ready_thread_count_lock);
+       }
+       pthread_mutex_unlock(&ready_thread_count_lock);
+
+       start_timer(&timer);
+       pthread_cond_broadcast(&start_cvar);
+       for (thread_index = 0; thread_index < args.num_threads; thread_index++) {
+               pthread_join(threads[thread_index], &thread_retval_ptr);
+               if (**test.error_str_ptr) {
+                       printf("Test failed: %s\n", *test.error_str_ptr);
+               }
+       }
+       end_timer(&timer);
+
+       if (test.cleanup) {
+               retval = test.cleanup(args.num_threads, args.length);
+       }
+       if (retval == PERFINDEX_FAILURE) {
+               fprintf(stderr, "Test cleanup failed: %s\n", *test.error_str_ptr);
+               free(threads);
+               return -1;
+       }
+
+       print_timer(&timer);
+
+       free(threads);
+
+       return 0;

 }
 }