Changeset 1269

Timestamp:

May 14, 2008, 12:46:00 AM (16 years ago)

Author:

landauf

Message:

added some control commands to TclThreadManager (status, dump, flush) and changed some small details.
calls to a TclThread are no longer hidden from the main-interpreter. if you want to pass expressions with variables to a thread, put them into {curly braces} - the expression will then be transfered untouched to the sub-interpreter. without braces, the variables will be replaced by the main-interpreter.
the advantage is: you can use a variable to pass the ID of a thread to TclThreadManager, which wasn't possible with the old solution. an example is remote.tcl that creates a thread, saves it's ID in a variable and executes a command on this thread.

oh, and if you didn't understood a word - no problem, this is only important for people using Tcl in Orxonox

Location:

code/branches/console

Files:

• bin/remote.tcl (modified) (1 diff)
• src/core/CommandExecutor.cc (modified) (1 diff)
• src/core/InputBuffer.cc (modified) (1 diff)
• src/core/TclThreadManager.cc (modified) (4 diffs)
• src/core/TclThreadManager.h (modified) (1 diff)

code/branches/console/bin/remote.tcl

@@ -1 @@
-TclThreadManager create
-TclThreadManager execute 1 source telnet_server.tcl
+set telnetserverthreadid [TclThreadManager create]
+TclThreadManager execute $telnetserverthreadid source telnet_server.tcl

code/branches/console/src/core/CommandExecutor.cc

@@ -394 +394 @@
         if (useTcl)
         {
-            std::string temp = getLowercase(removeTrailingWhitespaces(command));
-            if (!(temp.find("tclthread") == 0 || temp.find("tclthreadmanager") == 0))
+//            std::string temp = getLowercase(removeTrailingWhitespaces(command));
+//            if (!(temp.substr(0, 16) == "tclthreadmanager" || temp.substr(0, 10) == "tclexecute" || temp.substr(0, 8) == "tclquery"))
                 return TclBind::eval(command);
         }

code/branches/console/src/core/InputBuffer.cc

@@ -39 +39 @@
     {
         //this->bActivated_ = false;
-        this->allowedChars_ = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZäöüÄÖÜ0123456789 \\\"(){}[]<>.:,;_-+*/=!?|$&%^~";
+        this->allowedChars_ = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZäöüÄÖÜ0123456789 \\\"(){}[]<>.:,;_-+*/=!?|$&%^~#";
         this->keyboard_ = InputManager::getSingleton().getKeyboard();
         this->buffer_ = "";

code/branches/console/src/core/TclThreadManager.cc

@@ -48 +48 @@
 namespace orxonox
 {
-//    ConsoleCommand(TclThreadManager, tclthread, AccessLevel::None, true);
+    ConsoleCommandShortcutGeneric(tclexecute, createExecutor(createFunctor(&TclThreadManager::execute), "tclexecute", AccessLevel::None));
+    ConsoleCommandShortcutGeneric(tclquery,   createExecutor(createFunctor(&TclThreadManager::query),   "tclquery",   AccessLevel::None));
     ConsoleCommand(TclThreadManager, create,    AccessLevel::None, false);
     ConsoleCommand(TclThreadManager, destroy,   AccessLevel::None, false);
     ConsoleCommand(TclThreadManager, execute,   AccessLevel::None, false);
     ConsoleCommand(TclThreadManager, query,     AccessLevel::None, false);
-//    ConsoleCommand(TclThreadManager, status,    AccessLevel::None, false);
-//    ConsoleCommand(TclThreadManager, dump,      AccessLevel::None, false);
+    ConsoleCommand(TclThreadManager, status,    AccessLevel::None, false);
+    ConsoleCommand(TclThreadManager, dump,      AccessLevel::None, false);
+    ConsoleCommand(TclThreadManager, flush,     AccessLevel::None, false);
 
     TclThreadManager* instance = &TclThreadManager::getInstance();
@@ -132 +134 @@
     }
 
-    void TclThreadManager::execute(unsigned int threadID, const std::string& command)
-    {
-        TclThreadManager::getInstance().pushCommandToQueue(threadID, command);
+    void TclThreadManager::execute(unsigned int threadID, const std::string& _command)
+    {
+        std::string command = _command;
+        while (command.size() >= 2 && command[0] == '{' && command[command.size() - 1] == '}')
+            command = command.substr(1, command.size() - 2);
+
+
+        if (threadID == 0)
+            TclThreadManager::getInstance().pushCommandToQueue(command);
+        else
+            TclThreadManager::getInstance().pushCommandToQueue(threadID, command);
     }
 
@@ -140 +150 @@
     {
         return TclThreadManager::getInstance().evalQuery(TclThreadManager::getInstance().orxonoxInterpreterBundle_.id_, threadID, command);
+    }
+
+    void TclThreadManager::status()
+    {
+        COUT(0) << "Thread ID" << '\t' << "Queue size" << '\t' << "State" << std::endl;
+
+        std::string output = "Orxonox";
+        output += "\t\t";
+        {
+            boost::mutex::scoped_lock queue_lock(TclThreadManager::getInstance().orxonoxInterpreterBundle_.queueMutex_);
+            output += getConvertedValue<unsigned int, std::string>(TclThreadManager::getInstance().orxonoxInterpreterBundle_.queue_.size());
+        }
+        output += "\t\t";
+        output += "busy";
+        COUT(0) << output << std::endl;
+
+        boost::mutex::scoped_lock bundles_lock(TclThreadManager::getInstance().bundlesMutex_);
+        for (std::map<unsigned int, TclInterpreterBundle*>::const_iterator it = TclThreadManager::getInstance().interpreterBundles_.begin(); it != TclThreadManager::getInstance().interpreterBundles_.end(); ++it)
+        {
+            std::string output = getConvertedValue<unsigned int, std::string>((*it).first);
+            output += "\t\t";
+            {
+                boost::mutex::scoped_lock queue_lock((*it).second->queueMutex_);
+                output += getConvertedValue<unsigned int, std::string>((*it).second->queue_.size());
+            }
+            output += "\t\t";
+            {
+                boost::mutex::scoped_lock interpreter_lock((*it).second->interpreterMutex_, boost::defer_lock_t());
+                if (interpreter_lock.try_lock())
+                    output += "ready";
+                else
+                    output += "busy";
+            }
+            COUT(0) << output << std::endl;
+        }
+    }
+
+    void TclThreadManager::dump(unsigned int threadID)
+    {
+        TclInterpreterBundle* bundle = 0;
+        if (threadID == 0)
+        {
+            bundle = &TclThreadManager::getInstance().orxonoxInterpreterBundle_;
+            COUT(0) << "Queue dump of Orxonox:" << std::endl;
+        }
+        else
+        {
+            if (bundle = TclThreadManager::getInstance().getInterpreterBundle(threadID))
+            {
+                COUT(0) << "Queue dump of Tcl-thread " << threadID << ":" << std::endl;
+            }
+            else
+                return;
+        }
+
+        boost::mutex::scoped_lock queue_lock(bundle->queueMutex_);
+        unsigned int index = 0;
+        for (std::list<std::string>::const_iterator it = bundle->queue_.begin(); it != bundle->queue_.end(); ++it)
+        {
+            index++;
+            COUT(0) << index << ": " << (*it) << std::endl;
+        }
+    }
+
+    void TclThreadManager::flush(unsigned int threadID)
+    {
+        TclInterpreterBundle* bundle = 0;
+        if (threadID == 0)
+            bundle = &TclThreadManager::getInstance().orxonoxInterpreterBundle_;
+        else
+            if (!(bundle = TclThreadManager::getInstance().getInterpreterBundle(threadID)))
+                return;
+
+        boost::mutex::scoped_lock queue_lock(bundle->queueMutex_);
+        bundle->queue_.clear();
+        if (threadID == 0)
+        {
+            COUT(0) << "Flushed queue of Orxonox Tcl-interpreter." << std::endl;
+        }
+        else
+        {
+            COUT(0) << "Flushed queue of Tcl-interpreter " << threadID << "." << std::endl;
+        }
     }
 
@@ -473 +566 @@
     void tclThread(TclInterpreterBundle* interpreterBundle, std::string command)
     {
+std::cout << "tclthreadm executes " << command << std::endl;
         boost::mutex::scoped_lock interpreter_lock(interpreterBundle->interpreterMutex_);
         try

code/branches/console/src/core/TclThreadManager.h

@@ -76 +76 @@
             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 void tcl_execute(Tcl::object const &args);