processor.h

Go to the documentation of this file.

//    sampalib.org ESL library and tools
//    Copyright (C) 2007  Thierry Grellier
//
//    This program is free software; you can redistribute it and/or modify
//    it under the terms of the GNU General Public License version 2 as
//    published by the Free Software Foundation.
//
//    This program is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//    GNU General Public License for more details.
//
//    You should have received a copy of the GNU General Public License along
//    with this program; if not, write to the Free Software Foundation, Inc.,
//    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
//
//    contact: www.sampalib.org

#ifndef SAMPA_COMPONENT_PROCESSOR_H
#define SAMPA_COMPONENT_PROCESSOR_H

#include "sampa/component/protocol.h"

namespace Sampa {

  class TwoPortL1Cpu : public Module {
    SAMPA_MODULE(TwoPortL1Cpu);
  public:
    TwoPortL1Cpu(const Name& name);  
    
    void bind_clock(Clock* clock);
    void bind_fetch_target(Target* target);
    Initiator* get_fetch_initiator() { return &p_fetch; } 

    void bind_data_target(Target* target);
    Initiator* get_data_initiator() { return &p_data; } 
   
    bool recieve_fetch_response(const Response&);
    bool recieve_data_response(const Response&);
   
    enum Opcode { NOP, STALL, BRANCH, READ, WRITE, READ_MISS, WRITE_MISS, MISPREDICTED };
    typedef AdaptingInitiator<TwoPortL1Cpu> AdaptingInitiator;
  private: 
   
    void complete_restart();
    void execute();
    void fetch1();
    bool fetch_hit(const Address&);
    Opcode get_instruction(Address );
    void decode1();
    void execute1();  
    Opcode predict();
    bool read_hit();
    bool write_hit();
    void execute2();  
    void invalidate_pipeline();
    void read1();  
    bool eviction();
    void write1();

    AdaptingInitiator        p_fetch;
    AdaptingInitiator        p_data;
    EventListener            e_rising;
    IntParameter             m_cache_line_capacity;
    Gated<Address>           m_pc;
    Address                  m_old_pc;  
    Gated<Opcode>            m_inst;
    Gated<bool>              m_fetch_response_present;
    Gated<bool>              m_fetch_miss;
    int                      m_fetch_pending;
    int                      m_fetch_query;
    Request                  m_fetch_request;
    Gated<Opcode>            m_decoded;
    Gated<Opcode>            m_stage1;
    Gated<Opcode>            m_stage2;
    Opcode                   m_prediction[2];
    Gated<bool>              m_read;
    Gated<bool>              m_read_response_present;
    Gated<bool>              m_request_done;
    int                      m_read_pending;
    int                      m_read_query;
    Request                  m_read_request;
    Gated<bool>              m_write;
    int                      m_pending_write;
    IntParameter             m_write_buffer_capacity;
    Request                  m_eviction_request;
    Gated<int>               m_eviction_pending;
    Request                  m_write_request;
    DoubleParameter          m_mispredicted_branch_ratio;
    DoubleParameter          m_fetch_ratio;
    DoubleParameter          m_fetch_miss_ratio;
    DoubleParameter          m_read_miss_ratio;
    DoubleParameter          m_write_miss_ratio;
    DoubleParameter          m_branch_ratio;
    DoubleParameter          m_read_ratio;
    DoubleParameter          m_write_ratio;
    DoubleParameter          m_dirty_ratio;
    double                   m_branch_read_write_ratio;
    double                   m_read_write_ratio;
  };

}

#endif

---