Factorio Forums

slpwnd wrote:The original idea here was to simulate different chunks in different threads. However this is quite tricky to do properly - namely because overlaps and special cases. Another approach we have been thinking about recently is to do some "thematic" parallelization. Things like electric energy propagation, path finder, rail finding.

The list isn't so scary after all, so my optimistic estimate for 0.12 is 1.5 months from now, while slpwnd estimates 2.5 months from now. I know he is going to be right, but I still prefer to be optimistic and I also prefer to be pushed by deadlines.

McRib wrote:

The list isn't so scary after all, so my optimistic estimate for 0.12 is 1.5 months from now, while slpwnd estimates 2.5 months from now. I know he is going to be right, but I still prefer to be optimistic and I also prefer to be pushed by deadlines.

You mean version 12.01 or you mean a stable version 12.xx?

McRib wrote:

The list isn't so scary after all, so my optimistic estimate for 0.12 is 1.5 months from now, while slpwnd estimates 2.5 months from now. I know he is going to be right, but I still prefer to be optimistic and I also prefer to be pushed by deadlines.

You mean version 12.01 or you mean a stable version 12.xx?

Steam integration
This is not technically part of 0.12 as we plan to go to the steam when the 0.12 is stable, but this time we decided to postpone it no more.

slpwnd wrote:Yes. The goal is to make it playable even with 1s latency. However the latency hiding won't be perfect. This involves some dirty internal tricks, therefore we decided to go for most common actions. Things like moving, building, mining, etc. They will be (unless there is a collision) instantaneous. However in non-latency hidden actions the lag will still be felt. More on this will be in the fff.

ssilk wrote:So, what has happened to the hedgehog?

ssilk wrote:In the FFF the whole crew is mentioned.
The whole?
No!
A little hedgehog is missing! See https://www.factorio.com/team

So, what has happened to the hedgehog?

cpy wrote:I wonder if main thread threading is planned, because you could build 4x ish bigger factories on quadcore cpu.

bulldog98 wrote:

cpy wrote:I wonder if main thread threading is planned, because you could build 4x ish bigger factories on quadcore cpu.

The only thing that comes into my mind for this is the following:

cpy wrote:Hmm, i think some scripts can definitely be threaded, not necessarily useful in normal game but i'm sure mods could benefit if they could multithread some scripts.
Like treefarm, you don't need to check trees in any particular order if they want to grow, you can check them like 16 - 32 at once with threads. I'm sure there are other scripted mods that could use it.

orzelek wrote:

cpy wrote:Hmm, i think some scripts can definitely be threaded, not necessarily useful in normal game but i'm sure mods could benefit if they could multithread some scripts.
Like treefarm, you don't need to check trees in any particular order if they want to grow, you can check them like 16 - 32 at once with threads. I'm sure there are other scripted mods that could use it.

Threading of those would have quite complicated consequences for determinism of game. It could be tricky to make sure that they are threaded in exactly same way on all clients.

orzelek wrote: Threading of those would have quite complicated consequences for determinism of game. It could be tricky to make sure that they are threaded in exactly same way on all clients.

void tick(float powerfactor){//is the % of power available to allow slower progress
    if (inprogress){
        //update progress bars depending on power factor

        if(progress==100){
            //add result to output
        }
    }
    if(hasEnoughIngredients && outputNotFull){
        //remove the inputs

        inprogress = true;
    }
}

ratchetfreak wrote: In the lua engine you could say, given this collection of entities run this code once for each of them. With the restriction that the function is only allowed to access that entity and read-only basic values. Adding a reduce (adding the results of the function together) on the results is a simple followup.

parallelFor(entitiesToProcess, 
            [TempEnginePool]()=> TempEnginePool->pop(),
            [&Staticinputs](Pair<Entity*, Vector<LuaCode> e, LuaTempEngine* le)=>{
                le->prepEngine(e.first, Staticinputs); 
                foreach(LuaCode code in e.second)
                    le->run(code);
               le->propagateChangesToEntity(e);
            }, 
            [TempEnginePool](LuaTempEngine* le)=>TempEnginePool->release(le));

• the first parameter is the collection of entities,
• the second is the per thread init to get a temporary lua engine from a pool,
• the thirds is the per entity code to set the engine's globals as needed and run the code and finally propagate the changes to the entity back
• the final one is per thread cleanup to release the engine back into the pool