using threads for world gen

[endershadow]

One of my structures causes the game to lag while it's being generated, and I was wondering if anyone knows how I can put it in a seperate thread to reduce the lag caused during structure generation. I just need to know how I would get the structure to generate in the new thread. I already have a class sort of set up. Here's what I have so far.

https://github.com/code-lyoko-modding/CodeLyokoMod/blob/master/matt/lyoko/lib/TowerGenThread.java

[Yagoki]

I suck at threading so I'm probably not much help, but to create a new thread do you not just call

(new Thread(Runnable runnable)).start()

at the point in the game loop where you want the thread to start?

 

this causes the run method to be called in your Runnable class, so form there call your methods to generate the structure

[endershadow]

yes, but how do I make the thread do the world gen? I'm just not sure how to set up the run method. but I'll see what I can do.

[endershadow]

ok, I got the thread to work, but it didn't reduce the lag at all. is there anything else I need to do? here's all the classes used

https://github.com/code-lyoko-modding/CodeLyokoMod/blob/master/matt/lyoko/world/WorldGenTower.java

https://github.com/code-lyoko-modding/CodeLyokoMod/blob/master/matt/lyoko/lib/TowerGenThread.java

https://github.com/code-lyoko-modding/CodeLyokoMod/blob/master/matt/lyoko/world/StructureTower.java

[Yagoki]

given you pass it an object instance of the runnable class, can you not pass the required variables through the constructor for that then use them in the generation methods? I will repeat that I suck with threading and you will probably have to be careful with de-synchronizing the world variable (so two different ones exist as one was changed in the thread and the other remained the same) but I can't think how to fix this (lots of synchronization at points possibly???) I'll look into how to fix that in a bit

 

I'm probably being as useless as a... well.... as s sleep deprived me...

 

you did all i was just typing, looks like my knowledge isn't as bad as I thought it was

 

I'll look through your classes, but I probably won't be to much use in this state... why is England so hot all of a sudden???

[hydroflame]

hey there, i do have some thread knowledge and i think i might be able to help you. since youre asking the qestion youre obviously not a noob soooo i wont go into deep details.

but basicly youre gonna want your world generator to create more then 1 thread, because if you only create 1 youre not solving the problem at all (feel free to ask why you need more then 1)

basicly each thread will have to do 1/number of thread  of your structure

aka, if your structure is 50 block long (doesnt matter how much width and height) and you have 5 thread, thread 1 will do from 0-9, T2 from 10-19 etc

 

so make some class extends Runnable or even thread, make the constructor of this thread have a reference to the world, the starting location of the structure, the structure youre trying to do and which part of it the thread is suppose to construct.

also include a reference to the thread that started the threads (aka the world generator )

 

once thats all setup, in the world generator starts/run all thread and wait for them to complete. 

 

it is important to note that minecraft is single threaded and it is a huge problem. so i suggest that even before starting to work on this. make a program an try to understand how thread works and specificly what are the functions Object.wait and Object.notify are doing (btw you know that every class that doesnt extends something specificly by default extends Object right ? so every object has the methods wait and notify)

 

sry if my explanation is shitty but ive written all this on a phone

fell free to pm me

[endershadow]

I sometimes answer things like this on my phone too, so I know how you feel. I actually got a decent Thread set up, but why do I need multiple threads if minecraft is single threaded? and how would I use the wait and notify methods in this scenario.

[hydroflame]

round 2 (this "keyboard is painfull)

 

ok so in the case that you are using only 1 thread, basicly this would happen.

the minecraft thread creates a new thread, calls this thread and wait til its done... basicly while the main thread is waiting you got only 1 thread running, you didnt solve anything because overall, theres 1 thread doing nothing, 1 working. its the same as just having 1 thread doing all the work

 

in the case of creating 2 thread, you have the main thread waiting but 2 thread creating the structure

this is when you start gaining power

if you've actually read about wait and notify and dont understand them heres another solution

 

have the main thread create and start all thread and then have the main thread do something like this

for(all my thread){

while(!thread.isDoneGenerating()){}

}

 

make sure the custom thread set a boolean value to true tgat will be returned by isDoneGenerating when they are done generating their part

 

basicly if it takes 5 sec (its just an overkill example) to generate the structure, they should all finish at the same time. so the mc server thread will do the first "while" a lot but then the next while might not even make it in once

 

if thats still not clear tell me

and sorry for the shitty typing/typos/explanation, coding on a phone is horrible

[endershadow]

let me see if I can understand this. you want me to make a bunch of threads with the default boolean value to false. then you want me to iterate through them all and while they're not finished, you want me to do something? I'm still kind of confused. if you have a skype it might be easier to talk through there.

[hydroflame]

nope all good i got a computer ill be albe to make complete answers

 

ok so basicly your code to generate the world will look like this

 

public void idontknowthename(arguments){
//code
StructureGeneratorThread[] threads = new StructureGeneratorThread[5];
for(int i = 0; i < threads.length; i++){
threads[i] = new StructureGeneratorThread(/*argument to give to have all information */ world, structureToGenerate, startIndex, endIndex);
}

for(StructureGeneratorThread thread : threads){//do you know about this way of writing for loops ? if not its just going to iterate through the list
thread.start();
}

for(StructureGeneratorThread thread : threads){
while(!thread.isDone()){}
}
//more code
}

 

public class StructureGeneratorThread extends Thread{
boolean isDone = false;
public StructureGeneratorThread(/*the args showed earlier*/){
blah blah save all the args
}

public void run(){//this method will be automaticly called when start() is called
//here you generate the structure from startIndex to endIndex, aka thread 1 from 0-9, 2 from 10-19 etc if its 5 thread for a 50 block wide structure

isDone = true;
}

public boolean isDone(){ return isDone;}
}

 

[hydroflame]

so heres how to read this code

 

 

when youll start generating the structure, the server thread creates X "sub threads" each of those will be responsible to generate 1/X of the structure. (pick any axis and keep it as the "seperatable axis" exemple if you have a 10x20x30 structure, and you chose the x axis, the threads will generate from 1x20x30 to 5x20x30 and 6x20x30 to 10x20x30 (this is for 2 threads,  x threads= x subdivision) now the first loop creates all the threads and tell them which part they are responsible for

 

the 2nd loops starts all the thread, after the 2nd loop is done executing all the threads will be generating the structure

 

since they're all running in parallel the event log from this could look like this:

situation 2 thread generating a 2x2x2

 

thread1: generated 1, 1, 1

thread2: generated 2, 1, 1

thread1: generated 1, 1, 2

thread2: generated 2, 1, 2

thread1: generated 1, 2, 1

thread2: generated 2, 2, 1

thread1: generated 1, 2, 2

thread2: generated 2, 2, 2

 

optionnal note: since they are running in parallel this could be happening in ANY order (for some reason is it possible that the 2nd thread will generate more slowly but GENERALLY i should be pretty "symmetrical" )

 

so after the 2nd loop they're all generating and thats great, but how do we know its done? this is what the third loop is for

 

you see, at the end of the "run" method theres a isDone = true

meaning when the thread is done generating its own part of the structure itll set the boolean to true and the function isDone will now return true

 

the 3r loop basicly goes through each thread and wait til they are done generating

since this is happening in parrallel this SHOULD happen all at the same time

so the 3rd loop might wait 50 iteration of the while for the 1st loop to be done, but when itll be done all the other threads should ALSO be done, meaning it might not even enter then once !

 

was that better ?

[pelep]

the minecraft thread creates a new thread, calls this thread and wait til its done... basicly while the main thread is waiting you got only 1 thread running, you didnt solve anything because overall, theres 1 thread doing nothing, 1 working. its the same as just having 1 thread doing all the work

 

sorry for hijacking this thread (no pun intended), but @hydroflame, wouldn't there be two threads running if you create a new thread (the main mc thread and the new one you created)? correct me if i'm wrong, but wouldn't the main mc thread continue running whether or not the new one's finished (it's a new separate thread after all)?

[hydroflame]

hijacking this thread

i loled

 

wouldn't there be two threads running if you create a new thread (the main mc thread and the new one you created)?

you are absolutelly right there will be 2 thread running BUT the thin is the server thread cannot continue its work until the generation is finished. saying that it can continue it works (like continue to generate the caves n everything) would mean that from anywhere in the code you can receive the "is finished" message from the generating threads.

 

technicly... it could be possible that the generating threads (GT) would NOT in ANY way communicate with the main thread other then by the method that creates then

 

this "technique" would imply that the threads have "queue" of structure to generate and whenever the world gen wants to generate a structure he simply queues it to the least filled queue

 

the code would ressemble this

 

public class TowerGen implements IWorldGen{

private TowerGenThread[] threads;

public TowerGen(){

threads = new TowerGenThread[5];

}

 

public void generateTower(){

 

//code to decide where/if to put a tower

//find tower with least ammount of queued tower

//add tower to that thread

 

//more code if you want

 

}

 

 

}

 

public class TowerGenThread extends Thread{

private Queue towerToGen = new IDontKnowTheExactClassName();

 

public int getQueueSize(){

return towerToGen.size();

}

 

 

public void addToQueue(/*args that describe the location*/){

towerToGen.add(the args, either an object or wtv);

}

 

public void run(){

while(true){

if(towerToGen.hasNext()){//or wtv the name to check if theres an object in the queue

//code to generate the tower

}

}

}

 

bascily this would also work, BUT you might find yourself in situation where a particular chunk isnt loaded because it took so much time that the player leaved the general area where the tower was supposed to be generated

 

 

 

both design have advantage and disadvantage

 

the first one keep the main idea of "single thread" because the server doesnt continue until its done but will be useless if the structures are very small

 

if the structure are numerous but small in size the 2nd design MAY be a better solution.

 

[pelep]

BUT the thin is the server thread cannot continue its work until the generation is finished

 

woops. didn't see that "while(!blabla.isDone)" part at first. anyway, i was just clarifying

[Guff]

ExecutorService exe = Executors.newCachedThreadPool();
exe.execute(new MyWorldGenThread(params));

That will run alongside the main thread. I just tested it with one of my mods by executing the Runnable using the service. By printing a line at the start of the run() method, and then another during a loop, and then placing a line after the exe.execute() invocation, you will see something like this:

 

The thread has started

Test 1

Test 2

This should show after the thread has started

Test 3

Test 4

Test 5

 

This should help you run a world gen thread alongside the main thread.

[endershadow]

Thanks! you all helped me alot with this. It now works how I want it to.