Subversion Repositories openrisc

//==========================================================================

//

//      instrmnt/meminst.cxx

//

//      Memory buffer instrumentation functions

//

//==========================================================================

// ####ECOSGPLCOPYRIGHTBEGIN####                                            

// -------------------------------------------                              

// This file is part of eCos, the Embedded Configurable Operating System.   

// Copyright (C) 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.

//

// eCos 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 2 or (at your option) any later      

// version.                                                                 

//

// eCos 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 eCos; if not, write to the Free Software Foundation, Inc.,    

// 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.            

//

// As a special exception, if other files instantiate templates or use      

// macros or inline functions from this file, or you compile this file      

// and link it with other works to produce a work based on this file,       

// this file does not by itself cause the resulting work to be covered by   

// the GNU General Public License. However the source code for this file    

// must still be made available in accordance with section (3) of the GNU   

// General Public License v2.                                               

//

// This exception does not invalidate any other reasons why a work based    

// on this file might be covered by the GNU General Public License.         

// -------------------------------------------                              

// ####ECOSGPLCOPYRIGHTEND####                                              

//==========================================================================

//#####DESCRIPTIONBEGIN####

//

// Author(s):   nickg

// Contributors: nickg, andrew.lunn@ascom.ch

// Date:        1997-10-27

// Purpose:     Instrumentation functions

// Description: The functions in this file are implementations of the

//              standard instrumentation functions that place records

//              into a memory buffer.

//

//####DESCRIPTIONEND####

//

//==========================================================================

#include <pkgconf/kernel.h>

#include <cyg/kernel/ktypes.h>         // base kernel types

#include <cyg/infra/cyg_trac.h>        // tracing macros

#include <cyg/infra/cyg_ass.h>         // assertion macros

#include <cyg/kernel/instrmnt.h>       // instrumentation

#include <cyg/kernel/intr.hxx>         // interrupt control

#include <cyg/kernel/sched.hxx>        // scheduler defines

#include <cyg/kernel/sched.inl>        // scheduler inlines

#include <cyg/kernel/clock.inl>        // clock inlines

#ifdef CYGPKG_KERNEL_INSTRUMENT

// -------------------------------------------------------------------------

// Instrumentation record.

struct Instrument_Record

{

    CYG_WORD16  type;                   // record type

    CYG_WORD16  thread;                 // current thread id

    CYG_WORD    timestamp;              // 32 bit timestamp

    CYG_WORD    arg1;                   // first arg

    CYG_WORD    arg2;                   // second arg

};

// -------------------------------------------------------------------------

// Buffer base and end. This buffer must be a whole number of 

#ifdef CYGVAR_KERNEL_INSTRUMENT_EXTERNAL_BUFFER

externC Instrument_Record       instrument_buffer[];

externC cyg_uint32              instrument_buffer_size;

#else

extern "C"

{

Instrument_Record       instrument_buffer[CYGNUM_KERNEL_INSTRUMENT_BUFFER_SIZE];

cyg_uint32              instrument_buffer_size = CYGNUM_KERNEL_INSTRUMENT_BUFFER_SIZE;

};

#endif

extern "C"

{

#define instrument_buffer_start instrument_buffer[0]

#define instrument_buffer_end   instrument_buffer[instrument_buffer_size]

extern "C"

{

Instrument_Record       *instrument_buffer_pointer = &instrument_buffer_start;

};

#ifdef CYGDBG_KERNEL_INSTRUMENT_FLAGS

// This array contains a 32 bit word for each event class. The

// bits in the word correspond to events. By setting or clearing

// the appropriate bit, the selected instrumentation event may

// be enabled or disabled dynamically.

cyg_uint32 instrument_flags[(CYG_INSTRUMENT_CLASS_MAX>>8)+1];

#endif

};

// -------------------------------------------------------------------------

#ifdef CYGPKG_KERNEL_SMP_SUPPORT

HAL_SPINLOCK_TYPE instrument_lock = HAL_SPINLOCK_INIT_CLEAR;

#else

#define HAL_SPINLOCK_SPIN( __lock )

#define HAL_SPINLOCK_CLEAR( __lock )

#endif

// -------------------------------------------------------------------------

void cyg_instrument( cyg_uint32 type, CYG_ADDRWORD arg1, CYG_ADDRWORD arg2 )

{

    cyg_uint32 old_ints;

#ifdef CYGDBG_KERNEL_INSTRUMENT_FLAGS    

    cyg_ucount8 cl = (type>>8)&0xff;

    cyg_ucount8 event = type&0xff;

    if( instrument_flags[cl] & (1<<event) )

#endif        

    {

        HAL_DISABLE_INTERRUPTS(old_ints);

        HAL_SPINLOCK_SPIN( instrument_lock );

        Instrument_Record *p = instrument_buffer_pointer;

        Cyg_Thread *t = Cyg_Scheduler::get_current_thread();

        p->type             = type;

        p->thread           = (t==0)?0x0FFF:t->get_unique_id();

#ifdef CYGPKG_KERNEL_SMP_SUPPORT

        // Add CPU id to in top 4 bytes of thread id

        p->thread           = (p->thread&0x0FFF)|(CYG_KERNEL_CPU_THIS()<<12);

#endif        

#ifdef CYGVAR_KERNEL_COUNTERS_CLOCK        

//        p->timestamp        = Cyg_Clock::real_time_clock->current_value_lo();

        HAL_CLOCK_READ( &p->timestamp );

#else

        p->timestamp        = 0;

#endif

        p->arg1             = arg1;

        p->arg2             = arg2;

        p++;

#ifdef CYGDBG_KERNEL_INSTRUMENT_BUFFER_WRAP

        if( p == &instrument_buffer_end )

            instrument_buffer_pointer = &instrument_buffer_start;

        else instrument_buffer_pointer = p;

#else

        // when not wrapping, just continue to put further entries

        // in the last slot.

        if( p != &instrument_buffer_end )

            instrument_buffer_pointer = p;

#endif

        HAL_SPINLOCK_CLEAR( instrument_lock );

        HAL_RESTORE_INTERRUPTS(old_ints);

    }

    return;

}

// -------------------------------------------------------------------------

// Functions to enable and disable selected instrumentation events

// when the flags are enabled.

#ifdef CYGDBG_KERNEL_INSTRUMENT_FLAGS

externC void cyg_instrument_enable( cyg_uint32 cl, cyg_uint32 event)

{

    if( 0 != event )

        instrument_flags[cl>>8] |= 1<<event;

    else

        instrument_flags[cl>>8] = ~0;

}

externC void cyg_instrument_disable( cyg_uint32 cl, cyg_uint32 event)

{

    if( 0 != event )

        instrument_flags[cl>>8] &= ~(1<<event);

    else

        instrument_flags[cl>>8] = 0;

}

externC cyg_bool cyg_instrument_state( cyg_uint32 cl, cyg_uint32 event)

{

    return (instrument_flags[cl>>8] & (1<<event)) != 0;

}

#endif

// -------------------------------------------------------------------------

#ifdef CYGDBG_KERNEL_INSTRUMENT_MSGS

#define CYGDBG_KERNEL_INSTRUMENT_MSGS_DEFINE_TABLE

#include <cyg/kernel/instrument_desc.h>

externC char * cyg_instrument_msg(CYG_WORD16 type) {

  struct instrument_desc_s *record;

  struct instrument_desc_s *end_record;

  CYG_WORD cl, event;

  record = instrument_desc;

  end_record = &instrument_desc[CYG_NELEM(instrument_desc)-1];

  cl = type & 0xff00;

  event = type & 0x00ff;

  while ((record != end_record) && (record->num != cl)) {

    record++;

  }

  if (record->num == cl) {

    record++;

    while ((record != end_record) && (record->num != event) &&

           (record->num < 0xff)) {

      record++;

    }

    if (record->num == event) {

      return (record->msg);

    }

  }

  return("Unknown event");

}

#endif // CYGDBG_KERNEL_INSTRUMENT_MSGS

#endif // CYGPKG_KERNEL_INSTRUMENT

// EOF instrmnt/meminst.cxx