241 lines
6.8 KiB
Perl
Executable File
241 lines
6.8 KiB
Perl
Executable File
#!/usr/bin/perl -w
|
|
# Copyright (C) 1999-2013 Free Software Foundation, Inc.
|
|
# This file is part of the GNU C Library.
|
|
# Contributed by Andreas Jaeger <aj@suse.de>, 1999.
|
|
|
|
# The GNU C Library is free software; you can redistribute it and/or
|
|
# modify it under the terms of the GNU Lesser General Public
|
|
# License as published by the Free Software Foundation; either
|
|
# version 2.1 of the License, or (at your option) any later version.
|
|
|
|
# The GNU C Library is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
# Lesser General Public License for more details.
|
|
|
|
# You should have received a copy of the GNU Lesser General Public
|
|
# License along with the GNU C Library; if not, see
|
|
# <http://www.gnu.org/licenses/>.
|
|
|
|
# Information about tests are stored in: %results
|
|
# $results{$test}{"type"} is the result type, e.g. normal or complex.
|
|
# In the following description $platform, $type and $float are:
|
|
# - $platform is the used platform
|
|
# - $type is either "normal", "real" (for the real part of a complex number)
|
|
# or "imag" (for the imaginary part # of a complex number).
|
|
# - $float is either of float, ifloat, double, idouble, ldouble, ildouble;
|
|
# It represents the underlying floating point type (float, double or long
|
|
# double) and if inline functions (the leading i stands for inline)
|
|
# are used.
|
|
# $results{$test}{$platform}{$type}{$float} is defined and has a delta
|
|
# or 'fail' as value.
|
|
|
|
use File::Find;
|
|
|
|
use strict;
|
|
|
|
use vars qw ($sources @platforms %pplatforms);
|
|
use vars qw (%results @all_floats %suffices @all_functions);
|
|
|
|
|
|
# all_floats is in output order and contains all recognised float types that
|
|
# we're going to output
|
|
@all_floats = ('float', 'double', 'ldouble');
|
|
%suffices =
|
|
( 'float' => 'f',
|
|
'double' => '',
|
|
'ldouble' => 'l'
|
|
);
|
|
|
|
# Pretty description of platform
|
|
%pplatforms =
|
|
( "i386/fpu" => "ix86",
|
|
"generic" => "Generic",
|
|
"alpha/fpu" => "Alpha",
|
|
"ia64/fpu" => "IA64",
|
|
"m68k/fpu" => "M68k",
|
|
"mips/fpu" => "MIPS",
|
|
"powerpc/fpu" => "PowerPC",
|
|
"sparc/sparc32/fpu" => "Sparc 32-bit",
|
|
"sparc/sparc64/fpu" => "Sparc 64-bit",
|
|
"sh/sh4/fpu" => "SH4",
|
|
"s390/fpu" => "S/390",
|
|
"arm" => "ARM"
|
|
);
|
|
|
|
@all_functions =
|
|
( "acos", "acosh", "asin", "asinh", "atan", "atanh",
|
|
"atan2", "cabs", "cacos", "cacosh", "carg", "casin", "casinh",
|
|
"catan", "catanh", "cbrt", "ccos", "ccosh", "ceil", "cexp", "cimag",
|
|
"clog", "clog10", "conj", "copysign", "cos", "cosh", "cpow", "cproj",
|
|
"creal", "csin", "csinh", "csqrt", "ctan", "ctanh", "erf", "erfc",
|
|
"exp", "exp10", "exp2", "expm1", "fabs", "fdim", "floor", "fma",
|
|
"fmax", "fmin", "fmod", "frexp", "gamma", "hypot",
|
|
"ilogb", "j0", "j1", "jn", "lgamma", "lrint",
|
|
"llrint", "log", "log10", "log1p", "log2", "logb", "lround",
|
|
"llround", "modf", "nearbyint", "nextafter", "nexttoward", "pow",
|
|
"remainder", "remquo", "rint", "round", "scalb", "scalbn", "scalbln",
|
|
"sin", "sincos", "sinh", "sqrt", "tan", "tanh", "tgamma",
|
|
"trunc", "y0", "y1", "yn" );
|
|
# fpclassify, isnormal, isfinite, isinf, isnan, issignaling, signbit,
|
|
# isgreater, isgreaterequal, isless, islessequal, islessgreater, isunordered
|
|
# are not tabulated.
|
|
|
|
if ($#ARGV == 0) {
|
|
$sources = $ARGV[0];
|
|
} else {
|
|
$sources = '/usr/src/cvs/libc';
|
|
}
|
|
|
|
find (\&find_files, $sources);
|
|
|
|
@platforms = sort by_platforms @platforms;
|
|
|
|
&print_all;
|
|
|
|
sub find_files {
|
|
if ($_ eq 'libm-test-ulps') {
|
|
# print "Parsing $File::Find::name\n";
|
|
push @platforms, $File::Find::dir;
|
|
&parse_ulps ($File::Find::name, $File::Find::dir);
|
|
}
|
|
}
|
|
|
|
# Parse ulps file
|
|
sub parse_ulps {
|
|
my ($file, $platform) = @_;
|
|
my ($test, $type, $float, $eps, $kind);
|
|
|
|
# $type has the following values:
|
|
# "normal": No complex variable
|
|
# "real": Real part of complex result
|
|
# "imag": Imaginary part of complex result
|
|
open ULP, $file or die ("Can't open $file: $!");
|
|
while (<ULP>) {
|
|
chop;
|
|
# ignore comments and empty lines
|
|
next if /^#/;
|
|
next if /^\s*$/;
|
|
if (/^Test/) {
|
|
$kind = 'test';
|
|
next;
|
|
}
|
|
if (/^Function: /) {
|
|
if (/Real part of/) {
|
|
s/Real part of //;
|
|
$type = 'real';
|
|
} elsif (/Imaginary part of/) {
|
|
s/Imaginary part of //;
|
|
$type = 'imag';
|
|
} else {
|
|
$type = 'normal';
|
|
}
|
|
($test) = ($_ =~ /^Function:\s*\"([a-zA-Z0-9_]+)\"/);
|
|
$kind = 'fct';
|
|
next;
|
|
}
|
|
# Only handle maximal errors of functions
|
|
next if ($kind eq 'test');
|
|
if (/^i?(float|double|ldouble):/) {
|
|
($float, $eps) = split /\s*:\s*/,$_,2;
|
|
if ($eps eq 'fail') {
|
|
$results{$test}{$platform}{$type}{$float} = 'fail';
|
|
} elsif ($eps eq "0") {
|
|
# ignore
|
|
next;
|
|
} elsif (!exists $results{$test}{$platform}{$type}{$float}
|
|
|| $results{$test}{$platform}{$type}{$float} ne 'fail') {
|
|
$results{$test}{$platform}{$type}{$float} = $eps;
|
|
}
|
|
if ($type =~ /^real|imag$/) {
|
|
$results{$test}{'type'} = 'complex';
|
|
} elsif ($type eq 'normal') {
|
|
$results{$test}{'type'} = 'normal';
|
|
}
|
|
next;
|
|
}
|
|
print "Skipping unknown entry: `$_'\n";
|
|
}
|
|
close ULP;
|
|
}
|
|
|
|
sub get_value {
|
|
my ($fct, $platform, $type, $float) = @_;
|
|
|
|
return (exists $results{$fct}{$platform}{$type}{$float}
|
|
? $results{$fct}{$platform}{$type}{$float} : "0");
|
|
}
|
|
|
|
sub canonicalize_platform {
|
|
my ($platform) = @_;
|
|
|
|
$platform =~ s|^(.*/sysdeps/)||;
|
|
|
|
|
|
return exists $pplatforms{$platform} ? $pplatforms{$platform} : $platform;
|
|
}
|
|
|
|
sub print_platforms {
|
|
my (@p) = @_;
|
|
my ($fct, $platform, $float, $first, $i, $platform_no, $platform_total);
|
|
|
|
print '@multitable {nexttowardf} ';
|
|
foreach (@p) {
|
|
print ' {1000 + i 1000}';
|
|
}
|
|
print "\n";
|
|
|
|
print '@item Function ';
|
|
foreach (@p) {
|
|
print ' @tab ';
|
|
print &canonicalize_platform ($_);
|
|
}
|
|
print "\n";
|
|
|
|
|
|
foreach $fct (@all_functions) {
|
|
foreach $float (@all_floats) {
|
|
print "\@item $fct$suffices{$float} ";
|
|
foreach $platform (@p) {
|
|
print ' @tab ';
|
|
if (exists $results{$fct}{$platform}{'normal'}{$float}
|
|
|| exists $results{$fct}{$platform}{'real'}{$float}
|
|
|| exists $results{$fct}{$platform}{'imag'}{$float}) {
|
|
if ($results{$fct}{'type'} eq 'complex') {
|
|
print &get_value ($fct, $platform, 'real', $float),
|
|
' + i ', &get_value ($fct, $platform, 'imag', $float);
|
|
} else {
|
|
print $results{$fct}{$platform}{'normal'}{$float};
|
|
}
|
|
} else {
|
|
print '-';
|
|
}
|
|
}
|
|
print "\n";
|
|
}
|
|
}
|
|
|
|
print "\@end multitable\n";
|
|
}
|
|
|
|
sub print_all {
|
|
my ($i, $max);
|
|
|
|
my ($columns) = 5;
|
|
|
|
# Print only 5 platforms at a time.
|
|
for ($i=0; $i < $#platforms; $i+=$columns) {
|
|
$max = $i+$columns-1 > $#platforms ? $#platforms : $i+$columns-1;
|
|
print_platforms (@platforms[$i .. $max]);
|
|
}
|
|
}
|
|
|
|
sub by_platforms {
|
|
my ($pa, $pb);
|
|
|
|
$pa = $pplatforms{$a} ? $pplatforms{$a} : $a;
|
|
$pb = $pplatforms{$b} ? $pplatforms{$b} : $b;
|
|
|
|
return $pa cmp $pb;
|
|
}
|