C 只有对数底2可用时的自然对数实现

我试图用PTX实现自然对数。PTX本机仅提供实现以2为底的对数的

lg2.approx.f32

。因此，应用简单的数学方法，只需将欧拉数e的底2的对数与底2的对数相乘，就可以得到自然对数：

log_e（a）=log_2（a）/lg_2（e）

一级近似值

1/lg_2（e）

为

0.693147

。所以，我会乘以这个数字

我已经将

nvcc

的

log

函数（来自CUDA C）编译成了PTX（请在下面找到输出）。我可以看到最后乘以数值常数。但是还有很多事情要做。这重要吗？有人能解释一下为什么会有这么多的开销吗

    .entry _Z6kernelPfS_ (
        .param .u64 __cudaparm__Z6kernelPfS__out,
        .param .u64 __cudaparm__Z6kernelPfS__in)
    {
    .reg .u32 %r<13>;
    .reg .u64 %rd<4>;
    .reg .f32 %f<48>;
    .reg .pred %p<4>;
    .loc    14  3   0
$LDWbegin__Z6kernelPfS_:
    .loc    14  5   0
    ld.param.u64    %rd1, [__cudaparm__Z6kernelPfS__in];
    ld.global.f32   %f1, [%rd1+0];
    .loc    16  9365    0
    mov.f32     %f2, 0f00000000;        // 0
    set.gt.u32.f32  %r1, %f1, %f2;
    neg.s32     %r2, %r1;
    mov.f32     %f3, 0f7f800000;        // ((1.0F)/(0.0F))
    set.lt.u32.f32  %r3, %f1, %f3;
    neg.s32     %r4, %r3;
    and.b32     %r5, %r2, %r4;
    mov.u32     %r6, 0;
    setp.eq.s32     %p1, %r5, %r6;
    @%p1 bra    $Lt_0_2306;
    .loc    16  8512    0
    mov.b32     %r7, %f1;
    and.b32     %r8, %r7, -2139095041;
    or.b32  %r9, %r8, 1065353216;
    mov.b32     %f4, %r9;
    mov.f32     %f5, %f4;
    .loc    16  8513    0
    shr.u32     %r10, %r7, 23;
    sub.u32     %r11, %r10, 127;
    mov.f32     %f6, 0f3fb504f3;        // 1.41421
    setp.gt.f32     %p2, %f4, %f6;
    @!%p2 bra   $Lt_0_2562;
    .loc    16  8515    0
    mov.f32     %f7, 0f3f000000;        // 0.5
    mul.f32     %f5, %f4, %f7;
    .loc    16  8516    0
    add.s32     %r11, %r11, 1;
$Lt_0_2562:
    .loc    16  8429    0
    mov.f32     %f8, 0fbf800000;        // -1
    add.f32     %f9, %f5, %f8;
    mov.f32     %f10, 0f3f800000;       // 1
    add.f32     %f11, %f5, %f10;
    neg.f32     %f12, %f9;
    div.approx.f32  %f13, %f9, %f11;
    mul.rn.f32  %f14, %f12, %f13;
    add.rn.f32  %f15, %f9, %f14;
    mul.f32     %f16, %f15, %f15;
    mov.f32     %f17, 0f3b2063c3;       // 0.00244735
    mov.f32     %f18, %f17;
    mov.f32     %f19, %f16;
    mov.f32     %f20, 0f3c4c4be0;       // 0.0124693
    mov.f32     %f21, %f20;
    mad.f32 %f22, %f18, %f19, %f21;
    mov.f32     %f23, %f22;
    mov.f32     %f24, %f23;
    mov.f32     %f25, %f16;
    mov.f32     %f26, 0f3daaab50;       // 0.0833346
    mov.f32     %f27, %f26;
    mad.f32 %f28, %f24, %f25, %f27;
    mov.f32     %f29, %f28;
    mul.f32     %f30, %f16, %f29;
    mov.f32     %f31, %f30;
    mov.f32     %f32, %f15;
    mov.f32     %f33, %f14;
    mad.f32 %f34, %f31, %f32, %f33;
    mov.f32     %f35, %f34;
    cvt.rn.f32.s32  %f36, %r11;
    mov.f32     %f37, %f36;
    mov.f32     %f38, 0f3f317218;       // 0.693147
    mov.f32     %f39, %f38;
    add.f32     %f40, %f9, %f35;
    mov.f32     %f41, %f40;
    mad.f32 %f42, %f37, %f39, %f41;
    mov.f32     %f43, %f42;
    .loc    16  8523    0
    mov.f32     %f44, %f43;
    bra.uni     $Lt_0_2050;
$Lt_0_2306:
    .loc    16  8526    0
    lg2.approx.f32  %f45, %f1;
    mov.f32     %f46, 0f3f317218;       // 0.693147
    mul.f32     %f44, %f45, %f46;
$Lt_0_2050:
    .loc    14  5   0
    ld.param.u64    %rd2, [__cudaparm__Z6kernelPfS__out];
    st.global.f32   [%rd2+0], %f44;
    .loc    14  6   0
    exit;
$LDWend__Z6kernelPfS_:
    } // _Z6kernelPfS_

---

该函数通过将指数部分设置为1来计算浮点数的log2（有效地扩展到范围

1您可以查看logf（）的C源代码）在math_functions.h中，GPU硬件中内置的log2具有接近1.0的较大相对误差，因此使用纯软件近似值代替硬件，以在整个函数域中实现较小的ulp误差。如果只需要硬件log2加上反向乘法，请使用_logf（）而不是logf（）。好主意。我刚刚尝试了
logf
。不幸的是，PTX没有变化。似乎他们还是使用近似值。你看到在什么情况下，代码分支到“硬件lg2和反向乘法”。对我来说，这并不全面。带有两个前导下划线的\uu logf（）是“快速数学”直接映射到硬件近似值的版本。请参阅文件device_functions.h中的源代码。常规logf（）函数使用_logf（）仅处理例外情况，通过查看math_functions.h中的源代码可以很容易地看到。这两个文件在任何安装了CUDA的计算机上都很容易获得，因为CUDA标准数学库此时只是头文件的集合。是的，
\u logf（）
只生成它的硬件+乘法版本。这是标签
Lt_0_2306
之后的代码。回到我的问题：该标签的近似代码中有一个分支命令。如果Pade近似发生故障，您会说该分支被作为故障保护版本。来源：if（（a>CUDART\u ZERO\u F）&（a__global__ void kernel(float *out, float *in)
{
  *out = log( *in );
}