Rust

Die relativ neue Programmiersprache Rust will den Sprachen C/C++ den Rang für Betriebssystemprogrammierung und laufzeitkritische Anwendungen ablaufen. Begonnen hat Rust als ein Hobbyprojekt von dem Mozilla-Angestellten Gradon Hoare. Mittlerweile unterstützt Mozilla das Projekt auch offiziell. Sie haben ein paar echt gute Ideen für Rust, wobei der Fokus darauf liegt, die Schwachstellen von C/C++ möglichst nicht zu übernehmen.

Da ich ja immer an neuen Sprachen interessiert bin, habe ich mal damit angefangen Rust zu lernen. Es ist aber doch schon ein ziemlicher Unterschied zu C oder Python festzustellen. An einige Besonderheiten muss man sich erst einmal gewöhnen. Der erste Schritt beim lernen einer Programmiersprache ist das Hello-World-Programm. Bei Rust sieht es recht unspektakulär aus:

fn main() {
    println!("Hello, world!");
}

fn steht für function. println ist ein Marco das einen Text in der Konsole ausgibt und mit einem Zeilenwechsel abschließt. Am Ende jedes Befehls steht ein Semikolon. Codeblöcke werden mit {} eingegrenzt. Ausprobieren könnt ihr den Code in einer Online-Live-Umgebung. Wenn Interesse besteht, dann könnte ich auch ein Tutorial zur Programmierung mit Rust erstellen… (wenn Interesse besteht, dann einfach einen Kommentar hinterlassen oder mich kontaktieren).

Jetzt mal zur Laufzeit. Ziel ist es Binomialkoeffizienten zu berechnen. In C verwende ich das folgendes Programm:

unsigned long binomial(unsigned long n, unsigned long k)
{
    unsigned long r = 1, d = n - k;
     
    if (k==n || k==0) return 1;
    if (k > n) return 0;
    if (k < 0) return 0;
    if (k > n/2)
    {
        k = n - k;
        d = n - k;
    }
 
    while (n > k)
    {
        if (r >= UINT_MAX / n) return 0; /* overflown */
        r *= n--;

        while (d > 1 && !(r % d)) r /= d--;
    }
    return r;
}

Das Programm in Rust sieht wie folgt aus:

use std::u64;

fn choose(n: u64, k: u64)  -> u64 {
    let mut r:u64 = 1;
    let mut d:u64;
    let mut k:u64 = k;
    let mut n:u64 = n;
    let u_size:u64 = u64::max_value() as u64;
    d = (n-k) as u64;
    
    if k==n || k==0 {return 1;}
    if k > n {return 0;}
    
    if k > n/2
    {
        k = n - k;
        d = (n - k) as u64;
    }

    while n > k
    {
        if r >= (u_size / n) as u64 {return 0;} /* overflown */
        r = r * n as u64;
        n = n - 1;

        while d > 1 && r % d == 0
        {
            r = r / d;
            d = d - 1;
        }
    }
    return r;
}

Zum Vergleich habe ich außerdem noch die Funktion in python implementiert:

def binomial(n, k):
  if n < k:
    return 0
  elif n == k:
    return 1
  if k < 0:
    return 0
  elif k == 0:
    return 1

  from operator import mul
  if k > n - k:
    k = n - k
  return int(reduce(mul, range((n - k + 1), n + 1), 1) / reduce(mul, range(1, k + 1), 1))

So jetzt zum Vergleich. Ich habe die Programm jeweils unter Linux compiliert (bis auf das Python-Programm natürlich 😉 ) und die Berechnung von binomial(30,15) jeweils 1.000.000-mal ausgeführt. Es ergibt sich folgendes Ergebnis:

SpracheLaufzeit in s
Python7.30
C1.15
Rust1.62

Der Vergleich mit Python ist natürlich etwas unfair, da Python in einer anderen Liga spielt. Die Ergebnisse zeigen aber sehr schön, dass Rust nahezu die Geschwindigkeit von C erreicht. Python hat natürlich Vorteile wenn es um die Lesbarkeit und die Kürze des Codes geht. Der erste Performance-Test macht mich auf jeden Fall neugierig auf Rust.

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert.

Diese Website verwendet Akismet, um Spam zu reduzieren. Erfahre mehr darüber, wie deine Kommentardaten verarbeitet werden.