7 ms·

You can write Go programs in a certain style that doesn't use GC. It's the equivalent of not using malloc in a C program.

• pcwalton 9y ago
  No, it's really not. How do you allocate a data structure on the stack and then call a function passing a pointer to it at a polymorphic call site in Go? (A polymorphic call site is one in which the compiler cannot statically tell which function is being called.)
  • _ph_ 9y ago
    Yes, it is possible. The Go GC is written in the Go subset that can be compiled without heap allocation. The compiler even has a switch for this, which turns any heap allocation into a compile error. This is a subset of all possible Go programs, but still a very useful one.
    • w8rbt 9y ago
      What is the compiler switch?
      • _ph_ 9y ago
        Sorry, I don't know and haven't been able to locate it in the help for the build tool, but it was mentioned in a talk about the GC, especially about it being written in Go itself.
  • lopatin 9y ago
    Interfaces allow polymorphic coding, and they support stack allocated data structures last I checked.
    • pcwalton 9y ago
      I didn't say you couldn't make polymorphic calls in Go. I said that they don't mix well with relying on escape analysis to avoid tracing GC.
      • lopatin 9y ago
        Oh I see what you mean. Yeah forcing vars to actually be stack allocated can be challenging when using interfaces everywhere. What are the Go authors' opinions on improving escape analysis?
        • pcwalton 9y ago
          I think it's a design issue that can't be truly solved, period. You could try stuff like k-CFA I guess.
          • bogomipz 9y ago
            What is k-CFA ?
            • cyphar 9y ago
              https://en.m.wikipedia.org/wiki/Control_flow_analysis https://en.m.wikipedia.org/wiki/Control_flow_analysis
              • bogomipz 9y ago
                Ah neat, thanks.
• Animats 9y ago
  There's a fair amount of implicit allocation in Go. When you reference a slice, you create a slice descriptor, which takes up space. Maps, channels, and goroutines all allocate. It's not impossible to avoid allocation in a block of code, but it's not just avoiding explicit allocation. How do interrupts work in this system? Do they map to goroutines, or what?
  • _ph_ 9y ago
    The thing is, this allocation is usually on the stack. With a bit of experience, it is relatively easy to write your program such that all these allocations are on the stack. The compiler also gives you a clear breakdown on which objects are allocated on the heap. It is one big advantage of Go vs. Java for example, that you do get much better control about the allocation. All Go types are "value types", so this creates much more control and less memory pressure. (Except for interfaces, they are great when you need dynamic typing, but they behave more like reference types and do some unavoidable heap allocation, so avoid them in code parts which must not allocate from the heap.)