Irrlicht Engine

Code: Select all

class Ithread{
private:
     f32 *f32array;
     bool loadingrequest;

     void BreakIfLoading(); // a loop that wait extern users of the
                                      //  thread doing their loading of data
 
protected:

    virtual Ithread{

        using = false;
        loading = false;
        saving = false;
        f32array=new f32[size]; //or better an array datastruct

    }

    virtual void IdleThreadFunction{

        //no new variables declaration

        //put here the thread safe code
        // this function will be called periodically in the thread 
        // like a cycle.
        // makin calculations    
  
    }

    virtual void SavingThreadFunction{

        //when called (if is possibile write in data wich is not loaded
        // by some different thread)
        // this function wait for data is writable
        //so we can save the result of idle function calculation

        //we can also add the chance to break saving and continue later
        //if we are saving a lot of data

        // like this
        BreakIfLoading();

    }

public:

    void RequestLoading{

        //with this function you ask to load 
        //in this way you can let the thread know
        //that soon you will load data he is keeping

    }

bool LoadingPossible{
   //if is possible read data
}

virtual void Loadingfunction{
    //read data from thread calculation
    //not sure about return type or ByRef arguments
    // maybe a floating point array.
}

void WaitForload{
   //explicitly wait the end of saving in this thread
   //for loading in the thread using the data it needs
}

void LoadingEnd{
   //let the thread know he can start save data again
}

}

Code: Select all

int main{

    while(device->Run()){

        //doing something

        thread.RequestLoading();

        //doing something else

        if(thread.LoadingPossible)
            thread.LoadingFunction();
        else{
            thread.WaitForLoad();
            thread.LoadingFunction();  
        }

        //doing something else or save/load into the thread more
        //than one time

        thread.LoadingEnd();
    }
}

Code: Select all

//init code
if(CPU->has1Core)
    Ithread thread1(single);
else{
    Ithread thread1(multy);
    thread1->moveTo(2);//if we don't have 1 cpu we have at least 2 cpu
                                    //ok i know that normally the OS handles 
                                    //threads but this is just an example
}


//doing something

if(thread1->GetMode == single)
    thread1.Calculate(2) //run 2 times the idle function
    thread1.ForceSave() //then save result
else{
   thread1.RequestLoading();
   //calling thread1.Calculate if we are in multy mode will return exception
}

        //doing something else

        if(thread.LoadingPossible)
            thread.LoadingFunction();
        else{
            thread.WaitForLoad();
            thread.LoadingFunction();  
        }

Code: Select all

//request loading

 smgr->drawAllOne();

//loading from thread 
//let thread now the load is end

smgr->drawAllTwo();

//check for loading the thread that was in late after DrawAllOne

smgr->drawAllThree();

//finally if some thread is still lating wait it, maybe giving him more priority

//set his priority to normal

driver->endScene();

//update with new values