Discussion :

[fifafou]

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

[dalfab]

Bonjour,

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

[fifafou]

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
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();
 
    }
}

[dalfab]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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();
}

[fifafou]

Code world.cpp :

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
#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é

[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.

[fifafou]

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
#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

[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.

[fifafou]

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.