testreport.txt

CIRRUS 公司EP93XX系列CPU的WINCE下的BSP

TEST REPORT OF CRUNCHLIB

1. Objective
        This report is to give test result and conclusion of Crunchlib.

2. Scope
        The test covers of only those functions that are exported from the crunchlib 
        DLL as specified in crunchlibspec.txt, are covered in this document. The
        following is the list of the 27 functions that are covered in the test.
        
        <1> General Purpose Functions        
                double     ceil(double);
                double     floor(double);               
                double     fabs(double);
                double     sqrt(double);
                double     fmod(double, double);
                
                float      ceilf(float);
                float      floorf(float);
                float      fabsf(float);
                float      sqrtf(float);
                float      fmodf(float, float);               

                        
        <2> Transcendental Floating-Point Functions

        <<1>> Logarithmic Functions
                double     pow(double, double);
                double     log(double);
                double     log10(double);
                double     exp(double);

        <<2>> Trigonometric Functions
                double     sin(double);
                double     cos(double);
                double     tan(double);
                double     asin(double);
                double     acos(double);
                double     atan(double);
                double     atan2(double, double);

        <<3>> Hyperbolic Functions
                double     sinh(double);
                double     cosh(double);
                double     tanh(double);
                
        <3> Compute the Bessel functions        
                double     _y0( double x );
                double     _y1( double x );
                double     _yn( int n, double x );
            
        This document keeps down the test cases and test result of them. It also 
        gives a summarized test conclusion of the Crunchlib. The test covers the 
        following aspects or cases of the test for Crunchlib.
        
                - accuracy test
                - exception test
                - thread security test
                - performance test
        
        They are put in details in section 4 through 7 repectively. The conclusion
        is given in section 8.
    
        
3. Introduction
        The crunchlib DLL is to provide hardware replacement for the intrinsic 
        floating point functions in Windows CE kernel. Therefore, functions in 
        crunchlib must have equal calculation result, exception behavor and thread 
        security as their counterparts in Windows CE kernel. Meanwhile, their 
        performance, i.e., their speed must be higer than their counterparts in 
        Windows CE kernel.
        
        The test code are divided into three seperated projects. They are accruacy 
        test, exception test and performance test. The thread security test is 
        embedded in the accuracy test as a build with MACRO MULTI_THREAD_TEST defined.
        
4. Accuracy Test
        Accuracy test is to verify that functions in crunchlib give equal calculation
        result to their counterparts in Windows CE kernel. As explained in document
        crunchlibspec.txt, hard-float functions in the DLL give results that are equal
        to those of their soft-float counterparts in the precision scope. That means
        the result of hard-float and soft-float versions are not bit-exact. Their 
        difference is within a small value, which is acceptable for the users' precision
        requirement. 
        
        The following is the summarized test result of mathtest.exe, the accruacy test
        program. In the following description, bit N refers to the Nth bit from the
        MSB. For example, bit 62 refers to the bit next to LSB.
        
        <1> ceil        The result is the same as soft-float version.
        <2> floor       The result is the same as soft-float version.
        <3> fabs        The result is the same as soft-float version.
        <4> sqrt        The difference of hard-float and soft-float result is LSB.
        <5> fmod        The result is the same as soft-float version.
        
        <6> ceilf       The result is the same as soft-float version.
        <7> floorf      The result is the same as soft-float version.
        <8> fabsf       The result is the same as soft-float version.
        <9> sqrtf       The result is the same as soft-float version.
        <10> fmodf      The result is the same as soft-float version.
        
        <11> pow        The largest difference of hard-float and soft-float result occurs 
                        at bit 54. The average difference occurs at bit 60.1171875.
        <12> log        The largest difference occurs at bit 62. The average difference
                        occurs at bit 62.87096774.
        <13> log10      The largest difference occurs at bit 62. The average difference
                        occurs at bit 62.80434783.
        <14> exp        The difference is the LSB.
        
        <15> sin        The largest difference occurs at bit 26. The worst cases occur
                        when inputs are near the product of one integer with pi. The 
                        average difference occurs at bit 61.37681159.
        <16> cos        The largest difference occurs at bit 26. The worst cases occur
                        when inputs are near the product of one odd integer with pi/2. 
                        The average difference occurs at bit 61.72881356.
        <17> tan        The largest difference occurs at bit 26. The worst cases occur
                        when inputs are near the product of one odd integer with pi/2.
                        The average difference occurs at bit 61.04081633.
        <18> asin       The largest difference occurs at bit 62. The average difference
                        occurs at bit 62.95.
        <19> acos       The largest difference occurs at bit 63. The average difference
                        occurs at bit 63.
        <20> atan       The largest difference occurs at bit 62. The average difference
                        occurs at bit 62.93442623.
        <21> atan2      The result is the same as soft-float version.
        <22> sinh       The largest difference occurs at bit 62. The average difference
                        occurs at bit 62.97752809.
        <23> cosh       The largest difference occurs at bit 63. The average difference
                        occurs at bit 63.
        <24> tanh       The largest difference occurs at bit 62. The average difference
                        occurs at bit 62.94805195.
        <25> _y0        The largest difference occurs at bit 57. The average difference
                        occurs at bit 61.75.
        <26> _y1        The largest difference occurs at bit 57. The average difference
                        occurs at bit 61.90909091.
        <27> _yn        The largest difference occurs at bit 58. The average difference
                        occurs at bit 62.56578947.


5. Exception Test

Crunch MathCo enabled.                                                                                                      
start test ceil                                                 start test ceil                                             
finished. catched 282 exceptions use __try/__except.            finished. catched 282 exceptions use __try/__except.        
		0 divide bt zero                                		0 divide bt zero                            
		282 inexact result                              		282 inexact result                          
		0 invalid operation                             		0 invalid operation                         
		0 overflow                                      		0 overflow                                  
		0 underflow                                     		0 underflow                                 
                                                                                                                            
          catched 284 lines use __try/__finally.                          catched 284 lines use __try/__finally.