Bezogen auf meineandere FrageIch habe jetzt den Solver für dünne Matrizen so geändert, dass er die SOR-Methode (Sukzessive Over-Relaxation) verwendet. Der Code lautet nun wie folgt:

void SORSolver::step() {
    float const omega = 1.0f;
    float const
        *b = &d_b(1, 1),
        *w = &d_w(1, 1), *e = &d_e(1, 1), *s = &d_s(1, 1), *n = &d_n(1, 1),
        *xw = &d_x(0, 1), *xe = &d_x(2, 1), *xs = &d_x(1, 0), *xn = &d_x(1, 2);
    float *xc = &d_x(1, 1);
    for (size_t y = 1; y < d_ny - 1; ++y) {
        for (size_t x = 1; x < d_nx - 1; ++x) {
            float diff = *b
                - *xc
                - *e * *xe
                - *s * *xs - *n * *xn
                - *w * *xw;
            *xc += omega * diff;
            ++b;
            ++w; ++e; ++s; ++n;
            ++xw; ++xe; ++xs; ++xn;
            ++xc;
        }
        b += 2;
        w += 2; e += 2; s += 2; n += 2;
        xw += 2; xe += 2; xs += 2; xn += 2;
        xc += 2;
    }
}

Nun ist die seltsame Sache: Wenn ich zunehmeomega (der Relaxationsfaktor), beginnt die Ausführungsgeschwindigkeit zu hängendramatisch auf die Werte in den verschiedenen Arrays!

Zumomega = 1.0fist die Ausführungszeit mehr oder weniger konstant. Zumomega = 1.8B. 5 Millisekunden, um dies auszuführenstep() 10-mal, dies wird jedoch während der Simulation allmählich auf fast 100 ms erhöht. Wenn ich setzeomega = 1.0001fIch sehe eine entsprechend leichte Verlängerung der Ausführungszeit; der höhereomega Wenn dies der Fall ist, erhöht sich die Ausführungszeit während der Simulation.

Da dies alles in den Fluid Solver eingebettet ist, ist es schwierig, ein eigenständiges Beispiel zu finden. Aber ich habe den Anfangszustand gespeichert und den Löser in diesem Zustand jedes Mal neu ausgeführt sowie nach dem tatsächlichen Zeitschritt gesucht. Für den Anfangszustand war es schnell, für die folgenden Zeitschritte schrittweise langsamer. Da alles andere gleich ist, zeigt dies, dass die Ausführungsgeschwindigkeit dieses Codes von den Werten in diesen sechs Arrays abhängt.

Dies ist unter Ubuntu mit g ++ sowie unter 64-Bit-Windows 7 reproduzierbar, wenn mit VS2008 für 32-Bit kompiliert wird.

Ich habe gehört, dass NaN- und Inf-Werte für Gleitkommaberechnungen langsamer sein können, aber keine NaN- oder Inf-Werte vorhanden sind. Ist es möglich, dass die Geschwindigkeit von Float-Berechnungen ansonsten von den Werten der eingegebenen Zahlen abhängt?