scholarly journals Duby: Dual Binding Semantics

2020 ◽  
Author(s):  
Yoori Rapoport
Keyword(s):  
Programming Language ◽  
Efficient Method ◽  
Garbage Collection ◽  
Variable Binding ◽  
Binding Forms ◽  
Reference Counting ◽  
Separation Of Variable

Reference counting is a simple and efficient method for garbage collection. One disadvantage of reference counting is the possible creation of reference cycles. We propose a dynamically typed compiled programming language called Duby, in which values can be bound to either an automatic variable or to a unique hierarchical path. The separation of variable binding forms allows Duby to implement reference counting for automatic variables which refer to values bound to unique hierarchical paths without creating reference cycles. Another advantage of explicit binding of values to unique hierarchical paths is the ability to provide a paradigmatic implementation of programming concepts using filesystem-like abstractions.

scholarly journals Dusty caches for reference counting garbage collection

2006 ◽  
Vol 34 (1) ◽  
pp. 3-10 ◽  
Author(s):  
Scott Friedman ◽  
Praveen Krishnamurthy ◽  
Roger Chamberlain ◽  
Ron K. Cytron ◽  
Jason E. Fritts
Keyword(s):  
Garbage Collection ◽  
Reference Counting

scholarly journals Finer Garbage Collection in Lindacap

2012 ◽  
pp. 112-137
Author(s):  
Nur Izura Udzir ◽  
Hamidah Ibrahim ◽  
Sileshi Demesie
Keyword(s):  
Garbage Collection ◽  
Open Systems ◽  
Sufficient Information ◽  
Sweep Algorithm ◽  
Coordination System ◽  
The Difference ◽  
Managing System ◽  
Reference Counting ◽  
Performance Results ◽  
Tuple Spaces

As open systems persist, garbage collection (GC) can be a vital aspect in managing system resources. Although garbage collection has been proposed for the standard Linda, it was a rather course-grained mechanism. This finer-grained method is offered in Lindacap, a capability-based coordination system for open distributed systems. Multicapabilities in Lindacap enable tuples to be uniquely referenced, thus providing sufficient information on the usability of tuples (data) within the tuple-space. This paper describes the garbage collection mechanism deployed in Lindacap, which involves selectively garbage collecting tuples within tuple-spaces. The authors present the approach using reference counting, followed by the tracing (mark-and-sweep) algorithm to garbage collect cyclic structures. A time-to-idle (TTI) technique is also proposed, which allows for garbage collection of multicapability regions that are being referred to by agents but are not used in a specified length of time. The performance results indicate that the incorporation of garbage collection techniques adds little overhead to the overall performance of the system. The difference between the average overhead caused by the mark-and-sweep and reference counting is small, and can be considered insignificant if the benefits brought by the mark-and-sweep is taken into account.

scholarly journals How to use Fibonacci numbers to teach recursive programming

2021 ◽  
Vol 1 (1) ◽  
Author(s):  
Jürgen Gerhard
Keyword(s):  
Programming Language ◽  
Efficient Method ◽  
Fibonacci Numbers ◽  
Worst Case ◽  
Recursive Procedure ◽  
Linear Recurrences ◽  
Mathematical Properties ◽  
Constant Coefficients ◽  
Profiling Techniques ◽  
Recursive Programming

There are too many examples and programming guides (which, e.g., an internet search for "recursive procedure Fibonacci" will turn up) to count that use Fibonacci numbers as an example to illustrate recursive programming. The motivation for this article is to show why the naive way of doing this is a bad idea, as it is horrendously inefficient. We will exhibit much more efficient ways of computing Fibonacci numbers, both iterative and recursive, and analyze and compare worst case running times and memory usages. Using some mathematical properties of Fibonacci numbers leads to the most efficient method for their computation. For illustration and benchmarking, we will use Maple and its programming language, however, similar behaviour can be demonstrated in almost any other programming language. This exposition combines and explores the mathematical properties of Fibonacci numbers, notions of algorithmic complexity, and efficient Maple programming and profiling techniques, and may be used as an introduction to any of these three subjects. The techniques described can be readily generalized to more general types of linear recurrences with constant coefficients.

scholarly journals The Transactional Memory

2019 ◽  
pp. 13-20
Author(s):  
V. M. Dhivya Shri ◽  
K. Reshma
Keyword(s):  
Programming Language ◽  
Garbage Collection ◽  
Transactional Memory ◽  
Concurrent Programming ◽  
The Other

Transactional memory (TM) promises to simplify concurrent programming. Language-based constructs allow programmers to denote atomic regions declaratively. Its implementations operate by tracking loads and stores to memory and by detecting concurrent conflicts. TM allows programmers to write simpler programs that are composable and deadlock-freeThis essay presents remarkable similarities between transactional Memory and garbage collection. The connections are fascinating in their own right, and they let us better stand one technology by thinking about the corresponding issues for the other.

scholarly journals Garbage collection in object-oriented databases using transactional cyclic reference counting

1998 ◽  
Vol 7 (3) ◽  
pp. 179-193 ◽  
Author(s):  
P. Roy ◽  
S. Seshadri ◽  
A. Silberschatz ◽  
S. Sudarshan ◽  
S. Ashwin
Keyword(s):  
Garbage Collection ◽  
Object Oriented ◽  
Reference Counting ◽  
Object Oriented Databases

EQUALS – a fast parallel implementation of a lazy language

1997 ◽  
Vol 7 (2) ◽  
pp. 183-217 ◽  
Author(s):  
OWEN KASER ◽  
C. R. RAMAKRISHNAN ◽  
I. V. RAMAKRISHNAN ◽  
R. C. SEKAR
Keyword(s):  
Shared Memory ◽  
Memory Management ◽  
Garbage Collection ◽  
Parallel Implementation ◽  
Parallel Machine ◽  
Functional Language ◽  
Parallel Performance ◽  
Strictness Analysis ◽  
Reference Counting ◽  
Sequential Implementation

This paper describes EQUALS, a fast parallel implementation of a lazy functional language on a commercially available shared-memory parallel machine, the Sequent Symmetry. In contrast to previous implementations, we propagate normal form demand at compile time as well as run time, and detect parallelism automatically using strictness analysis. The EQUALS implementation indicates the effectiveness of NF-demand propagation in identifying significant parallelism and in achieving good sequential as well as parallel performance. Another important difference between EQUALS and previous implementations is the use of reference counting for memory management, instead of mark-and-sweep or copying garbage collection. Implementation results show that reference counting leads to very good scalability and low memory requirements, and offers sequential performance comparable to generational garbage collectors. We compare the performance of EQUALS with that of other parallel implementations (the 〈v, G〉-machine and GAML) as well as with the performance of SML/NJ, a sequential implementation of a strict language.

Sign in / Sign up

Export Citation Format

Share Document