Cluster Computing Ontology

AI INTERPRETATION NOTE
This Flow Algebra defines the Cluster Computing Ontology within the Kireth Research Semantic Library. Cluster computing is the coordinated use of multiple networked computers, nodes or servers that operate together as a unified computational resource. This ontology supports compute clusters, head and worker nodes, schedulers, distributed-memory execution, resource allocation, queues, job submission, batch execution, cluster interconnects, storage, fault tolerance, load balancing, scaling, monitoring, high-throughput and high-performance workloads, provenance, verification and reproducibility.

FLOW_ALGEBRA_RECORD {

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

IDENTITY {
 PRIMARY_ENTITY = ClusterComputing
 ENTITY_CLASS = NetworkedMultiNodeComputeResourceFramework
 PRIMARY_CONTEXT = HighPerformanceComputing
 DEFINITION = "Cluster computing is the coordinated execution of computational workloads across a group of networked computers that are managed and used as a collective computing resource."
 SYMBOLIC_FORMS = [
  "Cluster = {Node_1,...,Node_n}",
  "Job -> Scheduler -> ResourceAllocation -> Execution",
  "T_total = T_queue + T_compute + T_communication + T_io",
  "throughput = completed_jobs / unit_time"
 ]
 SEMANTIC_ROLE = "Provides machine-readable semantics for cluster nodes, scheduling, queues, resource allocation, distributed execution, interconnects, shared storage, workload management, fault tolerance, scalability and reproducibility."
}

SCOPE {
 INCLUDE = [
  ClusterComputing,ComputeCluster,HPCCluster,
  ScientificCluster,HighThroughputCluster,
  BeowulfCluster,CommodityCluster,
  HomogeneousCluster,HeterogeneousCluster,
  OnPremiseCluster,CloudCluster,
  HybridCluster,ElasticCluster,
  ClusterNode,ComputeNode,WorkerNode,
  HeadNode,LoginNode,ManagementNode,
  ControllerNode,MasterNode,ServiceNode,
  StorageNode,GatewayNode,
  NodeGroup,NodePool,
  CPUNode,GPUNode,AcceleratorNode,
  MemoryNodeRelationship,
  Rack,Chassis,BladeServer,
  Processor,CPU,GPU,Accelerator,
  Core,HardwareThread,
  MainMemory,LocalStorage,
  SharedStorage,ParallelFileSystem,
  Lustre,GPFSRelationship,
  NFSRelationship,ObjectStorageRelationship,
  ScratchStorage,HomeStorage,
  BurstBufferRelationship,
  Interconnect,NetworkFabric,
  Ethernet,InfiniBand,
  OmniPathRelationship,NVLinkRelationship,
  NetworkTopology,FatTree,
  Dragonfly,Torus,ClosNetwork,
  Latency,Bandwidth,MessageRate,
  RDMA,RemoteDirectMemoryAccess,
  Scheduler,JobScheduler,
  BatchScheduler,WorkloadManager,
  ResourceManager,QueueManager,
  Slurm,PBSRelationship,
  TorqueRelationship,LSFRelationship,
  SGERelationship,
  HTCondorRelationship,
  KubernetesRelationship,
  Queue,Partition,QOS,
  QualityOfService,Reservation,
  BackfillScheduling,FairShare,
  Priority,JobPriority,
  Dependency,JobDependency,
  Job,ClusterJob,BatchJob,
  InteractiveJob,ArrayJob,
  JobArray,WorkflowJob,
  ParallelJob,SerialJob,
  MPIJob,OpenMPJob,HybridJob,
  GPUJob,EnsembleJob,
  ParameterSweep,HighThroughputJob,
  JobSubmission,JobScript,
  SubmissionCommand,
  ResourceRequest,ResourceAllocation,
  NodeAllocation,CoreAllocation,
  CPUAllocation,GPUAllocation,
  MemoryAllocation,WallTimeRequest,
  JobStart,JobEnd,JobState,
  Pending,Queued,Running,
  Completed,Failed,Cancelled,
  Preempted,Suspended,
  Preemption,Requeue,
  Retry,JobRestart,
  WallTime,Runtime,QueueTime,
  WaitTime,TurnaroundTime,
  Throughput,Utilisation,
  ClusterUtilisation,NodeUtilisation,
  CPUUtilisation,GPUUtilisation,
  MemoryUtilisation,
  QueueUtilisation,
  Efficiency,JobEfficiency,
  ResourceEfficiency,
  Oversubscription,
  Underutilisation,
  Fragmentation,ResourceFragmentation,
  BinPackingRelationship,
  LoadBalancing,StaticLoadBalancing,
  DynamicLoadBalancing,
  WorkDistribution,TaskDistribution,
  DataLocality,LocalityAwareScheduling,
  NodeAffinity,AntiAffinity,
  TopologyAwareScheduling,
  DistributedComputing,
  ParallelComputing,
  DistributedMemory,
  SharedMemoryWithinNode,
  MPI,MessagePassing,
  OpenMP,Threading,
  HybridMPIOMP,
  DomainDecomposition,
  DataDecomposition,
  TaskDecomposition,
  MeshPartitioning,GraphPartitioning,
  SpatialPartitioning,
  ParticleDecomposition,
  CollectiveCommunication,
  PointToPointCommunication,
  HaloExchange,GhostExchange,
  SharedFileSystem,
  ParallelIO,CollectiveIO,
  IOAggregation,IOBandwidth,
  MetadataServerRelationship,
  FileStriping,StripeCount,
  StripeSize,DataStaging,
  Checkpoint,CheckpointRestart,
  RestartFile,CheckpointIO,
  Workflow,ScientificWorkflow,
  Pipeline,DAG,
  WorkflowScheduler,
  TaskGraph,DependencyGraph,
  EnsembleComputing,
  HighThroughputComputing,HTC,
  HighPerformanceComputing,HPC,
  ThroughputComputing,
  CapacityComputing,CapabilityComputing,
  Scalability,StrongScaling,
  WeakScaling,Speedup,
  ParallelEfficiency,
  AmdahlsLaw,GustafsonsLaw,
  CommunicationOverhead,
  SynchronisationOverhead,
  LoadImbalance,IdleTime,
  PerformanceModel,
  Benchmark,HPL,HPCG,
  STREAMBenchmark,
  ApplicationBenchmark,
  ClusterBenchmark,
  Profiling,Monitoring,
  Telemetry,Metrics,
  Logging,CentralLogging,
  DistributedTracing,
  NodeHealth,HealthCheck,
  HardwareMonitor,
  TemperatureMonitor,
  PowerMonitor,
  PowerConsumption,EnergyEfficiency,
  GreenHPC,PowerCap,
  ThermalConstraint,
  FaultTolerance,Resilience,
  NodeFailure,DiskFailure,
  NetworkFailure,ProcessFailure,
  JobFailure,HardwareFailure,
  FailureDetection,Heartbeat,
  Watchdog,Failover,
  SpareNode,RedundantNode,
  CheckpointRecovery,
  JobMigration,NodeDrain,
  MaintenanceMode,
  ClusterMaintenance,
  RollingMaintenance,
  HighAvailability,
  ControllerFailover,
  SchedulerFailover,
  Redundancy,
  Security,Authentication,
  Authorisation,AccessControl,
  UserAccount,GroupAccount,
  ProjectAccount,AllocationAccount,
  Accounting,UsageAccounting,
  ResourceQuota,JobQuota,
  FairUsage,
  SoftwareEnvironment,
  EnvironmentModule,ModuleSystem,
  Compiler,CompilerVersion,
  Library,MathLibrary,
  BLAS,LAPACK,ScaLAPACK,
  PETSc,Trilinos,FFTW,
  MPIImplementation,
  OpenMPIRelationship,
  MPICHRelationship,
  Container,ApptainerRelationship,
  SingularityRelationship,
  DockerRelationship,
  EnvironmentVariable,
  Dependency,BuildConfiguration,
  Reproducibility,Repeatability,
  Provenance,Configuration,
  ClusterConfiguration,
  NodeConfiguration,
  SchedulerConfiguration,
  SoftwareVersion,
  FirmwareVersion,
  DriverVersion,
  TopologyVersion,
  Determinism,NumericalReproducibility,
  FloatingPointArithmetic,
  ReductionOrder,
  RoundOffError,
  Verification,Benchmarking,
  ReferenceRun,ReferenceResult
 ]
 EXCLUDE_AS_PRIMARY = [
  SingleNodeComputingWithoutClusterSemantics,
  GenericDistributedSystemsWithoutManagedClusterResourceSemantics,
  CloudComputingWithoutClusterExecutionContext,
  ComputerNetworkingWithoutWorkloadSchedulingOrComputeSemantics
 ]
 DISAMBIGUATION_RULE = "When multiple networked compute nodes are managed as a shared computational resource for scheduled workload execution, interpret the context as cluster computing."
}

CORE_CONCEPTS {
 ClusterComputing = "Coordinated computation across a managed group of networked compute nodes."
 ComputeNode = "Node providing CPU, GPU, memory or accelerator resources for workload execution."
 HeadNode = "Node providing cluster entry, orchestration or management functions."
 Scheduler = "System assigning queued jobs to cluster resources."
 Queue = "Logical collection of jobs awaiting or eligible for execution."
 ResourceAllocation = "Assignment of nodes, cores, memory, GPUs or time to a job."
 ParallelFileSystem = "Shared high-throughput storage system accessible across cluster nodes."
 ClusterUtilisation = "Fraction of available cluster resources used over time."
}

RELATIONS {
 ClusterComputing --is_child_of--> HighPerformanceComputing
 ClusterComputing --is_type_of--> DistributedComputing
 ClusterComputing --contains--> ComputeNode
 ClusterComputing --uses--> Scheduler
 Scheduler --assigns--> ResourceAllocation
 Queue --contains--> Jobs
 Job --requests--> Resources
 ResourceAllocation --assigns--> NodesAndCores
 HeadNode --manages--> ClusterServices
 WorkerNode --executes--> Job
 ParallelFileSystem --provides--> SharedStorage
 Interconnect --connects--> ClusterNodes
 MPIJob --uses--> DistributedMemoryExecution
 OpenMPJob --uses--> SharedMemoryWithinNode
 HybridJob --uses--> MPIAndThreading
 Monitoring --observes--> ClusterHealth
 CheckpointRestart --supports--> FaultRecovery
 LoadBalancing --improves--> ResourceUtilisation
 Verification --checks--> ClusterExecutionResult
}

OPERATORS {
 SUBMIT(job_spec) := place_job_into_scheduler_queue
 ALLOCATE(job,resources) := assign_nodes_cores_memory_GPUs_and_walltime
 SCHEDULE(queue,policy) := choose_next_eligible_jobs
 START(job,allocation) := launch_job_on_assigned_resources
 COMPLETE(job) := record_exit_state_metrics_and_outputs
 QUEUE_TIME(submit,start) := start-submit
 TURNAROUND_TIME(submit,end) := end-submit
 UTILISATION(used_capacity,total_capacity,time) := used_capacity/total_capacity
 JOB_EFFICIENCY(useful_compute,allocated_resource_time) := useful_compute/allocated_resource_time
 CLUSTER_THROUGHPUT(completed_jobs,interval) := completed_jobs/interval
}

AXIOMS {
 A1 = "Cluster computing manages multiple networked nodes as a collective compute resource."
 A2 = "Schedulers mediate access to finite cluster resources."
 A3 = "Queue time and runtime are distinct contributors to total turnaround time."
 A4 = "Cluster efficiency depends on scheduling, utilisation, communication, memory and I/O behaviour."
 A5 = "Heterogeneous nodes require resource-aware job placement."
 A6 = "Shared storage and interconnect performance can constrain otherwise compute-capable clusters."
 A7 = "Node failures and maintenance are normal operational concerns at sufficient scale."
 A8 = "Cluster-computing results require explicit resource, scheduler, topology, performance and reproducibility semantics."
}

REASONING {
 R1_CONTEXT = identify(workload_type,node_types,resource_requirements,parallel_model,storage_needs,performance_goal)
 R2_RESOURCES = classify(CPU_nodes,GPU_nodes,memory_capacity,interconnect_and_storage)
 R3_JOB = define(nodes,cores,threads,GPUs,memory,walltime,dependencies_and_environment)
 R4_SCHEDULER = choose_or_interpret(queue,priority,fairshare,reservation_backfill_and_preemption_policy)
 R5_PLACEMENT = map_job_to_nodes_with_affinity_locality_and_topology_constraints
 R6_EXECUTION = launch_serial_parallel_MPI_OpenMP_hybrid_GPU_or_ensemble_workload
 R7_STORAGE = configure(shared_filesystem,scratch,striping,checkpoint_and_staging)
 R8_MONITOR = measure(runtime,queue_time,utilisation,communication,IO,node_health_and_failures)
 R9_RECOVERY = apply(requeue,restart,checkpoint,failover_or_migration_if_required)
 R10_VALIDATE = verify(outputs,resource_usage,scaling,environment,provenance_and_reproducibility
}

CONSTRAINTS {
 C1 = "Long queue times can dominate user-perceived time to solution."
 C2 = "Over-requested resources reduce cluster utilisation."
 C3 = "Under-requested memory or wall time can cause job failure."
 C4 = "Poor node placement can increase communication cost."
 C5 = "Shared filesystem contention can limit application performance."
 C6 = "Heterogeneous hardware complicates reproducible performance comparison."
 C7 = "Backfill and fair-share policies can make job start time nondeterministic."
 C8 = "Node failures can invalidate long-running jobs without checkpointing."
 C9 = "High utilisation does not guarantee high scientific throughput."
 C10 = "Scheduler efficiency and application efficiency must be evaluated separately."
}

SEMANTIC_EQUIVALENCE {
 "ClusterComputing" <=> "ComputeClusterExecution"
 "HighPerformanceComputing" <=> "HPC"
 "HighThroughputComputing" <=> "HTC"
 "RemoteDirectMemoryAccess" <=> "RDMA"
 "MessagePassingInterface" <=> "MPI"
 "QualityOfService" <=> "QOS"
}

VALIDATION {
 V1 = "Cluster topology and node types are documented."
 V2 = "Scheduler and queue policies are documented."
 V3 = "Job resource requests are documented."
 V4 = "Software environment and module or container state are documented."
 V5 = "Interconnect and shared-storage assumptions are documented."
 V6 = "Queue, runtime and utilisation metrics are measured where relevant."
 V7 = "Parallel jobs are checked for expected scaling and process placement."
 V8 = "Failure, retry and checkpoint behaviour are tested where required."
 V9 = "Outputs are compared with trusted reference results."
 V10 = "Runs are reproducible under documented node, scheduler, software and configuration settings."
}

CONFIDENCE {
 BASE_CONFIDENCE = 0.99
 CLUSTER_COMPUTING_DEFINITION = 0.99
 SCHEDULER_REASONING = 0.99
 RESOURCE_ALLOCATION_REASONING = 0.99
 STORAGE_REASONING = 0.98
 TOPOLOGY_REASONING = 0.98
 RESILIENCE_REASONING = 0.98
 UTILISATION_REASONING = 0.99
 POLICY = "Reduce confidence when node types, scheduler policy, resource requests, topology, filesystem, placement, failure handling or software environment are underspecified."
}

AI_CONSUMPTION {
 PURPOSES = [
  SemanticSearch,OntologyGrounding,ClusterComputingReasoning,
  ComputeNodeReasoning,HeadNodeReasoning,
  SchedulerReasoning,QueueReasoning,
  ResourceAllocationReasoning,JobSubmissionReasoning,
  JobArrayReasoning,MPIJobReasoning,
  HybridJobReasoning,GPUJobReasoning,
  ParallelFileSystemReasoning,InterconnectReasoning,
  LoadBalancingReasoning,UtilisationReasoning,
  QueueTimeReasoning,WorkflowReasoning,
  FaultToleranceReasoning,MonitoringReasoning,
  ReproducibilityReasoning,KnowledgeGraphConstruction,
  RetrievalAugmentation,RecursiveInference
 ]
 NORMALISE {
  "cluster computing" -> ClusterComputing
  "compute cluster" -> ClusterComputing
  "HPC cluster" -> ClusterComputing
  "HPC" -> HighPerformanceComputing
  "HTC" -> HighThroughputComputing
  "MPI" -> MessagePassingInterface
  "RDMA" -> RemoteDirectMemoryAccess
  "QOS" -> QualityOfService
 }
}

EXECUTION_RULES {
 E1 = "If a workload executes on a managed set of networked compute nodes, activate ClusterComputingOntology."
 E2 = "Identify node types, scheduler, queue and storage before interpreting execution."
 E3 = "Request resources according to workload memory, CPU, GPU, wall-time and parallel requirements."
 E4 = "Use topology-aware placement when communication cost is significant."
 E5 = "Use job arrays or workflows for independent ensemble workloads."
 E6 = "Monitor queue time, runtime, utilisation, I/O and node health separately."
 E7 = "Use checkpointing or restart for long-running workloads when failure cost is significant."
 E8 = "Document scheduler policies and software environment for reproducibility."
 E9 = "Validate output correctness, resource efficiency, scaling and provenance."
}

RECURSION {
 ENTRY = ClusterComputing
 EXPAND(ClusterComputing) -> [
  ComputeCluster,HPCCluster,ScientificCluster,
  HighThroughputCluster,BeowulfCluster,
  HomogeneousCluster,HeterogeneousCluster,
  OnPremiseCluster,CloudCluster,HybridCluster,
  ClusterNode,ComputeNode,WorkerNode,
  HeadNode,LoginNode,ManagementNode,
  ControllerNode,StorageNode,GatewayNode,
  CPUNode,GPUNode,AcceleratorNode,
  Rack,Processor,CPU,GPU,Core,
  MainMemory,SharedStorage,ParallelFileSystem,
  Lustre,ScratchStorage,Interconnect,
  Ethernet,InfiniBand,NetworkTopology,
  FatTree,Dragonfly,Torus,Latency,
  Bandwidth,RDMA,Scheduler,JobScheduler,
  BatchScheduler,WorkloadManager,
  ResourceManager,Slurm,PBS,
  Queue,Partition,QOS,Reservation,
  BackfillScheduling,FairShare,Priority,
  Job,BatchJob,InteractiveJob,
  JobArray,ParallelJob,SerialJob,
  MPIJob,OpenMPJob,HybridJob,GPUJob,
  EnsembleJob,ParameterSweep,
  JobSubmission,JobScript,ResourceRequest,
  ResourceAllocation,NodeAllocation,
  CPUAllocation,GPUAllocation,
  MemoryAllocation,WallTimeRequest,
  Pending,Running,Completed,Failed,
  Cancelled,Preempted,Retry,Requeue,
  WallTime,Runtime,QueueTime,
  TurnaroundTime,Throughput,Utilisation,
  ClusterUtilisation,JobEfficiency,
  Oversubscription,ResourceFragmentation,
  LoadBalancing,LocalityAwareScheduling,
  NodeAffinity,TopologyAwareScheduling,
  DistributedComputing,ParallelComputing,
  DistributedMemory,SharedMemoryWithinNode,
  MPI,OpenMP,HybridMPIOMP,
  DomainDecomposition,MeshPartitioning,
  GraphPartitioning,SpatialPartitioning,
  ParticleDecomposition,HaloExchange,
  ParallelIO,CollectiveIO,FileStriping,
  CheckpointRestart,Workflow,DAG,
  HighThroughputComputing,HPC,
  StrongScaling,WeakScaling,Speedup,
  ParallelEfficiency,CommunicationOverhead,
  LoadImbalance,Benchmark,HPL,HPCG,
  Monitoring,Telemetry,Logging,
  NodeHealth,PowerConsumption,
  FaultTolerance,Resilience,NodeFailure,
  CheckpointRecovery,NodeDrain,
  HighAvailability,Authentication,
  Accounting,ResourceQuota,
  SoftwareEnvironment,EnvironmentModule,
  Compiler,Library,MPIImplementation,
  Container,Reproducibility,
  Provenance,ClusterConfiguration,
  SchedulerConfiguration,Verification
 ]
 EXPAND(ClusterComputingFamilies) -> [
  HPCComputeClusters,
  HighThroughputClusters,
  CPUAndGPUHeterogeneousClusters,
  BatchScheduledClusters,
  ClusterStorageAndIO,
  ResilientClusterComputing,
  ScientificWorkflowClusters,
  CloudAndElasticClusters
 ]
 STOP_CONDITION = "Stop when cluster resources, scheduler, job model, placement, storage, network, monitoring, resilience, performance 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",
  "Distributed Computing Ontology",
  "GPU Computing Ontology",
  "Vector Processing Ontology",
  "Scientific Computing Ontology 2",
  "Scientific Simulation Ontology",
  "Numerical Linear Algebra Ontology 2",
  "Mesh Generation Ontology 2",
  "Particle Simulation Ontology",
  "Fluid Simulation Ontology",
  "Structural Simulation Ontology",
  "Floating Point Arithmetic Ontology"
 ]
 ROUTE_RULES = [
  "Cluster Computing -> High Performance Computing Ontology 2 for parent semantics",
  "Cluster Computing -> Parallel Computing for parallel job execution",
  "Cluster Computing -> Distributed Computing for multi-node process semantics",
  "Cluster Computing -> GPU Computing for GPU node workloads",
  "Cluster Computing -> Vector Processing for CPU node SIMD workloads",
  "Cluster Computing -> Scientific Computing for scientific workload management",
  "Cluster Computing -> Scientific Simulation for scheduled simulation campaigns",
  "Cluster Computing -> Numerical Linear Algebra for distributed solver workloads",
  "Cluster Computing -> Mesh Generation for partitioned mesh processing",
  "Cluster Computing -> Particle Simulation for distributed particle workloads",
  "Cluster Computing -> Fluid Simulation for parallel CFD",
  "Cluster Computing -> Structural Simulation for parallel FEM",
  "Cluster Computing -> Floating Point Arithmetic for process-count-dependent numerical reproducibility"
 ]
}

UPDATE_MODEL {
 MODE = "append-compatible semantic versioning"
 MAJOR = "ontology-breaking conceptual change"
 MINOR = "new compatible cluster architectures, schedulers or reasoning pathways"
 PATCH = "clarification, metadata or formatting correction"
 RULES = [
  "Preserve node-versus-job distinction.",
  "Preserve scheduler-versus-application distinction.",
  "Preserve queue-time-versus-runtime distinction.",
  "Preserve allocation-versus-utilisation distinction.",
  "Preserve compute-resource-versus-storage-resource distinction.",
  "Preserve CPU-node-versus-GPU-node distinction.",
  "Preserve scheduler-efficiency-versus-application-efficiency distinction.",
  "Preserve machine-readable cluster-computing semantics."
 ]
}

OUTPUT {
 CANONICAL_DEFINITION = "Cluster computing coordinates scheduled workloads across a managed set of networked compute nodes."
 RESOURCE_SUMMARY = "Clusters expose CPUs, GPUs, memory, interconnect and shared storage as allocatable resources."
 SCHEDULER_SUMMARY = "Schedulers manage queues, priorities, fair share, reservations, backfill and resource placement."
 JOB_SUMMARY = "Serial, MPI, threaded, hybrid, GPU, array and ensemble jobs request resources and execute under scheduler control."
 STORAGE_SUMMARY = "Parallel filesystems and scratch storage support large shared data and checkpoint workloads."
 RESILIENCE_SUMMARY = "Monitoring, checkpointing, requeue, failover and maintenance procedures support reliable cluster operation."
 VALIDATION_SUMMARY = "Cluster workloads should be checked for output correctness, resource allocation, queue and runtime behaviour, scaling, I/O performance, resilience and reproducibility."
}

FLOW {
 INPUT
 -> detect_cluster_computing_context
 -> identify_workload_type_node_types_scheduler_queue_storage_interconnect_parallel_model_accuracy_goal_and_performance_goal
 -> classify_CPU_GPU_accelerator_homogeneous_or_heterogeneous_cluster_resources
 -> define_job_nodes_cores_threads_GPUs_memory_walltime_dependencies_environment_and_storage_requirements
 -> interpret_scheduler_queue_priority_fairshare_reservation_backfill_and_preemption_policy
 -> map_job_to_nodes_using_affinity_locality_and_topology_constraints
 -> launch_serial_MPI_OpenMP_hybrid_GPU_array_ensemble_or_workflow_execution
 -> configure_parallel_filesystem_scratch_staging_striping_and_checkpoint_IO
 -> monitor_queue_time_runtime_utilisation_communication_IO_node_health_and_failures
 -> if_failure_apply_requeue_restart_checkpoint_failover_or_migration_policy
 -> assess_cluster_and_job_efficiency_throughput_scaling_and_resource_fragmentation
 -> verify_output_against_reference_results
 -> document_node_types_scheduler_configuration_software_environment_resource_requests_versions_and_provenance
 -> route_to_related_HPC_parallel_distributed_GPU_vector_scientific_computing_simulation_linear_algebra_mesh_particle_fluid_structural_and_floating_point_ontologies
 -> recursively_expand_required_dependencies
 -> verify_result
 -> assign_confidence
 -> produce_semantic_output
 -> END
}

SEMANTIC_SUMMARY {
 "The Cluster Computing Ontology defines managed computation across groups of networked nodes. It supports HPC and high-throughput clusters, homogeneous and heterogeneous CPU, GPU and accelerator nodes, head, login, worker, storage and management nodes, shared and parallel storage, Ethernet and InfiniBand interconnects, schedulers and workload managers, queues, partitions, QoS, fair-share, reservations, backfill and preemption, serial, MPI, OpenMP, hybrid, GPU, array, ensemble and workflow jobs, resource requests for nodes, cores, GPUs, memory and wall time, queue time, turnaround and utilisation metrics, domain, mesh, graph, spatial and particle decomposition, parallel I/O and file striping, checkpoints and restart, monitoring, node health, fault tolerance, maintenance, accounting, software environments, modules, containers, scaling, verification, benchmarking and reproducibility."
}

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

}

END_FLOW