counted-float 1.0.1__py3-none-any.whl

counted_float/_core/counting/models/_flop_weights.py

@@ -0,0 +1,85 @@
+from __future__ import annotations
+
+import math
+from typing import Iterable
+
+from pydantic import field_serializer, field_validator
+
+from ._base import MyBaseModel
+from ._flop_type import FlopType
+
+
+class FlopWeights(MyBaseModel):
+    weights: dict[FlopType, float | int]
+
+    # -------------------------------------------------------------------------
+    #  Helpers
+    # -------------------------------------------------------------------------
+    def round(self) -> FlopWeights:
+        """Round all weights to the nearest integer, with minimum of 1."""
+        return FlopWeights(
+            weights={k: max(1, round(v)) for k, v in self.weights.items()},
+        )
+
+    # -------------------------------------------------------------------------
+    #  Validation
+    # -------------------------------------------------------------------------
+    @field_validator("weights")
+    @classmethod
+    def check_all_flop_types_present(cls, v: dict[FlopType, float | int]) -> dict[FlopType, float | int]:
+        # make sure all FlopType enum members are present
+        missing = [member for member in FlopType if member not in v]
+        if missing:
+            raise ValueError(f"Missing weights for flop types: {missing}")
+        return v
+
+    @field_serializer("weights")
+    def serialize_weights(self, weights: dict[FlopType, float | int]) -> dict[str, float | int]:
+        # make sure we serialize using the enum values as keys
+        return {k.value: v for k, v in weights.items()}
+
+    # -------------------------------------------------------------------------
+    #  Custom visualization
+    # -------------------------------------------------------------------------
+    def show(self):
+        print("{")
+        for k, v in self.weights.items():
+            if isinstance(v, float):
+                print(f"    {k.long_name()}".ljust(40) + f": {v:9.5f}")
+            else:
+                print(f"    {k.long_name()}".ljust(40) + f": {v:>4}")
+        print("}")
+
+    # -------------------------------------------------------------------------
+    #  Factory methods
+    # -------------------------------------------------------------------------
+    @classmethod
+    def as_geo_mean(cls, all_flop_weights: Iterable[FlopWeights]) -> FlopWeights:
+        """Computes geo-mean of a collection of FlopWeights instances."""
+        all_flop_weights = list(all_flop_weights)
+        return FlopWeights(
+            weights={
+                flop_type: pow(
+                    math.prod(fw.weights[flop_type] for fw in all_flop_weights),
+                    1 / len(all_flop_weights),
+                )  # take geometric mean of all weights for this flop_type
+                for flop_type in FlopType
+            }
+        )
+
+    @classmethod
+    def from_abs_flop_costs(cls, flop_costs: dict[FlopType, float]) -> FlopWeights:
+        """
+        Computes FlopWeights based on absolute costs (in clock cycles, nanoseconds, ...) of each flop type.
+        As a reference duration, we take the geometric mean of the costs for EQUALS, ADD, SUB, and MUL operations.
+        """
+
+        # step 1) compute reference duration
+        ref_cost = (
+            flop_costs[FlopType.EQUALS] * flop_costs[FlopType.ADD] * flop_costs[FlopType.SUB] * flop_costs[FlopType.MUL]
+        ) ** (1 / 4)
+
+        # step 2) normalize and construct FlopWeights object
+        return FlopWeights(
+            weights={flop_type: flop_cost / ref_cost for flop_type, flop_cost in flop_costs.items()},
+        )

counted_float/_core/counting/models/_flops_benchmark_result.py

@@ -0,0 +1,69 @@
+from __future__ import annotations
+
+from ._base import MyBaseModel
+from ._flop_type import FlopType
+from ._flop_weights import FlopWeights
+
+
+# =================================================================================================
+#  Flops Benchmark Metadata
+# =================================================================================================
+class SystemInfo(MyBaseModel):
+    platform_processor: str
+    platform_machine: str
+    platform_system: str
+    platform_release: str
+    platform_python_version: str
+    platform_python_implementation: str
+    platform_python_compiler: str
+    psutil_cpu_count_logical: int
+    psutil_cpu_count_physical: int
+
+
+class BenchmarkSettings(MyBaseModel):
+    array_size: int
+    n_runs_total: int
+    n_runs_warmup: int
+    n_seconds_per_run_target: float
+
+
+# =================================================================================================
+#  Main Flops Benchmark Information
+# =================================================================================================
+class Quantiles(MyBaseModel):
+    """Class to represent a fixed set of quantiles of an (empirical) distribution."""
+
+    q25: float
+    q50: float
+    q75: float
+
+
+class FlopsBenchmarkDurations(MyBaseModel):
+    # baseline + flops benchmarking results in nanoseconds per <array_size> flops
+    baseline: Quantiles
+    flops: dict[FlopType, Quantiles]
+
+
+class FlopsBenchmarkResults(MyBaseModel):
+    system_info: SystemInfo
+    benchmark_settings: BenchmarkSettings
+    results_ns: FlopsBenchmarkDurations
+
+    @property
+    def flop_weights(self) -> FlopWeights:
+        """
+        Returns normalized weights for each flop type based on the benchmark results.
+           1) first of all, we only consider median values of the benchmark results
+           2) compute duration for each flop type _minus_ baseline duration per <array_size> flops
+           3) convert to flop weights by taking a few simple flop types as reference (see FlopWeights implementation)
+        """
+
+        # step 1) collect median values for all results
+        median_baseline_ns = self.results_ns.baseline.q50
+        median_flops_ns = {k: v.q50 for k, v in self.results_ns.flops.items()}
+
+        # step 2) surplus durations for each flop type, on top of baseline duration
+        flop_durations_ns = {flop_type: median_flops_ns[flop_type] - median_baseline_ns for flop_type in FlopType}
+
+        # step 3) convert to FlopWeights
+        return FlopWeights.from_abs_flop_costs(flop_costs=flop_durations_ns)

counted_float/_core/counting/models/_fpu_instruction.py

@@ -0,0 +1,22 @@
+from counted_float._core._backwards_compat import StrEnum
+
+
+class FPUInstruction(StrEnum):
+    """
+    Enum of relevant x87 FPU instructions.
+    Background:
+      - [FIL] "Simply FPU", by Raymond Filiatreault, available at: https://masm32.com/masmcode/rayfil/tutorial/index.html
+    """
+
+    FABS = "FABS"  # absolute value of float
+    FCHS = "FCHS"  # change sign of float
+    FCOM = "FCOM"  # compare two floats (a == b, a > b, a < b)
+    FTST = "FTST"  # test if float is zero (a >= 0)
+    FRNDINT = "FRNDINT"  # round float to integer (ceil or floor)
+    FADD = "FADD"  # addition of two floats (a + b)
+    FSUB = "FSUB"  # subtraction of two floats (a - b)
+    FMUL = "FMUL"  # multiplication of two floats (a * b)
+    FDIV = "FDIV"  # division of two floats (a / b)
+    FSQRT = "FSQRT"  # square root of float (sqrt(a))
+    F2XM1 = "F2XM1"  # 2 raised to the power of float minus 1 (2**a - 1)
+    FYL2X = "FYL2X"  # logarithm base 2 of float (log2(a))

counted_float/_core/counting/models/_fpu_specs.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+
+import math
+
+from pydantic import field_validator
+
+from . import FlopType
+from ._base import MyBaseModel
+from ._flop_weights import FlopWeights
+from ._fpu_instruction import FPUInstruction
+
+
+class Latency(MyBaseModel):
+    min_cycles: int
+    max_cycles: int
+
+    def geo_mean(self) -> float:
+        """Calculate the geometric mean of min and max cycles."""
+        return math.sqrt(self.min_cycles * self.max_cycles)
+
+
+class InstructionLatencies(MyBaseModel):
+    """Provides FPU instruction latency (in min/max processor cycles) per flop type."""
+
+    latencies: dict[FPUInstruction, Latency]
+
+    # -------------------------------------------------------------------------
+    #  Helpers
+    # -------------------------------------------------------------------------
+    @property
+    def flop_weights(self) -> FlopWeights:
+        """
+        Calculates estimated flop weights based on instruction latencies.
+
+        Note that some FPU instructions (e.g. FCOM) correspond to multiple flop types and some flop types (e.g. a^b)
+        consist of multiple FPU instructions.
+
+        Background:
+          - [FIL] "Simply FPU", by Raymond Filiatreault, available at: https://masm32.com/masmcode/rayfil/tutorial/index.html
+
+        | Math operation              | FPU instruction              | Comment               |
+        |-----------------------------|------------------------------|-----------------------|
+        | abs(a)                      | `FABS`                       |                       |
+        | -a                          | `FCHS`                       |                       |
+        | a==b, a>=b, a>b             | `FCOM`                       |                       |
+        | a>0, a>=0, a==0             | `FTST`                       |                       |
+        | round(a), floor(a), ceil(a) | `FRNDINT`                    | See [FIL], chapter 8  |
+        | a+b                         | `FADD`                       |                       |
+        | a-b                         | `FSUB`                       |                       |
+        | a*b                         | `FMUL`                       |                       |
+        | a/b                         | `FDIV`                       |                       |
+        | sqrt(a)                     | `FSQRT`                      |                       |
+        | log2(a)                     | `FYL2X`                      |                       |
+        | 2^a                         | > `F2XM1`                    | See [FIL], chapter 11 |
+        | a^b                         | > `FYL2X` + `F2XM1` + `FMUL` | See [FIL], chapter 11 |
+        """
+
+        # step 1) take geo_mean of all instruction latencies
+        lat = {k: v.geo_mean() for k, v in self.latencies.items()}
+
+        # step 2) convert instruction latencies to estimated flop costs
+        I = FPUInstruction
+        est_flop_type_latencies = {
+            FlopType.ABS: lat[I.FABS],
+            FlopType.MINUS: lat[I.FCHS],
+            FlopType.EQUALS: lat[I.FCOM],
+            FlopType.GTE: lat[I.FCOM],
+            FlopType.LTE: lat[I.FCOM],
+            FlopType.CMP_ZERO: lat[I.FTST],
+            FlopType.RND: lat[I.FRNDINT],
+            FlopType.ADD: lat[I.FADD],
+            FlopType.SUB: lat[I.FSUB],
+            FlopType.MUL: lat[I.FMUL],
+            FlopType.DIV: lat[I.FDIV],
+            FlopType.SQRT: lat[I.FSQRT],
+            FlopType.POW2: lat[I.F2XM1],
+            FlopType.LOG2: lat[I.FYL2X],
+            FlopType.POW: lat[I.F2XM1] + lat[I.FYL2X] + lat[I.FMUL],  # a^b = 2^(b*log2(a))
+        }
+
+        # step 3) convert to normalized FlopWeights by using a few simple flop types as reference (see FlopWeights)
+        return FlopWeights.from_abs_flop_costs(est_flop_type_latencies)
+
+    # -------------------------------------------------------------------------
+    #  Validation
+    # -------------------------------------------------------------------------
+    @field_validator("latencies")
+    @classmethod
+    def check_all_instructions_present(cls, v: dict[FPUInstruction, Latency]) -> dict[FPUInstruction, Latency]:
+        # make sure all FPUInstruction enum members are present
+        missing = [member for member in FPUInstruction if member not in v]
+        if missing:
+            raise ValueError(f"Missing latencies for FPU instructions: {missing}")
+        return v

counted_float/_core/data/benchmarks/apple_m3_max.json

@@ -0,0 +1,103 @@
+{
+    "system_info": {
+        "platform_processor": "arm",
+        "platform_machine": "arm64",
+        "platform_system": "Darwin",
+        "platform_release": "24.5.0",
+        "platform_python_version": "3.13.5",
+        "platform_python_implementation": "CPython",
+        "platform_python_compiler": "Clang 20.1.4 ",
+        "psutil_cpu_count_logical": 16,
+        "psutil_cpu_count_physical": 16
+    },
+    "benchmark_settings": {
+        "array_size": 1000,
+        "n_runs_total": 30,
+        "n_runs_warmup": 10,
+        "n_seconds_per_run_target": 0.5
+    },
+    "results_ns": {
+        "baseline": {
+            "q25": 180.70256378127044,
+            "q50": 181.9446176139497,
+            "q75": 183.10434616173248
+        },
+        "flops": {
+            "abs(x)": {
+                "q25": 284.28075017907906,
+                "q50": 292.3296343924162,
+                "q75": 296.61165546013325
+            },
+            "x>=0": {
+                "q25": 300.14336262601694,
+                "q50": 303.58112640145805,
+                "q75": 306.1948869947011
+            },
+            "round(x)": {
+                "q25": 298.31250819549473,
+                "q50": 304.39334992215333,
+                "q75": 311.7635501410813
+            },
+            "-x": {
+                "q25": 314.0143053880841,
+                "q50": 318.967762723343,
+                "q75": 325.5434245996779
+            },
+            "x==y": {
+                "q25": 319.24691665128887,
+                "q50": 322.4171760496964,
+                "q75": 327.6530252090009
+            },
+            "x>=y": {
+                "q25": 314.5796205515281,
+                "q50": 325.89943547082476,
+                "q75": 334.41104676760983
+            },
+            "x<=y": {
+                "q25": 318.20367539805585,
+                "q50": 321.12704488008126,
+                "q75": 329.7065581012761
+            },
+            "x+y": {
+                "q25": 312.08389463997486,
+                "q50": 319.3948649650657,
+                "q75": 326.92923334349905
+            },
+            "x-y": {
+                "q25": 313.18114328243973,
+                "q50": 320.7397985073316,
+                "q75": 330.6903906826164
+            },
+            "x*y": {
+                "q25": 316.74533056524433,
+                "q50": 321.116820553393,
+                "q75": 327.94291060846274
+            },
+            "sqrt(x)": {
+                "q25": 432.3789304009608,
+                "q50": 436.45438936204613,
+                "q75": 440.62596066215315
+            },
+            "x/y": {
+                "q25": 481.98645275049824,
+                "q50": 482.9500509728068,
+                "q75": 487.07500098437885
+            },
+            "2^x": {
+                "q25": 1772.9965944238375,
+                "q50": 1775.0265760379637,
+                "q75": 1780.0759553768837
+            },
+            "log2(x)": {
+                "q25": 2149.927421080074,
+                "q50": 2160.9350300536785,
+                "q75": 2175.8008708926454
+            },
+            "x^y": {
+                "q25": 6551.587641746191,
+                "q50": 6571.279149427383,
+                "q75": 6581.455023997079
+            }
+        }
+    }
+}

counted_float/_core/data/benchmarks/intel_i5_7200u.json

@@ -0,0 +1,103 @@
+{
+    "system_info": {
+        "platform_processor": "Intel64 Family 6 Model 142 Stepping 9, GenuineIntel",
+        "platform_machine": "AMD64",
+        "platform_system": "Windows",
+        "platform_release": "10",
+        "platform_python_version": "3.11.7",
+        "platform_python_implementation": "CPython",
+        "platform_python_compiler": "MSC v.1916 64 bit (AMD64)",
+        "psutil_cpu_count_logical": 4,
+        "psutil_cpu_count_physical": 2
+    },
+    "benchmark_settings": {
+        "array_size": 1000,
+        "n_runs_total": 30,
+        "n_runs_warmup": 10,
+        "n_seconds_per_run_target": 0.5
+    },
+    "results_ns": {
+        "baseline": {
+            "q25": 1211.1493417753495,
+            "q50": 1307.2530382631453,
+            "q75": 1391.3488203907768
+        },
+        "flops": {
+            "abs(x)": {
+                "q25": 1623.6614903570153,
+                "q50": 2170.525467066671,
+                "q75": 2724.9706170025684
+            },
+            "x>=0": {
+                "q25": 1539.4815340210503,
+                "q50": 1718.7036334858058,
+                "q75": 1827.9410638004579
+            },
+            "round(x)": {
+                "q25": 1457.0065953300357,
+                "q50": 1558.30311733864,
+                "q75": 1676.8450343779364
+            },
+            "-x": {
+                "q25": 1488.868161557058,
+                "q50": 1653.2690554752812,
+                "q75": 2280.2974533618644
+            },
+            "x==y": {
+                "q25": 1655.6262344708268,
+                "q50": 1830.172356557723,
+                "q75": 2088.9087756789663
+            },
+            "x>=y": {
+                "q25": 1655.6262344708268,
+                "q50": 1830.172356557723,
+                "q75": 2088.9087756789663
+            },
+            "x<=y": {
+                "q25": 1655.6262344708268,
+                "q50": 1830.172356557723,
+                "q75": 2088.9087756789663
+            },
+            "x+y": {
+                "q25": 1828.5074110467942,
+                "q50": 1974.5484596185097,
+                "q75": 2606.3806091903493
+            },
+            "x-y": {
+                "q25": 2567.297889164987,
+                "q50": 2764.450908060443,
+                "q75": 2965.6867371143035
+            },
+            "x*y": {
+                "q25": 1938.423746030986,
+                "q50": 2426.1415206122474,
+                "q75": 2827.0604978328874
+            },
+            "sqrt(x)": {
+                "q25": 2796.6202473232133,
+                "q50": 3066.6651003148763,
+                "q75": 3364.2090685415774
+            },
+            "x/y": {
+                "q25": 3163.277772962583,
+                "q50": 3299.2498172624,
+                "q75": 3442.890645108403
+            },
+            "2^x": {
+                "q25": 5315.585060615009,
+                "q50": 5658.201618089246,
+                "q75": 5906.3237367433785
+            },
+            "log2(x)": {
+                "q25": 7495.219774272615,
+                "q50": 8732.827433259092,
+                "q75": 9181.92753987244
+            },
+            "x^y": {
+                "q25": 13072.297712832518,
+                "q50": 13953.353992510196,
+                "q75": 14935.083207864303
+            }
+        }
+    }
+}

counted_float/_core/data/benchmarks/intel_i7_1265u.json

@@ -0,0 +1,103 @@
+{
+    "system_info": {
+        "platform_processor": "x86_64",
+        "platform_machine": "x86_64",
+        "platform_system": "Linux",
+        "platform_release": "5.15.0-94-generic",
+        "platform_python_version": "3.11.7",
+        "platform_python_implementation": "CPython",
+        "platform_python_compiler": "GCC 11.2.0",
+        "psutil_cpu_count_logical": 12,
+        "psutil_cpu_count_physical": 10
+    },
+    "benchmark_settings": {
+        "array_size": 1000,
+        "n_runs_total": 30,
+        "n_runs_warmup": 10,
+        "n_seconds_per_run_target": 0.5
+    },
+    "results_ns": {
+        "baseline": {
+            "q25": 235.7368871299203,
+            "q50": 239.26947187715905,
+            "q75": 250.43910989369024
+        },
+        "flops": {
+            "abs(x)": {
+                "q25": 326.23165256790696,
+                "q50": 341.8612340923687,
+                "q75": 350.5939730837959
+            },
+            "x>=0": {
+                "q25": 345.9860542847383,
+                "q50": 358.6503587550384,
+                "q75": 375.0537641284386
+            },
+            "round(x)": {
+                "q25": 605.9442359172265,
+                "q50": 612.7025683853096,
+                "q75": 620.0276949348317
+            },
+            "-x": {
+                "q25": 315.60999507080516,
+                "q50": 339.95131526516184,
+                "q75": 354.72383671394783
+            },
+            "x==y": {
+                "q25": 346.00513584372237,
+                "q50": 357.30622388854283,
+                "q75": 381.494968611982
+            },
+            "x>=y": {
+                "q25": 346.00513584372237,
+                "q50": 357.30622388854283,
+                "q75": 381.494968611982
+            },
+            "x<=y": {
+                "q25": 346.00513584372237,
+                "q50": 357.30622388854283,
+                "q75": 381.494968611982
+            },
+            "x+y": {
+                "q25": 313.6741648425307,
+                "q50": 319.53220110357825,
+                "q75": 327.70202468480556
+            },
+            "x-y": {
+                "q25": 311.7566818406692,
+                "q50": 336.3151218017174,
+                "q75": 348.1148053939487
+            },
+            "x*y": {
+                "q25": 319.8723732623861,
+                "q50": 327.4367509736013,
+                "q75": 335.91731357456
+            },
+            "sqrt(x)": {
+                "q25": 841.512485126231,
+                "q50": 844.3625917757934,
+                "q75": 853.6490636271077
+            },
+            "x/y": {
+                "q25": 1045.5432577829022,
+                "q50": 1063.5378522257229,
+                "q75": 1075.5049646159168
+            },
+            "2^x": {
+                "q25": 2193.125961022153,
+                "q50": 2200.297127195724,
+                "q75": 2211.858485396869
+            },
+            "log2(x)": {
+                "q25": 4101.653464795643,
+                "q50": 4128.668137169114,
+                "q75": 4285.959186784487
+            },
+            "x^y": {
+                "q25": 8503.688381994434,
+                "q50": 8536.172727211253,
+                "q75": 8557.370575449291
+            }
+        }
+    }
+}

counted_float/_core/data/specs/amd_zen4_r9_7900x.json

@@ -0,0 +1,52 @@
+{
+    "latencies": {
+        "FABS": {
+            "min_cycles": 1,
+            "max_cycles": 1
+        },
+        "FCHS": {
+            "min_cycles": 1,
+            "max_cycles": 1
+        },
+        "FCOM": {
+            "min_cycles": 7,
+            "max_cycles": 7
+        },
+        "FTST": {
+            "min_cycles": 7,
+            "max_cycles": 7
+        },
+        "FRNDINT": {
+            "min_cycles": 5,
+            "max_cycles": 5
+        },
+        "FADD": {
+            "min_cycles": 7,
+            "max_cycles": 7
+        },
+        "FSUB": {
+            "min_cycles": 7,
+            "max_cycles": 7
+        },
+        "FMUL": {
+            "min_cycles": 7,
+            "max_cycles": 7
+        },
+        "FDIV": {
+            "min_cycles": 15,
+            "max_cycles": 15
+        },
+        "FSQRT": {
+            "min_cycles": 25,
+            "max_cycles": 25
+        },
+        "F2XM1": {
+            "min_cycles": 50,
+            "max_cycles": 60
+        },
+        "FYL2X": {
+            "min_cycles": 40,
+            "max_cycles": 60
+        }
+    }
+}