--- deliantra/server/ext/map-scheduler.ext	2007/01/01 12:28:46	1.2
+++ deliantra/server/ext/map-scheduler.ext	2008/09/23 04:29:11	1.48
@@ -1,46 +1,107 @@
-#! perl
+#! perl # mandatory
 
 # this extension swaps out maps and resets them, in essence managing
 # the reset/swap policy of the server.
+# it also contains the map prefetching logic
 
-our $DEACTIVATE_TIMEOUT =   60; # number of seconds after which maps get deactivated to save cpu
-our $SWAP_TIMEOUT       =  600; # number of seconds after which maps inactive get swapped out
-our $SCHEDULE_INTERVAL  =    8; # time the map scheduler sleeps between runs
-our $SAVE_TIMEOUT       =   60; # save maps every n seconds
-our $SAVE_INTERVAL      =  0.4; # save at max. one map every $SAVE_HOLD
-
-$DEACTIVATE_TIMEOUT = 3;#d#
-$SWAP_TIMEOUT = 5;#d#
-$SCHEDULE_INTERVAL = 1;
-
-our $SCHEDULER = cf::coro {
-   while () {
-      Coro::Timer::sleep $SCHEDULE_INTERVAL;
-
-      for my $map (values %cf::MAP) {
-         eval {
-            next if $map->players;
-            my $last_access = $map->last_access;
-            # not yet, because maps might become visible to players nearby
-            # we need a tiled meta map for this to work
+#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} ||   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}        ||  .6; # swap as fast as possible at this load
+
+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;
+
+      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
+
+            my $base = cf::map::find $1;
+
+            # 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};
+
+            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};
+            }
+         }
+      }
+   };
+
+   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;
+         }
+
+         # 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 ($last_access + $SWAP_TIMEOUT <= $cf::RUNTIME) {
-               $map->swap_out;
-               Coro::Timer::sleep $SAVE_INTERVAL;
-            } elsif ($map->{last_save} + $SAVE_TIMEOUT <= $cf::RUNTIME) {
-               $map->save;
-               Coro::Timer::sleep $SAVE_INTERVAL;
-            }
+               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 $@;
-         Coro::cede;
       }
-   }
+   };
+
+   $SCHEDULER->prio (-2);
 };
-$SCHEDULER->prio (-2);
+