Changeset 4483 for source/ariba/utility

Timestamp:

Jun 25, 2009, 11:06:52 AM (15 years ago)

Author:

Christoph Mayer

Message:

-StartupWrapper bisschen umgeschrieben, erste Schritte für sauberes runterfahren

Location:

source/ariba/utility/system

Files:

• StartupWrapper.cpp (modified) (5 diffs)
• StartupWrapper.h (modified) (3 diffs)
• SystemQueue.cpp (modified) (5 diffs)

source/ariba/utility/system/StartupWrapper.cpp

@@ -48 +48 @@
 
 SystemEventType StartupWrapperEventStartup("StartupWrapperEventStartup");
-SystemEventType StartupWrapperEventShutdown("StartupWrapperEventShutdown");
 
 StartupWrapper::StartupWrapper(StartupInterface* _service) : service( _service ){
@@ -73 +72 @@
 #endif
 
-void StartupWrapper::initSystem(){
-
-        static bool initialized = false;
-        if( initialized ) return;
-        initialized = true;
+void StartupWrapper::startSystem(){
 
         //
@@ -121 +116 @@
 }
 
+void StartupWrapper::stopSystem(){
+        SystemQueue::instance().cancel();
+}
+
 void StartupWrapper::initConfig(string filename){
         configurations.push( filename );
@@ -142 +141 @@
 
                 service->startup();
-
-        } else if( event.getType() == StartupWrapperEventShutdown ){
-
-                service->shutdown();
-                SystemQueue::instance().cancel();
 
         }
@@ -174 +168 @@
 
         if(block){
-                SystemEvent ev (service->wrapper, StartupWrapperEventShutdown);
-                service->wrapper->handleSystemEvent(ev);
-
+                // call directly
+                service->shutdown();
         }else{
-                SystemQueue::instance().scheduleEvent(
-                                SystemEvent( service->wrapper, StartupWrapperEventShutdown, NULL), 0 );
+                // call async, but not using systemqueue! // TODO: mem leak
+                AsyncShutdown* async = new AsyncShutdown(service);
+                async->runBlockingMethod();
         }
 }
 
+StartupWrapper::AsyncShutdown::AsyncShutdown(StartupInterface* _service)
+        : service(_service){
+}
+
+void StartupWrapper::AsyncShutdown::blockingFunction(){
+        service->shutdown();
+}
+
+void StartupWrapper::AsyncShutdown::dispatchFunction(){
+        //unused
+}
+
 }} // namespace ariba, utility

source/ariba/utility/system/StartupWrapper.h

@@ -44 +44 @@
 #include "SystemQueue.h"
 #include "StartupInterface.h"
-#include "../configuration/Configuration.h"
+#include "ariba/utility/configuration/Configuration.h"
+#include "BlockingMethod.h"
 
 #ifdef UNDERLAY_OMNET
@@ -69 +70 @@
 class StartupWrapper : public SystemEventListener {
 public:
-        static void initSystem();
+        static void startSystem();
+        static void stopSystem();
+
         static void initConfig(string filename);
         static void startup(StartupInterface* service, bool block = true);
@@ -96 +99 @@
         void waitForExit();
         StartupInterface* service;
+
+        class AsyncShutdown : public BlockingMethod {
+        public:
+                AsyncShutdown(StartupInterface* _service);
+        protected:
+                virtual void dispatchFunction();
+                virtual void blockingFunction(); // unused
+        private:
+                StartupInterface* service;
+        };
+
 };
 

source/ariba/utility/system/SystemQueue.cpp

@@ -130 +130 @@
 
         // cause the thread to exit
-        running = false;
-        itemsAvailable.notify_all();
+        {
+                boost::mutex::scoped_lock lock(queueMutex);
+                running = false;
+
+                while( eventsQueue.size() > 0 ){
+                        eventsQueue.erase( eventsQueue.begin() );
+                }
+
+                itemsAvailable.notify_all();
+        }
 
         // wait that the thread has exited
@@ -139 +147 @@
         delete queueThread;
         queueThread = NULL;
-
-        while( eventsQueue.size() > 0 ){
-                eventsQueue.erase( eventsQueue.begin() );
-        }
 }
 
@@ -151 +155 @@
 
 void SystemQueue::QueueThread::insert( const SystemEvent& event, uint32_t delay ){
-        {
-                boost::mutex::scoped_lock lock( queueMutex );
-
-                eventsQueue.push_back( event );
-                eventsQueue.back().scheduledTime = boost::posix_time::microsec_clock::local_time();
-                eventsQueue.back().delayTime = delay;
-                eventsQueue.back().remainingDelay = delay;
-
-                onItemInserted( event );
-                itemsAvailable.notify_all();
-        }
+
+        // if this is called from a module that is currently handling
+        // a thread (called from SystemQueue::onNextQueueItem), the
+        // thread is the same anyway and the mutex will be already
+        // aquired, otherwise we aquire it now
+
+        boost::mutex::scoped_lock lock( queueMutex );
+
+        eventsQueue.push_back( event );
+        eventsQueue.back().scheduledTime = boost::posix_time::microsec_clock::local_time();
+        eventsQueue.back().delayTime = delay;
+        eventsQueue.back().remainingDelay = delay;
+
+        onItemInserted( event );
+        itemsAvailable.notify_all();
 }
 
@@ -177 +185 @@
                 while ( obj->eventsQueue.empty() && obj->running ){
 
-                        const boost::system_time duration =
-                                        boost::get_system_time() +
-                                        boost::posix_time::milliseconds(40);
+//                      const boost::system_time duration =
+//                                      boost::get_system_time() +
+//                                      boost::posix_time::milliseconds(100);
 
                         obj->itemsAvailable.wait( lock );
@@ -185 +193 @@
                 }
 
+                //
                 // work all the items that are currently in the queue
-
-                while( !obj->eventsQueue.empty() ) {
-
-                        // fetch the first item in the queue and deliver it to the
-                        // queue handler
+                //
+
+                while( !obj->eventsQueue.empty() && obj->running ) {
+
+                        // fetch the first item in the queue
+                        // and deliver it to the queue handler
                         SystemEvent ev = obj->eventsQueue.front();
                         obj->eventsQueue.erase( obj->eventsQueue.begin() );
 
-                        {
-                                // unlock the queue to that an event handler
-                                // can insert new items into the queue
-//                              obj->queueMutex.unlock();
-                                obj->onNextQueueItem( ev );
-//                              obj->queueMutex.lock();
-                        }
+                        // call the queue and this will
+                        // call the actual event handler
+                        obj->onNextQueueItem( ev );
 
                 } // !obj->eventsQueue.empty() )
         } // while (obj->running)
+
+        logging_debug("system queue exited");
 }