DF development has been consistent since 2006, but the project was started in 2002. Does having code that predates multicore processing make a single-threaded program any more difficult to convert to multi-thread, or is that a nonsensical question to somebody who knows anything about programming?
As far as I can tell, it has to do with the way the program is set up to handle calculations: These threads talk about it more.
This one talks briefly about multi-threading (information I did not know).
"You can buy a $1000 computer today with 4 CPU cores and 80 GPU cores. But you can't design a compiler that automatically gets full benefit out of that -- not just because it's impractical, but because it's mathematically impossible. For example, A* is pretty much explicitly serial: its entire benefit is from exploring what is usually the right path and not seeing anything else. Lisp and matlab do a great job of warping the programmer's brain to think about doing the same operation on lots of data, which can then be relatively easily parallelized. The more classically-trained programmers I work with find this all pretty mind-blowing, so it's going to take a generation or two before we can really get data-parallel languages in mass usage."
This one furthers the cause, and then talks about the processes involved with making and utilizing multi-thread. It gets interesting, but the people seem to come to the same conclusion: it would require a lot of rewriting.
This one is a bunch of pages of info, but summed up into one sentence: "Using multiple cores at all: Impossible without a total rewrite of the hooks that allow it to use even the one core." And is later broken down
here.
I didn't look too deeply into it, but this
reddit post Devlog by Toady may talk about it more.
You also can't
write a program to multi-thread it.
In the end: it looks like it may be possible, but the underlying issue is that a lot of the commands are serial (must be done in sequence) and can not be shucked off to another thread. It is possible, but may not be feasible. As was written in the last link:
"It's not that simple. For example, the code in Dwarf Fortress is designed to work serially, so it will likely behave quite badly when run in parallel. Race conditions, such as one thread attempting to read/write/edit/delete data while another thread is attempting to read/write/edit/delete that same data, can produce erratic behavior or even crash the program. For example, two dwarves deciding to do the same task at the same time could cause it to try to remove the same task from the list twice, which would likely screw up the task list, if not cause the program to crash entirely. The current code wouldn't check for that because it would never happen when run serially."
Author
Topic: CPU Utilization Question (Read 870 times)