ReorderBuf.h

/*
 * Copyright (c) 2017-2020, NVIDIA CORPORATION.  All rights reserved.
 * 
 * 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.
 */
 
#ifndef __REORDERBUF_H__
#define __REORDERBUF_H__
 
#include <fifo.h>
#include <nvhls_types.h>
#include <mem_array.h>
#include <nvhls_assert.h>
 
template <typename Data, unsigned int Depth, unsigned int InFlight>
class ReorderBuf {
 
public:
    ReorderBuf(): idrep(0)
    {
    }
 
    typedef sc_uint<nvhls::index_width<InFlight>::val> Id;
 
protected:
    mem_array_sep<Data, Depth, 1> storage;
    typedef FIFO<bool, Depth> VBits;
    VBits vbits;
 
    typedef NVUINTW(InFlight)   IdRepository;
 
    IdRepository idrep;
    typedef typename VBits::FifoIdx EntryNum;
 
    typedef mem_array_sep<EntryNum, InFlight,1> Id2Entry;
    Id2Entry id2entry;
    
    bool get_next_avail_id(Id& id, IdRepository& id_repository)
    {
        #pragma hls_unroll yes
        for (int i=0; i<static_cast<int>(InFlight); ++i)
        {
            if (id_repository[i]==0) 
            {
                id = i;
                id_repository[i]=1;
                return true;
            }
        }
        return false;
    }
 
public:
    bool canAcceptRequest()
    {
        return ((idrep != static_cast<IdRepository>(~0)) && !vbits.isFull());
    }
 
    Id addRequest()
    {
        Id id;
        bool success = get_next_avail_id(id, idrep);
        NVHLS_ASSERT_MSG(success, "get_next_avail_id unsuccessful");
 
        id2entry.write(static_cast<typename Id2Entry::LocalIndex>(id), 0, vbits.get_tail()); 
        vbits.push(false);
 
        return id;
    }
 
    bool topResponseReady()
    {
        if (isEmpty()){
            return false;
        } else {
            return vbits.peek();
        }
    }
 
    void addResponse(const Id& id, const Data& data)
    {
        EntryNum entryNum = id2entry.read(static_cast<typename Id2Entry::LocalIndex>(id), 0);
        storage.write(entryNum, 0, data);
        vbits.fifo_body.write(static_cast<typename VBits::FifoIdx>(entryNum), 0, true);
        NVHLS_ASSERT_MSG(idrep[static_cast<int>(id)] == 1, "idrep[id]!=1");
        idrep[static_cast<int>(id)]=0;
    }
 
    Data popResponse()
    {
        NVHLS_ASSERT_MSG(topResponseReady(),"topResponseNotReady");
 
        Data result = storage.read( vbits.get_head(), 0); 
        vbits.incrHead();
 
        return result;
    }
 
    void reset()
    {
        vbits.reset();
        idrep = 0;
    }
 
    bool isEmpty()
    {
        return vbits.isEmpty();
    }
    
};
 
#endif