Pro * différences de performance C

Question

Je suis en cours d'exécution dans le scénario suivant qui me donne un peu de maux de tête que je ne peux pas trouver une explication exacte pour le comportement que je vois. J'ai déclaré ce qui suit:

struct test_struct
{
    long testv1;
    char testv2[51];
    long testv3;
};

et une table correspondante dans Oracle 10g:

CREATE TABLE test_table
(
    testv1 NUMBER(10, 0),
    testv2 VARCHAR(50),
    testv3 NUMBER(4, 0)
);

Pour accéder aux données dans ce tableau, j'ai une fonction:

bool getTestData(long test_var1, struct test_struct *outStruct)

et ici je vois les différences que je dois expliquer, mais ne peut pas. Si le corps des regards de fonction comme ceci:

EXEC SQL BEGIN DECLARE SECTION;
    long testvar1_param = test_var1;
    struct test_struct *resStruct = outStruct;
EXEC SQL END DECLARE SECTION;

EXEC SQL SELECT testv1, testv2, testv3
    INTO :resStruct
    FROM test_table
    WHERE testv1 = :testvar1_param;

J'obtiens des performances plus lent que si le corps des regards de fonction comme:

EXEC SQL BEGIN DECLARE SECTION;
    long testvar1_param = test_var1;
    long *testv1_res = &(outStruct->testv1);
    char *testv2_res = outStruct->testv2;
    long *testv3_res = &(outStruct->testv3);
EXEC SQL END DECLARE SECTION;

EXEC SQL SELECT testv1, testv2, testv3
    INTO :testv1_res, :testv2_res, :testv3_res
    FROM test_table
    WHERE testv1 = :testvar1_param;

La performance dans la seconde se différencie par une marge importante.

Quelqu'un sait-il ce qui pourrait expliquer ce comportement?

Answer 1

Pour les problèmes de performances qui semblent inexplicables à première vue. Tour sur le traçage SQL, y compris attente

ALTER SESSION SET TRACEFILE_IDENTIFIER = "some_unique_identifier";
dbms_support.start_trace (binds=>true,waits=>true);

exécuter votre code, assurez-vous qu'il engage et débrancher gracieusement. Ne pas utiliser dbms_support.stop_trace parce qu'il pourrait empêcher la mise en attente des opérations de RowSource. Dans le tracefile vous généré trouverez le texte sql exact tel qu'il est analysé, les événements d'attente qui ont eu une incidence sql et les opérations de RowSource. Les opérations de RowSource montrent comment exactement le plan sql ressemblait pendant l'exécution du sql.

• Vérifiez le nombre de Parsis
• Vérifier les variables de liaison utilisé ou non.
• Vérifiez les opérations de RowSource pour le plan prévu.

Pour votre problème - devoir chercher beaucoup de lignes, un par un de manière aléatoire - je pense trouver

• 1 déclaration du curseur
• 1 Parse
• une boucle qui ouvre / extractions / ferme le curseur

Il est très important pour ces scénarios ne pas parse chaque sélection. L'analyse peut prendre plus de temps que l'exécution.

Une question qui reste est: pourquoi obtenir toutes les lignes une par une? Est-ce une sorte de copie de données opération?

Answer 2

Êtes-vous compte de l'effet de la mise en cache? Je suppose que non.

Si vous exécutez la première requête temporisée, puis exécutez la deuxième requête chronométré, où la valeur de testvar1_param est le même, le second finalise en temps nettement différent. Il ne sera pas question que la requête est lancé en premier, la deuxième version seront avantagées.

En effet, le prédicat où est le même dans les deux requêtes, et les données dans l'ensemble de résultats est le même dans les deux requêtes. Habituellement les requêtes ultérieures requêtes identiques beaucoup plus vite lorsque vous allez à l'encontre d'une requête indexée parce que vous ne vont jamais à la table pour obtenir le ResultSet, il vient de la. EAG où il est mis en mémoire cache

Essayez d'utiliser des valeurs différentes pour testvar1_param et exécuter 10 requêtes de chacun avec des valeurs de parm complètement différentes. Ils seront très très proches dans le temps.

Vous utilisez tkprof droit?

Answer 3

Par moment je veux dire (car il est le développement, non?)

ALTER SYSTEM SET TIMED_STATISTICS = TRUE;

Cela améliore ce oracle vous donne en matière de traçage pour la performance.