diff --git a/test/BUILD.gn b/test/BUILD.gn index 14737dbb..043f925c 100644 --- a/test/BUILD.gn +++ b/test/BUILD.gn @@ -99,30 +99,12 @@ mimalloc_unittest("test-info") { libs = [ "xml2.z" ] } -mimalloc_unittest("bench-malloc-thread") { - sources = [ "perfomance/bench-malloc-thread.c" ] -} - -mimalloc_unittest("xmalloc-test") { - sources = [ "perfomance/xmalloc-test.c" ] -} - -without_mimalloc_test("bench-malloc-thread-default") { - sources = [ "perfomance/bench-malloc-thread.c" ] -} - -without_mimalloc_test("xmalloc-test-default") { - sources = [ "perfomance/xmalloc-test.c" ] -} - mimalloc_unittest("test-backtrace") { } group("mimalloc_test") { testonly = true deps = [ - ":bench-malloc-thread", - ":bench-malloc-thread-default", ":test-api", ":test-api-fill", ":test-backtrace", @@ -133,7 +115,5 @@ group("mimalloc_test") { ":test-mallopt", ":test-stats-print", ":test-stress", - ":xmalloc-test", - ":xmalloc-test-default", ] } diff --git a/test/perfomance/README.md b/test/perfomance/README.md deleted file mode 100644 index b9324dcb..00000000 --- a/test/perfomance/README.md +++ /dev/null @@ -1,57 +0,0 @@ -# Mimalloc perfomance tests - -**xmalloc-test** - multi-threads benchmark with 100 purely allocating threads, and 100 purely deallocating threads with objects of various sizes migrating between them. This asymmetric producer/consumer pattern is usually difficult to handle by allocators with thread-local caches. - -**bench-malloc-thread** - multi-threads benchmark originally prepared for the glibc memory allocator - -### How to prepare: - -1. Build tests: -``` -$ ./build.sh --product-name rk3568 --build-target third_party/mimalloc:mimalloc_test -``` - -2. Copy tests to device: -``` -$ ./hdc_std file send ~/workspace/ohos/out/rk3568/tests/unittest/mimalloc_test/ /data -``` - -3. Make tests executable on the device: -``` -# chmod -R a+x /data/mimalloc_test/ -``` - -### Versions of tests: - -- xmalloc-test - test binary that use **mimalloc** memory allocator -- xmalloc-test-default - test binary that use **default musl** allocator -- bench-malloc-thread - test binary that use **mimalloc** memory allocator -- bench-malloc-thread-default - test binary that use **default musl** allocator - -#### Run xmalloc-tests: -``` -# ./xmalloc-test -w 4 -t 5 -s 64 -# ./xmalloc-test-default -w 4 -t 5 -s 64 -``` - -Output is relative time (**rtime** smaller is better): -``` -# ./xmalloc-test -w 4 -t 5 -s 64 -rtime: 15.258, free/sec: 6.554 M -# ./xmalloc-test-default -w 4 -t 5 -s 64 -rtime: 125.008, free/sec: 0.800 M -``` - -#### Run bench-malloc-thread: -``` -# ./bench-malloc-thread 4 -# ./bench-malloc-thread-default 4 -``` - -Output is number of iterations that tests can execute in constant time (**iterations** bigger is better): -``` -# ./bench-malloc-thread 4 -18120892 iterations -# ./bench-malloc-thread-default 4 -3996257 iterations -``` diff --git a/test/perfomance/bench-malloc-thread.c b/test/perfomance/bench-malloc-thread.c deleted file mode 100644 index 2fbbde1f..00000000 --- a/test/perfomance/bench-malloc-thread.c +++ /dev/null @@ -1,262 +0,0 @@ -/* Benchmark malloc and free functions. - Copyright (C) 2013-2021 Free Software Foundation, Inc. - This file is part of the GNU C Library. - The GNU C Library is free software; you can redistribute it and/or - modify it under the terms of the GNU Lesser General Public - License as published by the Free Software Foundation; either - version 2.1 of the License, or (at your option) any later version. - The GNU C Library 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 - Lesser General Public License for more details. - You should have received a copy of the GNU Lesser General Public - License along with the GNU C Library; if not, see - . */ - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -/* Benchmark duration in seconds. */ -#define BENCHMARK_DURATION 2 -#define RAND_SEED 88 - -#ifndef NUM_THREADS -# define NUM_THREADS 1 -#endif - -typedef long timing_t; -#define TIMING_NOW(s) -#define TIMING_DIFF(e,start,stop) -#define TIMING_ACCUM(x,y) - -/* Maximum memory that can be allocated at any one time is: - NUM_THREADS * WORKING_SET_SIZE * MAX_ALLOCATION_SIZE - However due to the distribution of the random block sizes - the typical amount allocated will be much smaller. */ -#define WORKING_SET_SIZE 1024 - -#define MIN_ALLOCATION_SIZE 4 -#define MAX_ALLOCATION_SIZE 32768 - -/* Get a random block size with an inverse square distribution. */ -static unsigned int -get_block_size (unsigned int rand_data) -{ - /* Inverse square. */ - const float exponent = -2; - /* Minimum value of distribution. */ - const float dist_min = MIN_ALLOCATION_SIZE; - /* Maximum value of distribution. */ - const float dist_max = MAX_ALLOCATION_SIZE; - - float min_pow = powf (dist_min, exponent + 1); - float max_pow = powf (dist_max, exponent + 1); - - float r = (float) rand_data / RAND_MAX; - - return (unsigned int) powf ((max_pow - min_pow) * r + min_pow, - 1 / (exponent + 1)); -} - -#define NUM_BLOCK_SIZES 8000 -#define NUM_OFFSETS ((WORKING_SET_SIZE) * 4) - -static unsigned int random_block_sizes[NUM_BLOCK_SIZES]; -static unsigned int random_offsets[NUM_OFFSETS]; - -static void -init_random_values (void) -{ - for (size_t i = 0; i < NUM_BLOCK_SIZES; i++) - random_block_sizes[i] = get_block_size (rand ()); - - for (size_t i = 0; i < NUM_OFFSETS; i++) - random_offsets[i] = rand () % WORKING_SET_SIZE; -} - -static unsigned int -get_random_block_size (unsigned int *state) -{ - unsigned int idx = *state; - - if (idx >= NUM_BLOCK_SIZES - 1) - idx = 0; - else - idx++; - - *state = idx; - - return random_block_sizes[idx]; -} - -static unsigned int -get_random_offset (unsigned int *state) -{ - unsigned int idx = *state; - - if (idx >= NUM_OFFSETS - 1) - idx = 0; - else - idx++; - - *state = idx; - - return random_offsets[idx]; -} - -static volatile bool timeout; - -static void -alarm_handler (int signum) -{ - timeout = true; -} - -/* Allocate and free blocks in a random order. */ -static size_t -malloc_benchmark_loop (void **ptr_arr) -{ - unsigned int offset_state = 0, block_state = 0; - size_t iters = 0; - - while (!timeout) - { - unsigned int next_idx = get_random_offset (&offset_state); - unsigned int next_block = get_random_block_size (&block_state); - - free (ptr_arr[next_idx]); - - void* p = ptr_arr[next_idx] = malloc (next_block); - - // touch the allocated memory - for(int i = 0; i < next_block; i++) { - ((char*)p)[i] = (char)i; - } - iters++; - } - - return iters; -} - -struct thread_args -{ - size_t iters; - void **working_set; - timing_t elapsed; -}; - -static void * -benchmark_thread (void *arg) -{ - struct thread_args *args = (struct thread_args *) arg; - size_t iters; - void *thread_set = args->working_set; - //timing_t start, stop; - - //TIMING_NOW (start); - iters = malloc_benchmark_loop (thread_set); - //TIMING_NOW (stop); - - //TIMING_DIFF (args->elapsed, start, stop); - args->iters = iters; - - return NULL; -} - -static timing_t -do_benchmark (size_t num_threads, size_t *iters) -{ - timing_t elapsed = 0; - - if (num_threads == 1) - { - //timing_t start, stop; - void *working_set[WORKING_SET_SIZE]; - - memset (working_set, 0, sizeof (working_set)); - - //TIMING_NOW (start); - *iters = malloc_benchmark_loop (working_set); - //TIMING_NOW (stop); - - //TIMING_DIFF (elapsed, start, stop); - } - else - { - struct thread_args args[num_threads]; - void *working_set[num_threads][WORKING_SET_SIZE]; - pthread_t threads[num_threads]; - - memset (working_set, 0, sizeof (working_set)); - - *iters = 0; - - for (size_t i = 0; i < num_threads; i++) - { - args[i].working_set = working_set[i]; - pthread_create(&threads[i], NULL, benchmark_thread, &args[i]); - } - - for (size_t i = 0; i < num_threads; i++) - { - pthread_join(threads[i], NULL); - TIMING_ACCUM (elapsed, args[i].elapsed); - *iters += args[i].iters; - } - } - return elapsed; -} - -static void usage(const char *name) -{ - fprintf (stderr, "%s: \n", name); - exit (1); -} - -int -main (int argc, char **argv) -{ - timing_t cur; - size_t iters = 0, num_threads = 1; - struct sigaction act; - //double d_total_s, d_total_i; - - if (argc == 1) - num_threads = 1; - else if (argc == 2) - { - long ret; - - errno = 0; - ret = strtol(argv[1], NULL, 10); - - if (errno || ret == 0) - usage(argv[0]); - - num_threads = ret; - } - else - usage(argv[0]); - - init_random_values (); - memset (&act, 0, sizeof (act)); - act.sa_handler = &alarm_handler; - - sigaction (SIGALRM, &act, NULL); - - alarm (BENCHMARK_DURATION); - - cur = do_benchmark (num_threads, &iters); - printf("%zd iterations\n", iters ); - - return 0; -} diff --git a/test/perfomance/random.h b/test/perfomance/random.h deleted file mode 100644 index 6cd82ee0..00000000 --- a/test/perfomance/random.h +++ /dev/null @@ -1,49 +0,0 @@ -// ======================================================= - -/* lran2.h - * by Wolfram Gloger 1996. - * - * A small, portable pseudo-random number generator. - */ - -#ifndef _LRAN2_H -#define _LRAN2_H - -#define LRAN2_MAX 714025l /* constants for portable */ -#define IA 1366l /* random number generator */ -#define IC 150889l /* (see e.g. `Numerical Recipes') */ - -struct lran2_st { - long x, y, v[97]; -}; - -static void -lran2_init(struct lran2_st* d, long seed) -{ - long x; - int j; - - x = (IC - seed) % LRAN2_MAX; - if(x < 0) x = -x; - for(j=0; j<97; j++) { - x = (IA*x + IC) % LRAN2_MAX; - d->v[j] = x; - } - d->x = (IA*x + IC) % LRAN2_MAX; - d->y = d->x; -} - -static -long lran2(struct lran2_st* d) -{ - int j = (d->y % 97); - - d->y = d->v[j]; - d->x = (IA*d->x + IC) % LRAN2_MAX; - d->v[j] = d->x; - return d->y; -} - -#undef IA -#undef IC -#endif \ No newline at end of file diff --git a/test/perfomance/xmalloc-test.c b/test/perfomance/xmalloc-test.c deleted file mode 100644 index 99e15a30..00000000 --- a/test/perfomance/xmalloc-test.c +++ /dev/null @@ -1,286 +0,0 @@ -/** - * \file test-malloc_test.c - * \author C. Lever and D. Boreham, Christian Eder ( ederc@mathematik.uni-kl.de ) - * \date 2000 - * \brief Test file for xmalloc. This is a multi-threaded test system by - * Lever and Boreham. It is first noted in their paper "malloc() - * Performance in a Multithreaded Linux Environment", appeared at the - * USENIX 2000 Annual Technical Conference: FREENIX Track. - * This file is part of XMALLOC, licensed under the GNU General - * Public License version 3. See COPYING for more information. - */ -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -//#include "xmalloc-config.h" -//#include "xmalloc.h" - -#include "random.h" - -#define CACHE_ALIGNED 1 - -#define xmalloc malloc -#define xfree free - -#define DEFAULT_OBJECT_SIZE 1024 - -int debug_flag = 0; -int verbose_flag = 0; -#define num_workers_default 4 -int num_workers = num_workers_default; -double run_time = 5.0; -int object_size = DEFAULT_OBJECT_SIZE; -/* array for thread ids */ -pthread_t *thread_ids; -/* array for saving result of each thread */ -struct counter { - long c -#if CACHE_ALIGNED - __attribute__((aligned(64))) -#endif -; -}; -struct counter *counters; - -volatile int done_flag = 0; -struct timeval begin; - - -#define atomic_load(addr) __atomic_load_n(addr, __ATOMIC_CONSUME) -#define atomic_store(addr, v) __atomic_store_n(addr, v, __ATOMIC_RELEASE) - - -static void -tvsub(tdiff, t1, t0) - struct timeval *tdiff, *t1, *t0; -{ - - tdiff->tv_sec = t1->tv_sec - t0->tv_sec; - tdiff->tv_usec = t1->tv_usec - t0->tv_usec; - if (tdiff->tv_usec < 0) - tdiff->tv_sec--, tdiff->tv_usec += 1000000; -} - -double elapsed_time(struct timeval *time0) -{ - struct timeval timedol; - struct timeval td; - double et = 0.0; - - gettimeofday(&timedol, (struct timezone *)0); - tvsub( &td, &timedol, time0 ); - et = td.tv_sec + ((double)td.tv_usec) / 1000000; - - return( et ); -} - -static const long possible_sizes[] = {8,12,16,24,32,48,64,96,128,192,256,(256*3)/2,512, (512*3)/2, 1024, (1024*3)/2, 2048}; -static const int n_sizes = sizeof(possible_sizes)/sizeof(long); - -#define OBJECTS_PER_BATCH 4096 -struct batch { - struct batch *next_batch; - void *objects[OBJECTS_PER_BATCH]; -}; - -struct batch *batches = NULL; -volatile int batch_count = 0; -const int batch_count_limit = 100; -pthread_cond_t empty_cv = PTHREAD_COND_INITIALIZER; -pthread_cond_t full_cv = PTHREAD_COND_INITIALIZER; -pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER; - -void enqueue_batch(struct batch *batch) { - pthread_mutex_lock(&lock); - while (batch_count >= batch_count_limit && !atomic_load(&done_flag)) { - pthread_cond_wait(&full_cv, &lock); - } - batch->next_batch = batches; - batches = batch; - batch_count++; - pthread_cond_signal(&empty_cv); - pthread_mutex_unlock(&lock); -} - -struct batch* dequeue_batch() { - pthread_mutex_lock(&lock); - while (batches == NULL && !atomic_load(&done_flag)) { - pthread_cond_wait(&empty_cv, &lock); - } - struct batch* result = batches; - if (result) { - batches = result->next_batch; - batch_count--; - pthread_cond_signal(&full_cv); - } - pthread_mutex_unlock(&lock); - return result; -} - -void *mem_allocator (void *arg) { - int thread_id = *(int *)arg; - struct lran2_st lr; - lran2_init(&lr, thread_id); - - while (!atomic_load(&done_flag)) { - struct batch *b = xmalloc(sizeof(*b)); - for (int i = 0; i < OBJECTS_PER_BATCH; i++) { - size_t siz = object_size > 0 ? object_size : possible_sizes[lran2(&lr)%n_sizes]; - b->objects[i] = xmalloc(siz); - memset(b->objects[i],i%256,(siz > 128 ? 128 : siz)); - } - enqueue_batch(b); - } - return NULL; -} - -void *mem_releaser(void *arg) { - int thread_id = *(int *)arg; - - while(!atomic_load(&done_flag)) { - struct batch *b = dequeue_batch(); - if (b) { - for (int i = 0; i < OBJECTS_PER_BATCH; i++) { - xfree(b->objects[i]); - } - xfree(b); - } - counters[thread_id].c += OBJECTS_PER_BATCH; - } - return NULL; -} - -int run_memory_free_test() -{ - void *ptr = NULL; - int i; - double elapse_time = 0.0; - long total = 0; - int *ids = (int *)xmalloc(sizeof(int) * num_workers); - - /* Initialize counter */ - for(i = 0; i < num_workers; ++i) - counters[i].c = 0; - - gettimeofday(&begin, (struct timezone *)0); - - /* Start up the mem_allocator and mem_releaser threads */ - for(i = 0; i < num_workers; ++i) { - ids[i] = i; - if (verbose_flag) printf("Starting mem_releaser %i ...\n", i); - if (pthread_create(&thread_ids[i * 2], NULL, mem_releaser, (void *)&ids[i])) { - perror("pthread_create mem_releaser"); - exit(errno); - } - - if (verbose_flag) printf("Starting mem_allocator %i ...\n", i); - if (pthread_create(&thread_ids[i * 2 + 1], NULL, mem_allocator, (void *)&ids[i])) { - perror("pthread_create mem_allocator"); - exit(errno); - } - } - - if (verbose_flag) printf("Testing for %.2f seconds\n\n", run_time); - - while (1) { - usleep(1000); - if (elapsed_time(&begin) > run_time) { - atomic_store(&done_flag, 1); - pthread_cond_broadcast(&empty_cv); - pthread_cond_broadcast(&full_cv); - break; - } - } - - for(i = 0; i < num_workers * 2; ++i) - pthread_join (thread_ids[i], &ptr); - - elapse_time = elapsed_time (&begin); - - for(i = 0; i < num_workers; ++i) { - if (verbose_flag) { - printf("Thread %2i frees %ld blocks in %.2f seconds. %.2f free/sec.\n", - i, counters[i].c, elapse_time, ((double)counters[i].c/elapse_time)); - } - } - if (verbose_flag) printf("----------------------------------------------------------------\n"); - for(i = 0; i < num_workers; ++i) total += counters[i].c; - if (verbose_flag) - printf("Total %ld freed in %.2f seconds. %.2fM free/second\n", - total, elapse_time, ((double) total/elapse_time)*1e-6); - else { - double mfree_per_sec = ((double)total/elapse_time) * 1e-6; - double rtime = 100.0 / mfree_per_sec; - printf("rtime: %.3f, free/sec: %.3f M\n", rtime, mfree_per_sec); - } - if (verbose_flag) printf("Program done\n"); - if (ids!=NULL) xfree(ids); - return(0); -} - -void usage(char *prog) -{ - printf("%s [-w workers] [-t run_time] [-d] [-v]\n", prog); - printf("\t -w number of producer threads (and number of consumer threads), default %d\n", num_workers_default); - printf("\t -t run time in seconds, default 20.0 seconds.\n"); - printf("\t -s size of object to allocate (default %d bytes) (specify -1 to get many different object sizes)\n", DEFAULT_OBJECT_SIZE); - printf("\t -d debug mode\n"); - printf("\t -v verbose mode (-v -v produces more verbose)\n"); - exit(1); -} - -int main(int argc, char **argv) -{ - int c; - while ((c = getopt(argc, argv, "w:t:ds:v")) != -1) { - - switch (c) { - - case 'w': - num_workers = atoi(optarg); - break; - case 't': - run_time = atof(optarg); - break; - case 'd': - debug_flag = 1; - break; - case 's': - object_size = atoi(optarg); - break; - case 'v': - verbose_flag++; - break; - default: - usage(argv[0]); - } - } - - /* allocate memory for working arrays */ - thread_ids = (pthread_t *) xmalloc(sizeof(pthread_t) * num_workers * 2); - counters = (struct counter *) xmalloc(sizeof(*counters) * num_workers); - - run_memory_free_test(); - - while (batches) { - struct batch *b = batches; - batches = b->next_batch; - for (int i = 0 ; i < OBJECTS_PER_BATCH; i++) { - xfree(b->objects[i]); - } - xfree(b); - } - - xfree(thread_ids); - xfree(counters); - - return 0; -}