4 ms·

I think you would be hard-pressed to find a modern AA game that does not already use a GC. The major game engines Unreal and Unity are garbage collected - altho

I think you would be hard-pressed to find a modern AA game that does not already use a GC. The major game engines Unreal and Unity are garbage collected - although they use manual memory management for some of their internals, the exposed API surface (including the C++ API) is designed with garbage collection in mind. Notably, the popular-with-hobbyists Godot Engine does not use a garbage collector. It uses reference counting with some objects, but does not provide cycle detection, thus requires all objects to be laid out in a tree structure (which the engine is built around).

pjmlp 10mo ago
Reference counting is chapter 5 on the linked book.
- pizlonator 10mo ago
  Reference counting isn’t garbage collection.
  - gf000 10mo ago
    It absolutely is (and as per another thread under another post, both pjmlp and me are notorious for correcting people on this specific point)
    - pizlonator 10mo ago
      They are not interchangeable. The semantics are observably different. Therefore, RC is not GC. Reference counting gives you eager destruction. GC cannot. GC gives lets you have garbage cycles. RC does not. I think a part of the GC crew reclassified RC as GC to try to gain relevance with industry types during a time when GC was not used in serious software but RC was. But this is brain damage. You can’t take a RC C++ codebase and replace the RC with GC and expect stuff to work. You can’t take a GC’d language impl and replace the GC with RC and expect it to work. Best you could do is use RC in addition to GC so you still keep the GC semantics.
      - gf000 10mo ago
        > Reference counting gives you eager destruction. GC cannot. Tracing GC can't. Reference counting, which is by definition a GC can. It's like insects vs bugs. And destructors are a specific language feature. No one says that they are a must have and if you don't have them then you can replace an RC with a tracing GC. Not that it matters, a ladybug is not the same as an ant, but they are both insects.
        pizlonator 10mo ago
        The best part of these conversations is that if I say “garbage collection”, you have zero doubt that I am in fact referring to what you call “tracing garbage collection”. You are defining reference counting as being a kind of garbage collection, but you can’t point to why you are doing it. I can point to why that definition is misleading. Reference counting as most of the industry understands it is based on destructors. The semantics are: - References hold a +1 on the object they point to. - Objects that reach 0 are destructed. - Destruction deletes the references, which then causes them to deref the pointed at object. This is a deterministic semantics and folks who use RC rely on it. This is nothing like garbage collection, which just gives you an allocation function and promises you that you don’t have to worry about freeing.
        gf000 10mo ago
        > https://web.eecs.umich.edu/~weimerw/2008-415/reading/bacon-garbage.pdf https://web.eecs.umich.edu/~weimerw/2008-415/reading/bacon-g... They are different approaches for the same thing: automatic memory management. (Which is itself a not trivial to define concept) One tracks liveness, while the other tracks "deadness", but as you can surely imagine on a graph of black and white nodes, collecting the whites and removing all the others vs one by one removing the black ones are quite similar approaches, aren't they?
        pizlonator 10mo ago
        You’re not going to convince me by citing that paper, as it’s controversial in GC circles. It’s more of a spicy opinion piece than a true story. I agree that RC and GC are both kinds of automatic memory management. RC’s semantics aren’t about tracking deadness. That’s the disconnect. In practice, when someone says, “I’m using RC”, they mean that they have destructors invoked on count reaching zero, which then may or may not cause other counts to reach zero. If you squint, this does look like a trace - but by that logic everyone writing recursive traversals of data structures is writing a garbage collector
  - hashmash 10mo ago
    Just say "tracing garbage collection" to avoid the usual referencing counting arguments.
    - pizlonator 10mo ago
      I won’t.
  - pjmlp 10mo ago
    It surely is from computer science point of view, now that many prefer street knowledge, is another matter.
    - pizlonator 10mo ago
      Someone saying that they are the same isn’t “science”. What is science is programming language semantics, and by that science, RC and GC are different.
      - pjmlp 10mo ago
        RC is a GC algorithm, naturally there are different implementations available. Semantics are well defined in research literature.
  - BoingBoomTschak 10mo ago
    Does it not collect garbage?
- indigo945 10mo ago
  I said "a GC", that is, "a garbage collector". Even if you consider reference counting as technically being garbage collection, purely reference counted systems do not have a distinct entity that can be identified as "a" garbage collector. So I'm technically correct here even in face of this pedantry. Not that I think it's a reasonable approach to language to be pedantic on this. RC being GC is, of course, true from an analytic approach to language: a garbage collection system is defined as a system that collects and frees objects that are unreachable and thus dead; a reference counting pointer collects and frees objects that are unreachable and thus dead; therefore, reference counting is garbage collection. One problem with this is the vagueness: now, the use of a call stack is garbage collection; after all, returning from a function collects and frees the objects in the stack frame. Leaking memory all over the place and expecting the operation system to clean up when you call `exit()` likewise is "garbage collection". But more importantly, it's just not how anyone understands the word. You understood perfectly well what I meant when I said "you would be hard-pressed to find a modern AA game that does not already use a GC"; in other words, you yourself don't even understand the word differently. You merely feel an ethical imperative to understand the word differently, and when you failed to do so, used my comment as a stand-in to work through the emotions caused by your own inability to live up to this unfulfilled ethic.
  - pjmlp 10mo ago
    Except they do, when one bothers to read computer science reference literature, instead of blog posts from folks that learned programming on their own way. Being pedantic is required mechanism to fix urban myths, that is how we end up with he says, she says, adultered knowledge. All those "garbage collection" variations are exactly the proof what happens when people on the street discuss matters without having a clue about what they are talking about, it is like practice medecine with village recipes "I hear XYZ cures ABC". It is not vague, IEEE and ACM have plenty of literature on the matter.

pjmlp 10mo ago

Reference counting is chapter 5 on the linked book.

pizlonator 10mo ago
Reference counting isn’t garbage collection.
- gf000 10mo ago
  It absolutely is (and as per another thread under another post, both pjmlp and me are notorious for correcting people on this specific point)
  - pizlonator 10mo ago
    They are not interchangeable. The semantics are observably different. Therefore, RC is not GC. Reference counting gives you eager destruction. GC cannot. GC gives lets you have garbage cycles. RC does not. I think a part of the GC crew reclassified RC as GC to try to gain relevance with industry types during a time when GC was not used in serious software but RC was. But this is brain damage. You can’t take a RC C++ codebase and replace the RC with GC and expect stuff to work. You can’t take a GC’d language impl and replace the GC with RC and expect it to work. Best you could do is use RC in addition to GC so you still keep the GC semantics.
    - gf000 10mo ago
      > Reference counting gives you eager destruction. GC cannot. Tracing GC can't. Reference counting, which is by definition a GC can. It's like insects vs bugs. And destructors are a specific language feature. No one says that they are a must have and if you don't have them then you can replace an RC with a tracing GC. Not that it matters, a ladybug is not the same as an ant, but they are both insects.
      - pizlonator 10mo ago
        The best part of these conversations is that if I say “garbage collection”, you have zero doubt that I am in fact referring to what you call “tracing garbage collection”. You are defining reference counting as being a kind of garbage collection, but you can’t point to why you are doing it. I can point to why that definition is misleading. Reference counting as most of the industry understands it is based on destructors. The semantics are: - References hold a +1 on the object they point to. - Objects that reach 0 are destructed. - Destruction deletes the references, which then causes them to deref the pointed at object. This is a deterministic semantics and folks who use RC rely on it. This is nothing like garbage collection, which just gives you an allocation function and promises you that you don’t have to worry about freeing.
        gf000 10mo ago
        > https://web.eecs.umich.edu/~weimerw/2008-415/reading/bacon-garbage.pdf https://web.eecs.umich.edu/~weimerw/2008-415/reading/bacon-g... They are different approaches for the same thing: automatic memory management. (Which is itself a not trivial to define concept) One tracks liveness, while the other tracks "deadness", but as you can surely imagine on a graph of black and white nodes, collecting the whites and removing all the others vs one by one removing the black ones are quite similar approaches, aren't they?
        pizlonator 10mo ago
        You’re not going to convince me by citing that paper, as it’s controversial in GC circles. It’s more of a spicy opinion piece than a true story. I agree that RC and GC are both kinds of automatic memory management. RC’s semantics aren’t about tracking deadness. That’s the disconnect. In practice, when someone says, “I’m using RC”, they mean that they have destructors invoked on count reaching zero, which then may or may not cause other counts to reach zero. If you squint, this does look like a trace - but by that logic everyone writing recursive traversals of data structures is writing a garbage collector
- hashmash 10mo ago
  Just say "tracing garbage collection" to avoid the usual referencing counting arguments.
  - pizlonator 10mo ago
    I won’t.
- pjmlp 10mo ago
  It surely is from computer science point of view, now that many prefer street knowledge, is another matter.
  - pizlonator 10mo ago
    Someone saying that they are the same isn’t “science”. What is science is programming language semantics, and by that science, RC and GC are different.
    - pjmlp 10mo ago
      RC is a GC algorithm, naturally there are different implementations available. Semantics are well defined in research literature.
- BoingBoomTschak 10mo ago
  Does it not collect garbage?
indigo945 10mo ago
I said "a GC", that is, "a garbage collector". Even if you consider reference counting as technically being garbage collection, purely reference counted systems do not have a distinct entity that can be identified as "a" garbage collector. So I'm technically correct here even in face of this pedantry. Not that I think it's a reasonable approach to language to be pedantic on this. RC being GC is, of course, true from an analytic approach to language: a garbage collection system is defined as a system that collects and frees objects that are unreachable and thus dead; a reference counting pointer collects and frees objects that are unreachable and thus dead; therefore, reference counting is garbage collection. One problem with this is the vagueness: now, the use of a call stack is garbage collection; after all, returning from a function collects and frees the objects in the stack frame. Leaking memory all over the place and expecting the operation system to clean up when you call `exit()` likewise is "garbage collection". But more importantly, it's just not how anyone understands the word. You understood perfectly well what I meant when I said "you would be hard-pressed to find a modern AA game that does not already use a GC"; in other words, you yourself don't even understand the word differently. You merely feel an ethical imperative to understand the word differently, and when you failed to do so, used my comment as a stand-in to work through the emotions caused by your own inability to live up to this unfulfilled ethic.
- pjmlp 10mo ago
  Except they do, when one bothers to read computer science reference literature, instead of blog posts from folks that learned programming on their own way. Being pedantic is required mechanism to fix urban myths, that is how we end up with he says, she says, adultered knowledge. All those "garbage collection" variations are exactly the proof what happens when people on the street discuss matters without having a clue about what they are talking about, it is like practice medecine with village recipes "I hear XYZ cures ABC". It is not vague, IEEE and ACM have plenty of literature on the matter.