Filters

Settings

Now showing1 - 7 of 7
  • Some of the metrics are blocked by your 
    consent settings
    Item type:Project, Access status: without files ,
    Memory Hierarchy Code Optimization
    Modern real-time embedded systems are required to fulfill stringent timing constraints. But with the increasing complexity of such systems, it is necessary to consider not just execution times but other non-functional properties such as energy consumption, code size, etc. To perform optimizations for such non-functional properties, compilers can be the optimal middle ground. Embedded systems can be equipped with sophisticated memory subsystems, featuring, among others, Flash memories, caches, tightly-coupled scratchpad memories (SPM), DRAM, DMA engines, etc. Principally, these memory subsystems play a vital role while optimizing these non-functional properties. Moreover, memory allocation for such elaborate architectures is a complex optimization problem to address. In the real-time community, the static assignment of memory objects to memories and address spaces typically is prevalent due to its inherent timing predictability. But this might lead to sub-optimal memory usage because of the lacking flexibility to adapt the memory allocation to the program's current state during execution. Therefore, this project will exploit compiler-based dynamic memory management for architectures with sophisticated memory hierarchies to design timing-, energy-, and code-size-efficient programs. Dynamic memory allocation has been investigated in the past only for reasonably limited architectures. Moreover, the overhead imposed due to the copying of memory objects within the memory hierarchy is modeled accurately only in some cases. Lastly, until now, only dynamic memory allocation-based single-objective optimizations are considered. Therefore, currently, there is no comprehensive approach for performing compiler-based dynamic memory allocation for architectures with sophisticated memory hierarchy, under simultaneous consideration of multiple objectives, which accounts for the overheads imposed by the allocation's dynamic behavior. To handle such multi-objective optimizations, this project aims to develop a generic framework based on Metaheuristic Algorithms and Integer Linear Programming (ILP) that performs dynamic memory allocation. As a kind of demonstration of our holistic approach, we will consider actual compiler-based optimizations like dynamic SPM allocation, cache locking, code compression, with and without DMA, etc. However, performing dynamic memory allocation is an NP-complete problem in itself. The design space within which the optimal solutions for such a problem lie, can be huge. Thus, performing multi-objective optimizations on such a huge problem, either by using the ILP- or Metaheuristics-based approach, is thus likely to have shortcomings in terms of complexity. Therefore, this project additionally aims to tackle the scalability issues by using hybrid combinations of these multi-objective optimization approaches.
      42
  • Some of the metrics are blocked by your 
    consent settings
    Item type:Project, Access status: without files ,
    Hamburg Graduate School for Data-Driven Participatory Smart Cities
    Metropolitan areas around the globe are facing huge logistical, societal, and ecological challenges. The rapid urbanization, climate change, and demographic change confronted with resource scarcity in urban areas have led to various stressors such as pollution and congestion, which directly impact the quality of life. The response of computer science and technology to those challenges is often called "Smart City". This concept denotes a system of systems, where a large amount of heterogeneous data, partly collected by Internet of Things (IoT) sensors, is processed in an intelligent way to efficiently manage scarce resources (such as green areas, mobility services, or energy) and to create services, which increase the citizens’ quality of life. Citizens represent a key enabling component of a smart city, i.e. users, who not only generate and share a large part of the data, but also play a central role in designing, promoting, and feeding smart city systems and services. The participation of users in the design, development, and usage of smart city services is thus crucial for a sustainable, data-centered smart city, which we call "sharing.city". Hamburg, one of the most dynamic and digitized cities in Europe, represents a perfect candidate of a sharing.city.  For instance, the Hamburg Open Data portal Transparenzportal and the underlying regulation were amongst the first in Germany and is now followed by other cities and states. Hamburg has also already a variety of smart city projects and services as the smart port or autonomous cars in the heart of the city as well as a long tradition of citizen participation. Moreover,  projects like Hamburg Open Science or Urban Data Hub build unique  research collaboration platforms, which facilitate  the development of sharing.city services. The sharing.city.college is a possible blueprint for a Hamburg-wide graduate school in computer science. The sharing.city.college is expected to pilot and evaluate formats for advancing the development of junior researchers, such as a summer school, international fellowships for leading researchers engaging junior researchers, research courses, development of demonstrators, engaging in citizen science and sharing research findings with practitioners and the public. The sharing.city.college addresses the following research areas: - Engineering sharing.city - Citizen Data Science - Smart, Sharing Infrastructures
      58
  • Some of the metrics are blocked by your 
    consent settings
    Item type:Project, Access status: without files ,
    I³-Project - Safety Critical Functions on Many-Core Avionics Architectures
    Complex problems such as investigating the influence of many-core embedded systems for safety-critical systems, usually cannot be solved by an institute alone as it requires the competences of several institutes. An interdisciplinary team consisting of experts from aircraft systems (avionics) and computer sciences (embedded systems) shall address the issue of defining and assessing new many-core architectures. M-7 and E-13-ES work in different fields of safety-critical function development. Although scientific exchange takes place, the potential of both institutes working together on hot topics in that field is currently not realised through joint projects. The first goal is, to tighten the connection of the institutes and to develop a strong core research topic for TUHH. New design- and analysis methods for safety-critical systems and software on many-core architectures shall be developed, taking modern flight control system platforms as use-case. These methods shall especially consider runtime-and qualification aspects (second goal). E-13-ES delivers into the projects the requirements and capabilities of many-core applications through the layer of implementation (bottom-up approach). M-7 provides a realistic, complex reference system as well as system- and architecture requirements (top-down approach). The institutes complement each other in their competences very well in that area. A corporate research platform shall be developed that allows technology assessment and access to more complex projects (third goal). At the end of the project, a virtual research avionics platform (ViRAP) shall run parallelised, safety-critical (redundant) flight control system applications based on many-core technology. New methods and tools shall allow a systematic, model-based system design and simulation-based validation. One aspect is to understand the influence on the overall system when changing the hardware architecture and/or its parameters.
      234
  • Some of the metrics are blocked by your 
    consent settings
    Item type:Project, Access status: without files ,
    Time, Energy and security Analysis for Multi/Manycore heterogenous PLAtforms - TeamPlay
    The TeamPlay project aims to develop new, formally-motivated, techniques that will allow execution time, energy usage, security, and other important non-functional properties of parallel software to be treated effectively, and as first- class citizens. We will build this into a toolbox for developing highly parallel software for low-energy systems, as required by the internet of things, cyber-physical systems etc. The TeamPlay approach will allow programs to reflect directly on their own time, energy consumption, security, etc., as well as enabling the developer to reason about both the functional and the non-functional properties of their software at the source code level. Our success will ensure significant progress on a pressing problem of major industrial importance: how to effectively manage energy consumption for parallel systems while maintaining the right balance with other important software metrics, including time, security etc. The project brings together leading industrial and academic experts in paral- lelism, energy modeling/transparency, worst-case execution time analysis, non-functional property analysis, compi- lation, security, and task coordination. Results will be evaluated using industrial use cases taken from the computer vision, satellites, flying drones, medical and cybersecurity domains.
      188
  • Some of the metrics are blocked by your 
    consent settings
    Item type:Project, Access status: without files ,
    haRTStone - Automated Generation of Benchmark Programs for the Evaluation of Analyses and Optimizations for Hard Real-Time Systems
    Many embedded systems are safety-critical real-time systems that have to meet hard deadlines (e.g., airbag or flight control systems). When designing such real-time systems, it is of utmost importance to guarantee that all tasks of a system meet their given deadlines. For this purpose, dedicated timing analyses are required that examine the worst-case behavior of a system and are able to provide such guarantees. In the case that deadlines are not met, optimizations need to be applied in order to modify the code of the system such that timing constraints are nevertheless finally met.Research on such analyses and optimizations for hard real-time systems is an extremely lively area where new results are presented regularly and at a very fast pace. Naturally, the evaluation of such analyses and optimizations plays a very important role. Nowadays, evaluation typically relies on benchmarking such that new analyses or optimizations are applied to existing collections of applications, tasks or program codes. The currently used benchmarks are, however, highly limited and not sufficient in order to perform a sound and scientific evaluation, especially if massively parallel multi-task systems are considered.For a well-founded and reproducible evaluation of analyses and optimizations, there is a strong demand for universally applicable benchmark approaches that are freely available for the entire scientific community. Benchmarks should satisfy the needs and requirements of various branches of research (e.g., schedulability analysis, WCET analysis, compiler optimization) on the one hand, but should also, on the other hand, realistically represent different application domains like, e.g., control or signal processing applications.This project aims at the realization of a flexible and parameterizable benchmark generator that produces benchmark programs in an automated, pseudo-randomized and reproducible fashion. This benchmark generator will in particular cover the system and the code level by producing both complete task sets and also actual program codes for the individual tasks. In order to enable a widespread use of the generator and a broad collaboration with arbitrary interested people and groups, this project will be inclusive and the developed software will be openly available right from the beginning. In the end, this project shall lead to a methodology for benchmarking-based evaluation that describes clearly and reproducibly for the different real-time communities, how to use the benchmark generator in order to obtain plausible, sound and scientifically accepted evaluation results.Many embedded systems are safety-critical real-time systems that have to meet hard deadlines (e.g., airbag or flight control systems). When designing such real-time systems, it is of utmost importance to guarantee that all tasks of a system meet their given deadlines. For this purpose, dedicated timing analyses are required that examine the worst-case behavior of a system and are able to provide such guarantees. In the case that deadlines are not met, optimizations need to be applied in order to modify the code of the system such that timing constraints are nevertheless finally met.Research on such analyses and optimizations for hard real-time systems is an extremely lively area where new results are presented regularly and at a very fast pace. Naturally, the evaluation of such analyses and optimizations plays a very important role. Nowadays, evaluation typically relies on benchmarking such that new analyses or optimizations are applied to existing collections of applications, tasks or program codes. The currently used benchmarks are, however, highly limited and not sufficient in order to perform a sound and scientific evaluation, especially if massively parallel multi-task systems are considered.For a well-founded and reproducible evaluation of analyses and optimizations, there is a strong demand for universally applicable benchmark approaches that are freely available for the entire scientific community. Benchmarks should satisfy the needs and requirements of various branches of research (e.g., schedulability analysis, WCET analysis, compiler optimization) on the one hand, but should also, on the other hand, realistically represent different application domains like, e.g., control or signal processing applications.This project aims at the realization of a flexible and parameterizable benchmark generator that produces benchmark programs in an automated, pseudo-randomized and reproducible fashion. This benchmark generator will in particular cover the system and the code level by producing both complete task sets and also actual program codes for the individual tasks. In order to enable a widespread use of the generator and a broad collaboration with arbitrary interested people and groups, this project will be inclusive and the developed software will be openly available right from the beginning. In the end, this project shall lead to a methodology for benchmarking-based evaluation that describes clearly and reproducibly for the different real-time communities, how to use the benchmark generator in order to obtain plausible, sound and scientifically accepted evaluation results.
      120
  • Some of the metrics are blocked by your 
    consent settings
    Item type:Project, Access status: without files ,
    Multi-criterial Code Optimization for Embedded Hard Real-Time Systems
    Embedded hard real-time systems often have to meet additional design constraints beyond their worst-case timing constraints. Systems operated on battery power have a limited amount energy available and should thus be as energy-efficient as possible. In addition, instruction, data and main memories of typical embedded processor architectures are also frequently severly limited due to technical limitations or given financial budgets. While designing embedded systems, these additional criteria also have to be considered, besides the system's real-time constraints.In order to achieve a correctly designed system, it has to meet all of the imposed resource constraints. If a system violates one or several design constraints, either the hardware platform must be modified or the resource demand of the software must be lowered. Modifying the hardware usually comes with an increase in costs and hardly predictable side effects. For example, exchanging the system's micro-controller in order to reduce power consumption will lead to changes in temporal behavior. Reducing the resource demand of the software by simply removing parts of the code is also not easily possible without compromising the correct functional behavior of the system.As a result, this project aims at optimizing embedded software systems at the compiler level with respect to multiple different design requirements. While translating source code to executable code, the compiler will aim to generate optimized code that finally fulfills all constraints with respect to multiple design criteria. However, current compilers are not able to achieve this, because multi-criterial system design is a highly volatile process. The optimization goals interfere with or may even directly contradict each other. Therefore, as part of this proposal, new optimization methods will be researched, implemented end evaluated for existing embedded hardware architectures. We focus on three of the most important criteria that embedded system designers are facing: Worst-Case Execution Time (WCET), code size and energy consumption.
      181
  • Some of the metrics are blocked by your 
    consent settings
    Item type:Project, Access status: without files ,
    Generation and Optimization of Real-Time Code for Embedded Multiprocess and Multiprocessor Systems
    Viele eingebettete Systeme sind sicherheitskritische Echtzeitsysteme, die Daten in fest vorgegebener Zeit verarbeiten müssen (z.B. Airbagsteuerungen, Autopiloten oder Fluglagesteuerungen). Beim Entwurf dieser Systeme wird deren Verhalten auf hoher Ebene (programmiersprachlich oder modellbasiert) spezifiziert. Compiler bilden ein unverzichtbares Werkzeug auf dem Weg von der Spezifikation zur Implementierung. Für Monoprozessoren und einzelne Prozesse wurde die Compilertechnik in jüngster Zeit so weiterentwickelt, dass eine Berücksichtigung der gewünschten Echtzeiteigenschaften bereits während der Kompilierung möglich ist. Für Multiprozessund Multiprozessor-Systeme existiert eine solche Unterstützung trotz deren wachsender Bedeutung bislang nicht. Ziel des Projektes ist es, für Multiprozess- und Multiprozessor-Systeme Softwareentwicklungsumgebungen bereitzustellen, die effizienten, bzgl. der größtmöglichen Ausführungszeit (Worst-Case Execution Time, WCET) optimierten Programmcode zum Einsatz in Echtzeitsystemen erzeugen können. Hierzu ist zu klären, wie Betriebssysteme und Compiler am besten zur Erreichung des Ziels zusammenwirken müssen. Hierfür notwendige Techniken der Kompilierung und Betriebssystemanpassungen sollen erforscht werden. Neben den grundlegenden Kooperationstechniken müssen Zeitmodelle und neue Optimierungstechniken entwickelt werden. In Multiprozess-Systemen können sich einzelne Prozesse gegenseitig unterbrechen und so in Wechselwirkung stehen. Es werden Optimierungen zur WCET-Reduktion entwickelt, die Prozesswechsel und Betriebssystem- Scheduler beachten. Für Multiprozessor-Systeme gilt, dass Prozessoren zeitgleich auf gemeinsame Ressourcen (z. B. Speicher, Busse) zugreifen und sich so gegenseitig beeinflussen können. Daher werden Optimierungen entwickelt, die zur WCET-Reduktion solcher Systeme Zugriffe auf gemeinsame Ressourcen berücksichtigen.
      102