Get rid of __ prefix for internal frand state

It made (some) sense when we had both OS and frand in anon unions,
but now lets just kill it.

Signed-off-by: Jens Axboe <axboe@fb.com>

diff --git a/backend.c b/backend.c
index d19d870f8143d985882841af68a0a94c056f7e35..cae4e38de4b9fb3adc871863558dd1230bba32b2 100644 (file)
--- a/backend.c
+++ b/backend.c
@@ -753,9 +753,9 @@ static uint64_t do_io(struct thread_data *td)
                    ((io_u->flags & IO_U_F_VER_LIST) || !td_rw(td))) {
 
                        if (!td->o.verify_pattern_bytes) {
-                               io_u->rand_seed = __rand(&td->__verify_state);
+                               io_u->rand_seed = __rand(&td->verify_state);
                                if (sizeof(int) != sizeof(long *))
-                                       io_u->rand_seed *= __rand(&td->__verify_state);
+                                       io_u->rand_seed *= __rand(&td->verify_state);
                        }
 
                        if (td->o.verify_async)

diff --git a/filesetup.c b/filesetup.c
index 1b487d22202473374ccf00dd3fbcdb3e6aa68f9e..4026f4de1bdb9ddbec833e251c9e99309ec5d16d 100644 (file)
--- a/filesetup.c
+++ b/filesetup.c
@@ -261,7 +261,7 @@ static unsigned long long get_rand_file_size(struct thread_data *td)
        unsigned long long ret, sized;
        unsigned long r;
 
-       r = __rand(&td->__file_size_state);
+       r = __rand(&td->file_size_state);
        sized = td->o.file_size_high - td->o.file_size_low;
        ret = (unsigned long long) ((double) sized * (r / (FRAND_MAX + 1.0)));
        ret += td->o.file_size_low;

diff --git a/fio.h b/fio.h
index 4ab28256801a40be41a29854af522c2839b74946..28f459750bf53949541609015d62b3cead4ea97d 100644 (file)
--- a/fio.h
+++ b/fio.h
@@ -137,7 +137,7 @@ struct thread_data {
        unsigned int nr_normal_files;
        union {
                unsigned int next_file;
-               struct frand_state __next_file_state;
+               struct frand_state next_file_state;
        };
        int error;
        int sig;
@@ -159,10 +159,10 @@ struct thread_data {
 
        unsigned long rand_seeds[FIO_RAND_NR_OFFS];
 
-       struct frand_state __bsrange_state;
-       struct frand_state __verify_state;
-       struct frand_state __trim_state;
-       struct frand_state __delay_state;
+       struct frand_state bsrange_state;
+       struct frand_state verify_state;
+       struct frand_state trim_state;
+       struct frand_state delay_state;
 
        struct frand_state buf_state;
        struct frand_state buf_state_prev;
@@ -236,7 +236,7 @@ struct thread_data {
        /*
         * State for random io, a bitmap of blocks done vs not done
         */
-       struct frand_state __random_state;
+       struct frand_state random_state;
 
        struct timeval start;   /* start of this loop */
        struct timeval epoch;   /* time job was started */
@@ -261,7 +261,7 @@ struct thread_data {
        /*
         * read/write mixed workload state
         */
-       struct frand_state __rwmix_state;
+       struct frand_state rwmix_state;
        unsigned long rwmix_issues;
        enum fio_ddir rwmix_ddir;
        unsigned int ddir_seq_nr;
@@ -269,7 +269,7 @@ struct thread_data {
        /*
         * rand/seq mixed workload state
         */
-       struct frand_state __seq_rand_state[DDIR_RWDIR_CNT];
+       struct frand_state seq_rand_state[DDIR_RWDIR_CNT];
 
        /*
         * IO history logs for verification. We use a tree for sorting,
@@ -304,7 +304,7 @@ struct thread_data {
        /*
         * For generating file sizes
         */
-       struct frand_state __file_size_state;
+       struct frand_state file_size_state;
 
        /*
         * Error counts

diff --git a/init.c b/init.c
index 313254381f790a10af01f3df9dffa0d15f3215ba..c2c126b55ff2bd2187baebe5e7a04b1977519369 100644 (file)
--- a/init.c
+++ b/init.c
@@ -470,7 +470,7 @@ static unsigned long long get_rand_start_delay(struct thread_data *td)
 
        delayrange = td->o.start_delay_high - td->o.start_delay;
 
-       r = __rand(&td->__delay_state);
+       r = __rand(&td->delay_state);
        delayrange = (unsigned long long) ((double) delayrange * (r / (FRAND_MAX + 1.0)));
 
        delayrange += td->o.start_delay;
@@ -784,16 +784,16 @@ static int exists_and_not_file(const char *filename)
 
 static void td_fill_rand_seeds_internal(struct thread_data *td)
 {
-       init_rand_seed(&td->__bsrange_state, td->rand_seeds[FIO_RAND_BS_OFF]);
-       init_rand_seed(&td->__verify_state, td->rand_seeds[FIO_RAND_VER_OFF]);
-       init_rand_seed(&td->__rwmix_state, td->rand_seeds[FIO_RAND_MIX_OFF]);
+       init_rand_seed(&td->bsrange_state, td->rand_seeds[FIO_RAND_BS_OFF]);
+       init_rand_seed(&td->verify_state, td->rand_seeds[FIO_RAND_VER_OFF]);
+       init_rand_seed(&td->rwmix_state, td->rand_seeds[FIO_RAND_MIX_OFF]);
 
        if (td->o.file_service_type == FIO_FSERVICE_RANDOM)
-               init_rand_seed(&td->__next_file_state, td->rand_seeds[FIO_RAND_FILE_OFF]);
+               init_rand_seed(&td->next_file_state, td->rand_seeds[FIO_RAND_FILE_OFF]);
 
-       init_rand_seed(&td->__file_size_state, td->rand_seeds[FIO_RAND_FILE_SIZE_OFF]);
-       init_rand_seed(&td->__trim_state, td->rand_seeds[FIO_RAND_TRIM_OFF]);
-       init_rand_seed(&td->__delay_state, td->rand_seeds[FIO_RAND_START_DELAY]);
+       init_rand_seed(&td->file_size_state, td->rand_seeds[FIO_RAND_FILE_SIZE_OFF]);
+       init_rand_seed(&td->trim_state, td->rand_seeds[FIO_RAND_TRIM_OFF]);
+       init_rand_seed(&td->delay_state, td->rand_seeds[FIO_RAND_START_DELAY]);
 
        if (!td_random(td))
                return;
@@ -801,10 +801,10 @@ static void td_fill_rand_seeds_internal(struct thread_data *td)
        if (td->o.rand_repeatable)
                td->rand_seeds[FIO_RAND_BLOCK_OFF] = FIO_RANDSEED * td->thread_number;
 
-       init_rand_seed(&td->__random_state, td->rand_seeds[FIO_RAND_BLOCK_OFF]);
-       init_rand_seed(&td->__seq_rand_state[DDIR_READ], td->rand_seeds[FIO_RAND_SEQ_RAND_READ_OFF]);
-       init_rand_seed(&td->__seq_rand_state[DDIR_WRITE], td->rand_seeds[FIO_RAND_SEQ_RAND_WRITE_OFF]);
-       init_rand_seed(&td->__seq_rand_state[DDIR_TRIM], td->rand_seeds[FIO_RAND_SEQ_RAND_TRIM_OFF]);
+       init_rand_seed(&td->random_state, td->rand_seeds[FIO_RAND_BLOCK_OFF]);
+       init_rand_seed(&td->seq_rand_state[DDIR_READ], td->rand_seeds[FIO_RAND_SEQ_RAND_READ_OFF]);
+       init_rand_seed(&td->seq_rand_state[DDIR_WRITE], td->rand_seeds[FIO_RAND_SEQ_RAND_WRITE_OFF]);
+       init_rand_seed(&td->seq_rand_state[DDIR_TRIM], td->rand_seeds[FIO_RAND_SEQ_RAND_TRIM_OFF]);
 }
 
 void td_fill_rand_seeds(struct thread_data *td)

diff --git a/io_u.c b/io_u.c
index 751e2cf7e1d7404e66e30ecd5d27f731dac01064..d815ad9a340a63aaee1c0de05c402adec129835e 100644 (file)
--- a/io_u.c
+++ b/io_u.c
@@ -90,7 +90,7 @@ static int __get_next_rand_offset(struct thread_data *td, struct fio_file *f,
                return 1;
 
        if (td->o.random_generator == FIO_RAND_GEN_TAUSWORTHE) {
-               r = __rand(&td->__random_state);
+               r = __rand(&td->random_state);
 
                dprint(FD_RANDOM, "off rand %llu\n", (unsigned long long) r);
 
@@ -190,7 +190,7 @@ static int should_do_random(struct thread_data *td, enum fio_ddir ddir)
        if (td->o.perc_rand[ddir] == 100)
                return 1;
 
-       r = __rand(&td->__seq_rand_state[ddir]);
+       r = __rand(&td->seq_rand_state[ddir]);
        v = 1 + (int) (100.0 * (r / (FRAND_MAX + 1.0)));
 
        return v <= td->o.perc_rand[ddir];
@@ -441,7 +441,7 @@ static unsigned int __get_next_buflen(struct thread_data *td, struct io_u *io_u,
                return 0;
 
        do {
-               r = __rand(&td->__bsrange_state);
+               r = __rand(&td->bsrange_state);
 
                if (!td->o.bssplit_nr[ddir]) {
                        buflen = 1 + (unsigned int) ((double) maxbs *
@@ -506,7 +506,7 @@ static inline enum fio_ddir get_rand_ddir(struct thread_data *td)
        unsigned int v;
        unsigned long r;
 
-       r = __rand(&td->__rwmix_state);
+       r = __rand(&td->rwmix_state);
        v = 1 + (int) (100.0 * (r / (FRAND_MAX + 1.0)));
 
        if (v <= td->o.rwmix[DDIR_READ])
@@ -959,7 +959,7 @@ static struct fio_file *get_next_file_rand(struct thread_data *td,
                int opened = 0;
                unsigned long r;
 
-               r = __rand(&td->__next_file_state);
+               r = __rand(&td->next_file_state);
                fno = (unsigned int) ((double) td->o.nr_files
                                * (r / (FRAND_MAX + 1.0)));
 

diff --git a/trim.c b/trim.c
index a15263da95a238d81d9e7d73e6d9e4d237579aaa..95c433b7c006aa0817357bd6d4b2d94d0d4b68fb 100644 (file)
--- a/trim.c
+++ b/trim.c
@@ -75,7 +75,7 @@ int io_u_should_trim(struct thread_data *td, struct io_u *io_u)
        if (!td->o.trim_percentage)
                return 0;
 
-       r = __rand(&td->__trim_state);
+       r = __rand(&td->trim_state);
        val = (FRAND_MAX / 100ULL);
 
        val *= (unsigned long long) td->o.trim_percentage;

diff --git a/verify.c b/verify.c
index 35d8969624cffb7275f23dd228fab78cecceeebd..f5c009cec5f5355f23db9027e1de50f1d993308c 100644 (file)
--- a/verify.c
+++ b/verify.c
@@ -73,7 +73,7 @@ void fill_verify_pattern(struct thread_data *td, void *p, unsigned int len,
                if (use_seed)
                        __fill_random_buf(p, len, seed);
                else
-                       io_u->rand_seed = fill_random_buf(&td->__verify_state, p, len);
+                       io_u->rand_seed = fill_random_buf(&td->verify_state, p, len);
                return;
        }
 
@@ -1140,9 +1140,9 @@ int get_next_verify(struct thread_data *td, struct io_u *io_u)
                dprint(FD_VERIFY, "get_next_verify: ret io_u %p\n", io_u);
 
                if (!td->o.verify_pattern_bytes) {
-                       io_u->rand_seed = __rand(&td->__verify_state);
+                       io_u->rand_seed = __rand(&td->verify_state);
                        if (sizeof(int) != sizeof(long *))
-                               io_u->rand_seed *= __rand(&td->__verify_state);
+                               io_u->rand_seed *= __rand(&td->verify_state);
                }
                return 0;
        }