CLOUD COMPUTING UNIT 4

TOPIC1-POLICIES AND MECHANISM FOR RESOURCE MANAGEMENT:

1.Admission Control
Admission control is a method used by a system to decide if it should allow a new task or user
to enter or use resources. Think of it like a busy restaurant where a waiter decides whether to
let more customers in based on how many seats are available. In the same way, a computer
system uses admission control to check if it has enough resources (like memory, CPU power, or
bandwidth) before accepting new requests. If the system doesn’t have enough resources, it
might block the request to prevent it from becoming overloaded, which could make it slow or
crash. This ensures that the system can handle tasks efficiently without being overwhelmed.

2. Load Balancing
Load balancing is a technique used to distribute work or traffic evenly across multiple servers or
systems. Imagine you have a team of workers, and you want to make sure no one is doing too
much while others are doing nothing. In computing, load balancing is like that. It ensures that all
the servers or computers share the work equally so that no single server gets too overloaded,
and performance doesn’t slow down. For example, if a website gets a lot of traffic, load
balancing makes sure that the requests are spread out to different servers, which helps the
website run smoothly without crashing. It’s especially important in cloud computing where
thousands of users might access the same service at once.

3. Capacity Allocation
Capacity allocation is about how to assign enough resources (like memory, storage, and
processing power) to different tasks or applications in a system. Think of it like giving out slices
of pizza to a group of friends, where some are hungrier than others. Some tasks (like video
streaming or gaming) need more resources to run smoothly, while others (like sending emails or
chatting) need less. Capacity allocation helps make sure that each task gets the right amount of
resources, so everything runs efficiently. If a system allocates too many resources to one task
and not enough to others, it can cause delays, crashes, or a poor user experience.

4. Energy Optimization
Energy optimization is all about using power efficiently to reduce energy waste in computer
systems, especially in data centers where a lot of servers are running at once. Imagine leaving
lights on in rooms you're not using — it wastes electricity. Similarly, in a data center, energy
optimization involves making sure that servers are only running when needed. For example, if
traffic is low, the system might shut down or put some servers into low-energy mode to save
electricity. This can help save money on power bills and reduce the environmental impact of the
system. It's also about ensuring that systems run in the most efficient way possible to avoid
wasting energy.

5. Quality of Service (QoS) Guarantees

Quality of Service (QoS) guarantees are promises made by a system to provide a certain level
of performance for specific tasks. Imagine when you order food from a restaurant, and they
guarantee delivery within 30 minutes. In computing, QoS guarantees ensure that important
tasks get the resources they need to work well. For example, a video streaming app might
guarantee smooth video playback without buffering, while a simple app like a calculator might
not need such a high level of service. QoS ensures that critical tasks get the necessary
resources (like bandwidth or processing power) so they run without delays, especially when the
system is under heavy load or when multiple tasks are competing for resources.
STABILITY OF A TWO LEVEL RESOURCE ARCHITECTURE:

The two-level resource allocation architecture in cloud systems uses two controllers: one for the
cloud service provider (cloud platform) and another for the applications running on the cloud.
The main goal of this architecture is to efficiently manage cloud resources such as processing
power, memory, and storage, ensuring that applications get the necessary resources for optimal
performance. The system is designed to manage the workload (the amount of work or tasks)
and the policies that control how resources are allocated, such as admission control, capacity
allocation, load balancing, energy optimization, and Quality of Service (QoS) guarantees.

In this system, sensors are used to monitor performance, and controllers adjust resources
based on the feedback from these sensors. The system follows a feedback loop, where the
controllers make changes to the resources based on real-time data to maintain stability and
avoid system overload. The system’s output is the resource allocation to the applications,
ensuring they receive the resources they need to function efficiently.

However, there are potential causes of instability within the system. These include:

1. Delay in system response: The system may not react quickly enough to changes, causing
delays in resource adjustments.
2.Granularity of control: If small adjustments lead to large changes in resource allocation, it can
destabilize the system.
3.Oscillations: If the system overreacts to changes, it may cause repetitive adjustments, which
could result in instability.

To manage these issues, two types of Policies are commonly used:

1}Threshold-based policies: These set specific performance limits (e.g., memory or CPU
usage). When the performance reaches these limits, resources are adjusted. These policies are
simple but require careful setting of thresholds to avoid instability if the workload fluctuates too
much.

2}Sequential decision policies: These involve making small, step-by-step adjustments based on
the system’s current performance, ensuring gradual changes.

The system’s controllers need to adjust resources gradually and wait for the application to
stabilize before making further changes. If too many changes are made too quickly, it could
trigger more adjustments, leading to instability. In conclusion, careful monitoring, gradual
adjustments, and maintaining a steady rhythm of control actions are essential to ensure the
smooth operation and stability of the cloud resource management system.
DIAGRAM ss
COORDINATION OF SPECIALIZED AUTONOMIC PERFORMANCE MANAGERS:

In modern cloud systems, managing the balance between energy consumption and
performance is crucial. This is done through a technique called Dynamic Voltage Scaling (DVS),
which helps save energy by adjusting the CPU frequency and voltage. The key idea is that
reducing the CPU's frequency can save energy, but it may also affect the system's performance.
The challenge is to find the right balance, ensuring good performance while saving energy.

How It Works:
- The CPU frequency(the speed at which instructions are processed) is controlled by a power
manager, which adjusts it several times per second.
- The performance manager controls how well the system performs and ensures that response
time (how fast the system responds to requests) meets the required targets.

Utility Function:
To balance energy consumption and performance, a utility function is used. This function takes
into account both response time (R) and power consumption (P). The idea is to maximize a joint
utility, which is a combination of these two factors, with a formula like this:

U(R, P) = \frac{U(R)}{P}

Where:
- (U(R)) is the utility based on response time.
- (P) is the power used.

By optimizing this utility function, we can adjust the system to achieve the best balance between
power consumption and performance.

Power and Performance Management:

- A power manager adjusts the system’s power consumption, setting the power cap(the
maximum power allowed). This is done based on the current workload intensity (like how many
clients or tasks are running).
- The performance manager uses the settings from the power manager (like CPU frequency) to
ensure that the application performs well according to Service Level Agreements (SLAs).

The two managers work together but do not directly negotiate; instead, they follow preset rules
based on the utility function. This allows the system to maintain optimal performance while
ensuring energy efficiency.

Experiment Results:
Three different experiments were conducted to test the system:
1. No power management: This is when the system operates without any power-saving
measures.
2. Determining response time and power consumption: This experiment showed that both
response time and power consumption depend on the power cap (maximum power allowed)
and the number of clients using the system.
3. Using reinforcement learning models: This helped derive the optimal power cap based on
workload intensity.

From these experiments, it was concluded that:

- Low load: The system performs well with low response time.
- Medium to high load: The response time improves rapidly when the power cap is increased,
but power consumption also increases significantly.

Conclusion:
The system successfully coordinates power management and performance, ensuring both
optimal performance and energy savings. By adjusting the CPU frequency and power
consumption dynamically, it can handle varying workloads efficiently, making it suitable for cloud
computing environments where both performance and energy efficiency are crucial.
RESOURCE BUNDLING:

In cloud computing, resources like CPU power, memory, and storage are often grouped together
in bundles. This is because most applications need a specific combination of these resources to
run smoothly. By bundling resources, cloud providers can offer better performance and make it
easier for users to get what they need without having to request each resource separately.
COMBINATORIAL AUCTION:
To distribute these bundles, a special type of auction called a combinatorial auction is used. In
this auction, users don’t just bid on one resource they bid on a combination of several
resources together. This method is efficient because it considers the needs of users who require
multiple resources at the same time. For example, some users might need both extra CPU and
memory, so they bid for a bundle containing both.
Price and allocation auction:
A strategy where the auction results are price and allocation where the user send the bid on
combination of resources and tell the price they are willing to pay the users are u=[1,2,3,...U]
and the resources are r=[1,2,3,...R]
Now the user u send bid bu=[q,q1,q2,..] where the q are the bundles of resources and tehy tell
the prices they are willing then the system will send the final price as a vector p=[p1,p2,..] with
the resources x=[x1,x2,,..] and x[p] represents the price paid by the user for the bundle of
resources
ALGORTIHM:
1}computationally tracable
2}scale well
3}be objective
4}be fair
5}indicate clearly what are the prices for the resources
6}indicate clearly the relationship b/w supply and demand in the system.

One popular method for these auctions is called the Ascending Simultaneous Clock Auction
(ASCA). In this process, users place their bids for the bundles they want, and the auctioneer
adjusts the prices based on the demand. If there is high demand for certain bundles, the prices
increase, and users may have to rethink their bids. This continues until a balance between
demand and supply is reached.

The auction algorithm aims to be fair and efficient. It divides users into winners and losers based
on their bids. Winners get the resources they bid for, while losers do not receive the bundle
because their bids were lower. The goal is to make sure that all winners pay a similar price,
which prevents any unfair advantage. This kind of pricing strategy helps maintain trust and
fairness in the auction process.
Code for ascending simultaneous combinatorial auction:
Set t=0;p[0]=p^
Loop
Collect bids xn(t)=Gu(p(t))
Calculate the excess demand z(t)=summationXu(t)
If z(t)<0 then
Break
Else
Update prices p(t+1)=p(t)+g(tx(t),p(t))
t=t+1
End if
End loop
SCHEDULING ALGORITHMS FOR COMPUTING CLOUD:
FAIR QUEUING:
Matter
Process
Algorithm
Diagram
Source-pdf and chatgpt

START TIME FAIR QUEUING:

Pdf with example
FEED BACK CONTROL:
Sure! Here’s a simpler explanation of *feedback control based on dynamic thresholds*:

Feedback Control:
Feedback control is a system that adjusts itself based on how well it is performing. It looks at its
current state (e.g., how much CPU is being used) and then makes changes if things are not
going as planned.

What Are Dynamic Thresholds:

A *threshold* is a limit or a boundary, like a target goal. A *dynamic threshold* means this limit
can change over time, based on how the system is performing. For example, if the system is
under heavy load, the threshold might increase to handle more work; if it's underused, the
threshold might decrease.

How Does Feedback Control with Dynamic Thresholds Work:

1. *Monitor the System*: The system keeps track of key factors like CPU usage, the number of
pending tasks, or the amount of memory being used.

2. *Set Initial Thresholds: You decide what the ideal system state is. For example, you might
want CPU usage to stay around 80%. This would be your **initial threshold*.

3. *Compare the Current State to the Threshold*: The system constantly checks if the actual
state (e.g., current CPU usage) is higher or lower than the dynamic threshold. If the CPU usage
goes beyond the threshold, it means the system is overloaded.

4. *Adjust the Threshold*: If the system detects that it is overloaded (e.g., CPU is at 90%), it
might increase the threshold to allow more tasks to be processed. Or if the CPU is underutilized
(e.g., only 50% used), it might lower the threshold to save resources.

5. *Take Action Based on the Comparison*: Depending on whether the system is over or under
the threshold, it will take action, such as:
- *Allocating more resources* (e.g., adding more CPU power or memory).
- *Prioritizing important tasks*.
- *Delaying or stopping some tasks* to reduce the load.

Example:
Let’s say you have a cloud server running several applications, and you want to control how
many tasks get processed based on the server's load.

- *System state to monitor*: CPU usage.

- *Initial threshold*: Target CPU usage is 80%.
- If the CPU usage goes *above 80%*, it means the server is getting overloaded, so the system
might:
- *Increase the threshold* to 85% (allow more tasks) or
 - *Stop non-essential tasks* to reduce the load.
- If the CPU usage goes *below 60%*, the system might decide:
- *Lower the threshold* to 70% (to keep the server active) or
- *Start new tasks* to make better use of resources.