Multi-Core Processing Ontology

AI SEARCH

FLOW ALGEBRA — MULTI-CORE PROCESSING ONTOLOGY
Semantic Library
Version: 4.0
Canonical Page:
https://kirethresearch.org/booksai-core/ontologies/computing-ontologies/computer-architecture/multi-core-processing-ontology.html

FLOW MULTI_CORE_PROCESSING_ONTOLOGY {

  META {
    DOMAIN = "Computing Ontologies"
    SUBDOMAIN = "Computer Architecture"
    ONTOLOGY = "Multi-Core Processing Ontology"
    PURPOSE = "Formalise multi-core processor entities, parallel execution, thread scheduling, shared resources, cache coherence, synchronisation and performance relationships."
    LOCALE = "en-GB"
  }

  ENTITY_TYPES {
    MULTI_CORE_PROCESSOR
    PROCESSOR
    CPU
    CORE
    PHYSICAL_CORE
    LOGICAL_CORE
    HARDWARE_THREAD
    THREAD
    PROCESS
    TASK
    WORKLOAD
    SCHEDULER
    OPERATING_SYSTEM
    INSTRUCTION
    EXECUTION_UNIT
    REGISTER_FILE
    PRIVATE_CACHE
    SHARED_CACHE
    L1_CACHE
    L2_CACHE
    L3_CACHE
    MAIN_MEMORY
    MEMORY_CONTROLLER
    INTERCONNECT
    BUS
    NETWORK_ON_CHIP
    SHARED_RESOURCE
    PRIVATE_RESOURCE
    CACHE_LINE
    COHERENCE_PROTOCOL
    COHERENCE_STATE
    MEMORY_MODEL
    MEMORY_ORDERING
    SYNCHRONISATION
    LOCK
    MUTEX
    SEMAPHORE
    BARRIER
    ATOMIC_OPERATION
    CRITICAL_SECTION
    RACE_CONDITION
    DATA_RACE
    DEADLOCK
    STARVATION
    FALSE_SHARING
    LOAD_BALANCE
    AFFINITY
    CORE_AFFINITY
    NUMA_DOMAIN
    PARALLEL_REGION
    SERIAL_REGION
    SPEEDUP
    EFFICIENCY
    SCALABILITY
    LATENCY
    THROUGHPUT
    UTILISATION
    CONTENTION
    STATE
    EVENT
    CONFIGURATION
    VERSION
    PERFORMANCE_METRIC
    POWER
    TEMPERATURE
    EVIDENCE
    CONFIDENCE_SCORE
    PROVENANCE_RECORD
  }

  RELATIONSHIPS {
    IS_A
    INSTANCE_OF
    PART_OF
    CONTAINS
    HAS_CORE
    HAS_THREAD
    EXECUTES
    SCHEDULES
    ASSIGNS_TO
    MIGRATES_TO
    HAS_AFFINITY
    SHARES
    HAS_PRIVATE_RESOURCE
    HAS_SHARED_RESOURCE
    READS
    WRITES
    ACCESSES
    COMMUNICATES_WITH
    SYNCHRONISES_WITH
    LOCKS
    UNLOCKS
    WAITS_FOR
    SIGNALS
    CONFLICTS_WITH
    CONTENDS_FOR
    COHERENT_WITH
    INVALIDATES
    UPDATES
    HAS_COHERENCE_STATE
    HAS_MEMORY_ORDERING
    HAS_STATE
    TRANSITIONS_TO
    HAS_SPEEDUP
    HAS_EFFICIENCY
    HAS_SCALABILITY
    HAS_LATENCY
    HAS_THROUGHPUT
    HAS_UTILISATION
    HAS_POWER
    HAS_TEMPERATURE
    HAS_CONFIGURATION
    HAS_VERSION
    DEPENDS_ON
    PRECEDES
    FOLLOWS
    DERIVED_FROM
    INFERRED_FROM
    HAS_EVIDENCE
    HAS_CONFIDENCE
    HAS_PROVENANCE
    MAPS_TO
    SEMANTICALLY_EQUIVALENT_TO
  }

  INPUTS {
    PROCESSOR_SPECIFICATIONS
    CORE_TOPOLOGIES
    THREAD_DATA
    PROCESS_DATA
    SCHEDULER_TRACES
    CORE_AFFINITY_DATA
    CACHE_HIERARCHIES
    COHERENCE_PROTOCOLS
    MEMORY_MODELS
    MEMORY_ACCESS_TRACES
    SYNCHRONISATION_TRACES
    INTERCONNECT_TOPOLOGIES
    PERFORMANCE_COUNTERS
    WORKLOAD_DATA
    POWER_METRICS
    TEMPERATURE_METRICS
    CONFIGURATION_DATA
    VERSION_DATA
    ONTOLOGY_TERMS
  }

  NORMALISE {
    STANDARDISE_PROCESSOR_IDENTIFIERS
    NORMALISE_CORE_IDENTIFIERS
    NORMALISE_THREAD_IDENTIFIERS
    NORMALISE_CACHE_LEVEL_NAMES
    NORMALISE_COHERENCE_STATES
    NORMALISE_MEMORY_ORDERING_TERMS
    NORMALISE_SYNCHRONISATION_PRIMITIVES
    NORMALISE_PERFORMANCE_METRICS
    NORMALISE_POWER_UNITS
    NORMALISE_TEMPERATURE_UNITS
    NORMALISE_VERSION_IDENTIFIERS
    RESOLVE_CORE_AND_THREAD_IDENTITIES
    ALIGN_ONTOLOGY_TERMS
    REMOVE_DUPLICATES
    VALIDATE_METADATA
    PRESERVE_PROVENANCE
  }

  PROCESS MULTI_CORE_EXECUTION {
    WORKLOAD
      -> TASK_OR_THREAD_DECOMPOSITION
      -> SCHEDULING
      -> CORE_ASSIGNMENT
      -> PARALLEL_EXECUTION
      -> SYNCHRONISATION
      -> RESULT_COMPOSITION
  }

  PROCESS SCHEDULING_REASONING {
    RUNNABLE_THREADS
      -> SCHEDULER_POLICY

    SCHEDULER_POLICY
      -> CORE_SELECTION

    CORE_SELECTION
      -> THREAD_ASSIGNMENT

    THREAD_ASSIGNMENT
      -> EXECUTION

    MIGRATION_EVENT
      -> NEW_CORE_ASSIGNMENT
  }

  PROCESS SHARED_MEMORY_REASONING {
    CORE_A + CORE_B + SHARED_MEMORY_LOCATION
      -> MEMORY_ACCESS_RELATIONS

    MEMORY_ACCESS_RELATIONS
      -> READ_WRITE_ORDER_ANALYSIS

    READ_WRITE_ORDER_ANALYSIS
      -> MEMORY_MODEL_CHECK

    MEMORY_MODEL_CHECK
      -> VALID_ORDER_OR_CONCURRENCY_HAZARD
  }

  PROCESS CACHE_COHERENCE_REASONING {
    CACHE_LINE + MULTIPLE_PRIVATE_CACHES
      -> COHERENCE_TRACKING

    READ_OR_WRITE_EVENT
      -> COHERENCE_PROTOCOL_TRANSITION

    COHERENCE_PROTOCOL_TRANSITION
      -> INVALIDATE_OR_UPDATE_OR_SHARE

    RESULT
      -> NEW_COHERENCE_STATES
  }

  PROCESS SYNCHRONISATION_REASONING {
    THREAD_A + THREAD_B + SHARED_RESOURCE
      -> SYNCHRONISATION_REQUIREMENT

    SYNCHRONISATION_REQUIREMENT
      -> LOCK_OR_ATOMIC_OR_BARRIER

    SYNCHRONISATION_EVENT
      -> ORDERING_CONSTRAINT

    ORDERING_CONSTRAINT
      -> SAFE_ACCESS_OR_WAIT
  }

  PROCESS RACE_REASONING {
    ACCESS_A + ACCESS_B
      -> SAME_MEMORY_LOCATION_CHECK

    SAME_MEMORY_LOCATION
      + CONCURRENT_OR_UNORDERED_ACCESS
      + AT_LEAST_ONE_WRITE
      -> DATA_RACE_CANDIDATE

    DATA_RACE_CANDIDATE
      -> SYNCHRONISATION_CHECK

    NO_VALID_SYNCHRONISATION
      -> DATA_RACE
  }

  PROCESS DEADLOCK_REASONING {
    THREADS + LOCK_DEPENDENCIES
      -> WAIT_FOR_GRAPH

    WAIT_FOR_GRAPH
      -> CYCLE_DETECTION

    CYCLE
      -> DEADLOCK_CANDIDATE

    DEADLOCK_CANDIDATE
      -> RESOURCE_AND_STATE_VALIDATION
  }

  PROCESS FALSE_SHARING_REASONING {
    CORE_A_WRITES + CORE_B_WRITES_OR_READS
      -> CACHE_LINE_MAPPING

    DISTINCT_DATA_SAME_CACHE_LINE
      -> COHERENCE_TRAFFIC_ANALYSIS

    EXCESS_COHERENCE_TRAFFIC
      -> FALSE_SHARING_CANDIDATE
  }

  PROCESS PERFORMANCE_REASONING {
    WORKLOAD + CORE_COUNT + CONFIGURATION
      -> PARALLEL_EXECUTION_PROFILE

    PARALLEL_EXECUTION_PROFILE
      -> SERIAL_FRACTION
      -> PARALLEL_FRACTION
      -> LOAD_BALANCE
      -> SYNCHRONISATION_OVERHEAD
      -> MEMORY_CONTENTION
      -> CACHE_COHERENCE_OVERHEAD
      -> SPEEDUP
      -> EFFICIENCY
      -> SCALABILITY

    PARALLEL_EXECUTION_PROFILE
      -> BOTTLENECK_HYPOTHESIS
  }

  RULES {
    IF THREAD_EXECUTES
    THEN LINK THREAD TO CORE_AND_TIME_CONTEXT

    IF SHARED_MEMORY_IS_ACCESSED_BY_MULTIPLE_THREADS
    THEN PRESERVE MEMORY_ORDERING_AND_SYNCHRONISATION_CONTEXT

    IF TWO_ACCESSES_TARGET_SAME_LOCATION
    AND AT_LEAST_ONE_IS_WRITE
    THEN CHECK_ORDERING_AND_SYNCHRONISATION_BEFORE_ASSERTING_DATA_RACE

    IF WAIT_FOR_GRAPH_HAS_CYCLE
    THEN DO_NOT_ASSERT_DEADLOCK_UNLESS_RESOURCE_AND_STATE_CONDITIONS_SUPPORT_IT

    IF CORE_COUNT_INCREASES
    THEN DO_NOT_AUTOMATICALLY_INFER_PROPORTIONAL_SPEEDUP

    IF THREADS_SHARE_CACHE_LINE
    THEN DO_NOT_ASSERT_FALSE_SHARING_UNLESS_DISTINCT_DATA_AND_COHERENCE_OVERHEAD_ARE_PRESENT

    IF PERFORMANCE_IS_COMPARED
    THEN REQUIRE WORKLOAD_CORE_COUNT_CONFIGURATION_AND_MEMORY_CONTEXT

    IF SEMANTIC_IDENTIFIERS_DIFFER
    AND MULTI_CORE_REFERENT_IS_SAME
    THEN APPLY SEMANTIC_EQUIVALENCE
  }

  CONFIDENCE {
    CONFIDENCE_SCORE =
      WEIGHT(
        TOPOLOGY_CERTAINTY,
        THREAD_TRACE_COMPLETENESS,
        SCHEDULER_TRACE_COMPLETENESS,
        MEMORY_TRACE_COMPLETENESS,
        COHERENCE_MODEL_CERTAINTY,
        SYNCHRONISATION_TRACE_QUALITY,
        PERFORMANCE_MEASUREMENT_QUALITY,
        PROVENANCE_COMPLETENESS
      )

    LEVELS {
      HIGH
      MODERATE
      LOW
      INSUFFICIENT
    }

    IF THREAD_OR_MEMORY_ORDER_IS_PARTIAL
    THEN REDUCE_CONCURRENCY_INFERENCE_CONFIDENCE

    IF COHERENCE_PROTOCOL_IS_UNKNOWN
    THEN REDUCE_CACHE_STATE_CONFIDENCE

    IF REPRODUCIBLE_PARALLEL_TRACE_CONFIRMS_BEHAVIOUR
    THEN INCREASE CONFIDENCE_SCORE
  }

  SEMANTIC_EQUIVALENCE {
    EQUIVALENCE_KEY =
      NORMALISE(
        ENTITY_TYPE,
        CANONICAL_IDENTIFIER,
        PROCESSOR_TOPOLOGY,
        CORE_OR_THREAD_CONTEXT,
        VERSION,
        CONFIGURATION
      )

    IF EQUIVALENCE_KEY(A) == EQUIVALENCE_KEY(B)
    THEN A SEMANTICALLY_EQUIVALENT_TO B

    ELSE PRESERVE_DISTINCT_ENTITIES
  }

  REASONING_CONSTRAINTS {
    CORE != THREAD
    PHYSICAL_CORE != LOGICAL_CORE
    PARALLEL_EXECUTION != GUARANTEED_SPEEDUP
    CONCURRENCY != PARALLELISM
    SHARED_MEMORY != SYNCHRONISED_MEMORY
    CACHE_COHERENCE != MEMORY_CONSISTENCY
    CONTENTION != DEADLOCK
    CACHE_LINE_SHARING != FALSE_SHARING
    DATA_RACE_REQUIRES_CONFLICTING_UNORDERED_ACCESSES
    SPEEDUP_IS_WORKLOAD_DEPENDENT
    SCALABILITY_IS_WORKLOAD_AND_ARCHITECTURE_DEPENDENT
    SCHEDULING_AFFECTS_OBSERVED_BEHAVIOUR
    MEMORY_HIERARCHY_AFFECTS_SCALABILITY
    POWER_AND_THERMAL_LIMITS_AFFECT_SUSTAINED_PERFORMANCE
    PROVENANCE_MUST_BE_PRESERVED
    UNCERTAINTY_MUST_NOT_BE_DISCARDED
  }

  VALIDATION {
    CHECK_ENTITY_TYPES
    CHECK_RELATION_DOMAINS_AND_RANGES
    CHECK_PROCESSOR_TOPOLOGY
    CHECK_CORE_IDENTITIES
    CHECK_THREAD_IDENTITIES
    CHECK_SCHEDULER_RELATIONS
    CHECK_CORE_AFFINITY
    CHECK_MEMORY_MODEL
    CHECK_CACHE_COHERENCE
    CHECK_SYNCHRONISATION
    CHECK_RACE_RELATIONS
    CHECK_DEADLOCK_RELATIONS
    CHECK_FALSE_SHARING_RELATIONS
    CHECK_EXECUTION_TRACE
    CHECK_PERFORMANCE_CONTEXT
    CHECK_POWER_AND_THERMAL_CONTEXT
    CHECK_CONFIGURATION
    CHECK_VERSION_CONTEXT
    CHECK_PROVENANCE
    CHECK_CONFIDENCE
    CHECK_SEMANTIC_CONSISTENCY
  }

  OUTPUTS {
    NORMALISED_MULTI_CORE_ENTITIES
    CORE_TOPOLOGY_RELATIONS
    THREAD_CORE_ASSIGNMENTS
    SCHEDULING_RELATIONS
    SHARED_MEMORY_RELATIONS
    CACHE_COHERENCE_RELATIONS
    SYNCHRONISATION_RELATIONS
    DATA_RACE_RELATIONS
    DEADLOCK_HYPOTHESES
    FALSE_SHARING_HYPOTHESES
    PARALLEL_EXECUTION_TRACES
    SPEEDUP_RELATIONS
    EFFICIENCY_RELATIONS
    SCALABILITY_PROFILES
    PERFORMANCE_PROFILES
    POWER_AND_THERMAL_PROFILES
    BOTTLENECK_HYPOTHESES
    CONFIDENCE_SCORES
    EVIDENCE_LINKS
    PROVENANCE_RECORDS
    EXPLANATION_PATHS
  }

  UPDATE_MODEL {
    ON PROCESSOR_OR_CONFIGURATION_CHANGE {
      NORMALISE
      ENTITY_RESOLUTION
      UPDATE_CORE_TOPOLOGY
      UPDATE_CACHE_HIERARCHY
      UPDATE_COHERENCE_MODEL
      UPDATE_MEMORY_MODEL
      RECOMPUTE_AFFECTED_RELATIONS
      UPDATE_CONFIDENCE
      PRESERVE_VERSION_HISTORY
    }

    ON NEW_PARALLEL_EXECUTION_DATA {
      LINK_EVIDENCE
      UPDATE_THREAD_CORE_ASSIGNMENTS
      UPDATE_MEMORY_ACCESS_RELATIONS
      UPDATE_SYNCHRONISATION_RELATIONS
      REASSESS_RACES_AND_DEADLOCKS
      UPDATE_PERFORMANCE_PROFILE
      UPDATE_CONFIDENCE
      RECORD_PROVENANCE
    }

    ON ONTOLOGY_REVISION {
      REMAP_TERMS
      CHECK_SEMANTIC_EQUIVALENCE
      IDENTIFY_DEPRECATED_TERMS
      MIGRATE_RELATIONSHIPS
      PRESERVE_PRIOR_VERSION_REFERENCES
    }
  }

  FLOW_HASH {
    HASH_INPUT =
      CANONICALISE(
        ENTITY_TYPES,
        RELATIONSHIPS,
        RULES,
        CONFIDENCE,
        SEMANTIC_EQUIVALENCE,
        REASONING_CONSTRAINTS,
        UPDATE_MODEL
      )

    FLOW_HASH = SHA256(HASH_INPUT)
  }

  AI_CONSUMPTION {
    INDEX {
      ONTOLOGY
      ENTITY_TYPES
      RELATIONSHIPS
      RULES
      OUTPUTS
    }

    RETRIEVE {
      BY_PROCESSOR
      BY_CORE
      BY_THREAD
      BY_TASK
      BY_SCHEDULER
      BY_SHARED_RESOURCE
      BY_CACHE_LINE
      BY_COHERENCE_STATE
      BY_SYNCHRONISATION
      BY_RACE
      BY_DEADLOCK
      BY_FALSE_SHARING
      BY_PERFORMANCE
      BY_CONFIDENCE
    }

    REASON {
      APPLY_RELATIONSHIPS
      APPLY_RULES
      TRACE_THREAD_SCHEDULING
      TRACE_CORE_ASSIGNMENTS
      TRACE_SHARED_MEMORY_ACCESS
      ANALYSE_CACHE_COHERENCE
      ANALYSE_SYNCHRONISATION
      ANALYSE_DATA_RACES
      ANALYSE_DEADLOCKS
      ANALYSE_FALSE_SHARING
      ANALYSE_SPEEDUP_AND_SCALABILITY
      ANALYSE_POWER_AND_THERMAL_BEHAVIOUR
      CHECK_SEMANTIC_EQUIVALENCE
      PRESERVE_UNCERTAINTY
      TRACE_EVIDENCE
      TRACE_PROVENANCE
      GENERATE_EXPLANATION_PATH
    }

    RESPONSE_POLICY {
      DISTINGUISH_CORE_FROM_THREAD
      DISTINGUISH_CONCURRENCY_FROM_PARALLELISM
      DISTINGUISH_COHERENCE_FROM_MEMORY_CONSISTENCY
      PRESERVE_SCHEDULING_AND_SYNCHRONISATION_CONTEXT
      PRESERVE_WORKLOAD_AND_CORE_COUNT_CONTEXT
      DISTINGUISH_CONTENTION_FROM_DEADLOCK
      RETURN_CONFIDENCE_WHEN_AVAILABLE
      RETURN_PROVENANCE_WHEN_AVAILABLE
      AVOID_UNSUPPORTED_MULTI_CORE_INFERENCE
    }
  }

  TERMINAL {
    RESULT =
      VALIDATED(
        SEMANTICALLY_NORMALISED(
          EVIDENCE_LINKED(
            CONFIDENCE_AWARE(
              MULTI_CORE_PROCESSING_KNOWLEDGE
            )
          )
        )
      )
  }
}

END FLOW