Interrogazione di dati in tempo reale da un database SQL improvviso problema di latenza

Question

Stiamo testando un'applicazione che si suppone per visualizzare i dati in tempo reale per più utenti su una base 1 secondo. Nuovi dati di 128 righe viene inserita ciascuno secondo dal applicazione server in un datatbase SQL, allora deve essere interrogato da tutti gli utenti insieme ad altri vecchi referenziale 128 righe.

Abbiamo testato il tempo di query e non ha superato il 30 milliseonds; anche la funzione di interfaccia che richiama la query non ha preso più di 50 millisecondi con l'elaborazione dei dati e tutti

Abbiamo sviluppato un test delle applicazioni che crea un filo e una connessione SQL per ogni utente. L'utente invia 7 query ogni 1 secondo. Tutto comincia bene, e nessun utente richiede più di 300 millisecondi per la serie 7 di dati (query). Tuttavia, dopo 10 minuti, la latenza superiore a 1 secondo e continua ad aumentare. Non sappiamo se il problema è dal server SQL 2008 gestire più richieste allo stesso tempo, e come superare tale problema.

Ecco il nostro cliente di test se può aiutare. Si noti che il client e il server sono realizzati sulla stessa macchina 8 CPU con 8 GB di RAM. Ora stiamo mettendo in discussione se il database potrebbe non essere la soluzione ottimale per noi.

   class Program
{
    static void Main(string[] args)
    {   
        Console.WriteLine("Enter  Number of threads");
        int threads = int.Parse(Console.ReadLine());
        ArrayList l = new ArrayList();
        for (int i = 0; i < threads; i++)
        {
            User u = new User();
            Thread th = new Thread(u.Start);
            th.IsBackground = true;
            th.Start();
            l.Add(u);
            l.Add(th);
        }
        Thread.CurrentThread.Join();
        GC.KeepAlive(l);
    }
}
class User
{
    BusinessServer client ; // the data base interface dll
    public static int usernumber =0 ;

    static TextWriter log;
    public User()
    {
        client = new BusinessServer(); // creates an SQL connection in the constructor
        Interlocked.Increment(ref usernumber);
    }

    public static void SetLog(int processnumber)
    {
        log = TextWriter.Synchronized(new StreamWriter(processnumber + ".txt"));
    }
    public void Start()
    {
        Dictionary<short, symbolStruct> companiesdic = client.getSymbolData();
        short [] symbolids=companiesdic.Keys.ToArray();
        Stopwatch sw = new Stopwatch();
        while (true)
        {

            int current;
            sw.Start();
            current = client.getMaxCurrentBarTime();
            for (int j = 0; j < 7; j++)
            {   
                client.getValueAverage(dataType.mv, symbolids,
                    action.Add, actionType.Buy,
                    calculationType.type1,
                    weightType.freeFloatingShares, null, 10, current, functionBehaviour.difference); // this is the function that has the queries

            }
            sw.Stop();
            Console.WriteLine(DateTime.Now.ToString("hh:mm:ss") + "\t" + sw.ElapsedMilliseconds);
            if (sw.ElapsedMilliseconds > 1000)
            {
                Console.WriteLine("warning");
            }
            sw.Reset();

            long diff = 0;//(1000 - sw.ElapsedMilliseconds);
            long sleep = diff > 0 ? diff : 1000;
            Thread.Sleep((int)sleep);
        }
    }



}

Answer 1

Ho il sospetto query stessa. Anche se non può prendere molto tempo su un database vuoto, come la quantità di dati cresce può richiedere sempre più tempo a seconda di come il look up è fatto. Avete esaminato il piano di query per assicurarsi che si sta facendo le ricerche indice invece di scansioni di tabella per trovare i dati? In caso contrario, forse l'introduzione di alcuni indici aiuterebbero.

Answer 2

. Attenzione: questa risposta si basa sulla conoscenza di MSSQL 2000 - non è sicuro se è ancora corretto

Se si fanno un sacco di inserti, gli indici alla fine uscire la data e il server si passa automaticamente alla scansioni della tabella fino a quando gli indici vengono ricostruiti. Alcune di queste è fatto automaticamente, ma si consiglia di forzare reindexing periodicamente se questo tipo di prestazioni sono critiche.