Riduzione del carico della CPU su una selezione remota da un database

Question

Sono in remoto selezionando i risultati da un database di produzione personalizzato con un criterio di circa tre minuti da un'applicazione C#.

Ogni volta che viene eseguito il comando di selezione, il PC server che sto utilizzando CPU sale fino a circa il 50%. Ma sicuramente, il carico dovrebbe essere sul database a cui mi sto connettendo?

Perché l'applicazione C# razzo al 50% finché i dati non vengono recuperati per la lettura?

Alcuni retroscena

• ho lavorato fuori dalla debug che l'istruzione Select sul database remoto dura circa 30-40 secondi, tenendo in mente che sto selezionando con un criterio che utilizza la colonna indicizzata .
• Allo stesso tempo della selezione dei dati dal DB remoto, ho monitorato il TaskManager e la CPU si è posizionata al 50% fino a quando la selezione è completa .. questo può durare circa 30-40 secondi per ogni ciclo.
• Se si seleziona nel motore sql nativo per il DB remoto, non vi è alcun ritardo nella selezione, i dati (se presenti) vengono restituiti immediatamente.
• So che non è l'analisi del set di risultati che sta prendendo il carico della CPU in quanto alcune selezioni non restituiranno nulla.

Ecco un codice che sto usando.

OdbcConnection remoteConn = new OdbcConnection(ConfigurationManager.ConnectionStrings["remoteConnectionString"].ToString()); 

      remoteConn.Open(); 

      OdbcCommand remoteCommand = new OdbcCommand(); 
      remoteCommand.Connection = remoteConn; 

      using (remoteConn) 
      { 
       string localSql = ""; 
       string remoteSql = "select * from tracking where last_update > 212316247440000000"; // Julian No = 2015-07-12 11:24:00 

       remoteCommand.CommandText = remoteSql; 

       OdbcDataReader remoteReader; 

       remoteReader = remoteCommand.ExecuteReader(); 

       while (remoteReader.Read()) 
       { 


        for (int i = 0; i < 68; i++) 
        { 
         localSql += ",'" + remoteReader[i].ToString() + "'"; 
        } 

       } 

      } 

Ho eseguito un test di prestazioni e diagnostica sull'applicazione e ha prodotto questo risultato.

Come, se del caso, posso ridurre questo carico della CPU o addirittura eliminare completamente. È completamente fuori dall'ordinario e non ho idea di come procedere.

Grazie

Answer 1

Grazie per l'informazione, Dan. Ecco i miei pensieri ...

Credo che il motivo principale per cui la tua app stia consumando tanta CPU è a causa dei driver che stai utilizzando.

Dato che ci si sta collegando a un database SQL Server, è necessario utilizzare i driver SQL Server che sanno come ottimizzare il trasporto dei dati tra client e server.

Per utilizzare i driver appropriati, assicurarsi di utilizzare il SqlConnection, SqlCommand, ecc

Questo permetterà a SQL Server di flusso i risultati al vostro cliente mentre si esegue una query il lettore di dati.

In secondo luogo, non utilizzare il metodo ExecuteReader() sull'oggetto DbCommand.Una delle tante meravigliose funzionalità esclusive dei driver SQL Server è il metodo ExecuteReaderAsync().

Poiché questo comando è un'operazione legata all'IO (non legata al calcolo), non è necessario bloccare il thread chiamante. Quando il risultato ritorna arriveranno su un thread di completamento IO.

Ecco un esempio di codice di come potrebbe essere il tuo codice dopo la modifica.

using (var remoteConn = new SqlConnection(ConfigurationManager.ConnectionStrings["remoteConnectionString"].ToString())) 
{ 
    remoteConn.Open(); 
    using (var remoteCommand = new SqlCommand()) 
    { 
     remoteCommand.Connection = remoteConn; 
     string localSql = ""; 
     string remoteSql = "select * from tracking where last_update > 212316247440000000"; // Julian No = 2015-07-12 11:24:00 

     remoteCommand.CommandText = remoteSql; 
     var remoteReader = await remoteCommand.ExecuteReaderAsync(); 
     while (remoteReader.Read()) 
     { 
      for (int i = 0; i < 68; i++) 
      { 
       localSql += ",'" + remoteReader[i].ToString() + "'"; 
      } 
     } 
    } 
} 

Answer 2

Potrebbe essere l'analisi del risultato? Stai usando una sorta di datalayer che analizza automaticamente i set di risultati in oggetti di dominio? Potrebbe essere molto intenso per la CPU ..

Answer 3

Io parto dal presupposto che il comando di selezione viene eseguito da un computer separato da quello che ospita il DB SQL.

Francamente è un po 'sconcertante. L'unica cosa che mi viene in mente è che potrebbe passare del tempo e elaborare i metadati. Hai provato a cambiare la tua query per tornare a dire solo un pezzo di dati?

Ad esempio:

select top 1 last_update from tracking where last_update > 212316247440000000 
select count (*) from tracking where last_update > 212316247440000000 

Questo chiarirà se i dati + metadati è la causa del problema.

Answer 4

Il modo migliore per le vostre operazioni IO Bound sta usando il Task, siccome non ha bisogno di cambiare il codice esistente:

var task = Task.Factory.StartNew(() => { 
    //your code or @Randy code with little change here: 
    using (var remoteConn = new SqlConnection(ConfigurationManager.ConnectionStrings["remoteConnectionString"].ToString())) 
    { 
     remoteConn.Open(); 
     using (var remoteCommand = new SqlCommand()) 
     { 
      remoteCommand.Connection = remoteConn; 
      string localSql = ""; 
      string remoteSql = "select * from tracking where last_update > 212316247440000000"; // Julian No = 2015-07-12 11:24:00 

      remoteCommand.CommandText = remoteSql; 
      var remoteReader = remoteCommand.ExecuteReader(); 
      while (remoteReader.Read()) 
      { 
       for (int i = 0; i < 68; i++) 
       { 
        localSql += ",'" + remoteReader[i].ToString() + "'"; 
       } 
      } 
     } 
    } 
}); 
//use can use 'task.wait();' to waiting for complete the task.