libjf API reference guide

jf_bench.c

Go to the documentation of this file.

/*
 * Copyright 2005 Tiian
 * {In real life Tiian is Christian Ferrari}
 * This file is part of "libjf" package.
 *
 * "libjf" 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.
 *
 * "libjf" 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 ; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
#include <jf/jf_config.h>



#ifdef HAVE_ERRNO_H
# include <errno.h>
#endif /* HAVE_ERRNO_H */
#ifdef HAVE_STRING_H
# include <string.h>
#endif /* HAVE_STRING_H */
#ifdef HAVE_LIBGEN_H
# include <libgen.h>
#endif /* HAVE_LIBGEN_H */

#include <jf_file.h>
#include <jf/jf_timer.h>
#include <jf/jf_patches.h>



/* set module trace flag */
#ifdef JF_TRACE_MODULE
# undef JF_TRACE_MODULE
#endif /* JF_TRACE_MODULE */
#define JF_TRACE_MODULE   JF_TRACE_MOD_PRG_UTILS



/* this is the official libjf benchmark utility program */



#define VERBOSE_MODE_SIL     0
#define VERBOSE_MODE_MIN     1
#define VERBOSE_MODE_MID     2
#define VERBOSE_MODE_MAX     3

const char *bench_file_name = "jf_bench_file_";

struct bench_table_rec_s {
        char       *name;
        FILE     *stream;
        jf_file_t  jfile;
};


typedef struct {
        int                       last; /* n + 1: position 0 is used for
                                         * journal (if any, positions 1 .. n
                                         * are used for data files */
        uint32_t                  policy;
        struct bench_table_rec_s *records;
        jf_journal_t              journal;
} bench_table_t;



int bench_table_create(bench_table_t *bt, const char *path_prefix,
                       int number_of_files);

int bench_table_unlink(const bench_table_t *bt);

int bench_table_destroy(bench_table_t *bt);

static inline int bench_table_get_last(const bench_table_t *bt)
{
        return bt->last;
}

static inline const char *bench_table_get_name(
        const bench_table_t *bt, int i)
{
#ifdef _EXTRA_CHECK
        if (i > bt->last)
                return NULL;
        else
#endif /* _EXTRA_CHECK */
                return bt->records[i].name;
}

static inline int bench_table_set_stream(bench_table_t *bt, int i,
                                         FILE *stream)
{
#ifdef _EXTRA_CHECK
        if (i > bt->last)
                return JF_RC_OUT_OF_RANGE;
#endif /* _EXTRA_CHECK */
        bt->records[i].stream = stream;
        return JF_RC_OK;
}

static inline FILE *bench_table_get_stream(bench_table_t *bt, int i)
{
#ifdef _EXTRA_CHECK
        if (i > bt->last)
                return NULL;
#endif /* _EXTRA_CHECK */
        return bt->records[i].stream;
}

static inline int bench_table_set_jfile(bench_table_t *bt, int i,
                                        jf_file_t *jf)
{
#ifdef _EXTRA_CHECK
        if (i > bt->last)
                return JF_RC_OUT_OF_RANGE;
#endif /* _EXTRA_CHECK */
        bt->records[i].jfile = *jf;
        return JF_RC_OK;
}

static inline jf_file_t *bench_table_get_jfile(bench_table_t *bt, int i)
{
#ifdef _EXTRA_CHECK
        if (i > bt->last)
                return NULL;
#endif /* _EXTRA_CHECK */
        return &(bt->records[i].jfile);
}

static inline void bench_table_reset(bench_table_t *bt)
{
        bt->last = 0;
        bt->policy = 0;
        bt->records = NULL;
}

static inline void bench_table_set_journal(bench_table_t *bt, jf_journal_t *j)
{
        bt->journal = *j;
}

static inline jf_journal_t *bench_table_get_journal(bench_table_t *bt)
{
        return &(bt->journal);
}

static inline uint32_t bench_table_get_policy(const bench_table_t *bt)
{
        return bt->policy;
}

static inline void bench_table_set_policy(bench_table_t *bt, uint32_t policy)
{
        bt->policy = policy;
}



#define BENCH_00_SIO_BLOCKS_SAFE    100
#define BENCH_00_SIO_BLOCKS_FAST    (100 * BENCH_00_SIO_BLOCKS_SAFE)


/* Helper functions */
int bench_X0_sio_pre(bench_table_t *bt,
                     const char *path_prefix, int number_of_files,
                     uint32_t policy, const char *open_mode);
int bench_X0_sio_post(bench_table_t *bt);
int bench_X0_ljf_pre(bench_table_t *bt,
                     const char *path_prefix, int number_of_files,
                     uint32_t policy, const char *open_mode);
int bench_X0_ljf_post(bench_table_t *bt);

int bench_X1_sio_pre(bench_table_t *bt,
                     const char *path_prefix, int number_of_files,
                     size_t block_size, int record_num,
                     uint32_t policy, const char *open_mode);
int bench_X1_ljf_pre(bench_table_t *bt,
                     const char *path_prefix, int number_of_files,
                     size_t block_size, int record_num,
                     uint32_t policy, const char *open_mode);

/*
 * All benchmark functions have the same prototype:
 * path_prefix: place for files
 * number_of_file: how many files the bench should use
 * block_size: how many data for operation (not used in "_pre" and "_post")
 * policy: JF_JOURNAL_PROP_SYNC_SAFE -> fsync/fdatasync,
 *         JF_JOURNAL_PROP_SYNC_FAST -> fflush
 */
int bench_00_sio_pre(bench_table_t *bt,
                     const char *path_prefix, int number_of_files,
                     size_t block_size, int record_num, uint32_t policy);
int bench_00_sio_run(bench_table_t *bt, const void *buffer,
                     size_t block_size, int record_num);
int bench_00_sio_post(bench_table_t *bt);

int bench_00_ljf_pre(bench_table_t *bt,
                     const char *path_prefix, int number_of_files,
                     size_t block_size, int record_num, uint32_t policy);
int bench_00_ljf_run(bench_table_t *bt, const void *buffer,
                     size_t block_size, int record_num);
int bench_00_ljf_post(bench_table_t *bt);

int bench_01_sio_pre(bench_table_t *bt,
                     const char *path_prefix, int number_of_files,
                     size_t block_size, int record_num, uint32_t policy);
int bench_01_sio_run(bench_table_t *bt, const void *buffer,
                     size_t block_size, int record_num);
int bench_01_sio_post(bench_table_t *bt);

int bench_01_ljf_pre(bench_table_t *bt,
                     const char *path_prefix, int number_of_files,
                     size_t block_size, int record_num, uint32_t policy);
int bench_01_ljf_run(bench_table_t *bt, const void *buffer,
                     size_t block_size, int record_num);
int bench_01_ljf_post(bench_table_t *bt);

int bench_02_sio_pre(bench_table_t *bt,
                     const char *path_prefix, int number_of_files,
                     size_t block_size, int record_num, uint32_t policy);
int bench_02_sio_run(bench_table_t *bt, const void *buffer,
                     size_t block_size, int record_num);
int bench_02_sio_post(bench_table_t *bt);

int bench_02_ljf_pre(bench_table_t *bt,
                     const char *path_prefix, int number_of_files,
                     size_t block_size, int record_num, uint32_t policy);
int bench_02_ljf_run(bench_table_t *bt, const void *buffer,
                     size_t block_size, int record_num);
int bench_02_ljf_post(bench_table_t *bt);

int bench_03_sio_pre(bench_table_t *bt,
                     const char *path_prefix, int number_of_files,
                     size_t block_size, int record_num, uint32_t policy);
int bench_03_sio_run(bench_table_t *bt, const void *buffer,
                     size_t block_size, int record_num);
int bench_03_sio_post(bench_table_t *bt);

int bench_03_ljf_pre(bench_table_t *bt,
                     const char *path_prefix, int number_of_files,
                     size_t block_size, int record_num, uint32_t policy);
int bench_03_ljf_run(bench_table_t *bt, const void *buffer,
                     size_t block_size, int record_num);
int bench_03_ljf_post(bench_table_t *bt);



typedef int (*bench_func_pre_t)(bench_table_t *bt,
                                const char *path_prefix, int number_of_files,
                                size_t block_size, int record_num,
                                uint32_t policy);

typedef int (*bench_func_run_t)(bench_table_t *bt, const void *buffer,
                                size_t block_size, int record_num);

typedef int (*bench_func_post_t)(bench_table_t *bt);

struct bench_test_func_s {
        const char        *descr;
        double             ratio_multiplier;
        bench_func_pre_t   ljf_pre;
        bench_func_run_t   ljf_run;
        bench_func_post_t  ljf_post;
        bench_func_pre_t   sio_pre;
        bench_func_run_t   sio_run;
        bench_func_post_t  sio_post;
};

struct bench_test_time_s {
        int    valid;
        double ljf_usr;
        double ljf_sys;
        double ljf_ela;
        double sio_usr;
        double sio_sys;
        double sio_ela;
};

void bench_test_time_reset(struct bench_test_time_s *btt);



/* number of times a bench must be repeated */
#define BENCH_TEST_REPETITIONS 12

/* number of transactions for every bench */
#define BENCH_TEST_TRANSACTIONS  25

/* this factor is used to determine the size of the file must be used for
 * update benchmarks;
 * NOTE: can NOT be less than 2 */
#define BENCH_TEST_UPDATE_FACTOR    100

static struct bench_test_func_s bench_test_func_array[] = {
        { "Append only test", 1.0,
          bench_00_ljf_pre, bench_00_ljf_run, bench_00_ljf_post,
          bench_00_sio_pre, bench_00_sio_run, bench_00_sio_post },
        { "Append, seek, read test", 2.0,
          bench_01_ljf_pre, bench_01_ljf_run, bench_01_ljf_post,
          bench_01_sio_pre, bench_01_sio_run, bench_01_sio_post },
        { "Seek, update test", 1.0,
          bench_02_ljf_pre, bench_02_ljf_run, bench_02_ljf_post,
          bench_02_sio_pre, bench_02_sio_run, bench_02_sio_post },
        { "Seek, read, seek, update test", 2.0,
          bench_03_ljf_pre, bench_03_ljf_run, bench_03_ljf_post,
          bench_03_sio_pre, bench_03_sio_run, bench_03_sio_post }
};

#define BENCH_TEST_TESTYPES (sizeof(bench_test_func_array)/sizeof(struct bench_test_func_s))

/* record size used for operations */
/* ORDER IS MANDATORY */
static size_t bench_test_recsize_array[] = {
        16, 256, 4096
};

#define BENCH_TEST_RECSIZES (sizeof(bench_test_recsize_array)/sizeof(size_t))

#define BENCH_TEST_MAX_RECSIZE  (bench_test_recsize_array[BENCH_TEST_RECSIZES -1 ])

/* number of records between sync point */
/* ORDER IS MANDATORY */
static int bench_test_recnum_array[] = {
        1, 10, 100
};

#define BENCH_TEST_RECNUMS (sizeof(bench_test_recnum_array)/sizeof(int))

/* number of file in transaction */
/* ORDER IS MANDATORY */
static int bench_test_numfile_array[] = {
        1, 5
};

#define BENCH_TEST_NUMFILES (sizeof(bench_test_numfile_array)/sizeof(int))

typedef struct bench_test_time_s bench_test_results_t[BENCH_TEST_REPETITIONS][BENCH_TEST_NUMFILES][BENCH_TEST_RECSIZES][BENCH_TEST_RECNUMS][BENCH_TEST_TESTYPES];

/* reset data matrix */
void bench_test_results_reset(bench_test_results_t btr);

/* compute data matrix */
int bench_test_results_compute(bench_test_results_t btr);

/* compute data cell */
int bench_test_results_compute_one(bench_test_results_t btr,
                                   int repetition,
                                   int number_of_file,
                                   int record_size,
                                   int record_num,
                                   int test_type);

/* remove best and worst data */
void bench_test_results_clean(bench_test_results_t btr);

/* report benchmark data */
void bench_test_results_report(bench_test_results_t btr);



void print_help(char *arg);



static long verbose_mode = VERBOSE_MODE_MIN;
static uint32_t sync_type = JF_JOURNAL_PROP_SYNC_SAFE;
static char *path_prefix = NULL;
static char *csv_file_name = NULL;
static char *xml_file_name = NULL;
static void *buffer = NULL;



int main(int argc, char *argv[])
{
        int opt;
        int ret_cod;
        bench_test_results_t btr;
        
        if (argc < 1) {
                print_help(argv[0]);
                return 1;
        } /* if (argc < 2) */
      
        // parsing args
        while ((opt = getopt(argc, argv, "p:c:v:x:hf")) != -1) {
                switch (opt) {
                    case 'p': /* path prefix */
                        if (NULL == (path_prefix = (char *)malloc(
                                             strlen(optarg) + 1))) {
                                fprintf(stderr, "%s: unable to allocate "
                                        "memory for path prefix string\n",
                                        basename(argv[0]));
                                return 1;
                        }
                        strcpy(path_prefix, optarg);
                        break;
                    case 'h': /* print help and exit */
                        print_help(argv[0]);
                        return 0;
                        break;
                    case 'c': /* csv file name */
                        csv_file_name = optarg;
                        break;
                    case 'x': /* xml file name */
                        xml_file_name = optarg;
                        break;
                    case 'v': /* verbose mode */
                        verbose_mode = strtol(optarg, NULL, 0);
                        break;
                    case 'f': /* fast sync type */
                        sync_type = JF_JOURNAL_PROP_SYNC_FAST;
                        break;
                    case '?':
                    case ':':
                        print_help(argv[0]);
                        return 1;
                        break;
                    default:
                        fprintf(stderr, 
                                "%s: internal error, option '-%c' not "
                                "handled\n", argv[0], opt);
                        return 1;
                } // switch (opt)
        } // while opt

        if (NULL == path_prefix) {
                print_help(argv[0]);
                return 1;
        }

        if (NULL == (buffer = malloc(bench_test_recsize_array[
                                             BENCH_TEST_RECSIZES-1]))) {
                fprintf(stderr, "%s: buffer can NOT be allocated\n",
                        basename(argv[0]));
                return 1;
        } /* if (NULL == (buffer = malloc(MAX_BUFFER_SIZE))) */

        bench_test_results_reset(btr);

        if (JF_RC_OK != (ret_cod = bench_test_results_compute(btr))) {
                fprintf(stderr, "%s/bench_test_results_compute: "
                        "error while computing benchmark results: %d/%s\n",
                        basename(argv[0]), ret_cod, jf_strerror(ret_cod));
                return 1;
        } /* if (JF_RC_OK != (ret_cod = bench_test_results_compute(btr))) */
        
        bench_test_results_clean(btr);
        
        bench_test_results_report(btr);
        
        if (NULL != path_prefix)
                free(path_prefix);

        return 0;
}



void print_help(char *arg)
{
        printf("Usage: %s -p <path prefix> [-c <csv file name>] [-x <xml file name>] [-v{0|1|2}] [-f] [-h]\n",
               basename(arg));
        printf("Execute library benchmark\n\n");
        printf("\t-c <csv file name> : produce a comma separated value with details\n");
        printf("\t-x <xml file name> : produce a XML file with details\n");
        printf("\t-v : verbose mode -v0 -v1 -v2\n");
        printf("\t-p <path prefix> : where bench files must be allocated\n"
               "\t\texamples:   '-p /tmp/'   '-p $HOME/tmp/'\n");
        printf("\t-f : use fast sync instead of safe sync\n");
        printf("\t-h : print this help\n");
}



int bench_table_create(bench_table_t *bt, const char *path_prefix,
                       int number_of_files)
{
        enum Exception { INVALID_OPTION
                         , INVALID_STATUS
                         , MALLOC_ERROR1
                         , MALLOC_ERROR2
                         , NONE } excp;
        int ret_cod = JF_RC_INTERNAL_ERROR;

        JF_TRACE(("bench_table_create\n"));
        TRY {
                int i;
        
                if (number_of_files < 1)
                        THROW(INVALID_OPTION);
                if (bt->last != 0)
                        THROW(INVALID_STATUS);
                
                bt->records = (struct bench_table_rec_s *)malloc(
                        (number_of_files + 1) *
                        sizeof(struct bench_table_rec_s));
                if (NULL == bt->records)
                        THROW(MALLOC_ERROR1);
                for (i = 0; i <= number_of_files; ++i) {
                        if (NULL == (bt->records[i].name = (char *)malloc(
                                             strlen(path_prefix) +
                                             strlen(bench_file_name) + 100)))
                                THROW(MALLOC_ERROR2);
                        sprintf(bt->records[i].name, "%s%s%d", path_prefix,
                                bench_file_name, i);
                        JF_TRACE(("File name %d >%s<\n",
                                  i, bt->records[i].name));
                } /* for (i = 0; i <= number_of_files; ++i) */
                bt->last = number_of_files;
                
                THROW(NONE);
        } CATCH {
                switch (excp) {
                    case INVALID_OPTION:
                        ret_cod = JF_RC_INVALID_OPTION;
                        break;
                    case INVALID_STATUS:
                        ret_cod = JF_RC_INVALID_STATUS;
                        break;
                    case MALLOC_ERROR1:
                    case MALLOC_ERROR2:
                        ret_cod = JF_RC_MALLOC_ERROR;
                        break;
                    case NONE:
                        ret_cod = JF_RC_OK;
                        break;
                    default:
                        ret_cod = JF_RC_INTERNAL_ERROR;
                } /* switch (excp) */
        } /* TRY-CATCH */
        JF_TRACE(("bench_table_create/excp=%d/"
                  "ret_cod=%d/errno=%d\n", excp, ret_cod, errno));
        return ret_cod;
}



int bench_table_unlink(const bench_table_t *bt)
{
        enum Exception { UNLINK_ERROR
                         , NONE } excp;
        int ret_cod = JF_RC_INTERNAL_ERROR;

        JF_TRACE(("bench_table_unlink\n"));
        TRY {
                int i;
                
                for (i = 0; i <= bt->last; ++i) {
                        if (0 != unlink(bt->records[i].name) &&
                            ENOENT != errno)
                                THROW(UNLINK_ERROR);
                } /* for (i = 0; i <= bt->last; ++i) */
                
                THROW(NONE);
        } CATCH {
                switch (excp) {
                    case UNLINK_ERROR:
                        ret_cod = JF_RC_UNLINK_ERROR;
                        break;
                    case NONE:
                        ret_cod = JF_RC_OK;
                        break;
                    default:
                        ret_cod = JF_RC_INTERNAL_ERROR;
                } /* switch (excp) */
        } /* TRY-CATCH */
        JF_TRACE(("bench_table_unlink/excp=%d/"
                  "ret_cod=%d/errno=%d\n", excp, ret_cod, errno));
        return ret_cod;
}



int bench_table_destroy(bench_table_t *bt)
{
        int i;
        
        if (bt->last < 0)
                return -1;
        if (bt->last == 0)
                return 0;

        for (i = 0; i <= bt->last; ++i) {
                JF_TRACE(("File name %d >%s<\n", i, bt->records[i].name));
                free(bt->records[i].name);
                bt->records[i].name = NULL;
        } /* for (i = 0; i <= bt->n; ++i) */
        free(bt->records);
        bt->records = NULL;
        bt->last = 0;
        return 0;
}



void bench_test_time_reset(struct bench_test_time_s *btt)
{
        btt->valid = FALSE;
        btt->ljf_usr = btt->ljf_sys = btt->ljf_ela =
                btt->sio_usr = btt->sio_sys = btt->sio_ela = 0.0;
}



void bench_test_results_reset(bench_test_results_t btr)
{
        int i, j, k, l, m;

        for (i = 0; i < BENCH_TEST_REPETITIONS; ++i)
                for (j = 0; j < BENCH_TEST_NUMFILES; ++j)
                        for (k = 0; k < BENCH_TEST_RECSIZES; ++k)
                                for (l = 0; l < BENCH_TEST_RECNUMS; ++l)
                                        for (m = 0; m < BENCH_TEST_TESTYPES;
                                             ++m)
                                                bench_test_time_reset(
                                                        &(btr[i][j][k][l][m]));
}



int bench_test_results_compute(bench_test_results_t btr)
{
        enum Exception { COMPUTE_ONE
                         , NONE } excp;
        int ret_cod = JF_RC_INTERNAL_ERROR;

        JF_TRACE(("bench_test_results_compute\n"));
        TRY {
                int i, j, k, l, m;
                
                for (i = 0; i < BENCH_TEST_REPETITIONS; ++i)
                        for (j = 0; j < BENCH_TEST_NUMFILES; ++j)
                                for (k = 0; k < BENCH_TEST_RECSIZES; ++k)
                                        for (l = 0; l < BENCH_TEST_RECNUMS;
                                             ++l)
                                                for (m = 0;
                                                     m < BENCH_TEST_TESTYPES;
                                                     ++m) {
                                                        ret_cod = bench_test_results_compute_one(btr, i, j, k, l, m);
                                                        if (JF_RC_OK != ret_cod) THROW(COMPUTE_ONE);
                                                }
                THROW(NONE);
        } CATCH {
                switch (excp) {
                    case COMPUTE_ONE:
                        break;
                    case NONE:
                        ret_cod = JF_RC_OK;
                        break;
                    default:
                        ret_cod = JF_RC_INTERNAL_ERROR;
                } /* switch (excp) */
        } /* TRY-CATCH */
        JF_TRACE(("bench_test_results_compute/excp=%d/"
                  "ret_cod=%d/errno=%d\n", excp, ret_cod, errno));
        return ret_cod;
}



int bench_test_results_compute_one(bench_test_results_t btr,
                                   int repetition,
                                   int number_of_file,
                                   int record_size,
                                   int record_num,
                                   int test_type)
{
        enum Exception { TIMER_RESET1
                         , LJF_PRE
                         , TIMER_START1
                         , LJF_RUN
                         , TIMER_STOP1
                         , LJF_POST
                         , TIMER_RESET2
                         , SIO_PRE
                         , TIMER_START2
                         , SIO_RUN
                         , TIMER_STOP2
                         , SIO_POST
                         , NONE } excp;
        int ret_cod = JF_RC_INTERNAL_ERROR;

        JF_TRACE(("bench_test_results_compute_one\n"));
        TRY {
                int nof = bench_test_numfile_array[number_of_file];
                size_t rs = bench_test_recsize_array[record_size];
                int rn = bench_test_recnum_array[record_num];
                struct bench_test_func_s *btt =
                        &(bench_test_func_array[test_type]);
                jf_timer_t timer1, timer2;
                bench_table_t bt;
                int i, n = BENCH_TEST_TRANSACTIONS;

                if (verbose_mode >= VERBOSE_MODE_MID)
                        printf("Test type: '%s'; repetition: %d, nof: %d, "
                               "rs: " SIZE_T_FORMAT ", rn: %d\n",
                               btt->descr, repetition, nof, rs, rn);

                ret_cod = jf_timer_reset(&timer1);
                if (JF_RC_OK != ret_cod)
                        THROW(TIMER_RESET1);

                ret_cod = btt->ljf_pre(&bt, path_prefix, nof, rs, rn,
                                       sync_type);
                if (JF_RC_OK != ret_cod)
                        THROW(LJF_PRE);
                
                ret_cod = jf_timer_start(&timer1);
                if (JF_RC_OK != ret_cod)
                        THROW(TIMER_START1);

                for (i = 0; i < n; ++i) {
                        ret_cod = btt->ljf_run(&bt, buffer, rs, rn);
                        if (JF_RC_OK != ret_cod)
                                THROW(LJF_RUN);
                } /* for (i = 0; i < n; ++i) */

                ret_cod = jf_timer_stop(&timer1);
                if (JF_RC_OK != ret_cod)
                        THROW(TIMER_STOP1);

                ret_cod = btt->ljf_post(&bt);
                if (JF_RC_OK != ret_cod)
                        THROW(LJF_POST);

                if (verbose_mode >= VERBOSE_MODE_MAX)
                        printf("LJF: user_time = %f, sys_time = %f, "
                               "ela_time = %f\n",
                               jf_timer_get_usr_time(&timer1),
                               jf_timer_get_sys_time(&timer1),
                               jf_timer_get_ela_time(&timer1));

                /* store values for LJF */
                btr[repetition][number_of_file][record_size][record_num]
                        [test_type].ljf_usr = jf_timer_get_usr_time(&timer1);
                btr[repetition][number_of_file][record_size][record_num]
                        [test_type].ljf_sys = jf_timer_get_sys_time(&timer1);
                btr[repetition][number_of_file][record_size][record_num]
                        [test_type].ljf_ela = jf_timer_get_ela_time(&timer1);
                
                ret_cod = jf_timer_reset(&timer2);
                if (JF_RC_OK != ret_cod)
                        THROW(TIMER_RESET2);

                ret_cod = btt->sio_pre(&bt, path_prefix, nof, rs, rn,
                                       sync_type);
                if (JF_RC_OK != ret_cod)
                        THROW(SIO_PRE);
                
                ret_cod = jf_timer_start(&timer2);
                if (JF_RC_OK != ret_cod)
                        THROW(TIMER_START2);

                for (i = 0; i < n; ++i) {
                        ret_cod = btt->sio_run(&bt, buffer, rs, rn);
                        if (JF_RC_OK != ret_cod)
                                THROW(SIO_RUN);
                } /* for (i = 0; i < n; ++i) */

                ret_cod = jf_timer_stop(&timer2);
                if (JF_RC_OK != ret_cod)
                        THROW(TIMER_STOP2);

                ret_cod = btt->sio_post(&bt);
                if (JF_RC_OK != ret_cod)
                        THROW(SIO_POST);

                if (verbose_mode >= VERBOSE_MODE_MAX)
                        printf("SIO: user_time = %f, sys_time = %f, "
                               "ela_time = %f\n",
                               jf_timer_get_usr_time(&timer2),
                               jf_timer_get_sys_time(&timer2),
                               jf_timer_get_ela_time(&timer2));

                /* store values for SIO */
                btr[repetition][number_of_file][record_size][record_num]
                        [test_type].sio_usr = jf_timer_get_usr_time(&timer2);
                btr[repetition][number_of_file][record_size][record_num]
                        [test_type].sio_sys = jf_timer_get_sys_time(&timer2);
                btr[repetition][number_of_file][record_size][record_num]
                        [test_type].sio_ela = jf_timer_get_ela_time(&timer2);
                
                btr[repetition][number_of_file][record_size][record_num]
                        [test_type].valid = TRUE;
                
                THROW(NONE);
        } CATCH {
                switch (excp) {
                    case TIMER_RESET1:
                    case LJF_PRE:
                    case TIMER_START1:
                    case LJF_RUN:
                    case TIMER_STOP1:
                    case LJF_POST:
                    case TIMER_RESET2:
                    case SIO_PRE:
                    case TIMER_START2:
                    case SIO_RUN:
                    case TIMER_STOP2:
                    case SIO_POST:
                        break;
                    case NONE:
                        ret_cod = JF_RC_OK;
                        break;
                    default:
                        ret_cod = JF_RC_INTERNAL_ERROR;
                } /* switch (excp) */
        } /* TRY-CATCH */
        JF_TRACE(("bench_test_results_compute_one/excp=%d/"
                  "ret_cod=%d/errno=%d\n", excp, ret_cod, errno));
        return ret_cod;
}



void bench_test_results_clean(bench_test_results_t btr)
{
        int i, j, k, l, m;
        
        for (j = 0; j < BENCH_TEST_NUMFILES; ++j)
                for (k = 0; k < BENCH_TEST_RECSIZES; ++k)
                        for (l = 0; l < BENCH_TEST_RECNUMS; ++l)
                                for (m = 0; m < BENCH_TEST_TESTYPES; ++m) {
                                        /*
                                        double avg_ljf_usr = 0.0;
                                        double avg_ljf_sys = 0.0;
                                        double avg_ljf_ela = 0.0;
                                        double avg_sio_usr = 0.0;
                                        double avg_sio_sys = 0.0;
                                        double avg_sio_ela = 0.0;
                                        */
                                        int best = 0, worst = 0;
        
                                        for (i = 0; i < BENCH_TEST_REPETITIONS; ++i) {
                                                /*
                                                avg_ljf_usr += btr[i][j][k][l][m].ljf_usr;
                                                avg_ljf_sys += btr[i][j][k][l][m].ljf_sys;
                                                avg_ljf_ela += btr[i][j][k][l][m].ljf_ela;
                                                avg_sio_usr += btr[i][j][k][l][m].sio_usr;
                                                avg_sio_sys += btr[i][j][k][l][m].sio_sys;
                                                avg_sio_ela += btr[i][j][k][l][m].sio_ela;
                                                */
                                        } /* for i */

                                        /*
                                        avg_ljf_usr /= BENCH_TEST_REPETITIONS;
                                        avg_ljf_sys /= BENCH_TEST_REPETITIONS;
                                        avg_ljf_ela /= BENCH_TEST_REPETITIONS;
                                        avg_sio_usr /= BENCH_TEST_REPETITIONS;
                                        avg_sio_sys /= BENCH_TEST_REPETITIONS;
                                        avg_sio_ela /= BENCH_TEST_REPETITIONS;
                                        */
                                        
                                        for (i = 1; i < BENCH_TEST_REPETITIONS; ++i) {
                                                /*
                                                if (btr[i][j][k][l][m].ljf_usr / avg_ljf_usr + btr[i][j][k][l][m].ljf_sys / avg_ljf_sys + btr[i][j][k][l][m].ljf_ela / avg_ljf_ela + btr[i][j][k][l][m].sio_usr / avg_sio_usr + btr[i][j][k][l][m].sio_sys / avg_sio_sys + btr[i][j][k][l][m].sio_ela / avg_sio_ela < btr[best][j][k][l][m].ljf_usr / avg_ljf_usr + btr[best][j][k][l][m].ljf_sys / avg_ljf_sys + btr[best][j][k][l][m].ljf_ela / avg_ljf_ela + btr[best][j][k][l][m].sio_usr / avg_sio_usr + btr[best][j][k][l][m].sio_sys / avg_sio_sys + btr[best][j][k][l][m].sio_ela / avg_sio_ela)
                                                        best = i;
                                                if (btr[i][j][k][l][m].ljf_usr / avg_ljf_usr + btr[i][j][k][l][m].ljf_sys / avg_ljf_sys + btr[i][j][k][l][m].ljf_ela / avg_ljf_ela + btr[i][j][k][l][m].sio_usr / avg_sio_usr + btr[i][j][k][l][m].sio_sys / avg_sio_sys + btr[i][j][k][l][m].sio_ela / avg_sio_ela > btr[worst][j][k][l][m].ljf_usr / avg_ljf_usr + btr[worst][j][k][l][m].ljf_sys / avg_ljf_sys + btr[worst][j][k][l][m].ljf_ela / avg_ljf_ela + btr[worst][j][k][l][m].sio_usr / avg_sio_usr + btr[worst][j][k][l][m].sio_sys / avg_sio_sys + btr[worst][j][k][l][m].sio_ela / avg_sio_ela)
                                                        worst = i;
                                                */
                                                if (btr[i][j][k][l][m].ljf_ela + btr[i][j][k][l][m].sio_ela < btr[best][j][k][l][m].ljf_ela + btr[best][j][k][l][m].sio_ela)
                                                        best = i;
                                                if (btr[i][j][k][l][m].ljf_ela + btr[i][j][k][l][m].sio_ela > btr[worst][j][k][l][m].ljf_ela + btr[worst][j][k][l][m].sio_ela)
                                                        worst = i;
                                        } /* for i */
                                        btr[best][j][k][l][m].valid = FALSE;
                                        btr[worst][j][k][l][m].valid = FALSE;
                                } /* for m */
}



void bench_test_results_report(bench_test_results_t btr)
{
        int i, j, k, l, m;

        double ljf_usr = 0.0;
        double ljf_sys = 0.0;
        double ljf_ela = 0.0;
        double sio_usr = 0.0;
        double sio_sys = 0.0;
        double sio_ela = 0.0;
        double glo_effic = 0.0;
        long transactions = 0;
        double d_tran = 0.0;
        FILE *csv = NULL, *xml = NULL;

        if (NULL != csv_file_name)
                csv = fopen(csv_file_name, "w");
        if (NULL != xml_file_name)
                xml = fopen(xml_file_name, "w");

        if (NULL != csv)
                fprintf(csv, "\"Test type\",\"Number of files\","
                        "\"Record size\","
                        "\"Number of records\",\"Sequential\","
                        "\"LJF CPU user time\",\"SIO CPU user time\","
                        "\"LJF CPU sys time\",\"SIO CPU sys time\","
                        "\"LJF Elapsed time\",\"SIO Elapsed time\"\n");
        if (NULL != xml) {
                fprintf(xml,
                        "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
                fprintf(xml, "<libjf_benchmark>\n");
        } /* if (NULL != xml) */
        
        for (m = 0; m < BENCH_TEST_TESTYPES; ++m) {
                double ljf_usr_perc = 0.0;
                double ljf_sys_perc = 0.0;
                double ljf_ela_ratio = 0.0;
                double sio_usr_perc = 0.0;
                double sio_sys_perc = 0.0;
                double sio_ela_ratio = 0.0;
                double effic = 1.0;
                long bytes = 0;

                if (NULL != xml)
                        fprintf(xml, "  <test name='%s'>\n",
                                bench_test_func_array[m].descr);
                
                for (j = 0; j < BENCH_TEST_NUMFILES; ++j) {
                        if (NULL != xml)
                                fprintf(xml, "    <number_of_files value='%d'>\n",
                                        bench_test_numfile_array[j]);
                        for (k = 0; k < BENCH_TEST_RECSIZES; ++k) {
                                if (NULL != xml)
                                        fprintf(xml, "      <record_size value='"SIZE_T_FORMAT"'>\n",
                                                bench_test_recsize_array[k]);
                                for (l = 0; l < BENCH_TEST_RECNUMS; ++l) {
                                        if (NULL != xml)
                                                fprintf(xml, "        <number_of_records value='%d'>\n",
                                                        bench_test_recnum_array[l]);
                                        for (i = 0; i < BENCH_TEST_REPETITIONS; ++i) {
                                                if (!btr[i][j][k][l][m].valid)
                                                        continue;
                                                if (NULL != xml)
                                                        fprintf(xml, "          <sequential value='%d'>\n", i);
                                                transactions += BENCH_TEST_TRANSACTIONS;
                                                bytes += bench_test_numfile_array[j] * bench_test_recsize_array[k] * bench_test_recnum_array[l] * BENCH_TEST_TRANSACTIONS * bench_test_func_array[m].ratio_multiplier;
                                                ljf_usr += btr[i][j][k][l][m].ljf_usr;
                                                ljf_sys += btr[i][j][k][l][m].ljf_sys;
                                                ljf_ela += btr[i][j][k][l][m].ljf_ela;
                                                sio_usr += btr[i][j][k][l][m].sio_usr;
                                                sio_sys += btr[i][j][k][l][m].sio_sys;
                                                sio_ela += btr[i][j][k][l][m].sio_ela;
                                                if (NULL != csv)
                                                        fprintf(csv,"\"%s\",%d,"
                                                                SIZE_T_FORMAT
                                                                ",%d,%d,%f,%f,"
                                                                "%f,%f,%f,%f\n",
                                                                bench_test_func_array[m].descr,
                                                                bench_test_numfile_array[j],
                                                                bench_test_recsize_array[k],
                                                                bench_test_recnum_array[l],
                                                                i,
                                                                btr[i][j][k][l][m].ljf_usr,
                                                                btr[i][j][k][l][m].sio_usr,
                                                                btr[i][j][k][l][m].ljf_sys,
                                                                btr[i][j][k][l][m].sio_sys,
                                                                btr[i][j][k][l][m].ljf_ela,
                                                                btr[i][j][k][l][m].sio_ela);

                                                if (NULL != xml)
                                                        fprintf(xml,
                                                                "            <LJF>\n"
                                                                "              <CPU_user_time>%f</CPU_user_time>\n"
                                                                "              <CPU_sys_time>%f</CPU_sys_time>\n"
                                                                "              <elapsed_time>%f</elapsed_time>\n"
                                                                "            </LJF>\n",
                                                                btr[i][j][k][l][m].ljf_usr,
                                                                btr[i][j][k][l][m].ljf_sys,
                                                                btr[i][j][k][l][m].ljf_ela);
                                                if (NULL != xml)
                                                        fprintf(xml,
                                                                "            <SIO>\n"
                                                                "              <CPU_user_time>%f</CPU_user_time>\n"
                                                                "              <CPU_sys_time>%f</CPU_sys_time>\n"
                                                                "              <elapsed_time>%f</elapsed_time>\n"
                                                                "            </SIO>\n",
                                                                btr[i][j][k][l][m].sio_usr,
                                                                btr[i][j][k][l][m].sio_sys,
                                                                btr[i][j][k][l][m].sio_ela);
                                                
                                                if (NULL != xml)
                                                        fprintf(xml, "          </sequential>\n");
                                        } /* for i */
                                        if (NULL != xml)
                                                fprintf(xml, "        </number_of_records>\n");
                                } /* for l */
                                if (NULL != xml)
                                        fprintf(xml, "      </record_size>\n");
                        } /* for k */
                        if (NULL != xml)
                                fprintf(xml, "    </number_of_files>\n");
                } /* for j */
                
                ljf_ela_ratio = bytes / ljf_ela / 1024;
                ljf_usr_perc = 100.0 * ljf_usr / ljf_ela;
                ljf_sys_perc = 100.0 * ljf_sys / ljf_ela;
                sio_ela_ratio = bytes / sio_ela / 1024;
                sio_usr_perc = 100.0 * sio_usr / sio_ela;
                sio_sys_perc = 100.0 * sio_sys / sio_ela;
                
                effic = ljf_ela_ratio / sio_ela_ratio;

                glo_effic += effic;

                d_tran = (double)transactions;

                if (verbose_mode >= VERBOSE_MODE_MIN) {
                        printf("----------------------------------------------------------------------------\n");
                        printf("\tBENCH TYPE: '%s'\n", bench_test_func_array[m].descr);
                        printf("Ratio:\t\t"
                               "ljf: %3.3f Kb/s\tsio: %3.3f Kb/s\n",
                               ljf_ela_ratio, sio_ela_ratio);
                        printf("Transac:\t"
                               "ljf: %3.3f t/s\tsio: %3.3f t/s\n",
                               d_tran/ljf_ela, d_tran/sio_ela);
                        printf("User CPU:\t"
                               "ljf: %3.3f %%\t\tsio: %3.3f %%\n",
                               ljf_usr_perc, sio_usr_perc);
                        printf("Sys CPU:\t"
                               "ljf: %3.3f %%\t\tsio: %3.3f %%\n",
                               ljf_sys_perc, sio_sys_perc);
                        printf("Efficiency:\t%3.3f %%\n", effic * 100.0);
                } /* if (verbose_mode) */
                
                if (NULL != xml)
                        fprintf(xml, "  </test>\n");
        } /* for m */

        if (NULL != csv)
                fclose(csv);
        if (NULL != xml) {
                fprintf(xml, "</libjf_benchmark>\n");
                fclose(xml);
        } /* if (NULL != xml) */

        glo_effic = glo_effic/((double)BENCH_TEST_TESTYPES);
        
        if (verbose_mode >= VERBOSE_MODE_SIL)
                printf("\nGLOBAL EFFICIENCY: %3.3f %%\n\n", glo_effic * 100.0);
}



int bench_X0_sio_pre(bench_table_t *bt,
                     const char *path_prefix, int number_of_files,
                     uint32_t policy, const char *open_mode)
{
        enum Exception { BENCH_TABLE_CREATE
                         , BENCH_TABLE_UNLINK
                         , FOPEN_ERROR
                         , BENCH_TABLE_SET_STREAM
                         , NONE } excp;
        int ret_cod = JF_RC_INTERNAL_ERROR;

        JF_TRACE(("bench_X0_sio_pre\n"));
        TRY {
                int i;
                
                bench_table_reset(bt);

                bench_table_set_policy(bt, policy);
                
                ret_cod = bench_table_create(bt, path_prefix,
                                             number_of_files);
                if (JF_RC_OK != ret_cod)
                        THROW(BENCH_TABLE_CREATE);

                ret_cod = bench_table_unlink(bt);
                if (JF_RC_OK != ret_cod)
                        THROW(BENCH_TABLE_UNLINK);
                
                for (i = 1; i <= bench_table_get_last(bt); ++i) {
                        FILE *stream = fopen(
                                bench_table_get_name(bt, i), open_mode);
                        if (NULL == stream)
                                THROW(FOPEN_ERROR);
                        ret_cod = bench_table_set_stream(bt, i, stream);
                        if (JF_RC_OK != ret_cod)
                                THROW(BENCH_TABLE_SET_STREAM);
                } /* for (i = 1; i <= bench_table_get_last(bt); ++i) */

                THROW(NONE);
        } CATCH {
                switch (excp) {
                    case FOPEN_ERROR:
                        ret_cod = JF_RC_FOPEN_ERROR;
                        break;
                    case BENCH_TABLE_SET_STREAM:
                    case BENCH_TABLE_CREATE:
                    case BENCH_TABLE_UNLINK:
                        break;
                    case NONE:
                        ret_cod = JF_RC_OK;
                        break;
                    default:
                        ret_cod = JF_RC_INTERNAL_ERROR;
                } /* switch (excp) */
        } /* TRY-CATCH */
        JF_TRACE(("bench_X0_sio_pre/excp=%d/"
                  "ret_cod=%d/errno=%d\n", excp, ret_cod, errno));
        return ret_cod;
}
        


int bench_X0_sio_post(bench_table_t *bt)
{
        enum Exception { BENCH_TABLE_UNLINK
                         , BENCH_TABLE_DESTROY
                         , FCLOSE_ERROR
                         , NONE } excp;
        int ret_cod = JF_RC_INTERNAL_ERROR;

        JF_TRACE(("bench_X0_sio_post\n"));
        TRY {
                int i;
                
                for (i = 1; i <= bench_table_get_last(bt); ++i) {
                        if (0 != fclose(bench_table_get_stream(bt, i)))
                                THROW(FCLOSE_ERROR);
                } /* for (i = 1; i <= bench_table_get_last(bt); ++i) */
                
                ret_cod = bench_table_unlink(bt);
                if (JF_RC_OK != ret_cod)
                        THROW(BENCH_TABLE_UNLINK);
                
                ret_cod = bench_table_destroy(bt);
                if (JF_RC_OK != ret_cod)
                        THROW(BENCH_TABLE_DESTROY);

                bench_table_reset(bt);

                THROW(NONE);
        } CATCH {
                switch (excp) {
                    case BENCH_TABLE_UNLINK:
                    case BENCH_TABLE_DESTROY:
                        break;
                    case FCLOSE_ERROR:
                        ret_cod = JF_RC_FCLOSE_ERROR;
                        break;
                    case NONE:
                        ret_cod = JF_RC_OK;
                        break;
                    default:
                        ret_cod = JF_RC_INTERNAL_ERROR;
                } /* switch (excp) */
        } /* TRY-CATCH */
        JF_TRACE(("bench_X0_sio_post/excp=%d/"
                  "ret_cod=%d/errno=%d\n", excp, ret_cod, errno));
        return ret_cod;
}



int bench_X0_ljf_pre(bench_table_t *bt,
                     const char *path_prefix, int number_of_files,
                     uint32_t policy, const char *open_mode)
{
        enum Exception { BENCH_TABLE_CREATE
                         , BENCH_TABLE_UNLINK
                         , JOURNAL_OPEN
                         , FOPEN_ERROR
                         , FILE_OPEN
                         , BENCH_TABLE_SET_JFILE
                         , NONE } excp;
        int ret_cod = JF_RC_INTERNAL_ERROR;

        JF_TRACE(("bench_X0_ljf_pre\n"));
        TRY {
                jf_journal_t journal;
                struct jf_journal_opts_s jopts;
                struct jf_file_open_opts_s opts;
                int i;
                
                bench_table_reset(bt);

                bench_table_set_policy(bt, policy);
                
                ret_cod = bench_table_create(bt, path_prefix,
                                             number_of_files);
                if (JF_RC_OK != ret_cod)
                        THROW(BENCH_TABLE_CREATE);

                ret_cod = bench_table_unlink(bt);
                if (JF_RC_OK != ret_cod)
                        THROW(BENCH_TABLE_UNLINK);

                jf_set_default_journal_opts(&jopts);
                jopts.flags |= JF_JOURNAL_PROP_OPEN_O_CREAT |
                        JF_JOURNAL_PROP_OPEN_O_EXCL | policy;

                ret_cod = jf_journal_open(&journal,
                                          bench_table_get_name(bt, 0),
                                          number_of_files, &jopts);
                if (JF_RC_OK != ret_cod)
                        THROW(JOURNAL_OPEN);

                bench_table_set_journal(bt, &journal);

                jf_set_default_file_open_opts(&opts);
                opts.join_the_journal = TRUE;
                
                for (i = 1; i <= bench_table_get_last(bt); ++i) {
                        jf_file_t jf;
                        ret_cod = jf_file_open(&jf,
                                               bench_table_get_journal(bt),
                                               bench_table_get_name(bt, i),
                                               open_mode, &opts);
                        if (JF_RC_OK != ret_cod)
                                THROW(FILE_OPEN);
                        ret_cod = bench_table_set_jfile(bt, i, &jf);
                        if (JF_RC_OK != ret_cod)
                                THROW(BENCH_TABLE_SET_JFILE);
                } /* for (i = 1; i <= bench_table_get_last(bt); ++i) */

                THROW(NONE);
        } CATCH {
                switch (excp) {
                    case FOPEN_ERROR:
                        ret_cod = JF_RC_FOPEN_ERROR;
                        break;
                    case BENCH_TABLE_CREATE:
                    case BENCH_TABLE_UNLINK:
                    case JOURNAL_OPEN:
                    case FILE_OPEN:
                    case BENCH_TABLE_SET_JFILE:
                        break;
                    case NONE:
                        ret_cod = JF_RC_OK;
                        break;
                    default:
                        ret_cod = JF_RC_INTERNAL_ERROR;
                } /* switch (excp) */
        } /* TRY-CATCH */
        JF_TRACE(("bench_X0_ljf_pre/excp=%d/"
                  "ret_cod=%d/errno=%d\n", excp, ret_cod, errno));
        return ret_cod;
}
        


int bench_X0_ljf_post(bench_table_t *bt)
{
        enum Exception { FILE_CLOSE
                         , JOURNAL_CLOSE
                         , BENCH_TABLE_UNLINK
                         , BENCH_TABLE_DESTROY
                         , NONE } excp;
        int ret_cod = JF_RC_INTERNAL_ERROR;

        JF_TRACE(("bench_X0_ljf_post\n"));
        TRY {
                int i;
                
                for (i = 1; i <= bench_table_get_last(bt); ++i) {
                        ret_cod = jf_file_close(bench_table_get_jfile(bt, i));
                        if (JF_RC_OK != ret_cod)
                                THROW(FILE_CLOSE);
                } /* for (i = 1; i <= bench_table_get_last(bt); ++i) */

                ret_cod = jf_journal_close(bench_table_get_journal(bt));
                if (JF_RC_OK != ret_cod)
                        THROW(JOURNAL_CLOSE);
                
                ret_cod = bench_table_unlink(bt);
                if (JF_RC_OK != ret_cod)
                        THROW(BENCH_TABLE_UNLINK);
                
                ret_cod = bench_table_destroy(bt);
                if (JF_RC_OK != ret_cod)
                        THROW(BENCH_TABLE_DESTROY);

                bench_table_reset(bt);

                THROW(NONE);
        } CATCH {
                switch (excp) {
                    case FILE_CLOSE:
                    case JOURNAL_CLOSE:
                    case BENCH_TABLE_UNLINK:
                    case BENCH_TABLE_DESTROY:
                        break;
                    case NONE:
                        ret_cod = JF_RC_OK;
                        break;
                    default:
                        ret_cod = JF_RC_INTERNAL_ERROR;
                } /* switch (excp) */
        } /* TRY-CATCH */
        JF_TRACE(("bench_X0_ljf_post/excp=%d/"
                  "ret_cod=%d/errno=%d\n", excp, ret_cod, errno));
        return ret_cod;
}



int bench_X1_sio_pre(bench_table_t *bt,
                     const char *path_prefix, int number_of_files,
                     size_t block_size, int record_num,
                     uint32_t policy, const char *open_mode)
{
        enum Exception { BENCH_X0_SIO_PRE
                         , FWRITE_ERROR
                         , STREAM_SYNC
                         , NONE } excp;
        int ret_cod = JF_RC_INTERNAL_ERROR;

        JF_TRACE(("bench_X1_sio_pre\n"));
        TRY {
                int i, j;
                
                ret_cod = bench_X0_sio_pre(bt, path_prefix, number_of_files,
                                           policy, open_mode);
                if (JF_RC_OK != ret_cod)
                        THROW(BENCH_X0_SIO_PRE);
                
                for (i = 1; i <= bench_table_get_last(bt); ++i) {
                        for (j = 0; j < record_num * BENCH_TEST_UPDATE_FACTOR;
                             ++j) {
                                /* writing */
                                if (1 != fwrite(
                                            buffer, block_size, 1,
                                            bench_table_get_stream(bt, i)))
                                        THROW(FWRITE_ERROR);
                        } /* for (j = 0; j < record_num * BENCH ...*/
                } /* for (i = 1; i <= bench_table_get_last(bt); */
                
                /* committing */
                for (i = 1; i <= bench_table_get_last(bt); ++i) {
                        ret_cod = jf_stream_sync(
                                bench_table_get_stream(bt, i),
                                bench_table_get_policy(bt));
                        if (JF_RC_OK != ret_cod)
                                THROW(STREAM_SYNC);
                } /* for (i = 1; i <= bench_table_get_last(bt); */
                
                THROW(NONE);
        } CATCH {
                switch (excp) {
                    case BENCH_X0_SIO_PRE:
                    case STREAM_SYNC:
                        break;
                    case FWRITE_ERROR:
                        ret_cod = JF_RC_FWRITE_ERROR;
                        break;
                    case NONE:
                        ret_cod = JF_RC_OK;
                        break;
                    default:
                        ret_cod = JF_RC_INTERNAL_ERROR;
                } /* switch (excp) */
        } /* TRY-CATCH */
        JF_TRACE(("bench_X1_sio_pre/excp=%d/"
                  "ret_cod=%d/errno=%d\n", excp, ret_cod, errno));
        return ret_cod;
}
        


int bench_X1_ljf_pre(bench_table_t *bt,
                     const char *path_prefix, int number_of_files,
                     size_t block_size, int record_num,
                     uint32_t policy, const char *open_mode)
{
        enum Exception { BENCH_X0_LJF_PRE
                         , FILE_WRITE
                         , JOURNAL_COMMIT
                         , NONE } excp;
        int ret_cod = JF_RC_INTERNAL_ERROR;

        JF_TRACE(("bench_X1_ljf_pre\n"));
        TRY {
                int i, j;

                ret_cod = bench_X0_ljf_pre(bt, path_prefix, number_of_files,
                                           policy, open_mode);
                if (JF_RC_OK != ret_cod)
                        THROW(BENCH_X0_LJF_PRE);
                
                for (i = 1; i <= bench_table_get_last(bt); ++i) {
                        for (j = 0; j < record_num * BENCH_TEST_UPDATE_FACTOR;
                             ++j) {
                                size_t w;
                                ret_cod = jf_file_write(
                                        bench_table_get_jfile(bt, i),
                                        buffer, block_size, &w);
                                if (JF_RC_OK != ret_cod || block_size != w)
                                        THROW(FILE_WRITE);
                        } /* for (j = 0; j < n; ++j) */
                } /* for (i = 1; i <= bench_table_get_last(bt); */
                
                ret_cod = jf_journal_commit(
                        bench_table_get_journal(bt));
                if (JF_RC_OK != ret_cod)
                        THROW(JOURNAL_COMMIT);
                
                THROW(NONE);
        } CATCH {
                switch (excp) {
                    case BENCH_X0_LJF_PRE:
                    case FILE_WRITE:
                    case JOURNAL_COMMIT:
                        break;
                    case NONE:
                        ret_cod = JF_RC_OK;
                        break;
                    default:
                        ret_cod = JF_RC_INTERNAL_ERROR;
                } /* switch (excp) */
        } /* TRY-CATCH */
        JF_TRACE(("bench_X1_ljf_pre/excp=%d/"
                  "ret_cod=%d/errno=%d\n", excp, ret_cod, errno));
        return ret_cod;
}



int bench_00_sio_pre(bench_table_t *bt,
                     const char *path_prefix, int number_of_files,
                     size_t block_size, int record_num, uint32_t policy)
{
        int ret_cod = JF_RC_INTERNAL_ERROR;
        JF_TRACE(("bench_00_sio_pre\n"));
        ret_cod = bench_X0_sio_pre(bt, path_prefix, number_of_files,
                                   policy, "ab");
        JF_TRACE(("bench_00_sio_pre/"
                  "ret_cod=%d/errno=%d\n", ret_cod, errno));
        return ret_cod;
}
        


int bench_00_sio_post(bench_table_t *bt)
{
        int ret_cod = JF_RC_INTERNAL_ERROR;
        JF_TRACE(("bench_00_sio_post\n"));
        ret_cod = bench_X0_sio_post(bt);
        JF_TRACE(("bench_00_sio_post/"
                  "ret_cod=%d/errno=%d\n", ret_cod, errno));
        return ret_cod;
}



int bench_00_sio_run(bench_table_t *bt, const void *buffer,
                     size_t block_size, int record_num)
{
        enum Exception { FWRITE_ERROR
                         , STREAM_SYNC
                         , NONE } excp;
        int ret_cod = JF_RC_INTERNAL_ERROR;

        JF_TRACE(("bench_00_sio_run\n"));
        TRY {
                int i, j;

                for (j = 0; j < record_num; ++j) {
                        /* writing */
                        for (i = 1; i <= bench_table_get_last(bt); ++i) {
                                if (1 != fwrite(
                                            buffer, block_size, 1,
                                            bench_table_get_stream(bt, i)))
                                        THROW(FWRITE_ERROR);
                        } /* for (i = 1; i <= bench_table_get_last(bt); */
                } /* for (j = 0; j < n; ++j) */
                
                /* committing */
                for (i = 1; i <= bench_table_get_last(bt); ++i) {
                        ret_cod = jf_stream_sync(
                                bench_table_get_stream(bt, i),
                                bench_table_get_policy(bt));
                        if (JF_RC_OK != ret_cod)
                                THROW(STREAM_SYNC);
                } /* for (i = 1; i <= bench_table_get_last(bt); */
                
                THROW(NONE);
        } CATCH {
                switch (excp) {
                    case STREAM_SYNC:
                        break;
                    case FWRITE_ERROR:
                        ret_cod = JF_RC_FWRITE_ERROR;
                        break;
                    case NONE:
                        ret_cod = JF_RC_OK;
                        break;
                    default:
                        ret_cod = JF_RC_INTERNAL_ERROR;
                } /* switch (excp) */
        } /* TRY-CATCH */
        JF_TRACE(("bench_00_sio_run/excp=%d/"
                  "ret_cod=%d/errno=%d\n", excp, ret_cod, errno));
        return ret_cod;
}



int bench_00_ljf_pre(bench_table_t *bt,
                     const char *path_prefix, int number_of_files,
                     size_t block_size, int record_num, uint32_t policy)
{
        int ret_cod = JF_RC_INTERNAL_ERROR;

        JF_TRACE(("bench_00_ljf_pre\n"));
        ret_cod = bench_X0_ljf_pre(bt, path_prefix, number_of_files,
                                   policy, "a");
        JF_TRACE(("bench_00_ljf_pre/"
                  "ret_cod=%d/errno=%d\n", ret_cod, errno));
        return ret_cod;
}
        


int bench_00_ljf_post(bench_table_t *bt)
{
        int ret_cod = JF_RC_INTERNAL_ERROR;
        JF_TRACE(("bench_00_ljf_post\n"));
        ret_cod = bench_X0_ljf_post(bt);
        JF_TRACE(("bench_00_ljf_post/"
                  "ret_cod=%d/errno=%d\n", ret_cod, errno));
        return ret_cod;
}



int bench_00_ljf_run(bench_table_t *bt, const void *buffer,
                     size_t block_size, int record_num)
{
        enum Exception { FILE_WRITE
                         , JOURNAL_COMMIT
                         , NONE } excp;
        int ret_cod = JF_RC_INTERNAL_ERROR;

        JF_TRACE(("bench_00_ljf_run\n"));
        TRY {
                int i, j;

                for (j = 0; j < record_num; ++j) {
                        for (i = 1; i <= bench_table_get_last(bt); ++i) {
                                size_t w;
                                ret_cod = jf_file_write(
                                        bench_table_get_jfile(bt, i),
                                        buffer, block_size, &w);
                                if (JF_RC_OK != ret_cod || block_size != w)
                                        THROW(FILE_WRITE);
                        } /* for (i = 1; i <= bench_table_get_last(bt); */
                } /* for (j = 0; j < n; ++j) */
                
                ret_cod = jf_journal_commit(
                        bench_table_get_journal(bt));
                if (JF_RC_OK != ret_cod)
                        THROW(JOURNAL_COMMIT);
                
                THROW(NONE);
        } CATCH {
                switch (excp) {
                    case FILE_WRITE:
                    case JOURNAL_COMMIT:
                        break;
                    case NONE:
                        ret_cod = JF_RC_OK;
                        break;
                    default:
                        ret_cod = JF_RC_INTERNAL_ERROR;
                } /* switch (excp) */
        } /* TRY-CATCH */
        JF_TRACE(("bench_00_ljf_run/excp=%d/"
                  "ret_cod=%d/errno=%d\n", excp, ret_cod, errno));
        return ret_cod;
}



int bench_01_sio_pre(bench_table_t *bt,
                     const char *path_prefix, int number_of_files,
                     size_t block_size, int record_num, uint32_t policy)
{
        int ret_cod = JF_RC_INTERNAL_ERROR;

        JF_TRACE(("bench_01_sio_pre\n"));
        ret_cod = bench_X0_sio_pre(bt, path_prefix, number_of_files,
                                   policy, "ab+");
        JF_TRACE(("bench_01_sio_pre/"
                  "ret_cod=%d/errno=%d\n", ret_cod, errno));
        return ret_cod;
}
        


int bench_01_sio_post(bench_table_t *bt)
{
        int ret_cod = JF_RC_INTERNAL_ERROR;
        JF_TRACE(("bench_01_sio_post\n"));
        ret_cod = bench_X0_sio_post(bt);
        JF_TRACE(("bench_01_sio_post/"
                  "ret_cod=%d/errno=%d\n", ret_cod, errno));
        return ret_cod;
}



int bench_01_sio_run(bench_table_t *bt, const void *buffer,
                     size_t block_size, int record_num)
{
        enum Exception { FWRITE_ERROR
                         , FSEEK_ERROR
                         , FREAD_ERROR
                         , STREAM_SYNC
                         , NONE } excp;
        int ret_cod = JF_RC_INTERNAL_ERROR;

        JF_TRACE(("bench_01_sio_run\n"));
        TRY {
                int i, j;
                byte_t tmp_buffer[BENCH_TEST_MAX_RECSIZE];

                for (j = 0; j < record_num; ++j) {
                        /* writing */
                        for (i = 1; i <= bench_table_get_last(bt); ++i) {
                                if (1 != fwrite(
                                            buffer, block_size, 1,
                                            bench_table_get_stream(bt, i)))
                                        THROW(FWRITE_ERROR);
                                if (0 != fseeko(
                                            bench_table_get_stream(bt, i),
                                            -((off_t)block_size),
                                            SEEK_CUR))
                                        THROW(FSEEK_ERROR);
                                if (1 != fread(tmp_buffer, block_size, 1,
                                               bench_table_get_stream(bt, i)))
                                        THROW(FREAD_ERROR);
                        } /* for (i = 1; i <= bench_table_get_last(bt); */
                } /* for (j = 0; j < n; ++j) */
                
                /* committing */
                for (i = 1; i <= bench_table_get_last(bt); ++i) {
                        ret_cod = jf_stream_sync(
                                bench_table_get_stream(bt, i),
                                bench_table_get_policy(bt));
                        if (JF_RC_OK != ret_cod)
                                THROW(STREAM_SYNC);
                } /* for (i = 1; i <= bench_table_get_last(bt); */
                
                THROW(NONE);
        } CATCH {
                switch (excp) {
                    case STREAM_SYNC:
                        break;
                    case FWRITE_ERROR:
                        ret_cod = JF_RC_FWRITE_ERROR;
                        break;
                    case FSEEK_ERROR:
                        ret_cod = JF_RC_FSEEK_ERROR;
                        break;
                    case FREAD_ERROR:
                        ret_cod = JF_RC_FREAD_ERROR;
                        break;
                    case NONE:
                        ret_cod = JF_RC_OK;
                        break;
                    default:
                        ret_cod = JF_RC_INTERNAL_ERROR;
                } /* switch (excp) */
        } /* TRY-CATCH */
        JF_TRACE(("bench_01_sio_run/excp=%d/"
                  "ret_cod=%d/errno=%d\n", excp, ret_cod, errno));
        return ret_cod;
}



int bench_01_ljf_pre(bench_table_t *bt,
                     const char *path_prefix, int number_of_files,
                     size_t block_size, int record_num, uint32_t policy)
{
        int ret_cod = JF_RC_INTERNAL_ERROR;

        JF_TRACE(("bench_01_ljf_pre\n"));
        ret_cod = bench_X0_ljf_pre(bt, path_prefix, number_of_files,
                                   policy, "a+");
        JF_TRACE(("bench_01_ljf_pre/"
                  "ret_cod=%d/errno=%d\n", ret_cod, errno));
        return ret_cod;
}
        


int bench_01_ljf_post(bench_table_t *bt)
{
        int ret_cod = JF_RC_INTERNAL_ERROR;
        JF_TRACE(("bench_01_ljf_post\n"));
        ret_cod = bench_X0_ljf_post(bt);
        JF_TRACE(("bench_01_ljf_post/"
                  "ret_cod=%d/errno=%d\n", ret_cod, errno));
        return ret_cod;
}



int bench_01_ljf_run(bench_table_t *bt, const void *buffer,
                     size_t block_size, int record_num)
{
        enum Exception { FILE_WRITE
                         , FILE_SEEK
                         , FILE_READ
                         , JOURNAL_COMMIT
                         , NONE } excp;
        int ret_cod = JF_RC_INTERNAL_ERROR;

        JF_TRACE(("bench_01_ljf_run\n"));
        TRY {
                int i, j;
                byte_t tmp_buffer[BENCH_TEST_MAX_RECSIZE];

                for (j = 0; j < record_num; ++j) {
                        for (i = 1; i <= bench_table_get_last(bt); ++i) {
                                size_t w;
                                ret_cod = jf_file_write(
                                        bench_table_get_jfile(bt, i),
                                        buffer, block_size, &w);
                                if (JF_RC_OK != ret_cod || block_size != w)
                                        THROW(FILE_WRITE);
                                ret_cod = jf_file_seek(
                                        bench_table_get_jfile(bt, i),
                                        -((jf_offset_t)block_size),
                                        SEEK_CUR);
                                if (JF_RC_OK != ret_cod)
                                        THROW(FILE_SEEK);
                                ret_cod = jf_file_read(
                                        bench_table_get_jfile(bt, i),
                                        tmp_buffer, block_size, &w);
                                if (JF_RC_OK != ret_cod)
                                        THROW(FILE_READ);
                        } /* for (i = 1; i <= bench_table_get_last(bt); */
                } /* for (j = 0; j < n; ++j) */
                
                ret_cod = jf_journal_commit(
                        bench_table_get_journal(bt));
                if (JF_RC_OK != ret_cod)
                        THROW(JOURNAL_COMMIT);
                
                THROW(NONE);
        } CATCH {
                switch (excp) {
                    case FILE_WRITE:
                    case FILE_SEEK:
                    case FILE_READ:
                    case JOURNAL_COMMIT:
                        break;
                    case NONE:
                        ret_cod = JF_RC_OK;
                        break;
                    default:
                        ret_cod = JF_RC_INTERNAL_ERROR;
                } /* switch (excp) */
        } /* TRY-CATCH */
        JF_TRACE(("bench_01_ljf_run/excp=%d/"
                  "ret_cod=%d/errno=%d\n", excp, ret_cod, errno));
        return ret_cod;
}



int bench_02_sio_pre(bench_table_t *bt,
                     const char *path_prefix, int number_of_files,
                     size_t block_size, int record_num, uint32_t policy)
{
        int ret_cod = JF_RC_INTERNAL_ERROR;

        JF_TRACE(("bench_02_sio_pre\n"));
        ret_cod = bench_X1_sio_pre(bt, path_prefix, number_of_files,
                                   block_size, record_num, policy, "wb+");
        JF_TRACE(("bench_02_sio_pre/"
                  "ret_cod=%d/errno=%d\n", ret_cod, errno));
        return ret_cod;
}
        


int bench_02_sio_post(bench_table_t *bt)
{
        int ret_cod = JF_RC_INTERNAL_ERROR;
        JF_TRACE(("bench_02_sio_post\n"));
        ret_cod = bench_X0_sio_post(bt);
        JF_TRACE(("bench_02_sio_post/"
                  "ret_cod=%d/errno=%d\n", ret_cod, errno));
        return ret_cod;
}



int bench_02_sio_run(bench_table_t *bt, const void *buffer,
                     size_t block_size, int record_num)
{
        enum Exception { FSEEK_ERROR
                         , FWRITE_ERROR
                         , STREAM_SYNC
                         , NONE } excp;
        int ret_cod = JF_RC_INTERNAL_ERROR;

        JF_TRACE(("bench_02_sio_run\n"));
        TRY {
                int i, j;

                for (j = 0; j < record_num; ++j) {
                        /* writing */
                        for (i = 1; i <= bench_table_get_last(bt); ++i) {
                                off_t offset;
                                offset = (off_t)(
                                        random() % (block_size *
                                                    (BENCH_TEST_UPDATE_FACTOR *
                                                     record_num - 1)));
                                if (0 != fseeko(
                                            bench_table_get_stream(bt, i),
                                            offset, SEEK_SET))
                                        THROW(FSEEK_ERROR);
                                if (1 != fwrite(
                                            buffer, block_size, 1,
                                            bench_table_get_stream(bt, i)))
                                        THROW(FWRITE_ERROR);
                        } /* for (i = 1; i <= bench_table_get_last(bt); */
                } /* for (j = 0; j < n; ++j) */
                
                /* committing */
                for (i = 1; i <= bench_table_get_last(bt); ++i) {
                        ret_cod = jf_stream_sync(
                                bench_table_get_stream(bt, i),
                                bench_table_get_policy(bt));
                        if (JF_RC_OK != ret_cod)
                                THROW(STREAM_SYNC);
                } /* for (i = 1; i <= bench_table_get_last(bt); */
                
                THROW(NONE);
        } CATCH {
                switch (excp) {
                    case FSEEK_ERROR:
                        ret_cod = JF_RC_FSEEK_ERROR;
                        break;
                    case FWRITE_ERROR:
                        ret_cod = JF_RC_FWRITE_ERROR;
                        break;
                    case STREAM_SYNC:
                        break;
                    case NONE:
                        ret_cod = JF_RC_OK;
                        break;
                    default:
                        ret_cod = JF_RC_INTERNAL_ERROR;
                } /* switch (excp) */
        } /* TRY-CATCH */
        JF_TRACE(("bench_02_sio_run/excp=%d/"
                  "ret_cod=%d/errno=%d\n", excp, ret_cod, errno));
        return ret_cod;
}



int bench_02_ljf_pre(bench_table_t *bt,
                     const char *path_prefix, int number_of_files,
                     size_t block_size, int record_num, uint32_t policy)
{
        enum Exception { BENCH_X0_LJF_PRE
                         , FILE_WRITE
                         , JOURNAL_COMMIT
                         , NONE } excp;
        int ret_cod = JF_RC_INTERNAL_ERROR;

        JF_TRACE(("bench_02_ljf_pre\n"));
        TRY {
                int i, j;

                ret_cod = bench_X1_ljf_pre(bt, path_prefix, number_of_files,
                                           block_size, record_num,
                                           policy, "w+");
                if (JF_RC_OK != ret_cod)
                        THROW(BENCH_X0_LJF_PRE);
                
                for (j = 0; j < record_num; ++j) {
                        for (i = 1; i <= bench_table_get_last(bt); ++i) {
                                size_t w;
                                ret_cod = jf_file_write(
                                        bench_table_get_jfile(bt, i),
                                        buffer, block_size, &w);
                                if (JF_RC_OK != ret_cod || block_size != w)
                                        THROW(FILE_WRITE);
                        } /* for (i = 1; i <= bench_table_get_last(bt); */
                } /* for (j = 0; j < n; ++j) */
                
                ret_cod = jf_journal_commit(
                        bench_table_get_journal(bt));
                if (JF_RC_OK != ret_cod)
                        THROW(JOURNAL_COMMIT);
                
                THROW(NONE);
        } CATCH {
                switch (excp) {
                    case BENCH_X0_LJF_PRE:
                    case FILE_WRITE:
                    case JOURNAL_COMMIT:
                        break;
                    case NONE:
                        ret_cod = JF_RC_OK;
                        break;
                    default:
                        ret_cod = JF_RC_INTERNAL_ERROR;
                } /* switch (excp) */
        } /* TRY-CATCH */
        JF_TRACE(("bench_02_ljf_pre/excp=%d/"
                  "ret_cod=%d/errno=%d\n", excp, ret_cod, errno));
        return ret_cod;
}



int bench_02_ljf_post(bench_table_t *bt)
{
        int ret_cod = JF_RC_INTERNAL_ERROR;
        JF_TRACE(("bench_02_ljf_post\n"));
        ret_cod = bench_X0_ljf_post(bt);
        JF_TRACE(("bench_02_ljf_post/"
                  "ret_cod=%d/errno=%d\n", ret_cod, errno));
        return ret_cod;
}



int bench_02_ljf_run(bench_table_t *bt, const void *buffer,
                     size_t block_size, int record_num)
{
        enum Exception { FILE_WRITE
                         , FILE_SEEK
                         , JOURNAL_COMMIT
                         , NONE } excp;
        int ret_cod = JF_RC_INTERNAL_ERROR;

        JF_TRACE(("bench_02_ljf_run\n"));
        TRY {
                int i, j;

                for (j = 0; j < record_num; ++j) {
                        for (i = 1; i <= bench_table_get_last(bt); ++i) {
                                jf_offset_t offset;
                                size_t w;
                                offset = (jf_offset_t)(
                                        random() % (block_size *
                                                    (BENCH_TEST_UPDATE_FACTOR *
                                                     record_num - 1)));
                                ret_cod = jf_file_seek(
                                        bench_table_get_jfile(bt, i),
                                        offset, SEEK_SET);
                                if (JF_RC_OK != ret_cod)
                                        THROW(FILE_SEEK);
                                ret_cod = jf_file_write(
                                        bench_table_get_jfile(bt, i),
                                        buffer, block_size, &w);
                                if (JF_RC_OK != ret_cod || block_size != w)
                                        THROW(FILE_WRITE);
                        } /* for (i = 1; i <= bench_table_get_last(bt); */
                } /* for (j = 0; j < n; ++j) */
                
                ret_cod = jf_journal_commit(
                        bench_table_get_journal(bt));
                if (JF_RC_OK != ret_cod)
                        THROW(JOURNAL_COMMIT);
                
                THROW(NONE);
        } CATCH {
                switch (excp) {
                    case FILE_WRITE:
                    case FILE_SEEK:
                    case JOURNAL_COMMIT:
                        break;
                    case NONE:
                        ret_cod = JF_RC_OK;
                        break;
                    default:
                        ret_cod = JF_RC_INTERNAL_ERROR;
                } /* switch (excp) */
        } /* TRY-CATCH */
        JF_TRACE(("bench_02_ljf_run/excp=%d/"
                  "ret_cod=%d/errno=%d\n", excp, ret_cod, errno));
        return ret_cod;
}



int bench_03_sio_pre(bench_table_t *bt,
                     const char *path_prefix, int number_of_files,
                     size_t block_size, int record_num, uint32_t policy)
{
        int ret_cod = JF_RC_INTERNAL_ERROR;

        JF_TRACE(("bench_03_sio_pre\n"));
        ret_cod = bench_X1_sio_pre(bt, path_prefix, number_of_files,
                                   block_size, record_num, policy, "wb+");
        JF_TRACE(("bench_03_sio_pre/"
                  "ret_cod=%d/errno=%d\n", ret_cod, errno));
        return ret_cod;
}
        


int bench_03_sio_post(bench_table_t *bt)
{
        int ret_cod = JF_RC_INTERNAL_ERROR;
        JF_TRACE(("bench_03_sio_post\n"));
        ret_cod = bench_X0_sio_post(bt);
        JF_TRACE(("bench_03_sio_post/"
                  "ret_cod=%d/errno=%d\n", ret_cod, errno));
        return ret_cod;
}



int bench_03_sio_run(bench_table_t *bt, const void *buffer,
                     size_t block_size, int record_num)
{
        enum Exception { FSEEK_ERROR1
                         , FREAD_ERROR
                         , FSEEK_ERROR2
                         , FWRITE_ERROR
                         , STREAM_SYNC
                         , NONE } excp;
        int ret_cod = JF_RC_INTERNAL_ERROR;

        JF_TRACE(("bench_03_sio_run\n"));
        TRY {
                int i, j;
                byte_t tmp_buffer[BENCH_TEST_MAX_RECSIZE];

                for (j = 0; j < record_num; ++j) {
                        /* writing */
                        for (i = 1; i <= bench_table_get_last(bt); ++i) {
                                off_t offset;
                                offset = (off_t)(
                                        random() % (block_size *
                                                    (BENCH_TEST_UPDATE_FACTOR *
                                                     record_num - 1)));
                                if (0 != fseeko(
                                            bench_table_get_stream(bt, i),
                                            offset, SEEK_SET))
                                        THROW(FSEEK_ERROR1);
                                if (1 != fread(tmp_buffer, block_size, 1,
                                               bench_table_get_stream(bt, i)))
                                        THROW(FREAD_ERROR);
                                if (0 != fseeko(
                                            bench_table_get_stream(bt, i),
                                            offset, SEEK_SET))
                                        THROW(FSEEK_ERROR2);
                                if (1 != fwrite(
                                            buffer, block_size, 1,
                                            bench_table_get_stream(bt, i)))
                                        THROW(FWRITE_ERROR);
                        } /* for (i = 1; i <= bench_table_get_last(bt); */
                } /* for (j = 0; j < n; ++j) */
                
                /* committing */
                for (i = 1; i <= bench_table_get_last(bt); ++i) {
                        ret_cod = jf_stream_sync(
                                bench_table_get_stream(bt, i),
                                bench_table_get_policy(bt));
                        if (JF_RC_OK != ret_cod)
                                THROW(STREAM_SYNC);
                } /* for (i = 1; i <= bench_table_get_last(bt); */
                
                THROW(NONE);
        } CATCH {
                switch (excp) {
                    case FSEEK_ERROR1:
                    case FSEEK_ERROR2:
                        ret_cod = JF_RC_FSEEK_ERROR;
                        break;
                    case FREAD_ERROR:
                        ret_cod = JF_RC_FREAD_ERROR;
                        break;
                    case FWRITE_ERROR:
                        ret_cod = JF_RC_FWRITE_ERROR;
                        break;
                    case STREAM_SYNC:
                        break;
                    case NONE:
                        ret_cod = JF_RC_OK;
                        break;
                    default:
                        ret_cod = JF_RC_INTERNAL_ERROR;
                } /* switch (excp) */
        } /* TRY-CATCH */
        JF_TRACE(("bench_03_sio_run/excp=%d/"
                  "ret_cod=%d/errno=%d\n", excp, ret_cod, errno));
        return ret_cod;
}



int bench_03_ljf_pre(bench_table_t *bt,
                     const char *path_prefix, int number_of_files,
                     size_t block_size, int record_num, uint32_t policy)
{
        int ret_cod = JF_RC_INTERNAL_ERROR;

        JF_TRACE(("bench_03_ljf_pre\n"));
        ret_cod = bench_X1_ljf_pre(bt, path_prefix, number_of_files,
                                   block_size, record_num, policy, "w+");
        JF_TRACE(("bench_03_ljf_pre/"
                  "ret_cod=%d/errno=%d\n", ret_cod, errno));
        return ret_cod;
}
        


int bench_03_ljf_post(bench_table_t *bt)
{
        int ret_cod = JF_RC_INTERNAL_ERROR;
        JF_TRACE(("bench_03_ljf_post\n"));
        ret_cod = bench_X0_ljf_post(bt);
        JF_TRACE(("bench_03_ljf_post/"
                  "ret_cod=%d/errno=%d\n", ret_cod, errno));
        return ret_cod;
}



int bench_03_ljf_run(bench_table_t *bt, const void *buffer,
                     size_t block_size, int record_num)
{
        enum Exception { FILE_SEEK1
                         , FILE_READ
                         , FILE_SEEK2
                         , FILE_WRITE
                         , JOURNAL_COMMIT
                         , NONE } excp;
        int ret_cod = JF_RC_INTERNAL_ERROR;

        JF_TRACE(("bench_03_ljf_run\n"));
        TRY {
                int i, j;
                byte_t tmp_buffer[BENCH_TEST_MAX_RECSIZE];

                for (j = 0; j < record_num; ++j) {
                        for (i = 1; i <= bench_table_get_last(bt); ++i) {
                                jf_offset_t offset;
                                size_t w;
                                offset = (jf_offset_t)(
                                        random() % (block_size *
                                                    (BENCH_TEST_UPDATE_FACTOR *
                                                     record_num - 1)));
                                ret_cod = jf_file_seek(
                                        bench_table_get_jfile(bt, i),
                                        offset, SEEK_SET);
                                if (JF_RC_OK != ret_cod)
                                        THROW(FILE_SEEK1);
                                ret_cod = jf_file_read(
                                        bench_table_get_jfile(bt, i),
                                        tmp_buffer, block_size, &w);
                                if (JF_RC_OK != ret_cod)
                                        THROW(FILE_READ);
                                ret_cod = jf_file_seek(
                                        bench_table_get_jfile(bt, i),
                                        offset, SEEK_SET);
                                if (JF_RC_OK != ret_cod)
                                        THROW(FILE_SEEK2);
                                ret_cod = jf_file_write(
                                        bench_table_get_jfile(bt, i),
                                        buffer, block_size, &w);
                                if (JF_RC_OK != ret_cod || block_size != w)
                                        THROW(FILE_WRITE);
                        } /* for (i = 1; i <= bench_table_get_last(bt); */
                } /* for (j = 0; j < n; ++j) */
                
                ret_cod = jf_journal_commit(
                        bench_table_get_journal(bt));
                if (JF_RC_OK != ret_cod)
                        THROW(JOURNAL_COMMIT);
                
                THROW(NONE);
        } CATCH {
                switch (excp) {
                    case FILE_WRITE:
                    case FILE_SEEK1:
                    case FILE_SEEK2:
                    case FILE_READ:
                    case JOURNAL_COMMIT:
                        break;
                    case NONE:
                        ret_cod = JF_RC_OK;
                        break;
                    default:
                        ret_cod = JF_RC_INTERNAL_ERROR;
                } /* switch (excp) */
        } /* TRY-CATCH */
        JF_TRACE(("bench_03_ljf_run/excp=%d/"
                  "ret_cod=%d/errno=%d\n", excp, ret_cod, errno));
        return ret_cod;
}

---

Copyright 2005 © Tiian