Ankündigung

Einklappen
Keine Ankündigung bisher.

Mehrere Prozesse benötigen gleiche Laufzeit in der Summe

Einklappen

Neue Werbung 2019

Einklappen
X
  • Filter
  • Zeit
  • Anzeigen
Alles löschen
neue Beiträge

  • Mehrere Prozesse benötigen gleiche Laufzeit in der Summe

    Hallo

    Ich möchte grössere Datenmengen verarbeiten und versuche deshalb Jobs auf mehrere Prozesse zu verteilen.
    Das Aufteilen, der Respawn und die Kommunikation funktioniert wunderbar. Jedoch sind die Ergebnisse nicht wie zu erwarten. Wenn ich keine CPU-Leistung abrufe, verhält es sich wie erwartet. Mit steigender Anzahl an Prozessen verringert sich die Ausführungszeit. Wenn ich aber leistungsintensive Funktionen ausführe, skaliert das überhaupt nicht mit der Prozessanzahl.

    Ich starte hiermit einen neuen Prozess:

    PHP-Code:
    require_once __DIR__.'/../helper/autoregister.php';

    $stream = new Stream(STDOUTSTDINSTDERR);
    $data $stream->read();
    $watchdog = new Watchdog($data['config']);
    $watchdog->watch();
    $stream->write('Done'); 
    Während des Programmierens habe ich eine Situation simuliert, welche einem API-Aufruf oder sonstiger I/O-Last entspricht.
    PHP-Code:
    class Watchdog {

        public function 
    __construct(array $config){

        }

        public function 
    watch(){
            
    usleep(rand(2000000,3000000));
        }

    Hat alles wie erwartet funktioniert. Ich konnte Problemlos hundert Prozesse parallel starten.
    Kerne Prozesse Dauer Dauer pro Job Proxmox CPU AGV
    16 2 122 2,44 -
    16 4 66 2,64 -
    16 8 32 2,56 -
    16 16 17 2,72 -
    16 32 9 2,88 -
    16 50 6 3 -
    16 100 3 3 -

    Dann wollte ich testen wie sich das Skript verhält, wenn ich CPU-Leistung in den Prozessen abrufe. Da hatte ich (unter Windows) mit den ersten Versuchen nicht viel Erfolg, da der Hauptprozess irgendwie überfordert war, die CPU sich aber gelangweilt hat.
    Also habe ich den usleep gegen folgendes getauscht.
    PHP-Code:
    class Watchdog {

        public function 
    __construct(array $config){

        }

        public function 
    watch(){
            
    $r rand(10000,12000);
            for(
    $x 0$x !== $r$x++){
                
    hash('sha256'bin2hex(random_bytes(4096)).hash('sha512'bin2hex(random_bytes(4096))));
            }
        }

    Diese Code dauerte auf einem Kern etwa 2,5 Sekunden, wohl abhängig von der Zufallszahl, und entsprach somit etwas dem usleep von zuvor. Bei den Tests ist mir dann aber aufgefallen, dass die Anzahl der Prozesse NULL Auswirkung auf die Summe der Laufzeit hat. Habe dann mehrfach geprüft ob die Prozesse richtig starten, ob das Code ausgeführt wird und ob die Rückgabe stimmt. Habe mir dann auch mit PHP ausgeben lassen wie viele (der 100 Jobs) noch ausstehend sind, wie viele Prozesse aktuell offen sein müssen und wie viele Prozesse erfolgreich abgeschlossen wurden. Die Ausgaben passen zu dem, was ich mit htop & Co. auslesen kann. Ich sehe die neu gestarteten Prozesse, die alten abgeschlossenen und die Ausgabe passt zu dem, was der Code machen soll. Jedoch kann man sagen, dass mit Verdoppelung der Prozesse, die Ausführungszeit pro Prozess sich gleich mit verdoppelt. Selbst dann, wenn die Anzahl paralleler Prozesse unter der Anzahl freier Kerne liegt.
    Hier die Tabelle dazu (Jeweils 100 Jobs zu erledigen)
    Kerne Prozesse Dauer Dauer pro Job Proxmox CPU AGV
    8 1 276 2,76 12,50 %
    8 2 292 5,84 25,00 %
    8 3 296 8,88 37,50 %
    8 4 289 11,56 50,00 %
    8 6 291 17,46 75,00 %
    8 8 289 23,12 100,00 %
    8 10 288 28,8 100,00 %
    8 16 289 46,24 100,00 %
    8 25 290 72,5 100,00 %
    8 50 289 144,5 100,00 %
    8 75 291 218,25 100,00 %
    8 100 292 292 100,00 %

    Würde man die Tests mehrfach wiederholen, würden sich die kleinen Unterschiede in der Dauer mit Sicherheit glätten. Also kann man sagen, die Dauer ist immer gleich. Obwohl die CPU-Auslastung extrem ansteigt.
    Habe dann mal noch ein paar Tests mit doppelten (16) Kernen gemacht.
    Kerne Prozesse Dauer Dauer pro Job Proxmox CPU AGV
    16 2 259 5,18 12,50 %
    16 8 229 18,32 50,00 %
    16 16 245 39,2 16,00 %
    16 50 246 123 17,00 %
    16 100 242 242 17,00 %
    Ab hier bin ich raus und konnte mir das Ergebnis überhaupt nicht mehr erklären.

    1. Warum bringt eine 8-fache Rechenleistung (1 Kern zu 8 Kernen) keinen Vorteil, sondern verlängert die Laufzeit der Prozesse OBWOHL 8 Kerne auf Anschlag 100% laufen?
    2. Was läuft bei den 16 Kernen falsch?

    Zum System selbst
    Ich hab das jetzt auf einer Debian VM unter Proxmox mit 8 und 16 Kernen und 8GB RAM getestet. PHP ist 8.0. Mit und ohne opcache macht keinen Unterschied. Ausgeführt auf CLI.
    Host ist ein AMD Epyc mit 48 Kernen. Es laufen noch andere VMs auf dem System. Die meisten sind irgendwelche 2-Kern Systeme, die nichts zu tun haben max. 1% Auslastung haben. Lediglich eine grosse Windows VM mit 32 Kernen döddelt mit 5-10% Auslastung vor sich hin. Aber selbst wenn ich die Test-VM auf allen Kernen voll belaste, bringt das auf dem Host keine 50% Auslastung.

    Ich habe keine Idee, woran das liegen kann.
    Der Unterschied zwischen dem richtigen Wort und dem beinahe richtigen ist derselbe Unterschied wie zwischen dem Blitz und einem Glühwürmchen.

  • #2
    und wo/wie genau startest du ein neune thread, task oder nutzt ein neuenn core ?

    Kommentar


    • #3
      ganz einfach mit proc_open
      PHP-Code:
      class Process {

          private 
      $process;
          private 
      Stream $stream;
          private 
      string|int $id;

          public function 
      __construct(string $cmd){

              
      $chans = [
                  
      => array("pipe""r"),
                  
      => array("pipe""w"),
                  
      => array("file"__DIR__.'/../error.txt'"w")
              ];

              
      $this->process proc_open($cmd$chans$pipes);

              if (
      is_resource($this->process)) {
                  
      $this->stream = new Stream($pipes[0], $pipes[1]);
              }
          }

          public function 
      write($data): bool{
              return 
      $this->stream->write($data);
          }

          public function 
      read(): mixed{
              return 
      $this->stream->read();
          }

          public function 
      close():void{
              if(
      $this->getStatus()['running']){
                  
      $this->stream->close();
                  
      proc_close($this->process);
              }
          }

          public function 
      getStatus():array{
              return 
      proc_get_status($this->process);
          }

      Das Objekt übergebe ich dann im Prozessmanager an die Prozessliste, worüber die laufenden und beendeten Prozesse periodisch verwaltet werden.
      Der Unterschied zwischen dem richtigen Wort und dem beinahe richtigen ist derselbe Unterschied wie zwischen dem Blitz und einem Glühwürmchen.

      Kommentar


      • #4
        wieso mirt proc_open ?
        schau mal da :
        https://www.php.net/manual/de/refs.f...ss.process.php

        Kommentar


        • #5
          Was ist an proc_open falsch? Warum verhält es sich so?
          Eigentlich sollte das Programm unter Windows laufen. Da ich unter Windows aber nicht auf das Ergebnis gekommen bin, welches ich wollte, habe ich es unter Linux versucht. Windows hat mich bei der Wahl der Erweiterungen stark eingeschränkt und proc_* sah nach einer einfachen Plattform unabhängigen Lösung aus, welche in den ersten Tests (mit sleep) auch genau so funktionierte, wie ich es mir vorgestellt habe.
          Der Unterschied zwischen dem richtigen Wort und dem beinahe richtigen ist derselbe Unterschied wie zwischen dem Blitz und einem Glühwürmchen.

          Kommentar


          • #6
            Bist du dir sicher, dass sich durch die Anzahl der gleichzeitigen Prozesse die Anzahl der Aufgaben nicht erhöht?

            Kannst du den kompletten Code zeigen, da ich dies recht interessant aussieht?

            Kommentar


            • #7
              Zitat von SteiniKeule Beitrag anzeigen
              . Windows hat mich bei der Wahl der Erweiterungen stark eingeschränkt und proc_* sah nach einer einfachen Plattform unabhängigen Lösung aus, welche in den ersten Tests (mit sleep) auch genau so funktionierte, wie ich es mir vorgestellt habe.
              Nur ein Tipp, aber schau dir unter Windows mal die WSL2 an.

              Kommentar


              • #8
                Lass dich nicht verwirren von den Prozessorkernen...

                Du hast 1 Prozessor, der eine bestimmte Leistung bringen kann... 1 Prozess auf dem Prozessor bringt 100% Leistung. Teilt man den Prozessor auf 4 (virtuelle) Kerne auf, kann jeder Kern nur 25% der Performance des Prozessors leisten.
                Oder anders gesagt: Egal in wie wieviele Stücke du den Kuchen teilst, es bleibt ein Kuchen. Du kannst nicht aus 1 Kuchen durch Aufteilen in 10 Teile 2 Kuchen von der Göße des ersten Kuchens machen. Das wäre Magie

                Beispiel "Download": Ein Download mit 1MB/s kann nicht schneller gemacht werden, wenn man daraus 2 Downloads macht - die teilen sich die Geschwindigkeit, also 2 Downloads mit je 500kb/s.... 4 DL mit 250kb/s, usw. - unter dem Strich bleibt es aber bei 1 MB/s

                Einen Geschwindigkeitsgewinn bekommst du nur dann, wenn eine lineare Berechnung in parallele Berechnung aufgeteilt werden kann. Dazu dürfen die Teile keine Abhängigkeiten aufweisen, also Teil 2 darf nicht von Teil 1 abhängen, da sonst Teil 2 auf Beendigung von Teil 1 warten müsste (das ist mit das wichtigste Kriterium für "gute" Parallelität).

                Über 90% aller Gewaltverbrechen passieren innerhalb von 24 Stunden nach dem Konsum von Brot.

                Kommentar


                • #9
                  Zitat von SteiniKeule Beitrag anzeigen
                  Was ist an proc_open falsch? Warum verhält es sich so?
                  Eigentlich sollte das Programm unter Windows laufen. Da ich unter Windows aber nicht auf das Ergebnis gekommen bin, welches ich wollte, habe ich es unter Linux versucht. Windows hat mich bei der Wahl der Erweiterungen stark eingeschränkt und proc_* sah nach einer einfachen Plattform unabhängigen Lösung aus, welche in den ersten Tests (mit sleep) auch genau so funktionierte, wie ich es mir vorgestellt habe.
                  mach was du magst , du wiest sicher und genau was proc_open macht - welchen overhead du hast und warum der von mir vorgeschlagene link nicht sinnvoill ist für deine aufgabe.

                  Kommentar


                  • #10
                    Zitat von Blar Beitrag anzeigen
                    Bist du dir sicher, dass sich durch die Anzahl der gleichzeitigen Prozesse die Anzahl der Aufgaben nicht erhöht?

                    Kannst du den kompletten Code zeigen, da ich dies recht interessant aussieht?
                    Ja, ich habe zum Testen einfach ein Array mit der Anzahl Jobs erstellt und bei jedem proc_open ein Element entfernt. Es besteht keine Möglichkeit, dass das Array zu irgend einem Zeitpunkt erweitert wird. Auch lasse ich mir den aktuellen Status ausgeben, der die Anzahl der Jobs, laufenden Prozesse und abgeschlossenen Prozesse beinhaltet. Zusätzlich habe ich in jedem Job eine .txt erstellen lassen und hatte am Ende immer die passende Anzahl an Dateien im Ordner.
                    Der ganze Code ist doch sehr umfangreich, da darin noch eine Menge anderer Abhängigkeiten enthalten sind, die mit dem Thema nichts zu tun haben. Ich hab aber mal ein Beispiel geschrieben, das genau so funktioniert, lediglich ohne Prozess-Kommunikation. Poste ich dann unten.

                    Zitat von lstegelitz Beitrag anzeigen
                    Lass dich nicht verwirren von den Prozessorkernen...

                    Du hast 1 Prozessor, der eine bestimmte Leistung bringen kann... 1 Prozess auf dem Prozessor bringt 100% Leistung. Teilt man den Prozessor auf 4 (virtuelle) Kerne auf, kann jeder Kern nur 25% der Performance des Prozessors leisten.
                    Oder anders gesagt: Egal in wie wieviele Stücke du den Kuchen teilst, es bleibt ein Kuchen. Du kannst nicht aus 1 Kuchen durch Aufteilen in 10 Teile 2 Kuchen von der Göße des ersten Kuchens machen. Das wäre Magie

                    Beispiel "Download": Ein Download mit 1MB/s kann nicht schneller gemacht werden, wenn man daraus 2 Downloads macht - die teilen sich die Geschwindigkeit, also 2 Downloads mit je 500kb/s.... 4 DL mit 250kb/s, usw. - unter dem Strich bleibt es aber bei 1 MB/s

                    Einen Geschwindigkeitsgewinn bekommst du nur dann, wenn eine lineare Berechnung in parallele Berechnung aufgeteilt werden kann. Dazu dürfen die Teile keine Abhängigkeiten aufweisen, also Teil 2 darf nicht von Teil 1 abhängen, da sonst Teil 2 auf Beendigung von Teil 1 warten müsste (das ist mit das wichtigste Kriterium für "gute" Parallelität).
                    Das war de facto 1995 so. Aber seit dem ersten Mehrkernprozessor (glaube der Core2Duo ab ~2005) ist das nicht mehr korrekt. Das kann ich auch ganz einfach dadurch belegen, dass ich mein Script zeitgleich auf 2 VMs auf dem gleichen Host laufen lasse und sich die Ausführungszeiten nicht im Ansatz verändert. Deine Aussage ist auf einen Prozessorkern bezogen richtig. Bei Hyperthreading trifft deine Aussage ebenfalls zu. Dabei wird die Leistung eines Kerns auf (aktuell) 2 virtuelle Kerne aufgeteilt, was die Rechenleistung des Kerns aber nicht verdoppelt. Mal teilt einfach. Das lässt sich auch durch unzählige CPU-Benchmarks mit Single-Core und Multi-Core Ergebnissen belegen.
                    Gleiches trifft auf deine Aussage mit den Downloads zu. 1 Kern ist 1 Leitung. Wenn der Router aber 48 Leitungen angeschlossen hat, kann man auch 48 Downloads mit 1MB/s pro Download starten. Ich kann aber nicht 1 Download mit 48 MB/s starten (ja ich weis, es gibt durchaus Router / Software, die das können).

                    Zitat von tomBuilder Beitrag anzeigen
                    mach was du magst , du wiest sicher und genau was proc_open macht - welchen overhead du hast
                    Ich weis ja nicht ob deine Medis heute nicht richtig kicken oder ob du einfach eine Persönlichkeit hast, die jegliche Äusserungen von Anderen als Kritik oder Angriff siehst...
                    Zitat von SteiniKeule
                    Was ist an proc_open falsch? Warum verhält es sich so?
                    Ich denke ich habe ganz klar und ausdrücklich danach gefragt, was an proc_open falsch ist und wie es sich verhält.

                    Zitat von tomBuilder Beitrag anzeigen
                    und warum der von mir vorgeschlagene link nicht sinnvoill ist für deine aufgabe.
                    Huch, proc_open ist ebenfalls auf der Liste unter deinem Link...
                    Warum beteiligst du dich immer wieder an Unterhaltungen wenn deine Beiträge einfach mal nutzlos und provokant sind?
                    Geh Angeln, geniesse die Sonne, erfreu dich deines Lebens und lass die anderen Menschen einfach sein.



                    proc.php (aka index)
                    PHP-Code:
                    <?php

                    include_once __DIR__.'/job.php';

                    class 
                    process{

                        private array 
                    $processList = [];
                        private 
                    int $closedProcesses 0;
                        private array 
                    $config;
                        private array 
                    $jobList = [];
                        private 
                    string $cmd;

                        public function 
                    __construct(array $config) {
                            
                    $this->config $config;
                            
                    $this->fakeData($this->config['fake_data_limit']);
                            
                    $this->cmd $config['cmd'];
                        }

                        private function 
                    fakeData(int $limit):void{
                            for(
                    $x=0$x !== $limit$x++)
                                
                    $this->jobList[] = random_bytes(2048);
                        }

                        private function 
                    checkProcesses():void{
                            foreach (
                    $this->processList as $id => $process){
                                
                    $status proc_get_status($process['process']);
                                if(!
                    $status['running']){
                                    unset(
                    $this->processList[$id]);
                                    
                    $this->closedProcesses++;
                                }

                            }
                        }

                        private function 
                    checkRespawnProcesses():void{
                            while (
                    count($this->processList) !== $this->config['max_processes'] && $this->jobList)
                                
                    $this->spawnProcess();
                        }

                        private function 
                    spawnProcess():void{

                            
                    $job $this->getJob();
                            if(!
                    $job)
                                return;

                            if(!
                    $this->config['create_process']){
                                
                    $start microtime(true);
                                
                    doJob($job);
                                
                    $this->closedProcesses++;
                                echo 
                    microtime(true)-$start.' >> Jobliste: '.count($this->jobList).' | Aktive Prozesse: 0 | Abgeschlossene Prozesse: '.$this->closedProcesses.PHP_EOL;
                                
                    //ProcessList wird hier nicht verwendet, da der Fake-Process direkt wieder gelöscht werden würde.
                                
                    return;
                            }

                            
                    $chans = [
                                
                    => array("pipe""r"),
                                
                    => array("pipe""w"),
                                
                    => array("file"__DIR__.'/error.txt'"w")
                            ];

                            
                    $process proc_open($this->cmd$chans$pipes);

                            if (
                    is_resource($process)) {
                                
                    $this->processList[] = [
                                    
                    'process' => $process,
                                    
                    'pipes' => $pipes
                                
                    ];
                            }else{
                                throw new 
                    Exception('Process not started! '.$this->cmd);
                            }
                        }

                        private function 
                    getJob():string|null{
                            return 
                    array_shift($this->jobList);
                        }

                        public function 
                    run($status):bool{
                            
                    $this->checkProcesses();
                            
                    $this->checkRespawnProcesses();
                            if(
                    $status)
                                echo 
                    'Jobliste: '.count($this->jobList).' | Aktive Prozesse: '.count($this->processList).' | Abgeschlossene Prozesse: '.$this->closedProcesses.PHP_EOL;
                            return 
                    count($this->jobList) || count($this->processList);
                        }

                    }

                    $config = [
                        
                    //Anzahl generierter Fake-Jobs
                        
                    'fake_data_limit' => 100,
                        
                    //Parallele Prozesse - Funktioniert nur wenn create_process=true
                        
                    'max_processes' => 2,
                        
                    //proc_open verwenden
                        
                    'create_process' => true,
                        
                    //der Befehl mit welchem der Prozess gestartet wird. Muss uU. angepasst werden
                        
                    'cmd' => 'php '.__DIR__.'/runJob.php'
                    ];

                    $processClass = new process($config);
                    $run true;
                    $start $last_output microtime(true);
                    $status true;
                    while (
                    $run){
                        if(
                    microtime(true)-$last_output >= 1){
                            
                    $last_output microtime(true);
                            
                    $status true;
                        }else
                            
                    $status false;

                        
                    $run $processClass->run($status);
                    }
                    echo 
                    'Total: '.microtime(true)-$start.PHP_EOL;
                    job.php wird in runJob.php und proc.php geladen. Das ist die eigentliche "Fake-Last"
                    ACHTUNG: Um zu testen ob der Job wirklich ausgeführt wird, erstellt die Funktion unter __DIR__/tmp/ für jeden Job eine Datei. Das Verzeichnis /tmp müsste angelegt werden oder die Zeile einfach löschen.
                    PHP-Code:
                    <?php
                    function doJob(string $job):void{
                        for(
                    $x 0$x !== 3000$x++){
                            
                    $hash md5(random_bytes(2048).hash('sha256'bin2hex(random_bytes(4096)).hash('sha512'bin2hex($job))));
                        }
                        
                    file_put_contents(__DIR__.'/tmp/'microtime().'.txt',  $hash);
                    }
                    runJob.php Wenn crate_process = true, wird diese Datei mit proc_open ausgeführt.
                    PHP-Code:
                    <?php
                    require_once __DIR__.'/job.php';
                    $job random_bytes(2048);
                    doJob($job);
                    Unter Windows verhält es sich, wie es soll. Mehr Prozesse = Geringere Laufzeit. Unter Linux jedoch nicht.

                    Windows PHP Version => 8.0.12 - 8 Prozesse: Total: 3.57115483284
                    Debian PHP Version => 8.0.21 - 8 Prozesse: Total: 47.785900115967

                    Windows - 1 Prozess | create_process = false: Total: 20.751991033554
                    Debian - 1 Prozess | create_process = false: Total: 58.229823112488

                    Beide laufen auf der gleichen Hardware (inkl. CPU) mit jeweils 16 Kernen und mind. 8GB Ram

                    Ich habe aktuell die Vermutung, dass es an der CLI-Ausführung liegt.
                    Der Unterschied zwischen dem richtigen Wort und dem beinahe richtigen ist derselbe Unterschied wie zwischen dem Blitz und einem Glühwürmchen.

                    Kommentar


                    • #11
                      Ich weis ja nicht ob deine Medis heute nicht richtig kicken oder ob du einfach eine Persönlichkeit hast, die jegliche Äusserungen von Anderen als Kritik oder Angriff siehst...
                      ich halte nach wir vor für wenig sinning ein systemprogramm zu starten statt eines processes.
                      ich sehe nicht, dass dein process irgenwie oder irgendwo detached und soweit ich weiss, paqssiert dies nicht automatisch.
                      aber dju legst ja kein wert auf meine meinung, sondern diffamierst mich lieber.
                      tgherefore -> ingolist

                      Kommentar


                      • #12
                        Zitat von tomBuilder Beitrag anzeigen

                        ich halte nach wir vor für wenig sinning ein systemprogramm zu starten statt eines prrocesses.
                        Wenn du das auch ordentlich erklärst, dass andere einen Mehrwert aus deinem Beitrag haben, dann kann man auch eine Unterhaltung führen.

                        Welches Systemprogramm wird ausgeführt? Welchen Overhead erzeugt das?

                        Ich bin davon ausgegangen, dass proc_open ein Prozess erzeugt, da das auch so aus der Doku abzuleiten ist.
                        proc_open is similar to popen but provides a much greater degree of control over the program execution.
                        popen — Opens process file pointer

                        PS: Ich stelle Fragen weil ich was lernen möchte, nicht um einfach eine Lösung zu bekommen ohne dabei irgendwas zu lernen.
                        Der Unterschied zwischen dem richtigen Wort und dem beinahe richtigen ist derselbe Unterschied wie zwischen dem Blitz und einem Glühwürmchen.

                        Kommentar


                        • #13
                          soweit ich weiss, startest du eine shell,welches ein komando aufruft (in deinem fall wohl php und das führt eine datei aus...
                          kann mich da irren.

                          nur ein innerhalb eines scriptes zu starten würde ich bspw mit pthreads machen
                          wenn du aber dabei bleibst, wie du es eben machst, dann detach deine shell mit &

                          bspw. hier haben klügre leute als ich über nebläufigkeit gesprochen
                          https://www.php.de/forum/webentwickl...it-auslagerung
                          und das willst du doch nehem ich an.

                          und ja, ich schreib nicht gern viel- ist halt so

                          Kommentar


                          • #14
                            Nach einigen Tagen des Testens habe ich das Problem nun gefunden. Es liegt an random_bytes. Der ursprüngliche Gedanke war, dass die Entropie unter Debian verbraucht ist, was aber laut
                            Code:
                            cat /proc/sys/kernel/random/entropy_avail
                            nicht der Fall war. Die Entropie stieg während der Ausführung sogar an.
                            bin2hex brachte keine Veränderung. Sobald ich aber random_bytes gegen eine eigene Zufalls-String Funktion mit rand getauscht habe, war Debian deutlich schneller als Windows.
                            In Zahlen:
                            100 Jobs - 8 parallele Prozesse - 4.000 Zeichen Länge
                            Windows: 28,57 Sek.
                            Debian: 16,18 Sek.

                            Im Vergleich mit random_bytes:
                            Windows: 7,57Sek.
                            Debian: 106,68 Sek.

                            Mit festem 4k Bytes String:
                            Windows: 6,85 Sek.
                            Debian: 5,64 Sek.
                            Der Unterschied zwischen dem richtigen Wort und dem beinahe richtigen ist derselbe Unterschied wie zwischen dem Blitz und einem Glühwürmchen.

                            Kommentar


                            • #15
                              Zitat von tomBuilder Beitrag anzeigen
                              ...
                              nur ein innerhalb eines scriptes zu starten würde ich bspw mit pthreads machen
                              ...
                              pthreads ist mittlerweile Geschichte, damit kann man nicht mehr wirklich was anstellen. parallel wird auch nicht mehr fortgeführt
                              DevBlog|3D Online-Shopping|Xatrium

                              Kommentar

                              Lädt...
                              X