精华内容
下载资源
问答
  • linux下socket内核缓冲区大小

    千次阅读 2018-11-29 12:00:47
    本次尝试主要研究 linux socket接受发送缓冲区大小,以及当缓冲区阻塞时,能发送多少数据。 (1)实验与尝试 测试环境: vmware虚拟机 centos7系统。 服务端建立连接后睡眠,应用层不接受任何数据,只有内核...

    本次尝试主要研究 linux socket接受发送缓冲区的大小,以及当缓冲区阻塞时,能发送多少数据。

    (1)实验与尝试

    测试环境: vmware虚拟机 centos7系统。

    服务端建立连接后睡眠,应用层不接受任何数据,只有内核接受缓冲区才接受数据。

    服务端代码如下:

    #include<stdio.h>
    #include<stdlib.h>
    #include<string.h>
    #include<errno.h>
    #include<sys/types.h>
    #include<sys/socket.h>
    #include<netinet/in.h>
    #include<unistd.h>
    
    #define MAXLINE 8096
    
    int main(int argc, char** argv){
        int  listenfd, connfd;
        struct sockaddr_in  servaddr;
        char  buff[MAXLINE];
        FILE *fp;
        int  n;
    
        if( (listenfd = socket(AF_INET, SOCK_STREAM, 0)) == -1 ){
            printf("create socket error: %s(errno: %d)\n",strerror(errno),errno);
            return 0;
        }
        printf("----init socket----\n");
    
        memset(&servaddr, 0, sizeof(servaddr));
        servaddr.sin_family = AF_INET;
        servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
        servaddr.sin_port = htons(6666);
        //设置端口可重用
        int contain;
        setsockopt(listenfd,SOL_SOCKET, SO_REUSEADDR, &contain, sizeof(int));
    
        if( bind(listenfd, (struct sockaddr*)&servaddr, sizeof(servaddr)) == -1){
            printf("bind socket error: %s(errno: %d)\n",strerror(errno),errno);
            return 0;
        }
        printf("----bind sucess----\n");
    
        if( listen(listenfd, 10) == -1){
            printf("listen socket error: %s(errno: %d)\n",strerror(errno),errno);
            return 0;
        }
        if((fp = fopen("new.txt","ab") ) == NULL )
        {
            printf("File.\n");
            close(listenfd);
            exit(1);
        }
    
        printf("======waiting for client's request======\n");
        while(1){
            struct sockaddr_in client_addr;
            socklen_t size=sizeof(client_addr);
            if( (connfd = accept(listenfd, (struct sockaddr*)&client_addr, &size)) == -1){
                printf("accept socket error: %s(errno: %d)",strerror(errno),errno);
                continue;
            }
    		
    	int s_length;
    	socklen_t optl = sizeof s_length;
    	getsockopt(connfd,SOL_SOCKET,SO_SNDBUF,&s_length,&optl);     
    	printf("server connfd send buffer = %d\n",s_length);                         
    	getsockopt(connfd,SOL_SOCKET,SO_RCVBUF,&s_length,&optl);      
    	printf("server connfd recv buffer = %d\n",s_length);  
    	
    	sleep(300000);	
    	
    	while(1){
    		n = read(connfd, buff, MAXLINE);
    		if(n == 0)
    			break;
    		fwrite(buff, 1, n, fp);
    	}
    	buff[n] = '\0';
    	printf("recv msg from client: %s\n", buff);
    	close(connfd);
    	fclose(fp);
        }
        close(listenfd);
        return 0;
    }
    

    客户端代码如下:

    #include <stdio.h>
    #include <errno.h>
    #include <string.h>
    #include <netdb.h>
    #include <sys/types.h>
    #include <netinet/in.h>
    #include <sys/socket.h>
    #include <stdlib.h>
    #include <unistd.h>
    #include <arpa/inet.h>
    #include <netdb.h>
    #define MAXLINE 8096
    
    int main(int argc, char** argv){
        int   sockfd, len;
        char  buffer[MAXLINE];
        struct sockaddr_in  servaddr;
        FILE *fq;
    
    	/*
        if( argc != 2){
            printf("usage: ./client <ipaddress>\n");
            return 0;
        }
    	*/
        if( (sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0){
            printf("create socket error: %s(errno: %d)\n", strerror(errno),errno);
            return 0;
        }
    	
        memset(&servaddr, 0, sizeof(servaddr));
        servaddr.sin_family = AF_INET;
        servaddr.sin_port = htons(6666);
    	servaddr.sin_addr.s_addr=inet_addr("127.0.0.1");
    	/*
        if( inet_pton(AF_INET, argv[1], &servaddr.sin_addr) <= 0){
            printf("inet_pton error for %s\n",argv[1]);
            return 0;
        }
    	*/
        if( connect(sockfd, (struct sockaddr*)&servaddr, sizeof(servaddr)) < 0){
            printf("connect error: %s(errno: %d)\n",strerror(errno),errno);
            return 0;
        }
    	
    	int s_length;
        socklen_t optl = sizeof s_length;
    	getsockopt(sockfd,SOL_SOCKET,SO_SNDBUF,&s_length,&optl);     //
        printf("client send buffer = %d\n",s_length);                         // 
     
        getsockopt(sockfd,SOL_SOCKET,SO_RCVBUF,&s_length,&optl);      //
        printf("client recv buffer = %d\n",s_length);  
    
    	
        if( ( fq = fopen("/root/socket/all.txt","rb") ) == NULL ){
            printf("File open.\n");
            close(sockfd);
            exit(1);
        }
    
        bzero(buffer,sizeof(buffer));
        int sum = 0;
        int writelen = 0;
        while(!feof(fq)){
            len = fread(buffer, 1, sizeof(buffer), fq);
            writelen = write(sockfd, buffer, len);
    	if(writelen < 0) {
                printf("write.\n");
                break;
            }
    	sum += writelen;	
    	printf("writelen %d sum %d\n",writelen, sum);
        }
        printf("sum %d", sum);
        close(sockfd);
        fclose(fq);
    
        return 0;
    }
    

    运行服务端 效果截图如下:

    客户端截图效果如下

    最后写多少数据进去不同的时期运行结果不是固定的

     

    (3)分析与疑惑:

    客户端与服务端的连接socket 内核发送缓冲区约为2.6M,接收缓冲区为1M,按照以前的想法,文本数据all.txt 的大小约为8.8M,客户端每次向发送缓冲区写如8096字节。按照原来的设想,客户端能写入的字节 = 客户端发送缓冲区大小 + 服务端接收缓冲区大小,约3.6M。事实上客户端写入的字节数均大于4.7M,与设想不符合。

    (3)尝试解决

    尝试使用抓包工具wiresha'rk,查看tcp连接状态以及窗口大小,单服务器与客户端都再虚拟机上,发包没有经过网卡,故捕获不了。利用linux自带的 tcpdump -i -lo  抓取回环网口的包,截图如下;

    结论尚未明确,等待下一部操作。有知情大佬请留言。

    展开全文
  • 1、socket内核缓冲区大小可用getsockopt获取 2、socket内核缓冲区大小可用setsockopt设置,缓冲区的大小为设置的值的2倍,具体设置代码入下 3、socket缓冲区设置最大为多大呢? 接收缓冲区最大为:/proc/sys/...

    linux内核中socket读取和接收的缓冲区大小

    1、socket内核缓冲区大小可用getsockopt获取
    2、socket内核缓冲区大小可用setsockopt设置,缓冲区的大小为设置的值的2倍,具体设置代码入下
    3、socket缓冲区设置最大为多大呢?
    接收缓冲区最大为:/proc/sys/net/core/rmem_max
    接收缓冲区大小默认为:/proc/sys/net/core/rmem_default

    问题(望大神回答):
    1、发送缓冲区大小最大值跟默认值是多少呢?
    2、为什么新创建的socket的接收缓存区的大小,跟/proc/sys/net/core/rmem_default中设置的值不一样呢?
    3、内核中的socket缓冲区的大小,对于应用层编程有什么影响呢?
    4、接收跟发送的缓冲区的大小多少合适呢?


    #include <stdio.h>
    #include <sys/socket.h>
    #include <sys/types.h>
    #include <netinet/in.h>
    #include <arpa/inet.h>
    
    int main(void)
    {
            int socketFd;
    
            if ((socketFd = socket(PF_INET, SOCK_STREAM,0)) < 0)
            {
            /* 获取socket发送和接收缓冲区的大小 */
            optlen = sizeof(snd_size);
            err = getsockopt(socketFd, SOL_SOCKET, SO_SNDBUF, &snd_size, &optlen);
            if (err < 0)
            {
    
                    printf("get send buff failed!\n");
            }
    
            optlen = sizeof(rcv_size);
            err = getsockopt(socketFd, SOL_SOCKET, SO_RCVBUF, &rcv_size, &optlen);
            if (err < 0)
            { 
                    printf("get rev buff failed!\n");
            }   
                
            printf("senBuffLen:%d\n", snd_size);
            printf("recBuffLen:%d\n", rcv_size);
    
            /* 设置socket发送和接收缓冲区大小都为8K */
            snd_size = 8*1024;
            optlen = sizeof(rcv_size);
            err = setsockopt(socketFd, SOL_SOCKET, SO_SNDBUF, &snd_size, optlen);
            if(err<0)
            {
                    printf("set send buff failed!\n");
            }
    
            rcv_size = 8*1024;
            optlen = sizeof(rcv_size);
            err = setsockopt(socketFd,SOL_SOCKET,SO_RCVBUF, (char *)&rcv_size, optlen);
            if(err<0){
                    printf("set rev buff failed!\n");
            }
    
            /* 获取socket接收和发送缓冲区大小 */
            optlen = sizeof(snd_size);
            err = getsockopt(socketFd, SOL_SOCKET, SO_SNDBUF, &snd_size, &optlen);
            if (err < 0)
            {
                    printf("get send buff failed!\n");
            }
    
            optlen = sizeof(rcv_size);
            err = getsockopt(socketFd, SOL_SOCKET, SO_RCVBUF, &rcv_size, &optlen);
            if (err < 0)
            {
                    printf("get rev buff failed!\n");
            }
    
            printf("senBuffLen:%d\n", snd_size);
            printf("recBuffLen:%d\n", rcv_size);
    
    
            return 0;
    }

     

    展开全文
  • Linux 内核详解以及内核缓冲区技术

    千次阅读 2018-11-14 01:02:45
    Linux 内核详解以及内核缓冲区技术

    分享一下我老师大神的人工智能教程!零基础,通俗易懂!http://blog.csdn.net/jiangjunshow

    也欢迎大家转载本篇文章。分享知识,造福人民,实现我们中华民族伟大复兴!

                   

    Linux 内核简介

    现在让我们从一个比较高的高度来审视一下 GNU/Linux 操作系统的体系结构。您可以从两个层次上来考虑操作系统,如图 2 所示。


    图 2. GNU/Linux 操作系统的基本体系结构
    GNU/Linux 操作系统的基本体系结构  

    最上面是用户(或应用程序)空间。这是用户应用程序执行的地方。用户空间之下是内核空间,Linux 内核正是位于这里。

    GNU C Library (glibc)也在这里。它提供了连接内核的系统调用接口,还提供了在用户空间应用程序和内核之间进行转换的机制。这点非常重要,因为内核和用户空间的应用程序使用的是不同的保护地址空间。每个用户空间的进程都使用自己的虚拟地址空间,而内核则占用单独的地址空间。 更多信息,请参看 参考资料 一节中的链接。

    Linux 内核可以进一步划分成 3 层。最上面是系统调用接口,它实现了一些基本的功能,例如 read 和 write。系统调用接口之下是内核代码,可以更精确地定义为独立于体系结构的内核代码。这些代码是 Linux 所支持的所有处理器体系结构所通用的。在这些代码之下是依赖于体系结构的代码,构成了通常称为 BSP(Board Support Package)的部分。这些代码用作给定体系结构的处理器和特定于平台的代码。

    Linux 内核的属性

    在讨论大型而复杂的系统的体系结构时,可以从很多角度来审视系统。体系结构分析的一个目标是提供一种方法更好地理解源代码,这正是本文的目的。

    Linux 内核实现了很多重要的体系结构属性。在或高或低的层次上,内核被划分为多个子系统。Linux 也可以看作是一个整体,因为它会将所有这些基本服务都集成到内核中。这与微内核的体系结构不同,后者会提供一些基本的服务,例如通信、I/O、内存和进程管理,更具体的服务都是插入到微内核层中的。每种内核都有自己的优点,不过这里并不对此进行讨论。

    随着时间的流逝,Linux 内核在内存和 CPU 使用方面具有较高的效率,并且非常稳定。但是对于 Linux 来说,最为有趣的是在这种大小和复杂性的前提下,依然具有良好的可移植性。Linux 编译后可在大量处理器和具有不同体系结构约束和需求的平台上运行。一个例子是 Linux 可以在一个具有内存管理单元(MMU)的处理器上运行,也可以在那些不提供 MMU 的处理器上运行。Linux 内核的 uClinux 移植提供了对非 MMU 的支持。

    Linux的主要子系统

    现在使用图 3 中的分类说明 Linux 内核的主要组件。


    图 3. Linux 内核的一个体系结构透视图
    Linux 内核的一个体系结构透视图  

    系统调用接口

    SCI 层提供了某些机制执行从用户空间到内核的函数调用。正如前面讨论的一样,这个接口依赖于体系结构,甚至在相同的处理器家族内也是如此。SCI 实际上是一个非常有用的函数调用多路复用和多路分解服务。在 ./linux/kernel 中您可以找到 SCI 的实现,并在 ./linux/arch 中找到依赖于体系结构的部分。

    进程管理

    进程管理的重点是进程的执行。在内核中,这些进程称为线程,代表了单独的处理器虚拟化(线程代码、数据、堆栈和 CPU 寄存器)。在用户空间,通常使用进程 这个术语,不过 Linux 实现并没有区分这两个概念(进程和线程)。内核通过 SCI 提供了一个应用程序编程接口(API)来创建一个新进程(fork、exec 或 Portable Operating System Interface [POSIX] 函数),停止进程(kill、exit),并在它们之间进行通信和同步(signal 或者 POSIX 机制)。

    进程管理还包括处理活动进程之间共享 CPU 的需求。内核实现了一种新型的调度算法,不管有多少个线程在竞争 CPU,这种算法都可以在固定时间内进行操作。这种算法就称为 O(1) 调度程序,这个名字就表示它调度多个线程所使用的时间和调度一个线程所使用的时间是相同的。 O(1) 调度程序也可以支持多处理器(称为对称多处理器或 SMP)。您可以在 ./linux/kernel 中找到进程管理的源代码,在 ./linux/arch 中可以找到依赖于体系结构的源代码。

    内存管理

    内核所管理的另外一个重要资源是内存。为了提高效率,如果由硬件管理虚拟内存,内存是按照所谓的内存页 方式进行管理的(对于大部分体系结构来说都是 4KB)。Linux 包括了管理可用内存的方式,以及物理和虚拟映射所使用的硬件机制。

    不过内存管理要管理的可不止 4KB 缓冲区。Linux 提供了对 4KB 缓冲区的抽象,例如 slab 分配器。这种内存管理模式使用 4KB 缓冲区为基数,然后从中分配结构,并跟踪内存页使用情况,比如哪些内存页是满的,哪些页面没有完全使用,哪些页面为空。这样就允许该模式根据系统需要来动态调整内存使用。

    为了支持多个用户使用内存,有时会出现可用内存被消耗光的情况。由于这个原因,页面可以移出内存并放入磁盘中。这个过程称为交换,因为页面会被从内存交换到硬盘上。内存管理的源代码可以在 ./linux/mm 中找到。

    虚拟文件系统

    虚拟文件系统(VFS)是 Linux 内核中非常有用的一个方面,因为它为文件系统提供了一个通用的接口抽象。VFS 在 SCI 和内核所支持的文件系统之间提供了一个交换层(请参看图 4)。


    图 4. VFS 在用户和文件系统之间提供了一个交换层
    VFS 在用户和文件系统之间提供了一个交换层  

    在 VFS 上面,是对诸如 open、close、read 和 write 之类的函数的一个通用 API 抽象。在 VFS 下面是文件系统抽象,它定义了上层函数的实现方式。它们是给定文件系统(超过 50 个)的插件。文件系统的源代码可以在 ./linux/fs 中找到。

    文件系统层之下是缓冲区缓存,它为文件系统层提供了一个通用函数集(与具体文件系统无关)。这个缓存层通过将数据保留一段时间(或者随即预先读取数据以便在需要是就可用)优化了对物理设备的访问。缓冲区缓存之下是设备驱动程序,它实现了特定物理设备的接口。

    网络堆栈

    网络堆栈在设计上遵循模拟协议本身的分层体系结构。回想一下,Internet Protocol (IP) 是传输协议(通常称为传输控制协议或 TCP)下面的核心网络层协议。TCP 上面是 socket 层,它是通过 SCI 进行调用的。

    socket 层是网络子系统的标准 API,它为各种网络协议提供了一个用户接口。从原始帧访问到 IP 协议数据单元(PDU),再到 TCP 和 User Datagram Protocol (UDP),socket 层提供了一种标准化的方法来管理连接,并在各个终点之间移动数据。内核中网络源代码可以在 ./linux/net 中找到。

    设备驱动程序

    Linux 内核中有大量代码都在设备驱动程序中,它们能够运转特定的硬件设备。Linux 源码树提供了一个驱动程序子目录,这个目录又进一步划分为各种支持设备,例如 Bluetooth、I2C、serial 等。设备驱动程序的代码可以在 ./linux/drivers 中找到。

    依赖体系结构的代码

    尽管 Linux 很大程度上独立于所运行的体系结构,但是有些元素则必须考虑体系结构才能正常操作并实现更高效率。./linux/arch 子目录定义了内核源代码中依赖于体系结构的部分,其中包含了各种特定于体系结构的子目录(共同组成了 BSP)。对于一个典型的桌面系统来说,使用的是 i386 目录。每个体系结构子目录都包含了很多其他子目录,每个子目录都关注内核中的一个特定方面,例如引导、内核、内存管理等。这些依赖体系结构的代码可以在 ./linux/arch 中找到。


    以上的内容来自:http://www.ibm.com/developerworks/cn/linux/l-linux-kernel/


    下面介绍内核缓冲区的内容:

    为什么总是需要将数据由内核缓冲区换到用户缓冲区或者相反呢?

    答:用户进程是运行在用户空间的,不能直接操作内核缓冲区的数据。 用户进程进行系统调用的时候,会由用户态切换到内核态,待内核处理完之后再返回用户态

    应用缓冲技术能很明显的提高系统效率。内核与外围设备的数据交换,内核与用户空间的数据交换都是比较费时的,使用缓冲区就是为了优化这些费时的操作。其实核心到用户空间的操作本身是不buffer的,是由I/O库用buffer来优化了这个操作。比如read本来从内核读取数据时是比较费时的,所以一次取出一块,以避免多次陷入内核。
          应用内核缓冲区的 主要思想就是一次读入大量的数据放在缓冲区,需要的时候从缓冲区取得数据。
          管理员模式和用户模式之间的切换需要消耗时间,但相比之下,磁盘的I/O操作消耗的时间更多,为了提高效率,内核也使用缓冲区技术来提高对磁盘的访问速度。磁盘是数据块 的集合,内核会对磁盘上的数据块做缓冲。内核将磁盘上的数据块复制到内核缓冲区中,当一个用户空间中的进程要从磁盘上读数据时,内核一般不直接读磁盘,而 是将内核缓冲区中的数据复制到进程的缓冲区中。当进程所要求的数据块不在内核缓冲区时,内核会把相应的数据块加入到请求队列,然后把该进程挂起,接着为其 他进程服务。一段时间之后(其实很短的时间),内核把相应的数据块从磁盘读到内核缓冲区,然后再把数据复制到进程的缓冲区中,最后唤醒被挂起的进程。
          注:理解内核缓冲区技术的原理有助于更好的掌握系统调用read&write,read把数据从内核缓冲区复制到进程缓冲区,write把数据从进程缓冲区复制到内核缓冲区,它们不等价于数据在内核缓冲区和磁盘之间的交换。
          从理论上讲,内核可以在任何时候写磁盘,但并不是所有的write操作都会导致内核的写动作。内核会把要写的数据暂时存在缓冲区中,积累到一定数量后再一 次写入。有时会导致意外情况,比如断电,内核还来不及把内核缓冲区中的数据写道磁盘上,这些更新的数据就会丢失。
          应用内核缓冲技术导致的结果是:提高了磁盘的I/O效率;优化了磁盘的写操作;需要及时的将缓冲数据写到磁盘。



               

    给我老师的人工智能教程打call!http://blog.csdn.net/jiangjunshow

    这里写图片描述
    展开全文
  • 点击打开链接我们可以用printk打印kernel的日志信息(即log信息),...那么如何增大缓冲区大小呢?我们看kernel/printk.c的代码[cpp] view plain copy "font-family: Arial, Helvetica, sans-serif;">/* rec

    点击打开链接

    我们可以用printk打印kernel的日志信息(即log信息),根据时间戳可以判断内核新打印的log会覆盖掉以前打印的log。原因是内核用环形缓冲区存放打印的log信息。那么 如何增大缓冲区的大小呢?
    我们看kernel/printk.c的代码

    [cpp]  view plain  copy
      在CODE上查看代码片 派生到我的代码片
    1. <span style="font-family: Arial, Helvetica, sans-serif;">/* record buffer */</span>  
    [cpp]  view plain  copy
      在CODE上查看代码片 派生到我的代码片
    1. #define LOG_ALIGN __alignof__(struct printk_log)  
    2. #define __LOG_BUF_LEN (1 << CONFIG_LOG_BUF_SHIFT)  
    3. static char __log_buf[__LOG_BUF_LEN] __aligned(LOG_ALIGN);  
    4. static char *log_buf = __log_buf;  
    5. static u32 log_buf_len = __LOG_BUF_LEN;  

    正是__LOG_BUF_LEN这个宏设置了环形缓冲区的大小,那么__LOG_BUF_LEN的大小是多少呢?是由1 << CONFIG_LOG_BUF_SHIFT(即2的CONFIG_LOG_BUF_SHIFT次幂)来决定的,那么CONFIG_LOG_BUF_SHIFT这个配置项又是在哪里定义呢?

    在init/Kconfig里定义

    [cpp]  view plain  copy
      在CODE上查看代码片 派生到我的代码片
    1. config LOG_BUF_SHIFT  
    2.         int "Kernel log buffer size (16 => 64KB, 17 => 128KB)"  
    3.         range 12 21  
    4.         default 17  
    5.         depends on PRINTK  
    6.         help  
    7.           Select the minimal kernel log buffer size as a power of 2.  
    8.           The final size is affected by LOG_CPU_MAX_BUF_SHIFT config  
    9.           parameter, see below. Any higher size also might be forced  
    10.           by "log_buf_len" boot parameter.  
    11.   
    12.           Examples:  
    13.                      17 => 128 KB  
    14.                      16 => 64 KB  
    15.                      15 => 32 KB  
    16.                      14 => 16 KB  
    17.                      13 =>  8 KB  
    18.                      12 =>  4 KB  

    可见CONFIG_LOG_BUF_SHIFT是一个内核配置项。它的大小可以配置为12~21,也就是说环形缓冲区的大小可以配置为4 KB - 2MB。内核(3.18内核)默认是17,即缓冲区的大小为2^17(131072)B。

          所以要想增大或者减小环形缓冲区的大小,只需要在内核的配置文件里(对于arm架构为arch/arm/configs/xxx或者arch/arm64/configs/xxx)添加CONFIG_LOG_BUF_SHIFT=XX 即可修改环形缓冲区的大小。


    展开全文
  • linux内核环形缓冲区

    千次阅读 2017-02-23 14:16:39
    循环缓冲区在一些竞争问题上提供了一种免锁的机制,免锁的前提是,生产者和消费  都只有一个的情况下,否则也要加锁。下面就内核中提取出来,而经过修改后的fifo进  行简要的分析。    先看其只要数据结构:...
  • linux网卡udp缓冲区One of the most common causes of UDP datagram lost on Linux is an undersized receive buffer on the Linux socket. How to enlarge Linux UDP buffer size? 在Linux上丢失UDP数据报的最常见...
  • linux 默认socket 缓冲区大小

    千次阅读 2013-04-17 11:47:20
    1. tcp 收发缓冲区默认值 [root@ www.linuxidc.com]# cat /proc/sys/net/ipv4/tcp_rmem   4096 87380 4161536 87380 :tcp接收缓冲区的默认值 [root@ www.linuxidc.com]# cat /proc/sys/...
  • Linux内核中的循环缓冲区

    千次阅读 2011-03-31 15:31:00
    Linux内核中的循环缓冲区(circular buffer)为解决某些特殊情况下的竞争问题提供了一种免锁的方法。这种特殊的情况就是当生产者和消费者都只有一个,而在其它情况下使用它也是必须要加锁的。 循环缓冲区定义在...
  • Author:阿冬哥 Created:2013-4-17  Blog:http://blog.csdn.net/c359719435/ Copyright 2013 阿冬哥 ... 使用以及转载请注明出处 ...1 设置socket tcp缓冲区大小的疑惑  疑惑1:通过setsockopt设置
  • linux socket 缓冲区默认大小

    千次阅读 2016-09-22 10:36:04
    1. tcp 收发缓冲区默认值 [root@ www.linuxidc.com]# cat /proc/sys/net/ipv4/tcp_rmem   4096 87380 4161536 87380 :tcp接收缓冲区的默认值 [root@ www.linuxidc.com]# cat /proc/sys/...
  • Linux0.11内核--缓冲区初始化

    千次阅读 2011-03-14 21:21:00
    if (memory_end > 12*1024*1024) //内存>12M 设置高速缓冲区大小4M buffer_memory_end = 4*1024*1024; else if (memory_end > 6*1024*1024) // 内存>6M 设置高速缓冲区大小2M buffer_memory_end = 2*1024*...
  • 关于linux udp收发包缓冲区大小

    万次阅读 2013-03-13 14:40:30
    1、修订单个socket的缓冲区大小:通过setsockopt使用SO_RCVBUF来设置接收缓冲区,该参数在设置的时候不会与rmem_max进行对比校验,但是如果设置的大小超过rmem_max的话,则...2、修订linux系统udp缓冲区大小:通过rm
  • 使用的APIread/write函数 常常被称为Unbuffered IO。指的是无用户缓存区。...验证内核缓存区大小思路很简单,就是测试4096这个临界点。首先往文件中写4096个字节,查看数据是否写入到磁盘文件,从终端读入数据...
  • Linux内核结构体--kfifo 环状缓冲区

    千次阅读 2014-12-17 19:46:37
     最近项目中用到一个环形缓冲区(ring buffer),代码是由linux内核的kfifo改过来的。缓冲区在文件系统中经常用到,通过缓冲区缓解cpu读写内存和读写磁盘的速度。例如一个进程A产生数据发给另外一个进程B,进程B...
  • 内核缓冲区slab的管理

    2014-02-23 09:05:34
    刚了下Linux内核情景分析中的内核缓冲区管理,做个小总结。 在Linux内核中,对于大块的内存的管理是用伙伴系统算法(buddy )管理。对于小块的内存则用slab管理。 在slab方法中,每种重要的数据结构都有自己专用的...
  • 循环缓冲区(参考linux内核Kfifo)

    千次阅读 2012-02-20 09:25:54
    1 循环缓冲区在一些竞争问题上提供了一种免锁的机制,免锁的前提是,生产者和消费 2 都只有一个的情况下,否则也要加锁。下面就内核中提取出来,而经过修改后的fifo进 3 行简要的分析。 4 5 先看其只要数据结构...
  • 系统提供的socket缓冲区大小为8K,你可以将之设置为64K,尤其在传输实时视频时。  socket发送数据时候先把数据发送到socket缓冲区中,之后接受函数再从缓冲区中取数据,如果发送端特别快的时候,缓冲区很快就被...
  • C 标准库IO缓冲区 内核缓冲区(一)

    千次阅读 2015-08-25 21:15:37
    1.C标准库的I/O缓冲区   UNIX的传统 是Everything is a file,键盘、显示器、串口、磁盘等设备在/dev 目录下都有一个特殊的设备文件与之对应,这些设备文件也可以像普通文件(保存在磁盘上的文件)一样打开、读、写和...
  • 管道缓冲区大小

    千次阅读 2019-03-30 20:56:39
    可以使用ulimit –a 命令来查看当前系统中创建管道文件所对应的内核缓冲区大小。通常为:pipe size 4K,即一个页面大小。也可以使用fpathconf函数来查看: #include <unistd.h> long fpathconf(int fd, int ...
  • linux设置套接字缓冲区大小

    万次阅读 2011-11-17 16:14:22
    系统提供的socket缓冲区大小为8K,你可以将之设置为64K,尤其在传输实时视频时。  socket发送数据时候先把数据发送到socket缓冲区中,之后接受函数再从缓冲区中取数据,如果发送端特别快的时候,缓冲区很快就被...
  • 因为网络实验要求,需要获取socket接受缓冲区已经占用的量。 目前尝试了使用ioctl获取,但是被告知用netlink访问内核的方法更好。 但是查询过程中发现内核代码很不熟悉,希望能获得一个代码进行参考。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 76,255
精华内容 30,502
关键字:

linux查看内核缓冲区大小

linux 订阅