pplinterface.h

Go to the documentation of this file.

/***
* ==++==
*
* Copyright (c) Microsoft Corporation. All rights reserved.
*
* ==--==
* =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
*
* pplinterface.h
*
* Parallel Patterns Library - PPL interface definitions
*
* =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
****/

#pragma once

#ifndef _PPLINTERFACE_H
#define _PPLINTERFACE_H

#include <memory>
#include <atomic>

namespace Concurrency
{


typedef void (__cdecl * TaskProc_t)(void *);

struct __declspec(novtable) scheduler_interface
{
    virtual void schedule( TaskProc_t, void* ) = 0;
};

struct scheduler_ptr
{
    explicit scheduler_ptr(std::shared_ptr<scheduler_interface> _Scheduler) : _M_sharedScheduler(std::move(_Scheduler))
    {
        _M_scheduler = _M_sharedScheduler.get();
    }

    explicit scheduler_ptr(_In_opt_ scheduler_interface * _PScheduler) : _M_scheduler(_PScheduler)
    {
    }

    scheduler_interface *operator->() const
    {
        return get();
    }

    scheduler_interface * get() const
    {
        return _M_scheduler;
    }

    operator bool() const { return get() != nullptr; }

private:

    std::shared_ptr<scheduler_interface> _M_sharedScheduler;
    scheduler_interface * _M_scheduler;
};


enum task_group_status
{
    
    not_complete,

    
    completed,

    
    canceled
};


class invalid_operation : public std::exception
{
public:
    
    explicit invalid_operation(_In_z_ const char* _Message) _NOEXCEPT
        : exception(_Message)
    { }

    
    invalid_operation() _NOEXCEPT
        : exception()
    {}
};


class task_canceled : public std::exception
{
public:
    
    explicit task_canceled(_In_z_ const char * _Message) _NOEXCEPT
        : exception(_Message)
    {}

    
    task_canceled() _NOEXCEPT
        : exception()
    {}
};

namespace details
{

//
// An internal exception that is used for cancellation. Users do not "see" this exception except through the
// resulting stack unwind. This exception should never be intercepted by user code. It is intended
// for use by the runtime only.
//
class _Interruption_exception : public std::exception
{
public:
    explicit _Interruption_exception(const char * _Message) _NOEXCEPT
        : exception(_Message)
    {}

    _Interruption_exception() _NOEXCEPT
        : exception()
    {}
};

enum _TaskInliningMode
{
    // Disable inline scheduling
    _NoInline = 0,
    // Let runtime decide whether to do inline scheduling or not
    _DefaultAutoInline = 16,
    // Always do inline scheduling
    _ForceInline = -1,
};

typedef std::atomic<long> atomic_long;
typedef std::atomic<size_t> atomic_size_t;

template<typename _T>
_T atomic_compare_exchange(std::atomic<_T>& _Target, _T _Exchange, _T _Comparand)
{
    _T _Result = _Comparand;
    _Target.compare_exchange_strong(_Result, _Exchange);
    return _Result;
}

template<typename _T>
_T atomic_exchange(std::atomic<_T>& _Target, _T _Value)
{
    return _Target.exchange(_Value);
}

template<typename _T>
_T atomic_increment(std::atomic<_T>& _Target)
{
    return _Target.fetch_add(1) + 1;
}

template<typename _T>
_T atomic_decrement(std::atomic<_T>& _Target)
{
    return _Target.fetch_sub(1) - 1;
}

template<typename _T>
_T atomic_add(std::atomic<_T>& _Target, _T _Value)
{
    return _Target.fetch_add(_Value) + _Value;
}

}} // namespace Concurrency::details

#endif // _PPLINTERFACE_H