Edge devices such as wearables, drones, and CCTV systems have been widely deployed to collect real-world data, playing a crucial role in enhancing and securing urban life. However, these devices often struggle with significant performance challenges due to their limited computational and storage capacities when processing data locally. Offloading computation and data to the public cloud is straightforward but introduces high costs and latency. Alternatively, relying on an edge server to support a diverse array of heterogeneous edge devices can standardize operations. Still, it may lead to underutilization of high-performance devices such as Jetson Xavier if all tasks are centralized on the server. To address these concerns, we introduce ERPF, an edge resource provisioner that virtually extends edge devices' computation and storage capabilities, enabling them to handle complex tasks beyond their capacity. ERPF supports dynamic volume provisioning, GPU provisioning, and online execution context migration. Also, we propose a novel technique (ATS) that schedules AI workloads on distributed edge devices and edge servers with adjustment of task partition sizes based on the computational and network performance of the edge devices. ATS is seamlessly integrated into the ERPF prototype, which is implemented on a Kubernetes cluster using the Rook-Ceph storage orchestrator. Experimental results show that ERPF efficiently scales resources for edge devices through strategic offloading, while ATS delivers a substantial performance improvement of up to 23 × compared to baseline methods.

With the growing adoption of Internet of Things (IoT)sensors and applications, the volume of time-series data is expanding rapidly, underscoring the increasing importance of time-series databases (TSDBs) for efficient data management across edge and cloud environments. TSDBs are required to deliver high throughput and low latency to meet performance demands. However, due to strict data management rules, conventional TSDBs often overwrite redundant time-series data with identical timestamps. To overcome this limitation, we propose Tag-based Sequential Grouping (TSG), a novel approach that preserves time-series data with identical timestamps in TSDBs. TSG leverages tag identifiers as a secondary indexing mechanism to store data without overwriting, ensuring complete retention. We evaluate TSG on state-of-the-art TSDBs using real-world datasets. Our experimental results demonstrate that TSG successfully retains 100% of time-series data with identical timestamps across various TSDBs without data loss. Moreover, TSG significantly enhances read latency, outperforming existing methods by up to 322 times on a 6-hour interval range query.

Internet of Things (IoT) (or edge) devices are typically resource-constrained in terms of CPU, memory, and storage. Thus, it is viable for the devices to request resource provisioning to an edge server in the presence of growing data and heavy computation, as the edge server provides better accessibility than cloud servers. Consequently, the edge devices often perform computation and storage provisioning to the edge servers in large-scale data operations. However, the conventional methods for provisioning edge devices take into little consideration the characteristics of resources that jobs executed at the devices rely on. In particular, fully migrating computation jobs from the device to the server may waste valuable resources of the server without considering the computation and I/O characteristics of the jobs, thereby making the devices' resources idle. To overcome these limitations, we propose a novel Kubernetes-based resource augmentation framework, termed K-RAF, for provisioning edge devices with limited capabilities and accelerating the devices' job processing. Our experiment demonstrates that utilizing GPU acceleration, on average, K-RAF can run tasks 306 times faster than local computation on an edge device. Also, we show that utilizing the task distribution between an edge device and K-RAF can offer an average speedup of about 40% compared to K-RAF alone.

The query optimization phase within a database management system (DBMS) ostensibly finds the fastest query execution plan from a potentially large set of enumerated plans, all of which correctly compute the same result of the specified query. Sometimes the cost-based optimizer selects a slower plan, for a variety of reasons. Previous work has focused on increasing the performance of specific components, often a single operator, within an individual DBMS. However, that does not address the fundamental question: from where does this suboptimality arise, across DBMSes generally? In particular, the contribution of each of many possible factors to DBMS suboptimality is currently unknown. To identify the root causes of DBMS suboptimality, we first introduce the notion of empirical suboptimality of a query plan chosen by the DBMS, indicated by the existence of a query plan that performs more efficiently than the chosen plan, for the same query. A crucial aspect is that this can be measured externally to the DBMS, and thus does not require access to its source code. We then propose a novel predictive model to explain the relationship between various factors in query optimization and empirical suboptimality. Our model associates suboptimality with the factors of complexity of the schema, of the underlying data on which the query is evaluated, of the query itself, and of the DBMS optimizer. The model also characterizes concomitant interactions among these factors. This model induces a number of specific hypotheses that were tested on multiple DBMSes. We performed a series of experiments that examined the plans for thousands of queries run on four popular DBMSes. We tested the model on over a million of these query executions, using correlational analysis, regression analysis, and causal analysis, specifically Structural Equation Modeling (SEM). We observed that the dependent construct of empirical suboptimality prevalence correlates positively with nine specific constructs characterizing four identified factors that explain in concert much of the variance of suboptimality of two extensive benchmarks, across these disparate DBMSes. This predictive model shows that it is the common aspects of these DBMSes that predict suboptimality, not the particulars embedded in the inordinate complexity of each of these DBMSes. This paper thus provides a new methodology to study mature query optimizers, identifies underlying DBMS-independent causes for the observed suboptimality, and quantifies the relative contribution of each of these causes to the observed suboptimality. This work thus provides a roadmap for fundamental improvements of cost-based query optimizers.

This paper presents a virtualization-based computing and storage resource provisioning manager, termed RPM, for edge devices. Given a request from an edge device, RPM can perform dynamic volume provisioning and accelerated computation on augmented computing resources. Also, RPM can migrate application execution conducted by edge devices online. We show that RPM is a promising approach through our experiments.

A cargo containment system (CCS) of liquefied natural gas (LNG) is an essential component of an LNG carrier (LNGC). During the manufacturing process of the LNGC CCS, it is critical that the heating, ventilation, and air conditioning (HVAC) facility stabilizes the environmental states inside the CCS at all times to prevent devastating rust and dew from forming inside the LNGC CCS. One critical problem is that it consumes enormous power, resulting in high expenses. To alleviate this problem, we propose our design of a novel data-driven framework, termed ECM, that uses a combination of machine learning and deep reinforcement learning (DRL) models to robustly and automatically control the HVAC system. Based on selected features, we develop the best indoor-environment forecasting model from several candidate models and build an HVAC control agent by training the DRL model with the reward function that uses the predicted temperature and humidity through the forecasting model. To validate our proposed framework, we have assessed the performance of our models on the real-world sensor data obtained from one of the major world-class shipyards. As a result, we show that our DRL-based model trained in the proposed framework stably controls the temperature inside the CCS within only 1.$5^{\mathrm{o}}$C variance in the set range from 2$3^{\mathrm{o}}$C to 2$5^{\mathrm{o}}$C while on average consuming power up to about 34% less than the compared existing methods. We expect our framework will bring an annual savings of about ${\$}$ 14 million or more once deployed in the actual field.

In this paper we conduct an empirical study across modern GPU-accelerated DBMSes with TPC-H workloads. Our rigorous experiments demonstrate that the studied DBMSes appear to utilize GPU resource effectively but do not scale well with growing databases nor have full capability to process some complex analytical queries. Thus, we claim that the GPU DBMSes still need to be further engineered to achieve a better analytical performance.

Summary Measuring execution time is one of the most used performance evaluation techniques in computer science research. Inaccurate measurements cannot be used for a fair performance comparison between programs. Despite the prevalence of its use, the intrinsic variability in the time measurement makes it hard to obtain repeatable and accurate timing results of a program running on an operating system. We propose a novel execution time measurement protocol (termed EMP) for measuring the execution time of a compute‐bound program on Linux, while minimizing that measurement's variability. During the development of execution time measurement protocol, we identified several factors that disturb execution time measurement. We introduce successive refinements to the protocol by addressing each of these factors, in concert, reducing variability by more than an order of magnitude. We also introduce a new visualization technique, what we term ‘dual‐execution scatter plot’ that highlights infrequent, long‐running daemons, differentiating them from frequent and/or short‐running daemons. Our empirical results show that the proposed protocol successfully achieves three major aspects—precision, accuracy, and scalability—in execution time measurement that can work for open‐source and proprietary software. Copyright © 2017 John Wiley & Sons, Ltd.

It is surprisingly hard to obtain accurate and precise measurements of the time spent executing a query because there are many sources of variance. To understand these sources, we review relevant per-process and overall measures obtainable from the Linux kernel and introduce a structural causal model relating these measures. A thorough correlational analysis provides strong support for this model. We attempted to determine why a particular measurement wasn’t repeatable and then to devise ways to eliminate or reduce that variance. This enabled us to articulate a timing protocol that applies to proprietary DBMSes, that ensures the repeatability of a query, and that obtains a quite accurate query execution time while dropping very few outliers. This resulting query time measurement procedure, termed the Tucson Timing Protocol Version 2 (TTPv2), consists of the following steps: (i) perform sanity checks to ensure data validity; (ii) drop some query executions via clearly motivated predicates; (iii) drop some entire queries at a cardinality, again via clearly motivated predicates; (iv) for those that remain, compute a single measured time by a carefully justified formula over the underlying measures of the remaining query executions; and (v) perform post-analysis sanity checks. The result is a mature, general, robust, self-checking protocol that provides a more precise and more accurate timing of the query. The protocol is also applicable to other operating domains in which measurements of multiple processes each doing computation and I/O is needed.

Computational science and engineering (CSE) researchers usually develop their own technology computer-aided design (TCAD) programs, accompanying large-scale computation and I/O on high-performance computing (HPC) resources like clusters or supercomputers. The researchers typically use command-line interface (CLI) such as Terminal to access the HPC resources. But CLI may not be a useful tool to those who conduct research or get educated with the TCAD software, because of their unfamiliarity with executing a series of commands. Thus there has been a strong need on a platform that assists domain-specific scientists to easily share, access, and run TCAD services. To satisfy the need, in this poster we present a novel cyber-environment, called "Education-research Integration through Simulation On the Net" (EDISON), which has been designed and implemented to access and run various TCAD software tools developed in five selected CSE fields over the past four years. The EDISON platform comprises three layers: application portal to browse and run TCAD software, middleware to manage metadata associated with TCAD software and handle online simulation jobs, and infrastructure to support network, storage, and computing resources. In this demo a user will interact with the EDISON platform to perform two representative use-case scenarios: 1) browsing various TCAD tools, selecting one of the tools, controlling with its parameters, and running a simulation job from the tool, and 2) constructing a scientific workflow of selected TCAD tools and executing the workflow. At the end, the user will visualize the completed simulation results.

In the database field, while very strong mathematical and engineering work has been done, the scientific approach has been much less prominent. The deep understanding of query optimizers obtained through the scientific approach can lead to better engineered designs. Unlike other domains, there have been few DBMS-dedicated laboratories, focusing on such scientific investigation. In this demonstration, we present a novel DBMS-oriented research infrastructure, called Arizona Database Laboratory (AZDBLab), to assist database researchers in conducting a large-scale empirical study across multiple DBMSes. For them to test their hypotheses on the behavior of query optimizers, AZDBLab can run and monitor a large-scale experiment with thousands (or millions) of queries on different DBMSes. Furthermore, AZDBLab can help users automatically analyze these queries. In the demo, the audience will interact with AZDBLab through the stand-alone application and the mobile app to conduct such a large-scale experiment for a study. The audience will then run a Tucson Timing Protocol analysis on the finished experiment and then see the analysis (data sanity check and timing) results.

It is surprisingly hard to obtain accurate and precise measurements of the time spent executing a query. We review relevant process and overall measures obtainable from the Linux kernel and introduce a structural causal model relating these measures. A thorough correlational analysis provides strong support for this model. Using this model, we developed a timing protocol, which (1) performs sanity checks to ensure validity of the data, (2) drops some query executions via clearly motivated predicates, (3) drops some entire queries at a cardinality, again via clearly motivated predicates, (4) for those that remain, for each computes a single measured time by a carefully justified formula over the underlying measures of the remaining query executions, and (5) performs post-analysis sanity checks. The resulting query time measurement procedure, termed the Tucson Protocol, applies to proprietary and open-source DBMSes.

This paper introduces a new tool that recommends an optimized partitioning solution called Multi-Level Partitioned Primary Index (MLPPI) for a fact table based on the queries in the workload. The tool implements a new technique using a greedy algorithm for search space enumeration. The space is driven by predicates in the queries. This technique fits very well the Teradata MLPPI scheme, as it is based on a general framework using general expressions, ranges and case expressions for partition definitions. The cost model implemented in the tool is based on the Teradata optimizer, and it is used to prune the search space for reaching a final solution. The tool resides completely on the client, and interfaces the database through APIs as opposed to previous work that requires optimizer code extension. The APIs are used to simplify the workload queries, and to capture fact table predicates and costs necessary to make the recommendation. The predicate-driven method implemented by the tool is general, and it can be applied to any clustering or partitioning scheme based on simple field expressions or complex SQL predicates. Experimental results given a particular workload will show that the recommendation from the tool outperforms a human expert. The experiments also show that the solution is scalable both with the workload complexity and the size of the fact table.

Flash memory devices commonly rely on traditional address mapping schemes such as page mapping, block mapping or a hybrid of the two. Page mapping is more flexible than block mapping or hybrid mapping without being restricted by block boundaries. However, its mapping table tends to grow large quickly as the capacity of flash memory devices does. To overcome this limitation, we propose a novel mapping scheme that is fundamentally different from the existing mapping strategies. We call this new scheme Virtual Extent Trie (VET), as it manages mapping information by treating each I/O request as an extent and by using extents as basic mapping units rather than pages or blocks. By storing extents instead of individual addresses, VET consumes much less memory to store mapping information and still remains as flexible as page mapping. We observed in our experiments that VET reduced memory consumption by up to an order of magnitude in comparison with the traditional mapping schemes for several real world workloads. The VET scheme also scaled well with increasing address spaces by synthetic workloads. With a binary search mechanism, VET limits the mapping time to O(log log|U |), where U denotes the set of all possible logical addresses. Though the asymptotic mapping cost of VET is higher than the O(1) time of a page mapping scheme, the amount of increased overhead was almost negligible or low enough to be hidden by an accompanying I/O operation.

In e-science environments, scientists need to execute a scientific application with various parameters multiple times to simulate and experiment complicated problems on the grid. For this, they should write every single job description with distinct parameters even if this is a troublesome task. To provide the flexibility and adaptability for parameter study, we propose an application parameter description language (APDL) and a service oriented parameter study scheme, called a parametric study service (PSS), for parameterized simulations on the grid. The APDL extends the job submission description language (JSDL) to generate parameters for multiple jobs. The proposed PSS provides a unified interface to submit jobs into various middleware platforms such as gLite, Globus, etc. The problem solving environment (PSE) assists a parameter study for their applications and every research fields tend to construct individual own PSE., The proposed PSS can be easily adapted into the specific PSE because of being implemented as Web services. In practice, we apply the APDL and the PSS into aerospace research PSE which carry out the three-dimensional turbulent analysis for compressible flow.