example/core/threadManager/main.cpp

   1 // ANNA - Anna is Not 'N' Anymore
   2 //
   3 // (c) Copyright 2005-2014 Eduardo Ramos Testillano & Francisco Ruiz Rayo
   4 //
   5 // https://bitbucket.org/testillano/anna
   6 //
   7 // Redistribution and use in source and binary forms, with or without
   8 // modification, are permitted provided that the following conditions
   9 // are met:
  10 //
  11 //     * Redistributions of source code must retain the above copyright
  12 // notice, this list of conditions and the following disclaimer.
  13 //     * Redistributions in binary form must reproduce the above
  14 // copyright notice, this list of conditions and the following disclaimer
  15 // in the documentation and/or other materials provided with the
  16 // distribution.
  17 //     * Neither the name of Google Inc. nor the names of its
  18 // contributors may be used to endorse or promote products derived from
  19 // this software without specific prior written permission.
  20 //
  21 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  22 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  23 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  24 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  25 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  26 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  27 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  28 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  29 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  30 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  31 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  32 //
  33 // Authors: eduardo.ramos.testillano@gmail.com
  34 //          cisco.tierra@gmail.com
  35
  36
  37 #include <iostream>
  38
  39 #include <anna/core/mt/ThreadManager.hpp>
  40 #include <anna/core/util/CommandLine.hpp>
  41 #include <anna/core/mt/Mutex.hpp>
  42 #include <anna/core/tracing/Logger.hpp>
  43 #include <anna/core/mt/Runnable.hpp>
  44 #include <anna/core/mt/Thread.hpp>
  45 #include <anna/core/tracing/TraceWriter.hpp>
  46
  47 using namespace std;
  48 using namespace anna;
  49
  50 class MyRunnable : public Runnable {
  51 public:
  52    MyRunnable () : Runnable () {;}
  53
  54 private:
  55    void initialize () throw (RuntimeException);
  56    void run () throw (RuntimeException);
  57    void terminate () throw ();
  58
  59    anna_complete_runnable (MyRunnable);
  60 };
  61
  62 int main (const int argc, const char** argv)
  63 {
  64    CommandLine& ccll = CommandLine::instantiate ();
  65    ThreadManager* threadManager (NULL);
  66
  67    try {
  68       ccll.add ("maxthr", CommandLine::Argument::Mandatory, "Maximum number of threads");
  69       ccll.add ("mode", CommandLine::Argument::Mandatory, "Manager instance mode");
  70       ccll.add ("nthr", CommandLine::Argument::Mandatory, "Number of threads to create");
  71
  72       ccll.initialize (argv, argc);
  73       ccll.verify ();
  74
  75       Logger::initialize ("thread_manager", new TraceWriter ("file.trace", 2048000));
  76
  77       ThreadManager::Mode::_v mode = ThreadManager::Mode::asEnumEx (ccll.getValue ("mode"));
  78
  79       const int maxThread = ccll.getIntegerValue ("maxthr");
  80       int nthr = max (2, ccll.getIntegerValue ("nthr"));
  81
  82       threadManager = new ThreadManager ("MyManager", mode, maxThread, Thread::Flag::Joinable);
  83       MyRunnable* myRunnable;
  84       Thread* thread;
  85
  86       // Se genrean memory-leaks en los MyRunnable, pero no nos interesa complicar el ejemplo
  87       for (int ii = 0; ii < nthr; ii ++) {
  88          myRunnable = new MyRunnable ();
  89          thread = threadManager->createThread ();
  90          thread->start (*myRunnable);
  91       }
  92
  93       // Espera la terminación de todos los threads asociados al gestor que siguen corriendo
  94       threadManager->join ();
  95
  96       // Crea un thread y espera su terminación
  97       Thread* aux = threadManager->createThread ();
  98       myRunnable = new MyRunnable ();
  99       aux->start (*myRunnable);
 100       aux->join ();
 101    }
 102    catch (RuntimeException& ex) {
 103       cout << ex.asString () << endl << endl;
 104       ex.trace ();
 105    }
 106 }
 107
 108 void MyRunnable::initialize ()
 109    throw (RuntimeException)
 110 {
 111    LOGDEBUG (
 112       string msg (asString ());
 113       msg += " | initialize ...";
 114       Logger::debug (msg, ANNA_FILE_LOCATION);
 115    );
 116 }
 117
 118 void MyRunnable::run ()
 119    throw (RuntimeException)
 120 {
 121    const int delay = rand () % 2000;
 122
 123    LOGDEBUG (
 124       string msg (asString ());
 125       msg += functions::asText (" | Waiting: ", delay);
 126       msg += " ms";
 127       Logger::debug (msg, ANNA_FILE_LOCATION);
 128    );
 129
 130    anna::functions::sleep ((Millisecond)delay);
 131 }
 132
 133 void MyRunnable::terminate ()
 134    throw ()
 135 {
 136    LOGDEBUG (
 137       string msg (asString ());
 138       msg += " | terminate ... ";
 139       Logger::debug (msg, ANNA_FILE_LOCATION);
 140    );
 141 }
 142