c++ - 为什么 _umul128 的工作速度比 mul128x64x2 函数的标量代码慢？-6ren

c++ - 为什么 _umul128 的工作速度比 mul128x64x2 函数的标量代码慢？

转载作者：塔克拉玛干更新时间：2023-11-03 01:41:26

我第二次尝试实现快速 mul128x64x2 功能。 First time I ask the question 与 _umul128 MSVC 版本没有比较。现在我做了这样的比较，我得到的结果表明 _umul128 函数比原生标量和手工 simd AVX 1.0 代码慢。

在我的测试代码下面:

#include <iostream>
#include <chrono>

#include <intrin.h>
#include <emmintrin.h>
#include <immintrin.h>

#pragma intrinsic(_umul128)

constexpr uint32_t LOW[4] = { 4294967295u, 0u, 4294967295u, 0u };

__forceinline void multiply128x128( const uint32_t ABCD[4], const uint32_t EFGH[4], uint32_t OUT[2][4] ) noexcept
{
    __m128i L  = _mm_lddqu_si128( reinterpret_cast< __m128i const* >( LOW ) );
    __m128i IN = _mm_lddqu_si128( reinterpret_cast< __m128i const* >( EFGH ) );

    __m128i A  = _mm_set1_epi32( ABCD[0] );
    __m128i B  = _mm_set1_epi32( ABCD[1] );
    __m128i C  = _mm_set1_epi32( ABCD[2] );
    __m128i D  = _mm_set1_epi32( ABCD[3] );

    __m128i ED = _mm_mul_epu32( IN, D );
    __m128i EC = _mm_mul_epu32( IN, C );
    __m128i EB = _mm_mul_epu32( IN, B );
    __m128i EA = _mm_mul_epu32( IN, A );

    IN = _mm_srli_epi64( IN, 32 );

    __m128i FD = _mm_mul_epu32( IN, D );
    __m128i FC = _mm_mul_epu32( IN, C );
    __m128i FB = _mm_mul_epu32( IN, B );
    __m128i FA = _mm_mul_epu32( IN, A );

    __m128i FD_H = _mm_srli_epi64( FD, 32 );
    __m128i FD_L = _mm_and_si128 ( L, FD );

    __m128i FC_H = _mm_srli_epi64( FC, 32 );
    __m128i FC_L = _mm_and_si128 ( L, FC );

    __m128i FB_H = _mm_srli_epi64( FB, 32 );
    __m128i FB_L = _mm_and_si128 ( L, FB );

    __m128i FA_H = _mm_srli_epi64( FA, 32 );
    __m128i FA_L = _mm_and_si128 ( L, FA );

    __m128i ED_H = _mm_srli_epi64( ED, 32 );
    __m128i ED_L = _mm_and_si128 ( L, ED );

    __m128i EC_H = _mm_srli_epi64( EC, 32 );
    __m128i EC_L = _mm_and_si128 ( L, EC );

    __m128i EB_H = _mm_srli_epi64( EB, 32 );
    __m128i EB_L = _mm_and_si128 ( L, EB );

    __m128i EA_H = _mm_srli_epi64( EA, 32 );
    __m128i EA_L = _mm_and_si128 ( L, EA );

    __m128i SUM_FC_L_FD_H = _mm_add_epi64( FC_L, FD_H );
    __m128i SUM_FB_L_FC_H = _mm_add_epi64( FB_L, FC_H );
    __m128i SUM_FA_L_FB_H = _mm_add_epi64( FA_L, FB_H );

    __m128i SUM_EC_L_ED_H = _mm_add_epi64( EC_L, ED_H );
    __m128i SUM_EB_L_EC_H = _mm_add_epi64( EB_L, EC_H );
    __m128i SUM_EA_L_EB_H = _mm_add_epi64( EA_L, EB_H );

    __m128i SUM_FC_L_FD_H_ED_L         = _mm_add_epi64( SUM_FC_L_FD_H, ED_L );
    __m128i SUM_FB_L_FC_H_EC_L_ED_H    = _mm_add_epi64( SUM_FB_L_FC_H, SUM_EC_L_ED_H );
    __m128i SUM_FA_L_FB_H_EB_L_EC_H    = _mm_add_epi64( SUM_FA_L_FB_H, SUM_EB_L_EC_H );
    __m128i SUM_FA_H_EA_L_EB_H         = _mm_add_epi64( FA_H, SUM_EA_L_EB_H );

    __m128i SUM_FC_L_FD_H_ED_L_L       = _mm_srli_epi64( SUM_FC_L_FD_H_ED_L, 32 );
            SUM_FC_L_FD_H_ED_L_L       = _mm_add_epi64 ( SUM_FC_L_FD_H_ED_L_L, SUM_FB_L_FC_H_EC_L_ED_H );

    __m128i SUM_FC_L_FD_H_ED_L_L_L     = _mm_srli_epi64( SUM_FC_L_FD_H_ED_L_L, 32 );
            SUM_FC_L_FD_H_ED_L_L_L     = _mm_add_epi64 ( SUM_FC_L_FD_H_ED_L_L_L, SUM_FA_L_FB_H_EB_L_EC_H );

    __m128i SUM_FC_L_FD_H_ED_L_L_L_L   = _mm_srli_epi64( SUM_FC_L_FD_H_ED_L_L_L, 32 );
            SUM_FC_L_FD_H_ED_L_L_L_L   = _mm_add_epi64 ( SUM_FC_L_FD_H_ED_L_L_L_L, SUM_FA_H_EA_L_EB_H );

    __m128i SUM_FC_L_FD_H_ED_L_L_L_L_L = _mm_srli_epi64( SUM_FC_L_FD_H_ED_L_L_L_L, 32 );
            SUM_FC_L_FD_H_ED_L_L_L_L_L = _mm_add_epi64 ( SUM_FC_L_FD_H_ED_L_L_L_L_L, EA_H );

    OUT[0][0] = SUM_FC_L_FD_H_ED_L_L_L_L_L.m128i_u32[0];
    OUT[0][1] = SUM_FC_L_FD_H_ED_L_L_L_L.m128i_u32[0];
    OUT[0][2] = SUM_FC_L_FD_H_ED_L_L_L.m128i_u32[0];
    OUT[0][3] = SUM_FC_L_FD_H_ED_L_L.m128i_u32[0];

    OUT[1][0] = SUM_FC_L_FD_H_ED_L_L_L_L_L.m128i_u32[2];
    OUT[1][1] = SUM_FC_L_FD_H_ED_L_L_L_L.m128i_u32[2];
    OUT[1][2] = SUM_FC_L_FD_H_ED_L_L_L.m128i_u32[2];
    OUT[1][3] = SUM_FC_L_FD_H_ED_L_L.m128i_u32[2];
}


__forceinline void multiply128x128_1( const uint32_t ABCD[4], const uint32_t EFGH[4], uint32_t OUT[2][4] ) noexcept
{
    uint64_t ED = static_cast<uint64_t>( ABCD[3] ) * static_cast<uint64_t>( EFGH[0] );
    uint64_t EC = static_cast<uint64_t>( ABCD[2] ) * static_cast<uint64_t>( EFGH[0] );
    uint64_t EB = static_cast<uint64_t>( ABCD[1] ) * static_cast<uint64_t>( EFGH[0] );
    uint64_t EA = static_cast<uint64_t>( ABCD[0] ) * static_cast<uint64_t>( EFGH[0] );

    uint64_t FD = static_cast<uint64_t>( ABCD[3] ) * static_cast<uint64_t>( EFGH[1] );
    uint64_t FC = static_cast<uint64_t>( ABCD[2] ) * static_cast<uint64_t>( EFGH[1] );
    uint64_t FB = static_cast<uint64_t>( ABCD[1] ) * static_cast<uint64_t>( EFGH[1] );
    uint64_t FA = static_cast<uint64_t>( ABCD[0] ) * static_cast<uint64_t>( EFGH[1] );

    uint64_t GD = static_cast<uint64_t>( ABCD[3] ) * static_cast<uint64_t>( EFGH[2] );
    uint64_t GC = static_cast<uint64_t>( ABCD[2] ) * static_cast<uint64_t>( EFGH[2] );
    uint64_t GB = static_cast<uint64_t>( ABCD[1] ) * static_cast<uint64_t>( EFGH[2] );
    uint64_t GA = static_cast<uint64_t>( ABCD[0] ) * static_cast<uint64_t>( EFGH[2] );

    uint64_t HD = static_cast<uint64_t>( ABCD[3] ) * static_cast<uint64_t>( EFGH[3] );
    uint64_t HC = static_cast<uint64_t>( ABCD[2] ) * static_cast<uint64_t>( EFGH[3] );
    uint64_t HB = static_cast<uint64_t>( ABCD[1] ) * static_cast<uint64_t>( EFGH[3] );
    uint64_t HA = static_cast<uint64_t>( ABCD[0] ) * static_cast<uint64_t>( EFGH[3] );

    uint64_t SUM_FC_L_FD_H = ( FC & 0xFFFFFFFF ) + ( FD >> 32u );
    uint64_t SUM_FB_L_FC_H = ( FB & 0xFFFFFFFF ) + ( FC >> 32u );
    uint64_t SUM_FA_L_FB_H = ( FA & 0xFFFFFFFF ) + ( FB >> 32u );

    uint64_t SUM_EC_L_ED_H = ( EC & 0xFFFFFFFF ) + ( ED >> 32u );
    uint64_t SUM_EB_L_EC_H = ( EB & 0xFFFFFFFF ) + ( EC >> 32u );
    uint64_t SUM_EA_L_EB_H = ( EA & 0xFFFFFFFF ) + ( EB >> 32u );

    uint64_t SUM_HC_L_HD_H = ( HC & 0xFFFFFFFF ) + ( HD >> 32u );
    uint64_t SUM_HB_L_HC_H = ( HB & 0xFFFFFFFF ) + ( HC >> 32u );
    uint64_t SUM_HA_L_HB_H = ( HA & 0xFFFFFFFF ) + ( HB >> 32u );

    uint64_t SUM_GC_L_GD_H = ( GC & 0xFFFFFFFF ) + ( GD >> 32u );
    uint64_t SUM_GB_L_GC_H = ( GB & 0xFFFFFFFF ) + ( GC >> 32u );
    uint64_t SUM_GA_L_GB_H = ( GA & 0xFFFFFFFF ) + ( GB >> 32u );

    uint64_t SUM_FC_L_FD_H_ED_L         = SUM_FC_L_FD_H + ( ED & 0xFFFFFFFF );
    uint64_t SUM_FB_L_FC_H_EC_L_ED_H    = SUM_FB_L_FC_H + SUM_EC_L_ED_H;
    uint64_t SUM_FA_L_FB_H_EB_L_EC_H    = SUM_FA_L_FB_H + SUM_EB_L_EC_H;
    uint64_t SUM_FA_H_EA_L_EB_H         = SUM_EA_L_EB_H + ( FA >> 32u );

    uint64_t SUM_FC_L_FD_H_ED_L_L       = ( SUM_FC_L_FD_H_ED_L       >> 32u ) + SUM_FB_L_FC_H_EC_L_ED_H;
    uint64_t SUM_FC_L_FD_H_ED_L_L_L     = ( SUM_FC_L_FD_H_ED_L_L     >> 32u ) + SUM_FA_L_FB_H_EB_L_EC_H;
    uint64_t SUM_FC_L_FD_H_ED_L_L_L_L   = ( SUM_FC_L_FD_H_ED_L_L_L   >> 32u ) + SUM_FA_H_EA_L_EB_H;
    uint64_t SUM_FC_L_FD_H_ED_L_L_L_L_L = ( SUM_FC_L_FD_H_ED_L_L_L_L >> 32u ) + ( EA >> 32u );

    uint64_t SUM_HC_L_HD_H_GD_L         = SUM_HC_L_HD_H + ( GD & 0xFFFFFFFF );
    uint64_t SUM_HB_L_HC_H_GC_L_GD_H    = SUM_HB_L_HC_H + SUM_GC_L_GD_H;
    uint64_t SUM_HA_L_HB_H_GB_L_GC_H    = SUM_HA_L_HB_H + SUM_GB_L_GC_H;
    uint64_t SUM_HA_H_GA_L_GB_H         = SUM_GA_L_GB_H + ( HA >> 32u );

    uint64_t SUM_HC_L_HD_H_GD_L_L       = ( SUM_HC_L_HD_H_GD_L       >> 32u ) + SUM_HB_L_HC_H_GC_L_GD_H;
    uint64_t SUM_HC_L_HD_H_GD_L_L_L     = ( SUM_HC_L_HD_H_GD_L_L     >> 32u ) + SUM_HA_L_HB_H_GB_L_GC_H;
    uint64_t SUM_HC_L_HD_H_GD_L_L_L_L   = ( SUM_HC_L_HD_H_GD_L_L_L   >> 32u ) + SUM_HA_H_GA_L_GB_H;
    uint64_t SUM_HC_L_HD_H_GD_L_L_L_L_L = ( SUM_HC_L_HD_H_GD_L_L_L_L >> 32u ) + ( GA >> 32u );

    OUT[0][0] = SUM_FC_L_FD_H_ED_L_L_L_L_L;
    OUT[0][1] = SUM_FC_L_FD_H_ED_L_L_L_L;
    OUT[0][2] = SUM_FC_L_FD_H_ED_L_L_L;
    OUT[0][3] = SUM_FC_L_FD_H_ED_L_L;

    OUT[1][0] = SUM_HC_L_HD_H_GD_L_L_L_L_L;
    OUT[1][1] = SUM_HC_L_HD_H_GD_L_L_L_L;
    OUT[1][2] = SUM_HC_L_HD_H_GD_L_L_L;
    OUT[1][3] = SUM_HC_L_HD_H_GD_L_L;
}


__forceinline void mulShift( const uint64_t* const m, const uint64_t* const mul , uint32_t OUT[2][4]) noexcept
{
    uint64_t B0[2];
    uint64_t B2[2];

    {
        B0[0] = _umul128( m[1], mul[0], &B0[1] );
        B2[0] = _umul128( m[0], mul[0], &B2[1] );

        uint64_t S = B0[1] + B2[0];

        OUT[0][2] = S >> 32;
        OUT[0][3] = S & 0xFFFFFFFF;

        uint64_t M = B2[1] + ( S < B2[0] );

        OUT[0][1] = M & 0xFFFFFFFF;
        OUT[0][0] = M >> 32;
    }

    {
        B0[0] = _umul128( m[1], mul[1], &B0[1] );
        B2[0] = _umul128( m[0], mul[1], &B2[1] );

        uint64_t S = B0[1] + B2[0];

        OUT[1][2] = S >> 32;
        OUT[1][3] = S & 0xFFFFFFFF;

        uint64_t M = B2[1] + ( S < B2[0] );

        OUT[1][1] = M & 0xFFFFFFFF;
        OUT[1][0] = M >> 32;
    }
}


constexpr uint32_t N = 1 << 28;

int main()
{
    uint32_t OUT[2][4];

    uint32_t ABCD[4] = { 4294967295u, 4294967295u, 4294967295u, 4294967295u };
    uint32_t EFGH[4] = { 4294967295u, 4294967295u, 4294967295u, 4294967295u };

    multiply128x128_1( ABCD, EFGH, OUT );

    uint64_t S_1 = 0u;
    uint64_t S_2 = 0u;
    uint64_t S_3 = 0u;

    auto start_1 = std::chrono::high_resolution_clock::now();

    for ( uint32_t i = 0; i < N; ++i )
    {
        EFGH[0] = i;
        EFGH[1] = i;
        EFGH[2] = i + 1;
        EFGH[3] = i + 1;

        ABCD[0] = i;
        ABCD[1] = i;
        ABCD[2] = i + 1;
        ABCD[3] = i + 1;

        multiply128x128( ABCD, EFGH, OUT );

        S_1 += OUT[0][0] + OUT[0][1] + OUT[0][2] + OUT[0][3];
        S_1 += OUT[1][0] + OUT[1][1] + OUT[1][2] + OUT[1][3];
    }

    auto stop_1 = std::chrono::high_resolution_clock::now();
    std::cout << "Test A: " << std::chrono::duration_cast<std::chrono::milliseconds>( stop_1 - start_1 ).count() << '\n';

    auto start_2 = std::chrono::high_resolution_clock::now();


    for ( uint32_t i = 0; i < N; ++i )
    {
        EFGH[0] = i;
        EFGH[1] = i;
        EFGH[2] = i + 1;
        EFGH[3] = i + 1;

        ABCD[0] = i;
        ABCD[1] = i;
        ABCD[2] = i + 1;
        ABCD[3] = i + 1;

       mulShift( reinterpret_cast<const uint64_t*>( ABCD ), reinterpret_cast<const uint64_t*>( EFGH ), OUT );
       S_2 += OUT[0][0] + OUT[0][1] + OUT[0][2] + OUT[0][3];
       S_2 += OUT[1][0] + OUT[1][1] + OUT[1][2] + OUT[1][3];
    }

    auto stop_2 = std::chrono::high_resolution_clock::now();
    std::cout << "Test B: " << std::chrono::duration_cast<std::chrono::milliseconds>( stop_2 - start_2 ).count() << '\n';


    auto start_3 = std::chrono::high_resolution_clock::now();

    for ( uint32_t i = 0; i < N; ++i )
    {
        EFGH[0] = i;
        EFGH[1] = i;
        EFGH[2] = i + 1;
        EFGH[3] = i + 1;

        ABCD[0] = i;
        ABCD[1] = i;
        ABCD[2] = i + 1;
        ABCD[3] = i + 1;

        multiply128x128_1( ABCD, EFGH, OUT );

        S_3 += OUT[0][0] + OUT[0][1] + OUT[0][2] + OUT[0][3];
        S_3 += OUT[1][0] + OUT[1][1] + OUT[1][2] + OUT[1][3];
    }

    auto stop_3 = std::chrono::high_resolution_clock::now();
    std::cout << "Test C: " << std::chrono::duration_cast<std::chrono::milliseconds>( stop_3 - start_3 ).count() << '\n';

    std::cout << S_1 << " " << S_2 << " " <<  S_3 << '\n';
}

为什么_umul128 这么慢？也许我在上面的测试代码中犯了一些错误？

我的结果:
测试 A (simd):4546 毫秒。
测试 B (_umul128):6637 毫秒。
测试 C(标量):2333 毫秒。

在 Windows 10、x64、MSVC 2019 上测试

最佳答案

_umul128 版本并没有那么慢 但是你通过摆弄 32 位数组，使 MSVC 发出可怕的 asm，从而使存储转发停止。

优化正在击败您的基准；纯 C 版本并没有那么快。

特别是对于简单的输入数据:

       ABCD[0] = EFGH[0] = i;
       ABCD[1] = EFGH[1] = i;
       ABCD[2] = EFGH[2] = i + 1;
       ABCD[3] = EFGH[3] = i + 1;

内联纯 C 版本后，像这样初始化两个输入会产生大量优化机会。 i*i 4 次， i*(i+1) = i*i + i 8 次， (i+1)*(i+1) 4 次。 MSVC 并不愚蠢，并注意到了这一点。 这称为 Common Subexpression Elimination (CSE)。

如果您想了解纯 C 的实际速度有多慢，您需要想出一种更复杂的方法来伪造输入。也许提前生成然后循环包含输入的内存？从循环计数器设置输入的成本几乎与乘法一样多。

MSVC 的 asm 输出证实了大部分工作都针对纯 C 版本进行了优化。 ( Godbolt with MSVC 19.22 for x64 )

   ...
$LL10@main:
        lea     r15, QWORD PTR [rax+1]
        mov     rcx, r15
        mov     r9, r15
        imul    rcx, rax               # only 3, not 16, imul instructions.
        imul    rax, rax               # (None appear later in this loop in the ... part)
        imul    r9, r15
        mov     edi, ecx
        mov     r14, rcx
        mov     r8d, eax
        shr     r14, 32                             ; 00000020H
        shr     rax, 32                             ; 00000020H
     ...
        sub     r13, 1
        jne     $LL10@main

MSVC 不擅长优化内部函数 并且执行所有 4 条 mul m64 指令，而不是注意到 ii * i1i1 执行了两次。

更重要的是， _umul128 循环受到存储转发停顿 的影响，因为它实际上将您的数组存储到具有 32 位存储的内存中，然后使用 64 位加载来提供 mul m64 。

此外，处理 32 位块中的输出只会让你自己受不了，引入额外的移位和 mov 操作。

这并不复杂，实际上只需要 3 条指令， mul r64 和 imul r64, r64 加上一个用于上半部分的 add，就是所需要的。 GCC/clang 很容易发出正确的信息，x86-64 System V 调用约定可以在寄存器中返回 128 位 int。

在 Godbolt 上:https://godbolt.org/z/DcZhSl

#include <stdint.h>
#ifdef __GNUC__
typedef unsigned __int128 u128;

u128 mul128x64( u128 a, uint64_t b) {
    return a * b;
}
#endif

# clang -O3 for the x86-64 System V ABI (Linux)
mul128x64(unsigned __int128, unsigned long):                         # 
    mov     rax, rdi
    imul    rsi, rdx
    mul     rdx
    add     rdx, rsi
    ret

对于 MSVC，我们必须自己做，调用约定意味着结果在内存中返回。

#ifdef _MSC_VER
#include <intrin.h>

struct u128 { uint64_t u64[2]; };
u128 mul128x64( uint64_t a_lo, uint64_t a_hi, uint64_t b)
{
    uint64_t lolo_high;
    uint64_t lolo = _umul128( a_lo, b, &lolo_high );
    uint64_t lohi = a_hi * b;
    return {{lolo, lohi + lolo_high}};
}
#endif

# MSVC x64 -O2 
u128 mul128x64(unsigned __int64,unsigned __int64,unsigned __int64) PROC
    mov     rax, r9
    mul     rdx
    imul    r8, r9
    mov     QWORD PTR [rcx], rax         # store the retval into hidden pointer
    mov     rax, rcx
    add     r8, rdx
    mov     QWORD PTR [rcx+8], r8
    ret     0

您的 __m128i 内在函数版本不太可能获胜 。现代 x86(主流 Intel SnB 系列，AMD Ryzen)对 mul 和 imul 具有 1/clock 的吞吐量。 (除了 Ryzen，其中扩大 i/mul r64 的吞吐量为 2c，但 imul r64,r64 仍为 1/clock 。)

因此，如果您在像这样编译为 asm 的 C 中实现，则 Sandybridge 系列上 64 x 128 位乘法的总吞吐量为每 2 个周期一个(瓶颈在端口 1)。

鉴于您需要超过 4 个 pmuludq 指令来实现乘法，AVX1 是一个非入门者。 (Skylake 的 pmuludq 吞吐量为 0.5c。Sandybridge 的吞吐量为 1c，因此您需要在每次乘法(平均)2 个 pmuludq insns 中完成工作才能与标量竞争。而且这还没有考虑所有的移位/洗牌/添加工作这需要做。

可能值得考虑推土机系列，其中 64 位标量乘法是 4c 吞吐量，但 pmuludq 是 1c。 ( https://agner.org/optimize/ ) 每个周期产生 128 个乘积位(两个 32x32 => 64 位乘积)比每 4 个周期产生 128 个乘积位要好，如果您可以在不消耗太多额外周期的情况下移动和添加它们。

同样，MSVC 不擅长通过内部函数进行恒定传播或 CSE 优化，因此您的内部函数版本不会从任何东西中受益。

您的测试代码还使用来自标量整数循环变量的 _mm_set1_epi32( )，需要 vmovd 和 vpshufd 指令。

并且您会为这些数组上的 lddqu 内在函数获得标量存储/vector 重新加载，因此您再次遇到了存储转发停顿。

SSE2 或 AVX1 的唯一希望是，如果您的数据来自内存，而不是寄存器。或者，如果您可以将数据长时间保存在 vector 寄存器中，而不是不断地来回移动它。特别是在推土机系列中 int <-> SIMD 具有高延迟。

关于c++ - 为什么 _umul128 的工作速度比 mul128x64x2 函数的标量代码慢？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/57712285/

文章推荐： c++ - 如何消除重载模板函数的歧义？

文章推荐： c - 如何以编程方式检测 linux 中大写锁定的状态

文章推荐： linux - 我怎样才能显示正确答案？

详解C语言sscanf()函数、vsscanf()函数、vscanf()函数
C语言sscanf()函数：从字符串中读取指定格式的数据头文件： ?
php - 如何解释at()函数； substr()函数;伪代码中的exist()函数
最近，我有一个关于工作预评估的问题，即使查询了每个功能的工作原理，我也不知道如何解决。这是一个伪代码。下面是一个名为foo()的函数，该函数将被传递一个值并返回一个值。如果将以下值传递给foo函数，
VBS教程：函数-CStr 函数
CStr 函数返回表达式，该表达式已被转换为 String 子类型的 Variant。 CStr(expression) expression 参数是任意有效的表达式。说明通常，可以
VBS教程：函数-CSng 函数
CSng 函数返回表达式，该表达式已被转换为 Single 子类型的 Variant。 CSng(expression) expression 参数是任意有效的表达式。说明通常，可
VBS教程：函数-CreateObject 函数
CreateObject 函数创建并返回对 Automation 对象的引用。 CreateObject(servername.typename [, location]) 参数 serv
VBS教程：函数-Cos 函数
Cos 函数返回某个角的余弦值。 Cos(number) number 参数可以是任何将某个角表示为弧度的有效数值表达式。说明 Cos 函数取某个角并返回直角三角形两边的比值。此比值是
VBS教程：函数-CLng 函数
CLng 函数返回表达式，此表达式已被转换为 Long 子类型的 Variant。 CLng(expression) expression 参数是任意有效的表达式。说明通常，您可以使
VBS教程：函数-CInt 函数
CInt 函数返回表达式，此表达式已被转换为 Integer 子类型的 Variant。 CInt(expression) expression 参数是任意有效的表达式。说明通常，可
VBS教程：函数-Chr 函数
Chr 函数返回与指定的 ANSI 字符代码相对应的字符。 Chr(charcode) charcode 参数是可以标识字符的数字。说明从 0 到 31 的数字表示标准的不可打印的
VBS教程：函数-CDbl 函数
CDbl 函数返回表达式，此表达式已被转换为 Double 子类型的 Variant。 CDbl(expression) expression 参数是任意有效的表达式。说明通常，您可
VBS教程：函数-CDate 函数
CDate 函数返回表达式，此表达式已被转换为 Date 子类型的 Variant。 CDate(date) date 参数是任意有效的日期表达式。说明 IsDate 函数用于判断 d
VBS教程：函数-CCur 函数
CCur 函数返回表达式，此表达式已被转换为 Currency 子类型的 Variant。 CCur(expression) expression 参数是任意有效的表达式。说明通常，
VBS教程：函数-CByte 函数
CByte 函数返回表达式，此表达式已被转换为 Byte 子类型的 Variant。 CByte(expression) expression 参数是任意有效的表达式。说明通常，可以
VBS教程：函数-CBool 函数
CBool 函数返回表达式，此表达式已转换为 Boolean 子类型的 Variant。 CBool(expression) expression 是任意有效的表达式。说明如果 ex
VBS教程：函数-Atn 函数
Atn 函数返回数值的反正切值。 Atn(number) number 参数可以是任意有效的数值表达式。说明 Atn 函数计算直角三角形两个边的比值 (number) 并返回对应角的弧
VBS教程：函数-Asc 函数
Asc 函数返回与字符串的第一个字母对应的 ANSI 字符代码。 Asc(string) string 参数是任意有效的字符串表达式。如果 string 参数未包含字符，则将发生运行时错误。
VBS教程：函数-Array 函数
Array 函数返回包含数组的 Variant。 Array(arglist) arglist 参数是赋给包含在 Variant 中的数组元素的值的列表（用逗号分隔）。如果没有指定此参数，则
VBS教程：函数-Abs 函数
Abs 函数返回数字的绝对值。 Abs(number) number 参数可以是任意有效的数值表达式。如果 number 包含 Null，则返回 Null；如果是未初始化变量，则返回 0。
VBS教程：函数-FormatPercent 函数
FormatPercent 函数返回表达式，此表达式已被格式化为尾随有 % 符号的百分比（乘以 100 ）。 FormatPercent(expression[,NumDigitsAfterD
VBS教程：函数-FormatNumber 函数
FormatNumber 函数返回表达式，此表达式已被格式化为数值。 FormatNumber( expression [,NumDigitsAfterDecimal [,Inc

塔克拉玛干

个人简介

我是一名优秀的程序员,十分优秀！

作者热门文章

滴滴打车优惠券免费领取

全站热门文章

首页

博学

6Ren·AI

商城

c++ - 为什么 _umul128 的工作速度比 mul128x64x2 函数的标量代码慢？