Search

The resources required to service cloud computing applications are dynamic and fluctuate over time in response to variations in the volume of incoming requests. Proactive autoscaling techniques attempt to predict future resource demand and assign resources before the request. Thus, establishing accurate prediction methods optimizes resource allocation and avoids service-level agreement violations (SLA). Most existing methods for predicting resource usage in cloud computing rely on univariate time series prediction models. These models consider only a single resource usage metric, make future predictions based on historical data for the target metric, and provide predictions for a single step ahead. This paper provides a hybrid method for multivariate time series workload prediction of host machines in cloud data centers that predicts the workload for the next few steps. First, a statistical analysis is used to construct the training set. Then, a convolutional neural network (CNN) is employed to extract the hidden spatial features between all correlated variables. Finally, the spatial features extracted by the CNN are fed into a GRU network optimized with the attention mechanism in order to extract the temporal correlation features. Two experiments employing Google cluster data were conducted to evaluate the proposed method. Experimental results reveal that our method improves prediction accuracy by 2% to 28% compared to baseline methods and previous research. [ABSTRACT FROM AUTHOR]

Cloud service providers can operate several execution instances on a single physical server using virtualization technology, which improves resource utilization. In recent years, container-based virtualization has been developed as a remarkably lightweight alternative to virtual machines. Containers consume less memory than virtual machines, enabling faster setup and portability. Cloud-based applications require dynamic resource allocation in response to fluctuations in the number of incoming requests. Most articles on proactive autoscaling in cloud computing have shortcomings in two ways. 1) During feature extraction, the temporal patterns of the data are ignored, and the historical sequences are assigned equal weight. 2) Existing research omits cool down time (CDT) from the planning phase. 3) Scaling operations can be performed at any time depending only on the current input workload, resulting in a large number of contradicting scaling actions. In response to the above shortcomings, this paper presents a proactive autoscaling method for web applications in Kubernetes using an attention-based gated recurrent unit (GRU) encoder-decoder (K-AGRUED), which predicts the resource usage of several future steps based on CDT. The results demonstrate that the proposed method reduces prediction error by 2–25% compared to state of the art methods. Our approach significantly reduces scaling operations and under-provisioning compared to the standard horizontal pod autoscaler (HPA) of Kubernetes and two previous studies. The K-AGRUED increases the scaling speedup by a factor of up to five in a real environment. [ABSTRACT FROM AUTHOR]

The present study aimed to explore how tweeters' opinions about open access publishing and its main features evolved over time. Using a quantitative content analysis method through an opinion mining approach, it explored a sample of English tweets on open access posted from 2007 to December 2019. The main terms related to open access were first identified through reviewing the related literature and were then categorized into five features including "costs & funding", "impact", "models", "publishing & publications", and "quality & quality control". The terms were composed in the form of search formulae. The searches on Twitter led to retrieving 629,123 tweets. A cleansing process was carried out to remove duplicates, non-English, and low-relevant tweets. The final sample reached 80,629 tweets. The tweets were then tagged with the five features. The KNIME data mining tool and SentiStrength were used respectively for processing the tweets' contents and calculating their opinion scores. According to the results, the open-access-related tweets have been growing based on a sigmoidal model. They were mostly neutral and opinion tweets were far lower in number. The tweets in different polarities have been increasing based on a power-law model, with the negative tweets experiencing a disproportionately higher increase. The positive and negative opinions have remained almost stable in strength, with the former being stronger. The results were almost in line with the previous surveys confirming the co-existence of the positive and negative attitudes about open access. However, the social sphere has been gradually becoming more negative. As attitudes are likely to go viral on social networks, and thereby affect users' perceptions and behaviors, the results call for devising appropriate measures to empower the movement and to find solutions for the problems and concerns leading to the negative opinions. [ABSTRACT FROM AUTHOR]

During recent years, big data explosion and the increase in main memory capacity, on the one hand, and the need for faster data processing, on the other hand, have caused the development of various in-memory processing tools to manage and analyze data. Engaging the speed of the main memory and advantaging data locality, these tools can process a large amount of data with high performance. Apache Ignite, as a distributed in-memory platform, can process massive volumes of data in parallel. Currently, this platform is CPU-based and does not utilize the GPU's processing resources. To address this concern, we introduce Ignite-GPU that uses the GPU's massively parallel processing power. Ignite-GPU handles a number of challenges in integrating GPUs into Ignite and utilizes the GPU's available resources. We have also identified and eliminated time-consuming overheads and used various GPU-specific optimization techniques to improve overall performance. Eventually, we have evaluated Ignite-GPU with the Genetic Algorithm, as a representative of data and compute-intensive algorithms, and gained more than thousands of times speedup in comparison with its CPU version. [ABSTRACT FROM AUTHOR]

Massive amounts of real-time streaming network data are generated quickly because of the exponential growth of applications. Analyzing patterns in generated flow traffic streaming offers benefits in reducing traffic congestion, enhancing network management, and improving the quality of service management. Processing massive volumes of generated traffic poses more challenges when data traffic encryption is raised. Classifying encrypted network traffic in real-time with deep learning networks has received attention because of their excellent performance. The substantial volume of incoming packets, characterized by high speed and wide variety, puts real-time traffic classification within the domain of big data problems. Classifying traffic with high speed and accuracy is a significant challenge in the era of big data. The real-time nature of traffic intensifies deep learning networks, necessitating a considerable number of parameters, layers, and resources for optimal network training. Until now, various datasets have been employed to evaluate the effectiveness of previous methods for classifying encrypted traffic. The primary objective has been to enhance accuracy, precision, and F1-measure. Presently, encrypted traffic classification performance depends on pre-existing datasets. The learning and testing phases are done offline, and more research is needed to investigate the feasibility of these methods in real-world scenarios. This paper examines the possibility of a tradeoff between evaluating the model’s effectiveness, execution time, and utilization of processing resources when processing stream-based input data for traffic classification. We aim to explore the feasibility of establishing a tradeoff between these factors and determining optimal parameter settings. This paper used the ISCX VPN-Non VPN 2016 public dataset to evaluate the proposed method. All packets from the dataset were streamed continuously through Apache Kafka to the classification framework. Numerous experiments have been designed to demonstrate the efficacy of the proposed method. The experimental results show that the proposed method outperforms the baseline methods by 11% in the F1-measure when the number of workers is two and by 25% when the number of workers is equal to 32. [ABSTRACT FROM AUTHOR]

The high number of transmissions in sensor nodes having a limited amount of energy leads to a drastic decrease in the lifetime of wireless sensor networks. For dense sensor networks, the provided data potentially have spatial and temporal correlations. The correlations between the data of the nodes make it possible to utilize compressive sensing theory during the data gathering phase; however, applying this technique leads to some errors during the reconstruction phase. In this paper, a method based on weighted spatial-temporal compressive sensing is proposed to improve the accuracy of the reconstructed data. Simulation results confirm that the reconstruction error of the proposed method is approximately 16 times less than the closest compared method. It should be noted that due to applying weighted spatial-temporal compressive sensing, some extra transmissions are posed to the network. However, considering both lifetime and accuracy factors as a compound metric, the proposed method yields a 12% improvement compared to the closest method in the literature. [ABSTRACT FROM AUTHOR]

A wide range of applications in engineering and scientific computing are based on the sparse matrix computation. There exist a variety of data representations to keep the non-zero elements in sparse matrices, and each representation favors some matrices while not working well for some others. The existing studies tend to process all types of applications, e.g., the most popular application which is matrix-vector multiplication, with different sparse matrix structures using a fixed representation. While Graphics Processing Units (GPUs) have evolved into a very attractive platform for general purpose computations, most of the existing works on sparse matrix-vector multiplication (SpMV, for short) consider CPUs. In this work, we design and implement an adaptive GPU-based SpMV scheme that selects the best format for the input matrix having the configuration and characteristics of GPUs in mind. We study the effect of various parameters and different settings on the performance of SpMV applications when employing different data representations. We then employ an adaptive scheme to execute different sparse matrix applications using proper sparse matrix representation formats. Evaluation results show that our run-time adaptive scheme properly adapts to different applications by selecting an appropriate representation for each input sparse matrix. The preliminary results show that our adaptive scheme improves the performance of sparse matrix multiplications by 2.1 $$\times $$ for single-precision and 1.6 $$\times $$ for double-precision formats, on average. [ABSTRACT FROM AUTHOR]

Understanding performance bottlenecks of applications in high-performance computing can lead to dramatic improvements in their performances. For example, a key problem in GPU programming is finding performance bottlenecks and solving them to reach the best possible performance. These bottlenecks in GPU architectures include a number of factors such as memory access latency, branch divergence, utilization, and the amount of existing parallelism. In addition, a simple profiling cannot demonstrate the relations between these bottlenecks. In this paper, we propose a statistical performance analyzer framework that not only helps us find bottlenecks, but also indicates the relations between them, which is not possible using a profiler. Recently, OpenCL has been proposed to be used in a variety of platforms, e.g., CPUs and GPUs, enabling a program written in one platform to be imported to other platforms with minimal effort. Therefore, we selected OpenCL to design our performance model for Nvidia GPUs. To construct the model, the values of GPU performance counters for the selected benchmarks are measured. Then, well-known statistical techniques such as regression and principal component analysis use these results to find the most significant parameters and to construct a performance model with up to 99 % accuracy. Finally, this method can be leveraged to characterize unknown applications based on their performance similarities with an existing database of benchmarks to predict their likely performance bottlenecks. [ABSTRACT FROM AUTHOR]

Mitigating energy consumption in Clouds reduces operational costs for providers. Power management policies which aim to reduce total energy consumed in data-centers pose challenges in both hardware technologies and resource management policies. We introduce an optimal utilization level of a host to execute a certain number of instructions to minimize energy consumption of the host. We also propose a virtual machine (VM) scheduling algorithm based on the unsurpassed utilization level to come up with optimal energy consumption while meeting a given QoS. In other words, our proposed algorithm regulates allocated computing resources of VMs on a host which results in reaching an optimal energy level in the host. The simulation results show that our proposed method not only reduces total energy consumption of a Cloud by 60 %, but also has a profound impact on turnaround times of real-time tasks by 94 %. It also increases the acceptance rate of arrival tasks by 96 %. Moreover, it takes a leading part in accepting lengthy tasks which have short deadlines. [ABSTRACT FROM AUTHOR]

The utilization of cloud computing in Internet of Things (IoT) applications has become widespread. However, it presents challenges for latency-sensitive scenarios due to data transmission to the centralized cloud structure, which leads to increased network traffic and service delays. To address this, fog computing has emerged as an intermediary layer between the cloud and IoT, ensuring low-latency interactions. A pivotal challenge within the fog computing paradigm is the service placement problem, involving assigning services to appropriate nodes, which is recognized as NP-hard. Recognizing the intricate nature of service placement, this study introduces a multi-objective optimization approach tailored for dynamic service placement within container-based fog computing environments. Considering multiple objectives is imperative due to the complex interplay of performance metrics in fog computing scenarios. A two-tier resource management framework based on Kubernetes is proposed to manage these diverse yet interrelated objectives effectively. The framework harnesses the power of the multi-objective, non-dominated sorting genetic algorithm II (NSGA-II) to reconcile conflicting objectives and facilitate optimal service placement decisions. Incorporating multi-objective optimization enables a comprehensive evaluation of service placement solutions, ensuring a balanced trade-off between latency, cost-efficiency, and energy consumption. Empirical evaluations demonstrate that the proposed method improves cost, average latency time, and energy consumption by 8% to 36% compared to state-of-the-art methods. [ABSTRACT FROM AUTHOR]