added forward ranking algorithm

12 files changed, 666 insertions, 34 deletions

diff --git a/TAO/orbsvcs/examples/FaultTolerance/FLARe/DeCoRAM/experiments/packing/generate.sh b/TAO/orbsvcs/examples/FaultTolerance/FLARe/DeCoRAM/experiments/packing/generate.sh
index 0e6a48cd60d..9a98572a32b 100755
--- a/TAO/orbsvcs/examples/FaultTolerance/FLARe/DeCoRAM/experiments/packing/generate.sh
+++ b/TAO/orbsvcs/examples/FaultTolerance/FLARe/DeCoRAM/experiments/packing/generate.sh
@@ -3,10 +3,8 @@ DECORAM_BIN=../../bin
 DATA_DIR=$1
 
 #experiment parameters
-PROCESSOR_NO=10
-TASK_NUMBER=160
 INTERVAL_NUMBER=1
-MAXIMUM_LOAD=0.20
+MAXIMUM_LOAD=0.25
 PERIOD_UPPER=1000.0
 PERIOD_LOWER=1.0
 SS_UPPER=0.01
@@ -15,7 +13,7 @@ SS_LOWER=0.005
 if [ ! -d ./$DATA_DIR ]; then mkdir ./$DATA_DIR; fi
 
 for TASK_NO in 10 20 40 80 160; do \
-  echo "run tgen for $TASK_NUMBER tasks..." && \
+  echo "run tgen for $TASK_NO tasks..." && \
   $DECORAM_BIN/tgen \
     -n $TASK_NO \
     -i $INTERVAL_NUMBER \
@@ -25,7 +23,7 @@ for TASK_NO in 10 20 40 80 160; do \
     -s $SS_UPPER \
     -z $SS_LOWER > ./$DATA_DIR/$TASK_NO-tasks.input && \
   for BACKUP_NO in 1 2 3 4 5; do \
-    for ALGORITHM in bftrmff pkftrmff fpftrmff; do \
+    for ALGORITHM in pftrmff aftrmff frftrmff; do \
       echo "run $ALGORITHM for $BACKUP_NO backups..." && \
       $DECORAM_BIN/$ALGORITHM \
         ./$DATA_DIR/$TASK_NO-tasks.input \
diff --git a/TAO/orbsvcs/examples/FaultTolerance/FLARe/DeCoRAM/experiments/packing/processor_util.sh b/TAO/orbsvcs/examples/FaultTolerance/FLARe/DeCoRAM/experiments/packing/processor_util.sh
index 2108a4a2fc9..e3b7eb7edb1 100755
--- a/TAO/orbsvcs/examples/FaultTolerance/FLARe/DeCoRAM/experiments/packing/processor_util.sh
+++ b/TAO/orbsvcs/examples/FaultTolerance/FLARe/DeCoRAM/experiments/packing/processor_util.sh
@@ -1,4 +1,4 @@
-#!/bin/bash
+zf#!/bin/bash
 EXPERIMENT_NAME=processor_util
 DECORAM_BIN=../../bin
 DATA_DIR=$1
@@ -7,7 +7,7 @@ RESULT_DIR=$DATA_DIR/$EXPERIMENT_NAME
 if [ ! -d ./$DATA_DIR ]; then echo Directory $DATA_DIR does not exist && exit; fi
 if [ ! -d ./$RESULT_DIR ]; then mkdir -p ./$RESULT_DIR; fi
 
-for ALGORITHM in bftrmff pkftrmff fpftrmff; do \
+for ALGORITHM in pftrmff bftrmff frftrmff; do \
   for TASK_NO in 10 20 40 80 160; do \
     echo "$TASK_NO tasks:" >> ./$RESULT_DIR/$EXPERIMENT_NAME-$ALGORITHM.dat && \
     for BACKUP_NO in 1 2 3 4 5; do \
diff --git a/TAO/orbsvcs/examples/FaultTolerance/FLARe/DeCoRAM/src/Algorithms.cpp b/TAO/orbsvcs/examples/FaultTolerance/FLARe/DeCoRAM/src/Algorithms.cpp
index f70d0febebe..dae94e0ee65 100644
--- a/TAO/orbsvcs/examples/FaultTolerance/FLARe/DeCoRAM/src/Algorithms.cpp
+++ b/TAO/orbsvcs/examples/FaultTolerance/FLARe/DeCoRAM/src/Algorithms.cpp
@@ -178,4 +178,3 @@ PrimaryConversion::operator () (const Task & task)
 
   return t;
 }
-
diff --git a/TAO/orbsvcs/examples/FaultTolerance/FLARe/DeCoRAM/src/CTT_Enhanced.cpp b/TAO/orbsvcs/examples/FaultTolerance/FLARe/DeCoRAM/src/CTT_Enhanced.cpp
index eb354bff8bd..41d8212439b 100644
--- a/TAO/orbsvcs/examples/FaultTolerance/FLARe/DeCoRAM/src/CTT_Enhanced.cpp
+++ b/TAO/orbsvcs/examples/FaultTolerance/FLARe/DeCoRAM/src/CTT_Enhanced.cpp
@@ -21,8 +21,6 @@ CTT_Enhanced::~CTT_Enhanced ()
 double
 CTT_Enhanced::operator () (const TASK_LIST & tasks)
 {
-  TRACE ("(" << tasks << ")");
-
   // copy tasks for local modifications
   TASK_LIST scheduled_tasks = tasks;
 
@@ -34,10 +32,15 @@ CTT_Enhanced::operator () (const TASK_LIST & tasks)
       Task t = scheduled_tasks [scheduled_tasks.size () - 1];
       scheduled_tasks.pop_back ();
 
+      double wcrt = this->worst_case_response_time_check (t, scheduled_tasks);
+
+      TRACE ("(" << tasks << ") = " << wcrt);
+
       // return the wcrt for this task
-      return this->worst_case_response_time_check (t, scheduled_tasks);
+      return wcrt;
     }
 
+  TRACE ("(" << tasks << ") = 0");
   return .0;
 }
 
diff --git a/TAO/orbsvcs/examples/FaultTolerance/FLARe/DeCoRAM/src/DeCoRAM.mpc b/TAO/orbsvcs/examples/FaultTolerance/FLARe/DeCoRAM/src/DeCoRAM.mpc
index 66ee46ec688..01e51783f18 100644
--- a/TAO/orbsvcs/examples/FaultTolerance/FLARe/DeCoRAM/src/DeCoRAM.mpc
+++ b/TAO/orbsvcs/examples/FaultTolerance/FLARe/DeCoRAM/src/DeCoRAM.mpc
@@ -1,6 +1,21 @@
-project (basic_ftrmff) {
+project (primary_ftrmff) {
 
-  exename = bftrmff
+  exename = pftrmff
+  exeout = ../bin
+  macros += DO_DEBUG
+
+  Source_Files {
+    Algorithms.cpp
+    Schedule.cpp
+    CTT_Basic.cpp
+    FTRMFF_Primary.cpp
+    primary_ftrmff.cpp
+  }
+}
+
+project (active_ftrmff) {
+
+  exename = aftrmff
   exeout = ../bin
   macros += DO_DEBUG
 
@@ -34,11 +49,11 @@ project (statesync_only_ftrmff) {
   }
 }
 
-project (enhanced_ftrmff) {
+project (unranked_ftrmff) {
 
   after += statesync_only_ftrmff
 
-  exename = eftrmff
+  exename = uftrmff
   exeout = ../bin
   macros += DO_DEBUG
 
@@ -56,7 +71,7 @@ project (enhanced_ftrmff) {
 
 project (ranked_ftrmff) {
 
-  after += enhanced_ftrmff
+  after += unranked_ftrmff
 
   exename = rftrmff
   exeout = ../bin
@@ -76,9 +91,9 @@ project (ranked_ftrmff) {
   }
 }
 
-project (bestfit_ftrmff) {
+project (worstfit_ranked_ftrmff) {
 
-  exename = ftrmbf
+  exename = rftrmwf
   exeout = ../bin
 
   macros += DO_DEBUG
@@ -96,9 +111,9 @@ project (bestfit_ftrmff) {
   }
 }
 
-project (binary_ftrmff) {
+project (binary_ranked_ftrmff) {
 
-  exename = bsftrmff
+  exename = bsftrmwf
   exeout = ../bin
 
   macros += DO_DEBUG
@@ -120,9 +135,9 @@ project (binary_ftrmff) {
   }
 }
 
-project (packing_ftrmff) {
+project (backward_packing_ftrmff) {
 
-  exename = pkftrmff
+  exename = bpftrmff
   exeout = ../bin
 
   macros += DO_DEBUG
@@ -153,10 +168,31 @@ project (forward_packing_ftrmff) {
     Scheduler.cpp
     Packing_Scheduler.cpp
     FTRMFF_Forward_Packing.cpp
+    Forward_Ranking_Scheduler.cpp
     forward_packing_ftrmff.cpp
   }
 }
 
+project (forward_ranking_ftrmff) {
+
+  exename = frftrmff
+  exeout = ../bin
+
+  macros += DO_DEBUGu
+
+  Source_Files {
+    Algorithms.cpp
+    Schedule.cpp
+    CTT_Basic.cpp
+    CTT_Enhanced.cpp
+    Scheduler.cpp
+    Packing_Scheduler.cpp
+    Forward_Ranking_Scheduler.cpp
+    FTRMFF_Forward_Packing.cpp
+    forward_ranking_ftrmff.cpp
+  }
+}
+
 project (schedulability_check) : acelib {
 
   exename = scheck
diff --git a/TAO/orbsvcs/examples/FaultTolerance/FLARe/DeCoRAM/src/FTRMFF_Forward_Packing.cpp b/TAO/orbsvcs/examples/FaultTolerance/FLARe/DeCoRAM/src/FTRMFF_Forward_Packing.cpp
index f5558b1d975..4459149188d 100644
--- a/TAO/orbsvcs/examples/FaultTolerance/FLARe/DeCoRAM/src/FTRMFF_Forward_Packing.cpp
+++ b/TAO/orbsvcs/examples/FaultTolerance/FLARe/DeCoRAM/src/FTRMFF_Forward_Packing.cpp
@@ -13,6 +13,14 @@
 #include <sstream>
 #include "FTRMFF_Forward_Packing.h"
 
+#include "Forward_Ranking_Scheduler.h"
+#include "Packing_Scheduler.h"
+
+FTRMFF_Forward_Packing::FTRMFF_Forward_Packing (const std::string & algorithm)
+  : algorithm_ (algorithm)
+{
+}
+
 FTRMFF_Forward_Packing::~FTRMFF_Forward_Packing ()
 {
 }
@@ -21,7 +29,8 @@ FTRMFF_Output
 FTRMFF_Forward_Packing::operator () (const FTRMFF_Input & input)
 {
   FTRMFF_Forward_Packing_Algorithm algorithm (input.processors,
-                                              input.backup_count);
+                                              input.backup_count,
+                                              algorithm_);
 
   FTRMFF_Output output;
   output.schedule = algorithm (input.tasks);
@@ -34,10 +43,20 @@ FTRMFF_Forward_Packing::operator () (const FTRMFF_Input & input)
 
 FTRMFF_Forward_Packing_Algorithm::FTRMFF_Forward_Packing_Algorithm (
   const PROCESSOR_LIST & processors,
-  unsigned int consistency_level)
-  : consistency_level_ (consistency_level),
-    scheduler_ (processors, consistency_level)
+  unsigned int consistency_level,
+  const std::string & scheduler)
+  : consistency_level_ (consistency_level)
 {
+  if (scheduler == "Forward_Ranking")
+    {
+      scheduler_.reset (new Forward_Ranking_Scheduler (processors,
+                                                       consistency_level_));
+    }
+  else
+    {
+      scheduler_.reset (new Packing_Scheduler (processors,
+                                               consistency_level_));
+    }
 }
 
 FTRMFF_Forward_Packing_Algorithm::~FTRMFF_Forward_Packing_Algorithm ()
@@ -46,7 +65,7 @@ FTRMFF_Forward_Packing_Algorithm::~FTRMFF_Forward_Packing_Algorithm ()
 
 SCHEDULING_MAP
 FTRMFF_Forward_Packing_Algorithm::operator () (const TASK_LIST & tasks)
-{
+{  
   // sort tasks based on their periods, which results in a priority
   // ordered list since we do rate monotonic scheduling
   TASK_LIST sorted_input = tasks;
@@ -67,7 +86,7 @@ FTRMFF_Forward_Packing_Algorithm::operator () (const TASK_LIST & tasks)
            task_it != task_group.end ();
            ++task_it)
         {
-          ScheduleResult r = scheduler_ (*task_it);
+          ScheduleResult r = (*scheduler_) (*task_it);
           if (r.wcrt <= .0)
             {
               ScheduleProgress pg = {*task_it, 
@@ -80,7 +99,7 @@ FTRMFF_Forward_Packing_Algorithm::operator () (const TASK_LIST & tasks)
         }
     }
 
-  return transform_schedule (scheduler_.schedule ());
+  return transform_schedule (scheduler_->schedule ());
 }
 
 SCHEDULE_PROGRESS_LIST
@@ -92,7 +111,7 @@ FTRMFF_Forward_Packing_Algorithm::get_unschedulable ()
 SCHEDULE
 FTRMFF_Forward_Packing_Algorithm::schedule () const
 {
-  return scheduler_.schedule ();
+  return scheduler_->schedule ();
 }
 
 TASK_LIST 
diff --git a/TAO/orbsvcs/examples/FaultTolerance/FLARe/DeCoRAM/src/FTRMFF_Forward_Packing.h b/TAO/orbsvcs/examples/FaultTolerance/FLARe/DeCoRAM/src/FTRMFF_Forward_Packing.h
index f0844934a94..be8a3c5b4aa 100644
--- a/TAO/orbsvcs/examples/FaultTolerance/FLARe/DeCoRAM/src/FTRMFF_Forward_Packing.h
+++ b/TAO/orbsvcs/examples/FaultTolerance/FLARe/DeCoRAM/src/FTRMFF_Forward_Packing.h
@@ -13,15 +13,18 @@
 #ifndef FTRMFF_FORWARD_PACKING_ALGORITHM_H_
 #define FTRMFF_FORWARD_PACKING_ALGORITHM_H_
 
-#include "Schedule.h"
-#include "Packing_Scheduler.h"
+#include "Scheduler.h"
 
 class FTRMFF_Forward_Packing : public FTRMFF_Algorithm
 {
 public:
+  FTRMFF_Forward_Packing (const std::string & algorithm = "Forward_Packing");
+
   virtual ~FTRMFF_Forward_Packing ();
 
   virtual FTRMFF_Output operator () (const FTRMFF_Input & input);
+private:
+  std::string algorithm_;
 };
 
 class FTRMFF_Forward_Packing_Algorithm : 
@@ -30,7 +33,8 @@ class FTRMFF_Forward_Packing_Algorithm :
 {
 public:
   FTRMFF_Forward_Packing_Algorithm (const PROCESSOR_LIST & processors,
-                                    unsigned int consistency_level);
+                                    unsigned int consistency_level,
+                                    const std::string & scheduler);
 
   virtual ~FTRMFF_Forward_Packing_Algorithm ();
 
@@ -45,7 +49,7 @@ private:
 private:
   SCHEDULE_PROGRESS_LIST unschedulable_;
   unsigned int consistency_level_;
-  Packing_Scheduler scheduler_;
+  std::auto_ptr<Scheduler> scheduler_;
 };
 
 #endif /* FTRMFF_FORWARD_PACKING_ALGORITHM_H_ */
diff --git a/TAO/orbsvcs/examples/FaultTolerance/FLARe/DeCoRAM/src/Forward_Ranking_Scheduler.cpp b/TAO/orbsvcs/examples/FaultTolerance/FLARe/DeCoRAM/src/Forward_Ranking_Scheduler.cpp
new file mode 100644
index 00000000000..08e46b73165
--- /dev/null
+++ b/TAO/orbsvcs/examples/FaultTolerance/FLARe/DeCoRAM/src/Forward_Ranking_Scheduler.cpp
@@ -0,0 +1,380 @@
+// -*- C++ -*-
+
+//=============================================================================
+/**
+ *  @file    Foward_Ranking_Scheduler.cpp
+ *
+ *  $Id$
+ *
+ *  @author  Friedhelm Wolf (fwolf@dre.vanderbilt.edu)
+ */
+//=============================================================================
+
+#include <numeric>
+#include "Forward_Ranking_Scheduler.h"
+#include "Combination_T.h"
+
+Forward_Ranking_Scheduler::Forward_Ranking_Scheduler (
+  const PROCESSOR_LIST & processors,
+  unsigned int max_failures)
+  : Scheduler (processors, max_failures)
+{
+}
+
+double
+Forward_Ranking_Scheduler::schedule_task (const Task & task,
+                                          const Processor & processor)
+{
+  TRACE ("(" << task << "," << processor << ")");
+
+  // check if there is already a replica of this task on the processor
+  if (this->check_for_existing_replicas (task, processor))
+    {
+      TRACE ("already contains replica of \"" << primary_name (task) << "\"");
+      return .0;
+    }
+
+  // add task to local copy of the processor tasks
+  TASK_LIST local_tasks = schedule_[processor];
+  local_tasks.push_back (task);
+
+  TRACE ("Tasks: " << local_tasks);
+
+  // determine processors that need to fail necessarily to become active
+  // this applies only for backups and depends on their rank
+  PROCESSOR_SET fixed_failures = this->replica_processors (task);
+
+  TRACE ("Fixed Failures: " << fixed_failures);
+
+  // find other processors that affect the backups on this processor
+  // if they fail
+  PROCESSOR_SET additional_failures = 
+    this->relevant_processors (local_tasks,
+                               fixed_failures);
+
+  TRACE ("Additional Failures: " << additional_failures);
+
+  PROCESSOR_SETS failure_scenarios = 
+    this->permute_processors (fixed_failures,
+                              additional_failures,
+                              max_failures_ - fixed_failures.size ());
+
+  TRACE ("Relevant Failure Scenarios: " << failure_scenarios);
+
+  TASK_SCENARIOS activation_scenarios = 
+    this->activate_tasks (local_tasks,
+                          failure_scenarios);
+
+  TRACE ("Task Scenarios: " << activation_scenarios);
+
+  double wcrt = this->accumulate_wcrt (activation_scenarios);
+
+  TRACE ("Maximum wcrt: " << wcrt);
+
+  return wcrt;
+}
+
+bool 
+Forward_Ranking_Scheduler::check_for_existing_replicas (
+  const Task & task,
+  const Processor & processor)
+{
+  TASK_POSITIONS replica_group = 
+    replica_groups_[primary_name (task)];
+      
+  return std::accumulate (replica_group.begin (),
+                          replica_group.end (),
+                          false,
+                          ProcessorNameComparison (processor));
+}
+
+class ReplicaFinder : public std::unary_function <Task,
+                                                  PROCESSOR_SET>
+{
+public:
+  ReplicaFinder (const REPLICA_GROUPS & rep_groups)
+    : rep_groups_ (rep_groups) {}
+
+  PROCESSOR_SET operator () (const Task & task)
+  {
+    PROCESSOR_SET result;
+
+    REPLICA_GROUPS::const_iterator replicas = 
+      rep_groups_.find (primary_name (task));
+ 
+    if (replicas != rep_groups_.end ())
+      {
+        std::transform (replicas->second.begin (),
+                        replicas->second.begin () + task.rank,
+                        std::inserter (result,
+                                       result.begin ()),
+                        ProcessorPicker ());
+      }
+
+    return result;
+  }
+
+private:
+  const REPLICA_GROUPS rep_groups_;
+};
+
+PROCESSOR_SET
+Forward_Ranking_Scheduler::replica_processors (const Task & task)
+{
+  ReplicaFinder finder (replica_groups_);
+
+  return finder (task);
+}
+
+class RelevantProcessorAccumulator : std::binary_function <PROCESSOR_SET,
+                                                           Task,
+                                                           PROCESSOR_SET>
+{
+public:
+  RelevantProcessorAccumulator (const REPLICA_GROUPS & rep_groups)
+    : rep_groups_ (rep_groups)
+  {
+  }
+
+  PROCESSOR_SET operator () (const PROCESSOR_SET & previous,
+                             const Task & task)
+  {
+    PROCESSOR_SET result = previous;
+    
+    std::transform (rep_groups_.find (primary_name (task))->second.begin (),
+                    rep_groups_.find (primary_name (task))->second.begin () + task.rank,
+                    std::inserter (result,
+                                   result.begin ()),
+                    ProcessorPicker ());
+
+    return result;
+  }
+
+private:
+  const REPLICA_GROUPS & rep_groups_;
+};
+
+PROCESSOR_SET 
+Forward_Ranking_Scheduler::relevant_processors (
+  const TASK_LIST & tasks,
+  const PROCESSOR_SET & ignored_processors)
+{
+  PROCESSOR_SET relevant =  
+    std::accumulate (tasks.begin (),
+                     tasks.end (),
+                     PROCESSOR_SET (),
+                     RelevantProcessorAccumulator (replica_groups_));
+
+  PROCESSOR_SET result;
+
+  // remove the processors from the result that should not be
+  // permutated here
+  std::set_difference (relevant.begin (),
+                       relevant.end (),
+                       ignored_processors.begin (),
+                       ignored_processors.end (),
+                       std::inserter (result,
+                                      result.begin ()));
+
+  return result;
+}
+
+PROCESSOR_SETS
+Forward_Ranking_Scheduler::permute_processors (
+  const PROCESSOR_SET & fixed,
+  const PROCESSOR_SET & exchangeable,
+  unsigned int failure_number)
+{
+  PROCESSOR_SETS failure_sets;
+  PROCESSOR_LIST combination;
+  unsigned int tupel_size = 
+    std::min (failure_number,
+              static_cast <unsigned int> (exchangeable.size ()));
+
+  PROCESSOR_SET::iterator it = exchangeable.begin ();
+  for (unsigned int c_index = 0; 
+       c_index < tupel_size; 
+       ++c_index, ++it)
+    {
+      combination.push_back (*it);
+    }
+
+  PROCESSOR_LIST failure_elements;
+  std::copy (exchangeable.begin (),
+             exchangeable.end (),
+             std::inserter (failure_elements,
+                            failure_elements.begin ()));
+
+  do
+    {
+      PROCESSOR_SET set;
+      // add a permutation of the relevant failures
+      std::copy (combination.begin (),
+                 combination.end (),
+                 std::inserter (set,
+                                set.begin ()));
+
+      // add the fixed aspects
+      std::copy (fixed.begin (),
+                 fixed.end (),
+                 std::inserter (set,
+                                set.begin ()));
+
+      failure_sets.push_back (set);
+    }
+  while (next_combination (failure_elements.begin (),
+                           failure_elements.end (),
+                           combination.begin (),
+                           combination.end ()));
+
+  return failure_sets;
+}
+
+class ActivateFailedTask : public std::unary_function <PROCESSOR_SET,
+                                                       Task>
+{
+public:
+  ActivateFailedTask (const PROCESSOR_SET & failures,
+                      const REPLICA_GROUPS & rep_groups)
+    : failures_ (failures),
+      rep_groups_ (rep_groups),
+      find_replicas_ (rep_groups_) {}
+
+  Task operator () (const Task & task)
+  {
+    // check in the replica map if all previous tasks get activated
+    // and switch the task to primary if this is the case
+    PROCESSOR_SET necessary_failures = find_replicas_ (task);
+
+    PROCESSOR_SET difference;
+    std::set_intersection (failures_.begin (),
+                           failures_.end (),
+                           necessary_failures.begin (),
+                           necessary_failures.end (),
+                           std::inserter (difference,
+                                          difference.begin ()));
+
+    // If all necessary processors are failing, make the task primary.
+    // This is the case if all necessary_failures are contained in the
+    // difference set.
+    if (difference.size () == necessary_failures.size ())
+      return convert_ (task);
+
+    return task;
+  }
+
+private:
+  const PROCESSOR_SET & failures_;
+  const REPLICA_GROUPS & rep_groups_;  
+  PrimaryConversion convert_;
+  ReplicaFinder find_replicas_;
+};
+
+class ActivateFailedTasks : public std::unary_function <PROCESSOR_SET,
+                                                        TASK_LIST>
+{
+public:
+  ActivateFailedTasks (const TASK_LIST & tasks,
+                       const REPLICA_GROUPS & rep_groups)
+    : tasks_ (tasks),
+      rep_groups_ (rep_groups) {}
+
+  TASK_LIST operator () (const PROCESSOR_SET & scenario)
+  {
+    TASK_LIST result;
+
+    // for each backup check whether it is activated
+    std::transform (tasks_.begin (),
+                    tasks_.end (),
+                    std::inserter (result,
+                                   result.begin ()),
+                    ActivateFailedTask (scenario,
+                                        rep_groups_));
+
+    return result;
+  }
+
+private:
+  const TASK_LIST & tasks_;
+  const REPLICA_GROUPS & rep_groups_;
+};
+
+TASK_SCENARIOS 
+Forward_Ranking_Scheduler::activate_tasks (const TASK_LIST & tasks,
+                                           const PROCESSOR_SETS & failures)
+{
+  TASK_SCENARIOS result;
+
+  // add an empty one for the primary case
+  result.push_back (tasks);
+
+  // add a case for each failure scenario
+  std::transform (failures.begin (),
+                  failures.end (),
+                  std::inserter (result,
+                                 result.begin ()),
+                  ActivateFailedTasks (tasks,
+                                       replica_groups_));
+
+  return result;
+}
+
+class WCRTAccumulator : public std::binary_function <double,
+                                                     TASK_LIST,
+                                                     double>
+{
+public:
+  double operator () (double previous,
+                      const TASK_LIST & tasks)
+  {
+    double result = ctt_ (tasks);
+
+    if ((result > .0) && (previous != .0))
+      return std::max(result,
+                      previous);
+    else
+      return .0;
+  }
+
+private:
+  CTT_Enhanced ctt_;
+};
+
+double
+Forward_Ranking_Scheduler::accumulate_wcrt (const TASK_SCENARIOS & scenarios)
+{
+  return std::accumulate (scenarios.begin (),
+                          scenarios.end (),
+                          -1.0,
+                          WCRTAccumulator ());
+}
+
+std::ostream & operator<< (std::ostream & ostr, 
+                           const PROCESSOR_SETS & ps)
+{
+  ostr << "{";
+  for (PROCESSOR_SETS::const_iterator it = ps.begin ();
+       it != ps.end ();
+       ++it)
+    {
+      ostr << *it << "| ";
+    }
+  ostr << "}";
+
+  return ostr;
+}
+
+std::ostream & operator<< (std::ostream & ostr, 
+                           const TASK_SCENARIOS & ts)
+{
+  ostr << "{";
+  for (TASK_SCENARIOS::const_iterator it = ts.begin ();
+       it != ts.end ();
+       ++it)
+    {
+      ostr << *it << "| ";
+    }
+  ostr << "}";
+
+  return ostr;  
+}
diff --git a/TAO/orbsvcs/examples/FaultTolerance/FLARe/DeCoRAM/src/Forward_Ranking_Scheduler.h b/TAO/orbsvcs/examples/FaultTolerance/FLARe/DeCoRAM/src/Forward_Ranking_Scheduler.h
new file mode 100644
index 00000000000..6174361e835
--- /dev/null
+++ b/TAO/orbsvcs/examples/FaultTolerance/FLARe/DeCoRAM/src/Forward_Ranking_Scheduler.h
@@ -0,0 +1,61 @@
+// -*- C++ -*-
+
+//=============================================================================
+/**
+ *  @file    Foward_Ranking_Scheduler.h
+ *
+ *  $Id$
+ *
+ *  @author  Friedhelm Wolf (fwolf@dre.vanderbilt.edu)
+ */
+//=============================================================================
+
+#ifndef FORWARD_RANKING_SCHEDULER_H_
+#define FORWARD_RANKING_SCHEDULER_H_
+
+#include "Scheduler.h"
+#include "CTT_Enhanced.h"
+
+typedef std::list<PROCESSOR_SET> PROCESSOR_SETS;
+
+typedef std::list<TASK_LIST> TASK_SCENARIOS;
+
+class Forward_Ranking_Scheduler : public Scheduler
+{
+public:
+  /// default ctor
+  Forward_Ranking_Scheduler (const PROCESSOR_LIST & processors,
+                             unsigned int max_failures);
+
+  virtual double schedule_task (const Task & task,
+                                const Processor & processor);
+private:
+  bool check_for_existing_replicas (const Task & task,
+                                     const Processor & processor);
+
+  PROCESSOR_SET replica_processors (const Task & task);
+
+  PROCESSOR_SET relevant_processors (const TASK_LIST & tasks,
+                                     const PROCESSOR_SET & ignored_processors);
+
+  PROCESSOR_SETS permute_processors (const PROCESSOR_SET & fixed,
+                                     const PROCESSOR_SET & exchangeable,
+                                     unsigned int failure_number);
+
+  TASK_SCENARIOS activate_tasks (const TASK_LIST & tasks,
+                                 const PROCESSOR_SETS & failures);
+
+  double accumulate_wcrt (const TASK_SCENARIOS & scenarios);
+
+private:
+  CTT_Enhanced ctt_;
+};
+
+// streaming operators for data structures defined in this header
+std::ostream & operator<< (std::ostream & ostr, 
+                           const PROCESSOR_SETS & ps);
+
+std::ostream & operator<< (std::ostream & ostr, 
+                           const TASK_SCENARIOS & ts);
+
+#endif /* FORWARD_RANKING_SCHEDULER_H_ */
diff --git a/TAO/orbsvcs/examples/FaultTolerance/FLARe/DeCoRAM/src/Scheduler.cpp b/TAO/orbsvcs/examples/FaultTolerance/FLARe/DeCoRAM/src/Scheduler.cpp
index 4f623270b3a..6c7459d8aa1 100644
--- a/TAO/orbsvcs/examples/FaultTolerance/FLARe/DeCoRAM/src/Scheduler.cpp
+++ b/TAO/orbsvcs/examples/FaultTolerance/FLARe/DeCoRAM/src/Scheduler.cpp
@@ -92,6 +92,24 @@ Scheduler::schedule (void) const
   return schedule_;
 }
 
+ProcessorNameComparison::ProcessorNameComparison (const Processor & p)
+  :p_ (p)
+{
+}
+
+Processor 
+ProcessorPicker::operator () (const TASK_POSITIONS::value_type & entry)
+{
+  return entry.first;
+}
+
+bool
+ProcessorNameComparison::operator () (bool equal, 
+                                      const TASK_POSITIONS::value_type & pos)
+{
+  return (equal || (pos.first.compare (p_) == 0));
+}
+
 std::ostream & operator<< (std::ostream & ostr, 
                            const TASK_POSITION & tp)
 {
diff --git a/TAO/orbsvcs/examples/FaultTolerance/FLARe/DeCoRAM/src/Scheduler.h b/TAO/orbsvcs/examples/FaultTolerance/FLARe/DeCoRAM/src/Scheduler.h
index 4bcd4685431..ac4ede69472 100644
--- a/TAO/orbsvcs/examples/FaultTolerance/FLARe/DeCoRAM/src/Scheduler.h
+++ b/TAO/orbsvcs/examples/FaultTolerance/FLARe/DeCoRAM/src/Scheduler.h
@@ -55,7 +55,41 @@ protected:
   REPLICA_GROUPS replica_groups_;
 };
 
+/*** Helper classes and operators ***/
 
+/**
+ * @class ProcessorNameComparison 
+ *
+ * @brief Can be used with the accumulate algorithm to find out if a
+ *        processor name belongs to a list of task positions
+ */
+class ProcessorNameComparison : public std::binary_function <
+  bool,
+  TASK_POSITIONS::value_type,
+  bool>
+{
+public:
+  ProcessorNameComparison (const Processor & p);
+
+  bool operator () (bool equal, const TASK_POSITIONS::value_type & pos);
+private:
+  Processor p_;
+};
+
+/**
+ * @class ProcessorPicker
+ * 
+ * @brief can be used within transform to extract the 
+ *        processor names from a TASK_POSITIONS structure.
+ */
+class ProcessorPicker : public std::unary_function<REPLICA_GROUPS::value_type,
+                                                   Processor>
+{
+public:
+  Processor operator () (const TASK_POSITIONS::value_type & entry);
+};
+
+// streaming operators for used data structures
 std::ostream & operator<< (std::ostream & ostr, 
                            const TASK_POSITION & tp);
 
diff --git a/TAO/orbsvcs/examples/FaultTolerance/FLARe/DeCoRAM/src/primary_ftrmff.cpp b/TAO/orbsvcs/examples/FaultTolerance/FLARe/DeCoRAM/src/primary_ftrmff.cpp
new file mode 100644
index 00000000000..ec815d3a013
--- /dev/null
+++ b/TAO/orbsvcs/examples/FaultTolerance/FLARe/DeCoRAM/src/primary_ftrmff.cpp
@@ -0,0 +1,80 @@
+// -*- C++ -*-
+
+//=============================================================================
+/**
+ *  @file    basic_ftrmff.cpp
+ *
+ *  $Id$
+ *
+ *  @author  Friedhelm Wolf (fwolf@dre.vanderbilt.edu)
+ */
+//=============================================================================
+
+#include <fstream>
+#include <sstream>
+#include <iostream>
+#include <ace/Get_Opt.h>
+#include "FTRMFF_Primary.h"
+
+std::string filename = "test.sd"; // filename of task list input
+unsigned int m = 4; // number of processors
+unsigned int c = 2; // consitency level
+
+int ACE_TMAIN (int argc, ACE_TCHAR *argv[])
+{
+  if (argc > 1)
+    filename = argv[1];
+
+  if (argc > 2)
+    m = atoi (argv[2]);
+
+  if (argc > 3)
+    c = atoi (argv[3]);
+
+  TASK_LIST tasks;
+  PROCESSOR_LIST procs;
+  for (unsigned int i = 1; i <= m; ++i)
+    {
+      std::stringstream ss;
+      ss << "P";
+      if (i < 10)
+        ss << "00";
+      else if (i < 100)
+        ss << "0";
+      ss << i;
+      procs.push_back (ss.str ());
+    }
+
+  std::ifstream ifile;
+  ifile.open (filename.c_str ());
+
+  std::transform (
+    std::istream_iterator <std::string> (ifile),
+    std::istream_iterator <std::string> (),
+    std::inserter <TASK_LIST> (tasks,
+                               tasks.begin ()),
+    string_to_task ());
+  
+  ifile.close ();
+
+  FTRMFF_Primary ftrmff;
+
+  FTRMFF_Input input;
+  input.tasks = tasks;
+  input.processors = procs;
+  input.backup_count = c;
+  FTRMFF_Output result = ftrmff (input);
+
+  if (result.unscheduled_tasks.size () > 0)
+    {
+      std::cout << "Could not schedule :"
+                << std::endl
+                << result.unscheduled_tasks
+                << std::endl;
+
+      return 1;
+    }
+
+  return 0;
+}
+