Beispiel #1
0
int main(void)
{
    plan_tests(1);

    if (getenv("SHF_PERFORMANCE_TEST_ENABLE") && atoi(getenv("SHF_PERFORMANCE_TEST_ENABLE"))) {
    }
    else {
        fprintf(stderr, "NOTE: prefix make with SHF_PERFORMANCE_TEST_ENABLE=1 ?\n");
        goto EARLY_EXIT;
    }

    uint32_t cpu_count_desired = getenv("SHF_PERFORMANCE_TEST_CPUS") ? atoi(getenv("SHF_PERFORMANCE_TEST_CPUS")) : 0;
    uint32_t test_keys_desired = getenv("SHF_PERFORMANCE_TEST_KEYS") ? atoi(getenv("SHF_PERFORMANCE_TEST_KEYS")) : 0;

    TEST_INIT();

#define TEST_MAX_PROCESSES (16)

#ifdef TEST_LMDB
             uint32_t   test_keys_default = 100 * 1000000; /* assume enough RAM is available for LMDB */
#else
             uint64_t   vfs_available_md  = shf_get_vfs_available(shf) / 1024 / 1024;
             uint32_t   test_keys_10m     = vfs_available_md / 436 * 10; /* 10M keys is about 436MB */
             uint32_t   test_keys_default = test_keys_10m > 100 ? 100 * 1000000 : test_keys_10m * 1000000; SHF_ASSERT(test_keys_default > 0, "ERROR: only %luMB available on /dev/shm but 10M keys takes at least 436MB for SharedHashFile", vfs_available_md);
#endif
             uint32_t   test_keys         = test_keys_desired ? test_keys_desired : test_keys_default;
             uint32_t   cpu_count         = cpu_count_desired ? cpu_count_desired : test_get_cpu_count();
             uint32_t   process;
             uint32_t   processes = cpu_count > TEST_MAX_PROCESSES ? TEST_MAX_PROCESSES : cpu_count;
             uint32_t   counts_old[TEST_MAX_PROCESSES] = { 0 };
    volatile uint32_t * put_counts = mmap(NULL, SHF_MOD_PAGE(TEST_MAX_PROCESSES*sizeof(uint32_t)), PROT_READ|PROT_WRITE, MAP_ANONYMOUS | MAP_SHARED | MAP_NORESERVE, -1, 0); SHF_ASSERT(MAP_FAILED != put_counts, "mmap(): %u: ", errno);
    volatile uint32_t * get_counts = mmap(NULL, SHF_MOD_PAGE(TEST_MAX_PROCESSES*sizeof(uint32_t)), PROT_READ|PROT_WRITE, MAP_ANONYMOUS | MAP_SHARED | MAP_NORESERVE, -1, 0); SHF_ASSERT(MAP_FAILED != get_counts, "mmap(): %u: ", errno);
    volatile uint32_t * mix_counts = mmap(NULL, SHF_MOD_PAGE(TEST_MAX_PROCESSES*sizeof(uint32_t)), PROT_READ|PROT_WRITE, MAP_ANONYMOUS | MAP_SHARED | MAP_NORESERVE, -1, 0); SHF_ASSERT(MAP_FAILED != mix_counts, "mmap(): %u: ", errno);
    volatile uint64_t * start_line = mmap(NULL, SHF_MOD_PAGE(                 3*sizeof(uint64_t)), PROT_READ|PROT_WRITE, MAP_ANONYMOUS | MAP_SHARED | MAP_NORESERVE, -1, 0); SHF_ASSERT(MAP_FAILED != mix_counts, "mmap(): %u: ", errno);
    SHF_ASSERT(sizeof(uint64_t) == sizeof(long), "INTERNAL: expected sizeof(uint64_t) == sizeof(long), but got %lu == %lu", sizeof(uint64_t), sizeof(long));
    start_line[0] = 0;
    start_line[1] = 0;
    start_line[2] = 0;
    for (process = 0; process < processes; process++) {
        pid_t fork_pid = fork();
        if (fork_pid == 0) {     /*child*/
            SHF_DEBUG("test process #%u with pid %5u\n", process, getpid());
            {
                long previous_long_value;
                SHF_UNUSE(previous_long_value);

                previous_long_value = InterlockedExchangeAdd((long volatile *) &start_line[0], 1);
                while (processes != start_line[0]) { SHF_YIELD(); }
                TEST_INIT_CHILD();
                for (uint32_t i = 0; i < (1 + (test_keys / processes)); i++) {
                    uint32_t key = test_keys / processes * process + i;
                    put_counts[process] ++;
                    TEST_PUT();
                }
                TEST_PUT_POST();
                TEST_MIX_PRE();
                usleep(2000000); /* 2 seconds */
                previous_long_value = InterlockedExchangeAdd((long volatile *) &start_line[1], 1);
                while (processes != start_line[1]) { SHF_YIELD(); }
                for (uint32_t i = 0; i < (1 + (test_keys / processes)); i++) {
                    uint32_t key = test_keys / processes * process + i;
                    TEST_MIX();
                }
                TEST_MIX_POST();
                TEST_GET_PRE();
                usleep(2000000); /* 2 seconds */
                previous_long_value = InterlockedExchangeAdd((long volatile *) &start_line[2], 1);
                while (processes != start_line[2]) { SHF_YIELD(); }
                for (uint32_t i = 0; i < (1 + (test_keys / processes)); i++) {
                    uint32_t key = test_keys / processes * process + i;
                    TEST_GET();
                }
                TEST_GET_POST();
                TEST_FINI();
                exit(0);
            }
            break;
        }
        else if (fork_pid > 0) { /*parent*/
            /* loop again */
        }
    }

    /* parent monitors & reports on forked children */
    uint32_t seconds            = 0;
    uint32_t key_total;
    uint32_t key_total_old      = 0;
    uint64_t tabs_mmaps_old     = 0;
    uint64_t tabs_mremaps_old   = 0;
    uint64_t tabs_shrunk_old    = 0;
    uint64_t tabs_parted_old    = 0;
    uint32_t message            = 0;
    const char * message_text = "PUT";
#ifdef SHF_DEBUG_VERSION
    uint64_t lock_conflicts_old = 0;
#endif
    char graph_100[] = "----------------------------------------------------------------------------------------------------";
    fprintf(stderr, "perf testing: " TEST_WHAT "\n");
    fprintf(stderr, "running tests on: via command: '%s'\n",               "cat /proc/cpuinfo | egrep 'model name' | head -n 1" );
    fprintf(stderr, "running tests on: `%s`\n"             , shf_backticks("cat /proc/cpuinfo | egrep 'model name' | head -n 1"));
    do {
        if (0 == seconds % 50) {
#ifdef SHF_DEBUG_VERSION
            fprintf(stderr, "-LOCKC ");
#endif
            fprintf(stderr, "-OP MMAP REMAP SHRK PART TOTAL ------PERCENT OPERATIONS PER PROCESS PER SECOND -OPS\n");
#ifdef SHF_DEBUG_VERSION
            fprintf(stderr, "------ ");
#endif
            fprintf(stderr, "--- -k/s --k/s --/s --/s M-OPS 00 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 -M/s\n");
        }
        seconds ++;
        // todo: add % system CPU time to per second summary line; why does put require so much system?
#ifdef SHF_DEBUG_VERSION
        {
            uint64_t lock_conflicts = 0;
            for (uint32_t win = 0; win < SHF_WINS_PER_SHF; win++) {
                lock_conflicts += shf->shf_mmap->wins[win].lock.conflicts;
            }
            fprintf(stderr, "%6lu ", lock_conflicts - lock_conflicts_old);
            lock_conflicts_old = lock_conflicts;
        }
#endif
        fprintf(stderr, "%s", message_text);
        {
            uint64_t tabs_mmaps   = 0;
            uint64_t tabs_mremaps = 0;
            uint64_t tabs_shrunk  = 0;
            uint64_t tabs_parted  = 0;
#ifdef TEST_SHF
            for (uint32_t win = 0; win < SHF_WINS_PER_SHF; win++) {
                tabs_mmaps   += shf->shf_mmap->wins[win].tabs_mmaps  ;
                tabs_mremaps += shf->shf_mmap->wins[win].tabs_mremaps;
                tabs_shrunk  += shf->shf_mmap->wins[win].tabs_shrunk ;
                tabs_parted  += shf->shf_mmap->wins[win].tabs_parted ;
            }
#endif
            fprintf(stderr, "%5.1f %5.1f %4llu %4llu",
                (tabs_mmaps   - tabs_mmaps_old  ) / 1000.0,
                (tabs_mremaps - tabs_mremaps_old) / 1000.0,
                (tabs_shrunk  - tabs_shrunk_old )         ,
                (tabs_parted  - tabs_parted_old )         );
            tabs_mmaps_old   = tabs_mmaps  ;
            tabs_mremaps_old = tabs_mremaps;
            tabs_shrunk_old  = tabs_shrunk ;
            tabs_parted_old  = tabs_parted ;
        }
        {
            key_total = 0;
            uint32_t key_total_this_second = 0;
            for (process = 0; process < TEST_MAX_PROCESSES; process++) {
                key_total             += put_counts[process] + get_counts[process] + mix_counts[process];
                key_total_this_second += put_counts[process] + get_counts[process] + mix_counts[process] - counts_old[process];
            }
            fprintf(stderr, " %5.1f", key_total / 1000.0 / 1000.0);
            for (process = 0; process < TEST_MAX_PROCESSES; process++) {
                fprintf(stderr, "%3.0f", (put_counts[process] + get_counts[process] + mix_counts[process] - counts_old[process]) * 100.0 / (0 == key_total_this_second ? 1 : key_total_this_second));
                counts_old[process] = put_counts[process] + get_counts[process] + mix_counts[process];
            }
            uint32_t key_total_per_second = key_total - key_total_old;
            fprintf(stderr, "%5.1f %s\n", key_total_per_second / 1000.0 / 1000.0, &graph_100[100 - (key_total_per_second / 750000)]);
            if      (0 == message && key_total >= (1 * test_keys)) { message ++; message_text = "MIX"; }
            else if (1 == message && key_total >= (2 * test_keys)) { message ++; message_text = "GET"; }
            key_total_old = key_total;
        }
        usleep(1000000); /* one second */
    } while (key_total < (3 * test_keys));
    fprintf(stderr, "* MIX is 2%% (%u) del/put, 98%% (%u) get\n", test_keys * 2 / 100, test_keys * 98 / 100);

    TEST_FINI_MASTER();

EARLY_EXIT:;

    ok(1, "test still alive");
    return exit_status();
} /* main() */
Beispiel #2
0
int
main(int argc, char **argv) {
    const char * mode = NULL;

    SHF_ASSERT(NULL != setlocale(LC_NUMERIC, ""), "setlocale(): %u: ", errno);

    if (argc >= 2) {
        SHF_ASSERT((0 == memcmp(argv[1], SHF_CONST_STR_AND_SIZE("c2js")))
        ||         (0 == memcmp(argv[1], SHF_CONST_STR_AND_SIZE("c2c" )))
        ||         (0 == memcmp(argv[1], SHF_CONST_STR_AND_SIZE("4c"  ))), "ERROR: please supply an argument; c2js, c2py, c2c, or 4c; got: '%s'", argv[1]);
    }

         if (argc > 1 && 0 == memcmp(argv[1], SHF_CONST_STR_AND_SIZE("c2js"))) { plan_tests( 6); mode = strdup(argv[1]); }
    else if (argc > 1 && 0 == memcmp(argv[1], SHF_CONST_STR_AND_SIZE("c2py"))) { plan_tests( 5); mode = strdup(argv[1]); }
    else if (argc > 1 && 0 == memcmp(argv[1], SHF_CONST_STR_AND_SIZE("c2c" ))) { plan_tests( 9); mode = strdup(argv[1]); }
    else if (argc > 1 && 0 == memcmp(argv[1], SHF_CONST_STR_AND_SIZE("4c"  ))) { plan_tests( 7); mode = strdup(argv[1]); }
    else                                                                       { plan_tests(10); mode = "c2c"          ; } /* default if no arguments */

    pid_t pid = getpid();
    SHF_DEBUG("pid %u started; mode is '%s'\n", pid, mode);

    if (0 == memcmp(mode, SHF_CONST_STR_AND_SIZE("c2js"))) { /* just for fun, test C to C call speed; useful for comparing to V8 to C call speed */
        double test_start_time = shf_get_time_in_seconds();
        double test_iterations = 0;
        do {
            test_iterations += test_dummy();
        } while (test_iterations < 10000000);
        double test_elapsed_time = shf_get_time_in_seconds() - test_start_time;
        ok(1, "   c2*: called  expected number to dummy function  // estimate %'.0f calls per second", test_iterations / test_elapsed_time);
    }

    char  test_shf_name[256];
    char  test_shf_folder[] = "/dev/shm";
    SHF_SNPRINTF(1, test_shf_name, "test-%05u-ipc-queue", pid);

    SHF      * shf;
    uint32_t   uid;
    uint32_t   test_keys = 100000;

    if (0 == memcmp(mode, SHF_CONST_STR_AND_SIZE("4c"))) {
        SHF_ASSERT(argc == 3, "ERROR: please supply arguments; 4c <name of shf>");

              shf_debug_verbosity_less();
              shf_init                ();
        shf = shf_attach_existing     (test_shf_folder, argv[2]); ok(NULL != shf, "    4c: shf_attach_existing() works for existing file as expected");
              shf_log_attach_existing (shf                     );

        shf_debug_verbosity_more(); SHF_DEBUG("'4c' mode; behaving as client\n"); shf_debug_verbosity_less();

        char     * test_q_items_addr  = shf_q_get(shf); SHF_UNUSE(test_q_items_addr); /* todo: this test doesn't actually manipulate the item itself */
        uint32_t   test_qid_free      = shf_q_get_name(shf, SHF_CONST_STR_AND_SIZE("qid-free"));
        uint32_t   test_qid_a2b       = shf_q_get_name(shf, SHF_CONST_STR_AND_SIZE("qid-a2b" ));
        uint32_t   test_qid_b2a       = shf_q_get_name(shf, SHF_CONST_STR_AND_SIZE("qid-b2a" ));
        ok(        test_qid_free     != SHF_QID_NONE, "    4c: shf_q_get_name('qid-free') returned qid as expected");
        ok(        test_qid_a2b      != SHF_QID_NONE, "    4c: shf_q_get_name('qid-a2b' ) returned qid as expected");
        ok(        test_qid_b2a      != SHF_QID_NONE, "    4c: shf_q_get_name('qid-b2a' ) returned qid as expected");

        shf_race_start(shf, SHF_CONST_STR_AND_SIZE("test-q-race-line"), 2);
        shf_debug_verbosity_more(); SHF_DEBUG("testing process b IPC queue a2b --> b2a speed\n"); shf_debug_verbosity_less();
        {
            uint32_t test_pull_items = 0;
            double   test_start_time = shf_get_time_in_seconds();
            shf_qiid = SHF_QIID_NONE;
            while(1) {
                while(SHF_QIID_NONE != shf_q_push_head_pull_tail(shf, test_qid_b2a, shf_qiid, test_qid_a2b)) {
                                       test_pull_items ++;
                }
                if (test_pull_items >= 1000000) { goto FINISH_LINE_4C; }
            }
FINISH_LINE_4C:;
            double test_elapsed_time = shf_get_time_in_seconds() - test_start_time;
            ok(1, "    4c: moved   expected number of new queue items // estimate %'.0f q items per second with contention", test_pull_items / test_elapsed_time);
        }

        {
            shf_debug_verbosity_more(); SHF_DEBUG("testing process b IPC lock speed\n"); shf_debug_verbosity_less();

                                    SHF_MAKE_HASH       ("lock");
            SHF_LOCK * lock  =      shf_get_key_val_addr(shf   );
            ok(        lock != NULL                             , "    4c: got lock value address as expected");

            shf_race_start(shf, SHF_CONST_STR_AND_SIZE("test-lock-race-line"), 2);
            double test_start_time = shf_get_time_in_seconds();
            double test_lock_iterations = 0;
            do {
                SHF_LOCK_WRITER(lock);
                SHF_UNLOCK_WRITER(lock);
                test_lock_iterations ++;
            } while (test_lock_iterations < 2000000);
            double test_elapsed_time = shf_get_time_in_seconds() - test_start_time;
            ok(1, "    4c: rw lock expected number of times           // estimate %'.0f locks per second; with contention", test_lock_iterations / test_elapsed_time);
        }

        shf_debug_verbosity_more(); SHF_DEBUG("ending child\n"); shf_debug_verbosity_less();

        shf_detach(shf);

        goto EARLY_OUT;
    } /* 4c */

          shf_debug_verbosity_less();
          shf_init                ();
          shf_set_data_need_factor(1);
    shf = shf_attach              (test_shf_folder, test_shf_name, 1 /* delete upon process exit */); ok(NULL != shf, "   c2*: shf_attach()          works for non-existing file as expected");
          shf_log_thread_new      (shf, 0 /* use default log buffer size */, STDOUT_FILENO);

    {
        shf_race_init(shf, SHF_CONST_STR_AND_SIZE("test-q-race-line"   ));
        shf_race_init(shf, SHF_CONST_STR_AND_SIZE("test-lock-race-line"));

        if (0 == memcmp(mode, SHF_CONST_STR_AND_SIZE("c2c"))) {
                      SHF_MAKE_HASH  (                     "lock");
               uid =  shf_put_key_val(shf, NULL, sizeof(SHF_LOCK));
            ok(uid != SHF_UID_NONE                                , "   c2*: put lock in value as expected");
        }
    }

    uint32_t test_qs          = 3;
    uint32_t test_q_items     = 100000;
    uint32_t test_q_item_size = 4096;
    ok(      NULL            != shf_q_new     (shf, test_qs, test_q_items, test_q_item_size, 1000), "   c2*: shf_q_new() returned as expected");
    uint32_t test_qid_free    = shf_q_new_name(shf, SHF_CONST_STR_AND_SIZE("qid-free")           );
    uint32_t test_qid_a2b     = shf_q_new_name(shf, SHF_CONST_STR_AND_SIZE("qid-a2b" )           );
    uint32_t test_qid_b2a     = shf_q_new_name(shf, SHF_CONST_STR_AND_SIZE("qid-b2a" )           );

    {
        double   test_start_time = shf_get_time_in_seconds();
        uint32_t test_pull_items = 0;
        while(SHF_QIID_NONE != shf_q_pull_tail(shf, test_qid_free          )) {
                               shf_q_push_head(shf, test_qid_a2b , shf_qiid);
                               test_pull_items ++;
        }
        double test_elapsed_time = shf_get_time_in_seconds() - test_start_time;
        ok(test_q_items == test_pull_items, "   c2*: moved   expected number of new queue items // estimate %'.0f q items per second without contention", test_keys / test_elapsed_time);
    }

    pid_t child_pid = 0;
    if      (0 == memcmp(mode, SHF_CONST_STR_AND_SIZE("c2js"))) { child_pid = shf_exec_child(shf_backticks("which node || which nodejs"), shf_backticks("which node || which nodejs"), "TestIpcQueue.js", test_shf_name); }
    else if (0 == memcmp(mode, SHF_CONST_STR_AND_SIZE("c2py"))) { child_pid = shf_exec_child(shf_backticks("which python"              ), "python"                                   , "TestIpcQueue.py", test_shf_name); }
    else if (0 == memcmp(mode, SHF_CONST_STR_AND_SIZE("c2c" ))) { child_pid = shf_exec_child(shf_backticks("which test.q.shf.t"        ), "test.q.shf.t"                             , "4c"             , test_shf_name); }
    else                                                        { SHF_ASSERT(0, "ERROR: should never get here!"); }

    shf_race_start(shf, SHF_CONST_STR_AND_SIZE("test-q-race-line"), 2);
    shf_debug_verbosity_more(); SHF_DEBUG("testing process a IPC queue b2a --> a2b speed\n"); shf_debug_verbosity_less();
    {
        double   test_start_time = shf_get_time_in_seconds();
        uint32_t test_pull_items = 0;
        shf_qiid = SHF_QIID_NONE;
        while (1) {
            while(SHF_QIID_NONE != shf_q_push_head_pull_tail(shf, test_qid_a2b, shf_qiid, test_qid_b2a)) {
                                   test_pull_items ++;
                if (1000000     == test_pull_items) { shf_q_push_head_pull_tail(shf, test_qid_a2b, shf_qiid, test_qid_b2a); goto FINISH_LINE_C2; }
            }
            if ((0 == memcmp(mode, SHF_CONST_STR_AND_SIZE("c2js")))
            ||  (0 == memcmp(mode, SHF_CONST_STR_AND_SIZE("c2py")))) { /* the rw spin locks are fair but don't create unnecessary contention for javascript or python client */
                usleep(1000); /* 1/1000th of a second */
            }
        }
FINISH_LINE_C2:;
        double test_elapsed_time = shf_get_time_in_seconds() - test_start_time;
        usleep(3000); /* hack: wait 3/1000th of a second so that the oks do not conflict */
        ok(1, "   c2*: moved   expected number of new queue items // estimate %'.0f q items per second with contention", test_pull_items / test_elapsed_time);
    }

    if (0 == memcmp(mode, SHF_CONST_STR_AND_SIZE("c2c"))) {
        shf_debug_verbosity_more(); SHF_DEBUG("testing process a IPC lock speed\n"); shf_debug_verbosity_less();

                                SHF_MAKE_HASH       ("lock");
        SHF_LOCK * lock  =      shf_get_key_val_addr(shf   );
        ok(        lock != NULL                             , "   c2*: got lock value address as expected");

        shf_race_start(shf, SHF_CONST_STR_AND_SIZE("test-lock-race-line"), 2);
        double test_start_time = shf_get_time_in_seconds();
        double test_lock_iterations = 0;
        do {
            SHF_LOCK_WRITER(lock);
            SHF_UNLOCK_WRITER(lock);
            test_lock_iterations ++;
        } while (test_lock_iterations < 2000000);
        double test_elapsed_time = shf_get_time_in_seconds() - test_start_time;
        ok(1, "   c2*: rw lock expected number of times           // estimate %'.0f locks per second; with contention", test_lock_iterations / test_elapsed_time);

        SHF_LOCK lock_without_contention;
        memset(&lock_without_contention, 0, sizeof(lock_without_contention));
        test_start_time = shf_get_time_in_seconds();
        test_lock_iterations = 0;
        do {
            SHF_LOCK_WRITER(&lock_without_contention);
            SHF_UNLOCK_WRITER(&lock_without_contention);
            test_lock_iterations ++;
        } while (test_lock_iterations < 2000000);
        test_elapsed_time = shf_get_time_in_seconds() - test_start_time;
        ok(1, "   c2*: rw lock expected number of times           // estimate %'.0f locks per second; without contention", test_lock_iterations / test_elapsed_time);

        test_start_time = shf_get_time_in_seconds();
        test_lock_iterations = 0;
        do {
            test_lock_iterations ++;
        } while (test_lock_iterations < 2000000);
        test_elapsed_time = shf_get_time_in_seconds() - test_start_time;
        ok(1, "   c2*: rw lock expected number of times           // estimate %'.0f locks per second; without lock, just loop", test_lock_iterations / test_elapsed_time);
    }

    shf_debug_verbosity_more();

    int status;
    waitpid(child_pid, &status, 0);

    ok(1, "   c2*: test still alive");

    SHF_DEBUG("ending parent\n");

    SHF_PLAIN("test: shf size before deletion: %s\n", shf_del(shf));

EARLY_OUT:;

    return exit_status();
} /* main() */