ibp_capset_t *create_alias_allocs(int nallocs, ibp_capset_t *base_caps, int n_base) { int i, err; opque_t *q; op_generic_t *op; ibp_capset_t *bcap; ibp_capset_t *caps = (ibp_capset_t *)malloc(sizeof(ibp_capset_t)*nallocs); q = new_opque(); for (i=0; i<nallocs; i++) { bcap = &(base_caps[i % n_base]); op = new_ibp_alias_alloc_op(ic, &(caps[i]), get_ibp_cap(bcap, IBP_MANAGECAP), 0, 0, 0, ibp_timeout); opque_add(q, op); } io_start(q); err = io_waitall(q); if (err != 0) { printf("create_alias_allocs: At least 1 error occured! * ibp_errno=%d * nfailed=%d\n", err, opque_tasks_failed(q)); } opque_free(q, OP_DESTROY); return(caps); }
void random_allocs(ibp_capset_t *caps, int n, int asize, int block_size, double rfrac) { int i, err, bslot; int j, nblocks, rem, len; opque_t *q; op_generic_t *op; double rnd; tbuffer_t *buf; char *rbuffer = (char *)malloc(block_size); char *wbuffer = (char *)malloc(block_size); init_buffer(rbuffer, 'r', block_size); init_buffer(wbuffer, 'w', block_size); q = new_opque(); nblocks = asize / block_size; rem = asize % block_size; if (rem > 0) nblocks++; type_malloc_clear(buf, tbuffer_t, n*nblocks); for (j=0; j<nblocks; j++) { for (i=0; i<n; i++) { rnd = rand()/(RAND_MAX + 1.0); if ((j==(nblocks-1)) && (rem > 0)) { len = rem; } else { len = block_size; } bslot = j*n + i; if (rnd < rfrac) { tbuffer_single(&(buf[bslot]), len, rbuffer); op = new_ibp_read_op(ic, get_ibp_cap(&(caps[i]), IBP_READCAP), j*block_size, &(buf[bslot]), 0, len, ibp_timeout); } else { tbuffer_single(&(buf[bslot]), len, wbuffer); op = new_ibp_write_op(ic, get_ibp_cap(&(caps[i]), IBP_WRITECAP), j*block_size, &(buf[bslot]), 0, len, ibp_timeout); } opque_add(q, op); } } io_start(q); err = io_waitall(q); if (err != 0) { printf("random_allocs: At least 1 error occured! * ibp_errno=%d * nfailed=%d\n", err, opque_tasks_failed(q)); } opque_free(q, OP_DESTROY); free(buf); free(rbuffer); free(wbuffer); }
double small_random_allocs(ibp_capset_t *caps, int n, int asize, double readfrac, int small_count, int min_size, int max_size) { int i, io_size, offset, slot, err; opque_t *q; op_generic_t *op; double rnd, lmin, lmax; double nbytes; tbuffer_t *buf; q = new_opque(); lmin = log(min_size); lmax = log(max_size); if (asize < max_size) { max_size = asize; log_printf(0, "small_random_allocs: Adjusting max_size=%d\n", max_size); } char *rbuffer = (char *)malloc(max_size); char *wbuffer = (char *)malloc(max_size); init_buffer(rbuffer, '1', max_size); init_buffer(wbuffer, '2', max_size); type_malloc_clear(buf, tbuffer_t, small_count); nbytes = 0; for (i=0; i<small_count; i++) { rnd = rand()/(RAND_MAX+1.0); slot = n * rnd; rnd = rand()/(RAND_MAX+1.0); rnd = lmin + (lmax - lmin) * rnd; io_size = exp(rnd); if (io_size == 0) io_size = 1; nbytes = nbytes + io_size; rnd = rand()/(RAND_MAX+1.0); offset = (asize - io_size) * rnd; // log_printf(15, "small_random_allocs: slot=%d offset=%d size=%d\n", slot, offset, io_size); rnd = rand()/(RAND_MAX+1.0); if (rnd < readfrac) { tbuffer_single(&(buf[i]), io_size, rbuffer); op = new_ibp_read_op(ic, get_ibp_cap(&(caps[slot]), IBP_READCAP), offset, &(buf[i]), 0, io_size, ibp_timeout); } else { tbuffer_single(&(buf[i]), io_size, wbuffer); op = new_ibp_write_op(ic, get_ibp_cap(&(caps[slot]), IBP_WRITECAP), offset, &(buf[i]), 0, io_size, ibp_timeout); } opque_add(q, op); } io_start(q); err = io_waitall(q); if (err != 0) { printf("small_random_allocs: At least 1 error occured! * ibp_errno=%d * nfailed=%d\n", err, opque_tasks_failed(q)); } opque_free(q, OP_DESTROY); free(buf); free(rbuffer); free(wbuffer); return(nbytes); }
void read_allocs(ibp_capset_t *caps, int n, int asize, int block_size) { int i, j, nblocks, rem, len, err, slot; opque_t *q; op_generic_t *op; tbuffer_t *buf; char *buffer = (char *)malloc(block_size); q = new_opque(); nblocks = asize / block_size; rem = asize % block_size; if (rem > 0) nblocks++; type_malloc_clear(buf, tbuffer_t, n*nblocks); // for (j=0; j<nblocks; j++) { for (j=nblocks-1; j>= 0; j--) { for (i=0; i<n; i++) { if ((j==(nblocks-1)) && (rem > 0)) { len = rem; } else { len = block_size; } slot = j*n + i; tbuffer_single(&(buf[slot]), len, buffer); op = new_ibp_read_op(ic, get_ibp_cap(&(caps[i]), IBP_READCAP), j*block_size, &(buf[slot]), 0, len, ibp_timeout); opque_add(q, op); } } io_start(q); err = io_waitall(q); if (err != 0) { printf("read_allocs: At least 1 error occured! * ibp_errno=%d * nfailed=%d\n", err, opque_tasks_failed(q)); } opque_free(q, OP_DESTROY); free(buf); free(buffer); }
void validate_allocs(ibp_capset_t *caps_list, int nallocs) { int i, err; int nalloc_bad, nblocks_bad; opque_t *q; op_generic_t *op; int *bad_blocks = (int *) malloc(sizeof(int)*nallocs); int correct_errors = 0; q = new_opque(); for (i=0; i<nallocs; i++) { bad_blocks[i] = 0; op = new_ibp_validate_chksum_op(ic, get_ibp_cap(&(caps_list[i]), IBP_MANAGECAP), correct_errors, &(bad_blocks[i]), ibp_timeout); opque_add(q, op); } io_start(q); err = io_waitall(q); if (err != 0) { printf("validate_allocs: At least 1 error occured! * ibp_errno=%d * nfailed=%d\n", err, opque_tasks_failed(q)); nalloc_bad = 0; nblocks_bad = 0; for (i=0; i<nallocs; i++) { if (bad_blocks[i] != 0) { printf(" %d cap=%s blocks_bad=%d\n", i, get_ibp_cap(&(caps_list[i]), IBP_MANAGECAP), bad_blocks[i]); nalloc_bad++; nblocks_bad = nblocks_bad + bad_blocks[i]; } } printf(" Total Bad allocations: %d Total Bad blocks: %d\n", nalloc_bad, nblocks_bad); } opque_free(q, OP_DESTROY); free(bad_blocks); return; }
void remove_allocs(ibp_capset_t *caps_list, int nallocs) { int i, err; opque_t *q; op_generic_t *op; q = new_opque(); for (i=0; i<nallocs; i++) { op = new_ibp_remove_op(ic, get_ibp_cap(&(caps_list[i]), IBP_MANAGECAP), ibp_timeout); opque_add(q, op); } io_start(q); err = io_waitall(q); if (err != 0) { printf("remove_allocs: At least 1 error occured! * ibp_errno=%d * nfailed=%d\n", err, opque_tasks_failed(q)); } opque_free(q, OP_DESTROY); //** Lastly free all the caps and the array for (i=0; i<nallocs; i++) { destroy_ibp_cap(get_ibp_cap(&(caps_list[i]), IBP_READCAP)); destroy_ibp_cap(get_ibp_cap(&(caps_list[i]), IBP_WRITECAP)); destroy_ibp_cap(get_ibp_cap(&(caps_list[i]), IBP_MANAGECAP)); } free(caps_list); return; }
ibp_capset_t *create_allocs(int nallocs, int asize) { int i, err; ibp_attributes_t attr; ibp_depot_t *depot; opque_t *q; op_generic_t *op; ibp_capset_t *caps = (ibp_capset_t *)malloc(sizeof(ibp_capset_t)*nallocs); set_ibp_attributes(&attr, time(NULL) + a_duration, IBP_HARD, IBP_BYTEARRAY); q = new_opque(); for (i=0; i<nallocs; i++) { depot = &(depot_list[i % n_depots]); op = new_ibp_alloc_op(ic, &(caps[i]), asize, depot, &attr, disk_cs_type, disk_blocksize, ibp_timeout); opque_add(q, op); } io_start(q); err = io_waitall(q); if (err != 0) { printf("create_allocs: At least 1 error occured! * ibp_errno=%d * nfailed=%d\n", err, opque_tasks_failed(q)); abort(); } opque_free(q, OP_DESTROY); return(caps); }
double write_allocs(ibp_capset_t *caps, int qlen, int n, int asize, int block_size) { int count, i, j, nleft, nblocks, rem, len, err, block_start, alloc_start; int *slot; op_status_t status; int64_t nbytes, last_bytes, print_bytes, delta_bytes; apr_int32_t nfds, finished; double dbytes, r1, r2; apr_pool_t *pool; apr_file_t *fd_in; opque_t *q; op_generic_t *op; char *buffer = (char *)malloc(block_size); apr_interval_time_t dt = 10; apr_pollfd_t pfd; apr_time_t stime, dtime; int *tbuf_index; tbuffer_t *buf; Stack_t *tbuf_free; tbuf_free = new_stack(); type_malloc_clear(tbuf_index, int, qlen); type_malloc_clear(buf, tbuffer_t, qlen); for (i=0; i<qlen; i++) { tbuf_index[i] = i; push(tbuf_free, &(tbuf_index[i])); } //** Make the stuff to capture the kbd apr_pool_create(&pool, NULL); nfds = 1; apr_file_open_stdin(&fd_in, pool); pfd.p = pool; pfd.desc_type = APR_POLL_FILE; pfd.reqevents = APR_POLLIN|APR_POLLHUP; pfd.desc.f = fd_in; pfd.client_data = NULL; //** Init the ibp stuff init_buffer(buffer, 'W', block_size); q = new_opque(); opque_start_execution(q); nblocks = asize / block_size; rem = asize % block_size; if (rem > 0) nblocks++; block_start = 0; alloc_start = 0; finished = 0; apr_poll(&pfd, nfds, &finished, dt); count = 0; nbytes=0; last_bytes = 0; delta_bytes = 1024 * 1024 * 1024; print_bytes = delta_bytes; stime = apr_time_now(); while (finished == 0) { // nleft = qlen - opque_tasks_left(q); nleft = stack_size(tbuf_free); // printf("\nLOOP: nleft=%d qlen=%d\n", nleft, qlen); if (nleft > 0) { for (j=block_start; j < nblocks; j++) { for (i=alloc_start; i<n; i++) { nleft--; if (nleft <= 0) { block_start = j; alloc_start = i; goto skip_submit; } slot = (int *)pop(tbuf_free); if ((j==(nblocks-1)) && (rem > 0)) { len = rem; } else { len = block_size; } // printf("%d=(%d,%d) ", count, j, i); tbuffer_single(&(buf[*slot]), len, buffer); op = new_ibp_write_op(ic, get_ibp_cap(&(caps[i]), IBP_WRITECAP), j*block_size, &(buf[*slot]), 0, len, ibp_timeout); gop_set_id(op, *slot); ibp_op_set_cc(ibp_get_iop(op), cc); ibp_op_set_ncs(ibp_get_iop(op), ncs); opque_add(q, op); } alloc_start = 0; } block_start = 0; } skip_submit: finished = 1; apr_poll(&pfd, nfds, &finished, dt); do { //** Empty the finished queue. Always wait for for at least 1 to complete op = opque_waitany(q); status = gop_get_status(op); if (status.error_code != IBP_OK) { printf("ERROR: Aborting with error code %d\n", status.error_code); finished = 0; } count++; i = gop_get_id(op); nbytes = nbytes + tbuffer_size(&(buf[i])); if (nbytes > print_bytes) { dbytes = nbytes / (1.0*1024*1024*1024); dtime = apr_time_now() - stime; r2 = dtime / (1.0 * APR_USEC_PER_SEC); r1 = nbytes - last_bytes; r1 = r1 / (r2 * 1024.0 * 1024.0); printf("%.2lfGB written (%.2lfMB/s : %.2lf secs)\n", dbytes, r1, r2); print_bytes = print_bytes + delta_bytes; last_bytes = nbytes; stime = apr_time_now(); } push(tbuf_free, &(tbuf_index[i])); gop_free(op, OP_DESTROY); } while (opque_tasks_finished(q) > 0); } err = opque_waitall(q); if (err != OP_STATE_SUCCESS) { printf("write_allocs: At least 1 error occured! * ibp_errno=%d * nfailed=%d\n", err, opque_tasks_failed(q)); } opque_free(q, OP_DESTROY); free_stack(tbuf_free, 0); free(tbuf_index); free(buf); free(buffer); apr_pool_destroy(pool); dbytes = nbytes; return(dbytes); }