11 ms·
Is garbage collection strictly worse than other memory managementarment techniques? Got distracted one sentence in by an assertion that's so at odds with my un
by Waterluvian 10y ago
Is garbage collection strictly worse than other memory managementarment techniques?
Got distracted one sentence in by an assertion that's so at odds with my understanding of the world.
- moon_priestess 10y agoNo, absolutely not. Swift uses reference counting under the hood because of its Objective-C runtime ties, not because reference counting is better than tracing garbage collection. The author is just not well-informed on that issue.
- seanmcdirmid 10y agoTracing GC was supported in objective C for awhile but was deprecated/dropped awhile back because of performance issues. Referencing counting does have some advantages over tracing GC, but it's all really a bunch of trade offs to make.
- pjmlp 10y agoPerformance wasn't the main problem, rather crashes and memory corruption. https://news.ycombinator.com/item?id=12589998 https://news.ycombinator.com/item?id=12589998
- seanmcdirmid 10y agoAh, that makes sense. I remember them putting it in and then yanking it out for some reason. Referencing counting seems to be in vogue these days because it is somewhat more predictable on mobile systems, at least this is what I heard about the Metro/Store/UWP API at Microsoft (C# is still garbage collected, but the APIs are primarily ref counted).
- pjmlp 10y agoWinRT is just COM with a new base interface extending IUknown and .NET metadata instead of TLB files. If you search for Ext-VOS on Don Syme blog, it resembles quite a lot the genesis of .NET before they went with the CLR.
- kbsletten 10y agoI would say that in the specific case of this article (talking about passing pointers to managed objects to C) it is easier without a tracing GC simply because reference counting doesn't ever move the object and so pointers won't be broken (except, as the author shows, if you let the only reference go out of scope before you're done using the pointer). A GC language _may_ implement pinning to overcome this, but not all do.
- stjepang 10y agoChris Lattner on the advantages of reference counting over tracing garbage collection: https://lists.swift.org/pipermail/swift-evolution/Week-of-Mon-20160208/009422.html https://lists.swift.org/pipermail/swift-evolution/Week-of-Mo...
- coldtea 10y ago>Swift uses reference counting under the hood because of its Objective-C runtime ties, not because reference counting is better than tracing garbage collection Not really. Obj-C already had a GC and dropped it, to implement ARC because it's faster and more memory efficient.
- pjmlp 10y agoCompletely wrong. GC was dropped from Objective-C, because Apple did not manage to make it work safely with C semantics. Objective-C developers weren't able to mix Frameworks compiled with and without GC, there were lots of corner cases and forum discussions regarding GC runtime crashes were quite common. Apple's decision in such scenario was to take the alternative route to make the compiler do what the Cocoa manual reference counting patterns already required. Nothing to do with being faster and more memory efficient, rather having something in Objective-C that would work at all. However this urban myth keeps being repeated.
- Joky 10y agoIt's OK to point something as "Completely wrong" and as a "Urban myth", but a source is appreciated.
- pjmlp 10y agoThe source are the Apple developer forums and WWDC sessions.
- coldtea 10y agoHow about Chris Lattner, who implemented that in Obj-C and then Swift? >>Has a GC been considered at all? >GC [also] has several huge* disadvantages that are usually glossed over: while it is true that modern GC's can provide high performance, they can only do that when they are granted much more memory than the process is actually using. Generally, unless you give the GC 3-4x more memory than is needed, you’ll get thrashing and incredibly poor performance. Additionally, since the sweep pass touches almost all RAM in the process, they tend to be very power inefficient (leading to reduced battery life). I’m personally not interested in requiring a model that requires us to throw away a ton of perfectly good RAM to get an “simpler" programming model - particularly on that adds so many tradeoffs.* So it's hardly "completely wrong", especially for iOS.
- mikeash 10y agoSwift also uses reference counting because the people at Apple think it's outright better, not just because of the Objective-C heritage. Whether they're correct is certainly debatable, but it's not a compromise in their view, it's the best choice.
- kbsletten 10y agoWell, passing raw pointers to garbage collected objects is impossible without language support for "pinning". This is because the GC will move objects around in memory breaking any pointers you're using in your C code. That may be a generous interpretation of the author (it could just be bile), but in the context of the article (about C interoperability) that's what comes to mind.
- pjmlp 10y agoThat's not quite true. For example, in Cedar, Modula-3, Active Oberon, D you can mark a pointer as not being under GC control. Other GC enabled systems programming languages offer similar feature.
- masklinn 10y ago> This is because the GC will move objects around in memory Not necessarily, you could use (and guarantee) a non-moving GC. Moving is but one of the attributes/details you can use for your GC.
- mikeash 10y agoAnd this is definitely not just theoretical. Any conservative collector must also be non-moving. The Boehm GC for C and C++ and Apple's GC for Objective-C are both existing examples.
- masklinn 10y agoIIRC Go's GC is also non-moving for now (or has that changed in a recent version? I believe it was still non-moving around 1.5)
- BFatts 10y agoThere is nothing inherently wrong with garbage collection, but it does take your control away. You have to allow for a certain level of "magic" to have elements be freed. This doesn't always work so memory leaks are a bit harder to track down. In a system where you control the allocations and deallocations, you have finer control but it's easier to forget to deallocate memory no longer in use. This is easier to track down, but a headache none the less.
- kbsletten 10y agoAlso, if we're talking about passing pointers to objects to C code, GC frequently moves objects in memory which will invalidate the pointer. It's not possible to reliably predict when this will happen, so you need extra language support for pinning to do any of the things in this tutorial without accessing invalid memory.
- adrianm 10y agoThe Garbage Collection Handbook [http://gchandbook.org/ http://gchandbook.org/] has a good overview of the advantages and disadvantages of reference counting as garbage collection. In summary, Advantages: A. Objects are collected immediately when they become garbage. B. Programming language runtime support is simpler. C. Memory can be reclaimed easily in programs with distributed heaps. Disadvantages: A. Natural race conditions exist in multi-threaded programs when reference counting is used. Atomic read/writes are necessary when incrementing/decrementing the reference count for an object. B. Cyclic data structures cannot be reclaimed. (This is why you have to jump through hoops to avoid this in Objective-C and Swift.) C. Every object in your language which is reference counted needs a field to hold the reference count. Or you need a special object in its stead which "points" to your object, like a shared pointer. D. Pauses with reference counting are still possible. As stated in the book, "When the last reference to the head of a large pointer structure is deleted, reference counting must recursively delete the descendant of the root."
- pjmlp 10y agoRegarding D, you can even get stack overflows if the destructors require nested calls.
- masklinn 10y ago> C. Every object in your language which is reference counted needs a field to hold the reference count. Or you need a special object in its stead which "points" to your object, like a shared pointer. For a long time (until the 64b class pointers I think) Objective-C used external tables of reference counts instead of embedding refcounts in objects.
- mayoff 10y agoThe side table only gets a slot for an object when the object is retained (has its reference count incremented) after creation. (Every object starts with a count of 1 at creation.) Before ARC, you could certainly have lots of objects that were never retained after creation. Since ARC tends to be more careful than a human about retaining objects (meaning it retains objects in more places), I don't know how much more load ARC puts on the side table, but I suspect it's not zero.
- oldmanjay 10y agoWithout trying to be unfair to the author, this article is not super well-written so intentions may not be expressed clearly.