Distributed Computing Ontology

AI INTERPRETATION NOTE
This Flow Algebra defines the Distributed Computing Ontology within the Kireth Research Semantic Library. Distributed computing coordinates computational work across multiple networked machines or processes that communicate through message exchange and share no single global memory. This ontology supports distributed-memory execution, message passing, remote procedure calls, distributed data structures, consensus relationships, partitioning, replication, fault tolerance, synchronisation, distributed scheduling, load balancing, latency, bandwidth, consistency, scalability, parallel scientific workloads, cloud and cluster execution, verification and reproducibility.

FLOW_ALGEBRA_RECORD {

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

IDENTITY {
 PRIMARY_ENTITY = DistributedComputing
 ENTITY_CLASS = NetworkedMultiNodeComputationalExecutionFramework
 PRIMARY_CONTEXT = HighPerformanceComputing
 DEFINITION = "Distributed computing is the coordinated execution of computation across multiple autonomous networked processing nodes that communicate by exchanging data or messages."
 SYMBOLIC_FORMS = [
  "GlobalWork = union_i LocalWork_i",
  "T_total = T_compute + T_communication + T_synchronisation + T_failure_overhead",
  "message(i,j,payload) -> state_j'",
  "speedup=T_1/T_p"
 ]
 SEMANTIC_ROLE = "Provides machine-readable semantics for distributed-memory execution, node coordination, communication, partitioning, replication, consistency, synchronisation, failures, recovery, scalability and reproducibility."
}

SCOPE {
 INCLUDE = [
  DistributedComputing,DistributedExecution,
  DistributedSystem,DistributedAlgorithm,
  DistributedProgram,DistributedProcess,
  ComputeNode,WorkerNode,MasterNode,
  CoordinatorNode,ServiceNode,
  Process,Rank,Worker,Coordinator,
  DistributedMemory,LocalMemory,
  RemoteMemory,GlobalState,
  MessagePassing,Message,
  Send,Receive,PointToPointCommunication,
  CollectiveCommunication,Broadcast,
  Reduce,AllReduce,Scatter,Gather,
  AllGather,AllToAll,Barrier,
  BlockingCommunication,NonblockingCommunication,
  AsynchronousCommunication,SynchronousCommunication,
  Request,Response,RemoteProcedureCall,RPC,
  RemoteMethodInvocation,RMI,
  MessageQueue,Mailbox,Channel,
  PublishSubscribe,EventBus,
  Stream,DataStream,MessageBrokerRelationship,
  Network,Interconnect,NetworkFabric,
  Ethernet,InfiniBand,NVLinkRelationship,
  Latency,Bandwidth,Throughput,
  MessageRate,PacketLoss,NetworkJitter,
  CommunicationCost,CommunicationVolume,
  CommunicationPattern,Topology,
  StarTopology,RingTopology,MeshTopology,
  TreeTopology,TorusTopology,
  FatTree,DragonflyTopology,
  DistributedData,DataPartition,
  Shard,Sharding,Partition,
  HorizontalPartition,VerticalPartition,
  DomainDecomposition,DataDecomposition,
  GraphPartitioning,MeshPartitioning,
  SpatialPartitioning,ParticleDecomposition,
  BlockPartition,CyclicPartition,
  BlockCyclicPartition,
  Ownership,OwnerProcess,
  GhostRegion,HaloRegion,
  GhostCell,GhostParticle,
  HaloExchange,GhostExchange,
  Replication,Replica,
  PrimaryReplica,SecondaryReplica,
  ReplicationFactor,DataRedundancy,
  Consistency,StrongConsistency,
  EventualConsistency,CausalConsistency,
  SequentialConsistency,
  LinearizabilityRelationship,
  ConsistencyModel,ConsistencyLevel,
  Synchronisation,ClockSynchronisation,
  LogicalClock,LamportClock,
  VectorClock,Timestamp,
  Ordering,TotalOrder,PartialOrder,
  HappenedBeforeRelation,Causality,
  Consensus,LeaderElection,
  Quorum,MajorityQuorum,
  PaxosRelationship,RaftRelationship,
  ByzantineFaultRelationship,
  DistributedLock,Lease,
  DistributedBarrier,
  DistributedSemaphore,
  MutualExclusion,DistributedMutualExclusion,
  TaskDistribution,TaskScheduling,
  DistributedScheduler,
  WorkQueue,TaskQueue,
  WorkStealing,WorkSharing,
  StaticScheduling,DynamicScheduling,
  LoadBalancing,StaticLoadBalancing,
  DynamicLoadBalancing,
  LoadMigration,TaskMigration,
  DataMigration,ProcessMigration,
  Affinity,DataLocality,
  LocalityAwareScheduling,
  DistributedCache,CacheCoherenceRelationship,
  DistributedHashTable,DHT,
  ConsistentHashing,
  KeyValueStoreRelationship,
  DistributedArray,DistributedMatrix,
  DistributedVector,
  DistributedGraph,DistributedMesh,
  DistributedFileSystem,
  ParallelFileSystem,
  DistributedStorage,
  ObjectStorageRelationship,
  Checkpoint,CheckpointRestart,
  DistributedCheckpoint,
  CoordinatedCheckpoint,
  UncoordinatedCheckpoint,
  IncrementalCheckpoint,
  Snapshot,GlobalSnapshot,
  ChandyLamportSnapshot,
  FaultTolerance,Resilience,
  Failure,NodeFailure,ProcessFailure,
  NetworkFailure,PartitionFailure,
  NetworkPartition,SplitBrain,
  CrashFailure,FailStopFailure,
  OmissionFailure,ByzantineFailure,
  FailureDetector,Heartbeat,
  Timeout,Retry,Backoff,
  Recovery,Restart,Rollback,
  RollForward,ReplicationRecovery,
  Redundancy,Failover,
  HighAvailability,
  Idempotence,ExactlyOnceRelationship,
  AtLeastOnceRelationship,AtMostOnceRelationship,
  DuplicateSuppression,
  DistributedTransactionRelationship,
  TwoPhaseCommit,ThreePhaseCommit,
  TransactionCoordinator,
  Deadlock,DistributedDeadlock,
  Livelock,Starvation,
  DistributedTerminationDetection,
  DistributedGarbageCollectionRelationship,
  ParallelComputing,HPC,
  ClusterComputing,GridComputing,
  CloudComputingRelationship,
  EdgeComputingRelationship,
  FogComputingRelationship,
  FederatedComputingRelationship,
  VolunteerComputingRelationship,
  HighThroughputComputing,
  EnsembleComputing,
  WorkflowComputing,
  MapReduce,Map,ReduceOperation,
  BulkSynchronousParallel,BSPModel,
  ActorModel,DataflowModel,
  StreamingComputation,
  DistributedSharedMemory,DSM,
  PartitionedGlobalAddressSpace,PGAS,
  OneSidedCommunication,RDMA,
  RemoteDirectMemoryAccess,
  MPI,MessagePassingInterface,
  UPCRelationship,CoarrayFortranRelationship,
  SHMEMRelationship,
  SparkRelationship,HadoopRelationship,
  DaskRelationship,RayRelationship,
  DistributedDatabaseRelationship,
  DistributedMachineLearningRelationship,
  ParameterServerRelationship,
  AllReduceTrainingRelationship,
  DistributedOptimisation,
  DistributedLinearAlgebra,
  DistributedFFT,
  DistributedGraphAlgorithm,
  DistributedSimulation,
  DistributedMonteCarlo,
  DistributedParticleSimulation,
  DistributedCFD,
  DistributedFEM,
  Scalability,StrongScaling,WeakScaling,
  Speedup,ParallelEfficiency,
  AmdahlsLaw,GustafsonsLaw,
  CommunicationOverhead,
  SynchronisationOverhead,
  LoadImbalance,IdleTime,
  PerformanceModel,Runtime,
  TimeToSolution,Throughput,
  LatencyToSolution,
  EnergyToSolution,
  Profiling,Tracing,
  DistributedTracing,
  PerformanceCounter,
  Monitoring,Telemetry,
  Logging,DistributedLog,
  Provenance,Configuration,
  SoftwareVersion,ProtocolVersion,
  TopologyVersion,DeploymentConfiguration,
  Determinism,Nondeterminism,
  NumericalReproducibility,
  FloatingPointArithmetic,
  ReductionOrder,RoundOffError,
  Verification,Benchmarking,
  ReferenceImplementation,
  Reproducibility
 ]
 EXCLUDE_AS_PRIMARY = [
  SharedMemoryParallelismWithoutNetworkedNodeSemantics,
  SerialRemoteExecutionWithoutDistributedCoordination,
  GenericComputerNetworkingWithoutComputation,
  DistributedBusinessApplicationsWithoutComputationalWorkloadSemantics
 ]
 DISAMBIGUATION_RULE = "When computation is coordinated across multiple autonomous networked nodes that communicate through messages or remote data exchange, interpret the context as distributed computing."
}

CORE_CONCEPTS {
 DistributedComputing = "Computation coordinated across networked autonomous nodes."
 DistributedMemory = "Memory model in which each process or node owns local memory."
 MessagePassing = "Explicit exchange of data between distributed processes."
 Partitioning = "Division of data or work across nodes."
 Replication = "Maintenance of redundant state across multiple nodes."
 ConsistencyModel = "Rules defining how distributed state updates become visible."
 FaultTolerance = "Ability to continue or recover after distributed failures."
 Scalability = "Ability to use additional distributed resources effectively."
}

RELATIONS {
 DistributedComputing --is_child_of--> HighPerformanceComputing
 DistributedComputing --is_type_of--> ParallelComputing
 DistributedComputing --uses--> DistributedMemory
 DistributedMemory --requires--> Communication
 MessagePassing --connects--> DistributedProcesses
 MPI --implements--> MessagePassing
 DomainDecomposition --partitions--> ComputationalDomain
 DataPartition --is_owned_by--> Process
 GhostRegion --mirrors--> RemoteBoundaryData
 HaloExchange --updates--> GhostRegion
 Replication --supports--> FaultTolerance
 ConsistencyModel --governs--> ReplicaVisibility
 LogicalClock --orders--> DistributedEvents
 Consensus --coordinates--> DistributedAgreement
 LeaderElection --selects--> CoordinatorNode
 CheckpointRestart --supports--> Recovery
 LoadBalancing --redistributes--> Work
 DistributedScheduler --assigns--> Tasks
 Verification --checks--> DistributedComputationResult
}

OPERATORS {
 SEND(i,j,m) := transmit_message_from_i_to_j
 RECEIVE(j,m) := deliver_message_to_j
 BROADCAST(root,m) := send_m_to_all_participants
 REDUCE(values,op) := combine_distributed_values_using_op
 ALLREDUCE(values,op) := reduce_then_distribute_result
 PARTITION(data,p) := {data_1,...,data_p}
 HALO_EXCHANGE(local_state,neighbours) := update_remote_boundary_copies
 CONSISTENCY_APPLY(update,model) := propagate_update_according_to_consistency_rules
 RECOVER(checkpoint,failure) := restore_computation_from_recoverable_state
 DISTRIBUTED_RUNTIME(local_compute,communication,synchronisation,imbalance,failure_overhead) := sum_components
}

AXIOMS {
 A1 = "Distributed computing assumes independent processing nodes connected by a communication network."
 A2 = "There is no implicit globally shared memory in a distributed-memory model."
 A3 = "Communication latency and bandwidth are first-class execution costs."
 A4 = "Distributed state can be replicated, partitioned or both."
 A5 = "Failure is a normal design concern in sufficiently large distributed systems."
 A6 = "Consistency, availability and partition behaviour require explicit semantic choices."
 A7 = "Distributed execution order can affect numerical and logical reproducibility."
 A8 = "Distributed-computing results require explicit communication, partitioning, failure, consistency, scalability and reproducibility semantics."
}

REASONING {
 R1_CONTEXT = identify(workload,node_count,data_distribution,network,consistency_needs,failure_model,performance_goal)
 R2_PARTITION = choose(data,domain,graph,mesh,spatial,particle,task_or_hybrid_partitioning)
 R3_COMMUNICATION = define(point_to_point,collective,RPC,stream_or_one_sided_exchange)
 R4_OWNERSHIP = assign(data_and_task_ownership_and_ghost_regions)
 R5_COORDINATION = configure(ordering,barriers,locks,consensus_or_leader_coordination_if_required)
 R6_REPLICATION = if_required define(replication_factor,consistency_and_failover_policy)
 R7_SCHEDULING = choose(static,dynamic,locality_aware_or_work_stealing_distribution)
 R8_RESILIENCE = configure(checkpoint,retry,replication,heartbeat_and_recovery)
 R9_PROFILE = measure(compute,communication,latency,throughput,imbalance,failures_and_scalability)
 R10_VALIDATE = verify(correctness,consistency,failure_recovery,reproducibility_and_performance)
}

CONSTRAINTS {
 C1 = "Network latency can dominate fine-grained distributed workloads."
 C2 = "Insufficient bandwidth can limit distributed scaling."
 C3 = "Poor partitioning can produce excessive communication."
 C4 = "Replica consistency can increase coordination cost."
 C5 = "Network partitions can make strong coordination unavailable."
 C6 = "Distributed failure handling can introduce duplicate or reordered work."
 C7 = "Load imbalance can leave resources idle."
 C8 = "Global barriers can amplify the effect of slow nodes."
 C9 = "Distributed reductions can change floating-point results with process topology or order."
 C10 = "A correct failure-free run does not establish fault-tolerant correctness."
}

SEMANTIC_EQUIVALENCE {
 "DistributedComputing" <=> "DistributedExecution"
 "MessagePassingInterface" <=> "MPI"
 "PartitionedGlobalAddressSpace" <=> "PGAS"
 "RemoteDirectMemoryAccess" <=> "RDMA"
 "DistributedHashTable" <=> "DHT"
 "HighPerformanceComputing" <=> "HPC"
}

VALIDATION {
 V1 = "Node topology and network are documented."
 V2 = "Data and task partitioning are documented."
 V3 = "Ownership and ghost or halo semantics are documented."
 V4 = "Communication patterns and protocols are documented."
 V5 = "Consistency and replication semantics are documented where used."
 V6 = "Failure model and recovery policy are tested where relevant."
 V7 = "Load balance, latency and communication overhead are measured."
 V8 = "Strong or weak scaling is assessed where relevant."
 V9 = "Distributed results are compared with a trusted reference."
 V10 = "Runs are reproducible under documented process counts, topology, software and configuration settings."
}

CONFIDENCE {
 BASE_CONFIDENCE = 0.99
 DISTRIBUTED_COMPUTING_DEFINITION = 0.99
 MESSAGE_PASSING_REASONING = 0.99
 PARTITIONING_REASONING = 0.99
 CONSISTENCY_REASONING = 0.98
 REPLICATION_REASONING = 0.98
 FAULT_TOLERANCE_REASONING = 0.98
 SCALABILITY_REASONING = 0.99
 POLICY = "Reduce confidence when partitioning, ownership, communication, consistency, replication, failure model, topology or recovery semantics are underspecified."
}

AI_CONSUMPTION {
 PURPOSES = [
  SemanticSearch,OntologyGrounding,DistributedComputingReasoning,
  DistributedMemoryReasoning,MessagePassingReasoning,
  PartitioningReasoning,OwnershipReasoning,
  GhostRegionReasoning,CollectiveCommunicationReasoning,
  ReplicationReasoning,ConsistencyReasoning,
  LogicalClockReasoning,ConsensusReasoning,
  LeaderElectionReasoning,DistributedSchedulingReasoning,
  LoadBalancingReasoning,FaultToleranceReasoning,
  CheckpointReasoning,RecoveryReasoning,
  ScalabilityReasoning,DistributedPerformanceReasoning,
  ReproducibilityReasoning,KnowledgeGraphConstruction,
  RetrievalAugmentation,RecursiveInference
 ]
 NORMALISE {
  "distributed computing" -> DistributedComputing
  "distributed execution" -> DistributedComputing
  "MPI" -> MessagePassingInterface
  "PGAS" -> PartitionedGlobalAddressSpace
  "RDMA" -> RemoteDirectMemoryAccess
  "DHT" -> DistributedHashTable
  "HPC" -> HighPerformanceComputing
 }
}

EXECUTION_RULES {
 E1 = "If computation is coordinated across multiple networked nodes, activate DistributedComputingOntology."
 E2 = "Define partitioning, ownership and communication before execution."
 E3 = "Minimise remote data movement through locality-aware decomposition."
 E4 = "Use collectives, one-sided communication or RPC according to workload semantics."
 E5 = "Define consistency and replication explicitly when state is shared across nodes."
 E6 = "Treat failures, retries and duplicate work as first-class semantics."
 E7 = "Use locality-aware load balancing and minimise global barriers."
 E8 = "Measure communication, scaling and failure-recovery cost."
 E9 = "Validate correctness, consistency, recovery behaviour, reproducibility and performance."
}

RECURSION {
 ENTRY = DistributedComputing
 EXPAND(DistributedComputing) -> [
  DistributedExecution,DistributedSystem,
  DistributedAlgorithm,DistributedProgram,
  ComputeNode,WorkerNode,CoordinatorNode,
  Process,Rank,Worker,DistributedMemory,
  LocalMemory,RemoteMemory,MessagePassing,
  Message,Send,Receive,PointToPointCommunication,
  CollectiveCommunication,Broadcast,Reduce,
  AllReduce,Scatter,Gather,AllGather,
  AllToAll,Barrier,BlockingCommunication,
  NonblockingCommunication,AsynchronousCommunication,
  RemoteProcedureCall,RPC,MessageQueue,
  Network,Interconnect,Latency,Bandwidth,
  CommunicationCost,Topology,DataPartition,
  Shard,Sharding,DomainDecomposition,
  DataDecomposition,GraphPartitioning,
  MeshPartitioning,SpatialPartitioning,
  ParticleDecomposition,Ownership,
  GhostRegion,HaloRegion,HaloExchange,
  Replication,Replica,Consistency,
  StrongConsistency,EventualConsistency,
  CausalConsistency,LogicalClock,
  LamportClock,VectorClock,
  Causality,Consensus,LeaderElection,
  Quorum,DistributedLock,TaskScheduling,
  DistributedScheduler,WorkStealing,
  LoadBalancing,TaskMigration,
  DataMigration,DataLocality,
  DistributedHashTable,DHT,
  ConsistentHashing,DistributedArray,
  DistributedMatrix,DistributedGraph,
  DistributedFileSystem,CheckpointRestart,
  DistributedCheckpoint,GlobalSnapshot,
  FaultTolerance,Resilience,NodeFailure,
  NetworkPartition,FailureDetector,
  Heartbeat,Retry,Recovery,Failover,
  HighAvailability,TwoPhaseCommit,
  DistributedDeadlock,ParallelComputing,
  HPC,ClusterComputing,GridComputing,
  HighThroughputComputing,MapReduce,
  BulkSynchronousParallel,ActorModel,
  DistributedSharedMemory,PGAS,RDMA,
  MPI,DistributedOptimisation,
  DistributedLinearAlgebra,DistributedFFT,
  DistributedGraphAlgorithm,DistributedSimulation,
  DistributedParticleSimulation,DistributedCFD,
  DistributedFEM,Scalability,StrongScaling,
  WeakScaling,Speedup,ParallelEfficiency,
  CommunicationOverhead,LoadImbalance,
  Profiling,DistributedTracing,
  Monitoring,Provenance,NumericalReproducibility,
  FloatingPointArithmetic,Verification,
  Benchmarking,Reproducibility
 ]
 EXPAND(DistributedComputingFamilies) -> [
  DistributedMemoryScientificComputing,
  MessagePassingComputing,
  DistributedDataAndStateManagement,
  ReplicatedAndFaultTolerantComputing,
  DistributedSchedulingAndLoadBalancing,
  DistributedLinearAlgebraAndSimulation,
  DistributedWorkflowComputing,
  CloudAndClusterDistributedComputing
 ]
 STOP_CONDITION = "Stop when nodes, partitioning, ownership, communication, consistency, scheduling, replication, failure handling, scalability and reproducibility are sufficiently resolved."
}

ROUTING {
 PARENT_ONTOLOGY = "High Performance Computing Ontology 2"
 RELATED_ONTOLOGIES = [
  "High Performance Computing Ontology 2",
  "High Performance Computing",
  "Parallel Computing Ontology",
  "Scientific Computing Ontology 2",
  "Numerical Linear Algebra Ontology 2",
  "Sparse Matrix Ontology 2",
  "Spatial Partitioning Ontology 2",
  "Mesh Generation Ontology 2",
  "Particle Simulation Ontology",
  "Fluid Simulation Ontology",
  "Structural Simulation Ontology",
  "Monte Carlo Simulation Ontology",
  "Floating Point Arithmetic Ontology",
  "Numerical Stability Ontology 2"
 ]
 ROUTE_RULES = [
  "Distributed Computing -> High Performance Computing Ontology 2 for parent semantics",
  "Distributed Computing -> Parallel Computing for general parallel execution semantics",
  "Distributed Computing -> Scientific Computing for scientific workload implementation",
  "Distributed Computing -> Numerical Linear Algebra for distributed matrix and solver workloads",
  "Distributed Computing -> Sparse Matrix for sparse distributed data structures",
  "Distributed Computing -> Spatial Partitioning for domain ownership and sharding",
  "Distributed Computing -> Mesh Generation for partitioned mesh workloads",
  "Distributed Computing -> Particle Simulation for ghost-particle exchange",
  "Distributed Computing -> Fluid Simulation for distributed CFD",
  "Distributed Computing -> Structural Simulation for distributed FEM",
  "Distributed Computing -> Monte Carlo Simulation for distributed ensemble workloads",
  "Distributed Computing -> Floating Point Arithmetic for distributed reduction order",
  "Distributed Computing -> Numerical Stability for distributed numerical behaviour"
 ]
}

UPDATE_MODEL {
 MODE = "append-compatible semantic versioning"
 MAJOR = "ontology-breaking conceptual change"
 MINOR = "new compatible distributed models, protocols or reasoning pathways"
 PATCH = "clarification, metadata or formatting correction"
 RULES = [
  "Preserve local-memory-versus-remote-memory distinction.",
  "Preserve partitioning-versus-replication distinction.",
  "Preserve communication-versus-synchronisation distinction.",
  "Preserve consistency-versus-availability distinction.",
  "Preserve failure-free-versus-fault-tolerant correctness distinction.",
  "Preserve logical-time-versus-wall-clock-time distinction.",
  "Preserve data-ownership-versus-ghost-copy distinction.",
  "Preserve machine-readable distributed-computing semantics."
 ]
}

OUTPUT {
 CANONICAL_DEFINITION = "Distributed computing coordinates computation across multiple autonomous networked nodes through explicit communication and distributed state management."
 COMMUNICATION_SUMMARY = "Point-to-point, collective, RPC, streaming and one-sided operations move data between distributed processes."
 PARTITIONING_SUMMARY = "Data, domains, meshes, graphs, particles and tasks can be partitioned across nodes with explicit ownership."
 CONSISTENCY_SUMMARY = "Replicated state requires declared consistency, ordering and visibility semantics."
 RESILIENCE_SUMMARY = "Checkpointing, replication, retries and failure detection support recovery from node, process and network failures."
 SCALABILITY_SUMMARY = "Latency, bandwidth, partition quality, load balance and synchronisation determine distributed scaling."
 VALIDATION_SUMMARY = "Distributed workloads should be checked for correctness, consistency, recovery, communication cost, scalability, numerical reproducibility and deployment provenance."
}

FLOW {
 INPUT
 -> detect_distributed_computing_context
 -> identify_workload_node_count_data_distribution_network_consistency_requirements_failure_model_accuracy_goal_and_performance_goal
 -> choose_data_domain_graph_mesh_spatial_particle_task_or_hybrid_partitioning
 -> assign_data_task_and_boundary_ownership
 -> configure_point_to_point_collective_RPC_stream_or_one_sided_communication
 -> configure_halo_or_ghost_exchange_where_required
 -> if_replicated_define_replication_factor_consistency_visibility_and_failover_semantics
 -> configure_ordering_barriers_locks_consensus_or_leader_coordination_if_required
 -> choose_static_dynamic_locality_aware_or_work_stealing_scheduling
 -> configure_checkpoint_retry_heartbeat_replication_and_recovery_policy
 -> execute_and_measure_compute_communication_latency_throughput_imbalance_IO_and_failure_overhead
 -> assess_strong_or_weak_scaling_speedup_efficiency_and_resource_utilisation
 -> verify_against_serial_or_reference_results
 -> test_failure_recovery_network_partition_consistency_and_duplicate_work_behaviour
 -> assess_numerical_reproducibility_and_distributed_reduction_order_effects
 -> document_process_count_topology_protocol_versions_software_versions_configuration_and_provenance
 -> route_to_related_HPC_parallel_computing_scientific_computing_linear_algebra_sparse_matrix_spatial_partitioning_mesh_particle_fluid_structural_Monte_Carlo_floating_point_and_stability_ontologies
 -> recursively_expand_required_dependencies
 -> verify_result
 -> assign_confidence
 -> produce_semantic_output
 -> END
}

SEMANTIC_SUMMARY {
 "The Distributed Computing Ontology defines computational execution across autonomous networked nodes. It supports distributed-memory processes, message passing, point-to-point and collective communication, remote procedure calls, streams and channels, network latency and bandwidth, data, graph, mesh, spatial and particle partitioning, ownership and halo regions, replication and consistency models, logical clocks and event ordering, consensus and leader-election relationships, distributed scheduling, work stealing and load balancing, distributed arrays, matrices, graphs and file systems, coordinated and uncoordinated checkpoints, fault detection, network partitions, retries, failover and recovery, cluster, grid, high-throughput and workflow computing, map-reduce, BSP, actor and PGAS relationships, MPI, RDMA, distributed optimisation, linear algebra, FFT, graph algorithms and simulation, scaling, profiling, distributed tracing, numerical reproducibility, verification and reproducibility."
}

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

}

END_FLOW