Laufzeitoptimierung eines Consolen-Programms

[Andreas13]

Zitat von Olli73:

Also ich habe mal von Debug auf Release umgestellt und die E/A-Prüfung abgeschaltet. Die Bereichsüberprüfung und Überlaufprüfung waren dann bereits abgeschaltet. Dies hat bei mir die Laufzeit von 20,x auf 11,x Sekunden verkürzt.
Ein for nn:= 24999999 downto 0 do begin hat dann nochmals eine Sekunde gebracht.

Welche Delphi-Version benutzt Du Olli?
Denn bei XE5 haben Deine Vorschläge bei mir keinen meßbaren Zeitgewinn gebracht. Anscheinend optimiert XE5 bereits nach Deinen Empfehlungen. Allerdings läuft das 64-Bit-Prgramm bei mir 1 Sekunde schneller und braucht nur noch 6,23 Sekunden.

[Olli73]

Habe mit XE3 getestet.

Habe einen Core i7-4770, 16 GB RAM und SATA-SSD.

[Andreas13]

Danke, Olli.
Ich verwende einen PC mit:
AMD Ryzen 7 PRO 4750G with Radeon Graphics
8 Cores, 3.580 MHz, 64 GM RAM,
Windows 10 auf WD - SATA-SSD, 1 TB
Eigene Anwendungen: Samsung SSD 980 PRO, 1 TB

[himitsu]

PS: CUDA, OpenCL und Co, aber ob es dann noch Delphi/Pascal wäre?

[Renate Schaaf]

Das größte Problem ist m.E., dass das Programm im Wesentlichen auf nur einem Prozessor läuft. Mit threads könnte man da sicher was rausholen.

[stpolster]

Danke für alle Hinweise.
Multithreading ist in den Bedingungen des Tests ausdrücklich "verboten", wobei ich auch nicht wüsste, wie man bei diesem Problem etwas parallel laufen lassen könnte.

Im Moment ist ein Rust-Programm mit 0,4 s Laufzeit das Schnellste.

Code:

// needs:
// cargo add ethnum;
use ethnum::U256;
use std::time::Instant;
fn main() {
    let ten = &U256::new(10);
    let two = &U256::new(2);

    let soll = two.pow(255);
    let z = two.pow(128) - 1;
    let sub = ten.pow(77) / 9;

    let mut a = two.pow(127) + 29;
    let mut b = two.pow(127) - 25;
    let mut c = U256::new(0);

    let mut nad = 0u64;
    let mut nsu = 0u64;

    let watch = Instant::now();

    for _nn in 0..25_000_000 {
        c = &a * &b;
        while &c < &soll {
            c += &#8834;
            nad += 1;
        }
        while &c > &soll {
            c -= &#8834;
            nsu += 1;
        }
        a = &c >> 128;
        b = &c & &z;
    }
    let duration = watch.elapsed();
    println!("c {:?}", c);
    println!("ad={:?} su={:?} in {} s", nad, nsu, duration.as_secs_f64());
}

Wie das möglich ist? Ich weiß es nicht. Zumal ich nicht einmal wusste, dass es ein "Rust" gibt.

[Andreas13]

Rust kenne ich zwar auch nicht, aber aus dem Quellcode geht hervor, daß es für die Berechnung einen "eingebauten" Datentype U256 verwendet, also einen vorzeichenlosen 256-Bit-Integer, der für die Hardware optimiert zu sein scheint.

Wolfgang Ehrhardt's mp_int hat dagegen eine variable Länge und daher einen größeren Overhead.

Ich habe versucht lebenswichtige Überprüfungen wie mp_not_init(..), mp_error<>MP_OKAY und MPC_ArgCheck zu deaktivieren: Es hat bei 64-Bit lediglich 0,3 Sekunden gebracht.