Accès a front pour une std queue

Version imprimable

18/01/2020, 20h23
fifafou

Accès a front pour une std queue

Dans mon programme j'utilise un systeme producer–consumer avec une std::queue
Dans le thread je peut faire appel a chunksToLoad.pop(); par exemple mais pas à chunksToLoad.front(); qui fait crash
18/01/2020, 22h18
dalfab

Bonjour,

Il nous faut plus d'info pour pouvoir t'aider.

Code:

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
43
44
45
46
47
48
#include "chunkLoading.h"
#include "iostream"
#include <SFML/Window.hpp>
#include<chunk.h>
using namespace std;
 
ChunkLoading::ChunkLoading()
{
}
 
ChunkLoading::ChunkLoading(World* world)
{
    worldIn=world;
    for(int i=0;i<5;i++)
    for(int j=0;j<1;j++)
    for(int k=0;k<5;k++)
    {
        addChunkToLoad(ivec3(i,j,k));
    }
    thread loadingThread(loadLoop,this);
    loadingThread.detach();
}
 
ChunkLoading::~ChunkLoading()
{
    //dtor
}
void ChunkLoading::loadChunk()
{
    if(!chunksToLoad.empty())
    {
        glm::ivec3 pos=chunksToLoad.front();//crash
        Chunk* p = new Chunk(pos,worldIn);
        worldIn->queueMutex.lock();
        worldIn->sendChunk(p);
        worldIn->queueMutex.unlock();
        chunksToLoad.pop();
    }
}
void ChunkLoading::loadLoop()
{
    while(!chunksToLoad.empty())
    {
        sf::sleep(sf::milliseconds(100));
        loadChunk();
 
    }
}

Il manque encore des infos. D'après ce que je vois. A quoi ça sert un mutex? Ça permet d’empêcher que 2 threads agissent en même temps sur une même ressource. Ta fonction loadChunk() veut protéger l'appel à sendChunk(), c'est possible que ça soit nécessaire, j'ai des doutes (divination sans voir le code). Par contre l'objet chunkToLoad est peut-être utilisé par plusieurs threads (divination sans voir le code), et dans ce cas il faut "protéger" les fonctions qui l'utilisent comme .empty() .front() et .pop(). Du coup, je "protégerais" exactement l'inverse de ce que tu as fait.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 void ChunkLoading::loadChunk() { worldIn->queueMutex.lock(); if ( !chunksToLoad.empty() ) { glm::ivec3 pos = chunksToLoad.front();//crash worldIn->queueMutex.unlock(); Chunk* p = new Chunk( pos, worldIn ); worldIn->sendChunk( p ); worldIn->queueMutex.lock(); chunksToLoad.pop(); } worldIn->queueMutex.unlock(); }

Code:

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 #include "world.h" #include <vector> #include <chunk.h> #include <iostream> using namespace glm; World::World() { ChunkLoading chunkLoader(this); } World::~World() { //dtor } void World::addChunks(){ queueMutex.lock(); while(!chunksLoaded.empty()) { Chunk* p=chunksLoaded.front(); chunksLoaded.pop(); chunkMap[p->Getpos()]=p; p->init(); } queueMutex.unlock(); } std::unordered_map<ivec3,Chunk*>::const_iterator World::getChunk(ivec3 pos){ return chunkMap.find(pos); } void World::sendChunk(Chunk* p){ chunksLoaded.push(p); }
chunksToLoad est une queue remplie au début du programme et destiné a être rempli au fur et a mesure par le thread,donc pas d’accès simultané
tandis que chunksLoaded est une queue de chunks préchargés rempli par le thread(via sendchunk) et consommé par la boucle principale(via addChunks),c'est donc celui là que j'ai protégé

22/01/2020, 02h10
dalfab

Ligne 8, tu crées un ChunkLoading.
Dans le constructeur de ChunkLoading, tu lances un thread qui va utiliser le ChunkLoading.
Mais ligne 9, tu quittes le World::World() donc ton objet chunkLoader de type ChunkLoading disparaît immédiatement.
Quand le thread s’exécute, l'objet ChunkLoading est déjà plus là d'où un plantage quand le thread veut y accéder.

Code:

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
#ifndef World_H
#define World_H
#include <chunk.h>
#include <chunkLoading.h>
#include <unordered_map>
#include <glm/glm.hpp>
#define GLM_ENABLE_EXPERIMENTAL
#include "glm/gtx/hash.hpp"
#include <mutex>
#include <queue>
using namespace glm;
class Chunk;
class ChunkLoading;
class World
{
    public:
        World();
        virtual ~World();
        void addChunks();
        void sendChunk(Chunk* p);
        std::unordered_map<ivec3,Chunk*>::const_iterator getChunk(ivec3 pos);
        std::unordered_map<ivec3,Chunk*>::const_iterator endOfMap(){return chunkMap.end();}
        std::unordered_map<ivec3,Chunk*> chunkMap;
        std::mutex queueMutex;
    private:
        ChunkLoading chunkLoader;
        std::queue<Chunk*> chunksLoaded;
};
 
#endif // World_H

chunkLoader est membre de world donc il ne devrait pas disparaitre

22/01/2020, 14h07
bacelar

En ligne 8, vous déclarez une variable locale et vous l'assignez. Ce n'est pas le champ/membre qui est utilisé.

Faites vous un cadeau, utilisez les listes d'initialisation. ;)
28/01/2020, 18h47
fifafou

Citation:

Envoyé par bacelar

En ligne 8, vous déclarez une variable locale et vous l'assignez. Ce n'est pas le champ/membre qui est utilisé.

Faites vous un cadeau, utilisez les listes d'initialisation. ;)

Effectivement ça résout le problème,merci!
Je vais essayer d'en savoir plus là dessus.