folgendes Szenario:
ich habe mir 2 rudimentäre Log-Klassen implementiert. Einmal in C++ und einmal in PHP. Grund: reine Neugier bzgl. der Geschwindigkeit.

Die C++ Datei:

#include <iostream>
#include <string>
#include <fstream>

#include <time.h>

class Logger {
public:
	Logger(std::string log_file) {
		this->log_file = log_file;
	}

	void write(const std::string &message) const {
		std::ofstream log_file_stream;
		log_file_stream.open(this->log_file, std::ios_base::app);
		log_file_stream << message << "\n";
		log_file_stream.close();
	}
private:
	std::string log_file;
};

int main(int argc, char* argv[]) {
	if(argc > 1) {
		clock_t tStart = clock();

		Logger logger("./log-cpp.txt");

		std::string log_message;
		for(int i = 1; i < argc; i++) {
			log_message += (std::string) + argv[i] + (i != (argc - 1) ? " " : "");
		}

		for(int i = 0; i <= 100; i++)
			logger.write(log_message);

		printf("Time taken: %.2fs\n", (double)(clock() - tStart)/CLOCKS_PER_SEC);

		return 0;
	} else {
		// ERROR...

		return 1;
	}
}

Anmerkung: ich programmiere C++ nur hin und wieder, wenn das ganze nicht so wirklich schön implementiert ist - steinigt mich nicht.
Jedenfalls: Ausführungszeit beträgt zwischen 0.1 bis 0.15 Sekunden.

Die PHP Variante:

<?php
class Log {
    const LOG_FILE = './log-php.txt';

    public static function write($message)
    {
        file_put_contents(self::LOG_FILE, $message . "\r\n", FILE_APPEND | LOCK_EX);
    }
}

$start = microtime();
$start = explode(' ', $start);
$start = ($start[1] + $start[0]);
define('SCR_START', $start);

for($i = 0; $i <= 100; $i++) {
    Log::write($i . ': This is a test');
    //exec('log.exe '.$i.': This is test');
}

$end = microtime();
$end = explode(' ', $end);
$end = ($end[1] + $end[0]);
define('SCR_END', $end);

echo '<br><br> Execution: ' . (SCR_END - SCR_START) . 's';

Ausführungszeit: 0.012 bis 0.02 Sekunden.

Wie man sieht hab ich auch die C++ Implementation über PHP aufgerufen - da warens dann direkt mal 6 Sekunden, weil der Interpreter vermutlich beim Aufrufen von "exec" bissl mehr zu tun hat wie erwartet.

Die Frage aber bleibt: warum ist die PHP Implementation schneller? Liegts einfach nur an meinem Quellcode oder woran sonst?

Danke

Deshalb hält man Dateien auch nicht als std::string (wie kommt man auf die Idee?), sondern als ihre übliche C++-Abstraktion: (i/o)fstream. Oder man entzieht der Klasse ganz die Verantwortung für die Datei und benutzt nur noch einen allgemeinen (i/o)stream. Überhaupt ist ein explizites open oder close in C++ sehr oft ein Designfehler - eine Datei sollte so lange offen bleiben, wie ihr assoziierter Stream lebt.

Du misst hier in allererster Linie die Implementation von open und close aus der jeweiligen Standardbibliothek, dein Programm selber leistet jeweils so gut wie keine Arbeit, daher merkst du keinen Effekt der Sprache.

Das bzgl. std::string ist mein Fehler - wusste ich nicht besser.

Aber ersetz einfach mal std::ios_base::app durch std::ios_base::ate.
Das sollte mMn. einiges bringen.

log_message += (std::string) + argv[i] + (i != (argc - 1) ? " " : "");

Sieht aus, als sei

log_message += std::string() + argv[i] + (i != (argc - 1) ? " " : "");

gemeint, aber in Wirklichkeit ist der erste Term ein unäres Plus, angewandt auf argv[i] , was dann nach std::string gecastet wird. Dabei ist das gar nicht so schlecht, nur sollte man es dann auch so schreiben (ohne das + natürlich):

log_message += std::string(argv[i]) + (i != (argc - 1) ? " " : "");

Zu dem Tipp bzgl. std::ios_base::ate - sehr interessant, direkt auf 0.02 bis 0.04 Sekunden runter. Danke.

Mein eigentliches Ziel aber habe ich nicht erreicht. Es liegt nicht an der Geschwindigkeit des C++-Programms, sondern an "exec" selbst. Ich wollte versuchen, den Logger über ein nativ geschriebenes Programm auszuführen um so mehr Geschwindigkeit rauszuholen - das exec so langsam ist, wusste ich nicht.

Scheinbar ist die von beispielsweise Facebook genutzte Lösung, Scribe, dann wohl die einzig schnellere um das Logging schneller hinzukriegen.

log_message += (std::string)argv[i] + (i != (argc - 1) ? " " : "");

Vermutlich das Überbleibsel von irgendwelchen Tests die ich gestern noch angestellt hatte.

Scheinbar ist die von beispielsweise Facebook genutzte Lösung, Scribe, dann wohl die einzig schnellere um das Logging schneller hinzukriegen.

Nein, GANZ sicher nicht die einzige.
Du kannst in C++ Extensions für PHP entwickeln. Also quasi Funktionen in C++ implementieren die du aus PHP dann direkt aufrufen kannst -- genau so als wenn es "echte" PHP Funktionen wären.

Diese können dann beliebig schlaues Caching/Coalescing machen, und dadurch die Logging-Geschwindigkeit quasi beliebig steigern.

Du kannst aber auch, was viel einfacher wäre, deinen eigenen Logging-Funktionen in PHP so schreiben, dass sie einfach nicht das File dauernd auf- und wieder zumachen. Damit wirst du langsamer sein als mit einer "schlauen" C++ Extension, aber immer noch viel schneller als jetzt.

Oder du verwendest einen Logging-Daemon, der über Sockets oder Pipes Verbindungen annimmt, und alles was auf diesen Verbindungen ankommt in das Logfile schreibt. Der Logging-Daemon wäre dann wieder in etwas anderem als PHP implementiert, damit er asynchrone IO Funktionen, Threads und was nicht noch alles verwenden kann um das Schreiben von vielen kleinen Datenstückchen in ein gemeinsames Logfile zu beschleunigen.

Du kannst in C++ Extensions für PHP entwickeln. Also quasi Funktionen in C++ implementieren die du aus PHP dann direkt aufrufen kannst -- genau so als wenn es "echte" PHP Funktionen wären.

Diese können dann beliebig schlaues Caching/Coalescing machen, und dadurch die Logging-Geschwindigkeit quasi beliebig steigern.

"Beliebig"? Ich weiß nicht, wie die entsprechenden Funktionen in PHP momentan in implementiert sind - vlt. sind diese ja schon relativ gut optimiert? Keine Ahnung.

Du kannst aber auch, was viel einfacher wäre, deinen eigenen Logging-Funktionen in PHP so schreiben, dass sie einfach nicht das File dauernd auf- und wieder zumachen. Damit wirst du langsamer sein als mit einer "schlauen" C++ Extension, aber immer noch viel schneller als jetzt.

Was i.d.R. nicht unter realen Bedingungen funktioniert. Normalerweise loggt man auf einer Seite ja nicht 100 Sachen auf einmal, sondern nur ein paar Dinge. Ändert man den Request, muss der Interpreter erneut ran und die Datei wieder aufmachen. Wie man den Stream über mehrere Requests offen lassen könnte, wäre mir nicht bekannt (vor allem, da der Interpreter am Ende seiner Arbeit ja alles freigibt und beendet was irgendwie noch da bzw. offen ist).

Oder du verwendest einen Logging-Daemon, der über Sockets oder Pipes Verbindungen annimmt, und alles was auf diesen Verbindungen ankommt in das Logfile schreibt. Der Logging-Daemon wäre dann wieder in etwas anderem als PHP implementiert, damit er asynchrone IO Funktionen, Threads und was nicht noch alles verwenden kann um das Schreiben von vielen kleinen Datenstückchen in ein gemeinsames Logfile zu beschleunigen.

Jop, was dann wohl sowas wie Scribe wäre. Wenn ich das richtig verstanden habe.