在这篇文章中，我给大家介绍一些oracle内存管理和大页的知识。oracle发展这么多年，提供了多种的内存管理方式，从最早sga、pga手工管理，到9i版本出现的pga的自动管理，到10g版本出现的sga自动管理（asmm)，再到11g版本出现的memory自动管理（amm)，oracle基本是在朝着智能化、傻瓜化、自动化的方向稳步前进着，对于初学oracle的dba来说，看到这些不同的内存管理方式一定心里有着不同程度的疑惑，例如：
· oracle有这么多内存分配的管理方式，我该使用哪一种？是使用11g版本推出的amm管理方式，还是使用10g版本出现的asmm管理方式？或者干脆使用最旧的手工方式管理内存？
· 我该为我的实例sga，pga分别设置多大呢?
· 我该为buffer cache，shared pool分配多大的内存空间？
· 什么情况下我该使用大页？为什么大页这个词最近几年这么容易听到？
· 有没有一些简单粗暴的算法来搞定这一切？
写这篇文章的初衷也来源于上面这些非常正常的疑问，如果这篇文章能给有这些疑惑的dba朋友一些指导和帮助，那肉丝我也就真的功莫大焉了。
memory构成
在一个运行着oracle数据库的专用服务器上，内存基本上被以下内容所占用：
· kernel
· os page table
· 文件系统cache
· sga
· pga
· oracle进程
· 其他进程（rman，非oracle的进程等等）
严格来说os page table也算是kernel memory部分的内容，由于本文后面会重点讲大页的内容，因此把os page table这部分在图中独立了出来，以引起读者注意。必须要强调，oracle不应该使用掉主机上的所有内存，过量的内存分配会诱发操作系统swap的产生，导致oracle性能严重降低，在rac环境下，内存不足还非常容易导致rac节点的驱逐。对于oracle两大块内存：sga和pga，dba一定要仔细根据系统特点、业务使用特点做好规划和设计，以防出现os内存不够用的情况。
内存自动化发展历程
我们首先了解一下oracle内存发展的历程，基本上oracle的内存管理在版本的演进过程中沿着越来越智能化、自动化、傻瓜化的方向前进。接触过mysql等数据库的dba朋友应该比较清楚，这些数据库基本上都还需要dba去决定每个内存组件的大小，而oracle已经从9i版本开始就迈向智能化、自动化的过程了。下图是oracle内存管理的一个演进图：
pga 自动管理
oracle是多进程的架构，这点区别于mysql，mysql是单进程多线程的架构，oracle会为每一个用户连接创建一个独立的操作系统进程来为用户提供服务，这个进程叫做服务器进程或者影子进程，它像是用户的一个代理，来操作数据文件或者sga内存，由于服务器进程的代码是oracle公司开发的，所以oracle公司完全相信这些进程或代码是安全的，因此这些进程可以直接操作数据文件和sga内存，这些进程接受用户进程发送的指令，并完成相关的操作，并根据需要来给用户进程返回结果。由于服务器进程是操作系统上的一个进程，因此它本身需要占用一些操作系统内存，除此之外，进程在对数据进行读取、排序、hash过程中，也会占用一定量的内存，在oracle 9i版本之前，对于服务器进程的内存管理是由一些参数去控制的，以下参数代表每一个服务器进程可以使用的不同区域的内存大小（都是进程的私有内存区域）：
· sort_area_size
· hash_area_size
· bitmap_merge_area_size
· create_bitmap_area_size
例如，sort_area_size控制了每一个进程可用的排序区大小，hash_area_size参数控制了每一个进程可用的hash区大小，这些参数都有默认值，但是默认值是否合适，需要打上一个大大的问号，因为不同的任务对于pga内存的不同区域有不同的要求，例如，如果是做排序操作，就对排序区内存要求较大，而对hash区没任何的要求。当然如果默认值不合适，dba可以手工调整这些区域的大小。
oracle 9i版本出现了pga的自动管理，不再需要像9i之前版本需要设置一系列参数来控制pga的使用，只需要设置pga_aggregate_target为一个值，就可以控制所有的服务器进程的pga使用量，至于每个服务器进程使用了多少排序区，hash区，都交给oracle去控制。
一般情况下对于pga的大量使用有如下几种操作：
· hash 对于hash join操作，hash桶所占用的内存就在进程的私有pga内存中，而不是在共享内存sga中，如果使用pga手工管理的话，可以通过hash_area_size参数来动态调整会话进行hash操作能够使用的内存量。
· sort 对于排序操作，例如查询语句里的order by、创建索引的排序操作等占用的内存也在pga中，如果使用pga手工管理，可以通过sort_area_size参数动态调整会话排序操作可以使用的内存量。
· parallel 并行操作简直可以说是pga内存的杀手，每一个并行进程都能使用到最多2g的pga内存，当然oracle会确保所有的并行slave使用的pga内存不能超过pga_aggregate_target的一半。
现在oracle的版本已经出到了12c，pga的自动管理已经发展了很多个年头，如果是个人，也应该是一个非常成熟的小伙子了，甚至是位大叔了????，绝大部分数据库操作完全没必要再去手工调整pga的一些参数。不过，我们依然能从互联网上、论坛上看到有很多dba对这种手工调整pga的技术崇拜有加（我以前也是），确实在一些情况下，通过手工调整pga的相关内存区，可以达到加速排序等一些操作的目的，但是如果需要操作的数据量非常的大，那这种调整往往是费时费力，甚至是徒劳的，因为对于一个进程的私有pga内存来说，像sort,hash等p区域的内存分配是有限制的，现在11gr2的版本对于每个进程的pga内存最大限制默认是2个g，且排序区可以使用的只有1个g，如果你的排序等操作需要的内存远远不止1，2个g，那么这种优化就非常的徒劳，甚至还可能变慢（肉丝亲身遭遇过变慢的案例????）。是否使用pga自动管理由参数workarea_size_policy控制，它的值可以为auto和manual，顾名思义，auto为pga自动管理，manual为pga手工管理，回到9i之前的使用方式。
这里肉丝提供几个大家可能会感兴趣的隐含参数，比如我上面提到了每个进程最大能使用的pga不能超过2个g，通过修改隐含参数可以突破这个限制。 >肉丝在这里警戒各位，这些参数如果要在生产环境使用，请在你的数据库版本下做好测试。
以下为11gr2版本的情况，其他版本并未做测试：
· _pga_max_size 每个进程的pga的最大内存大小。默认值为：2147483648，2个g，单位为b。
· _smm_max_size 每个进程的工作区的大小，默认值为1/2 _pga_max_size，1048576 ，单位kb，1gb，排序区、hash区都属于工作区的范围。64位系统下真实使用的排序区内存不能超过4gb。
· _smm_px_max_size 所有并行查询的slave进程能够用到的pga总量。默认值为 1/2 pga_aggregate_target，单位为kb，rac环境下，每个节点都可以用到这么多内存。
以上全部为动态参数，可以在session/system级别来在线修改。
alter system set"_smm_px_max_size"=10485760;
alter system set"_smm_max_size"=1048576;
alter system set"_pga_max_size"=2147483648;
上面的参数调整后，一定要设置对应的pga_aggregate_target，否则以上调整可能会不起作用，建议设置为修改后的_smm_px_max_size的值的两倍。
默认情况下，每个进程使用的排序区不能超过1g。由参数_smm_max_size（单位kb）控制，默认为_pga_max_size（单位b）的一半。 例如，并行度20创建索引，总共可以使用的排序区大小为20*1g=20g，但是同时还受参数_smm_px_max_size的控制，所有的slave占用的内存不能超过_smm_px_max_size的值（单位为kb），默认为pga_aggregate_target的一半。同时64位系统下，每个进程可以使用的排序空间不能超过4个g。所以即使把_smm_max_size调整大于4个g也没有用。_smm_px_max_size，所有并行查询的slave进程能够用到的pga总量。每个rac 节点都可以用到这么多，限制的是本节点所有并行slave能够消耗的pga。
如何为pga_aggregate_target设置一个合理的值？
pga_aggregate_target的设定经常是一个摸索的过程，这里给出官方的一个分配指导原则
pga_aggregate_target =(total_mem * 80%) * 20% for an oltp system
pga_aggregate_target = (total_mem * 80%) * 50%for a dss system
上面公式中的total_mem * 80%代表着oracle可以使用的所有内存为操作系统的80%，再根据不同类型业务的特点，oltp系统，可以在此基础上分配20%的内存给pga，dss分析型系统，可以给出剩余内存的50%。这个只是一个指导的意见，具体情况要具体分析。例如，你的oltp系统上有成千上万个连接，那么你可以粗略的按照每个进程占用10m的内存来大体的计算一下pga需要占用的内存空间，再者，假如你的系统不但连接数非常多，而且活跃的连接数也非常的多，那么你可以按照每个进程至少12m的内存来进行估算，更为重要的，系统中假如存在非常多的临时性的计算任务，那么要为pga预留的内存就更多了。 例如，并行度设置为5创建索引，每个并行进程占用的pga内存接近1个g：
select * from
(select pga_used_mem/1024/1024,pga_alloc_mem/1024/1024,pga_max_mem/1024/1024
from v$process order by 1 desc) whererownum<14;
pga_used_mem/1024/1024 pga_alloc_mem/1024/1024 pga_max_mem/1024/1024
---------------------- --------------------------------------------
1043.70779 1044.39673 1044.39673
904.724821 905.334227 905.334227
851.350813 851.959227 851.959227
804.526175 805.146727 805.146727
589.681547 590.209227 637.584227
27.0686626 27.5379925 27.5379925
所以你在为系统规划pga内存时不要忘了这些临时性任务需要占用的内存。他们可能是很大的一块哦。
该为数据库分配多少的pga内存，除了把连接数的多少这个指标作为一个考量因素外，还需要关注活跃连接数的多少，这是因为很多系统连接数虽然非常的多，但是去数据库里一统计发现，绝大部分的连接已经几个小时甚至几天都没活跃过了，这往往是应用程序的连接池不加以管理的结果（也可能是其他原因）。对于不活跃的连接，oracle每个进程的pga占用不会太大，按照10m计算是个合理安全的值。aix下可以大一些，按照每个15m-20m计算。
这里再提供一种估算每个空闲的服务器进程占用os内存的方法。 首先通过操作系统命令free -m查看一下当前os剩余的内存，69590m
echo 3 >/proc/sys/vm/drop_caches
#free -m
total used free shared buffers cach
ed
mem: 128923 69590 59332 0 4 2
27
-/+ buffers/cache: 69358 59564
swap: 15999 1276 14723
然后创建2000个连接
test.sql
declare
l_n number;
begin
dbms_lock.sleep(600);
end;
/
#! /bin/sh
. /home/oracle/.bash_profile
step=1
while [ $step -lt 2000 ]
do
nohup sqlplus test/test @test.sql &
let "step+=1"
echo $step
done
再次查看剩余的操作系统内存，通过没创建连接之前的剩余内存减去创建完2000个连接之后的剩余内存可以估算出每个进程占用的内存大约为（59332-44548）/ 2000=7m
free -m
total used free shared buffers cach
mem: 128923 84374 44548 0 11 2
63
-/+ buffers/cache: 84099 44823
swap: 15999 1276 14723
读者需要牢记，减少的7m内存中，绝大部分都是进程本身占用的，只有1-2m的内存是pga占用的。因此上面给大家推荐的值是10-12m，也就是给进程预留出一些pga的内存来。
确认一个空闲进程占用的真正pga内存有多大，可以通过v$process视图中pga_alloc_mem字段来获得，如下：只有1.49m。但是就像上面已经提到的，这个进程从操作系统层面看却占用了7m左右的内存。
select round(pga_alloc_mem/1024/1024,2) from v$process where spid=5553;
round(pga_alloc_mem/1024/1024,2)
--------------------------------
1.49
pga_aggregate_target参数指定的值并不是一个硬限制，直到oracle 12c才提供了一个参数来强制限制pga的使用量。如果读者不知道该为自己系统的pga设置一个什么样的值，可以通过视图v
sysmetric_history
selectbegin_time,end_time,value
from v$sysmetric_history
where metric_name ='total pga allocated';
begin_time end_time value
------------------- ------------------- ----------
2016-04-08 11:31:21 2016-04-08 11:32:21 323746816
2016-04-08 11:30:20 2016-04-08 11:31:21 323746816
2016-04-08 11:29:21 2016-04-08 11:30:20 328404992
2016-04-08 11:28:21 2016-04-08 11:29:21 323746816
2016-04-08 11:27:21 2016-04-08 11:28:21 323746816
2016-04-08 11:26:20 2016-04-08 11:27:21 323746816
2016-04-08 11:25:21 2016-04-08 11:26:20 323746816
2016-04-08 11:24:21 2016-04-08 11:25:21 326611968
2016-04-08 11:23:21 2016-04-08 11:24:21 323746816
上面查询的输出代表了各个时间段的，pga内存的使用量，结果集并没有完全列出来，读者可以根据pga各个时间段的使用量来更加精准的去为自己系统的pga如何做设定做决策。设定pga的过程是一个循序渐进的过程。再次强调，一个进程占用的内存除了pga之外，进程本身也会占用内存，这点上面我们已经讨论过。
按照oracle 2015年oow上的一份ppt提到，12c之前版本，pga最多可用的内存可达到pga_aggregate_target设定值的三倍，这里你听一下就行了，不必当真。
如果生产环境真的遭遇了pga严重使用过量的情况，可以通过event 10261 来限制某个/所有进程pga的使用，level后面值的单位为kb。
alter session set events'10261 trace name context forever, level 100000';
一旦进程超出pga的设定配额，会被后台进程杀掉并报错，不同的版本可能报错的信息不一样：
· for 11.2.0.4 and 12.1.0.1+, ora-10260
· for 11.1 - 11.2.0.3, ora-600[723]
12c pga_aggregate_limit
12c之前的版本对于pga的使用限制并没有一个硬限制，这个可能会导致一些问题，比如不加以限制后可能会导致os swap的问题，一旦出现swap会导致oracle性能的急剧下降，甚至导致down机，我曾经遭遇过的一个案例是出现swap后，lgwr进程本身的内存出现了swap，数据库系统的表现是几乎完全hang死，最后没办法只能重启解决问题。
对于这个新特性的使用是通过参数pga_aggregate_limit来限制pga的使用上线，它是一个推导参数，在使用asmm情况下，取以下的最大值
· 2gb
· 200% pga_aggregate_target
· 3mb* processes
在使用amm情况下，肉丝还未找到pga_aggregate_limit取值的规律，如果你知道，请告诉我哦。
msmm
10g前sga的管理是通过手工设置一系列的参数来实现的，例如重要的参数有以下几个：
● buffer_cache_size
● shared_pool_size
● large_pool_size
● stream_pool_size
● log_buffer
sga是一大块内存的统称，由上面列出的组件组成，10g之前的版本,dba需要对sga的各个内存区域进行手工设置，这可能对一个dba无形中要求变得非常的高，需要了解业务，了解热点数据量，了解sql的使用方式，是否存在大量不同文本的sql等等来决策来给每个区域分配多少内存。使用过这个版本的dba基本都遭遇过一个经典的报错：ora-04031，一般是由于shared pool内存不够导致，这个不够的原因可能有很多，共享池内存的严重碎片化，大量的硬解析，巨大的pl/sql文本等等都可能会导致这个问题。下面我们来看下，手工管理sga情况下，如何考虑为buffer cache和shared pool这两个最重要的内存组件分配内存。
buffer cache
buffer cache俗称数据块高速缓存，是用来缓存数据块的拷贝的，oracle通过改进后的lru算法以期待这些数据块后续被高效的重用。服务器进程从磁盘读入的数据就放在这块内存中，修改数据时，也是在这个区域对数据进行修改。并没有一个给buffer cache分配内存的黄金法则，还是要根据操作系统的内存大小，业务的热点数据量、业务的类型等因素来决定给buffer cache分配多大的内存大小。我们先看下如何决定整个sga的大小，对于sga的分配原则，官方建议如下：
上面的公式格式跟pga的公式大同小异，刨去20%内存给操作系统之后，分为了不同的系统类型，基本上是oltp系统，大部分的内存给buffer cache，dss类的系统，buffer cache没那么重要，可以给到50%甚至更低。 至于sga中多少可以分配给buffer_cache，要看实际情况。dba可以通过查看buffer cache的命中率来粗略了解是否给buffer cache分配了足够的内存。但是熟悉我的朋友都知道，我是owi方法论的践行者，对于命中率的崇拜在oracle里已然不应该再存在，但是命中率作为一种性能诊断的辅助手段依然具有它的价值。如果系统的sql都足够优化后，命中率不高，一定程度上意味着可能buffer cache给小了或者你的业务访问的数据非常的离散，热点数量太少。这里肉丝给出的优化思路是自顶向下，命中率低是一个表象，最上层的应用是不是调用了大量不需要调用的sql，这些sql是不是缺少索引，sql都足够优化后，dba是不是考虑加大buffer cache来提升性能，加大之后还是不行，是不是要考虑增加系统内存来进一步提高buffer cache的大小，最后是不是需要为数据库多加几个盘或者使用ssd来提高性能。采用自顶向下的分析方法有利于真正发现问题所在而且以最低的代价解决问题，如果仅仅是一个sql由于缺少索引而导致整个数据库系统缓慢，dba直接就去加盘扩容io，那么最终会发现花费了这么大的代价，治标不治本，问题依然没有解决。上面给出的公式并不适用于所有情况，特别是oltp系统，如果进程数非常的多，那么需要进一步降低sga占用内存的比例，以预留出更多内存给pga使用。
shared pool
oracle占用量最大的两块内存除了buffer cache区就是shared pool的内存了，它的结构非常的复杂，而且由于要缓存sql代码这种非标准大小的文本，经常会产生大量的碎片化内存，shared pool总体上包含了两大部分，一块是library cache区，用来缓存sql、pl/sql代码，保存它们的执行计划，提高sql的解析效率，如果你的应用代码从来不使用绑定变量，那么这一块的内存对你来说是一个很大的负担，但是oracle里是无法关闭library cache区的，因此对于oltp系统，请确保sql都使用了绑定变量。第二大块区域是row cache区，用来缓存数据库的数据字典，由于保存在里面的信息是以行的形式存在，因此叫row cache。对于这一块的内存，依据数据库中元信息（metadata）的多少而决定，如果数据库中有几十万的对象，那么这一块的内存就会占用比较大，同时表上的很多列都有直方图信息，也会导致这一区的内存占用比较大。在一个稳定的系统中，这一区域的内存基本上是静态的，oracle中几乎没有操作会频繁修改row cache区。有个例外情况是没有cache属性的sequence，如果这种sequence调用频繁，就会触发频繁的修改sequence的属性值，进而可能会产生row cache lock的一些等待，优化的办法是为每一个sequence设置足够的cache值。 >如果应用程序没有使用绑定变量，而且难以修改，可以通过设置cursor_sharing为force来尝试解决问题。
这里肉丝再讲一个亲身经历的案例，老dba嘛，可能技能已经不多，但故事还是有的????，曾经帮一位客户解决了一个free buffer waits的案例，这个等待事件的出现一般说明buffer cache过小，或者全表扫描、写入操作比较多、写脏数据比较慢，从awr报告看，free buffer waits排在top event的第一名,占用的db time已达到了百分之七八十，而且从awr报告中发现客户的shared pool内存占用已经达到了接近50g，而分析数据库一个月之前的awr报告，shared pool的内存只有3个g左右的大小，基本上可以认定为shared pool内存占用过大，而导致buffer cache不够用，进而出现了free buffer waits等待事件，经过跟客户沟通后知道，以前一直比较稳定，最近做过的大的变更是给数据库使用了oracle 的flahcache，通过mos上搜索flashcache关键字最终发现，在11.2.0.4，oracle rac如果使用了flash cache，那么会在shared pool 中分配额外的内存存放gcs资源。多出的内存为：208 bytes * the total number of (flash) buffer blocks。因为这里提醒广大dba朋友，如果你打算使用oracle的flashcache那么请为它预留出足够的shared pool内存。
asmm
10g 版本oracle推出了asmm，自动sga管理，它的出现一定程度上帮助dba解决了管理sga的问题，通过设置参数sga_target为非0值来启用asmm。但是在10gr1,包括10gr2的早期版本，asmm还不够成熟存在比较多的bug，导致了比较多的问题，所以当时dba在一些核心的生产环境，还是沿用了9i时候的手工sga管理。自动sga管理，不再需要为每个内存组件设定值，当然如果你设置sga_target的同时，设置了db_cache_size这些参数，那么db_cache_size这些参数值会作为最小值要求。
如果sga_target设置为0，memory_target也为0，则回归到传统的msmm管理。通过使用asmm可以很大程度上解决上面提到的ora-04031的错误。在使用了asmm后，去查看spfile文件，会发现多了一些双下划线打头的内存参数如__db_cache_size，这些内存参数是oracle实例运行过程中动态产生固化到spfile中的，如果实例运行的时间足够长，这些参数的值被固话后，相当于有了一个基于自身环境的最佳实践参数，数据库实例重启后，会沿用固化在spfile中的这些参数值。 > 11g版本即使sga_target设置为0，memory_target也设置为0，也可能会发现sga的pool之间granule的移动，这是11g的新linux特性，通过参数_memory_imm_mode_without_autosga来控制。 >
granule
asmm技术的实现，内部是通过granule在内存组件之间移动来实现。这里对granule做一点解释，oracle 10g引入的自动共享内存管理，目的是为了解决下面的问题，“我应该把db_cache_size设置为多大?我应该把shared_pool_size设置多大？那么10g以后，oracle给出的答案是，“你不用再考虑这个问题了，我通过算法帮你搞定“。简单来说，就是通过比较通过增加数据块缓存减少的磁盘io时间与通过增加共享池优化而节省的时间，通过比对，来得出是否需要在两者间来移动内存。为了让内存在db_cache_size和shared_pool_size之间高效移动，oracle在9i版本中重新构建了sga，也就是使用固定大小的内存块-granule，granule会随着操作系统、oracle版本以及sga大小的不同而不同，读者可以通过如下的sql语句来查看当前实例的granule的大小：
amm
有了pga的自动管理，sga的自动管理，oracle 这个强迫症患者终于在11g这个版本推出了amm，自动内存管理，由于使用了amm后就不能使用大页，因此这个功能其实一直没被广泛使用，通过这个功能dba只需要设置memory_target一个参数就可以完成整个数据库实例内存的配置，就像asmm导致了一些双下划线隐含参数的产生，amm同样导致了一些双下划线隐含参数的产生，例如：__pga_aggregate_target，__sga_target。而且在11.2.0.2版本之前，dbca建库默认就是amm管理（有些时候oracle胆子真的是很大），11.2.0.3以后开始dbca建库时会检测操作系统内存大小，大于4g内存默认为asmm，小于4g内存默认为amm。同样如果你设置amm后，也设置了sga_target等参数，那么这些参数会作为最小值要求。
amm最大的问题是不能使用大页内存。关于使用大页的重要性会在本文后面部分详细介绍。 >doc 749851.1 > > doc 1453227.1.
11g后由于出现了amm，如果你做dba时间足够长，你一定遇到过下面这个错误
这个错误给人莫名其妙的感觉，“memory_target特性不被支持”，其实不是特性不被支持，这是由于amm使用的是操作系统的共享内存文件系统，位于/dev/shm下，如果配置的内存文件系统比较小，小于了memory_target的值就会报错，一般在linux主流的操作系统上，这个内存共享文件系统的值是内存大小的一半，如果读者遭遇了这个问题，要不去调小memory_target的参数值，要不通过如下办法去修改这个共享内存文件系统的大小：
这里指出一点，11g asm默认会使用amm，官方强烈建议不要修改这个默认行为。asm里要求memory_target的最小值为256m。如果设置了低于256m的值，oracle会自动增加内存到256m。 对于asm的发布版：11.2.0.3/11.2.0.4/12.1，oracle强烈建议把memory_target设置为1536m，这个值被证明在绝大部分的环境里都是足够的。
使用了asm后，数据库实例的shared_pool内存需要重新评估计算，如下公式是在正常shared pool的基础上需要额外增加的大小：
? 如果asm磁盘组是external redundancy,需要在2mb基础上，每100g的空间，增加1mb。
? 如果asm磁盘组是normal redundancy,需要在4mb基础上，每50g的空间，增加1mb。
? 如果asm磁盘组是high redundancy,需要在6mb基础上，每33g的空间，增加1mb。
asm & shared pool (ora-4031) (文档 id 437924.1)
大页
对于类linux系统，cpu必须把虚拟地址转换程物理内存地址才能真正访问内存。为了提高这个转换效率，cpu会缓存最近的虚拟内存地址和物理内存地址的映射关系，并保存在一个由cpu维护的映射表中，为了尽量提高内存的访问速度，需要在映射表中保存尽量多的映射关系。这个映射表在linux中每个进程都要持有一份，如果映射表太大，就会大大降低cpu的tlb命中率，主流的linux操作系统，默认页的大小是4k，对于大内存来说，这会产生非常多的page table entries，上面已经提到，linux下页表不是共享的，每个进程都有自己的页表，现在随便一个主机的内存都配置的是几十个g，几百个g，甚至上t，如果在上面跑oracle不使用大页，基本上是找死，因为oracle是多进程架构的，每一个连接都是一个独占的进程，大内存+多进程+不使用大页=灾难，肉丝在8年的dba生涯里，至少帮助不下5个客户处理过由于没有使用大页而导致的系统故障，而这5个客户都是近三四年遇到的，为什么大页这个词提前个三五年并没有被频繁提起，而当下，大页这个词在各种技术大会，最佳实践中成为热门词汇？这是因为最近几年是linux系统被大量普及应用的几年，也是大内存遍地开花的几年，而且现在一个数据库系统动不动就是几百上千个连接，这些都促成了大页被越来越多的被关注到。
大页的好处
我们来看一下使用了大页的好处：
● 少的page table entries,减少页表内存
● pin住sga，没有page out
● 提高tlb命中率，减少内核cpu消耗
在没有使用大页的系统上，经常可能会发现几十上百g的页表，严重情况下，系统cpu的sys部分的消耗非常大，这些都是没使用大页的情况下的一些症状。
大页的特点/缺点
● 要预先分配
● 不够灵活，甚至需要重启主机
● 如果分配过多，会造成浪费，不能被其他程序使用。
大页的分配方法
通过在文件/etc/sysctl.cnf中增加vm.nr_hugepages参数来为大页设定一个合理的值，值的单位为2mb。或者通过echo 一个值到/proc/sys/vm/nr_hugepages中也可以临时性的对大页进行设定。 至于应该为大页设定多大的值，这个要根据系统sga的配置来定，一般建议大页的总占用量大于系统上所有sga总和+2gb。
hugepages on oracle linux 64-bit (文档 id 361468.1),aix页表共享，一般不用设置大页。
大页的原理
以下的内容是基于32位的系统，4k的内存页大小做出的计算： 1）目录表，用来存放页表的位置，共包含1024个目录entry，每个目录entry指向一个页表位置，每个目录entry，4b大小，目录表共4b*1024=4k大小 2）页表，用来存放物理地址页的起始地址，每个页表entry也是4b大小，每个页表共1024个页表entry，因此一个页表的大小也是4k，共1024个页表，因此页表的最大大小是1024*4k=4m大小 3）每个页表entry指向的是4k的物理内存页，因此页表一共可以指向的物理内存大小为：1024（页表数）*1024（每个页表的entry数）*4k（一个页表entry代表的页大小）=4g 4）操作系统将虚拟地址映射为物理地址时，将虚拟地址的31-22这10位用于从目录表中索引到1024个页表中的一个，将虚拟地址的12-21这10位用于从页表中索引到1024个页表entry中的一个。从这个页表entry中获得物理内存页的起始地址，然后将虚拟地址的0-12位用作4kb内存页中的偏移量，那么物理内存页起始地址加上偏移量就是进出所需要访问的物理内存地址。
由于32位操作系统不会出现4m的页表，因为一个进程不能使用到4gb的内存空间，有些空间被保留使用，比如用来做操作系统内核的内存。而且页表entry的创建出现在进程访问到一块内存的时候，而不是一开始就创建。
页表内存计算
在32位系统下，一个进程访问1gb的内存，会产生1m的页表，如果是在64位系统，将会增大到2m。 很容易推算，如果一个sga设置为60g，有1500个oracle用户进程，64位linux的系统上，最大的页表占用内存为：60*2*1500/1024=175g，是的，你没看错，是175g！但是实际情况看到的页表占用可能没有这么大，打个百分之四五十的折扣，这是因为只有服务器进程访问到sga的特定区域后，进程才需要把这一块对应的页表项加入到自己的页表中。
11.2.0.3版本
11.2.0.3版本之前，如果分配的大页数量不足，那么oracle启动过程中不会使用大页，转而使用小页，但是在11.2.0.3版本后，oracle在启动时同样会尝试使用大页，如果大页的数量不够，那么会把当前配置的大页使用完，不够的部分再从小页中去获取，这一行为实际上是通过oracle的一个参数来控制use_large_pages，后面会对这个参数做详细解释。通过数据库实例的alert文件可以清楚的看到这一情况的发生：
total shared global region in large pages = 1024 mb (85%)，代表只有85%的sga被放在了大页中。recommendation部分，建议你至少增加89个大页来让sga完全放到大页中。
use_large_pages
这个参数用来控制数据库实例启动时，对于大页内存的使用行为。有3个值在11.2.0.3版本之前，11.2.0.3版本多了一个值auto：
? true 默认值，尽可能使用大页，有可能有一些页在大页中，有一些在小页中，这种情况下通过操作系统命令ipcs -ma可能会看到内存分段（内存分段可能有多重情况都会导致，例如开启numa也可能会导致内存分段）
? false 不使用大页
? only 选项代表强制使用大页，否则无法启动
? auto （11.2.0.3）在实例启动时，通过后台进程dism echo xxx > /proc/sys/vm/nr_hugepages 来尽可能的使用大页
以下代码为在参数设置为auto情况下alert的输出：
可以看到启动实例过程中，优先启动了dism进程，通过这个进程来自动完成大页的配置。$oracle_home/bin/oradism的权限也是root权限，因为如果是grid权限不能完成大页的配置echo xxx > /proc/sys/vm/nr_hugepages。
transparent hugepage
从redhat6, redhat7, ol6, ol7 sles11 和 uek2 kernels开始transparent hugepage被默认开启，它允许大页做动态的分配，而不是系统启动后就分配好，根据oracle mos doc：1557478.1，transparent hugepage导致了很多的问题，建议将其关闭 查看是否启用了transparent hugepage cat /sys/kernel/mm/transparent_hugepage/enabled [always] never []内的值是当前启用的值，上面的输出说明启用了transparent hugepage。 可以通过 /etc/grub.conf 文件来关闭transparent hugepage。
通过增加关键字transparent_hugepage=never来讲transparent hugepage关闭。 也可以通过开机启动后，echo相应的值到对应的文件来动态关闭transparent hugepage。
os层面查看大页使用情况
hugepages_total为所分配的页面数目，和hugepagesize相乘后得到所分配的内存大小。43000*2/1024大约为84gb。
hugepages_free为从来没有被使用过的hugepages数目。即使oracle sga已经分配了这部分内存，但是如果没有实际写入，那么看到的还是free的。这是很容易误解的地方。
hugepages_rsvd为已经被分配预留但是还没有使用的page数目。在oracle刚刚启动时，大部分内存应该都是reserved并且free的，随着oracle sga的使用，reserved和free都会不断的降低。
hugepages_free – hugepages_rsvd 这部分是没有被使用到的内存，如果没有其他的oracle instance，这部分内存也许永远都不会被使用到，也就是被浪费了。在该系统上有11.5gb的内存被浪费了。
最佳实践
对于oracle来说，这是一个最佳实践泛滥的时代，所有的最佳实践其实都有特定的应用场景，而不是放之四海皆准，但是当今信息爆炸时代（数据库种类爆炸时代），很多dba没有那么多的耐心去专注学习一门数据库，只是拿来主义从网上找出一些最佳实践来，不管三七二十一就用到自己的环境中（甚至是生产环境中），一定程度上来说，崇拜最佳实践是懒惰的结果。
针对于oracle的内存分配方式，肉丝给大家推荐在核心系统上： 1.使用手工的sga管理，这种管理方式已经非常的成熟，但是这种方式对dba要求较高，一定程度上需要了解业务特点。 2.如果第一种方法你感觉到比较难，那么使用asmm，但是为buffer cache,shared pool设定最小值的方式，这种方式是我非常推荐的方式。
至于amm这种内存分配方式，由于不能使用大页，建议不要去用。
具体到内存如何分配，针对是oltp场景，还是olap场景，有着不同的内存分配原则，即使是oltp场景，针对进程数的多少，并发数的多少，sql语句的特点，都会导致产生不同的内存分配方法。作为dba要掌握基本的oracle内存使用原理，然后根据实际情况去根据业务自身特点分配内存。
不管是oltp系统或者olap系统，一般都建议至少为操作系统预留出20%的内存空间，这些内存空间用于kernal、page table以及一些其他的进程需要，例如rman备份，文件系统缓存。这个也是oracle官方的建议。
把这一部分的内存刨去后，针对oltp系统，可以考虑先尝试预留出20%的内存给pga使用，80%的内存给sga使用。如果系统上进程数比较多，特别是同时活跃的进程数比较多，需要给pga预留出更多的内存，可以按照每个进程12m的pga占用进行计算。
针对olap系统，刨去操作系统的预留内存后，可以考虑预留出50%的内存给pga使用，50%的内存给sga使用。毕竟在纯olap下，buffer cache其实不需要那么大的内存空间。
sga、pga分配好后，要考虑到是否需要为buffer cache、shared pool来手工设定一个值，就像上文已经提到过的，可以参考buffer cache 的命中率，library hit的命中率作为一个辅助参考.如果命中率较低，有可能是内存分配的不够合理。当然你还需要借助于像awr报告这样的工具，根据sql的执行计划等内容来进一步的做诊断，比如命中率低的原因可能不是分配的buffer cache小，而是存在大量的低效的全表扫描，进而导致命中率低，这样的话，需要优化的就是sql，而不是继续加大buffer cache。再比如，如果你发现library cache hit比较低，可能并不是shared pool比较小，还可能是系统的sql存在大量未使用绑定变量的情况，导致硬解析过重。
优化经常是个系统工程，不能一蹴而就，特别像oracle是一个很庞大的复杂系统，对于问题的出现，更是要仔细推敲，不能轻易的下结论。随着做dba时间越来越长，你也会越来越懂tom的一句话：it depends。
<b>本文来自云栖社区合作伙伴“dbgeek”</b>