评估Linux系统表现-linux-evaluate (评估量表的量念几声)

Linux是一款开放源代码的操作系统，广泛被应用于 服务器 、桌面电脑和移动设备等领域。随着Linux的不断普及和发展，许多企业和个人纷纷选择Linux作为他们的操作系统。当然，使用Linux操作系统时，我们需要对它的性能进行评估，以确保它能够满足我们的需求。本文将细致地介绍如何评估Linux系统的表现。

一、了解Linux操作系统

要评估Linux系统的表现，首先需要了解Linux操作系统的基本知识。Linux操作系统是一个开放源代码的操作系统，它可以免费下载和使用，其核心是由Linus Torvalds于1991年编写的。Linux操作系统与传统的操作系统（如Microsoft Windows）不同，因为它是基于一种分层的设计模式，该模式允许用户对操作系统进行自定义和修改。此外，Linux操作系统也支持许多语言和硬件。

二、了解Linux的性能

在评估Linux系统的表现之前，我们需要了解Linux的性能。Linux的性能可以通过以下几个指标来评估：

1. 处理能力：处理能力是指计算机系统处理信息的速度。处理能力的评估通常将cpu性能、磁盘I/O、内存带宽和网络带宽等指标纳入考虑。

2. 稳定性：稳定性是指计算机系统连续工作的时间。这通常与系统的磁盘使用率、CPU利用率和内存利用率等指标有关。

3. 可扩展性：可扩展性是指计算机系统在增加用户和处理任务时保持稳定的能力。这通常与系统的架构、内存大小和磁盘空间大小等指标有关。

三、如何评估Linux的表现

对于一个Linux系统，用户可以通过以下几个步骤来评估其表现：

1. 选择性能测试工具。Linux系统有许多性能测试工具，如Syench、IOzone、Bonnie++等。在选择工具时，我们需要考虑我们要测试的指标（如处理能力、磁盘I/O、内存带宽和网络带宽等）以及测试环境（如服务器或桌面电脑等）。

2. 配置测试环境。我们需要在测试之前配置正确的测试环境。这通常包括设置测试环境中的硬件和软件，并确保系统处于稳定状态。

3. 运行性能测试工具。运行选定的性能测试工具，并收集测试数据。这些数据可以用来评估系统的性能。

4. 分析测试结果。对测试结果进行分析，并根据测试结果来评估系统的性能。如果性能测试结果不理想，我们需要进一步优化系统配置。

四、如何优化Linux系统

对于Linux系统，我们可以通过以下几个方法来优化其性能：

1. 更新驱动程序。更新系统中的驱动程序可以提高系统的性能，并修复一些潜在的问题。

2. 禁用不必要的服务。禁用不必要的服务可以减少系统的负担，并提高系统的响应速度和稳定性。

3. 合理使用内存和磁盘空间。使用适当的内存和磁盘空间可以减少系统崩溃和抖动等问题。

4. 调整系统参数。对系统参数的调整可以提高系统性能和稳定性。

五、

在时，我们需要了解Linux系统的基本知识和性能。通过选择正确的性能测试工具，我们可以评估系统的性能，并通过优化Linux系统来提高其性能和稳定性。希望本文能对正在使用或将要使用Linux操作系统的用户有所帮助。

相关问题拓展阅读：

ranking svm 怎么用

ranking svm

排序支持向量机

拼音 双语对照

ranking svm

网络

排序支持向量机

双语例句

Therefore, this paper uses SVM and Ranking SVM to evaluate translation candidates.

因此卖纯返，本文采用裤坦SVM和Ranking SVM分别评估翻译候选。中饥

很简单啊，按照官搭返网的讲法用就好了

我是在linux上用的，解压缩之后，准备好训练集槐纤和测试集文档（比如官网的example3，解压到ranking svm路径下），用命令：铅枝仿

svm_rank_learn -c 3 example3/train.dat example3/model

就会在example3下生成model模型，再用：

svm_rank_classify example3/test.dat example3/model example3/predictions

就会生生成排序结果文件prediction，每一行的数字就是相关性大小

关于evaluate linux的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。

香港服务器首选树叶云，2H2G首月10元开通。树叶云（shuyeidc.com）提供简单好用，价格厚道的香港/美国云服务器和独立服务器。IDC+ISP+ICP资质。ARIN和APNIC会员。成熟技术团队15年行业经验。

TC的详细使用方法

给你个TC中文MAN，参考参考，也可以去我的BLOG看看，最近我也在学，名字tc - 显示／维护流量控制设置 摘要tc qdisc [ add | change | replace | link ] dev DEV [ parent qdisc-id | Root ] [ handle qdisc-id ] qdisc [ qdisc specific parameters ] tc class [ add | change | replace ] dev DEV parent qdisc-id [ classid class-id ] qdisc [ qdisc specific parameters ] tc filter [ add | change | replace ] dev DEV [ parent qdisc-id | root ] protocol protocol prio priority filtertype [ filtertype specific parameters ] flowid flow-id tc [-s | -d ] qdisc show [ dev DEV ] tc [-s | -d ] class show dev DEV tc filter show dev DEV 简介Tc用于Linux内核的流量控制。 流量控制包括以下几种方式：SHAPING(限制)当流量被限制，它的传输速率就被控制在某个值以下。 限制值可以大大小于有效带宽，这样可以平滑突发数据流量，使网络更为稳定。 shaping（限制）只适用于向外的流量。 SCHEDULING(调度)通过调度数据包的传输，可以在带宽范围内，按照优先级分配带宽。 SCHEDULING(调度)也只适于向外的流量。 POLICING(策略)SHAPING用于处理向外的流量，而POLICIING(策略)用于处理接收到的数据。 DROPPING(丢弃)如果流量超过某个设定的带宽，就丢弃数据包，不管是向内还是向外。 流量的处理由三种对象控制，它们是：qdisc(排队规则)、class(类别)和filter(过滤器)。 QDISC(排队嬖?QDisc(排队规则)是queueing discipline的简写，它是理解流量控制(traffic control)的基础。 无论何时，内核如果需要通过某个网络接口发送数据包，它都需要按照为这个接口配置的qdisc(排队规则)把数据包加入队列。 然后，内核会尽可能多地从qdisc里面取出数据包，把它们交给网络适配器驱动模块。 最简单的QDisc是pfifo它不对进入的数据包做任何的处理，数据包采用先入先出的方式通过队列。 不过，它会保存网络接口一时无法处理的数据包。 CLASS(类)某些QDisc(排队规则)可以包含一些类别，不同的类别中可以包含更深入的QDisc(排队规则)，通过这些细分的QDisc还可以为进入的队列的数据包排队。 通过设置各种类别数据包的离队次序，QDisc可以为设置网络数据流量的优先级。 FILTER(过滤器)filter(过滤器)用于为数据包分类，决定它们按照何种QDisc进入队列。 无论何时数据包进入一个划分子类的类别中，都需要进行分类。 分类的方法可以有多种，使用fileter(过滤器)就是其中之一。 使用filter(过滤器)分类时，内核会调用附属于这个类(class)的所有过滤器，直到返回一个判决。 如果没有判决返回，就作进一步的处理，而处理方式和QDISC有关。 需要注意的是，filter(过滤器)是在QDisc内部，它们不能作为主体。 CLASSLESS QDisc(不可分类QDisc)无类别QDISC包括： [p|b]fifo使用最简单的qdisc，纯粹的先进先出。 只有一个参数：limit，用来设置队列的长度,pfifo是以数据包的个数为单位；bfifo是以字节数为单位。 pfifo_fast在编译内核时，如果打开了高级路由器(Advanced Router)编译选项，pfifo_fast就是系统的标准QDISC。 它的队列包括三个波段(band)。 在每个波段里面，使用先进先出规则。 而三个波段(band)的优先级也不相同，band 0的优先级最高，band 2的最低。 如果band里面有数据包，系统就不会处理band 1里面的数据包，band 1和band 2之间也是一样。 数据包是按照服务类型(Type of Service,TOS)被分配多三个波段(band)里面的。 redred是Random Early Detection(随机早期探测)的简写。 如果使用这种QDISC，当带宽的占用接近于规定的带宽时，系统会随机地丢弃一些数据包。 它非常适合高带宽应用。 sfqsfq是Stochastic Fairness Queueing的简写。 它按照会话(session--对应于每个TCP连接或者UDP流)为流量进行排序，然后循环发送每个会话的数据包。 tbftbf是Token Bucket Filter的简写，适合于把流速降低到某个值。 不可分类QDisc的配置如果没有可分类QDisc，不可分类QDisc只能附属于设备的根。 它们的用法如下： tc qdisc add dev DEV root QDISC QDISC-PARAMETERS 要删除一个不可分类QDisc，需要使用如下命令： tc qdisc del dev DEV root 一个网络接口上如果没有设置QDisc，pfifo_fast就作为缺省的QDisc。 CLASSFUL QDISC(分类QDisc)可分类的QDisc包括： CBQCBQ是Class Based Queueing(基于类别排队)的缩写。 它实现了一个丰富的连接共享类别结构，既有限制(shaping)带宽的能力，也具有带宽优先级管理的能力。 带宽限制是通过计算连接的空闲时间完成的。 空闲时间的计算标准是数据包离队事件的频率和下层连接(数据链路层)的带宽。 HTBHTB是Hierarchy Token Bucket的缩写。 通过在实践基础上的改进，它实现了一个丰富的连接共享类别体系。 使用HTB可以很容易地保证每个类别的带宽，虽然它也允许特定的类可以突破带宽上限，占用别的类的带宽。 HTB可以通过TBF(Token Bucket Filter)实现带宽限制，也能够划分类别的优先级。 PRIOPRIO QDisc不能限制带宽，因为属于不同类别的数据包是顺序离队的。 使用PRIO QDisc可以很容易对流量进行优先级管理，只有属于高优先级类别的数据包全部发送完毕，才会发送属于低优先级类别的数据包。 为了方便管理，需要使用iptables或者ipchains处理数据包的服务类型(Type Of Service,ToS)。 操作原理类(Class)组成一个树，每个类都只有一个父类，而一个类可以有多个子类。 某些QDisc(例如：CBQ和HTB)允许在运行时动态添加类，而其它的QDisc(例如：PRIO)不允许动态建立类。 允许动态添加类的QDisc可以有零个或者多个子类，由它们为数据包排队。 此外，每个类都有一个叶子QDisc，默认情况下，这个叶子QDisc使用pfifo的方式排队，我们也可以使用其它类型的QDisc代替这个默认的QDisc。 而且，这个叶子叶子QDisc有可以分类，不过每个子类只能有一个叶子QDisc。 当一个数据包进入一个分类QDisc，它会被归入某个子类。 我们可以使用以下三种方式为数据包归类，不过不是所有的QDisc都能够使用这三种方式。 tc过滤器(tc filter)如果过滤器附属于一个类，相关的指令就会对它们进行查询。 过滤器能够匹配数据包头所有的域，也可以匹配由ipchains或者iptables做的标记。 服务类型(Type of Service)某些QDisc有基于服务类型（Type of Service,ToS）的内置的规则为数据包分类。 skb->priority用户空间的应用程序可以使用SO_PRIORITY选项在skb->priority域设置一个类的ID。 树的每个节点都可以有自己的过滤器，但是高层的过滤器也可以直接用于其子类。 如果数据包没有被成功归类，就会被排到这个类的叶子QDisc的队中。 相关细节在各个QDisc的手册页中。 命名规则所有的QDisc、类和过滤器都有ID。 ID可以手工设置，也可以有内核自动分配。 ID由一个主序列号和一个从序列号组成，两个数字用一个冒号分开。 QDISC一个QDisc会被分配一个主序列号，叫做句柄(handle)，然后把从序列号作为类的命名空间。 句柄采用象10:一样的表达方式。 习惯上，需要为有子类的QDisc显式地分配一个句柄。 类(CLASS)在同一个QDisc里面的类分享这个QDisc的主序列号，但是每个类都有自己的从序列号，叫做类识别符(classid)。 类识别符只与父QDisc有关，和父类无关。 类的命名习惯和QDisc的相同。 过滤器(FILTER)过滤器的ID有三部分，只有在对过滤器进行散列组织才会用到。 详情请参考tc-filters手册页。 单位tc命令的所有参数都可以使用浮点数，可能会涉及到以下计数单位。 带宽或者流速单位： kbps千字节／秒 mbps兆字节／秒 kbitKBits／秒 mbitMBits／秒 bps或者一个无单位数字字节数／秒 数据的数量单位： kb或者k千字节 mb或者m兆字节 mbit兆bit kbit千bit b或者一个无单位数字字节数 时间的计量单位： s、sec或者secs秒 ms、msec或者msecs分钟 us、usec、usecs或者一个无单位数字微秒 TC命令tc可以使用以下命令对QDisc、类和过滤器进行操作： add在一个节点里加入一个QDisc、类或者过滤器。 添加时，需要传递一个祖先作为参数，传递参数时既可以使用ID也可以直接传递设备的根。 如果要建立一个QDisc或者过滤器，可以使用句柄(handle)来命名；如果要建立一个类，可以使用类识别符(classid)来命名。 remove删除有某个句柄(handle)指定的QDisc，根QDisc(root)也可以删除。 被删除QDisc上的所有子类以及附属于各个类的过滤器都会被自动删除。 change以替代的方式修改某些条目。 除了句柄(handle)和祖先不能修改以外，change命令的语法和add命令相同。 换句话说，change命令不能一定节点的位置。 replace对一个现有节点进行近于原子操作的删除／添加。 如果节点不存在，这个命令就会建立节点。 link只适用于DQisc，替代一个现有的节点。 历史tc由Alexey N. Kuznetsov编写，从Linux 2.2版开始并入Linux内核。 SEE ALSOtc-cbq(8)、tc-htb(8)、tc-sfq(8)、tc-red(8)、tc-tbf(8)、tc-pfifo(8)、tc-bfifo(8)、tc-pfifo_fast(8)、tc-filters(8) Linux从kernel 2.1.105开始支持QOS，不过，需要重新编译内核。 运行make config时将EXPERIMENTAL _OPTIONS设置成y，并且将Class Based Queueing (CBQ), Token Bucket Flow, Traffic Shapers 设置为 y ，运行 make dep; make clean; make bzilo，生成新的内核。 在Linux操作系统中流量控制器(TC)主要是在输出端口处建立一个队列进行流量控制，控制的方式是基于路由，亦即基于目的IP地址或目的子网的网络号的流量控制。 流量控制器TC，其基本的功能模块为队列、分类和过滤器。 Linux内核中支持的队列有，Class Based Queue ，Token Bucket Flow ，CSZ ，First In First Out ，Priority ，TEQL ，SFQ ，ATM ，RED。 这里我们讨论的队列与分类都是基于CBQ(Class Based Queue)的，而过滤器是基于路由(Route)的。 配置和使用流量控制器TC，主要分以下几个方面：分别为建立队列、建立分类、建立过滤器和建立路由，另外还需要对现有的队列、分类、过滤器和路由进行监视。 其基本使用步骤为： 1) 针对网络物理设备(如以太网卡eth0)绑定一个CBQ队列； 2) 在该队列上建立分类； 3) 为每一分类建立一个基于路由的过滤器； 4) 最后与过滤器相配合，建立特定的路由表。 先假设一个简单的环境 流量控制器上的以太网卡(eth0) 的IP地址为192.168.1.66，在其上建立一个CBQ队列。 假设包的平均大小为1000字节，包间隔发送单元的大小为8字节，可接收冲突的发送最长包数目为20字节。 假如有三种类型的流量需要控制: 1) 是发往主机1的，其IP地址为192.168.1.24。 其流量带宽控制在8Mbit，优先级为2； 2) 是发往主机2的，其IP地址为192.168.1.26。 其流量带宽控制在1Mbit，优先级为1； 3) 是发往子网1的，其子网号为192.168.1.0，子网掩码为255.255.255.0。 流量带宽控制在1Mbit，优先级为6。 1. 建立队列 一般情况下，针对一个网卡只需建立一个队列。 将一个cbq队列绑定到网络物理设备eth0上，其编号为1:0；网络物理设备eth0的实际带宽为10 Mbit，包的平均大小为1000字节；包间隔发送单元的大小为8字节，最小传输包大小为64字节。 ?tc qdisc add dev eth0 root handle 1: cbq bandwidth 10Mbit avpkt 1000 cell 8 mpu 64 2. 建立分类 分类建立在队列之上。 一般情况下，针对一个队列需建立一个根分类，然后再在其上建立子分类。 对于分类，按其分类的编号顺序起作用，编号小的优先；一旦符合某个分类匹配规则，通过该分类发送数据包，则其后的分类不再起作用。 1） 创建根分类1:1；分配带宽为10Mbit，优先级别为8。 ?tc class add dev eth0 parent 1:0 classid 1:1 cbq bandwidth 10Mbit rate 10Mbit maxburst 20 allot 1514 prio 8 avpkt 1000 cell 8 weight 1Mbit 该队列的最大可用带宽为10Mbit，实际分配的带宽为10Mbit，可接收冲突的发送最长包数目为20字节；最大传输单元加MAC头的大小为1514字节，优先级别为8，包的平均大小为1000字节，包间隔发送单元的大小为8字节，相应于实际带宽的加权速率为1Mbit。 2）创建分类1:2，其父分类为1:1，分配带宽为8Mbit，优先级别为2。 ?tc class add dev eth0 parent 1:1 classid 1:2 cbq bandwidth 10Mbit rate 8Mbit maxburst 20 allot 1514 prio 2 avpkt 1000 cell 8 weight 800Kbit split 1:0 bounded 该队列的最大可用带宽为10Mbit，实际分配的带宽为 8Mbit，可接收冲突的发送最长包数目为20字节；最大传输单元加MAC头的大小为1514字节，优先级别为1，包的平均大小为1000字节，包间隔发送单元的大小为8字节，相应于实际带宽的加权速率为800Kbit，分类的分离点为1:0，且不可借用未使用带宽。 3）创建分类1:3，其父分类为1:1，分配带宽为1Mbit，优先级别为1。 ?tc class add dev eth0 parent 1:1 classid 1:3 cbq bandwidth 10Mbit rate 1Mbit maxburst 20 allot 1514 prio 1 avpkt 1000 cell 8 weight 100Kbit split 1:0 该队列的最大可用带宽为10Mbit，实际分配的带宽为 1Mbit，可接收冲突的发送最长包数目为20字节；最大传输单元加MAC头的大小为1514字节，优先级别为2，包的平均大小为1000字节，包间隔发送单元的大小为8字节，相应于实际带宽的加权速率为100Kbit，分类的分离点为1:0。 4）创建分类1:4，其父分类为1:1，分配带宽为1Mbit，优先级别为6。 ?tc class add dev eth0 parent 1:1 classid 1:4 cbq bandwidth 10Mbit rate 1Mbit maxburst 20 allot 1514 prio 6 avpkt 1000 cell 8 weight 100Kbit split 1:0 该队列的最大可用带宽为10Mbit，实际分配的带宽为 64Kbit，可接收冲突的发送最长包数目为20字节；最大传输单元加MAC头的大小为1514字节，优先级别为1，包的平均大小为1000字节，包间隔发送单元的大小为8字节，相应于实际带宽的加权速率为100Kbit，分类的分离点为1:0。 3. 建立过滤器 过滤器主要服务于分类。 一般只需针对根分类提供一个过滤器，然后为每个子分类提供路由映射。 1） 应用路由分类器到cbq队列的根，父分类编号为1:0；过滤协议为ip，优先级别为100，过滤器为基于路由表。 ?tc filter add dev eth0 parent 1:0 protocol ip prio 100 route 2） 建立路由映射分类1:2, 1:3, 1:4 ?tc filter add dev eth0 parent 1:0 protocol ip prio 100 route to 2 flowid 1:2 ?tc filter add dev eth0 parent 1:0 protocol ip prio 100 route to 3 flowid 1:3 ?tc filter add dev eth0 parent 1:0 protocol ip prio 100 route to 4 flowid 1:4 4.建立路由 该路由是与前面所建立的路由映射一一对应。 1） 发往主机192.168.1.24的数据包通过分类2转发(分类2的速率8Mbit) ?ip route add 192.168.1.24 dev eth0 via 192.168.1.66 realm 2 2） 发往主机192.168.1.30的数据包通过分类3转发(分类3的速率1Mbit) ?ip route add 192.168.1.30 dev eth0 via 192.168.1.66 realm 3 3）发往子网192.168.1.0/24的数据包通过分类4转发(分类4的速率1Mbit) ?ip route add 192.168.1.0/24 dev eth0 via 192.168.1.66 realm 4 注：一般对于流量控制器所直接连接的网段建议使用IP主机地址流量控制限制，不要使用子网流量控制限制。 如一定需要对直连子网使用子网流量控制限制，则在建立该子网的路由映射前，需将原先由系统建立的路由删除，才可完成相应步骤。 5. 监视 主要包括对现有队列、分类、过滤器和路由的状况进行监视。 1）显示队列的状况 简单显示指定设备(这里为eth0)的队列状况 ?tc qdisc ls dev eth0 qdisc cbq 1: rate 10Mbit (bounded,isolated) prio no-transmit 详细显示指定设备(这里为eth0)的队列状况 ?tc -s qdisc ls dev eth0 qdisc cbq 1: rate 10Mbit (bounded,isolated) prio no-transmit Sent bytes pkts (dropped 0, overlimits 0) borrowed 0 overactions 0 avgidle 31 undertime 0 这里主要显示了通过该队列发送了个数据包，数据流量为个字节，丢弃的包数目为0，超过速率限制的包数目为0。 2）显示分类的状况 简单显示指定设备(这里为eth0)的分类状况 ?tc class ls dev eth0 class cbq 1: root rate 10Mbit (bounded,isolated) prio no-transmit class cbq 1:1 parent 1: rate 10Mbit prio no-transmit #no-transmit表示优先级为8 class cbq 1:2 parent 1:1 rate 8Mbit prio 2 class cbq 1:3 parent 1:1 rate 1Mbit prio 1 class cbq 1:4 parent 1:1 rate 1Mbit prio 6 详细显示指定设备(这里为eth0)的分类状况 ?tc -s class ls dev eth0 class cbq 1: root rate 10Mbit (bounded,isolated) prio no-transmit Sent bytes pkts (dropped 0, overlimits 0) borrowed 0 overactions 0 avgidle 31 undertime 0 class cbq 1:1 parent 1: rate 10Mbit prio no-transmit Sent bytes pkts (dropped 0, overlimits 0) borrowed overactions 0 avgidle 587 undertime 0 class cbq 1:2 parent 1:1 rate 8Mbit prio 2 Sent bytes 3130 pkts (dropped 0, overlimits 0) borrowed 0 overactions 0 avgidle 4137 undertime 0 class cbq 1:3 parent 1:1 rate 1Mbit prio 1 Sent 0 bytes 0 pkts (dropped 0, overlimits 0) borrowed 0 overactions 0 avgidle undertime 0 class cbq 1:4 parent 1:1 rate 1Mbit prio 6 Sent bytes 8076 pkts (dropped 0, overlimits 0) borrowed 3797 overactions 0 avgidle undertime 0 这里主要显示了通过不同分类发送的数据包，数据流量，丢弃的包数目，超过速率限制的包数目等等。 其中根分类(class cbq 1:0)的状况应与队列的状况类似。 例如，分类class cbq 1:4发送了8076个数据包，数据流量为个字节，丢弃的包数目为0，超过速率限制的包数目为0。 显示过滤器的状况 ?tc -s filter ls dev eth0 filter parent 1: protocol ip pref 100 route filter parent 1: protocol ip pref 100 route fh 0xffff0002 flowid 1:2 to 2 filter parent 1: protocol ip pref 100 route fh 0xffff0003 flowid 1:3 to 3 filter parent 1: protocol ip pref 100 route fh 0xffff0004 flowid 1:4 to 4 这里flowid 1:2代表分类class cbq 1:2，to 2代表通过路由2发送。 显示现有路由的状况 ?ip route 192.168.1.66 dev eth0 scope link 192.168.1.24 via 192.168.1.66 dev eth0 realm 2 202.102.24.216 dev ppp0 proto kernel scope link src 202.102.76.5 192.168.1.30 via 192.168.1.66 dev eth0 realm 3 192.168.1.0/24 via 192.168.1.66 dev eth0 realm 4 192.168.1.0/24 dev eth0 proto kernel scope link src 192.168.1.66 172.16.1.0/24 via 192.168.1.66 dev eth0 scope link 127.0.0.0/8 dev lo scope link default via 202.102.24.216 dev ppp0 default via 192.168.1.254 dev eth0 如上所示，结尾包含有realm的显示行是起作用的路由过滤器。 6. 维护 主要包括对队列、分类、过滤器和路由的增添、修改和删除。 增添动作一般依照队列->分类->过滤器->路由的顺序进行；修改动作则没有什么要求；删除则依照路由->过滤器->分类->队列的顺序进行。 1）队列的维护 一般对于一台流量控制器来说，出厂时针对每个以太网卡均已配置好一个队列了，通常情况下对队列无需进行增添、修改和删除动作了。 2）分类的维护 增添 增添动作通过tc class add命令实现，如前面所示。 修改 修改动作通过tc class change命令实现，如下所示： ?tc class change dev eth0 parent 1:1 classid 1:2 cbq bandwidth 10Mbitrate 7Mbit maxburst 20 allot 1514 prio 2 avpkt 1000 cell 8 weight 700Kbit split 1:0 bounded 对于bounded命令应慎用，一旦添加后就进行修改，只可通过删除后再添加来实现。 删除 删除动作只在该分类没有工作前才可进行，一旦通过该分类发送过数据，则无法删除它了。 因此，需要通过shell文件方式来修改，通过重新启动来完成删除动作。 3）过滤器的维护 增添 增添动作通过tc filter add命令实现，如前面所示。 修改 修改动作通过tc filter change命令实现，如下所示： ?tc filter change dev eth0 parent 1:0 protocol ip prio 100 route to 10 flowid 1:8 删除 删除动作通过tc filter del命令实现，如下所示： ?tc filter del dev eth0 parent 1:0 protocol ip prio 100 route to 10 4）与过滤器一一映射路由的维护 增添 增添动作通过ip route add命令实现，如前面所示。 修改 修改动作通过ip route change命令实现，如下所示： ?ip route change 192.168.1.30 dev eth0 via 192.168.1.66 realm 8 删除 删除动作通过ip route del命令实现，如下所示： ?ip route del 192.168.1.30 dev eth0 via 192.168.1.66 realm 8 ?ip route del 192.168.1.0/24 dev eth0 via 192.168.1.66 realm 4

Linux内核为了提高内存的使用效率采用过度分配内存(over-commit memory)的办法，造成物理内存过度紧张进而触发OOM机制来杀死一些进程回收内存。 该机制会监控那些占用内存过大，尤其是瞬间很快消耗大量内存的进程，为了防止内存耗尽会把该进程杀掉。 Linux在内存分配路径上会对内存余量做检查，（1）如果检查到内存不足，则触发OOM机制。 （2）OOM首先会对系统所有进程(出init和内核线程等特殊进程)进行打分，并选出最bad的进程；然后杀死该进程。 （3）同时会触发内核oom_reaper进行内存收割。 （4）同时内核还提供了sysfs接口系统OOM行为，以及进程OOM行为。 然后借用一个示例来分析OOM时内存状态。 1. 关于OOM 内核检测到系统内存不足，在内存分配路径上触发 out_of_memory() ，然后调用 select_bad_process() 选择一个bad进程 oom_kill_process() 杀掉，判断和选择一个‘bad进程的过程由 oom_badness() 决定。 Linux下每个进程都有自己的OOM权重，在/proc//oom_adj里面，范围是-17到+15，取值越高，越容易被杀掉。 2. OOM触发路径 在内存分配路径上，当内存不足的时候会触发kswapd、或者内存规整，极端情况会触发OOM，来获取更多内存。 在内存回收失败之后，__alloc_pages_may_oom是OOM的入口，但是主要工作在out_of_memory中进行处理。 由于Linux内存都是以页为单位，所以__alloc_pages_nodemask是必经之处。 static inline struct page * __alloc_pages_may_oom(gfp_t gfp_mask, unsigned int order, const struct alloc_context *ac, unsigned long *did_some_progress) { struct oom_control oc = {---------------------------------------------------------OOM控制参数。 = ac->zonelist, = ac->nodemask, = NULL, _mask = gfp_mask, = order, }; struct page *page; *did_some_progress = 0; /** Acquire the oom lock. If that fails, somebody else is* making progress for us.*/ if (!mutex_trylock(&oom_lock)) { *did_some_progress = 1; schedule_timeout_uninterruptible(1); return NULL; } page = get_page_from_freelist(gfp_mask | __GFP_HARDWALL, order, ALLOC_WMARK_HIGH|ALLOC_CPUSET, ac);-----------------------------再次使用高水位检查一次，是否需要启动OOM流程。 if (page) goto out; if (!(gfp_mask & __GFP_NOFAIL)) {----------------------------------------------__GFP_NOFAIL是不允许内存申请失败的情况，下面都是允许失败的处理。 /* Coredumps can quickly deplete all memory reserves */ if (current->flags & PF_DUMPCORE) goto out; /* The OOM killer will not help higher order allocs */ if (order > PAGE_ALLOC_COSTLY_ORDER)---------------------------------------order超过3的申请失败，不会启动OOM回收。 goto out; /* The OOM killer does not needlessly kill tasks for lowmem */ if (ac->high_zoneidx < ZONE_NORMAL) goto out; if (pm_suspended_storage()) goto out; /* The OOM killer may not free memory on a specific node */ if (gfp_mask & __GFP_THISNODE) goto out; } /* Exhausted what can be done so its blamo time */ if (out_of_memory(&oc) || WARN_ON_ONCE(gfp_mask & __GFP_NOFAIL)) {-------------经过上面各种情况，任然需要进行OOM处理。 调用out_of_memory()。 *did_some_progress = 1; if (gfp_mask & __GFP_NOFAIL) { page = get_page_from_freelist(gfp_mask, order, ALLOC_NO_WATERMARKS|ALLOC_CPUSET, ac);-------------------------对于__GFP_NOFAIL的分配情况，降低分配条件从ALLOC_WMARK_HIGH|ALLOC_CPUSET降低到ALLOC_NO_WATERMARKS|ALLOC_CPUSET。 /** fallback to ignore cpuset restriction if our nodes* are depleted*/ if (!page) page = get_page_from_freelist(gfp_mask, order, ALLOC_NO_WATERMARKS, ac);--------------------------------------如果还是分配失败，再次降低分配标准，从ALLOC_NO_WATERMARKS|ALLOC_CPUSET降低到ALLOC_NO_WATERMARKS。 真的是为了成功，节操越来越低啊。 } } out: mutex_unlock(&oom_lock); return page; } 4.3 OOM处理：对进程打分以及杀死最高评分进程 out_of_memory函数是OOM机制的核心，他可以分为两部分。 一是调挑选最’bad‘的进程，二是杀死它。 bool out_of_memory(struct oom_control *oc) { unsigned long freed = 0; enum oom_constraint constraint = CONSTRAINT_NONE; if (oom_killer_disabled)----------------------------------------------------在freeze_processes会将其置位，即禁止OOM；在thaw_processes会将其清零，即打开OOM。 所以，如果在冻结过程，不允许OOM。 return false; if (!is_memcg_oom(oc)) { blocking_notifier_call_chain(&oom_notify_list, 0, &freed); if (freed > 0) /* Got some memory back in the last second. */ return true; } if (task_will_free_mem(current)) {----------------------------------------如果当前进程正因为各种原因将要退出，或者释放内存，将当前进程作为OOM候选者，然后唤醒OOM reaper去收割进而释放内存。 mark_oom_victim(current); wake_oom_reaper(current); return true;---------------------当前进程由于自身原因将要推出，OOM则将其标注为TIF_MEMDIE状态；然后唤醒OOM Reaper去处理。 不需要经过下面的打分和杀死流程。 } if (oc->gfp_mask && !(oc->gfp_mask & (__GFP_FS|__GFP_NOFAIL)))-----------如果内存申请掩码包括__GFP_DS或__GFP_NOFAIL，则不进行OOM收割。 return true; constraint = constrained_alloc(oc);--------------------------------------未定义CONFIG_NUMA返回CONSTRAINT_NONE。 if (constraint != CONSTRAINT_MEMORY_POLICY) oc->nodemask = NULL; check_panic_on_oom(oc, constraint);--------------------------------------检查sysctl_panic_on_oom设置，以及是否由sysrq触发，来决定是否触发panic。 if (!is_memcg_oom(oc) && sysctl_oom_kill_allocating_task &&--------------如果设置了sysctl_oom_kill_allocating_task，那么当内存耗尽时，会把当前申请内存分配的进程杀掉。 current->mm && !oom_unkillable_task(current, NULL, oc->nodemask) && current->signal->oom_score_adj != OOM_SCORE_ADJ_MIN) { get_task_struct(current); oc->chosen = current; oom_kill_process(oc, Out of memory (oom_kill_allocating_task)); return true; } select_bad_process(oc);-------------------------------------------------遍历所有进程，进程下的线程，查找合适的候选进程。 即得分最高的候选进程。 /* Found nothing?!?! Either we hang forever, or we panic. */ if (!oc->chosen && !is_sysrq_oom(oc) && !is_memcg_oom(oc)) {------------如果没有合适候选进程，并且OOM不是由sysrq触发的，进入panic。 dump_header(oc, NULL); panic(Out of memory and no killable processes...\n); } if (oc->chosen && oc->chosen != (void *)-1UL) { oom_kill_process(oc, !is_memcg_oom(oc) ? Out of memory :Memory cgroup out of memory);----------------------------杀死选中的进程。 schedule_timeout_killable(1); } return !!oc->chosen; }select_bad_process()通过oom_evaluate_task()来评估每个进程的得分，对于进程1、内核线程、得分低的进程直接跳过。 static void select_bad_process(struct oom_control *oc) { if (is_memcg_oom(oc)) mem_cgroup_scan_tasks(oc->memcg, oom_evaluate_task, oc); else { struct task_struct *p; rcu_read_lock(); for_each_process(p)----------------------------------------------遍历系统范围内所有进程线程。 if (oom_evaluate_task(p, oc)) break; rcu_read_unlock(); } oc->chosen_points = oc->chosen_points * 1000 / oc->totalpages; } static int oom_evaluate_task(struct task_struct *task, void *arg) { struct oom_control *oc = arg; unsigned long points; if (oom_unkillable_task(task, NULL, oc->nodemask))-------------------进程1以及内核线程等等不能被kill的线程跳过。 goto next; if (!is_sysrq_oom(oc) && tsk_is_oom_victim(task)) { if (test_bit(MMF_OOM_SKIP, &task->signal->oom_mm->flags)) goto next; goto abort; } if (oom_task_origin(task)) { points = ULONG_MAX; goto select; } points = oom_badness(task, NULL, oc->nodemask, oc->totalpages);------对进程task进行打分。 if (!points || points < oc->chosen_points)---------------------------这里保证只取最高分的进程，所以分数最高者被选中。 其他情况则直接跳过。 goto next; /* Prefer thread group leaders for display purposes */ if (points == oc->chosen_points && thread_group_leader(oc->chosen)) goto next; select: if (oc->chosen) put_task_struct(oc->chosen); get_task_struct(task); oc->chosen = task;--------------------------------------------------更新OOM选中的进程和当前最高分。 oc->chosen_points = points; next: return 0; abort: if (oc->chosen) put_task_struct(oc->chosen); oc->chosen = (void *)-1UL; return 1; } 在oom_badness()中计算当前进程的得分，返回选中进程的结构体，以及进程得分ppoints。 oom_badness()是给进程打分的函数，可以说是核心中的核心。 最终结果受oom_score_adj和当前进程内存使用量综合影响。 oom_score_adj为OOM_SCORE_ADJ_MIN的进程不参加评选。 进程的oom_score_adj值在/proc/xxx/oom_score_adj中。 mm->flags为MMF_OOM_SKIP的进程不参加评选。 处于vfork()中的进程不参加评选。 进程的得分取决于其消耗的RSS部分内存(文件映射内存MM_FILEPAGES、匿名映射内存MM_ANONPAGES、shmem内存MM_SHMEMPAGES)、匿名交换内存MM_SWAPENTS、PTE页表所占内存、PMD页表所占内存。 具有root权限的进程只取其97%的得分参加评选。 所以进程得分points=process_pages + oom_score_adj*totalpages/1000；如果是root权限的进程points=process_pages*0.97 + oom_score_adj*totalpages/1000。 在oom_score_adj都为0(默认值)的情况下，最终得分跟进程自身消耗的内存有关；消耗的内存越大越容易被Kill。 oom_score_adj每降低1，可以多获得系统内存资源的1/1000使用量。 反之，每增加1，则少获得系统内存资源1/1000使用量。 unsigned long oom_badness(struct task_struct *p, struct mem_cgroup *memcg,const nodemask_t *nodemask, unsigned long totalpages) { long points; long adj; if (oom_unkillable_task(p, memcg, nodemask))-------------------------------如果进程不可被杀，直接跳过。 return 0; p = find_lock_task_mm(p);------------找到进程p，并使用task_lock()锁上。 if (!p) return 0; /** Do not even consider tasks which are explicitly marked oom* unkillable or have been already oom reaped or the are in* the middle of vfork*/ adj = (long)p->signal->oom_score_adj;--------------------------------------获取当前进程的oom_score_adj参数。 if (adj == OOM_SCORE_ADJ_MIN || test_bit(MMF_OOM_SKIP, &p->mm->flags) || in_vfork(p)) { task_unlock(p); return 0;--------------------------------------------------------------如果当前进程oom_score_adj为OOM_SCORE_ADJ_MIN的话，就返回0.等于告诉OOM，此进程不参数bad评比。 } /** The baseline for the badness score is the proportion of RAM that each* tasks rss, pagetable and swap space use.*/ points = get_mm_rss(p->mm) + get_mm_counter(p->mm, MM_SWAPENTS) + atomic_long_read(&p->mm->nr_ptes) + mm_nr_pmds(p->mm);-----------------可以看出points综合了内存占用情况，包括RSS部分、swap file或者swap device占用内存、以及页表占用内存。 task_unlock(p); /** Root processes get 3% bonus, just like the __vm_enough_memory()* implementation used by LSMs.*/ if (has_capability_noaudit(p, CAP_SYS_ADMIN))------------------------------如果是root用户，增加3%的使用特权。 points -= (points * 3) / 100; /* Normalize to oom_score_adj units */ adj *= totalpages / 1000;--------------------------------------------------这里可以看出oom_score_adj对最终分数的影响，如果oom_score_adj小于0，则最终points就会变小，进程更加不会被选中。 points += adj;-------------------------------------------------------------将归一化后的adj和points求和，作为当前进程的分数。 /** Never return 0 for an eligible task regardless of the root bonus and* oom_score_adj (oom_score_adj cant be OOM_SCORE_ADJ_MIN here).*/ return points > 0 ? points : 1; }

使用 Linux 命令 expr/bc 进行数学运算

在Linux系统中，用于数学运算的命令主要有expr和bc。 expr命令，全称为evaluate expressions，主要用于整数计算和字符串处理，例如计算字符串长度、字符串比较、字符串匹配、字符串提取等。 需要注意的是，expr仅支持整数，若需进行浮点数运算，应使用bc命令。 bc命令，全称为Basic Calculator，是一款强大的浮点数和高精度计算工具，适用于处理各种数学运算，包括加减乘除、指数运算、取模、求平方根等。 其输入和输出方式类似于C语言，便于执行计算。 基本用法包括直接在终端中输入表达式并按回车键获得结果。 对于浮点数运算，可以通过设置scale变量来控制小数点后的位数。 bc还支持使用变量和函数进行更复杂的计算，例如定义函数来计算圆的面积。 在进行高级运算时，bc命令能够执行浮点运算和一些高级函数，如设定小数精度、进行进制转换及计算平方和平方根等。 expr与bc的主要区别在于，expr仅支持整数运算，而bc支持浮点数运算及整数运算，功能更加强大。