[t:4447], check in ptquery performance benchmark

/* -*- mode: C; c-basic-offset: 4 -*- */

#ident "Copyright (c) 2007 Tokutek Inc.  All rights reserved."

#ident "$Id: test_stress1.c 39258 2012-01-27 13:51:58Z zardosht $"

#include "test.h"

#include <stdio.h>

#include <stdlib.h>

#include <toku_pthread.h>

#include <unistd.h>

#include <memory.h>

#include <sys/stat.h>

#include <db.h>

#include "threaded_stress_test_helpers.h"

//

// This test is a form of stress that does operations on a single dictionary:

// We create a dictionary bigger than the cachetable (around 4x greater).

// Then, we spawn a bunch of pthreads that do the following:

//  - scan dictionary forward with bulk fetch

//  - scan dictionary forward slowly

//  - scan dictionary backward with bulk fetch

//  - scan dictionary backward slowly

//  - Grow the dictionary with insertions

//  - do random point queries into the dictionary

// With the small cachetable, this should produce quite a bit of churn in reading in and evicting nodes.

// If the test runs to completion without crashing, we consider it a success. It also tests that snapshots

// work correctly by verifying that table scans sum their vals to 0.

//

// This does NOT test:

//  - splits and merges

//  - multiple DBs

//

// Variables that are interesting to tweak and run:

//  - small cachetable

//  - number of elements

//

static void

stress_table(DB_ENV* env, DB** dbp, struct cli_args *cli_args) {

    int n = cli_args->num_elements;

    //

    // the threads that we want:

    //   - some threads constantly updating random values

    //   - one thread doing table scan with bulk fetch

    //   - one thread doing table scan without bulk fetch

    //   - some threads doing random point queries

    //

    if (verbose) printf("starting creation of pthreads\n");

    const int num_threads = cli_args->num_ptquery_threads;

    struct arg myargs[num_threads];

    for (int i = 0; i < num_threads; i++) {

        arg_init(&myargs[i], n, dbp, env, cli_args);

    }

    for (int i = 0; i < num_threads; i++) {

        myargs[i].operation = ptquery_op;

    }

    run_workers(myargs, num_threads, cli_args->time_of_test, false, cli_args);

}

int

test_main(int argc, char *const argv[]) {

    struct cli_args args = get_default_args_for_perf();

    parse_stress_test_args(argc, argv, &args);

    stress_test_main(&args);

    return 0;

}

    int update_pad_frequency;

};

static struct update_op_args get_update_op_args(struct cli_args* cli_args, int* update_history_buffer) {    

static struct update_op_args UU() get_update_op_args(struct cli_args* cli_args, int* update_history_buffer) {    

    struct update_op_args uoe;

    uoe.update_history_buffer = update_history_buffer;

    uoe.update_pad_frequency = cli_args->num_elements/100; // arbitrary

    .update_function = update_op_callback,

};

static const struct env_args DEFAULT_PERF_ENV_ARGS = {

    .node_size = 4*1024*1024,

    .basement_node_size = 128*1024,

    .checkpointing_period = 60,

    .cleaner_period = 1,

    .cleaner_iterations = 5,

    .cachetable_size = 1<<30,

    .envdir = ENVDIR,

    .update_function = NULL,

};

#define MIN_VAL_SIZE sizeof(int)

#define MIN_KEY_SIZE sizeof(int)

static struct cli_args get_default_args(void) {

    return DEFAULT_ARGS;

}

static struct cli_args get_default_args_for_perf(void) {

    struct cli_args args = get_default_args();

    args.num_elements = 1000000; //default of 1M

    args.print_performance = true;

    args.env_args = DEFAULT_PERF_ENV_ARGS;

    return args;

}

static inline void parse_stress_test_args (int argc, char *const argv[], struct cli_args *args) {

    const char *argv0=argv[0];

    while (argc>1) {