cache.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_CACHE_H_
#define _SAMPA_COMPONENT_CACHE_H_

#include "sampa/core/module.h"

namespace Sampa {

  class Cache : public Module {
  public:
    Cache(const Name&);

    void bind_inst_initiator(Initiator*);
    void bind_data_initiator(Initiator*);
    Target* get_inst_target() { return &p_inst_slave; }
    Target* get_data_target() { return &p_data_slave; }

    void bind_inst_target(Target*);
    void bind_data_target(Target*);
    Initiator* get_inst_initiator() { return &p_inst_master; }
    Initiator* get_data_initiator() { return &p_data_master; }

  private:
    bool recieve_inst_response(const Response&);
    {
      if (m_inst_responses_pipe.is_empty())
        e_inst_response.notify_in_n_rising(m_response_pipeline_depth);
      short idx = m_inst_response_pipe.push();
      m_inst_response[idx]      = response;
      m_inst_response_date[idx] = get_rising_count();
      return true;
    }

    bool recieve_data_response(const Response& response)
    {
      if (m_data_responses_pipe.is_empty())
        e_data_response.notify_in_n_rising(m_response_pipeline_depth);
      short idx = m_inst_response_pipe.push();
      m_data_response[idx]      = response;
      m_data_response_date[idx] = get_rising_count();
      return true;
    }

    bool recieve_inst_request(const Request& req) {
      if (m_burst-- == 0) {
        m_inst_req.schedule(req);
        m_burst += req.get_burst();
      }
      return true;
    }

    bool recieve_data_request(const Request&);

    void fill_instruction() {
      if (m_inst_line_fill_pending) {
        m_inst_line_fill_pending = false;
        m_inst_req_out = m_inst_req;
        if (inst_miss()) {
          e_inst_request.notify_in_n_rising(2);
        }
      } else {
        // 1 cycle to fill line read buffer

      }
      if (m_pending_inst_resp > 0) {
        m_pending_inst_resp--;
        p_inst_slave->send_response(m_inst_req); 
      }
    }

    void forward_data_request()
    {
      if (read_pending > 0) {
      } else if (eviction) {
      }
    }

    void forward_data_response()
    {
      short idx = m_inst_response_pipe.pop();
      p_inst_slave->send_response(m_inst_responses[idx]);
      if (!m_inst_response_pipe.is_empty())
        e_inst_response.notify_in_n_rising(m_inst_responses_date[m_inst_response_pipe.peek()]+m_response_pipeline_depth- get_rising_count());
    }

    void forward_inst_response()
    {
      short idx = m_inst_response_pipe.pop();
      p_inst_slave->send_response(m_inst_responses[idx]);
      if (!m_inst_response_pipe.is_empty())
        e_inst_response.notify_in_n_rising(m_inst_responses_date[m_inst_response_pipe.peek()]+m_response_pipeline_depth- get_rising_count());
    }

    AdaptingTarget    p_inst_slave;
    AdaptingTarget    p_data_slave;
    AdaptingInitiator p_inst_master;
    AdaptingInitiator p_data_master;

    EventSingle       e_inst_response;
    EventSingle       e_data_response;
    IntParameter      m_response_pipeline_depth;
    Array<Response>   m_inst_responses;
    Array<Response>   m_data_responses;
    Gated<Request>    m_inst_req;
    Gated<Request>    m_data_req;
  };
}

#endif
bool read_hit(const Address& address)
{
  return (cacheable(address) && sampa_rand01() >=  m_read_miss_ratio);
}

bool inst_hit(const Address& address)
{
  return (cacheable(address) && sampa_rand01() >=  m_inst_miss_ratio);
}

bool write_hit(const Address& address)
{
  return (cacheable(address) && sampa_rand01() >=  m_write_miss_ratio);
}

bool eviction_hit(const Address& address)
{
  return (cacheable(address) && sampa_rand01() >= m_eviction_miss_ratio);
}

void process_data()
{
  switch (state) {
    case EVALUATE:
      if (request.get_command() == READ) {
        // linefill
        if (read_hit(request.get_address())) {
          state = READ_HIT;
          e_forward.notify_in_n_rising(2);
          set_next_trigger(e_forward);
        } else {
          state = READ_MISS; // maybe non cacheable
          e_forward.notify_in_n_rising(1);
          set_next_trigger(e_forward);
        }
      } else if (request.get_burst() > 1) {
        // eviction from L1
        e_forward.notify_in_n_rising(1);
        set_next_trigger(e_forward);
        if (eviction_hit(request.get_address())) {
          state = EVICTION_HIT;
        } else if (m_write_though) {
          // must write
          state = EVICTION_MISS;
        } else if (eviction()) {
          // must make space for the eviction!
          state = EVICTION_BACK_EVICTION;
        } else {
          // just tmp
          state = STALL_EVICTION;
        }
      } else {
        // write
        e_forward.notify_in_n_rising(1);
        set_next_trigger(e_forward);
        if (hit()) {
          state = WRITE_HIT;
        } else if (m_write_through) {
          state = WRITE_MISS;
        } else {
          // need to fill cache first, before writing
          m_write_pending = true;
          state = MISS;
        }
      }
      m_burst += req.get_burst();
      if (hit()) {
        state = HIT;
        e_forward.notify_in_n_rising(2);
        set_next_trigger(e_forward);
      } else {
        state = MISS;
        e_forward.notify_in_n_rising(1);
      }
      break;
    case READ_HIT:
      set_next_trigger(p_data_slave->get_response_accepted_event());
      state = READ_HIT_NEXT;
      // no break !
    case READ_HIT_NEXT:
      p_inst_slave->send_response();
      if (m_burst-- = 0) {
        state = EVALUATE;
        p_data_slave->accept_request();
        set_next_trigger(p_data_slave->get_request_accepted_event());
      }
      break;
    case MISS:
      if (m_pending_eviction) {
        // stall until completed
        set_next_trigger();
        break;
      }
      set_next_trigger(p_inst_master->get_request_accepted_event());
      state = MISS_NEXT;
      // no break !
    case MISS_NEXT:
      p_inst_master->send_request();
      if (m_burst-- != 0) break;
      if (eviction()) {
        m_eviction_requested |= 1<<INST;
        if (m_eviction_pending > 0) {
          state = STALL_EVICTION;
          set_next_trigger(e_eviction_granted[INST]);
          break;
        }
      }
      // no break !
    case STALL_EVICTION:
      state = EVALUATE;
      p_inst_slave->accept_request();
      set_next_trigger(p_inst_slave->get_request_accepted_event());
      break; 
  }
}

void forward_data_request()
{
  if (m_linefill_pending) {
    p_data_master->send_request();
    if (--m_linefill_pending == 0) {
      set_next_trigger(e_data_req_forward);
      if (m_eviction_requested != NONE)
        e_data_req_forward.notify_next_cycle();
    }
  } else if (m_eviction_pending > 0) {
    p_data_master->send_request();
    if (--m_eviction_pending == 0) {
      set_next_trigger(e_data_req_forward);
      if (m_eviction_requested != NONE)
        e_data_req_forward.notify_next_cycle();
    }
  } else if (m_linefill_requested) {
    m_linefill_pending = m_linefill_req.get_burst() - 1;
    p_data_master->send_request(m_linefill_req);
    set_next_trigger(p_data_master->get_request_accepted_event());
  } else if (m_eviction_requested) {
    m_eviction_elected = 1 - m_eviction_elected;
    if (!(m_eviction_requested&(1+m_eviction_elected)))
      m_eviction_elected = 1 - m_eviction_elected);
    m_eviction_requested &= ~(1+m_eviction_elected);     // deassert
    e_eviction_granted[m_eviction_elected].notify_next_cycle(); // unblock if stalled
    m_eviction_pending = m_eviction_req.get_burst() - 1;
    p_data_master->send_request(m_eviction_req);
    set_next_trigger(p_data_master->get_request_accepted_event());
  }
}

void process_inst()
{
  switch (state) {
    case EVALUATE:
      m_burst += req.get_burst();
      if (hit()) {
        state = HIT;
        e_forward.notify_in_n_rising(2); // hit calc + line read buffer fill
        set_next_trigger(e_forward);
      } else {
        state = MISS;
        e_forward.notify_in_n_rising(1); // hit calc
      }
      break;
    case HIT:
      set_next_trigger(p_inst_slave->get_response_accepted_event());
      state = HIT_NEXT;
      // no break !
    case HIT_NEXT:
      p_inst_slave->send_response();
      if (m_burst-- = 0) {
        state = EVALUATE;
        p_inst_master->accept_request();
        set_next_trigger(p_inst_master->get_request_accepted_event());
      }
      break;
    case MISS:
      set_next_trigger(p_inst_master->get_request_accepted_event());
      state = MISS_NEXT;
      // no break !
    case MISS_NEXT:
      p_inst_master->send_request();
      if (m_burst-- != 0) break;
      if (eviction()) {
        m_eviction_requested |= 1<<INST;
        if (m_eviction_pending > 0) {
          state = STALL_EVICTION;
          set_next_trigger(e_eviction_granted[INST]);
          break;
        }
      }
      // no break !
    case STALL_EVICTION:
      state = EVALUATE;
      p_inst_slave->accept_request();
      set_next_trigger(p_inst_slave->get_request_accepted_event());
      break; 
  }
}

---