Back to results list
Show full item record
Please use this identifier to cite or link to this item:
|Title:||Design and analysis for embedded systems to meet resource constraints||Authors:||Zhang, Wei||Degree:||Ph.D.||Issue Date:||2021||Abstract:||Embedded systems are generally subject to resource constraints due to the limited amount of available resources. To operate correctly, efficiently and sustainedly in the presence of resource constraints, the system should be precisely analyzed and elaborately designed. This thesis considers two typical resource constraints, timing constraints and energy constraints, and studies on designing or analyzing embedded software under these constraints. Tasks in real-time systems have a limited amount of time to use. In order to satisfy the timing constraints, the worst-case execution time (WCET) of real-time tasks should be tightly and safely predicted. In the past decades, the WCET analysis of real-time tasks is well studied under the single-task environment. However, in reality, a task may be interfered with by other tasks, resulting in more cache misses and additional execution time. For instance, higher priority tasks may preempt the lower priority task's execution and evict memory blocks accessed by the lower priority task. Once the lower priority task is resumed, the memory reference that is originally cache hit may miss the cache, and additional time will be costed to reload these additional cache miss memory blocks. The additional execution time and the additional cache miss memory block are called cache-related preemption delay (CRPD) and useful cache block (UCB), respectively. The state-of-the-art method computes the CRPD by counting the number of UCB. However, it can not capture the dynamic behavior of data memory references, e.g., index-dependent array access, as a result, may either overestimate or underestimate the CRPD. To address this problem, this thesis adopts the temporal scope analysis to capture the dynamic behavior of data memory references and integrate it into the existing UCB computation method to tightly and safely bound the number of UCB. Experimentally, our approach conducts a tighter and safe result comparing with the state-of-the-art. A real-time task may be preempted more than once during its one operating period, and thus the total CRPD caused by all the preemptions should be counted. The state-of-the art method counts the number of UCB of different preemption points in isolation and sums the k-largest counts as the total number of extra cache misses of k preemptions. However, different preemption points may have the same UCB, and simply summing them may double count some UCB, causing overestimation. To address this problem, we efficiently explore the correlation on UCB computation among different preemption points and introduce a new analysis unit to produce a tighter total UCB. Experiments with benchmark programs show that the proposed technique leads to substantially tighter total CRPD estimation with multiple preemptions comparing with the state-of-the-art.
Similar to preemptions, shared cache contentions between parallel executing tasks may also cause additional cache misses and execution time. The state-of-the-art method considers that all the possible shared cache contentions between parallel executing tasks can happen together. In specific, a memory reference is considered as a shared cache miss as long as its parallel executing tasks access the same shared cache line with it. But, because each task's memory references are accessed in a certain order, a large portion of the shared cache contentions can not happen together in reality. Therefore the state-of-the-art method is pessimistic. To address this problem, this thesis models shared cache contentions between memory references and access orders among memory references together, and proposes an efficient algorithm for calculating the worst-case additional execution time. We conduct the experiments with the MRTC benchmarks. Experiment results show that our method can significantly improve the analysis precision over the state-of-the-art with most benchmark programs without sacrificing the analysis efficiency. Energy harvesting systems, which harvest energy from the environment to operate, promise to power billions of IoT devices without being restricted by battery life. Since the ambient energy is generally weak and unstable, the system is subject to energy constraints; that is, it may suffer unpredictable and frequent power failures. To finish a task across power outages, the state-of-the-art method frequently backup the system state, which costs lots of energy and time and adversely reduces the time and energy for the program's execution. This thesis proposes LATICS, a low-overhead adaptive task-based intermittent computing system, which adaptively skips some unnecessary state savings when the energy supply is sufficient. To reduce the backup overhead, we precisely analyze the minimum set of data that should be saved when its following state saving points are dynamically enabled/disabled at run-time rather than saving all the system state. Moreover, we disclose that the state saving point can not be blindly skipped even if the energy is sufficient. It is because skipping such state saving points can lead to more data to backup. In this thesis, we introduce the concept of breaking points to avoid skipping such points. Experimentally, LATICS significantly reduces state saving overhead and improves execution efficiency compared to existing solutions. State backup which is performed frequently in energy harvesting systems, is considered as the performance bottleneck. Although its overhead can be reduced through some optimizing techniques, it always blocks the system's execution as they are performed in sequential. Performing state saving and system execution in parallel is feasible in modern MCU, e.g., by leverage DMA, but is not adopted by existing systems as it may cause data race and further system error. However, in energy harvesting systems, since the backup is performed frequently, the former incorrect backup can be overwritten soon by the following backups. Moreover, incorrect backup rarely happens as only a part of data may result in incorrect backup errors. Therefore, in this work, instead of avoiding the incorrect backup, we allow the incorrect backup to occur and propose an efficient method to precisely detect the incorrect backup. In addition, we design a fault-tolerant backup management mechanism to guarantee that the system can execute correctly in case of the state is backed up incorrectly. The proposed method is implemented as a run-time system, and experimental results show that the proposed method has a better performance than existing methods.
|Subjects:||Embedded computer systems
Embedded computer systems -- Design and construction
Hong Kong Polytechnic University -- Dissertations
|Pages:||xvi, 161 pages : illustrations|
|Appears in Collections:||Thesis|
View full-text via https://theses.lib.polyu.edu.hk/handle/200/11358
Citations as of May 22, 2022
Items in DSpace are protected by copyright, with all rights reserved, unless otherwise indicated.