Home

Home

PHP VS .NET - Runde 2 - Benchmark

Als Rahmen für das Benchmark dient eine ASP.NET Website, welche für jeden Benchmark Durchlauf abwechselnd eine ASP.NET und eine PHP Seite aufruft, und die Ausgabe für die Auswertung parst.
Die Seiten selbst bekommen übergeben wie oft welche Methode laufen soll, stoppen die jeweilige Ausführungszeit und geben das Ergebnis aus.
Wenn Interesse besteht stelle ich den Quellcode auch gern zum Download bereit.

Die Runs der jeweiligen Methoden wurden so angepasst, dass die schnellere der Sprachen mindestens ein zweistellige Zahl erreicht.
Das Benchmark hat beide Seiten jeweils 500 mal aufgerufen.

Test 1 - Math

Einfache Grundrechnungen die sich in beiden Sprachen kaum unterscheiden.
Bei 1.600.000 Runs hat PHP im Schnitt 484ms gebraucht und .NET 13ms.

PHP 
function Math($runs)
{
    for($i = 1; $i <= $runs; $i++)
    {
        $x = $i * 10;
        $x = $x + $x;
        $x = $x - $x;
        $x = $x / 10;
    }
}
C#/.NET 
public void Math(int runs)
{
    for (int i = 1; i <= runs; i++)
    {
        var x = i * 10;
        x = x + x;
        x = x - x;
        x = x / 10;
    }
}

Test 2 - Strings

Hier wurde die Zeichenkette umgekehrt, ein Substring extrahiert und alle Zeichen in Grußbuchstaben umgewandelt. In .NET musste ich für die Umkehrung der Zeichenkette eine kleine Helfermethode schreiben.
Bei 35.000 Runs hat PHP im Schnitt 67ms gebraucht und .NET 14ms.

PHP 
35.000 Runs
function Strings($runs)
{
    $string1 = 'abcdefghij';
    for($i = 1; $i <= $runs; $i++)
    {
        $string3 = $string1 . strrev($string1);
        $string2 = substr($string1, 9, 1) . substr($string1, 0, 9);
        $string1 = strtoupper($string2);
    }
}
C#/.NET 
public void Strings(int runs)
{
    var string1 = "abcdefghij";
    for (int i = 1; i <= runs; i++)
    {
        var string3 = string1 + Reverse(string1);
        var string2 = string1.Substring(9, 1) + string1.Substring(0, 9);
        string1 = string2.ToUpper();
    }
}
private string Reverse(string s)
{
    char[] arr = s.ToCharArray();
    Array.Reverse(arr);
    return new string(arr);
}

Test 3 - Encryption

Getestet wurden MD5, SHA1 und CRC32. Bei .NET war dies etwas aufwändiger, da jede Encryption mehre Methodenaufrufe benötigt.
Bei 7.000 Runs hat PHP im Schnitt 14ms gebraucht und .NET 208ms.

PHP 
function Encryption($runs)
{
    $string2 = "Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua.";
    for($i=0; $i < $runs; $i++)
    {
        $md5 = md5($string2);
        $sha1 = sha1($md5);
        $crc32 = crc32($sha1);
    }
}
C#/.NET 
public void Encryption(int runs)
{
    var string2 = "Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua.";
    for (int i = 0; i < runs; i++)
    {
        var md5 = ToMD5(string2);
        var sha1 = ToSHA1(md5);
        var crc32 = ToCRC32(sha1);
    }
}

private string ToMD5(string s)
{
    var x = new MD5CryptoServiceProvider();
    var buffer = System.Text.Encoding.ASCII.GetBytes(s);
    buffer = x.ComputeHash(buffer);
    return System.Text.Encoding.ASCII.GetString(buffer);
}

private string ToSHA1(string s)
{
    var sha1 = new SHA1CryptoServiceProvider();
    var buffer = System.Text.Encoding.ASCII.GetBytes(s);
    buffer = sha1.ComputeHash(buffer);
    return System.Text.Encoding.ASCII.GetString(buffer);
}

private string ToCRC32(string s)
{
    var crc32 = new Crc32();
    var buffer = System.Text.Encoding.ASCII.GetBytes(s);
    buffer = crc32.ComputeChecksumBytes(buffer);
    return System.Text.Encoding.ASCII.GetString(buffer);
}

Test 4 - Dates

Hier wurde einmal das aktuelle Datum und Neujahr formatiert ausgegeben, dann noch etwas mit der Timestamp gerechnet und ebenfalls formatiert ausgegeben.
Beim formatieren ist .NET etwas umständlicher, dafür geht das Rechnen mit Datumsangaben wiederrum leichter.
Bei 3.000 Runs hat PHP im Schnitt 167ms gebraucht und .NET 11ms.

PHP 
function Dates($runs)
{
    for($i=0; $i < $runs; $i++)
    {
         $string3 = date("D M d Y"). ', Neujahr : ' .date("M-d-Y", mktime(0, 0, 0, 1, 1, 2012));
         $secNextWeek = time() + (7 * 24 * 60 * 60);
         $string4 = date('Y-m-d', $secNextWeek);
    }
}
C#/.NET 
public void Dates(int runs)
{
    for (int i = 0; i < runs; i++)
    {
        var string3 = string.Format("{0:ddd MMM dd yyyy}, Neujahr : {1:MMM-dd-yyyy}", DateTime.Now, new DateTime(1998,1,1));
        var nextWeek = DateTime.Now.AddDays(7);
        var string4 = string.Format("{0:yyyy-MM-dd}", nextWeek);
    }
}

Test 5 - Images

Dieser Test erzeugt ein neues Bild mit einem Text darin.
Bei 300 Runs hat PHP im Schnitt 12ms gebraucht und .NET 34ms.

PHP 
function Images($runs)
{
    for($i=0; $i < $runs; $i++)
    {
        $im = @imagecreatetruecolor(200, 200) or die("Cannot Initialize new GD image stream");
        $text_color = imagecolorallocate($im, 233, 14, 91);
        imagestring($im, 1, 5, 5,  "Lorem Ipsum", $text_color);
        imagedestroy($im);
        unset($im);
    }
}
C#/.NET 
public void Images(int runs)
{
    for (int i = 0; i < runs; i++)
    {
        System.Drawing.Bitmap pic = new System.Drawing.Bitmap(200, 200);
        Graphics g = Graphics.FromImage(pic);
        Font f = new Font(new FontFamily("Arial"), 12f);
        Brush b = new SolidBrush(Color.FromArgb(233, 14, 91));
        g.DrawString("Lorem Ipsum", f, b, new PointF(5, 5));
        pic.Dispose();
    }
}

Test 6 - Arrays

Arrays sind bei beiden Sprachen schwer zu vergleichen. Während es bei PHP einen sehr flexiblen Typ dafür gibt, hat .NET viele spezialisierte Typen für bestimmte Aufgaben.
In diesem Test musste die Umgebungsvariable $_SERVER herhalten und wurde kräftig durcheinandergebracht und anschließend nach dem Key sortiert.
Bei 300 Runs hat PHP im Schnitt 12ms gebraucht und .NET 31ms.

PHP 
function Arrays($runs)
{
    $array = $_SERVER;
    for($i=0; $i < $runs; $i++)
    {
        shuffle($array);
        arsort($array);
    }
}
C#/.NET 
public void Arrays(int runs)
{
    var dic = GetTheDictionary();
    for (int i = 0; i < runs; i++)
    {
        var dic2 = new SortedDictionary<string, string>(dic, new RandomComparer<string>());
        var dic3 = new SortedDictionary<string, string>(dic2);
    }
}

private static Random r = new Random();
class RandomComparer<T> : IComparer<T> where T : IComparable<T>
{
    public int Compare(T x, T y)
    {
        int rnd = r.Next(0, 10);
        if (rnd > 4)
            return -1;

        return 1;
    }
}

private SortedDictionary<string, string> GetTheDictionary()
{
    var dic = new SortedDictionary<string, string>();
    dic.Add("PROCESSOR_ARCHITEW6432", "AMD64");
    ... ~90 weitere key value pairs aus $_SERVER ...
    dic.Add("PHP_SELF", "/PHPvsNET/bench.php");
    return dic;
}

Test 7 - Arrays durchsuchen

Hier wurde die Umgebungsvariable $_SERVER nach einem bestimmten Wert durchsucht und der Key dazu ermittelt.
Bei 5.000 Runs hat PHP im Schnitt 1181ms gebraucht und .NET 12ms.

PHP 
function ArraysSearch($runs)
{
    $array = $_SERVER;
    for($i=0; $i < $runs; $i++)
    {
        $key = array_search("keep-alive");
    }
}
C#/.NET 
public void ArraysSearch(int runs)
{
    var dic = GetTheDictionary();
    for (int i = 0; i < runs; i++)
    {
        var key = (from e in dic where e.Value == "keep-alive" select e.Key).First();
    }
}

Test 8 - Filesystem

Dieser Test versucht das PHP Benchmark Script zu kopieren, liest dabei noch die Dateigröße aus und überprüft ob die Datei lesbar und schreibbar ist.
Bei 50 Runs hat PHP im Schnitt 23ms gebraucht und .NET 14ms.

PHP 
function Filesystem($runs)
{
    $filename="bench.php";
    $file2 = "bench2.php";
    for($i=0; $i < $runs; $i++)
    {
        $dataFile = fopen( $filename, "r" ) ;
        if($dataFile)
        {
            while (!feof($dataFile))
            {
                $buffer = fgets($dataFile, 4096);
            }
            fclose($dataFile);
        }
        else
        {
           die( "fopen failed for $filename" ) ;
        }

        $filesize = @filesize($filename);
        $isreadable = @is_readable($filename);
        $iswritable = @is_writable($filename);

        if($i < 7)
        {
            $copy = @copy($filename, $file2);
            if($copy)
                unlink($file2);
        }
    }
}
C#/.NET 
public void Filesystem(int runs)
{
    var dir = @"C:\inetpub\wwwroot\PHPvsNET";
    var filename = dir + @"\bench.php";
    var file2 = dir + @"\bench2.php";

    for (int i = 0; i < runs; i++)
    {
        var buffer = File.ReadAllBytes(filename);

        FileInfo fi = new FileInfo(filename);
        var filesize = fi.Length;
        var isreadable = IsReadable(filename);
        var iswriteable = !fi.IsReadOnly;

        if (i < 7)
        {
            try { File.Copy(filename, file2); }
            catch { }
            try { File.Delete(file2); }
            catch { }
        }
    }
}

private bool IsReadable(string filename)
{
    try
    {
        var fp = File.OpenRead(filename);
        fp.Close();
    }
    catch
    {
        return false;
    }

    return true;
}

Test 9 - Objekte

Dem Konstruktor wird eine Zeichenkette als Parameter übergeben welche dann in einem Feld gespeichert wird. Anschließend wird diese Zeichenkette über eine Methode wieder ausgelesen und über eine weitere Methode werden zwei Zahlen multipliziert.
Bei 450.000 Runs hat PHP im Schnitt 1.100ms gebraucht und .NET 11ms.

PHP 
function Objects($runs)
{
    class Foo
    {
        var $z;
        function Foo($var)
        {
            $this->z = $var;
        }
        function do_foo()
        {
            return $this->z;
        }
        function multiply($var1, $var2)
        {
            return ($var1 * $var2);
        }
    }

    for($i=0; $i < $runs; $i++)
    {
        $bar = new Foo("Lorem Ipsum");
        $_1 = $bar->do_foo();
        $_2 = $bar->multiply(72, 12);
    }
}
C#/.NET 
public void Objects(int runs)
{
    for (int i = 0; i < runs; i++)
    {
        var bar = new Foo("Lorem Ipsum");
        var s1 = bar.do_foo();
        var s2 = bar.multiply(72, 12);
    }
}

class Foo
{
    private string z;
    public Foo(string var)
    {
        z = var;
    }

    public string do_foo()
    {
        return z;
    }

    public int multiply(int x, int y)
    {
        return (x * y);
    }
}

Test 10 - MySQL Verbindungsaufbau

Dieser Test öffnet eine MySQL Verbindung, wählt eine Datenbank und schließt die Verbindung wieder.
Bei 25 Runs hat PHP im Schnitt 73ms gebraucht und .NET 14ms.

PHP 
function MySQLConnect($runs)
{
    for($i=0; $i < $runs; $i++)
    {
        $con = mysql_connect("localhost","root","");
        mysql_select_db("northwind");

        mysql_close($con);
    }
}
C#/.NET 
public void MySQLConnect(int runs)
{
    for (int i = 0; i < runs; i++)
    {
        MySql.Data.MySqlClient.MySqlConnection con = new MySql.Data.MySqlClient.MySqlConnection("Server=localhost;Database=northwind;Uid=root;Pwd=;");
        con.Open();

        con.Close();
        con.Dispose();
    }
}

Test 11 - MySQL SELECT

Dieser Test führt einen SELECT Query aus und packt das Ergebnis in eine DataTable bzw. in ein Array zur Weiterverarbeitung.
Bei 20 Runs hat PHP im Schnitt 30ms gebraucht und .NET 17ms.

PHP 
function MySQLSelect($runs)
{
    $con = mysql_connect("localhost","root","");
    mysql_select_db("northwind");
    mysql_query( "SET NAMES 'utf8'");

    $dt = array();
    for($i=0; $i < $runs; $i++)
    {
        $query = mysql_query("SELECT * FROM customers;");

        while($row = mysql_fetch_assoc($query))
        {
          $dt[] = $row;
        }
    }
    mysql_close($con);
}
C#/.NET 
public void MySQLSelect(int runs)
{
    MySql.Data.MySqlClient.MySqlConnection con = new MySql.Data.MySqlClient.MySqlConnection("Server=localhost;Database=northwind;Uid=root;Pwd=;");
    con.Open();
    for (int i = 0; i < runs; i++)
    {
        DataTable dt = new DataTable();
        MySql.Data.MySqlClient.MySqlDataAdapter da = new MySql.Data.MySqlClient.MySqlDataAdapter("SELECT * FROM customers;", con);
        da.Fill(dt);
    }
    con.Close();
    con.Dispose();
}

Und hier die Ergebnisse noch einmal zusammengefasst:

TestPHP.NET
Math48413
Strings6714
Encryption14208
Dates16711
Images1234
Arrays1231
ArraysSearch118113
Filesystem2314
Objects110011
MySQLConnect7314
MySQLSelect3017
SUMME3166386

Im Nachhinein fällt mir auf, dass der Object-Test vermutlich durch das Multiplizieren verfälscht wird. Aber auch wenn man das Verhältnis von 1:37 beim Grundrechnen von den 1:100 bei Objekten abzieht ist hier noch eine erhebliche Differenz zu erkennen.

Fazit:
In der Summe geht hier der Sieg ganz klar an .NET.
Um jedoch messbare Ergebnisse im Millisekunden-Bereich zu bekommen muss man zum Teil extrem viele Operationen ausführen, die in der Praxis in dieser Häufigkeit wohl eher selten vorkommen.
Der Geschwindigkeitsunterschied dürfte also für den Besucher einer Seite nur in Sonderfällen fühlbar sein.

PHP VS. NET - Runde 1 - Apache oder IIS für PHP

Ich habe mir schon des Öfteren die Frage gestellt ob .NET oder PHP für eine Website schneller ist. Da ich gehört habe, dass der ISS mittlerweile für PHP schneller sein soll als der Apache, habe ich mich erst mal damit beschäftigt.

Zum Testen habe ich ein Benchmark von Sourceforge verwendet. Leider kann ich das Script nicht verlinken, da der Link nicht mehr funktioniert. Falls das Benchmark jemand erkennt bitte eine kurze Mitteilung an mich, damit ich den Link noch einfügen kann.

Das Script enthält Test für Encryption, die Verarbeitung von Strings und Datumsangaben, Bildbearbeitung, Array-Handling, Zugriff auf das Dateisystem und Objekte. Um auf messbare Ergebnisse zu kommen werden die Tests natürlich mehrfach wiederholt.

Apache mit PHP 5.2.17
 Apache mit PHP 5.3.5
 IIS7 mit PHP 5.3.5

Der erste Testdurchlauf erfolge auf meinem aktuell installierten Apache mit PHP 5.2.17. Da aber die PHP Version aber nicht die aktuellste war, habe ich den Test nach einem Update auf Version 5.3.5 noch einmal laufen lassen.
Für den dritten Testdurchlauf habe ich mir die gleiche PHP Version als FastCGI Modul auf dem IIS7 installiert.
Dank des neuen PHP Managers für den IIS7 ging das deutlich einfacher als in der Vergangenheit.

Fazit:
Man sollte immer darauf achten eine aktuelle PHP Version installiert zu haben, gerade wenn sich die Minor-Version verändert, da dies meist etwas umfangreichere Änderungen mit sich bringt.
Der Server hingegen macht keinen großen Unterschied bei der Ausführungsgeschwindigkeit von PHP.

 
   

Kategorien  

   

Werbung  

   

Login Form