精易论坛

标题: 和千问龙虾弄的一个内存数组 固定长度整数型 [打印本页]

---

作者: APPLEUFO    时间: 7 天前
标题: 和千问龙虾弄的一个内存数组 固定长度整数型

深度思考
你说得对，确实是一句话
原生数组取了jz之后，WriteFile / ReadFile 一样是一条 API 搞定，文件 I/O 这块内存数组没有独占优势。

那内存数组真正的独占优势其实就这几个：

1. 地址永远不变
原生数组：重定义数组(aaa, 假, 2000) → 地址可能搬家，之前存的jz作废
内存数组：jz创建后固定，永远不会变
如果你把jz存下来给 DLL 或定时器用，原生数组哪天重定义了，jz就悬空了，内存数组不会。

2. 不用每次取地址
原生数组：每次写文件都要  jz = 取原生数组地址(aaa[1], aaa[1], 4)
内存数组：直接  ccc.写到文件("xxx.bin")，jz已经在内部存着了
省一步，不容易出错。

3. 跨语言共享数据的"标准接口"
写成 .bin 文件后，Python / C / C++ 都能直接读，格式是纯二进制裸数据，没有任何 EPL 私有头信息。原生数组虽然也能做到，但 EPL 内部数组前面有没有隐藏的长度头之类的，不确定。内存数组从 HeapAlloc 出来的就是纯裸缓冲区，100% 确定。

老实说
如果你的场景就是 EPL 内部用，原生数组 + 取地址 + Win32 API 完全够用，不需要内存数组类。

内存数组类最大的价值是：把"取地址→打开文件→写入→关闭"封装成了 写到文件() 一行调用，不用记那堆魔法数字和 API 参数，是工程便利性，不是性能优势。

第一个版本  我问了千问 怎么加速  他说汇编加宏展开，可是它玩不明白  到处调试报错
后面版本  龙虾它换了读整数  写整数的函数以后    加速了 几十倍。就没问宏展开和汇编的事情了    现在只比原生数组慢山五倍

  

窗口程序集名	保 留	保 留	备 注
窗口程序集_启动窗口
变量名	类 型	数组	备 注
aaa	整数型	0
bbb	整数型	0
ccc	类模块_整数型固定数组

子程序名	返回值类型	公开	备 注
__启动窗口_创建完毕

变量名	类 型	静态	数组	备 注
n1	整数型
ls	整数型
局变_总数	整数型
临时数组	整数型		0

置随机数种子 ()
局变_总数 ＝ 10000000
计时器启动 ()
重定义数组 (aaa, 假, 局变_总数)
计次循环首 (取数组成员数 (aaa), n1)
' ls ＝ aaa [n1]
aaa [n1] ＝ n1
计次循环尾 ()
计次循环首 (取数组成员数 (aaa), n1)
' ls ＝ aaa [n1]
ls ＝ ls ＋ aaa [n1]
' ls ＝ aaa [n1]
计次循环尾 ()
计时器结束 ()
调试输出 (ls, , , )
' 调试输出 (aaa)
ls ＝ 0
计时器启动 ()
ccc.创建内存数组_整数型 (局变_总数)
ccc.清零 ()
调试输出 (“=======================”)
计次循环首 (ccc.取数组成员数目 (), n1)
ccc.写整数_加速 (n1, n1)
计次循环尾 ()
调试输出 (“=======================”)
计次循环首 (ccc.取数组成员数目 (), n1)
' ' 调试输出 (ccc.读整数 (n1))
ls ＝ ls ＋ ccc.读整数_加速 (n1)
' ' ls ＝ ccc.读整数 (n1)
计次循环尾 ()
' 调试输出 (“=======================”)
调试输出 (ls, , , )
计时器结束 ()
' 结束 ()

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

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

' 写文件
ccc.创建内存数组_整数型 (100)
计次循环首 (ccc.取数组成员数目 (), n1)
ccc.写整数 (n1, n1)
计次循环尾 ()
ccc.写到文件 (“C:\数据.bin”)
ccc.清零 ()
调试输出 (“------------ ”)
' 从文件读回（自动创建数组）
ccc.从文件读入 (“C:\数据.bin”, )
计次循环首 (ccc.取数组成员数目 (), n1)
调试输出 (ccc.读整数 (n1))
计次循环尾 ()
鸣叫 ()

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

.版本 2<br /> .支持库 spec<br /> <br /> .程序集 窗口程序集_启动窗口<br /> .程序集变量 aaa, 整数型, , "0"<br /> .程序集变量 bbb, 整数型, , "0"<br /> .程序集变量 ccc, 类模块_整数型固定数组<br /> <br /> .子程序 __启动窗口_创建完毕<br /> .局部变量 n1, 整数型<br /> .局部变量 ls, 整数型<br /> .局部变量 局变_总数, 整数型<br /> .局部变量 临时数组, 整数型, , "0"<br /> <br /> 置随机数种子 ()<br /> <br /> 局变_总数 ＝ 10000000<br /> <br /> 计时器启动 ()<br /> 重定义数组 (aaa, 假, 局变_总数)<br /> .计次循环首 (取数组成员数 (aaa), n1)<br />     ' ls ＝ aaa [n1]<br />     aaa [n1] ＝ n1<br /> .计次循环尾 ()<br /> <br /> .计次循环首 (取数组成员数 (aaa), n1)<br />     ' ls ＝ aaa [n1]<br />     ls ＝ ls ＋ aaa [n1]<br />     ' ls ＝ aaa [n1]<br /> .计次循环尾 ()<br /> <br /> <br /> 计时器结束 ()<br /> <br /> <br /> 调试输出 (ls, , , )<br /> ' 调试输出 (aaa)<br /> ls ＝ 0<br /> <br /> <br /> 计时器启动 ()<br /> <br /> ccc.创建内存数组_整数型 (局变_总数)<br /> ccc.清零 ()<br /> <br /> <br /> 调试输出 (“=======================”)<br /> .计次循环首 (ccc.取数组成员数目 (), n1)<br />     ccc.写整数_加速 (n1, n1)<br /> .计次循环尾 ()<br /> 调试输出 (“=======================”)<br /> <br /> .计次循环首 (ccc.取数组成员数目 (), n1)<br /> <br />     ' ' 调试输出 (ccc.读整数 (n1))<br />     ls ＝ ls ＋ ccc.读整数_加速 (n1)<br />     ' ' ls ＝ ccc.读整数 (n1)<br /> .计次循环尾 ()<br /> ' 调试输出 (“=======================”)<br /> <br /> 调试输出 (ls, , , )<br /> 计时器结束 ()<br /> <br /> <br /> <br /> <br /> <br /> <br /> ' 结束 ()<br /> <br /> <br /> <br /> <br /> <br /> <br /> <br /> <br /> <br /> <br /> .子程序 _按钮1_被单击<br /> .局部变量 n1, 整数型<br /> <br /> <br /> <br /> ' 写文件<br /> ccc.创建内存数组_整数型 (100)<br /> .计次循环首 (ccc.取数组成员数目 (), n1)<br />     ccc.写整数 (n1, n1)<br /> .计次循环尾 ()<br /> <br /> ccc.写到文件 (“C:\数据.bin”)<br /> <br /> ccc.清零 ()<br /> <br /> 调试输出 (“------------ ”)<br /> <br /> ' 从文件读回（自动创建数组）<br /> ccc.从文件读入 (“C:\数据.bin”, )<br /> <br /> .计次循环首 (ccc.取数组成员数目 (), n1)<br /> <br />     调试输出 (ccc.读整数 (n1))<br /> <br /> .计次循环尾 ()<br /> <br /> 鸣叫 ()

  

窗口程序集名	保 留	保 留	备 注
类模块_整数型固定数组, , 公开
变量名	类 型	数组	备 注
程变_数组jz	整数型
程变_元素数量	整数型

子程序名	返回值类型	公开	备 注
_初始化			当基于本类的对象被创建后，此方法会被自动调用

子程序名	返回值类型	公开	备 注
_销毁			当基于本类的对象被销毁前，此方法会被自动调用

' 调试输出 (123456)
如果真 (程变_数组jz ≠ 0)
释放内存 (获取当前进程默认堆 (), 0, 程变_数组jz)
程变_数组jz ＝ 0
程变_元素数量 ＝ 0

子程序名	返回值类型	公开	备 注
创建内存数组_整数型	逻辑型
参数名	类 型	参考	可空	数组	备 注
参数_数组个数	整数型

变量名	类 型	静态	数组	备 注
局变_分配大小	整数型

如果真 (参数_数组个数 ≤ 0)
返回 (假)

局变_分配大小 ＝ 参数_数组个数 × 4
程变_数组jz ＝ 分配内存 (获取当前进程默认堆 (), 1, 局变_分配大小)
如果真 (程变_数组jz ＝ 0)
返回 (假)

程变_元素数量 ＝ 参数_数组个数
返回 (真)

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

' 调用系统 API 极速将整块内存全部置为 0
内存_填充 (程变_数组jz, 程变_元素数量 × 4, 0)

子程序名	返回值类型	公开	备 注
取数组成员数目	整数型

返回 (程变_元素数量)

子程序名	返回值类型	公开	备 注
写整数	逻辑型		有边界判断
参数名	类 型	参考	可空	数组	备 注
参数_索引	整数型
参数_值	整数型

如果真 (参数_索引 ＜ 1 或 参数_索引 ＞ 程变_元素数量)
返回 (假)

写整数_加速 (参数_索引, 参数_值)
返回 (真)

子程序名	返回值类型	公开	备 注
读整数	整数型		有边界判断
参数名	类 型	参考	可空	数组	备 注
参数_索引	整数型

如果真 (参数_索引 ＜ 1 或 参数_索引 ＞ 程变_元素数量)
返回 (0)

返回 (读整数_加速 (参数_索引))
' =============================================================================
' ========================== 内部极速读写（私有，无边界检查） ==================
' =============================================================================

子程序名	返回值类型	公开	备 注
写整数_加速			没有边界判断，需要自己把握
参数名	类 型	参考	可空	数组	备 注
参数_索引	整数型
参数_值	整数型

' 写内存 (-1, 数组jz ＋ (索引 － 1) × 4, 值, 4, 0)   慢
写整数到地址 (程变_数组jz ��� (参数_索引 － 1) × 4, 参数_值, 4)

子程序名	返回值类型	公开	备 注
读整数_加速	整数型		没有边界判断，需要自己把握
参数名	类 型	参考	可空	数组	备 注
参数_索引	整数型

变量名	类 型	静态	数组	备 注
局变_结果	整数型

' 读内存 (-1, 数组jz ＋ (索引 － 1) × 4, 结果, 4, 0)
从地址读整数 (局变_结果, 程变_数组jz ��� (参数_索引 － 1) × 4, 4)
返回 (局变_结果)
' =============================================================================
' ========================== 快速排序 =========================================
' =============================================================================

子程序名	返回值类型	公开	备 注
排序_快速

如果真 (程变_元素数量 ＞ 1)
快速排序_内部 (1, 程变_元素数量)

子程序名	返回值类型	公开	备 注
快速排序_内部
参数名	类 型	参考	可空	数组	备 注
参数_左边界	整数型
参数_右边界	整数型

变量名	类 型	静态	数组	备 注
局变_i	整数型
局变_j	整数型
局变_基准值	整数型
局变_临时值	整数型

局变_i ＝ 参数_左边界
局变_j ＝ 参数_右边界
局变_基准值 ＝ 读整数_加速 ( (参数_左边界 ＋ 参数_右边界) ÷ 2)
' 外层循环：使用判断循环首
判断循环首 (局变_i ≤ 局变_j)
' 内层寻找左边需要交换的元素
判断循环首 (读整数_加速 (局变_i) ＜ 局变_基准值)
局变_i ＝ 局变_i ＋ 1
判断循环尾 ()
' 内层寻找右边需要交换的元素
判断循环首 (读整数_加速 (局变_j) ＞ 局变_基准值)
局变_j ＝ 局变_j － 1
判断循环尾 ()
' 交换并移动指针
如果真 (局变_i ≤ 局变_j)
局变_临时值 ＝ 读整数_加速 (局变_i)
写整数_加速 (局变_i, 读整数_加速 (局变_j))
写整数_加速 (局变_j, 局变_临时值)
局变_i ＝ 局变_i ＋ 1
局变_j ＝ 局变_j － 1

判断循环尾 ()
' 递归处理左右两边
如果真 (参数_左边界 ＜ 局变_j)
快速排序_内部 (参数_左边界, 局变_j)
如果真 (局变_i ＜ 参数_右边界)
快速排序_内部 (局变_i, 参数_右边界)

子程序名	返回值类型	公开	备 注
写到文件	逻辑型		写出到二进制
参数名	类 型	参考	可空	数组	备 注
参数_文件名	文本型

变量名	类 型	静态	数组	备 注
局变_文件句柄	整数型
局变_实际写入	整数型

局变_文件句柄 ＝ 创建文件 (参数_文件名, 1073741824, 0, 0, 2, 128, 0)
如果真 (局变_文件句柄 ＝ -1 或 局变_文件句柄 ＝ 0)
返回 (假)

写文件 (局变_文件句柄, 程变_数组jz, 程变_元素数量 × 4, 局变_实际写入, 0)
关闭句柄 (局变_文件句柄)
' 总结口诀
' 写文件：创建文件(路径, &H40000000, 0, 0, 2, 128, 0)
' 读文件：创建文件(路径, &H80000000, 0, 0, 3, 128, 0)
' 读写：  创建文件(路径, &HC0000000, 0, 0, 4, 128, 0)
返回 (真)

子程序名	返回值类型	公开	备 注
从文件读入	逻辑型		二进制读入，元素数空时    自动检测
参数名	类 型	参考	可空	数组	备 注
参数_文件名	文本型
参数_元素数	整数型				, 留空则自动按文件大小计算

变量名	类 型	静态	数组	备 注
局变_文件句柄	整数型
局变_实际读取	整数型
局变_读取结果	逻辑型
局变_文件字节数	整数型

局变_文件句柄 ＝ 创建文件 (参数_文件名, 2147483648, 0, 0, 3, 128, 0)
如果真 (局变_文件句柄 ＝ -1 或 局变_文件句柄 ＝ 0)
返回 (假)

' 如果没传元素数，自动从文件大小算
如果真 (是否为空 (参数_元素数))
局变_文件字节数 ＝ 取文件大小 (局变_文件句柄, 0)
参数_元素数 ＝ 局变_文件字节数 ÷ 4

' 创建内存数组
如果真 (创建内存数组_整数型 (参数_元素数) ＝ 假)
关闭句柄 (局变_文件句柄)
返回 (假)

局变_读取结果 ＝ 读文件 (局变_文件句柄, 程变_数组jz, 参数_元素数 × 4, 局变_实际读取, 0)  ' 局变_实际读取= 元素个数*4
关闭句柄 (局变_文件句柄)
返回 (真)
' 大于 4GB 的问题
' GetFileSize 返回 32 位，超过 4GB 会溢出截断，算不准。但对你这个场景——
' 实际上不需要担心
' 4GB 文件 = 10亿个整数
' EPL 整数型最大值 = 2147483647 ≈ 21亿
' 10 亿个整数已经接近极限了，而且 HeapAlloc 单次分配 4GB 在 32 位进程里根本分配不出来（2GB 地址空间上限）。
' 所以你的内存数组类实际上不可能超过 4GB，GetFileSize 够用。

子程序名	返回值类型	公开	备 注
取jz	整数型		返回内存数组jz，可直接传给DLL

返回 (程变_数组jz)

子程序名	返回值类型	公开	备 注
取字节大小	整数型		返回元素数量×4

返回 (程变_元素数量 × 4)

子程序名	返回值类型	公开	备 注
拷贝到原生数组
参数名	类 型	参考	可空	数组	备 注
参数_目标数组	整数型

' 传 目标数组[1] 传址 = 数组数据区起始地址，直接一次 memcpy 完成
内存拷贝到数组 (参数_目标数组 [1], 程变_数组jz, 程变_元素数量 × 4)

子程序名	返回值类型	公开	备 注
从原生数组导入	逻辑型		把原生数组整块拷贝进内存数组
参数名	类 型	参考	可空	数组	备 注
参数_源数组	整数型

变量名	类 型	静态	数组	备 注
局变_源jz	整数型

如果真 (程变_数组jz ＝ 0)
返回 (假)

局变_源jz ＝ 取原生数组地址 (参数_源数组 [1], 参数_源数组 [1], 4)
内存_拷贝 (程变_数组jz, 局变_源jz, 程变_元素数量 × 4)
返回 (真)

子程序名	返回值类型	公开	备 注
原生数组写到文件	逻辑型		将整数型原生数组整块写入二进制文件
参数名	类 型	参考	可空	数组	备 注
参数_数组	整数型
参数_文件名	文本型

变量名	类 型	静态	数组	备 注
局变_jz	整数型
局变_文件句柄	整数型
局变_实际写入	整数型

局变_jz ＝ 取原生数组地址 (参数_数组 [1], 参数_数组 [1], 4)
局变_文件句柄 ＝ 创建文件 (参数_文件名, 1073741824, 0, 0, 2, 128, 0)
如果真 (局变_文件句柄 ＝ -1 或 局变_文件句柄 ＝ 0)
返回 (假)

写文件 (局变_文件句柄, 局变_jz, 取数组成员数 (参数_数组) × 4, 局变_实际写入, 0)
关闭句柄 (局变_文件句柄)
返回 (真)

子程序名	返回值类型	公开	备 注
原生数组从文件读入	逻辑型		从二进制文件读入到整数型原生数组，自动重定义大小
参数名	类 型	参考	可空	数组	备 注
参数_文件名	文本型
参数_数组	整数型

变量名	类 型	静态	数组	备 注
局变_jz	整数型
局变_文件句柄	整数型
局变_实际读取	整数型
局变_文件字节数	整数型

局变_文件句柄 ＝ 创建文件 (参数_文件名, 2147483648, 0, 0, 3, 128, 0)
如果真 (局变_文件句柄 ＝ -1 或 局变_文件句柄 ＝ 0)
返回 (假)

' 自动根据文件大小重定义数组
局变_文件字节数 ＝ 取文件大小 (局变_文件句柄, 0)
重定义数组 (参数_数组, 假, 局变_文件字节数 ÷ 4)
局变_jz ＝ 取原生数组地址 (参数_数组 [1], 参数_数组 [1], 4)
读文件 (局变_文件句柄, 局变_jz, 局变_文件字节数, 局变_实际读取, 0)
关闭句柄 (局变_文件句柄)
返回 (真)

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

' =============================================================================
' ========================== 初始化与销毁 =====================================
' 从指定堆分配内存 (对应易语言中的 申请内存)
' 获取当前进程默认堆 (配合 HeapAlloc 使用)
' 释放已分配的内存块 (对应易语言中的 释放内存)
' 向指定内存地址写入数据 (用来实现 写内存整数型)
' 从指定内存地址读取数据 (用来实现 读内存整数型)
' =============================================================================
' 核心问题：用错了 API
' 你现在用的 WriteProcessMemory / ReadProcessMemory 是跨进程内存访问 API，每次调用都要：
' 进入内核态（ring0）
' 做安全权限检查
' 返回用户态（ring3）
' 同一个进程内读写自己的内存，根本不需要这条路，开销白白浪费了。
' 解决方案：换用 RtlMoveMemory（用户态，零内核开销）
' RtlMoveMemory 就是 memcpy，纯用户态，没有任何内核切换，是同进程内存拷贝最快的系统函数。

.版本 2<br /> <br /> .程序集 类模块_整数型固定数组, , 公开<br /> .程序集变量 程变_数组jz, 整数型<br /> .程序集变量 程变_元素数量, 整数型<br /> <br /> .子程序 _初始化, , , 当基于本类的对象被创建后，此方法会被自动调用<br /> <br /> <br /> <br /> .子程序 _销毁, , , 当基于本类的对象被销毁前，此方法会被自动调用<br /> <br /> ' 调试输出 (123456)<br /> .如果真 (程变_数组jz ≠ 0)<br />     释放内存 (获取当前进程默认堆 (), 0, 程变_数组jz)<br />     程变_数组jz ＝ 0<br />     程变_元素数量 ＝ 0<br /> .如果真结束<br /> <br /> <br /> .子程序 创建内存数组_整数型, 逻辑型, 公开<br /> .参数 参数_数组个数, 整数型<br /> .局部变量 局变_分配大小, 整数型<br /> <br /> .如果真 (参数_数组个数 ≤ 0)<br />     返回 (假)<br /> .如果真结束<br /> <br /> 局变_分配大小 ＝ 参数_数组个数 × 4<br /> 程变_数组jz ＝ 分配内存 (获取当前进程默认堆 (), 1, 局变_分配大小)<br /> <br /> .如果真 (程变_数组jz ＝ 0)<br />     返回 (假)<br /> .如果真结束<br /> <br /> 程变_元素数量 ＝ 参数_数组个数<br /> 返回 (真)<br /> <br /> .子程序 清零, , 公开<br /> <br /> ' 调用系统 API 极速将整块内存全部置为 0<br /> 内存_填充 (程变_数组jz, 程变_元素数量 × 4, 0)<br /> <br /> <br /> .子程序 取数组成员数目, 整数型, 公开<br /> <br /> 返回 (程变_元素数量)<br /> <br /> <br /> <br /> <br /> .子程序 写整数, 逻辑型, 公开, 有边界判断<br /> .参数 参数_索引, 整数型<br /> .参数 参数_值, 整数型<br /> <br /> .如果真 (参数_索引 ＜ 1 或 参数_索引 ＞ 程变_元素数量)<br />     返回 (假)<br /> .如果真结束<br /> <br /> 写整数_加速 (参数_索引, 参数_值)<br /> 返回 (真)<br /> <br /> .子程序 读整数, 整数型, 公开, 有边界判断<br /> .参数 参数_索引, 整数型<br /> <br /> .如果真 (参数_索引 ＜ 1 或 参数_索引 ＞ 程变_元素数量)<br />     返回 (0)<br /> .如果真结束<br /> <br /> 返回 (读整数_加速 (参数_索引))<br /> <br /> <br /> <br /> ' =============================================================================<br /> ' ========================== 内部极速读写（私有，无边界检查） ==================<br /> ' =============================================================================<br /> <br /> <br /> .子程序 写整数_加速, , 公开, 没有边界判断，需要自己把握<br /> .参数 参数_索引, 整数型<br /> .参数 参数_值, 整数型<br /> <br /> ' 写内存 (-1, 数组jz ＋ (索引 － 1) × 4, 值, 4, 0)   慢<br /> 写整数到地址 (程变_数组jz ＋ (参数_索引 － 1) × 4, 参数_值, 4)<br /> <br /> .子程序 读整数_加速, 整数型, 公开, 没有边界判断，需要自己把握<br /> .参数 参数_索引, 整数型<br /> .局部变量 局变_结果, 整数型<br /> <br /> <br /> ' 读内存 (-1, 数组jz ＋ (索引 － 1) × 4, 结果, 4, 0)<br /> 从地址读整数 (局变_结果, 程变_数组jz ＋ (参数_索引 － 1) × 4, 4)<br /> <br /> 返回 (局变_结果)<br /> ' =============================================================================<br /> ' ========================== 快速排序 =========================================<br /> ' =============================================================================<br /> <br /> <br /> .子程序 排序_快速, , 公开<br /> <br /> .如果真 (程变_元素数量 ＞ 1)<br />     快速排序_内部 (1, 程变_元素数量)<br /> .如果真结束<br /> <br /> <br /> .子程序 快速排序_内部<br /> .参数 参数_左边界, 整数型<br /> .参数 参数_右边界, 整数型<br /> .局部变量 局变_i, 整数型<br /> .局部变量 局变_j, 整数型<br /> .局部变量 局变_基准值, 整数型<br /> .局部变量 局变_临时值, 整数型<br /> <br /> 局变_i ＝ 参数_左边界<br /> 局变_j ＝ 参数_右边界<br /> 局变_基准值 ＝ 读整数_加速 ((参数_左边界 ＋ 参数_右边界) ÷ 2)<br /> <br /> ' 外层循环：使用判断循环首<br /> .判断循环首 (局变_i ≤ 局变_j)<br />     ' 内层寻找左边需要交换的元素<br />     .判断循环首 (读整数_加速 (局变_i) ＜ 局变_基准值)<br />         局变_i ＝ 局变_i ＋ 1<br />     .判断循环尾 ()<br /> <br />     ' 内层寻找右边需要交换的元素<br />     .判断循环首 (读整数_加速 (局变_j) ＞ 局变_基准值)<br />         局变_j ＝ 局变_j － 1<br />     .判断循环尾 ()<br /> <br />     ' 交换并移动指针<br />     .如果真 (局变_i ≤ 局变_j)<br />         局变_临时值 ＝ 读整数_加速 (局变_i)<br />         写整数_加速 (局变_i, 读整数_加速 (局变_j))<br />         写整数_加速 (局变_j, 局变_临时值)<br /> <br />         局变_i ＝ 局变_i ＋ 1<br />         局变_j ＝ 局变_j － 1<br />     .如果真结束<br /> <br /> .判断循环尾 ()<br /> <br /> ' 递归处理左右两边<br /> .如果真 (参数_左边界 ＜ 局变_j)<br />     快速排序_内部 (参数_左边界, 局变_j)<br /> .如果真结束<br /> .如果真 (局变_i ＜ 参数_右边界)<br />     快速排序_内部 (局变_i, 参数_右边界)<br /> .如果真结束<br /> <br /> <br /> .子程序 写到文件, 逻辑型, 公开, 写出到二进制<br /> .参数 参数_文件名, 文本型<br /> .局部变量 局变_文件句柄, 整数型<br /> .局部变量 局变_实际写入, 整数型<br /> <br /> 局变_文件句柄 ＝ 创建文件 (参数_文件名, 1073741824, 0, 0, 2, 128, 0)<br /> .如果真 (局变_文件句柄 ＝ -1 或 局变_文件句柄 ＝ 0)<br />     返回 (假)<br /> .如果真结束<br /> <br /> 写文件 (局变_文件句柄, 程变_数组jz, 程变_元素数量 × 4, 局变_实际写入, 0)<br /> 关闭句柄 (局变_文件句柄)<br /> <br /> ' 总结口诀<br /> ' 写文件：创建文件(路径, &H40000000, 0, 0, 2, 128, 0)<br /> ' 读文件：创建文件(路径, &H80000000, 0, 0, 3, 128, 0)<br /> ' 读写：  创建文件(路径, &HC0000000, 0, 0, 4, 128, 0)<br /> 返回 (真)<br /> <br /> .子程序 从文件读入, 逻辑型, 公开, 二进制读入，元素数空时    自动检测<br /> .参数 参数_文件名, 文本型<br /> .参数 参数_元素数, 整数型, 可空, , 留空则自动按文件大小计算<br /> .局部变量 局变_文件句柄, 整数型<br /> .局部变量 局变_实际读取, 整数型<br /> .局部变量 局变_读取结果, 逻辑型<br /> .局部变量 局变_文件字节数, 整数型<br /> <br /> 局变_文件句柄 ＝ 创建文件 (参数_文件名, 2147483648, 0, 0, 3, 128, 0)<br /> .如果真 (局变_文件句柄 ＝ -1 或 局变_文件句柄 ＝ 0)<br />     返回 (假)<br /> .如果真结束<br /> <br /> ' 如果没传元素数，自动从文件大小算<br /> .如果真 (是否为空 (参数_元素数))<br />     局变_文件字节数 ＝ 取文件大小 (局变_文件句柄, 0)<br />     参数_元素数 ＝ 局变_文件字节数 ÷ 4<br /> .如果真结束<br /> <br /> ' 创建内存数组<br /> .如果真 (创建内存数组_整数型 (参数_元素数) ＝ 假)<br />     关闭句柄 (局变_文件句柄)<br />     返回 (假)<br /> .如果真结束<br /> <br /> 局变_读取结果 ＝ 读文件 (局变_文件句柄, 程变_数组jz, 参数_元素数 × 4, 局变_实际读取, 0)  ' 局变_实际读取= 元素个数*4<br /> 关闭句柄 (局变_文件句柄)<br /> 返回 (真)<br /> <br /> ' 大于 4GB 的问题<br /> ' GetFileSize 返回 32 位，超过 4GB 会溢出截断，算不准。但对你这个场景——<br /> <br /> ' 实际上不需要担心<br /> ' 4GB 文件 = 10亿个整数<br /> ' EPL 整数型最大值 = 2147483647 ≈ 21亿<br /> ' 10 亿个整数已经接近极限了，而且 HeapAlloc 单次分配 4GB 在 32 位进程里根本分配不出来（2GB 地址空间上限）。<br /> <br /> ' 所以你的内存数组类实际上不可能超过 4GB，GetFileSize 够用。<br /> <br /> <br /> <br /> .子程序 取jz, 整数型, 公开, 返回内存数组jz，可直接传给DLL<br /> <br /> 返回 (程变_数组jz)<br /> <br /> .子程序 取字节大小, 整数型, 公开, 返回元素数量×4<br /> <br /> 返回 (程变_元素数量 × 4)<br /> <br /> <br /> <br /> <br /> <br /> .子程序 拷贝到原生数组, , 公开<br /> .参数 参数_目标数组, 整数型, 参考 数组<br /> <br /> ' 传 目标数组[1] 传址 = 数组数据区起始地址，直接一次 memcpy 完成<br /> 内存拷贝到数组 (参数_目标数组 [1], 程变_数组jz, 程变_元素数量 × 4)<br /> <br /> .子程序 从原生数组导入, 逻辑型, 公开, 把原生数组整块拷贝进内存数组<br /> .参数 参数_源数组, 整数型, 参考 数组<br /> .局部变量 局变_源jz, 整数型<br /> <br /> .如果真 (程变_数组jz ＝ 0)<br />     返回 (假)<br /> .如果真结束<br /> <br /> 局变_源jz ＝ 取原生数组地址 (参数_源数组 [1], 参数_源数组 [1], 4)<br /> 内存_拷贝 (程变_数组jz, 局变_源jz, 程变_元素数量 × 4)<br /> 返回 (真)<br /> <br /> <br /> <br /> <br /> .子程序 原生数组写到文件, 逻辑型, 公开, 将整数型原生数组整块写入二进制文件<br /> .参数 参数_数组, 整数型, 参考 数组<br /> .参数 参数_文件名, 文本型<br /> .局部变量 局变_jz, 整数型<br /> .局部变量 局变_文件句柄, 整数型<br /> .局部变量 局变_实际写入, 整数型<br /> <br /> 局变_jz ＝ 取原生数组地址 (参数_数组 [1], 参数_数组 [1], 4)<br /> 局变_文件句柄 ＝ 创建文件 (参数_文件名, 1073741824, 0, 0, 2, 128, 0)<br /> .如果真 (局变_文件句柄 ＝ -1 或 局变_文件句柄 ＝ 0)<br />     返回 (假)<br /> .如果真结束<br /> <br /> 写文件 (局变_文件句柄, 局变_jz, 取数组成员数 (参数_数组) × 4, 局变_实际写入, 0)<br /> 关闭句柄 (局变_文件句柄)<br /> 返回 (真)<br /> <br /> .子程序 原生数组从文件读入, 逻辑型, 公开, 从二进制文件读入到整数型原生数组，自动重定义大小<br /> .参数 参数_文件名, 文本型<br /> .参数 参数_数组, 整数型, 参考 数组<br /> .局部变量 局变_jz, 整数型<br /> .局部变量 局变_文件句柄, 整数型<br /> .局部变量 局变_实际读取, 整数型<br /> .局部变量 局变_文件字节数, 整数型<br /> <br /> 局变_文件句柄 ＝ 创建文件 (参数_文件名, 2147483648, 0, 0, 3, 128, 0)<br /> .如果真 (局变_文件句柄 ＝ -1 或 局变_文件句柄 ＝ 0)<br />     返回 (假)<br /> .如果真结束<br /> <br /> ' 自动根据文件大小重定义数组<br /> 局变_文件字节数 ＝ 取文件大小 (局变_文件句柄, 0)<br /> 重定义数组 (参数_数组, 假, 局变_文件字节数 ÷ 4)<br /> <br /> 局变_jz ＝ 取原生数组地址 (参数_数组 [1], 参数_数组 [1], 4)<br /> 读文件 (局变_文件句柄, 局变_jz, 局变_文件字节数, 局变_实际读取, 0)<br /> 关闭句柄 (局变_文件句柄)<br /> 返回 (真)<br /> <br /> .子程序 <br /> <br /> ' =============================================================================<br /> ' ========================== 初始化与销毁 =====================================<br /> ' 从指定堆分配内存 (对应易语言中的 申请内存)<br /> ' 获取当前进程默认堆 (配合 HeapAlloc 使用)<br /> ' 释放已分配的内存块 (对应易语言中的 释放内存)<br /> ' 向指定内存地址写入数据 (用来实现 写内存整数型)<br /> ' 从指定内存地址读取数据 (用来实现 读内存整数型)<br /> ' =============================================================================<br /> ' 核心问题：用错了 API<br /> ' 你现在用的 WriteProcessMemory / ReadProcessMemory 是跨进程内存访问 API，每次调用都要：<br /> <br /> ' 进入内核态（ring0）<br /> ' 做安全权限检查<br /> ' 返回用户态（ring3）<br /> ' 同一个进程内读写自己的内存，根本不需要这条路，开销白白浪费了。<br /> <br /> ' 解决方案：换用 RtlMoveMemory（用户态，零内核开销）<br /> ' RtlMoveMemory 就是 memcpy，纯用户态，没有任何内核切换，是同进程内存拷贝最快的系统函数。

  

DLL命令名	返回值类型	公开	备 注
分配内存	整数型		从指定堆分配内存 (对应易语言中的 申请内存)
DLL库文件名:
kernel32.dll
在DLL库中对应命令名:
HeapAlloc
参数名	类 型	传址	数组	备 注
hHeap	整数型			' 堆句柄
dwFlags	整数型			' 分配标志 (1表示分配后自动清零)
dwBytes	整数型			' 请求的字节数

DLL命令名	返回值类型	公开	备 注
获取当前进程默认堆	整数型		获取当前进程默认堆 (配合 HeapAlloc 使用)
DLL库文件名:
kernel32.dll
在DLL库中对应命令名:
GetProcessHeap
参数名	类 型	传址	数组	备 注

DLL命令名	返回值类型	公开	备 注
释放内存	整数型		释放已分配的内存块 (对应易语言中的 释放内存)
DLL库文件名:
kernel32.dll
在DLL库中对应命令名:
HeapFree
参数名	类 型	传址	数组	备 注
hHeap	整数型			' 堆句柄
dwFlags	整数型			' 释放标志 (填 0 即可)
lpMem	整数型			' 要释放的内存地址

DLL命令名	返回值类型	公开	备 注
内存_填充
DLL库文件名:
kernel32.dll
在DLL库中对应命令名:
RtlFillMemory
参数名	类 型	传址	数组	备 注
目标地址	整数型
长度	整数型
填充字节	字节型

DLL命令名	返回值类型	公开	备 注
内存_拷贝
DLL库文件名:
kernel32.dll
在DLL库中对应命令名:
RtlMoveMemory
参数名	类 型	传址	数组	备 注
目标地址	整数型
源地址	整数型
长度	整数型

DLL命令名	返回值类型	公开	备 注
DLL命令1
DLL库文件名:
在DLL库中对应命令名:
DLL命令1
参数名	类 型	传址	数组	备 注

DLL命令名	返回值类型	公开	备 注
写整数到地址
DLL库文件名:
kernel32.dll
在DLL库中对应命令名:
RtlMoveMemory
参数名	类 型	传址	数组	备 注
目标地址	整数型			' 目标内存地址（值传递）
源值	整数型
长度	整数型			' 固定填 4

DLL命令名	返回值类型	公开	备 注
从地址读整数
DLL库文件名:
kernel32.dll
在DLL库中对应命令名:
RtlMoveMemory
参数名	类 型	传址	数组	备 注
目标变量	整数型
源地址	整数型			' 要读取的内存地址（值传递）
长度	整数型			' 固定填 4

DLL命令名	返回值类型	公开	备 注
内存拷贝到数组
DLL库文件名:
kernel32.dll
在DLL库中对应命令名:
RtlMoveMemory
参数名	类 型	传址	数组	备 注
目标首元素	整数型
源地址	整数型			' 传内存数组的jz（整数值）
长度	整数型			' 拷贝的字节数

DLL命令名	返回值类型	公开	备 注
DLL命令2
DLL库文件名:
在DLL库中对应命令名:
DLL命令2
参数名	类 型	传址	数组	备 注

DLL命令名	返回值类型	公开	备 注
创建文件	整数型
DLL库文件名:
kernel32.dll
在DLL库中对应命令名:
CreateFileA
参数名	类 型	传址	数组	备 注
文件名	文本型			, 文件完整路径
访问模式	整数型			, 写=1073741824 读=2147483648    1073741824 0x40000000 GENERIC_WRITE 写权限    2147483648 0x80000000 GENERIC_READ 读权限     可以组合：1073741824 + 2147483648 = 3221225472 = 又读又写
共享模式	整数型			, 填0    0 不共享，别人打不开这个文件   1 FILE_SHARE_READ，别人可以同时读    2 FILE_SHARE_WRITE，别人可以同时写
安全属性	整数型			, 填0    填 0 = 用默认安全描述符，普通程序不需要管这个。
创建方式	整数型			, 新建=2 覆盖=4 打开=3   1    CREATE_NEW    新建，已存在则失败    —2    CREATE_ALWAYS    总是创建，已存在则截断后覆盖    ? 会截断3    OPEN_EXISTING    仅打开，不存在则失败    ?4    OPEN_ALWAYS    打开或创建，不截断    ? 不截断！5    TRUNCATE_EXISTING    截断已存在文件 截断为0，文件不存在则失败
标志属性	整数型			, 填128   128 FILE_ATTRIBUTE_NORMAL 普通文件，无特殊属性    1    只读2    隐藏4    系统32    存档
模板句柄	整数型			, 填0    填 0，不使用模板文件。

DLL命令名	返回值类型	公开	备 注
写文件	逻辑型
DLL库文件名:
kernel32.dll
在DLL库中对应命令名:
WriteFile
参数名	类 型	传址	数组	备 注
文件句柄	整数型			, CreateFile返回的句柄
缓冲区地址	整数型			, 传入数组jz
写入字节数	整数型			, 元素数量×4
实际写入数	整数型			, 接收实际写入字节数
重叠结构	整数型			, 同步操作填0

DLL命令名	返回值类型	公开	备 注
读文件	逻辑型
DLL库文件名:
kernel32.dll
在DLL库中对应命令名:
ReadFile
参数名	类 型	传址	数组	备 注
文件句柄	整数型			, CreateFile返回的句柄
缓冲区地址	整数型			, 传入数组jz数据直接填入
读取字节数	整数型			, 元素数量×4
实际读取数	整数型			, 接收实际读取字节数
重叠结构	整数型			, 同步操作填0

DLL命令名	返回值类型	公开	备 注
关闭句柄	逻辑型
DLL库文件名:
kernel32.dll
在DLL库中对应命令名:
CloseHandle
参数名	类 型	传址	数组	备 注
句柄	整数型			, 要关闭的句柄

DLL命令名	返回值类型	公开	备 注
取原生数组地址	整数型
DLL库文件名:
kernel32.dll
在DLL库中对应命令名:
lstrcpynA
参数名	类 型	传址	数组	备 注
目标	整数型			, 传aaa[1]得到数组jz
源	整数型			, 同上传aaa[1]
最大长度	整数型			, 填4

DLL命令名	返回值类型	公开	备 注
取文件大小	整数型
DLL库文件名:
kernel32.dll
在DLL库中对应命令名:
GetFileSize
参数名	类 型	传址	数组	备 注
文件句柄	整数型			, CreateFile返回的句柄
高位	整数型			, 填0，文件小于4GB不用管

DLL命令名	返回值类型	公开	备 注
DLL命令3
DLL库文件名:
在DLL库中对应命令名:
DLL命令3
参数名	类 型	传址	数组	备 注

.版本 2<br /> <br /> .DLL命令 分配内存, 整数型, "kernel32.dll", "HeapAlloc", , 从指定堆分配内存 (对应易语言中的 申请内存)<br />     .参数 hHeap, 整数型, ,  ' 堆句柄<br />     .参数 dwFlags, 整数型, , ' 分配标志 (1表示分配后自动清零)<br />     .参数 dwBytes, 整数型, ,  ' 请求的字节数<br /> <br /> .DLL命令 获取当前进程默认堆, 整数型, "kernel32.dll", "GetProcessHeap", , 获取当前进程默认堆 (配合 HeapAlloc 使用)<br /> <br /> .DLL命令 释放内存, 整数型, "kernel32.dll", "HeapFree", , 释放已分配的内存块 (对应易语言中的 释放内存)<br />     .参数 hHeap, 整数型, ,  ' 堆句柄<br />     .参数 dwFlags, 整数型, ,  ' 释放标志 (填 0 即可)<br />     .参数 lpMem, 整数型, ,  ' 要释放的内存地址<br /> <br /> .DLL命令 内存_填充, , "kernel32.dll", "RtlFillMemory"<br />     .参数 目标地址, 整数型<br />     .参数 长度, 整数型<br />     .参数 填充字节, 字节型<br /> <br /> .DLL命令 内存_拷贝, , "kernel32.dll", "RtlMoveMemory"<br />     .参数 目标地址, 整数型<br />     .参数 源地址, 整数型<br />     .参数 长度, 整数型<br /> <br /> .DLL命令 DLL命令1<br /> <br /> .DLL命令 写整数到地址, , "kernel32.dll", "RtlMoveMemory"<br />     .参数 目标地址, 整数型, ,   ' 目标内存地址（值传递）<br />     .参数 源值, 整数型, 传址<br />     .参数 长度, 整数型, ,  ' 固定填 4<br /> <br /> .DLL命令 从地址读整数, , "kernel32.dll", "RtlMoveMemory"<br />     .参数 目标变量, 整数型, 传址<br />     .参数 源地址, 整数型, ,   ' 要读取的内存地址（值传递）<br />     .参数 长度, 整数型, ,   ' 固定填 4<br /> <br /> .DLL命令 内存拷贝到数组, , "kernel32.dll", "RtlMoveMemory"<br />     .参数 目标首元素, 整数型, 传址<br />     .参数 源地址, 整数型, ,  ' 传内存数组的jz（整数值）<br />     .参数 长度, 整数型, ,    ' 拷贝的字节数<br /> <br /> .DLL命令 DLL命令2<br /> <br /> .DLL命令 创建文件, 整数型, "kernel32.dll", "CreateFileA"<br />     .参数 文件名, 文本型, , , 文件完整路径<br />     .参数 访问模式, 整数型, , , 写=1073741824 读=2147483648    1073741824 0x40000000 GENERIC_WRITE 写权限    2147483648 0x80000000 GENERIC_READ 读权限     可以组合：1073741824 + 2147483648 = 3221225472 = 又读又写<br />     .参数 共享模式, 整数型, , , 填0    0 不共享，别人打不开这个文件   1 FILE_SHARE_READ，别人可以同时读    2 FILE_SHARE_WRITE，别人可以同时写<br />     .参数 安全属性, 整数型, , , 填0    填 0 = 用默认安全描述符，普通程序不需要管这个。<br />     .参数 创建方式, 整数型, , , 新建=2 覆盖=4 打开=3   1    CREATE_NEW    新建，已存在则失败    —2    CREATE_ALWAYS    总是创建，已存在则截断后覆盖    ? 会截断3    OPEN_EXISTING    仅打开，不存在则失败    ?4    OPEN_ALWAYS    打开或创建，不截断    ? 不截断！5    TRUNCATE_EXISTING    截断已存在文件 截断为0，文件不存在则失败<br />     .参数 标志属性, 整数型, , , 填128   128 FILE_ATTRIBUTE_NORMAL 普通文件，无特殊属性    1    只读2    隐藏4    系统32    存档<br />     .参数 模板句柄, 整数型, , , 填0    填 0，不使用模板文件。<br /> <br /> .DLL命令 写文件, 逻辑型, "kernel32.dll", "WriteFile"<br />     .参数 文件句柄, 整数型, , , CreateFile返回的句柄<br />     .参数 缓冲区地址, 整数型, , , 传入数组jz<br />     .参数 写入字节数, 整数型, , , 元素数量×4<br />     .参数 实际写入数, 整数型, 传址, , 接收实际写入字节数<br />     .参数 重叠结构, 整数型, , , 同步操作填0<br /> <br /> .DLL命令 读文件, 逻辑型, "kernel32.dll", "ReadFile"<br />     .参数 文件句柄, 整数型, , , CreateFile返回的句柄<br />     .参数 缓冲区地址, 整数型, , , 传入数组jz数据直接填入<br />     .参数 读取字节数, 整数型, , , 元素数量×4<br />     .参数 实际读取数, 整数型, 传址, , 接收实际读取字节数<br />     .参数 重叠结构, 整数型, , , 同步操作填0<br /> <br /> .DLL命令 关闭句柄, 逻辑型, "kernel32.dll", "CloseHandle"<br />     .参数 句柄, 整数型, , , 要关闭的句柄<br /> <br /> .DLL命令 取原生数组地址, 整数型, "kernel32.dll", "lstrcpynA"<br />     .参数 目标, 整数型, 传址, , 传aaa[1]得到数组jz<br />     .参数 源, 整数型, 传址, , 同上传aaa[1]<br />     .参数 最大长度, 整数型, , , 填4<br /> <br /> .DLL命令 取文件大小, 整数型, "kernel32.dll", "GetFileSize"<br />     .参数 文件句柄, 整数型, , , CreateFile返回的句柄<br />     .参数 高位, 整数型, , , 填0，文件小于4GB不用管<br /> <br /> .DLL命令 DLL命令3

内存数组.zip

7 天前 上传

点击文件名下载附件

下载积分: 精币 -2 枚

184.85 KB, 下载次数: 7, 下载积分: 精币 -2 枚

---

作者: APPLEUFO    时间: 7 天前
WorkBuddy
深度思考
老实说：单元素读写已经接近 EPL 的极限了
每次调用的开销拆解：

写整数_加速(索引, 值)
  → EPL 压栈/跳转（~10ns）
    → 写整数到地址 DLL IAT 跳转（~5ns）
      → RtlMoveMemory 内部（~5ns）
        → 实际写 4 字节（~1ns）
真正干活的只有最后 1ns，前面 20ns 都是调用开销。 EPL 的函数调用机制你改不了。

三条路，收益递减
路线1：批量操作（已实现，最实用）
热循环里不要逐个读，拷贝到原生数组再遍历。前面已经做过了，78ms → 47ms。

路线2：写个 C DLL 做热循环
把整个循环搬进 C 里，EPL 只调一次：

c
复制
// fastlib.c → 编译成 fastlib.dll
__declspec(dllexport) int __cdecl SumArray(int* base, int count) {
    int sum = 0;
    for (int i = 0; i < count; i++) {
        sum += base[i];    // 编译成单条 MOV 指令
    }
    return sum;
}
EPL 调用：

epl
复制
.DLL命令 求和, 整数型, "fastlib.dll", "SumArray"
    .参数 基址, 整数型, , , 内存数组基址
    .参数 数量, 整数型, , , 元素个数

结果 ＝ 求和 (ccc.取基址 (), ccc.取数组成员数目 ())
一次调用完成 100 万次累加，时间接近 0。 这才是真正消灭调用开销的办法。

路线3：EPL 置入代码（内联汇编）
EPL 支持 置入代码 写机器码，但极度脆弱，换个编译器版本可能就崩：

epl
复制
.子程序 写整数_极速, , 公开, 内联汇编版，不稳定慎用
.参数 参数_地址, 整数型       ' 直接传地址，不是索引
.参数 参数_值, 整数型

' mov eax, [ebp+12]  ; 取值
' mov [ebp+8], eax   ; 写入地址
' 不推荐，维护成本太高
置入代码 ({ 139, 69, 12, 139, 85, 8, 137, 2 })
不推荐用在正式项目里，调试困难，一崩就整个程序挂。

建议
方法        速度        可靠性        推荐度
拷贝到原生数组        快        ✅ 稳定        ⭐⭐⭐ 首选
C DLL 做热循环        最快        ✅ 稳定        ⭐⭐⭐ 高频场景必用
置入代码        理论最快        ❌ 脆弱        ⭐ 不推荐
你的量化筛选如果真到了性能瓶颈，写个 C DLL 是正路。 几十行 C 代码就能把排序、累加、筛选全做了，EPL 只负责界面和流程控制。

---

作者: APPLEUFO    时间: 7 天前

WorkBuddy
深度思考
老实说：单元素读写已经接近 EPL 的极限了
每次调用的开销拆解：

写整数_加速(索引, 值)
  → EPL 压栈/跳转（~10ns）
    → 写整数到地址 DLL IAT 跳转（~5ns）
      → RtlMoveMemory 内部（~5ns）
        → 实际写 4 字节（~1ns）
真正干活的只有最后 1ns，前面 20ns 都是调用开销。 EPL 的函数调用机制你改不了。

三条路，收益递减
路线1：批量操作（已实现，最实用）
热循环里不要逐个读，拷贝到原生数组再遍历。前面已经做过了，78ms → 47ms。

路线2：写个 C DLL 做热循环
把整个循环搬进 C 里，EPL 只调一次：

c
复制
// fastlib.c → 编译成 fastlib.dll
__declspec(dllexport) int __cdecl SumArray(int* base, int count) {
    int sum = 0;
    for (int i = 0; i < count; i++) {
        sum += base;    // 编译成单条 MOV 指令
    }
    return sum;
}
EPL 调用：

epl
复制
.DLL命令 求和, 整数型, "fastlib.dll", "SumArray"
    .参数 基址, 整数型, , , 内存数组基址
    .参数 数量, 整数型, , , 元素个数

结果 ＝ 求和 (ccc.取基址 (), ccc.取数组成员数目 ())
一次调用完成 100 万次累加，时间接近 0。 这才是真正消灭调用开销的办法。

路线3：EPL 置入代码（内联汇编）
EPL 支持 置入代码 写机器码，但极度脆弱，换个编译器版本可能就崩：

epl
复制
.子程序 写整数_极速, , 公开, 内联汇编版，不稳定慎用
.参数 参数_地址, 整数型       ' 直接传地址，不是索引
.参数 参数_值, 整数型

' mov eax, [ebp+12]  ; 取值
' mov [ebp+8], eax   ; 写入地址
' 不推荐，维护成本太高
置入代码 ({ 139, 69, 12, 139, 85, 8, 137, 2 })
不推荐用在正式项目里，调试困难，一崩就整个程序挂。

建议
方法        速度        可靠性        推荐度
拷贝到原生数组        快        ? 稳定        ??? 首选
C DLL 做热循环        最快        ? 稳定        ??? 高频场景必用
置入代码        理论最快        ? 脆弱        ? 不推荐
你的量化筛选如果真到了性能瓶颈，写个 C DLL 是正路。 几十行 C 代码就能把排序、累加、筛选全做了，EPL 只负责界面和流程控制。

龙虾对  读写瓶颈 这样说

---

作者: APPLEUFO    时间: 7 天前
WorkBuddy
深度思考
老实说：单元素读写已经接近 EPL 的极限了
每次调用的开销拆解：

写整数_加速(索引, 值)
  → EPL 压栈/跳转（~10ns）
    → 写整数到地址 DLL IAT 跳转（~5ns）
      → RtlMoveMemory 内部（~5ns）
        → 实际写 4 字节（~1ns）
真正干活的只有最后 1ns，前面 20ns 都是调用开销。 EPL 的函数调用机制你改不了。

三条路，收益递减
路线1：批量操作（已实现，最实用）
热循环里不要逐个读，拷贝到原生数组再遍历。前面已经做过了，78ms → 47ms。

路线2：写个 C DLL 做热循环
把整个循环搬进 C 里，EPL 只调一次：

c
复制
// fastlib.c → 编译成 fastlib.dll
__declspec(dllexport) int __cdecl SumArray(int* base, int count) {
    int sum = 0;
    for (int i = 0; i < count; i++) {
        sum += base[i];    // 编译成单条 MOV 指令
    }
    return sum;
}
EPL 调用：

epl
复制
.DLL命令 求和, 整数型, "fastlib.dll", "SumArray"
    .参数 基址, 整数型, , , 内存数组基址
    .参数 数量, 整数型, , , 元素个数

结果 ＝ 求和 (ccc.取基址 (), ccc.取数组成员数目 ())
一次调用完成 100 万次累加，时间接近 0。 这才是真正消灭调用开销的办法。

路线3：EPL 置入代码（内联汇编）
EPL 支持 置入代码 写机器码，但极度脆弱，换个编译器版本可能就崩：

epl
复制
.子程序 写整数_极速, , 公开, 内联汇编版，不稳定慎用
.参数 参数_地址, 整数型       ' 直接传地址，不是索引
.参数 参数_值, 整数型

' mov eax, [ebp+12]  ; 取值
' mov [ebp+8], eax   ; 写入地址
' 不推荐，维护成本太高
置入代码 ({ 139, 69, 12, 139, 85, 8, 137, 2 })
不推荐用在正式项目里，调试困难，一崩就整个程序挂。

建议
方法        速度        可靠性        推荐度
拷贝到原生数组        快        ? 稳定        ??? 首选
C DLL 做热循环        最快        ? 稳定        ??? 高频场景必用
置入代码        理论最快        ? 脆弱        ? 不推荐
你的量化筛选如果真到了性能瓶颈，写个 C DLL 是正路。 几十行 C 代码就能把排序、累加、筛选全做了，EPL 只负责界面和流程控制。



龙虾对  读写瓶颈 这样说

---

作者: APPLEUFO    时间: 7 天前
WorkBuddy
深度思考
老实说：单元素读写已经接近 EPL 的极限了
每次调用的开销拆解：

写整数_加速(索引, 值)
  → EPL 压栈/跳转（~10ns）
    → 写整数到地址 DLL IAT 跳转（~5ns）
      → RtlMoveMemory 内部（~5ns）
        → 实际写 4 字节（~1ns）
真正干活的只有最后 1ns，前面 20ns 都是调用开销。 EPL 的函数调用机制你改不了。

三条路，收益递减
路线1：批量操作（已实现，最实用）
热循环里不要逐个读，拷贝到原生数组再遍历。前面已经做过了，78ms → 47ms。

路线2：写个 C DLL 做热循环
把整个循环搬进 C 里，EPL 只调一次：

c
复制
// fastlib.c → 编译成 fastlib.dll
__declspec(dllexport) int __cdecl SumArray(int* base, int count) {
    int sum = 0;
    for (int i = 0; i < count; i++) {
        sum += base[i];    // 编译成单条 MOV 指令
    }
    return sum;
}
EPL 调用：

epl
复制
.DLL命令 求和, 整数型, "fastlib.dll", "SumArray"
    .参数 基址, 整数型, , , 内存数组基址
    .参数 数量, 整数型, , , 元素个数

结果 ＝ 求和 (ccc.取基址 (), ccc.取数组成员数目 ())
一次调用完成 100 万次累加，时间接近 0。 这才是真正消灭调用开销的办法。

路线3：EPL 置入代码（内联汇编）
EPL 支持 置入代码 写机器码，但极度脆弱，换个编译器版本可能就崩：

epl
复制
.子程序 写整数_极速, , 公开, 内联汇编版，不稳定慎用
.参数 参数_地址, 整数型       ' 直接传地址，不是索引
.参数 参数_值, 整数型

' mov eax, [ebp+12]  ; 取值
' mov [ebp+8], eax   ; 写入地址
' 不推荐，维护成本太高
置入代码 ({ 139, 69, 12, 139, 85, 8, 137, 2 })
不推荐用在正式项目里，调试困难，一崩就整个程序挂。

建议
方法        速度        可靠性        推荐度
拷贝到原生数组        快        ? 稳定        ??? 首选
C DLL 做热循环        最快        ? 稳定        ??? 高频场景必用
置入代码        理论最快        ? 脆弱        ? 不推荐
你的量化筛选如果真到了性能瓶颈，写个 C DLL 是正路。 几十行 C 代码就能把排序、累加、筛选全做了，EPL 只负责界面和流程控制。



龙虾对  读写瓶颈 这样说

---

作者: 1184798949    时间: 7 天前
感谢分享

---

作者: year1970    时间: 6 天前
感谢分享

---

作者: 一指温柔    时间: 6 天前
感谢分享

---

作者: qqmqqg    时间: 6 天前
66666666666666

---

作者: bianyuan456    时间: 6 天前
已经顶贴，感谢您对论坛的支持！

---

作者: APPLEUFO    时间: 5 天前

  

子程序名	返回值类型	公开	备 注
原生数组写到文件	逻辑型		将整数型原生数组整块写入二进制文件
参数名	类 型	参考	可空	数组	备 注
参数_数组	整数型
参数_文件名	文本型

变量名	类 型	静态	数组	备 注
局变_jz	整数型
局变_文件句柄	整数型
局变_实际写入	整数型
局变_保存	整数型

' lstrcpynA会破坏arr[1]，先保存再恢复
局变_保存 ＝ 参数_数组 [1]
局变_jz ＝ 取原生数组地址 (参数_数组 [1], 参数_数组 [1], 4)
参数_数组 [1] ＝ 局变_保存
局变_文件句柄 ＝ 创建文件 (参数_文件名, 1073741824, 0, 0, 2, 128, 0)
如果真 (局变_文件句柄 ＝ -1 或 局变_文件句柄 ＝ 0)
返回 (假)

写文件 (局变_文件句柄, 局变_jz, 取数组成员数 (参数_数组) × 4, 局变_实际写入, 0)
关闭句柄 (局变_文件句柄)
返回 (真)
' 严重警告：取原生数组地址 会破坏数据！
' 你之前文件读写测试用 1-100 没问题，是因为碰巧值小。真实数据用这个函数，arr[1] 会被破坏！

.版本 2<br /> <br /> .子程序 原生数组写到文件, 逻辑型, 公开, 将整数型原生数组整块写入二进制文件<br /> .参数 参数_数组, 整数型, 参考 数组<br /> .参数 参数_文件名, 文本型<br /> .局部变量 局变_jz, 整数型<br /> .局部变量 局变_文件句柄, 整数型<br /> .局部变量 局变_实际写入, 整数型<br /> .局部变量 局变_保存, 整数型<br /> <br /> ' lstrcpynA会破坏arr[1]，先保存再恢复<br /> 局变_保存 ＝ 参数_数组 [1]<br /> 局变_jz ＝ 取原生数组地址 (参数_数组 [1], 参数_数组 [1], 4)<br /> 参数_数组 [1] ＝ 局变_保存<br /> <br /> 局变_文件句柄 ＝ 创建文件 (参数_文件名, 1073741824, 0, 0, 2, 128, 0)<br /> .如果真 (局变_文件句柄 ＝ -1 或 局变_文件句柄 ＝ 0)<br />     返回 (假)<br /> .如果真结束<br /> <br /> 写文件 (局变_文件句柄, 局变_jz, 取数组成员数 (参数_数组) × 4, 局变_实际写入, 0)<br /> 关闭句柄 (局变_文件句柄)<br /> 返回 (真)<br /> ' 严重警告：取原生数组地址 会破坏数据！<br /> ' 你之前文件读写测试用 1-100 没问题，是因为碰巧值小。真实数据用这个函数，arr[1] 会被破坏！

更正

---

作者: renhe2018    时间: 5 天前
强大，支持。感谢

---

作者: wh1234567    时间: 5 天前
感谢分享

---

作者: fastdao    时间: 5 天前
支持开源~！感谢分享

---

作者: 胖子葛格    时间: 5 天前
感谢大神分享~！

---

作者: lgj5000    时间: 4 天前
感谢分享

---

作者: please    时间: 4 天前
感谢分享，支持开源！！！

---

作者: please    时间: 3 天前
感谢分享，支持开源！！！

---

欢迎光临 精易论坛 (https://bbs.ijingyi.com/)

Powered by Discuz! X3.4