bg
/
avr-crypto-lib
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

[performance-reports] switching to printf

This commit is contained in:
bg 2013-02-25 14:39:23 +01:00
parent 3a9f9d918f
commit a707b2a401
6 changed files with 52 additions and 100 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
arcfour/arcfour-asm.S
View File

@ -101,7 +101,7 @@ uint8_t arcfour_gen(arcfour_ctx_t *c){
.global arcfour_gen .global arcfour_gen
;== arcfour_gen == ;== arcfour_gen ==
; this function initialises the context ; this function generates a keystream byte
; param1: 16-bit pointer to a ctx struct ; param1: 16-bit pointer to a ctx struct
; given in r25,r24 ; given in r25,r24

12
bcal/bcal-performance.c
View File

@ -69,12 +69,12 @@ void bcal_performance(const bcdesc_t *bcd){
return; return;
calibrateTimer(); calibrateTimer();
print_overhead(); print_overhead();
printf_P(PSTR("\n\n === %S"), bc.name); printf_P(PSTR("\n\n === %S performance === \n"
printf_P(PSTR(" performance === \n" "\ttype: blockcipher\n"
" type: blockcipher\n" "\tkeysize (bits): %5"PRIu16"\n"
" keysize (bits): %5"PRIu16"\n"), keysize); "\tctxsize (bytes): %5"PRIu16"\n"
printf_P(PSTR(" ctxsize (bytes): %5"PRIu16"\n"), bc.ctxsize_B); "\tblocksize (bits): %5"PRIu16"\n"),
printf_P(PSTR(" blocksize (bits): %5"PRIu16"\n"), bc.blocksize_b); bc.name, keysize, bc.ctxsize_B, bc.blocksize_b);
uart0_flush(); uart0_flush();
t=0; t=0;
if(bc.init.init1){ if(bc.init.init1){

86
hfal/hfal-performance.c
View File

@ -25,56 +25,40 @@
* *
*/ */
#include "hfal-performance.h"
#include "hashfunction_descriptor.h"
#include "stack_measuring.h"
#include "cli.h"
#include "performance_test.h"
#include <stdint.h> #include <stdint.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include <stdio.h>
#include <avr/pgmspace.h> #include <avr/pgmspace.h>
#include "hfal-performance.h"
#include "hashfunction_descriptor.h"
#include "stack_measuring.h"
#include "performance_test.h"
#include "uart_i.h"
#define PATTERN_A 0xAA #define PATTERN_A 0xAA
#define PATTERN_B 0x55 #define PATTERN_B 0x55
static
void printvalue(unsigned long v){
char str[20];
int i;
ultoa(v, str, 10);
for(i=0; i<10-strlen(str); ++i){
cli_putc(' ');
}
cli_putstr(str);
}
void hfal_performance(const hfdesc_t *hd){ void hfal_performance(const hfdesc_t *hd){
hfdesc_t hf; hfdesc_t hf;
memcpy_P(&hf, hd, sizeof(hfdesc_t)); memcpy_P(&hf, hd, sizeof(hfdesc_t));
uint8_t ctx[hf.ctxsize_B]; uint8_t ctx[hf.ctxsize_B];
uint8_t data[(hf.blocksize_b+7)/8]; uint8_t data[(hf.blocksize_b+7)/8];
uint8_t digest[(hf.hashsize_b+7)/8]; uint8_t digest[(hf.hashsize_b+7)/8];
uint64_t t; uint32_t t;
uint8_t i; uint8_t i;
if(hf.type!=HFDESC_TYPE_HASHFUNCTION) if(hf.type!=HFDESC_TYPE_HASHFUNCTION)
return; return;
calibrateTimer(); calibrateTimer();
print_overhead(); print_overhead();
cli_putstr_P(PSTR("\r\n\r\n === ")); printf_P(PSTR("\n\n === %S performance ===\n"
cli_putstr_P(hf.name); "\ttype: hashfunction\n"
cli_putstr_P(PSTR(" performance === " "\thashsize (bits): %10"PRIu16"\n"
"\r\n type: hashfunction" "\tctxsize (bytes): %10"PRIu16"\n"
"\r\n hashsize (bits): ")); "\tblocksize (bits): %10"PRIu16"\n"),
printvalue(hf.hashsize_b); hf.name, hf.hashsize_b, hf.ctxsize_B, hf.blocksize_b);
uart0_flush();
cli_putstr_P(PSTR("\r\n ctxsize (bytes): "));
printvalue(hf.ctxsize_B);
cli_putstr_P(PSTR("\r\n blocksize (bits): "));
printvalue(hf.blocksize_b);
t=0; t=0;
for(i=0; i<32; ++i){ for(i=0; i<32; ++i){
startTimer(0); startTimer(0);
@ -87,8 +71,7 @@ void hfal_performance(const hfdesc_t *hd){
} }
} }
t>>=5; t>>=5;
cli_putstr_P(PSTR("\r\n init (cycles): ")); printf_P(PSTR("\tinit (cycles): %10"PRIu32"\n"), t);
printvalue(t);
t=0; t=0;
for(i=0; i<32; ++i){ for(i=0; i<32; ++i){
@ -99,8 +82,7 @@ void hfal_performance(const hfdesc_t *hd){
t += stopTimer(); t += stopTimer();
} }
t>>=5; t>>=5;
cli_putstr_P(PSTR("\r\n nextBlock (cycles): ")); printf_P(PSTR("\tnextBlock (cycles): %10"PRIu32"\n"), t);
printvalue(t);
t=0; t=0;
for(i=0; i<32; ++i){ for(i=0; i<32; ++i){
@ -111,8 +93,7 @@ void hfal_performance(const hfdesc_t *hd){
t += stopTimer(); t += stopTimer();
} }
t>>=5; t>>=5;
cli_putstr_P(PSTR("\r\n lastBlock (cycles): ")); printf_P(PSTR("\tlastBlock (cycles): %10"PRIu32"\n"), t);
printvalue(t);
t=0; t=0;
for(i=0; i<32; ++i){ for(i=0; i<32; ++i){
@ -123,8 +104,7 @@ void hfal_performance(const hfdesc_t *hd){
t += stopTimer(); t += stopTimer();
} }
t>>=5; t>>=5;
cli_putstr_P(PSTR("\r\n ctx2hash (cycles): ")); printf_P(PSTR("\tctx2hash (cycles): %10"PRIu32"\n"), t);
printvalue(t);
if(hf.free){ if(hf.free){
hf.free(&ctx); hf.free(&ctx);
@ -136,15 +116,13 @@ void hfal_stacksize(const hfdesc_t *hd){
stack_measuring_ctx_t smctx; stack_measuring_ctx_t smctx;
memcpy_P(&hf, hd, sizeof(hfdesc_t)); memcpy_P(&hf, hd, sizeof(hfdesc_t));
uint8_t ctx[hf.ctxsize_B]; uint8_t ctx[hf.ctxsize_B];
uint8_t data[(hf.blocksize_b+7)/8]; uint8_t data[(hf.blocksize_b + 7) / 8];
uint8_t digest[(hf.hashsize_b+7)/8]; uint8_t digest[(hf.hashsize_b + 7) / 8];
uint16_t t1, t2; size_t t1, t2;
if(hf.type!=HFDESC_TYPE_HASHFUNCTION) if(hf.type!=HFDESC_TYPE_HASHFUNCTION)
return; return;
cli_putstr_P(PSTR("\r\n\r\n === ")); printf_P(PSTR("\n === %S stack-usage ===\n"), hf.name);
cli_putstr_P(hf.name);
cli_putstr_P(PSTR(" stack-usage === "));
cli(); cli();
stack_measure_init(&smctx, PATTERN_A); stack_measure_init(&smctx, PATTERN_A);
@ -155,9 +133,8 @@ void hfal_stacksize(const hfdesc_t *hd){
t2 = stack_measure_final(&smctx); t2 = stack_measure_final(&smctx);
sei(); sei();
t1 = (t1>t2)?t1:t2; t1 = (t1 > t2) ? t1 : t2;
cli_putstr_P(PSTR("\r\n init (bytes): ")); printf_P(PSTR("\tinit (bytes): %10"PRIu16"\n"), t1);
printvalue((unsigned long)t1);
cli(); cli();
stack_measure_init(&smctx, PATTERN_A); stack_measure_init(&smctx, PATTERN_A);
@ -168,9 +145,8 @@ void hfal_stacksize(const hfdesc_t *hd){
t2 = stack_measure_final(&smctx); t2 = stack_measure_final(&smctx);
sei(); sei();
t1 = (t1>t2)?t1:t2; t1 = (t1 > t2) ? t1 : t2;
cli_putstr_P(PSTR("\r\n nextBlock (bytes): ")); printf_P(PSTR("\tnextBlock (bytes): %10"PRIu16"\n"), t1);
printvalue((unsigned long)t1);
cli(); cli();
stack_measure_init(&smctx, PATTERN_A); stack_measure_init(&smctx, PATTERN_A);
@ -181,9 +157,8 @@ void hfal_stacksize(const hfdesc_t *hd){
t2 = stack_measure_final(&smctx); t2 = stack_measure_final(&smctx);
sei(); sei();
t1 = (t1>t2)?t1:t2; t1 = (t1 > t2) ? t1 : t2;
cli_putstr_P(PSTR("\r\n lastBlock (bytes): ")); printf_P(PSTR("\tlastBlock (bytes): %10"PRIu16"\n"), t1);
printvalue((unsigned long)t1);
cli(); cli();
stack_measure_init(&smctx, PATTERN_A); stack_measure_init(&smctx, PATTERN_A);
@ -195,8 +170,7 @@ void hfal_stacksize(const hfdesc_t *hd){
sei(); sei();
t1 = (t1>t2)?t1:t2; t1 = (t1>t2)?t1:t2;
cli_putstr_P(PSTR("\r\n ctx2hash (bytes): ")); printf_P(PSTR("\tctx2hash (bytes): %10"PRIu16"\n"));
printvalue((unsigned long)t1);
if(hf.free){ if(hf.free){
hf.free(&ctx); hf.free(&ctx);
@ -208,7 +182,7 @@ void hfal_performance_multiple(const hfdesc_t *const *hd_list){
for(;;){ for(;;){
hd = (void*)pgm_read_word(hd_list); hd = (void*)pgm_read_word(hd_list);
if(!hd){ if(!hd){
cli_putstr_P(PSTR("\r\n\r\n End of performance figures\r\n")); puts_P(PSTR("\n End of performance figures\n"));
return; return;
} }
hfal_performance(hd); hfal_performance(hd);

16
test_src/main-arcfour-test.c
View File

@ -45,8 +45,7 @@ void testrun_nessie_arcfour(void){
} }
void testrun_performance_arcfour(void){ void testrun_performance_arcfour(void){
uint64_t t; uint32_t t;
char str[16];
uint8_t key[16]; uint8_t key[16];
arcfour_ctx_t ctx; arcfour_ctx_t ctx;
@ -55,21 +54,16 @@ void testrun_performance_arcfour(void){
memset(key, 0, 16); memset(key, 0, 16);
uart0_flush();
startTimer(1); startTimer(1);
arcfour_init(key, 16, &ctx); arcfour_init(key, 16, &ctx);
t = stopTimer(); t = stopTimer();
cli_putstr_P(PSTR("\r\n\tctx-gen time: ")); printf_P(PSTR("\tctx-gen time: %10"PRIu32"\n"), t);
ultoa((unsigned long)t, str, 10); uart0_flush();
cli_putstr(str);
startTimer(1); startTimer(1);
arcfour_gen(&ctx); arcfour_gen(&ctx);
t = stopTimer(); t = stopTimer();
cli_putstr_P(PSTR("\r\n\tencrypt time: ")); printf_P(PSTR("\tencrypt time: %10"PRIu32"\n"), t);
ultoa((unsigned long)t, str, 10);
cli_putstr(str);
cli_putstr_P(PSTR("\r\n"));
} }

34
test_src/performance_test.c
View File

@ -31,7 +31,7 @@
#include <avr/io.h> #include <avr/io.h>
#include <avr/interrupt.h> #include <avr/interrupt.h>
#include <avr/pgmspace.h> #include <avr/pgmspace.h>
#include "cli.h" #include <stdio.h>
#include "performance_test.h" #include "performance_test.h"
@ -43,21 +43,20 @@
static volatile uint32_t ovfcounter; static volatile uint32_t ovfcounter;
static uint16_t const_overhead=0; static uint16_t const_overhead = 0;
static uint16_t int_overhead=0; static uint16_t int_overhead = 0;
ISR(TIMER1_OVF_vect){ ISR(TIMER1_OVF_vect){
ovfcounter++; ++ovfcounter;
} }
void calibrateTimer(void){ void calibrateTimer(void){
volatile uint8_t i=0;
startTimer(1); startTimer(1);
stopTimer(); stopTimer();
const_overhead = TCNT1; const_overhead = TCNT1;
startTimer(1); startTimer(1);
TCNT1=0xFFFE; TCNT1 = 0xFFFE;
i++; asm("nop");
stopTimer(); stopTimer();
int_overhead = TCNT1; int_overhead = TCNT1;
} }
@ -85,27 +84,12 @@ void getOverhead(uint16_t *constoh, uint16_t *intoh){
*intoh = int_overhead; *intoh = int_overhead;
} }
void print_time_P(PGM_P s, uint64_t t){ void print_time_P(PGM_P s, uint32_t t){
char sv[16]; printf_P(PSTR("%S%11"PRIu32), t);
uint8_t c;
cli_putstr_P(PSTR("\r\n"));
cli_putstr_P(s);
ultoa((unsigned long)t, sv, 10);
for(c=strlen(sv); c<11; ++c){
cli_putc(' ');
}
cli_putstr(sv);
} }
void print_overhead(void){ void print_overhead(void){
char str[16]; printf_P(PSTR("\n=== benchmark ===\n\tconst overhead: %7"PRIu16"\n\tinterrupt overhead: %7"PRIu16"\n"), const_overhead, int_overhead);
cli_putstr_P(PSTR("\r\n\r\n=== benchmark ==="));
utoa(const_overhead, str, 10);
cli_putstr_P(PSTR("\r\n\tconst overhead: "));
cli_putstr(str);
utoa(int_overhead, str, 10);
cli_putstr_P(PSTR("\r\n\tinterrupt overhead: "));
cli_putstr(str);
} }

2
test_src/performance_test.h
View File

@ -33,7 +33,7 @@ void startTimer(uint8_t granularity);
uint64_t stopTimer(void); uint64_t stopTimer(void);
void getOverhead(uint16_t *constoh, uint16_t *intoh); void getOverhead(uint16_t *constoh, uint16_t *intoh);
void print_time_P(PGM_P s, uint64_t t); void print_time_P(PGM_P s, uint32_t t);
void print_overhead(void); void print_overhead(void);
#endif /*PERFORMANCE_TEST_H_*/ #endif /*PERFORMANCE_TEST_H_*/