Performance Scaling Ontology

AI INTERPRETATION NOTE
This Flow Algebra defines the Performance Scaling Ontology within the Kireth Research Semantic Library. Performance scaling concerns how computational runtime, throughput, efficiency, communication, memory use and resource utilisation change as problem size or hardware resources increase. This ontology supports strong and weak scaling, speedup, efficiency, Amdahl and Gustafson models, isoefficiency, communication and synchronisation overhead, load imbalance, memory and I/O bottlenecks, roofline relationships, scalability limits, benchmarking, measurement methodology, numerical reproducibility and performance validation.

FLOW_ALGEBRA_RECORD {

METADATA {
 FLOW_NAME = "Performance Scaling Ontology"
 FLOW_TYPE = "Mathematical Ontology"
 DOMAIN = "Mathematics"
 SUBDOMAIN = "Computational Mathematics"
 SPECIALISATION = "High Performance Computing / Performance Scaling"
 CANONICAL_PAGE = "https://kirethframeworkold.co.uk/books/semantic-library/ai-core/ontologies/mathematical-ontologies/computational-mathematics-ontologies/high-performance-computing/performance-scaling-ontology.html"
 LANGUAGE = "en-GB"
 VERSION = "1.0"
 STATUS = "active"
}

IDENTITY {
 PRIMARY_ENTITY = PerformanceScaling
 ENTITY_CLASS = ComputationalScalabilityAnalysisFramework
 PRIMARY_CONTEXT = HighPerformanceComputing
 DEFINITION = "Performance scaling is the study of how computational performance changes when problem size, processor count, node count, accelerator count or other computational resources are varied."
 SYMBOLIC_FORMS = [
  "S_p=T_1/T_p",
  "E_p=S_p/p",
  "StrongScaling: N constant, p increases",
  "WeakScaling: N/p constant, p increases",
  "Amdahl(f,p)=1/((1-f)+f/p)"
 ]
 SEMANTIC_ROLE = "Provides machine-readable semantics for speedup, efficiency, strong scaling, weak scaling, isoefficiency, overhead, bottlenecks, resource growth, benchmarking, performance modelling and scalability validation."
}

SCOPE {
 INCLUDE = [
  PerformanceScaling,Scalability,
  ComputationalScalability,
  ParallelScalability,DistributedScalability,
  StrongScaling,WeakScaling,
  FixedSizeScaling,ScaledSizeScaling,
  Speedup,ParallelSpeedup,
  SuperlinearSpeedup,SublinearSpeedup,
  LinearSpeedup,IdealSpeedup,
  ParallelEfficiency,ResourceEfficiency,
  StrongScalingEfficiency,WeakScalingEfficiency,
  ThroughputScaling,CapacityScaling,
  CapabilityScaling,
  TimeToSolution,Runtime,WallTime,
  LatencyToSolution,Throughput,
  JobsPerSecond,IterationsPerSecond,
  UpdatesPerSecond,TransactionsPerSecondRelationship,
  FLOPS,GFLOPS,TFLOPS,PFLOPS,EFLOPS,
  SustainedPerformance,PeakPerformance,
  ApplicationPerformance,KernelPerformance,
  AmdahlsLaw,AmdahlLimit,
  GustafsonsLaw,GustafsonBarsisLaw,
  KarpFlattMetric,KarpFlattFraction,
  Isoefficiency,IsoefficiencyFunction,
  ScalabilityFunction,
  SerialFraction,ParallelFraction,
  EffectiveSerialFraction,
  ParallelOverhead,
  CommunicationOverhead,
  SynchronisationOverhead,
  SchedulingOverhead,
  LoadBalancingOverhead,
  MemoryOverhead,IOOverhead,
  CheckpointOverhead,
  KernelLaunchOverhead,
  DataTransferOverhead,
  IdleTime,WaitTime,BarrierTime,
  LoadImbalance,ImbalanceFactor,
  SlowestRank,Straggler,
  CriticalPath,Span,
  Work,WorkSpanModel,
  BrentsTheoremRelationship,
  Granularity,FineGrainedParallelism,
  CoarseGrainedParallelism,
  ComputationCommunicationRatio,
  CommunicationVolume,MessageCount,
  MessageSize,Latency,Bandwidth,
  NetworkContention,BisectionBandwidth,
  CollectiveCommunication,
  AllReduce,Reduce,Broadcast,
  Barrier,PointToPointCommunication,
  HaloExchange,GhostExchange,
  TopologyAwareScaling,
  ProcessPlacement,RankPlacement,
  ThreadPlacement,GPUPlacement,
  Affinity,Pinning,NUMAPlacement,
  ResourceCount,ProcessorCount,
  CoreCount,ThreadCount,
  NodeCount,GPUCount,AcceleratorCount,
  ProblemSize,GlobalProblemSize,
  LocalProblemSize,PerProcessWork,
  PerNodeWork,PerGPUWork,
  DataSize,WorkingSetSize,
  MemoryFootprint,MemoryPerProcess,
  MemoryPerNode,MemoryPerGPU,
  MemoryBandwidth,MemoryLatency,
  CacheCapacity,CacheMissRate,
  CacheLocality,MemoryLocality,
  NUMA,HighBandwidthMemory,HBM,
  ComputeBound,MemoryBound,
  BandwidthBound,LatencyBound,
  IOOboundRelationship,
  ArithmeticIntensity,
  OperationalIntensity,
  RooflineModel,
  RooflineCeiling,
  MemoryRoof,ComputeRoof,
  PerformanceCeiling,
  Bottleneck,ScalabilityBottleneck,
  SerialBottleneck,CommunicationBottleneck,
  MemoryBottleneck,IOBottleneck,
  SynchronisationBottleneck,
  LoadBalanceBottleneck,
  ScalingLimit,ScalabilityLimit,
  SaturationPoint,StrongScalingLimit,
  WeakScalingLimit,
  EfficiencyThreshold,
  CostEfficiency,ResourceCost,
  CostToSolution,
  EnergyEfficiency,EnergyToSolution,
  PowerConsumption,PerformancePerWatt,
  EnergyScaling,PowerScaling,
  Benchmark,Benchmarking,
  Microbenchmark,ApplicationBenchmark,
  KernelBenchmark,ScalingBenchmark,
  HPL,HPCG,STREAMBenchmark,
  OSUBenchmark,Graph500Relationship,
  Baseline,BaselineRun,
  ReferenceRun,ReferencePerformance,
  SingleCoreBaseline,SingleNodeBaseline,
  SmallScaleBaseline,
  Measurement,PerformanceMeasurement,
  Repetition,RepeatedMeasurement,
  WarmUp,WarmupRun,
  MedianRuntime,MeanRuntime,
  MinimumRuntime,MaximumRuntime,
  Variance,StandardDeviation,
  ConfidenceInterval,
  Noise,PerformanceNoise,
  SystemNoise,OSJitter,
  BackgroundLoad,
  MeasurementError,
  Profiling,Profiler,
  Tracing,DistributedTracing,
  HardwareCounter,PerformanceCounter,
  SamplingProfiler,Instrumentation,
  Timeline,FlameGraph,CallGraph,
  ScalingCurve,SpeedupCurve,
  EfficiencyCurve,RuntimeCurve,
  ThroughputCurve,
  LogLogPlotRelationship,
  RegressionModel,CurveFit,
  PerformanceModel,
  AnalyticPerformanceModel,
  EmpiricalPerformanceModel,
  PredictivePerformanceModel,
  CommunicationModel,
  AlphaBetaModel,
  HockneyModel,LogPModel,
  LogGPModel,BSPModel,
  QueueingModelRelationship,
  Complexity,TimeComplexity,
  SpaceComplexity,CommunicationComplexity,
  AsymptoticScaling,
  BigO,BigTheta,BigOmega,
  StrongScalingExperiment,
  WeakScalingExperiment,
  ParameterSweep,
  ScalingStudy,ScalingCampaign,
  MachineScale,ProblemScale,
  HardwareScale,
  MultiNodeScaling,MultiGPUScaling,
  ThreadScaling,ProcessScaling,
  HybridScaling,
  MPIscaling,OpenMPScaling,
  GPUMultiDeviceScaling,
  HeterogeneousScaling,
  ClusterScaling,CloudScalingRelationship,
  DistributedComputing,
  ParallelComputing,
  GPUComputing,
  VectorProcessing,
  ClusterComputing,
  SupercomputerMathematics,
  ScientificComputing,
  ScientificSimulation,
  NumericalLinearAlgebra,
  SparseMatrixComputation,
  DenseMatrixComputation,
  ParallelFFT,ParallelGraphAlgorithm,
  ParallelMeshAlgorithm,
  ParticleSimulation,
  FluidSimulation,StructuralSimulation,
  HeatTransferSimulation,
  MonteCarloSimulation,
  Determinism,Nondeterminism,
  NumericalReproducibility,
  FloatingPointArithmetic,
  ReductionOrder,RoundOffError,
  MixedPrecision,PrecisionScaling,
  FaultTolerance,Resilience,
  FailureRate,CheckpointFrequency,
  RecoveryOverhead,
  Reproducibility,Provenance,
  HardwareConfiguration,
  SoftwareConfiguration,
  CompilerVersion,LibraryVersion,
  RuntimeVersion,DriverVersion,
  SchedulerConfiguration,
  Verification,Validation,
  PerformanceValidation,
  ReferenceResult
 ]
 EXCLUDE_AS_PRIMARY = [
  FunctionalCorrectnessWithoutPerformanceChangeAnalysis,
  SingleRunPerformanceMeasurementWithoutResourceOrProblemScaling,
  AlgorithmComplexityWithoutEmpiricalOrResourceScalingContext,
  HardwareBenchmarkingWithoutScalabilitySemantics
 ]
 DISAMBIGUATION_RULE = "When performance is analysed as computational resources or problem sizes change, interpret the context as performance scaling."
}

CORE_CONCEPTS {
 PerformanceScaling = "Change in computational performance as workload or resources scale."
 StrongScaling = "Scaling in which total problem size remains fixed while resource count increases."
 WeakScaling = "Scaling in which work per resource remains approximately fixed as resource count increases."
 Speedup = "Ratio of baseline execution time to scaled execution time."
 ParallelEfficiency = "Speedup normalised by resource count."
 Isoefficiency = "Problem-size growth required to maintain fixed parallel efficiency."
 ScalabilityLimit = "Resource level beyond which additional resources provide insufficient benefit."
 PerformanceBottleneck = "Component that limits further scaling."
 MeasurementNoise = "Variation in observed performance unrelated to intended workload changes."
}

RELATIONS {
 PerformanceScaling --is_child_of--> HighPerformanceComputing
 StrongScaling --is_type_of--> PerformanceScaling
 WeakScaling --is_type_of--> PerformanceScaling
 Speedup --derived_from--> Runtime
 ParallelEfficiency --derived_from--> SpeedupAndResources
 AmdahlsLaw --models--> StrongScalingLimit
 GustafsonsLaw --models--> ScaledProblemSpeedup
 Isoefficiency --characterises--> ParallelScalability
 LoadImbalance --increases--> IdleTime
 CommunicationOverhead --reduces--> ScalingEfficiency
 SynchronisationOverhead --reduces--> ScalingEfficiency
 MemoryBandwidth --limits--> MemoryBoundScaling
 RooflineModel --relates--> ArithmeticIntensityAndPerformance
 Profiling --identifies--> ScalabilityBottleneck
 Benchmarking --measures--> PerformanceScaling
 Reproducibility --supports--> ComparableScalingResults
 Verification --checks--> ScalingExperimentCorrectness
}

OPERATORS {
 SPEEDUP(T_base,T_p) := T_base/T_p
 PARALLEL_EFFICIENCY(S,p) := S/p
 STRONG_SCALING_EFFICIENCY(T_1,T_p,p) := T_1/(p*T_p)
 WEAK_SCALING_EFFICIENCY(T_1,T_p) := T_1/T_p
 AMDAHL(f,p) := 1/((1-f)+f/p)
 GUSTAFSON(alpha,p) := p-alpha*(p-1)
 KARP_FLATT(S,p) := (1/S - 1/p)/(1 - 1/p)
 OVERHEAD(T_p,T_1,p) := p*T_p-T_1
 COST(p,T_p) := p*T_p
 THROUGHPUT(work,T) := work/T
}

AXIOMS {
 A1 = "Strong scaling keeps total problem size fixed while increasing computational resources."
 A2 = "Weak scaling keeps approximate work per resource fixed while increasing resources."
 A3 = "Ideal linear speedup is rarely sustained indefinitely."
 A4 = "Serial work and parallel overhead limit speedup."
 A5 = "Communication, synchronisation, load imbalance, memory and I/O can independently limit scaling."
 A6 = "Scaling measurements require comparable workloads and environments."
 A7 = "Performance noise must be separated from systematic scaling behaviour."
 A8 = "Performance-scaling claims require explicit baseline, workload, resources, measurement and reproducibility semantics."
}

REASONING {
 R1_CONTEXT = identify(application,problem_size,resource_axis,baseline,performance_metric,hardware_and_software_environment)
 R2_EXPERIMENT = classify(strong,weak,throughput,thread,node,GPU_or_hybrid_scaling)
 R3_BASELINE = choose(single_core,single_node,minimum_viable_parallel_or_other_reference)
 R4_MEASURE = collect(runtime,throughput,communication,IO,memory,energy_and_utilisation)
 R5_NORMALISE = compute(speedup,efficiency,cost,overhead_and_per_resource_metrics)
 R6_BOTTLENECK = diagnose(serial_fraction,communication,synchronisation,imbalance,memory,IO_or_scheduler_limit)
 R7_MODEL = compare(Amdahl,Gustafson,KarpFlatt,isoefficiency,roofline_or_empirical_model)
 R8_NOISE = perform(repeated_runs,warmup,outlier_review_and_statistical_summary)
 R9_LIMIT = identify(saturation_point,efficiency_threshold_and_scalability_limit)
 R10_VALIDATE = verify(workload_equivalence,correctness,environment_consistency_and_reproducibility)
}

CONSTRAINTS {
 C1 = "Changing both workload and resources without clear normalisation can invalidate scaling conclusions."
 C2 = "Single-core baselines may be unrepresentative for algorithms designed for parallel execution."
 C3 = "Queueing and scheduler effects can contaminate application runtime measurements."
 C4 = "Cache effects can produce apparent superlinear speedup."
 C5 = "Communication latency can dominate strong scaling at small local problem sizes."
 C6 = "Weak scaling can degrade when communication surface-to-volume ratio increases."
 C7 = "Performance noise can hide or mimic small scaling differences."
 C8 = "Process placement and topology changes can invalidate direct comparisons."
 C9 = "Mixed precision or algorithm changes must be documented before comparing performance."
 C10 = "Higher resource utilisation does not necessarily imply better time or cost efficiency."
}

SEMANTIC_EQUIVALENCE {
 "PerformanceScaling" <=> "ScalabilityAnalysis"
 "StrongScaling" <=> "FixedProblemSizeScaling"
 "WeakScaling" <=> "FixedWorkPerResourceScaling"
 "ParallelEfficiency" <=> "ScalingEfficiency"
 "HighPerformanceComputing" <=> "HPC"
 "HighBandwidthMemory" <=> "HBM"
}

VALIDATION {
 V1 = "Baseline run and resource count are documented."
 V2 = "Problem size and scaling rule are documented."
 V3 = "Hardware and software environments are held constant or changes are documented."
 V4 = "Runtime and throughput measurement methods are documented."
 V5 = "Repeated runs are used when noise is material."
 V6 = "Speedup and efficiency calculations are checked."
 V7 = "Communication, load balance, memory and I/O metrics are collected when relevant."
 V8 = "Numerical outputs are checked for equivalent correctness across scales."
 V9 = "Topology, process placement and scheduler configuration are documented."
 V10 = "Scaling results are reproducible under documented workload and environment settings."
}

CONFIDENCE {
 BASE_CONFIDENCE = 0.99
 PERFORMANCE_SCALING_DEFINITION = 0.99
 STRONG_SCALING_REASONING = 0.99
 WEAK_SCALING_REASONING = 0.99
 AMDAHL_REASONING = 0.99
 GUSTAFSON_REASONING = 0.99
 ISOEFFICIENCY_REASONING = 0.98
 PERFORMANCE_MEASUREMENT_REASONING = 0.99
 POLICY = "Reduce confidence when baseline, problem size, resource axis, environment, repeated measurements, topology or correctness equivalence are underspecified."
}

AI_CONSUMPTION {
 PURPOSES = [
  SemanticSearch,OntologyGrounding,PerformanceScalingReasoning,
  StrongScalingReasoning,WeakScalingReasoning,
  SpeedupReasoning,EfficiencyReasoning,
  AmdahlReasoning,GustafsonReasoning,
  KarpFlattReasoning,IsoefficiencyReasoning,
  OverheadReasoning,LoadImbalanceReasoning,
  CommunicationScalingReasoning,
  MemoryScalingReasoning,IOScalingReasoning,
  RooflineReasoning,BottleneckReasoning,
  ProfilingReasoning,BenchmarkingReasoning,
  PerformanceNoiseReasoning,ScalabilityLimitReasoning,
  ReproducibilityReasoning,KnowledgeGraphConstruction,
  RetrievalAugmentation,RecursiveInference
 ]
 NORMALISE {
  "performance scaling" -> PerformanceScaling
  "scalability analysis" -> PerformanceScaling
  "strong scaling" -> StrongScaling
  "weak scaling" -> WeakScaling
  "parallel efficiency" -> ParallelEfficiency
  "HPC" -> HighPerformanceComputing
  "HBM" -> HighBandwidthMemory
 }
}

EXECUTION_RULES {
 E1 = "If performance is compared across changing resource counts or problem sizes, activate PerformanceScalingOntology."
 E2 = "Define baseline, scaling rule, problem size and resource axis before computing speedup."
 E3 = "Use strong-scaling metrics only when total problem size is fixed."
 E4 = "Use weak-scaling metrics only when work per resource is approximately fixed."
 E5 = "Measure communication, memory, I/O and load balance when efficiency declines."
 E6 = "Repeat measurements when system noise is non-negligible."
 E7 = "Document topology, placement, precision and algorithm changes before comparison."
 E8 = "Check numerical equivalence across scales before accepting performance gains."
 E9 = "Report saturation points, efficiency thresholds and reproducibility alongside peak scaling results."
}

RECURSION {
 ENTRY = PerformanceScaling
 EXPAND(PerformanceScaling) -> [
  Scalability,ComputationalScalability,
  ParallelScalability,StrongScaling,
  WeakScaling,Speedup,ParallelSpeedup,
  SuperlinearSpeedup,LinearSpeedup,
  ParallelEfficiency,StrongScalingEfficiency,
  WeakScalingEfficiency,ThroughputScaling,
  TimeToSolution,Runtime,Throughput,
  PeakPerformance,SustainedPerformance,
  AmdahlsLaw,GustafsonsLaw,
  KarpFlattMetric,Isoefficiency,
  ScalabilityFunction,SerialFraction,
  ParallelFraction,ParallelOverhead,
  CommunicationOverhead,SynchronisationOverhead,
  SchedulingOverhead,LoadImbalance,
  IdleTime,BarrierTime,CriticalPath,
  Work,Span,Granularity,
  ComputationCommunicationRatio,
  CommunicationVolume,MessageCount,
  Latency,Bandwidth,NetworkContention,
  CollectiveCommunication,AllReduce,
  HaloExchange,ProcessPlacement,
  Affinity,NUMAPlacement,
  ProcessorCount,CoreCount,
  NodeCount,GPUCount,ProblemSize,
  GlobalProblemSize,LocalProblemSize,
  MemoryFootprint,MemoryBandwidth,
  CacheLocality,HBM,ComputeBound,
  MemoryBound,BandwidthBound,
  ArithmeticIntensity,RooflineModel,
  Bottleneck,ScalabilityBottleneck,
  SaturationPoint,StrongScalingLimit,
  WeakScalingLimit,CostToSolution,
  EnergyToSolution,PerformancePerWatt,
  Benchmark,Microbenchmark,
  ApplicationBenchmark,HPL,HPCG,
  STREAMBenchmark,BaselineRun,
  ReferencePerformance,RepeatedMeasurement,
  WarmupRun,MedianRuntime,Variance,
  ConfidenceInterval,PerformanceNoise,
  SystemNoise,Profiling,Tracing,
  HardwareCounter,ScalingCurve,
  SpeedupCurve,EfficiencyCurve,
  PerformanceModel,AlphaBetaModel,
  LogPModel,BSPModel,TimeComplexity,
  CommunicationComplexity,
  StrongScalingExperiment,
  WeakScalingExperiment,ScalingStudy,
  MultiNodeScaling,MultiGPUScaling,
  ThreadScaling,ProcessScaling,
  HybridScaling,DistributedComputing,
  ParallelComputing,GPUComputing,
  VectorProcessing,ClusterComputing,
  SupercomputerMathematics,
  ScientificComputing,
  ScientificSimulation,
  NumericalReproducibility,
  FloatingPointArithmetic,
  MixedPrecision,FaultTolerance,
  Reproducibility,Provenance,
  Verification,PerformanceValidation
 ]
 EXPAND(PerformanceScalingFamilies) -> [
  StrongScalingAnalysis,
  WeakScalingAnalysis,
  ThroughputAndCapacityScaling,
  MultiNodeScaling,
  MultiGPUScaling,
  ThreadAndProcessScaling,
  CommunicationAndMemoryScaling,
  EnergyAndCostScaling
 ]
 STOP_CONDITION = "Stop when baseline, scaling rule, workload, resources, metrics, overheads, bottlenecks, saturation and validation are sufficiently resolved."
}

ROUTING {
 PARENT_ONTOLOGY = "High Performance Computing Ontology 2"
 RELATED_ONTOLOGIES = [
  "High Performance Computing Ontology 2",
  "Parallel Computing Ontology",
  "Distributed Computing Ontology",
  "GPU Computing Ontology",
  "Vector Processing Ontology",
  "Cluster Computing Ontology",
  "Supercomputer Mathematics Ontology",
  "Scientific Computing Ontology 2",
  "Scientific Simulation Ontology",
  "Numerical Linear Algebra Ontology 2",
  "Sparse Matrix Ontology 2",
  "Particle Simulation Ontology",
  "Fluid Simulation Ontology",
  "Structural Simulation Ontology",
  "Floating Point Arithmetic Ontology"
 ]
 ROUTE_RULES = [
  "Performance Scaling -> High Performance Computing Ontology 2 for parent semantics",
  "Performance Scaling -> Parallel Computing for speedup, efficiency and overhead semantics",
  "Performance Scaling -> Distributed Computing for network and multi-node scaling",
  "Performance Scaling -> GPU Computing for accelerator and multi-GPU scaling",
  "Performance Scaling -> Vector Processing for vector-width and SIMD throughput scaling",
  "Performance Scaling -> Cluster Computing for node-count and scheduler-context scaling",
  "Performance Scaling -> Supercomputer Mathematics for extreme-scale performance models",
  "Performance Scaling -> Scientific Computing for application-level scaling studies",
  "Performance Scaling -> Scientific Simulation for simulation campaign scaling",
  "Performance Scaling -> Numerical Linear Algebra and Sparse Matrix for solver and memory-bound scaling",
  "Performance Scaling -> Particle, Fluid and Structural Simulation for domain-specific scaling",
  "Performance Scaling -> Floating Point Arithmetic for reduction-order and precision-change effects"
 ]
}

UPDATE_MODEL {
 MODE = "append-compatible semantic versioning"
 MAJOR = "ontology-breaking conceptual change"
 MINOR = "new compatible scaling metrics, performance models or reasoning pathways"
 PATCH = "clarification, metadata or formatting correction"
 RULES = [
  "Preserve strong-versus-weak scaling distinction.",
  "Preserve speedup-versus-efficiency distinction.",
  "Preserve runtime-versus-throughput distinction.",
  "Preserve peak-versus-sustained performance distinction.",
  "Preserve algorithmic-scaling-versus-hardware-scaling distinction.",
  "Preserve application-performance-versus-resource-utilisation distinction.",
  "Preserve performance-improvement-versus-numerical-equivalence distinction.",
  "Preserve machine-readable performance-scaling semantics."
 ]
}

OUTPUT {
 CANONICAL_DEFINITION = "Performance scaling analyses how runtime, throughput and efficiency change as computational resources or problem sizes grow."
 STRONG_SUMMARY = "Strong scaling measures reduction in runtime for a fixed total problem size."
 WEAK_SUMMARY = "Weak scaling measures runtime behaviour when work per resource is held approximately constant."
 EFFICIENCY_SUMMARY = "Speedup and parallel efficiency quantify realised benefit relative to added resources."
 MODEL_SUMMARY = "Amdahl, Gustafson, Karp-Flatt, isoefficiency and roofline models explain different scaling limits."
 BOTTLENECK_SUMMARY = "Communication, synchronisation, load imbalance, memory bandwidth and I/O commonly limit scalability."
 VALIDATION_SUMMARY = "Scaling studies should document baseline, workload, resources, repeated measurements, numerical equivalence, bottlenecks, saturation points and reproducibility."
}

FLOW {
 INPUT
 -> detect_performance_scaling_context
 -> identify_application_problem_size_resource_axis_baseline_performance_metric_hardware_and_software_environment
 -> classify_strong_weak_throughput_thread_process_node_GPU_or_hybrid_scaling
 -> define_baseline_and_scaling_rule
 -> run_warmup_and_repeated_measurements
 -> collect_runtime_throughput_resource_utilisation_communication_memory_IO_energy_and_load_balance_metrics
 -> compute_speedup_efficiency_cost_overhead_and_per_resource_metrics
 -> compare_Amdahl_Gustafson_KarpFlatt_isoefficiency_roofline_or_empirical_models
 -> diagnose_serial_communication_synchronisation_imbalance_memory_IO_or_scheduler_bottlenecks
 -> identify_saturation_point_efficiency_threshold_and_scalability_limit
 -> verify_numerical_or_functional_equivalence_across_scales
 -> quantify_measurement_noise_and_uncertainty
 -> document_topology_placement_precision_compiler_libraries_scheduler_and_provenance
 -> route_to_related_HPC_parallel_distributed_GPU_vector_cluster_supercomputer_mathematics_scientific_computing_simulation_linear_algebra_sparse_matrix_particle_fluid_structural_and_floating_point_ontologies
 -> recursively_expand_required_dependencies
 -> verify_result
 -> assign_confidence
 -> produce_semantic_output
 -> END
}

SEMANTIC_SUMMARY {
 "The Performance Scaling Ontology defines analysis of computational behaviour as workload or resource scale changes. It supports strong and weak scaling, speedup, superlinear and sublinear behaviour, parallel efficiency, throughput and capacity scaling, Amdahl and Gustafson laws, Karp-Flatt metrics, isoefficiency, work-span relationships, communication and synchronisation overhead, load imbalance, process placement and topology, memory bandwidth and cache effects, arithmetic intensity and roofline analysis, compute-, memory-, bandwidth- and latency-bound regimes, scalability bottlenecks and saturation points, cost and energy scaling, benchmarks and baselines, repeated measurements, warm-up and performance noise, profiling, hardware counters and tracing, analytic and empirical performance models, thread, process, node, GPU and hybrid scaling, numerical equivalence, reproducibility, verification and provenance."
}

FLOW_HASH {
 METHOD = "semantic-content-identity"
 ID = "KIRETH-MATH-HPC-PERFORMANCE-SCALING-ONTOLOGY-V1"
}

}

END_FLOW