src/abstractactor.cpp

/*                                                                            *\
**                          Copyright (C) 2009-2010                           **
**       Dominik Charousset < Dominik.Charousset (at) haw-hamburg.de >        **
**                                                                            **
**            MMM       MMMMMM   MMMMMMMMM MMMMMMM   MMM       MMM            **
**           MMMMM     MMMMMMMM  MMMMMMMMM MMMMMMMM  MMM      MMMMM           **
**          MMM MMM   MMM        MMMM      MMM   MMM MMM     MMM MMM          **
**         MMM   MMM  MMM        MMMMMMMMM MMM   MMM MMM    MMM   MMM         **
**        MMMMMMMMMMM MMMM   MMM MMMM      MMM   MMM MMM   MMMMMMMMMMM        **
**       MMM       MMM MMMMMMMM  MMMMMMMMM MMMMMMMM  MMM  MMM       MMM       **
**      MMM         MMM MMMMMM   MMMMMMMMM MMMMMMM   MMM MMM         MMM      **
**                                                                            **
**                                                                            **
** This file is part of the acedia library.                                   **
**                                                                            **
** This library is free software: you can redistribute it and/or modify       **
** it under the terms of the GNU Lesser General Public License as published   **
** by the Free Software Foundation, either version 3 of the License, or       **
** (at your option) any later version.                                        **
**                                                                            **
** This library 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 Lesser General Public License for more details.                        **
**                                                                            **
** You should have received a copy of the GNU Lesser General Public License   **
** along with acedia. If not, see <http://www.gnu.org/licenses/>.             **
\*                                                                            */

#define ACEDIA_REDUCED_ANNOUNCE

#include "abstractactor.hpp"
#include "actor.hpp"
#include "actorref.hpp"
#include "acedia_atomic.hpp"
#include "acedia.hpp"

#include <map>
#include <boost/thread/mutex.hpp>

static volatile boost::uint32_t usedActorIds = 0;

typedef std::map<boost::uint32_t, acedia::ActorRef> InstancesMap;
typedef std::pair<boost::uint32_t, acedia::ActorRef> IdAndActorPair;
typedef boost::mutex::scoped_lock ScopedLock;

static InstancesMap actorInstances;
static boost::mutex actorInstancesMutex;

void addToInstances(boost::uint32_t id, const acedia::ActorRef &actor)
{
    ScopedLock lock(actorInstancesMutex);
    actorInstances.insert(IdAndActorPair(id, actor));
}

void removeFromInstances(boost::uint32_t id)
{
    ScopedLock lock(actorInstancesMutex);
    actorInstances.erase(id);
}

namespace acedia
{
    namespace details
    {
        ActorRef getInstanceById(boost::uint32_t id)
        {
            ScopedLock lock(actorInstancesMutex);
            InstancesMap::iterator it = actorInstances.find(id);
            if (it == actorInstances.end())
            {
                return acedia::ActorRef();
            }
            return it->second;
        }
    }

    AbstractActor::AbstractActor(bool farRef, bool isDummy) throw() :
            ReferenceCounted(0), m_isFarRef(farRef),
            m_exitReason(exit_reasons::NOT_EXITED)
    {
        m_self = new ActorRef(this, true);
        ACEDIA_MEMORY_BARRIER();
        if (!isDummy)
        {
            m_id = atomic::addAndFetch(&usedActorIds, 1);
            addToInstances(m_id, *m_self);
        }
        else m_id = 0;
    }

    AbstractActor::~AbstractActor() { delete m_self; }

    void AbstractActor::forward(const Message& what, ActorRef& whom)
    {
        whom.send(what);
    }

    void AbstractActor::send(ActorRef &receiver,const Any &v1)
    {
        receiver.send(Message(self(),receiver,v1));
    }

    void AbstractActor::send(ActorRef &receiver,const Any &v1, const Any &v2)
    {
        receiver.send(Message(self(),receiver,v1,v2));
    }

    void AbstractActor::send(ActorRef &receiver,const Any &v1, const Any &v2, const Any &v3)
    {
        receiver.send(Message(self(),receiver,v1,v2,v3));
    }

    void AbstractActor::send(ActorRef &receiver,const Any &v1, const Any &v2, const Any &v3, const Any &v4)
    {
        receiver.send(Message(self(),receiver,v1,v2,v3,v4));
    }

    void AbstractActor::send(ActorRef &receiver,const Any &v1, const Any &v2, const Any &v3, const Any &v4, const Any &v5)
    {
        receiver.send(Message(self(),receiver,v1,v2,v3,v4,v5));
    }

    void AbstractActor::send(ActorRef &receiver,const Any &v1, const Any &v2, const Any &v3, const Any &v4, const Any &v5, const Any &v6)
    {
        receiver.send(Message(self(),receiver,v1,v2,v3,v4,v5,v6));
    }

    void AbstractActor::send(ActorRef &receiver,const Any &v1, const Any &v2, const Any &v3, const Any &v4, const Any &v5, const Any &v6, const Any &v7)
    {
        receiver.send(Message(self(),receiver,v1,v2,v3,v4,v5,v6,v7));
    }

    void AbstractActor::send(ActorRef &receiver,const Any &v1, const Any &v2, const Any &v3, const Any &v4, const Any &v5, const Any &v6, const Any &v7, const Any &v8)
    {
        receiver.send(Message(self(),receiver,v1,v2,v3,v4,v5,v6,v7,v8));
    }

    void AbstractActor::send(ActorRef &receiver,const Any &v1, const Any &v2, const Any &v3, const Any &v4, const Any &v5, const Any &v6, const Any &v7, const Any &v8, const Any &v9)
    {
        receiver.send(Message(self(),receiver,v1,v2,v3,v4,v5,v6,v7,v8,v9));
    }

    void Actor::executeActor()
    {
        if (m_state == READY) m_state = RUNNING;
        try { act(); }
        catch (ActorKilledException &e)
        {
            m_exitReason = e.reason();
        }
        catch (...)
        {
            m_exitReason = exit_reasons::UNHANDLED_EXCEPTION;
        }
        if (exit_reasons::NOT_EXITED == m_exitReason)
            m_exitReason = exit_reasons::NORMAL_EXIT;
        ACEDIA_MEMORY_BARRIER();
        *yieldState = EXITED;
        removeFromInstances(id());
    }

    void Actor::trampoline(Actor *_this)
    {
        _this->executeActor();
        // done (return to the scheduler which deletes this actor)
        ACEDIA_MEMORY_BARRIER();
        Context::swap(*(_this->m_context),
                      *const_cast<Context*>(_this->m_returnContext));
    }

#if defined(ACEDIA_UCONTEXT_IMPL)
    void Actor::ucontext_trampoline(int thisActor)
#elif defined(ACEDIA_FIBER_IMPL)
    void Actor::fiber_trampoline(PVOID *thisActor)
#endif
    {
        trampoline(reinterpret_cast<Actor*>(thisActor));
    }

}

---