Catégories: Auteurs, Cary Millsap, Doug Burns, Franck Pachot, Greg Rahn, Jonathan Lewis, Tom Kyte

Mohamed Houri a traduit un chapitre de Jonathan Lewis sur le Clustering Factor qui est si important dans le coùt d'accès à une table via un index.
Voici le lien de la traduction en français: http://jonathanlewis.files.wordpress.com/2011/05/le-clustering-factor.pdf

Jonathan Lewis a mis les liens de l'article original et de la traduction sur son blog.

Il n'a a pas eu beaucoup d'articles traduits ces derniers mois. Pour patienter, voici un lien sur une présentation:
Interpreting AWR Report - Straight to the Goal en anglais, mais très visuel...

C'est parfois difficile d'aborder un rapport AWR ou Statspack qui comprends 50 pages de statistiques, dont seulement quelques unes sont utiles dans un contexte donné. J'ai vu plusieurs personnes qui ne savent pas vraiment par où commencer. Et sans une approche méthodique, c'est facile de perdre du temps sur des choses qui ne feront pas gagner un un temps significatif dans l'amélioration du temps de réponse.

Cette présentation montre une approche méthodique: en partant du temps passé en base de données (DB time) pour voir si le rapport est pertinent ou pas, puis en prenant les éléments du 'Top 5 events' en montrant où aller chercher les détails qui permettent de comprendre la raison d'un problème de performance, comment le résoudre, et estimer le gain en temps de réponse que peut apporter la résolution.

Ceci est une traduction de d'un ancien post de Jonathan Lewis sur forums.oracle.com, référencé récemment sur son blog. Il décrit le fonctionnement de la journalisation en mémoire (IMU - In Memory Undo), une optimisation introduite en 10g qui utilise des structures en mémoire pour diminuer la contention sur les blocs d'undo et le redo log buffer.

Le contenu des blocs d'undo et des fichiers de redo log sont quasiment les même que l'on utilise in-memory undo (et les private redo threads) ou que l'on utilise la journalisation 'normale'.
La principale différence se trouve dans l'ordre où sont faites les choses.
Il y a aussi, avec in-memory undo, une diminution du nombre de redo records même si le nombre de change vectors reste le même.

Voici le séquencement d'une transaction courte avec gestion normale de la journalisation.

• Vous modifiez un bloc de table ou d'index. Un vecteur de changement (redo change vector) est généré pour cette modification.
• En même temps, vous devez enregistrer l'information nécessaire pour défaire (rollback) de cette modification. C'est un enregistrement d'annulation (undo record) qui est généré pour décrire ce qui a été altéré.
• Mais comme cet undo record est stocké dans un bloc d'undo (rollback segment), alors un vecteur de changement redo change vector est généré pour décrire cette modification du bloc d'undo
• Oracle combine ces deux redo change vector (vecteurs de changement du bloc de donnée et du bloc d'undo) dans en un enregistrement de redo (redo record), ce qui incrémente la statistique de session 'redo entries'.
• Donc pour cette modification, Oracle doit acquérir de l'espace dans le tampon journalisation redo log buffer avec le latch 'redo allocation' et y copier l'enregistrement de redo avec le latch 'redo copy'

Si l'on insère 10 lignes, une par une, dans une table qui a 4 indexes, alors on va générer 50 redo records et 50 undo records, et faire appel 50 fois au latches de redo: 5 redo record par ligne (un pour la table et un pour chaque index) pour 10 lignes.

Lorsque la fonctionnalité de journalisation en mémoire (in-memory undo) est activée, et parce que dans cet exemple il s'agit d'une petite transaction, voici ce qu'il se passe:

• A moment où on modifie la première ligne de la table, Oracle alloue dans la shared pool son propre buffer de redo privé (appelé redo strand) et son propre buffer de "undo". En fait, ce buffer de "undo" contient du redo: c'est le redo qui décrit ce qui doit être modifié dans les bloc d'undo.
• Lors de la mise à jour de la table et des index, chaque change vector qui décrit la modification est écrit dans le buffer de redo privé.
• En même temps, les change vector qui décrivent le undo record correspondant sont écrits dans le buffer de "undo" privé.
• Le nombre total de change vectors, et leur contenu sont exactement les mêmes que pour les change vectors traditionnels.
• Au commit, oracle concatène ces 2 buffers pour faire un seul redo record et l'écrit dans le tampon de journalisation normal (redo log buffer)
• En même temps, ces 100 change vectors sont appliqués: 10 sur la table, 10 sur chaque index, et 50 sur les blocs d'undo. Et en dehors de cela, tout ce qui doit se faire lors d'un commit s'applique aussi.
• Le nombre de modification de blocs ("db block changes") reste le même dans tous les cas
• La différence la plus significative dans le volume de redo généré vient de l'entête du redo record qui fait 12 octets. Avec la gestion 'in-memory' de l'undo il n'y qu'un seul redo record, donc un header de 12 octets, alors que la méthode traditionnelle en génère 50, donc 50*12=600 octets.

Il y a de nombreux détails et variations autour de ce qui se passe là. Par exemple au début et à la fin de la transaction, ou lorsque un des deux buffers est plein (puisqu'ils ne font que 64Ko ou 128Ko) mais la description faite ci-dessus couvre les différences essentielles.

Question: Supposons que je démarre l'instance et effectue quelques mises à jour. J'ai donc un buffer privé de redo et un buffer privé de undo, créés en shared pool. Immédiatement après le système se plante et rien n'est encore écrit dans les fichiers de redo ni dans les blocs d'undo. Dans cette situation comment fait Oracle pour récupérer les données d'undo ?

Il y a deux chose que vous devez prendre en compte dans ma description:

• la précision: 'Il y a de nombreux détails et variations'
• la partie qui montre que les modifications faites dans les blocs tables et index est tout à la fin.

Si la session a fait un commit, elle a écrit le redo privé dans le redo thread public, qui doit être écrit sur disque avant que le commit ne soit terminé. Donc il n'y a rien de différent au niveau du recovery.

Maintenant, si la session n'a pas encore fait de commit, alors du point de vue des autres utilisateurs, rien ne s'est encore passé (ils ne sont censés voir que les effets des transactions commitées). Du coup, cela n'a pas d'importance que les redo et undo privés aient disparu.

Mais voici où ca devient plus complexe: Comment les autres sessions voient que vous êtes en train de modifier les mêmes blocs qu'elles, si vous ne les mettez à jour que lorsque vous faites le commit de votre transaction ? Comment Oracle fait pour minimiser le temps que prennent toutes les modifications de blocs qui doivent être faites lors du commit ? J'ai quelques réponses à ces questions, mais elles ne sont ni exactes, ni complètes, alors je ne préfère pas les publier.

Cependant, un point clé de ce mécanisme, c'est le fait qu'il ne s'applique qu'à des petites transactions. Les zones privées ne font que 64Ko ou 128Ko suivant qu'on est en 32 ou 64 bits, et dès que la transaction devient trop grande, Oracle les écrit dans les redo buffer et poursuit avec le mécanisme normal.

Cet article est la traduction d'un article de Greg Rahn publié sur son blog. L'article original en anglais est: The Core Performance Fundamentals Of Oracle Data Warehousing – Set Processing vs Row Processing. Cet article fait partie d'une série sur les principes fondamentaux des datawarehouse, mais s'applique à tous les traitements de type batch.

Durant 6 ans à faire des Proof Of Concept et des Benchmarks sur des datawarehouse pour les clients, il y a un domaine qui s'est toujours montré problématique: les traitements par lots (batch). La plupart du temps, ces batchs prennent la forme de procédures et packages PL/SQL, qui font du chargement de donnée, de la transformation, du traitement, ou quelque chose de similaire.
La raison pour laquelle c'est souvent problématique, c'est que les développeurs y ont codé en dur la lenteur du traitement. Je suis certain que les développeurs ne savaient pas qu'ils faisaient cela, lorsqu'ils ont codé leur PL/SQL, mais en tout cas, c'est ce qui est arrivé.

Alors comment ont-ils codé 'en dur' cette lenteur en PL/SQL ?

» Lire la suite!

Cet article est la traduction d'une réponse de Tom Kyte sur son site AskTom décrivant rapidement les points à considérer lorsqu'on a une table a fort volume transactionnel et forte concurrence (L'article original en anglais se trouve ici).

Question

Que puis-je faire du point de vue du design physique pour maximiser les performances et la concurrence lorsque une table va être la cible de centaines de milliers de select et probablement autour de 80000 insert, autant d'update et delete par heure, de manière transactionnels sur une base OLTP.
Ces débits de insert/update/delete sont juste un exemple. En réalité ils seront beaucoup plus élevés, même si on ne sait pas à quel point ils seront plus élevés car nous sommes toujours en phase de design.

Je suis à la recherche de quelques lignes directrices que je pourrais essayer sur mon application.

Réponse

On pourrait écrire un livre là dessus :) Le mien est 'Expert Oracle Database Architecture' et vous serez surement intéressé par de nombreux chapitres, plus particulièrement ceux sur les types de données, les tables et les index.

• Vous pourriez avoir besoin de partitionner: répartir les inserts sur de nombreux segments, afin d'éviter des contentions sur la partie droite des index (sur les dates ou les séquences par exemple)...
• Vous pourriez avoir besoin d'IOT (tables organisées index), plus lent pour les insert dans la plupart des cas, mais si vous faites des requêtes qui ramènent de nombreuses lignes qui sont arrivées dans la table à des moments différents dans le temps, l'IOT peut permettre de regrouper (cluster) ces lignes afin de rendre plus efficace le fait de les récupérer ensembles.
• Vous pourriez aussi utiliser ASSM (Automatic segment space management) pour améliorer la concurrence, pour éviter de chercher les bonnes valeurs de PCTUSED, FREELISTS et FREELIST GROUP (mais vous devez comprendre ce qu'il y a de différent entre ASSM et MSSM...)
• Vous pourriez chercher à comprendre comment les types de données sont stockés physiquement, réfléchir à PCTFREE, et comment maximiser les performances possibles sur les LOB, si vous les utilisez, etc.

En bref, vous voulez comprendre comment fonctionnent les choses à un certain niveau. Le concepts guide de la documentation Oracle et un bon point de départ. Si vous aimez ma manière d'écrire, vous pouvez commencer aussi par 'Expert Oracle Database Architecture'.

Vous aurez besoin de réfléchir à la concurrence, aux choses comme ASSM, le partitionnement, voire les technique de regroupement de données (clustering): IOT, hash/btree clusters.

Vous aurez besoin de réfléchir sur l'archivage des données dans le temps.

Vous devrez peut-être envisager la nécessité de faire une réorganisation des tables à l'occasion, et donc prévoir le design qui permettra de le faire: à nouveau le partitionnement.

Historiquement, les vues V$ collectent les durées en centisecondes (100ème de secondes).
Cependant, certaines vues utilisent une autre unité:

microsecondes (1000000ème de seconde):

TIME_WAITED_MICRO, WAIT_TIME dans V$SESSION_WAIT, V$SYSTEM_EVENT, V$SESSION_EVENT, V$ACTIVE_SESSION_HISTORY
CPU_TIME, ELAPSED_TIME dans V$SQL, V$SQLAREA
WAIT_TIME dans V$LATCH, V$LATCH_PARENT, V$LATCH_CHILDREN
ACTIVE_TIME dans V$SQL_WORKAREA, V$SQL_WORKAREA_ACTIVE

millisecondes (1000ème de seconde):

CPU_WAIT_TIME dans V$ENQUEUE_STAT

secondes:

CTIME dans V$LOCK

La liste est non exhaustive, et les commentaires sont bienvenus pour la mettre à jour

Ceci est une traduction de d'un post de Jonathan Lewis sur son blog - la quatrième et dernière partie d'une série de quatre sur la fragmentation (original en anglais). Il est conseillé de lire avant: Fragmentation - Introduction, Fragmentation - Disque et Tablespace, Fragmentation - Table

Fragmentation Index

La fragmentation en extents multiples et la fragmentation due à ASSM que j'ai décrit dans la note précédente à propos des tables s'appliquent aussi aux indexes, bien sûr, et nous importe de la même manière, c'est à dire presque jamais. Lorsque les gens parlent de fragmentation d'index, ils pensent en général au problème des blocs avec un faible taux de remplissage (sparsely populated blocks) qui est aussi un phénomène que j'ai décrit à propos de la fragmentation des tables, mais il y a quelques différences entre une table et un index, que nous allons examiner tout de suite.
Il est intéressant de considérer aussi un autre sens possible pour la fragmentation d'un index, que nous allons aussi examiner: c'est l'effet de bord de la division d'un bloc feuille (leaf block splitting) qui fait que des blocs qui sont logiquement à la suite se retrouvent physiquement dispersés.

» Lire la suite!

Ceci est une traduction de d'un post de Jonathan Lewis sur son blog - la troisième partie d'une série de quatre sur la fragmentation (original en anglais). Il est conseillé de lire avant: Fragmentation - Introduction, Fragmentation - Disque et Tablespace

Fragmentation Table

Dans l'introduction nous avons parlé d'un type de fragmentation au niveau table qui, en général, ne pose pas de problème: la fragmentation d'une table en plusieurs extents. Et il y a une chose amusante, c'est que ASSM (Automatic Segment Space Management - la gestion automatique de l'espace libre dans les segments) a introduit une nouvelle forme de fragmentation, mais qui ne pose généralement pas de problème non plus.

» Lire la suite!

Ceci est une traduction de d'un post de Jonathan Lewis sur son blog - la deuxième partie d'une série de quatre sur la fragmentation (original en anglais). Il est conseillé de lire avant: Fragmentation - Introduction

Fragmentation Disque

Les tablespaces sont composés de fichiers, et les fichiers sont stockés sur disque. Il s'agit la plupart du temps de disques logiques (logical volumes) plutôt que de vrais disques directement (real devices).
Lorsqu'on fait une lecture sur un vrai disque, la taille des données qu'on peut lire en une seule opération physique est quelque chose comme 400Ko ou 500Ko. C'est le contenu d'une seule piste sur un seul plateau d'un disque physique. Une lecture plus large continue en passant sur un autre plateau (ce n'est pas un mouvement physique des têtes, mais une commutation 'électronique') , ou bien en passant sur une autre piste (c'est alors un mouvement physique, mouvement latéral de la tête), ou encore en passant sur un autre disque. Passer sur un autre disque, c'est rejoindre une autre file d'attente de disque, et dans ce cas le logiciel du SAN, ou l'équivalent, aura probablement anticipé les disques dont vous aurez besoin et aura lancé en parallèle ces demandes de lectures dans les files d'attentes correspondantes.

» Lire la suite!

Ceci est une traduction d'un post de Jonathan Lewis sur son blog - la première partie d'une série de quatre sur la fragmentation (original en anglais)

Cet article a commencé comme une note brève, jusqu'à ce que je réalise que ça allait être plus important, et que j'en fasse plutôt une série de quatre articles:

• Fragmentation - Introduction
• Fragmentation - Disque et Tablespace
• Fragmentation - Table
• Fragmentation - Index

Introduction

Le mot 'fragmentation' donne l'idée de quelque chose qui est cassé en plusieurs morceaux, mais il a aussi une connotation émotionnelle qui fait penser qu'il y a beaucoup de petits morceaux. Dans le contexte d'une base Oracle, vous devez savoir ce que vous entendez par 'morceau', ainsi que la granularité de ces morceaux, et leur impact possible sur les performances.

» Lire la suite!

Cet article est la traduction d'un article de Tom Kyte sur son blog (L'article original en anglais se trouve ici). Lectures cohérentes et multi-versionnage, par Tom Kyte

Il est conseillé lire préalablement les premières partie:

• Ecritures cohérentes, par Tom Kyte (1ère partie)
• Ecritures cohérentes - observation d'un redémarrage (2ème partie)

La première chose qui vient à l'esprit, c'est que le trigger se déclenche deux fois. On avait une table avec une seule ligne, et un trigger BEFORE FOR EACH ROW qui se déclanche pour chaque ligne. Un a fait un update sur une seule ligne et le trigger s'est déclanché deux fois.

Vous devez penser aux conséquentes de cela. Si vous faites dans votre trigger quoi que ce soit qui ne soit pas transactionnel, vous pouvez avoir un problème assez sérieux.

» Lire la suite!

Cet article est la traduction d'un article de Tom Kyte sur son blog (L'article original en anglais se trouve ici).

Il est conseillé lire préalablement la première partie:

• Ecritures cohérentes, par Tom Kyte (1ère partie)

Voir un redémarrage d'une requête update est plus plus facile qu'on ne pense.
En fait, nous allons même en voir un avec une simple table d'une seule ligne.

» Lire la suite!