Parallel Computing Ontology

AI INTERPRETATION NOTE
This Flow Algebra defines the Parallel Computing Ontology within the Kireth Research Semantic Library. Parallel computing is the concurrent execution of computational work across multiple processing elements in order to reduce time to solution, increase throughput or enable larger problem sizes. This ontology supports task, data, domain, pipeline and vector parallelism, shared-memory and distributed-memory execution, threads, processes, synchronisation, communication, decomposition, scheduling, load balancing, scalability, performance modelling, correctness, race conditions, deadlock, reproducibility and scientific-computing integration.

FLOW_ALGEBRA_RECORD {

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

IDENTITY {
 PRIMARY_ENTITY = ParallelComputing
 ENTITY_CLASS = ConcurrentComputationalExecutionFramework
 PRIMARY_CONTEXT = HighPerformanceComputing
 DEFINITION = "Parallel computing is the execution of multiple computational operations concurrently across more than one processing element."
 SYMBOLIC_FORMS = [
  "T_p < T_1 under useful parallel speedup",
  "S_p=T_1/T_p",
  "E_p=S_p/p",
  "Work = sum_i Work_i across concurrent tasks"
 ]
 SEMANTIC_ROLE = "Provides machine-readable semantics for parallel decomposition, execution units, threads, processes, communication, synchronisation, scheduling, load balance, scalability, correctness and reproducibility."
}

SCOPE {
 INCLUDE = [
  ParallelComputing,ParallelExecution,Concurrency,
  ParallelAlgorithm,ParallelProgram,
  ProcessingElement,Processor,CPU,Core,
  MulticoreProcessor,ManycoreProcessor,
  HardwareThread,LogicalCore,GPU,
  Accelerator,ComputeNode,
  Thread,Process,Task,Kernel,
  Worker,MasterWorker,Coordinator,
  SharedMemory,DistributedMemory,
  HybridParallelism,MemoryModel,
  GlobalAddressSpace,LocalMemory,
  DataParallelism,TaskParallelism,
  FunctionalParallelism,DomainParallelism,
  PipelineParallelism,LoopParallelism,
  InstructionLevelParallelism,
  ThreadLevelParallelism,ProcessLevelParallelism,
  VectorParallelism,SIMD,SIMT,
  MIMD,SPMD,MPMD,
  ForkJoinParallelism,MapReduce,
  DivideAndConquerParallelism,
  BulkSynchronousParallel,BSPModel,
  ActorModel,MessagePassing,
  RemoteProcedureCall,
  SharedVariable,PrivateVariable,
  ThreadLocalStorage,
  CriticalSection,Mutex,Lock,
  Spinlock,Semaphore,Monitor,
  AtomicOperation,AtomicVariable,
  CompareAndSwap,CAS,
  Barrier,Synchronisation,
  ConditionVariable,Event,
  Fence,MemoryFence,
  MemoryConsistency,SequentialConsistency,
  WeakMemoryModel,MemoryOrdering,
  RaceCondition,DataRace,
  RaceFreeProgram,Deadlock,
  Livelock,Starvation,
  MutualExclusion,LockContention,
  FalseSharing,CacheCoherence,
  CoherenceProtocol,
  Communication,PointToPointCommunication,
  CollectiveCommunication,
  Broadcast,Reduce,AllReduce,
  Scatter,Gather,AllGather,AllToAll,
  BlockingCommunication,NonblockingCommunication,
  SynchronousCommunication,AsynchronousCommunication,
  Message,MessageBuffer,Send,Receive,
  CommunicationLatency,CommunicationBandwidth,
  CommunicationVolume,CommunicationPattern,
  NearestNeighbourCommunication,
  HaloExchange,GhostExchange,
  DomainDecomposition,DataDecomposition,
  TaskDecomposition,FunctionalDecomposition,
  BlockDecomposition,CyclicDecomposition,
  BlockCyclicDecomposition,
  GraphPartitioning,MeshPartitioning,
  SpatialPartitioning,ParticleDecomposition,
  WorkPartition,WorkUnit,
  LoadBalancing,StaticLoadBalancing,
  DynamicLoadBalancing,WorkStealing,
  WorkSharing,TaskQueue,
  Scheduler,RuntimeScheduler,
  StaticScheduling,DynamicScheduling,
  GuidedScheduling,ChunkSize,
  Affinity,ThreadAffinity,ProcessAffinity,
  Pinning,Binding,NUMAAffinity,
  Locality,DataLocality,MemoryLocality,
  CacheLocality,SpatialLocality,TemporalLocality,
  NUMA,NonUniformMemoryAccess,
  Oversubscription,Undersubscription,
  GrainSize,Granularity,
  FineGrainedParallelism,CoarseGrainedParallelism,
  Dependency,DataDependency,ControlDependency,
  ReadAfterWrite,WriteAfterRead,WriteAfterWrite,
  DependencyGraph,TaskGraph,DAG,
  CriticalPath,Span,Work,
  WorkSpanModel,BrentsTheorem,
  ParallelPrefix,Scan,Reduction,
  ParallelSort,ParallelSearch,
  ParallelMatrixMultiplication,
  ParallelLinearAlgebra,
  SparseMatrixVectorProduct,
  ParallelFFT,ParallelGraphAlgorithm,
  ParallelMeshAlgorithm,
  ParallelSimulation,
  ParallelMonteCarlo,
  ParallelOptimisation,
  SharedMemoryParallelism,
  DistributedMemoryParallelism,
  HeterogeneousParallelism,
  CPUParallelism,GPUParellelism,
  OpenMP,MPI,Pthreads,
  CilkRelationship,TBBRelationship,
  CUDA,OpenCL,HIP,SYCL,
  Speedup,ParallelEfficiency,
  Scalability,StrongScaling,
  WeakScaling,AmdahlsLaw,
  GustafsonsLaw,SerialFraction,
  ParallelFraction,CommunicationOverhead,
  SynchronisationOverhead,
  SchedulingOverhead,LoadImbalance,
  IdleTime,Contention,
  PerformanceModel,
  Runtime,WallTime,Throughput,
  TimeToSolution,LatencyToSolution,
  EnergyToSolution,
  Profiling,Tracing,
  PerformanceCounter,HardwareCounter,
  ParallelCorrectness,
  Determinism,Nondeterminism,
  DeterministicParallelism,
  Reproducibility,NumericalReproducibility,
  ReductionOrder,FloatingPointArithmetic,
  RoundOffError,AssociativityLoss,
  FaultTolerance,Resilience,
  CheckpointRestart,Replication,
  ParallelIO,CollectiveIO,
  DistributedFileSystem,
  HighPerformanceComputing,HPC,
  ScientificComputing,
  Verification,Benchmarking,
  ReferenceImplementation,
  ReproducibilityTest
 ]
 EXCLUDE_AS_PRIMARY = [
  SequentialComputingWithoutConcurrentExecution,
  GenericMultitaskingWithoutComputationalParallelism,
  DistributedSystemsWithoutConcurrentComputationalWorkloadSemantics,
  ComputerArchitectureWithoutParallelAlgorithmContext
 ]
 DISAMBIGUATION_RULE = "When multiple computational operations are intended to execute concurrently across threads, processes, cores, nodes or accelerators, interpret the context as parallel computing."
}

CORE_CONCEPTS {
 ParallelComputing = "Concurrent execution of computational work."
 TaskParallelism = "Parallel execution of distinct tasks or functions."
 DataParallelism = "Parallel execution of similar operations across different data partitions."
 SharedMemoryParallelism = "Parallel execution through threads sharing an address space."
 DistributedMemoryParallelism = "Parallel execution through processes communicating explicitly."
 Synchronisation = "Coordination that constrains the ordering or visibility of concurrent operations."
 LoadBalancing = "Distribution of work so processing elements remain effectively utilised."
 Scalability = "Ability to use increasing parallel resources effectively."
}

RELATIONS {
 ParallelComputing --is_child_of--> HighPerformanceComputing
 ParallelComputing --uses--> ParallelAlgorithm
 ParallelAlgorithm --decomposes_into--> ParallelTasks
 TaskParallelism --executes--> DistinctTasks
 DataParallelism --operates_on--> DataPartitions
 SharedMemoryParallelism --uses--> Threads
 DistributedMemoryParallelism --uses--> Processes
 Processes --communicate_via--> MessagePassing
 Threads --coordinate_via--> Synchronisation
 Barrier --is_type_of--> Synchronisation
 Mutex --provides--> MutualExclusion
 AtomicOperation --supports--> LockFreeCoordination
 RaceCondition --causes--> NondeterministicBehaviour
 Deadlock --prevents--> Progress
 LoadBalancing --reduces--> IdleTime
 WorkStealing --supports--> DynamicLoadBalancing
 StrongScaling --measures--> FixedProblemParallelScaling
 WeakScaling --measures--> FixedWorkPerProcessorScaling
 AmdahlsLaw --bounds--> Speedup
 Profiling --identifies--> ParallelBottleneck
 Verification --checks--> ParallelCorrectness
}

OPERATORS {
 SPEEDUP(T1,Tp) := T1/Tp
 EFFICIENCY(S,p) := S/p
 PARALLEL_WORK(tasks) := sum_i cost(task_i)
 SPAN(task_graph) := longest_dependency_path_cost
 IDEAL_PARALLEL_TIME(W,S,p) := max(W/p,S)
 LOAD_IMBALANCE(max_load,avg_load) := max_load/avg_load
 COMMUNICATION_COST(messages,latency,bandwidth) := sum(latency + bytes/bandwidth)
 PARALLEL_RUNTIME(compute,communication,synchronisation,scheduling,imbalance) := compute+communication+synchronisation+scheduling+imbalance
}

AXIOMS {
 A1 = "Parallel computing requires computational work that can execute concurrently."
 A2 = "Dependencies constrain available parallelism."
 A3 = "Parallel speedup is limited by serial work and parallel overhead."
 A4 = "Shared-memory correctness depends on synchronisation and memory-order semantics."
 A5 = "Distributed-memory execution requires explicit data exchange."
 A6 = "Load imbalance reduces parallel efficiency."
 A7 = "Execution order can affect floating-point and nondeterministic results."
 A8 = "Parallel-computing results require explicit decomposition, communication, synchronisation, correctness and reproducibility semantics."
}

REASONING {
 R1_CONTEXT = identify(workload,dependencies,data_size,execution_units,memory_model,performance_goal)
 R2_PARALLELISM = classify(data,task,domain,pipeline,vector_or_hybrid_parallelism)
 R3_DECOMPOSITION = partition(work,data_or_domain_into_parallel_units)
 R4_DEPENDENCIES = construct_or_identify(dependency_graph_and_critical_path)
 R5_EXECUTION_MODEL = choose(threads,processes,SPMD,MPMD,task_runtime,GPU_or_hybrid_model)
 R6_COORDINATION = define(communication,synchronisation,atomics,barriers_and_ordering)
 R7_BALANCE = configure(static_dynamic_guided_or_work_stealing_scheduling)
 R8_LOCALITY = optimise(data_placement,affinity,cache_and_NUMA_locality)
 R9_PROFILE = measure(runtime,communication,synchronisation,contention,imbalance_and_scaling)
 R10_VALIDATE = verify(correctness,race_freedom,deadlock_freedom,reproducibility_and_scalability)
}

CONSTRAINTS {
 C1 = "Parallelisation overhead can exceed computational savings for small workloads."
 C2 = "Fine-grained tasks can cause excessive scheduling and synchronisation overhead."
 C3 = "Shared mutable state can introduce races and contention."
 C4 = "Incorrect lock ordering can cause deadlock."
 C5 = "Barriers can amplify load imbalance."
 C6 = "Communication cost can dominate distributed-memory workloads."
 C7 = "False sharing can severely reduce shared-memory performance."
 C8 = "Oversubscription can increase context-switch and cache costs."
 C9 = "Floating-point reductions can vary with execution order."
 C10 = "More threads or processes do not guarantee higher performance."
}

SEMANTIC_EQUIVALENCE {
 "ParallelComputing" <=> "ParallelExecution"
 "SingleProgramMultipleData" <=> "SPMD"
 "MultipleProgramMultipleData" <=> "MPMD"
 "SingleInstructionMultipleData" <=> "SIMD"
 "SingleInstructionMultipleThreads" <=> "SIMT"
 "CompareAndSwap" <=> "CAS"
 "HighPerformanceComputing" <=> "HPC"
}

VALIDATION {
 V1 = "Parallel decomposition is documented."
 V2 = "Execution model and processing resources are documented."
 V3 = "Data dependencies and synchronisation are documented."
 V4 = "Communication patterns are documented."
 V5 = "Race, deadlock and data-consistency behaviour are tested."
 V6 = "Load balance and idle time are measured where relevant."
 V7 = "Strong or weak scaling is assessed where relevant."
 V8 = "Parallel output is compared with a trusted serial or reference implementation."
 V9 = "Numerical reproducibility is assessed where material."
 V10 = "Results are reproducible under documented resource, affinity and software settings."
}

CONFIDENCE {
 BASE_CONFIDENCE = 0.99
 PARALLEL_COMPUTING_DEFINITION = 0.99
 TASK_PARALLELISM_REASONING = 0.99
 DATA_PARALLELISM_REASONING = 0.99
 SHARED_MEMORY_REASONING = 0.99
 DISTRIBUTED_MEMORY_REASONING = 0.99
 SYNCHRONISATION_REASONING = 0.99
 SCALABILITY_REASONING = 0.99
 POLICY = "Reduce confidence when dependencies, memory model, decomposition, communication, synchronisation, scheduling, affinity or scaling measurements are underspecified."
}

AI_CONSUMPTION {
 PURPOSES = [
  SemanticSearch,OntologyGrounding,ParallelComputingReasoning,
  TaskParallelismReasoning,DataParallelismReasoning,
  DomainParallelismReasoning,PipelineParallelismReasoning,
  SharedMemoryReasoning,DistributedMemoryReasoning,
  ThreadReasoning,ProcessReasoning,
  SynchronisationReasoning,RaceConditionReasoning,
  DeadlockReasoning,MessagePassingReasoning,
  LoadBalancingReasoning,WorkStealingReasoning,
  LocalityReasoning,ScalabilityReasoning,
  WorkSpanReasoning,ProfilingReasoning,
  ParallelCorrectnessReasoning,ReproducibilityReasoning,
  KnowledgeGraphConstruction,RetrievalAugmentation,RecursiveInference
 ]
 NORMALISE {
  "parallel computing" -> ParallelComputing
  "parallel execution" -> ParallelComputing
  "SPMD" -> SingleProgramMultipleData
  "MPMD" -> MultipleProgramMultipleData
  "SIMD" -> SingleInstructionMultipleData
  "SIMT" -> SingleInstructionMultipleThreads
  "CAS" -> CompareAndSwap
  "HPC" -> HighPerformanceComputing
 }
}

EXECUTION_RULES {
 E1 = "If computational work is executed concurrently across multiple processing elements, activate ParallelComputingOntology."
 E2 = "Identify dependencies before selecting a parallel decomposition."
 E3 = "Choose data, task, domain, pipeline, vector or hybrid parallelism according to workload structure."
 E4 = "Define memory model, communication and synchronisation explicitly."
 E5 = "Minimise critical sections, barriers and unnecessary shared state."
 E6 = "Use load balancing and appropriate granularity to maintain utilisation."
 E7 = "Optimise affinity and data locality for shared-memory and NUMA systems."
 E8 = "Measure scalability and parallel overhead rather than assuming speedup."
 E9 = "Validate correctness, race freedom, deadlock freedom and reproducibility."
}

RECURSION {
 ENTRY = ParallelComputing
 EXPAND(ParallelComputing) -> [
  ParallelExecution,Concurrency,ParallelAlgorithm,
  ParallelProgram,ProcessingElement,Processor,
  CPU,Core,MulticoreProcessor,ManycoreProcessor,
  HardwareThread,GPU,Accelerator,Thread,
  Process,Task,Kernel,Worker,
  SharedMemory,DistributedMemory,HybridParallelism,
  DataParallelism,TaskParallelism,
  FunctionalParallelism,DomainParallelism,
  PipelineParallelism,LoopParallelism,
  VectorParallelism,SIMD,SIMT,MIMD,
  SPMD,MPMD,ForkJoinParallelism,
  MapReduce,DivideAndConquerParallelism,
  BulkSynchronousParallel,ActorModel,
  MessagePassing,SharedVariable,
  PrivateVariable,ThreadLocalStorage,
  CriticalSection,Mutex,Lock,Spinlock,
  Semaphore,AtomicOperation,CompareAndSwap,
  Barrier,Synchronisation,ConditionVariable,
  MemoryFence,MemoryConsistency,
  RaceCondition,DataRace,Deadlock,
  Livelock,Starvation,MutualExclusion,
  LockContention,FalseSharing,CacheCoherence,
  PointToPointCommunication,CollectiveCommunication,
  Broadcast,Reduce,AllReduce,Scatter,
  Gather,AllGather,AllToAll,
  BlockingCommunication,NonblockingCommunication,
  CommunicationLatency,CommunicationBandwidth,
  HaloExchange,DomainDecomposition,
  DataDecomposition,TaskDecomposition,
  BlockDecomposition,CyclicDecomposition,
  BlockCyclicDecomposition,GraphPartitioning,
  MeshPartitioning,SpatialPartitioning,
  ParticleDecomposition,LoadBalancing,
  StaticLoadBalancing,DynamicLoadBalancing,
  WorkStealing,TaskQueue,Scheduler,
  StaticScheduling,DynamicScheduling,
  GuidedScheduling,Affinity,Pinning,
  NUMA,Granularity,FineGrainedParallelism,
  CoarseGrainedParallelism,Dependency,
  DependencyGraph,TaskGraph,DAG,
  CriticalPath,Span,Work,WorkSpanModel,
  BrentsTheorem,ParallelPrefix,Scan,
  Reduction,ParallelSort,ParallelSearch,
  ParallelMatrixMultiplication,
  ParallelLinearAlgebra,ParallelFFT,
  ParallelGraphAlgorithm,ParallelSimulation,
  OpenMP,MPI,Pthreads,CUDA,
  OpenCL,HIP,SYCL,Speedup,
  ParallelEfficiency,StrongScaling,
  WeakScaling,AmdahlsLaw,GustafsonsLaw,
  SerialFraction,CommunicationOverhead,
  SynchronisationOverhead,LoadImbalance,
  Profiling,ParallelCorrectness,
  Determinism,Nondeterminism,
  NumericalReproducibility,FloatingPointArithmetic,
  FaultTolerance,CheckpointRestart,
  ParallelIO,HighPerformanceComputing,
  ScientificComputing,Verification,
  Benchmarking,Reproducibility
 ]
 EXPAND(ParallelComputingFamilies) -> [
  SharedMemoryParallelComputing,
  DistributedMemoryParallelComputing,
  DataParallelComputing,
  TaskParallelComputing,
  PipelineAndStreamingParallelism,
  VectorAndSIMDParallelism,
  GPUAndAcceleratorParallelism,
  HybridParallelComputing
 ]
 STOP_CONDITION = "Stop when parallelism, dependencies, execution model, decomposition, communication, synchronisation, scheduling, locality, correctness and scalability are sufficiently resolved."
}

ROUTING {
 PARENT_ONTOLOGY = "High Performance Computing Ontology 2"
 RELATED_ONTOLOGIES = [
  "High Performance Computing Ontology 2",
  "High Performance Computing",
  "Scientific Computing Ontology 2",
  "Numerical Linear Algebra Ontology 2",
  "Sparse Matrix Ontology 2",
  "Matrix Computation Ontology",
  "Spatial Partitioning Ontology 2",
  "Mesh Generation Ontology 2",
  "Particle Simulation Ontology",
  "Fluid Simulation Ontology",
  "Structural Simulation Ontology",
  "Floating Point Arithmetic Ontology",
  "Numerical Stability Ontology 2"
 ]
 ROUTE_RULES = [
  "Parallel Computing -> High Performance Computing Ontology 2 for parent semantics",
  "Parallel Computing -> Scientific Computing for scientific workload execution",
  "Parallel Computing -> Numerical Linear Algebra for parallel solvers and matrix kernels",
  "Parallel Computing -> Sparse Matrix for memory-bound sparse parallelism",
  "Parallel Computing -> Matrix Computation for dense data-parallel kernels",
  "Parallel Computing -> Spatial Partitioning for domain decomposition",
  "Parallel Computing -> Mesh Generation for parallel mesh workloads",
  "Parallel Computing -> Particle Simulation for particle-domain parallelism",
  "Parallel Computing -> Fluid Simulation for parallel CFD",
  "Parallel Computing -> Structural Simulation for parallel FEM",
  "Parallel Computing -> Floating Point Arithmetic for reduction-order effects",
  "Parallel Computing -> Numerical Stability for parallel numerical behaviour"
 ]
}

UPDATE_MODEL {
 MODE = "append-compatible semantic versioning"
 MAJOR = "ontology-breaking conceptual change"
 MINOR = "new compatible parallel models, runtimes or reasoning pathways"
 PATCH = "clarification, metadata or formatting correction"
 RULES = [
  "Preserve concurrency-versus-parallelism distinction where required.",
  "Preserve thread-versus-process distinction.",
  "Preserve shared-memory-versus-distributed-memory distinction.",
  "Preserve task-versus-data parallelism distinction.",
  "Preserve computation-versus-communication distinction.",
  "Preserve synchronisation-versus-communication distinction.",
  "Preserve correctness-versus-performance distinction.",
  "Preserve machine-readable parallel-computing semantics."
 ]
}

OUTPUT {
 CANONICAL_DEFINITION = "Parallel computing executes multiple computational operations concurrently across threads, processes, cores, nodes or accelerators."
 PARALLELISM_SUMMARY = "Data, task, domain, pipeline and vector parallelism expose different forms of concurrency."
 MEMORY_SUMMARY = "Shared-memory programs coordinate threads through synchronisation, while distributed-memory programs exchange data explicitly."
 CORRECTNESS_SUMMARY = "Race conditions, deadlock, memory ordering and dependencies determine parallel correctness."
 SCHEDULING_SUMMARY = "Static, dynamic, guided and work-stealing schedules trade overhead against load balance."
 SCALABILITY_SUMMARY = "Speedup, efficiency, critical path, strong scaling and weak scaling quantify useful parallelism."
 VALIDATION_SUMMARY = "Parallel programs should be checked for reference correctness, races, deadlocks, communication, load balance, scalability, numerical reproducibility and environment provenance."
}

FLOW {
 INPUT
 -> detect_parallel_computing_context
 -> identify_workload_dependencies_data_size_execution_units_memory_model_accuracy_goal_and_performance_goal
 -> classify_data_task_domain_pipeline_vector_shared_memory_distributed_memory_or_hybrid_parallelism
 -> construct_or_identify_dependency_graph_and_critical_path
 -> choose_thread_process_SPMD_MPMD_task_runtime_GPU_or_hybrid_execution_model
 -> partition_work_data_mesh_graph_domain_or_tasks
 -> configure_communication_synchronisation_atomics_memory_ordering_and_collectives
 -> configure_static_dynamic_guided_work_stealing_or_custom_scheduling
 -> optimise_granularity_affinity_cache_NUMA_and_data_locality
 -> execute_and_measure_runtime_communication_synchronisation_contention_idle_time_and_load_balance
 -> assess_speedup_efficiency_strong_scaling_weak_scaling_work_span_and_parallel_overhead
 -> verify_against_serial_or_reference_results
 -> test_race_deadlock_and_data_consistency_behaviour
 -> assess_numerical_reproducibility_and_reduction_order_effects
 -> document_resources_affinity_runtime_library_versions_configuration_and_provenance
 -> route_to_related_HPC_scientific_computing_linear_algebra_sparse_matrix_matrix_computation_spatial_partitioning_mesh_particle_fluid_structural_floating_point_and_stability_ontologies
 -> recursively_expand_required_dependencies
 -> verify_result
 -> assign_confidence
 -> produce_semantic_output
 -> END
}

SEMANTIC_SUMMARY {
 "The Parallel Computing Ontology defines concurrent computational execution across threads, processes, cores, nodes and accelerators. It supports task, data, functional, domain, pipeline, loop, vector, SIMD, SIMT, SPMD and MPMD forms of parallelism, fork-join and divide-and-conquer models, shared variables, locks, atomics, barriers and memory ordering, race conditions, deadlock, livelock and starvation, point-to-point and collective communication, halo exchange, domain, graph, mesh and particle decomposition, static and dynamic load balancing, work stealing, task scheduling, affinity and NUMA locality, work-span and critical-path reasoning, parallel reductions, sorting, FFT, linear algebra, graph algorithms and simulation, OpenMP, MPI, Pthreads, CUDA, OpenCL, HIP and SYCL relationships, speedup, efficiency, strong and weak scaling, Amdahl and Gustafson models, profiling, numerical reproducibility, fault tolerance, parallel I/O, verification and reproducibility."
}

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

}

END_FLOW