luanet性能测试

测试环境 intel-i5 双核 2.53HZ 服务器客户端均在本机运行

测试内容:echo回射,每个包的字节数在20字节内

luanet

连接数    每秒回射数            
1         19,000/s
10        12,5000/s
100       12,0000/s
1000      80,000/s 

node.js

连接数    每秒回射数            
1         27,000/s
10        30,000/s
100       30,000/s
1000      27,000/s

luvit

连接数    每秒回射数            
1         16,500/s
10        74,000/s
100       75,000/s
1000      51,000/s

从测试结果上看只有在1个连接的情况下luanet不如node.js,当连接数上去之后 luanet每秒的回射数基本都在

node.js的3倍左右.在所有的连接数下都比luvit 高30%以上.

node.js:echo.js

 var net = require('net');
    var server = net.createServer(function(c) { // 'connection' 监听器
      console.log('一个新连接');
      c.on('end', function() {
        console.log('连接断开');
      });
      c.on('data',function(data){
        c.write(data);
      });
      c.on('close',function(){
          console.log('连接断开');
      });   
      c.on('error',function(e){
      });  
    });
    server.listen(8010, function() { // 'listening' 监听器
      console.log('服务器监听8010');
    });

 

luvit:echo.lua

local net = require('net')

net.createServer(function (client)
  -- Echo everything the client says back to itself
  client:pipe(client)
end):listen(8010)

print("TCP echo server listening on port 8010")

 

luanet:echoserver.lua

local cjson = require "cjson"

function on_data(s,data,err)
    if not data then
        print("a client disconnected")
        C.close(s)
    else
        local tb = cjson.decode(data)
        C.send(s,cjson.encode(tb),nil)
    end
end

function on_newclient(s)
    print("on_newclient")
    if not C.bind(s,{recvfinish = on_data})then
        print("bind error")
        C.close(s)
    end
end

C.listen(IPPROTO_TCP,SOCK_STREAM,net.netaddr_ipv4("127.0.0.1",8010),
         {onaccept=on_newclient})

统一的测试客户端:echoclient.lua

local net = require "lua/netaddr"
local cjson = require "cjson"
local Sche = require "lua/scheduler"
local count = 0

function on_data(s,data,err)
    if not data then
        print("a client disconnected")
        C.close(s)
    else
        count = count + 1
        local tb = cjson.decode(data)
        C.send(s,cjson.encode(tb),nil)
    end
end

function on_connected(s,remote_addr,err)
    print("on_connected")
    if s then
        if not C.bind(s,{recvfinish = on_data}) then
            print("bind error")
            C.close(s)
        else
            print("bind success")
            C.send(s,cjson.encode({"hahaha"}),nil)
        end
    end 
end
print("echoclient")
for i=1,1 do
    C.connect(IPPROTO_TCP,SOCK_STREAM,net.netaddr_ipv4("127.0.0.1",8010),
              nil,{onconnected = on_connected},3000)
end

local tick = C.GetSysTick()
local now = C.GetSysTick()
while true do 
    now = C.GetSysTick()
    if now - tick >= 1000 then
        print(count*1000/(now-tick) .. " " .. now-tick)
        tick = now
        count = 0
    end
    Sche.Sleep(50)
end

luanet rpc测试:客户端调用服务端的Plus函数,函数只是把客户端提供的两个参数相加并返回

平均每秒rpc调用次数在6,8000左右.而用C+协程实现的版本在70,0000左右.我试着用luajit来运行 同样的测试,非常意外的是性能差了一大截,

只有可怜的2,000次,具体原因还在调查中.

测试代码:server.lua,client.lua

<think>嗯,用户想测试一下Gin和Robyn的性能对比。首先,我需要确认这两个框架的背景。Gin是用Go语言写的,而Robyn是Rust的,对吧?对,Gin作为Go的框架,以高性能著称,特别是在并发处理方面,因为Go的goroutine很强大。Robyn呢,作为新兴的Rust框架,Rust本身以安全和高性能闻名,但它的异步模型可能和Go有所不同。 用户可能想了解在不同负载下两者的表现,比如并发请求的处理能力、延迟、吞吐量等。可能需要设计一个基准测试,使用相同的API端点,比如返回“Hello World”,然后用工具如wrk或hey进行压力测试。需要注意测试环境的一致性,比如同一台机器,相同的网络条件,排除其他干扰因素。 还要考虑框架的配置,比如Gin可能默认就是优化的,而Robyn可能需要调整一些参数。比如,Gin可能使用默认的路由器,而Robyn作为Rust框架,可能依赖hyper或其他库,需要确认服务器配置是否最大化性能。 测试结果可能显示,Gin在处理高并发时因为Go的调度器表现更好,而Robyn在单线程性能上可能更优,但由于Rust的异步模型,可能需要更多的线程来发挥多核优势。不过实际结果可能因测试用例而异,比如简单路由和复杂业务逻辑可能有不同表现。 另外,用户可能没有考虑到测试的细节,比如预热次数、测试持续时间、并发连接数等。这些都会影响结果。需要提醒用户多次测试取平均值,避免偶然性。同时,内存占用和资源消耗也是比较的一部分,虽然用户没提,但可能也是重要的考量因素。 最后,用户可能需要结论,但应该建议他们根据具体需求选择框架。比如,如果团队熟悉Go,Gin是更优选择;若追求Rust的安全性和性能,Robyn可能更适合。同时,框架的生态和社区支持也是考虑因素,Gin更成熟,文档更多,而Robyn可能还在发展中。测试</think> Gin(Go 语言框架)和 Robyn(Rust 语言框架)的性能对比需要设计一个基准测试实验,通常关注**吞吐量(Requests/sec)**、**延迟(Latency)**和**资源占用**等指标。以下是一个简化的对比思路和示例: --- ### 1. **框架简介** - **Gin**(Go):基于 Go 的高性能 HTTP 框架,利用 Go 的并发模型(Goroutine)处理高并发请求。 - **Robyn**(Rust):基于 Rust 的异步 Web 框架,依赖 `tokio` 运行时,强调内存安全和零成本抽象。 --- ### 2. **测试设计** #### 环境一致性 - 同一台物理机/虚拟机(避免云环境波动)。 - 禁用无关后台进程。 - 使用 `Docker` 容器化部署(可选,但需注意网络模式)。 #### 测试工具 - **wrk**:轻量级 HTTP 压测工具,支持多线程和 Lua 脚本。 - **hey**:Go 编写的压测工具,适合快速测试。 - **Vegeta**:分布式压测工具,适合复杂场景。 #### 测试接口 设计一个简单 GET 接口,返回 `Hello World`,避免业务逻辑干扰: ```go // Gin 示例代码 r := gin.Default() r.GET("/", func(c *gin.Context) { c.String(200, "Hello World") }) r.Run(":3000") ``` ```rust // Robyn 示例代码 use robyn::*; fn hello(_: Request) -> Response { Response::text("Hello World") } #[tokio::main] async fn main() { let mut app = Robyn::new(); app.get("/", hello); app.start("127.0.0.1", 3000).await; } ``` --- ### 3. **基准测试示例** #### 使用 `wrk` 进行压测(示例命令): ```bash # 测试 Gin(Go) wrk -t12 -c400 -d30s http://localhost:3000/ # 测试 Robyn(Rust) wrk -t12 -c400 -d30s http://localhost:3000/ ``` #### 预期结果(仅供参考): | 框架 | 吞吐量(Requests/sec) | 平均延迟(ms) | 资源占用(CPU/Memory) | |--------|------------------------|----------------|------------------------| | Gin | ~50,000 - 100,000 | 1 - 5 | 中低(Go GC 影响) | | Robyn | ~80,000 - 150,000 | 0.5 - 3 | 极低(Rust 无 GC) | --- ### 4. **关键差异分析** 1. **语言特性**: - Go 的 Goroutine 轻量级并发模型适合高并发,但 GC 可能导致吞吐量波动。 - Rust 无 GC,内存控制更精细,但异步编程复杂度较高。 2. **框架设计**: - Gin 基于 Go 标准库 `net/http`,成熟但优化空间有限。 - Robyn 依赖 `tokio` 异步运行时,可通过线程池和事件循环优化性能。 3. **实际场景**: - 简单路由:Rust 可能占优(更底层优化)。 - 复杂业务逻辑:Go 的开发效率优势更明显。 --- ### 5. **注意事项** - **预热**:运行压测前先进行预热请求,避免冷启动误差。 - **参数调优**:调整框架线程池、缓冲区大小等参数(如 Robyn 的 `tokio` 线程数)。 - **结果验证**:多次测试取平均值,避免偶发波动。 --- ### 6. **结论建议** - 如果追求极致性能且团队熟悉 Rust,**Robyn** 是更好选择。 - 如果需要快速开发和高并发支持,**Gin** 的生态和开发效率更优。 建议根据实际业务场景(如 I/O 密集型 vs CPU 密集型)进行针对性测试。
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值