Oracle PGA详解

深碍√TFBOYSˉ_ 2022-04-12 10:53 326阅读 0赞

转自：http://yanguz123.iteye.com/blog/1542369  
  
　　PGA（Program Global Area 程序全局区）是一块包含一个服务进程的数据和控制信息的内存区域。它是 Oracle 在一个服务进程启动是创建的，是非共享的。一个 Oracle 进程拥有一个 PGA 内存区。一个 PGA 也只能被拥有它的那个服务进程所访问，只有这个进程中的 Oracle 代码才能读写它。因此， PGA 中的结构是不需要 Latch 保护的。  
　　我们可以设置所有服务进程的 PGA 内存总数受到实例分配的总体 PGA （ Aggregated PGA ）限制。  
　　在专有服务器（ Dedicated Server ）模式下， Oracle 会为每个会话启动一个 Oracle 进程；而在多线程服务（ Multi-Thread Server MTS ）模式下，由多个会话共享通一个 Oracle 服务进程。  
　　PGA 中包含了关于进程使用到的操作系统资源的信息，以及一些关于进程状态的信息。而关于进程使用的 Oracle 共享资源的信息则是在 SGA 中。这样做可以使在进程以外中止时，能够及时释放和清除这些资源。  
  
?Stack Space 是用来存储用户会话变量和数组的存储区域；  
?User Session Data 是为用户会话使用的附加存储区。  
|--Session Information  
|--Sort Area  
|--Cursor Information  
　　注意 Session information （用户会话信息）在独占服务器中与在共享服务器中所处的内存区域是不同的。  
  
\[b\]1.PGA 的组成\[/b\]  
PGA 由两组区域组成：固定 PGA 和可变 PGA （或者叫 PGA 堆， PGA Heap 【堆—— Heap 就是一个受管理的内存区】）。固定 PGA 和固定 SGA 类似，它的大小时固定的，包含了大量原子变量、小的数据结构和指向可变 PGA 的指针。  
　　可变 PGA 是一个内存堆。它的内存段可以通过视图 X$KSMPP （另外一个视图 X$KSMSP 可以查到可变 SGA 的内存段信息，他们的结构相同）查到。 PGA 堆包含用于存放 X$ 表的的内存（依赖与参数设置，包括 DB\_FILES 、 CONTROL\_FILES ）。  
  
　　总的来说， PGA 的可变区中主要分为以下三部分内容：  
　　1）私有 SQL 区；  
　　2）游标和 SQL 区  
　　3）会话内存  
  
\[b\]1.1 私有 SQL 区（ Private SQL Area ）\[/b\]  
私有 SQL 区包含了绑定变量值和运行时期内存结构信息等数据。每一个运行 SQL 语句的会话都有一个块私有 SQL 区。所有提交了相同 SQL 语句的用户都有各自的私有 SQL 区，并且他们共享一个共享 SQL 区。因此，一个共享 SQL 区可能和多个私有共享区相关联。  
  
　　一个游标的私有 SQL 区又分为两个生命周期不同的区：  
　　永久区：包含绑定变量信息。当游标关闭时被释放。  
　　运行区：当执行结束时释放。  
　　创建运行区是一次执行请求的第一步。对于 INSERT 、 UPDATE 和 DELETE 语句， Oracle 在语句运行结束时释放运行区。对于查询操作， Oracle 只有在所有记录被 fetch 到或者查询被取消时释放运行区。  
  
\[b\]1.2 游标和 SQL 区（ Cursors and SQL Areas ）\[/b\]  
　　一个 Oracle 预编译程序或 OCI 程序的应用开发人员能够很明确的打开一个游标，或者控制一块特定的私有 SQL 区，将他们作为程序运行的命名资源。另外， oracle 隐含的为一些 SQL 语句产生的递归调用（前面有介绍，读取数据字典信息）也使用共享 SQL 区。  
　　私有 SQL 区是由用户进程管理的。如何分配和释放私有 SQL 区极大的依赖与你所使用的应用工具。而用户进程可以分配的私有 SQL 区的数量是由参数 OPEN\_CURSORS 控制的，它的默认值是 50 。  
　　在游标关闭前或者语句句柄被释放前，私有 SQL 区将一直存在（但其中的运行区是在语句执行结束时被释放，只有永久区一直存在）下去。应用开发人员可以通过将所有打开的不再使用的游标都关闭来释放永久区，以减少用户程序所占用的内存。  
  
\[b\]1.3 会话内存（ Session Memory ）\[/b\]  
　　会话内存是一段用于保存会话变量（如登录信息）和其他预会话相关信息的内存。对于共享服务器模式下，会话内存是共享的，而不是私有的。  
　　对于复杂的查询（如决策支持系统中的查询），运行区的很大一部分被那些内存需求很大的操作分配给 SQL 工作区（ SQL Work Area ）。这些操作包括：  
　　基于排序的操作（ ORDER BY 、 GROUP BY 、 ROLLUP 、窗口函数）；  
　　Hash Join  
　　Bitmap merge  
　　Bitmap create  
  
　　例如，一个排序操作使用工作区（这时也可叫排序区 Sort Area ）来将一部分数据行在内存排序；而一个 Hash Join 操作则使用工作区（这时也可以叫做 Hash 区 Hash Area ）来建立 Hash 表。如果这两种操作所处理的数据量比工作区大，那就会将输入的数据分成一些更小的数据片，使一些数据片能够在内存中处理，而其他的就在临时表空间的磁盘上稍后处理。尽管工作区太小时， Bitmap 操作不会将数据放到磁盘上处理，但是他们的复杂性是和工作区大小成反比的。因此，总的来说，工作区越大，这些操作就运行越快。  
　　工作区的大小是可以调整的。一般来说，大的工作区能让一些特定的操作性能更佳，但也会消耗更多的内存。工作区的大小足够适应输入的数据和相关的 SQL 操作所需的辅助的内存就是最优的。如果不满足，因为需要将一部分数据放到临时表空间磁盘上处理，操作的响应时间会增长。  
  
  
\[b\]2 PGA 内存自动管理\[/b\]  
SQL 工作区可以是自动的、全局的管理。 DBA 只要设置参数 PGA\_AGGREGATE\_TARGET 给一个实例的 PGA 内存指定总的大小。设置这个参数后， Oracle 将它作为一个总的全局限制值，尽量使所有 Oracle 服务进程的 PGA 内存总数不超过这个值。  
　　在这个参数出现之前， DBA 要调整参数 SORT\_AREA\_SIZE 、 HASH\_AREA\_SIZE 、 BITMAP\_MERGE\_AREA\_SIZE 和 CREATE\_BITMAP\_AREA\_SIZE （关于这些参数，我们会在后面介绍），使性能和 PGA 内存消耗最佳。对这些参数的调整是非常麻烦的，因为即要考虑所有相关的操作，使工作区适合它们输入数据大小，又要使 PGA 内存不消耗过大导致系统整体性能下降。  
　　9i 以后，通过设置了参数 PGA\_AGGREGATE\_TARGET ，使所有会话的工作区的大小都是自动分配。同时，所有 \*\_AREA\_SIZE 参数都会失效。在任何时候，实例中可用于工作区的 PGA 内存总数都是基于参数 PGA\_AGGREGATE\_TARGET 的。工作区内存总数等于参数 PGA\_AGGREGATE\_TARGET 的值减去系统其他组件（如分配给会话的 PGA 内存）的内存消耗。分配给 Oracle 进程的 PGA 内存大小是根据它们对内存的需求情况来的。  
　　参数 WORKAREA\_SIZE\_POLICY 决定是否使用 PGA\_AGGREGATE\_TARGET 来管理 PGA 内存。它有两个值： AUTO 和 MANUAL 。默认是 AUTO ，即使用PGA\_AGGREGATE\_TARGET 来管理 PGA 内存。其实，从参数 WORKAREA\_SIZE\_POLICY 的名字上可以看出， Oracle 的 PGA 内存自动管理只会调整工作区部分，而非工作区部分（固定 PGA 区）则不会受影响。  
　　还有注意一点就是： 10g 之前， PGA\_AGGREGATE\_TARGET 只在专用服务模式下生效。而 10g 以后， PGA 内存自动管理在专有服务模式（ Dedicated Server ）和 MTS 下都有效。另外， 9i 在 OpenVMS 系统上还不支持 PGA 内存自动管理，但 10g 支持。  
　　设置了 PGA\_AGGREGATE\_TARGET 以后，每个进程 PGA 内存的大小也是受限制的：  
　　串行操作时，每个进程可用的 PGA 内存为 MIN(PGA\_AGGREGATE\_TARGET \* 5%, \_pga\_max\_size/2) ，其中隐含参数 \_pga\_max\_size 的默认值是 200M ，同样不建议修改它。  
并行操作时，并行语句可用的 PGA 内存为 PGA\_AGGREGATE\_TARGET \* 30% / DOP （ Degree Of Parallelism 并行度）。  
  
　　当用户进程连接到数据库并创建一个对应的会话时， Oracle 服务进程会为这个用户专门设置一个 PGA 区，用来存储这个用户会话的相关内容。当这个用户会话终止时，数据库系统会自动释放这个 PAG 区所占用的内存。这个 PGA 区对于数据库的性能有比较大的影响，特别是对于排序操作的性能。所以，在必要的时候合理管理 PGA 区，能够在很大程度上提高数据库的性能。  
  
\[b\]一、 PGA 与 SGA 的区别\[/b\]  
  
　　PGA( 程序缓存区 ) 与 SGA ( 系统全局区 ) 类似，都是 Oracle 数据库系统为会话在服务器内存中分配的区域。不过两者的作用不同，共享程度也不同。 SGA 系统全局区顾名思义，是对系统内的所有进程都是共享的。当多个用户同时连接到一个例程时，所有的用户进程、服务进程都可以共享使用这个 SGA 区。为此这个 SGA 的主要用途就是为不同用户之间的进程与服务进程提供一个交流的平台。除了这个作用，另外有一个重要的作用就是各种数据库的操作主要就是在这个 SGA 区内完成。  
  
　　而 PGA 程序缓冲区则主要是为了某个用户进程所服务的。这个内存区不是共享的，只有这个用户的服务进程本身才能够访问它自己的 PGA 区。做个形象的比喻， SGA 就好像是操作系统上的一个共享文件夹，不同用户可以以此为平台进行数据方面的交流。而 PGA 就好像是操作系统上的一个私有文件夹，只有这个文件夹的所有者才能够进行访问，其他用户都不能够访问。虽然程序缓存区不像其他用户的进程开放，但是这个内存区仍然肩负着一些重要的使命，如数据排序、权限控制等等都离不开这个内存区。  
  
\[b\]二、 为排序设置合理的排序区大小\[/b\]  
  
　　当用户需要对某些数据进行排序时，数据库是如何处理的呢 ? 首先，数据库系统会将需要排序的数据保存到 PGA 程序缓存区中的一个排序区内。然后再在这个排序区内对这些数据进行排序。如需要排序的数据有 2M ，那么排序区内必须至少要有 2M 的空间来容纳这些数据。然后排序过程中又需要有 2M 的空间来保存排序后的数据。由于系统从内存中读取数据比从硬盘中读取数据的速度要快几千倍，为此如果这个数据排序与读取的操作都能够在内存中完成，无疑可以在很大程度上提高数据库排序与访问的性能。如果这个排序的操作都能够在内存中完成，显然这是很理想的。但是如果 PGA 区中的排序区容量不够，不能够容纳排序后的数据，那会如何呢 ? 此时，系统会从硬盘中获取一个空间，用来保存这需要排序的数据。此时排序的效率就会降低许多。为此在数据库管理中，如果发现用户的很多操作都需要用到排序，那么会用户设置比较大的排序区，可以提高用户访问数据的效率。  
  
　　在 Oracle 数据库中，这个排序区主要用来存放排序操作产生的临时数据。一般来说，这个排序区的大小占据这 PGA 程序缓存取的大部分空间，这是影响 PGA 区大小的主要因素。在小型应用中，数据库管理员可以直接采用其默认的值。但是在一些大型的应用中，或者需要进行大量记录排序操作的数据库系统中，管理员可能需要手工调整这个排序区的大小，以提高排序的性能。如果系统管理员需要调整这个排序区大小的话，需要通过初始化参数 SORT\_AREA\_SIZE 来实现。为了提高数据访问与排序的性能，数据库系统利用内存比硬盘要快几千倍的实施，会将准备排序的数据临时存放到这个排序区，并在排序区内完成数据的排序。管理员需要牢记这个原则，并在适当的情况下调整排序区的大小，以提高数据访问与数据排序的性能。  
  
\[b\]三、 会话区保存着用户的权限等重要信息\[/b\]  
  
　　在程序缓存区内还包含着一个会话区。虽然绝大部分情况下，管理员不要维护这个会话区，可以让数据库系统进行维护。但是，管理员还是需要了解一下这个会话区的作用。因为这个会话区直接关系着数据库系统中数据的安全性。数据库系统不仅是存放数据的一个很好的载体，而且在还提供了一个统一管理数据的平台，可以根据实际需要，为不同的用户设置不同的访问权限。简单的说，在数据库中可以控制用户可以访问哪些数据。从而提高数据的安全性。  
  
　　当用户进程与数据库建立会话时，系统会将这个用户的相关权限查询出来，然后保存在这个会话区内。如此的话，用户进程在访问数据时，系统就会核对会话区内的用户权限信息，看看其是否具有相关的访问权限。由于系统将这个用户的权限信息存放在内存上，所以其核对用户权限的速度非常的快。因为系统不用再去硬盘中读取数据，直接从内存中读取。而从内存读取数据的效率要比硬盘上快几千倍。  
  
　　通常情况下，这个会话区内保存了会话所具有的权限、角色、性能统计等信息。这个会话区一般都是由数据库进行自我维护的，系统管理员不用干预。  
  
  
\[b\]四、 堆栈区保存变量信息\[/b\]  
  
　　有时候为了提高 SQL 语句的重用性，会在语句中使用绑定变量。简单的说，就是 SQL 语句可以接受用户传入的变量。从而用户只需要输入不同的变量值，就可以满足不同的查询需求。如现在用户需要查询所有员工的信息。然后其又要查询所有工龄在 3 年以上的员工等等。此时其实他们采用的是同一个 SQL 语句，只是传递给系统的变量不同而已。这可以在很大程度上降低数据库开发的工作量。这个变量在 Oracle 数据库系统中就叫做绑定变量。利用绑定变量可以加强与用户的互动性。另外在这个堆栈区内还保存着会话变量、 SQL 语句运行时的内存结构等重要的信息。  
  
　　通常情况下，这个堆栈区跟上面讲到的会话区一样，都可以让数据库系统进行自我维护，而管理员不用参与到其中。这些分区的大小，也是系统根据实际情况来进行自动分配的。当这个用户会话结束时，系统会自动释放这些区所占用的空间。  
  
\[b\]五、 游标区\[/b\]  
  
　　无论是 SQLServer 数据库还是 Oracle 数据库中，有时候都需要用到游标技术。当运行使用游标的语句时， Oracle 数据库系统会在程序缓存区中间为其分配一块区域。这块区域就叫做游标区。通常情况下，游标用来完成一些比较特殊的功能。而且一般来说，采用游标的语句要比其他语句的执行效率低一点。为此管理员在使用游标的时候，还是需要慎重。  
  
　　游标区是一个动态的区域。当用户执行游标语句时，系统就会在这个游标区内创建一个区域。当关闭游标时，这个区域就会被释放。这创建与释放，需要站用一定的系统资源，花费一定的时间。为此在使用游标时，如果频繁的打开和关闭游标，就会降低语句的执行性能。所以笔者建议，在写语句时，如果真的有必要使用游标技术时，则要注意游标不要频繁的打开和关闭。  
  
　　另外在 Oracle 数据库中，还可以通过限制游标的数量来提高数据库的性能。如在数据库系统中有一个初始化参数 OPEN\_CURSORS 。管理员可以根据实际的需要，来设置这个参数，控制用户能够同时打开游标的数目。不过需要注意的是，在确实需要才有游标的情况下，如果硬件资源能够支持的话，那么就需要放宽这个限制。这可以避免用户进程频繁的打开和关闭游标。因为频繁的打开和关闭游标这对游标的操作是不利的，会影响数据库的性能。  
  
从以上的分析中可以看出，程序全局区主要包含排序区、会话区、堆栈区和游标区四个部分的内容，他们各司其职，完成用户进程与数据库之间的会话。通常情况下，系统管理员主要关注的是排序区，在必要时需要手工调整这个排序区的大小。另外需要主要的是，游标区是一个动态的区域，在游标打开时创建，关闭时释放。故在数据库开发时，不要频繁的打开和关闭游标可以提高游标操作的效率，改善数据库的性能。其他分区的内容管理员只需要了解其用途，日常的维护交给数据库系统来完成即可。  
  
使用这个新特性，  
（1） oracle 可以自动调整 sql 内存区。  
（2） the sort\_area\_size 等参数 is ignored by all the sessions running 。  
　　在 oracle9i 中， pga\_aggregate\_target 参数仅对专用服务器模式下（ dedicated server ）的专属连接有效，对共享服务器（ shared server ）连接无效；从 oracle10g 开始 pga\_aggregate\_target 对专用服务器连接和共享服务器连接同时生效。  
　　1. pga\_aggregate\_target- 此参数用来指定所有 session 总计可以使用最大 pga 内存。这个参数可以被动态的更改 , 取值范围从 10m -- （ 4096g-1 ） bytes 。  
　　2. workarea\_size\_policy- 此参数用于开关 pga 内存自动管理功能，该参数有两个选项： auto 和 manual ，当设置为 auto 时，数据库使用 oracle9i 提供的自动 pga 管理功能，当设置为 manual 时，则仍然使用 oracle9i 前手工管理的方式。  
缺省的， oracle9i 中 workarea\_size\_policy 被设置为 auto 。  
  
　　单个 sql 操作能够使用的 pga 内存按照以下原则分配：  
　　1 ．对于串行操作  
　　min （ 5% pga\_aggregate\_target ,100mb ）  
　　2 ．对于并行操作  
　　30% pga\_aggregate\_target /dop （ dop=degree of parallelism 并行度）  
　　启用了自动 pga 调整之后， oracle 仍然需要遵循以下原则：  
　　untunable memory size + tunable memory size <= pga\_aggregate\_target  
　　对于 pga\_aggregate\_target 参数的设置， oracle 提供这样一个建议方案  
　　1 ．对于 oltp 系统  
　　pga\_aggregate\_target = (<total physical memory > \* 80%) \* 20%  
　　2 ．对于 dss 系统  
　　pga\_aggregate\_target = (<total physical memory > \* 80%) \* 50%  
  
　　一段描述  
　　在 9i 之前，我们主要是通过设置 sort\_area\_size 、 hash\_area\_size 等参数值（通常都叫做 \*\_area\_size ）来管理 PGA 的使用，不过严格说来，是对 PGA 中的 UGA 中的私有 SQL 区域进行管理，这块内存区域又有个名称叫做 SQL 工作区域。但是，这里有个问题，就是这些参数都是针对某个 session 而言的，也就是说设置的参数值对所有连进来的 session 都生效。在数据库实际运行过程中，总有些 session 需要的 PGA 多，而有些 session 需要的 PGA 少。如果都设置一个很小的 \*\_area\_size ，则会使得某些 SQL 语句运行时由于需要将临时数据交换到磁盘而导致效率低下。而如果都设置一个很大的值，又有可能一方面浪费空间，另一方面，消耗过多内存可能导致操作系统其他组件所需要的内存短缺，而引起数据库整体性能下降。所以如何设置 \*\_area\_size 的值一直都是 DBA 很头疼的一个问题。  
　　而从 9i 起所引入的一个新的特性可以有效的解决这个问题，这个特性就是自动 PGA 管理。 DBA 可以根据数据库的负载情况估计所有 session 大概需要消耗的 PGA 的内存总和，然后把该值设置为初始化参数 pga\_aggregate\_target 的值即可。 Oracle 会按照每个 session 的需要为其分配 PGA ，同时会尽量维持整个 PGA 的内存总和不超过该参数所定义的值。这样的话， oracle 就能尽量避免整个 PGA 的内存容量异常增长而影响整个数据库的性能。从而，就有效的解决了设置 \*\_area\_size 所带来的问题。  
  
  
  
\-- 预备知识  
PGA(Process Global Area) ，是 server process 一段私有内存区，它包含有全局变量，数据结构和一些控制信息。在 Oracle8i 中， PGA 调整非常复杂，要调整 SORT\_AREA\_SIZE 、 HASH\_AREA\_SIZE 、 BITMAP\_MERGE\_AREA\_SIZE 、 CREATE\_BITMAP\_AREA\_SIZE 等参数。在 ORACLE9I 中，只需要调整 PGA\_AGGREGATE\_TARGET 。  
具体参数：  
SQL> SHOW PARAMETER SORT\_AREA\_SIZE;  
  
NAME TYPE VALUE  
\------------------------------------ ----------- --------  
sort\_area\_size integer 524288  
  
SQL> SHOW PARAMETER HASH\_AREA\_SIZE;  
  
NAME TYPE VALUE  
\------------------------------------ ----------- ---------  
hash\_area\_size integer 1048576  
  
SQL> SHOW PARAMETER BITMAP\_MERGE\_AREA\_SIZE;  
  
NAME TYPE VALUE  
\------------------------------------ ----------- ---------  
bitmap\_merge\_area\_size integer 1048576  
  
SQL> SHOW PARAMETER CREATE\_BITMAP\_AREA\_SIZE;  
  
NAME TYPE VALUE  
\------------------------------------ ----------- ------------------------------  
create\_bitmap\_area\_size integer 8388608  
  
SQL> SHOW PARAMETER PGA\_AGGREGATE\_TARGET;  
  
NAME TYPE VALUE  
\------------------------------------ ----------- ------------------------------  
pga\_aggregate\_target big integer 25165824  
  
\--PGA\_AGGREGATE\_TARGET 初始化设置  
  
PGA\_AGGREGATE\_TARGET 的值应该基于 Oracle 实例可利用内存的总量来设置，这个参数可以被动态的修改。假设 Oracle 实例可分配 4GB 的物理内存，剩下的内存分配给操作系统和其它应用程序。你也许会分配 80 ％的可用内存给 Oracle 实例，即 3.2G 。现在必须在内存中划分 SGA 和 PGA 区域。  
  
在 OLTP 系统中，典型 PGA 内存设置应该是总内存的较小部分（例如 20 ％），剩下 80 ％分配给 SGA 。  
OLTP ： PGA\_AGGREGATE\_TARGET = (total\_mem \* 80%) \* 20%  
  
在 DSS 系统中，由于会运行一些很大的查询，典型的 PGA 内存最多分配 70 ％的内存。  
DSS ： PGA\_AGGREGATE\_TARGET = (total\_mem \* 80%) \* 50%  
  
在这个例子中，总内存 4GB ， DSS 系统，你可以设置 PGA\_AGGREGATE\_TARGET 为 1600MB ， OLTP 则为 655MB 。  
  
\-- 配置 PGA 自动管理  
  
不用重启 DB ，直接在线修改。  
  
SQL> alter system set workarea\_size\_policy=auto scope=both;  
  
System altered.  
  
SQL> alter system set pga\_aggregate\_target=512m scope=both;  
  
System altered.  
  
SQL> show parameter workarea  
  
NAME TYPE VALUE  
\------------------------------------ ----------- ------------------------------  
workarea\_size\_policy string AUTO -- 这个设置成 AUTO  
SQL> show parameter pga  
  
NAME TYPE VALUE  
\------------------------------------ ----------- ------------------------------  
pga\_aggregate\_target big integer 536870912  
  
\-- 监控自动 PGA 内存管理的性能  
  
V$PGASTAT ：这个视图给出了一个实例级别的 PGA 内存使用和自动分配的统计。  
  
SQL> set lines 256  
SQL> set pages 42  
SQL> SELECT \* FROM V$PGASTAT;  
  
NAME VALUE UNIT  
\---------------------------------------------------------------- ---------- ------------  
aggregate PGA target parameter 536870912 bytes -- 当前 PGA\_AGGREGATE\_TARGET 的值  
aggregate PGA auto target 477379584 bytes -- 当前可用于自动分配了的 PGA 大小，不应该比 PGA\_AGGREGATE\_TARGET 小  
global memory bound 26843136 bytes -- 自动模式下工作区域的最大大小， Oracle 根据工作负载自动调整。  
total PGA inuse 6448128 bytes  
total PGA allocated 11598848 bytes --PGA 的最大分配  
maximum PGA allocated 166175744 bytes  
total freeable PGA memory 393216 bytes --PGA 的最大空闲大小  
PGA memory freed back to OS 69074944 bytes  
total PGA used for auto workareas 0 bytes --PGA 分配给 auto workareas 的大小  
maximum PGA used for auto workareas 1049600 bytes  
total PGA used for manual workareas 0 bytes  
maximum PGA used for manual workareas 530432 bytes  
over allocation count 1118  
\-- 实例启动后，发生的分配次数，如果这个值大于 0 ，就要考虑增加 pga 的值  
bytes processed 114895872 bytes  
extra bytes read/written 4608000 bytes  
cache hit percentage 96.14 percent -- 命中率  
  
16 rows selected.  
  
\--V$PGA\_TARGET\_ADVICE  
  
SQL> SELECT round(PGA\_TARGET\_FOR\_ESTIMATE/1024/1024) target\_mb,  
ESTD\_PGA\_CACHE\_HIT\_PERCENTAGE cache\_hit\_perc,  
ESTD\_OVERALLOC\_COUNT  
FROM v$pga\_target\_advice;  
  
The output of this query might look like the following:  
  
TARGET\_MB CACHE\_HIT\_PERC ESTD\_OVERALLOC\_COUNT  
\---------- -------------- --------------------  
63 23 367  
125 24 30  
250 30 3  
375 39 0  
500 58 0  
600 59 0  
700 59 0  
800 60 0  
900 60 0  
1000 61 0  
1500 67 0  
2000 76 0  
3000 83 0  
4000 85 0  
  
可以看出当 TARGET\_MB 为 375M 是 ESTD\_OVERALLOC\_COUNT=0 ，所以我们可以将 PGA\_AGGREGATE\_TARGET 设置成 375M  
  
  
主要总结下 pga 分配算法 , 详细概念单总结  
  
简单理解 pga,pga 就是一个操作系统进程 , 或线程 (WIN 上 ) 的专用内存  
pmon,smon 这些后台进程都有自己的 pga  
  
  
pga 早期手动管理组成由 sort\_area\_size,hash\_area\_size,bitmap\_merge\_size,create\_bitmap\_area\_size( 这些都叫工作区 )  
手动缺点，不好回收和共享，会造成 PGA 内存过度消耗  
  
PAG 自动（ 9i 开始支持）  
1.pga\_aggregate\_target 来指定所有 session 总计可以使用的最大 pga 内存（ 10M-4096G ）  
2.workarea\_size\_policy 控制 pag 自动管理功能开启或关闭， auto 表示开启（ default ）， manual 表示关闭， 9i auto 只支持专用连接，共享连接不支持  
10g 都支持  
  
\_pga\_max\_size: 控制 pga 最大大小  
9i-10r1 中 , 单个 sql 操作内存使用现在  
1. 对于串行操作 , 单 sql 操作 pga 分配原则 ,min(5%\*pga\_aggregate\_target,100mb)  
\#\#\#\#\#\#\#\#5%\*pga\_aggregate\_targe 实际由 \_smm\_max\_size 控制 \]  
2. 并行操作使用 pga 按 30%\*pga\_aggregate\_target/dop(dop= 并行度 )  
  
  
  
  
9I \_pga\_max\_size 与 \_smm\_max\_size  
\_pga\_max\_size>5%\*pga\_aggregate\_target,\_smm\_max\_size=5%\*pga\_aggregate\_target'  
\_pga\_max\_size<5%\*pga\_aggregate\_target,\_smm\_max\_size=50\*\_pga\_max\_size  
  
used\_pga\_mb=min(5%\*pga\_aggregate\_target,50\*\_pga\_max\_size,\_smm\_max\_size)  
  
10r2,11g 原则  
1. 串行操作  
pga\_aggregate\_target<=500MB,\_smm\_max\_size=20%\*pga\_aggregate\_target  
pga\_aggregate\_target between 500m and 1000M ,\_smm\_max\_size=100M  
pga\_aggregate\_target between 1001m and 2.5g,\_smm\_max\_size=10%\*pga\_aggregate\_target  
pga\_aggregate\_target >2.5g,\_smm\_max\_size=0.25GB  
2. 并行操作  
50\*pag\_aggregate\_target/dop  
dop<=5 时 ,\_smm\_max\_size 生效  
dop>5 时 ,\_smm\_px\_max\_size 生效  
  
\_newsort\_enabled 控制算法规则 ,true 用 10g 新算法 ,false 用 9i 算法  
SQL> set linesize 132  
SQL> column name format a30  
SQL> column value format a25  
SQL> SELECT x.ksppinm NAME, y.ksppstvl VALUE, x.ksppdesc describ  
2 FROM SYS.x$ksppi x, SYS.x$ksppcv y  
3 WHERE x.indx = y.indx AND x.ksppinm LIKE '%&par%'  
4  
SQL> /  
Enter value for par: newsort  
old 3: WHERE x.indx = y.indx AND x.ksppinm LIKE '%&par%'  
new 3: WHERE x.indx = y.indx AND x.ksppinm LIKE '%newsort%'  
  
NAME VALUE  
\------------------------------ -------------------------  
DESCRIB  
\------------------------------------------------------------------------------------------------------------------------------------  
\_newsort\_enabled TRUE  
controls whether new sorts can be used as system sort  
  
设置建议  
1.oltp 系统 pag\_aggregate\_target=<total physical memory>\*80%\*20%  
2.dss 系统 pag\_aggregate\_target=<total physical memory>\*80%\*50%  
分析 : 留 20% 给 os, 其他 80% 给 pga+sga,oltp ,pga 占 80% 中 20%,dss 占 80% 中 50%  
  
\# 查看某个 process 使用情况  
select pid,spid,username ,pga\_used\_mem,pga\_alloc\_mem,pga\_freeable\_mem,pga\_max\_mem,program from v$process where spid=&spid  
  
SQL> select pid,spid,username ,pga\_used\_mem,pga\_alloc\_mem,pga\_freeable\_mem,pga\_max\_mem,program from v$process where spid=&spid;  
Enter value for spid: 25510  
old 1: select pid,spid,username ,pga\_used\_mem,pga\_alloc\_mem,pga\_freeable\_mem,pga\_max\_mem,program from v$process where spid=&spid  
new 1: select pid,spid,username ,pga\_used\_mem,pga\_alloc\_mem,pga\_freeable\_mem,pga\_max\_mem,program from v$process where spid=25510  
  
PID SPID USERNAME PGA\_USED\_MEM PGA\_ALLOC\_MEM  
\---------- ------------------------ --------------- ------------ -------------  
PGA\_FREEABLE\_MEM PGA\_MAX\_MEM PROGRAM  
\---------------- ----------- ------------------------------------------------  
33 25510 oracle 0 2664666  
983040 8431834oracle@dmk01(PZ98)  
  
pga\_used\_mem: 进程使用的 pga  
pga\_alloc\_mem: 分配给进程的 pga  
pga\_freeable\_mem: 空闲  
pga\_max\_mem: 进程使用 pga 内存的最大  
  
  
  
  
\# 查看 pga 消耗到哪些项目上了  
col program for a20  
set linesize 1000  
select p.program,p.pid,pm.category,pm.allocated,pm.used,pm.max\_allocated from v$process p,v$process\_memory pm where p.pid=pm.pid and p.spid=&spid;  
  
  
SQL> col program for a20  
SQL> set linesize 1000  
SQL> select p.program,p.pid,pm.category,pm.allocated,pm.used,pm.max\_allocated from v$process p,v$process\_memory pm where p.pid=pm.pid and p.spid=&spid;  
Enter value for spid: 25510  
old 1: select p.program,p.pid,pm.category,pm.allocated,pm.used,pm.max\_allocated from v$process p,v$process\_memory pm where p.pid=pm.pid and p.spid=&spid  
new 1: select p.program,p.pid,pm.category,pm.allocated,pm.used,pm.max\_allocated from v$process p,v$process\_memory pm where p.pid=pm.pid and p.spid=25510  
  
PROGRAM PID CATEGORY ALLOCATED USED MAX\_ALLOCATED  
\-------------------- ---------- --------------- ---------- ---------- -------------  
oracle@dmk01(PZ98) 33 SQL 0 0 2424808  
oracle@dmk01(PZ98) 33 PL/SQL 24840 17104 26928  
oracle@dmk01(PZ98) 33 Freeable 983040 0  
oracle@dmk01(PZ98) 33 Other 1656786 4997058  
  
  
  
sql 在 workare 中有 3 种方式  
1.optimal: 最优方式 , 所有处理可以在内存中完成  
2.onepass: 大部分操作可以在内存中完成 , 但交换到临时表一次  
3.multipass: 多变交互临时表 , 产生大量 disk sort 之类 , 性能最差  
  
oracle 建议  
workarea execution\_optimal>=90%  
workarea execution\_multipass=0%  
\# 查看系统中性能指标  
select name,value,100\*(value/decode((select sum(value) from v$sysstat where name like 'workarea execution%'),0,null,(select sum(value) from v$sysstat where name like 'workarea execution%')))pct from v$sysstat where name like 'workarea executions%';  
  
  
SQL> select name,value,100\*(value/decode((select sum(value) from v$sysstat where name like 'workarea execution%'),0,null,(select sum(value) from v$sysstat where name like 'workarea execution%')))pct from v$sysstat where name like 'workarea executions%';  
  
NAME VALUE PCT  
\---------------------------------------------------------------- ---------- ----------  
workarea executions - optimal 567832 99.9954214  
workarea executions - onepass 24 .004226409  
workarea executions - multipass 0 0  
  
  
  
\# 查单个 sql 语句 workarea 使用情况  
SELECT  
b.sql\_text,  
a.operation\_type,  
a.policy,  
a.last\_memory\_used/(1024\*1024) as "Used MB" ,  
a.estimated\_optimal\_size/(1024\*1024) as "Est Opt MB",  
a.estimated\_onepass\_size/(1024\*1024) as "Est OnePass MB",  
a.last\_execution,  
a.last\_tempseg\_size  
FROM v$sql\_workarea a,v$sql b  
WHERE a.hash\_value = b.hash\_value  
and a.hash\_value = &hashvalue  
/  
  
\# 查 session 使用 pga  
select a.name, b.value  
from v$statname a, v$sesstat b  
where a.statistic\# = b.statistic\#  
and b.sid = &sid  
and a.name like '%ga %'  
order by a.name  
/  
  
\#program 使用 pga 情况  
SELECT  
a.pga\_used\_mem "PGA Used",  
a.pga\_alloc\_mem "PGA Alloc",  
a.pga\_max\_mem "PGA Max"  
FROM v$process a,v$session b  
where a.addr = b.paddr  
and b.sid= &sid  
/  
  
  
  
  
  
关于 pga 自动管理算法：  
oracle 采用的 feedback loop 实现的，当一个 process 执行 sql 语句时 , 先用 local memory manager 注册一个 active workarea profile,workarea profile 是与内存管理器之间唯一的通信接口  
( 既 sql 语句和内存管理器之间唯一接口 ), 当 sql 语句执行完成对应的 workarea profile 删除  
,profile 含这个 workarea 很多属性（例如 sql 类型是 hash join 还是什么之类，执行 one pass,optimal 操作内存大小等的元数据）  
workarea active profile 集，通过 local memory manager 维护，存 sga 中 ,profile 常常被更新 ( 要求及时反映 sql 语句当前已消耗内存，及是否被交换到 temp tablespace 等信息 ) ，  
所以 active profile 基本上就是 pga 内存需要和当前正在使用的 pga 内存 , 通过这些 profile 信息  
,global memory manager 会计算出一个既可以限制内存使用又可以提高较好性能的 global memory bound, 这个值用于限制单个进程 pga 的上限， global memory manager 每 3S 更新一次 memory  
bound,local memory manager 得到 memory bound 后会计算每个 active statement 所需要分配的 pga 内存大小（ execute size ），然后每个 active statement 将会在自己所分配到的 execute size  
中计算  
  
  
  
  
路线 ( 一个环路 )  
active statement---> 注册 workarea profile-->local memory manager( 存 sga 中 )-->set of active workarea profiles-->global memory manager---> 计算出 memory bound--->local memory manager  
\---> 获取 workarea size--->active statement  
  
其实原理很简单，就是每个 sql 语句拿出信息做成 profile ，然后交给 local memory manager 然后做成 profile 集（大量 profile ），然后 global memory manager 通过 profile 集计算出 memory bound  
，把这个 memory bound 给 local memory manager ， local memory manager 用 memory bound 计算出每个 active statement 的 execute size ，然后每个 active statement 在自己分到的 execute  
size 中计算  
  
  
global memeory bound 将影响 所有进程 pga 分配（限制单个进程 pga 的上限）  
  
  
  
  
由 ckpt 实现 ,global memory manager 3s 更新一次 memory bound  
  
SQL> select description ,dest from x$messages where lower(description) like 'sql memory%';  
  
DESCRIPTION  
\----------------------------------------------------------------  
DEST  
\----------------------------------------------------------------  
SQL Memory Management Calculation  
CKPT  
  
  
  
SQL> select time,data from x$trace where lower(data) like '%sql memory%' order by seq\#;  
  
TIME  
\----------  
DATA  
\--------------------------------------------------------------------------------  
1.2688E+15  
KSBCTI: (CKPT) : (timeout action) : acnum=\[178\] comment=\[SQL Memory Management  
Calculation\]  
  
1.2688E+15  
KSBCTI: (CKPT) : (timeout action) : acnum=\[178\] comment=\[SQL Memory Management  
Calculation\]  
  
1.2688E+15  
  
TIME  
\----------  
DATA  
\--------------------------------------------------------------------------------  
KSBCTI: (CKPT) : (timeout action) : acnum=\[178\] comment=\[SQL Memory Management  
Calculation\]  
  
  
  
  
10g r2,11g 中， workarea 管理内存分配，存在 shared pool 中（ local memory manager ）  
SQL> select \* from v$sgastat where name like 'work area%';  
  
POOL NAME BYTES  
\------------ -------------------------- ----------  
shared pool work area tab 265320  
  
  
  
  
  
  
  
  
10g 测试  
  
  
  
SQL> select \* from v$version;  
  
BANNER  
\----------------------------------------------------------------  
Oracle Database 10g Enterprise Edition Release 10.2.0.4.0 - Prod  
PL/SQL Release 10.2.0.4.0 - Production  
CORE 10.2.0.4.0 Production  
TNS for Linux: Version 10.2.0.4.0 - Production  
NLSRTL Version 10.2.0.4.0 - Production  
  
  
  
SQL> set linesize 132  
SQL> column name format a30  
SQL> column value format a25  
SQL> SELECT x.ksppinm NAME, y.ksppstvl VALUE, x.ksppdesc describ  
2 FROM SYS.x$ksppi x, SYS.x$ksppcv y  
3 WHERE x.indx = y.indx AND x.ksppinm LIKE '%&par%'  
4  
SQL> /  
Enter value for par: pga\_max  
old 3: WHERE x.indx = y.indx AND x.ksppinm LIKE '%&par%'  
new 3: WHERE x.indx = y.indx AND x.ksppinm LIKE '%pga\_max%'  
  
NAME VALUE  
\------------------------------ -------------------------  
DESCRIB  
\------------------------------------------------------------------------------------------------------------------------------------  
\_pga\_max\_size 209715200  
Maximum size of the PGA memory for one process  
  
可以看到当 pga\_aggreate\_target 小于 1g,\_pga\_max\_size 默认为 200MB  
  
SQL> /  
Enter value for par: smm\_max  
old 3: WHERE x.indx = y.indx AND x.ksppinm LIKE '%&par%'  
new 3: WHERE x.indx = y.indx AND x.ksppinm LIKE '%smm\_max%'  
  
NAME VALUE  
\------------------------------ -------------------------  
DESCRIB  
\------------------------------------------------------------------------------------------------------------------------------------  
\_smm\_max\_size 26214  
maximum work area size in auto mode (serial)  
  
pga\_aggregate\_target <500M,\_smm\_max\_size 默认为 20%pga\_aggregate\_target=25.6M( 其实 \_smm\_max\_size 实际与 \_pga\_max\_size 还有关系 , 单相关算发已经不是 9i 的了 , 下面会证实 )  
  
  
SQL> show parameter pga  
  
NAME TYPE VALUE  
\------------------------------------ ----------- ------------------------------  
pga\_aggregate\_target big integer 128M  
SQL>  
  
  
SQL> select 26214/1024 from dual;  
  
26214/1024  
\----------  
25.5996094  
  
SQL> select 0.2\*128 from dual;  
  
0.2\*128  
\----------  
25.6  
  
\_smm\_max\_size = 20%\*pga\_aggregate\_target  
  
  
  
  
修改 \_pga\_max\_size=10MB pga\_aggregate\_target =128M  
  
SQL> alter system set "\_pga\_max\_size"=10m;  
  
System altered.  
  
SQL> startup force 重起下库 , 让内存重新计算  
ORACLE instance started.  
  
Total System Global Area 268435456 bytes  
Fixed Size 1266944 bytes  
Variable Size 100666112 bytes  
Database Buffers 159383552 bytes  
Redo Buffers 7118848 bytes  
Database mounted.  
Database opened.  
SQL> drop table t;  
  
Table dropped.  
  
SQL> create table t as select \* from dba\_objects;  
  
Table created.  
  
SQL> insert into t select \* from dba\_objects;  
  
50067 rows created.  
  
SQL> insert into t select \* from dba\_objects;  
  
50067 rows created.  
  
SQL> commit;  
  
Commit complete.  
  
SQL> select distinct sid from v$mystat;  
  
SID  
\----------  
159  
  
SQL> show parameter pga  
  
NAME TYPE VALUE  
\------------------------------------ ----------- ------------------------------  
\_pga\_max\_size big integer 10M  
pga\_aggregate\_target big integer 128M  
SQL> set linesize 132  
column name format a30  
SQL> SQL> column value format a25  
SQL> SELECT x.ksppinm NAME, y.ksppstvl VALUE, x.ksppdesc describ  
2 FROM SYS.x$ksppi x, SYS.x$ksppcv y  
3 WHERE x.indx = y.indx AND x.ksppinm LIKE '%&par%'  
4  
SQL> /  
Enter value for par: pga\_max  
old 3: WHERE x.indx = y.indx AND x.ksppinm LIKE '%&par%'  
new 3: WHERE x.indx = y.indx AND x.ksppinm LIKE '%pga\_max%'  
  
NAME VALUE  
\------------------------------ -------------------------  
DESCRIB  
\------------------------------------------------------------------------------------------------------------------------------------  
\_pga\_max\_size 10485760  
Maximum size of the PGA memory for one process  
可以看到已经生效 , 单位字节 =10M  
  
SQL> set linesize 132  
SQL> column name format a30  
SQL> column value format a25  
SQL> SELECT x.ksppinm NAME, y.ksppstvl VALUE, x.ksppdesc describ  
2 FROM SYS.x$ksppi x, SYS.x$ksppcv y  
3 WHERE x.indx = y.indx AND x.ksppinm LIKE '%&par%'  
4  
SQL> /  
Enter value for par: smm\_max  
old 3: WHERE x.indx = y.indx AND x.ksppinm LIKE '%&par%'  
new 3: WHERE x.indx = y.indx AND x.ksppinm LIKE '%smm\_max%'  
  
NAME VALUE  
\------------------------------ -------------------------  
DESCRIB  
\------------------------------------------------------------------------------------------------------------------------------------  
\_smm\_max\_size 5120  
maximum work area size in auto mode (serial)  
  
可以看到 \_smm\_max\_size 此时并不等于 20%\*pga\_aggregate\_target 而是 =5m 既 50%\_pga\_max\_size  
  
  
  
  
SQL> select 10485760/1024/1024 from dual;  
  
10485760/1024/1024  
\------------------  
10  
  
  
SQL> select 5120/1024 from dual;  
  
5120/1024  
\----------  
5  
  
  
SQL> set autotrace traceonly stat  
SQL> select \* from t where rownum<50000 order by 1,2,3,4,5,6,7;  
  
49999 rows selected.  
  
  
Statistics  
\----------------------------------------------------------  
37 recursive calls  
8 db block gets  
835 consistent gets  
1382 physical reads  
0 redo size  
2837037 bytes sent via SQL\*Net to client  
37063 bytes received via SQL\*Net from client  
3335 SQL\*Net roundtrips to/from client  
0 sorts (memory)  
1 sorts (disk)  
49999 rows processed  
  
  
  
  
  
  
SQL> select hash\_value from v$sql where sql\_text='select \* from t where rownum<50000 order by 1,2,3,4,5,6,7'  
2 ;  
  
HASH\_VALUE  
\----------  
1281487883  
  
SQL> SELECT  
b.sql\_text,  
2 3 a.operation\_type,  
4 a.policy,  
5 a.last\_memory\_used/(1024\*1024) as "Used MB" ,  
6 a.estimated\_optimal\_size/(1024\*1024) as "Est Opt MB",  
7 a.estimated\_onepass\_size/(1024\*1024) as "Est OnePass MB",  
8 a.last\_execution,  
9 a.last\_tempseg\_size  
10 FROM v$sql\_workarea a,v$sql b  
11 WHERE a.hash\_value = b.hash\_value  
12 and a.hash\_value = &hashvalue  
13 /  
Enter value for hashvalue: 1281487883  
old 12: and a.hash\_value = &hashvalue  
new 12: and a.hash\_value = 1281487883  
  
SQL\_TEXT  
\--------------------------------------------------------------------------------  
OPERATION\_TYPE POLICY Used MB Est Opt MB Est OnePass MB LAST\_EXECU  
\-------------------- ---------- ---------- ---------- -------------- ----------  
LAST\_TEMPSEG\_SIZE  
\-----------------  
select \* from t where rownum<50000 order by 1,2,3,4,5,6,7  
SORT (v2) AUTO 5.02832031 6.09960938 .98828125 1 PASS  
6291456  
  
可以看到内存被限制在 5M 内 , 现在操作是 1 pass, 如果 最优操作 ( 全在内存里 需要 6M)  
所以 \_smm\_max\_size 就可以限制一个 process pga 内存 最大使用  
  
  
此时 \_smm\_max\_size=5m 是如下计算  
1.\_pga\_max\_size<40%\*pga\_aggregate\_size, 此时 \_smm\_max\_size=50%\_pga\_max\_size  
2.\_pga\_max\_size>40%\*pga\_aggregate\_siz, 此时 \_smm\_max\_size 按下面方式计算  
  
pga\_aggregate\_target<=500MB,\_smm\_max\_size=20%\*pga\_aggregate\_target  
pga\_aggregate\_target between 500m and 1000M ,\_smm\_max\_size=100M  
pga\_aggregate\_target between 1001m and 2.5g,\_smm\_max\_size=10%\*pga\_aggregate\_target  
pga\_aggregate\_target >2.5g,\_smm\_max\_size=0.25GB  
  
  
  
  
修改 pga\_aggregate\_target 超过 500m  
SQL> alter system set pga\_aggregate\_target=501m;  
  
System altered.  
  
SQL> startup force  
ORACLE instance started.  
  
Total System Global Area 268435456 bytes  
Fixed Size 1266944 bytes  
Variable Size 100666112 bytes  
Database Buffers 159383552 bytes  
Redo Buffers 7118848 bytes  
Database mounted.  
Database opened.  
SQL> show parameter pga  
  
NAME TYPE VALUE  
\------------------------------------ ----------- ------------------------------  
\_pga\_max\_size big integer 10M ~~~~~~~~~ 还未 10MB  
pga\_aggregate\_target big integer 501M  
SQL>  
  
  
  
  
SQL> set linesize 132  
SQL> column name format a30  
SQL> column value format a25  
SELECT x.ksppinm NAME, y.ksppstvl VALUE, x.ksppdesc describ  
SQL> 2 FROM SYS.x$ksppi x, SYS.x$ksppcv y  
3 WHERE x.indx = y.indx AND x.ksppinm LIKE '%&par%'  
4  
SQL> /  
Enter value for par: pga\_max  
old 3: WHERE x.indx = y.indx AND x.ksppinm LIKE '%&par%'  
new 3: WHERE x.indx = y.indx AND x.ksppinm LIKE '%pga\_max%'  
  
NAME VALUE  
\------------------------------ -------------------------  
DESCRIB  
\------------------------------------------------------------------------------------------------------------------------------------  
\_pga\_max\_size 10485760  
Maximum size of the PGA memory for one process  
  
  
SQL> /  
Enter value for par: smm\_max  
old 3: WHERE x.indx = y.indx AND x.ksppinm LIKE '%&par%'  
new 3: WHERE x.indx = y.indx AND x.ksppinm LIKE '%smm\_max%'  
  
NAME VALUE  
\------------------------------ -------------------------  
DESCRIB  
\------------------------------------------------------------------------------------------------------------------------------------  
\_smm\_max\_size 5120 ~~~~~~~~~~~~~~~ 还为 5M 单位 kb  
maximum work area size in auto mode (serial)  
  
通过这个可以发现 影响 \_smm\_max\_size 调整最直接相关的参数为 \_pga\_max\_size, 由于 \_pga\_max\_size 未调整 . \_smm\_max\_size 没变  
所以可以得出结论 pga\_aggreate\_target 影响 \_pga\_max\_size,\_pga\_max\_size 影响 \_smm\_max\_size  
  
可以看到 虽然 pga\_aggregate\_target 设置了 501M,\_PGA\_MAX\_SIZE 应该为 200M 自动调整为，但由于 \_pga\_max\_size 手动调整的，所以要手动 reset 下 让它自动默认（这样就自动计算了）  
SQL> alter system reset "\_pga\_max\_size" scope=spfile sid='\*' ;  
  
System altered.  
  
SQL> startup force  
ORACLE instance started  
  
Total System Global Area 268435456 bytes  
Fixed Size 1266944 bytes  
Variable Size 100666112 bytes  
Database Buffers 159383552 bytes  
Redo Buffers 7118848 bytes  
Database mounted.  
Database opened.  
SQL> set linesize 132  
SQL> column name format a30  
SQL> column value format a25  
SQL> SELECT x.ksppinm NAME, y.ksppstvl VALUE, x.ksppdesc describ  
2 FROM SYS.x$ksppi x, SYS.x$ksppcv y  
3 WHERE x.indx = y.indx AND x.ksppinm LIKE '%&par%'  
4  
SQL> /  
Enter value for par: pga\_max  
old 3: WHERE x.indx = y.indx AND x.ksppinm LIKE '%&par%'  
new 3: WHERE x.indx = y.indx AND x.ksppinm LIKE '%pga\_max%'  
  
NAME VALUE  
\------------------------------ -------------------------  
DESCRIB  
\------------------------------------------------------------------------------------------------------------------------------------  
\_pga\_max\_size 209715200 ~~~~~~~~~  
Maximum size of the PGA memory for one process  
  
按算发 pga\_aggreate\_target<1g,\_pga\_max\_size =200m  
  
SQL> /  
Enter value for par: smm\_max  
old 3: WHERE x.indx = y.indx AND x.ksppinm LIKE '%&par%'  
new 3: WHERE x.indx = y.indx AND x.ksppinm LIKE '%smm\_max%'  
  
NAME VALUE  
\------------------------------ -------------------------  
DESCRIB  
\------------------------------------------------------------------------------------------------------------------------------------  
\_smm\_max\_size 102400  
maximum work area size in auto mode (serial)  
  
  
SQL> show parameter pga  
  
NAME TYPE VALUE  
\------------------------------------ ----------- ------------------------------  
pga\_aggregate\_target big integer 501M  
SQL>  
  
102400/1024=100MB 正好 100MB  
可以看到 \_pga\_max\_size=200M(pga\_aggreate\_target<1g,\_pga\_max\_size default =200m) ，按表面算法 pga\_aggreate\_target>500M \_smm\_max\_size 为 100MB  
而实际内部因为  
\_pga\_max\_size=200M<40%\*pga\_aggregate\_target, 所以 \_smm\_max\_size =100M （ 50%\*\_pga\_max\_size ）  
(pga\_aggreate\_target 影响 \_pga\_max\_size,\_pga\_max\_size 影响 \_smm\_max\_size)  
有时候 手动修改 \_pga\_max\_size 后 ，如果要让算法继续执行，需要 reset 下，否则不使用算法了 .  
  
  
  
改 pga\_aggregate\_target<500M  
SQL> alter system set pga\_aggregate\_target=499m;  
  
System altered.  
  
SQL> startup force  
ORACLE instance started.  
  
Total System Global Area 268435456 bytes  
Fixed Size 1266944 bytes  
Variable Size 100666112 bytes  
Database Buffers 159383552 bytes  
Redo Buffers 7118848 bytes  
Database mounted.  
Database opened.  
SQL> set linesize 132  
SQL> column name format a30  
SQL> column value format a25  
SQL> SELECT x.ksppinm NAME, y.ksppstvl VALUE, x.ksppdesc describ  
2 FROM SYS.x$ksppi x, SYS.x$ksppcv y  
3 WHERE x.indx = y.indx AND x.ksppinm LIKE '%&par%'  
4  
SQL> /  
Enter value for par: pga\_max  
old 3: WHERE x.indx = y.indx AND x.ksppinm LIKE '%&par%'  
new 3: WHERE x.indx = y.indx AND x.ksppinm LIKE '%pga\_max%'  
  
NAME VALUE  
\------------------------------ -------------------------  
DESCRIB  
\------------------------------------------------------------------------------------------------------------------------------------  
\_pga\_max\_size 209715200  
Maximum size of the PGA memory for one process  
  
  
SQL> /  
Enter value for par: smm\_max  
old 3: WHERE x.indx = y.indx AND x.ksppinm LIKE '%&par%'  
new 3: WHERE x.indx = y.indx AND x.ksppinm LIKE '%smm\_max%'  
  
NAME VALUE  
\------------------------------ -------------------------  
DESCRIB  
\------------------------------------------------------------------------------------------------------------------------------------  
\_smm\_max\_size 102195  
maximum work area size in auto mode (serial)  
  
  
SQL> select 102195/1024 from dual;  
  
102195/1024  
\-----------  
99.7998047 \_smm\_max\_size=99.8m,\_pga\_max\_size =200M  
  
SQL> show parameter pga  
  
NAME TYPE VALUE  
\------------------------------------ ----------- ------------------------------  
pga\_aggregate\_target big integer 499M  
SQL> select 499\*0.2 from dual;  
  
499\*0.2  
\----------  
99.8  
  
SQL> select 0.4\*499 from dual;  
  
0.4\*499  
\----------  
199.6  
  
分析 \_pga\_max\_size >40%pga\_aggregate\_target , 所以 \_smm\_max\_size=20%\*pga\_aggregate\_target =99.8M  
  
  
  
手动改 \_pga\_max\_size 为 300M,pga\_aggregate\_target=501M  
SQL> alter system set "\_pga\_max\_size"=300M SCOPE=SPFILE;  
  
System altered.  
  
SQL> startup force;  
ORACLE instance started.  
  
Total System Global Area 268435456 bytes  
Fixed Size 1266944 bytes  
Variable Size 100666112 bytes  
Database Buffers 159383552 bytes  
Redo Buffers 7118848 bytes  
Database mounted.  
Database opened.  
SQL> set linesize 132  
SQL> column name format a30  
SQL> column value format a25  
SQL> SELECT x.ksppinm NAME, y.ksppstvl VALUE, x.ksppdesc describ  
2 FROM SYS.x$ksppi x, SYS.x$ksppcv y  
3 WHERE x.indx = y.indx AND x.ksppinm LIKE '%&par%'  
4  
SQL> /  
Enter value for par: pga\_max  
old 3: WHERE x.indx = y.indx AND x.ksppinm LIKE '%&par%'  
new 3: WHERE x.indx = y.indx AND x.ksppinm LIKE '%pga\_max%'  
  
NAME VALUE  
\------------------------------ -------------------------  
DESCRIB  
\------------------------------------------------------------------------------------------------------------------------------------  
\_pga\_max\_size 314572800  
Maximum size of the PGA memory for one process  
  
  
SQL> /  
Enter value for par: smm\_max  
old 3: WHERE x.indx = y.indx AND x.ksppinm LIKE '%&par%'  
new 3: WHERE x.indx = y.indx AND x.ksppinm LIKE '%smm\_max%'  
  
NAME VALUE  
\------------------------------ -------------------------  
DESCRIB  
\------------------------------------------------------------------------------------------------------------------------------------  
\_smm\_max\_size 102604  
maximum work area size in auto mode (serial)  
  
  
  
SQL> show parameter pga  
  
NAME TYPE VALUE  
\------------------------------------ ----------- ------------------------------  
\_pga\_max\_size big integer 300M  
pga\_aggregate\_target big integer 501M  
SQL>  
SQL> select 102604/1024 from dual;  
  
102604/1024  
\-----------  
100.199219  
  
  
SQL> select 0.2\*501 from dual;  
  
0.2\*501  
\----------  
100.2  
  
  
分析  
\_pga\_max\_size>40%\*pga\_aggregate\_target,  
按算法 pga\_aggregate\_target>500M<1G,\_smm\_max\_size =100MB( 按 pga\_aggregate\_target between 500m and 1000M ,\_smm\_max\_size=100M), 但实际还是按  
\_pga\_max\_size>40%\*pga\_aggregate\_target,\_smm\_max\_size=20%\*pga\_aggregate\_target =100.2m  
  
  
做一个极端的 ,\_pga\_max\_size=600M,pga\_aggregate\_target=700M, 如果按 pga\_aggregate\_target between 500m and 1000M 那么 \_smm\_max\_size=100M, 实际会是这样吗 ?  
  
  
SQL> alter system set "\_pga\_max\_size"=600m;  
  
System altered.  
  
SQL> alter system set pga\_aggregate\_target=700m;  
  
System altered.  
  
SQL> startup force  
ORACLE instance started.  
  
Total System Global Area 268435456 bytes  
Fixed Size 1266944 bytes  
Variable Size 100666112 bytes  
Database Buffers 159383552 bytes  
Redo Buffers 7118848 bytes  
Database mounted.  
Database opened.  
SQL> show parameter pga  
  
NAME TYPE VALUE  
\------------------------------------ ----------- ------------------------------  
\_pga\_max\_size big integer 600M  
pga\_aggregate\_target big integer 700M  
SQL> set linesize 132  
SQL> column name format a30  
SQL> column value format a25  
SQL> SELECT x.ksppinm NAME, y.ksppstvl VALUE, x.ksppdesc describ  
2 FROM SYS.x$ksppi x, SYS.x$ksppcv y  
3 WHERE x.indx = y.indx AND x.ksppinm LIKE '%&par%'  
4  
SQL>  
SQL> /  
Enter value for par: smm\_max  
old 3: WHERE x.indx = y.indx AND x.ksppinm LIKE '%&par%'  
new 3: WHERE x.indx = y.indx AND x.ksppinm LIKE '%smm\_max%'  
  
NAME VALUE  
\------------------------------ -------------------------  
DESCRIB  
\------------------------------------------------------------------------------------------------------------------------------------  
\_smm\_max\_size 143360  
maximum work area size in auto mode (serial)  
  
  
可以看到 \_smm\_max\_size=140G 没有按 ,pga\_aggregate\_target>500M<1G 时候应该 =100m,\_pga\_max\_size>40%\*pga\_aggregate\_target, 而是按 20%\*pga\_aggreget\_target 算的 =140G 了  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
设置 \_pga\_max\_size=199g,pga\_aggregate\_target=501g  
SQL> alter system set "\_pga\_max\_size"=199M SCOPE=SPFILE;  
  
System altered.  
  
SQL> startup force  
ORACLE instance started.  
  
Total System Global Area 268435456 bytes  
Fixed Size 1266944 bytes  
Variable Size 100666112 bytes  
Database Buffers 159383552 bytes  
Redo Buffers 7118848 bytes  
Database mounted.  
Database opened.  
SQL> show parameter pga  
  
NAME TYPE VALUE  
\------------------------------------ ----------- ------------------------------  
\_pga\_max\_size big integer 199M  
pga\_aggregate\_target big integer 501M  
SQL> set linesize 132  
SQL> column name format a30  
SQL> column value format a25  
SQL> SELECT x.ksppinm NAME, y.ksppstvl VALUE, x.ksppdesc describ  
2 FROM SYS.x$ksppi x, SYS.x$ksppcv y  
3 WHERE x.indx = y.indx AND x.ksppinm LIKE '%&par%'  
4  
SQL> /  
Enter value for par: smm\_max  
old 3: WHERE x.indx = y.indx AND x.ksppinm LIKE '%&par%'  
new 3: WHERE x.indx = y.indx AND x.ksppinm LIKE '%smm\_max%'  
  
NAME VALUE  
\------------------------------ -------------------------  
DESCRIB  
\------------------------------------------------------------------------------------------------------------------------------------  
\_smm\_max\_size 101888  
maximum work area size in auto mode (serial)  
  
  
SQL> select 101888/1024 from dual;  
  
101888/1024  
\-----------  
99.5~~~~~~~~~~~~~~~  
  
分析 \_pga\_max\_size<40%pga\_aggregat\_target, 所以 \_smm\_max\_size=50%\_pga\_max\_size  
  
SQL> alter system set "\_pga\_max\_size"=99M SCOPE=SPFILE;  
  
System altered.  
  
SQL> startup force  
ORACLE instance started.  
  
Total System Global Area 268435456 bytes  
Fixed Size 1266944 bytes  
Variable Size 100666112 bytes  
Database Buffers 159383552 bytes  
Redo Buffers 7118848 bytes  
Database mounted.  
Database opened.  
SQL> set linesize 132  
SQL> column name format a30  
SQL> column value format a25  
SQL> SELECT x.ksppinm NAME, y.ksppstvl VALUE, x.ksppdesc describ  
2 FROM SYS.x$ksppi x, SYS.x$ksppcv y  
3 WHERE x.indx = y.indx AND x.ksppinm LIKE '%&par%'  
4  
SQL> /  
Enter value for par: pga\_max  
old 3: WHERE x.indx = y.indx AND x.ksppinm LIKE '%&par%'  
new 3: WHERE x.indx = y.indx AND x.ksppinm LIKE '%pga\_max%'  
  
NAME VALUE  
\------------------------------ -------------------------  
DESCRIB  
\------------------------------------------------------------------------------------------------------------------------------------  
\_pga\_max\_size 103809024  
Maximum size of the PGA memory for one process  
  
  
SQL> /  
Enter value for par: smm\_max  
old 3: WHERE x.indx = y.indx AND x.ksppinm LIKE '%&par%'  
new 3: WHERE x.indx = y.indx AND x.ksppinm LIKE '%smm\_max%'  
  
NAME VALUE  
\------------------------------ -------------------------  
DESCRIB  
\------------------------------------------------------------------------------------------------------------------------------------  
\_smm\_max\_size 50688  
maximum work area size in auto mode (serial)  
  
  
SQL> select 103809024/1024/1024 from dual  
2 ;  
  
103809024/1024/1024  
\-------------------  
99  
  
SQL> select 50688 /1024 from dual;  
  
50688/1024  
\----------  
49.5  
\_smm\_max\_size = 49.5  
  
分析 \_pga\_max\_size<40%pga\_aggregat\_target, 所以 \_smm\_max\_size=50%\_pga\_max\_size  
  
  
  
  
有文挡说 \_smm\_max\_size 最大 0.25GB, 实际是这样吗  
SQL> alter system set pga\_aggregate\_target=2g; 修改为 2g  
  
System altered.  
  
SQL> startup force;  
ORACLE instance started.  
  
Total System Global Area 268435456 bytes  
Fixed Size 1266944 bytes  
Variable Size 100666112 bytes  
Database Buffers 159383552 bytes  
Redo Buffers 7118848 bytes  
Database mounted.  
Database opened.  
SQL> set linesize 132  
SQL> column name format a30  
SQL> column value format a25  
SQL> SELECT x.ksppinm NAME, y.ksppstvl VALUE, x.ksppdesc describ  
2 FROM SYS.x$ksppi x, SYS.x$ksppcv y  
3 WHERE x.indx = y.indx AND x.ksppinm LIKE '%&par%'  
4  
SQL> /  
Enter value for par: pga\_max  
old 3: WHERE x.indx = y.indx AND x.ksppinm LIKE '%&par%'  
new 3: WHERE x.indx = y.indx AND x.ksppinm LIKE '%pga\_max%'  
  
NAME VALUE  
\------------------------------ -------------------------  
DESCRIB  
\------------------------------------------------------------------------------------------------------------------------------------  
\_pga\_max\_size 419430400  
Maximum size of the PGA memory for one process  
  
  
\_pga\_max\_size =20%\*pga\_aggreaget\_target=400m  
SQL> /  
Enter value for par: smm\_max  
old 3: WHERE x.indx = y.indx AND x.ksppinm LIKE '%&par%'  
new 3: WHERE x.indx = y.indx AND x.ksppinm LIKE '%smm\_max%'  
  
NAME VALUE  
\------------------------------ -------------------------  
DESCRIB  
\------------------------------------------------------------------------------------------------------------------------------------  
\_smm\_max\_size 204800  
maximum work area size in auto mode (serial)  
  
\_pga\_max\_size<40%pga\_aggregate\_target, 所以 \_smm\_max\_size=50%\*\_pga\_max\_size=200m  
  
文档中当 pga\_aggrgate\_target >1G 情况时 , 其实还是按上面的 计算方式  
\_pga\_max\_size=20%\*pga\_aggregate\_target  
\_smm\_max\_size=10%\*pga\_aggregate\_target  
  
一套负责的生产库中 pga (11g,11.1.0.7)  
SQL> show parameter target  
  
NAME TYPE VALUE  
\------------------------------------ ----------- ------------------------------  
archive\_lag\_target integer 0  
db\_flashback\_retention\_target integer 1440  
fast\_start\_io\_target integer 0  
fast\_start\_mttr\_target integer 0  
memory\_max\_target big integer 0  
memory\_target big integer 0 \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* 没开  
SQL> show parameter pga  
  
NAME TYPE VALUE  
\------------------------------------ ----------- ------------------------------  
pga\_aggregate\_target big integer 30G  
SQL> set linesize 132  
SQL> column name format a30  
SQL> column value format a25  
SQL> SELECT x.ksppinm NAME, y.ksppstvl VALUE, x.ksppdesc describ  
2 FROM SYS.x$ksppi x, SYS.x$ksppcv y  
3 WHERE x.indx = y.indx AND x.ksppinm LIKE '%&par%'  
4  
SQL>  
SQL> /  
Enter value for par: pga\_max  
old 3: WHERE x.indx = y.indx AND x.ksppinm LIKE '%&par%'  
new 3: WHERE x.indx = y.indx AND x.ksppinm LIKE '%pga\_max%'  
  
NAME VALUE  
\------------------------------ -------------------------  
DESCRIB  
\------------------------------------------------------------------------------------------------------------------------------------  
\_pga\_max\_size 2147483648  
Maximum size of the PGA memory for one process  
  
  
SQL> /  
Enter value for par: smm\_max  
old 3: WHERE x.indx = y.indx AND x.ksppinm LIKE '%&par%'  
new 3: WHERE x.indx = y.indx AND x.ksppinm LIKE '%smm\_max%'  
  
NAME VALUE  
\------------------------------ -------------------------  
DESCRIB  
\------------------------------------------------------------------------------------------------------------------------------------  
\_smm\_max\_size 1048576  
  
可以看到 \_smm\_max\_size 早就超过了 250M 到达了 1G, 这个数是根据 \_pga\_max\_size 决定  
当 pga\_aggreate\_size>1g 时候 ,\_pga\_max\_size=20%\*pga\_aggreate\_size(pga\_aggreate\_size>10g 时 ,\_pga\_max\_size 不变 )  
\_pga\_max\_size=20%\*10g<40%\*pga\_aggreaget\_size, 所以 \_smm\_max\_size=50%\*\_pga\_max\_size=1g  
  
总结 10g r2  
  
PGA\_AGGREATE\_TARGET 与 \_smm\_max\_size  
pga\_aggregate\_target<=500MB,\_smm\_max\_size=20%\*pga\_aggregate\_target  
pga\_aggregate\_target between 500m and 1000M ,\_smm\_max\_size=100M  
pga\_aggregate\_target between 1001m and 2.5g,\_smm\_max\_size=10%\*pga\_aggregate\_target  
  
  
  
  
  
pga\_aggregate\_target,\_pga\_max\_size 关系  
\_pga\_max\_size 如果 pga\_aggregate\_target<1g \_pga\_max\_size= 默认 200MB  
\_pga\_max\_size 如果 pga\_aggregate\_target>1g,\_pga\_max\_size=20%\*pga\_aggregate\_target(>5G 不再变化 )  
  
实际到内部  
\_smm\_max\_size 为实际控制单个 process 使用 pga 上限 , 唯一可以相关他的参数是 \_pga\_max\_size,\_pga\_max\_size 被 pga\_aggregate\_target 相关  
\_pga\_max\_size<40%\*pga\_aggregate\_target,\_smm\_max\_size=50%\*\_pga\_max\_size ，  
其他时候（ \_pga\_max\_size>40%\*pga\_aggregate\_target ） \_smm\_max\_size=20%PGA\_AGGREGATe\_TARGET  
  
  
  
  
具体 process 可以使用的 pga 就是由 \_smm\_max\_size 控制  
  
  
> "\_pga\_max\_size" is 200M by default.  
  
That was true up to Oracle 10.1. Since 10.2 it is a dynamic parameter.  
  
In 10.2 it is limited to 200M as long as pga\_aggregate\_target is smaller as 1GB.  
When pga\_aggregate\_target is set to a larger value as 1GB then \_pga\_max\_size= 20% of pga\_aggregate\_target .  
  
> Is 350M of "pga\_aggregate\_target" effective even when "\_pga\_max\_size" is 200M?  
Yes it is still effective. The size of one work area (hash area, sort area) is not directly limited by \_pga\_max\_size but by \_smm\_max\_size (unit of this parameter is KBytes!). When you set pga\_aggregate\_target to 350M \_smm\_max\_size should have a value like 71680 (71680KB => 70MB).  
  
  
  
  
  
  
  
随着版本的变化内存管理也发生变化  
  
11g 内存管理更加简单了  
只要设置 memory\_target=PGA+SGA 这叫做 amm 特性， automatic memory management  
设置后取代了 pga\_aggregate\_target,sga\_target, 原理跟设置 sga\_target 一样， \_pga\_aggregate\_target,\_sga\_target 表示数据库上次正常关闭时候内存分配的样子  
  
oracle 启动时候 会用 pga\_aggregate\_target,sga\_target 与 \_pga\_aggregate\_target,\_sga\_target, 谁的值大用谁  
  
  
SQL> show parameter target  
  
NAME TYPE VALUE  
\------------------------------------ ----------- ------------------------------  
archive\_lag\_target integer 0  
db\_flashback\_retention\_target integer 1440  
fast\_start\_io\_target integer 0  
fast\_start\_mttr\_target integer 0  
memory\_max\_target big integer 476M  
memory\_target big integer 476M \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*  
pga\_aggregate\_target big integer 60M  
sga\_target big integer 0  
  
  
  
SQL> set linesize 132  
SQL> column name format a30  
SQL> column value format a25  
SQL> SELECT x.ksppinm NAME, y.ksppstvl VALUE, x.ksppdesc describ  
2 FROM SYS.x$ksppi x, SYS.x$ksppcv y  
3 WHERE x.indx = y.indx AND x.ksppinm LIKE '%&par%'  
4  
SQL>  
SQL> /  
Enter value for par: pga\_aggrega  
old 3: WHERE x.indx = y.indx AND x.ksppinm LIKE '%&par%'  
new 3: WHERE x.indx = y.indx AND x.ksppinm LIKE '%pga\_aggrega%'  
  
NAME VALUE  
\------------------------------ -------------------------  
DESCRIB  
\------------------------------------------------------------------------------------------------------------------------------------  
pga\_aggregate\_target 62914560  
Target size for the aggregate PGA memory consumed by the instance  
  
\_\_pga\_aggregate\_target 150994944  
Current target size for the aggregate PGA memory consumed  
  
可以看到实际 pga 为 150M  
SQL> /  
Enter value for par: pga\_max  
old 3: WHERE x.indx = y.indx AND x.ksppinm LIKE '%&par%'  
new 3: WHERE x.indx = y.indx AND x.ksppinm LIKE '%pga\_max%'  
  
NAME VALUE  
\------------------------------ -------------------------  
DESCRIB  
\------------------------------------------------------------------------------------------------------------------------------------  
\_pga\_max\_size 209715200  
Maximum size of the PGA memory for one process  
  
可以看到 pga 小于 1g,\_pga\_max\_size 默认为 200M  
  
SQL> /  
Enter value for par: smm\_max  
old 3: WHERE x.indx = y.indx AND x.ksppinm LIKE '%&par%'  
new 3: WHERE x.indx = y.indx AND x.ksppinm LIKE '%smm\_max%'  
  
NAME VALUE  
\------------------------------ -------------------------  
DESCRIB  
\------------------------------------------------------------------------------------------------------------------------------------  
\_smm\_max\_size 29491  
maximum work area size in auto mode (serial)  
  
\_pga\_max\_size>40%\_\_pga\_aggregate\_target 所以 ,\_smm\_max\_size 按 \_\_pga\_aggregate\_target 算法 ( 此例中小于 500M 那么 \_smm\_max\_size=20\*\_\_pga\_aggregate\_target=30M).  
  
  
  
  
  
  
  
  
  
  
\# 查看 pga 建议  
SELECT (SELECT ROUND(value/1024/1024,0) FROM v$parameter  
WHERE name = 'pga\_aggregate\_target') "Current Mb"  
, ROUND(pga\_target\_for\_estimate/1024/1024,0) "Projected Mb"  
, ROUND(estd\_pga\_cache\_hit\_percentage) "%"  
FROM v$pga\_target\_advice  
ORDER BY 2;  
  
  
  
  
\#PGA 常用的查询  
  
\-PGASTAT  
max memory used per session = min(5%\*pga\_aggregate\_target,50%\*\_pga\_max\_size,\_smm\_max\_size)  
\_sort\_multiblock\_read\_count  
  
SELECT NAME,VALUE VALUE\_INT FROM V$PGASTAT;  
  
select last\_execution,count(1) from v$sql\_workarea where POLICY='AUTO' group by last\_execution;  
  
select sum(OPTIMAL\_EXECUTIONS) OPTIMAL,sum(ONEPASS\_EXECUTIONS) ONEPASS ,sum(MULTIPASSES\_EXECUTIONS) MULTIPASSES  
from v$sql\_workarea where POLICY='AUTO';  
  
SELECT LOW\_OPTIMAL\_SIZE/1024 low\_kb,(HIGH\_OPTIMAL\_SIZE+1)/1024 high\_kb,  
optimal\_executions optimal, onepass\_executions onepass, multipasses\_executions multipasses  
FROM v$sql\_workarea\_histogram  
WHERE total\_executions != 0;  
  
select n.name,sum(s.value) value  
from v$sesstat s,v$statname n where s.statistic\#=n.statistic\#  
and n.name like 'workarea executions%'  
group by n.name;  
  
select n.name,sum(s.value) value  
from v$sysstat s,v$statname n where s.statistic\#=n.statistic\#  
and n.name like 'workarea executions%'  
group by n.name;  
  
SELECT round(PGA\_TARGET\_FOR\_ESTIMATE/1024/1024) target\_mb,  
ESTD\_PGA\_CACHE\_HIT\_PERCENTAGE cache\_hit\_perc,  
ESTD\_OVERALLOC\_COUNT  
FROM v$pga\_target\_advice;  
  
SELECT server, s.username, osuser, NAME, VALUE / 1024 / 1024, s.SID, s.serial\#, spid  
FROM v$session s, v$sesstat st, v$statname sn, v$process p  
WHERE st.SID = s.SID  
AND st.statistic\# = sn.statistic\#  
AND sn.NAME LIKE 'session pga memory'  
AND p.addr = s.paddr  
AND VALUE > 10 \* 1024 \* 1024 --only show pga > 10M  
ORDER BY VALUE DESC;  
  
\--PGA USAGE  
SQL> select  
sum(value)/1024/1024 Mb  
from  
v$sesstat s, v$statname n  
where  
n.STATISTIC\# = s.STATISTIC\# and  
name = 'session pga memory';  
  
col name format a30  
select  
sid,name,value  
from  
v$statname n,v$sesstat s  
where  
n.STATISTIC\# = s.STATISTIC\# and  
name like 'session%memory%'  
order by 3 asc;  
  
SQL> select sum(bytes)/1024/1024 Mb from  
(select bytes from v$sgastat  
union  
select value bytes from  
v$sesstat s,  
v$statname n  
where  
n.STATISTIC\# = s.STATISTIC\# and  
n.name = 'session pga memory'  
);  
  
  
  
\# 接触过许多 9I 库ＰＧＡ　给到 40 多Ｇ　但还是有不少多遍排序情况～原因就是　上面算法问题