7 ms·
Concurrency is the New Memory Management
- seanmcdirmid 12y agoYep, we also need our version of garbage collection for concurrency; e.g., http://research.microsoft.com/apps/pubs/default.aspx?id=211297 http://research.microsoft.com/apps/pubs/default.aspx?id=2112...
- woah 12y agoWow, this looks interesting. No time to grok the full paper, but do you have any examples of a simple app written with this technique?
- seanmcdirmid 12y agoThere are videos linked in Section 4 of the paper. It is still in the small program stage although Glitch as a C# framework is usable now (indeed, I've written an editor, UI, and so on, all very concurrent). As a framework, it is not really convenient without being a new language, but it could be interesting to do something like ReactJS using replay and rollback. If you like Bret Victor-style demos, I'm working on a web essay that should be done sometime this summer.
- sitkack 12y agoNeed.
- overgard 12y agoProbably not a popular opinion but: I'm not really a fan of all the user-space async stuff that's become popular (IE: the nodejs/tornado style of single threaded apps with non-blocking IO). Remember Windows 3.1 or old Mac OS with it's cooperative multitasking where you had to explicitly yield or risk freezing up the entire computer? It's basically the same thing reinvented with a nicer brand. I know I'm dating myself here, but it's really the same model. We came up with preemptive multitasking for a reason: because it's more robust and efficient. Threads are dangerous, but basically you can avoid the danger for the most part if you avoid sharing objects across threads, and if you do that then with blocking IO your code flows linearly and you don't have to deal with callback hell.
- MartinMond 12y agoErlang has preemption and process isolation in user-space. Go's goroutines also somewhat approach proper user-space preemption/isolation.
- overgard 12y agoYeah, it's not really the user-space part I have an issue with, just the lack of preemption. Erlang obviously has concurrency solved pretty well.
- Negitivefrags 12y agoIt's a little less dangerous when you only need to cooperate with yourself, but yes, it does mean you need to be very careful that you don't have any means for some requests to take an unexpectedly long amount of time. In MacOS if you grabbed a window title bar for too long with the mouse then all your sockets would drop. Fun times.
- gioele 12y ago> In MacOS if you grabbed a window title bar for too long with the mouse then all your sockets would drop. Fun times. I wonder if the people developing windowing systems with client side decorations (e.g. Wayland + Qt) thought about this issue. Any information about that?
- mattdw 12y agoAs far as I'm aware there's two approaches (often both used at once) in modern GUI systems that mitigate this. One is an explicit event loop, which can be locked up by user code but not normally by routine events, and the other approach is running the UI on its own thread. (Or, to put it another way, applications should perform any long-running operations not on the UI thread.) The second, particularly, would avoid the dropping-sockets problem, as network and drawing would very likely be on separate threads.
- deleted 12y ago[deleted]
- derengel 12y agoSTM is not appropriated for distributed systems but why hasn't it took off more in the concurrency world?
- AaronFriel 12y agoCoordination with the real world is and always has been the pain point with STM. It's fine if your STM universe lives entirely in a subset of your data on a single machine [1], or within a single database [2], or with a single decision-making unit [3]. Most languages have extremely poor support for separating interactions with the real world from interactions that occur entirely within one serializable context (a thread working with thread-local memory, for example). Can you safely replay arbitrary C, C++, etc.? No, because side-effecting code could run at any time and occur in any context. So that is one problem that has to be solved first. Suppose you've solved that problem. Well, now for a distributed system, you need to make STM talk to STM. Make one module talk to another over a network, or a filesystem, or another database, or a client browser. Do you have STM working in the JavaScript running on client's machines? And even if you managed that feat, do you have end-to-end STM from your datastore to your client's actions? Distributed STM that wasn't painful to use, either to write or in terms of performance, would be a sort of holy-grail of distributed computing. I don't think any language or toolchain is there yet. [1] Haskell, Clojure, et al STM engines. [2] SQL-compliant relational databases such as DB2, Oracle, SQL Server, as well as distributed databases like HyperDex that support true transactions. [3] Paxos, Raft, and other decision-making algorithms only ever externally appear to be consistent, but are internally complex and might have an internal tug-of-war.
- seanmcdirmid 12y ago> Can you safely replay arbitrary C, C++, etc.? No, because side-effecting code could run at any time and occur in any context. So that is one problem that has to be solved first. I spend my time solving this problem. You can do it with a programming model especially designed for it. Functional programming is not required, though can be convenient. > Well, now for a distributed system, you need to make STM talk to STM. Make one module talk to another over a network, or a filesystem, or another database, or a client browser. Do you have STM working in the JavaScript running on client's machines? And even if you managed that feat, do you have end-to-end STM from your datastore to your client's actions? STM is the wrong way of thinking about this problem, mainly because replay is not an intrinsic part of the paradigm (instead, users manage that themselves). Rather, go back further to Jefferson's virtual time/Time Warp system [1], which was designed specifically in the context of distributed systems. [1] http://dl.acm.org/citation.cfm?id=3988 http://dl.acm.org/citation.cfm?id=3988 There are also many related systems like Concurrent Revisions, LVars, Bloom, and so on...
- johnpmayer 12y agoYou know, the embedded systems community has a heck of a lot of tools and formal logics for designing this stuff in the abstract. Lots of little DSLs and auto-checkers for thinking about processes and messages, that sort of thing. I'm not so sure about model -> code generation, I think that is mostly rolled by-hand. For concurrency in the large, I wonder if there will be greater adoption of these sorts of engineering techniques.
- colechristensen 12y agoCan you point to some of these tools for those interested?
- seanmcdirmid 12y agoI assume you are referring to the concurrency DSLs like Esterel? These are quite low level with a different emphasis; I'm not sure they would scale to larger non-embedded systems, and they like many of the niceties that programming for larger systems can afford.
- stcredzero 12y agoI am not a hardware expert, but from what I understand, hardware architects didn't get around to supporting VMs and garbage collection as well as they might have. Systems continued to be optimized best for workloads that looked like scientific computing in Fortran from the 80's or desktop applications written in C++ from the 90's. Hardware architectures to support video games and media, on the other hand, seem to have taken huge strides over the same timeframe. Now, it seems like they are behind in terms of supporting distributed systems on multi-core machines. The kind of contortions required to detect and avoid problems like False Sharing indicate that today's hardware could be a good ways suboptimal for building these systems.
- sitkack 12y agoAzul.
- Rusky 12y agoThe Mill CPU has an interesting approach to false sharing [0]- cache lines keep track of which bytes are valid for their core, so one core could be using one part of the line while another uses a different part, and they wouldn't try to communicate until/unless they actually tried to use the same bytes. [0] http://millcomputing.com/docs/memory/ http://millcomputing.com/docs/memory/
- anon4 12y ago> Hardware architectures to support video games and media, on the other hand I'll have to disagree about the video games bit. Today's consoles are a completely regular AMD x64 CPU together with a completely regular AMD GPU, one running a version of Windows, plus one that uses PowerPC. Yesterday's were two with multi-core PowerPC and an AMD GPU, one running a version of Windows, plus one with that really weird PowerPC together with 7 tiny PowerPClets and an nVidia GPU that was famously awful to program for. Going back even further, we have an Intel x86 together with an nVidia GPU, running a version of Windows, a PowerPC-based CPU and an ATI-developed GPU (minor note: the company, ArtX, that was doing the GPU got bought by ATI and their designs did end up in ATI GPUs, so I'm listing it as such), a Hitachi SuperH CPU together with a PowerVR GPU, running a version of Windows, and this weird design from SONY. And going back a further iteration things get even weirder and so on and so forth. I'll agree that the further we go, the more these systems are made from specialised components (hello Saturn) and don't resemble what you'd get from e.g. a Dell. But that is mostly because you needed to use specialised components to get really cutting-edge performance for those tasks. Today you can more or less stick in 4 x64 cores and forget about it.
- marcosdumay 12y agoI really can not agree. - non-blocking I/O - user-space concurrency - easy messaging - advanced scheduling From those, only easy messaging actually helps creating clusters, and it can be implemented in a library without any problem. The other may help the language being good, or help one get more throughput from a node, but offer no help in maintaining the consistency of a cluster.
- ianstallings 12y agoSeems pretty accurate. So this is probably a great time to mention my favorite new(ish) platform for handling concurrency in a polyglot way: http://vertx.io/ http://vertx.io/
- signa11 12y agoisn't this same as tibco's event-bus offering ?
- scott_s 12y agoThere is an interesting - but very readable! - academic paper that is kinda related: "The Transactional Memory / Garbage Collection Analogy": https://homes.cs.washington.edu/~djg/papers/analogy_oopsla07.pdf https://homes.cs.washington.edu/~djg/papers/analogy_oopsla07... I say "kinda" related because even TM is a lower-level thing than the author of this post is talking about. The treatment of the subject, however, is much more in-depth. Lambda the Ultimate discussion: http://lambda-the-ultimate.org/node/2990 http://lambda-the-ultimate.org/node/2990
- seanmcdirmid 12y agoWow, I wasn't aware of this paper although I went to that OOPSLA. Thanks for the link!
- jeffdavis 12y ago"Languages and frameworks like Go, Akka and Erlang have come up now because they help solve the hard networking and concurrency problems that we need to build clusters." What does Go offer for a cluster environment? As far as I can tell, it's still targeted at single machines (though perhaps with many cores).
- quarterwave 12y agoThe first question to ask may well be "why does my problem need computation on a commodity cluster?". A massive multi-player spaceship battle may be best served by a HPC environment, using C++ and MPI. There's probably only a limited class of distributed problems that map nicely to a commodity cluster. Several worthy commentators have pointed out that even if the systems programming environment offered the same verbs for both, commodity network latency makes "distributed concurrency" very different from "in-box concurrency". To loosely borrow a term from physics, time delays can break the scaling symmetry of a renormalization group. A systems architect with a sound background in mathematics may be able to reason out the cluster performance of a social algorithm operating on a Erdos-Renyi random graph. Plodders such as myself will try to prototype. I'll insist that a prototype has business value if only because otherwise I have no way of appearing to be busy. For prototyping a distributed system on a commodity cluster, my personal preference would be Erlang. As rvirding commented with great insight in another post, Erlang has an OS feel to it. From my limited perspective, Erlang spares me the trouble of knowing Unix and networking (for example: I don't need to know what a TCP port is). Erlang gives me a minimal & consistent set of verbs, and that's all I need for prototyping.
- CmonDev 12y ago"Languages and frameworks like Go, Akka and Erlang have come up now ... keep lots of the syntax and semantics from the "languages of yesterday"." Erlang is really, really old-school actually - 1986. The language of the day before yesterday.
- CmonDev 12y agoI would also look outside of the JVM box and consider C#. It stays familiar, while having proper parallelism and concurrency constructs: async+await, TPL, TPL DataFlow, Parallel. Alternatively there is also F# with it's Erlang-inspired http://en.wikibooks.org/wiki/F_Sharp_Programming/MailboxProcessor http://en.wikibooks.org/wiki/F_Sharp_Programming/MailboxProc...
- collyw 12y agoDoes that make it any worse? Lots of people who use it rate Lisp very highly.
- unoti 12y agoIf you're interested in concurrency, you owe it to yourself to spend some time working through this guide on ZeroMQ[1]. It could change the way you think about software architecture forever, because it makes it so straightforward to change your app into a multi-node, multi-language fabric of machines. It's also a fun way to get your feet wet with a new language, because every language under the sun is supported, and you can easily integrate the code in your new language with systems written in your old language. Which is another reason it might change how you think about architecture. ZeroMQ makes it practical to bring in other new languages and libraries into your ecosystem. [1] http://zguide.zeromq.org/page:all http://zguide.zeromq.org/page:all
- TheMagicHorsey 12y agoI feel like the author of this piece doesn't really have personal knowledge about what he is talking about. I use Go and I use Erlang. I've never used Akka. Go is not in the same class as Erlang when it comes to Cloud Computing. In Erlang the state and behavior of your entire datacenter can be contained in Erlang itself. Erlang will take care of bringing up new processes when your jobs break. Erlang will handle messaging between processes executing on different machines. Go doesn't do any of that out of the box. There are some interesting projects like Go Circuit, which sort of kinda want to emulate Erlang's OTP and bring your datacenter behavior into Go, but Go Circuit isn't being run in production by anyone I have heard of. Maybe its ready to go, but it looks more like a research project to me. As such, Go has nothing to do with managing a cluster other than that it gives you some nice single node concurrency features. You will need to build or import everything else you need. I can't think of anything else out there which is quite like Erlang/OTP. Maybe Julia has some tools that are similar but I don't know too much about it. Edit: For those Go programmers that are interested in what I'm talking about, check out this concise explanation from the Erlang docs: http://www.erlang.org/doc/getting_started/conc_prog.html http://www.erlang.org/doc/getting_started/conc_prog.html Erlang isn't as user friendly as Go, but it has a lot of stuff that can save you serious headaches if you think you will need to scale. Premature optimization is a waste of time ... blah blah etc., so maybe you don't need it for your project. Also Go on App Engine allegedly scales pretty well with very little programmer effort.
- deleted 12y ago[deleted]