4 ms·

Yup, same experience for us. We went back and forth between workstation and server mode gc. If you have a process that maintains things like leases/heartbeats i

Yup, same experience for us. We went back and forth between workstation and server mode gc. If you have a process that maintains things like leases/heartbeats in a low latency setting, C# doesn't seem like a good idea. Wonder how well Go works in this scenario considering it was purpose built for this.

xoluxo123 10y ago
Go is also a GC language.
- jamra 10y ago
  It has pretty low pause times by the GC.
  - jjawssd 10y ago
    Yep, around 2 milliseconds for most programs https://sli.mg/1RmNsB https://sli.mg/1RmNsB
    - im_down_w_otp 10y ago
      Two-milliseconds is an eternity in kernel time. That's wired round-trip time between two GigE endpoints on Linux's mediocre TCP/IP stack. Now imagine you stacked 2ms GC pauses into that level of the system. That would be a barely serviceable kernel. Forget any real-time facilities.
      - pjmlp 10y ago
        OSes written in GC enabled systems programming languages always allowed for controlling the GC behaviour. So you can have a GC free TCP/IP stack, while enjoying the GC comfort in areas where the 2ms pause aren't an issue.
        snaky 10y ago
        Or maybe even not completely GC-free [1]. What might be especially helpful is a good JIT that could reoptimize the code on-the-fly, when data patterns changes. Maybe performance level of 'data-guided optimization' provided by (controllable) GC and state-of-the-art JIT could beat down traditional approach someday. http://lukego.github.io/blog/2013/01/03/snabb-switchs-luajit-ethernet-device-driver/ http://lukego.github.io/blog/2013/01/03/snabb-switchs-luajit...
      - naasking 10y ago
        > Now imagine you stacked 2ms GC pauses into that level of the system. That would be a barely serviceable kernel. Forget any real-time facilities. Real-time just means bounded latency. If 2ms was a hard upper bound, that's hard realtime. If it's ~90% bounded by 2ms with a small variance, that's soft realtime.
nine_k 10y ago
Why Go, it has GC, too. I'd look at Rust.
- pjmlp 10y ago
  Because it is the spiritual successor of Oberon. https://en.wikipedia.org/wiki/Oberon_(operating_system) https://en.wikipedia.org/wiki/Oberon_(operating_system) http://www.ocp.inf.ethz.ch/wiki/Documentation/Language http://www.ocp.inf.ethz.ch/wiki/Documentation/Language
  - nine_k 10y ago
    Oberon the OS was cool, but Oberon the language is sort of too 1990s. (But I'd definitely take Modula-2 for low-level stuff instead of C any day, as I did in early 1990s.)
    - pjmlp 10y ago
      I agree, hence why after my initial interest in Go I eventually switched focus to other languages. However, it doesn't change the fact that it allows for lots of low level stuff in the similar vein as Oberon, which is why I happen to take Go's side, even if I rather use other more expressive programming languages. And to be faire, Niklaus Wirth latest language changes (Oberon-07) are even more minimalist than Go's.
twotwotwo 10y ago
Go does some of the same stuff Duffy recommends for C# in this post, like using an AOT compiler and stack-allocatable structs. Some things about Go may make that style of programming feel more natural. For example, structs are the default and syscalls look like other function calls. The stdlib might be friendly to this style (for example, widespread io.Reader/Writer lets a lot of stuff stream data through a reusable buffer rather than allocate big blobs) but I don't know enough to usefully compare it with the .NET libs/BCL. Or C# could be better for you. It has a lot of work behind it, including in the collector. Go's collector is now decent at keeping most work in the background but isn't generational or compacting as the CLR collector can be. And using a new language is always weird; you never start out as good with the new as you were with the old. The CLR's SustainedLowLatency collector mode, which tries to defer compaction as long as it can at the cost of RAM footprint, is the one that sounds most like Go's, FWIW. It all depends so much on what kind of deadlines your app has, how much memory pressure, what else you're getting/paying for in C# land. It's always tricky to grok a different ecosystem. The best ideas I can think of are to look for something existing in Go that seems kind of like what you want to do (like if you're implementing some kind of queue, look at NATS or nsq or such), or just build the smallest project that seems like a reasonable test.

xoluxo123 10y ago

Go is also a GC language.

jamra 10y ago
It has pretty low pause times by the GC.
- jjawssd 10y ago
  Yep, around 2 milliseconds for most programs https://sli.mg/1RmNsB https://sli.mg/1RmNsB
  - im_down_w_otp 10y ago
    Two-milliseconds is an eternity in kernel time. That's wired round-trip time between two GigE endpoints on Linux's mediocre TCP/IP stack. Now imagine you stacked 2ms GC pauses into that level of the system. That would be a barely serviceable kernel. Forget any real-time facilities.
    - pjmlp 10y ago
      OSes written in GC enabled systems programming languages always allowed for controlling the GC behaviour. So you can have a GC free TCP/IP stack, while enjoying the GC comfort in areas where the 2ms pause aren't an issue.
      - snaky 10y ago
        Or maybe even not completely GC-free [1]. What might be especially helpful is a good JIT that could reoptimize the code on-the-fly, when data patterns changes. Maybe performance level of 'data-guided optimization' provided by (controllable) GC and state-of-the-art JIT could beat down traditional approach someday. http://lukego.github.io/blog/2013/01/03/snabb-switchs-luajit-ethernet-device-driver/ http://lukego.github.io/blog/2013/01/03/snabb-switchs-luajit...
    - naasking 10y ago
      > Now imagine you stacked 2ms GC pauses into that level of the system. That would be a barely serviceable kernel. Forget any real-time facilities. Real-time just means bounded latency. If 2ms was a hard upper bound, that's hard realtime. If it's ~90% bounded by 2ms with a small variance, that's soft realtime.

nine_k 10y ago

Why Go, it has GC, too. I'd look at Rust.

pjmlp 10y ago
Because it is the spiritual successor of Oberon. https://en.wikipedia.org/wiki/Oberon_(operating_system) https://en.wikipedia.org/wiki/Oberon_(operating_system) http://www.ocp.inf.ethz.ch/wiki/Documentation/Language http://www.ocp.inf.ethz.ch/wiki/Documentation/Language
- nine_k 10y ago
  Oberon the OS was cool, but Oberon the language is sort of too 1990s. (But I'd definitely take Modula-2 for low-level stuff instead of C any day, as I did in early 1990s.)
  - pjmlp 10y ago
    I agree, hence why after my initial interest in Go I eventually switched focus to other languages. However, it doesn't change the fact that it allows for lots of low level stuff in the similar vein as Oberon, which is why I happen to take Go's side, even if I rather use other more expressive programming languages. And to be faire, Niklaus Wirth latest language changes (Oberon-07) are even more minimalist than Go's.

twotwotwo 10y ago

Go does some of the same stuff Duffy recommends for C# in this post, like using an AOT compiler and stack-allocatable structs. Some things about Go may make that style of programming feel more natural. For example, structs are the default and syscalls look like other function calls. The stdlib might be friendly to this style (for example, widespread io.Reader/Writer lets a lot of stuff stream data through a reusable buffer rather than allocate big blobs) but I don't know enough to usefully compare it with the .NET libs/BCL. Or C# could be better for you. It has a lot of work behind it, including in the collector. Go's collector is now decent at keeping most work in the background but isn't generational or compacting as the CLR collector can be. And using a new language is always weird; you never start out as good with the new as you were with the old. The CLR's SustainedLowLatency collector mode, which tries to defer compaction as long as it can at the cost of RAM footprint, is the one that sounds most like Go's, FWIW. It all depends so much on what kind of deadlines your app has, how much memory pressure, what else you're getting/paying for in C# land. It's always tricky to grok a different ecosystem. The best ideas I can think of are to look for something existing in Go that seems kind of like what you want to do (like if you're implementing some kind of queue, look at NATS or nsq or such), or just build the smallest project that seems like a reasonable test.