Example #1
0
void testrun_performance_des(void){
	uint64_t t;
	char str[16];
	uint8_t key[8], data[8];
	
	
	calibrateTimer();
	print_overhead();
	
	memset(key,  0, 8);
	memset(data, 0, 8);
	
	startTimer(1);
	des_enc(data, data, key);
	t = stopTimer();
	uart_putstr_P(PSTR("\r\n\tencrypt time: "));
	ultoa((unsigned long)t, str, 10);
	uart_putstr(str);
	
	startTimer(1);
	des_dec(data, data, key);
	t = stopTimer();
	uart_putstr_P(PSTR("\r\n\tdecrypt time: "));
	ultoa((unsigned long)t, str, 10);
	uart_putstr(str);
	uart_putstr_P(PSTR("\r\n"));
}
Example #2
0
void testrun_performance_rabbit(void){
	uint64_t t;
	char str[16];
	uint8_t key[16];
	rabbit_ctx_t ctx;

	calibrateTimer();
	print_overhead();

	memset(key,  0, 16);

	startTimer(1);
	rabbit_init(key, 128, NULL, &ctx);
	t = stopTimer();
	cli_putstr_P(PSTR("\r\n\tctx-gen time: "));
	ultoa((unsigned long)t, str, 10);
	cli_putstr(str);

	startTimer(1);
	rabbit_gen(&ctx);
	t = stopTimer();
	cli_putstr_P(PSTR("\r\n\tencrypt time: "));
	ultoa((unsigned long)t, str, 10);
	cli_putstr(str);

	cli_putstr_P(PSTR("\r\n"));
}
void testrun_performance_grain(void) {
    uint64_t t;
    char str[16];
    uint8_t key[10], iv[8];
    grain_ctx_t ctx;

    calibrateTimer();
    print_overhead();

    memset(key,  0, 10);
    memset(iv,  0, 8);

    startTimer(1);
    grain_init(key, iv, &ctx);
    t = stopTimer();
    cli_putstr_P(PSTR("\r\n\tctx-gen time: "));
    ultoa((unsigned long)t, str, 10);
    cli_putstr(str);

    startTimer(1);
    grain_enc(&ctx);
    t = stopTimer();
    cli_putstr_P(PSTR("\r\n\tencrypt time: "));
    ultoa((unsigned long)t, str, 10);
    cli_putstr(str);

    cli_putstr_P(PSTR("\r\n"));
}
Example #4
0
void testrun_performance_noekeon(void){
	uint64_t t;
	char str[16];
	uint8_t key[16], data[16];
	noekeon_ctx_t ctx;
	
	calibrateTimer();
	print_overhead();
	
	memset(key,  0, 16);
	memset(data, 0, 16);
	
	startTimer(1);
	noekeon_init(key, &ctx);
	t = stopTimer();
	uart_putstr_P(PSTR("\r\n\tctx-gen time: "));
	ultoa((unsigned long)t, str, 10);
	uart_putstr(str);	
	
	startTimer(1);
	noekeon_enc(data, &ctx);
	t = stopTimer();
	uart_putstr_P(PSTR("\r\n\tencrypt time: "));
	ultoa((unsigned long)t, str, 10);
	uart_putstr(str);	
	
	startTimer(1);
	noekeon_dec(data, &ctx);
	t = stopTimer();
	uart_putstr_P(PSTR("\r\n\tdecrypt time: "));
	ultoa((unsigned long)t, str, 10);
	uart_putstr(str);
	
	uart_putstr_P(PSTR("\r\n"));
}
void testrun_performance_entropium(void){
	uint64_t t;
	char str[16];
	uint8_t data[32];
	
	calibrateTimer();
	print_overhead();
	
	startTimer(1);
	entropium_addEntropy(128, data);
	t = stopTimer();
	cli_putstr_P(PSTR("\r\n\tadd entropy time: "));
	ultoa((unsigned long)t, str, 10);
	cli_putstr(str);
	
	
	startTimer(1);
	entropium_getRandomBlock(data);
	t = stopTimer();
	cli_putstr_P(PSTR("\r\n\tget random time:  "));
	ultoa((unsigned long)t, str, 10);
	cli_putstr(str);
	
	cli_putstr_P(PSTR("\r\n"));
}
void testrun_performance_shabea(void){
	uint64_t t;
	char str[16];
	uint8_t key[32], data[32];
	
	calibrateTimer();
	print_overhead();
	
	memset(key,  0, 32);
	memset(data, 0, 32);
	
	startTimer(1);
	shabea256(data, key, 256, 1, 16);
	t = stopTimer();
	cli_putstr_P(PSTR("\r\n\tencrypt time: "));
	ultoa((unsigned long)t, str, 10);
	cli_putstr(str);
	
	
	startTimer(1);
	shabea256(data, key, 256, 0, 16);
	t = stopTimer();
	cli_putstr_P(PSTR("\r\n\tdecrypt time: "));
	ultoa((unsigned long)t, str, 10);
	cli_putstr(str);
	
	cli_putstr_P(PSTR("\r\n"));
}
void testrun_performance_shacal2enc(void){
	uint64_t t;
	uint8_t key[SHACAL2_KEYSIZE_B], data[SHACAL2_BLOCKSIZE_B];
	
	calibrateTimer();
	print_overhead();
	
	memset(key,  0, SHACAL2_KEYSIZE_B);
	memset(data, 0, SHACAL2_BLOCKSIZE_B);
	
	
	startTimer(1);
	shacal2_enc(data, key, SHACAL2_KEYSIZE);
	t = stopTimer();
	print_time_P(PSTR("\tencrypt time: "), t);
	
	cli_putstr_P(PSTR("\r\n"));
}
void testrun_performance_twister512(void){
	uint64_t t;
	char str[16];
	uint8_t data[64];
	twister_big_ctx_t ctx;
	
	calibrateTimer();
	print_overhead();
	
	memset(data, 0, 64);
	
	startTimer(1);
	twister_big_init(&ctx, 512);
	t = stopTimer();
	uart_putstr_P(PSTR("\r\n\tctx-gen time: "));
	ultoa((unsigned long)t, str, 10);
	uart_putstr(str);
	
	
	startTimer(1);
	twister_big_nextBlock(&ctx, data);
	t = stopTimer();
	uart_putstr_P(PSTR("\r\n\tone-block time: "));
	ultoa((unsigned long)t, str, 10);
	uart_putstr(str);
	
	
	startTimer(1);
	twister_big_lastBlock(&ctx, data, 0);
	t = stopTimer();
	uart_putstr_P(PSTR("\r\n\tlast block time: "));
	ultoa((unsigned long)t, str, 10);
	uart_putstr(str);
	
	startTimer(1);
	twister_big_ctx2hash(data, &ctx, 512);
	t = stopTimer();
	uart_putstr_P(PSTR("\r\n\tctx2hash time: "));
	ultoa((unsigned long)t, str, 10);
	uart_putstr(str);

	uart_putstr_P(PSTR("\r\n"));
}
Example #9
0
void testrun_performance_sha256(void){
	uint64_t t;
	char str[16];
	uint8_t data[32];
	sha256_ctx_t ctx;
	
	calibrateTimer();
	print_overhead();
	
	memset(data, 0, 32);
	
	startTimer(1);
	sha256_init(&ctx);
	t = stopTimer();
	uart_putstr_P(PSTR("\r\n\tctx-gen time: "));
	ultoa((unsigned long)t, str, 10);
	uart_putstr(str);
	
	
	startTimer(1);
	sha256_nextBlock(&ctx, data);
	t = stopTimer();
	uart_putstr_P(PSTR("\r\n\tone-block time: "));
	ultoa((unsigned long)t, str, 10);
	uart_putstr(str);
	
	
	startTimer(1);
	sha256_lastBlock(&ctx, data, 0);
	t = stopTimer();
	uart_putstr_P(PSTR("\r\n\tlast block time: "));
	ultoa((unsigned long)t, str, 10);
	uart_putstr(str);
	
	uart_putstr_P(PSTR("\r\n"));
}
Example #10
0
int main(int argc, char *argv[])
{
	int i,j,k;
	int n;
	int iterations;
	FILE *file;
	double time;
	double omega;
	double eps;
	double temp,err1;
	int node_id;
	int nodes;
	int start;
	int end;
	double **send;
	double **send2;
	double *data;
	double *_data;
	double *g_err;
	char name[4];
	int row_size;
	d2mce_barrier_t b1;
	d2mce_mutex_t m1;
	d2mce_sem_t **sem;
	nodes = NODES;
	n = SIZE;
	eps = EPS;
	omega = OMEGA;
	iterations = ITERATIONS;

	if (argc > 1) {
		for ( i = 1 ; i < argc ;) {
			if (strcmp(argv[i],"-s") == 0) {
				n = atoi(argv[i+1]);
				n = n;
				i+=2;
			} else if (strcmp(argv[i],"-n") == 0) {
				nodes = atoi(argv[i+1]);
				i+=2;
			} else if (strcmp(argv[i],"-i") == 0) {
				iterations = atoi(argv[i+1]);
				i+=2;
			} else {
				print_usage();
				return 0;
			}
		}
	}
	//init
	printf("init...\n");
	d2mce_init();
	node_id = d2mce_join("sor","d2mce_orig", 0);
	printf("my node id:%d\n", node_id);
	startend(node_id, nodes, n, &start, &end);
	start++;
	printf("start %d end %d\n", start, end);
	d2mce_mutex_init(&m1,"m1");
	d2mce_barrier_init(&b1,"b1");
	data = d2mce_malloc("data", sizeof(double)* (n+2) * (n+2));
	_data = malloc(sizeof(double)* (n+2) * (n+2));
	g_err = d2mce_malloc("g_err", sizeof(double));
	send= (double **)malloc(sizeof(double*) * nodes);
	send2 = (double **)malloc(sizeof(double*) * nodes);
	sem = (d2mce_sem_t **)malloc(sizeof(d2mce_sem_t*) * nodes);
	for (i=0;i<nodes;i++) {
		sem[i] = (d2mce_sem_t*)malloc(sizeof(d2mce_sem_t));
		snprintf(name, 3,"b%d", i);
		d2mce_sem_init(sem[i], name , 0);
		snprintf(name , 4, "s1%d", i);
		send[i] = (double*)d2mce_malloc(name, sizeof(double)* (n+3));
       	snprintf(name , 4, "s2%d", i);
        send2[i] = (double*)d2mce_malloc(name, sizeof(double)* (n+3));

	}
	//read data
	if (node_id == 0) {
		file = fopen("input.data","r");
		if (file==NULL) {
			printf("can't not open the input.data file\n");
			return -1;
		}
		fread(data, sizeof(double), (n+2)*(n+2), file);
		fclose(file);
		*g_err = 0;
	} else {
		d2mce_load(g_err);
		d2mce_load(data);
		d2mce_sethome(send[node_id]);
		d2mce_sethome(send2[node_id]);
	}
	memcpy(_data, data, sizeof(double)*(n+2)*(n+2));
	d2mce_barrier(&b1, nodes);
	row_size = n+2;
	//processing
	printf("d2mce SOR processing...\n");
	time = -d2mce_time();
	for (k=1; k<iterations; k++)  {
		printf("%d \n",k);
		err1 = 0.0;
		//get up node's end dataA

		if (node_id < (nodes-1)) {
			d2mce_acq();
			for (j=0; j<=(n+1); j++) {
				send[node_id][j] = _data[end*row_size+j];
			}
			d2mce_store(send[node_id]);
			d2mce_sem_post(sem[node_id]);
		}
		if (node_id > 0) {
			d2mce_sem_wait(sem[node_id-1]);
			d2mce_load( send[node_id-1] );
			for (j=0; j<=(n+1); j++) {
				_data[(start-1)*row_size+j] = send[node_id-1][j];
			}
		}

		//white
		// i == columnA
#ifdef OPENMP
	    #pragma omp parallel for private(temp, j)
#endif
		for (i=start; i<=end; i+=2)  {
			// j == row
			for (j=1; j<=n; j++)  {
	            temp=0.125*( _data[(i-1)*row_size+j]+_data[(i+1)*row_size+j]+_data[i*row_size+j-1]+_data[i*row_size+j+1]+
    		 	             _data[(i-1)*row_size+j-1]+_data[(i-1)*row_size+j+1]+_data[(i+1)*row_size+j-1]+_data[(i+1)*row_size+j+1] )-_data[i*row_size+j];

				_data[i*row_size+j]+=omega*temp;
				if (temp < 0)
					temp=-temp;
				if (temp > err1)
					err1=temp;
			}
		}
//		d2mce_barrier(&b1, nodes);
		//get next node's start data
		if (node_id > 0) {
			d2mce_acq();
			for (j=0; j<=(n+1); j++) {
				send2[node_id][j] = _data[start*row_size+j];
			}
			d2mce_store(send2[node_id]);
			d2mce_sem_post(sem[node_id]);
		}
		if (node_id < (nodes-1)) {
			d2mce_sem_wait(sem[node_id+1]);
			d2mce_load( send2[node_id+1] );
			for (j=0; j<=(n+1); j++) {
				_data[(end+1)*row_size+j] = send2[node_id+1][j];
			}
		}

		//black
#ifdef OPENMP
        #pragma omp parallel for private(temp, j)
#endif

		for (i=start+1; i<=end; i+=2)  {
			for (j=1; j<=n; j++)  {
		        temp=0.125*( _data[(i-1)*row_size+j]+_data[(i+1)*row_size+j]+_data[i*row_size+j-1]+_data[i*row_size+j+1]+
        	                 _data[(i-1)*row_size+j-1]+_data[(i-1)*row_size+j+1]+_data[(i+1)*row_size+j-1]+_data[(i+1)*row_size+j+1] )-_data[i*row_size+j];

				_data[i*row_size+j]+=omega*temp;
				if (temp < 0)
					temp=-temp;
				if (temp > err1)
					err1=temp;
			}
		}
		*g_err = 0.0;
		//get max err1;
		d2mce_mutex_lock(&m1);
		d2mce_load(g_err);
		if (err1 > *g_err) {
			*g_err = err1;
			d2mce_store(g_err);
		}
		d2mce_mutex_unlock(&m1);
		d2mce_barrier(&b1, nodes);
		d2mce_load(g_err);
		if (*g_err <= eps)
			break;
//		d2mce_barrier(&b1, nodes);

	}
	// get all data
	d2mce_mutex_lock(&m1);
	d2mce_load(data);
/*
#ifdef OPENMP
        #pragma omp parallel for private(temp, j)
#endif
*/
	for (i = start; i <= end; i++)
		for (j = 0; j <= (n+1); j++)
			data[i*row_size+j] = _data[i*row_size+j];
	d2mce_store(data);
	d2mce_mutex_unlock(&m1);
	d2mce_barrier(&b1, nodes);
	if (node_id == 0)
		d2mce_load(data);

	time+=d2mce_time();
	printf("\n====================================================\n");
	printf("Result:\n");
	printf("\tTIME\tVector_Size\tLoops\tErr\n");
	printf("\t%f\t%d\t%d\t%.5e\n", time, n, k, *g_err);
	file = fopen("d2mce_output.data","w");
	if (file == NULL) {
		printf("can't not open signal_output.data\n");
		return -1;
	}
	fwrite(data, sizeof(double), (n+2)*(n+2), file);
	fclose(file);
	print_overhead();
	d2mce_finalize();

	return 0;
}
Example #11
0
int main(int argc, char *argv[]){
	int i,j,k;
	int _vector_size = VECTOR_SIZE;
	int _iteration = ITERATION;
	double _initval = INITVAL;
	int _nodes = NODES;
	int _column = VECTOR_SIZE+1;
	int ans_index=0;
	int change=1;
	d2mce_mutex_t lock;
	d2mce_barrier_t b1;
	int node_id;
	int *initialized;
//	int local_index;
	double computing;
	double *matrix;
	double *ans;
	double *_ans[2];
	double time;
	int comp_size = 0;
	FILE *file;
// processing argument
	if(argc > 1){
		for( i = 1 ; i < argc ;){
			if( !strcmp(argv[i], "-s" )){
				if(argv[i+1] == NULL){
					usage_info();
					return 0;
				}
				_vector_size = atoi(argv[i+1]);
				_column = _vector_size + 1;
				i+=2;
			}
			else if( !strcmp(argv[i], "-i")){
				if(argv[i+1] == NULL){
					usage_info();
					return 0;
				}
				_iteration = atoi(argv[i+1]);
				i+=2;
			}
			else if( !strcmp(argv[i], "-v")){
				if(argv[i+1] == NULL){
					usage_info();
					return 0;
				}
				_initval = atof(argv[i+1]);
				i+=2;
			}
			else if( !strcmp(argv[i], "-n")){
				if(argv[i+1] == NULL){
					usage_info();
					return 0;
				}
				_nodes = atoi(argv[i+1]);
				i+=2;
			}
			else{
				usage_info();
				return 0;
			}
		}
	}
	comp_size = _vector_size /_nodes;
	if(_vector_size%_nodes !=0)
		comp_size++;

	srand( RANDOM_SEED );
	d2mce_init();
	node_id = d2mce_join("jacobi", "eps308", 0);
	printf("my id%d\n", node_id);
	d2mce_mutex_init(&lock, "lock");
	d2mce_barrier_init(&b1, "b1");
// init value 

	initialized = (int*)d2mce_malloc("initialized", sizeof(int));
	matrix = (double*) d2mce_malloc("matrix", sizeof(double)* _vector_size * _column );
	ans = (double*) d2mce_malloc("ans", sizeof(double)* _vector_size ); //the old ans;
//	ans[1] = (double*) d2mce_malloc("ans[1]", sizeof(double), _vector_size );
	_ans[0] = (double*) malloc(sizeof(double) * _vector_size ); //the new ans;
	_ans[1] = (double*) malloc(sizeof(double) * _vector_size ); //local index to check the data is dirty
	
	if(node_id == 0){
		d2mce_mutex_rw(&lock, 3, initialized, "rw",  matrix, "rw", ans, "rw"); 
		for( i=0; i < _vector_size; i++){
			ans[i] = (double)_initval;
			_ans[0][i] = (double)_initval;
			_ans[1][i] = 0.0;
			for( j=0; j< _column ; j++){
				if(i == j)
					matrix[i*_column + j] = 0;
				else
					matrix[i*_column + j] = create_init_value();
			}
		}
		*initialized = 0;	
		d2mce_mutex_unlock(&lock);
	}
	else{
		while (! initialized) {
			d2mce_mutex_rw(&lock, 1,initialized,"r");
			d2mce_mutex_unlock(&lock);
		}
		d2mce_mutex_rw(&lock, 2, matrix, "r", ans, "r" );
		d2mce_mutex_unlock(&lock);
        for( i=0; i < _vector_size; i++){
			_ans[0][i] = ans[i];
			_ans[1][i] = 0.0;
		}
	}
	if(_nodes >1)
		d2mce_barrier(&b1, _nodes);
	
/*
	for( i=0; i < _vector_size; i++){
		for( j=0; j< _column ; j++){
			printf("%f ", matrix[i*_column + j]);
		}
		printf("\n");
	}
	printf("\n\n");
	for( j=0; j< _column ; j++){
		printf("%f ", ans[j]);
	}
	printf("\n\n");

	for( j=0; j< _column ; j++){
		printf("%f ", _ans[0][j]);
	}
	printf("\n\n");
	for( j=0; j< _column ; j++){
		printf("%f ", _ans[1][j]);
	}
	printf("\n\n");
*/	


/*
	ans[0][0]=-1.5;
	ans[0][1]=2.5;
	ans[0][2]=-0.5;
	matrix[0]=-0;
	matrix[1]=-0.125;
	matrix[2]=0.25;
	matrix[3]=-(double)11/8;
	matrix[_column]=-(double)2/9;
	matrix[_column+1]=0;
	matrix[_column+2]=-(double)1/9;
	matrix[_column+3]=(double)22/9;
	matrix[2*_column]=(double)1/11;
	matrix[2*_column+1]=(double)2/11;
	matrix[2*_column+2]=0;
	matrix[2*_column+3]=-(double)15/11;
*/

/*
 * jacobi method computing
 */
	time = -d2mce_time();
	for( i=0; i<_iteration; i++){
		for( j=node_id*comp_size; j<(node_id*comp_size+comp_size) && j<_vector_size; j++){
			computing =0;
			for( k=0; k<_vector_size; k++){
				if(j!=k)
					computing += matrix[j*_column + k]*_ans[ans_index][k];
			}
			computing += matrix[j*_column + _vector_size];
			_ans[ans_index + change][j] = computing;
		}
		ans_index += change;
		change = -change;
//		d2mce_barrier(&b1, _nodes);
        d2mce_mutex_rw(&lock, 1, ans, "rw");
        for( j=node_id*comp_size; j<(node_id*comp_size+comp_size) && j<_vector_size; j++){
            ans[j] = _ans[ans_index][j];
        }
        d2mce_mutex_unlock(&lock);
		d2mce_barrier(&b1, _nodes);
		d2mce_load(ans);
		if( i != _iteration){
		#ifdef OPENMP
	        #pragma omp parallel for
		#endif
	        for( j=0; j<_vector_size; j++){
    	        _ans[ans_index][j] = ans[j];
	        }
		}

	}
	time += d2mce_time();
/*
 * print the result information
 */
/*
	printf("the ans:\n");
	for( i=0; i < _vector_size; i++){
		printf("%f ", ans[i]);
	}
	printf("\n");
*/
	printf("Result:\n");
 	printf("\tTIME\tVector_Size\n");
    printf("\t%f\t%d\n", time, _vector_size);
    file = fopen("d2mce_output.data","w");
    fwrite(ans, sizeof(double), _vector_size, file);
    fclose(file);
	print_overhead();
	d2mce_finalize();
	free(_ans[0]);	
	free(_ans[1]);
	return 0;
}
Example #12
0
int main(int argc, char *argv[])
{
	int i,j,k;
	int n;
	int *data;
	int *_data;
	int *tmp;
	FILE *file;
	double time;
	int node_id;
	int nodes;
	int block_size;
	int root;
	d2mce_barrier_t b1;
	d2mce_mutex_t m1;

	n=SIZE;
	nodes = NODES;
	if (argc > 1) {
		for ( i = 1 ; i < argc ;) {
			if (strcmp(argv[i],"-s") == 0) {
				n = atoi(argv[i+1]);
				i+=2;
			} else if (strcmp(argv[i],"-n") == 0) {
				nodes = atoi(argv[i+1]);
				i+=2;
			} else {
				print_usage();
				return 0;
			}
		}
	}
	block_size = n / nodes;
	if (n % nodes !=0) {
		printf("size error\n");
		return -1;
	}
	printf("init...\n");
	d2mce_init();
	node_id = d2mce_join("asp","d2mce_orig", 0);
	printf("my node id:%d\n", node_id);
	d2mce_mutex_init(&m1,"m1");
	d2mce_barrier_init(&b1,"b1");
	data = d2mce_malloc("data", sizeof(int)* n * n);
	tmp = d2mce_malloc("tmp", sizeof(int)*n);

	_data = malloc(sizeof(int)*n*n);
	//read data
	if (node_id == 0) {
		file = fopen("input.data","r");
		if (file==NULL) {
			printf("can't not open the input.data file\n");
			return -1;
		}
		fread(data, sizeof(int), n*n, file);
		fclose(file);
	} else {
		d2mce_load(data);
	}
	//memcpy(_data, data, sizeof(int)*n*n);
	d2mce_barrier(&b1, nodes);
	//processing
	printf("d2mce ASP processing...\n");
	time = -d2mce_time();

	for (k = 0; k < n; k++) {
		root = k/block_size;
		if(node_id == root){
			for(j=0;j<n;j++)
				tmp[j] = data[k*n+j];
			d2mce_acq();
			d2mce_store(tmp);
			d2mce_barrier(&b1, nodes);
		}else{
			d2mce_barrier(&b1, nodes);
			d2mce_load(tmp);
		}
#ifdef OPENMP
        #pragma omp parallel for private(j)
#endif
		for (i = node_id * block_size; i < node_id *block_size + block_size; i++){
			for (j = 0; j < n; j++) {
				if (data[i*n+j] > (data[i*n+k] + tmp[j]))
					data[i*n+j] = data[i*n+k] + tmp[j];
			}
		}
		d2mce_barrier(&b1, nodes);
	}
	//gather
/*
	d2mce_mutex_lock(&m1);
    d2mce_load(data);
#ifdef OPENMP
        #pragma omp parallel for private(j)
#endif
 	for (i = node_id * block_size; i < node_id *block_size + block_size; i++)
	    for (j = 0; j < n; j++)
    	    data[i*n+j] = _data[i*n+j];
    d2mce_store(data);
    d2mce_mutex_unlock(&m1);
*/
	d2mce_mstore(data,  node_id * block_size * n * sizeof(int), block_size * n * sizeof(int));

    d2mce_barrier(&b1, nodes);
	if(node_id == 0)
		d2mce_load(data);
	time+=d2mce_time();
	printf("Result:\n");
	printf("\tTIME\tVector_Size\n");
	printf("\t%f\t%d\n", time, n);
	if(node_id == 0){
		file = fopen("d2mce_output.data","w");
		fwrite(data, sizeof(int), n*n, file);
		fclose(file);
	}
	print_overhead();
	d2mce_finalize();
	free(_data);
	return 0;
}
Example #13
0
void bcal_performance(const bcdesc_t* bcd){
	bcdesc_t bc;
	memcpy_P(&bc, bcd, sizeof(bcdesc_t));
	uint8_t ctx[bc.ctxsize_B];
	uint8_t data[(bc.blocksize_b+7)/8];
	uint16_t keysize = get_keysize(bc.valid_keysize_desc);
	uint8_t key[(keysize+7)/8];
	uint64_t t;
	uint8_t i;

	if(bc.type!=BCDESC_TYPE_BLOCKCIPHER)
		return;
	calibrateTimer();
	print_overhead();
	cli_putstr_P(PSTR("\r\n\r\n === "));
	cli_putstr_P(bc.name);
	cli_putstr_P(PSTR(" performance === "
	                  "\r\n    type:             blockcipher"
	                  "\r\n    keysize (bits):     "));
	printvalue(keysize);

	cli_putstr_P(PSTR("\r\n    ctxsize (bytes):    "));
	printvalue(bc.ctxsize_B);

	cli_putstr_P(PSTR("\r\n    blocksize (bits):   "));
	printvalue(bc.blocksize_b);



	t=0;
	if(bc.init.init1){
		if((bc.flags&BC_INIT_TYPE)==BC_INIT_TYPE_1){
			for(i=0; i<32; ++i){
				startTimer(0);
				START_TIMER;
				(bc.init.init1)(key, &ctx);
				STOP_TIMER;
				t += stopTimer();
				if(i!=31 && bc.free){
					bc.free(&ctx);
				}
			}
		} else {
			for(i=0; i<32; ++i){
				startTimer(0);
				START_TIMER;
				(bc.init.init2)(key, keysize, &ctx);
				STOP_TIMER;
				t += stopTimer();
				if(i!=31 && bc.free){
					bc.free(&ctx);
				}
			}
		}
		t>>=5;
		cli_putstr_P(PSTR("\r\n    init (cycles):      "));
		printvalue(t);
	}
	t=0;
	for(i=0; i<32; ++i){
		startTimer(0);
		START_TIMER;
		bc.enc.enc1(data, &ctx);
		STOP_TIMER;
		t += stopTimer();
	}
	t>>=5;
	cli_putstr_P(PSTR("\r\n    encrypt (cycles):   "));
	printvalue(t);

	t=0;
	for(i=0; i<32; ++i){
		startTimer(0);
		START_TIMER;
		bc.dec.dec1(data, &ctx);
		STOP_TIMER;
		t += stopTimer();
	}
	t>>=5;
	cli_putstr_P(PSTR("\r\n    decrypt (cycles):   "));
	printvalue(t);

	if(bc.free){
		bc.free(&ctx);
	}
}