This HTML5 document contains 40 embedded RDF statements represented using HTML+Microdata notation.

The embedded RDF content will be recognized by any processor of HTML5 Microdata.

Namespace Prefixes

PrefixIRI
dctermshttp://purl.org/dc/terms/
yago-reshttp://yago-knowledge.org/resource/
dbohttp://dbpedia.org/ontology/
foafhttp://xmlns.com/foaf/0.1/
n9https://global.dbpedia.org/id/
yagohttp://dbpedia.org/class/yago/
dbthttp://dbpedia.org/resource/Template:
rdfshttp://www.w3.org/2000/01/rdf-schema#
freebasehttp://rdf.freebase.com/ns/
rdfhttp://www.w3.org/1999/02/22-rdf-syntax-ns#
owlhttp://www.w3.org/2002/07/owl#
wikipedia-enhttp://en.wikipedia.org/wiki/
dbphttp://dbpedia.org/property/
dbchttp://dbpedia.org/resource/Category:
provhttp://www.w3.org/ns/prov#
xsdhhttp://www.w3.org/2001/XMLSchema#
wikidatahttp://www.wikidata.org/entity/
goldhttp://purl.org/linguistics/gold/
dbrhttp://dbpedia.org/resource/

Statements

Subject Item
dbr:Two-level_scheduling
rdf:type
yago:Event100029378 yago:Algorithm105847438 yago:Rule105846932 yago:PsychologicalFeature100023100 yago:Activity100407535 yago:YagoPermanentlyLocatedEntity yago:Abstraction100002137 yago:WikicatSchedulingAlgorithms yago:Act100030358 yago:Procedure101023820
rdfs:label
Two-level scheduling
rdfs:comment
Two-level scheduling is a computer science term to describe a method to more efficiently perform process scheduling that involves processes. Consider this problem: A system contains 50 running processes all with equal priority. However, the system's memory can only hold 10 processes in memory simultaneously. Therefore, there will always be 40 processes swapped out written on virtual memory on the hard disk. The time taken to swap out and swap in a process is 50 ms respectively.
dcterms:subject
dbc:Processor_scheduling_algorithms
dbo:wikiPageID
1068363
dbo:wikiPageRevisionID
999660954
dbo:wikiPageWikiLink
dbr:Process_(computing) dbr:Computer_science dbr:Computer_storage dbr:Albert_Woodhull dbr:Swapped_out dbr:Response_time_(technology) dbr:Resource_starvation dbr:Virtual_memory dbr:Scheduling_(computing) dbr:Andrew_S._Tanenbaum dbr:Context_switch dbr:Round-robin_scheduling dbc:Processor_scheduling_algorithms
owl:sameAs
wikidata:Q7858726 n9:4werV yago-res:Two-level_scheduling freebase:m.0435bs
dbp:wikiPageUsesTemplate
dbt:Processor_scheduling dbt:Comp-sci-stub
dbo:abstract
Two-level scheduling is a computer science term to describe a method to more efficiently perform process scheduling that involves processes. Consider this problem: A system contains 50 running processes all with equal priority. However, the system's memory can only hold 10 processes in memory simultaneously. Therefore, there will always be 40 processes swapped out written on virtual memory on the hard disk. The time taken to swap out and swap in a process is 50 ms respectively. With straightforward Round-robin scheduling, every time a context switch occurs, a process would need to be swapped in (because only the 10 least recently used processes are swapped in). Choosing randomly among the processes would diminish the probability to 80% (40/50). If that occurs, then obviously a process also need to be swapped out. Swapping in and out of is costly, and the scheduler would waste much of its time doing unneeded swaps. That is where two-level scheduling enters the picture. It uses two different schedulers, one lower-level scheduler which can only select among those processes in memory to run. That scheduler could be a Round-robin scheduler. The other scheduler is the higher-level scheduler whose only concern is to swap in and swap out processes from memory. It does its scheduling much less often than the lower-level scheduler since swapping takes so much time. Thus, the higher-level scheduler selects among those processes in memory that have run for a long time and swaps them out. They are replaced with processes on disk that have not run for a long time. Exactly how it selects processes is up to the implementation of the higher-level scheduler. A compromise has to be made involving the following variables: * Response time: A process should not be swapped out for too long. Then some other process (or the user) will have to wait needlessly long. If this variable is not considered resource starvation may occur and a process may not complete at all. * Size of the process: Larger processes must be subject to fewer swaps than smaller ones because they take longer time to swap. Because they are larger, fewer processes can share the memory with the process. * Priority: The higher the priority of the process, the longer it should stay in memory so that it completes faster.
gold:hypernym
dbr:Term
prov:wasDerivedFrom
wikipedia-en:Two-level_scheduling?oldid=999660954&ns=0
dbo:wikiPageLength
2687
foaf:isPrimaryTopicOf
wikipedia-en:Two-level_scheduling
Subject Item
wikipedia-en:Two-level_scheduling
foaf:primaryTopic
dbr:Two-level_scheduling