#!/usr/bin/perl
  # -----------------------------------------------------------------------
  #

  #   Copyright 2007-2008 rPath, Inc. - All Rights Reserved

  #
  #   This file is part of the Linux kernel, and is made available under
  #   the terms of the GNU General Public License version 2 or (at your
  #   option) any later version; incorporated herein by reference.
  #
  # -----------------------------------------------------------------------
  #
  
  #
  # Usage: timeconst.pl HZ > timeconst.h
  #
  
  # Precomputed values for systems without Math::BigInt
  # Generated by:
  # timeconst.pl --can 24 32 48 64 100 122 128 200 250 256 300 512 1000 1024 1200
  %canned_values = (
  	24 => [
  		'0xa6aaaaab','0x2aaaaaa',26,

  		125,3,
  		'0xc49ba5e4','0x1fbe76c8b4',37,

  		3,125,
  		'0xa2c2aaab','0xaaaa',16,

  		125000,3,
  		'0xc9539b89','0x7fffbce4217d',47,

  		3,125000,
  	], 32 => [
  		'0xfa000000','0x6000000',27,

  		125,4,
  		'0x83126e98','0xfdf3b645a',36,

  		4,125,
  		'0xf4240000','0x0',17,

  		31250,1,
  		'0x8637bd06','0x3fff79c842fa',46,

  		1,31250,
  	], 48 => [
  		'0xa6aaaaab','0x6aaaaaa',27,

  		125,6,
  		'0xc49ba5e4','0xfdf3b645a',36,

  		6,125,
  		'0xa2c2aaab','0x15555',17,

  		62500,3,
  		'0xc9539b89','0x3fffbce4217d',46,

  		3,62500,
  	], 64 => [
  		'0xfa000000','0xe000000',28,

  		125,8,
  		'0x83126e98','0x7ef9db22d',35,

  		8,125,
  		'0xf4240000','0x0',18,

  		15625,1,
  		'0x8637bd06','0x1fff79c842fa',45,

  		1,15625,
  	], 100 => [
  		'0xa0000000','0x0',28,

  		10,1,
  		'0xcccccccd','0x733333333',35,

  		1,10,
  		'0x9c400000','0x0',18,

  		10000,1,
  		'0xd1b71759','0x1fff2e48e8a7',45,

  		1,10000,
  	], 122 => [
  		'0x8325c53f','0xfbcda3a',28,

  		500,61,
  		'0xf9db22d1','0x7fbe76c8b',35,

  		61,500,
  		'0x8012e2a0','0x3ef36',18,

  		500000,61,
  		'0xffda4053','0x1ffffbce4217',45,

  		61,500000,
  	], 128 => [
  		'0xfa000000','0x1e000000',29,

  		125,16,
  		'0x83126e98','0x3f7ced916',34,

  		16,125,
  		'0xf4240000','0x40000',19,

  		15625,2,
  		'0x8637bd06','0xfffbce4217d',44,

  		2,15625,
  	], 200 => [
  		'0xa0000000','0x0',29,

  		5,1,
  		'0xcccccccd','0x333333333',34,

  		1,5,
  		'0x9c400000','0x0',19,

  		5000,1,
  		'0xd1b71759','0xfff2e48e8a7',44,

  		1,5000,
  	], 250 => [
  		'0x80000000','0x0',29,

  		4,1,
  		'0x80000000','0x180000000',33,

  		1,4,
  		'0xfa000000','0x0',20,

  		4000,1,
  		'0x83126e98','0x7ff7ced9168',43,

  		1,4000,
  	], 256 => [
  		'0xfa000000','0x3e000000',30,

  		125,32,
  		'0x83126e98','0x1fbe76c8b',33,

  		32,125,
  		'0xf4240000','0xc0000',20,

  		15625,4,
  		'0x8637bd06','0x7ffde7210be',43,

  		4,15625,
  	], 300 => [
  		'0xd5555556','0x2aaaaaaa',30,

  		10,3,
  		'0x9999999a','0x1cccccccc',33,

  		3,10,
  		'0xd0555556','0xaaaaa',20,

  		10000,3,
  		'0x9d495183','0x7ffcb923a29',43,

  		3,10000,
  	], 512 => [
  		'0xfa000000','0x7e000000',31,

  		125,64,
  		'0x83126e98','0xfdf3b645',32,

  		64,125,
  		'0xf4240000','0x1c0000',21,

  		15625,8,
  		'0x8637bd06','0x3ffef39085f',42,

  		8,15625,
  	], 1000 => [
  		'0x80000000','0x0',31,

  		1,1,
  		'0x80000000','0x0',31,

  		1,1,
  		'0xfa000000','0x0',22,

  		1000,1,
  		'0x83126e98','0x1ff7ced9168',41,

  		1,1000,
  	], 1024 => [
  		'0xfa000000','0xfe000000',32,

  		125,128,
  		'0x83126e98','0x7ef9db22',31,

  		128,125,
  		'0xf4240000','0x3c0000',22,

  		15625,16,
  		'0x8637bd06','0x1fff79c842f',41,

  		16,15625,
  	], 1200 => [
  		'0xd5555556','0xd5555555',32,

  		5,6,
  		'0x9999999a','0x66666666',31,

  		6,5,
  		'0xd0555556','0x2aaaaa',22,

  		2500,3,
  		'0x9d495183','0x1ffcb923a29',41,

  		3,2500,
  	]
  );
  
  $has_bigint = eval 'use Math::BigInt qw(bgcd); 1;';
  
  sub bint($)
  {
  	my($x) = @_;
  	return Math::BigInt->new($x);
  }
  
  #
  # Constants for division by reciprocal multiplication.
  # (bits, numerator, denominator)
  #
  sub fmul($$$)
  {
  	my ($b,$n,$d) = @_;
  
  	$n = bint($n);
  	$d = bint($d);
  
  	return scalar (($n << $b)+$d-bint(1))/$d;
  }
  
  sub fadj($$$)
  {
  	my($b,$n,$d) = @_;
  
  	$n = bint($n);
  	$d = bint($d);
  
  	$d = $d/bgcd($n, $d);
  	return scalar (($d-bint(1)) << $b)/$d;
  }
  
  sub fmuls($$$) {
  	my($b,$n,$d) = @_;
  	my($s,$m);
  	my($thres) = bint(1) << ($b-1);
  
  	$n = bint($n);
  	$d = bint($d);
  
  	for ($s = 0; 1; $s++) {
  		$m = fmul($s,$n,$d);
  		return $s if ($m >= $thres);
  	}
  	return 0;
  }

  # Generate a hex value if the result fits in 64 bits;
  # otherwise skip.
  sub bignum_hex($) {
  	my($x) = @_;
  	my $s = $x->as_hex();
  
  	return (length($s) > 18) ? undef : $s;
  }

  # Provides mul, adj, and shr factors for a specific
  # (bit, time, hz) combination
  sub muladj($$$) {
  	my($b, $t, $hz) = @_;
  	my $s = fmuls($b, $t, $hz);
  	my $m = fmul($s, $t, $hz);
  	my $a = fadj($s, $t, $hz);

  	return (bignum_hex($m), bignum_hex($a), $s);

  }
  
  # Provides numerator, denominator values
  sub numden($$) {
  	my($n, $d) = @_;
  	my $g = bgcd($n, $d);
  	return ($n/$g, $d/$g);
  }
  
  # All values for a specific (time, hz) combo
  sub conversions($$) {
  	my ($t, $hz) = @_;
  	my @val = ();
  
  	# HZ_TO_xx
  	push(@val, muladj(32, $t, $hz));

  	push(@val, numden($t, $hz));
  
  	# xx_TO_HZ
  	push(@val, muladj(32, $hz, $t));

  	push(@val, numden($hz, $t));
  
  	return @val;
  }
  
  sub compute_values($) {
  	my($hz) = @_;
  	my @val = ();
  	my $s, $m, $a, $g;
  
  	if (!$has_bigint) {
  		die "$0: HZ == $hz not canned and ".
  		    "Math::BigInt not available
  ";
  	}
  
  	# MSEC conversions
  	push(@val, conversions(1000, $hz));
  
  	# USEC conversions
  	push(@val, conversions(1000000, $hz));
  
  	return @val;
  }

  sub outputval($$)
  {
  	my($name, $val) = @_;
  	my $csuf;
  
  	if (defined($val)) {
  	    if ($name !~ /SHR/) {
  		$val = "U64_C($val)";
  	    }
  	    printf "#define %-23s %s
  ", $name.$csuf, $val.$csuf;
  	}
  }

  sub output($@)
  {
  	my($hz, @val) = @_;
  	my $pfx, $bit, $suf, $s, $m, $a;
  
  	print "/* Automatically generated by kernel/timeconst.pl */
  ";
  	print "/* Conversion constants for HZ == $hz */
  ";
  	print "
  ";
  	print "#ifndef KERNEL_TIMECONST_H
  ";
  	print "#define KERNEL_TIMECONST_H
  ";
  	print "
  ";
  
  	print "#include <linux/param.h>
  ";

  	print "#include <linux/types.h>
  ";

  
  	print "
  ";
  	print "#if HZ != $hz
  ";
  	print "#error \"kernel/timeconst.h has the wrong HZ value!\"
  ";
  	print "#endif
  ";
  	print "
  ";
  
  	foreach $pfx ('HZ_TO_MSEC','MSEC_TO_HZ',

  		      'HZ_TO_USEC','USEC_TO_HZ') {

  		foreach $bit (32) {

  			foreach $suf ('MUL', 'ADJ', 'SHR') {

  				outputval("${pfx}_$suf$bit", shift(@val));

  			}
  		}
  		foreach $suf ('NUM', 'DEN') {

  			outputval("${pfx}_$suf", shift(@val));

  		}
  	}
  
  	print "
  ";
  	print "#endif /* KERNEL_TIMECONST_H */
  ";
  }

  # Pretty-print Perl values
  sub perlvals(@) {
  	my $v;
  	my @l = ();
  
  	foreach $v (@_) {
  		if (!defined($v)) {
  			push(@l, 'undef');
  		} elsif ($v =~ /^0x/) {
  			push(@l, "\'".$v."\'");
  		} else {
  			push(@l, $v.'');
  		}
  	}
  	return join(',', @l);
  }

  ($hz) = @ARGV;
  
  # Use this to generate the %canned_values structure
  if ($hz eq '--can') {
  	shift(@ARGV);
  	@hzlist = sort {$a <=> $b} (@ARGV);
  
  	print "# Precomputed values for systems without Math::BigInt
  ";
  	print "# Generated by:
  ";
  	print "# timeconst.pl --can ", join(' ', @hzlist), "
  ";
  	print "\%canned_values = (
  ";
  	my $pf = "\t";
  	foreach $hz (@hzlist) {
  		my @values = compute_values($hz);
  		print "$pf$hz => [
  ";
  		while (scalar(@values)) {
  			my $bit;

  			foreach $bit (32) {

  				my $m = shift(@values);
  				my $a = shift(@values);
  				my $s = shift(@values);

  				print "\t\t", perlvals($m,$a,$s), ",
  ";

  			}
  			my $n = shift(@values);
  			my $d = shift(@values);

  			print "\t\t", perlvals($n,$d), ",
  ";

  		}
  		print "\t]";
  		$pf = ', ';
  	}
  	print "
  );
  ";
  } else {
  	$hz += 0;			# Force to number
  	if ($hz < 1) {
  		die "Usage: $0 HZ
  ";
  	}
  
  	@val = @{$canned_values{$hz}};
  	if (!defined(@val)) {
  		@val = compute_values($hz);
  	}
  	output($hz, @val);
  }
  exit 0;