Laufzeitoptimierung eines Consolen-Programms

[Olli73]

Da du "nn" in der Schleife nicht nutzt, sollte sie rückwärts laufen (wegen Optimierung; prüfen auf 0 ist schneller). Wenn dem nicht so ist, kannst du selber "downto" verwenden.

[stpolster]

Danke. Probiere ich aus.

[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

Delphi-Quellcode:

for nn:= 24999999 downto 0 do begin

hat dann nochmals eine Sekunde gebracht.

[Olli73]

64 bit bringt dann nochmals 2,5 Sekunden.

[Andreas13]

Zitat:

Zitat von Olli73 (Beitrag 1526391)

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

Delphi-Quellcode:

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.:-D
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. :(