tools/crypto/tcrypt/tcrypt_speed_compare.py

   1 #!/usr/bin/env python3
   2 # SPDX-License-Identifier: GPL-2.0
   3 #
   4 # Copyright (C) xFusion Digital Technologies Co., Ltd., 2023
   5 #
   6 # Author: Wang Jinchao <wangjinchao@xfusion.com>
   7 #
   8 """
   9 A tool for comparing tcrypt speed test logs.
  10
  11 Please note that for such a comparison, stability depends
  12 on whether we allow frequency to float or pin the frequency.
  13
  14 Both support tests for operations within one second and
  15 cycles of operation.
  16 For example, use it in the bash script below.
  17
  18 ```bash
  19 #!/bin/bash
  20
  21 # log file prefix
  22 seq_num=0
  23
  24 # When sec=0, it will perform cycle tests;
  25 # otherwise, it indicates the duration of a single test
  26 sec=0
  27 num_mb=8
  28 mode=211
  29
  30 # base speed test
  31 lsmod | grep pcrypt && modprobe -r pcrypt
  32 dmesg -C
  33 modprobe tcrypt alg="pcrypt(rfc4106(gcm(aes)))" type=3
  34 modprobe tcrypt mode=${mode} sec=${sec} num_mb=${num_mb}
  35 dmesg > ${seq_num}_base_dmesg.log
  36
  37 # new speed test
  38 lsmod | grep pcrypt && modprobe -r pcrypt
  39 dmesg -C
  40 modprobe tcrypt alg="pcrypt(rfc4106(gcm(aes)))" type=3
  41 modprobe tcrypt mode=${mode} sec=${sec} num_mb=${num_mb}
  42 dmesg > ${seq_num}_new_dmesg.log
  43 lsmod | grep pcrypt && modprobe -r pcrypt
  44
  45 tools/crypto/tcrypt/tcrypt_speed_compare.py \
  46     ${seq_num}_base_dmesg.log \
  47     ${seq_num}_new_dmesg.log  \
  48         >${seq_num}_compare.log
  49 grep 'average' -A2 -B0 --group-separator="" ${seq_num}_compare.log
  50 ```
  51 """
  52
  53 import sys
  54 import re
  55
  56
  57 def parse_title(line):
  58     pattern = r'tcrypt: testing speed of (.*?) (encryption|decryption)'
  59     match = re.search(pattern, line)
  60     if match:
  61         alg = match.group(1)
  62         op = match.group(2)
  63         return alg, op
  64     else:
  65         return "", ""
  66
  67
  68 def parse_item(line):
  69     pattern_operations = r'\((\d+) bit key, (\d+) byte blocks\): (\d+) operations'
  70     pattern_cycles = r'\((\d+) bit key, (\d+) byte blocks\): 1 operation in (\d+) cycles'
  71     match = re.search(pattern_operations, line)
  72     if match:
  73         res = {
  74             "bit_key": int(match.group(1)),
  75             "byte_blocks": int(match.group(2)),
  76             "operations": int(match.group(3)),
  77         }
  78         return res
  79
  80     match = re.search(pattern_cycles, line)
  81     if match:
  82         res = {
  83             "bit_key": int(match.group(1)),
  84             "byte_blocks": int(match.group(2)),
  85             "cycles": int(match.group(3)),
  86         }
  87         return res
  88
  89     return None
  90
  91
  92 def parse(filepath):
  93     result = {}
  94     alg, op = "", ""
  95     with open(filepath, 'r') as file:
  96         for line in file:
  97             if not line:
  98                 continue
  99             _alg, _op = parse_title(line)
 100             if _alg:
 101                 alg, op = _alg, _op
 102                 if alg not in result:
 103                     result[alg] = {}
 104                 if op not in result[alg]:
 105                     result[alg][op] = []
 106                 continue
 107             parsed_result = parse_item(line)
 108             if parsed_result:
 109                 result[alg][op].append(parsed_result)
 110     return result
 111
 112
 113 def merge(base, new):
 114     merged = {}
 115     for alg in base.keys():
 116         merged[alg] = {}
 117         for op in base[alg].keys():
 118             if op not in merged[alg]:
 119                 merged[alg][op] = []
 120             for index in range(len(base[alg][op])):
 121                 merged_item = {
 122                     "bit_key": base[alg][op][index]["bit_key"],
 123                     "byte_blocks": base[alg][op][index]["byte_blocks"],
 124                 }
 125                 if "operations" in base[alg][op][index].keys():
 126                     merged_item["base_ops"] = base[alg][op][index]["operations"]
 127                     merged_item["new_ops"] = new[alg][op][index]["operations"]
 128                 else:
 129                     merged_item["base_cycles"] = base[alg][op][index]["cycles"]
 130                     merged_item["new_cycles"] = new[alg][op][index]["cycles"]
 131
 132                 merged[alg][op].append(merged_item)
 133     return merged
 134
 135
 136 def format(merged):
 137     for alg in merged.keys():
 138         for op in merged[alg].keys():
 139             base_sum = 0
 140             new_sum = 0
 141             differ_sum = 0
 142             differ_cnt = 0
 143             print()
 144             hlen = 80
 145             print("="*hlen)
 146             print(f"{alg}")
 147             print(f"{' '*(len(alg)//3) + op}")
 148             print("-"*hlen)
 149             key = ""
 150             if "base_ops" in merged[alg][op][0]:
 151                 key = "ops"
 152                 print(f"bit key | byte blocks | base ops    | new ops     | differ(%)")
 153             else:
 154                 key = "cycles"
 155                 print(f"bit key | byte blocks | base cycles | new cycles  | differ(%)")
 156             for index in range(len(merged[alg][op])):
 157                 item = merged[alg][op][index]
 158                 base_cnt = item[f"base_{key}"]
 159                 new_cnt = item[f"new_{key}"]
 160                 base_sum += base_cnt
 161                 new_sum += new_cnt
 162                 differ = round((new_cnt - base_cnt)*100/base_cnt, 2)
 163                 differ_sum += differ
 164                 differ_cnt += 1
 165                 bit_key = item["bit_key"]
 166                 byte_blocks = item["byte_blocks"]
 167                 print(
 168                     f"{bit_key:<7} | {byte_blocks:<11} | {base_cnt:<11} | {new_cnt:<11} | {differ:<8}")
 169             average_speed_up = "{:.2f}".format(differ_sum/differ_cnt)
 170             ops_total_speed_up = "{:.2f}".format(
 171                 (base_sum - new_sum) * 100 / base_sum)
 172             print('-'*hlen)
 173             print(f"average differ(%s)    | total_differ(%)")
 174             print('-'*hlen)
 175             print(f"{average_speed_up:<21} | {ops_total_speed_up:<10}")
 176             print('='*hlen)
 177
 178
 179 def main(base_log, new_log):
 180     base = parse(base_log)
 181     new = parse(new_log)
 182     merged = merge(base, new)
 183     format(merged)
 184
 185
 186 if __name__ == "__main__":
 187     if len(sys.argv) != 3:
 188         print(f"usage: {sys.argv[0]} base_log new_log")
 189         exit(-1)
 190     main(sys.argv[1], sys.argv[2])