Publications
Peer-reviewed journal and conference publications
2025
- HotCloudPerfIrisBench: An Open-Source Benchmark Suite for Video Processing Systems in CloudZhiqi Li, Ruiqi Yu, and Jianshu LiuIn Companion of the 16th ACM/SPEC International Conference on Performance Engineering, Toronto ON, Canada, 2025
Recent advances in generative text-to-video AI models (e.g., VideoPoet and Sora) have spurred a surge in video production, leading to an increased demand for video processing pipelines among various video service providers such as YouTube and TikTok. With the improvement of cloud computing, video processing systems are frequently updated and present both opportunities and challenges while optimizing the quality of service (QoS) and cloud resource utilization. However, research on evaluating the performance of video processing systems is limited. Besides the availability of video datasets and realistic workloads, the lack of an open-source benchmark system reflecting the characteristics of industrial video processing systems is a significant gap. To fill this gap, we develop IrisBench, an open-source benchmark suite for cloud video processing systems to facilitate research on performance analysis. Our benchmark suite includes three video services: video transcoding, video partitioning, and video object detection services. Our future work relies on using IrisBench to study the architectural implications of various cloud video processing systems in the cloud.
@inproceedings{10.1145/3680256.3721317, author = {Li, Zhiqi and Yu, Ruiqi and Liu, Jianshu}, title = {IrisBench: An Open-Source Benchmark Suite for Video Processing Systems in Cloud}, year = {2025}, isbn = {9798400711305}, publisher = {Association for Computing Machinery}, address = {New York, NY, USA}, url = {https://doi.org/10.1145/3680256.3721317}, doi = {10.1145/3680256.3721317}, booktitle = {Companion of the 16th ACM/SPEC International Conference on Performance Engineering}, pages = {167–173}, numpages = {7}, keywords = {benchmark, cloud computing, serverless, stream processing}, location = {Toronto ON, Canada}, series = {ICPE '25}, }
2024
- DSNGrunt Attack: Exploiting Execution Dependencies in MicroservicesXuhang Gu, Qingyang Wang, Jianshu Liu, and Jinpeng WeiIn 2024 54th Annual IEEE/IFIP International Conference on Dependable Systems and Networks (DSN), Brisbane, Australia, 2024
Loosely-coupled and lightweight microservices running in containers are likely to form complex execution dependencies inside the system. The execution dependency arises when two execution paths partially share component microservices, resulting in potential runtime blocking effects. In this paper, we present Grunt Attack - a novel low-volume DDoS attack that takes advantage of the execution dependencies of microservice applications. Grunt Attack utilizes legitimate HTTP requests to accurately profile the internal pairwise dependencies of all supported execution paths in the target system. By grouping and characterizing all the execution paths based on their pairwise dependencies, the Grunt attacker can target only a few execution paths to launch a low-volume DDoS attack that achieves large performance damage to the entire system. To increase the attack stealthiness, the Grunt attacker avoids creating a persistent bottleneck by alternating the target execution paths within their dependency group. We validate the effectiveness of Grunt attack through experiments of open-source microservices benchmark applications on real clouds (e.g., EC2, Azure) equipped with state-of-the-art IDS/IPS systems and live attack scenarios. Our results show that Grunt attack consumes less than 20% additional CPU resource of the target system while increasing its average response time by over 10x.
@inproceedings{10646949, author = {Gu, Xuhang and Wang, Qingyang and Liu, Jianshu and Wei, Jinpeng}, booktitle = {2024 54th Annual IEEE/IFIP International Conference on Dependable Systems and Networks (DSN)}, title = {Grunt Attack: Exploiting Execution Dependencies in Microservices}, year = {2024}, volume = {}, number = {}, pages = {115-128}, keywords = {Degradation;Runtime;Microservice architectures;Benchmark testing;Containers;Denial-of-service attack;HTTP;Microservices;DDoS attack;SLA violations}, doi = {10.1109/DSN58291.2024.00025}, location = {Brisbane, Australia} } - AsiaCCSSync-Millibottleneck Attack on Microservices Cloud ArchitectureXuhang Gu, Qingyang Wang, Qiben Yan, Jianshu Liu, and 1 more authorIn Proceedings of the 19th ACM Asia Conference on Computer and Communications Security, Singapore, Singapore, 2024
The modern web services landscape is characterized by numerous fine-grained, loosely coupled microservices with increasingly stringent low-latency requirements. However, this architecture also brings new performance vulnerabilities. In this paper, we introduce a novel low-volume application layer DDoS attack called the Sync-Millibottleneck (SyncM) attack, specifically targeting microservices. The goal of this attack is to cause a long-tail latency problem that violates the service-level agreement (SLA) while evading state-of-the-art DDoS detection/defense mechanisms. The SyncM attack exploits two unique features of microservices architecture: (1) the shared frontend gateway that directs user requests to mid-tier/backend microservices, and (2) the co-existence of multiple logically independent execution paths, each with its own bottleneck resource. By creating synchronized millibottlenecks (i.e., sub-second duration bottlenecks) on multiple independent execution paths, SyncM attack can cause the queuing effect in each execution path to be propagated and superimposed in the shared frontend gateway. As a result, SyncM triggers surprisingly high latency spikes in the system, even when all system resources are far from saturation, making it challenging to trace the cause of performance instability.To evaluate the practicality of the SyncM attack, we conduct extensive experiments on real cloud systems such as EC2 and Azure, which are equipped with state-of-the-art IDS/IPS systems. We also conduct a large-scale simulation using a production Alibaba trace to show the scalability of our attack. Our results demonstrate that the SyncM attack is highly effective, as it only consumes less than 15% of additional CPU resources of the target system while increasing its 95th percentile response time by more than 20 times.
@inproceedings{10.1145/3634737.3644991, author = {Gu, Xuhang and Wang, Qingyang and Yan, Qiben and Liu, Jianshu and Pu, Calton}, title = {Sync-Millibottleneck Attack on Microservices Cloud Architecture}, year = {2024}, isbn = {9798400704826}, publisher = {Association for Computing Machinery}, address = {New York, NY, USA}, url = {https://doi.org/10.1145/3634737.3644991}, doi = {10.1145/3634737.3644991}, booktitle = {Proceedings of the 19th ACM Asia Conference on Computer and Communications Security}, pages = {799–813}, numpages = {15}, keywords = {microservices, DDoS attack, long tail latency, SLA violations}, location = {Singapore, Singapore}, series = {ASIA CCS '24}, }
2023
- SoCCμConAdapter: Reinforcement Learning-based Fast Concurrency Adaptation for Microservices in CloudJianshu Liu, Shungeng Zhang, and Qingyang WangIn Proceedings of the 2023 ACM Symposium on Cloud Computing, Santa Cruz, CA, USA, 2023
Modern web-facing applications such as e-commerce comprise tens or hundreds of distributed and loosely coupled microservices that promise to facilitate high scalability. While hardware resource scaling approaches [28] have been proposed to address response time fluctuations in critical microservices, little attention has been given to the scaling of soft resources (e.g., threads or database connections), which control hardware resource concurrency. This paper demonstrates that optimal soft resource allocation for critical microservices significantly impacts overall system performance, particularly response time. This suggests the need for fast and intelligent runtime reallocation of soft resources as part of microservices scaling management. We introduce μConAdapter, an intelligent and efficient framework for managing concurrency adaptation. It quickly identifies optimal soft resource allocations for critical microservices and adjusts them to mitigate violations of service-level objectives (SLOs). μConAdapter utilizes fine-grained online monitoring metrics from both the system and application levels and a Deep Q-Network (DQN) to quickly and adaptively provide optimal concurrency settings for critical microservices. Using six realistic bursty workload traces and two representative microservices-based benchmarks (SockShop and SocialNetwork), our experimental results show that μConAdapter can effectively mitigate large response time fluctuation and reduce the tail latency at the 99th percentile by 3\texttimes on average when compared to the hardware-only scaling strategies like Kubernetes Autoscaling and FIRM [28], and by 1.6\texttimes to the state-of-the-art concurrency-aware system scaling strategy like ConScale [21].
@inproceedings{10.1145/3620678.3624980, author = {Liu, Jianshu and Zhang, Shungeng and Wang, Qingyang}, title = {μConAdapter: Reinforcement Learning-based Fast Concurrency Adaptation for Microservices in Cloud}, year = {2023}, isbn = {9798400703874}, publisher = {Association for Computing Machinery}, address = {New York, NY, USA}, url = {https://doi.org/10.1145/3620678.3624980}, doi = {10.1145/3620678.3624980}, booktitle = {Proceedings of the 2023 ACM Symposium on Cloud Computing}, pages = {427–442}, numpages = {16}, keywords = {Auto-scaling, Microservices, Scalability, Soft Resource}, location = {Santa Cruz, CA, USA}, series = {SoCC '23}, } - MiddlewareSora: A Latency Sensitive Approach for Microservice Soft Resource AdaptationJianshu Liu, Qingyang Wang, Shungeng Zhang, Liting Hu, and 1 more authorIn 24th ACM/IFIP International Middleware Conference, Bologna, Italy, 2023
In recognition of paper “Sora” presented during Middleware 2023.
Fast response time for modern web services that include numerous distributed and lightweight microservices becomes increasingly important due to its business impact. While hardware-only resource scaling approaches (e.g., FIRM [47] and PARSLO [40]) have been proposed to mitigate response time fluctuations on critical microservices, the re-adaptation of soft resources (e.g., threads or connections) that control the concurrency of hardware resource usage has been largely ignored. This paper shows that the soft resource adaptation of critical microservices has a significant impact on system scalability because either under- or over-allocation of soft resources can lead to inefficient usage of underlying hardware resources. We present Sora, an intelligent, fast soft resource adaptation management framework for quickly identifying and adjusting the optimal concurrency level of critical microservices to mitigate service-level objective (SLO) violations. Sora leverages online finegrained system metrics and the propagated deadline along the critical path of request execution to quickly and accurately provide optimal concurrency setting for critical microservices. Based on six real-world bursty workload traces and two representative microservices benchmarks (Sock Shop and Social Network), our experimental results show that Sora can effectively mitigate large response time fluctuations and reduce the 99th percentile latency by up to 2.5× compared to the hardware-only scaling strategy FIRM [47] and 1.5× to the state-of-the-art concurrency-aware system scaling strategy ConScale.
@inproceedings{liu2023sora, title = {Sora: A Latency Sensitive Approach for Microservice Soft Resource Adaptation}, author = {Liu, Jianshu and Wang, Qingyang and Zhang, Shungeng and Hu, Liting and Silva, Dilma Da}, booktitle = {24th ACM/IFIP International Middleware Conference}, year = {2023}, doi = {10.1145/3590140.3592851}, url = {https://dl.acm.org/doi/10.1145/3590140.3592851}, location = {Bologna, Italy} } - CICA BlackBox Approach to Profile Runtime Execution Dependencies in MicroservicesXuhang Gu, Jianshu Liu, and Qingyang WangIn 2023 IEEE 9th International Conference on Collaboration and Internet Computing (CIC), Atlanta, GA, USA, 2023
Loosely-coupled and lightweight microservices running in containers are likely to form complex execution dependencies inside the system. The execution dependency arises when two execution paths partially share component microservices, resulting in potential runtime performance interference. In this paper, we present a blackbox approach that utilizes legitimate HTTP requests to accurately profile the internal pairwise dependencies of all supported execution paths in the target microservices application. Concretely, we profile the pairwise dependency of two execution paths through performance interference analysis by sending bursts of two types of requests simultaneously. By characterizing and grouping all the execution paths based on their pairwise dependencies, the black box approach can derive a clear dependency graph(s) of the entire backend of the microservices application. We validate the effectiveness of the blackbox approach through experiments of open-source microservices benchmark applications running on real clouds (e.g., EC2, Azure).
@inproceedings{10429940, author = {Gu, Xuhang and Liu, Jianshu and Wang, Qingyang}, booktitle = {2023 IEEE 9th International Conference on Collaboration and Internet Computing (CIC)}, title = {A BlackBox Approach to Profile Runtime Execution Dependencies in Microservices}, year = {2023}, volume = {}, number = {}, pages = {116-120}, keywords = {Cloud computing;Runtime;Microservice architectures;Closed box;Interference;Production;Benchmark testing;Microservices;performance analysis;dependency}, doi = {10.1109/CIC58953.2023.00024}, location = {Atlanta, GA, USA} }
2022
- MiddlewareShadowSync: latency long tail caused by hidden synchronization in real-time LSM-tree based stream processing systemsShungeng Zhang, Qingyang Wang, Yasuhiko Kanemasa, Julius Michaelis, and 2 more authorsIn Proceedings of the 23rd ACM/IFIP International Middleware Conference, Quebec, QC, Canada, 2022
Mission-critical, real-time, continuous stream processing applications that interact with the real world have stringent latency requirements. For example, e-commerce websites like Amazon improve their marketing strategy by performing real-time advertising based on customers’ behavior, and latency long tail can cause significant revenue loss. Recent work [39] showed a positive correlation between latency long tail and variance in the execution time of synchronous invocation chains (critical paths) in microservices benchmarks. This paper shows that asynchronous, very short but intense resource demands (called millibottlenecks) outside of critical paths can also cause significant latency long tail.Using a traffic analysis stream processing application benchmark, we evaluated the impact of asynchronous workload bursts generated by a multi-layer data structure called LSM-tree (log-structured merge-tree) for continuous checkpointing. Outside of the critical path, LSM-tree relies on maintenance operations (e.g., flushing/compaction during a checkpoint) to reorganize LSM-tree in memory and on disk to keep data access latency short. Although asynchronous, such recurrent maintenance operations can cause frequent millibottlenecks, particularly when they overlap, a problem we call ShadowSync. For scheduling and statistical reasons, significant latency long tail can arise from ShadowSync caused by asynchronous recurrent operations. Our experimental results show that with typical settings of benchmark components such as RocksDB, ShadowSync can prolong request message latency by up to 2 seconds. We show effective mitigation methods can alleviate both scheduled and statistical ShadowSync reducing the latency long tail to less than 20% of the original at the 99.9th percentile.
@inproceedings{10.1145/3528535.3565251, author = {Zhang, Shungeng and Wang, Qingyang and Kanemasa, Yasuhiko and Michaelis, Julius and Liu, Jianshu and Pu, Calton}, title = {ShadowSync: latency long tail caused by hidden synchronization in real-time LSM-tree based stream processing systems}, year = {2022}, isbn = {9781450393409}, publisher = {Association for Computing Machinery}, address = {New York, NY, USA}, url = {https://doi.org/10.1145/3528535.3565251}, doi = {10.1145/3528535.3565251}, booktitle = {Proceedings of the 23rd ACM/IFIP International Middleware Conference}, pages = {281–294}, numpages = {14}, keywords = {performance instability, stream processing, synchronization}, location = {Quebec, QC, Canada}, series = {Middleware '22}, } - TPDSCoordinating Fast Concurrency Adapting With Autoscaling for SLO-Oriented Web ApplicationsJianshu Liu, Shungeng Zhang, Qingyang Wang, and Jinpeng WeiIEEE Transactions on Parallel and Distributed Systems, 2022
Cloud providers tend to support dynamic computing resources reallocation (e.g., Autoscaling) to handle the bursty workload for web applications (e.g., e-commerce) in the cloud environment. Nevertheless, we demonstrate that directly scaling a bottleneck server without quickly adjusting its soft resources (e.g., server threads and database connections) can cause significant response time fluctuations of the target web application. Since soft resources determine the request processing concurrency of each server in the system, simply scaling out/in the bottleneck service can unintentionally change the concurrency level of related services, inducing either under- or over-utilization of the critical hardware resource. In this paper, we propose the Scatter-Concurrency-Throughput (SCT) model, which can rapidly identify the near-optimal soft resource allocation of each server in the system using the measurement of each server’s real-time throughput and concurrency. Furthermore, we implement a Concurrency-aware autoScaling (ConScale) framework that integrates the SCT model to quickly reallocate the soft resources of the key servers in the system to best utilize the new hardware resource capacity after the system scaling. Based on extensive experimental comparisons with two widely used hardware-only scaling mechanisms for web applications: EC2-AutoScaling (VM-based autoscaler) and Kubernetes HPA (container-based autoscaler), we show that ConScale can successfully mitigate the response time fluctuations over the system scaling phase in both VM-based and container-based environments.
@article{9714008, author = {Liu, Jianshu and Zhang, Shungeng and Wang, Qingyang and Wei, Jinpeng}, journal = {IEEE Transactions on Parallel and Distributed Systems}, title = {Coordinating Fast Concurrency Adapting With Autoscaling for SLO-Oriented Web Applications}, year = {2022}, volume = {33}, number = {12}, pages = {3349-3362}, keywords = {Concurrent computing;Servers;Hardware;Throughput;Time factors;Resource management;Topology;Scalability;auto-scaling;soft resource;cloud-based applications}, doi = {10.1109/TPDS.2022.3151512}, }
2021
- TPS-ISAA Functional Model and Analysis of Next Generation Malware Attacks and DefensesCalton Pu, Qingyang Wang, Yasuhiko Kanemasa, Rodrigo Alves Lima, and 4 more authorsIn 2021 Third IEEE International Conference on Trust, Privacy and Security in Intelligent Systems and Applications (TPS-ISA), Atlanta, GA, USA, 2021
Recent ransomware attacks (e.g., Colonial and JBS) caused significant social and economic impact due to their ability to shut down entire businesses. A functional model divides next-generation malware (NG-malware) attacks into 3 stages: Penetration (to gain a foothold), Propagation (to gain full control of target system), and a variety of Exploitation methods. The functional model shows that many attack methods and tools can be flexibly combined to bypass implementation-specific defenses at each stage, with the most important defense battleground being the prevention of NG-malware gaining full control of target system. Given the potential for further evolution of MG-malware, e.g., obfuscation of lateral movement jobs to increase both the speed and stealth of Propagation, it is crucial for the defense to develop effective defenses to detect NG-malware Propagation before ceding full control. An experimental platform that enables detailed evaluation of new NG-malware attacks and defenses is an effective tool in the battle for full control.
@inproceedings{9750235, author = {Pu, Calton and Wang, Qingyang and Kanemasa, Yasuhiko and Alves Lima, Rodrigo and Kimball, Joshua and Zhang, Shungeng and Liu, Jianshu and Gu, Xuhang}, booktitle = {2021 Third IEEE International Conference on Trust, Privacy and Security in Intelligent Systems and Applications (TPS-ISA)}, title = {A Functional Model and Analysis of Next Generation Malware Attacks and Defenses}, year = {2021}, volume = {}, number = {}, pages = {197-206}, keywords = {Privacy;Detectors;Machine learning;Control systems;Ransomware;Security;Intelligent systems;malware;insider attack;ransomware;obfuscation;millibottleneck}, doi = {10.1109/TPSISA52974.2021.00023}, location = {Atlanta, GA, USA} }
2020
- MiddlewareDoubleFaceAD: A New Datastore Driver Architecture to Optimize Fanout Query PerformanceShungeng Zhang, Qingyang Wang, Yasuhiko Kanemasa, Jianshu Liu, and 1 more authorIn Proceedings of the 21st International Middleware Conference, Delft, Netherlands, 2020
The broad adoption of fanout queries on distributed datastores has made asynchronous event-driven datastore drivers a natural choice due to reduced multithreading overhead. However, through extensive experiments using the latest datastore drivers (e.g., MongoDB, HBase, DynamoDB) and YCSB benchmark, we show that an asynchronous datastore driver can cause unexpected performance degradation especially in fanout-query scenarios. For example, the default MongoDB asynchronous driver adopts the latest Java asynchronous I/O library, which uses a hidden on-demand JVM level thread pool to process fanout query responses, causing a surprising multithreading overhead when the query response size is large. A second instance is the traditional wisdom of modular design of an application server and the embedded asynchronous datastore driver can cause an im-balanced workload between the two components due to lack of coordination, incurring frequent unnecessary system calls. To address the revealed problems, we introduce DoubleFaceAD–a new asynchronous datastore driver architecture that integrates the management of both upstream and downstream workload traffic through a few shared reactor threads, with fanout-query-aware priority-based scheduling to reduce the overall query waiting time. Our experimental results on two representative application scenarios (YCSB and DBLP) show DoubleFaceAD outperforms all other types of datastore drivers up to 34% on throughput and 1.9\texttimes faster on 99th percentile response time.
@inproceedings{10.1145/3423211.3425684, author = {Zhang, Shungeng and Wang, Qingyang and Kanemasa, Yasuhiko and Liu, Jianshu and Pu, Calton}, title = {DoubleFaceAD: A New Datastore Driver Architecture to Optimize Fanout Query Performance}, year = {2020}, isbn = {9781450381536}, publisher = {Association for Computing Machinery}, address = {New York, NY, USA}, url = {https://doi.org/10.1145/3423211.3425684}, doi = {10.1145/3423211.3425684}, booktitle = {Proceedings of the 21st International Middleware Conference}, pages = {430–444}, numpages = {15}, keywords = {performance, fanout queries, distributed datastores, asynchronous}, location = {Delft, Netherlands}, series = {Middleware '20}, } - IPDPSMitigating Large Response Time Fluctuations through Fast Concurrency Adapting in CloudsJianshu Liu, Shungeng Zhang, Qingyang Wang, and Jinpeng WeiIn 2020 IEEE International Parallel and Distributed Processing Symposium (IPDPS), New Orleans, LA, USA, 2020
Dynamically reallocating computing resources to handle bursty workloads is a common practice for web applications (e.g., e-commerce) in clouds. However, our empirical analysis on a standard n-tier benchmark application (RUBBoS) shows that simply scaling an n-tier application by reallocating hardware resources without fast adapting soft resources (e.g., server threads, connections) may lead to large response time fluctuations. This is because soft resources control the workload concurrency of component servers in the system: adding or removing hardware resources such as Virtual Machines (VMs) can implicitly change the workload concurrency of dependent servers, causing either under- or over-utilization of the critical hardware resource in the system. To quickly identify the optimal soft resource allocation of each server in the system and stabilize response time fluctuation, we propose a novel Scatter-Concurrency-Throughput (SCT) model based on the monitoring of each server’s real-time concurrency and throughput. We then implement a Concurrency-aware system Scaling (ConScale) framework which integrates the SCT model to fast adapt the soft resource allocations of key servers during the system scaling process. Our experiments using six realistic bursty workload traces show that ConScale can effectively mitigate the response time fluctuations of the target web application compared to the state-of-the-art cloud scaling strategies such as EC2-AutoScaling.
@inproceedings{9139832, author = {Liu, Jianshu and Zhang, Shungeng and Wang, Qingyang and Wei, Jinpeng}, booktitle = {2020 IEEE International Parallel and Distributed Processing Symposium (IPDPS)}, title = {Mitigating Large Response Time Fluctuations through Fast Concurrency Adapting in Clouds}, year = {2020}, volume = {}, number = {}, pages = {368-377}, keywords = {Servers;Concurrent computing;Hardware;Throughput;Time factors;Resource management;Adaptation models;scalability;soft resources;web applications}, doi = {10.1109/IPDPS47924.2020.00046}, location = {New Orleans, LA, USA} }
2019
- ICDCSTail Amplification in n-Tier Systems: A Study of Transient Cross-Resource Contention AttacksShungeng Zhang, Huasong Shan, Qingyang Wang, Jianshu Liu, and 2 more authorsIn 2019 IEEE 39th International Conference on Distributed Computing Systems (ICDCS), Dallas, TX, USA, 2019
Fast response time becomes increasingly important for modern web applications (e.g., e-commerce) due to intense competitive pressure. In this paper, we present a new type of Denial of Service (DoS) Attacks in the cloud, MemCA, with the goal of causing performance uncertainty (the long-tail response time problem) of the target n-tier web application while keeping stealthy. MemCA exploits the sharing nature of public cloud computing platforms by co-locating the adversary VMs with the target VMs that host the target web application, and causing intermittent and short-lived cross-resource contentions on the target VMs. We show that these short-lived cross-resource contentions can cause transient performance interferences that lead to large response time fluctuations of the target web application, due to complex resource dependencies in the system. We further model the attack scenario in n-tier systems based on queuing network theory, and analyze cross-tier queue overflow and tail response time amplification under our attacks. Through extensive benchmark experiments in both private and public clouds (e.g., Amazon EC2), we confirm that MemCA can cause significant performance uncertainty of the target n-tier system while keeping stealthy. Specifically, we show that MemCA not only bypasses the cloud elastic scaling mechanisms, but also the state-of-the-art cloud performance interference detection mechanisms.
@inproceedings{8884816, author = {Zhang, Shungeng and Shan, Huasong and Wang, Qingyang and Liu, Jianshu and Yan, Qiben and Wei, Jinpeng}, booktitle = {2019 IEEE 39th International Conference on Distributed Computing Systems (ICDCS)}, title = {Tail Amplification in n-Tier Systems: A Study of Transient Cross-Resource Contention Attacks}, year = {2019}, volume = {}, number = {}, pages = {1527-1538}, keywords = {Cloud computing;Time factors;Interference;Bandwidth;System-on-chip;Random access memory;Monitoring;Performance uncertainty;web attack;millibottleneck;resource contention;n-tier systems}, doi = {10.1109/ICDCS.2019.00152}, location = {Dallas, TX, USA} }