Figure 6 - uploaded by Mayukh Saubhasik
Content may be subject to copyright.
Source publication
Advances in hardware capacity, especially I/O devices such as cameras and displays, are driving the development of ap- plications like high-definition video conferencing that ha ve tight timing and CPU requirements. Unfortunately, current operating systems do not adequately provide the timing response needed by these applications. In this paper, we...
Contexts in source publication
Context 1
... the multiple-group experiment, only the timer event information is shared, and the kernel allocates CPU fairly. Figure 6 shows the cumulative distribution of tardiness in QStream with the three schedulers. Both the single and multiple group cases of the cooperative scheduler achieve comparable tardiness, in the 1ms range. ...
Context 2
... should emphasize that the adap- tive threads use cooperative polling, which indirectly helps X11 even when it does not use cooperative polling. The X11 tardiness would be close to the Linux CFS CDF shown in Figure 6 if the adaptive threads were running under CFS. Figure 12. Tardiness with a misbehaving cooperative task. ...
Similar publications
In a multiparty video conference, multiple users simultaneously distribute video streams to their receivers. As the traditional server-based solutions incur high infrastructure and bandwidth cost, conventional peer-to-peer (P2P) solutions only leveraging end-users' upload bandwidth are normally not self-sustainable: The video streaming workload inc...
The integration of information and communication technologies (ICT) has been one of the priorities of the Moroccan education system that date back to pre-COVID-19 period. Since 1999, the National Charter for Education and Training has accorded great importance to distance education (DE) and learning. Several programmes and initiatives (such as GENI...
Gaze mismatch is a common problem in video conferencing, where the viewpoint captured by a camera (usually located above or below a display monitor) is not aligned with the gaze direction of the human subject, who typically looks at his counterpart in the center of the screen. This means that the two parties cannot converse eye-to-eye, hampering th...
Compared to more common media of communication such as telephone or e-mail, video conferences (VCs) provide further communicational resources for the interactants by allowing for visual cues that are suspected to play a major role in discourse management, cognitive and affective processing. Video-conferencing furthermore has a number of practical a...
The purpose of this paper is to examine the effectiveness of different social marketing communication strategies and evaluate their appropriateness to situational needs amid COVID-19 pandemic. In-Depth semi-structured interviews were conducted with participants using the Zoom video conferencing tool to investigate the effectiveness of three wearing...
Citations
... Redline [190] improves the performance of interactive applications by allowing users to specify requirements to the scheduler without modifying the application. Other solutions propose to provide an application programming interface (API) to applications so that they can communicate their requirements to the scheduler at run time [3,101,150]. work conservation. ...
In this thesis, we address the problem of schedulers for multi-core architectures from several perspectives: design (simplicity and correctness), performance improvement and the development of application-specific schedulers. The contributions presented are summarized as follows:- Ipanema, a domain-specific language dedicated to thread schedulers for multi-core architectures. We also implement a new abstraction in the Linux kernel that enables the dynamic addition of schedulers written in Ipanema.- a series of performance and bug tracking tools. Thanks to these tools, we show that the Linux scheduler, CFS, suffers from a problem related to frequency management on modern processors. We propose a solution to this problem in the form of a patch submitted to the community. This patch allows to significantly improve the performance of numerous applications.- a scheduler model in the form of a “feature tree”. We implement these features independently in order to offer a new fully modular scheduler. This modular scheduler allows us to study exhaustively the different combinations of features, thus paving the way for the development of application-specific schedulers.
... Redline [190] improves the performance of interactive applications by allowing users to specify requirements to the scheduler without modifying the application. Other solutions propose to provide an application programming interface (API) to applications so that they can communicate their requirements to the scheduler at run time [3,101,150]. work conservation. ...
In this thesis, we address the problem of schedulers for multi-core architectures from several perspectives: design (simplicity and correctness), performance improvement and the development of application-specific schedulers. The contributions presented are summarized as follows : - Ipanema, a domain-specific language dedicated to thread schedulers for multi-core architectures. We also implement a new abstraction in the Linux kernel that enables the dynamic addition of schedulers written in Ipanema. - a series of performance and bug tracking tools. Thanks to these tools, we show that the Linux scheduler, CFS, suffers from a problem related to frequency management on modern processors. We propose a solution to this problem in the form of a patch submitted to the community. This patch allows to significantly improve the performance of numerous applications. - a scheduler model in the form of a “feature tree”. We implement these features independently in order to offer a new fully modular scheduler. This modular scheduler allows us to study exhaustively the different combinations of features, thus paving the way for the development of application-specific schedulers.
... These two types of computations need to be clearly identified so that their needs can be met independently. DOHA provides an event-loop abstraction to ensure timely event execution [41]. The event-loop dispatches non-preemptively, prioritizing the time synchronous computations over the best-effort computations. ...
... Event-driven reactivity in DOHA has its roots in the concepts of reactive programming [5]. DOHA introduces execution event classes and specifies timing information at the event level similar to the application model in Cooperative Polling [41]. Explicit execution events are used for all computations and the underlying scheduler adheres to hints in events to run important computations in a timely fashion. ...
... On the other hand, Paceline streams share the same underlying TCP channel and use weighted fair sharing across concurrent streams. Paceline's support for fairness across multiple concurrent streams is influenced by CPU scheduling for multimedia applications[41]. Finally, application-level protocols, such as MUX[26] and BEEP[62] multiplex logical streams over one communication channel similar to Paceline; however, they do not deal with timeliness or fairness across streams. ...
Emerging interactive multimedia applications, such as real-time visualizations, animations, on-line games, virtual reality, and video conferencing have low latency interactions and continuous high resource (e.g., CPU processing and network bandwidth) demands. The combination of latency sensitive interactions and high resource demands is challenging for best-effort platforms, such as the Internet, general-purpose operating systems and Web browsers because these platforms have no timing or resource guarantees and tend to favor high utilization. When demands exceed available resources, it is impossible to process all computations and data in a timely fashion resulting in diminished perceived quality (e.g., frame rate) and brittle real-time performance. The mismatch between application demands and available resources is observed to varying degrees in all resources including network, processing, and storage. To deal with the volatility and shortage of resources, we build upon and extend the Priority-Progress quality adaptation model. Our approach enables applications to scale demands (up or down) based on available resources and to utilize the limited resources in processing the computations and data with more influence over perceived quality. We develop enhancement layers to improve timeliness and guarantee more consistent quality using quality adaptation while maintaining the strengths of the existing best-effort transports and execution platforms. DOHA, our execution layer, extends the Priority-Progress CPU adaptation to work in games and across multiple execution threads. The modified game has better timing, higher perceived quality, and linearly scalable quality with a small number of cores. Our transport layer, Paceline, introduces low latency techniques over TCP and exposes Priority-Progress adaptation as an essential transport feature improving upon TCP's end-to-end latency while preserving its fairness and utilization.
... These two types of computations need to be clearly identified so that their needs can be met independently. The event-loop dispatches non-preemptively, prioritizing the time synchronous computations over the best-effort computations [14]. Events can be dispatched with low latency because our event-based model should ideally have short-lived computations that avoid blocking. ...
... Event-driven reactivity in DOHA has its roots in the concepts of reactive programming [3]. DOHA introduces event classes and specifies timing information at the event level similar to the application model in Cooperative Polling [14]. ...
Browsers have become mature execution platforms enabling web applications to rival their desktop counterparts. An important class of such applications is interactive multimedia: games, animations, and interactive visualizations. Unlike many early web applications, these applications are latency sensitive and processing (CPU and graphics) intensive. When demands exceed available resources, application quality (e.g., frame rate) diminishes because it is hard to balance timeliness and utilization. The quality of ambitious web applications is also limited by single-threaded execution prevalent in the Web. Applications need to scale their quality, and thereby scale processing load, based on the resources that are available. We refer to this as scalable quality.
DOHA is an execution layer written entirely in JavaScript to enable scalable quality in web applications. DOHA favors important computations with more influence over quality based on hints from application-specific adaptation policies. To utilize widely available multi-core resources, DOHA augments HTML5 web workers with mechanisms to facilitate state management and load-balancing. We evaluate DOHA with an award-winning web-based game. When resources are limited, the modified game has better timing and overall quality. More importantly, quality scales linearly with a small number of cores and the game is playable in challenging scenarios that are beyond the scope of the original game.
... These two types of computations need to be clearly identified so that their needs can be met independently. The event-loop dispatches non-preemptively, prioritizing the time-synchronous computations (timer events) over the best-effort computations (best-effort events) [4]. This is possible because our event-based model should have computations that are non-preemptive and short-lived. ...
As the Web has grown in popularity, web applications have started to rival their desktop counterparts. An important class of such applications is interactive multimedia: games, animations, and interactive visualizations. Unlike many early web applications, these applications are latency sensitive and processing (CPU and graphics) intensive. As web applications execute on a wide range of hardware from phones to powerful desktops and dynamically share these platforms with other applications, resolving the conflict between timeliness, application quality, and CPU utilization is a challenge. We propose scalable quality, which consists of application-defined policies and an adaptive execution layer that includes HTML5 worker threads. This paper describes our adaptive approach to maximize quality according to available resources. We also explore the challenges of using web workers in a real game and share our initial design decisions for concurrent web-based game development.
... Lu et al. dynamically adjust the cache size for multiple request classes [17]. Krasic et al. [18] propose an approach called cooperative polling to ensure rigorous all applications fairly share resources. Lu et al. propose scheduling scheme to satisfy the requirements of different QoS requests for access to the networked storage system [19]. ...
Resource provisioning for N-tier web applications in Clouds is non-trivial due to at least two reasons. First, there is an inherent optimization conflict between cost of resources and Service Level Agreement (SLA) compliance. Second, the resource demands of the multiple tiers can be different from each other, and varying along with the time. Resources have to be allocated to multiple (virtual) containers to minimize the total amount of resources while meeting the end-to-end performance requirements for the application. In this paper we address these two challenges through the combination of the resource controllers on both application and container levels. On the application level, a decision maker (i.e., an adaptive feedback controller) determines the total budget of the resources that are required for the application to meet SLA requirements as the workload varies. On the container level, a second controller partitions the total resource budget among the components of the applications to optimize the application performance (i.e., to minimize the round trip time). We evaluated our method with three different workload models -- open, closed, and semi-open - that were implemented in the RUBiS web application benchmark. Our evaluation indicates two major advantages of our method in comparison to previous approaches. First, fewer resources are provisioned to the applications to achieve the same performance. Second, our approach is robust enough to address various types of workloads with time-varying resource demand without reconfiguration.
... The important lesson and the key insight derived from past work and driving our research is that in order to most efficiently utilize heterogeneous platforms, there should be transparency -not opacity -between the different levels of abstraction present in modern systems, including applications, toolchains, runtimes, systems, and hardware. Specifically, there should be ways for applications and runtimes to inform systems about known or inferred needs and requirements [21,39,32,24], and there should be platform-provided information which systems can use to better manage platform resources. Common methods concerning the latter are the runtime use of hardware performance counters or system-level monitoring methods [27] and similar arguments can be made about runtime information provided to toolchains in order to fuse or merge finegrained parallel computations into larger units better suited for execution on platform cores or caches [12]. ...
... It is important, therefore, to present to guests and applications the heterogeneous platforms with exactly the characteristics they expect to see, and conversely, to enable the management methods resident at different levels of ab-straction to operate 'symbiotically' and jointly to gain desired performance/power tradeoffs [26]. The need for and usefulness of such information sharing and interaction has been demonstrated for broad classes of systems and application domains, including in [38,32,26,21,18], with one intuition being that resource management methods running at different system levels have differing purposes, such as VMM-level resource management concerned with platform-level properties like total power usage vs. VM-level management focused on meeting the demands of applications run in each VM. ...
Trends indicate a rapid increase in the number of cores on chip, exhibiting various types of performance and functional asymmetries present in hardware to gain scalability with balanced power vs. performance requirements. This poses new challenges in platform resource management, which are further exacerbated by the need for runtime power budgeting and by the increased dynamics in workload behavior observed in consolidated datacenter and cloudcomputing systems. This paper considers the implications of these challenges for the virtualization layer of abstraction, which is the base layer for resource management in such heterogeneous multicore platforms. Specifically, while existing and upcoming management methods routinely leverage system-level information available to the hypervisor about current and global platform state, we argue that for future systems there will be an increased necessity for additional information about applications and their needs. This 'end-to-end' argument leads us to propose 'performance points' as a general interface between the virtualization system and higher layers like the guest operating systems that run application workloads. Building on concrete examples from past work on APIs with which applications can inform systems of phase or workload changes and conversely, with which systems can indicate to applications desired changes in power consumption, performance points are shown to be an effective way to better exploit asymmetries and gain the power/performance improvements promised by heterogeneous multicore systems.
... The important lesson and the key insight derived from past work and driving our research is that in order to most efficiently utilize heterogeneous platforms, there should be transparency -not opacity -between the different levels of abstraction present in modern systems, including applications, toolchains, runtimes, systems, and hardware. Specifically, there should be ways for applications and runtimes to inform systems about known or inferred needs and requirements [21,39,32,24], and there should be platform-provided information which systems can use to better manage platform resources. Common methods concerning the latter are the runtime use of hardware performance counters or system-level monitoring methods [27] and similar arguments can be made about runtime information provided to toolchains in order to fuse or merge finegrained parallel computations into larger units better suited for execution on platform cores or caches [12]. ...
... It is important, therefore, to present to guests and applications the heterogeneous platforms with exactly the characteristics they expect to see, and conversely, to enable the management methods resident at different levels of ab-straction to operate 'symbiotically' and jointly to gain desired performance/power tradeoffs [26]. The need for and usefulness of such information sharing and interaction has been demonstrated for broad classes of systems and application domains, including in [38,32,26,21,18], with one intuition being that resource management methods running at different system levels have differing purposes, such as VMM-level resource management concerned with platform-level properties like total power usage vs. VM-level management focused on meeting the demands of applications run in each VM. ...
Trends indicate a rapid increase in the number of cores on chip, exhibiting various types of performance and functional asymmetries present in hardware to gain scalability with balanced power vs. performance requirements. This poses new challenges in platform resource management, which are further exacerbated by the need for runtime power budgeting and by the increased dynamics in workload behavior observed in consolidated datacenter and cloudcomputing systems. This paper considers the implications of these challenges for the virtualization layer of abstraction, which is the base layer for resource management in such heterogeneous multicore platforms. Specifically, while existing and upcoming management methods routinely leverage system-level information available to the hypervisor about current and global platform state, we argue that for future systems there will be an increased necessity for additional information about applications and their needs. This 'end-to-end' argument leads us to propose 'performance points' as a general interface between the virtualization system and higher layers like the guest operating systems that run application workloads. Building on concrete examples from past work on APIs with which applications can inform systems of phase or workload changes and conversely, with which systems can indicate to applications desired changes in power consumption, performance points are shown to be an effective way to better exploit asymmetries and gain the power/performance improvements promised by heterogeneous multicore systems.
... However, all of the approaches mentioned above mandate the use of some kind of specialised API within the application, and are not easily applied to legacy applications. The use of a specialised API is assumed by several authors proposing an Operating System support for multimedia and time-sensitive applications [Leslie et al. 1996; Jones et al. 1996; Krasic et al. 2009]. More similar to our approach is the work proposed by Steere et al. [Steere et al. 1999], who propose a reservation scheme implemented in the Linux kernel, and a feedback-based controller to adjust the scheduling parameters. ...
Multimedia applications are often executed on standard Personal Computers. The absence of established standards has hindered the adoption of real-time scheduling solutions in this class of applications. Developers have adopted a wide range of heuristic approaches to achieve an acceptable timing behaviour but the result is often unreliable. We propose a mechanism to extend the benefits of real-time scheduling to legacy applications based on the combination of two techniques: 1) a real-time monitor that observes and infers the activation period of the application, and 2) a feedback mechanism that adapts the scheduling parameters to improve its real-time performance.
... However, all of the approaches mentioned above mandate the use of some kind of specialised API within the application , and it is not easy to apply them to applications which have not been explicitly developed to use such APIs. The use of a specialised API is assumed by several authors proposing an operating system support for multimedia and timesensitive applications [13, 14, 17]. A piece of work that bears some resemblance with this paper is the one proposed by Steere et.al. ...
We present an approach for adaptive scheduling of soft realtime legacy applications (for which no timing information is exposed to the system). Our strategy is based on the combination of two techniques: 1) a real-time monitor that observes the sequence of events generated by the application to infer its activation period, 2) a feedback mechanism that adapts the scheduling parameters to ensure a timely execution of the application. By a thorough experimental evaluation of an implementation of our approach, we show its performance and its efficiency.
