main.c

nios中自定义指令集实现三角函数的软件部分。

        {
          //printf("j=%d i=%d - 0x%08lX %08lX - 0x%08lX %08lX C\n", j, i, cusp_result_array[(i*2) + 1], cusp_result_array[(i*2)], calc_result_array[(i*2) + 1], calc_result_array[(i*2)]);
          count_correct++;
        }
        else
        {
          if(((cusp_result_hi & 0xFFF00000) == (calc_result_hi & 0xFFF00000)) && ((cusp_result_hi & 0x7FF00000) == 0x0))
          {
            //printf("denormal j=%d i=%d - 0x%08lX %08lX - 0x%08lX %08lX I\n", j, i, cusp_result_array[(i*2) + 1], cusp_result_array[(i*2)], calc_result_array[(i*2) + 1], calc_result_array[(i*2)]);
            denormal_result++;
            count_correct++;
          }
          else if((((cusp_result_lo - calc_result_lo) == 1) || ((calc_result_lo - cusp_result_lo) == 1)) && (cusp_result_hi == calc_result_hi))
          {
            //printf("lsb only j=%d i=%d - 0x%08lX %08lX - 0x%08lX %08lX I\n", j, i, cusp_result_array[(i*2) + 1], cusp_result_array[(i*2)], calc_result_array[(i*2) + 1], calc_result_array[(i*2)]);
            round_off_by_one++;
            count_correct++;
          }
          else
          {
            printf("swp_a=%d swp_b=%d ex_a=%ld ex_b=%ld - 0x%08lX %08lX - 0x%08lX %08lX I\n", i, j, exponent_a, exponent_b, cusp_result_hi, cusp_result_lo, calc_result_hi, calc_result_lo);
            count_incorrect++;
          }
        }
      }
    }

    printf("Correct = %d\n", count_correct);
    printf("Incorrect = %d\n", count_incorrect);
    printf("Denormal Result = %d\n", denormal_result);
    printf("Round off by one = %d\n", round_off_by_one);
#endif //MUL_TEST
#ifdef DIV_TEST
    // Division
    mantissa_a_lo = 0;
    mantissa_a_hi = 0;
    exponent_a = 0;
    sign_a = 0;
    
    mantissa_b_lo = 0;
    mantissa_b_hi = 0;
    exponent_b = 0;
    sign_b = 0;
    
    count_correct = 0;
    count_incorrect = 0;
    denormal_result = 0;
    round_off_by_one = 0;

    printf("\nDouble Precision Exponent Sweep Division Test...\n\n");
    
    for( i = 1 ; i < 0x7FF ; i++)
    {
      exponent_a = i;
      
      for( j = 1 ; j < 0x7FF ; j++)
      {
        exponent_b = j;
                
        *(my_long_ptr_to_double_operand_a) = mantissa_a_lo;
        *(my_long_ptr_to_double_operand_a + 1) = (mantissa_a_hi & 0x000FFFFF)|((exponent_a & 0x7FF)<<20)|(sign_a<<31);
        *(my_long_ptr_to_double_operand_b) = mantissa_b_lo;
        *(my_long_ptr_to_double_operand_b + 1) = (mantissa_b_hi & 0x000FFFFF)|((exponent_b & 0x7FF)<<20)|(sign_b<<31);
        
        double_result = double_operand_a / double_operand_b;
  
        calc_result_lo = *(my_long_ptr_to_double_result);
        calc_result_hi = *(my_long_ptr_to_double_result + 1);
        
        double_result = dpfp_hw_division(double_operand_a, double_operand_b);
        
        cusp_result_lo = *(my_long_ptr_to_double_result);
        cusp_result_hi = *(my_long_ptr_to_double_result + 1);
    
        if((cusp_result_lo == calc_result_lo) && (cusp_result_hi == calc_result_hi))
        {
          //printf("j=%d i=%d - 0x%08lX %08lX - 0x%08lX %08lX C\n", j, i, cusp_result_array[(i*2) + 1], cusp_result_array[(i*2)], calc_result_array[(i*2) + 1], calc_result_array[(i*2)]);
          count_correct++;
        }
        else
        {
          if(((cusp_result_hi & 0xFFF00000) == (calc_result_hi & 0xFFF00000)) && ((cusp_result_hi & 0x7FF00000) == 0x0))
          {
            //printf("denormal j=%d i=%d - 0x%08lX %08lX - 0x%08lX %08lX I\n", j, i, cusp_result_array[(i*2) + 1], cusp_result_array[(i*2)], calc_result_array[(i*2) + 1], calc_result_array[(i*2)]);
            denormal_result++;
            count_correct++;
          }
          else if((((cusp_result_lo - calc_result_lo) == 1) || ((calc_result_lo - cusp_result_lo) == 1)) && (cusp_result_hi == calc_result_hi))
          {
            //printf("lsb only j=%d i=%d - 0x%08lX %08lX - 0x%08lX %08lX I\n", j, i, cusp_result_array[(i*2) + 1], cusp_result_array[(i*2)], calc_result_array[(i*2) + 1], calc_result_array[(i*2)]);
            round_off_by_one++;
            count_correct++;
          }
          else
          {
            printf("swp_a=%d swp_b=%d ex_a=%ld ex_b=%ld - 0x%08lX %08lX - 0x%08lX %08lX I\n", i, j, exponent_a, exponent_b, cusp_result_hi, cusp_result_lo, calc_result_hi, calc_result_lo);
            count_incorrect++;
          }
        }
      }
    }

    printf("Correct = %d\n", count_correct);
    printf("Incorrect = %d\n", count_incorrect);
    printf("Denormal Result = %d\n", denormal_result);
    printf("Round off by one = %d\n", round_off_by_one);
#endif //DIV_TEST    
#endif //EXPONENT_SWEEP_TEST
#ifdef MANTISSA_SWEEP_TEST
// full mantissa sweep tests with exponent 0x3FF
#ifdef ADD_TEST
    // addition
    mantissa_a_lo = 0;
    mantissa_a_hi = 0;
    exponent_a = 0x3FF;
    sign_a = 0;
    
    mantissa_b_lo = 0;
    mantissa_b_hi = 0;
    exponent_b = 0x3FF;
    sign_b = 0;
    
    count_correct = 0;
    count_incorrect = 0;
    denormal_result = 0;
    round_off_by_one = 0;

    printf("\nDouble Precision Mantissa Sweep Addition Test...\n\n");
    
    for(sweep_index_a = 0 ; sweep_index_a < SWEEP_ARRAY_SIZE_IN_DOUBLES ; sweep_index_a++)
    {
      mantissa_a_hi = my_double_mantissa_sweep_array[(sweep_index_a * 2)];
      mantissa_a_lo = my_double_mantissa_sweep_array[(sweep_index_a * 2) + 1];
      
      for(sweep_index_b = 0 ; sweep_index_b < SWEEP_ARRAY_SIZE_IN_DOUBLES ; sweep_index_b++)
      {
        mantissa_b_hi = my_double_mantissa_sweep_array[(sweep_index_b * 2)];
        mantissa_b_lo = my_double_mantissa_sweep_array[(sweep_index_b * 2) + 1];
                      
        *(my_long_ptr_to_double_operand_a) = mantissa_a_lo;
        *(my_long_ptr_to_double_operand_a + 1) = (mantissa_a_hi & 0x000FFFFF)|((exponent_a & 0x7FF)<<20)|(sign_a<<31);
        *(my_long_ptr_to_double_operand_b) = mantissa_b_lo;
        *(my_long_ptr_to_double_operand_b + 1) = (mantissa_b_hi & 0x000FFFFF)|((exponent_b & 0x7FF)<<20)|(sign_b<<31);
        
        double_result = double_operand_a + double_operand_b;
  
        calc_result_lo = *(my_long_ptr_to_double_result);
        calc_result_hi = *(my_long_ptr_to_double_result + 1);
        
        double_result = dpfp_hw_addition(double_operand_a, double_operand_b);
        
        cusp_result_lo = *(my_long_ptr_to_double_result);
        cusp_result_hi = *(my_long_ptr_to_double_result + 1);
    
        if((cusp_result_lo == calc_result_lo) && (cusp_result_hi == calc_result_hi))
        {
          //printf("j=%d i=%d - 0x%08lX %08lX - 0x%08lX %08lX C\n", j, i, cusp_result_array[(i*2) + 1], cusp_result_array[(i*2)], calc_result_array[(i*2) + 1], calc_result_array[(i*2)]);
          count_correct++;
        }
        else
        {
          if(((cusp_result_hi & 0xFFF00000) == (calc_result_hi & 0xFFF00000)) && ((cusp_result_hi & 0x7FF00000) == 0x0))
          {
            //printf("denormal j=%d i=%d - 0x%08lX %08lX - 0x%08lX %08lX I\n", j, i, cusp_result_array[(i*2) + 1], cusp_result_array[(i*2)], calc_result_array[(i*2) + 1], calc_result_array[(i*2)]);
            denormal_result++;
            count_correct++;
          }
          else if((((cusp_result_lo - calc_result_lo) == 1) || ((calc_result_lo - cusp_result_lo) == 1)) && (cusp_result_hi == calc_result_hi))
          {
            //printf("lsb only j=%d i=%d - 0x%08lX %08lX - 0x%08lX %08lX I\n", j, i, cusp_result_array[(i*2) + 1], cusp_result_array[(i*2)], calc_result_array[(i*2) + 1], calc_result_array[(i*2)]);
            round_off_by_one++;
            count_correct++;
          }
          else
          {
            printf("swp_a=%ld swp_b=%ld ex_a=%ld ex_b=%ld - 0x%08lX %08lX - 0x%08lX %08lX I\n", sweep_index_a, sweep_index_b, exponent_a, exponent_b, cusp_result_hi, cusp_result_lo, calc_result_hi, calc_result_lo);
            count_incorrect++;
          }
        }
      }
    }

    printf("Correct = %d\n", count_correct);
    printf("Incorrect = %d\n", count_incorrect);
    printf("Denormal Result = %d\n", denormal_result);
    printf("Round off by one = %d\n", round_off_by_one);
#endif //ADD_TEST
#ifdef SUB_TEST
    // subtraction
    mantissa_a_lo = 0;
    mantissa_a_hi = 0;
    exponent_a = 0x3FF;
    sign_a = 0;
    
    mantissa_b_lo = 0;
    mantissa_b_hi = 0;
    exponent_b = 0x3FF;
    sign_b = 0;
    
    count_correct = 0;
    count_incorrect = 0;
    denormal_result = 0;
    round_off_by_one = 0;

    printf("\nDouble Precision Mantissa Sweep Subtraction Test...\n\n");
    
    for(sweep_index_a = 0 ; sweep_index_a < SWEEP_ARRAY_SIZE_IN_DOUBLES ; sweep_index_a++)
    {
      mantissa_a_hi = my_double_mantissa_sweep_array[(sweep_index_a * 2)];
      mantissa_a_lo = my_double_mantissa_sweep_array[(sweep_index_a * 2) + 1];
      
      for(sweep_index_b = 0 ; sweep_index_b < SWEEP_ARRAY_SIZE_IN_DOUBLES ; sweep_index_b++)
      {
        mantissa_b_hi = my_double_mantissa_sweep_array[(sweep_index_b * 2)];
        mantissa_b_lo = my_double_mantissa_sweep_array[(sweep_index_b * 2) + 1];
                      
        *(my_long_ptr_to_double_operand_a) = mantissa_a_lo;
        *(my_long_ptr_to_double_operand_a + 1) = (mantissa_a_hi & 0x000FFFFF)|((exponent_a & 0x7FF)<<20)|(sign_a<<31);
        *(my_long_ptr_to_double_operand_b) = mantissa_b_lo;
        *(my_long_ptr_to_double_operand_b + 1) = (mantissa_b_hi & 0x000FFFFF)|((exponent_b & 0x7FF)<<20)|(sign_b<<31);
        
        double_result = double_operand_a - double_operand_b;
  
        calc_result_lo = *(my_long_ptr_to_double_result);
        calc_result_hi = *(my_long_ptr_to_double_result + 1);
        
        double_result = dpfp_hw_subtraction(double_operand_a, double_operand_b);
        
        cusp_result_lo = *(my_long_ptr_to_double_result);
        cusp_result_hi = *(my_long_ptr_to_double_result + 1);
    
        if((cusp_result_lo == calc_result_lo) && (cusp_result_hi == calc_result_hi))
        {
          //printf("j=%d i=%d - 0x%08lX %08lX - 0x%08lX %08lX C\n", j, i, cusp_result_array[(i*2) + 1], cusp_result_array[(i*2)], calc_result_array[(i*2) + 1], calc_result_array[(i*2)]);
          count_correct++;
        }
        else
        {
          if(((cusp_result_hi & 0xFFF00000) == (calc_result_hi & 0xFFF00000)) && ((cusp_result_hi & 0x7FF00000) == 0x0))
          {
            //printf("denormal j=%d i=%d - 0x%08lX %08lX - 0x%08lX %08lX I\n", j, i, cusp_result_array[(i*2) + 1], cusp_result_array[(i*2)], calc_result_array[(i*2) + 1], calc_result_array[(i*2)]);
            denormal_result++;
            count_correct++;
          }
          else if((((cusp_result_lo - calc_result_lo) == 1) || ((calc_result_lo - cusp_result_lo) == 1)) && (cusp_result_hi == calc_result_hi))
          {
            //printf("lsb only j=%d i=%d - 0x%08lX %08lX - 0x%08lX %08lX I\n", j, i, cusp_result_array[(i*2) + 1], cusp_result_array[(i*2)], calc_result_array[(i*2) + 1], calc_result_array[(i*2)]);
            round_off_by_one++;
            count_correct++;
          }
          else
          {
            printf("swp_a=%ld swp_b=%ld ex_a=%ld ex_b=%ld - 0x%08lX %08lX - 0x%08lX %08lX I\n", sweep_index_a, sweep_index_b, exponent_a, exponent_b, cusp_result_hi, cusp_result_lo, calc_result_hi, calc_result_lo);
            count_incorrect++;
          }
        }
      }
    }

    printf("Correct = %d\n", count_correct);
    printf("Incorrect = %d\n", count_incorrect);
    printf("Denormal Result = %d\n", denormal_result);
    printf("Round off by one = %d\n", round_off_by_one);
#endif //SUB_TEST
#ifdef MUL_TEST
    // multiplication
    mantissa_a_lo = 0;
    mantissa_a_hi = 0;
    exponent_a = 0x3FF;
    sign_a = 0;
    
    mantissa_b_lo = 0;
    mantissa_b_hi = 0;
    exponent_b = 0x3FF;
    sign_b = 0;
    
    count_correct = 0;
    count_incorrect = 0;
    denormal_result = 0;
    round_off_by_one = 0;

    printf("\nDouble Precision Mantissa Sweep Multicplication Test...\n\n");
    
    for(sweep_index_a = 0 ; sweep_index_a < SWEEP_ARRAY_SIZE_IN_DOUBLES ; sweep_index_a++)
    {
      mantissa_a_hi = my_double_mantissa_sweep_array[(sweep_index_a * 2)];
      mantissa_a_lo = my_double_mantissa_sweep_array[(sweep_index_a * 2) + 1];
      
      for(sweep_index_b = 0 ; sweep_index_b < SWEEP_ARRAY_SIZE_IN_DOUBLES ; sweep_index_b++)
      {
        mantissa_b_hi = my_double_mantissa_sweep_array[(sweep_index_b * 2)];
        mantissa_b_lo = my_double_mantissa_sweep_array[(sweep_index_b * 2) + 1];
        
        *(my_long_ptr_to_double_operand_a) = mantissa_a_lo;
        *(my_long_ptr_to_double_operand_a + 1) = (mantissa_a_hi & 0x000FFFFF)|((exponent_a & 0x7FF)<<20)|(sign_a<<31);
        *(my_long_ptr_to_double_operand_b) = mantissa_b_lo;
        *(my_long_ptr_to_double_operand_b + 1) = (mantissa_b_hi & 0x000FFFFF)|((exponent_b & 0x7FF)<<20)|(sign_b<<31);
        
        double_result = double_operand_a * double_operand_b;
  
        calc_result_lo = *(my_long_ptr_to_double_result);
        calc_result_hi = *(my_long_ptr_to_double_result + 1);
        
        double_result = dpfp_hw_multiplication(double_operand_a, double_operand_b);
        
        cusp_result_lo = *(my_long_ptr_to_double_result);
        cusp_result_hi = *(my_long_ptr_to_double_result + 1);
    
        if((cusp_result_lo == calc_result_lo) && (cusp_result_hi == calc_result_hi))
        {
          //printf("j=%d i=%d - 0x%08lX %08lX - 0x%08lX %08lX C\n", j, i, cusp_result_array[(i*2) + 1], cusp_result_array[(i*2)], calc_result_array[(i*2) + 1], calc_result_array[(i*2)]);
          count_correct++;
        }
        else
        {
          if(((cusp_result_hi & 0xFFF00000) == (calc_result_hi & 0xFFF00000)) && ((cusp_result_hi & 0x7FF00000) == 0x0))
          {
            //printf("denormal j=%d i=%d - 0x%08lX %08lX - 0x%08lX %08lX I\n", j, i, cusp_result_array[(i*2) + 1], cusp_result_array[(i*2)], calc_result_array[(i*2) + 1], calc_result_array[(i*2)]);
            denormal_result++;
            count_correct++;
          }
          else if((((cusp_result_lo - calc_result_lo) == 1) || ((calc_result_lo - cusp_result_lo) == 1)) && (cusp_result_hi == calc_result_hi))
          {