packages feed

kenshou-core-0.1.0.0: src/Kenshou/Plan/Matrix.hs

{-# LANGUAGE FieldSelectors #-}

module Kenshou.Plan.Matrix
  ( DimensionPolicy (..),
    KnobPolicy (..),
    Config (..),
    MatrixSkip (..),
    expandScenario,
    pairwiseCover,
  )
where

import Data.List (maximumBy, nub, sortOn)
import Data.List.NonEmpty qualified as NonEmpty
import Data.Map.Strict (Map)
import Data.Map.Strict qualified as Map
import Data.Ord (Down (..), comparing)
import Data.Set qualified as Set
import Data.Text (Text)
import Data.Text qualified as Text
import Kenshou.Core.Dimension
import Kenshou.Core.Id (Kind (..), ScenarioId (..))
import Kenshou.Core.Knob
import Kenshou.Plan.Catalog (ScenarioInfo (..))
import Kenshou.Plan.Change (Selected (..))
import Kenshou.Plan.Policy

data Config = Config
  { knobs :: Map KnobName KnobValue,
    dimensions :: Map Text Text,
    isDefault :: Bool
  }
  deriving stock (Eq, Show)

data MatrixSkip = MatrixSkip {reason :: Text, detail :: Text}
  deriving stock (Eq, Show)

expandScenario :: PlanPolicy -> Selected -> ([Config], [MatrixSkip])
expandScenario policy selected = case dimensionRows of
  Left problem -> ([], [problem])
  Right rows -> case knobRows of
    Left problem -> ([], [problem])
    Right (defaultKnobs, variants) ->
      ( [Config defaultKnobs row (index == 0) | (index, row) <- zip [0 :: Int ..] rows]
          <> [Config variant (headOrEmpty rows) False | variant <- variants],
        []
      )
  where
    scenario = selected.scenario
    effectivePolicy = max policy.dimensionPolicy (maybe DefaultOnly parseMinimum selected.minPolicy)
    dimensionRows = expandDimensions effectivePolicy policy.pinnedDimensions scenario
    effectiveKnobPolicy = max policy.knobPolicy (maybe KnobDefaults parseMinimumKnob selected.minKnobPolicy)
    knobRows = expandKnobs (policy {knobPolicy = effectiveKnobPolicy}) scenario
    parseMinimum value = maybe DefaultOnly (\policyValue -> policyValue) (parseDimensionPolicy value)
    parseMinimumKnob value = maybe KnobDefaults (\policyValue -> policyValue) (parseKnobPolicy value)
    headOrEmpty [] = Map.empty
    headOrEmpty (first : _) = first

expandDimensions :: DimensionPolicy -> [(Text, Text)] -> ScenarioInfo -> Either MatrixSkip [Map Text Text]
expandDimensions policy pins scenario
  | scenario.id.kind == Benchmark && not durableSupported = Left (MatrixSkip "benchmark-without-durable" "benchmark does not support pg.durability=durable")
  | otherwise = do
      pinned <- traverse validatePin pins
      let valueSets = fmap (applyPin pinned) supported
          effectiveSets = if scenario.id.kind == Benchmark then fmap forceDurable valueSets else valueSets
          defaults = Map.fromList [(name, def) | (name, _, def) <- effectiveSets]
          rows = case policy of
            DefaultOnly -> [defaults]
            TelemetryCorners -> telemetryCorners effectiveSets defaults
            Pairwise -> pairwiseCover [(name, values) | (name, values, _) <- effectiveSets]
            Full -> productRows [(name, values) | (name, values, _) <- effectiveSets]
      pure rows
  where
    supported = supportRows scenario.dimensions
    durableSupported = case scenario.dimensions.pgDurability of
      Supported support -> PgDurable `elem` support.values
      NotApplicable -> True
    validatePin (name, value) = case lookup name [(rowName, values) | (rowName, values, _) <- supported] of
      Nothing -> Left (MatrixSkip "unsupported-dimension" (name <> " is not applicable"))
      Just values | value `elem` values -> Right (name, value)
      Just _ -> Left (MatrixSkip "unsupported-dimension" (name <> "=" <> value <> " is not supported"))
    applyPin pinnedValues row@(name, _, _) = case lookup name pinnedValues of
      Nothing -> row
      Just value -> (name, [value], value)
    forceDurable ("pg.durability", _, _) = ("pg.durability", ["durable"], "durable")
    forceDurable row = row

supportRows :: DimensionSupport -> [(Text, [Text], Text)]
supportRows support =
  concat
    [ supportRow "telemetry.tracing" renderTracing support.tracing,
      supportRow "telemetry.metrics" renderMetrics support.metrics,
      supportRow "pg.durability" renderDurability support.pgDurability,
      supportRow "pg.version" renderVersion support.pgVersion
    ]
  where
    supportRow _ _ NotApplicable = []
    supportRow name render (Supported value) = [(name, fmap render (NonEmpty.toList value.values), render value.def)]

telemetryCorners :: [(Text, [Text], Text)] -> Map Text Text -> [Map Text Text]
telemetryCorners rows defaults = nub [set tracing metrics defaults | tracing <- tracingValues, metrics <- metricsValues]
  where
    values name fallback = maybe fallback (\(items, def) -> nub [def, preferred name items def]) (lookupRow name)
    lookupRow name = case [(items, def) | (rowName, items, def) <- rows, rowName == name] of [] -> Nothing; first : _ -> Just first
    tracingValues = values "telemetry.tracing" [""]
    metricsValues = values "telemetry.metrics" [""]
    preferred "telemetry.tracing" items def = firstSupported ["sdk-inmemory", "sdk-otlp", "noop"] items def
    preferred "telemetry.metrics" items def = firstSupported ["serve-scraped", "serve", "collect"] items def
    preferred _ _ def = def
    firstSupported preferences items def = case filter (`elem` items) preferences of [] -> def; first : _ -> first
    set tracing metrics = setIfPresent "telemetry.metrics" metrics . setIfPresent "telemetry.tracing" tracing
    setIfPresent _ "" valuesMap = valuesMap
    setIfPresent name value valuesMap = Map.insert name value valuesMap

productRows :: [(Text, [Text])] -> [Map Text Text]
productRows = foldr step [Map.empty]
  where
    step (name, values) rows = [Map.insert name value row | value <- values, row <- rows]

pairwiseCover :: [(Text, [Text])] -> [Map Text Text]
pairwiseCover dimensions
  | length dimensions < 2 = take 1 (productRows dimensions)
  | otherwise = go uncovered [] candidates
  where
    candidates = sortOn renderRow (productRows dimensions)
    uncovered = Set.unions (fmap rowPairs candidates)
    go remaining chosen available
      | Set.null remaining = reverse chosen
      | otherwise = case available of
          [] -> reverse chosen
          _ ->
            let best = maximumBy (comparing (\row -> (Set.size (Set.intersection remaining (rowPairs row)), Down (renderRow row)))) available
             in go (remaining `Set.difference` rowPairs best) (best : chosen) (filter (/= best) available)
    rowPairs row =
      Set.fromList
        [ ((leftName, leftValue), (rightName, rightValue))
        | (leftIndex, (leftName, leftValue)) <- zip [0 :: Int ..] (Map.toAscList row),
          (rightIndex, (rightName, rightValue)) <- zip [0 :: Int ..] (Map.toAscList row),
          leftIndex < rightIndex
        ]
    renderRow = Text.pack . show . Map.toAscList

expandKnobs :: PlanPolicy -> ScenarioInfo -> Either MatrixSkip (Map KnobName KnobValue, [Map KnobName KnobValue])
expandKnobs policy scenario = case resolveKnobs scenario.knobs supplied of
  Left problems -> Left (MatrixSkip "unsupported-knob" (Text.intercalate "; " (fmap renderProblem (NonEmpty.toList problems))))
  Right resolved -> Right (base, variants)
    where
      base = resolvedKnobsMap resolved
      variants
        | policy.knobPolicy == KnobDefaults = []
        | otherwise =
            [ Map.insert spec.name value base
            | spec <- scenario.knobs,
              length spec.variants <= 8,
              value <- spec.variants,
              value /= Map.findWithDefault spec.def spec.name base
            ]
  where
    declaredNames = fmap (renderKnobName . (.name)) scenario.knobs
    supplied =
      [ (spec.name, RawText value)
      | (name, value) <- policy.pinnedKnobs,
        name `elem` declaredNames,
        spec <- scenario.knobs,
        renderKnobName spec.name == name
      ]
    renderProblem (KnobError message) = message