本文介绍了HAWQ如何通过全局资源管理、资源队列等方式管理CPU、内存等系统资源，详细阐述了独立资源管理模式与YARN整合模式的配置方法，并提供了资源队列管理的最佳实践。
目录
一、HAWQ 如何管理资源
HAWQ 使用多种机制管理 CPU、内存、I/O、文件句柄等系统资源，包括全局资源管理、资源队列、强制资源使用限额等。
1. 全局资源管理
Hadoop 通常使用 YARN 全局管理资源，YARN 是一个通用的资源管理框架，为 MapReduce 作业或其他配置了 YARN 的应用提供资源。在 YARN 环境中，资源分配的单位被称为容器（container），YARN 还能强制限制每个集群节点上的可用资源。图1 展示了 Hadoop YARN 环境下的 HAWQ 集群布局。
图1
可以将 HAWQ 配置为一个在 YARN 中注册的应用，执行查询时，HAWQ 的资源管理器与 YARN 通信以获取所需的资源。之后 HAWQ master 主机上的资源管理器管理分配这些从 YARN 获得的资源，当资源使用完成时返还给 YARN。
2. HAWQ 资源队列
资源队列是 HAWQ 系统中并发管理的主要工具，它是一种数据库对象，可以使用 CREATE RESOURCE QUEUE 语句创建。资源队列控制可以并发执行的活跃查询数量，以及为每种查询类型分配的最大内存、CUP 数量。资源队列还可以限制一个查询消耗的资源总量，避免个别查询使用过多的资源而影响系统整体的性能。
HAWQ 内部基于资源队列层次系统动态管理资源。资源队列的数据结构为一棵 n 叉树，如图2 所示。
图2
HAWQ 初始化后有一个根队列 pg_root 和一个缺省的队列 pg_default，如果使用 YARN 模式，HAWQ 资源管理器自动从全局资源管理器获得根队列资源。当创建了一个新的资源队列时，必须指定其父队列，以这种方式将所有资源队列组织到一棵树中。
执行查询时，进行编译和语义分析后，优化器与 HAWQ 资源管理器协调查询的资源使用情况，得到基于可用资源的优化的查询计划。查询分发器将每个查询的资源分配与查询计划一同发送给 segment。这样，segment 上的查询执行器（QE）就知道当前查询的资源配额，并在整个执行过程中使用这些资源。查询结束或终止后，资源返还给 HAWQ 资源管理器。
资源队列树中，只有叶子队列可以被授予角色和接受查询。资源分配策略如下：
- 只为正在运行或排队的查询分配资源队列。
- 多个查询竞争时，HAWQ 资源管理器自动依据可用资源情况平衡队列间的资源。
- 在一个资源队列中，如果有多个查询等待资源，最终资源以 Best-Effort 方式分配给每个查询。
二、资源管理器配置最佳实践
配置资源管理时可以使用下面 HAWQ 给出的的实践原则，保证高效的资源管理和最佳系统性能：
- segment 节点没有相同的 IP 地址。某些软件使用自动配置 IP 地址的虚拟网卡，这可能造成某些 HAWQ segment 得到相同的 IP 地址。这种情况下，资源管理器的容错服务组件只能认到相同 IP 中的一个 segment。
- 所有 segment 配置相同的资源容量配额。
- 为了避免资源碎片化，配置 segment 资源配额为所有虚拟段资源限额的整数倍。
- 确保有足够已注册的 segment 响应资源请求。如果失效的 segment 超过了限制，资源请求被拒绝。
- master 和 segment 使用多个独立的大磁盘（2T 或以上）的临时目录，例如 /disk1/tmp、/disk2/tmp，保证写临时文件的负载均衡。对于给定查询，HAWQ 为每个虚拟段使用一个单独的临时目录存储溢出文件，多个 HAWQ 会话也是用自己的临时目录避免磁盘竞争。如果临时目录过少，或者多个临时目录存储在同一个磁盘上，会增加磁盘竞争或磁盘空间用尽的风险。
- 最小化每个 segment 的 YARN 容器数，并设置空闲资源返还 YARN 的超时时间。
- yarn.scheduler.minimum-allocation-mb 参数设置成可以被 1GB 整除，如 1024、512 等。
三、独立资源管理器
HAWQ 中的资源管理器配置主要涉及以下几个方面：
- 确定使用哪种资源管理模式。HAWQ 支持两种管理模式：独立模式与外部全局资源管理器模式。独立模式也叫无全局资源管理模式，在该模式下，HAWQ 使用集群节点资源时，不考虑其他共存的应用，HAWQ 假设它能使用所有 segment 的资源。对于专用 HAWQ 集群，独立模式是可选的方案。当前 HAWQ 支持 YARN 作为外部全局资源管理器，该模式下，HAWQ 作为一个 YARN 的应用，使用 YARN 管理的集群资源。
- 如果选择独立资源管理模式，需要决定是否限制分配给每个 HAWQ segment 使用的内存与 CPU。
- 如果使用 YARN 模式，需要在 YARN 中为 HAWQ 配置资源队列，还要在 HAWQ 进行与 YARN 相关的配置。HAWQ 自动注册为 YARN 应用，使用 YARN 中配置的资源队列。
- 在 HAWQ 中，创建资源队列。
1. 使用独立模式
为了配置 HAWQ 运行独立资源管理模式，在 master 上的 hawq-site.xml 文件中设置以下属性：
<property>
<name>hawq_global_rm_type</name>
<value>none</value>
</property>该属性为全局设置，需要重启 HAWQ 以生效。当然也可以使用 ambari，在 HAWQ->Configs->Resource Manager 进行设置，然后重启 HAWQ 服务。
hawq_global_rm_type 参数代表 HAWQ 全局资源管理类型，有效值为 yarn 和 none。设置为 none 表示由 HAWQ 的资源管理器自己管理资源，设置为 yarn 意味着与 YARN 协调使用资源，缺省安装时使用的是独立模式。
[gpadmin@hdp3 ~]$ hawq config -s hawq_global_rm_type
GUC : hawq_global_rm_type
Value : none
[gpadmin@hdp3 ~]$ 2. 配置 segment 资源限制
使用独立模式（hawq_global_rm_type=none）时，可以限制每个 HAWQ segment 所能使用的资源，配置方法是在 hawq-site.xml 文件中增加以下参数：
<property>
<name>hawq_rm_memory_limit_perseg</name>
<value>8GB</value>
</property>
<property>
<name>hawq_rm_nvcore_limit_perseg</name>
<value>4</value>
</property>hawq_rm_memory_limit_perseg 参数设置独立资源管理模式下，每个 HAWQ segment 使用的最大内存数。hawq_rm_nvcore_limit_perseg 参数设置每个 HAWQ segment 使用的最大 CPU 虚拟核数。
因为 XML 的配置验证，在 YARN 模式下也需要设置这些属性，即使该模式下不会使用这些参数。所有 segment 都配置成相同的值，内存应该设置成 1GB 的倍数，并且为了降低形成资源碎片的可能性，hawq_rm_memory_limit_perseg 应该配置成所有虚拟段资源限额（通过资源队列的 VSEG_RESOURCE_QUOTA 配置）的倍数。例如，hawq_rm_memory_limit_perseg 设置成 15GB，但是虚拟段资源限额设置成 2GB，那么一个 segment 可以使用的最大内存只有 14GB。
3. 配置查询语句的资源限额
某些场景下，可能需要在查询语句级增加资源限额。以下配置属性允许用户通过修改相应的资源队列控制限额：
- hawq_rm_stmt_vseg_memory
- hawq_rm_stmt_nvseg
hawq_rm_stmt_vseg_memory 定义每个虚拟段的内存限额，hawq_rm_stmt_nvseg 定义下个执行的查询所使用的虚拟段个数，缺省值为 0，表示不能在语句级设置资源限额。下面的例子中，执行下个查询语句时，HAWQ 的资源管理器将分配 10 个虚拟段，每个虚拟段有 256MB 的内存限额。
db1=# set hawq_rm_stmt_vseg_memory='256mb';
SET
db1=# set hawq_rm_stmt_nvseg=10;
SET
db1=# create table t(i integer);
CREATE TABLE
db1=# insert into t values(1);
INSERT 0 1
db1=# HAWQ 是动态为给定查询语句分配资源的，资源管理器只是分配 segment 的资源，而不会为查询保留资源。并且，语句级设置的虚拟段数不要超过全局配置参数 hawq_rm_nvseg_perquery_limit 的值。
4. 配置最大虚拟段数
可以在服务器级限制语句执行时使用的虚拟段数，这能防止数据装载期间的资源瓶颈或过渡消耗资源带来的性能问题。在 Hadoop 集群中，NameNode 和 DataNode 可以并发打开的写文件数是有限制的，考虑下面的场景：
- 需要向有 P 个分区的表导入数据。
- 集群中有 N 个节点，为了导入数据，每个节点上启动了 V 个虚拟段。
则每个 DataNode 要打开 P * V 个文件，至少启动 P * V 个线程。如果 P 和 V 的数量很大，DataNode 将成为瓶颈。而在 NameNode 上将有 V * N 个连接，如果节点很多，那么 NameNode 可能成为瓶颈。
为了缓解 NameNode 的负载，使用下面的服务器配置参数限制 V 的大小，即每个节点启动的最大虚拟段数。
- hawq_rm_nvseg_perquery_limit：在服务器级别上限制执行一条语句可以使用的最大虚拟段数量，缺省值为 512。default_hash_table_bucket_number 定义的哈希桶数不能超过 hawq_rm_nvseg_perquery_limit。
- default_hash_table_bucket_number：定义哈希表使用的缺省桶数。查询哈希表时，分配给查询的虚拟段数是固定的，等于表的桶数。一般集群扩容后应当调整此参数。
还可以在资源队列配置中限制查询使用的虚拟段数量。全局配置参数是“硬限制”，资源队列或语句级别的限额不能超过服务器级别的限额。
四、整合YARN
HAWQ 支持 YARN 作为全局资源管理器，在 YARN 管理的环境中，HAWQ 动态向 YARN 请求资源容器，资源使用完成后返还 YARN。此特性让 HAWQ 有效利用 Hadoop 的资源管理能力，并使 HAWQ 成为 Hadoop 生态圈的一员。总的来说，可以使用以下步骤整合 YARN 与 HAWQ：
- 安装 YARN。如果使用 HDP 2.3 版本，必须设置 yarn.resourcemanager.system-metrics-publisher.enabled=false。
- 配置 YARN 使用 CapacityScheduler 调度器，并为 HAWQ 保留一个单独的应用队列。
- 启用 YARN 的高可用特性（可选）。
- 配置 HAWQ 的 YARN 模式。
- 根据需要调整 HAWQ 的资源使用：为 HAWQ 修改相应的 YARN 资源队列配额（刷新 YARN 资源队列不需要重启 HAWQ）；通过修改 HAWQ 资源队列进行资源消耗的细粒度控制；其他配置，如设置每个 HAWQ segment 的最小 YARN 容器数，或修改 HAWQ 的空闲资源超时时间等。
1. 配置 YARN
查询请求资源执行时，HAWQ 的资源管理器与 YARN 的资源调度器协商资源分配。查询执行完毕后，HAWQ 资源管理器向 YARN 调度器返回占用的资源。为了使用 YARN，最好为 HAWQ 配置独立的应用资源队列。YARN 为特定的资源调度器配置资源队列，调度器根据资源队列的配置为应用分配资源。目前 HAWQ 仅支持 YARN 的 Capacity 调度器。
下面的例子说明如何使用 ambari 配置 CapacityScheduler 作为 YARN 的调度器。
（1）登录 ambari
（2）选择 YARN -> Configs -> Advanced -> Scheduler，如图3 所示
图3
（3）在 yarn.resourcemanager.scheduler.class 输入框中输入以下值：
org.apache.hadoop.yarn.server.resourcemanager.scheduler.capacity.CapacityScheduler该属性值设置 YARN 的调度器为 Capacity。
（4）在 Capacity Scheduler 输入框中输入以下内容：
yarn.scheduler.capacity.maximum-am-resource-percent=0.2
yarn.scheduler.capacity.maximum-applications=10000
yarn.scheduler.capacity.node-locality-delay=40
yarn.scheduler.capacity.root.acl_administer_queue=*
yarn.scheduler.capacity.root.capacity=100
yarn.scheduler.capacity.root.queues=mrque1,mrque2,hawqque
yarn.scheduler.capacity.root.hawqque.capacity=20
yarn.scheduler.capacity.root.hawqque.maximum-capacity=80
yarn.scheduler.capacity.root.hawqque.state=RUNNING
yarn.scheduler.capacity.root.hawqque.user-limit-factor=1
yarn.scheduler.capacity.root.mrque1.capacity=30
yarn.scheduler.capacity.root.mrque1.maximum-capacity=50
yarn.scheduler.capacity.root.mrque1.state=RUNNING
yarn.scheduler.capacity.root.mrque1.user-limit-factor=1
yarn.scheduler.capacity.root.mrque2.capacity=50
yarn.scheduler.capacity.root.mrque2.maximum-capacity=50
yarn.scheduler.capacity.root.mrque2.state=RUNNING
yarn.scheduler.capacity.root.mrque2.user-limit-factor=1缺省的 Capacity 调度策略只有一个名为 default 的资源队列。以上属性在根队列下设置两个 MapReduce 队列和一个名为 hawqque 的 HAWQ 专用队列，三个队列并存，共享整个集群资源。hawqque 队列可以使用整个集群 20% 到 80% 的资源。表1 说明了队列配置的主要属性及其含义。
| 属性名称 | 描述 |
| yarn.scheduler.capacity.maximum-am-resource-percent | 集群中可用于运行 application master 的资源比例上限，通常用于限制并发运行的应用程序数目。示例中设置为 0.2，即 20%。 |
| yarn.scheduler.capacity.maximum-applications | 集群中所有队列同时处于等待和运行状态的应用程序数目上限，这是一个强限制，一旦集群中应用程序数目超过该上限，后续提交的应用程序将被拒绝，默认值为 10000。 |
| yarn.scheduler.capacity.node-locality-delay | 调度器尝试调度一个 rack-local container 之前，最多跳过的调度机会。通常该值被设置成集群中机架数目，缺省值为 40，接近一个机架中的节点数目。 |
| yarn.scheduler.capacity.<queue_name>.queues | 定义本队列下的资源队列。即资源队列树中某节点的直接下级节点。 |
| yarn.scheduler.capacity.<queue_name>.capacity | 一个百分比的值，表示队列占用整个集群的百分之多少比例的资源。 |
| yarn.scheduler.capacity.<queue_name>.maximum-capacity | 弹性设置，队列最多占用多少比例的资源。 |
| yarn.scheduler.capacity.<queue_name>.state | 队列状态，可以是 RUNNING 或 STOPPED。 |
| yarn.scheduler.capacity.<queue_name>.user-limit-factor | 每个用户的低保百分比，比如设置为 1，则表示无论有多少用户在跑任务，每个用户占用最低不会少于 1% 的资源。 |
表1
（5）保存配置并重启 YARN 服务，之后可以在 YARN 资源管理器的用户界面看到配置的三个队列，如图4 所示。
图4
2. 在 YARN 中设置 segment 资源限制
与独立资源管理模式类似，也可以通过 YARN 管理 HAWQ segment 的配额。HAWQ 推荐将所有 segment 设置成相同的资源配额。在 yarn-site.xml 文件中设置如下属性：
<property>
<name>yarn.nodemanager.resource.memory-mb</name>
<value>4GB</value>
</property>
<property>
<name>yarn.nodemanager.resource.cpu-vcores</name>
<value>1</value>
</property>或者使用 ambari 的 YARN -> Configs -> Settings 进行配置，yarn.nodemanager.resource.memory-mb 和 yarn.nodemanager.resource.cpu-vcores 的设置分别如图5、图6 所示。
图5
图6
- yarn.nodemanager.resource.memory-mb：表示该节点上 YARN 可使用的物理内存总量，默认是 8192MB。如果节点的内存资源不够 8GB，则需要调减小这个值，YARN 不会智能的探测节点的物理内存总量。
- yarn.nodemanager.resource.cpu-vcores：表示该节点上 YARN 可使用的虚拟 CPU 个数，默认是 8，目前推荐将该值设值为与物理 CPU 核数相同。如果节点的 CPU 核数不够 8 个，则需要调减小这个值，YARN 不会智能的探测节点的物理 CPU 总数。
与独立模式一样，HAWQ 推荐每核内存数是 1GB 的倍数，如每核 1G、2G、4G 等。为了减少 YARN 模式下产生资源碎片的可能，应该遵从以下配置原则：
- yarn.nodemanager.resource.memory-mb 应该设置为虚拟段资源限额（在 HAWQ 资源队列中配置）的倍数。
- 每核内存应该设置为 yarn.scheduler.minimum-allocation-mb 的倍数。
比如 YARN 中的配置如下：
- yarn.scheduler.minimum-allocation-mb=1024
- yarn.nodemanager.resource.memory-mb=49152
- yarn.nodemanager.resource.cpu-vcores=16
HAWQ 计算的每核内存为 3GB（48GB/16）。由于 yarn.scheduler.minimum-allocation-mb 设置是 1GB，每个 YARN 容器内存为 1GB。这样每核内存正好是 YARN 容器的 3 倍，不会形成资源碎片。但如果 yarn.scheduler.minimum-allocation-mb 设置为 4GB，则每个 YARN 容器形成 1GB 的内存碎片空间（4GB - 3GB）。为了避免这种情况，可以修改 yarn.nodemanager.resource.memory-mb 为 64GB，或者将 yarn.scheduler.minimum-allocation-mb 改为 1GB。注意，如果将 yarn.scheduler.minimum-allocation-mb 设置为 1GB 或更小的值，该值应该能被 1GB 整除，如 1024、512 等。
3. 启用 YARN 模式
配置完 YARN，就可以在 hawq-site.xml 文件中添加如下属性，将 YARN 启用为 HAWQ 的全局资源管理器。
<property>
<name>hawq_global_rm_type</name>
<value>yarn</value>
</property>或者使用 ambari 的 HAWQ -> Configs -> Settings -> Resource Management 进行配置，如图7 所示。
图7
这样 HAWQ 资源管理器只会使用 YARN 分配的资源。YARN 模式的 HAWQ 需要在 hawq-site.xml 文件中配置以下属性：
<property>
<name>hawq_rm_yarn_address</name>
<value>hdp2:8050</value>
</property>
<property>
<name>hawq_rm_yarn_scheduler_address</name>
<value>hdp2:8030</value>
</property>
<property>
<name>hawq_rm_yarn_queue_name</name>
<value>hawqque</value></property>
<property>
<name>hawq_rm_yarn_app_name</name>
<value>hawq</value>
</property>或者使用 ambari 的 HAWQ -> Configs -> Advanced -> Advanced hawq-site 进行配置，如图8 所示。
图8
表2 包含了相关属性的描述。
| 属性名称 | 描述 |
| hawq_rm_yarn_address | YARN 服务器的主机和端口号，与 yarn-site.xml 中的 yarn.resourcemanager.address 属性相同。 |
| hawq_rm_yarn_scheduler_address | YARN 调度器的主机和端口号，与 yarn-site.xml 中的 yarn.resourcemanager.scheduler.address 属性相同。 |
| hawq_rm_yarn_queue_name | YARN 中 HAWQ 使用的资源队列名称。 |
| hawq_rm_yarn_app_name | YARN 中 HAWQ 使用的应用名称。 |
表2
4. 用 YARN 协调 HAWQ 资源
为了保证资源管理的效率与查询性能，应该做适当的配置，协调 YARN 为 HAWQ 资源管理器分配资源。
（1）调整每个 segment 的最小 YARN 容器数
当 HAWQ 刚注册到 YARN，还没有工作负载时，HAWQ 不需要立即获得任何资源。只有在 HAWQ 接收到第一个查询请求时，HAWQ 资源管理器才开始向 YARN 请求资源。为保证为后续查询优化资源分配，同时避免与 YARN 协调过于频繁，可以调整 hawq_rm_min_resource_perseg 参数。无论初始查询的大小，每个 HAWQ segment 都至少会被分配指定的 YARN 容器数。该参数的缺省值为 2，这意味着即便查询所需的资源很少，HAWQ 资源管理器为每个 segment 至少获得两个 YARN 容器。
此属性配置不能超过 YARN 中 HAWQ 资源队列的配额。例如，如果 YARN 中 HAWQ 队列的配额不大于整个集群的 50%，并且每个 YARN 节点的最大内存与虚拟 CPU 核数分别为 64GB 和 16，那么 hawq_rm_min_resource_perseg 的设置不能大于 8。这是因为 HAWQ 资源管理器通过虚拟 CPU 核数获得 YARN 资源容器。
（2）设置 YARN 资源超时
如果 HAWQ 的工作负载很低，HAWQ 资源管理器已经获得的 YARN 资源有可能出现空闲的情况，可以调整 hawq_rm_resource_idle_timeout 参数，让 HAWQ 资源管理器更快或更慢地向 YARN 返还空闲资源。例如，HAWQ 资源管理器获取资源的过程会造成查询延时，为了让 HAWQ 资源管理器更长时间持有已获资源，以备后面的查询工作使用，可增加 hawq_rm_resource_idle_timeout 的值。该参数的缺省值为 300 秒。
五、资源队列层次
通过定义层次化的资源队列，系统管理员能够根据需要均衡分配系统资源。
资源队列是使用 CREATE RESOURCE QUEUE 语句创建的数据库对象，是 HAWQ 系统中管理并发度的主要工具。可以使用资源队列控制并发执行的活跃查询的数量，以及分配给每种查询类型使用的最大内存与 CPU 数量。资源队列还可以防止某些查询因消耗太多系统资源，影响系统整体性能的情况。HAWQ 内部将资源队列组织为一棵如图2 所示的 n 叉树。HAWQ 初始化后，有一个名为 pg_root 的根队列，根下有一个名为 pg_default 的缺省队列，图2 中用灰色节点表示。
1. 设置资源队列最大数
可以配置 HAWQ 集群中允许的资源队列最大数量，缺省值为 128，值域范围是 3 - 1024。
[gpadmin@hdp3 ~]$ hawq config -s hawq_rm_nresqueue_limit
GUC : hawq_rm_nresqueue_limit
Value : 128
[gpadmin@hdp3 ~]$手工编辑 hawq-site.xml 文件或使用 ambari 界面配置该参数，新值在 HAWQ 重启后生效。下面例子将最大资源队列数设置成 50。
<property>
<name>hawq_rm_nresqueue_limit</name>
<value>50</value>
</property>执行以下命令检查运行时的参数设置：
db1=# show hawq_rm_nresqueue_limit;
hawq_rm_nresqueue_limit
-------------------------
128
(1 row)该参数不能在服务器启动后动态改变：
db1=# set hawq_rm_nresqueue_limit=50;
ERROR: attempted change of parameter "hawq_rm_nresqueue_limit" ignored
DETAIL: This parameter cannot be changed after server start.
db1=# 2. 资源队列维护
（1）创建资源队列
使用 CREATE RESOURCE QUEUE 语句创建资源队列，只有管理员用户才能运行该 DDL 语句。创建资源队列时需要指定队列的名称、父队列名称、CPU 和内存限制等，还能可选限制队列中的活跃语句数量。
下面的语句在 pg_root 下创建一个名为 myqueue 的资源队列，限制活跃查询数为 20，内存和 CPU 核数最多为集群总量的 10%：
db1=# create resource queue myqueue with (parent='pg_root', active_statements=20,
db1(# memory_limit_cluster=10%, core_limit_cluster=10%);
CREATE QUEUE
db1=# 一个父队列下的所有直接子队列的资源限制总和不能超过 100%。例如，缺省的 pg_default 队列的 memory_limit_cluster 和 core_limit_cluster 为 50%，刚刚建立的 myqueue 两者限制为10%，两个队列的限制总和是 60%，此时无法再在 pg_root 下创建限制超过 40% 的资源队列。
db1=# create resource queue myqueue1 with (parent='pg_root', active_statements=20,
db1(# memory_limit_cluster=50%, core_limit_cluster=50%);
ERROR: the value of core_limit_cluster and memory_limit_cluster exceeds parent queue's limit, wrong value = 50%
db1=# 下面的语句在 pg_root 下创建一个名为 test_queue_1 的资源队列，内存和 CPU 核数最多为集群总量的 40%，并指定资源过度使用因子为 2：
db1=# create resource queue test_queue_1 with (parent='pg_root',
db1(# memory_limit_cluster=30%, core_limit_cluster=30%, resource_overcommit_factor=2);
CREATE QUEUE
db1=# RESOURCE_OVERCOMMIT_FACTOR 是一个可选属性，定义有多少资源能够被过度使用，缺省值为 2.0，最小值为 1.0。如果设置 RESOURCE_OVERCOMMIT_FACTOR 为 3.0，同时将 MEMORY_LIMIT_CLUSTER 设置为 30%，那么最大可能的资源分配为 90%（30% * 3）。如果资源限制与 RESOURCE_OVERCOMMIT_FACTOR 相乘的结果值大于 100%，采用 100%。
（2）修改资源队列
使用 ALTER RESOURCE QUEUE 语句修改资源队列，只有管理员用户才能运行该 DDL 语句。该语句可以修改队列的资源限制和活跃语句数，但不能改变一个队列的父队列，创建资源队列时的约束同样适用于修改语句。
可以在队列正在被使用时进行修改，所有队列中排队的资源请求都调整为基于修改后的队列。在修改队列时，排队的资源请求可能遇到某些冲突，如可能发生资源死锁，或者修改后的资源限额不能满足排队的请求等。为防止冲突，缺省情况下 HAWQ 会取消与新资源队列定义冲突的所有请求，该行为受服务器配置参数 hawq_rm_force_alterqueue_cancel_queued_request 控制，缺省设置是 on。
[gpadmin@hdp3 ~]$ hawq config -s hawq_rm_force_alterqueue_cancel_queued_request
GUC : hawq_rm_force_alterqueue_cancel_queued_request
Value : on
[gpadmin@hdp3 ~]$如果该参数设置为 off，如果资源管理器发现新的队列定义与排队请求发生冲突，则取消 ALTER RESOURCE QUEUE 中指定的限制。
以下语句修改资源队列的内存和 CPU 核数限制：
db1=# alter resource queue test_queue_1 with (memory_limit_cluster=40%,core_limit_cluster=40%);
ALTER QUEUE
db1=#以下语句将资源队列的最大活跃语句数由缺省的 20 改为 50：
db1=# alter resource queue test_queue_1 with (active_statements=50);
ALTER QUEUE
db1=# （3）删除资源队列
使用 DROP RESOURCE QUEUE 语句删除一个资源队列，只有管理员用户才能运行该 DDL 语句。满足以下条件的资源队列才能被删除：
- 没有查询正在使用该队列。
- 没有子队列。
- 没有被赋予角色。
不能删除系统资源队列 pg_root 和 pg_default。
以下语句从资源队列中删除角色，角色会被移到缺省的 pg_default 资源队列中：
db1=# alter role wxy resource queue none;
ALTER ROLE
db1=# 以下语句删除 myqueue 资源队列。
db1=# drop resource queue myqueue;
DROP QUEUE
db1=# （4）检查现有资源队列
HAWQ 的系统表 pg_resqueue 保存资源队列数据。下面的查询语句显示 test_queue_1 的相关信息：
db1=# \x
Expanded display is on.
db1=# select rsqname,
db1-# parentoid,
db1-# activestats,
db1-# memorylimit,
db1-# corelimit,
db1-# resovercommit,
db1-# allocpolicy,
db1-# vsegresourcequota,
db1-# nvsegupperlimit,
db1-# nvseglowerlimit,
db1-# nvsegupperlimitperseg,
db1-# nvseglowerlimitperseg
db1-# from pg_resqueue
db1-# where rsqname='test_queue_1';
-[ RECORD 1 ]---------+-------------
rsqname | test_queue_1
parentoid | 9800
activestats | 50
memorylimit | 40%
corelimit | 40%
resovercommit | 2
allocpolicy | even
vsegresourcequota | mem:256mb
nvsegupperlimit | 0
nvseglowerlimit | 0
nvsegupperlimitperseg | 0
nvseglowerlimitperseg | 0
db1=#
也可以从 pg_resqueue_status 系统视图检查资源队列的运行时状态：
db1=# select * from pg_resqueue_status;
rsqname | segmem | segcore | segsize | segsizemax | inusemem | inusecore | rsqholders | rsqwaiters | paused
--------------+--------+----------+---------+------------+----------+-----------+------------+------------+--------
pg_root | 256 | 0.125000 | 72 | 72 | 0 | 0.000000 | 0 | 0 | F
pg_default | 256 | 0.125000 | 36 | 72 | 0 | 0.000000 | 0 | 0 | F
test_queue_1 | 256 | 0.125000 | 28 | 57 | 0 | 0.000000 | 0 | 0 | F
(3 rows)表3 描述了 pg_resqueue_status 视图中各字段的含义。
| 字段名称 | 描述 |
| rsqname | HAWQ 资源队列名称。 |
| segmem | 每个虚拟段内存限额（MB）。 |
| segcore | 每个虚拟段的 CPU 虚拟核数限额。 |
| segsize | 资源队列能够为执行查询分配的虚拟段数。 |
| segsizemax | 过度使用其他队列的资源时，资源队列可为执行查询分配的最大虚拟段数。 |
| inusemem | 当前运行的语句使用的总内存（MB）。 |
| inusecore | 当前运行的语句使用的总 CPU 虚拟核数。 |
| rsqholders | 并发运行的语句数量。 |
| rsqwaiters | 排队语句的数量。 |
| paused | 指示在没有资源状态改变时，资源队列是否临时性暂停。‘F’表示否，‘T’表示是，‘R’表示资源队列发生了资源碎片问题。 |
表3
下面的语句查询所有资源队列的当前活动 SQL：
select usename, rsqname, locktype, objid, transaction, pid, mode, granted, waiting
from pg_stat_activity, pg_resqueue, pg_locks
where pg_stat_activity.procpid=pg_locks.pid
and pg_locks.objid=pg_resqueue.oid;下面的语句查询所有资源队列的当前等待 SQL：
select rolname, rsqname, pid, granted, current_query, datname
from pg_roles, pg_resqueue, pg_locks, pg_stat_activity
where pg_roles.rolresqueue=pg_locks.objid
and pg_locks.objid=pg_resqueue.oid
and pg_stat_activity.procpid=pg_locks.pid;3. 给角色赋予资源队列
资源队列对资源的管理是通过角色（用户）发挥作用的，角色被赋予某个资源队列，用该角色执行的查询受相应资源队列的限制。只允许为角色赋予叶子队列。
下面的语句在创建或修改角色时赋予角色一个资源队列：
db1=# create role rmtest1 with login resource queue pg_default;
CREATE ROLE
db1=# alter role rmtest1 resource queue test_queue_1;
ALTER ROLE
db1=# 下面的语句查看为角色分配的资源队列：
db1=# select rolname, rsqname from pg_roles, pg_resqueue
db1-# where pg_roles.rolresqueue=pg_resqueue.oid;
rolname | rsqname
---------+--------------
gpadmin | pg_default
wxy | pg_default
rmtest1 | test_queue_1
(3 rows)六、查询资源管理器状态
通过一些查询能够导出资源管理器的细节信息，如活跃资源上下文状态、当前资源队列状态、HAWQ segment 状态等。
1. 连接状态跟踪
查询执行时从资源管理器请求分配资源，此时会有一个连接跟踪实例，记录查询资源使用的整个生命周期，从中可以找到所有的资源请求与分配情况。下面的查询获取保存连接跟踪状态信息的文件路径：
db1=# select * from dump_resource_manager_status(1);
dump_resource_manager_status
-----------------------------------------------------------------------------------------
Dump resource manager connection track status to /tmp/resource_manager_conntrack_status
(1 row)表4 总结了该文件中的输出字段及其描述。
| 字段名称 | 描述 |
| Number of free connection ids | 空闲的连接跟踪实例数量。HAWQ 资源管理器支持最多 65536 个活动连接跟踪实例。 |
| Number of connection tracks having requests to handle | 资源管理器已经接受但还没有处理的请求数量。 |
| Number of connection tracks having responses to send | 资源管理器已经生成但还没有发送出去的响应数量。 |
| SOCK | 请求的socket连接信息。 |
| CONN | 请求的角色名称、目标队列和当前状态等信息。 prog=1 表示连接建立 prog=2 连接由用户注册 prog=3 表示连接等待目标队列中的资源。 prog=4 表示资源已经分配给连接。 prog>5 表示失败或异常状态。 |
| ALLOC | 会话相关信息，如请求的资源、会话级资源限制、语句级资源设置、按查询计划分片数估计的工作量等等。 |
| LOC | 查询扫描 HDFS 的数据本地化信息。 |
| RESOURCE | 已经分配的资源信息。 |
| MSG | 最后收到的消息。 |
| COMMSTAT | 当前socket通信缓冲区状态。 |
表4
2. 资源队列状态
下面的查询获取保存资源队列状态信息的文件路径：
db1=# select * from dump_resource_manager_status(2);
dump_resource_manager_status
--------------------------------------------------------------------------------------
Dump resource manager resource queue status to /tmp/resource_manager_resqueue_status
(1 row)表5 总结了该文件中的输出字段及其描述。
| 字段名称 | 描述 |
| Maximum capacity of queue in global resource manager cluster | YARN 资源队列最大配额。 |
| Number of resource queues | HAWQ资源队列总数量。 |
| QUEUE | 资源队列的基本结构信息，以及是否忙于为查询调度资源。 |
| REQ | 等待队列的计数和状态。 |
| SEGCAP | 虚拟段资源限额和可派发的虚拟段数量。 |
| QUECAP | 原始资源队列配额，以及一个队列可以使用的集群资源的实际百分比。 |
| QUEUSE | 资源队列使用信息。 |
表5
3. HAWQ segment 状态
下面的查询获取保存 HAWQ segment 状态信息的文件路径：
db1=# select * from dump_resource_manager_status(3);
dump_resource_manager_status
------------------------------------------------------------------------------------
Dump resource manager resource pool status to /tmp/resource_manager_respool_status
(1 row)表6 总结了该文件中的输出字段及其描述。
| 字段名称 | 描述 |
| HOST_ID | 识别的 segment 名称和内部 ID。 |
| HOST_INFO | segment 配置的资源配额。GRMTotalMemoryMB 和GRMTotalCore 显示 YARN 报告的限额，FTSTotalMemoryMB 和 FTSTotalCore 显示 HAWQ 中配置的限额。 |
| HOST_AVAILABILITY | segment 对于 HAWQ 容错服务（fault tolerance service，FTS）和 YARN 是否可用。 |
| HOST_RESOURCE | 当前分配的和可用的资源，以及估算的负载计数器。 |
| HOST_RESOURCE_CONTAINERSET | Segment 持有的资源容器。 |
表6
扫一扫
2945
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
