张墨轩的技术宅

不忘初心,方得始终

[置顶] 我的微信公众号

功夫编译系统心得总结

1.yarn工具可以理解为node下npm工具的升级版
2.cross-env,cross-var是node下的一个包(工具),用于解决跨平台环境变量设置问题
3.pipenv是一个python程序 用于建立python虚拟环境(带包管理器),Pipfile包含依赖,Pipfile.lock能有效解决依赖版本问题(注意和anconda中conda create创建的python环境在概念上进行区分和对比)
4.conan(柯南)也是一个python程序,用于C++包管理(配置执行文件:conanfile.py)
5.electron-builder electron程序编译工具,关于electron的简单理解就是把JavaScript,HTML 和 CSS和一个本地浏览器内核(包含v8-js解析引擎)打包到一起,成为一个可执行文件,而其中js代码是用ts代码开发,然后将ts代码通过typescript编译(转换)成js代码,关于typescript请自行百度
6.webpack js打包工具

core部分:
因为我装的anconda是3.8版本的,所以首先利用conda create -n创建了一个py37的环境,然后切换到这个py37的环境下,然后开始进行下面的工作
首先运行yarm 更新所有的node依赖包,然后生成yarn.lock文件,yarn.lock能有效解决依赖版本问题
然后利用pipenv安装python虚拟环境,并在这个环境下把所有需要的包装好
然后利用conan安装所有需要的C++包
然后调用python/build.py进行编译(内部通过cmake-js进行编译) 【2.2版本后改成利用conan通过conanfile.py文件操作
然后利用setup.py打包成wheel包【2.2版本后改成利用conan通过conanfile.py文件操作
然后通过python/build.py freeze打包成可执行文件(内部调用pyinstaller)【2.2版本后改成利用conan通过conanfile.py文件操作

app部分:
首先运行electron-builder install-app-deps安装相应依赖
然后调用.electron-kungfu/build.js和electron-builder进行编译和打包

功夫采用c/c++, python, js/ts/electron, js/node 混合开发,其中js/node和C++之间采用node的N-API机制交互,关于N-API请自行百度node-addon-api/node-gyp等。python与C++之间采用pybind11库进行混合编程, pybind11可实现C++11标准和Python之间的无缝操作,具体请自行百度

这里顺便说下cython机制, cython可以简单理解为开发了一种新的语言,这个语言语法类似python,然后编译的基本流程是首先通过Cython.Build.cythonize将cython代码编译(转换)为C++代码,然后通过setup函数调用本地安装的C++编译器将C++代码编译成二进制模块,然后就可以被python给调用了。开源项目AlgoPlus就采用了cython机制.

当我们用pip安装包(轮子文件)的时候,因为有些包内部采用了比如C++开发,并不一定是纯python,那么如果官方没有提供编译好的版本的话,那么就需要下载相应源码到本机进行实时编译,虽然这个过程是自动进行的,但是因为本地编译环境的原因,常常出错,所以我们一般 最好别用太新的版本的python,比如python3.7比较稳定发布时间也很长了,所以与之对应的包基本都有编译好的版本,出问题的概率相对较小,但如果用较新版本的python,比如3.8版本,甚至3.9版本,它们很多包仓库里面还没有编译好的版本,需要安装的时候本地编译,出错概率大大加大,所以开发建议用py37的版本。

多因子指数增强模型

项目概览:

本项目通过构建多因子模型实现了沪深300指数增强策略,流程包括原始数据获取、因子生成、因子预处理、单因子检验、收益预测模型及风险模型等,具体流程如图:

指数增强模型结构.png


第六弹(P2P分布式游戏下载软件)

技术虽然每天日新月异,但是对技术的热爱却从未改变,总结过去,展望未来。这次发的是当年开发的一套基于Boost C++和libtorrent的专门用于更新游戏的bt下载软件。软件界面如下:

第五弹(磁盘保护+穿透更新)

技术虽然每天日新月异,但是对技术的热爱却从未改变,总结过去,展望未来。对于一些公共场所的带硬盘的Windows PC,比如酒店或者网吧,既需要保护硬盘系统不被破坏,又需要对上面的一些软件进行更新,比如游戏。本模块是我以前开发的三层游戏更新平台客户端的核心模块,能保护磁盘的同时又可以更新指定的游戏或者软件。

演示截图:

强大的异步架构量化平台(alphahunter)

alphahunter是一个基于Python原生异步库(asyncio)实现的异步事件驱动开源量化策略研究/策略回测/量化交易/高频做市平台,本系统实现数据采集,存储,推送,研究,仿真模拟,线上模拟,实盘等全流程量化研究交易支持,各步骤规则,配置,接口高度统一,异步框架提高系统综合性能。

中低频基础框架如下图所示:

第四弹(Windows安全防火墙)

技术虽然每天日新月异,但是对技术的热爱却从未改变,总结过去,展望未来。这次发的是2008年开发的一个Windows安全组件,主要包括两个部分,一是内核驱动防火墙,通过白名单机制,阻止未授权的驱动的加载,并且通过HOOK SSDT的方式保护自身进程的安全,二是ARP防火墙,它通过NDIS中间层驱动捕获以太数据报文,过滤掉其中的恶意ARP报文。自夸一下,当年项目代码很工整,并且自定义了C++ stub,用于实现ddk下编译C++代码 :)

截图如下:

第三弹(PXE全自动网刻工具)

这是以前开发的一个网维小工具, 工具虽小作用却很大,它结合PXE+Ghost能够批量对局域网内pc进行操作,比如安装操作系统。

当需要统一维护大批电脑时(如批量安装操作系统),尤其适用于比如学校机房和网吧等,PXE技术的网络克隆方案是首选。

PXE(Preboot Execution Environment)是RPL(Remote Program Load)的升级品,它是基于TCP/IP、DHCP、TFTP 等Internet 协议之上的扩展网络协议。它在工作站启动之前便预置好其工作环境。两者不同之处在于RPL 是静态路由,而PXE 是动态路由。RPL 是根据网卡的MAC 再加上其它信息组成帧向服务器发出请求,服务器里已经有了这个MAC 数据,若匹配成功则进行远程启动。PXE则是根据服务器端收到的工作站地址,由DHCP 服务给这个MAC 地址指定一个IP 地址,即PXE 为工作站动态分配地址。工作站得到IP 地址后,从服务器上下载启动映像文件,在工作站内存中虚拟一个软驱,并将启动映象文件还原为实模式连网文件、系统内核文件和环境设置文件。像无盘工作站的各种工作环境,包括服务器名、共享目录名及网卡实模式驱动程序都是在此环境文件中设置的。

浅谈去中心化交易所生态

DeFi, 去中心化金融, 包含很多内容, 其中非常重要的一个领域就是去中心化交易所了.

简单把交易生态分成三个角色: <交易所>, <做市商>, <交易者>

<交易所>为交易提供基础设施, <做市商>作为流动性提供者, 为交易所提供流动性, <交易者>包括套利交易者, 对冲交易者, 散户, 机构等等.  <交易所>和<做市商>是利益共同体, 一起分享交易手续费等收入, 同时<交易所>还可以发行治理代币, <做市商>通过流动性挖矿方式获取治理代币奖励, 而<交易者>需要支付交易手续费, 如果把交易看成一门生意的话, 其实就是<交易所>和<做市商>一起赚<交易者>的钱.

从交易机制来说传统的中心化交易所和初代的去中心化交易所一般采用的都是订单簿+撮合机制, 本质是人和人交易, 而目前新一代的去中心化交易所大都采用AMM(自动化做市商)机制, 典型代表有Uniswap, Balancer, Curve, Bancor等. 在AMM自动化做市商机制下我们其实是和由智能合约实现的流动性代币对池交易, 在传统的订单簿+撮合机制下要成为做市商还是有一定门槛的, 一般需要有程序员,量化工程师等开发自动化做市程序,如果想更进一步可能还需要构建更巧妙的数学模型,比如将深度强化学习应用于高频做市程序, 然后还需要一定量的资金, 因为交易所一般对做市挂单额度都有要求. 而在智能合约+AMM机制下,做市就变得非常容易, 仅仅只需要向流动性池子按一定比率充值相应的代币就可以完成做市操作.

那么如何参入到游戏中来, 我们还是从<交易所>,<做市商>,<交易者>三个方面来看, 开设交易所, 这个难度显然太大. 成为做市商, 这是一个选项, 前面说了, 对于传统的订单簿+撮合机制, 还需要构建自动化做市程序,  而对于智能合约+AMM机制只需要向流动性池子充值就行, 不过采用AMM机制的去中心化交易所非常多, 各池子收益各不相同, 是否可以针对最优的AMM池子进行投资组合优化呢, 当然是可以的, Yearn Finance就是代表, 本质上不管是流动性挖矿还是staking或者借贷亦或是DEX的AMM, 其都是将代币存入存储池, 然后赚取收益, 完全可以进行投资组合优化. 最后从<交易者>角度看, 可以进行套利交易, 比如搬砖, 比如统计套利, 比如构建数学模型对价格进行预测, 买涨买跌, CTA交易等, 这些其实就属于最经典的量化交易了. 另外还可以做聚合交易, 在中心化交易所领域, AiCoin就是典型代表, 那么在去中心化交易所里面1inch.exchange就是典型代表. 另外就是还有些工具类的可以参入, 因为类似Uniswap这样的去中心化交易所一般只有简单的交易功能, 并没有类似中心化交易所那样全面的比如K线, 成交列表等信息展示功能, 亦或是限价单等功能, 所以像dextools, Unitrade等工具类应用就帮其补全这一块的功能.


asyncio要点

asyncio是一个异步并发库, 注意是并发, 不是并行. 利用 async/await 组合

`可等待对象`有三种主要类型: coroutine,Task,Future, `可等待对象`实现了__await__方法 (Task派生至Future)

coroutine 协程,实现异步模型的基本单元

Future 主要用于coroutine之间`执行权`的切换, 内部本质用的是yield, await future -> __await__ -> yeild,
这个类很大程度上模仿concurrent.futures.Future

Task将(coroutine,Future)整合到一起, 成为一个task, 然后交给loop去执行. add_done_callback可以
为Task添加完成通知回调

loop是一个任务执行队列循环, 底层用类似select机制, linux上可以用epoll, windows上可以
用wsaeventselect或者`完成端口`来实现`单线程多任务`异步非阻塞IO操作

asyncio.run -> loop.run_until_complete -> loop.run_forever()

下面是并发示例代码:

#==========================================================================
#==========================================================================

async def test1():
    """
    asyncio.sleep内部创建了一个future对象和一个定时运行的回调函数,
    然后await等待这个future对象,这样会交出`执行权`,
    然后等到指定时间回调函数被调用,在回调函数里面
    调用future.set_result函数,这样asyncio.sleep将重新获取`执行权`,并返回.
    代码如下:
    async def sleep(delay, result=None, *, loop=None):
        if delay <= 0:
            await __sleep0()
            return result
        
        if loop is None:
            loop = events.get_event_loop()
        future = loop.create_future()  #创建一个future对象
        h = loop.call_later(delay,
                            futures._set_result_unless_cancelled, #这个回调函数里面会调用future.set_result
                            future, result)
        try:
            return await future #进入等待状态,直到回调函数futures._set_result_unless_cancelled被调用
        finally:
            h.cancel()
    """
    obj = asyncio.sleep(3) #生成`协程对象`,并不是真正执行`协程函数`
    await obj              #真正执行协程函数,并且等待完成
    print("test1 done")

async def test2():
    obj = asyncio.sleep(3)
    await obj
    print("test2 done")

async def main():
    """
    方式一:
    这里是串行执行, 3+3 一共要等待6秒才完成
    """
    obj1 = test1()   #生成`协程对象`,并不是真正执行`协程函数`
    obj2 = test2()   #生成`协程对象`,并不是真正执行`协程函数`
    #obj1.send(None) #协程对象可以这样运行
    await obj1 #真正执行协程函数,并且等待完成
    await obj2 #真正执行协程函数,并且等待完成
    
    """
    方式二:
    这里是并发执行, 一共只需要大约3秒就完成
    """
    obj1 = test1()  #生成`协程对象`,并不是真正执行`协程函数`
    obj2 = test2()  #生成`协程对象`,并不是真正执行`协程函数`
    task1 = asyncio.create_task(obj1)#创建任务对象,并且加入到执行列表里面,Task派生至Future,所以这里可以看成是future对象
    task2 = asyncio.create_task(obj2)#创建任务对象,并且加入到执行列表里面,Task派生至Future,所以这里可以看成是future对象
    """
    因为上面asyncio.create_task把两个协程都排入了执行队列,
    具有并发执行的性质,所以下面虽然从代码看上去是一个接一个在等待,
    但两个任务实际是并发完成的,所以一共只需要大约3秒就完成了
    """
    await task1#其实就是等待一个future对象,task内部执行完协程后,会在这个future对象上调用future.set_result,这样await就会返回,后面的代码继续运行
    await task2#其实就是等待一个future对象,task内部执行完协程后,会在这个future对象上调用future.set_result,这样await就会返回,后面的代码继续运行
    
    """
    方式三:
    这里也是并发执行,一共只需要大约3秒就完成,而且从代码上看更容易理解是并发执行,不会产生歧义.
    
    asyncio.wait内部主要流程是会利用add_done_callback为传入的每个任务添加同一个`任务完成回调通知`函数,
    然后await等待一个future对象,等任务完成后,`任务完成回调通知`函数被调用,这个函数里面有个计数器,
    当计数为0,代表所有任务都完成,然后就会调用future.set_result,这样前面说的await调用就会返回,然后asyncio.wait就会返回
   
    代码如下:
    async def _wait(fs, timeout, return_when, loop):
    
        assert fs, 'Set of Futures is empty.'
        waiter = loop.create_future() #创建一个future对象,后面会用到
        timeout_handle = None
        if timeout is not None:
            timeout_handle = loop.call_later(timeout, _release_waiter, waiter)
        counter = len(fs)
        #下面就是`任务完成回调通知`函数
        def _on_completion(f):
            nonlocal counter #计数器
            counter -= 1 #每完成一个任务计数器减一
            if (counter <= 0 or #计数器为0意味着任务都执行完毕了
                return_when == FIRST_COMPLETED or
                return_when == FIRST_EXCEPTION and (not f.cancelled() and
                                                    f.exception() is not None)):
                if timeout_handle is not None:
                    timeout_handle.cancel()
                if not waiter.done():
                    waiter.set_result(None) #任务都执行完毕,调用set_result,这样后面await waiter代码就会返回,流程得以继续
    
        for f in fs:
            f.add_done_callback(_on_completion) #为每个任务添加`任务完成回调通知`函数
    
        try:
            await waiter #等待之前创建的future对象
        finally:
            if timeout_handle is not None:
                timeout_handle.cancel()
    
        done, pending = set(), set()
        for f in fs:
            f.remove_done_callback(_on_completion)
            if f.done():
                done.add(f)
            else:
                pending.add(f)
        return done, pending
    """
    obj1 = test1()  #生成`协程对象`,并不是真正执行`协程函数`
    obj2 = test2()  #生成`协程对象`,并不是真正执行`协程函数`
    task1 = asyncio.create_task(obj1)#创建任务对象,并且加入到执行列表里面,Task派生至Future,所以这里可以看成是future对象
    task2 = asyncio.create_task(obj2)#创建任务对象,并且加入到执行列表里面,Task派生至Future,所以这里可以看成是future对象
    l = [task1, task2]
    obj = asyncio.wait(l)       #生成`协程对象`,并不是真正执行`协程函数`
    done, pending = await obj   #真正执行协程函数,并且等待完成

asyncio.run(main())

#还可以如下方式调用
#loop = asyncio.get_event_loop()
#loop.run_until_complete(main())

#还可以如下方式调用
#loop = asyncio.get_event_loop()
#t = loop.create_task(main())
#loop.run_until_complete(t)

#还可以如下方式调用,这种方式程序永远不会退出
#loop = asyncio.get_event_loop()
#loop.create_task(main())
#loop.run_forever()

exit()

#==========================================================================
#==========================================================================

若干参考资料:

asyncio源码: Anaconda3/Lib/asyncio/*.py 例如futures.py,tasks.py,coroutines.py,events.py,runners.py等

https://docs.python.org/zh-cn/3/library/asyncio-task.html  《协程与任务》
https://zhuanlan.zhihu.com/p/27258289     《Python Async/Await入门指南》
https://www.cnblogs.com/pigerhan/p/3474217.html 《两种IO模式:Proactor与Reactor模式》
https://www.cnblogs.com/harelion/p/8496360.html 《Python 3.5中async/await的工作机制》

一个不错的数字货币量化交易框架

量化交易系统整体架构:

 

«123456»

Powered By Z-Blog 2.2 Prism Build 140101

Copyright phonegap.me Rights Reserved.