High Performance Computing Ontology

AI INTERPRETATION NOTE
This Flow Algebra defines the High Performance Computing Ontology 2 within the Kireth Research Semantic Library. High-performance computing concerns the efficient execution of large, complex or time-critical computational workloads through parallelism, distribution, vectorisation, accelerator use and large-scale resource coordination. This ontology supports shared-memory and distributed-memory models, multicore CPUs, GPUs, message passing, threading, task and data parallelism, memory hierarchy, communication, decomposition, load balancing, scalability, performance modelling, profiling, resilience, numerical reproducibility and scientific-computing integration.

FLOW_ALGEBRA_RECORD {

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

IDENTITY {
 PRIMARY_ENTITY = HighPerformanceComputing
 ENTITY_CLASS = ScalableParallelComputingFramework
 PRIMARY_CONTEXT = HighPerformanceComputingParent
 DEFINITION = "High-performance computing is the use of parallel, distributed and accelerated computational resources to execute demanding numerical, scientific and data-intensive workloads efficiently."
 SYMBOLIC_FORMS = [
  "S_p=T_1/T_p",
  "E_p=S_p/p",
  "Amdahl(f,p)=1/((1-f)+f/p)",
  "Roofline=min(P_peak,I*B_peak)"
 ]
 SEMANTIC_ROLE = "Provides machine-readable semantics for scalable architectures, decomposition, parallel programming models, communication, synchronisation, memory behaviour, acceleration, performance, resilience and reproducibility."
}

SCOPE {
 INCLUDE = [
  HighPerformanceComputing,HPC,ParallelComputing,
  DistributedComputing,AcceleratedComputing,
  Supercomputing,ScientificComputing,
  Supercomputer,ComputeCluster,ComputeNode,
  CPU,MulticoreCPU,ManycoreProcessor,Core,
  HardwareThread,SMT,GPU,Accelerator,
  FPGAAccelerator,VectorProcessor,
  SharedMemory,DistributedMemory,
  HybridMemory,UnifiedMemory,NUMA,
  MemoryHierarchy,Register,Cache,L1Cache,L2Cache,L3Cache,
  MainMemory,HighBandwidthMemory,HBM,
  MemoryBandwidth,MemoryLatency,
  Storage,ParallelFileSystem,Lustre,
  Interconnect,NetworkFabric,InfiniBand,
  NVLink,PCIe,Latency,Bandwidth,
  NetworkTopology,FatTree,Dragonfly,Torus,
  MPI,MessagePassingInterface,
  PointToPointCommunication,CollectiveCommunication,
  Broadcast,Reduce,AllReduce,Scatter,Gather,
  AllGather,AllToAll,Barrier,
  BlockingCommunication,NonblockingCommunication,
  SynchronousCommunication,AsynchronousCommunication,
  RDMA,RemoteDirectMemoryAccess,
  OpenMP,ThreadParallelism,Threading,
  TaskParallelism,DataParallelism,
  PipelineParallelism,FunctionalParallelism,
  ModelParallelism,DomainParallelism,
  SIMD,SIMT,Vectorisation,
  AutoVectorisation,ManualVectorisation,
  CUDA,OpenCL,HIP,SYCL,
  DeviceKernel,KernelLaunch,ThreadBlock,
  Warp,Wavefront,Occupancy,
  SharedMemoryGPU,GlobalMemoryGPU,
  CoalescedMemoryAccess,BranchDivergence,
  DataTransfer,HostDeviceTransfer,
  DomainDecomposition,DataDecomposition,
  TaskDecomposition,FunctionalDecomposition,
  MeshPartitioning,GraphPartitioning,
  SpatialDecomposition,ParticleDecomposition,
  BlockDecomposition,CyclicDecomposition,
  BlockCyclicDecomposition,
  LoadBalancing,StaticLoadBalancing,
  DynamicLoadBalancing,WorkStealing,
  WorkSharing,TaskScheduling,
  Scheduler,JobScheduler,Slurm,
  BatchJob,InteractiveJob,JobArray,
  ResourceAllocation,Queue,Partition,
  NodeCount,CoreCount,GPUCount,
  Runtime,WallTime,Throughput,
  TimeToSolution,LatencyToSolution,
  EnergyToSolution,
  Performance,PerformanceMetric,
  Speedup,ParallelEfficiency,
  StrongScaling,WeakScaling,
  Scalability,SerialFraction,ParallelFraction,
  AmdahlsLaw,GustafsonsLaw,
  Isoefficiency,ScalabilityFunction,
  CommunicationOverhead,SynchronisationOverhead,
  LoadImbalance,IdleTime,
  ComputationCommunicationRatio,
  ArithmeticIntensity,OperationalIntensity,
  RooflineModel,PeakPerformance,
  FLOPS,GFLOPS,TFLOPS,PFLOPS,EFLOPS,
  ComputeBound,MemoryBound,BandwidthBound,
  LatencyBound,
  Profiling,Profiler,SamplingProfiler,
  Instrumentation,Tracing,Timeline,
  PerformanceCounter,HardwareCounter,
  CallGraph,FlameGraph,
  Benchmark,Microbenchmark,
  HPL,HPCG,LINPACK,STREAMBenchmark,
  OSUBenchmark,ApplicationBenchmark,
  PerformanceOptimisation,CodeOptimisation,
  CompilerOptimisation,LoopOptimisation,
  LoopTiling,LoopBlocking,CacheBlocking,
  Prefetching,MemoryLocality,
  SpatialLocality,TemporalLocality,
  DataLayout,ArrayOfStructures,
  StructureOfArrays,Alignment,Padding,
  CommunicationAvoidingAlgorithm,
  CommunicationHiding,OverlapCommunicationComputation,
  KernelFusion,KernelLaunchOverhead,
  MixedPrecision,ReducedPrecision,
  ParallelAlgorithm,DistributedAlgorithm,
  ParallelLinearAlgebra,
  DistributedMatrix,DistributedVector,
  SparseMatrixVectorProduct,
  ParallelMatrixMultiplication,
  ParallelFFT,ParallelSort,ParallelScan,
  PrefixSum,ParallelGraphAlgorithm,
  ParallelMeshAlgorithm,ParallelGeometry,
  ParallelParticleSimulation,
  ParallelCFD,ParallelFEM,
  ParallelMonteCarlo,ParallelOptimisation,
  EnsembleComputing,HighThroughputComputing,
  HTC,WorkflowParallelism,
  ParameterSweep,EnsembleJob,
  TaskGraph,DAG,WorkflowScheduler,
  FaultTolerance,Resilience,
  CheckpointRestart,Checkpoint,Restart,
  CoordinatedCheckpoint,UncoordinatedCheckpoint,
  IncrementalCheckpoint,Replication,
  Redundancy,FailureDetection,
  NodeFailure,ProcessFailure,Recovery,
  AlgorithmBasedFaultTolerance,ABFT,
  ResilientAlgorithm,SilentDataCorruption,
  ErrorDetection,Reliability,Availability,
  NumericalReproducibility,
  DeterministicReduction,
  ReproducibleReduction,ReductionOrder,
  FloatingPointArithmetic,MachinePrecision,
  RoundOffError,AssociativityLoss,
  Reproducibility,Repeatability,
  Provenance,Configuration,
  SoftwareEnvironment,EnvironmentModule,
  Container,ApptainerRelationship,
  SingularityRelationship,DockerRelationship,
  Compiler,CompilerVersion,
  BuildConfiguration,OptimisationFlag,
  Library,MathLibrary,BLAS,LAPACK,
  ScaLAPACK,PETSc,Trilinos,
  FFTW,HDF5,NetCDF,
  ParallelIO,CollectiveIO,
  IOAggregation,CheckpointIO,
  DataStaging,InSituAnalysis,
  InTransitAnalysis,Postprocessing,
  CloudHPC,ElasticHPC,HybridCloud,
  CostModel,EnergyEfficiency,
  PowerConsumption,PowerCap,
  EnergyAwareScheduling,GreenHPC,
  CarbonEfficiency
 ]
 EXCLUDE_AS_PRIMARY = [
  SerialComputingWithoutParallelOrAcceleratedExecution,
  GenericDistributedBusinessSystemsWithoutHPCSemantics,
  CloudComputingWithoutScientificOrParallelWorkloadFocus,
  HardwareArchitectureWithoutWorkloadExecutionSemantics
 ]
 DISAMBIGUATION_RULE = "When computational speed, scale or throughput is increased through parallelism, distribution, vectorisation, accelerators or specialised high-performance systems, interpret the context as high-performance computing."
}

CORE_CONCEPTS {
 HighPerformanceComputing = "Scalable execution of demanding computational workloads."
 ParallelComputing = "Concurrent execution of computational work."
 DistributedMemory = "Memory model requiring explicit communication between processes."
 SharedMemory = "Memory model where multiple threads access a common address space."
 AcceleratorComputing = "Use of specialised hardware such as GPUs to increase throughput."
 Scalability = "Effectiveness of using increased computational resources."
 PerformanceEngineering = "Measurement and optimisation of runtime, memory, communication and resource use."
 Resilience = "Ability to recover from or tolerate failures during execution."
}

RELATIONS {
 HighPerformanceComputing --is_child_of--> HighPerformanceComputingParent
 HighPerformanceComputing --uses--> ParallelComputing
 ParallelComputing --uses--> ParallelAlgorithm
 DistributedMemory --uses--> MessagePassing
 SharedMemory --uses--> Threading
 MPI --implements--> MessagePassing
 OpenMP --supports--> SharedMemoryParallelism
 GPU --supports--> AcceleratedComputing
 CUDA --targets--> GPU
 DomainDecomposition --creates--> ParallelSubdomains
 MeshPartitioning --supports--> DomainDecomposition
 LoadBalancing --reduces--> IdleTime
 StrongScaling --measures--> FixedProblemResourceScaling
 WeakScaling --measures--> FixedWorkPerResourceScaling
 AmdahlsLaw --bounds--> ParallelSpeedup
 GustafsonsLaw --models--> ScaledProblemSpeedup
 RooflineModel --relates--> ArithmeticIntensityAndPerformance
 Profiling --identifies--> PerformanceBottleneck
 CheckpointRestart --supports--> Resilience
 DeterministicReduction --supports--> NumericalReproducibility
 Verification --checks--> ParallelComputationResult
}

OPERATORS {
 SPEEDUP(T1,Tp) := T1/Tp
 EFFICIENCY(S,p) := S/p
 AMDAHL(f,p) := 1/((1-f)+f/p)
 GUSTAFSON(alpha,p) := p-alpha*(p-1)
 ARITHMETIC_INTENSITY(flops,bytes) := flops/bytes
 ROOFLINE(I,P_peak,B_peak) := min(P_peak,I*B_peak)
 PARALLEL_RUNTIME(Tcomp,Tcomm,Tsync,Timbalance,Tio) := Tcomp+Tcomm+Tsync+Timbalance+Tio
 LOAD_IMBALANCE(max_work,avg_work) := max_work/avg_work
 STRONG_SCALING_EFFICIENCY(T1,Tp,p) := T1/(p*Tp)
}

AXIOMS {
 A1 = "High-performance computing depends on both algorithmic parallelism and hardware execution characteristics."
 A2 = "Parallel speedup is limited by serial work and parallel overhead."
 A3 = "Strong and weak scaling answer different questions and must not be conflated."
 A4 = "Communication and synchronisation can dominate fine-grained distributed workloads."
 A5 = "Memory bandwidth and locality can limit performance below arithmetic peak."
 A6 = "Accelerator performance depends on concurrency, occupancy and efficient data movement."
 A7 = "Parallel execution order can alter floating-point results without altering mathematical intent."
 A8 = "HPC results require explicit architecture, decomposition, performance, resilience and reproducibility semantics."
}

REASONING {
 R1_CONTEXT = identify(workload,problem_size,algorithm,data_dependencies,target_hardware,performance_goal,accuracy_goal)
 R2_ARCHITECTURE = classify(shared_memory,distributed_memory,GPU,hybrid,cluster_or_accelerated_system)
 R3_PARALLELISM = expose(data,task,domain,pipeline,functional_or_model_parallelism)
 R4_DECOMPOSITION = choose(block,cyclic,graph,mesh,spatial,particle_or_task_partitioning)
 R5_COMMUNICATION = configure(point_to_point,collective,blocking,nonblocking_and_overlap_strategy)
 R6_MEMORY = analyse(cache,NUMA,bandwidth,data_layout,working_set_and_locality)
 R7_ACCELERATION = configure(vectorisation,GPU_kernels,offload,mixed_precision_or_specialised_hardware)
 R8_BALANCE = measure_and_adjust(load_distribution_and_dynamic_scheduling)
 R9_PROFILE = measure(runtime,counters,communication,IO,scaling_and_energy)
 R10_VALIDATE = verify_correctness,reproducibility,resilience,performance_and_environment_provenance
}

CONSTRAINTS {
 C1 = "Adding resources can increase runtime when overhead exceeds saved computation."
 C2 = "Fine-grained communication can be latency dominated."
 C3 = "Bandwidth-bound kernels cannot reach arithmetic peak performance."
 C4 = "NUMA-unaware allocation can degrade shared-memory scalability."
 C5 = "GPU acceleration can be negated by host-device transfer overhead."
 C6 = "Branch divergence can reduce SIMT efficiency."
 C7 = "Load imbalance reduces parallel utilisation."
 C8 = "Parallel I/O can become the dominant bottleneck at scale."
 C9 = "Floating-point reductions may not be bitwise reproducible across process counts."
 C10 = "Synthetic benchmark performance does not guarantee application performance."
}

SEMANTIC_EQUIVALENCE {
 "HighPerformanceComputing" <=> "HPC"
 "MessagePassingInterface" <=> "MPI"
 "GraphicsProcessingUnit" <=> "GPU"
 "HighBandwidthMemory" <=> "HBM"
 "NonUniformMemoryAccess" <=> "NUMA"
 "HighThroughputComputing" <=> "HTC"
 "AlgorithmBasedFaultTolerance" <=> "ABFT"
}

VALIDATION {
 V1 = "Target architecture and hardware resources are documented."
 V2 = "Parallel decomposition and mapping are documented."
 V3 = "Communication and synchronisation patterns are documented."
 V4 = "Memory layout and NUMA or accelerator placement are documented where relevant."
 V5 = "Compiler, libraries and build configuration are documented."
 V6 = "Strong or weak scaling is measured where relevant."
 V7 = "Numerical correctness is compared with a trusted reference."
 V8 = "Parallel reproducibility is assessed where material."
 V9 = "Checkpoint, restart or fault-recovery behaviour is validated where required."
 V10 = "Performance results are reproducible under documented hardware and software conditions."
}

CONFIDENCE {
 BASE_CONFIDENCE = 0.99
 HPC_DEFINITION = 0.99
 MPI_REASONING = 0.99
 OPENMP_REASONING = 0.99
 GPU_REASONING = 0.99
 SCALABILITY_REASONING = 0.99
 MEMORY_REASONING = 0.99
 RESILIENCE_REASONING = 0.98
 POLICY = "Reduce confidence when architecture, decomposition, communication, memory behaviour, resource mapping, profiling data, scaling measurements or software environment are underspecified."
}

AI_CONSUMPTION {
 PURPOSES = [
  SemanticSearch,OntologyGrounding,HPCReasoning,
  ParallelComputingReasoning,DistributedMemoryReasoning,
  SharedMemoryReasoning,MPIReasoning,OpenMPReasoning,
  GPUReasoning,AcceleratorReasoning,VectorisationReasoning,
  DomainDecompositionReasoning,GraphPartitionReasoning,
  LoadBalancingReasoning,StrongScalingReasoning,
  WeakScalingReasoning,AmdahlReasoning,
  GustafsonReasoning,RooflineReasoning,
  MemoryHierarchyReasoning,NUMAReasoning,
  CommunicationReasoning,ProfilingReasoning,
  ParallelIOReasoning,ResilienceReasoning,
  NumericalReproducibilityReasoning,
  KnowledgeGraphConstruction,RetrievalAugmentation,RecursiveInference
 ]
 NORMALISE {
  "high-performance computing" -> HighPerformanceComputing
  "high performance computing" -> HighPerformanceComputing
  "HPC" -> HighPerformanceComputing
  "MPI" -> MessagePassingInterface
  "GPU" -> GraphicsProcessingUnit
  "HBM" -> HighBandwidthMemory
  "NUMA" -> NonUniformMemoryAccess
  "HTC" -> HighThroughputComputing
  "ABFT" -> AlgorithmBasedFaultTolerance
 }
}

EXECUTION_RULES {
 E1 = "If a workload uses parallel, distributed, vector or accelerated execution to increase speed or scale, activate HighPerformanceComputingOntology2."
 E2 = "Identify workload dependencies and hardware architecture before selecting parallelism."
 E3 = "Choose decomposition that minimises communication while preserving load balance."
 E4 = "Map processes, threads and accelerator work according to memory and topology characteristics."
 E5 = "Use nonblocking communication or overlap where it reduces exposed latency."
 E6 = "Measure memory bandwidth, locality and arithmetic intensity before assuming compute limitation."
 E7 = "Use profiling and scaling measurements to guide optimisation."
 E8 = "Preserve numerical correctness and document reduction-order effects."
 E9 = "Validate resilience, reproducibility and environment provenance after performance optimisation."
}

RECURSION {
 ENTRY = HighPerformanceComputing
 EXPAND(HighPerformanceComputing) -> [
  HPC,ParallelComputing,DistributedComputing,
  AcceleratedComputing,Supercomputing,
  ScientificComputing,ComputeCluster,ComputeNode,
  CPU,MulticoreCPU,ManycoreProcessor,
  Core,HardwareThread,GPU,Accelerator,
  SharedMemory,DistributedMemory,UnifiedMemory,
  NUMA,MemoryHierarchy,Cache,MainMemory,
  HBM,MemoryBandwidth,MemoryLatency,
  ParallelFileSystem,Interconnect,InfiniBand,
  NVLink,PCIe,Latency,Bandwidth,
  MPI,MessagePassingInterface,
  PointToPointCommunication,CollectiveCommunication,
  Broadcast,Reduce,AllReduce,Scatter,Gather,
  Barrier,NonblockingCommunication,RDMA,
  OpenMP,ThreadParallelism,TaskParallelism,
  DataParallelism,PipelineParallelism,
  SIMD,SIMT,Vectorisation,
  CUDA,OpenCL,HIP,SYCL,
  DeviceKernel,Warp,Occupancy,
  CoalescedMemoryAccess,BranchDivergence,
  DomainDecomposition,DataDecomposition,
  TaskDecomposition,MeshPartitioning,
  GraphPartitioning,SpatialDecomposition,
  ParticleDecomposition,LoadBalancing,
  DynamicLoadBalancing,WorkStealing,
  Scheduler,Slurm,ResourceAllocation,
  Runtime,Throughput,Speedup,
  ParallelEfficiency,StrongScaling,
  WeakScaling,AmdahlsLaw,GustafsonsLaw,
  Isoefficiency,CommunicationOverhead,
  SynchronisationOverhead,LoadImbalance,
  ArithmeticIntensity,RooflineModel,
  PeakPerformance,FLOPS,MemoryBound,
  ComputeBound,Profiling,PerformanceCounter,
  Benchmark,HPL,HPCG,STREAMBenchmark,
  PerformanceOptimisation,LoopTiling,
  CacheBlocking,Prefetching,MemoryLocality,
  DataLayout,CommunicationAvoidingAlgorithm,
  CommunicationHiding,MixedPrecision,
  ParallelLinearAlgebra,SparseMatrixVectorProduct,
  ParallelMatrixMultiplication,ParallelFFT,
  ParallelSort,ParallelScan,ParallelGraphAlgorithm,
  ParallelMeshAlgorithm,ParallelParticleSimulation,
  ParallelCFD,ParallelFEM,ParallelMonteCarlo,
  EnsembleComputing,HighThroughputComputing,
  WorkflowParallelism,FaultTolerance,
  Resilience,CheckpointRestart,Replication,
  NodeFailure,ABFT,SilentDataCorruption,
  NumericalReproducibility,DeterministicReduction,
  FloatingPointArithmetic,Reproducibility,
  Provenance,SoftwareEnvironment,Compiler,
  BLAS,LAPACK,ScaLAPACK,PETSc,
  Trilinos,FFTW,HDF5,NetCDF,
  ParallelIO,CollectiveIO,InSituAnalysis,
  CloudHPC,EnergyEfficiency,GreenHPC
 ]
 EXPAND(HPCFamilies) -> [
  SharedMemoryHPC,
  DistributedMemoryHPC,
  GPUAndAcceleratorHPC,
  VectorAndSIMDHPC,
  ParallelScientificAlgorithms,
  HighThroughputAndWorkflowComputing,
  ResilientHPC,
  PerformanceEngineeringAndScalability
 ]
 STOP_CONDITION = "Stop when workload, architecture, parallelism, decomposition, communication, memory, acceleration, load balance, performance, resilience and reproducibility are sufficiently resolved."
}

ROUTING {
 PARENT_ONTOLOGY = "High Performance Computing"
 RELATED_ONTOLOGIES = [
  "High Performance Computing",
  "Scientific Computing Ontology 2",
  "Scientific Simulation Ontology",
  "Numerical Linear Algebra Ontology 2",
  "Sparse Matrix Ontology 2",
  "Matrix Computation Ontology",
  "Computational Geometry Ontology 2",
  "Mesh Generation Ontology 2",
  "Spatial Partitioning Ontology 2",
  "Particle Simulation Ontology",
  "Fluid Simulation Ontology",
  "Structural Simulation Ontology",
  "Numerical Stability Ontology 2",
  "Floating Point Arithmetic Ontology"
 ]
 ROUTE_RULES = [
  "High Performance Computing Ontology 2 -> High Performance Computing for parent semantics",
  "High Performance Computing Ontology 2 -> Scientific Computing for implementation and workload semantics",
  "High Performance Computing Ontology 2 -> Scientific Simulation for simulation workloads",
  "High Performance Computing Ontology 2 -> Numerical Linear Algebra for distributed solver workloads",
  "High Performance Computing Ontology 2 -> Sparse Matrix for memory-bound sparse kernels",
  "High Performance Computing Ontology 2 -> Matrix Computation for dense compute kernels",
  "High Performance Computing Ontology 2 -> Computational Geometry for parallel geometric algorithms",
  "High Performance Computing Ontology 2 -> Mesh Generation and Spatial Partitioning for decomposition",
  "High Performance Computing Ontology 2 -> Particle Simulation for particle-domain decomposition",
  "High Performance Computing Ontology 2 -> Fluid Simulation for parallel CFD",
  "High Performance Computing Ontology 2 -> Structural Simulation for parallel FEM",
  "High Performance Computing Ontology 2 -> Numerical Stability for parallel numerical behaviour",
  "High Performance Computing Ontology 2 -> Floating Point Arithmetic for reduction order and reproducibility"
 ]
}

UPDATE_MODEL {
 MODE = "append-compatible semantic versioning"
 MAJOR = "ontology-breaking conceptual change"
 MINOR = "new compatible architectures, programming models or performance pathways"
 PATCH = "clarification, metadata or formatting correction"
 RULES = [
  "Preserve shared-memory-versus-distributed-memory distinction.",
  "Preserve data-parallel-versus-task-parallel distinction.",
  "Preserve communication-versus-computation distinction.",
  "Preserve strong-versus-weak scaling distinction.",
  "Preserve peak-versus-sustained performance distinction.",
  "Preserve compute-bound-versus-memory-bound distinction.",
  "Preserve deterministic-versus-nondeterministic reduction distinction.",
  "Preserve machine-readable high-performance-computing semantics."
 ]
}

OUTPUT {
 CANONICAL_DEFINITION = "High-performance computing uses parallel, distributed and accelerated systems to solve computationally demanding workloads efficiently."
 ARCHITECTURE_SUMMARY = "Shared-memory CPUs, distributed-memory clusters and GPUs expose different memory, communication and execution semantics."
 PARALLELISM_SUMMARY = "Data, task, domain, pipeline, SIMD and SIMT parallelism provide different forms of concurrency."
 COMMUNICATION_SUMMARY = "MPI, collectives, barriers and asynchronous communication determine distributed execution overhead."
 MEMORY_SUMMARY = "Cache locality, NUMA placement, memory bandwidth and data layout strongly influence sustained performance."
 SCALABILITY_SUMMARY = "Speedup, efficiency, strong scaling, weak scaling, Amdahl and Gustafson models quantify resource effectiveness."
 RESILIENCE_SUMMARY = "Checkpointing, replication and resilient algorithms support recovery at scale."
 VALIDATION_SUMMARY = "HPC execution should be checked for correctness, measured performance, scalability, memory behaviour, numerical reproducibility, resilience and software-environment provenance."
}

FLOW {
 INPUT
 -> detect_high_performance_computing_context
 -> identify_workload_problem_size_data_dependencies_target_hardware_performance_goal_and_accuracy_goal
 -> classify_shared_memory_distributed_memory_GPU_hybrid_cluster_or_accelerated_architecture
 -> expose_data_task_domain_pipeline_functional_model_SIMD_or_SIMT_parallelism
 -> choose_block_cyclic_graph_mesh_spatial_particle_or_task_decomposition
 -> configure_process_thread_device_mapping_and_resource_allocation
 -> define_point_to_point_collective_blocking_nonblocking_synchronisation_and_overlap_strategy
 -> analyse_cache_NUMA_bandwidth_data_layout_working_set_and_locality
 -> if_accelerated_configure_vectorisation_GPU_kernels_offload_data_transfer_and_mixed_precision
 -> measure_and_adjust_load_balance
 -> profile_runtime_hardware_counters_communication_IO_and_energy
 -> assess_speedup_efficiency_strong_scaling_weak_scaling_and_roofline_position
 -> optimise_serial_fraction_communication_memory_traffic_synchronisation_IO_and_idle_time
 -> configure_checkpoint_restart_replication_or_resilience_if_required
 -> verify_numerical_correctness_parallel_reproducibility_and_recovery_behaviour
 -> document_hardware_compiler_libraries_build_flags_scheduler_resources_and_provenance
 -> route_to_related_parent_scientific_computing_simulation_linear_algebra_sparse_matrix_matrix_computation_geometry_mesh_spatial_partitioning_particle_fluid_structural_stability_and_floating_point_ontologies
 -> recursively_expand_required_dependencies
 -> verify_result
 -> assign_confidence
 -> produce_semantic_output
 -> END
}

SEMANTIC_SUMMARY {
 "The High Performance Computing Ontology 2 defines scalable parallel and accelerated computational execution. It supports shared-memory and distributed-memory systems, multicore CPUs, GPUs and accelerators, NUMA and memory hierarchies, high-bandwidth memory, MPI point-to-point and collective communication, OpenMP threading, task, data, pipeline, SIMD and SIMT execution, CUDA, OpenCL, HIP and SYCL relationships, domain, mesh, graph, particle and task decomposition, static and dynamic load balancing, batch scheduling and resource allocation, speedup, efficiency, strong and weak scaling, Amdahl, Gustafson and isoefficiency reasoning, arithmetic intensity and roofline analysis, profiling and hardware counters, cache and data-layout optimisation, communication avoidance and overlap, mixed precision, parallel linear algebra, FFT, sorting, graph, particle, CFD and FEM workloads, high-throughput and workflow computing, checkpointing, fault tolerance, numerical reproducibility, parallel I/O, cloud HPC, energy efficiency, verification and reproducibility."
}

FLOW_HASH {
 METHOD = "semantic-content-identity"
 ID = "KIRETH-MATH-COMPUTATIONAL-MATHEMATICS-HIGH-PERFORMANCE-COMPUTING-ONTOLOGY-2-V1"
}

}

END_FLOW