]> git.cryptolib.org Git - avr-crypto-lib.git/blob - hfal/hfal-performance.c
[performance-reports] switching to printf
[avr-crypto-lib.git] / hfal / hfal-performance.c
1 /* hfal-performance.c */
2 /*
3     This file is part of the AVR-Crypto-Lib.
4     Copyright (C) 2009  Daniel Otte (daniel.otte@rub.de)
5
6     This program is free software: you can redistribute it and/or modify
7     it under the terms of the GNU General Public License as published by
8     the Free Software Foundation, either version 3 of the License, or
9     (at your option) any later version.
10
11     This program is distributed in the hope that it will be useful,
12     but WITHOUT ANY WARRANTY; without even the implied warranty of
13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14     GNU General Public License for more details.
15
16     You should have received a copy of the GNU General Public License
17     along with this program.  If not, see <http://www.gnu.org/licenses/>.
18 */
19 /*
20  * \file    hfal-performance.c
21  * \author  Daniel Otte
22  * \email   daniel.otte@rub.de
23  * \date    2009-05-10
24  * \license GPLv3 or later
25  *
26  */
27
28 #include <stdint.h>
29 #include <stdlib.h>
30 #include <string.h>
31 #include <stdio.h>
32 #include <avr/pgmspace.h>
33 #include "hfal-performance.h"
34 #include "hashfunction_descriptor.h"
35 #include "stack_measuring.h"
36 #include "performance_test.h"
37 #include "uart_i.h"
38
39 #define PATTERN_A 0xAA
40 #define PATTERN_B 0x55
41
42 void hfal_performance(const hfdesc_t *hd){
43         hfdesc_t hf;
44         memcpy_P(&hf, hd, sizeof(hfdesc_t));
45         uint8_t ctx[hf.ctxsize_B];
46         uint8_t data[(hf.blocksize_b+7)/8];
47         uint8_t digest[(hf.hashsize_b+7)/8];
48         uint32_t t;
49         uint8_t i;
50
51         if(hf.type!=HFDESC_TYPE_HASHFUNCTION)
52                 return;
53         calibrateTimer();
54         print_overhead();
55         printf_P(PSTR("\n\n === %S performance ===\n"
56                       "\ttype:             hashfunction\n"
57                       "\thashsize (bits):    %10"PRIu16"\n"
58                       "\tctxsize (bytes):    %10"PRIu16"\n"
59                       "\tblocksize (bits):   %10"PRIu16"\n"),
60                  hf.name, hf.hashsize_b, hf.ctxsize_B, hf.blocksize_b);
61         uart0_flush();
62         t=0;
63         for(i=0; i<32; ++i){
64                 startTimer(0);
65                 START_TIMER;
66                 hf.init(&ctx);
67                 STOP_TIMER;
68                 t += stopTimer();
69                 if(i!=31 && hf.free){
70                         hf.free(&ctx);
71                 }
72         }
73         t>>=5;
74         printf_P(PSTR("\tinit (cycles):      %10"PRIu32"\n"), t);
75
76         t=0;
77         for(i=0; i<32; ++i){
78                 startTimer(0);
79                 START_TIMER;
80                 hf.nextBlock(&ctx, data);
81                 STOP_TIMER;
82                 t += stopTimer();
83         }
84         t>>=5;
85         printf_P(PSTR("\tnextBlock (cycles): %10"PRIu32"\n"), t);
86
87         t=0;
88         for(i=0; i<32; ++i){
89                 startTimer(0);
90                 START_TIMER;
91                 hf.lastBlock(&ctx, data, 0);
92                 STOP_TIMER;
93                 t += stopTimer();
94         }
95         t>>=5;
96         printf_P(PSTR("\tlastBlock (cycles): %10"PRIu32"\n"), t);
97
98         t=0;
99         for(i=0; i<32; ++i){
100                 startTimer(0);
101                 START_TIMER;
102                 hf.ctx2hash(digest, &ctx);
103                 STOP_TIMER;
104                 t += stopTimer();
105         }
106         t>>=5;
107         printf_P(PSTR("\tctx2hash (cycles):  %10"PRIu32"\n"), t);
108
109         if(hf.free){
110                 hf.free(&ctx);
111         }
112 }
113
114 void hfal_stacksize(const hfdesc_t *hd){
115         hfdesc_t hf;
116         stack_measuring_ctx_t smctx;
117         memcpy_P(&hf, hd, sizeof(hfdesc_t));
118         uint8_t ctx[hf.ctxsize_B];
119         uint8_t data[(hf.blocksize_b + 7) / 8];
120         uint8_t digest[(hf.hashsize_b + 7) / 8];
121         size_t t1, t2;
122
123         if(hf.type!=HFDESC_TYPE_HASHFUNCTION)
124                 return;
125         printf_P(PSTR("\n === %S stack-usage ===\n"), hf.name);
126
127         cli();
128         stack_measure_init(&smctx, PATTERN_A);
129         hf.init(&ctx);
130         t1 = stack_measure_final(&smctx);
131         stack_measure_init(&smctx, PATTERN_B);
132         hf.init(&ctx);
133         t2 = stack_measure_final(&smctx);
134         sei();
135
136         t1 = (t1 > t2) ? t1 : t2;
137         printf_P(PSTR("\tinit (bytes):       %10"PRIu16"\n"), t1);
138
139         cli();
140         stack_measure_init(&smctx, PATTERN_A);
141         hf.nextBlock(&ctx, data);
142         t1 = stack_measure_final(&smctx);
143         stack_measure_init(&smctx, PATTERN_B);
144         hf.nextBlock(&ctx, data);
145         t2 = stack_measure_final(&smctx);
146         sei();
147
148         t1 = (t1 > t2) ? t1 : t2;
149         printf_P(PSTR("\tnextBlock (bytes):  %10"PRIu16"\n"), t1);
150
151         cli();
152         stack_measure_init(&smctx, PATTERN_A);
153         hf.lastBlock(&ctx, data, 0);
154         t1 = stack_measure_final(&smctx);
155         stack_measure_init(&smctx, PATTERN_B);
156         hf.lastBlock(&ctx, data, 0);
157         t2 = stack_measure_final(&smctx);
158         sei();
159
160         t1 = (t1 > t2) ? t1 : t2;
161         printf_P(PSTR("\tlastBlock (bytes):  %10"PRIu16"\n"), t1);
162
163         cli();
164         stack_measure_init(&smctx, PATTERN_A);
165         hf.ctx2hash(digest, &ctx);
166         t1 = stack_measure_final(&smctx);
167         stack_measure_init(&smctx, PATTERN_B);
168         hf.ctx2hash(digest, &ctx);
169         t2 = stack_measure_final(&smctx);
170         sei();
171
172         t1 = (t1>t2)?t1:t2;
173         printf_P(PSTR("\tctx2hash (bytes):   %10"PRIu16"\n"));
174
175         if(hf.free){
176                 hf.free(&ctx);
177         }
178 }
179
180 void hfal_performance_multiple(const hfdesc_t *const *hd_list){
181         const hfdesc_t *hd;
182         for(;;){
183                 hd = (void*)pgm_read_word(hd_list);
184                 if(!hd){
185                         puts_P(PSTR("\n End of performance figures\n"));
186                         return;
187                 }
188                 hfal_performance(hd);
189                 hfal_stacksize(hd);
190                 hd_list = (void*)((uint8_t*)hd_list + 2);
191         }
192 }
193