Consultando dados em tempo real a partir de um banco de dados SQL problema repentino latência

Question

Estamos testando um aplicativo que é suposto para exibir dados em tempo real para vários usuários em uma segunda base 1. Novos dados de 128 linhas é inserido cada um segundo pelo aplicativo de servidor em um datatbase SQL, então ele tem de ser consultado por todos os usuários, juntamente com outros antigos referenciais 128 linhas.

Nós testamos o tempo de consulta e não exceder 30 milliseonds; também a função de interface que invoca a consulta não demorou mais de 50 milissegundos com o processamento de dados e todos

Foi desenvolvido um aplicativo de teste que cria um segmento e uma conexão SQL por cada usuário. Os problemas do usuário 7 consulta cada 1 segundo. Tudo começa bem, e nenhum usuário tem mais de 300 milissegundos para as 7 séries de dados (consultas). No entanto, após 10 minutos, a latência é superior a 1 segundo e continua a aumentar. Não sabemos se o problema é do servidor SQL Server 2008 lidar com várias solicitações ao mesmo tempo, e como superar tal problema.

Aqui está o nosso cliente teste se ele poderia ajudar. Note-se que o cliente eo servidor são feitas na mesma máquina 8 CPU com 8 GB de RAM. Agora estamos questionando se o banco de dados pode não ser a solução ideal para nós.

   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

Eu suspeito que a consulta em si. Enquanto ele não pode demorar muito tempo em um banco de dados vazio, como a quantidade de dados cresce, ela pode exigir mais e mais tempo dependendo de como o olhar para cima é feito. de ter examinado o plano de consulta para se certificar de que está fazendo pesquisas de índice em vez de varrer a tabela para encontrar os dados? Se não, talvez introduzindo alguns índices ajudaria.

Answer 2

Atenção:. Esta resposta é baseada no conhecimento de MSSQL 2000 - não tenho certeza se ele ainda está correto

Se você faz um monte de inserções, os índices acabará por sair da data e o servidor passará automaticamente para varreduras de tabela até que os índices são reconstruídos. Alguns dos isto é feito automaticamente, mas você pode querer forçar a reindexação periodicamente se este tipo de desempenho é fundamental.