boost, la serialization et les threads (encore)

**nemodev** · 03/03/2010, 21h43

Mes salutations distinguées

,

Me revoilà avec un problème concernant boost (boost::archive) et le multithreading. J'obtiens un segfault lorsque j'utilise la serialization, un morceau de code vous sera certainement plus parlant.

Voici la boucle multithreadé:

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
while (1) {
	glfwLockMutex(mutex);
	haveToQuit = mustDie;
	glfwUnlockMutex(mutex);
 
	if (haveToQuit) {
		break;
	}
 
	glfwLockMutex(mutexStats); // un mutex static !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 
	boost::asio::streambuf sendBuff;
	std::ostream send_stream(&sendBuff);
	boost::archive::text_oarchive oTextArchive(send_stream);
 
	pkInfo piS;
	piS.type = pkInfo::PIT_NULL;
	piS.nb = 0;
	oTextArchive << piS;
 
	// Send the request.
	boost::asio::write(sock, sendBuff);
 
	std::ostringstream oss;
 
	// Read the response
	boost::asio::streambuf readBuff;
	boost::asio::read_until(sock, readBuff, "\0");
 
	std::istream read_stream(&readBuff);
	boost::archive::text_iarchive iTextArchive(read_stream);
 
	pkInfo piR;
	try {
		iTextArchive >> piR; // LABEL IARCHIVE !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
	}
	catch (...) {
		log->log (Logger::IMPORTANT, "IAClient::routineDeIAClient", "exception betwen mutex");
	}
 
 
	glfwUnlockMutex(mutexStats); // ET le unlock !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 
 
	fprintf (stdout, "after iArchive:%s\n", tbName.c_str());fflush (stdout);
	glfwSleep(timeToSleep);
}

Pas de backtrace

. Le problème se manifeste le plus souvent sur le label IARCHIVE.

Chez boost, ils disent http://www.boost.org/doc/libs/1_42_0...ulti_threading ...
je suis pas sur d'avoir tout compris

, mais ca ne devrait pas être ca.

However, Writing/Reading different archives simultaneously in different tasks is permitted as each archive instance is (almost) completely independent from any other archive instance.

Je comprend pas trop le "(almost) completely independent".

Lorsque, j'utilise les mutex, ca plante pas. Est ce une preuve que la portion de code entre le lock/unlock n'est pas thread-safe ?

la lib utilisé : -llibboost_serialization-mgw34-mt-d-1_42

Je crois que c'est tout. Merci à tout ceux qui se sont penché sur mon cas.

**Mat007** · 05/03/2010, 14h54

Salut,

Ils sont où les threads ?
Est-ce que sock est partagé entre plusieurs threads ?

MAT.

**nemodev** · 05/03/2010, 15h27

Salut Mat007,

non, il y a un socket par thread. La boucle au dessus s'exécute sur plusieurs threads.

Juste avant la boucle :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
	boost::asio::io_service ioservice;
	boost::asio::ip::tcp::socket sock(ioservice);
 
	try {
		// Connection au serveur d'IA
		boost::asio::ip::tcp::endpoint IAServer (boost::asio::ip::address::from_string(ip), portServ);
 
		sock.connect(IAServer);
 
	}
	catch (std::exception& e) {
		// gestion de l'exception qui n'est pas levée
	}

J'ai du nouveau, le code plante même avec les mutex

. Je comprend plus rien ! Des que je commente la ligne IARCHIVE tout rentre dans l'ordre.

Ca fait 3 jours que j'en suis au meme point.

et la classe serializée. Je fais rien de bien spécial.

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
class pkInfo {
public:
	enum PIT {
		PIT_PEV,
		PIT_PEV_HISTO,
		PIT_NEED_EMERGENCY_ACTION,
		PIT_FATAL_ERROR,
 
		PIT_NULL
	};
	enum PIAType {
		PIAT_NULL
	};
	pkInfo() {};
	virtual ~pkInfo() {};
	PIT type;
	PIAType atype;
	unsigned short nb;
	float ft;
	std::string str;
private:
	friend class boost::serialization::access;
	template<class Archive>
	void serialize(Archive& ar, const unsigned int version){
		ar & type & atype & nb & ft & str;
	}
 
};

et les warning à la compilation, je compile avec un gcc(mingw)3.4.5, je suis donc habitué à ce que gcc me crache pleins de warning avec boost.

C:/Dev/boost_1_42_0/boost/mpl/print.hpp: At global scope:
C:/Dev/boost_1_42_0/boost/mpl/print.hpp: In instantiation of `boost::mpl::print<boost::serialization::BOOST_SERIALIZATION_STATIC_WARNING_LINE<98> >':
C:/Dev/boost_1_42_0/boost/serialization/static_warning.hpp:92: instantiated from `boost::serialization::static_warning_test< false, 98>'
C:/Dev/boost_1_42_0/boost/archive/detail/check.hpp:98: instantiated from `void boost::archive::detail::check_object_tracking() [with T = pkInfo]'
C:/Dev/boost_1_42_0/boost/archive/detail/oserializer.hpp:313: instantiated from `static void boost::archive::detail::save_non_pointer_type<Archive>::invoke(Archive&, T&) [with T = pkInfo, Archive = boost::archive::text_oarchive]'
C:/Dev/boost_1_42_0/boost/archive/detail/oserializer.hpp:525: instantiated from `void boost::archive::save(Archive&, T&) [with Archive = boost::archive::text_oarchive, T = pkInfo]'
C:/Dev/boost_1_42_0/boost/archive/detail/common_oarchive.hpp:69: instantiated from `void boost::archive::detail::common_oarchive<Archive>::save_override(T&, int) [with T = pkInfo, Archive = boost::archive::text_oarchive]'
C:/Dev/boost_1_42_0/boost/archive/basic_text_oarchive.hpp:80: instantiated from `void boost::archive::basic_text_oarchive<Archive>::save_override(T&, int) [with T = pkInfo, Archive = boost::archive::text_oarchive]'
C:/Dev/boost_1_42_0/boost/archive/detail/interface_oarchive.hpp:64: instantiated from `Archive& boost::archive::detail::interface_oarchive<Archive>::operator<<(T&) [with T = pkInfo, Archive = boost::archive::text_oarchive]'
IAClient.cpp:106: instantiated from here
C:/Dev/boost_1_42_0/boost/mpl/print.hpp:55: warning: comparison between signed and unsigned integer expressions
pkInfo.h: In instantiation of `void pkInfo::serialize(Archive&, unsigned int) [with Archive = boost::archive::text_iarchive]':
C:/Dev/boost_1_42_0/boost/serialization/access.hpp:118: instantiated from `static void boost::serialization::access::serialize(Archive&, T&, unsigned int) [with Archive = boost::archive::text_iarchive, T = pkInfo]'
C:/Dev/boost_1_42_0/boost/serialization/serialization.hpp:74: instantiated from `void boost::serialization::serialize(Archive&, T&, unsigned int) [with Archive = boost::archive::text_iarchive, T = pkInfo]'
C:/Dev/boost_1_42_0/boost/serialization/serialization.hpp:133: instantiated from `void boost::serialization::serialize_adl(Archive&, T&, unsigned int) [with Archive = boost::archive::text_iarchive, T = pkInfo]'
C:/Dev/boost_1_42_0/boost/archive/detail/iserializer.hpp:182: instantiated from `void boost::archive::detail::iserializer<Archive, T>::load_object_data(boost::archive::detail::basic_iarchive&, void*, unsigned int) const [with Archive = boost::archive::text_iarchive, T = pkInfo]'
IAClient.cpp:538: instantiated from here
pkInfo.h:46: warning: unused parameter 'version'
pkInfo.h: In instantiation of `void pkInfo::serialize(Archive&, unsigned int) [with Archive = boost::archive::text_oarchive]':
C:/Dev/boost_1_42_0/boost/serialization/access.hpp:118: instantiated from `static void boost::serialization::access::serialize(Archive&, T&, unsigned int) [with Archive = boost::archive::text_oarchive, T = pkInfo]'
C:/Dev/boost_1_42_0/boost/serialization/serialization.hpp:74: instantiated from `void boost::serialization::serialize(Archive&, T&, unsigned int) [with Archive = boost::archive::text_oarchive, T = pkInfo]'
C:/Dev/boost_1_42_0/boost/serialization/serialization.hpp:133: instantiated from `void boost::serialization::serialize_adl(Archive&, T&, unsigned int) [with Archive = boost::archive::text_oarchive, T = pkInfo]'
C:/Dev/boost_1_42_0/boost/archive/detail/oserializer.hpp:148: instantiated from `void boost::archive::detail::oserializer<Archive, T>::save_object_data(boost::archive::detail::basic_oarchive&, const void*) const [with Archive = boost::archive::text_oarchive, T = pkInfo]'
IAClient.cpp:538: instantiated from here
pkInfo.h:46: warning: unused parameter 'version'

**Mat007** · 05/03/2010, 16h15

Envoyé par nemodev

non, il y a un socket par thread. La boucle au dessus s'exécute sur plusieurs threads.

Je ne comprends toujours pas, où sont créés les threads ?
Et à quoi ils servent d'ailleurs ?

Si ce que tu cherches à faire c'est gérer une connexion par thread, c'est sans doute pas une très bonne idée et il vaut mieux utiliser asio de manière asynchrone.
D'ailleurs il y a un exemple qui fait ça de concert avec Boost.Serialization : Serialization.

edit : ah non mais en fait c'est côté client le code là ? tu veux pouvoir envoyer plusieurs 'requêtes' à un serveur en parallèle ? enfin c'est le même principe globalement.

MAT.

**nemodev** · 05/03/2010, 16h39

oui c'est ca, mon client se connecte à plusieurs serveurs. J'ai déjà jeté un œil à l'asynchrone mais ca me parait pas super évident.

Le truc, c'est que ca marche sans les archives, donc ...

Je vais poster la fonction threadé complète si tu veux, mais j'ai du ménage a faire. Imagine ca fait 3 jours que je la retourne dans tout les sens

**nemodev** · 12/03/2010, 15h29

salut,

pour info, j'ai abandonné l'utilisation de la serialization. Pour le peu que je l'utilise, j'y ai perdu pas mal de mon temps. Je me retrouverai peut etre plus tard avec des probleme de portabilité, mais au moins la je maitrise parfaitement mon code

merci a Mat007.

boost, la serialization et les threads (encore)

Boost C++

Discussions similaires

Partager

Partager