Print

Please login or register.
1 Hour 1 Day 1 Week 1 Month Forever
Login with username, password and session length

[Im_Sparks]

A quick topic, should be off the front page in an hour.

Does dwarf fortress run on a single core processor or multiple core processor?
If it's single core, that would explain the lagmammoth.

[Rysith]

Yes, it's single core.

[Im_Sparks]

Yes, it's single core.

That blows. Majorly. It has so much potential with dual core, or more core systems!

MORE CORE!

[Fieari]

This topic comes up repeatedly.  Every time it does, it spawns a multi-page thread of flaming doom.  Please, let's not do this again.

Summary: Multithreading is not easy, is even less easy when you don't start work on it from the beginning, and Toady has no skill in how to do it.  The graphics portion of the game is slowly becomming multithreaded by Baughn though, so you'll have a little bit at least.  Eventually.  When he's able to get it to work.

[Sir Pseudonymous]

Except multithreading *is* easy. Every time I read an article talking about multithreading, or read materials about multithreading in a given language, they make a point of talking about how hard it is, how many pitfalls there are, etc. But, it's not hard to write a program keeping those things in mind. It's different, so I suppose any perceived difficulty comes from being set in a single-threaded mindset, but it is by no means hard in and of itself.

That said, I'd imagine trying to adapt a program, especially something like DF, to use multiple threads successfully would be an ungodly bitch, and would amount to a complete rewrite.

[Slappy Moose]

That said, I'd imagine trying to adapt a program, especially something like DF, to use multiple threads successfully would be an ungodly bitch, and would amount to a complete rewrite.

Well that's the problem right there.

Multithreading from the beginning = easy.
Multithreading halfway into developement = FFFFFFFFFFFFFFFFFFFUCK.

[Im_Sparks]

That said, I'd imagine trying to adapt a program, especially something like DF, to use multiple threads successfully would be an ungodly bitch, and would amount to a complete rewrite.

Well that's the problem right there.

Multithreading from the beginning = easy.
Multithreading halfway into developement = FFFFFFFFFFFFFFFFFFFUCK.

I believe Toady, using his godly temperance and endurance, will get around to it someday. Rewriting the entire fortress as we know it. The question is just when.

[Untelligent]

After he's done with all the important stuff, most likely.

[PTTG??]

As nice as the Important Stuff is, I can't help but worry that the more he codes now, the more will be in the way when he decides to multithread it.

Of course, Polycore machines could still go the way of the beta tape if some new processor system turns up, such as optical.

[Armok]

A long as there computing capacity is finite, people will want more of it.
There will within the foreseeable future always be a ultimate limit to how much faster you can make a single core my making adding more stuff to it, due to the speed of light if nothing else.
therefore, until FTL quantum computing or something is invented, multiple cores will always make a comeback.

[ephrion]

A long as there computing capacity is finite, people will want more of it.
There will within the foreseeable future always be a ultimate limit to how much faster you can make a single core my making adding more stuff to it, due to the speed of light if nothing else.
therefore, until FTL quantum computing or something is invented, multiple cores will always make a comeback.

I don't think multiple cores will ever become outdated.  No matter how fast a single core can get, it will always be cheaper and easier to put two of them in a box rather than making it twice as fast.

[IndonesiaWarMinister]

A long as there computing capacity is finite, people will want more of it.
There will within the foreseeable future always be a ultimate limit to how much faster you can make a single core my making adding more stuff to it, due to the speed of light if nothing else.
therefore, until FTL quantum computing or something is invented, multiple cores will always make a comeback.

I don't think multiple cores will ever become outdated.  No matter how fast a single core can get, it will always be cheaper and easier to put two of them in a box rather than making it twice as fast.

Until we hit mugen

[Angellus]

And that, my dear friends. Is the first and most important wishlist number one of Dwarf Fortress 2.0


Now we just have to wait for 3009 to get to it...
If only we could get a full def-crew for toady to work with 

[Michael]

Except multithreading *is* easy. Every time I read an article talking about multithreading, or read materials about multithreading in a given language, they make a point of talking about how hard it is, how many pitfalls there are, etc. But, it's not hard to write a program keeping those things in mind. It's different, so I suppose any perceived difficulty comes from being set in a single-threaded mindset, but it is by no means hard in and of itself.

The problem is that multithreaded programs are inherently nondeterministic.  Depending on the relative speed of execution of individual threads, entirely different logical paths can be taken.  This means it is far easier for a bug to go unnoticed, and when a bug is noticed it can be hard to reproduce.  Add to this the new bug class of forgetting to use semaphores when needed, and multithreading becomes a very sharp double-edge sword.

If you are a sufficiently elite programmer to write code that works bug-free on its first compile, then multi-threaded code is no harder than synchronous code.  But if, like most people, you rely on the crutch of finding bugs by testing, it becomes very easy for serious bugs to slip out.


Note that rather than use threading (multiple processes sharing the same address space), it would be better if the code were split into separate full processes that communicate via the networking APIs.  This would be slower than true threading, but would avoid a lot of the potential for bugs.  Better yet, with this approach, it would be possible to divide the load across multiple computers.

Imagine, after the next dot-com bust, buying a used datacenter-in-a-shipping-container for cheap and then playing DF across a 200-node cluster.... 

[ac31]

Imagine, after the next dot-com bust, buying a used datacenter-in-a-shipping-container for cheap and then playing DF across a 200-node cluster.... 

son, its stuff like this that keeps me sane