[ViewVC] Diff of: cvs/deliantra/server/lib/cf.pm

Comparing deliantra/server/lib/cf.pm (file contents):
Revision 1.395 by root, Sat Nov 10 22:41:59 2007 UTC vs.
Revision 1.398 by root, Wed Dec 5 11:08:34 2007 UTC

 use strict;
 use Symbol;
 use List::Util;
 use Socket;
-use Event;
+use EV;
 use Opcode;
 use Safe;
 use Safe::Hole;
 use Storable ();
 use Coro 4.1 ();
 use Coro::State;
 use Coro::Handle;
-use Coro::Event;
+use Coro::EV;
 use Coro::Timer;
 use Coro::Signal;
 use Coro::Semaphore;
 use Coro::AIO;
 use Coro::Storable;
 use Coro::Util ();
-use JSON::XS ();
+use JSON::XS 2.01 ();
 use BDB ();
 use Data::Dumper;
 use Digest::MD5;
 use Fcntl;
 use YAML::Syck ();
 # configure various modules to our taste
 #
 $Storable::canonical = 1; # reduce rsync transfers
 Coro::State::cctx_stacksize 256000; # 1-2MB stack, for deep recursions in maze generator
 Compress::LZF::sfreeze_cr { }; # prime Compress::LZF so it does not use require later
-$Event::Eval = 1; # no idea why this is required, but it is
 # work around bug in YAML::Syck - bad news for perl6, will it be as broken wrt. unicode?
 $YAML::Syck::ImplicitUnicode = 1;
 $Coro::main->prio (Coro::PRIO_MAX); # run main coroutine ("the server") with very high priority
 )) {
    no strict 'refs';
    @{"safe::$pkg\::wrap::ISA"} = @{"$pkg\::wrap::ISA"} = $pkg;
 }
-$Event::DIED = sub {
+$EV::DIED = sub {
    warn "error in event callback: @_";
 };
 #############################################################################
       $d =~ s/([\x00-\x07\x09\x0b\x0c\x0e-\x1f])/sprintf "\\x%02x", ord($1)/ge;
       $d
    } || "[unable to dump $_[0]: '$@']";
 }
-=item $ref = cf::from_json $json
+=item $ref = cf::decode_json $json
 Converts a JSON string into the corresponding perl data structure.
-=item $json = cf::to_json $ref
+=item $json = cf::encode_json $ref
 Converts a perl data structure into its JSON representation.
 =cut
 our $json_coder = JSON::XS->new->utf8->max_size (1e6); # accept ~1mb max
-sub to_json   ($) { $json_coder->encode ($_[0]) }
+sub encode_json($) { $json_coder->encode ($_[0]) }
-sub from_json ($) { $json_coder->decode ($_[0]) }
+sub decode_json($) { $json_coder->decode ($_[0]) }
 =item cf::lock_wait $string
 Wait until the given lock is available. See cf::lock_acquire.
    my $guard = Coro::guard {
       $TICK_WATCHER->start;
    };
    $TICK_WATCHER->stop;
    $guard
+}
+=item cf::periodic $interval, $cb
+Like EV::periodic, but randomly selects a starting point so that the actions
+get spread over timer.
+=cut
+sub periodic($$) {
+   my ($interval, $cb) = @_;
+   my $start = rand List::Util::min 180, $interval;
+   EV::periodic $start, $interval, 0, $cb
 }
 =item cf::get_slot $time[, $priority[, $name]]
 Allocate $time seconds of blocking CPU time at priority C<$priority>:
 sub sync_job(&) {
    my ($job) = @_;
    if ($Coro::current == $Coro::main) {
-      my $time = Event::time;
+      my $time = EV::time;
       # this is the main coro, too bad, we have to block
       # till the operation succeeds, freezing the server :/
       LOG llevError, Carp::longmess "sync job";#d#
       while ($busy) {
          if (Coro::nready) {
             Coro::cede_notself;
          } else {
-            Event::one_event;
+            EV::loop EV::LOOP_ONESHOT;
          }
       }
-      $time = Event::time - $time;
+      $time = EV::time - $time;
       LOG llevError | logBacktrace, Carp::longmess "long sync job"
          if $time > $TICK * 0.5 && $TICK_WATCHER->is_active;
       $tick_start += $time; # do not account sync jobs to server load
 =item fork_call { }, $args
 Executes the given code block with the given arguments in a seperate
 process, returning the results. Everything must be serialisable with
 Coro::Storable. May, of course, block. Note that the executed sub may
-never block itself or use any form of Event handling.
+never block itself or use any form of event handling.
 =cut
 sub fork_call(&@) {
    my ($cb, @args) = @_;
 cf::attachable->attach (
    prio           => -1000000,
    on_instantiate => sub {
       my ($obj, $data) = @_;
-      $data = from_json $data;
+      $data = decode_json $data;
       for (@$data) {
          my ($name, $args) = @$_;
          $obj->attach ($name, %{$args || {} });
       $rmp->{origin_y}   = $exit->y;
    }
    $rmp->{random_seed} ||= $exit->random_seed;
-   my $data = cf::to_json $rmp;
+   my $data = cf::encode_json $rmp;
    my $md5 = Digest::MD5::md5_hex $data;
    my $meta = "$RANDOMDIR/$md5.meta";
    if (my $fh = aio_open "$meta~", O_WRONLY | O_CREAT, 0666) {
       aio_write $fh, 0, (length $data), $data, 0;
    # we must not ever block the main coroutine
    local $Coro::idle = sub {
       Carp::cluck "FATAL: Coro::idle was called, major BUG, use cf::sync_job!\n";#d#
       (async {
          $Coro::current->{desc} = "IDLE BUG HANDLER";
-         Event::one_event;
+         EV::loop EV::LOOP_ONESHOT;
       })->prio (Coro::PRIO_MAX);
    };
    reload_config;
    db_init;
    load_extensions;
    $TICK_WATCHER->start;
+   $Coro::current->prio (Coro::PRIO_MAX); # give the main loop max. priority
-   Event::loop;
+   EV::loop;
 }
 #############################################################################
 # initialisation and cleanup
 # install some emergency cleanup handlers
 BEGIN {
+   our %SIGWATCHER = ();
    for my $signal (qw(INT HUP TERM)) {
-      Event->signal (
+      $SIGWATCHER{$signal} = EV::signal $signal, sub {
-         reentrant => 0,
-         data      => WF_AUTOCANCEL,
-         signal    => $signal,
-         prio      => 0,
-         cb        => sub {
-            cf::cleanup "SIG$signal";
+         cf::cleanup "SIG$signal";
-         },
-      );
+      };
    }
 }
 sub write_runtime {
    my $runtime = "$LOCALDIR/runtime";
       warn "syncing database to disk";
       BDB::db_env_txn_checkpoint $DB_ENV;
       # if anything goes wrong in here, we should simply crash as we already saved
-      warn "cancelling all WF_AUTOCANCEL watchers";
-      for (Event::all_watchers) {
-         $_->cancel if $_->data & WF_AUTOCANCEL;
-      }
       warn "flushing outstanding aio requests";
       for (;;) {
          BDB::flush;
          IO::AIO::flush;
          Coro::cede_notself;
 sub reload_perl() {
    # doing reload synchronously and two reloads happen back-to-back,
    # coro crashes during coro_state_free->destroy here.
-   $RELOAD_WATCHER ||= Event->timer (
+   $RELOAD_WATCHER ||= EV::timer 0, 0, sub {
-      reentrant => 0,
-      after     => 0,
-      data      => WF_AUTOCANCEL,
-      cb => sub {
-         do_reload_perl;
-         undef $RELOAD_WATCHER;
+      undef $RELOAD_WATCHER;
-      },
+      do_reload_perl;
-   );
+   };
 }
 register_command "reload" => sub {
    my ($who, $arg) = @_;
    my $signal = new Coro::Signal;
    push @WAIT_FOR_TICK_BEGIN, $signal;
    $signal->wait;
 }
-$TICK_WATCHER = Event->timer (
+$TICK_WATCHER = EV::periodic_ns 0, $TICK, 0, sub {
-   reentrant => 0,
-   parked    => 1,
-   prio      => 0,
-   at        => $NEXT_TICK || $TICK,
-   data      => WF_AUTOCANCEL,
-   cb        => sub {
-      if ($Coro::current != $Coro::main) {
+   if ($Coro::current != $Coro::main) {
-         Carp::cluck "major BUG: server tick called outside of main coro, skipping it"
+      Carp::cluck "major BUG: server tick called outside of main coro, skipping it"
-            unless ++$bug_warning > 10;
+         unless ++$bug_warning > 10;
-         return;
+      return;
-      }
+   }
-      $NOW = $tick_start = Event::time;
+   $NOW = $tick_start = EV::now;
-      cf::server_tick; # one server iteration
+   cf::server_tick; # one server iteration
-      $RUNTIME   += $TICK;
+   $RUNTIME   += $TICK;
-      $NEXT_TICK += $TICK;
+   $NEXT_TICK += $TICK;
-      if ($NOW >= $NEXT_RUNTIME_WRITE) {
+   if ($NOW >= $NEXT_RUNTIME_WRITE) {
-         $NEXT_RUNTIME_WRITE = $NOW + 10;
+      $NEXT_RUNTIME_WRITE = $NOW + 10;
-         Coro::async_pool {
+      Coro::async_pool {
-            $Coro::current->{desc} = "runtime saver";
+         $Coro::current->{desc} = "runtime saver";
-            write_runtime
+         write_runtime
-               or warn "ERROR: unable to write runtime file: $!";
+            or warn "ERROR: unable to write runtime file: $!";
-         };
-      }
+      };
+   }
-      if (my $sig = shift @WAIT_FOR_TICK_BEGIN) {
+   if (my $sig = shift @WAIT_FOR_TICK_BEGIN) {
-         $sig->send;
+      $sig->send;
-      }
+   }
-      while (my $sig = shift @WAIT_FOR_TICK) {
+   while (my $sig = shift @WAIT_FOR_TICK) {
-         $sig->send;
+      $sig->send;
-      }
+   }
-      $NOW = Event::time;
-      # if we are delayed by four ticks or more, skip them all
-      $NEXT_TICK = $NOW if $NOW >= $NEXT_TICK + $TICK * 4;
-      $TICK_WATCHER->at ($NEXT_TICK);
-      $TICK_WATCHER->start;
-      $LOAD = ($NOW - $tick_start) / $TICK;
+   $LOAD = ($NOW - $tick_start) / $TICK;
-      $LOADAVG = $LOADAVG * 0.75 + $LOAD * 0.25;
+   $LOADAVG = $LOADAVG * 0.75 + $LOAD * 0.25;
-      _post_tick;
+   _post_tick;
-   },
+};
-);
+$TICK_WATCHER->priority (EV::MAXPRI);
 {
    BDB::min_parallel 8;
    BDB::max_poll_time $TICK * 0.1;
-   $BDB_POLL_WATCHER = Event->io (
+   $BDB_POLL_WATCHER = EV::io BDB::poll_fileno, EV::READ, \&BDB::poll_cb;
-      reentrant => 0,
-      fd        => BDB::poll_fileno,
-      poll      => 'r',
-      prio      => 0,
-      data      => WF_AUTOCANCEL,
-      cb        => \&BDB::poll_cb,
-   );
    BDB::set_sync_prepare {
       my $status;
       my $current = $Coro::current;
       (
          cf::cleanup "db_env_open(db): $@" if $@;
       };
    }
-   $BDB_DEADLOCK_WATCHER = Event->timer (
+   $BDB_DEADLOCK_WATCHER = EV::periodic 0, 3, 0, sub {
-      after     => 3,
-      interval  => 1,
-      hard      => 1,
-      prio      => 0,
-      data      => WF_AUTOCANCEL,
-      cb        => sub {
-         BDB::db_env_lock_detect $DB_ENV, 0, BDB::LOCK_DEFAULT, 0, sub { };
+      BDB::db_env_lock_detect $DB_ENV, 0, BDB::LOCK_DEFAULT, 0, sub { };
-      },
-   );
+   };
-   $BDB_CHECKPOINT_WATCHER = Event->timer (
+   $BDB_CHECKPOINT_WATCHER = EV::periodic 0, 60, 0, sub {
-      after     => 11,
-      interval  => 60,
-      hard      => 1,
-      prio      => 0,
-      data      => WF_AUTOCANCEL,
-      cb        => sub {
-         BDB::db_env_txn_checkpoint $DB_ENV, 0, 0, 0, sub { };
+      BDB::db_env_txn_checkpoint $DB_ENV, 0, 0, 0, sub { };
-      },
-   );
+   };
-   $BDB_TRICKLE_WATCHER = Event->timer (
+   $BDB_TRICKLE_WATCHER = EV::periodic 0, 10, 0, sub {
-      after     => 5,
-      interval  => 10,
-      hard      => 1,
-      prio      => 0,
-      data      => WF_AUTOCANCEL,
-      cb        => sub {
-         BDB::db_env_memp_trickle $DB_ENV, 20, 0, sub { };
+      BDB::db_env_memp_trickle $DB_ENV, 20, 0, sub { };
-      },
-   );
+   };
 }
 {
    IO::AIO::min_parallel 8;
    undef $Coro::AIO::WATCHER;
    IO::AIO::max_poll_time $TICK * 0.1;
-   $AIO_POLL_WATCHER = Event->io (
+   $AIO_POLL_WATCHER = EV::io IO::AIO::poll_fileno, EV::READ, \&IO::AIO::poll_cb;
-      reentrant => 0,
-      data      => WF_AUTOCANCEL,
-      fd        => IO::AIO::poll_fileno,
-      poll      => 'r',
-      prio      => 0,
-      cb        => \&IO::AIO::poll_cb,
-   );
 }
 my $_log_backtrace;
 sub _log_backtrace {

Diff Legend

-–
+Removed lines
-+
+Added lines
-<
+Changed lines
->
+Changed lines

Comparing deliantra/server/lib/cf.pm (file contents): Revision 1.395 by root, Sat Nov 10 22:41:59 2007 UTC vs. Revision 1.398 by root, Wed Dec 5 11:08:34 2007 UTC

Diff Legend

Comparing deliantra/server/lib/cf.pm (file contents):
Revision 1.395 by root, Sat Nov 10 22:41:59 2007 UTC vs.
Revision 1.398 by root, Wed Dec 5 11:08:34 2007 UTC