I am a games developer and am currently implementing a multi-thread / multi-core particle system.... it ain't as easy as pressing a "make faster" button.
But as its on PC/Mac and threads can access main memory (*shakes fist at PS3*), it should be possible to move things like temperature calculations and path-finding tasks to separate threads. But ho-boy don't expect the DF-Multicore update anytime soon. As mentioned in previous posts, really these things need to be designed form the ground up, retro-fitting parallel processing into a current program is fun .
It would be awesome to see DF at its full potential, but I im not going to whinge about a free Indie game being coded by ONE guy.
Finally someone who knows WTF he's talking about in these kinds of things.
Not to say there haven't been others, I just mean a programmer who's tried this kind of thing.
There was another dev a few posts up that had similar insight, but a different view.
And as a game-technology software developer myself, the reality is, the answer is "it depends". To get the best/most performance, building from the ground up with a multi-threaded approach is the only way to go. But that is not to say that enormous gains cannot be made in performance in certain (common) situations with relatively small changes.
There are many threading libraries that will convert a for loop into a multi-threaded for loop, which basically takes a little bit of find and replace. The catch here is that any given step in the for loop can't depend on any other (this creates an error in logic). It also means that common writable resources need to not be involved or be made thread-safe (which is conceptually simple, but often in practice difficult). Both of these will be an issue in some places, and not in others.
The entire game does not need a multi-threading overhaul in order to make an enormous performance boost, of course. Generally there are few, massive bottlenecks in terms of loops. If a few of those can be threaded, the game suddenly performs much better without touching a bunch of code all over the place.
However, since none of us have any knowledge of
this codebase, how easy threading
can be is highly moot. It must be evaluated on a case-by-case basis. On the other hand, this isn't a problem that's going away.