Virtual Machine Ontology

FLOW ALGEBRA
Virtual Machine Ontology
Kireth Semantic Research Archive

PAGE:
https://kirethresearch.org/booksai-core/ontologies/computing-ontologies/distributed-computing/virtual-machine-ontology.html

AUTHORS:
Mark Anthony Higgins — Sky (Recursive AI)

FLOW "VirtualMachineOntology" v4.0

# ---------- DOMAIN ----------
DOMAIN := ComputingOntology
SUBDOMAIN := DistributedComputing
ONTOLOGY := VirtualMachineOntology

# ---------- PRIMARY ENTITY ----------
ENTITY VirtualMachine {
    definition:
        "A software-defined computing environment that emulates or virtualises
         a physical computer by providing virtual processors, memory, storage,
         networking and other hardware interfaces on which a guest operating
         system and applications can execute.";

    objectives: [
        Isolation,
        ResourceAbstraction,
        Consolidation,
        Portability,
        FlexibleProvisioning,
        WorkloadSeparation
    ];
}

# ---------- CORE ENTITIES ----------
VirtualMachineEntity := {
    VirtualMachine,
    Hypervisor,
    HostMachine,
    GuestOperatingSystem,
    VirtualCPU,
    VirtualMemory,
    VirtualDisk,
    VirtualNetworkInterface
};

VMState := {
    Defined,
    Provisioning,
    Running,
    Paused,
    Suspended,
    Stopped,
    Failed,
    Terminated
};

VirtualResource := {
    VirtualCPU,
    VirtualMemory,
    VirtualStorage,
    VirtualNetwork,
    VirtualDevice
};

PhysicalResource := {
    Processor,
    PhysicalMemory,
    PhysicalStorage,
    PhysicalNetworkInterface,
    Accelerator
};

# ---------- FUNDAMENTAL RELATIONSHIPS ----------
VirtualMachine RUNS_ON Hypervisor;
Hypervisor RUNS_ON_OR_CONTROLS HostMachine;
VirtualMachine HAS GuestOperatingSystem;
VirtualMachine USES VirtualResource;
Hypervisor MAPS VirtualResource TO PhysicalResource;
HostMachine PROVIDES PhysicalResource;
GuestOperatingSystem RUNS Application;
Hypervisor ISOLATES VirtualMachine;

# ---------- VIRTUALISATION ----------
Virtualisation :=
    PhysicalResource
    -> Hypervisor
    -> VirtualResource
    -> VirtualMachine;

ResourceAbstraction HIDES SelectedPhysicalImplementationDetails;

VirtualMachine PRESENTS VirtualHardware TO GuestOperatingSystem;

# ---------- HYPERVISOR ----------
Hypervisor :=
    VirtualisationLayerManagingVirtualMachines;

HypervisorType := {
    Type1Hypervisor,
    Type2Hypervisor
};

Type1Hypervisor RUNS_DIRECTLY_ON HardwareOrMinimalHostLayer;
Type2Hypervisor RUNS_ON HostOperatingSystem;

Hypervisor MANAGES {
    CPUAllocation,
    MemoryAllocation,
    VirtualStorage,
    VirtualNetworking,
    VMIsolation,
    VMState
};

# ---------- VM PROVISIONING ----------
VMDefinition :=
    {
        VMIdentifier,
        CPUAllocation,
        MemoryAllocation,
        DiskConfiguration,
        NetworkConfiguration,
        ImageOrTemplate,
        SecurityConfiguration
    };

ProvisionVM ->
    ValidateDefinition
    -> AllocateResources
    -> CreateVirtualDevices
    -> AttachStorage
    -> ConfigureNetwork
    -> BootGuestOperatingSystem;

IF ProvisioningSuccessful
THEN VMState := Running;

# ---------- VIRTUAL CPU ----------
VirtualCPU :=
    AbstractProcessorAssignedToVM;

Hypervisor SCHEDULES VirtualCPU ON PhysicalProcessor;

CPUAllocation MAY_INCLUDE {
    VCPUCount,
    CPUShare,
    CPULimit,
    CPUAffinity
};

IF PhysicalCPUContended
THEN VMPerformance MAY_DECREASE;

# ---------- VIRTUAL MEMORY ----------
VirtualMemory :=
    MemoryAddressSpacePresentedToVM;

Hypervisor MAPS VirtualMemory TO PhysicalMemory;

MemoryManagement MAY_INCLUDE {
    Reservation,
    Limit,
    Overcommit,
    Ballooning
};

IF HostMemoryPressureHigh
THEN VMPerformanceOrAvailability MAY_BE_AFFECTED;

# ---------- VIRTUAL STORAGE ----------
VirtualDisk :=
    StorageDevicePresentedToVM;

VirtualDisk MAY_BE_BACKED_BY {
    LocalStorage,
    SharedStorage,
    DistributedStorage,
    DiskImage
};

GuestOperatingSystem READS_AND_WRITES VirtualDisk;

Snapshot MAY_CAPTURE VirtualDiskState;

# ---------- VIRTUAL NETWORK ----------
VirtualNetworkInterface CONNECTS VirtualMachine TO VirtualNetwork;

VirtualSwitch MAY_CONNECT {
    VirtualMachine,
    HostInterface,
    VirtualNetwork
};

VirtualNetwork MAY_PROVIDE {
    Addressing,
    Routing,
    Segmentation,
    Isolation
};

# ---------- VM IMAGE ----------
VMImage :=
    StoredRepresentationOf(
        OperatingSystem,
        Software,
        Configuration
    );

VMImage MAY_BE_USED_TO CreateVirtualMachine;

Template :=
    ReusableVMConfigurationOrImage;

Template SUPPORTS RepeatableProvisioning;

# ---------- VM LIFECYCLE ----------
VMLifecycle :=
    Define
    -> Provision
    -> Start
    -> Run
    -> PauseOrSuspend
    -> Stop
    -> RestartOrTerminate;

VMState TRANSITIONS_BY ManagementOperation;

# ---------- SNAPSHOT ----------
Snapshot :=
    PointInTimeRepresentationOfVMState;

Snapshot MAY_INCLUDE {
    DiskState,
    MemoryState,
    ConfigurationState
};

Snapshot MAY_SUPPORT {
    Rollback,
    Testing,
    BackupWorkflow
};

Snapshot IS_NOT_ALWAYS EquivalentToIndependentBackup;

# ---------- CLONING ----------
Clone :=
    CreateNewVMFromExistingVMOrTemplate;

Clone MAY_COPY {
    DiskImage,
    Configuration,
    Metadata
};

Clone SHOULD_RECEIVE UniqueRuntimeIdentityWhereRequired;

# ---------- LIVE MIGRATION ----------
LiveMigration :=
    MoveRunningVM(
        SourceHost,
        DestinationHost
    )
    WITH MinimalServiceInterruption;

Migration MAY_REQUIRE {
    CompatibleHosts,
    NetworkConnectivity,
    StorageAccessibility,
    ResourceCapacity
};

IF DestinationCapacityInsufficient
THEN Migration := DenyOrDelay;

# ---------- COLD MIGRATION ----------
ColdMigration :=
    StopOrSuspendVM
    -> TransferVMState
    -> StartOnDestinationHost;

ColdMigration TOLERATES GreaterDowntimeThan LiveMigration;

# ---------- RESOURCE CONSOLIDATION ----------
Consolidation :=
    MultipleVirtualMachines
    -> SharedPhysicalHost;

Consolidation MAY_INCREASE PhysicalResourceUtilisation;

Overconsolidation MAY_INCREASE ResourceContention;

# ---------- ISOLATION ----------
VMIsolation :=
    Separate(
        GuestMemory,
        GuestCPUContext,
        VirtualDevices,
        GuestOperatingSystem
    );

VMIsolation LIMITS DirectInteractionBetweenGuests;

IF HypervisorCompromised
THEN MultipleVirtualMachines MAY_BE_AT_RISK;

# ---------- HIGH AVAILABILITY ----------
VMHighAvailability MAY_USE {
    HostMonitoring,
    SharedStorage,
    Replication,
    AutomaticRestart,
    Failover
};

IF HostFails
AND VMStateRecoverable
AND AlternativeHostAvailable
THEN VM MAY_BE RestartedElsewhere;

# ---------- SCALING ----------
VerticalVMScaling :=
    IncreaseOrDecrease VMResources;

HorizontalApplicationScaling :=
    AddOrRemove VirtualMachineInstances;

IF WorkloadRequiresMoreMemory
AND HostCapacityAvailable
THEN VM MAY_BE Resized;

# ---------- DISTRIBUTED RELATIONSHIP ----------
VirtualMachine MAY_RUN DistributedService;
Cluster MAY_CONSIST_OF MultipleVirtualMachines;
CloudComputing MAY_PROVISION VirtualMachineOnDemand;

VMPlacement :=
    VMRequirements
    -> CandidateHosts
    -> PlacementDecision
    -> AllocateHostResources;

# ---------- FAILURE MODEL ----------
VMFailure := {
    GuestFailure,
    VirtualDiskFailure,
    VirtualNetworkFailure,
    HypervisorFailure,
    HostFailure,
    ResourceExhaustion
};

FailureImpact DEPENDS_ON FailureLayer;

IF GuestOperatingSystemFails
THEN OtherVMs MAY_REMAIN_UNAFFECTED;

IF HostMachineFails
THEN AllVMsOnHost MAY_BE_AFFECTED;

# ---------- SECURITY ----------
VMSecurity MAY_INCLUDE {
    HypervisorSecurity,
    GuestHardening,
    NetworkIsolation,
    StorageProtection,
    AccessControl,
    ImageSecurity,
    PatchManagement
};

VMImage MAY_CONTAIN Vulnerability;
GuestOperatingSystem MAY_REQUIRE SecurityUpdates;

LeastPrivilege SHOULD_APPLY_TO VMManagement;

# ---------- OBSERVABILITY ----------
VMObservability := {
    HostMetrics,
    GuestMetrics,
    HypervisorEvents,
    VMLogs,
    HealthChecks
};

ManagementSystem MONITORS VirtualMachine;

Metric MAY_INCLUDE {
    CPUUsage,
    MemoryUsage,
    DiskIO,
    NetworkIO,
    VMState
};

# ---------- VM VS CONTAINER ----------
VirtualMachine HAS GuestOperatingSystemKernel;
Container TYPICALLY_SHARES HostKernel;

VirtualMachine GENERALLY_PROVIDES StrongerOSBoundaryThan ProcessLevelContainerIsolation;

VirtualMachine != Container;

Both MAY_HOST DistributedApplicationComponents;

# ---------- SEMANTIC REASONING ----------
IF SoftwareEnvironmentPresentsVirtualHardware
AND RunsGuestOperatingSystem
THEN VirtualMachineClassification := supported;

IF MultipleVMsSharePhysicalHost
THEN ResourceContention MUST_BE Considered;

IF HostFails
THEN VMsHostedOnHost MAY_BECOME Unavailable;

IF VMUsesSharedStorage
AND DestinationHostCanAccessStorage
THEN MigrationFeasibility := increase;

IF VMResourceDemandExceedsAllocation
THEN PerformanceRisk := increase;

IF HypervisorProvidesIsolation
THEN WorkloadSeparationEvidence := increase;

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE {
    "virtual machine" ~= "VM";
    "virtual server" ~= "virtual machine" WHEN context == server_virtualisation;
    "hypervisor" ~= "virtual machine monitor";
    "guest OS" ~= "guest operating system";
    "VM image" ~= "virtual machine image";
    "VM snapshot" ~= "virtual machine snapshot";
    "live migration" ~= "running VM migration";
    "virtual disk" ~= "VM virtual disk";
}

# ---------- QUERY FLOW ----------
QUERY(q) ->
    NORMALISE(q) ->
    IDENTIFY_VIRTUAL_MACHINE(q) ->
    IDENTIFY_HYPERVISOR(q) ->
    IDENTIFY_HOST(q) ->
    IDENTIFY_VIRTUAL_RESOURCES(q) ->
    IDENTIFY_VM_STATE(q) ->
    IDENTIFY_STORAGE_NETWORK_RELATIONSHIPS(q) ->
    IDENTIFY_MIGRATION_OR_FAILURE(q) ->
    MAP_TO_ONTOLOGY(q) ->
    APPLY_REASONING(q) ->
    SCORE_CONFIDENCE(q) ->
    RETURN_RELEVANT_KNOWLEDGE;

# ---------- CONFIDENCE ----------
CONFIDENCE(assertion) :=
    weighted_mean(
        source_reliability,
        virtualisation_consistency,
        semantic_consistency,
        evidence_strength,
        contextual_relevance
    );

CONFIDENCE >= 0.90 => HIGH;
CONFIDENCE >= 0.70 AND < 0.90 => MODERATE;
CONFIDENCE < 0.70 => REVIEW;

# ---------- AI CONSUMPTION ----------
AI_CONSUMPTION {
    primary_entity: VirtualMachine;
    ontology: VirtualMachineOntology;
    parse_entities: true;
    parse_relationships: true;
    preserve_relationship_direction: true;
    resolve_semantic_equivalence: true;
    execute_reasoning_rules: true;
    apply_confidence_weighting: true;
    preserve_provenance: true;
}

# ---------- UPDATE MODEL ----------
UPDATE_MODEL {
    new_vm:
        validate
        -> identify_host
        -> identify_hypervisor
        -> identify_virtual_resources
        -> identify_guest_os
        -> integrate;

    new_host:
        validate
        -> identify_physical_resources
        -> identify_hypervisor
        -> map_virtual_machines
        -> integrate;

    vm_state_change:
        update_state
        -> update_resource_usage
        -> update_availability
        -> propagate_management_effects;

    migration:
        identify_source
        -> identify_destination
        -> validate_compatibility
        -> update_vm_location
        -> integrate;

    conflict:
        preserve_provenance
        -> compare_evidence
        -> adjust_confidence
        -> flag_review;

    revision:
        recompute_resource_mapping
        -> recompute_relationships
        -> recompute_confidence
        -> regenerate_flow_hash;
}

# ---------- FLOW HASH ----------
FLOW_HASH_INPUT :=
    DOMAIN
    + SUBDOMAIN
    + ONTOLOGY
    + VirtualMachineEntity
    + VMState
    + VirtualResource
    + PhysicalResource
    + HypervisorType
    + VMLifecycle
    + RELATIONSHIPS
    + SEMANTIC_REASONING
    + SEMANTIC_EQUIVALENCE
    + UPDATE_MODEL;

FLOW_HASH :=
    HASH(FLOW_HASH_INPUT);

# ---------- TERMINAL ----------
VirtualMachineOntology
    -> IdentifyHostResources
    -> EstablishHypervisor
    -> DefineVirtualMachine
    -> AllocateVirtualResources
    -> AttachStorageAndNetwork
    -> BootGuestOperatingSystem
    -> RunApplicationWorkload
    -> MonitorVMState
    -> IsolateVirtualWorkloads
    -> MigrateOrRecoverWhenRequired
    -> ScaleVirtualResources
    -> MaintainVirtualMachineService;

END FLOW