# Protocol Buffers - Google's data interchange format # Copyright 2026 Google LLC. All rights reserved. # # Use of this source code is governed by a BSD-style # license that can be found in the LICENSE file or at # https://developers.google.com/open-source/licenses/bsd """Microbenchmarks for JSON format parsing and custom enum names.""" import statistics import timeit import unittest from google.protobuf import json_format from google.protobuf.json import json_enumval_custom_string_pb2 class JsonFormatBenchmark(unittest.TestCase): """Microbenchmarks for JSON format parsing.""" def test_benchmark_parse_json(self): """Benchmarks parsing of default, custom, and unknown enum names in JSON.""" default_payloads = [ '{"armor":"ARMOR_GREAT_HELM"}', '{"armor":"ARMOR_GAUNTLET"}', '{"armor":"ARMOR_PLATE"}', '{"armor":"ARMOR_COIF"}', '{"armor":"ARMOR_PAULDRON"}', '{"armor":"ARMOR_SABATON"}', '{"armor":"ARMOR_HACHI_MAI_DO"}', ] custom_payloads = [ '{"armor":"gr8 helm"}', '{"armor":"a\\"b"}', '{"armor":"\\"plate\\""}', '{"armor":""}', '{"armor":"p\\taul\\ndron"}', '{"armor":"sabaton"}', '{"armor":"8"}', ] unknown_payloads = [ '{"armor":"UNKNOWN_1"}', '{"armor":"UNKNOWN_2"}', '{"armor":"UNKNOWN_3"}', '{"armor":"UNKNOWN_4"}', '{"armor":"UNKNOWN_5"}', '{"armor":"UNKNOWN_6"}', '{"armor":"UNKNOWN_7"}', ] repeated_default_payload = ( '{"armors":[' + ','.join( [ '"ARMOR_GREAT_HELM"', '"ARMOR_GAUNTLET"', '"ARMOR_PLATE"', '"ARMOR_COIF"', '"ARMOR_PAULDRON"', '"ARMOR_SABATON"', '"ARMOR_HACHI_MAI_DO"', ] * 14 ) + ']}' ) repeated_custom_payload = ( '{"armors":[' + ','.join( [ '"gr8 helm"', '"a\\"b"', '"\\"plate\\""', '""', '"p\\taul\\ndron"', '"sabaton"', '"8"', ] * 14 ) + ']}' ) repeated_unknown_payload = ( '{"armors":[' + ','.join( [ '"UNKNOWN_1"', '"UNKNOWN_2"', '"UNKNOWN_3"', '"UNKNOWN_4"', '"UNKNOWN_5"', '"UNKNOWN_6"', '"UNKNOWN_7"', ] * 14 ) + ']}' ) iterations = 10 trials = 100 num_parses = 10 num_items = 98 msg = json_enumval_custom_string_pb2.Knight() # Warmup phase to eliminate initial compilation/import overhead for _ in range(200): for p in custom_payloads: msg.Clear() json_format.Parse(p, msg) def run_def(): for p in default_payloads: for _ in range(num_parses): msg.Clear() json_format.Parse(p, msg) def run_cust(): for p in custom_payloads: for _ in range(num_parses): msg.Clear() json_format.Parse(p, msg) def run_unk(): for p in unknown_payloads: for _ in range(num_parses): msg.Clear() json_format.Parse(p, msg, ignore_unknown_fields=True) def run_rep_def(): for _ in range(num_parses): msg.Clear() json_format.Parse(repeated_default_payload, msg) def run_rep_cust(): for _ in range(num_parses): msg.Clear() json_format.Parse(repeated_custom_payload, msg) def run_rep_unk(): for _ in range(num_parses): msg.Clear() json_format.Parse( repeated_unknown_payload, msg, ignore_unknown_fields=True ) benchmarks = [ ( 'run_def', timeit.Timer(run_def, setup=msg.Clear), len(default_payloads) * num_parses, ), ( 'run_cust', timeit.Timer(run_cust, setup=msg.Clear), len(custom_payloads) * num_parses, ), ( 'run_unk', timeit.Timer(run_unk, setup=msg.Clear), len(unknown_payloads) * num_parses, ), ( 'run_rep_def', timeit.Timer(run_rep_def, setup=msg.Clear), num_items * num_parses, ), ( 'run_rep_cust', timeit.Timer(run_rep_cust, setup=msg.Clear), num_items * num_parses, ), ( 'run_rep_unk', timeit.Timer(run_rep_unk, setup=msg.Clear), num_items * num_parses, ), ] # Interleaved trials to minimize CPU frequency scaling / ordering bias benchmark_samples = {name: [] for name, _, _ in benchmarks} for _ in range(trials): for name, timer, num_ops_per_batch in benchmarks: total_ops = iterations * num_ops_per_batch elapsed = timer.timeit(number=iterations) benchmark_samples[name].append(elapsed * 1e6 / total_ops) def stats(samples): if len(samples) < 100: raise ValueError( f'Insufficient samples ({len(samples)}) for statistical' ' calculations. At least 100 samples are required.' ) med_val = statistics.median(samples) mean_val = statistics.mean(samples) stdev_val = statistics.stdev(samples) p99_val = statistics.quantiles(samples, n=100)[98] return p99_val, med_val, mean_val, stdev_val p99_def, med_def, mean_def, std_def = stats(benchmark_samples['run_def']) p99_cust, med_cust, mean_cust, std_cust = stats( benchmark_samples['run_cust'] ) p99_unk, med_unk, mean_unk, std_unk = stats(benchmark_samples['run_unk']) p99_rep_def, med_rep_def, mean_rep_def, std_rep_def = stats( benchmark_samples['run_rep_def'] ) p99_rep_cust, med_rep_cust, mean_rep_cust, std_rep_cust = stats( benchmark_samples['run_rep_cust'] ) p99_rep_unk, med_rep_unk, mean_rep_unk, std_rep_unk = stats( benchmark_samples['run_rep_unk'] ) print( f'\n[BENCHMARK] ParseJsonDefault: med {med_def:.2f}' f' us/op | p99 {p99_def:.2f} us/op | mean {mean_def:.2f} ±' f' {std_def:.2f} us/op' ) print( f'[BENCHMARK] ParseJsonCustom: med {med_cust:.2f} us/op' f' | p99 {p99_cust:.2f} us/op | mean {mean_cust:.2f} ± {std_cust:.2f}' ' us/op' ) print( '[BENCHMARK] ParseJsonUnknownIgnored: ' f' med {med_unk:.2f} us/op | p99 {p99_unk:.2f} us/op | mean' f' {mean_unk:.2f} ± {std_unk:.2f} us/op' ) print( '[BENCHMARK] ParseRepeatedJsonDefault: ' f' med {med_rep_def:.2f} us/item | p99 {p99_rep_def:.2f} us/item |' f' mean {mean_rep_def:.2f} ± {std_rep_def:.2f} us/item' ) print( '[BENCHMARK] ParseRepeatedJsonCustom: ' f' med {med_rep_cust:.2f} us/item | p99 {p99_rep_cust:.2f} us/item |' f' mean {mean_rep_cust:.2f} ± {std_rep_cust:.2f} us/item' ) print( '[BENCHMARK] ParseRepeatedJsonUnknownIgnored:' f' med {med_rep_unk:.2f} us/item | p99 {p99_rep_unk:.2f} us/item |' f' mean {mean_rep_unk:.2f} ± {std_rep_unk:.2f} us/item' ) if __name__ == '__main__': unittest.main()