Scheduler.h

Go to the documentation of this file.

// ----------------------------------------------------------------------------
//
// $Id$
//
// Copyright 2008, 2009, 2010, 2011, 2012  Antonio Franchi and Paolo Stegagno    
//
// This file is part of MIP.
//
// MIP is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// MIP is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with MIP. If not, see <http://www.gnu.org/licenses/>.
//
// Contact info: antonio.franchi@tuebingen.mpg.de stegagno@diag.uniroma1.it
//
// ----------------------------------------------------------------------------






/* @{ */


#ifndef __SCHEDULER_H_
#define __SCHEDULER_H_

#include <FifoTerm.h>
#include <LogTrace.h>
#include <Task.h>
#include <TaskFactory.h>
#include <Resource.h>
#include <ResourceFactory.h>
#include <dlfcn.h>

using namespace MipTasks;

class SchedulerStatus{
 public:
  bool isScheduling;
  Decimal frequency;
  
  SchedulerStatus(){
   isScheduling = false;
   frequency = 0.0;
  }
};

class Scheduler: public MIPObject{
 private:
  TasksPointers   _scheduledTasks;   
  ResourcePointers _scheduledResources; 
  TasksPPointers  _tasksUnloadList;   
  ResourcePPointers _resourcesUnloadList; 
  int argc;
  const char** argv;
  
  vector<destroy_task*> pluginTaskDestroyers;
  vector<destroy_resource*> pluginResourceDestroyers;
  
  bool checkResPlate(ResourcePlate plate,Resource* resource);
  
  template <class ResourceType> void resourceLoader(ResourcePlate plate){
   Resource* resource = new ResourceType(argc,argv);/* polymorph */
    checkResPlate(plate,resource); /* check its plate */
   stringstream ss;
   ss << "Loaded resource " << ResourceNames[resource->getPlate()] << " ("<< (long int) resource << ")";
   debug(1,ss.str());
   _scheduledResources.push_back(resource);
   _resourcesUnloadList.push_back(&resource);
   
  }

  template <class ResourceType> void resourceUnloader(Resource* resource){
   ResourceType* realResource = (ResourceType*) resource;
   stringstream ss;
   ss << "Deleting resource " << ResourceNames[resource->getPlate()] << " ("<< (long int) resource << ")";
   debug(1,ss.str());
   delete realResource;
  }
  
  void resourcePluginLoader(string &resourceName, string &libraryName);
  
  bool checkTaskPlate(TaskPlate plate,Task* task);
  
  template <class TaskType> void taskLoader(TaskPlate plate){
   Task* task = new TaskType(_scheduledResources,argc,argv);
   checkTaskPlate(plate,task);
   stringstream ss;
   ss << "Loaded task " << TaskNames[task->getPlate()];
   debug(1,ss.str());
   _scheduledTasks.push_back(task); /*polymorph */
   _tasksUnloadList.push_back(&task);
  }
  
  void newtaskLoaderKbHitTask();
  
  
  void taskPluginLoader(string &taskName, string &libraryName);
  
  template <class TaskType> void taskUnloader(Task* task){
    TaskType* realTask = (TaskType*) task;
   stringstream ss;
   ss << "Deleting task " << TaskNames[task->getPlate()]; 
   debug(1,ss.str());
    delete realTask;
  }
  
  void loadResources(const ResourcePlates& resourcePlates);
  void unloadResources();
  void loadPluginResources(vector<string> &plResourceNames, vector<string> &plResourceLibs);
  void unloadPluginResources();
  void loadTasks(const TaskPlates& taskPlates);
  void unloadTasks();
  void loadTasksPlugins(vector<string> &plTaskNames, vector<string> &plTaskLibs);
  void unloadPluginTasks();
  
  
  string getObjectName() const;
  
 public:
  SchedulerStatus status;
  
  Scheduler(const ResourcePlates& resourcePlates,const TaskPlates& taskPlates, vector<string> &plResourceNames, vector<string> &plResourceLibs, vector<string> &plTaskNames, vector<string> &plTaskLibs, int pargc, const char* pargv[]);
  
  ~Scheduler();
  
  void schedule(unsigned long int cycles,Time minCycleDuration);
  
  bool getResourcePointers(ResourcePointers &rp);
};

#endif

/* @} */