Subversion Repositories openrisc

/* pcu.c -- Simulation of OR1k performance counters

   Copyright (C) 2011 Julius Baxter, julius@opencores.org

   This file is part of Or1ksim, the OpenRISC 1000 Architectural Simulator.

   This program is free software; you can redistribute it and/or modify it

   under the terms of the GNU General Public License as published by the Free

   Software Foundation; either version 3 of the License, or (at your option)

   any later version.

   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, see <http://www.gnu.org/licenses/>.  */

/* This program is commented throughout in a fashion suitable for processing

   with Doxygen. */

#include "config.h"

#include "sim-config.h"

#include "execute.h"

#include "pcu.h"

/*---------------------------------------------------------------------------*/

/*!Increment a PCCR depending on the event

   Check the event, see if any PCMRs are set to increment, and permissions and

   increment the corresponding PCCR.

   The performance counters unit relies on a call to pcu_count_event()

   being placed a the appropriate place elsewhere in the simulator code.

   At present only instruction fetch, LSU accesses, MMU and cache misses are

   logged. Counts for other things such as stalls for LSU or fetch can

   probably be done but haven't been, yet.

   The function expects to receive the bit of the PCMR to check against for

   incrementing. See the existing use of the function in the

   cpu/common/abstract.c file which is where LSU accesses and instruction

   fetches are logged.

   @param[in] event  The event that has occurred (PCMR bit)                  */

/*---------------------------------------------------------------------------*/

void

pcu_count_event(unsigned event)

{

  int i;

  // Look through each PCMR, check if this event should be logged

  for(i=0;i<8;i++)

    if ((event & cpu_state.sprs[SPR_PCMR(i)]) &&

        // Count in SM, and SR[SM] set

        (((cpu_state.sprs[SPR_PCMR(i)] & SPR_PCMR_CISM) &&

          (cpu_state.sprs[SPR_SR] & SPR_SR_SM)) ||

         // Count in UM and SR[SM] cleared

         ((cpu_state.sprs[SPR_PCMR(i)] & SPR_PCMR_CIUM) &&

          !(cpu_state.sprs[SPR_SR] & SPR_SR_SM))))

      {

        cpu_state.sprs[SPR_PCCR(i)]++;

      }

}

/*---------------------------------------------------------------------------*/

/*!Enable or disable the performance counters unit

   Set the corresponding field in the UPR, set present bit in all PCMRs

   @param[in] val  The value to use

   @param[in] dat  The config data structure (not used here)                 */

/*---------------------------------------------------------------------------*/

static void

pcu_enabled (union param_val val, void *dat)

{

  if (val.int_val)

    {

      cpu_state.sprs[SPR_UPR] |= SPR_UPR_PCUP;

      cpu_state.sprs[SPR_PCMR(0)] = SPR_PCMR_CP;

      cpu_state.sprs[SPR_PCMR(1)] = SPR_PCMR_CP;

      cpu_state.sprs[SPR_PCMR(2)] = SPR_PCMR_CP;

      cpu_state.sprs[SPR_PCMR(3)] = SPR_PCMR_CP;

      cpu_state.sprs[SPR_PCMR(4)] = SPR_PCMR_CP;

      cpu_state.sprs[SPR_PCMR(5)] = SPR_PCMR_CP;

      cpu_state.sprs[SPR_PCMR(6)] = SPR_PCMR_CP;

      cpu_state.sprs[SPR_PCMR(7)] = SPR_PCMR_CP;

    }

  else

    {

      cpu_state.sprs[SPR_UPR] &= ~SPR_UPR_PCUP;

    }

  config.pcu.enabled = val.int_val;

}       /* pcu_enabled() */

/*---------------------------------------------------------------------------*/

/*!Register the configuration functions for the performance counters unit    */

/*---------------------------------------------------------------------------*/

void

reg_pcu_sec ()

{

  struct config_section *sec = reg_config_sec ("pcu", NULL, NULL);

  reg_config_param (sec, "enabled",     PARAMT_INT, pcu_enabled);

}       /* reg_pcu_sec () */