1

我在程序中使用 libresample。一段时间后（大约 50 分钟），它在一个工作站的 lib 函数 lrsFilterUD() 中崩溃。

float lrsFilterUD(float Imp[],  /* impulse response */
              float ImpD[], /* impulse response deltas */
              UWORD Nwing,  /* len of one wing of filter */
              BOOL Interp,  /* Interpolate coefs using deltas? */
              float *Xp,    /* Current sample */
              double Ph,    /* Phase */
              int Inc,    /* increment (1 for right wing or -1 for left) */
              double dhb)
{
   float a;
   float *Hp, *Hdp, *End;
   float v, t;
   double Ho;

   v = 0.0; /* The output value */
   Ho = Ph*dhb;
   End = &Imp[Nwing];
   if (Inc == 1)        /* If doing right wing...              */
   {                      /* ...drop extra coeff, so when Ph is  */
      End--;            /*    0.5, we don't do too many mult's */
      if (Ph == 0)      /* If the phase is zero...           */
         Ho += dhb;     /* ...then we've already skipped the */
   }                         /*    first sample, so we must also  */
                        /*    skip ahead in Imp[] and ImpD[] */

   if (Interp)
      while ((Hp = &Imp[(int)Ho]) < End) {
         t = *Hp;       /* Get IR sample */
         Hdp = &ImpD[(int)Ho];  /* get interp bits from diff table*/
         a = Ho - floor(Ho);      /* a is logically between 0 and 1 */
         t += (*Hdp)*a; /* t is now interp'd filter coeff */
         t *= *Xp;      /* Mult coeff by input sample */
         v += t;            /* The filter output */
         Ho += dhb;     /* IR step */
         Xp += Inc;     /* Input signal step. NO CHECK ON BOUNDS */
      }
   else 
      while ((Hp = &Imp[(int)Ho]) < End) {
         dprintf("while begin: Hp = %p, *Hp = %a, (int)Ho = %d, Imp[(int)Ho] = %a, &Imp[(int)Ho] = %p", Hp, *Hp, (int)Ho, Imp[(int)Ho], &Imp[(int)Ho]);
         t = *Hp;       /* Get IR sample */
         dprintf("before t = %a, *Xp = %a, Xp = %p", t, *Xp, Xp);
         t *= *Xp;      /* Mult coeff by input sample */
         dprintf("after2 t = %a, v = %a", t, v);
         v += t;            /* The filter output */
         dprintf("v = %a", v);
         Ho += dhb;     /* IR step */
         Xp += Inc;     /* Input signal step. NO CHECK ON BOUNDS */
      }

   return v;
}

我在乘法之前和之后记录了 t、*Xp、Xp 的值：

while begin: Hp = 0xaf5daa8, *Hp = -0.009034, (int)Ho = 16384, Imp[(int)Ho] = -0.009034, &Imp[(int)Ho] = 0xaf5daa8
before multiplication t = -0.009034, *Xp = 0.000000, Xp = 0xaebe9b8
after multiplication t = nan

此代码运行多次，崩溃前有相同的 t 和 Xp 值：

before multiplication t = -0.009034, *Xp = 0.000000, Xp = 0xaebe9c8
after multiplication t = -0.000000, v = 282.423676

或另一种情况：

before addition t = -460.799988, v = 0.000000
after addition v = nan

什么可能导致nan？这是在 Linux 上使用 gcc 4.1.2 编译的。

更新：将变量打印为 %a。结果：

//t = 0x1.2806bap+2
//Hp = 0xb3bb870
t = *Hp;
//t = nan

更新 2：如果代码由 icpc 编译，则不存在此类问题。那么有编译器特定的问题吗？

4

4 回答 4

6

显然，-0.009034•0.000000 不应产生 NaN。因此，要么问题中呈现的代码和数据不能准确表示实际计算，要么计算实现存在缺陷。

如果我们假设硬件和基本计算实现没有缺陷，那么需要调查的一些可能性包括：

  • 记录t和*Xp未能记录乘法之前的正确值t和乘法之后的正确值或乘法之后的正确值。*Xpt
  • t或的值显示*Xp不正确。例如，用于显示的格式*Xp显示“0.000000”，即使*Xp有一些其他值，例如 NaN。
  • Xp指向不合适的地方，导致*Xp不可靠（例如，被外部操作更改）。
  • 显示的代码不准确。例如，它来自已更改的旧源，或者它是新源但正在执行先前编译的代码。

注意：使用浮点对象进行调试时，不应使用诸如“%f”之类的格式进行打印，尤其是不要使用位数的默认值。您应该使用“%a”打印，它使用十六进制表示打印浮点值的精确值。您也可以在许多情况下使用“%.99g”，前提是您的 C 实现提供了浮点值到十进制的良好转换。

于 2012-12-24T13:20:06.187 回答
4

Eric Postpischil的其他出色答案没有提到第五种可能性：

  • 乘法是在 x87 寄存器中执行的，并且由于程序执行中的（可能不相关的）早期操作而发生了浮点堆栈溢出。当处理器处于这种故障状态时，在 x87 寄存器上执行的所有计算都会产生 NaN 结果。

造成这种情况的两个最常见原因是调用函数返回的浮点结果在范围内没有原型（使用许多调用约定，这将导致调用者无法将结果从 FP 堆栈中弹出），以及不正确的手- 编写的（可能是内联的）程序集。

故障仅在经过一段时间后才发生的事实为这种可能性提供了一些证据；如果有一个很少使用的代码路径泄漏了浮点堆栈的一个元素，则需要在故障出现之前使用它一定次数，这可能让它直到现在才被注意到。

要诊断或排除这种可能性，您需要查看浮点状态寄存器 (FPSR) 的第 6 位 (SF)。根据您使用的编译器，检查 FPSR 的确切方法可能会有所不同。

于 2012-12-24T14:35:51.810 回答
1

从Wiki中，可以返回 NaN 的操作有以下三种：

1. Operations with a NaN as at least one operand.
2. Indeterminate forms
      The divisions 0/0 and ±∞/±∞
      The multiplications 0×±∞ and ±∞×0
      The additions ∞ + (−∞), (−∞) + ∞ and equivalent subtractions
      The standard has alternative functions for powers:
      The standard pow function and the integer exponent pown function define 0pow(0), 1pow(∞),
      and ∞pow(0) as 1.
      The powr function defines all three indeterminate forms as invalid operations and 
      so returns NaN.
3. Real operations with complex results, for example:
      The square root of a negative number.
      The logarithm of a negative number
      The inverse sine or cosine of a number that is less than −1 or greater than +1.

现在这应该可以帮助您自己解决问题。

于 2012-12-24T13:10:03.570 回答
0

您必须为每个计算打印子结果 - 或使用该isnan()功能在常规位置检查，并追踪它的来源。这要么是一些“糟糕”的数学，要么是你一开始就在喂垃圾（未初始化的变量很可能是 NaN 的）

于 2012-12-24T13:17:55.567 回答