Begrenzung

[stemer]

Hallo,

kann mir sagen wie ich das am besten mache.

Per Formular kann man Bilder in einen Ordner uploaden, jetzt sollte ich aber für den Ordner eine Begrenzung haben, also entweder darf im Ordner Gesammt 200KB sein oder 5 Dateien. Wie mache ich das?

Gruss Stefan

[Markus]

Per Formular kann man Bilder in einen Ordner uploaden, jetzt sollte ich aber für den Ordner eine Begrenzung haben, also entweder darf im Ordner Gesammt 200KB sein oder 5 Dateien. Wie mache ich das?

vielleicht hilft dir das weiter:
http://www.selfphp.info/funktionsuebersicht/dateisystem_funktionen.php

[Tobias Kloth]

Hallo Markus,

http://www.selfphp.info/funktionsuebersicht/dateisystem_funktionen.php

die Seite ist veraltet, verwende http://de3.php.net/ref.filesystem.

Grüße aus Nürnberg
Tobias

[XaraX]

Hallo Stefan,

Per Formular kann man Bilder in einen Ordner uploaden, jetzt sollte ich aber für den Ordner eine Begrenzung haben, also entweder darf im Ordner Gesammt 200KB sein oder 5 Dateien. Wie mache ich das?

Du liest den Ordnerinhalt aus. Da führt kein Weg dran vorbei:

$dir=opendir($das_verzeichnis);
wihle(($f=readdir($dir)!=FALSE)
   if(!is_dir($das_verzeichnis.'/'.$f))
      $a[]=$f;

closedir($dir);

$b=count($a);

Dann machst Du einfach eine Fallentscheidung:

if($b>4)
   echo 'Script will nicht';
else
   {
   for($i=0;$i<$b;$i++)
      $c+=file_size($das_verzeichnis.'/'.$a);

if($c>204800)
      echo 'Script will nicht';
   else
      upload_organisationsfunktion();
   }

Gruß aus Berlin!
eddi

[stemer]

Hallo Eddi,

Leider gibt mir das folgenden Fehler aus:parse error, unexpected T_IF

Gruss Stefan

[Tom]

Hello Eddi,

Du liest den Ordnerinhalt aus. Da führt kein Weg dran vorbei:

$dir = opendir($das_verzeichnis);

while(($f=readdir($dir))!==FALSE)           # Identitätsoperator! und Klammer
  {
    if(is_file($das_verzeichnis.'/'.$f))      # sollten auch Links mitgezählt werden?
    {
      $a[]=$f;
    }
  }

closedir($dir);

$b=count($a);

Dann machst Du einfach eine Fallentscheidung:

if($b>4)
   echo 'Script will nicht';
else
   {

hier würde ich foreach() verwenden...

und außerdem sollte $c vorher initialisiert werden!

for($i=0;$i<$b;$i++)
      $c+=file_size($das_verzeichnis.'/'.$a);

Wenn man Zugriff auf Systemfunktionen (bei Linux) hat, kann man auch 'du' verwenden für das Verzeichnis. Das ist dann schneller, wenn es nicht um 5 sondern um 500 Files gehen sollte.

Harzliche Grüße aus http://www.annerschbarrich.de

Tom

[XaraX]

Hallo Tom :)

while(($f=readdir($dir))!==FALSE)           # Identitätsoperator! und Klammer

Mist; wieder beim schnellschustern erwischt ;)

{
    if(is_file($das_verzeichnis.'/'.$f))      # sollten auch Links mitgezählt werden?

Genaugenommen leider nicht per Frage definiert.

{
      $a[]=$f;
    }
  }

closedir($dir);

$b=count($a);

Dann machst Du einfach eine Fallentscheidung:

if($b>4)
   echo 'Script will nicht';
else
   {

hier würde ich foreach() verwenden...

Hm, begründe mal bitte!

und außerdem sollte $c vorher initialisiert werden!

Ja, muß ich Dir recht geben, insbesondere dann wenn man Buchstabe für Buchstabe ohne Hirnrindenaktivität übernimmt...

for($i=0;$i<$b;$i++)
      $c+=file_size($das_verzeichnis.'/'.$a[$i]);

Wenn man Zugriff auf Systemfunktionen (bei Linux) hat, kann man auch 'du' verwenden für das Verzeichnis.

Kannte ich bis jetzt noch gar nicht. Danke! Aber leider bekomme ich bei

eddi@eddi~> du

auch alle unterverzeichnisse präsentiert, gib bitte die Parameter an, mit denen Du arbeiten würdest, da "man du" mir nicht weiterhilft. Mir fehlt ein Parameter um die Tiefe auf einen Ordner zu setzen (exlusive Unterordner).

Das ist dann schneller, wenn es nicht um 5 sondern um 500 Files gehen sollte.

Na das teste ich mal gleich nach Deiner heiß erwarteten Antwort :)))))

Gruß aus Berlin!
eddi

[Tom]

Hello,

if(is_file($das_verzeichnis.'/'.$f))      # sollten auch Links mitgezählt werden?

Genaugenommen leider nicht per Frage definiert.

Ich habe nur darüber nachgedacht, dass mittels Link jedes Verzeichnis auch auf öffentliche Bildr zeigen könnte, die dem User zur Verfügung stehen, die aber nicht zu seinem Amount gehören.

hier würde ich foreach() verwenden...

Hm, begründe mal bitte!

Foreach() arbeitet die Kette der Elemente ab, so wie sie vorhanden sind.
Man könnte also vorher auch einzelne Elemente mit unset() 'herausschießen'
die For-Schleife sucht in der Kette die Indexe, die aber auf den Elementen stehen, und NICHT den Platz in der Kette repräsentieren.
Wenn einer fehlt, gibt es einen Fehler.

Wie das intern genau funktioniert, stehe immer noch auf meiner ToDo-Liste. Ist aber recht komplex. Die Array-Verarbeitung mit den Spezialfunktionen (foreach()) ist aber messbar schneller.

Harzliche Grüße aus http://www.annerschbarrich.de

Tom

[XaraX]

Re:

hier würde ich foreach() verwenden...

Hm, begründe mal bitte!

Foreach() arbeitet die Kette der Elemente ab, so wie sie vorhanden sind.
Man könnte also vorher auch einzelne Elemente mit unset() 'herausschießen'
die For-Schleife sucht in der Kette die Indexe, die aber auf den Elementen stehen, und NICHT den Platz in der Kette repräsentieren.
Wenn einer fehlt, gibt es einen Fehler.

Das genaue Gegenteil ist mir ersichtlich:

eddi@eddi:~> eddi g-test 10000

for_c           : 27.102898836136
foreach         : 25.85285615921
for             : 13.902323961258
Durchlaeufe     : 10000

OS      : Linux SuSe 9.1 prof
SAPI    : cli
Version : 5.0.3

Bitte überprüfe es mal:

<?php
ini_set('max_execution_time',200);
ini_set('memory_limit','50M');
$d=time();
$u=$argv[1] ? $argv[1] : 1;

$a=file('test1.txt');

sleep(1); $start=explode(' ',microtime()); $start=$start[1].substr($start[0],-9);

for($i=0;$i<$u;$i++)
 {
 for($j=0;$j<count($a);$j++);
 }

$end=explode(' ',microtime()); $end=$end[1].substr($end[0],-9); echo 'for_c  : '.str_pad(($end-$start),16)."\n";
 unset($j,$i); sleep(1); $start=explode(' ',microtime()); $start=$start[1].substr($start[0],-9);

for($i=0;$i<$u;$i++)
 {
 foreach($a as $v);
 }

$end=explode(' ',microtime()); $end=$end[1].substr($end[0],-9); echo 'foreach  : '.str_pad(($end-$start),16)."\n";
 unset($v,$i); sleep(1); $start=explode(' ',microtime()); $start=$start[1].substr($start[0],-9);

for($i=0;$i<$u;$i++)
 {
 for($j=0;$a[$j];$j++);
 }

$end=explode(' ',microtime()); $end=$end[1].substr($end[0],-9); echo 'for  : '.str_pad(($end-$start),16)."\n";
 echo 'Durchlaeufe : '.$u;
?>

test1.txt ist ein 1050112 Byte große Datei, die mit file() ein Datenfeld mit Index 0-1535 erzeugt 1/3 der Strings ist 1.0 kB, 1/3 ist 0.67 kB und 1/3 ist 0.33 kB groß.

Nach wie vor würde mich du interessieren, da ich den Befehl noch nicht kannte.

Gruß aus Berlin!
eddi

[Tom]

Hello,

sorry, aber da steige ich jetzt nicht ganz durch.

könntest Du bitte noch ein paar Kommentare dazwischen schreiben, was Du bezwecken wolltest?

Harzliche Grüße aus http://www.annerschbarrich.de

Tom

[XaraX]

Hallo Tom,

tschuldige, das war auch etwas überfallsartig ;) eddi ist mein ShellScript, mit dem ich auf allen meinen Systemen den Aufruf von PHP-CLI erledige. D. h. PHP kann auf einem abgeschirmten System nur mit den Minimaldiensten ohne Server oder Ähnlichem seinen Dienst vollziehen. Dem Script wird als Parameter der Name eines Scriptes übergeben: eddi g-test. Das ShellScript eddi ruft damit folgendes auf:

env -i /home/eddi/bin/5.0.3/bin/php -f /home/eddi/phpscripte/g-test.php $@

Mit dem Aufruf an der Konsole eddi g-test 10000 übergebe ich noch den Parameter 10000, der Durchlaufanzahl bestimmt.

############################ g-test.php ###################################

<?php
ini_set('max_execution_time',200);
ini_set('memory_limit','50M');

$u wird Durch Prüfung Erstellt. Ist der zweite Parameter an der Konsole

eingegeben worden, so wird $u dieser zugewiesen; andernfalls "1" als

Durchlaufanzahl

$u=$argv[1] ? $argv[1] : 1;

test1.txt ist ein 1050112 Byte große Datei, die mit file() ein Daten-

feld mit Index 0-1535 erzeugt 1/3 der Strings ist 1.0 kB, 1/3 ist

0.67 kB und 1/3 ist 0.33 kB groß.

Die Datei kann zum Vergleich unter

http://eddi.to-grip.de/versuch/test1.txt heruntergeladen werden.

$a=file('test1.txt');

Der Prozess wird zum Vergleich ausgesetzt

sleep(1);

Beispiel für die Ausgabe von microtime(): "0.96838300 1105291560"

Die Ausgabe von microtime() wird ein Datenfeld umgewandelt

echo $start[0]; => "0.96838300" // (Sekundenbruchteil)

echo $start[1]; => "1105291560" // (wie 'echo time();')

$start=explode(' ',microtime());

Beim Beispiel ("0.96838300 1105291560") beleibend wäre die genaue Zeit

also 1105291560.96838300. Anders ausgedrückt sind das alle Zeichen von

$start[1] verbunden mit den letzen neune Zeichen von $start[0]:

$start=$start[1].substr($start[0],-9);

die erste Testreihe mit $u Durchläufen beginnt

for($i=0;$i<$u;$i++)
   {

wird das Datenfeld $a durchlaufen

for($j=0;$j<count($a);$j++);
   }

$end siehe $start

$end=explode(' ',microtime());
$end=$end[1].substr($end[0],-9);

Ausgabe an der Konsole:

$end - $start ergibt die exakte Dauer in Sekunden der Durchläufe $u für

for($j=0;$j<count($a);$j++); als _FOR_ mit _C_ount "for_c"

str_pad() naja ;) man ist ja Ästhet

echo 'for_c  : '.str_pad(($end-$start),16)."\n";

um das Ergebnis keinsterleiweise zu beeinflussen bekommt jede funktion

die gleichen $GLOBALS übergeben, daher wird $j und $i gelöscht

unset($j,$i);

Der Prozess wird zum Vergleich ausgesetzt und abhieran wiederholen sich

die Dinge

sleep(1);
$start=explode(' ',microtime());
$start=$start[1].substr($start[0],-9);

for($i=0;$i<$u;$i++)
 {
 foreach($a as $v);
 }

$end=explode(' ',microtime());
$end=$end[1].substr($end[0],-9);
echo 'foreach  : '.str_pad(($end-$start),16)."\n";
unset($v,$i);
sleep(1);
$start=explode(' ',microtime());
$start=$start[1].substr($start[0],-9);

for($i=0;$i<$u;$i++)
 {
 for($j=0;$a[$j];$j++);
 }

$end=explode(' ',microtime());
$end=$end[1].substr($end[0],-9);
echo 'for  : '.str_pad(($end-$start),16)."\n";

es wird die Anzahl der Duchläufe ausgegeben

echo 'Durchlaeufe : '.$u;
?>

#####################Ausgabe an der Konsole ###############################

Das ist mein Code, mit dem ich Geschwindigkeitstests durchführe. Jedoch ist anzumerken, das die Kommentare herauszunehmen sind! Aus irgendeinem Grund beinflussen diese das Ergebnis...

Die schnellste Methode von -for vs foreach- ist in diesem Test allerdings:

$b=count($a);
for($i=0;$i<$u;$i++)
   {
   for($j=0;$j<$b;$j++);
   }

Dabei wird count nicht bei jedem Aufruf folzogen, was noch mehr spart, aber
erst in Konstrukten wie

while()
   for()

oder

foreach()
   for()

im Realem seine Wirkung vollzieht.

Gruß aus Berlin!
eddi

[Tom]

Hello,

die erste Testreihe mit $u Durchläufen beginnt

for($i=0;$i<$u;$i++)
   {

wird das Datenfeld $a durchlaufen

for($j=0;$j<count($a);$j++);
   }

Hier wurde nicht das Array $a durchlaufen, sondern der Index $j
Die Dereferenzierung von $a wird überhaupt nicht benutzt und auf Werte von $a[x] schon gar nicht zugegriffen

for($i=0;$i<$u;$i++)
{
  foreach($a as $v);
}

Hier wird nun wirklich für jedes Element von $a die Dereferenzierung durchgeführt und dessen Inhalt in die statische Variable $v übertragen und das Ganze u-mal.

Auch bei der nächsten for()-Schleife machst Du wieder nichts wirkliches mit dem Array $a.

Dieser Vergleich hinkt also.

Harzliche Grüße aus http://www.annerschbarrich.de

Tom

[XaraX]

Re:

Hier wurde nicht das Array $a durchlaufen, sondern der Index $j
Die Dereferenzierung von $a wird überhaupt nicht benutzt und auf Werte von $a[x] schon gar nicht zugegriffen

Stimmt! Leider ändert sich nichts an der Geschwindigkeit.

for_1536 : 217.28548502922
foreach  : 256.68023610115
for  : 240.39348602295
Durchlaeufe : 100000

für:

for($j=0;$j<1536;$j++){$b=$a[$j];}
foreach($a as $c);
for($j=0;$a[$j];$j++){$b=$a[$j];}

Gruß aus Berlin!
eddi

[Christoph Zurnieden]

Hi,

Stimmt! Leider ändert sich nichts an der Geschwindigkeit.

for_1536 : 217.28548502922
foreach  : 256.68023610115
for  : 240.39348602295
Durchlaeufe : 100000

Naja, könnte man eigentlich gut behaupten, das alle drei gleich schnell sind, da tut sich nicht wirklich 'was und dann auch nur bei 100.000 Durchläufen.

Die kleinen Differenzen liegen an Folgendem:

for($j=0;$j<1536;$j++){$b=$a[$j];}

Vergleich gegen eine fixe Zahl

foreach($a as $c);

Vergleich gegen zwei aufzulösende Variablen.

for($j=0;$a[$j];$j++){$b=$a[$j];}

Vergleich gegen eine aufzulösende Variable. (ja, eigentlich zwei, aber $a ja nur einmal pro gesammtem Loop)

Also? Ist alles nur syntactic sugar und der verursacht bekanntlich keine Karies.

so short

Christoph Zurnieden

[Christoph Zurnieden]

Hi

hier würde ich foreach() verwenden...

(was macht ihr hier? Auch noch den letzen halben Frame/Sekunde rausquetschen? ;-)

Nach wie vor würde mich du interessieren, da ich den Befehl noch nicht kannte.

Ist ein kleines Tool aus den fileutils, die jetzt übrigens coreutils heißen.

Manpage: http://www.die.net/doc/linux/man/man1/du.1.html

so short

Christoph Zurnieden

[Tom]

Hello,

hier würde ich foreach() verwenden...

(was macht ihr hier? Auch noch den letzen halben Frame/Sekunde rausquetschen? ;-)

Eigentlich geht es mir beim Wechsel von for() zu foreach() selten wirklich um die Geschwindigkeit, sondern um die Vermeidung der erheblichen Fehlermöglichkeiten, die for() bei Anwendung auf PHP-"Arrays" mit sich bringt.

Harzliche Grüße aus http://www.annerschbarrich.de

Tom

[XaraX]

Hallo Christoph,

hier würde ich foreach() verwenden...

(was macht ihr hier? Auch noch den letzen halben Frame/Sekunde rausquetschen? ;-)

wenn es nach mir ginge schon ;)

Eigentlich geht es mir beim Wechsel von for() zu foreach() selten wirklich um die Geschwindigkeit, sondern um die Vermeidung der erheblichen Fehlermöglichkeiten, die for() bei Anwendung auf PHP-"Arrays" mit sich bringt.

Mir ist die Geschwindigkeit da mehr im Vordergrund. Allerdings ist das auch nur auf der Vermutung aufgebaut PHP liefert mit file() immer ein formschönes Datenfeld ab. Insofern ist Toms Überlegung extrasauberes coding, was ich nur als positiv bewerten kann, denn da bin ich doch oft sehr vorschnell.

Gruß aus Berlin!
eddi

[Christoph Zurnieden]

Hi,

hier würde ich foreach() verwenden...

(was macht ihr hier? Auch noch den letzen halben Frame/Sekunde rausquetschen? ;-)

wenn es nach mir ginge schon ;)

Wozu?
Selbst wenn die Hardware schon so ausgereizt ist, das es merkbar wird, dann bringen besserer Algorithmus/Hardware trotzdem mehr.
Geschwindigkeitsoptimierung im Detail kostet immer mehr, als sie bringt. Ausnahmen bestätigen die Regel, klar, aber den schnellen Hack, weil noch kein Geld für eine dickere Maschine da ist zählt wohl kaum und der embeded Bereich hat eine ganz andere Problemstellung und vor allem Lösungen.

Eigentlich geht es mir beim Wechsel von for() zu foreach() selten wirklich um die Geschwindigkeit, sondern um die Vermeidung der erheblichen Fehlermöglichkeiten, die for() bei Anwendung auf PHP-"Arrays" mit sich bringt.

Mir ist die Geschwindigkeit da mehr im Vordergrund.

Warum? Sollte das Programm nicht erstmal funktionieren? Wenn dann noch Zeitist, kannst Du ja immer noch dran rumfeilen, aber die Zeit ist im Grunde nie da, die hast Du im Höchstfall bei privaten Projekten.

Allerdings ist das auch nur auf der Vermutung aufgebaut PHP liefert mit file() immer ein formschönes Datenfeld ab. Insofern ist Toms Überlegung extrasauberes coding, was ich nur als positiv bewerten kann, denn da bin ich doch oft sehr vorschnell.

Es gibt kein "extrasauberes" Coding, entweder ist das ordentlich oder schlampig. Du kannst es Dir erlauben schlampig zu werden, wenn Du _genau_ weißt, was Du tust. Dieses "genau" sollte aber vorzugsweise bis runter zu den Opcodes gehen.

so short

Christoph Zurnieden

[XaraX]

Re:

Wozu?
Selbst wenn die Hardware schon so ausgereizt ist, das es merkbar wird, dann bringen besserer Algorithmus/Hardware trotzdem mehr.
Geschwindigkeitsoptimierung im Detail kostet immer mehr, als sie bringt. Ausnahmen bestätigen die Regel, klar, aber den schnellen Hack, weil noch kein Geld für eine dickere Maschine da ist zählt wohl kaum und der embeded Bereich hat eine ganz andere Problemstellung und vor allem Lösungen.

Da werden wir mutmalsich immer differieren.

Mir ist die Geschwindigkeit da mehr im Vordergrund.
Warum? Sollte das Programm nicht erstmal funktionieren?

Diese Philisophie sehen wir alle hier jeden Tag mit irgendwelchen Code, der zum Teil nicht mal von den Einzelnen nachvollzogen werden kann. Genaugenommen habe ich mal eben auch schnell was zusammengezimmert, wo mir Tom in https://forum.selfhtml.org/?t=98391&m=599837 und https://forum.selfhtml.org/?t=98391&m=599930 die Zähne gezogen hat; und das völlig zu recht. Dieses "erstmal funktionieren" ist nach meinem Geschmack keines Falls das, was man braucht.

Wenn dann noch Zeitist, kannst Du ja immer noch dran rumfeilen, aber die Zeit ist im Grunde nie da, die hast Du im Höchstfall bei privaten Projekten.

Hast Du schon mal den Code von einem Vorgänger durcharbeiten sollen? Was wenn ein Kunde mal die Kosten für ein Gutachten nicht scheut? Diese Einstellung hat bei kleinen Leuten mit kleinem Budget Berechtigung.

Es gibt kein "extrasauberes" Coding, entweder ist das ordentlich oder schlampig.

Entweder Du widersprichst Dir hier, oder Du gibst zu, lieber schlampigen Code abzuliefern an dem man "immer noch dran rumfeilen [kann]".

Du kannst es Dir erlauben schlampig zu werden, wenn Du _genau_ weißt, was Du tust. Dieses "genau" sollte aber vorzugsweise bis runter zu den Opcodes gehen.

Dies abzustellen bin ich Stückweise dabei.

Gruß aus Berlin!
eddi

[Christoph Zurnieden]

Hi,

Mir ist die Geschwindigkeit da mehr im Vordergrund.
Warum? Sollte das Programm nicht erstmal funktionieren?

Diese Philisophie sehen wir alle hier jeden Tag mit irgendwelchen Code, der zum Teil nicht mal von den Einzelnen nachvollzogen werden kann. Genaugenommen habe ich mal eben auch schnell was zusammengezimmert, wo mir Tom in https://forum.selfhtml.org/?t=98391&m=599837 und https://forum.selfhtml.org/?t=98391&m=599930 die Zähne gezogen hat; und das völlig zu recht. Dieses "erstmal funktionieren" ist nach meinem Geschmack keines Falls das, was man braucht.

Ich dachte eigentlich, das es genau das ist, was man braucht, denn die Alternative wäre "funktioniert erstmal nicht", denn entweder klappt es oder nicht; ein bischen schwanger gibt es nicht.
Zu dem Funktionieren gehört natürlich auch, das es in finiter Zeit abläuft, klar. Aber wie lang "finite Zeit" sein soll, muß _vorher_ bestimmt werden und vor allem _genau_. Wenn dann noch der letzte Fitz fehlen sollte, dann kannst Du nachschauen, wo's hängt, aber empfehlen würde ich da eher einen anderen Algorithmus zu suchen. Macht deutlich mehr Sinn als sich darum zu streiten, ob der minimale Overhead von PHPs syntactic sugar Karies verursacht.

Wenn dann noch Zeitist, kannst Du ja immer noch dran rumfeilen, aber die Zeit ist im Grunde nie da, die hast Du im Höchstfall bei privaten Projekten.

Hast Du schon mal den Code von einem Vorgänger durcharbeiten sollen?

Ja. Aber was hat das hiermit zu tun?

Was wenn ein Kunde mal die Kosten für ein Gutachten nicht scheut?

Wer macht das Gutachten und vor allem: worauf hin? Doch höchstens daraufhin, das die Vorgaben nicht eingehalten wurden und ob da Sicherheitsmängel zu finden sind. Was noch?

Diese Einstellung hat bei kleinen Leuten mit kleinem Budget Berechtigung.

Da schon mal überhaupt nicht. Das teuerste ist bei Softwareentwicklung Zeit und Microoptimierung frißt Zeit, die kannst Du stets anderweitig _viel_ gewinnbringender einsetzen.

Es gibt kein "extrasauberes" Coding, entweder ist das ordentlich oder schlampig.

Entweder Du widersprichst Dir hier, oder Du gibst zu, lieber schlampigen Code abzuliefern an dem man "immer noch dran rumfeilen [kann]".

Ach, Du möchtest beides? Sauberen _und_ geschwindigkeitsoptimierten Code? Das funktoniert nicht, da ist das Minimax-Gesetz gegen. Du kannst nur _entweder_ sauber schreiben _oder_ geschwindigkeitsoptimiert. Beides gleichzeitig geht nicht. (Auch wenn die Formulierung "geht nicht" mir fast schon körperliche Schmerzen bereitet ;-)
Wenn Du geschwindigkeitsmäßig noch signifikant etwas rausholen kannst (z.B. O(n*log(n)) statt O(n^2)) dann war der vorherige Algorithmus einfach _falsch_ und nicht bloß lahm.

Du kannst es Dir erlauben schlampig zu werden, wenn Du _genau_ weißt, was Du tust. Dieses "genau" sollte aber vorzugsweise bis runter zu den Opcodes gehen.

Dies abzustellen bin ich Stückweise dabei.

Was abstellen? Nicht mehr genau wissen zu müssen, was man tut? Ist zugleich eine sehr angehme als auch furchtbare Vorstellung.
Aber das meintest Du wohl nicht, oder?

so short

Christoph Zurnieden

[XaraX]

Hi,

Mir ist die Geschwindigkeit da mehr im Vordergrund.
Warum? Sollte das Programm nicht erstmal funktionieren?

Diese Philisophie sehen wir alle hier jeden Tag mit irgendwelchen Code, der zum Teil nicht mal von den Einzelnen nachvollzogen werden kann. Genaugenommen habe ich mal eben auch schnell was zusammengezimmert, wo mir Tom in https://forum.selfhtml.org/?t=98391&m=599837 und https://forum.selfhtml.org/?t=98391&m=599930 die Zähne gezogen hat; und das völlig zu recht. Dieses "erstmal funktionieren" ist nach meinem Geschmack keines Falls das, was man braucht.

Ich dachte eigentlich, das es genau das ist, was man braucht, denn die Alternative wäre "funktioniert erstmal nicht", denn entweder klappt es oder nicht; ein bischen schwanger gibt es nicht.

Ja Christoph, viele Wege führen nach Rom. In diesem Sinne finde ich Deinen Vergleich der Schwangerschaft unpassend, denn funktionieren werden viele Wege. Aber beim Beispiel bleibend scheint es Schwangerschaften zu geben die länger als neun Monate brauchen; oder anders ausgedrück: Manch eine Reise hat die Stationen Paris - Erkner - Rom ;)
 Allgemein ist mir Deine Denkweise zu schroff und der vermutete -Beweis durch Kontraposition- dem Verständnis, was gemeint ist, nicht zuträglich. Mir geht es nicht um das direkte Gegenteil von "[erstmal ]funktionieren" zu "[erstmal ]nicht funktionieren" hin, sondern nur um das Wie mit der Grundlage "funktionieren". Wenn Du so willst: "funktioniert" <> "funktioniert bestmöglich"

[... "finite Zeit" ...] Wenn dann noch der letzte Fitz fehlen sollte, dann kannst Du nachschauen, wo's hängt, aber empfehlen würde ich da eher einen anderen Algorithmus zu suchen. Macht deutlich mehr Sinn als sich darum zu streiten, ob der minimale Overhead von PHPs syntactic sugar Karies verursacht.

Wovon reden wir hier? Davon, daß man jede Zeile funktionierenden Codes eines -erstmal funktionierenden- Projekts auseinanderprlückt, um es zu optimieren, und dies beim nächsten wieder, und beim nächsten, und... Nein - ich nicht. Ich für meinen Teil meine, wenn man verschiedene Aspekte von Anweisungen / Funktionen sich als Kenntnis zur Basis gemacht hat, wird beim Zusammenstellen eines Scripts sich eine spätere Optimierung schlichtweg erübrigen. Um es deutlich zu sagen: Es geht mir um eine Basis, die nicht der Zielsetzung "es funktioniert" hat, sondern vielmehr "es ist das Bestmögliche, was ich weiß und kann".

Genaugenommen reden wir hier also über den grundlegenden Ansatz von Programmiertechnik. Ich will jedes Sandkorn im Getriebe kennen, bevor ich ein solches zusammensetze und kann möglicherweise auf eine Aufrüstung mit PS-stärkerem Motor verzichten.
 Das erarbeiten einer solchen Basis ist überaus Zeitaufwändig. Und genau da geht Dein Argument fehl: Ist die Basis da, verbraucht sie keinerlei Zeit, sondern im Gegenteil wird Zeit für nötige Optimierungen erspart.

Vor einer Überpüfung habe ich geglaubt, die neu Funktion scandir() sei eine Erleichterung. Jetzt weiß ich es besser. Vor einer Überprüfung habe ich geglaubt, mit fgets() bin ich gut bedien. Jetzt weiß ich es besser. Vor einer Überpüfung habe ich geglaubt, mit count() in einer Schleife arbeiten zu wollen. Jetzt weiß ich es besser...

Hast Du schon mal den Code von einem Vorgänger durcharbeiten sollen?

Ja. Aber was hat das hiermit zu tun?

Hast Du dann auch schon mal mit der hablen Zeit -das Selbe- erledigt?

Was wenn ein Kunde mal die Kosten für ein Gutachten nicht scheut?

Wer macht das Gutachten und vor allem: worauf hin? Doch höchstens daraufhin, das die Vorgaben nicht eingehalten wurden und ob da Sicherheitsmängel zu finden sind. Was noch?

Was war noch mal mein Anliegen? ;)

Diese Einstellung hat bei kleinen Leuten mit kleinem Budget Berechtigung.

Da schon mal überhaupt nicht. Das teuerste ist bei Softwareentwicklung Zeit und Microoptimierung frißt Zeit, die kannst Du stets anderweitig _viel_ gewinnbringender einsetzen.

Mit "Diese Einstellung hat bei kleinen Leuten mit kleinem Budget Berechtigung." stimme ich Dir zu und fange mir "Da schon mal überhaupt nicht." ein. Jetzt wird mir Deine Logik zu hoch.

Es gibt kein "extrasauberes" Coding, entweder ist das ordentlich oder schlampig.

Entweder Du widersprichst Dir hier, oder Du gibst zu, lieber schlampigen Code abzuliefern an dem man "immer noch dran rumfeilen [kann]".

Ach, Du möchtest beides? Sauberen _und_ geschwindigkeitsoptimierten Code? Das funktoniert nicht, da ist das Minimax-Gesetz gegen.

Hm, google half mir nicht weiter. Bitte gib eine Quelle an, damit ich die gleiche Grundlage habe. Ich kenne kein Minimax-Gesetz.

Du kannst nur _entweder_ sauber schreiben _oder_ geschwindigkeitsoptimiert. Beides gleichzeitig geht nicht. (Auch wenn die Formulierung "geht nicht" mir fast schon körperliche Schmerzen bereitet ;-)
Wenn Du geschwindigkeitsmäßig noch signifikant etwas rausholen kannst (z.B. O(n*log(n)) statt O(n^2)) dann war der vorherige Algorithmus einfach _falsch_ und nicht bloß lahm.

Du kannst es Dir erlauben schlampig zu werden, wenn Du _genau_ weißt, was Du tust. Dieses "genau" sollte aber vorzugsweise bis runter zu den Opcodes gehen.

Dies abzustellen bin ich Stückweise dabei.

Was abstellen?

1. Schlampig zu arbeiten
  2. nicht genau zu wissen was ich tue

Das mache ich mit Grundlagenforschung, indem ich mich stückweise auch an die Sourcen von PHP herantaste.

Gruß aus Berlin!
eddi

[Christoph Zurnieden]

Hi,

Ich dachte eigentlich, das es genau das ist, was man braucht, denn die Alternative wäre "funktioniert erstmal nicht", denn entweder klappt es oder nicht; ein bischen schwanger gibt es nicht.

Ja Christoph, viele Wege führen nach Rom.

Ich dachte eigentlich immer: alle?

In diesem Sinne finde ich Deinen Vergleich der Schwangerschaft unpassend, denn funktionieren werden viele Wege. Aber beim Beispiel bleibend scheint es Schwangerschaften zu geben die länger als neun Monate brauchen; oder anders ausgedrück: Manch eine Reise hat die Stationen Paris - Erkner - Rom ;)

Ja, mitunter ist die Landkarte, die Entscheidung, der Algorithmus falsch.

Allgemein ist mir Deine Denkweise zu schroff und der vermutete -Beweis durch Kontraposition-

Nein, das war's noch nicht einmal, das war schlichte Polemik. Mitunter laß ich mich da hinreißen, bitte um Entschuldigung.

dem Verständnis, was gemeint ist, nicht zuträglich. Mir geht es nicht um das direkte Gegenteil von "[erstmal ]funktionieren" zu "[erstmal ]nicht funktionieren" hin, sondern nur um das Wie mit der Grundlage "funktionieren". Wenn Du so willst: "funktioniert" <> "funktioniert bestmöglich"

Dann hängt aber alles an Deiner Definition von "bestmöglich".
Es ist wie schon erwähnt, das Gleiche wie beim Minimax-Prinzip. _Entweder_ maximierst Du den Gewinn _oder_ minimierst die Kosten, beides _gleichzeitig_ geht einfach nicht aber das ist genau das, was Du hier versuchst.

Das erarbeiten einer solchen Basis ist überaus Zeitaufwändig.

Rein theoretisch sogar unendlich, denn Du mußt Dein Wissen ja ständig uptodate halten: für jede Architektur, Sprachversion und Erkenntnisse der Informationstechnik.
Ich mein: Du weißt ganz genau, wann Dir der Kernelscheduler dazwischenhaut? Ob das stört oder nicht? Für jeden Kernel auf jeder Architektur, die der Mensch geschaffen hat und noch schaffen wird? Nur ein kleines Teil von sehr vielen.

Und genau da geht Dein Argument fehl: Ist die Basis da, verbraucht sie keinerlei Zeit, sondern im Gegenteil wird Zeit für nötige Optimierungen erspart.

Ich behaupte hier aber nunmal, das _solche_ Optimierungen nicht nötig sind. Wenn Deine Hardware bereits an einem OPunkt ist, das die 1-3% Geschwindigkeitsverbesserung tatsächlich nötig werden, dann reicht die Hardware einfach nicht mehr.
Es gibt Optimierungen, die bringen 'was: reduziertes I/O, reduzierte DB-Zugriffe, ein besserer Sortieralgorithmus, usw,
das bringt Geschwnidigkjeitssteigerungen im exponetiellen Bereich. Aber auch reduzierte Codemenge (= weniger potentielle Bugs!) bringt etwas: es funktioniert schneller (das Programm ist in kürzerer Zeit entwickelt bzw hat weniger Bugs): R&D ist billiger.
Auch können spezielle Algorithem dazu führen, das, obwohl sie einzeln betrachtet deutlich langsamer sind als andere, parallel abgearbeitet werden können, ich kann ein Mehrprozessorsystem ausnutzen.

Hier und da einen Zyklus einzusparen bringt vieleicht etwas bei einem Computerspiel, denn mehr Frames/Sekunde ist aus mir nicht ganz erfindlichen Gründen wohl ein gutes Verkaufsargument.
Im Embeded Bereich der Endverbraucher (Handhelds) ist Geschwindigkeit der Ausführung auch kaum noch ein Problem, da ist es mit deutlicher Mehrheit der begrenzte Speicher.
BTW: in Handhelds sind meist RISC-Prozessoren verbaut, kennst Du Dich mit deren Gepflogenheiten ebenfalls aus?

Vor einer Überpüfung habe ich geglaubt, die neu Funktion scandir() sei eine Erleichterung. Jetzt weiß ich es besser.

Ja, ist es denn komplizierter damit?

Vor einer Überprüfung habe ich geglaubt, mit fgets() bin ich gut bedien. Jetzt weiß ich es besser.

Was gibt es denn besseres?

Vor einer Überpüfung habe ich geglaubt, mit count() in einer Schleife arbeiten zu wollen. Jetzt weiß ich es besser...

Was ist daran verkehrt?

Hast Du schon mal den Code von einem Vorgänger durcharbeiten sollen?

Ja. Aber was hat das hiermit zu tun?

Hast Du dann auch schon mal mit der hablen Zeit -das Selbe- erledigt?

Du meinst: "Mein lieber Mann, was für ein Murks, das habe ich ja schneller neu gebaut als repariert!"?
Ja, das kam schon mal vor.
Aber da nur für pieselige 100% Geschwindigkeitssteigerung dranzugehen - nein, das bringt nix, das zahlt keiner. Das Risiko nicht zu vergessen, das man durch jede(!) Änderung auch neue Bugs einbauen kann!
Wenn ich jedoch sehe, das ich auch bei konservativster Kosten/Nutzen/Risiko Kalkulation Gewinn machen kann (Anderer Algorithmus verringert Komplexität im Code und/oder macht das 10-100x schneller), dann geh ich da ran, das kann ich auch gut verkaufen.

Was wenn ein Kunde mal die Kosten für ein Gutachten nicht scheut?

Wer macht das Gutachten und vor allem: worauf hin? Doch höchstens daraufhin, das die Vorgaben nicht eingehalten wurden und ob da Sicherheitsmängel zu finden sind. Was noch?

Was war noch mal mein Anliegen? ;)

Geschwindigkeitsoptimierung, ja.
Stehen da Geschwindigkeitsvorgaben in den Specs? Nein? Dann muß Dich das auch nicht kümmern.
Stehen da welche drin? Hast Du die eingehalten wenn auch nicht ein Promille mehr, obwohl theoretisch möglich? Dann muß Dich das auch nicht kümmern.

Nur wenn das Dein einziger Kunde ist, hast Du ein Problem, das ist aber keineswegs informationstechnischer Art, sondern ökonomischer.

Diese Einstellung hat bei kleinen Leuten mit kleinem Budget Berechtigung.

Da schon mal überhaupt nicht. Das teuerste ist bei Softwareentwicklung Zeit und Microoptimierung frißt Zeit, die kannst Du stets anderweitig _viel_ gewinnbringender einsetzen.

Mit "Diese Einstellung hat bei kleinen Leuten mit kleinem Budget Berechtigung." stimme ich Dir zu und fange mir "Da schon mal überhaupt nicht." ein. Jetzt wird mir Deine Logik zu hoch.

Dann war es ein Mißverständnis, für mich sah es tatsächlich so merkwürdig aus.
Allerdings: auch mit großem Budget würde ich das Geld für andere Zwecke als Microoptimierung einsetzen. Aber ich habe auch noch nie eine Softwareentwicklung mit großem Budget gesehen, selbst bei Microsoft nicht, wenn man das in Relation setzt. Das gibt es vielleicht bei Geheimdiensten von Staaten mit großem BIP zum Zwecke des Schlüsselknackens o.ä., aber nicht in der Wirtschaft.

So ein Budget ist immer zu klein für den Entwickler und immer zu groß für den Geldgeber.

Ach, Du möchtest beides? Sauberen _und_ geschwindigkeitsoptimierten Code? Das funktoniert nicht, da ist das Minimax-Gesetz gegen.

Hm, google half mir nicht weiter. Bitte gib eine Quelle an, damit ich die gleiche Grundlage habe. Ich kenne kein Minimax-Gesetz.

Steht's nicht bei Google gibt's da nicht?
Ja, das kann passieren, ist aber auch sehr unwahrscheinlich.
Wie auch hier:
http://www.google.de/search?q=minimax&ie=UTF-8&oe=UTF-8
letzter Eintrag auf der Seite http://de.wikipedia.org/wiki/Minimax-Algorithmus.
Ich meinte zwar die kaufmännische Variante (z.B. irgendwo hier http://www.sam.sdu.dk/parn/parn/allpap1294), aber
das spielt keine wesentliche Rolle ist prinzipiell das Gleiche.

Was abstellen?

1. Schlampig zu arbeiten
  2. nicht genau zu wissen was ich tue

Das mache ich mit Grundlagenforschung, indem ich mich stückweise auch an die Sourcen von PHP herantaste.

Damit weißt Du aber imer nochnicht, was Du da genau tust. Wenn Du nur die Rosinen aus dem Kuchen porkelst weißt Du nicht, ob Deine Entscheidung evt Seiteneffekte hat. Du weißt ja noch nicht einmal, ob die Lösung der PHP-Entwickler geschwindigkeitsoptimal ist. Oder schaust Du jedesmal nach, was der Compiler aus dem C-Code an Maschinencode gezaubert hat? C erlaubt auch Inline-Assembler und das führt auch mich hin und wieder in Versuchung. Aber ich habe gelernt _vorher_ nachzuschauen, was der Compiler da selber optimiert. Das reicht in 99,9% der Fälle und für das restliche Promille ist der Aufwand einfach viel zu hoch. Ob Du den jetzt vorher betreibst oder jedesmal, also in Raten, spielt keine Rolle, kostet alles am Ende das Gleiche.
Dein Vorgehen ist einfach nicht ökonomisch.

Aber ich kann Dich natürlich auch verstehen: es macht Spaß einer Sache auf den Grund zu gehen. Und es macht auch Spaß, das dadurch erworbene Wissen in die Tat umsetzen zu können. Das rüttelt aber in keinster Weise an der Tatsache: es ist hier nicht nötig, denn Du kannst Dein Wissen nicht wirklich anwenden, das sieht nur von außen so aus.
Das Wissen über die Struktur des Quellcodes von PHP könntest Du nur gewinnbringend anlegen, wenn Du selber darin Änderungen ausführen willst/mußt, eine ähnliche Sprache schreiben willst oder z.B. auch nach Sicherheitsmängeln suchst. Danach zu schauen welche Funktion schneller ist, ist hingegen eine müßige Übung.

so short

Christoph Zurnieden

[XaraX]

Hallo Christoph,

über Ökonomie gab es bereits eine Satire, deren meist verkannte Essenz "der Zweck heiligt die Mittel" war...
Gestatte mir; ich belasse es mal, wenn auch mit dem Zusatz genau diesen Punkt im direkten Gespräch aufgreifen zu können.

Gruß aus Berlin!
eddi

[Andreas Korthaus]

Hallo!

Vor einer Überpüfung habe ich geglaubt, die neu Funktion scandir() sei eine Erleichterung. Jetzt weiß ich es besser.

wo ist das Problem?

Vor einer Überprüfung habe ich geglaubt, mit fgets() bin ich gut bedient. Jetzt weiß ich es besser.

kommt drauf an...

Vor einer Überpüfung habe ich geglaubt, mit count() in einer Schleife arbeiten zu wollen. Jetzt weiß ich es besser...

count($array) ist eine O(1) Operation. Ein PHP-Array führt intern einen counter mit sich, der bei jeder Änderung aktualisiert wird. Vergleichbares gilt für strlen($string)...

Grüße
Andreas

[XaraX]

Hallo Andreas,

Vor einer Überpüfung habe ich geglaubt, die neu Funktion scandir() sei eine Erleichterung. Jetzt weiß ich es besser.
wo ist das Problem?

scandir() ist lam gegen while() in Verbindung mit opendir(), readdir() und closedir().

scandir         : 0.050137042999268
while()         : 0.015081882476807

Vor einer Überprüfung habe ich geglaubt, mit fgets() bin ich gut bedient. Jetzt weiß ich es besser.
kommt drauf an...

Ja das ist richtig, daher will ich mich präzisieren: fgets() zur Ausgabe des gesamten Inhalts läßt sich einfacher und schneller (je nach dem) über readdir() oder file_get_contents() oder file() erledigen.

Vor einer Überpüfung habe ich geglaubt, mit count() in einer Schleife arbeiten zu wollen. Jetzt weiß ich es besser...
count($array) ist eine O(1) Operation. Ein PHP-Array führt intern einen counter mit sich, der bei jeder Änderung aktualisiert wird. Vergleichbares gilt für strlen($string)...

Der Vergleich zweier Integer anscheinend schneller zu sein.

Gruß aus Berlin!
eddi

[Christoph Zurnieden]

Hi,

ja, ich weiß, Du wolltest nicht mehr, aber keine Angst: ich reite auch nicht mehr drauf rum, respektiere Deinen Wunsch.

Vor einer Überpüfung habe ich geglaubt, die neu Funktion scandir() sei eine Erleichterung. Jetzt weiß ich es besser.
wo ist das Problem?

scandir() ist lam gegen while() in Verbindung mit opendir(), readdir() und closedir().

scandir         : 0.050137042999268
while()         : 0.015081882476807

scandir() ist aufwendiger weil es das Ergenis vor der Ausgabe auch noch sortiert. Steht zumindest in der Manpage.

Aber davon ab: was sind das eigentlich für Nummern? Wo kommen die her? Wie lautete der Code für diesen Benchmark? Wie kontrolliert war die Umgebung (Load des Systems)? Was für eine Umgebung? Welche Versionen welcher beteiligter Software? Da es sich zudem um OpenSource-Ware handelt: mit welchem Compiler wie gebaut?

Gut, das sind natürlich die strengen akademischen Bedingungen, die will ich dafür nicht unbedingt ansetzen wollen, aber Du hättest ja zumindest ein paar dürre Worte oder Zeilen Code dazu mitgeben können. So ganz "nackicht" kann man da recht wenig mit anfangen.

Vor einer Überprüfung habe ich geglaubt, mit fgets() bin ich gut bedient. Jetzt weiß ich es besser.
kommt drauf an...

Ja das ist richtig, daher will ich mich präzisieren: fgets() zur Ausgabe des gesamten Inhalts läßt sich einfacher und schneller (je nach dem) über readdir() oder file_get_contents() oder file() erledigen.

fgets() ist eigentlich auch nur zum sequentiellem gepuffertem Dateilesen gedacht, nicht dafür, eine gesamte Datei einzulesen und _nur_ das. Deswegen gibt es ja die anderen Funktionen, die genau für diesen Spezialfall gedacht sind.
Im Bereich in dem PHP am meisten genutzt wird, ist aber normalerweise eh nur die gesamte Datei wichtig, das ist bei PHP also kein Spezialfall mehr, sondern Regel. Deshalb gibt es die entsprechnden Funktionen, die dem Programmierer die Schreibarbeit abnehmen. "Syntactic sugar" wie's so schön heißt, wenn's auch hier nicht stimmt.

count($array) ist eine O(1) Operation. Ein PHP-Array führt intern einen counter mit sich, der bei jeder Änderung aktualisiert wird. Vergleichbares gilt für strlen($string)...

Der Vergleich zweier Integer anscheinend schneller zu sein.

Gibt es auch die dafür nötigen Angaben, damit man das nachvollziehen kann? Zumindest ein kleines Stückchen Code?

Der Vergleich zweier Integer kann je nach Umständen, Architektur und Größe der beteiligten Integer gerade mal zwei Zyklen benötigen. Inklusive Registerladen.
Für die Komplexitätsberechnung ist aber beides O(1), da nur eine Berechnung durchgeführt werden muß: count($array) zählt den internen Counter einen hoch/runter, zwei Integer vergleichen ist aber auch nur - naja, ein einziger Vergleich eben.

so short

Christoph Zurnieden

[XaraX]

Hallo Christoph,

ja, ich weiß, Du wolltest nicht mehr, aber keine Angst: ich reite auch nicht mehr drauf rum, respektiere Deinen Wunsch.

Mein Wunsch ist es durchaus das ganze nochmal aufzugreifen - allerdings nicht im Theoretischen sondern Praktischem. Sofern haben Deine tiefergehenden Überlegungen allgemeingültig Bestand, daher kann ich Deine Überlegungen auch so stehen lassen.

Ich bin Dir in dem Sinne um jeden Ausreißer dankbar, der sich reproduzieren läßt - allerdings mit dem Zusatz PHP als gemeinsame Basis.

Vor einer Überpüfung habe ich geglaubt, die neu Funktion scandir() sei eine Erleichterung. Jetzt weiß ich es besser.
wo ist das Problem?

scandir() ist lam gegen while() in Verbindung mit opendir(), readdir() und closedir().

scandir         : 0.050137042999268
while()         : 0.015081882476807

scandir() ist aufwendiger weil es das Ergenis vor der Ausgabe auch noch sortiert. Steht zumindest in der Manpage.

Aber davon ab: was sind das eigentlich für Nummern?

Es sind Zahlen, die die Sekunden eines Durchlaufs ausdrücken.

Wo kommen die her?

Aus einem geparstem Steuerfluß.

Wie lautete der Code für diesen Benchmark?

Erstmalig zusammengefriemelt: http://forum.de.selfhtml.org/archiv/2004/9/t90480/#m542996
In diesem Thread beschrieben: https://forum.selfhtml.org/?t=98391&m=599923

Wie kontrolliert war die Umgebung (Load des Systems)?

Das System steht alleine, Zugriffe fanden nicht statt.

Was für eine Umgebung?

Der obere Test wurde auf einer SuSe 9.1 i586 - Kernel 2.6.5-7.111.19-default auf einem AMD 1200 veranstaltet.
Der Prozess wurde mit env -i gestartet. Weitere laufende Prozesse:

USER        PID ACCESS COMMAND
/                    root          1 .rc..  init
                     root          2 .rc..  ksoftirqd/0
                     root          3 .rc..  events/0
                     root          4 .rc..  kacpid
                     root          5 .rc..  kblockd/0
                     root          6 .rc..  khelper
                     root          7 .rc..  pdflush
                     root          8 .rc..  pdflush
                     root          9 .rc..  kswapd0
                     root         10 .rc..  aio/0
                     root        164 .rc..  kseriod
                     root        355 .rc..  reiserfs/0
                     root        424 .rc..  kcopyd
                     root       1114 .rc..  khubd
                     root       2074 .rc..  login
                     root       2075 .rc..  mingetty
                     root       2076 .rc..  mingetty
                     root       2077 .rc..  mingetty
                     root       2078 .rc..  mingetty
                     root       2079 .rc..  mingetty
                     root       2218 .r...  bash
                     root       2249 .r...  fuser

Welche Versionen welcher beteiligter Software?

sh --version  //GNU bash, version 2.05b.0(1)-release (i586-suse-linux)
env --version //env (coreutils) 5.2.1
php --version //PHP 5.0.3 (cli) //Zend Engine v2.0.3

Da es sich zudem um OpenSource-Ware handelt: mit welchem Compiler wie gebaut?

Da müste ich jetzt lügen, derzeit habe ich gcc (GCC) 3.3.3 (SuSE Linux) drauf
Parameter waren glaube ich default -O2 -pthread -DZTS

Gut, das sind natürlich die strengen akademischen Bedingungen, die will ich dafür nicht unbedingt ansetzen wollen, aber Du hättest ja zumindest ein paar dürre Worte oder Zeilen Code dazu mitgeben können. So ganz "nackicht" kann man da recht wenig mit anfangen.

Hallo? Was glaubst Du warum ich das Ferne vor Deiner Diskusion gesucht habe? Weil ich mich durch Theoretisches abgekanzelt fühle.

Vor einer Überprüfung habe ich geglaubt, mit fgets() bin ich gut bedient. Jetzt weiß ich es besser.
kommt drauf an...

Ja das ist richtig, daher will ich mich präzisieren: fgets() zur Ausgabe des gesamten Inhalts läßt sich einfacher und schneller (je nach dem) über readdir() oder file_get_contents() oder file() erledigen.

fgets() ist eigentlich auch nur zum sequentiellem gepuffertem Dateilesen gedacht, nicht dafür, eine gesamte Datei einzulesen und _nur_ das. Deswegen gibt es ja die anderen Funktionen, die genau für diesen Spezialfall gedacht sind.
Im Bereich in dem PHP am meisten genutzt wird, ist aber normalerweise eh nur die gesamte Datei wichtig, das ist bei PHP also kein Spezialfall mehr, sondern Regel. Deshalb gibt es die entsprechnden Funktionen, die dem Programmierer die Schreibarbeit abnehmen. "Syntactic sugar" wie's so schön heißt, wenn's auch hier nicht stimmt.

Na endlich! Darum geht es mir doch die ganze Zeit.

count($array) ist eine O(1) Operation. Ein PHP-Array führt intern einen counter mit sich, der bei jeder Änderung aktualisiert wird. Vergleichbares gilt für strlen($string)...

Der Vergleich zweier Integer anscheinend schneller zu sein.

Gibt es auch die dafür nötigen Angaben, damit man das nachvollziehen kann? Zumindest ein kleines Stückchen Code?

for($i=0;$i<count($a);$i++)

gegen

for($i=0;$i<1536;$i++)

Betrifft unteren Teil

Der Vergleich zweier Integer kann je nach Umständen, Architektur und Größe der beteiligten Integer gerade mal zwei Zyklen benötigen. Inklusive Registerladen.
Für die Komplexitätsberechnung ist aber beides O(1), da nur eine Berechnung durchgeführt werden muß: count($array) zählt den internen Counter einen hoch/runter, zwei Integer vergleichen ist aber auch nur - naja, ein einziger Vergleich eben.

Es bleibt wie gehabt, Querschläger nehme ich sehr gerne zur Kenntnis, um meine Basis wieder zu verbreitern.

Gruß aus Berlin!
eddi

[Christoph Zurnieden]

Hi,

Ich bin Dir in dem Sinne um jeden Ausreißer dankbar, der sich reproduzieren läßt - allerdings mit dem Zusatz PHP als gemeinsame Basis.

Ahso. Und wofür schlepp' ich die ganzen sauschweren Schwarten mit den Prozessoropcodes aus dem Keller? ;-)

Wie kontrolliert war die Umgebung (Load des Systems)?
Das System steht alleine, Zugriffe fanden nicht statt.

Ich habe hier eigentlich etwas Statistik erwartet. Ist aber nicht weiter schlimm.

Was für eine Umgebung?

Der obere Test wurde auf einer SuSe 9.1 i586 - Kernel 2.6.5-7.111.19-default auf einem AMD 1200 veranstaltet.

Ist das der SuSE oder der Vanila-Kernel?

Der Prozess wurde mit env -i gestartet. Weitere laufende Prozesse:

USER        PID ACCESS COMMAND
/                    root          1 .rc..  init

[...]

root       2218 .r...  bash

Na, na, na! ;-)

Hallo? Was glaubst Du warum ich das Ferne vor Deiner Diskusion gesucht habe? Weil ich mich durch Theoretisches abgekanzelt fühle.

Achso, dann sag' das doch! Kann ich doch nicht riechen!
Da ich Code verlangte ist das zwar eigentlich fast schon  automatisch nicht mehr theoretisch, aber ohne eine gewisse Mindestmenge Theorie geht's leider gar nicht. Dazu gehört bei Optimierungsversuchen natürlich Komplexitätstheorie. Das hört sich alles doll an, sieht ehrfurchtsgebietend aus, aber es hört sich wirklich nur so an und sieht auch tatsächlich nur so aus.
Die berüchtigte O-Notation wird gerne als Überblick benutzt und bedeutet extrem simplifiziert (Alle Infor-, Mathe- und andere -matiker mal eben weggehört! ;-):
'n'  => Anzahle der beteiligten Daten
O(1) => um zum Ergebnis zu kommen reicht eine Operation, egal wieviele Daten beteiligt sind => einmal.
O(n) => für jedes einzelne beteiligte Datum wird auch eine Operation benötigt, um zum Ergebniss zu kommen => n-mal
0(n^2) = Jedes Datum muß genau so oft angefaßt werden, wie es Daten gibt => (n*n)-mal
...
Es entwickelt sich also exponentiell und bezieht sich immer auf die Menge der Daten. Deswegen bringen Optimierungen dann am meisten, wenn sie es schaffen so wenig Daten so selten wie möglich anzufassen, um zum Ergebniss zu kommen.
Es ist also schön für Dich, das eine Berechnung eines Datums schneller ist, als eine andere, aber _gar keine_ Berechnung ist nunmal unschlagbar schneller, oder?

"Laufzeit-Optimierung" ist also die Suche nach einem besserem Algorithmus, nicht nach dem einem oder anderem einsparbaren Prozessorzyklus.

Der Vergleich zweier Integer anscheinend schneller zu sein.

Gibt es auch die dafür nötigen Angaben, damit man das nachvollziehen kann? Zumindest ein kleines Stückchen Code?

for($i=0;$i<count($a);$i++)

gegen

for($i=0;$i<1536;$i++)

Ah, d'rum.
Falls im erstem Fall mit $a innerhalb der Schleife nichts gemacht wird, ist das count($a) recht sinnlos. Allerdings sollte das dann der Compiler/Interpreter gut wegoptimieren können (Im zweitem Fall passiert das ja wohl auch). Macht das die heutige Version nicht, macht's die morgige, Fummeleien sind da recht zweckfrei, solche Kinkerlitzchen solte man dem Compiler überlassen, der kennt sich da meist besser aus.

Es bleibt wie gehabt, Querschläger nehme ich sehr gerne zur Kenntnis, um meine Basis wieder zu verbreitern.

Vergiß es gleich wieder, denn das hat keine großen sittlichen Nährwert, wenn Du mit der Sprache nur etwas programmieren willst und nicht an der Sprache/Interpreter/Compiler selber Veränderungen vornehmen möchtest.

so short

Christoph Zurnieden

[XaraX]

Morgen Christop,

Ich bin Dir in dem Sinne um jeden Ausreißer dankbar, der sich reproduzieren läßt - allerdings mit dem Zusatz PHP als gemeinsame Basis.

Ahso. Und wofür schlepp' ich die ganzen sauschweren Schwarten mit den Prozessoropcodes aus dem Keller? ;-)

Ich wäre sicher nicht am Rumbasteln mit PHP, wenn ich mir Notfalls eigene Lösungen herzaubern könnte. Daher anerkenne ich ja Deine Überlegungen als weitergehender und daher besser. Das mit den Wälzern tut mir leid; und auch noch aus dem Keller... Tschuldige so viel Tiefgang bedarf es nicht (noch nicht).

Was für eine Umgebung?

Der obere Test wurde auf einer SuSe 9.1 i586 - Kernel 2.6.5-7.111.19-default auf einem AMD 1200 veranstaltet.

Ist das der SuSE oder der Vanila-Kernel?

yast meldet mir dazu, es sei der hauseigene von Suse.

Hallo? Was glaubst Du warum ich das Ferne vor Deiner Diskusion gesucht habe? Weil ich mich durch Theoretisches abgekanzelt fühle.

Achso, dann sag' das doch! Kann ich doch nicht riechen!
Da ich Code verlangte ist das zwar eigentlich fast schon  automatisch nicht mehr theoretisch, aber ohne eine gewisse Mindestmenge Theorie geht's leider gar nicht.

Da ist mir das mit Stift und Block bei einer Cola an einem Tisch wesentlich lieber. Würde mich freund, wenn man das mal in diesem Leben erledigen könnte.

Dazu gehört bei Optimierungsversuchen natürlich Komplexitätstheorie. Das hört sich alles doll an, sieht ehrfurchtsgebietend aus, aber es hört sich wirklich nur so an und sieht auch tatsächlich nur so aus.

... ;)

[...]

Ja - schade eigentlich! Danke! Wieder einer Illusion weniger.

Gruß aus Berlin!
eddi

[Christoph Zurnieden]

Hi,

Ich wäre sicher nicht am Rumbasteln mit PHP, wenn ich mir Notfalls eigene Lösungen herzaubern könnte.

Auch dann würdest Du wahrscheinlich PHP benutzen, da Du es wohl am besten kennst. In seiner Muttersprache unterhält es sich nun mal am leichtesten.

Daher anerkenne ich ja Deine Überlegungen als weitergehender und daher besser.

Sie mögen weitergehender oder besser: allgemeiner sein, aber ob sie besser sind?

Das mit den Wälzern tut mir leid; und auch noch aus dem Keller... Tschuldige so viel Tiefgang bedarf es nicht (noch nicht).

Ich behandele sowas recht großzügig. Deshalb und für die Verknüpfung von Keller und Tiefgang bekommst Du jetzt das Wortwitzschweinderl unter die Nase gehalten und wirst um zwei Euro gebeten.

Achso, dann sag' das doch! Kann ich doch nicht riechen!
Da ich Code verlangte ist das zwar eigentlich fast schon  automatisch nicht mehr theoretisch, aber ohne eine gewisse Mindestmenge Theorie geht's leider gar nicht.

Da ist mir das mit Stift und Block bei einer Cola an einem Tisch wesentlich lieber. Würde mich freund, wenn man das mal in diesem Leben erledigen könnte.

Ich habe eine Sauklaue, nuschele, hasse Cola und haare stark (bin aber stubenrein), aber wenn Du meinst. Würde aber eher Email empfehlen.

so short

Christooph Zurnieden

[Tom]

Hello,

Ich dachte eigentlich, das es genau das ist, was man braucht, denn die Alternative wäre "funktioniert erstmal nicht", denn entweder klappt es oder nicht; ein bischen schwanger gibt es nicht.

Beim Programmieren schon!
Es funktioniert eben nur dann, wenn man alle Randbedingungen genau einhält. Jede Abweichung von der vom Programmierer beim "ein bisschen Schwängern" berücksichtigten Spur führt ins Chaos.

Das ist ein beliebter Fehler. Man programiert, was nicht funktionieren soll und lässt alle anderen Fälle zu, statt dass man programmiert, was wann woduch funktionieren soll und alle anderen Fälle per default verbietet und abfängt.

Harzliche Grüße aus http://www.annerschbarrich.de

Tom

[Christoph Zurnieden]

Hi,

Ich dachte eigentlich, das es genau das ist, was man braucht, denn die Alternative wäre "funktioniert erstmal nicht", denn entweder klappt es oder nicht; ein bischen schwanger gibt es nicht.

Beim Programmieren schon!
Es funktioniert eben nur dann, wenn man alle Randbedingungen genau einhält. Jede Abweichung von der vom Programmierer beim "ein bisschen Schwängern" berücksichtigten Spur führt ins Chaos.

Wenn etwas für genau bezeichnete Bedingungen funktionieren soll, muß es einen Mechanismus geben, der andere Bedingunegn ausschließt. Ein Programm, das dieses nicht tut ist als fehlerhaft anzusehen und somit als nicht funktionierend.
Sollte es Absicht gewesen sein, das es auf die Art funktioniert - warum auch immer - dann entspricht das Programm den Spezifikationen und ist als voll funktionstüchtig anzusehen.
Alles Bool, Herr Kollege, alles Bool und alles darüber hinaus wird schon mal gar nicht bezahlt >;->

Das ist ein beliebter Fehler. Man programiert, was nicht funktionieren soll und lässt alle anderen Fälle zu, statt dass man programmiert, was wann woduch funktionieren soll und alle anderen Fälle per default verbietet und abfängt.

Ja, das ist der Punkt: "Nimm was Du brauchst und schmeiß den Rest weg." Dazu kommt noch: "Es wird nach Fehlern gesucht, nicht die Funktion bewundert!" und vor allem: "Such Dir immer _vorher_ aus, wem Du später die Schuld geben willst!"

Mein erstes Lemma: "Wenn Du meinst, das das ein Bug im Compiler ist, ist es einer in deinem Code. Wenn Du dort keinen findest ist es ein Bug in Deinem Code."
Mein zweites Lemma: "Ist es wirklich ein Compilerbug merkst Du das nach dem Update des Compilers, denn dann ist es wieder ein Bug in Deinem eigenem Code."
Theorem: "Der Programmierer ist immer Schuld."

so short

Christoph Zurnieden

[Tom]

Hello,

Wenn etwas für genau bezeichnete Bedingungen funktionieren soll, muß es einen Mechanismus geben, der andere Bedingunegn ausschließt. Ein Programm, das dieses nicht tut ist als fehlerhaft anzusehen und somit als nicht funktionierend.

Da hast Du aber eben noch genau was anderes gesagt.
Außerdem würde ein "Newbie" immer den berühmten Spruch tun: "wieso, denn? Funktioniert doch!"

Sollte es Absicht gewesen sein, das es auf die Art funktioniert - warum auch immer - dann entspricht das Programm den Spezifikationen und ist als voll funktionstüchtig anzusehen.

Wer sagt das?

Alles Bool, Herr Kollege, alles Bool und alles darüber hinaus wird schon mal gar nicht bezahlt >;-

?

"Such Dir immer _vorher_ aus, wem Du später die Schuld geben willst!"

Gute Idee!

Mein erstes Lemma: "Wenn Du meinst, das das ein Bug im Compiler ist, ist es einer in deinem Code. Wenn Du dort keinen findest ist es ein Bug in Deinem Code."

Das sowieso.

Ich habe mal in einer ewig langen Switch-Anweisung an einer einzigen Stelle irgendwo statt eines Vergleiches eine Zuweisung gehabt. Alle anderen waren aber richtig. Da suchst Du Dich dämlich. Hat 'nur' einen ganzen Tag gedauert, das zu finden :-(( Ausgerechnet der fehlerhafte Auswahlfall kam nur bei jeder 100sten Abfrage dran, sodass der Fehler eben nur sehr selten auftrat.

Harzliche Grüße aus http://www.annerschbarrich.de

Tom

[Christoph Zurnieden]

Hi,

Wenn etwas für genau bezeichnete Bedingungen funktionieren soll, muß es einen Mechanismus geben, der andere Bedingunegn ausschließt. Ein Programm, das dieses nicht tut ist als fehlerhaft anzusehen und somit als nicht funktionierend.

Da hast Du aber eben noch genau was anderes gesagt.

Nein, nur nicht so elaboriert.

Außerdem würde ein "Newbie" immer den berühmten Spruch tun: "wieso, denn? Funktioniert doch!"

Ja, und genau das ist das Problem: es funktioniert eben nicht. Das Programm soll ja nur auf bestimmte Eingaben eine ebenso bestimmte Ausgabe erarbeiten. Läßt Du nun unbestimmte Eingaben zu, gibt's unbestimmte Ausgaben. Das kann doch keiner guten Gewissens als "funktionierend" bezeichnen?

Tut ja auch normlerweise keiner. Wenn aber nun die Spezifikationen kaputt sind, sozusagen "nicht funktionieren", dann triit der andere von mir beschriebene Fall ein:

Sollte es Absicht gewesen sein, das es auf die Art funktioniert - warum auch immer - dann entspricht das Programm den Spezifikationen und ist als voll funktionstüchtig anzusehen.

Wer sagt das?

Die Spezifikationen sagen das.
Wann funktioniert ein Programm? Wenn es das tut, was in den Spezifikationen steht. Sind die nicht in Ordnung, ist dsa nicht die Schuld des Programmierers, sein Programm kann durchaus exakt nach Vorgabe funktionieren.

Ein kleines krummes Beispiel:
Wenn ich beim Schlosser meiens Vertrauens Schrauben bestimmter Größe anfertigen lasse und die passen nicht, weil ich die verkehrten Maße angegeben habe, wessen Schuld ist das dann? Sind die Schrauben deswegen kaputt, nur weil es keine Mutter dafür gibt?

Alles Bool, Herr Kollege, alles Bool und alles darüber hinaus wird schon mal gar nicht bezahlt >;-

?

Es ist alles "Ja oder Nein", nichts dazwischen, und wenn doch - wird die Rechnung für den Murks nicht bezahlt.

Ich habe mal in einer ewig langen Switch-Anweisung an einer einzigen Stelle irgendwo statt eines Vergleiches eine Zuweisung gehabt. Alle anderen waren aber richtig. Da suchst Du Dich dämlich. Hat 'nur' einen ganzen Tag gedauert, das zu finden :-(( Ausgerechnet der fehlerhafte Auswahlfall kam nur bei jeder 100sten Abfrage dran, sodass der Fehler eben nur sehr selten auftrat.

Es gibt Programme, die einen bei sowas warnen können. Je nach Sprache gibt es Fallen, die können ein paar Zeilen pessimistischer Perlcode o.ä. gut aufspüren. Sowas sollte ein guter Progarmmierer schon am Taschenmesser dranhaben.
(Falls Du da noch nicht sabbernd vorgestanden hast, oder gar schon erworben: http://www.thinkgeek.com/gadgets/tools/6b3b/)

so short

Christoph Zurnieden