Vogon Fleet: implementation: Added environment, concrete_environment, a

placeholder for the ready queue, needed by environment, and factorized
stubs for tests in a separate directory. Updated makefile including environment, concrete_environment, ready_queue, but NOT the stubs and/or the tests.


git-svn-id: svn://svn.gna.org/svn/sgpemv2/trunk@685 3ecf2c5c-341e-0410-92b4-d18e462d057c

src/backend/concrete_environment.cc

@@ -0,0 +1,149 @@
+// src/backend/resource.cc - Copyright 2005, 2006, University
+//               of Padova, dept. of Pure and Applied
+//               Mathematics
+//
+// This file is part of SGPEMv2.
+//
+// This 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 2 of the License, or
+// (at your option) any later version.
+//
+// SGPEMv2 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 SGPEMv2; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+#include "concrete_environment.hh"
+#include <iterator>
+
+using namespace sgpem;
+
+
+
+ConcreteEnvironment::ConcreteEnvironment()
+{
+  // Nothing to do here. Really.
+}
+
+
+
+ConcreteEnvironment::ConcreteEnvironment(const ConcreteEnvironment & c) :
+  Environment(c), _sched_queue(c._sched_queue)
+{
+  // DynamicRequest objects never change, so there is no need to keep
+  // a separate copy for each instant of the simulation, therefore
+  // we simply copy the map.
+  // Actually we may even avoid copiying the map, but this would not
+  // be worth the effort (too much code to change)
+  // Anyway, this causes much trouble when coming to destruction, see.
+  _resources = c._resources;
+
+  // DynamicProcess object need to be copied.
+  // The deep copy is guaranteed by the DynamicProcess copy constructor
+  std::vector<Process *>::const_iterator iter = c._processes.begin();
+  while (iter != c._processes.end())
+  {
+    DynamicProcess * current = dynamic_cast<DynamicProcess *>(*iter++);
+    _processes.push_back(new DynamicProcess(*current));
+  }
+
+  // The ready queue needs to be copied, too.
+  // This implementation relies on the copy constructor
+  // which is explicit in the initialization list
+}
+
+
+
+const std::vector<Process *>
+ConcreteEnvironment::get_processes() const
+{
+  return _processes;
+}
+
+
+
+std::vector<Process *>
+ConcreteEnvironment::get_processes()
+{
+  return _processes;
+}
+
+
+
+const std::map<int, Resource *>
+ConcreteEnvironment::get_resources() const
+{
+  return _resources;
+}
+
+
+
+std::map<int, Resource *>
+ConcreteEnvironment::get_resources()
+{
+  return _resources;
+}
+
+
+
+const std::vector<Request *>
+ConcreteEnvironment::get_request_queue(Resource * resource) const
+{
+  std::vector<Request *> request_queue;
+  // TODO: fill that vector, walking over the classes, looking for
+  // those no-more-valid requests.
+  return request_queue;
+}
+
+
+
+const ReadyQueue *
+ConcreteEnvironment::get_sorted_queue() const
+{
+  return &_sched_queue;
+}
+
+
+
+ReadyQueue *
+ConcreteEnvironment::get_sorted_queue()
+{
+  return &_sched_queue;
+}
+
+
+
+ConcreteEnvironment::~ConcreteEnvironment()
+{
+  std::vector<Process *>::iterator iter = _processes.begin();
+  while (iter != _processes.end())
+  {
+    // This call will invoke the DynamicProcess virtual destructor
+    // Which will delete on cascade all DynamicThreads and so on.
+    delete *iter++;
+    // The iterator is still valid, since the pointed object is not,
+    // but the pointer is.
+  }
+  // After this, the destructor of _sched_queue is invoked
+  // After that, the destructor of _processes is invoked
+  // After that, the destructor of _resources is invoked
+  // The current implementation does not destroy the DynamicResource
+  // objects, as they are shared among all the DynamicEnvironment
+  // objects. This means that if none deletes them when deleting the
+  // last DynamicEnvironment object, we have a memory leak.
+  // And we do have one, since none by now cares for this. Maybe
+  // History will. Anyway, this is not nice, so please FIXME.
+}
+
+
+
+void
+ConcreteEnvironment::serialize(SerializeVisitor& translator) const
+{
+  // TODO: call something like translator.serializeEnvironment(this);
+}

src/backend/concrete_environment.hh

@@ -0,0 +1,222 @@
+// src/backend/resource.hh - Copyright 2005, 2006, University
+//               of Padova, dept. of Pure and Applied
+//               Mathematics
+//
+// This file is part of SGPEMv2.
+//
+// This 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 2 of the License, or
+// (at your option) any later version.
+//
+// SGPEMv2 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 SGPEMv2; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+#ifndef CONCRETE_ENVIRONMENT_HH
+#define CONCRETE_ENVIRONMENT_HH 1
+
+#include "config.h"
+#include "environment.hh"
+#include "resource.hh"
+#include "dynamic_process.hh"
+#include "dynamic_request.hh"
+#include "ready_queue.hh"
+
+
+namespace sgpem
+{
+
+
+
+  class SerializeVisitor;
+
+
+
+  ///  \brief An implementation of the Environment class
+  /// Class ConcreteEnvironment implements the Environment
+  /// abstract class.
+  ///
+  /// This implementation actually contains the collections
+  /// of snapshots accessed by the function members defined
+  /// in the Environment class.
+  ///
+  /// \see Environment
+
+  class ConcreteEnvironment : public Environment
+  {
+
+
+
+  public:
+
+
+
+    /// \brief Standard constructor.
+    /// Builds an empty environment.
+
+    ConcreteEnvironment();
+
+
+
+    /// \brief Copy constructor.
+    /// Performs a deep copy of all structures.
+
+    ConcreteEnvironment(const ConcreteEnvironment & c);
+
+
+
+    /// \brief Returns an indexed set of snapshots of the processes
+    /// Returns a standard vector of Process objects describing
+    /// all the processes of the simulated environment at the
+    /// considered instant.
+    ///
+    /// The Process objects returned are actually DynamicProcess
+    /// objects. A downcast to DynamicProcess is guaranteed to be 
+    /// always safe.
+    ///
+    /// \return a constant set of snapshots of processes
+
+    virtual const std::vector<Process *>
+    get_processes() const;
+
+
+
+    /// \brief Non-constant version of get_processes()
+    ///
+    /// \return a set of snapshots of processes
+    /// \see get_processes()
+
+    virtual std::vector<Process *>
+    get_processes();
+
+
+
+    /// \brief Returns an indexed set of snapshots of the resources
+    /// Returns a standard map of \code int \endcode to Resource
+    /// objects describing the all resources of the simulated environment
+    /// at the considered instant.
+    ///
+    /// The set is indexed in order to allow retreiving the requested
+    /// resource of a SubRequest object.
+    ///
+    /// Future implementation may provide a cleaner implementation, i.e.
+    /// a \code get_request \endcode function member in the SubRequest
+    /// class which returns the Resource object indexed.
+    ///
+    /// The Resource objects returned are actually DynamicResource
+    /// objects. A downcast to DynamicResource is guaranteed to be 
+    /// always safe.
+    ///
+    /// \return a indexed constant set of snapshot of resources.
+    /// \see DynamicSybrequest::get_resource()
+
+    virtual const std::map<int, Resource *>
+    get_resources() const;
+
+
+
+    /// \brief Non-constant version of get_resources()
+    ///
+    /// \return an indexed set of snapshots of resources
+    /// \see get_resources()
+
+    virtual std::map<int, Resource *>
+    get_resources();
+
+
+
+    /// \brief Returns a snapshot of the current request queue for a resource.
+    /// Returns a standard vector of Request objects
+    /// representing the queue of ready requests of threads which
+    /// are waiting for getting control of a limited-access resource.
+    ///
+    /// The Request objects returned are actually DynamicRequest
+    /// objects. A downcast to DynamicRequest is guaranteed to be 
+    /// always safe.
+    ///
+    /// \param resource the resource the requests are for
+    /// \return the current ready requests queue.
+
+    virtual const std::vector<Request *>
+    get_request_queue(Resource * resource) const;
+
+
+
+    /// \brief Returns a snapshot of the current scheduler's ready queue.
+    /// Returns a ReadyQueue object representing the queue
+    /// of ready processes or ready threads, depending on the
+    /// scheduling policy, which are waiting for getting control
+    /// of the CPU.
+    ///
+    /// \return the current ready queue (constant).
+
+    virtual const ReadyQueue *
+    get_sorted_queue() const;
+
+
+
+    /// \brief Non-constant version of get_sorted_queue()
+    ///
+    /// \return the current ready queue.
+    /// \see get_sorted_queue()
+
+    virtual ReadyQueue *
+    get_sorted_queue();
+
+
+
+    /// \brief The standard virtual destructor.
+    /// The standard virtual destructor.
+
+    virtual
+    ~ConcreteEnvironment();
+
+
+
+    /// \brief Serializes the whole environment.
+    /// \see SerializeVisitor
+
+    virtual void
+    serialize(SerializeVisitor& translator) const;
+
+
+
+  private:
+
+
+
+    /// \brief The container of all Resource objecs.
+    /// Actually contains only DynamicResource objects.
+    // resources come before processes because of
+    // destruction order. See destructor implementation
+
+    std::map<int, Resource *>
+    _resources;
+
+
+
+    /// \brief The container of all Process objecs.
+    /// Actually contains only DynamicProcess objects.
+
+    std::vector<Process *>
+    _processes;
+
+
+
+    /// \brief The queue of the ready schedulables
+    /// Does not contain the running process.
+
+    ReadyQueue
+    _sched_queue;
+
+  };
+
+}
+
+#endif

src/backend/environment.cc

@@ -0,0 +1,28 @@
+// src/backend/resource.cc - Copyright 2005, 2006, University
+//               of Padova, dept. of Pure and Applied
+//               Mathematics
+//
+// This file is part of SGPEMv2.
+//
+// This 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 2 of the License, or
+// (at your option) any later version.
+//
+// SGPEMv2 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 SGPEMv2; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+#include "environment.hh"
+
+using namespace sgpem;
+
+
+Environment::~Environment()
+{}
+

src/backend/environment.hh

@@ -0,0 +1,120 @@
+// src/backend/resource.hh - Copyright 2005, 2006, University
+//               of Padova, dept. of Pure and Applied
+//               Mathematics
+//
+// This file is part of SGPEMv2.
+//
+// This 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 2 of the License, or
+// (at your option) any later version.
+//
+// SGPEMv2 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 SGPEMv2; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+#ifndef ENVIRONMENT_HH
+#define ENVIRONMENT_HH 1
+
+#include "config.h"
+#include <vector>
+#include <map>
+
+namespace sgpem
+{
+  class ReadyQueue;
+  class Process;
+  class Request;
+  class Resource;
+
+  /// \brief An instant of the simulation.
+  /// An object of the Environment class represents a snapshot of
+  /// the simulated environment taken in a fixed instant, composed 
+  /// by processes, threads, resources and more.
+  /// A snapshot for every single entity is accessible from here.
+  /// All the provided objects and data is constant.
+  ///
+  /// Class History provides access to Environments for each instant
+  /// of the simulation.
+  ///
+  /// Anyway, as well as the returned collections contain non-const
+  /// pointers, it will be possible to call non-const member functions
+  /// on these objects. This has no consequences until someone adds
+  /// non-const member functions to these classes.
+  ///
+  /// This class is abstract: it provides the public interface to
+  /// read the content of an History.
+  /// \see History
+
+  class SG_DLLEXPORT Environment
+  {
+  public:
+
+    /// \brief Returns an indexed set of snapshots of the processes
+    /// Returns a standard vector of Process objects describing
+    /// all the processes of the simulated environment at the
+    /// considered instant.
+    ///
+    /// \return a constant set of snapshots of processes
+
+    virtual std::vector<Process *> const
+    get_processes() const = 0;
+
+
+    /// \brief Returns an indexed set of snapshots of the resources
+    /// Returns a standard map of \code int \endcode to Resource
+    /// objects describing the all resources of the simulated environment
+    /// at the considered instant.
+    ///
+    /// The set is indexed in order to allow retreiving the requested
+    /// resource of a SubRequest object.
+    ///
+    /// Future implementation may provide a cleaner implementation, i.e.
+    /// a \code get_request \endcode function member in the SubRequest
+    /// class which returns the Resource object indexed.
+    ///
+    /// \return an indexed constant set of snapshot of resources.
+
+    virtual std::map<int, Resource *> const
+    get_resources() const = 0;
+
+
+    /// \brief Returns a snapshot of the current request queue for a resource.
+    /// Returns a standard vector of Request objects
+    /// representing the queue of ready requests of threads which
+    /// are waiting for getting control of a limited-access resource.
+    /// \param resource the resource the requests are for
+    /// \return the current ready requests queue (constant).
+
+    virtual std::vector<Resource *> const
+    get_request_queue(const Resource * resource) const = 0;
+
+
+    /// \brief Returns a snapshot of the current scheduler's ready queue.
+    /// Returns a ReadyQueue object representing the queue
+    /// of ready processes or ready threads, depending on the
+    /// scheduling policy, which are waiting for getting control
+    /// of the CPU.
+    /// \return the current ready queue (constant).
+
+    virtual const ReadyQueue *
+    get_sorted_queue() const = 0;
+
+
+    /// \brief The standard virtual destructor.
+    /// The standard virtual destructor.
+
+    virtual
+    ~Environment();
+
+  };
+
+}
+
+#endif
+

src/backend/ready_queue.cc

@@ -0,0 +1,27 @@
+// src/backend/resource.cc - Copyright 2005, 2006, University
+//               of Padova, dept. of Pure and Applied
+//               Mathematics
+//
+// This file is part of SGPEMv2.
+//
+// This 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 2 of the License, or
+// (at your option) any later version.
+//
+// SGPEMv2 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 SGPEMv2; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+#include "ready_queue.hh"
+
+using namespace sgpem;
+
+ReadyQueue::~ReadyQueue()
+{}
+

src/backend/ready_queue.hh

@@ -0,0 +1,41 @@
+// src/backend/resource.hh - Copyright 2005, 2006, University
+//               of Padova, dept. of Pure and Applied
+//               Mathematics
+//
+// This file is part of SGPEMv2.
+//
+// This 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 2 of the License, or
+// (at your option) any later version.
+//
+// SGPEMv2 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 SGPEMv2; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+#ifndef READY_QUEUE_HH
+#define READY_QUEUE_HH 1
+
+#include "config.h"
+#include "glibmm/ustring.h"
+
+namespace sgpem
+{
+
+
+  class SG_DLLEXPORT ReadyQueue
+  {
+  public:
+    virtual
+    ~ReadyQueue();
+  };
+
+}
+
+#endif
+