Reactor百万连接的并发

实现百万并发连接的Reactor 和普通函数调用的不同之处在于:应用程序不是主动的调用某个 API 完成处理,而是恰恰 相反,Reactor 逆置了事件处理流程,应用程序需要提供相应的接口并注册到 Reactor 上, 如果相应的时间发生,Reactor 将主动调用应用程序注册的接口,这些接口又称为“回调函 数”。可是缺点也是明显的,现在的硬件发展,已经不再遵循摩尔定 律,CPU 的频率受制于材料的限制不再有大的提升,而改为是从核数的增加上提升能力, 当程序需要使用多核资源时,Reactor 模型就会悲剧。这是listenfd的回调函数。 阅读详情

epoll水平触发/边沿触发

LT,recvbuff中有数据就一直触发;

ET,recvbuff中收到数据,只触发一次。如果recvbuff中数据没有读完,不会再次触发,当recvbuff中收到新的数据时,再次触发。也就是收到一个包,只触发一次。比如客户端发送32byte的包,服务器只recv了10byte的数据,那么epoll不会再次触发,等到下一次客户端再发送32byte的数据,epoll会再一次触发。对于ET,对于recv,最好是一个循环的读,直到读完,返回-1。

所以LT适合用于大包,数据没读完会一直触发;ET适合小包,只触发一次,需要应用程序循环把数据读完。

ET模式下,sendbuff从不可发送到可发送,只触发一次。

send的情况,如果sendbuff一直为空,如果用ET,epoll会一直触发吗?

测试过,只会触发一次。

哪些场景使用水平触发?

  1. 小数据,使用边沿触发

  2. 数据块,数据量比较大使用水平触发。防止一次性接收不完。

listenfd用水平触发,如果多个client同时连接进来,listenfd里面积攒多个连接的话,accept一次只处理一个连接,防止漏掉连接,选择水平触发。

水平触发和边沿触发分界点,recv的BUFFER_LENGTH如果一次能接收完recv buffer中的数据,就是小数据,一次接收不完就是大数据

修改代码支持百万连接

reactor怎么存储100万个event

使用reactor实现百万并发连接的服务器,需要考虑event怎么保存,怎样分配内存, 存储百万级别的event。

数据结构设计

利用fd是递增的特性,可以设计成下面的结构。这样做可扩展性非常好,reactor存储的event数量不受限制。

typedef struct _eventblock {

    struct _eventblock *next;
    nevent *events; // 每一个block 1024个event

} eventblock;


typedef struct _nreactor {

    int epfd;
    int blkcnt;
    eventblock *evblk;

} nreactor;

​C++后台开发系统学习地址:C/C++Linux服务器开发高级架构师/C++后台开发架构师​

以下学习资料,C++后台开发面试题,教学视频,C++后台开发学习路线图,免费分享有需要的可以自行添加:学习资料群720209036 自取

代码实现

通过fd,可以计算得出相应的eventblock位置,以及event在该eventblock中的相应位置。之前代码中所有使用reactor->events的都需要做相应的修改。

nevent *nreactor_idx(nreactor *reactor, int sockfd) {

    int blkidx = sockfd / MAX_EPOLL_EVENTS;

    while (blkidx >= reactor->blkcnt) {
        nreactor_alloc(reactor);
    }
    
    int i = 0;
    eventblock *blk = reactor->evblk;
    while (i++ < blkidx && blk != NULL) {
        blk = blk->next;
    }
    
    return &blk->events[sockfd % MAX_EPOLL_EVENTS];

}

reactor初始化时,也需要相应的申请eventblock内存,以及events

int nreactor_alloc(nreactor *reactor) {

    if (reactor == NULL) return -1;
    if (reactor->evblk == NULL) return -1;

    eventblock *blk = reactor->evblk;

    while (blk->next != NULL) {

        blk = blk->next;
    }

    nevent *evs = (nevent *)malloc(MAX_EPOLL_EVENTS * sizeof(nevent));
    if (evs == NULL) {
        perror("nreactor_alloc malloc events failed");
        return -2;
    }
    memset(evs, 0, MAX_EPOLL_EVENTS * sizeof(nevent));

    eventblock *block = (eventblock *)malloc(sizeof(eventblock));

    if (block == NULL) {
        perror("nreactor_alloc malloc block failed");
        return -2;
    }
    memset(block, 0, sizeof(eventblock));

    block->events = evs;
    block->next = NULL;

    blk->next = block;
    reactor->blkcnt++;

    return 0;
}

完整代码

#include <sys/types.h>
#include <sys/socket.h>
#include <sys/epoll.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <arpa/inet.h>
#include <string.h>



#define BUFFER_LENGTH       1024
#define MAX_EPOLL_EVENTS    1024
#define SERVER_PORT         9105
#define PORT_COUNT          100

typedef int (*NCALLBACK)(int fd, void *arg);

typedef struct _nevent {

    int fd;
    int events;
    void *arg;
    NCALLBACK callback;

    int status; // whether fd is in epoll now.
    char buffer[BUFFER_LENGTH];
    int length;

} nevent;

typedef struct _eventblock {

    struct _eventblock *next;
    nevent *events; // 每一个block 1024个event

} eventblock;


typedef struct _nreactor {

    int epfd;
    int blkcnt;
    eventblock *evblk;

} nreactor;

int recv_cb(int client_fd, void *arg);
int send_cb(int client_fd, void *arg);
int accept_cb(int listen_fd, void *arg);
nevent *nreactor_idx(nreactor *reactor, int sockfd);

int init_sock(unsigned short port) {

    int listen_fd = socket(AF_INET, SOCK_STREAM, 0);
    fcntl(listen_fd, F_SETFL, O_NONBLOCK);

    struct sockaddr_in server_addr;
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    server_addr.sin_port = htons(port);

    bind(listen_fd, (struct sockaddr *)&server_addr, sizeof(server_addr));

    if (listen(listen_fd, 20) < 0) {
        perror("listen");
    }

    return listen_fd;
}

int nreactor_alloc(nreactor *reactor) {

    if (reactor == NULL) return -1;
    if (reactor->evblk == NULL) return -1;

    eventblock *blk = reactor->evblk;

    while (blk->next != NULL) {

        blk = blk->next;
    }

    nevent *evs = (nevent *)malloc(MAX_EPOLL_EVENTS * sizeof(nevent));
    if (evs == NULL) {
        perror("nreactor_alloc malloc events failed");
        return -2;
    }
    memset(evs, 0, MAX_EPOLL_EVENTS * sizeof(nevent));

    eventblock *block = (eventblock *)malloc(sizeof(eventblock));

    if (block == NULL) {
        perror("nreactor_alloc malloc block failed");
        return -2;
    }
    memset(block, 0, sizeof(eventblock));

    block->events = evs;
    block->next = NULL;

    blk->next = block;
    reactor->blkcnt++;

    return 0;
}

int nreactor_init(nreactor *reactor) {

    if (reactor == NULL)  return -1;
    memset(reactor, 0, sizeof(nreactor));

    reactor->epfd = epoll_create(1);
    if (reactor->epfd < 0) {
        perror("epoll_create");
        return -2;
    }

    nevent *evs = (nevent *)malloc(MAX_EPOLL_EVENTS * sizeof(nevent));
    if (evs == NULL) {
        perror("nreactor_init malloc events failed");
        return -2;
    }
    memset(evs, 0, MAX_EPOLL_EVENTS * sizeof(nevent));

    eventblock *block = (eventblock *)malloc(sizeof(eventblock));

    if (block == NULL) {
        perror("nreactor_init malloc block failed");
        return -2;
    }
    memset(block, 0, sizeof(eventblock));

    block->events = evs;
    block->next = NULL;

    reactor->evblk = block;
    reactor->blkcnt = 1;

    return 0;

}

int nreactor_destroy(nreactor *reactor) {

    close(reactor->epfd);
    
    eventblock *blk = reactor->evblk;
    eventblock *blk_next = NULL;

    while (blk != NULL) {

        blk_next = blk->next;

        free(blk->events);
        free(blk);
        blk = blk_next;
    }

    return 0;
}

void nreactor_event_set(nevent *ev, int fd, NCALLBACK callback, void *arg) {

    ev->fd = fd;
    ev->callback = callback;
    ev->arg = arg;
    ev->events = 0;

}

int nreactor_event_add(int epfd, nevent *ev, int events) {

    struct epoll_event ep_ev = {0, {0}};
    ep_ev.events = ev->events = events;
    ep_ev.data.ptr = ev;

    int op;
    if (ev->status == 1) {
        op = EPOLL_CTL_MOD;
    } else {
        ev->status = 1;
        op = EPOLL_CTL_ADD;
    }

    if (epoll_ctl(epfd, op, ev->fd, &ep_ev) < 0) {
        perror("epoll_ctl");
        return -1;
    }

    return 0;

}

int nreactor_event_del(int epfd, nevent *ev) {

    struct epoll_event ep_ev = {0, {0}};
    
    if (ev->status != 1) {
        return -1;
    }

    ev->status = 0;

    epoll_ctl(epfd, EPOLL_CTL_DEL, ev->fd, NULL);

    return 0;

}

int recv_cb(int client_fd, void *arg) {

    nreactor *reactor = (nreactor *)arg;
    if (reactor == NULL) return -1;

    nevent *ev = nreactor_idx(reactor, client_fd);

    int len = recv(client_fd, ev->buffer, BUFFER_LENGTH, 0);
    nreactor_event_del(reactor->epfd, ev);

    if (len > 0) {

        ev->length = len;
        ev->buffer[len] = '\0';

        printf("client_fd[%d]:%s\n", client_fd, ev->buffer);

        nreactor_event_set(ev, client_fd, send_cb, reactor);
        nreactor_event_add(reactor->epfd, ev, EPOLLOUT);

    } else if (len == 0) {

        close(client_fd);
        // printf("[client_fd=%d] pos[%ld], closed\n", client_fd, ev - reactor->events);

    } else {

        close(client_fd);
        perror("recv");

    }

    return len;

}

int send_cb(int client_fd, void *arg) {

    nreactor *reactor = (nreactor *)arg;
    if (reactor == NULL) return -1;

    nevent *ev = nreactor_idx(reactor, client_fd);

    int len = send(client_fd, ev->buffer, ev->length, 0);
    nreactor_event_del(reactor->epfd, ev);
    if (len > 0) {

        printf("send[client_fd=%d], [%d]%s\n", client_fd, len, ev->buffer);

        nreactor_event_set(ev, client_fd, recv_cb, reactor);
        nreactor_event_add(reactor->epfd, ev, EPOLLIN);

    } else {

        close(ev->fd);
        perror("send");
    }

    return len;

}

int accept_cb(int listen_fd, void *arg) {

    nreactor *reactor = (nreactor *)arg;
    if (reactor == NULL) return -1;

    struct sockaddr_in client_addr;
    socklen_t len = sizeof(client_addr);

    int client_fd = accept(listen_fd, (struct sockaddr *)&client_addr, &len);
    if (client_fd < 0) {
        perror("accept");
        return -1;
    }

    int flag = fcntl(client_fd, F_SETFL, O_NONBLOCK);
    if (flag < 0) {
        perror("fcntl");
        return -2;
    }

    nevent *ev = nreactor_idx(reactor, client_fd);
    nreactor_event_set(ev, client_fd, recv_cb, reactor);
    nreactor_event_add(reactor->epfd, ev, EPOLLIN);

    printf("new connect [%s:%d], client_fd[%d]\n", 
        inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port), client_fd);
}

nevent *nreactor_idx(nreactor *reactor, int sockfd) {

    int blkidx = sockfd / MAX_EPOLL_EVENTS;

    while (blkidx >= reactor->blkcnt) {
        nreactor_alloc(reactor);
    }
    
    int i = 0;
    eventblock *blk = reactor->evblk;
    while (i++ < blkidx && blk != NULL) {
        blk = blk->next;
    }
    
    return &blk->events[sockfd % MAX_EPOLL_EVENTS];

}


int nreactor_addlistener(nreactor *reactor, int listen_fd, NCALLBACK accept_cb) {

    if (reactor == NULL || reactor->evblk == NULL) {
        return -1;
    }

    nevent *event = nreactor_idx(reactor, listen_fd);

    nreactor_event_set(event, listen_fd, accept_cb, reactor);
    nreactor_event_add(reactor->epfd, event, EPOLLIN);

    return 0;

}

int nreactor_run(nreactor *reactor) {

    if (reactor == NULL) return -1;
    if (reactor->evblk == NULL) return -1;

    struct epoll_event events[MAX_EPOLL_EVENTS];

    while (1) {

        int nready = epoll_wait(reactor->epfd, events, MAX_EPOLL_EVENTS, 1000);
        if (nready < 0) {
            perror("epoll_wait");
            continue;
        }

        int i;
        for (i = 0; i < nready; i++) {

            nevent *ev = (nevent *)events[i].data.ptr;

            if ((events[i].events & EPOLLIN) && (ev->events & EPOLLIN)) {
                ev->callback(ev->fd, ev->arg); 
            }
            if ((events[i].events & EPOLLOUT) && (ev->events & EPOLLOUT)) {
                ev->callback(ev->fd, ev->arg);
            }

        }

    }

}


#if 1

int main(int argc, char *argv[]) {

    unsigned short port = SERVER_PORT;
    if (argc == 2) {
        port = atoi(argv[1]);
    }

    nreactor *reactor = (nreactor *)malloc(sizeof(nreactor));
    nreactor_init(reactor);

    int i = 0;
    int listen_fds[PORT_COUNT] = {0};
    for (i = 0; i < PORT_COUNT; i++) {
        listen_fds[i] = init_sock(port + i);
        nreactor_addlistener(reactor, listen_fds[i], accept_cb);
    }

    
    nreactor_run(reactor);

    nreactor_destroy(reactor);

    for (i = 0; i < PORT_COUNT; i++) {
        close(listen_fds[i]);
    }

    free(reactor);

    return 0;
}


#endif

如何测试

服务器端修改配置

修改ulimit

​

# /etc/security/limits.conf
* hard nofile 1048576
* soft nofile 1048576

修改file-max

​

# vim /etc/sysctl.conf
# cat /proc/sys/fs/file-max
fs.file-max = 1048576

修改nf_conntrack_max

​

# /etc/sysctl.conf
# cat /proc/sys/net/netfilter/nf_conntrack_max
# sysctl -p
net.netfilter.nf_conntrack_max = 1048576

修改tcp_wmem, tcp_rmem

如果服务器的内存不够,为了测试,修改一下wmem和rmem,即将sendbuff、recvbuff改小,单位是byte。测试后,记得还原回去。

# vim /etc/sysctl.conf
# cat /proc/sys/net/ipv4/tcp_wmem
# sysctl -p

net.ipv4.tcp_rmem = 512 512 1024
net.ipv4.tcp_wmem = 512 512 1024

修改tcp_mem

tcp_mem是tcp协议栈的大小,单位是页,一页4k

​

# vi /etc/sysctl.conf
# sysctl -p
# cat /proc/sys/net/ipv4/tcp_mem

net.ipv4.tcp_mem = 757596 1010128 1515192

测试结果

最后只到61W多,四台机器,每个都是4核16G。

跑到50W左右的时候,连接处理的速度就比较慢了。

Server:

​

Client:

reactor如何支持多核

1.大量客户端连到服务器,要使连接的处理速度更快,可以把100个listenfd放在不同的线程。

可以通过一个线程一个reactor来实现。每个线程一个reactor,对应一个listenfd。

2.如果服务器只监听一个端口,怎么做?开进程

一个master进程,多个worker进程。通过加accept锁来决定由那个worker进行处理该连接。

3.可以把listenfd和clientfd放到不同的线程里面。

可以看下libevent/redis的reactor, 将listenfd和clientfd,使用不同的线程进行处理。

开一个worker线程,main线程处理accept,worker线程处理clientfd。main线程可以使用poll。

单线程,libevent/redis

多线程,memcached,每个线程一个epoll_wait

多进程,nginx

我们实现的reactor是个单线程的,100个listenfd都在一个线程里,如果想要性能更高,可以把100个listenfd放在不同的线程里面。3个思考问题:

1)reactor怎么使用多线程,比如listen 10个端口,怎么做到每个端口(listenfd)一个线程?

每个线程一个reactor,对应一个listenfd

2)服务器一般只监听一个port,比如8888,怎么解决?可以通过开进程解决。

怎么做到多个进程listen一个端口?

nginx的解决方案

3)如何做到listenfd和clientfd在不同的线程?

一个main线程,一个worker线程。main线程负责listen,处理连接;worker线程负责处理clientfd。

listen的backlog参数,linux系统上指的是accpt队列长度;unix系统上是sync + accept队列长度。

参考资料

​推荐一个零声教育C/C++后台开发的免费公开课程,个人觉得老师讲得不错,分享给大家:C/C++后台开发高级架构师,内容包括Linux,Nginx,ZeroMQ,MySQL,Redis,fastdfs,MongoDB,ZK,流媒体,CDN,P2P,K8S,Docker,TCP/IP,协程,DPDK等技术内容,立即学习

原文链接:reactor百万连接的并发_congchp的博客-优快云博客

面试官:请设计一个能支撑百万连接的系统架构! 这篇文章,给大家聊一聊:如果你设计一个系统需要支撑百万用户连接,应该如何来设计其高并发请求处理架构? 阅读详情

相关推荐

张量分解浅谈(四 Tucker 分解)

学完了SVD算法之后,我们继续回到张量几大分解的学习上来,本期学习的主要内容是张量的 Tucker 分解 以及 前面的CP分解还留下一点没有说完,正好一并补齐!后面的公式我将采用颜色标记,红色代表必须掌握,蓝色尽量掌握! 在这之前先附一张图,包含了各种运算符号的名称含义,大部分是前面说过或者使用过的: Tensor decomposition一 . Tucker 分解公式介绍和原理二 . 张量的 n-Rank 一 . Tucker 分解公式介绍和原理 我们先来看一张被使用过很多次的Trucker 分解图

欢迎来到 豪哥 的博客 1万+

reactor百万连接的并发

epoll水平触发/边沿触发 LT,recvbuff中有数据就一直触发; ET,recvbuff中收到数据,只触发一次。如果recvbuff中数据没有读完,不会再次触发,当recvbuff中收到新的数据时,再次触发。也就是收到一个包,只触发一次。比如客户端发送32byte的包,服务器只recv了10byte的数据,那么epoll不会再次触发,等到下一次客户端再发送32byte的数据,epoll会再一次触发。对于ET,对于recv,最好是一个循环的读,直到读完,返回-1。 所以LT适合用于大包,数据没读完会一

congchp的博客 1659

超分算法 SwinIR: Image Restoration Using Swin Transformer

这篇文章结构比较简单,如果看过Swin-Transformer的话就没什么难点了。作者引入Swin-T结构应用于低级视觉任务,包括图像超分辨率重建、图像去噪、图像压缩伪影去除。网络由一个浅层特征提取模块、深层特征提取模块、重建模块构成。重建模块对不同的任务使用不同的结构。浅层特征提取就是一个3×3的卷积层。深层特征提取是k个RSTB块和一个卷积层构成。RSTB(Res- SwinIR: Image Restoration Using Swin Transformer[ICCV 2021]Abstract1.

qq_45122568的博客 1万+

网络编程:epoll 反应堆模式

epoll 反应堆模式 1、头文件和宏定义 2、系统 epoll_event 事件结构体 3、函数声明 4、main 函数 5、初始化 init_socklisten_tree 6、lfd 连接就绪处理函数 listenproc_lfd 7、cfd 读就绪处理函数 readproc_cfd,非阻塞循环读 8、cfd 写就绪处理函数 write_cfd 9、从监听树,删除/添加节点...

weixin_41565755的博客 593

电化学阻抗谱(EIS)在锂离子电池中的应用

摘要电化学阻抗谱(electrochemical impedance spectroscopy, EIS)是一种重要的电化学测试方法,在锂离子电池动力学反应机理研究及动力学参数测量等方面具有广泛的应用。在锂离子电池运行过程中,各反应步骤的动力学参数及时间常数不同,而EIS可以在较宽的频率范围内对体系施加小幅正弦激励信号,使得在特定频率下突出特定时间常数的电极过程,从而将复杂的电极过程分离,实现单一电极过程动力学的分析。通过对交流阻抗信息的研究,也可以为锂离子电池及其他电池的应用与管理、电化学过程设计及电极材

qiushireader的博客 2660

PDF与OFD电子发票解析技术实战:从格式转换到精准识别

本文深入探讨了PDF与OFD电子发票解析技术的实战应用,从格式转换到精准识别,提供了全面的解决方案。通过OFD转PDF技术、动态定位算法和多重校验机制,显著提升电子发票识别效率与准确率,助力企业财务数字化转型。

weixin_42565652的博客 167

单线程reactor支持百万连接

C1000K 目的 测试单线程reactor能否支持百万连接。 1个连接由5元组唯一确定: local_ip local_port peer_ip peer_port protocal 已知ubuntu-1604的默认的端口范围:32768-60999 假设client有20000个端口能用,server开100个端口,用2个client去连接server,则理论最大连接数是:20000 x 100 x 2 = 400万。 代码修改 在reactor的基础上,server开启100个监听端口。 虚拟机配

回头太难 2490

RagFlow专题三、RagFlow 关键技术(向量数据库、文档分块、Prompt 设计与召回排序优化)

FAISS 是由 Meta(Facebook)开源的高效向量检索库,适用于大规模向量搜索任务。,并了解了如何通过 RagFlow 机制优化信息检索和生成质量。(FAISS、Milvus、ES)用于高效存储和检索语义向量。提高 LLM 生成效果,增强 RagFlow 任务质量。(分块)策略,将文档拆分成更小的片段,提高检索效率。提高检索精准度,避免文本过长导致信息丢失。提升检索结果的相关性,提高生成质量。当多个检索结果被返回时,我们需要一个。在前一篇文章中,我们详细探讨了。在 RagFlow 任务中,

xiaoqi270620903的专栏 3044

linux epoll+eventfd实现线程间通信

使用linux的epoll和eventfd机制实现的线程间通信示例

u011376563的博客 965

Python爬虫实战:如何爬取汽车之家报价信息

本文通过实战介绍了如何使用Python编写爬虫,抓取汽车之家网站的车型、价格、配置等信息。在爬虫实现过程中,我们使用了requests库来发送HTTP请求,使用解析HTML页面,提取嵌入的JSON数据,并将数据存储到CSV文件中。同时,我们还介绍了如何使用反爬虫策略(如随机User-Agent、请求延时、代理池等)来规避反爬虫机制,确保爬虫的稳定性。

2201_76125261的博客 1596

从零到一构建一个智能爬虫 Agent 完整教程

本文将打造一个具备自主决策、动态解析、反反爬、持久化能力的智能爬虫 Agent

数据知道的博客 4799

reactor模式学习

1.什么是reactor模式 2.reactor模式解决的问题是什么 3.reactor模式的实现方式有哪些 一. 什么是reactor模式 讲这个之前,先整体上看看,如今服务端架构设计都是怎么做的。 (1) 经典的Thread-Based Architecture(线程模式)。 每来一个客户端,就用一个线程与客户端对接,与客户端之间的I/O操作也都放在子线程之中。 优点: 简单直观 缺点:链接和线程始终保持一一对应的关系。...

yuanshenqiang的博客 1393

YOLOv11 改进入门篇 | 轻量级涨点技巧:GhostConv 替代普通卷积的实战指南

摘要: 本文介绍如何通过GhostConv改进YOLOv11,实现轻量化涨点。YOLOv11深度增加导致参数量、延迟和内存占用上升,GhostConv通过“本征特征+线性变换”策略,在精度几乎无损的情况下降低30%-50%计算量。文章详细解析GhostConv原理,对比普通卷积的参数量和FLOPs优势,并提供完整的代码级改造流程,包括模块实现、注册及网络配置。实验表明,该方法有效提升边缘端推理效率,适用于移动端等资源受限场景。

shrgegrb的博客 1658

网络编程03——reactor网络模式实现百万并发连接

Reactor模式,也被称为分发者模式或通知者模式,是一种基于事件驱动的并发模型。它通过将事件处理逻辑与事件分发机制解耦,实现高性能、可扩展的并发处理。其核心思想在于利用操作系统提供的io多路复用机制(如select、poll、epoll等),高效地监听和分发事件,使得程序能够以非阻塞方式处理多个I/O事件。这些机制允许同时监视多个文件描述符或套接字,当其中一个文件描述符或套接字准备好进行I/O操作时,多路复用机制会通知应用程序。大量短时连接。

qq_74286523的博客 844

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

大中型超市收银系统(可直接运行)

光步前台收银系统系统功能:商品销售、商品退货、挂单、收银员权限、会员销售、单品取消、整单取消、商品查询、脱机销售、脱机数据上传,基本资料下载,开钱箱、小票打印、收款结算,支持多币种付款方式(现金、储值卡、礼券、微信等),支持多种促销。运行环境:.net 4.0登陆信息用户名:1001 密码:123456内置商品信息,商品编码可输入00001000 - 00010000,测试效果相关功能键F5 结算 F9挂单 F11商品查询 F8退货 Insert单品取消 Del整单取消 F12开钱箱F2 会员 Ctrl+Z退出系统 Home 锁屏 相关源码待公开

基于epoll与reactor模式的百万并发服务器以及百万连接测试(linux c)

基于epoll与reactor模式的百万并发服务器 reactor epoll 百万并发 百万连接 连接测试

m0_50401606的博客 545

怀旧版电脑GBC模拟器

再现原版GBC掌机的界面,电脑运行连游戏界面都一样大小,很怀旧,很真实,(英文版)强烈推荐,很小的文件,很难才找到的。

揭秘C++异步网络编程:如何用Reactor模式实现百万并发连接

掌握C++网络编程中Reactor模式的异步处理机制,轻松应对百万级并发连接挑战。适用于高性能服务器开发,提升系统吞吐量与响应速度。核心原理+代码实例解析,值得收藏。

AlgoInk的博客 335

锂电池充电器电路设计 里面有电路

锂电池充电器电路设计 里面有电路 3.7V升压到5V电路设计。

TCP服务器(reactor)单线程百万连接并发的实现(以栏目二代码为基础)--------(三)

(1条消息) (C++)利用TCP协议服务器(epoll),实现reactor(二)--------------------附直接实现代码_Gpangpangwa的博客-优快云博客 epoll组件的水平触发和边沿触发: 水平触发:我们的fd的缓存buffer里面有数据的时候就是水平触发(epoll默认是水平触发); ---------------大数据(buffer不能一次读完),listenfd的接受(防止客户端申请连接失败) 边沿触发: 缓存buffer从无数据到有数据的触发是边沿触发,也就

weixin_43961989的博客 4785

利用单线程reactor实现百万连接并发

#include <stdio.h> #include <stdlib.h> #include <string.h> #include <sys/socket.h> #include <sys/epoll.h> #include <arpa/inet.h> #include <fcntl.h> #include <unistd.h> #include <errno.h> #define ...

weixin_42381791的博客 711

基于reactor的百万并发和webserver、websocket应用

本文基于reactor事件驱动模型实现了百万级并发服务器,并开发了webserver和websocket应用。通过多端口监听和内核参数优化,服务器成功建立了101000个并发连接。采用reactor模型将IO事件与业务逻辑解耦,通过回调函数处理不同状态的请求。在webserver中引入状态机机制,分阶段处理HTTP请求和响应;websocket则实现了HTTP握手升级和数据帧通信。

weixin_67693061的博客 858

reactor以及百万服务器并发的实现

实现reactor,百万服务器并发实现过程中遇到的各种问题及其解决方案。

2402_88130836的博客 860

单机测试百万连接

1.修改系统设置的最大打开文件数 修改/etc/sysctl.conf,将fs.file-max上限值改到百万以上,可用 【sysctl -a | grep file-max】这个命令看到原本机器上的这个值的设置.

Edidaughter的博客 408

Reactor百万级并发

Qps:前面1000个连接耗费大约1秒多一点。到达28万左右时1000个连接将近10秒钟,后面慢慢达到20秒。最终测试一台虚拟服务器,一台虚拟客户端。测试可以连接到34万。:五元组不够-Cannot assign requested address。代码逻辑其实没有啥复杂,关键就是要把epoll三个函数弄懂到底是干啥的。方法2:需要在/etc/security/limits.conf中添加。方法1:Ubuntu没测试,centos可以。它是一种简单并且有效的实现资源限制的方式。:centos中修改不生效。

码愉 705

【Reactor百万并发模型】

reactor模型实现

wu_tingqiang的博客 924

Spring WebFlux构建百万级实时推送系统

本文介绍了一种基于Spring WebFlux和Project Reactor的高性能实时推送系统架构,可支持120万+ WebSocket长连接,实现毫秒级消息延迟和50万消息/秒的吞吐量。系统采用分层架构设计,包含客户端层、负载均衡层、网关层、业务处理层和数据层,通过智能连接路由算法和三级缓存策略(内存/Redis/数据库)优化连接管理。消息分发支持单播、组播和广播模式,结合Redis Pub/Sub和Kafka实现高效消息路由。系统还包含完善的监控体系,资源利用率提升300%,解决了传统阻塞式架构在百

如果足够勇敢 应该扛起问题往前走 直到因果成熟自动脱落 人对问题的解决方式 不是试图找到答案 而是背负到可以解决的那一天 2078

TCP服务器的演变过程:使用epoll构建reactor网络模型实现百万级并发(详细代码)

在现代互联网应用中,高并发性能是至关重要的。Reactor模型作为处理并发I/O的常见模式,凭借其高效的事件处理机制,能够有效提升服务器的并发能力。本文将深入探讨如何使用epoll构建Reactor网络模型,并结合详细代码实现,帮助读者从零开始构建支持百万级并发的TCP服务器。通过学习Reactor模型,您将掌握构建高性能网络应用的核心技术,为应对日益增长的用户需求做好准备。

Lion_Long的博客 2159

支持百万并发的服务器测试

如何让一个服务器程序支持百万并发,测试过程中会遇到的问题。

QNBZ的博客 1242
上一篇: Redis io多线程
下一篇: 时间堆原理详解及C++11的实现
评论 1
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值