- Open Access
Discrete control for ensuring consistency between multiple autonomic managers
© Gueye et al.; licensee Springer. 2013
- Received: 25 February 2013
- Accepted: 21 September 2013
- Published: 31 October 2013
The increasing complexity of computer systems has led to the automation of administration functions, in the form of autonomic managers. Today many autonomic managers are available but they mostly address a specific administration aspect which makes necessary their coexistence for a complete autonomic system management. However, coordinating them is necessary for proper and effective global administration. Such coordination can be considered as a problem of synchronization and logical control of managers actions. We therefore investigate the use of reactive models with events and states, and discrete control techniques to solve this problem. This paper presents an application of the latter approach for coordinating autonomic managers addressing resource optimization, in the perspective of green computing. The managers control server provisioning (self-sizing manager) and CPU frequency (Dvfs manager), and the coordination controller controls the managers actions so as to avoid incoherent management decisions. The coordination controller is designed using synchronous programming and Discrete controller synthesis (DCS) which are well-suited for the design of reactive systems. Experimental results are presented to evaluate the efficacy of the approach.
- Minimum Threshold
- Resource Optimization
- Coordination Policy
- Maximum Threshold
- Discrete Control
Computing systems have become more and more complex and harder to manage manually. Their architecture is mostly distributed involving several hardware and software components operating in a dynamic heterogeneous environment. Manual management of such systems can be time-consuming, expensive and error-prone. Autonomic computing  proposes a solution for the management issues consisting in automating the management functions in the form of an autonomic manager. An autonomic manager continuously monitors the managed system so as to detect any change in the system state that is in contrast to its objectives. When it detects such a change, it applies administration operations to lead the system to a state in which its objectives are satisfied. An autonomic manager is generally implemented in a closed loop, which can be inspired by techniques from control theory, continuous as well as discrete. Today many autonomic managers are available but they mostly address a specific administration aspect which makes necessary their coexistence for a complete autonomic system management. However the coexistence of several managers has to be coordinated to avoid incoherent and conflicting management decisions. Implementing manually such a coordination can be tedious, difficult to test and validate, and maintain.
This paper proposes an approach for coordinating multiple autonomic managers based on the discrete control approach. This provides high level programming languages for formal specification of a control system, and tools for automating the verification and validation of properties, and Discrete Controller Synthesis (DCS) for the synthesis of the control logic allowing to guarantee the properties, and code generation. Formal descriptions and proofs of correction of the techniques and tools used are presented in  and the theories and mathematical models in . The benefit of this approach is the automatic generation of the coordination controller instead of manually programming it in which case it could be complex, tedious and error-prone.
To put our approach into practice, we consider the coordination of two autonomic managers addressing the resource optimization of a system. One addresses the resource optimization within a machine (e.g., Dynamic Voltage/Frequency Scaling (DVFS)) while the other addresses the resource optimization within a replication-based system (e.g., server provisioning (self-sizing)). These managers act on different management levels, but their actions are complementary to improve resource optimization when coordinated, hence reducing the energy consumption of the managed system.
In the following, we present in section 'Autonomic managers for resource optimization’ two autonomic managers, self-sizing and Dvfs. We details in section 'Synchronous programming and discrete controller synthesis’ the principles of BZR, a synchronous programming language allowing modelling a system through automata and integrating DCS within its compiler. We detail in section 'Discrete control for coordinating self-sizing and Dvfs managers’ the design of a coordination controller for the two managers and show how it is integrated within a management system in section 'Implementation’. We show evaluation of the coordinated execution with our approach in section 'Experimentation’ and discuss related work in section 'Related work’. Finally, in section 'Conclusion and future work’, we conclude the paper and outline directions for future work.
This section presents two autonomic managers dealing with resource optimization. Their management decisions consist to reduce the resource allocated to the managed system while preserving good performance. They act at different management levels but their management actions are complementary to improve energy optimization through resource optimization when coordinated.
Server provisioning manager: Self-Sizing
This manager, inspired from , addresses the management of the degree of replication of a replicated-based system where each replicated server handles a part of the workload. It dynamically adapts the number of active replicated servers depending on the load of the machines hosting the replicated servers. The load of the machines is measured through the load of their CPU.
CPU-frequency manager: Dvfs
This manager, inspired from , targets a single machine management. Its role is to dynamically adapt the CPU-frequency of the machine depending on its CPU load.
The coexistence of both self-sizing and Dvfs managers can improve resource optimization. While using the self-sizing manager to optimize the number of active machines allocated to a replication-based system, Dvfs managers can be deployed on each active machine to perform local optimization by adjusting the CPU frequency. However their coexistence has to be coordinated to avoid incoherent management decisions. Indeed when each machine hosting a replicated server is equipped with a Dvfs manager, their CPU-frequency might not be maximal all the time. The Dvfs managers can lower the frequency of the CPU of the machines which makes the latter work slower. In higher frequency a CPU can handle more instructions per time unit than in lower Frequency. A workload which can overload a CPU in lower frequency can possibly be supported by the CPU in higher frequency. So when self-sizing detects an overload in lower CPU frequency, the adding operation it performs can be unnecessary if increasing the CPU frequency of the active machines before the adding operation is sufficient to support the workload. More when an overload occurs in lower frequency and is detected by self-sizing and Dvfs, the adding operation and the CPU increase operations performed by the managers can cause a decrease of the CPU utilization under the minimum threshold leading to removal and CPU decrease operations. When an underload occurs in higher frequency, the removal operations and CPU decrease operations performed by the managers can cause an increase of the CPU utilization over the maximum threshold leading to adding and CPU increase operations.
A strategy to achieve an efficient resource optimization and avoid incoherent operations could be to delay as long as possible adding a new replicated server when the machines hosting the active servers are not in their maximum CPU frequency. Indeed the evaluation of an overload by self-sizing is relevant only in higher CPU frequency in which case the CPU frequency can no more be increased. This can be stated as follows:
Ignoring overload of the machines hosting the replicated servers — if these machines are not in their maximum CPU frequency.
This allows to add a new replicated server only when the active ones are in maximum CPU frequency and become overloaded.
Synchronous programming allows to model the dynamics (functional and/or non-functional aspects) of a system as an automaton. A system composed of several sub-systems can be modelled via a composition of automata, where each single automaton models the dynamics of each specific sub-system. Hence, the composition models the state of the system as a whole.
With some controllable transitions in the automata, Discrete Controller Synthesis (DCS) tools  can compute a controller that restrains the set of reachable states (i.e., all possible behaviours) to those satisfying a control objective (e.g., a coordination policy).
In this Section, we first briefly introduce the basics of the synchronous language Heptagon. We then describe the main features of BZR, that extends Heptagon with a new construct for expressing behavioural contracts . BZR is the language we use for the synthesis of a coordination controller.
Automata and data-flow nodes
The Heptagon language allows the programming of reactive systems by means of mixed synchronous data-flow equations and automata with parallel and hierarchical composition . The basic behaviour is that of the synchronous data-flow languages family : at each reaction step, values of the input flows are used, as well as local and memory values, in order to compute the values of the output flows for that step, and memories for the next step. Inside nodes (i.e., block of codes defining an automaton or a composition of automata), these computations are specified as a system of equations defining, for each output and local, the value of the flow in terms of an expression on other flows and memories.
The compilation of an Heptagon program produces executable code in target languages such as C or Java, in the form of an initialization procedure reset, and a step procedure implementing the transition function of the resulting automaton. step takes incoming values of input flows gathered in the environment, computes the next state on internal variables, and returns values of the output flows. It is called at relevant instants from the infrastructure where the program is used.
Contracts and control in BZR
 propose BZRa that extends Heptagon with a new construct for expressing behavioural contracts. Its compilation involves discrete controller synthesis . DCS can be described as a formal operation on automata : given an automaton representing all possible behaviours of a system, its variables are partitioned into controllable and uncontrollable variables. For a given control objective (e.g., staying permanently inside a subset of states, considered “good”), the DCS algorithm automatically computes, for each state and value of the uncontrollables, the constraint on controllable variables so that all remaining behaviours satisfy the objective. This constraint is the least necessary, inhibiting the minimum possible behaviours, therefore it is called maximally permissive. Formalisms and algorithms are related to model-checking techniques for state space exploration. They are described elsewhere by  and .
Concretely, the BZR language permits the declaration, using the with statement, of controllable variables, the value of which being not defined by the programmer. These free variables can be used in the program to describe choices between several transitions. They are then defined, in the final executable program, by the controller computed by DCS, according to the expression given in the enforce statement. A possibility exists, not used here, to take into account some knowledge about the environment in an assume statement; observers can be used to have objective like: always having a task t1 between t2 and t3”. BZR compilation invokes a DCS tool, and inserts the synthesized controller in the generated executable code. The latter has the same structure as above: reset and step procedures.
Figure 4 shows an example of contract coordinating two instances of the delayable node of Figure 3. The twotasks node has a with part declaring controllable variables c1 and c2. The enforce part asserts the property to be enforced by DCS. Here, we want to ensure that the two tasks running in parallel will not be both active at the same time: not (a1and a2). The controllable variables c1 and c2 will be used by the computed controller to block some requests, leading automata of tasks to the Wait state whenever the other task is in its Active state. Observe that the constraint produced by DCS can have several solutions: the BZR compiler generates deterministic executable code by favouring, for each controllable variable, value true over false, in the order of declaration in the with statement.
This section presents the design of a coordination controller for the self-sizing and Dvfs managers. We first describe the automata modelling the self-sizing and Dvfs managers, then we describe how the coordination controller is designed from these models. The self-sizing is modelled with some control point allowing the control of its operations. In this work, the Dvfs actions are not controlled, we model the global states of the set of Dvfs which are necessary for controlling the self-sizing operations. Indeed the management actions of each Dvfs depend mainly on the load its managed machine receives, which affects the CPU utilization.
Modelling the self-sizing manager
Variables of the automaton modelling the self-sizing behaviours
Upsizing operations are suspended.
An overload occurs in the system.
An underload occurs in the system.
The minimum number of replicas is reached
The maximum number of replicas is reached.
The completion of an upsizing operation.
The manager is waiting for the completion of an upsizing operation.
The manager is launching an upsizingoperation. Its value depends on the value of delay and overload.
The manager is launching the downsizing operation. Its value depends on the value of underload.
Variables of the automaton modelling the control of self-sizing
The upsizing operations must be suspended.
The manager has suspended the launch of upsizing operations.
Modelling the global states of the set of Dvfs
Variables of the automaton modelling the global states of the set of Dvfs
Corresponds to the conjunction of all max.
Corresponds to the conjunction of all min.
All Dvfs manager are in themaximum CPU-frequency.
All Dvfs manager are in theminimum CPU-frequency.
Designing the coordination controller for self-sizing and Dvfs
To achieve the coordination strategy, we formally define an invariant. The invariant is expressed via the outputs of the automata. It is specified as a contract to be enforced at compilation time.
The strategy consists in preventing the self-sizing manager from adding a new replicated server when the machines hosting the current active servers are not in maximum CPU frequency. This means that the adding operations are inhibited when the Dvfs managers can increase the CPU frequency of their managed machines. To this end, the invariant is defined as follows:
i n v a r i a n t= (max_freq and not delay) or (not max_freq and delay)
At compilation, the BZR compiler will synthesize a control logic capable of enforcing the coordination policy in the composition by acting on the controllable variable c which is an input of the automaton in Figure 6. The composition of the automata and the computed control logic is generated in a target language (i.e., in Java for this work), which will constitute the coordination controller for the managers within the managed system. This coordination policy is very simple but allows to perform the complete experiment including implementation as shown in next section.
This section shows how the generated program from BZR compiler is integrated into the management system. This consists in connecting the inputs of the automata to the corresponding events and the outputs of the automata to the corresponding commands or operations.
Connecting the automata
The automata model an aspect of the dynamics of the self-sizing and Dvfs. Their inputs correspond to the events that trigger transitions between the states in the dynamics (e.g., overload for self-sizing and maximum CPU frequency reached for Dvfs). Their outputs reflect the current state in which the automata are and possibly the operations which should be processed (e.g., add server).
The automaton shown in Figure 7 takes the state of the sef of Dvfs represented by the inputs maximum and minimum. The input maximum (respectively minimum) being true corresponds to the state where the set of Dvfs reaches the maximum CPU frequency (respectively the minimum CPU frequency). The automaton in Figure 5 models the dynamics of the decision making module of the self-sizing and its control. The input overload (resp. underload) is the event that triggers upsizing (resp. downsizing) if max_node (resp. min_node) is false.overload and underload are the result of the evaluation of the CPU_Avg while max_node and min_node are the result of the execution of the management operations upsizing and downwsizing. The triggering of upsizing (resp. downsizing) is represented by the output add_node (resp. remove_node) being true. The automaton in Figure 6 models the control of the decision making module. It has one input (i.e., c) which is controllable. The latter is managed by the synthesized control logic through DCS and the output (delay) of the automaton is used to control the value of the input delay in the automaton in Figure 5 in order to control transitions leading to the adding state when necessary.
Integration of the generated code for coordinating managers
The compilation of the BZR program returns a set of Java classes corresponding to the composition of the automata presented above with the computed control logic. A main Java class allows to interact with the program. This class has two methods: reset and step. The reset method allows to initialize the program (i.e., initialize all automata and the generated controller) and the step method allows to compute transitions (i.e., transition in the automata). The step method takes arguments corresponding to the inputs of the automata and returns outputs corresponding to outputs of the automata. A loop has to be defined to call the step with the appropriate inputs and to manage the outputs referring to commands such as preventing upsizing operations of the Self-sizing manager. We implement a loop that receives events from sensors, calls the step method with required inputs and transmits the outputs of the step method to managers.
In this paper we only focus on the integration of a controller obtained through the Discrete control techniques for the coordination of autonomic managers. The purpose is to show that the latter controller react properly regarding the coordination policy although the system considered is small.
In the following we calibrate the thresholds of the managers in order for them to react properly individually at runtime. Then we present executions, to evaluate the behaviours of the synthesized controller.
Calibrating the managers thresholds
This section details how the Maximum Threshold and the Minimum Threshold for both self-sizing and Dvfs managers are determined. We perform heuristic experimentations to determine these thresholds. For both managers, the Maximum Threshold can be statically fixed while the Minimum Threshold can be dynamically adapted.
Determining the maximum threshold (T max ) for self-sizing and Dvfs
The CPU load is 100 percent means that the CPU is fully utilized. This causes delay on the execution of instructions and the degradation of the performance of the machine. So it is better to consider a maximum threshold less than 100. We choose arbitrary 90 as T max . At 90 percent, a machine becomes overloaded but it executes instructions in an optimal period of time. This allows to perform operations for monitoring (i.e., CPU load) and reconfiguring (i.e., increase of the CPU frequency) sufficiently fast to avoid performance degradation. The Maximum Threshold (T m a x ) for self-sizing as well as for Dvfs is fixed to 90 percent.
Determining the minimum threshold (T min ) for self-Sizing and Dvfs
We use different workloads following the same profile (a ramp-up phase followed by a constant phase), to observe the impact of the management operations of the managers on the CPU utilization. The management operations are performed manually once the workload is constant and stable to evaluate the factor by which the CPU utilization varies. The difference between the workload is the amount of requests injected. This allows to determine if the factor is the same for each workload. This allows to deduct an equation for calculating the Minimum Threshold based on the Maximum Threshold, and the number of active replicated servers for self-sizing.
Minimum threshold (T m a x ) for self-sizing
C is a margin. It denotes the difference between the maximum value of T min and the acceptable value of T min sufficiently high for detecting underload and sufficiently far from T max to avoid oscillations of the CPU utilization between the maximum threshold and the minimum threshold which possibly trigger unnecessary reconfiguration operations. In our experimentations, we consider C=0. In case of two machines, we have: .
As shown in Figures 12, the CPU load does not decrease by half when one server was added and Figures 13, the CPU load does not double when one server was removed. This equation, T min =[ f r a c T max 2 ], is enough to avoid side effects. So there is no risk of oscillations.
Determining the value of C–
To avoid oscillation when the number of servers becomes large a maximum value for T min can be fixed. This avoid T min to be close to T max . In this case the maximum value of T min is used whenever the computed value of T min is higher than the latter.
Minimum threshold (T m i n ) for Dvfs
In our platform, the machines hosting replicated server have two CPU frequency levels, 800Mhz and 1.2Ghz. A workload that overloads the machine in frequency 800Mhz could possibly be supported when increasing the frequency up to 1.2Ghz. Theoretically, in frequency 1.2Ghz, the machine performs 1.5 times more instructions than in frequency 800Mhz. This corresponds to the theoretical factor of decrease of the CPU utilization.
Coordination controller evaluation
This section presents the evaluation of our approach. We apply our approach for coordinating the self-sizing and Dvfs managers for the management of a replicated-based system. We inject different workload profiles. Each workload profile is defined by two phases, a first phase that consists of a ramp-up load about three minutes then a second phase that consists of a constant the load after the ramp-up phase. For each workload profile, we performed two executions, one without coordinating managers and another one by coordinating managers execution. At each experimentation, each machine hosting an active Tomcat server starts with its minimum CPU frequency, the local Dvfs adjusts it on the fly. Initially, one Tomcat server is started. The second Tomcat server was either added or removed automatically by the self-sizing manager depending on the workload. The executions takes 20 minutes. After this duration, we stopped sending requests. In this paper, we present three workload profiles Workload1 (4750 requests/sec), Workload2 (5000 requests/sec) and Workload3 (5542 requests/sec). Workload1 and Workload2 are supportable by one Tomcat server at max CPU frequency. Workload3 necessitates two Tomcat servers for treatment.
Concerning energy control, many works addressed energy management on datacenters. Some of these researches are based on (i) hardware with voltage and frequency control (e.g., DVFS ), (ii) resource allocation: Reducing power consumption by reducing the clock frequency of the processor has been widely studied [5, 12], Flautner et al.  explored a software managed dynamic voltage scaling policy that sets CPU speed on a task basis rather than by time intervals.  proposes a power budget guided job scheduling policy that maximizes overall job performance for a given power budget. Many works such as [4, 15–18] focused on dynamic resource provisioning in response to dynamic workload changes. These techniques monitor workloads or other SLA (Service Level Agreement) metrics experienced by a server and adjust the instantaneous resources available to the server. Depending on the granularity of the server (single or replicated), the dynamically provisioned resources can be a whole machine in the case of replicated servers. Energy efficiency is achieved using a workload-aware, just-right dynamic provisioning mechanism and the ability to power down subsystems of a host system that are not required.
While these works are relevant, they did not address the problem of coordinating multiple energy managers. Our work is complementary since it can be used to build a system that includes more that one of the previous approaches. Few works have also investigated manager coordination for energy efficiency. Kumar  proposes vManage, a coordination approach that loosely couples platform and virtualization management to improve energy savings and QoS while reducing VM migrations. Kephart  addresses the coordination of multiple autonomic managers for power/performance trade-offs based on a utility function in a non-virtualized environment. Nathuji  proposes VirtualPower to control the coordination among virtual machines to reduce the power consumption. These works involve coordination between control loops, but these loops are applied to the managed applications. However, these work propose adhoc specific solutions that have to be implemented by hand. If new managers have to be added in the system the whole coordination manager need to be redesigned. Also, the design of the coordination infrastructure becomes complex if the number of co-existing autonomic managers grows. Instead, we propose an approach for coordinating several managers based on control techniques. The latter provide high level programming languages and discrete controller synthesis techniques for the automated synthesis of the controller capable to ensure the coordination.  propose an approach for synchronizing multiple Control-Loops to ensure stability of their behaviours based on a binary linear program. It introduces an Actions Synchronization Module (ASM) that selects, whenever a set of actions needs to be synchronized, the best subset allowed to execute which maximizes a set of QoS metrics. Our approach is similar to the latters since it allows, among a set of actions, a subset to execute. However, contrary to a binary linear program, in our approach the decision is based on the invariants on Control-Loops behaviours.  address stability in autonomic networking. It identifies three issues that must be considered to ensure stability which are interactions, conflicts resolution and Time scaling of control-loops. The Game theory approach which provides analytical tools is proposed for studying the efficient collaboration of control-loops. An architectural design is proposed based on the GANA architecture which provides features for structuring control-loops and ensuring their synchronization to achieve stability through Action Synchronization Functions presented in . This approach is based on optimization, typically of QoS metrics, by means of Game theory, whereas our approach proposes an enforcement of logical properties upon states or sequences of actions.
In contrast with , which relies on formal specification to derive a formal model that is guaranteed to be equivalent to the requirements, our work can be related to the applications of control theory to autonomic or adaptive computing systems . In particular, Discrete Event Systems in the form of Petri nets models and control have been used for deadlock avoidance problems . Compared to these works, we rely on synchronous programming and discrete controller synthesis. Once an autonomic manager is modelled as automata, inserting this autonomic manager with other pre-existing just require to update the coordination invariants. The new coordination manager is automatically generated from the managers models and the coordination invariants.
In contrast with , which addresses the management of datacenters based on thermal awareness with external sensing infrastructure for energy and cooling efficiency, the work, presented in this paper, focuses on coordinating multiple workload-aware managers to ensure an energy efficiency.
One major challenge in system administration is coordinating multiple autonomic managers for correct and coherent system management. In this paper we presented an approach for coordinating multiple autonomic managers in a consistent manner. This approach, based on synchronous programming and Discrete Controller Synthesis, has the advantage of generating by construction the correct controller to enable the coordination of managers.
The advantages of this approach are following: (1) High-level of programming, (2) Automated generation/synthesis of the controller and (3) correctness of the controller, (4) that is maximally permissive. The resulting controlled automaton is correct in the sense that the formal technique of DCS has been applied to guarantee, in a form of verification, that it can have only behaviours that satisfy the property to be enforced. It is also maximally permissive in the sense that all behaviours that satisfy the property are kept possible by the controller.
We tested this approach for coordinating two autonomic managers addressing resource optimization: self-Sizing, which manages the degree of replication for a system based on a load balancer scheme, and Dvfs, which manages the level of CPU frequency for a single node. In this case, the coordination policy was to allow self-Sizing to add new node only when all Dvfs modules cannot apply increase operations at all in response to the increasing load the system receives. The experimentations shows that the generated controller ensures a correct coordination with respect of our coordination policy. However, we used thresholds as base for managers decision. These thresholds are not sufficient to capture only overload and underload since there is a probability for a peak of load not to correspond to an overload.
For future work, we plan to improve the model with the use of continuous control to take into account quantitative aspects and avoid oscillations and reduce decision errors. We will improve our use of discrete control by considering more advanced control techniques with cost functions and optimal control. We plan to evaluate this approach for large scale coordination with more complex coordination policies and several managers, combining both self-optimization and self-regulation frequency managers with self-repair manager that heal fail-stop clustered multi-tiers system.
This research is supported by ANR INFRA (ANR-11-INFR 012 11) under a grant for the project ctrl-Green.
- Kephart JO, Chess DM: The vision of autonomic computing. Computer 2003, 36: 41–50. http://dx.doi.org/10.1109/MC.2003.1160055 10.1109/MC.2003.1160055View ArticleGoogle Scholar
- Marchand H, Gaudin B: Supervisory Control Problems of Hierarchical Finite State Machines. In 41th IEEE Conference on Decision and Control. Las Vegas, USA; 2002:1199–1204.Google Scholar
- Delaval G, Marchand H, Rutten É: Contracts for modular discrete controller synthesis. In Proceedings of the ACM SIGPLAN/SIGBED 2010 Conference on Languages, Compilers, and Tools for Embedded Systems. ACM, New York, NY, USA: LCTES ’10; 2010:57–66.View ArticleGoogle Scholar
- Chase JS, Anderson DC, Thakar PN, Vahdat AM, Doyle RP: Managing energy and server resources in hosting centers. In Proceedings of the eighteenth ACM symposium on Operating systems principles. ACM, New York, NY, USA: SOSP ’01; 2001:103–116. http://doi.acm.org/10.1145/502034.502045View ArticleGoogle Scholar
- Weiser M, Welch B, Demers A, Shenker S: Scheduling for reduced CPU energy. In Proceedings of the 1st USENIX conference on Operating Systems Design and Implementation, OSDI ’94. Berkeley, CA, USA: USENIX Association; 1994. http://dl.acm.org/citation.cfm?id=1267638.1267640Google Scholar
- Besnard L, Marchand H, Rutten E: The Sigali tool box environment. Workshop on Discrete Event Systems, WODES’06 (Tool Paper). (MI, USA): Ann-Arbor; 2006. http://www.irisa.fr/vertecs/Logiciels/sigali.htmlGoogle Scholar
- Colaço JL, Pagano B, Pouzet M: A conservative extension of synchronous data-flow with state machines. In Proceedings of the 5th ACM International Conference on, Conference on Embedded Software. New York, NY, USA,: EMSOFT ’05, ACM; 2005:173–182.Google Scholar
- Benveniste A, Caspi P, Edwards S, Halbwachs N, Le Guernic P, de Simone R: The synchronous languages 12 years later. Proc IEEE 2003, 91: 64–83. 10.1109/JPROC.2002.805826View ArticleGoogle Scholar
- Ramadge P, Wonham W: Supervisory control of a class of discrete event processes. SIAM J. on Control Optimization 1987, 25: 206–230. 10.1137/0325013MathSciNetView ArticleMATHGoogle Scholar
- Cassandras CG, Lafortune S: Introduction to discrete event systems. Secaucus, NJ, USA: Springer-Verlag New, York, Inc.; 2006.MATHGoogle Scholar
- Fox A, Gribble SD, Chawathe Y, Brewer EA, Gauthier P: Cluster-based scalable network services. In Proceedings of the sixteenth ACM symposium on Operating systems principles. New York, NY, USA: SOSP ’97, ACM; 1997:78–91. http://doi.acm.org/10.1145/268998.266662View ArticleGoogle Scholar
- Govil K, Chan E, Wasserman H: Comparing algorithm for dynamic speed-setting of a low-power CPU. In Proceedings of the 1st annual international conference on Mobile computing and networking. New York, NY, USA: MobiCom ’95, ACM; 1995:13–25. http://doi.acm.org/10.1145/215530.215546Google Scholar
- Flautner K, Reinhardt S, Mudge T: Automatic performance setting for dynamic voltage scaling. Wirel Netw 2002, 8: 507–520. http://dx.doi.org/10.1023/A:1016546330128 10.1023/A:1016546330128View ArticleMATHGoogle Scholar
- Etinski M, Corbalan J, Labarta J, Valero M: Optimizing job performance under a given power constraint in HPC centers. In Proceedings of the International Conference on Green Computing. Washington, DC, USA: GREENCOMP ’10, IEEE Computer Society; 2010:257–267. http://dx.doi.org/10.1109/GREENCOMP.2010.5598303View ArticleGoogle Scholar
- Lin M, Wierman A, Andrew LLH, Thereska E: Dynamic right-sizing for power-proportional data centers. In Proc. IEEE INFOCOM. Shanghai, China; 2011:1098–1106. http://www.caia.swin.edu.au/cv/landrew/pubs/RightSizing.pdfGoogle Scholar
- Bouchenak S, De Palma N, Hagimont D, Taton C: Autonomic Management of Clustered Applications. Cluster Computing, 2006 IEEE International Conference on 2006, 1–11.View ArticleGoogle Scholar
- Pinheiro E, Bianchini R, Carrera EV, Heath T: Load balancing and unbalancing for power and performance in cluster-based Systems. Proceedings of the Workshop on Compilers and Operating Systems for Low Power (COLP’01) 2001. http://research.ac.upc.es/pact01/colp/paper04.pdfGoogle Scholar
- Rodero I, Jaramillo J, Quiroz A, Parashar M, Guim F, Poole S: Energy-efficient application-aware online provisioning for virtualized clouds and data centers. In Proceedings of the International Conference on Green Computing. Washington, DC, USA: GREENCOMP ’10, IEEE Computer Society; 2010:31–45. http://dx.doi.org/10.1109/GREENCOMP.2010.5598283View ArticleGoogle Scholar
- Kumar S, Talwar V, Kumar V, Ranganathan P, Schwan K: vManage: loosely coupled platform and virtualization management in data centers. In Proceedings of the 6th international conference on Autonomic computing. New York, NY, USA: ICAC ’09,ACM; 2009:127–136. http://doi.acm.org/10.1145/1555228.1555262Google Scholar
- Das R, Kephart JO, Lefurgy C, Tesauro G, Levine DW, Chan H: Autonomic multi-agent management of power and performance in data centers. In Proceedings of the 7th international joint conference on Autonomous agents and multiagent systems: industrial track. AAMAS ’08, Richland SC; 2008:107–114. http://dl.acm.org/citation.cfm?id=1402795.1402816Google Scholar
- Nathuji R, Schwan K: VirtualPower: coordinated power management in virtualized enterprise systems. In Proceedings of twenty-first ACM SIGOPS symposium on Operating systems principles. New York, NY, USA: SOSP ’07, ACM; 2007:265–278. http://doi.acm.org/10.1145/1294261.1294287View ArticleGoogle Scholar
- Tcholtchev N, Chaparadza R, Prakash A: Addressing Stability of Control-Loops in the Context of the GANA Architecture: Synchronization of Actions and Policies. In Proceedings of the 4th IFIP TC 6 International Workshop on Self-Organizing Systems, IWSOS ’09. Berlin, Heidelberg: Springer-Verlag; 2009:262–268. http://dx.doi.org/10.1007/978–3-642–10865–5_28Google Scholar
- Kastrinogiannis T, Tcholtchev N, Prakash A, Chaparadza R, Kaldanis V, Coskun H, Papavassiliou S: Addressing stability in future autonomic networking. In MONAMI, Lecture Notes of the Institute for Computer Sciences, Social Informatics and Telecommunications Engineering. Edited by: Pentikousis K, Calvo RA, García-Arranz M, Papavassiliou S. Springer; 2010:50–61. http://dblp.uni-trier.de/db/conf/monami/monami2010.html#KastrinogiannisTPCKCP10Google Scholar
- Sterritt R, Hinchey M, Rash J, Truszkowski W, Rouff C, Gracanin D: Towards Formal Specification and Generation of Autonomic Policies. Embedded and Ubiquitous Computing 2005, 1245–1254. http://dx.doi.org/10.1007/11596042_126Google Scholar
- Hellerstein JL, Diao Y, Parekh S, Tilbury DM: Feedback Control of Computing Systems. John Wiley & Sons; 2004.View ArticleGoogle Scholar
- Wang Y, Kelly T, Lafortune S: Discrete control for safe execution of IT automation workflows. In Proceedings of the 2nd ACM SIGOPS/EuroSys European Conference on Computer Systems 2007. New, York, NY, USA: EuroSys ’07, ACM; 2007:305–314. http://doi.acm.org/10.1145/1272996.1273028View ArticleGoogle Scholar
- Viswanathan H, Lee E, Pompili D: Self-organizing sensing infrastructure for autonomic management of green datacenters. Ieee Netw 2011, 25(4):34–40. http://ieeexplore.ieee.org/lpdocs/epic03/wrapper.htm?arnumber=5958006View ArticleGoogle Scholar
This article is published under license to BioMed Central Ltd. This is an Open Access article distributed under the terms of the Creative Commons Attribution License (http://creativecommons.org/licenses/by/2.0), which permits unrestricted use, distribution, and reproduction in any medium, provided the original work is properly cited.