Reduce Memory Consumption Research Articles

SaberLDA

Latent Dirichlet Allocation (LDA) is a popular tool for analyzing discrete count data such as text and images. Applications require LDA to handle both large datasets and a large number of topics. Though distributed CPU systems have been used, GPU-based systems have emerged as a promising alternative because of the high computational power and memory bandwidth of GPUs. However, existing GPU-based LDA systems cannot support a large number of topics because they use algorithms on dense data structures whose time and space complexity is linear to the number of topics. In this paper, we propose SaberLDA, a GPU-based LDA system that implements a sparsity-aware algorithm to achieve sublinear time complexity and scales well to learn a large number of topics. To address the challenges introduced by sparsity, we propose a novel data layout, a new warp-based sampling kernel, and an efficient sparse count matrix updating algorithm that improves locality, makes efficient utilization of GPU warps, and reduces memory consumption. Experiments show that SaberLDA can learn from billions-token-scale data with up to 10,000 topics, which is almost two orders of magnitude larger than that of the previous GPU-based systems. With a single GPU card, SaberLDA is able to learn 10,000 topics from a dataset of billions of tokens in a few hours, which is only achievable with clusters with tens of machines before.

SaberLDA

Latent Dirichlet Allocation (LDA) is a popular tool for analyzing discrete count data such as text and images. Applications require LDA to handle both large datasets and a large number of topics. Though distributed CPU systems have been used, GPU-based systems have emerged as a promising alternative because of the high computational power and memory bandwidth of GPUs. However, existing GPU-based LDA systems cannot support a large number of topics because they use algorithms on dense data structures whose time and space complexity is linear to the number of topics. In this paper, we propose SaberLDA, a GPU-based LDA system that implements a sparsity-aware algorithm to achieve sublinear time complexity and scales well to learn a large number of topics. To address the challenges introduced by sparsity, we propose a novel data layout, a new warp-based sampling kernel, and an efficient sparse count matrix updating algorithm that improves locality, makes efficient utilization of GPU warps, and reduces memory consumption. Experiments show that SaberLDA can learn from billions-token-scale data with up to 10,000 topics, which is almost two orders of magnitude larger than that of the previous GPU-based systems. With a single GPU card, SaberLDA is able to learn 10,000 topics from a dataset of billions of tokens in a few hours, which is only achievable with clusters with tens of machines before.

SSA Transformations to Facilitate Type Inference in Dynamically Typed Code

In most dynamically typed languages, variables are created without declaring their type. This way of programming allows variable reuse, so that variables sometimes hold different dynamic types in the same scope. Besides, it is also common to use the same variable to hold different dynamic types, depending on the execution flow of the program. When dynamically typed code is compiled into Java and .Net, the dynamic variables are usually generated as Object references. The approach of declaring variables with the top type (e.g. Object in Java and .Net) requires unsafe and inefficient type casts and, sometimes, the use of reflection. We propose the use of SSA (Static Single Assignment) transformations to facilitate inferring the type of dynamically typed local variables. The approach has been included in an existing compiler for the .Net framework. The result is that dynamically typed code performs significantly better when the SSA transformations are used, and it outperforms C#. Our technique reduces memory consumption at runtime by 35%, but increases compilation time by 13%.

A New Approach to Reduce Memory Consumption in Lattice Boltzmann Method on GPU

A New Approach to Reduce Memory Consumption in Lattice Boltzmann Method on GPU

Improved direct radiation pattern estimation in FDTD

Application of direct radiation pattern estimation in finite difference time domain (FDTD) simulation environment as an alternative to cumbersome near-to-far field transformation is considered. With the proposed improvement, direct estimation of the radiation pattern from the field strength samples in FDTD method becomes significantly less sensitive to the antenna geometry and thus more applicable to practically relevant cases. The main idea is to use field samples taken at two different radii to account for antenna geometry. The samples are taken at radii that are as close as possible to the antenna but still not too close to spoil the correctness of the results. The introduced improvement, combined with multigrid simulation domain and higher order accuracy FDTD formulations, reduces the necessary size of the computational domain, which directly leads to reduced memory consumption and a smaller error due to numerical dispersion.

An SRAM-based novel hardware architecture for longest prefix matching for IP route lookup

A static random access memory (SRAM)-based novel hardware architecture for longest prefix match (LPM) search scheme has been proposed in this paper. The key concept of this architecture is to store the IP prefixes virtually in the forwarding table. This architecture reduces memory consumption by using a two-tier hierarchical SRAM-based memory structure for maintaining the next hop port information. Originally, next hop addresses are kept in the shared global memory called next hop global memory (NHGM) and its links are maintained in another memory, called next hop link memory (NHLM). This approximately reduces memory consumption by 50---62.5% compared to existing SRAM-based schemes. The proposed architecture consumes single memory write cycle to store an IP prefix and also takes single memory read cycle for LPM search. However, finding next hop information incurs two memory read cycles due to hierarchical next hop memory structure. The proposed scheme performs an LPM lookup operation in 1.05---1.31 ns in IPv4 and between 1.05 and 1.6 ns in IPv6. This results into LPM search throughput of 950 million lookups per second (MLPS) to 760 MLPS in IPv4 and between 620 and 950 MLPS in IPv6. The average search throughput achievable from this architecture is roughly 850 MLPS in IPv4 and 780 MLPS in IPv6. The numerical results show that this architecture significantly reduces memory requirement, power consumption, and transistor-count/bit requirement.

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.

N-FIB: Scalable, memory efficient name-based forwarding

Named Data Networking (NDN) is a promising future Internet which retrieves the content using their names. Content names composed of strings separated by ‘/’ are stored in the NDN Forwarding Information Base (FIB) to forward the incoming packets further. Though NDN has several benefits over traditional IP-based Internet, storing names instead of IP addresses has two major bottlenecks. While it consumes significantly large memory, it incurs higher search and update time. Another issue is the fast growth of routing table size through which FIB will not fit in existing routers’ line-card memory. Moreover, frequent updates to the FIB can degrade the packet delivery performance. In this paper, we propose a scalable and memory efficient Patricia trie based name forwarding scheme (called, N-FIB) for FIB. N-FIB supports FIB aggregation to significantly minimize the impact of large FIB size and high FIB update cost. Extensive experiment results show that the N-FIB scheme can reduce memory consumption by 68.18% compared to the BP scheme for 29 million named dataset. Moreover, N-FIB is reducing routers’ computation and memory overhead, while supporting strong forwarding correctness.

Development of sensitivity analysis capabilities of generalized responses to nuclear data in Monte Carlo code RMC

Capabilities for nuclear data sensitivity and uncertainty analysis have been recently implemented in numerous continuous-energy Monte Carlo codes, including the Reactor Monte Carlo (RMC) code. Previous work developed the capability for RMC of computing sensitivity coefficients of the effective multiplication factor and related uncertainties, due to nuclear data. In this work, such capability was extended to generalized responses in the form of ratios of linear response functions of the forward flux based on the collision history-based approach as implemented in SERPENT2. The superhistory algorithm was also adopted in RMC to reduce memory consumption for generalized sensitivity calculations. These new capabilities of RMC were verified by comparing results of TSUNAMI-1D in SCALE6.1 code package, and SERPENT2 through Jezebel, Flattop and the UAM TMI PWR pin cell benchmark problems.

Large-scale solitary wave simulation with implicit incompressible SPH

Simultaneously tackling a large-scale simulation domain, high resolution, and a high level of incompressibility presents a computational challenge for smoothed-particle hydrodynamics. We present a method involving a combination of a recently developed implicit incompressible SPH scheme, a fluid-rigid boundary handling technique, and a data structure for neighborhood search to address the problem. We implemented the method on multi-core CPUs and performed simulations of tsunami wave impacts on coastal nuclear facilities to advance the state of the practice in probabilistic risk analysis modeling. Preliminary validation was conducted on a dam break problem test and a solitary wave past a conical island test. In addition to reduced memory consumption and the ability to handle arbitrarily large simulation domains, the technique exhibits fast simulation times. Performance of the method is evaluated for different parameter values related to time-stepping and neighborhood search, and several levels of resolution and incompressiblity enforcement. The results demonstrate its applicability for large-scale simulations relevant to ocean and coastal engineering, and, thereby, as a valuable tool for risk-informed decision-making related to external flooding events.

Code cache management in managed language VMs to reduce memory consumption for embedded systems

The compiled native code generated by a just-in-time (JIT) compiler in managed language virtual machines (VM) is placed in a region of memory called the code cache. Code cache management (CCM) in a VM is responsible to find and evict methods from the code cache to maintain execution correctness and manage program performance for a given code cache size or memory budget. Effective CCM can also boost program speed by enabling more aggressive JIT compilation, powerful optimizations, and improved hardware instruction cache and I-TLB performance. Though important, CCM is an overlooked component in VMs. We find that the default CCM policies in Oracle’s production-grade HotSpot VM perform poorly even at modest memory pressure. We develop a detailed simulation-based framework to model and evaluate the potential efficiency of many different CCM policies in a controlled and realistic, but VM-independent environment. We make the encouraging discovery that effective CCM policies can sustain high program performance even for very small cache sizes. Our simulation study provides the rationale and motivation to improve CCM strategies in existing VMs. We implement and study the properties of several CCM policies in HotSpot. We find that in spite of working within the bounds of the HotSpot VM’s current CCM sub-system, our best CCM policy implementation in HotSpot improves program performance over the default CCM algorithm by 39%, 41%, 55%, and 50% with code cache sizes that are 90%, 75%, 50%, and 25% of the desired cache size, on average.

Idle time garbage collection scheduling

Efficient garbage collection is increasingly important in today's managed language runtime systems that demand low latency, low memory consumption, and high throughput. Garbage collection may pause the application for many milliseconds to identify live memory, free unused memory, and compact fragmented regions of memory, even when employing concurrent garbage collection. In animation-based applications that require 60 frames per second, these pause times may be observable, degrading user experience. This paper introduces idle time garbage collection scheduling to increase the responsiveness of applications by hiding expensive garbage collection operations inside of small, otherwise unused idle portions of the application's execution, resulting in smoother animations. Additionally we take advantage of idleness to reduce memory consumption while allowing higher memory use when high throughput is required. We implemented idle time garbage collection scheduling in V8, an open-source, production JavaScript virtual machine running within Chrome. We present performance results on various benchmarks running popular webpages and show that idle time garbage collection scheduling can significantly improve latency and memory consumption. Furthermore, we introduce a new metric called frame time discrepancy to quantify the quality of the user experience and precisely measure the improvements that idle time garbage collection provides for a WebGL-based game benchmark. Idle time garbage collection is shipped and enabled by default in Chrome.

MultiBoost with ENN-based ensemble fault diagnosis method and its application in complicated chemical process

Fault diagnosis plays an important role in complicated industrial process. It is a challenging task to detect, identify and locate faults quickly and accurately for large-scale process system. To solve the problem, a novel MultiBoost-based integrated ENN (extension neural network) fault diagnosis method is proposed. Fault data of complicated chemical process have some difficult-to-handle characteristics, such as high-dimension, non-linear and non-Gaussian distribution, so we use margin discriminant projection(MDP) algorithm to reduce dimensions and extract main features. Then, the affinity propagation (AP) clustering method is used to select core data and boundary data as training samples to reduce memory consumption and shorten learning time. Afterwards, an integrated ENN classifier based on MultiBoost strategy is constructed to identify fault types. The artificial data sets are tested to verify the effectiveness of the proposed method and make a detailed sensitivity analysis for the key parameters. Finally, a real industrial system—Tennessee Eastman (TE) process is employed to evaluate the performance of the proposed method. And the results show that the proposed method is efficient and capable to diagnose various types of faults in complicated chemical process.

Supporting virtualization standard for network devices in RTEMS real-time operating system

The virtualization technology is attractive for modern embedded systems in that it can ideally implement resource partitioning but also can provide transparent software development environments. Although hardware emulation overheads for virtualization have been reduced significantly, the network I/O performance in virtual machine is still not satisfactory. It is very critical to minimize the virtualization overheads especially in real-time embedded systems, because the overheads can change the timing behavior of real-time applications. To resolve this issue, we aim to design and implement the device driver of the standardized virtual network device, called virtio, over RTEMS real-time operating system. Our virtio device driver can be portable across different Virtual Machine Monitors (VMMs) because our implementation is compliant with the standard. The measurement results clearly show that our virtio can achieve comparable performance to the virtio implemented in Linux while reducing memory consumption for network buffers.

Dynamic foreground detection based on improved Codebook model

Foreground detection method based on improved Codebook algorithm is discussed in this paper: first of all, transform RGB colour space into YCbCr colour space to make chromaticity convergent, and cope with illumination changing. Second, search for the CodeWords matching with the pixel values of the YCbCr to update the algorithm, so as to ensure the foreground detection effect. Then apply random abandon value method to delete the CodeWords that have not been accessed for a long time, reduce memory consumption and improve processing speed. Finally, conduct experiments on the infrared imagery and the colour image, respectively, to make foreground detection. The results demonstrate that the model and algorithm presented in this paper can make better foreground detection and reduce memory consumption. Meanwhile, compare this method with other algorithms to prove its advantages.

Radient: Scalable, memory efficient name lookup algorithm for named data networking

Named Data Networking (NDN) aims to discard the existing host-centric networking paradigm just to replace it with a more practical Content-Centric Networking (CCN) paradigm. CCN allows users to fetch and distribute contents directly using their names. NDN router stores all incoming content requests (׳/׳-delimited string components) in the Pending Interest Table (PIT) until they are satisfied. Multiple requests for the same content are merged in a single PIT entry and when the requested content is available, it is forwarded simultaneously to all the requesters. Although NDN has several benefits over the existing IP-based network, replacing IP addresses with names increases memory consumption and lookup cost. One possible way to restrict memory usage is to use name encoding, i.e., to encode identical components of a name with a unique integer. In this paper, we proposed a novel memory efficient name encoding scheme (called, Radient) for PIT and evaluated it extensively. Our results show that the Radient scheme can reduce memory consumption by 35.45% compared to the ENPT for 29 million names.

A distributed semantic filtering model based on approximate automata for heterogeneous multi-sensor networks

An increasing number of sensor networks are deployed to collect information on a wide range of applications. However, these sensor networks are isolated to each other. Meanwhile, processing large-scale of data stream is the neck of the push-mode system. To match the huge event stream in heterogeneous sensor network data, we propose approximation semantic factor ASR, according to which we further propose the approximately semantic matching model for heterogeneous multi-sensor networks called approximately semantic matching model for heterogeneous multi-sensor networks ASMMN. Furthermore, the evaluate pattern algorithm is put forward. ASMMN can effectively solve the semantic coupling and speed matching. Simulation results show that the proposed model can accelerate the matching process and reduce memory consumption of intermediate states among event streams. Meanwhile, the model has a good scalability that can be widely used in the heterogeneous push-mode sensor networks and internet of things IOTs.

A Hybrid 3DMLUV-FIA Method for Scattering from a 3D Dielectric Object above a 2D Dielectric Rough Surface

The electromagnetic scattering from the composite model of a three-dimensional (3D) dielectric object located above a two-dimensional (2D) dielectric rough surface is analyzed in this work. Poggio, Miller, Chang, Harrington, Wu, and Tsai (PMCHWT) integral equations are discretized by the method of moments (MoM) into a matrix which is solved by Biconjugate Gradients Stabilized (BICGSTAB) method. Method of 3DMLUV was used for PEC object located above rough surface. Comparing to the case when object and rough surface are both PEC, the memory requirement and computational complexity for dielectric models are increased due to doubled unknown number. Moreover, compared to dielectric object in free space, the coupling between dielectric object and dielectric rough surface will result in complicated numerical simulation. To solve this problem, the updated rank based 3D Multilevel UV (3DMLUV) method is employed to reduce memory consumption and CPU time overhead. The 3DMLUV has been successfully applied in the scattering of PEC targets; however, when the object or rough surface becomes dielectric, the coupling between dielectric object and dielectric rough surface will lead to slow constriction. Therefore, the Fast Iterative Approach (FIA) is applied to further speed up the constricted speed of the matrix required in 3DMLUV. The efficiency, stability, and accuracy of the proposed method are demonstrated in a variety of scattering problems.

CONSERT: Constructing optimal name-based routing tables

Name-based routing belongs to a routing category different from address-based routing, it is usually adopted by content-oriented networks [Sharma et al., 2014, Koponen et al., 2007, Rajahalme et al.,2011, Thaler et al.,1998, Hwang et al., 2010, Gritter et al., 2001, Caesar et al., 2006, Carzaniga et al., 2004, Koponen et al., 2007, Hwang et al., 2009 Singla et al., 2010, Detti et al., 2011, Jain et al., 2011 Xu et al., 2013, Katsaros et al., 2012. [1–15]] e.g., the recently proposed Named Data Networking (NDN). It populates routers with name-based routing tables, which are composed of name prefixesand their corresponding next hop(s). Name-based routing tables are believed to have much larger size than IP routing tables, because of the large amount of name prefixes and the unbounded length of each prefix. This paper presents CONSERT—an algorithm that, given an arbitrary name-based routing table as input, computes a routing table with the minimal number of prefixes, while keeping equivalent forwarding behavior. The optimal routing table also supports incremental update. We formulate the CONSERT algorithm and prove its optimality with an induction method. Evaluation results show that, CONSERT can reduce 18% to 45% prefixes in the synthetic routing tables depending on the distribution of the next hops, and meanwhile improve the lookup performance by more than 20%. Prior efforts usually focus on compact data structures and lookup algorithms so as to reduce memory consumption and expedite lookup speed of the routing table, while CONSERT compresses the routing table from another perspective: it removes the inherent “redundancy” in the routing table. Therefore, CONSERT is orthogonal to these prior efforts, thus the combination of CONSERT and a prior compressing method would further optimize the memory consumption and lookup speed of the routing table. E.g., we can first adopt CONSERT to achieve the optimal routing table, and afterwards apply NameFilter [Wang et al., 2013. [16], a two-stage-Bloom-filter method, to that optimal table. This combination diminishes the memory consumption of the routing table data structure by roughly 88%, and increases the lookup throughput by around 17% simultaneously. The joint method outperforms each individual method in terms of memory savings and absolute lookup throughout increase.

A research for plasma electromagnetic character using JEC-CN-FDTD algorithm based on ICCG method

For the first time, the current density convolution finite-difference time-domain (JEC-FDTD) method is extended to dispersive media using Crank–Nicolson difference scheme, and derive the one-dimensional JEC-CN-FDTD iterative equation of plasma. The incomplete Cholesky conjugate gradient (ICCG) is proposed to solve the large sparse matrix equation in the Crank–Nicolson finite-difference time-domain (CN-FDTD) method as the ICCG method improves speed of convergence, enhances stability and reduces memory consumption. The high accuracy and efficiency of the JEC-CN-FDTD method are confirmed by computing the characteristic parameters of electromagnetic wave through a collision plasma slab in one dimension, such as the reflection electric field, transmission electric field, magnitudes and phases of reflection coefficient and transmission coefficient. The results prove that the method performs stably, is of accuracy, and has certain advantages.