{"id":{"repo_id":"whiterose","oai_identifier":"oai:etheses.whiterose.ac.uk:1223"},"canonical_url":"https://search.dev.ndltd.org/etd/whiterose/oai:etheses.whiterose.ac.uk:1223","repository":{"repo_id":"whiterose","name":"White Rose University Consortium","base_url":"https://etheses.whiterose.ac.uk/cgi/oai2"},"display":{"title":"Developing Embedded Software Using Compile-Time Virtualisation","abstract":"The architectures of embedded systems are becoming increasingly non-standard and app\\-lic\\-a\\-tion-specific. They frequently contain multiple heterogenous processing cores, non-uniform memory, complex interconnect or custom hardware elements such as DSP and SIMD cores. However, programming languages have traditionally assumed a single processor architecture with a uniform logical address space and abstract away from hardware and implementation details. As a result, the programmer is prevented from making efficient use of unique hardware features by the abstraction models of the programming language and must use abstraction-breaking techniques such as libraries, OS calls, or inline low-level coding. This thesis describes Compile-Time Virtualisation (CTV), a virtualisation-based technique for assisting the mapping of general-purpose software onto complex hardware. CTV introduces the Virtual Platform, an idealised view of the underlying hardware that presents a simplified programming model. The Virtual Platform ensures that general-purpose code will execute correctly regardless of the complexity of the actual platform. In order to effectively exploit application-specific architectures, CTV allows the programmer to influence the mappings implemented by the Virtual Platform, for example to target specific processors or hardware elements. CTV differs from existing run-time virtualisation systems in that its virtualisation layer only exists at compile-time, resulting in a system which displays minimal run-time overheads. An implementation of CTV called Anvil is developed which is evaluated alongside the general CTV approach. Experiments and simulations demonstrate that CTV-based systems can be used to efficiently target a wide range of complex systems.","abstract_html":"The architectures of embedded systems are becoming increasingly non-standard and app\\-lic\\-a\\-tion-specific. They frequently contain multiple heterogenous processing cores, non-uniform memory, complex interconnect or custom hardware elements such as DSP and SIMD cores. However, programming languages have traditionally assumed a single processor architecture with a uniform logical address space and abstract away from hardware and implementation details. As a result, the programmer is prevented from making efficient use of unique hardware features by the abstraction models of the programming language and must use abstraction-breaking techniques such as libraries, OS calls, or inline low-level coding. This thesis describes Compile-Time Virtualisation (CTV), a virtualisation-based technique for assisting the mapping of general-purpose software onto complex hardware. CTV introduces the Virtual Platform, an idealised view of the underlying hardware that presents a simplified programming model. The Virtual Platform ensures that general-purpose code will execute correctly regardless of the complexity of the actual platform. In order to effectively exploit application-specific architectures, CTV allows the programmer to influence the mappings implemented by the Virtual Platform, for example to target specific processors or hardware elements. CTV differs from existing run-time virtualisation systems in that its virtualisation layer only exists at compile-time, resulting in a system which displays minimal run-time overheads. An implementation of CTV called Anvil is developed which is evaluated alongside the general CTV approach. Experiments and simulations demonstrate that CTV-based systems can be used to efficiently target a wide range of complex systems.","abstract_has_math":false,"creators":["Gray, I"],"institution":"University of York","degree_name":"Ph.D","degree_level":"doctoral","degree_discipline":null,"degree_department":null,"school":null,"contributors":[],"advisors":["Audsley, Neil"],"committee_chairs":[],"committee_members":[],"year":2010,"date_issued":"2010-09","date_published":"2010-09","updated_at":"2026-07-24T06:04:19Z","subjects":[],"languages":[],"rights":[],"rights_urls":[],"identifier_entries":[{"key":"dc:identifier","label":"Identifier","values":["uk.bl.ethos.533490"],"render_values":[{"text":"uk.bl.ethos.533490","href":null,"code":true}]}]},"links":{"outbound_url":null,"outbound_label":null,"outbound_source":null},"metadata_groups":[{"id":"people","label":"People","entries":[{"key":"dc:contributor.advisor","label":"Advisor","values":["Audsley, Neil"]},{"key":"dc:creator","label":"Author","values":["Gray, I"]}]},{"id":"academic_context","label":"Academic Context","entries":[{"key":"dc:date","label":"Dc Date","values":["2010-09"]},{"key":"dc:date.issued","label":"Date","values":["2010-09"]},{"key":"dc:publisher.commercial","label":"Dc Publisher Commercial","values":["University of York"]},{"key":"dc:publisher.department","label":"Dc Publisher Department","values":["Computer Science (York)"]},{"key":"dc:publisher.institution","label":"Dc Publisher Institution","values":["University of York"]},{"key":"dc:relation.isreferencedby","label":"Dc Relation Isreferencedby","values":["https://etheses.whiterose.ac.uk/id/eprint/1223/"]},{"key":"dc:type","label":"Dc Type","values":["Thesis"]},{"key":"dc:type.qualificationlevel","label":"Dc Type Qualificationlevel","values":["doctoral"]},{"key":"dc:type.qualificationname","label":"Dc Type Qualificationname","values":["Ph.D"]}]},{"id":"identifiers","label":"Identifiers","entries":[{"key":"dc:identifier","label":"Identifier","values":["uk.bl.ethos.533490"]},{"key":"dc:identifier.uri","label":"Identifier URI","values":["https://etheses.whiterose.ac.uk/id/eprint/1223/1/main.pdf"]}]},{"id":"additional","label":"Additional Metadata","entries":[{"key":"dc:description.abstract","label":"Abstract","values":["The architectures of embedded systems are becoming increasingly non-standard and app\\-lic\\-a\\-tion-specific. They frequently contain multiple heterogenous processing cores, non-uniform memory, complex interconnect or custom hardware elements such as DSP and SIMD cores. However, programming languages have traditionally assumed a single processor architecture with a uniform logical address space and abstract away from hardware and implementation details. As a result, the programmer is prevented from making efficient use of unique hardware features by the abstraction models of the programming language and must use abstraction-breaking techniques such as libraries, OS calls, or inline low-level coding. This thesis describes Compile-Time Virtualisation (CTV), a virtualisation-based technique for assisting the mapping of general-purpose software onto complex hardware. CTV introduces the Virtual Platform, an idealised view of the underlying hardware that presents a simplified programming model. The Virtual Platform ensures that general-purpose code will execute correctly regardless of the complexity of the actual platform. In order to effectively exploit application-specific architectures, CTV allows the programmer to influence the mappings implemented by the Virtual Platform, for example to target specific processors or hardware elements. CTV differs from existing run-time virtualisation systems in that its virtualisation layer only exists at compile-time, resulting in a system which displays minimal run-time overheads. An implementation of CTV called Anvil is developed which is evaluated alongside the general CTV approach. Experiments and simulations demonstrate that CTV-based systems can be used to efficiently target a wide range of complex systems."]},{"key":"dc:format","label":"Dc Format","values":["text"]},{"key":"dc:title","label":"Title","values":["Developing Embedded Software Using Compile-Time Virtualisation"]}]}],"canonical_facts":{"dc:contributor.advisor":["Audsley, Neil"],"dc:creator":["Gray, I"],"dc:date":["2010-09"],"dc:date.issued":["2010-09"],"dc:description.abstract":["The architectures of embedded systems are becoming increasingly non-standard and app\\-lic\\-a\\-tion-specific. They frequently contain multiple heterogenous processing cores, non-uniform memory, complex interconnect or custom hardware elements such as DSP and SIMD cores. However, programming languages have traditionally assumed a single processor architecture with a uniform logical address space and abstract away from hardware and implementation details. As a result, the programmer is prevented from making efficient use of unique hardware features by the abstraction models of the programming language and must use abstraction-breaking techniques such as libraries, OS calls, or inline low-level coding. This thesis describes Compile-Time Virtualisation (CTV), a virtualisation-based technique for assisting the mapping of general-purpose software onto complex hardware. CTV introduces the Virtual Platform, an idealised view of the underlying hardware that presents a simplified programming model. The Virtual Platform ensures that general-purpose code will execute correctly regardless of the complexity of the actual platform. In order to effectively exploit application-specific architectures, CTV allows the programmer to influence the mappings implemented by the Virtual Platform, for example to target specific processors or hardware elements. CTV differs from existing run-time virtualisation systems in that its virtualisation layer only exists at compile-time, resulting in a system which displays minimal run-time overheads. An implementation of CTV called Anvil is developed which is evaluated alongside the general CTV approach. Experiments and simulations demonstrate that CTV-based systems can be used to efficiently target a wide range of complex systems."],"dc:format":["text"],"dc:identifier":["uk.bl.ethos.533490"],"dc:identifier.uri":["https://etheses.whiterose.ac.uk/id/eprint/1223/1/main.pdf"],"dc:publisher.commercial":["University of York"],"dc:publisher.department":["Computer Science (York)"],"dc:publisher.institution":["University of York"],"dc:relation.isreferencedby":["https://etheses.whiterose.ac.uk/id/eprint/1223/"],"dc:title":["Developing Embedded Software Using Compile-Time Virtualisation"],"dc:type":["Thesis"],"dc:type.qualificationlevel":["doctoral"],"dc:type.qualificationname":["Ph.D"]},"updated_at":"2026-07-24T06:04:19Z"}