| … | |
… | |
| 7 | use Errno (); |
7 | use Errno (); |
| 8 | use Time::HiRes; |
8 | use Time::HiRes; |
| 9 | use Fcntl; |
9 | use Fcntl; |
| 10 | use IO::AIO; |
10 | use IO::AIO; |
| 11 | |
11 | |
|
|
12 | Event->io (fd => IO::AIO::poll_fileno, |
|
|
13 | poll => 'r', |
|
|
14 | cb => \&IO::AIO::poll_cb); |
|
|
15 | |
| 12 | # find all potential exit paths, this is slow, so this info is cached |
16 | # find all potential exit paths, this is slow, so this info is cached |
| 13 | sub find_exits { |
17 | sub find_exits { |
| 14 | my ($map) = @_; |
18 | my ($map) = @_; |
| 15 | |
19 | |
| 16 | my %exit; |
20 | my %exit; |
| 17 | |
21 | |
|
|
22 | # normal exits |
| 18 | for my $x (0 .. $map->width - 1) { |
23 | for my $x (0 .. $map->width - 1) { |
| 19 | for my $y (0 .. $map->height - 1) { |
24 | for my $y (0 .. $map->height - 1) { |
| 20 | for (grep $_->type == 66, $map->at ($x, $y)) { |
25 | for (grep $_->type == 66, $map->at ($x, $y)) { |
| 21 | my $path = $_->slaying; |
26 | my $path = $_->slaying; |
| 22 | |
27 | |
| 23 | next if 3 > length $path; |
28 | next if 3 > length $path; |
| 24 | |
29 | |
|
|
30 | # TODO: improve unique exit detection etc. |
| 25 | $path = cf::maps_directory cf::path_combine_and_normalize $map->path, $path; |
31 | $exit{cf::maps_directory cf::path_combine_and_normalize $map->path, $path}++; |
| 26 | |
|
|
| 27 | $exit{$path}++; |
|
|
| 28 | } |
32 | } |
| 29 | } |
33 | } |
|
|
34 | } |
|
|
35 | |
|
|
36 | # tiled maps |
|
|
37 | for (0..3) { |
|
|
38 | my $path = $map->tile_path ($_) |
|
|
39 | or next; |
|
|
40 | |
|
|
41 | $exit{cf::maps_directory cf::path_combine_and_normalize $map->path, $path}++; |
| 30 | } |
42 | } |
| 31 | |
43 | |
| 32 | [keys %exit] |
44 | [keys %exit] |
| 33 | } |
45 | } |
| 34 | |
46 | |
| 35 | my %MAP_EXITS; |
47 | my $PREFETCHING; |
|
|
48 | my @PREFETCH; |
| 36 | my %MAP_TIMEOUT; |
49 | my %FILE_TIMEOUT; |
| 37 | |
50 | |
| 38 | sub on_mapenter { |
51 | sub _prefetch; |
| 39 | my ($ob) = @_; |
|
|
| 40 | |
52 | |
| 41 | my $exit = $MAP_EXITS{$ob->map->path} ||= find_exits $ob->map; |
53 | my $empty_cb = sub { }; |
|
|
54 | |
|
|
55 | sub load_file { |
|
|
56 | my ($path, $cb) = @_; |
| 42 | |
57 | |
| 43 | my $NOW = Time::HiRes::time; |
58 | my $NOW = Time::HiRes::time; |
| 44 | |
59 | |
| 45 | for my $path (@$exit) { |
60 | aio_open $path, O_RDONLY, 0, sub { |
| 46 | next if $MAP_TIMEOUT{$path} > $NOW; |
61 | my $fh = shift |
|
|
62 | or return $cb->(), _prefetch; |
| 47 | |
63 | |
| 48 | if (my $map = cf::map::has_been_loaded $path) { |
64 | aio_readahead $fh, 0, -s $fh, sub { |
| 49 | next if $map->in_memory == cf::MAP_IN_MEMORY; |
65 | my $time = Time::HiRes::time - $NOW; |
|
|
66 | warn "LONG PREFETCH $path $time\n" if $time > 0.3; |
| 50 | |
67 | |
|
|
68 | $cb->(), _prefetch; |
|
|
69 | }; |
|
|
70 | }; |
|
|
71 | } |
|
|
72 | |
|
|
73 | sub prefetch($$;$) { |
|
|
74 | my ($type, $path, $cb) = @_; |
|
|
75 | |
|
|
76 | push @PREFETCH, [$type, $path, $cb || $empty_cb]; |
|
|
77 | _prefetch unless $PREFETCHING; |
|
|
78 | } |
|
|
79 | |
|
|
80 | sub _prefetch { |
|
|
81 | $PREFETCHING = 1; |
|
|
82 | |
|
|
83 | while (@PREFETCH) { |
|
|
84 | my ($type, $path, $cb) = @{ shift @PREFETCH }; |
|
|
85 | |
|
|
86 | my $NOW = Time::HiRes::time; |
|
|
87 | $cb->(), next if $FILE_TIMEOUT{$path} > $NOW; |
|
|
88 | $FILE_TIMEOUT{$path} = $NOW + 60 + rand 60; |
|
|
89 | |
|
|
90 | if ($type eq "map") { |
|
|
91 | if (my $map = cf::map::has_been_loaded $path) { |
|
|
92 | $cb->(), next if $map->in_memory == cf::MAP_IN_MEMORY; |
|
|
93 | |
|
|
94 | prefetch file => $map->tmpname |
| 51 | $path = $map->tmppath if $map->in_memory == cf::MAP_SWAPPED; |
95 | if $map->in_memory == cf::MAP_SWAPPED; |
|
|
96 | } |
| 52 | } |
97 | } |
| 53 | |
98 | |
| 54 | $MAP_TIMEOUT{$path} = $NOW + 60 + rand 60; |
99 | load_file $path, $cb; |
|
|
100 | return; |
|
|
101 | } |
| 55 | |
102 | |
| 56 | aio_open $path, O_RDONLY, 0, sub { |
103 | $PREFETCHING = 0; |
| 57 | my ($fh) = @_ |
|
|
| 58 | or return; |
|
|
| 59 | aio_readahead $fh, 0, -s $fh, sub { |
|
|
| 60 | my $time = Time::HiRes::time - $NOW; |
|
|
| 61 | warn "LONG PREFETCH $path $time\n" if $time > 0.15; |
|
|
| 62 | }; |
|
|
| 63 | }; |
|
|
| 64 | } |
|
|
| 65 | } |
104 | } |
| 66 | |
105 | |
| 67 | sub on_clock { |
106 | my %MAP_EXITS; |
| 68 | # boy how I hate polling |
107 | |
| 69 | IO::AIO::poll_cb; |
108 | sub prefetch_map($) { |
|
|
109 | my ($map) = @_; |
|
|
110 | |
|
|
111 | my $exit = $MAP_EXITS{$map->path} ||= find_exits $map; |
|
|
112 | prefetch map => $_ for @$exit; |
|
|
113 | } |
|
|
114 | |
|
|
115 | cf::attach_to_players prio => -900, |
|
|
116 | on_map_change => sub { |
|
|
117 | my ($pl, $new, $x, $x) = @_; |
|
|
118 | |
|
|
119 | prefetch_map $new; |
|
|
120 | }, |
|
|
121 | ; |
|
|
122 | |
|
|
123 | if (0) { #test# |
|
|
124 | # prefetch a few players/second |
|
|
125 | { |
|
|
126 | my @players; |
|
|
127 | |
|
|
128 | Event->timer (interval => 0.2, cb => sub { |
|
|
129 | @players = map $_->ob->name, cf::player::list unless @players; |
|
|
130 | my $player = cf::player::find pop @players |
|
|
131 | or return; |
|
|
132 | |
|
|
133 | if (my $map = $player->ob->map) { |
|
|
134 | prefetch_map $map; |
|
|
135 | } |
|
|
136 | |
|
|
137 | prefetch map => +($player->get_savebed)[0]; |
|
|
138 | }); |
|
|
139 | } |
|
|
140 | |
|
|
141 | # prefetch all .pl files every few minutes (thats only a "few" megabytes) |
|
|
142 | Event->timer (after => 1, interval => 600, cb => sub { |
|
|
143 | my $playerdir = cf::localdir . "/" . cf::playerdir; |
|
|
144 | |
|
|
145 | aio_readdir $playerdir, sub { |
|
|
146 | my ($players) = @_; |
|
|
147 | my $prefetch; $prefetch = sub { |
|
|
148 | my $player = pop @$players |
|
|
149 | or return; |
|
|
150 | |
|
|
151 | load_file "$playerdir/$player/$player.pl", $prefetch; |
|
|
152 | }; |
|
|
153 | |
|
|
154 | $prefetch->(); $prefetch->(); |
|
|
155 | }; |
|
|
156 | }); |
| 70 | } |
157 | } |
| 71 | |
158 | |
| 72 | |
159 | |
|
|
160 | |
