共查询到20条相似文献，搜索用时 15 毫秒
1.
We propose the use of generations with modern reference counting. A reference counting collector is well suited to collect the old generation, containing a large fraction of live objects that are modified infrequently. Such a collector can be combined with a tracing collector to collect the young generation, typically containing a small fraction of live objects. We have designed such a collector appropriate for running on a multiprocessor. As our building blocks, we used the sliding‐views on‐the‐fly collectors. We have implemented the new collector on the Jikes Research Java Virtual Machine (Jikes RVM) and compared it with the concurrent reference counting collector supplied with the Jikes RVM package. Our measurements demonstrate short pause times, retaining those of the original on‐the‐fly collectors and a gain in application throughput time. It turns out that a modern reference counting collector may benefit from the use of generations. Copyright © 2006 John Wiley & Sons, Ltd. 相似文献
2.
It is well accepted that automatic garbage collection simplifies programming, promotes modularity, and reduces development effort. However it is commonly believed that these advantages do not counteract the perceived price: excessive overheads, possible long pause times while garbage collections occur, and the need to modify existing code. Even though there are publically available garbage collector implementations that can be used in existing programs, they do not guarantee short pauses, and some modification of the application using them is still required. In this paper we describe a snapshot-at-beginning concurrent garbage collector algorithm and its implementation. This algorithm guarantees short pauses, and can be easily implemented on stock UNIX-like operating systems. Our results show that our collector performs comparable to other garbage collection implementations on uniprocessor machines and outperforms similar collectors on multiprocessor machines. We also show our collector to be competitive in performance with explicit deallocation. Our collector has the added advantage of being non-intrusive. Using a dynamic linking technique and effective root set inferencing, we have been able to successfully run our collector even in commercial programs where only the binary executable and no source code is available. In this paper we describe our algorithm, its implementation, and provide both an algorithmic and a performance comparison between our collector and other similar garbage collectors. ©1997 by John Wiley & Sons, Ltd. 相似文献
3.
4.
即时编译器辅助的垃圾收集技术结合显式和自动内存管理的优点,在编译阶段由即时编译器分析应用程序并在其中插桩显式释放内存的指令,以便垃圾收集器及时回收死亡对象所占用的内存空间,从而减轻垃圾收集器的负担.提出一种应用于该项技术的插桩算法,它基于控制流中的支配关系并提供不同的插桩策略,保证插桩的正确性和灵活性;它能够主动获得域引用从而释放对象及其域引用的内存空间.实验表明基于该插桩算法的垃圾收集器能够回收大量的内存空间,提高Java程序的执行效率. 相似文献
5.
Copying garbage collectors are now standard for the memory-management subsystems of functional and object-oriented programming languages. Compacting garbage collection has correspondingly fallen out of favor. We revitalize the case for compaction by demonstrating that a simple compacting collector, extended with the generational garbage collection heuristic, exhibits performance as effectively as or better than a well-designed generational copying collector on real programs running in real environments. The observation that compaction preserves allocation order across collections leads to a new generalization of the generational heuristic that reduces the movement of long-lived objects. We measure the effect of substituting our compacting generational collector for a copying collector in Standard ML of New Jersey. 相似文献
6.
7.
Java语言的一个显著特点是它通过虚拟机和垃圾回收机制管理着大部分的内存事务,但是在Java程序中还是可能存在内存泄漏问题。文中首先对Java内存泄漏做一个简要的定义,接着围绕一个实例详细地介绍如何用工具检测Java内存泄漏,最后列举了一些典型的泄漏,以便读者在Java程序开发中尽量避免类似的内存泄漏。 相似文献
8.
.NET Framework中的垃圾回收(Garbage Collection)机制减少了一些应用程序中发生内存泄露和访问冲突的可能性,但GC的工作机制仍然存在问题。在程序开发中,总会发现对于GC的错误理解。文章针对此问题进行研究分析,简要说明内存垃圾的产生原因、垃圾回收机制的原理、垃圾回收的主要对象以及释放模式。 相似文献
9.
C#是一种新的面向对象的程序设计语言,进一步研究C#程序设计的内存分配,就必须涉及．NET Framwork的概念,因为C#是专门为．NET Framework而设计的程序设计语言。本文主要叙述了C#和．NET程序设计中内存管理的特点和对程序设计性能的影响,并且就C#和传统的程序设计语言作了比较。 相似文献
10.
NAND Flash因非易失、抗震、低功耗等特点被广泛应用于嵌入式系统的大容量数据存储中。虽然随着JFFS3文件系统的提出,理论上解决了初始化文件系统时需扫描整个闪存分区、挂载时间过长、占用内存过多的缺陷,但并未解决NAND Flash本身随机读写严重不均衡的问题。在对JFFS3文件系统研究的基础上提出采用FDTree索引结构的SFFS文件系统,以解决在数据频繁更新的环境里NAND Flash数据管理问题,给出了考虑损耗均衡兼顾回收效率的垃圾回收机制。 相似文献
11.
12.
内存管理在计算机系统设计中是及其重要且必须的部分.高效的内存分配,垃圾回收和整理,在并行,分布式和实时应用中变的越来越重要.提出了一种利用二叉树来管理可利用内存分区的算法,并通过试验得出的数据分析,表明为什么该方法比其它算法更为方便高效,实现起来也比较简单易行. 相似文献
13.
Proper memory management and pointer usage often prove to be the most difficult concepts for students learning C++ to grasp. Compounding this problem is the fact that the compilers and runtime environments traditionally used to introduce these concepts leave much to be desired with regard to generating meaningful diagnostics to assist students in tracking down and fixing memory‐related logical errors. To alleviate this, we have developed Dereferee, an advanced yet thin wrapper around C++ pointers that greatly increases the quality of these runtime diagnostics, but with only a small amount of intrusion into the development process. With regard to performance, memory‐intensive programs will experience execution times approximately 20–30 times slower when using Dereferee, which is comparable with other similar tools. Furthermore, the library has been designed to be customizable and easily disabled to transition codes from development to production.Copyright © 2013 John Wiley & Sons, Ltd. 相似文献
14.
Platforms with automatic memory management, such as the JVM, are usually considered free of memory leaks. However, memory leaks can happen in such environments, as the garbage collector cannot free objects, which are not used by the application anymore, but are still referenced. Such unused objects can eventually fill up the heap and crash the application. Although this problem has been studied extensively, nevertheless, there are still many rooms for improvement in this area. This paper describes the statistical approach for memory leak detection, as an alternative, along with a commercial tool, Plumbr, which is based on the method. The tool is later analyzed with three case studies of real applications and in the process also analyzes strengths and weaknesses of the statistical approach for memory leak detection. Copyright © 2014 John Wiley & Sons, Ltd. 相似文献
15.
The aim of an ideal distributed Mobile Cloud environment, the surrogate object, is an agent for a particular Mobile Host in the wired or wireless network with specific data structures and methods. The Surrogate object is a software entity that is hosted on mobile support station and acts on behalf of a mobile host during the disconnection operation. The mobile hosts are registered with their own unique identifier in their cloud environment with their mobile support system. If the registered Mobile host is migrated from one cloud to another, the surrogate object handovers the data or resource management to another cloud with a new object with the same entities of old surrogate object, which leads inefficient. The granularity of object migration the old object is useless after the old object switched over into the new object. The collection of unused surrogate object is a big challenge. This problem will be achieved through the garbage collector technique in Mobile Cloud computing. In this research, we propose the Surrogate Object Garbage Collector (SOGC) model with new middleware consists in detecting the unused surrogate object by Mark‐Compact Garbage Collection technique to recycle their object resources. SOGC periodically recycles the idle object and automatically reuses it; whenever it is needed to manage cloud environment, it results in quality‐of‐execution, low latency, and cost optimization in data management. 相似文献
16.
在Linux上,内存交换有着特殊的作用,块设备在当前的Linux内核上充当交换区时,工作得很好;Nandflash在写入数据之前需要先擦除,因此当Nandflash充当交换区时,当前的内存交换模型就需要改进,否则内存交换就不能正常工作。根据虚拟内存页面映射的原理,设计了一种适用于Nandflash的内存交换模型。分析内存交换特点,提出了NVEA(new valid erase algorithm)垃圾回收算法并通过模型实现测试。结果证明,模型解决了Nandflash充当交换区时存在的各种问题,并且NVEA 相似文献
17.
A memory leak in a managed language occurs when the program inadvertently maintains references to objects that it no longer needs. Memory leaks cause systematic heap growth that degrade performance and can result in program crashes after perhaps days or weeks of execution. Prior approaches for detecting memory leaks rely on heap differencing or detailed object statistics which store state proportional to the number of objects in the heap. These overheads preclude their use on the same processor for deployed long‐running applications. This paper introduces Cork as a tool that accurately identifies heap growth caused by leaks. It is space efficient (adding less than 1% to the heap) and time efficient (adding 2.3% on average to total execution time). We implement this approach of examining and summarizing the class of live objects during garbage collection in a class points‐from graph (CPFG). Each node in the CPFG represents a class and edges between nodes represent references between objects of the specific classes. Cork annotates nodes and edges with the corresponding volume of live objects. Cork identifies growing data structures across multiple collections and computes a class slice to identify leaks for the user. We experiment with two functions for identifying growth and show that Cork is accurate: it identifies systematic heap growth with no false positives in 4 of 15 benchmarks we tested. Cork's slice report enabled us to quickly identify and eliminate growing data structures in large and unfamiliar programs, something their developers had not previously done. Copyright © 2009 John Wiley & Sons, Ltd. 相似文献
18.
Jinkyu Jeong Euiseong Seo Jeonghwan Choi Hwanju Kim Heeseung Jo Joonwon Lee 《Software》2010,40(8):605-625
Memory leaks are a continuing problem in the software developed with programming languages, such as C and C++. A recent approach adopted by some researchers is to tolerate leaks in the software application and to reclaim the leaked memory by use of specially constructed memory allocation routines. However, such routines replace the usual general‐purpose memory allocator and tend to be less efficient in speed and in memory utilization. We propose a new scheme which coexists with the existing memory allocation routines and which reclaims memory leaks. Our scheme identifies and reclaims leaked memory at the kernel level. There are some major advantages to our approach: (1) the application software does not need to be modified; (2) the application does not need to be suspended while leaked memory is reclaimed; (3) a remote host can be used to identify the leaked memory, thus minimizing impact on the application program's performance; and (4) our scheme does not degrade the service availability of the application while detecting and reclaiming memory leaks. We have implemented a prototype that works with the GNU C library and with the Linux kernel. Our prototype has been tested and evaluated with various real‐world applications. Our results show that the computational overhead of our approach is around 2% of that incurred by the conventional memory allocator in terms of throughput and average response time. We also verified that the prototype successfully suppressed address space expansion caused by memory leaks when the applications are run on synthetic workloads. Copyright © 2010 John Wiley & Sons, Ltd. 相似文献
19.
Automatic garbage collection relieves programmers from the burden of managing memory themselves and several techniques have been developed that make garbage collection feasible in many situations, including real time applications or within traditional programming languages. However, optimal performance cannot always be achieved by a uniform general purpose solution. Sometimes an algorithm exhibits a predictable pattern of memory usage that could be better handled specifically, delaying as much as possible the intervention of the general purpose collector. This leads to the requirement for algorithm specific customisation of the collector strategies. We present a dynamic memory management framework which can be customised to the needs of an algorithm, while preserving the convenience of automatic collection in the normal case. The Customisable Memory Manager (CMM) organises memory in multiple heaps. Each heap is an instance of C++ class which abstracts and encapsulates a particular storage discipline. The default heap for collectable objects uses the technique of mostly copying garbage collection, providing good performance and memory compaction. Customisation of the collector is achieved exploiting object orientation by defining specialised versions of the collector methods for each heap class. The object-oriented interface to the collector enables coexistence and coordination among the various collectors as well as integration with traditional code unaware of garbage collection. The CMM is implemented in C++ without any special support in the language or the compiler. The techniques used in the CMM are general enough to be applicable also to other languages. The performance of the CMM is analysed and compared to other conservative collectors for C/C++ in various configurations. © 1998 John Wiley & Sons, Ltd. 相似文献
20.
针对Android存储系统在闪存管理上存在较差的磨损均衡效果和较高的垃圾回收额外开销的缺陷,引入冷热数据分离策略,将文件按照不同热度写入对应热度的物理存储单元,同时改进垃圾回收策略,以达到良好的磨损均衡效果并减少垃圾回收额外开销。基于Android平台的实验结果表明,改进后的策略在有效减少NAND闪存垃圾回收额外开销的同时,还能有效改善其磨损均衡效果。 相似文献