src/context.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 "context.hpp"
#include "acedia_atomic.hpp"

#ifdef ACEDIA_UCONTEXT_IMPL

/******************************************************************************\
*                            ACEDIA_UCONTEXT_IMPL                              *
\******************************************************************************/

#include "exceptions.hpp"

namespace acedia
{
    namespace details
    {
        struct SNode
        {
            SNode *next;
            void *s;
            inline SNode() :
                    next(NULL) , s(mmap(0, STACK_SIZE,
                                        PROT_EXEC | PROT_READ | PROT_WRITE,
                                        MAP_PRIVATE | MAP_ANON,
                                        -1, 0))
            {
            }
            inline ~SNode()
            {
                munmap(s, STACK_SIZE);
            }
        };

        struct StackFactory
        {

            static volatile SNode *head;
            static volatile boost::int32_t count;

            static SNode *get()
            {
                for (;;)
                {
                    SNode *result = const_cast<SNode*>(head);
                    if (result)
                    {
                        if (atomic::compareAndSwap(&head, result, result->next))
                        {
                            (void) atomic::addAndFetch(&count, -1);
                            return result;
                        }
                    }
                    else return new SNode;
                }
            }

            static void release(SNode *n)
            {
                if (atomic::addAndFetch(&count, 1) < 16)
                {
                    for (;;)
                    {
                        n->next = const_cast<SNode*>(head);
                        if (atomic::compareAndSwap(&head, n->next, n)) return;
                    }
                }
                else
                {
                    (void) atomic::addAndFetch(&count, -1);
                    delete n;
                }
            }

        };

    } // namespace details

} // namespace acedia

volatile acedia::details::SNode *acedia::details::StackFactory::head = NULL;
volatile boost::int32_t acedia::details::StackFactory::count = 0;

namespace acedia
{
    void Context::init()
    {
        stack = reinterpret_cast<void*>(details::StackFactory::get());
        getcontext(&ctx);
        ctx.uc_stack.ss_sp = reinterpret_cast<details::SNode*>(stack)->s;
        ctx.uc_stack.ss_size = STACK_SIZE;
        ctx.uc_link = 0;
    }

    Context::Context() throw() : stack(NULL)
    {
        getcontext(&ctx);
    }

    Context::Context(void (*func)(void), int arg1) : stack(NULL)
    {
        init();
        makecontext(&ctx, func, 1, arg1);
    }

    Context::~Context()
    {
        if (stack) details::StackFactory::release((details::SNode*) stack);
    }

} // namespace acedia

#elif defined(ACEDIA_FIBER_IMPL)

/*****************************************************************************
 *                           Fibers implementation                           *
 *****************************************************************************/

#include <cassert>

namespace acedia
{
    Context::Context() : fiber(NULL), isConvertedThread(true)
    {
        fiber = ConvertThreadToFiber(NULL);
        assert(fiber != NULL);
    }

    Context::Context(LPFIBER_START_ROUTINE func, LPVOID arg1) :
            fiber(NULL), isConvertedThread(false)
    {
        fiber = CreateFiber(0, func, arg1);
        assert(fiber != NULL);
    }

    Context::~Context()
    {
        if (fiber && !isConvertedThread) DeleteFiber(fiber);
    }

} // namespace acedia

#endif

---