OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

Compare Revisions

  • This comparison shows the changes necessary to convert path 
    /openrisc/trunk/rtos/ecos-2.0/packages/kernel/v2_0/src/instrmnt
    from Rev 27 to Rev 174
    ↔ Reverse comparison
  •

Rev 27 → Rev 174

/meminst.cxx
0,0 → 1,261
//==========================================================================
//
// 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 Red Hat, 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.,
// 59 Temple Place, Suite 330, Boston, MA 02111-1307 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.
//
// This exception does not invalidate any other reasons why a work based on
// this file might be covered by the GNU General Public License.
//
// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc.
// at http://sources.redhat.com/ecos/ecos-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>
#define NELEM(x) (sizeof(x)/sizeof*(x))
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[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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.