counted-float 0.9.2__tar.gz → 0.9.3__tar.gz

{counted_float-0.9.2 → counted_float-0.9.3}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: counted-float
-Version: 0.9.2
+Version: 0.9.3
 Summary: Count floating-point operations in Python code & benchmark relative flop costs.
 Project-URL: Source, https://github.com/bertpl/counted-float
-Project-URL: ChangeLog, https://github.com/bertpl/counted-float/blob/develop/RELEASE_NOTES.md
+Project-URL: ChangeLog, https://github.com/bertpl/counted-float/blob/develop/CHANGELOG.md
 Project-URL: Issues, https://github.com/bertpl/counted-float/issues
 Project-URL: Roadmap, https://github.com/bertpl/counted-float/milestones
 License-File: LICENSE
@@ -21,9 +21,9 @@ Description-Content-Type: text/markdown
 
 <!--START_SECTION:images-->
 ![shields.io-python-versions](https://img.shields.io/badge/python-3.10%20%7C%203.11%20%7C%203.12%20%7C%203.13-blue)
-![genbadge-test-count](https://bertpl.github.io/counted-float/version_artifacts/v0.9.2/badge-test-count.svg)
-![genbadge-test-coverage](https://bertpl.github.io/counted-float/version_artifacts/v0.9.2/badge-coverage.svg)
-![counted_float logo](https://bertpl.github.io/counted-float/version_artifacts/v0.9.2/splash.webp)
+![genbadge-test-count](https://bertpl.github.io/counted-float/version_artifacts/v0.9.3/badge-test-count.svg)
+![genbadge-test-coverage](https://bertpl.github.io/counted-float/version_artifacts/v0.9.3/badge-coverage.svg)
+![counted_float logo](https://bertpl.github.io/counted-float/version_artifacts/v0.9.3/splash.webp)
 <!--END_SECTION:images-->
 
 # counted-float
@@ -148,7 +148,10 @@ counts.total_count()         # 2
 ## 2.3. Weighted FLOP counting
 
 The `counted_float` package contains a set of default, built-in FLOP weights, based on both empirical measurements
-and theoretical estimates of the relative cost of different floating point operations.
+and theoretical estimates of the relative cost of different floating point operations. 
+
+See [fpu_data_sources.md](https://github.com/bertpl/counted-float/tree/develop/docs/analysis_methodology.md) for
+rationale behind choice of data sources and methodology.
 
 ```
 >>> from counted_float.config import get_flop_weights

{counted_float-0.9.2 → counted_float-0.9.3}/README.md

@@ -1,8 +1,8 @@
 <!--START_SECTION:images-->
 ![shields.io-python-versions](https://img.shields.io/badge/python-3.10%20%7C%203.11%20%7C%203.12%20%7C%203.13-blue)
-![genbadge-test-count](https://bertpl.github.io/counted-float/version_artifacts/v0.9.2/badge-test-count.svg)
-![genbadge-test-coverage](https://bertpl.github.io/counted-float/version_artifacts/v0.9.2/badge-coverage.svg)
-![counted_float logo](https://bertpl.github.io/counted-float/version_artifacts/v0.9.2/splash.webp)
+![genbadge-test-count](https://bertpl.github.io/counted-float/version_artifacts/v0.9.3/badge-test-count.svg)
+![genbadge-test-coverage](https://bertpl.github.io/counted-float/version_artifacts/v0.9.3/badge-coverage.svg)
+![counted_float logo](https://bertpl.github.io/counted-float/version_artifacts/v0.9.3/splash.webp)
 <!--END_SECTION:images-->
 
 # counted-float
@@ -127,7 +127,10 @@ counts.total_count()         # 2
 ## 2.3. Weighted FLOP counting
 
 The `counted_float` package contains a set of default, built-in FLOP weights, based on both empirical measurements
-and theoretical estimates of the relative cost of different floating point operations.
+and theoretical estimates of the relative cost of different floating point operations. 
+
+See [fpu_data_sources.md](https://github.com/bertpl/counted-float/tree/develop/docs/analysis_methodology.md) for
+rationale behind choice of data sources and methodology.
 
 ```
 >>> from counted_float.config import get_flop_weights

{counted_float-0.9.2 → counted_float-0.9.3}/counted_float/__init__.py

@@ -8,7 +8,6 @@ from ._core.models import (
     FlopsBenchmarkResults,
     FlopType,
     FlopWeights,
-    FPUInstruction,
     Quantiles,
     SystemInfo,
 )
@@ -23,7 +22,6 @@ __all__ = [
     "FlopsBenchmarkResults",
     "FlopType",
     "FlopWeights",
-    "FPUInstruction",
     "PauseFlopCounting",
     "Quantiles",
     "SystemInfo",

{counted_float-0.9.2 → counted_float-0.9.3}/counted_float/_core/counting/_builtin_data.py

@@ -3,10 +3,10 @@ from __future__ import annotations
 import math
 from importlib.resources import files
 
-from pydantic import ValidationError
+from pydantic import BaseModel, ValidationError
 from rich.console import Console
 
-from counted_float._core.models import FlopsBenchmarkResults, FlopType, FlopWeights, InstructionLatencies
+from counted_float._core.models import FlopsBenchmarkResults, FlopWeights, InstructionLatencies
 
 DATA_PACKAGE = "counted_float.data"
 
@@ -64,17 +64,8 @@ class BuiltInData:
     def benchmarks(cls) -> dict[str, FlopsBenchmarkResults]:
         return {
             key: FlopsBenchmarkResults.model_validate_json(json_str)
-            for key, json_str in _load_json_files_as_dict(files(f"{DATA_PACKAGE}.benchmarks")).items()
-        }
-
-    # -------------------------------------------------------------------------
-    #  Specs
-    # -------------------------------------------------------------------------
-    @classmethod
-    def specs(cls) -> dict[str, InstructionLatencies]:
-        return {
-            key: InstructionLatencies.model_validate_json(json_str)
-            for key, json_str in _load_json_files_as_dict(files(f"{DATA_PACKAGE}.specs")).items()
+            for key, json_str in _load_json_files_as_dict(files(f"{DATA_PACKAGE}")).items()
+            if "benchmark" in key
         }
 
     # -------------------------------------------------------------------------
@@ -146,16 +137,27 @@ def _construct_flop_weights_from_json_str(json_str: str) -> FlopWeights:
     """
     Construct a FlopWeights instance from a JSON string, where the JSON string can represent either...
       - FlopsBenchmarkResults
-      - InstructionLatencies
+      - InstructionLatencies_<x>
     :param json_str: (str) JSON string representing either of the aforementioned data structures.
     :return: FlopWeights instance extracted from the input data.
     """
 
     # try all supported classes, all of which have a .flop_weights property
-    for pydantic_cls in [FlopsBenchmarkResults, InstructionLatencies]:
+    return _deserialize_as_any_pydantic_class(
+        json_str,
+        [
+            FlopsBenchmarkResults,
+            InstructionLatencies,
+        ],
+    ).flop_weights()
+
+
+def _deserialize_as_any_pydantic_class(json_str: str, pydantic_classes: list[type[BaseModel]]):
+    # try all supported classes
+    for pydantic_cls in pydantic_classes:
         try:
             obj = pydantic_cls.model_validate_json(json_str)
-            return obj.flop_weights
+            return obj
         except ValidationError:
             continue
 

{counted_float-0.9.2 → counted_float-0.9.3}/counted_float/_core/models/__init__.py

@@ -8,6 +8,9 @@ from ._flops_benchmark_result import (
     FlopsBenchmarkResults,
     SystemInfo,
 )
-from ._fpu_instruction import FPUInstruction
-from ._fpu_specs import InstructionLatencies
+from ._instruction_latencies import (
+    InstructionLatencies,
+    InstructionLatencies_ARM,
+    InstructionLatencies_SSE2,
+)
 from ._micro_benchmark_result import MicroBenchmarkResult, Quantiles, SingleRunResult

{counted_float-0.9.2 → counted_float-0.9.3}/counted_float/_core/models/_flop_weights.py

@@ -38,11 +38,11 @@ class FlopWeights(MyBaseModel):
     # -------------------------------------------------------------------------
     @field_validator("weights")
     @classmethod
-    def check_all_flop_types_present(cls, v: dict[FlopType, float | int]) -> dict[FlopType, float | int]:
+    def ensure_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}")
+        for flop_type in FlopType:
+            if flop_type not in v:
+                v[flop_type] = math.nan
         return v
 
     @field_serializer("weights")
@@ -103,14 +103,8 @@ class FlopWeights(MyBaseModel):
         As a reference duration, we take the geometric mean of the costs for EQUALS, ADD, SUB, and MUL operations.
         """
 
-        # step 1) compute reference duration based on 4 simple flop types that should be about equally fast on most CPUs
-        ref_values = [
-            flop_costs[FlopType.EQUALS],
-            flop_costs[FlopType.ADD],
-            flop_costs[FlopType.SUB],
-            flop_costs[FlopType.MUL],
-        ]
-        ref_cost = geo_mean([v for v in ref_values if not math.isnan(v)])  # ignore any missing data
+        # step 1) compute reference duration based on 1 simple flop type (SUB, MUL and a few others are usually very close)
+        ref_cost = flop_costs[FlopType.ADD]
 
         # step 2) normalize and construct FlopWeights object
         return FlopWeights(

{counted_float-0.9.2 → counted_float-0.9.3}/counted_float/_core/models/_flops_benchmark_result.py

@@ -43,7 +43,6 @@ class FlopsBenchmarkResults(MyBaseModel):
     benchmark_settings: BenchmarkSettings
     results_ns: FlopsBenchmarkDurations
 
-    @property
     def flop_weights(self) -> FlopWeights:
         """
         Returns normalized weights for each flop type based on the benchmark results.

counted_float-0.9.3/counted_float/_core/models/_instruction_latencies.py

@@ -0,0 +1,146 @@
+from __future__ import annotations
+
+import math
+from typing import Annotated, Literal, Union
+
+from pydantic import Field, model_validator
+
+from ._base import MyBaseModel
+from ._flop_type import FlopType
+from ._flop_weights import FlopWeights
+
+
+# =================================================================================================
+#  Single-Instruction Latency
+# =================================================================================================
+class Latency(MyBaseModel):
+    note: str = ""
+    min_cycles: float | None = None
+    max_cycles: float | None = None
+
+    def geo_mean(self) -> float:
+        """Calculate the geometric mean of min and max cycles."""
+        if (self.min_cycles is None) or (self.max_cycles is None):
+            return math.nan
+        else:
+            return math.sqrt(self.min_cycles * self.max_cycles)
+
+    @model_validator(mode="before")
+    @classmethod
+    def check_min_max_cycles(cls, values):
+        # Fill in missing values if just 1 of 2 is missing
+        #   (assuming min=max; which is making the least assumptions, as this is the case in most instructions)
+        if (values.get("min_cycles") is None) and (values.get("max_cycles") is not None):
+            values["min_cycles"] = values["max_cycles"]
+        elif (values.get("min_cycles") is not None) and (values.get("max_cycles") is None):
+            values["max_cycles"] = values["min_cycles"]
+
+        # Avoid 0 values.  (which in principle can happen in corner cases, but which confuses our analysis)
+        if values.get("min_cycles") is not None:
+            values["min_cycles"] = max(1.0, values["min_cycles"])
+        if values.get("max_cycles") is not None:
+            values["max_cycles"] = max(1.0, values["max_cycles"])
+
+        # Return processed values
+        return values
+
+
+# =================================================================================================
+#  InstructionLatencies - SSE2
+# =================================================================================================
+class InstructionLatencies_SSE2(MyBaseModel):
+    # SEE: https://github.com/bertpl/counted-float/tree/develop/counted_float/data/fpu_data_sources.md
+
+    # --- primary fields ----------------------------------
+    architecture: Literal["sse2"] = "sse2"
+
+    ANDPD: Latency = Latency()  # abs(x)
+    CVTSD2SI: Latency = Latency()  # double -> int
+    CVTSI2SD: Latency = Latency()  # int -> double
+    XORPD: Latency = Latency()  # -x
+    UCOMISD: Latency = Latency()  # x < == > y, x < == > 0    NOTE: should be ranges of UCOMISD & COMISD merged
+    MAXSD: Latency = Latency()  # max(x,y)
+    MINSD: Latency = Latency()  # min(x,y)
+    ADDSD: Latency = Latency()  # x+y
+    SUBSD: Latency = Latency()  # x-y
+    MULSD: Latency = Latency()  # x*y
+    DIVSD: Latency = Latency()  # x/y
+    SQRTSD: Latency = Latency()  # sqrt(x)
+
+    # --- helpers -----------------------------------------
+    def flop_weights(self) -> FlopWeights:
+        return FlopWeights.from_abs_flop_costs(
+            {
+                FlopType.ABS: self.ANDPD.geo_mean(),
+                FlopType.MINUS: self.XORPD.geo_mean(),
+                FlopType.EQUALS: self.UCOMISD.geo_mean(),
+                FlopType.GTE: self.UCOMISD.geo_mean(),
+                FlopType.LTE: self.UCOMISD.geo_mean(),
+                FlopType.CMP_ZERO: self.UCOMISD.geo_mean(),
+                FlopType.RND: self.CVTSD2SI.geo_mean(),
+                FlopType.ADD: self.ADDSD.geo_mean(),
+                FlopType.SUB: self.SUBSD.geo_mean(),
+                FlopType.MUL: self.MULSD.geo_mean(),
+                FlopType.DIV: self.DIVSD.geo_mean(),
+                FlopType.SQRT: self.SQRTSD.geo_mean(),
+            }
+        )
+
+
+# =================================================================================================
+#  InstructionLatencies - ARM
+# =================================================================================================
+class InstructionLatencies_ARM(MyBaseModel):
+    # SEE: https://github.com/bertpl/counted-float/tree/develop/counted_float/data/fpu_data_sources.md
+
+    # --- primary fields ----------------------------------
+    architecture: Literal["arm"] = "arm"
+
+    FABS: Latency = Latency()  # abs(x)
+    FCVTZS: Latency = Latency()  # double -> int
+    SCVTF: Latency = Latency()  # int -> double
+    FNEG: Latency = Latency()  # -x
+    FCMP: Latency = Latency()  # x < == > y, x < == > 0
+    FMAX: Latency = Latency()  # max(x,y)
+    FMIN: Latency = Latency()  # min(x,y)
+    FADD: Latency = Latency()  # x+y
+    FSUB: Latency = Latency()  # x-y
+    FMUL: Latency = Latency()  # x*y
+    FDIV: Latency = Latency()  # x/y
+    FSQRT: Latency = Latency()  # sqrt(x)
+
+    # --- helpers -----------------------------------------
+    def flop_weights(self) -> FlopWeights:
+        return FlopWeights.from_abs_flop_costs(
+            {
+                FlopType.ABS: self.FABS.geo_mean(),
+                FlopType.MINUS: self.FNEG.geo_mean(),
+                FlopType.EQUALS: self.FCMP.geo_mean(),
+                FlopType.GTE: self.FCMP.geo_mean(),
+                FlopType.LTE: self.FCMP.geo_mean(),
+                FlopType.CMP_ZERO: self.FCMP.geo_mean(),
+                FlopType.RND: self.FCVTZS.geo_mean(),
+                FlopType.ADD: self.FADD.geo_mean(),
+                FlopType.SUB: self.FSUB.geo_mean(),
+                FlopType.MUL: self.FMUL.geo_mean(),
+                FlopType.DIV: self.FDIV.geo_mean(),
+                FlopType.SQRT: self.FSQRT.geo_mean(),
+            }
+        )
+
+
+# =================================================================================================
+#  Union Class
+# =================================================================================================
+class InstructionLatencies(MyBaseModel):
+    notes: list[str] | None = [""]
+    latencies: Annotated[
+        Union[
+            InstructionLatencies_SSE2,
+            InstructionLatencies_ARM,
+        ],
+        Field(discriminator="architecture"),
+    ]
+
+    def flop_weights(self) -> FlopWeights:
+        return self.latencies.flop_weights()

{counted_float-0.9.2/counted_float/data/specs/arm → counted_float-0.9.3/counted_float/data/arm/v8_x/specs}/arm_v8_cortex_a76.json

@@ -2,51 +2,69 @@
     "notes": [
         "Data taken from:",
         "https://developer.arm.com/documentation/PJDOC-466751330-7215/latest/",
-        "FPU data processing instructions - aarch64 - exec latency",
-        "FCHS=FNEG, FTST=FCMPZ, FRNDINT=FCVT"
+        "FPU data processing instructions - aarch64 - exec latency"
     ],
     "latencies": {
+        "architecture": "arm",
         "FABS": {
+            "notes": "",
             "min_cycles": 2,
             "max_cycles": 2
         },
-        "FCHS": {
+        "FCVTZS": {
+            "notes": "",
+            "min_cycles": 4,
+            "max_cycles": 4
+        },
+        "SCVTF": {
+            "notes": "",
+            "min_cycles": 6,
+            "max_cycles": 6
+        },
+        "FNEG": {
+            "notes": "",
             "min_cycles": 2,
             "max_cycles": 2
         },
-        "FCOM": {
+        "FCMP": {
+            "notes": "",
             "min_cycles": 2,
             "max_cycles": 2
         },
-        "FTST": {
+        "FMAX": {
+            "notes": "",
             "min_cycles": 2,
             "max_cycles": 2
         },
-        "FRNDINT": {
-            "min_cycles": 3,
-            "max_cycles": 3
+        "FMIN": {
+            "notes": "",
+            "min_cycles": 2,
+            "max_cycles": 2
         },
         "FADD": {
+            "notes": "",
             "min_cycles": 2,
             "max_cycles": 2
         },
         "FSUB": {
+            "notes": "",
             "min_cycles": 2,
             "max_cycles": 2
         },
         "FMUL": {
+            "notes": "",
             "min_cycles": 3,
             "max_cycles": 3
         },
         "FDIV": {
+            "notes": "",
             "min_cycles": 7,
             "max_cycles": 15
         },
         "FSQRT": {
+            "notes": "",
             "min_cycles": 7,
             "max_cycles": 17
-        },
-        "F2XM1": null,
-        "FYL2X": null
+        }
     }
 }

counted_float-0.9.3/counted_float/data/arm/v8_x/specs/arm_v9_cortex_n1.json

@@ -0,0 +1,70 @@
+{
+    "notes": [
+        "Data taken from:",
+        "https://developer.arm.com/documentation/109896/0400/",
+        "FPU data processing instructions - aarch64 - exec latency"
+    ],
+    "latencies": {
+        "architecture": "arm",
+        "FABS": {
+            "notes": "",
+            "min_cycles": 2,
+            "max_cycles": 2
+        },
+        "FCVTZS": {
+            "notes": "",
+            "min_cycles": 4,
+            "max_cycles": 4
+        },
+        "SCVTF": {
+            "notes": "",
+            "min_cycles": 6,
+            "max_cycles": 6
+        },
+        "FNEG": {
+            "notes": "",
+            "min_cycles": 2,
+            "max_cycles": 2
+        },
+        "FCMP": {
+            "notes": "",
+            "min_cycles": 2,
+            "max_cycles": 2
+        },
+        "FMAX": {
+            "notes": "",
+            "min_cycles": 2,
+            "max_cycles": 2
+        },
+        "FMIN": {
+            "notes": "",
+            "min_cycles": 2,
+            "max_cycles": 2
+        },
+        "FADD": {
+            "notes": "",
+            "min_cycles": 2,
+            "max_cycles": 2
+        },
+        "FSUB": {
+            "notes": "",
+            "min_cycles": 2,
+            "max_cycles": 2
+        },
+        "FMUL": {
+            "notes": "",
+            "min_cycles": 3,
+            "max_cycles": 3
+        },
+        "FDIV": {
+            "notes": "",
+            "min_cycles": 7,
+            "max_cycles": 15
+        },
+        "FSQRT": {
+            "notes": "",
+            "min_cycles": 7,
+            "max_cycles": 17
+        }
+    }
+}

counted_float-0.9.3/counted_float/data/arm/v8_x/specs/arm_v9_cortex_v1.json

@@ -0,0 +1,70 @@
+{
+    "notes": [
+        "Data taken from:",
+        "https://developer.arm.com/documentation/109897/0600/",
+        "FPU data processing instructions - aarch64 - exec latency"
+    ],
+    "latencies": {
+        "architecture": "arm",
+        "FABS": {
+            "notes": "",
+            "min_cycles": 2,
+            "max_cycles": 2
+        },
+        "FCVTZS": {
+            "notes": "",
+            "min_cycles": 3,
+            "max_cycles": 3
+        },
+        "SCVTF": {
+            "notes": "",
+            "min_cycles": 3,
+            "max_cycles": 3
+        },
+        "FNEG": {
+            "notes": "",
+            "min_cycles": 2,
+            "max_cycles": 2
+        },
+        "FCMP": {
+            "notes": "",
+            "min_cycles": 2,
+            "max_cycles": 2
+        },
+        "FMAX": {
+            "notes": "",
+            "min_cycles": 2,
+            "max_cycles": 2
+        },
+        "FMIN": {
+            "notes": "",
+            "min_cycles": 2,
+            "max_cycles": 2
+        },
+        "FADD": {
+            "notes": "",
+            "min_cycles": 2,
+            "max_cycles": 2
+        },
+        "FSUB": {
+            "notes": "",
+            "min_cycles": 2,
+            "max_cycles": 2
+        },
+        "FMUL": {
+            "notes": "",
+            "min_cycles": 3,
+            "max_cycles": 3
+        },
+        "FDIV": {
+            "notes": "",
+            "min_cycles": 7,
+            "max_cycles": 15
+        },
+        "FSQRT": {
+            "notes": "",
+            "min_cycles": 7,
+            "max_cycles": 16
+        }
+    }
+}

{counted_float-0.9.2/counted_float/data/specs/arm → counted_float-0.9.3/counted_float/data/arm/v8_x/specs}/arm_v9_cortex_x1.json

@@ -2,51 +2,69 @@
     "notes": [
         "Data taken from:",
         "https://developer.arm.com/documentation/102174/latest/",
-        "FPU data processing instructions - aarch64 - exec latency",
-        "FCHS=FNEG, FTST=FCMPZ, FRNDINT=FCVT"
+        "FPU data processing instructions - aarch64 - exec latency"
     ],
     "latencies": {
+        "architecture": "arm",
         "FABS": {
+            "notes": "",
             "min_cycles": 2,
             "max_cycles": 2
         },
-        "FCHS": {
+        "FCVTZS": {
+            "notes": "",
+            "min_cycles": 3,
+            "max_cycles": 3
+        },
+        "SCVTF": {
+            "notes": "",
+            "min_cycles": 3,
+            "max_cycles": 3
+        },
+        "FNEG": {
+            "notes": "",
             "min_cycles": 2,
             "max_cycles": 2
         },
-        "FCOM": {
+        "FCMP": {
+            "notes": "",
             "min_cycles": 2,
             "max_cycles": 2
         },
-        "FTST": {
+        "FMAX": {
+            "notes": "",
             "min_cycles": 2,
             "max_cycles": 2
         },
-        "FRNDINT": {
-            "min_cycles": 3,
-            "max_cycles": 3
+        "FMIN": {
+            "notes": "",
+            "min_cycles": 2,
+            "max_cycles": 2
         },
         "FADD": {
+            "notes": "",
             "min_cycles": 2,
             "max_cycles": 2
         },
         "FSUB": {
+            "notes": "",
             "min_cycles": 2,
             "max_cycles": 2
         },
         "FMUL": {
+            "notes": "",
             "min_cycles": 3,
             "max_cycles": 3
         },
         "FDIV": {
+            "notes": "",
             "min_cycles": 7,
             "max_cycles": 15
         },
         "FSQRT": {
+            "notes": "",
             "min_cycles": 7,
             "max_cycles": 16
-        },
-        "F2XM1": null,
-        "FYL2X": null
+        }
     }
 }