Bonjour à tous,

Je viens à votre rencontre en espérant que vous puissiez m'aider face à un problème de vitesse. Pour comprendre mon problème, il m'est important de vous expliquer simplement le contexte (sans lequel il sera difficile de me comprendre).

J'ai mis en place un sniffer (capture de paquets) sur Qt (c++) qui a pour but de capturer environ 10000 paquets par seconde. Ces paquets sont mis dans une mémoire partagée accessible par un autre thread qui va permettre de décoder les paquets pour extraire ce que j'appelle des "cellules vidéos" (environ 1000 par paquet). Chaque cellule vidéo contient 4 données, que je dois transmettre à un autre thread afin de faire un traitement "pré-affichage". Je transmets donc par paquet, 4données * 1000 cellules à mon thread pré-affichage.

Là est mon problème, dans ce thread pré-affichage, je dois calculer pour chaque cellules, 4 points (ce qui fait donc 8 coordonnées x,y), ainsi qu'une autre variable que l'on nommera Level. Toutes ses informations nouvellement calculées, sont envoyées à ma classe MyOpenGLWidget, dans une méthode updateVertices, qui va copier coller ma liste contenant toutes les coordonnées dans un VBO afin de réaliser un simple affichage plus tard.

Le problème est que je dois capturer toutes les 1 secondes, environ 10 000 paquets (contenant chacun mes 1000 cellules), et que actuellement, la mise en place des coordonnées dans ma VBO est trop lente. Je copie toutes mes données seulement toutes les 5 secondes, alors que dans l'idéal, il faudrait que toutes les 2 secondes, mes données se retrouvent dans la VBO.

Avez-vous des suggestions ? Je peux vous fournir le code si nécessaire.
j'ai entendu parler des shaders, et fragment shaders, je me demandais même s'il n'était pas possible de mettre dans le VBO uniquement 1 point (donc 2 coordonnées) par cellule vidéo, afin de réaliser un shader qui calculera les 3 autres points de chaque cellule.


Je vous remercie,
si vous avez d'autres questions, n'hésitez pas

Méthode dans laquelle je copie mes données dans le VBO
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
void MyOpenGLWidget::updateVertices(const std::vector<double>& vertices)
{       //Lecture du VBO + maj de ses données avec celles de allRadarCells
        tempVertices.insert(tempVertices.end(), vertices.begin(), vertices.end());
        if (tempVertices.size() >= 4096*2240*9)
        {
            glBindBuffer(GL_ARRAY_BUFFER, VBO);
            glBufferData(GL_ARRAY_BUFFER, tempVertices.size()*sizeof(double), tempVertices.data(), GL_DYNAMIC_DRAW);
            tempVertices.clear();
        }
}
Thread dans lequel je calcule les 8 coordonnées, que j'envoie vers ma méthode qui mettra les données dans le VBO :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
void vertexConversion::run()
{
    while(!stopFlag)
    {
        QMutexLocker locker(&mutexvertex);
        while(radarCells.isEmpty()) {
            conditionvertex.wait(&mutexvertex);
        }
        auto cells = radarCells;
        radarCells.clear();
        locker.unlock();
        std::vector<double> vertices;
        for (const auto& cell : cells)
        {
            //qDebug()<<"Az_start:"<<cell.azimuth_start<<" Az_end:"<<cell.azimuth_end<<" Distance:"<<cell.distance;
            /*Conversion des coordonnées*/
            double X1_start = 640+((cell.distance)*cos(cell.azimuth_start))*64.0/550.0;
            double Y1_start = 300-((cell.distance)*sin(cell.azimuth_start))*64.0/550.0;
            double X2_start = 640+((cell.distance+2.5)*cos(cell.azimuth_start))*64.0/550.0;
            double Y2_start = 300-((cell.distance+2.5)*sin(cell.azimuth_start))*64.0/550.0;
 
            double X1_end = 640+((cell.distance)*cos(cell.azimuth_end))*64.0/550.0;
            double Y1_end = 300-((cell.distance)*sin(cell.azimuth_end))*64.0/550.0;
            double X2_end = 640+((cell.distance+2.5)*cos(cell.azimuth_end))*64.0/550.0;
            double Y2_end = 300-((cell.distance+2.5)*sin(cell.azimuth_end))*64.0/550.0;
 
            vertices.push_back(X1_start);
            vertices.push_back(Y1_start);
            vertices.push_back(X2_start);
            vertices.push_back(Y2_start);
 
            vertices.push_back(X1_end);
            vertices.push_back(Y1_end);
            vertices.push_back(X2_end);
            vertices.push_back(Y2_end);
 
            vertices.push_back(cell.signalLevel);
        }
 
        emit verticesReady(vertices);
    }
}