Manejo automático de memoria

A partir de la versión 11g  de la base de datos Oracle, se tiene una opción bastante útil y recomendada por Oracle de manejo automático de memoria y además, recomendada por el mismo Oracle. Al modificar algunos parámetros de la instancia, se puede implementar fácilmente.

Con esta opción, sólo se tiene que analizar de qué tamaño se desea tener las estructuras de memoria y Oracle se encarga de administrar dichas estructuras automáticamente. Su nombre en inglés es Automatic Memory Management (AMM).

El antecesor ASMM

Antes de la versión 11g, ya Oracle había implementado el Automatic Shared Memory Management (ASMM) en la versión 10g. Este consistía en asignar un valor a dos parámetros de la instancia de la base de datos para que Oracle controlara los demás parámetros de memoria como el Shared Pool o el Database Buffer Cache automáticamente.

Los dos parámetros son el sga_target y el sga_max_size, que controlan el límite inicial de uso de memoria y la cantidad máxima de memoria respectivamente.

De manera adicional y por separado, se tenía qué modificar el espacio a usar por la Program Global Area (PGA), es decir, la memoria que se reparte entre las sesiones que se conectan a la instancia de la base de datos. Esta se configura con los parámetros pga_aggregate_target y pga_aggregate_limit que actúan de manera similar a los del párrafo anterior.

blog_asmm

El nuevo AMM

Ahora con la opción AMM, se puede configurar toda la memoria que usará la instancia de la base de datos como un solo ente, la PGA se integra en esta sola configuración de memoria.

blog_amm

Para implementar la opción de manejo automático de memoria, se tienen qué seguir los pasos que se enumeran a continuación:

1. Verificar que el parámetro lock_sga no tenga el valor TRUE, porque eso haría que esté bloqueado el manejo automático de la memoria:

SQL> show parameter lock_sga

NAME                                 TYPE        VALUE
------------------------------------ ----------- ------------------------------
lock_sga                             boolean     FALSE

2. Determinar el tamaño que tiene actualmente la memoria por medio del parámetro sga_target:

SQL> show parameter sga_target

NAME                          TYPE        VALUE
----------------------------- ----------- ------------------------------
sga_target                    big integer 1G

3. Verificar el tamaño real usado por la PGA por medio de la vista V$PGASTAT:

SQL> select value/1024/1024/1024 used_pga
  2    from v$pgastat
  3   where name = 'maximum PGA allocated';

USED_PGA
 ----------
 .2336092

1 row selected.

4. Calcular la memoria que deberá tener administrando el AMM. El parámetro memory_target debe ser calculado de la siguiente forma:

memory_target = sga_target + max (used_pga, pga_aggregate_target)

En el ejemplo que muestro:

memory_target = 1GB + max (.233GB, 0.100GB)
memory_target = 1GB + .233GB
memory_target = 1.233GB    <- Este es el tamaño objetivo.

5. Cambiar los parámetros que controlan la memoria. El parámetro memory_max_target debe ser configurado como el tope máximo de uso de memoria, puede ser igual al memory_target o un poco más:

alter system set memory_max_target=cantidadM scope=spfile;

6. Verificar los parámetros que se tienen para el AMM:

show parameter db_cache_size
show parameter java_pool_size
show parameter large_pool_size
show parameter memory_max_target
show parameter memory_target
show parameter pga_aggregate_target
show parameter sga_max_size
show parameter sga_target
show parameter shared_pool_size
show parameter streams_pool_size

o con la siguiente consulta:

  select name,
         value / 1024 / 1024 total_mb
    from v$parameter
   where name in ('db_cache_size',
                  'java_pool_size',
                  'large_pool_size',
                  'memory_max_target',
                  'memory_target',
                  'pga_aggregate_target',
                  'sga_max_size',
                  'sga_target',
                  'shared_pool_size',
                  'streams_pool_size')
order by name;

7. Respaldar el spfile a un pfile para prevenirnos en caso de que algo malo pase:

create pfile from spfile;

8. Configurar el AMM poniendo loa parámetros memory_target y memory_max_target al valor que se tendrá y el resto a cero (0).

Si se desea que alguno de estos parámetros tenga un valor mínimo, entonces, también se puede configurar con un valor determinado. En el siguiente ejemplo, se pone un tamaño máximo de 2.5GB para la memoria máxima y de 2GB para el tamaño de esta:

alter system set        db_cache_size=0     scope=spfile;
alter system set       java_pool_size=0     scope=spfile;
alter system set      large_pool_size=0     scope=spfile;
alter system set    memory_max_target=2560m scope=spfile;
alter system set        memory_target=2048m scope=spfile;
alter system set pga_aggregate_target=0     scope=spfile;
alter system set         sga_max_size=0     scope=spfile;
alter system set           sga_target=0     scope=spfile;
alter system set     shared_pool_size=0     scope=spfile;
alter system set    streams_pool_size=0     scope=spfile;

9. Una vez cambiados los parámetros, se reinicia la instancia:

shutdown immediate
startup

y se puede confirmar que los parámetros de memoria tomaron el valor, en el siguiente ejemplo, se puede observar cómo ya Oracle asignó un valor al parámetro sga_max_size de manera automática:

NAME                              TOTAL_MB
------------------------------ -----------
db_cache_size                            0
java_pool_size                           0
large_pool_size                          0
memory_max_target                 2,560
memory_target                     2,048
pga_aggregate_target                     0
sga_max_size                      1,228
sga_target                               0
shared_pool_size                         0
streams_pool_size                        0

Cuando ya se levantó nuevamente la instancia, se puede monitorear el uso de la memoria conforme pase el tiempo con las siguientes consultas:

Uso actual de los componentes de la memoria en MB

  select component,
         min_size / 1024 / 1024            min_size,
         current_size / 1024 / 1024        current_size,
         max_size / 1024 / 1024            max_size,
         user_specified_size / 1024 / 1024 user_specified_size,
         granule_size / 1024 / 1024        granule_size
    from v$memory_dynamic_components
order by component;

Ejemplo de cómo se encuentra después del cambio, esto puede cambiar conforme se use la base de datos y su instancia:

COMPONENT                  MIN_SIZE   CURRENT_SIZE   MAX_SIZE USER_SPECIFIED_SIZE GRANULE_SIZE
-------------------------- ---------- ------------ ---------- ------------------- ------------
ASM Buffer Cache                    0            0          0                   0            4
DEFAULT 16K buffer cache            0            0          0                   0            4
DEFAULT 2K buffer cache             0            0          0                   0            4
DEFAULT 32K buffer cache            0            0          0                   0            4
DEFAULT 4K buffer cache             0            0          0                   0            4
DEFAULT 8K buffer cache             0            0          0                   0            4
DEFAULT buffer cache              912          912        912                   0            4
KEEP buffer cache                   0            0          0                   0            4
PGA Target                        820          820        820                   0            4
RECYCLE buffer cache                0            0          0                   0            4
SGA Target                       1228         1228       1228                   0            4
Shared IO Pool                      0            0          0                   0            4
java pool                           4            4          4                   0            4
large pool                          0            4          4                   0            4
shared pool                       296          296        296                   0            4
streams pool                        0            0          0                   0            4

Recomendación de tamaño de memoria

  select memory_size,
         memory_size_factor * 100  memory_size_factor,
         estd_db_time,
         estd_db_time_factor * 100 estd_db_time_factor
    from v$memory_target_advice
order by memory_size;

Con esta consulta se podrá ver qué tan eficiente ha sido y puede ser el uso de la memoria conforme al tamaño actual y un estimado hacia abajo hasta un 25% y hacia arriba hasta un 200% del mismo:

MEMORY_SIZE MEMORY_SIZE_FACTOR ESTD_DB_TIME ESTD_DB_TIME_FACTOR
----------- ------------------ ------------ -------------------
        512                 25           13              100.02
       1024                 50           13                 100
       1536                 75           13                 100
      2048               100          13                100
       2560                125           13                 100
       3072                150           13                 100
       3584                175           13                 100
       4096                200           13                 100

Donde:

MEMORY_SIZE muestra distintos tamaños de memoria alrededor del que se tiene actualmente en MB.

MEMORY_SIZE_FACTOR muestra el factor en porcentaje de cada tamaño. En negritas está el que configuré, por eso está al 100%, aquí se pueden ver los distintos porcentajes que se pueden tener con respecto al tamaño actual.

ESTD_DB_TIME es un estimado en tiempo de respuesta al ser consultada la información con base en el tamaño de la memoria. Esta es una columna importante porque se busca que sea el número menor de tiempo, así, si la memoria correspondiente al 150% del tamaño actual, tiene un número menor, me indicará que debo incrementar el tamaño de la memoria para llegar a ese factor de tiempo de respuesta. En el ejemplo, se ven todos iguales porque apenas lo acabo de cambiar.

ESTD_DB_TIME_FACTOR es el factor en porcentaje para el tiempo estimado de la columna ESTD_DB_TIME.

Recomendación de tamaño de la System Global Area (SGA)

De manera similar al anterior punto, se puede tener una recomendación en cuanto al tamaño de la SGA, esto se puede ver con la siguiente consulta:

   select sga_size,
          sga_size_factor * 100     sga_size_factor,
          estd_db_time,
          estd_db_time_factor * 100 estd_db_time_factor,
          estd_physical_reads
     from v$sga_target_advice
 order by sga_size;

Aquí se puede ver de qué tamaño se puede poner a la SGA para ver qué respuesta de tiempo de acuerdo a su tamaño, en el siguiente ejemplo, se ve cómo con el 50% de la SGA ya se tiene un tiempo aceptable:

  SGA_SIZE SGA_SIZE_FACTOR ESTD_DB_TIME ESTD_DB_TIME_FACTOR ESTD_PHYSICAL_READS
---------- --------------- ------------ ------------------- -------------------
       307              25          151              431.43               17298
       614              50           35                 100               16750
       921              75           35                 100               16750
      1228             100           35                 100               16750
      1535             125           35                 100               16750
      1842             150           35                 100               16750
      2149             175           35                 100               16750
      2456             200           35                 100               16750

Información actual de la SGA por módulo

Finalmente, una consulta un tanto clásica para ver qué tamaño tiene cada módulo  que compone a la SGA:

   select name,
          bytes/1024/1024 current_size,
          resizeable
     from v$sgainfo
 order by name;

En el siguiente ejemplo, se puede ver cómo ya algunos de los componentes han cambiado de tamaño después de lo que ya Oracle está administrando automáticamente:

NAME                                CURRENT_SIZE RES
----------------------------------- ------------ ---
Buffer Cache Size                            912 Yes
Fixed SGA Size                                 2 No
Free SGA Memory Available                      0
Granule Size                                   4 No
Java Pool Size                                 4 Yes
Large Pool Size                                4 Yes
Maximum SGA Size                           1,223 No
Redo Buffers                                   4 No
Shared IO Pool Size                            0 Yes
Shared Pool Size                             296 Yes
Startup overhead in Shared Pool               84 No
Streams Pool Size                              0 Yes

Si la información de este post te ha sido de utilidad o quieres que agregue algo más, deja por favor un comentario, contestaré a la brevedad.

Anuncios

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión /  Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión /  Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión /  Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión /  Cambiar )

Conectando a %s

A %d blogueros les gusta esto: