Utilitybased Selection of Resources on Computational Grids Vinicius

Utility-based Selection of Resources on Computational Grids Vinicius Petrucci, Orlando Loques, Alexandre Sztajnberg Instituto de Computação Universidade Federal Fluminense (UFF) vpetrucci, loques@ic. uff. br Instituto de Matemática e Estatística Universidade do Estado do Rio de Janeiro (UERJ) alexszt@uerj. br

Key Points CR-RIO is an architecture-based approach to specify, deploy and manage applications with non-functional requirements (or system qualities) Grids are being used as generic platforms for sharing any type of resource in network Utility theory helps make trade-offs where multiple (sometimes conflicting) objectives must be considered to select the best resource in an operating scenario

CR-RIO Approach Contractual Reflective-Reconfigurable Interconnectable Objects Adopts software architecture as a conceptual abstraction for modelling complex software systems and then for deployment and evolution Describes and formalizes the dynamic non-functional requirements using architectural contracts Provides an infrastructure to deploy and manage the application based on the contracts (Continuously) monitor the resources and adapt the application to current resource availability

Contract Language in a nutshell Categories describe resource properties Profiles quantify the category properties and represent constraints to architectural components and/or interactions among them Services describe allowed operating conditions or possible configurations regarding the application’s architecture Negotiation defines rules to guide the selection of the specific service to be deployed possible transitions between services Client Terminal Contract

Grid The Grid technology focus on sharing resources to reach high computational capacity Now, the Grid is being used as generic platform for sharing any type of resource in network commonly used in scientific applications to solve largescale computational problems increasingly being used in multi-user applications, such as games and video conference The next step in this computing infrastructure is a shift from a closed user group system to a Ubiquitous Computing environment a grid system must integrate heterogeneous resources with varying quality and availability

Autonomic Computing x Grids Highly dynamic and unpredictable environment Benefits of geographically dispersed computing requirements Adaptability and fault tolerance Dynamically changing user needs Resource variability local resources (ex. : CPU, memory) communication resources (ex. : bandwidth, latency) Resource discovery software components, devices and services

Autonomic Computing The ultimate aim is to automate human tasks in system management to achieve high-level stakeholder objectives One common approach is to capture and represent human expertise in a computer-executable form When more than one dimension must be considered, representing choice and trade-offs becomes impractical In short, programmatic or rule-based approach is insufficient for expressing the necessary adaptation expertise emulating trade-off decisions in the presence of multiples objectives

Utility Functions Utility function is a mathematical formulation that returns a measure of utility-value given an environment state Utility is an ordinal (i. e. ordering or ranking) concept For example, if U(x) = 0. 6 and U(y) = 0. 2 then x is strictly preferred to y. However, x is not necessarily “three times better” than y Utility functions allow expressing high-level preferences for an application, regarding resource attributes, in a compact and systematic way

Utility-based Model We describe a state as a vector of attributes (measured or predefined) A utility function maps each possible state of a system or component to a real scalar value on a common scale Actions represent the utilityvalue of transitioning the system The action that maximizes overall utility is taken States and actions a 1 current state S a 2 possible state S 1 possible state S 2 a 3 possible state S 3 S = <attr 1, . . . , attr n>

Video Conference Reflectors Problem: in a given Grid domain, with a previously established reflector configuration, a client X wants do join the service ref. UFF ref. UERJ Client X ref. LMPD

Video Conference Reflectors Problem: which reflector to use? ref. UFF ref. UERJ ? Client X ref. LMPD

Video Conference Reflectors Problem: the client wants to maximize the benefits selecting the “best” Reflector to connect to, e. g. , regarding delay and bandwidth attributes ref. UFF ref. UERJ Client X ref. LMPD

Video Conference Reflectors Solution: apply an utility function, which specifies the user’s preferences regarding each property, and selects the most useful reflector ref. UFF ref. UERJ Client X ref. LMPD

User Preferences Resource characteristics and properties that can be monitored are defined Category { delay: decreasing numeric ms; bandwidth: increasing numeric Kbps; } Transport; An utility class is defined based on the class and category properties Utility { delay: pref(Transport. delay) weight 0. 6; bandwidth: pref(Transport. bandwidth) weight 0. 4; } util. Refl; The preference function, pref, normalizes the monitored variables and returns a real value between [0, 1] the weight operator defines importance of attributes

Contract for a Client Terminal Selection Function prototype @ref = select(Resource. Class, Util. Class); Contract contract { service { (. . . ) link term to @ref = select*(Reflector, refl. Util); } HQTerm; service { (. . . ) } LQTerm; negotiation { (. . . ) } } video. Conf; Periodically checks if the current selected component is still the best choice Contract Language

Selection Example Reflector Class = {ref. UFF, ref. UERJ, ref. LMPD} Monitoring Snapshot: ref. UFF = {delay: 63 ms; bandwidth: 578 kps} ref. UERJ = {delay: 126 ms; bandwidth: 926 kbps} ref. LMPD = {delay: 27 ms; bandwidth: 414 kbps} Preference Calculation: pref(ref. UFF) = {delay: 0. 64; bandwidth: 0. 32} pref(ref. UERJ) = {delay: 0. 00; bandwidth: 1. 00} pref(ref. LMPD) = {delay: 1. 00; bandwidth: 0. 00}

Selection Example Overall utility calculation: U(ref. UFF) = (0. 6 * 0. 64) + (0. 4 * 0. 32) = 0. 51 U(ref. UERJ) = (0. 6 * 0. 00) + (0. 4 * 1. 00) = 0. 40 U(ref. LMPD) = (0. 6 * 1. 00) + (0. 4 * 0. 00) = 0. 60 Selection Process: ref. UFF 0. 51 select 0. 40 ref. UERJ 0. 60 ref. LMPD

Dynamic Reconfiguration Environment Change: ref. UERJ = {delay: 48 ms; bandwidth: 926 kbps} Preference re-calculation: pref(ref. UFF) = {delay: 0. 00; bandwidth: 0. 32} pref(ref. UERJ) = {delay: 0. 42; bandwidth: 1. 00} pref(ref. LMPD) = {delay: 1. 00; bandwidth: 0. 00} Overall utility re-calculation: U(ref. UFF) = (0. 6 * 0. 00) + (0. 4 * 0. 32) = 0. 13 U(ref. UERJ) = (0. 6 * 0. 42) + (0. 4 * 1. 00) = 0. 65 U(ref. LMPD) = (0. 6 * 1. 00) + (0. 4 * 0. 00) = 0. 60 A new reflector is selected => ref. UERJ

Infrastructure Resource Discovery q Queries a resource repository and the Context Service in a given domain q Accepts a list of profiles Resource Discovery q. Returns a list of components Context Service of a given class that meets the profiles Resource List Query Resources Context Service Selector Contract Manager Configurator Contract Manager q Interprets the contracts, selects a service to be negotiated q Commands the Contractors to verify if the profiles are valid q Monitors a (set of) resource Contractor

Infrastructure Resource Discovery Context Service Selector q Selects the best resource given Query Resources q a component class Resource List best resource q A utility function Selector Profiles + utility function + resource class Contract Manager Configurator Contractor

Infrastructure Resource Discovery Query Resources Context Service Resource List best resource Profiles + utility function + resource class Contract Selector Profiles Contract Manager Contractor Validation / Violation Configurator Contractor q Gets local resource demands (profiles) form the CM q Manages and mediates the monitoring process

Infrastructure Contract Manager Resource Discovery Context Service q Commands the Configurator to deploy the architectural components Query Resources or Resource List q Selects another service to negotiate according to the policy specified best resource Profiles + utility function + resource class Contract Selector Profiles Contractor Contract Manager Validation / Violation Effect configuration Configurator Contractor q Validations and validations of the profiles Configurator q Effectuates (re)configurations are notified to the CM

Infrastructure Selector (select*) Resource Discovery Context Service q Continuously queries the Resource Discovery and computes the utility function q Notifies the Contract manager if a even better utility value is found Query Resources Resource List Notify +best resouce Profiles + utility function + resource class Contract Selector Profiles Contract Manager Validation / Violation Effect configuration Configurator Contractor

Final Remarks Grid as a candidate for provisioning computational services to applications in ubiquitous computing environments Utility-based selection mechanism allows handling complex-decision cases, catering for the balance of multiple (many times conflicting) objectives that depend on the combination of several variables of the environment Our approach can also be applied on the configuration of services the reflector overlay network topology and component selection

Future Steps Prototype implementation and results CR-RIO framework Globus services, NWS, Remos Disruption on reconfigurations notion of cost of change associated with swapping a component Learning services machine learning techniques a learned function is employed for future automation