enum_bench.py

import pyperf
from cuda.bindings._internal._fast_enum import FastEnum


class BenchEnum(FastEnum):
    ELEM_0 = 0
    ELEM_1 = 1
    ELEM_2 = 2
    ELEM_3 = 3
    ELEM_4 = 4
    ELEM_5 = 5
    ELEM_6 = 6
    ELEM_7 = 7
    ELEM_8 = 8
    ELEM_9 = 9
    ELEM_10 = 10
    ELEM_11 = 11
    ELEM_12 = 12
    ELEM_13 = 13
    ELEM_14 = 14
    ELEM_15 = 15
    ELEM_16 = 16
    ELEM_17 = 17
    ELEM_18 = 18
    ELEM_19 = 19
    ELEM_20 = 20
    ELEM_21 = 21
    ELEM_22 = 22
    ELEM_23 = 23
    ELEM_24 = 24
    ELEM_25 = 25
    ELEM_26 = 26
    ELEM_27 = 27
    ELEM_28 = 28
    ELEM_29 = 29
    ELEM_30 = 30
    ELEM_31 = 31


TEST_ELEM = BenchEnum.ELEM_15
TEST_STR = "ELEM_15"


def bench_get_int(loops):
    t0 = pyperf.perf_counter()
    for _ in range(loops):
        int(TEST_ELEM)
    return pyperf.perf_counter() - t0


def bench_get_int_whole(loops):
    t0 = pyperf.perf_counter()
    for _ in range(loops):
        int(BenchEnum.ELEM_15)
    return pyperf.perf_counter() - t0


def bench_match(loops, s):
    t0 = pyperf.perf_counter()
    for _ in range(loops):
        match s:
            case "ELEM_0":
                result = 0
            case "ELEM_1":
                result = 1
            case "ELEM_2":
                result = 2
            case "ELEM_3":
                result = 3
            case "ELEM_4":
                result = 4
            case "ELEM_5":
                result = 5
            case "ELEM_6":
                result = 6
            case "ELEM_7":
                result = 7
            case "ELEM_8":
                result = 8
            case "ELEM_9":
                result = 9
            case "ELEM_10":
                result = 10
            case "ELEM_11":
                result = 11
            case "ELEM_12":
                result = 12
            case "ELEM_13":
                result = 13
            case "ELEM_14":
                result = 14
            case "ELEM_15":
                result = 15
            case "ELEM_16":
                result = 16
            case "ELEM_17":
                result = 17
            case "ELEM_18":
                result = 18
            case "ELEM_19":
                result = 19
            case "ELEM_20":
                result = 20
            case "ELEM_21":
                result = 21
            case "ELEM_22":
                result = 22
            case "ELEM_23":
                result = 23
            case "ELEM_24":
                result = 24
            case "ELEM_25":
                result = 25
            case "ELEM_26":
                result = 26
            case "ELEM_27":
                result = 27
            case "ELEM_28":
                result = 28
            case "ELEM_29":
                result = 29
            case "ELEM_30":
                result = 30
            case "ELEM_31":
                result = 31
    return pyperf.perf_counter() - t0


_lookup = {f"ELEM_{i}": i for i in range(32)}


def bench_dict(loops, s):
    t0 = pyperf.perf_counter()
    for _ in range(loops):
        _lookup[s]
    return pyperf.perf_counter() - t0


def bench_if_elif(loops, s):
    t0 = pyperf.perf_counter()
    for _ in range(loops):
        if s == "ELEM_0":
            result = 0
        elif s == "ELEM_1":
            result = 1
        elif s == "ELEM_2":
            result = 2
        elif s == "ELEM_3":
            result = 3
        elif s == "ELEM_4":
            result = 4
        elif s == "ELEM_5":
            result = 5
        elif s == "ELEM_6":
            result = 6
        elif s == "ELEM_7":
            result = 7
        elif s == "ELEM_8":
            result = 8
        elif s == "ELEM_9":
            result = 9
        elif s == "ELEM_10":
            result = 10
        elif s == "ELEM_11":
            result = 11
        elif s == "ELEM_12":
            result = 12
        elif s == "ELEM_13":
            result = 13
        elif s == "ELEM_14":
            result = 14
        elif s == "ELEM_15":
            result = 15
        elif s == "ELEM_16":
            result = 16
        elif s == "ELEM_17":
            result = 17
        elif s == "ELEM_18":
            result = 18
        elif s == "ELEM_19":
            result = 19
        elif s == "ELEM_20":
            result = 20
        elif s == "ELEM_21":
            result = 21
        elif s == "ELEM_22":
            result = 22
        elif s == "ELEM_23":
            result = 23
        elif s == "ELEM_24":
            result = 24
        elif s == "ELEM_25":
            result = 25
        elif s == "ELEM_26":
            result = 26
        elif s == "ELEM_27":
            result = 27
        elif s == "ELEM_28":
            result = 28
        elif s == "ELEM_29":
            result = 29
        elif s == "ELEM_30":
            result = 30
        elif s == "ELEM_31":
            result = 31
    return pyperf.perf_counter() - t0


def bench_getattr(loops, s):
    t0 = pyperf.perf_counter()
    for _ in range(loops):
        int(getattr(BenchEnum, s))
    return pyperf.perf_counter() - t0


if __name__ == "__main__":
    runner = pyperf.Runner()
    runner.bench_time_func("get_int_from_element", bench_get_int)
    runner.bench_time_func("get_int_from_whole", bench_get_int_whole)
    runner.bench_time_func("match_str_to_int", bench_match, TEST_STR)
    runner.bench_time_func("dict_str_to_int", bench_dict, TEST_STR)
    runner.bench_time_func("if_elif_str_to_int", bench_if_elif, TEST_STR)
    runner.bench_time_func("getattr_str_to_int", bench_getattr, TEST_STR)

enum_bench.txt

get_int_from_element: Mean +- std dev: 16.2 ns +- 0.9 ns
get_int_from_whole: Mean +- std dev: 22.3 ns +- 0.5 ns
match_str_to_int: Mean +- std dev: 82.9 ns +- 4.4 ns
dict_str_to_int: Mean +- std dev: 15.4 ns +- 0.6 ns
if_elif_str_to_int: Mean +- std dev: 76.6 ns +- 4.0 ns
getattr_str_to_int: Mean +- std dev: 29.7 ns +- 1.0 ns