Libreria OTL - SQL Server - C ++ - Performance

Question

Ho recentemente iniziato a testare la libreria OTL con il server SQL Server utilizzando il Visual Studio 2013 .I miei test hanno dimostrato che la performance di semplici dichiarazioni di selezione contro una tabella di conteggio di 10000 è il 40% più lento rispetto alla performance di un'applicazione di test simile .NET 4.0 .Tutti i test sono stati eseguiti con tutte le ottimizzazioni accese per entrambe le piattaforme.

Entrambe le app eseguono le seguenti attività: Apri la connessione DB Crea (e riserva spazio) per l'oggetto container. Esegui il comando Seleziona istruzione. Per ogni record fetched da db Crea un'entità utilizzando l'oggetto DB (Stream / Reader) Aggiungi l'oggetto al contenitore Chiudi

.NET C # App richiede 0,5 secondi per completare questa attività, mentre l'app OTL-C ++ richiede 0,7 secondi da completare e mi chiedo Se è possibile ottimizzare l'app C ++ per eseguire più veloce ?

.

Snippet del codice C ++:

#define OTL_ODBC_MSSQL_2008     // Compile OTL 4/ODBC, MS SQL 2008
#define OTL_CPP_11_ON
#define OTL_STL                 // Turn on STL features
#define OTL_ANSI_CPP            // Turn on ANSI C++ typecasts
#define OTL_UNICODE             // Enable Unicode OTL for ODBC
#include "otlv4.h"    
 class Employee

{
private:
    int employeeId;
    wstring regno;
    wstring name;
    wstring surname;

public:
    Employee()
    {
    }

    Employee(otl_stream& stream)
    {
        unsigned short _regno[32];
        unsigned short _name[32];
        unsigned short _surname[32];

        if (!stream.is_null())
        {
            stream >> employeeId;
        }

        if (!stream.is_null())
        {
            stream >> (unsigned char*)_regno;
            regno = (wchar_t*)_regno;
        }

        if (!stream.is_null()){
            stream >> (unsigned char*)_name;
            name = (wchar_t*)_name;
        }


        if (!stream.is_null()){
            stream >> (unsigned char*)_surname;
            surname = (wchar_t*)_surname;
        }
    }

    int GetEmployeeId() const
    {
        return employeeId;
    }
};



otl_connect db;
int main()
{
    otl_connect::otl_initialize();
    try
    {
otl_connect::otl_initialize();
    try
    {
        // connect
        db.rlogon("DSN=SQLODBC");

        // start timing
        clock_t begin = clock();
        otl_stream i(10000, "SELECT Id, Field1, Field2, Field3 FROM Test", db);

        // create container
        vector<Employee> employeeList;
        employeeList.reserve(10000);

        // iterate and fill container
        while (!i.eof())
        {
            Employee employee(i);
            employeeList.push_back(employee);
        }
        i.close();

        // cleanup
        size_t size = employeeList.size();  
        clock_t end = clock();
        double elapsed_secs = double(end - begin) / CLOCKS_PER_SEC;
        cout << "Total records:" << size << endl;
        cout << "Time elapsed to read all records:" << elapsed_secs << endl;



    }

    catch (otl_exception& p){ // intercept OTL exceptions
        cerr << p.msg << endl; // print out error message
        cerr << p.stm_text << endl; // print out SQL that caused the error
        cerr << p.sqlstate << endl; // print out SQLSTATE message
        cerr << p.var_info << endl; // print out the variable that caused the error
    }

    db.logoff();
return EXIT_SUCCESS;
}

.

Answer 1

Non penso così, quando si guarda la fonte di codice di OTL, usa ODBC API per SQL Server ed è ottimizzato solo come livello superiore ODBC.SQL Server .NET 4.0 utilizzerà l'API del driver SQL anziché API ODBC per la performance Motivo.

Anche se non si prepara il consumo della memoria, si allenterà sempre a .NET e Java a causa della chiamata della funzione Sysallocmem.È come cercare di misurare 4000 chiamate a SysAlloc vs 1 chiama a Sysalloc.Il problema delle prestazioni è direttamente collegato a tali funzioni.