5 ms·
I'm interested in tracking Go as a replacement for Erlang. Some things that should probably happen: * GC works on 32 bit systems. * Scheduler improvements so
by davidw 14y ago
I'm interested in tracking Go as a replacement for Erlang. Some things that should probably happen:
* GC works on 32 bit systems.
* Scheduler improvements so that things are a bit more robust ( http://code.google.com/p/go/issues/detail?id=543 http://code.google.com/p/go/issues/detail?id=543 )
* A fairly solid library implementing supervision trees or something like it.
* Probably some other things, but those strike me as the big ones. The important thing is for the system to be able to run for months at a time.
I think they'll get there eventually. Maybe not 100%, but 'good enough' sooner or later.
- lmfao 14y agoThe first thing is one of the major issues I have with go at the moment. Lots of my servers are forced to run on 32 bit, due to certain software requirements and it bothers me to not be able to write go daemons for it.
- davidw 14y agoThe system I'm working on is an embedded-ish platform that should probably be 32bit in order to save on memory.
- trailfox 14y agoAkka is also a viable Erlang alternative.
- davidw 14y agoGood point; I wonder what kind of memory usage you could squeeze that in to.
- trailfox 14y agoIt should run comfortably on any modern server, might be tricky if you have severe memory constraints though.
- JulianMorrison 14y agohttps://code.google.com/p/jetlang/ https://code.google.com/p/jetlang/ is a rather Go-like model, with lightweight processes (optionally backed by a thread pool) and typed channels. Much less functionality than Akka but if you want low memory overhead, it's hard to beat.
- waffle_ss 14y agoLooks like a nice library but I don't think it's a serious contender to replace Erlang because the JVM just isn't made for the level of concurrency that Erlang's VM is. Off the top of my head as an Erlang newbie: * You're still using Java threads, so the potential to access [shared memory][1] is there (i.e. "shared nothing" can't be guaranteed). * You're still subject to global GC pauses, whereas the Erlang VM has per-process GC. [1]: http://doc.akka.io/docs/akka/snapshot/general/jmm.html http://doc.akka.io/docs/akka/snapshot/general/jmm.html
- trailfox 14y agoRecent benchmarks and related responses resulted in Akka out-performing Erlang (read the full post): https://plus.google.com/112820434312193778084/posts/HdKFx4VQtJj https://plus.google.com/112820434312193778084/posts/HdKFx4VQ... Shared memory when running on the same machine is actually more efficient since there is no need to copy immutable objects. If the sophisticated low-latency GC options available on the JVM are not sufficient for you feel free to fire up more JVM instances on the same machine or on other machines.
- waffle_ss 14y agoI assume you mean the comment that links here, with Akka getting 2.1M messages/sec? http://uberblo.gs/2011/12/scala-akka-and-erlang-actor-benchmarks http://uberblo.gs/2011/12/scala-akka-and-erlang-actor-benchm... If you follow the comments there, someone improved the Erlang benchmark to 3M messages/sec, beating Akka once again: http://musings-of-an-erlang-priest.blogspot.dk/2012/07/i-only-trust-benchmarks-i-have-rigged.html http://musings-of-an-erlang-priest.blogspot.dk/2012/07/i-onl... > Shared memory when running on the same machine is actually more efficient since there is no need to copy immutable objects. Many Erlang processes fit onto an OS-level thread or process, so passing messages is very fast ("copying" shouldn't be equated with context switching OS threads). > If the sophisticated low-latency GC options available on the JVM are not sufficient for you feel free to fire up more JVM instances on the same machine or on other machines. Akka is a library and can't make guarantees about how the JVM will perform garbage collection of actors while Erlang has it built into its VM. No amount of creating new JVM instances will change that.
- JulianMorrison 14y agoThat issue is quite simply a misinterpretation of goroutines. Erlang: perform a maximum number of reductions, then switch, or switch on IO. The number of reductions is cleverly adjusted so that a process which is swamping other processes will be throttled. Go: switch on IO. Go's design is much simpler, and closer to Ruby Fibers than to Erlang processes, except that goroutine scheduling can use multiple threads. To cooperatively switch without doing IO, call runtime.Gosched().
- jerf 14y agoRight now, as near as I can tell, you basically can't implement an Erlang supervision tree in Go. You don't have anything like linking, which really has to be guaranteed by the runtime to work properly at scale, so bodging something together with some 'defer' really doesn't cut it. You also can't talk about "a goroutine", because you can't get a reference or a handle to one (no such thing), you can only get channels, but they aren't guaranteed to map in any particular way to goroutines. I've done Erlang for years and Go for weeks, so I'm trying to withhold judgement, but I still feel like Erlang got it more right here; it's way easier to restrict yourself to a subset of Erlang that looks like a channel if that is desirable for some reason than to implement process features with channels in Go.
- JulianMorrison 14y agoDefer and recover are guaranteed by the runtime, so deferring a recovery that launches a goroutine which sends a value on a child-died channel is not quite a bodge. However as you point out unlike Erlang there are no PIDs, so you'd either need a channel per child or an ID per child. And the whole thing would be very, very manual. Something like type Crash struct { PID int Panic interface{} } var crashed = make(chan Crash) func parent() { go child() oops := <-crashed panic(oops) } func child() { defer func() { if r := recover(); r != nil { crashed <- Crash{1, r} } } panic("boom") }