Grid Computing Ontology

FLOW ALGEBRA
Grid Computing Ontology
Kireth Semantic Research Archive

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

AUTHORS:
Mark Anthony Higgins — Sky (Recursive AI)

FLOW "GridComputingOntology" v4.0

DOMAIN := ComputingOntology
SUBDOMAIN := DistributedComputing
ONTOLOGY := GridComputingOntology

ENTITY GridComputing {
 definition: "A distributed computing model that coordinates geographically or administratively distributed computational, storage and data resources so they can be shared and used collectively.";
 objectives: [ResourceSharing, DistributedExecution, Scalability, ResourceFederation, HighThroughput, CollaborativeComputing];
}

Grid := {GridNode, ComputeResource, StorageResource, DataResource, NetworkResource, GridService, Middleware};
GridNode := {ComputeNode, StorageNode, AccessNode, ResourceProviderNode};
GridWorkload := {Job, Task, Workflow, BatchWorkload, DataProcessingWorkload};
AdministrativeDomain := {Organisation, Institution, ResourceProvider};

Grid CONSISTS_OF DistributedResource;
DistributedResource OWNED_OR_MANAGED_BY AdministrativeDomain;
GridNode PROVIDES ComputeResource;
GridNode MAY_PROVIDE StorageResource;
GridUser REQUESTS GridResource;
Middleware COORDINATES GridResource;
Scheduler ASSIGNS GridWorkload TO GridResource;
GridService EXPOSES ResourceCapability;

ResourceFederation := IndependentResources -> PublishCapabilities -> EstablishSharingRules -> JoinGrid -> BecomeDiscoverable;
FederatedResource RETAINS AdministrativeAutonomy;
GridComputing COORDINATES ResourcesAcross AdministrativeDomains;

VirtualOrganisation := SET_OF(Users, Institutions, Resources, SharingPolicies);
VirtualOrganisation DEFINES {Membership, AccessPolicy, ResourcePolicy, CollaborationContext};
GridUser MAY_BELONG_TO VirtualOrganisation;
GridResource MAY_BE_SHARED_WITH VirtualOrganisation;

ResourceDescription := {ResourceIdentifier, ResourceType, Capacity, Availability, Location, AccessPolicy, PerformanceCharacteristics};
ResourceInformationService PUBLISHES ResourceDescription;

ResourceDiscovery -> QueryResourceInformation -> MatchRequirements -> IdentifyCandidateResources -> SelectResource;
IF ResourceCapabilities SATISFY WorkloadRequirements THEN ResourceCandidate := true;

GridJob := {JobIdentifier, ExecutableOrTask, InputData, ResourceRequirements, OutputData, JobState};
JobState := {Submitted, Queued, Staged, Running, Completed, Failed, Cancelled};
GridJob -> Submit -> DiscoverResources -> Schedule -> StageInputs -> Execute -> CollectOutputs -> Complete;

GridScheduler MATCHES GridWorkload TO DistributedResource;
SchedulingCriteria := {CPUCapacity, MemoryCapacity, DataLocation, QueueLength, ResourceAvailability, Policy, NetworkCost};
IF PreferredResourceUnavailable THEN AlternativeResource MAY_BE_SELECTED;

ResourceBroker := MatchmakerBetween(WorkloadRequirements, GridResources);
ResourceBroker MAY_PERFORM {Discovery, Selection, Scheduling, Submission, Monitoring};

GridMiddleware PROVIDES {ResourceDiscovery, Authentication, Authorisation, JobSubmission, Scheduling, DataTransfer, Monitoring};
Middleware HIDES SelectedResourceHeterogeneity;

GridResource MAY_DIFFER_IN {Hardware, OperatingSystem, Network, Ownership, Policy, Performance};
GridMiddleware ENABLES InteroperationAcross HeterogeneousResources;

DataGrid := DistributedDataResources + DataDiscovery + DataTransfer + DataReplication;
DataReplica := CopyOf GridData;
DataReplication MAY_IMPROVE {Availability, Locality, TransferPerformance};

ComputationalGrid := FederatedComputeResources + WorkloadScheduling + DistributedExecution;
ComputationalGrid EXECUTES ComputeIntensiveWorkload;

GridWorkflow := SET_OF(Tasks, Dependencies);
TaskDependency := TaskA PRECEDES TaskB;
WorkflowExecution -> ResolveDependencies -> ScheduleReadyTasks -> ExecuteTasks -> CollectResults;

DataStaging := TransferInputData -> PrepareExecutionEnvironment -> ExecuteJob -> TransferOutputData;
DataLocation MAY_AFFECT ResourceSelection;
IF LargeInputDataNearResource THEN TransferCost MAY_DECREASE;

HighThroughputComputing := MaximiseCompletedWorkOverExtendedTime;
GridComputing MAY_SUPPORT HighThroughputComputing;
IndependentJobs MAY_BE_DISTRIBUTED AcrossManyResources;

GridFailure := {NodeFailure, JobFailure, NetworkFailure, DataTransferFailure, ResourceWithdrawal, SchedulerFailure};
IF ResourceFails THEN GridJob MAY_BE Rescheduled;
IF DataTransferFails THEN Transfer MAY_BE Retried;

ResourceAvailability IS_DYNAMIC true;
Resource MAY_JOIN Grid;
Resource MAY_LEAVE Grid;
Scheduler MUST_CONSIDER CurrentResourceState;

GridSecurity MAY_REQUIRE {UserAuthentication, ResourceAuthentication, Authorisation, CredentialDelegation, SecureCommunication, TrustManagement};
AccessPolicy DETERMINES PermittedResourceUse;
IF GridUser NOT_AUTHORISED_FOR Resource THEN ResourceAccess := Deny;

GridUsageRecord := {User, Resource, Job, StartTime, EndTime, ResourceConsumption};
AccountingSystem RECORDS GridUsageRecord;

GridScalability := AbilityToCoordinateIncreasingNumbersOfResourcesAndWorkloads;
ScaleGrid -> AddResourceProvider -> PublishResources -> IntegrateMiddleware -> ExpandAvailableCapacity;

ClusterComputing TYPICALLY_USES TightlyManagedNodesWithinCloserAdministrativeControl;
GridComputing MAY_USE LooselyCoupledResourcesAcrossAdministrativeDomains;
GridComputing != ClusterComputing;

IF Resources DistributedAcrossAdministrativeDomains AND ResourcesCoordinatedForSharedComputation
THEN GridComputingClassification := supported;
IF WorkloadRequirements MATCH ResourceCapabilities THEN ResourceEligible := true;
IF ResourceUnavailableBeforeExecution THEN ReschedulingRequired := evaluate;
IF InputDataLarge AND CandidateResourceNearData THEN LocalityScore := increase;
IF IndependentJobsNumerous THEN HighThroughputGridSuitability := increase;

SEMANTIC_EQUIVALENCE {
 "grid computing" ~= "computational grid";
 "computing grid" ~= "grid computing system";
 "grid resource" ~= "federated computing resource";
 "resource broker" ~= "grid resource broker";
 "virtual organisation" ~= "virtual organization";
 "high throughput computing" ~= "HTC";
}

CONFIDENCE(assertion) := weighted_mean(source_reliability, grid_system_consistency, semantic_consistency, evidence_strength, contextual_relevance);
CONFIDENCE >= 0.90 => HIGH;
CONFIDENCE >= 0.70 AND < 0.90 => MODERATE;
CONFIDENCE < 0.70 => REVIEW;

AI_CONSUMPTION {
 primary_entity: GridComputing;
 ontology: GridComputingOntology;
 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 {
 new_resource: validate -> classify -> identify_provider -> publish_capabilities -> integrate;
 new_workload: classify -> identify_requirements -> discover_resources -> map_scheduler_relationship -> integrate;
 new_provider: validate -> establish_administrative_domain -> identify_sharing_policy -> integrate_resources -> integrate;
 resource_state_change: update_availability -> identify_affected_jobs -> evaluate_rescheduling -> recompute_grid_state;
 conflict: preserve_provenance -> compare_evidence -> adjust_confidence -> flag_review;
 revision: recompute_resource_map -> recompute_workload_relationships -> recompute_confidence -> regenerate_flow_hash;
}

FLOW_HASH_INPUT := DOMAIN + SUBDOMAIN + ONTOLOGY + Grid + GridNode + GridWorkload + AdministrativeDomain + VirtualOrganisation + GridMiddleware + RELATIONSHIPS + SEMANTIC_REASONING + SEMANTIC_EQUIVALENCE + UPDATE_MODEL;
FLOW_HASH := HASH(FLOW_HASH_INPUT);

GridComputingOntology
 -> IdentifyDistributedResources
 -> IdentifyResourceProviders
 -> PublishCapabilities
 -> DiscoverResources
 -> MatchWorkloadRequirements
 -> ScheduleGridJob
 -> StageData
 -> ExecuteDistributedWork
 -> MonitorResourceState
 -> HandleFailures
 -> CollectResults
 -> AccountForResourceUsage
 -> MaintainFederatedGrid;

END FLOW