// Reads and verifies the specified number of records. Reader can also be
// stopped via gpr_cv_signal(&args->stop). Sleeps for 'read_interval_in_msec'
// between read iterations.
static void reader_thread(void* arg) {
reader_thread_args* args = (reader_thread_args*)arg;
if (VERBOSE) {
printf(" Reader starting\n");
}
gpr_timespec interval = gpr_time_from_micros(
args->read_iteration_interval_in_msec * 1000, GPR_TIMESPAN);
gpr_mu_lock(args->mu);
int records_read = 0;
int num_iterations = 0;
int counter = 0;
while (!args->stop_flag && records_read < args->total_records) {
gpr_cv_wait(&args->stop, args->mu, interval);
if (!args->stop_flag) {
records_read += perform_read_iteration(args->record_size);
GPR_ASSERT(records_read <= args->total_records);
if (VERBOSE && (counter++ == 100000)) {
printf(" Reader: %d out of %d read\n", records_read,
args->total_records);
counter = 0;
}
++num_iterations;
}
}
// Done
args->running = 0;
gpr_cv_signal(args->done);
if (VERBOSE) {
printf(" Reader: records: %d, iterations: %d\n", records_read,
num_iterations);
}
gpr_mu_unlock(args->mu);
}
/* Fills the log and verifies data. If 'no fragmentation' is true, records
are sized such that CENSUS_LOG_2_MAX_RECORD_SIZE is a multiple of record
size. If not a circular log, verifies that the number of records written
match the number of records read. */
static void fill_log(size_t log_size, int no_fragmentation, int circular_log) {
int size;
int32_t records_written;
int32_t usable_space;
int32_t records_read;
if (no_fragmentation) {
int log2size = rand() % (CENSUS_LOG_2_MAX_RECORD_SIZE + 1);
size = (1 << log2size);
} else {
while (1) {
size = 1 + (rand() % CENSUS_LOG_MAX_RECORD_SIZE);
if (CENSUS_LOG_MAX_RECORD_SIZE % size) {
break;
}
}
}
printf(" Fill record size: %d\n", size);
records_written = write_records_to_log(
0 /* writer id */, size, (log_size / size) * 2, 0 /* spin count */);
usable_space = min_usable_space(log_size, size);
GPR_ASSERT(records_written * size >= usable_space);
records_read = perform_read_iteration(size);
if (!circular_log) {
GPR_ASSERT(records_written == records_read);
}
assert_log_empty();
}
/* Reads and verifies the specified number of records. Reader can also be
stopped via gpr_cv_signal(&args->stop). Sleeps for 'read_interval_in_msec'
between read iterations. */
static void reader_thread(void* arg) {
gpr_int32 records_read = 0;
reader_thread_args* args = (reader_thread_args*)arg;
gpr_int32 num_iterations = 0;
gpr_timespec interval;
int counter = 0;
printf(" Reader starting\n");
interval = gpr_time_from_micros(args->read_iteration_interval_in_msec * 1000);
gpr_mu_lock(args->mu);
while (!args->stop_flag && records_read < args->total_records) {
gpr_cv_wait(&args->stop, args->mu, interval);
if (!args->stop_flag) {
records_read += perform_read_iteration(args->record_size);
GPR_ASSERT(records_read <= args->total_records);
if (counter++ == 100000) {
printf(" Reader: %d out of %d read\n", records_read,
args->total_records);
counter = 0;
}
++num_iterations;
}
}
/* Done */
args->running = 0;
gpr_cv_broadcast(args->done);
printf(" Reader: records: %d, iterations: %d\n", records_read,
num_iterations);
gpr_mu_unlock(args->mu);
}
// Fills the log and verifies data. If 'no fragmentation' is true, records
// are sized such that CENSUS_LOG_2_MAX_RECORD_SIZE is a multiple of record
// size. If not a circular log, verifies that the number of records written
// match the number of records read.
static void fill_log(size_t log_size, int no_fragmentation, int circular_log) {
size_t size;
if (no_fragmentation) {
int log2size = rand() % (CENSUS_LOG_2_MAX_RECORD_SIZE + 1);
size = ((size_t)1 << log2size);
} else {
while (1) {
size = 1 + ((size_t)rand() % CENSUS_LOG_MAX_RECORD_SIZE);
if (CENSUS_LOG_MAX_RECORD_SIZE % size) {
break;
}
}
}
int records_written =
write_records_to_log(0 /* writer id */, size,
(int)((log_size / size) * 2), 0 /* spin count */);
int records_read = perform_read_iteration(size);
if (!circular_log) {
GPR_ASSERT(records_written == records_read);
}
assert_log_empty();
}