伊人久久综在合线亚洲91,久久久久亚洲AV无码专区网站 ,337P日本欧洲亚洲大胆精品

SO_REUSEPORT学习(f��n)�W�记补遗

nieyong — Wed, 25 Feb 2015 14:23:00 GMT

前言

因�ؓ(f��)能力有限�Q�还是有很多东西�Q�SO_REUSEADDR和SO_REUSEPORT的区别等�Q�没有能够在一��文字中表达清楚�Q�作��遗，也方便以后自己回�q�头来复�?f��n)�?/p>

SO_REUSADDR VS SO_REUSEPORT

两者不是一码事�Q�没有可比性。有时也�?x��)被其搞晕，自己�ȝ��的不好，推荐StackOverflow�?a >Socket options SO_REUSEADDR and SO_REUSEPORT, how do they differ?资料�Q��ȝ��的很全面�?/p>

��单来��_(d��)��(x��)

讄��?ji��n)SO_REUSADDR的应用可以避免TCP �?TIME_WAIT 状�?旉��q�长无法复用端口�Q�尤其表现在应用�E�序关闭-重启交替的瞬�?
SO_REUSEPORT更强大，隶属于同一个用��P��防止端口劫持�Q�的多个�q�程/�U�程�׃�n一个端口，同时在内核层面替上层应用做数据包�q�程/�U�程的处理均�?

若有困惑�Q�推荐两者都讄��Q�不�?x��)有冲突�?/p>

Netty多线�E��用SO_REUSEPORT

上一��讲到SO_REUSEPORT�Q�多个程�l�定同一个端口，可以�Ҏ(gu��)��需要控制进�E�的数量。这里讲讲基�?code>Netty 4.0.25+Epoll navtie transport在单个进�E�内多个�U�程�l�定同一个端口的情况�Q�也是比较实用的�?/p>

TCP服务器，同一个进�E�多�U�程�l�定同一个端�?/h4>

�q�是一个PING-PONG�C��应用�Q?/p>

     public void run() throws Exception {
            final EventLoopGroup bossGroup = new EpollEventLoopGroup();
            final EventLoopGroup workerGroup = new EpollEventLoopGroup();
            ServerBootstrap b = new ServerBootstrap();

           b.group(bossGroup, workerGroup)
                     .channel(EpollServerSocketChannel. class)
                     .childHandler( new ChannelInitializer<SocketChannel>() {
                            @Override
                            public void initChannel(SocketChannel ch) throws Exception {
                                ch.pipeline().addLast(
                                            new StringDecoder(CharsetUtil.UTF_8 ),
                                            new StringEncoder(CharsetUtil.UTF_8 ),
                                            new PingPongServerHandler());
                           }
                     }).option(ChannelOption. SO_REUSEADDR, true)
                     .option(EpollChannelOption. SO_REUSEPORT, true)
                     .childOption(ChannelOption. SO_KEEPALIVE, true);

            int workerThreads = Runtime.getRuntime().availableProcessors();
           ChannelFuture future;
            for ( int i = 0; i < workerThreads; ++i) {
                future = b.bind( port).await();
                 if (!future.isSuccess())
                      throw new Exception(String. format("fail to bind on port = %d.",
                                 port), future.cause());
           }
           Runtime. getRuntime().addShutdownHook (new Thread(){
                 @Override
                 public void run(){
                     workerGroup.shutdownGracefully();
                     bossGroup.shutdownGracefully();
                }
           });
     }

打成jar包，在CentOS 7下面�q�行�Q�检查同一个端口所打开的文件句柄�?/p>

# lsof -i:8000
COMMAND  PID USER   FD   TYPE DEVICE SIZE/OFF NODE NAME
java    3515 root   42u  IPv6  29040      0t0  TCP *:irdmi (LISTEN)
java    3515 root   43u  IPv6  29087      0t0  TCP *:irdmi (LISTEN)
java    3515 root   44u  IPv6  29088      0t0  TCP *:irdmi (LISTEN)
java    3515 root   45u  IPv6  29089      0t0  TCP *:irdmi (LISTEN)

同一�q�程�Q�但打开的文件句柄是不一��L(f��ng)��?/p>

UDP服务器，多个�U�程�l�同一个端�?/h4>

/**
 * UDP谚语服务器，单进�E�多�U�程�l�定同一端口�C����
 */
public final class QuoteOfTheMomentServer {

       private static final int PORT = Integer.parseInt(System. getProperty("port" ,
                   "9000" ));

       public static void main(String[] args) throws Exception {
             final EventLoopGroup group = new EpollEventLoopGroup();

            Bootstrap b = new Bootstrap();
            b.group(group).channel(EpollDatagramChannel. class)
                        .option(EpollChannelOption. SO_REUSEPORT, true )
                        .handler( new QuoteOfTheMomentServerHandler());

             int workerThreads = Runtime.getRuntime().availableProcessors();
             for (int i = 0; i < workerThreads; ++i) {
                  ChannelFuture future = b.bind( PORT).await();
                   if (!future.isSuccess())
                         throw new Exception(String.format ("Fail to bind on port = %d.",
                                     PORT), future.cause());
            }

            Runtime. getRuntime().addShutdownHook(new Thread() {
                   @Override
                   public void run() {
                        group.shutdownGracefully();
                  }
            });
      }
}
}

@Sharable
class QuoteOfTheMomentServerHandler extends
            SimpleChannelInboundHandler<DatagramPacket> {

       private static final String[] quotes = {
                   "Where there is love there is life." ,
                   "First they ignore you, then they laugh at you, then they fight you, then you win.",
                   "Be the change you want to see in the world." ,
                   "The weak can never forgive. Forgiveness is the attribute of the strong.", };

       private static String nextQuote() {
             int quoteId = ThreadLocalRandom.current().nextInt( quotes .length );
             return quotes [quoteId];
      }

       @Override
       public void channelRead0(ChannelHandlerContext ctx, DatagramPacket packet)
                   throws Exception {
             if ("QOTM?" .equals(packet.content().toString(CharsetUtil. UTF_8))) {
                  ctx.write( new DatagramPacket(Unpooled.copiedBuffer( "QOTM: "
                              + nextQuote(), CharsetUtil. UTF_8), packet.sender()));
            }
      }

       @Override
       public void channelReadComplete(ChannelHandlerContext ctx) {
            ctx.flush();
      }

       @Override
       public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
            cause.printStackTrace();
      }
}

同样也要��(g��)��一下端口文件句柄打开情况�Q?/p>

# lsof -i:9000
COMMAND  PID USER   FD   TYPE DEVICE SIZE/OFF NODE NAME
java    3181 root   26u  IPv6  27188      0t0  UDP *:cslistener
java    3181 root   27u  IPv6  27217      0t0  UDP *:cslistener
java    3181 root   28u  IPv6  27218      0t0  UDP *:cslistener
java    3181 root   29u  IPv6  27219      0t0  UDP *:cslistener

��结

以上为Netty+SO_REUSEPORT多线�E�绑定同一端口的一些情况，是�ؓ(f��)记蝲�?/p>

nieyong 2015-02-25 22:23 发表评论

SO_REUSEPORT学习(f��n)�W�记

nieyong — Thu, 12 Feb 2015 08:50:00 GMT

前言

本篇用于记录学习(f��n)SO_REUSEPORT的笔记和�?j��)得�Q�末��还?sh��)��(x��)提供一个bindp��工具也能�ؓ(f��)已有的程序��n受这个新的特性�?/p>

当前Linux�|�络应用�E�序问题

�q�行在Linux�pȝ��上网�l�应用程序，��Z��(ji��n)利用多核的优势，一般��用以下比较典型的多进�E?多线�E�服务器模型�Q?/p>

单线�E�listen/accept�Q�多个工作线�E�接收�Q务分发，虽CPU的工作负载不再是问题�Q�但�?x��)存在�?x��)
- 单线�E�listener�Q�在处理高速率��量�q�接�Ӟ��一样会(x��)成�ؓ(f��)瓉��
- CPU�~�存行丢失套接字�l�构(socket structure)现象严重
所有工作线�E�都accept()在同一个服务器套接字上呢，一样存在问题：(x��)
- 多线�E�访问server socket锁竞争严�?/li>
- 高负载下�Q�线�E�之间处理不均衡�Q�有旉��?:1不均衡比�?/li>
- ��D��CPU�~�存行蟩�?cache line bouncing)
- 在繁忙C(j��)PU上存在较大�g�q?/li>

上面模型虽然可以做到�U�程和CPU核绑定，但都�?x��)存在�?x��)

单一listener工作�U�程在高速的�q�接接入处理时会(x��)成�ؓ(f��)瓉��
�~�存行蟩�?/li>
很难做到CPU之间的负载均�?/li>
随着核数的扩展，性能�q�没有随着提升

比如HTTP CPS(Connection Per Second)吞吐量�ƈ没有随着CPU核数增加呈现�U�性增长：(x��)

Linux kernel 3.9带来�?ji��n)SO_REUSEPORT�Ҏ(gu��)��，可以解决以上大部分问题�?/p>

SO_REUSEPORT解决�?ji��n)什么问�?/h3>
linux man文档中一�D�|��字描�q�其作用�Q?/p>

The new socket option allows multiple sockets on the same host to bind to the same port, and is intended to improve the performance of multithreaded network server applications running on top of multicore systems.

SO_REUSEPORT支持多个�q�程或者线�E�绑定到同一端口�Q�提高服务器�E�序的性能�Q�解决的问题�Q?/p>

允许多个套接�?bind()/listen() 同一个TCP/UDP端口

每一个线�E�拥有自��q��服务器套接字

在服务器套接字上没有�?ji��n)锁的竞�?/li>

内核层面实现负蝲均衡

安全层面�Q�监听同一个端口的套接字只能位于同一个用户下�?/li>

其核�?j��)的实现主要有三点�?x��)

扩展 socket option�Q�增�?SO_REUSEPORT 选项�Q�用来设�|?reuseport�?/li>
修改 bind �pȝ��调用实现�Q�以便支持可以绑定到相同�?IP 和端�?/li>
修改处理新徏�q�接的实玎ͼ�查找 listener 的时候，能够支持在监听相�?IP 和端口的多个 sock 之间均衡选择�?/li>

代码分析�Q�可以参考引用资�?[多个�q�程�l�定相同端口的实现分析[Google Patch]]�?/p>

CPU之间�q��处理�Q�水�q�x(ch��ng)��?/h4>
以前通过`fork`形式创徏多个子进�E�，现在有了(ji��n)SO_REUSEPORT�Q�可以不用通过`fork`的�Ş式，让多�q�程监听同一个端口，各个�q�程�?code>accept socket fd不一��P��有新�q�接建立�Ӟ��内核只会(x��)唤醒一个进�E�来`accept`�Q��ƈ且保证唤醒的均衡性�?/p>
模型��单，�l�护方便�?ji��n)，�q�程的管理和应用逻辑解耦，�q�程的管理水�q�x(ch��ng)��展权限下攄��E�序�?��理员，可以�Ҏ(gu��)��实际�q�行控制�q�程启动/关闭�Q�增加了(ji��n)灉|��性�?/p>
�q�带来了(ji��n)一个较为微观的水��^扩展思�\�Q�线�E�多��是否合适，状态是否存在共享，降低单个�q�程的资源依赖，针对无状态的服务器架构最为适合�?ji��n)�?/p>

新特性测试或多个版本共存

可以很方便的��试新特性，同一个程序，不同版本同时�q�行中，�Ҏ(gu��)��q�行�l�果军_��新老版本更�q�与否�?/p>

针对对客��L(f��ng)��而言�Q�表面上感受不到其变动，因�ؓ(f��)�q�些工作完全在服务器端进行�?/p>

服务器无�~�重�?切换

��x(ch��ng)��是，我们�q�代�?ji��n)一版本�Q�需要部�|�到�U�上�Q��ؓ(f��)之启动一个新的进�E�后�Q�稍后关闭旧版本�q�程�E�序�Q�服务一直在�q�行中不间断�Q�需要��^衡过度。这��像Erlang语言层面所提供的热更新一栗��?/p>

��x(ch��ng)��不错�Q�但是实际操作�v来，��׃��是那么��^滑了(ji��n)�Q�还好有一�?a >hubtime开源工��P��原理�?code>SIGHUP信号处理�?SO_REUSEPORT+LD_RELOAD�Q�可以帮助我们轻村ց�刎ͼ�有需要的同学可以��(g��)�?gu��)��用一下�?/p>

SO_REUSEPORT已知问题

SO_REUSEPORT�Ҏ(gu��)��数据包的四元�l�{src ip, src port, dst ip, dst port}和当前绑定同一个端口的服务器套接字数量�q�行数据包分发。若服务器套接字数量产生变化�Q�内�怼�(x��)把本该上一个服务器套接字所处理的客��L(f��ng)��q�接所发送的数据包（比如三次握手期间的半�q�接�Q�以�?qi��ng)已�l�完成握手但在队列中排队的连接）(j��)分发到其它的服务器套接字上面�Q�可能会(x��)��D��客户端请求失败，一般可以��用：(x��)

使用固定的服务器套接字数量，不要在负载繁忙期间轻易变�?/li>
允许多个服务器套接字�׃�nTCP��h��?Tcp request table)
不��用四元组作�ؓ(f��)Hash��D��行选择本地套接字处理，�?xi��)选隶属于同一个CPU的套接字

与RFS/RPS/XPS-mq协作�Q�可以获得进一步的性能�Q?/p>

服务器线�E�绑定到CPUs
RPS分发TCP SYN包到对应CPU�怸�
TCP�q�接被已�l�定到CPU上的�U�程accept()
XPS-mq(Transmit Packet Steering for multiqueue)�Q�传输队列和CPU�l�定�Q�发送数�?/li>
RFS/RPS保证同一个连接后�l�数据包都会(x��)被分发到同一个CPU�?/li>
�|�卡接收队列已经�l�定到CPU�Q�则RFS/RPS则无��设�|?/li>
需要注意硬件支持与�?/li>

目的嘛，数据包的软硬中断、接收、处理等在一个CPU�怸��Q��ƈ行化处理�Q�尽可能做到资源利用最大化�?/p>

SO_REUSEPORT不是一贴万能膏�?/h4>
虽然SO_REUSEPORT解决�?ji��n)多个进�E�共同绑�?监听同一端口的问题，但根据新��林晓峰同学��试�l�果来看�Q�在多核扩展层面也未能够做到理想的线性扩展：(x��)

可以参考Fastsocket在其基础之上的改�q�，链接地址�?/p>

支持SO_REUSEPORT的Tengine

淘宝的Tengine已经支持�?ji��n)SO_REUSEPORT�Ҏ(gu��)��，在其��试报告中，有一个简单测试，可以看出来相�Ҏ(gu��)��SO_REUSEPORT所带来的性能提升�Q?/p>

使用SO_REUSEPORT以后�Q�最明显的效果是在压力下不容易出��C��h��的情况，CPU均衡性��^�E��?/p>

Java支持否？

JDK 1.6语言层面不支持，至于以后的版本，�׃��暂时没有使用刎ͼ�不多说�?/p>

Netty 3/4版本默认都不支持SO_REUSEPORT�Ҏ(gu��)��，但Netty 4.0.19以及(qi��ng)之后版本才真正提供了(ji��n)JNI方式单独包装的epoll native transport版本�Q�在Linux�pȝ��下运行）(j��)�Q�可以配�|�类��g��SO_REUSEPORT�{�（JAVA NIIO没有提供�Q�选项�Q�这部分是在io.netty.channel.epoll.EpollChannelOption中定义（在线代码部分�Q��?/p>

在linux环境下��用epoll native transport�Q�可以获得内核层面网�l�堆栈增强的�U�利�Q�如何��用可参�?a >Native transports文档�?/p>

使用epoll native transport倒也��单，�c�d��E�作替换�Q?/p>

NioEventLoopGroup → EpollEventLoopGroup
NioEventLoop → EpollEventLoop
NioServerSocketChannel → EpollServerSocketChannel
NioSocketChannel → EpollSocketChannel

比如写一个PING-PONG应用服务器程序，�c�M��代码�Q?/p>

public void run() throws Exception {
    EventLoopGroup bossGroup = new EpollEventLoopGroup();
    EventLoopGroup workerGroup = new EpollEventLoopGroup();
    try {
        ServerBootstrap b = new ServerBootstrap();
        ChannelFuture f = b
                .group(bossGroup, workerGroup)
                .channel(EpollServerSocketChannel.class)
                .childHandler(new ChannelInitializer() {
                    @Override
                    public void initChannel(SocketChannel ch)
                            throws Exception {
                        ch.pipeline().addLast(
                                new StringDecoder(CharsetUtil.UTF_8),
                                new StringEncoder(CharsetUtil.UTF_8),
                                new PingPongServerHandler());
                    }
                }).option(ChannelOption.SO_REUSEADDR, true)
                .option(EpollChannelOption.SO_REUSEPORT, true)
                .childOption(ChannelOption.SO_KEEPALIVE, true).bind(port)
                .sync();
        f.channel().closeFuture().sync();
    } finally {
        workerGroup.shutdownGracefully();
        bossGroup.shutdownGracefully();
    }
}

若不要这么折腾，�q�想让以往Java/Netty应用�E�序在不做�Q何改动的前提下顺利在Linux kernel >= 3.9下同样��n受到SO_REUSEPORT带来的好处，不妨��试一�?a >bindp�Q�更为经��，�q�一部分下面�?x��)讲到�?/p>

bindp�Q��ؓ(f��)已有应用��d��SO_REUSEPORT�Ҏ(gu��)�?/h3>

以前所�?a >bindp��程序，可以为已有程序绑定指定的IP地址和端口，一斚w��可以省去��编码，另一斚w��也�ؓ(f��)��试提供�?ji��n)一些方�ѝ�?/p>

另外�Q��ؓ(f��)�?ji��n)让以前没有��编�?code>SO_REUSEPORT的应用程序可以在Linux内核3.9以及(qi��ng)之后Linux�pȝ��上也能够得到内核增强支持�Q�稍做修改，��d��支持�?/p>

但要求如下：(x��)

Linux内核(>= 3.9)支持SO_REUSEPORT�Ҏ(gu��)�?/li>
需要配�|?code>REUSE_PORT=1

不满��以上条�Ӟ��此特性将无法生效�?/p>

使用�C��Q?/p>

REUSE_PORT=1 BIND_PORT=9999 LD_PRELOAD=./libbindp.so java -server -jar pingpongserver.jar &

当然�Q�你可以�Ҏ(gu��)��需要运行命令多�ơ，多个�q�程监听同一个端口，单机�q�程水��^扩展�?/p>

使用�C��

使用python脚本快速构��Z��个小的示范原型，两个�q�程�Q�都监听同一个端�?0000�Q�客��L(f��ng)��h��q�回不同内容�Q�仅供娱乐�?/p>

server_v1.py�Q�简单PING-PONG�Q?/p>

# -*- coding:UTF-8 -*-

import socket
import os

PORT = 10000
BUFSIZE = 1024

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind(('', PORT))
s.listen(1)

while True:
    conn, addr = s.accept()
    data = conn.recv(PORT)
    conn.send('Connected to server[%s] from client[%s]\n' % (os.getpid(), addr))
    conn.close()

s.close()

server_v2.py�Q�输出当前时��_(d��)��(x��)

# -*- coding:UTF-8 -*-

import socket
import time
import os

PORT = 10000
BUFSIZE = 1024

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind(('', PORT))
s.listen(1)

while True:
    conn, addr = s.accept()
    data = conn.recv(PORT)
    conn.send('server[%s] time %s\n' % (os.getpid(), time.ctime()))
    conn.close()

s.close()

借助于bindp�q�行两个版本的程序：(x��)

REUSE_PORT=1 LD_PRELOAD=/opt/bindp/libindp.so python server_v1.py &
REUSE_PORT=1 LD_PRELOAD=/opt/bindp/libindp.so python server_v2.py &

模拟客户端请�?0�ơ：(x��)

for i in {1..10};do echo "hello" | nc 127.0.0.1 10000;done

看看�l�果吧：(x��)

Connected to server[3139] from client[('127.0.0.1', 48858)]
server[3140] time Thu Feb 12 16:39:12 2015
server[3140] time Thu Feb 12 16:39:12 2015
server[3140] time Thu Feb 12 16:39:12 2015
Connected to server[3139] from client[('127.0.0.1', 48862)]
server[3140] time Thu Feb 12 16:39:12 2015
Connected to server[3139] from client[('127.0.0.1', 48864)]
server[3140] time Thu Feb 12 16:39:12 2015
Connected to server[3139] from client[('127.0.0.1', 48866)]
Connected to server[3139] from client[('127.0.0.1', 48867)]

可以看出来，CPU分配很均衡，各自分配50%的请求量�?/p>

嗯，虽是��玩��P��有些意�?:))

bindp的��用方�?/h4>
更多使用说明�Q�请参�?a >README�?/p>

参考资�?/h3>

《SO_REUSEPORT: Scaling Techniques for Servers with High Connection Rates》PPT

huptime

SO_REUSEPORT and accept(2) performance

多个�q�程�l�定相同端口的实现分析[Google Patch]

nieyong 2015-02-12 16:50 发表评论

Fastsocket学习(f��n)�W�记之小�l�篇

nieyong — Thu, 05 Feb 2015 07:21:00 GMT

前言

前面啰啰嗦嗦的几��文字，各个斚w��介绍�?ji��n)Fastsocket�Q�盲人摸象一般，能力有限�Q�还得��l�深入学�?f��n)不是。这不，��C��(ji��n)该小�l�收��时候了(ji��n)�?/p>

�~��v�Q�内核已�l�成为瓶�?/h3>
使用Linux作�ؓ(f��)服务器，在请求量很小的时候，是不用担�?j��)其性能。但在�v量的数据��h��下，Linux内核在TCP/IP�|�络处理斚w��Q�已�l�成为瓶颈。比如新��在某台HAProxy服务器上取样�Q?0%的CPU旉��被内核占用，应用�E�序只能够分配到较少的CPU旉��周期的资源�?/p>

�l�过Haproxy�pȝ��详尽分析后，发现大部分CPU资源消耗在kernel里，�q�且在多核��^��C��Q�kernel在网�l�协议栈处理�q�程中存在着大量同步开销�?/p>

同时在多�怸��q�行��试�Q�HTTP CPS(Connection Per Second)吞吐量�ƈ没有随着CPU核数增加呈现�U�性增长：(x��)

内核3.9之前的Linux TCP调用

kernel 3.9之前的tcp socket实现
bind�pȝ��调用�?x��)将socket和port�q�行�l�定�Q��ƈ加入全局tcp_hashinfo的bhash链表�?
所有bind调用都会(x��)查询�q�个bhash链表�Q�如果port被占用，内核�?x��)导致bind��p�|
listen则是�Ҏ(gu��)��用户讄��的队列大��预先�ؓ(f��)tcp�q�接分配内存�I�间
一个应用在同一个port上只能listen一�ơ，那么也就只有一个队列来保存已经建立的连�?
nginx在listen之后�?x��)fork处多个worker�Q�每个worker�?x��)��承listen的socket�Q�每个worker�?x��)创��Z��个epoll fd�Q��ƈ��listen fd和accept的新�q�接的fd加入epoll fd
但是一旦新的连接到来，多个nginx worker只能排队accept�q�接�q�行处理
对于大量的短�q�接�Q�accept昄��成�ؓ(f��)�?ji��n)一个瓶�?

Linux�|�络堆栈所存在问题

TCP处理&多核
- 一个完整的TCP�q�接�Q�中断发生在一个CPU�怸��Q�但应用数据处理可能�?x��)在另外一个核�?
- 不同CPU核心(j��)处理�Q�带来了(ji��n)锁竞争和CPU Cache Miss�Q��L动不�q��Q?
- 多个�q�程监听一个TCP套接字，�׃�n一个listen queue队列
- 用于�q�接��理全局哈希表格�Q�存在资源竞�?
- epoll IO模型多进�E�对accept�{�待�Q�惊��现�?br />
Linux VFS的同步损耗严�?/p>
- Socket被VFS��理
- VFS�Ҏ(gu��)��件节点Inode和目录Dentry有同步需�?
- SOCKET只需要在内存?sh��)��存在即可，非严格意义上文�g�pȝ��Q�不需要Inode和Dentry
- 代码层面略过不必��ȝ��常规锁，但又保持�?ji��n)��够的兼容�?

Fastsocket所作改�q?/h3>

TCP单个�q�接完整处理做到�?ji��n)CPU本地化，避免�?ji��n)资源竞�?
保持完整BSD socket API

CPU之间不共享数据，�q�行化各自独立处理TCP�q�接�Q�也是其高效的主要原因。其架构囑֏�以看出其改进�Q?/p>

Fastsocket架构囑֏�以很清晰说明其大致结构，内核态和用户态通过`ioctl`函数传输。记得netmap在重写网卡驱动里面通过`ioctl`函数直接透传到用��h��中�Q�其更�ؓ(f��)高效�Q�但没有完整的TCP/IP�|�络堆栈支持嘛�?/p>

Fastsocket的TCP调用�?/h4>

多个�q�程可以同时listen在同一个port�?
动态链接库libfsocket.so拦截socket、bind、listen�{�系�l�调用�ƈ�q�入�q�个链接库进行处�?
对于listen�pȝ��调用�Q�fastsocket�?x��)记录下�q�个fd�Q�当应用通过epoll��这个fd加入到epoll fdset中时�Q�libfsocket.so�?x��)通过ioctl��q�程clone listen fd兌��的socket、sock、file的系�l�资�?
内核模块��clone的socket再次调用bind和listen
bind�pȝ��调用��(g��)��到另外一个进�E�绑定到已经被绑定的port�Ӟ��?x��)进行相��x(ch��ng)��?
通过��(g��)查sock��会(x��)被记录到port相关联的一个链表中�Q�通过该链表可以知道所有bind同一个port的sock
而sock是关联到fd的，�q�程则持有fd�Q�那么所有的资源��已�l�关联到一�?
新的�q�程再次调用listen�pȝ��调用的时候，fastsocket内核�?x��)再�ơ��?f��)其关联的sock分配accept队列
�l�果是多个进�E�也��拥有了(ji��n)多个accept队列�Q�可避免cpu cache miss
fastsocket提供��每个listen和accept的进�E�绑定到用户指定的CPU�?
如果用户未指定，fastsocket��会(x��)��q�程默认�l�定一个空闲的CPU�?

Fastsocket短连接性能

在新��测试中�Q�在24核的安装有Centos 6.5的服务器上，借助于Fastsocket�Q�Nginx和HAProxy每秒处理�q�接数指标（connection/second�Q�性能很惊人，分别增加290%�?20%。这也证明了(ji��n)�Q�Fastsocket带来�?ji��n)TCP�q�接快速处理的能力�?除此之外�Q�借助于硬件特性：(x��)

借助于Intel��U�程�Q�可以获得另�?0%的性能增长
HAProxy代理服务器借助于网卡Flow-Director�Ҏ(gu��)��支持，吞吐量可增加15%

Fastsocket V1.0正式版从2014�q?月䆾开始已�l�在新浪生��环境中��用，用作代理服务器，因此大家可以考虑是否可以采用。针�?.0版本�Q�以下环境较为收益：(x��)

服务器至��不��于8个CPU核心(j��)
短连接被大量使用
CPU周期大部分消耗在�|�络软中断和套接字系�l�调用上
应用�E�序使用��Z��epoll的非��d��IO
应用�E�序使用多个�q�程单独接受�q�接

多线�E�嘛�Q�就得需要参考示范应用所提供实践��?ji��n)�?/p>

Nginx��试服务器配�|?/h4>

nginx工作�q�程数量讄��成CPU核数�?
http keep-alive�Ҏ(gu��)��被��用
��试端http_load从nginx获取64字节�?r��n)态文�Ӟ��q�发量�ؓ(f��)500*CPU核数
启用内存�~�存�?r��n)态文件访问，用于排除��盘影响
务必��用accept_mutex�Q�多核访问a(ch��n)ccept产生锁竞争，另fastsocket内核模块为其去除�?ji��n)锁竞争�Q?

从下表测试图片中�Q�可以看刎ͼ�(x��)

Fastsocket�?4核服务器辑ֈ��?75K Connection/Second�Q�获得了(ji��n)21倍的提升
Centos 6.5在CPU核数增长�?2核时�q�没有呈现线性增长势��_(d��)��反而在24核时下降�?59k CPS
Linux kernel 3.13�?4核时获得�?ji��n)近乎两倍于Centos 6.5的吞吐量�Q?83K CPS�Q�但�?2核后呈现出扩展性瓶�?

HAProxy重要配置

工作�q�程数量�{�同于CPU核数�?
需要启用RFD(Receive Flow Deliver)
http keep-alive需要禁�?
��试端http_load�q�发量�ؓ(f��)500*CPU核数
后端服务器响应外�?4个字节的消息

��试�l�果中：(x��)

fastsocket呈现��Z��(ji��n)惊�h的扩展性能
24核，Linux kernel 3.13成�W�?39K CPS
24核，Centos 6.5借助Fastsocket�Q�获得了(ji��n)370K CPS的吞吐量

实际部��v环境的成�l?/h4>

8核服务器�U�上环境�q�行�?4��时的成�l�，图a展示�?ji��n)部�|�fastsocket之前CPU利用率，图b为部�|�了(ji��n)fastsocekt之后的CPU利用率�?Fastsocket带来的收益：(x��)

每个CPU核心(j��)负蝲均衡
�q�_��CPU利用率降�?0%
HAProxy处理能力增长85%

其实吧，�q�一块期待新��公布更多的数据�?/p>

长连接的支持正在开发中

长连接支持，�q�是需要等一�{�的。但是要支持什么类型长�q�接�Q�百万��别应用服务器�c�d��Q�还是redis�Q�可能是后者。虽然目前正做，但目前没有时间表�Q�但目前所做特性�ȝ��如下�Q?/p>

�|�络堆栈的定�?
- SKB-Pool�Q�每一CPU核对应一个预分配skb pool�Q�替换内核缓冲区kernel slab
  - Percore skb pool
  - 合�ƈskb头部和数�?
  - 本地Pool和重复��@环��用的Pool�Q�F(tu��n)low-Director�Q?
- Fast-Epoll
  - 多进�E�之间TCP�q�接�׃�n变得�E��?
  - 在file�l�构体中保存Epoll entry�Q�用以节省调用epoll_ctl时红黑树(w��i)查询的开销
跨层的设�?
- Direct-TCP�Q�数据包隶属于已建立套接字会(x��)直接跌��路由�q�程
  - 记录TCP套接字的输入路由信息�Q�Record input route information in TCP socket�Q?
  - 直接查找�|�络套接字在�q�入�|�络堆栈之前�Q�Lookup socket directly before network stack�Q?
  - 从套接字��d��输入路由信息�Q�Read input route information from socket�Q?
  - 标记数据包被路有�q�（Mark the packet as routed�Q?
- Receive-CPU-Selection �c�M��于RFS�Q�但更轻巧、精准与快�?
  - 把当前CPU核id�~�码到套接字中（Application marks current CPU id in the socket�Q?
  - 直接查询套接字在�q�入�|�络堆栈之前�Q�Lookup socket directly before network stack�Q?
  - ��d��套接字中包含的CPU核，然后发送给它（Read CPU id from socket and deliver accordingly�Q?
- RPS-Framework 数据包在�q�入�|�络堆栈之前�Q�让开发者在内核模块之外定制数据包投递规则，扩充RPS功能

Redis��试�l�果

��试环境:

CPU: Intel E5 2640 v2 (6 core) * 2
NIC: Intel X520

Redis配置选项:

TCP持久�q�接
8个Redis实例�Q�绑定不同端�?
使用�?个CPU核心(j��)�Q��ƈ且绑定CPU�?

��试�l�果�Q?/p>

仅开启RSS�Q?0%的吞吐量增加
启用�|�卡Flow-Director�Ҏ(gu��)��：(x��)45%吞吐量增�?

但需要注意：(x��)

仅�ؓ(f��)实验��试阶段
为V1.0补充�Q�Nginx和HAProxy同样�?x��)收�?

Fastsocket v1.1

V1.1版本要增加长�q�接的支持，那么�c�M��于Redis的服务器应用�E�序��很受益�?ji��n)，因��?f��)没有具体的时间表�Q�只能够慢慢�{�待�?ji��n)�?/p>

以后一些优化措�?/h3>

在上下文切换�Ӟ��避免拯��操作�Q�Zero-Copy
中断机制完善�Q�减��中�?
支持扚w��提交�Q�降低系�l�函数调�?
提交到Linux kernel��d��支上�?
HugeTLB/HugePage�{?

Fastsocket和mTCP�{�简单对�?/h3>
说是�Ҏ(gu��)��Q�其实是我从mTCP论文中摘取出来，增加�?ji��n)Fastsocket一栏，可以看出��Z��一直努力的脚步�?/p>

Types Accept queue Conn. Locality Socket API Event Handling Packet I/O Application Mod- ification Kernel Modification

PSIO ,
DPDK ,
PF RING ,
netmap No TCP stack Batched No interface for transport layer No
(NIC driver)

Linux-2.6 Shared None BSD socket Syscalls Per packet Transparent No

Linux-3.9 Per-core None BSD socket Syscalls Per packet Add option SO REUSEPORT No

Affinity-Accept Per-core Yes BSD socket Syscalls Per packet Transparent Yes

MegaPipe Per-core Yes lwsocket Batched syscalls Per packet Event model to completion I/O Yes

FlexSC,VOS Shared None BSD socket Batched syscalls Per packet Change to use new API Yes

mTCP Per-core Yes User-level socket Batched function calls Batched Socket API to mTCP API No
(NIC driver)

Fastsocket Per-core Yes BSD socket Ioctl + kernel calls Per packet Transparent No

有一个大致的印象�Q�也方便�Ҏ(gu��)��Q�但�q�只能是一个暂时的摘要而已�Q��h�c�d��性能的��(f��)求��L��朝着更好的方向发展着�?/p>

部��v��试

怎么说呢�Q�Fastsocket是�ؓ(f��)大家耳熟能详服务器程序Nginx�Q�HAProxy�{�而开发的。但若应用环境�ؓ(f��)大量的短�q�接�Q��ƈ且是��文件类型请求，不需要强制支持Keep-alive�Ҏ(gu��)��（短连接要的是快速请�?相应�Q�然后关闭）(j��)�Q�那么管理员可以��试一下Fastsocket�Q�至于部�|�策略，选择性部�|�几��C��为实验看看结果�?/p>

��结

本系列到此算是告一�D�落啦。以后呢�Q�自然是希望Fastsocket��快发布寚w��q�接的支持，�q�有更高性能的提升咯 :))

nieyong 2015-02-05 15:21 发表评论

Fastsocket学习(f��n)�W�记之内核篇

nieyong — Wed, 04 Feb 2015 06:22:00 GMT

前言

前面分析Fastsocket慢慢凑成�?ji��n)几��烂文字�Q�要把一件事情坚持做下来�Q�有时味同爵蜡，但既焉��择�?ji��n)，也得��着头皮做下厅R��闲话少��_(d��)��文归正文。本文接自上��内核模块篇�Q��l�记录学�?f��n)Fastsocket内核的笔记内宏V�?/p>

Fastsocket建立在SO_REUSEPORT支持基础�?/h3>

Linux kernel 3.9包含TCP/UDP支持多进�E�、多�U�程�l�定同一个IP和端口的�Ҏ(gu��)��，�?code>SO_REUSEPORT�Q�在内核层面同时也让�U�程/�q�程之间各自独��nSOCKET�Q�避免CPU�怹�间以锁资源争�?code>accept queue的调用。在fastsocket/kernel/net/sock.h定义sock_common�l�构�Ӟ��可以看到其��n影：(x��)

unsigned char          skc_reuse:4;
unsigned char          skc_reuseport:4;

在多个socket.h文�g中（比如fastsocket/kernel/include/asm/socket.h�Q�，定义�?ji��n)SO_REUSESORT的变量��|��(x��)

#define SO_REUSEPORT     15

在fastsocket/kernel/net/core/sock.c的sock_setsockopt和sock_getsockopt函数中，都有SO_REUSEPORT的��n影：(x��)

sock_setsockopt函数中：(x��)

case SO_REUSEADDR:
  sk->sk_reuse = valbool;
  break;
case SO_REUSEPORT:
  sk->sk_reuseport = valbool;
  break;

sock_getsockopt函数体中�Q?/p>

case SO_REUSEADDR:
  v.val = sk->sk_reuse;
  break;
case SO_REUSEPORT:
  v.val = sk->sk_reuseport;
  break;

�?code>SO_REUSEPORT�Ҏ(gu��)��支持之前的事�g驱动驱动服务器资源竞争：(x��)

之后呢，可以看做是�ƈ行的�?ji��n)�?x��)

Fastsocket没有重复发明轮子�Q�在SO_REUSEPORT基础上进行进一步的优化�{��?/p>

嗯，后面准备写一个动态链接库��程序，打算让以前的没有��编�?code>SO_REUSEPORT的程序也能够在Linux kernel >= 3.9�pȝ��上��n受真正的端口重用的新�Ҏ(gu��)��的支持�?/p>

Fastsocket架构�?/h3>

下面按照其架构图所�C�内核层面从上到下一一列出�?/p>

虚拟文�g�pȝ��VFS的改�q?/h3>

因�ؓ(f��)Linux Kernel VFS的同步损耗严�?/p>

VFS�Ҏ(gu��)��件节点Inode和目录Dentry有同步需�?
但SOCKET只需要在内存?sh��)��存在即可，非严格意义上文�g�pȝ��Q�其不需要�\径，不需要�ؓ(f��)Inode和Dentry加锁
代码层面略过不必��ȝ��常规锁，但又保持�?ji��n)��够的兼容�?

提交记录�Q?/p>

a209dfc vfs: dont chain pipe/anon/socket on superblock s_inodes list
4b93688 fs: improve scalability of pseudo filesystems

对VFS的改�q�，在所提升的性能中占有超�q?0%的比例，效果非常明显�Q?/p>

Local Listen Table

对于多核多接攉��列来��_(d��)��linux原生的协议栈只能listen在一个socket上面�Q��ƈ且所有完成三�ơ握手还没来得及(qi��ng)被应用accept的套接字都会(x��)攑օ�光��带的accept队列中，accept�pȝ��调用必须串行的从队列取出�Q�当�q�发量较大时多核竞争�Q�这��成为性能瓉��Q�媄(ji��ng)响徏立连接处理速度�?/p>

Local Listen Table�Q�fastsocket为每一个CPU核克隆监听套接字�Q��ƈ保存到其本地表中�Q�CPU�怹�间不�?x��)存在accept的竞争关�p�R��下面�ؓ(f��)引用描述内容�Q?/p>

每个core有一个listen socket table。应用程序徏立连接的时候，执行�q�程�?x��)调用local_listen()函数�Q�有两个参数�Q�一个是socket FD�Q�一个是core number. new socket从原始的listen socket(global)拯��到per-core local socket table. �q�些对于应用�E�序来说都是透明的，提供�l�应用程序的socketFD是抽象过的，隐藏�?ji��n)底层的实现�?
当一个TCP SYN到达本机�Q�kernel首先去local listen table中找匚w��的listen socket�Q�如果找刎ͼ��通过�|�卡RSS传递这个socket��C��个core�Q�否则就去global listen table中找�?
定w��斚w��Q�当�q�程崩溃的话�Q�local listen socket�?x��)被关闭�Q�进入的�q�接��会(x��)被引导到global Listen socket�Q?�q�样的话�Q�别的process可以处理�q�些�q�接。由于local listen socket和global listen socket�׃�nFD�Q�所以kernel��会(x��)把新的connet通知到相应的process�?
如果应用�E�序�q�程使用accept()�pȝ��调用�Q�那么处理过�E�是首先去global listen table中查扑֒�操作�Q�因为是��L��作，没有使用锁）(j��)�Q�如果没有找刎ͼ�那么去core的local table中查找。如果找刎ͼ��p��回给应用�E�序。由于listen的时候把socket�l�定��C��(ji��n)一个core�Q�所以查扄��时候也去这个core的local table中查找�?
epoll兼容性，如果应用�E�序使用epoll_ctl()�pȝ��调用�Q�来把一个listen socket��d��到Epoll set中，那么local的listen socket和global的listen socket都被epoll监控。事件发生的时候，epoll_wait()�pȝ��调用�?x��)返回listen socket�Q�accept()�pȝ��调用��׃��(x��)处理�q�个socket。这样就保证�?ji��n)epoll实现的兼�Ҏ(gu��)��?

使用��程图概括上面所�q�ͼ�(x��)

Local Established Table

Linux内核使用一个全局的hash表以�?qi��ng)锁操作来维护establised sockets�Q�被用来跟踪�q�接的sockets�Q�。Fastsocket ��x(ch��ng)��是把全局table分散到per-Core table�Q�当一个core需要访问socket的时候，只在隶属于自��q��table中搜索，因此不需要锁操纵�Q�也不存在资源竞争。由fastsocket建立的socket本地l(f��)ocal established table中，其他的regular sockets保存在global的table中。core首先去自��q��local table中查找（不需要锁�Q�，然后去global中查找�?/p>

Receive Flow Deliver

默认情况下，应用�E�序��d��发包的时候，发出�ȝ��包是通过正在执行本进�E�的那个CPU 核（�pȝ��分配的）(j��)来完成的�Q�而接收数据包的时CPU 核是由前面提到的RSS或RPS来传递。这样一来，�q�接可能�׃��同的两个CPU核来完成。连接应该在本地化处理。RFS和Intel�|�卡的FlowDirector可以从��Y件和��g上缓解这�U�情况，但是不完备�?/p>

RFD�Q�Receive Flow Deliver�Q�主要的思想是CPU核数��d��发�v�q�接的时候可以把CPU core的标识和�q�接的source port�~�码��C��赗��CPU cores和ports的关�pȝ��一个关�p�集合来军_��【cores�Q�ports】，对于一个port�Q�有唯一的一个core与之对应。当一个core来徏立connection的时候，RFD随机选择一个跟当前core匚w��的port。接收包的时候，RFD负责军_��q�个包应该让哪一个core来处理，如果当前core不是被选中的cpu core�Q�那么就deliver到选中的cpu core�?/p>

一般来��_(d��)��RFD对代理程序收益比较大�Q�单�U�的WEB服务器可以选择��用�?/p>

��结

以上参考了(ji��n)大量的外部资料进行整理而成�Q�进而可以获得一个较为整体的Fastsocket内核架构印象�?/p>

Fastsocket的努力，在单个TCP�q�接的管理从�|�卡触发的硬中断、��Y中断、三�ơ握手、数据传输、四�ơ挥手等完整的过�E�在完整在一个CPU�怸��q�行处理�Q�从而实��C��(ji��n)每一个CPU核心(j��)TCP资源本地化，�q�样为多核水�q�x(ch��ng)��展打好了(ji��n)基础�Q�减��全局资源竞争�Q��^行化处理�q�接�Q�同旉��低文仉��的副作用�Q�做��C��(ji��n)极�ؓ(f��)高效的短�q�接处理�Ҏ(gu��)��Q�不得不赞啊�?/p>

引用资料�Q?/h3>

Fastsocket PPT
FastSocket

nieyong 2015-02-04 14:22 发表评论

Fastsocket学习(f��n)�W�记之模块篇

nieyong — Tue, 03 Feb 2015 05:26:00 GMT

前言

本篇学习(f��n)Fastsocket内核模块fastsocket.so�Q�作为用��h�?code>libfsocket.so的内核态的支持�Q�处�?code>ioctl传递到/dev/fastsocket的数据，非常核心(j��)和基��。嗯�Q�还是先��译�Q�随后挟带些点评�q�来�?/p>

模块介绍

Fastsocket内核模块 (fastsocket.ko) 提供若干�Ҏ(gu��)��，�q�各自具有开启和关闭�{�丰富选项可配�|��?/p>

VFS 优化

CentOS 6.5带来的内栔R��竞争处处可见�Q�导致无论如何优化TCP/IP�|�络堆栈都不能够带来很好的性能扩展。比较严重锁竞争例子�Q?code>inode_lock�?code>dcache_lock�Q�针对套接字文�g�pȝ��sockfs而言�Q��ƈ不是必须。fastsocket通过在VFS初始化结构时提供fastpath快速�\径用以解��x(ch��ng)��w��题，已经向代号�ؓ(f��)香草�Q�vanilla�Q�的内核提交�?ji��n)两处修改�?x��)

a209dfc vfs: dont chain pipe/anon/socket on superblock s_inodes list
4b93688 fs: improve scalability of pseudo filesystems

此项修改没有提供选项可供配置�Q�因此所有fastsocket创徏的套接字sockets都会(x��)强制�l�由fastpath传输�?/p>

内核模块参数

enable_listen_spawn

fastsocket为每个CPU创徏�?ji��n)一个本地socket监听表（local listen table�Q�，应用�E�序可以军_��在一个特定CPU内核上处理某个新的连接，具体��是通过拯��原始监听套接字socket�Q�然后插入到本地套接字socket监听表中。当新徏�q�接在某CPU处理�Ӟ��pȝ��内核��试匚w��本地socket监听表，匚w��成功�?x��)插入到本地accept队列中。稍后，CPU�?x��)从本地accept队列中获取进行处理�?/p>

�q�种方式每一个网�l��Y中断都会(x��)有隶属于自己本地套接字队列当新的�q�接�q�来时可以压入，每一个进�E�从本地队列中弹�?gu��)��接进行处理。当�q�程和CPU�q�行�l�定�Q�一旦有�|�卡接口军_��投递到某个CPU内核上，那么包括��中断、��Y中断、系�l�调用以�?qi��ng)用戯��E�，都会(x��)有这个CPU全程负责。好处就是客��L(f��ng)��h��q�接在没有锁的竞争环境下分散到各个CPU上被动处理本地连接�?/p>

本特性更适合以下情况�Q?/p>

��可能多的网卡Rx接收队列和CPU核数
应用�E�序工作�q�程被静(r��n)态绑定到每一个CPU�?

�W�一�U�情况下�Q�RPS可以在网卡接攉��列小于CPU核数时被使用。第二种�Ҏ(gu��)��可以满��两个斚w��Q?/p>

应用�E�序在启动时自己�l�定工作�q�程和CPU亲和�?
允许fastsocket自动为工作进�E�绑定CPU亲和�?

因此�Q?code>enable_listen_spawn��h��三个值可供配�|�：(x��)

enable_listen_spawn=0: ��d��止
enable_listen_spawn=1: 启用�Q�但要求应用�E�序自己�l�定CPU
enable_listen_spawn=2 (默认�?: 启用此特性，允许fastsocket为每一个工作进�E�绑定到CPU�?

enable_fast_epoll

一旦开启，需要�ؓ(f��)文�g�l�构额外��d��一字段用以保存文�g与epitem的映��关�p�，�q�样可省��d��epoll_ctl�Ҏ(gu��)��被调用时从epoll�U�黑�?w��i)查找epitem的开销�?/p>

虽然此项优化有所修改epoll语义�Q�但带来�?ji��n)套接字性能提升。开启的前提是一个套接字只允许添加到一个epoll实例中，但不包括监听套接字。默认��gؓ(f��)true可以适用于绝大多数应用程序，若你的程序不满��条�g��得需要禁用了(ji��n)�?/p>

enable_fast_epoll 为布?y��u)��(d��ng)型boolean选项:

enable_fast_epoll=0: ��用fast-epoll
enable_fast_epoll=1 (默认�?: 开启fast-epoll

enable_receive_flow_deliver

RFD�Q�Receive Flow Deliver�Q�会(x��)把�ؓ(f��)新徏�q�接分配的CPU ID��装到其�q�接的端口号中，而不是随机选择新创建的��d��q�接的源端口�q�行分配到CPU上�?/p>

当应用从�z�d��q�接收到数据包RFD解码�Ӟ��?x��)从目的地端口上解析出对应的CPU内核ID�Q��而�{发给对应的CPU内核。再加上listen_spawn�Q�保证了(ji��n)一个连接CPU处理的完全本地化�?/p>

enable_receive_flow是一个布?y��u)��(d��ng)型选项:

enable_receive_flow=0 (默认�?: ��用RFD
enable_receive_flow=1: 启用RFD

注意事项�Q?/p>

当启用时�Q�在当前的实玎ͼ�RFD完全覆盖RPS�{�略�Q��ƈ使得RPS无效。若使用RPS�Q�请��用此特�?
�׃��RFD只会(x��)对诸如代理应用程序有利，我们��在Web服务器上��用此特�?

以上�Q�翻译完毕�?/em>

源码��单梳�?/h3>
fastsocket的内核模块相对�\径�ؓ(f��)fastsocket/module/�Q�除�?ji��n)README.md外，��是两个软连接文件了(ji��n)�Q?/p>

fastsocket.c ../kernel/net/fastsocket/fastsocket.c 真实环境下不存在�q�个文�g�Q�可能是�E�序BUG
fastsocket.h ../kernel/net/fastsocket/fastsocket.h 有对应头文�g存在

换种说法�Q�fastsocket内核模块真正路径�?code>fastsocket/kernel/net/fastsocket�Q�具体文件列表�ؓ(f��)�Q?/p>

Kconfig
Makefile
fastsocket.h 定义内核模块所使用到变量和�Ҏ(gu��)��
fastsocket_core.c 负责�Ҏ(gu��)��实现�Q�供fastsocket_api.c调用
fastsocket_api.c 内核模块加蝲/卸蝲�{�操作，处理前端动态链接库�l�由ioctl传递的数据

fastsocket_api.c实现内核模块接口�Q�在源码里面注册�?ji��n)好多文档暂时没有公开的可配置��目�Q?/p>
int enable_fastsocket_debug = 3; /* Fastsocket feature switches */ int enable_listen_spawn = 2; int enable_receive_flow_deliver; int enable_fast_epoll = 1; int enable_skb_pool; int enable_rps_framework; int enable_receive_cpu_selection = 0; int enable_direct_tcp = 0; int enable_socket_pool_size = 0; module_param(enable_fastsocket_debug,int, 0); module_param(enable_listen_spawn, int, 0); module_param(enable_receive_flow_deliver, int, 0); module_param(enable_fast_epoll, int, 0); module_param(enable_direct_tcp, int, 0); module_param(enable_skb_pool, int, 0); module_param(enable_receive_cpu_selection, int, 0); module_param(enable_socket_pool_size, int, 0); MODULE_PARM_DESC(enable_fastsocket_debug, " Debug level [Default: 3]" ); MODULE_PARM_DESC(enable_listen_spawn, " Control Listen-Spawn: 0 = Disabled, 1 = Process affinity required, 2 = Autoset process affinity[Default]"); MODULE_PARM_DESC(enable_receive_flow_deliver, " Control Receive-Flow-Deliver: 0 = Disabled[Default], 1 = Enabled"); MODULE_PARM_DESC(enable_fast_epoll, " Control Fast-Epoll: 0 = Disabled, 1 = Enabled[Default]"); MODULE_PARM_DESC(enable_direct_tcp, " Control Direct-TCP: 0 = Disbale[Default], 1 = Enabled"); MODULE_PARM_DESC(enable_skb_pool, " Control Skb-Pool: 0 = Disbale[Default], 1 = Receive skb pool, 2 = Send skb pool, 3 = Both skb pool"); MODULE_PARM_DESC(enable_receive_cpu_selection, " Control RCS: 0 = Disabled[Default], 1 = Enabled"); MODULE_PARM_DESC(enable_socket_pool_size, "Control socket pool size: 0 = Disabled[Default], other are the pool size");

接收用户态的libfsocket.so通过ioctl传递过来的数据�Q�根据命令进行数据分发：(x��)
static long fastsocket_ioctl(struct file *filp, unsigned int cmd, unsigned long __user u_arg) { struct fsocket_ioctl_arg k_arg; if (copy_from_user(&k_arg, (struct fsocket_ioctl_arg *)u_arg, sizeof(k_arg))) { EPRINTK_LIMIT(ERR, "copy ioctl parameter from user space to kernel failed\n"); return -EFAULT; } switch (cmd) { case FSOCKET_IOC_SOCKET: return fastsocket_socket(&k_arg); case FSOCKET_IOC_LISTEN: return fastsocket_listen(&k_arg); case FSOCKET_IOC_SPAWN_LISTEN: return fastsocket_spawn_listen(&k_arg); case FSOCKET_IOC_ACCEPT: return fastsocket_accept(&k_arg); case FSOCKET_IOC_CLOSE: return fastsocket_close(&k_arg); case FSOCKET_IOC_SHUTDOWN_LISTEN: return fastsocket_shutdown_listen(&k_arg); //case FSOCKET_IOC_EPOLL_CTL: // return fastsocket_epoll_ctl((struct fsocket_ioctl_arg *)arg); default: EPRINTK_LIMIT(ERR, "ioctl [%d] operation not support\n", cmd); break; } return -EINVAL; }

fastsocket/library/libsocket.h头文件定义的FSOCKET_IOC_* 操作状态码��p��够一一对应的上�?ioctl传输数据从用��h�?>内核态，需要经�q�一�ơ拷贝过�E�（copy_from_user�Q�，然后�Ҏ(gu��)��cmd命��o(h��)�q�行功能路由�?/p>
libfsocket.so如何与fastsocket内核模块交互

通过指定的设备通道/dev/fastsocket�q�行交互�Q?/p>

fastsocket内核模块注册要监听的通道讑֤�名称�?code>/dev/fastsocket
libfsocket打开/dev/fastsocket讑֤�获得文�g句柄�Q�开�?code>ioctl数据传�?

��结

��单梳理了(ji��n)fastsocket内核模块�Q�但一��h��很多的点没有涉及(qi��ng)�Q�后面可能会(x��)在Fastsocket内核��中再次梳理一下�?/p>

nieyong 2015-02-03 13:26 发表评论

nieyong — Mon, 02 Feb 2015 06:16:00 GMT

前言

本篇为fastsocket的动态链接库学习(f��n)�W�记�Q�对应源码目录�ؓ(f��) fastsocket/library�Q�先��译README.md文�g内容�Q�后面添加上个�h学习(f��n)�?j��)得�?/p>
介绍

动态链接库libfsocket.so�Q��ؓ(f��)已有应用�E�序提供加速服务，��h��可维护性和兼容性�?/p>

可维护�?/strong>�Q�Fastsocket优化在于重新实现套接字的�pȝ��调用从而达到Linux内核�|�络堆栈效率的提高。而应用程序是不用修改�q�些�pȝ��调用�Q�借助于Fastsocket��可以达到加速的目的。Fastsocket在内核模块提供了(ji��n)一个新的ioctl接口�Q�供上层应用�E�序调用�?
兼容�?/strong>�Q�若让应用程序必��M��改其代码以适应新的�pȝ��调用接口�Q�在现实世界中这很麻�?ch��)也不可行。借助于libfsocket拦截�pȝ��调用�q�提供新的接口进行替换系�l�调用，同时Fastsocket提供�?ji��n)与BSD socket完全兼容的调用接口，�q��得应用程序在无需更改��M��代码的情况下�Q�可直接使用Fastsocket�Q�获得网�l�加速的效果�?

�~�译

很简单，�q�入目录之后�Q�执�?code>make命��o(h��)�~�译卛_��Q?/p>
cd fastsocket/library make

最后在当前目录下生�?code>libfsocket.so文�g�?/p>
用法

很简单的��_(d��)��借助�?code>LD_PRELOAD加蝲libfsocket.so�Q�启动应用程序，以nginx��Z��Q?/p>
LD_PRELOAD=/your_path/fastsocket/library/libfsocket.so nginx

若回滚，��q��单了(ji��n)�Q�直接启动nginx��p��Q?/p>
nginx

注意事项�Q?/p>

��保fastsocket.ko内核模块已经加蝲成功
只对启动时以预加�?code>libfsocket.so的上层应用程序有效果

内部构�g

Fastsocket拦截�|�络套接字的常规�pȝ��调用�Q��ƈ使用ioctl接口取代之�?/p>
若不依赖�?code>libfsocket.so�Q�上层应用程序要想��用Fastsocket Percore-Listen-Table的特点，应用�E�序需要在父流�E�forking之后�Q�以�?qi��ng)提前做事�g循环�Q�event loop�Q�处理，应用工作�q�程需要手动调�?code>listen_spawn函数�Q�复制全局的监听套接字�q�插入到本地监听表中�?/p>
libfsocket.so��Z��层应用程序做�?code>listien_spawn的工作，用以保持应用�E�序的代码不变，�Ҏ(gu��)��如下:

libfsocket.so跟踪所有需要监听的套接字文件句�?
libfsocket.so拦截�?code>epoll_ctl�pȝ��调用
当监听到应用�E�序调用epoll_ctl��d��监听套接字文件句柄到epoll�Ӟ��libfsocket.so�?x��)调�?code>listen_spawn�Ҏ(gu��)��

不是所有应用程序都适合本方案，但nginx、haproxy、lighttpd与之配合��工作得相当不错。因此当你在其他应用�E�序中想使用Percore-Listen-Table�Ҏ(gu��)��时�Q�请务必��心(j��)��试�?ji��n)，��保是否合适�?/p>
OK�Q�翻译完毕�?/em>

源码一�?/h3>
fastsocket/library用于构徏libfsocket.so动态链接库�Q�主要组成：(x��)

Makefile �~�译脚本
libsocket.h 头文�Ӟ��定义变量、结构等
libsocket.c 动态链接库实现

libsocket.h

定义�?code>ioctl�Q��ؓ(f��)Input/Output ConTroL�~�写�Q�函数和伪设�?/dev/fastsocket)交换数据所使用到的几个命��o(h��)�Q?/p>
#define IOC_ID 0xf5 #define FSOCKET_IOC_SOCKET _IO(IOC_ID, 0x01) #define FSOCKET_IOC_LISTEN _IO(IOC_ID, 0x02) #define FSOCKET_IOC_ACCEPT _IO(IOC_ID, 0x03) #define FSOCKET_IOC_CLOSE _IO(IOC_ID, 0x04) //#define FSOCKET_IOC_EPOLL_CTL _IO(IOC_ID, 0x05) #define FSOCKET_IOC_SPAWN_LISTEN _IO(IOC_ID, 0x06) #define FSOCKET_IOC_SHUTDOWN_LISTEN _IO(IOC_ID, 0x07)

紧接着定义�?ji��n)需要在用户态和内核态通过ioctl�q�行交互的结构：(x��)
struct fsocket_ioctl_arg { u32 fd; u32 backlog; union ops_arg { struct socket_accept_op_t { void *sockaddr; int *sockaddr_len; int flags; }accept_op; struct spawn_op_t { int cpu; }spawn_op; struct io_op_t { char *buf; u32 buf_len; }io_op; struct socket_op_t { u32 family; u32 type; u32 protocol; }socket_op; struct shutdown_op_t { int how; }shutdown_op; struct epoll_op_t { u32 epoll_fd; u32 size; u32 ep_ctl_cmd; u32 time_out; struct epoll_event *ev; }epoll_op; }op; };

�q�样看来�Q?code>ioctl函数原型调用为：(x��)
ioctl(/dev/fastsocket讑֤�文�g句柄�Q?FSOCKET_IOC_具体宏命令， fsocket_ioctl_arg�l�构指针)

现在大致能够弄清楚了(ji��n)内核态和用户态之间通过ioctl传递结构化的数据的方式�?ji��n)�?/p>
libsocket.c ��要分�?/h3>
�q�接内核模块已经注册好的讑֤��道/dev/fastsocket�Q�获取到文�g描述�W�，同时做些CPU�q�程�l�定的工�?/p>
#define INIT_FDSET_NUM 65536 ...... __attribute__((constructor)) void fastsocket_init(void) { int ret = 0; int i; cpu_set_t cmask; ret = open("/dev/fastsocket", O_RDONLY); // 建立fastsocket通道 if (ret < 0) { FSOCKET_ERR("Open fastsocket channel failed, please CHECK\n"); /* Just exit for safty*/ exit(-1); } fsocket_channel_fd = ret; fsocket_fd_set = calloc(INIT_FDSET_NUM, sizeof(int)); if (!fsocket_fd_set) { FSOCKET_ERR("Allocate memory for listen fd set failed\n"); exit(-1); } fsocket_fd_num = INIT_FDSET_NUM; // ��gؓ(f��)65535 CPU_ZERO(&cmask); for (i = 0; i < get_cpus(); i++) CPU_SET(i, &cmask); ret = sched_setaffinity(0, get_cpus(), &cmask); if (ret < 0) { FSOCKET_ERR("Clear process CPU affinity failed\n"); exit(-1); } return; }

主观上，仅仅是�ؓ(f��)�?ji��n)短�q�接而设�|�的�Q�定义的fastsocket文�g句柄数组大小�?5535�Q�针对类��g��WEB Server、HTTP API�{�环境��够了(ji��n)�Q�针对百万��别的长连接服务器环境?y��u)�׃��适合�?ji��n)�?/p>
socket/listen/accept/close/shutdown/epoll_ctl�{�函敎ͼ�通过dlsym方式替换已有套接字系�l�函数等�Q�具体的交互�q�程使用ioctl替代一些系�l�调用�?/p>
除了(ji��n)重写socket/listen/accept/close/shutdown�{�套接字接口�Q�同时也�?code>epoll_ctl�Ҏ(gu��)��动了(ji��n)手术�Q�江湖传�a�CPU多核多进�E�的epoll服务器存在惊��现象）(j��)�Q�更好利用多核：(x��)
int epoll_ctl(int efd, int cmd, int fd, struct epoll_event *ev) { static int (*real_epoll_ctl)(int, int, int, struct epoll_event *) = NULL; int ret; struct fsocket_ioctl_arg arg; if (fsocket_channel_fd >= 0) { arg.fd = fd; arg.op.spawn_op.cpu = -1; /* "Automatically" do the spawn */ if (fsocket_fd_set[fd] && cmd == EPOLL_CTL_ADD) { ret = ioctl(fsocket_channel_fd, FSOCKET_IOC_SPAWN_LISTEN, &arg); if (ret < 0) { FSOCKET_ERR("FSOCKET: spawn failed!\n"); } } } if (!real_epoll_ctl) real_epoll_ctl = dlsym(RTLD_NEXT, "epoll_ctl"); ret = real_epoll_ctl(efd, cmd, fd, ev); return ret; }

因�ؓ(f��)定义�?ji��n)作用于内部的�?r��n)态变�?code>real_epoll_ctl�Q�只有在�W�一�ơ加载的时候才�?x��)被赋��|��real_epoll_ctl = dlsym(RTLD_NEXT, "epoll_ctl")�Q�后面调用时通过ioctl把fsocket_ioctl_arg传递到内核模块中去�?/p>
其它socket/listen/accept/close/shutdown�{�套接字接口�Q�流�E�类伹{�?/p>
��结

以上��单翻译、粗略分析用��h��fastsocket动态链接库大致情况�Q�若要�v作用�Q�需要和内核态Fastsocket�q�行交互、传递数据才能够作用的很好�?/p>

nieyong 2015-02-02 14:16 发表评论

Fastsocket学习(f��n)�W�记之网卡设�|�篇

nieyong — Fri, 30 Jan 2015 08:49:00 GMT

前言

前面�~�译安装好了(ji��n)包含有fastsocket的内核模块，以及(qi��ng)fastsocket的动态链接库libfsocket.so�Q�下面其实就可以讄��|�卡�?ji��n)�?/p>
下面��Z��些名词解释，上下文中需要��用到�Q?/p>

Rx�Q�接攉��?
Tx�Q�发送队�?

本文�|�卡讄��W�记内容�Q�大部分来自于fastsocket源码相对路径fastsocket/scripts/�Q�老规矩，先翻译�?/p>
�|�卡讄��翻译原�?/h3>
介绍

nic.sh脚本负责�|�卡配置以尽可能的最大化受益于fastsocket带来的问题。给定一个网卡接口，它调整接口的各种�Ҏ(gu��)��以�?qi��ng)一些系�l�配�|��?/p>
相关配置

中断和CPU的亲和�?/h5>
每个�|�卡��g队列�?qi��ng)其兌��中断�l�定��C��同的CPU核心(j��)。若��g队列数大于CPU核数�Q�队列需要配�|�成循环round-robin方式�Q?Irqbalance服务需要被��用以防其更攚w��|��?/p>
中断阀速率

nic.sh脚本通过ethtool命��o(h��)讄��每秒中断��C��限，防止中断风暴。两个Rx中断间隔讄��成至��?33us�Q�约3000个中断每�U��?/p>
RPS

为每个CPU核心(j��)与不同的�|�卡��g队列之间建立一一映射对应关系�Q�这样CPU核心(j��)?y��u)��可以很均匀地处理网�l�数据包。当�|�卡��g队列��于CPU内核敎ͼ�nic.sh脚本利用RPS (Receive Packet Steering)软�g方式�q��q�入��量负蝲�Q�这样CPU和硬仉��列不存在对应关系。RPS机制可以让进入的数据包自由分发到��M��CPU�怸��?/p>
�|�卡接收产生的中断可以均衡分配到对应CPU上�?/p>
XPS

XPS (Transmit Packet Steering) 建立CPU内核和Tx发送队列映��对应关�p�，掌控出站数据包。系�l�有N个CPU核心(j��)�Q�脚本会(x��)讄��XPS臛_��存在N个Tx队列在网卡接口上�Q�这样就可以建立CPU内核和Tx队列1�?的映��关�p�R�?/p>
�|�卡传送数据��生的中断一样可以均很分配到CPU上，避免单个CPU核心(j��)�q�于�J�忙�?/p>
IPTABLES

压测�Ӟ��防火墙iptables的规则会(x��)占用更多的CPU周期�Q�有所降低�|�络堆栈性能。因�?code>nic.sh脚本若检��到iptables后台�q�行中会(x��)直接输出报警信息�Q�提�C�关闭之�?/p>
nic.sh脚本脚本分析

�l�过验证好用的Intel和博通系列千兆和万兆�|�卡列表�Q?/p>
# igb "Intel Corporation 82576 Gigabit Network Connection (rev 01)" "Intel Corporation I350 Gigabit Network Connection (rev 01)" # ixgbe "Intel Corporation 82599EB 10-Gigabit SFI/SFP+ Network Connection (rev 01)" "Intel Corporation 82599ES 10-Gigabit SFI/SFP+ Network Connection (rev 01)" # tg3 "Broadcom Corporation NetXtreme BCM5720 Gigabit Ethernet PCIe" "Broadcom Corporation NetXtreme BCM5761 Gigabit Ethernet PCIe (rev 10)" # bnx2 "Broadcom Corporation NetXtreme II BCM5708 Gigabit Ethernet (rev 12)" "Broadcom Corporation NetXtreme II BCM5709 Gigabit Ethernet (rev 20)"

若当前服务器没有以上�|�卡�Q�会(x��)警告一下，无碍�?/p>
�q�里把一些常规性的CPU、网卡驱动、网�l�队列情冉|��查单独抽取出来，重温好多已经遗忘的命令，有改变，�q�样写较��单嘛�Q�便于以后��用：(x��)

直接查看CPU核数�Q?code>grep -c processor /proc/cpuinfo
查看�|�卡软接攉��列数�Q?code>ls /sys/class/net/eth0/queues | grep -c rx
查看�|�卡软发生队列数�Q?code>ls /sys/class/net/eth0/queues | grep -c tx
查看当前�|�卡��g队列敎ͼ�(x��)egrep -c eth0 /proc/interrupts
查看�|�卡名称和版本号�Q?code>lspci | grep Ethernet | sed "s/Ethernet controller: //g"
查看�|�卡驱动名称�Q?code>ethtool -i eth0 | grep driver

脚本先是获取CPU、网卡等信息�Q�接着讄��中断单位�U�内吞吐量：(x��) ethtool -C eth0 rx-usecs 333 > /dev/null 2>&1

启用XPS�Q�充分借助�|�卡发送队列，提升�|�卡发送吞吐量�Q�是有条仉��制的�Q�发送队列数要大于CPU核数�Q?/p>
if [[ $TX_QUEUES -ge $CORES ]]; then for i in $(seq 0 $((CORES-1))); do cpuid_to_mask $((i%CORES)) | xargs -i echo {} > /sys/class/net/$IFACE/queues/tx-$i/xps_cpus done info_msg " XPS enabled" fi

接着判断是否可以启用PRS�Q�省��L��动设�|�的�ȝ��(ch��)�Q�但启用RPS前提是CPU核数与网卡硬仉��列不相等�Q?/p>
if [[ ! $HW_QUEUES == $CORES ]]; then for i in /sys/class/net/$IFACE/queues/rx-*; do printf "%x\n" $((2**CORES-1)) | xargs -i echo {} > $i/rps_cpus; done info_msg " RPS enabled" else for i in /sys/class/net/$IFACE/queues/rx-*; do echo 0 > $i/rps_cpus; done info_msg " RPS disabled" fi

若没有��用fastsocket�Q�单�U�借助于RPS�Q�会(x��)带来处理中断的CPU和处理当前数据包的CPU不是同一个，自然�?x��)造成CPU Cache Miss�Q�CPU�~�存?sh��)��失�Q�，造成��许的性能影响�Q��ؓ(f��)�?ji��n)避免这�U�情况，��Z��?x��)依赖于RFS�Q�Receive Flow Steering�Q��?/p>

使用�?ji��n)fastsocket后，��׃��用这么麻�?ch��)�?ji��n)�?/p>
irqbalance和fastsocket有冲�H�，�?x��)强制禁用�?x��)
if ps aux | grep irqbalance | grep -v grep; then info_msg "Disable irqbalance..." # XXX Do we have a more moderate way to do this? killall irqbalance > /dev/null 2>&1 fi

脚本也包含了(ji��n)讄��中断和CPU的亲和性：(x��)
i=0 intr_list $IFACE $DRIVER | while read irq; do cpuid_to_mask $((i%CORES)) | xargs -i echo {} > /proc/irq/$irq/smp_affinity i=$((i+1)) done

若iptables服务存在�Q�会(x��)友善��用�?x��)好一些，毕竟�?x��)带来性能损耗。文件打开句柄不大�?024�Q�脚本同样会(x��)提醒�Q�怎么讄��文�g打开句柄�Q�可以参考以前博文�?/p>
Linux�pȝ��|�络堆栈的常规扩展优化措�?/h3>
针对不��用fastsocket的服务器�Q�当前比较流行的针对�|�卡的网�l�堆栈性能扩展、优化措施，一般会(x��)使用到RSS、RPS、RFS、XFS�{�方式，以便充分利用CPU多核和硬件网卡等自��n性能�Q�达到�ƈ�?�q�发处理的目的。下面�ȝ��一个表��|��可以凑合看一下�?/p>

RSS
(Receive Side Scaling) RPS
(Receive Packet Steering) RFS
(Receive Flow Steering) Accelerated RFS
(Accelerated Receive Flow Steering) XPS
(Transmit Packet Steering)

解决问题 �|�卡和驱动支�?/td> 软�g方式实现RSS 数据包��生的中断和应用处理在同一个CPU�?/td> ��Z��RFS��g加速的负蝲�q��机制 ��选择�|�卡多队列的队列快速发�?/td>

内核支持 2.6.36开始引入，需要硬件支�?/td> 2.6.35 2.6.35 2.6.35 2.6.38

�� |�卡队列数和物理核数一�?/td> ��x(ch��ng)��多队列的�|�卡若RSS已经配置�?ji��n)，则不需要RPS�?/td> 需要rps_sock_flow_entries和rps_flow_cnt属�?/td> 需要网卡设备和驱动都支持加速。�ƈ且要求ntuple�q��o(h��)已经通过ethtool启用单传输队列的�|�卡无效�Q�若队列比CPU��，�׃�n指定队列的CPU最好是与处理传输硬中断的CPU�׃�n�~�存的CPU

fastsocket �|�卡�Ҏ(gu��)�?/td> 改进版RPS�Q�性能提升源码包含�Q�文档没有涉�?/td> 文档没有涉及(qi��ng) 要求发送队列数要大于CPU核数

传送方�?/td> �|�卡接收内核接收 CPU接收处理加速�ƈ接收 �|�卡发送数�?/td>

更具体优化措施，可以参考文档：(x��)Scaling in the Linux Networking Stack�?/p>
另，若网卡支�?code>Flow Director Filters�Ҏ(gu��)��（�q�里有一个非常有��的动画介绍�Q?a >Intel® Ethernet Flow Director�Q�值得一看）(j��)�Q�那么可以结合F(tu��n)astsocket一起加速。比如，在其所作Redis长连接测试中�Q�启用Flow-Director�Ҏ(gu��)��要比禁用可以带�?5%的性能提升�?/p>
自然软硬�l�合�Q�可以做的更好一些嘛�?/p>
延��阅读�Q?a >多队列网卡简�?/a>

��结

以上记录�?ji��n)学习(f��n)fastsocket的网卡设�|�脚本方面笔记�?/p>
不过呢，nic.sh脚本�Q�值得收藏�Q�无��Z��不��用fastsocket�Q�对�U�上服务器网卡调优都是不错选择哦�?/p>

nieyong 2015-01-30 16:49 发表评论

Fastsocket学习(f��n)�W�记之安装篇

nieyong — Fri, 30 Jan 2015 05:14:00 GMT

前言

�q�行环境为Centos 6.5�pȝ��Q�默认内��ؓ(f��)2.6.32-431.el6.x86_64�Q�下面所有编译安装操作是�?code>root用户权限�q�行操作�?/p>
�~�译安装f(xi��)astsocket内核

�W�一步需要下载代码，当然�q�是废话�?ji��n)，下蝲�?opt目录下：(x��)
git clone https://github.com/fastos/fastsocket.git

�~�译安装

下蝲之后�Q�需要进入其目录中：(x��)
cd fastsocket/kernel

因�ؓ(f��)是涉�?qi��ng)到内核嘛，�~�译之前需要做一些参数选项配置�Q��?code>make config�?x��)篏��M�h的，好几千个选项参数需要你一一配置�Q�大部分旉��Q�默认配�|�就挺好的：(x��)
make defconfig

然后嘛，�~�译内核的节奏：(x��)
make

内核�~�译相当耗费旉��Q�至��?0分钟旉��。之后紧接着是编译所需的内核模块，fastsocket模块�Q?/p>
make modules_install

�~�译完成之后�Q�最后一条输出，�?x��)看刎ͼ?x��)

DEPMOD 2.6.32-431.17.1.el6.FASTSOCKET

fastsocket内核模块�~�译好之后，需要安装内核：(x��)
make install

上面命��o(h��)其实执行shell脚本�q�行安装�Q?/p>

sh /opt/fastsocket/kernel/arch/x86/boot/install.sh 2.6.32-431.17.1.el6.FASTSOCKET arch/x86/boot/bzImage \ System.map "/boot"

基本上，fastsocket内核模块已经构徏安装完毕�?ji��n)，但需要告知Linux�pȝ��在下�ơ启动的时候切换到新编译的、包含有fastsocket模块的内核�?/p>
配置启动旉��要切换的内核

�q�部分需要在/etc/grup.conf中配�|�，现在看一下其文�g内容�Q?/p>
default=1 timeout=5 splashimage=(hd0,0)/grub/splash.xpm.gz hiddenmenu title CentOS (2.6.32-431.17.1.el6.FASTSOCKET) root (hd0,0) kernel /vmlinuz-2.6.32-431.17.1.el6.FASTSOCKET ro root=/dev/mapper/vg_centos6-lv_root rd_NO_LUKS rd_NO_MD rd_LVM_LV=vg_centos6/lv_swap crashkernel=auto LANG=zh_CN.UTF-8 rd_LVM_LV=vg_centos6/lv_root KEYBOARDTYPE=pc KEYTABLE=us rd_NO_DM rhgb quiet initrd /initramfs-2.6.32-431.17.1.el6.FASTSOCKET.img title CentOS (2.6.32-431.el6.x86_64) root (hd0,0) kernel /vmlinuz-2.6.32-431.el6.x86_64 ro root=/dev/mapper/vg_centos6-lv_root rd_NO_LUKS rd_NO_MD rd_LVM_LV=vg_centos6/lv_swap crashkernel=auto LANG=zh_CN.UTF-8 rd_LVM_LV=vg_centos6/lv_root KEYBOARDTYPE=pc KEYTABLE=us rd_NO_DM rhgb quiet initrd /initramfs-2.6.32-431.el6.x86_64.img

defautl=1�Q�表�C�目前系�l�选择的以原先内核作作为启动项�Q�原先位于第二个root (hd0,0)后面�Q�需要切换到新的内核下面�Q�需要修�?code>default=0�Q�保存后�Q�reboot重启�pȝ��Q��之生效�?/p>
��(g��)��生�?/h4>
�pȝ��重启后，需要加载fastsocket模块到系�l�运行中去，下面以默认选项参数方式加蝲�Q?/p>
modprobe fastsocket

加蝲之后�Q�列出当前系�l�所加蝲模块列表�Q�检查是否成�?/p>
lsmod | grep fastsocket

若能看到�c�M��输出信息�Q�表�C�OK�Q?/p>

fastsocket 39766 0

开始构建libfastsocket.so链接库文�?/h3>
上面内核模块安装好之后，可以构徏fastsocket的动态链接库文�g�?ji��n)�?x��)
cd /opt/fastsocket/library/ make

可能�?x��)收��C��些警告信息，无碍�Q?/p>
gcc -g -shared -ldl -fPIC libsocket.c -o libfsocket.so -Wall libsocket.c: 在函�?#8216;fastsocket_init’�? libsocket.c:59: 警告�Q�隐式声明函�?#8216;open’ libsocket.c: 在函�?#8216;fastsocket_expand_fdset’�? libsocket.c:109: 警告�Q�隐式声明函�?#8216;ioctl’ libsocket.c: 在函�?#8216;accept’�? libsocket.c:186: 警告�Q�对指针赋值时目标与指针符号不一�? libsocket.c: 在函�?#8216;accept4’�? libsocket.c:214: 警告�Q�对指针赋值时目标与指针符号不一�?

最后，可以看到gcc�~�译之后生成�?code>libfsocket.so库文�Ӟ��说明�~�译成功�?/p>
��结

OK�Q�编译安装到此结束，后面��是如何使用fastsocket的示范程序进行测试了(ji��n)�?/p>

nieyong 2015-01-30 13:14 发表评论

Fastsocket学习(f��n)�W�记之示范应用篇

nieyong — Thu, 29 Jan 2015 09:16:00 GMT

前言

上篇介绍�?ji��n)如何构建安装f(xi��)astsocket内核模块�Q�下面将��Z��fastsocket/demo/README.md文�g��译整理而成�?/p>
嗯，下面�q�入��译��?/p>
介绍

�C��Z��个简单TCP Server服务器程序，用于基准��试和剖析Liunx内核�|�络堆栈性能表现�Q�当然也是�ؓ(f��)�?ji��n)演�C�Fastsocket可扩展和其性能改进�?/p>
�C��应用��Z��epoll模型和非��d��性IO�Q�处理网�l�连接，但只有在多核的模式下才能够工作得很好�Q�程序的每一个进�E�被�l�定到CPU的不同核�Q��v始于CPU core 0�Q�各自独立处理客��L(f��ng)��q�接��h��?/p>
�C��E�序��h��两种工作模式�Q?/p>

服务器模�?/strong>�Q��Q何请求都�?x��)直接返回HTTP 200 OK
代理模式�Q�服务器接收到客��L(f��ng)��h��Q��{发给后端服务器，同时转发后端响应�l�客��L(f��ng)��?

�q�是一个简单傻瓜�Ş式的Tcp Server�Q�仅仅用于测试��用，使用时要求客��L(f��ng)��和服务器端只能够携带一个packet包大��的数据�Q�否则程序会(x��)处理不了(ji��n)�?/p>
构徏

以下面方式进行构建：(x��)

cd demo && make

用法

最��单方式以默认配置无参数�Ş式运行：(x��)

./server

参数如下:

-w worker_num: 定义�q�程�?

默认��gؓ(f��)当前可用CPU核心(j��)��C��q�程.

-c start_core: 指定�q�程�l�定CPU核的开始烦(ch��)引�?

默认��gؓ(f��) 0.

-o log_file: 定义日志文�g名称

默认��gؓ(f��) ./demo.log

-a listen_address: 指定监听地址�Q�[ip:port]字符串组合�Ş式，支持��d��多个地址

默认��gؓ(f��) 0.0.0.0:80

-x backend_address: 启动代理模式�Q�需要填写[ip:port]�l�合形式地址�Q�支持多个代理地址

默认不开�?

-v: 启用详细�l�计数据输出

默认为禁�?

-d: 启动Debug调试模式�Q�调试信息被写入日志文�g�?

默认��用

-k: 启用HTTP keepalive机制�Q�当前只能够工作在服务器模式�?

默认被禁�?

实例

在运行之前，需要注意两点：(x��)

��Z��(ji��n)跑满CPU�Q�需要确保客��L(f��ng)��和后端服务器都不应该成�ؓ(f��)瓉��Q�两�U�可行方案：(x��)

提供��_��多机器用以充当客��L(f��ng)��和后端服务器角色
或在一台机器上充当客户端和后端服务器，使用fastsocket�Q�推荐方案，较�ؓ(f��)节省服务器）(j��)

正确配置�|�卡�Q�若不知道如何做�Q�可以参考源码中script目录

服务器模式示�?/h4>
服务器模式至��需要两��C��机：(x��)

��L��A作�ؓ(f��)客户端��生HTTP��h��
��L��B为Web服务�?

讑֮�每台��L��CPU 12核，�|�络大概讄��如下�Q?/p>
+--------------------+ +--------------------+ | Host A | | Host B | | | | | | 10.0.0.1/24 |-----| 10.0.0.2/24 | | | | | +--------------------+ +--------------------+

下面是运行两��C��机的步骤�Q?/p>
��L��B�Q?/p>

Web服务器模式单独运行，开�?2个工作进�E�，和CPU核心(j��)��C��_(d��)��(x��)

./server -w 12 -a 10.0.0.2:80

或者测试借助于Fastsocket所带来的性能

LD_PRELOAD=../library/libfsocket.so ./server -w 12 -a 10.0.0.2:80

��L��A�Q?/p>

�q�行Apache ab�E�序作�ؓ(f��)��h��?br />ab -n 1000000 -c 100 http://10.0.0.2:80/
单个Apache ab�E�序不能够体现服务器负蝲能力�Q�多个ab实例同时�q�发�q�行可能�?x��)好很多�Q�开12个实例和CPU核心(j��)��C��_(d��)��(x��) N=12; for i in $(seq 1 $N); do ab -n 1000000 -c 100 http://10.0.0.2:80/ > /dev/null 2>&1; done

代理模式�C��

代理模式下，需要三台机器：(x��)

��L��A作�ؓ(f��)客户端��生HTTP��h��
��L��B作�ؓ(f��)代理角色
��L��C则需要后端服务器

讑֮�每台机器CPU内核�?2�Q�网�l�结构如下：(x��)
+--------------------+ +--------------------+ +--------------------+ | Host A | | Host B | | Host C | | | | | | | | 10.0.0.1/24 | | 10.0.0.2/24 | | 10.0.0.3/24 | +---------+----------+ +---------+----------+ +----------+---------+ | | | +---------+--------------------------+---------------------------+---------+ | switch | +--------------------------------------------------------------------------+

下面为具体的�q�行步骤�Q?/p>
��L��B�Q?/p>

��Z��理服务器启动12个进�E?br />./server -w 12 -a 10.0.0.2:80 -x 10.0.0.3:80
或者以Fastsocket方式启动 LD_PRELOAD=../library/libsocket.so ./server -w 12 -a 10.0.0.2:80 -x 10.0.0.3:80

��L��C�Q?/p>

理论上�Q何WEB服务器都可以充当后端服务器，�q�里充分利用�C��E�序好了(ji��n)�Q?br />./server -w 12 -a 10.0.0.3:80

��L��A�Q?/p>

作�ؓ(f��)客户端请求生成器�Q�同样启�?2个Apache ab实例�Q?br />N=12; for i in $(seq 1 $N); do ab -n 1000000 -c 100 http://10.0.0.2:80/ > /dev/null 2>&1; done

动手实践

以上��译完毕�Q�下面将是根据上面内容进行动手测试描�q�吧�?/p>
安装Apache ab命��o(h��)

��(g��)查一下包含Apache ab命��o(h��)的��Y件包�Q?/p>
yum provides /usr/bin/ab

可以看到�c�M��于如下字��P��(x��)

httpd-tools-2.2.15-39.el6.centos.x86_64 : Tools for use with the Apache HTTP Server

安装它就可以�?/p>
yum install httpd-tools

虚拟机测�?/h4>
Windows 7专业版跑VMware Workstation 10.04虚拟机，两个Centos 6.5�pȝ��Q�配�|�一��_(d��)��2G内存�Q?个CPU逻辑处理器核�?j��)�?/p>
客户端安装Apache ab命��o(h��)��试�Q�跑8个实例：(x��) for i in $(seq 1 8); do ab -n 10000 -c 100 http://192.168.192.16:80/ > /dev/null 2>&1; done

服务器端�Q�分别记录：(x��)
/opt/fast/server -w 8 LD_PRELOAD=../library/libfsocket.so ./server -w 8

服务器模式对�?/h4>
两组数据�Ҏ(gu��)��Q?/p>

�q�行方式处理消耗时�?�U? 处理��L�� q�_��每秒处理�?/th> 最大�?/th>

单独�q�行 34s 80270 2361 2674

加蝲fasocket 28s 80399 2871 2964

代理模式数据

��试方式如上�Q�三台服务器�Q�测试端+代理�?服务器端�Q�配�|�一栗��第一�ơ代理单独启动，�W�二�ơ代理预加蝲fastsocket方式�?/p>

�q�行方式处理消耗时�?�U? 处理��L�� q�_��每秒处理�?/th> 最大�?/th>

�W�一�ơ测试后�?/td> 44s 80189 1822 2150

�W�一�ơ测试代�?/td> 44s 80189 1822 2152

�W�二�ơ测试后�?/td> 42s 80051 1906 2188

�W�二�ơ测试代�?/td> 42s 80051 1906 2167

备注�Q�虚拟机上数据，不代表真实服务器上数据，仅供参考�?/p>

虽然��Z��虚拟机，��试环境受限�Q�但一样可以看到基于fastsocket服务器模型，处理性能有所提升�Q��M��处理旉��Q�每�U��^均处理数�Q�以�?qi��ng)处理上限等�?/p>
关于LD_PRELOAD注意事项

动态链接预先加载LD_PRELOAD虽是利器�Q�但不是万能药，LD_PRELOAD遇到下面情况�?x��)失效�?x��)

�?r��n)态链接��用gcc -static参数把libc.so.6�?r��n)态链入执行程序中
讄��执行文�g的SUID权限�Q�可能也�?x��)导致LD_PRELOAD失效�Q�如�Q�chmod 4755 daemon�Q?

情况很复杂，��心(j��)��Z��?/p>
��结

学习(f��n)�q�测试了(ji��n)fastsocket的源码示范部分，前后�Ҏ(gu��)��可以看到fastsocket带来�?ji��n)处理性能的提升�?/p>

nieyong 2015-01-29 17:16 发表评论

nieyong — Thu, 29 Jan 2015 06:11:00 GMT

前言

以前在infoq上看到fastsocket的宣�?a >《两周内在Github上收�?800+个星�Q�内核层�|�络栈优化项目Fastsocket背后的故事�?/a>�Q�明白了(ji��n)fastsocket是什么：(x��)

高度可扩展的socket
是Linux内核层面的底层网�l�实�?
在多核机器上可实现极��x(ch��ng)��能�Q?4�总�内的性能增长呈线性，�q�超�q�默认内核在12�总�上的机器��׃��(x��)出现性能下降的情�?
非常�Ҏ(gu��)��使用和维护，应用代码无需变更
针对kernel-2.6.32-431.17.1.el6/CentOS-6.5的实�?
已经在新��的生��环境部��v
由新��的操作�pȝ��团队发�v
清华大学操作�pȝ��实验室、Intel、哲思自��p�Y件社区（Zeuux�Q�对该项目均有支�?

开源协议�ؓ(f��)GPLv2

��M��很吸引�h�Q�从内核层面�q�行优化TCP/IP�|�络堆栈�Q�上层网�l�应用程序不用做修改�Q�就可以得到处理性能的提升，很赞�Q?/p>

Fastsocket学习(f��n)�W�记目录

�q�期有点��空�Ԍ��开始对Fastsocket�q�行��x(ch��ng)��Q�虽然资料不多，但也记录�?ji��n)几��连�l�的学习(f��n)�W�记。大部分�W�记�Q�思�\主要是优先翻译官�Ҏ(gu��)��档，紧接着�?x��)夹带些个�h一些学�?f��n)笔记�?/p>
fastsocket��目地址是：(x��)https://github.com/fastos/fastsocket�Q�其wiki和代码是本系列笔��C��要来源。一开始想�q�一步全面认知fastsocket�Q�发现无从下手，只能从侧面开始一一旁敲侧击�Q�逐渐加深。本�p�d��W�记�Ҏ(gu��)��其源码目录结构划分特性，分开记录学习(f��n):

�~�译安装��?/a>
�C��应用��?/a>�Q�对应demo目录
�|�卡讄��?/a>�Q�对应scripts目录
动态链接库��?/a>�Q�对应library目录
内核模块��?/a>�Q�对应module目录�Q�实际上是kernel/net/fastsocket目录
内核��?/a>�Q�对应kernel目录�Q�也是内核模块篇
��结��?/a>

怎么说呢�Q�能力有限，若发现问�?�U�漏�Q�请帮忙�?qi��ng)时指正�Q�不胜感�Ȁ�?/p>
其它

代码贡献者，除了(ji��n)林晓�?/a>之外�Q�目前提交最为频�J�的�?a >greewind同学�Q�其博客地址�?a >http://blog.chinaunix.net/uid/23629988.html�Q�也是一位牛人�?/p>
优秀的开源项目，��L��可以吸引到最优秀的开发者�?/p>

nieyong 2015-01-29 14:11 发表评论

从网�l�游戏中学习(f��n)如何处理延迟

nieyong — Tue, 23 Dec 2014 02:02:00 GMT

前言

�|�络延迟是客观存在的�Q�但�|�络游戏行业已经�U�篏�?ji��n)大量优质经验，使用一些策略、技术手�D�在客户端消�?隐藏掉�g�q�带来的不便�Q�以��可能的掩盖实际存在的�g�Ӟ��同时实现实时渲染�Q�将用户带入快速的交互式实时游戏中�Q�体验完��的互动�׃��中�?/p>
�q�样处理�l�果�Q�稍高�g�q�的玩家也不�?x��)因为网�l�不是那么好�Q�也能够很和谐的与其它网�l�参差不�?qi��ng)玩家一��h��戏中�?/p>
虽然延时军_��?ji��n)实时游戏的最低反应时��_(d��)��但最重要的是客户端看��h��要流畅。第一人称设计游戏�Q�F(tu��n)PS�Q�可巧妙的化解与规避�Q�最�l�在适合普遍用户�|�络环境�?200ms)�Q�实现实时快速互动游戏�?/p>
嗯，下面��是�q�期脑补�l�果�?/p>
�|�游P2P & CS�l�构

早先�|�游使用P2P�|�络拓扑在玩家之间进行交换数据通信。但P2P模型引�v的高延迟在FPS游戏中无法被很好掩盖�Q�所有玩家的延迟取决于当前玩家中延迟最烂的那个。好比木桶理论，低�g�q�网�l�好的玩家会(x��)被高延迟坏网�l�的玩家拖篏。最�l�结果导��_(d��)��所有玩安��不太开�?j��)�?ji��n)。但在局域网环境下，不会(x��)感觉到�g�q�带来的问题。另�Q�游戏逻辑大部分都集中在客��L(f��ng)��?ji��n)，很难避免作弊行��?f��)�?/p>
C/S�l�构�|�游�Q?/p>

C/S�l�构在服务器端跑所有的游戏逻辑和输入响应，客户端只需要渲染以�?qi��ng)把自己需要一些状态同步下来，把用戯��入发�l�服务器端，然后昄��l�果��可以了(ji��n)
C/S�l�构�|�游最大优点就是把延迟从玩家之间最卡玩家的延迟改变?sh��)��玩家和服务器连接的延迟�Q�结果就是客��L(f��ng)��在带宽上的要求也低了(ji��n)不少�Q�因为只需要把输入发给服务器端��׃��?qi��ng)接收服务器响应��够�?
C/S�l�构�|�游虽然转移�?ji��n)网�l��g�q�矛盄��Q�但现实�|�络环境一样会(x��)带来较高的网�l��g�q�。客��L(f��ng)��每执行一�ơ操作，都需要等待服务器端命令，那会(x��)用户操作�?x��)造成操纵卡顿现象。如何解军_��Q�客��L(f��ng)��一般采用预��和插值等方式在渲染层隐藏�|�络延迟

客户端预��和插�?/h3>
服务器可以允许某些情况下客户端本地即时执行移动操作，�q�种�Ҏ(gu��)��可以�U�Cؓ(f��)客户端预��?/p>
比如游戏中键盘控制角色行赎ͼ��q�个时候可以在很小的时间段�Q�时间很短，比如1-3�U�）(j��)内预��用戯��动轨�q�（方向+加速度�Q�角色行走结果）(j��)�Q�这部分的命令客��L(f��ng)��?x��)全部发送到服务器端校验正确与否�Q�避免瞬间�{�Uȝ��外挂�Q�。但客户端预��有时也不是癑ֈ�癑և��，需要服务器�q�行�U�正�Q�所谓服务器��是上帝�Q�The sever is the man�Q�）(j��)。纠正结果可能就是游戏角色行走轨�q�和客户端预��轨�qҎ(gu��)��所偏差�Q�客��L(f��ng)��可以使用插值方式（�_�略来讲�Q�就是角色在两点之间�U�d��渲染的方式）(j��)渲染游戏角色在游戏世界中的位�|��{�U�d�^滑一些，避免游戏角色从一个位�|�瞬间拉回到另一个位�|�，让�h有些莫名其妙�?/p>
插��|��有�h也称之�ؓ(f��)路径补偿�Q�都是一回事。插值的�Ҏ(gu��)��?x��)涉及(qi��ng)到很多数学公式�Q�线性插倹{��三�ơ线性插值等�Q�比如这��文章所讲到�?a >插值那些事�?/p>
��结�Q�客��L(f��ng)��预测�Q�服务器端纠正，客户端采用插值方式微调�?/p>
针对交互的一��玩�Ӟ��|�络好坏层次不齐�Q�游戏的一些操作效果可能需�?#8221;延迟补偿“�{�略�q�行

延迟补偿

延迟补偿是游戏服务器端执行的一�U�策略，处理用户命��o(h��)回退到客��L(f��ng)��发送命令的准确旉��Q��g�q�导��_(d��)��(j��)�Q�根据客��L(f��ng)��的具体情况进行修正，以牺牲游戏在伤害判定斚w��的真实感来��I补攻击行为等斚w��真实感，本质上是一�U�折?sh��)��选择�?/p>
主要注意�Q��g�q�补偿不是发生在客户端�?/p>
关于延迟补偿的一个例子：(x��)

在FPS游戏中，玩家A�?0.5�U�时向目标对象玩家B��击�q�且��M��Q�射��M��息被打包发送（�|�络延迟100毫秒�Q�，服务器于10.6�U�收刎ͼ�此时玩家B可能已跑到另外一个位�|��?
若服务器仅仅��Z��接收时刻�Q?0.6�U�）(j��)�q�行判断�Q�那么玩家B没有收到伤害�Q�或许可能会(x��)��M��玩家B后面紧跟的玩家C�Q?00ms后玩家C完全由可能已处于玩家A的射�ȝ��标位�|�）(j��)
��Z��(ji��n)弥补�׃��延迟造成的问题，服务器端需要引�?#8220;延迟补偿”�{�略用于修正因�g�q�造成错�ؕ假象
服务器计��执行设计命令时��_(d��)��然后扑և�当前世界10.5�U�时�ȝ��家信息，�Ҏ(gu��)��击��法模拟得出是否命中判断�Q�以辑ֈ��可能精��?

若游戏�g�q�补偿被��用�Q�那么就�?x��)有许多玩家抱怨自己明明打中了(ji��n)�Ҏ(gu��)��却没有造成��M��伤害。�?/p>
有所得，有所失：(x��)但这对低延时玩家貌似有些不公�q�I��U�d��速度快，可能已经跑到角落里�ƈ且已�y�在一个箱子后面隐藏�v来时被对手击中的错觉�Q�子�Ҏ(gu��)��视掩体，玩家隔着墙被��击�Q�，��实有些不乐意�?/p>
延迟补偿�Q�网�l�高延迟的玩家有利，低�g�q�的玩家优势可能�?x��)被降低�Q�低延迟玩家利益受损�Q�，但对�l�护游戏世界的��^衡还是有利的�?/p>
�Ҏ(gu��)��&阀�?/h3>
客户端和服务器需要对�Ӟ��互相知道彼此延迟情况�Q�比如云风定义的某个步骤�Q?/p>

客户端发送一个本地时间量�l�服务器�Q�服务收到包后，夹带一个服务器旉��q�回�l�客��L(f��ng)��。当客户端收到这个包后，可以估算出包在�\�E�上�l�过的时间。同时把本地新时间夹带进去，再次发送给服务器。服务器也可以进一步的�?ji��n)解响应旉��?/p>

C/S两端通过�c�M��步骤�q�行计算彼此延时/时差�Q�同时会(x��)对实时同步设�|�一个阀��|��比如对�g�q�低�?0ms�Q?.01�U�）(j��)的交互认为是��x(ch��ng)��同步发生�Q�不�?x��)认为是延迟�?/p>
UDP或TCP

不同�c�d��的游戏会(x��)钟爱不同的协议呢�Q�不一而��Q?/p>

客户端间歇性的发�v无状态的查询�Q��ƈ且偶��?d��ng)发生�g�q�是可以容忍�Q�那么��用HTTP/HTTPS�?
客户端和服务器都可以独立发包�Q�偶��?d��ng)发生�g�q�可以容忍（比如�Q�在�U�的�U�牌游戏�Q�许多MMO�cȝ��游戏�Q�，那么使用TCP长连接吧
客户端和服务器都可以独立发包�Q�而且无法忍受延迟�Q�比如：(x��)大多数的多�hFPS动作�c�L��戏Quake、CS�{�，以及(qi��ng)一些MMO�c�L��戏）(j��)�Q�那么��用UDP�?

TCP�?x��)认定丢包是因��?f��)本地带宽不��D��Q�本地带宽不��x(ch��ng)��丢包的一部分原因�Q�，但国内ISP可能�?x��)在自��n机房�|�络拥挤时丢弃数据包�Q�这时候可能需要快速发包争抢通道�Q�而非TCP�H�口收羃�Q�UDP没有TCP�H�口收羃的负担，可以很容易做到这一炏V�?/p>
要求实时性放在第一位的FPS游戏�Q�eg�Q�Quake�Q�CS�Q�，�q�域�|�一般采用UDP�Q�因可容许有丢失数据包存在（另客��L(f��ng)��若等待一�D�|��间中间丢包，可以通过插值等手段忽略掉）(j��)�Q�一旦检��到可以快速发送，另不涉及(qi��ng)到重发的时候UDP比TCP要快一点嘛。但�?x��)在UDP应用层面有所增加协议控制�Q�比如ACK�{��?/p>
很多时候协议�؜用，比如MMO客户端也�?d��ng)R��先��用HTTP去获取上一�ơ的更新内容�Q?重要信息如角色获得的物品和经验需要通过TCP传输�Q�而周围�h物的动向、NPC�U�d��、技能动��L��令等则可以��用UDP传输�Q�虽然可能丢包，但媄(ji��ng)响不大�?/p>
��结

�|�游通过客户端预��、插值和服务器端延迟补脓(chu��ng)�{�，化解/消除用户端网�l��g�q�造成的停��ѝ��我们虽然可能没有机�?x��)接触游戏开发，学习(f��n)跨界的优良经验和实践�Q�说不准�?x��)对当前工作某些业务点的处理有所启发呢�?/p>

本集由韩国宇航局赞助播出�Q�我们要去远方看看，�q�有什么是我们的思密达�?------ 《万万没惛_��》王大锤

nieyong 2014-12-23 10:02 发表评论

nieyong — Thu, 20 Nov 2014 14:05:00 GMT

最�q�一�D�|��_(d��)��U�d��2G/3G客户端连接成功率不高�Q�着实让人头疹{�?/p>
说是Android�|�络调试�Q�其实也不过是在被ROOT后Android�pȝ��操作�Q��用adb shell执行一些常规的�l�端命��o(h��)�Q�检��?G/3G/4G/WIFI�|�络�{�，�q�而确定一些因�|�络�{�导致的问题而已。但adb shell默认没有几个支持的命令，比如 cat, tcpdump�Q�这些都是最基本的必备命令，也不支持。对于想要查看网�l�请求有几次跌��{�Q�不借助些外力，��实是�g很不可能的事情�?/p>
基本��会(x��)包含如下内容�Q?/p>

如何安装需要的Linux�l�端命��o(h��)tcpdump,mtr
调试2G/3G�{�网�l�连通，域名��h��跌��{
��h��丢包情况

Android�l�端扩展��器opkg

说它是神器，一炚w��不夸张。Homepage�Q?http://dan.drown.org/android/)�Q�上开��明义：(x��)

Unix command-line programs ported to run on android. This project uses opkg, which handles downloading and installing packages and their dependencies (like yum or apt). Source for all packages are available.

作�?strong>Dan (http://blog.dan.drown.org/)为我们移植到Android�q�_��Q��ƈ且还?sh��)��我们编译好相当多的常用�E�序�Q�具体支持列表，可从Changelog(http://dan.drown.org/android/)中找刎ͼ��q�里不再累述�?/p>
十分隑־��Q�由��h��谢�?/p>
下蝲opkg�?/h3>
预先把依赖下载到本地:

http://dan.drown.org/android/system/xbin/busybox
http://dan.drown.org/android/opkg.tar.gz

安装opkg

讑֮�装到Android手机�?/data/local 目录�Q�那么首先需要确保这个目录具有可��d��权限�?/p>

记得要��用su命��o(h��)切换到root��理员�̎��P��操作、权限才不会(x��)受阻�?/p>
adb shell chmod 777 /data/local

拯��opkg�?data/local目录
adb push busybox /data/local adb push opkg.tar.gz /data/local

adb shell�q�去之后�Q�开始编译安装：(x��)
cd /data/local chmod 777 busybox ./busybox tar zxvf opkg.tar.gz

讄��环境变量�Q?/p>
export PATH=$PATH:/data/local/bin

执行更新、安装准�?/p>
opkg update opkg install opkg opkg list # 可以查看可以支持安装的终端应用程�?命��o(h��))

话说�Q�opkg可以应用于各�U�嵌入式环境中，��强的说�?/p>
安装linux�l�端应用/命��o(h��)

可以一口气安装几个试试�Q?/p>
opkg install mtr curl tcpdump cat

当然�Q�你也可以一个一个安装�?/p>
安装好之后呢�Q�就是直接运行应�?命��o(h��)�?ji��n)，��试baidu.com域名解析、丢包情��c(di��n)�?/p>

mtr -r baidu.com HOST: localhost Loss% Snt Last
Avg Best Wrst StDev
1.|-- ??? 100.0 10 0.0 0.0 0.0 0.0 0.0
2.|-- 192.168.61.1 0.0% 10 504.3 635.0 339.3 1024. 238.7
3.|-- 192.168.63.138 0.0% 10 392.9 588.7 298.5 847.7 220.3
4.|-- 221.130.39.106 0.0% 10 340.9 557.3 257.4 823.5 211.7
5.|-- 221.179.159.45 10.0% 10 649.6 631.4 332.6 821.4 165.0
6.|-- 111.13.14.6 10.0% 10 561.9 551.3 268.2 777.0 170.0
7.|-- 111.13.0.162 10.0% 10 510.6 570.6 385.5 767.6 116.6
8.|-- 111.13.1.14 10.0% 10 775.4 565.2 377.7 775.4 130.9
9.|-- 111.13.2.130 10.0% 10 707.2 564.6 381.1 887.3 173.4

嗯，通过mtr��实很容易就看出�Q�网�l�蟩敎ͼ�每一个节点丢包率。这样就能很�Ҏ(gu��)��扑ֈ�在移�?G/3G�|�络�q�接��时比较严重的问题所在。下面就是希望运�l�的同学��快处理好，避免再次出现��p��通机房再�ơ蟩转到�U�d��机房问题�?/p>

非常感谢陈杰同学推荐的比ping+traceroute�q�要好用命��o(h��)mtr。一旦拥有，不会(x��)放手�Q?/p>

�U�d��2G/3G下网�l�抓�?/h4>
要想抓取2G/3G�|�络下数据包�Q�必��d��装一个tcpdump命��o(h��)�Q?/p>
opkg install tcpdump

opkg很脓(chu��ng)�?j��)的会(x��)把所依赖的libpcap也都一�q�安装上�Q�完全不用担�?j��)版本问题�?/p>
tcpdump -i any -p -vv -s 0 -w /sdcard/capture.pcap

下面��是一气呵成的导出�Q��用wireshark�q�行分析�?ji��n)�?/p>
adb pull /sdcard/tmp1.pcap c:/tmp

其它有利于诊断网�l�的APP

不习(f��n)惯��用终端诊断网�l�，可以直接使用现成的APP�?/p>

�W�一�?Fing�Q�大名如雯��耻I��跨Android、IOS�q�_��Q�DNS、PING�{�不在话下，居家生活之必�?
�W�二名嘛�Q�暂时还没有发现�?
shark for root�Q�也不错�Q�Android�q�_��推荐
�|�速测试，可以看到当前�|�络的�g�q�等�Q�也不错

有更好的APP推荐�Q�欢�q�推荐一二�?/p>
��结

希望可以�l�遇到同样问题的同学一些帮�?
记录下来便于以后索引

nieyong 2014-11-20 22:05 发表评论

��Z��么批量请求要��可能的合�ƈ操作

nieyong — Sun, 09 Nov 2014 14:08:00 GMT

前言

�U�上情况�Q?/p>

�U�上Redis集群�Q�多个Twemproxy代理�Q�nutcracker�Q�，LVS DR路由均衡调度
客户端��用Jedis操作Redis集群�Q�一个程序进�E�实例��用原�?024个工作线�E�处理请求，若干个进�E�实�?
一天超�q?2亿次��h��Q�网�l�一般情况下�Q�一天超�q�上万个�q�接��p�|异常
�q�维同学告知�Q�LVS压力较大

改进工作�Q?/p>

工作�U�程由原�?024改用16�?
每个�U�程每次最多操�?000个Redis命��o(h��)扚w��提交

实际效果�Q?/p>

一天不��C��亿次的请求量
LVS压力大减
CPU压力降低到原�?/3以下
单个��h��抽样调研�q�_��减少1-90毫秒旉��Q�尤其是跨机房处理）(j��)

Redis支持扚w��提交

原生支持扚w��操作方式

一般命令前�~�若添加上m字符�Ԍ��表示支持多个、批量命令提交了(ji��n)�?/p>
昑ּ��?..
MSET key value [key value ...] MSETNX key value [key value ...] HMGET key field [field ...] HMSET key field value [field value ...]

一般方式的...
HDEL key field [field ...] SREM key member [member ...] RPUSH key value [value ...] ......

更多�Q�请参考：(x��)http://redis.cn/commands.html

pipeline��道方式

官方文档�Q?a >http://redis.io/topics/pipelining

Redis Client把所有命令一��h��包发送到Redis Server�Q�然后阻塞等待处理结�?
Redis Server必须在处理完所有命令前先缓存�v所有命令的处理�l�果
打包的命令越多，�~�存消耗内存�(sh��)��多
不是打包的命令越多越�?
实际环境需要根据命令执行时间等各种因素选择合�ƈ命��o(h��)的个敎ͼ�以及(qi��ng)��试效果�{?

Java队列支持

一般业务、接入前端请求量�q�大�Q�生产者速度�q�快�Q�这时候��用队列暂时缓存�(sh��)��(x��)比较好一些，消费者直接直接从队列获取��d��Q�通过队列让生产者和消费者进行分��这也是业界普通采用的方式�?/p>
监控队列

有的时候，若可以监控一下队列消�Ҏ(gu��)��况，可以监控一下，��很直观。同事�ؓ(f��)队列��d��?ji��n)一个监控线�E�，清晰明了(ji��n)�?ji��n)解队列消费情况�?/p>
�C��

�C��使用�?ji��n)Redis Pipeline�Q�线�E�池�Q�准备数据，生��?消费者队列，队列监控�{�，消费完毕�Q�程序关闭�?/p>
/** * 以下��试在Jedis 2.6下测试通过 * * @author nieyong * */ public class TestJedisPipeline { private static final int NUM = 512; private static final int MAX = 1000000; // 100W private static JedisPool redisPool; private static final ExecutorService pool = Executors.newCachedThreadPool(); protected static final BlockingQueue queue = new ArrayBlockingQueue( MAX); // 100W private static boolean finished = false; static { JedisPoolConfig config = new JedisPoolConfig(); config.setMaxActive(64); config.setMaxIdle(64); try { redisPool = new JedisPool(config, "192.168.192.8", 6379, 10000, null, 0); } catch (Exception e) { System.err.println("Init msg redis factory error! " + e.toString()); } } public static void main(String[] args) throws InterruptedException { System.out.println("prepare test data 100W"); prepareTestData(); System.out.println("prepare test data done!"); // 生��者，模拟��h��100W��? pool.execute(new Runnable() { @Override public void run() { for (int i = 0; i < MAX; i++) { if (i % 3 == 0) { queue.offer("del_key key_" + i); } else { queue.offer("get_key key_" + i); } } } }); // CPU核数*2 个工作者线�E? int threadNum = 2 * Runtime.getRuntime().availableProcessors(); for (int i = 0; i < threadNum; i++) pool.execute(new ConsumerTask()); pool.execute(new MonitorTask()); Thread.sleep(10 * 1000);// 10sec System.out.println("going to shutdown server ..."); setFinished(true); pool.shutdown(); pool.awaitTermination(1, TimeUnit.MILLISECONDS); System.out.println("colse!"); } private static void prepareTestData() { Jedis redis = redisPool.getResource(); Pipeline pipeline = redis.pipelined(); for (int i = 0; i < MAX; i++) { pipeline.set("key_" + i, (i * 2 + 1) + ""); if (i % (NUM * 2) == 0) { pipeline.sync(); } } pipeline.sync(); redisPool.returnResource(redis); } // queue monitor�Q�生产�?消费队列监控 private static class MonitorTask implements Runnable { @Override public void run() { while (!Thread.interrupted() && !isFinished()) { System.out.println("queue.size = " + queue.size()); try { Thread.sleep(500); // 0.5 second } catch (InterruptedException e) { break; } } } } // consumer�Q�消费�? private static class ConsumerTask implements Runnable { @Override public void run() { while (!Thread.interrupted() && !isFinished()) { if (queue.isEmpty()) { try { Thread.sleep(100); } catch (InterruptedException e) { } continue; } List tasks = new ArrayList(NUM); queue.drainTo(tasks, NUM); if (tasks.isEmpty()) { continue; } Jedis jedis = redisPool.getResource(); Pipeline pipeline = jedis.pipelined(); try { List> resultList = new ArrayList>( tasks.size()); List waitDeleteList = new ArrayList( tasks.size()); for (String task : tasks) { String key = task.split(" ")[1]; if (task.startsWith("get_key")) { resultList.add(pipeline.get(key)); waitDeleteList.add(key); } else if (task.startsWith("del_key")) { pipeline.del(key); } } pipeline.sync(); // 处理�q�回列表 for (int i = 0; i < resultList.size(); i++) { resultList.get(i).get(); // handle value here ... // System.out.println("get value " + value); } // ��d��完毕�Q�直接删除之 for (String key : waitDeleteList) { pipeline.del(key); } pipeline.sync(); } catch (Exception e) { redisPool.returnBrokenResource(jedis); } finally { redisPool.returnResource(jedis); } } } } private static boolean isFinished(){ return finished; } private static void setFinished(boolean bool){ finished = bool; } }

代码作�ؓ(f��)�C��。若�U�上则需要处理一些异常等�?/p>
��结

若能够批量请求进行合�q�操作，自然可以节省很多的网�l�带宽、CPU�{�资源。有�c�M��问题的同学，不妨考虑一下�?/p>

nieyong 2014-11-09 22:08 发表评论

随手��C��Linux 2.6.32内核SYN flooding警告信息

nieyong — Wed, 20 Aug 2014 12:43:00 GMT

前言

新申��L(f��ng)��服务器内��ؓ(f��)2.6.32�Q�原先的TCP Server直接在新内核的Linxu服务器上�q�行�Q�运行dmesg命��o(h��)�Q�可以看到大量的SYN flooding警告�Q?/p>

possible SYN flooding on port 8080. Sending cookies.

原先�?.6.18内核的参数在2.6.32内核版本情况下，��单调�?net.ipv4.tcp_max_syn_backlog"已经没有作用�?/p>
怎么办，只能再次阅读2.6.32源码�Q�以下即是�?/p>
最后小�l�处有直接结论，�?j��)急的你可以直接阅��L�ȝ��好了(ji��n)�?/p>
linux内核2.6.32有关backlog值分�?/h3>
net/Socket.c:
SYSCALL_DEFINE2(listen, int, fd, int, backlog) { struct socket *sock; int err, fput_needed; int somaxconn; sock = sockfd_lookup_light(fd, &err, &fput_needed); if (sock) { somaxconn = sock_net(sock->sk)->core.sysctl_somaxconn; if ((unsigned)backlog > somaxconn) backlog = somaxconn; err = security_socket_listen(sock, backlog); if (!err) err = sock->ops->listen(sock, backlog); fput_light(sock->file, fput_needed); } return err; }

net/ipv4/Af_inet.c:
/* * Move a socket into listening state. */ int inet_listen(struct socket *sock, int backlog) { struct sock *sk = sock->sk; unsigned char old_state; int err; lock_sock(sk); err = -EINVAL; if (sock->state != SS_UNCONNECTED || sock->type != SOCK_STREAM) goto out; old_state = sk->sk_state; if (!((1 << old_state) & (TCPF_CLOSE | TCPF_LISTEN))) goto out; /* Really, if the socket is already in listen state * we can only allow the backlog to be adjusted. */ if (old_state != TCP_LISTEN) { err = inet_csk_listen_start(sk, backlog); if (err) goto out; } sk->sk_max_ack_backlog = backlog; err = 0; out: release_sock(sk); return err; }

inet_listen调用inet_csk_listen_start函数�Q�所传入的backlog参数改头换面�Q�变成了(ji��n)不可修改的常量nr_table_entries�?ji��n)�?/p>
net/ipv4/Inet_connection_sock.c:
int inet_csk_listen_start(struct sock *sk, const int nr_table_entries) { struct inet_sock *inet = inet_sk(sk); struct inet_connection_sock *icsk = inet_csk(sk); int rc = reqsk_queue_alloc(&icsk->icsk_accept_queue, nr_table_entries); if (rc != 0) return rc; sk->sk_max_ack_backlog = 0; sk->sk_ack_backlog = 0; inet_csk_delack_init(sk); /* There is race window here: we announce ourselves listening, * but this transition is still not validated by get_port(). * It is OK, because this socket enters to hash table only * after validation is complete. */ sk->sk_state = TCP_LISTEN; if (!sk->sk_prot->get_port(sk, inet->num)) { inet->sport = htons(inet->num); sk_dst_reset(sk); sk->sk_prot->hash(sk); return 0; } sk->sk_state = TCP_CLOSE; __reqsk_queue_destroy(&icsk->icsk_accept_queue); return -EADDRINUSE; }

下面处理的是TCP SYN_RECV状态的�q�接�Q�处于握手阶�D�，也可以说是半�q�接�Ӟ��{�待着�q�接方第三次握手�?/p>
/* * Maximum number of SYN_RECV sockets in queue per LISTEN socket. * One SYN_RECV socket costs about 80bytes on a 32bit machine. * It would be better to replace it with a global counter for all sockets * but then some measure against one socket starving all other sockets * would be needed. * * It was 128 by default. Experiments with real servers show, that * it is absolutely not enough even at 100conn/sec. 256 cures most * of problems. This value is adjusted to 128 for very small machines * (<=32Mb of memory) and to 1024 on normal or better ones (>=256Mb). * Note : Dont forget somaxconn that may limit backlog too. */ int reqsk_queue_alloc(struct request_sock_queue *queue, unsigned int nr_table_entries) { size_t lopt_size = sizeof(struct listen_sock); struct listen_sock *lopt; nr_table_entries = min_t(u32, nr_table_entries, sysctl_max_syn_backlog); nr_table_entries = max_t(u32, nr_table_entries, 8); nr_table_entries = roundup_pow_of_two(nr_table_entries + 1); lopt_size += nr_table_entries * sizeof(struct request_sock *); if (lopt_size > PAGE_SIZE) lopt = __vmalloc(lopt_size, GFP_KERNEL | __GFP_HIGHMEM | __GFP_ZERO, PAGE_KERNEL); else lopt = kzalloc(lopt_size, GFP_KERNEL); if (lopt == NULL) return -ENOMEM; for (lopt->max_qlen_log = 3; (1 << lopt->max_qlen_log) < nr_table_entries; lopt->max_qlen_log++); get_random_bytes(&lopt->hash_rnd, sizeof(lopt->hash_rnd)); rwlock_init(&queue->syn_wait_lock); queue->rskq_accept_head = NULL; lopt->nr_table_entries = nr_table_entries; write_lock_bh(&queue->syn_wait_lock); queue->listen_opt = lopt; write_unlock_bh(&queue->syn_wait_lock); return 0; }

关键要看nr_table_entries变量�Q�在reqsk_queue_alloc函数中nr_table_entries变成�?ji��n)无�W�号变量�Q�可修改的，变化受限�?/p>
比如实际内核参数��gؓ(f��)�Q?/p>

net.ipv4.tcp_max_syn_backlog = 65535

所传入的backlog�Q�不大于net.core.somaxconn = 65535�Q��ؓ(f��)8102�Q�那�?/p>
// 取listen函数的backlog和sysctl_max_syn_backlog最��|��l�果�?102 nr_table_entries = min_t(u32, nr_table_entries, sysctl_max_syn_backlog); // 取nr_table_entries�?�q�行比较的最大��|��l�果�?102 nr_table_entries = max_t(u32, nr_table_entries, 8); // 可看�?nr_table_entries*2�Q�结果�ؓ(f��)8102*2=16204 nr_table_entries = roundup_pow_of_two(nr_table_entries + 1); 计算�l�果�Q�max_qlen_log = 14

2.6.18内核中max_qlen_log的计��方�?/h4>
for (lopt->max_qlen_log = 6; (1 << lopt->max_qlen_log) < sysctl_max_syn_backlog; lopt->max_qlen_log++);

很显�?d��ng)��sysctl_max_syn_backlog参与�?ji��n)运��，sysctl_max_syn_backlog值很大的话会(x��)��D��max_qlen_log值相�Ҏ(gu��)��也很�?
若sysctl_max_syn_backlog=65535�Q�那么max_qlen_log=16
2.6.18内核中半�q�接长度�?^16=65536

作�ؓ(f��)listen_sock�l�构定义�?ji��n)需要处理的处理半连接的队列元素个数为nr_table_entries�Q�此例中�?6204长度�?/p>
/** struct listen_sock - listen state * * @max_qlen_log - log_2 of maximal queued SYNs/REQUESTs */ struct listen_sock { u8 max_qlen_log; /* 3 bytes hole, try to use */ int qlen; int qlen_young; int clock_hand; u32 hash_rnd; u32 nr_table_entries; struct request_sock *syn_table[0]; };

�l�描�q�而知�Q?^max_qlen_log = 半连接队列长度qlen倹{�?/p>
再回头看看报告SYN flooding的函敎ͼ�(x��)

net/ipv4/Tcp_ipv4.c
#ifdef CONFIG_SYN_COOKIES static void syn_flood_warning(struct sk_buff *skb) { static unsigned long warntime; if (time_after(jiffies, (warntime + HZ * 60))) { warntime = jiffies; printk(KERN_INFO "possible SYN flooding on port %d. Sending cookies.\n", ntohs(tcp_hdr(skb)->dest)); } } #endif

被调用的处，已精��若干代码�Q?/p>
int tcp_v4_conn_request(struct sock *sk, struct sk_buff *skb) { ...... #ifdef CONFIG_SYN_COOKIES int want_cookie = 0; #else #define want_cookie 0 /* Argh, why doesn't gcc optimize this :( */ #endif ...... /* TW buckets are converted to open requests without * limitations, they conserve resources and peer is * evidently real one. */ // 判断半连接队列是否已�?&& !0 if (inet_csk_reqsk_queue_is_full(sk) && !isn) { #ifdef CONFIG_SYN_COOKIES if (sysctl_tcp_syncookies) { want_cookie = 1; } else #endif goto drop; } /* Accept backlog is full. If we have already queued enough * of warm entries in syn queue, drop request. It is better than * clogging syn queue with openreqs with exponentially increasing * timeout. */ if (sk_acceptq_is_full(sk) && inet_csk_reqsk_queue_young(sk) > 1) goto drop; req = inet_reqsk_alloc(&tcp_request_sock_ops); if (!req) goto drop; ...... if (!want_cookie) TCP_ECN_create_request(req, tcp_hdr(skb)); if (want_cookie) { #ifdef CONFIG_SYN_COOKIES syn_flood_warning(skb); req->cookie_ts = tmp_opt.tstamp_ok; #endif isn = cookie_v4_init_sequence(sk, skb, &req->mss); } else if (!isn) { ...... } ...... }

判断半连接队列已满的函数很关键，可以看看�q�算法则�Q?/p>
include/net/Inet_connection_sock.h:
static inline int inet_csk_reqsk_queue_is_full(const struct sock *sk) { return reqsk_queue_is_full(&inet_csk(sk)->icsk_accept_queue); }

include/net/Rquest_sock.h:
static inline int reqsk_queue_is_full(const struct request_sock_queue *queue) { // 向右�U�M��max_qlen_log个单�? return queue->listen_opt->qlen >> queue->listen_opt->max_qlen_log; }

�q�回1�Q�自然表�C�半�q�接队列已满�?/p>
以上仅仅是分析了(ji��n)半连接队列已满的判断条�g�Q��M��应用�E�序所传入的backlog很关键，如值太��，很容易得�?.

�?somaxconn = 128�Q�sysctl_max_syn_backlog = 4096�Q�backlog = 511 则最�l?nr_table_entries = 256�Q�max_qlen_log = 8。那么超�q?56个半�q�接的队列，257 >> 8 = 1�Q�队列已满�?/p>
如何讄��backlog�Q�还得需要结合具体应用程序，需要�ؓ(f��)其调用listen�Ҏ(gu��)��赋倹{�?/p>
Netty backlog处理

Tcp Server使用Netty 3.7 版本�Q�版本较低，在处理backlog�Q�若我们不手动指定backlog��|��JDK 1.6默认�?0�?/p>
有证如下�Q?java.net.ServerSocket:
public void bind(SocketAddress endpoint, int backlog) throws IOException { if (isClosed()) throw new SocketException("Socket is closed"); if (!oldImpl && isBound()) throw new SocketException("Already bound"); if (endpoint == null) endpoint = new InetSocketAddress(0); if (!(endpoint instanceof InetSocketAddress)) throw new IllegalArgumentException("Unsupported address type"); InetSocketAddress epoint = (InetSocketAddress) endpoint; if (epoint.isUnresolved()) throw new SocketException("Unresolved address"); if (backlog < 1) backlog = 50; try { SecurityManager security = System.getSecurityManager(); if (security != null) security.checkListen(epoint.getPort()); getImpl().bind(epoint.getAddress(), epoint.getPort()); getImpl().listen(backlog); bound = true; } catch(SecurityException e) { bound = false; throw e; } catch(IOException e) { bound = false; throw e; } }

netty中，处理backlog的地方：(x��)

org/jboss/netty/channel/socket/DefaultServerSocketChannelConfig.java:
@Override public boolean setOption(String key, Object value) { if (super.setOption(key, value)) { return true; } if ("receiveBufferSize".equals(key)) { setReceiveBufferSize(ConversionUtil.toInt(value)); } else if ("reuseAddress".equals(key)) { setReuseAddress(ConversionUtil.toBoolean(value)); } else if ("backlog".equals(key)) { setBacklog(ConversionUtil.toInt(value)); } else { return false; } return true; }

既然需要我们手动指定backlog��|��那么可以�q�样做：(x��)
bootstrap.setOption("backlog", 8102); // 讄��大一些没有关�p�，�pȝ��内核�?x��)自动与net.core.somaxconn相比较，取最低�?

相对比Netty 4.0�Q�有些不��Q�可参考：(x��)http://www.tkk7.com/yongboy/archive/2014/07/30/416373.html

��结

在linux内核2.6.32�Q�若在没有遭受到SYN flooding��d��的情况下�Q�可以适当调整�Q?/p>

sysctl -w net.core.somaxconn=32768

sysctl -w net.ipv4.tcp_max_syn_backlog=65535

sysctl -p

另千万别忘记修改TCP Server的listen接口所传入的backlog��|��若不讄��或者过��，都会(x��)有可能造成SYN flooding的警告信息。开始不妨设�|�成1024�Q�然后观察一�D�|��间根据实际情况需要再慢慢往上调�?/p>
无论你如何设�|�，最�l�backlog��D��围�ؓ(f��)�Q?/p>

backlog <= net.core.somaxconn

半连接队列长度约为：(x��)

半连接队列长�?≈ 2 * min(backlog, net.ipv4.tcpmax_syn_backlog)

另，若出现SYN flooding�Ӟ��此时TCP SYN_RECV数量表示半连接队列已�l�满�Q�可以查看一下：(x��)
ss -ant | awk 'NR>1 {++s[$1]} END {for(k in s) print k,s[k]}'

感谢�q�维书坤��伙提供的比较好用查看命令�?/p>

nieyong 2014-08-20 20:43 发表评论

随手��C��Linux内核SYN flooding警告信息

nieyong — Wed, 06 Aug 2014 13:57:00 GMT

前言

最�q�线上服务器�Q�dmesg�?x��)给��Z��些警告信息：(x��)

possible SYN flooding on port 8080. Sending cookies.

初看以�ؓ(f��)是受到DOS拒绝性攻击，但仔�l�一分析�Q�一天量也就是在1000多条左右�Q�感觉上属于正常可接受范围�?/p>
下面需要找出来源，以及(qi��ng)原因�Q�以下内容基于Linux 2.6.18内核�?/p>
警告输出源头

net/ipv4/Tcp_ipv4.c:
#ifdef CONFIG_SYN_COOKIES static void syn_flood_warning(struct sk_buff *skb) { static unsigned long warntime; // �W�一�ơ加载初始化为零�Q�后�l�warntime = jiffies if (time_after(jiffies, (warntime + HZ * 60))) { warntime = jiffies; printk(KERN_INFO "possible SYN flooding on port %d. Sending cookies.\n", ntohs(skb->h.th->dest)); } } #endif

很显�?d��ng)��CONFIG_SYN_COOKIES在Linux�pȝ��~�译�Ӟ��已被讄��true�?/p>
time_after宏定义：(x��)
#define time_after(a,b) \ (typecheck(unsigned long, a) && \ typecheck(unsigned long, b) && \ ((long)(b) - (long)(a) < 0))

两个无符��L(f��ng)��旉��比较�Q�确定先后顺序�?/p>
jiffies真��n�Q?/p>
# define jiffies raid6_jiffies() #define HZ 1000 ...... static inline uint32_t raid6_jiffies(void) { struct timeval tv; gettimeofday(&tv, NULL); return tv.tv_sec*1000 + tv.tv_usec/1000; // �U?1000 + 微秒/1000 }

回过头来�Q�再看看syn_flood_warning函数�Q?/p>
static void syn_flood_warning(struct sk_buff *skb) { static unsigned long warntime; // �W�一�ơ加载初始化为零�Q�后�l�warntime = jiffies if (time_after(jiffies, (warntime + HZ * 60))) { warntime = jiffies; printk(KERN_INFO "possible SYN flooding on port %d. Sending cookies.\n", ntohs(skb->h.th->dest)); } }

warntime为static�c�d��Q�第一�ơ调用时被初始化为零�Q�下�ơ调用就是上�ơ的jiffies��g��(ji��n)�Q�前后间隔��D��q�HZ*60��׃��?x��)输��(gu��)��告信息�?ji��n)�?/p>
有关time_after和jiffies�Q�分享几��文章：(x��)

http://wenku.baidu.com/view/c75658d480eb6294dd886c4e.html
http://www.360doc.com/content/11/1201/09/1317564_168810003.shtml

警告输出需要满��的条�g

注意观察want_cookie=1时的条�g�?/p>
net/ipv4/Tcp_ipv4.c:
int tcp_v4_conn_request(struct sock *sk, struct sk_buff *skb) { struct inet_request_sock *ireq; struct tcp_options_received tmp_opt; struct request_sock *req; __u32 saddr = skb->nh.iph->saddr; __u32 daddr = skb->nh.iph->daddr; __u32 isn = TCP_SKB_CB(skb)->when; // when在tcp_v4_rcv()中会(x��)被置�? struct dst_entry *dst = NULL; #ifdef CONFIG_SYN_COOKIES int want_cookie = 0; #else #define want_cookie 0 /* Argh, why doesn't gcc optimize this :( */ #endif /* Never answer to SYNs send to broadcast or multicast */ if (((struct rtable *)skb->dst)->rt_flags & (RTCF_BROADCAST | RTCF_MULTICAST)) goto drop; /* TW buckets are converted to open requests without * limitations, they conserve resources and peer is * evidently real one. */ // if(判断半连接队列已�?&& !0) if (inet_csk_reqsk_queue_is_full(sk) && !isn) { #ifdef CONFIG_SYN_COOKIES if (sysctl_tcp_syncookies) { // net.ipv4.tcp_syncookies = 1 want_cookie = 1; } else #endif goto drop; } /* Accept backlog is full. If we have already queued enough * of warm entries in syn queue, drop request. It is better than * clogging syn queue with openreqs with exponentially increasing * timeout. */ // if(�q�接队列是否已满 && 半连接队列中�q�有未重传ACK半连接数�?> 1) if (sk_acceptq_is_full(sk) && inet_csk_reqsk_queue_young(sk) > 1) goto drop; ...... tcp_openreq_init(req, &tmp_opt, skb); ireq = inet_rsk(req); ireq->loc_addr = daddr; ireq->rmt_addr = saddr; ireq->opt = tcp_v4_save_options(sk, skb); if (!want_cookie) TCP_ECN_create_request(req, skb->h.th); if (want_cookie) { // 半连接队列已满会(x��)触发 #ifdef CONFIG_SYN_COOKIES syn_flood_warning(skb); #endif isn = cookie_v4_init_sequence(sk, skb, &req->mss); } else if (!isn) { ...... } /* Kill the following clause, if you dislike this way. */ // net.ipv4.tcp_syncookies未设�|�情况下�Q�sysctl_max_syn_backlog发生的作�? else if (!sysctl_tcp_syncookies && (sysctl_max_syn_backlog - inet_csk_reqsk_queue_len(sk) < (sysctl_max_syn_backlog >> 2)) && (!peer || !peer->tcp_ts_stamp) && (!dst || !dst_metric(dst, RTAX_RTT))) { /* Without syncookies last quarter of * backlog is filled with destinations, * proven to be alive. * It means that we continue to communicate * to destinations, already remembered * to the moment of synflood. */ LIMIT_NETDEBUG(KERN_DEBUG "TCP: drop open " "request from %u.%u.%u.%u/%u\n", NIPQUAD(saddr), ntohs(skb->h.th->source)); dst_release(dst); goto drop_and_free; } isn = tcp_v4_init_sequence(sk, skb); } tcp_rsk(req)->snt_isn = isn; if (tcp_v4_send_synack(sk, req, dst)) goto drop_and_free; if (want_cookie) { reqsk_free(req); } else { inet_csk_reqsk_queue_hash_add(sk, req, TCP_TIMEOUT_INIT); } return 0; drop_and_free: reqsk_free(req); drop: return 0; }

��结

��M��Q�如�pȝ��出现�Q?/p>

possible SYN flooding on port 8080. Sending cookies.

若量不大�Q�是在提醒你需要关�?j��)一下sysctl_max_syn_backlog其值是否过�?

sysctl -a | grep 'max_syn_backlog'

不妨成倍增加一�?/p>

sysctl -w net.ipv4.tcp_max_syn_backlog=8192

sysctl -p

若进�E�无法做到重新加载，那就需要重启应用，以适应新的内核参数。进而持�l�观察一�D�|��间�?/p>
貌似tcp_max_syn_backlog参数其完整作用域�q�没有理解完��_(d��)��下次有时间再写吧�?/p>

nieyong 2014-08-06 21:57 发表评论

随手��C��Linux内核Backlog�W�记

nieyong — Wed, 30 Jul 2014 09:22:00 GMT

零。前�a�

有些东西��L��很容易遗忘，一时记得了(ji��n)�Q�过两天��q��正还�l�周公了(ji��n)。零零碎��的不如一�q�记下来�Q�以后可以直接拿�q�来查询卛_��?/p>
以下内容��Z��Linux 2.6.18内核�?/p>
一。listen�Ҏ(gu��)��传入的backlog参数�Q�net.core.somaxconn

�q�个参数具体意义�Q�先看看Linux Socket的listen解释

man listen
#include int listen(int sockfd, int backlog);

int�c�d��的backlog参数�Q�listen�Ҏ(gu��)��的backlog意义为，已经完成三次握手、已�l�成功徏立连接的套接字将要进入队列的长度�?/p>
一般我们自己定义设定backlog��|��若我们设�|�的backlog值大于net.core.somaxconn��|��被�|��ؓ(f��)net.core.somaxconn值大��。若不想直接��性指定，跟随�pȝ��讑֮��Q�则需要读�?proc/sys/net/core/somaxconn�?/p>
net\Socket.c :
/* * Perform a listen. Basically, we allow the protocol to do anything * necessary for a listen, and if that works, we mark the socket as * ready for listening. */ int sysctl_somaxconn = SOMAXCONN; asmlinkage long sys_listen(int fd, int backlog) { struct socket *sock; int err, fput_needed; if ((sock = sockfd_lookup_light(fd, &err, &fput_needed)) != NULL) { if ((unsigned) backlog > sysctl_somaxconn) backlog = sysctl_somaxconn; err = security_socket_listen(sock, backlog); if (!err) err = sock->ops->listen(sock, backlog); fput_light(sock->file, fput_needed); } return err; }

比如�l�常使用的netty(4.0)框架�Q�在Linux下启动时�Q�会(x��)直接��d��/proc/sys/net/core/somaxconn值然后作为listen的backlog参数�q�行调用Linux�pȝ��的listen�q�行初始化等�?/p>
int somaxconn = 3072; BufferedReader in = null; try { in = new BufferedReader(new FileReader("/proc/sys/net/core/somaxconn")); somaxconn = Integer.parseInt(in.readLine()); logger.debug("/proc/sys/net/core/somaxconn: {}", somaxconn); } catch (Exception e) { // Failed to get SOMAXCONN } finally { if (in != null) { try { in.close(); } catch (Exception e) { // Ignored. } } } SOMAXCONN = somaxconn; ...... private volatile int backlog = NetUtil.SOMAXCONN;

一般稍微增大net.core.somaxconn值就昑־�很有必要�?/p>
讄��其值方法：(x��)
sysctl -w net.core.somaxconn=65535

较大内存的Linux�Q?5535数��g��般就可以�?ji��n)�?/p>
若让其生效，sysctl -p 卛_��Q�然后重启你的Server应用卛_��?/p>
二。网卡设备将��h��攑օ�队列的长度，netdev_max_backlog

内核代码中sysctl.c文�g解释�Q?/p>
number of unprocessed input packets before kernel starts dropping them, default 300

我所理解的含义，每个�|�络接口接收数据包的速率比内核处理这些包的速率快时�Q�允�?d��ng)R��到队列的最大数目，一旦超�q�将被丢弃�?/p>
所起作用处�Q�net/core/Dev.c�Q?/p>
int netif_rx(struct sk_buff *skb) { struct softnet_data *queue; unsigned long flags; /* if netpoll wants it, pretend we never saw it */ if (netpoll_rx(skb)) return NET_RX_DROP; if (!skb->tstamp.off_sec) net_timestamp(skb); /* * The code is rearranged so that the path is the most * short when CPU is congested, but is still operating. */ local_irq_save(flags); queue = &__get_cpu_var(softnet_data); __get_cpu_var(netdev_rx_stat).total++; if (queue->input_pkt_queue.qlen <= netdev_max_backlog) { if (queue->input_pkt_queue.qlen) { enqueue: dev_hold(skb->dev); __skb_queue_tail(&queue->input_pkt_queue, skb); local_irq_restore(flags); return NET_RX_SUCCESS; } netif_rx_schedule(&queue->backlog_dev); goto enqueue; } __get_cpu_var(netdev_rx_stat).dropped++; local_irq_restore(flags); kfree_skb(skb); return NET_RX_DROP; }

以上代码看一下，大概�?x��)明白netdev_max_backlog�?x��)在什么时候�v作用�?/p>

nieyong 2014-07-30 17:22 发表评论

nieyong — Sat, 28 Jun 2014 06:15:00 GMT

前言

公司内技术分享文档，不涉�?qi��ng)公司内部技术等�Q�可以拿出来分��n一下�?/p>
演示文档

讉K��地址�Q?a >https://speakerdeck.com/yongboy/linuxxi-tong-fu-wu-duan-kou-de-na-xie-shi

有些�_�糙�Q�有些点可能未表达清楚，�(zh��n)�若发现谬误之处�Q�欢�q�及(qi��ng)时指出�?/p>

nieyong 2014-06-28 14:15 发表评论

nieyong — Fri, 28 Jun 2013 08:56:00 GMT

《让�|�页加蝲快一些》，�q�篇PPT演示文档�Q�目的在于扩大视野用�Q�没有涉�?qi��ng)到深度�Q�，便于在处理网��|��能优化�Ӟ��Z��些同事提供一些处理思�\�Q�避免到处撞墙�?br />
目标�Q?br />
如何让一个页面加载快一些，�q�是主题
��面每经�q�一个环节，都会(x��)��单涉�?br /> 覆盖面广(前前后后都有)�Q�但蜻蜓�Ҏ(gu��)��
可能�?x��)增加些视野�Q�目的也��p��C��(ji��n)�Q?br /> 前期不要做优化，但需要做规划�Q?br />

豆丁地址�Q?br />
http://www.docin.com/p-671771410.html

nieyong 2013-06-28 16:56 发表评论

nieyong — Wed, 24 Oct 2012 10:14:00 GMT

套接字模�?/strong>

��d��模式�Q�选项{active, true}�Q�一般让人很喜欢�Q�非��d��消息接收�Q�但在系�l�无法应对超大流量请求时�Q�客��L(f��ng)��发送的数据快过服务器可以处理的速度�Q�那么系�l�就可能�?x��)造成消息�~�冲��塞满�Q�可能出现持�l�繁忙的��量的极端情况下�Q�系�l�因��h��而溢出，虚拟机造成内存?sh��)��的风险而崩溃�?/p>
使用被动模式�Q�选项{active, false}�Q�的套接字，底层的TCP�~�冲区可用于抑制��h��Q��ƈ拒绝客户端的消息�Q�在接收数据的地斚w��?x��)调用gen_tcp:recv�Q�造成��d��Q�单�q�程模式下就只能消极�{�待某一个具体的客户端套接字�Q�很危险�Q�。需要注意的是，操作�pȝ��可能�q��(sh��)��(x��)做一些缓存允许客��L(f��ng)��机器�l�箋(hu��)发送少量数据，然后才会(x��)��其��d��Q�此时Erlang��未调用recv函数�?/p>
混合型模式（半阻塞）(j��)�Q��用选项{active, once}打开�Q�主动仅针对一个消息，在控制进�E�发送完一个数据消息后�Q�必��L��C��用inet:setopts(Socket, [{active, once}])重新�Ȁ�z�M��便接受下一个消息（在此之前�Q�系�l�处于阻塞状态）(j��)。可见，混合型模式综合了(ji��n)��d��模式和被动模式的两者优势，可实现流量控�Ӟ��防止服务器被�q�多消息�Ҏ(gu��)��?/p>
以下TCP Server代码�Q�都是徏立在混合型模式（半阻塞）(j��)基础上�?/p>
prim_inet相关说明

prim_inet没有官方文档�Q�可以认为是对底层socket的直接包装。淘�?a target="_blank">yufeng��_(d��)��q�是otp内部实现的细�?是针对Erlang库开发者的private module�Q�底层模块，不推荐��用。但�?a target="_blank">Building a Non-blocking TCP server using OTP principles�C��中演�C�Z��(ji��n)prim_inet操作Socket异步�Ҏ(gu��)��?/p>
设计模式

一般来��_(d��)��需要一个单独进�E�进行客��L(f��ng)��套接字监听，每一个子�q�程�q�行处理来自具体客户端的socket��h��?/p>
�?a target="_blank">Building a Non-blocking TCP server using OTP principles�C��中，子进�E��用gen_fsm处理�Q�很巧妙的结合状态机和消息事�Ӟ��值得学习(f��n)�?/p>
�?a target="_blank">Erlang: A Generalized TCP Server文章中，作者也是��用此模式�Q�但子进�E�不�W�合OTP规范�Q�因此个��Z��是一个很好的实践模式�?/p>
simple_one_for_one

��易的一对一监督�q�程�Q�用来创��Z��l�动态子�q�程。对于需要�ƈ发处理多个请求的服务器较为合适。比如socket 服务端接受新的客��L(f��ng)��q�接��h��以后�Q�需要动态创��Z��个新的socket�q�接处理子进�E�。若遵守OTP原则�Q�那��是子监督进�E��?/p>
TCP Server实现

��Z��标准API��单实�?/strong>

也是��Z��{active, once}模式�Q�但��d��的等待下一个客��L(f��ng)��q�接的�Q务被抛给�?ji��n)子监督�q�程�?/p>
看一下入口tcp_server_app�?/p>
��d��端口�Q�然后启动主监督�q�程�Q�此时还?sh��)��?x��)监听处理客户端socket��h��Q�，紧接着启动子监督进�E�，开始处理来自客��L(f��ng)��的socket的连接�?/p>
监督�q�程tcp_server_sup也很��单：(x��)

需要注意的是，只有调用start_child函数�Ӟ��才真正调用tcp_server_handler:start_link([LSock])函数�?/p>
tcp_server_handler的代码也不复杂：(x��)

代码很精巧，有些��技巧在里面。子监督�q�程调用start_link函数�Q�init�?x��)返回{ok, #state{lsock = Socket}, 0}. 数字0代表�?ji��n)timeout数��|��意味着gen_server马上调用handle_info(timeout, #state{lsock = LSock} = State)函数�Q�执行客��L(f��ng)��socket监听�Q�阻塞于此，但不�?x��)�?ji��ng)响在此模式下其它函数的调用。直到有客户端进来，然后启动一个新的子监督�q�程tcp_server_handler�Q�当前子监督�q�程解除��d��?/p>

��Z��prim_inet实现

�q�个实现师从于Non-blocking TCP server using OTP principles一文，但子�q�程改�ؓ(f��)�?ji��n)gen_server实现�?/p>
看一看入口，很简单的�Q?/p>
监督�q�程代码�Q?/p>
�{�略不一��P��one_for_one包括�?ji��n)一个监听进�E�tcp_listener�Q�还包含�?ji��n)一个tcp_client_sup�q�程�?simple_one_for_one�{�略)

tcp_listener单独一个进�E�用于监听来自客��L(f��ng)��socket的连�?

很显�?d��ng)��接收客户端的�q�接之后�Q��{交给tcp_client_handler模块�q�行处理�Q?/p>
和标准API�Ҏ(gu��)��一下，可以感受到异步IO的好处�?/p>
��结

通过不同的模式，��单实��C��个基于Erlang OTP的TCP服务器，也是学习(f��n)�ȝ��Q�不至于忘记�?/p>
�(zh��n)�若有更好的��Q�欢�q�告知，谢谢�?/p>
参考资�?/strong>

Building a Non-blocking TCP server using OTP principles

Erlang: A Generalized TCP Server

《Erlang�E�序设计�?/li>
《Erlang/OTP�q�发�~�程实战�?/li>

nieyong 2012-10-24 18:14 发表评论

Types	Accept queue	Conn. Locality	Socket API	Event Handling	Packet I/O	Application Mod- ification	Kernel Modification
PSIO , DPDK , PF RING , netmap	No TCP stack				Batched	No interface for transport layer	No (NIC driver)
Linux-2.6	Shared	None	BSD socket	Syscalls	Per packet	Transparent	No
Linux-3.9	Per-core	None	BSD socket	Syscalls	Per packet	Add option SO REUSEPORT	No
Affinity-Accept	Per-core	Yes	BSD socket	Syscalls	Per packet	Transparent	Yes
MegaPipe	Per-core	Yes	lwsocket	Batched syscalls	Per packet	Event model to completion I/O	Yes
FlexSC,VOS	Shared	None	BSD socket	Batched syscalls	Per packet	Change to use new API	Yes
mTCP	Per-core	Yes	User-level socket	Batched function calls	Batched	Socket API to mTCP API	No (NIC driver)
Fastsocket	Per-core	Yes	BSD socket	Ioctl + kernel calls	Per packet	Transparent	No

	RSS (Receive Side Scaling)	RPS (Receive Packet Steering)	RFS (Receive Flow Steering)	Accelerated RFS (Accelerated Receive Flow Steering)	XPS (Transmit Packet Steering)
解决问题	�\|�卡和驱动支�?/td>	软�g方式实现RSS	数据包��生的中断和应用处理在同一个CPU�?/td>	��Z��RFS��g加速的负蝲�q��机制	��选择�\|�卡多队列的队列快速发�?/td>
内核支持	2.6.36开始引入，需要硬件支�?/td>	2.6.35	2.6.35	2.6.35	2.6.38
��	�\|�卡队列数和物理核数一�?/td>	��x(ch��ng)��多队列的�\|�卡若RSS已经配置�?ji��n)，则不需要RPS�?/td>	需要rps_sock_flow_entries和rps_flow_cnt属�?/td>	需要网卡设备和驱动都支持加速。�ƈ且要求ntuple�q��o(h��)已经通过ethtool启用	单传输队列的�\|�卡无效�Q�若队列比CPU��，�׃�n指定队列的CPU最好是与处理传输硬中断的CPU�׃�n�~�存的CPU
fastsocket	�\|�卡�Ҏ(gu��)�?/td>	改进版RPS�Q�性能提升	源码包含�Q�文档没有涉�?/td>	文档没有涉及(qi��ng)	要求发送队列数要大于CPU核数
传送方�?/td>	�\|�卡接收	内核接收	CPU接收处理	加速�ƈ接收	�\|�卡发送数�?/td>

�q�行方式	处理消耗时�?�U?	处理��L��	�q�_��每秒处理�?/th>	最大�?/th>
单独�q�行	34s	80270	2361	2674
加蝲fasocket	28s	80399	2871	2964

�q�行方式	处理消耗时�?�U?	处理��L��	�q�_��每秒处理�?/th>	最大�?/th>
�W�一�ơ测试后�?/td>	44s	80189	1822	2150
�W�一�ơ测试代�?/td>	44s	80189	1822	2152
�W�二�ơ测试后�?/td>	42s	80051	1906	2188
�W�二�ơ测试代�?/td>	42s	80051	1906	2167

伊人久久综在合线亚洲91,久久久久亚洲AV无码专区网站 ,337P日本欧洲亚洲大胆精品

SO_REUSEPORT学习(f��n)�W�记补遗

前言

SO_REUSADDR VS SO_REUSEPORT

Netty多线�E���用SO_REUSEPORT

���结

SO_REUSEPORT学习(f��n)�W�记

前言

当前Linux�|�络应用�E�序问题

新特性测试或多个版本共存

服务器无�~�重�?切换

SO_REUSEPORT已知问题

支持SO_REUSEPORT的Tengine

Java支持否？

使用�C����

bindp的��用方�?/h4> 更多使用说明�Q�请参�?a >README�?/p>

参考资�?/h3> 《SO_REUSEPORT: Scaling Techniques for Servers with High Connection Rates》PPT huptime SO_REUSEPORT and accept(2) performance 多个�q�程�l�定相同端口的实现分析[Google Patch]

Fastsocket学习(f��n)�W�记之小�l�篇

前言

内核3.9之前的Linux TCP调用

Linux�|�络堆栈所存在问题

Fastsocket短连接性能

HAProxy重要配置

长连接的支持正在开发中

Redis���试�l�果

Fastsocket v1.1

以后一些优化措�?/h3> 在上下文切换�Ӟ��避免拯���操作�Q�Zero-Copy 中断机制完善�Q�减���中�? 支持扚w��提交�Q�降低系�l�函数调�? 提交到Linux kernel��d��支上�? HugeTLB/HugePage�{?

部��v���试

���结

资源引用

Fastsocket学习(f��n)�W�记之内核篇

前言

Fastsocket架构�?/h3> 下面按照其架构图所�C�内核层面从上到下一一列出�?/p>

Local Listen Table

Local Established Table

Receive Flow Deliver

���结

引用资料�Q?/h3> Fastsocket PPT FastSocket

Fastsocket学习(f��n)�W�记之模块篇

前言

模块介绍

VFS 优化

内核模块参数

enable_listen_spawn

enable_fast_epoll

enable_receive_flow_deliver

libfsocket.so如何与fastsocket内核模块交互

���结

前言

介绍

�~�译

用法

内部构�g

源码一�?/h3> fastsocket/library用于构徏libfsocket.so动态链接库�Q�主要组成：(x��) Makefile �~�译脚本 libsocket.h 头文�Ӟ��定义变量、结构等 libsocket.c 动态链接库实现

libsocket.h

���结

Fastsocket学习(f��n)�W�记之网卡设�|�篇

前言

�|�卡讄������翻译原�?/h3>

介绍

相关配置

中断阀速率

RPS

XPS

IPTABLES

nic.sh脚本脚本分析

���结

Fastsocket学习(f��n)�W�记之安装篇

前言

�~�译安装f(xi��)astsocket内核

�~�译安装

配置启动旉���要切换的内核

���结

Fastsocket学习(f��n)�W�记之示范应用篇

前言

介绍

构徏

用法

实例

代理模式�C����

Netty多线�E��用SO_REUSEPORT

��结

使用�C��

bindp的��用方�?/h4>
更多使用说明�Q�请参�?a >README�?/p>

参考资�?/h3>

《SO_REUSEPORT: Scaling Techniques for Servers with High Connection Rates》PPT

huptime

SO_REUSEPORT and accept(2) performance

多个�q�程�l�定相同端口的实现分析[Google Patch]

Redis��试�l�果

以后一些优化措�?/h3>

在上下文切换�Ӟ��避免拯��操作�Q�Zero-Copy
中断机制完善�Q�减��中�?
支持扚w��提交�Q�降低系�l�函数调�?
提交到Linux kernel��d��支上�?
HugeTLB/HugePage�{?

部��v��试

��结

Fastsocket架构�?/h3>

下面按照其架构图所�C�内核层面从上到下一一列出�?/p>

��结

引用资料�Q?/h3>

Fastsocket PPT
FastSocket

��结

源码一�?/h3>
fastsocket/library用于构徏`libfsocket.so`动态链接库�Q�主要组成：(x��)

Makefile �~�译脚本
libsocket.h 头文�Ӟ��定义变量、结构等
libsocket.c 动态链接库实现

��结

�|�卡讄��翻译原�?/h3>

`nic.sh`脚本脚本分析

��结

配置启动旉��要切换的内核

��结

代理模式�C��

服务器模式对�?/h4>
两组数据�Ҏ(gu��)��Q?/p>

�q�行方式处理消耗时�?�U? 处理��L�� q�_��每秒处理�?/th> 最大�?/th>

单独�q�行 34s 80270 2361 2674

加蝲fasocket 28s 80399 2871 2964

��结

��结

Android�l�端扩展��器opkg

下蝲opkg�?/h3>
预先把依赖下载到本地:

http://dan.drown.org/android/system/xbin/busybox
http://dan.drown.org/android/opkg.tar.gz

��结

��Z��么批量请求要��可能的合�ƈ操作

pipeline��道方式

�C��

��结

��结

警告输出需要满��的条�g

��结