Thread-level priority assignment in global multiprocessor scheduling for DAG tasks

https://doi.org/10.1016/j.jss.2015.12.004Get rights and content

Highlights

  • An efficient interference-based analysis for multi-threaded tasks is introduced.

  • The optimal thread-level priority assignment (OTPA) algorithm is proposed.

  • A novel priority assignment based on deadline adjustment is suggested.

  • Robust experiments that show great performance of our proposed approaches are given.

Abstract

The advent of multi- and many-core processors offers enormous performance potential for parallel tasks that exhibit sufficient intra-task thread-level parallelism. With a growth of novel parallel programming models (e.g., OpenMP, MapReduce), scheduling parallel tasks in the real-time context has received an increasing attention in the recent past. While most studies focused on schedulability analysis under some well-known scheduling algorithms designed for sequential tasks, little work has been introduced to design new scheduling policies that accommodate the features of parallel tasks, such as their multi-threaded structure. Motivated by this, we refine real-time scheduling algorithm categories according to the basic unit of scheduling and propose a new priority assignment method for global task-wide thread-level fixed-priority scheduling of parallel task systems. Our evaluation results show that a finer-grained, thread-level fixed-priority assignment, when properly assigned, significantly improves schedulability, compared to a coarser-grained, task-level assignment.

Introduction

The trend for multicore processors is towards an increasing number of on-chip cores. Today, CPUs with 8–10 state-of-the-art cores or 10s of smaller cores AMD are commonplace. In the near future, manycore processors with 100s of cores will be possible Comming soon. A shift from unicore to multicore processors allows inter-task parallelism, where several applications (tasks) can execute simultaneously on multiple cores. However, in order to fully exploit multicore processing potential, it entails support for intra-task parallelism, where a single task consists of multiple threads that are able to execute concurrently on multiple cores.

Two fundamental problems in real-time scheduling are (1) algorithm design to derive priorities so as to satisfy all timing constrains (i.e., deadlines) and (2) schedulability analysis to provide guarantees of deadline satisfaction. Over decades, those two fundamental problems have been substantially studied for multiprocessor scheduling (Davis and Burns, 2011), generally with a focus on the inter-task parallelism of single-threaded (sequential) tasks. Recently, a growing number of studies have been introduced for supporting multi-threaded (parallel) tasks (Bonifaci, Marchetti-Spaccamela, Stiller, Wiese, 2013, Li, Chen, Agrawal, Lu, Gill, Saifullah, 2014, Baruah, Bonifaci, Marchetti-Spaccamela, Stougie, Wiese, 2012, Andersson, de Niz, 2012, Li, Agrawal, Lu, Gill, 2013, Chwa, Lee, Phan, Easwaran, Shin, 2013, Baruah, 2014, Saifullah, Agrawal, Lu, Gill, 2011, Nelissen, Berten, Goossens, Milojevic, 2012a, Lakshmanan, Kato, Rajkumar, 2010, Liu, Anderson, 2010, Liu, Anderson, 2012, Ferry, Li, Mahadevan, Gill, Lu, Agrawal, 2013, Axer, Quinton, Neukirchner, Ernst, Dobel, Hartig, 2013, Qi Wang, 2014, Li, Luo, Ferry, Agrawal, Gill, Lu, 2015, Kwon, Kim, Paik, Lee, Lee, 2015, Melani, Bertogna, Bonifaci, Marchetti-Spaccamela, Buttazzo, 2015, Sanjoy Baruah, Bonifaci, 2015, Shen Li, Hu, 2015). Schedulability analysis has been the main subject of much work on thread-level parallelism (Bonifaci, Marchetti-Spaccamela, Stiller, Wiese, 2013, Li, Chen, Agrawal, Lu, Gill, Saifullah, 2014, Baruah, Bonifaci, Marchetti-Spaccamela, Stougie, Wiese, 2012, Andersson, de Niz, 2012, Li, Agrawal, Lu, Gill, 2013, Chwa, Lee, Phan, Easwaran, Shin, 2013, Baruah, 2014, Saifullah, Agrawal, Lu, Gill, 2011, Nelissen, Berten, Goossens, Milojevic, 2012a, Lakshmanan, Kato, Rajkumar, 2010, Liu, Anderson, 2010, Liu, Anderson, 2012, Ferry, Li, Mahadevan, Gill, Lu, Agrawal, 2013, Axer, Quinton, Neukirchner, Ernst, Dobel, Hartig, 2013, Li, Luo, Ferry, Agrawal, Gill, Lu, 2015) for some traditionally well-known scheduling policies, i.e., EDF (Earliest Deadline First) (Liu and Layland, 1973) and DM (Deadline Monotonic) (Leung and Whitehead, 1982). However, a relatively much less effort has been made to understand how to design good scheduling algorithms for parallel tasks.

In a sequential task, a task is a sequence of invocations, or jobs, and the task invocation is the unit of scheduling. In general, priority-based real-time scheduling algorithms can fall into three categories according to when priorities change (Davis and Burns, 2011) : task-wide fixed-priority where a task has a single static priority over all of its invocations (e.g., DM), job-wide fixed-priority where a job has a single fixed priority (e.g., EDF), and dynamic-priority where a single job may have different priorities at different times (e.g., LLF Least Laxity First Dertouzos and Mok, 1989).

A parallel task consists of multiple threads, and the invocation of a thread is then the unit of scheduling. This brings a new dimension to the scheduling categories. With a finer granularity of scheduling from task to thread, we can further subdivide each scheduling category into two sub-categories, task-level and thread-level, according to the unit of priority assignment. To this end, we can refine the scheduling categories to a finer-grained thread level as follows:

  • Task-wide thread-level fixed-priority: a single thread has a static priority across all of its invocations.

  • Job-wide thread-level fixed-priority: a single thread has a static priority over one invocation.

  • Thread-level dynamic-priority: a single thread can have different priorities at different times within one invocation.

In this paper, we aim to explore the possibility of performance enhancement in real-time scheduling by fully exploiting both inter-task and intra-task parallelisms. We hypothesize that a major factor in fully capitalizing on multicore processing potential is priority assignment. The key intuition behind our work is that finding an appropriate priority ordering is as important as using an efficient schedulability test, and that a finer-grained priority ordering at the thread level is more effective than a coarser-grained, task-level one. To this end, in this paper, we focus on priority assignment policies for global1 task-wide thread-level fixed-priority pre-emptive scheduling.

In the recent past, supporting intra-task thread-level parallelism in the context of real-time scheduling has received increasing attention in the recent past (Bonifaci, Marchetti-Spaccamela, Stiller, Wiese, 2013, Li, Chen, Agrawal, Lu, Gill, Saifullah, 2014, Baruah, Bonifaci, Marchetti-Spaccamela, Stougie, Wiese, 2012, Andersson, de Niz, 2012, Li, Agrawal, Lu, Gill, 2013, Chwa, Lee, Phan, Easwaran, Shin, 2013, Baruah, 2014, Saifullah, Agrawal, Lu, Gill, 2011, Nelissen, Berten, Goossens, Milojevic, 2012a, Lakshmanan, Kato, Rajkumar, 2010, Liu, Anderson, 2010, Liu, Anderson, 2012, Ferry, Li, Mahadevan, Gill, Lu, Agrawal, 2013, Axer, Quinton, Neukirchner, Ernst, Dobel, Hartig, 2013, Qi Wang, 2014, Li, Luo, Ferry, Agrawal, Gill, Lu, 2015, Kwon, Kim, Paik, Lee, Lee, 2015, Melani, Bertogna, Bonifaci, Marchetti-Spaccamela, Buttazzo, 2015, Sanjoy Baruah, Bonifaci, 2015, Shen Li, Hu, 2015). The work in Liu and Anderson (2010); 2012) considers soft real-time scheduling focusing on bounding tardiness upon deadline miss, while hard real-time systems aim at ensuring all deadlines are met. In this paper, we consider hard real-time scheduling.

Fork-join task model. The fork-join task model is one of the popular parallel task models (Lea, 2000), OpenMP, where a task consists of an alternate sequence of sequential and parallel regions, called segments, and all the threads within each segment should synchronize in order to proceed to the next segment. Under the assumption that each parallel segment can have at most as many threads as the number of processors, Lakshmanan et al. (2010) introduced a task decomposition method that transforms each synchronous parallel task into a set of independent sequential tasks, which can be then scheduled with traditional multiprocessor scheduling techniques. Lakshmanan et al. (2010) presented a resource augmentation bound2 of 3.42 for partitioned thread-level DM scheduling. Lately, Qi Wang (2014) attempted to implement a system, called FJOS, that supports to fork-join intra-task parallelism in a hard real-time environment. They proposed the overhead-aware assignment algorithm based on the analysis presented in Axer et al. (2013).

Synchronous parallel task model. Relaxing the restriction that sequential and parallel segments alternate, several studies have considered a more general synchronous parallel task model that allows each segment to have any arbitrary number of threads. Saifullah et al. (2011) presented decomposition method for synchronous parallel tasks and proved a resource augmentation bound of 4 for global thread-level EDF scheduling and 5 for partitioned thread-level DM scheduling. Building upon this work, Ferry et al. (2013) presented a prototype scheduling service for their RT-OpenMP concurrency platform. Nelissen et al. (2012a) also introduced another decomposition method and showed a resource augmentation bound of 2 for a certain class of global scheduling algorithms, such as PD2 (Srinivasan and Anderson, 2005), LLREF (Cho et al., 2006), DP-Wrap (Levin et al., 2010), or U-EDF (Nelissen et al., 2012b). Some studies (Andersson, de Niz, 2012, Chwa, Lee, Phan, Easwaran, Shin, 2013, Axer, Quinton, Neukirchner, Ernst, Dobel, Hartig, 2013) developed direct schedulability analysis without task decomposition for synchronous parallel tasks. In this context, Andersson and de Niz (2012) showed a resource augmentation bound of 21/m for global EDF scheduling. Chwa et al. (2013) introduced an interference-based analysis for global task-level EDF scheduling, and Axer et al. (2013) presented a response-time analysis (RTA) for partitioned thread-level fixed-priority scheduling.

DAG task model. Refining the granularity of synchronization from segment-level to thread-level, a DAG (Directed Acyclic Graph) task model is considered, where a node represents a thread and an edge specifies a precedence dependency between nodes. Baruah et al. (2012) showed a resource augmentation bound of 2 for a single DAG task with arbitrary deadlines under global task-level EDF scheduling. For a set of DAG tasks, a resource augmentation bound of 21/m was presented for global task-level EDF scheduling in Bonifaci et al. (2013), Li et al. (2013) and Baruah (2014). Bonifaci et al. (2013) also derived a 31/m resource augmentation bound for global task-level DM scheduling. In addition to those resource augmentation bounds, Li et al. (2013) introduced capacity augmentation bounds that can work as independent schedulability tests, and showed a 42/m capacity augmentation bound for global task-level EDF. In a further study, Li et al. (2015) developed a prototype platform, called PGEDF, by combining GNU-OpenMP runtime system and the LITMUSRT system for DAG tasks, and evaluated the schedulability test presented in Li et al. (2013). Later, Li et al. (2014) improved the capacity augmentation bound up to 2.6181 and 3.7321 for global task-level EDF and RM, respectively. Li et al. (2014) also proposed a new scheduling policy, called federated scheduling, and derived a resource augmentation bound of 2 for the proposed approach.

Nowadays, some studies have been introduced for an extended DAG task model, which considers more practical excution environments. Kwon et al. (2015) relaxed the assumption of a pre-defined number of threads in the DAG task model, and exploited multiple parallel options (i.e., runtime selectable numbers of threads) to improve schedulability. The work in Melani et al. (2015) and Sanjoy Baruah (2015) also proposed the extended DAG task model which characterizes the excution flow of conditional branch, and Shen Li (2015) proposed a real-time scheduling of MapReduce workflows based on a hierarchical scheduling scheme.

In summary, much work in the literature introduced and improved schedulability analysis for different parallel task models under different multiprocessor scheduling approaches and algorithms. Table 1 summarizes the global scheduling algorithms that have been considered in the literature, to the best of the author’s knowledge. We have two interesting observations from the table. One is that most existing studies considered well-known deadline-based scheduling algorithms (EDF, DM) originally designed for sequential tasks, with a large portion on task-level priority scheduling. Capturing the urgency of real-time workloads, deadlines are a good real-time scheduling parameter, in particular, for sequential tasks on a single processor (Liu and Layland, 1973). However, deadlines are no longer as effective for parallel tasks on multiprocessors, since deadlines are inappropriate to represent the characteristics of parallel tasks, including the degree of intra-task parallelism (i.e., the number of threads that can run in parallel on multiprocessors) or precedence dependency between threads. The other observation from Table 1 is that little work has explored the task-wide thread-level fixed-priority scheduling category. These motivate our work to develop a new task-wide thread-level fixed-priority assignment method that incorporates the characteristics of DAG tasks.

This work is motivated by an attempt to see how good task-wide thread-level fixed-priority assignment, beyond task-level, can be for global multiprocessor scheduling of parallel tasks. To this end, this paper seeks to explore the possibility of using the OPA (Optimal Priority Assignment) algorithm (Audsley, 1991, Audsley, 2001, Davis, Burns, 2009), which is proven to be optimal in task-wide fixed-priority assignment for independent tasks with respect to some given schedulability analysis. The application of OPA to thread-level priority assignment raises several issues, including how to deal with thread-level dependency and how to develop an efficient thread-level OPA-compatible analysis.

A parallel task typically consists of multiple threads that come with their own precedence dependency. With such a thread-level dependency in the parallel task case, it is thereby non-trivial to make use of OPA for thread-level priority assignment, since OPA is designed for independent tasks. Task decomposition is one of the widely used approaches to deal with the thread-level precedence dependency (Saifullah, Agrawal, Lu, Gill, 2011, Nelissen, Berten, Goossens, Milojevic, 2012a, Lakshmanan, Kato, Rajkumar, 2010, Ferry, Li, Mahadevan, Gill, Lu, Agrawal, 2013, Axer, Quinton, Neukirchner, Ernst, Dobel, Hartig, 2013). Through task decomposition, each individual thread is assigned its own offset and deadline in a way that its execution is separated from those of its predecessors. This allows all threads to be considered as independent as long as their thread-level deadlines can be met. In this paper, we employ such a task decomposition approach to develop an OPA-based thread-level priority assignment method.

Contributions. The main results and contributions of this paper can be summarized as follows. First, we introduce an efficient thread-level interference-based analysis that is aware of the multi-threaded structure of parallel tasks (in Section 3). We also show that the proposed analysis is OPA-compatible (in Section 4). This allows OPA, when using the proposed analysis, to accommodate the characteristics of parallel tasks via its underlying analysis in priority assignment.

Second, we show that the OPA algorithm, originally designed for independent sequential tasks, is applicable to parallel tasks when thread-level precedence dependencies are resolved properly through task decomposition. That is, the algorithm holds optimality in thread-level priority assignment when threads are independent with their own offsets and deadlines with respect to its underlying analysis (in Section 4). With the use of OPA, this study separates thread priority assignment from thread dependency resolution. While most previous decomposition-based studies (Saifullah, Agrawal, Lu, Gill, 2011, Lakshmanan, Kato, Rajkumar, 2010, Ferry, Li, Mahadevan, Gill, Lu, Agrawal, 2013) share an approach that resolves between-thread dependencies by determining the relative deadlines of individual threads properly and makes use of thread deadlines for priority ordering, this study decouples thread priorities from deadlines.

Third, we propose a new OPA-based priority assignment method that adjusts thread offsets and deadlines, called PADA (Priority Assignment with Deadline Adjustment), taking into consideration the properties of OPA and its underlying analysis (in Section 5). In the previous studies on fixed-priority scheduling (Saifullah, Agrawal, Lu, Gill, 2011, Lakshmanan, Kato, Rajkumar, 2010, Ferry, Li, Mahadevan, Gill, Lu, Agrawal, 2013), thread deadlines are determined, from an individual task perspective, only to resolve intra-task thread dependency. On the other hand, in this study, thread deadlines are adjusted, from the system-wide perspective, to accommodate interference between tasks for schedulability improvement.

Finally, our evaluation results show that the proposed thread-level priority assignment is significantly more effective, in terms of the number of task sets deemed schedulable, than task-level priority assignment in global task-wide fixed-priority scheduling (in Section 6). The results also show that incorporating the features of parallel tasks into priority assignment significantly improves schedulability, compared to traditional deadline-based priority ordering, and that the proposed approach outperforms the existing approaches.

Section snippets

DAG task

We consider a set of DAG (Directed Acyclic Graph) tasks τ. A DAG task τiτ is represented by a directed acyclic graph as shown in Fig. 1(a). A vertex vi, p in τi represents a single thread θi, p, and a directed edge from vi, p to vi, q represents the precedence dependency such that θi, q cannot start execution unless θi, p has finished execution. A thread θi, p becomes ready for execution as soon as all of its predecessors have completed their execution.

A sporadic DAG task τi invokes a series

Schedulability analysis

Once a DAG task is decomposed into individual threads, each thread has its own relative offset and deadline without having to consider precedence dependency any more. This allows to treat each thread as an individual independent sequential task, and it is possible to analyze the schedulability of each thread in a sufficient manner using the existing task-level schedulability analyzes. However, this brings a substantial degree of pessimism since the existing task-level analysis techniques were

Optimal thread-level priority assignment

This paper considers the thread-level optimal priority assignment problem that, given a decomposed set τdecom, determines the priority Pi, p of every thread θi, pτdecom such that the decomposed set is deemed schedulable according to the workload-based schedulability test given in Theorem 1. In this section, we show that the OPA algorithm for sequential tasks is applicable to parallel tasks with decomposition.

The OPA algorithm (Davis and Burns, 2009) aims at assigning a priority to each

Priority assignment with deadline adjustment

In the previous section, thread-level priority assignment was considered under the assumption that the offset and deadline of each thread are given statically. Relaxing this assumption, in this section, we consider the problem of determining the offset, deadline, and priority of each individual thread such that the parallel task system is deemed schedulable according to the schedulability analysis in Theorem 1.

The existing decomposition approaches (Saifullah, Agrawal, Lu, Gill, 2011, Nelissen,

Evaluation

In this section, we present simulation results to evaluate the proposed thread-level priority assignment algorithms. For presentational convenience, we here define terms. Ci is the sum of the worst-case execution times of all threads of τi (≜∑qCi, q), and Usys is the system utilization (=τiτCi/Ti). Also, Li is the worst-case execution time of τi on infinite number of processors, called critical execution path, and LUsys is defined as the maximum Li/Di among the tasks τiτ.

Conclusion

In the recent past, there is a growing attention to supporting parallel tasks in the context of real-time scheduling (Bonifaci, Marchetti-Spaccamela, Stiller, Wiese, 2013, Li, Chen, Agrawal, Lu, Gill, Saifullah, 2014, Baruah, Bonifaci, Marchetti-Spaccamela, Stougie, Wiese, 2012, Andersson, de Niz, 2012, Li, Agrawal, Lu, Gill, 2013, Chwa, Lee, Phan, Easwaran, Shin, 2013, Baruah, 2014, Saifullah, Agrawal, Lu, Gill, 2011, Nelissen, Berten, Goossens, Milojevic, 2012a, Lakshmanan, Kato, Rajkumar,

Acknowledgments

This work was supported in part by BSRP (NRF-2010-0006650, NRF-2012R1A1A1014930, NRF-2014R1A1A1035827), NCRC (2010-0028680), IITP (2011-10041313, B0101-15-0557), and NRF (2015M3A9A7067220) funded by the Korea Government (MEST/MSIP/MOTIE). This work was also conducted at High-Speed Vehicle Research Center of KAIST with the support of Defense Acquisition Program Administration (DAPA) and Agency for Defense Development (ADD).

Jiyeon Lee received B.S. degree in Computer Science from Dankook Univercity, South Korea in 2012 and M.S. degree in Computer Science from KAIST (Korea Advanced Institute of Science and Technology), South Korea in 2014. She is currently working toward the Ph.D. degree in Computer Science from KAIST. Her research interests include system design and analysis with timing guarantees and resource management in real-time embedded systems and cyber-physical systems.

References (50)

  • AudsleyN.C.

    On priority asignment in fixed priority scheduling

    Inf. Process. Lett.

    (2001)
  • LeungJ. et al.

    On the complexity of fixed-priority scheduling of periodic real-time tasks

    Perform. Eval.

    (1982)
  • SrinivasanA. et al.

    Fair scheduling of dynamic task systems on multiprocessors

    J. Syst. Softw.

    (2005)
  • ...
  • AnderssonB. et al.

    Analyzing global-EDF for multiprocessor scheduling of parallel tasks

    Proceedings of International Conference on Principles of Distributed Systems

    (2012)
  • AudsleyN.

    Optimal Priority Assignment and Feasibility of Static Priority Tasks With Arbitrary Start Times

    Technical Report YCS164

    (1991)
  • AxerP. et al.

    Response-time analysis of parallel fork-join workloads with real-time constraints

    Proceedings of Euromicro Conference on Real-Time Systems. ECRTS

    (2013)
  • BackH. et al.

    Schedulability analysis and priority assignment for global job-level fixed-priority multiprocessor scheduling

    Proceedings of Real-Time and Embedded Technology and Applications Symposium. RTAS

    (2012)
  • BakerT.P.

    Multiprocessor EDF and deadline monotonic schedulability analysis

    Proceedings of Real-Time and Embedded Technology and Applications Symposium. RTSS

    (2003)
  • BaruahS.

    Improved multiprocessor global schedulability analysis of sporadic DAG task systems

    Proceedings of Euromicro Conference on Real-Time Systems. ECRTS

    (2014)
  • BaruahS. et al.

    A generalized parallel task model for recurrent real-time processes

    Proceedings of Real-Time Systems Symposium. RTSS

    (2012)
  • BertognaM. et al.

    Improved schedulability analysis of EDF on multiprocessor platforms

    Proceedings of Euromicro Conference on Real-Time Systems. ECRTS

    (2005)
  • BertognaM. et al.

    Schedulability analysis of global scheduling algorithms on multiprocessor platforms

    IEEE Trans. Parallel Distrib. Syst.

    (2009)
  • BonifaciV. et al.

    Feasibility analysis in the sporadic DAG task model

    Proceedings of Euromicro Conference on Real-Time Systems. ECRTS

    (2013)
  • ChoH. et al.

    An optimal real-time scheduling algorithm for multiprocessors

    Proceedings of Real-Time Systems Symposium. RTSS

    (2006)
  • ChwaH.S. et al.

    Extending task-level to job-level fixed priority assignment and schedulability analysis using pseudo-deadlines

    Proceedings of Real-Time Systems Symposium. RTSS

    (2012)
  • ChwaH.S. et al.

    Global EDF schedulability analysis for synchronous parallel tasks on multicore platforms

    Proceedings of Euromicro Conference on Real-Time Systems. ECRTS

    (2013)
  • Comming soon tile-gx100 the first 100 cores processors in the world....
  • CordeiroD. et al.

    Random graph generation for scheduling simulations

    Proceedings of International Conference on Simulation Tools and Techniques. SIMUTools

    (2010)
  • DavisR. et al.

    Priority assignment for global fixed priority pre-emptive scheduling in multiprocessor real-time systems

    Proceedings of Real-Time Systems Symposium. RTSS

    (2009)
  • DavisR.I. et al.

    A survey of hard real-time scheduling for multiprocessor systems

    ACM Comput. Surv.

    (2011)
  • DertouzosM.L. et al.

    Multiprocessor on-line scheduling of hard-real-time tasks

    IEEE Trans. Softw. Eng.

    (1989)
  • Y. Ding et al.

    Multicore-aware code co-positioning to reduce WCET on dual-core processors with shared instruction caches

    J. Comput. Sci. Eng.

    (2012)
  • Y. Ding et al.

    Bounding worst-case DRAM performance on multicore processors

    J. Comput. Sci. Eng.

    (2013)
  • Y. Ding et al.

    Multicore real-time scheduling to reduce inter-thread cache interferences

    J. Comput. Sci. Eng.

    (2013)
  • Cited by (12)

    • Real-Time scheduling and analysis of parallel tasks on heterogeneous multi-cores

      2020, Journal of Systems Architecture
      Citation Excerpt :

      DAG task model is a promising model to formulate the intra-task parallelism software. The real-time scheduling and analysis of DAG parallel task model has gained a lot of attention in the real-time and High-Performance Computing communities [8–18]. Moreover, heterogeneous hardware architecture that can utilize specialized processing capabilities and can offer higher performance and energy efficiency than homogeneous architecture has received more and more attention [19–23].

    • Improved schedulability analysis of the contention-free policy for real-time systems

      2019, Journal of Systems and Software
      Citation Excerpt :

      Among the broad spectrum of research in the area of real-time scheduling, scheduling algorithm design and schedulability analysis are the fundamental parts; the former aims at developing a prioritization policy for real-time tasks, and the latter aims to obtain their timing guarantees at design time. A number of studies addressed the former and/or the latter, e.g., Lee et al. (2016) and Lee and Shin (2017). Over the last few decades, as multiprocessor platforms have been increasingly used in the real-time systems for high-end real-time applications, a number of studies on real-time scheduling theory have been performed so as to effectively exploit such platforms, e.g., Brandenburg and Gul (2016), Melani et al. (2016) and Biondi et al. (2016).

    • SMART-EDF: An EDF based semi-partitioned energy-Aware multicore scheduler for real-Time systems

      2021, IEEE Region 10 Annual International Conference, Proceedings/TENCON
    • Response Time Analysis of Typed DAG Tasks on Heterogeneous Multi-Cores

      2020, Jisuanji Xuebao/Chinese Journal of Computers
    View all citing articles on Scopus

    Jiyeon Lee received B.S. degree in Computer Science from Dankook Univercity, South Korea in 2012 and M.S. degree in Computer Science from KAIST (Korea Advanced Institute of Science and Technology), South Korea in 2014. She is currently working toward the Ph.D. degree in Computer Science from KAIST. Her research interests include system design and analysis with timing guarantees and resource management in real-time embedded systems and cyber-physical systems.

    Hoon Sung Chwa received B.S. and M.S. degrees in Computer Science in 2009 and 2011, respectively, from KAIST (Korea Advanced Institute of Science and Technology), South Korea. He is currently working toward the Ph.D. degree in Computer Science from KAIST. His research interests include system design and analysis with timing guarantees and resource management in real-time embedded systems and cyber-physical systems. He won two best paper awards from the 33rd IEEE Real-Time Systems Symposium (RTSS) in 2012 and from the IEEE International Conference on Cyber-Physical Systems, Networks, and Applications (CPSNA) in 2014.

    Jinkyu Lee is an assistant professor in Department of Computer Science and Engineering, Sungkyunkwan University (SKKU), Republic of Korea, where he joined in 2014. He received the B.S., M.S., and Ph.D. degrees in computer science from the Korea Advanced Institute of Science and Technology (KAIST), Republic of Korea, in 2004, 2006, and 2011, respectively. He has been a research fellow/visiting scholar in the Department of Electrical Engineering and Computer Science, University of Michigan until 2014. His research interests include system design and analysis with timing guarantees, QoS support, and resource management in real-time embedded systems and cyber-physical systems. He won the best student paper award from the 17th IEEE Real-Time and Embedded Technology and Applications Symposium (RTAS) in 2011, and the Best Paper Award from the 33rd IEEE Real-Time Systems Symposium (RTSS) in 2012.

    Insik Shin is currently an associate professor in Department of Computer Science at KAIST, South Korea, where he joined in 2008. He received a B.S. from Korea University, an M.S. from Stanford University, and a Ph.D. from University of Pennsylvania all in Computer Science in 1994, 1998, and 2006, respectively. He has been a post-doctoral research fellow at Malardalen University, Sweden, and a visiting scholar at University of Illinois, Urbana-Champaign until 2008. His research interests lie in cyber-physical systems and real-time embedded systems. He is currently a member of Editorial Boards of Journal of Computing Science and Engineering. He has been co-chairs of various workshops including satellite workshops of RTSS, CPSWeek and RTCSA and has served various program committees in real-time embedded systems, including RTSS, RTAS, ECRTS, and EMSOFT. He received best paper awards, including Best Paper Awards from RTSS in 2003 and 2012, Best Student Paper Award from RTAS in 2011, and Best Paper runner-ups at ECRTS and RTSS in 2008.

    View full text