循环十万百万高效率的写法求一个

psyche · 发表于 2024-10-12 22:38:50

子程序名	返回值类型	公开	备注
子程序1

变量名	类型	静态	数组	备注
时间戳	文本型
a	整数型
测试	文本型

计次循环首 (100000, a)

测试＝到大写 (取文本左边 (取数据摘要 (到字节集 (时间戳＋到文本 (a) ＋到文本 (取随机数 (1, 9)) ＋到文本 (取随机数 (1, 9)) ＋到文本 (取随机数 (1, 9)) ＋到文本 (取随机数 (1, 9)) ＋到文本 (取随机数 (1, 9)) ＋到文本 (取随机数 (1, 9)) ＋到文本 (取随机数 (1, 9)) ＋ “+” ＋到文本 (取随机数 (1, 9)) ＋到文本 (取随机数 (1, 9)) ＋到文本 (取随机数 (1, 9)) ＋到文本 (取随机数 (1, 9)))), 到整数 (16)))

计次循环尾 ()

i支持库列表	支持库注释
dp1	数据操作支持库一
spec	特殊功能支持库

大漠小鸟 · 发表于 2024-10-12 22:38:51

我来交作业了，速度应该很快了这个过程，10万次本机测试58毫秒
代码阅读性差，注重解题过程哈

源码预览：

窗口程序集名	保留	保留	备注
程序集1

子程序名	返回值类型	公开	备注
_启动子程序	整数型

变量名	类型	静态	数组	备注
启动时间	长整数型
结束时间	长整数型

QueryPerformanceCounter (启动时间)
_临时子程序 ()
QueryPerformanceCounter (结束时间)
调试输出 (结束时间－启动时间, (结束时间－启动时间) ÷ 10000)
返回 (0)

子程序名	返回值类型	公开	备注
_临时子程序

变量名	类型	静态	数组	备注
时间戳	文本型
i	整数型
测试	文本型
测试地址	整数型
指针地址	整数型
算法缓冲区	文本型
算法缓冲区地址	整数型

' 时间戳：10
' 计次 I：6
' 随机数：11
' 符号 +：1
' -------------
' 总计：28 字节
' MD5 ：32
' 大写：16
' -------------
' 总计：32
时间戳＝ “1728746500”
' 已知最大文本的长度就32字节就够了，如果循环次数达到百万或时间戳文本长度更长，缓冲区可适当加大到40-48
测试＝取空白文本 (32)
测试地址＝取变量数据地址 (测试)
算法缓冲区＝取空白文本 (104)
算法缓冲区地址＝取变量数据地址 (算法缓冲区)

计次循环首 (100000, i) ' 10万次58毫秒，百万次580毫秒

指针地址＝测试地址

' 写入时间戳

写到内存 (时间戳, 指针地址, )

指针地址＝测试地址＋ 10 ' 时间戳文本长度

' 到文本(i)

_itoa (i, 指针地址, 10)

指针地址＝指针地址＋ GetStrLen (指针地址)

' 取随机数，头7次

计次循环首 (7, )

_itoa (Random (1, 9), 指针地址, 10)

指针地址＝指针地址＋ 1

计次循环尾 ()

' 中间补一个 '+'

写到内存 (“+”, 指针地址, )

指针地址＝指针地址＋ 1

' 取随机数，尾4次

计次循环首 (4, )

_itoa (Random (1, 9), 指针地址, 10)

指针地址＝指针地址＋ 1

计次循环尾 ()

' 取数据摘要

GetMd5 (测试地址, 指针地址－测试地址, 算法缓冲区地址, 测试地址, 7)

' 取文本左边(测试，16)，直接在第16个字节的位置写入终止符\0 截断

写到内存 ({ 0 }, 测试地址＋ 16, )

计次循环尾 ()
' 调试输出 (测试)
' 解释：
' 你原始的代码存在大量的整数到文本转换，每转换一次就要申请内存块（整数4294967295+\0）
' 即使在循环过程编译器等会优化这个过程，大量循环下消耗的时间还是很多的
' 其次还存在文本相加的过程，比如：到文本(随机数)+到文本(随机数)
' 这个过程会逐字遍历文本，找到文本的终止符，实现取文本长度，然后再申请一块大内存，将文本块复制过去
' 然后再申请一块字节集的缓冲区
' 然后计算MD5时还会申请额外的内存来计算，到大小写这个过程也会重新申请内存
' 总之原始代码存在大量的申请释放内存过程
' 上面那么多代码的作用就是避免这个过程，循环过程就飞快了

子程序名	返回值类型	公开	备注
GetStrLen	整数型		取文本型数据的长度，不包含结束0。
参数名	类型	参考	可空	数组	备注
pAddr	通用型				可以是文本型或文本指针

' __asm{
' ; mov eax,dword [ebp+8]    ;字符串栈地址
' ; mov eax,dword [eax]       ;字符串堆地址
' ; test eax,eax             ;判断堆地址是否为零，比如传入空变量
' ; jz 返回
' ; lea edx,[eax+3]          ;拷贝一份字符串堆地址，+3仅为了最后运算的偏移
' ; 读入四字节:
' ; mov ebx,[eax]             ;读入4个字节
' ; add eax,4                ;字符串指针+4
' ; lea ecx,[ebx-01010101h]    ;ebx的4字节每个字节-1
' ; not ebx                   ;ebx的4个字节逻辑取反，如-1变成1
' ; and ecx,ebx                ;ecx=取反后的每个字节和没取反后-1的每个字节进行逻辑与
' ; and ecx,80808080h          ;判断每个字节的二进制第8位是否为1，为1则说明原字节=0
' ; jz 读入四字节             ;如果为零，表示4个字节都不为null，跳回继续循环
' ; test ecx,00008080h       ;判断null是否在前2个字节中
' ; jnz 计算长度             ;在前2个字节处理
' ; shr ecx,16                ;不在前2字节，将ecx高16复制到低16(后2字节复制到前2字节)
' ; add eax,2                ;字符串指针+2
' ; 计算长度:
' ; shl cl,1                   ;第1个字节逻辑左移1位，如果第1个字节为Null，则CF=1，否则即说
' ; sbb eax,edx                ;eax=eax-edx-CF
' ; 返回:
' ; leave
' ; retn __参数大小__
' }
置入代码 ({ 139, 69, 8, 139, 0, 133, 192, 116, 44, 141, 80, 3, 139, 24, 131, 192, 4, 141, 139, 255, 254, 254, 254, 247, 211, 33, 217, 129, 225, 128, 128, 128, 128, 116, 233, 247, 193, 128, 128, 0, 0, 117, 6, 193, 233, 16, 131, 192, 2, 208, 225, 25, 208, 201, 194, 4, 0 })
返回 (0)

子程序名	返回值类型	公开	备注
Random	整数型		取随机数，效率2.7亿/s
参数名	类型	参考	可空	数组	备注
min	整数型
max	整数型
reset	逻辑型

变量名	类型	静态	数组	备注
n	整数型
i	整数型

如果真 (reset ＝真或 n ＝ 0)

置入代码 ({ 15, 49, 133, 192, 116, 250, 137, 69, 252 })

n ＝ i
置入代码 ({ 232, 0, 0, 0, 0, 89, 139, 85, 12, 139, 69, 8, 83, 87, 86, 139, 113, 247, 57, 208, 137, 193, 15, 79, 202, 15, 79, 208, 139, 6, 137, 199, 193, 231, 13, 49, 199, 137, 251, 193, 235, 17, 49, 251, 137, 216, 193, 224, 5, 49, 216, 41, 202, 66, 191, 255, 255, 255, 255, 15, 69, 250, 137, 6, 49, 210, 247, 247, 1, 209, 137, 200, 94, 95, 91, 201, 194, 16, 0 })
返回 (0)

子程序名	返回值类型	公开	备注
GetMd5
参数名	类型	参考	可空	数组	备注
数据地址	整数型
数据长度	整数型				如果为文本、字节集变量，则数据长度可以填0。如果是数据指针中的部分数据，请填写数据长度。
算法缓冲区指针	整数型				该缓冲区大小至少为104
MD5缓冲区	整数型				该缓冲区大小至少为32
大小写	整数型				7=大写，39=小写

变量名	类型	静态	数组	备注
变量类型	整数型
i	整数型

MD5_Init (算法缓冲区指针)  ' 初始化
MD5_Update (算法缓冲区指针, 数据地址, 数据长度)  ' 加入需要计算的数据
MD5_Final (算法缓冲区指针)  ' 取出计算结果
' 将末尾的16字节转换到16进制
BytesToHex (算法缓冲区指针＋ 88, 16, MD5缓冲区, 大小写, 0)

子程序名	返回值类型	公开	备注
BytesToHex	整数型
参数名	类型	参考	可空	数组	备注
数据地址	整数型				字节集数据地址,取变量数据地址(字节集)
数据长度	整数型				字节集的长度
输出缓冲区	整数型				该缓冲区大小至少为：字节集长度2；如果带分隔符，该缓冲区大小至少为：字节集长度3
输出大小写	整数型				只能为两者值之一：7=大写；39=小写；
输出分隔符	整数型				0=无分隔符，空格=32(ascii码)

' __asm{
' ; mov esi, dword ptr [ebp +  8]          ;字节集数据地址
' ; mov ecx, dword ptr [ebp + 12]          ;字节集长度
' ; mov edi, dword ptr [ebp + 16]          ;输出缓冲区数据地址
' ; mov dh,  byte  ptr [ebp + 20]          ;7=大写；39=小写
' ; mov al,  byte  ptr [ebp + 24]          ;输出缓冲区分隔符，0=无分隔符；32=空格
' ; next_byte:                            ;循环首标签开始
' ; test ecx, ecx                      ;自身位与比较等价于：位与(ecx,ecx)
' ; jz done                            ;如果ecx=0,转到done标签结束，否则↓执行
' ; mov dl,byte ptr [esi]             ;读取esi处一个字节，假设字节=254,Hex=FE
' ; shr dl,4                            ;15=右移(254,4)
' ; and dl,15                         ;15=位与(15,15)
' ; add dl,'0'                         ;15+48=63
' ; cmp dl,'9'                         ;比较 63 ， 57
' ; jbe write_byte_1                   ;如果 63 ≯ 57 则跳转
' ; add dl,dh                         ;否则 63+7=70=F,63+39=102=f
' ; write_byte_1:                         ;写第一个字节;0-F，上面dl已经处理好了
' ; mov byte ptr [edi],dl             ;将F写入edi中
' ; inc edi                            ;edi 递增+1
' ; mov dl,byte ptr [esi]             ;原先的dl已被覆盖，再次取出当前字节(254)
' ; and dl,15                         ;14=位与(254,15)
' ; add dl,'0'                         ;14+48=62
' ; cmp dl,'9'                         ;比较 62 ， 57
' ; jbe write_byte_2                   ;如果 62 ≯ 57 则跳转
' ; add dl,dh                         ;否则 62+7=69=E,62+39=101=e
' ; write_byte_2:                         ;写第二个字节
' ; mov byte ptr [edi],dl             ;将E写入edi中
' ; inc edi                            ;edi 递增+1
' ; test al,al                         ;位与(al,al)
' ; jz no_fill                         ;如果al=0，不填充分隔符，跳转标签
' ; mov byte ptr [edi],al             ;否则将分隔符填充进edi中
' ; inc edi                            ;edi 递增+1
' ; no_fill:
' ; inc esi                            ;字节集数据指针递增+1
' ; dec ecx                            ;ecx 循环递减-1
' ; jmp next_byte                      ;跳转到循环首↑处理下一个字节
' ; done:
' ; mov eax,dword ptr [ebp+16]          ;读取初始的输出缓冲区数据地址
' ; cmp eax,edi                         ;初始指针和结束指针比较
' ; jz end_ret                         ;如果两者相等，说明没处理过任何数据
' ; mov byte ptr [edi],0                ;否则edi末尾的分隔符设置为终止符0
' ; mov eax,edi                         ;将edi结束指针赋值到eax
' ; end_ret:
' ; leave                               ;清理恢复栈
' ; retn __参数大小__                   ;32位程序的返回值储存在eax中，64位在rax
' }
置入代码 ({ 139, 117, 8, 139, 77, 12, 139, 125, 16, 138, 117, 20, 138, 69, 24, 133, 201, 116, 50, 138, 22, 192, 234, 4, 128, 226, 15, 128, 194, 48, 128, 250, 57, 118, 2, 0, 242, 136, 23, 71, 138, 22, 128, 226, 15, 128, 194, 48, 128, 250, 57, 118, 2, 0, 242, 136, 23, 71, 132, 192, 116, 3, 136, 7, 71, 70, 73, 235, 202, 139, 69, 16, 57, 248, 116, 5, 198, 7, 0, 137, 248, 201, 194, 20, 0 })
返回 (0)

i支持库列表	支持库注释
spec	特殊功能支持库

.版本 2<br />
.支持库 spec<br />
<br />
.程序集 程序集1<br />
<br />
.子程序 _启动子程序, 整数型<br />
.局部变量 启动时间, 长整数型<br />
.局部变量 结束时间, 长整数型<br />
<br />
QueryPerformanceCounter (启动时间)<br />
_临时子程序 ()<br />
QueryPerformanceCounter (结束时间)<br />
调试输出 (结束时间 － 启动时间, (结束时间 － 启动时间) ÷ 10000)<br />
<br />
返回 (0)<br />
<br />
.子程序 _临时子程序<br />
.局部变量 时间戳, 文本型<br />
.局部变量 i, 整数型<br />
.局部变量 测试, 文本型<br />
.局部变量 测试地址, 整数型<br />
.局部变量 指针地址, 整数型<br />
.局部变量 算法缓冲区, 文本型<br />
.局部变量 算法缓冲区地址, 整数型<br />
<br />
' 时间戳：10<br />
' 计次 I：6<br />
' 随机数：11<br />
' 符号 +：1<br />
' -------------<br />
' 总计：28 字节<br />
<br />
<br />
' MD5   ：32<br />
' 大写  ：16<br />
' -------------<br />
' 总计  ：32<br />
<br />
<br />
<br />
时间戳 ＝ “1728746500”<br />
<br />
' 已知最大文本的长度就32字节就够了，如果循环次数达到百万或时间戳文本长度更长，缓冲区可适当加大到40-48<br />
测试 ＝ 取空白文本 (32)<br />
测试地址 ＝ 取变量数据地址 (测试)<br />
<br />
<br />
算法缓冲区 ＝ 取空白文本 (104)<br />
算法缓冲区地址 ＝ 取变量数据地址 (算法缓冲区)<br />
<br />
.计次循环首 (100000, i)  ' 10万次58毫秒，百万次580毫秒<br />
    指针地址 ＝ 测试地址<br />
<br />
    ' 写入时间戳<br />
    写到内存 (时间戳, 指针地址, )<br />
    指针地址 ＝ 测试地址 ＋ 10  ' 时间戳文本长度<br />
<br />
    ' 到文本(i)<br />
    _itoa (i, 指针地址, 10)<br />
    指针地址 ＝ 指针地址 ＋ GetStrLen (指针地址)<br />
<br />
    ' 取随机数，头7次<br />
    .计次循环首 (7, )<br />
        _itoa (Random (1, 9), 指针地址, 10)<br />
        指针地址 ＝ 指针地址 ＋ 1<br />
    .计次循环尾 ()<br />
<br />
    ' 中间补一个 '+'<br />
    写到内存 (“+”, 指针地址, )<br />
    指针地址 ＝ 指针地址 ＋ 1<br />
<br />
    ' 取随机数，尾4次<br />
    .计次循环首 (4, )<br />
        _itoa (Random (1, 9), 指针地址, 10)<br />
        指针地址 ＝ 指针地址 ＋ 1<br />
    .计次循环尾 ()<br />
<br />
    ' 取数据摘要<br />
    GetMd5 (测试地址, 指针地址 － 测试地址, 算法缓冲区地址, 测试地址, 7)<br />
<br />
    ' 取文本左边(测试，16)，直接在第16个字节的位置写入终止符\0 截断<br />
    写到内存 ({ 0 }, 测试地址 ＋ 16, )<br />
<br />
.计次循环尾 ()<br />
' 调试输出 (测试)<br />
<br />
' 解释：<br />
' 你原始的代码存在大量的整数到文本转换，每转换一次就要申请内存块（整数4294967295+\0）<br />
' 即使在循环过程编译器等会优化这个过程，大量循环下消耗的时间还是很多的<br />
' 其次 还存在文本相加的过程，比如：到文本(随机数)+到文本(随机数)<br />
' 这个过程会逐字遍历文本，找到文本的终止符，实现取文本长度，然后再申请一块大内存，将文本块复制过去<br />
' 然后再申请一块字节集的缓冲区<br />
' 然后计算MD5时还会申请额外的内存来计算，到大小写这个过程也会重新申请内存<br />
' 总之原始代码存在大量的申请释放内存过程<br />
' 上面那么多代码的作用就是避免这个过程，循环过程就飞快了<br />
<br />
<br />
.子程序 GetStrLen, 整数型, , 取文本型数据的长度，不包含结束0。<br />
.参数 pAddr, 通用型, 参考, 可以是文本型或文本指针<br />
<br />
<br />
' __asm{<br />
' ; mov eax,dword [ebp+8]       ;字符串栈地址<br />
' ; mov eax,dword [eax]         ;字符串堆地址<br />
' ; test eax,eax                ;判断堆地址是否为零，比如传入空变量<br />
' ; jz 返回<br />
<br />
' ; lea edx,[eax+3]             ;拷贝一份字符串堆地址，+3仅为了最后运算的偏移<br />
<br />
' ; 读入四字节:<br />
' ; mov ebx,[eax]               ;读入4个字节<br />
' ; add eax,4                   ;字符串指针+4<br />
' ; lea ecx,[ebx-01010101h]     ;ebx的4字节每个字节-1<br />
' ; not ebx                     ;ebx的4个字节逻辑取反，如-1变成1<br />
' ; and ecx,ebx                 ;ecx=取反后的每个字节和没取反后-1的每个字节进行逻辑与<br />
' ; and ecx,80808080h           ;判断每个字节的二进制第8位是否为1，为1则说明原字节=0<br />
' ; jz 读入四字节               ;如果为零，表示4个字节都不为null，跳回继续循环<br />
<br />
' ; test ecx,00008080h          ;判断null是否在前2个字节中<br />
' ; jnz 计算长度                ;在前2个字节处理<br />
' ; shr ecx,16                  ;不在前2字节，将ecx高16复制到低16(后2字节复制到前2字节)<br />
' ; add eax,2                   ;字符串指针+2<br />
' ; 计算长度:<br />
' ; shl cl,1                    ;第1个字节逻辑左移1位，如果第1个字节为Null，则CF=1，否则即说<br />
' ; sbb eax,edx                 ;eax=eax-edx-CF<br />
<br />
' ; 返回:<br />
' ; leave<br />
' ; retn __参数大小__<br />
' }<br />
<br />
置入代码 ({ 139, 69, 8, 139, 0, 133, 192, 116, 44, 141, 80, 3, 139, 24, 131, 192, 4, 141, 139, 255, 254, 254, 254, 247, 211, 33, 217, 129, 225, 128, 128, 128, 128, 116, 233, 247, 193, 128, 128, 0, 0, 117, 6, 193, 233, 16, 131, 192, 2, 208, 225, 25, 208, 201, 194, 4, 0 })<br />
返回 (0)<br />
<br />
.子程序 Random, 整数型, , 取随机数，效率2.7亿/s<br />
.参数 min, 整数型<br />
.参数 max, 整数型<br />
.参数 reset, 逻辑型, 可空<br />
.局部变量 n, 整数型, 静态<br />
.局部变量 i, 整数型<br />
<br />
.如果真 (reset ＝ 真 或 n ＝ 0)<br />
    置入代码 ({ 15, 49, 133, 192, 116, 250, 137, 69, 252 })<br />
    n ＝ i<br />
.如果真结束<br />
置入代码 ({ 232, 0, 0, 0, 0, 89, 139, 85, 12, 139, 69, 8, 83, 87, 86, 139, 113, 247, 57, 208, 137, 193, 15, 79, 202, 15, 79, 208, 139, 6, 137, 199, 193, 231, 13, 49, 199, 137, 251, 193, 235, 17, 49, 251, 137, 216, 193, 224, 5, 49, 216, 41, 202, 66, 191, 255, 255, 255, 255, 15, 69, 250, 137, 6, 49, 210, 247, 247, 1, 209, 137, 200, 94, 95, 91, 201, 194, 16, 0 })<br />
返回 (0)<br />
<br />
<br />
.子程序 GetMd5<br />
.参数 数据地址, 整数型<br />
.参数 数据长度, 整数型, , 如果为文本、字节集变量，则数据长度可以填0。如果是数据指针中的部分数据，请填写数据长度。<br />
.参数 算法缓冲区指针, 整数型, , 该缓冲区大小至少为104<br />
.参数 MD5缓冲区, 整数型, , 该缓冲区大小至少为32<br />
.参数 大小写, 整数型, , 7=大写，39=小写<br />
.局部变量 变量类型, 整数型<br />
.局部变量 i, 整数型<br />
<br />
MD5_Init (算法缓冲区指针)  ' 初始化<br />
MD5_Update (算法缓冲区指针, 数据地址, 数据长度)  ' 加入需要计算的数据<br />
MD5_Final (算法缓冲区指针)  ' 取出计算结果<br />
<br />
' 将末尾的16字节转换到16进制<br />
BytesToHex (算法缓冲区指针 ＋ 88, 16, MD5缓冲区, 大小写, 0)<br />
<br />
.子程序 BytesToHex, 整数型<br />
.参数 数据地址, 整数型, , 字节集数据地址,取变量数据地址(字节集)<br />
.参数 数据长度, 整数型, , 字节集的长度<br />
.参数 输出缓冲区, 整数型, , 该缓冲区大小至少为：字节集长度*2；如果带分隔符，该缓冲区大小至少为：字节集长度*3<br />
.参数 输出大小写, 整数型, , 只能为两者值之一：7=大写；39=小写；<br />
.参数 输出分隔符, 整数型, , 0=无分隔符，空格=32(ascii码)<br />
<br />
' __asm{<br />
' ; mov esi, dword ptr [ebp +  8]           ;字节集数据地址<br />
' ; mov ecx, dword ptr [ebp + 12]           ;字节集长度<br />
' ; mov edi, dword ptr [ebp + 16]           ;输出缓冲区数据地址<br />
' ; mov dh,  byte  ptr [ebp + 20]           ;7=大写；39=小写<br />
' ; mov al,  byte  ptr [ebp + 24]           ;输出缓冲区分隔符，0=无分隔符；32=空格<br />
<br />
' ; next_byte:                              ;循环首标签开始<br />
' ;    test ecx, ecx                        ;自身位与比较等价于：位与(ecx,ecx)<br />
' ;    jz done                              ;如果ecx=0,转到done标签结束，否则↓执行<br />
<br />
' ;    mov dl,byte ptr [esi]                ;读取esi处一个字节，假设字节=254,Hex=FE<br />
' ;    shr dl,4                             ;15=右移(254,4)<br />
' ;    and dl,15                            ;15=位与(15,15)<br />
' ;    add dl,'0'                           ;15+48=63<br />
' ;    cmp dl,'9'                           ;比较 63 ， 57<br />
' ;    jbe write_byte_1                     ;如果 63 ≯ 57 则跳转<br />
' ;    add dl,dh                            ;否则 63+7=70=F,63+39=102=f<br />
' ; write_byte_1:                           ;写第一个字节;0-F，上面dl已经处理好了<br />
' ;    mov byte ptr [edi],dl                ;将F写入edi中<br />
' ;    inc edi                              ;edi 递增+1<br />
<br />
' ;    mov dl,byte ptr [esi]                ;原先的dl已被覆盖，再次取出当前字节(254)<br />
' ;    and dl,15                            ;14=位与(254,15)<br />
' ;    add dl,'0'                           ;14+48=62<br />
' ;    cmp dl,'9'                           ;比较 62 ， 57<br />
' ;    jbe write_byte_2                     ;如果 62 ≯ 57 则跳转<br />
' ;    add dl,dh                            ;否则 62+7=69=E,62+39=101=e<br />
' ; write_byte_2:                           ;写第二个字节<br />
' ;    mov byte ptr [edi],dl                ;将E写入edi中<br />
' ;    inc edi                              ;edi 递增+1<br />
<br />
' ;    test al,al                           ;位与(al,al)<br />
' ;    jz no_fill                           ;如果al=0，不填充分隔符，跳转标签<br />
' ;    mov byte ptr [edi],al                ;否则将分隔符填充进edi中<br />
' ;    inc edi                              ;edi 递增+1<br />
' ; no_fill:<br />
' ;    inc esi                              ;字节集数据指针递增+1<br />
' ;    dec ecx                              ;ecx 循环递减-1<br />
' ;    jmp next_byte                        ;跳转到循环首↑处理下一个字节<br />
<br />
' ; done:<br />
' ;    mov eax,dword ptr [ebp+16]           ;读取初始的输出缓冲区数据地址<br />
' ;    cmp eax,edi                          ;初始指针和结束指针比较<br />
' ;    jz end_ret                           ;如果两者相等，说明没处理过任何数据<br />
' ;    mov byte ptr [edi],0                 ;否则edi末尾的分隔符设置为终止符0<br />
' ;    mov eax,edi                          ;将edi结束指针赋值到eax<br />
' ; end_ret:<br />
' ;    leave                                ;清理恢复栈<br />
' ;    retn __参数大小__                    ;32位程序的返回值储存在eax中，64位在rax<br />
' }<br />
<br />
置入代码 ({ 139, 117, 8, 139, 77, 12, 139, 125, 16, 138, 117, 20, 138, 69, 24, 133, 201, 116, 50, 138, 22, 192, 234, 4, 128, 226, 15, 128, 194, 48, 128, 250, 57, 118, 2, 0, 242, 136, 23, 71, 138, 22, 128, 226, 15, 128, 194, 48, 128, 250, 57, 118, 2, 0, 242, 136, 23, 71, 132, 192, 116, 3, 136, 7, 71, 70, 73, 235, 202, 139, 69, 16, 57, 248, 116, 5, 198, 7, 0, 137, 248, 201, 194, 20, 0 })<br />
返回 (0)

完整源码下载：

demo.e (16.07 KB, 下载次数: 3)

LEOONL · 发表于 2024-10-12 22:44:05

子程序名	返回值类型	公开	备注
_按钮1_被单击

子程序1 ()

子程序名	返回值类型	公开	备注
子程序1

变量名	类型	静态	数组	备注
时间戳	文本型
a	整数型
测试	文本型

计次循环首 (100000, a)

测试＝到大写 (取文本左边 (取数据摘要 (到字节集 (时间戳＋到文本 (a) ＋到文本 (取随机数 (111111, 999999)) ＋ “+” ＋到文本 (取随机数 (11111, 99999)))), 16))

计次循环尾 ()
调试输出 (测试)

i支持库列表	支持库注释
dp1	数据操作支持库一
spec	特殊功能支持库

真IKUN · 发表于 2024-10-12 22:50:10

十万百万开线程，每个线程执行不同的循环

呵呵仙 · 发表于 2024-10-12 23:04:36

不要用+这样的文本追加文本内容,要用一次申请足够内存空间,然后复制内存方式把数据追加.这样就快了!思路:
https://bbs.125.la/forum.php?mod ... 14759821&extra=

LEOONL · 发表于 2024-10-12 23:04:53

子程序名	返回值类型	公开	备注
_按钮1_被单击

子程序1 ()

子程序名	返回值类型	公开	备注
子程序1

变量名	类型	静态	数组	备注
时间戳	文本型
a	整数型
测试	文本型
b	整数型
c	整数型
n	整数型

计次循环首 (100000, a)

计次循环首 (11, n)

b ＝取随机数 (1, 9)

计次循环首 (n － 1, )

b ＝ b × 10

计次循环尾 ()

c ＝ c ＋ b

计次循环尾 ()

计次循环首 (11, )

a ＝ a × 10

计次循环尾 ()

c ＝ a ＋ c

测试＝到大写 (取文本左边 (取数据摘要 (到字节集 (时间戳＋到文本 (c))), 16))

计次循环尾 ()
调试输出 (测试)

i支持库列表	支持库注释
dp1	数据操作支持库一
spec	特殊功能支持库

LEOONL · 发表于 2024-10-12 23:18:57

你用点评真是没法沟通，他那个方法有到文本（）效率慢得我都等不到出结果，改次方确实快点

子程序名	返回值类型	公开	备注
_按钮1_被单击

子程序1 ()

子程序名	返回值类型	公开	备注
子程序1

变量名	类型	静态	数组	备注
时间戳	文本型
a	整数型
测试	文本型
b	整数型
c	整数型
n	整数型

计次循环首 (100000, a)

计次循环首 (11, n)

b ＝取随机数 (1, 9)

b ＝ b × 求次方 (10, n － 1)

c ＝ c ＋ b

计次循环尾 ()

a ＝ a × 求次方 (10, 11)

c ＝ a ＋ c

测试＝到大写 (取文本左边 (取数据摘要 (到字节集 (时间戳＋到文本 (c))), 16))

计次循环尾 ()
调试输出 (测试)

i支持库列表	支持库注释
dp1	数据操作支持库一
spec	特殊功能支持库

xf702 · 发表于 2024-10-12 23:54:36

这是用来测机器性能的吗？

大漠小鸟 · 发表于 2024-10-13 00:39:30

源码预览：

窗口程序集名	保留	保留	备注
程序集1

子程序名	返回值类型	公开	备注
_启动子程序	整数型

变量名	类型	静态	数组	备注
启动时间	长整数型
结束时间	长整数型

QueryPerformanceCounter (启动时间)
_临时子程序 ()
QueryPerformanceCounter (结束时间)
调试输出 (结束时间－启动时间, (结束时间－启动时间) ÷ 10000)
返回 (0)

子程序名	返回值类型	公开	备注
_临时子程序

变量名	类型	静态	数组	备注
时间戳	文本型
i	整数型
测试	文本型
测试地址	整数型
指针地址	整数型
算法缓冲区	文本型
算法缓冲区地址	整数型

' 时间戳：10
' 计次 I：6
' 随机数：11
' 符号 +：1
' -------------
' 总计：28 字节
' MD5 ：32
' 大写：16
' -------------
' 总计：32
时间戳＝ “1728746500”
' 已知最大文本的长度就32字节就够了，如果循环次数达到百万或时间戳文本长度更长，缓冲区可适当加大到40-48
测试＝取空白文本 (32)
测试地址＝取变量数据地址 (测试)
算法缓冲区＝取空白文本 (104)
算法缓冲区地址＝取变量数据地址 (算法缓冲区)

计次循环首 (100000, i) ' 10万次58毫秒，百万次580毫秒

指针地址＝测试地址

' 写入时间戳

写到内存 (时间戳, 指针地址, )

指针地址＝测试地址＋ 10 ' 时间戳文本长度

' 到文本(i)

_itoa (i, 指针地址, 10)

指针地址＝指针地址＋ GetStrLen (指针地址)

' 取随机数，头7次

计次循环首 (7, )

_itoa (Random (1, 9), 指针地址, 10)

指针地址＝指针地址＋ 1

计次循环尾 ()

' 中间补一个 '+'

写到内存 (“+”, 指针地址, )

指针地址＝指针地址＋ 1

' 取随机数，尾4次

计次循环首 (4, )

_itoa (Random (1, 9), 指针地址, 10)

指针地址＝指针地址＋ 1

计次循环尾 ()

' 取数据摘要

GetMd5 (测试地址, 指针地址－测试地址, 算法缓冲区地址, 测试地址, 7)

' 取文本左边(测试，16)，直接在第16个字节的位置写入终止符\0 截断

写到内存 ({ 0 }, 测试地址＋ 16, )

计次循环尾 ()
' 调试输出 (测试)
' 解释：
' 你原始的代码存在大量的整数到文本转换，每转换一次就要申请内存块（整数4294967295+\0）
' 即使在循环过程编译器等会优化这个过程，大量循环下消耗的时间还是很多的
' 其次还存在文本相加的过程，比如：到文本(随机数)+到文本(随机数)
' 这个过程会逐字遍历文本，找到文本的终止符，实现取文本长度，然后再申请一块大内存，将文本块复制过去
' 然后再申请一块字节集的缓冲区
' 然后计算MD5时还会申请额外的内存来计算，到大小写这个过程也会重新申请内存
' 总之原始代码存在大量的申请释放内存过程
' 上面那么多代码的作用就是避免这个过程，循环过程就飞快了

i支持库列表	支持库注释
spec	特殊功能支持库

源码预览：<br />
.版本 2<br />
.支持库 spec<br />
<br />
.程序集 程序集1<br />
<br />
.子程序 _启动子程序, 整数型<br />
.局部变量 启动时间, 长整数型<br />
.局部变量 结束时间, 长整数型<br />
<br />
QueryPerformanceCounter (启动时间)<br />
_临时子程序 ()<br />
QueryPerformanceCounter (结束时间)<br />
调试输出 (结束时间 － 启动时间, (结束时间 － 启动时间) ÷ 10000)<br />
<br />
返回 (0)<br />
<br />
.子程序 _临时子程序<br />
.局部变量 时间戳, 文本型<br />
.局部变量 i, 整数型<br />
.局部变量 测试, 文本型<br />
.局部变量 测试地址, 整数型<br />
.局部变量 指针地址, 整数型<br />
.局部变量 算法缓冲区, 文本型<br />
.局部变量 算法缓冲区地址, 整数型<br />
<br />
' 时间戳：10<br />
' 计次 I：6<br />
' 随机数：11<br />
' 符号 +：1<br />
' -------------<br />
' 总计：28 字节<br />
<br />
<br />
' MD5   ：32<br />
' 大写  ：16<br />
' -------------<br />
' 总计  ：32<br />
<br />
<br />
<br />
时间戳 ＝ “1728746500”<br />
<br />
' 已知最大文本的长度就32字节就够了，如果循环次数达到百万或时间戳文本长度更长，缓冲区可适当加大到40-48<br />
测试 ＝ 取空白文本 (32)<br />
测试地址 ＝ 取变量数据地址 (测试)<br />
<br />
<br />
算法缓冲区 ＝ 取空白文本 (104)<br />
算法缓冲区地址 ＝ 取变量数据地址 (算法缓冲区)<br />
<br />
.计次循环首 (100000, i)  ' 10万次58毫秒，百万次580毫秒<br />
    指针地址 ＝ 测试地址<br />
<br />
    ' 写入时间戳<br />
    写到内存 (时间戳, 指针地址, )<br />
    指针地址 ＝ 测试地址 ＋ 10  ' 时间戳文本长度<br />
<br />
    ' 到文本(i)<br />
    _itoa (i, 指针地址, 10)<br />
    指针地址 ＝ 指针地址 ＋ GetStrLen (指针地址)<br />
<br />
    ' 取随机数，头7次<br />
    .计次循环首 (7, )<br />
        _itoa (Random (1, 9), 指针地址, 10)<br />
        指针地址 ＝ 指针地址 ＋ 1<br />
    .计次循环尾 ()<br />
<br />
    ' 中间补一个 '+'<br />
    写到内存 (“+”, 指针地址, )<br />
    指针地址 ＝ 指针地址 ＋ 1<br />
<br />
    ' 取随机数，尾4次<br />
    .计次循环首 (4, )<br />
        _itoa (Random (1, 9), 指针地址, 10)<br />
        指针地址 ＝ 指针地址 ＋ 1<br />
    .计次循环尾 ()<br />
<br />
    ' 取数据摘要<br />
    GetMd5 (测试地址, 指针地址 － 测试地址, 算法缓冲区地址, 测试地址, 7)<br />
<br />
    ' 取文本左边(测试，16)，直接在第16个字节的位置写入终止符\0 截断<br />
    写到内存 ({ 0 }, 测试地址 ＋ 16, )<br />
<br />
.计次循环尾 ()<br />
' 调试输出 (测试)<br />
<br />
' 解释：<br />
' 你原始的代码存在大量的整数到文本转换，每转换一次就要申请内存块（整数4294967295+\0）<br />
' 即使在循环过程编译器等会优化这个过程，大量循环下消耗的时间还是很多的<br />
' 其次 还存在文本相加的过程，比如：到文本(随机数)+到文本(随机数)<br />
' 这个过程会逐字遍历文本，找到文本的终止符，实现取文本长度，然后再申请一块大内存，将文本块复制过去<br />
' 然后再申请一块字节集的缓冲区<br />
' 然后计算MD5时还会申请额外的内存来计算，到大小写这个过程也会重新申请内存<br />
' 总之原始代码存在大量的申请释放内存过程<br />
' 上面那么多代码的作用就是避免这个过程，循环过程就飞快了

完整源码下载：

demo.e (16.07 KB, 下载次数: 5)

psyche · 发表于 2024-10-13 09:45:07

大漠小鸟发表于 2024-10-13 00:39
[e=1]源码预览：
.版本 2
.支持库 spec

我的慢慢阅读下，，大佬费心

		自动登录	找回密码
密码			注册

[已解决] 循环十万百万高效率的写法求一个

最佳答案

点评

本帖被以下淘专辑推荐:

评分

点评

点评

点评

[已解决] 循环十万 百万 高效率的写法 求一个

最佳答案

点评

本帖被以下淘专辑推荐:

评分

点评

点评

点评

[已解决] 循环十万百万高效率的写法求一个