SSim C++ API documentation (v. 1.5.0)

---

ssim.h

Go to the documentation of this file.

// -*-C++-*-
//
//  This file is part of the Siena Simulator, a simple discrete-event
//  simulator used with the Siena project.  See
//  http://www.cs.colorado.edu/serl/siena/
//
//  Author: Antonio Carzaniga <carzanig@cs.colorado.edu>
//  See the file AUTHORS for full details. 
//
//  Copyright (C) 1998-2004 University of Colorado
//
//  This program 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.
//
//  This program 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 this program; if not, write to the Free Software
//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307,
//  USA, or send email to serl@cs.colorado.edu.
//
//
// $Id: ssim.h,v 1.13 2004/01/06 17:51:38 carzanig Exp $
//
#ifndef _ssim_h
#define _ssim_h

#include <vector>
#include <map>

using std::multimap;
using std::map;
using std::vector;

namespace ssim {

extern const char *     Version;

typedef int             ProcessId;

const ProcessId         NULL_PROCESSID = -1;

typedef unsigned long   Time;

const Time              INIT_TIME = 0;

class Event {
 public:
                        Event();
    virtual             ~Event();

 private:
    mutable unsigned refcount;
    friend class Sim;
};

class Process {
 public:
    virtual             ~Process();

    virtual void        init(void);

    virtual void        process_event(const Event * msg);

    virtual void        stop(void);
};

class ProcessWithPId : public Process {
 public:
    ProcessId           activate();

    ProcessId           pid() const;

    ProcessWithPId();

 private:
    ProcessId process_id;
};

class Sim {
public:
    static ProcessId    create_process(Process *);

    static int          stop_process(ProcessId);
    static void         stop_process();

    static void         clear();

    static void         self_signal_event(const Event *) throw();

    static void         self_signal_event(const Event *, Time delay) throw();

    static int          signal_event(ProcessId, const Event *) throw();
    static int          signal_event(ProcessId, const Event *, Time) throw();

    static void         advance_delay(Time);
    
    static ProcessId    this_process();

    static Time         clock();
    
    static void         run_simulation();
    static void         stop_simulation();

    static void         set_stop_time(Time t = INIT_TIME);

private:
    static Time         current_time;
    static Time         stop_time;
    static ProcessId    current_process;
    static Time         current_delay;
    static bool         running;

    enum ActionType { A_Event, A_Init, A_Stop };
    
    struct Action {
        ActionType      type;
        ProcessId       pid;
        const Event *   event;
        
                        Action(ActionType, ProcessId);
                        Action(ActionType, ProcessId, const Event *);

                        Action(const Action &);
        Action &        operator = (const Action &);
    };

    typedef multimap<Time, Action>      ActionsTable;
    static ActionsTable                 actions;

    static void         schedule(const Action &, Time);
    static void         schedule_now(const Action &);

    struct PDescr {
        Process *       process;
        bool            terminated;
        Time            available_at;

        PDescr(Process * p);
    };

    typedef vector<PDescr> PsTable;
    static PsTable processes;
};

//
// inline implementations
//
inline Event::Event(): refcount(0) {};
inline Event::~Event() {};

inline Process::~Process() {};

inline void Process::init(void) {};
inline void Process::stop(void) {};
inline void Process::process_event(const Event *) {};

inline Sim::PDescr::PDescr(Process * p)
    : process(p), terminated(false), available_at(INIT_TIME) {}

inline Sim::Action::Action(ActionType i, ProcessId p, const Event *e)
    : type(i), pid(p), event(e) {}

inline Sim::Action::Action(ActionType i, ProcessId p)
    : type(i), pid(p), event((Event*)0) {}

inline Sim::Action::Action(const Action &a):
    type(a.type), pid(a.pid), event(a.event) {}

inline Sim::Action & Sim::Action::operator = (const Action &a) {
    type = a.type; pid = a.pid; event = a.event;
    return *this;
}

inline void Sim::set_stop_time(Time t) {
    stop_time = t;
}

inline void Sim::stop_process() {
    schedule_now(Action(A_Stop, current_process)); 
}

inline int Sim::stop_process(ProcessId pid) {
    if (processes[pid].terminated) return -1;
    schedule_now(Action(A_Stop, pid)); 
    return 0;
}

inline void Sim::stop_simulation() {
    running = false;
}

inline void Sim::advance_delay(Time delay) {
    if (!running) return;
    current_delay += delay;
}

inline ProcessId Sim::this_process() {
    return current_process;
}

inline Time Sim::clock() {
    return current_time + current_delay;
}

inline void Sim::self_signal_event(const Event * e) throw() {
    schedule_now(Action(A_Event, current_process, e));
}

inline void Sim::self_signal_event(const Event * e, Time delay) throw() {
    schedule(Action(A_Event, current_process, e), delay);
}

inline int Sim::signal_event(ProcessId pid, const Event * e) throw() {
    PDescr & pd = processes[current_process];
    if (pd.terminated) return -1;
    if (pd.available_at <= clock()) {
        schedule_now(Action(A_Event, pid, e));
    }
    return 0;
}

inline int Sim::signal_event(ProcessId pid, const Event * e, Time d) throw() {
    PDescr & pd = processes[current_process];
    if (pd.terminated) return -1;
    if (pd.available_at <= clock() + d) {
        schedule(Action(A_Event, pid, e), d);
    }
    return 0;
}

inline void Sim::schedule(const Action & action, Time t) {
    if (action.event != 0) { action.event->refcount++; }
    actions.insert(ActionsTable::value_type(clock() + t, action));
}

inline void Sim::schedule_now(const Action & action) {
    if (action.event != 0) { action.event->refcount++; }
    actions.insert(actions.begin(), ActionsTable::value_type(clock(), action));
}

inline ProcessId ProcessWithPId::activate() {
    if (process_id == NULL_PROCESSID) {
        return process_id = Sim::create_process(this);
    } else {
        return NULL_PROCESSID;
    }
}

inline ProcessWithPId::ProcessWithPId(): process_id(NULL_PROCESSID) {};

inline ProcessId ProcessWithPId::pid() const {
        return process_id;
}

}; // end namespace ssim

#endif /* _ssim_h */

---

Copyright © 2002-2004 University of Colorado.
Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.1 or any later version published by the Free Software Foundation; with no Invariant Sections, no Front-Cover Texts and no Back-Cover Texts. A copy of the license is included in the section entitled "GNU Free Documentation License". This documentation is authored and maintained by Antonio Carzaniga