Search

Abstract The development of the cloud and data centers alike has caused users to increasingly share storage systems, and storage systems have adopted SSDs to improve performance. The number of users is growing sharply and causing resource competition, so the throughput allocation of a hybrid storage system has an important effect on users' performance. A hybrid storage architect faces a challenge: sharing I/O throughput resources between SSDs and HDDs fairly with high resource utilization. Drawing on economic game-theory, many methods based on Leontief preference have been proposed to determine fair throughput allocation in a hybrid storage system with having the properties of Sharing Incentive (SI), Envy Freeness (EF) and Pareto Optimality (PO). However, users' workload characteristics vary because of the adoption of SSDs, so there is heterogeneity among the storage media. The heterogeneity of storage media and the diversity of user workloads together create more constraints on fairness, which imposes restrictions to improve the resource utilization. To improve the resource utilization, some researchers have proposed relaxing the limitation of fairness properties by adjusting users' allocations. However, when adjusting the allocation between users, some users' allocations are reduced but others' are improved, with the goal of increasing the resource utilization of the whole system, this will pose a problem because of the Leontief preference restriction: some users' performance is degraded, while other users' performance is improved. In this paper, we first propose one variant of the Cobb–Douglas preference based on users' workloads and allocations, and then present a throughput allocation model based on this variant named TACD that can capture the effects of diminishing returns and substitutability in throughput allocation for hybrid storage. By making use of these effects, TACD can improve some users' performance while providing the same performance for other users and achieving higher resource utilization in the whole system, and it can provide a fair allocation while enjoying SI, EF and PO properties. The variant of the Cobb–Douglas preference proposed in this paper has taken consideration of users' workloads, so TACD can conduct the throughput allocation based on these workloads for meeting the performance requirements of users reasonably. Extensive experiments are conducted to prove the effectiveness of TACD. The simulation results show that TACD can fit the throughput allocation of hybrid storage system very well. The Linux results show that compared with the allocation method based on Leontief preference, TACD can provide a higher resource utilization and performance for users throughout the system, it can improve some users' performance when maintaining comparable performance for other users, in contrast to the Leontief method based on weaker fairness under the same resource utilization, and its allocation result enjoys SI, EF and PO properties. Highlights • The throughput allocation method based on the variant of Cobb–Douglas preference (TACD). • The variant of Cobb–Douglas preference based on users' workloads, which can conduct a reasonable allocation for meeting users' performance. • TACD can capture the effects of diminishing returns and substitutability for improving the resource utilization with enjoying fairness properties, and its allocation can improve some users' performance without degrading the performance of the remaining users. [ABSTRACT FROM AUTHOR]

Modern large-scale computers have shifted to Multi-socket Multi-core (MSMC) architectures, where multiple CPU chips are integrated into a machine as sockets and multiple memory nodes are integrated into the shared main memory (NUMA). To improve the hardware utilization of MSMC computers, multiple programs are often executed concurrently. However, most work-stealing schedulers are designed for single-socket architectures and contention-free scenarios. Work-stealing programs suffer from very-high-frequency remote memory access and serious interference from co-located programs in MSMC architectures, which in turn significantly degrade their performance. To solve these two problems, we propose a Contention- and Locality-Aware Work-Stealing (CLAWS) scheduler. CLAWS first evenly distributes the data set of a program to all the memory nodes and allocates a task to the socket where the local memory node stores its data. Then, according to the real-time contention situation for each socket collected at runtime, CLAWS dynamically migrates data and re-allocates the corresponding tasks to balance the workload and reduce remote memory accesses. Experimental results show that CLAWS can improve the performance of memory-bound programs by 40.1 percent on average compared with traditional work-stealing schedulers. Meanwhile, CLAWS is also more energy efficient than traditional work-stealing schedulers. [ABSTRACT FROM PUBLISHER]

The potential to promote market value by analysing graph-structured data is increasingly attracting businesses from a variety of industries, ranging from Internet companies to traditional enterprises. However, the query over large graphs easily and efficiently is still a critical problem in large scale distributed systems. Many proposed systems have to use low-level programming model, like Pregel, which requires a large amount of code optimization and maintenance work by developers. Although structural recursion has been studied as an efficient high-level programming model for graph transformations, it is not well exploited in practice to accelerate the parallel graph computing. To address the above problem, in this paper, we propose optimizations of structure recursion for distributed graphs to reduce the number of iterations during graph query processing in a distributed system. In order to improve query response time and throughput, subgraph based computation on structure recursive functions are used to replace typical vertex based evaluation approach. Meanwhile, we propose several redundancy rules to reduce graph size in parallel. We verify the performance of our system through evaluation on real datasets. The results show that, compared to the state-of-the-art approach (Tung and Hu (2015) Towards systematic parallelization of graph transformations over pregel, pp. 1-20. Springer), our algorithm achieves speedup over two times on query response time. [ABSTRACT FROM AUTHOR]

Indoor subarea localization can facilitate numerous location-based services, such as indoor navigation, indoor POI recommendation and mobile advertising. Most existing subarea localization approaches suffer from two bottlenecks, one is fingerprint-based methods require time-consuming site survey and another is triangulation-based methods are lack of scalability. In this paper, we propose a graph-based method for indoor subarea localization with zero-configuration. Zero-configuration means the proposed method can be directly employed in indoor environment without time-consuming site survey or pre-installing additional infrastructure. To accomplish this, we first utilize two unexploited characteristics of WiFi radio signal strength to generate logical floor graph and then formulate the problem of constructing fingerprint map as a graph isomorphism problem between logical floor graph and physical floor graph. In online localization phase, a Bayesian-based approach is utilized to estimate the unknown subarea. The proposed method has been implemented in a real-world shopping mall, and extensive experimental results show that the proposed method can achieve competitive performance comparing with existing methods. [ABSTRACT FROM AUTHOR]

Modern multicore computers often adopt a multisocket multicore architecture with shared caches in each socket. However, traditional work-stealing schedulers tend to pollute the shared cache and incur more cache misses due to their random stealing. To relieve this problem, this paper proposes an Adaptive Cache-Aware Bi-tier work-stealing (A-CAB) scheduler. A-CAB improves the performance of memory-bound applications by reducing memory footprint and cache misses of tasks running inside the same CPU socket. A-CAB adaptively uses a DAG partitioner to divide an execution Directed Acyclic Graph (DAG) into the intersocket tier and the intrasocket tier. Tasks in the intersocket tier are scheduled across sockets while tasks in the intrasocket tier are scheduled within the same socket. Experimental results tell us that A-CAB can improve the performance of memory-bound applications up to 74.4 percent compared with the traditional work-stealing. [ABSTRACT FROM PUBLISHER]

As an important cornerstone for clouds, virtualization plays a vital role in building this emerging infrastructure. Virtual machines (VMs) with a variety of workloads may run simultaneously on a physical machine in the cloud platform. The scheduling algorithm used in Xen schedules virtual CPUs (VCPUs) of a VM asynchronously and guarantees the proportion of the CPU time allocated to the VM. This proportional sharing (PS) method is beneficial as it simplifies the implementation of CPU scheduling in the virtual machine monitor (VMM), and can deliver near-native performance for some workloads. However, when workloads in VMs are concurrent applications such as multithreaded programs with the synchronization operation, it has been demonstrated that this method in the VMM can reduce the performance, due to the negative impact of virtualization on synchronization. To address this issue, we present a hybrid scheduling framework for CPU management in the VMM to adapt to the diversity of VMs running simultaneously on a physical machine. We implement a hybrid scheduler based on Xen, and experimental results indicate that the hybrid CPU management method is feasible to mitigate the negative influence of virtualization on synchronization, and improve the performance of concurrent applications in the virtualized system, while maintaining the performance of high-throughput applications. [ABSTRACT FROM PUBLISHER]

In MapReduce model, a job is divided into a series of map tasks and reduce tasks. The execution time of the job is prolonged by some slow tasks seriously, especially in heterogeneous environments. To finish the slow tasks as soon as possible, current MapReduce schedulers launch a backup task on other nodes for each of the slow tasks. However, traditional MapReduce schedulers cannot detect slow tasks correctly since they cannot estimate the progress of tasks accurately (Hadoop home page , ; Zaharia et al. in 8th USENIX symposium on operating systems design and implementation, ACM, New York, pp. 29-42, ). To solve this problem, this paper proposes a History-based Auto-Tuning (HAT) MapReduce scheduler, which calculates the progress of tasks accurately and adapts to the continuously varying environment automatically. HAT tunes the weight of each phase of a map task and a reduce task according to the value of them in history tasks and uses the accurate weights of the phases to calculate the progress of current tasks. Based on the accurate-calculated progress of tasks, HAT estimates the remaining time of tasks accurately and further launches backup tasks for the tasks that have the longest remaining time. Experimental results show that HAT can significantly improve the performance of MapReduce applications up to 37% compared with Hadoop and up to 16% compared with LATE scheduler. [ABSTRACT FROM AUTHOR]

In loops, some arrays are referenced with induction variables. To parallelize such kind of loops, those induction variables should be substituted. Thus, those array references that were substituted are formulated as nonlinear expressions. The goal of data alignment is to intelligently map the computations and data onto a set of virtual processors which are organized as a Cartesian grid (or a template in HPF terms), and to provide data locality for parallelizing compilers so that data access communication costs can be minimized. Most data alignment methods are mainly devised to align the referenced arrays using linear subscripts or quadratic subscripts with n loop index variables, and the methods are well developed. Seldom work, however, is researched on the nonlinear expressions of index variables. This paper proposes a new communication-free data alignment technique to align the referenced arrays using exponential subscripts with n loop index variables or other complex nonlinear expressions. The experimental results using SPEC95FP Benchmarks point out that the techniques proposed in the paper can improve the execution time of the subroutines in these benchmarks. [ABSTRACT FROM AUTHOR]

Target tracking is one application of wireless sensor networks and energy efficient target tracking algorithms that can be used for accurate tracking are highly desired. In order to achieve energy savings, we focus on reducing energy usage by limiting the number of sensors used to track a target through monitoring their data quality and by limiting the amount of data being sent to the cluster head. We propose an energy efficient target tracking protocol that uses two algorithms to accomplish this goal. Simulation studies show that the network lifetime is extended up to 35% with application of both algorithms and that the side effect on target tracking accuracy is not too negative. [ABSTRACT FROM AUTHOR]

Abstract: Many high-performance DSP processors employ multi-bank on-chip memory to improve performance and energy consumption. This architectural feature supports higher memory bandwidth by allowing multiple data memory accesses to be executed in parallel. However, making effective use of multi-bank memory remains difficult, considering the combined effect of performance and energy requirement. This paper studies the scheduling and assignment problem about how to minimize the total energy consumption while satisfying the timing constraint with heterogeneous multi-bank memory for applications with loop. An algorithm, TASL (Type Assignment and Scheduling for Loops), is proposed. The algorithm uses bank type assignment with the consideration of variable partition to find the best configuration for both memory and ALU. The experimental results show that the average improvement on energy-saving is significant by using TASL. [Copyright &y& Elsevier]

Traditionally, loop nests are fused only when the data dependences in the loop nests are not violated. This paper presents a new loop fusion algorithm that is capable of fusing loop nests in the presence of fusion-preventing anti-dependences. All the violated anti-dependences are removed by automatic array copying. As a case study, this aggressive loop fusion strategy is applied to a Jacobi solver. The performance of iterative methods is typically limited by the speed of the memory system. Fusing the two loop nests in the Jacobi solver into one reduces data cache misses, and consequently, improves the performance results of both sequential and parallel versions of the Jacobi program, as validated by our experimental results on an HP AlphaServer SC45 supercomputer. [ABSTRACT FROM AUTHOR]

Abstract: Many scientific applications require array redistribution when the programs run on distributed memory parallel computers. It is essential to use efficient algorithms for redistribution, otherwise the performance of the programs will degrade considerably. The redistribution overheads consist of two parts: index computation and inter-processor communication. If there is no communication scheduling in a redistribution routine, the inter-processor communication will incur a larger communication idle time when there exists node contention and/or difference among message lengths during one particular communication step. In order to solve this problem, in this paper, we propose an efficient scheduling scheme that not only minimizes the number of communication steps and eliminates node contention, but also minimizes the difference of message lengths in each communication step. Thus, the communication idle time is reduced in redistribution routines. [Copyright &y& Elsevier]

Abstract: Cook''s Theorem [Cormen, T.H., Leiserson, C.E., Rivest, R.L., 2001. Introduction to Algorithms, second ed., The MIT Press; Garey, M.R., Johnson, D.S., 1979. Computer and Intractability, Freeman, San Fransico, CA] is that if one algorithm for an NP-complete or an NP-hard problem will be developed, then other problems will be solved by means of reduction to that problem. Cook''s Theorem has been demonstrated to be correct in a general digital electronic computer. In this paper, we first propose a DNA algorithm for solving the vertex-cover problem. Then, we demonstrate that if the size of a reduced NP-complete or NP-hard problem is equal to or less than that of the vertex-cover problem, then the proposed algorithm can be directly used for solving the reduced NP-complete or NP-hard problem and Cook''s Theorem is correct on DNA-based computing. Otherwise, a new DNA algorithm for optimal solution of a reduced NP-complete problem or a reduced NP-hard problem should be developed from the characteristic of NP-complete problems or NP-hard problems. [Copyright &y& Elsevier]

This paper shows how to use DNA strands to construct solution space of molecules for the dominating-set problem and how to apply biological operations to solve the problem from the solution space of molecules. In order to achieve this, we have proposed some DNA based parallel algorithms using the operations in Adleman–Lipton model, together with the analysis of the computational complexity for DNA parallel algorithms. [Copyright &y& Elsevier]

Adleman wrote the first paper in which it is shown that deoxyribonucleic acid (DNA) strands could be employed towards calculating solutions to an instance of the NP-complete Hamiltonian path problem (HPP). Lipton also demonstrated that Adleman’s techniques could be used to solve the NP-complete satisfiability (SAT) problem (the first NP-complete problem). In this paper, it is proved how the DNA operations presented by Adleman and Lipton can be used for developing DNA algorithms to resolving the set cover problem and the problem of exact cover by 3-sets. [Copyright &y& Elsevier]

Communication set generation significantly influences the performance of parallel programs. However, studies seldom give attention to the problem of communication set generation for irregular applications. In this paper, we propose communication optimization techniques for the situation of irregular array references in nested loops. In our methods, the local array distribution schemes are determined so that the total number of communication messages is minimized. Then, we explain how to support communication set generation at compile-time by introducing some symbolic analysis techniques. In our symbolic analysis, symbolic solutions of a set of symbolic expression are obtained by using certain restrictions. We introduce symbolic analysis algorithms to obtain the solutions in terms of a set of equalities and inequalities. Finally, experimental results on a parallel computer CM-5 are presented to validate our approach. [ABSTRACT FROM AUTHOR]

It is important for programmers to understand the semantics of a programming language. However, little work has been done about the semantic descriptions of HPFlike data-parallel languages. In this paper, we first define a simple language D, which includes the principal facilities of a data-parallel language such as HPF. Then we present a denotational semantic model of D. It is useful for understanding the components of an HPF-like language, such as data alignment and distribution directives, forall dataparallel statements. [ABSTRACT FROM AUTHOR]

In recent decades, the exponential growth of applications has intensified traffic demands, posing challenges in ensuring optimal user experiences within modern networks. Traditional congestion avoidance and control mechanisms embedded in conventional routing struggle to promptly adapt to new-generation networks. Current routing approaches risk-averse outcomes such as (1) scalability constraints, (2) high convergence times, and (3) congestion due to inadequate real-time traffic prioritization. To address these issues, this paper introduces a QoS-Driven Routing Optimization in Software-Defined Networking (SDN) using Deep Reinforcement Learning (DRL) to optimize routing and enhance QoS efficiency. Employing DRL, the proposed DQS optimizes routing decisions by intelligently distributing traffic, guided by a multi-objective function-driven DRL agent that considers both link and queue metrics. Despite the complexity of the network, DQS sustains scalability while significantly reducing convergence times. Through a Docker-based Openflow prototype, results highlight a substantial 20-30% reduction in end-to-end delay compared to baseline methods. • DQS tackles scalability and congestion with a multi-objective loss function, integrating CoS into routing decisions to make informed decisions. • DQS employs a seven-parameter traffic classifier with ML techniques, efficiently categorizing CoS and ensuring mice and elephant traffic. • The paper presents DQS, employing DRL to optimize routing decisions, minimize delay and loss, and maximize bandwidth use across links and queues. • We evaluate DQS with a Docker-based SDN prototype, showing its adaptability, scalability, and responsiveness to traffic changes and QoS demands. • Results show 20-30% delay reduction and 14% processing time improvement over state-of-the-art algorithms, enhancing network performance. [ABSTRACT FROM AUTHOR]

• Early recurrence after bowel resection in patients with Crohn's disease has been a clinical challenge. • CTE features are useful in predicting prognosis of early recurrence in patients with CD after surgery. • MCFI score ≥ 4 (OR = 32.42 [10.69–98.33], p < 0.001) is significantly associated with recurrence within one year. To investigate the value of mesenteric creeping fat index (MCFI) defined by computed-tomography enterography (CTE) in patients with Crohn's Disease (CD) for predicting early postoperative recurrence. A total of 110 patients with CD who underwent CTE and I-stage intestinal resection surgery from December 2013 to December 2018 were enrolled. Two radiologists independently assessed CTE parameters, including MCFI, with scores ranging from 1 to 8; bowel-wall thickening, with a scale of 1 to 3; mural hyperenhancement, mural stratification, submucosal fat deposition, mesenteric fibrofatty proliferation, mesenteric hypervascularity, mesenteric fat stranding, with a scale of 0 to 2; abscess/fistula, enlarged mesenteric lymph node, abdominal and pelvic effusion, with a scale of 0 to 1. Imaging findings associated with early recurrence were assessed using logistic regression analysis. Within one year follow-up, early postoperative recurrence occurred in 56.4 % (62/110) patients with CD. In univariate analysis, MCFI, bowel-wall thickening, mesenteric hypervascularity, mesenteric fat stranding, abscess/fistula and mesenteric lymphadenopathy were associated with early postoperative recurrence. Among all variables, MCFI (score ≥ 4) contributes the optimal AUC (0.838 [0.758–0.919]), specificity (89.6 %), positive predictive value (90.7 %), accuracy (83.6 %), and risk ratio (OR = 32.42 [10.69–98.33], p < 0.001). In multivariate analysis, only MCFI was an independent predictor of early postoperative recurrence (OR = 25.71 [7.65–86.35], p < 0.001). CTE features are useful in predicting early postoperative recurrence in patients with CD, MCFI may be a valuable tool for clinical monitoring and follow-up. [ABSTRACT FROM AUTHOR]

Solid-state drives (SSDs) have been added into storage systems for improving their performance, which will bring the heterogeneity into the storage medium. The throughput is one of the essential resources in heterogeneous storage systems, and how to allocate the throughput plays a crucial role in user performance. There are many types of research on the throughput allocation of heterogeneous storage systems. However, the throughput allocation of heterogeneous storage is facing new challenges in a dynamic setting, where users are not present in the system simultaneously, and enter the system dynamically. Drawing on economic game-theory, researchers have proposed many methods to tackle dynamic throughput allocation issues for heterogeneous storages, cross out enjoying Sharing Incentive (SI), Envy Freeness (EF), and Pareto Optimality (PO). However, they either relax constraints of fairness property to cause the allocation with weak fairness or interrupt some users present in the system to give up a piece of their allocations for new users entering the system, which will degrade these donors’ performance. Moreover, all of existing methods will cause lower resource utilization due to constraints of users’ dominant share equality. In this article, we propose a dynamic throughout allocation method based on gradual increase (DAGI), which can adapt to various workloads to make a fair allocation with a maximum resource utilization. Without relaxing constraints of fairness properties, when new users enter the system, DAGI can make a dynamic allocation with strong fairness by appropriately postponing the allocation of surplus throughputs, so this can provide an opportunity that DAGI can guarantee the final allocation with strong fairness when allocating remaining throughputs after all users are present in the system. Meanwhile, DAGI can gradually increase user allocation without reduction, which will not interrupt any users present in the system. Furthermore, DAGI can conduct a dynamic throughput allocation based on users’ local bottleneck resources, which can adapt to various workloads of users to improve resource utilization. Extensive experiments are conducted to prove the effectiveness of DAGI. The experimental results show that DAGI can achieve higher resource utilization and performance than existing methods, and can satisfy desirable game-theoretic properties with guaranteeing the strong fairness. In addition, DAGI gradually increases the allocation of each user without interrupting any user to reduce its allocation to degrade its performance. [ABSTRACT FROM AUTHOR]

Graph analytics has been routinely used to solve problems in a wide range of real-life applications. Efficiently processing concurrent graph analytics queries in a multiuser environment is highly desirable as we enter a world of edge device oriented services. Existing research, however, primarily focuses on analyzing a single, large graph dataset and leaves the efficient processing of multiple mid-sized graph analytics queries an intriguing yet challenging open problem. In this work, we investigate the scheduling of concurrent graph analytics queries on NUMA machines. We analyze the performance of several graph analytics algorithms and observe that they have diminishing performance returns as the number of processor cores increases. With concurrent graph analytics, such diminishing returns translate to no or even negative performance gains because of increasing contention on shared hardware resources. We also demonstrate the unpredictability of memory bandwidth usage for numerous graph analytics algorithms, which can lead to sub-optimal performance due to its potential to cause severe memory bandwidth contention. Motivated by the above observations, we propose CongraPlus, a NUMA-aware scheduler that intelligently manages concurrent graph analytics queries for better system throughput and memory bandwidth efficiency. CongraPlus collects the memory bandwidth consumption characteristics of graph analytics queries via offline profiling and eliminates memory bandwidth contention by computing the optimal sequence to launch queries. It also avoids computation resource contention by assigning a certain number of processor cores to the individual queries. We implement CongraPlus in C++ on top of the Ligra graph processing framework and test it with judiciously selected graph processing query combinations. Our results reveal that CongraPlus-based schemes improve query throughput by 30 percent compared to the conventional approach. It also exhibits a much better quality of service and scalability. [ABSTRACT FROM AUTHOR]

The article discusses various reports published within the issue, including one by Liu, Cao, Zheng and Xie on minimizing energy consumption for data gathering and aggregation in wireless sensor networks, and another by Xue, Guo and Dai on how aggressive loop fushion can improve parallelism of iterative methods.

This article presents an introduction to periodical.

Disaggregated architecture brings new opportunities to memory-consuming applications like graph processing. It allows one to outspread memory access pressure from local to far memory, providing an attractive alternative to disk-based processing. Although existing works on general-purpose far memory platforms show great potentials for application expansion, it is unclear how graph processing applications could benefit from disaggregated architecture, and how different optimization methods influence the overall performance. In this paper, we take the first step to analyze the impact of graph processing workload on disaggregated architecture by extending the GridGraph framework on top of the RDMA-based far memory system. We propose Fargraph+, a system with parallel graph data offloading and far memory coordination strategy for enhancing efficiency of graph processing workload on RDMA-based far memory architecture. Specifically, Fargraph+ reduces the overall data movement through a well-crafted, graph-aware data segment offloading mechanism. In addition, we use optimal data segment splitting and asynchronous data buffering to achieve graph iteration-friendly far memory access. We further configure efficient parallelism-oriented control to accelerate performance of multi-threading processing on graph iterations while improving memory efficiency of far memory access by utilizing RDMA queue features. We show that Fargraph+ achieves near-oracle performance for typical in-local-memory graph processing systems. Fargraph+ shows up to 11.2× speedup compared to Fastswap, the state-of-the-art, general-purpose far memory platform. • Graph programs demand large memory capacity and higher performance on disaggregated architecture. • Fargraph+ optimizes the execution to run graph applications on RDMA-based far memory in parallel efficiently. • The smart graph-aware data segment grouping and splitting method achieves better effectiveness by flexible data offloading. • The adaptive far memory interaction improves performance of graph iterations by buffering the transferred data carefully. • Parallelism control of multi-threaded graph iterations and RDMA shared-resource queues optimizes overall memory efficiency. [ABSTRACT FROM AUTHOR]

Even with Network Function Virtualization (NFV), many commodity network servers have spare cycles. Despite that they are small and irregularly occur, spare cycles are fit for deploying short-lived serverless computing functions at the network edge. In this work, we perform detailed analyses of the benefits and limitations of co-locating serverless functions on NFV-ready servers. We propose NEMO, a novel platform that enables efficient serverless edge function deployment in the NFV environment. NEMO can intelligently harvest spare cycles of network functions to warm up the serverless functions and speed up the function invocation in an agile manner. Besides, NEMO can judiciously manage the thread conflict in a resource-limited environment. We build a prototype of NEMO. Our thorough evaluations show that NEMO can harvest up to 41% spare cycles and achieve about 12.5 $\sim$ ∼ 25X performance improvement compared with straightforward co-location. [ABSTRACT FROM AUTHOR]

User-facing services are now evolving towards the microservice architecture where a service is built by connecting multiple microservice stages. Since the entire service is heavy, the microservice architecture shows the opportunity to only offload some microservice stages to the edge devices that are close to the end users. However, emerging techniques often result in the violation of Quality-of-Service (QoS) of microservice-based services in cloud-edge continuum, as they do not consider the communication overhead or the resource contention between microservices and external co-located tasks. We propose Nautilus, a runtime system that effectively deploys microservice-based user-facing services in cloud-edge continuum. Nautilus ensures the QoS of microservice-based user-facing services while minimizing the required computational resources, which is comprised of a communication-aware microservice mapper, a contention-aware resource manager and an IO-sensitive and load-aware microservice migration scheduler. The mapper divides the microservice graph into multiple partitions based on the communication overhead and maps the partitions to appropriate nodes. On each node, the resource manager determines the optimal resource allocation for its microservices based on reinforcement learning that may capture the complex contention behaviors. Once the microservices are suffered from external IO pressure, the IO-sensitive microservice scheduler migrates the critical one to idle nodes. Furthermore, when the load of microservices changes dynamically, the load-aware microservice scheduler migrates microservices from busy nodes to idle ones to ensure the QoS goal of the entire service. Our experimental results show that Nautilus can guarantee the required QoS target under external shared resources contention while the state-of-the-art suffers from QoS violations. Meanwhile, Nautilus reduces the computational resource usage by 23.9% and the network bandwidth usage by 53.4%, while achieving the required 99%-ile latency. [ABSTRACT FROM AUTHOR]

Datacenters use GPUs to provide the significant computing throughput required by emerging user-facing services. The diurnal user access pattern of user-facing services provides a strong incentive to co-located applications for better GPU utilization, and prior work has focused on enabling co-location on multicore processors and traditional non-preemptive GPUs. However, current GPUs are evolving towards spatial multitasking and introduce a new set of challenges to eliminate QoS violations. To address this open problem, we explore the underlying causes of QoS violation on spatial multitasking GPUs. In response to these causes, we propose C-Laius, a runtime system that carefully allocates the computation resource to co-located applications for maximizing the throughput of batch applications while guaranteeing the required QoS of user-facing services. C-Laius not only allows co-locating one user-facing application with multiple batch applications, but also supports the co-location of multiple user-facing applications with batch applications. In the case of a single co-located user-facing application, our evaluation on an Nvidia RTX 2080Ti GPU shows that C-Laius improves the utilization of spatial multitasking GPUs by 20.8 percent, while achieving the 99%-ile latency target for user-facing services. As to the case of multiple co-located user-facing applications, C-Laius ensures no violation of QoS while improving the accelerator utilization by 35.9 percent on average. [ABSTRACT FROM AUTHOR]

Aggregate nearest neighbor (Ann) query in both the euclidean space and road networks has been extensively studied, and the flexible aggregate nearest neighbor (Fann) problem further generalizes Ann by introducing an extra flexibility parameter $\phi$ ϕ that ranges in $(0, 1]$ (0 , 1 ] . In this article, we focus on Fann on road networks, denoted as Fann $_\mathcal {R}$ R , and its keyword-aware variant, denoted as KFann $_\mathcal {R}$ R . To solve these problems, we propose a series of universal (i.e., suitable for both max and sum) algorithms, including a Dijkstra-based algorithm that enumerates $P$ P instead of $\phi |Q|$ ϕ | Q | -combinations of $Q$ Q , a queue-based approach that processes data points from-near-to-far, and a framework that combines incremental euclidean restriction (IER) and $k$ k NN. We also propose a specific exact solution to max-Fann $_\mathcal {R}$ R and a constant-factor ratio approximate solution to sum-Fann $_\mathcal {R}$ R . These specific algorithms are easy to implement and can achieve excellent performance in some scenarios. Besides, we further extend this problem to top- $k$ k and multiple Fann $_\mathcal {R}$ R (resp., KFann $_\mathcal {R}$ R ) queries. We conduct a comprehensive experimental evaluation for the proposed algorithms on real datasets to demonstrate their superior efficiency and high quality. [ABSTRACT FROM AUTHOR]

In this paper our main purpose is to give molecular solutions for the subset-sum problem. In order to achieve this, we propose a DNA-based algorithm of an n-bit parallel adder and a DNA-based algorithm of an n-bit parallel comparator to formally verify our designed molecular solutions for the subset-sum problem. [Copyright &y& Elsevier]

With the rapid technological growth in the last decades, the number of devices and users has drastically increased. Software-defined networking (SDN) with machine learning (ML) has become an emerging solution for network scheduling, quality of service (QoS), resource allocations, and security. This paper focuses on the implementation of a network traffic classifier using a novel Docker-based SDN network. ML offers good performance to real-time traffic solutions without depending on well-known TCP or UDP port numbers, IP addresses, or encrypted payloads. In this paper, using three ML techniques, we first classify network flows with 3, 5, and 7 parameters giving up to 97.14% accuracy. Additionally, we present a new performance accelerator algorithm (PAA), which incorporates these three ML classifiers and accelerates the overall performance significantly. We then propose a dynamic network classifier (DNC) generated from PAA over a novel Docker-based SDN network. Finally, we propose a new controller algorithm for Ryu platforms, which integrates the DNC and classifies both TCP and UDP flows in real-time. Based on the evaluations, an improvement in latency performance has been demonstrated, where analysing a packet, controller processing time takes on an average of 10 µs. This study will certainly serve to further research on optimising SDN and QoS. [ABSTRACT FROM AUTHOR]

We aim to tackle existing problems about deep learning serving on GPUs in the view of the system. GPUs have been widely adopted to serve online deep learning-based services that have stringent QoS(Quality-of-Service) requirements. However, emerging deep learning serving systems often result in poor responsiveness and low throughput of the inferences that damage user experience and increase the number of GPUs required to host an online service. Our investigation shows that the poor batching operation and the lack of data transfer-computation overlap are the root causes of the poor responsiveness and low throughput. To this end, we propose E $^2$ 2 bird, a deep learning serving system that is comprised of a GPU-resident memory pool, a multi-granularity inference engine, and an elastic batch scheduler. The memory pool eliminates the unnecessary waiting of the batching operation and enables data transfer-computation overlap. The inference engine enables concurrent execution of different batches, improving the GPU resource utilization. The batch scheduler organizes inferences elastically to guarantee the QoS. Our experimental results on an Nvidia Titan RTX GPU show that E $^2$ 2 bird reduces the response latency of inferences by up to 82.4 percent and improves the throughput by up to 62.8 percent while guaranteeing the QoS target compared with TensorFlow Serving. [ABSTRACT FROM AUTHOR]

The parameter server architecture has shown promising performance advantages when handling deep learning (DL) applications. One crucial issue in this regard is the presence of stragglers, which significantly retards DL training progress. Previous solutions for solving stragglers may not fully exploit the computation resource of the cluster as evidenced by our experiments, especially in the heterogeneous environment. This motivates us to design a heterogeneity-aware parameter server paradigm that addresses stragglers and accelerates DL training from the perspective of computation parallelism. We introduce a novel methodology named straggler projection to give a comprehensive inspection of stragglers and reveal practical guidelines to solve this problem in two aspects: (1) controlling each worker's training speed via elastic training parallelism control and (2) transferring blocked tasks from stragglers to pioneers to fully utilize the computation resource. Following these guidelines, we propose the abstraction of parallelism as an infrastructure and design the Elastic-Parallelism Synchronous Parallel (EPSP) algorithm to handle distributed training and parameter synchronization, supporting both enforced- and slack-synchronization schemes. The whole idea has been implemented into a prototype called Falcon which effectively accelerates the DL training speed with the presence of stragglers. Evaluation under various benchmarks with baseline comparison demonstrates the superiority of our system. Specifically, Falcon reduces the training convergence time, by up to 61.83, 55.19, 38.92, and 23.68 percent shorter than FlexRR, Sync-opt, ConSGD, and DynSGD, respectively. [ABSTRACT FROM AUTHOR]

In recent years, spatial-keyword queries have attracted much attention with the fast development of location-based services. However, current spatial-keyword techniques are disk-based, which cannot fulfill the requirements of high throughput and low response time. With the surging data size, people tend to process data in distributed in-memory environments to achieve low latency. In this paper, we present the distributed solution, i.e., Skia (Spatial-Keyword In-memory Analytics), to provide a scalable backend for spatial-textual analytics. Skia introduces a two-level index framework for big spatial-textual data including: (1) efficient and scalable global index, which prunes the candidate partitions a lot while achieving small space budget; and (2) four novel local indexes, that further support low latency services for exact and approximate spatial-keyword queries. Skia can support common spatial-keyword queries via traditional SQL programming interfaces. The experiments conducted on large-scale real datasets have demonstrated the promising performance of the proposed indexes and our distributed solution. [ABSTRACT FROM AUTHOR]

Predicting performance degradation of a GPU application at co-location on a spatial multitasking GPU without prior application knowledge is essential in public Clouds. Prior work mainly targets CPU co-location, and is inaccurate and/or inefficient for predicting performance of applications at co-location on spatial multitasking GPUs. Our investigation shows that hardware event statistics caused by co-located applications strongly correlate with their slowdowns. Based on this observation, we present Themis with a kernel slowdown model (Themis-KSM), which performs precise and efficient online application slowdown prediction without prior application knowledge. The kernel slowdown model is trained offline. When new applications co-run, Themis-KSM collects event statistics and predicts their slowdowns simultaneously. In addition, we also propose a two-stage slowdown prediction mechanism (Themis-TSP) for real-system GPUs without any hardware modification. Our evaluation shows that Themis has negligible runtime overhead, and both Themis-KSM and Themis-TSP can precisely predict application-level slowdown with prediction error smaller than 9.5% and 12.8%, respectively. Based on Themis, we also implement an SM allocation engine to rein in application slowdown at co-location. Case studies show that the engine successfully enforces fair sharing and QoS. • Themis predicts and reins in application-level slowdown on spatial multitasking GPUs. • The kernel slowdown model (KSM) collects hardware event statistics by per-SM counters and predicts slowdown with a pre-trained neural network. • The two-stage slowdown prediction model (TSP) predicts slowdown on real-system GPUs, by using a two-stage piecewise function to approximate kernels' SM-IPC curves. • The SM allocation engine reins in application slowdown to fulfill user requirements such as fairness or QoS. [ABSTRACT FROM AUTHOR]

Big data analytics in datacenters often involve scheduling of data-parallel jobs. Traditional scheduling techniques based on improving network resource utilization are subject to limited bandwidth in datacenter networks. To alleviate the shortage of bandwidth, some cluster frameworks employ techniques of traffic compression to reduce transmission consumption. However, they tackle scheduling in a coarse-grained manner at task level and do not perform well in terms of flow-level metrics due to high complexity. Fortunately, the abstraction of coflow pioneers a new perspective to facilitate scheduling efficiency. In this paper, we introduce a coflow compression mechanism to minimize the completion time in data-intensive applications. Due to the NP-hardness, we propose a heuristic algorithm called Fastest-Volume-Disposal-First (FVDF) to solve this problem. For online applicability, FVDF supports stage pipelining to accelerate scheduling and exploits recurrent neural networks (RNNs) to predict compression speed. Meanwhile, we build ${\sf Swallow}$ Swallow , an efficient scheduling system that implements our proposed algorithms. It minimizes coflow completion time (CCT) while guaranteeing resource conservation and starvation freedom. The results of both trace-driven simulations and real experiments show the superiority of our algorithm, over existing one. Specifically, ${\sf Swallow}$ Swallow speeds up CCT and job completion time (JCT) by up to $1.47 \times$ 1. 47 × and $1.66 \times$ 1. 66 × on average, respectively, over the SEBF in Varys, one of the most efficient coflow scheduling algorithms so far. Moreover, with coflow compression, ${\sf Swallow}$ Swallow reduces data traffic by up to 48.41 percent on average. [ABSTRACT FROM AUTHOR]

Emerging data analytic workloads such as graph processing, neural network and edge data preprocesing desire efficient memory read operations. Unfortunately, due to the necessity of dynamic refresh, modern DRAM systems have to stall access during refresh cycles. As DRAM device density continues to grow, refresh operations can be a crucial throughput bottleneck. To fully unleash memory access performance, we revisit conventional refresh mechanism and DRAM architecture. We propose DR refresh, a specific refresh mechanism that enable read and refresh operations to be done simultaneously. We devise DR DRAM, a specific memory hardware system that can efficiently deploy DR refresh. Unlike traditional refresh, DR explores device refresh that only refreshes a designated device at a time. Meanwhile, DR increases read efficiency by recovering the inaccessible data that resides on a device under refreshing. We also propose Hybrid Refresh Main Memory (HRMM) which can designate refresh schemes (DR or traditional refresh) in a specific memory space. We expect that our design can benefit many real-life tasks such as SPEC CPU2006, CNN, LLT and PageRank. [ABSTRACT FROM AUTHOR]

The emergence of edge computing has witnessed a fast-growing volume of data on edge devices belonging to different stakeholders which, however, cannot be shared among them due to the lack of the trust. By exploiting blockchain’s non-repudiation and non-tampering properties that enable trust, we develop a blockchain-based big data sharing framework to support various applications across resource-limited edges. In particular, we devise a number of novel resource-efficient techniques for the framework: (1) the PoC (Proof-of-Collaboration) based consensus mechanism with low computation complexity which is especially beneficial to the edge devices with low computation capacity, (2) the blockchain transaction filtering and offloading scheme that can significantly reduce the storage overhead, and (3) new types of blockchain transaction (i.e., Express Transaction) and block (i.e., Hollow Block) to enhance the communication efficiency. Extensive experiments are conducted and the results demonstrate the superior performance of our proposal. [ABSTRACT FROM AUTHOR]

Video streaming, one of the most popular technologies for online video playback, has already been applied to 4G LTE networks. Previous work has been devoted to understanding the power consumption in general 4G LTE networks, while it is still unclear how the online video streaming makes impact on the power performance of mobile devices. Inspired by this, this paper investigates the relationship between the mobile device’s power performance characteristics and the behaviours of video streaming in 4G LTE networks. There are many natural issues/questions that are clearly interesting and important, while it is non-trivial to answer these issues/questions exactly (e.g., where is the energy saving room? how much is it?). To address a series of issues like the above, we formulate our energy models together with an algorithm that can assist our analysis. Particularly, we design a systematic platform, and conduct a comprehensive and also deep analysis on the power consumption of video streaming in 4G LTE networks. Our experiments reveal us a series of valuable findings—the saving room in the network part is large (from 41.86 to 69.62%), the number of RRC tails and the transmission pattern could be promising for optimizing the power consumption, for example. [ABSTRACT FROM AUTHOR]

Shortest path query is one of the most fundamental and classic problems in graph analytics, which returns the complete shortest path between any two vertices. However, in many real-life scenarios, only critical vertices on the shortest path are desirable and it is unnecessary to search for the complete path. This paper investigates the shortest path sketch by defining a top- $k$ critical vertices ($k$ CV) query on the shortest path. Given a source vertex $s$ and target vertex $t$ in a graph, $k$ CV query can return the top- $k$ significant vertices on the shortest path $SP(s,t)$ . The significance of the vertices can be predefined. The key strategy for seeking the sketch is to apply off-line preprocessed distance oracle to accelerate on-line real-time queries. This allows us to omit unnecessary vertices and obtain the most representative sketch of the shortest path directly. We further explore a series of methods and optimizations to answer $k$ CV query on both centralized and distributed platforms, using exact and approximate approaches, respectively. We evaluate our methods in terms of time, space complexity and approximation quality. Experiments on large-scale real-world networks validate that our algorithms are of high efficiency and accuracy. [ABSTRACT FROM AUTHOR]

Emerging recommender systems often adopt collaborative filtering techniques to improve the recommending accuracy. Existing collaborative filtering techniques are implemented with either alternating least square algorithm or gradient descent (GD) algorithm. However, both of the two algorithms are not scalable because ALS suffers from high computation complexity and GD suffers from severe synchronization problem and tremendous data movement. To solve the above problems, we proposed a Dataflow-based Collaborative Filtering (DCF) algorithm. More specifically, DCF exploits fine-grain asynchronous feature of dataflow model to minimize synchronization overhead; leverages mini-batch technique to reduce computation and communication complexities; uses dummy edge and multicasting techniques to avoid fine-grain overhead of dependency checking and reduce data movement. By utilizing all the above techniques, DCF is able to significantly improve the performance of collaborative filtering. Our experiment on a cluster with one master node and ten slave nodes show that DCF achieves 23× speedup over ALS on Spark and 18× speedup over GD on Graphlab in public datasets. [ABSTRACT FROM AUTHOR]

Carbon nanotube field effect transistor (CNFET), using the carbon nanotubes (CNTs) as the material for conducting, is a promising alternative of CMOS technology to overcome the “power wall” issue. Recently, a microprocessor solely based on CNFETs was fabricated and demonstrated, which is a big step forward to the industrial practice. However, CNFETs are inherently subject to much larger process variation or manufacturing defects; thereby it may cause significant design cost to build high performance processors. This is exacerbated in the large register file (RF) architectures widely used in single instruction multiple data (SIMD) architectures, e.g., general public utilities style processors, where the number of critical paths are multiplied by the SIMD width and thread count. In this paper, we seek cost-effective approaches to address the issues by judiciously exploiting the strong asymmetric spatial correlation in the variation unique to the CNFET fabrication process. This paper presents a microarchitectural model to characterize CNFET delay variation and malfunction, under which we show that the RF organizations coupled with the architectural schemes are critical to the performance and power consumption of the SIMD processor. Therefore, we propose several architectural techniques to mitigate the performance degradation and the impact of CNT metallization, leveraging the distinctive CNFET characteristics and the unique features in the SIMD processors. Experimental results verify the effectiveness of the proposed techniques and demonstrate the great opportunity offered by this new device technology. [ABSTRACT FROM AUTHOR]

Wi-Fi channel state information (CSI) provides adequate information for recognizing and analyzing human activities. Because of the short distance and low transmit power of Wi-Fi communications, people usually deploy multiple access points (APs) in a small area. Traditional Wi-Fi CSI-based human activity recognition methods adopt Wi-Fi CSI from a single AP, which is not very appropriate for a high-density Wi-Fi environment. In this article, we propose a learning method that analyzes the CSI of multiple APs in a small area to detect and recognize human activities. We introduce a deep learning model to process complex and large CSI from multiple APs. From extensive experiment results, our method performs better than other solutions in a given environment where multiple Wi-Fi APs exist. [ABSTRACT FROM PUBLISHER]

Crowdsourcing allows requesters to allocate tasks to a group of workers on the Internet to make use of their collective intelligence. Quality control is a key design objective in incentive mechanisms for crowdsourcing as requesters aim at obtaining high-quality answers under a limited budget. However, when measuring workers’ long-term quality, existing mechanisms either fail to utilize workers’ historical information, or treat workers’ quality as stable and ignore its temporal characteristics, hence performing poorly in a long run. In this paper we propose MeLoDy, a long-term dynamic quality-aware incentive mechanism for crowdsourcing. MeLoDy models interaction between requesters and workers as reverse auctions that run continuously. In each run of MeLoDy, we design a truthful, individual rational, budget feasible and quality-aware algorithm for task allocation with polynomial-time computation complexity and $O(1)$ performance ratio. Moreover, taking into consideration the long-term characteristics of workers’ quality, we propose a novel framework in MeLoDy for quality inference and parameters learning based on Linear Dynamical Systems at the end of each run, which takes full advantage of workers’ historical information and predicts their quality accurately. Through extensive simulations, we demonstrate that MeLoDy outperforms existing work in terms of both quality estimation (reducing estimation error by $17.6\% \sim 24.2\%$ ) and social performance (increasing requester's utility by $18.2\% \sim 46.6\%$) in long-term scenarios. [ABSTRACT FROM AUTHOR]

The boundaries of conic polygons consist of conic segments or second degree curves. The conic polygon has two degenerate or special cases: the linear polygon and the circular-arc polygon. The natural problem–Boolean operations on linear polygons–has been extensively studied. Surprisingly, (almost) no article focuses on the problem of Boolean operations on circular-arc polygons , yet this potentially has many applications. This implies that if there is a targeted solution for Boolean operations on circular-arc polygons, it should be favourable for potential users. In this article, we close the gap by devising a concise data structure and then developing a targeted algorithm called R e2l . Our method is simple, easy-to-implement, but without loss of efficiency. Given two circular-arc polygons with m and n edges respectively, our method runs in O ( m + n + ( l + k ) log l ) time, using O ( m + n + k ) space, where k is the number of intersections, and l is the number of related edges (defined in Section 5 ). Our algorithm has the power to approximate to linear complexity when k and l are small. The superiority of the proposed algorithm is also validated through empirical study. In particular, our method is of independent interest and we show that it can be easily extended to compute Boolean operations of other types of polygons. [ABSTRACT FROM AUTHOR]

The popularity of mobile devices, especially intelligent mobile phones, significantly prompt various location-based services (LBSs) in cloud systems. These services not only greatly facilitate people's daily lives, but also cause serious threats that users' location information may be misused or leaked by service providers. The dummy-based privacy protection techniques have significant advantages over others because they neither rely on trusted servers nor need adequate number of trustworthy peers. Existing dummy-based location privacy protection schemes, however, cannot yet provide long-term privacy protection. In this paper, we propose four principles for the dummy-based long-term location privacy protection (LT-LPP). Based on the principles, we propose a set of long-term consistent dummy generation algorithms for the LT-LPP. Our approach is built on soft computing techniques and can balance the preferred privacy protection and computing cost. Comprehensive experimental results demonstrate that our approach is effective to both long-term privacy protection and fake path generation for LBSs in mobile clouds. [ABSTRACT FROM AUTHOR]

Cyber-physical systems (CPSs) have recently become an important research field not only because of their important and varied application scenarios, including transportation systems, smart homes, surveillance systems, and wearable devices but also because the fundamental infrastructure has yet to be well addressed. Wireless sensor networks (WSNs), as a type of supporting infrastructure, play an irreplaceable role in CPS design. Specifically, secure communication in WSNs is vital because information transferred in the networks can be easily stolen or replaced. Therefore, this paper presents a novel distributed low-storage clone detection protocol (LSCD) for WSNs. We first design a detection route along the perpendicular direction of a witness path with witness nodes deployed in a ring path. This ensures that the detection route must encounter the witness path because the distance between any two detection routes must be smaller than the witness path length. In the LSCD protocol, clone detection is processed in a nonhotspot region where a large amount of energy remains, which can improve energy efficiency as well as network lifetime. Extensive simulations demonstrate that the lifetime, storage requirements, and detection probability of our protocol are substantially improved over competing solutions from the literature. [ABSTRACT FROM AUTHOR]

DDoS attack source traceback is an open and challenging problem. Deterministic packet marking (DPM) is a simple and effective traceback mechanism, but the current DPM based traceback schemes are not practical due to their scalability constraint. We noticed a factor that only a limited number of computers and routers are involved in an attack session. Therefore, we only need to mark these involved nodes for traceback purpose, rather than marking every node of the Internet as the existing schemes doing. Based on this finding, we propose a novel marking on demand (MOD) traceback scheme based on the DPM mechanism. In order to traceback to involved attack source, what we need to do is to mark these involved ingress routers using the traditional DPM strategy. Similar to existing schemes, we require participated routers to install a traffic monitor. When a monitor notices a surge of suspicious network flows, it will request a unique mark from a globally shared MOD server, and mark the suspicious flows with the unique marks. At the same time, the MOD server records the information of the marks and their related requesting IP addresses. Once a DDoS attack is confirmed, the victim can obtain the attack sources by requesting the MOD server with the marks extracted from attack packets. Moreover, we use the marking space in a round-robin style, which essentially addresses the scalability problem of the existing DPM based traceback schemes. We establish a mathematical model for the proposed traceback scheme, and thoroughly analyze the system. Theoretical analysis and extensive real-world data experiments demonstrate that the proposed traceback method is feasible and effective. [ABSTRACT FROM AUTHOR]

The MapReduce programming model simplifies large-scale data processing on commodity cluster by exploiting parallel map tasks and reduce tasks. Although many efforts have been made to improve the performance of MapReduce jobs, they ignore the network traffic generated in the shuffle phase, which plays a critical role in performance enhancement. Traditionally, a hash function is used to partition intermediate data among reduce tasks, which, however, is not traffic-efficient because network topology and data size associated with each key are not taken into consideration. In this paper, we study to reduce network traffic cost for a MapReduce job by designing a novel intermediate data partition scheme. Furthermore, we jointly consider the aggregator placement problem, where each aggregator can reduce merged traffic from multiple map tasks. A decomposition-based distributed algorithm is proposed to deal with the large-scale optimization problem for big data application and an online algorithm is also designed to adjust data partition and aggregation in a dynamic manner. Finally, extensive simulation results demonstrate that our proposals can significantly reduce network traffic cost under both offline and online cases. [ABSTRACT FROM PUBLISHER]