YARN的内存和CPU配置

Yarn 内存分配管理机制及相关参数配置 理解Yarn的内存管理与分配机制,对于我们搭建、部署集群,开发维护应用都是尤为重要的,对于这方面我做了一些调研供大家参考。 一、相关配置情况 关于Yarn内存分配与管理,主要涉及到了ResourceManage、ApplicationMatser、NodeManager这几个概念,相关的优化也要紧紧围绕着这几方面来开展。这里还有一个Container的概念,现在可以先把它理解为运行map/re 阅读详情


Hadoop YARN同时支持内存和CPU两种资源的调度,本文介绍如何配置YARN对内存和CPU的使用。

YARN作为一个资源调度器,应该考虑到集群里面每一台机子的计算资源,然后根据application申请的资源进行分配Container。Container是YARN里面资源分配的基本单位,具有一定的内存以及CPU资源。

在YARN集群中,平衡内存、CPU、磁盘的资源的很重要的,根据经验,每两个container使用一块磁盘以及一个CPU核的时候可以使集群的资源得到一个比较好的利用。

内存配置

关于内存相关的配置可以参考hortonwork公司的文档Determine HDP Memory Configuration Settings来配置你的集群。

YARN以及MAPREDUCE所有可用的内存资源应该要除去系统运行需要的以及其他的hadoop的一些程序,总共保留的内存=系统内存+HBASE内存。

可以参考下面的表格确定应该保留的内存:

每台机子内存系统需要的内存HBase需要的内存
4GB1GB1GB
8GB2GB1GB
16GB2GB2GB
24GB4GB4GB
48GB6GB8GB
64GB8GB8GB
72GB8GB8GB
96GB12GB16GB
128GB24GB24GB
255GB32GB32GB
512GB64GB64GB

计算每台机子最多可以拥有多少个container,可以使用下面的公式:

containers = min (2*CORES, 1.8*DISKS, (Total available RAM) / MIN_CONTAINER_SIZE)

说明:

  • CORES为机器CPU核数
  • DISKS为机器上挂载的磁盘个数
  • Total available RAM为机器总内存
  • MIN_CONTAINER_SIZE是指container最小的容量大小,这需要根据具体情况去设置,可以参考下面的表格:
每台机子可用的RAMcontainer最小值
小于4GB256MB
4GB到8GB之间512MB
8GB到24GB之间1024MB
大于24GB2048MB

每个container的平均使用内存大小计算方式为:

RAM-per-container = max(MIN_CONTAINER_SIZE, (Total Available RAM) / containers))

通过上面的计算,YARN以及MAPREDUCE可以这样配置:

配置文件配置设置默认值计算值
yarn-site.xmlyarn.nodemanager.resource.memory-mb8192 MB= containers * RAM-per-container
yarn-site.xmlyarn.scheduler.minimum-allocation-mb1024MB= RAM-per-container
yarn-site.xmlyarn.scheduler.maximum-allocation-mb8192 MB= containers * RAM-per-container
yarn-site.xml (check)yarn.app.mapreduce.am.resource.mb1536 MB= 2 * RAM-per-container
yarn-site.xml (check)yarn.app.mapreduce.am.command-opts-Xmx1024m= 0.8 * 2 * RAM-per-container
mapred-site.xmlmapreduce.map.memory.mb1024 MB= RAM-per-container
mapred-site.xmlmapreduce.reduce.memory.mb1024 MB= 2 * RAM-per-container
mapred-site.xmlmapreduce.map.java.opts = 0.8 * RAM-per-container
mapred-site.xmlmapreduce.reduce.java.opts = 0.8 * 2 * RAM-per-container

举个例子:对于128G内存、32核CPU的机器,挂载了7个磁盘,根据上面的说明,系统保留内存为24G,不适应HBase情况下,系统剩余可用内存为104G,计算containers值如下:

containers = min (2*32, 1.8* 7 , (128-24)/2) = min (64, 12.6 , 51) = 13

计算RAM-per-container值如下:

RAM-per-container = max (2, (124-24)/13) = max (2, 8) = 8

你也可以使用脚本yarn-utils.py来计算上面的值:

  1. #!/usr/bin/env python
  2. import optparse
  3. from pprint import pprint
  4. import logging
  5. import sys
  6. import math
  7. import ast
  8. ''' Reserved for OS + DN + NM, Map: Memory => Reservation '''
  9. reservedStack = { 4 : 1 , 8 : 2 , 16 : 2 , 24 : 4 , 48 : 6 , 64 : 8 , 72 : 8 , 96 : 12 ,
  10. 128 : 24 , 256 : 32 , 512 : 64 }
  11. ''' Reserved for HBase. Map: Memory => Reservation '''
  12. reservedHBase = { 4 : 1 , 8 : 1 , 16 : 2 , 24 : 4 , 48 : 8 , 64 : 8 , 72 : 8 , 96 : 16 ,
  13. 128 : 24 , 256 : 32 , 512 : 64 }
  14. GB = 1024
  15. def getMinContainerSize ( memory ):
  16. if ( memory <= 4 ):
  17. return 256
  18. elif ( memory <= 8 ):
  19. return 512
  20. elif ( memory <= 24 ):
  21. return 1024
  22. else :
  23. return 2048
  24. pass
  25. def getReservedStackMemory ( memory ):
  26. if ( reservedStack . has_key ( memory )):
  27. return reservedStack [ memory ]
  28. if ( memory <= 4 ):
  29. ret = 1
  30. elif ( memory >= 512 ):
  31. ret = 64
  32. else :
  33. ret = 1
  34. return ret
  35. def getReservedHBaseMem ( memory ):
  36. if ( reservedHBase . has_key ( memory )):
  37. return reservedHBase [ memory ]
  38. if ( memory <= 4 ):
  39. ret = 1
  40. elif ( memory >= 512 ):
  41. ret = 64
  42. else :
  43. ret = 2
  44. return ret
  45. def main ():
  46. log = logging . getLogger ( __name__ )
  47. out_hdlr = logging . StreamHandler ( sys . stdout )
  48. out_hdlr . setFormatter ( logging . Formatter ( ' %(message) s' ))
  49. out_hdlr . setLevel ( logging . INFO )
  50. log . addHandler ( out_hdlr )
  51. log . setLevel ( logging . INFO )
  52. parser = optparse . OptionParser ()
  53. memory = 0
  54. cores = 0
  55. disks = 0
  56. hbaseEnabled = True
  57. parser . add_option ( '-c' , '--cores' , default = 16 ,
  58. help = 'Number of cores on each host' )
  59. parser . add_option ( '-m' , '--memory' , default = 64 ,
  60. help = 'Amount of Memory on each host in GB' )
  61. parser . add_option ( '-d' , '--disks' , default = 4 ,
  62. help = 'Number of disks on each host' )
  63. parser . add_option ( '-k' , '--hbase' , default = "True" ,
  64. help = 'True if HBase is installed, False is not' )
  65. ( options , args ) = parser . parse_args ()
  66. cores = int ( options . cores )
  67. memory = int ( options . memory )
  68. disks = int ( options . disks )
  69. hbaseEnabled = ast . literal_eval ( options . hbase )
  70. log . info ( "Using cores=" + str ( cores ) + " memory=" + str ( memory ) + "GB" +
  71. " disks=" + str ( disks ) + " hbase=" + str ( hbaseEnabled ))
  72. minContainerSize = getMinContainerSize ( memory )
  73. reservedStackMemory = getReservedStackMemory ( memory )
  74. reservedHBaseMemory = 0
  75. if ( hbaseEnabled ):
  76. reservedHBaseMemory = getReservedHBaseMem ( memory )
  77. reservedMem = reservedStackMemory + reservedHBaseMemory
  78. usableMem = memory - reservedMem
  79. memory -= ( reservedMem )
  80. if ( memory < 2 ):
  81. memory = 2
  82. reservedMem = max ( 0 , memory - reservedMem )
  83. memory *= GB
  84. containers = int ( min ( 2 * cores ,
  85. min ( math . ceil ( 1.8 * float ( disks )),
  86. memory / minContainerSize )))
  87. if ( containers <= 2 ):
  88. containers = 3
  89. log . info ( "Profile: cores=" + str ( cores ) + " memory=" + str ( memory ) + "MB"
  90. + " reserved=" + str ( reservedMem ) + "GB" + " usableMem="
  91. + str ( usableMem ) + "GB" + " disks=" + str ( disks ))
  92. container_ram = abs ( memory / containers )
  93. if ( container_ram > GB ):
  94. container_ram = int ( math . floor ( container_ram / 512 )) * 512
  95. log . info ( "Num Container=" + str ( containers ))
  96. log . info ( "Container Ram=" + str ( container_ram ) + "MB" )
  97. log . info ( "Used Ram=" + str ( int ( containers * container_ram / float ( GB ))) + "GB" )
  98. log . info ( "Unused Ram=" + str ( reservedMem ) + "GB" )
  99. log . info ( "yarn.scheduler.minimum-allocation-mb=" + str ( container_ram ))
  100. log . info ( "yarn.scheduler.maximum-allocation-mb=" + str ( containers * container_ram ))
  101. log . info ( "yarn.nodemanager.resource.memory-mb=" + str ( containers * container_ram ))
  102. map_memory = container_ram
  103. reduce_memory = 2 * container_ram if ( container_ram <= 2048 ) else container_ram
  104. am_memory = max ( map_memory , reduce_memory )
  105. log . info ( "mapreduce.map.memory.mb=" + str ( map_memory ))
  106. log . info ( "mapreduce.map.java.opts=-Xmx" + str ( int ( 0.8 * map_memory )) + "m" )
  107. log . info ( "mapreduce.reduce.memory.mb=" + str ( reduce_memory ))
  108. log . info ( "mapreduce.reduce.java.opts=-Xmx" + str ( int ( 0.8 * reduce_memory )) + "m" )
  109. log . info ( "yarn.app.mapreduce.am.resource.mb=" + str ( am_memory ))
  110. log . info ( "yarn.app.mapreduce.am.command-opts=-Xmx" + str ( int ( 0.8 * am_memory )) + "m" )
  111. log . info ( "mapreduce.task.io.sort.mb=" + str ( int ( 0.4 * map_memory )))
  112. pass
  113. if __name__ == '__main__' :
  114. try :
  115. main ()
  116. except ( KeyboardInterrupt , EOFError ):
  117. print ( " \n Aborting ... Keyboard Interrupt." )
  118. sys . exit ( 1 )

执行下面命令:

python yarn-utils.py -c 32 -m 128 -d 7 -k False

返回结果如下:

  1. Using cores = 32 memory=128GB disks=7 hbase=False
  2. Profile : cores=32 memory=106496MB reserved=24GB usableMem=104GB disks=7
  3. Num Container = 13
  4. Container Ram = 8192MB
  5. Used Ram = 104GB
  6. Unused Ram = 24GB
  7. yarn.scheduler.minimum-allocation- mb = 8192
  8. yarn.scheduler.maximum-allocation- mb = 106496
  9. yarn.nodemanager.resource.memory- mb = 106496
  10. mapreduce.map.memory.mb = 8192
  11. mapreduce.map.java.opts = -Xmx6553m
  12. mapreduce.reduce.memory.mb = 8192
  13. mapreduce.reduce.java.opts = -Xmx6553m
  14. yarn.app.mapreduce.am.resource.mb = 8192
  15. yarn.app.mapreduce.am.command- opts = -Xmx6553m
  16. mapreduce.task.io.sort.mb = 3276

这样的话,每个container内存为8G,似乎有点多,我更愿意根据集群使用情况任务将其调整为2G内存,则集群中下面的参数配置值如下:

配置文件配置设置计算值
yarn-site.xmlyarn.nodemanager.resource.memory-mb= 52 * 2 =104 G
yarn-site.xmlyarn.scheduler.minimum-allocation-mb= 2G
yarn-site.xmlyarn.scheduler.maximum-allocation-mb= 52 * 2 = 104G
yarn-site.xml (check)yarn.app.mapreduce.am.resource.mb= 2 * 2=4G
yarn-site.xml (check)yarn.app.mapreduce.am.command-opts= 0.8 * 2 * 2=3.2G
mapred-site.xmlmapreduce.map.memory.mb= 2G
mapred-site.xmlmapreduce.reduce.memory.mb= 2 * 2=4G
mapred-site.xmlmapreduce.map.java.opts= 0.8 * 2=1.6G
mapred-site.xmlmapreduce.reduce.java.opts= 0.8 * 2 * 2=3.2G

对应的xml配置为:

  1. <property>
  2. <name>yarn.nodemanager.resource.memory-mb </name>
  3. <value>106496 </value>
  4. </property>
  5. <property>
  6. <name>yarn.scheduler.minimum-allocation-mb </name>
  7. <value>2048 </value>
  8. </property>
  9. <property>
  10. <name>yarn.scheduler.maximum-allocation-mb </name>
  11. <value>106496 </value>
  12. </property>
  13. <property>
  14. <name>yarn.app.mapreduce.am.resource.mb </name>
  15. <value>4096 </value>
  16. </property>
  17. <property>
  18. <name>yarn.app.mapreduce.am.command-opts </name>
  19. <value>-Xmx3276m </value>
  20. </property>

另外,还有一下几个参数:

  • yarn.nodemanager.vmem-pmem-ratio:任务每使用1MB物理内存,最多可使用虚拟内存量,默认是2.1。
  • yarn.nodemanager.pmem-check-enabled:是否启动一个线程检查每个任务正使用的物理内存量,如果任务超出分配值,则直接将其杀掉,默认是true。
  • yarn.nodemanager.vmem-pmem-ratio:是否启动一个线程检查每个任务正使用的虚拟内存量,如果任务超出分配值,则直接将其杀掉,默认是true。

第一个参数的意思是当一个map任务总共分配的物理内存为2G的时候,该任务的container最多内分配的堆内存为1.6G,可以分配的虚拟内存上限为2*2.1=4.2G。另外,照这样算下去,每个节点上YARN可以启动的Map数为104/2=52个。

CPU配置

YARN中目前的CPU被划分成虚拟CPU(CPU virtual Core),这里的虚拟CPU是YARN自己引入的概念,初衷是,考虑到不同节点的CPU性能可能不同,每个CPU具有的计算能力也是不一样的,比如某个物理CPU的计算能力可能是另外一个物理CPU的2倍,这时候,你可以通过为第一个物理CPU多配置几个虚拟CPU弥补这种差异。用户提交作业时,可以指定每个任务需要的虚拟CPU个数。

在YARN中,CPU相关配置参数如下:

  • yarn.nodemanager.resource.cpu-vcores:表示该节点上YARN可使用的虚拟CPU个数,默认是8,注意,目前推荐将该值设值为与物理CPU核数数目相同。如果你的节点CPU核数不够8个,则需要调减小这个值,而YARN不会智能的探测节点的物理CPU总数。
  • yarn.scheduler.minimum-allocation-vcores:单个任务可申请的最小虚拟CPU个数,默认是1,如果一个任务申请的CPU个数少于该数,则该对应的值改为这个数。
  • yarn.scheduler.maximum-allocation-vcores:单个任务可申请的最多虚拟CPU个数,默认是32。

对于一个CPU核数较多的集群来说,上面的默认配置显然是不合适的,在我的测试集群中,4个节点每个机器CPU核数为31,留一个给操作系统,可以配置为:

  1. <property>
  2. <name>yarn.nodemanager.resource.cpu-vcores </name>
  3. <value>31 </value>
  4. </property>
  5. <property>
  6. <name>yarn.scheduler.maximum-allocation-vcores </name>
  7. <value>124 </value>
  8. </property>
yarn-utils.py 计算yarn内存配置的python脚本yarn-util.py,此脚本有四个参数 参数 描述 -c CORES 每个节点CPU核数 -m MEMORY 每个节点内存总数(单位G) -d DISKS 每个节点的硬盘个数 -k HBASE 如果安装了Hbase则为True,否则为False 立即下载

相关推荐

webapi .net core8.0配置使用Token权限认证

本人在网上找了很多版本,不是太复杂就是不行。

m0_74824592的博客 1761

详解 YARN的内存和CPU配置

一:简单介绍 Hadoop YARN同时支持内存和CPU两种资源的调度,本文介绍如何配置YARN对内存和CPU的使用。 YARN作为一个资源调度器,应该考虑到集群里面每一台机子的计算资源,然后根据application申请的资源进行分配Container。Container是YARN里面资源分配的基本单位,具有一定的内存以及CPU资源。 在YARN集群中,平衡内存、CPU、磁盘的资源的很重要的,根...

qq_43688472的博客 6135

GPS-SDR-SIM使用详解

GPS-SDR-SIM 是一款开源工具,能够生成 GPS 基带信号数据流,这些数据流可通过软件定义无线电(SDR)平台(如 ADALM-Pluto、bladeRF、HackRF、USRP 等)转换为射频(RF)信号。简单来说,它能模拟 GPS 卫星信号,帮助开发者或爱好者测试 GPS 接收设备的性能,而无需依赖真实的卫星信号。

qq_35621280的博客 1243

Yarn——常用配置、常见配置案例

Yarn——常用配置、常见配置案例

xdx_dili的博客 2439

TESSY创建单元测试或集成测试工程

我们以tessy5.1为例,给大家展示单元测试和集成测试工程的创建过程。

空气中的告白专栏 1687

Nvidia Jetson AGX Orin 如何进入 Recovery Mode(刷机注意事项)

Jetson Orin 如何进入Recovery mode + 刷机注意事项

Pandako's Blog 1万+

## YARN运行资源配置

这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题,有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能,丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 欢迎使用Markdown编辑器 你好! 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Mar

chenjunshi123的博客 5408

手把手教你用STM32CubeMX和HAL库驱动DW3000:从SPI配置到第一个测距Demo

本文详细介绍了如何使用STM32CubeMX和HAL库驱动DW3000 UWB定位通信模块,从SPI配置到实现厘米级测距Demo的全过程。涵盖硬件连接、SPI通信调试、驱动移植及双向测距(TWR)算法实现,帮助开发者快速掌握UWB高精度定位技术,适用于仓储物流、智能家居等场景。

weixin_27038245的博客 485

Yarn内存和CPU调优配置

Hadoop Yarn同时支持内存和CPU的两种资源的调度。 yarn 作为一个资源调度器,应考虑集群中每一台机器的计算资源,然后根据application申请的资源进行分配Container(Yarn的组件 虚拟的概念 ),而Container是yarn里面资源分配的基本单位,具有一定的内存以及CPU资源。 在yarn集群中,平衡内存,CPU,磁盘的资源很重要, 每两个container使用一...

Java大数据 1733

HFSS学习记录——0. HFSS软件安装(ANSYS Electromagnetics Suite 2023 R1)

HFSS 2023 R1安装步骤

plmxu34的博客 15万+

JavaSwing_4.2: JDialog、JOptionPane(对话框)

JDialog,对话框。使用 JDialog 类可以创建自定义有的对话框,或者调用 JOptionPane 中的多个静态方法快速创建各种标准的对话框。JOptionPane是 JavaSwing 内部已实现好的,以静态方法的形式提供调用,能够快速方便的弹出要求用户提供值或向其发出通知的标准对话框。

谢TS的博客 7万+

转载-YARN的内存和CPU配置

Hadoop YARN同时支持内存和CPU两种资源的调度,本文介绍如何配置YARN对内存和CPU的使用。 YARN作为一个资源调度器,应该考虑到集群里面每一台机子的计算资源,然后根据application申请的资源进行分配Container。Container是YARN里面资源分配的基本单位,具有一定的内存以及CPU资源。 在YARN集群中,平衡内存、CPU、磁盘的资源的很重要的,根...

weixin_30877227的博客 89

正点原子stm32f103RChal库制作数字秒表:如用keil5和正点原子STM32F1开发板实现?

🏆本文收录于 《全栈Bug调优(实战版)》 专栏,该专栏专注于分享我在真实项目开发中遇到的各类疑难Bug及其深层成因,并系统提供高效、可复现的解决思路和实操方案。无论你是刚入行的新手开发者,还是拥有多年项目经验的资深工程师,本专栏都将为你提供一条系统化、高质量的问题排查与优化路径,助力你加速成长,攻克技术壁垒,迈向技术价值最大化与职业发展的更高峰🚀!    📌 特别说明: 文中部分技术问题来源于真实生产环境及网络公开案例,均经过精挑细选与系统化整理,并结合多位一线资深架构师和工程师多年实战经验沉淀,提

**My Coding Family** 1267
上一篇: Java虚拟机学习 - 内存调优
下一篇: 漫游Kafka之过期数据清理
王树民
博客等级 码龄10年 912粉丝 560原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值