source: soft/build_system/build_system/mkcd/tags/V3_8_6_1mdk/pm/Mkcd/Optimize.pm @ 1

Last change on this file since 1 was 1, checked in by fasma, 12 years ago

Initial Import from Mandriva's soft revision 224062 and package revision 45733

File size: 26.4 KB
Line 
1package Mkcd::Optimize;
2
3my $VERSION = '0.0.2';
4
5use strict;
6use Mkcd::Tools qw(log_);
7our @ISA = qw(Exporter);
8our @EXPORT = qw(optimize_space get_pkgs_deps print_conflict_matrix );
9
10sub optimize_space {
11    my ($config, $groups, $diff, $size, $cdsize, $cdnum, $gain, $cdlists, $special, $grp, $list, $type, $all_rpmsize) = @_;
12    $config->{optimize_space} or return 0;
13    log_("optimize_space: cdnum $cdnum gain $gain cdlists $cdlists grp $grp list $list\n", $config->{verbose}, $config->{LOG}, 4);
14    my @cd_to_test;
15    if (!$special) {
16        if (defined $size->{optimize_space}{disc}{$cdnum} && $gain > $size->{optimize_space}{disc}{$cdnum}) {
17            log_("WARNING optimize_space: last time only get $size->{optimize_space}{disc}{$cdnum} on disc $cdnum, does not try again\n", $config->{verbose}, $config->{LOG}, 4);
18            return 0 
19        }
20        log_("optimize_space: previously manage to gain $size->{optimize_space}{disc}{$cdnum} on disc $cdnum\n", $config->{verbose}, $config->{LOG}, 2) if defined $size->{optimize_space}{disc}{$cdnum};
21        my $maxSpace; 
22        for (my $i; $i < @$cdsize; $i++) {
23            $cdlists->{$i} or next;
24            $groups->[$grp]{disc_impacted}{$i} or next;
25            my $space = $cdsize->[$i] - $size->{disc}[$i];
26            push @cd_to_test, [ $i, $space ];
27            $maxSpace += $space
28        }
29        $maxSpace -= $all_rpmsize;
30        if ($maxSpace < $gain) { log_("WARNING optimize_space: could not get $gain on disc $cdnum (only $maxSpace available)\n", $config->{verbose}, $config->{LOG}, 4); return 0 }
31        else { log_("optimize_space: $maxSpace available, try to move packages to get $gain free space on disc $cdnum\n", $config->{verbose}, $config->{LOG}, 4) }
32    }
33    my $realgain = 0;
34    my @cd_sorted = sort { $b->[1] <=> $a->[1] } @cd_to_test;
35    my ($local_diff, $local_size, $local_done, @to_reject);
36    my $check_diff_deps = sub {
37        my ($rpms, $deps_rpms, $rep_num, $g) = @_;
38        my @rpmsd;
39        log_("optimize_space check_diff_deps\n", $config->{verbose}, $config->{LOG}, 4);
40        foreach (@$deps_rpms) { push @rpmsd, @{$_->[6]} if $_->[6] }
41        my $deps = get_pkgs_deps(\@rpmsd, $groups->[$g]);
42        my %deps;
43        foreach my $d_ids (@$deps) { if (ref $d_ids) { foreach (@$d_ids) { $deps{alt}{$_} = $d_ids } } else { $deps{std}{$_} = 1 } }
44        foreach my $d (@$rpms) {
45            # log_("optimize_space check_diff_deps: data $d\n", $config->{verbose}, $config->{LOG});
46            foreach my $data (@{$d->[5]}) {
47                my $rpm = $data->[0];
48                # log_("optimize_space check_diff_deps: $rpm ($groups->[$g]{urpm}{rpm}{$rpm})\n", $config->{verbose}, $config->{LOG});
49                my $id = $groups->[$g]{urpm}{rpm}{$rpm}->id;
50                if ($deps{std}{$id}) {
51                    log_("optimize_space check_diff_deps: $rpm depends on these packages\n", $config->{verbose}, $config->{LOG}, 5);
52                    return 0
53                } elsif ($deps{alt}{$id}) {
54                    log_("optimize_space check_diff_deps: $rpm depends on these packages as alternatives, trying to find another alternative\n", $config->{verbose}, $config->{LOG}, 5);
55                    my $n_pres = 1;
56                    foreach (@{$deps{alt}{$id}}) {
57                        my $alt_rpm = $groups->[$g]{depslistid}[$_];
58                        if ($local_done->[$g]{rep}{$alt_rpm} <= $rep_num) {
59                            $n_pres = 0
60                        }
61                    }
62                    return 0 if $n_pres
63                }
64            }
65        }
66        1
67    };
68    my $check_previous_deps = sub {
69        my ($rpms1, $rpms2, $g, $src_rep, $dest_rep) = @_;
70        log_("optimize_space check_previous_deps: rpms1 $rpms1 rpms2 $rpms2 g $g src_rep $src_rep dest_rep $dest_rep\n", $config->{verbose}, $config->{LOG}, 6);
71        my ($src, $dest);
72        if ($src_rep > $dest_rep) {
73            $src = $src_rep;
74            $dest = $dest_rep;
75        } elsif ($src_rep < $dest_rep) {
76            $dest = $src_rep;
77            $src = $dest_rep;
78        } else {
79            return 1;
80        }
81        if ($src > $dest + 1) {
82            foreach my $rep ($dest+1 .. $src-1) {
83                foreach (@{$local_diff->{idx}}) {
84                    my $d = $local_diff->{data}[$_];
85                    push @$rpms1, $d if $d->[3] == $rep
86                }
87            }
88        }
89        return $check_diff_deps->($rpms2, $rpms1, $dest, $g);
90    };
91    my $exchange = sub {
92        my ($elt, $src_cd, $src_rep, $cd, $rep, $dest_curdir, $idx, $tot_size, $group, $l) = @_;
93        my $rpms;
94        foreach (@{$elt->[5]}) { 
95            $local_done->[$group]{list}{$_->[0]} = $l; 
96            $local_done->[$group]{rep}{$_->[0]} = $rep; 
97            $rpms .= " $_->[0]" 
98        }
99        log_("optimize_space exchange: moving $rpms (grp $group list $l) from disc $src_cd rep $src_rep to disc $cd rep $rep\n", $config->{verbose}, $config->{LOG}, 5);
100        # TODO data is not duplicated, must check to see if this is a pb
101        my @new_elt = @$elt;
102        $new_elt[0] = $dest_curdir;
103        $new_elt[3] = $rep;
104        my $b_idx = push @{$local_diff->{data}}, \@new_elt;
105        $local_diff->{idx}[$idx] = $b_idx-1;
106        $local_size->{disc}[$src_cd] -= $tot_size;
107        my $src_repname = $groups->[$group]{replist}{srpm}[$src_rep-1][1];
108        $local_size->{rep}{$src_cd}{$src_repname}{$l} -= $tot_size;
109        $local_size->{disc}[$cd] += $tot_size;
110        my $dest_repname = $groups->[$group]{replist}{srpm}[$rep-1][1];
111        $local_size->{rep}{$cd}{$dest_repname}{$l} += $tot_size;
112        log_("optimize_space exchange: moving $rpms (grp $group list $l) from disc $src_cd rep $src_rep (size $local_size->{disc}[$src_cd]) to disc $cd rep $rep (size $local_size->{disc}[$cd])\n", $config->{verbose}, $config->{LOG}, 5);
113        if ($src_cd == $cdnum) {
114            $realgain += $tot_size;
115            log_("optimize_space exchange: current gain $realgain\n", $config->{verbose}, $config->{LOG}, 5);
116            if ($realgain > $gain) { goto optimize_space_ok }
117        } elsif ($cd == $cdnum) {
118            $realgain -= $tot_size;
119            log_("optimize_space exchange: current gain $realgain\n", $config->{verbose}, $config->{LOG}, 5);
120        }
121        1
122    };
123    my $delete = sub {
124        my ($elt, $src_cd, $src_rep, $idx, $tot_size, $group, $l) = @_;
125        my $rpms;
126        # FIXME must test no_src_fit mod
127        foreach (@{$elt->[5]}) { 
128            $local_done->[$group]{rep}{$_->[0]} = 0; 
129            $local_done->[$group]{list}{$_->[0]} = 0; 
130            $to_reject[$group]{$_->[0]}{no_space} = 1;
131            $rpms .= " $_->[0]" }
132        # remove entry
133        for (my $i = $idx; $i < @{$local_diff->{idx}} - 1; $i++) {
134            $local_diff->{idx}[$i] = $local_diff->{idx}[$i+1];
135        }
136        pop @{$local_diff->{idx}};
137        log_("optimize_space delete: new diff size " . (int @{$local_diff->{idx}}) . "\n", $config->{verbose}, $config->{LOG});
138        $local_size->{disc}[$src_cd] -= $tot_size;
139        log_("optimize_space delete: deleting idx $idx packages $rpms (grp $group list $l) from disc $src_cd rep $src_rep (disc $src_cd size $local_size->{disc}[$src_cd])\n", $config->{verbose}, $config->{LOG});
140        my $src_repname = $groups->[$group]{replist}{srpm}[$src_rep-1][1];
141        $local_size->{rep}{$src_cd}{$src_repname}{$l} -= $tot_size;
142        if ($src_cd == $cdnum) {
143            $realgain += $tot_size;
144            log_("optimize_space delete: current gain $realgain\n", $config->{verbose}, $config->{LOG}, 5);
145            if ($realgain > $gain) { goto optimize_space_ok }
146        }
147        1
148    };
149    my $delete_and_check = sub {
150        my ($to_del_d, $i, $type, $prev) = @_;
151        my ($group, $list) = ($to_del_d->[1], $to_del_d->[2]);
152        my ($dn, $needed);
153        my @pkg_to_del;
154        my ($bin_d, $j, $bin_dcd, $bin_d_curdir, $bin_drepnum, $bin_dsize);
155        for ($j = $i; $j >= 0; $j--) {
156            $bin_d = $local_diff->{data}[$local_diff->{idx}[$j]];
157            ($bin_d_curdir, undef, undef, $bin_drepnum) = @$bin_d;
158            ($bin_dcd) = @$bin_d_curdir;
159            $bin_dsize = $bin_d->[7];
160            ($bin_d->[4] == 1 || $config->{nosrcfit} || $config->{nosrc} || $groups->[$group]{options}{nosrcfit}) and last;
161            my $bin_srpms;
162            foreach (@{$bin_d->[5]}) { $bin_srpms .= " $_->[0]" }
163            log_("optimize_space delete_and_check: strict source mode, deleting also srpms $bin_srpms associated from disc $bin_dcd\n", $config->{verbose}, $config->{LOG}, 5);
164            push @pkg_to_del, [$bin_d, $bin_dcd, $bin_drepnum, $j, $bin_dsize, $bin_d->[1], $bin_d->[2]]
165        }
166        log_("optimize_space delete_and_check: deleting rpms from disc $bin_dcd\n", $config->{verbose}, $config->{LOG}, 5);
167        push @pkg_to_del, [$bin_d, $bin_dcd, $bin_drepnum, $j, $bin_dsize, $bin_d->[1], $bin_d->[2]];
168
169        my $ok = 1;
170        foreach my $pkg (@pkg_to_del) {
171            my ($d, $dcd, $drepnum, $i, $dsize, $g, $l) = @$pkg;
172            if ($d->[1] != $group || $d->[2] != $list) {
173                log_("ERROR optimize_space delete_and_check: this must not happen, in strict source mode sources must follow rpms in diff indexes (group $bin_d->[1] list $bin_d->[1] instead of group $g list $l)\n", $config->{verbose}, $config->{LOG}, 4);
174                $ok = 0;
175            }
176            if ($d->[4] == 1) {
177                foreach (@{$d->[5]}) {
178                    if ($_->[2][1]{force} || $_->[2][1]{needed} || $_->[2][1]{done}) {
179                        $needed = 1;
180                        log_("optimize_space delete_and_check: could not delete $_->[0] needed $_->[2][1]{needed} ($drepnum)\n", $config->{verbose}, $config->{LOG}, 5);
181                        last
182                    }
183                }
184                if ($needed || @$prev && !$check_diff_deps->($prev, [$d], $drepnum, $g)) {
185                    push @$prev, $d;
186                    $ok = 0;
187                }
188            }
189        }
190        my $mid = @pkg_to_del;
191        if ($ok) {
192            foreach my $pkg (@pkg_to_del) {
193                my ($d, $dcd, $drepnum, $i, $dsize, $g, $l) = @$pkg;
194                $delete->($d, $dcd, $drepnum, $i, $dsize, $g, $l);
195            }
196            return $mid, $mid
197        }
198        return 0, $mid
199    };
200
201    my $move_bin = sub {
202            my ($g, $l, $special, $reverse) = @_;
203            $special && $reverse and return 0;
204            my @test;
205            my @ordered_bin_list_rep = sort { $reverse ? $a->[2] <=> $b->[2] : $b->[2] <=> $a->[2] } grep { $_->[3]{$l} } @{$groups->[$g]{replist}{rpm}};
206        my $dn;
207        my $pdn = -1;
208        my $spec = $special;
209        log_("optimize_space: moving binaries from group $g list $l (reverse $reverse)\n", $config->{verbose}, $config->{LOG}, 5);
210        while ($dn > $pdn) {
211            move_bin_while:
212            $pdn = $dn;
213            for (my $bin_idx; $bin_idx < $#ordered_bin_list_rep; $bin_idx++) {
214                my @bin_r = @{$ordered_bin_list_rep[$bin_idx]};
215                my @src_bin_r = @{$ordered_bin_list_rep[$bin_idx+1]};
216
217                my ($bin_cd, undef, $bin_num, $hashlist) = @bin_r;
218                next if $bin_cd == $cdnum;
219                my ($src_bin_cd, undef, $src_bin_num) = @src_bin_r;
220                my @next_src_bin_r;
221                my ($next_src_bin_cd, $next_src_bin_num);
222                if ($bin_idx+2 < @ordered_bin_list_rep) {
223                    @next_src_bin_r = @{$ordered_bin_list_rep[$bin_idx+2]};
224                    ($next_src_bin_cd, undef, $next_src_bin_num) = @src_bin_r;
225                }
226                next if $bin_cd == $src_bin_cd;
227                my $end;
228                log_("optimize_space: try to move binaries from disc $src_bin_cd rep $src_bin_num to disc $bin_cd rep $bin_num (spec $spec)\n", $config->{verbose}, $config->{LOG}, 5);
229                my ($a, $b, $c) = $reverse ? (0, @{$local_diff->{idx}},1) : ($#{$local_diff->{idx}},0, -1);
230                my $next_first_size;
231                if (!$spec && $next_src_bin_num) {
232                    my $next_d;
233                    my $next_idx;
234                    for ($next_idx = $a; $c*$next_idx <= $b; $next_idx += $c) {
235                        $next_d = $local_diff->{data}[$local_diff->{idx}[$next_idx]];
236                        ($next_d->[1] == $g && $next_d->[2] == $l && $next_d->[4] == 1 && $next_d->[3] == $next_src_bin_num) and last;
237                    }
238                    $next_first_size = $next_d->[7];
239                    log_("optimize_space: next to move will be id $next_idx size $next_first_size on disc $next_src_bin_cd rep $next_src_bin_num\n", $config->{verbose}, $config->{LOG}, 5);
240                    my $cd_space;
241                    if ($next_d->[0][2]{limit}) {
242                        log_("optimize_space: rep limit mode for srpm rep $src_bin_cd/$src_bin_num\n", $config->{verbose}, $config->{LOG}, 6);
243                        $cd_space = $next_d->[0][2]{limit}{size} - $local_size->{rep}{$src_bin_cd}{$next_d->[0][1]}{$l}
244                    } else {
245                        $cd_space = $cdsize->[$src_bin_cd] - $local_size->{disc}[$src_bin_cd]
246                    }
247                    if ($next_first_size < $cd_space) {
248                        log_("optimize_space: no need to move from disc $src_bin_cd rep $src_bin_num, trying next\n", $config->{verbose}, $config->{LOG}, 5);
249                        next
250                    }
251                }
252                my (@previous, $check, $d);
253                my $rep_diff = abs($src_bin_num - $bin_num);
254                foreach my $mode (0,1) {
255                    for (my $idx = $a; $c*$idx <= $b; $idx += $c) {
256                        my $d = $local_diff->{data}[$local_diff->{idx}[$idx]];
257                        ($d->[1] == $g && $d->[2] == $l && $d->[4] == 1 && $d->[3] == $src_bin_num) or next;
258                        my $curdir = $d->[0];
259                        my $first_size = $d->[7];
260                        if ($spec) {
261                            log_("optimize_space: try to delete rpms in rep $bin_num\n", $config->{verbose}, $config->{LOG}, 5);
262                            foreach my $del_mode (0,1) {
263                                my ($to_del_idx, $to_del_d, @prev, $to_del_l);
264                                for ($to_del_idx = $#{$local_diff->{idx}}; $to_del_idx >= 0; $to_del_idx--) {
265                                    $to_del_d = $local_diff->{data}[$local_diff->{idx}[$to_del_idx]];
266       
267                                    my $del_bin_cd = $local_diff->{data}[$local_diff->{idx}[$to_del_idx]][0][0];
268
269                                    if (!$to_del_d->[5]) {
270                                        log_("ERROR optimize_space move_bin: this must not happen, idx $to_del_idx is null in diff->{data} ($to_del_d)\n", $config->{verbose}, $config->{LOG}, 5); next
271                                    }
272                                    $to_del_d->[1] == $g or next;
273                                    if ($del_mode == 0 && $to_del_d->[2] != $l && $to_del_d->[4] == 1) {
274                                        push @prev, $to_del_d;
275                                        next
276                                    }
277                                    $spec = 0;
278                                    my ($nb, $mid) = $delete_and_check->($to_del_d, $to_del_idx, 'rpm', \@prev);
279                                    $to_del_idx -= $mid - 1;
280                                    $dn += $nb;
281                                    if ($idx >= $to_del_idx) {
282                                        $idx -= $nb
283                                    }
284                                    log_("optimize_space move_bin: first_size $first_size size_disc $local_size->{disc}[$bin_cd] cdsize $cdsize->[$bin_cd]\n", $config->{verbose}, $config->{LOG}, 5); next;
285                                    if ($curdir->[2]{limit}) {
286                                        log_("optimize_space: rep limit mode for rpm rep $bin_cd/$bin_num\n", $config->{verbose}, $config->{LOG}, 6);
287                                        goto move_bin_try_to_move if $first_size + $local_size->{rep}{$bin_cd}{$curdir->[1]}{$l} < $curdir->[2]{limit}{size};
288                                    } else {
289                                        goto move_bin_try_to_move if $first_size + $local_size->{disc}[$bin_cd] < $cdsize->[$bin_cd];
290                                    }
291                                    if ($to_del_d->[0][2]{limit}) {
292                                        log_("optimize_space: rep limit mode for rpm rep $del_bin_cd/$to_del_d->[3]\n", $config->{verbose}, $config->{LOG}, 6);
293                                        goto move_bin_while if $first_size < $to_del_d->[0][2]{limit}{size} - $local_size->{rep}{$del_bin_cd}{$to_del_d->[0][1]}{$l}
294                                    } else { 
295                                        goto move_bin_while if $first_size < $cdsize->[$del_bin_cd] - $local_size->{disc}[$del_bin_cd]
296                                    }
297                                }
298                            }
299                        }
300                        move_bin_try_to_move:
301                        my $av_space;
302                        # FIXME must be checked to validate generic limit option (soft option should be validated too)
303                        if ($curdir->[2]{limit}) {
304                            log_("optimize_space: rep limit mode for rpm rep $bin_cd/$bin_num\n", $config->{verbose}, $config->{LOG}, 6);
305                            $av_space = $curdir->[2]{limit}{size} - $local_size->{rep}{$bin_cd}{$curdir->[1]}{$l};
306                        } else {
307                            $av_space = $cdsize->[$bin_cd] - $local_size->{disc}[$bin_cd];
308                        }
309                        my $needed;
310                        foreach (@{$d->[5]}) {
311                            if ($_->[2][1]{needed} || $_->[2][1]{done}) {
312                                $needed = 1;
313                                log_("optimize_space: could not move $_->[0] needed $_->[2][1]{needed} ($bin_num)\n", $config->{verbose}, $config->{LOG}, 5);
314                                last
315                            }
316                        }
317                        if ($needed || ((@previous || $rep_diff > 1) && !$check_previous_deps->(\@previous, [$d], $g, $src_bin_num, $bin_num))) {
318                            push @previous, $d;
319                            next
320                        }
321                        if ($first_size < $av_space) {
322                            my $dest_curdir = $hashlist->{$l};
323                            $dn += $exchange->($d, $src_bin_cd, $src_bin_num, $bin_cd, $bin_num, $dest_curdir, $idx, $first_size, $g, $l);
324                            if ($curdir->[2]{limit}) { 
325                                log_("optimize_space: rep limit mode for rpm rep $src_bin_cd/$src_bin_num\n", $config->{verbose}, $config->{LOG}, 6);
326                                last if $next_first_size + $local_size->{rep}{$src_bin_cd}{$curdir->[1]}{$l} < $curdir->[2]{limit}{size}
327                            } else {
328                                last if $next_first_size + $local_size->{disc}[$src_bin_cd] < $cdsize->[$src_bin_cd]
329                            }
330                        } else {
331                            if ($mode == 0) {
332                                push @previous, $d
333                            } else { 
334                                if ($special && !$spec) {
335                                    $spec = $special;
336                                    goto move_bin_while
337                                }
338                                last
339                            }
340                        }
341                    }
342                }
343            }
344        }
345        $dn
346    };
347    my $try_to_move = sub {
348        my ($grp, $list, $type, $g, $l, $opti_mode, $cd, $special) = @_;
349        my $dn;
350        if ($opti_mode || $grp != $g || $list != $l) {
351            if ($groups->[$grp]{list_conflict}{$list}{$type}{$g}{$l}{rpm} && (!$cd || $groups->[$grp]{list_cd}{$list}{$cd})) {
352                $dn += $move_bin->($g, $l);
353            } else {
354                log_("optimize_space try_to_move: group $grp list $list type $type has no common disc with group $g list $l type rpm\n", $config->{verbose}, $config->{LOG}, 5);       
355            }
356        }
357        if ($groups->[$grp]{list_conflict}{$list}{$type}{$g}{$l}{srpm}) {
358            my $spec = 0;
359            foreach my $s_mode (0,1,2) { 
360                my $loop_gain = -1;
361                log_("optimize_space try_to_move: srpm mode $s_mode\n", $config->{verbose}, $config->{LOG}, 5); 
362                while ($realgain > $loop_gain) {
363                    move_src_while:
364                    $loop_gain = $realgain;
365                    my @max_size;
366                    my @prev;
367                    for (my $i = $#{$local_diff->{idx}}; $i >= 0; $i--) {
368                        my $d = $local_diff->{data}[$local_diff->{idx}[$i]];
369                        $d->[4] != 2 || $d->[1] != $g and next;
370                        my ($d_curdir, undef, undef, $drepnum, undef, $ddata) = @$d;
371                        my $dcd = $d_curdir->[0];
372                        if (!($spec || $s_mode == 2 || $dcd == $cdnum)) { next }
373                        my $dsize = $d->[7];
374                        if (!$s_mode && $dsize > (1.5 * ($gain - $realgain))) { next }
375                        if ($max_size[$drepnum]) {
376                            next if $dsize > $max_size[$drepnum]
377                        }
378                        my $srpms;
379                        foreach (@$ddata) { $srpms .= " $_->[0]" }
380                        log_("optimize_space: trying to move $srpms (size $dsize) from disc $dcd srpm rep $drepnum\n", $config->{verbose}, $config->{LOG}, 5);
381                        foreach (@{$groups->[$g]{replist}{srpm}}) {
382                            # log_("optimize_space: test $_ group $g list $l", $config->{verbose}, $config->{LOG}, 5);
383                            log_(" $_->[3] - $_->[3]{$l}\n", $config->{verbose}, $config->{LOG}, 5);
384                        }
385                        my @ordered_src_list_rep = sort { $a->[2] <=> $b->[2] } grep { ref $_->[3] && $_->[3]{$l} } @{$groups->[$g]{replist}{srpm}};
386                        my $test_dn = $dn;
387                        for (my $k=0; $k < @ordered_src_list_rep; $k++) {
388                            my ($dest_cd, $dest_repname, $dest_repnum, $hash_list) = @{$ordered_src_list_rep[$k]};
389                            log_("optimize_space: trying disc $dest_cd srpm rep $dest_repnum\n", $config->{verbose}, $config->{LOG}, 5);
390                            $dest_repnum == $drepnum and next;
391                            $dest_cd == $cdnum and next;
392                            my $dest_curdir = $hash_list->{$l};
393                            log_("optimize_space: trying disc $dest_cd srpm rep $dest_repnum\n", $config->{verbose}, $config->{LOG}, 5);
394                            my $cd_space;
395                            if ($dest_curdir->[2]{limit}) {
396                                log_("optimize_space: rep limit mode for srpm rep $dest_cd/$dest_repnum ($dest_curdir->[2]{limit}{size} - $local_size->{rep}{$dest_cd}{$dest_curdir->[1]}{$l})\n", $config->{verbose}, $config->{LOG}, 6);
397                                $cd_space = $dest_curdir->[2]{limit}{size} - $local_size->{rep}{$dest_cd}{$dest_curdir->[1]}{$l}
398                            } else {
399                                $cd_space = $cdsize->[$dest_cd] - $local_size->{disc}[$dest_cd]
400                            }
401                            if ($d->[2] == $l && $dsize <= $cd_space) {
402                                log_("optimize_space: moving srpm $srpms from disc $dcd to disc $dest_cd\n", $config->{verbose}, $config->{LOG}, 5);
403                                $dn += $exchange->($d, $dcd, $drepnum, $dest_cd, $dest_repnum, $dest_curdir, $i, $dsize, $g, $l);
404                                goto move_src_while if $cdnum == $dcd;
405                                #$dn += $move_bin->($g, $l) if (!$cd || $groups->[$grp]{list_cd}{$list}{$cd}) && $groups->[$grp]{list_conflict}{$list}{$type}{$g}{$l}{rpm} && $groups->[$g]{list_conflict}{$l}{srpm}{$g}{$l}{rpm};
406                                $realgain > $loop_gain ? last : goto try_to_move_end
407                            } elsif (!$spec && $special) {
408                                $spec = 1;
409                                goto move_src_while
410                            } elsif ($special) {
411                                log_("optimize_space: deleting srpm $srpms from disc $dcd\n", $config->{verbose}, $config->{LOG}, 5);
412                                my ($nb, $mid) += $delete_and_check->($d, $i, 'srpm', \@prev);
413                                $i -= $mid - 1;
414                                $dn += $nb;
415                                next if $cdnum == $dcd;
416                                $spec = 0; 
417                                #$dn += $move_bin->($g, $l) if (!$cd || $groups->[$grp]{list_cd}{$list}{$cd}) && $groups->[$grp]{list_conflict}{$list}{$type}{$g}{$l}{rpm} && $groups->[$g]{list_conflict}{$l}{srpm}{$g}{$l}{rpm};
418                                $realgain > $loop_gain ? last : goto try_to_move_end
419                            }
420                        }
421                        $max_size[$drepnum] = $dsize if $dn == $test_dn
422                    }
423                }
424            }
425        } else {
426            log_("optimize_space: group $grp list $list type $type has no common disc with group $g list $l type srpm\n", $config->{verbose}, $config->{LOG}, 5);       
427        }
428        if ($special && $groups->[$g]{disc_impacted}{$cdnum}) {
429            $dn += $move_bin->($g, $l,1);
430        }
431        try_to_move_end:
432        $dn
433    };
434    my $opti = sub {
435        my ($grp, $list, $type, $cd, $opti_mode, $special) = @_;
436        my $i;
437        $i++;
438        log_("optimize_space: main loop $i (special $special)\n", $config->{verbose}, $config->{LOG}, 5);
439        if (!$cd || $groups->[$grp]{list_cd}{$list}{$cd}) { $try_to_move->($grp, $list, $type, $grp, $list, $opti_mode, $cd, $special) }
440        foreach my $g (0 .. $#{$groups}) {
441            foreach my $l (keys %{$groups->[$g]{list}}) {
442                if (!$l) { log_("ERROR optimize_space: list 0 must not be defined\n", $config->{verbose}, $config->{LOG}, 2); next }
443                if ($cd || $groups->[$grp]{list_cd}{$list}{$cd}) { 
444                    $try_to_move->($grp, $list, $type, $g, $l, $opti_mode, $cd, $special)
445                }
446            }
447        }
448    };   
449
450    my $local_copy = sub {
451        my ($diff, $size) = @_;
452        my ($local_diff, $local_size, $local_done) = ({}, {}, []);
453        $local_diff->{idx} = [ @{$diff->{idx}} ];
454        for (my $i = 0; $i < @{$diff->{data}}; $i++) {
455            $local_diff->{data}[$i] = [ @{$diff->{data}[$i]} ] if ref $diff->{data}[$i]
456        }
457        for (my $group; $group < @$groups; $group++) {
458            foreach (keys %{$groups->[$group]{done}{rep}}) {
459                $local_done->[$group]{rep}{$_} = $groups->[$group]{done}{rep}{$_};
460                $local_done->[$group]{list}{$_} = $groups->[$group]{done}{list}{$_}
461            }
462        }
463        $local_size->{disc} = [ @{$size->{disc}} ];
464        foreach my $cd (keys %{$size->{rep}}) {
465            foreach my $rep (keys %{$size->{rep}{$cd}}) {
466                foreach my $list (keys %{$size->{rep}{$cd}{$rep}}) {
467                    log_("optimize_space: local_copy {$cd}{$rep}{$list} -> $size->{rep}{$cd}{$rep}{$list}\n", $config->{verbose}, $config->{LOG}, 6);
468                    $local_size->{rep}{$cd}{$rep}{$list} = $size->{rep}{$cd}{$rep}{$list}
469                }
470            }
471        }
472        ($local_diff, $local_size, $local_done)
473    };
474
475    my $do_it = sub {
476        my ($local_diff, $local_size, $diff, $size) = @_;
477        log_("optimize_space do_it: apply changes\n", $config->{verbose}, $config->{LOG}, 6);
478        $diff->{idx} = $local_diff->{idx};
479        $diff->{data} = $local_diff->{data};
480        $size->{disc} = $local_size->{disc};
481        $size->{rep} = $local_size->{rep};
482        for (my $group; $group < @$local_done; $group++) {
483            $groups->[$group]{done} = $local_done->[$group]
484        }
485        for (my $g; $g < @to_reject; $g++) {
486            foreach my $rpm (keys %{$groups->[$g]{rejected}}) {
487                foreach (keys %{$groups->[$g]{rejected}{$rpm}}) {
488                    push @{$groups->[$g]{rejected}{$rpm}}, [ $_, 'optimize_space' ]
489                }
490            }
491        }
492    };
493
494    ($local_diff, $local_size, $local_done) = $local_copy->($diff, $size);
495    foreach my $opti_mode (0,1) {
496        my $dn = 1;
497        while ($dn) {
498            $dn = 0;
499            foreach my $cd_d (@cd_sorted, [0]) {
500                my ($cd) = @$cd_d;
501                log_("optimize_space: cd @$cd_d\n", $config->{verbose}, $config->{LOG}, 6);
502
503                if (defined $grp && defined $list) {
504                    my @type_o = $type eq 'rpm' ? ('rpm', 'srpm') : ('srpm', 'rpm');
505                    foreach my $t (@type_o) { $dn = $opti->($grp, $list, $t, $cd, $opti_mode) }
506                    if ($special) { foreach my $t (@type_o) { $dn = $opti->($grp, $list, $t, $cd, $opti_mode, 1) } }
507                } else {
508                    foreach my $s (0 .. $special) {
509                        foreach my $grp (keys %{$config->{disc}[$cdnum]{group_list}}) {
510                            foreach my $lst (keys %{$config->{disc}[$cdnum]{group_list}{$grp}}) {
511                                if (!$lst) { log_("ERROR optimize_space: list 0 must not be defined\n", $config->{verbose}, $config->{LOG}, 2); next }
512                                foreach my $type (keys %{$config->{disc}[$cdnum]{group_list}{$grp}{$lst}}) {
513                                    $dn = $opti->($grp, $lst, $type, $special)
514                                }
515                                $dn and goto try_another_time
516                            }
517                        }
518                    }
519                }
520            }
521            try_another_time:
522            @cd_to_test = ();
523            for (my $i; $i < @$cdsize; $i++) {
524                $cdlists->{$i} or next;
525                $groups->[$grp]{disc_impacted}{$i} or next;
526                push @cd_to_test, [ $i, $cdsize->[$i] - $local_size->{disc}[$i] ]
527            }
528        }
529    }
530   
531optimize_space_ok:
532    log_("optimize_space: manage to gain $realgain\n", $config->{verbose}, $config->{LOG}, 2);
533    if ($realgain < $gain) {
534        log_("optimize_space: setting max gain for disc $cdnum to $realgain\n", $config->{verbose}, $config->{LOG}, 2);
535        $size->{optimize_space}{disc}{$cdnum} = $realgain
536    } else {
537        $do_it->($local_diff, $local_size, $diff, $size)
538    }
539    return $realgain
540}
541
542sub get_pkgs_deps {
543    my ($rpmd, $group) = @_;
544    my (@tdeps, %curID);
545    foreach (@$rpmd) {
546        my $rpm = $_->[0];
547        $curID{$group->{urpm}{rpm}{$rpm}->id} = 1;
548        $_->[1]{nodeps} and next;
549        $group->{pkgdeps}{$rpm} and push @tdeps, @{$group->{pkgdeps}{$rpm}}
550    }
551    my (@deps, %depsdone);
552    foreach (@tdeps) {
553        if (ref $_) {
554            my @toadd;
555            my $key = join '|', @$_;
556            $depsdone{$key}++ and next;
557            # We could not just remove the $deps inside the foreach loop
558            # otherwize one alternative deps could be removed but not the other, and
559            # this could lead to package rejected for ordering reasons although they should not
560            # As a consequence two foreach loops are needed
561            my $ok;
562            $ok ||= $depsdone{$_} foreach @$_;
563            $ok and next;
564            foreach my $d (@$_) {
565                if ($curID{$d}) { @toadd = (); last }
566                push @toadd, $d
567            }
568            @toadd and push @deps, \@toadd
569        } elsif (!$curID{$_}) {
570            $depsdone{$_}++ and next;
571            push @deps, $_
572        }
573    }
574    return \@deps
575}
576
577sub print_conflict_matrix {
578    my ($groups) = @_;
579    print "print_listcd_matrix\n";
580    for (my $i = 0; $i < @$groups; $i++) {
581        ref $groups->[$i]{list_cd} or next;
582        print "Group $i\n";
583        foreach my $list (keys %{$groups->[$i]{list_cd}}) {
584            ref $groups->[$i]{list_cd}{$list} or next;
585            print "Group $i list $list\n";
586            foreach my $cd (keys %{$groups->[$i]{list_cd}{$list}}) {
587                ref $groups->[$i]{list_cd}{$list}{$cd} or next;
588                print "Group $i list $list cd $cd\n";
589                foreach my $type (keys %{$groups->[$i]{list_cd}{$list}{$cd}}) {
590                    ref $groups->[$i]{list_cd}{$list}{$cd}{$type} or next;
591                    print "Group $i list $list cd $cd type $type -> @{$groups->[$i]{list_cd}{$list}{$cd}{$type}}\n"
592                }
593            }
594        }
595    }
596    print "print_conflict_matrix\n";
597    for (my $i = 0; $i < @$groups; $i++) {
598        ref $groups->[$i]{list_conflict} or next;
599        #print "Group $i\n";
600        foreach my $list (keys %{$groups->[$i]{list_conflict}}) {
601            ref $groups->[$i]{list_conflict}{$list} or next;
602            #print "Group $i list $list\n";
603            foreach my $type (keys %{$groups->[$i]{list_conflict}{$list}}) {
604                ref $groups->[$i]{list_conflict}{$list}{$type} or next;
605                #print "Group $i list $list type $type\n";
606                foreach my $group (keys %{$groups->[$i]{list_conflict}{$list}{$type}}) {
607                    ref $groups->[$i]{list_conflict}{$list}{$type}{$group} or next;
608                    #print "Group $i list $list type $type group $group\n";
609                    foreach my $list_2 (keys %{$groups->[$i]{list_conflict}{$list}{$type}{$group}}) {
610                        ref $groups->[$i]{list_conflict}{$list}{$type}{$group}{$list_2} or next;
611                        #print "Group $i list $list type $type group $group list $list_2\n";
612                        foreach my $type (keys %{$groups->[$i]{list_conflict}{$list}{$type}{$group}{$list_2}}) {
613                            print "Group $i list $list type $type group $group list $list_2 type $type -> $groups->[$i]{list_conflict}{$list}{$type}{$group}{$list_2}{$type}\n"
614                        }
615                    }
616                }
617            }
618        }
619    }
620       
621
622}
Note: See TracBrowser for help on using the repository browser.