Mehrkern-Threading für Anfänger?! :)

[-horn-]

moien,

ich würde mal wieder was wissen.
ich habe bei meinem code einige stellen, die man sicherlich parallel bearbeiten könnte und zur zeit wird mein dual core centrino nur auf einem kern mit dem programm belastet.
ich würd mich also gern ein wenig mit threading anfreunen und dazu mal was lesen. hättet ihr da mal EINFACHE beispiele oder links zu eben solchen?
find das thema äußerst spannend, auch wenn das, wa sich bis jetzt laß, sehr komplex war.

grüße, Andreas

 

[maki]

*falscher thread*

 

[faetzminator]

Für spezifische Themen finde ich die Insel toll, ist das zu schwer für dich? Galileo Computing :: Java ist auch eine Insel (8. Auflage) – 11.2 Threads erzeugen

 

[eliot]

Mehrkern-Threading? Was soll das sein?
Du kannst auch mehrere Threads haben und dennoch nur einen Cpu-Core.
Es heißt Multithreading und nicht Multicorethreading.

Schau dir vor allem auch diese Kapitel an: Galileo Computing :: Java ist auch eine Insel (8. Auflage) – 11.5 Synchronisation über kritische Abschnitte

 

[-horn-]

moien,

so, ich hab meinen coderei lauffähig, allerdings dauert das sehr lange. das es lange dauert war mir klar , aber ich will auch keine tage auf das ergebnis warten müssen und hatte nun threaden anhand der bei galileo zu findenden infos versucht, aber das raffe ich nocht nicht ganz, wie ich das bei mir anwenden soll.

ich zeig euch mal eben einen ausschnitt:

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package schachteln;

/**
 *
 * @author Andreas
 */
public class finder {
    public static double[][][] bisection(int levelmax, int level, double[][] control, double[][] controlLimits, int controlIndex, double[] dtPhase, double[][] startconditions, double[][] dataSC, int[] stepsPhase, double stepsize){
        //double[][][] result = new double[2][][]; //{target[1],control[x][y]}

        double[][][]    result      =   new double[2][][]; //{target[1],control[x][y]}
                        result[0]   =   new double[1][1];
                        result[1]   =   control;

        double[][][]    resultl     = new double[2][][];
        double[][][]    resultr     = new double[2][][];
        double[][][]    resultm     = new double[2][][];

        // grenzen
        double boarderXl = 0;   // linke grenze
        double boarderXr = 0;   // rechte grenze

        if(controlLimits[level][0] != controlLimits[level][1]){
            //System.out.println("nicht gleich!");
            if(controlLimits[level][0]<controlLimits[level][1]){
                boarderXl = controlLimits[level][0];
                boarderXr = controlLimits[level][1];
            } else if(controlLimits[level][0]>controlLimits[level][1]){
                boarderXl = controlLimits[level][1];
                boarderXr = controlLimits[level][0];
            }


            // stellen
            double Xl   = boarderXl;
            double Xr   = boarderXr;

            double Xm   = 0;
            if(level%2==0){
                Xm   = (Xr+Xl)/2;               // X Mitte
            } else if(level%2==1){
                Xm   = Math.round((Xr+Xl)/2);   // INTcode X Mitte
            }

// 1. von hier parallel
            // werte
            control[level][controlIndex]    =   Xl;
            resultl                         =   recursion.out(levelmax, level, control, controlLimits, controlIndex, dtPhase, startconditions, dataSC, stepsPhase, stepsize);
            double Yl                       =   resultl[0][0][0];
            control[level][controlIndex]    =   Xr;
            resultr                         =   recursion.out(levelmax, level, control, controlLimits, controlIndex, dtPhase, startconditions, dataSC, stepsPhase, stepsize);
            double Yr                       =   resultr[0][0][0];
            control[level][controlIndex]    =   Xm;
            resultm                         =   recursion.out(levelmax, level, control, controlLimits, controlIndex, dtPhase, startconditions, dataSC, stepsPhase, stepsize);
            double Ym                       =   resultm[0][0][0];
// 1. bis hier parallel

            // temporaere umfuelldaten
            double tmpXl=0;
            double tmpXr=0;

            // abbruchkriterien
            int     counterMAX  = 30;      // damit die schleife sich nicht unendlich wiederholt notaus bei counterMAX schleifen
            int     counter     = 1;        // weil direkt fuer die ersten werte schon die halbierung gemacht wird
            int     stop        = 0;


            //System.out.println("level="+level+" Xl= " + Xl + " Yl= " + Yl + " | Xm= " + Xm + " Ym= " + Ym + " | Xr= " + Xr + " Yr= " + Yr);

            //INTcode aber auch nochmal fuer double ueberdenken!
            if(level%2==1 && (Xr-Xl)+1==2){   //+1 weil 0bis1=2intstellen sind
                //System.out.println("(Yr-Yl)+1==3");
                stop = 1;

                if(Yl < Ym && Ym <= Yr){
                    //System.out.println("LoesungLi: Xl= " + Xl + " Yl= " + Yl);
                    result[0][0][0]                 =   Yl;
                    control[level][controlIndex]    =   Xl;
                    result[1]                       =   control;
                } else if(Yl >= Ym && Ym > Yr){
                    //System.out.println("LoesungRe: Xr= " + Xr + " Yr= " + Yr);
                    result[0][0][0]                 =   Yr;
                    control[level][controlIndex]    =   Xr;
                    result[1]                       =   control;
                } else{
                    System.out.println("1. ungenau in Bisektion Level "+ level +" in INTEGER");
                }
            }
            // INTcode ende

            //for(int i=0; i<11; i++){
            while(stop==0){
                if(Yl < Ym && Ym <= Yr || Yl < Ym && Ym > Yr && Yl < Yr){
                    //System.out.println("links kleiner");
                    if((Xl+(Xl-Xm)) < boarderXl){
                        //Xl     = Xl;
                    } else{
                        tmpXl   = Xl+(Xl-Xm);
                        Xl      = tmpXl;
// 2. von hier parallel
                        control[level][controlIndex]    =   Xl;
                        resultl                         =   recursion.out(levelmax, level, control, controlLimits, controlIndex, dtPhase, startconditions, dataSC, stepsPhase, stepsize);
                        Yl                              =   resultl[0][0][0];
                    }
                    Xr   = Xm;
                    if(level%2==0){
                        Xm  =   (Xr+Xl)/2;
                    } else if(level%2==1){
                        Xm  =   Math.round((Xr+Xl)/2);                  // INTcode
                    }

                    resultr                         =   resultm;
                    Yr                              =   resultr[0][0][0];

                    control[level][controlIndex]    =   Xm;
                    resultm                         =   recursion.out(levelmax, level, control, controlLimits, controlIndex, dtPhase, startconditions, dataSC, stepsPhase, stepsize);
                    Ym                              =   resultm[0][0][0];
// 2. bis hier parallel

                } else if(Yl >= Ym && Ym > Yr || Yl > Yr && Yl < Ym && Ym > Yr){
                    //System.out.println("rechts kleiner");
                    if((Xr+(Xr-Xm)) > boarderXr){
                        //Xr   = Xr;
                    } else{
                        tmpXr   = Xr+(Xr-Xm);
                        Xr      = tmpXr;
// 3. von hier parallel
                        control[level][controlIndex]    =   Xr;
                        resultr                         =   recursion.out(levelmax, level, control, controlLimits, controlIndex, dtPhase, startconditions, dataSC, stepsPhase, stepsize);
                        Yr                              =   resultr[0][0][0];
                    }
                    Xl  =   Xm;
                    if(level%2==0){
                        Xm  =   (Xr+Xl)/2;
                    } else if(level%2==1){
                        Xm  =   Math.round((Xr+Xl)/2);                  // INTcode
                    }

                    resultl                         =   resultm;
                    Yl                              =   resultl[0][0][0];

                    control[level][controlIndex]    =   Xm;
                    resultm                         =   recursion.out(levelmax, level, control, controlLimits, controlIndex, dtPhase, startconditions, dataSC, stepsPhase, stepsize);
                    Ym                              =   resultm[0][0][0];
// 3. bis hier parallel

                } else if(Yl > Ym && Ym <= Yr || Yl >= Ym && Ym < Yr){
                    //System.out.println("nix kleiner");
                    if(level%2==0){
                        tmpXl   = (Xm+Xl)/2;
                        tmpXr   = (Xr+Xm)/2;
                    } else if(level%2==1){
                        tmpXl   = Math.round((Xm+Xl)/2);            // INTcode
                        tmpXr   = Math.round((Xr+Xm)/2);            // INTcode
                    }

                    Xl      = tmpXl;
                    Xr      = tmpXr;
// 4. von hier parallel
                    control[level][controlIndex]    =   Xl;
                    resultl                         =   recursion.out(levelmax, level, control, controlLimits, controlIndex, dtPhase, startconditions, dataSC, stepsPhase, stepsize);
                    Yl                              =   resultl[0][0][0];
                    control[level][controlIndex]    =   Xr;
                    resultr                         =   recursion.out(levelmax, level, control, controlLimits, controlIndex, dtPhase, startconditions, dataSC, stepsPhase, stepsize);
                    Yr                              =   resultr[0][0][0];
// 4. bis hier parallel

                } else{
                    System.out.println("2. ungenau in Bisektion Level "+ level +" Xl="+Xl+";Yl="+Yl+";Xm="+Xm+";Ym="+Ym+";Xr="+Xr+";Yr="+Yr+" in DOUBLE");
                }

                counter = counter + 1;
                if(level%2==0){
                    if((Xr-Xm) <= stepsize || counter >= counterMAX){
                    //System.out.println(Xr-Xm);
                    //System.out.println(counter);
                    stop = 1;
                    }
                } else if(level%2==1){
                    // INTcode
                    if((Xr-Xm)<=1 && (Xm-Xl)<=1 && Ym<=Yr && Ym<=Yl || (Xr-Xm)<=1 && (Xm-Xl)<=1 && Ym>=Yr && Ym>=Yl || counter>=counterMAX){
                        //System.out.println("abstand=1; " + (Xr-Xm) +";" + (Xm-Xl)+ " Yl="+Yl+";Ym="+Ym+";Yr="+Yr+" counter="+counter);
                        //System.out.println(Xr-Xm);
                        //System.out.println(counter);
                        stop = 1;
                    }
                }

                //System.out.println("level="+level+" Xl= " + Xl + " Yl= " + Yl + " | Xm= " + Xm + " Ym= " + Ym + " | Xr= " + Xr + " Yr= " + Yr);


            }

            // PLATZHALTER: hier werden dann die letztendlichen rueckgabewerte erzeugt
            if(Yl < Ym && Ym <= Yr){
                //System.out.println("Level="+level+" Loesung: Xl= " + Xl + " Yl= " + Yl);
                result[0][0][0]                 =   Yl;
                control[level][controlIndex]    =   Xl;
                result[1]                       =   control;
                //output = Xl;
            } else if(Yl >= Ym && Ym > Yr){
                //System.out.println("Level="+level+" Loesung: Xr= " + Xr + " Yr= " + Yr);
                result[0][0][0]                 =   Yr;
                control[level][controlIndex]    =   Xr;
                result[1]                       =   control;
                //output = Xr;
            } else if(Yl > Ym && Ym <= Yr || Yl >= Ym && Ym < Yr){
                //System.out.println("Level="+level+" Loesung: Xm= " + Xm + " Ym= " + Ym);
                result[0][0][0]                 =   Ym;
                control[level][controlIndex]    =   Xm;
                result[1]                       =   control;
                //output = Xm;
            } else{
                System.out.println("3. ungenau in Bisektion Level "+ level +" in DOUBLE Loesung");
            }

        } else{
            System.out.println("input1 und input2 sind gleich");

            // PLATZHALTER: hier werden dann die letztendlichen rueckgabewerte erzeugt
            result[0][0][0]                 =   result[0][0][0];
            control[level][controlIndex]    =   controlLimits[level][0];
            result[1]                       =   control;

            //output = controlLimits[level][0];
        }

        return result;

        // bisection
        // hier muss der bisectionsalgo control zwischen den controlLimits verandern
        // und auf die trajectories zugreifen.
        //System.out.println("bisection in level= " + level + " controlIndex=" +controlIndex);
        
        //result = recursion.out(levelmax, level, control, controlLimits, controlIndex, dtPhase, startconditions, dataSC, stepsPhase, stepsize);

        //return result;
    }

}

damit es schneller zu finden ist hab ich euch da mal "// 1. von/bis hier parallel" eingefügt und dan an 4 stellen.
denn in diesen bereichen gibt es die recursion.out() und die berechnungen dort dauern halt länger. das ganze ist, wie man vermuten kann als sich selber aufrufend gemacht und dazu habe ich nun meine erste frage.
wenn ich nun innerhalb dieser public static thread vergebe, sind die dann auch unabhängig, so dass diese public später nochmals aufgerufen innerhalb der rekursion dann auch dort neue threads vergibt?

und generell, wie würde das nun mit dem parallel bei mir gehen. das recursion.out() sollte schon threadbar sein, denn ich brauche nur das ergebnis daraus, um damit vergleiche zu machen. ich habe da eine bisektion gemacht, wo ichmir am linken und rechten rand des spektrums und genau in der hälfte den wert berechnen lasse und dann die drei werte miteinander zu vergleichen, um denkleinsten wert rauszukriegen. Bisektion ? Wikipedia
im restlichen code brauch nix parallel, weil das kleine fische im gegensatz zu den berechnungen dort sind.

grüße, Andreas

 

[suelman]

// 1. von hier parallel
            // werte
            control[level][controlIndex]    =   Xl;
            resultl                         =   recursion.out(levelmax, level, control, controlLimits, controlIndex, dtPhase, startconditions, dataSC, stepsPhase, stepsize);
            double Yl                       =   resultl[0][0][0];
            control[level][controlIndex]    =   Xr;
            resultr                         =   recursion.out(levelmax, level, control, controlLimits, controlIndex, dtPhase, startconditions, dataSC, stepsPhase, stepsize);
            double Yr                       =   resultr[0][0][0];
            control[level][controlIndex]    =   Xm;
            resultm                         =   recursion.out(levelmax, level, control, controlLimits, controlIndex, dtPhase, startconditions, dataSC, stepsPhase, stepsize);
            double Ym                       =   resultm[0][0][0];

ich kenne dein recursion.out nicht, aber sofern die parameter (wie z.B. control) sich durch die aufrufe verändern, hängen sie sequenziell voneinander ab. Sprich der zweite Aufruf benötigt das ergebnis des ersten. Sofern das der Fall ist, kannst du die einzelnen Aufrufe logischerweise nicht parralel berechnen. Ansonsten könntest du sowas wie:
(mal ganz einfach)

new Thread(){
 public void run(){
 control[level][controlIndex]    =   Xl;
            resultl                         =   recursion.out(levelmax, level, control, controlLimits, controlIndex, dtPhase, startconditions, dataSC, stepsPhase, stepsize);
double Yl                       =   resultl[0][0][0];
}}.start();
new Thread(){
 public void run(){
             control[level][controlIndex]    =   Xr;
            resultr                         =   recursion.out(levelmax, level, control, controlLimits, controlIndex, dtPhase, startconditions, dataSC, stepsPhase, stepsize);
 double Yr                       =   resultr[0][0][0];

}}.start();

new Thread(){
 public void run(){
control[level][controlIndex]    =   Xm;
            resultm                         =   recursion.out(levelmax, level, control, controlLimits, controlIndex, dtPhase, startconditions, dataSC, stepsPhase, stepsize);
            double Ym                       =   resultm[0][0][0];

}}.start();

versuchen. Denn laufen die berechnungeb Parralel. Demnach könnte die jvm die Berechnungen auf verschiedenen Kernen durchführen. Ich leg aber nicht die hand dafür ins feuer, dass sie das macht. Ansonsten müsstest du die Methode auslagern, eine neue Instanz der jvm auf einen anderen Kern starten und diese dann mit entsprechenden Parametern aufrufen. Das ist aber nicht mal schnell gemacht soweit ich weiß.

 

[suelman]

ich vergaß, nach dem dritten Threadaufruf musst du natürlich erstmal warten bis die drei Threads durchgelaufen sind, bevor du mit deinem Code fortfährst.

 

[-horn-]

moien,

ich hab das mal, wie suelmann vorgeschlagen, versucht, aber das klappt nicht.
zum zusammenführen der threads hatte ich join ausgemacht, aber wie kriege ich werte rein und wieder aus dem thread raus? das ist mir noch nicht ganz klar.

grüße, Andreas

 

[Painii]

moien,

ich hab das mal, wie suelmann vorgeschlagen, versucht, aber das klappt nicht.
zum zusammenführen der threads hatte ich join ausgemacht, aber wie kriege ich werte rein und wieder aus dem thread raus? das ist mir noch nicht ganz klar.

grüße, Andreas

Für jeden Thread ein eingenes Objekt bauen was du übergibst, das kann dann im Konstruktor die Werte bekommen.


Zum zurückgeben gibts 2 Varianten:
a) Wenn der Thread fertig ist gibts du die Werte über eine Methode zurück, etwa so:

public int getWert(){
if(nochNichtFertigGerechnet)throw new NochNichtFertigException();
else return ergebnis;
}

b) Observer/Observable, der Thread benachrichtigt Aufrufer mit dem Wert.

 

[bygones]

whau... ernsthafte Frage:

verstehst du selber deinen code ?
kann dein Code ein unbedarfter verstehen beim drueberfliegen ?

verzeih mir, aber das ist echt harter Tobak....

 

[sparrow]

Kurz am Rande, ohne Bezug auf deinen Code: In Java kannst du einen Thread nicht fest einem Kern zuweisen.
In den meisten anderen Sprachen übrigens auch nicht.
Das Scheduling, und damit auch die Threadaufteilung auf die Kerne, übernimmt der Scheduler des Betriebssystems.

Was du persönlich brauchst ist ein kleiner Manger der eine von dir definerte Anzahl von Threads startet (2 oder 3), und dann nachdem einer davon durch ist einen weiteren anwirft.
Probier vielleicht erstmal ohne den eigentlichen Inhalt des Threads, das macht es... unübersichtlich.

 

[-horn-]

moien,

whau... ernsthafte Frage:

verstehst du selber deinen code ?
kann dein Code ein unbedarfter verstehen beim drueberfliegen ?

verzeih mir, aber das ist echt harter Tobak....

jo, ich verstehe den und ich weiss auch, dass der kruddellig aussieht, aber ich bin auch kein programmierer, der tausend arten kennt, zum selben ergebnis zu kommen und sich dann den schönsten weg aussucht. ich bin froh, wenn ich einen kenne und der dann funktioniert. und das ich den noch nicht kommentiert habe, hatte ich ja glaube ich erwähnt.

Kurz am Rande, ohne Bezug auf deinen Code: In Java kannst du einen Thread nicht fest einem Kern zuweisen.
In den meisten anderen Sprachen übrigens auch nicht.
Das Scheduling, und damit auch die Threadaufteilung auf die Kerne, übernimmt der Scheduler des Betriebssystems.

Was du persönlich brauchst ist ein kleiner Manger der eine von dir definerte Anzahl von Threads startet (2 oder 3), und dann nachdem einer davon durch ist einen weiteren anwirft.
Probier vielleicht erstmal ohne den eigentlichen Inhalt des Threads, das macht es... unübersichtlich.

ich wollte auch nicht explizit einen thread einem kern zuweisen, ich möchte nur gerne explizit einen codebereich zu einem thread zusammenfassen, so dass dann der compiler sieht, dass der das parallel zu machen hat. auf welchen kern der das dann berechnet ist mir egal. mir ist nur wichtig, dass es schneller fertig wird.
und genau wegen kleinere beispiele bin ich ja hier und hatte den thread hier gestartet. ich hatte mir auch die beispiele bei der javainsel angeguckt und verstehen tu ich das vom prinzip auch, nur sind mir die beispiele dann nicht so, dass ich die gleich anpassen und auf mein problem übertragen kann.

grüße, Andreas

 

[sparrow]

Ich habe so etwas erst einmal gebraucht. Das ist auch schon ein paar Tage her.
Ohne Warnings sieht das heute wie folgt aus:

package test;

import java.util.ArrayList;
import java.util.Random;




public class Main {

    private static int CON_THREADS = 2;
    private static int THREADS = 20;

    ArrayList<TestThread> tlist;
    int threadcount = 0;

    public static void main(String[] args) {
        Main m = new Main();
        m.doWork();
    }

    public void doWork() {
        tlist = new ArrayList<TestThread>();
        // init dummy-threads
        for (int i = 0; i < THREADS; i++) {
            tlist.add(new TestThread(i, this));
        }
        // starting threads
        for (int i = 0; i < CON_THREADS; i++) {
            startNextThread();
        }
    }

    synchronized public void startNextThread() {
        if (threadcount < tlist.size()) {
            Thread t = tlist.get(threadcount);
            t.start();
            threadcount++;
        }
    }



    class TestThread extends Thread {

        private int id;
        private int sleeptime;
        private Main main;

        public TestThread(int id, Main main) {
            this.id = id;
            this.main = main;
            sleeptime = new Random().nextInt(4000) + 1000;
            System.out.println("Thread " + id + " init wit " +
                    sleeptime + "ms sleeptime");
        }

        public void run() {
            System.out.println("Thread gestartet: " + id);
            try {
                Thread.sleep((long) sleeptime);
            } catch (InterruptedException ex) {
                ex.printStackTrace();
            }
            System.out.println("Thread beendet: " + id);
            main.startNextThread();
        }
    }
    
}

Der Thread bekommt also die Möglichkeit auf den Manager zuzugreifen und dort vor seinem Ableben den Start des nächsten Threads anzufordern. Wenn man also anfangs 2 Threads startet diese wiederrum im Manager ihre Nachfolger.

 

[-horn-]

Ich habe so etwas erst einmal gebraucht. Das ist auch schon ein paar Tage her.
Ohne Warnings sieht das heute wie folgt aus:
...

moien,

du, keine panik. ich hab das auch vorher noch nicht gemacht!
ich brauche deswegen ne kleine zeit, bis ich da sverstanden habe, was du da tust. ich meld emich bei bedarf, wollte aber schonmal danke sagen.

 

[sparrow]

Joah, wenn du noch Fragen hast, einfach Fragen.

Im Groben geht es nur darum, dass du eine gewünschte Anzahl von Threads startest und jeder Thread der mit seiner Arbeit fertig ist als letzte Anweisung einen neuen Thread startet.