--- deliantra/server/ext/map-scheduler.ext	2007/07/28 14:32:21	1.40
+++ deliantra/server/ext/map-scheduler.ext	2009/10/23 03:28:11	1.50
@@ -6,93 +6,113 @@
 
 #our $DEACTIVATE_TIMEOUT =   20; # number of seconds after which maps get deactivated to save cpu
 our $SWAP_TIMEOUT       = $cf::CFG{swap_timeout}      || 300; # number of seconds after which inactive maps get swapped out
-our $SCHEDULE_INTERVAL  = $cf::CFG{schedule_interval} ||  .8; # time the map scheduler sleeps between runs
+our $SCHEDULE_INTERVAL  = $cf::CFG{schedule_interval} ||   5; # time the map scheduler sleeps between runs
 our $SAVE_TIMEOUT       = $cf::CFG{save_timeout}      ||  30; # save maps every n seconds
 our $SWAP_LOAD1         = $cf::CFG{swap_load1}        ||  .1; # start aggressively swapping at this load
-our $SWAP_LOAD2         = $cf::CFG{swap_load2}        ||  .4; # swap as fast as possible at this load
+our $SWAP_LOAD2         = $cf::CFG{swap_load2}        ||  .6; # swap as fast as possible at this load
 
-cf::async_ext {
-   $Coro::current->prio (Coro::PRIO_MIN);
+cf::post_init {
+   cf::async_ext {
+      $Coro::current->{desc} = "startup map scanner";
+      $Coro::current->prio (Coro::PRIO_MIN);
+
+      # load the header of swapped-out maps.
+      # this is not a correctness issue, it simply saves diskspace
+      # because old files will get cleaned up on reset time
+      Coro::Timer::sleep 0.25;
 
-   # load the header of swapped-out maps.
-   # this is not a correctness issue, it simply saves diskspace
-   # because old files will get cleaned up on reset time
-   Coro::Timer::sleep 0.25;
-
-   for my $path (@{ cf::map::tmp_maps or [] }, @{ cf::map::random_maps or [] }) {
-      cf::cede_to_tick;
-      cf::map::find $path;
-   }
-
-   # now hunt for resettable per-player maps
-   for my $login (@{ cf::player::list_logins or [] }) {
-      for my $path (@{ cf::player::maps $login or [] }) {
+      for my $path (@{ cf::map::tmp_maps or [] }, @{ cf::map::random_maps or [] }) {
          cf::cede_to_tick;
+         cf::map::find $path;
+      }
+
+      # now hunt for resettable per-player maps
+      for my $login (@{ cf::player::list_logins or [] }) {
+         for my $path (@{ cf::player::maps $login or [] }) {
+            cf::cede_to_tick;
 
-         $path =~ /^~[^\/]+(\/.*)$/
-            or next; # doh
+            $path =~ /^~[^\/]+(\/.*)$/
+               or next; # doh
 
-         my $base = cf::map::find $1;
+            my $base = cf::map::find $1;
 
-         # skip maps without base maps on the assumption
-         # that those are old, unresettable maps
-         next unless $base;
+            # skip maps without base maps on the assumption
+            # that those are old, unresettable maps
+            next unless $base;
 
-         # skip unresettable maps, for speed
-         next if $base->{deny_reset};
+            # skip unresettable maps, for speed
+            next if $base->{deny_reset};
 
-         my $map = cf::map::find $path;
+            my $map = cf::map::find $path;
 
-         if ($map->{deny_reset}) {
-            warn "found noreset map with resettable base map, resetting: $path\n";
-            delete $map->{deny_reset};
+            if ($map->{deny_reset}) {
+               warn "found noreset map with resettable base map, resetting: $path\n";
+               delete $map->{deny_reset};
+            }
          }
       }
-   }
-};
+   };
 
-our $SCHEDULER = cf::async_ext {
-   my $timer = Coro::Event->timer (after => 1);
+   our $SCHEDULER = cf::async_ext {
+      $Coro::current->{desc} = "map scheduler";
+      $Coro::current->prio (Coro::PRIO_MAX);
+
+      while () {
+         if ($cf::LOADAVG > $SWAP_LOAD2) {
+            cf::wait_for_tick;
+         } else {
+            Coro::EV::timer_once $SCHEDULE_INTERVAL;
+         }
 
-   while () {
-      $timer->interval ($SCHEDULE_INTERVAL);
-      $timer->next unless $cf::LOADAVG > $SWAP_LOAD2;
-
-      # this weird form of iteration over values is used because
-      # the hash changes underneath us frequently, and for
-      # keeps a direct reference to the value without (in 5.8 perls)
-      # keeping a reference, so this is prone to crashes or worse.
-      my @maps = keys %cf::MAP;
-      for (@maps) {
-         my $map = $cf::MAP{$_}
-            or next;
-         $map->valid or next;
-
-         eval {
-            # not yet, because maps might become visible to players nearby
-            # we need to remove the map from %cf::MAP and all tiled map links
+         # this weird form of iteration over values is used because
+         # the hash changes underneath us frequently, and for
+         # keeps a direct reference to the value without (in 5.8 perls)
+         # keeping a reference, so this is prone to crashes or worse.
+         my @maps = keys %cf::MAP;
+         for (@maps) {
+            my $map = $cf::MAP{$_}
+               or next;
+            $map->valid or next;
+
+            eval {
+               # not yet, because maps might become visible to players nearby
+               # we need to remove the map from %cf::MAP and all tiled map links
 #         if ($last_access + $DEACTIVATE_TIMEOUT <= $cf::RUNTIME) {
 #            $map->deactivate;
 #            delete $map->{active};
 #         }
-            if ($map->should_reset) {
-               $map->reset;
-            } elsif ($map->in_memory == cf::MAP_IN_MEMORY) {
-               my $max_idle = cf::clamp +(cf::lerp $cf::LOADAVG, $SWAP_LOAD1, $SWAP_LOAD2, $SWAP_TIMEOUT, 0), 0, $SWAP_TIMEOUT;
-
-               if ($map->last_access + $max_idle <= $cf::RUNTIME && !$map->players) {
-                  $map->swap_out;
-               } elsif ($map->{last_save} + $SAVE_TIMEOUT <= $cf::RUNTIME) {
-                  $map->save;
-                  $map->{last_save} -= rand; # randomise map save times a bit
+               if ($map->should_reset) {
+                  $map->reset;
+               } elsif ($map->in_memory == cf::MAP_ACTIVE) {
+                  my $max_idle = cf::clamp +(cf::lerp $cf::LOADAVG, $SWAP_LOAD1, $SWAP_LOAD2, $SWAP_TIMEOUT, $cf::TICK * 1.5),
+                                           $cf::TICK * 1.5, $SWAP_TIMEOUT;
+
+                  if ($map->last_access + $max_idle <= $cf::RUNTIME && !$map->players) {
+                     $map->swap_out;
+                  } elsif ($map->{last_save} + $SAVE_TIMEOUT <= $cf::RUNTIME) {
+                     $map->save;
+                     $map->{last_save} -= rand; # randomise map save times a bit
+                  }
                }
-            }
+            };
+            warn $@ if $@;
+            cf::cede_to_tick;
          };
-         warn $@ if $@;
-         cf::cede_to_tick;
-      };
-   }
+      }
+   };
+
+   $SCHEDULER->prio (-2);
 };
 
-$SCHEDULER->prio (-2);
+# purely for debugging, will load ALL maps
+sub loadall {
+   my $maps = cf::map::static_maps;
+
+   for my $path (@$maps) {
+      my $map = cf::map::find $path
+         or warn "ERROR: unable to find map $path\n";
+      $map->load;
+   }
+}
+