ordered_semaphore.h

/*******************************************************************************
 * Copyright 2019 MINRES Technologies GmbH
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *******************************************************************************/
 
#pragma once
 
#include "sysc/communication/sc_semaphore_if.h"
#include "sysc/kernel/sc_event.h"
#include "sysc/kernel/sc_object.h"
#include "traceable.h"
#include <array>
#include <deque>
#include <sysc/kernel/sc_process_handle.h>
 
#ifndef SC_API
#define SC_API
#endif
 
namespace scc {
class SC_API ordered_semaphore : public sc_core::sc_semaphore_if, public sc_core::sc_object, public scc::traceable {
public:
    explicit ordered_semaphore(unsigned init_value = 1);
    ordered_semaphore(const char* name, unsigned init_value = 1, bool value_traceable = false);
 
    ordered_semaphore(const ordered_semaphore&) = delete;
 
    ordered_semaphore& operator=(const ordered_semaphore&) = delete;
    int wait() override { return wait(0); }
    int wait(unsigned priority);
    int trywait() override;
    int post() override;
    unsigned get_capacity() { return capacity; }
    void set_capacity(unsigned capacity);
    int get_value() const override { return value; }
    const char* kind() const override { return "sc_semaphore_ordered"; }
    void trace(sc_core::sc_trace_file* tf) const override;
    bool is_trace_enabled() const override { return value_traceable; }
    struct lock {
        lock(scc::ordered_semaphore& sem)
        : sem(sem) {
            sem.wait();
        }
        lock(scc::ordered_semaphore& sem, unsigned prio)
        : sem(sem) {
            sem.wait(prio);
        }
        ~lock() { release(); }
        void release() {
            if(owned)
                sem.post();
            owned = false;
        }
 
    private:
        scc::ordered_semaphore& sem;
        bool owned{true};
    };
 
protected:
    // support methods
    bool in_use() {
        if(value > 0) {
            if(queue[1].size()) {
                if(queue[1].front() == sc_core::sc_get_current_process_handle()) {
                    queue[1].pop_front();
                    return false;
                }
            } else {
                if(queue[0].front() == sc_core::sc_get_current_process_handle()) {
                    queue[0].pop_front();
                    return false;
                }
            }
        }
        return true;
    }
 
    // error reporting
    void report_error(const char* id, const char* add_msg = 0) const;
 
protected:
    sc_core::sc_event free_evt; // event to block on when m_value is negative
    int value;                  // current value of the semaphore
    unsigned capacity;
    bool value_traceable = false;
    std::array<std::deque<sc_core::sc_process_handle>, 2> queue;
};
 
template <unsigned CAPACITY> struct ordered_semaphore_t : public ordered_semaphore {
    explicit ordered_semaphore_t()
    : ordered_semaphore(CAPACITY) {}
    ordered_semaphore_t(const char* name_)
    : ordered_semaphore(name_, CAPACITY) {}
};
 
} // namespace scc // end of scc-sysc