linuxreceiver

A. 怎么在linux上安装receiver

首先来在CentOS5.5上安装最新版Citrix Receiver 11.100。
1、安装ICAClient（可以看到，缺少部分依赖包，主要用于GUI显示接口），可以使用yum install libXaw.so.7来安装依赖包，其他类似
2、安装完成以后，可以在Application->Internet->Citrix Receiver打开
3、配置Citrix Receiver连接服务器
4、添加XenApp或者XenDesktop服务器，并配置地址
5、配置地址完成后，选择View->Citrix XenApp View可以查看该服务器的应用程序
6、点击应用程序以后，会提示输入账号密码，当然也支持Pass-Through方式。具体的配置请大家自行查看。

B. Linux进程通信实验（共享内存通信，接上篇）

这一篇记录一下共享内存实验，需要linux的共享内存机制有一定的了解，同时也需要了解POSIX信号量来实现进程间的同步。可以参考以下两篇博客: https://blog.csdn.net/sicofield/article/details/10897091
https://blog.csdn.net/ljianhui/article/details/10253345

实验要求：编写sender和receiver程序，sender创建一个共享内存并等待用户输入，然后把输入通过共享内存发送给receiver并等待，receiver收到后把消息显示在屏幕上并用同样方式向sender发送一个over，然后两个程序结束运行。
这个实验的难点主要在于共享内存的创建和撤销（涉及到的步骤比较多，需要理解各步骤的功能），以及实现两个进程间的相互等待（使用信号量来实现，这里使用了有名信号量）

实验心得：学习理解了linux的共享内存机制以及POSIX信号量机制。
两个实验虽然加强了对linux一些机制的理解，但是感觉对linux的学习还不够，需要继续学习。

C. 2020-08-25

Prometheus 实现邮件告警（Prometheus+Alertmanager+QQ邮箱或者网易163邮箱，目前测试过这两种邮箱都可以发送告警邮件）

Prometheus实现邮件告警原理如下：

Prometheus官方有一个附带的中间件：alertmanager，通过设置rules规则和路由转发可以实现邮件告警，前提是你需要有一个可以发送邮件的邮件服务端（可以自建或者使用互联网公司提供的免费邮箱）

告警原理图

Prometheus完整架构图

我之前得出的错误结论如下：

推荐直接在虚拟机操作系统上直接安装Prometheus和Alertmanager，不推荐其中任何一方在容器中运行，因为测试过在容器中运行Prometheus和alertmanager，结果出现如下错误情况

第一种情况是：我的node-exporter掉线跌机了（手动关机，模拟突然掉线跌机），Prometheus却提示节点依然在线？有时候却能够正常显示节点掉线跌机，生成告警发送邮件

第二种情况是：我的node-exporter掉线跌机了（手动关机，模拟突然掉线跌机），Prometheus提示节点掉线，告警生成，但是没有发送邮件，我手动恢复node-exporter后，告警解除，邮件能正常发送邮件提示告警已经解除。。。。

第三种情况是：我的node-exporter掉线跌机了（手动关机，模拟突然掉线跌机），Prometheus提示节点掉线，告警生成，正常成功发送邮件，我手动恢复node-exporter后，告警解除，邮件没有发送出来。。。。

以上三种情况之前经常出现，当时第一步以为是自己设置的scrape_interval不合理导致的，结果调试几次，问题没有解决，第二步以为是自己的服务器时间没有做到精确同步，然后我去设置和阿里云的ntp服务器同步，结果问题依然没有解决，第三步，换个方向，把alertmanager迁移到虚拟机操作系统上安装运行，问题解决！

北京时间是GMT+8小时，有些同志的时间可能是UTC的，但是如果是在要求不太十分精确的情况下，UTC时间是刚刚好等于GMT时间

为了避免时区的混乱，prometheus所有的组件内部都强制使用Unix时间，对外展示使用GMT时间。

要改时区有两个办法

1 .修改源码，重新编译。

2. 使用 docker 运行 Prometheus，挂载本地时区文件

docker run --restart always -e TZ=Asia/Shanghai --hostname prometheus --name prometheus-server -d -p 9090:9090 -v /data/prometheus/server/data:/prometheus -v /data/prometheus/server/conf/prometheus.yml:/etc/prometheus/prometheus.yml -u root prom/prometheus:v2.5.0

正文开始

安装alertmanager

容器安装方式：

docker run -d --name alertmanager -p 9093:9093 -v /usr/local/Prometheus/alertmanager/alertmanager.yml:/etc/alertmanager/alertmanager.yml prom/alertmanager:latest

先在宿主机/usr/local/Prometheus下创建一个文件夹alertmanager，然后在文件夹里创建alertmanager.yml配置文件，待会才能映射到alertmanager容器里的/etc/alertmanager目录下

global：全局配置

   resolve_timeout: 问题解决的超时时间

   smtp_from: 发送告警邮件的邮箱账号

   smtp_smarthost: 邮箱 SMTP 服务地址,这里是以QQ邮箱为例，也可以用网易163邮箱，这个和我之前设置zabbix邮件告警时的配置一样

   smtp_auth_username: 如果没有设置邮箱别名，那就是账户名

   smtp_auth_password:  邮箱的授权码，不是 账户密码，你可以在QQ邮箱或者网易163邮箱网页端设置，开启 POP3/SMTP 服务时会提示，和配置zabbix邮件告警的时候几乎一样

   smtp_require_tls: 是否使用 tls，根据环境不同，来选择开启和关闭。如果提示报错 email.loginAuth failed: 530 Must issue a STARTTLS command first，那么就需要设置为 true。着重说明一下，如果开启了 tls，提示报错 starttls failed: x509: certificate signed by unknown authority，需要在 email_configs 下配置 insecure_skip_verify: true 来跳过 tls 验证。

templates： 告警模板目录，可以不编写模板，有默认模板

    Subject: '{{ template "email.default.subject" . }}'

    html: '{{ template "email.default.html" . }}'

route：报警的分发设置

    group_by：分组

    group_wait: 分组等待时间

    group_interval: 5m 每组时间间隔

    repeat_interval: 10m 重复间隔

    receiver: 接收方式，请注意！这里的名字要对应下面receivers中的任何一个名字，不然会报错，这里其实就是选择方式，有邮箱，企业微信，wehook，victorops等等

receivers：接受方式汇总，即告警方式汇总

例子：

receivers:

- name:'default-receiver' 

email_configs:

- to:'[email protected]'    

  html: '{{ template "alert.html" . }}'    

  headers: { Subject: "[WARN] 报警邮件test"}

inhibit_rules:   抑制规则

当存在与另一组匹配的警报（源）时，抑制规则将禁用与一组匹配的警报（目标）。

包括源匹配和目标匹配

alertmanager官方是这样说的

Inhibition

Inhibition is a concept of suppressing notifications for certain alerts if certain other alerts are already firing.

Example:  An alert is firing that informs that an entire cluster is not reachable. Alertmanager can be configured to mute all other alerts concerning this cluster if that particular alert is firing. This prevents notifications for hundreds or thousands of firing alerts that are unrelated to the actual issue.

Inhibitions are configured through the Alertmanager's configuration file.

当存在与另一组匹配器匹配的警报（源）时，禁止规则会使与一组匹配器匹配的警报（目标）静音。目标警报和源警报的equal列表中的标签名称都必须具有相同的标签值。

在语义上，缺少标签和带有空值的标签是同一件事。因此，如果equal源警报和目标警报都缺少列出的所有标签名称，则将应用禁止规则。

为了防止警报禁止自身，与规则的目标和源端 都 匹配的警报不能被警报（包括其本身）为真来禁止。但是，我们建议选择目标匹配器和源匹配器，以使警报永远不会同时匹配双方。这很容易进行推理，并且不会触发此特殊情况。

接着是规则rules

不解释了，自己研究官方文档

alertmanager的非容器安装方式是

 wget https://github.com/prometheus/alertmanager/releases/download/v0.20.0/alertmanager-0.20.0.linux-amd64.tar.gz

tar xf alertmanager-0.20.0.linux-amd64.tar.gz

mv alertmanager-0.20.0.linux-amd64 /usr/local/alertmanager

vim /usr/lib/systemd/system/alertmanager.service

[Unit]

Description=alertmanager

Documentation=https://github.com/prometheus/alertmanager

After=network.target

[Service]

Type=simple

User=root

ExecStart=/usr/local/alertmanager/alertmanager --config.file=/usr/local/alertmanager/alertmanager.yml

Restart=on-failure

[Install]

WantedBy=multi-user.target

Alertmanager 安装目录下默认有 alertmanager.yml 配置文件，可以创建新的配置文件，在启动时指定即可。

其余方式和上面一样

接着是Prometheus，我之前的博客里有写了容器安装和非容器安装的方法，自己去翻阅

然后是在prometheus.yml里修改相关配置

首先去掉alertmanager的注释，改成IP加你设置的端口号，默认是9093

接着在rule_files: 下面写下规则文件的绝对路径，可以是具体文件名，也可以是*，也可以分几级文件，*默认是全部匹配

接着是被监控项的设置，这里设置完成可以在Prometheus网页里的targets里看得到

请注意，这里设置的参数名字要和rule规则中设置的参数名字一模一样，否则你的prometheus服务会无法启动，然后报错

如果不在特定的job下设置scrape_interval（优先级高于全局）,则默认采用gobal下的scrape_interval

最后模拟节点掉线，手动关闭node-exporter或者Cadvisor

docker stop node-exporter 或者容器ID

docker stop cadvisor 或者容器ID

或者把up{{job='prometheus'}} == 1 设置成1，反向设置，不用关掉服务，就可以看看告警成不成功

说明一下 Prometheus Alert 告警状态有三种状态：Inactive、Pending、Firing。

Inactive：非活动状态，表示正在监控，但是还未有任何警报触发。

Pending：表示这个警报必须被触发。由于警报可以被分组、压抑/抑制或静默/静音，所以等待验证，一旦所有的验证都通过，则将转到 Firing 状态。

Firing：将警报发送到 AlertManager，它将按照配置将警报的发送给所有接收者。一旦警报解除，则将状态转到 Inactive，如此循环。

没有配置告警模板时的默认告警格式是这样的

节点恢复后邮件告知是这样的

写了模板后是这样的

还要重新映射模板文件夹路径到alertmanager容器里的相对路径，然后重启alertmanager，当然，如果目录下没有模板文件，则不显示

告警模板

在alertmanager.yml中修改相关设置

重启alertmanager

docker restart alertmanager

最终效果不是很好

D. 如何查看linux下串口是否可用串口名称等

1、查看串口是否可用，可以对串口发送数据比如对com1口，echo lyjie126 > /dev/ttyS0

2、查看串口名称使用 ls -l /dev/ttyS* 一般情况下串口的名称全部在dev下面，如果你没有外插串口卡的话默认是dev下的ttyS* ,一般ttyS0对应com1，ttyS1对应com2，当然也不一定是必然的；

3、查看串口驱动：cat /proc/tty/drivers/serial

4、查看串口设备：dmesg | grep ttyS*

(4)linuxreceiver扩展阅读

接口划分标准

同步串行接口（英文：SynchronousSerialInterface，SSI）是一种常用的工业用通信接口。。

异步串行是指UART（Universal Asynchronous Receiver/Transmitter），通用异步接收/发送。UART是一个并行输入成为串行输出的芯片，通常集成在主板上。UART包含TTL电平的串口和RS232电平的串口。 TTL电平是3.3V的，而RS232是负逻辑电平，它定义+5~+12V为低电平，而-12~-5V为高电平，MDS2710、MDS SD4、EL805等是RS232接口，EL806有TTL接口。

串行接口按电气标准及协议来分包括RS-232-C、RS-422、RS485等。RS-232-C、RS-422与RS-485标准只对接口的电气特性做出规定，不涉及接插件、电缆或协议。

E. receiver for linux安装在Centos里，使用自带浏览器正常登录虚拟桌面，之后无法退出

控制下的暂停啊 挂起就行吧

F. 在Linux 上，编写一个每秒接收 100万UDP数据包的程序究竟有多难

首先，我们假设：
测量每秒的数据包(pps)比测量每秒字节数(Bps)更有意思。您可以通过更好的管道输送以及发送更长数据包来获取更高的Bps。而相比之下，提高pps要困难得多。
因为我们对pps感兴趣，我们的实验将使用较短的 UDP 消息。准确来说是 32 字节的 UDP 负载，这相当于以太网层的 74 字节。
在实验中，我们将使用两个物理服务器：“接收器”和“发送器”。
它们都有两个六核2 GHz的 Xeon处理器。每个服务器都启用了 24 个处理器的超线程(HT)，有 Solarflare 的 10G 多队列网卡，有 11 个接收队列配置。稍后将详细介绍。
测试程序的源代码分别是：udpsender、udpreceiver。
预备知识
我们使用4321作为UDP数据包的端口，在开始之前，我们必须确保传输不会被iptables干扰：

Shell

receiver$ iptables -I INPUT 1 -p udp --dport 4321 -j ACCEPT

receiver$ iptables -t raw -I PREROUTING 1 -p udp --dport 4321 -j NOTRACK

为了后面测试方便，我们显式地定义IP地址：

Shell

receiver$ for i in `seq 1 20`; do

ip addr add 192.168.254.$i/24 dev eth2;

done

sender$ ip addr add 192.168.254.30/24 dev eth3

1. 简单的方法
开始我们做一些最简单的试验。通过简单地发送和接收，有多少包将会被传送？
模拟发送者的伪代码：

Python

fd = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

fd.bind(("0.0.0.0", 65400)) # select source port to rece nondeterminism

fd.connect(("192.168.254.1", 4321))

while True:

fd.sendmmsg(["x00" * 32] * 1024)

因为我们使用了常见的系统调用的send，所以效率不会很高。上下文切换到内核代价很高所以最好避免它。幸运地是，最近Linux加入了一个方便的系统调用叫sendmmsg。它允许我们在一次调用时，发送很多的数据包。那我们就一次发1024个数据包。
模拟接受者的伪代码：

Python

fd = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
fd.bind(("0.0.0.0", 4321))
while True:
packets = [None] * 1024
fd.recvmmsg(packets, MSG_WAITFORONE)

同样地，recvmmsg 也是相对于常见的 recv 更有效的一版系统调用。
让我们试试吧：

Shell

sender$ ./udpsender 192.168.254.1:4321
receiver$ ./udpreceiver1 0.0.0.0:4321
0.352M pps 10.730MiB / 90.010Mb
0.284M pps 8.655MiB / 72.603Mb
0.262M pps 7.991MiB / 67.033Mb
0.199M pps 6.081MiB / 51.013Mb
0.195M pps 5.956MiB / 49.966Mb
0.199M pps 6.060MiB / 50.836Mb
0.200M pps 6.097MiB / 51.147Mb
0.197M pps 6.021MiB / 50.509Mb

测试发现，运用最简单的方式可以实现 197k – 350k pps。看起来还不错嘛，但不幸的是，很不稳定啊，这是因为内核在核之间交换我们的程序，那我们把进程附在 CPU 上将会有所帮助

Shell

sender$ taskset -c 1 ./udpsender 192.168.254.1:4321
receiver$ taskset -c 1 ./udpreceiver1 0.0.0.0:4321
0.362M pps 11.058MiB / 92.760Mb
0.374M pps 11.411MiB / 95.723Mb
0.369M pps 11.252MiB / 94.389Mb
0.370M pps 11.289MiB / 94.696Mb
0.365M pps 11.152MiB / 93.552Mb
0.360M pps 10.971MiB / 92.033Mb

现在内核调度器将进程运行在特定的CPU上，这提高了处理器缓存，使数据更加一致，这就是我们想要的啊！
2. 发送更多的数据包
虽然 370k pps 对于简单的程序来说已经很不错了，但是离我们 1Mpps 的目标还有些距离。为了接收更多，首先我们必须发送更多的包。那我们用独立的两个线程发送，如何呢：

Shell

sender$ taskset -c 1,2 ./udpsender
192.168.254.1:4321 192.168.254.1:4321
receiver$ taskset -c 1 ./udpreceiver1 0.0.0.0:4321
0.349M pps 10.651MiB / 89.343Mb
0.354M pps 10.815MiB / 90.724Mb
0.354M pps 10.806MiB / 90.646Mb
0.354M pps 10.811MiB / 90.690Mb

接收一端的数据没有增加，ethtool –S 命令将显示数据包实际上都去哪儿了：

Shell

receiver$ watch 'sudo ethtool -S eth2 |grep rx'
rx_nodesc_drop_cnt: 451.3k/s
rx-0.rx_packets: 8.0/s
rx-1.rx_packets: 0.0/s
rx-2.rx_packets: 0.0/s
rx-3.rx_packets: 0.5/s
rx-4.rx_packets: 355.2k/s
rx-5.rx_packets: 0.0/s
rx-6.rx_packets: 0.0/s
rx-7.rx_packets: 0.5/s
rx-8.rx_packets: 0.0/s
rx-9.rx_packets: 0.0/s
rx-10.rx_packets: 0.0/s

通过这些统计，NIC 显示 4 号 RX 队列已经成功地传输大约 350Kpps。rx_nodesc_drop_cnt 是 Solarflare 特有的计数器，表明NIC发送到内核未能实现发送 450kpps。
有时候，这些数据包没有被发送的原因不是很清晰，然而在我们这种情境下却很清楚：4号RX队列发送数据包到4号CPU，然而4号CPU已经忙不过来了，因为它最忙也只能读350kpps。在htop中显示为：

多队列 NIC 速成课程
从历史上看，网卡拥有单个RX队列，用于硬件和内核之间传递数据包。这样的设计有一个明显的限制，就是不可能比单个CPU处理更多的数据包。
为了利用多核系统，NIC开始支持多个RX队列。这种设计很简单：每个RX队列被附到分开的CPU上，因此，把包送到所有的RX队列网卡可以利用所有的CPU。但是又产生了另一个问题：对于一个数据包，NIC怎么决定把它发送到哪一个RX队列？

用 Round-robin 的方式来平衡是不能接受的，因为这有可能导致单个连接中数据包的重排序。另一种方法是使用数据包的hash值来决定RX号码。Hash值通常由一个元组（源IP，目标IP，源port，目标port）计算而来。这确保了从一个流产生的包将最终在完全相同的RX队列，并且不可能在一个流中重排包。
在我们的例子中，hash值可能是这样的：

Shell

1

RX_queue_number = hash('192.168.254.30', '192.168.254.1', 65400, 4321) % number_of_queues

多队列 hash 算法
Hash算法通过ethtool配置，设置如下：

Shell

receiver$ ethtool -n eth2 rx-flow-hash udp4
UDP over IPV4 flows use these fields for computing Hash flow key:
IP SA
IP DA

对于IPv4 UDP数据包，NIC将hash(源 IP,目标 IP)地址。即

Shell

1

RX_queue_number = hash('192.168.254.30', '192.168.254.1') % number_of_queues

这是相当有限的，因为它忽略了端口号。很多NIC允许自定义hash。再一次，使用ethtool我们可以选择元组(源 IP、目标 IP、源port、目标port)生成hash值。

Shell

receiver$ ethtool -N eth2 rx-flow-hash udp4 sdfn
Cannot change RX network flow hashing options: Operation not supported

不幸地是，我们的NIC不支持自定义，我们只能选用(源 IP、目的 IP) 生成hash。
NUMA性能报告
到目前为止，我们所有的数据包都流向一个RX队列，并且一个CPU。我们可以借这个机会为基准来衡量不同CPU的性能。在我们设置为接收方的主机上有两个单独的处理器，每一个都是一个不同的NUMA节点。
在我们设置中，可以将单线程接收者依附到四个CPU中的一个，四个选项如下：
另一个CPU上运行接收器，但将相同的NUMA节点作为RX队列。性能如上面我们看到的，大约是360 kpps。
将运行接收器的同一 CPU 作为RX队列，我们可以得到大约430 kpps。但这样也会有很高的不稳定性，如果NIC被数据包所淹没，性能将下降到零。
当接收器运行在HT对应的处理RX队列的CPU之上，性能是通常的一半，大约在200kpps左右。
接收器在一个不同的NUMA节点而不是RX队列的CPU上，性能大约是330 kpps。但是数字会不太一致。
虽然运行在一个不同的NUMA节点上有10%的代价，听起来可能不算太坏，但随着规模的变大，问题只会变得更糟。在一些测试中，每个核只能发出250 kpps，在所有跨NUMA测试中，这种不稳定是很糟糕。跨NUMA节点的性能损失，在更高的吞吐量上更明显。在一次测试时，发现在一个坏掉的NUMA节点上运行接收器，性能下降有4倍。
3.多接收IP
因为我们NIC上hash算法的限制，通过RX队列分配数据包的唯一方法是利用多个IP地址。下面是如何将数据包发到不同的目的IP：

1

sender$ taskset -c 1,2 ./udpsender 192.168.254.1:4321 192.168.254.2:4321

ethtool 证实了数据包流向了不同的 RX 队列：

Shell

receiver$ watch 'sudo ethtool -S eth2 |grep rx'
rx-0.rx_packets: 8.0/s
rx-1.rx_packets: 0.0/s
rx-2.rx_packets: 0.0/s
rx-3.rx_packets: 355.2k/s
rx-4.rx_packets: 0.5/s
rx-5.rx_packets: 297.0k/s
rx-6.rx_packets: 0.0/s
rx-7.rx_packets: 0.5/s
rx-8.rx_packets: 0.0/s
rx-9.rx_packets: 0.0/s
rx-10.rx_packets: 0.0/s

接收部分：

Shell

receiver$ taskset -c 1 ./udpreceiver1 0.0.0.0:4321
0.609M pps 18.599MiB / 156.019Mb
0.657M pps 20.039MiB / 168.102Mb
0.649M pps 19.803MiB / 166.120Mb

万岁！有两个核忙于处理RX队列，第三运行应用程序时，可以达到大约650 kpps !
我们可以通过发送数据到三或四个RX队列来增加这个数值，但是很快这个应用就会有另一个瓶颈。这一次rx_nodesc_drop_cnt没有增加，但是netstat接收到了如下错误：

Shell

receiver$ watch 'netstat -s --udp'
Udp:
437.0k/s packets received
0.0/s packets to unknown port received.
386.9k/s packet receive errors
0.0/s packets sent
RcvbufErrors: 123.8k/s
SndbufErrors: 0
InCsumErrors: 0

这意味着虽然NIC能够将数据包发送到内核，但是内核不能将数据包发给应用程序。在我们的case中，只能提供440 kpps，其余的390 kpps + 123 kpps的下降是由于应用程序接收它们不够快。
4.多线程接收
我们需要扩展接收者应用程序。最简单的方式是利用多线程接收，但是不管用：

Shell

sender$ taskset -c 1,2 ./udpsender 192.168.254.1:4321 192.168.254.2:4321
receiver$ taskset -c 1,2 ./udpreceiver1 0.0.0.0:4321 2
0.495M pps 15.108MiB / 126.733Mb
0.480M pps 14.636MiB / 122.775Mb
0.461M pps 14.071MiB / 118.038Mb
0.486M pps 14.820MiB / 124.322Mb

接收性能较于单个线程下降了，这是由UDP接收缓冲区那边的锁竞争导致的。由于两个线程使用相同的套接字描述符，它们花费过多的时间在UDP接收缓冲区的锁竞争。这篇论文详细描述了这一问题。
看来使用多线程从一个描述符接收，并不是最优方案。
5. SO_REUSEPORT
幸运地是，最近有一个解决方案添加到 Linux 了 —— SO_REUSEPORT 标志位（flag）。当这个标志位设置在一个套接字描述符上时，Linux将允许许多进程绑定到相同的端口，事实上，任何数量的进程将允许绑定上去，负载也会均衡分布。
有了SO_REUSEPORT，每一个进程都有一个独立的socket描述符。因此每一个都会拥有一个专用的UDP接收缓冲区。这样就避免了以前遇到的竞争问题：

Shell

1
2
3
4

receiver$ taskset -c 1,2,3,4 ./udpreceiver1 0.0.0.0:4321 4 1
1.114M pps 34.007MiB / 285.271Mb
1.147M pps 34.990MiB / 293.518Mb
1.126M pps 34.374MiB / 288.354Mb

现在更加喜欢了，吞吐量很不错嘛！
更多的调查显示还有进一步改进的空间。即使我们开始4个接收线程，负载也会不均匀地分布：

两个进程接收了所有的工作，而另外两个根本没有数据包。这是因为hash冲突，但是这次是在SO_REUSEPORT层。
结束语
我做了一些进一步的测试，完全一致的RX队列，接收线程在单个NUMA节点可以达到1.4Mpps。在不同的NUMA节点上运行接收者会导致这个数字做多下降到1Mpps。
总之，如果你想要一个完美的性能，你需要做下面这些：
确保流量均匀分布在许多RX队列和SO_REUSEPORT进程上。在实践中，只要有大量的连接(或流动)，负载通常是分布式的。
需要有足够的CPU容量去从内核上获取数据包。
To make the things harder, both RX queues and receiver processes should be on a single NUMA node.
为了使事情更加稳定，RX队列和接收进程都应该在单个NUMA节点上。
虽然我们已经表明，在一台Linux机器上接收1Mpps在技术上是可行的，但是应用程序将不会对收到的数据包做任何实际处理——甚至连看都不看内容的流量。别太指望这样的性能，因为对于任何实际应用并没有太大用处。

G. 如何在ubuntu安装receiver 13.6 for linux

有以下方法：
方法一：
使用Linux系统上支持Windows程序运行的用Wine程序。

方法二：
使用用虚拟机，如VMware、VirtualBox等，在虚拟机上安装Windows的虚拟机系统，然后再在虚拟机系统里面安装Windows应用程序即可。
上面两种方法对比：第一种方法对于某些Windows程序不支持，第二种方式比第一种方式繁琐，但是效果会更好一些。

H. LINUX 终端设备驱动

在Linux系统中，终端是一种字符型设备，它有多种类型，通常使用tty (Teletype）来简称各种类型的终端设备。对于嵌入式系统而言，最普遍采用的是UART (Universal Asynchronous Receiver/Transmitter)串行端口，日常生活中简称串口。
Linux内核中tty的层次结构它包含tty核心tty_10.c、tty或路规在n_tty.C(头现N_11Y线路规程）和tty驱动实例xxx_tty.c，tty线路规程的工作是以特殊的方式格式化从一个用户或者硬件收到的数据，这种格式化常常采用一个协议转换的形式tty _io.c本身是一个标准的字符设备驱动，它对上有字符改备的职贡，买现tle_operatIonS双贝图效。但是tty核心层对下又定义了tty_driver的架构，这样tty设备驱动的主体工作就变成了琪允tty_driVeT依构体中的成员，实现其中的tty_operations的成员函数，而不再是去实现file_operations这一级的工作。tty设备发送数据的流程为:tty核心从一个用户获取将要发送给一个tty设备的数据，tty核心将数据传递给tty线路规程驱动，接着数据被传递到tty驱动，tty驱动将数据转换为可以发送给硬件的格式。接收数据的流程为:从tty硬件接收到的数据向上交给tty驱动，接着进入tty线路规程驱动，再进入tty核心，在这里它被一个用户获取。尽管一个特定的底层UART设备驱动完全可以遵循上述tty_driver的方法来设计，即定义tty_driver并实现tty_operations中的成员函数，但是鉴于串口之间的共性，Linux考虑在文件drivers'ttyliserial'serial_core.c中实现了UART设备的通用tty驱动层（我们可以称其为串口核心层)。这样，UART驱动的主要任务就进一步演变成了实现serial-core.c中定义的一组uart_xxx接口而不是tty_xxx接口。因此，按照面向对象的思想，可以认为tty_driver是字符设备的泛化、serial-core是tty_driver的泛化，而具体的串口驱动又是serial-core的泛化。