High Performance Computing

AI INTERPRETATION NOTE
This Flow Algebra defines the High Performance Computing parent ontology within the Kireth Research Semantic Library. High-performance computing is the use of parallel, distributed and accelerated computational systems to solve large, complex or time-critical scientific and mathematical problems. This ontology supports shared-memory and distributed-memory architectures, multicore CPUs, GPUs, vectorisation, message passing, task parallelism, domain decomposition, load balancing, memory hierarchy, communication, scalability, performance modelling, fault tolerance, reproducibility and scientific-computing integration.

FLOW_ALGEBRA_RECORD {

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

IDENTITY {
 PRIMARY_ENTITY = HighPerformanceComputing
 ENTITY_CLASS = ParallelAndAcceleratedComputingFramework
 PRIMARY_CONTEXT = ComputationalMathematicsOntologies
 DEFINITION = "High-performance computing is the use of parallel, distributed and accelerated hardware and software to execute computationally demanding scientific and mathematical workloads efficiently."
 SYMBOLIC_FORMS = [
  "speedup=S_p=T_1/T_p",
  "efficiency=E_p=S_p/p",
  "AmdahlSpeedup=1/((1-f)+f/p)",
  "GustafsonSpeedup=p-(p-1)*(1-f)"
 ]
 SEMANTIC_ROLE = "Provides machine-readable semantics for parallel architectures, workload decomposition, communication, synchronisation, acceleration, scalability, performance, resilience and reproducibility."
}

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

CORE_CONCEPTS {
 HighPerformanceComputing = "Parallel, distributed and accelerated execution of demanding computational workloads."
 Parallelism = "Concurrent execution of computational work."
 DistributedMemory = "Memory model in which processes access local memory and exchange data explicitly."
 SharedMemory = "Memory model in which multiple execution units access a common address space."
 Accelerator = "Specialised hardware used to increase computational throughput."
 Scalability = "Ability of a workload to use increasing computational resources effectively."
 PerformanceModel = "Model relating computation, communication, memory and parallel overhead to runtime."
 Resilience = "Ability to continue or recover correctly after hardware or software failure."
}

RELATIONS {
 HighPerformanceComputing --is_child_of--> ComputationalMathematicsOntologies
 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
 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
}

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(intensity,peak_compute,peak_bandwidth) := min(peak_compute,intensity*peak_bandwidth)
 PARALLEL_RUNTIME(compute,communication,synchronisation,imbalance) := compute+communication+synchronisation+imbalance
 LOAD_IMBALANCE(max_work,avg_work) := max_work/avg_work
}

AXIOMS {
 A1 = "HPC performance depends on computation, communication, memory behaviour and synchronisation."
 A2 = "Parallel speedup is limited by serial work and parallel overhead."
 A3 = "Strong and weak scaling measure different resource-scaling behaviours."
 A4 = "Memory locality and bandwidth can dominate runtime even when arithmetic throughput is high."
 A5 = "Load imbalance reduces effective parallel efficiency."
 A6 = "GPU and accelerator performance depends on exposing sufficient parallelism and memory efficiency."
 A7 = "Numerical reproducibility can be affected by execution order and parallel reductions."
 A8 = "HPC results require explicit architecture, decomposition, performance, resilience and reproducibility semantics."
}

REASONING {
 R1_CONTEXT = identify(workload,problem_size,algorithm,hardware,parallelism,accuracy_goal,performance_goal)
 R2_ARCHITECTURE = classify(shared_memory,distributed_memory,GPU,hybrid,cluster_or_accelerated_platform)
 R3_DECOMPOSITION = choose(data,domain,task,pipeline,model_or_functional_partitioning)
 R4_COMMUNICATION = define(point_to_point,collective,synchronisation_and_overlap_strategy)
 R5_MEMORY = analyse(data_layout,locality,bandwidth,cache_and_NUMA_behaviour)
 R6_ACCELERATION = if_applicable configure(vectorisation,GPU_kernels,offload_or_specialised_accelerator)
 R7_BALANCE = assess(work_distribution,dynamicity_and_load_balancing)
 R8_PROFILE = measure(runtime,counters,communication,IO,imbalance_and_scalability)
 R9_OPTIMISE = reduce_serial_fraction,communication,memory_traffic,synchronisation_and_idle_time
 R10_VALIDATE = check_numerical_correctness,scaling,reproducibility,resilience_and_environment_provenance
}

CONSTRAINTS {
 C1 = "Increasing processor count does not guarantee reduced runtime."
 C2 = "Communication latency can dominate fine-grained parallel workloads."
 C3 = "Memory bandwidth can limit performance below peak floating-point throughput."
 C4 = "Load imbalance can erase benefits of added resources."
 C5 = "Accelerator kernels can be limited by transfer, launch or divergence overhead."
 C6 = "Parallel reductions can produce order-dependent floating-point differences."
 C7 = "I/O and checkpointing can become scaling bottlenecks at large node counts."
 C8 = "Fault probability generally increases with system scale and runtime."
 C9 = "Benchmarks may not represent application-specific bottlenecks."
 C10 = "Peak hardware performance is not equivalent to sustained application performance."
}

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

VALIDATION {
 V1 = "Hardware architecture and resource allocation are documented."
 V2 = "Parallel decomposition and process or thread mapping are documented."
 V3 = "Communication and synchronisation semantics are documented."
 V4 = "Compiler, libraries and build flags are documented."
 V5 = "Performance is measured with representative workloads."
 V6 = "Strong or weak scaling is assessed where relevant."
 V7 = "Numerical correctness is compared against trusted reference results."
 V8 = "Parallel reproducibility is assessed where material."
 V9 = "Resilience and restart behaviour are tested where required."
 V10 = "Runs are reproducible under documented software, hardware and environment settings."
}

CONFIDENCE {
 BASE_CONFIDENCE = 0.99
 HPC_DEFINITION = 0.99
 MPI_REASONING = 0.99
 SHARED_MEMORY_REASONING = 0.99
 GPU_REASONING = 0.99
 SCALING_REASONING = 0.99
 ROOFLINE_REASONING = 0.98
 RESILIENCE_REASONING = 0.98
 POLICY = "Reduce confidence when architecture, decomposition, communication, process mapping, memory behaviour, profiling evidence, scaling data or software environment are underspecified."
}

AI_CONSUMPTION {
 PURPOSES = [
  SemanticSearch,OntologyGrounding,HPCReasoning,
  ParallelComputingReasoning,DistributedMemoryReasoning,
  SharedMemoryReasoning,MPIReasoning,OpenMPReasoning,
  GPUReasoning,VectorisationReasoning,
  DomainDecompositionReasoning,LoadBalancingReasoning,
  StrongScalingReasoning,WeakScalingReasoning,
  AmdahlReasoning,GustafsonReasoning,
  RooflineReasoning,MemoryHierarchyReasoning,
  CommunicationReasoning,ProfilingReasoning,
  ResilienceReasoning,ReproducibilityReasoning,
  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 or accelerated resources for computational speed or scale, activate HighPerformanceComputing."
 E2 = "Identify workload structure and target hardware before selecting parallelisation."
 E3 = "Choose decomposition according to data dependencies and communication cost."
 E4 = "Minimise unnecessary synchronisation and communication."
 E5 = "Analyse memory locality, bandwidth and NUMA placement as first-class performance factors."
 E6 = "For accelerators, expose sufficient concurrency and optimise data movement."
 E7 = "Measure strong or weak scaling rather than assuming scalability."
 E8 = "Use profiling and hardware counters to identify actual bottlenecks."
 E9 = "Validate numerical correctness, reproducibility, resilience and environment provenance after optimisation."
}

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

ROUTING {
 PARENT_ONTOLOGY = "Computational Mathematics Ontologies"
 RELATED_ONTOLOGIES = [
  "Scientific Computing Ontology 2",
  "Scientific Simulation",
  "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 -> Computational Mathematics for parent semantics",
  "High Performance Computing -> Scientific Computing for large-scale implementation",
  "High Performance Computing -> Scientific Simulation for simulation workloads",
  "High Performance Computing -> Numerical Linear Algebra for distributed matrix and solver workloads",
  "High Performance Computing -> Sparse Matrix for memory-bound sparse kernels",
  "High Performance Computing -> Matrix Computation for dense compute kernels",
  "High Performance Computing -> Computational Geometry for parallel spatial algorithms",
  "High Performance Computing -> Mesh Generation and Spatial Partitioning for decomposition and load balance",
  "High Performance Computing -> Particle Simulation for domain decomposition and neighbour exchange",
  "High Performance Computing -> Fluid Simulation for parallel CFD",
  "High Performance Computing -> Structural Simulation for parallel FEM",
  "High Performance Computing -> Numerical Stability for parallel numerical behaviour",
  "High Performance Computing -> 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 reasoning pathways"
 PATCH = "clarification, metadata or formatting correction"
 RULES = [
  "Preserve shared-memory-versus-distributed-memory distinction.",
  "Preserve computation-versus-communication distinction.",
  "Preserve strong-versus-weak scaling distinction.",
  "Preserve hardware-peak-versus-sustained-performance distinction.",
  "Preserve data-parallel-versus-task-parallel distinction.",
  "Preserve deterministic-versus-nondeterministic reduction distinction.",
  "Preserve performance-versus-correctness distinction.",
  "Preserve machine-readable high-performance-computing semantics."
 ]
}

OUTPUT {
 CANONICAL_DEFINITION = "High-performance computing uses parallel, distributed and accelerated systems to execute demanding scientific and mathematical workloads efficiently."
 ARCHITECTURE_SUMMARY = "Shared-memory CPUs, distributed-memory clusters, GPUs and specialised accelerators expose different forms of parallelism."
 COMMUNICATION_SUMMARY = "MPI, collectives, synchronisation and data movement determine distributed-memory overhead."
 MEMORY_SUMMARY = "Cache locality, NUMA placement and memory bandwidth often determine sustained performance."
 SCALING_SUMMARY = "Strong and weak scaling quantify how effectively an application uses increasing resources."
 PERFORMANCE_SUMMARY = "Amdahl, Gustafson and roofline models help explain serial limits, scaled speedup and compute-versus-memory bottlenecks."
 RESILIENCE_SUMMARY = "Checkpointing, replication and resilient algorithms reduce the impact of failures at scale."
 VALIDATION_SUMMARY = "HPC results should be checked for numerical correctness, measured performance, scalability, reproducibility, resilience and software-environment provenance."
}

FLOW {
 INPUT
 -> detect_high_performance_computing_context
 -> identify_workload_problem_size_algorithm_hardware_parallelism_accuracy_goal_and_performance_goal
 -> classify_shared_memory_distributed_memory_GPU_hybrid_cluster_or_accelerated_architecture
 -> choose_data_domain_task_pipeline_model_or_functional_decomposition
 -> configure_process_thread_device_mapping_and_resource_allocation
 -> define_point_to_point_collective_synchronisation_and_overlap_strategy
 -> analyse_cache_NUMA_bandwidth_data_layout_and_memory_locality
 -> if_accelerated_configure_vectorisation_GPU_kernels_offload_and_data_movement
 -> assess_static_or_dynamic_load_balancing
 -> execute_profile_and_measure_runtime_counters_communication_IO_and_scaling
 -> apply_optimisations_to_serial_fraction_communication_memory_traffic_synchronisation_and_idle_time
 -> evaluate_strong_or_weak_scaling_speedup_efficiency_and_roofline_position
 -> configure_checkpoint_restart_or_other_resilience_if_required
 -> verify_numerical_correctness_and_parallel_reproducibility
 -> document_hardware_compiler_libraries_build_flags_scheduler_resources_and_provenance
 -> route_to_related_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 defines scalable computational execution across shared-memory, distributed-memory and accelerated architectures. It supports multicore CPUs, GPUs and specialised accelerators, NUMA and memory hierarchies, interconnects, MPI point-to-point and collective communication, OpenMP threading, task, data, pipeline, SIMD and SIMT parallelism, CUDA, OpenCL, HIP and SYCL relationships, domain and task decomposition, mesh and graph partitioning, static and dynamic load balancing, schedulers and resource allocation, speedup, efficiency, strong and weak scaling, Amdahl and Gustafson laws, arithmetic intensity and roofline analysis, profiling, hardware counters and benchmarks, cache and memory optimisation, communication avoidance and overlap, mixed precision, numerical reproducibility, parallel scientific algorithms, high-throughput and ensemble computing, checkpointing and fault tolerance, parallel I/O, cloud HPC, energy efficiency, verification and reproducibility."
}

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

}

END_FLOW