随笔 - 113  文章 - 1  trackbacks - 0
<2020年5月>
262728293012
3456789
10111213141516
17181920212223
24252627282930
31123456

常用链接

留言簿

随笔分类

随笔档案

收藏夹

调试技巧

搜索

  •  

最新评论

阅读排行榜

评论排行榜

60天内阅读排行

零拷贝介绍

  1. 零拷贝是网络编程的关键, 很多性能优化都需要零拷贝。
  2. 在 Java程序中, 常用的零拷贝方式有m(memory)map[内存映射] 和 sendFile。它们在OS中又是怎样的设计?
  3. NIO中如何使用零拷贝?

NIO 与 传统IO对比

  • 传统IO流程示意图

    1575855435947

    • user context: 用户态
    • kernel context: 内核态
    • User space: 用户空间
    • Kernel space: 内核空间
    • Syscall read: 系统调用读取
    • Syscall write: 系统调用写入
    • Hard drive: 硬件驱动
    • kernel buffer: 内核态缓冲区
    • user buffer: 用户态缓冲区
    • socket buffer: 套接字缓存
    • protocol engine: 协议引擎
    • DMA: Direct Memory Access: 直接内存拷贝(不使用CPU)
    • 总结: 4次拷贝, 3次状态切换, 效率不高
  • mmap优化流程示意图

    1575855870723

    • mmap 通过内存映射, 将文件映射到内核缓冲区, 同时, 用户空间可以共享内核空间的数据。
    • 这样, 在进行网络传输时, 就可以减少内核空间到用户空间的拷贝次数。
    • 总结: 3次拷贝, 3次状态切换, 不是真正意义上的零拷贝。
  • sendFile Linux2.1版本优化流程示意图

    1575856449573

    • 数据根本不经过用户态, 直接从内核缓冲区进入到Socket Buffer, 同时, 由于和用户台完全无关, 就减少了一次上下文切换。
    • 但是仍然有一次CPU拷贝, 不是真正的零拷贝(没有CPU拷贝)。
    • 总结: 3次拷贝, 2次切换
  • sendFile Linux

    1575856952257

    • 避免了从内核缓冲区拷贝到Socket buffer的操作, 直接拷贝到协议栈, 从而再一次减少了数据拷贝。
    • 其实是有一次cpu拷贝的, kernel buffer -> socket buffer, 但是拷贝的信息很少, length, offset, 消耗低, 基本可以忽略。
    • 总结: 2次拷贝(如果忽略消耗低的cpu拷贝的话), 2次切换, 基本可以认为是零拷贝了。

零拷贝理解

  • 零拷贝是从操作系统的角度来看的。内核缓冲区之间, 没有数据是重复的(只有kernel buffer有一份数据)。
  • 零拷贝不仅仅带来更少的数据复制, 还能带来其他的性能优势: 如更少的上下文切换, 更少的 CPU 缓存伪共享以及无CPU校验和计算。

mmap 与 sendFile 总结

  • mmap适合小数据两读写, sendFile适合大文件传输
  • mmap 需要3次上下文切换, 3次数据拷贝; sendFile 需要3次上下文切换, 最少2次数据拷贝。
  • sendFile 可以利用 DMA 方式, 减少 CPU 拷贝, 而 mmap则不能(必须从内核拷贝到Socket缓冲区)。
posted @ 2020-05-14 11:27 长戟十三千 阅读(8) | 评论 (0)编辑 收藏
     摘要: 关于TCP连接的TIME-WAIT状态,它是为何而生,存在的意义是什么?    让我们回忆一下,什么是TCP TIME-WAIT状态?如下图    当TCP连接关闭之前,首先发起关闭的一方会进入TIME_WAIT状态(也就是主动关闭连接的一方才会产生TIME_WAIT),另一方可以快速回收连接。可以用ss -tan来查...  阅读全文
posted @ 2020-05-09 17:06 长戟十三千 阅读(5) | 评论 (0)编辑 收藏
string(REGEX REPLACE "(.*)/(.*)/(.*)" "\\1" PROJECT_INIT_PATH  ${PROJECT_SOURCE_DIR})
message("上层目录=" $(PROJECT_INIT_PATH))

举例:
PROJECT_SOURCE_DIR=/home/1/2/3/4
用正则表达式对目录进行匹配,最后一次匹配结果:
(/home/1/2)/(3)/(4)  
string(REGEX REPLACE "(.*)/(.*)/(.*)" "\\1" PROJECT_INIT_PATH  ${PROJECT_SOURCE_DIR}) 结果:/home/1/2
string(REGEX REPLACE "(.*)/(.*)/(.*)" "\\2" PROJECT_INIT_PATH  ${PROJECT_SOURCE_DIR}) 结果:3
string(REGEX REPLACE "(.*)/(.*)/(.*)" "\\3" PROJECT_INIT_PATH  ${PROJECT_SOURCE_DIR}) 结果:4
posted @ 2020-05-06 17:09 长戟十三千 阅读(9) | 评论 (0)编辑 收藏

1、 time_wait的作用:

复制代码
TIME_WAIT状态存在的理由: 1可靠地实现TCP全双工连接的终止    在进行关闭连接四次挥手协议时,最后的ACK是由主动关闭端发出的,如果这个最终的ACK丢失,服务器将重发最终的FIN, 因此客户端必须维护状态信息允许它重发最终的ACK。如果不维持这个状态信息,那么客户端将响应RST分节,服务器将此分节解释成一个错误(在java中会抛出connection reset的SocketException)。 因而,要实现TCP全双工连接的正常终止,必须处理终止序列四个分节中任何一个分节的丢失情况,主动关闭的客户端必须维持状态信息进入TIME_WAIT状态。   2允许老的重复分节在网络中消逝  TCP分节可能由于路由器异常而“迷途”,在迷途期间,TCP发送端可能因确认超时而重发这个分节,迷途的分节在路由器修复后也会被送到最终目的地,这个原来的迷途分节就称为lost duplicate。 在关闭一个TCP连接后,马上又重新建立起一个相同的IP地址和端口之间的TCP连接,后一个连接被称为前一个连接的化身(incarnation),那么有可能出现这种情况,前一个连接的迷途重复分组在前一个连接终止后出现,从而被误解成从属于新的化身。 为了避免这个情况,TCP不允许处于TIME_WAIT状态的连接启动一个新的化身,因为TIME_WAIT状态持续2MSL,就可以保证当成功建立一个TCP连接的时候,来自连接先前化身的重复分组已经在网络中消逝。
复制代码

2、大量TIME_WAIT造成的影响:

      在高并发短连接的TCP服务器上,当服务器处理完请求后立刻主动正常关闭连接。这个场景下会出现大量socket处于TIME_WAIT状态。如果客户端的并发量持续很高,此时部分客户端就会显示连接不上。
我来解释下这个场景。主动正常关闭TCP连接,都会出现TIMEWAIT。

为什么我们要关注这个高并发短连接呢?有两个方面需要注意:
1. 高并发可以让服务器在短时间范围内同时占用大量端口,而端口有个0~65535的范围,并不是很多,刨除系统和其他服务要用的,剩下的就更少了。
2. 在这个场景中,短连接表示“业务处理+传输数据的时间 远远小于 TIMEWAIT超时的时间”的连接

      这里有个相对长短的概念,比如取一个web页面,1秒钟的http短连接处理完业务,在关闭连接之后,这个业务用过的端口会停留在TIMEWAIT状态几分钟,而这几分钟,其他HTTP请求来临的时候是无法占用此端口的(占着茅坑不拉翔)。单用这个业务计算服务器的利用率会发现,服务器干正经事的时间和端口(资源)被挂着无法被使用的时间的比例是 1:几百,服务器资源严重浪费。(说个题外话,从这个意义出发来考虑服务器性能调优的话,长连接业务的服务就不需要考虑TIMEWAIT状态。同时,假如你对服务器业务场景非常熟悉,你会发现,在实际业务场景中,一般长连接对应的业务的并发量并不会很高
     综合这两个方面,持续的到达一定量的高并发短连接,会使服务器因端口资源不足而拒绝为一部分客户服务。同时,这些端口都是服务器临时分配,无法用SO_REUSEADDR选项解决这个问题。

关于time_wait的反思

存在即是合理的,既然TCP协议能盛行四十多年,就证明他的设计合理性。所以我们尽可能的使用其原本功能。 依靠TIME_WAIT状态来保证我的服务器程序健壮,服务功能正常。 那是不是就不要性能了呢?并不是。如果服务器上跑的短连接业务量到了我真的必须处理这个TIMEWAIT状态过多的问题的时候,我的原则是尽量处理,而不是跟TIMEWAIT干上,非先除之而后快。 如果尽量处理了,还是解决不了问题,仍然拒绝服务部分请求,那我会采取负载均衡来抗这些高并发的短请求。持续十万并发的短连接请求,两台机器,每台5万个,应该够用了吧。一般的业务量以及国内大部分网站其实并不需要关注这个问题,一句话,达不到时才需要关注这个问题的访问量。

小知识点:

TCP协议发表:1974年12月,卡恩、瑟夫的第一份TCP协议详细说明正式发表。当时美国国防部与三个科学家小组签定了完成TCP/IP的协议,结果由瑟夫领衔的小组捷足先登,首先制定出了通过详细定义的TCP/IP协议标准。当时作了一个试验,将信息包通过点对点的卫星网络,再通过陆地电缆
,再通过卫星网络,再由地面传输,贯串欧洲和美国,经过各种电脑系统,全程9.4万公里竟然没有丢失一个数据位,远距离的可靠数据传输证明了TCP/IP协议的成功。

 

3、案列分析:

    首先,根据一个查询TCP连接数,来说明这个问题。

复制代码
netstat -ant|awk '/^tcp/ {++S[$NF]} END {for(a in S) print (a,S[a])}' LAST_ACK 14 SYN_RECV 348 ESTABLISHED 70 FIN_WAIT1 229 FIN_WAIT2 30 CLOSING 33 TIME_WAIT 18122
复制代码

状态描述:

复制代码
CLOSED:无连接是活动的或正在进行 LISTEN:服务器在等待进入呼叫 SYN_RECV:一个连接请求已经到达,等待确认 SYN_SENT:应用已经开始,打开一个连接 ESTABLISHED:正常数据传输状态 FIN_WAIT1:应用说它已经完成 FIN_WAIT2:另一边已同意释放 ITMED_WAIT:等待所有分组死掉 CLOSING:两边同时尝试关闭 TIME_WAIT:另一边已初始化一个释放 LAST_ACK:等待所有分组死掉
复制代码

命令解释:

复制代码
先来看看netstat: netstat -n Active Internet connections (w/o servers) Proto Recv-Q Send-Q Local Address Foreign Address State tcp 0 0 123.123.123.123:80 234.234.234.234:12345 TIME_WAIT 你实际执行这条命令的时候,可能会得到成千上万条类似上面的记录,不过我们就拿其中的一条就足够了。  再来看看awk: /^tcp/ 滤出tcp开头的记录,屏蔽udp, socket等无关记录。 state[]相当于定义了一个名叫state的数组 NF 表示记录的字段数,如上所示的记录,NF等于6 $NF 表示某个字段的值,如上所示的记录,$NF也就是$6,表示第6个字段的值,也就是TIME_WAIT state[$NF]表示数组元素的值,如上所示的记录,就是state[TIME_WAIT]状态的连接数 ++state[$NF]表示把某个数加一,如上所示的记录,就是把state[TIME_WAIT]状态的连接数加一 END 表示在最后阶段要执行的命令 for(key in state) 遍历数组
复制代码

 

如何尽量处理TIMEWAIT过多?

编辑内核文件/etc/sysctl.conf,加入以下内容:

net.ipv4.tcp_syncookies = 1 表示开启SYN Cookies。当出现SYN等待队列溢出时,启用cookies来处理,可防范少量SYN攻击,默认为0,表示关闭; net.ipv4.tcp_tw_reuse = 1 表示开启重用。允许将TIME-WAIT sockets重新用于新的TCP连接,默认为0,表示关闭; net.ipv4.tcp_tw_recycle = 1 表示开启TCP连接中TIME-WAIT sockets的快速回收,默认为0,表示关闭。 net.ipv4.tcp_fin_timeout 修改系默认的 TIMEOUT 时间

然后执行 /sbin/sysctl -p 让参数生效.

/etc/sysctl.conf是一个允许改变正在运行中的Linux系统的接口,它包含一些TCP/IP堆栈和虚拟内存系统的高级选项,修改内核参数永久生效。

简单来说,就是打开系统的TIMEWAIT重用和快速回收。

如果以上配置调优后性能还不理想,可继续修改一下配置:

复制代码
vi /etc/sysctl.conf net.ipv4.tcp_keepalive_time = 1200  #表示当keepalive起用的时候,TCP发送keepalive消息的频度。缺省是2小时,改为20分钟。 net.ipv4.ip_local_port_range = 1024 65000  #表示用于向外连接的端口范围。缺省情况下很小:32768到61000,改为1024到65000。 net.ipv4.tcp_max_syn_backlog = 8192  #表示SYN队列的长度,默认为1024,加大队列长度为8192,可以容纳更多等待连接的网络连接数。 net.ipv4.tcp_max_tw_buckets = 5000  #表示系统同时保持TIME_WAIT套接字的最大数量,如果超过这个数字,TIME_WAIT套接字将立刻被清除并打印警告信息。 默认为180000,改为5000。对于Apache、Nginx等服务器,上几行的参数可以很好地减少TIME_WAIT套接字数量,但是对于 Squid,效果却不大。此项参数可以控制TIME_WAIT套接字的最大数量,避免Squid服务器被大量的TIME_WAIT套接字拖死。
复制代码

 

posted @ 2020-04-24 16:18 长戟十三千 阅读(14) | 评论 (0)编辑 收藏
2.。。

1、listen fd,有新连接请求,对端发送普通数据 触发EPOLLIN。
2、带外数据,只触发EPOLLPRI。
3、对端正常关闭(程序里close(),shell下kill或ctr+c),触发EPOLLIN和EPOLLRDHUP,但是不触发EPOLLERR 和EPOLLHUP。
再man epoll_ctl看下后两个事件的说明,这两个应该是本端(server端)出错才触发的。
5、对端异常断开连接(只测了拔网线),没触发任何事件。

附man:

EPOLLIN       连接到达;有数据来临;
The associated file is available for read(2) operations.
EPOLLOUT      有数据要写
The associated file is available for write(2) operations.
EPOLLRDHUP    这个好像有些系统检测不到,可以使用EPOLLIN,read返回0,删除掉事件,关闭close(fd);
如果有EPOLLRDHUP,检测它就可以直到是对方关闭;否则就用上面方法。
Stream socket peer closed connection, or shut down writing half
of connection. (This flag is especially useful for writing sim-
ple code to detect peer shutdown when using Edge Triggered moni-
toring.)
EPOLLPRI      外带数据
There is urgent data available for read(2) operations.

              
EPOLLERR      只有采取动作时,才能知道是否对方异常。即对方突然断掉,是不可能
有此事件发生的。只有自己采取动作(当然自己此刻也不知道),read,write时,出EPOLLERR错,说明对方已经异常断开。

EPOLLERR 是服务器这边出错(自己出错当然能检测到,对方出错你咋能知道啊)

关于 EPOLLERR:
socket能检测到对方出错吗?目前为止,好像我还不知道如何检测。
但是,在给已经关闭的socket写时,会发生EPOLLERR,也就是说,只有在采取行动(比如
读一个已经关闭的socket,或者写一个已经关闭的socket)时候,才知道对方是否关闭了。
这个时候,如果对方异常关闭了,则会出现EPOLLERR,出现Error把对方DEL掉,close就可以
了。

3.各类事件

1)监听的fd,此fd的设置等待事件:
EPOLLIN ;或者EPOLLET |EPOLLIN 
  由于此socket只监听有无连接,谈不上写和其他操作。
故只有这两类。(默认是LT模式,即EPOLLLT |EPOLLIN)。

  说明:如果在这个socket上也设置EPOLLOUT等,也不会出错,
只是这个socket不会收到这样的消息。

2)客户端正常关闭
client 端close()联接

server 会报某个sockfd可读,即epollin来临。 
然后recv一下 , 如果返回0再掉用epoll_ctl 中的EPOLL_CTL_DEL , 同时close(sockfd)。

有些系统会收到一个EPOLLRDHUP,当然检测这个是最好不过了。只可惜是有些系统,
上面的方法最保险;如果能加上对EPOLLRDHUP的处理那就是万能的了。

3)客户端异常关闭:

客户端异常关闭,并不会通知服务器(如果会通知,以前的socket当然会有与此相关
的api)。正常关闭时read到0后,异常断开时检测不到的。服务器再给一个已经关闭
的socket写数据时,会出错,这时候,服务器才明白对方可能已经异常断开了(读也
可以)。

Epoll中就是向已经断开的socket写或者读,会发生EPollErr,即表明已经断开。

4)EpollIn:

5)监听的skocket只需要EpollIn就足够了,EpollErr和EpollHup会自动加上。
监听的socket又不会写,一个EpollIn足矣。

4. 补充 EpollErr

当客户端的机器在发送“请求”前,就崩溃了(或者网络断掉了),则服务器一端是无从知晓的。

按照你现在的这个“请求响应方式”,无论是否使用epoll,都必须要做超时检查。

因此,这个问题与epoll无关。EpollErr这种错误必须是有动作才能检测出来。
服务器不可能经常的向客户端写一个东西,依照有没有EpollErr来判断客户端是不是死了。

因此,服务器中的超时检查是很重要的。这也是以前服务器中作死后确认的原因。
新的代码里也是时间循环,时间循环....

!!!服务器 中的超时检查!!!很重要

posted @ 2020-04-24 14:36 长戟十三千 阅读(17) | 评论 (0)编辑 收藏
     摘要:  =================                         LINUX内核内存屏障                     ...  阅读全文
posted @ 2020-04-24 10:51 长戟十三千 阅读(5) | 评论 (0)编辑 收藏
     摘要: 关于无锁队列的实现,网上有很多文章,虽然本文可能和那些文章有所重复,但是我还是想以我自己的方式把这些文章中的重要的知识点串起来和大家讲一讲这个技术。下面开始正文。目录关于CAS等原子操作无锁队列的链表实现CAS的ABA问题解决ABA的问题用数组实现无锁队列 小结关于CAS等原子操作在开始说无锁队列之前,我们需要知道一个很重要的技术就是CAS操作——Compare ...  阅读全文
posted @ 2020-04-23 17:49 长戟十三千 阅读(23) | 评论 (0)编辑 收藏
Linux kernel里面从来就不缺少简洁,优雅和高效的代码,只是我们缺少发现和品味的眼光。在Linux kernel里面,简洁并不表示代码使用神出鬼没的超然技巧,相反,它使用的不过是大家非常熟悉的基础数据结构,但是kernel开发者能从基础的数据结构中,提炼出优美的特性。 
kfifo就是这样的一类优美代码,它十分简洁,绝无多余的一行代码,却非常高效。 
关于kfifo信息如下:
本文分析的原代码版本: 2.6.24.4
kfifo的定义文件: kernel/kfifo.c
kfifo的头文件: include/linux/kfifo.h
kfifo概述
kfifo是内核里面的一个First In First Out数据结构,它采用环形循环队列的数据结构来实现;它提供一个无边界的字节流服务,最重要的一点是,它使用并行无锁编程技术,即当它用于只有一个入队线程和一个出队线程的场情时,两个线程可以并发操作,而不需要任何加锁行为,就可以保证kfifo的线程安全。 
kfifo代码既然肩负着这么多特性,那我们先一敝它的代码:
struct kfifo {
    unsigned char *buffer;    /* the buffer holding the data */
    unsigned int size;    /* the size of the allocated buffer */
    unsigned int in;    /* data is added at offset (in % size) */
    unsigned int out;    /* data is extracted from off. (out % size) */
    spinlock_t *lock;    /* protects concurrent modifications */
};
1
2
3
4
5
6
7
这是kfifo的数据结构,kfifo主要提供了两个操作,__kfifo_put(入队操作)和__kfifo_get(出队操作)。 它的各个数据成员如下:
buffer: 用于存放数据的缓存
size: buffer空间的大小,在初化时,将它向上扩展成2的幂
lock: 如果使用不能保证任何时间最多只有一个读线程和写线程,需要使用该lock实施同步。
in, out: 和buffer一起构成一个循环队列。 in指向buffer中队头,而且out指向buffer中的队尾,它的结构如示图如下:
+--------------------------------------------------------------+
|            |<----------data---------->|                      |
+--------------------------------------------------------------+
             ^                          ^                      ^
             |                          |                      |
            out                        in                     size
1
2
3
4
5
6
当然,内核开发者使用了一种更好的技术处理了in, out和buffer的关系,我们将在下面进行详细分析。
kfifo功能描述
kfifo提供如下对外功能规格
只支持一个读者和一个读者并发操作
无阻塞的读写操作,如果空间不够,则返回实际访问空间
kfifo_alloc 分配kfifo内存和初始化工作
struct kfifo *kfifo_alloc(unsigned int size, gfp_t gfp_mask, spinlock_t *lock)
{
    unsigned char *buffer;
    struct kfifo *ret;
    /*
     * round up to the next power of 2, since our 'let the indices
     * wrap' tachnique works only in this case.
     */
    if (size & (size - 1)) {
        BUG_ON(size > 0x80000000);
        size = roundup_pow_of_two(size);
    }
    buffer = kmalloc(size, gfp_mask);
    if (!buffer)
        return ERR_PTR(-ENOMEM);
    ret = kfifo_init(buffer, size, gfp_mask, lock);
    if (IS_ERR(ret))
        kfree(buffer);
    return ret;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
这里值得一提的是,kfifo->size的值总是在调用者传进来的size参数的基础上向2的幂扩展,这是内核一贯的做法。这样的好处不言而喻——对kfifo->size取模运算可以转化为与运算,如下:
kfifo->in % kfifo->size 可以转化为 kfifo->in & (kfifo->size – 1)
在kfifo_alloc函数中,使用size & (size – 1)来判断size 是否为2幂,如果条件为真,则表示size不是2的幂,然后调用roundup_pow_of_two将之向上扩展为2的幂。
这都是常用的技巧,只不过大家没有将它们结合起来使用而已,下面要分析的__kfifo_put和__kfifo_get则是将kfifo->size的特点发挥到了极致。
__kfifo_put和__kfifo_get巧妙的入队和出队
__kfifo_put是入队操作,它先将数据放入buffer里面,最后才修改in参数;__kfifo_get是出队操作,它先将数据从buffer中移走,最后才修改out。你会发现in和out两者各司其职。
下面是__kfifo_put和__kfifo_get的代码
unsigned int __kfifo_put(struct kfifo *fifo,
             unsigned char *buffer, unsigned int len)
{
    unsigned int l;
    len = min(len, fifo->size - fifo->in + fifo->out);
    /*
     * Ensure that we sample the fifo->out index -before- we
     * start putting bytes into the kfifo.
     */
    smp_mb();
    /* first put the data starting from fifo->in to buffer end */
    l = min(len, fifo->size - (fifo->in & (fifo->size - 1)));
    memcpy(fifo->buffer + (fifo->in & (fifo->size - 1)), buffer, l);
    /* then put the rest (if any) at the beginning of the buffer */
    memcpy(fifo->buffer, buffer + l, len - l);
    /*
     * Ensure that we add the bytes to the kfifo -before-
     * we update the fifo->in index.
     */
    smp_wmb();
    fifo->in += len;
    return len;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
奇怪吗?代码完全是线性结构,没有任何if-else分支来判断是否有足够的空间存放数据。内核在这里的代码非常简洁,没有一行多余的代码。
l = min(len, fifo->size - (fifo->in & (fifo->size - 1)));
这个表达式计算当前写入的空间,换成人可理解的语言就是:
l = kfifo可写空间和预期写入空间的最小值
使用min宏来代if-else分支
__kfifo_get也应用了同样技巧,代码如下:
unsigned int __kfifo_get(struct kfifo *fifo,
             unsigned char *buffer, unsigned int len)
{
    unsigned int l;
    len = min(len, fifo->in - fifo->out);
    /*
     * Ensure that we sample the fifo->in index -before- we
     * start removing bytes from the kfifo.
     */
    smp_rmb();
    /* first get the data from fifo->out until the end of the buffer */
    l = min(len, fifo->size - (fifo->out & (fifo->size - 1)));
    memcpy(buffer, fifo->buffer + (fifo->out & (fifo->size - 1)), l);
    /* then get the rest (if any) from the beginning of the buffer */
    memcpy(buffer + l, fifo->buffer, len - l);
    /*
     * Ensure that we remove the bytes from the kfifo -before-
     * we update the fifo->out index.
     */
    smp_mb();
    fifo->out += len;
    return len;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
认真读两遍吧,我也读了多次,每次总是有新发现,因为in, out和size的关系太巧妙了,竟然能利用上unsigned int回绕的特性。
原来,kfifo每次入队或出队,kfifo->in或kfifo->out只是简单地kfifo->in/kfifo->out += len,并没有对kfifo->size 进行取模运算。因此kfifo->in和kfifo->out总是一直增大,直到unsigned in最大值时,又会绕回到0这一起始端。但始终满足:
kfifo->in - kfifo->out <= kfifo->size
即使kfifo->in回绕到了0的那一端,这个性质仍然是保持的。
对于给定的kfifo:
数据空间长度为:kfifo->in - kfifo->out
而剩余空间(可写入空间)长度为:kfifo->size - (kfifo->in - kfifo->out)
尽管kfifo->in和kfofo->out一直超过kfifo->size进行增长,但它对应在kfifo->buffer空间的下标却是如下:
kfifo->in % kfifo->size (i.e. kfifo->in & (kfifo->size - 1))
kfifo->out % kfifo->size (i.e. kfifo->out & (kfifo->size - 1))
往kfifo里面写一块数据时,数据空间、写入空间和kfifo->size的关系如果满足:
kfifo->in % size + len > size
那就要做写拆分了,见下图:
                                                    kfifo_put(写)空间开始地址
                                                    |
                                                   \_/
                                                    |XXXXXXXXXX
XXXXXXXX|                                                    
+--------------------------------------------------------------+
|                        |<----------data---------->|          |
+--------------------------------------------------------------+
                         ^                          ^          ^
                         |                          |          |
                       out%size                   in%size     size
        ^
        |
      写空间结束地址                      
1
2
3
4
5
6
7
8
9
10
11
12
13
14
第一块当然是: [kfifo->in % kfifo->size, kfifo->size] 
第二块当然是:[0, len - (kfifo->size - kfifo->in % kfifo->size)]
下面是代码,细细体味吧:
/* first put the data starting from fifo->in to buffer end */   
l = min(len, fifo->size - (fifo->in & (fifo->size - 1)));   
memcpy(fifo->buffer + (fifo->in & (fifo->size - 1)), buffer, l);   
/* then put the rest (if any) at the beginning of the buffer */   
memcpy(fifo->buffer, buffer + l, len - l);  
1
2
3
4
5
6
对于kfifo_get过程,也是类似的,请各位自行分析。
kfifo_get和kfifo_put无锁并发操作
计算机科学家已经证明,当只有一个读经程和一个写线程并发操作时,不需要任何额外的锁,就可以确保是线程安全的,也即kfifo使用了无锁编程技术,以提高kernel的并发。
kfifo使用in和out两个指针来描述写入和读取游标,对于写入操作,只更新in指针,而读取操作,只更新out指针,可谓井水不犯河水,示意图如下:
                                               |<--写入-->|
+--------------------------------------------------------------+
|                        |<----------data----->|               |
+--------------------------------------------------------------+
                         |<--读取-->|
                         ^                     ^               ^
                         |                     |               |
                        out                   in              size
1
2
3
4
5
6
7
8
为了避免读者看到写者预计写入,但实际没有写入数据的空间,写者必须保证以下的写入顺序:
往[kfifo->in, kfifo->in + len]空间写入数据
更新kfifo->in指针为 kfifo->in + len
在操作1完成时,读者是还没有看到写入的信息的,因为kfifo->in没有变化,认为读者还没有开始写操作,只有更新kfifo->in之后,读者才能看到。
那么如何保证1必须在2之前完成,秘密就是使用内存屏障:smp_mb(),smp_rmb(), smp_wmb(),来保证对方观察到的内存操作顺序。
总结
读完kfifo代码,令我想起那首诗“众里寻他千百度,默然回首,那人正在灯火阑珊处”。不知你是否和我一样,总想追求简洁,高质量和可读性的代码,当用尽各种方法,江郞才尽之时,才发现Linux kernel里面的代码就是我们寻找和学习的对象
————————————————
版权声明:本文为CSDN博主「海枫」的原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接及本声明。
原文链接:https://blog.csdn.net/linyt/article/details/53355355
posted @ 2020-04-23 16:38 长戟十三千 阅读(6) | 评论 (0)编辑 收藏
     摘要: 何为C++对象模型?C++对象模型可以概括为以下2部分:1.        语言中直接支持面向对象程序设计的部分2.        对于各种支持的底层实现机制语言中直接支持面向对象程序设计的部分,如构造函数、析构函数、虚函数、继承(单继承、...  阅读全文
posted @ 2020-04-23 15:56 长戟十三千 阅读(6) | 评论 (0)编辑 收藏
posted @ 2020-04-23 15:55 长戟十三千 阅读(12) | 评论 (0)编辑 收藏
仅列出标题  下一页