Reduce Memory Consumption Research Articles

A Program Optimization Method for Embedded Software Developed Using Open Sources

Program optimization or software optimization is the process of modifying a software system to make some aspect of it work more efficiently or use fewer resources. When developing software for embedded systems, open source libraries are usually used. An Embedded software built using a variety of open software and libraries is apt to have too many unused codes because open source libraries contain many functions and features to be used in various applications. In this paper, we describe the process of a library optimization method to reduce memory consumption for the user interface software of a set-top box product. The overall optimization process uses freeware tools developed for the Linux operating system. We devised an optimization technique to compensate for operation imperfections in the target system. The original Qt library of 19.57 MB was optimized to be 7.26 MB in program image size. In the case of the DirectFB library, 3.2 MB was reduced to 2.4 MB. The optimization process can be applied to any embedded software that are developed with open source libraries or sources.

Layer-Centric Memory Reuse and Data Migration for Extreme-Scale Deep Learning on Many-Core Architectures

Due to the popularity of Deep Neural Network (DNN) models, we have witnessed extreme-scale DNN models with the continued increase of the scale in terms of depth and width. However, the extremely high memory requirements for them make it difficult to run the training processes on single many-core architectures such as a Graphic Processing Unit (GPU), which compels researchers to use model parallelism over multiple GPUs to make it work. However, model parallelism always brings very heavy additional overhead. Therefore, running an extreme-scale model in a single GPU is urgently required. There still exist several challenges to reduce the memory footprint for extreme-scale deep learning. To address this tough problem, we first identify the memory usage characteristics for deep and wide convolutional networks, and demonstrate the opportunities for memory reuse at both the intra-layer and inter-layer levels. We then present Layrub, a runtime data placement strategy that orchestrates the execution of the training process. It achieves layer-centric reuse to reduce memory consumption for extreme-scale deep learning that could not previously be run on a single GPU. Experiments show that, compared to the original Caffe, Layrub can cut down the memory usage rate by an average of 58.2% and by up to 98.9%, at the moderate cost of 24.1% higher training execution time on average. Results also show that Layrub outperforms some popular deep learning systems such as GeePS, vDNN, MXNet, and Tensorflow. More importantly, Layrub can tackle extreme-scale deep learning tasks. For example, it makes an extra-deep ResNet with 1,517 layers that can be trained successfully in one GPU with 12GB memory, while other existing deep learning systems cannot.

A co-located partitions strategy for parallel CFD–DEM couplings

In this work, a new partition-collocation strategy for the parallel execution of CFD–DEM couplings is investigated. Having a good parallel performance is a key issue for an Eulerian-Lagrangian software that aims to be applied to solve industrially significant problems, as the computational cost of these couplings is one of their main drawback. The approach presented here consists in co-locating the overlapping parts of the simulation domain of each software on the same MPI process, in order to reduce the cost of the data exchanges. It is shown how this strategy allows reducing memory consumption and inter-process communication between CFD and DEM to a minimum and therefore to overcome an important parallelization bottleneck identified in the literature. Four benchmarks are proposed to assess the consistency and scalability of this approach. A coupled execution on 280 cores shows that less than 0.1% of the time is used to perform inter-physics data exchange.

Efficient Indexing For Past and Current Position of Moving Objects on Road Networks

The ever-increasing volume of trajectories of moving objects and the diversity of intelligent transportation systems and location-based services that rely on spatio-temporal data of moving objects highlight the need for more efficient indexing techniques. The state-of-the-art methods index moving objects at three time modes of past (historical data), present, and future. An integrated method called “PCI” was proposed (past current indexing) to index and store spatial-temporal data of the past and present simultaneously. The method can handle queries in both the time modes and it processes and generates both the past and present indices using an integrated set of processing resources. Two interconnected data structures were utilized to store indices of both the time modes. Connecting the index of different time modes enforces efficiency challenges due to difference in updating costs. Since the method stores the indices in the main memory, the way the structures are connected to each other makes it possible to transfer the current data to the section responsible for historical data. This method indexes them in the trajectory of moving objects at a minimum time expense. As the quality of data inevitably affects the performance of applications, map matching methods was used in PCI to remove noises—e.g., stationary state noises—in the data received from the moving objects. This feature adds to the accuracy and reliability of query results. The effects of data reduction techniques on accelerating indexing, query processing, and reducing memory consumption (in voluminous data sets) were examined. Results of the comparisons, made based on the experiments, showed the higher efficiency of the indexing structure.

Hierarchical Cascading Algorithm for 2-D FEM Simulation of Finite SAW Devices.

Application of the finite-element method (FEM) for the simulation of surface acoustic wave (SAW) devices has been constrained by the large number of degrees of freedom required, resulting in large memory usage and long computation times. We propose a new 2-D algorithm that takes advantage of the periodic structure typical of SAW devices. The device is partitioned into small, repeatedly occurring building blocks. Only unique building blocks are simulated with FEM. The device geometry is presented as a hierarchical tree of cascading operations, where smaller blocks are combined into larger blocks. This is equivalent to the full FEM simulation of the device, implying the drastic reduction of memory consumption and simulation time for structures with a high degree of periodicity. The method is verified against FEM/BEM-based software. To ensure accurate and efficient simulation, the boundary conditions should be chosen according to the anisotropy of the substrate crystal.

Matrix-free weighted quadrature for a computationally efficient isogeometric [formula omitted]-method

The k-method is the isogeometric method based on splines (or NURBS, etc.) with maximum regularity. When implemented following the paradigms of classical finite element methods, the computational resources required by the k-method are prohibitive even for moderate degree. In order to address this issue, we propose a matrix-free strategy combined with weighted quadrature, which is an ad-hoc strategy to compute the integrals of the Galerkin system. Matrix-free weighted quadrature (MF-WQ) speeds up matrix operations, and, perhaps even more important, greatly reduces memory consumption. Our strategy also requires an efficient preconditioner for the linear system iterative solver. In this work we deal with an elliptic model problem, and adopt a preconditioner based on the Fast Diagonalization method, an old idea to solve Sylvester-like equations. Our numerical tests show that the isogeometric solver based on MF-WQ is faster than standard approaches (where the main cost is the matrix formation by standard Gaussian quadrature) even for low degree. But the main achievement is that, with MF-WQ, the k-method gets orders of magnitude faster by increasing the degree, given a target accuracy. Therefore, we are able to show the superiority, in terms of computational efficiency, of the high-degree k-method with respect to low-degree isogeometric discretizations. What we present here is applicable to more complex and realistic differential problems, but its effectiveness will depend on the preconditioner stage, which is as always problem-dependent. This situation is typical of modern high-order methods: the overall performance is mainly related to the quality of the preconditioner.

Mining Precise-Positioning Episode Rules from Event Sequences

Episode Rule Mining is a popular framework for discovering sequential rules from event sequential data. However, traditional episode rule mining methods only tell that the consequent event is likely to happen within a given time interval after the occurrence of the antecedent events. As a result, they cannot satisfy the requirement of many time sensitive applications, such as program security trading and intelligent transportation management due to the lack of fine-grained response time. In this study, we come up with the concept of fixed-gap episode to address this problem. A fixed-gap episode consists of an ordered set of events where the elapsed time between any two consecutive events is a constant. Based on this concept, we formulate the problem of mining precise-positioning episode rules in which the occurrence time of each event in the consequent is clearly specified. In addition, we develop a trie-based data structure to mine such precise-positioning episode rules with several pruning strategies incorporated for improving the performance as well as reducing memory consumption. Experimental results on real datasets show the superiority of our proposed algorithms.

Layrub

Growing accuracy and robustness of Deep Neural Networks (DNN) models are accompanied by growing model capacity (going deeper or wider). However, high memory requirements of those models make it difficult to execute the training process in one GPU. To address it, we first identify the memory usage characteristics for deep and wide convolutional networks, and demonstrate the opportunities of memory reuse on both intra-layer and inter-layer levels. We then present Layrub, a runtime data placement strategy that orchestrates the execution of training process. It achieves layer-centric reuse to reduce memory consumption for extreme-scale deep learning that cannot be run on one single GPU.

Data decomposition method for full-core Monte Carlo transport–burnup calculation

Monte Carlo transport simulations of a full-core reactor with a high-fidelity structure have been made possible by modern-day computing capabilities. Performing transport–burnup calculations of a full-core model typically includes millions of burnup areas requiring hundreds of gigabytes of memory for burnup-related tallies. This paper presents the study of a parallel computing method for full-core Monte Carlo transport–burnup calculations and the development of a thread-level data decomposition method. The proposed method decomposes tally accumulators into different threads and improves the parallel communication pattern and memory access efficiency. A typical pressurized water reactor burnup assembly along with the benchmark for evaluation and validation of reactor simulations model was used to test the proposed method. The result indicates that the method effectively reduces memory consumption and maintains high parallel efficiency.

Fast Adjustable Threshold for Uniform Neural Network Quantization

Neural network quantization procedure is the necessary step for porting of neural networks to mobile devices. Quantization allows accelerating the inference, reducing memory consumption and model size. It can be performed without fine-tuning using calibration procedure (calculation of parameters necessary for quantization), or it is possible to train the network with quantization from scratch. Training with quantization from scratch on the labeled data is rather long and resource-consuming procedure. Quantization of network without fine-tuning leads to accuracy drop because of outliers which appear during the calibration. In this article we suggest to simplify the quantization procedure significantly by introducing the trained scale factors for quantization thresholds. It allows speeding up the process of quantization with fine-tuning up to 8 epochs as well as reducing the requirements to the set of train images. By our knowledge, the proposed method allowed us to get the first public available quantized version of MNAS without significant accuracy reduction - 74.8% vs 75.3% for original full-precision network. Model and code are ready for use and available at: this https URL.

Design and Implementation of Distributed Crawler System Based on Scrapy

At present, some large-scale search engines at home and abroad only provide users with non-custom search services, and a single-machine web crawler cannot sovle the difficult task. In this paper, Through the study and research of the original Scrapy framework, the original Scrapy framework is improved by combining Scrapy and Redis, a distributed crawler system based on Web information Scrapy framework is designed and implemented, and Bloom Filter algorithm is applied to dupefilter modul to reduce memory consumption. The movie information captured from douban is stored in MongoDB, so that the data can be processed and analyzed. The results show that distributed crawler system based on Scrapy framework is more efficient and stable than the single-machine web crawler system.

Improving adaptive frameless rendering

By eliminating the rigid sampling patterns of framed renderers and adapting sampling and reconstruction to spatio-temporal changes, combined with sample reprojection, adaptive frameless rendering offers significant potential to generate coherent imagery from sparse set of samples in real-time rendering systems. It capitalizes on the unique feature of ray-based rendering methods the ability to select where to render along with when to render, which is missing in traditional double buffered renderings. With its unique contribution of adaptive partial update of display it has applications in rendering, display, and imaging systems. In this work, we propose alternate data structures and modified algorithms to reduce memory consumption by more than 90%, reduce computation overheads by approximately 50%, and improve sampler response to regions of change by modifying sampling pattern and tracking temporal changes in 3D space, improving the quality of rendering.

Patch-based self-adaptive matting for high-resolution image and video

We propose an efficient patch-based self-adaptive matting approach to reduce memory consumption in processing high-resolution image and video. Most existing image matting techniques employ a global optimization over the whole set of image pixels, incurring a prohibitively high memory consumption, especially in high-resolution images. Inspired by “divide-and-conquer,” we divide the images into small patches in a self-adaptive way according to the distribution of unknown pixels and handle the small patches one by one. The alpha mattes in patch level are combined according to the weights. Relationships between patches are also considered by locally linear embedding to maintain consistency through the whole image. We also extend the framework to video matting with considering the temporal coherence of alpha mattes. A sampling method is applied to speed up the operation of video sampling. A multi-frame graph model is also proposed to enhance temporal and spatial consistency which can be solved efficiently by Random Walk. Experimental results show that the proposed method significantly reduces memory consumption while maintaining high-fidelity matting results on the benchmark dataset.

Statisticum

We introduce a new concept of leveraging traditional data statistics as dynamic data integrity constraints. These data statistics produce transient database constraints, which are valid as long as they can be proven to be consistent with the current data. We denote this type of data statistics by constraint data statistics , their properties needed for consistency checking by consistency metadata , and their implied integrity constraints by implied data statistics constraints ( implied constraints for short). Implied constraints are valid integrity constraints which are powerful query optimization tools employed, just as traditional database constraints, in semantic query transformation (aka query reformulation), partition pruning, runtime optimization, and semi-join reduction, to name a few. To our knowledge, this is the first work introducing this novel and powerful concept of deriving implied integrity constraints from data statistics. We discuss theoretical aspects of the constraint data statistics concept and their integration into query processing. We present the current architecture of data statistics management in SAP HANA and detail how constraint data statistics are designed and integrated into this architecture. As an instantiation of this framework, we consider dynamic partition pruning for data aging scenarios. We discuss our current implementation for constraint data statistics objects in SAP HANA which can be used for dynamic partition pruning. We enumerate their properties and show how consistency checking for implied integrity constraints is supported in the data statistics architecture. Our experimental evaluations on the TPC-H benchmark and a real customer application confirm the effectiveness of the implied integrity constraints; (1) for 59% of TPC-H queries, constraint data statistics utilization results in pruning cold partitions and reducing memory consumption, and (2) we observe up to 3 orders of magnitude speed-up in query processing time, for a real customer running an S/4HANA application.

Ternary Sparse Matrix Representation for Volumetric Mesh Subdivision and Processing on GPUs

AbstractIn this paper, we present a novel volumetric mesh representation suited for parallel computing on modern GPU architectures. The data structure is based on a compact, ternary sparse matrix storage of boundary operators. Boundary operators correspond to the first‐order top‐down relations of k‐faces to their (k − 1)‐face facets. The compact, ternary matrix storage format is based on compressed sparse row matrices with signed indices and allows for efficient parallel computation of indirect and bottom‐up relations. This representation is then used in the implementation of several parallel volumetric mesh algorithms including Laplacian smoothing and volumetric Catmull‐Clark subdivision. We compare these algorithms with their counterparts based on OpenVolumeMesh and achieve speedups from 3× to 531×, for sufficiently large meshes, while reducing memory consumption by up to 36%.

A compressed representation for ray tracing parametric surfaces

Parametric surfaces are an essential modeling tool in computer aided design and movie production. Even though their use is well established in industry, generating ray-traced images adds significant cost in time and memory consumption. Ray tracing such surfaces is usually accomplished by subdividing the surfaces on the fly, or by conversion to a polygonal representation. However, on-the-fly subdivision is computationally very expensive, whereas polygonal meshes require large amounts of memory. This is a particular problem for parametric surfaces with displacement, where very fine tessellation is required to faithfully represent the shape. Hence, memory restrictions are the major challenge in production rendering. In this article, we present a novel solution to this problem. We propose a compression scheme for a priori Bounding Volume Hierarchies (BVHs) on parametric patches, that reduces the data required for the hierarchy by a factor of up to 48. We further propose an approximate evaluation method that does not require leaf geometry, yielding an overall reduction of memory consumption by a factor of 60 over regular BVHs on indexed face sets and by a factor of 16 over established state-of-the-art compression schemes. Alternatively, our compression can simply be applied to a standard BVH while keeping the leaf geometry, resulting in a compression rate of up to 2:1 over current methods. Although decompression generates additional costs during traversal, we can manage very complex scenes even on the memory restrictive GPU at competitive render times.

A Compressed Representation for Ray Tracing Parametric Surfaces

Parametric surfaces are an essential modeling tool in computer aided design and movie production. Even though their use is well established in industry, generating ray-traced images adds significant cost in time and memory consumption. Ray tracing such surfaces is usually accomplished by subdividing the surfaces on the fly, or by conversion to a polygonal representation. However, on-the-fly subdivision is computationally very expensive, whereas polygonal meshes require large amounts of memory. This is a particular problem for parametric surfaces with displacement, where very fine tessellation is required to faithfully represent the shape. Hence, memory restrictions are the major challenge in production rendering. In this article, we present a novel solution to this problem. We propose a compression scheme for a priori Bounding Volume Hierarchies (BVHs) on parametric patches, that reduces the data required for the hierarchy by a factor of up to 48. We further propose an approximate evaluation method that does not require leaf geometry, yielding an overall reduction of memory consumption by a factor of 60 over regular BVHs on indexed face sets and by a factor of 16 over established state-of-the-art compression schemes. Alternatively, our compression can simply be applied to a standard BVH while keeping the leaf geometry, resulting in a compression rate of up to 2:1 over current methods. Although decompression generates additional costs during traversal, we can manage very complex scenes even on the memory restrictive GPU at competitive render times.

Scalable model exploration for model-driven engineering

Abstract Model-Driven Engineering (MDE) promotes the use of models to conduct all phases of software development in an automated way. However, for complex systems, these models may become large and unwieldy, and hence difficult to process and comprehend. In order to alleviate this situation, we combine model fragmentation strategies – to split models into more manageable chunks – with model abstraction and visualisation mechanisms, able to provide simpler views of the models. In this paper, we describe the underlying methods and techniques, as well as the supporting tools. The feasibility and benefits of our approach are confirmed based on evaluations in the embedded systems, and the reverse engineering domains, where large benefits in terms of visualisation time (speeds up of up to 55 × ), and reduction in memory consumption (reduction of 97%) are obtained.

Improving the performance of minimizers and winnowing schemes.

MotivationThe minimizers scheme is a method for selecting k-mers from sequences. It is used in many bioinformatics software tools to bin comparable sequences or to sample a sequence in a deterministic fashion at approximately regular intervals, in order to reduce memory consumption and processing time. Although very useful, the minimizers selection procedure has undesirable behaviors (e.g. too many k-mers are selected when processing certain sequences). Some of these problems were already known to the authors of the minimizers technique, and the natural lexicographic ordering of k-mers used by minimizers was recognized as their origin. Many software tools using minimizers employ ad hoc variations of the lexicographic order to alleviate those issues.ResultsWe provide an in-depth analysis of the effect of k-mer ordering on the performance of the minimizers technique. By using small universal hitting sets (a recently defined concept), we show how to significantly improve the performance of minimizers and avoid some of its worse behaviors. Based on these results, we encourage bioinformatics software developers to use an ordering based on a universal hitting set or, if not possible, a randomized ordering, rather than the lexicographic order. This analysis also settles negatively a conjecture (by Schleimer et al.) on the expected density of minimizers in a random sequence.Availability and ImplementationThe software used for this analysis is available on GitHub: https://github.com/gmarcais/minimizers.git.

A Modified Approach of OPTICS Algorithm for Data Streams

Data are continuously evolving from a huge variety of applications in huge volume and size. They are fast changing, temporally ordered and thus data mining has become a field of major interest. A mining technique such as clustering is implemented in order to process data streams and generate a set of similar objects as an individual group. Outliers generated in this process are the noisy data points that shows abnormal behavior compared to the normal data points. In order to obtain the clusters of pure quality outliers should be efficiently discovered and discarded. In this paper, a concept of pruning is applied on the stream optics algorithm along with the identification of real outliers, which reduces memory consumption and increases the speed for identifying potential clusters.