Lines Matching refs:delta
116 # a new "delta" hash that represents what has changed over time.
119 # a single delta hash that encompasses all the time periods described by the
313 # to access the kstats, and then we create a delta comparing these
314 # kstats with a prior set of kstats, that delta will cover
335 # dumpdelta takes a reference to our "delta" structure:
336 # {"missing"} "1" if the delta's component stats had inconsistencies
337 # {"minsnap"} time of the first kstat snaptime used in this delta
338 # {"maxsnap"} time of the last kstat snaptime used in this delta
339 # {"goodness"} cost function applied to this delta
357 # It prints out the delta structure in a nice, human readable display.
362 my ($delta) = @_;
367 syslog('debug', " RECONFIGURATION IN DELTA") if $delta->{missing} > 0;
369 $delta->{avgintrload} * 100, $delta->{avgintrnsec});
370 syslog('debug', " goodness: %5.2f%%", $delta->{goodness} * 100)
371 if exists($delta->{goodness});
375 while (my ($cpu, $cpst) = each %$delta) {
396 # getstat(), and creates a %delta. %delta (not surprisingly) contains the
398 # instead of absolute times. We return a reference to the delta.
405 my %delta = ();
411 $delta{minsnap} = $stat->{snaptime};
412 $delta{maxsnap} = $newstat->{snaptime};
413 if (VERIFY($delta{maxsnap} > $delta{minsnap},
415 $delta{missing} = 1;
416 return (\%delta);
421 $delta{missing} = (keys(%$stat) != keys(%$newstat));
422 if (VERIFY($delta{missing} == 0,
424 return (\%delta);
438 $delta{missing} = 1;
439 return (\%delta);
442 $delta{$cpu}{tot} = $newcpst->{tot} - $cpst->{tot};
443 if (VERIFY($delta{$cpu}{tot} >= 0,
445 $delta{missing} = 1;
446 delete($delta{$cpu});
447 return (\%delta);
450 $delta{$cpu}{tot} = 1 if $delta{$cpu}{tot} == 0;
451 $delta{$cpu}{intrs} = 0;
452 $delta{$cpu}{bigintr} = 0;
455 $delta{$cpu}{ivecs} = \%ivecs;
463 $delta{missing} = 1;
464 return (\%delta);
481 $delta{missing} = 1;
482 return (\%delta);
486 # Create $delta{$cpu}{ivecs}{$inum}.
489 $delta{$cpu}{ivecs}{$inum} = \%dltivec;
496 $delta{missing} = 1;
497 delete($delta{$cpu}{ivecs}{$inum});
498 return (\%delta);
500 $delta{$cpu}{intrs} += $time;
502 if ($time > $delta{$cpu}{bigintr}) {
503 $delta{$cpu}{bigintr} = $time;
518 if ($delta{$cpu}{tot} < $delta{$cpu}{intrs}) {
521 $delta{$cpu}{tot} = $delta{$cpu}{intrs};
523 $delta{$cpu}{intrload} =
524 $delta{$cpu}{intrs} / $delta{$cpu}{tot};
525 $intrload += $delta{$cpu}{intrload};
526 $intrnsec += $delta{$cpu}{intrs};
530 $delta{avgintrload} = $intrload / $cpus;
531 $delta{avgintrnsec} = $intrnsec / $cpus;
533 $delta{avgintrload} = 0;
534 $delta{avgintrnsec} = 0;
536 return (\%delta);
540 # compress_delta takes a list of deltas, and returns a single new delta
543 # delta looks just like any other delta. This new delta is also more accurate
557 "compress_deltas: list of delta is empty?")) {
564 foreach my $delta (@$deltas) {
565 if (VERIFY($delta->{missing} == 0,
569 while (my ($cpuid, $cpu) = each %$delta) {
639 # a delta and determining the best possible assignment of interrupts to CPUs.
655 # goodness(%delta) examines a delta and return its "goodness". goodness will
676 my ($delta) = @_;
678 return (1) if $delta->{missing} > 0;
683 foreach my $cpu (values(%$delta)) {
686 $goodness = goodness_cpu($cpu, $delta->{avgintrload});
689 dumpdelta($delta);
723 # which will effectively contaminate this entire delta.
780 # move_intr(\%delta, $inum, $oldcpu, $newcpu)
782 # a delta. This manipulates data structures, and does not actually move
787 my ($delta, $inum, $oldcpuid, $newcpuid) = @_;
789 my $ivec = $delta->{$oldcpuid}{ivecs}{$inum};
793 my $oldcpu = $delta->{$oldcpuid};
813 my $newcpu = $delta->{$newcpuid};
826 my ($delta, $oldcpuid, $newcpuid) = @_;
828 VERIFY($delta->{$oldcpuid}{tot} >= $delta->{$oldcpuid}{intrs},
830 VERIFY($delta->{$newcpuid}{tot} >= $delta->{$newcpuid}{intrs},
846 my ($delta) = @_;
848 my $goodness = $delta->{goodness};
861 if (VERIFY ($delta->{missing} == 0, "RECONFIG Aborted: should not ".
862 "have a delta with missing")) {
871 while (my ($cpuid, $cpu) = each %$delta) {
894 sort({$delta->{$b}{intrload} <=> $delta->{$a}{intrload}}
898 if (($delta->{$cpu}{intrload} <= $goodness_unsafe_load) &&
899 ($delta->{$cpu}{intrload} <=
900 $delta->{avgintrload} + $goodness_mindelta)) {
902 "$delta->{$cpu}{intrload} avgload ".
903 "$delta->{avgintrload}");
906 if (goodness_cpu($delta->{$cpu}, $delta->{avgintrload}) <
910 do_reconfig_cpu($delta, \@cpusortlist, $cpu);
917 my $newgoodness = goodness($delta);
934 while (my ($cpuid, $cpu) = each %$delta) {
957 my ($delta, $cpusortlist, $oldcpuid) = @_;
970 my $cpu = $delta->{$oldcpuid};
971 my $avgintrload = $delta->{avgintrload};
978 my $tgt = $delta->{$tgtcpuid};
982 do_reconfig_cpu2cpu($delta, $oldcpuid, $tgtcpuid, $load);
988 my ($delta, $srccpuid, $tgtcpuid, $srcload) = @_;
999 my @ivecs = (values(%{$delta->{$srccpuid}{ivecs}}),
1000 values(%{$delta->{$tgtcpuid}{ivecs}}));
1010 my $goal = $delta->{avgintrnsec};
1017 ($delta->{$srccpuid}{intrs} + $delta->{$tgtcpuid}{intrs}) / 2;
1036 # Call move_intr() to update our $delta with the new results.
1045 move_intr($delta, $ivec->{inum}, $ivec->{nowcpu},
1048 move_intr($delta, $ivec->{inum}, $ivec->{nowcpu},
1052 move_intr_check($delta, $srccpuid, $tgtcpuid); # asserts
1054 my $newload = $delta->{$srccpuid}{intrs} / $delta->{$srccpuid}{tot};
1055 VERIFY($newload <= $srcload && $newload > $delta->{avgintrload},
1236 my $delta;
1312 # 2. Compare $newstat with the prior set of values, result in %$delta.
1314 $delta = generate_delta($stat, $newstat);
1315 dumpdelta($delta) if $debug; # Dump most recent stats to stdout.
1319 # 3. If $delta->{missing}, then there has been a reconfiguration of
1323 # Also, if the delta covers a very long range of time, then we've
1328 $deltatime = $delta->{maxsnap} - $delta->{minsnap};
1329 if ($delta->{missing} > 0 || $deltatime > $statslen) {
1336 # 4. Incorporate new delta into the list of deltas, and associated
1343 push(@deltas, $delta);
1365 # First, take @deltas and generate a single "compressed" delta