ArchDataSegment.hpp

// <ArchDataSegment> -*- C++ -*-
 
#pragma once
 
#include <iostream>
#include <math.h>
 
#include "sparta/utils/SpartaException.hpp"
#include "sparta/utils/SpartaAssert.hpp"
#include "sparta/utils/Utils.hpp"
 
 
namespace sparta
{
    class ArchData;
 
    class ArchDataSegment
    {
    public:
 
        typedef uint64_t offset_type; //<! Represents offset (address) into ArchData
        typedef uint32_t ident_type; //<! DataView identifiers (distinguishes items in the same ArchData)
 
        static const ident_type INVALID_ID = ~(ident_type)0;
 
        ArchDataSegment(const ArchDataSegment&) = delete;
        ArchDataSegment(const ArchDataSegment&&) = delete;
        ArchDataSegment& operator=(const ArchDataSegment&) = delete;
 
        ArchDataSegment(ArchData* data,
                        offset_type size,
                        ident_type id,
                        ident_type subset_of=INVALID_ID,
                        offset_type subset_offset=0) :
            offset_(0),  is_placed_(false), size_(size),
            adata_(data),
            ident_(id),
            subset_of_(subset_of),
            subset_offset_(subset_offset)
 
        {
            // No reason not to allow this, it just can't have subsegments
            //if(id == INVALID_ID){
            //    throw SpartaException("Cannot construct ArchDataSegment with identifier=INVALID_ID");
            //}
 
            if(!isPowerOf2(size)){
                throw SpartaException("size must be a power of 2, is ")
                    << size;
            }
 
            sparta_assert(getOffset() == 0); // Ensure initialized to 0 because getOffset expects this
        }
 
        virtual ~ArchDataSegment() {};
 
        void place(offset_type offset) {
            if(is_placed_){
                SpartaException ex("ArchDataSegment ");
                ex << ident_ << " was already placed. Cannot place again";
                throw ex;
            }
            offset_ = offset;
            is_placed_ = true;
 
            place_(offset);
        }
 
        void writeInitial() {
            sparta_assert(is_placed_, "Should not be invoking writeInitial when is_placed_ is false");
            writeInitial_();
        }
 
        // Layout State
 
        bool isPlaced() const { return is_placed_; }
 
        offset_type getOffset() const { return offset_; }
 
 
        // Const Attributes
 
        offset_type getLayoutSize() const { return size_; }
 
        ident_type getLayoutID() const { return ident_; }
 
        ident_type getSubsetOf() const { return subset_of_; }
 
        offset_type getSubsetOffset() const { return subset_offset_; }
 
        ArchData* getArchData() { return adata_; }
 
        const ArchData* getArchData() const { return adata_; }
 
    protected:
 
        virtual void place_(offset_type offset) {
            (void) offset;
        }
 
        virtual void writeInitial_() {
        }
 
    private:
 
        // Placement
        offset_type offset_;         
        bool is_placed_;             
        const offset_type size_;     
 
        // Backend data
        ArchData* const adata_;      
 
        //
        const ident_type ident_;     
        const ident_type subset_of_; 
        const offset_type subset_offset_; 
    };
 
} // namespace sparta