Changeset 3307 for code/trunk/src/core/TclThreadManager.h

Timestamp:

Jul 19, 2009, 2:12:50 AM (16 years ago)

Author:

landauf

Message:

Completely rewrote TclThreadManager. This fixes several bugs from the initial implementation. The main features work fine now, but some tasks are still open (for example destroying a thread or implementing a queue size limit).

I hope this doesn't cause any troubles because I used the TclThreadManager-version from netp6 as a draft for the reimplementation. I've also applied the c-style-cast-fixes from core.

I tested this with boost 1.37, I hope it also works with 1.35 (I haven't seen any remarkable changes in the log). However it won't work with boost 1.34.1 and lower, but this change already happened back in netp6, so please update your dependencies if you're still using an old version (the current release is 1.39 btw).

File:

• code/trunk/src/core/TclThreadManager.h (modified) (2 diffs)

code/trunk/src/core/TclThreadManager.h

@@ -33 +33 @@
 
 #include <cassert>
-#include <list>
 #include <map>
 #include <string>
-#include "core/OrxonoxClass.h"
+
+#include "OrxonoxClass.h"
+
+namespace boost
+{
+    // forward declarations
+    class mutex;
+    class shared_mutex;
+    class condition_variable;
+}
 
 namespace orxonox
 {
-    // Internal struct
-    struct TclInterpreterBundle;
-
     class _CoreExport TclThreadManager : public OrxonoxClass
     {
-        friend class IRC;
         friend class TclBind;
+        friend void tclThread(TclInterpreterBundle* bundle, std::string command);
 
         public:
             TclThreadManager(Tcl::interpreter* interpreter);
-            ~TclThreadManager();
+            virtual ~TclThreadManager();
 
-            static TclThreadManager& getInstance() { assert(singletonRef_s); return *singletonRef_s; }
+            static TclThreadManager& getInstance() { assert(TclThreadManager::singletonPtr_s); return *TclThreadManager::singletonPtr_s; }
 
-            static unsigned int create();
-            static unsigned int createID(unsigned int threadID);
-            static void destroy(unsigned int threadID);
-            static void execute(unsigned int threadID, const std::string& command);
-            static std::string query(unsigned int threadID, const std::string& command);
-            static void status();
-            static void dump(unsigned int threadID);
-            static void flush(unsigned int threadID);
+            static unsigned int      create();
+            static Tcl::interpreter* createWithId(unsigned int id);
+            static void              destroy(unsigned int id);
+            static void              execute(unsigned int target_id, const std::string& command);
+            static std::string       query(unsigned int target_id, const std::string& command);
 
             void error(const std::string& error);
@@ -71 +73 @@
 
         private:
-            TclThreadManager(const TclThreadManager& other);
+            static void tcl_execute(const Tcl::object& args);
+            static void tcl_crossexecute(int target_id, const Tcl::object& args);
+            static std::string tcl_query(int source_id, const Tcl::object& args);
+            static std::string tcl_crossquery(int source_id, int target_id, const Tcl::object& args);
+            static bool tcl_running(int id);
 
-            static void tcl_execute(Tcl::object const &args);
-            static std::string tcl_query(int querierID, Tcl::object const &args);
-            static std::string tcl_crossquery(int querierID, int threadID, Tcl::object const &args);
-            static bool tcl_running(int threadID);
+            void _execute(unsigned int target_id, const std::string& command);
+            std::string _query(unsigned int source_id, unsigned int target_id, const std::string& command, bool bUseCommandExecutor = false);
 
-            Tcl::interpreter* createNewTclInterpreter(const std::string& threadID);
-            Tcl::interpreter* getTclInterpreter(unsigned int threadID);
-            TclInterpreterBundle* getInterpreterBundle(unsigned int threadID);
+            TclInterpreterBundle* getInterpreterBundle(unsigned int id);
             std::string dumpList(const std::list<unsigned int>& list);
 
-            void pushCommandToQueue(const std::string& command);
-            void forceCommandToFrontOfQueue(const std::string& command);
-            std::string popCommandFromQueue();
-            bool queueIsEmpty();
+            std::string eval(TclInterpreterBundle* bundle, const std::string& command);
 
-            void pushCommandToQueue(unsigned int threadID, const std::string& command);
-            std::string popCommandFromQueue(unsigned int threadID);
-            bool queueIsEmpty(unsigned int threadID);
+            static TclThreadManager* singletonPtr_s;                            ///< Singleton pointer
 
-            bool updateQueriersList(TclInterpreterBundle* querier, TclInterpreterBundle* target);
-
-            std::string evalQuery(unsigned int querierID, const std::string& command);
-            std::string evalQuery(unsigned int querierID, unsigned int threadID, const std::string& command);
-
-            unsigned int threadCounter_;
-            TclInterpreterBundle* orxonoxInterpreterBundle_;
-            std::map<unsigned int, TclInterpreterBundle*> interpreterBundles_;
-
-            static TclThreadManager* singletonRef_s;
+            unsigned int numInterpreterBundles_;                                ///< Number of created Tcl-interpreters (only used for auto-numbered interpreters, not affected by @ref createWithId)
+            std::map<unsigned int, TclInterpreterBundle*> interpreterBundles_;  ///< A map containing all Tcl-interpreters
+            boost::shared_mutex* interpreterBundlesMutex_;                      ///< A mutex used to synchronize threads when accessing @ref interpreterBundles_
+            TclThreadList<std::string>* messageQueue_;                          ///< A queue to pass messages from Tcl-threads to the main thread
+            boost::mutex* mainInterpreterMutex_;                                ///< A mutex to synchronize queries to the main interpreter
     };
 
-    _CoreExport void tclThread(TclInterpreterBundle* interpreterBundle, std::string command);
+    _CoreExport void tclThread(TclInterpreterBundle* bundle, std::string command);
 }