Mark Sweep

description6 papers

group1 follower

lightbulbAbout this topic

Mark Sweep is a garbage collection algorithm used in computer science to reclaim memory. It operates in two phases: the 'mark' phase identifies live objects, while the 'sweep' phase deallocates memory occupied by unreferenced objects, thereby optimizing memory usage and preventing memory leaks.

lightbulbAbout this topic

Key research themes

1. How can mobile sensors be optimally scheduled for sweep coverage to monitor points of interest with minimal resources?

This research area centers on designing methods to periodically monitor specified points of interest (POIs) in wireless sensor networks and similar applications using a minimal number of mobile sensors. Unlike traditional full or barrier coverage where the entire area or boundary must be constantly monitored, sweep coverage requires guaranteeing that each POI is covered at specific time intervals, allowing time-varying coverage demands and enabling resource-efficient sensor deployment and scheduling. Efficient sweep coverage is challenging due to the NP-hardness of optimal sensor allocation and the complexity of coordinating movements and ensuring coverage constraints in dynamic scenarios.

An Efficient Method for Sweep Coverage With Minimum Mobile Sensor

by Tu N . Nguyen and

2016

Key finding: Proposes the Perpendicular-Distance-Based Algorithm (PDBA) that designs sensor movement schedules employing checking distance and time procedures to optimize the number of mobile sensors required for sweep coverage.... Read more

articleView Paper downloadDownload

Sweep coverage with mobile sensors

by Mo Li

2014

Key finding: Formally defines sweep coverage with varying sweep periods per POI and proves that minimizing the number of mobile sensors for sweep coverage is NP-hard and inapproximable within a factor of 2 unless P=NP. Proposes CSWEEP, a... Read more

articleView Paper downloadDownload

Search for smart evaders with sweeping agents

by Alfred Bruckstein

2022, Robotica

Key finding: Develops theoretical sweeping policies using line formations of agents moving at velocities above a critical threshold to guarantee capture (detection) of fast-moving evaders within an initial circular region. Presents... Read more

articleView Paper downloadDownload

keyboard_arrow_downShow more

2. What mathematical and control-theoretic properties govern the behavior and optimization of the sweeping process, especially under perturbations and control inputs?

The classical sweeping process models dynamics constrained by moving sets using differential inclusions and normal cone operators. Understanding topological properties, existence and uniqueness of solutions, and optimal control of these systems is crucial for applications in mechanical systems, crowd dynamics, and more. Research investigates perturbed sweeping processes with nonconvex and nonsmooth moving sets, develops optimal control frameworks where controls act on the moving sets, and characterizes minimum-time problems using Hamilton-Jacobi equations and variational analysis. These insights provide foundational theory and tools essential for both modeling and controlling sweeping processes in applied settings.

Topological properties for a perturbed first order sweeping process

by Nina Dora

2021, Acta Universitatis Sapientiae, Mathematica

Key finding: Analyzes perturbed sweeping processes governed by state-dependent moving sets with subsmooth geometry. Establishes topological properties of attainable sets under perturbations represented by set-valued mappings that are... Read more

articleView Paper downloadDownload

The Minimum Time Function for the Controlled Moreau's Sweeping Process

by Giovanni Colombo

2021, SIAM Journal on Control and Optimization

Key finding: Develops a framework for studying the minimum time problem to reach targets under controlled sweeping processes with moving sets and Lipschitz controls, where dynamics are given by non-Lipschitz differential inclusions... Read more

articleView Paper downloadDownload

Preprint ISSN 0946 – 8633 Optimal control of the sweeping process

by Nguyen Duc Hoang

2023

Key finding: Presents the first systematic study of optimal control problems where control functions define the moving set in the sweeping process. Proves existence of optimal solutions and derives necessary optimality conditions for... Read more

articleView Paper downloadDownload

keyboard_arrow_downShow more

3. How can sharp features and discontinuities in solid geometries be incorporated consistently within computational frameworks for sweeping and swept volume construction?

Extending swept volume computation to solids with sharp edges and vertices (G0 continuity) is crucial for practical CAD and manufacturing applications, where mechanical parts inherently possess nonsmooth features. This theme investigates mathematical characterization and computational treatment of sharp edges sweeping through space, including their geometry, parametrization, singularities, trimming, and the correct assembling of boundary representations (breps). It addresses challenges such as normal cone behavior at sharp points, proper trimming of generated surfaces, and topology preservation, thus enabling robust and accurate swept volume modeling compatible with standard CAD data structures.

Incorporating Sharp Features in the General Solid Sweep Framework

by Milind Sohoni

2021, Computer Graphics Forum

Key finding: Extends previous swept volume frameworks from G1 (smooth) solids to G0 solids with sharp features by providing a precise mathematical treatment of surfaces generated by sweeping sharp edges and vertices. Introduces methods... Read more

articleView Paper downloadDownload

keyboard_arrow_downShow more

All papers in Mark Sweep

Efficient Concurrent Mark-Sweep Cycle Collection

by John Zigman

2024

Since 1960, reference counting has been a popular means of garbage collection. Reference counters achieve low pause times by using local data to determine liveness, but the use of this local data leaves the collector unable to collect... more

Figure 3: Adding an Extra Node to the Race. Figure 2 illustrates the fundamental race that a concurrent tracing collector must address. We use the standard tri-color convention: Black represents a node which has been visited and need not be re- visited by the collector. Grey represents a node which the collector must visit. White represents unvisited nodes, which at the end of collection will be garbage [13]. At fo, the collector marks A’s sole referent, B, grey and enqueues it before marking A black (reach- able). At t;, the mutator adds a pointer from A to C and deletes the pointer from B to C. At time fy the collector marks B as black (reachable) and since it has no referents, does not enqueue any ob- jects for marking. C is thus left white (unreachable) at the end of the collection although it is live. The problem is due to the creation of a pointer from a black node to a white node (A to C).

Figure 4: Adding a Cycle to the Mutator-Collector Race.

Figure 5: Throughput Limit Study, Varying Collection Period. ga a as aay SS A SS SS BE ear SS SRO tS owe Figure 5 shows the overall throughput of MSCD and trial dele- tion algorithms normalized against the snapshot-at-the-beginning base algorithm for cycle detection periodicities ranging from 128KB to 128MB. Here we show the average time for each cycle detection,

Figure 6: Total, Mutator, GC and Cycle Detection Performance

Table 2: Throughput Limit Study, 8MB Collection Period, Average Costs Per Cycle Detection.

descriptionView Paper arrow_downwardDownload

Schism: Fragmentation-Tolerant Real-Time Garbage Collection

by Antony Hosking

2022, Proceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI)

Managed languages such as Java and C# are being considered for use in hard real-time systems. A hurdle to their widespread adoption is the lack of garbage collection algorithms that offer predictable space-and-time performance in the face... more

descriptionView Paper arrow_downwardDownload

A comprehensive evaluation of object scanning techniques

by Robin Garner

2022, ACM SIGPLAN Notices

At the heart of all garbage collectors lies the process of identifying and processing reference fields within an object. Despite its key role, and evidence of many different implementation approaches, to our knowledge no comprehensive... more

descriptionView Paper arrow_downwardDownload

The design and construction of high performance garbage collectors

by Robin Garner

2022

Garbage collection is a performance-critical component of modern language implementations. The performance of a garbage collector depends in part on major algorithmic decisions, but also significantly on implementation details and... more

This section shows results of our experiments exploring traversal order. We measure total elapsed time for the heap traversal across all GCs in the third iteration of each benchmark, and repeat each measurement six times in order to obtain a sufficiently small confidence interval. We take the arithmetic mean of these six iterations and di- vide by the mean elapsed time for the ‘sorted’ traversal order to produce a normalised elapsed time ratio for each benchmark and traversal order. We summarise this to a single figure for the traversal order on a machine architecture by taking the geometric mean of the per-benchmark normalised figures. Table 3.7: Hardware platforms used for heap traversal order experiments.

Table 5.3: Hardware platforms for scanning experiments.

Table 3.1: Tracing loop time as a percentage of total GC time.

Figure 1.1: Architectural dependence on GC performance. Total running time on three architectures, geometric mean of the Spec JVM 98 benchmarks. Reproduced from Blackburn et al. [2004a].

Figure 3.5: Effects of traversal order: major design choices

to an otherwise depth-first traversal, for varying buffer sizes. The data series ‘buffer

Figure 3.11: Edge enqueuing. Effects of partial breadth-first order

Table 4.1: Hardware Platforms for prefetch experiments We evaluate performance on 4 architectures, details of which are provided in Ta- ple 4.1.

sured on our four modern architectures. Each graph shows the geometric mean of performance for the full set of 17 benchmarks drawn from DaCapo and SPEC. Results are normalized to the time for NodeSide with no prefetch. NodeSide is the configuration which most closely follows prior work [Boehm, 2000; Cher et al., 2004]. We gathered results for different heap sizes, but found that the effect of prefetch was independent of heap size. We report here the results for a fairly generous heap; three times the min imum heap size for each benchmark. We performed identical experiments on 2 and 4x heaps, and found the GC-time results were almost indistinguishable, although the overall impact of this GC-time optimization on total time obviously increases since time spent in GC goes up in smaller heaps. For completeness, Figure 4.5 shows tota time as a function of heap size. In order to maintain a consistent number of collections across the different configurations and fairly assess the effect of prefetch, we did not allow the header meta-data configurations to make use of the minor space saving due to avoiding the side bitmap.

significant, with GC-time performance improvements ranging from 30% on the Pow- erPC 970, to around 20% on the Athlon 64. Notable degradations occur for a number of configurations on the Pentium-M. We also see that prefetch distances greater than eight provide little advantage, with longer prefetch distances degrading performance slightly on the Athlon 64.

(a) Reference fields per object. Mean of all benchmarks.

In Figure 5.7 we compare specialized scanning (Section 5.4.3) across the three object layout schemes. Specialization performs well on average compared to the baseline

Figure 5.6: The effect of inlining common cases. Geometric mean of 18 benchmarks.

Figure 5.8: The effect of varying header encodings. Geometric mean of 18 benchmarks. We now explore the header metadata design space described in Section 5.4.4.

Figure 5.9: The effect of different levels of indirection. Geometric mean of 18 benchmarks.

Figure 5.10: The effect of various object layout optimizations. Geometric mean of 18 benchmarks.

Figure 5.11: Summary, showing four metrics for six well-performing de- signs.

Table 3.2: Hardware Platforms used for the Replay Tracing Loop Cost Experiments 3.3.1.2 Tracing Costs We now use the replay tracing framework described in Section 3.2 to evaluate the dominant costs of the mark-sweep tracing loop shown in Figure 3.1. We perform our measurements using Jikes RVM and MMTk with DaCapo and SPEC benchmarks, as described in Chapter 2, and the AMD and Pentium-M architectures shown in Ta- ble 3.2.

descriptionView Paper arrow_downwardDownload

High-Level Low-Level Programming

by Eliot Moss

2021

The power of high-level languages lies in their abstraction over hardware and software complexity, leading to greater security, better reliability, and lower development costs. However, opaque abstractions are often show-stoppers for... more

descriptionView Paper arrow_downwardDownload

Wake up and smell the coffee

by Antony Hosking

2016, Communications of the ACM

Evaluation methodology underpins all innovation in experimental computer science. It requires relevant workloads, appropriate experimental design, and rigorous analysis. Unfortunately, methodology is not keeping pace with the changes in... more

descriptionView Paper arrow_downwardDownload

Z-rays

by Jennifer B Sartor

2016, Proceedings of the 2010 ACM SIGPLAN conference on Programming language design and implementation - PLDI '10

Arrays are the ubiquitous organization for indexed data. Throughout programming language evolution, implementations have laid out arrays contiguously in memory. This layout is problematic in space and time. It causes heap fragmentation,... more

descriptionView Paper arrow_downwardDownload

Z-rays

by Jennifer B Sartor

2016, ACM SIGPLAN Notices

descriptionView Paper arrow_downwardDownload

Optimized memory management for class metadata in a JVM

by Laurent Daynes and

2015, Proceedings of the 9th International Conference on Principles and Practice of Programming in Java - PPPJ '11

A Java virtual machine (JVM) typically manages large amounts of class metadata (e.g. class descriptors, methods, byte codes) in main-memory. In this paper, we analyze the impact of metadata memory management on garbage collection costs in... more

Figure 2. Two heaps with their generations consisting of regions allocated from a region pool.

Figure 4. Class descriptors and mirrors.

Figure 5. Costs of full collection phases for COMP.

Table 2. Heap sizes used. We choose a multiple of 32 MB that is larger than the maximum live heap size measured at the end of full collections in multiple runs of the benchmark.

Figure 6. References visited during full collections. The line be- tween the bars separates the references emanating from the applica- tion heap (bottom) from those emanating from the permanent gen- eration (top).

Figure 7. Full collection performance of META and COMP.

Figure 8. Footprint of metaspaces, grouped by class loader type. NAT RENEE ROMIRT TE RAGAN T OMe REIN RR! RAITT CE STEEN BE iio eS Sane Wena a NS MEN LO AT ~The DaC apo benchmark Harness class loader (or Harness loader for short) is an artefact of the DaCapo benchmark suite: it is used to instantiate and run the benchmarks. In a regular application, most of the classes it defines would be defined by the system loader. Reflective class loaders are created for fast reflective invocation to define a single invocation stub class.

Figure 9. Full collection performance of COMP-, META- and META+. Table 4. Memory usage for META compared to COMP

Table 5. Percentage of unoccupied space in metaspace. Table 5 shows how much of this assigned memory is unoccu- pied. Unoccupied space includes the space at the end of the cur rent fixed-size chunk, which available for allocation, and the space left in the other chunks, which cannot be used for allocation and is therefore wasted.

descriptionView Paper arrow_downwardDownload

Program-level adaptive memory management

by Mitsunori Ogihara

2015, Proceedings of the 2006 international symposium on Memory management - ISMM '06

Most application's performance is impacted by the amount of available memory. In a traditional application, which has a fixed working set size, increasing memory has a beneficial effect up until the application's working set is met. In... more

descriptionView Paper arrow_downwardDownload

Detecting memory leaks in managed languages with Cork

by Maria Jump

2015

A memory leak in a managed program occurs when the program inadvertently maintains references to objects that it no longer needs. Memory leaks cause systematic heap growth which degrades performance and results 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 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. ; 0:0-0 Prepared using speauth.cls 2 JUMP & MCKINLEY using staleness is that data structures such as arrays and hash tables occasionally touch all the objects when the data structure grows, which defeats leak detection based only on stale objects. Prior work thus lacks efficiency and precision. Our approach is efficient because it piggyback on the garbage collector and it is precise because it identifies growing data structures that cause heap growth

descriptionView Paper arrow_downwardDownload

ANU-Digital Collections: The design and construction of high performance garbage collectors

by Robin Garner

2013

descriptionView Paper arrow_downwardDownload

A Comprehensive Evaluation of Object Scanning Techniques

by Robin Garner

2011

descriptionView Paper arrow_downwardDownload

Effective prefetch for mark-sweep garbage collection

by Robin Garner

2011, Proceedings of the 6th …