PCatch: Automatically Detecting Performance Cascading Bugs in Cloud Systems
Cloud computing has overcome the most feared trait of all the rising computer centers, the fear of high energy production from digital devices. The major trait behind improving efficiency and effectiveness is the shift to cloud computing. The big cloud data centers use virtual machine software, high-density storage, tailored chips, ultrafast networking, and customized airflow systems- all to increase computing firepower with the least electricity.
An efficient along with cost-effective use of computing resources in the cloud is to make it Green Cloud computing. By reducing carbon emission and energy consumption in cloud computing data centers make a challenge and orient toward making all the data centers green. The study reveals that there are many energy-efficient frameworks for cloud computing and data centers that make cloud computing the Green cloud computing.
Distributed systems, such as cloud storage, data-parallel computing frameworks, and synchronization services, have become a key supporters for modern clouds.
Unfortunately, software-resource contention may cause a local slowdown to propagate to a different job or a critical system routine, such as the heartbeat routine, and eventually lead to severe slowdowns affecting multiple jobs and sometimes multiple physical nodes in the system.
The cascading nature of PC bugs makes the performance-failure diagnosis difficult — it requires global analysis to identify the slowness propagation chains and the slowdown root causes. PC bugs are often triggered by large workloads and end up with global performance problems, violating both scalability and performance-isolation expectations.
PCatch is a vital tool that can automatically predict PCbugs by analyzing system execution under small-scale workloads. PCatch contains three vital elements in predicting PCbugs. It uses a system of analysis that identifies code regions whose execution time can potentially increase according to the zise of its workload.
It adapts the traditional happens-before model to reason about software resource contention and performance dependency relationship; it uses dynamic tracking to identify whether the slowdown propagation is contained in one job or not.
- Workload and dynamic analysis: PCatch bug detection is carefully designed to be largely oblivious to the size of the workload and the timing of the bug-detection run.
- Scalability Analysis: PCatch tool, including cascading analysis, job-origin analysis, and loop scalability analysis, enables users to detect PCbugs under small workloads and regular non-bug-triggering timing.
- Future Analysis: PCatch is just a starting point in tackling performance cascading problems in distributed systems. Future prospects extends PCatch system to detect PC bugs along with fixing and leveraging PCatch bug reports and analysis techniques.
- Performance-dependence model: PCatch cascading analysis is tied with our may-HB and must-HB models. It may miss performance dependencies caused by semaphores, custom synchronizations, and resource contentions currently not covered by our must-HB and may-HB models, resulting in false negatives.
- Workload and dynamic analysis: PCatch would still inevitably suffer false negatives if some bug-related code is not executed during bug-detection runs (e.g., the loop sources, I/O operations inside a loop source, causal operations, resource contention operations, sinks), which is a long-standing testing coverage problem.
- Static analysis: PCatch scalability analysis intentionally focuses on common patterns of non-scalable loops to scale to analyzing large distributed systems, but it could miss truly non-scalable loops that are outside the local-loop and global loop, and hence lead to false negatives.
PROGRAML: GRAPH-BASED DEEP LEARNING FOR PROGRAM OPTIMIZATION AND ANALYSIS
Machine learning brings in vital pros for the improvment of the construction of optimization heuristics by replacing fragile and expensive hand-tuned heuristics with data-driven statistical modeling. The objective is achieved by machine learning systems capable of reasoning about program semantics.
A graph representation not only comprises of meaningful attention learning and a promulate information throughout the graph like typical compiler analyses. A message-passing graph neural network, in contrast, needs only to learn to pass a message forward in the case of an existing control-flow edge between two nodes, essentially learning an identity operation over control-flow edges and zero on others.
In this study, the limitation of the flow of information in the program using representations that do not encode the information is fulfilled by making the program’s control, data, and call dependencies a central part of the program’s representation and primary consideration when processing it. This is achieved by seeing the program as a graph, in which individual statements are connected to other statements through relational dependencies.
- Efficiency: While tuning heuristics by hand is expensive and slow to keep up with the pace of compiler and architecture advancements, machine learning offers tremendous benefits for automatically constructing heuristics that are both cheaper to develop and better performing than hand-crafted equivalents.
- Accuracy: A graph-based representation for programs is presented, from compiler IRs, that accurately captures the semantics of a program’s statements and the relations between them.
- Expressiveness: The approach is more expressive than prior sequence- or graph-based representations, while closely approximating the representations that are traditionally used within compilers.
- Re-usability-: PROGRAML is to provide a re-usable toolbox for representing and reasoning about programs in the future.
- Lack of Attention: PROGRAML is to provide attention to the challenges that machine learning methods face in the domain of programming languages
- Research prospects: Promising research avenues for downstream tasks to be enabled by the enriched program representation.