How exactly is object removed from memory in Swift?

I've read a bunch of articles about the memory management in swift. However, there is still some things which are not clear.

1. What does it mean to free memory?
2. Is memory freed exactly after counter for strong references is zero or is there some event which triggers deinit?
3. How does swift knows that some piece of memory is occupied?

Seems like this is more about OS rather than language but still I would appreciate any answer here.

Just to clarify, when we talk about "Swift the language", it's just talking about the language syntax and semantics in the abstract, without any regards for a concrete implementation. Technically, the Swift programming language can be implemented with multiple different memory-management strategies, including conventional Garbage Collection, although some APIs (isKnownUniquelyReferenced(_:) and the CoW behaviours that depend on it) strongly imply that reference-counting is used.

So everything from here on will be talking about the main Swift implementation by Apple, and not others (like RemObjects Silver)

1. > What does it mean to free memory?

   It means that a function like free() is called, which takes a pointer to the allocated memory and marks it as "available". Future allocations (such as with malloc()) are free to vend out this memory next time a new allocation is needed.

2. > Is memory freed exactly after counter for strong references is zero or is there some event which triggers deinit?

   Swift's ARC decrements reference counts by calling swift_release(the_object). If the decrement causes the reference count to hit 0 or less, then it immediately triggers the deinit and deallocation code path.

   Unlike a garbage collector (which can defer object deallocation indefinitely), this happens deterministically, right at the point of last use of the object.

   You can see this for yourself: https://github.com/apple/swift/blob/2db4a038c3ecbbc5a9b4d90c36b684e2f56b022f/stdlib/public/SwiftShims/swift/shims/RefCount.h#L1028-L1030

3. > How does Swift knows that some piece of memory is occupied?

   It doesn't, really. Most automatic memory management schemes take a very conservative definition of "garbage": An object is garbage if and only if there are no more strong references to it. In essence, if we know there's no more strong references to an object, we can be certain that the user doesn't need it anymore (because they couldn't possible access it, even if they wanted).

   If they didn't take such a conservative stance, any false positive would mean the deallocation of an object that's still in use, which would be catastrophic.

   So as far as the system is concerned, any object with a non-zero reference count is "in use"/"occupied"/"not garbage," until its reference count eventually reaches 0.