Style for PEO

git-svn-id: svn://scm.gforge.inria.fr/svnroot/paradiseo@906 331e1502-861f-0410-8da2-ba01fb791d7f

trunk/paradiseo-peo/src/core/communicable.cpp

@@ -47,7 +47,8 @@ static std :: map <const Communicable *, unsigned> comm_to_key; /* Map of regist
 unsigned Communicable :: num_comm = 0;
 
 
-Communicable :: Communicable () {
+Communicable :: Communicable ()
+{
 
   comm_to_key [this] = key = ++ num_comm;
   key_to_comm.push_back (this);
@@ -55,46 +56,54 @@ Communicable :: Communicable () {
   sem_init (& sem_stop, 0, 0);
 }
 
-Communicable :: ~ Communicable () {
+Communicable :: ~ Communicable ()
-
+{
 }
 
-COMM_ID Communicable :: getKey () {
+COMM_ID Communicable :: getKey ()
+{
 
   return key;
 }
 
-Communicable * getCommunicable (COMM_ID __key) {
+Communicable * getCommunicable (COMM_ID __key)
+{
 
   assert (__key < key_to_comm.size ());
   return key_to_comm [__key];
 }
 
-COMM_ID getKey (const Communicable * __comm) {
+COMM_ID getKey (const Communicable * __comm)
+{
 
   return comm_to_key [__comm];
 }
 
-void Communicable :: lock () {
+void Communicable :: lock ()
+  {
 
     sem_wait (& sem_lock);
   }
 
-void Communicable :: unlock () {
+void Communicable :: unlock ()
+{
 
   sem_post (& sem_lock);
 }
 
-void Communicable :: stop () {
+void Communicable :: stop ()
+{
   sem_wait (& sem_stop);
 }
 
-void Communicable :: resume () {
+void Communicable :: resume ()
+{
 
   sem_post (& sem_stop);
 }
 
-void initCommunicableEnv () {
+void initCommunicableEnv ()
+{
 
   key_to_comm.resize (1);
   comm_to_key.clear ();

trunk/paradiseo-peo/src/core/communicable.h

@@ -42,7 +42,8 @@
 
 typedef unsigned COMM_ID;
 
-class Communicable {
+class Communicable
+  {
 
   public :
 

trunk/paradiseo-peo/src/core/cooperative.h

@@ -43,7 +43,8 @@
 
 typedef unsigned COOP_ID;
 
-class Cooperative : public Communicable {
+class Cooperative : public Communicable
+  {
 
   public :
 

trunk/paradiseo-peo/src/core/eoPop_mesg.h

@@ -42,14 +42,16 @@
 #include "messaging.h"
 
 
-template <class EOT> void pack (const eoPop <EOT> & __pop) {
+template <class EOT> void pack (const eoPop <EOT> & __pop)
+{
 
   pack ((unsigned) __pop.size ());
   for (unsigned i = 0; i < __pop.size (); i ++)
     pack (__pop [i]);
 }
 
-template <class EOT> void unpack (eoPop <EOT> & __pop) {
+template <class EOT> void unpack (eoPop <EOT> & __pop)
+{
 
   unsigned n;
 

trunk/paradiseo-peo/src/core/eoVector_mesg.h

@@ -43,12 +43,15 @@
 #include "messaging.h"
 
 
-template <class F, class T> void pack (const eoVector <F, T> & __v) {
+template <class F, class T> void pack (const eoVector <F, T> & __v)
+{
 
-  if (__v.invalid()) {
+  if (__v.invalid())
+    {
       pack((unsigned)0);
     }
-  else {
+  else
+    {
       pack((unsigned)1);
       pack (__v.fitness ());
     }
@@ -59,14 +62,18 @@ template <class F, class T> void pack (const eoVector <F, T> & __v) {
     pack (__v [i]);
 }
 
-template <class F, class T> void unpack (eoVector <F, T> & __v) {
+template <class F, class T> void unpack (eoVector <F, T> & __v)
+{
 
-  unsigned valid; unpack(valid);
+  unsigned valid;
+  unpack(valid);
 
-  if (! valid) {
+  if (! valid)
+    {
       __v.invalidate();
     }
-  else {
+  else
+    {
       F fit;
       unpack (fit);
       __v.fitness (fit);
@@ -79,12 +86,15 @@ template <class F, class T> void unpack (eoVector <F, T> & __v) {
     unpack (__v [i]);
 }
 
-template <class F, class T, class V> void pack (const eoVectorParticle <F, T, V> & __v) {
+template <class F, class T, class V> void pack (const eoVectorParticle <F, T, V> & __v)
+{
 
-  if (__v.invalid()) {
+  if (__v.invalid())
+    {
       pack((unsigned)0);
     }
-  else {
+  else
+    {
       pack((unsigned)1);
       pack (__v.fitness ());
       pack (__v.best());
@@ -100,14 +110,18 @@ template <class F, class T, class V> void pack (const eoVectorParticle <F, T, V>
     pack (__v.velocities[i]);
 }
 
-template <class F, class T, class V> void unpack (eoVectorParticle <F, T, V> & __v) {
+template <class F, class T, class V> void unpack (eoVectorParticle <F, T, V> & __v)
+{
 
-unsigned valid; unpack(valid);
+  unsigned valid;
+  unpack(valid);
 
-  if (! valid) {
+  if (! valid)
+    {
       __v.invalidate();
     }
-  else {
+  else
+    {
       F fit;
       unpack (fit);
       __v.fitness (fit);

trunk/paradiseo-peo/src/core/messaging.h

@@ -75,13 +75,15 @@ extern void pack (const char * __str);
 extern void pack (const std::string & __str);
 
 /* Pointer */
-template <class T> void pack (const T * __ptr) {
+template <class T> void pack (const T * __ptr)
+{
 
   pack ((unsigned long) __ptr);
 }
 
 /* Pair */
-template <class U, class V> void pack (const std :: pair <U, V> & __pair) {
+template <class U, class V> void pack (const std :: pair <U, V> & __pair)
+{
 
   pack (__pair.first);
   pack (__pair.second);
@@ -124,7 +126,8 @@ extern void unpack (char * __str);
 extern void unpack (std::string & __str);
 
 /* Pointer */
-template <class T> void unpack (T * & __ptr) {
+template <class T> void unpack (T * & __ptr)
+{
 
   unsigned long p;
   unpack (p);
@@ -132,7 +135,8 @@ template <class T> void unpack (T * & __ptr) {
 }
 
 /* Pair */
-template <class U, class V> void unpack (std :: pair <U, V> & __pair) {
+template <class U, class V> void unpack (std :: pair <U, V> & __pair)
+{
 
   unpack (__pair.first);
   unpack (__pair.second);

trunk/paradiseo-peo/src/core/peo_debug.cpp

@@ -58,7 +58,8 @@ static char host [MAX_BUFF_SIZE];
 std :: vector <FILE *> files;
 
 
-void setDebugMode (bool __dbg) {
+void setDebugMode (bool __dbg)
+{
 
   debug = __dbg;
   gethostname (host, MAX_BUFF_SIZE);
@@ -66,7 +67,8 @@ void setDebugMode (bool __dbg) {
 
 extern int getNodeRank ();
 
-void initDebugging () {
+void initDebugging ()
+{
 
   mkdir (DEBUG_PATH, S_IRWXU);
   //  files.push_back (stdout);
@@ -75,7 +77,8 @@ void initDebugging () {
   files.push_back (fopen (buff, "w"));
 }
 
-void endDebugging () {
+void endDebugging ()
+{
 
   for (unsigned i = 0; i < files.size (); i ++)
     if (files [i] != stdout)
@@ -83,9 +86,11 @@ void endDebugging () {
   files.clear();
 }
 
-void printDebugMessage (const char * __mess) {
+void printDebugMessage (const char * __mess)
+{
 
-  if (debug) {
+  if (debug)
+    {
 
       char buff [MAX_BUFF_SIZE];
       char localTime [MAX_BUFF_SIZE];
@@ -102,7 +107,8 @@ void printDebugMessage (const char * __mess) {
       /* Message */
       sprintf (buff, "%s", __mess);
 
-    for (unsigned i = 0; i < files.size (); i ++) {
+      for (unsigned i = 0; i < files.size (); i ++)
+        {
           fputs (buff, files [i]);
           fputs ("\n", files [i]);
           fflush (files [i]);

trunk/paradiseo-peo/src/core/peo_fin.cpp

@@ -39,7 +39,8 @@
 #include "runner.h"
 #include "rmc.h"
 
-void peo :: finalize () {
+void peo :: finalize ()
+{
 
   printDebugMessage ("waiting for the termination of all threads");
 

trunk/paradiseo-peo/src/core/peo_fin.h

@@ -37,7 +37,8 @@
 #ifndef __peo_finalize_h
 #define __peo_finalize_h
 
-namespace peo {
+namespace peo
+  {
 
   extern void finalize ();
 }

trunk/paradiseo-peo/src/core/peo_init.cpp

@@ -57,7 +57,8 @@ extern void initScheduler ();
 extern void initSynchron ();
 
 
-static void initExecutionEnv() {
+static void initExecutionEnv()
+{
 
   initCommunicableEnv ();
   initBuffers ();
@@ -72,13 +73,15 @@ static void initExecutionEnv() {
 }
 
 
-namespace peo {
+namespace peo
+  {
 
   int * argc;
 
   char * * * argv;
 
-  void init (int & __argc, char * * & __argv) {
+  void init (int & __argc, char * * & __argv)
+  {
 
     argc = & __argc;
 

trunk/paradiseo-peo/src/core/peo_init.h

@@ -37,7 +37,8 @@
 #ifndef __peo_init_h
 #define __peo_init_h
 
-namespace peo {
+namespace peo
+  {
 
   extern int * argc;
 

trunk/paradiseo-peo/src/core/peo_param.cpp

@@ -40,7 +40,8 @@
 #include "peo_debug.h"
 
 
-void peo :: loadParameters (int & __argc, char * * & __argv) {
+void peo :: loadParameters (int & __argc, char * * & __argv)
+{
 
   eoParser parser (__argc, __argv);
 

trunk/paradiseo-peo/src/core/peo_param.h

@@ -37,7 +37,8 @@
 #ifndef __peo_param_h
 #define __peo_param_h
 
-namespace peo {
+namespace peo
+  {
 
   extern void loadParameters (int & __argc, char * * & __argv);
 }

trunk/paradiseo-peo/src/core/peo_run.cpp

@@ -39,7 +39,8 @@
 #include "runner.h"
 
 
-void peo :: run () {
+void peo :: run ()
+{
 
   startRunners ();
 

trunk/paradiseo-peo/src/core/peo_run.h

@@ -37,7 +37,8 @@
 #ifndef __peo_run_h
 #define __peo_run_h
 
-namespace peo {
+namespace peo
+  {
 
   extern void run ();
 }

trunk/paradiseo-peo/src/core/reac_thread.cpp

@@ -41,29 +41,34 @@ static bool the_end = false;
 static std :: vector <ReactiveThread *> reac_threads;
 
 
-ReactiveThread :: ReactiveThread () {
+ReactiveThread :: ReactiveThread ()
+{
 
   reac_threads.push_back (this);
   sem_init (& sem, 0, 0);
 }
 
-void ReactiveThread :: sleep () {
+void ReactiveThread :: sleep ()
+{
 
   sem_wait (& sem);
 }
 
-void ReactiveThread :: wakeUp () {
+void ReactiveThread :: wakeUp ()
+{
 
   sem_post (& sem);
 }
 
-void initReactiveThreadsEnv () {
+void initReactiveThreadsEnv ()
+{
 
   the_end = false;
   reac_threads.clear ();
 }
 
-void stopReactiveThreads () {
+void stopReactiveThreads ()
+{
 
   the_end = true;
   for (unsigned i = 0; i < reac_threads.size (); i ++)
@@ -71,4 +76,7 @@ void stopReactiveThreads () {
   reac_threads.clear ();
 }
 
-bool theEnd () { return the_end; }
+bool theEnd ()
+{
+  return the_end;
+}

trunk/paradiseo-peo/src/core/reac_thread.h

@@ -42,7 +42,8 @@
 #include "thread.h"
 
 
-class ReactiveThread : public Thread {
+class ReactiveThread : public Thread
+  {
 
   public:
 

trunk/paradiseo-peo/src/core/ring_topo.cpp

@@ -38,14 +38,16 @@
 
 void RingTopology :: setNeighbors (Cooperative * __mig,
                                    std :: vector <Cooperative *> & __from,
-				   std :: vector <Cooperative *> & __to) {
+                                   std :: vector <Cooperative *> & __to)
+{
   __from.clear () ;
   __to.clear () ;
 
   int len = mig.size () ;
 
   for (int i = 0 ; i < len ; i ++)
-      if (mig [i] == __mig) {	
+    if (mig [i] == __mig)
+      {
         __from.push_back (mig [(i - 1 + len) % len]) ;
         __to.push_back (mig [(i + 1) % len]) ;
         break;

trunk/paradiseo-peo/src/core/ring_topo.h

@@ -39,7 +39,8 @@
 
 #include "topology.h"
 
-class RingTopology : public Topology {
+class RingTopology : public Topology
+  {
 
   public :
 

trunk/paradiseo-peo/src/core/runner.cpp

@@ -66,7 +66,8 @@ extern int getNumberOfNodes ();
 extern void wakeUpCommunicator ();
 
 
-Runner :: Runner () {
+Runner :: Runner ()
+{
 
   exec_id = 0;
   def_id = ++ num_def_runners;
@@ -77,32 +78,38 @@ Runner :: Runner () {
   sem_init (& sem_cntxt, 0, 0);
 }
 
-RUNNER_ID Runner :: getDefinitionID () {
+RUNNER_ID Runner :: getDefinitionID ()
+{
 
   return def_id;
 }
 
-RUNNER_ID Runner :: getExecutionID () {
+RUNNER_ID Runner :: getExecutionID ()
+{
 
   return exec_id;
 }
 
-void Runner :: setExecutionID (const RUNNER_ID& execution_id) {
+void Runner :: setExecutionID (const RUNNER_ID& execution_id)
+{
 
   exec_id = execution_id;
 }
 
-Runner * getRunner (RUNNER_ID __key) {
+Runner * getRunner (RUNNER_ID __key)
+{
 
   return dynamic_cast <Runner *> (getCommunicable (__key));
 }
 
-void initializeContext () {
+void initializeContext ()
+{
 
   num_local_exec_runners = 0;
 
   // setting up the execution IDs & counting the number of local exec. runners
-  for (unsigned i = 0; i < the_runners.size (); i ++) {
+  for (unsigned i = 0; i < the_runners.size (); i ++)
+    {
       the_runners [i] -> setExecutionID ( my_node -> execution_id_run[ i ] );
       if (the_runners [i] -> isAssignedLocally ()) num_local_exec_runners ++;
     }
@@ -115,17 +122,20 @@ void initializeContext () {
     if (the_runners [i] -> isAssignedLocally ()) the_runners [i] -> notifyContextInitialized ();
 }
 
-void Runner :: waitStarting () {
+void Runner :: waitStarting ()
+{
 
   sem_wait (& sem_start);
 }
 
-void Runner :: waitContextInitialization () {
+void Runner :: waitContextInitialization ()
+{
 
   sem_wait (& sem_cntxt);
 }
 
-void Runner :: start () {
+void Runner :: start ()
+{
 
   setActive ();
 
@@ -136,11 +146,13 @@ void Runner :: start () {
   terminate ();
 }
 
-void startRunners () {
+void startRunners ()
+{
 
   /* Runners */
   for (unsigned i = 0; i < the_runners.size (); i ++)
-    if (the_runners [i] -> isAssignedLocally ()) {
+    if (the_runners [i] -> isAssignedLocally ())
+      {
         addThread (the_runners [i], ll_threads);
         the_runners [i] -> waitStarting ();
       }
@@ -148,34 +160,40 @@ void startRunners () {
   printDebugMessage ("launched the parallel runners");
 }
 
-void joinRunners () {
+void joinRunners ()
+{
 
   joinThreads (ll_threads);
   the_runners.clear();
 }
 
-bool atLeastOneActiveRunner () {
+bool atLeastOneActiveRunner ()
+{
 
   return num_exec_runners;
 }
 
-unsigned numberOfActiveRunners () {
+unsigned numberOfActiveRunners ()
+{
 
   return num_exec_runners;
 }
 
-void Runner :: notifyContextInitialized () {
+void Runner :: notifyContextInitialized ()
+{
 
   sem_post (& sem_cntxt);
 }
 
-void Runner :: notifySendingTermination () {
+void Runner :: notifySendingTermination ()
+{
 
   printDebugMessage ("I am informed that everyone received my termination notification.");
   setPassive ();
 }
 
-void unpackTerminationOfRunner () {
+void unpackTerminationOfRunner ()
+{
 
   RUNNER_ID finished_id;
   unpack (finished_id);
@@ -184,7 +202,8 @@ void unpackTerminationOfRunner () {
 
   printDebugMessage ("I'm noticed of the termination of a runner");
 
-  if (!num_exec_runners) {
+  if (!num_exec_runners)
+    {
 
       printDebugMessage ("All the runners have terminated - now stopping the reactive threads.");
       stopReactiveThreads ();
@@ -194,7 +213,8 @@ void unpackTerminationOfRunner () {
   wakeUpCommunicator ();
 }
 
-void initRunnersEnv () {
+void initRunnersEnv ()
+{
 
   ll_threads.clear ();
   the_runners.clear ();

trunk/paradiseo-peo/src/core/runner.h

@@ -46,7 +46,8 @@
 typedef unsigned RUNNER_ID;
 
 
-class Runner : public Communicable, public Thread {
+class Runner : public Communicable, public Thread
+  {
 
   public :
 

trunk/paradiseo-peo/src/core/service.cpp

@@ -36,38 +36,49 @@
 
 #include "service.h"
 
-void Service :: setOwner (Thread & __owner) {
+void Service :: setOwner (Thread & __owner)
+{
 
   owner = & __owner;
 }
 
-Thread * Service :: getOwner () {
+Thread * Service :: getOwner ()
+{
 
   return owner;
 }
 
-Service * getService (SERVICE_ID __key) {
+Service * getService (SERVICE_ID __key)
+{
 
   return dynamic_cast <Service *> (getCommunicable (__key));
 }
 
-void Service :: notifySendingData () { }
+void Service :: notifySendingData ()
+{ }
 
-void Service :: notifySendingResourceRequest () {
+void Service :: notifySendingResourceRequest ()
+{
 
   num_sent_rr --;
   if (! num_sent_rr)
     notifySendingAllResourceRequests ();
 }
 
-void Service :: notifySendingAllResourceRequests () { }
+void Service :: notifySendingAllResourceRequests ()
+{ }
 
-void Service :: packData () {}
+void Service :: packData ()
+{}
 
-void Service :: unpackData () {}
+void Service :: unpackData ()
+{}
 
-void Service :: execute () {}
+void Service :: execute ()
+{}
 
-void Service :: packResult () {}
+void Service :: packResult ()
+{}
 
-void Service :: unpackResult () {}
+void Service :: unpackResult ()
+{}

trunk/paradiseo-peo/src/core/service.h

@@ -43,7 +43,8 @@
 
 typedef unsigned SERVICE_ID;
 
-class Service : public Communicable {
+class Service : public Communicable
+  {
 
   public :
 

trunk/paradiseo-peo/src/core/thread.cpp

@@ -43,47 +43,56 @@ static std :: vector <Thread *> threads;
 unsigned num_act = 0;
 
 
-Thread :: Thread () {
+Thread :: Thread ()
+{
 
   threads.push_back (this);
   act = false;
 }
 
-Thread :: ~ Thread () {
+Thread :: ~ Thread ()
+{
 
   /* Nothing ! */
 }
 
-void Thread :: setActive () {
+void Thread :: setActive ()
+{
 
-  if (! act) {
+  if (! act)
+    {
 
       act = true;
       num_act ++;
     }
 }
 
-void Thread :: setPassive () {
+void Thread :: setPassive ()
+{
 
-  if (act) {
+  if (act)
+    {
 
       act = false;
       num_act --;
     }
 }
 
-void initThreadsEnv () {
+void initThreadsEnv ()
+{
 
   threads.clear ();
   num_act = 0;
 }
 
-bool atLeastOneActiveThread () {
+bool atLeastOneActiveThread ()
+{
 
   return num_act;
 }
 
-static void * launch (void * __arg) {
+static void * launch (void * __arg)
+{
 
   Thread * thr = (Thread *) __arg;
   thr -> start ();
@@ -91,16 +100,19 @@ static void * launch (void * __arg) {
   return 0;
 }
 
-void addThread (Thread * __hl_thread, std :: vector <pthread_t *> & __ll_threads) {
+void addThread (Thread * __hl_thread, std :: vector <pthread_t *> & __ll_threads)
+{
 
   pthread_t * ll_thr = new pthread_t;
   __ll_threads.push_back (ll_thr);
   pthread_create (ll_thr, 0, launch, __hl_thread);
 }
 
-void joinThreads (std :: vector <pthread_t *> & __threads) {
+void joinThreads (std :: vector <pthread_t *> & __threads)
+{
 
-  for (unsigned i = 0; i < __threads.size (); i ++) {
+  for (unsigned i = 0; i < __threads.size (); i ++)
+    {
       pthread_join (* __threads [i], 0);
       delete __threads [i];
     }

trunk/paradiseo-peo/src/core/thread.h

@@ -41,7 +41,8 @@
 
 
 /* A high-level thread */
-class Thread {
+class Thread
+  {
 
   public:
 

trunk/paradiseo-peo/src/core/topology.cpp

@@ -36,17 +36,20 @@
 
 #include "topology.h"
 
-Topology :: ~ Topology () {
+Topology :: ~ Topology ()
+{
 
   /* Nothing ! */
 }
 
-void Topology :: add (Cooperative & __mig) {
+void Topology :: add (Cooperative & __mig)
+  {
 
     mig.push_back (& __mig) ;
   }
 
-Topology :: operator std :: vector <Cooperative *>& () {
+Topology :: operator std :: vector <Cooperative *>& ()
+{
 
   return mig;
 }

trunk/paradiseo-peo/src/core/topology.h

@@ -41,7 +41,8 @@
 
 #include "cooperative.h"
 
-class Topology {
+class Topology
+  {
 
   public:
 

trunk/paradiseo-peo/src/peoAsyncIslandMig.h

@@ -234,8 +234,8 @@ template< class EOT , class TYPE> void peoAsyncIslandMig< EOT , TYPE> :: unpack(
   unlock();
 }
 
-template< class EOT , class TYPE> void peoAsyncIslandMig< EOT, TYPE > :: packSynchronizeReq() {
+template< class EOT , class TYPE> void peoAsyncIslandMig< EOT, TYPE > :: packSynchronizeReq()
-}
+{}
 
 template< class EOT , class TYPE> void peoAsyncIslandMig< EOT , TYPE> :: emigrate()
 {

trunk/paradiseo-peo/src/peoData.h

@@ -44,11 +44,14 @@
 /**************************  DEFINE A DATA   ******************************************/
 /**************************************************************************************/
 
-class peoData {
+class peoData
+  {
   public:
 
-  virtual void pack () {}
+    virtual void pack ()
-  virtual void unpack () {}
+    {}
+    virtual void unpack ()
+    {}
 
   };
 
@@ -92,12 +95,15 @@ public:
 
 // Specific implementation : migration of a population
 
-template < class EOT> class eoContinuator : public continuator{
+template < class EOT> class eoContinuator : public continuator
+  {
   public:
 
-	eoContinuator(eoContinue<EOT> & _cont, const eoPop<EOT> & _pop): cont (_cont), pop(_pop){}
+    eoContinuator(eoContinue<EOT> & _cont, const eoPop<EOT> & _pop): cont (_cont), pop(_pop)
+    {}
 
-	virtual bool check(){
+    virtual bool check()
+    {
       return cont(pop);
     }
 
@@ -120,10 +126,12 @@ public:
 
 // Specific implementation : migration of a population
 
-template < class EOT, class TYPE> class eoSelector : public selector< TYPE >{
+template < class EOT, class TYPE> class eoSelector : public selector< TYPE >
+  {
   public:
 
-	eoSelector(eoSelectOne<EOT> & _select, unsigned _nb_select, const TYPE & _source): selector (_select), nb_select(_nb_select), source(_source){}
+    eoSelector(eoSelectOne<EOT> & _select, unsigned _nb_select, const TYPE & _source): selector (_select), nb_select(_nb_select), source(_source)
+    {}
 
     virtual void operator()(TYPE & _dest)
     {
@@ -153,9 +161,11 @@ public:
 
 // Specific implementation : migration of a population
 
-template < class EOT, class TYPE> class eoReplace : public replacement< TYPE >{
+template < class EOT, class TYPE> class eoReplace : public replacement< TYPE >
+  {
   public:
-	eoReplace(eoReplacement<EOT> & _replace, TYPE & _destination): replace(_replace), destination(_destination){} 
+    eoReplace(eoReplacement<EOT> & _replace, TYPE & _destination): replace(_replace), destination(_destination)
+    {}
 
     virtual void operator()(TYPE & _source)
     {
@@ -177,7 +187,8 @@ class eoSyncContinue: public continuator
 
   public:
 
-  eoSyncContinue (unsigned __period, unsigned __init_counter = 0): period (__period),counter (__init_counter) {}
+    eoSyncContinue (unsigned __period, unsigned __init_counter = 0): period (__period),counter (__init_counter)
+    {}
 
     virtual bool check()
     {

trunk/paradiseo-peo/src/peoSyncIslandMig.h

@@ -256,7 +256,8 @@ template< class EOT, class TYPE > void peoSyncIslandMig< EOT, TYPE > :: unpack()
   explicitPassive = true;
 }
 
-template< class EOT, class TYPE > void peoSyncIslandMig< EOT,TYPE > :: packSynchronizeReq() {
+template< class EOT, class TYPE > void peoSyncIslandMig< EOT,TYPE > :: packSynchronizeReq()
+{
 
   packSynchronRequest( all );
 }
@@ -280,7 +281,8 @@ template< class EOT, class TYPE > void peoSyncIslandMig< EOT , TYPE > :: immigra
 {
   assert( imm.size() );
 
-  while ( imm.size() ) {
+  while ( imm.size() )
+    {
       replace( imm.front() ) ;
       imm.pop();
     }
@@ -294,16 +296,19 @@ template< class EOT, class TYPE > void peoSyncIslandMig< EOT , TYPE > :: operato
   if ( cont.check() )
     {
       explicitPassive = standbyMigration = false;
-    topology.setNeighbors( this, in, out ); all = topology;
+      topology.setNeighbors( this, in, out );
+      all = topology;
       nbMigrations = 0;
-    synchronizeCoopEx(); stop();
+      synchronizeCoopEx();
+      stop();
       // sending emigrants
       emigrate();
       // synchronizing
       sem_wait( &sync );
       // receiving immigrants
       immigrate();
-    synchronizeCoopEx(); stop();
+      synchronizeCoopEx();
+      stop();
     }
 }
 
@@ -316,19 +321,22 @@ template< class EOT, class TYPE > void peoSyncIslandMig< EOT , TYPE > :: notifyR
 {
   nbMigrations++;
 
-  if ( nbMigrations == in.size() ) {
+  if ( nbMigrations == in.size() )
+    {
 
       if ( standbyMigration ) getOwner()->setActive();
       sem_post( &sync );
     }
 }
 
-template< class EOT, class TYPE > void peoSyncIslandMig< EOT, TYPE > :: notifySendingSyncReq () {
+template< class EOT, class TYPE > void peoSyncIslandMig< EOT, TYPE > :: notifySendingSyncReq ()
+{
 
   getOwner()->setPassive();
 }
 
-template< class EOT, class TYPE > void peoSyncIslandMig< EOT, TYPE > :: notifySynchronized () {
+template< class EOT, class TYPE > void peoSyncIslandMig< EOT, TYPE > :: notifySynchronized ()
+{
 
   standbyMigration = true;
   getOwner()->setActive();

trunk/paradiseo-peo/src/rmc/mpi/comm.cpp

@@ -52,7 +52,8 @@ static sem_t sem_comm_init;
 static Communicator * the_thread;
 
 
-Communicator :: Communicator (int * __argc, char * * * __argv) {
+Communicator :: Communicator (int * __argc, char * * * __argv)
+{
 
   the_thread = this;
   initNode  (__argc, __argv);
@@ -61,9 +62,11 @@ Communicator :: Communicator (int * __argc, char * * * __argv) {
   sem_post (& sem_comm_init);
 }
 
-void Communicator :: start () {
+void Communicator :: start ()
+{
 
-  while (true) {
+  while (true)
+    {
 
       /* Zzz Zzz Zzz :-))) */
       sleep ();
@@ -82,11 +85,13 @@ void Communicator :: start () {
   //synchronizeNodes ();
 }
 
-void initCommunication () {
+void initCommunication ()
+{
 
   static bool initializedSemaphore = false;
 
-  if (initializedSemaphore) {
+  if (initializedSemaphore)
+    {
       sem_destroy(& sem_comm_init);
     }
 
@@ -94,12 +99,14 @@ void initCommunication () {
   initializedSemaphore = true;
 }
 
-void waitNodeInitialization () {
+void waitNodeInitialization ()
+{
 
   sem_wait (& sem_comm_init);
 }
 
-void wakeUpCommunicator () {
+void wakeUpCommunicator ()
+{
 
   the_thread -> wakeUp ();
 }

trunk/paradiseo-peo/src/rmc/mpi/comm.h

@@ -40,7 +40,8 @@
 #include "../../core/communicable.h"
 #include "../../core/reac_thread.h"
 
-class Communicator : public ReactiveThread {
+class Communicator : public ReactiveThread
+  {
 
   public :
 

trunk/paradiseo-peo/src/rmc/mpi/cooperative.cpp

@@ -41,42 +41,48 @@
 #include "mess.h"
 #include "../../core/peo_debug.h"
 
-Runner * Cooperative :: getOwner () {
+Runner * Cooperative :: getOwner ()
+{
 
   return owner;
 }
 
-void Cooperative :: setOwner (Runner & __runner) {
+void Cooperative :: setOwner (Runner & __runner)
+{
 
   owner = & __runner;
 }
 
-void Cooperative :: send (Cooperative * __coop) {
+void Cooperative :: send (Cooperative * __coop)
+{
 
   :: send (this, getRankOfRunner (__coop -> getOwner () -> getDefinitionID ()), COOP_TAG);
   //  stop ();
 }
 
-void Cooperative :: synchronizeCoopEx () {
+void Cooperative :: synchronizeCoopEx ()
+{
   :: send (this, my_node -> rk_sched, SYNCHRONIZE_REQ_TAG);
 }
 
-Cooperative * getCooperative (COOP_ID __key) {
+Cooperative * getCooperative (COOP_ID __key)
+{
 
   return dynamic_cast <Cooperative *> (getCommunicable (__key));
 }
 
-void Cooperative :: notifySending () {
+void Cooperative :: notifySending ()
+{
 
   //getOwner -> setPassive ();
   //  resume ();
 }
 
-void Cooperative :: notifyReceiving () {
+void Cooperative :: notifyReceiving ()
-}
+{}
 
-void Cooperative :: notifySendingSyncReq () {
+void Cooperative :: notifySendingSyncReq ()
-}
+{}
 
-void Cooperative :: notifySynchronized () {
+void Cooperative :: notifySynchronized ()
-}
+{}

trunk/paradiseo-peo/src/rmc/mpi/mess.cpp

@@ -51,22 +51,26 @@ static std :: vector <char *> act_buf; /* Active buffers */
 
 static std :: vector <MPI_Request *> act_req; /* Active requests */
 
-void initBuffers () {
+void initBuffers ()
+{
 
   pos_buf = 0;
   act_buf.clear ();
   act_req.clear ();
 }
 
-void cleanBuffers () {
+void cleanBuffers ()
+{
 
-  for (unsigned i = 0; i < act_req.size ();) {
+  for (unsigned i = 0; i < act_req.size ();)
+    {
 
       MPI_Status stat ;
       int flag ;
 
       MPI_Test (act_req [i], & flag, & stat) ;
-    if (flag) {
+      if (flag)
+        {
 
           delete[] act_buf [i] ;
           delete act_req [i] ;
@@ -82,11 +86,13 @@ void cleanBuffers () {
     }
 }
 
-void waitBuffers () {
+void waitBuffers ()
+{
 
   printDebugMessage ("waiting the termination of the asynchronous operations to complete");
 
-  for (unsigned i = 0; i < act_req.size (); i ++) {
+  for (unsigned i = 0; i < act_req.size (); i ++)
+    {
 
       MPI_Status stat ;
 
@@ -97,7 +103,8 @@ void waitBuffers () {
     }
 }
 
-bool probeMessage (int & __src, int & __tag) {
+bool probeMessage (int & __src, int & __tag)
+{
 
   int flag;
 
@@ -111,19 +118,22 @@ bool probeMessage (int & __src, int & __tag) {
   return flag;
 }
 
-void waitMessage () {
+void waitMessage ()
+{
 
   MPI_Status stat;
 
   MPI_Probe (MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, & stat);
 }
 
-void initMessage () {
+void initMessage ()
+{
 
   pos_buf = 0;
 }
 
-void sendMessage (int __to, int __tag) {
+void sendMessage (int __to, int __tag)
+{
 
   cleanBuffers ();
   act_buf.push_back (new char [pos_buf]);
@@ -132,13 +142,15 @@ void sendMessage (int __to, int __tag) {
   MPI_Isend (act_buf.back (), pos_buf, MPI_PACKED, __to, __tag, MPI_COMM_WORLD, act_req.back ());
 }
 
-void sendMessageToAll (int __tag) {
+void sendMessageToAll (int __tag)
+{
 
   for (int i = 0; i < getNumberOfNodes (); i ++)
     sendMessage (i, __tag);
 }
 
-void receiveMessage (int __from, int __tag) {
+void receiveMessage (int __from, int __tag)
+{
 
   MPI_Status stat;
   MPI_Request req;
@@ -147,80 +159,93 @@ void receiveMessage (int __from, int __tag) {
   MPI_Wait (& req, & stat);
 }
 
-void synchronizeNodes () {
+void synchronizeNodes ()
+{
 
   MPI_Barrier ( MPI_COMM_WORLD );
 }
 
 /* Char */
-void pack (const char & __c) {
+void pack (const char & __c)
+{
 
   MPI_Pack ((void *) & __c, 1, MPI_CHAR, mpi_buf, MPI_BUF_SIZE, & pos_buf, MPI_COMM_WORLD);
 }
 
 /* Boolean */
-void pack (const bool & __b, int __nitem){
+void pack (const bool & __b, int __nitem)
+{
 
   MPI_Pack ((void *) & __b, __nitem, MPI_INT, mpi_buf, MPI_BUF_SIZE, & pos_buf, MPI_COMM_WORLD);
 }
 
 /* Float */
-void pack (const float & __f, int __nitem) {
+void pack (const float & __f, int __nitem)
+{
 
   MPI_Pack ((void *) & __f, __nitem, MPI_FLOAT, mpi_buf, MPI_BUF_SIZE, & pos_buf, MPI_COMM_WORLD);
 }
 
 /* Double */
-void pack (const double & __d, int __nitem) {
+void pack (const double & __d, int __nitem)
+{
 
   MPI_Pack ((void *) & __d, __nitem, MPI_DOUBLE, mpi_buf, MPI_BUF_SIZE, & pos_buf, MPI_COMM_WORLD);
 }
 
 /* Integer */
-void pack (const int & __i, int __nitem) {
+void pack (const int & __i, int __nitem)
+{
 
   MPI_Pack ((void *) & __i, __nitem, MPI_INT, mpi_buf, MPI_BUF_SIZE, & pos_buf, MPI_COMM_WORLD);
 }
 
 /* Unsigned int. */
-void pack (const unsigned int & __ui, int __nitem) {
+void pack (const unsigned int & __ui, int __nitem)
+{
 
   MPI_Pack ((void *) & __ui, __nitem, MPI_UNSIGNED, mpi_buf, MPI_BUF_SIZE, & pos_buf, MPI_COMM_WORLD);
 }
 
 /* Short int. */
-void pack (const short & __sh, int __nitem) {
+void pack (const short & __sh, int __nitem)
+{
 
   MPI_Pack ((void *) & __sh, __nitem, MPI_SHORT, mpi_buf, MPI_BUF_SIZE, & pos_buf, MPI_COMM_WORLD);
 }
 
 /* Unsigned short */
-void pack (const unsigned short & __ush, int __nitem) {
+void pack (const unsigned short & __ush, int __nitem)
+{
 
   MPI_Pack ((void *) & __ush, __nitem, MPI_UNSIGNED_SHORT, mpi_buf, MPI_BUF_SIZE, & pos_buf, MPI_COMM_WORLD);
 }
 
 /* Long */
-void pack (const long & __l, int __nitem) {
+void pack (const long & __l, int __nitem)
+{
 
   MPI_Pack ((void *) & __l, __nitem, MPI_LONG, mpi_buf, MPI_BUF_SIZE, & pos_buf, MPI_COMM_WORLD);
 }
 
 /* Unsigned long */
-void pack (const unsigned long & __ul, int __nitem) {
+void pack (const unsigned long & __ul, int __nitem)
+{
 
   MPI_Pack ((void *) & __ul, __nitem, MPI_UNSIGNED_LONG, mpi_buf, MPI_BUF_SIZE, & pos_buf, MPI_COMM_WORLD);
 }
 
 /* String */
-void pack (const char * __str) {
+void pack (const char * __str)
+{
 
   int len = strlen (__str) + 1;
   MPI_Pack (& len, 1, MPI_INT, mpi_buf, MPI_BUF_SIZE, & pos_buf, MPI_COMM_WORLD);
   MPI_Pack ((void *) __str, len, MPI_CHAR, mpi_buf, MPI_BUF_SIZE, & pos_buf, MPI_COMM_WORLD);
 }
 
-void pack (const std::string & __str) {
+void pack (const std::string & __str)
+{
 
   size_t size = __str.size() + 1;
   char * buffer = new char[ size ];
@@ -230,73 +255,85 @@ void pack (const std::string & __str) {
 }
 
 /* Char */
-void unpack (char & __c) {
+void unpack (char & __c)
+{
 
   MPI_Unpack (mpi_buf, MPI_BUF_SIZE, & pos_buf, & __c, 1, MPI_CHAR, MPI_COMM_WORLD);
 }
 
 /* Boolean */
-extern void unpack (bool & __b, int __nitem ){
+extern void unpack (bool & __b, int __nitem )
+  {
 
     MPI_Unpack (mpi_buf, MPI_BUF_SIZE, & pos_buf, & __b, __nitem, MPI_INT, MPI_COMM_WORLD);
   }
 
 /* Float */
-void unpack (float & __f, int __nitem) {
+void unpack (float & __f, int __nitem)
+{
 
   MPI_Unpack (mpi_buf, MPI_BUF_SIZE, & pos_buf, & __f, __nitem, MPI_FLOAT, MPI_COMM_WORLD);
 }
 
 /* Double */
-void unpack (double & __d, int __nitem) {
+void unpack (double & __d, int __nitem)
+{
 
   MPI_Unpack (mpi_buf, MPI_BUF_SIZE, & pos_buf, & __d, __nitem, MPI_DOUBLE, MPI_COMM_WORLD);
 }
 
 /* Integer */
-void unpack (int & __i, int __nitem) {
+void unpack (int & __i, int __nitem)
+{
 
   MPI_Unpack (mpi_buf, MPI_BUF_SIZE, & pos_buf, & __i, __nitem, MPI_INT, MPI_COMM_WORLD);
 }
 
 /* Unsigned int. */
-void unpack (unsigned int & __ui, int __nitem) {
+void unpack (unsigned int & __ui, int __nitem)
+{
 
   MPI_Unpack (mpi_buf, MPI_BUF_SIZE, & pos_buf, & __ui, __nitem, MPI_UNSIGNED, MPI_COMM_WORLD);
 }
 
 /* Short int. */
-void unpack (short & __sh, int __nitem) {
+void unpack (short & __sh, int __nitem)
+{
 
   MPI_Unpack (mpi_buf, MPI_BUF_SIZE, & pos_buf, & __sh, __nitem, MPI_SHORT, MPI_COMM_WORLD);
 }
 
 /* Unsigned short */
-void unpack (unsigned short & __ush, int __nitem) {
+void unpack (unsigned short & __ush, int __nitem)
+{
 
   MPI_Unpack (mpi_buf, MPI_BUF_SIZE, & pos_buf, & __ush, __nitem, MPI_UNSIGNED_SHORT, MPI_COMM_WORLD);
 }
 
 /* Long */
-void unpack (long & __l, int __nitem) {
+void unpack (long & __l, int __nitem)
+{
 
   MPI_Unpack (mpi_buf, MPI_BUF_SIZE, & pos_buf, & __l, __nitem, MPI_LONG, MPI_COMM_WORLD);
 }
 
 /* Unsigned long */
-void unpack (unsigned long & __ul, int __nitem) {
+void unpack (unsigned long & __ul, int __nitem)
+{
 
   MPI_Unpack (mpi_buf, MPI_BUF_SIZE, & pos_buf, & __ul, __nitem, MPI_UNSIGNED_LONG, MPI_COMM_WORLD);
 }
 
 /* String */
-void unpack (char * __str) {
+void unpack (char * __str)
+{
 
   int len;
   MPI_Unpack (mpi_buf, MPI_BUF_SIZE, & pos_buf, & len, 1, MPI_INT, MPI_COMM_WORLD);
   MPI_Unpack (mpi_buf, MPI_BUF_SIZE, & pos_buf, __str, len, MPI_CHAR, MPI_COMM_WORLD);
 }
-void unpack (std::string & __str) {
+void unpack (std::string & __str)
+{
 
   char * buffer;
   int len;

trunk/paradiseo-peo/src/rmc/mpi/node.cpp

@@ -43,20 +43,24 @@
 #include "mess.h"
 
 
-class MPIThreadedEnv {
+class MPIThreadedEnv
+  {
 
   public:
 
-  static void init ( int * __argc, char * * * __argv ) {
+    static void init ( int * __argc, char * * * __argv )
+    {
 
       static MPIThreadedEnv mpiThreadedEnv( __argc, __argv );
     }
 
-  static void finalize () {
+    static void finalize ()
+    {
 
       static bool finalizedEnvironment = false;
 
-    if (! finalizedEnvironment ) {
+      if (! finalizedEnvironment )
+        {
 
           MPI_Finalize ();
           finalizedEnvironment = true;
@@ -66,12 +70,14 @@ public:
   private:
 
     /* No instance of this class can be created outside its domain! */
-  MPIThreadedEnv ( int * __argc, char * * * __argv ) {
+    MPIThreadedEnv ( int * __argc, char * * * __argv )
+    {
 
       static bool MPIThreadedEnvInitialized = false;
       int provided = 1;
 
-    if (! MPIThreadedEnvInitialized) {
+      if (! MPIThreadedEnvInitialized)
+        {
 
           MPI_Init_thread (__argc, __argv, MPI_THREAD_FUNNELED, & provided);
 
@@ -82,7 +88,8 @@ private:
         }
     }
 
-  ~MPIThreadedEnv() {
+    ~MPIThreadedEnv()
+    {
 
       finalize ();
     }
@@ -96,27 +103,32 @@ static std :: map <std :: string, int> name_to_rk;
 static std :: vector <std :: string> rk_to_name;
 
 
-int getNodeRank () {
+int getNodeRank ()
+{
 
   return rk;
 }
 
-int getNumberOfNodes () {
+int getNumberOfNodes ()
+{
 
   return sz;
 }
 
-void collectiveCountOfRunners ( unsigned int* num_local_exec_runners, unsigned int* num_exec_runners ) {
+void collectiveCountOfRunners ( unsigned int* num_local_exec_runners, unsigned int* num_exec_runners )
+{
 
   MPI_Allreduce( num_local_exec_runners, num_exec_runners, 1, MPI_UNSIGNED, MPI_SUM, MPI_COMM_WORLD );
 }
 
-int getRankFromName (const std :: string & __name) {
+int getRankFromName (const std :: string & __name)
+{
 
   return atoi (__name.c_str ());
 }
 
-void initNode (int * __argc, char * * * __argv) {
+void initNode (int * __argc, char * * * __argv)
+{
 
   rk_to_name.clear ();
   name_to_rk.clear ();
@@ -134,7 +146,8 @@ void initNode (int * __argc, char * * * __argv) {
   MPI_Get_processor_name (names [0], & len);   /* Me */
   MPI_Allgather (names, MPI_MAX_PROCESSOR_NAME, MPI_CHAR, names, MPI_MAX_PROCESSOR_NAME, MPI_CHAR, MPI_COMM_WORLD); /* Broadcast */
 
-  for (int i = 0; i < sz; i ++) {
+  for (int i = 0; i < sz; i ++)
+    {
       rk_to_name.push_back (names [i]);
       name_to_rk [names [i]] = i;
     }

trunk/paradiseo-peo/src/rmc/mpi/node.h

@@ -44,7 +44,8 @@
 
 typedef int RANK_ID;
 
-struct Node {
+struct Node
+  {
 
     RANK_ID rk; /* Rank */
     std :: string name; /* Host name */

trunk/paradiseo-peo/src/rmc/mpi/param.cpp

@@ -38,7 +38,8 @@
 
 #include "schema.h"
 
-void loadRMCParameters (int & __argc, char * * & __argv) {
+void loadRMCParameters (int & __argc, char * * & __argv)
+{
 
   eoParser parser (__argc, __argv);
 

trunk/paradiseo-peo/src/rmc/mpi/recv.cpp

@@ -45,25 +45,30 @@
 #include "../../core/cooperative.h"
 #include "../../core/peo_debug.h"
 
-void receiveMessages () {
+void receiveMessages ()
+{
 
   cleanBuffers ();
 
-  do {
+  do
+    {
 
-    if (! atLeastOneActiveThread ()) {
+      if (! atLeastOneActiveThread ())
+        {
 
           waitMessage ();
         }
 
       int src, tag;
 
-    while (probeMessage (src, tag)) {
+      while (probeMessage (src, tag))
+        {
 
           receiveMessage (src, tag);
           initMessage ();
 
-      switch (tag) {
+          switch (tag)
+            {
 
             case RUNNER_STOP_TAG:
               unpackTerminationOfRunner ();
@@ -146,5 +151,6 @@ void receiveMessages () {
             };
         }
 
-  } while ( ! atLeastOneActiveThread () && atLeastOneActiveRunner () /*&& ! allResourcesFree ()*/ );
+    }
+  while ( ! atLeastOneActiveThread () && atLeastOneActiveRunner () /*&& ! allResourcesFree ()*/ );
 }

trunk/paradiseo-peo/src/rmc/mpi/rmc.cpp

@@ -46,10 +46,12 @@ static std :: vector <Worker *> worker_threads; /* Worker threads */
 static Communicator* communicator_thread = NULL; /* Communicator thread */
 
 
-void runRMC () {
+void runRMC ()
+{
 
   /* Worker(s) ? */
-  for (unsigned i = 0; i < my_node -> num_workers; i ++) {
+  for (unsigned i = 0; i < my_node -> num_workers; i ++)
+    {
       worker_threads.push_back (new Worker);
       addThread (worker_threads.back(), ll_threads);
     }
@@ -57,7 +59,8 @@ void runRMC () {
   wakeUpCommunicator ();
 }
 
-void initRMC (int & __argc, char * * & __argv) {
+void initRMC (int & __argc, char * * & __argv)
+{
 
   /* Communication */
   initCommunication ();
@@ -71,12 +74,14 @@ void initRMC (int & __argc, char * * & __argv) {
     initScheduler ();
 }
 
-void finalizeRMC () {
+void finalizeRMC ()
+{
 
   printDebugMessage ("before join threads RMC");
 
   joinThreads (ll_threads);
-  for (unsigned i = 0; i < worker_threads.size(); i++ ) {
+  for (unsigned i = 0; i < worker_threads.size(); i++ )
+    {
       delete worker_threads [i];
     }
   worker_threads.clear ();

trunk/paradiseo-peo/src/rmc/mpi/runner.cpp

@@ -43,7 +43,8 @@
 #include "schema.h"
 
 
-bool Runner :: isAssignedLocally () {
+bool Runner :: isAssignedLocally ()
+{
 
   for (unsigned i = 0; i < my_node -> id_run.size (); i ++)
     if (my_node -> id_run [i] == def_id)
@@ -51,12 +52,14 @@ bool Runner :: isAssignedLocally () {
   return false;
 }
 
-void Runner :: terminate () {
+void Runner :: terminate ()
+{
 
   sendToAll (this, RUNNER_STOP_TAG);
 }
 
-void Runner :: packTermination () {
+void Runner :: packTermination ()
+{
 
   pack (def_id);
 }

trunk/paradiseo-peo/src/rmc/mpi/scheduler.cpp

@@ -49,13 +49,15 @@ static unsigned initNumberOfRes = 0;
 
 extern void wakeUpCommunicator();
 
-void initScheduler () {
+void initScheduler ()
+{
 
   resources = std :: queue <SCHED_RESOURCE> ();
   requests = std :: queue <SCHED_REQUEST> ();
   initNumberOfRes = 0;
 
-  for (unsigned i = 0; i < the_schema.size (); i ++) {
+  for (unsigned i = 0; i < the_schema.size (); i ++)
+    {
 
       const Node & node = the_schema [i];
 
@@ -66,19 +68,23 @@ void initScheduler () {
   initNumberOfRes = resources.size ();
 }
 
-bool allResourcesFree () {
+bool allResourcesFree ()
+{
   return resources.size () == initNumberOfRes;
 }
 
-unsigned numResourcesFree () {
+unsigned numResourcesFree ()
+{
   return resources.size ();
 }
 
-static void update () {
+static void update ()
+{
 
   unsigned num_alloc = std :: min (resources.size (), requests.size ());
 
-  for (unsigned i = 0; i < num_alloc; i ++) {
+  for (unsigned i = 0; i < num_alloc; i ++)
+    {
 
       SCHED_REQUEST req = requests.front ();
       requests.pop ();
@@ -94,7 +100,8 @@ static void update () {
     }
 }
 
-void unpackResourceRequest () {
+void unpackResourceRequest ()
+{
 
   printDebugMessage ("queuing a resource request.");
   SCHED_REQUEST req;
@@ -103,7 +110,8 @@ void unpackResourceRequest () {
   update ();
 }
 
-void unpackTaskDone () {
+void unpackTaskDone ()
+{
 
   printDebugMessage ("I'm notified a worker is now idle.");
   SCHED_RESOURCE res;

trunk/paradiseo-peo/src/rmc/mpi/schema.cpp

@@ -51,7 +51,8 @@ Node * my_node;
 static unsigned maxSpecifiedRunnerID = 0;
 
 
-RANK_ID getRankOfRunner (RUNNER_ID __key) {
+RANK_ID getRankOfRunner (RUNNER_ID __key)
+{
 
   for (unsigned i = 0; i < the_schema.size (); i ++)
     for (unsigned j = 0; j < the_schema [i].id_run.size (); j ++)
@@ -61,7 +62,8 @@ RANK_ID getRankOfRunner (RUNNER_ID __key) {
   return 0;
 }
 
-static void loadNode (int __rk_sched) {
+static void loadNode (int __rk_sched)
+{
 
   Node node;
 
@@ -72,12 +74,14 @@ static void loadNode (int __rk_sched) {
   /* ATT: num_workers */
   node.num_workers = atoi (getAttributeValue ("num_workers").c_str ());
 
-  while (true) {
+  while (true)
+    {
 
       /* TAG: <runner> | </node> */
       std :: string name = getNextNode ();
       assert (name == "runner" || name == "node");
-    if (name == "runner") {
+      if (name == "runner")
+        {
           /* TAG: </node> */
           node.id_run.push_back (atoi (getNextNode ().c_str ()));
           if ( node.id_run.back() > maxSpecifiedRunnerID )
@@ -85,7 +89,8 @@ static void loadNode (int __rk_sched) {
           /* TAG: </runner> */
           assert (getNextNode () == "runner");
         }
-    else {
+      else
+        {
           /* TAG: </node> */
           node.execution_id_run = node.id_run;
           the_schema.push_back (node);
@@ -94,14 +99,16 @@ static void loadNode (int __rk_sched) {
     }
 }
 
-static void loadGroup () {
+static void loadGroup ()
+{
 
   std :: string name;
 
   /* ATT: scheduler*/
   int rk_sched = getRankFromName (getAttributeValue ("scheduler"));
 
-  while (true) {
+  while (true)
+    {
 
       /* TAG: <node> | </group> */
       name = getNextNode ();
@@ -115,12 +122,14 @@ static void loadGroup () {
     }
 }
 
-bool isScheduleNode () {
+bool isScheduleNode ()
+{
 
   return my_node -> rk == my_node -> rk_sched;
 }
 
-void loadSchema (const char * __filename) {
+void loadSchema (const char * __filename)
+{
 
   openXMLDocument (__filename);
 
@@ -133,7 +142,8 @@ void loadSchema (const char * __filename) {
   the_schema.clear();
   maxSpecifiedRunnerID = 0;
 
-  while (true) {
+  while (true)
+    {
 
       /* TAG: <group> | </schema> */
       name = getNextNode ();
@@ -147,12 +157,16 @@ void loadSchema (const char * __filename) {
     }
 
 
-  std :: set<unsigned> uniqueRunnerIDs; unsigned nbUniqueIDs = 0;
+  std :: set<unsigned> uniqueRunnerIDs;
-  for (unsigned i = 0; i < the_schema.size (); i ++) {
+  unsigned nbUniqueIDs = 0;
-    for (unsigned j = 0; j < the_schema [i].id_run.size(); j ++) {
+  for (unsigned i = 0; i < the_schema.size (); i ++)
+    {
+      for (unsigned j = 0; j < the_schema [i].id_run.size(); j ++)
+        {
           uniqueRunnerIDs.insert( the_schema [i].id_run[j] );
           /* In case a duplicate ID has been found */
-      if ( uniqueRunnerIDs.size() == nbUniqueIDs ) {
+          if ( uniqueRunnerIDs.size() == nbUniqueIDs )
+            {
               the_schema [i].execution_id_run[j] = ++maxSpecifiedRunnerID;
             }
           nbUniqueIDs = uniqueRunnerIDs.size();
@@ -160,7 +174,8 @@ void loadSchema (const char * __filename) {
     }
 
   /* Looking for my node */
-  for (unsigned i = 0; i < the_schema.size (); i ++) {
+  for (unsigned i = 0; i < the_schema.size (); i ++)
+    {
       if (the_schema [i].rk == getNodeRank ())
         my_node = & (the_schema [i]);
     }
@@ -175,12 +190,14 @@ void loadSchema (const char * __filename) {
   if (isScheduleNode ())
     printDebugMessage ("I'am a scheduler");
 
-  for (unsigned i = 0; i < my_node -> id_run.size (); i ++) {
+  for (unsigned i = 0; i < my_node -> id_run.size (); i ++)
+    {
       sprintf (mess, "I manage the runner %d", my_node -> id_run [i]);
       printDebugMessage (mess);
     }
 
-  if (my_node -> num_workers) {
+  if (my_node -> num_workers)
+    {
 
       sprintf (mess, "I manage %d worker(s)", my_node -> num_workers);
       printDebugMessage (mess);

trunk/paradiseo-peo/src/rmc/mpi/send.cpp

@@ -50,13 +50,15 @@
 #define TO_ALL -1
 
 
-typedef struct {
+typedef struct
+  {
 
     Communicable * comm;
     int to;
     int tag;
 
-} SEND_REQUEST;
+  }
+SEND_REQUEST;
 
 
 static std :: queue <SEND_REQUEST> mess;
@@ -66,13 +68,15 @@ static sem_t sem_send;
 static bool contextInitialized = false;
 
 
-void initSending () {
+void initSending ()
+{
 
   static bool initializedSemaphore = false;
 
   mess = std :: queue <SEND_REQUEST> ();
 
-  if (initializedSemaphore) {
+  if (initializedSemaphore)
+    {
       sem_destroy(& sem_send);
     }
 
@@ -82,7 +86,8 @@ void initSending () {
   contextInitialized = false;
 }
 
-void send (Communicable * __comm, int __to, int __tag) {
+void send (Communicable * __comm, int __to, int __tag)
+{
 
   SEND_REQUEST req;
   req.comm = __comm;
@@ -95,23 +100,27 @@ void send (Communicable * __comm, int __to, int __tag) {
   wakeUpCommunicator ();
 }
 
-void sendToAll (Communicable * __comm, int __tag) {
+void sendToAll (Communicable * __comm, int __tag)
+{
 
   send (__comm, TO_ALL, __tag);
 }
 
 extern void initializeContext ();
 
-void sendMessages () {
+void sendMessages ()
+{
 
-  if (! contextInitialized) {
+  if (! contextInitialized)
+    {
       contextInitialized = true;
       initializeContext();
     }
 
   sem_wait (& sem_send);
 
-  while (! mess.empty ()) {
+  while (! mess.empty ())
+    {
 
       SEND_REQUEST req = mess.front ();
 
@@ -119,7 +128,8 @@ void sendMessages () {
 
       initMessage ();
 
-    switch (req.tag) {
+      switch (req.tag)
+        {
 
         case RUNNER_STOP_TAG:
           dynamic_cast <Runner *> (comm) -> packTermination ();

trunk/paradiseo-peo/src/rmc/mpi/service.cpp

@@ -41,14 +41,16 @@
 #include "send.h"
 #include "scheduler.h"
 
-void Service :: requestResourceRequest (unsigned __how_many) {
+void Service :: requestResourceRequest (unsigned __how_many)
+{
 
   num_sent_rr = __how_many;
   for (unsigned i = 0; i < __how_many; i ++)
     send (this, my_node -> rk_sched, SCHED_REQUEST_TAG);
 }
 
-void Service :: packResourceRequest () {
+void Service :: packResourceRequest ()
+{
 
   SCHED_REQUEST req;
   req.first = getNodeRank ();

trunk/paradiseo-peo/src/rmc/mpi/synchron.cpp

@@ -50,26 +50,30 @@ extern void wakeUpCommunicator();
 extern RANK_ID getRankOfRunner (RUNNER_ID __key);
 
 /* Initializing the list of runners to be synchronized */
-void initSynchron () {
+void initSynchron ()
+{
 
   syncRunners = SYNC();
 }
 
 /* packing a synchronization request from a service */
-void packSynchronRequest ( const std :: vector <Cooperative *>& coops ) {
+void packSynchronRequest ( const std :: vector <Cooperative *>& coops )
+{
 
   /* Number of coops to synchronize */
   pack( (unsigned)( coops.size() ) );
 
   /* Coops to synchronize */
-  for (unsigned i = 0; i < coops.size(); i ++) {
+  for (unsigned i = 0; i < coops.size(); i ++)
+    {
       pack( coops[ i ]->getOwner()->getDefinitionID() );
       pack( coops[ i ]->getKey() );
     }
 }
 
 /* Processing a synchronization request from a service */
-void unpackSynchronRequest () {
+void unpackSynchronRequest ()
+{
 
   unsigned req_num_entries;
   unpack (req_num_entries);
@@ -79,7 +83,8 @@ void unpackSynchronRequest () {
 
   /* Adding entries for each of the runners to be synchronized */
   SyncEntry req_entry;
-  for (unsigned i = 0; i < req_num_entries; i ++) {
+  for (unsigned i = 0; i < req_num_entries; i ++)
+    {
 
       unpack (req_entry.runner);
       unpack (req_entry.coop);
@@ -91,24 +96,28 @@ void unpackSynchronRequest () {
   SYNC::iterator sync_it = syncRunners.find (req_sync);
 
   /* The vector does not exist - insert a new sync */
-  if (sync_it == syncRunners.end ()) {
+  if (sync_it == syncRunners.end ())
+    {
       req_sync.second = 1;
       syncRunners.insert (req_sync);
     }
-  else {
+  else
+    {
 
       /* The vector exists - updating the entry */
       std::pair< SYNC_RUNNERS, unsigned >& sync_req_entry = const_cast< std::pair< SYNC_RUNNERS, unsigned >& > (*sync_it);
       sync_req_entry.second ++;
 
       /* All the runners to be synchronized sent the SYNC_REQUEST signal */
-    if (sync_req_entry.second == sync_req_entry.first.size()) {
+      if (sync_req_entry.second == sync_req_entry.first.size())
+        {
 
           /* Remove the entry */
           syncRunners.erase (sync_it);
 
           /* Send SYNCHRONIZED signals to all the coop objects */
-      for (unsigned i = 0; i < req_sync.first.size(); i ++) {
+          for (unsigned i = 0; i < req_sync.first.size(); i ++)
+            {
 
               initMessage ();
 

trunk/paradiseo-peo/src/rmc/mpi/synchron.h

@@ -44,24 +44,32 @@
 #include "../../core/runner.h"
 #include "../../core/cooperative.h"
 
-struct SyncEntry {
+struct SyncEntry
+  {
 
     RUNNER_ID runner;
     COOP_ID coop;
   };
 
-struct SyncCompare {
+struct SyncCompare
+  {
 
-  bool operator()( const std::pair< std::vector< SyncEntry >, unsigned >& A, const std::pair< std::vector< SyncEntry >, unsigned >& B ) {
+    bool operator()( const std::pair< std::vector< SyncEntry >, unsigned >& A, const std::pair< std::vector< SyncEntry >, unsigned >& B )
+    {
 
       const std::vector< SyncEntry >& syncA = A.first;
       const std::vector< SyncEntry >& syncB = B.first;
 
-    if ( syncA.size() == syncB.size() ) {
+      if ( syncA.size() == syncB.size() )
+        {
           std::vector< SyncEntry >::const_iterator itA = syncA.begin();
           std::vector< SyncEntry >::const_iterator itB = syncB.begin();
 
-      while ( (*itA).runner < (*itB).runner && itA != syncA.end() ) { itA++; itB++; }
+          while ( (*itA).runner < (*itB).runner && itA != syncA.end() )
+            {
+              itA++;
+              itB++;
+            }
 
           return itA == syncA.end();
         }

trunk/paradiseo-peo/src/rmc/mpi/worker.cpp

@@ -48,12 +48,14 @@ static std :: vector <Worker *> key_to_worker (1); /* Vector of registered worke
 
 extern void wakeUpCommunicator ();
 
-Worker * getWorker (WORKER_ID __key) {
+Worker * getWorker (WORKER_ID __key)
+{
 
   return key_to_worker [__key];
 }
 
-Worker :: Worker () {
+Worker :: Worker ()
+{
 
   recvAndCompleted = false;
   taskAssigned = 0;
@@ -63,13 +65,15 @@ Worker :: Worker () {
   sem_init( &sem_task_done, 0, 0 );
 }
 
-void Worker :: packResult () {
+void Worker :: packResult ()
+{
 
   pack (serv_id);
   serv -> packResult ();
 }
 
-void Worker :: unpackData () {
+void Worker :: unpackData ()
+{
 
   taskAssigned ++;
   printDebugMessage ("unpacking the ID. of the service.");
@@ -81,46 +85,54 @@ void Worker :: unpackData () {
   setActive ();
 }
 
-void Worker :: packTaskDone () {
+void Worker :: packTaskDone ()
+{
 
   pack (getNodeRank ());
   pack (id);
 }
 
-void Worker :: notifySendingResult () {
+void Worker :: notifySendingResult ()
+{
 
   /* Notifying the scheduler of the termination */
   recvAndCompleted = true;
   wakeUp ();
 }
 
-void Worker :: notifySendingTaskDone () {
+void Worker :: notifySendingTaskDone ()
+{
 
   sem_post(&sem_task_done);
   setPassive ();
 }
 
-void Worker :: setSource (int __rank) {
+void Worker :: setSource (int __rank)
+{
 
   src = __rank;
 }
 
-void Worker :: start () {
+void Worker :: start ()
+{
 
-  while (true) {
+  while (true)
+    {
 
       sleep ();
 
       if (! atLeastOneActiveRunner () && ! taskAssigned)
         break;
 
-    if (recvAndCompleted) {
+      if (recvAndCompleted)
+        {
           send (this, my_node -> rk_sched, TASK_DONE_TAG);
           recvAndCompleted = false;
           sem_wait(&sem_task_done);
           taskAssigned --;
         }
-    else {
+      else
+        {
 
           serv -> execute ();
           send (this, src, TASK_RESULT_TAG);
@@ -133,7 +145,8 @@ void Worker :: start () {
   wakeUpCommunicator();
 }
 
-void initWorkersEnv () {
+void initWorkersEnv ()
+{
 
   key_to_worker.resize (1);
 }

trunk/paradiseo-peo/src/rmc/mpi/worker.h

@@ -44,7 +44,8 @@
 
 typedef unsigned WORKER_ID;
 
-class Worker : public Communicable, public ReactiveThread {
+class Worker : public Communicable, public ReactiveThread
+  {
 
   public :
 

trunk/paradiseo-peo/src/rmc/mpi/xml_parser.cpp

@@ -40,23 +40,27 @@
 
 static xmlTextReaderPtr reader;
 
-void openXMLDocument (const char * __filename) {
+void openXMLDocument (const char * __filename)
+{
 
   reader = xmlNewTextReaderFilename (__filename);
 
-  if (! reader) {
+  if (! reader)
+    {
 
       fprintf (stderr, "unable to open '%s'.\n", __filename);
       exit (1);
     }
 }
 
-void closeXMLDocument () {
+void closeXMLDocument ()
+{
 
   xmlFreeTextReader (reader);
 }
 
-std :: string getAttributeValue (const std :: string & __attr) {
+std :: string getAttributeValue (const std :: string & __attr)
+{
 
   xmlChar * value = xmlTextReaderGetAttribute (reader, (const xmlChar *) __attr.c_str ());
 
@@ -67,7 +71,8 @@ std :: string getAttributeValue (const std :: string & __attr) {
   return str;
 }
 
-static bool isSep (const xmlChar * __text) {
+static bool isSep (const xmlChar * __text)
+{
 
   for (unsigned i = 0; i < strlen ((char *) __text); i ++)
     if (__text [i] != ' ' && __text [i] != '\t' && __text [i] != '\n')
@@ -75,15 +80,18 @@ static bool isSep (const xmlChar * __text) {
   return true;
 }
 
-std :: string getNextNode () {
+std :: string getNextNode ()
+{
 
   xmlChar * name, * value;
 
-  do {
+  do
+    {
       xmlTextReaderRead (reader);
       name = xmlTextReaderName (reader);
       value = xmlTextReaderValue (reader);
-  } while (! strcmp ((char *) name, "#text") && isSep (value));
+    }
+  while (! strcmp ((char *) name, "#text") && isSep (value));
 
   std :: string str;
 

trunk/paradiseo-peo/tutorial/Lesson5/main.cpp

@@ -56,7 +56,8 @@ class eoResizerInit: public eoInit<EOT>
     typedef typename EOT::AtomType AtomType;
 
     eoResizerInit(unsigned _size)
-            : size(_size){}
+        : size(_size)
+    {}
 
     virtual void operator()(EOT& chrom)
     {

trunk/paradiseo-peo/tutorial/examples/tsp/display_best_route.cpp

@@ -40,7 +40,6 @@
 DisplayBestRoute :: DisplayBestRoute (eoPop <Route> & __pop
                                      ) : pop (__pop)
 {
-
 }
 
 void DisplayBestRoute :: operator () ()

trunk/paradiseo-peo/tutorial/examples/tsp/part_route_eval.cpp

@@ -41,8 +41,7 @@ PartRouteEval :: PartRouteEval (float __from,
                                 float __to
                                ) : from (__from),
     to (__to)
-{
+{}
-}
 
 void PartRouteEval :: operator () (Route & __route)
 {