GPU Computing Ontology

AI INTERPRETATION NOTE
This Flow Algebra defines the GPU Computing Ontology within the Kireth Research Semantic Library. GPU computing is the use of graphics processing units as massively parallel accelerators for scientific, numerical and data-intensive workloads. This ontology supports kernels, threads, warps, wavefronts, blocks, grids, SIMT execution, memory hierarchy, host-device transfers, occupancy, coalescing, divergence, synchronisation, atomics, streams, asynchronous execution, multi-GPU scaling, performance modelling, mixed precision, numerical reproducibility, profiling, resilience and scientific-computing integration.

FLOW_ALGEBRA_RECORD {

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

IDENTITY {
 PRIMARY_ENTITY = GPUComputing
 ENTITY_CLASS = MassivelyParallelAcceleratorComputingFramework
 PRIMARY_CONTEXT = HighPerformanceComputing
 DEFINITION = "GPU computing is the execution of computational workloads on graphics processing units using large numbers of parallel execution threads and specialised memory hierarchies."
 SYMBOLIC_FORMS = [
  "Kernel<<<grid,block>>>(data)",
  "throughput approx active_threads * work_per_thread",
  "occupancy = active_warps / maximum_supported_warps",
  "performance <= min(peak_compute, arithmetic_intensity * memory_bandwidth)"
 ]
 SEMANTIC_ROLE = "Provides machine-readable semantics for GPU architecture, SIMT execution, kernels, thread organisation, memory hierarchy, synchronisation, streams, data transfer, occupancy, performance, numerical behaviour and reproducibility."
}

SCOPE {
 INCLUDE = [
  GPUComputing,GPGPU,GeneralPurposeGPUComputing,
  GPU,GraphicsProcessingUnit,Accelerator,
  Device,Host,HostDeviceModel,
  StreamingMultiprocessor,SM,
  ComputeUnit,CU,
  CUDAcoreRelationship,StreamProcessor,
  TensorCore,MatrixCore,
  Warp,Wavefront,Thread,
  ThreadBlock,WorkGroup,WorkItem,
  Grid,Kernel,DeviceKernel,
  KernelLaunch,LaunchConfiguration,
  ThreadIndex,BlockIndex,GridDimension,
  BlockDimension,GlobalThreadIndex,
  SIMT,SingleInstructionMultipleThreads,
  SIMDRelationship,VectorExecution,
  WarpScheduler,WavefrontScheduler,
  InstructionIssue,Occupancy,
  ActiveWarp,ResidentBlock,
  Register,RegisterFile,
  RegisterPressure,RegisterSpill,
  LocalMemory,SharedMemory,
  SharedMemoryBank,BankConflict,
  GlobalMemory,DeviceMemory,
  ConstantMemory,TextureMemory,
  ReadOnlyCache,L1Cache,L2Cache,
  MemoryHierarchy,HighBandwidthMemory,HBM,
  UnifiedMemory,ManagedMemory,
  PinnedMemory,PageLockedMemory,
  HostMemory,DeviceMemoryTransfer,
  HostToDeviceTransfer,H2D,
  DeviceToHostTransfer,D2H,
  PeerToPeerTransfer,P2P,
  NVLink,PCIe,
  MemoryBandwidth,MemoryLatency,
  CoalescedMemoryAccess,UncoalescedAccess,
  MemoryTransaction,Alignment,
  CacheLine,MemoryCoalescing,
  SharedMemoryTiling,LoopTiling,
  DataReuse,MemoryLocality,
  ArithmeticIntensity,OperationalIntensity,
  ComputeBound,MemoryBound,
  BandwidthBound,LatencyBound,
  RooflineModel,
  BranchDivergence,ControlDivergence,
  WarpDivergence,Predication,
  Synchronisation,ThreadSynchronization,
  BlockSynchronization,
  Barrier,MemoryFence,
  WarpSynchronization,
  CooperativeGroups,
  AtomicOperation,AtomicAdd,
  AtomicCAS,CompareAndSwap,
  RaceCondition,DataRace,
  Determinism,Nondeterminism,
  Stream,CUDAStreamRelationship,
  CommandQueue,AsynchronousExecution,
  OverlapComputationCommunication,
  ConcurrentKernelExecution,
  Event,DeviceEvent,
  StreamSynchronization,
  AsynchronousCopy,
  Prefetch,MemoryPrefetch,
  DoubleBuffering,
  CUDA,OpenCL,HIP,SYCL,
  OpenACCRelationship,OpenMPTargetRelationship,
  KernelFusion,KernelFission,
  KernelLaunchOverhead,
  PersistentKernel,
  DynamicParallelism,
  GraphExecution,CUDAgraphRelationship,
  DeviceFunction,InlineFunction,
  Compiler,PTXRelationship,
  SPIRVRelationship,
  IntermediateRepresentation,
  JITCompilation,KernelCompilation,
  OccupancyCalculator,
  LaunchBounds,
  ThreadCoarsening,
  LoopUnrolling,
  SoftwarePipelining,
  SharedMemoryStaging,
  TiledAlgorithm,
  Reduction,ParallelReduction,
  PrefixSum,Scan,
  Histogram,Scatter,Gather,
  Sort,ParallelSort,
  MatrixMultiplication,GEMM,
  SparseMatrixVectorProduct,SpMV,
  SparseMatrixMultiplication,
  FFT,FastFourierTransform,
  Convolution,StencilComputation,
  MonteCarloGPU,
  ParticleSimulationGPU,
  MolecularDynamicsGPU,
  CFDGPU,FiniteElementGPU,
  ComputationalGeometryGPU,
  GraphAlgorithmGPU,
  ImageProcessingGPU,
  MachineLearningGPU,
  DeepLearningGPU,
  BatchedComputation,
  EnsembleComputation,
  MixedPrecision,
  HalfPrecision,FP16,
  BFloat16,BF16,
  TF32Relationship,
  SinglePrecision,FP32,
  DoublePrecision,FP64,
  TensorCoreComputation,
  AccumulationPrecision,
  NumericalStability,
  FloatingPointArithmetic,
  MachinePrecision,RoundOffError,
  AssociativityLoss,ReductionOrder,
  NumericalReproducibility,
  DeterministicKernel,
  ReproducibleReduction,
  MultiGPU,MultiGPUComputing,
  DeviceSelection,GPUAffinity,
  PeerAccess,PeerMemory,
  GPUDirect,GPUDirectRDMA,
  DistributedGPUComputing,
  NCCLRelationship,
  CollectiveCommunication,
  AllReduce,Broadcast,Reduce,
  Scatter,Gather,
  GPUAwareMPI,
  DistributedTrainingRelationship,
  DomainDecomposition,
  DataParallelism,ModelParallelism,
  PipelineParallelism,
  LoadBalancing,
  WorkPartitioning,
  DynamicLoadBalancing,
  Oversubscription,
  GPUVirtualisationRelationship,
  MultiInstanceGPU,MIGRelationship,
  Profiling,Profiler,
  NsightRelationship,
  RocprofRelationship,
  PerformanceCounter,HardwareCounter,
  OccupancyMetric,MemoryThroughput,
  DRAMThroughput,L2HitRate,
  WarpExecutionEfficiency,
  BranchEfficiency,
  SMUtilisation,
  TensorCoreUtilisation,
  KernelRuntime,TransferRuntime,
  TimeToSolution,Throughput,
  Speedup,Efficiency,
  StrongScaling,WeakScaling,
  EnergyEfficiency,PowerConsumption,
  ThermalThrottling,PowerLimit,
  FaultTolerance,Resilience,
  GPUFailure,DeviceReset,
  CheckpointRestart,
  ErrorDetection,ECCMemory,
  SilentDataCorruption,
  Reliability,
  Verification,Benchmarking,
  Microbenchmark,
  ReferenceImplementation,
  Reproducibility,
  Configuration,DriverVersion,
  RuntimeVersion,ToolkitVersion,
  CompilerVersion,KernelVersion,
  DeviceArchitecture,ComputeCapability,
  SoftwareEnvironment,Container,
  HighPerformanceComputing,HPC,
  ParallelComputing,DistributedComputing,
  ScientificComputing
 ]
 EXCLUDE_AS_PRIMARY = [
  CPUOnlyParallelComputingWithoutGPUAcceleration,
  GraphicsRenderingWithoutGeneralPurposeComputation,
  GenericAcceleratorComputingWithoutGPUSpecificExecutionSemantics,
  NeuralNetworkUsageWithoutGPUExecutionOrPerformanceSemantics
 ]
 DISAMBIGUATION_RULE = "When computational workloads execute on GPU hardware using kernels, SIMT thread groups or GPU memory hierarchies, interpret the context as GPU computing."
}

CORE_CONCEPTS {
 GPUComputing = "Massively parallel computation executed on graphics processing units."
 Kernel = "Function executed in parallel by many GPU threads."
 ThreadBlock = "Group of threads scheduled together and able to cooperate through block-local mechanisms."
 Warp = "Hardware scheduling unit consisting of a fixed-size group of GPU threads."
 SIMT = "Execution model in which groups of threads execute common instructions over separate data."
 Occupancy = "Ratio or measure of active execution resources relative to hardware capacity."
 CoalescedMemoryAccess = "Memory access pattern combining nearby thread accesses into efficient transactions."
 BranchDivergence = "Loss of SIMT efficiency when threads in a warp follow different control-flow paths."
}

RELATIONS {
 GPUComputing --is_child_of--> HighPerformanceComputing
 GPUComputing --is_type_of--> ParallelComputing
 GPU --executes--> Kernel
 Kernel --contains--> Threads
 Threads --group_into--> ThreadBlocks
 ThreadBlocks --schedule_on--> StreamingMultiprocessors
 Warp --schedules--> Threads
 SharedMemory --is_scoped_to--> ThreadBlock
 GlobalMemory --is_accessible_by--> KernelThreads
 CoalescedMemoryAccess --improves--> MemoryEfficiency
 BranchDivergence --reduces--> SIMTEfficiency
 Occupancy --depends_on--> RegistersAndSharedMemory
 CUDA --targets--> GPU
 OpenCL --targets--> HeterogeneousDevices
 HIP --targets--> GPU
 SYCL --targets--> HeterogeneousDevices
 Stream --orders--> GPUOperations
 AsynchronousCopy --supports--> OverlapComputationCommunication
 MultiGPU --uses--> PeerOrCollectiveCommunication
 Verification --checks--> GPUComputationResult
}

OPERATORS {
 GLOBAL_THREAD_ID(blockIdx,blockDim,threadIdx) := blockIdx*blockDim+threadIdx
 OCCUPANCY(active_warps,max_warps) := active_warps/max_warps
 ARITHMETIC_INTENSITY(flops,bytes) := flops/bytes
 ROOFLINE(I,P_peak,B_peak) := min(P_peak,I*B_peak)
 TRANSFER_TIME(bytes,bandwidth,latency) := latency+bytes/bandwidth
 GPU_RUNTIME(kernel,transfer,sync,launch) := kernel+transfer+sync+launch
 COALESCING_EFFICIENCY(useful_bytes,transaction_bytes) := useful_bytes/transaction_bytes
 PARALLEL_REDUCTION(values,op) := hierarchical_gpu_reduction(values,op)
}

AXIOMS {
 A1 = "GPU computing depends on exposing large quantities of parallel work."
 A2 = "Kernel performance depends on thread organisation, memory access and hardware occupancy."
 A3 = "GPU memory bandwidth and latency are first-class performance constraints."
 A4 = "Branch divergence reduces effective SIMT utilisation."
 A5 = "Host-device data movement can dominate workloads with low computational intensity."
 A6 = "Shared memory and registers improve locality but consume limited on-chip resources."
 A7 = "Parallel reduction order can affect floating-point reproducibility."
 A8 = "GPU-computing results require explicit kernel, memory, launch, performance and reproducibility semantics."
}

REASONING {
 R1_CONTEXT = identify(workload,data_parallelism,problem_size,device_architecture,precision_goal,performance_goal)
 R2_MAPPING = map(work_items_to_threads_blocks_grids_or_workgroups)
 R3_MEMORY = classify(data_as_register_shared_global_constant_texture_unified_or_host_resident)
 R4_ACCESS = analyse(coalescing,alignment,reuse,bank_conflicts_and_cache_behaviour)
 R5_CONTROL = analyse(branch_divergence,loop_structure_and_thread_activity)
 R6_OCCUPANCY = evaluate(register_pressure,shared_memory_usage,threads_per_block_and_residency)
 R7_OVERLAP = configure(streams,asynchronous_copy,prefetch_and_concurrent_execution)
 R8_MULTI_GPU = if_required partition_data_or_domain_and_configure_peer_collective_or_MPI_exchange)
 R9_PROFILE = measure(kernel_runtime,transfer_runtime,throughput,occupancy,memory_efficiency_and_scaling)
 R10_VALIDATE = verify(numerical_correctness,reproducibility,precision_sensitivity_and_environment_provenance)
}

CONSTRAINTS {
 C1 = "Small workloads may not expose enough parallelism to amortise GPU overhead."
 C2 = "Uncoalesced global-memory access can severely reduce throughput."
 C3 = "High register pressure can reduce occupancy."
 C4 = "Excess shared-memory use can reduce resident block count."
 C5 = "Branch divergence can serialise paths within a warp."
 C6 = "Host-device transfer cost can dominate low-intensity kernels."
 C7 = "Atomics can create contention under high update collisions."
 C8 = "Mixed precision can increase speed while reducing numerical robustness."
 C9 = "Multi-GPU scaling can be limited by interconnect bandwidth and communication."
 C10 = "Peak GPU throughput does not imply sustained application performance."
}

SEMANTIC_EQUIVALENCE {
 "GPUComputing" <=> "GPGPU"
 "GraphicsProcessingUnit" <=> "GPU"
 "SingleInstructionMultipleThreads" <=> "SIMT"
 "HighBandwidthMemory" <=> "HBM"
 "HostToDeviceTransfer" <=> "H2D"
 "DeviceToHostTransfer" <=> "D2H"
 "PeerToPeerTransfer" <=> "P2P"
 "HighPerformanceComputing" <=> "HPC"
}

VALIDATION {
 V1 = "GPU device architecture and compute capability are documented."
 V2 = "Kernel launch configuration is documented."
 V3 = "Memory placement and transfer strategy are documented."
 V4 = "Precision and accumulation semantics are documented."
 V5 = "Occupancy and resource usage are measured where relevant."
 V6 = "Kernel and transfer times are measured separately."
 V7 = "Results are compared with a trusted CPU or reference implementation."
 V8 = "Mixed-precision sensitivity is assessed where used."
 V9 = "Multi-GPU communication and scaling are assessed where relevant."
 V10 = "Runs are reproducible under documented driver, runtime, toolkit, compiler and hardware settings."
}

CONFIDENCE {
 BASE_CONFIDENCE = 0.99
 GPU_COMPUTING_DEFINITION = 0.99
 KERNEL_REASONING = 0.99
 MEMORY_REASONING = 0.99
 OCCUPANCY_REASONING = 0.99
 DIVERGENCE_REASONING = 0.99
 MULTI_GPU_REASONING = 0.98
 MIXED_PRECISION_REASONING = 0.98
 POLICY = "Reduce confidence when device architecture, launch configuration, memory strategy, precision, occupancy, transfer costs, divergence or profiling evidence are underspecified."
}

AI_CONSUMPTION {
 PURPOSES = [
  SemanticSearch,OntologyGrounding,GPUComputingReasoning,
  KernelReasoning,ThreadBlockReasoning,WarpReasoning,
  SIMTReasoning,MemoryHierarchyReasoning,
  CoalescingReasoning,SharedMemoryReasoning,
  OccupancyReasoning,BranchDivergenceReasoning,
  StreamReasoning,AsynchronousExecutionReasoning,
  MixedPrecisionReasoning,TensorCoreReasoning,
  MultiGPUReasoning,GPUCollectiveReasoning,
  ProfilingReasoning,RooflineReasoning,
  NumericalReproducibilityReasoning,
  VerificationReasoning,KnowledgeGraphConstruction,
  RetrievalAugmentation,RecursiveInference
 ]
 NORMALISE {
  "GPU computing" -> GPUComputing
  "GPGPU" -> GPUComputing
  "GPU" -> GraphicsProcessingUnit
  "SIMT" -> SingleInstructionMultipleThreads
  "HBM" -> HighBandwidthMemory
  "H2D" -> HostToDeviceTransfer
  "D2H" -> DeviceToHostTransfer
  "P2P" -> PeerToPeerTransfer
  "HPC" -> HighPerformanceComputing
 }
}

EXECUTION_RULES {
 E1 = "If a workload executes through GPU kernels or GPU thread groups, activate GPUComputingOntology."
 E2 = "Map independent work to threads and blocks according to data dependencies."
 E3 = "Place data according to locality, reuse and transfer cost."
 E4 = "Optimise global-memory coalescing and minimise unnecessary host-device movement."
 E5 = "Balance occupancy against register and shared-memory consumption."
 E6 = "Reduce branch divergence where it limits SIMT efficiency."
 E7 = "Use streams and asynchronous copies to overlap communication and computation where beneficial."
 E8 = "For multi-GPU workloads, partition work and measure inter-device communication explicitly."
 E9 = "Validate correctness, precision sensitivity, numerical reproducibility and environment provenance."
}

RECURSION {
 ENTRY = GPUComputing
 EXPAND(GPUComputing) -> [
  GPGPU,GeneralPurposeGPUComputing,GPU,
  GraphicsProcessingUnit,Accelerator,Device,Host,
  StreamingMultiprocessor,ComputeUnit,
  TensorCore,Warp,Wavefront,Thread,
  ThreadBlock,WorkGroup,WorkItem,Grid,
  Kernel,DeviceKernel,KernelLaunch,
  LaunchConfiguration,ThreadIndex,BlockIndex,
  SIMT,SIMD,Occupancy,ResidentBlock,
  Register,RegisterPressure,SharedMemory,
  SharedMemoryBank,BankConflict,GlobalMemory,
  DeviceMemory,ConstantMemory,TextureMemory,
  L1Cache,L2Cache,HBM,UnifiedMemory,
  PinnedMemory,HostToDeviceTransfer,
  DeviceToHostTransfer,PeerToPeerTransfer,
  NVLink,PCIe,MemoryBandwidth,
  CoalescedMemoryAccess,Alignment,
  SharedMemoryTiling,DataReuse,
  ArithmeticIntensity,RooflineModel,
  BranchDivergence,Predication,
  Synchronisation,Barrier,MemoryFence,
  AtomicOperation,AtomicAdd,AtomicCAS,
  RaceCondition,Stream,AsynchronousExecution,
  ConcurrentKernelExecution,Event,
  AsynchronousCopy,Prefetch,DoubleBuffering,
  CUDA,OpenCL,HIP,SYCL,
  KernelFusion,KernelLaunchOverhead,
  PersistentKernel,DynamicParallelism,
  JITCompilation,LaunchBounds,
  ThreadCoarsening,LoopUnrolling,
  ParallelReduction,PrefixSum,Scan,
  Histogram,MatrixMultiplication,GEMM,
  SparseMatrixVectorProduct,FFT,
  Convolution,StencilComputation,
  ParticleSimulationGPU,MolecularDynamicsGPU,
  CFDGPU,FiniteElementGPU,
  ComputationalGeometryGPU,GraphAlgorithmGPU,
  MachineLearningGPU,BatchedComputation,
  MixedPrecision,FP16,BF16,FP32,FP64,
  TensorCoreComputation,AccumulationPrecision,
  NumericalStability,FloatingPointArithmetic,
  NumericalReproducibility,MultiGPU,
  GPUAffinity,PeerAccess,GPUDirect,
  GPUDirectRDMA,NCCL,CollectiveCommunication,
  GPUAwareMPI,DomainDecomposition,
  DataParallelism,ModelParallelism,
  PipelineParallelism,Profiling,
  PerformanceCounter,MemoryThroughput,
  WarpExecutionEfficiency,BranchEfficiency,
  SMUtilisation,KernelRuntime,TransferRuntime,
  Speedup,StrongScaling,WeakScaling,
  EnergyEfficiency,FaultTolerance,
  ECCMemory,Verification,Benchmarking,
  DriverVersion,RuntimeVersion,ToolkitVersion,
  DeviceArchitecture,HighPerformanceComputing,
  ParallelComputing,DistributedComputing,
  ScientificComputing,Reproducibility
 ]
 EXPAND(GPUComputingFamilies) -> [
  SingleGPUGeneralPurposeComputing,
  GPUKernelAndSIMTExecution,
  GPUMemoryOptimisation,
  MixedPrecisionAndTensorCoreComputing,
  MultiGPUComputing,
  GPUScientificComputing,
  GPUPerformanceEngineering,
  ResilientAndReproducibleGPUComputing
 ]
 STOP_CONDITION = "Stop when device, kernel mapping, memory, launch configuration, occupancy, divergence, transfer, precision, scaling and validation 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",
  "Scientific Computing Ontology 2",
  "Numerical Linear Algebra Ontology 2",
  "Sparse Matrix Ontology 2",
  "Matrix Computation Ontology",
  "Particle Simulation Ontology",
  "Molecular Simulation Ontology",
  "Fluid Simulation Ontology",
  "Structural Simulation Ontology",
  "Computational Geometry Ontology 2",
  "Floating Point Arithmetic Ontology",
  "Numerical Stability Ontology 2"
 ]
 ROUTE_RULES = [
  "GPU Computing -> High Performance Computing Ontology 2 for parent semantics",
  "GPU Computing -> Parallel Computing for generic parallel execution semantics",
  "GPU Computing -> Distributed Computing for multi-GPU and GPU-aware MPI workloads",
  "GPU Computing -> Scientific Computing for scientific accelerator workloads",
  "GPU Computing -> Numerical Linear Algebra for GPU solvers and BLAS-style kernels",
  "GPU Computing -> Sparse Matrix for SpMV and irregular memory-access kernels",
  "GPU Computing -> Matrix Computation for dense GEMM and tensor-core workloads",
  "GPU Computing -> Particle and Molecular Simulation for GPU neighbour and force kernels",
  "GPU Computing -> Fluid Simulation for GPU CFD",
  "GPU Computing -> Structural Simulation for GPU FEM",
  "GPU Computing -> Computational Geometry for GPU spatial algorithms",
  "GPU Computing -> Floating Point Arithmetic for mixed-precision and reduction-order effects",
  "GPU Computing -> Numerical Stability for finite-precision accelerator behaviour"
 ]
}

UPDATE_MODEL {
 MODE = "append-compatible semantic versioning"
 MAJOR = "ontology-breaking conceptual change"
 MINOR = "new compatible GPU architectures, programming models or performance pathways"
 PATCH = "clarification, metadata or formatting correction"
 RULES = [
  "Preserve host-versus-device distinction.",
  "Preserve thread-versus-warp-versus-block distinction.",
  "Preserve on-chip-versus-global-memory distinction.",
  "Preserve compute-bound-versus-memory-bound distinction.",
  "Preserve occupancy-versus-utilisation distinction.",
  "Preserve control-divergence-versus-load-imbalance distinction.",
  "Preserve single-GPU-versus-multi-GPU distinction.",
  "Preserve machine-readable GPU-computing semantics."
 ]
}

OUTPUT {
 CANONICAL_DEFINITION = "GPU computing executes massively parallel workloads on graphics processing units using kernels, thread groups and specialised memory hierarchies."
 EXECUTION_SUMMARY = "Threads execute kernels in warps or wavefronts organised into blocks or workgroups."
 MEMORY_SUMMARY = "Registers, shared memory, caches, global memory and HBM form a hierarchy with different capacity, latency and scope."
 PERFORMANCE_SUMMARY = "Occupancy, coalescing, arithmetic intensity, divergence and transfer overhead strongly influence throughput."
 ASYNC_SUMMARY = "Streams, events and asynchronous copies can overlap kernel execution and data movement."
 MULTI_GPU_SUMMARY = "Multi-GPU workloads require explicit partitioning, peer or collective communication and topology-aware scaling."
 VALIDATION_SUMMARY = "GPU workloads should be checked for reference correctness, precision sensitivity, memory efficiency, occupancy, transfer cost, scalability, numerical reproducibility and environment provenance."
}

FLOW {
 INPUT
 -> detect_GPU_computing_context
 -> identify_workload_data_parallelism_problem_size_device_architecture_precision_goal_and_performance_goal
 -> map_work_to_threads_blocks_grids_or_workgroups
 -> choose_launch_configuration_and_resource_limits
 -> classify_data_as_register_shared_global_constant_texture_unified_or_host_resident
 -> analyse_coalescing_alignment_reuse_bank_conflicts_cache_behaviour_and_host_device_transfer
 -> analyse_branch_divergence_control_flow_and_thread_activity
 -> assess_register_pressure_shared_memory_usage_occupancy_and_residency
 -> configure_streams_asynchronous_copy_prefetch_and_concurrent_execution
 -> if_multi_GPU_partition_data_or_domain_and_configure_peer_NCCL_MPI_or_GPUDirect_exchange
 -> execute_and_profile_kernel_runtime_transfer_runtime_memory_throughput_occupancy_and_utilisation
 -> assess_arithmetic_intensity_roofline_position_speedup_and_scaling
 -> evaluate_mixed_precision_and_reduction_order_effects_if_used
 -> verify_against_CPU_or_reference_results
 -> document_device_architecture_driver_runtime_toolkit_compiler_versions_launch_configuration_and_provenance
 -> route_to_related_HPC_parallel_distributed_scientific_computing_linear_algebra_sparse_matrix_matrix_computation_particle_molecular_fluid_structural_geometry_floating_point_and_stability_ontologies
 -> recursively_expand_required_dependencies
 -> verify_result
 -> assign_confidence
 -> produce_semantic_output
 -> END
}

SEMANTIC_SUMMARY {
 "The GPU Computing Ontology defines general-purpose scientific and numerical computation on graphics processing units. It supports kernels, threads, warps, wavefronts, thread blocks, workgroups, grids and SIMT execution, streaming multiprocessors and compute units, registers, shared, global, constant and texture memory, caches, HBM and unified memory, host-device and peer transfers, memory coalescing, bank conflicts, occupancy and register pressure, branch divergence, synchronisation and atomics, streams, events, asynchronous copies and concurrent kernels, CUDA, OpenCL, HIP and SYCL relationships, kernel fusion, persistent kernels and dynamic parallelism, reductions, scans, GEMM, SpMV, FFT, convolution and stencil workloads, GPU particle, molecular, fluid, structural and geometry computation, mixed precision, tensor cores, multi-GPU, GPUDirect, NCCL and GPU-aware MPI relationships, profiling, roofline analysis, numerical reproducibility, resilience, verification and reproducibility."
}

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

}

END_FLOW