transaction_data_buffer_pool.h

Go to the documentation of this file.

// -*- mode: C++; c-file-style: "virtutech-c++" -*-
 
/*
  © 2025 Intel Corporation
 
  This software and the related documents are Intel copyrighted materials, and
  your use of them is governed by the express license under which they were
  provided to you ("License"). Unless the License provides otherwise, you may
  not use, modify, copy, publish, distribute, disclose or transmit this software
  or the related documents without Intel's prior written permission.
 
  This software and the related documents are provided as is, with no express or
  implied warranties, other than those that are expressly stated in the License.
*/
 
#ifndef SIMICS_SYSTEMC_IFACE_TRANSACTION_DATA_BUFFER_POOL_H
#define SIMICS_SYSTEMC_IFACE_TRANSACTION_DATA_BUFFER_POOL_H
 
#include <simics/base/transaction.h>
 
#include <cstring>  // memset
#include <stdexcept>
#include <unordered_map>
#include <vector>
 
namespace simics {
namespace systemc {
namespace iface {
 
/*
 * The data buffer used for get/set the data from a transaction
 */
class TransactionDataBuffer {
  public:
    explicit TransactionDataBuffer(unsigned num_bytes)
        : data_(num_bytes, 0) {
        if (num_bytes == 0) {
            throw std::invalid_argument {
                "Cannot allocate an empty data buffer"
            };
        }
        buffer_.data = &data_.front();
        buffer_.len = num_bytes;
        bytes_.data = &data_.front();
        bytes_.len = num_bytes;
    }
 
    virtual ~TransactionDataBuffer() {
        buffer_.data = nullptr;
        bytes_.data = nullptr;
    }
 
    unsigned numBytes() const {
        return data_.size();
    }
 
    unsigned char *dataPtr() const {
        return buffer_.data;
    }
 
 
    void copyToBuffer(const transaction_t *transaction) {
        auto size = SIM_transaction_size(transaction);
        if (size > numBytes()) {
            throw std::logic_error {
                "The number of bytes for this data buffer ("
                + std::to_string(numBytes())
                + ") does not fit the size of the transaction ("
                + std::to_string(size) + ")"
            };
        }
        buffer_.len = size;
        SIM_get_transaction_bytes(transaction, buffer_);
    }
 
    void copyFromBuffer(const transaction_t *transaction) {
        auto size = SIM_transaction_size(transaction);
        if (size > numBytes()) {
            throw std::logic_error {
                "The number of bytes for this data buffer ("
                + std::to_string(numBytes())
                + ") does not fit the size of the transaction ("
                + std::to_string(size) + ")"
            };
        }
        bytes_.len = size;
        SIM_set_transaction_bytes(transaction, bytes_);
    }
 
  private:
    std::vector<unsigned char> data_;
    buffer_t buffer_;
    bytes_t bytes_;
};
 
/*
 * The pool for allocating/releasing TransactionDataBuffers
 */
class TransactionDataBufferPool {
  public:
    virtual ~TransactionDataBufferPool() {
        for (auto it = pool_.begin(); it != pool_.end(); ++it) {
            delete it->second;
        }
    }
 
    TransactionDataBuffer *acquire(unsigned size) {
        TransactionDataBuffer *buf = nullptr;
        auto roundup_size = roundUpSize(size);
        auto it = pool_.find(roundup_size);
        if (it != pool_.end()) {
            buf = it->second;
            // Remove only one buffer of this size
            pool_.erase(it);
        } else {
            buf = new TransactionDataBuffer(roundup_size);
        }
        return buf;
    }
 
    void release(TransactionDataBuffer *buf) {
        pool_.emplace(buf->numBytes(), buf);
    }
 
  private:
    // Round up requested size to the nearest size class:
    // 8, 8K and 8M
    static unsigned roundUpSize(unsigned size) {
        if (size <= 8) {
            return 8;
        }
        if (size <= 8192) {
            return 8192;
        }
        if (size <= 8388608) {
            return 8388608;
        }
        throw std::logic_error {
            "The transaction data buffer does not support"
            " data larger than 8M. Please report it."
        };
    }
 
    std::unordered_multimap<unsigned, TransactionDataBuffer*> pool_;
};
 
}  // namespace iface
}  // namespace systemc
}  // namespace simics
 
#endif