int main(void)
{
vbx_test_init();
vbx_mxp_t *this_mxp = VBX_GET_THIS_MXP();
const int VBX_SCRATCHPAD_SIZE = this_mxp->scratchpad_size;
const int required_vectors = 4;
int N = VBX_SCRATCHPAD_SIZE / sizeof(vbx_mm_t) / required_vectors;
int PRINT_LENGTH = min( N, MAX_PRINT_LENGTH );
double scalar_time, vector_time;
int errors=0;
vbx_mxp_print_params();
printf( "\nAdd test...\n" );
printf( "Vector length: %d\n", N );
vbx_mm_t *scalar_in1 = malloc( N*sizeof(vbx_mm_t) );
vbx_mm_t *scalar_in2 = malloc( N*sizeof(vbx_mm_t) );
vbx_mm_t *scalar_out = malloc( N*sizeof(vbx_mm_t) );
vbx_mm_t *vector_in1 = vbx_shared_malloc( N*sizeof(vbx_mm_t) );
vbx_mm_t *vector_in2 = vbx_shared_malloc( N*sizeof(vbx_mm_t) );
vbx_mm_t *vector_out = vbx_shared_malloc( N*sizeof(vbx_mm_t) );
// vbx_mm_t *vector_out = vector_in2 - 5;
vbx_sp_t *v_in1 = vbx_sp_malloc( N*sizeof(vbx_sp_t) );
vbx_sp_t *v_in2 = vbx_sp_malloc( N*sizeof(vbx_sp_t) );
vbx_sp_t *v_out = vbx_sp_malloc( N*sizeof(vbx_sp_t) );
// vbx_sp_t *v_out = v_in2-5;
VBX_T(test_zero_array)( scalar_out, N );
VBX_T(test_zero_array)( vector_out, N );
VBX_T(test_init_array)( scalar_in1, N, 1 );
VBX_T(test_copy_array)( vector_in1, scalar_in1, N );
VBX_T(test_init_array)( scalar_in2, N, 1 );
VBX_T(test_copy_array)( vector_in2, scalar_in2, N );
VBX_T(test_print_array)( scalar_in1, PRINT_LENGTH );
VBX_T(test_print_array)( scalar_in2, PRINT_LENGTH );
scalar_time = test_scalar( scalar_out, scalar_in1, scalar_in2, N );
VBX_T(test_print_array)( scalar_out, PRINT_LENGTH);
vbx_dma_to_vector( v_in1, (void *)vector_in1, N*sizeof(vbx_sp_t) );
vbx_dma_to_vector( v_in2, (void *)vector_in1, N*sizeof(vbx_sp_t) );
vector_time = test_vector( v_out, v_in1, v_in2, N, scalar_time );
vbx_dma_to_host( (void *)vector_out, v_out, N*sizeof(vbx_sp_t) );
vbx_sync();
VBX_T(test_print_array)( vector_out, PRINT_LENGTH );
errors += VBX_T(test_verify_array)( scalar_out, vector_out, N );
VBX_TEST_END(errors);
return 0;
}
int main(void)
{
vbx_test_init();
vbx_mxp_print_params();
int errors=0;
unsigned instr_cycles,instr_count, dma_cycles,dma_count;
vbx_mxp_t *this_mxp = VBX_GET_THIS_MXP();
int lanes= this_mxp->vector_lanes;
int dma_width=this_mxp->dma_alignment_bytes /4;
debug(lanes);
debug(dma_width);
vbx_set_vl(-1);
VBX_COUNTER_RESET();
vbx(SVW,VMOV,0,0,0);
vbx_sync();
if(VBX_SIMULATOR)
printf("simulator\n");
else
printf("not simulator\n");
instr_cycles=VBX_GET_WRITEBACK_CYCLES();
dma_cycles=VBX_GET_DMA_CYCLES();
dma_count=VBX_GET_DMAS();
instr_count=VBX_GET_INSTRUCTIONS();
debug(instr_cycles);
debug(dma_cycles);
debug(dma_count);
debug(instr_count );
VBX_TEST_END(errors);
return 0;
}
int dma_bandwidth_test()
{
const int num_iter = 64;
vbx_mxp_t *this_mxp = VBX_GET_THIS_MXP();
int scratchpad_size = this_mxp->scratchpad_size;
uint8_t *buf = vbx_shared_malloc(scratchpad_size);
vbx_ubyte_t *v_buf = vbx_sp_malloc(scratchpad_size);
vbx_timestamp_t time_start, time_stop;
int i;
int len;
int to_host;
int errors = 0;
vbx_mxp_print_params();
// dma_alignment_bytes gives DMA master data bus width in bytes.
double bytes_per_sec = \
(((double) this_mxp->core_freq) * this_mxp->dma_alignment_bytes);
double max_megabytes_per_sec = bytes_per_sec/(1024*1024);
printf("\nMax available bandwidth = %s Megabytes/s\n",
vbx_eng(max_megabytes_per_sec, 4));
printf("\n");
for (to_host = 0; to_host < 2; to_host++) {
for (len = 32; len <= scratchpad_size ; len *= 2) {
printf("DMA %s, %d bytes\n", to_host ? "write" : "read", len);
vbx_timestamp_start();
if (to_host) {
time_start = vbx_timestamp();
for (i = 0; i < num_iter; i++) {
vbx_dma_to_host(buf, v_buf, len);
}
vbx_sync();
time_stop = vbx_timestamp();
} else {
time_start = vbx_timestamp();
for (i = 0; i < num_iter; i++) {
vbx_dma_to_vector(v_buf, buf, len);
}
vbx_sync();
time_stop = vbx_timestamp();
}
print_dma_bandwidth(time_start, time_stop, len, num_iter,
max_megabytes_per_sec);
printf("\n");
}
printf("\n");
}
vbx_shared_free(buf);
vbx_sp_free();
return errors;
}
int main(void)
{
double scalar_time, vector_time;
int errors=0;
vbx_test_init();
vbx_mxp_print_params();
printf("\nVector FIR test...\n");
vbx_mm_t *scalar_sample = malloc( (SAMP_SIZE+NTAPS)*sizeof(vbx_mm_t) );
vbx_mm_t *scalar_coeffs = malloc( NTAPS*sizeof(vbx_mm_t) );
vbx_mm_t *scalar_out = malloc( SAMP_SIZE*sizeof(vbx_mm_t) );
vbx_mm_t *sample = vbx_shared_malloc( (SAMP_SIZE+NTAPS)*sizeof(vbx_mm_t) );
vbx_mm_t *coeffs = vbx_shared_malloc( NTAPS*sizeof(vbx_mm_t) );
vbx_mm_t *vector_out = vbx_shared_malloc( SAMP_SIZE*sizeof(vbx_mm_t) );
VBX_T(test_zero_array)( scalar_out, SAMP_SIZE );
VBX_T(test_zero_array)( vector_out, SAMP_SIZE );
VBX_T(test_init_array)( scalar_sample, SAMP_SIZE, 0xff );
VBX_T(test_copy_array)( sample, scalar_sample, SAMP_SIZE );
VBX_T(test_init_array)( scalar_coeffs, NTAPS, 1 );
VBX_T(test_copy_array)( coeffs, scalar_coeffs, NTAPS );
VBX_T(test_zero_array)( scalar_sample+SAMP_SIZE, NTAPS );
VBX_T(test_zero_array)( sample+SAMP_SIZE, NTAPS );
printf("\nSamples:\n");
VBX_T(test_print_array)( scalar_sample, min(SAMP_SIZE,MAX_PRINT_LENGTH) );
printf("\nCoefficients:\n");
VBX_T(test_print_array)( scalar_coeffs, min(NTAPS,MAX_PRINT_LENGTH) );
scalar_time = test_scalar( scalar_out, scalar_sample, scalar_coeffs);
VBX_T(test_print_array)( scalar_out, min(SAMP_SIZE,MAX_PRINT_LENGTH) );
#ifdef USE_TRANSPOSE
vector_time = test_vector_transpose( vector_out, sample, coeffs, scalar_time );
VBX_T(test_print_array)( vector_out, min(SAMP_SIZE,MAX_PRINT_LENGTH) );
errors += VBX_T(test_verify_array)( scalar_out, vector_out, SAMP_SIZE-NTAPS );
#endif //USE_TRANSPOSE
#ifdef USE_1D
vector_time = test_vector_1d( vector_out, sample, coeffs, scalar_time );
VBX_T(test_print_array)( vector_out, min(SAMP_SIZE,MAX_PRINT_LENGTH) );
errors += VBX_T(test_verify_array)( scalar_out, vector_out, SAMP_SIZE-NTAPS );
#endif //USE_1D
#ifdef USE_2D
vector_time = test_vector_2d( vector_out, sample, coeffs, scalar_time );
VBX_T(test_print_array)( vector_out, min(SAMP_SIZE,MAX_PRINT_LENGTH) );
errors += VBX_T(test_verify_array)( scalar_out, vector_out, SAMP_SIZE-NTAPS );
#endif //USE_2D
VBX_TEST_END(errors);
return 0;
}
int main(void)
{
vbx_test_init();
vbx_mxp_t *this_mxp = VBX_GET_THIS_MXP();
const int VBX_SCRATCHPAD_SIZE = this_mxp->scratchpad_size;
int N = VBX_SCRATCHPAD_SIZE/sizeof(vbx_word_t)/12;
N=1024;
int PRINT_LENGTH = min(N, MAX_PRINT_LENGTH);
double scalar_time, vector_time;
int errors=0;
vbx_mxp_print_params();
printf("\nVector power test...\n");
printf("Vector length: %d\n", N);
vbx_word_t *scalar_in1 = malloc( N*sizeof(vbx_word_t) );
vbx_word_t *scalar_in2 = malloc( N*sizeof(vbx_word_t) );
vbx_word_t *scalar_out = malloc( N*sizeof(vbx_word_t) );
vbx_word_t *vector_in1 = vbx_shared_malloc( N*sizeof(vbx_word_t) );
vbx_word_t *vector_in2 = vbx_shared_malloc( N*sizeof(vbx_word_t) );
vbx_word_t *vector_out = vbx_shared_malloc( N*sizeof(vbx_word_t) );
if(vector_out==NULL){
printf("malloc_failed\n");
return 1;
}
test_zero_array_word( scalar_out, N );
test_zero_array_word( vector_out, N );
test_init_array_word( scalar_in1, N, 5 );
test_copy_array_word( vector_in1, scalar_in1, N );
test_init_array_word( scalar_in2, N, 112 );
test_copy_array_word( vector_in2, scalar_in2, N );
test_print_array_word( scalar_in1, PRINT_LENGTH );
test_print_array_word( scalar_in2, PRINT_LENGTH );
scalar_time = test_scalar_power( scalar_out, scalar_in1, scalar_in2, N);
test_print_array_word( scalar_out, PRINT_LENGTH );
vector_time = test_vector_power( vector_out, vector_in1, vector_in2, N, scalar_time );
test_print_array_word( vector_out, PRINT_LENGTH );
errors += test_verify_array_word( scalar_out, vector_out, N );
VBX_TEST_END(errors);
return 0;
}
int main(void)
{
vbx_timestamp_t time_start, time_stop;
double scalar_time, vbx_time, vbx_time_masked;
int i, j, k, l, m, n;
int errors = 0;
vbx_test_init();
vbx_mxp_print_params();
pixel *input, *scalar_input, *vbx_input, *vbx_input_masked;
uint16_t *scalar_short;
input = (pixel *)vbx_shared_malloc(IMAGE_WIDTH*IMAGE_HEIGHT*sizeof(pixel));
scalar_input = (pixel *)vbx_remap_cached(input, IMAGE_WIDTH*IMAGE_HEIGHT*sizeof(pixel));
scalar_short = (uint16_t *)malloc(IMAGE_WIDTH*IMAGE_HEIGHT*sizeof(uint16_t));
vbx_input = (pixel *)vbx_shared_malloc(IMAGE_WIDTH*IMAGE_HEIGHT*sizeof(pixel));
vbx_input_masked = (pixel *)vbx_shared_malloc(IMAGE_WIDTH*IMAGE_HEIGHT*sizeof(pixel));
#if UNIT
unsigned char *vbx_img8;
unsigned short *img, *vbx_img;
unsigned int *iImg, *vbx_iImg;
unsigned int *iiImg, *vbx_iiImg;
img = (unsigned short*)malloc(IMAGE_WIDTH*IMAGE_HEIGHT*sizeof(unsigned short));
vbx_img = (unsigned short*)vbx_shared_malloc(IMAGE_WIDTH*IMAGE_HEIGHT*sizeof(unsigned short));
vbx_img8 = (unsigned char*)vbx_shared_malloc(IMAGE_WIDTH*IMAGE_HEIGHT*sizeof(unsigned char));
iImg = (unsigned int*)malloc(IMAGE_WIDTH*IMAGE_HEIGHT*sizeof(unsigned int));
vbx_iImg = (unsigned int*)vbx_shared_malloc(IMAGE_WIDTH*IMAGE_HEIGHT*sizeof(unsigned int));
iiImg = (unsigned int*)malloc(IMAGE_WIDTH*IMAGE_HEIGHT*sizeof(unsigned int));
vbx_iiImg = (unsigned int*)vbx_shared_malloc(IMAGE_WIDTH*IMAGE_HEIGHT*sizeof(unsigned int));
#endif//UNIT
printf("Resolution = %dx%d\n", IMAGE_WIDTH, IMAGE_HEIGHT);
printf("Initializing data\n");
vbx_timestamp_start();
for(l = 0; l < 1; l++){
char *src;
char *sdst;
char *vdst;
char *mdst;
if(l == 0){
load_lenna(input, IMAGE_WIDTH, IMAGE_HEIGHT);
load_lenna(vbx_input, IMAGE_WIDTH, IMAGE_HEIGHT);
load_lenna(vbx_input_masked, IMAGE_WIDTH, IMAGE_HEIGHT);
printf("\nLenna\n");
src = "lenna";
sdst = "s_lenna";
vdst = "v_lenna";
mdst = "m_lenna";
}else if(l == 1){
load_ms(input, IMAGE_WIDTH, IMAGE_HEIGHT);
load_ms(vbx_input, IMAGE_WIDTH, IMAGE_HEIGHT);
load_ms(vbx_input_masked, IMAGE_WIDTH, IMAGE_HEIGHT);
printf("\nMicrosoft\n");
src = "ms";
sdst = "s_ms";
vdst = "v_ms";
mdst = "m_ms";
}else if(l == 2){
load_blank(input, IMAGE_WIDTH, IMAGE_HEIGHT);
load_blank(vbx_input, IMAGE_WIDTH, IMAGE_HEIGHT);
load_blank(vbx_input_masked, IMAGE_WIDTH, IMAGE_HEIGHT);
printf("\nblank\n");
src = "blank";
sdst = "s_blank";
vdst = "v_blank";
mdst = "m_blank";
}
#if UNIT
int window = 20;
int log=0;
while(((window/3)>>log) >= 2) log++;
errors += compare_scalar_rgb2luma_to_vbw_rgb2luma16(img, vbx_img, vbx_input, IMAGE_WIDTH, IMAGE_HEIGHT, IMAGE_WIDTH, MAX_PRINT_ERRORS);
vbw_rgb2luma8(vbx_img8, vbx_input, IMAGE_WIDTH, IMAGE_HEIGHT, IMAGE_WIDTH);
int s;
#if LUT_CI
#if DOUBLE_LUT
printf("Testing double lut\n");
printf("Assign lbp double lut\n");
assign_lbp_lut_ci2();
int prev = errors;
printf("Cascade check\n");
/* errors += cascade_check_2w(face_lbp, face_lbp_max_stage, 256); */
/* errors += cascade_check_2h(face_lbp, face_lbp_max_stage, 256); */
errors += cascade_check_2b(face_lbp, face_lbp_max_stage, 256);
if (errors) {
printf("errors %d\n", errors-prev);
}
#else
assign_lbp_lut_ci();
printf("Testing cascade\n");
int prev = errors;
printf("lut check\n");
#if 0
#if 0
errors += lut_check(256, 0, 0, 0);
if (errors) {
printf("errors %d\n", errors-prev);
}
#elif 1
int print_errors = 0;
vbx_mxp_t *this_mxp = VBX_GET_THIS_MXP();
int vci_lanes = this_mxp->vcustom0_lanes;
int num_features = cascade_max_feature();
int input_length = 10;
int lut_length = num_features*vci_lanes;
int lut_iterations = 15;
#if 1
lut_length = input_length = 128;
lut_iterations = 13;
print_errors = 0;
errors += lut_check2(input_length, lut_length, lut_iterations, print_errors);
if (errors) {
printf("errors %d\n", errors-prev);
}
#elif 1
input_length = 64;
lut_length = input_length;
lut_iterations = 13;
print_errors = 1;
errors += lut_check2(input_length, lut_length, lut_iterations, print_errors);
if (errors) {
printf("errors %d\n", errors-prev);
}
#else
for(s = 2; s < 100; s=s+10){
errors += lut_check2(s, lut_length, lut_iterations, print_errors);
if (errors - prev > 0) {
printf("%d\terrors %d\n", s, errors-prev);
} else {
printf("%d\n", s);
}
prev = errors;
}
#endif
#else
for(s = 0; s < 2000; s=s+100){
errors += lut_check(s, 0, 0, 0);
if (errors - prev > 0) {
printf("%d\terrors %d\n", s, errors-prev);
} else {
printf("%d\n", s);
}
prev = errors;
}
#endif
#elif 1
#else
printf("check cascade\n");
prev = errors;
errors += cascade_check(face_lbp, face_lbp_max_stage, 256);
if (errors) {
printf("errors %d\n", errors-prev);
}
printf("Testing LBP LUT CI\n");
prev = errors;
for(s = 0; s < face_lbp_max_stage; s++){
errors += compare_vbx_lut_to_vbx_lut_ci(s, MAX_PRINT_ERRORS);
}
if (errors) {
printf("errors %d\n", errors-prev);
prev = errors;
}
#endif
#endif
#endif
#if 0
printf("Printing grey scale img\n");
printf("grey = [");
for (j = 0; j < IMAGE_HEIGHT; j++) {
printf("[");
for (i = 0; i < IMAGE_WIDTH; i++) {
printf("%d, ", vbx_img8[j*IMAGE_WIDTH+i]);
}
printf("],\n");
}
printf("]\n");
#endif
#if LBP_CI
printf("Testing LBP Pattern CI\n");
errors += compare_LBPRestrictedCI_to_test_scalar_patterns(vbx_img, vbx_img8, log, IMAGE_WIDTH, IMAGE_HEIGHT, MAX_PRINT_ERRORS);
#endif
#if BLIP
printf("Testing BLIP\n");
for(s = 1; s < 10; s++){
errors += compare_scalar_BLIP2_to_vector_BLIP(img, vbx_input, IMAGE_WIDTH, IMAGE_HEIGHT, MAX_PRINT_ERRORS, s);
}
#endif
#if 0
errors += compare_LBPRestrictedSums_to_test_scalar_sums_byte(vbx_img, log, IMAGE_WIDTH, IMAGE_HEIGHT, MAX_PRINT_ERRORS);
errors += compare_LBPRestrictedSums2_to_test_scalar_sums_half(vbx_img, log, IMAGE_WIDTH, IMAGE_HEIGHT, MAX_PRINT_ERRORS);
errors += compare_ScalarLBPRestrictedSums_to_test_scalar_sums_half(vbx_img, log, IMAGE_WIDTH, IMAGE_HEIGHT, MAX_PRINT_ERRORS);
errors += compare_ScalarLBPRestrictedPatterns_to_test_scalar_patterns(vbx_img, log, IMAGE_WIDTH, IMAGE_HEIGHT, MAX_PRINT_ERRORS);
errors += compare_LBPRestrictedPatterns2_to_test_scalar_patterns(vbx_img, log, IMAGE_WIDTH, IMAGE_HEIGHT, MAX_PRINT_ERRORS);
errors += compare_LBPRestricted_to_test_scalar_patterns(vbx_img, log, IMAGE_WIDTH, IMAGE_HEIGHT, MAX_PRINT_ERRORS);
/* overflow issues -- using bytes changes lbp pattern */
errors += compare_LBPRestrictedPatterns_to_test_scalar_patterns(vbx_img, log, IMAGE_WIDTH, IMAGE_HEIGHT, MAX_PRINT_ERRORS);
/* requires SKIP_INTEGRALS 0 */
errors += compare_gen_integrals_to_vector_get_img(img, iImg, iiImg, vbx_img, vbx_iImg, vbx_iiImg, vbx_input, IMAGE_WIDTH, IMAGE_HEIGHT, MAX_PRINT_ERRORS);
/* redundant test, compare to test_scalar_patterns instead */
errors += compare_ScalarLBPRestrictedPatterns_to_SATBinaryPattern(vbx_img, log, IMAGE_WIDTH, IMAGE_HEIGHT, MAX_PRINT_ERRORS);
errors += compare_SATBinaryPattern_to_test_scalar_patterns(vbx_img, log, IMAGE_WIDTH, IMAGE_HEIGHT, MAX_PRINT_ERRORS);
errors += compare_LBPPassStage_to_restricted(vbx_img, log, face_lbp[0], window, IMAGE_WIDTH, IMAGE_HEIGHT, MAX_PRINT_ERRORS);
#endif
#else // UNIT
#if PRINT
print_python_pixel(scalar_input, src, IMAGE_WIDTH, IMAGE_HEIGHT);
#endif
time_start = vbx_timestamp();
scalar_rgb2luma(scalar_short, input, IMAGE_WIDTH, IMAGE_HEIGHT, IMAGE_WIDTH);
scalar_face_detect_luma(scalar_short, input, IMAGE_WIDTH, IMAGE_HEIGHT, IMAGE_WIDTH, sdst);
time_stop = vbx_timestamp();
scalar_time = vbx_print_scalar_time(time_start, time_stop);
#if PRINT
print_python_pixel(scalar_input, sdst, IMAGE_WIDTH, IMAGE_HEIGHT);
#endif
printf("\nVector");
time_start = vbx_timestamp();
vector_face_detect((pixel *)vbx_input, IMAGE_WIDTH, IMAGE_HEIGHT, IMAGE_WIDTH, 0, vdst);
time_stop = vbx_timestamp();
vbx_time = vbx_print_vector_time(time_start, time_stop, scalar_time);
#if PRINT
print_python_pixel(vbx_input, vdst, IMAGE_WIDTH, IMAGE_HEIGHT);
#endif
printf("\nVector Masked");
time_start = vbx_timestamp();
vector_face_detect((pixel *)vbx_input_masked, IMAGE_WIDTH, IMAGE_HEIGHT, IMAGE_WIDTH, 1, mdst);
time_stop = vbx_timestamp();
vbx_time_masked = vbx_print_vector_time(time_start, time_stop, scalar_time);
#if PRINT
print_python_pixel(vbx_input_masked, mdst, IMAGE_WIDTH, IMAGE_HEIGHT);
#endif
/* errors += match_array_pixel(input, vbx_input, "vector", IMAGE_WIDTH, IMAGE_HEIGHT, 0, MAX_PRINT_ERRORS, 0); */
/* errors += match_array_pixel(input, vbx_input_masked, "masked", IMAGE_WIDTH, IMAGE_HEIGHT, 0, MAX_PRINT_ERRORS, 0); */
errors += match_array_pixel(vbx_input, vbx_input_masked, "masked", IMAGE_WIDTH, IMAGE_HEIGHT, 0, MAX_PRINT_ERRORS, 0);
#endif // UNIT
}
VBX_TEST_END(errors);
return errors;
}
int main(void)
{
vbx_timestamp_t time_start, time_stop;
double scalar_time, vbx_time, vbx_time_masked;
int i, j, k, l, m, n;
int errors = 0;
vbx_test_init();
vbx_mxp_print_params();
pixel *input, *scalar_input, *vbx_input, *vbx_input_masked;
uint16_t *scalar_short;
input = (pixel *)vbx_shared_malloc(IMAGE_WIDTH*IMAGE_HEIGHT*sizeof(pixel));
scalar_input = (pixel *)vbx_remap_cached(input, IMAGE_WIDTH*IMAGE_HEIGHT*sizeof(pixel));
scalar_short = (uint16_t *)malloc(IMAGE_WIDTH*IMAGE_HEIGHT*sizeof(uint16_t));
vbx_input = (pixel *)vbx_shared_malloc(IMAGE_WIDTH*IMAGE_HEIGHT*sizeof(pixel));
vbx_input_masked = (pixel *)vbx_shared_malloc(IMAGE_WIDTH*IMAGE_HEIGHT*sizeof(pixel));
#if UNIT
unsigned short *img, *vbx_img;
unsigned int *iImg, *vbx_iImg;
unsigned int *iiImg, *vbx_iiImg;
img = (unsigned short*)malloc(IMAGE_WIDTH*IMAGE_HEIGHT*sizeof(unsigned short));
vbx_img = (unsigned short*)vbx_shared_malloc(IMAGE_WIDTH*IMAGE_HEIGHT*sizeof(unsigned short));
iImg = (unsigned int*)malloc(IMAGE_WIDTH*IMAGE_HEIGHT*sizeof(unsigned int));
vbx_iImg = (unsigned int*)vbx_shared_malloc(IMAGE_WIDTH*IMAGE_HEIGHT*sizeof(unsigned int));
iiImg = (unsigned int*)malloc(IMAGE_WIDTH*IMAGE_HEIGHT*sizeof(unsigned int));
vbx_iiImg = (unsigned int*)vbx_shared_malloc(IMAGE_WIDTH*IMAGE_HEIGHT*sizeof(unsigned int));
#endif//UNIT
printf("Resolution = %dx%d\n", IMAGE_WIDTH, IMAGE_HEIGHT);
printf("Initializing data\n");
vbx_timestamp_start();
for(l = 0; l < 1; l++){
char *src;
char *sdst;
char *vdst;
char *mdst;
if(l == 0){
load_lenna(input, IMAGE_WIDTH, IMAGE_HEIGHT);
load_lenna(vbx_input, IMAGE_WIDTH, IMAGE_HEIGHT);
load_lenna(vbx_input_masked, IMAGE_WIDTH, IMAGE_HEIGHT);
printf("\nLenna\n");
src = "lenna";
sdst = "s_lenna";
vdst = "v_lenna";
mdst = "m_lenna";
}else if(l == 1){
load_ms(input, IMAGE_WIDTH, IMAGE_HEIGHT);
load_ms(vbx_input, IMAGE_WIDTH, IMAGE_HEIGHT);
load_ms(vbx_input_masked, IMAGE_WIDTH, IMAGE_HEIGHT);
printf("\nMicrosoft\n");
src = "ms";
sdst = "s_ms";
vdst = "v_ms";
mdst = "m_ms";
}else if(l == 2){
load_blank(input, IMAGE_WIDTH, IMAGE_HEIGHT);
load_blank(vbx_input, IMAGE_WIDTH, IMAGE_HEIGHT);
load_blank(vbx_input_masked, IMAGE_WIDTH, IMAGE_HEIGHT);
printf("\nblank\n");
src = "blank";
sdst = "s_blank";
vdst = "v_blank";
mdst = "m_blank";
}
#if UNIT
int window = 20;
int log=0;
while(((window/3)>>log) >= 2) log++;
#if LUT_CI
/* errors += compare_vbx_lut_to_vbx_lut_ci(1024, MAX_PRINT_ERRORS); */
#endif
#if LBP_CI
errors += compare_vbx_lbp_ci_to_scalar_patterns(vbx_img, IMAGE_WIDTH, IMAGE_HEIGHT, MAX_PRINT_ERRORS);
#endif
errors += compare_scalar_rgb2luma_to_vbw_rgb2luma16(img, vbx_img, vbx_input, IMAGE_WIDTH, IMAGE_HEIGHT, IMAGE_WIDTH, MAX_PRINT_ERRORS);
/* errors += compare_LBPRestrictedSums_to_test_scalar_sums_byte(vbx_img, log, IMAGE_WIDTH, IMAGE_HEIGHT, MAX_PRINT_ERRORS); */
/* errors += compare_LBPRestrictedSums2_to_test_scalar_sums_half(vbx_img, log, IMAGE_WIDTH, IMAGE_HEIGHT, MAX_PRINT_ERRORS); */
/* errors += compare_ScalarLBPRestrictedSums_to_test_scalar_sums_half(vbx_img, log, IMAGE_WIDTH, IMAGE_HEIGHT, MAX_PRINT_ERRORS); */
/* errors += compare_ScalarLBPRestrictedPatterns_to_test_scalar_patterns(vbx_img, log, IMAGE_WIDTH, IMAGE_HEIGHT, MAX_PRINT_ERRORS); */
/* errors += compare_LBPRestrictedPatterns2_to_test_scalar_patterns(vbx_img, log, IMAGE_WIDTH, IMAGE_HEIGHT, MAX_PRINT_ERRORS); */
errors += compare_LBPRestricted_to_test_scalar_patterns(vbx_img, log, IMAGE_WIDTH, IMAGE_HEIGHT, MAX_PRINT_ERRORS);
#if 0
/* overflow issues -- using bytes changes lbp pattern */
errors += compare_LBPRestrictedPatterns_to_test_scalar_patterns(vbx_img, log, IMAGE_WIDTH, IMAGE_HEIGHT, MAX_PRINT_ERRORS);
/* requires SKIP_INTEGRALS 0 */
errors += compare_gen_integrals_to_vector_get_img(img, iImg, iiImg, vbx_img, vbx_iImg, vbx_iiImg, vbx_input, IMAGE_WIDTH, IMAGE_HEIGHT, MAX_PRINT_ERRORS);
/* currently last values have errors if the scaled images size is not an integer, width * f/ (f+1) */
errors += compare_scalar_BLIP2_to_vector_BLIP(img, vbx_input, IMAGE_WIDTH, IMAGE_HEIGHT, MAX_PRINT_ERRORS);
/* redundant test, compare to test_scalar_patterns instead */
errors += compare_ScalarLBPRestrictedPatterns_to_SATBinaryPattern(vbx_img, log, IMAGE_WIDTH, IMAGE_HEIGHT, MAX_PRINT_ERRORS);
errors += compare_SATBinaryPattern_to_test_scalar_patterns(vbx_img, log, IMAGE_WIDTH, IMAGE_HEIGHT, MAX_PRINT_ERRORS);
#endif
errors += compare_LBPPassStage_to_restricted(vbx_img, log, face_lbp[0], window, IMAGE_WIDTH, IMAGE_HEIGHT, MAX_PRINT_ERRORS);
#else // UNIT
#if PRINT
print_python_pixel(scalar_input, src, IMAGE_WIDTH, IMAGE_HEIGHT);
#endif
time_start = vbx_timestamp();
scalar_rgb2luma(scalar_short, input, IMAGE_WIDTH, IMAGE_HEIGHT, IMAGE_WIDTH);
scalar_face_detect_luma(scalar_short, input, IMAGE_WIDTH, IMAGE_HEIGHT, IMAGE_WIDTH, sdst);
time_stop = vbx_timestamp();
scalar_time = vbx_print_scalar_time(time_start, time_stop);
#if PRINT
print_python_pixel(scalar_input, sdst, IMAGE_WIDTH, IMAGE_HEIGHT);
#endif
printf("\nVector");
time_start = vbx_timestamp();
vector_face_detect((pixel *)vbx_input, IMAGE_WIDTH, IMAGE_HEIGHT, IMAGE_WIDTH, 0, vdst);
time_stop = vbx_timestamp();
vbx_time = vbx_print_vector_time(time_start, time_stop, scalar_time);
#if PRINT
print_python_pixel(vbx_input, vdst, IMAGE_WIDTH, IMAGE_HEIGHT);
#endif
printf("\nVector Masked");
time_start = vbx_timestamp();
vector_face_detect((pixel *)vbx_input_masked, IMAGE_WIDTH, IMAGE_HEIGHT, IMAGE_WIDTH, 1, mdst);
time_stop = vbx_timestamp();
vbx_time_masked = vbx_print_vector_time(time_start, time_stop, scalar_time);
#if PRINT
print_python_pixel(vbx_input_masked, mdst, IMAGE_WIDTH, IMAGE_HEIGHT);
#endif
/* errors += match_array_pixel(input, vbx_input, "vector", IMAGE_WIDTH, IMAGE_HEIGHT, MAX_PRINT_ERRORS, 0); */
/* errors += match_array_pixel(input, vbx_input_masked, "masked", IMAGE_WIDTH, IMAGE_HEIGHT, MAX_PRINT_ERRORS, 0); */
errors += match_array_pixel(vbx_input, vbx_input_masked, "masked", IMAGE_WIDTH, IMAGE_HEIGHT, MAX_PRINT_ERRORS, 0);
#endif // UNIT
}
VBX_TEST_END(errors);
return errors;
}
int main(void)
{
pixel *input;
pixel *scalar_input;
#if USE_LUMA
unsigned char *vbx_luma;
#endif
unsigned short *scalar_luma;
pixel *vbx_output;
pixel *scalar_output;
vbx_timestamp_t time_start, time_stop;
double scalar_time, vbx_time;
int x, y;
int errors = 0;
vbx_test_init();
vbx_mxp_print_params();
input = (pixel *)vbx_shared_malloc(IMAGE_WIDTH*IMAGE_HEIGHT*sizeof(pixel));
scalar_input = (pixel *)vbx_remap_cached(input, IMAGE_WIDTH*IMAGE_HEIGHT*sizeof(pixel));
#if USE_LUMA
vbx_luma = (unsigned char *)vbx_shared_malloc(IMAGE_WIDTH*IMAGE_HEIGHT*sizeof(unsigned char));
#endif
scalar_luma = (unsigned short *)malloc(IMAGE_WIDTH*IMAGE_HEIGHT*sizeof(unsigned short));
vbx_output = (pixel *)vbx_shared_malloc(IMAGE_WIDTH*IMAGE_HEIGHT*sizeof(pixel));
scalar_output = (pixel *)malloc(IMAGE_WIDTH*IMAGE_HEIGHT*sizeof(pixel));
printf("\nInitializing data\n");
printf("Resolution = %dx%d\n", IMAGE_WIDTH, IMAGE_HEIGHT);
init_matrix(input, IMAGE_WIDTH, IMAGE_HEIGHT);
printf("Starting Sobel 3x3 edge-detection test\n");
#if USE_LUMA
scalar_rgb2luma(scalar_luma, scalar_input, IMAGE_WIDTH, IMAGE_HEIGHT, IMAGE_PITCH);
#endif
vbx_timestamp_start();
time_start = vbx_timestamp();
#if !USE_LUMA
scalar_rgb2luma(scalar_luma, scalar_input, IMAGE_WIDTH, IMAGE_HEIGHT, IMAGE_PITCH);
#endif
scalar_sobel_argb32_3x3(scalar_output, scalar_luma, IMAGE_WIDTH, IMAGE_HEIGHT, IMAGE_PITCH, RENORM_AMOUNT);
time_stop = vbx_timestamp();
scalar_time = vbx_print_scalar_time(time_start, time_stop);
#if USE_LUMA
vbw_rgb2luma8(vbx_luma, (unsigned *)input, IMAGE_WIDTH, IMAGE_HEIGHT, IMAGE_PITCH);
#endif
vbx_timestamp_start();
time_start = vbx_timestamp();
#if USE_LUMA
vbw_sobel_luma8_3x3((unsigned *)vbx_output, vbx_luma, IMAGE_WIDTH, IMAGE_HEIGHT, IMAGE_PITCH, RENORM_AMOUNT);
#else
vbw_sobel_argb32_3x3((unsigned *)vbx_output, (unsigned *)input, IMAGE_WIDTH, IMAGE_HEIGHT, IMAGE_PITCH, RENORM_AMOUNT);
#endif
time_stop = vbx_timestamp();
vbx_time = vbx_print_vector_time(time_start, time_stop, scalar_time);
for (y = 0; y < IMAGE_HEIGHT; y++) {
for (x = 0; x < IMAGE_WIDTH; x++) {
#if USE_LUMA
if (scalar_luma[y*IMAGE_WIDTH+x] != vbx_luma[y*IMAGE_WIDTH+x]) {
if (errors < MAX_PRINT_ERRORS) {
printf("Y Error at %d, %d: Expected = %02X, got = %02X\n",
y, x, scalar_luma[y*IMAGE_WIDTH+x], vbx_luma[y*IMAGE_WIDTH+x]);
}
errors++;
}
#endif
if (scalar_output[y*IMAGE_WIDTH+x].r != vbx_output[y*IMAGE_WIDTH+x].r) {
if (errors < MAX_PRINT_ERRORS) {
printf("R Error at %d, %d: Expected = %02X, got = %02X\n",
y, x, scalar_output[y*IMAGE_WIDTH+x].r, vbx_output[y*IMAGE_WIDTH+x].r);
}
errors++;
}
if (scalar_output[y*IMAGE_WIDTH+x].g != vbx_output[y*IMAGE_WIDTH+x].g) {
if (errors < MAX_PRINT_ERRORS) {
printf("G Error at %d, %d: Expected = %02X, got = %02X\n",
y, x, scalar_output[y*IMAGE_WIDTH+x].g, vbx_output[y*IMAGE_WIDTH+x].g);
}
errors++;
}
if (scalar_output[y*IMAGE_WIDTH+x].b != vbx_output[y*IMAGE_WIDTH+x].b) {
if (errors < MAX_PRINT_ERRORS) {
printf("B Error at %d, %d: Expected = %02X, got = %02X\n",
y, x, scalar_output[y*IMAGE_WIDTH+x].b, vbx_output[y*IMAGE_WIDTH+x].b);
}
errors++;
}
}
}
VBX_TEST_END(errors);
return errors;
}
int main(void)
{
vbx_test_init();
#if 0
vbx_mxp_t *this_mxp = VBX_GET_THIS_MXP();
const int VBX_SCRATCHPAD_SIZE = this_mxp->scratchpad_size;
int N = VBX_SCRATCHPAD_SIZE/sizeof(vbx_mm_t)/8;
#endif
int TEST_LENGTH = TEST_ROWS*TEST_COLS;
int NTAP_LENGTH = NTAP_ROWS*NTAP_COLS;
int PRINT_COLS = min( TEST_COLS, MAX_PRINT_LENGTH );
int PRINT_ROWS = min( TEST_ROWS, MAX_PRINT_LENGTH );
double scalar_time, vector_time;
int errors=0;
vbx_mxp_print_params();
printf( "\nMatrix FIR test...\n" );
printf( "Matrix dimensions: %d,%d\n", TEST_ROWS, TEST_COLS );
vbx_mm_t *scalar_in = malloc( TEST_LENGTH*sizeof(vbx_mm_t) );
vbx_mm_t *vector_in = vbx_shared_malloc( TEST_LENGTH*sizeof(vbx_mm_t) );
int32_t *scalar_filt = malloc( NTAP_LENGTH*sizeof(int32_t) );
int32_t *vector_filt = vbx_shared_malloc( NTAP_LENGTH*sizeof(int32_t) );
vbx_mm_t *scalar_out = malloc( TEST_LENGTH*sizeof(vbx_mm_t) );
vbx_mm_t *vector_out = vbx_shared_malloc( TEST_LENGTH*sizeof(vbx_mm_t) );
VBX_T(test_zero_array)( scalar_out, TEST_LENGTH );
VBX_T(test_zero_array)( vector_out, TEST_LENGTH );
VBX_T(test_init_array)( scalar_in, TEST_LENGTH, 1 );
VBX_T(test_copy_array)( vector_in, scalar_in, TEST_LENGTH );
test_init_array_word( scalar_filt, NTAP_LENGTH, 1 );
test_copy_array_word( vector_filt, scalar_filt, NTAP_LENGTH );
VBX_T(test_print_matrix)( scalar_in, PRINT_ROWS, PRINT_COLS, TEST_COLS );
test_print_matrix_word( scalar_filt, NTAP_ROWS, NTAP_COLS, NTAP_COLS );
scalar_time = test_scalar( scalar_out, scalar_in, scalar_filt,
TEST_ROWS, TEST_COLS, NTAP_ROWS, NTAP_COLS);
VBX_T(test_print_matrix)( scalar_out, PRINT_COLS, PRINT_ROWS, TEST_COLS );
vector_time = test_vector( vector_out, vector_in, vector_filt,
TEST_ROWS, TEST_COLS, NTAP_ROWS, NTAP_COLS, scalar_time );
VBX_T(test_print_matrix)( vector_out, PRINT_COLS, PRINT_ROWS, TEST_COLS );
int i;
for(i=0; i<TEST_ROWS-NTAP_ROWS; i++){
errors += VBX_T(test_verify_array)( scalar_out+i*TEST_COLS, vector_out+i*TEST_COLS, TEST_COLS-NTAP_COLS );
}
VBX_TEST_END(errors);
return 0;
}
int main(void)
{
vbx_test_init();
typedef vbx_word_t vbx_mm_t;
vbx_mxp_t *this_mxp = VBX_GET_THIS_MXP();
const int VBX_SCRATCHPAD_SIZE = this_mxp->scratchpad_size;
int N = VBX_SCRATCHPAD_SIZE / sizeof(vbx_mm_t );
N = 20;
int M = 20;
int PRINT_LENGTH = N<MAX_PRINT_LENGTH ? N : MAX_PRINT_LENGTH ;
// int PRINT_ROWS = PRINT_LENGTH;
int PRINT_ROWS = M<MAX_PRINT_LENGTH ? N : MAX_PRINT_LENGTH;
int PRINT_COLS = PRINT_LENGTH;
double scalar_time, vector_time,vector2_time;
int errors=0;
vbx_mxp_print_params();
printf( "\nMatrix multiply test...\n" );
printf( "Matrix dimensions: %d,%d\n", N, M );
vbx_mm_t *scalar_in1 = (vbx_mm_t*)malloc( M*N*sizeof(vbx_mm_t ) );
vbx_mm_t *scalar_in2 = (vbx_mm_t*)malloc( M*N*sizeof(vbx_mm_t ) );
vbx_mm_t *scalar_out = (vbx_mm_t*)malloc( N*N*sizeof(vbx_mm_t ) );
vbx_mm_t *vector_in1 = (vbx_mm_t*)vbx_shared_malloc( M*N*sizeof(vbx_mm_t ) );
vbx_mm_t *vector_in2 = (vbx_mm_t*)vbx_shared_malloc( M*N*sizeof(vbx_mm_t ) );
vbx_mm_t *vector_out = (vbx_mm_t*)vbx_shared_malloc( N*N*sizeof(vbx_mm_t ) );
if ( scalar_in1 == NULL ||
scalar_in2 == NULL ||
scalar_out == NULL ||
vector_in1 == NULL ||
vector_in2 == NULL ||
vector_out == NULL ){
printf("Malloc failed\n");
VBX_TEST_END(1);
return 0;
}
test_zero_array_word(scalar_out, N*N );
test_zero_array_word(vector_out, N*N );
test_init_array_word( scalar_in1, M*N, 1 );
test_copy_array_word( vector_in1, scalar_in1, M*N );
test_init_array_word( scalar_in2, M*N, 999 );
//scalar_mtx_xp_MN_word( vector_in2, scalar_in2, N, N );
test_copy_array_word( vector_in2, scalar_in2, M*N );
test_print_matrix_word( scalar_in1, PRINT_COLS, PRINT_ROWS, M );
test_print_matrix_word( scalar_in2, PRINT_ROWS, PRINT_COLS, N );
//change print sizes for outputs
PRINT_ROWS=PRINT_COLS=N<PRINT_LENGTH?N:PRINT_LENGTH;
scalar_time = test_scalar( scalar_out, scalar_in1, N, M, scalar_in2, M, N);
test_print_matrix_word( scalar_out, PRINT_COLS, PRINT_ROWS, N );
vector_time = test_vector( vector_out, vector_in1, N, M, vector_in2, M, N, scalar_time );
test_print_matrix_word( vector_out, PRINT_COLS, PRINT_ROWS, N );
errors += test_verify_array_word( scalar_out, vector_out, N*N);
vector2_time = test_vector_trans( vector_out, vector_in1, N, M, vector_in2, M, N, scalar_time );
test_print_matrix_word( vector_out, PRINT_COLS, PRINT_ROWS, N );
errors += test_verify_array_word( scalar_out, vector_out, N*N);
vector2_time = test_vector_sp( vector_out, vector_in1, N, M, vector_in2, M, N, scalar_time );
test_print_matrix_word( vector_out, PRINT_COLS, PRINT_ROWS, N );
errors += test_verify_array_word( scalar_out, vector_out, N*N);
vbx_shared_free(vector_out);
vbx_shared_free(vector_in2);
vbx_shared_free(vector_in1);
free(scalar_out);
free(scalar_in2);
free(scalar_in1);
//errors += orig_test();
VBX_TEST_END(errors);
return 0;
}
int main(void)
{
vbx_timestamp_t time_start, time_stop;
double scalar_time, vector_time;
input_pointer img1;
input_pointer img2;
input_pointer sc_img1;
input_pointer sc_img2;
output_pointer scalar_out;
output_pointer vector_out;
int i,j;
int total_errors = 0;
vbx_test_init();
vbx_mxp_print_params();
img1 = vbx_shared_malloc( NUM_OF_ROWS*NUM_OF_COLUMNS*sizeof(input_type) );
img2 = vbx_shared_malloc( NUM_OF_ROWS*NUM_OF_COLUMNS*sizeof(input_type) );
vector_out = vbx_shared_malloc( NUM_OF_ROWS*NUM_OF_COLUMNS*sizeof(output_type) );
sc_img1 = malloc( NUM_OF_ROWS*NUM_OF_COLUMNS*sizeof(input_type) );
sc_img2 = malloc( NUM_OF_ROWS*NUM_OF_COLUMNS*sizeof(input_type) );
scalar_out = malloc( NUM_OF_ROWS*NUM_OF_COLUMNS*sizeof(output_type) );
init_img( img1, img2 );
init_img( sc_img1, sc_img2 );
vbx_mxp_t *this_mxp = VBX_GET_THIS_MXP();
const int VBX_VECTOR_BYTE_LANES = this_mxp->vector_lanes * sizeof(int);
printf("\n");
printf("Num of byte lanes: %d\n", VBX_VECTOR_BYTE_LANES);
printf("Initialized data\n\n");
printf("Executing Scalar Image Blend...\n");
vbx_timestamp_start();
time_start = vbx_timestamp();
scalar_blend( scalar_out, sc_img1, sc_img2, NUM_OF_ROWS, NUM_OF_COLUMNS, CONST_BLEND );
time_stop = vbx_timestamp();
printf("Finished Scalar Image Blend\n");
scalar_time = vbx_print_scalar_time(time_start, time_stop);
printf("\nExecuting Vector Image Blend...\n");
vbx_timestamp_start();
time_start = vbx_timestamp();
vector_blend( vector_out, img1, img2, NUM_OF_ROWS, NUM_OF_COLUMNS, CONST_BLEND);
time_stop = vbx_timestamp();
printf("Finished Vector Image Blend\n");
vector_time = vbx_print_vector_time(time_start, time_stop, scalar_time);
int errors = 0;
for( j=0; j<NUM_OF_ROWS; j++ ) {
for( i = 0; i < NUM_OF_COLUMNS; i++ ) {
if( vector_out[j*NUM_OF_COLUMNS+i] != scalar_out[j*NUM_OF_COLUMNS+i] ) {
if(errors < 5)
printf( "\nFail at sample [%3d,%3d]. Scalar: %3d Vector: %3d Img1: %3d Img2: %3d",
j, i, scalar_out[j*NUM_OF_COLUMNS+i],
vector_out[j*NUM_OF_COLUMNS+i], img1[j*NUM_OF_COLUMNS+i], img2[j*NUM_OF_COLUMNS+i] );
errors++;
}
}
}
printf("\n%d errors\n", errors);
total_errors += errors;
VBX_TEST_END(total_errors);
return 0;
}
int main(void)
{
vbx_test_init();
vbx_mxp_t *this_mxp = VBX_GET_THIS_MXP();
const int VBX_SCRATCHPAD_SIZE = this_mxp->scratchpad_size;
const int required_vectors = 4;
int N = VBX_PAD_DN(VBX_SCRATCHPAD_SIZE / sizeof(vbx_mm_t) / required_vectors, this_mxp->scratchpad_alignment_bytes);
int PRINT_LENGTH = min( N, MAX_PRINT_LENGTH );
double scalar_time, vector_time;
int errors=0;
vbx_mxp_print_params();
printf( "\nVector copy test...\n" );
printf( "Vector length: %d\n", N );
vbx_mm_t *scalar_in = malloc( N*sizeof(vbx_mm_t) );
vbx_mm_t *scalar_out = malloc( N*sizeof(vbx_mm_t) );
vbx_mm_t *vector_in = vbx_shared_malloc( N*sizeof(vbx_mm_t) );
vbx_mm_t *vector_out = vbx_shared_malloc( N*sizeof(vbx_mm_t) );
vbx_sp_t *v_out = vbx_sp_malloc( N*sizeof(vbx_sp_t) );
vbx_sp_t *v_in = vbx_sp_malloc( N*sizeof(vbx_sp_t) );
VBX_T(test_zero_array)( scalar_in, N );
VBX_T(test_zero_array)( vector_in, N );
VBX_T(test_init_array)( scalar_in, N, 1 );
VBX_T(test_copy_array)( vector_in, scalar_in, N );
scalar_time = test_scalar( scalar_out, scalar_in, N );
VBX_T(test_print_array)( scalar_out, PRINT_LENGTH );
vbx_dma_to_vector( v_in, vector_in, N*sizeof(vbx_sp_t) );
vector_time = test_vector( v_out, v_in, N, scalar_time );
vbx_dma_to_host(vector_out, v_out, N*sizeof(vbx_sp_t) );
vbx_sync();
VBX_T(test_print_array)( vector_out, PRINT_LENGTH );
errors += VBX_T(test_verify_array)( scalar_out, vector_out, N );
vbx_sp_free();
#if TEST_DEEP_SP
errors += deep_vector_copy_test();
#endif
#if DEBUG_MAKE_SP_FULL
vbx_sp_malloc(vbx_sp_getfree());
#endif
#if TEST_DEEP_MM
errors += deep_vector_copy_ext_test();
#endif
VBX_TEST_END(errors);
return 0;
}
