• Arc: Atomic reference counting
  • considering concurrncy

Suppose one thread incrementing the value and second thread decrementing the value

l = Read the variable counter;
write l + 1;

l = Read the variable counter;
write l - 1;

if second thread is executed in between the first thread:

Rc : not considering concurrent runs Solving the problem -> Arc : guarantees no instructions scheduling interleaves the instruction.

Atomic {
  l = read teh variable;
  write l + 1;
} // no other thread interleaves
// but not guaranteeing the order of the thread execution

Send trait: it’s implementation is unsafe!

Cloning arc pointer: incrementing the reference counter when arc pointer is dropped: incrementing the reference counter

Arc::new(Mutex::new(0));
// arc guarantees the data inside is shared
// mutex guarantees the integrity of modification.
g = a.locK();
*g = 42;

• spanwed thread panics -> delivered to main thread

• lifetime of function sent to spawn

  let counter = Arc::clone(&counter);
  thread::spwan(move || {
  // use counter;
  // arc guarantees that counter will not be dropped;
  })
  

• Intermittent computing

• Implementing garbage collection:
  • mark and sweep
  • tracing algorihthm
  • reference counting
  • improved algorithm: reference count for small counts, tracing for larger counts
  • reduce the $#$ of tracing (improve performance)
• problem of reference counting:
  • cycled objects : there will be always an object that points to self -> use trace

  -splitting the counts (strong / weak)

  • tree : strong edge (going to child) / weak edge (going to parent)
  • strong count -> drop
  • weak reference