Subversion Repositories riscv_vhdl

/*
 *  Copyright 2018 Sergey Khabarov, sergeykhbr@gmail.com
 *
 *  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.
 */
 
#include <api_utils.h>
#include <async_tqueue.h>
 
namespace debugger {
 
AsyncTQueueType::AsyncTQueueType() {
    stepPreQueued_.make_list(0);
    stepQueue_.make_list(16);   /** it will be auto reallocated if needed */
    RISCV_mutex_init(&mutex_);
    hardReset();
}
 
AsyncTQueueType::~AsyncTQueueType() {
    RISCV_mutex_destroy(&mutex_);
}
 
void AsyncTQueueType::hardReset() {
    preLen_ = 0;
    curLen_ = 0;
    curIdx_ = 0;
}
 
void AsyncTQueueType::put(AttributeType *item) {
    if (preLen_ == stepPreQueued_.size()) {
        unsigned new_sz = 2 * stepPreQueued_.size();
        if (new_sz == 0) {
            new_sz = 1;
        }
        stepPreQueued_.realloc_list(new_sz);
    }
    stepPreQueued_[preLen_].attr_free();
    stepPreQueued_[preLen_] = *item;
    preLen_++;
}
 
void AsyncTQueueType::pushPreQueued() {
    if (preLen_ == 0) {
        return;
    }
    RISCV_mutex_lock(&mutex_);
    for (unsigned i = 0; i < preLen_; i++) {
        if (curLen_ < stepQueue_.size()) {
            stepQueue_[curLen_].attr_free();
            stepQueue_[curLen_] = stepPreQueued_[i];
        } else {
            stepQueue_.add_to_list(&stepPreQueued_[i]);
        }
        curLen_++;
    }
    preLen_ = 0;
    RISCV_mutex_unlock(&mutex_);
}
 
void AsyncTQueueType::initProc() {
    curIdx_ = 0;
}
 
/** Clock queue */
ClockAsyncTQueueType::ClockAsyncTQueueType() : AsyncTQueueType() {
    item_.make_list(Queue_Total);
}
 
void ClockAsyncTQueueType::put(uint64_t time, IFace *cb) {
    RISCV_mutex_lock(&mutex_);
    item_[Queue_Time].make_uint64(time);
    item_[Queue_IFace].make_iface(cb);
 
    AsyncTQueueType::put(&item_);
    RISCV_mutex_unlock(&mutex_);
}
 
IFace *ClockAsyncTQueueType::getNext(uint64_t step_cnt) {
    IFace *ret = 0;
    if (curIdx_ >= curLen_) {
        return ret;
    }
    for (unsigned i = curIdx_; i < curLen_; i++) {
        uint64_t ev_time = stepQueue_[i][Queue_Time].to_uint64();
 
        curIdx_ = i;
        if (step_cnt < ev_time) {
            continue;
        }
        ret = stepQueue_[i][Queue_IFace].to_iface();
 
        // remove item from list using swap function to avoid usage
        // of allocation/deallocation calls.
        if (i < (curLen_ - 1)) {
            stepQueue_.swap_list_item(i, curLen_ - 1);
        }
        curLen_--;
        break;
    }
    return ret;
}
 
 
/** GUI queue */
GuiAsyncTQueueType::GuiAsyncTQueueType() : AsyncTQueueType() {
    item_.make_list(Queue_Total);
    dbg_cnt_ = 0;
}
 
void GuiAsyncTQueueType::put(IFace *src, AttributeType *cmd, bool silent) {
    RISCV_mutex_lock(&mutex_);
    item_[Queue_Source].make_iface(src);
    item_[Queue_Command] = *cmd;
    item_[Queue_Silent].make_boolean(silent);
 
    AsyncTQueueType::put(&item_);
    dbg_cnt_++;
    RISCV_mutex_unlock(&mutex_);
}
 
bool GuiAsyncTQueueType::getNext(IFace **src, AttributeType &cmd,
                                 bool &silent) {
    *src = 0;
    if (curIdx_ >= curLen_) {
        curIdx_ = 0;
        curLen_ = 0;
        return false;
    }
    AttributeType &item = stepQueue_[curIdx_++];
    dbg_cnt_--;
 
    *src = item[Queue_Source].to_iface();
    cmd = item[Queue_Command];
    silent = item[Queue_Silent].to_bool();
    return true;
}
 
void GuiAsyncTQueueType::remove(IFace *src) {
    RISCV_mutex_lock(&mutex_);
    for (unsigned i = 0; i < preLen_; i++) {
        AttributeType &item = stepPreQueued_[i];
        if (item[Queue_Source].to_iface() == src) {
            item[Queue_Source].make_iface(0);
        }
    }
    for (unsigned i = 0; i < curLen_; i++) {
        AttributeType &item = stepQueue_[i];
        if (item[Queue_Source].to_iface() == src) {
            item[Queue_Source].make_iface(0);
        }
    }
    RISCV_mutex_unlock(&mutex_);
}
 
}  // namespace debugger