Kurze Frage zu Threads



  • Hi,

    ich würde gerne Aufgaben effizient in Threads aufteilen.
    Vorrausgesetzt ich habe erkannt, dass ich 4 Threads
    parallel laufen lassen kann, dann würde ich
    ein Array mit 4 Threads erzeugen.

    Kann ich die Abzuarbeitende Funktion eine Threadinstanz ändern, oder muss ich
    Jedes mal einen ganzen neune Thread erzeugen, wenn eine Funktion abgearbeitet worden ist.

    Gruß



  • Kannste die 4 Threads gerne durchlaufen lassen, die hiolen sich von einer gemeinsamen Queue oder Pipe ihre Aufträge.



  • Bevorzuge 1 Thread pro Core, nicht 1 Thread pro Arbeit.



  • Okay,
    ich denke es läuft.
    Ich müßte jetzt 5 Threads haben, welche meine Pipe bearbeiten.

    Kann ich in einer Threadfunktion herrausfinden, welche ID der Thread momentan hat ??

    Einfach zum Prüfen, ob auf brav alle ihre Arbeit machen.

    EDIt: Also ich arbeite mit boost::Tread





  • Hi PI,

    also wenn cih auf den aktuellen Thread zugriff habe, dann ist es kein Problem.
    Aber ich suche nach etwas, wo ich innerhalb des Threads die eigene ID rausfindenkann...
    Ich hatte es davor schonmal mit
    boost::this_thread::id
    versucht..

    EDIT: Trotzdem cooler link =).



  • Läuft wie ne Eins =)...



  • Wofür brauchst du eine Thread-ID?

    Außerdem ging mir es eigentlich zu schnell wie du dann eine Lösung gefunden hast.

    Kannst du mal deinen Code posten?

    Ich glaube volkard meinte es etwa so:

    #include <iostream>
    #include <boost/thread.hpp>
    #include <boost/interprocess/sync/scoped_lock.hpp>
    
    class Task;
    
    class TaskQueue{
    public:
    	void add(Task* task){
    		boost::mutex::scoped_lock l(mutex);
    		queue.push_back(task);
    		empty_condition.notify_one();
    		std::cout << "adding task" << std::endl;
    	}
    
    	Task* task(){
    		boost::mutex::scoped_lock lock(mutex);
    		while(queue.empty())
    			empty_condition.wait(lock);
    		typename std::list<Task*>::iterator it = queue.begin();
    		queue.erase(it);
    		std::cout << "removing task" << std::endl;
    		return *it;
    	}
    
    private:
    	boost::mutex mutex;
    	std::list<Task*> queue;
    	boost::condition_variable empty_condition;
    };
    
    class Task{
    public:
    	virtual void execute() = 0;
    };
    
    class Thread{
    public:
    	Thread(TaskQueue& task_source) : task_source(task_source){}
    
    	void operator()(){
    		while(true){
    			Task* task = task_source.task();
    			task->execute();
    			delete task;
    		}
    	}
    
    private:
    	TaskQueue& task_source;
    };
    
    class ThreadPool : public TaskQueue{
    public:
    	ThreadPool(unsigned int count){
    		for(int i=0; i<count; ++i){
    			boost::thread(Thread(*this));
    		}
    	}
    
    };
    
    class CounterTask : public Task{
    public:
    	CounterTask(unsigned int i) : i(i){}
    
    	virtual void execute(){
    		for(int j=0; j<i; ++j){
    			std::cout << j << std::endl;
    		}
    	}
    
    private:
    	unsigned int i;
    };
    
    int main(){
    	ThreadPool pool(5);
    	for(int i=0; i<11; ++i){
    		pool.add(new CounterTask(i*1000));
    	}
    	while(true);
    }
    


  • Hi XSpille,

    ich habs mir aus dem alten zusammengebaut. Find deine Lösung aber schöner =).

    Werd ich mir merken =).

    Aber im Grunde machen wir beide das Selbe.



  • Weißt du eigentlich ob Boost was bietet für Dreiecksnetze ??
    Hab glaub mal was von einem Geometrie Teil gelesen....



  • Meinst du Meshes? Was haben Meshes nu mit Threads zu tun? 😕



  • Hi Hustebär 🙂

    nicht sonderlich viel. War eher als belanglose Frage zu später Stunde gedacht.
    Aber ja ich meine Meshes.



  • Also ich kenne da nix. Ist auch reichlich speziell finde ich.

    Davor erwarte ich mir erstmal ne ordentliche Mathe-Library mit schönen fixed-size Vektor und Matrixklassen, hübsch optimiert mit SSE und allem. Das wäre IMO ausreichend allgemein um wirklich nützlich zu sein. Jede 2D/3D Engine implementiert sich das selbst, jedes GUI Toolkit etc. - das muss ja nicht sein.

    Darauf könnte man dann evtl. was aufbauen was mit Meshes arbeitet.



  • 🙂 Andere Leute träumen von Eiss bei dem Wetter.
    Aber mir gehts ähnlich. Mir wären ein paar Software-Erweiterungen auch lieber.

    Aber nochmal ein weiter Sprung. Kennst Du eine gute Beschreibung wo das Thema Dynamisch gelinkte Bibliotheken gut angeht.
    In erster Linie wie man die Schnittstelle ordentlich definiert. Also auch die Rückgabewerte. Ich brächt sogar ne Callback.... Kenne mich aber mit DLLs nicht aus. Plattform unabhängig sollte der Code auch noch sein. ...
    Dann sollte das ganze Ding auch noch Threadsafe sein.
    Ich frage, weil das Thema neu für mich ist, und der erste Eindruck eienr Sache
    meißt am besten hängen bleibt und ich möchte nicht mit einer schlechten Beschreibung beginnen...

    Grüße

    EDIT: Will damit sagen, ich kann mir selbst was raussuchen, aber ich kann nicht entscheiden ob das dann gut ist. 🙂


Log in to reply