int main(int argc, char *argv[]) { int i; void *buffs[TEST_SOURCES + 2]; struct perf start; printf("Test pq_gen_perf %d sources X %d bytes\n", TEST_SOURCES, TEST_LEN); // Allocate the arrays for (i = 0; i < TEST_SOURCES + 2; i++) { int ret; void *buf; ret = posix_memalign(&buf, 64, TEST_LEN); if (ret) { printf("alloc error: Fail"); return 1; } buffs[i] = buf; } // Setup data for (i = 0; i < TEST_SOURCES + 2; i++) memset(buffs[i], 0, TEST_LEN); // Warm up BENCHMARK(&start, BENCHMARK_TIME, pq_gen(TEST_SOURCES + 2, TEST_LEN, buffs)); printf("pq_gen" TEST_TYPE_STR ": "); perf_print(start, (long long)TEST_MEM); return 0; }
int main(void) { int i; unsigned char key1[16], key2[16], tinit[16]; unsigned char *pt, *ct; printf("aes_xts_128_enc_perf:\n"); pt = malloc(TEST_LEN); ct = malloc(TEST_LEN); if (NULL == pt || NULL == ct) { printf("malloc of testsize failed\n"); return -1; } mk_rand_data(key1, key2, tinit, pt, TEST_LEN); XTS_AES_128_enc(key2, key1, tinit, TEST_LEN, pt, ct); struct perf start, stop; perf_start(&start); for (i = 0; i < TEST_LOOPS; i++) { XTS_AES_128_enc(key2, key1, tinit, TEST_LEN, pt, ct); } perf_stop(&stop); printf("aes_xts_128_enc" TEST_TYPE_STR ": "); perf_print(stop, start, (long long)TEST_LEN * i); return 0; }
int main(int argc, char *argv[]) { int i; void *buf; uint16_t crc; struct perf start, stop; printf("crc16_t10dif_perf:\n"); if (posix_memalign(&buf, 1024, TEST_LEN)) { printf("alloc error: Fail"); return -1; } printf("Start timed tests\n"); fflush(0); memset(buf, 0, TEST_LEN); crc = crc16_t10dif(TEST_SEED, buf, TEST_LEN); perf_start(&start); for (i = 0; i < TEST_LOOPS; i++) { crc = crc16_t10dif(TEST_SEED, buf, TEST_LEN); } perf_stop(&stop); printf("crc16_t10dif" TEST_TYPE_STR ": "); perf_print(stop, start, (long long)TEST_LEN * i); printf("finish 0x%x\n", crc); return 0; }
void perf_add(char *id) { GET_CPU_CYCLES(logpos->time); logpos->id = id; logpos++; if (logpos == &perf_log[LOG_SIZE]) { perf_print(); } }
static long fimg2d_ioctl(struct file *file, unsigned int cmd, unsigned long arg) { int ret = 0; struct fimg2d_context *ctx; struct fimg2d_platdata *pdata; union { struct fimg2d_blit *blit; struct fimg2d_version ver; } u; ctx = file->private_data; if (!ctx) { printk(KERN_ERR "[%s] missing ctx\n", __func__); return -EFAULT; } switch (cmd) { case FIMG2D_BITBLT_BLIT: fimg2d_debug("FIMG2D_BITBLT_BLIT ctx: %p\n", ctx); u.blit = (struct fimg2d_blit *)arg; ret = fimg2d_add_command(info, ctx, u.blit); if (!ret) fimg2d_request_bitblt(ctx); #ifdef PERF_PROFILE perf_print(ctx, u.blit->seq_no); perf_clear(ctx); #endif break; case FIMG2D_BITBLT_SYNC: fimg2d_debug("FIMG2D_BITBLT_SYNC ctx: %p\n", ctx); /* FIXME: */ break; case FIMG2D_BITBLT_VERSION: fimg2d_debug("FIMG2D_BITBLT_VERSION ctx: %p\n", ctx); pdata = to_fimg2d_plat(info->dev); u.ver.hw = pdata->hw_ver; u.ver.sw = 0; fimg2d_debug("fimg2d version, hw: 0x%x sw: 0x%x\n", u.ver.hw, u.ver.sw); if (copy_to_user((void *)arg, &u.ver, sizeof(u.ver))) return -EFAULT; break; default: printk(KERN_ERR "[%s] unknown ioctl\n", __func__); ret = -EFAULT; break; } return ret; }
void fimg2d_del_command(struct fimg2d_control *ctrl, struct fimg2d_bltcmd *cmd) { unsigned long flags; struct fimg2d_context *ctx = cmd->ctx; perf_end(cmd, PERF_TOTAL); perf_print(cmd); g2d_spin_lock(&ctrl->bltlock, flags); fimg2d_dequeue(&cmd->node); kfree(cmd); atomic_dec(&ctx->ncmd); #ifdef BLIT_WORKQUE /* wake up context */ if (!atomic_read(&ctx->ncmd)) wake_up(&ctx->wait_q); #endif g2d_spin_unlock(&ctrl->bltlock, flags); }
int main(int argc, char *argv[]) { int i; u8 *buff1, *buff2, gf_const_tbl[64], a = 2; struct perf start, stop; printf("gf_vect_mul_perf:\n"); mk_gf_field(); gf_vect_mul_init(a, gf_const_tbl); // Allocate large mem region buff1 = (u8*) malloc(TEST_LEN); buff2 = (u8*) malloc(TEST_LEN); if (NULL == buff1 || NULL == buff2){ printf("Failed to allocate %dB\n", TEST_LEN); return 1; } memset(buff1, 0, TEST_LEN); memset(buff2, 0, TEST_LEN); gf_vect_mul(TEST_LEN, gf_const_tbl, buff1, buff2); printf("Start timed tests\n"); fflush(0); gf_vect_mul(TEST_LEN, gf_const_tbl, buff1, buff2); perf_start(&start); for(i=0; i<TEST_LOOPS; i++){ gf_vect_mul_init(a, gf_const_tbl); gf_vect_mul(TEST_LEN, gf_const_tbl, buff1, buff2); } perf_stop(&stop); printf("gf_vect_mul" TEST_TYPE_STR ": "); perf_print(stop,start,(long long)TEST_LEN*i); return 0; }
int main(void) { int i, j, k; u8 s, vec[TEST_SOURCES], dest1[TEST_LEN], dest2[TEST_LEN]; u8 *matrix[TEST_SOURCES]; struct perf start, stop; mk_gf_field(); mk_gf_mul_table(gf_mul_table); //generate random vector and matrix/data for (i = 0; i < TEST_SOURCES; i++) { vec[i] = rand(); if (!(matrix[i] = malloc(TEST_LEN))) { fprintf(stderr, "Error failure\n\n"); return -1; } for (j = 0; j < TEST_LEN; j++) matrix[i][j] = rand(); } gf_vect_dot_prod_ref(TEST_LEN, TEST_SOURCES, vec, matrix, dest1); perf_start(&start); for (i = 0; i < TEST_LOOPS; i++) gf_vect_dot_prod_ref(TEST_LEN, TEST_SOURCES, vec, matrix, dest1); perf_stop(&stop); printf("gf_vect_dot_prod_2tbl" TEST_TYPE_STR ": "); perf_print(stop, start, (long long)TEST_LEN * (TEST_SOURCES + 1) * i); // Warm up mult tables for (i = 0; i < TEST_LEN; i++) { s = 0; for (j = 0; j < TEST_SOURCES; j++) { s ^= gf_mul_table[vec[j] * 256 + matrix[j][i]]; } dest2[i] = s; } perf_start(&start); for (k = 0; k < TEST_LOOPS; k++) { for (i = 0; i < TEST_LEN; i++) { s = 0; for (j = 0; j < TEST_SOURCES; j++) { s ^= gf_mul_table[vec[j] * 256 + matrix[j][i]]; } dest2[i] = s; } } perf_stop(&stop); printf("gf_vect_dot_prod_1tbl" TEST_TYPE_STR ": "); perf_print(stop, start, (long long)TEST_LEN * (TEST_SOURCES + 1) * k); // Compare with reference function if (0 != memcmp(dest1, dest2, TEST_LEN)) { printf("Error, different results!\n\n"); return -1; } printf("Pass functional test\n"); return 0; }
int main(int argc, char *argv[]) { FILE *in, *out = NULL; unsigned char *inbuf, *outbuf; int i, infile_size, iterations, outbuf_size; if (argc > 3 || argc < 2) { fprintf(stderr, "Usage: igzip_sync_flush_file_perf infile [outfile]\n" "\t - Runs multiple iterations of igzip on a file to get more accurate time results.\n"); exit(0); } in = fopen(argv[1], "rb"); if (!in) { fprintf(stderr, "Can't open %s for reading\n", argv[1]); exit(0); } if (argc > 2) { out = fopen(argv[2], "wb"); if (!out) { fprintf(stderr, "Can't open %s for writing\n", argv[2]); exit(0); } printf("outfile=%s\n", argv[2]); } printf("Window Size: %d K\n", HIST_SIZE); printf("igzip_sync_flush_file_perf: \n"); fflush(0); /* Allocate space for entire input file and * output (assuming 1:1 max output size) */ infile_size = get_filesize(in); if (infile_size != 0) { outbuf_size = infile_size; iterations = RUN_MEM_SIZE / infile_size; } else { outbuf_size = BUF_SIZE; iterations = MIN_TEST_LOOPS; } if (iterations < MIN_TEST_LOOPS) iterations = MIN_TEST_LOOPS; inbuf = malloc(infile_size); if (inbuf == NULL) { fprintf(stderr, "Can't allocate input buffer memory\n"); exit(0); } outbuf = malloc(outbuf_size); if (outbuf == NULL) { fprintf(stderr, "Can't allocate output buffer memory\n"); exit(0); } printf("igzip_sync_flush_file_perf: %s %d iterations\n", argv[1], iterations); /* Read complete input file into buffer */ stream.avail_in = (uint32_t) fread(inbuf, 1, infile_size, in); if (stream.avail_in != infile_size) { fprintf(stderr, "Couldn't fit all of input file into buffer\n"); exit(0); } struct perf start, stop; perf_start(&start); for (i = 0; i < iterations; i++) { isal_deflate_init(&stream); stream.end_of_stream = 0; stream.flush = SYNC_FLUSH; stream.next_in = inbuf; stream.avail_in = infile_size / 2; stream.next_out = outbuf; stream.avail_out = outbuf_size / 2; isal_deflate(&stream); if (infile_size == 0) continue; stream.avail_in = infile_size - infile_size / 2; stream.end_of_stream = 1; stream.next_in = inbuf + stream.total_in; stream.flush = SYNC_FLUSH; stream.avail_out = infile_size - outbuf_size / 2; stream.next_out = outbuf + stream.total_out; isal_deflate(&stream); if (stream.avail_in != 0) break; } perf_stop(&stop); if (stream.avail_in != 0) { fprintf(stderr, "Could not compress all of inbuf\n"); exit(0); } printf(" file %s - in_size=%d out_size=%d iter=%d ratio=%3.1f%%\n", argv[1], infile_size, stream.total_out, i, 100.0 * stream.total_out / infile_size); printf("igzip_file: "); perf_print(stop, start, (long long)infile_size * i); if (argc > 2 && out) { printf("writing %s\n", argv[2]); fwrite(outbuf, 1, stream.total_out, out); fclose(out); } fclose(in); printf("End of igzip_sync_flush_file_perf\n\n"); fflush(0); return 0; }
int main(void) { int i; unsigned char key1[16], key2[16], tinit[16]; unsigned char *pt, *ct, *refct; struct perf start, stop; unsigned char keyssl[32]; /* SSL takes both keys together */ /* Initialise our cipher context, which can use same input vectors */ EVP_CIPHER_CTX *ctx; ctx = EVP_CIPHER_CTX_new(); printf("aes_xts_128_enc_perf:\n"); pt = malloc(TEST_LEN); ct = malloc(TEST_LEN); refct = malloc(TEST_LEN); if (NULL == pt || NULL == ct || NULL == refct) { printf("malloc of testsize failed\n"); return -1; } xts128_mk_rand_data(key1, key2, tinit, pt, TEST_LEN); /* Set up key for the SSL engine */ for (i = 0; i < 16; i++) { keyssl[i] = key1[i]; keyssl[i + 16] = key2[i]; } /* Encrypt and compare output */ XTS_AES_128_enc(key2, key1, tinit, TEST_LEN, pt, ct); openssl_aes_128_xts_enc(ctx, keyssl, tinit, TEST_LEN, pt, refct); if (memcmp(ct, refct, TEST_LEN)) { printf("ISA-L and OpenSSL results don't match\n"); return -1; } /* Time ISA-L encryption */ perf_start(&start); for (i = 0; i < TEST_LOOPS; i++) XTS_AES_128_enc(key2, key1, tinit, TEST_LEN, pt, ct); perf_stop(&stop); printf("aes_xts_128_enc" TEST_TYPE_STR ": "); perf_print(stop, start, (long long)TEST_LEN * i); /* Time OpenSSL encryption */ perf_start(&start); for (i = 0; i < TEST_LOOPS; i++) openssl_aes_128_xts_enc(ctx, keyssl, tinit, TEST_LEN, pt, refct); perf_stop(&stop); printf("aes_xts_128_openssl_enc" TEST_TYPE_STR ": "); perf_print(stop, start, (long long)TEST_LEN * i); EVP_CIPHER_CTX_free(ctx); return 0; }
int main(int argc, char *argv[]) { int i, j, rtest, m, k, nerrs, r; void *buf; u8 *temp_buffs[TEST_SOURCES], *buffs[TEST_SOURCES]; u8 a[MMAX * KMAX], b[MMAX * KMAX], c[MMAX * KMAX], d[MMAX * KMAX]; u8 g_tbls[KMAX * TEST_SOURCES * 32], src_in_err[TEST_SOURCES]; u8 src_err_list[TEST_SOURCES], *recov[TEST_SOURCES]; struct perf start, stop; // Pick test parameters m = 14; k = 10; nerrs = 4; const u8 err_list[] = {2, 4, 5, 7}; printf("erasure_code_base_perf: %dx%d %d\n", m, TEST_LEN(m), nerrs); if (m > MMAX || k > KMAX || nerrs > (m - k)){ printf(" Input test parameter error\n"); return -1; } memcpy(src_err_list, err_list, nerrs); memset(src_in_err, 0, TEST_SOURCES); for (i = 0; i < nerrs; i++) src_in_err[src_err_list[i]] = 1; // Allocate the arrays for (i = 0; i < m; i++) { if (posix_memalign(&buf, 64, TEST_LEN(m))) { printf("alloc error: Fail\n"); return -1; } buffs[i] = buf; } for (i = 0; i < (m - k); i++) { if (posix_memalign(&buf, 64, TEST_LEN(m))) { printf("alloc error: Fail\n"); return -1; } temp_buffs[i] = buf; } // Make random data for (i = 0; i < k; i++) for (j = 0; j < TEST_LEN(m); j++) buffs[i][j] = rand(); gf_gen_rs_matrix(a, m, k); ec_init_tables(k, m - k, &a[k * k], g_tbls); ec_encode_data_base(TEST_LEN(m), k, m - k, g_tbls, buffs, &buffs[k]); // Start encode test perf_start(&start); for (rtest = 0; rtest < TEST_LOOPS(m); rtest++) { // Make parity vects ec_init_tables(k, m - k, &a[k * k], g_tbls); ec_encode_data_base(TEST_LEN(m), k, m - k, g_tbls, buffs, &buffs[k]); } perf_stop(&stop); printf("erasure_code_base_encode" TEST_TYPE_STR ": "); perf_print(stop, start, (long long)(TEST_LEN(m)) * (m) * rtest); // Start decode test perf_start(&start); for (rtest = 0; rtest < TEST_LOOPS(m); rtest++) { // Construct b by removing error rows for (i = 0, r = 0; i < k; i++, r++) { while (src_in_err[r]) r++; recov[i] = buffs[r]; for (j = 0; j < k; j++) b[k * i + j] = a[k * r + j]; } if (gf_invert_matrix(b, d, k) < 0) { printf("BAD MATRIX\n"); return -1; } for (i = 0; i < nerrs; i++) for (j = 0; j < k; j++) c[k * i + j] = d[k * src_err_list[i] + j]; // Recover data ec_init_tables(k, nerrs, c, g_tbls); ec_encode_data_base(TEST_LEN(m), k, nerrs, g_tbls, recov, temp_buffs); } perf_stop(&stop); for (i = 0; i < nerrs; i++) { if (0 != memcmp(temp_buffs[i], buffs[src_err_list[i]], TEST_LEN(m))) { printf("Fail error recovery (%d, %d, %d) - ", m, k, nerrs); return -1; } } printf("erasure_code_base_decode" TEST_TYPE_STR ": "); perf_print(stop, start, (long long)(TEST_LEN(m)) * (k + nerrs) * rtest); printf("done all: Pass\n"); return 0; }
static long fimg2d_ioctl(struct file *file, unsigned int cmd, unsigned long arg) { int ret = 0; struct fimg2d_context *ctx; struct fimg2d_platdata *pdata; struct fimg2d_blit blit; struct fimg2d_version ver; struct fimg2d_image dst; ctx = file->private_data; if (!ctx) { printk(KERN_ERR "[%s] missing ctx\n", __func__); return -EFAULT; } switch (cmd) { case FIMG2D_BITBLT_BLIT: if (info->secure) return -EFAULT; if (copy_from_user(&blit, (void *)arg, sizeof(blit))) return -EFAULT; if (blit.dst) if (copy_from_user(&dst, (void *)blit.dst, sizeof(dst))) return -EFAULT; #ifdef CONFIG_BUSFREQ_OPP #if defined(CONFIG_CPU_EXYNOS4212) || defined(CONFIG_CPU_EXYNOS4412) dev_lock(info->bus_dev, info->dev, 160160); #endif #endif if ((blit.dst) && (dst.addr.type == ADDR_USER)) if (!down_write_trylock(&page_alloc_slow_rwsem)) ret = -EAGAIN; if (ret != -EAGAIN) ret = fimg2d_add_command(info, ctx, &blit, dst.addr.type); if (!ret) { fimg2d_request_bitblt(ctx); } #ifdef PERF_PROFILE perf_print(ctx, blit.seq_no); perf_clear(ctx); #endif if ((blit.dst) && (dst.addr.type == ADDR_USER) && ret != -EAGAIN) up_write(&page_alloc_slow_rwsem); #ifdef CONFIG_BUSFREQ_OPP #if defined(CONFIG_CPU_EXYNOS4212) || defined(CONFIG_CPU_EXYNOS4412) dev_unlock(info->bus_dev, info->dev); #endif #endif break; case FIMG2D_BITBLT_SYNC: fimg2d_debug("FIMG2D_BITBLT_SYNC ctx: %p\n", ctx); /* FIXME: */ break; case FIMG2D_BITBLT_VERSION: pdata = to_fimg2d_plat(info->dev); ver.hw = pdata->hw_ver; ver.sw = 0; fimg2d_debug("fimg2d version, hw: 0x%x sw: 0x%x\n", ver.hw, ver.sw); if (copy_to_user((void *)arg, &ver, sizeof(ver))) return -EFAULT; break; case FIMG2D_BITBLT_SECURE: if (copy_from_user(&info->secure, (unsigned int *)arg, sizeof(unsigned int))) { printk(KERN_ERR "[%s] failed to FIMG2D_BITBLT_SECURE: copy_from_user error\n\n", __func__); return -EFAULT; } while (1) { if (fimg2d_queue_is_empty(&info->cmd_q)) break; mdelay(2); } break; default: printk(KERN_ERR "[%s] unknown ioctl\n", __func__); ret = -EFAULT; break; } return ret; }
int main(int argc, char *argv[]) { int i, j; void *buf; u8 g1[TEST_SOURCES], g2[TEST_SOURCES], g3[TEST_SOURCES]; u8 g4[TEST_SOURCES], g5[TEST_SOURCES], g6[TEST_SOURCES], *g_tbls; u8 *dest1, *dest2, *dest3, *dest4, *dest5, *dest6, *dest_ref1; u8 *dest_ref2, *dest_ref3, *dest_ref4, *dest_ref5, *dest_ref6; u8 *dest_ptrs[6], *buffs[TEST_SOURCES]; struct perf start, stop; printf(xstr(FUNCTION_UNDER_TEST) ": %dx%d\n", TEST_SOURCES, TEST_LEN); // Allocate the arrays for (i = 0; i < TEST_SOURCES; i++) { if (posix_memalign(&buf, 64, TEST_LEN)) { printf("alloc error: Fail"); return -1; } buffs[i] = buf; } if (posix_memalign(&buf, 16, 6 * TEST_SOURCES * 32)) { printf("alloc error: Fail"); return -1; } g_tbls = buf; if (posix_memalign(&buf, 64, TEST_LEN)) { printf("alloc error: Fail"); return -1; } dest1 = buf; if (posix_memalign(&buf, 64, TEST_LEN)) { printf("alloc error: Fail"); return -1; } dest2 = buf; if (posix_memalign(&buf, 64, TEST_LEN)) { printf("alloc error: Fail"); return -1; } dest3 = buf; if (posix_memalign(&buf, 64, TEST_LEN)) { printf("alloc error: Fail"); return -1; } dest4 = buf; if (posix_memalign(&buf, 64, TEST_LEN)) { printf("alloc error: Fail"); return -1; } dest5 = buf; if (posix_memalign(&buf, 64, TEST_LEN)) { printf("alloc error: Fail"); return -1; } dest6 = buf; if (posix_memalign(&buf, 64, TEST_LEN)) { printf("alloc error: Fail"); return -1; } dest_ref1 = buf; if (posix_memalign(&buf, 64, TEST_LEN)) { printf("alloc error: Fail"); return -1; } dest_ref2 = buf; if (posix_memalign(&buf, 64, TEST_LEN)) { printf("alloc error: Fail"); return -1; } dest_ref3 = buf; if (posix_memalign(&buf, 64, TEST_LEN)) { printf("alloc error: Fail"); return -1; } dest_ref4 = buf; if (posix_memalign(&buf, 64, TEST_LEN)) { printf("alloc error: Fail"); return -1; } dest_ref5 = buf; if (posix_memalign(&buf, 64, TEST_LEN)) { printf("alloc error: Fail"); return -1; } dest_ref6 = buf; dest_ptrs[0] = dest1; dest_ptrs[1] = dest2; dest_ptrs[2] = dest3; dest_ptrs[3] = dest4; dest_ptrs[4] = dest5; dest_ptrs[5] = dest6; // Performance test for (i = 0; i < TEST_SOURCES; i++) for (j = 0; j < TEST_LEN; j++) buffs[i][j] = rand(); memset(dest1, 0, TEST_LEN); memset(dest2, 0, TEST_LEN); memset(dest3, 0, TEST_LEN); memset(dest4, 0, TEST_LEN); memset(dest5, 0, TEST_LEN); memset(dest6, 0, TEST_LEN); memset(dest_ref1, 0, TEST_LEN); memset(dest_ref2, 0, TEST_LEN); memset(dest_ref3, 0, TEST_LEN); memset(dest_ref4, 0, TEST_LEN); memset(dest_ref5, 0, TEST_LEN); memset(dest_ref6, 0, TEST_LEN); for (i = 0; i < TEST_SOURCES; i++) { g1[i] = rand(); g2[i] = rand(); g3[i] = rand(); g4[i] = rand(); g5[i] = rand(); g6[i] = rand(); } for (j = 0; j < TEST_SOURCES; j++) { gf_vect_mul_init(g1[j], &g_tbls[j * 32]); gf_vect_mul_init(g2[j], &g_tbls[(32 * TEST_SOURCES) + (j * 32)]); gf_vect_mul_init(g3[j], &g_tbls[(64 * TEST_SOURCES) + (j * 32)]); gf_vect_mul_init(g4[j], &g_tbls[(96 * TEST_SOURCES) + (j * 32)]); gf_vect_mul_init(g5[j], &g_tbls[(128 * TEST_SOURCES) + (j * 32)]); gf_vect_mul_init(g6[j], &g_tbls[(160 * TEST_SOURCES) + (j * 32)]); } gf_vect_dot_prod_base(TEST_LEN, TEST_SOURCES, &g_tbls[0], buffs, dest_ref1); gf_vect_dot_prod_base(TEST_LEN, TEST_SOURCES, &g_tbls[32 * TEST_SOURCES], buffs, dest_ref2); gf_vect_dot_prod_base(TEST_LEN, TEST_SOURCES, &g_tbls[64 * TEST_SOURCES], buffs, dest_ref3); gf_vect_dot_prod_base(TEST_LEN, TEST_SOURCES, &g_tbls[96 * TEST_SOURCES], buffs, dest_ref4); gf_vect_dot_prod_base(TEST_LEN, TEST_SOURCES, &g_tbls[128 * TEST_SOURCES], buffs, dest_ref5); gf_vect_dot_prod_base(TEST_LEN, TEST_SOURCES, &g_tbls[160 * TEST_SOURCES], buffs, dest_ref6); #ifdef DO_REF_PERF perf_start(&start); for (i = 0; i < TEST_LOOPS / 20; i++) { for (j = 0; j < TEST_SOURCES; j++) { gf_vect_mul_init(g1[j], &g_tbls[j * 32]); gf_vect_mul_init(g2[j], &g_tbls[(32 * TEST_SOURCES) + (j * 32)]); gf_vect_mul_init(g3[j], &g_tbls[(64 * TEST_SOURCES) + (j * 32)]); gf_vect_mul_init(g4[j], &g_tbls[(96 * TEST_SOURCES) + (j * 32)]); gf_vect_mul_init(g5[j], &g_tbls[(128 * TEST_SOURCES) + (j * 32)]); gf_vect_mul_init(g6[j], &g_tbls[(160 * TEST_SOURCES) + (j * 32)]); } gf_vect_dot_prod_base(TEST_LEN, TEST_SOURCES, &g_tbls[0], buffs, dest_ref1); gf_vect_dot_prod_base(TEST_LEN, TEST_SOURCES, &g_tbls[32 * TEST_SOURCES], buffs, dest_ref2); gf_vect_dot_prod_base(TEST_LEN, TEST_SOURCES, &g_tbls[64 * TEST_SOURCES], buffs, dest_ref3); gf_vect_dot_prod_base(TEST_LEN, TEST_SOURCES, &g_tbls[96 * TEST_SOURCES], buffs, dest_ref4); gf_vect_dot_prod_base(TEST_LEN, TEST_SOURCES, &g_tbls[128 * TEST_SOURCES], buffs, dest_ref5); gf_vect_dot_prod_base(TEST_LEN, TEST_SOURCES, &g_tbls[160 * TEST_SOURCES], buffs, dest_ref6); } perf_stop(&stop); printf("gf_6vect_dot_prod_base" TEST_TYPE_STR ": "); perf_print(stop, start, (long long)TEST_LEN * (TEST_SOURCES + 6) * i); #endif FUNCTION_UNDER_TEST(TEST_LEN, TEST_SOURCES, g_tbls, buffs, dest_ptrs); perf_start(&start); for (i = 0; i < TEST_LOOPS; i++) { for (j = 0; j < TEST_SOURCES; j++) { gf_vect_mul_init(g1[j], &g_tbls[j * 32]); gf_vect_mul_init(g2[j], &g_tbls[(32 * TEST_SOURCES) + (j * 32)]); gf_vect_mul_init(g3[j], &g_tbls[(64 * TEST_SOURCES) + (j * 32)]); gf_vect_mul_init(g4[j], &g_tbls[(96 * TEST_SOURCES) + (j * 32)]); gf_vect_mul_init(g5[j], &g_tbls[(128 * TEST_SOURCES) + (j * 32)]); gf_vect_mul_init(g6[j], &g_tbls[(160 * TEST_SOURCES) + (j * 32)]); } FUNCTION_UNDER_TEST(TEST_LEN, TEST_SOURCES, g_tbls, buffs, dest_ptrs); } perf_stop(&stop); printf(xstr(FUNCTION_UNDER_TEST) TEST_TYPE_STR ": "); perf_print(stop, start, (long long)TEST_LEN * (TEST_SOURCES + 6) * i); if (0 != memcmp(dest_ref1, dest1, TEST_LEN)) { printf("Fail perf " xstr(FUNCTION_UNDER_TEST) " test1\n"); dump_matrix(buffs, 5, TEST_SOURCES); printf("dprod_base:"); dump(dest_ref1, 25); printf("dprod_dut:"); dump(dest1, 25); return -1; } if (0 != memcmp(dest_ref2, dest2, TEST_LEN)) { printf("Fail perf " xstr(FUNCTION_UNDER_TEST) " test2\n"); dump_matrix(buffs, 5, TEST_SOURCES); printf("dprod_base:"); dump(dest_ref2, 25); printf("dprod_dut:"); dump(dest2, 25); return -1; } if (0 != memcmp(dest_ref3, dest3, TEST_LEN)) { printf("Fail perf " xstr(FUNCTION_UNDER_TEST) " test3\n"); dump_matrix(buffs, 5, TEST_SOURCES); printf("dprod_base:"); dump(dest_ref3, 25); printf("dprod_dut:"); dump(dest3, 25); return -1; } if (0 != memcmp(dest_ref4, dest4, TEST_LEN)) { printf("Fail perf " xstr(FUNCTION_UNDER_TEST) " test4\n"); dump_matrix(buffs, 5, TEST_SOURCES); printf("dprod_base:"); dump(dest_ref4, 25); printf("dprod_dut:"); dump(dest4, 25); return -1; } if (0 != memcmp(dest_ref5, dest5, TEST_LEN)) { printf("Fail perf " xstr(FUNCTION_UNDER_TEST) " test5\n"); dump_matrix(buffs, 5, TEST_SOURCES); printf("dprod_base:"); dump(dest_ref5, 25); printf("dprod_dut:"); dump(dest5, 25); return -1; } if (0 != memcmp(dest_ref6, dest6, TEST_LEN)) { printf("Fail perf " xstr(FUNCTION_UNDER_TEST) " test6\n"); dump_matrix(buffs, 5, TEST_SOURCES); printf("dprod_base:"); dump(dest_ref6, 25); printf("dprod_dut:"); dump(dest6, 25); return -1; } printf("pass perf check\n"); return 0; }
int main(int argc, char *argv[]) { int i, j, rtest, m, k, nerrs, r, err; void *buf; u8 *temp_buffs[TEST_SOURCES], *buffs[TEST_SOURCES]; u8 a[MMAX*KMAX], b[MMAX*KMAX], c[MMAX*KMAX], d[MMAX*KMAX]; u8 g_tbls[KMAX*TEST_SOURCES*32], src_in_err[TEST_SOURCES]; u8 src_err_list[TEST_SOURCES], *recov[TEST_SOURCES]; struct perf start, stop; m = 32; k = 28; printf("erasure_code_sse_perf: %dx%d ", m, (TEST_LEN(m))); // Allocate the arrays for(i=0; i<TEST_SOURCES; i++) { if (posix_memalign(&buf, 64, TEST_LEN(m))) { printf("alloc error: Fail"); return -1; } buffs[i] = buf; } for (i=0; i<TEST_SOURCES; i++) { if (posix_memalign(&buf, 64, TEST_LEN(m))) { printf("alloc error: Fail"); return -1; } temp_buffs[i] = buf; } // Test erasure code by encode and recovery // Pick a first test if (m > MMAX || k > KMAX) return -1; // Make random data for(i=0; i<k; i++) for(j=0; j<(TEST_LEN(m)); j++) buffs[i][j] = rand(); memset(src_in_err, 0, TEST_SOURCES); srand(1); for (i=0, nerrs=0; i<k && nerrs<m-k; i++) { err = 1 & rand(); src_in_err[i] = err; if (err) src_err_list[nerrs++] = i; } if (nerrs == 0) { // should have at least one error while ((err = (rand() % KMAX)) >= k) ; src_err_list[nerrs++] = err; src_in_err[err] = 1; } printf("Test erase list = "); for (i=0; i<nerrs; i++) printf(" %d", src_err_list[i]); printf("\n"); perf_start(&start); for (rtest = 0; rtest < TEST_LOOPS(m); rtest++) { gf_gen_rs_matrix(a, m, k); // Make parity vects ec_init_tables(k, m-k, &a[k*k], g_tbls); ec_encode_data_sse((TEST_LEN(m)), k, m-k, g_tbls, buffs, &buffs[k]); } perf_stop(&stop); printf("erasure_code_sse_encode" TEST_TYPE_STR ": "); perf_print(stop,start, (long long)(TEST_LEN(m))*(m)*rtest); perf_start(&start); for (rtest = 0; rtest < TEST_LOOPS(m); rtest++) { // Construct b by removing error rows for(i=0, r=0; i<k; i++, r++) { while (src_in_err[r]) r++; for(j=0; j<k; j++) b[k*i+j] = a[k*r+j]; } if (gf_invert_matrix(b, d, k) < 0) { printf("BAD MATRIX\n"); return -1; } for(i=0, r=0; i<k; i++, r++) { while (src_in_err[r]) r++; recov[i] = buffs[r]; } for(i=0; i<nerrs; i++) { for(j=0; j<k; j++) { c[k*i+j]=d[k*src_err_list[i]+j]; } } // Recover data ec_init_tables(k, nerrs, c, g_tbls); ec_encode_data_sse((TEST_LEN(m)), k, nerrs, g_tbls, recov, &temp_buffs[k]); } perf_stop(&stop); for(i=0; i<nerrs; i++) { if (0 != memcmp(temp_buffs[k+i], buffs[src_err_list[i]], (TEST_LEN(m)))) { printf("Fail error recovery (%d, %d, %d) - ", m, k, nerrs); printf(" - erase list = "); for (j=0; j<nerrs; j++) printf(" %d", src_err_list[j]); printf("\na:\n"); dump_u8xu8((u8*)a, m, k); printf("inv b:\n"); dump_u8xu8((u8*)d, k, k); printf("orig data:\n"); dump_matrix(buffs, m, 25); printf("orig :"); dump(buffs[src_err_list[i]],25); printf("recov %d:",src_err_list[i]); dump(temp_buffs[k+i], 25); return -1; } } printf("erasure_code_sse_decode" TEST_TYPE_STR ": "); perf_print(stop,start, (long long)(TEST_LEN(m))*(k+nerrs)*rtest); printf("done all: Pass\n"); return 0; }
int main(int argc, char *argv[]) { int i,j; void *buf; u8 g1[TEST_SOURCES], g2[TEST_SOURCES], g3[TEST_SOURCES]; u8 g_tbls[3*TEST_SOURCES*32], *dest_ptrs[3], *buffs[TEST_SOURCES]; u8 *dest1, *dest2, *dest3, *dest_ref1, *dest_ref2, *dest_ref3; struct perf start, stop; printf("gf_3vect_dot_prod_sse: %dx%d\n", TEST_SOURCES, TEST_LEN); mk_gf_field(); // Allocate the arrays for(i=0; i<TEST_SOURCES; i++){ if (posix_memalign(&buf, 64, TEST_LEN)) { printf("alloc error: Fail"); return -1; } buffs[i] = buf; } if (posix_memalign(&buf, 64, TEST_LEN)) { printf("alloc error: Fail"); return -1; } dest1 = buf; if (posix_memalign(&buf, 64, TEST_LEN)) { printf("alloc error: Fail"); return -1; } dest2 = buf; if (posix_memalign(&buf, 64, TEST_LEN)) { printf("alloc error: Fail"); return -1; } dest3 = buf; if (posix_memalign(&buf, 64, TEST_LEN)) { printf("alloc error: Fail"); return -1; } dest_ref1 = buf; if (posix_memalign(&buf, 64, TEST_LEN)) { printf("alloc error: Fail"); return -1; } dest_ref2 = buf; if (posix_memalign(&buf, 64, TEST_LEN)) { printf("alloc error: Fail"); return -1; } dest_ref3 = buf; dest_ptrs[0] = dest1; dest_ptrs[1] = dest2; dest_ptrs[2] = dest3; // Performance test for(i=0; i<TEST_SOURCES; i++) for(j=0; j<TEST_LEN; j++) buffs[i][j] = rand(); memset(dest1, 0, TEST_LEN); memset(dest2, 0, TEST_LEN); memset(dest_ref1, 0, TEST_LEN); memset(dest_ref2, 0, TEST_LEN); for (i=0; i<TEST_SOURCES; i++){ g1[i] = rand(); g2[i] = rand(); g3[i] = rand(); } for(j=0; j<TEST_SOURCES; j++){ gf_vect_mul_init(g1[j], &g_tbls[j*32]); gf_vect_mul_init(g2[j], &g_tbls[(32*TEST_SOURCES) + (j*32)]); gf_vect_mul_init(g3[j], &g_tbls[(64*TEST_SOURCES) + (j*32)]); } gf_vect_dot_prod_base(TEST_LEN, TEST_SOURCES, &g_tbls[0], buffs, dest_ref1); gf_vect_dot_prod_base(TEST_LEN, TEST_SOURCES, &g_tbls[32*TEST_SOURCES], buffs, dest_ref2); gf_vect_dot_prod_base(TEST_LEN, TEST_SOURCES, &g_tbls[64*TEST_SOURCES], buffs, dest_ref3); #ifdef DO_REF_PERF perf_start(&start); for (i=0; i<TEST_LOOPS/100; i++){ for (j=0; j<TEST_SOURCES; j++){ gf_vect_mul_init(g1[j], &g_tbls[j*32]); gf_vect_mul_init(g2[j], &g_tbls[(32*TEST_SOURCES) + (j*32)]); gf_vect_mul_init(g3[j], &g_tbls[(64*TEST_SOURCES) + (j*32)]); } gf_vect_dot_prod_base(TEST_LEN, TEST_SOURCES, &g_tbls[0], buffs, dest_ref1); gf_vect_dot_prod_base(TEST_LEN, TEST_SOURCES, &g_tbls[32*TEST_SOURCES], buffs, dest_ref2); gf_vect_dot_prod_base(TEST_LEN, TEST_SOURCES, &g_tbls[64*TEST_SOURCES], buffs, dest_ref3); } perf_stop(&stop); printf("gf_3vect_dot_prod_base" TEST_TYPE_STR ": "); perf_print(stop,start,(long long)TEST_LEN*(TEST_SOURCES+3)*i); #endif gf_3vect_dot_prod_sse(TEST_LEN, TEST_SOURCES, g_tbls, buffs, dest_ptrs); perf_start(&start); for (i=0; i<TEST_LOOPS; i++) { for (j=0; j<TEST_SOURCES; j++){ gf_vect_mul_init(g1[j], &g_tbls[j*32]); gf_vect_mul_init(g2[j], &g_tbls[(32*TEST_SOURCES) + (j*32)]); gf_vect_mul_init(g3[j], &g_tbls[(64*TEST_SOURCES) + (j*32)]); } gf_3vect_dot_prod_sse(TEST_LEN, TEST_SOURCES, g_tbls, buffs, dest_ptrs); } perf_stop(&stop); printf("gf_3vect_dot_prod_sse" TEST_TYPE_STR ": "); perf_print(stop,start, (long long)TEST_LEN*(TEST_SOURCES+3)*i); if (0 != memcmp(dest_ref1, dest1, TEST_LEN)){ printf("Fail perf vect_dot_prod_sse test1\n"); dump_matrix(buffs, 5, TEST_SOURCES); printf("dprod_base:"); dump(dest_ref1, 25); printf("dprod_sse:"); dump(dest1, 25); return -1; } if (0 != memcmp(dest_ref2, dest2, TEST_LEN)){ printf("Fail perf vect_dot_prod_sse test2\n"); dump_matrix(buffs, 5, TEST_SOURCES); printf("dprod_base:"); dump(dest_ref2, 25); printf("dprod_sse:"); dump(dest2, 25); return -1; } if (0 != memcmp(dest_ref3, dest3, TEST_LEN)){ printf("Fail perf vect_dot_prod_sse test3\n"); dump_matrix(buffs, 5, TEST_SOURCES); printf("dprod_base:"); dump(dest_ref3, 25); printf("dprod_sse:"); dump(dest3, 25); return -1; } printf("pass perf check\n"); return 0; }
int main(int argc, char *argv[]) { int i, j; void *buf; u8 g[TEST_SOURCES], g_tbls[TEST_SOURCES * 32], *dest, *dest_ref; u8 *temp_buff, *buffs[TEST_SOURCES]; struct perf start, stop; printf(xstr(FUNCTION_UNDER_TEST) ": %dx%d\n", TEST_SOURCES, TEST_LEN); // Allocate the arrays for (i = 0; i < TEST_SOURCES; i++) { if (posix_memalign(&buf, 64, TEST_LEN)) { printf("alloc error: Fail"); return -1; } buffs[i] = buf; } if (posix_memalign(&buf, 64, TEST_LEN)) { printf("alloc error: Fail"); return -1; } dest = buf; if (posix_memalign(&buf, 64, TEST_LEN)) { printf("alloc error: Fail"); return -1; } dest_ref = buf; if (posix_memalign(&buf, 64, TEST_LEN)) { printf("alloc error: Fail"); return -1; } temp_buff = buf; // Performance test for (i = 0; i < TEST_SOURCES; i++) for (j = 0; j < TEST_LEN; j++) buffs[i][j] = rand(); memset(dest, 0, TEST_LEN); memset(temp_buff, 0, TEST_LEN); memset(dest_ref, 0, TEST_LEN); memset(g, 0, TEST_SOURCES); for (i = 0; i < TEST_SOURCES; i++) g[i] = rand(); for (j = 0; j < TEST_SOURCES; j++) gf_vect_mul_init(g[j], &g_tbls[j * 32]); gf_vect_dot_prod_base(TEST_LEN, TEST_SOURCES, &g_tbls[0], buffs, dest_ref); #ifdef DO_REF_PERF perf_start(&start); for (i = 0; i < TEST_LOOPS; i++) { for (j = 0; j < TEST_SOURCES; j++) gf_vect_mul_init(g[j], &g_tbls[j * 32]); gf_vect_dot_prod_base(TEST_LEN, TEST_SOURCES, &g_tbls[0], buffs, dest_ref); } perf_stop(&stop); printf("gf_vect_dot_prod_base" TEST_TYPE_STR ": "); perf_print(stop, start, (long long)TEST_LEN * (TEST_SOURCES + 1) * i); #endif FUNCTION_UNDER_TEST(TEST_LEN, TEST_SOURCES, g_tbls, buffs, dest); perf_start(&start); for (i = 0; i < TEST_LOOPS; i++) { for (j = 0; j < TEST_SOURCES; j++) gf_vect_mul_init(g[j], &g_tbls[j * 32]); FUNCTION_UNDER_TEST(TEST_LEN, TEST_SOURCES, g_tbls, buffs, dest); } perf_stop(&stop); printf(xstr(FUNCTION_UNDER_TEST) TEST_TYPE_STR ": "); perf_print(stop, start, (long long)TEST_LEN * (TEST_SOURCES + 1) * i); if (0 != memcmp(dest_ref, dest, TEST_LEN)) { printf("Fail zero " xstr(FUNCTION_UNDER_TEST) " test\n"); dump_matrix(buffs, 5, TEST_SOURCES); printf("dprod_base:"); dump(dest_ref, 25); printf("dprod:"); dump(dest, 25); return -1; } printf("pass perf check\n"); return 0; }
int main(void) { MD5_HASH_CTX_MGR *mgr = NULL; MD5_HASH_CTX ctxpool[TEST_BUFS]; unsigned char *bufs[TEST_BUFS]; uint32_t i, j, t, fail = 0; struct perf start, stop; for (i = 0; i < TEST_BUFS; i++) { bufs[i] = (unsigned char *)calloc((size_t) TEST_LEN, 1); if (bufs[i] == NULL) { printf("calloc failed test aborted\n"); return 1; } // Init ctx contents hash_ctx_init(&ctxpool[i]); ctxpool[i].user_data = (void *)((uint64_t) i); } posix_memalign((void *)&mgr, 16, sizeof(MD5_HASH_CTX_MGR)); md5_ctx_mgr_init(mgr); // Start OpenSSL tests perf_start(&start); for (t = 0; t < TEST_LOOPS; t++) { for (i = 0; i < TEST_BUFS; i++) MD5(bufs[i], TEST_LEN, digest_ssl[i]); } perf_stop(&stop); printf("md5_openssl" TEST_TYPE_STR ": "); perf_print(stop, start, (long long)TEST_LEN * i * t); // Start mb tests perf_start(&start); for (t = 0; t < TEST_LOOPS; t++) { for (i = 0; i < TEST_BUFS; i++) md5_ctx_mgr_submit(mgr, &ctxpool[i], bufs[i], TEST_LEN, HASH_ENTIRE); while (md5_ctx_mgr_flush(mgr)) ; } perf_stop(&stop); printf("multibinary_md5" TEST_TYPE_STR ": "); perf_print(stop, start, (long long)TEST_LEN * i * t); for (i = 0; i < TEST_BUFS; i++) { for (j = 0; j < MD5_DIGEST_NWORDS; j++) { if (ctxpool[i].job.result_digest[j] != ((uint32_t *) digest_ssl[i])[j]) { fail++; printf("Test%d, digest%d fail %08X <=> %08X\n", i, j, ctxpool[i].job.result_digest[j], ((uint32_t *) digest_ssl[i])[j]); } } } printf("Multi-buffer md5 test complete %d buffers of %d B with " "%d iterations\n", TEST_BUFS, TEST_LEN, TEST_LOOPS); if (fail) printf("Test failed function check %d\n", fail); else printf(" multibinary_md5_ossl_perf: Pass\n"); return fail; }