886 research outputs found
On the use of code mobility mechanisms in real-time systems
Applications with soft real-time requirements can benefit from code mobility mechanisms, as long as those mechanisms
support the timing and Quality of Service requirements of applications. In this paper, a generic model for code mobility
mechanisms is presented. The proposed model gives system designers the necessary tools to perform a statistical timing
analysis on the execution of the mobility mechanisms that can be used to determine the impact of code mobility in
distributed real-time applications
Time-bounded distributed QoS-aware service configuration in heterogeneous cooperative environments
The scarcity and diversity of resources among the devices of heterogeneous computing
environments may affect their ability to perform services with specific Quality
of Service constraints, particularly in dynamic distributed environments where the
characteristics of the computational load cannot always be predicted in advance.
Our work addresses this problem by allowing resource constrained devices to cooperate
with more powerful neighbour nodes, opportunistically taking advantage
of global distributed resources and processing power. Rather than assuming that
the dynamic configuration of this cooperative service executes until it computes
its optimal output, the paper proposes an anytime approach that has the ability
to tradeoff deliberation time for the quality of the solution. Extensive simulations
demonstrate that the proposed anytime algorithms are able to quickly find a good
initial solution and effectively optimise the rate at which the quality of the current
solution improves at each iteration, with an overhead that can be considered
negligible
Iterative refinement approach for QOS-Aware service configuration
In heterogeneous environments, diversity of resources among the devices
may affect their ability to perform services with specific QoS constraints,
and drive peers to group themselves in a coalition for cooperative service
execution. The dynamic selection of peers should be influenced
by user’s QoS requirements as well as local computation availability,
tailoring provided service to user’s specific needs. However, complex
dynamic real-time scenarios may prevent the possibility of computing
optimal service configurations before execution. An iterative refinement
approach with the ability to trade off deliberation time for the quality
of the solution is proposed. We state the importance of quickly finding
a good initial solution and propose heuristic evaluation functions that
optimise the rate at which the quality of the current solution improves
as the algorithms have more time to run
The capacity exchange protocol
This paper proposes a new strategy to integrate shared resources and precedence constraints among real-time tasks, assuming
no precise information on critical sections and computation times is available. The concept of bandwidth inheritance
is combined with a capacity sharing and stealing mechanism to efficiently exchange bandwidth among tasks to minimise the
degree of deviation from the ideal system’s behaviour caused by inter-application blocking.
The proposed Capacity Exchange Protocol (CXP) is simpler than other proposed solutions for sharing resources in open
real-time systems since it does not attempt to return the inherited capacity in the same exact amount to blocked servers. This
loss of optimality is worth the reduced complexity as the protocol’s behaviour nevertheless tends to be fair and outperforms
the previous solutions in highly dynamic scenarios as demonstrated by extensive simulations.
A formal analysis of CXP is presented and the conditions under which it is possible to guarantee hard real-time tasks are
discussed
A capacity sharing and stealing strategy for open real-time systems
This paper focuses on the scheduling of tasks with hard and soft real-time constraints
in open and dynamic real-time systems. It starts by presenting a capacity
sharing and stealing (CSS) strategy that supports the coexistence of guaranteed
and non-guaranteed bandwidth servers to efficiently handle soft-tasks’ overloads by
making additional capacity available from two sources: (i) reclaiming unused reserved
capacity when jobs complete in less than their budgeted execution time and
(ii) stealing reserved capacity from inactive non-isolated servers used to schedule
best-effort jobs.
CSS is then combined with the concept of bandwidth inheritance to efficiently
exchange reserved bandwidth among sets of inter-dependent tasks which share resources
and exhibit precedence constraints, assuming no previous information on
critical sections and computation times is available. The proposed Capacity Exchange
Protocol (CXP) has a better performance and a lower overhead when compared
against other available solutions and introduces a novel approach to integrate
precedence constraints among tasks of open real-time systems
Handling QoS dependencies in distributed cooperative real-time systems
Due to the growing complexity and adaptability requirements of real-time embedded systems, which often exhibit
unrestricted inter-dependencies among supported services and user-imposed quality constraints, it is increasingly
difficult to optimise the level of service of a dynamic task set within an useful and bounded time. This is even more
difficult when intending to benefit from the full potential of an open distributed cooperating environment, where service
characteristics are not known beforehand. This paper proposes an iterative refinement approach for a service’s QoS
configuration taking into account services’ inter-dependencies and quality constraints, and trading off the achieved
solution’s quality for the cost of computation. Extensive simulations demonstrate that the proposed anytime algorithm is
able to quickly find a good initial solution and effectively optimises the rate at which the quality of the current solution
improves as the algorithm is given more time to run. The added benefits of the proposed approach clearly surpass its
reducedoverhead
Optimising and adapting the QoS of a dynamic set of inter-dependent tasks
Due to the growing complexity and adaptability requirements of real-time systems, which often exhibit
unrestricted Quality of Service (QoS) inter-dependencies among supported services and user-imposed
quality constraints, it is increasingly difficult to optimise the level of service of a dynamic task set within
an useful and bounded time. This is even more difficult when intending to benefit from the full potential
of an open distributed cooperating environment, where service characteristics are not known beforehand
and tasks may be inter-dependent.
This paper focuses on optimising a dynamic local set of inter-dependent tasks that can be executed
at varying levels of QoS to achieve an efficient resource usage that is constantly adapted to the specific
constraints of devices and users, nature of executing tasks and dynamically changing system conditions.
Extensive simulations demonstrate that the proposed anytime algorithms are able to quickly find a good
initial solution and effectively optimise the rate at which the quality of the current solution improves
as the algorithms are given more time to run, with a minimum overhead when compared against their
traditional versions
Capacity sharing and stealing in serverbased real-time systems
A dynamic scheduler that supports the coexistence of guaranteed and non-guaranteed bandwidth servers is proposed.
Overloads are handled by an efficient reclaiming of residual capacities originated by early completions as well as by allowing
reserved capacity stealing of non-guaranteed bandwidth servers. The proposed dynamic budget accounting mechanism
ensures that at a particular time the currently executing server is using a residual capacity, its own capacity or is stealing
some reserved capacity, eliminating the need of additional server states or unbounded queues. The server to which the
budget accounting is going to be performed is dynamically determined at the time instant when a capacity is needed. This
paper describes and evaluates the proposed scheduling algorithm, showing that it can efficiently reduce the mean tardiness
of periodic jobs. The achieved results become even more significant when tasks’ computation times have a large variance
Building adaptable, QoS-aware dependable embedded systems
Most of today’s embedded systems are required to work
in dynamic environments, where the characteristics of the
computational load cannot always be predicted in advance.
Furthermore, resource needs are usually data dependent
and vary over time. Resource constrained devices may need
to cooperate with neighbour nodes in order to fulfil those requirements
and handle stringent non-functional constraints.
This paper describes a framework that facilitates the distribution
of resource intensive services across a community of
nodes, forming temporary coalitions for a cooperative QoSaware
execution. The increasing need to tailor provided
service to each application’s specific needs determines the
dynamic selection of peers to form such a coalition. The
system is able to react to load variations, degrading its performance
in a controlled fashion if needed. Isolation between
different services is achieved by guaranteeing a minimal
service quality to accepted services and by an efficient
overload control that considers the challenges and opportunities
of dynamic distributed embedded systems
Dynamic QoS-Aware coalition formation
Users of wireless devices increasingly demand access to multimedia
content with speci c quality of service requirements. Users might
tolerate di erent levels of service, or could be satis ed with di erent
quality combinations choices. However, multimedia processing introduces
heavy resource requirements on the client side.
Our work tries to address the growing demand on resources and performance
requirements, by allowing wireless nodes to cooperate with
each other to meet resource allocation requests and handle stringent
constraints, opportunistically taking advantage of the local ad-hoc network
that is created spontaneously, as nodes move in range of each
other, forming a temporary coalition for service execution. Coalition
formation is necessary when a single node cannot execute a speci c service,
but it may also be bene cial when groups perform more e ciently
when compared to a single s node performance
- …