Philipp Hasenfratz: sleep und Timeslice ( => Prozessorauslastung senken )

Hallo

ich muss ein Programm schreiben, welches gewisse Prozesse automatisieren soll. Ich verwende ein ständig laufendes Perl-Daemon-Programm, welches die meiste Zeit "verschläft" (bis es gebraucht wird; periodisch jede Minute). Dieses Schlafen wird durch den sleep-Befehl erreicht.
Aus Performancegründen, möchte ich noch folgende Frage stellen (ich hoffe, dass sie mir jemand beantworten kann).

Wird durch sleep() das Programm eingefrohren für die Anzahl Sekunden, oder findet intern immer noch eine Verarbeitung statt, z. B. in Form einer Schleife, inder die Zeit immer neu eingelesen wird und die Schleife stoppt, wenn die Anzahl Sekunden abgelaufen sind??

Viele Grüsse

Philipp

  1. Hoi,

    Wird durch sleep() das Programm eingefrohren für die Anzahl Sekunden, oder
    findet intern immer noch eine Verarbeitung statt, z. B. in Form einer
    Schleife, inder die Zeit immer neu eingelesen wird und die Schleife stoppt,
    wenn die Anzahl Sekunden abgelaufen sind??

    Das kommt auf das OS an.
    Unter Windows, Linux und einigen anderen Unixen, die ich getestet habe, wird
    die Verarbeitung gestoppt und die Prozessorzeit freigegeben.
    Unter MacOS dagegen ist sleep() von einer While-Schleife nicht zu unterscheiden.

    Gruss,
     CK

    1. Hoi CK

      Wird durch sleep() das Programm eingefrohren für die Anzahl Sekunden, oder
      findet intern immer noch eine Verarbeitung statt, z. B. in Form einer
      Schleife, inder die Zeit immer neu eingelesen wird und die Schleife stoppt,
      wenn die Anzahl Sekunden abgelaufen sind??

      Das kommt auf das OS an.
      Unter Windows, Linux und einigen anderen Unixen, die ich getestet habe, wird
      die Verarbeitung gestoppt und die Prozessorzeit freigegeben.
      Unter MacOS dagegen ist sleep() von einer While-Schleife nicht zu unterscheiden.

      Yep. Genau das, was ich hören wollte ;)
      Ich arbeite auf Win, der Server auf Linux, kein MacOS => Performance ist gesichert. Sehr gut.

      Vielen Dank für die erfreuliche Antwort

      Philipp.

      PS: Wo bleibt die 5-Lines-RSA-Kodierung?

      1. Hoi,

        Ich arbeite auf Win, der Server auf Linux, kein MacOS => Performance
        ist gesichert. Sehr gut.

        Trotzdem solltest du ueberlegen, das OS-Unabhaengig zu machen.

        PS: Wo bleibt die 5-Lines-RSA-Kodierung?

        Die hab ich nur daheim. In der Firma sitze ich an einem Win-Rechner.

        Gruss,
         CK

        1. Ich arbeite auf Win, der Server auf Linux, kein MacOS => Performance
          ist gesichert. Sehr gut.

          Trotzdem solltest du ueberlegen, das OS-Unabhaengig zu machen.

          Funktionieren tut's ja auch auf MacOS, nur eben Performanceverschwendend. Nun, wenn wir mal auf einen MacOS-X Server umsteigen, kann ich es ja noch umprogrammieren. Im Moment habe ich andere Sorgen, als die Performance ;)

          PS: Wo bleibt die 5-Lines-RSA-Kodierung?

          Die hab ich nur daheim. In der Firma sitze ich an einem Win-Rechner.

          Ich dachte an den 5-Linien Perl-Code, der zu den kürzesten RSA-Kodierungen gilt. Ich glaube du warst es, der das hier mal gepostet hast (oder in einem Mail an den Footer gehängt hast)

          --snip--
          s s^s<DATA>se;s (([^\s]))(ord($1)%2?
          chr(ord($1)-5):chr(ord($1)-3))sieg;s s^s$_see;
          __END__
          uwlsy%*Sr%kqdphv%yr%AFN4%dy%zzzyhfm3ihC*1'as'>
          --/snip--

          Gruss

          Philipp

          1. Joho,

            Funktionieren tut's ja auch auf MacOS, nur eben Performanceverschwendend. Nun, wenn wir
            mal auf einen MacOS-X Server umsteigen, kann ich es ja noch umprogrammieren. Im
            Moment habe ich andere Sorgen, als die Performance ;)

            99% CPU-Auslastung hat nichts mehr mit Performance zu tun. In Wahrheit ist das
            schon kriminell: der arme User kriegt nix mehr ab von der CPU.

            Ich dachte an den 5-Linien Perl-Code, der zu den kürzesten RSA-Kodierungen gilt. Ich glaube
            du warst es, der das hier mal gepostet hast (oder in einem Mail an den Footer gehängt hast)

            Ja, ich auch. Auch wenn das nichts mit RSA zu tun hat.

            --snip--
            s s^s<DATA>se;s (([^\s]))(ord($1)%2?
            chr(ord($1)-5):chr(ord($1)-3))sieg;s s^s$_see;
            __END__
            uwlsy%*Sr%kqdphv%yr%AFN4%dy%zzzyhfm3ihC*1'as'>
            --/snip--

            Ja, das ist meine Signatur. Die hab ich in der Firma normal nicht.

            Gruss,
             CK

            s s^s<DATA>se;s (([^\s]))(ord($1)%2?
            chr(ord($1)-5):chr(ord($1)-3))sieg;s s^s$_see;
            __END__
            uwlsy%*Sr%kqdphv%yr%AFN4%dy%zzzyhfm3ihC*1'as'>

            1. Funktionieren tut's ja auch auf MacOS, nur eben Performanceverschwendend. Nun, wenn wir
              mal auf einen MacOS-X Server umsteigen, kann ich es ja noch umprogrammieren. Im
              Moment habe ich andere Sorgen, als die Performance ;)

              99% CPU-Auslastung hat nichts mehr mit Performance zu tun. In Wahrheit ist das
              schon kriminell: der arme User kriegt nix mehr ab von der CPU.

              Klar. Aber dafür sorge ich schon. Aber obs nun 20% oder 30% Auslastung sind, ist mir im Moment nicht so wichtig.

              Ich dachte an den 5-Linien Perl-Code, der zu den kürzesten RSA-Kodierungen gilt. Ich glaube
              du warst es, der das hier mal gepostet hast (oder in einem Mail an den Footer gehängt hast)

              Ja, ich auch. Auch wenn das nichts mit RSA zu tun hat.

              Ach, schade ;) - Dachte schon ich hätte dich durchschaut. Nun, zweiter Vorschlag: lineare Transformation (-5 oder -3), die abhängt, ob der ASCII-Code durch zwei Teilbar ist oder nicht? - Hab nochmals genauer hingeschaut, wie komme ich nur auf RSA? - Aber wie zum Henker werden die Daten ausgegeben? - Das hab ich bis heute nicht geschnallt. ( dieses Script hat meine Aufmerksamkeit und mein Interesse geweckt ;) )

              Viele Grüsse

              Philipp

              1. Joho,

                Ach, schade ;) - Dachte schon ich hätte dich durchschaut. Nun, zweiter Vorschlag: lineare
                Transformation (-5 oder -3), die abhängt, ob der ASCII-Code durch zwei Teilbar ist oder nicht?

                Jepp, sehr einfach.

                • Hab nochmals genauer hingeschaut, wie komme ich nur auf RSA?

                Keine Ahnung ;-) hab ich mich auch gefragt.

                • Aber wie zum Henker werden die Daten ausgegeben? - Das hab ich bis heute nicht geschnallt.

                eigentlich ist das relativ einfach. Ich formatiere es mal etwas anders:

                s s^s<DATA>se;
                s (([^\s]))(ord($1) % 2 ? chr(ord($1)-5) : chr(ord($1)-3))sieg;
                s s^s$_see;
                __END__
                uwlsy%*Sr%kqdphv%yr%AFN4%dy%zzzyhfm3ihC*1'as'>

                s s^s<DATA>se; sollte klar sein, ebenso wie die Zeile darunter. Das interessante ist
                erst s s^s$_see: hier wird ein string evaluiert. Mehr sag ich dazu nicht.

                ( dieses Script hat meine Aufmerksamkeit und mein Interesse geweckt ;) )

                JAPHs sind im allgemeinen sehr cool. Z. B.:

                I, require strict and do(not require warnings); my $answer = $u
                unless $answer == '42'; Question: if(defined by this_paradigm do
                you_do_the_hacker_foo(??)){sub AUTOLOAD{$_=$now=join'the',<DATA>
                ;y?FO?01?; s.o|the| |\n..goe;s/(.{7})/(chr(eval'($u,$ate)=(0,1);
                foreach $foo(reverse split "",$1){$u+=$ate*$foo;$but_I=$ate*=2;}
                $$answer'))/eg;$_= join'',sort/(..)/g and print join'',/.(.)/go;
                $now and exit, do(not die)}}else{goto Question and $answer;y???}
                 __DATA__

                OOFFOOOOOFOO      OFOO       OOFFFOOOFFO    FOOO    FFOO    OFFO
                FFFOOFOOOFOF    OFFFFOOF     OFFFOOFOOOOO   OFOO    FOFO    FFFF
                    FOOO      FOOF    OOFO   FOOO    OFOF   OOOO    FFOF    OOOF
                    OFOF      OOFO    FFFO   OFFF    OOOO   OFFO    OOOF    FFFO
                    OFFO      FOFOOOFFOFFO   FFFFFOOOFOFF   OOFFFFOOOFFO    FFOO
                    OFOF      FOOFFOFOFOFF   FFFOOFFOOFO    FFFFFOOOOFOF    OOOF
                    FFOO      OOOF    FFOO   OFOO           FFOO    OFFF    FOOO
                FF  OFOO      FOOO    OOOF   FOFO           OOFO    OFFO
                OOFFOFOO      FFFO    FOOO   FOFO           OOFO    FFOO    OOFO
                 FFOOOF       OOOO    OFFO   FOOO           OOFF    OFOF    FFFO

                Oder eines von Abigail:

                tie $" => A; $, = " "; $\ = "\n"; @a = ("") x 2; print map {"@a"} 1 .. 4;
                sub A::TIESCALAR {bless \my $A => A} #  Yet Another silly JAPH by Abigail
                sub A::FETCH     {@q = qw /Just Another Perl Hacker/ unless @q; shift @q}

                Oder von Thoren Johne:

                END{tie$@=>X=>and$@=42=>print"$@8#X"}eval(reverse(q?}esrever{HCTEF::A bus
                ;>=101010>>42;}"JAPHn"=_${EROTS::A bus}'A'>=@$\sselb{RALACSEIT::X bus?))

                Oder eins von Andy (IMHO sein genialstes):

                $_=q?tvc!uif)%*|#Bopuifs!A#~tvc!Xibu)%\*|qsjou#Kvtu!A#~tvc!KBQI!)*|~
                tvc!ifmm)%*|#Qfsm!A`#~tvc!jt)%*|(Ibdlfs(~  # What the hell is JAPH? ;
                @_=split/\s\s+#/;$_=(join''=>map{chr(ord(  #            n.d. parker ;
                $_)-1)}split//=>$_[0]).$_[1];s s.*s$_see;  # http://www.o3media.de/ ;

                Naja, es gibt ziemlich viele ;-)

                Gruss,
                 CK

                  • Aber wie zum Henker werden die Daten ausgegeben? - Das hab ich bis heute nicht geschnallt.

                  eigentlich ist das relativ einfach. Ich formatiere es mal etwas anders:

                  so hab ichs auch schon aufgeschlüsselt.

                  s s^s<DATA>se;
                  s (([^\s]))(ord($1) % 2 ? chr(ord($1)-5) : chr(ord($1)-3))sieg;
                  s s^s$_see;
                  __END__
                  uwlsy%*Sr%kqdphv%yr%AFN4%dy%zzzyhfm3ihC*1'as'>

                  s s^s<DATA>se; sollte klar sein, ebenso wie die Zeile darunter. Das interessante ist
                  erst s s^s$_see: hier wird ein string evaluiert. Mehr sag ich dazu nicht.

                  Musst auch nicht. Will dir ja nicht den "Hint" klauen. Zudem, wenn ich auch mal so was mache (was unwahrscheinlich ist), will ich selber was machen und nicht Tricks von anderen stehlen.

                  JAPHs sind im allgemeinen sehr cool. Z. B.:

                  BOW. Faszinierend, wie man alles shortcoden kann. In der Tat sehr cool.

                  Vielen Dank und viele Grüsse

                  Philipp

          2. Hallo,

            Funktionieren tut's ja auch auf MacOS, nur eben Performanceverschwendend. Nun, wenn wir mal auf einen MacOS-X Server umsteigen, kann ich es ja noch umprogrammieren. Im Moment habe ich andere Sorgen, als die Performance ;)

            Allerdings ist MacOS-X auch ein Unix (oder -Derivat?), zumindest vom Kernel her, da sollte es also wieder funktionieren.

            Grüße
              Klaus

  2. ich muss ein Programm schreiben, welches gewisse Prozesse automatisieren
    soll. Ich verwende ein ständig laufendes Perl-Daemon-Programm, welches
    die meiste Zeit "verschläft" (bis es gebraucht wird; periodisch jede
    Minute). Dieses Schlafen wird durch den sleep-Befehl erreicht.

    http://www.cpan.org/modules/by-module/Schedule/Schedule-Cron-0.01.readme ?

    1. http://www.cpan.org/modules/by-module/Schedule/Schedule-Cron-0.01.readme ?

      Oh, sehr interessant. Aber hast du gesehen -> Shedule::Cron arbeitet mit fork um Subprozesse zu erstellen. Die werden sich wohl die selbe Frage gestellt haben wie ich, gleibt nur noch aus, ob sie das ganze auch mit sleep() gemacht haben.
      Nun, ich bleibe bei meinem Programm ( mache am liebsten alles selber, statt irgendwelche Module zu verwenden, indie ich mich erst einarbeiten muss; gut, dieses ist wohl ziemlich einfach ). Aber man weiss nie, vielleicht brauche ich es mal ;)

      Viele Grüsse

      Philipp