This report details the design of a garbage collection (GC) module, which introduces modern GC features to the domain of embedded implementations. The described design supports weak references and feeds reference queues. Its architecture allows multiple concurrent application cores operating as mutators on the shared memory managed by the GC module. The garbage collection is exact and fully concurrent so as to enable the uninterrupted computational progress of the mutators. It combines a distributed root marking with a centralized heap scan of the managed memory. It features a novel mark-and-copy GC strategy on a segmented memory, which thereby overcomes both the tremendous space overhead of two-space copying and the compaction race of mark-and-compact approaches. The proposed GC architecture has been practically implemented and proven using the embedded bytecode processor SHAP as a sample testbed. The synthesis results for settings up to three SHAP mutator cores are given and online functional measurements are presented. Basic performance dependencies on the system configuration are evaluated.

Purely functional languages--with static type systems and dynamic memory management using garbage collection--are a known tool for helping programmers to reduce the number of memory errors in programs. By using such languages, we can establish correctness properties relating to memory-safety through our choice of implementation language alone. Unfortunately, the language characteristics that make purely functional languages safe also make them more difficult to apply in a low-level domain like operating systems construction. The low-level features that support the kinds of hardware manipulations required by operating systems are not typically available in memory-safe languages with garbage collection. Those that are provided may have the ability to violate memory- and type-safety, destroying the guarantees that motivate using such languages in the first place. This work demonstrates that it is possible to bridge the gap between the requirements of operating system implementations and the features of purely functional languages without sacrificing type- and memory-safety. In particular, we show that this can be achieved by isolating the potentially unsafe memory operations required by operating systems in an abstraction layer that is well integrated with a purely functional language. The salient features of this abstraction layer are that the operations it exposes are memory-safe and yet sufficiently expressive to support the implementation of realistic operating systems. The abstraction layer enables systems programmers to perform all of the low-level tasks necessary in an OS implementation, such as manipulating an MMU and executing user-level programs, without compromising the static memory-safety guarantees of programming in a purely functional language. A specific contribution of this work is an analysis of memory-safety for the abstraction layer by formalizing a meaning for memory-safety in the presence of virtual-memory using a novel application of noninterference security policies. In addition, we evaluate the expressiveness of the abstraction layer by implementing the L4 microkernel API, which has a flexible set of virtual memory management operations.

Denna rapport jämför prestanda med Unitys nya inkrementella garbage collection system med deras tidigare stop the world system, samt analyserar effekten av objektpooling på tidsprestanda. De olika systemen testas med hjälp av en förenklad version av ett bullet hell spel, där flertalet kulor skapas och förstörs per sekund. Rapporten finner att användning av objektpooling drastiskt förbättrar prestanda i den givna testmiljön. Rapporten finner även att stop the world presterar något bättre i genomsnitt, men dess extremvärden är markant högre på grund av garbage collection spikar. Rapporten rekommenderar användning av pooling samt användning av det inkrementella garbage collection systemet för att minimera överskridande av spelets tidsbudget per bilduppdatering.

No description available.

No description available.

No description available.

The Java programming language manages memory automatically through the use of a garbage collector (GC). The Java Virtual Machine provides several GCs tuned for different usage scenarios. One such GC is ZGC. Both ZGC and other GCs utilize bump-pointer allocation, which allocates objects compactly but leads to the creation of unusable memory gaps over time, known as fragmentation. ZGC handles fragmentation through relocation, a process which is costly. This thesis proposes an alternative memory allocation method leveraging free-lists to reduce the need for relocation to manage fragmentation.We design and develop a new allocator tailored for ZGC, based on the TLSF allocator by Masmano et al. Previous research on the customization of allocators shows varying results and does not fully investigate usage in complex environments like a GC.Opportunities for enhancements in performance and memory efficiency are identified and implemented through the exploration of ZGC's operational boundaries. The most significant adaptation is the introduction of a 0-byte header, which leverages information within ZGC to significantly reduce internal fragmentation of the allocator. We evaluate the performance of our adapted allocator and compare it to a reference implementation of TLSF. Results show that the adapted allocator performs on par with the reference implementation for single allocations but is slightly slower for single frees and when applying allocation patterns from real-world programs. The findings of this work suggest that customizing allocators for garbage collection is worth considering and may be useful for future integration.

This thesis deals with the designing of a garbage collector for the PNtalk virtual machine. It describes and rates the approaches and algorithms for an automatic memory management. Four algorithm families ale presented: mark-sweep, mark-compact, copying algorithms and reference counting. At first it describes sequential forms, that pauses running of the main program (mutator), then it describes parallel and concurent forms, that do not pauses the mutator. The thesis also presents generational model of garbage collecting. The following sections briefly introduces object orientated Petri nets. The result of this thesis is the design of the generational garbage collector for the PNtalk virtual machine.

We present a distributed garbage collection algorithm for Java distributed objects using the object model provided by the Java Support for Distributed Objects (JSDA) object model and using weak references in Java. The algorithm can also be used for any other Java based distributed object models that use the stub-skeleton paradigm. Furthermore, the solution could also be applied to any language that supports weak references as a mean of interaction with the local garbage collector. We also give a formal definition and a proof of correctness for the proposed algorithm.

The design of a waste collection system affects public health, the extent of participation in the system by residents, the recovery of resources from waste, and the cost of collection. Many developing countries use communal container collection [CCC] systems in which large containers are dispersed throughout neighbourhoods for the storage of waste until collection. These systems tend to have limited success as they often do not garner viable amounts of participation and containers are prone to being overfilled. The communal container waste collection system in the city of Aguascalientes, AGS, Mexico was assessed according to the Integrated Solid Waste Management [ISWM] principles of social acceptability, environmental effectiveness, economic affordability and effective management. Information was collected through seven interviews with waste-related managers, 282 residential questionnaires, and 12 informal collector questionnaires. The collection system garners a high participation rate (99%) attributed to: non-burdensome one-way distances from residences to containers (mean 114+/-71m); thorough, daily collection; and a culture of cleanliness. Factors of adherence to waste collection regulations were found to be public knowledge, social acceptability, convenience and perception of importance. The collection system was assessed by rational-intuitive consideration of all indicators and principles, to be mostly acceptable from an ISWM framework due to: a high collection rate (~100% daily) which is enabled by effective monitoring and efficient operation; a high participation rate; similarity of the resource recovery rate to that of other developing and developed countries; and long-term affordability. Areas for improvement in equality of service provision, collaboration with informal collectors, and communication were identified. Lessons learned about communal container collection are applicable to lower-middle and upper-middle income countries.